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/strings/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:
SetUp()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
TEST_F(IPEndPointTest,Constructor)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
TEST_F(IPEndPointTest,Assignment)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
TEST_F(IPEndPointTest,Copy)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
TEST_F(IPEndPointTest,ToFromSockAddr)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
TEST_F(IPEndPointTest,ToSockAddrBufTooSmall)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
TEST_F(IPEndPointTest,FromSockAddrBufTooSmall)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
TEST_F(IPEndPointTest,Equality)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
TEST_F(IPEndPointTest,LessThan)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
TEST_F(IPEndPointTest,ToString)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
174