← Back to branch summary

~ubuntu-branches/debian/experimental/kopete/experimental

« back to all changes in this revision

Viewing changes to protocols/jabber/libjingle/talk/base/ipaddress_unittest.cc

  • Committer: Package Import Robot
  • Author(s): Maximiliano Curia
  • Date: 2015-02-24 11:32:57 UTC
  • mfrom: (1.1.41 vivid)
  • Revision ID: package-import@ubuntu.com-20150224113257-gnupg4v7lzz18ij0
Tags: 4:14.12.2-1
* New upstream release (14.12.2).
* Bump Standards-Version to 3.9.6, no changes needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
protocols/jabber/libjingle/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 kIPv6AnyAddrString = "::";
 
75
static const std::string kIPv6LoopbackAddrString = "::1";
 
76
static const std::string kIPv6LinkLocalAddrString = "fe80::be30:5bff:fee5:c3";
 
77
static const std::string kIPv6PublicAddrString =
 
78
    "2401:fa00:4:1000:be30:5bff:fee5:c3";
 
79
static const std::string kIPv4MappedAnyAddrString = "::ffff:0:0";
 
80
static const std::string kIPv4MappedRFC1918AddrString = "::ffff:c0a8:701";
 
81
static const std::string kIPv4MappedLoopbackAddrString = "::ffff:7f00:1";
 
82
static const std::string kIPv4MappedPublicAddrString = "::ffff:102:0304";
 
83
static const std::string kIPv4MappedV4StyleAddrString = "::ffff:192.168.7.1";
 
84
 
 
85
static const std::string kIPv4BrokenString1 = "192.168.7.";
 
86
static const std::string kIPv4BrokenString2 = "192.168.7.1.1";
 
87
static const std::string kIPv4BrokenString3 = "192.168.7.1:80";
 
88
static const std::string kIPv4BrokenString4 = "192.168.7.ONE";
 
89
static const std::string kIPv4BrokenString5 = "-192.168.7.1";
 
90
static const std::string kIPv4BrokenString6 = "256.168.7.1";
 
91
static const std::string kIPv6BrokenString1 = "2401:fa00:4:1000:be30";
 
92
static const std::string kIPv6BrokenString2 =
 
93
    "2401:fa00:4:1000:be30:5bff:fee5:c3:1";
 
94
static const std::string kIPv6BrokenString3 =
 
95
    "[2401:fa00:4:1000:be30:5bff:fee5:c3]:1";
 
96
static const std::string kIPv6BrokenString4 =
 
97
    "2401::4::be30";
 
98
static const std::string kIPv6BrokenString5 =
 
99
    "2401:::4:fee5:be30";
 
100
static const std::string kIPv6BrokenString6 =
 
101
    "2401f:fa00:4:1000:be30:5bff:fee5:c3";
 
102
static const std::string kIPv6BrokenString7 =
 
103
    "2401:ga00:4:1000:be30:5bff:fee5:c3";
 
104
static const std::string kIPv6BrokenString8 =
 
105
    "2401:fa000:4:1000:be30:5bff:fee5:c3";
 
106
static const std::string kIPv6BrokenString9 =
 
107
    "2401:fal0:4:1000:be30:5bff:fee5:c3";
 
108
static const std::string kIPv6BrokenString10 =
 
109
    "::ffff:192.168.7.";
 
110
static const std::string kIPv6BrokenString11 =
 
111
    "::ffff:192.168.7.1.1.1";
 
112
static const std::string kIPv6BrokenString12 =
 
113
    "::fffe:192.168.7.1";
 
114
static const std::string kIPv6BrokenString13 =
 
115
    "::ffff:192.168.7.ff";
 
116
static const std::string kIPv6BrokenString14 =
 
117
    "0x2401:fa00:4:1000:be30:5bff:fee5:c3";
 
118
 
 
119
bool IPFromHostEntWorks(const std::string& name, int expected_family,
 
120
                        IPAddress expected_addr) {
 
121
  struct hostent* ent = gethostbyname(name.c_str());
 
122
  if (ent) {
 
123
    IPAddress addr;
 
124
    if (!IPFromHostEnt(ent, &addr)) {
 
125
      return false;
 
126
    }
 
127
    return addr == expected_addr;
 
128
  }
 
129
  return true;
 
130
}
 
131
 
 
132
bool AreEqual(const IPAddress& addr,
 
133
              const IPAddress& addr2) {
 
134
  if ((IPIsAny(addr) != IPIsAny(addr2)) ||
 
135
      (IPIsLoopback(addr) != IPIsLoopback(addr2)) ||
 
136
      (IPIsPrivate(addr) != IPIsPrivate(addr2)) ||
 
137
      (HashIP(addr) != HashIP(addr2)) ||
 
138
      (addr.Size() != addr2.Size()) ||
 
139
      (addr.family() != addr2.family()) ||
 
140
      (addr.ToString() != addr2.ToString())) {
 
141
    return false;
 
142
  }
 
143
  in_addr v4addr, v4addr2;
 
144
  v4addr = addr.ipv4_address();
 
145
  v4addr2 = addr2.ipv4_address();
 
146
  if (0 != memcmp(&v4addr, &v4addr2, sizeof(v4addr))) {
 
147
    return false;
 
148
  }
 
149
  in6_addr v6addr, v6addr2;
 
150
  v6addr = addr.ipv6_address();
 
151
  v6addr2 = addr2.ipv6_address();
 
152
  if (0 != memcmp(&v6addr, &v6addr2, sizeof(v6addr))) {
 
153
    return false;
 
154
  }
 
155
  return true;
 
156
}
 
157
 
 
158
bool BrokenIPStringFails(const std::string& broken) {
 
159
  IPAddress addr(0);   // Intentionally make it v4.
 
160
  if (IPFromString(kIPv4BrokenString1, &addr)) {
 
161
    return false;
 
162
  }
 
163
  return addr.family() == AF_UNSPEC;
 
164
}
 
165
 
 
166
bool CheckMaskCount(const std::string& mask, int expected_length) {
 
167
  IPAddress addr;
 
168
  return IPFromString(mask, &addr) &&
 
169
      (expected_length == CountIPMaskBits(addr));
 
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, TestHostEntCtor) {
 
301
  IPAddress addr(INADDR_LOOPBACK);
 
302
  EXPECT_PRED3(IPFromHostEntWorks, "localhost", AF_INET, addr);
 
303
 
 
304
  addr = IPAddress(kIPv6AllNodes);
 
305
  EXPECT_PRED3(IPFromHostEntWorks, "ip6-allnodes", AF_INET6, addr);
 
306
 
 
307
  //  gethostbyname works for literal addresses too
 
308
  addr = IPAddress(INADDR_ANY);
 
309
  EXPECT_PRED3(IPFromHostEntWorks,
 
310
               kIPv4AnyAddrString, AF_INET, addr);
 
311
  addr = IPAddress(kIPv4RFC1918Addr);
 
312
  EXPECT_PRED3(IPFromHostEntWorks,
 
313
               kIPv4RFC1918AddrString, AF_INET, addr);
 
314
  addr = IPAddress(kIPv4PublicAddr);
 
315
  EXPECT_PRED3(IPFromHostEntWorks,
 
316
               kIPv4PublicAddrString, AF_INET, addr);
 
317
 
 
318
  addr = IPAddress(in6addr_any);
 
319
  EXPECT_PRED3(IPFromHostEntWorks,
 
320
               kIPv6AnyAddrString, AF_INET6, addr);
 
321
  addr = IPAddress(in6addr_loopback);
 
322
  EXPECT_PRED3(IPFromHostEntWorks,
 
323
               kIPv6LoopbackAddrString, AF_INET6, addr);
 
324
  addr = IPAddress(kIPv6LinkLocalAddr);
 
325
  EXPECT_PRED3(IPFromHostEntWorks,
 
326
               kIPv6LinkLocalAddrString, AF_INET6, addr);
 
327
  addr = IPAddress(kIPv6PublicAddr);
 
328
  EXPECT_PRED3(IPFromHostEntWorks,
 
329
               kIPv6PublicAddrString, AF_INET6, addr);
 
330
}
 
331
 
 
332
TEST(IPAddressTest, TestCopyCtor) {
 
333
  in_addr v4addr;
 
334
  v4addr.s_addr = htonl(kIPv4PublicAddr);
 
335
  IPAddress addr(v4addr);
 
336
  IPAddress addr2(addr);
 
337
 
 
338
  EXPECT_PRED2(AreEqual, addr, addr2);
 
339
 
 
340
  addr = IPAddress(INADDR_ANY);
 
341
  addr2 = IPAddress(addr);
 
342
  EXPECT_PRED2(AreEqual, addr, addr2);
 
343
 
 
344
  addr = IPAddress(INADDR_LOOPBACK);
 
345
  addr2 = IPAddress(addr);
 
346
  EXPECT_PRED2(AreEqual, addr, addr2);
 
347
 
 
348
  addr = IPAddress(kIPv4PublicAddr);
 
349
  addr2 = IPAddress(addr);
 
350
  EXPECT_PRED2(AreEqual, addr, addr2);
 
351
 
 
352
  addr = IPAddress(kIPv4RFC1918Addr);
 
353
  addr2 = IPAddress(addr);
 
354
  EXPECT_PRED2(AreEqual, addr, addr2);
 
355
 
 
356
  addr = IPAddress(in6addr_any);
 
357
  addr2 = IPAddress(addr);
 
358
  EXPECT_PRED2(AreEqual, addr, addr2);
 
359
 
 
360
  addr = IPAddress(in6addr_loopback);
 
361
  addr2 = IPAddress(addr);
 
362
  EXPECT_PRED2(AreEqual, addr, addr2);
 
363
 
 
364
  addr = IPAddress(kIPv6LinkLocalAddr);
 
365
  addr2 = IPAddress(addr);
 
366
  EXPECT_PRED2(AreEqual, addr, addr2);
 
367
 
 
368
  addr = IPAddress(kIPv6PublicAddr);
 
369
  addr2 = IPAddress(addr);
 
370
  EXPECT_PRED2(AreEqual, addr, addr2);
 
371
}
 
372
 
 
373
TEST(IPAddressTest, TestEquality) {
 
374
  // Check v4 equality
 
375
  in_addr v4addr, v4addr2;
 
376
  v4addr.s_addr = htonl(kIPv4PublicAddr);
 
377
  v4addr2.s_addr = htonl(kIPv4PublicAddr + 1);
 
378
  IPAddress addr(v4addr);
 
379
  IPAddress addr2(v4addr2);
 
380
  IPAddress addr3(v4addr);
 
381
 
 
382
  EXPECT_TRUE(addr == addr);
 
383
  EXPECT_TRUE(addr2 == addr2);
 
384
  EXPECT_TRUE(addr3 == addr3);
 
385
  EXPECT_TRUE(addr == addr3);
 
386
  EXPECT_TRUE(addr3 == addr);
 
387
  EXPECT_FALSE(addr2 == addr);
 
388
  EXPECT_FALSE(addr2 == addr3);
 
389
  EXPECT_FALSE(addr == addr2);
 
390
  EXPECT_FALSE(addr3 == addr2);
 
391
 
 
392
  // Check v6 equality
 
393
  IPAddress addr4(kIPv6PublicAddr);
 
394
  IPAddress addr5(kIPv6LinkLocalAddr);
 
395
  IPAddress addr6(kIPv6PublicAddr);
 
396
 
 
397
  EXPECT_TRUE(addr4 == addr4);
 
398
  EXPECT_TRUE(addr5 == addr5);
 
399
  EXPECT_TRUE(addr4 == addr6);
 
400
  EXPECT_TRUE(addr6 == addr4);
 
401
  EXPECT_FALSE(addr4 == addr5);
 
402
  EXPECT_FALSE(addr5 == addr4);
 
403
  EXPECT_FALSE(addr6 == addr5);
 
404
  EXPECT_FALSE(addr5 == addr6);
 
405
 
 
406
  // Check v4/v6 cross-equality
 
407
  EXPECT_FALSE(addr == addr4);
 
408
  EXPECT_FALSE(addr == addr5);
 
409
  EXPECT_FALSE(addr == addr6);
 
410
  EXPECT_FALSE(addr4 == addr);
 
411
  EXPECT_FALSE(addr5 == addr);
 
412
  EXPECT_FALSE(addr6 == addr);
 
413
  EXPECT_FALSE(addr2 == addr4);
 
414
  EXPECT_FALSE(addr2 == addr5);
 
415
  EXPECT_FALSE(addr2 == addr6);
 
416
  EXPECT_FALSE(addr4 == addr2);
 
417
  EXPECT_FALSE(addr5 == addr2);
 
418
  EXPECT_FALSE(addr6 == addr2);
 
419
  EXPECT_FALSE(addr3 == addr4);
 
420
  EXPECT_FALSE(addr3 == addr5);
 
421
  EXPECT_FALSE(addr3 == addr6);
 
422
  EXPECT_FALSE(addr4 == addr3);
 
423
  EXPECT_FALSE(addr5 == addr3);
 
424
  EXPECT_FALSE(addr6 == addr3);
 
425
 
 
426
  // Special cases: loopback and any.
 
427
  // They're special but they're still not equal.
 
428
  IPAddress v4loopback(htonl(INADDR_LOOPBACK));
 
429
  IPAddress v6loopback(in6addr_loopback);
 
430
  EXPECT_FALSE(v4loopback == v6loopback);
 
431
 
 
432
  IPAddress v4any(0);
 
433
  IPAddress v6any(in6addr_any);
 
434
  EXPECT_FALSE(v4any == v6any);
 
435
}
 
436
 
 
437
TEST(IPAddressTest, TestComparison) {
 
438
  // Defined in 'ascending' order.
 
439
  // v6 > v4, and intra-family sorting is purely numerical
 
440
  IPAddress addr0;  // AF_UNSPEC
 
441
  IPAddress addr1(INADDR_ANY);  // 0.0.0.0
 
442
  IPAddress addr2(kIPv4PublicAddr);  // 1.2.3.4
 
443
  IPAddress addr3(INADDR_LOOPBACK);  // 127.0.0.1
 
444
  IPAddress addr4(kIPv4RFC1918Addr);  // 192.168.7.1.
 
445
  IPAddress addr5(in6addr_any);  // ::
 
446
  IPAddress addr6(in6addr_loopback);  // ::1
 
447
  IPAddress addr7(kIPv6PublicAddr);  // 2401....
 
448
  IPAddress addr8(kIPv6LinkLocalAddr);  // fe80....
 
449
 
 
450
  EXPECT_TRUE(addr0 < addr1);
 
451
  EXPECT_TRUE(addr1 < addr2);
 
452
  EXPECT_TRUE(addr2 < addr3);
 
453
  EXPECT_TRUE(addr3 < addr4);
 
454
  EXPECT_TRUE(addr4 < addr5);
 
455
  EXPECT_TRUE(addr5 < addr6);
 
456
  EXPECT_TRUE(addr6 < addr7);
 
457
  EXPECT_TRUE(addr7 < addr8);
 
458
 
 
459
  EXPECT_FALSE(addr0 > addr1);
 
460
  EXPECT_FALSE(addr1 > addr2);
 
461
  EXPECT_FALSE(addr2 > addr3);
 
462
  EXPECT_FALSE(addr3 > addr4);
 
463
  EXPECT_FALSE(addr4 > addr5);
 
464
  EXPECT_FALSE(addr5 > addr6);
 
465
  EXPECT_FALSE(addr6 > addr7);
 
466
  EXPECT_FALSE(addr7 > addr8);
 
467
 
 
468
  EXPECT_FALSE(addr0 > addr0);
 
469
  EXPECT_FALSE(addr1 > addr1);
 
470
  EXPECT_FALSE(addr2 > addr2);
 
471
  EXPECT_FALSE(addr3 > addr3);
 
472
  EXPECT_FALSE(addr4 > addr4);
 
473
  EXPECT_FALSE(addr5 > addr5);
 
474
  EXPECT_FALSE(addr6 > addr6);
 
475
  EXPECT_FALSE(addr7 > addr7);
 
476
  EXPECT_FALSE(addr8 > addr8);
 
477
 
 
478
  EXPECT_FALSE(addr0 < addr0);
 
479
  EXPECT_FALSE(addr1 < addr1);
 
480
  EXPECT_FALSE(addr2 < addr2);
 
481
  EXPECT_FALSE(addr3 < addr3);
 
482
  EXPECT_FALSE(addr4 < addr4);
 
483
  EXPECT_FALSE(addr5 < addr5);
 
484
  EXPECT_FALSE(addr6 < addr6);
 
485
  EXPECT_FALSE(addr7 < addr7);
 
486
  EXPECT_FALSE(addr8 < addr8);
 
487
}
 
488
 
 
489
TEST(IPAddressTest, TestFromString) {
 
490
  IPAddress addr;
 
491
  IPAddress addr2;
 
492
  addr2 = IPAddress(INADDR_ANY);
 
493
 
 
494
  EXPECT_TRUE(IPFromString(kIPv4AnyAddrString, &addr));
 
495
  EXPECT_EQ(addr.ToString(), kIPv4AnyAddrString);
 
496
  EXPECT_PRED2(AreEqual, addr, addr2);
 
497
 
 
498
  addr2 = IPAddress(INADDR_LOOPBACK);
 
499
  EXPECT_TRUE(IPFromString(kIPv4LoopbackAddrString, &addr));
 
500
  EXPECT_EQ(addr.ToString(), kIPv4LoopbackAddrString);
 
501
  EXPECT_PRED2(AreEqual, addr, addr2);
 
502
 
 
503
  addr2 = IPAddress(kIPv4RFC1918Addr);
 
504
  EXPECT_TRUE(IPFromString(kIPv4RFC1918AddrString, &addr));
 
505
  EXPECT_EQ(addr.ToString(), kIPv4RFC1918AddrString);
 
506
  EXPECT_PRED2(AreEqual, addr, addr2);
 
507
 
 
508
  addr2 = IPAddress(kIPv4PublicAddr);
 
509
  EXPECT_TRUE(IPFromString(kIPv4PublicAddrString, &addr));
 
510
  EXPECT_EQ(addr.ToString(), kIPv4PublicAddrString);
 
511
  EXPECT_PRED2(AreEqual, addr, addr2);
 
512
 
 
513
  addr2 = IPAddress(in6addr_any);
 
514
  EXPECT_TRUE(IPFromString(kIPv6AnyAddrString, &addr));
 
515
  EXPECT_EQ(addr.ToString(), kIPv6AnyAddrString);
 
516
  EXPECT_PRED2(AreEqual, addr, addr2);
 
517
 
 
518
  addr2 = IPAddress(in6addr_loopback);
 
519
  EXPECT_TRUE(IPFromString(kIPv6LoopbackAddrString, &addr));
 
520
  EXPECT_EQ(addr.ToString(), kIPv6LoopbackAddrString);
 
521
  EXPECT_PRED2(AreEqual, addr, addr2);
 
522
 
 
523
  addr2 = IPAddress(kIPv6LinkLocalAddr);
 
524
  EXPECT_TRUE(IPFromString(kIPv6LinkLocalAddrString, &addr));
 
525
  EXPECT_EQ(addr.ToString(), kIPv6LinkLocalAddrString);
 
526
  EXPECT_PRED2(AreEqual, addr, addr2);
 
527
 
 
528
  addr2 = IPAddress(kIPv6PublicAddr);
 
529
  EXPECT_TRUE(IPFromString(kIPv6PublicAddrString, &addr));
 
530
  EXPECT_EQ(addr.ToString(), kIPv6PublicAddrString);
 
531
  EXPECT_PRED2(AreEqual, addr, addr2);
 
532
 
 
533
  addr2 = IPAddress(kIPv4MappedRFC1918Addr);
 
534
  EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr));
 
535
  EXPECT_PRED2(AreEqual, addr, addr2);
 
536
 
 
537
  // Broken cases, should set addr to AF_UNSPEC.
 
538
  EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString1);
 
539
  EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString2);
 
540
  EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString3);
 
541
  EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString4);
 
542
  EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString5);
 
543
  EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString6);
 
544
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString1);
 
545
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString2);
 
546
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString3);
 
547
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString4);
 
548
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString5);
 
549
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString6);
 
550
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString7);
 
551
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString8);
 
552
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString9);
 
553
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString10);
 
554
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString11);
 
555
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString12);
 
556
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString13);
 
557
  EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString14);
 
558
}
 
559
 
 
560
TEST(IPAddressTest, TestIsPrivate) {
 
561
  EXPECT_FALSE(IPIsPrivate(IPAddress(INADDR_ANY)));
 
562
  EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4PublicAddr)));
 
563
  EXPECT_FALSE(IPIsPrivate(IPAddress(in6addr_any)));
 
564
  EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv6PublicAddr)));
 
565
  EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedAnyAddr)));
 
566
  EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedPublicAddr)));
 
567
 
 
568
  EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv4RFC1918Addr)));
 
569
  EXPECT_TRUE(IPIsPrivate(IPAddress(INADDR_LOOPBACK)));
 
570
  EXPECT_TRUE(IPIsPrivate(IPAddress(in6addr_loopback)));
 
571
  EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv6LinkLocalAddr)));
 
572
}
 
573
 
 
574
TEST(IPAddressTest, TestIsLoopback) {
 
575
  EXPECT_FALSE(IPIsLoopback(IPAddress(INADDR_ANY)));
 
576
  EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4PublicAddr)));
 
577
  EXPECT_FALSE(IPIsLoopback(IPAddress(in6addr_any)));
 
578
  EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv6PublicAddr)));
 
579
  EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedAnyAddr)));
 
580
  EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedPublicAddr)));
 
581
 
 
582
  EXPECT_TRUE(IPIsLoopback(IPAddress(INADDR_LOOPBACK)));
 
583
  EXPECT_TRUE(IPIsLoopback(IPAddress(in6addr_loopback)));
 
584
}
 
585
 
 
586
TEST(IPAddressTest, TestNormalized) {
 
587
  // Check normalizing a ::ffff:a.b.c.d address.
 
588
  IPAddress addr;
 
589
  EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr));
 
590
  IPAddress addr2(kIPv4RFC1918Addr);
 
591
  addr = addr.Normalized();
 
592
  EXPECT_EQ(addr2, addr);
 
593
 
 
594
  // Check normalizing a ::ffff:aabb:ccdd address.
 
595
  addr = IPAddress(kIPv4MappedPublicAddr);
 
596
  addr2 = IPAddress(kIPv4PublicAddr);
 
597
  addr = addr.Normalized();
 
598
  EXPECT_EQ(addr, addr2);
 
599
 
 
600
  // Check that a non-mapped v6 addresses isn't altered.
 
601
  addr = IPAddress(kIPv6PublicAddr);
 
602
  addr2 = IPAddress(kIPv6PublicAddr);
 
603
  addr = addr.Normalized();
 
604
  EXPECT_EQ(addr, addr2);
 
605
 
 
606
  // Check that addresses that look a bit like mapped addresses aren't altered
 
607
  EXPECT_TRUE(IPFromString("fe80::ffff:0102:0304", &addr));
 
608
  addr2 = addr;
 
609
  addr = addr.Normalized();
 
610
  EXPECT_EQ(addr, addr2);
 
611
  EXPECT_TRUE(IPFromString("::0102:0304", &addr));
 
612
  addr2 = addr;
 
613
  addr = addr.Normalized();
 
614
  EXPECT_EQ(addr, addr2);
 
615
  // This string should 'work' as an IP address but is not a mapped address,
 
616
  // so it shouldn't change on normalization.
 
617
  EXPECT_TRUE(IPFromString("::192.168.7.1", &addr));
 
618
  addr2 = addr;
 
619
  addr = addr.Normalized();
 
620
  EXPECT_EQ(addr, addr2);
 
621
 
 
622
  // Check that v4 addresses aren't altered.
 
623
  addr = IPAddress(htonl(kIPv4PublicAddr));
 
624
  addr2 = IPAddress(htonl(kIPv4PublicAddr));
 
625
  addr = addr.Normalized();
 
626
  EXPECT_EQ(addr, addr2);
 
627
}
 
628
 
 
629
TEST(IPAddressTest, TestAsIPv6Address) {
 
630
  IPAddress addr(kIPv4PublicAddr);
 
631
  IPAddress addr2(kIPv4MappedPublicAddr);
 
632
  addr = addr.AsIPv6Address();
 
633
  EXPECT_EQ(addr, addr2);
 
634
 
 
635
  addr = IPAddress(kIPv4MappedPublicAddr);
 
636
  addr2 = IPAddress(kIPv4MappedPublicAddr);
 
637
  addr = addr.AsIPv6Address();
 
638
  EXPECT_EQ(addr, addr2);
 
639
 
 
640
  addr = IPAddress(kIPv6PublicAddr);
 
641
  addr2 = IPAddress(kIPv6PublicAddr);
 
642
  addr = addr.AsIPv6Address();
 
643
  EXPECT_EQ(addr, addr2);
 
644
}
 
645
 
 
646
TEST(IPAddressTest, TestCountIPMaskBits) {
 
647
  IPAddress mask;
 
648
  // IPv4 on byte boundaries
 
649
  EXPECT_PRED2(CheckMaskCount, "255.255.255.255", 32);
 
650
  EXPECT_PRED2(CheckMaskCount, "255.255.255.0", 24);
 
651
  EXPECT_PRED2(CheckMaskCount, "255.255.0.0", 16);
 
652
  EXPECT_PRED2(CheckMaskCount, "255.0.0.0", 8);
 
653
  EXPECT_PRED2(CheckMaskCount, "0.0.0.0", 0);
 
654
 
 
655
  // IPv4 not on byte boundaries
 
656
  EXPECT_PRED2(CheckMaskCount, "128.0.0.0", 1);
 
657
  EXPECT_PRED2(CheckMaskCount, "224.0.0.0", 3);
 
658
  EXPECT_PRED2(CheckMaskCount, "255.248.0.0", 13);
 
659
  EXPECT_PRED2(CheckMaskCount, "255.255.224.0", 19);
 
660
  EXPECT_PRED2(CheckMaskCount, "255.255.255.252", 30);
 
661
 
 
662
  // V6 on byte boundaries
 
663
  EXPECT_PRED2(CheckMaskCount, "::", 0);
 
664
  EXPECT_PRED2(CheckMaskCount, "ff00::", 8);
 
665
  EXPECT_PRED2(CheckMaskCount, "ffff::", 16);
 
666
  EXPECT_PRED2(CheckMaskCount, "ffff:ff00::", 24);
 
667
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff::", 32);
 
668
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ff00::", 40);
 
669
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff::", 48);
 
670
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ff00::", 56);
 
671
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff::", 64);
 
672
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ff00::", 72);
 
673
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff::", 80);
 
674
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff00::", 88);
 
675
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff::", 96);
 
676
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff00:0000", 104);
 
677
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0000", 112);
 
678
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00", 120);
 
679
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 128);
 
680
 
 
681
  // V6 not on byte boundaries.
 
682
  EXPECT_PRED2(CheckMaskCount, "8000::", 1);
 
683
  EXPECT_PRED2(CheckMaskCount, "ff80::", 9);
 
684
  EXPECT_PRED2(CheckMaskCount, "ffff:fe00::", 23);
 
685
  EXPECT_PRED2(CheckMaskCount, "ffff:fffe::", 31);
 
686
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:e000::", 35);
 
687
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffe0::", 43);
 
688
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:f800::", 53);
 
689
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:fff8::", 61);
 
690
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fc00::", 70);
 
691
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fffc::", 78);
 
692
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:8000::", 81);
 
693
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff80::", 89);
 
694
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fe00::", 103);
 
695
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fffe:0000", 111);
 
696
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fc00", 118);
 
697
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffc", 126);
 
698
 
 
699
  // Non-contiguous ranges. These are kind-of invalid but lets test them
 
700
  // to make sure they don't crash anything or infinite loop or something.
 
701
  EXPECT_PRED2(CheckMaskCount, "217.0.0.0", 2);
 
702
  EXPECT_PRED2(CheckMaskCount, "255.185.0.0", 9);
 
703
  EXPECT_PRED2(CheckMaskCount, "255.255.251.0", 21);
 
704
  EXPECT_PRED2(CheckMaskCount, "255.255.251.255", 21);
 
705
  EXPECT_PRED2(CheckMaskCount, "255.255.254.201", 23);
 
706
  EXPECT_PRED2(CheckMaskCount, "::1", 0);
 
707
  EXPECT_PRED2(CheckMaskCount, "fe80::1", 7);
 
708
  EXPECT_PRED2(CheckMaskCount, "ff80::1", 9);
 
709
  EXPECT_PRED2(CheckMaskCount, "ffff::1", 16);
 
710
  EXPECT_PRED2(CheckMaskCount, "ffff:ff00:1::1", 24);
 
711
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff::ffff:1", 32);
 
712
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ff00:1::", 40);
 
713
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff::ff00", 48);
 
714
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ff00:1234::", 56);
 
715
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:0012::ffff", 64);
 
716
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ff01::", 72);
 
717
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:7f00::", 80);
 
718
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff7a::", 88);
 
719
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:7f00:0000", 96);
 
720
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff70:0000", 104);
 
721
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0211", 112);
 
722
  EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff7f", 120);
 
723
}
 
724
 
 
725
TEST(IPAddressTest, TestTruncateIP) {
 
726
  EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 24, "255.255.255.0");
 
727
  EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 16, "255.255.0.0");
 
728
  EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 8, "255.0.0.0");
 
729
  EXPECT_PRED3(CheckTruncateIP, "202.67.7.255", 24, "202.67.7.0");
 
730
  EXPECT_PRED3(CheckTruncateIP, "202.129.65.205", 16, "202.129.0.0");
 
731
  EXPECT_PRED3(CheckTruncateIP, "55.25.2.77", 8, "55.0.0.0");
 
732
  EXPECT_PRED3(CheckTruncateIP, "74.128.99.254", 1, "0.0.0.0");
 
733
  EXPECT_PRED3(CheckTruncateIP, "106.55.99.254", 3, "96.0.0.0");
 
734
  EXPECT_PRED3(CheckTruncateIP, "172.167.53.222", 13, "172.160.0.0");
 
735
  EXPECT_PRED3(CheckTruncateIP, "255.255.224.0", 18, "255.255.192.0");
 
736
  EXPECT_PRED3(CheckTruncateIP, "255.255.255.252", 28, "255.255.255.240");
 
737
 
 
738
  EXPECT_PRED3(CheckTruncateIP, "fe80:1111:2222:3333:4444:5555:6666:7777", 1,
 
739
               "8000::");
 
740
  EXPECT_PRED3(CheckTruncateIP, "fff0:1111:2222:3333:4444:5555:6666:7777", 9,
 
741
               "ff80::");
 
742
  EXPECT_PRED3(CheckTruncateIP, "ffff:ff80:1111:2222:3333:4444:5555:6666", 23,
 
743
               "ffff:fe00::");
 
744
  EXPECT_PRED3(CheckTruncateIP, "ffff:ff80:1111:2222:3333:4444:5555:6666", 32,
 
745
               "ffff:ff80::");
 
746
  EXPECT_PRED3(CheckTruncateIP, "2400:f9af:e456:1111:2222:3333:4444:5555", 35,
 
747
               "2400:f9af:e000::");
 
748
  EXPECT_PRED3(CheckTruncateIP, "9999:1111:2233:4444:5555:6666:7777:8888", 53,
 
749
               "9999:1111:2233:4000::");
 
750
  EXPECT_PRED3(CheckTruncateIP, "9999:1111:2233:4567:5555:6666:7777:8888", 64,
 
751
               "9999:1111:2233:4567::");
 
752
  EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 68,
 
753
               "1111:2222:3333:4444:5000::");
 
754
  EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 92,
 
755
               "1111:2222:3333:4444:5555:6660::");
 
756
  EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 96,
 
757
               "1111:2222:3333:4444:5555:6666::");
 
758
  EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 105,
 
759
               "1111:2222:3333:4444:5555:6666:7700::");
 
760
  EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 124,
 
761
               "1111:2222:3333:4444:5555:6666:7777:8880");
 
762
 
 
763
  // Slightly degenerate cases
 
764
  EXPECT_PRED3(CheckTruncateIP, "202.165.33.127", 32, "202.165.33.127");
 
765
  EXPECT_PRED3(CheckTruncateIP, "235.105.77.12", 0, "0.0.0.0");
 
766
  EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 128,
 
767
               "1111:2222:3333:4444:5555:6666:7777:8888");
 
768
  EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 0,
 
769
               "::");
 
770
}
 
771
}  // namespace talk_base