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_map> 11 12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 13 // class Alloc = allocator<pair<const Key, T>>> 14 // class unordered_map 15 16 // local_iterator begin (size_type n); 17 // local_iterator end (size_type n); 18 // const_local_iterator begin (size_type n) const; 19 // const_local_iterator end (size_type n) const; 20 // const_local_iterator cbegin(size_type n) const; 21 // const_local_iterator cend (size_type n) const; 22 23 #include <unordered_map> 24 #include <string> 25 #include <cassert> 26 27 #include "min_allocator.h" 28 29 int main() 30 { 31 { 32 typedef std::unordered_map<int, std::string> C; 33 typedef std::pair<int, std::string> P; 34 typedef C::local_iterator I; 35 P a[] = 36 { 37 P(1, "one"), 38 P(2, "two"), 39 P(3, "three"), 40 P(4, "four"), 41 P(1, "four"), 42 P(2, "four"), 43 }; 44 C c(a, a + sizeof(a)/sizeof(a[0])); 45 assert(c.bucket_count() >= 5); 46 C::size_type b = c.bucket(0); 47 I i = c.begin(b); 48 I j = c.end(b); 49 assert(std::distance(i, j) == 0); 50 51 b = c.bucket(1); 52 i = c.begin(b); 53 j = c.end(b); 54 assert(std::distance(i, j) == 1); 55 assert(i->first == 1); 56 assert(i->second == "one"); 57 58 b = c.bucket(2); 59 i = c.begin(b); 60 j = c.end(b); 61 assert(std::distance(i, j) == 1); 62 assert(i->first == 2); 63 assert(i->second == "two"); 64 65 b = c.bucket(3); 66 i = c.begin(b); 67 j = c.end(b); 68 assert(std::distance(i, j) == 1); 69 assert(i->first == 3); 70 assert(i->second == "three"); 71 72 b = c.bucket(4); 73 i = c.begin(b); 74 j = c.end(b); 75 assert(std::distance(i, j) == 1); 76 assert(i->first == 4); 77 assert(i->second == "four"); 78 } 79 { 80 typedef std::unordered_map<int, std::string> C; 81 typedef std::pair<int, std::string> P; 82 typedef C::const_local_iterator I; 83 P a[] = 84 { 85 P(1, "one"), 86 P(2, "two"), 87 P(3, "three"), 88 P(4, "four"), 89 P(1, "four"), 90 P(2, "four"), 91 }; 92 const C c(a, a + sizeof(a)/sizeof(a[0])); 93 assert(c.bucket_count() >= 5); 94 C::size_type b = c.bucket(0); 95 I i = c.begin(b); 96 I j = c.end(b); 97 assert(std::distance(i, j) == 0); 98 99 b = c.bucket(1); 100 i = c.begin(b); 101 j = c.end(b); 102 assert(std::distance(i, j) == 1); 103 assert(i->first == 1); 104 assert(i->second == "one"); 105 106 b = c.bucket(2); 107 i = c.begin(b); 108 j = c.end(b); 109 assert(std::distance(i, j) == 1); 110 assert(i->first == 2); 111 assert(i->second == "two"); 112 113 b = c.bucket(3); 114 i = c.begin(b); 115 j = c.end(b); 116 assert(std::distance(i, j) == 1); 117 assert(i->first == 3); 118 assert(i->second == "three"); 119 120 b = c.bucket(4); 121 i = c.begin(b); 122 j = c.end(b); 123 assert(std::distance(i, j) == 1); 124 assert(i->first == 4); 125 assert(i->second == "four"); 126 } 127 { 128 typedef std::unordered_map<int, std::string> C; 129 typedef std::pair<int, std::string> P; 130 typedef C::const_local_iterator I; 131 P a[] = 132 { 133 P(1, "one"), 134 P(2, "two"), 135 P(3, "three"), 136 P(4, "four"), 137 P(1, "four"), 138 P(2, "four"), 139 }; 140 C c(a, a + sizeof(a)/sizeof(a[0])); 141 assert(c.bucket_count() >= 5); 142 C::size_type b = c.bucket(0); 143 I i = c.cbegin(b); 144 I j = c.cend(b); 145 assert(std::distance(i, j) == 0); 146 147 b = c.bucket(1); 148 i = c.cbegin(b); 149 j = c.cend(b); 150 assert(std::distance(i, j) == 1); 151 assert(i->first == 1); 152 assert(i->second == "one"); 153 154 b = c.bucket(2); 155 i = c.cbegin(b); 156 j = c.cend(b); 157 assert(std::distance(i, j) == 1); 158 assert(i->first == 2); 159 assert(i->second == "two"); 160 161 b = c.bucket(3); 162 i = c.cbegin(b); 163 j = c.cend(b); 164 assert(std::distance(i, j) == 1); 165 assert(i->first == 3); 166 assert(i->second == "three"); 167 168 b = c.bucket(4); 169 i = c.cbegin(b); 170 j = c.cend(b); 171 assert(std::distance(i, j) == 1); 172 assert(i->first == 4); 173 assert(i->second == "four"); 174 } 175 { 176 typedef std::unordered_map<int, std::string> C; 177 typedef std::pair<int, std::string> P; 178 typedef C::const_local_iterator I; 179 P a[] = 180 { 181 P(1, "one"), 182 P(2, "two"), 183 P(3, "three"), 184 P(4, "four"), 185 P(1, "four"), 186 P(2, "four"), 187 }; 188 const C c(a, a + sizeof(a)/sizeof(a[0])); 189 assert(c.bucket_count() >= 5); 190 C::size_type b = c.bucket(0); 191 I i = c.cbegin(b); 192 I j = c.cend(b); 193 assert(std::distance(i, j) == 0); 194 195 b = c.bucket(1); 196 i = c.cbegin(b); 197 j = c.cend(b); 198 assert(std::distance(i, j) == 1); 199 assert(i->first == 1); 200 assert(i->second == "one"); 201 202 b = c.bucket(2); 203 i = c.cbegin(b); 204 j = c.cend(b); 205 assert(std::distance(i, j) == 1); 206 assert(i->first == 2); 207 assert(i->second == "two"); 208 209 b = c.bucket(3); 210 i = c.cbegin(b); 211 j = c.cend(b); 212 assert(std::distance(i, j) == 1); 213 assert(i->first == 3); 214 assert(i->second == "three"); 215 216 b = c.bucket(4); 217 i = c.cbegin(b); 218 j = c.cend(b); 219 assert(std::distance(i, j) == 1); 220 assert(i->first == 4); 221 assert(i->second == "four"); 222 } 223 #if TEST_STD_VER >= 11 224 { 225 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, 226 min_allocator<std::pair<const int, std::string>>> C; 227 typedef std::pair<int, std::string> P; 228 typedef C::local_iterator I; 229 P a[] = 230 { 231 P(1, "one"), 232 P(2, "two"), 233 P(3, "three"), 234 P(4, "four"), 235 P(1, "four"), 236 P(2, "four"), 237 }; 238 C c(a, a + sizeof(a)/sizeof(a[0])); 239 assert(c.bucket_count() >= 5); 240 C::size_type b = c.bucket(0); 241 I i = c.begin(b); 242 I j = c.end(b); 243 assert(std::distance(i, j) == 0); 244 245 b = c.bucket(1); 246 i = c.begin(b); 247 j = c.end(b); 248 assert(std::distance(i, j) == 1); 249 assert(i->first == 1); 250 assert(i->second == "one"); 251 252 b = c.bucket(2); 253 i = c.begin(b); 254 j = c.end(b); 255 assert(std::distance(i, j) == 1); 256 assert(i->first == 2); 257 assert(i->second == "two"); 258 259 b = c.bucket(3); 260 i = c.begin(b); 261 j = c.end(b); 262 assert(std::distance(i, j) == 1); 263 assert(i->first == 3); 264 assert(i->second == "three"); 265 266 b = c.bucket(4); 267 i = c.begin(b); 268 j = c.end(b); 269 assert(std::distance(i, j) == 1); 270 assert(i->first == 4); 271 assert(i->second == "four"); 272 } 273 { 274 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, 275 min_allocator<std::pair<const int, std::string>>> C; 276 typedef std::pair<int, std::string> P; 277 typedef C::const_local_iterator I; 278 P a[] = 279 { 280 P(1, "one"), 281 P(2, "two"), 282 P(3, "three"), 283 P(4, "four"), 284 P(1, "four"), 285 P(2, "four"), 286 }; 287 const C c(a, a + sizeof(a)/sizeof(a[0])); 288 assert(c.bucket_count() >= 5); 289 C::size_type b = c.bucket(0); 290 I i = c.begin(b); 291 I j = c.end(b); 292 assert(std::distance(i, j) == 0); 293 294 b = c.bucket(1); 295 i = c.begin(b); 296 j = c.end(b); 297 assert(std::distance(i, j) == 1); 298 assert(i->first == 1); 299 assert(i->second == "one"); 300 301 b = c.bucket(2); 302 i = c.begin(b); 303 j = c.end(b); 304 assert(std::distance(i, j) == 1); 305 assert(i->first == 2); 306 assert(i->second == "two"); 307 308 b = c.bucket(3); 309 i = c.begin(b); 310 j = c.end(b); 311 assert(std::distance(i, j) == 1); 312 assert(i->first == 3); 313 assert(i->second == "three"); 314 315 b = c.bucket(4); 316 i = c.begin(b); 317 j = c.end(b); 318 assert(std::distance(i, j) == 1); 319 assert(i->first == 4); 320 assert(i->second == "four"); 321 } 322 { 323 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, 324 min_allocator<std::pair<const int, std::string>>> C; 325 typedef std::pair<int, std::string> P; 326 typedef C::const_local_iterator I; 327 P a[] = 328 { 329 P(1, "one"), 330 P(2, "two"), 331 P(3, "three"), 332 P(4, "four"), 333 P(1, "four"), 334 P(2, "four"), 335 }; 336 C c(a, a + sizeof(a)/sizeof(a[0])); 337 assert(c.bucket_count() >= 5); 338 C::size_type b = c.bucket(0); 339 I i = c.cbegin(b); 340 I j = c.cend(b); 341 assert(std::distance(i, j) == 0); 342 343 b = c.bucket(1); 344 i = c.cbegin(b); 345 j = c.cend(b); 346 assert(std::distance(i, j) == 1); 347 assert(i->first == 1); 348 assert(i->second == "one"); 349 350 b = c.bucket(2); 351 i = c.cbegin(b); 352 j = c.cend(b); 353 assert(std::distance(i, j) == 1); 354 assert(i->first == 2); 355 assert(i->second == "two"); 356 357 b = c.bucket(3); 358 i = c.cbegin(b); 359 j = c.cend(b); 360 assert(std::distance(i, j) == 1); 361 assert(i->first == 3); 362 assert(i->second == "three"); 363 364 b = c.bucket(4); 365 i = c.cbegin(b); 366 j = c.cend(b); 367 assert(std::distance(i, j) == 1); 368 assert(i->first == 4); 369 assert(i->second == "four"); 370 } 371 { 372 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, 373 min_allocator<std::pair<const int, std::string>>> C; 374 typedef std::pair<int, std::string> P; 375 typedef C::const_local_iterator I; 376 P a[] = 377 { 378 P(1, "one"), 379 P(2, "two"), 380 P(3, "three"), 381 P(4, "four"), 382 P(1, "four"), 383 P(2, "four"), 384 }; 385 const C c(a, a + sizeof(a)/sizeof(a[0])); 386 assert(c.bucket_count() >= 5); 387 C::size_type b = c.bucket(0); 388 I i = c.cbegin(b); 389 I j = c.cend(b); 390 assert(std::distance(i, j) == 0); 391 392 b = c.bucket(1); 393 i = c.cbegin(b); 394 j = c.cend(b); 395 assert(std::distance(i, j) == 1); 396 assert(i->first == 1); 397 assert(i->second == "one"); 398 399 b = c.bucket(2); 400 i = c.cbegin(b); 401 j = c.cend(b); 402 assert(std::distance(i, j) == 1); 403 assert(i->first == 2); 404 assert(i->second == "two"); 405 406 b = c.bucket(3); 407 i = c.cbegin(b); 408 j = c.cend(b); 409 assert(std::distance(i, j) == 1); 410 assert(i->first == 3); 411 assert(i->second == "three"); 412 413 b = c.bucket(4); 414 i = c.cbegin(b); 415 j = c.cend(b); 416 assert(std::distance(i, j) == 1); 417 assert(i->first == 4); 418 assert(i->second == "four"); 419 } 420 #endif 421 } 422
