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