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