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

Lines Matching refs:c1
36         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
39         c1.swap(c2);
41         LIBCPP_ASSERT(c1.bucket_count() == 0);
42         assert(c1.size() == 0);
43         assert(c1.hash_function() == Hash(2));
44         assert(c1.key_eq() == Compare(2));
45         assert(c1.get_allocator().get_id() == 1);
46         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
47         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
48         assert(c1.max_load_factor() == 2);
76         C c1(0, Hash(1), Compare(1), Alloc(1, 1));
79         c1.swap(c2);
81         assert(c1.bucket_count() >= 8);
82         assert(c1.size() == 8);
83         assert(c1.at(10) == "ten");
84         assert(c1.at(20) == "twenty");
85         assert(c1.at(30) == "thirty");
86         assert(c1.at(40) == "forty");
87         assert(c1.at(50) == "fifty");
88         assert(c1.at(60) == "sixty");
89         assert(c1.at(70) == "seventy");
90         assert(c1.at(80) == "eighty");
91         assert(c1.hash_function() == Hash(2));
92         assert(c1.key_eq() == Compare(2));
93         assert(c1.get_allocator().get_id() == 1);
94         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
95         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
96         assert(c1.max_load_factor() == 2);
122         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1));
125         c1.swap(c2);
127         LIBCPP_ASSERT(c1.bucket_count() == 0);
128         assert(c1.size() == 0);
129         assert(c1.hash_function() == Hash(2));
130         assert(c1.key_eq() == Compare(2));
131         assert(c1.get_allocator().get_id() == 1);
132         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
133         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
134         assert(c1.max_load_factor() == 2);
175         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1));
178         c1.swap(c2);
180         assert(c1.bucket_count() >= 8);
181         assert(c1.size() == 8);
182         assert(c1.at(10) == "ten");
183         assert(c1.at(20) == "twenty");
184         assert(c1.at(30) == "thirty");
185         assert(c1.at(40) == "forty");
186         assert(c1.at(50) == "fifty");
187         assert(c1.at(60) == "sixty");
188         assert(c1.at(70) == "seventy");
189         assert(c1.at(80) == "eighty");
190         assert(c1.hash_function() == Hash(2));
191         assert(c1.key_eq() == Compare(2));
192         assert(c1.get_allocator().get_id() == 1);
193         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
194         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
195         assert(c1.max_load_factor() == 2);
216         C c1(0, Hash(1), Compare(1), Alloc(1));
219         c1.swap(c2);
221         LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
227         assert(static_cast<std::size_t>(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         c1.swap(c2);
261         assert(c1.bucket_count() >= 8);
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) == "forty");
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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
275         assert(static_cast<std::size_t>(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         c1.swap(c2);
307         LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
313         assert(static_cast<std::size_t>(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         c1.swap(c2);
360         assert(c1.bucket_count() >= 8);
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) == "forty");
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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
374         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
375         assert(c1.max_load_factor() == 2);
396         C c1(0, Hash(1), Compare(1), Alloc());
399         c1.swap(c2);
401         LIBCPP_ASSERT(c1.bucket_count() == 0);
402         assert(c1.size() == 0);
403         assert(c1.hash_function() == Hash(2));
404         assert(c1.key_eq() == Compare(2));
405         assert(c1.get_allocator() == Alloc());
406         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
407         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
408         assert(c1.max_load_factor() == 2);
436         C c1(0, Hash(1), Compare(1), Alloc());
439         c1.swap(c2);
441         assert(c1.bucket_count() >= 8);
442         assert(c1.size() == 8);
443         assert(c1.at(10) == "ten");
444         assert(c1.at(20) == "twenty");
445         assert(c1.at(30) == "thirty");
446         assert(c1.at(40) == "forty");
447         assert(c1.at(50) == "fifty");
448         assert(c1.at(60) == "sixty");
449         assert(c1.at(70) == "seventy");
450         assert(c1.at(80) == "eighty");
451         assert(c1.hash_function() == Hash(2));
452         assert(c1.key_eq() == Compare(2));
453         assert(c1.get_allocator() == Alloc());
454         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
455         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
456         assert(c1.max_load_factor() == 2);
482         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
485         c1.swap(c2);
487         LIBCPP_ASSERT(c1.bucket_count() == 0);
488         assert(c1.size() == 0);
489         assert(c1.hash_function() == Hash(2));
490         assert(c1.key_eq() == Compare(2));
491         assert(c1.get_allocator() == Alloc());
492         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
493         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
494         assert(c1.max_load_factor() == 2);
535         C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc());
538         c1.swap(c2);
540         assert(c1.bucket_count() >= 8);
541         assert(c1.size() == 8);
542         assert(c1.at(10) == "ten");
543         assert(c1.at(20) == "twenty");
544         assert(c1.at(30) == "thirty");
545         assert(c1.at(40) == "forty");
546         assert(c1.at(50) == "fifty");
547         assert(c1.at(60) == "sixty");
548         assert(c1.at(70) == "seventy");
549         assert(c1.at(80) == "eighty");
550         assert(c1.hash_function() == Hash(2));
551         assert(c1.key_eq() == Compare(2));
552         assert(c1.get_allocator() == Alloc());
553         assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
554         assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
555         assert(c1.max_load_factor() == 2);