2 * Copyright 2014 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 "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(16, sizeof(IPAddressV6));
33 EXPECT_EQ(20, 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, Ordering) {
57 IPAddress a1("0.1.1.1");
58 IPAddress a2("1.1.1.0");
61 IPAddress b1("::ffff:0.1.1.1");
62 IPAddress b2("::ffff:1.1.1.0");
66 TEST(IPAddress, InvalidAddressFamilyExceptions) {
70 EXPECT_THROW(addr.asV4(), InvalidAddressFamilyException);
75 EXPECT_THROW(addr.asV6(), InvalidAddressFamilyException);
81 addr.sin_family = AF_UNSPEC;
83 EXPECT_THROW(IPAddress((sockaddr *)&addr), InvalidAddressFamilyException);
87 TEST(IPAddress, CreateNetwork) {
88 // test valid IPv4 network
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));
96 // test valid IPv4 network without applying mask
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));
104 // test valid IPv6 network
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));
112 // test valid IPv6 network without applying mask
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));
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
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);
136 // test no slash string with default IPv6
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);
143 // test no slash string with invalid default
144 EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 33),
145 IPAddressFormatException);
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";
154 // Test assigning IPAddressV6 addr to IPAddress (was V4)
156 IPAddress addr(kIPv4Addr);
157 IPAddressV6 addrV6 = IPAddress(kIPv6Addr).asV6();
158 EXPECT_TRUE(addr.isV4());
159 EXPECT_EQ(kIPv4Addr, addr.str());
161 EXPECT_TRUE(addr.isV6());
162 EXPECT_EQ(kIPv6Addr, addr.str());
164 // Test assigning IPAddressV4 addr to IPAddress (was V6)
166 IPAddress addr(kIPv6Addr);
167 IPAddressV4 addrV4 = IPAddress(kIPv4Addr).asV4();
168 EXPECT_TRUE(addr.isV6());
169 EXPECT_EQ(kIPv6Addr, addr.str());
171 EXPECT_TRUE(addr.isV4());
172 EXPECT_EQ(kIPv4Addr, addr.str());
174 // Test assigning IPAddress(v6) to IPAddress (was v4)
176 IPAddress addr(kIPv4Addr);
177 IPAddress addrV6 = IPAddress(kIPv6Addr);
178 EXPECT_TRUE(addr.isV4());
179 EXPECT_EQ(kIPv4Addr, addr.str());
181 EXPECT_TRUE(addr.isV6());
182 EXPECT_EQ(kIPv6Addr, addr.str());
184 // Test assigning IPAddress(v4) to IPAddress (was v6)
186 IPAddress addr(kIPv6Addr);
187 IPAddress addrV4 = IPAddress(kIPv4Addr);
188 EXPECT_TRUE(addr.isV6());
189 EXPECT_EQ(kIPv6Addr, addr.str());
191 EXPECT_TRUE(addr.isV4());
192 EXPECT_EQ(kIPv4Addr, addr.str());
196 // Test the default constructors
197 TEST(IPAddress, CtorDefault) {
199 EXPECT_EQ(IPAddressV4("0.0.0.0"), v4);
201 EXPECT_EQ(IPAddressV6("::0"), v6);
204 // Test addresses constructed using a in[6]_addr value
205 TEST_P(IPAddressTest, CtorAddress) {
206 AddressData param = GetParam();
207 IPAddress strAddr(param.address);
210 if (param.version == 4) {
211 in_addr v4addr = detail::Bytes::mkAddress4(¶m.bytes[0]);
212 address = IPAddress(v4addr);
214 in6_addr v6addr = detail::Bytes::mkAddress6(¶m.bytes[0]);
215 address = IPAddress(v6addr);
217 ExpectIsValid(address);
218 EXPECT_EQ(strAddr, address);
221 // Test addresses constructed using a binary address
222 TEST_P(IPAddressTest, CtorBinary) {
223 AddressData param = GetParam();
226 if (param.version == 4) {
227 in_addr v4addr = AddressData::parseAddress4(param.address);
228 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v4addr, 4));
230 in6_addr v6addr = AddressData::parseAddress6(param.address);
231 address = IPAddress::fromBinary(ByteRange((unsigned char*)&v6addr, 16));
234 ExpectIsValid(address);
235 EXPECT_EQ(IPAddress(param.address), address);
238 // Test addresses constructed using a string
239 TEST_P(IPAddressTest, CtorString) {
240 AddressData param = GetParam();
241 IPAddress address(param.address);
243 ExpectIsValid(address);
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);
257 TEST(IPAddress, CtorSockaddr) {
263 sin_addr.s_addr = htonl(2122547223);
264 addr.sin_family = AF_INET;
265 addr.sin_addr = sin_addr;
267 IPAddress ipAddr((sockaddr *)&addr);
268 EXPECT_TRUE(ipAddr.isV4());
269 EXPECT_EQ("126.131.128.23", ipAddr.str());
277 // 2620:0:1cfe:face:b00c::3
278 38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3
280 std::memcpy(sin_addr.s6_addr, sec.data(), 16);
281 addr.sin6_family = AF_INET6;
282 addr.sin6_addr = sin_addr;
284 IPAddress ipAddr((sockaddr *)&addr);
285 EXPECT_TRUE(ipAddr.isV6());
286 EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
288 // test nullptr exception
290 sockaddr *addr = nullptr;
291 EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
293 // test invalid family exception
298 sin_addr.s_addr = htonl(2122547223);
299 addr.sin_family = AF_UNSPEC;
300 addr.sin_addr = sin_addr;
302 EXPECT_THROW(IPAddress((sockaddr *)&addr), IPAddressFormatException);
306 TEST(IPAddress, ToSockaddrStorage) {
309 string strAddr("126.131.128.23");
310 IPAddress addr(strAddr);
311 sockaddr_storage out;
313 ASSERT_TRUE(addr.isV4()); // test invariant
314 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
316 IPAddress sockAddr((sockaddr*)&out);
317 ASSERT_TRUE(sockAddr.isV4());
318 EXPECT_EQ(strAddr, sockAddr.str());
322 string strAddr("2620:0:1cfe:face:b00c::3");
323 IPAddress addr(strAddr);
324 sockaddr_storage out;
326 ASSERT_TRUE(addr.isV6()); // test invariant
327 EXPECT_GT(addr.toSockaddrStorage(&out), 0);
329 IPAddress sockAddr((sockaddr*)&out);
330 ASSERT_TRUE(sockAddr.isV6());
331 EXPECT_EQ(strAddr, sockAddr.str());
333 // test nullptr exception
335 sockaddr_storage *out = nullptr;
336 IPAddress addr("127.0.0.1");
337 EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
339 // test invalid family exception
342 sockaddr_storage out;
343 ASSERT_EQ(AF_UNSPEC, addr.family());
344 EXPECT_THROW(addr.toSockaddrStorage(&out), InvalidAddressFamilyException);
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));
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));
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";
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);
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())
388 TEST(IPAddress, ToFullyQualifiedLocal) {
390 EXPECT_EQ("0000:0000:0000:0000:0000:0000:0000:0001", ip.toFullyQualified())
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;
400 auto mapped = IPAddress(mappedIp);
401 auto expected = IPAddress(otherIp);
403 EXPECT_EQ(expected, mapped);
407 v6addr = mapped.asV4().createIPv6();
408 } else if (expected.isV4()) {
409 v6addr = expected.asV4().createIPv6();
411 EXPECT_TRUE(v6addr.isV6());
412 EXPECT_TRUE(mapped == v6addr);
413 EXPECT_TRUE(expected == v6addr);
416 // Test subnet mask calculations
417 TEST_P(IPAddressMaskTest, Masks) {
418 auto param = GetParam();
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;
427 // Test inSubnet calculations
428 TEST_P(IPAddressMaskTest, InSubnet) {
429 auto param = GetParam();
431 IPAddress ip(param.address);
432 IPAddress subnet(param.subnet);
433 EXPECT_TRUE(ip.inSubnet(subnet, param.mask));
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));
444 TEST(IPAddress, UnitializedEqual) {
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);
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));
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));
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));
479 static vector<pair<string, uint8_t> > invalidMasks = {
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);
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},
497 TEST(IPAddress, V6Types) {
498 auto mkName = [&](const IPAddressV6::Type t) -> string {
500 case IPAddressV6::Type::TEREDO:
502 case IPAddressV6::Type::T6TO4:
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());
516 case IPAddressV6::Type::TEREDO:
517 EXPECT_TRUE(ipv6.isTeredo()) << "isTeredo was false";
518 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
520 case IPAddressV6::Type::T6TO4:
521 EXPECT_TRUE(ipv6.is6To4()) << "is6To4 was false";
522 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
524 case IPAddressV6::Type::NORMAL:
525 EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
526 EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
529 throw std::range_error("Invalid expected type: " +
530 to_string(tc.second));
535 static vector<pair<string, uint32_t> > provideToLong = {
537 {"10.0.0.0", 167772160},
538 {"126.131.128.23", 2122547223},
539 {"192.168.0.0", 3232235520},
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());
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());
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());
561 TEST(IPAddress, fromBinaryV4) {
562 for (auto& tc : provideToLong) {
563 SCOPED_TRACE(tc.first);
568 data.u32 = Endian::big(tc.second);
569 ByteRange bytes(data.u8, 4);
571 auto fromBin = IPAddressV4::fromBinary(bytes);
572 IPAddressV4 fromStr(tc.first);
573 EXPECT_EQ(fromStr, fromBin);
575 IPAddressV4 addr2("0.0.0.0");
576 addr2 = IPAddressV4::fromBinary(bytes);
577 EXPECT_EQ(fromStr, addr2);
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);
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);
594 static vector<pair<string, vector<uint8_t> > > provideBinary16Bytes = {
596 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
597 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
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}},
608 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
609 0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
612 TEST(IPAddress, fromBinaryV6) {
613 for (auto& tc : provideBinary16Bytes) {
614 SCOPED_TRACE(tc.first);
615 ByteRange bytes(&tc.second.front(), tc.second.size());
617 auto fromBin = IPAddressV6::fromBinary(bytes);
618 IPAddressV6 fromStr(tc.first);
619 EXPECT_EQ(fromStr, fromBin);
621 IPAddressV6 addr2("::0");
622 addr2 = IPAddressV6::fromBinary(bytes);
623 EXPECT_EQ(fromStr, addr2);
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);
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);
640 TEST_P(IPAddressFlagTest, IsLoopback) {
641 AddressFlags param = GetParam();
642 IPAddress addr(param.address);
644 EXPECT_EQ(param.version, addr.version());
645 EXPECT_EQ(param.isLoopback(), addr.isLoopback());
648 TEST_P(IPAddressFlagTest, IsPrivate) {
649 AddressFlags param = GetParam();
650 IPAddress addr(param.address);
652 EXPECT_EQ(param.version, addr.version());
653 EXPECT_EQ(param.isPrivate(), addr.isPrivate()) << addr;
656 TEST_P(IPAddressFlagTest, IsNonroutable) {
657 AddressFlags param = GetParam();
658 IPAddress addr(param.address);
660 EXPECT_EQ(param.version, addr.version());
661 EXPECT_EQ(param.isNonroutable(), addr.isNonroutable()) << addr;
664 TEST_P(IPAddressFlagTest, IsZero) {
665 AddressFlags param = GetParam();
666 IPAddress addr(param.address);
668 EXPECT_EQ(param.version, addr.version());
669 EXPECT_EQ(param.isZero(), addr.isZero()) << addr;
672 TEST_P(IPAddressFlagTest, IsLinkLocal) {
673 AddressFlags param = GetParam();
674 if (param.version != 6) {
677 IPAddressV6 addr(param.address);
678 EXPECT_EQ(param.isLinkLocal(), addr.isLinkLocal()) << addr;
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);
685 addr = IPAddressV6(IPAddressV6::LINK_LOCAL, MacAddress("02:00:00:12:34:56"));
686 EXPECT_EQ(IPAddressV6("fe80::ff:fe12:3456"), addr);
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());
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());
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());
707 TEST_P(IPAddressByteAccessorTest, CheckBytes) {
708 auto addrData = GetParam();
709 IPAddress ip(addrData.address);
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));
717 for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); ++i,
719 EXPECT_EQ(*byritr, ip.getNthLSByte(i));
720 EXPECT_EQ(*byritr, ip.isV4() ?
721 ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
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));
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);
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);
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);
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);
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},
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);
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);
821 prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
822 prefix4 = IPAddressV4::longestCommonPrefix({ip11.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);
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},
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);
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);
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);
861 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
862 std::invalid_argument);
863 EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1},
865 std::invalid_argument);
866 EXPECT_THROW(IPAddressV4::longestCommonPrefix(
867 {ip10.asV4(), IPAddressV4::bitCount() + 1},
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);
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),
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),
890 static vector<string> invalidAddressProvider = {
896 "127.0.0.1,127.0.0.1",
900 static vector<ByteVector> invalidBinaryProvider = {
901 {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31},
907 {0x00, 0x00, 0x00, 0x00, 0x00},
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;
922 static vector<AddressFlags> flagProvider = {
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),
932 AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0),
935 AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE),
936 AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE),
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),
950 AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE),
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),
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),
976 AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL),
977 AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL),
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),
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),
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"},
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, "::")
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),
1056 INSTANTIATE_TEST_CASE_P(IPAddress,
1058 ::testing::ValuesIn(validAddressProvider));
1059 INSTANTIATE_TEST_CASE_P(IPAddress,
1061 ::testing::ValuesIn(flagProvider));
1062 INSTANTIATE_TEST_CASE_P(IPAddress,
1063 IPAddressMappedTest,
1064 ::testing::ValuesIn(mapProvider));
1065 INSTANTIATE_TEST_CASE_P(IPAddress,
1067 ::testing::ValuesIn(invalidAddressProvider));
1068 INSTANTIATE_TEST_CASE_P(IPAddress,
1069 IPAddressCtorBinaryTest,
1070 ::testing::ValuesIn(invalidBinaryProvider));
1071 INSTANTIATE_TEST_CASE_P(IPAddress,
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));