Update IPAddress::IsReserved() ranges.

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"
@@ skipping 59 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) {
+// Tests for the reserved IPv4 ranges and the (unreserved) blocks in between.
+// The reserved ranges are tested by checking the first and last address of each
+// range. The unreserved blocks are tested similarly. These tests cover the
+// entire IPv4 address range.
+TEST(IPAddressTest, IsReserved_IPv4) {
   struct {
     const char* const address;
     bool is_reserved;

[eroman, 2016/04/18 18:13:15]

Consider making this an enum, for better readability of the test data. Could
then write things like:


{"10.255.255.255", RESERVED},

[martijnc, 2016/04/18 21:39:54]

Done.

-  } tests[] = {{"10.10.10.10", true},
-               {"9.9.255.255", false},
-               {"127.0.0.1", true},
-               {"128.0.0.1", false},
+  } tests[] = {// 0.0.0.0/8
+               {"0.0.0.0", true},
+               {"0.255.255.255", true},
+               // Unreserved block(s)
+               {"1.0.0.0", false},
+               {"9.255.255.255", false},
+               // 10.0.0.0/8
+               {"10.0.0.0", true},
+               {"10.255.255.255", true},
+               // Unreserved block(s)
+               {"11.0.0.0", false},
+               {"100.63.255.255", false},
+               // 100.64.0.0/10
+               {"100.64.0.0", true},
+               {"100.127.255.255", true},
+               // Unreserved block(s)
+               {"100.128.0.0", false},
+               {"126.255.255.255", false},
+               // 127.0.0.0/8
+               {"127.0.0.0", true},
+               {"127.255.255.255", true},
+               // Unreserved block(s)
+               {"128.0.0.0", false},
+               {"169.253.255.255", false},
+               // 169.254.0.0/16
+               {"169.254.0.0", true},
+               {"169.254.255.255", true},
+               // Unreserved block(s)
+               {"169.255.0.0", false},
+               {"172.15.255.255", false},
+               // 172.16.0.0/12
+               {"172.16.0.0", true},
+               {"172.31.255.255", true},
+               // Unreserved block(s)
+               {"172.32.0.0", false},
+               {"191.255.255.255", false},
+               // 192.0.0.0/24 (including sub ranges)
+               {"192.0.0.0", false},
+               {"192.0.0.255", false},
+               // Unreserved block(s)
+               {"192.0.1.0", false},
+               {"192.0.1.255", false},
+               // 192.0.2.0/24
+               {"192.0.2.0", true},
+               {"192.0.2.255", true},
+               // Unreserved block(s)
+               {"192.0.3.0", false},
+               {"192.31.195.255", false},
+               // 192.31.196.0/24
+               {"192.31.196.0", false},
+               {"192.31.196.255", false},
+               // Unreserved block(s)
+               {"192.32.197.0", false},
+               {"192.52.192.255", false},
+               // 192.52.193.0/24
+               {"192.52.193.0", false},
+               {"192.52.193.255", false},
+               // Unreserved block(s)
+               {"192.52.194.0", false},
+               {"192.88.98.255", false},
+               // 192.88.99.0/24
+               {"192.88.99.0", true},
+               {"192.88.99.255", true},
+               // Unreserved block(s)
+               {"192.88.100.0", false},
+               {"192.167.255.255", false},
+               // 192.168.0.0/16
+               {"192.168.0.0", true},
+               {"192.168.255.255", true},
+               // Unreserved block(s)
+               {"192.169.0.0", false},
+               {"192.175.47.255", false},
+               // 192.175.48.0/24
+               {"192.175.48.0", false},
+               {"192.175.48.255", false},
+               // Unreserved block(s)
+               {"192.175.49.0", false},
+               {"198.17.255.255", false},
+               // 198.18.0.0/15
                {"198.18.0.0", true},
-               {"198.18.255.255", true},
-               {"198.17.255.255", false},
                {"198.19.255.255", true},
+               // Unreserved block(s)
                {"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}};
+               {"198.51.99.255", false},
+               // 198.51.100.0/24
+               {"198.51.100.0", true},
+               {"198.51.100.255", true},
+               // Unreserved block(s)
+               {"198.51.101.0", false},
+               {"203.0.112.255", false},
+               // 203.0.113.0/24
+               {"203.0.113.0", true},
+               {"203.0.113.255", true},
+               // Unreserved block(s)
+               {"203.0.114.0", false},
+               {"223.255.255.255", false},
+               // 224.0.0.0/8 - 255.0.0.0/8
+               {"224.0.0.0", true},
+               {"255.255.255.255", true}};

[eroman, 2016/04/18 18:13:15]

Thanks for adding all these tests!

 
   IPAddress address;
   for (const auto& test : tests) {
+    EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
+    EXPECT_EQ(test.is_reserved, address.IsReserved());
+  }
+}
+
+// Tests for the reserved IPv6 ranges and the (unreserved) blocks in between.
+// The reserved ranges are tested by checking the first and last address of each
+// range. The unreserved blocks are tested similarly. These tests cover the
+// entire IPv6 address range.
+TEST(IPAddressTest, IsReserved_IPv6) {
+  struct {
+    const char* const address;
+    bool is_reserved;
+  } tests[] = {// 0000::/8
+               {"0:0:0:0:0:0:0:0", true},
+               {"ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // 0100::/8
+               {"100:0:0:0:0:0:0:0", true},
+               {"1ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // 0200::/7
+               {"200:0:0:0:0:0:0:0", true},
+               {"3ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // 0400::/6
+               {"400:0:0:0:0:0:0:0", true},
+               {"7ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // 0800::/5
+               {"800:0:0:0:0:0:0:0", true},
+               {"fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // 1000::/4
+               {"1000:0:0:0:0:0:0:0", true},
+               {"1fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // 2000::/3 (Global Unicast)
+               {"2000:0:0:0:0:0:0:0", false},
+               {"3fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", false},
+               // 4000::/3
+               {"4000:0:0:0:0:0:0:0", true},
+               {"5fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // 6000::/3
+               {"6000:0:0:0:0:0:0:0", true},
+               {"7fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // 8000::/3
+               {"8000:0:0:0:0:0:0:0", true},
+               {"9fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // c000::/3
+               {"c000:0:0:0:0:0:0:0", true},
+               {"dfff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // e000::/4
+               {"e000:0:0:0:0:0:0:0", true},
+               {"efff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // f000::/5
+               {"f000:0:0:0:0:0:0:0", true},
+               {"f7ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // f800::/6
+               {"f800:0:0:0:0:0:0:0", true},
+               {"fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // fc00::/7
+               {"fc00:0:0:0:0:0:0:0", true},
+               {"fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // fe00::/9
+               {"fe00:0:0:0:0:0:0:0", true},
+               {"fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // fe80::/10
+               {"fe80:0:0:0:0:0:0:0", true},
+               {"febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // fec0::/10
+               {"fec0:0:0:0:0:0:0:0", true},
+               {"feff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+               // ff00::/8 (Multicast)
+               {"ff00:0:0:0:0:0:0:0", false},
+               {"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", false}};
+
+  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());
 
@@ skipping 318 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