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 #ifndef MAP_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
10 #define MAP_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
11
12 // <map>
13 // <unordered_map>
14
15 // class map
16 // class unordered_map
17
18 // insert(...);
19 // emplace(...);
20 // emplace_hint(...);
21
22 // UNSUPPORTED: c++03
23
24 #include <cassert>
25 #include <iterator>
26
27 #include "test_macros.h"
28 #include "count_new.h"
29 #include "container_test_types.h"
30
31
32 template <class Container>
testMapInsert()33 void testMapInsert()
34 {
35 typedef typename Container::value_type ValueTp;
36 ConstructController* cc = getConstructController();
37 cc->reset();
38 {
39 // Testing C::insert(const value_type&)
40 Container c;
41 const ValueTp v(42, 1);
42 cc->expect<const ValueTp&>();
43 assert(c.insert(v).second);
44 assert(!cc->unchecked());
45 {
46 DisableAllocationGuard g;
47 const ValueTp v2(42, 1);
48 assert(c.insert(v2).second == false);
49 }
50 }
51 {
52 // Testing C::insert(value_type&)
53 Container c;
54 ValueTp v(42, 1);
55 cc->expect<const ValueTp&>();
56 assert(c.insert(v).second);
57 assert(!cc->unchecked());
58 {
59 DisableAllocationGuard g;
60 ValueTp v2(42, 1);
61 assert(c.insert(v2).second == false);
62 }
63 }
64 {
65 // Testing C::insert(value_type&&)
66 Container c;
67 ValueTp v(42, 1);
68 cc->expect<ValueTp&&>();
69 assert(c.insert(std::move(v)).second);
70 assert(!cc->unchecked());
71 {
72 DisableAllocationGuard g;
73 ValueTp v2(42, 1);
74 assert(c.insert(std::move(v2)).second == false);
75 }
76 }
77 {
78 // Testing C::insert(const value_type&&)
79 Container c;
80 const ValueTp v(42, 1);
81 cc->expect<const ValueTp&>();
82 assert(c.insert(std::move(v)).second);
83 assert(!cc->unchecked());
84 {
85 DisableAllocationGuard g;
86 const ValueTp v2(42, 1);
87 assert(c.insert(std::move(v2)).second == false);
88 }
89 }
90 {
91 // Testing C::insert({key, value})
92 Container c;
93 cc->expect<ValueTp&&>();
94 assert(c.insert({42, 1}).second);
95 assert(!cc->unchecked());
96 {
97 DisableAllocationGuard g;
98 const ValueTp v2(42, 1);
99 assert(c.insert(std::move(v2)).second == false);
100 }
101 }
102 {
103 // Testing C::insert(std::initializer_list<ValueTp>)
104 Container c;
105 std::initializer_list<ValueTp> il = { ValueTp(1, 1), ValueTp(2, 1) };
106 cc->expect<ValueTp const&>(2);
107 c.insert(il);
108 assert(!cc->unchecked());
109 {
110 DisableAllocationGuard g;
111 c.insert(il);
112 }
113 }
114 {
115 // Testing C::insert(Iter, Iter) for *Iter = value_type const&
116 Container c;
117 const ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1), ValueTp(3, 1) };
118 cc->expect<ValueTp const&>(3);
119 c.insert(std::begin(ValueList), std::end(ValueList));
120 assert(!cc->unchecked());
121 {
122 DisableAllocationGuard g;
123 c.insert(std::begin(ValueList), std::end(ValueList));
124 }
125 }
126 {
127 // Testing C::insert(Iter, Iter) for *Iter = value_type&&
128 Container c;
129 ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
130 cc->expect<ValueTp&&>(3);
131 c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)),
132 std::move_iterator<ValueTp*>(std::end(ValueList)));
133 assert(!cc->unchecked());
134 {
135 DisableAllocationGuard g;
136 ValueTp ValueList2[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
137 c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList2)),
138 std::move_iterator<ValueTp*>(std::end(ValueList2)));
139 }
140 }
141 {
142 // Testing C::insert(Iter, Iter) for *Iter = value_type&
143 Container c;
144 ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
145 cc->expect<ValueTp const&>(3);
146 c.insert(std::begin(ValueList), std::end(ValueList));
147 assert(!cc->unchecked());
148 {
149 DisableAllocationGuard g;
150 c.insert(std::begin(ValueList), std::end(ValueList));
151 }
152 }
153 }
154
155
156 template <class Container>
testMapInsertHint()157 void testMapInsertHint()
158 {
159 typedef typename Container::value_type ValueTp;
160 typedef typename Container::key_type Key;
161 typedef typename Container::mapped_type Mapped;
162 typedef typename std::pair<Key, Mapped> NonConstKeyPair;
163 typedef Container C;
164 typedef typename C::iterator It;
165 ConstructController* cc = getConstructController();
166 cc->reset();
167 {
168 // Testing C::insert(p, const value_type&)
169 Container c;
170 const ValueTp v(42, 1);
171 cc->expect<const ValueTp&>();
172 It ret = c.insert(c.end(), v);
173 assert(ret != c.end());
174 assert(c.size() == 1);
175 assert(!cc->unchecked());
176 {
177 DisableAllocationGuard g;
178 const ValueTp v2(42, 1);
179 It ret2 = c.insert(c.begin(), v2);
180 assert(&(*ret2) == &(*ret));
181 assert(c.size() == 1);
182 }
183 }
184 {
185 // Testing C::insert(p, value_type&)
186 Container c;
187 ValueTp v(42, 1);
188 cc->expect<ValueTp const&>();
189 It ret = c.insert(c.end(), v);
190 assert(ret != c.end());
191 assert(c.size() == 1);
192 assert(!cc->unchecked());
193 {
194 DisableAllocationGuard g;
195 ValueTp v2(42, 1);
196 It ret2 = c.insert(c.begin(), v2);
197 assert(&(*ret2) == &(*ret));
198 assert(c.size() == 1);
199 }
200 }
201 {
202 // Testing C::insert(p, value_type&&)
203 Container c;
204 ValueTp v(42, 1);
205 cc->expect<ValueTp&&>();
206 It ret = c.insert(c.end(), std::move(v));
207 assert(ret != c.end());
208 assert(c.size() == 1);
209 assert(!cc->unchecked());
210 {
211 DisableAllocationGuard g;
212 ValueTp v2(42, 1);
213 It ret2 = c.insert(c.begin(), std::move(v2));
214 assert(&(*ret2) == &(*ret));
215 assert(c.size() == 1);
216 }
217 }
218 {
219 // Testing C::insert(p, {key, value})
220 Container c;
221 cc->expect<ValueTp&&>();
222 It ret = c.insert(c.end(), {42, 1});
223 assert(ret != c.end());
224 assert(c.size() == 1);
225 assert(!cc->unchecked());
226 {
227 DisableAllocationGuard g;
228 It ret2 = c.insert(c.begin(), {42, 1});
229 assert(&(*ret2) == &(*ret));
230 assert(c.size() == 1);
231 }
232 }
233 {
234 // Testing C::insert(p, const value_type&&)
235 Container c;
236 const ValueTp v(42, 1);
237 cc->expect<const ValueTp&>();
238 It ret = c.insert(c.end(), std::move(v));
239 assert(ret != c.end());
240 assert(c.size() == 1);
241 assert(!cc->unchecked());
242 {
243 DisableAllocationGuard g;
244 const ValueTp v2(42, 1);
245 It ret2 = c.insert(c.begin(), std::move(v2));
246 assert(&(*ret2) == &(*ret));
247 assert(c.size() == 1);
248 }
249 }
250 {
251 // Testing C::insert(p, pair<Key, Mapped> const&)
252 Container c;
253 const NonConstKeyPair v(42, 1);
254 cc->expect<const NonConstKeyPair&>();
255 It ret = c.insert(c.end(), v);
256 assert(ret != c.end());
257 assert(c.size() == 1);
258 assert(!cc->unchecked());
259 {
260 DisableAllocationGuard g;
261 const NonConstKeyPair v2(42, 1);
262 It ret2 = c.insert(c.begin(), v2);
263 assert(&(*ret2) == &(*ret));
264 assert(c.size() == 1);
265 }
266 }
267 {
268 // Testing C::insert(p, pair<Key, Mapped>&&)
269 Container c;
270 NonConstKeyPair v(42, 1);
271 cc->expect<NonConstKeyPair&&>();
272 It ret = c.insert(c.end(), std::move(v));
273 assert(ret != c.end());
274 assert(c.size() == 1);
275 assert(!cc->unchecked());
276 {
277 DisableAllocationGuard g;
278 NonConstKeyPair v2(42, 1);
279 It ret2 = c.insert(c.begin(), std::move(v2));
280 assert(&(*ret2) == &(*ret));
281 assert(c.size() == 1);
282 }
283 }
284
285
286 }
287
288
289 template <class Container>
testMapEmplace()290 void testMapEmplace()
291 {
292 typedef typename Container::value_type ValueTp;
293 typedef typename Container::key_type Key;
294 typedef typename Container::mapped_type Mapped;
295 typedef typename std::pair<Key, Mapped> NonConstKeyPair;
296 ConstructController* cc = getConstructController();
297 cc->reset();
298 {
299 // Testing C::emplace(const value_type&)
300 Container c;
301 const ValueTp v(42, 1);
302 cc->expect<const ValueTp&>();
303 assert(c.emplace(v).second);
304 assert(!cc->unchecked());
305 {
306 DisableAllocationGuard g;
307 const ValueTp v2(42, 1);
308 assert(c.emplace(v2).second == false);
309 }
310 }
311 {
312 // Testing C::emplace(value_type&)
313 Container c;
314 ValueTp v(42, 1);
315 cc->expect<ValueTp&>();
316 assert(c.emplace(v).second);
317 assert(!cc->unchecked());
318 {
319 DisableAllocationGuard g;
320 ValueTp v2(42, 1);
321 assert(c.emplace(v2).second == false);
322 }
323 }
324 {
325 // Testing C::emplace(value_type&&)
326 Container c;
327 ValueTp v(42, 1);
328 cc->expect<ValueTp&&>();
329 assert(c.emplace(std::move(v)).second);
330 assert(!cc->unchecked());
331 {
332 DisableAllocationGuard g;
333 ValueTp v2(42, 1);
334 assert(c.emplace(std::move(v2)).second == false);
335 }
336 }
337 {
338 // Testing C::emplace(const value_type&&)
339 Container c;
340 const ValueTp v(42, 1);
341 cc->expect<const ValueTp&&>();
342 assert(c.emplace(std::move(v)).second);
343 assert(!cc->unchecked());
344 {
345 DisableAllocationGuard g;
346 const ValueTp v2(42, 1);
347 assert(c.emplace(std::move(v2)).second == false);
348 }
349 }
350 {
351 // Testing C::emplace(pair<Key, Mapped> const&)
352 Container c;
353 const NonConstKeyPair v(42, 1);
354 cc->expect<const NonConstKeyPair&>();
355 assert(c.emplace(v).second);
356 assert(!cc->unchecked());
357 {
358 DisableAllocationGuard g;
359 const NonConstKeyPair v2(42, 1);
360 assert(c.emplace(v2).second == false);
361 }
362 }
363 {
364 // Testing C::emplace(pair<Key, Mapped> &&)
365 Container c;
366 NonConstKeyPair v(42, 1);
367 cc->expect<NonConstKeyPair&&>();
368 assert(c.emplace(std::move(v)).second);
369 assert(!cc->unchecked());
370 {
371 DisableAllocationGuard g;
372 NonConstKeyPair v2(42, 1);
373 assert(c.emplace(std::move(v2)).second == false);
374 }
375 }
376 {
377 // Testing C::emplace(const Key&, ConvertibleToMapped&&)
378 Container c;
379 const Key k(42);
380 cc->expect<Key const&, int&&>();
381 assert(c.emplace(k, 1).second);
382 assert(!cc->unchecked());
383 {
384 DisableAllocationGuard g;
385 const Key k2(42);
386 assert(c.emplace(k2, 2).second == false);
387 }
388 }
389 {
390 // Testing C::emplace(Key&, Mapped&)
391 Container c;
392 Key k(42);
393 Mapped m(1);
394 cc->expect<Key&, Mapped&>();
395 assert(c.emplace(k, m).second);
396 assert(!cc->unchecked());
397 {
398 DisableAllocationGuard g;
399 Key k2(42);
400 assert(c.emplace(k2, m).second == false);
401 }
402 }
403 {
404 // Testing C::emplace(Key&&, Mapped&&)
405 Container c;
406 Key k(42);
407 Mapped m(1);
408 cc->expect<Key&&, Mapped&&>();
409 assert(c.emplace(std::move(k), std::move(m)).second);
410 assert(!cc->unchecked());
411 {
412 DisableAllocationGuard g;
413 Key k2(42);
414 Mapped m2(2);
415 assert(c.emplace(std::move(k2), std::move(m2)).second == false);
416 }
417 }
418 {
419 // Testing C::emplace(ConvertibleToKey&&, ConvertibleToMapped&&)
420 Container c;
421 cc->expect<int&&, int&&>();
422 assert(c.emplace(42, 1).second);
423 assert(!cc->unchecked());
424 {
425 // test that emplacing a duplicate item allocates. We cannot optimize
426 // this case because int&& does not match the type of key exactly.
427 cc->expect<int&&, int&&>();
428 assert(c.emplace(42, 1).second == false);
429 assert(!cc->unchecked());
430 }
431 }
432 }
433
434
435 template <class Container>
testMapEmplaceHint()436 void testMapEmplaceHint()
437 {
438 typedef typename Container::value_type ValueTp;
439 typedef typename Container::key_type Key;
440 typedef typename Container::mapped_type Mapped;
441 typedef typename std::pair<Key, Mapped> NonConstKeyPair;
442 typedef Container C;
443 typedef typename C::iterator It;
444 ConstructController* cc = getConstructController();
445 cc->reset();
446 {
447 // Testing C::emplace_hint(p, const value_type&)
448 Container c;
449 const ValueTp v(42, 1);
450 cc->expect<const ValueTp&>();
451 It ret = c.emplace_hint(c.end(), v);
452 assert(ret != c.end());
453 assert(c.size() == 1);
454 assert(!cc->unchecked());
455 {
456 DisableAllocationGuard g;
457 const ValueTp v2(42, 1);
458 It ret2 = c.emplace_hint(c.begin(), v2);
459 assert(&(*ret2) == &(*ret));
460 assert(c.size() == 1);
461 }
462 }
463 {
464 // Testing C::emplace_hint(p, value_type&)
465 Container c;
466 ValueTp v(42, 1);
467 cc->expect<ValueTp&>();
468 It ret = c.emplace_hint(c.end(), v);
469 assert(ret != c.end());
470 assert(c.size() == 1);
471 assert(!cc->unchecked());
472 {
473 DisableAllocationGuard g;
474 ValueTp v2(42, 1);
475 It ret2 = c.emplace_hint(c.begin(), v2);
476 assert(&(*ret2) == &(*ret));
477 assert(c.size() == 1);
478 }
479 }
480 {
481 // Testing C::emplace_hint(p, value_type&&)
482 Container c;
483 ValueTp v(42, 1);
484 cc->expect<ValueTp&&>();
485 It ret = c.emplace_hint(c.end(), std::move(v));
486 assert(ret != c.end());
487 assert(c.size() == 1);
488 assert(!cc->unchecked());
489 {
490 DisableAllocationGuard g;
491 ValueTp v2(42, 1);
492 It ret2 = c.emplace_hint(c.begin(), std::move(v2));
493 assert(&(*ret2) == &(*ret));
494 assert(c.size() == 1);
495 }
496 }
497 {
498 // Testing C::emplace_hint(p, const value_type&&)
499 Container c;
500 const ValueTp v(42, 1);
501 cc->expect<const ValueTp&&>();
502 It ret = c.emplace_hint(c.end(), std::move(v));
503 assert(ret != c.end());
504 assert(c.size() == 1);
505 assert(!cc->unchecked());
506 {
507 DisableAllocationGuard g;
508 const ValueTp v2(42, 1);
509 It ret2 = c.emplace_hint(c.begin(), std::move(v2));
510 assert(&(*ret2) == &(*ret));
511 assert(c.size() == 1);
512 }
513 }
514 {
515 // Testing C::emplace_hint(p, pair<Key, Mapped> const&)
516 Container c;
517 const NonConstKeyPair v(42, 1);
518 cc->expect<const NonConstKeyPair&>();
519 It ret = c.emplace_hint(c.end(), v);
520 assert(ret != c.end());
521 assert(c.size() == 1);
522 assert(!cc->unchecked());
523 {
524 DisableAllocationGuard g;
525 const NonConstKeyPair v2(42, 1);
526 It ret2 = c.emplace_hint(c.begin(), v2);
527 assert(&(*ret2) == &(*ret));
528 assert(c.size() == 1);
529 }
530 }
531 {
532 // Testing C::emplace_hint(p, pair<Key, Mapped>&&)
533 Container c;
534 NonConstKeyPair v(42, 1);
535 cc->expect<NonConstKeyPair&&>();
536 It ret = c.emplace_hint(c.end(), std::move(v));
537 assert(ret != c.end());
538 assert(c.size() == 1);
539 assert(!cc->unchecked());
540 {
541 DisableAllocationGuard g;
542 NonConstKeyPair v2(42, 1);
543 It ret2 = c.emplace_hint(c.begin(), std::move(v2));
544 assert(&(*ret2) == &(*ret));
545 assert(c.size() == 1);
546 }
547 }
548 {
549 // Testing C::emplace_hint(p, const Key&, ConvertibleToMapped&&)
550 Container c;
551 const Key k(42);
552 cc->expect<Key const&, int&&>();
553 It ret = c.emplace_hint(c.end(), k, 42);
554 assert(ret != c.end());
555 assert(c.size() == 1);
556 assert(!cc->unchecked());
557 {
558 DisableAllocationGuard g;
559 const Key k2(42);
560 It ret2 = c.emplace_hint(c.begin(), k2, 1);
561 assert(&(*ret2) == &(*ret));
562 assert(c.size() == 1);
563 }
564 }
565 {
566 // Testing C::emplace_hint(p, Key&, Mapped&)
567 Container c;
568 Key k(42);
569 Mapped m(1);
570 cc->expect<Key&, Mapped&>();
571 It ret = c.emplace_hint(c.end(), k, m);
572 assert(ret != c.end());
573 assert(c.size() == 1);
574 assert(!cc->unchecked());
575 {
576 DisableAllocationGuard g;
577 Key k2(42);
578 Mapped m2(2);
579 It ret2 = c.emplace_hint(c.begin(), k2, m2);
580 assert(&(*ret2) == &(*ret));
581 assert(c.size() == 1);
582 }
583 }
584 {
585 // Testing C::emplace_hint(p, Key&&, Mapped&&)
586 Container c;
587 Key k(42);
588 Mapped m(1);
589 cc->expect<Key&&, Mapped&&>();
590 It ret = c.emplace_hint(c.end(), std::move(k), std::move(m));
591 assert(ret != c.end());
592 assert(c.size() == 1);
593 assert(!cc->unchecked());
594 {
595 DisableAllocationGuard g;
596 Key k2(42);
597 Mapped m2(2);
598 It ret2 = c.emplace_hint(c.begin(), std::move(k2), std::move(m2));
599 assert(&(*ret2) == &(*ret));
600 assert(c.size() == 1);
601 }
602 }
603 {
604 // Testing C::emplace_hint(p, ConvertibleToKey&&, ConvertibleToMapped&&)
605 Container c;
606 cc->expect<int&&, int&&>();
607 It ret = c.emplace_hint(c.end(), 42, 1);
608 assert(ret != c.end());
609 assert(c.size() == 1);
610 assert(!cc->unchecked());
611 {
612 cc->expect<int&&, int&&>();
613 It ret2 = c.emplace_hint(c.begin(), 42, 2);
614 assert(&(*ret2) == &(*ret));
615 assert(c.size() == 1);
616 assert(!cc->unchecked());
617 }
618 }
619
620 }
621
622
623 template <class Container>
testMultimapInsert()624 void testMultimapInsert()
625 {
626 typedef typename Container::value_type ValueTp;
627 ConstructController* cc = getConstructController();
628 cc->reset();
629 {
630 // Testing C::insert(const value_type&)
631 Container c;
632 const ValueTp v(42, 1);
633 cc->expect<const ValueTp&>();
634 c.insert(v);
635 assert(!cc->unchecked());
636 }
637 {
638 // Testing C::insert(value_type&)
639 Container c;
640 ValueTp v(42, 1);
641 cc->expect<ValueTp&>();
642 c.insert(v);
643 assert(!cc->unchecked());
644 }
645 {
646 // Testing C::insert(value_type&&)
647 Container c;
648 ValueTp v(42, 1);
649 cc->expect<ValueTp&&>();
650 c.insert(std::move(v));
651 assert(!cc->unchecked());
652 }
653 {
654 // Testing C::insert({key, value})
655 Container c;
656 cc->expect<ValueTp&&>();
657 c.insert({42, 1});
658 assert(!cc->unchecked());
659 }
660 {
661 // Testing C::insert(std::initializer_list<ValueTp>)
662 Container c;
663 std::initializer_list<ValueTp> il = { ValueTp(1, 1), ValueTp(2, 1) };
664 cc->expect<ValueTp const&>(2);
665 c.insert(il);
666 assert(!cc->unchecked());
667 }
668 {
669 // Testing C::insert(Iter, Iter) for *Iter = value_type const&
670 Container c;
671 const ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1), ValueTp(3, 1) };
672 cc->expect<ValueTp const&>(3);
673 c.insert(std::begin(ValueList), std::end(ValueList));
674 assert(!cc->unchecked());
675 }
676 {
677 // Testing C::insert(Iter, Iter) for *Iter = value_type&&
678 Container c;
679 ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
680 cc->expect<ValueTp&&>(3);
681 c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)),
682 std::move_iterator<ValueTp*>(std::end(ValueList)));
683 assert(!cc->unchecked());
684 }
685 {
686 // Testing C::insert(Iter, Iter) for *Iter = value_type&
687 Container c;
688 ValueTp ValueList[] = { ValueTp(1, 1), ValueTp(2, 1) , ValueTp(3, 1) };
689 cc->expect<ValueTp&>(3);
690 c.insert(std::begin(ValueList), std::end(ValueList));
691 assert(!cc->unchecked());
692 }
693 }
694
695
696 template <class Container>
testMultimapInsertHint()697 void testMultimapInsertHint()
698 {
699 typedef typename Container::value_type ValueTp;
700 ConstructController* cc = getConstructController();
701 cc->reset();
702 {
703 // Testing C::insert(p, const value_type&)
704 Container c;
705 const ValueTp v(42, 1);
706 cc->expect<const ValueTp&>();
707 c.insert(c.begin(), v);
708 assert(!cc->unchecked());
709 }
710 {
711 // Testing C::insert(p, value_type&)
712 Container c;
713 ValueTp v(42, 1);
714 cc->expect<ValueTp&>();
715 c.insert(c.begin(), v);
716 assert(!cc->unchecked());
717 }
718 {
719 // Testing C::insert(p, value_type&&)
720 Container c;
721 ValueTp v(42, 1);
722 cc->expect<ValueTp&&>();
723 c.insert(c.begin(), std::move(v));
724 assert(!cc->unchecked());
725 }
726 {
727 // Testing C::insert(p, {key, value})
728 Container c;
729 cc->expect<ValueTp&&>();
730 c.insert(c.begin(), {42, 1});
731 assert(!cc->unchecked());
732 }
733 }
734
735 #endif
736