src/test/addrman_tests.cpp

   1 // Copyright (c) 2012-2015 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4 #include "addrman.h"
   5 #include "test/test_bitcoin.h"
   6 #include <string>
   7 #include <boost/test/unit_test.hpp>
   8
   9 #include "hash.h"
  10 #include "netbase.h"
  11 #include "random.h"
  12
  13 using namespace std;
  14
  15 class CAddrManTest : public CAddrMan
  16 {
  17     uint64_t state;
  18
  19 public:
  20     CAddrManTest()
  21     {
  22         state = 1;
  23     }
  24
  25     //! Ensure that bucket placement is always the same for testing purposes.
  26     void MakeDeterministic()
  27     {
  28         nKey.SetNull();
  29         insecure_rand = FastRandomContext(true);
  30     }
  31
  32     int RandomInt(int nMax)
  33     {
  34         state = (CHashWriter(SER_GETHASH, 0) << state).GetHash().GetCheapHash();
  35         return (unsigned int)(state % nMax);
  36     }
  37
  38     CAddrInfo* Find(const CNetAddr& addr, int* pnId = NULL)
  39     {
  40         return CAddrMan::Find(addr, pnId);
  41     }
  42
  43     CAddrInfo* Create(const CAddress& addr, const CNetAddr& addrSource, int* pnId = NULL)
  44     {
  45         return CAddrMan::Create(addr, addrSource, pnId);
  46     }
  47
  48     void Delete(int nId)
  49     {
  50         CAddrMan::Delete(nId);
  51     }
  52 };
  53
  54 static CNetAddr ResolveIP(const char* ip)
  55 {
  56     CNetAddr addr;
  57     BOOST_CHECK_MESSAGE(LookupHost(ip, addr, false), strprintf("failed to resolve: %s", ip));
  58     return addr;
  59 }
  60
  61 static CNetAddr ResolveIP(std::string ip)
  62 {
  63     return ResolveIP(ip.c_str());
  64 }
  65
  66 static CService ResolveService(const char* ip, int port = 0)
  67 {
  68     CService serv;
  69     BOOST_CHECK_MESSAGE(Lookup(ip, serv, port, false), strprintf("failed to resolve: %s:%i", ip, port));
  70     return serv;
  71 }
  72
  73 static CService ResolveService(std::string ip, int port = 0)
  74 {
  75     return ResolveService(ip.c_str(), port);
  76 }
  77
  78 BOOST_FIXTURE_TEST_SUITE(addrman_tests, BasicTestingSetup)
  79
  80 BOOST_AUTO_TEST_CASE(addrman_simple)
  81 {
  82     CAddrManTest addrman;
  83
  84     // Set addrman addr placement to be deterministic.
  85     addrman.MakeDeterministic();
  86
  87     CNetAddr source = ResolveIP("252.2.2.2");
  88
  89     // Test 1: Does Addrman respond correctly when empty.
  90     BOOST_CHECK(addrman.size() == 0);
  91     CAddrInfo addr_null = addrman.Select();
  92     BOOST_CHECK(addr_null.ToString() == "[::]:0");
  93
  94     // Test 2: Does Addrman::Add work as expected.
  95     CService addr1 = ResolveService("250.1.1.1", 8333);
  96     addrman.Add(CAddress(addr1, NODE_NONE), source);
  97     BOOST_CHECK(addrman.size() == 1);
  98     CAddrInfo addr_ret1 = addrman.Select();
  99     BOOST_CHECK(addr_ret1.ToString() == "250.1.1.1:8333");
 100
 101     // Test 3: Does IP address deduplication work correctly.
 102     //  Expected dup IP should not be added.
 103     CService addr1_dup = ResolveService("250.1.1.1", 8333);
 104     addrman.Add(CAddress(addr1_dup, NODE_NONE), source);
 105     BOOST_CHECK(addrman.size() == 1);
 106
 107
 108     // Test 5: New table has one addr and we add a diff addr we should
 109     //  have two addrs.
 110     CService addr2 = ResolveService("250.1.1.2", 8333);
 111     addrman.Add(CAddress(addr2, NODE_NONE), source);
 112     BOOST_CHECK(addrman.size() == 2);
 113
 114     // Test 6: AddrMan::Clear() should empty the new table.
 115     addrman.Clear();
 116     BOOST_CHECK(addrman.size() == 0);
 117     CAddrInfo addr_null2 = addrman.Select();
 118     BOOST_CHECK(addr_null2.ToString() == "[::]:0");
 119 }
 120
 121 BOOST_AUTO_TEST_CASE(addrman_ports)
 122 {
 123     CAddrManTest addrman;
 124
 125     // Set addrman addr placement to be deterministic.
 126     addrman.MakeDeterministic();
 127
 128     CNetAddr source = ResolveIP("252.2.2.2");
 129
 130     BOOST_CHECK(addrman.size() == 0);
 131
 132     // Test 7; Addr with same IP but diff port does not replace existing addr.
 133     CService addr1 = ResolveService("250.1.1.1", 8333);
 134     addrman.Add(CAddress(addr1, NODE_NONE), source);
 135     BOOST_CHECK(addrman.size() == 1);
 136
 137     CService addr1_port = ResolveService("250.1.1.1", 8334);
 138     addrman.Add(CAddress(addr1_port, NODE_NONE), source);
 139     BOOST_CHECK(addrman.size() == 1);
 140     CAddrInfo addr_ret2 = addrman.Select();
 141     BOOST_CHECK(addr_ret2.ToString() == "250.1.1.1:8333");
 142
 143     // Test 8: Add same IP but diff port to tried table, it doesn't get added.
 144     //  Perhaps this is not ideal behavior but it is the current behavior.
 145     addrman.Good(CAddress(addr1_port, NODE_NONE));
 146     BOOST_CHECK(addrman.size() == 1);
 147     bool newOnly = true;
 148     CAddrInfo addr_ret3 = addrman.Select(newOnly);
 149     BOOST_CHECK(addr_ret3.ToString() == "250.1.1.1:8333");
 150 }
 151
 152
 153 BOOST_AUTO_TEST_CASE(addrman_select)
 154 {
 155     CAddrManTest addrman;
 156
 157     // Set addrman addr placement to be deterministic.
 158     addrman.MakeDeterministic();
 159
 160     CNetAddr source = ResolveIP("252.2.2.2");
 161
 162     // Test 9: Select from new with 1 addr in new.
 163     CService addr1 = ResolveService("250.1.1.1", 8333);
 164     addrman.Add(CAddress(addr1, NODE_NONE), source);
 165     BOOST_CHECK(addrman.size() == 1);
 166
 167     bool newOnly = true;
 168     CAddrInfo addr_ret1 = addrman.Select(newOnly);
 169     BOOST_CHECK(addr_ret1.ToString() == "250.1.1.1:8333");
 170
 171     // Test 10: move addr to tried, select from new expected nothing returned.
 172     addrman.Good(CAddress(addr1, NODE_NONE));
 173     BOOST_CHECK(addrman.size() == 1);
 174     CAddrInfo addr_ret2 = addrman.Select(newOnly);
 175     BOOST_CHECK(addr_ret2.ToString() == "[::]:0");
 176
 177     CAddrInfo addr_ret3 = addrman.Select();
 178     BOOST_CHECK(addr_ret3.ToString() == "250.1.1.1:8333");
 179
 180     BOOST_CHECK(addrman.size() == 1);
 181
 182
 183     // Add three addresses to new table.
 184     CService addr2 = ResolveService("250.3.1.1", 8333);
 185     CService addr3 = ResolveService("250.3.2.2", 9999);
 186     CService addr4 = ResolveService("250.3.3.3", 9999);
 187
 188     addrman.Add(CAddress(addr2, NODE_NONE), ResolveService("250.3.1.1", 8333));
 189     addrman.Add(CAddress(addr3, NODE_NONE), ResolveService("250.3.1.1", 8333));
 190     addrman.Add(CAddress(addr4, NODE_NONE), ResolveService("250.4.1.1", 8333));
 191
 192     // Add three addresses to tried table.
 193     CService addr5 = ResolveService("250.4.4.4", 8333);
 194     CService addr6 = ResolveService("250.4.5.5", 7777);
 195     CService addr7 = ResolveService("250.4.6.6", 8333);
 196
 197     addrman.Add(CAddress(addr5, NODE_NONE), ResolveService("250.3.1.1", 8333));
 198     addrman.Good(CAddress(addr5, NODE_NONE));
 199     addrman.Add(CAddress(addr6, NODE_NONE), ResolveService("250.3.1.1", 8333));
 200     addrman.Good(CAddress(addr6, NODE_NONE));
 201     addrman.Add(CAddress(addr7, NODE_NONE), ResolveService("250.1.1.3", 8333));
 202     addrman.Good(CAddress(addr7, NODE_NONE));
 203
 204     // Test 11: 6 addrs + 1 addr from last test = 7.
 205     BOOST_CHECK(addrman.size() == 7);
 206
 207     // Test 12: Select pulls from new and tried regardless of port number.
 208     BOOST_CHECK(addrman.Select().ToString() == "250.4.6.6:8333");
 209     BOOST_CHECK(addrman.Select().ToString() == "250.3.2.2:9999");
 210     BOOST_CHECK(addrman.Select().ToString() == "250.3.3.3:9999");
 211     BOOST_CHECK(addrman.Select().ToString() == "250.4.4.4:8333");
 212 }
 213
 214 BOOST_AUTO_TEST_CASE(addrman_new_collisions)
 215 {
 216     CAddrManTest addrman;
 217
 218     // Set addrman addr placement to be deterministic.
 219     addrman.MakeDeterministic();
 220
 221     CNetAddr source = ResolveIP("252.2.2.2");
 222
 223     BOOST_CHECK(addrman.size() == 0);
 224
 225     for (unsigned int i = 1; i < 18; i++) {
 226         CService addr = ResolveService("250.1.1." + boost::to_string(i));
 227         addrman.Add(CAddress(addr, NODE_NONE), source);
 228
 229         //Test 13: No collision in new table yet.
 230         BOOST_CHECK(addrman.size() == i);
 231     }
 232
 233     //Test 14: new table collision!
 234     CService addr1 = ResolveService("250.1.1.18");
 235     addrman.Add(CAddress(addr1, NODE_NONE), source);
 236     BOOST_CHECK(addrman.size() == 17);
 237
 238     CService addr2 = ResolveService("250.1.1.19");
 239     addrman.Add(CAddress(addr2, NODE_NONE), source);
 240     BOOST_CHECK(addrman.size() == 18);
 241 }
 242
 243 BOOST_AUTO_TEST_CASE(addrman_tried_collisions)
 244 {
 245     CAddrManTest addrman;
 246
 247     // Set addrman addr placement to be deterministic.
 248     addrman.MakeDeterministic();
 249
 250     CNetAddr source = ResolveIP("252.2.2.2");
 251
 252     BOOST_CHECK(addrman.size() == 0);
 253
 254     for (unsigned int i = 1; i < 80; i++) {
 255         CService addr = ResolveService("250.1.1." + boost::to_string(i));
 256         addrman.Add(CAddress(addr, NODE_NONE), source);
 257         addrman.Good(CAddress(addr, NODE_NONE));
 258
 259         //Test 15: No collision in tried table yet.
 260         BOOST_CHECK_EQUAL(addrman.size(), i);
 261     }
 262
 263     //Test 16: tried table collision!
 264     CService addr1 = ResolveService("250.1.1.80");
 265     addrman.Add(CAddress(addr1, NODE_NONE), source);
 266     BOOST_CHECK(addrman.size() == 79);
 267
 268     CService addr2 = ResolveService("250.1.1.81");
 269     addrman.Add(CAddress(addr2, NODE_NONE), source);
 270     BOOST_CHECK(addrman.size() == 80);
 271 }
 272
 273 BOOST_AUTO_TEST_CASE(addrman_find)
 274 {
 275     CAddrManTest addrman;
 276
 277     // Set addrman addr placement to be deterministic.
 278     addrman.MakeDeterministic();
 279
 280     BOOST_CHECK(addrman.size() == 0);
 281
 282     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
 283     CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
 284     CAddress addr3 = CAddress(ResolveService("251.255.2.1", 8333), NODE_NONE);
 285
 286     CNetAddr source1 = ResolveIP("250.1.2.1");
 287     CNetAddr source2 = ResolveIP("250.1.2.2");
 288
 289     addrman.Add(addr1, source1);
 290     addrman.Add(addr2, source2);
 291     addrman.Add(addr3, source1);
 292
 293     // Test 17: ensure Find returns an IP matching what we searched on.
 294     CAddrInfo* info1 = addrman.Find(addr1);
 295     BOOST_CHECK(info1);
 296     if (info1)
 297         BOOST_CHECK(info1->ToString() == "250.1.2.1:8333");
 298
 299     // Test 18; Find does not discriminate by port number.
 300     CAddrInfo* info2 = addrman.Find(addr2);
 301     BOOST_CHECK(info2);
 302     if (info2)
 303         BOOST_CHECK(info2->ToString() == info1->ToString());
 304
 305     // Test 19: Find returns another IP matching what we searched on.
 306     CAddrInfo* info3 = addrman.Find(addr3);
 307     BOOST_CHECK(info3);
 308     if (info3)
 309         BOOST_CHECK(info3->ToString() == "251.255.2.1:8333");
 310 }
 311
 312 BOOST_AUTO_TEST_CASE(addrman_create)
 313 {
 314     CAddrManTest addrman;
 315
 316     // Set addrman addr placement to be deterministic.
 317     addrman.MakeDeterministic();
 318
 319     BOOST_CHECK(addrman.size() == 0);
 320
 321     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
 322     CNetAddr source1 = ResolveIP("250.1.2.1");
 323
 324     int nId;
 325     CAddrInfo* pinfo = addrman.Create(addr1, source1, &nId);
 326
 327     // Test 20: The result should be the same as the input addr.
 328     BOOST_CHECK(pinfo->ToString() == "250.1.2.1:8333");
 329
 330     CAddrInfo* info2 = addrman.Find(addr1);
 331     BOOST_CHECK(info2->ToString() == "250.1.2.1:8333");
 332 }
 333
 334
 335 BOOST_AUTO_TEST_CASE(addrman_delete)
 336 {
 337     CAddrManTest addrman;
 338
 339     // Set addrman addr placement to be deterministic.
 340     addrman.MakeDeterministic();
 341
 342     BOOST_CHECK(addrman.size() == 0);
 343
 344     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
 345     CNetAddr source1 = ResolveIP("250.1.2.1");
 346
 347     int nId;
 348     addrman.Create(addr1, source1, &nId);
 349
 350     // Test 21: Delete should actually delete the addr.
 351     BOOST_CHECK(addrman.size() == 1);
 352     addrman.Delete(nId);
 353     BOOST_CHECK(addrman.size() == 0);
 354     CAddrInfo* info2 = addrman.Find(addr1);
 355     BOOST_CHECK(info2 == NULL);
 356 }
 357
 358 BOOST_AUTO_TEST_CASE(addrman_getaddr)
 359 {
 360     CAddrManTest addrman;
 361
 362     // Set addrman addr placement to be deterministic.
 363     addrman.MakeDeterministic();
 364
 365     // Test 22: Sanity check, GetAddr should never return anything if addrman
 366     //  is empty.
 367     BOOST_CHECK(addrman.size() == 0);
 368     vector<CAddress> vAddr1 = addrman.GetAddr();
 369     BOOST_CHECK(vAddr1.size() == 0);
 370
 371     CAddress addr1 = CAddress(ResolveService("250.250.2.1", 8333), NODE_NONE);
 372     addr1.nTime = GetAdjustedTime(); // Set time so isTerrible = false
 373     CAddress addr2 = CAddress(ResolveService("250.251.2.2", 9999), NODE_NONE);
 374     addr2.nTime = GetAdjustedTime();
 375     CAddress addr3 = CAddress(ResolveService("251.252.2.3", 8333), NODE_NONE);
 376     addr3.nTime = GetAdjustedTime();
 377     CAddress addr4 = CAddress(ResolveService("252.253.3.4", 8333), NODE_NONE);
 378     addr4.nTime = GetAdjustedTime();
 379     CAddress addr5 = CAddress(ResolveService("252.254.4.5", 8333), NODE_NONE);
 380     addr5.nTime = GetAdjustedTime();
 381     CNetAddr source1 = ResolveIP("250.1.2.1");
 382     CNetAddr source2 = ResolveIP("250.2.3.3");
 383
 384     // Test 23: Ensure GetAddr works with new addresses.
 385     addrman.Add(addr1, source1);
 386     addrman.Add(addr2, source2);
 387     addrman.Add(addr3, source1);
 388     addrman.Add(addr4, source2);
 389     addrman.Add(addr5, source1);
 390
 391     // GetAddr returns 23% of addresses, 23% of 5 is 1 rounded down.
 392     BOOST_CHECK(addrman.GetAddr().size() == 1);
 393
 394     // Test 24: Ensure GetAddr works with new and tried addresses.
 395     addrman.Good(CAddress(addr1, NODE_NONE));
 396     addrman.Good(CAddress(addr2, NODE_NONE));
 397     BOOST_CHECK(addrman.GetAddr().size() == 1);
 398
 399     // Test 25: Ensure GetAddr still returns 23% when addrman has many addrs.
 400     for (unsigned int i = 1; i < (8 * 256); i++) {
 401         int octet1 = i % 256;
 402         int octet2 = (i / 256) % 256;
 403         int octet3 = (i / (256 * 2)) % 256;
 404         string strAddr = boost::to_string(octet1) + "." + boost::to_string(octet2) + "." + boost::to_string(octet3) + ".23";
 405         CAddress addr = CAddress(ResolveService(strAddr), NODE_NONE);
 406
 407         // Ensure that for all addrs in addrman, isTerrible == false.
 408         addr.nTime = GetAdjustedTime();
 409         addrman.Add(addr, ResolveIP(strAddr));
 410         if (i % 8 == 0)
 411             addrman.Good(addr);
 412     }
 413     vector<CAddress> vAddr = addrman.GetAddr();
 414
 415     size_t percent23 = (addrman.size() * 23) / 100;
 416     BOOST_CHECK(vAddr.size() == percent23);
 417     BOOST_CHECK(vAddr.size() == 461);
 418     // (Addrman.size() < number of addresses added) due to address collisons.
 419     BOOST_CHECK(addrman.size() == 2007);
 420 }
 421
 422
 423 BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket)
 424 {
 425     CAddrManTest addrman;
 426
 427     // Set addrman addr placement to be deterministic.
 428     addrman.MakeDeterministic();
 429
 430     CAddress addr1 = CAddress(ResolveService("250.1.1.1", 8333), NODE_NONE);
 431     CAddress addr2 = CAddress(ResolveService("250.1.1.1", 9999), NODE_NONE);
 432
 433     CNetAddr source1 = ResolveIP("250.1.1.1");
 434
 435
 436     CAddrInfo info1 = CAddrInfo(addr1, source1);
 437
 438     uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
 439     uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
 440
 441
 442     BOOST_CHECK(info1.GetTriedBucket(nKey1) == 40);
 443
 444     // Test 26: Make sure key actually randomizes bucket placement. A fail on
 445     //  this test could be a security issue.
 446     BOOST_CHECK(info1.GetTriedBucket(nKey1) != info1.GetTriedBucket(nKey2));
 447
 448     // Test 27: Two addresses with same IP but different ports can map to
 449     //  different buckets because they have different keys.
 450     CAddrInfo info2 = CAddrInfo(addr2, source1);
 451
 452     BOOST_CHECK(info1.GetKey() != info2.GetKey());
 453     BOOST_CHECK(info1.GetTriedBucket(nKey1) != info2.GetTriedBucket(nKey1));
 454
 455     set<int> buckets;
 456     for (int i = 0; i < 255; i++) {
 457         CAddrInfo infoi = CAddrInfo(
 458             CAddress(ResolveService("250.1.1." + boost::to_string(i)), NODE_NONE),
 459             ResolveIP("250.1.1." + boost::to_string(i)));
 460         int bucket = infoi.GetTriedBucket(nKey1);
 461         buckets.insert(bucket);
 462     }
 463     // Test 28: IP addresses in the same group (\16 prefix for IPv4) should
 464     //  never get more than 8 buckets
 465     BOOST_CHECK(buckets.size() == 8);
 466
 467     buckets.clear();
 468     for (int j = 0; j < 255; j++) {
 469         CAddrInfo infoj = CAddrInfo(
 470             CAddress(ResolveService("250." + boost::to_string(j) + ".1.1"), NODE_NONE),
 471             ResolveIP("250." + boost::to_string(j) + ".1.1"));
 472         int bucket = infoj.GetTriedBucket(nKey1);
 473         buckets.insert(bucket);
 474     }
 475     // Test 29: IP addresses in the different groups should map to more than
 476     //  8 buckets.
 477     BOOST_CHECK(buckets.size() == 160);
 478 }
 479
 480 BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)
 481 {
 482     CAddrManTest addrman;
 483
 484     // Set addrman addr placement to be deterministic.
 485     addrman.MakeDeterministic();
 486
 487     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
 488     CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
 489
 490     CNetAddr source1 = ResolveIP("250.1.2.1");
 491
 492     CAddrInfo info1 = CAddrInfo(addr1, source1);
 493
 494     uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
 495     uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
 496
 497     BOOST_CHECK(info1.GetNewBucket(nKey1) == 786);
 498
 499     // Test 30: Make sure key actually randomizes bucket placement. A fail on
 500     //  this test could be a security issue.
 501     BOOST_CHECK(info1.GetNewBucket(nKey1) != info1.GetNewBucket(nKey2));
 502
 503     // Test 31: Ports should not effect bucket placement in the addr
 504     CAddrInfo info2 = CAddrInfo(addr2, source1);
 505     BOOST_CHECK(info1.GetKey() != info2.GetKey());
 506     BOOST_CHECK(info1.GetNewBucket(nKey1) == info2.GetNewBucket(nKey1));
 507
 508     set<int> buckets;
 509     for (int i = 0; i < 255; i++) {
 510         CAddrInfo infoi = CAddrInfo(
 511             CAddress(ResolveService("250.1.1." + boost::to_string(i)), NODE_NONE),
 512             ResolveIP("250.1.1." + boost::to_string(i)));
 513         int bucket = infoi.GetNewBucket(nKey1);
 514         buckets.insert(bucket);
 515     }
 516     // Test 32: IP addresses in the same group (\16 prefix for IPv4) should
 517     //  always map to the same bucket.
 518     BOOST_CHECK(buckets.size() == 1);
 519
 520     buckets.clear();
 521     for (int j = 0; j < 4 * 255; j++) {
 522         CAddrInfo infoj = CAddrInfo(CAddress(
 523                                         ResolveService(
 524                                             boost::to_string(250 + (j / 255)) + "." + boost::to_string(j % 256) + ".1.1"), NODE_NONE),
 525             ResolveIP("251.4.1.1"));
 526         int bucket = infoj.GetNewBucket(nKey1);
 527         buckets.insert(bucket);
 528     }
 529     // Test 33: IP addresses in the same source groups should map to no more
 530     //  than 64 buckets.
 531     BOOST_CHECK(buckets.size() <= 64);
 532
 533     buckets.clear();
 534     for (int p = 0; p < 255; p++) {
 535         CAddrInfo infoj = CAddrInfo(
 536             CAddress(ResolveService("250.1.1.1"), NODE_NONE),
 537             ResolveIP("250." + boost::to_string(p) + ".1.1"));
 538         int bucket = infoj.GetNewBucket(nKey1);
 539         buckets.insert(bucket);
 540     }
 541     // Test 34: IP addresses in the different source groups should map to more
 542     //  than 64 buckets.
 543     BOOST_CHECK(buckets.size() > 64);
 544 }
 545 BOOST_AUTO_TEST_SUITE_END()