folly/test/IPAddressTest.cpp

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