Add IPAddress class as a replacement for the IPAddressNumber typedef.

net/base/ip_address_unittest.cc

Index: net/base/ip_address_unittest.cc
diff --git a/net/base/ip_address_unittest.cc b/net/base/ip_address_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..be6df5ef103560f72f0942961e1bb000126338d1
--- /dev/null
+++ b/net/base/ip_address_unittest.cc
@@ -0,0 +1,296 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/base/ip_address.h"
+
+#include <vector>
+
+#include "base/format_macros.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "net/base/net_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+class IPAddressTest : public testing::Test {
+ public:
+  // Helper to strignize an IP number (used to define expectations).
+  static std::string DumpIPAddress(const IPAddress& v) {
+    std::string out;
+    for (size_t i = 0; i < v.ip_address_.size(); ++i) {
+      if (i != 0)
+        out.append(",");
+      out.append(base::IntToString(static_cast<int>(v.ip_address_[i])));
+    }
+    return out;
+  }
+
+  static IPAddress ArrayToIPAdress(uint8_t address[], size_t length) {
+    std::vector<unsigned char> vec(address, address + length);
+    IPAddress ip_address(vec);
+    return ip_address;
+  }
+};
+
+namespace {
+
+TEST(IPAddressTest, IPAddressToString) {
+  uint8_t addr1[4] = {0, 0, 0, 0};
+  IPAddress ip_address1 = IPAddressTest::ArrayToIPAdress(addr1, sizeof(addr1));
+  EXPECT_EQ("0.0.0.0", ip_address1.ToString());
+
+  uint8_t addr2[4] = {192, 168, 0, 1};
+  IPAddress ip_address2 = IPAddressTest::ArrayToIPAdress(addr2, sizeof(addr2));
+  EXPECT_EQ("192.168.0.1", ip_address2.ToString());
+
+  uint8_t addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
+  IPAddress ip_address3 = IPAddressTest::ArrayToIPAdress(addr3, sizeof(addr3));
+  EXPECT_EQ("fedc:ba98::", ip_address3.ToString());
+}
+
+TEST(IPAddressTest, IPAddressToStringWithPort) {
+  uint8_t addr1[4] = {0, 0, 0, 0};
+  IPAddress ip_address1 = IPAddressTest::ArrayToIPAdress(addr1, sizeof(addr1));
+  EXPECT_EQ("0.0.0.0:3", ip_address1.ToStringWithPort(3));
+
+  uint8_t addr2[4] = {192, 168, 0, 1};
+  IPAddress ip_address2 = IPAddressTest::ArrayToIPAdress(addr2, sizeof(addr2));
+  EXPECT_EQ("192.168.0.1:99", ip_address2.ToStringWithPort(99));
+
+  uint8_t addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
+  IPAddress ip_address3 = IPAddressTest::ArrayToIPAdress(addr3, sizeof(addr3));
+  EXPECT_EQ("[fedc:ba98::]:8080", ip_address3.ToStringWithPort(8080));
+}
+
+// Test that invalid IP literals fail to parse.
+TEST(IPAddressTest, FromIPLiteral_FailParse) {
+  IPAddress address;
+
+  EXPECT_FALSE(IPAddress::FromIPLiteral("bad value", &address));
+  EXPECT_FALSE(IPAddress::FromIPLiteral("bad:value", &address));
+  EXPECT_FALSE(IPAddress::FromIPLiteral(std::string(), &address));
+  EXPECT_FALSE(IPAddress::FromIPLiteral("192.168.0.1:30", &address));
+  EXPECT_FALSE(IPAddress::FromIPLiteral("  192.168.0.1  ", &address));
+  EXPECT_FALSE(IPAddress::FromIPLiteral("[::1]", &address));
+}
+
+// Test parsing an IPv4 literal.
+TEST(IPAddressTest, FromIPLiteral_IPv4) {
+  IPAddress address;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("192.168.0.1", &address));
+  EXPECT_EQ("192,168,0,1", IPAddressTest::DumpIPAddress(address));
+  EXPECT_EQ("192.168.0.1", address.ToString());
+}
+
+// Test parsing an IPv6 literal.
+TEST(IPAddressTest, FromIPLiteral_IPv6) {
+  IPAddress address;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("1:abcd::3:4:ff", &address));
+  EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255",
+            IPAddressTest::DumpIPAddress(address));
+  EXPECT_EQ("1:abcd::3:4:ff", address.ToString());
+}
+
+// Test mapping an IPv4 address to an IPv6 address.
+TEST(IPAddressTest, ConvertIPv4ToIPv6) {
+  IPAddress ipv4_address;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("192.168.0.1", &ipv4_address));
+
+  IPAddress ipv6_address = IPAddress::ConvertIPv4ToIPv6(ipv4_address);
+
+  // ::ffff:192.168.0.1
+  EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
+            IPAddressTest::DumpIPAddress(ipv6_address));
+  EXPECT_EQ("::ffff:c0a8:1", ipv6_address.ToString());
+}
+
+TEST(IPAddressTest, FromURLHostname_FailParse) {
+  IPAddress address;
+
+  EXPECT_FALSE(IPAddress::FromURLHostname("bad value", &address));
+  EXPECT_FALSE(IPAddress::FromURLHostname("bad:value", &address));
+  EXPECT_FALSE(IPAddress::FromURLHostname(std::string(), &address));
+  EXPECT_FALSE(IPAddress::FromURLHostname("192.168.0.1:30", &address));
+  EXPECT_FALSE(IPAddress::FromURLHostname("  192.168.0.1  ", &address));
+  EXPECT_FALSE(IPAddress::FromURLHostname("::1", &address));
+}
+
+TEST(IPAddressTest, FromURLHostname_IPv4) {
+  IPAddress address;
+  EXPECT_TRUE(IPAddress::FromURLHostname("192.168.0.1", &address));
+  EXPECT_EQ("192,168,0,1", IPAddressTest::DumpIPAddress(address));
+  EXPECT_EQ("192.168.0.1", address.ToString());
+}
+
+TEST(IPAddressTest, FromURLHostname_IPv6) {
+  IPAddress address;
+  EXPECT_TRUE(IPAddress::FromURLHostname("[1:abcd::3:4:ff]", &address));
+  EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255",
+            IPAddressTest::DumpIPAddress(address));
+  EXPECT_EQ("1:abcd::3:4:ff", address.ToString());
+}
+
+TEST(IPAddressTest, IsIPv4Mapped) {
+  IPAddress ipv4_address;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("192.168.0.1", &ipv4_address));
+  EXPECT_FALSE(ipv4_address.IsIPv4Mapped());
+
+  IPAddress ipv6_address;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("::1", &ipv4_address));
+  EXPECT_FALSE(ipv6_address.IsIPv4Mapped());
+
+  IPAddress ipv4mapped_address;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("::ffff:0101:1", &ipv4mapped_address));
+  EXPECT_TRUE(ipv4mapped_address.IsIPv4Mapped());
+}
+
+TEST(IPAddressTest, ConvertIPv4MappedToIPv4) {
+  IPAddress ipv4mapped_address;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("::ffff:0101:1", &ipv4mapped_address));
+  IPAddress expected;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("1.1.0.1", &expected));
+  IPAddress result = IPAddress::ConvertIPv4MappedToIPv4(ipv4mapped_address);
+  EXPECT_EQ(expected.ToString(), result.ToString());
+}
+
+// Test parsing invalid CIDR notation literals.
+TEST(IPAddressTest, FromCIDRBlock_Invalid) {
+  const char* const bad_literals[] = {"foobar",
+                                      "",
+                                      "192.168.0.1",
+                                      "::1",
+                                      "/",
+                                      "/1",
+                                      "1",
+                                      "192.168.1.1/-1",
+                                      "192.168.1.1/33",
+                                      "::1/-3",
+                                      "a::3/129",
+                                      "::1/x",
+                                      "192.168.0.1//11"};
+
+  for (size_t i = 0; i < arraysize(bad_literals); ++i) {
+    IPAddress ip_address;
+    size_t prefix_length_in_bits;
+
+    EXPECT_FALSE(IPAddress::FromCIDRBlock(bad_literals[i], &ip_address,
+                                          &prefix_length_in_bits));
+  }
+}
+
+// Test parsing a valid CIDR notation literal.
+TEST(IPAddressTest, FromCIDRBlock_Valid) {
+  IPAddress ip_address;
+  size_t prefix_length_in_bits;
+
+  EXPECT_TRUE(IPAddress::FromCIDRBlock("192.168.0.1/11", &ip_address,
+                                       &prefix_length_in_bits));
+
+  EXPECT_EQ("192,168,0,1", IPAddressTest::DumpIPAddress(ip_address));
+  EXPECT_EQ(11u, prefix_length_in_bits);
+}
+
+TEST(IPAddressTest, MatchesPrefix) {
+  struct {
+    const char* const cidr_literal;
+    const char* const ip_literal;
+    bool expected_to_match;
+  } tests[] = {
+      // IPv4 prefix with IPv4 inputs.
+      {"10.10.1.32/27", "10.10.1.44", true},
+      {"10.10.1.32/27", "10.10.1.90", false},
+      {"10.10.1.32/27", "10.10.1.90", false},
+
+      // IPv6 prefix with IPv6 inputs.
+      {"2001:db8::/32", "2001:DB8:3:4::5", true},
+      {"2001:db8::/32", "2001:c8::", false},
+
+      // IPv6 prefix with IPv4 inputs.
+      {"2001:db8::/33", "192.168.0.1", false},
+      {"::ffff:192.168.0.1/112", "192.168.33.77", true},
+
+      // IPv4 prefix with IPv6 inputs.
+      {"10.11.33.44/16", "::ffff:0a0b:89", true},
+      {"10.11.33.44/16", "::ffff:10.12.33.44", false},
+  };
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s, %s", i,
+                                    tests[i].cidr_literal,
+                                    tests[i].ip_literal));
+
+    IPAddress ip_address;
+    EXPECT_TRUE(IPAddress::FromIPLiteral(tests[i].ip_literal, &ip_address));
+
+    IPAddress ip_prefix;
+    size_t prefix_length_in_bits;
+
+    EXPECT_TRUE(IPAddress::FromCIDRBlock(tests[i].cidr_literal, &ip_prefix,
+                                         &prefix_length_in_bits));
+
+    EXPECT_EQ(tests[i].expected_to_match,
+              ip_address.MatchesPrefix(ip_prefix, prefix_length_in_bits));
+  }
+}
+
+TEST(IPAddressTest, AddressFamily) {
+  IPAddress ipv4_address;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("1.1.0.1", &ipv4_address));
+  EXPECT_EQ(ADDRESS_FAMILY_IPV4, ipv4_address.GetAddressFamily());
+
+  IPAddress ipv6_address;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("::1", &ipv6_address));
+  EXPECT_EQ(ADDRESS_FAMILY_IPV6, ipv6_address.GetAddressFamily());
+}
+
+TEST(IPAddressTest, IsEqual) {
+  IPAddress ip_address1;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("127.0.0.1", &ip_address1));
+  IPAddress ip_address2;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("2001:db8:0::42", &ip_address2));
+  IPAddress ip_address3;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("127.0.0.1", &ip_address3));
+
+  EXPECT_FALSE(ip_address1 == ip_address2);
+  EXPECT_TRUE(ip_address1 == ip_address3);
+
+  EXPECT_TRUE(ip_address1 != ip_address2);
+  EXPECT_FALSE(ip_address1 != ip_address3);
+}
+
+TEST(IPAddressTest, LessThan) {
+  // IPv4 vs IPv6
+  IPAddress ip_address1;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("127.0.0.1", &ip_address1));
+  IPAddress ip_address2;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("2001:db8:0::42", &ip_address2));
+  EXPECT_TRUE(ip_address1 < ip_address2);
+  EXPECT_FALSE(ip_address2 < ip_address1);
+
+  // Compare equivalent addresses.
+  IPAddress ip_address3;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("127.0.0.1", &ip_address3));
+  EXPECT_FALSE(ip_address1 < ip_address3);
+  EXPECT_FALSE(ip_address3 < ip_address1);
+}
+
+TEST(IPAddressTest, MoreThan) {
+  // IPv4 vs IPv6
+  IPAddress ip_address1;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("127.0.0.1", &ip_address1));
+  IPAddress ip_address2;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("2001:db8:0::42", &ip_address2));
+  EXPECT_FALSE(ip_address1 > ip_address2);
+  EXPECT_TRUE(ip_address2 > ip_address1);
+
+  // Compare equivalent addresses.
+  IPAddress ip_address3;
+  EXPECT_TRUE(IPAddress::FromIPLiteral("127.0.0.1", &ip_address3));
+  EXPECT_FALSE(ip_address1 > ip_address3);
+  EXPECT_FALSE(ip_address3 > ip_address1);
+}
+
+}  // anonymous namespace
+
+}  // namespace net