IPAddressTest.cpp File Reference

#include <sys/types.h>
#include <string>
#include <folly/Format.h>
#include <folly/IPAddress.h>
#include <folly/MacAddress.h>
#include <folly/String.h>
#include <folly/container/BitIterator.h>
#include <folly/detail/IPAddressSource.h>
#include <folly/lang/Bits.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	AddressData
struct	AddressFlags
struct	MaskData
struct	MaskBoundaryData
struct	SerializeData
struct	IPAddressTest
struct	IPAddressFlagTest
struct	IPAddressCtorTest
struct	IPAddressCtorBinaryTest
struct	IPAddressMappedTest
struct	IPAddressMaskTest
struct	IPAddressMaskBoundaryTest
struct	IPAddressSerializeTest
struct	IPAddressByteAccessorTest
struct	IPAddressBitAccessorTest
struct	StringTestParam
struct	TryFromStringTest

Typedefs
typedef std::vector< uint8_t >	ByteVector
using	ByteArray8 = std::array< uint8_t, 8 >

Functions
	TEST (IPAddress, CodeExample)
	TEST (IPAddress, Scope)
	TEST (IPAddress, ScopeNumeric)
	TEST (IPAddress, Ordering)
	TEST (IPAddress, InvalidAddressFamilyExceptions)
	TEST (IPAddress, TryCreateNetwork)
	TEST (IPAddress, CreateNetworkExceptions)
	TEST (IPAddress, Assignment)
	TEST (IPAddress, CtorDefault)
	TEST (IPAddressV4, validate)
	TEST (IPAddressV6, validate)
	TEST (IPAddress, validate)
	TEST_P (IPAddressTest, CtorAddress)
	TEST_P (IPAddressTest, CtorBinary)
	TEST_P (IPAddressTest, CtorString)
	TEST (IPAddress, CtorSockaddr)
	TEST (IPAddress, ToSockaddrStorage)
	TEST_P (TryFromStringTest, IPAddress)
	TEST_P (TryFromStringTest, IPAddressV4)
	TEST_P (TryFromStringTest, IPAddressV6)
	TEST (IPAddress, ToString)
	TEST (IPaddress, toInverseArpaName)
	TEST (IPaddress, fromInverseArpaName)
	TEST_P (IPAddressCtorTest, InvalidCreation)
	TEST_P (IPAddressCtorBinaryTest, InvalidBinary)
	TEST (IPAddressSource, ToHex)
	TEST (IPAddress, ToFullyQualifiedFb)
	TEST (IPAddress, ToFullyQualifiedLocal)
	TEST (IPAddress, ToFullyQualifiedAppendV6)
	TEST (IPAddress, ToFullyQualifiedAppendV4)
	TEST (IPAddress, ToFullyQualifiedSizeV6)
	TEST (IPAddress, MaxToFullyQualifiedSizeV4)
	TEST_P (IPAddressMappedTest, MappedEqual)
	TEST_P (IPAddressMaskTest, Masks)
	TEST_P (IPAddressMaskTest, InSubnet)
	TEST_P (IPAddressMaskBoundaryTest, NonMaskedSubnet)
	TEST (IPAddress, UnitializedEqual)
	TEST (IPAddress, InSubnetWith6to4)
	TEST (IPAddress, getIPv6For6To4)
	TEST (IPAddress, InvalidMask)
	TEST (IPAddress, V6Types)
	TEST (IPAddress, ToLong)
	TEST (IPAddress, fromBinaryV4)
	TEST (IPAddress, toBinaryV4)
	TEST (IPAddress, fromBinaryV6)
	TEST (IPAddress, toBinaryV6)
	TEST_P (IPAddressFlagTest, IsLoopback)
	TEST_P (IPAddressFlagTest, IsPrivate)
	TEST_P (IPAddressFlagTest, IsNonroutable)
	TEST_P (IPAddressFlagTest, IsZero)
	TEST_P (IPAddressFlagTest, IsLinkLocal)
	TEST (IPAddress, CreateLinkLocal)
	TEST_P (IPAddressFlagTest, IsLinkLocalBroadcast)
	TEST (IPAddress, SolicitedNodeAddress)
	TEST_P (IPAddressByteAccessorTest, CheckBytes)
	TEST_P (IPAddressBitAccessorTest, CheckBits)
	TEST (IPAddress, InvalidByteAccess)
	TEST (IPAddress, InvalidBBitAccess)
	TEST (IPAddress, StringFormat)
	TEST (IPAddress, getMacAddressFromLinkLocal)
	TEST (IPAddress, getMacAddressFromLinkLocal_Negative)
	TEST (IPAddress, getMacAddressFromEUI64)
	TEST (IPAddress, getMacAddressFromEUI64_Negative)
	TEST (IPAddress, LongestCommonPrefix)
	INSTANTIATE_TEST_CASE_P (IPAddress, IPAddressTest,::testing::ValuesIn(validAddressProvider))
	INSTANTIATE_TEST_CASE_P (IPAddress, IPAddressFlagTest,::testing::ValuesIn(flagProvider))
	INSTANTIATE_TEST_CASE_P (IPAddress, IPAddressMappedTest,::testing::ValuesIn(mapProvider))
	INSTANTIATE_TEST_CASE_P (IPAddress, IPAddressCtorTest,::testing::ValuesIn(invalidAddressProvider))
	INSTANTIATE_TEST_CASE_P (IPAddress, IPAddressCtorBinaryTest,::testing::ValuesIn(invalidBinaryProvider))
	INSTANTIATE_TEST_CASE_P (IPAddress, IPAddressMaskTest,::testing::ValuesIn(masksProvider))
	INSTANTIATE_TEST_CASE_P (IPAddress, IPAddressMaskBoundaryTest,::testing::ValuesIn(maskBoundaryProvider))
	INSTANTIATE_TEST_CASE_P (IPAddress, IPAddressByteAccessorTest,::testing::ValuesIn(validAddressProvider))
	INSTANTIATE_TEST_CASE_P (IPAddress, IPAddressBitAccessorTest,::testing::ValuesIn(validAddressProvider))
	INSTANTIATE_TEST_CASE_P (IPAddress, TryFromStringTest,::testing::ValuesIn(TryFromStringTest::ipInOutProvider()))
	TEST (IPAddressV4, fetchMask)
	TEST (IPAddressV6, fetchMask)

Variables
static const vector< string >	ipv4Strs
static const vector< pair< string, uint8_t > >	invalidMasks
static const vector< pair< string, IPAddressV6::Type > >	v6types
static const vector< pair< string, uint32_t > >	provideToLong
static auto	join8
static const vector< pair< string, ByteArray16 > >	provideBinary16Bytes
static const vector< AddressData >	validAddressProvider
static const vector< string >	invalidAddressProvider
static const vector< ByteVector >	invalidBinaryProvider
static const uint8_t	IS_LOCAL = AddressFlags::IS_LOCAL
static const uint8_t	IS_NONROUTABLE = AddressFlags::IS_NONROUTABLE
static const uint8_t	IS_PRIVATE = AddressFlags::IS_PRIVATE
static const uint8_t	IS_ZERO = AddressFlags::IS_ZERO
static const uint8_t	IS_LINK_LOCAL
static const uint8_t	IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE
static const uint8_t	IS_MULTICAST = AddressFlags::IS_MULTICAST
static const uint8_t	IS_LINK_LOCAL_BROADCAST
static vector< AddressFlags >	flagProvider
static const vector< pair< string, string > >	mapProvider
static const vector< MaskData >	masksProvider
static const vector< MaskBoundaryData >	maskBoundaryProvider

Typedef Documentation

using ByteArray8 = std::array<uint8_t, 8>

Definition at line 975 of file IPAddressTest.cpp.

typedef std::vector<uint8_t> ByteVector

Definition at line 34 of file IPAddressTest.cpp.

Function Documentation

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		IPAddressTest	,
		::testing::ValuesIn(validAddressProvider)
	)

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		IPAddressFlagTest	,
		::testing::ValuesIn(flagProvider)
	)

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		IPAddressMappedTest	,
		::testing::ValuesIn(mapProvider)
	)

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		IPAddressCtorTest	,
		::testing::ValuesIn(invalidAddressProvider)
	)

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		IPAddressCtorBinaryTest	,
		::testing::ValuesIn(invalidBinaryProvider)
	)

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		IPAddressMaskTest	,
		::testing::ValuesIn(masksProvider)
	)

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		IPAddressMaskBoundaryTest	,
		::testing::ValuesIn(maskBoundaryProvider)
	)

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		IPAddressByteAccessorTest	,
		::testing::ValuesIn(validAddressProvider)
	)

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		IPAddressBitAccessorTest	,
		::testing::ValuesIn(validAddressProvider)
	)

INSTANTIATE_TEST_CASE_P	(	IPAddress	,
		TryFromStringTest	,
		::testing::ValuesIn(TryFromStringTest::ipInOutProvider())
	)

TEST	(	IPAddress	,
		CodeExample
	)

Definition at line 189 of file IPAddressTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, EXPECT_EQ, EXPECT_FALSE, and EXPECT_TRUE.

                             {
  EXPECT_EQ(4, sizeof(IPAddressV4));
  EXPECT_EQ(20, sizeof(IPAddressV6));
  EXPECT_EQ(24, sizeof(IPAddress));
  IPAddress uninitaddr;
  IPAddress v4addr("192.0.2.129");
  IPAddress v6map("::ffff:192.0.2.129");
  ASSERT_TRUE(uninitaddr.empty());
  ASSERT_FALSE(v4addr.empty());
  ASSERT_FALSE(v6map.empty());
  EXPECT_TRUE(v4addr.inSubnet("192.0.2.0/24"));
  EXPECT_TRUE(v4addr.inSubnet(IPAddress("192.0.2.0"), 24));
  EXPECT_TRUE(v4addr.inSubnet("192.0.2.128/30"));
  EXPECT_FALSE(v4addr.inSubnet("192.0.2.128/32"));
  EXPECT_EQ(2164392128, v4addr.asV4().toLong());
  EXPECT_EQ(3221226113, v4addr.asV4().toLongHBO());
  ASSERT_FALSE(uninitaddr.isV4());
  ASSERT_FALSE(uninitaddr.isV6());
  ASSERT_TRUE(v4addr.isV4());
  ASSERT_TRUE(v6map.isV6());
  EXPECT_TRUE(v4addr == v6map);
  ASSERT_TRUE(v6map.isIPv4Mapped());
  EXPECT_TRUE(v4addr.asV4() == IPAddress::createIPv4(v6map));
  EXPECT_TRUE(IPAddress::createIPv6(v4addr) == v6map.asV6());
}

TEST	(	IPAddress	,
		Scope
	)

Definition at line 215 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, folly::IPAddressV6::setScopeId(), folly::IPAddressV6::str(), and folly::IPAddressV6::toSockAddr().

                       {
  // Test that link-local scope is saved
  auto str = "fe80::62eb:69ff:fe9b:ba60%eth0";
  IPAddressV6 a2(str);
  EXPECT_EQ(str, a2.str());

  sockaddr_in6 sock = a2.toSockAddr();
  EXPECT_NE(0, sock.sin6_scope_id);

  IPAddress a1(str);
  EXPECT_EQ(str, a1.str());

  a2.setScopeId(0);
  EXPECT_NE(a1, a2);

  EXPECT_TRUE(a2 < a1);
}

TEST	(	IPAddress	,
		ScopeNumeric
	)

Definition at line 233 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, folly::IPAddressV6::setScopeId(), folly::IPAddressV6::str(), and folly::IPAddressV6::toSockAddr().

                              {
  // it's very unlikely that the host running these
  // tests will have 42 network interfaces
  auto str = "fe80::62eb:69ff:fe9b:ba60%42";
  IPAddressV6 a2(str);
  EXPECT_EQ(str, a2.str());

  sockaddr_in6 sock = a2.toSockAddr();
  EXPECT_NE(0, sock.sin6_scope_id);

  IPAddress a1(str);
  EXPECT_EQ(str, a1.str());

  a2.setScopeId(0);
  EXPECT_NE(a1, a2);

  EXPECT_TRUE(a2 < a1);
}

TEST	(	IPAddress	,
		Ordering
	)

Definition at line 252 of file IPAddressTest.cpp.

References EXPECT_TRUE.

                          {
  IPAddress a1("0.1.1.1");
  IPAddress a2("1.1.1.0");
  EXPECT_TRUE(a1 < a2);

  IPAddress b1("::ffff:0.1.1.1");
  IPAddress b2("::ffff:1.1.1.0");
  EXPECT_TRUE(b1 < b2);
}

TEST	(	IPAddress	,
		InvalidAddressFamilyExceptions
	)

Definition at line 262 of file IPAddressTest.cpp.

References addr, and EXPECT_THROW.

                                                {
  // asV4
  {
    IPAddress addr;
    EXPECT_THROW(addr.asV4(), InvalidAddressFamilyException);
  }
  // asV6
  {
    IPAddress addr;
    EXPECT_THROW(addr.asV6(), InvalidAddressFamilyException);
  }
  // sockaddr ctor
  {
    // setup
    sockaddr_in addr;
    addr.sin_family = AF_UNSPEC;

    EXPECT_THROW(IPAddress((sockaddr*)&addr), InvalidAddressFamilyException);
  }
}

TEST	(	IPAddress	,
		TryCreateNetwork
	)

Definition at line 283 of file IPAddressTest.cpp.

References ASSERT_TRUE, folly::CIDR_MISMATCH, folly::pushmi::operators::error(), EXPECT_EQ, folly::INVALID_DEFAULT_CIDR, folly::INVALID_IP, and folly::INVALID_IP_SLASH_CIDR.

                                  {
  // test valid IPv4 network
  {
    auto net = IPAddress::tryCreateNetwork("192.168.0.1/24").value();
    ASSERT_TRUE(net.first.isV4());
    EXPECT_EQ("192.168.0.0", net.first.str());
    EXPECT_EQ(24, net.second);
    EXPECT_EQ("192.168.0.0/24", IPAddress::networkToString(net));
  }
  // test valid IPv4 network without applying mask
  {
    auto net = IPAddress::tryCreateNetwork("192.168.0.1/24", -1, false).value();
    ASSERT_TRUE(net.first.isV4());
    EXPECT_EQ("192.168.0.1", net.first.str());
    EXPECT_EQ(24, net.second);
    EXPECT_EQ("192.168.0.1/24", IPAddress::networkToString(net));
  }
  // test valid IPv6 network
  {
    auto net = IPAddress::tryCreateNetwork("1999::1/24").value();
    ASSERT_TRUE(net.first.isV6());
    EXPECT_EQ("1999::", net.first.str());
    EXPECT_EQ(24, net.second);
    EXPECT_EQ("1999::/24", IPAddress::networkToString(net));
  }
  // test valid IPv6 network without applying mask
  {
    auto net = IPAddress::tryCreateNetwork("1999::1/24", -1, false).value();
    ASSERT_TRUE(net.first.isV6());
    EXPECT_EQ("1999::1", net.first.str());
    EXPECT_EQ(24, net.second);
    EXPECT_EQ("1999::1/24", IPAddress::networkToString(net));
  }

  // test invalid default CIDR
  EXPECT_EQ(
      CIDRNetworkError::INVALID_DEFAULT_CIDR,
      IPAddress::tryCreateNetwork("192.168.1.1", 300).error());

  // test empty string
  EXPECT_EQ(
      CIDRNetworkError::INVALID_IP, IPAddress::tryCreateNetwork("").error());

  // test multi slash string
  EXPECT_EQ(
      CIDRNetworkError::INVALID_IP_SLASH_CIDR,
      IPAddress::tryCreateNetwork("192.168.0.1/24/36").error());

  // test no slash string with default IPv4
  {
    auto net = IPAddress::tryCreateNetwork("192.168.0.1").value();
    ASSERT_TRUE(net.first.isV4());
    EXPECT_EQ("192.168.0.1", net.first.str());
    EXPECT_EQ(32, net.second); // auto-detected
    net = IPAddress::createNetwork("192.168.0.1", -1, false);
    ASSERT_TRUE(net.first.isV4());
    EXPECT_EQ("192.168.0.1", net.first.str());
    EXPECT_EQ(32, net.second);
  }
  // test no slash string with default IPv6
  {
    auto net = IPAddress::tryCreateNetwork("1999::1").value();
    ASSERT_TRUE(net.first.isV6());
    EXPECT_EQ("1999::1", net.first.str());
    EXPECT_EQ(128, net.second);
  }
  // test no slash string with invalid default
  EXPECT_EQ(
      CIDRNetworkError::CIDR_MISMATCH,
      IPAddress::tryCreateNetwork("192.168.0.1", 33).error());
}

TEST	(	IPAddress	,
		CreateNetworkExceptions
	)

Definition at line 356 of file IPAddressTest.cpp.

References EXPECT_THROW.

                                         {
  // test invalid default CIDR
  EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 300), std::range_error);
  // test empty string
  EXPECT_THROW(IPAddress::createNetwork(""), IPAddressFormatException);
  // test multi slash string
  EXPECT_THROW(
      IPAddress::createNetwork("192.168.0.1/24/36"), IPAddressFormatException);
  // test no slash string with invalid default
  EXPECT_THROW(
      IPAddress::createNetwork("192.168.0.1", 33), IPAddressFormatException);
}

TEST	(	IPAddress	,
		Assignment
	)

Definition at line 370 of file IPAddressTest.cpp.

References addr, EXPECT_EQ, and EXPECT_TRUE.

                            {
  static const string kIPv4Addr = "69.63.189.16";
  static const string kIPv6Addr = "2620:0:1cfe:face:b00c::3";

  // Test assigning IPAddressV6 addr to IPAddress (was V4)
  {
    IPAddress addr(kIPv4Addr);
    IPAddressV6 addrV6 = IPAddress(kIPv6Addr).asV6();
    EXPECT_TRUE(addr.isV4());
    EXPECT_EQ(kIPv4Addr, addr.str());
    addr = addrV6;
    EXPECT_TRUE(addr.isV6());
    EXPECT_EQ(kIPv6Addr, addr.str());
  }
  // Test assigning IPAddressV4 addr to IPAddress (was V6)
  {
    IPAddress addr(kIPv6Addr);
    IPAddressV4 addrV4 = IPAddress(kIPv4Addr).asV4();
    EXPECT_TRUE(addr.isV6());
    EXPECT_EQ(kIPv6Addr, addr.str());
    addr = addrV4;
    EXPECT_TRUE(addr.isV4());
    EXPECT_EQ(kIPv4Addr, addr.str());
  }
  // Test assigning IPAddress(v6) to IPAddress (was v4)
  {
    IPAddress addr(kIPv4Addr);
    IPAddress addrV6 = IPAddress(kIPv6Addr);
    EXPECT_TRUE(addr.isV4());
    EXPECT_EQ(kIPv4Addr, addr.str());
    addr = addrV6;
    EXPECT_TRUE(addr.isV6());
    EXPECT_EQ(kIPv6Addr, addr.str());
  }
  // Test assigning IPAddress(v4) to IPAddress (was v6)
  {
    IPAddress addr(kIPv6Addr);
    IPAddress addrV4 = IPAddress(kIPv4Addr);
    EXPECT_TRUE(addr.isV6());
    EXPECT_EQ(kIPv6Addr, addr.str());
    addr = addrV4;
    EXPECT_TRUE(addr.isV4());
    EXPECT_EQ(kIPv4Addr, addr.str());
  }
}

TEST	(	IPAddress	,
		CtorDefault
	)

Definition at line 417 of file IPAddressTest.cpp.

References EXPECT_EQ.

                             {
  IPAddressV4 v4;
  EXPECT_EQ(IPAddressV4("0.0.0.0"), v4);
  IPAddressV6 v6;
  EXPECT_EQ(IPAddressV6("::0"), v6);
}

TEST	(	IPAddressV4	,
		validate
	)

Definition at line 424 of file IPAddressTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and folly::IPAddressV4::validate().

                            {
  EXPECT_TRUE(IPAddressV4::validate("0.0.0.0"));
  EXPECT_FALSE(IPAddressV4::validate("0.0.0."));
  EXPECT_TRUE(IPAddressV4::validate("127.127.127.127"));
}

TEST	(	IPAddressV6	,
		validate
	)

Definition at line 430 of file IPAddressTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and folly::IPAddressV6::validate().

                            {
  EXPECT_TRUE(IPAddressV6::validate("2620:0:1cfe:face:b00c::3"));
  EXPECT_FALSE(IPAddressV6::validate("0.0.0.0"));
  EXPECT_TRUE(IPAddressV6::validate("[2620:0:1cfe:face:b00c::3]"));
  EXPECT_TRUE(IPAddressV6::validate("::ffff:0.1.1.1"));
  EXPECT_TRUE(IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:0000:0003"));
  EXPECT_TRUE(
      IPAddressV6::validate("2620:0000:1cfe:face:b00c:0000:127.127.127.127"));
}

TEST	(	IPAddress	,
		validate
	)

Definition at line 440 of file IPAddressTest.cpp.

References EXPECT_FALSE, and EXPECT_TRUE.

                          {
  EXPECT_TRUE(IPAddress::validate("0.0.0.0"));
  EXPECT_TRUE(IPAddress::validate("::"));
  EXPECT_FALSE(IPAddress::validate("asdf"));
}

TEST	(	IPAddress	,
		CtorSockaddr
	)

Definition at line 499 of file IPAddressTest.cpp.

References addr, EXPECT_EQ, EXPECT_THROW, and EXPECT_TRUE.

                              {
  // test v4 address
  {
    // setup
    sockaddr_in addr;
    in_addr sin_addr;
    sin_addr.s_addr = htonl(2122547223);
    addr.sin_family = AF_INET;
    addr.sin_addr = sin_addr;

    IPAddress ipAddr((sockaddr*)&addr);
    EXPECT_TRUE(ipAddr.isV4());
    EXPECT_EQ("126.131.128.23", ipAddr.str());
  }
  // test v6 address
  {
    // setup
    sockaddr_in6 addr;
    memset(&addr, 0, sizeof(addr));
    in6_addr sin_addr;
    // 2620:0:1cfe:face:b00c::3
    ByteArray16 sec{
        {38, 32, 0, 0, 28, 254, 250, 206, 176, 12, 0, 0, 0, 0, 0, 3}};
    std::memcpy(sin_addr.s6_addr, sec.data(), 16);
    addr.sin6_family = AF_INET6;
    addr.sin6_addr = sin_addr;

    IPAddress ipAddr((sockaddr*)&addr);
    EXPECT_TRUE(ipAddr.isV6());
    EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
  }
  // test nullptr exception
  {
    sockaddr* addr = nullptr;
    EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
  }
  // test invalid family exception
  {
    // setup
    sockaddr_in addr;
    in_addr sin_addr;
    sin_addr.s_addr = htonl(2122547223);
    addr.sin_family = AF_UNSPEC;
    addr.sin_addr = sin_addr;

    EXPECT_THROW(IPAddress((sockaddr*)&addr), IPAddressFormatException);
  }
}

TEST	(	IPAddress	,
		ToSockaddrStorage
	)

Definition at line 548 of file IPAddressTest.cpp.

References addr, ASSERT_EQ, ASSERT_TRUE, EXPECT_EQ, EXPECT_GT, and EXPECT_THROW.

                                   {
  // test v4 address
  {
    string strAddr("126.131.128.23");
    IPAddress addr(strAddr);
    sockaddr_storage out;

    ASSERT_TRUE(addr.isV4()); // test invariant
    EXPECT_GT(addr.toSockaddrStorage(&out), 0);

    IPAddress sockAddr((sockaddr*)&out);
    ASSERT_TRUE(sockAddr.isV4());
    EXPECT_EQ(strAddr, sockAddr.str());
  }
  // test v6 address
  {
    string strAddr("2620:0:1cfe:face:b00c::3");
    IPAddress addr(strAddr);
    sockaddr_storage out;

    ASSERT_TRUE(addr.isV6()); // test invariant
    EXPECT_GT(addr.toSockaddrStorage(&out), 0);

    IPAddress sockAddr((sockaddr*)&out);
    ASSERT_TRUE(sockAddr.isV6());
    EXPECT_EQ(strAddr, sockAddr.str());
  }
  // test nullptr exception
  {
    sockaddr_storage* out = nullptr;
    IPAddress addr("127.0.0.1");
    EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
  }
  // test invalid family exception
  {
    IPAddress addr;
    sockaddr_storage out;
    ASSERT_EQ(AF_UNSPEC, addr.family());
    EXPECT_THROW(addr.toSockaddrStorage(&out), InvalidAddressFamilyException);
  }
}

TEST	(	IPAddress	,
		ToString
	)

Definition at line 628 of file IPAddressTest.cpp.

References EXPECT_EQ.

                          {
  // Test with IPAddressV4
  IPAddressV4 addr_10_0_0_1("10.0.0.1");
  EXPECT_EQ("10.0.0.1", folly::to<string>(addr_10_0_0_1));
  // Test with IPAddressV6
  IPAddressV6 addr_1("::1");
  EXPECT_EQ("::1", folly::to<string>(addr_1));
  // Test with IPAddress, both V4 and V6
  IPAddress addr_10_1_2_3("10.1.2.3");
  EXPECT_EQ("10.1.2.3", folly::to<string>(addr_10_1_2_3));
  IPAddress addr_1_2_3("1:2::3");
  EXPECT_EQ("1:2::3", folly::to<string>(addr_1_2_3));

  // Test a combination of all the above arguments
  EXPECT_EQ(
      "1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3",
      folly::to<string>(
          addr_1_2_3,
          " - ",
          addr_10_0_0_1,
          " - ",
          addr_1,
          " - ",
          addr_10_1_2_3));
}

TEST	(	IPaddress	,
		toInverseArpaName
	)

Definition at line 654 of file IPAddressTest.cpp.

References EXPECT_EQ, folly::sformat(), and folly::IPAddressV4::toInverseArpaName().

                                   {
  IPAddressV4 addr_ipv4("10.0.0.1");
  EXPECT_EQ("1.0.0.10.in-addr.arpa", addr_ipv4.toInverseArpaName());
  IPAddressV6 addr_ipv6("2620:0000:1cfe:face:b00c:0000:0000:0003");
  EXPECT_EQ(
      sformat(
          "{}.ip6.arpa",
          "3.0.0.0.0.0.0.0.0.0.0.0.c.0.0.b.e.c.a.f.e.f.c.1.0.0.0.0.0.2.6.2"),
      addr_ipv6.toInverseArpaName());
}

TEST	(	IPaddress	,
		fromInverseArpaName
	)

Definition at line 665 of file IPAddressTest.cpp.

References EXPECT_EQ, folly::IPAddressV4::fromInverseArpaName(), folly::IPAddressV6::fromInverseArpaName(), and folly::sformat().

                                     {
  EXPECT_EQ(
      IPAddressV4("10.0.0.1"),
      IPAddressV4::fromInverseArpaName("1.0.0.10.in-addr.arpa"));
  EXPECT_EQ(
      IPAddressV6("2620:0000:1cfe:face:b00c:0000:0000:0003"),
      IPAddressV6::fromInverseArpaName(sformat(
          "{}.ip6.arpa",
          "3.0.0.0.0.0.0.0.0.0.0.0.c.0.0.b.e.c.a.f.e.f.c.1.0.0.0.0.0.2.6.2")));
}

TEST	(	IPAddressSource	,
		ToHex
	)

Definition at line 698 of file IPAddressTest.cpp.

References folly::data(), EXPECT_EQ, and folly::detail::Bytes::toHex().

                             {
  vector<std::uint8_t> data = {{0xff, 0x20, 0x45}};
  EXPECT_EQ(detail::Bytes::toHex(data.data(), 0), "");
  EXPECT_EQ(detail::Bytes::toHex(data.data(), 1), "ff");
  EXPECT_EQ(detail::Bytes::toHex(data.data(), 2), "ff20");
  EXPECT_EQ(detail::Bytes::toHex(data.data(), 3), "ff2045");
}

TEST	(	IPAddress	,
		ToFullyQualifiedFb
	)

Definition at line 707 of file IPAddressTest.cpp.

References EXPECT_EQ.

                                    {
  IPAddress ip("2620:0:1cfe:face:b00c::3");
  EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", ip.toFullyQualified())
      << ip;
}

TEST	(	IPAddress	,
		ToFullyQualifiedLocal
	)

Definition at line 712 of file IPAddressTest.cpp.

References EXPECT_EQ.

                                       {
  IPAddress ip("::1");
  EXPECT_EQ("0000:0000:0000:0000:0000:0000:0000:0001", ip.toFullyQualified())
      << ip;
}

TEST	(	IPAddress	,
		ToFullyQualifiedAppendV6
	)

Definition at line 717 of file IPAddressTest.cpp.

References EXPECT_EQ, and string.

                                          {
  IPAddress ip("2620:0:1cfe:face:b00c::3");
  std::string result;
  ip.toFullyQualifiedAppend(result);
  EXPECT_EQ("2620:0000:1cfe:face:b00c:0000:0000:0003", result) << ip;
}

TEST	(	IPAddress	,
		ToFullyQualifiedAppendV4
	)

Definition at line 723 of file IPAddressTest.cpp.

References EXPECT_EQ, and string.

                                          {
  IPAddress ip("127.0.0.1");
  std::string result;
  ip.toFullyQualifiedAppend(result);
  EXPECT_EQ("127.0.0.1", result) << ip;
}

TEST	(	IPAddress	,
		ToFullyQualifiedSizeV6
	)

Definition at line 729 of file IPAddressTest.cpp.

References EXPECT_EQ, and folly::IPAddressV6::kToFullyQualifiedSize.

                                        {
  auto actual = IPAddressV6::kToFullyQualifiedSize;
  auto expected = IPAddress("::").toFullyQualified().size();
  EXPECT_EQ(expected, actual);
}

TEST	(	IPAddress	,
		MaxToFullyQualifiedSizeV4
	)

Definition at line 734 of file IPAddressTest.cpp.

References EXPECT_EQ, and folly::IPAddressV4::kMaxToFullyQualifiedSize.

                                           {
  auto actual = IPAddressV4::kMaxToFullyQualifiedSize;
  auto expected = IPAddress("255.255.255.255").toFullyQualified().size();
  EXPECT_EQ(expected, actual);
}

TEST	(	IPAddress	,
		UnitializedEqual
	)

Definition at line 790 of file IPAddressTest.cpp.

References EXPECT_EQ, and EXPECT_FALSE.

                                  {
  IPAddress addrEmpty;
  IPAddress ip4("127.0.0.1");
  EXPECT_FALSE(addrEmpty == ip4);
  EXPECT_FALSE(ip4 == addrEmpty);
  IPAddress ip6("::1");
  EXPECT_FALSE(addrEmpty == ip6);
  EXPECT_FALSE(ip6 == addrEmpty);
  IPAddress ip6Map("::ffff:192.0.2.129");
  EXPECT_FALSE(addrEmpty == ip6Map);
  EXPECT_FALSE(ip6Map == addrEmpty);
  IPAddress ip4Zero("0.0.0.0");
  EXPECT_FALSE(addrEmpty == ip4Zero);
  EXPECT_FALSE(ip4Zero == addrEmpty);
  IPAddress ip6Zero("::");
  EXPECT_FALSE(addrEmpty == ip6Zero);
  EXPECT_FALSE(ip6Zero == addrEmpty);
  EXPECT_EQ(addrEmpty, addrEmpty);
}

TEST	(	IPAddress	,
		InSubnetWith6to4
	)

Definition at line 811 of file IPAddressTest.cpp.

References EXPECT_TRUE.

                                  {
  auto ip = IPAddress("2002:c000:022a::"); // 192.0.2.42
  auto subnet = IPAddress("192.0.0.0");
  EXPECT_TRUE(ip.inSubnet(subnet, 16));

  auto ip2 = IPAddress("192.0.0.1");
  auto subnet2 = IPAddress("2002:c000:0000::"); // 192.0.0.0
  EXPECT_TRUE(ip2.inSubnet(subnet2, 14));

  auto ip3 = IPAddress("2002:c000:022a::"); // 192.0.2.42
  auto subnet3 = IPAddress("2002:c000:0000::"); // 192.0.0.0
  EXPECT_TRUE(ip3.inSubnet(subnet3, 16));
}

TEST	(	IPAddress	,
		getIPv6For6To4
	)

Definition at line 830 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and folly::IPAddressV4::getIPv6For6To4().

                                {
  for (auto ipv4Str : ipv4Strs) {
    auto ip = IPAddress(ipv4Str);
    EXPECT_TRUE(ip.isV4());
    IPAddressV4 ipv4 = ip.asV4();
    auto ipv6 = ipv4.getIPv6For6To4();
    EXPECT_EQ(ipv6.type(), IPAddressV6::Type::T6TO4);
    auto ipv4New = ipv6.getIPv4For6To4();
    EXPECT_EQ(ipv4Str, ipv4New.str());
  }
}

TEST	(	IPAddress	,
		InvalidMask
	)

Definition at line 846 of file IPAddressTest.cpp.

References EXPECT_THROW, and tc.

                             {
  for (auto& tc : invalidMasks) {
    auto ip = IPAddress(tc.first);
    EXPECT_THROW(ip.mask(tc.second), IPAddressFormatException);
  }
}

TEST	(	IPAddress	,
		V6Types
	)

Definition at line 859 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, FAIL, folly::pushmi::detail::t, and tc.

                         {
  auto mkName = [&](const IPAddressV6::Type t) -> string {
    switch (t) {
      case IPAddressV6::Type::TEREDO:
        return "teredo";
      case IPAddressV6::Type::T6TO4:
        return "6to4";
      default:
        return "default";
    }
  };

  for (auto& tc : v6types) {
    auto ip = IPAddress(tc.first);
    EXPECT_TRUE(ip.isV6());
    IPAddressV6 ipv6 = ip.asV6();
    EXPECT_EQ(tc.second, ipv6.type())
        << "expected " << mkName(tc.second) << ", got " << mkName(ipv6.type());
    switch (tc.second) {
      case IPAddressV6::Type::TEREDO:
        EXPECT_TRUE(ipv6.isTeredo()) << "isTeredo was false";
        EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
        break;
      case IPAddressV6::Type::T6TO4:
        EXPECT_TRUE(ipv6.is6To4()) << "is6To4 was false";
        EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
        break;
      case IPAddressV6::Type::NORMAL:
        EXPECT_FALSE(ipv6.is6To4()) << "is6To4 was true";
        EXPECT_FALSE(ipv6.isTeredo()) << "isTeredo was true";
        break;
      default:
        FAIL() << "Invalid expected type: " << to<std::string>(tc.second);
    }
  }
}

TEST	(	IPAddress	,
		ToLong
	)

Definition at line 902 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and tc.

                        {
  for (auto& tc : provideToLong) {
    auto ip = IPAddress(tc.first);
    EXPECT_TRUE(ip.isV4());
    IPAddressV4 ipv4 = ip.asV4();
    EXPECT_EQ(tc.second, ipv4.toLongHBO());

    auto ip2 = IPAddress::fromLongHBO(tc.second);
    EXPECT_TRUE(ip2.isV4());
    EXPECT_EQ(tc.first, ip2.str());
    EXPECT_EQ(tc.second, ip2.asV4().toLongHBO());

    auto nla = htonl(tc.second);
    auto ip3 = IPAddress::fromLong(nla);
    EXPECT_TRUE(ip3.isV4());
    EXPECT_EQ(tc.first, ip3.str());
    EXPECT_EQ(nla, ip3.asV4().toLong());
  }
}

TEST	(	IPAddress	,
		fromBinaryV4
	)

Definition at line 922 of file IPAddressTest.cpp.

References ASSERT_TRUE, folly::Endian::big(), folly::data(), EXPECT_EQ, EXPECT_THROW, EXPECT_TRUE, folly::IPAddressV4::fromBinary(), SCOPED_TRACE, tc, folly::IPAddressV4::tryFromBinary(), uint32_t, and uint8_t.

                              {
  for (auto& tc : provideToLong) {
    SCOPED_TRACE(tc.first);
    union {
      uint8_t u8[4];
      uint32_t u32;
    } data;
    data.u32 = Endian::big(tc.second);
    ByteRange bytes(data.u8, 4);

    auto fromBin = IPAddressV4::fromBinary(bytes);
    IPAddressV4 fromStr(tc.first);
    EXPECT_EQ(fromStr, fromBin);

    IPAddressV4 addr2("0.0.0.0");
    addr2 = IPAddressV4::fromBinary(bytes);
    EXPECT_EQ(fromStr, addr2);

    auto maybeAddr3 = IPAddressV4::tryFromBinary(bytes);
    EXPECT_TRUE(maybeAddr3.hasValue());
    EXPECT_EQ(fromStr, maybeAddr3.value());

    IPAddress genericAddr = IPAddress::fromBinary(bytes);
    ASSERT_TRUE(genericAddr.isV4());
    EXPECT_EQ(fromStr, genericAddr.asV4());
    EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
  }

  uint8_t data[20];
  EXPECT_THROW(
      IPAddressV4::fromBinary(ByteRange(data, 3)), IPAddressFormatException);
  EXPECT_THROW(
      IPAddressV4::fromBinary(ByteRange(data, 16)), IPAddressFormatException);
  EXPECT_THROW(
      IPAddressV4::fromBinary(ByteRange(data, 20)), IPAddressFormatException);
}

TEST	(	IPAddress	,
		toBinaryV4
	)

Definition at line 959 of file IPAddressTest.cpp.

References folly::Endian::big(), folly::data(), EXPECT_EQ, folly::IPAddressV4::fromBinary(), SCOPED_TRACE, tc, uint32_t, and uint8_t.

                            {
  for (auto& tc : provideToLong) {
    SCOPED_TRACE(tc.first);
    union {
      uint8_t u8[4];
      uint32_t u32;
    } data;
    data.u32 = Endian::big(tc.second);
    ByteRange bytes(data.u8, 4);

    auto fromBin = IPAddressV4::fromBinary(bytes);
    auto toBin = fromBin.toBinary();
    EXPECT_EQ(bytes, toBin);
  }
}

TEST	(	IPAddress	,
		fromBinaryV6
	)

Definition at line 1015 of file IPAddressTest.cpp.

References ASSERT_TRUE, folly::data(), EXPECT_EQ, EXPECT_THROW, EXPECT_TRUE, folly::IPAddressV6::fromBinary(), SCOPED_TRACE, tc, folly::IPAddressV6::tryFromBinary(), and uint8_t.

                              {
  for (auto& tc : provideBinary16Bytes) {
    SCOPED_TRACE(tc.first);
    ByteRange bytes(&tc.second.front(), tc.second.size());

    auto fromBin = IPAddressV6::fromBinary(bytes);
    IPAddressV6 fromStr(tc.first);
    EXPECT_EQ(fromStr, fromBin);

    IPAddressV6 addr2("::0");
    addr2 = IPAddressV6::fromBinary(bytes);
    EXPECT_EQ(fromStr, addr2);

    auto maybeAddr3 = IPAddressV6::tryFromBinary(bytes);
    EXPECT_TRUE(maybeAddr3.hasValue());
    EXPECT_EQ(fromStr, maybeAddr3.value());

    IPAddress genericAddr = IPAddress::fromBinary(bytes);
    ASSERT_TRUE(genericAddr.isV6());
    EXPECT_EQ(fromStr, genericAddr.asV6());
    EXPECT_EQ(ByteRange(genericAddr.bytes(), genericAddr.byteCount()), bytes);
  }

  uint8_t data[20];
  EXPECT_THROW(
      IPAddressV6::fromBinary(ByteRange(data, 3)), IPAddressFormatException);
  EXPECT_THROW(
      IPAddressV6::fromBinary(ByteRange(data, 4)), IPAddressFormatException);
  EXPECT_THROW(
      IPAddressV6::fromBinary(ByteRange(data, 20)), IPAddressFormatException);
}

TEST	(	IPAddress	,
		toBinaryV6
	)

Definition at line 1047 of file IPAddressTest.cpp.

References EXPECT_EQ, folly::IPAddressV6::fromBinary(), SCOPED_TRACE, and tc.

                            {
  for (auto& tc : provideBinary16Bytes) {
    SCOPED_TRACE(tc.first);
    ByteRange bytes(&tc.second.front(), tc.second.size());

    auto fromBin = IPAddressV6::fromBinary(bytes);
    auto toBin = fromBin.toBinary();
    EXPECT_EQ(bytes, toBin);
  }
}

TEST	(	IPAddress	,
		CreateLinkLocal
	)

Definition at line 1096 of file IPAddressTest.cpp.

References addr, EXPECT_EQ, and folly::IPAddressV6::LINK_LOCAL.

                                 {
  IPAddressV6 addr(IPAddressV6::LINK_LOCAL, MacAddress("00:05:73:f9:46:fc"));
  EXPECT_EQ(IPAddressV6("fe80::0205:73ff:fef9:46fc"), addr);

  addr = IPAddressV6(IPAddressV6::LINK_LOCAL, MacAddress("02:00:00:12:34:56"));
  EXPECT_EQ(IPAddressV6("fe80::ff:fe12:3456"), addr);
}

TEST	(	IPAddress	,
		SolicitedNodeAddress
	)

Definition at line 1111 of file IPAddressTest.cpp.

References EXPECT_EQ.

                                      {
  // An example from RFC 4291 section 2.7.1
  EXPECT_EQ(
      IPAddressV6("ff02::1:ff0e:8c6c"),
      IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress());

  // An example from wikipedia
  // (http://en.wikipedia.org/wiki/Solicited-node_multicast_address)
  EXPECT_EQ(
      IPAddressV6("ff02::1:ff28:9c5a"),
      IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress());
}

TEST	(	IPAddress	,
		InvalidByteAccess
	)

Definition at line 1167 of file IPAddressTest.cpp.

References EXPECT_THROW.

                                   {
  IPAddress ip4("10.10.10.10");
  // MSByte, LSByte accessors are 0 indexed
  EXPECT_THROW(ip4.getNthMSByte(ip4.byteCount()), std::invalid_argument);
  EXPECT_THROW(ip4.getNthLSByte(ip4.byteCount()), std::invalid_argument);
  EXPECT_THROW(ip4.getNthMSByte(-1), std::invalid_argument);
  EXPECT_THROW(ip4.getNthLSByte(-1), std::invalid_argument);
  auto asV4 = ip4.asV4();
  EXPECT_THROW(asV4.getNthMSByte(asV4.byteCount()), std::invalid_argument);
  EXPECT_THROW(asV4.getNthLSByte(asV4.byteCount()), std::invalid_argument);
  EXPECT_THROW(asV4.getNthMSByte(-1), std::invalid_argument);
  EXPECT_THROW(asV4.getNthLSByte(-1), std::invalid_argument);

  IPAddress ip6("2620:0:1cfe:face:b00c::3");
  EXPECT_THROW(ip6.getNthMSByte(ip6.byteCount()), std::invalid_argument);
  EXPECT_THROW(ip6.getNthLSByte(ip6.byteCount()), std::invalid_argument);
  EXPECT_THROW(ip6.getNthMSByte(-1), std::invalid_argument);
  EXPECT_THROW(ip6.getNthLSByte(-1), std::invalid_argument);
  auto asV6 = ip6.asV6();
  EXPECT_THROW(asV6.getNthMSByte(asV6.byteCount()), std::invalid_argument);
  EXPECT_THROW(asV6.getNthLSByte(asV6.byteCount()), std::invalid_argument);
  EXPECT_THROW(asV6.getNthMSByte(-1), std::invalid_argument);
  EXPECT_THROW(asV6.getNthLSByte(-1), std::invalid_argument);
}

TEST	(	IPAddress	,
		InvalidBBitAccess
	)

Definition at line 1192 of file IPAddressTest.cpp.

References EXPECT_THROW.

                                   {
  IPAddress ip4("10.10.10.10");
  // MSByte, LSByte accessors are 0 indexed
  EXPECT_THROW(ip4.getNthMSBit(ip4.bitCount()), std::invalid_argument);
  EXPECT_THROW(ip4.getNthLSBit(ip4.bitCount()), std::invalid_argument);
  EXPECT_THROW(ip4.getNthMSBit(-1), std::invalid_argument);
  EXPECT_THROW(ip4.getNthLSBit(-1), std::invalid_argument);
  auto asV4 = ip4.asV4();
  EXPECT_THROW(asV4.getNthMSBit(asV4.bitCount()), std::invalid_argument);
  EXPECT_THROW(asV4.getNthLSBit(asV4.bitCount()), std::invalid_argument);
  EXPECT_THROW(asV4.getNthMSBit(-1), std::invalid_argument);
  EXPECT_THROW(asV4.getNthLSBit(-1), std::invalid_argument);

  IPAddress ip6("2620:0:1cfe:face:b00c::3");
  EXPECT_THROW(ip6.getNthMSBit(ip6.bitCount()), std::invalid_argument);
  EXPECT_THROW(ip6.getNthLSBit(ip6.bitCount()), std::invalid_argument);
  EXPECT_THROW(ip6.getNthMSBit(-1), std::invalid_argument);
  EXPECT_THROW(ip6.getNthLSBit(-1), std::invalid_argument);
  auto asV6 = ip6.asV6();
  EXPECT_THROW(asV6.getNthMSBit(asV6.bitCount()), std::invalid_argument);
  EXPECT_THROW(asV6.getNthLSBit(asV6.bitCount()), std::invalid_argument);
  EXPECT_THROW(asV6.getNthMSBit(-1), std::invalid_argument);
  EXPECT_THROW(asV6.getNthLSBit(-1), std::invalid_argument);
}

TEST	(	IPAddress	,
		StringFormat
	)

Definition at line 1217 of file IPAddressTest.cpp.

References EXPECT_EQ, folly::detail::fastIpv4ToString(), folly::detail::fastIpv6ToString(), i, and folly::pushmi::detail::t.

                              {
  in6_addr a6;
  for (int i = 0; i < 8; ++i) {
    auto t = htons(0x0123 + ((i % 4) * 0x4444));
#ifdef _WIN32
    a6.u.Word[i] = t;
#else
    a6.s6_addr16[i] = t;
#endif
  }
  EXPECT_EQ(
      "0123:4567:89ab:cdef:0123:4567:89ab:cdef", detail::fastIpv6ToString(a6));

  in_addr a4;
  a4.s_addr = htonl(0x01020304);
  EXPECT_EQ("1.2.3.4", detail::fastIpv4ToString(a4));
}

TEST	(	IPAddress	,
		getMacAddressFromLinkLocal
	)

Definition at line 1235 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and folly::IPAddressV6::getMacAddressFromLinkLocal().

                                            {
  IPAddressV6 ip6("fe80::f652:14ff:fec5:74d8");
  EXPECT_TRUE(ip6.getMacAddressFromLinkLocal().hasValue());
  EXPECT_EQ("f4:52:14:c5:74:d8", ip6.getMacAddressFromLinkLocal()->toString());
}

TEST	(	IPAddress	,
		getMacAddressFromLinkLocal_Negative
	)

Definition at line 1241 of file IPAddressTest.cpp.

References EXPECT_FALSE, and folly::IPAddressV6::getMacAddressFromLinkLocal().

                                                     {
  IPAddressV6 no_link_local_ip6("2803:6082:a2:4447::1");
  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
  no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ccc5:74d8");
  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
  no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ffc5:74d8");
  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
  no_link_local_ip6 = IPAddressV6("fe81::f652:14ff:ffc5:74d8");
  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
}

TEST	(	IPAddress	,
		getMacAddressFromEUI64
	)

Definition at line 1252 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and folly::IPAddressV6::getMacAddressFromEUI64().

                                        {
  IPAddressV6 ip6("2401:db00:3020:51dc:4a57:ddff:fe04:5643");
  EXPECT_TRUE(ip6.getMacAddressFromEUI64().hasValue());
  EXPECT_EQ("48:57:dd:04:56:43", ip6.getMacAddressFromEUI64()->toString());
  ip6 = IPAddressV6("fe80::4a57:ddff:fe04:5643");
  EXPECT_TRUE(ip6.getMacAddressFromEUI64().hasValue());
  EXPECT_EQ("48:57:dd:04:56:43", ip6.getMacAddressFromEUI64()->toString());
}

TEST	(	IPAddress	,
		getMacAddressFromEUI64_Negative
	)

Definition at line 1261 of file IPAddressTest.cpp.

References EXPECT_FALSE, and folly::IPAddressV6::getMacAddressFromEUI64().

                                                 {
  IPAddressV6 not_eui64_ip6("2401:db00:3020:51dc:face:0000:009a:0000");
  EXPECT_FALSE(not_eui64_ip6.getMacAddressFromEUI64().hasValue());
}

TEST	(	IPAddress	,
		LongestCommonPrefix
	)

Definition at line 1266 of file IPAddressTest.cpp.

References folly::IPAddressV4::bitCount(), folly::IPAddressV6::bitCount(), EXPECT_EQ, EXPECT_THROW, folly::IPAddressV4::longestCommonPrefix(), folly::IPAddressV6::longestCommonPrefix(), and prefix().

                                     {
  IPAddress ip10("10.0.0.0");
  IPAddress ip11("11.0.0.0");
  IPAddress ip12("12.0.0.0");
  IPAddress ip128("128.0.0.0");
  IPAddress ip10dot10("10.10.0.0");
  auto prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip128, 8});
  auto prefix4 =
      IPAddressV4::longestCommonPrefix({ip10.asV4(), 8}, {ip128.asV4(), 8});
  // No bits match b/w 128/8 and 10/8
  EXPECT_EQ(IPAddress("0.0.0.0"), prefix.first);
  EXPECT_EQ(0, prefix.second);
  EXPECT_EQ(IPAddressV4("0.0.0.0"), prefix4.first);
  EXPECT_EQ(0, prefix4.second);

  prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip10dot10, 16});
  prefix4 = IPAddressV4::longestCommonPrefix(
      {ip10.asV4(), 8}, {ip10dot10.asV4(), 16});
  // Between 10/8 and 10.10/16, 10/8 is the longest common match
  EXPECT_EQ(ip10, prefix.first);
  EXPECT_EQ(8, prefix.second);
  EXPECT_EQ(ip10.asV4(), prefix4.first);
  EXPECT_EQ(8, prefix4.second);

  prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
  prefix4 =
      IPAddressV4::longestCommonPrefix({ip11.asV4(), 8}, {ip12.asV4(), 8});
  // 12 = 1100, 11 = 1011, longest match - 1000 = 8
  EXPECT_EQ(IPAddress("8.0.0.0"), prefix.first);
  EXPECT_EQ(5, prefix.second);
  EXPECT_EQ(IPAddressV4("8.0.0.0"), prefix4.first);
  EXPECT_EQ(5, prefix4.second);

  // Between 128/1 and 128/2, longest match 128/1
  prefix = IPAddress::longestCommonPrefix({ip128, 1}, {ip128, 2});
  prefix4 =
      IPAddressV4::longestCommonPrefix({ip128.asV4(), 1}, {ip128.asV4(), 2});
  EXPECT_EQ(ip128, prefix.first);
  EXPECT_EQ(1, prefix.second);
  EXPECT_EQ(ip128.asV4(), prefix4.first);
  EXPECT_EQ(1, prefix4.second);

  IPAddress ip6("2620:0:1cfe:face:b00c::3");
  prefix = IPAddress::longestCommonPrefix(
      {ip6, ip6.bitCount()}, {ip6, ip6.bitCount()});
  auto prefix6 = IPAddressV6::longestCommonPrefix(
      {ip6.asV6(), IPAddressV6::bitCount()},
      {ip6.asV6(), IPAddressV6::bitCount()});
  // Longest common b/w me and myself is myself
  EXPECT_EQ(ip6, prefix.first);
  EXPECT_EQ(ip6.bitCount(), prefix.second);
  EXPECT_EQ(ip6.asV6(), prefix6.first);
  EXPECT_EQ(ip6.asV6().bitCount(), prefix6.second);

  IPAddress ip6Zero("::");
  prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, {ip6Zero, 0});
  prefix6 = IPAddressV6::longestCommonPrefix(
      {ip6.asV6(), IPAddressV6::bitCount()}, {ip6Zero.asV6(), 0});
  // Longest common b/w :: (ipv6 equivalent of 0/0) is ::
  EXPECT_EQ(ip6Zero, prefix.first);
  EXPECT_EQ(0, prefix.second);

  // Exceptional cases
  EXPECT_THROW(
      IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
      std::invalid_argument);
  EXPECT_THROW(
      IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1}, {ip10, 8}),
      std::invalid_argument);
  EXPECT_THROW(
      IPAddressV4::longestCommonPrefix(
          {ip10.asV4(), IPAddressV4::bitCount() + 1}, {ip10.asV4(), 8}),
      std::invalid_argument);
  EXPECT_THROW(
      IPAddress::longestCommonPrefix(
          {ip6, ip6.bitCount() + 1}, {ip6, ip6.bitCount()}),
      std::invalid_argument);
  EXPECT_THROW(
      IPAddressV6::longestCommonPrefix(
          {ip6.asV6(), IPAddressV6::bitCount() + 1},
          {ip6.asV6(), IPAddressV6::bitCount()}),
      std::invalid_argument);
}

TEST	(	IPAddressV4	,
		fetchMask
	)

Definition at line 1574 of file IPAddressTest.cpp.

References testing::ElementsAreArray(), EXPECT_THAT, and folly::IPAddressV4::fetchMask().

                             {
  struct X : private IPAddressV4 {
    using IPAddressV4::fetchMask;
  };

  EXPECT_THAT(
      X::fetchMask(0),
      ::testing::ElementsAreArray(ByteArray4{{0x00, 0x00, 0x00, 0x00}}));

  EXPECT_THAT(
      X::fetchMask(1),
      ::testing::ElementsAreArray(ByteArray4{{0x80, 0x00, 0x00, 0x00}}));

  EXPECT_THAT(
      X::fetchMask(31),
      ::testing::ElementsAreArray(ByteArray4{{0xff, 0xff, 0xff, 0xfe}}));

  EXPECT_THAT(
      X::fetchMask(32),
      ::testing::ElementsAreArray(ByteArray4{{0xff, 0xff, 0xff, 0xff}}));
}

TEST	(	IPAddressV6	,
		fetchMask
	)

Definition at line 1596 of file IPAddressTest.cpp.

References testing::ElementsAreArray(), EXPECT_THAT, folly::IPAddressV6::fetchMask(), and join8.

                             {
  struct X : private IPAddressV6 {
    using IPAddressV6::fetchMask;
  };

  EXPECT_THAT(
      X::fetchMask(0),
      ::testing::ElementsAreArray(join8({{
          ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
          ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
      }})));

  EXPECT_THAT(
      X::fetchMask(1),
      ::testing::ElementsAreArray(join8({{
          ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
          ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
      }})));

  EXPECT_THAT(
      X::fetchMask(63),
      ::testing::ElementsAreArray(join8({{
          ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
          ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
      }})));

  EXPECT_THAT(
      X::fetchMask(64),
      ::testing::ElementsAreArray(join8({{
          ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
          ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
      }})));

  EXPECT_THAT(
      X::fetchMask(65),
      ::testing::ElementsAreArray(join8({{
          ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
          ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
      }})));

  EXPECT_THAT(
      X::fetchMask(127),
      ::testing::ElementsAreArray(join8({{
          ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
          ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
      }})));

  EXPECT_THAT(
      X::fetchMask(128),
      ::testing::ElementsAreArray(join8({{
          ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
          ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
      }})));
}

TEST_P	(	IPAddressTest	,
		CtorAddress
	)

Definition at line 447 of file IPAddressTest.cpp.

References AddressData::address, AddressData::bytes, EXPECT_EQ, folly::detail::Bytes::mkAddress4(), folly::detail::Bytes::mkAddress6(), and AddressData::version.

                                   {
  AddressData param = GetParam();
  IPAddress strAddr(param.address);
  IPAddress address;

  if (param.version == 4) {
    in_addr v4addr = detail::Bytes::mkAddress4(&param.bytes[0]);
    address = IPAddress(v4addr);
  } else {
    in6_addr v6addr = detail::Bytes::mkAddress6(&param.bytes[0]);
    address = IPAddress(v6addr);
  }
  ExpectIsValid(address);
  EXPECT_EQ(strAddr, address);
}

TEST_P	(	IPAddressTest	,
		CtorBinary
	)

Definition at line 464 of file IPAddressTest.cpp.

References AddressData::address, EXPECT_EQ, AddressData::parseAddress4(), AddressData::parseAddress6(), and AddressData::version.

                                  {
  AddressData param = GetParam();
  IPAddress address;

  if (param.version == 4) {
    in_addr v4addr = AddressData::parseAddress4(param.address);
    address = IPAddress::fromBinary(ByteRange((unsigned char*)&v4addr, 4));
  } else {
    in6_addr v6addr = AddressData::parseAddress6(param.address);
    address = IPAddress::fromBinary(ByteRange((unsigned char*)&v6addr, 16));
  }

  ExpectIsValid(address);
  EXPECT_EQ(IPAddress(param.address), address);
}

TEST_P	(	IPAddressTest	,
		CtorString
	)

Definition at line 481 of file IPAddressTest.cpp.

References AddressData::address, EXPECT_THROW, and AddressData::version.

                                  {
  AddressData param = GetParam();
  IPAddress address(param.address);

  ExpectIsValid(address);

  // Test the direct version-specific constructor
  if (param.version == 4) {
    IPAddressV4 v4(param.address);
    ExpectIsValid(IPAddress(v4));
    EXPECT_THROW(IPAddressV6 v6(param.address), IPAddressFormatException);
  } else if (param.version == 6) {
    IPAddressV6 v6(param.address);
    ExpectIsValid(IPAddress(v6));
    EXPECT_THROW(IPAddressV4 v4(param.address), IPAddressFormatException);
  }
}

TEST_P	(	TryFromStringTest	,
		IPAddress
	)

Definition at line 590 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::INVALID_IP, and folly::UNSUPPORTED_ADDR_FAMILY.

                                     {
  auto param = GetParam();
  auto maybeIp = IPAddress::tryFromString(param.in);
  if (param.out) {
    EXPECT_TRUE(maybeIp.hasValue());
    EXPECT_EQ(param.out, maybeIp.value().str());
  } else {
    EXPECT_TRUE(maybeIp.hasError());
    EXPECT_TRUE(
        IPAddressFormatError::INVALID_IP == maybeIp.error() ||
        IPAddressFormatError::UNSUPPORTED_ADDR_FAMILY == maybeIp.error());
  }
}

TEST_P	(	TryFromStringTest	,
		IPAddressV4
	)

Definition at line 604 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::INVALID_IP, and folly::IPAddressV4::tryFromString().

                                       {
  auto param = GetParam();
  auto maybeIp = IPAddressV4::tryFromString(param.in);
  if (param.out4) {
    EXPECT_TRUE(maybeIp.hasValue());
    EXPECT_EQ(param.out4, maybeIp.value().str());
  } else {
    EXPECT_TRUE(maybeIp.hasError());
    EXPECT_EQ(IPAddressFormatError::INVALID_IP, maybeIp.error());
  }
}

TEST_P	(	TryFromStringTest	,
		IPAddressV6
	)

Definition at line 616 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::INVALID_IP, and folly::IPAddressV6::tryFromString().

                                       {
  auto param = GetParam();
  auto maybeIp = IPAddressV6::tryFromString(param.in);
  if (param.out6) {
    EXPECT_TRUE(maybeIp.hasValue());
    EXPECT_EQ(param.out6, maybeIp.value().str());
  } else {
    EXPECT_TRUE(maybeIp.hasError());
    EXPECT_EQ(IPAddressFormatError::INVALID_IP, maybeIp.error());
  }
}

TEST_P	(	IPAddressCtorTest	,
		InvalidCreation
	)

Definition at line 677 of file IPAddressTest.cpp.

References addr, and EXPECT_THROW.

                                           {
  string addr = GetParam();
  EXPECT_THROW(IPAddress((const string)addr), IPAddressFormatException)
      << "IPAddress(" << addr << ") "
      << "should have thrown an IPAddressFormatException";
}

TEST_P	(	IPAddressCtorBinaryTest	,
		InvalidBinary
	)

Definition at line 685 of file IPAddressTest.cpp.

References EXPECT_THROW, EXPECT_TRUE, folly::IPAddressV4::fromBinary(), folly::IPAddressV6::fromBinary(), folly::IPAddressV4::tryFromBinary(), and folly::IPAddressV6::tryFromBinary().

                                               {
  auto bin = GetParam();
  auto byteRange = ByteRange(&bin[0], bin.size());
  // Throwing versions.
  EXPECT_THROW(IPAddress::fromBinary(byteRange), IPAddressFormatException);
  EXPECT_THROW(IPAddressV4::fromBinary(byteRange), IPAddressFormatException);
  EXPECT_THROW(IPAddressV6::fromBinary(byteRange), IPAddressFormatException);
  // Non-throwing versions.
  EXPECT_TRUE(IPAddress::tryFromBinary(byteRange).hasError());
  EXPECT_TRUE(IPAddressV4::tryFromBinary(byteRange).hasError());
  EXPECT_TRUE(IPAddressV6::tryFromBinary(byteRange).hasError());
}

TEST_P	(	IPAddressMappedTest	,
		MappedEqual
	)

Definition at line 741 of file IPAddressTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and folly::gen::mapped().

                                         {
  auto param = GetParam();
  string mappedIp = param.first;
  string otherIp = param.second;

  auto mapped = IPAddress(mappedIp);
  auto expected = IPAddress(otherIp);

  EXPECT_EQ(expected, mapped);

  IPAddress v6addr;
  if (mapped.isV4()) {
    v6addr = mapped.asV4().createIPv6();
  } else if (expected.isV4()) {
    v6addr = expected.asV4().createIPv6();
  }
  EXPECT_TRUE(v6addr.isV6());
  EXPECT_TRUE(mapped == v6addr);
  EXPECT_TRUE(expected == v6addr);
}

TEST_P	(	IPAddressMaskTest	,
		Masks
	)

Definition at line 763 of file IPAddressTest.cpp.

References EXPECT_EQ.

                                 {
  auto param = GetParam();

  IPAddress ip(param.address);
  IPAddress masked = ip.mask(param.mask);
  EXPECT_EQ(param.subnet, masked.str())
      << param.address << "/" << folly::to<std::string>(param.mask) << " -> "
      << param.subnet;
}

TEST_P	(	IPAddressMaskTest	,
		InSubnet
	)

Definition at line 774 of file IPAddressTest.cpp.

References EXPECT_TRUE.

                                    {
  auto param = GetParam();

  IPAddress ip(param.address);
  IPAddress subnet(param.subnet);
  EXPECT_TRUE(ip.inSubnet(subnet, param.mask));
}

TEST_P	(	IPAddressMaskBoundaryTest	,
		NonMaskedSubnet
	)

Definition at line 783 of file IPAddressTest.cpp.

References EXPECT_EQ.

                                                   {
  auto param = GetParam();
  IPAddress ip(param.address);
  IPAddress subnet(param.subnet);
  EXPECT_EQ(param.inSubnet, ip.inSubnet(subnet, param.mask));
}

TEST_P	(	IPAddressFlagTest	,
		IsLoopback
	)

Definition at line 1058 of file IPAddressTest.cpp.

References addr, AddressFlags::address, EXPECT_EQ, AddressFlags::isLoopback(), and AddressFlags::version.

                                      {
  AddressFlags param = GetParam();
  IPAddress addr(param.address);

  EXPECT_EQ(param.version, addr.version());
  EXPECT_EQ(param.isLoopback(), addr.isLoopback());
}

TEST_P	(	IPAddressFlagTest	,
		IsPrivate
	)

Definition at line 1066 of file IPAddressTest.cpp.

References addr, AddressFlags::address, EXPECT_EQ, AddressFlags::isPrivate(), and AddressFlags::version.

                                     {
  AddressFlags param = GetParam();
  IPAddress addr(param.address);

  EXPECT_EQ(param.version, addr.version());
  EXPECT_EQ(param.isPrivate(), addr.isPrivate()) << addr;
}

TEST_P	(	IPAddressFlagTest	,
		IsNonroutable
	)

Definition at line 1074 of file IPAddressTest.cpp.

References addr, AddressFlags::address, EXPECT_EQ, AddressFlags::isNonroutable(), and AddressFlags::version.

                                         {
  AddressFlags param = GetParam();
  IPAddress addr(param.address);

  EXPECT_EQ(param.version, addr.version());
  EXPECT_EQ(param.isNonroutable(), addr.isNonroutable()) << addr;
}

TEST_P	(	IPAddressFlagTest	,
		IsZero
	)

Definition at line 1082 of file IPAddressTest.cpp.

References addr, AddressFlags::address, EXPECT_EQ, AddressFlags::isZero(), and AddressFlags::version.

                                  {
  AddressFlags param = GetParam();
  IPAddress addr(param.address);

  EXPECT_EQ(param.version, addr.version());
  EXPECT_EQ(param.isZero(), addr.isZero()) << addr;
}

TEST_P	(	IPAddressFlagTest	,
		IsLinkLocal
	)

Definition at line 1090 of file IPAddressTest.cpp.

References addr, AddressFlags::address, EXPECT_EQ, and AddressFlags::isLinkLocal().

                                       {
  AddressFlags param = GetParam();
  IPAddress addr(param.address);
  EXPECT_EQ(param.isLinkLocal(), addr.isLinkLocal()) << addr;
}

TEST_P	(	IPAddressFlagTest	,
		IsLinkLocalBroadcast
	)

Definition at line 1104 of file IPAddressTest.cpp.

References addr, AddressFlags::address, EXPECT_EQ, AddressFlags::isLinkLocalBroadcast(), and AddressFlags::version.

                                                {
  AddressFlags param = GetParam();
  IPAddress addr(param.address);
  EXPECT_EQ(param.version, addr.version());
  EXPECT_EQ(param.isLinkLocalBroadcast(), addr.isLinkLocalBroadcast());
}

TEST_P	(	IPAddressByteAccessorTest	,
		CheckBytes
	)

Definition at line 1124 of file IPAddressTest.cpp.

References EXPECT_EQ, and i.

                                              {
  auto addrData = GetParam();
  IPAddress ip(addrData.address);
  size_t i = 0;
  for (auto byitr = addrData.bytes.begin(); i < ip.byteCount(); ++i, ++byitr) {
    EXPECT_EQ(*byitr, ip.getNthMSByte(i));
    EXPECT_EQ(
        *byitr,
        ip.isV4() ? ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i));
  }
  i = 0;
  for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount();
       ++i, ++byritr) {
    EXPECT_EQ(*byritr, ip.getNthLSByte(i));
    EXPECT_EQ(
        *byritr,
        ip.isV4() ? ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
  }
}

TEST_P	(	IPAddressBitAccessorTest	,
		CheckBits
	)

Definition at line 1144 of file IPAddressTest.cpp.

References EXPECT_EQ, i, and folly::makeBitIterator().

                                            {
  auto addrData = GetParam();
  auto littleEndianAddrData = addrData.bytes;
  // IPAddress stores address data in n/w byte order.
  reverse(littleEndianAddrData.begin(), littleEndianAddrData.end());
  // Bit iterator goes from LSBit to MSBit
  // We will traverse the IPAddress bits from 0 to bitCount -1
  auto bitr = folly::makeBitIterator(littleEndianAddrData.begin());
  IPAddress ip(addrData.address);
  for (size_t i = 0; i < ip.bitCount(); ++i) {
    auto msbIndex = ip.bitCount() - i - 1;
    EXPECT_EQ(*bitr, ip.getNthMSBit(msbIndex));
    EXPECT_EQ(
        *bitr,
        ip.isV4() ? ip.asV4().getNthMSBit(msbIndex)
                  : ip.asV6().getNthMSBit(msbIndex));
    EXPECT_EQ(*bitr, ip.getNthLSBit(i));
    EXPECT_EQ(
        *bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) : ip.asV6().getNthLSBit(i));
    ++bitr;
  }
}

Variable Documentation

vector<AddressFlags> flagProvider

static

Definition at line 1393 of file IPAddressTest.cpp.

const vector<string> invalidAddressProvider

static

Initial value:

= {
    "",
    "foo",
    "1.1.1.256",
    "1",
    ":1",
    "127.0.0.1,127.0.0.1",
    "[1234]",
}

Definition at line 1361 of file IPAddressTest.cpp.

const vector<ByteVector> invalidBinaryProvider

static

Initial value:

= {
    {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31},
    
    {0x66, 0x6f, 0x6f},
    {0x00},
    {0x00, 0x00},
    {0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00, 0x00, 0x00},
    {0xff},
}

Definition at line 1371 of file IPAddressTest.cpp.

const vector<pair<string, uint8_t> > invalidMasks

static

Initial value:

= {
    {"127.0.0.1", 33},
    {"::1", 129},
}

Definition at line 842 of file IPAddressTest.cpp.

const vector<string> ipv4Strs

static

Initial value:

= {
    "127.0.0.1",
    "198.168.0.1",
    "8.8.0.0",
}

Definition at line 825 of file IPAddressTest.cpp.

const uint8_t IS_LINK_LOCAL

static

Initial value:

=
    AddressFlags::IS_LINK_LOCAL | IS_NONROUTABLE

Definition at line 1386 of file IPAddressTest.cpp.

const uint8_t IS_LINK_LOCAL_BROADCAST

static

Initial value:

=
    AddressFlags::IS_LINK_LOCAL_BROADCAST

Definition at line 1390 of file IPAddressTest.cpp.

const uint8_t IS_LOCAL = AddressFlags::IS_LOCAL

static

Definition at line 1382 of file IPAddressTest.cpp.

const uint8_t IS_MULTICAST = AddressFlags::IS_MULTICAST

static

Definition at line 1389 of file IPAddressTest.cpp.

const uint8_t IS_NONROUTABLE = AddressFlags::IS_NONROUTABLE

static

Definition at line 1383 of file IPAddressTest.cpp.

const uint8_t IS_PRIVATE = AddressFlags::IS_PRIVATE

static

Definition at line 1384 of file IPAddressTest.cpp.

const uint8_t IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE

static

Definition at line 1388 of file IPAddressTest.cpp.

const uint8_t IS_ZERO = AddressFlags::IS_ZERO

static

Definition at line 1385 of file IPAddressTest.cpp.

auto join8

static

Initial value:

= [](std::array<ByteArray8, 2> parts) {
  ByteArray16 _return;
  std::memcpy(_return.data(), parts.data(), _return.size());
  return _return;
}

Definition at line 977 of file IPAddressTest.cpp.

Referenced by TEST().

const vector<pair<string, string> > mapProvider

static

Initial value:

= {
    {"::ffff:192.0.2.128", "192.0.2.128"},
    {"192.0.2.128", "::ffff:192.0.2.128"},
    {"::FFFF:129.144.52.38", "129.144.52.38"},
    {"129.144.52.38", "::FFFF:129.144.52.38"},
    {"0:0:0:0:0:FFFF:222.1.41.90", "222.1.41.90"},
    {"::FFFF:222.1.41.90", "222.1.41.90"},
}

Definition at line 1470 of file IPAddressTest.cpp.

const vector<MaskBoundaryData> maskBoundaryProvider

static

Initial value:

= {
    MaskBoundaryData("10.1.1.1", 24, "10.1.1.1", true),
    MaskBoundaryData("10.1.1.1", 8, "10.1.2.3", true),
    MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfe::", true),
    
    MaskBoundaryData("10.1.1.1", 24, "10.1.2.1", false),
    MaskBoundaryData("10.1.1.1", 16, "10.2.3.4", false),
    MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false),
}

Definition at line 1523 of file IPAddressTest.cpp.

const vector<MaskData> masksProvider

static

Definition at line 1479 of file IPAddressTest.cpp.

const vector<pair<string, ByteArray16> > provideBinary16Bytes

static

Definition at line 983 of file IPAddressTest.cpp.

const vector<pair<string, uint32_t> > provideToLong

static

Initial value:

= {
    {"0.0.0.0", 0},
    {"10.0.0.0", 167772160},
    {"126.131.128.23", 2122547223},
    {"192.168.0.0", 3232235520},
}

Definition at line 896 of file IPAddressTest.cpp.

const vector<pair<string, IPAddressV6::Type> > v6types

static

Initial value:

= {
    {"::1", IPAddressV6::Type::NORMAL},
    {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL},
    {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO},
    {"2002:c000:022a::", IPAddressV6::Type::T6TO4},
}

Definition at line 853 of file IPAddressTest.cpp.

const vector<AddressData> validAddressProvider

static

Initial value:

= {
    AddressData("127.0.0.1", {127, 0, 0, 1}, 4),
    AddressData("69.63.189.16", {69, 63, 189, 16}, 4),
    AddressData("0.0.0.0", {0, 0, 0, 0}, 4),
    AddressData("::1", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, 6),
    AddressData(
        "2620:0:1cfe:face:b00c::3",
        {38, 32, 0, 0, 28, 254, 250, 206, 176, 12, 0, 0, 0, 0, 0, 3},
        6),
}

Definition at line 1350 of file IPAddressTest.cpp.