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..d977b2298290f4bf9ca41a3ad86c97c6152bdcdb
--- /dev/null
+++ b/net/base/ip_address_unittest.cc
@@ -0,0 +1,134 @@
+// 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/strings/string_number_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+// Helper to stringize an IP number (used to define expectations).
+std::string DumpIPAddress(const IPAddress& v) {
+  std::string out;
+  for (size_t i = 0; i < v.bytes().size(); ++i) {
+    if (i != 0)
+      out.append(",");
+    out.append(base::UintToString(v.bytes()[i]));
+  }
+  return out;
+}
+
+template <size_t N>
+IPAddress ArrayToIPAdress(const uint8_t(&address)[N]) {
+  return IPAddress(address, N);
+}
+
+TEST(IPAddressTest, IsIPVersion) {
+  uint8_t addr1[4] = {192, 168, 0, 1};
+  IPAddress ip_address1 = ArrayToIPAdress(addr1);
+  EXPECT_TRUE(ip_address1.IsIPv4());
+  EXPECT_FALSE(ip_address1.IsIPv6());
+
+  uint8_t addr2[16] = {0xFE, 0xDC, 0xBA, 0x98};
+  IPAddress ip_address2 = ArrayToIPAdress(addr2);
+  EXPECT_TRUE(ip_address2.IsIPv6());
+  EXPECT_FALSE(ip_address2.IsIPv4());
+
+  IPAddress ip_address3 = IPAddress();
+  EXPECT_FALSE(ip_address3.IsIPv6());
+  EXPECT_FALSE(ip_address3.IsIPv4());
+}
+
+TEST(IPAddressTest, ToString) {
+  uint8_t addr1[4] = {0, 0, 0, 0};
+  IPAddress ip_address1 = ArrayToIPAdress(addr1);
+  EXPECT_EQ("0.0.0.0", ip_address1.ToString());
+
+  uint8_t addr2[4] = {192, 168, 0, 1};
+  IPAddress ip_address2 = ArrayToIPAdress(addr2);
+  EXPECT_EQ("192.168.0.1", ip_address2.ToString());
+
+  uint8_t addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
+  IPAddress ip_address3 = ArrayToIPAdress(addr3);
+  EXPECT_EQ("fedc:ba98::", ip_address3.ToString());
+}
+
+// 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", 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", 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, 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);
+}
+
+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);
+}
+
+}  // anonymous namespace
+
+}  // namespace net