folly/test/IPAddressTest.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <sys/types.h>
  18
  19 #include <string>
  20
  21 #include <folly/BitIterator.h>
  22 #include <folly/Bits.h>
  23 #include <folly/Format.h>
  24 #include <folly/IPAddress.h>
  25 #include <folly/MacAddress.h>
  26 #include <folly/String.h>
  27 #include <folly/detail/IPAddressSource.h>
  28 #include <folly/portability/GMock.h>
  29 #include <folly/portability/GTest.h>
  30
  31 using namespace folly;
  32 using namespace std;
  33 using namespace testing;
  34
  35 typedef std::vector<uint8_t> ByteVector;
  36
  37 struct AddressData {
  38   std::string address;
  39   ByteVector bytes;
  40   uint8_t version;
  41
  42   AddressData(
  43       const std::string& address,
  44       const ByteVector& bytes,
  45       uint8_t version)
  46       : address(address), bytes(bytes), version(version) {}
  47   AddressData(const std::string& address, uint8_t version)
  48       : address(address), bytes(), version(version) {}
  49   explicit AddressData(const std::string& address)
  50       : address(address), bytes(), version(0) {}
  51   AddressData() : address(""), bytes(), version(0) {}
  52
  53   static in_addr parseAddress4(const std::string& src) {
  54     in_addr addr;
  55     inet_pton(AF_INET, src.c_str(), &addr);
  56     return addr;
  57   }
  58
  59   static in6_addr parseAddress6(const std::string& src) {
  60     in6_addr addr;
  61     inet_pton(AF_INET6, src.c_str(), &addr);
  62     return addr;
  63   }
  64 };
  65
  66 struct AddressFlags {
  67   std::string address;
  68   uint8_t flags;
  69   uint8_t version;
  70
  71   static const uint8_t IS_LOCAL = 1 << 0;
  72   static const uint8_t IS_NONROUTABLE = 1 << 1;
  73   static const uint8_t IS_PRIVATE = 1 << 2;
  74   static const uint8_t IS_ZERO = 1 << 3;
  75   static const uint8_t IS_LINK_LOCAL = 1 << 4;
  76   static const uint8_t IS_MULTICAST = 1 << 5;
  77   static const uint8_t IS_LINK_LOCAL_BROADCAST = 1 << 6;
  78
  79   AddressFlags(const std::string& addr, uint8_t version, uint8_t flags)
  80       : address(addr), flags(flags), version(version) {}
  81
  82   bool isLoopback() const {
  83     return (flags & IS_LOCAL);
  84   }
  85   bool isNonroutable() const {
  86     return (flags & IS_NONROUTABLE);
  87   }
  88   bool isPrivate() const {
  89     return (flags & IS_PRIVATE);
  90   }
  91   bool isZero() const {
  92     return (flags & IS_ZERO);
  93   }
  94   bool isLinkLocal() const {
  95     return (flags & IS_LINK_LOCAL);
  96   }
  97   bool isLinkLocalBroadcast() const {
  98     return (flags & IS_LINK_LOCAL_BROADCAST);
  99   }
 100 };
 101
 102 struct MaskData {
 103   std::string address;
 104   uint8_t mask;
 105   std::string subnet;
 106   MaskData(const std::string& addr, uint8_t mask, const std::string& subnet)
 107       : address(addr), mask(mask), subnet(subnet) {}
 108 };
 109
 110 struct MaskBoundaryData : MaskData {
 111   bool inSubnet;
 112   MaskBoundaryData(
 113       const std::string& addr,
 114       uint8_t mask,
 115       const std::string& subnet,
 116       bool inSubnet)
 117       : MaskData(addr, mask, subnet), inSubnet(inSubnet) {}
 118 };
 119
 120 struct SerializeData {
 121   std::string address;
 122   ByteVector bytes;
 123
 124   SerializeData(const std::string& addr, const ByteVector& bytes)
 125       : address(addr), bytes(bytes) {}
 126 };
 127
 128 struct IPAddressTest : TestWithParam<AddressData> {
 129   void ExpectIsValid(const IPAddress& addr) {
 130     AddressData param = GetParam();
 131     EXPECT_EQ(param.version, addr.version());
 132     EXPECT_EQ(param.address, addr.str());
 133     if (param.version == 4) {
 134       in_addr v4addr = AddressData::parseAddress4(param.address);
 135       EXPECT_EQ(0, memcmp(&v4addr, addr.asV4().toByteArray().data(), 4));
 136       EXPECT_TRUE(addr.isV4());
 137       EXPECT_FALSE(addr.isV6());
 138     } else {
 139       in6_addr v6addr = AddressData::parseAddress6(param.address);
 140       EXPECT_EQ(0, memcmp(&v6addr, addr.asV6().toByteArray().data(), 16));
 141       EXPECT_TRUE(addr.isV6());
 142       EXPECT_FALSE(addr.isV4());
 143     }
 144   }
 145 };
 146 struct IPAddressFlagTest : TestWithParam<AddressFlags> {};
 147 struct IPAddressCtorTest : TestWithParam<std::string> {};
 148 struct IPAddressCtorBinaryTest : TestWithParam<ByteVector> {};
 149 struct IPAddressMappedTest
 150     : TestWithParam<std::pair<std::string, std::string>> {};
 151 struct IPAddressMaskTest : TestWithParam<MaskData> {};
 152 struct IPAddressMaskBoundaryTest : TestWithParam<MaskBoundaryData> {};
 153 struct IPAddressSerializeTest : TestWithParam<SerializeData> {};
 154 struct IPAddressByteAccessorTest : TestWithParam<AddressData> {};
 155 struct IPAddressBitAccessorTest : TestWithParam<AddressData> {};
 156
 157 // tests code example
 158 TEST(IPAddress, CodeExample) {
 159   EXPECT_EQ(4, sizeof(IPAddressV4));
 160   EXPECT_EQ(20, sizeof(IPAddressV6));
 161   EXPECT_EQ(24, sizeof(IPAddress));
 162   IPAddress uninitaddr;
 163   IPAddress v4addr("192.0.2.129");
 164   IPAddress v6map("::ffff:192.0.2.129");
 165   ASSERT_TRUE(uninitaddr.empty());
 166   ASSERT_FALSE(v4addr.empty());
 167   ASSERT_FALSE(v6map.empty());
 168   EXPECT_TRUE(v4addr.inSubnet("192.0.2.0/24"));
 169   EXPECT_TRUE(v4addr.inSubnet(IPAddress("192.0.2.0"), 24));
 170   EXPECT_TRUE(v4addr.inSubnet("192.0.2.128/30"));
 171   EXPECT_FALSE(v4addr.inSubnet("192.0.2.128/32"));
 172   EXPECT_EQ(2164392128, v4addr.asV4().toLong());
 173   EXPECT_EQ(3221226113, v4addr.asV4().toLongHBO());
 174   ASSERT_FALSE(uninitaddr.isV4());
 175   ASSERT_FALSE(uninitaddr.isV6());
 176   ASSERT_TRUE(v4addr.isV4());
 177   ASSERT_TRUE(v6map.isV6());
 178   EXPECT_TRUE(v4addr == v6map);
 179   ASSERT_TRUE(v6map.isIPv4Mapped());
 180   EXPECT_TRUE(v4addr.asV4() == IPAddress::createIPv4(v6map));
 181   EXPECT_TRUE(IPAddress::createIPv6(v4addr) == v6map.asV6());
 182 }
 183
 184 TEST(IPAddress, Scope) {
 185   // Test that link-local scope is saved
 186   auto str = "fe80::62eb:69ff:fe9b:ba60%eth0";
 187   IPAddressV6 a2(str);
 188   EXPECT_EQ(str, a2.str());
 189
 190   sockaddr_in6 sock = a2.toSockAddr();
 191   EXPECT_NE(0, sock.sin6_scope_id);
 192
 193   IPAddress a1(str);
 194   EXPECT_EQ(str, a1.str());
 195
 196   a2.setScopeId(0);
 197   EXPECT_NE(a1, a2);
 198
 199   EXPECT_TRUE(a2 < a1);
 200 }
 201
 202 TEST(IPAddress, ScopeNumeric) {
 203   // it's very unlikely that the host running these
 204   // tests will have 42 network interfaces
 205   auto str = "fe80::62eb:69ff:fe9b:ba60%42";
 206   IPAddressV6 a2(str);
 207   EXPECT_EQ(str, a2.str());
 208
 209   sockaddr_in6 sock = a2.toSockAddr();
 210   EXPECT_NE(0, sock.sin6_scope_id);
 211
 212   IPAddress a1(str);
 213   EXPECT_EQ(str, a1.str());
 214
 215   a2.setScopeId(0);
 216   EXPECT_NE(a1, a2);
 217
 218   EXPECT_TRUE(a2 < a1);
 219 }
 220
 221 TEST(IPAddress, Ordering) {
 222   IPAddress a1("0.1.1.1");
 223   IPAddress a2("1.1.1.0");
 224   EXPECT_TRUE(a1 < a2);
 225
 226   IPAddress b1("::ffff:0.1.1.1");
 227   IPAddress b2("::ffff:1.1.1.0");
 228   EXPECT_TRUE(b1 < b2);
 229 }
 230
 231 TEST(IPAddress, InvalidAddressFamilyExceptions) {
 232   // asV4
 233   {
 234     IPAddress addr;
 235     EXPECT_THROW(addr.asV4(), InvalidAddressFamilyException);
 236   }
 237   // asV6
 238   {
 239     IPAddress addr;
 240     EXPECT_THROW(addr.asV6(), InvalidAddressFamilyException);
 241   }
 242   // sockaddr ctor
 243   {
 244     // setup
 245     sockaddr_in addr;
 246     addr.sin_family = AF_UNSPEC;
 247
 248     EXPECT_THROW(IPAddress((sockaddr*)&addr), InvalidAddressFamilyException);
 249   }
 250 }
 251
 252 TEST(IPAddress, CreateNetwork) {
 253   // test valid IPv4 network
 254   {
 255     auto net = IPAddress::createNetwork("192.168.0.1/24");
 256     ASSERT_TRUE(net.first.isV4());
 257     EXPECT_EQ("192.168.0.0", net.first.str());
 258     EXPECT_EQ(24, net.second);
 259     EXPECT_EQ("192.168.0.0/24", IPAddress::networkToString(net));
 260   }
 261   // test valid IPv4 network without applying mask
 262   {
 263     auto net = IPAddress::createNetwork("192.168.0.1/24", -1, false);
 264     ASSERT_TRUE(net.first.isV4());
 265     EXPECT_EQ("192.168.0.1", net.first.str());
 266     EXPECT_EQ(24, net.second);
 267     EXPECT_EQ("192.168.0.1/24", IPAddress::networkToString(net));
 268   }
 269   // test valid IPv6 network
 270   {
 271     auto net = IPAddress::createNetwork("1999::1/24");
 272     ASSERT_TRUE(net.first.isV6());
 273     EXPECT_EQ("1999::", net.first.str());
 274     EXPECT_EQ(24, net.second);
 275     EXPECT_EQ("1999::/24", IPAddress::networkToString(net));
 276   }
 277   // test valid IPv6 network without applying mask
 278   {
 279     auto net = IPAddress::createNetwork("1999::1/24", -1, false);
 280     ASSERT_TRUE(net.first.isV6());
 281     EXPECT_EQ("1999::1", net.first.str());
 282     EXPECT_EQ(24, net.second);
 283     EXPECT_EQ("1999::1/24", IPAddress::networkToString(net));
 284   }
 285   // test empty string
 286   EXPECT_THROW(IPAddress::createNetwork(""), IPAddressFormatException);
 287   // test multi slash string
 288   EXPECT_THROW(
 289       IPAddress::createNetwork("192.168.0.1/24/36"), IPAddressFormatException);
 290   // test no slash string with default IPv4
 291   {
 292     auto net = IPAddress::createNetwork("192.168.0.1");
 293     ASSERT_TRUE(net.first.isV4());
 294     EXPECT_EQ("192.168.0.1", net.first.str());
 295     EXPECT_EQ(32, net.second); // auto-detected
 296     net = IPAddress::createNetwork("192.168.0.1", -1, false);
 297     ASSERT_TRUE(net.first.isV4());
 298     EXPECT_EQ("192.168.0.1", net.first.str());
 299     EXPECT_EQ(32, net.second);
 300   }
 301   // test no slash string with default IPv6
 302   {
 303     auto net = IPAddress::createNetwork("1999::1");
 304     ASSERT_TRUE(net.first.isV6());
 305     EXPECT_EQ("1999::1", net.first.str());
 306     EXPECT_EQ(128, net.second);
 307   }
 308   // test no slash string with invalid default
 309   EXPECT_THROW(
 310       IPAddress::createNetwork("192.168.0.1", 33), IPAddressFormatException);
 311 }
 312
 313 // test assignment operators
 314 TEST(IPAddress, Assignment) {
 315   static const string kIPv4Addr = "69.63.189.16";
 316   static const string kIPv6Addr = "2620:0:1cfe:face:b00c::3";
 317
 318   // Test assigning IPAddressV6 addr to IPAddress (was V4)
 319   {
 320     IPAddress addr(kIPv4Addr);
 321     IPAddressV6 addrV6 = IPAddress(kIPv6Addr).asV6();
 322     EXPECT_TRUE(addr.isV4());
 323     EXPECT_EQ(kIPv4Addr, addr.str());
 324     addr = addrV6;
 325     EXPECT_TRUE(addr.isV6());
 326     EXPECT_EQ(kIPv6Addr, addr.str());
 327   }
 328   // Test assigning IPAddressV4 addr to IPAddress (was V6)
 329   {
 330     IPAddress addr(kIPv6Addr);
 331     IPAddressV4 addrV4 = IPAddress(kIPv4Addr).asV4();
 332     EXPECT_TRUE(addr.isV6());
 333     EXPECT_EQ(kIPv6Addr, addr.str());
 334     addr = addrV4;
 335     EXPECT_TRUE(addr.isV4());
 336     EXPECT_EQ(kIPv4Addr, addr.str());
 337   }
 338   // Test assigning IPAddress(v6) to IPAddress (was v4)
 339   {
 340     IPAddress addr(kIPv4Addr);
 341     IPAddress addrV6 = IPAddress(kIPv6Addr);
 342     EXPECT_TRUE(addr.isV4());
 343     EXPECT_EQ(kIPv4Addr, addr.str());
 344     addr = addrV6;
 345     EXPECT_TRUE(addr.isV6());
 346     EXPECT_EQ(kIPv6Addr, addr.str());
 347   }
 348   // Test assigning IPAddress(v4) to IPAddress (was v6)
 349   {
 350     IPAddress addr(kIPv6Addr);
 351     IPAddress addrV4 = IPAddress(kIPv4Addr);
 352     EXPECT_TRUE(addr.isV6());
 353     EXPECT_EQ(kIPv6Addr, addr.str());
 354     addr = addrV4;
 355     EXPECT_TRUE(addr.isV4());
 356     EXPECT_EQ(kIPv4Addr, addr.str());
 357   }
 358 }
 359
 360 // Test the default constructors
 361 TEST(IPAddress, CtorDefault) {
 362   IPAddressV4 v4;
 363   EXPECT_EQ(IPAddressV4("0.0.0.0"), v4);
 364   IPAddressV6 v6;
 365   EXPECT_EQ(IPAddressV6("::0"), v6);
 366 }
 367
 368 TEST(IPAddressV4, validate) {
 369   EXPECT_TRUE(IPAddressV4::validate("0.0.0.0"));
 370   EXPECT_FALSE(IPAddressV4::validate("0.0.0."));
 371   EXPECT_TRUE(IPAddressV4::validate("127.127.127.127"));
 372 }
 373
 374 TEST(IPAddressV6, validate) {
 375   EXPECT_TRUE(IPAddressV6::validate("2620:0:1cfe:face:b00c::3"));
 376   EXPECT_FALSE(IPAddressV6::validate("0.0.0.0"));
 377   EXPECT_TRUE(IPAddressV6::validate("[2620:0:1cfe:face:b00c::3]"));
 378   EXPECT_TRUE(IPAddressV6::validate("::ffff:0.1.1.1"));
 379   EXPECT_TRUE(IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:0000:0003"));
 380   EXPECT_TRUE(
 381       IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:127.127.127.127"));
 382 }
 383
 384 TEST(IPAddress, validate) {
 385   EXPECT_TRUE(IPAddress::validate("0.0.0.0"));
 386   EXPECT_TRUE(IPAddress::validate("::"));
 387   EXPECT_FALSE(IPAddress::validate("asdf"));
 388 }
 389
 390 // Test addresses constructed using a in[6]_addr value
 391 TEST_P(IPAddressTest, CtorAddress) {
 392   AddressData param = GetParam();
 393   IPAddress strAddr(param.address);
 394   IPAddress address;
 395
 396   if (param.version == 4) {
 397     in_addr v4addr = detail::Bytes::mkAddress4(&param.bytes[0]);
 398     address = IPAddress(v4addr);
 399   } else {
 400     in6_addr v6addr = detail::Bytes::mkAddress6(&param.bytes[0]);
 401     address = IPAddress(v6addr);
 402   }
 403   ExpectIsValid(address);
 404   EXPECT_EQ(strAddr, address);
 405 }
 406
 407 // Test addresses constructed using a binary address
 408 TEST_P(IPAddressTest, CtorBinary) {
 409   AddressData param = GetParam();
 410   IPAddress address;
 411
 412   if (param.version == 4) {
 413     in_addr v4addr = AddressData::parseAddress4(param.address);
 414     address = IPAddress::fromBinary(ByteRange((unsigned char*)&v4addr, 4));
 415   } else {
 416     in6_addr v6addr = AddressData::parseAddress6(param.address);
 417     address = IPAddress::fromBinary(ByteRange((unsigned char*)&v6addr, 16));
 418   }
 419
 420   ExpectIsValid(address);
 421   EXPECT_EQ(IPAddress(param.address), address);
 422 }
 423
 424 // Test addresses constructed using a string
 425 TEST_P(IPAddressTest, CtorString) {
 426   AddressData param = GetParam();
 427   IPAddress address(param.address);
 428
 429   ExpectIsValid(address);
 430
 431   // Test the direct version-specific constructor
 432   if (param.version == 4) {
 433     IPAddressV4 v4(param.address);
 434     ExpectIsValid(IPAddress(v4));
 435     EXPECT_THROW(IPAddressV6 v6(param.address), IPAddressFormatException);
 436   } else if (param.version == 6) {
 437     IPAddressV6 v6(param.address);
 438     ExpectIsValid(IPAddress(v6));
 439     EXPECT_THROW(IPAddressV4 v4(param.address), IPAddressFormatException);
 440   }
 441 }
 442
 443 TEST(IPAddress, CtorSockaddr) {
 444   // test v4 address
 445   {
 446     // setup
 447     sockaddr_in addr;
 448     in_addr sin_addr;
 449     sin_addr.s_addr = htonl(2122547223);
 450     addr.sin_family = AF_INET;
 451     addr.sin_addr = sin_addr;
 452
 453     IPAddress ipAddr((sockaddr*)&addr);
 454     EXPECT_TRUE(ipAddr.isV4());
 455     EXPECT_EQ("126.131.128.23", ipAddr.str());
 456   }
 457   // test v6 address
 458   {
 459     // setup
 460     sockaddr_in6 addr;
 461     memset(&addr, 0, sizeof(addr));
 462     in6_addr sin_addr;
 463     // 2620:0:1cfe:face:b00c::3
 464     ByteArray16 sec{
 465         {38, 32, 0, 0, 28, 254, 250, 206, 176, 12, 0, 0, 0, 0, 0, 3}};
 466     std::memcpy(sin_addr.s6_addr, sec.data(), 16);
 467     addr.sin6_family = AF_INET6;
 468     addr.sin6_addr = sin_addr;
 469
 470     IPAddress ipAddr((sockaddr*)&addr);
 471     EXPECT_TRUE(ipAddr.isV6());
 472     EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
 473   }
 474   // test nullptr exception
 475   {
 476     sockaddr* addr = nullptr;
 477     EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
 478   }
 479   // test invalid family exception
 480   {
 481     // setup
 482     sockaddr_in addr;
 483     in_addr sin_addr;
 484     sin_addr.s_addr = htonl(2122547223);
 485     addr.sin_family = AF_UNSPEC;
 486     addr.sin_addr = sin_addr;
 487
 488     EXPECT_THROW(IPAddress((sockaddr*)&addr), IPAddressFormatException);
 489   }
 490 }
 491
 492 TEST(IPAddress, ToSockaddrStorage) {
 493   // test v4 address
 494   {
 495     string strAddr("126.131.128.23");
 496     IPAddress addr(strAddr);
 497     sockaddr_storage out;
 498
 499     ASSERT_TRUE(addr.isV4()); // test invariant
 500     EXPECT_GT(addr.toSockaddrStorage(&out), 0);
 501
 502     IPAddress sockAddr((sockaddr*)&out);
 503     ASSERT_TRUE(sockAddr.isV4());
 504     EXPECT_EQ(strAddr, sockAddr.str());
 505   }
 506   // test v6 address
 507   {
 508     string strAddr("2620:0:1cfe:face:b00c::3");
 509     IPAddress addr(strAddr);
 510     sockaddr_storage out;
 511
 512     ASSERT_TRUE(addr.isV6()); // test invariant
 513     EXPECT_GT(addr.toSockaddrStorage(&out), 0);
 514
 515     IPAddress sockAddr((sockaddr*)&out);
 516     ASSERT_TRUE(sockAddr.isV6());
 517     EXPECT_EQ(strAddr, sockAddr.str());
 518   }
 519   // test nullptr exception
 520   {
 521     sockaddr_storage* out = nullptr;
 522     IPAddress addr("127.0.0.1");
 523     EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
 524   }
 525   // test invalid family exception
 526   {
 527     IPAddress addr;
 528     sockaddr_storage out;
 529     ASSERT_EQ(AF_UNSPEC, addr.family());
 530     EXPECT_THROW(addr.toSockaddrStorage(&out), InvalidAddressFamilyException);
 531   }
 532 }
 533
 534 TEST(IPAddress, ToString) {
 535   // Test with IPAddressV4
 536   IPAddressV4 addr_10_0_0_1("10.0.0.1");
 537   EXPECT_EQ("10.0.0.1", folly::to<string>(addr_10_0_0_1));
 538   // Test with IPAddressV6
 539   IPAddressV6 addr_1("::1");
 540   EXPECT_EQ("::1", folly::to<string>(addr_1));
 541   // Test with IPAddress, both V4 and V6
 542   IPAddress addr_10_1_2_3("10.1.2.3");
 543   EXPECT_EQ("10.1.2.3", folly::to<string>(addr_10_1_2_3));
 544   IPAddress addr_1_2_3("1:2::3");
 545   EXPECT_EQ("1:2::3", folly::to<string>(addr_1_2_3));
 546
 547   // Test a combination of all the above arguments
 548   EXPECT_EQ(
 549       "1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3",
 550       folly::to<string>(
 551           addr_1_2_3,
 552           " - ",
 553           addr_10_0_0_1,
 554           " - ",
 555           addr_1,
 556           " - ",
 557           addr_10_1_2_3));
 558 }
 559
 560 TEST(IPaddress, toInverseArpaName) {
 561   IPAddressV4 addr_ipv4("10.0.0.1");
 562   EXPECT_EQ("1.0.0.10.in-addr.arpa", addr_ipv4.toInverseArpaName());
 563   IPAddressV6 addr_ipv6("2620:0000:1cfe:face:b00c:0000:0000:0003");
 564   EXPECT_EQ(
 565       sformat(
 566           "{}.ip6.arpa",
 567           "3.0.0.0.0.0.0.0.0.0.0.0.c.0.0.b.e.c.a.f.e.f.c.1.0.0.0.0.0.2.6.2"),
 568       addr_ipv6.toInverseArpaName());
 569 }
 570
 571 TEST(IPaddress, fromInverseArpaName) {
 572   EXPECT_EQ(
 573       IPAddressV4("10.0.0.1"),
 574       IPAddressV4::fromInverseArpaName("1.0.0.10.in-addr.arpa"));
 575   EXPECT_EQ(
 576       IPAddressV6("2620:0000:1cfe:face:b00c:0000:0000:0003"),
 577       IPAddressV6::fromInverseArpaName(sformat(
 578           "{}.ip6.arpa",
 579           "3.0.0.0.0.0.0.0.0.0.0.0.c.0.0.b.e.c.a.f.e.f.c.1.0.0.0.0.0.2.6.2")));
 580 }
 581
 582 // Test that invalid string values are killed
 583 TEST_P(IPAddressCtorTest, InvalidCreation) {
 584   string addr = GetParam();
 585   EXPECT_THROW(IPAddress((const string)addr), IPAddressFormatException)
 586       << "IPAddress(" << addr << ") "
 587       << "should have thrown an IPAddressFormatException";
 588 }
 589
 590 // Test that invalid binary values throw an exception
 591 TEST_P(IPAddressCtorBinaryTest, InvalidBinary) {
 592   auto bin = GetParam();
 593   EXPECT_THROW(
 594       IPAddress::fromBinary(ByteRange(&bin[0], bin.size())),
 595       IPAddressFormatException);
 596 }
 597
 598 TEST(IPAddressSource, ToHex) {
 599   vector<std::uint8_t> data = {{0xff, 0x20, 0x45}};
 600   EXPECT_EQ(detail::Bytes::toHex(data.data(), 0), "");
 601   EXPECT_EQ(detail::Bytes::toHex(data.data(), 1), "ff");
 602   EXPECT_EQ(detail::Bytes::toHex(data.data(), 2), "ff20");
 603   EXPECT_EQ(detail::Bytes::toHex(data.data(), 3), "ff2045");
 604 }
 605
 606 // Test toFullyQualified()
 607 TEST(IPAddress, ToFullyQualifiedFb) {
 608   IPAddress ip("2620:0:1cfe:face:b00c::3");
 609   EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", ip.toFullyQualified())
 610       << ip;
 611 }
 612 TEST(IPAddress, ToFullyQualifiedLocal) {
 613   IPAddress ip("::1");
 614   EXPECT_EQ("0000:0000:0000:0000:0000:0000:0000:0001", ip.toFullyQualified())
 615       << ip;
 616 }
 617 TEST(IPAddress, ToFullyQualifiedAppendV6) {
 618   IPAddress ip("2620:0:1cfe:face:b00c::3");
 619   std::string result;
 620   ip.toFullyQualifiedAppend(result);
 621   EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", result) << ip;
 622 }
 623 TEST(IPAddress, ToFullyQualifiedAppendV4) {
 624   IPAddress ip("127.0.0.1");
 625   std::string result;
 626   ip.toFullyQualifiedAppend(result);
 627   EXPECT_EQ("127.0.0.1", result) << ip;
 628 }
 629 TEST(IPAddress, ToFullyQualifiedSizeV6) {
 630   auto actual = IPAddressV6::kToFullyQualifiedSize;
 631   auto expected = IPAddress("::").toFullyQualified().size();
 632   EXPECT_EQ(expected, actual);
 633 }
 634 TEST(IPAddress, MaxToFullyQualifiedSizeV4) {
 635   auto actual = IPAddressV4::kMaxToFullyQualifiedSize;
 636   auto expected = IPAddress("255.255.255.255").toFullyQualified().size();
 637   EXPECT_EQ(expected, actual);
 638 }
 639
 640 // test v4-v6 mapped addresses
 641 TEST_P(IPAddressMappedTest, MappedEqual) {
 642   auto param = GetParam();
 643   string mappedIp = param.first;
 644   string otherIp = param.second;
 645
 646   auto mapped = IPAddress(mappedIp);
 647   auto expected = IPAddress(otherIp);
 648
 649   EXPECT_EQ(expected, mapped);
 650
 651   IPAddress v6addr;
 652   if (mapped.isV4()) {
 653     v6addr = mapped.asV4().createIPv6();
 654   } else if (expected.isV4()) {
 655     v6addr = expected.asV4().createIPv6();
 656   }
 657   EXPECT_TRUE(v6addr.isV6());
 658   EXPECT_TRUE(mapped == v6addr);
 659   EXPECT_TRUE(expected == v6addr);
 660 }
 661
 662 // Test subnet mask calculations
 663 TEST_P(IPAddressMaskTest, Masks) {
 664   auto param = GetParam();
 665
 666   IPAddress ip(param.address);
 667   IPAddress masked = ip.mask(param.mask);
 668   EXPECT_EQ(param.subnet, masked.str())
 669       << param.address << "/" << folly::to<std::string>(param.mask) << " -> "
 670       << param.subnet;
 671 }
 672
 673 // Test inSubnet calculations
 674 TEST_P(IPAddressMaskTest, InSubnet) {
 675   auto param = GetParam();
 676
 677   IPAddress ip(param.address);
 678   IPAddress subnet(param.subnet);
 679   EXPECT_TRUE(ip.inSubnet(subnet, param.mask));
 680 }
 681
 682 // Test boundary conditions for subnet calculations
 683 TEST_P(IPAddressMaskBoundaryTest, NonMaskedSubnet) {
 684   auto param = GetParam();
 685   IPAddress ip(param.address);
 686   IPAddress subnet(param.subnet);
 687   EXPECT_EQ(param.inSubnet, ip.inSubnet(subnet, param.mask));
 688 }
 689
 690 TEST(IPAddress, UnitializedEqual) {
 691   IPAddress addrEmpty;
 692   IPAddress ip4("127.0.0.1");
 693   EXPECT_FALSE(addrEmpty == ip4);
 694   EXPECT_FALSE(ip4 == addrEmpty);
 695   IPAddress ip6("::1");
 696   EXPECT_FALSE(addrEmpty == ip6);
 697   EXPECT_FALSE(ip6 == addrEmpty);
 698   IPAddress ip6Map("::ffff:192.0.2.129");
 699   EXPECT_FALSE(addrEmpty == ip6Map);
 700   EXPECT_FALSE(ip6Map == addrEmpty);
 701   IPAddress ip4Zero("0.0.0.0");
 702   EXPECT_FALSE(addrEmpty == ip4Zero);
 703   EXPECT_FALSE(ip4Zero == addrEmpty);
 704   IPAddress ip6Zero("::");
 705   EXPECT_FALSE(addrEmpty == ip6Zero);
 706   EXPECT_FALSE(ip6Zero == addrEmpty);
 707   EXPECT_EQ(addrEmpty, addrEmpty);
 708 }
 709
 710 // Test subnet calcs with 6to4 addresses
 711 TEST(IPAddress, InSubnetWith6to4) {
 712   auto ip = IPAddress("2002:c000:022a::"); // 192.0.2.42
 713   auto subnet = IPAddress("192.0.0.0");
 714   EXPECT_TRUE(ip.inSubnet(subnet, 16));
 715
 716   auto ip2 = IPAddress("192.0.0.1");
 717   auto subnet2 = IPAddress("2002:c000:0000::"); // 192.0.0.0
 718   EXPECT_TRUE(ip2.inSubnet(subnet2, 14));
 719
 720   auto ip3 = IPAddress("2002:c000:022a::"); // 192.0.2.42
 721   auto subnet3 = IPAddress("2002:c000:0000::"); // 192.0.0.0
 722   EXPECT_TRUE(ip3.inSubnet(subnet3, 16));
 723 }
 724
 725 static const vector<string> ipv4Strs = {
 726     "127.0.0.1",
 727     "198.168.0.1",
 728     "8.8.0.0",
 729 };
 730 TEST(IPAddress, getIPv6For6To4) {
 731   for (auto ipv4Str : ipv4Strs) {
 732     auto ip = IPAddress(ipv4Str);
 733     EXPECT_TRUE(ip.isV4());
 734     IPAddressV4 ipv4 = ip.asV4();
 735     auto ipv6 = ipv4.getIPv6For6To4();
 736     EXPECT_EQ(ipv6.type(), IPAddressV6::Type::T6TO4);
 737     auto ipv4New = ipv6.getIPv4For6To4();
 738     EXPECT_TRUE(ipv4Str.compare(ipv4New.str()) == 0);
 739   }
 740 }
 741
 742 static const vector<pair<string, uint8_t>> invalidMasks = {
 743     {"127.0.0.1", 33},
 744     {"::1", 129},
 745 };
 746 TEST(IPAddress, InvalidMask) {
 747   for (auto& tc : invalidMasks) {
 748     auto ip = IPAddress(tc.first);
 749     EXPECT_THROW(ip.mask(tc.second), IPAddressFormatException);
 750   }
 751 }
 752
 753 static const vector<pair<string, IPAddressV6::Type>> v6types = {
 754     {"::1", IPAddressV6::Type::NORMAL},
 755     {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL},
 756     {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO},
 757     {"2002:c000:022a::", IPAddressV6::Type::T6TO4},
 758 };
 759 TEST(IPAddress, V6Types) {
 760   auto mkName = [&](const IPAddressV6::Type t) -> string {
 761     switch (t) {
 762       case IPAddressV6::Type::TEREDO:
 763         return "teredo";
 764       case IPAddressV6::Type::T6TO4:
 765         return "6to4";
 766       default:
 767         return "default";
 768     }
 769   };
 770
 771   for (auto& tc : v6types) {
 772     auto ip = IPAddress(tc.first);
 773     EXPECT_TRUE(ip.isV6());
 774     IPAddressV6 ipv6 = ip.asV6();
 775     EXPECT_EQ(tc.second, ipv6.type())
 776         << "expected " << mkName(tc.second) << ", got " << mkName(ipv6.type());
 777     switch (tc.second) {
 778       case IPAddressV6::Type::TEREDO:
 779         EXPECT_TRUE(ipv6.isTeredo()) << "isTeredo was false";
 780         EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
 781         break;
 782       case IPAddressV6::Type::T6TO4:
 783         EXPECT_TRUE(ipv6.is6To4()) << "is6To4 was false";
 784         EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
 785         break;
 786       case IPAddressV6::Type::NORMAL:
 787         EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
 788         EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
 789         break;
 790       default:
 791         FAIL() << "Invalid expected type: " << to<std::string>(tc.second);
 792     }
 793   }
 794 }
 795
 796 static const vector<pair<string, uint32_t>> provideToLong = {
 797     {"0.0.0.0", 0},
 798     {"10.0.0.0", 167772160},
 799     {"126.131.128.23", 2122547223},
 800     {"192.168.0.0", 3232235520},
 801 };
 802 TEST(IPAddress, ToLong) {
 803   for (auto& tc : provideToLong) {
 804     auto ip = IPAddress(tc.first);
 805     EXPECT_TRUE(ip.isV4());
 806     IPAddressV4 ipv4 = ip.asV4();
 807     EXPECT_EQ(tc.second, ipv4.toLongHBO());
 808
 809     auto ip2 = IPAddress::fromLongHBO(tc.second);
 810     EXPECT_TRUE(ip2.isV4());
 811     EXPECT_TRUE(tc.first.compare(ip2.str()) == 0);
 812     EXPECT_EQ(tc.second, ip2.asV4().toLongHBO());
 813
 814     auto nla = htonl(tc.second);
 815     auto ip3 = IPAddress::fromLong(nla);
 816     EXPECT_TRUE(ip3.isV4());
 817     EXPECT_TRUE(tc.first.compare(ip3.str()) == 0);
 818     EXPECT_EQ(nla, ip3.asV4().toLong());
 819   }
 820 }
 821
 822 TEST(IPAddress, fromBinaryV4) {
 823   for (auto& tc : provideToLong) {
 824     SCOPED_TRACE(tc.first);
 825     union {
 826       uint8_t u8[4];
 827       uint32_t u32;
 828     } data;
 829     data.u32 = Endian::big(tc.second);
 830     ByteRange bytes(data.u8, 4);
 831
 832     auto fromBin = IPAddressV4::fromBinary(bytes);
 833     IPAddressV4 fromStr(tc.first);
 834     EXPECT_EQ(fromStr, fromBin);
 835
 836     IPAddressV4 addr2("0.0.0.0");
 837     addr2 = IPAddressV4::fromBinary(bytes);
 838     EXPECT_EQ(fromStr, addr2);
 839
 840     IPAddress genericAddr = IPAddress::fromBinary(bytes);
 841     ASSERT_TRUE(genericAddr.isV4());
 842     EXPECT_EQ(fromStr, genericAddr.asV4());
 843     EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
 844   }
 845
 846   uint8_t data[20];
 847   EXPECT_THROW(
 848       IPAddressV4::fromBinary(ByteRange(data, 3)), IPAddressFormatException);
 849   EXPECT_THROW(
 850       IPAddressV4::fromBinary(ByteRange(data, 16)), IPAddressFormatException);
 851   EXPECT_THROW(
 852       IPAddressV4::fromBinary(ByteRange(data, 20)), IPAddressFormatException);
 853 }
 854
 855 TEST(IPAddress, toBinaryV4) {
 856   for (auto& tc : provideToLong) {
 857     SCOPED_TRACE(tc.first);
 858     union {
 859       uint8_t u8[4];
 860       uint32_t u32;
 861     } data;
 862     data.u32 = Endian::big(tc.second);
 863     ByteRange bytes(data.u8, 4);
 864
 865     auto fromBin = IPAddressV4::fromBinary(bytes);
 866     auto toBin = fromBin.toBinary();
 867     EXPECT_EQ(bytes, toBin);
 868   }
 869 }
 870
 871 using ByteArray8 = std::array<uint8_t, 8>;
 872
 873 static auto join8 = [](std::array<ByteArray8, 2> parts) {
 874   ByteArray16 _return;
 875   std::memcpy(_return.data(), parts.data(), _return.size());
 876   return _return;
 877 };
 878
 879 static const vector<pair<string, ByteArray16>> provideBinary16Bytes = {
 880     make_pair(
 881         "::0",
 882         join8({{
 883             ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
 884             ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
 885         }})),
 886     make_pair(
 887         "1::2",
 888         join8({{
 889             ByteArray8{{0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
 890             ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
 891         }})),
 892     make_pair(
 893         "fe80::0012:34ff:fe56:78ab",
 894         join8(
 895             {{ByteArray8{{0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
 896               ByteArray8{{0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}}}})),
 897     make_pair(
 898         "2001:db8:1234:5678:90ab:cdef:8765:4321",
 899         join8({{
 900             ByteArray8{{0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78}},
 901             ByteArray8{{0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}},
 902         }})),
 903     make_pair(
 904         "::ffff:0:c0a8:1",
 905         join8({{
 906             ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
 907             ByteArray8{{0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
 908         }})),
 909 };
 910
 911 TEST(IPAddress, fromBinaryV6) {
 912   for (auto& tc : provideBinary16Bytes) {
 913     SCOPED_TRACE(tc.first);
 914     ByteRange bytes(&tc.second.front(), tc.second.size());
 915
 916     auto fromBin = IPAddressV6::fromBinary(bytes);
 917     IPAddressV6 fromStr(tc.first);
 918     EXPECT_EQ(fromStr, fromBin);
 919
 920     IPAddressV6 addr2("::0");
 921     addr2 = IPAddressV6::fromBinary(bytes);
 922     EXPECT_EQ(fromStr, addr2);
 923
 924     IPAddress genericAddr = IPAddress::fromBinary(bytes);
 925     ASSERT_TRUE(genericAddr.isV6());
 926     EXPECT_EQ(fromStr, genericAddr.asV6());
 927     EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
 928   }
 929
 930   uint8_t data[20];
 931   EXPECT_THROW(
 932       IPAddressV6::fromBinary(ByteRange(data, 3)), IPAddressFormatException);
 933   EXPECT_THROW(
 934       IPAddressV6::fromBinary(ByteRange(data, 4)), IPAddressFormatException);
 935   EXPECT_THROW(
 936       IPAddressV6::fromBinary(ByteRange(data, 20)), IPAddressFormatException);
 937 }
 938
 939 TEST(IPAddress, toBinaryV6) {
 940   for (auto& tc : provideBinary16Bytes) {
 941     SCOPED_TRACE(tc.first);
 942     ByteRange bytes(&tc.second.front(), tc.second.size());
 943
 944     auto fromBin = IPAddressV6::fromBinary(bytes);
 945     auto toBin = fromBin.toBinary();
 946     EXPECT_EQ(bytes, toBin);
 947   }
 948 }
 949
 950 TEST_P(IPAddressFlagTest, IsLoopback) {
 951   AddressFlags param = GetParam();
 952   IPAddress addr(param.address);
 953
 954   EXPECT_EQ(param.version, addr.version());
 955   EXPECT_EQ(param.isLoopback(), addr.isLoopback());
 956 }
 957
 958 TEST_P(IPAddressFlagTest, IsPrivate) {
 959   AddressFlags param = GetParam();
 960   IPAddress addr(param.address);
 961
 962   EXPECT_EQ(param.version, addr.version());
 963   EXPECT_EQ(param.isPrivate(), addr.isPrivate()) << addr;
 964 }
 965
 966 TEST_P(IPAddressFlagTest, IsNonroutable) {
 967   AddressFlags param = GetParam();
 968   IPAddress addr(param.address);
 969
 970   EXPECT_EQ(param.version, addr.version());
 971   EXPECT_EQ(param.isNonroutable(), addr.isNonroutable()) << addr;
 972 }
 973
 974 TEST_P(IPAddressFlagTest, IsZero) {
 975   AddressFlags param = GetParam();
 976   IPAddress addr(param.address);
 977
 978   EXPECT_EQ(param.version, addr.version());
 979   EXPECT_EQ(param.isZero(), addr.isZero()) << addr;
 980 }
 981
 982 TEST_P(IPAddressFlagTest, IsLinkLocal) {
 983   AddressFlags param = GetParam();
 984   IPAddress addr(param.address);
 985   EXPECT_EQ(param.isLinkLocal(), addr.isLinkLocal()) << addr;
 986 }
 987
 988 TEST(IPAddress, CreateLinkLocal) {
 989   IPAddressV6 addr(IPAddressV6::LINK_LOCAL, MacAddress("00:05:73:f9:46:fc"));
 990   EXPECT_EQ(IPAddressV6("fe80::0205:73ff:fef9:46fc"), addr);
 991
 992   addr = IPAddressV6(IPAddressV6::LINK_LOCAL, MacAddress("02:00:00:12:34:56"));
 993   EXPECT_EQ(IPAddressV6("fe80::ff:fe12:3456"), addr);
 994 }
 995
 996 TEST_P(IPAddressFlagTest, IsLinkLocalBroadcast) {
 997   AddressFlags param = GetParam();
 998   IPAddress addr(param.address);
 999   EXPECT_EQ(param.version, addr.version());
1000   EXPECT_EQ(param.isLinkLocalBroadcast(), addr.isLinkLocalBroadcast());
1001 }
1002
1003 TEST(IPAddress, SolicitedNodeAddress) {
1004   // An example from RFC 4291 section 2.7.1
1005   EXPECT_EQ(
1006       IPAddressV6("ff02::1:ff0e:8c6c"),
1007       IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress());
1008
1009   // An example from wikipedia
1010   // (http://en.wikipedia.org/wiki/Solicited-node_multicast_address)
1011   EXPECT_EQ(
1012       IPAddressV6("ff02::1:ff28:9c5a"),
1013       IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress());
1014 }
1015
1016 TEST_P(IPAddressByteAccessorTest, CheckBytes) {
1017   auto addrData = GetParam();
1018   IPAddress ip(addrData.address);
1019   size_t i = 0;
1020   for (auto byitr = addrData.bytes.begin(); i < ip.byteCount(); ++i, ++byitr) {
1021     EXPECT_EQ(*byitr, ip.getNthMSByte(i));
1022     EXPECT_EQ(
1023         *byitr,
1024         ip.isV4() ? ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i));
1025   }
1026   i = 0;
1027   for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount();
1028        ++i, ++byritr) {
1029     EXPECT_EQ(*byritr, ip.getNthLSByte(i));
1030     EXPECT_EQ(
1031         *byritr,
1032         ip.isV4() ? ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
1033   }
1034 }
1035
1036 TEST_P(IPAddressBitAccessorTest, CheckBits) {
1037   auto addrData = GetParam();
1038   auto littleEndianAddrData = addrData.bytes;
1039   // IPAddress stores address data in n/w byte order.
1040   reverse(littleEndianAddrData.begin(), littleEndianAddrData.end());
1041   // Bit iterator goes from LSBit to MSBit
1042   // We will traverse the IPAddress bits from 0 to bitCount -1
1043   auto bitr = folly::makeBitIterator(littleEndianAddrData.begin());
1044   IPAddress ip(addrData.address);
1045   for (size_t i = 0; i < ip.bitCount(); ++i) {
1046     auto msbIndex = ip.bitCount() - i - 1;
1047     EXPECT_EQ(*bitr, ip.getNthMSBit(msbIndex));
1048     EXPECT_EQ(
1049         *bitr,
1050         ip.isV4() ? ip.asV4().getNthMSBit(msbIndex)
1051                   : ip.asV6().getNthMSBit(msbIndex));
1052     EXPECT_EQ(*bitr, ip.getNthLSBit(i));
1053     EXPECT_EQ(
1054         *bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) : ip.asV6().getNthLSBit(i));
1055     ++bitr;
1056   }
1057 }
1058
1059 TEST(IPAddress, InvalidByteAccess) {
1060   IPAddress ip4("10.10.10.10");
1061   // MSByte, LSByte accessors are 0 indexed
1062   EXPECT_THROW(ip4.getNthMSByte(ip4.byteCount()), std::invalid_argument);
1063   EXPECT_THROW(ip4.getNthLSByte(ip4.byteCount()), std::invalid_argument);
1064   EXPECT_THROW(ip4.getNthMSByte(-1), std::invalid_argument);
1065   EXPECT_THROW(ip4.getNthLSByte(-1), std::invalid_argument);
1066   auto asV4 = ip4.asV4();
1067   EXPECT_THROW(asV4.getNthMSByte(asV4.byteCount()), std::invalid_argument);
1068   EXPECT_THROW(asV4.getNthLSByte(asV4.byteCount()), std::invalid_argument);
1069   EXPECT_THROW(asV4.getNthMSByte(-1), std::invalid_argument);
1070   EXPECT_THROW(asV4.getNthLSByte(-1), std::invalid_argument);
1071
1072   IPAddress ip6("2620:0:1cfe:face:b00c::3");
1073   EXPECT_THROW(ip6.getNthMSByte(ip6.byteCount()), std::invalid_argument);
1074   EXPECT_THROW(ip6.getNthLSByte(ip6.byteCount()), std::invalid_argument);
1075   EXPECT_THROW(ip6.getNthMSByte(-1), std::invalid_argument);
1076   EXPECT_THROW(ip6.getNthLSByte(-1), std::invalid_argument);
1077   auto asV6 = ip6.asV6();
1078   EXPECT_THROW(asV6.getNthMSByte(asV6.byteCount()), std::invalid_argument);
1079   EXPECT_THROW(asV6.getNthLSByte(asV6.byteCount()), std::invalid_argument);
1080   EXPECT_THROW(asV6.getNthMSByte(-1), std::invalid_argument);
1081   EXPECT_THROW(asV6.getNthLSByte(-1), std::invalid_argument);
1082 }
1083
1084 TEST(IPAddress, InvalidBBitAccess) {
1085   IPAddress ip4("10.10.10.10");
1086   // MSByte, LSByte accessors are 0 indexed
1087   EXPECT_THROW(ip4.getNthMSBit(ip4.bitCount()), std::invalid_argument);
1088   EXPECT_THROW(ip4.getNthLSBit(ip4.bitCount()), std::invalid_argument);
1089   EXPECT_THROW(ip4.getNthMSBit(-1), std::invalid_argument);
1090   EXPECT_THROW(ip4.getNthLSBit(-1), std::invalid_argument);
1091   auto asV4 = ip4.asV4();
1092   EXPECT_THROW(asV4.getNthMSBit(asV4.bitCount()), std::invalid_argument);
1093   EXPECT_THROW(asV4.getNthLSBit(asV4.bitCount()), std::invalid_argument);
1094   EXPECT_THROW(asV4.getNthMSBit(-1), std::invalid_argument);
1095   EXPECT_THROW(asV4.getNthLSBit(-1), std::invalid_argument);
1096
1097   IPAddress ip6("2620:0:1cfe:face:b00c::3");
1098   EXPECT_THROW(ip6.getNthMSBit(ip6.bitCount()), std::invalid_argument);
1099   EXPECT_THROW(ip6.getNthLSBit(ip6.bitCount()), std::invalid_argument);
1100   EXPECT_THROW(ip6.getNthMSBit(-1), std::invalid_argument);
1101   EXPECT_THROW(ip6.getNthLSBit(-1), std::invalid_argument);
1102   auto asV6 = ip6.asV6();
1103   EXPECT_THROW(asV6.getNthMSBit(asV6.bitCount()), std::invalid_argument);
1104   EXPECT_THROW(asV6.getNthLSBit(asV6.bitCount()), std::invalid_argument);
1105   EXPECT_THROW(asV6.getNthMSBit(-1), std::invalid_argument);
1106   EXPECT_THROW(asV6.getNthLSBit(-1), std::invalid_argument);
1107 }
1108
1109 TEST(IPAddress, StringFormat) {
1110   in6_addr a6;
1111   for (int i = 0; i < 8; ++i) {
1112     auto t = htons(0x0123 + ((i % 4) * 0x4444));
1113 #ifdef _WIN32
1114     a6.u.Word[i] = t;
1115 #else
1116     a6.s6_addr16[i] = t;
1117 #endif
1118   }
1119   EXPECT_EQ(
1120       "0123:4567:89ab:cdef:0123:4567:89ab:cdef", detail::fastIpv6ToString(a6));
1121
1122   in_addr a4;
1123   a4.s_addr = htonl(0x01020304);
1124   EXPECT_EQ("1.2.3.4", detail::fastIpv4ToString(a4));
1125 }
1126
1127 TEST(IPAddress, getMacAddressFromLinkLocal) {
1128   IPAddressV6 ip6("fe80::f652:14ff:fec5:74d8");
1129   EXPECT_TRUE(ip6.getMacAddressFromLinkLocal().hasValue());
1130   EXPECT_EQ("f4:52:14:c5:74:d8", ip6.getMacAddressFromLinkLocal()->toString());
1131 }
1132
1133 TEST(IPAddress, getMacAddressFromLinkLocal_Negative) {
1134   IPAddressV6 no_link_local_ip6("2803:6082:a2:4447::1");
1135   EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
1136   no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ccc5:74d8");
1137   EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
1138   no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ffc5:74d8");
1139   EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
1140   no_link_local_ip6 = IPAddressV6("fe81::f652:14ff:ffc5:74d8");
1141   EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
1142 }
1143
1144 TEST(IPAddress, getMacAddressFromEUI64) {
1145   IPAddressV6 ip6("2401:db00:3020:51dc:4a57:ddff:fe04:5643");
1146   EXPECT_TRUE(ip6.getMacAddressFromEUI64().hasValue());
1147   EXPECT_EQ("48:57:dd:04:56:43", ip6.getMacAddressFromEUI64()->toString());
1148   ip6 = IPAddressV6("fe80::4a57:ddff:fe04:5643");
1149   EXPECT_TRUE(ip6.getMacAddressFromEUI64().hasValue());
1150   EXPECT_EQ("48:57:dd:04:56:43", ip6.getMacAddressFromEUI64()->toString());
1151 }
1152
1153 TEST(IPAddress, getMacAddressFromEUI64_Negative) {
1154   IPAddressV6 not_eui64_ip6("2401:db00:3020:51dc:face:0000:009a:0000");
1155   EXPECT_FALSE(not_eui64_ip6.getMacAddressFromEUI64().hasValue());
1156 }
1157
1158 TEST(IPAddress, LongestCommonPrefix) {
1159   IPAddress ip10("10.0.0.0");
1160   IPAddress ip11("11.0.0.0");
1161   IPAddress ip12("12.0.0.0");
1162   IPAddress ip128("128.0.0.0");
1163   IPAddress ip10dot10("10.10.0.0");
1164   auto prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip128, 8});
1165   auto prefix4 =
1166       IPAddressV4::longestCommonPrefix({ip10.asV4(), 8}, {ip128.asV4(), 8});
1167   // No bits match b/w 128/8 and 10/8
1168   EXPECT_EQ(IPAddress("0.0.0.0"), prefix.first);
1169   EXPECT_EQ(0, prefix.second);
1170   EXPECT_EQ(IPAddressV4("0.0.0.0"), prefix4.first);
1171   EXPECT_EQ(0, prefix4.second);
1172
1173   prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip10dot10, 16});
1174   prefix4 = IPAddressV4::longestCommonPrefix(
1175       {ip10.asV4(), 8}, {ip10dot10.asV4(), 16});
1176   // Between 10/8 and 10.10/16, 10/8 is the longest common match
1177   EXPECT_EQ(ip10, prefix.first);
1178   EXPECT_EQ(8, prefix.second);
1179   EXPECT_EQ(ip10.asV4(), prefix4.first);
1180   EXPECT_EQ(8, prefix4.second);
1181
1182   prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
1183   prefix4 =
1184       IPAddressV4::longestCommonPrefix({ip11.asV4(), 8}, {ip12.asV4(), 8});
1185   // 12 = 1100, 11 = 1011, longest match - 1000 = 8
1186   EXPECT_EQ(IPAddress("8.0.0.0"), prefix.first);
1187   EXPECT_EQ(5, prefix.second);
1188   EXPECT_EQ(IPAddressV4("8.0.0.0"), prefix4.first);
1189   EXPECT_EQ(5, prefix4.second);
1190
1191   // Between 128/1 and 128/2, longest match 128/1
1192   prefix = IPAddress::longestCommonPrefix({ip128, 1}, {ip128, 2});
1193   prefix4 =
1194       IPAddressV4::longestCommonPrefix({ip128.asV4(), 1}, {ip128.asV4(), 2});
1195   EXPECT_EQ(ip128, prefix.first);
1196   EXPECT_EQ(1, prefix.second);
1197   EXPECT_EQ(ip128.asV4(), prefix4.first);
1198   EXPECT_EQ(1, prefix4.second);
1199
1200   IPAddress ip6("2620:0:1cfe:face:b00c::3");
1201   prefix = IPAddress::longestCommonPrefix(
1202       {ip6, ip6.bitCount()}, {ip6, ip6.bitCount()});
1203   auto prefix6 = IPAddressV6::longestCommonPrefix(
1204       {ip6.asV6(), IPAddressV6::bitCount()},
1205       {ip6.asV6(), IPAddressV6::bitCount()});
1206   // Longest common b/w me and myself is myself
1207   EXPECT_EQ(ip6, prefix.first);
1208   EXPECT_EQ(ip6.bitCount(), prefix.second);
1209   EXPECT_EQ(ip6.asV6(), prefix6.first);
1210   EXPECT_EQ(ip6.asV6().bitCount(), prefix6.second);
1211
1212   IPAddress ip6Zero("::");
1213   prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, {ip6Zero, 0});
1214   prefix6 = IPAddressV6::longestCommonPrefix(
1215       {ip6.asV6(), IPAddressV6::bitCount()}, {ip6Zero.asV6(), 0});
1216   // Longest common b/w :: (ipv6 equivalent of 0/0) is ::
1217   EXPECT_EQ(ip6Zero, prefix.first);
1218   EXPECT_EQ(0, prefix.second);
1219
1220   // Exceptional cases
1221   EXPECT_THROW(
1222       IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
1223       std::invalid_argument);
1224   EXPECT_THROW(
1225       IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1}, {ip10, 8}),
1226       std::invalid_argument);
1227   EXPECT_THROW(
1228       IPAddressV4::longestCommonPrefix(
1229           {ip10.asV4(), IPAddressV4::bitCount() + 1}, {ip10.asV4(), 8}),
1230       std::invalid_argument);
1231   EXPECT_THROW(
1232       IPAddress::longestCommonPrefix(
1233           {ip6, ip6.bitCount() + 1}, {ip6, ip6.bitCount()}),
1234       std::invalid_argument);
1235   EXPECT_THROW(
1236       IPAddressV6::longestCommonPrefix(
1237           {ip6.asV6(), IPAddressV6::bitCount() + 1},
1238           {ip6.asV6(), IPAddressV6::bitCount()}),
1239       std::invalid_argument);
1240 }
1241
1242 static const vector<AddressData> validAddressProvider = {
1243     AddressData("127.0.0.1", {127, 0, 0, 1}, 4),
1244     AddressData("69.63.189.16", {69, 63, 189, 16}, 4),
1245     AddressData("0.0.0.0", {0, 0, 0, 0}, 4),
1246     AddressData("::1", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, 6),
1247     AddressData(
1248         "2620:0:1cfe:face:b00c::3",
1249         {38, 32, 0, 0, 28, 254, 250, 206, 176, 12, 0, 0, 0, 0, 0, 3},
1250         6),
1251 };
1252
1253 static const vector<string> invalidAddressProvider = {
1254     "",
1255     "foo",
1256     "1.1.1.256",
1257     "1",
1258     ":1",
1259     "127.0.0.1,127.0.0.1",
1260     "[1234]",
1261 };
1262
1263 static const vector<ByteVector> invalidBinaryProvider = {
1264     {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31},
1265     // foo
1266     {0x66, 0x6f, 0x6f},
1267     {0x00},
1268     {0x00, 0x00},
1269     {0x00, 0x00, 0x00},
1270     {0x00, 0x00, 0x00, 0x00, 0x00},
1271     {0xff},
1272 };
1273
1274 static const uint8_t IS_LOCAL = AddressFlags::IS_LOCAL;
1275 static const uint8_t IS_NONROUTABLE = AddressFlags::IS_NONROUTABLE;
1276 static const uint8_t IS_PRIVATE = AddressFlags::IS_PRIVATE;
1277 static const uint8_t IS_ZERO = AddressFlags::IS_ZERO;
1278 static const uint8_t IS_LINK_LOCAL =
1279     AddressFlags::IS_LINK_LOCAL | IS_NONROUTABLE;
1280 static const uint8_t IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE;
1281 static const uint8_t IS_MULTICAST = AddressFlags::IS_MULTICAST;
1282 static const uint8_t IS_LINK_LOCAL_BROADCAST =
1283     AddressFlags::IS_LINK_LOCAL_BROADCAST;
1284
1285 static vector<AddressFlags> flagProvider = {
1286     // public v4
1287     AddressFlags("69.63.176.1", 4, 0),
1288     AddressFlags("128.12.65.3", 4, 0),
1289     AddressFlags("192.0.1.0", 4, 0),
1290     AddressFlags("198.51.101.0", 4, 0),
1291     AddressFlags("203.0.114.0", 4, 0),
1292     AddressFlags("128.12.64.115", 4, 0),
1293
1294     // public v6
1295     AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0),
1296
1297     // localhost
1298     AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE),
1299     AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE),
1300
1301     // link-local v4
1302     AddressFlags("169.254.0.1", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
1303
1304     // private v4
1305     AddressFlags("10.0.0.0", 4, IS_PVT_NONROUTE),
1306     AddressFlags("10.11.12.13", 4, IS_PVT_NONROUTE),
1307     AddressFlags("10.255.255.255", 4, IS_PVT_NONROUTE),
1308     AddressFlags("127.128.129.200", 4, IS_LOCAL | IS_PVT_NONROUTE),
1309     AddressFlags("127.255.255.255", 4, IS_LOCAL | IS_PVT_NONROUTE),
1310     AddressFlags("169.254.0.0", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
1311     AddressFlags("192.168.0.0", 4, IS_PVT_NONROUTE),
1312     AddressFlags("192.168.200.255", 4, IS_PVT_NONROUTE),
1313     AddressFlags("192.168.255.255", 4, IS_PVT_NONROUTE),
1314
1315     // private v6
1316     AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE),
1317
1318     // non routable v4
1319     AddressFlags("0.0.0.0", 4, IS_NONROUTABLE | IS_ZERO),
1320     AddressFlags("0.255.255.255", 4, IS_NONROUTABLE),
1321     AddressFlags("192.0.0.0", 4, IS_NONROUTABLE),
1322     AddressFlags("192.0.2.0", 4, IS_NONROUTABLE),
1323     AddressFlags("198.18.0.0", 4, IS_NONROUTABLE),
1324     AddressFlags("198.19.255.255", 4, IS_NONROUTABLE),
1325     AddressFlags("198.51.100.0", 4, IS_NONROUTABLE),
1326     AddressFlags("198.51.100.255", 4, IS_NONROUTABLE),
1327     AddressFlags("203.0.113.0", 4, IS_NONROUTABLE),
1328     AddressFlags("203.0.113.255", 4, IS_NONROUTABLE),
1329     AddressFlags("224.0.0.0", 4, IS_NONROUTABLE | IS_MULTICAST),
1330     AddressFlags("240.0.0.0", 4, IS_NONROUTABLE),
1331     AddressFlags("224.0.0.0", 4, IS_NONROUTABLE),
1332     // v4 link local broadcast
1333     AddressFlags(
1334         "255.255.255.255",
1335         4,
1336         IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1337
1338     // non routable v6
1339     AddressFlags("1999::1", 6, IS_NONROUTABLE),
1340     AddressFlags("0::0", 6, IS_NONROUTABLE | IS_ZERO),
1341     AddressFlags("0::0:0", 6, IS_NONROUTABLE | IS_ZERO),
1342     AddressFlags("0:0:0::0", 6, IS_NONROUTABLE | IS_ZERO),
1343
1344     // link-local v6
1345     AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL),
1346     AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL),
1347
1348     // multicast v4
1349     AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE),
1350     AddressFlags("224.0.0.251", 4, IS_MULTICAST | IS_NONROUTABLE),
1351     AddressFlags("239.12.34.56", 4, IS_MULTICAST | IS_NONROUTABLE),
1352
1353     // multicast v6
1354     AddressFlags("ff00::", 6, IS_MULTICAST | IS_NONROUTABLE),
1355     AddressFlags("ff02:ffff::1", 6, IS_MULTICAST | IS_NONROUTABLE),
1356     AddressFlags("ff02::101", 6, IS_MULTICAST | IS_NONROUTABLE),
1357     AddressFlags("ff0e::101", 6, IS_MULTICAST),
1358     // v6 link local broadcast
1359     AddressFlags("ff02::1", 6, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1360 };
1361
1362 static const vector<pair<string, string>> mapProvider = {
1363     {"::ffff:192.0.2.128", "192.0.2.128"},
1364     {"192.0.2.128", "::ffff:192.0.2.128"},
1365     {"::FFFF:129.144.52.38", "129.144.52.38"},
1366     {"129.144.52.38", "::FFFF:129.144.52.38"},
1367     {"0:0:0:0:0:FFFF:222.1.41.90", "222.1.41.90"},
1368     {"::FFFF:222.1.41.90", "222.1.41.90"},
1369 };
1370
1371 static const vector<MaskData> masksProvider = {
1372     MaskData("255.255.255.255", 1, "128.0.0.0"),
1373     MaskData("255.255.255.255", 2, "192.0.0.0"),
1374     MaskData("192.0.2.42", 16, "192.0.0.0"),
1375     MaskData("255.255.255.255", 24, "255.255.255.0"),
1376     MaskData("255.255.255.255", 32, "255.255.255.255"),
1377     MaskData("10.10.10.10", 0, "0.0.0.0"),
1378     MaskData("::1", 64, "::"),
1379     MaskData("2620:0:1cfe:face:b00c::3", 1, "::"),
1380     MaskData("2620:0:1cfe:face:b00c::3", 3, "2000::"),
1381     MaskData("2620:0:1cfe:face:b00c::3", 6, "2400::"),
1382     MaskData("2620:0:1cfe:face:b00c::3", 7, "2600::"),
1383     MaskData("2620:0:1cfe:face:b00c::3", 11, "2620::"),
1384     MaskData("2620:0:1cfe:face:b00c::3", 36, "2620:0:1000::"),
1385     MaskData("2620:0:1cfe:face:b00c::3", 37, "2620:0:1800::"),
1386     MaskData("2620:0:1cfe:face:b00c::3", 38, "2620:0:1c00::"),
1387     MaskData("2620:0:1cfe:face:b00c::3", 41, "2620:0:1c80::"),
1388     MaskData("2620:0:1cfe:face:b00c::3", 42, "2620:0:1cc0::"),
1389     MaskData("2620:0:1cfe:face:b00c::3", 43, "2620:0:1ce0::"),
1390     MaskData("2620:0:1cfe:face:b00c::3", 44, "2620:0:1cf0::"),
1391     MaskData("2620:0:1cfe:face:b00c::3", 45, "2620:0:1cf8::"),
1392     MaskData("2620:0:1cfe:face:b00c::3", 46, "2620:0:1cfc::"),
1393     MaskData("2620:0:1cfe:face:b00c::3", 47, "2620:0:1cfe::"),
1394     MaskData("2620:0:1cfe:face:b00c::3", 49, "2620:0:1cfe:8000::"),
1395     MaskData("2620:0:1cfe:face:b00c::3", 50, "2620:0:1cfe:c000::"),
1396     MaskData("2620:0:1cfe:face:b00c::3", 51, "2620:0:1cfe:e000::"),
1397     MaskData("2620:0:1cfe:face:b00c::3", 52, "2620:0:1cfe:f000::"),
1398     MaskData("2620:0:1cfe:face:b00c::3", 53, "2620:0:1cfe:f800::"),
1399     MaskData("2620:0:1cfe:face:b00c::3", 55, "2620:0:1cfe:fa00::"),
1400     MaskData("2620:0:1cfe:face:b00c::3", 57, "2620:0:1cfe:fa80::"),
1401     MaskData("2620:0:1cfe:face:b00c::3", 58, "2620:0:1cfe:fac0::"),
1402     MaskData("2620:0:1cfe:face:b00c::3", 61, "2620:0:1cfe:fac8::"),
1403     MaskData("2620:0:1cfe:face:b00c::3", 62, "2620:0:1cfe:facc::"),
1404     MaskData("2620:0:1cfe:face:b00c::3", 63, "2620:0:1cfe:face::"),
1405     MaskData("2620:0:1cfe:face:b00c::3", 65, "2620:0:1cfe:face:8000::"),
1406     MaskData("2620:0:1cfe:face:b00c::3", 67, "2620:0:1cfe:face:a000::"),
1407     MaskData("2620:0:1cfe:face:b00c::3", 68, "2620:0:1cfe:face:b000::"),
1408     MaskData("2620:0:1cfe:face:b00c::3", 77, "2620:0:1cfe:face:b008::"),
1409     MaskData("2620:0:1cfe:face:b00c::3", 78, "2620:0:1cfe:face:b00c::"),
1410     MaskData("2620:0:1cfe:face:b00c::3", 127, "2620:0:1cfe:face:b00c::2"),
1411     MaskData("2620:0:1cfe:face:b00c::3", 128, "2620:0:1cfe:face:b00c::3"),
1412     MaskData("2620:0:1cfe:face:b00c::3", 0, "::"),
1413 };
1414
1415 static const vector<MaskBoundaryData> maskBoundaryProvider = {
1416     MaskBoundaryData("10.1.1.1", 24, "10.1.1.1", true),
1417     MaskBoundaryData("10.1.1.1", 8, "10.1.2.3", true),
1418     MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfe::", true),
1419     // addresses that are NOT in the same subnet once mask is applied
1420     MaskBoundaryData("10.1.1.1", 24, "10.1.2.1", false),
1421     MaskBoundaryData("10.1.1.1", 16, "10.2.3.4", false),
1422     MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false),
1423 };
1424
1425 INSTANTIATE_TEST_CASE_P(
1426     IPAddress,
1427     IPAddressTest,
1428     ::testing::ValuesIn(validAddressProvider));
1429 INSTANTIATE_TEST_CASE_P(
1430     IPAddress,
1431     IPAddressFlagTest,
1432     ::testing::ValuesIn(flagProvider));
1433 INSTANTIATE_TEST_CASE_P(
1434     IPAddress,
1435     IPAddressMappedTest,
1436     ::testing::ValuesIn(mapProvider));
1437 INSTANTIATE_TEST_CASE_P(
1438     IPAddress,
1439     IPAddressCtorTest,
1440     ::testing::ValuesIn(invalidAddressProvider));
1441 INSTANTIATE_TEST_CASE_P(
1442     IPAddress,
1443     IPAddressCtorBinaryTest,
1444     ::testing::ValuesIn(invalidBinaryProvider));
1445 INSTANTIATE_TEST_CASE_P(
1446     IPAddress,
1447     IPAddressMaskTest,
1448     ::testing::ValuesIn(masksProvider));
1449 INSTANTIATE_TEST_CASE_P(
1450     IPAddress,
1451     IPAddressMaskBoundaryTest,
1452     ::testing::ValuesIn(maskBoundaryProvider));
1453 INSTANTIATE_TEST_CASE_P(
1454     IPAddress,
1455     IPAddressByteAccessorTest,
1456     ::testing::ValuesIn(validAddressProvider));
1457 INSTANTIATE_TEST_CASE_P(
1458     IPAddress,
1459     IPAddressBitAccessorTest,
1460     ::testing::ValuesIn(validAddressProvider));
1461
1462 TEST(IPAddressV4, fetchMask) {
1463   struct X : private IPAddressV4 {
1464     using IPAddressV4::fetchMask;
1465   };
1466
1467   EXPECT_THAT(
1468       X::fetchMask(0),
1469       ::testing::ElementsAreArray(ByteArray4{{0x00, 0x00, 0x00, 0x00}}));
1470
1471   EXPECT_THAT(
1472       X::fetchMask(1),
1473       ::testing::ElementsAreArray(ByteArray4{{0x80, 0x00, 0x00, 0x00}}));
1474
1475   EXPECT_THAT(
1476       X::fetchMask(31),
1477       ::testing::ElementsAreArray(ByteArray4{{0xff, 0xff, 0xff, 0xfe}}));
1478
1479   EXPECT_THAT(
1480       X::fetchMask(32),
1481       ::testing::ElementsAreArray(ByteArray4{{0xff, 0xff, 0xff, 0xff}}));
1482 }
1483
1484 TEST(IPAddressV6, fetchMask) {
1485   struct X : private IPAddressV6 {
1486     using IPAddressV6::fetchMask;
1487   };
1488
1489   EXPECT_THAT(
1490       X::fetchMask(0),
1491       ::testing::ElementsAreArray(join8({{
1492           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1493           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1494       }})));
1495
1496   EXPECT_THAT(
1497       X::fetchMask(1),
1498       ::testing::ElementsAreArray(join8({{
1499           ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1500           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1501       }})));
1502
1503   EXPECT_THAT(
1504       X::fetchMask(63),
1505       ::testing::ElementsAreArray(join8({{
1506           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
1507           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1508       }})));
1509
1510   EXPECT_THAT(
1511       X::fetchMask(64),
1512       ::testing::ElementsAreArray(join8({{
1513           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1514           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1515       }})));
1516
1517   EXPECT_THAT(
1518       X::fetchMask(65),
1519       ::testing::ElementsAreArray(join8({{
1520           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1521           ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
1522       }})));
1523
1524   EXPECT_THAT(
1525       X::fetchMask(127),
1526       ::testing::ElementsAreArray(join8({{
1527           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1528           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
1529       }})));
1530
1531   EXPECT_THAT(
1532       X::fetchMask(128),
1533       ::testing::ElementsAreArray(join8({{
1534           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1535           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
1536       }})));
1537 }