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