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