Cross Reference: /external/libcxx/test/containers/unord/unord.map/unord.map.swap/swap_non

Lines Matching refs:c1
35         C c1(0, Hash(1), Compare(1), Alloc(1));
38         swap(c1, c2);
40         assert(c1.bucket_count() == 0);
41         assert(c1.size() == 0);
42         assert(c1.hash_function() == Hash(2));
43         assert(c1.key_eq() == Compare(2));
44         assert(c1.get_allocator() == Alloc(1));
45         assert(std::distance(c1.begin(), c1.end()) == c1.size());
46         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
47         assert(c1.max_load_factor() == 2);
75         C c1(0, Hash(1), Compare(1), Alloc(1));
78         swap(c1, c2);
80         assert(c1.bucket_count() >= 11);
81         assert(c1.size() == 8);
82         assert(c1.at(10) == "ten");
83         assert(c1.at(20) == "twenty");
84         assert(c1.at(30) == "thirty");
85         assert(c1.at(40) == "fourty");
86         assert(c1.at(50) == "fifty");
87         assert(c1.at(60) == "sixty");
88         assert(c1.at(70) == "seventy");
89         assert(c1.at(80) == "eighty");
90         assert(c1.hash_function() == Hash(2));
91         assert(c1.key_eq() == Compare(2));
92         assert(c1.get_allocator() == Alloc(1));
93         assert(std::distance(c1.begin(), c1.end()) == c1.size());
94         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
95         assert(c1.max_load_factor() == 2);
121         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
124         swap(c1, c2);
126         assert(c1.bucket_count() == 0);
127         assert(c1.size() == 0);
128         assert(c1.hash_function() == Hash(2));
129         assert(c1.key_eq() == Compare(2));
130         assert(c1.get_allocator() == Alloc(1));
131         assert(std::distance(c1.begin(), c1.end()) == c1.size());
132         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
133         assert(c1.max_load_factor() == 2);
174         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
177         swap(c1, c2);
179         assert(c1.bucket_count() >= 11);
180         assert(c1.size() == 8);
181         assert(c1.at(10) == "ten");
182         assert(c1.at(20) == "twenty");
183         assert(c1.at(30) == "thirty");
184         assert(c1.at(40) == "fourty");
185         assert(c1.at(50) == "fifty");
186         assert(c1.at(60) == "sixty");
187         assert(c1.at(70) == "seventy");
188         assert(c1.at(80) == "eighty");
189         assert(c1.hash_function() == Hash(2));
190         assert(c1.key_eq() == Compare(2));
191         assert(c1.get_allocator() == Alloc(1));
192         assert(std::distance(c1.begin(), c1.end()) == c1.size());
193         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
194         assert(c1.max_load_factor() == 2);
216         C c1(0, Hash(1), Compare(1), Alloc(1));
219         swap(c1, c2);
221         assert(c1.bucket_count() == 0);
222         assert(c1.size() == 0);
223         assert(c1.hash_function() == Hash(2));
224         assert(c1.key_eq() == Compare(2));
225         assert(c1.get_allocator() == Alloc(2));
226         assert(std::distance(c1.begin(), c1.end()) == c1.size());
227         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
228         assert(c1.max_load_factor() == 2);
256         C c1(0, Hash(1), Compare(1), Alloc(1));
259         swap(c1, c2);
261         assert(c1.bucket_count() >= 11);
262         assert(c1.size() == 8);
263         assert(c1.at(10) == "ten");
264         assert(c1.at(20) == "twenty");
265         assert(c1.at(30) == "thirty");
266         assert(c1.at(40) == "fourty");
267         assert(c1.at(50) == "fifty");
268         assert(c1.at(60) == "sixty");
269         assert(c1.at(70) == "seventy");
270         assert(c1.at(80) == "eighty");
271         assert(c1.hash_function() == Hash(2));
272         assert(c1.key_eq() == Compare(2));
273         assert(c1.get_allocator() == Alloc(2));
274         assert(std::distance(c1.begin(), c1.end()) == c1.size());
275         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
276         assert(c1.max_load_factor() == 2);
302         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
305         swap(c1, c2);
307         assert(c1.bucket_count() == 0);
308         assert(c1.size() == 0);
309         assert(c1.hash_function() == Hash(2));
310         assert(c1.key_eq() == Compare(2));
311         assert(c1.get_allocator() == Alloc(2));
312         assert(std::distance(c1.begin(), c1.end()) == c1.size());
313         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
314         assert(c1.max_load_factor() == 2);
355         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1));
358         swap(c1, c2);
360         assert(c1.bucket_count() >= 11);
361         assert(c1.size() == 8);
362         assert(c1.at(10) == "ten");
363         assert(c1.at(20) == "twenty");
364         assert(c1.at(30) == "thirty");
365         assert(c1.at(40) == "fourty");
366         assert(c1.at(50) == "fifty");
367         assert(c1.at(60) == "sixty");
368         assert(c1.at(70) == "seventy");
369         assert(c1.at(80) == "eighty");
370         assert(c1.hash_function() == Hash(2));
371         assert(c1.key_eq() == Compare(2));
372         assert(c1.get_allocator() == Alloc(2));
373         assert(std::distance(c1.begin(), c1.end()) == c1.size());
374         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
375         assert(c1.max_load_factor() == 2);
397         C c1(0, Hash(1), Compare(1), Alloc());
400         swap(c1, c2);
402         assert(c1.bucket_count() == 0);
403         assert(c1.size() == 0);
404         assert(c1.hash_function() == Hash(2));
405         assert(c1.key_eq() == Compare(2));
406         assert(c1.get_allocator() == Alloc());
407         assert(std::distance(c1.begin(), c1.end()) == c1.size());
408         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
409         assert(c1.max_load_factor() == 2);
437         C c1(0, Hash(1), Compare(1), Alloc());
440         swap(c1, c2);
442         assert(c1.bucket_count() >= 11);
443         assert(c1.size() == 8);
444         assert(c1.at(10) == "ten");
445         assert(c1.at(20) == "twenty");
446         assert(c1.at(30) == "thirty");
447         assert(c1.at(40) == "fourty");
448         assert(c1.at(50) == "fifty");
449         assert(c1.at(60) == "sixty");
450         assert(c1.at(70) == "seventy");
451         assert(c1.at(80) == "eighty");
452         assert(c1.hash_function() == Hash(2));
453         assert(c1.key_eq() == Compare(2));
454         assert(c1.get_allocator() == Alloc());
455         assert(std::distance(c1.begin(), c1.end()) == c1.size());
456         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
457         assert(c1.max_load_factor() == 2);
483         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
486         swap(c1, c2);
488         assert(c1.bucket_count() == 0);
489         assert(c1.size() == 0);
490         assert(c1.hash_function() == Hash(2));
491         assert(c1.key_eq() == Compare(2));
492         assert(c1.get_allocator() == Alloc());
493         assert(std::distance(c1.begin(), c1.end()) == c1.size());
494         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
495         assert(c1.max_load_factor() == 2);
536         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
539         swap(c1, c2);
541         assert(c1.bucket_count() >= 11);
542         assert(c1.size() == 8);
543         assert(c1.at(10) == "ten");
544         assert(c1.at(20) == "twenty");
545         assert(c1.at(30) == "thirty");
546         assert(c1.at(40) == "fourty");
547         assert(c1.at(50) == "fifty");
548         assert(c1.at(60) == "sixty");
549         assert(c1.at(70) == "seventy");
550         assert(c1.at(80) == "eighty");
551         assert(c1.hash_function() == Hash(2));
552         assert(c1.key_eq() == Compare(2));
553         assert(c1.get_allocator() == Alloc());
554         assert(std::distance(c1.begin(), c1.end()) == c1.size());
555         assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
556         assert(c1.max_load_factor() == 2);