assign_copy.pass.cpp (5942B)
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 10 // <unordered_set> 11 12 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, 13 // class Alloc = allocator<Value>> 14 // class unordered_set 15 16 // unordered_set& operator=(const unordered_set& u); 17 18 #include <unordered_set> 19 #include <algorithm> 20 #include <cassert> 21 #include <cfloat> 22 #include <cmath> 23 #include <cstddef> 24 25 #include "test_macros.h" 26 #include "../../../test_compare.h" 27 #include "../../../test_hash.h" 28 #include "test_allocator.h" 29 #include "min_allocator.h" 30 31 int main() 32 { 33 { 34 typedef test_allocator<int> A; 35 typedef std::unordered_set<int, 36 test_hash<std::hash<int> >, 37 test_compare<std::equal_to<int> >, 38 A 39 > C; 40 typedef int P; 41 P a[] = 42 { 43 P(1), 44 P(2), 45 P(3), 46 P(4), 47 P(1), 48 P(2) 49 }; 50 C c0(a, a + sizeof(a)/sizeof(a[0]), 51 7, 52 test_hash<std::hash<int> >(8), 53 test_compare<std::equal_to<int> >(9), 54 A(10) 55 ); 56 C c(a, a + 2, 57 7, 58 test_hash<std::hash<int> >(2), 59 test_compare<std::equal_to<int> >(3), 60 A(4) 61 ); 62 c = c0; 63 LIBCPP_ASSERT(c.bucket_count() == 7); 64 assert(c.size() == 4); 65 assert(c.count(1) == 1); 66 assert(c.count(2) == 1); 67 assert(c.count(3) == 1); 68 assert(c.count(4) == 1); 69 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 70 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 71 assert(c.get_allocator() == A(4)); 72 assert(!c.empty()); 73 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 74 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 75 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 76 assert(c.max_load_factor() == 1); 77 } 78 { 79 typedef std::unordered_set<int> C; 80 typedef int P; 81 P a[] = 82 { 83 P(1), 84 P(2), 85 P(3), 86 P(4), 87 P(1), 88 P(2) 89 }; 90 C c(a, a + sizeof(a)/sizeof(a[0])); 91 C *p = &c; 92 c = *p; 93 assert(c.size() == 4); 94 assert(std::is_permutation(c.begin(), c.end(), a)); 95 } 96 { 97 typedef other_allocator<int> A; 98 typedef std::unordered_set<int, 99 test_hash<std::hash<int> >, 100 test_compare<std::equal_to<int> >, 101 A 102 > C; 103 typedef int P; 104 P a[] = 105 { 106 P(1), 107 P(2), 108 P(3), 109 P(4), 110 P(1), 111 P(2) 112 }; 113 C c0(a, a + sizeof(a)/sizeof(a[0]), 114 7, 115 test_hash<std::hash<int> >(8), 116 test_compare<std::equal_to<int> >(9), 117 A(10) 118 ); 119 C c(a, a + 2, 120 7, 121 test_hash<std::hash<int> >(2), 122 test_compare<std::equal_to<int> >(3), 123 A(4) 124 ); 125 c = c0; 126 assert(c.bucket_count() >= 5); 127 assert(c.size() == 4); 128 assert(c.count(1) == 1); 129 assert(c.count(2) == 1); 130 assert(c.count(3) == 1); 131 assert(c.count(4) == 1); 132 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 133 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 134 assert(c.get_allocator() == A(10)); 135 assert(!c.empty()); 136 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 137 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 138 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 139 assert(c.max_load_factor() == 1); 140 } 141 #if TEST_STD_VER >= 11 142 { 143 typedef min_allocator<int> A; 144 typedef std::unordered_set<int, 145 test_hash<std::hash<int> >, 146 test_compare<std::equal_to<int> >, 147 A 148 > C; 149 typedef int P; 150 P a[] = 151 { 152 P(1), 153 P(2), 154 P(3), 155 P(4), 156 P(1), 157 P(2) 158 }; 159 C c0(a, a + sizeof(a)/sizeof(a[0]), 160 7, 161 test_hash<std::hash<int> >(8), 162 test_compare<std::equal_to<int> >(9), 163 A() 164 ); 165 C c(a, a + 2, 166 7, 167 test_hash<std::hash<int> >(2), 168 test_compare<std::equal_to<int> >(3), 169 A() 170 ); 171 c = c0; 172 LIBCPP_ASSERT(c.bucket_count() == 7); 173 assert(c.size() == 4); 174 assert(c.count(1) == 1); 175 assert(c.count(2) == 1); 176 assert(c.count(3) == 1); 177 assert(c.count(4) == 1); 178 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 179 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 180 assert(c.get_allocator() == A()); 181 assert(!c.empty()); 182 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 183 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 184 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 185 assert(c.max_load_factor() == 1); 186 } 187 #endif 188 }