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 <queue>
20 #include <list>
21 #include <iterator>
22 #include <cassert>
23 #include <cstddef>
24 #include <climits> // INT_MAX
25
26 #include "test_macros.h"
27 #include "test_iterators.h"
28 #include "test_allocator.h"
29
30 struct A {};
31
main(int,char **)32 int main(int, char**)
33 {
34
35 // Test the explicit deduction guides
36 {
37 std::list<int> l{0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
38 std::queue que(l);
39
40 static_assert(std::is_same_v<decltype(que), std::queue<int, std::list<int>>>, "");
41 assert(que.size() == l.size());
42 assert(que.back() == l.back());
43 }
44
45 {
46 std::list<long, test_allocator<long>> l{10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
47 std::queue que(l, test_allocator<long>(0,2)); // different allocator
48 static_assert(std::is_same_v<decltype(que)::container_type, std::list<long, test_allocator<long>>>, "");
49 static_assert(std::is_same_v<decltype(que)::value_type, long>, "");
50 assert(que.size() == 10);
51 assert(que.back() == 19);
52 // I'd like to assert that we've gotten the right allocator in the queue, but
53 // I don't know how to get at the underlying container.
54 }
55
56 // Test the implicit deduction guides
57 {
58 // We don't expect this one to work - no way to implicitly get value_type
59 // std::queue que(std::allocator<int>()); // queue (allocator &)
60 }
61
62 {
63 std::queue<A> source;
64 std::queue que(source); // queue(queue &)
65 static_assert(std::is_same_v<decltype(que)::value_type, A>, "");
66 static_assert(std::is_same_v<decltype(que)::container_type, std::deque<A>>, "");
67 assert(que.size() == 0);
68 }
69
70 {
71 typedef short T;
72 typedef test_allocator<T> Alloc;
73 typedef std::list<T, Alloc> Cont;
74 typedef test_allocator<int> ConvertibleToAlloc;
75 static_assert(std::uses_allocator_v<Cont, ConvertibleToAlloc> &&
76 !std::is_same_v<typename Cont::allocator_type, ConvertibleToAlloc>);
77
78 {
79 Cont cont;
80 std::queue que(cont, Alloc(2));
81 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
82 }
83
84 {
85 Cont cont;
86 std::queue que(cont, ConvertibleToAlloc(2));
87 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
88 }
89
90 {
91 Cont cont;
92 std::queue que(std::move(cont), Alloc(2));
93 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
94 }
95
96 {
97 Cont cont;
98 std::queue que(std::move(cont), ConvertibleToAlloc(2));
99 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
100 }
101 }
102
103 {
104 typedef short T;
105 typedef test_allocator<T> Alloc;
106 typedef std::list<T, Alloc> Cont;
107 typedef test_allocator<int> ConvertibleToAlloc;
108 static_assert(std::uses_allocator_v<Cont, ConvertibleToAlloc> &&
109 !std::is_same_v<typename Cont::allocator_type, ConvertibleToAlloc>);
110
111 {
112 std::queue<T, Cont> source;
113 std::queue que(source, Alloc(2));
114 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
115 }
116
117 {
118 std::queue<T, Cont> source;
119 std::queue que(source, ConvertibleToAlloc(2));
120 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
121 }
122
123 {
124 std::queue<T, Cont> source;
125 std::queue que(std::move(source), Alloc(2));
126 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
127 }
128
129 {
130 std::queue<T, Cont> source;
131 std::queue que(std::move(source), ConvertibleToAlloc(2));
132 static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
133 }
134 }
135
136 return 0;
137 }
138