InetAddressesTest.java revision 1d580d0f6ee4f21eb309ba7b509d2c6d671c4044 
1/*
2 * Copyright (C) 2008 The Guava Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.google.common.net;
18
19import com.google.common.testing.NullPointerTester;
20
21import junit.framework.TestCase;
22
23import java.net.Inet4Address;
24import java.net.Inet6Address;
25import java.net.InetAddress;
26import java.net.UnknownHostException;
27
28/**
29 * Tests for {@link InetAddresses}.
30 *
31 * @author Erik Kline
32 */
33public class InetAddressesTest extends TestCase {
34
35  public void testNulls() throws Exception {
36    NullPointerTester tester = new NullPointerTester();
37
38    tester.testAllPublicStaticMethods(InetAddresses.class);
39  }
40
41  public void testForStringBogusInput() {
42    String[] bogusInputs = {
43        "",
44        "016.016.016.016",
45        "016.016.016",
46        "016.016",
47        "016",
48        "000.000.000.000",
49        "000",
50        "0x0a.0x0a.0x0a.0x0a",
51        "0x0a.0x0a.0x0a",
52        "0x0a.0x0a",
53        "0x0a",
54        "42.42.42.42.42",
55        "42.42.42",
56        "42.42",
57        "42",
58        "42..42.42",
59        "42..42.42.42",
60        "42.42.42.42.",
61        "42.42.42.42...",
62        ".42.42.42.42",
63        "...42.42.42.42",
64        "42.42.42.-0",
65        "42.42.42.+0",
66        ".",
67        "...",
68        "bogus",
69        "bogus.com",
70        "192.168.0.1.com",
71        "12345.67899.-54321.-98765",
72        "257.0.0.0",
73        "42.42.42.-42",
74        "3ffe::1.net",
75        "3ffe::1::1",
76        "1::2::3::4:5",
77        "::7:6:5:4:3:2:",  // should end with ":0"
78        ":6:5:4:3:2:1::",  // should begin with "0:"
79        "2001::db:::1",
80        "FEDC:9878",
81        "+1.+2.+3.4",
82        "1.2.3.4e0",
83        "::7:6:5:4:3:2:1:0",  // too many parts
84        "7:6:5:4:3:2:1:0::",  // too many parts
85        "9:8:7:6:5:4:3::2:1",  // too many parts
86        "0:1:2:3::4:5:6:7",  // :: must remove at least one 0.
87        "3ffe:0:0:0:0:0:0:0:1",  // too many parts (9 instead of 8)
88        "3ffe::10000",  // hextet exceeds 16 bits
89        "3ffe::goog",
90        "3ffe::-0",
91        "3ffe::+0",
92        "3ffe::-1",
93        ":",
94        ":::",
95        "::1.2.3",
96        "::1.2.3.4.5",
97        "::1.2.3.4:",
98        "1.2.3.4::",
99        "2001:db8::1:",
100        ":2001:db8::1",
101        ":1:2:3:4:5:6:7",
102        "1:2:3:4:5:6:7:",
103        ":1:2:3:4:5:6:"
104    };
105
106    for (int i = 0; i < bogusInputs.length; i++) {
107      try {
108        InetAddresses.forString(bogusInputs[i]);
109        fail("IllegalArgumentException expected for '" + bogusInputs[i] + "'");
110      } catch (IllegalArgumentException expected) {
111        // expected behavior
112      }
113      assertFalse(InetAddresses.isInetAddress(bogusInputs[i]));
114    }
115  }
116
117  public void test3ff31() {
118    try {
119      InetAddresses.forString("3ffe:::1");
120      fail("IllegalArgumentException expected");
121    } catch (IllegalArgumentException expected) {
122      // expected behavior
123    }
124    assertFalse(InetAddresses.isInetAddress("016.016.016.016"));
125  }
126
127  public void testForStringIPv4Input() throws UnknownHostException {
128    String ipStr = "192.168.0.1";
129    InetAddress ipv4Addr = null;
130    // Shouldn't hit DNS, because it's an IP string literal.
131    ipv4Addr = InetAddress.getByName(ipStr);
132    assertEquals(ipv4Addr, InetAddresses.forString(ipStr));
133    assertTrue(InetAddresses.isInetAddress(ipStr));
134  }
135
136  public void testForStringIPv6Input() throws UnknownHostException {
137    String ipStr = "3ffe::1";
138    InetAddress ipv6Addr = null;
139    // Shouldn't hit DNS, because it's an IP string literal.
140    ipv6Addr = InetAddress.getByName(ipStr);
141    assertEquals(ipv6Addr, InetAddresses.forString(ipStr));
142    assertTrue(InetAddresses.isInetAddress(ipStr));
143  }
144
145  public void testForStringIPv6EightColons() throws UnknownHostException {
146    String[] eightColons = {
147      "::7:6:5:4:3:2:1",
148      "::7:6:5:4:3:2:0",
149      "7:6:5:4:3:2:1::",
150      "0:6:5:4:3:2:1::",
151    };
152
153    for (int i = 0; i < eightColons.length; i++) {
154      InetAddress ipv6Addr = null;
155      // Shouldn't hit DNS, because it's an IP string literal.
156      ipv6Addr = InetAddress.getByName(eightColons[i]);
157      assertEquals(ipv6Addr, InetAddresses.forString(eightColons[i]));
158      assertTrue(InetAddresses.isInetAddress(eightColons[i]));
159    }
160  }
161
162  public void testConvertDottedQuadToHex() throws UnknownHostException {
163    String[] ipStrings = {"7::0.128.0.127", "7::0.128.0.128",
164        "7::128.128.0.127", "7::0.128.128.127"};
165
166    for (String ipString : ipStrings) {
167      // Shouldn't hit DNS, because it's an IP string literal.
168      InetAddress ipv6Addr = InetAddress.getByName(ipString);
169      assertEquals(ipv6Addr, InetAddresses.forString(ipString));
170      assertTrue(InetAddresses.isInetAddress(ipString));
171    }
172  }
173
174  public void testToAddrStringIPv4() {
175    // Don't need to test IPv4 much; it just calls getHostAddress().
176    assertEquals("1.2.3.4",
177                 InetAddresses.toAddrString(
178                     InetAddresses.forString("1.2.3.4")));
179  }
180
181  public void testToAddrStringIPv6() {
182    assertEquals("1:2:3:4:5:6:7:8",
183                 InetAddresses.toAddrString(
184                     InetAddresses.forString("1:2:3:4:5:6:7:8")));
185    assertEquals("2001:0:0:4::8",
186                 InetAddresses.toAddrString(
187                     InetAddresses.forString("2001:0:0:4:0:0:0:8")));
188    assertEquals("2001::4:5:6:7:8",
189                 InetAddresses.toAddrString(
190                     InetAddresses.forString("2001:0:0:4:5:6:7:8")));
191    assertEquals("2001:0:3:4:5:6:7:8",
192                 InetAddresses.toAddrString(
193                     InetAddresses.forString("2001:0:3:4:5:6:7:8")));
194    assertEquals("0:0:3::ffff",
195                 InetAddresses.toAddrString(
196                     InetAddresses.forString("0:0:3:0:0:0:0:ffff")));
197    assertEquals("::4:0:0:0:ffff",
198                 InetAddresses.toAddrString(
199                     InetAddresses.forString("0:0:0:4:0:0:0:ffff")));
200    assertEquals("::5:0:0:ffff",
201                 InetAddresses.toAddrString(
202                     InetAddresses.forString("0:0:0:0:5:0:0:ffff")));
203    assertEquals("1::4:0:0:7:8",
204                 InetAddresses.toAddrString(
205                     InetAddresses.forString("1:0:0:4:0:0:7:8")));
206    assertEquals("::",
207                 InetAddresses.toAddrString(
208                     InetAddresses.forString("0:0:0:0:0:0:0:0")));
209    assertEquals("::1",
210                 InetAddresses.toAddrString(
211                     InetAddresses.forString("0:0:0:0:0:0:0:1")));
212    assertEquals("2001:658:22a:cafe::",
213                 InetAddresses.toAddrString(
214                     InetAddresses.forString("2001:0658:022a:cafe::")));
215    assertEquals("::102:304",
216                 InetAddresses.toAddrString(
217                     InetAddresses.forString("::1.2.3.4")));
218  }
219
220  public void testToUriStringIPv4() {
221    String ipStr = "1.2.3.4";
222    InetAddress ip = InetAddresses.forString(ipStr);
223    assertEquals("1.2.3.4", InetAddresses.toUriString(ip));
224  }
225
226  public void testToUriStringIPv6() {
227    // Unfortunately the InetAddress.toString() method for IPv6 addresses
228    // does not collapse contiguous shorts of zeroes with the :: abbreviation.
229    String ipStr = "3ffe::1";
230    InetAddress ip = InetAddresses.forString(ipStr);
231    assertEquals("[3ffe::1]", InetAddresses.toUriString(ip));
232  }
233
234  public void testForUriStringIPv4() {
235    Inet4Address expected = (Inet4Address) InetAddresses.forString("192.168.1.1");
236    assertEquals(expected, InetAddresses.forUriString("192.168.1.1"));
237  }
238
239  public void testForUriStringIPv6() {
240    Inet6Address expected = (Inet6Address) InetAddresses.forString("3ffe:0:0:0:0:0:0:1");
241    assertEquals(expected, InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1]"));
242  }
243
244  public void testIsUriInetAddress() {
245    assertTrue(InetAddresses.isUriInetAddress("192.168.1.1"));
246    assertTrue(InetAddresses.isUriInetAddress("[3ffe:0:0:0:0:0:0:1]"));
247
248    assertFalse(InetAddresses.isUriInetAddress("[192.168.1.1"));
249    assertFalse(InetAddresses.isUriInetAddress("192.168.1.1]"));
250    assertFalse(InetAddresses.isUriInetAddress(""));
251    assertFalse(InetAddresses.isUriInetAddress("192.168.999.888"));
252    assertFalse(InetAddresses.isUriInetAddress("www.google.com"));
253    assertFalse(InetAddresses.isUriInetAddress("1:2e"));
254    assertFalse(InetAddresses.isUriInetAddress("[3ffe:0:0:0:0:0:0:1"));
255    assertFalse(InetAddresses.isUriInetAddress("3ffe:0:0:0:0:0:0:1]"));
256  }
257
258  public void testForUriStringBad() {
259    try {
260      InetAddresses.forUriString("");
261      fail("expected IllegalArgumentException");  // COV_NF_LINE
262    } catch (IllegalArgumentException e) {
263      // expected
264    }
265
266    try {
267      InetAddresses.forUriString("192.168.999.888");
268      fail("expected IllegalArgumentException");  // COV_NF_LINE
269    } catch (IllegalArgumentException e) {
270      // expected
271    }
272
273    try {
274      InetAddresses.forUriString("www.google.com");
275      fail("expected IllegalArgumentException");  // COV_NF_LINE
276    } catch (IllegalArgumentException e) {
277      // expected
278    }
279
280    try {
281      InetAddresses.forUriString("[1:2e]");
282      fail("expected IllegalArgumentException");  // COV_NF_LINE
283    } catch (IllegalArgumentException e) {
284      // expected
285    }
286
287    try {
288      InetAddresses.forUriString("[192.168.1.1]");
289      fail("expected IllegalArgumentException");  // COV_NF_LINE
290    } catch (IllegalArgumentException e) {
291      // expected
292    }
293
294    try {
295      InetAddresses.forUriString("192.168.1.1]");
296      fail("expected IllegalArgumentException");  // COV_NF_LINE
297    } catch (IllegalArgumentException e) {
298      // expected
299    }
300
301    try {
302      InetAddresses.forUriString("[192.168.1.1");
303      fail("expected IllegalArgumentException");  // COV_NF_LINE
304    } catch (IllegalArgumentException e) {
305      // expected
306    }
307
308    try {
309      InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1");
310      fail("expected IllegalArgumentException");  // COV_NF_LINE
311    } catch (IllegalArgumentException e) {
312      // expected
313    }
314
315    try {
316      InetAddresses.forUriString("3ffe:0:0:0:0:0:0:1]");
317      fail("expected IllegalArgumentException");  // COV_NF_LINE
318    } catch (IllegalArgumentException e) {
319      // expected
320    }
321  }
322
323  public void testCompatIPv4Addresses() {
324    String[] nonCompatAddresses = {
325        "3ffe::1",
326        "::",
327        "::1",
328    };
329
330    for (int i = 0; i < nonCompatAddresses.length; i++) {
331      InetAddress ip = InetAddresses.forString(nonCompatAddresses[i]);
332      assertFalse(InetAddresses.isCompatIPv4Address((Inet6Address) ip));
333      try {
334        InetAddresses.getCompatIPv4Address((Inet6Address) ip);
335        fail("IllegalArgumentException expected for '" +
336             nonCompatAddresses[i] + "'");
337      } catch (IllegalArgumentException expected) {
338        // expected behavior
339      }
340    }
341
342    String[] validCompatAddresses = {
343        "::1.2.3.4",
344        "::102:304",
345    };
346    String compatStr = "1.2.3.4";
347    InetAddress compat = InetAddresses.forString(compatStr);
348
349    for (int i = 0; i < validCompatAddresses.length; i++) {
350      InetAddress ip = InetAddresses.forString(validCompatAddresses[i]);
351      assertTrue("checking '" + validCompatAddresses[i] + "'", ip instanceof Inet6Address);
352      assertTrue("checking '" + validCompatAddresses[i] + "'",
353          InetAddresses.isCompatIPv4Address((Inet6Address) ip));
354      assertEquals("checking '" + validCompatAddresses[i] + "'", compat,
355                   InetAddresses.getCompatIPv4Address((Inet6Address) ip));
356    }
357  }
358
359  public void testMappedIPv4Addresses() throws UnknownHostException {
360    /*
361     * Verify that it is not possible to instantiate an Inet6Address
362     * from an "IPv4 mapped" IPv6 address.  Our String-based method can
363     * at least identify them, however.
364     */
365    String mappedStr = "::ffff:192.168.0.1";
366    assertTrue(InetAddresses.isMappedIPv4Address(mappedStr));
367    InetAddress mapped = InetAddresses.forString(mappedStr);
368    assertFalse(mapped instanceof Inet6Address);
369    assertEquals(InetAddress.getByName("192.168.0.1"), mapped);
370
371    // check upper case
372    mappedStr = "::FFFF:192.168.0.1";
373    assertTrue(InetAddresses.isMappedIPv4Address(mappedStr));
374    mapped = InetAddresses.forString(mappedStr);
375    assertFalse(mapped instanceof Inet6Address);
376    assertEquals(InetAddress.getByName("192.168.0.1"), mapped);
377
378    mappedStr = "0:00:000:0000:0:ffff:1.2.3.4";
379    assertTrue(InetAddresses.isMappedIPv4Address(mappedStr));
380    mapped = InetAddresses.forString(mappedStr);
381    assertFalse(mapped instanceof Inet6Address);
382    assertEquals(InetAddress.getByName("1.2.3.4"), mapped);
383
384    mappedStr = "::ffff:0102:0304";
385    assertTrue(InetAddresses.isMappedIPv4Address(mappedStr));
386    mapped = InetAddresses.forString(mappedStr);
387    assertFalse(mapped instanceof Inet6Address);
388    assertEquals(InetAddress.getByName("1.2.3.4"), mapped);
389
390    assertFalse(InetAddresses.isMappedIPv4Address("::"));
391    assertFalse(InetAddresses.isMappedIPv4Address("::ffff"));
392    assertFalse(InetAddresses.isMappedIPv4Address("::ffff:0"));
393    assertFalse(InetAddresses.isMappedIPv4Address("::fffe:0:0"));
394    assertFalse(InetAddresses.isMappedIPv4Address("::1:ffff:0:0"));
395    assertFalse(InetAddresses.isMappedIPv4Address("foo"));
396    assertFalse(InetAddresses.isMappedIPv4Address("192.0.2.1"));
397  }
398
399  public void test6to4Addresses() {
400    String[] non6to4Addresses = {
401        "::1.2.3.4",
402        "3ffe::1",
403        "::",
404        "::1",
405    };
406
407    for (int i = 0; i < non6to4Addresses.length; i++) {
408      InetAddress ip = InetAddresses.forString(non6to4Addresses[i]);
409      assertFalse(InetAddresses.is6to4Address((Inet6Address) ip));
410      try {
411        InetAddresses.get6to4IPv4Address(
412            (Inet6Address) ip);
413        fail("IllegalArgumentException expected for '" +
414             non6to4Addresses[i] + "'");
415      } catch (IllegalArgumentException expected) {
416        // expected behavior
417      }
418    }
419
420    String valid6to4Address = "2002:0102:0304::1";
421    String ipv4Str = "1.2.3.4";
422
423    InetAddress ipv4 = InetAddresses.forString(ipv4Str);
424    InetAddress ip = InetAddresses.forString(valid6to4Address);
425    assertTrue(InetAddresses.is6to4Address((Inet6Address) ip));
426    assertEquals(ipv4, InetAddresses.get6to4IPv4Address((Inet6Address) ip));
427  }
428
429  public void testTeredoAddresses() {
430    String[] nonTeredoAddresses = {
431        "::1.2.3.4",
432        "3ffe::1",
433        "::",
434        "::1",
435    };
436
437    for (int i = 0; i < nonTeredoAddresses.length; i++) {
438      InetAddress ip = InetAddresses.forString(nonTeredoAddresses[i]);
439      assertFalse(InetAddresses.isTeredoAddress((Inet6Address) ip));
440      try {
441        InetAddresses.getTeredoInfo((Inet6Address) ip);
442        fail("IllegalArgumentException expected for '" +
443             nonTeredoAddresses[i] + "'");
444      } catch (IllegalArgumentException expected) {
445        // expected behavior
446      }
447    }
448
449    String validTeredoAddress = "2001:0000:4136:e378:8000:63bf:3fff:fdd2";
450    String serverStr = "65.54.227.120";
451    String clientStr = "192.0.2.45";
452    int port = 40000;
453    int flags = 0x8000;
454
455    InetAddress ip = InetAddresses.forString(validTeredoAddress);
456    assertTrue(InetAddresses.isTeredoAddress((Inet6Address) ip));
457    InetAddresses.TeredoInfo teredo =
458        InetAddresses.getTeredoInfo((Inet6Address) ip);
459
460    InetAddress server = InetAddresses.forString(serverStr);
461    assertEquals(server, teredo.getServer());
462
463    InetAddress client = InetAddresses.forString(clientStr);
464    assertEquals(client, teredo.getClient());
465
466    assertEquals(port, teredo.getPort());
467    assertEquals(flags, teredo.getFlags());
468  }
469
470  public void testIsatapAddresses() {
471    InetAddress ipv4 = InetAddresses.forString("1.2.3.4");
472    String[] validIsatapAddresses = {
473        "2001:db8::5efe:102:304",
474        "2001:db8::100:5efe:102:304",  // Private Multicast? Not likely.
475        "2001:db8::200:5efe:102:304",
476        "2001:db8::300:5efe:102:304"   // Public Multicast? Also unlikely.
477    };
478    String[] nonIsatapAddresses = {
479        "::1.2.3.4",
480        "3ffe::1",
481        "::",
482        "::1",
483        "2001:db8::0040:5efe:102:304",
484        "2001:db8::5ffe:102:304",
485        "2001:db8::5eff:102:304",
486        "2001:0:102:203:200:5efe:506:708",  // Teredo address; not ISATAP
487    };
488
489    for (int i = 0; i < validIsatapAddresses.length; i++) {
490      InetAddress ip = InetAddresses.forString(validIsatapAddresses[i]);
491      assertTrue(InetAddresses.isIsatapAddress((Inet6Address) ip));
492      assertEquals("checking '" + validIsatapAddresses[i] + "'", ipv4,
493                   InetAddresses.getIsatapIPv4Address((Inet6Address) ip));
494    }
495    for (int i = 0; i < nonIsatapAddresses.length; i++) {
496      InetAddress ip = InetAddresses.forString(nonIsatapAddresses[i]);
497      assertFalse(InetAddresses.isIsatapAddress((Inet6Address) ip));
498      try {
499        InetAddresses.getIsatapIPv4Address((Inet6Address) ip);
500        fail("IllegalArgumentException expected for '" +
501             nonIsatapAddresses[i] + "'");
502      } catch (IllegalArgumentException expected) {
503        // expected behavior
504      }
505    }
506  }
507
508  public void testGetEmbeddedIPv4ClientAddress() {
509    Inet6Address testIp;
510
511    // Test regular global unicast address.
512    testIp = (Inet6Address) InetAddresses.forString("2001:db8::1");
513    assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
514
515    // Test ISATAP address.
516    testIp = (Inet6Address) InetAddresses.forString("2001:db8::5efe:102:304");
517    assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
518
519    // Test compat address.
520    testIp = (Inet6Address) InetAddresses.forString("::1.2.3.4");
521    assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
522    InetAddress ipv4 = InetAddresses.forString("1.2.3.4");
523    assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp));
524
525    // Test 6to4 address.
526    testIp = (Inet6Address) InetAddresses.forString("2002:0102:0304::1");
527    assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
528    ipv4 = InetAddresses.forString("1.2.3.4");
529    assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp));
530
531    // Test Teredo address.
532    testIp = (Inet6Address) InetAddresses.forString(
533        "2001:0000:4136:e378:8000:63bf:3fff:fdd2");
534    assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
535    ipv4 = InetAddresses.forString("192.0.2.45");
536    assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp));
537  }
538
539  public void testGetCoercedIPv4Address() {
540    // Check that a coerced IPv4 address is unaltered.
541    InetAddress localHost4 = InetAddresses.forString("127.0.0.1");
542    assertEquals(localHost4,
543                 InetAddresses.getCoercedIPv4Address(localHost4));
544
545    // ::1 special case
546    assertEquals(localHost4,
547                 InetAddresses.getCoercedIPv4Address(
548                     InetAddresses.forString("::1")));
549
550    // :: special case
551    assertEquals(InetAddresses.forString("0.0.0.0"),
552                 InetAddresses.getCoercedIPv4Address(
553                     InetAddresses.forString("::")));
554
555    // test compat address (should be hashed)
556    assertTrue(InetAddresses.forString("1.2.3.4") !=
557               InetAddresses.getCoercedIPv4Address(
558                   InetAddresses.forString("::1.2.3.4")));
559
560    // test 6to4 address (should be hashed)
561    assertTrue(InetAddresses.forString("1.2.3.4") !=
562               InetAddresses.getCoercedIPv4Address(
563                   InetAddresses.forString("2002:0102:0304::1")));
564
565    // 2 6to4 addresses differing in the embedded IPv4 address should
566    // hash to the different values.
567    assertTrue(InetAddresses.getCoercedIPv4Address(
568                   InetAddresses.forString("2002:0102:0304::1")) !=
569               InetAddresses.getCoercedIPv4Address(
570                   InetAddresses.forString("2002:0506:0708::1")));
571
572    // 2 6to4 addresses NOT differing in the embedded IPv4 address should
573    // hash to the same value.
574    assertTrue(InetAddresses.getCoercedIPv4Address(
575                   InetAddresses.forString("2002:0102:0304::1")) !=
576               InetAddresses.getCoercedIPv4Address(
577                   InetAddresses.forString("2002:0102:0304::2")));
578
579    // test Teredo address (should be hashed)
580    assertTrue(InetAddresses.forString("192.0.2.45") !=
581               InetAddresses.getCoercedIPv4Address(
582                   InetAddresses.forString(
583                       "2001:0000:4136:e378:8000:63bf:3fff:fdd2")));
584
585    // 2 Teredo addresses differing in the embedded IPv4 address should
586    // hash to the different values.
587    assertTrue(InetAddresses.getCoercedIPv4Address(
588                   InetAddresses.forString(
589                       "2001:0000:4136:e378:8000:63bf:3fff:fdd2")) !=
590               InetAddresses.getCoercedIPv4Address(
591                   InetAddresses.forString(
592                       "2001:0000:4136:e379:8000:63bf:3fff:fdd2")));
593
594    // 2 Teredo addresses NOT differing in the embedded IPv4 address should
595    // hash to the same value.
596    assertEquals(InetAddresses.getCoercedIPv4Address(
597                     InetAddresses.forString(
598                         "2001:0000:4136:e378:8000:63bf:3fff:fdd2")),
599                 InetAddresses.getCoercedIPv4Address(
600                     InetAddresses.forString(
601                         "2001:0000:4136:e378:9000:63bf:3fff:fdd2")));
602
603    // Test that an address hashes in to the 224.0.0.0/3 number-space.
604    InetAddress coerced = InetAddresses.getCoercedIPv4Address(
605                              InetAddresses.forString("2001:4860::1"));
606    assertTrue(0xe0000000 <= InetAddresses.coerceToInteger(coerced));
607    assertTrue(InetAddresses.coerceToInteger(coerced) <= 0xfffffffe);
608  }
609
610  public void testHash64To32() {
611    // Make sure the output looks reasonably sane.
612    assertEquals(532412650, InetAddresses.hash64To32(-1));
613    assertEquals(720020139, InetAddresses.hash64To32(0));
614    assertEquals(357654460, InetAddresses.hash64To32(1));
615    assertEquals(-1977349188, InetAddresses.hash64To32(0x7fffffffffffffffL));
616  }
617
618  public void testToInteger() {
619    InetAddress ipv4Addr = InetAddresses.forString("127.0.0.1");
620    assertEquals(0x7f000001, InetAddresses.coerceToInteger(ipv4Addr));
621  }
622
623  public void testFromInteger() {
624    assertEquals(InetAddresses.fromInteger(0x7f000001),
625                 InetAddresses.forString("127.0.0.1"));
626  }
627
628  public void testFromLittleEndianByteArray() throws UnknownHostException {
629    assertEquals(
630        InetAddresses.fromLittleEndianByteArray(new byte[] {1, 2, 3, 4}),
631        InetAddress.getByAddress(new byte[] {4, 3, 2, 1}));
632
633    assertEquals(
634        InetAddresses.fromLittleEndianByteArray(
635            new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}),
636        InetAddress.getByAddress(
637            new byte[] {16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}));
638
639    try {
640      InetAddresses.fromLittleEndianByteArray(new byte[3]);
641      fail("expected exception");
642    } catch (UnknownHostException expected) {
643      // success
644    }
645  }
646
647  public void testIsMaximum() throws UnknownHostException {
648    InetAddress address = InetAddress.getByName("255.255.255.254");
649    assertFalse(InetAddresses.isMaximum(address));
650
651    address = InetAddress.getByName("255.255.255.255");
652    assertTrue(InetAddresses.isMaximum(address));
653
654    address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe");
655    assertFalse(InetAddresses.isMaximum(address));
656
657    address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
658    assertTrue(InetAddresses.isMaximum(address));
659  }
660
661  public void testIncrementIPv4() throws UnknownHostException {
662    InetAddress address_66_0 = InetAddress.getByName("172.24.66.0");
663    InetAddress address_66_255 = InetAddress.getByName("172.24.66.255");
664    InetAddress address_67_0 = InetAddress.getByName("172.24.67.0");
665
666    InetAddress address = address_66_0;
667    for (int i = 0; i < 255; i++) {
668      address = InetAddresses.increment(address);
669    }
670    assertEquals(address_66_255, address);
671
672    address = InetAddresses.increment(address);
673    assertEquals(address_67_0, address);
674
675    InetAddress address_ffffff = InetAddress.getByName("255.255.255.255");
676    address = address_ffffff;
677    try {
678      address = InetAddresses.increment(address);
679      fail();
680    } catch (IllegalArgumentException expected) { }
681  }
682
683  public void testIncrementIPv6() throws UnknownHostException {
684    InetAddress addressV6_66_0 = InetAddress.getByName("2001:db8::6600");
685    InetAddress addressV6_66_ff = InetAddress.getByName("2001:db8::66ff");
686    InetAddress addressV6_67_0 = InetAddress.getByName("2001:db8::6700");
687
688    InetAddress address = addressV6_66_0;
689    for (int i = 0; i < 255; i++) {
690      address = InetAddresses.increment(address);
691    }
692    assertEquals(addressV6_66_ff, address);
693
694    address = InetAddresses.increment(address);
695    assertEquals(addressV6_67_0, address);
696
697    InetAddress addressV6_ffffff =
698        InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
699    address = addressV6_ffffff;
700    try {
701      address = InetAddresses.increment(address);
702      fail();
703    } catch (IllegalArgumentException expected) { }
704  }
705}
706