assign_move.pass.cpp (10160B)
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 // UNSUPPORTED: c++98, c++03 11 12 // <unordered_map> 13 14 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 15 // class Alloc = allocator<pair<const Key, T>>> 16 // class unordered_multimap 17 18 // unordered_multimap& operator=(unordered_multimap&& u); 19 20 #include <unordered_map> 21 #include <string> 22 #include <cassert> 23 #include <cfloat> 24 #include <cmath> 25 #include <cstddef> 26 27 #include "test_macros.h" 28 #include "../../../test_compare.h" 29 #include "../../../test_hash.h" 30 #include "test_allocator.h" 31 #include "min_allocator.h" 32 33 int main() 34 { 35 { 36 typedef test_allocator<std::pair<const int, std::string> > A; 37 typedef std::unordered_multimap<int, std::string, 38 test_hash<std::hash<int> >, 39 test_compare<std::equal_to<int> >, 40 A 41 > C; 42 typedef std::pair<int, std::string> P; 43 P a[] = 44 { 45 P(1, "one"), 46 P(2, "two"), 47 P(3, "three"), 48 P(4, "four"), 49 P(1, "four"), 50 P(2, "four"), 51 }; 52 C c0(a, a + sizeof(a)/sizeof(a[0]), 53 7, 54 test_hash<std::hash<int> >(8), 55 test_compare<std::equal_to<int> >(9), 56 A(10) 57 ); 58 C c(a, a + 2, 59 7, 60 test_hash<std::hash<int> >(2), 61 test_compare<std::equal_to<int> >(3), 62 A(4) 63 ); 64 c = std::move(c0); 65 LIBCPP_ASSERT(c.bucket_count() == 7); 66 assert(c.size() == 6); 67 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 68 Eq eq = c.equal_range(1); 69 assert(std::distance(eq.first, eq.second) == 2); 70 C::const_iterator i = eq.first; 71 assert(i->first == 1); 72 assert(i->second == "one"); 73 ++i; 74 assert(i->first == 1); 75 assert(i->second == "four"); 76 eq = c.equal_range(2); 77 assert(std::distance(eq.first, eq.second) == 2); 78 i = eq.first; 79 assert(i->first == 2); 80 assert(i->second == "two"); 81 ++i; 82 assert(i->first == 2); 83 assert(i->second == "four"); 84 85 eq = c.equal_range(3); 86 assert(std::distance(eq.first, eq.second) == 1); 87 i = eq.first; 88 assert(i->first == 3); 89 assert(i->second == "three"); 90 eq = c.equal_range(4); 91 assert(std::distance(eq.first, eq.second) == 1); 92 i = eq.first; 93 assert(i->first == 4); 94 assert(i->second == "four"); 95 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 96 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 97 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 98 assert(c.max_load_factor() == 1); 99 } 100 { 101 typedef test_allocator<std::pair<const int, std::string> > A; 102 typedef std::unordered_multimap<int, std::string, 103 test_hash<std::hash<int> >, 104 test_compare<std::equal_to<int> >, 105 A 106 > C; 107 typedef std::pair<int, std::string> P; 108 P a[] = 109 { 110 P(1, "one"), 111 P(2, "two"), 112 P(3, "three"), 113 P(4, "four"), 114 P(1, "four"), 115 P(2, "four"), 116 }; 117 C c0(a, a + sizeof(a)/sizeof(a[0]), 118 7, 119 test_hash<std::hash<int> >(8), 120 test_compare<std::equal_to<int> >(9), 121 A(10) 122 ); 123 C c(a, a + 2, 124 7, 125 test_hash<std::hash<int> >(2), 126 test_compare<std::equal_to<int> >(3), 127 A(10) 128 ); 129 c = std::move(c0); 130 LIBCPP_ASSERT(c.bucket_count() == 7); 131 assert(c.size() == 6); 132 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 133 Eq eq = c.equal_range(1); 134 assert(std::distance(eq.first, eq.second) == 2); 135 C::const_iterator i = eq.first; 136 assert(i->first == 1); 137 assert(i->second == "one"); 138 ++i; 139 assert(i->first == 1); 140 assert(i->second == "four"); 141 eq = c.equal_range(2); 142 assert(std::distance(eq.first, eq.second) == 2); 143 i = eq.first; 144 assert(i->first == 2); 145 assert(i->second == "two"); 146 ++i; 147 assert(i->first == 2); 148 assert(i->second == "four"); 149 150 eq = c.equal_range(3); 151 assert(std::distance(eq.first, eq.second) == 1); 152 i = eq.first; 153 assert(i->first == 3); 154 assert(i->second == "three"); 155 eq = c.equal_range(4); 156 assert(std::distance(eq.first, eq.second) == 1); 157 i = eq.first; 158 assert(i->first == 4); 159 assert(i->second == "four"); 160 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 161 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 162 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 163 assert(c.max_load_factor() == 1); 164 } 165 { 166 typedef other_allocator<std::pair<const int, std::string> > A; 167 typedef std::unordered_multimap<int, std::string, 168 test_hash<std::hash<int> >, 169 test_compare<std::equal_to<int> >, 170 A 171 > C; 172 typedef std::pair<int, std::string> P; 173 P a[] = 174 { 175 P(1, "one"), 176 P(2, "two"), 177 P(3, "three"), 178 P(4, "four"), 179 P(1, "four"), 180 P(2, "four"), 181 }; 182 C c0(a, a + sizeof(a)/sizeof(a[0]), 183 7, 184 test_hash<std::hash<int> >(8), 185 test_compare<std::equal_to<int> >(9), 186 A(10) 187 ); 188 C c(a, a + 2, 189 7, 190 test_hash<std::hash<int> >(2), 191 test_compare<std::equal_to<int> >(3), 192 A(4) 193 ); 194 c = std::move(c0); 195 LIBCPP_ASSERT(c.bucket_count() == 7); 196 assert(c.size() == 6); 197 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 198 Eq eq = c.equal_range(1); 199 assert(std::distance(eq.first, eq.second) == 2); 200 C::const_iterator i = eq.first; 201 assert(i->first == 1); 202 assert(i->second == "one"); 203 ++i; 204 assert(i->first == 1); 205 assert(i->second == "four"); 206 eq = c.equal_range(2); 207 assert(std::distance(eq.first, eq.second) == 2); 208 i = eq.first; 209 assert(i->first == 2); 210 assert(i->second == "two"); 211 ++i; 212 assert(i->first == 2); 213 assert(i->second == "four"); 214 215 eq = c.equal_range(3); 216 assert(std::distance(eq.first, eq.second) == 1); 217 i = eq.first; 218 assert(i->first == 3); 219 assert(i->second == "three"); 220 eq = c.equal_range(4); 221 assert(std::distance(eq.first, eq.second) == 1); 222 i = eq.first; 223 assert(i->first == 4); 224 assert(i->second == "four"); 225 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 226 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 227 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 228 assert(c.max_load_factor() == 1); 229 } 230 { 231 typedef min_allocator<std::pair<const int, std::string> > A; 232 typedef std::unordered_multimap<int, std::string, 233 test_hash<std::hash<int> >, 234 test_compare<std::equal_to<int> >, 235 A 236 > C; 237 typedef std::pair<int, std::string> P; 238 P a[] = 239 { 240 P(1, "one"), 241 P(2, "two"), 242 P(3, "three"), 243 P(4, "four"), 244 P(1, "four"), 245 P(2, "four"), 246 }; 247 C c0(a, a + sizeof(a)/sizeof(a[0]), 248 7, 249 test_hash<std::hash<int> >(8), 250 test_compare<std::equal_to<int> >(9), 251 A() 252 ); 253 C c(a, a + 2, 254 7, 255 test_hash<std::hash<int> >(2), 256 test_compare<std::equal_to<int> >(3), 257 A() 258 ); 259 c = std::move(c0); 260 LIBCPP_ASSERT(c.bucket_count() == 7); 261 assert(c.size() == 6); 262 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 263 Eq eq = c.equal_range(1); 264 assert(std::distance(eq.first, eq.second) == 2); 265 C::const_iterator i = eq.first; 266 assert(i->first == 1); 267 assert(i->second == "one"); 268 ++i; 269 assert(i->first == 1); 270 assert(i->second == "four"); 271 eq = c.equal_range(2); 272 assert(std::distance(eq.first, eq.second) == 2); 273 i = eq.first; 274 assert(i->first == 2); 275 assert(i->second == "two"); 276 ++i; 277 assert(i->first == 2); 278 assert(i->second == "four"); 279 280 eq = c.equal_range(3); 281 assert(std::distance(eq.first, eq.second) == 1); 282 i = eq.first; 283 assert(i->first == 3); 284 assert(i->second == "three"); 285 eq = c.equal_range(4); 286 assert(std::distance(eq.first, eq.second) == 1); 287 i = eq.first; 288 assert(i->first == 4); 289 assert(i->second == "four"); 290 assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); 291 assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); 292 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 293 assert(c.max_load_factor() == 1); 294 } 295 }