2 * Copyright 2015 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/String.h>
24 #include <folly/MacAddress.h>
26 using namespace folly;
30 TEST(IPAddress, CodeExample) {
31 EXPECT_EQ(4, sizeof(IPAddressV4));
32 EXPECT_EQ(20, sizeof(IPAddressV6));
33 EXPECT_EQ(24, sizeof(IPAddress));
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());
56 TEST(IPAddress, Scope) {
57 // Test that link-local scope is saved
58 auto str = "fe80::62eb:69ff:fe9b:ba60%eth0";
60 EXPECT_EQ(str, a2.str());
62 sockaddr_in6 sock = a2.toSockAddr();
63 EXPECT_NE(0, sock.sin6_scope_id);
66 EXPECT_EQ(str, a1.str());
74 TEST(IPAddress, Ordering) {
75 IPAddress a1("0.1.1.1");
76 IPAddress a2("1.1.1.0");
79 IPAddress b1("::ffff:0.1.1.1");
80 IPAddress b2("::ffff:1.1.1.0");
84 TEST(IPAddress, InvalidAddressFamilyExceptions) {
88 EXPECT_THROW(addr.asV4(), InvalidAddressFamilyException);
93 EXPECT_THROW(addr.asV6(), InvalidAddressFamilyException);
99 addr.sin_family = AF_UNSPEC;
101 EXPECT_THROW(IPAddress((sockaddr *)&addr), InvalidAddressFamilyException);
105 TEST(IPAddress, CreateNetwork) {
106 // test valid IPv4 network
108 auto net = IPAddress::createNetwork("192.168.0.1/24");
109 ASSERT_TRUE(net.first.isV4());
110 EXPECT_EQ("192.168.0.0", net.first.str());
111 EXPECT_EQ(24, net.second);
112 EXPECT_EQ("192.168.0.0/24", IPAddress::networkToString(net));
114 // test valid IPv4 network without applying mask
116 auto net = IPAddress::createNetwork("192.168.0.1/24", -1, false);
117 ASSERT_TRUE(net.first.isV4());
118 EXPECT_EQ("192.168.0.1", net.first.str());
119 EXPECT_EQ(24, net.second);
120 EXPECT_EQ("192.168.0.1/24", IPAddress::networkToString(net));
122 // test valid IPv6 network
124 auto net = IPAddress::createNetwork("1999::1/24");
125 ASSERT_TRUE(net.first.isV6());
126 EXPECT_EQ("1999::", net.first.str());
127 EXPECT_EQ(24, net.second);
128 EXPECT_EQ("1999::/24", IPAddress::networkToString(net));
130 // test valid IPv6 network without applying mask
132 auto net = IPAddress::createNetwork("1999::1/24", -1, false);
133 ASSERT_TRUE(net.first.isV6());
134 EXPECT_EQ("1999::1", net.first.str());
135 EXPECT_EQ(24, net.second);
136 EXPECT_EQ("1999::1/24", IPAddress::networkToString(net));
139 EXPECT_THROW(IPAddress::createNetwork(""), IPAddressFormatException);
140 // test multi slash string
141 EXPECT_THROW(IPAddress::createNetwork("192.168.0.1/24/36"),
142 IPAddressFormatException);
143 // test no slash string with default IPv4
145 auto net = IPAddress::createNetwork("192.168.0.1");
146 ASSERT_TRUE(net.first.isV4());
147 EXPECT_EQ("192.168.0.1", net.first.str());
148 EXPECT_EQ(32, net.second); // auto-detected
149 net = IPAddress::createNetwork("192.168.0.1", -1, false);
150 ASSERT_TRUE(net.first.isV4());
151 EXPECT_EQ("192.168.0.1", net.first.str());
152 EXPECT_EQ(32, net.second);
154 // test no slash string with default IPv6
156 auto net = IPAddress::createNetwork("1999::1");
157 ASSERT_TRUE(net.first.isV6());
158 EXPECT_EQ("1999::1", net.first.str());
159 EXPECT_EQ(128, net.second);
161 // test no slash string with invalid default
162 EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 33),
163 IPAddressFormatException);
167 // test assignment operators
168 TEST(IPAddress, Assignment) {
169 static const string kIPv4Addr = "69.63.189.16";
170 static const string kIPv6Addr = "2620:0:1cfe:face:b00c::3";
172 // Test assigning IPAddressV6 addr to IPAddress (was V4)
174 IPAddress addr(kIPv4Addr);
175 IPAddressV6 addrV6 = IPAddress(kIPv6Addr).asV6();
176 EXPECT_TRUE(addr.isV4());
177 EXPECT_EQ(kIPv4Addr, addr.str());
179 EXPECT_TRUE(addr.isV6());
180 EXPECT_EQ(kIPv6Addr, addr.str());
182 // Test assigning IPAddressV4 addr to IPAddress (was V6)
184 IPAddress addr(kIPv6Addr);
185 IPAddressV4 addrV4 = IPAddress(kIPv4Addr).asV4();
186 EXPECT_TRUE(addr.isV6());
187 EXPECT_EQ(kIPv6Addr, addr.str());
189 EXPECT_TRUE(addr.isV4());
190 EXPECT_EQ(kIPv4Addr, addr.str());
192 // Test assigning IPAddress(v6) to IPAddress (was v4)
194 IPAddress addr(kIPv4Addr);
195 IPAddress addrV6 = IPAddress(kIPv6Addr);
196 EXPECT_TRUE(addr.isV4());
197 EXPECT_EQ(kIPv4Addr, addr.str());
199 EXPECT_TRUE(addr.isV6());
200 EXPECT_EQ(kIPv6Addr, addr.str());
202 // Test assigning IPAddress(v4) to IPAddress (was v6)
204 IPAddress addr(kIPv6Addr);
205 IPAddress addrV4 = IPAddress(kIPv4Addr);
206 EXPECT_TRUE(addr.isV6());
207 EXPECT_EQ(kIPv6Addr, addr.str());
209 EXPECT_TRUE(addr.isV4());
210 EXPECT_EQ(kIPv4Addr, addr.str());
214 // Test the default constructors
215 TEST(IPAddress, CtorDefault) {
217 EXPECT_EQ(IPAddressV4("0.0.0.0"), v4);
219 EXPECT_EQ(IPAddressV6("::0"), v6);
222 // Test addresses constructed using a in[6]_addr value
223 TEST_P(IPAddressTest, CtorAddress) {
224 AddressData param = GetParam();
225 IPAddress strAddr(param.address);
228 if (param.version == 4) {
229 in_addr v4addr = detail::Bytes::mkAddress4(¶m.bytes[0]);
230 address = IPAddress(v4addr);
232 in6_addr v6addr = detail::Bytes::mkAddress6(¶m.bytes[0]);
233 address = IPAddress(v6addr);
235 ExpectIsValid(address);
236 EXPECT_EQ(strAddr, address);
239 // Test addresses constructed using a binary address
240 TEST_P(IPAddressTest, CtorBinary) {
241 AddressData param = GetParam();
244 if (param.version == 4) {
245 in_addr v4addr = AddressData::parseAddress4(param.address);
246 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v4addr, 4));
248 in6_addr v6addr = AddressData::parseAddress6(param.address);
249 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v6addr, 16));
252 ExpectIsValid(address);
253 EXPECT_EQ(IPAddress(param.address), address);
256 // Test addresses constructed using a string
257 TEST_P(IPAddressTest, CtorString) {
258 AddressData param = GetParam();
259 IPAddress address(param.address);
261 ExpectIsValid(address);
263 // Test the direct version-specific constructor
264 if (param.version == 4) {
265 IPAddressV4 v4(param.address);
266 ExpectIsValid(IPAddress(v4));
267 EXPECT_THROW(IPAddressV6 v6(param.address), IPAddressFormatException);
268 } else if (param.version == 6) {
269 IPAddressV6 v6(param.address);
270 ExpectIsValid(IPAddress(v6));
271 EXPECT_THROW(IPAddressV4 v4(param.address), IPAddressFormatException);
275 TEST(IPAddress, CtorSockaddr) {
281 sin_addr.s_addr = htonl(2122547223);
282 addr.sin_family = AF_INET;
283 addr.sin_addr = sin_addr;
285 IPAddress ipAddr((sockaddr *)&addr);
286 EXPECT_TRUE(ipAddr.isV4());
287 EXPECT_EQ("126.131.128.23", ipAddr.str());
293 memset(&addr, 0, sizeof(addr));
296 // 2620:0:1cfe:face:b00c::3
297 38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3
299 std::memcpy(sin_addr.s6_addr, sec.data(), 16);
300 addr.sin6_family = AF_INET6;
301 addr.sin6_addr = sin_addr;
303 IPAddress ipAddr((sockaddr *)&addr);
304 EXPECT_TRUE(ipAddr.isV6());
305 EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
307 // test nullptr exception
309 sockaddr *addr = nullptr;
310 EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
312 // test invalid family exception
317 sin_addr.s_addr = htonl(2122547223);
318 addr.sin_family = AF_UNSPEC;
319 addr.sin_addr = sin_addr;
321 EXPECT_THROW(IPAddress((sockaddr *)&addr), IPAddressFormatException);
325 TEST(IPAddress, ToSockaddrStorage) {
328 string strAddr("126.131.128.23");
329 IPAddress addr(strAddr);
330 sockaddr_storage out;
332 ASSERT_TRUE(addr.isV4()); // test invariant
333 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
335 IPAddress sockAddr((sockaddr*)&out);
336 ASSERT_TRUE(sockAddr.isV4());
337 EXPECT_EQ(strAddr, sockAddr.str());
341 string strAddr("2620:0:1cfe:face:b00c::3");
342 IPAddress addr(strAddr);
343 sockaddr_storage out;
345 ASSERT_TRUE(addr.isV6()); // test invariant
346 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
348 IPAddress sockAddr((sockaddr*)&out);
349 ASSERT_TRUE(sockAddr.isV6());
350 EXPECT_EQ(strAddr, sockAddr.str());
352 // test nullptr exception
354 sockaddr_storage *out = nullptr;
355 IPAddress addr("127.0.0.1");
356 EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
358 // test invalid family exception
361 sockaddr_storage out;
362 ASSERT_EQ(AF_UNSPEC, addr.family());
363 EXPECT_THROW(addr.toSockaddrStorage(&out), InvalidAddressFamilyException);
367 TEST(IPAddress, ToString) {
368 // Test with IPAddressV4
369 IPAddressV4 addr_10_0_0_1("10.0.0.1");
370 EXPECT_EQ("10.0.0.1", folly::to<string>(addr_10_0_0_1));
371 // Test with IPAddressV6
372 IPAddressV6 addr_1("::1");
373 EXPECT_EQ("::1", folly::to<string>(addr_1));
374 // Test with IPAddress, both V4 and V6
375 IPAddress addr_10_1_2_3("10.1.2.3");
376 EXPECT_EQ("10.1.2.3", folly::to<string>(addr_10_1_2_3));
377 IPAddress addr_1_2_3("1:2::3");
378 EXPECT_EQ("1:2::3", folly::to<string>(addr_1_2_3));
380 // Test a combination of all the above arguments
381 EXPECT_EQ("1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3",
382 folly::to<string>(addr_1_2_3, " - ", addr_10_0_0_1,
383 " - ", addr_1, " - ", addr_10_1_2_3));
386 // Test that invalid string values are killed
387 TEST_P(IPAddressCtorTest, InvalidCreation) {
388 string addr = GetParam();
389 EXPECT_THROW(IPAddress((const string)addr), IPAddressFormatException)
390 << "IPAddress(" << addr << ") "
391 << "should have thrown an IPAddressFormatException";
394 // Test that invalid binary values throw an exception
395 TEST_P(IPAddressCtorBinaryTest, InvalidBinary) {
396 auto bin = GetParam();
397 EXPECT_THROW(IPAddress::fromBinary(ByteRange(&bin[0], bin.size())),
398 IPAddressFormatException);
401 // Test toFullyQualified()
402 TEST(IPAddress, ToFullyQualifiedFb) {
403 IPAddress ip("2620:0:1cfe:face:b00c::3");
404 EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", ip.toFullyQualified())
407 TEST(IPAddress, ToFullyQualifiedLocal) {
409 EXPECT_EQ("0000:0000:0000:0000:0000:0000:0000:0001", ip.toFullyQualified())
412 TEST(IPAddress, ToFullyQualifiedSize) {
413 auto actual = IPAddressV6::kToFullyQualifiedSize;
414 auto expected = IPAddress("::").toFullyQualified().size();
415 EXPECT_EQ(expected, actual);
418 // test v4-v6 mapped addresses
419 TEST_P(IPAddressMappedTest, MappedEqual) {
420 auto param = GetParam();
421 string mappedIp = param.first;
422 string otherIp = param.second;
424 auto mapped = IPAddress(mappedIp);
425 auto expected = IPAddress(otherIp);
427 EXPECT_EQ(expected, mapped);
431 v6addr = mapped.asV4().createIPv6();
432 } else if (expected.isV4()) {
433 v6addr = expected.asV4().createIPv6();
435 EXPECT_TRUE(v6addr.isV6());
436 EXPECT_TRUE(mapped == v6addr);
437 EXPECT_TRUE(expected == v6addr);
440 // Test subnet mask calculations
441 TEST_P(IPAddressMaskTest, Masks) {
442 auto param = GetParam();
444 IPAddress ip(param.address);
445 IPAddress masked = ip.mask(param.mask);
446 EXPECT_EQ(param.subnet, masked.str())
447 << param.address << "/" << to_string(param.mask)
448 << " -> " << param.subnet;
451 // Test inSubnet calculations
452 TEST_P(IPAddressMaskTest, InSubnet) {
453 auto param = GetParam();
455 IPAddress ip(param.address);
456 IPAddress subnet(param.subnet);
457 EXPECT_TRUE(ip.inSubnet(subnet, param.mask));
460 // Test boundary conditions for subnet calculations
461 TEST_P(IPAddressMaskBoundaryTest, NonMaskedSubnet) {
462 auto param = GetParam();
463 IPAddress ip(param.address);
464 IPAddress subnet(param.subnet);
465 EXPECT_EQ(param.inSubnet, ip.inSubnet(subnet, param.mask));
468 TEST(IPAddress, UnitializedEqual) {
470 IPAddress ip4("127.0.0.1");
471 EXPECT_FALSE(addrEmpty == ip4);
472 EXPECT_FALSE(ip4 == addrEmpty);
473 IPAddress ip6("::1");
474 EXPECT_FALSE(addrEmpty == ip6);
475 EXPECT_FALSE(ip6 == addrEmpty);
476 IPAddress ip6Map("::ffff:192.0.2.129");
477 EXPECT_FALSE(addrEmpty == ip6Map);
478 EXPECT_FALSE(ip6Map == addrEmpty);
479 IPAddress ip4Zero("0.0.0.0");
480 EXPECT_FALSE(addrEmpty == ip4Zero);
481 EXPECT_FALSE(ip4Zero == addrEmpty);
482 IPAddress ip6Zero("::");
483 EXPECT_FALSE(addrEmpty == ip6Zero);
484 EXPECT_FALSE(ip6Zero == addrEmpty);
485 EXPECT_EQ(addrEmpty, addrEmpty);
488 // Test subnet calcs with 6to4 addresses
489 TEST(IPAddress, InSubnetWith6to4) {
490 auto ip = IPAddress("2002:c000:022a::"); // 192.0.2.42
491 auto subnet = IPAddress("192.0.0.0");
492 EXPECT_TRUE(ip.inSubnet(subnet, 16));
494 auto ip2 = IPAddress("192.0.0.1");
495 auto subnet2 = IPAddress("2002:c000:0000::"); // 192.0.0.0
496 EXPECT_TRUE(ip2.inSubnet(subnet2, 14));
498 auto ip3 = IPAddress("2002:c000:022a::"); // 192.0.2.42
499 auto subnet3 = IPAddress("2002:c000:0000::"); // 192.0.0.0
500 EXPECT_TRUE(ip3.inSubnet(subnet3, 16));
503 static vector<pair<string, uint8_t> > invalidMasks = {
507 TEST(IPAddress, InvalidMask) {
508 for (auto& tc : invalidMasks) {
509 uint8_t mask = tc.second;
510 auto ip = IPAddress(tc.first);
511 EXPECT_THROW(ip.mask(tc.second), IPAddressFormatException);
515 static vector<pair<string, IPAddressV6::Type> > v6types = {
516 {"::1", IPAddressV6::Type::NORMAL},
517 {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL},
518 {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO},
519 {"2002:c000:022a::", IPAddressV6::Type::T6TO4},
521 TEST(IPAddress, V6Types) {
522 auto mkName = [&](const IPAddressV6::Type t) -> string {
524 case IPAddressV6::Type::TEREDO:
526 case IPAddressV6::Type::T6TO4:
533 for (auto& tc : v6types) {
534 auto ip = IPAddress(tc.first);
535 EXPECT_TRUE(ip.isV6());
536 IPAddressV6 ipv6 = ip.asV6();
537 EXPECT_EQ(tc.second, ipv6.type())
538 << "expected " << mkName(tc.second) << ", got " << mkName(ipv6.type());
540 case IPAddressV6::Type::TEREDO:
541 EXPECT_TRUE(ipv6.isTeredo()) << "isTeredo was false";
542 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
544 case IPAddressV6::Type::T6TO4:
545 EXPECT_TRUE(ipv6.is6To4()) << "is6To4 was false";
546 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
548 case IPAddressV6::Type::NORMAL:
549 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
550 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
553 throw std::range_error("Invalid expected type: " +
554 to_string(tc.second));
559 static vector<pair<string, uint32_t> > provideToLong = {
561 {"10.0.0.0", 167772160},
562 {"126.131.128.23", 2122547223},
563 {"192.168.0.0", 3232235520},
565 TEST(IPAddress, ToLong) {
566 for (auto& tc : provideToLong) {
567 auto ip = IPAddress(tc.first);
568 EXPECT_TRUE(ip.isV4());
569 IPAddressV4 ipv4 = ip.asV4();
570 EXPECT_EQ(tc.second, ipv4.toLongHBO());
572 auto ip2 = IPAddress::fromLongHBO(tc.second);
573 EXPECT_TRUE(ip2.isV4());
574 EXPECT_TRUE(tc.first.compare(ip2.str()) == 0);
575 EXPECT_EQ(tc.second, ip2.asV4().toLongHBO());
577 auto nla = htonl(tc.second);
578 auto ip3 = IPAddress::fromLong(nla);
579 EXPECT_TRUE(ip3.isV4());
580 EXPECT_TRUE(tc.first.compare(ip3.str()) == 0);
581 EXPECT_EQ(nla, ip3.asV4().toLong());
585 TEST(IPAddress, fromBinaryV4) {
586 for (auto& tc : provideToLong) {
587 SCOPED_TRACE(tc.first);
592 data.u32 = Endian::big(tc.second);
593 ByteRange bytes(data.u8, 4);
595 auto fromBin = IPAddressV4::fromBinary(bytes);
596 IPAddressV4 fromStr(tc.first);
597 EXPECT_EQ(fromStr, fromBin);
599 IPAddressV4 addr2("0.0.0.0");
600 addr2 = IPAddressV4::fromBinary(bytes);
601 EXPECT_EQ(fromStr, addr2);
603 IPAddress genericAddr = IPAddress::fromBinary(bytes);
604 ASSERT_TRUE(genericAddr.isV4());
605 EXPECT_EQ(fromStr, genericAddr.asV4());
606 EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
610 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 3)),
611 IPAddressFormatException);
612 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 16)),
613 IPAddressFormatException);
614 EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 20)),
615 IPAddressFormatException);
618 static vector<pair<string, vector<uint8_t> > > provideBinary16Bytes = {
620 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
621 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
623 {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
624 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
625 {"fe80::0012:34ff:fe56:78ab",
626 {0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
627 0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}},
628 {"2001:db8:1234:5678:90ab:cdef:8765:4321",
629 {0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78,
630 0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}},
632 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
633 0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
636 TEST(IPAddress, fromBinaryV6) {
637 for (auto& tc : provideBinary16Bytes) {
638 SCOPED_TRACE(tc.first);
639 ByteRange bytes(&tc.second.front(), tc.second.size());
641 auto fromBin = IPAddressV6::fromBinary(bytes);
642 IPAddressV6 fromStr(tc.first);
643 EXPECT_EQ(fromStr, fromBin);
645 IPAddressV6 addr2("::0");
646 addr2 = IPAddressV6::fromBinary(bytes);
647 EXPECT_EQ(fromStr, addr2);
649 IPAddress genericAddr = IPAddress::fromBinary(bytes);
650 ASSERT_TRUE(genericAddr.isV6());
651 EXPECT_EQ(fromStr, genericAddr.asV6());
652 EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
656 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 3)),
657 IPAddressFormatException);
658 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 4)),
659 IPAddressFormatException);
660 EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 20)),
661 IPAddressFormatException);
664 TEST_P(IPAddressFlagTest, IsLoopback) {
665 AddressFlags param = GetParam();
666 IPAddress addr(param.address);
668 EXPECT_EQ(param.version, addr.version());
669 EXPECT_EQ(param.isLoopback(), addr.isLoopback());
672 TEST_P(IPAddressFlagTest, IsPrivate) {
673 AddressFlags param = GetParam();
674 IPAddress addr(param.address);
676 EXPECT_EQ(param.version, addr.version());
677 EXPECT_EQ(param.isPrivate(), addr.isPrivate()) << addr;
680 TEST_P(IPAddressFlagTest, IsNonroutable) {
681 AddressFlags param = GetParam();
682 IPAddress addr(param.address);
684 EXPECT_EQ(param.version, addr.version());
685 EXPECT_EQ(param.isNonroutable(), addr.isNonroutable()) << addr;
688 TEST_P(IPAddressFlagTest, IsZero) {
689 AddressFlags param = GetParam();
690 IPAddress addr(param.address);
692 EXPECT_EQ(param.version, addr.version());
693 EXPECT_EQ(param.isZero(), addr.isZero()) << addr;
696 TEST_P(IPAddressFlagTest, IsLinkLocal) {
697 AddressFlags param = GetParam();
698 IPAddress addr(param.address);
699 EXPECT_EQ(param.isLinkLocal(), addr.isLinkLocal()) << addr;
702 TEST(IPAddress, CreateLinkLocal) {
703 IPAddressV6 addr(IPAddressV6::LINK_LOCAL, MacAddress("00:05:73:f9:46:fc"));
704 EXPECT_EQ(IPAddressV6("fe80::0205:73ff:fef9:46fc"), addr);
706 addr = IPAddressV6(IPAddressV6::LINK_LOCAL, MacAddress("02:00:00:12:34:56"));
707 EXPECT_EQ(IPAddressV6("fe80::ff:fe12:3456"), addr);
710 TEST_P(IPAddressFlagTest, IsLinkLocalBroadcast) {
711 AddressFlags param = GetParam();
712 IPAddress addr(param.address);
713 EXPECT_EQ(param.version, addr.version());
714 EXPECT_EQ(param.isLinkLocalBroadcast(), addr.isLinkLocalBroadcast());
717 TEST(IPAddress, SolicitedNodeAddress) {
718 // An example from RFC 4291 section 2.7.1
719 EXPECT_EQ(IPAddressV6("ff02::1:ff0e:8c6c"),
720 IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress());
722 // An example from wikipedia
723 // (http://en.wikipedia.org/wiki/Solicited-node_multicast_address)
724 EXPECT_EQ(IPAddressV6("ff02::1:ff28:9c5a"),
725 IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress());
728 TEST_P(IPAddressByteAccessorTest, CheckBytes) {
729 auto addrData = GetParam();
730 IPAddress ip(addrData.address);
732 for (auto byitr = addrData.bytes.begin(); i < ip.byteCount(); ++i, ++byitr) {
733 EXPECT_EQ(*byitr, ip.getNthMSByte(i));
734 EXPECT_EQ(*byitr, ip.isV4() ?
735 ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i));
738 for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); ++i,
740 EXPECT_EQ(*byritr, ip.getNthLSByte(i));
741 EXPECT_EQ(*byritr, ip.isV4() ?
742 ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
746 TEST_P(IPAddressBitAccessorTest, CheckBits) {
747 auto addrData = GetParam();
748 auto littleEndianAddrData = addrData.bytes;
749 //IPAddress stores address data in n/w byte order.
750 reverse(littleEndianAddrData.begin(), littleEndianAddrData.end());
751 //Bit iterator goes from LSBit to MSBit
752 //We will traverse the IPAddress bits from 0 to bitCount -1
753 auto bitr = folly::makeBitIterator(littleEndianAddrData.begin());
754 IPAddress ip(addrData.address);
755 for (size_t i = 0; i < ip.bitCount(); ++i) {
756 auto msbIndex = ip.bitCount() - i - 1;
757 EXPECT_EQ(*bitr, ip.getNthMSBit(msbIndex));
758 EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthMSBit(msbIndex) :
759 ip.asV6().getNthMSBit(msbIndex));
760 EXPECT_EQ(*bitr, ip.getNthLSBit(i));
761 EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) :
762 ip.asV6().getNthLSBit(i));
767 TEST(IPAddress, InvalidByteAccess) {
768 IPAddress ip4("10.10.10.10");
769 //MSByte, LSByte accessors are 0 indexed
770 EXPECT_THROW(ip4.getNthMSByte(ip4.byteCount()), std::invalid_argument);
771 EXPECT_THROW(ip4.getNthLSByte(ip4.byteCount()), std::invalid_argument);
772 EXPECT_THROW(ip4.getNthMSByte(-1), std::invalid_argument);
773 EXPECT_THROW(ip4.getNthLSByte(-1), std::invalid_argument);
774 auto asV4 = ip4.asV4();
775 EXPECT_THROW(asV4.getNthMSByte(asV4.byteCount()), std::invalid_argument);
776 EXPECT_THROW(asV4.getNthLSByte(asV4.byteCount()), std::invalid_argument);
777 EXPECT_THROW(asV4.getNthMSByte(-1), std::invalid_argument);
778 EXPECT_THROW(asV4.getNthLSByte(-1), std::invalid_argument);
780 IPAddress ip6("2620:0:1cfe:face:b00c::3");
781 EXPECT_THROW(ip6.getNthMSByte(ip6.byteCount()), std::invalid_argument);
782 EXPECT_THROW(ip6.getNthLSByte(ip6.byteCount()), std::invalid_argument);
783 EXPECT_THROW(ip6.getNthMSByte(-1), std::invalid_argument);
784 EXPECT_THROW(ip6.getNthLSByte(-1), std::invalid_argument);
785 auto asV6 = ip6.asV6();
786 EXPECT_THROW(asV6.getNthMSByte(asV6.byteCount()), std::invalid_argument);
787 EXPECT_THROW(asV6.getNthLSByte(asV6.byteCount()), std::invalid_argument);
788 EXPECT_THROW(asV6.getNthMSByte(-1), std::invalid_argument);
789 EXPECT_THROW(asV6.getNthLSByte(-1), std::invalid_argument);
793 TEST(IPAddress, InvalidBBitAccess) {
794 IPAddress ip4("10.10.10.10");
795 //MSByte, LSByte accessors are 0 indexed
796 EXPECT_THROW(ip4.getNthMSBit(ip4.bitCount()), std::invalid_argument);
797 EXPECT_THROW(ip4.getNthLSBit(ip4.bitCount()), std::invalid_argument);
798 EXPECT_THROW(ip4.getNthMSBit(-1), std::invalid_argument);
799 EXPECT_THROW(ip4.getNthLSBit(-1), std::invalid_argument);
800 auto asV4 = ip4.asV4();
801 EXPECT_THROW(asV4.getNthMSBit(asV4.bitCount()), std::invalid_argument);
802 EXPECT_THROW(asV4.getNthLSBit(asV4.bitCount()), std::invalid_argument);
803 EXPECT_THROW(asV4.getNthMSBit(-1), std::invalid_argument);
804 EXPECT_THROW(asV4.getNthLSBit(-1), std::invalid_argument);
806 IPAddress ip6("2620:0:1cfe:face:b00c::3");
807 EXPECT_THROW(ip6.getNthMSBit(ip6.bitCount()), std::invalid_argument);
808 EXPECT_THROW(ip6.getNthLSBit(ip6.bitCount()), std::invalid_argument);
809 EXPECT_THROW(ip6.getNthMSBit(-1), std::invalid_argument);
810 EXPECT_THROW(ip6.getNthLSBit(-1), std::invalid_argument);
811 auto asV6 = ip6.asV6();
812 EXPECT_THROW(asV6.getNthMSBit(asV6.bitCount()), std::invalid_argument);
813 EXPECT_THROW(asV6.getNthLSBit(asV6.bitCount()), std::invalid_argument);
814 EXPECT_THROW(asV6.getNthMSBit(-1), std::invalid_argument);
815 EXPECT_THROW(asV6.getNthLSBit(-1), std::invalid_argument);
818 TEST(IPAddress, StringFormat) {
820 for (int i = 0; i < 8; ++i) {
821 a6.s6_addr16[i] = htons(0x0123 + ((i%4) * 0x4444));
823 EXPECT_EQ("0123:4567:89ab:cdef:0123:4567:89ab:cdef",
824 detail::fastIpv6ToString(a6));
827 a4.s_addr = htonl(0x01020304);
828 EXPECT_EQ("1.2.3.4", detail::fastIpv4ToString(a4));
831 TEST(IPAddress, LongestCommonPrefix) {
832 IPAddress ip10("10.0.0.0");
833 IPAddress ip11("11.0.0.0");
834 IPAddress ip12("12.0.0.0");
835 IPAddress ip128("128.0.0.0");
836 IPAddress ip10dot10("10.10.0.0");
837 auto prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip128, 8});
838 auto prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
840 // No bits match b/w 128/8 and 10/8
841 EXPECT_EQ(IPAddress("0.0.0.0"), prefix.first);
842 EXPECT_EQ(0, prefix.second);
843 EXPECT_EQ(IPAddressV4("0.0.0.0"), prefix4.first);
844 EXPECT_EQ(0, prefix4.second);
846 prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip10dot10, 16});
847 prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
848 {ip10dot10.asV4(), 16});
849 // Between 10/8 and 10.10/16, 10/8 is the longest common match
850 EXPECT_EQ(ip10, prefix.first);
851 EXPECT_EQ(8, prefix.second);
852 EXPECT_EQ(ip10.asV4(), prefix4.first);
853 EXPECT_EQ(8, prefix4.second);
855 prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
856 prefix4 = IPAddressV4::longestCommonPrefix({ip11.asV4(), 8},
858 // 12 = 1100, 11 = 1011, longest match - 1000 = 8
859 EXPECT_EQ(IPAddress("8.0.0.0"), prefix.first);
860 EXPECT_EQ(5, prefix.second);
861 EXPECT_EQ(IPAddressV4("8.0.0.0"), prefix4.first);
862 EXPECT_EQ(5, prefix4.second);
864 // Between 128/1 and 128/2, longest match 128/1
865 prefix = IPAddress::longestCommonPrefix({ip128, 1}, {ip128, 2});
866 prefix4 = IPAddressV4::longestCommonPrefix({ip128.asV4(), 1},
868 EXPECT_EQ(ip128, prefix.first);
869 EXPECT_EQ(1, prefix.second);
870 EXPECT_EQ(ip128.asV4(), prefix4.first);
871 EXPECT_EQ(1, prefix4.second);
873 IPAddress ip6("2620:0:1cfe:face:b00c::3");
874 prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()},
875 {ip6, ip6.bitCount()});
876 auto prefix6 = IPAddressV6::longestCommonPrefix(
877 {ip6.asV6(), IPAddressV6::bitCount()},
878 {ip6.asV6(), IPAddressV6::bitCount()});
879 // Longest common b/w me and myself is myself
880 EXPECT_EQ(ip6, prefix.first);
881 EXPECT_EQ(ip6.bitCount(), prefix.second);
882 EXPECT_EQ(ip6.asV6(), prefix6.first);
883 EXPECT_EQ(ip6.asV6().bitCount(), prefix6.second);
885 IPAddress ip6Zero("::");
886 prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, {ip6Zero, 0});
887 prefix6 = IPAddressV6::longestCommonPrefix(
888 {ip6.asV6(), IPAddressV6::bitCount()},
889 {ip6Zero.asV6(), 0});
890 // Longest common b/w :: (ipv6 equivalent of 0/0) is ::
891 EXPECT_EQ(ip6Zero, prefix.first);
892 EXPECT_EQ(0, prefix.second);
895 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
896 std::invalid_argument);
897 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1},
899 std::invalid_argument);
900 EXPECT_THROW(IPAddressV4::longestCommonPrefix(
901 {ip10.asV4(), IPAddressV4::bitCount() + 1},
903 std::invalid_argument);
904 EXPECT_THROW(IPAddress::longestCommonPrefix({ip6, ip6.bitCount() + 1},
905 {ip6, ip6.bitCount()}),
906 std::invalid_argument);
907 EXPECT_THROW(IPAddressV6::longestCommonPrefix(
908 {ip6.asV6(), IPAddressV6::bitCount() + 1},
909 {ip6.asV6(), IPAddressV6::bitCount()}),
910 std::invalid_argument);
914 static vector<AddressData> validAddressProvider = {
915 AddressData("127.0.0.1", {127,0,0,1}, 4),
916 AddressData("69.63.189.16", {69,63,189,16}, 4),
917 AddressData("0.0.0.0", {0,0,0,0}, 4),
919 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}, 6),
920 AddressData("2620:0:1cfe:face:b00c::3",
921 {38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3}, 6),
924 static vector<string> invalidAddressProvider = {
930 "127.0.0.1,127.0.0.1",
934 static vector<ByteVector> invalidBinaryProvider = {
935 {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31},
941 {0x00, 0x00, 0x00, 0x00, 0x00},
945 static const uint8_t IS_LOCAL = AddressFlags::IS_LOCAL;
946 static const uint8_t IS_NONROUTABLE = AddressFlags::IS_NONROUTABLE;
947 static const uint8_t IS_PRIVATE = AddressFlags::IS_PRIVATE;
948 static const uint8_t IS_ZERO = AddressFlags::IS_ZERO;
949 static const uint8_t IS_LINK_LOCAL =
950 AddressFlags::IS_LINK_LOCAL | IS_NONROUTABLE;
951 static const uint8_t IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE;
952 static const uint8_t IS_MULTICAST = AddressFlags::IS_MULTICAST;
953 static const uint8_t IS_LINK_LOCAL_BROADCAST =
954 AddressFlags::IS_LINK_LOCAL_BROADCAST;
956 static vector<AddressFlags> flagProvider = {
958 AddressFlags("69.63.176.1", 4, 0),
959 AddressFlags("128.12.65.3", 4, 0),
960 AddressFlags("192.0.1.0", 4, 0),
961 AddressFlags("198.51.101.0", 4, 0),
962 AddressFlags("203.0.114.0", 4, 0),
963 AddressFlags("128.12.64.115", 4, 0),
966 AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0),
969 AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE),
970 AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE),
973 AddressFlags("169.254.0.1", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
976 AddressFlags("10.0.0.0", 4, IS_PVT_NONROUTE),
977 AddressFlags("10.11.12.13", 4, IS_PVT_NONROUTE),
978 AddressFlags("10.255.255.255", 4, IS_PVT_NONROUTE),
979 AddressFlags("127.128.129.200", 4, IS_LOCAL | IS_PVT_NONROUTE),
980 AddressFlags("127.255.255.255", 4, IS_LOCAL | IS_PVT_NONROUTE),
981 AddressFlags("169.254.0.0", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE),
982 AddressFlags("192.168.0.0", 4, IS_PVT_NONROUTE),
983 AddressFlags("192.168.200.255", 4, IS_PVT_NONROUTE),
984 AddressFlags("192.168.255.255", 4, IS_PVT_NONROUTE),
987 AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE),
990 AddressFlags("0.0.0.0", 4, IS_NONROUTABLE | IS_ZERO),
991 AddressFlags("0.255.255.255", 4, IS_NONROUTABLE),
992 AddressFlags("192.0.0.0", 4, IS_NONROUTABLE),
993 AddressFlags("192.0.2.0", 4, IS_NONROUTABLE),
994 AddressFlags("198.18.0.0", 4, IS_NONROUTABLE),
995 AddressFlags("198.19.255.255", 4, IS_NONROUTABLE),
996 AddressFlags("198.51.100.0", 4, IS_NONROUTABLE),
997 AddressFlags("198.51.100.255", 4, IS_NONROUTABLE),
998 AddressFlags("203.0.113.0", 4, IS_NONROUTABLE),
999 AddressFlags("203.0.113.255", 4, IS_NONROUTABLE),
1000 AddressFlags("224.0.0.0", 4, IS_NONROUTABLE | IS_MULTICAST),
1001 AddressFlags("240.0.0.0", 4, IS_NONROUTABLE),
1002 AddressFlags("224.0.0.0", 4, IS_NONROUTABLE),
1003 // v4 link local broadcast
1004 AddressFlags("255.255.255.255", 4, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1007 AddressFlags("1999::1", 6, IS_NONROUTABLE),
1008 AddressFlags("0::0", 6, IS_NONROUTABLE | IS_ZERO),
1009 AddressFlags("0::0:0", 6, IS_NONROUTABLE | IS_ZERO),
1010 AddressFlags("0:0:0::0", 6, IS_NONROUTABLE | IS_ZERO),
1013 AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL),
1014 AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL),
1017 AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE) ,
1018 AddressFlags("224.0.0.251", 4, IS_MULTICAST | IS_NONROUTABLE),
1019 AddressFlags("239.12.34.56", 4, IS_MULTICAST | IS_NONROUTABLE),
1022 AddressFlags("ff00::", 6, IS_MULTICAST | IS_NONROUTABLE),
1023 AddressFlags("ff02:ffff::1", 6, IS_MULTICAST | IS_NONROUTABLE),
1024 AddressFlags("ff02::101", 6, IS_MULTICAST | IS_NONROUTABLE),
1025 AddressFlags("ff0e::101", 6, IS_MULTICAST),
1026 // v6 link local broadcast
1027 AddressFlags("ff02::1", 6, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
1030 static vector<pair<string, string> > mapProvider = {
1031 {"::ffff:192.0.2.128", "192.0.2.128"},
1032 {"192.0.2.128", "::ffff:192.0.2.128"},
1033 {"::FFFF:129.144.52.38", "129.144.52.38"},
1034 {"129.144.52.38", "::FFFF:129.144.52.38"},
1035 {"0:0:0:0:0:FFFF:222.1.41.90", "222.1.41.90"},
1036 {"::FFFF:222.1.41.90", "222.1.41.90"},
1039 static vector<MaskData> masksProvider = {
1040 MaskData("255.255.255.255", 1, "128.0.0.0"),
1041 MaskData("255.255.255.255", 2, "192.0.0.0"),
1042 MaskData("192.0.2.42", 16, "192.0.0.0"),
1043 MaskData("255.255.255.255", 24, "255.255.255.0"),
1044 MaskData("255.255.255.255", 32, "255.255.255.255"),
1045 MaskData("10.10.10.10", 0, "0.0.0.0"),
1046 MaskData("::1", 64, "::"),
1047 MaskData("2620:0:1cfe:face:b00c::3", 1, "::"),
1048 MaskData("2620:0:1cfe:face:b00c::3", 3, "2000::"),
1049 MaskData("2620:0:1cfe:face:b00c::3", 6, "2400::"),
1050 MaskData("2620:0:1cfe:face:b00c::3", 7, "2600::"),
1051 MaskData("2620:0:1cfe:face:b00c::3", 11, "2620::"),
1052 MaskData("2620:0:1cfe:face:b00c::3", 36, "2620:0:1000::"),
1053 MaskData("2620:0:1cfe:face:b00c::3", 37, "2620:0:1800::"),
1054 MaskData("2620:0:1cfe:face:b00c::3", 38, "2620:0:1c00::"),
1055 MaskData("2620:0:1cfe:face:b00c::3", 41, "2620:0:1c80::"),
1056 MaskData("2620:0:1cfe:face:b00c::3", 42, "2620:0:1cc0::"),
1057 MaskData("2620:0:1cfe:face:b00c::3", 43, "2620:0:1ce0::"),
1058 MaskData("2620:0:1cfe:face:b00c::3", 44, "2620:0:1cf0::"),
1059 MaskData("2620:0:1cfe:face:b00c::3", 45, "2620:0:1cf8::"),
1060 MaskData("2620:0:1cfe:face:b00c::3", 46, "2620:0:1cfc::"),
1061 MaskData("2620:0:1cfe:face:b00c::3", 47, "2620:0:1cfe::"),
1062 MaskData("2620:0:1cfe:face:b00c::3", 49, "2620:0:1cfe:8000::"),
1063 MaskData("2620:0:1cfe:face:b00c::3", 50, "2620:0:1cfe:c000::"),
1064 MaskData("2620:0:1cfe:face:b00c::3", 51, "2620:0:1cfe:e000::"),
1065 MaskData("2620:0:1cfe:face:b00c::3", 52, "2620:0:1cfe:f000::"),
1066 MaskData("2620:0:1cfe:face:b00c::3", 53, "2620:0:1cfe:f800::"),
1067 MaskData("2620:0:1cfe:face:b00c::3", 55, "2620:0:1cfe:fa00::"),
1068 MaskData("2620:0:1cfe:face:b00c::3", 57, "2620:0:1cfe:fa80::"),
1069 MaskData("2620:0:1cfe:face:b00c::3", 58, "2620:0:1cfe:fac0::"),
1070 MaskData("2620:0:1cfe:face:b00c::3", 61, "2620:0:1cfe:fac8::"),
1071 MaskData("2620:0:1cfe:face:b00c::3", 62, "2620:0:1cfe:facc::"),
1072 MaskData("2620:0:1cfe:face:b00c::3", 63, "2620:0:1cfe:face::"),
1073 MaskData("2620:0:1cfe:face:b00c::3", 65, "2620:0:1cfe:face:8000::"),
1074 MaskData("2620:0:1cfe:face:b00c::3", 67, "2620:0:1cfe:face:a000::"),
1075 MaskData("2620:0:1cfe:face:b00c::3", 68, "2620:0:1cfe:face:b000::"),
1076 MaskData("2620:0:1cfe:face:b00c::3", 77, "2620:0:1cfe:face:b008::"),
1077 MaskData("2620:0:1cfe:face:b00c::3", 78, "2620:0:1cfe:face:b00c::"),
1078 MaskData("2620:0:1cfe:face:b00c::3", 127, "2620:0:1cfe:face:b00c::2"),
1079 MaskData("2620:0:1cfe:face:b00c::3", 128, "2620:0:1cfe:face:b00c::3"),
1080 MaskData("2620:0:1cfe:face:b00c::3", 0, "::")
1083 static vector<MaskBoundaryData> maskBoundaryProvider = {
1084 MaskBoundaryData("10.1.1.1", 24, "10.1.1.1", true),
1085 MaskBoundaryData("10.1.1.1", 8, "10.1.2.3", true),
1086 MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfe::", true),
1087 // addresses that are NOT in the same subnet once mask is applied
1088 MaskBoundaryData("10.1.1.1", 24, "10.1.2.1", false),
1089 MaskBoundaryData("10.1.1.1", 16, "10.2.3.4", false),
1090 MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false),
1093 INSTANTIATE_TEST_CASE_P(IPAddress,
1095 ::testing::ValuesIn(validAddressProvider));
1096 INSTANTIATE_TEST_CASE_P(IPAddress,
1098 ::testing::ValuesIn(flagProvider));
1099 INSTANTIATE_TEST_CASE_P(IPAddress,
1100 IPAddressMappedTest,
1101 ::testing::ValuesIn(mapProvider));
1102 INSTANTIATE_TEST_CASE_P(IPAddress,
1104 ::testing::ValuesIn(invalidAddressProvider));
1105 INSTANTIATE_TEST_CASE_P(IPAddress,
1106 IPAddressCtorBinaryTest,
1107 ::testing::ValuesIn(invalidBinaryProvider));
1108 INSTANTIATE_TEST_CASE_P(IPAddress,
1110 ::testing::ValuesIn(masksProvider));
1111 INSTANTIATE_TEST_CASE_P(IPAddress,
1112 IPAddressMaskBoundaryTest,
1113 ::testing::ValuesIn(maskBoundaryProvider));
1114 INSTANTIATE_TEST_CASE_P(IPAddress,
1115 IPAddressByteAccessorTest,
1116 ::testing::ValuesIn(validAddressProvider));
1117 INSTANTIATE_TEST_CASE_P(IPAddress,
1118 IPAddressBitAccessorTest,
1119 ::testing::ValuesIn(validAddressProvider));