Migrate net/proxy/* 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/strings/string_number_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 220 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 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",

[eroman, 2016/03/18 23:52:16]

I wonder if we currently allow :

192.168.1.1/+1

I suspect StringToInt() allows a leading plus sign, in which case we are more
permissive than we should be!

If it does fail (as it should) then would be a good idea to add that to the list
too.

[martijnc, 2016/03/19 12:06:07]

ParseCIDRBlock (incorrectly) parses this as valid. I'll leave this as a refactor
but filled [1] to fix this.

[1] https://crbug.com/596258

+                                      "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) {

[eroman, 2016/03/18 23:52:17]

If you like can change this to:

for (const auto& bad_literal : bad_literals) {
   ...
}

(I believe that works)

[martijnc, 2016/03/19 12:06:07]

Done.

+    IPAddress ip_address;
+    size_t prefix_length_in_bits;
+
+    EXPECT_FALSE(
+        ParseCIDRBlock(bad_literals[i], &ip_address, &prefix_length_in_bits));
+  }
+}
+
+// Test parsing a valid CIDR notation literal.
+TEST(IPAddressTest, ParseCIDRBlock_Valid) {
+  IPAddress ip_address;
+  size_t prefix_length_in_bits;
+
+  EXPECT_TRUE(
+      ParseCIDRBlock("192.168.0.1/11", &ip_address, &prefix_length_in_bits));
+
+  EXPECT_EQ("192,168,0,1", DumpIPAddress(ip_address));
+  EXPECT_EQ(11u, prefix_length_in_bits);
+
+  EXPECT_TRUE(ParseCIDRBlock("::ffff:192.168.0.1/112", &ip_address,
+                             &prefix_length_in_bits));
+
+  EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
+            DumpIPAddress(ip_address));
+  EXPECT_EQ(112u, prefix_length_in_bits);
+}
+
 TEST(IPAddressTest, IPAddressStartsWith) {
   IPAddress ipv4_address(192, 168, 10, 5);
 
   uint8_t ipv4_prefix1[] = {192, 168, 10};
   EXPECT_TRUE(IPAddressStartsWith(ipv4_address, ipv4_prefix1));
 
   uint8_t ipv4_prefix3[] = {192, 168, 10, 5};
   EXPECT_TRUE(IPAddressStartsWith(ipv4_address, ipv4_prefix3));
 
   uint8_t ipv4_prefix2[] = {192, 168, 10, 10};
@@ skipping 23 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