← Back to branch summary

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

« back to all changes in this revision

Viewing changes to protocols/jabber/googletalk/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/googletalk/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