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 // <deque>
10
11 // template <class InputIterator>
12 // void assign(InputIterator f, InputIterator l);
13
14 #include <deque>
15 #include <cassert>
16 #include <cstddef>
17
18 #include "test_macros.h"
19 #include "test_iterators.h"
20 #include "min_allocator.h"
21 #if TEST_STD_VER >= 11
22 #include "emplace_constructible.h"
23 #endif
24
25 template <class C>
26 C
make(int size,int start=0)27 make(int size, int start = 0 )
28 {
29 const int b = 4096 / sizeof(int);
30 int init = 0;
31 if (start > 0)
32 {
33 init = (start+1) / b + ((start+1) % b != 0);
34 init *= b;
35 --init;
36 }
37 C c(init, 0);
38 for (int i = 0; i < init-start; ++i)
39 c.pop_back();
40 for (int i = 0; i < size; ++i)
41 c.push_back(i);
42 for (int i = 0; i < start; ++i)
43 c.pop_front();
44 return c;
45 }
46
47 template <class C>
48 void
test(C & c1,const C & c2)49 test(C& c1, const C& c2)
50 {
51 c1.assign(c2.begin(), c2.end());
52 assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
53 assert(c1 == c2);
54 }
55
56 template <class C>
57 void
testN(int start,int N,int M)58 testN(int start, int N, int M)
59 {
60 C c1 = make<C>(N, start);
61 C c2 = make<C>(M);
62 test(c1, c2);
63 }
64
65 template <class C>
66 void
testI(C & c1,const C & c2)67 testI(C& c1, const C& c2)
68 {
69 typedef typename C::const_iterator CI;
70 typedef cpp17_input_iterator<CI> ICI;
71 c1.assign(ICI(c2.begin()), ICI(c2.end()));
72 assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
73 assert(c1 == c2);
74 }
75
76 template <class C>
77 void
testNI(int start,int N,int M)78 testNI(int start, int N, int M)
79 {
80 C c1 = make<C>(N, start);
81 C c2 = make<C>(M);
82 testI(c1, c2);
83 }
84
basic_test()85 void basic_test()
86 {
87 {
88 int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
89 const int N = sizeof(rng)/sizeof(rng[0]);
90 for (int i = 0; i < N; ++i)
91 for (int j = 0; j < N; ++j)
92 for (int k = 0; k < N; ++k)
93 testN<std::deque<int> >(rng[i], rng[j], rng[k]);
94 testNI<std::deque<int> >(1500, 2000, 1000);
95 }
96 #if TEST_STD_VER >= 11
97 {
98 int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
99 const int N = sizeof(rng)/sizeof(rng[0]);
100 for (int i = 0; i < N; ++i)
101 for (int j = 0; j < N; ++j)
102 for (int k = 0; k < N; ++k)
103 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
104 testNI<std::deque<int, min_allocator<int>> >(1500, 2000, 1000);
105 }
106 #endif
107 }
108
test_emplacable_concept()109 void test_emplacable_concept() {
110 #if TEST_STD_VER >= 11
111 int arr1[] = {42};
112 int arr2[] = {1, 101, 42};
113 {
114 using T = EmplaceConstructibleMoveableAndAssignable<int>;
115 using It = random_access_iterator<int*>;
116 {
117 std::deque<T> v;
118 v.assign(It(arr1), It(std::end(arr1)));
119 assert(v[0].value == 42);
120 }
121 {
122 std::deque<T> v;
123 v.assign(It(arr2), It(std::end(arr2)));
124 assert(v[0].value == 1);
125 assert(v[1].value == 101);
126 assert(v[2].value == 42);
127 }
128 }
129 {
130 using T = EmplaceConstructibleMoveableAndAssignable<int>;
131 using It = cpp17_input_iterator<int*>;
132 {
133 std::deque<T> v;
134 v.assign(It(arr1), It(std::end(arr1)));
135 assert(v[0].copied == 0);
136 assert(v[0].value == 42);
137 }
138 {
139 std::deque<T> v;
140 v.assign(It(arr2), It(std::end(arr2)));
141 //assert(v[0].copied == 0);
142 assert(v[0].value == 1);
143 //assert(v[1].copied == 0);
144 assert(v[1].value == 101);
145 assert(v[2].copied == 0);
146 assert(v[2].value == 42);
147 }
148 }
149 #endif
150 }
151
main(int,char **)152 int main(int, char**) {
153 basic_test();
154 test_emplacable_concept();
155
156 return 0;
157 }
158