1 // Copyright 2015 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifdef UNSAFE_BUFFERS_BUILD
6 // TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
7 #pragma allow_unsafe_buffers
8 #endif
9
10 #include "net/base/ip_address.h"
11
12 #include <optional>
13 #include <vector>
14
15 #include "base/format_macros.h"
16 #include "base/strings/string_number_conversions.h"
17 #include "base/strings/stringprintf.h"
18 #include "testing/gmock/include/gmock/gmock.h"
19 #include "testing/gtest/include/gtest/gtest.h"
20
21 using testing::Optional;
22
23 namespace net {
24
25 namespace {
26
27 // Helper to stringize an IP address (used to define expectations).
DumpIPAddress(const IPAddress & v)28 std::string DumpIPAddress(const IPAddress& v) {
29 std::string out;
30 for (size_t i = 0; i < v.bytes().size(); ++i) {
31 if (i != 0)
32 out.append(",");
33 out.append(base::NumberToString(v.bytes()[i]));
34 }
35 return out;
36 }
37
TEST(IPAddressBytesTest,ConstructEmpty)38 TEST(IPAddressBytesTest, ConstructEmpty) {
39 IPAddressBytes bytes;
40 ASSERT_EQ(0u, bytes.size());
41 }
42
TEST(IPAddressBytesTest,ConstructIPv4)43 TEST(IPAddressBytesTest, ConstructIPv4) {
44 uint8_t data[] = {192, 168, 1, 1};
45 IPAddressBytes bytes(data);
46 ASSERT_EQ(std::size(data), bytes.size());
47 size_t i = 0;
48 for (uint8_t byte : bytes)
49 EXPECT_EQ(data[i++], byte);
50 ASSERT_EQ(std::size(data), i);
51 }
52
TEST(IPAddressBytesTest,ConstructIPv6)53 TEST(IPAddressBytesTest, ConstructIPv6) {
54 uint8_t data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
55 IPAddressBytes bytes(data);
56 ASSERT_EQ(std::size(data), bytes.size());
57 size_t i = 0;
58 for (uint8_t byte : bytes)
59 EXPECT_EQ(data[i++], byte);
60 ASSERT_EQ(std::size(data), i);
61 }
62
TEST(IPAddressBytesTest,Assign)63 TEST(IPAddressBytesTest, Assign) {
64 uint8_t data[] = {192, 168, 1, 1};
65 IPAddressBytes copy;
66 copy.Assign(data);
67 EXPECT_EQ(IPAddressBytes(data), copy);
68 }
69
TEST(IPAddressTest,ConstructIPv4)70 TEST(IPAddressTest, ConstructIPv4) {
71 EXPECT_EQ("127.0.0.1", IPAddress::IPv4Localhost().ToString());
72
73 IPAddress ipv4_ctor(192, 168, 1, 1);
74 EXPECT_EQ("192.168.1.1", ipv4_ctor.ToString());
75 }
76
TEST(IPAddressTest,IsIPVersion)77 TEST(IPAddressTest, IsIPVersion) {
78 uint8_t addr1[4] = {192, 168, 0, 1};
79 IPAddress ip_address1(addr1);
80 EXPECT_TRUE(ip_address1.IsIPv4());
81 EXPECT_FALSE(ip_address1.IsIPv6());
82
83 uint8_t addr2[16] = {0xFE, 0xDC, 0xBA, 0x98};
84 IPAddress ip_address2(addr2);
85 EXPECT_TRUE(ip_address2.IsIPv6());
86 EXPECT_FALSE(ip_address2.IsIPv4());
87
88 IPAddress ip_address3;
89 EXPECT_FALSE(ip_address3.IsIPv6());
90 EXPECT_FALSE(ip_address3.IsIPv4());
91 }
92
TEST(IPAddressTest,IsValid)93 TEST(IPAddressTest, IsValid) {
94 uint8_t addr1[4] = {192, 168, 0, 1};
95 IPAddress ip_address1(addr1);
96 EXPECT_TRUE(ip_address1.IsValid());
97 EXPECT_FALSE(ip_address1.empty());
98
99 uint8_t addr2[16] = {0xFE, 0xDC, 0xBA, 0x98};
100 IPAddress ip_address2(addr2);
101 EXPECT_TRUE(ip_address2.IsValid());
102 EXPECT_FALSE(ip_address2.empty());
103
104 uint8_t addr3[5] = {0xFE, 0xDC, 0xBA, 0x98};
105 IPAddress ip_address3(addr3);
106 EXPECT_FALSE(ip_address3.IsValid());
107 EXPECT_FALSE(ip_address3.empty());
108
109 IPAddress ip_address4;
110 EXPECT_FALSE(ip_address4.IsValid());
111 EXPECT_TRUE(ip_address4.empty());
112 }
113
114 enum IPAddressReservedResult : bool { NOT_RESERVED = false, RESERVED = true };
115
116 // Tests for the reserved IPv4 ranges and the (unreserved) blocks in between.
117 // The reserved ranges are tested by checking the first and last address of each
118 // range. The unreserved blocks are tested similarly. These tests cover the
119 // entire IPv4 address range, as well as this range mapped to IPv6.
TEST(IPAddressTest,IsPubliclyRoutableIPv4)120 TEST(IPAddressTest, IsPubliclyRoutableIPv4) {
121 struct {
122 const char* const address;
123 IPAddressReservedResult is_reserved;
124 } tests[] = {// 0.0.0.0/8
125 {"0.0.0.0", RESERVED},
126 {"0.255.255.255", RESERVED},
127 // Unreserved block(s)
128 {"1.0.0.0", NOT_RESERVED},
129 {"9.255.255.255", NOT_RESERVED},
130 // 10.0.0.0/8
131 {"10.0.0.0", RESERVED},
132 {"10.255.255.255", RESERVED},
133 // Unreserved block(s)
134 {"11.0.0.0", NOT_RESERVED},
135 {"100.63.255.255", NOT_RESERVED},
136 // 100.64.0.0/10
137 {"100.64.0.0", RESERVED},
138 {"100.127.255.255", RESERVED},
139 // Unreserved block(s)
140 {"100.128.0.0", NOT_RESERVED},
141 {"126.255.255.255", NOT_RESERVED},
142 // 127.0.0.0/8
143 {"127.0.0.0", RESERVED},
144 {"127.255.255.255", RESERVED},
145 // Unreserved block(s)
146 {"128.0.0.0", NOT_RESERVED},
147 {"169.253.255.255", NOT_RESERVED},
148 // 169.254.0.0/16
149 {"169.254.0.0", RESERVED},
150 {"169.254.255.255", RESERVED},
151 // Unreserved block(s)
152 {"169.255.0.0", NOT_RESERVED},
153 {"172.15.255.255", NOT_RESERVED},
154 // 172.16.0.0/12
155 {"172.16.0.0", RESERVED},
156 {"172.31.255.255", RESERVED},
157 // Unreserved block(s)
158 {"172.32.0.0", NOT_RESERVED},
159 {"191.255.255.255", NOT_RESERVED},
160 // 192.0.0.0/24 (including sub ranges)
161 {"192.0.0.0", RESERVED},
162 {"192.0.0.255", RESERVED},
163 // Unreserved block(s)
164 {"192.0.1.0", NOT_RESERVED},
165 {"192.0.1.255", NOT_RESERVED},
166 // 192.0.2.0/24
167 {"192.0.2.0", RESERVED},
168 {"192.0.2.255", RESERVED},
169 // Unreserved block(s)
170 {"192.0.3.0", NOT_RESERVED},
171 {"192.31.195.255", NOT_RESERVED},
172 // 192.31.196.0/24
173 {"192.31.196.0", NOT_RESERVED},
174 {"192.31.196.255", NOT_RESERVED},
175 // Unreserved block(s)
176 {"192.32.197.0", NOT_RESERVED},
177 {"192.52.192.255", NOT_RESERVED},
178 // 192.52.193.0/24
179 {"192.52.193.0", NOT_RESERVED},
180 {"192.52.193.255", NOT_RESERVED},
181 // Unreserved block(s)
182 {"192.52.194.0", NOT_RESERVED},
183 {"192.88.98.255", NOT_RESERVED},
184 // 192.88.99.0/24
185 {"192.88.99.0", RESERVED},
186 {"192.88.99.255", RESERVED},
187 // Unreserved block(s)
188 {"192.88.100.0", NOT_RESERVED},
189 {"192.167.255.255", NOT_RESERVED},
190 // 192.168.0.0/16
191 {"192.168.0.0", RESERVED},
192 {"192.168.255.255", RESERVED},
193 // Unreserved block(s)
194 {"192.169.0.0", NOT_RESERVED},
195 {"192.175.47.255", NOT_RESERVED},
196 // 192.175.48.0/24
197 {"192.175.48.0", NOT_RESERVED},
198 {"192.175.48.255", NOT_RESERVED},
199 // Unreserved block(s)
200 {"192.175.49.0", NOT_RESERVED},
201 {"198.17.255.255", NOT_RESERVED},
202 // 198.18.0.0/15
203 {"198.18.0.0", RESERVED},
204 {"198.19.255.255", RESERVED},
205 // Unreserved block(s)
206 {"198.20.0.0", NOT_RESERVED},
207 {"198.51.99.255", NOT_RESERVED},
208 // 198.51.100.0/24
209 {"198.51.100.0", RESERVED},
210 {"198.51.100.255", RESERVED},
211 // Unreserved block(s)
212 {"198.51.101.0", NOT_RESERVED},
213 {"203.0.112.255", NOT_RESERVED},
214 // 203.0.113.0/24
215 {"203.0.113.0", RESERVED},
216 {"203.0.113.255", RESERVED},
217 // Unreserved block(s)
218 {"203.0.114.0", NOT_RESERVED},
219 {"223.255.255.255", NOT_RESERVED},
220 // 224.0.0.0/8 - 255.0.0.0/8
221 {"224.0.0.0", RESERVED},
222 {"255.255.255.255", RESERVED}};
223
224 for (const auto& test : tests) {
225 IPAddress address;
226 EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
227 ASSERT_TRUE(address.IsValid());
228 EXPECT_EQ(!test.is_reserved, address.IsPubliclyRoutable());
229
230 // Check these IPv4 addresses when mapped to IPv6. This verifies we're
231 // properly unpacking mapped addresses.
232 IPAddress mapped_address = ConvertIPv4ToIPv4MappedIPv6(address);
233 EXPECT_EQ(!test.is_reserved, mapped_address.IsPubliclyRoutable());
234 }
235 }
236
237 // Tests for the reserved IPv6 ranges and the (unreserved) blocks in between.
238 // The reserved ranges are tested by checking the first and last address of each
239 // range. The unreserved blocks are tested similarly. These tests cover the
240 // entire IPv6 address range.
TEST(IPAddressTest,IsPubliclyRoutableIPv6)241 TEST(IPAddressTest, IsPubliclyRoutableIPv6) {
242 struct {
243 const char* const address;
244 IPAddressReservedResult is_reserved;
245 } tests[] = {// 0000::/8.
246 // Skip testing ::ffff:/96 explicitly since it was tested
247 // in IsPubliclyRoutableIPv4
248 {"0:0:0:0:0:0:0:0", RESERVED},
249 {"ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
250 // 0100::/8
251 {"100:0:0:0:0:0:0:0", RESERVED},
252 {"1ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
253 // 0200::/7
254 {"200:0:0:0:0:0:0:0", RESERVED},
255 {"3ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
256 // 0400::/6
257 {"400:0:0:0:0:0:0:0", RESERVED},
258 {"7ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
259 // 0800::/5
260 {"800:0:0:0:0:0:0:0", RESERVED},
261 {"fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
262 // 1000::/4
263 {"1000:0:0:0:0:0:0:0", RESERVED},
264 {"1fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
265 // 2000::/3 (Global Unicast)
266 {"2000:0:0:0:0:0:0:0", NOT_RESERVED},
267 {"3fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", NOT_RESERVED},
268 // 4000::/3
269 {"4000:0:0:0:0:0:0:0", RESERVED},
270 {"5fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
271 // 6000::/3
272 {"6000:0:0:0:0:0:0:0", RESERVED},
273 {"7fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
274 // 8000::/3
275 {"8000:0:0:0:0:0:0:0", RESERVED},
276 {"9fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
277 // c000::/3
278 {"c000:0:0:0:0:0:0:0", RESERVED},
279 {"dfff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
280 // e000::/4
281 {"e000:0:0:0:0:0:0:0", RESERVED},
282 {"efff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
283 // f000::/5
284 {"f000:0:0:0:0:0:0:0", RESERVED},
285 {"f7ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
286 // f800::/6
287 {"f800:0:0:0:0:0:0:0", RESERVED},
288 {"fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
289 // fc00::/7
290 {"fc00:0:0:0:0:0:0:0", RESERVED},
291 {"fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
292 // fe00::/9
293 {"fe00:0:0:0:0:0:0:0", RESERVED},
294 {"fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
295 // fe80::/10
296 {"fe80:0:0:0:0:0:0:0", RESERVED},
297 {"febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
298 // fec0::/10
299 {"fec0:0:0:0:0:0:0:0", RESERVED},
300 {"feff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
301 // ff00::/8 (Multicast)
302 {"ff00:0:0:0:0:0:0:0", NOT_RESERVED},
303 {"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", NOT_RESERVED}};
304
305 IPAddress address;
306 for (const auto& test : tests) {
307 EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
308 EXPECT_EQ(!test.is_reserved, address.IsPubliclyRoutable());
309 }
310 }
311
TEST(IPAddressTest,IsZero)312 TEST(IPAddressTest, IsZero) {
313 uint8_t address1[4] = {};
314 IPAddress zero_ipv4_address(address1);
315 EXPECT_TRUE(zero_ipv4_address.IsZero());
316
317 uint8_t address2[4] = {10};
318 IPAddress non_zero_ipv4_address(address2);
319 EXPECT_FALSE(non_zero_ipv4_address.IsZero());
320
321 uint8_t address3[16] = {};
322 IPAddress zero_ipv6_address(address3);
323 EXPECT_TRUE(zero_ipv6_address.IsZero());
324
325 uint8_t address4[16] = {10};
326 IPAddress non_zero_ipv6_address(address4);
327 EXPECT_FALSE(non_zero_ipv6_address.IsZero());
328
329 IPAddress empty_address;
330 EXPECT_FALSE(empty_address.IsZero());
331 }
332
TEST(IPAddressTest,IsIPv4Mapped)333 TEST(IPAddressTest, IsIPv4Mapped) {
334 IPAddress ipv4_address(192, 168, 0, 1);
335 EXPECT_FALSE(ipv4_address.IsIPv4MappedIPv6());
336 IPAddress ipv6_address(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
337 EXPECT_FALSE(ipv6_address.IsIPv4MappedIPv6());
338 IPAddress mapped_address(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 1, 1, 0, 1);
339 EXPECT_TRUE(mapped_address.IsIPv4MappedIPv6());
340 }
341
TEST(IPAddressTest,AllZeros)342 TEST(IPAddressTest, AllZeros) {
343 EXPECT_TRUE(IPAddress::AllZeros(0).empty());
344
345 EXPECT_EQ(3u, IPAddress::AllZeros(3).size());
346 EXPECT_TRUE(IPAddress::AllZeros(3).IsZero());
347
348 EXPECT_EQ("0.0.0.0", IPAddress::IPv4AllZeros().ToString());
349 EXPECT_EQ("::", IPAddress::IPv6AllZeros().ToString());
350 }
351
TEST(IPAddressTest,ToString)352 TEST(IPAddressTest, ToString) {
353 EXPECT_EQ("0.0.0.0", IPAddress::IPv4AllZeros().ToString());
354
355 IPAddress address(192, 168, 0, 1);
356 EXPECT_EQ("192.168.0.1", address.ToString());
357
358 IPAddress address2(0xFE, 0xDC, 0xBA, 0x98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
359 0);
360 EXPECT_EQ("fedc:ba98::", address2.ToString());
361
362 // ToString() shouldn't crash on invalid addresses.
363 uint8_t addr4[2];
364 IPAddress address4(addr4);
365 EXPECT_EQ("", address4.ToString());
366
367 IPAddress address5;
368 EXPECT_EQ("", address5.ToString());
369 }
370
TEST(IPAddressTest,IPAddressToStringWithPort)371 TEST(IPAddressTest, IPAddressToStringWithPort) {
372 EXPECT_EQ("0.0.0.0:3",
373 IPAddressToStringWithPort(IPAddress::IPv4AllZeros(), 3));
374
375 IPAddress address1(192, 168, 0, 1);
376 EXPECT_EQ("192.168.0.1:99", IPAddressToStringWithPort(address1, 99));
377
378 IPAddress address2(0xFE, 0xDC, 0xBA, 0x98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
379 0);
380 EXPECT_EQ("[fedc:ba98::]:8080", IPAddressToStringWithPort(address2, 8080));
381
382 // IPAddressToStringWithPort() shouldn't crash on invalid addresses.
383 uint8_t addr3[2];
384 EXPECT_EQ("", IPAddressToStringWithPort(IPAddress(addr3), 8080));
385 }
386
TEST(IPAddressTest,IPAddressToPackedString)387 TEST(IPAddressTest, IPAddressToPackedString) {
388 IPAddress ipv4_address;
389 EXPECT_TRUE(ipv4_address.AssignFromIPLiteral("4.31.198.44"));
390 std::string expected_ipv4_address("\x04\x1f\xc6\x2c", 4);
391 EXPECT_EQ(expected_ipv4_address, IPAddressToPackedString(ipv4_address));
392
393 IPAddress ipv6_address;
394 EXPECT_TRUE(ipv6_address.AssignFromIPLiteral("2001:0700:0300:1800::000f"));
395 std::string expected_ipv6_address(
396 "\x20\x01\x07\x00\x03\x00\x18\x00"
397 "\x00\x00\x00\x00\x00\x00\x00\x0f",
398 16);
399 EXPECT_EQ(expected_ipv6_address, IPAddressToPackedString(ipv6_address));
400 }
401
402 // Test that invalid IP literals fail to parse.
TEST(IPAddressTest,AssignFromIPLiteral_FailParse)403 TEST(IPAddressTest, AssignFromIPLiteral_FailParse) {
404 IPAddress address;
405
406 EXPECT_FALSE(address.AssignFromIPLiteral("bad value"));
407 EXPECT_FALSE(address.AssignFromIPLiteral("bad:value"));
408 EXPECT_FALSE(address.AssignFromIPLiteral(std::string()));
409 EXPECT_FALSE(address.AssignFromIPLiteral("192.168.0.1:30"));
410 EXPECT_FALSE(address.AssignFromIPLiteral(" 192.168.0.1 "));
411 EXPECT_FALSE(address.AssignFromIPLiteral("[::1]"));
412 }
413
414 // Test that a failure calling AssignFromIPLiteral() has the sideffect of
415 // clearing the current value.
TEST(IPAddressTest,AssignFromIPLiteral_ResetOnFailure)416 TEST(IPAddressTest, AssignFromIPLiteral_ResetOnFailure) {
417 IPAddress address = IPAddress::IPv6Localhost();
418
419 EXPECT_TRUE(address.IsValid());
420 EXPECT_FALSE(address.empty());
421
422 EXPECT_FALSE(address.AssignFromIPLiteral("bad value"));
423
424 EXPECT_FALSE(address.IsValid());
425 EXPECT_TRUE(address.empty());
426 }
427
428 // Test parsing an IPv4 literal.
TEST(IPAddressTest,AssignFromIPLiteral_IPv4)429 TEST(IPAddressTest, AssignFromIPLiteral_IPv4) {
430 IPAddress address;
431 EXPECT_TRUE(address.AssignFromIPLiteral("192.168.0.1"));
432 EXPECT_EQ("192,168,0,1", DumpIPAddress(address));
433 EXPECT_EQ("192.168.0.1", address.ToString());
434 }
435
436 // Test parsing an IPv6 literal.
TEST(IPAddressTest,AssignFromIPLiteral_IPv6)437 TEST(IPAddressTest, AssignFromIPLiteral_IPv6) {
438 IPAddress address;
439 EXPECT_TRUE(address.AssignFromIPLiteral("1:abcd::3:4:ff"));
440 EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPAddress(address));
441 EXPECT_EQ("1:abcd::3:4:ff", address.ToString());
442 }
443
TEST(IPAddressTest,IsIPv4MappedIPv6)444 TEST(IPAddressTest, IsIPv4MappedIPv6) {
445 IPAddress ipv4_address(192, 168, 0, 1);
446 EXPECT_FALSE(ipv4_address.IsIPv4MappedIPv6());
447 IPAddress ipv6_address = IPAddress::IPv6Localhost();
448 EXPECT_FALSE(ipv6_address.IsIPv4MappedIPv6());
449 IPAddress mapped_address(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 1, 1, 0, 1);
450 EXPECT_TRUE(mapped_address.IsIPv4MappedIPv6());
451 }
452
TEST(IPAddressTest,IsEqual)453 TEST(IPAddressTest, IsEqual) {
454 IPAddress ip_address1;
455 EXPECT_TRUE(ip_address1.AssignFromIPLiteral("127.0.0.1"));
456 IPAddress ip_address2;
457 EXPECT_TRUE(ip_address2.AssignFromIPLiteral("2001:db8:0::42"));
458 IPAddress ip_address3;
459 EXPECT_TRUE(ip_address3.AssignFromIPLiteral("127.0.0.1"));
460
461 EXPECT_FALSE(ip_address1 == ip_address2);
462 EXPECT_TRUE(ip_address1 == ip_address3);
463 }
464
TEST(IPAddressTest,LessThan)465 TEST(IPAddressTest, LessThan) {
466 // IPv4 vs IPv6
467 IPAddress ip_address1;
468 EXPECT_TRUE(ip_address1.AssignFromIPLiteral("127.0.0.1"));
469 IPAddress ip_address2;
470 EXPECT_TRUE(ip_address2.AssignFromIPLiteral("2001:db8:0::42"));
471 EXPECT_TRUE(ip_address1 < ip_address2);
472 EXPECT_FALSE(ip_address2 < ip_address1);
473
474 // Compare equivalent addresses.
475 IPAddress ip_address3;
476 EXPECT_TRUE(ip_address3.AssignFromIPLiteral("127.0.0.1"));
477 EXPECT_FALSE(ip_address1 < ip_address3);
478 EXPECT_FALSE(ip_address3 < ip_address1);
479
480 IPAddress ip_address4;
481 EXPECT_TRUE(ip_address4.AssignFromIPLiteral("128.0.0.0"));
482 EXPECT_TRUE(ip_address1 < ip_address4);
483 EXPECT_FALSE(ip_address4 < ip_address1);
484 }
485
486 // Test mapping an IPv4 address to an IPv6 address.
TEST(IPAddressTest,ConvertIPv4ToIPv4MappedIPv6)487 TEST(IPAddressTest, ConvertIPv4ToIPv4MappedIPv6) {
488 IPAddress ipv4_address(192, 168, 0, 1);
489 IPAddress ipv6_address = ConvertIPv4ToIPv4MappedIPv6(ipv4_address);
490
491 // ::ffff:192.168.0.1
492 EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
493 DumpIPAddress(ipv6_address));
494 EXPECT_EQ("::ffff:c0a8:1", ipv6_address.ToString());
495 }
496
497 // Test reversal of a IPv6 address mapping.
TEST(IPAddressTest,ConvertIPv4MappedIPv6ToIPv4)498 TEST(IPAddressTest, ConvertIPv4MappedIPv6ToIPv4) {
499 IPAddress ipv4mapped_address;
500 EXPECT_TRUE(ipv4mapped_address.AssignFromIPLiteral("::ffff:c0a8:1"));
501
502 IPAddress expected(192, 168, 0, 1);
503
504 IPAddress result = ConvertIPv4MappedIPv6ToIPv4(ipv4mapped_address);
505 EXPECT_EQ(expected, result);
506 }
507
TEST(IPAddressTest,IPAddressMatchesPrefix)508 TEST(IPAddressTest, IPAddressMatchesPrefix) {
509 struct {
510 const char* const cidr_literal;
511 size_t prefix_length_in_bits;
512 const char* const ip_literal;
513 bool expected_to_match;
514 } tests[] = {
515 // IPv4 prefix with IPv4 inputs.
516 {"10.10.1.32", 27, "10.10.1.44", true},
517 {"10.10.1.32", 27, "10.10.1.90", false},
518 {"10.10.1.32", 27, "10.10.1.90", false},
519
520 // IPv6 prefix with IPv6 inputs.
521 {"2001:db8::", 32, "2001:DB8:3:4::5", true},
522 {"2001:db8::", 32, "2001:c8::", false},
523
524 // IPv6 prefix with IPv4 inputs.
525 {"2001:db8::", 33, "192.168.0.1", false},
526 {"::ffff:192.168.0.1", 112, "192.168.33.77", true},
527
528 // IPv4 prefix with IPv6 inputs.
529 {"10.11.33.44", 16, "::ffff:0a0b:89", true},
530 {"10.11.33.44", 16, "::ffff:10.12.33.44", false},
531 };
532 for (const auto& test : tests) {
533 SCOPED_TRACE(
534 base::StringPrintf("%s, %s", test.cidr_literal, test.ip_literal));
535
536 IPAddress ip_address;
537 EXPECT_TRUE(ip_address.AssignFromIPLiteral(test.ip_literal));
538
539 IPAddress ip_prefix;
540 EXPECT_TRUE(ip_prefix.AssignFromIPLiteral(test.cidr_literal));
541
542 EXPECT_EQ(test.expected_to_match,
543 IPAddressMatchesPrefix(ip_address, ip_prefix,
544 test.prefix_length_in_bits));
545 }
546 }
547
548 // Test parsing invalid CIDR notation literals.
TEST(IPAddressTest,ParseCIDRBlock_Invalid)549 TEST(IPAddressTest, ParseCIDRBlock_Invalid) {
550 const char* const bad_literals[] = {"foobar",
551 "",
552 "192.168.0.1",
553 "::1",
554 "/",
555 "/1",
556 "1",
557 "192.168.1.1/-1",
558 "192.168.1.1/33",
559 "::1/-3",
560 "a::3/129",
561 "::1/x",
562 "192.168.0.1//11",
563 "192.168.1.1/+1",
564 "192.168.1.1/ +1",
565 "192.168.1.1/"};
566
567 for (auto* bad_literal : bad_literals) {
568 IPAddress ip_address;
569 size_t prefix_length_in_bits;
570
571 EXPECT_FALSE(
572 ParseCIDRBlock(bad_literal, &ip_address, &prefix_length_in_bits));
573 }
574 }
575
576 // Test parsing a valid CIDR notation literal.
TEST(IPAddressTest,ParseCIDRBlock_Valid)577 TEST(IPAddressTest, ParseCIDRBlock_Valid) {
578 IPAddress ip_address;
579 size_t prefix_length_in_bits;
580
581 EXPECT_TRUE(
582 ParseCIDRBlock("192.168.0.1/11", &ip_address, &prefix_length_in_bits));
583
584 EXPECT_EQ("192,168,0,1", DumpIPAddress(ip_address));
585 EXPECT_EQ(11u, prefix_length_in_bits);
586
587 EXPECT_TRUE(ParseCIDRBlock("::ffff:192.168.0.1/112", &ip_address,
588 &prefix_length_in_bits));
589
590 EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
591 DumpIPAddress(ip_address));
592 EXPECT_EQ(112u, prefix_length_in_bits);
593 }
594
TEST(IPAddressTest,ParseURLHostnameToAddress_FailParse)595 TEST(IPAddressTest, ParseURLHostnameToAddress_FailParse) {
596 IPAddress address;
597 EXPECT_FALSE(ParseURLHostnameToAddress("bad value", &address));
598 EXPECT_FALSE(ParseURLHostnameToAddress("bad:value", &address));
599 EXPECT_FALSE(ParseURLHostnameToAddress(std::string(), &address));
600 EXPECT_FALSE(ParseURLHostnameToAddress("192.168.0.1:30", &address));
601 EXPECT_FALSE(ParseURLHostnameToAddress(" 192.168.0.1 ", &address));
602 EXPECT_FALSE(ParseURLHostnameToAddress("::1", &address));
603 EXPECT_FALSE(ParseURLHostnameToAddress("[192.169.0.1]", &address));
604 }
605
TEST(IPAddressTest,ParseURLHostnameToAddress_IPv4)606 TEST(IPAddressTest, ParseURLHostnameToAddress_IPv4) {
607 IPAddress address;
608 EXPECT_TRUE(ParseURLHostnameToAddress("192.168.0.1", &address));
609 EXPECT_EQ("192,168,0,1", DumpIPAddress(address));
610 EXPECT_EQ("192.168.0.1", address.ToString());
611 }
612
TEST(IPAddressTest,ParseURLHostnameToAddress_IPv6)613 TEST(IPAddressTest, ParseURLHostnameToAddress_IPv6) {
614 IPAddress address;
615 EXPECT_TRUE(ParseURLHostnameToAddress("[1:abcd::3:4:ff]", &address));
616 EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPAddress(address));
617 EXPECT_EQ("1:abcd::3:4:ff", address.ToString());
618 }
619
TEST(IPAddressTest,IPAddressStartsWith)620 TEST(IPAddressTest, IPAddressStartsWith) {
621 IPAddress ipv4_address(192, 168, 10, 5);
622
623 uint8_t ipv4_prefix1[] = {192, 168, 10};
624 EXPECT_TRUE(IPAddressStartsWith(ipv4_address, ipv4_prefix1));
625
626 uint8_t ipv4_prefix3[] = {192, 168, 10, 5};
627 EXPECT_TRUE(IPAddressStartsWith(ipv4_address, ipv4_prefix3));
628
629 uint8_t ipv4_prefix2[] = {192, 168, 10, 10};
630 EXPECT_FALSE(IPAddressStartsWith(ipv4_address, ipv4_prefix2));
631
632 // Prefix is longer than the address.
633 uint8_t ipv4_prefix4[] = {192, 168, 10, 10, 0};
634 EXPECT_FALSE(IPAddressStartsWith(ipv4_address, ipv4_prefix4));
635
636 IPAddress ipv6_address;
637 EXPECT_TRUE(ipv6_address.AssignFromIPLiteral("2a00:1450:400c:c09::64"));
638
639 uint8_t ipv6_prefix1[] = {42, 0, 20, 80, 64, 12, 12, 9};
640 EXPECT_TRUE(IPAddressStartsWith(ipv6_address, ipv6_prefix1));
641
642 uint8_t ipv6_prefix2[] = {41, 0, 20, 80, 64, 12, 12, 9,
643 0, 0, 0, 0, 0, 0, 100};
644 EXPECT_FALSE(IPAddressStartsWith(ipv6_address, ipv6_prefix2));
645
646 uint8_t ipv6_prefix3[] = {42, 0, 20, 80, 64, 12, 12, 9,
647 0, 0, 0, 0, 0, 0, 0, 100};
648 EXPECT_TRUE(IPAddressStartsWith(ipv6_address, ipv6_prefix3));
649
650 uint8_t ipv6_prefix4[] = {42, 0, 20, 80, 64, 12, 12, 9,
651 0, 0, 0, 0, 0, 0, 0, 0};
652 EXPECT_FALSE(IPAddressStartsWith(ipv6_address, ipv6_prefix4));
653
654 // Prefix is longer than the address.
655 uint8_t ipv6_prefix5[] = {42, 0, 20, 80, 64, 12, 12, 9, 0,
656 0, 0, 0, 0, 0, 0, 0, 10};
657 EXPECT_FALSE(IPAddressStartsWith(ipv6_address, ipv6_prefix5));
658 }
659
TEST(IPAddressTest,IsLinkLocal)660 TEST(IPAddressTest, IsLinkLocal) {
661 const char* kPositive[] = {
662 "169.254.0.0",
663 "169.254.100.1",
664 "169.254.100.1",
665 "::ffff:169.254.0.0",
666 "::ffff:169.254.100.1",
667 "fe80::1",
668 "fe81::1",
669 };
670
671 for (const char* literal : kPositive) {
672 IPAddress ip_address;
673 ASSERT_TRUE(ip_address.AssignFromIPLiteral(literal));
674 EXPECT_TRUE(ip_address.IsLinkLocal()) << literal;
675 }
676
677 const char* kNegative[] = {
678 "170.254.0.0", "169.255.0.0", "::169.254.0.0",
679 "::fffe:169.254.0.0", "::ffff:169.255.0.0", "fec0::1",
680 };
681
682 for (const char* literal : kNegative) {
683 IPAddress ip_address;
684 ASSERT_TRUE(ip_address.AssignFromIPLiteral(literal));
685 EXPECT_FALSE(ip_address.IsLinkLocal()) << literal;
686 }
687 }
688
TEST(IPAddressTest,IsUniqueLocalIPv6)689 TEST(IPAddressTest, IsUniqueLocalIPv6) {
690 const char* kPositive[] = {
691 "fc00::1",
692 "fc80::1",
693 "fd00::1",
694 };
695
696 for (const char* literal : kPositive) {
697 IPAddress ip_address;
698 ASSERT_TRUE(ip_address.AssignFromIPLiteral(literal));
699 EXPECT_TRUE(ip_address.IsUniqueLocalIPv6()) << literal;
700 }
701
702 const char* kNegative[] = {
703 "fe00::1",
704 "ff00::1",
705 "252.0.0.1",
706 };
707
708 for (const char* literal : kNegative) {
709 IPAddress ip_address;
710 ASSERT_TRUE(ip_address.AssignFromIPLiteral(literal));
711 EXPECT_FALSE(ip_address.IsUniqueLocalIPv6()) << literal;
712 }
713 }
714
715 // Tests extraction of the NAT64 translation prefix.
TEST(IPAddressTest,ExtractPref64FromIpv4onlyArpaAAAA)716 TEST(IPAddressTest, ExtractPref64FromIpv4onlyArpaAAAA) {
717 // Well Known Prefix 64:ff9b::/96.
718 IPAddress ipv6_address_WKP_0(0, 100, 255, 155, 0, 0, 0, 0, 0, 0, 0, 0, 192, 0,
719 0, 170);
720 IPAddress ipv6_address_WKP_1(0, 100, 255, 155, 0, 0, 0, 0, 0, 0, 0, 0, 192, 0,
721 0, 171);
722 Dns64PrefixLength pref64_length_WKP_0 =
723 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_WKP_0);
724 Dns64PrefixLength pref64_length_WKP_1 =
725 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_WKP_1);
726 EXPECT_EQ(Dns64PrefixLength::k96bit, pref64_length_WKP_0);
727 EXPECT_EQ(Dns64PrefixLength::k96bit, pref64_length_WKP_1);
728
729 // Prefix length 96
730 IPAddress ipv6_address_96_0(32, 1, 13, 184, 1, 34, 3, 68, 0, 0, 0, 0, 192, 0,
731 0, 170);
732 IPAddress ipv6_address_96_1(32, 1, 13, 184, 1, 34, 3, 68, 0, 0, 0, 0, 192, 0,
733 0, 171);
734 Dns64PrefixLength pref64_length_96_0 =
735 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_96_0);
736 Dns64PrefixLength pref64_length_96_1 =
737 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_96_1);
738 EXPECT_EQ(Dns64PrefixLength::k96bit, pref64_length_96_0);
739 EXPECT_EQ(Dns64PrefixLength::k96bit, pref64_length_96_1);
740
741 // Prefix length 64
742 IPAddress ipv6_address_64_0(32, 1, 13, 184, 1, 34, 3, 68, 0, 192, 0, 0, 170,
743 0, 0, 0);
744 IPAddress ipv6_address_64_1(32, 1, 13, 184, 1, 34, 3, 68, 0, 192, 0, 0, 171,
745 0, 0, 0);
746 Dns64PrefixLength pref64_length_64_0 =
747 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_64_0);
748 Dns64PrefixLength pref64_length_64_1 =
749 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_64_1);
750 EXPECT_EQ(Dns64PrefixLength::k64bit, pref64_length_64_0);
751 EXPECT_EQ(Dns64PrefixLength::k64bit, pref64_length_64_1);
752
753 // Prefix length 56
754 IPAddress ipv6_address_56_0(32, 1, 13, 184, 1, 34, 3, 192, 0, 0, 0, 170, 0, 0,
755 0, 0);
756 IPAddress ipv6_address_56_1(32, 1, 13, 184, 1, 34, 3, 192, 0, 0, 0, 171, 0, 0,
757 0, 0);
758 Dns64PrefixLength pref64_length_56_0 =
759 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_56_0);
760 Dns64PrefixLength pref64_length_56_1 =
761 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_56_1);
762 EXPECT_EQ(Dns64PrefixLength::k56bit, pref64_length_56_0);
763 EXPECT_EQ(Dns64PrefixLength::k56bit, pref64_length_56_1);
764
765 // Prefix length 48
766 IPAddress ipv6_address_48_0(32, 1, 13, 184, 1, 34, 192, 0, 0, 0, 170, 0, 0, 0,
767 0, 0);
768 IPAddress ipv6_address_48_1(32, 1, 13, 184, 1, 34, 192, 0, 0, 0, 171, 0, 0, 0,
769 0, 0);
770 Dns64PrefixLength pref64_length_48_0 =
771 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_48_0);
772 Dns64PrefixLength pref64_length_48_1 =
773 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_48_1);
774 EXPECT_EQ(Dns64PrefixLength::k48bit, pref64_length_48_0);
775 EXPECT_EQ(Dns64PrefixLength::k48bit, pref64_length_48_1);
776
777 // Prefix length 40
778 IPAddress ipv6_address_40_0(32, 1, 13, 184, 1, 192, 0, 0, 0, 170, 0, 0, 0, 0,
779 0, 0);
780 IPAddress ipv6_address_40_1(32, 1, 13, 184, 1, 192, 0, 0, 0, 171, 0, 0, 0, 0,
781 0, 0);
782 Dns64PrefixLength pref64_length_40_0 =
783 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_40_0);
784 Dns64PrefixLength pref64_length_40_1 =
785 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_40_1);
786 EXPECT_EQ(Dns64PrefixLength::k40bit, pref64_length_40_0);
787 EXPECT_EQ(Dns64PrefixLength::k40bit, pref64_length_40_1);
788
789 // Prefix length 32
790 IPAddress ipv6_address_32_0(32, 1, 13, 184, 192, 0, 0, 170, 0, 0, 0, 0, 0, 0,
791 0, 0);
792 IPAddress ipv6_address_32_1(32, 1, 13, 184, 192, 0, 0, 171, 0, 0, 0, 0, 0, 0,
793 0, 0);
794 Dns64PrefixLength pref64_length_32_0 =
795 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_32_0);
796 Dns64PrefixLength pref64_length_32_1 =
797 ExtractPref64FromIpv4onlyArpaAAAA(ipv6_address_32_1);
798 EXPECT_EQ(Dns64PrefixLength::k32bit, pref64_length_32_0);
799 EXPECT_EQ(Dns64PrefixLength::k32bit, pref64_length_32_1);
800 }
801
802 // Tests mapping an IPv4 address to an IPv6 address.
TEST(IPAddressTest,ConvertIPv4ToIPv4EmbeddedIPv6)803 TEST(IPAddressTest, ConvertIPv4ToIPv4EmbeddedIPv6) {
804 IPAddress ipv4_address(192, 0, 2, 33);
805
806 // Well Known Prefix 64:ff9b::/96.
807 IPAddress ipv6_address_WKP(0, 100, 255, 155, 0, 0, 0, 0, 0, 0, 0, 0, 192, 0,
808 0, 170);
809 IPAddress converted_ipv6_address_WKP = ConvertIPv4ToIPv4EmbeddedIPv6(
810 ipv4_address, ipv6_address_WKP, Dns64PrefixLength::k96bit);
811 EXPECT_EQ("0,100,255,155,0,0,0,0,0,0,0,0,192,0,2,33",
812 DumpIPAddress(converted_ipv6_address_WKP));
813 EXPECT_EQ("64:ff9b::c000:221", converted_ipv6_address_WKP.ToString());
814
815 // Prefix length 96
816 IPAddress ipv6_address_96(32, 1, 13, 184, 1, 34, 3, 68, 0, 0, 0, 0, 0, 0, 0,
817 0);
818 IPAddress converted_ipv6_address_96 = ConvertIPv4ToIPv4EmbeddedIPv6(
819 ipv4_address, ipv6_address_96, Dns64PrefixLength::k96bit);
820 EXPECT_EQ("32,1,13,184,1,34,3,68,0,0,0,0,192,0,2,33",
821 DumpIPAddress(converted_ipv6_address_96));
822 EXPECT_EQ("2001:db8:122:344::c000:221", converted_ipv6_address_96.ToString());
823
824 // Prefix length 64
825 IPAddress ipv6_address_64(32, 1, 13, 184, 1, 34, 3, 68, 0, 0, 0, 0, 0, 0, 0,
826 0);
827 IPAddress converted_ipv6_address_64 = ConvertIPv4ToIPv4EmbeddedIPv6(
828 ipv4_address, ipv6_address_64, Dns64PrefixLength::k64bit);
829 EXPECT_EQ("32,1,13,184,1,34,3,68,0,192,0,2,33,0,0,0",
830 DumpIPAddress(converted_ipv6_address_64));
831 EXPECT_EQ("2001:db8:122:344:c0:2:2100:0",
832 converted_ipv6_address_64.ToString());
833
834 // Prefix length 56
835 IPAddress ipv6_address_56(32, 1, 13, 184, 1, 34, 3, 0, 0, 0, 0, 0, 0, 0, 0,
836 0);
837 IPAddress converted_ipv6_address_56 = ConvertIPv4ToIPv4EmbeddedIPv6(
838 ipv4_address, ipv6_address_56, Dns64PrefixLength::k56bit);
839 EXPECT_EQ("32,1,13,184,1,34,3,192,0,0,2,33,0,0,0,0",
840 DumpIPAddress(converted_ipv6_address_56));
841 EXPECT_EQ("2001:db8:122:3c0:0:221::", converted_ipv6_address_56.ToString());
842
843 // Prefix length 48
844 IPAddress ipv6_address_48(32, 1, 13, 184, 1, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0,
845 0);
846 IPAddress converted_ipv6_address_48 = ConvertIPv4ToIPv4EmbeddedIPv6(
847 ipv4_address, ipv6_address_48, Dns64PrefixLength::k48bit);
848 EXPECT_EQ("32,1,13,184,1,34,192,0,0,2,33,0,0,0,0,0",
849 DumpIPAddress(converted_ipv6_address_48));
850 EXPECT_EQ("2001:db8:122:c000:2:2100::", converted_ipv6_address_48.ToString());
851
852 // Prefix length 40
853 IPAddress ipv6_address_40(32, 1, 13, 184, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
854 IPAddress converted_ipv6_address_40 = ConvertIPv4ToIPv4EmbeddedIPv6(
855 ipv4_address, ipv6_address_40, Dns64PrefixLength::k40bit);
856 EXPECT_EQ("32,1,13,184,1,192,0,2,0,33,0,0,0,0,0,0",
857 DumpIPAddress(converted_ipv6_address_40));
858 EXPECT_EQ("2001:db8:1c0:2:21::", converted_ipv6_address_40.ToString());
859
860 // Prefix length 32
861 IPAddress ipv6_address_32(32, 1, 13, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
862 IPAddress converted_ipv6_address_32 = ConvertIPv4ToIPv4EmbeddedIPv6(
863 ipv4_address, ipv6_address_32, Dns64PrefixLength::k32bit);
864 EXPECT_EQ("32,1,13,184,192,0,2,33,0,0,0,0,0,0,0,0",
865 DumpIPAddress(converted_ipv6_address_32));
866 EXPECT_EQ("2001:db8:c000:221::", converted_ipv6_address_32.ToString());
867 }
868
TEST(IPAddressTest,RoundtripAddressThroughValue)869 TEST(IPAddressTest, RoundtripAddressThroughValue) {
870 IPAddress address(1, 2, 3, 4);
871 ASSERT_TRUE(address.IsValid());
872
873 base::Value value = address.ToValue();
874 EXPECT_THAT(IPAddress::FromValue(value), Optional(address));
875 }
876
TEST(IPAddressTest,FromGarbageValue)877 TEST(IPAddressTest, FromGarbageValue) {
878 base::Value value(123);
879 EXPECT_FALSE(IPAddress::FromValue(value).has_value());
880 }
881
TEST(IPAddressTest,FromInvalidValue)882 TEST(IPAddressTest, FromInvalidValue) {
883 base::Value value("1.2.3.4.5");
884 EXPECT_FALSE(IPAddress::FromValue(value).has_value());
885 }
886
TEST(IPAddressTest,IPv4Mask)887 TEST(IPAddressTest, IPv4Mask) {
888 IPAddress mask;
889 EXPECT_FALSE(
890 IPAddress::CreateIPv4Mask(&mask, IPAddress::kIPv6AddressSize * 8));
891 EXPECT_FALSE(
892 IPAddress::CreateIPv4Mask(&mask, (IPAddress::kIPv4AddressSize + 1) * 8));
893 EXPECT_FALSE(
894 IPAddress::CreateIPv4Mask(&mask, IPAddress::kIPv4AddressSize * 8 + 1));
895 EXPECT_TRUE(
896 IPAddress::CreateIPv4Mask(&mask, IPAddress::kIPv4AddressSize * 8));
897 EXPECT_EQ("255.255.255.255", mask.ToString());
898 EXPECT_TRUE(IPAddress::CreateIPv4Mask(&mask, 31));
899 EXPECT_EQ("255.255.255.254", mask.ToString());
900 EXPECT_TRUE(IPAddress::CreateIPv4Mask(&mask, 24));
901 EXPECT_EQ("255.255.255.0", mask.ToString());
902 EXPECT_TRUE(IPAddress::CreateIPv4Mask(&mask, 23));
903 EXPECT_EQ("255.255.254.0", mask.ToString());
904 EXPECT_TRUE(IPAddress::CreateIPv4Mask(&mask, 18));
905 EXPECT_EQ("255.255.192.0", mask.ToString());
906 EXPECT_TRUE(IPAddress::CreateIPv4Mask(&mask, 16));
907 EXPECT_EQ("255.255.0.0", mask.ToString());
908 EXPECT_TRUE(IPAddress::CreateIPv4Mask(&mask, 8));
909 EXPECT_EQ("255.0.0.0", mask.ToString());
910 EXPECT_TRUE(IPAddress::CreateIPv4Mask(&mask, 1));
911 EXPECT_EQ("128.0.0.0", mask.ToString());
912 EXPECT_TRUE(IPAddress::CreateIPv4Mask(&mask, 0));
913 EXPECT_EQ("0.0.0.0", mask.ToString());
914 }
915
TEST(IPAddressTest,IPv6Mask)916 TEST(IPAddressTest, IPv6Mask) {
917 IPAddress mask;
918 EXPECT_FALSE(
919 IPAddress::CreateIPv6Mask(&mask, (IPAddress::kIPv6AddressSize * 8) + 1));
920 EXPECT_TRUE(
921 IPAddress::CreateIPv6Mask(&mask, IPAddress::kIPv6AddressSize * 8));
922 EXPECT_EQ("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", mask.ToString());
923 EXPECT_TRUE(IPAddress::CreateIPv6Mask(&mask, 112));
924 EXPECT_EQ("ffff:ffff:ffff:ffff:ffff:ffff:ffff:0", mask.ToString());
925 EXPECT_TRUE(IPAddress::CreateIPv6Mask(&mask, 32));
926 EXPECT_EQ("ffff:ffff::", mask.ToString());
927 EXPECT_TRUE(IPAddress::CreateIPv6Mask(&mask, 1));
928 EXPECT_EQ("8000::", mask.ToString());
929 EXPECT_TRUE(IPAddress::CreateIPv6Mask(&mask, 0));
930 EXPECT_EQ("::", mask.ToString());
931 }
932
933 } // anonymous namespace
934
935 } // namespace net
936