address_list_unittest.cc revision 3345a6884c488ff3a535c2c9acdd33d74b37e311 
1// Copyright (c) 2010 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/address_list.h"
6
7#include "base/string_util.h"
8#include "net/base/host_resolver_proc.h"
9#include "net/base/net_util.h"
10#include "net/base/sys_addrinfo.h"
11#if defined(OS_WIN)
12#include "net/base/winsock_init.h"
13#endif
14#include "testing/gtest/include/gtest/gtest.h"
15
16namespace {
17
18// Use getaddrinfo() to allocate an addrinfo structure.
19int CreateAddressList(const std::string& hostname, int port,
20                      net::AddressList* addrlist) {
21#if defined(OS_WIN)
22  net::EnsureWinsockInit();
23#endif
24  int rv = SystemHostResolverProc(hostname,
25                                  net::ADDRESS_FAMILY_UNSPECIFIED,
26                                  0,
27                                  addrlist, NULL);
28  if (rv == 0)
29    addrlist->SetPort(port);
30  return rv;
31}
32
33void CreateLongAddressList(net::AddressList* addrlist, int port) {
34  EXPECT_EQ(0, CreateAddressList("192.168.1.1", port, addrlist));
35  net::AddressList second_list;
36  EXPECT_EQ(0, CreateAddressList("192.168.1.2", port, &second_list));
37  addrlist->Append(second_list.head());
38}
39
40TEST(AddressListTest, GetPort) {
41  net::AddressList addrlist;
42  EXPECT_EQ(0, CreateAddressList("192.168.1.1", 81, &addrlist));
43  EXPECT_EQ(81, addrlist.GetPort());
44
45  addrlist.SetPort(83);
46  EXPECT_EQ(83, addrlist.GetPort());
47}
48
49TEST(AddressListTest, Assignment) {
50  net::AddressList addrlist1;
51  EXPECT_EQ(0, CreateAddressList("192.168.1.1", 85, &addrlist1));
52  EXPECT_EQ(85, addrlist1.GetPort());
53
54  // Should reference the same data as addrlist1 -- so when we change addrlist1
55  // both are changed.
56  net::AddressList addrlist2 = addrlist1;
57  EXPECT_EQ(85, addrlist2.GetPort());
58
59  addrlist1.SetPort(80);
60  EXPECT_EQ(80, addrlist1.GetPort());
61  EXPECT_EQ(80, addrlist2.GetPort());
62}
63
64TEST(AddressListTest, CopyRecursive) {
65  net::AddressList addrlist1;
66  CreateLongAddressList(&addrlist1, 85);
67  EXPECT_EQ(85, addrlist1.GetPort());
68
69  net::AddressList addrlist2;
70  addrlist2.Copy(addrlist1.head(), true);
71
72  ASSERT_TRUE(addrlist2.head()->ai_next != NULL);
73
74  // addrlist1 is the same as addrlist2 at this point.
75  EXPECT_EQ(85, addrlist1.GetPort());
76  EXPECT_EQ(85, addrlist2.GetPort());
77
78  // Changes to addrlist1 are not reflected in addrlist2.
79  addrlist1.SetPort(70);
80  addrlist2.SetPort(90);
81
82  EXPECT_EQ(70, addrlist1.GetPort());
83  EXPECT_EQ(90, addrlist2.GetPort());
84}
85
86TEST(AddressListTest, CopyNonRecursive) {
87  net::AddressList addrlist1;
88  CreateLongAddressList(&addrlist1, 85);
89  EXPECT_EQ(85, addrlist1.GetPort());
90
91  net::AddressList addrlist2;
92  addrlist2.Copy(addrlist1.head(), false);
93
94  ASSERT_TRUE(addrlist2.head()->ai_next == NULL);
95
96  // addrlist1 is the same as addrlist2 at this point.
97  EXPECT_EQ(85, addrlist1.GetPort());
98  EXPECT_EQ(85, addrlist2.GetPort());
99
100  // Changes to addrlist1 are not reflected in addrlist2.
101  addrlist1.SetPort(70);
102  addrlist2.SetPort(90);
103
104  EXPECT_EQ(70, addrlist1.GetPort());
105  EXPECT_EQ(90, addrlist2.GetPort());
106}
107
108TEST(AddressListTest, Append) {
109  net::AddressList addrlist1;
110  EXPECT_EQ(0, CreateAddressList("192.168.1.1", 11, &addrlist1));
111  EXPECT_EQ(11, addrlist1.GetPort());
112  net::AddressList addrlist2;
113  EXPECT_EQ(0, CreateAddressList("192.168.1.2", 12, &addrlist2));
114  EXPECT_EQ(12, addrlist2.GetPort());
115
116  ASSERT_TRUE(addrlist1.head()->ai_next == NULL);
117  addrlist1.Append(addrlist2.head());
118  ASSERT_TRUE(addrlist1.head()->ai_next != NULL);
119
120  net::AddressList addrlist3;
121  addrlist3.Copy(addrlist1.head()->ai_next, false);
122  EXPECT_EQ(12, addrlist3.GetPort());
123}
124
125static const char* kCanonicalHostname = "canonical.bar.com";
126
127TEST(AddressListTest, Canonical) {
128  // Create an addrinfo with a canonical name.
129  sockaddr_in address;
130  // The contents of address do not matter for this test,
131  // so just zero-ing them out for consistency.
132  memset(&address, 0x0, sizeof(address));
133  struct addrinfo ai;
134  memset(&ai, 0x0, sizeof(ai));
135  ai.ai_family = AF_INET;
136  ai.ai_socktype = SOCK_STREAM;
137  ai.ai_addrlen = sizeof(address);
138  ai.ai_addr = reinterpret_cast<sockaddr*>(&address);
139  ai.ai_canonname = const_cast<char *>(kCanonicalHostname);
140
141  // Copy the addrinfo struct into an AddressList object and
142  // make sure it seems correct.
143  net::AddressList addrlist1;
144  addrlist1.Copy(&ai, true);
145  const struct addrinfo* addrinfo1 = addrlist1.head();
146  EXPECT_TRUE(addrinfo1 != NULL);
147  EXPECT_TRUE(addrinfo1->ai_next == NULL);
148  std::string canon_name1;
149  EXPECT_TRUE(addrlist1.GetCanonicalName(&canon_name1));
150  EXPECT_EQ("canonical.bar.com", canon_name1);
151
152  // Copy the AddressList to another one.
153  net::AddressList addrlist2;
154  addrlist2.Copy(addrinfo1, true);
155  const struct addrinfo* addrinfo2 = addrlist2.head();
156  EXPECT_TRUE(addrinfo2 != NULL);
157  EXPECT_TRUE(addrinfo2->ai_next == NULL);
158  EXPECT_TRUE(addrinfo2->ai_canonname != NULL);
159  EXPECT_NE(addrinfo1, addrinfo2);
160  EXPECT_NE(addrinfo1->ai_canonname, addrinfo2->ai_canonname);
161  std::string canon_name2;
162  EXPECT_TRUE(addrlist2.GetCanonicalName(&canon_name2));
163  EXPECT_EQ("canonical.bar.com", canon_name2);
164
165  // Make sure that GetCanonicalName correctly returns false
166  // when ai_canonname is NULL.
167  ai.ai_canonname = NULL;
168  net::AddressList addrlist_no_canon;
169  addrlist_no_canon.Copy(&ai, true);
170  std::string canon_name3 = "blah";
171  EXPECT_FALSE(addrlist_no_canon.GetCanonicalName(&canon_name3));
172  EXPECT_EQ("blah", canon_name3);
173}
174
175TEST(AddressListTest, IPLiteralConstructor) {
176  struct TestData {
177    std::string ip_address;
178    std::string canonical_ip_address;
179    bool is_ipv6;
180  } tests[] = {
181    { "127.0.00.1", "127.0.0.1", false },
182    { "192.168.1.1", "192.168.1.1", false },
183    { "::1", "::1", true },
184    { "2001:db8:0::42", "2001:db8::42", true },
185  };
186  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
187    net::AddressList expected_list;
188    int rv = CreateAddressList(tests[i].canonical_ip_address, 80,
189                               &expected_list);
190    if (tests[i].is_ipv6 && rv != 0) {
191      LOG(WARNING) << "Unable to resolve ip literal '" << tests[i].ip_address
192                   << "' test skipped.";
193      continue;
194    }
195    ASSERT_EQ(0, rv);
196    const struct addrinfo* good_ai = expected_list.head();
197
198    net::IPAddressNumber ip_number;
199    net::ParseIPLiteralToNumber(tests[i].ip_address, &ip_number);
200    net::AddressList test_list(ip_number, 80, true);
201    const struct addrinfo* test_ai = test_list.head();
202
203    EXPECT_EQ(good_ai->ai_family, test_ai->ai_family);
204    EXPECT_EQ(good_ai->ai_socktype, test_ai->ai_socktype);
205    EXPECT_EQ(good_ai->ai_addrlen, test_ai->ai_addrlen);
206    size_t sockaddr_size =
207        good_ai->ai_socktype == AF_INET ? sizeof(struct sockaddr_in) :
208        good_ai->ai_socktype == AF_INET6 ? sizeof(struct sockaddr_in6) : 0;
209    EXPECT_EQ(memcmp(good_ai->ai_addr, test_ai->ai_addr, sockaddr_size), 0);
210    EXPECT_EQ(good_ai->ai_next, test_ai->ai_next);
211    EXPECT_EQ(strcmp(tests[i].canonical_ip_address.c_str(),
212                     test_ai->ai_canonname), 0);
213  }
214}
215
216}  // namespace
217