Move some net::IPAddressNumber implementations to net::IPAddress.

net/base/ip_address_unittest.cc

 // 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 "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 // Helper to stringize an IP address (used to define expectations).
 std::string DumpIPAddress(const IPAddress& v) {
   std::string out;
   for (size_t i = 0; i < v.bytes().size(); ++i) {
@@ skipping 48 matching lines @@
   uint8_t addr3[5] = {0xFE, 0xDC, 0xBA, 0x98};
   IPAddress ip_address3(addr3);
   EXPECT_FALSE(ip_address3.IsValid());
   EXPECT_FALSE(ip_address3.empty());
 
   IPAddress ip_address4;
   EXPECT_FALSE(ip_address4.IsValid());
   EXPECT_TRUE(ip_address4.empty());
 }
 
+TEST(IPAddressTest, IsReserved) {

[martijnc, 2016/04/11 22:02:09]

Added these tests, the IPv6 addresses are from [1] which was (indirectly)
testing this code. But since the method is used in other places I though it
would be good to tests here as well.

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/net/base/url_util_...

[eroman, 2016/04/13 01:36:21]

Agreed, thanks!

I have some suggestions on the IPv6 data to test, but will save those comments
for the bugfix CL (basically we will want to test an address from each
allocations the IANA document lists).

+  struct {
+    const char* const address;
+    bool is_reserved;
+  } tests[] = {{"10.10.10.10", true},
+               {"9.9.255.255", false},
+               {"127.0.0.1", true},
+               {"128.0.0.1", false},
+               {"198.18.0.0", true},
+               {"198.18.255.255", true},
+               {"198.17.255.255", false},
+               {"198.19.255.255", true},
+               {"198.20.0.0", false},
+               {"0000::", true},
+               {"FFC0:ba98:7654:3210:FEDC:BA98:7654:3210", false},
+               {"2000:ba98:7654:2301:EFCD:BA98:7654:3210", false},
+               {"::192.9.5.5", true},
+               {"FEED::BEEF", true}};
+
+  IPAddress address;
+  for (const auto& test : tests) {
+    EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
+    EXPECT_EQ(test.is_reserved, address.IsReserved());
+  }
+}
+
 TEST(IPAddressTest, IsZero) {
   uint8_t address1[4] = {};
   IPAddress zero_ipv4_address(address1);
   EXPECT_TRUE(zero_ipv4_address.IsZero());
 
   uint8_t address2[4] = {10};
   IPAddress non_zero_ipv4_address(address2);
   EXPECT_FALSE(non_zero_ipv4_address.IsZero());
 
   uint8_t address3[16] = {};
@@ skipping 157 matching lines @@
   IPAddress ipv4mapped_address;
   EXPECT_TRUE(ipv4mapped_address.AssignFromIPLiteral("::ffff:c0a8:1"));
 
   IPAddress expected;
   EXPECT_TRUE(expected.AssignFromIPLiteral("192.168.0.1"));
 
   IPAddress result = ConvertIPv4MappedIPv6ToIPv4(ipv4mapped_address);
   EXPECT_EQ(expected, result);
 }
 
+TEST(IPAddressTest, IPAddressMatchesPrefix) {

[martijnc, 2016/04/11 22:02:09]

Tests from net/base/ip_address_number_unittest.cc.

+  struct {
+    const char* const cidr_literal;
+    size_t prefix_length_in_bits;
+    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(ip_address.AssignFromIPLiteral(tests[i].ip_literal));
+
+    IPAddress ip_prefix;
+    EXPECT_TRUE(ip_prefix.AssignFromIPLiteral(tests[i].cidr_literal));
+
+    EXPECT_EQ(tests[i].expected_to_match,
+              IPAddressMatchesPrefix(ip_address, ip_prefix,
+                                     tests[i].prefix_length_in_bits));
+  }
+}
+
 // Test parsing invalid CIDR notation literals.
 TEST(IPAddressTest, ParseCIDRBlock_Invalid) {
   const char* const bad_literals[] = {"foobar",
                                       "",
                                       "192.168.0.1",
                                       "::1",
                                       "/",
                                       "/1",
                                       "1",
                                       "192.168.1.1/-1",
@@ skipping 95 matching lines @@
 
   // Prefix is longer than the address.
   uint8_t ipv6_prefix5[] = {42, 0, 20, 80, 64, 12, 12, 9, 0,
                             0,  0, 0,  0,  0,  0,  0,  10};
   EXPECT_FALSE(IPAddressStartsWith(ipv6_address, ipv6_prefix5));
 }
 
 }  // anonymous namespace
 
 }  // namespace net