src/test/addrman_tests.cpp

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