1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // <queue>
10 // UNSUPPORTED: c++03, c++11, c++14
11
12 // template<class Container>
13 // queue(Container) -> queue<typename Container::value_type, Container>;
14 //
15 // template<class Container, class Allocator>
16 // queue(Container, Allocator) -> queue<typename Container::value_type, Container>;
17
18
19 #include <array>
20 #include <queue>
21 #include <list>
22 #include <iterator>
23 #include <cassert>
24 #include <cstddef>
25
26 #include "deduction_guides_sfinae_checks.h"
27 #include "test_macros.h"
28 #include "test_iterators.h"
29 #include "test_allocator.h"
30
31 struct A {};
32
main(int,char **)33 int main(int, char**)
34 {
35
36 // Test the explicit deduction guides
37 {
38 std::list<int> l{0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
39 std::queue que(l);
40
41 static_assert(std::is_same_v<decltype(que), std::queue<int, std::list<int>>>, "");
42 assert(que.size() == l.size());
43 assert(que.back() == l.back());
44 }
45
46 {
47 std::list<long, test_allocator<long>> l{10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
48 std::queue que(l, test_allocator<long>(0,2)); // different allocator
49 static_assert(std::is_same_v<decltype(que)::container_type, std::list<long, test_allocator<long>>>, "");
50 static_assert(std::is_same_v<decltype(que)::value_type, long>, "");
51 assert(que.size() == 10);
52 assert(que.back() == 19);
53 // I'd like to assert that we've gotten the right allocator in the queue, but
54 // I don't know how to get at the underlying container.
55 }
56
57 // Test the implicit deduction guides
58 {
59 // We don't expect this one to work - no way to implicitly get value_type
60 // std::queue que(std::allocator<int>()); // queue (allocator &)
61 }
62
63 {
64 std::queue<A> source;
65 std::queue que(source); // queue(queue &)
66 static_assert(std::is_same_v<decltype(que)::value_type, A>, "");
67 static_assert(std::is_same_v<decltype(que)::container_type, std::deque<A>>, "");
68 assert(que.size() == 0);
69 }
70
71 {
72 typedef short T;
73 typedef test_allocator<T> Alloc;
74 typedef std::list<T, Alloc> Cont;
75 typedef test_allocator<int> ConvertibleToAlloc;
76 static_assert(std::uses_allocator_v<Cont, ConvertibleToAlloc> &&
77 !std::is_same_v<typename Cont::allocator_type, ConvertibleToAlloc>);
78
79 {
80 Cont cont;
81 std::queue que(cont, Alloc(2));
82 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
83 }
84
85 {
86 Cont cont;
87 std::queue que(cont, ConvertibleToAlloc(2));
88 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
89 }
90
91 {
92 Cont cont;
93 std::queue que(std::move(cont), Alloc(2));
94 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
95 }
96
97 {
98 Cont cont;
99 std::queue que(std::move(cont), ConvertibleToAlloc(2));
100 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
101 }
102 }
103
104 {
105 typedef short T;
106 typedef test_allocator<T> Alloc;
107 typedef std::list<T, Alloc> Cont;
108 typedef test_allocator<int> ConvertibleToAlloc;
109 static_assert(std::uses_allocator_v<Cont, ConvertibleToAlloc> &&
110 !std::is_same_v<typename Cont::allocator_type, ConvertibleToAlloc>);
111
112 {
113 std::queue<T, Cont> source;
114 std::queue que(source, Alloc(2));
115 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
116 }
117
118 {
119 std::queue<T, Cont> source;
120 std::queue que(source, ConvertibleToAlloc(2));
121 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
122 }
123
124 {
125 std::queue<T, Cont> source;
126 std::queue que(std::move(source), Alloc(2));
127 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
128 }
129
130 {
131 std::queue<T, Cont> source;
132 std::queue que(std::move(source), ConvertibleToAlloc(2));
133 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
134 }
135 }
136
137 // Deduction guides should be SFINAE'd away when given:
138 // - a "bad" allocator (that is, a type not qualifying as an allocator);
139 // - an allocator instead of a container;
140 // - an allocator and a container that uses a different allocator.
141 {
142 using Cont = std::list<int>;
143 using Alloc = std::allocator<int>;
144 using DiffAlloc = test_allocator<int>;
145 using Iter = int*;
146
147 struct NotIter{};
148 struct NotAlloc {};
149
150 static_assert(SFINAEs_away<std::queue, Alloc, NotAlloc>);
151 static_assert(SFINAEs_away<std::queue, Cont, NotAlloc>);
152 static_assert(SFINAEs_away<std::queue, Cont, DiffAlloc>);
153 static_assert(SFINAEs_away<std::queue, Iter, NotIter>);
154 #if TEST_STD_VER > 20
155 static_assert(SFINAEs_away<std::queue, Iter, NotIter, Alloc>);
156 static_assert(SFINAEs_away<std::queue, Iter, Iter, NotAlloc>);
157 #endif
158 }
159 #if TEST_STD_VER > 20
160 {
161 typedef short T;
162 typedef test_allocator<T> Alloc;
163 std::list<T> a;
164 {
165 std::queue q(a.begin(), a.end());
166 static_assert(std::is_same_v<decltype(q), std::queue<T>>);
167 }
168 {
169 std::queue q(a.begin(), a.end(), Alloc());
170 static_assert(std::is_same_v<decltype(q), std::queue<T, std::deque<T, Alloc>>>);
171 }
172 }
173 #endif
174 return 0;
175 }
176