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