src/third_party/libjingle/source/talk/base/ipaddress_unittest.cc

   1 /*
   2  * libjingle
   3  * Copyright 2004--2011, Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "talk/base/gunit.h"
  29 #include "talk/base/ipaddress.h"
  30
  31 namespace talk_base {
  32
  33 static const unsigned int kIPv4AddrSize = 4;
  34 static const unsigned int kIPv6AddrSize = 16;
  35 static const unsigned int kIPv4RFC1918Addr = 0xC0A80701;
  36 static const unsigned int kIPv4PublicAddr = 0x01020304;
  37 static const in6_addr kIPv6LinkLocalAddr = {{{0xfe, 0x80, 0x00, 0x00,
  38                                               0x00, 0x00, 0x00, 0x00,
  39                                               0xbe, 0x30, 0x5b, 0xff,
  40                                               0xfe, 0xe5, 0x00, 0xc3}}};
  41 static const in6_addr kIPv6PublicAddr = {{{0x24, 0x01, 0xfa, 0x00,
  42                                            0x00, 0x04, 0x10, 0x00,
  43                                            0xbe, 0x30, 0x5b, 0xff,
  44                                            0xfe, 0xe5, 0x00, 0xc3}}};
  45 static const in6_addr kIPv6CompatAddr = {{{0x00, 0x00, 0x00, 0x00,
  46                                            0x00, 0x00, 0x00, 0x00,
  47                                            0x00, 0x00, 0x00, 0x00,
  48                                            0xfe, 0xe5, 0x00, 0xc3}}};
  49 static const in6_addr kIPv4MappedAnyAddr = {{{0x00, 0x00, 0x00, 0x00,
  50                                               0x00, 0x00, 0x00, 0x00,
  51                                               0x00, 0x00, 0xff, 0xff,
  52                                               0x00, 0x00, 0x00, 0x00}}};
  53 static const in6_addr kIPv4MappedLoopbackAddr = {{{0x00, 0x00, 0x00, 0x00,
  54                                                    0x00, 0x00, 0x00, 0x00,
  55                                                    0x00, 0x00, 0xff, 0xff,
  56                                                    0x7f, 0x00, 0x00, 0x01}}};
  57 static const in6_addr kIPv4MappedRFC1918Addr = {{{0x00, 0x00, 0x00, 0x00,
  58                                                   0x00, 0x00, 0x00, 0x00,
  59                                                   0x00, 0x00, 0xff, 0xff,
  60                                                   0xc0, 0xa8, 0x07, 0x01}}};
  61 static const in6_addr kIPv4MappedPublicAddr = {{{0x00, 0x00, 0x00, 0x00,
  62                                                  0x00, 0x00, 0x00, 0x00,
  63                                                  0x00, 0x00, 0xff, 0xff,
  64                                                  0x01, 0x02, 0x03, 0x04}}};
  65 static const in6_addr kIPv6AllNodes = {{{0xff, 0x02, 0x00, 0x00,
  66                                          0x00, 0x00, 0x00, 0x00,
  67                                          0x00, 0x00, 0x00, 0x00,
  68                                          0x00, 0x00, 0x00, 0x01}}};
  69
  70 static const std::string kIPv4AnyAddrString = "0.0.0.0";
  71 static const std::string kIPv4LoopbackAddrString = "127.0.0.1";
  72 static const std::string kIPv4RFC1918AddrString = "192.168.7.1";
  73 static const std::string kIPv4PublicAddrString = "1.2.3.4";
  74 static const std::string kIPv4PublicAddrAnonymizedString = "1.2.3.x";
  75 static const std::string kIPv6AnyAddrString = "::";
  76 static const std::string kIPv6LoopbackAddrString = "::1";
  77 static const std::string kIPv6LinkLocalAddrString = "fe80::be30:5bff:fee5:c3";
  78 static const std::string kIPv6PublicAddrString =
  79     "2401:fa00:4:1000:be30:5bff:fee5:c3";
  80 static const std::string kIPv6PublicAddrAnonymizedString = "2401:fa00:4::";
  81 static const std::string kIPv4MappedAnyAddrString = "::ffff:0:0";
  82 static const std::string kIPv4MappedRFC1918AddrString = "::ffff:c0a8:701";
  83 static const std::string kIPv4MappedLoopbackAddrString = "::ffff:7f00:1";
  84 static const std::string kIPv4MappedPublicAddrString = "::ffff:102:0304";
  85 static const std::string kIPv4MappedV4StyleAddrString = "::ffff:192.168.7.1";
  86
  87 static const std::string kIPv4BrokenString1 = "192.168.7.";
  88 static const std::string kIPv4BrokenString2 = "192.168.7.1.1";
  89 static const std::string kIPv4BrokenString3 = "192.168.7.1:80";
  90 static const std::string kIPv4BrokenString4 = "192.168.7.ONE";
  91 static const std::string kIPv4BrokenString5 = "-192.168.7.1";
  92 static const std::string kIPv4BrokenString6 = "256.168.7.1";
  93 static const std::string kIPv6BrokenString1 = "2401:fa00:4:1000:be30";
  94 static const std::string kIPv6BrokenString2 =
  95     "2401:fa00:4:1000:be30:5bff:fee5:c3:1";
  96 static const std::string kIPv6BrokenString3 =
  97     "[2401:fa00:4:1000:be30:5bff:fee5:c3]:1";
  98 static const std::string kIPv6BrokenString4 =
  99     "2401::4::be30";
 100 static const std::string kIPv6BrokenString5 =
 101     "2401:::4:fee5:be30";
 102 static const std::string kIPv6BrokenString6 =
 103     "2401f:fa00:4:1000:be30:5bff:fee5:c3";
 104 static const std::string kIPv6BrokenString7 =
 105     "2401:ga00:4:1000:be30:5bff:fee5:c3";
 106 static const std::string kIPv6BrokenString8 =
 107     "2401:fa000:4:1000:be30:5bff:fee5:c3";
 108 static const std::string kIPv6BrokenString9 =
 109     "2401:fal0:4:1000:be30:5bff:fee5:c3";
 110 static const std::string kIPv6BrokenString10 =
 111     "::ffff:192.168.7.";
 112 static const std::string kIPv6BrokenString11 =
 113     "::ffff:192.168.7.1.1.1";
 114 static const std::string kIPv6BrokenString12 =
 115     "::fffe:192.168.7.1";
 116 static const std::string kIPv6BrokenString13 =
 117     "::ffff:192.168.7.ff";
 118 static const std::string kIPv6BrokenString14 =
 119     "0x2401:fa00:4:1000:be30:5bff:fee5:c3";
 120
 121 bool AreEqual(const IPAddress& addr,
 122               const IPAddress& addr2) {
 123   if ((IPIsAny(addr) != IPIsAny(addr2)) ||
 124       (IPIsLoopback(addr) != IPIsLoopback(addr2)) ||
 125       (IPIsPrivate(addr) != IPIsPrivate(addr2)) ||
 126       (HashIP(addr) != HashIP(addr2)) ||
 127       (addr.Size() != addr2.Size()) ||
 128       (addr.family() != addr2.family()) ||
 129       (addr.ToString() != addr2.ToString())) {
 130     return false;
 131   }
 132   in_addr v4addr, v4addr2;
 133   v4addr = addr.ipv4_address();
 134   v4addr2 = addr2.ipv4_address();
 135   if (0 != memcmp(&v4addr, &v4addr2, sizeof(v4addr))) {
 136     return false;
 137   }
 138   in6_addr v6addr, v6addr2;
 139   v6addr = addr.ipv6_address();
 140   v6addr2 = addr2.ipv6_address();
 141   if (0 != memcmp(&v6addr, &v6addr2, sizeof(v6addr))) {
 142     return false;
 143   }
 144   return true;
 145 }
 146
 147 bool BrokenIPStringFails(const std::string& broken) {
 148   IPAddress addr(0);   // Intentionally make it v4.
 149   if (IPFromString(kIPv4BrokenString1, &addr)) {
 150     return false;
 151   }
 152   return addr.family() == AF_UNSPEC;
 153 }
 154
 155 bool CheckMaskCount(const std::string& mask, int expected_length) {
 156   IPAddress addr;
 157   return IPFromString(mask, &addr) &&
 158       (expected_length == CountIPMaskBits(addr));
 159 }
 160
 161 bool TryInvalidMaskCount(const std::string& mask) {
 162   // We don't care about the result at all, but we do want to know if
 163   // CountIPMaskBits is going to crash or infinite loop or something.
 164   IPAddress addr;
 165   if (!IPFromString(mask, &addr)) {
 166     return false;
 167   }
 168   CountIPMaskBits(addr);
 169   return true;
 170 }
 171
 172 bool CheckTruncateIP(const std::string& initial, int truncate_length,
 173                      const std::string& expected_result) {
 174   IPAddress addr, expected;
 175   IPFromString(initial, &addr);
 176   IPFromString(expected_result, &expected);
 177   IPAddress truncated = TruncateIP(addr, truncate_length);
 178   return truncated == expected;
 179 }
 180
 181 TEST(IPAddressTest, TestDefaultCtor) {
 182   IPAddress addr;
 183   EXPECT_FALSE(IPIsAny(addr));
 184   EXPECT_FALSE(IPIsLoopback(addr));
 185   EXPECT_FALSE(IPIsPrivate(addr));
 186
 187   EXPECT_EQ(0U, addr.Size());
 188   EXPECT_EQ(AF_UNSPEC, addr.family());
 189   EXPECT_EQ("", addr.ToString());
 190 }
 191
 192 TEST(IPAddressTest, TestInAddrCtor) {
 193   in_addr v4addr;
 194
 195   // Test V4 Any address.
 196   v4addr.s_addr = INADDR_ANY;
 197   IPAddress addr(v4addr);
 198   EXPECT_TRUE(IPIsAny(addr));
 199   EXPECT_FALSE(IPIsLoopback(addr));
 200   EXPECT_FALSE(IPIsPrivate(addr));
 201   EXPECT_EQ(kIPv4AddrSize, addr.Size());
 202   EXPECT_EQ(kIPv4AnyAddrString, addr.ToString());
 203
 204   // Test a V4 loopback address.
 205   v4addr.s_addr = htonl(INADDR_LOOPBACK);
 206   addr = IPAddress(v4addr);
 207   EXPECT_FALSE(IPIsAny(addr));
 208   EXPECT_TRUE(IPIsLoopback(addr));
 209   EXPECT_TRUE(IPIsPrivate(addr));
 210   EXPECT_EQ(kIPv4AddrSize, addr.Size());
 211   EXPECT_EQ(kIPv4LoopbackAddrString, addr.ToString());
 212
 213   // Test an RFC1918 address.
 214   v4addr.s_addr = htonl(kIPv4RFC1918Addr);
 215   addr = IPAddress(v4addr);
 216   EXPECT_FALSE(IPIsAny(addr));
 217   EXPECT_FALSE(IPIsLoopback(addr));
 218   EXPECT_TRUE(IPIsPrivate(addr));
 219   EXPECT_EQ(kIPv4AddrSize, addr.Size());
 220   EXPECT_EQ(kIPv4RFC1918AddrString, addr.ToString());
 221
 222   // Test a 'normal' v4 address.
 223   v4addr.s_addr = htonl(kIPv4PublicAddr);
 224   addr = IPAddress(v4addr);
 225   EXPECT_FALSE(IPIsAny(addr));
 226   EXPECT_FALSE(IPIsLoopback(addr));
 227   EXPECT_FALSE(IPIsPrivate(addr));
 228   EXPECT_EQ(kIPv4AddrSize, addr.Size());
 229   EXPECT_EQ(kIPv4PublicAddrString, addr.ToString());
 230 }
 231
 232 TEST(IPAddressTest, TestInAddr6Ctor) {
 233   // Test v6 empty.
 234   IPAddress addr(in6addr_any);
 235   EXPECT_TRUE(IPIsAny(addr));
 236   EXPECT_FALSE(IPIsLoopback(addr));
 237   EXPECT_FALSE(IPIsPrivate(addr));
 238   EXPECT_EQ(kIPv6AddrSize, addr.Size());
 239   EXPECT_EQ(kIPv6AnyAddrString, addr.ToString());
 240
 241   // Test v6 loopback.
 242   addr = IPAddress(in6addr_loopback);
 243   EXPECT_FALSE(IPIsAny(addr));
 244   EXPECT_TRUE(IPIsLoopback(addr));
 245   EXPECT_TRUE(IPIsPrivate(addr));
 246   EXPECT_EQ(kIPv6AddrSize, addr.Size());
 247   EXPECT_EQ(kIPv6LoopbackAddrString, addr.ToString());
 248
 249   // Test v6 link-local.
 250   addr = IPAddress(kIPv6LinkLocalAddr);
 251   EXPECT_FALSE(IPIsAny(addr));
 252   EXPECT_FALSE(IPIsLoopback(addr));
 253   EXPECT_TRUE(IPIsPrivate(addr));
 254   EXPECT_EQ(kIPv6AddrSize, addr.Size());
 255   EXPECT_EQ(kIPv6LinkLocalAddrString, addr.ToString());
 256
 257   // Test v6 global address.
 258   addr = IPAddress(kIPv6PublicAddr);
 259   EXPECT_FALSE(IPIsAny(addr));
 260   EXPECT_FALSE(IPIsLoopback(addr));
 261   EXPECT_FALSE(IPIsPrivate(addr));
 262   EXPECT_EQ(kIPv6AddrSize, addr.Size());
 263   EXPECT_EQ(kIPv6PublicAddrString, addr.ToString());
 264 }
 265
 266 TEST(IPAddressTest, TestUint32Ctor) {
 267   // Test V4 Any address.
 268   IPAddress addr(0);
 269   EXPECT_TRUE(IPIsAny(addr));
 270   EXPECT_FALSE(IPIsLoopback(addr));
 271   EXPECT_FALSE(IPIsPrivate(addr));
 272   EXPECT_EQ(kIPv4AddrSize, addr.Size());
 273   EXPECT_EQ(kIPv4AnyAddrString, addr.ToString());
 274
 275   // Test a V4 loopback address.
 276   addr = IPAddress(INADDR_LOOPBACK);
 277   EXPECT_FALSE(IPIsAny(addr));
 278   EXPECT_TRUE(IPIsLoopback(addr));
 279   EXPECT_TRUE(IPIsPrivate(addr));
 280   EXPECT_EQ(kIPv4AddrSize, addr.Size());
 281   EXPECT_EQ(kIPv4LoopbackAddrString, addr.ToString());
 282
 283   // Test an RFC1918 address.
 284   addr = IPAddress(kIPv4RFC1918Addr);
 285   EXPECT_FALSE(IPIsAny(addr));
 286   EXPECT_FALSE(IPIsLoopback(addr));
 287   EXPECT_TRUE(IPIsPrivate(addr));
 288   EXPECT_EQ(kIPv4AddrSize, addr.Size());
 289   EXPECT_EQ(kIPv4RFC1918AddrString, addr.ToString());
 290
 291   // Test a 'normal' v4 address.
 292   addr = IPAddress(kIPv4PublicAddr);
 293   EXPECT_FALSE(IPIsAny(addr));
 294   EXPECT_FALSE(IPIsLoopback(addr));
 295   EXPECT_FALSE(IPIsPrivate(addr));
 296   EXPECT_EQ(kIPv4AddrSize, addr.Size());
 297   EXPECT_EQ(kIPv4PublicAddrString, addr.ToString());
 298 }
 299
 300 TEST(IPAddressTest, TestCopyCtor) {
 301   in_addr v4addr;
 302   v4addr.s_addr = htonl(kIPv4PublicAddr);
 303   IPAddress addr(v4addr);
 304   IPAddress addr2(addr);
 305
 306   EXPECT_PRED2(AreEqual, addr, addr2);
 307
 308   addr = IPAddress(INADDR_ANY);
 309   addr2 = IPAddress(addr);
 310   EXPECT_PRED2(AreEqual, addr, addr2);
 311
 312   addr = IPAddress(INADDR_LOOPBACK);
 313   addr2 = IPAddress(addr);
 314   EXPECT_PRED2(AreEqual, addr, addr2);
 315
 316   addr = IPAddress(kIPv4PublicAddr);
 317   addr2 = IPAddress(addr);
 318   EXPECT_PRED2(AreEqual, addr, addr2);
 319
 320   addr = IPAddress(kIPv4RFC1918Addr);
 321   addr2 = IPAddress(addr);
 322   EXPECT_PRED2(AreEqual, addr, addr2);
 323
 324   addr = IPAddress(in6addr_any);
 325   addr2 = IPAddress(addr);
 326   EXPECT_PRED2(AreEqual, addr, addr2);
 327
 328   addr = IPAddress(in6addr_loopback);
 329   addr2 = IPAddress(addr);
 330   EXPECT_PRED2(AreEqual, addr, addr2);
 331
 332   addr = IPAddress(kIPv6LinkLocalAddr);
 333   addr2 = IPAddress(addr);
 334   EXPECT_PRED2(AreEqual, addr, addr2);
 335
 336   addr = IPAddress(kIPv6PublicAddr);
 337   addr2 = IPAddress(addr);
 338   EXPECT_PRED2(AreEqual, addr, addr2);
 339 }
 340
 341 TEST(IPAddressTest, TestEquality) {
 342   // Check v4 equality
 343   in_addr v4addr, v4addr2;
 344   v4addr.s_addr = htonl(kIPv4PublicAddr);
 345   v4addr2.s_addr = htonl(kIPv4PublicAddr + 1);
 346   IPAddress addr(v4addr);
 347   IPAddress addr2(v4addr2);
 348   IPAddress addr3(v4addr);
 349
 350   EXPECT_TRUE(addr == addr);
 351   EXPECT_TRUE(addr2 == addr2);
 352   EXPECT_TRUE(addr3 == addr3);
 353   EXPECT_TRUE(addr == addr3);
 354   EXPECT_TRUE(addr3 == addr);
 355   EXPECT_FALSE(addr2 == addr);
 356   EXPECT_FALSE(addr2 == addr3);
 357   EXPECT_FALSE(addr == addr2);
 358   EXPECT_FALSE(addr3 == addr2);
 359
 360   // Check v6 equality
 361   IPAddress addr4(kIPv6PublicAddr);
 362   IPAddress addr5(kIPv6LinkLocalAddr);
 363   IPAddress addr6(kIPv6PublicAddr);
 364
 365   EXPECT_TRUE(addr4 == addr4);
 366   EXPECT_TRUE(addr5 == addr5);
 367   EXPECT_TRUE(addr4 == addr6);
 368   EXPECT_TRUE(addr6 == addr4);
 369   EXPECT_FALSE(addr4 == addr5);
 370   EXPECT_FALSE(addr5 == addr4);
 371   EXPECT_FALSE(addr6 == addr5);
 372   EXPECT_FALSE(addr5 == addr6);
 373
 374   // Check v4/v6 cross-equality
 375   EXPECT_FALSE(addr == addr4);
 376   EXPECT_FALSE(addr == addr5);
 377   EXPECT_FALSE(addr == addr6);
 378   EXPECT_FALSE(addr4 == addr);
 379   EXPECT_FALSE(addr5 == addr);
 380   EXPECT_FALSE(addr6 == addr);
 381   EXPECT_FALSE(addr2 == addr4);
 382   EXPECT_FALSE(addr2 == addr5);
 383   EXPECT_FALSE(addr2 == addr6);
 384   EXPECT_FALSE(addr4 == addr2);
 385   EXPECT_FALSE(addr5 == addr2);
 386   EXPECT_FALSE(addr6 == addr2);
 387   EXPECT_FALSE(addr3 == addr4);
 388   EXPECT_FALSE(addr3 == addr5);
 389   EXPECT_FALSE(addr3 == addr6);
 390   EXPECT_FALSE(addr4 == addr3);
 391   EXPECT_FALSE(addr5 == addr3);
 392   EXPECT_FALSE(addr6 == addr3);
 393
 394   // Special cases: loopback and any.
 395   // They're special but they're still not equal.
 396   IPAddress v4loopback(htonl(INADDR_LOOPBACK));
 397   IPAddress v6loopback(in6addr_loopback);
 398   EXPECT_FALSE(v4loopback == v6loopback);
 399
 400   IPAddress v4any(0);
 401   IPAddress v6any(in6addr_any);
 402   EXPECT_FALSE(v4any == v6any);
 403 }
 404
 405 TEST(IPAddressTest, TestComparison) {
 406   // Defined in 'ascending' order.
 407   // v6 > v4, and intra-family sorting is purely numerical
 408   IPAddress addr0;  // AF_UNSPEC
 409   IPAddress addr1(INADDR_ANY);  // 0.0.0.0
 410   IPAddress addr2(kIPv4PublicAddr);  // 1.2.3.4
 411   IPAddress addr3(INADDR_LOOPBACK);  // 127.0.0.1
 412   IPAddress addr4(kIPv4RFC1918Addr);  // 192.168.7.1.
 413   IPAddress addr5(in6addr_any);  // ::
 414   IPAddress addr6(in6addr_loopback);  // ::1
 415   IPAddress addr7(kIPv6PublicAddr);  // 2401....
 416   IPAddress addr8(kIPv6LinkLocalAddr);  // fe80....
 417
 418   EXPECT_TRUE(addr0 < addr1);
 419   EXPECT_TRUE(addr1 < addr2);
 420   EXPECT_TRUE(addr2 < addr3);
 421   EXPECT_TRUE(addr3 < addr4);
 422   EXPECT_TRUE(addr4 < addr5);
 423   EXPECT_TRUE(addr5 < addr6);
 424   EXPECT_TRUE(addr6 < addr7);
 425   EXPECT_TRUE(addr7 < addr8);
 426
 427   EXPECT_FALSE(addr0 > addr1);
 428   EXPECT_FALSE(addr1 > addr2);
 429   EXPECT_FALSE(addr2 > addr3);
 430   EXPECT_FALSE(addr3 > addr4);
 431   EXPECT_FALSE(addr4 > addr5);
 432   EXPECT_FALSE(addr5 > addr6);
 433   EXPECT_FALSE(addr6 > addr7);
 434   EXPECT_FALSE(addr7 > addr8);
 435
 436   EXPECT_FALSE(addr0 > addr0);
 437   EXPECT_FALSE(addr1 > addr1);
 438   EXPECT_FALSE(addr2 > addr2);
 439   EXPECT_FALSE(addr3 > addr3);
 440   EXPECT_FALSE(addr4 > addr4);
 441   EXPECT_FALSE(addr5 > addr5);
 442   EXPECT_FALSE(addr6 > addr6);
 443   EXPECT_FALSE(addr7 > addr7);
 444   EXPECT_FALSE(addr8 > addr8);
 445
 446   EXPECT_FALSE(addr0 < addr0);
 447   EXPECT_FALSE(addr1 < addr1);
 448   EXPECT_FALSE(addr2 < addr2);
 449   EXPECT_FALSE(addr3 < addr3);
 450   EXPECT_FALSE(addr4 < addr4);
 451   EXPECT_FALSE(addr5 < addr5);
 452   EXPECT_FALSE(addr6 < addr6);
 453   EXPECT_FALSE(addr7 < addr7);
 454   EXPECT_FALSE(addr8 < addr8);
 455 }
 456
 457 TEST(IPAddressTest, TestFromString) {
 458   IPAddress addr;
 459   IPAddress addr2;
 460   addr2 = IPAddress(INADDR_ANY);
 461
 462   EXPECT_TRUE(IPFromString(kIPv4AnyAddrString, &addr));
 463   EXPECT_EQ(addr.ToString(), kIPv4AnyAddrString);
 464   EXPECT_PRED2(AreEqual, addr, addr2);
 465
 466   addr2 = IPAddress(INADDR_LOOPBACK);
 467   EXPECT_TRUE(IPFromString(kIPv4LoopbackAddrString, &addr));
 468   EXPECT_EQ(addr.ToString(), kIPv4LoopbackAddrString);
 469   EXPECT_PRED2(AreEqual, addr, addr2);
 470
 471   addr2 = IPAddress(kIPv4RFC1918Addr);
 472   EXPECT_TRUE(IPFromString(kIPv4RFC1918AddrString, &addr));
 473   EXPECT_EQ(addr.ToString(), kIPv4RFC1918AddrString);
 474   EXPECT_PRED2(AreEqual, addr, addr2);
 475
 476   addr2 = IPAddress(kIPv4PublicAddr);
 477   EXPECT_TRUE(IPFromString(kIPv4PublicAddrString, &addr));
 478   EXPECT_EQ(addr.ToString(), kIPv4PublicAddrString);
 479   EXPECT_PRED2(AreEqual, addr, addr2);
 480
 481   addr2 = IPAddress(in6addr_any);
 482   EXPECT_TRUE(IPFromString(kIPv6AnyAddrString, &addr));
 483   EXPECT_EQ(addr.ToString(), kIPv6AnyAddrString);
 484   EXPECT_PRED2(AreEqual, addr, addr2);
 485
 486   addr2 = IPAddress(in6addr_loopback);
 487   EXPECT_TRUE(IPFromString(kIPv6LoopbackAddrString, &addr));
 488   EXPECT_EQ(addr.ToString(), kIPv6LoopbackAddrString);
 489   EXPECT_PRED2(AreEqual, addr, addr2);
 490
 491   addr2 = IPAddress(kIPv6LinkLocalAddr);
 492   EXPECT_TRUE(IPFromString(kIPv6LinkLocalAddrString, &addr));
 493   EXPECT_EQ(addr.ToString(), kIPv6LinkLocalAddrString);
 494   EXPECT_PRED2(AreEqual, addr, addr2);
 495
 496   addr2 = IPAddress(kIPv6PublicAddr);
 497   EXPECT_TRUE(IPFromString(kIPv6PublicAddrString, &addr));
 498   EXPECT_EQ(addr.ToString(), kIPv6PublicAddrString);
 499   EXPECT_PRED2(AreEqual, addr, addr2);
 500
 501   addr2 = IPAddress(kIPv4MappedRFC1918Addr);
 502   EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr));
 503   EXPECT_PRED2(AreEqual, addr, addr2);
 504
 505   // Broken cases, should set addr to AF_UNSPEC.
 506   EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString1);
 507   EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString2);
 508   EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString3);
 509   EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString4);
 510   EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString5);
 511   EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString6);
 512   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString1);
 513   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString2);
 514   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString3);
 515   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString4);
 516   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString5);
 517   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString6);
 518   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString7);
 519   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString8);
 520   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString9);
 521   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString10);
 522   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString11);
 523   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString12);
 524   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString13);
 525   EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString14);
 526 }
 527
 528 TEST(IPAddressTest, TestIPFromAddrInfo) {
 529   struct sockaddr_in expected4;
 530   struct sockaddr_in6 expected6;
 531   struct addrinfo test_info;
 532   struct addrinfo next_info;
 533   memset(&next_info, 'A', sizeof(next_info));
 534   test_info.ai_next = &next_info;
 535   // Check that we can get an IPv4 address out.
 536   test_info.ai_addr = reinterpret_cast<struct sockaddr*>(&expected4);
 537   expected4.sin_addr.s_addr = HostToNetwork32(kIPv4PublicAddr);
 538   expected4.sin_family = AF_INET;
 539   IPAddress expected(kIPv4PublicAddr);
 540   IPAddress addr;
 541   EXPECT_TRUE(IPFromAddrInfo(&test_info, &addr));
 542   EXPECT_EQ(expected, addr);
 543   // Check that we can get an IPv6 address out.
 544   expected6.sin6_addr = kIPv6PublicAddr;
 545   expected6.sin6_family = AF_INET6;
 546   expected = IPAddress(kIPv6PublicAddr);
 547   test_info.ai_addr = reinterpret_cast<struct sockaddr*>(&expected6);
 548   EXPECT_TRUE(IPFromAddrInfo(&test_info, &addr));
 549   EXPECT_EQ(expected, addr);
 550   // Check that unspec fails.
 551   expected6.sin6_family = AF_UNSPEC;
 552   EXPECT_FALSE(IPFromAddrInfo(&test_info, &addr));
 553   // Check a zeroed out addrinfo doesn't crash us.
 554   memset(&next_info, 0, sizeof(next_info));
 555   EXPECT_FALSE(IPFromAddrInfo(&next_info, &addr));
 556 }
 557
 558 TEST(IPAddressTest, TestIsPrivate) {
 559   EXPECT_FALSE(IPIsPrivate(IPAddress(INADDR_ANY)));
 560   EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4PublicAddr)));
 561   EXPECT_FALSE(IPIsPrivate(IPAddress(in6addr_any)));
 562   EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv6PublicAddr)));
 563   EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedAnyAddr)));
 564   EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedPublicAddr)));
 565
 566   EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv4RFC1918Addr)));
 567   EXPECT_TRUE(IPIsPrivate(IPAddress(INADDR_LOOPBACK)));
 568   EXPECT_TRUE(IPIsPrivate(IPAddress(in6addr_loopback)));
 569   EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv6LinkLocalAddr)));
 570 }
 571
 572 TEST(IPAddressTest, TestIsLoopback) {
 573   EXPECT_FALSE(IPIsLoopback(IPAddress(INADDR_ANY)));
 574   EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4PublicAddr)));
 575   EXPECT_FALSE(IPIsLoopback(IPAddress(in6addr_any)));
 576   EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv6PublicAddr)));
 577   EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedAnyAddr)));
 578   EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedPublicAddr)));
 579
 580   EXPECT_TRUE(IPIsLoopback(IPAddress(INADDR_LOOPBACK)));
 581   EXPECT_TRUE(IPIsLoopback(IPAddress(in6addr_loopback)));
 582 }
 583
 584 TEST(IPAddressTest, TestNormalized) {
 585   // Check normalizing a ::ffff:a.b.c.d address.
 586   IPAddress addr;
 587   EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr));
 588   IPAddress addr2(kIPv4RFC1918Addr);
 589   addr = addr.Normalized();
 590   EXPECT_EQ(addr2, addr);
 591
 592   // Check normalizing a ::ffff:aabb:ccdd address.
 593   addr = IPAddress(kIPv4MappedPublicAddr);
 594   addr2 = IPAddress(kIPv4PublicAddr);
 595   addr = addr.Normalized();
 596   EXPECT_EQ(addr, addr2);
 597
 598   // Check that a non-mapped v6 addresses isn't altered.
 599   addr = IPAddress(kIPv6PublicAddr);
 600   addr2 = IPAddress(kIPv6PublicAddr);
 601   addr = addr.Normalized();
 602   EXPECT_EQ(addr, addr2);
 603
 604   // Check that addresses that look a bit like mapped addresses aren't altered
 605   EXPECT_TRUE(IPFromString("fe80::ffff:0102:0304", &addr));
 606   addr2 = addr;
 607   addr = addr.Normalized();
 608   EXPECT_EQ(addr, addr2);
 609   EXPECT_TRUE(IPFromString("::0102:0304", &addr));
 610   addr2 = addr;
 611   addr = addr.Normalized();
 612   EXPECT_EQ(addr, addr2);
 613   // This string should 'work' as an IP address but is not a mapped address,
 614   // so it shouldn't change on normalization.
 615   EXPECT_TRUE(IPFromString("::192.168.7.1", &addr));
 616   addr2 = addr;
 617   addr = addr.Normalized();
 618   EXPECT_EQ(addr, addr2);
 619
 620   // Check that v4 addresses aren't altered.
 621   addr = IPAddress(htonl(kIPv4PublicAddr));
 622   addr2 = IPAddress(htonl(kIPv4PublicAddr));
 623   addr = addr.Normalized();
 624   EXPECT_EQ(addr, addr2);
 625 }
 626
 627 TEST(IPAddressTest, TestAsIPv6Address) {
 628   IPAddress addr(kIPv4PublicAddr);
 629   IPAddress addr2(kIPv4MappedPublicAddr);
 630   addr = addr.AsIPv6Address();
 631   EXPECT_EQ(addr, addr2);
 632
 633   addr = IPAddress(kIPv4MappedPublicAddr);
 634   addr2 = IPAddress(kIPv4MappedPublicAddr);
 635   addr = addr.AsIPv6Address();
 636   EXPECT_EQ(addr, addr2);
 637
 638   addr = IPAddress(kIPv6PublicAddr);
 639   addr2 = IPAddress(kIPv6PublicAddr);
 640   addr = addr.AsIPv6Address();
 641   EXPECT_EQ(addr, addr2);
 642 }
 643
 644 TEST(IPAddressTest, TestCountIPMaskBits) {
 645   IPAddress mask;
 646   // IPv4 on byte boundaries
 647   EXPECT_PRED2(CheckMaskCount, "255.255.255.255", 32);
 648   EXPECT_PRED2(CheckMaskCount, "255.255.255.0", 24);
 649   EXPECT_PRED2(CheckMaskCount, "255.255.0.0", 16);
 650   EXPECT_PRED2(CheckMaskCount, "255.0.0.0", 8);
 651   EXPECT_PRED2(CheckMaskCount, "0.0.0.0", 0);
 652
 653   // IPv4 not on byte boundaries
 654   EXPECT_PRED2(CheckMaskCount, "128.0.0.0", 1);
 655   EXPECT_PRED2(CheckMaskCount, "224.0.0.0", 3);
 656   EXPECT_PRED2(CheckMaskCount, "255.248.0.0", 13);
 657   EXPECT_PRED2(CheckMaskCount, "255.255.224.0", 19);
 658   EXPECT_PRED2(CheckMaskCount, "255.255.255.252", 30);
 659
 660   // V6 on byte boundaries
 661   EXPECT_PRED2(CheckMaskCount, "::", 0);
 662   EXPECT_PRED2(CheckMaskCount, "ff00::", 8);
 663   EXPECT_PRED2(CheckMaskCount, "ffff::", 16);
 664   EXPECT_PRED2(CheckMaskCount, "ffff:ff00::", 24);
 665   EXPECT_PRED2(CheckMaskCount, "ffff:ffff::", 32);
 666   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ff00::", 40);
 667   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff::", 48);
 668   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ff00::", 56);
 669   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff::", 64);
 670   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ff00::", 72);
 671   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff::", 80);
 672   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff00::", 88);
 673   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff::", 96);
 674   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff00:0000", 104);
 675   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0000", 112);
 676   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00", 120);
 677   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 128);
 678
 679   // V6 not on byte boundaries.
 680   EXPECT_PRED2(CheckMaskCount, "8000::", 1);
 681   EXPECT_PRED2(CheckMaskCount, "ff80::", 9);
 682   EXPECT_PRED2(CheckMaskCount, "ffff:fe00::", 23);
 683   EXPECT_PRED2(CheckMaskCount, "ffff:fffe::", 31);
 684   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:e000::", 35);
 685   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffe0::", 43);
 686   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:f800::", 53);
 687   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:fff8::", 61);
 688   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fc00::", 70);
 689   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fffc::", 78);
 690   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:8000::", 81);
 691   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff80::", 89);
 692   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fe00::", 103);
 693   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fffe:0000", 111);
 694   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fc00", 118);
 695   EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffc", 126);
 696
 697   // Non-contiguous ranges. These are invalid but lets test them
 698   // to make sure they don't crash anything or infinite loop or something.
 699   EXPECT_PRED1(TryInvalidMaskCount, "217.0.0.0");
 700   EXPECT_PRED1(TryInvalidMaskCount, "255.185.0.0");
 701   EXPECT_PRED1(TryInvalidMaskCount, "255.255.251.0");
 702   EXPECT_PRED1(TryInvalidMaskCount, "255.255.251.255");
 703   EXPECT_PRED1(TryInvalidMaskCount, "255.255.254.201");
 704   EXPECT_PRED1(TryInvalidMaskCount, "::1");
 705   EXPECT_PRED1(TryInvalidMaskCount, "fe80::1");
 706   EXPECT_PRED1(TryInvalidMaskCount, "ff80::1");
 707   EXPECT_PRED1(TryInvalidMaskCount, "ffff::1");
 708   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ff00:1::1");
 709   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff::ffff:1");
 710   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ff00:1::");
 711   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff::ff00");
 712   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ff00:1234::");
 713   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:0012::ffff");
 714   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ff01::");
 715   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:7f00::");
 716   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ff7a::");
 717   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:7f00:0000");
 718   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff70:0000");
 719   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0211");
 720   EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff7f");
 721 }
 722
 723 TEST(IPAddressTest, TestTruncateIP) {
 724   EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 24, "255.255.255.0");
 725   EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 16, "255.255.0.0");
 726   EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 8, "255.0.0.0");
 727   EXPECT_PRED3(CheckTruncateIP, "202.67.7.255", 24, "202.67.7.0");
 728   EXPECT_PRED3(CheckTruncateIP, "202.129.65.205", 16, "202.129.0.0");
 729   EXPECT_PRED3(CheckTruncateIP, "55.25.2.77", 8, "55.0.0.0");
 730   EXPECT_PRED3(CheckTruncateIP, "74.128.99.254", 1, "0.0.0.0");
 731   EXPECT_PRED3(CheckTruncateIP, "106.55.99.254", 3, "96.0.0.0");
 732   EXPECT_PRED3(CheckTruncateIP, "172.167.53.222", 13, "172.160.0.0");
 733   EXPECT_PRED3(CheckTruncateIP, "255.255.224.0", 18, "255.255.192.0");
 734   EXPECT_PRED3(CheckTruncateIP, "255.255.255.252", 28, "255.255.255.240");
 735
 736   EXPECT_PRED3(CheckTruncateIP, "fe80:1111:2222:3333:4444:5555:6666:7777", 1,
 737                "8000::");
 738   EXPECT_PRED3(CheckTruncateIP, "fff0:1111:2222:3333:4444:5555:6666:7777", 9,
 739                "ff80::");
 740   EXPECT_PRED3(CheckTruncateIP, "ffff:ff80:1111:2222:3333:4444:5555:6666", 23,
 741                "ffff:fe00::");
 742   EXPECT_PRED3(CheckTruncateIP, "ffff:ff80:1111:2222:3333:4444:5555:6666", 32,
 743                "ffff:ff80::");
 744   EXPECT_PRED3(CheckTruncateIP, "2400:f9af:e456:1111:2222:3333:4444:5555", 35,
 745                "2400:f9af:e000::");
 746   EXPECT_PRED3(CheckTruncateIP, "9999:1111:2233:4444:5555:6666:7777:8888", 53,
 747                "9999:1111:2233:4000::");
 748   EXPECT_PRED3(CheckTruncateIP, "9999:1111:2233:4567:5555:6666:7777:8888", 64,
 749                "9999:1111:2233:4567::");
 750   EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 68,
 751                "1111:2222:3333:4444:5000::");
 752   EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 92,
 753                "1111:2222:3333:4444:5555:6660::");
 754   EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 96,
 755                "1111:2222:3333:4444:5555:6666::");
 756   EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 105,
 757                "1111:2222:3333:4444:5555:6666:7700::");
 758   EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 124,
 759                "1111:2222:3333:4444:5555:6666:7777:8880");
 760
 761   // Slightly degenerate cases
 762   EXPECT_PRED3(CheckTruncateIP, "202.165.33.127", 32, "202.165.33.127");
 763   EXPECT_PRED3(CheckTruncateIP, "235.105.77.12", 0, "0.0.0.0");
 764   EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 128,
 765                "1111:2222:3333:4444:5555:6666:7777:8888");
 766   EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 0,
 767                "::");
 768 }
 769
 770 TEST(IPAddressTest, TestCategorizeIPv6) {
 771   // Test determining if an IPAddress is 6Bone/6To4/Teredo/etc.
 772   // IPv4 address, should be none of these (not even v4compat/v4mapped).
 773   IPAddress v4_addr(kIPv4PublicAddr);
 774   EXPECT_FALSE(IPIs6Bone(v4_addr));
 775   EXPECT_FALSE(IPIs6To4(v4_addr));
 776   EXPECT_FALSE(IPIsSiteLocal(v4_addr));
 777   EXPECT_FALSE(IPIsTeredo(v4_addr));
 778   EXPECT_FALSE(IPIsULA(v4_addr));
 779   EXPECT_FALSE(IPIsV4Compatibility(v4_addr));
 780   EXPECT_FALSE(IPIsV4Mapped(v4_addr));
 781   // Linklocal (fe80::/16) adddress; should be none of these.
 782   IPAddress linklocal_addr(kIPv6LinkLocalAddr);
 783   EXPECT_FALSE(IPIs6Bone(linklocal_addr));
 784   EXPECT_FALSE(IPIs6To4(linklocal_addr));
 785   EXPECT_FALSE(IPIsSiteLocal(linklocal_addr));
 786   EXPECT_FALSE(IPIsTeredo(linklocal_addr));
 787   EXPECT_FALSE(IPIsULA(linklocal_addr));
 788   EXPECT_FALSE(IPIsV4Compatibility(linklocal_addr));
 789   EXPECT_FALSE(IPIsV4Mapped(linklocal_addr));
 790   // 'Normal' IPv6 address, should also be none of these.
 791   IPAddress normal_addr(kIPv6PublicAddr);
 792   EXPECT_FALSE(IPIs6Bone(normal_addr));
 793   EXPECT_FALSE(IPIs6To4(normal_addr));
 794   EXPECT_FALSE(IPIsSiteLocal(normal_addr));
 795   EXPECT_FALSE(IPIsTeredo(normal_addr));
 796   EXPECT_FALSE(IPIsULA(normal_addr));
 797   EXPECT_FALSE(IPIsV4Compatibility(normal_addr));
 798   EXPECT_FALSE(IPIsV4Mapped(normal_addr));
 799   // IPv4 mapped address (::ffff:123.123.123.123)
 800   IPAddress v4mapped_addr(kIPv4MappedPublicAddr);
 801   EXPECT_TRUE(IPIsV4Mapped(v4mapped_addr));
 802   EXPECT_FALSE(IPIsV4Compatibility(v4mapped_addr));
 803   EXPECT_FALSE(IPIs6Bone(v4mapped_addr));
 804   EXPECT_FALSE(IPIs6To4(v4mapped_addr));
 805   EXPECT_FALSE(IPIsSiteLocal(v4mapped_addr));
 806   EXPECT_FALSE(IPIsTeredo(v4mapped_addr));
 807   EXPECT_FALSE(IPIsULA(v4mapped_addr));
 808   // IPv4 compatibility address (::123.123.123.123)
 809   IPAddress v4compat_addr;
 810   IPFromString("::192.168.7.1", &v4compat_addr);
 811   EXPECT_TRUE(IPIsV4Compatibility(v4compat_addr));
 812   EXPECT_FALSE(IPIs6Bone(v4compat_addr));
 813   EXPECT_FALSE(IPIs6To4(v4compat_addr));
 814   EXPECT_FALSE(IPIsSiteLocal(v4compat_addr));
 815   EXPECT_FALSE(IPIsTeredo(v4compat_addr));
 816   EXPECT_FALSE(IPIsULA(v4compat_addr));
 817   EXPECT_FALSE(IPIsV4Mapped(v4compat_addr));
 818   // 6Bone address (3FFE::/16)
 819   IPAddress sixbone_addr;
 820   IPFromString("3FFE:123:456::789:123", &sixbone_addr);
 821   EXPECT_TRUE(IPIs6Bone(sixbone_addr));
 822   EXPECT_FALSE(IPIs6To4(sixbone_addr));
 823   EXPECT_FALSE(IPIsSiteLocal(sixbone_addr));
 824   EXPECT_FALSE(IPIsTeredo(sixbone_addr));
 825   EXPECT_FALSE(IPIsULA(sixbone_addr));
 826   EXPECT_FALSE(IPIsV4Mapped(sixbone_addr));
 827   EXPECT_FALSE(IPIsV4Compatibility(sixbone_addr));
 828   // Unique Local Address (FC::/7)
 829   IPAddress ula_addr;
 830   IPFromString("FC00:123:456::789:123", &ula_addr);
 831   EXPECT_TRUE(IPIsULA(ula_addr));
 832   EXPECT_FALSE(IPIs6Bone(ula_addr));
 833   EXPECT_FALSE(IPIs6To4(ula_addr));
 834   EXPECT_FALSE(IPIsSiteLocal(ula_addr));
 835   EXPECT_FALSE(IPIsTeredo(ula_addr));
 836   EXPECT_FALSE(IPIsV4Mapped(ula_addr));
 837   EXPECT_FALSE(IPIsV4Compatibility(ula_addr));
 838   // 6To4 Address (2002::/16)
 839   IPAddress sixtofour_addr;
 840   IPFromString("2002:123:456::789:123", &sixtofour_addr);
 841   EXPECT_TRUE(IPIs6To4(sixtofour_addr));
 842   EXPECT_FALSE(IPIs6Bone(sixtofour_addr));
 843   EXPECT_FALSE(IPIsSiteLocal(sixtofour_addr));
 844   EXPECT_FALSE(IPIsTeredo(sixtofour_addr));
 845   EXPECT_FALSE(IPIsULA(sixtofour_addr));
 846   EXPECT_FALSE(IPIsV4Compatibility(sixtofour_addr));
 847   EXPECT_FALSE(IPIsV4Mapped(sixtofour_addr));
 848   // Site Local address (FEC0::/10)
 849   IPAddress sitelocal_addr;
 850   IPFromString("FEC0:123:456::789:123", &sitelocal_addr);
 851   EXPECT_TRUE(IPIsSiteLocal(sitelocal_addr));
 852   EXPECT_FALSE(IPIs6Bone(sitelocal_addr));
 853   EXPECT_FALSE(IPIs6To4(sitelocal_addr));
 854   EXPECT_FALSE(IPIsTeredo(sitelocal_addr));
 855   EXPECT_FALSE(IPIsULA(sitelocal_addr));
 856   EXPECT_FALSE(IPIsV4Compatibility(sitelocal_addr));
 857   EXPECT_FALSE(IPIsV4Mapped(sitelocal_addr));
 858   // Teredo Address (2001:0000::/32)
 859   IPAddress teredo_addr;
 860   IPFromString("2001:0000:123:456::789:123", &teredo_addr);
 861   EXPECT_TRUE(IPIsTeredo(teredo_addr));
 862   EXPECT_FALSE(IPIsSiteLocal(teredo_addr));
 863   EXPECT_FALSE(IPIs6Bone(teredo_addr));
 864   EXPECT_FALSE(IPIs6To4(teredo_addr));
 865   EXPECT_FALSE(IPIsULA(teredo_addr));
 866   EXPECT_FALSE(IPIsV4Compatibility(teredo_addr));
 867   EXPECT_FALSE(IPIsV4Mapped(teredo_addr));
 868 }
 869
 870 TEST(IPAddressTest, TestToSensitiveString) {
 871   IPAddress addr_v4 = IPAddress(kIPv4PublicAddr);
 872   EXPECT_EQ(kIPv4PublicAddrString, addr_v4.ToString());
 873   EXPECT_EQ(kIPv4PublicAddrString, addr_v4.ToSensitiveString());
 874   IPAddress::set_strip_sensitive(true);
 875   EXPECT_EQ(kIPv4PublicAddrString, addr_v4.ToString());
 876   EXPECT_EQ(kIPv4PublicAddrAnonymizedString, addr_v4.ToSensitiveString());
 877   IPAddress::set_strip_sensitive(false);
 878
 879   IPAddress addr_v6 = IPAddress(kIPv6PublicAddr);
 880   EXPECT_EQ(kIPv6PublicAddrString, addr_v6.ToString());
 881   EXPECT_EQ(kIPv6PublicAddrString, addr_v6.ToSensitiveString());
 882   IPAddress::set_strip_sensitive(true);
 883   EXPECT_EQ(kIPv6PublicAddrString, addr_v6.ToString());
 884   EXPECT_EQ(kIPv6PublicAddrAnonymizedString, addr_v6.ToSensitiveString());
 885   IPAddress::set_strip_sensitive(false);
 886 }
 887
 888 }  // namespace talk_base