Introduce PPB_NetAddress_Dev.

ppapi/tests/test_net_address.cc

Index: ppapi/tests/test_net_address.cc
diff --git a/ppapi/tests/test_net_address.cc b/ppapi/tests/test_net_address.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e85e2315bcc668c2de8e635dddc995cf070289bf
--- /dev/null
+++ b/ppapi/tests/test_net_address.cc
@@ -0,0 +1,174 @@
+// Copyright (c) 2013 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 "ppapi/tests/test_net_address.h"
+
+#include <cstring>
+
+#include "ppapi/cpp/dev/net_address_dev.h"
+#include "ppapi/tests/test_utils.h"
+#include "ppapi/tests/testing_instance.h"
+
+using pp::NetAddress_Dev;
+
+REGISTER_TEST_CASE(NetAddress);
+
+namespace {
+
+bool EqualIPv4Address(const PP_NetAddress_IPv4_Dev& addr1,
+                      const PP_NetAddress_IPv4_Dev& addr2) {
+  return addr1.port == addr2.port &&
+         !memcmp(addr1.addr, addr2.addr, sizeof(addr1.addr));
+}
+
+bool EqualIPv6Address(const PP_NetAddress_IPv6_Dev& addr1,
+                      const PP_NetAddress_IPv6_Dev& addr2) {
+  return addr1.port == addr2.port &&
+         !memcmp(addr1.addr, addr2.addr, sizeof(addr1.addr));
+}
+
+NetAddress_Dev CreateFromHostOrderIPv6Address(
+    const pp::InstanceHandle& instance,
+    const uint16_t host_order_addr[8],
+    uint16_t host_order_port) {
+  PP_NetAddress_IPv6_Dev ipv6_addr;
+  ipv6_addr.port = ConvertToNetEndian16(host_order_port);
+  for (size_t i = 0; i < 8; ++i) {
+    uint16_t net_order_addr = ConvertToNetEndian16(host_order_addr[i]);
+    memcpy(&ipv6_addr.addr[2 * i], &net_order_addr, 2);
+  }
+
+  return NetAddress_Dev(instance, ipv6_addr);
+}
+
+}  // namespace
+
+TestNetAddress::TestNetAddress(TestingInstance* instance) : TestCase(instance) {
+}
+
+bool TestNetAddress::Init() {
+  return NetAddress_Dev::IsAvailable();

[bbudge, 2013/06/06 19:01:10]

Nice! We should probably start adding these IsAvailable methods to other
wrappers.

+}
+
+void TestNetAddress::RunTests(const std::string& filter) {
+  RUN_TEST(IPv4Address, filter);
+  RUN_TEST(IPv6Address, filter);
+  RUN_TEST(DescribeAsString, filter);
+}
+
+std::string TestNetAddress::TestIPv4Address() {
+  PP_NetAddress_IPv4_Dev ipv4_addr = { ConvertToNetEndian16(80), 0,
+                                       { 127, 0, 0, 1 } };
+  NetAddress_Dev net_addr(instance_, ipv4_addr);
+  ASSERT_NE(0, net_addr.pp_resource());
+
+  ASSERT_EQ(PP_NETADDRESS_FAMILY_IPV4, net_addr.GetFamily());
+
+  PP_NetAddress_IPv4_Dev out_ipv4_addr;
+  ASSERT_TRUE(net_addr.DescribeAsIPv4Address(&out_ipv4_addr));
+  ASSERT_TRUE(EqualIPv4Address(ipv4_addr, out_ipv4_addr));
+
+  PP_NetAddress_IPv6_Dev out_ipv6_addr;
+  ASSERT_FALSE(net_addr.DescribeAsIPv6Address(&out_ipv6_addr));
+
+  PASS();
+}
+
+std::string TestNetAddress::TestIPv6Address() {
+  PP_NetAddress_IPv6_Dev ipv6_addr = {
+    ConvertToNetEndian16(1024), 0,
+    { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }
+  };
+
+  NetAddress_Dev net_addr(instance_, ipv6_addr);
+  ASSERT_NE(0, net_addr.pp_resource());
+
+  ASSERT_EQ(PP_NETADDRESS_FAMILY_IPV6, net_addr.GetFamily());
+
+  PP_NetAddress_IPv6_Dev out_ipv6_addr;
+  ASSERT_TRUE(net_addr.DescribeAsIPv6Address(&out_ipv6_addr));
+  ASSERT_TRUE(EqualIPv6Address(ipv6_addr, out_ipv6_addr));
+
+  PP_NetAddress_IPv4_Dev out_ipv4_addr;
+  ASSERT_FALSE(net_addr.DescribeAsIPv4Address(&out_ipv4_addr));
+
+  PASS();
+}
+
+std::string TestNetAddress::TestDescribeAsString() {
+  {
+    // Test describing IPv4 addresses.
+    PP_NetAddress_IPv4_Dev ipv4_addr1 = { ConvertToNetEndian16(1234), 0,
+                                          { 127, 0, 0, 1 } };
+    NetAddress_Dev addr1(instance_, ipv4_addr1);
+    ASSERT_EQ("127.0.0.1", addr1.DescribeAsString(PP_FALSE).AsString());
+    ASSERT_EQ("127.0.0.1:1234", addr1.DescribeAsString(PP_TRUE).AsString());
+
+    PP_NetAddress_IPv4_Dev ipv4_addr2 = { ConvertToNetEndian16(80), 0,
+                                          { 192, 168, 0, 2 } };
+    NetAddress_Dev addr2(instance_, ipv4_addr2);
+    ASSERT_EQ("192.168.0.2", addr2.DescribeAsString(PP_FALSE).AsString());
+    ASSERT_EQ("192.168.0.2:80", addr2.DescribeAsString(PP_TRUE).AsString());
+  }
+  {
+    // Test describing IPv6 addresses.
+    static const struct {
+      uint16_t host_order_addr[8];
+      uint16_t host_order_port;
+      const char* expected_without_port;
+      const char* expected_with_port;
+    } ipv6_test_cases[] = {
+      {  // Generic test case (unique longest run of zeros to collapse).
+        { 0x12, 0xabcd, 0, 0x0001, 0, 0, 0, 0xcdef }, 12,
+        "12:abcd:0:1::cdef", "[12:abcd:0:1::cdef]:12"
+      },
+      {  // Ignore the first (non-longest) run of zeros.
+        { 0, 0, 0, 0x0123, 0, 0, 0, 0 }, 123,
+        "0:0:0:123::", "[0:0:0:123::]:123"
+      },
+      {  // Collapse the first (equally-longest) run of zeros.
+        { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef }, 123,
+        "1234:abcd::ff:0:0:cdef", "[1234:abcd::ff:0:0:cdef]:123"
+      },
+      {  // Don't collapse "runs" of zeros of length 1.
+        { 0, 0xa, 1, 2, 3, 0, 5, 0 }, 123,
+        "0:a:1:2:3:0:5:0", "[0:a:1:2:3:0:5:0]:123"
+      },
+      {  // Collapse a run of zeros at the beginning.
+        { 0, 0, 0, 2, 3, 0, 0, 0 }, 123,
+        "::2:3:0:0:0", "[::2:3:0:0:0]:123"
+      },
+      {  // Collapse a run of zeros at the end.
+        { 0, 0xa, 1, 2, 3, 0, 0, 0 }, 123,
+        "0:a:1:2:3::", "[0:a:1:2:3::]:123"
+      },
+      {  // IPv4 192.168.1.2 embedded in IPv6 in the deprecated way.
+        { 0, 0, 0, 0, 0, 0, 0xc0a8, 0x102 }, 123,
+        "::192.168.1.2", "[::192.168.1.2]:123"
+      },
+      {  // IPv4 192.168.1.2 embedded in IPv6.
+        { 0, 0, 0, 0, 0, 0xffff, 0xc0a8, 0x102 }, 123,
+        "::ffff:192.168.1.2", "[::ffff:192.168.1.2]:123"
+      },
+      {  // *Not* IPv4 embedded in IPv6.
+        { 0, 0, 0, 0, 0, 0x1234, 0xc0a8, 0x102 }, 123,
+        "::1234:c0a8:102", "[::1234:c0a8:102]:123"
+      }
+    };
+
+    for (size_t i = 0;
+         i < sizeof(ipv6_test_cases) / sizeof(ipv6_test_cases[0]);
+         ++i) {
+      NetAddress_Dev addr = CreateFromHostOrderIPv6Address(
+          instance_, ipv6_test_cases[i].host_order_addr,
+          ipv6_test_cases[i].host_order_port);
+      ASSERT_EQ(ipv6_test_cases[i].expected_without_port,
+                addr.DescribeAsString(PP_FALSE).AsString());
+      ASSERT_EQ(ipv6_test_cases[i].expected_with_port,
+                addr.DescribeAsString(PP_TRUE).AsString());
+    }
+  }
+
+  PASS();
+}