1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 #ifndef SET_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
10 #define SET_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
11 
12 // <set>
13 // <unordered_set>
14 
15 // class set
16 // class unordered_set
17 
18 // insert(...);
19 // emplace(...);
20 // emplace_hint(...);
21 
22 
23 #include <cassert>
24 
25 #include "test_macros.h"
26 #include "count_new.hpp"
27 #include "container_test_types.h"
28 #include "assert_checkpoint.h"
29 
30 
31 template <class Container>
testSetInsert()32 void testSetInsert()
33 {
34   typedef typename Container::value_type ValueTp;
35   ConstructController* cc = getConstructController();
36   cc->reset();
37   {
38     CHECKPOINT("Testing C::insert(const value_type&)");
39     Container c;
40     const ValueTp v(42);
41     cc->expect<const ValueTp&>();
42     assert(c.insert(v).second);
43     assert(!cc->unchecked());
44     {
45       DisableAllocationGuard g;
46       const ValueTp v2(42);
47       assert(c.insert(v2).second == false);
48     }
49   }
50   {
51     CHECKPOINT("Testing C::insert(value_type&)");
52     Container c;
53     ValueTp v(42);
54     cc->expect<const ValueTp&>();
55     assert(c.insert(v).second);
56     assert(!cc->unchecked());
57     {
58       DisableAllocationGuard g;
59       ValueTp v2(42);
60       assert(c.insert(v2).second == false);
61     }
62   }
63   {
64     CHECKPOINT("Testing C::insert(value_type&&)");
65     Container c;
66     ValueTp v(42);
67     cc->expect<ValueTp&&>();
68     assert(c.insert(std::move(v)).second);
69     assert(!cc->unchecked());
70     {
71       DisableAllocationGuard g;
72       ValueTp v2(42);
73       assert(c.insert(std::move(v2)).second == false);
74     }
75   }
76   {
77     CHECKPOINT("Testing C::insert(const value_type&&)");
78     Container c;
79     const ValueTp v(42);
80     cc->expect<const ValueTp&>();
81     assert(c.insert(std::move(v)).second);
82     assert(!cc->unchecked());
83     {
84       DisableAllocationGuard g;
85       const ValueTp v2(42);
86       assert(c.insert(std::move(v2)).second == false);
87     }
88   }
89   {
90     CHECKPOINT("Testing C::insert(std::initializer_list<ValueTp>)");
91     Container c;
92     std::initializer_list<ValueTp> il = { ValueTp(1), ValueTp(2) };
93     cc->expect<ValueTp const&>(2);
94     c.insert(il);
95     assert(!cc->unchecked());
96     {
97       DisableAllocationGuard g;
98       c.insert(il);
99     }
100   }
101   {
102     CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type const&");
103     Container c;
104     const ValueTp ValueList[] = { ValueTp(1), ValueTp(2), ValueTp(3) };
105     cc->expect<ValueTp const&>(3);
106     c.insert(std::begin(ValueList), std::end(ValueList));
107     assert(!cc->unchecked());
108     {
109       DisableAllocationGuard g;
110       c.insert(std::begin(ValueList), std::end(ValueList));
111     }
112   }
113   {
114     CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&&");
115     Container c;
116     ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) };
117     cc->expect<ValueTp&&>(3);
118     c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)),
119              std::move_iterator<ValueTp*>(std::end(ValueList)));
120     assert(!cc->unchecked());
121     {
122       DisableAllocationGuard g;
123       ValueTp ValueList2[] = { ValueTp(1), ValueTp(2) , ValueTp(3) };
124       c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList2)),
125                std::move_iterator<ValueTp*>(std::end(ValueList2)));
126     }
127   }
128   {
129     CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&");
130     Container c;
131     ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) };
132     cc->expect<ValueTp const&>(3);
133     c.insert(std::begin(ValueList), std::end(ValueList));
134     assert(!cc->unchecked());
135     {
136       DisableAllocationGuard g;
137       c.insert(std::begin(ValueList), std::end(ValueList));
138     }
139   }
140 }
141 
142 
143 template <class Container>
testSetEmplace()144 void testSetEmplace()
145 {
146   typedef typename Container::value_type ValueTp;
147   ConstructController* cc = getConstructController();
148   cc->reset();
149   {
150     CHECKPOINT("Testing C::emplace(const value_type&)");
151     Container c;
152     const ValueTp v(42);
153     cc->expect<const ValueTp&>();
154     assert(c.emplace(v).second);
155     assert(!cc->unchecked());
156     {
157       DisableAllocationGuard g;
158       const ValueTp v2(42);
159       assert(c.emplace(v2).second == false);
160     }
161   }
162   {
163     CHECKPOINT("Testing C::emplace(value_type&)");
164     Container c;
165     ValueTp v(42);
166     cc->expect<ValueTp&>();
167     assert(c.emplace(v).second);
168     assert(!cc->unchecked());
169     {
170       DisableAllocationGuard g;
171       ValueTp v2(42);
172       assert(c.emplace(v2).second == false);
173     }
174   }
175   {
176     CHECKPOINT("Testing C::emplace(value_type&&)");
177     Container c;
178     ValueTp v(42);
179     cc->expect<ValueTp&&>();
180     assert(c.emplace(std::move(v)).second);
181     assert(!cc->unchecked());
182     {
183       DisableAllocationGuard g;
184       ValueTp v2(42);
185       assert(c.emplace(std::move(v2)).second == false);
186     }
187   }
188   {
189     CHECKPOINT("Testing C::emplace(const value_type&&)");
190     Container c;
191     const ValueTp v(42);
192     cc->expect<const ValueTp&&>();
193     assert(c.emplace(std::move(v)).second);
194     assert(!cc->unchecked());
195     {
196       DisableAllocationGuard g;
197       const ValueTp v2(42);
198       assert(c.emplace(std::move(v2)).second == false);
199     }
200   }
201 }
202 
203 
204 template <class Container>
testSetEmplaceHint()205 void testSetEmplaceHint()
206 {
207   typedef typename Container::value_type ValueTp;
208   typedef Container C;
209   typedef typename C::iterator It;
210   ConstructController* cc = getConstructController();
211   cc->reset();
212   {
213     CHECKPOINT("Testing C::emplace_hint(p, const value_type&)");
214     Container c;
215     const ValueTp v(42);
216     cc->expect<const ValueTp&>();
217     It ret = c.emplace_hint(c.end(), v);
218     assert(ret != c.end());
219     assert(c.size() == 1);
220     assert(!cc->unchecked());
221     {
222       DisableAllocationGuard g;
223       const ValueTp v2(42);
224       It ret2 = c.emplace_hint(c.begin(), v2);
225       assert(&(*ret2) == &(*ret));
226       assert(c.size() == 1);
227     }
228   }
229   {
230     CHECKPOINT("Testing C::emplace_hint(p, value_type&)");
231     Container c;
232     ValueTp v(42);
233     cc->expect<ValueTp&>();
234     It ret = c.emplace_hint(c.end(), v);
235     assert(ret != c.end());
236     assert(c.size() == 1);
237     assert(!cc->unchecked());
238     {
239       DisableAllocationGuard g;
240       ValueTp v2(42);
241       It ret2 = c.emplace_hint(c.begin(), v2);
242       assert(&(*ret2) == &(*ret));
243       assert(c.size() == 1);
244     }
245   }
246   {
247     CHECKPOINT("Testing C::emplace_hint(p, value_type&&)");
248     Container c;
249     ValueTp v(42);
250     cc->expect<ValueTp&&>();
251     It ret = c.emplace_hint(c.end(), std::move(v));
252     assert(ret != c.end());
253     assert(c.size() == 1);
254     assert(!cc->unchecked());
255     {
256       DisableAllocationGuard g;
257       ValueTp v2(42);
258       It ret2 = c.emplace_hint(c.begin(), std::move(v2));
259       assert(&(*ret2) == &(*ret));
260       assert(c.size() == 1);
261     }
262   }
263   {
264     CHECKPOINT("Testing C::emplace_hint(p, const value_type&&)");
265     Container c;
266     const ValueTp v(42);
267     cc->expect<const ValueTp&&>();
268     It ret = c.emplace_hint(c.end(), std::move(v));
269     assert(ret != c.end());
270     assert(c.size() == 1);
271     assert(!cc->unchecked());
272     {
273       DisableAllocationGuard g;
274       const ValueTp v2(42);
275       It ret2 = c.emplace_hint(c.begin(), std::move(v2));
276       assert(&(*ret2) == &(*ret));
277       assert(c.size() == 1);
278     }
279   }
280 }
281 
282 
283 template <class Container>
testMultisetInsert()284 void testMultisetInsert()
285 {
286   typedef typename Container::value_type ValueTp;
287   ConstructController* cc = getConstructController();
288   cc->reset();
289   {
290     CHECKPOINT("Testing C::insert(const value_type&)");
291     Container c;
292     const ValueTp v(42);
293     cc->expect<const ValueTp&>();
294     c.insert(v);
295     assert(!cc->unchecked());
296   }
297   {
298     CHECKPOINT("Testing C::insert(value_type&)");
299     Container c;
300     ValueTp v(42);
301     cc->expect<const ValueTp&>();
302     c.insert(v);
303     assert(!cc->unchecked());
304   }
305   {
306     CHECKPOINT("Testing C::insert(value_type&&)");
307     Container c;
308     ValueTp v(42);
309     cc->expect<ValueTp&&>();
310     c.insert(std::move(v));
311     assert(!cc->unchecked());
312   }
313   {
314     CHECKPOINT("Testing C::insert(std::initializer_list<ValueTp>)");
315     Container c;
316     std::initializer_list<ValueTp> il = { ValueTp(1), ValueTp(2) };
317     cc->expect<ValueTp const&>(2);
318     c.insert(il);
319     assert(!cc->unchecked());
320   }
321   {
322     CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type const&");
323     Container c;
324     const ValueTp ValueList[] = { ValueTp(1), ValueTp(2), ValueTp(3) };
325     cc->expect<ValueTp const&>(3);
326     c.insert(std::begin(ValueList), std::end(ValueList));
327     assert(!cc->unchecked());
328   }
329   {
330     CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&&");
331     Container c;
332     ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) };
333     cc->expect<ValueTp&&>(3);
334     c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)),
335              std::move_iterator<ValueTp*>(std::end(ValueList)));
336     assert(!cc->unchecked());
337   }
338   {
339     CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&");
340     Container c;
341     ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(1) };
342     cc->expect<ValueTp&>(3);
343     c.insert(std::begin(ValueList), std::end(ValueList));
344     assert(!cc->unchecked());
345   }
346 }
347 
348 
349 template <class Container>
testMultisetEmplace()350 void testMultisetEmplace()
351 {
352   typedef typename Container::value_type ValueTp;
353   ConstructController* cc = getConstructController();
354   cc->reset();
355   {
356     CHECKPOINT("Testing C::emplace(const value_type&)");
357     Container c;
358     const ValueTp v(42);
359     cc->expect<const ValueTp&>();
360     c.emplace(v);
361     assert(!cc->unchecked());
362   }
363   {
364     CHECKPOINT("Testing C::emplace(value_type&)");
365     Container c;
366     ValueTp v(42);
367     cc->expect<ValueTp&>();
368     c.emplace(v);
369     assert(!cc->unchecked());
370   }
371   {
372     CHECKPOINT("Testing C::emplace(value_type&&)");
373     Container c;
374     ValueTp v(42);
375     cc->expect<ValueTp&&>();
376     c.emplace(std::move(v));
377     assert(!cc->unchecked());
378   }
379   {
380     CHECKPOINT("Testing C::emplace(const value_type&&)");
381     Container c;
382     const ValueTp v(42);
383     cc->expect<const ValueTp&&>();
384     c.emplace(std::move(v));
385     assert(!cc->unchecked());
386   }
387 }
388 
389 #endif
390