net/base/ip_endpoint_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/ip_endpoint.h"
   6
   7 #include "base/string_number_conversions.h"
   8 #include "net/base/net_util.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "testing/platform_test.h"
  11 #if defined(OS_WIN)
  12 #include <winsock2.h>
  13 #elif defined(OS_POSIX)
  14 #include <netinet/in.h>
  15 #endif
  16
  17 namespace net {
  18
  19 namespace {
  20
  21 struct TestData {
  22   std::string host;
  23   std::string host_normalized;
  24   bool ipv6;
  25   IPAddressNumber ip_address;
  26 } tests[] = {
  27   { "127.0.00.1", "127.0.0.1", false},
  28   { "192.168.1.1", "192.168.1.1", false },
  29   { "::1", "[::1]", true },
  30   { "2001:db8:0::42", "[2001:db8::42]", true },
  31 };
  32 int test_count = ARRAYSIZE_UNSAFE(tests);
  33
  34 class IPEndPointTest : public PlatformTest {
  35  public:
  36   virtual void SetUp() {
  37     // This is where we populate the TestData.
  38     for (int index = 0; index < test_count; ++index) {
  39       EXPECT_TRUE(ParseIPLiteralToNumber(tests[index].host,
  40           &tests[index].ip_address));
  41     }
  42   }
  43 };
  44
  45 TEST_F(IPEndPointTest, Constructor) {
  46   IPEndPoint endpoint;
  47   EXPECT_EQ(0, endpoint.port());
  48
  49   for (int index = 0; index < test_count; ++index) {
  50     IPEndPoint endpoint(tests[index].ip_address, 80);
  51     EXPECT_EQ(80, endpoint.port());
  52     EXPECT_EQ(tests[index].ip_address, endpoint.address());
  53   }
  54 }
  55
  56 TEST_F(IPEndPointTest, Assignment) {
  57   for (int index = 0; index < test_count; ++index) {
  58     IPEndPoint src(tests[index].ip_address, index);
  59     IPEndPoint dest = src;
  60
  61     EXPECT_EQ(src.port(), dest.port());
  62     EXPECT_EQ(src.address(), dest.address());
  63   }
  64 }
  65
  66 TEST_F(IPEndPointTest, Copy) {
  67   for (int index = 0; index < test_count; ++index) {
  68     IPEndPoint src(tests[index].ip_address, index);
  69     IPEndPoint dest(src);
  70
  71     EXPECT_EQ(src.port(), dest.port());
  72     EXPECT_EQ(src.address(), dest.address());
  73   }
  74 }
  75
  76 TEST_F(IPEndPointTest, ToFromSockAddr) {
  77   for (int index = 0; index < test_count; ++index) {
  78     IPEndPoint ip_endpoint(tests[index].ip_address, index);
  79
  80     // Convert to a sockaddr.
  81     SockaddrStorage storage;
  82     EXPECT_TRUE(ip_endpoint.ToSockAddr(storage.addr, &storage.addr_len));
  83
  84     // Basic verification.
  85     socklen_t expected_size = tests[index].ipv6 ?
  86         sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
  87     EXPECT_EQ(expected_size, storage.addr_len);
  88     EXPECT_EQ(ip_endpoint.port(), GetPortFromSockaddr(storage.addr,
  89                                                       storage.addr_len));
  90
  91     // And convert back to an IPEndPoint.
  92     IPEndPoint ip_endpoint2;
  93     EXPECT_TRUE(ip_endpoint2.FromSockAddr(storage.addr, storage.addr_len));
  94     EXPECT_EQ(ip_endpoint.port(), ip_endpoint2.port());
  95     EXPECT_EQ(ip_endpoint.address(), ip_endpoint2.address());
  96   }
  97 }
  98
  99 TEST_F(IPEndPointTest, ToSockAddrBufTooSmall) {
 100   for (int index = 0; index < test_count; ++index) {
 101     IPEndPoint ip_endpoint(tests[index].ip_address, index);
 102
 103     SockaddrStorage storage;
 104     storage.addr_len = index;  // size is too small!
 105     EXPECT_FALSE(ip_endpoint.ToSockAddr(storage.addr, &storage.addr_len));
 106   }
 107 }
 108
 109 TEST_F(IPEndPointTest, FromSockAddrBufTooSmall) {
 110   struct sockaddr_in addr;
 111   memset(&addr, 0, sizeof(addr));
 112   addr.sin_family = AF_INET;
 113   IPEndPoint ip_endpoint;
 114   struct sockaddr* sockaddr = reinterpret_cast<struct sockaddr*>(&addr);
 115   EXPECT_FALSE(ip_endpoint.FromSockAddr(sockaddr, sizeof(addr) - 1));
 116 }
 117
 118 TEST_F(IPEndPointTest, Equality) {
 119   for (int index = 0; index < test_count; ++index) {
 120     IPEndPoint src(tests[index].ip_address, index);
 121     IPEndPoint dest(src);
 122     EXPECT_TRUE(src == dest);
 123   }
 124 }
 125
 126 TEST_F(IPEndPointTest, LessThan) {
 127   // Vary by port.
 128   IPEndPoint ip_endpoint1(tests[0].ip_address, 100);
 129   IPEndPoint ip_endpoint2(tests[0].ip_address, 1000);
 130   EXPECT_TRUE(ip_endpoint1 < ip_endpoint2);
 131   EXPECT_FALSE(ip_endpoint2 < ip_endpoint1);
 132
 133   // IPv4 vs IPv6
 134   ip_endpoint1 = IPEndPoint(tests[0].ip_address, 81);
 135   ip_endpoint2 = IPEndPoint(tests[2].ip_address, 80);
 136   EXPECT_TRUE(ip_endpoint1 < ip_endpoint2);
 137   EXPECT_FALSE(ip_endpoint2 < ip_endpoint1);
 138
 139   // IPv4 vs IPv4
 140   ip_endpoint1 = IPEndPoint(tests[0].ip_address, 81);
 141   ip_endpoint2 = IPEndPoint(tests[1].ip_address, 80);
 142   EXPECT_TRUE(ip_endpoint1 < ip_endpoint2);
 143   EXPECT_FALSE(ip_endpoint2 < ip_endpoint1);
 144
 145   // IPv6 vs IPv6
 146   ip_endpoint1 = IPEndPoint(tests[2].ip_address, 81);
 147   ip_endpoint2 = IPEndPoint(tests[3].ip_address, 80);
 148   EXPECT_TRUE(ip_endpoint1 < ip_endpoint2);
 149   EXPECT_FALSE(ip_endpoint2 < ip_endpoint1);
 150
 151   // Compare equivalent endpoints.
 152   ip_endpoint1 = IPEndPoint(tests[0].ip_address, 80);
 153   ip_endpoint2 = IPEndPoint(tests[0].ip_address, 80);
 154   EXPECT_FALSE(ip_endpoint1 < ip_endpoint2);
 155   EXPECT_FALSE(ip_endpoint2 < ip_endpoint1);
 156 }
 157
 158 TEST_F(IPEndPointTest, ToString) {
 159   IPEndPoint endpoint;
 160   EXPECT_EQ(0, endpoint.port());
 161
 162   for (int index = 0; index < test_count; ++index) {
 163     int port = 100 + index;
 164     IPEndPoint endpoint(tests[index].ip_address, port);
 165     const std::string result = endpoint.ToString();
 166     EXPECT_EQ(tests[index].host_normalized + ":" + base::IntToString(port),
 167               result);
 168   }
 169 }
 170
 171 }  // namespace
 172
 173 }  // namespace net