text: // Copyright (c) 2012 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_private.h"
  
  #include <stddef.h>
  #include <stdint.h>
  #include <string.h>
  
  #include "ppapi/c/private/ppb_net_address_private.h"
  #include "ppapi/cpp/private/net_address_private.h"
  #include "ppapi/tests/test_utils.h"
  #include "ppapi/tests/testing_instance.h"
  
  using pp::NetAddressPrivate;
  
  namespace {
  
  PP_NetAddress_Private MakeIPv4NetAddress(const uint8_t host[4], int port) {
    PP_NetAddress_Private addr;
    NetAddressPrivate::CreateFromIPv4Address(host, port, &addr);
    return addr;
  }
  
  PP_NetAddress_Private MakeIPv6NetAddress(const uint16_t host[8], uint16_t port,
                                           uint32_t scope_id) {
    PP_NetAddress_Private addr = PP_NetAddress_Private();
    uint8_t ip[16];
    for(int i = 0; i < 8; ++i) {
      ip[i * 2] = host[i] >> 8;
      ip[i * 2 + 1] = host[i] & 0xff;
    }
    NetAddressPrivate::CreateFromIPv6Address(ip, scope_id, port, &addr);
    return addr;
  }
  
  }  // namespace
  
  REGISTER_TEST_CASE(NetAddressPrivate);
  
  TestNetAddressPrivate::TestNetAddressPrivate(TestingInstance* instance)
      : TestCase(instance) {
  }
  
  bool TestNetAddressPrivate::Init() {
    return NetAddressPrivate::IsAvailable();
  }
  
  void TestNetAddressPrivate::RunTests(const std::string& filter) {
    RUN_TEST(AreEqual, filter);
    RUN_TEST(AreHostsEqual, filter);
    RUN_TEST(Describe, filter);
    RUN_TEST(ReplacePort, filter);
    RUN_TEST(GetAnyAddress, filter);
    RUN_TEST(DescribeIPv6, filter);
    RUN_TEST(GetFamily, filter);
    RUN_TEST(GetPort, filter);
    RUN_TEST(GetAddress, filter);
    RUN_TEST(GetScopeID, filter);
  }
  
  std::string TestNetAddressPrivate::TestAreEqual() {
    // No comparisons should ever be done with invalid addresses.
    PP_NetAddress_Private invalid = PP_NetAddress_Private();
    ASSERT_FALSE(NetAddressPrivate::AreEqual(invalid, invalid));
  
    uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
    PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
    ASSERT_TRUE(NetAddressPrivate::AreEqual(localhost_80, localhost_80));
    ASSERT_FALSE(NetAddressPrivate::AreEqual(localhost_80, invalid));
  
    PP_NetAddress_Private localhost_1234 = MakeIPv4NetAddress(localhost_ip, 1234);
    ASSERT_FALSE(NetAddressPrivate::AreEqual(localhost_80, localhost_1234));
  
    uint8_t other_ip[4] = { 192, 168, 0, 1 };
    PP_NetAddress_Private other_80 = MakeIPv4NetAddress(other_ip, 80);
    ASSERT_FALSE(NetAddressPrivate::AreEqual(localhost_80, other_80));
  
    PASS();
  }
  
  std::string TestNetAddressPrivate::TestAreHostsEqual() {
    // No comparisons should ever be done with invalid addresses.
    PP_NetAddress_Private invalid = PP_NetAddress_Private();
    ASSERT_FALSE(NetAddressPrivate::AreHostsEqual(invalid, invalid));
  
    uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
    PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
    ASSERT_TRUE(NetAddressPrivate::AreHostsEqual(localhost_80, localhost_80));
    ASSERT_FALSE(NetAddressPrivate::AreHostsEqual(localhost_80, invalid));
  
    PP_NetAddress_Private localhost_1234 = MakeIPv4NetAddress(localhost_ip, 1234);
    ASSERT_TRUE(NetAddressPrivate::AreHostsEqual(localhost_80, localhost_1234));
  
    uint8_t other_ip[4] = { 192, 168, 0, 1 };
    PP_NetAddress_Private other_80 = MakeIPv4NetAddress(other_ip, 80);
    ASSERT_FALSE(NetAddressPrivate::AreHostsEqual(localhost_80, other_80));
  
    PASS();
  }
  
  std::string TestNetAddressPrivate::TestDescribe() {
    PP_NetAddress_Private invalid = PP_NetAddress_Private();
    ASSERT_EQ("", NetAddressPrivate::Describe(invalid, false));
    ASSERT_EQ("", NetAddressPrivate::Describe(invalid, true));
  
    uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
    PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
    ASSERT_EQ("127.0.0.1", NetAddressPrivate::Describe(localhost_80, false));
    ASSERT_EQ("127.0.0.1:80", NetAddressPrivate::Describe(localhost_80, true));
  
    PP_NetAddress_Private localhost_1234 = MakeIPv4NetAddress(localhost_ip, 1234);
    ASSERT_EQ("127.0.0.1", NetAddressPrivate::Describe(localhost_1234, false));
    ASSERT_EQ("127.0.0.1:1234", NetAddressPrivate::Describe(localhost_1234,
                                                            true));
  
    uint8_t other_ip[4] = { 192, 168, 0, 1 };
    PP_NetAddress_Private other_80 = MakeIPv4NetAddress(other_ip, 80);
    ASSERT_EQ("192.168.0.1", NetAddressPrivate::Describe(other_80, false));
    ASSERT_EQ("192.168.0.1:80", NetAddressPrivate::Describe(other_80, true));
  
    PASS();
  }
  
  std::string TestNetAddressPrivate::TestReplacePort() {
    // Assume that |AreEqual()| works correctly.
    PP_NetAddress_Private result = PP_NetAddress_Private();
  
    PP_NetAddress_Private invalid = PP_NetAddress_Private();
    ASSERT_FALSE(NetAddressPrivate::ReplacePort(invalid, 1234, &result));
  
    uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
    PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
    ASSERT_TRUE(NetAddressPrivate::ReplacePort(localhost_80, 1234, &result));
    PP_NetAddress_Private localhost_1234 = MakeIPv4NetAddress(localhost_ip, 1234);
    ASSERT_TRUE(NetAddressPrivate::AreEqual(result, localhost_1234));
  
    // Test that having the out param being the same as the in param works
    // properly.
    ASSERT_TRUE(NetAddressPrivate::ReplacePort(result, 80, &result));
    ASSERT_TRUE(NetAddressPrivate::AreEqual(result, localhost_80));
  
    PASS();
  }
  
  std::string TestNetAddressPrivate::TestGetAnyAddress() {
    // Just make sure it doesn't crash and such.
    PP_NetAddress_Private result = PP_NetAddress_Private();
  
    NetAddressPrivate::GetAnyAddress(false, &result);
    ASSERT_TRUE(NetAddressPrivate::AreEqual(result, result));
  
    NetAddressPrivate::GetAnyAddress(true, &result);
    ASSERT_TRUE(NetAddressPrivate::AreEqual(result, result));
  
    PASS();
  }
  
  // TODO(viettrungluu): More IPv6 tests needed.
  
  std::string TestNetAddressPrivate::TestDescribeIPv6() {
    static const struct {
      uint16_t address[8];
      uint16_t port;
      uint32_t scope;
      const char* expected_without_port;
      const char* expected_with_port;
    } test_cases[] = {
      {  // Generic test case (unique longest run of zeros to collapse).
        { 0x12, 0xabcd, 0, 0x0001, 0, 0, 0, 0xcdef }, 12, 0,
        "12:abcd:0:1::cdef", "[12:abcd:0:1::cdef]:12"
      },
      {  // Non-zero scope.
        { 0x1234, 0xabcd, 0, 0x0001, 0, 0, 0, 0xcdef }, 1234, 789,
        "1234:abcd:0:1::cdef%789", "[1234:abcd:0:1::cdef%789]:1234"
      },
      {  // Ignore the first (non-longest) run of zeros.
        { 0, 0, 0, 0x0123, 0, 0, 0, 0 }, 123, 0,
        "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, 0,
        "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,
        "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, 0,
        "::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,
        "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, 0,
        "::192.168.1.2", "[::192.168.1.2]:123"
      },
      {  // ... with non-zero scope.
        { 0, 0, 0, 0, 0, 0, 0xc0a8, 0x102 }, 123, 789,
        "::192.168.1.2%789", "[::192.168.1.2%789]:123"
      },
      {  // IPv4 192.168.1.2 embedded in IPv6.
        { 0, 0, 0, 0, 0, 0xffff, 0xc0a8, 0x102 }, 123, 0,
        "::ffff:192.168.1.2", "[::ffff:192.168.1.2]:123"
      },
      {  // ... with non-zero scope.
        { 0, 0, 0, 0, 0, 0xffff, 0xc0a8, 0x102 }, 123, 789,
        "::ffff:192.168.1.2%789", "[::ffff:192.168.1.2%789]:123"
      },
      {  // *Not* IPv4 embedded in IPv6.
        { 0, 0, 0, 0, 0, 0x1234, 0xc0a8, 0x102 }, 123, 0,
        "::1234:c0a8:102", "[::1234:c0a8:102]:123"
      }
    };
  
    for (size_t i = 0; i < sizeof(test_cases)/sizeof(test_cases[0]); i++) {
      PP_NetAddress_Private addr = MakeIPv6NetAddress(test_cases[i].address,
                                                      test_cases[i].port,
                                                      test_cases[i].scope);
      ASSERT_EQ(test_cases[i].expected_without_port,
                NetAddressPrivate::Describe(addr, false));
      ASSERT_EQ(test_cases[i].expected_with_port,
                NetAddressPrivate::Describe(addr, true));
    }
  
    PASS();
  }
  
  std::string TestNetAddressPrivate::TestGetFamily() {
    uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
    PP_NetAddress_Private ipv4 = MakeIPv4NetAddress(localhost_ip, 80);
    ASSERT_EQ(NetAddressPrivate::GetFamily(ipv4),
              PP_NETADDRESSFAMILY_PRIVATE_IPV4);
  
    uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
    PP_NetAddress_Private ipv6 = MakeIPv6NetAddress(ipv6_address, 123, 0);
    ASSERT_EQ(NetAddressPrivate::GetFamily(ipv6),
              PP_NETADDRESSFAMILY_PRIVATE_IPV6);
  
    PASS();
  }
  
  std::string TestNetAddressPrivate::TestGetPort() {
    uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
    PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
    ASSERT_EQ(NetAddressPrivate::GetPort(localhost_80), 80);
  
    uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
  
    PP_NetAddress_Private port_123 = MakeIPv6NetAddress(ipv6_address, 123, 0);
    ASSERT_EQ(NetAddressPrivate::GetPort(port_123), 123);
  
    PP_NetAddress_Private port_FFFF = MakeIPv6NetAddress(ipv6_address,
                                                         0xFFFF,
                                                         0);
    ASSERT_EQ(NetAddressPrivate::GetPort(port_FFFF), 0xFFFF);
  
    PASS();
  }
  
  std::string TestNetAddressPrivate::TestGetAddress() {
    const int addr_storage_len = 16;
    unsigned char addr_storage[addr_storage_len];
  
    const uint8_t ipv4_addr[4] = { 127, 0, 0, 1 };
    PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(ipv4_addr, 80);
    memset(addr_storage, 0, addr_storage_len);
    ASSERT_TRUE(NetAddressPrivate::GetAddress(localhost_80,
                                              addr_storage,
                                              addr_storage_len));
    ASSERT_EQ(memcmp(addr_storage, &ipv4_addr, 4), 0);
  
    // Insufficient storage for address.
    ASSERT_FALSE(NetAddressPrivate::GetAddress(localhost_80,
                                               addr_storage,
                                               1));
  
    uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
    PP_NetAddress_Private ipv6_addr = MakeIPv6NetAddress(ipv6_address,
                                                         123,
                                                         0);
  
    // Ensure the ipv6 address is transformed properly into network order.
    uint8_t ipv6_bytes[16];
    for(int i = 0; i < 8; ++i) {
      ipv6_bytes[i * 2] = ipv6_address[i] >> 8;
      ipv6_bytes[i * 2 + 1] = ipv6_address[i] & 0xFF;
    }
  
    memset(addr_storage, 0, addr_storage_len);
    ASSERT_TRUE(NetAddressPrivate::GetAddress(ipv6_addr,
                                              addr_storage,
                                              addr_storage_len));
    ASSERT_EQ(memcmp(addr_storage, ipv6_bytes, 16), 0);
  
    // Insufficient storage for address.
    ASSERT_FALSE(NetAddressPrivate::GetAddress(ipv6_addr,
                                               addr_storage,
                                               1));
  
    PASS();
  }
  
  std::string TestNetAddressPrivate::TestGetScopeID() {
    uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
    PP_NetAddress_Private ipv4 = MakeIPv4NetAddress(localhost_ip, 80);
    ASSERT_EQ(0, NetAddressPrivate::GetScopeID(ipv4));
  
    uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
  
    PP_NetAddress_Private ipv6_123 = MakeIPv6NetAddress(ipv6_address, 0, 123);
    ASSERT_EQ(123, NetAddressPrivate::GetScopeID(ipv6_123));
  
    PP_NetAddress_Private ipv6_max =
        MakeIPv6NetAddress(ipv6_address, 0, 0xFFFFFFFF);
    ASSERT_EQ(NetAddressPrivate::GetScopeID(ipv6_max), 0xFFFFFFFF);
  
    PASS();
  }
  