Avoid heap allocations in 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) {
     if (i != 0)
       out.append(",");
     out.append(base::UintToString(v.bytes()[i]));
   }
   return out;
 }
 
+TEST(IPAddressBytesTest, ConstructEmpty) {
+  IPAddressBytes bytes;
+  ASSERT_EQ(0u, bytes.size());
+}
+
+TEST(IPAddressBytesTest, ConstructIPv4) {
+  uint8_t data[] = {192, 168, 1, 1};
+  IPAddressBytes bytes(data, arraysize(data));
+  ASSERT_EQ(arraysize(data), bytes.size());
+  size_t i = 0;
+  for (uint8_t byte : bytes)
+    EXPECT_EQ(data[i++], byte);
+  ASSERT_EQ(arraysize(data), i);
+}
+
+TEST(IPAddressBytesTest, ConstructIPv6) {
+  uint8_t data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+  IPAddressBytes bytes(data, arraysize(data));
+  ASSERT_EQ(arraysize(data), bytes.size());
+  size_t i = 0;
+  for (uint8_t byte : bytes)
+    EXPECT_EQ(data[i++], byte);
+  ASSERT_EQ(arraysize(data), i);
+}
+
+TEST(IPAddressBytesTest, Assign) {
+  uint8_t data[] = {192, 168, 1, 1};
+  IPAddressBytes copy;
+  copy.Assign(data, arraysize(data));
+  EXPECT_EQ(IPAddressBytes(data, arraysize(data)), copy);
+}
+
 TEST(IPAddressTest, ConstructIPv4) {
   EXPECT_EQ("127.0.0.1", IPAddress::IPv4Localhost().ToString());
 
   IPAddress ipv4_ctor(192, 168, 1, 1);
   EXPECT_EQ("192.168.1.1", ipv4_ctor.ToString());
 }
 
-TEST(IPAddressTest, ConstructIPv6) {
-  EXPECT_EQ("::1", IPAddress::IPv6Localhost().ToString());
-
-  IPAddress ipv6_ctor(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  EXPECT_EQ("102:304:506:708:90a:b0c:d0e:f10", ipv6_ctor.ToString());
-}
-
 TEST(IPAddressTest, IsIPVersion) {
   uint8_t addr1[4] = {192, 168, 0, 1};
   IPAddress ip_address1(addr1);
   EXPECT_TRUE(ip_address1.IsIPv4());
   EXPECT_FALSE(ip_address1.IsIPv6());
 
   uint8_t addr2[16] = {0xFE, 0xDC, 0xBA, 0x98};
   IPAddress ip_address2(addr2);
   EXPECT_TRUE(ip_address2.IsIPv6());
   EXPECT_FALSE(ip_address2.IsIPv4());
@@ skipping 130 matching lines @@
                // Unreserved block(s)
                {"203.0.114.0", NOT_RESERVED},
                {"223.255.255.255", NOT_RESERVED},
                // 224.0.0.0/8 - 255.0.0.0/8
                {"224.0.0.0", RESERVED},
                {"255.255.255.255", RESERVED}};
 
   IPAddress address;
   for (const auto& test : tests) {
     EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
+    ASSERT_TRUE(address.IsValid());
     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, IsReservedIPv6) {
   struct {
@@ skipping 210 matching lines @@
   IPAddress ip_address2;
   EXPECT_TRUE(ip_address2.AssignFromIPLiteral("2001:db8:0::42"));
   EXPECT_TRUE(ip_address1 < ip_address2);
   EXPECT_FALSE(ip_address2 < ip_address1);
 
   // Compare equivalent addresses.
   IPAddress ip_address3;
   EXPECT_TRUE(ip_address3.AssignFromIPLiteral("127.0.0.1"));
   EXPECT_FALSE(ip_address1 < ip_address3);
   EXPECT_FALSE(ip_address3 < ip_address1);
+
+  IPAddress ip_address4;
+  EXPECT_TRUE(ip_address4.AssignFromIPLiteral("128.0.0.0"));
+  EXPECT_TRUE(ip_address1 < ip_address4);
+  EXPECT_FALSE(ip_address4 < ip_address1);
 }
 
 // Test mapping an IPv4 address to an IPv6 address.
 TEST(IPAddressTest, ConvertIPv4ToIPv4MappedIPv6) {
   IPAddress ipv4_address(192, 168, 0, 1);
   IPAddress ipv6_address = ConvertIPv4ToIPv4MappedIPv6(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",
             DumpIPAddress(ipv6_address));
@@ skipping 160 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