2 * Copyright 2016 Facebook, Inc.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include <folly/test/IPAddressTest.h>
19 #include <gtest/gtest.h>
21 #include <folly/Bits.h>
22 #include <folly/Format.h>
23 #include <folly/MacAddress.h>
24 #include <folly/String.h>
25 #include <folly/detail/IPAddressSource.h>
27 using namespace folly;
31 TEST(IPAddress, CodeExample) {
32 EXPECT_EQ(4, sizeof(IPAddressV4));
33 EXPECT_EQ(20, sizeof(IPAddressV6));
34 EXPECT_EQ(24, sizeof(IPAddress));
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());
57 TEST(IPAddress, Scope) {
58 // Test that link-local scope is saved
59 auto str = "fe80::62eb:69ff:fe9b:ba60%eth0";
61 EXPECT_EQ(str, a2.str());
63 sockaddr_in6 sock = a2.toSockAddr();
64 EXPECT_NE(0, sock.sin6_scope_id);
67 EXPECT_EQ(str, a1.str());
75 TEST(IPAddress, Ordering) {
76 IPAddress a1("0.1.1.1");
77 IPAddress a2("1.1.1.0");
80 IPAddress b1("::ffff:0.1.1.1");
81 IPAddress b2("::ffff:1.1.1.0");
85 TEST(IPAddress, InvalidAddressFamilyExceptions) {
89 EXPECT_THROW(addr.asV4(), InvalidAddressFamilyException);
94 EXPECT_THROW(addr.asV6(), InvalidAddressFamilyException);
100 addr.sin_family = AF_UNSPEC;
102 EXPECT_THROW(IPAddress((sockaddr *)&addr), InvalidAddressFamilyException);
106 TEST(IPAddress, CreateNetwork) {
107 // test valid IPv4 network
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));
115 // test valid IPv4 network without applying mask
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));
123 // test valid IPv6 network
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));
131 // test valid IPv6 network without applying mask
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));
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
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);
155 // test no slash string with default IPv6
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);
162 // test no slash string with invalid default
163 EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 33),
164 IPAddressFormatException);
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";
173 // Test assigning IPAddressV6 addr to IPAddress (was V4)
175 IPAddress addr(kIPv4Addr);
176 IPAddressV6 addrV6 = IPAddress(kIPv6Addr).asV6();
177 EXPECT_TRUE(addr.isV4());
178 EXPECT_EQ(kIPv4Addr, addr.str());
180 EXPECT_TRUE(addr.isV6());
181 EXPECT_EQ(kIPv6Addr, addr.str());
183 // Test assigning IPAddressV4 addr to IPAddress (was V6)
185 IPAddress addr(kIPv6Addr);
186 IPAddressV4 addrV4 = IPAddress(kIPv4Addr).asV4();
187 EXPECT_TRUE(addr.isV6());
188 EXPECT_EQ(kIPv6Addr, addr.str());
190 EXPECT_TRUE(addr.isV4());
191 EXPECT_EQ(kIPv4Addr, addr.str());
193 // Test assigning IPAddress(v6) to IPAddress (was v4)
195 IPAddress addr(kIPv4Addr);
196 IPAddress addrV6 = IPAddress(kIPv6Addr);
197 EXPECT_TRUE(addr.isV4());
198 EXPECT_EQ(kIPv4Addr, addr.str());
200 EXPECT_TRUE(addr.isV6());
201 EXPECT_EQ(kIPv6Addr, addr.str());
203 // Test assigning IPAddress(v4) to IPAddress (was v6)
205 IPAddress addr(kIPv6Addr);
206 IPAddress addrV4 = IPAddress(kIPv4Addr);
207 EXPECT_TRUE(addr.isV6());
208 EXPECT_EQ(kIPv6Addr, addr.str());
210 EXPECT_TRUE(addr.isV4());
211 EXPECT_EQ(kIPv4Addr, addr.str());
215 // Test the default constructors
216 TEST(IPAddress, CtorDefault) {
218 EXPECT_EQ(IPAddressV4("0.0.0.0"), v4);
220 EXPECT_EQ(IPAddressV6("::0"), v6);
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"));
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"));
236 IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:127.127.127.127"));
239 TEST(IPAddress, validate) {
240 EXPECT_TRUE(IPAddress::validate("0.0.0.0"));
241 EXPECT_TRUE(IPAddress::validate("::"));
242 EXPECT_FALSE(IPAddress::validate("asdf"));
245 // Test addresses constructed using a in[6]_addr value
246 TEST_P(IPAddressTest, CtorAddress) {
247 AddressData param = GetParam();
248 IPAddress strAddr(param.address);
251 if (param.version == 4) {
252 in_addr v4addr = detail::Bytes::mkAddress4(¶m.bytes[0]);
253 address = IPAddress(v4addr);
255 in6_addr v6addr = detail::Bytes::mkAddress6(¶m.bytes[0]);
256 address = IPAddress(v6addr);
258 ExpectIsValid(address);
259 EXPECT_EQ(strAddr, address);
262 // Test addresses constructed using a binary address
263 TEST_P(IPAddressTest, CtorBinary) {
264 AddressData param = GetParam();
267 if (param.version == 4) {
268 in_addr v4addr = AddressData::parseAddress4(param.address);
269 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v4addr, 4));
271 in6_addr v6addr = AddressData::parseAddress6(param.address);
272 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v6addr, 16));
275 ExpectIsValid(address);
276 EXPECT_EQ(IPAddress(param.address), address);
279 // Test addresses constructed using a string
280 TEST_P(IPAddressTest, CtorString) {
281 AddressData param = GetParam();
282 IPAddress address(param.address);
284 ExpectIsValid(address);
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);
298 TEST(IPAddress, CtorSockaddr) {
304 sin_addr.s_addr = htonl(2122547223);
305 addr.sin_family = AF_INET;
306 addr.sin_addr = sin_addr;
308 IPAddress ipAddr((sockaddr *)&addr);
309 EXPECT_TRUE(ipAddr.isV4());
310 EXPECT_EQ("126.131.128.23", ipAddr.str());
316 memset(&addr, 0, sizeof(addr));
319 // 2620:0:1cfe:face:b00c::3
320 38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3
322 std::memcpy(sin_addr.s6_addr, sec.data(), 16);
323 addr.sin6_family = AF_INET6;
324 addr.sin6_addr = sin_addr;
326 IPAddress ipAddr((sockaddr *)&addr);
327 EXPECT_TRUE(ipAddr.isV6());
328 EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
330 // test nullptr exception
332 sockaddr *addr = nullptr;
333 EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
335 // test invalid family exception
340 sin_addr.s_addr = htonl(2122547223);
341 addr.sin_family = AF_UNSPEC;
342 addr.sin_addr = sin_addr;
344 EXPECT_THROW(IPAddress((sockaddr *)&addr), IPAddressFormatException);
348 TEST(IPAddress, ToSockaddrStorage) {
351 string strAddr("126.131.128.23");
352 IPAddress addr(strAddr);
353 sockaddr_storage out;
355 ASSERT_TRUE(addr.isV4()); // test invariant
356 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
358 IPAddress sockAddr((sockaddr*)&out);
359 ASSERT_TRUE(sockAddr.isV4());
360 EXPECT_EQ(strAddr, sockAddr.str());
364 string strAddr("2620:0:1cfe:face:b00c::3");
365 IPAddress addr(strAddr);
366 sockaddr_storage out;
368 ASSERT_TRUE(addr.isV6()); // test invariant
369 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
371 IPAddress sockAddr((sockaddr*)&out);
372 ASSERT_TRUE(sockAddr.isV6());
373 EXPECT_EQ(strAddr, sockAddr.str());
375 // test nullptr exception
377 sockaddr_storage *out = nullptr;
378 IPAddress addr("127.0.0.1");
379 EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
381 // test invalid family exception
384 sockaddr_storage out;
385 ASSERT_EQ(AF_UNSPEC, addr.family());
386 EXPECT_THROW(addr.toSockaddrStorage(&out), InvalidAddressFamilyException);
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));
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));
409 // Test that invalid string values are killed
410 TEST_P(IPAddressCtorTest, InvalidCreation) {
411 string addr = GetParam();
412 EXPECT_THROW(IPAddress((const string)addr), IPAddressFormatException)
413 << "IPAddress(" << addr << ") "
414 << "should have thrown an IPAddressFormatException";
417 // Test that invalid binary values throw an exception
418 TEST_P(IPAddressCtorBinaryTest, InvalidBinary) {
419 auto bin = GetParam();
420 EXPECT_THROW(IPAddress::fromBinary(ByteRange(&bin[0], bin.size())),
421 IPAddressFormatException);
424 // Test toFullyQualified()
425 TEST(IPAddress, ToFullyQualifiedFb) {
426 IPAddress ip("2620:0:1cfe:face:b00c::3");
427 EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", ip.toFullyQualified())
430 TEST(IPAddress, ToFullyQualifiedLocal) {
432 EXPECT_EQ("0000:0000:0000:0000:0000:0000:0000:0001", ip.toFullyQualified())
435 TEST(IPAddress, ToFullyQualifiedSize) {
436 auto actual = IPAddressV6::kToFullyQualifiedSize;
437 auto expected = IPAddress("::").toFullyQualified().size();
438 EXPECT_EQ(expected, actual);
441 // test v4-v6 mapped addresses
442 TEST_P(IPAddressMappedTest, MappedEqual) {
443 auto param = GetParam();
444 string mappedIp = param.first;
445 string otherIp = param.second;
447 auto mapped = IPAddress(mappedIp);
448 auto expected = IPAddress(otherIp);
450 EXPECT_EQ(expected, mapped);
454 v6addr = mapped.asV4().createIPv6();
455 } else if (expected.isV4()) {
456 v6addr = expected.asV4().createIPv6();
458 EXPECT_TRUE(v6addr.isV6());
459 EXPECT_TRUE(mapped == v6addr);
460 EXPECT_TRUE(expected == v6addr);
463 // Test subnet mask calculations
464 TEST_P(IPAddressMaskTest, Masks) {
465 auto param = GetParam();
467 IPAddress ip(param.address);
468 IPAddress masked = ip.mask(param.mask);
469 EXPECT_EQ(param.subnet, masked.str())
470 << param.address << "/" << folly::to<std::string>(param.mask) << " -> "
474 // Test inSubnet calculations
475 TEST_P(IPAddressMaskTest, InSubnet) {
476 auto param = GetParam();
478 IPAddress ip(param.address);
479 IPAddress subnet(param.subnet);
480 EXPECT_TRUE(ip.inSubnet(subnet, param.mask));
483 // Test boundary conditions for subnet calculations
484 TEST_P(IPAddressMaskBoundaryTest, NonMaskedSubnet) {
485 auto param = GetParam();
486 IPAddress ip(param.address);
487 IPAddress subnet(param.subnet);
488 EXPECT_EQ(param.inSubnet, ip.inSubnet(subnet, param.mask));
491 TEST(IPAddress, UnitializedEqual) {
493 IPAddress ip4("127.0.0.1");
494 EXPECT_FALSE(addrEmpty == ip4);
495 EXPECT_FALSE(ip4 == addrEmpty);
496 IPAddress ip6("::1");
497 EXPECT_FALSE(addrEmpty == ip6);
498 EXPECT_FALSE(ip6 == addrEmpty);
499 IPAddress ip6Map("::ffff:192.0.2.129");
500 EXPECT_FALSE(addrEmpty == ip6Map);
501 EXPECT_FALSE(ip6Map == addrEmpty);
502 IPAddress ip4Zero("0.0.0.0");
503 EXPECT_FALSE(addrEmpty == ip4Zero);
504 EXPECT_FALSE(ip4Zero == addrEmpty);
505 IPAddress ip6Zero("::");
506 EXPECT_FALSE(addrEmpty == ip6Zero);
507 EXPECT_FALSE(ip6Zero == addrEmpty);
508 EXPECT_EQ(addrEmpty, addrEmpty);
511 // Test subnet calcs with 6to4 addresses
512 TEST(IPAddress, InSubnetWith6to4) {
513 auto ip = IPAddress("2002:c000:022a::"); // 192.0.2.42
514 auto subnet = IPAddress("192.0.0.0");
515 EXPECT_TRUE(ip.inSubnet(subnet, 16));
517 auto ip2 = IPAddress("192.0.0.1");
518 auto subnet2 = IPAddress("2002:c000:0000::"); // 192.0.0.0
519 EXPECT_TRUE(ip2.inSubnet(subnet2, 14));
521 auto ip3 = IPAddress("2002:c000:022a::"); // 192.0.2.42
522 auto subnet3 = IPAddress("2002:c000:0000::"); // 192.0.0.0
523 EXPECT_TRUE(ip3.inSubnet(subnet3, 16));
526 static const vector<string> ipv4Strs = {
531 TEST(IPAddress, getIPv6For6To4) {
532 for (auto ipv4Str : ipv4Strs) {
533 auto ip = IPAddress(ipv4Str);
534 EXPECT_TRUE(ip.isV4());
535 IPAddressV4 ipv4 = ip.asV4();
536 auto ipv6 = ipv4.getIPv6For6To4();
537 EXPECT_EQ(ipv6.type(), IPAddressV6::Type::T6TO4);
538 auto ipv4New = ipv6.getIPv4For6To4();
539 EXPECT_TRUE(ipv4Str.compare(ipv4New.str()) == 0);
543 static const vector<pair<string, uint8_t> > invalidMasks = {
547 TEST(IPAddress, InvalidMask) {
548 for (auto& tc : invalidMasks) {
549 auto ip = IPAddress(tc.first);
550 EXPECT_THROW(ip.mask(tc.second), IPAddressFormatException);
554 static const vector<pair<string, IPAddressV6::Type> > v6types = {
555 {"::1", IPAddressV6::Type::NORMAL},
556 {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL},
557 {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO},
558 {"2002:c000:022a::", IPAddressV6::Type::T6TO4},
560 TEST(IPAddress, V6Types) {
561 auto mkName = [&](const IPAddressV6::Type t) -> string {
563 case IPAddressV6::Type::TEREDO:
565 case IPAddressV6::Type::T6TO4:
572 for (auto& tc : v6types) {
573 auto ip = IPAddress(tc.first);
574 EXPECT_TRUE(ip.isV6());
575 IPAddressV6 ipv6 = ip.asV6();
576 EXPECT_EQ(tc.second, ipv6.type())
577 << "expected " << mkName(tc.second) << ", got " << mkName(ipv6.type());
579 case IPAddressV6::Type::TEREDO:
580 EXPECT_TRUE(ipv6.isTeredo()) << "isTeredo was false";
581 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
583 case IPAddressV6::Type::T6TO4:
584 EXPECT_TRUE(ipv6.is6To4()) << "is6To4 was false";
585 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
587 case IPAddressV6::Type::NORMAL:
588 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
589 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
592 throw std::range_error("Invalid expected type: " +
593 folly::to<std::string>(tc.second));
598 static const vector<pair<string, uint32_t> > provideToLong = {
600 {"10.0.0.0", 167772160},
601 {"126.131.128.23", 2122547223},
602 {"192.168.0.0", 3232235520},
604 TEST(IPAddress, ToLong) {
605 for (auto& tc : provideToLong) {
606 auto ip = IPAddress(tc.first);
607 EXPECT_TRUE(ip.isV4());
608 IPAddressV4 ipv4 = ip.asV4();
609 EXPECT_EQ(tc.second, ipv4.toLongHBO());
611 auto ip2 = IPAddress::fromLongHBO(tc.second);
612 EXPECT_TRUE(ip2.isV4());
613 EXPECT_TRUE(tc.first.compare(ip2.str()) == 0);
614 EXPECT_EQ(tc.second, ip2.asV4().toLongHBO());
616 auto nla = htonl(tc.second);
617 auto ip3 = IPAddress::fromLong(nla);
618 EXPECT_TRUE(ip3.isV4());
619 EXPECT_TRUE(tc.first.compare(ip3.str()) == 0);
620 EXPECT_EQ(nla, ip3.asV4().toLong());
624 TEST(IPAddress, fromBinaryV4) {
625 for (auto& tc : provideToLong) {
626 SCOPED_TRACE(tc.first);
631 data.u32 = Endian::big(tc.second);
632 ByteRange bytes(data.u8, 4);
634 auto fromBin = IPAddressV4::fromBinary(bytes);
635 IPAddressV4 fromStr(tc.first);
636 EXPECT_EQ(fromStr, fromBin);
638 IPAddressV4 addr2("0.0.0.0");
639 addr2 = IPAddressV4::fromBinary(bytes);
640 EXPECT_EQ(fromStr, addr2);
642 IPAddress genericAddr = IPAddress::fromBinary(bytes);
643 ASSERT_TRUE(genericAddr.isV4());
644 EXPECT_EQ(fromStr, genericAddr.asV4());
645 EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
649 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 3)),
650 IPAddressFormatException);
651 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 16)),
652 IPAddressFormatException);
653 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 20)),
654 IPAddressFormatException);
657 TEST(IPAddress, toBinaryV4) {
658 for (auto& tc : provideToLong) {
659 SCOPED_TRACE(tc.first);
664 data.u32 = Endian::big(tc.second);
665 ByteRange bytes(data.u8, 4);
667 auto fromBin = IPAddressV4::fromBinary(bytes);
668 auto toBin = fromBin.toBinary();
669 EXPECT_EQ(bytes, toBin);
673 static const vector<pair<string, vector<uint8_t> > > provideBinary16Bytes = {
675 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
676 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
678 {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
679 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
680 {"fe80::0012:34ff:fe56:78ab",
681 {0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
682 0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}},
683 {"2001:db8:1234:5678:90ab:cdef:8765:4321",
684 {0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78,
685 0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}},
687 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
688 0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
691 TEST(IPAddress, fromBinaryV6) {
692 for (auto& tc : provideBinary16Bytes) {
693 SCOPED_TRACE(tc.first);
694 ByteRange bytes(&tc.second.front(), tc.second.size());
696 auto fromBin = IPAddressV6::fromBinary(bytes);
697 IPAddressV6 fromStr(tc.first);
698 EXPECT_EQ(fromStr, fromBin);
700 IPAddressV6 addr2("::0");
701 addr2 = IPAddressV6::fromBinary(bytes);
702 EXPECT_EQ(fromStr, addr2);
704 IPAddress genericAddr = IPAddress::fromBinary(bytes);
705 ASSERT_TRUE(genericAddr.isV6());
706 EXPECT_EQ(fromStr, genericAddr.asV6());
707 EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
711 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 3)),
712 IPAddressFormatException);
713 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 4)),
714 IPAddressFormatException);
715 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 20)),
716 IPAddressFormatException);
719 TEST(IPAddress, toBinaryV6) {
720 for (auto& tc : provideBinary16Bytes) {
721 SCOPED_TRACE(tc.first);
722 ByteRange bytes(&tc.second.front(), tc.second.size());
724 auto fromBin = IPAddressV6::fromBinary(bytes);
725 auto toBin = fromBin.toBinary();
726 EXPECT_EQ(bytes, toBin);
730 TEST_P(IPAddressFlagTest, IsLoopback) {
731 AddressFlags param = GetParam();
732 IPAddress addr(param.address);
734 EXPECT_EQ(param.version, addr.version());
735 EXPECT_EQ(param.isLoopback(), addr.isLoopback());
738 TEST_P(IPAddressFlagTest, IsPrivate) {
739 AddressFlags param = GetParam();
740 IPAddress addr(param.address);
742 EXPECT_EQ(param.version, addr.version());
743 EXPECT_EQ(param.isPrivate(), addr.isPrivate()) << addr;
746 TEST_P(IPAddressFlagTest, IsNonroutable) {
747 AddressFlags param = GetParam();
748 IPAddress addr(param.address);
750 EXPECT_EQ(param.version, addr.version());
751 EXPECT_EQ(param.isNonroutable(), addr.isNonroutable()) << addr;
754 TEST_P(IPAddressFlagTest, IsZero) {
755 AddressFlags param = GetParam();
756 IPAddress addr(param.address);
758 EXPECT_EQ(param.version, addr.version());
759 EXPECT_EQ(param.isZero(), addr.isZero()) << addr;
762 TEST_P(IPAddressFlagTest, IsLinkLocal) {
763 AddressFlags param = GetParam();
764 IPAddress addr(param.address);
765 EXPECT_EQ(param.isLinkLocal(), addr.isLinkLocal()) << addr;
768 TEST(IPAddress, CreateLinkLocal) {
769 IPAddressV6 addr(IPAddressV6::LINK_LOCAL, MacAddress("00:05:73:f9:46:fc"));
770 EXPECT_EQ(IPAddressV6("fe80::0205:73ff:fef9:46fc"), addr);
772 addr = IPAddressV6(IPAddressV6::LINK_LOCAL, MacAddress("02:00:00:12:34:56"));
773 EXPECT_EQ(IPAddressV6("fe80::ff:fe12:3456"), addr);
776 TEST_P(IPAddressFlagTest, IsLinkLocalBroadcast) {
777 AddressFlags param = GetParam();
778 IPAddress addr(param.address);
779 EXPECT_EQ(param.version, addr.version());
780 EXPECT_EQ(param.isLinkLocalBroadcast(), addr.isLinkLocalBroadcast());
783 TEST(IPAddress, SolicitedNodeAddress) {
784 // An example from RFC 4291 section 2.7.1
785 EXPECT_EQ(IPAddressV6("ff02::1:ff0e:8c6c"),
786 IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress());
788 // An example from wikipedia
789 // (http://en.wikipedia.org/wiki/Solicited-node_multicast_address)
790 EXPECT_EQ(IPAddressV6("ff02::1:ff28:9c5a"),
791 IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress());
794 TEST_P(IPAddressByteAccessorTest, CheckBytes) {
795 auto addrData = GetParam();
796 IPAddress ip(addrData.address);
798 for (auto byitr = addrData.bytes.begin(); i < ip.byteCount(); ++i, ++byitr) {
799 EXPECT_EQ(*byitr, ip.getNthMSByte(i));
800 EXPECT_EQ(*byitr, ip.isV4() ?
801 ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i));
804 for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); ++i,
806 EXPECT_EQ(*byritr, ip.getNthLSByte(i));
807 EXPECT_EQ(*byritr, ip.isV4() ?
808 ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
812 TEST_P(IPAddressBitAccessorTest, CheckBits) {
813 auto addrData = GetParam();
814 auto littleEndianAddrData = addrData.bytes;
815 //IPAddress stores address data in n/w byte order.
816 reverse(littleEndianAddrData.begin(), littleEndianAddrData.end());
817 //Bit iterator goes from LSBit to MSBit
818 //We will traverse the IPAddress bits from 0 to bitCount -1
819 auto bitr = folly::makeBitIterator(littleEndianAddrData.begin());
820 IPAddress ip(addrData.address);
821 for (size_t i = 0; i < ip.bitCount(); ++i) {
822 auto msbIndex = ip.bitCount() - i - 1;
823 EXPECT_EQ(*bitr, ip.getNthMSBit(msbIndex));
824 EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthMSBit(msbIndex) :
825 ip.asV6().getNthMSBit(msbIndex));
826 EXPECT_EQ(*bitr, ip.getNthLSBit(i));
827 EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) :
828 ip.asV6().getNthLSBit(i));
833 TEST(IPAddress, InvalidByteAccess) {
834 IPAddress ip4("10.10.10.10");
835 //MSByte, LSByte accessors are 0 indexed
836 EXPECT_THROW(ip4.getNthMSByte(ip4.byteCount()), std::invalid_argument);
837 EXPECT_THROW(ip4.getNthLSByte(ip4.byteCount()), std::invalid_argument);
838 EXPECT_THROW(ip4.getNthMSByte(-1), std::invalid_argument);
839 EXPECT_THROW(ip4.getNthLSByte(-1), std::invalid_argument);
840 auto asV4 = ip4.asV4();
841 EXPECT_THROW(asV4.getNthMSByte(asV4.byteCount()), std::invalid_argument);
842 EXPECT_THROW(asV4.getNthLSByte(asV4.byteCount()), std::invalid_argument);
843 EXPECT_THROW(asV4.getNthMSByte(-1), std::invalid_argument);
844 EXPECT_THROW(asV4.getNthLSByte(-1), std::invalid_argument);
846 IPAddress ip6("2620:0:1cfe:face:b00c::3");
847 EXPECT_THROW(ip6.getNthMSByte(ip6.byteCount()), std::invalid_argument);
848 EXPECT_THROW(ip6.getNthLSByte(ip6.byteCount()), std::invalid_argument);
849 EXPECT_THROW(ip6.getNthMSByte(-1), std::invalid_argument);
850 EXPECT_THROW(ip6.getNthLSByte(-1), std::invalid_argument);
851 auto asV6 = ip6.asV6();
852 EXPECT_THROW(asV6.getNthMSByte(asV6.byteCount()), std::invalid_argument);
853 EXPECT_THROW(asV6.getNthLSByte(asV6.byteCount()), std::invalid_argument);
854 EXPECT_THROW(asV6.getNthMSByte(-1), std::invalid_argument);
855 EXPECT_THROW(asV6.getNthLSByte(-1), std::invalid_argument);
859 TEST(IPAddress, InvalidBBitAccess) {
860 IPAddress ip4("10.10.10.10");
861 //MSByte, LSByte accessors are 0 indexed
862 EXPECT_THROW(ip4.getNthMSBit(ip4.bitCount()), std::invalid_argument);
863 EXPECT_THROW(ip4.getNthLSBit(ip4.bitCount()), std::invalid_argument);
864 EXPECT_THROW(ip4.getNthMSBit(-1), std::invalid_argument);
865 EXPECT_THROW(ip4.getNthLSBit(-1), std::invalid_argument);
866 auto asV4 = ip4.asV4();
867 EXPECT_THROW(asV4.getNthMSBit(asV4.bitCount()), std::invalid_argument);
868 EXPECT_THROW(asV4.getNthLSBit(asV4.bitCount()), std::invalid_argument);
869 EXPECT_THROW(asV4.getNthMSBit(-1), std::invalid_argument);
870 EXPECT_THROW(asV4.getNthLSBit(-1), std::invalid_argument);
872 IPAddress ip6("2620:0:1cfe:face:b00c::3");
873 EXPECT_THROW(ip6.getNthMSBit(ip6.bitCount()), std::invalid_argument);
874 EXPECT_THROW(ip6.getNthLSBit(ip6.bitCount()), std::invalid_argument);
875 EXPECT_THROW(ip6.getNthMSBit(-1), std::invalid_argument);
876 EXPECT_THROW(ip6.getNthLSBit(-1), std::invalid_argument);
877 auto asV6 = ip6.asV6();
878 EXPECT_THROW(asV6.getNthMSBit(asV6.bitCount()), std::invalid_argument);
879 EXPECT_THROW(asV6.getNthLSBit(asV6.bitCount()), std::invalid_argument);
880 EXPECT_THROW(asV6.getNthMSBit(-1), std::invalid_argument);
881 EXPECT_THROW(asV6.getNthLSBit(-1), std::invalid_argument);
884 TEST(IPAddress, StringFormat) {
886 for (int i = 0; i < 8; ++i) {
887 a6.s6_addr16[i] = htons(0x0123 + ((i%4) * 0x4444));
889 EXPECT_EQ("0123:4567:89ab:cdef:0123:4567:89ab:cdef",
890 detail::fastIpv6ToString(a6));
893 a4.s_addr = htonl(0x01020304);
894 EXPECT_EQ("1.2.3.4", detail::fastIpv4ToString(a4));
897 TEST(IPAddress, LongestCommonPrefix) {
898 IPAddress ip10("10.0.0.0");
899 IPAddress ip11("11.0.0.0");
900 IPAddress ip12("12.0.0.0");
901 IPAddress ip128("128.0.0.0");
902 IPAddress ip10dot10("10.10.0.0");
903 auto prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip128, 8});
904 auto prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
906 // No bits match b/w 128/8 and 10/8
907 EXPECT_EQ(IPAddress("0.0.0.0"), prefix.first);
908 EXPECT_EQ(0, prefix.second);
909 EXPECT_EQ(IPAddressV4("0.0.0.0"), prefix4.first);
910 EXPECT_EQ(0, prefix4.second);
912 prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip10dot10, 16});
913 prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
914 {ip10dot10.asV4(), 16});
915 // Between 10/8 and 10.10/16, 10/8 is the longest common match
916 EXPECT_EQ(ip10, prefix.first);
917 EXPECT_EQ(8, prefix.second);
918 EXPECT_EQ(ip10.asV4(), prefix4.first);
919 EXPECT_EQ(8, prefix4.second);
921 prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
922 prefix4 = IPAddressV4::longestCommonPrefix({ip11.asV4(), 8},
924 // 12 = 1100, 11 = 1011, longest match - 1000 = 8
925 EXPECT_EQ(IPAddress("8.0.0.0"), prefix.first);
926 EXPECT_EQ(5, prefix.second);
927 EXPECT_EQ(IPAddressV4("8.0.0.0"), prefix4.first);
928 EXPECT_EQ(5, prefix4.second);
930 // Between 128/1 and 128/2, longest match 128/1
931 prefix = IPAddress::longestCommonPrefix({ip128, 1}, {ip128, 2});
932 prefix4 = IPAddressV4::longestCommonPrefix({ip128.asV4(), 1},
934 EXPECT_EQ(ip128, prefix.first);
935 EXPECT_EQ(1, prefix.second);
936 EXPECT_EQ(ip128.asV4(), prefix4.first);
937 EXPECT_EQ(1, prefix4.second);
939 IPAddress ip6("2620:0:1cfe:face:b00c::3");
940 prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()},
941 {ip6, ip6.bitCount()});
942 auto prefix6 = IPAddressV6::longestCommonPrefix(
943 {ip6.asV6(), IPAddressV6::bitCount()},
944 {ip6.asV6(), IPAddressV6::bitCount()});
945 // Longest common b/w me and myself is myself
946 EXPECT_EQ(ip6, prefix.first);
947 EXPECT_EQ(ip6.bitCount(), prefix.second);
948 EXPECT_EQ(ip6.asV6(), prefix6.first);
949 EXPECT_EQ(ip6.asV6().bitCount(), prefix6.second);
951 IPAddress ip6Zero("::");
952 prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, {ip6Zero, 0});
953 prefix6 = IPAddressV6::longestCommonPrefix(
954 {ip6.asV6(), IPAddressV6::bitCount()},
955 {ip6Zero.asV6(), 0});
956 // Longest common b/w :: (ipv6 equivalent of 0/0) is ::
957 EXPECT_EQ(ip6Zero, prefix.first);
958 EXPECT_EQ(0, prefix.second);
961 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
962 std::invalid_argument);
963 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1},
965 std::invalid_argument);
966 EXPECT_THROW(IPAddressV4::longestCommonPrefix(
967 {ip10.asV4(), IPAddressV4::bitCount() + 1},
969 std::invalid_argument);
970 EXPECT_THROW(IPAddress::longestCommonPrefix({ip6, ip6.bitCount() + 1},
971 {ip6, ip6.bitCount()}),
972 std::invalid_argument);
973 EXPECT_THROW(IPAddressV6::longestCommonPrefix(
974 {ip6.asV6(), IPAddressV6::bitCount() + 1},
975 {ip6.asV6(), IPAddressV6::bitCount()}),
976 std::invalid_argument);
980 static const vector<AddressData> validAddressProvider = {
981 AddressData("127.0.0.1", {127,0,0,1}, 4),
982 AddressData("69.63.189.16", {69,63,189,16}, 4),
983 AddressData("0.0.0.0", {0,0,0,0}, 4),
985 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}, 6),
986 AddressData("2620:0:1cfe:face:b00c::3",
987 {38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3}, 6),
990 static const vector<string> invalidAddressProvider = {
996 "127.0.0.1,127.0.0.1",
1000 static const vector<ByteVector> invalidBinaryProvider = {
1001 {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31},
1007 {0x00, 0x00, 0x00, 0x00, 0x00},
1011 static const uint8_t IS_LOCAL = AddressFlags::IS_LOCAL;
1012 static const uint8_t IS_NONROUTABLE = AddressFlags::IS_NONROUTABLE;
1013 static const uint8_t IS_PRIVATE = AddressFlags::IS_PRIVATE;
1014 static const uint8_t IS_ZERO = AddressFlags::IS_ZERO;
1015 static const uint8_t IS_LINK_LOCAL =
1016 AddressFlags::IS_LINK_LOCAL | IS_NONROUTABLE;
1017 static const uint8_t IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE;
1018 static const uint8_t IS_MULTICAST = AddressFlags::IS_MULTICAST;
1019 static const uint8_t IS_LINK_LOCAL_BROADCAST =
1020 AddressFlags::IS_LINK_LOCAL_BROADCAST;
1022 static vector<AddressFlags> flagProvider = {
1024 AddressFlags("69.63.176.1", 4, 0),
1025 AddressFlags("128.12.65.3", 4, 0),
1026 AddressFlags("192.0.1.0", 4, 0),
1027 AddressFlags("198.51.101.0", 4, 0),
1028 AddressFlags("203.0.114.0", 4, 0),
1029 AddressFlags("128.12.64.115", 4, 0),
1032 AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0),
1035 AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE),
1036 AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE),
1039 AddressFlags("169.254.0.1", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
1042 AddressFlags("10.0.0.0", 4, IS_PVT_NONROUTE),
1043 AddressFlags("10.11.12.13", 4, IS_PVT_NONROUTE),
1044 AddressFlags("10.255.255.255", 4, IS_PVT_NONROUTE),
1045 AddressFlags("127.128.129.200", 4, IS_LOCAL | IS_PVT_NONROUTE),
1046 AddressFlags("127.255.255.255", 4, IS_LOCAL | IS_PVT_NONROUTE),
1047 AddressFlags("169.254.0.0", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
1048 AddressFlags("192.168.0.0", 4, IS_PVT_NONROUTE),
1049 AddressFlags("192.168.200.255", 4, IS_PVT_NONROUTE),
1050 AddressFlags("192.168.255.255", 4, IS_PVT_NONROUTE),
1053 AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE),
1056 AddressFlags("0.0.0.0", 4, IS_NONROUTABLE | IS_ZERO),
1057 AddressFlags("0.255.255.255", 4, IS_NONROUTABLE),
1058 AddressFlags("192.0.0.0", 4, IS_NONROUTABLE),
1059 AddressFlags("192.0.2.0", 4, IS_NONROUTABLE),
1060 AddressFlags("198.18.0.0", 4, IS_NONROUTABLE),
1061 AddressFlags("198.19.255.255", 4, IS_NONROUTABLE),
1062 AddressFlags("198.51.100.0", 4, IS_NONROUTABLE),
1063 AddressFlags("198.51.100.255", 4, IS_NONROUTABLE),
1064 AddressFlags("203.0.113.0", 4, IS_NONROUTABLE),
1065 AddressFlags("203.0.113.255", 4, IS_NONROUTABLE),
1066 AddressFlags("224.0.0.0", 4, IS_NONROUTABLE | IS_MULTICAST),
1067 AddressFlags("240.0.0.0", 4, IS_NONROUTABLE),
1068 AddressFlags("224.0.0.0", 4, IS_NONROUTABLE),
1069 // v4 link local broadcast
1070 AddressFlags("255.255.255.255", 4, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1073 AddressFlags("1999::1", 6, IS_NONROUTABLE),
1074 AddressFlags("0::0", 6, IS_NONROUTABLE | IS_ZERO),
1075 AddressFlags("0::0:0", 6, IS_NONROUTABLE | IS_ZERO),
1076 AddressFlags("0:0:0::0", 6, IS_NONROUTABLE | IS_ZERO),
1079 AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL),
1080 AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL),
1083 AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE) ,
1084 AddressFlags("224.0.0.251", 4, IS_MULTICAST | IS_NONROUTABLE),
1085 AddressFlags("239.12.34.56", 4, IS_MULTICAST | IS_NONROUTABLE),
1088 AddressFlags("ff00::", 6, IS_MULTICAST | IS_NONROUTABLE),
1089 AddressFlags("ff02:ffff::1", 6, IS_MULTICAST | IS_NONROUTABLE),
1090 AddressFlags("ff02::101", 6, IS_MULTICAST | IS_NONROUTABLE),
1091 AddressFlags("ff0e::101", 6, IS_MULTICAST),
1092 // v6 link local broadcast
1093 AddressFlags("ff02::1", 6, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1096 static const vector<pair<string, string> > mapProvider = {
1097 {"::ffff:192.0.2.128", "192.0.2.128"},
1098 {"192.0.2.128", "::ffff:192.0.2.128"},
1099 {"::FFFF:129.144.52.38", "129.144.52.38"},
1100 {"129.144.52.38", "::FFFF:129.144.52.38"},
1101 {"0:0:0:0:0:FFFF:222.1.41.90", "222.1.41.90"},
1102 {"::FFFF:222.1.41.90", "222.1.41.90"},
1105 static const vector<MaskData> masksProvider = {
1106 MaskData("255.255.255.255", 1, "128.0.0.0"),
1107 MaskData("255.255.255.255", 2, "192.0.0.0"),
1108 MaskData("192.0.2.42", 16, "192.0.0.0"),
1109 MaskData("255.255.255.255", 24, "255.255.255.0"),
1110 MaskData("255.255.255.255", 32, "255.255.255.255"),
1111 MaskData("10.10.10.10", 0, "0.0.0.0"),
1112 MaskData("::1", 64, "::"),
1113 MaskData("2620:0:1cfe:face:b00c::3", 1, "::"),
1114 MaskData("2620:0:1cfe:face:b00c::3", 3, "2000::"),
1115 MaskData("2620:0:1cfe:face:b00c::3", 6, "2400::"),
1116 MaskData("2620:0:1cfe:face:b00c::3", 7, "2600::"),
1117 MaskData("2620:0:1cfe:face:b00c::3", 11, "2620::"),
1118 MaskData("2620:0:1cfe:face:b00c::3", 36, "2620:0:1000::"),
1119 MaskData("2620:0:1cfe:face:b00c::3", 37, "2620:0:1800::"),
1120 MaskData("2620:0:1cfe:face:b00c::3", 38, "2620:0:1c00::"),
1121 MaskData("2620:0:1cfe:face:b00c::3", 41, "2620:0:1c80::"),
1122 MaskData("2620:0:1cfe:face:b00c::3", 42, "2620:0:1cc0::"),
1123 MaskData("2620:0:1cfe:face:b00c::3", 43, "2620:0:1ce0::"),
1124 MaskData("2620:0:1cfe:face:b00c::3", 44, "2620:0:1cf0::"),
1125 MaskData("2620:0:1cfe:face:b00c::3", 45, "2620:0:1cf8::"),
1126 MaskData("2620:0:1cfe:face:b00c::3", 46, "2620:0:1cfc::"),
1127 MaskData("2620:0:1cfe:face:b00c::3", 47, "2620:0:1cfe::"),
1128 MaskData("2620:0:1cfe:face:b00c::3", 49, "2620:0:1cfe:8000::"),
1129 MaskData("2620:0:1cfe:face:b00c::3", 50, "2620:0:1cfe:c000::"),
1130 MaskData("2620:0:1cfe:face:b00c::3", 51, "2620:0:1cfe:e000::"),
1131 MaskData("2620:0:1cfe:face:b00c::3", 52, "2620:0:1cfe:f000::"),
1132 MaskData("2620:0:1cfe:face:b00c::3", 53, "2620:0:1cfe:f800::"),
1133 MaskData("2620:0:1cfe:face:b00c::3", 55, "2620:0:1cfe:fa00::"),
1134 MaskData("2620:0:1cfe:face:b00c::3", 57, "2620:0:1cfe:fa80::"),
1135 MaskData("2620:0:1cfe:face:b00c::3", 58, "2620:0:1cfe:fac0::"),
1136 MaskData("2620:0:1cfe:face:b00c::3", 61, "2620:0:1cfe:fac8::"),
1137 MaskData("2620:0:1cfe:face:b00c::3", 62, "2620:0:1cfe:facc::"),
1138 MaskData("2620:0:1cfe:face:b00c::3", 63, "2620:0:1cfe:face::"),
1139 MaskData("2620:0:1cfe:face:b00c::3", 65, "2620:0:1cfe:face:8000::"),
1140 MaskData("2620:0:1cfe:face:b00c::3", 67, "2620:0:1cfe:face:a000::"),
1141 MaskData("2620:0:1cfe:face:b00c::3", 68, "2620:0:1cfe:face:b000::"),
1142 MaskData("2620:0:1cfe:face:b00c::3", 77, "2620:0:1cfe:face:b008::"),
1143 MaskData("2620:0:1cfe:face:b00c::3", 78, "2620:0:1cfe:face:b00c::"),
1144 MaskData("2620:0:1cfe:face:b00c::3", 127, "2620:0:1cfe:face:b00c::2"),
1145 MaskData("2620:0:1cfe:face:b00c::3", 128, "2620:0:1cfe:face:b00c::3"),
1146 MaskData("2620:0:1cfe:face:b00c::3", 0, "::")
1149 static const vector<MaskBoundaryData> maskBoundaryProvider = {
1150 MaskBoundaryData("10.1.1.1", 24, "10.1.1.1", true),
1151 MaskBoundaryData("10.1.1.1", 8, "10.1.2.3", true),
1152 MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfe::", true),
1153 // addresses that are NOT in the same subnet once mask is applied
1154 MaskBoundaryData("10.1.1.1", 24, "10.1.2.1", false),
1155 MaskBoundaryData("10.1.1.1", 16, "10.2.3.4", false),
1156 MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false),
1159 INSTANTIATE_TEST_CASE_P(IPAddress,
1161 ::testing::ValuesIn(validAddressProvider));
1162 INSTANTIATE_TEST_CASE_P(IPAddress,
1164 ::testing::ValuesIn(flagProvider));
1165 INSTANTIATE_TEST_CASE_P(IPAddress,
1166 IPAddressMappedTest,
1167 ::testing::ValuesIn(mapProvider));
1168 INSTANTIATE_TEST_CASE_P(IPAddress,
1170 ::testing::ValuesIn(invalidAddressProvider));
1171 INSTANTIATE_TEST_CASE_P(IPAddress,
1172 IPAddressCtorBinaryTest,
1173 ::testing::ValuesIn(invalidBinaryProvider));
1174 INSTANTIATE_TEST_CASE_P(IPAddress,
1176 ::testing::ValuesIn(masksProvider));
1177 INSTANTIATE_TEST_CASE_P(IPAddress,
1178 IPAddressMaskBoundaryTest,
1179 ::testing::ValuesIn(maskBoundaryProvider));
1180 INSTANTIATE_TEST_CASE_P(IPAddress,
1181 IPAddressByteAccessorTest,
1182 ::testing::ValuesIn(validAddressProvider));
1183 INSTANTIATE_TEST_CASE_P(IPAddress,
1184 IPAddressBitAccessorTest,
1185 ::testing::ValuesIn(validAddressProvider));