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