InetAddressesTest.java revision 0888a09821a98ac0680fad765217302858e70fa4 
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() {
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 testForUriStringIPv4Mapped() {
245    Inet4Address expected = (Inet4Address) InetAddresses.forString("192.0.2.1");
246    assertEquals(expected, InetAddresses.forUriString("[::ffff:192.0.2.1]"));
247  }
248
249  public void testIsUriInetAddress() {
250    assertTrue(InetAddresses.isUriInetAddress("192.168.1.1"));
251    assertTrue(InetAddresses.isUriInetAddress("[3ffe:0:0:0:0:0:0:1]"));
252    assertTrue(InetAddresses.isUriInetAddress("[::ffff:192.0.2.1]"));
253
254    assertFalse(InetAddresses.isUriInetAddress("[192.168.1.1"));
255    assertFalse(InetAddresses.isUriInetAddress("192.168.1.1]"));
256    assertFalse(InetAddresses.isUriInetAddress(""));
257    assertFalse(InetAddresses.isUriInetAddress("192.168.999.888"));
258    assertFalse(InetAddresses.isUriInetAddress("www.google.com"));
259    assertFalse(InetAddresses.isUriInetAddress("1:2e"));
260    assertFalse(InetAddresses.isUriInetAddress("[3ffe:0:0:0:0:0:0:1"));
261    assertFalse(InetAddresses.isUriInetAddress("3ffe:0:0:0:0:0:0:1]"));
262    assertFalse(InetAddresses.isUriInetAddress("3ffe:0:0:0:0:0:0:1"));
263    assertFalse(InetAddresses.isUriInetAddress("::ffff:192.0.2.1"));
264  }
265
266  public void testForUriStringBad() {
267    try {
268      InetAddresses.forUriString("");
269      fail("expected IllegalArgumentException");  // COV_NF_LINE
270    } catch (IllegalArgumentException e) {
271      // expected
272    }
273
274    try {
275      InetAddresses.forUriString("192.168.999.888");
276      fail("expected IllegalArgumentException");  // COV_NF_LINE
277    } catch (IllegalArgumentException e) {
278      // expected
279    }
280
281    try {
282      InetAddresses.forUriString("www.google.com");
283      fail("expected IllegalArgumentException");  // COV_NF_LINE
284    } catch (IllegalArgumentException e) {
285      // expected
286    }
287
288    try {
289      InetAddresses.forUriString("[1:2e]");
290      fail("expected IllegalArgumentException");  // COV_NF_LINE
291    } catch (IllegalArgumentException e) {
292      // expected
293    }
294
295    try {
296      InetAddresses.forUriString("[192.168.1.1]");
297      fail("expected IllegalArgumentException");  // COV_NF_LINE
298    } catch (IllegalArgumentException e) {
299      // expected
300    }
301
302    try {
303      InetAddresses.forUriString("192.168.1.1]");
304      fail("expected IllegalArgumentException");  // COV_NF_LINE
305    } catch (IllegalArgumentException e) {
306      // expected
307    }
308
309    try {
310      InetAddresses.forUriString("[192.168.1.1");
311      fail("expected IllegalArgumentException");  // COV_NF_LINE
312    } catch (IllegalArgumentException e) {
313      // expected
314    }
315
316    try {
317      InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1");
318      fail("expected IllegalArgumentException");  // COV_NF_LINE
319    } catch (IllegalArgumentException e) {
320      // expected
321    }
322
323    try {
324      InetAddresses.forUriString("3ffe:0:0:0:0:0:0:1]");
325      fail("expected IllegalArgumentException");  // COV_NF_LINE
326    } catch (IllegalArgumentException e) {
327      // expected
328    }
329
330    try {
331      InetAddresses.forUriString("3ffe:0:0:0:0:0:0:1");
332      fail("expected IllegalArgumentException");  // COV_NF_LINE
333    } catch (IllegalArgumentException e) {
334      // expected
335    }
336
337    try {
338      InetAddresses.forUriString("::ffff:192.0.2.1");
339      fail("expected IllegalArgumentException");  // COV_NF_LINE
340    } catch (IllegalArgumentException e) {
341      // expected
342    }
343  }
344
345  public void testCompatIPv4Addresses() {
346    String[] nonCompatAddresses = {
347        "3ffe::1",
348        "::",
349        "::1",
350    };
351
352    for (int i = 0; i < nonCompatAddresses.length; i++) {
353      InetAddress ip = InetAddresses.forString(nonCompatAddresses[i]);
354      assertFalse(InetAddresses.isCompatIPv4Address((Inet6Address) ip));
355      try {
356        InetAddresses.getCompatIPv4Address((Inet6Address) ip);
357        fail("IllegalArgumentException expected for '" +
358             nonCompatAddresses[i] + "'");
359      } catch (IllegalArgumentException expected) {
360        // expected behavior
361      }
362    }
363
364    String[] validCompatAddresses = {
365        "::1.2.3.4",
366        "::102:304",
367    };
368    String compatStr = "1.2.3.4";
369    InetAddress compat = InetAddresses.forString(compatStr);
370
371    for (int i = 0; i < validCompatAddresses.length; i++) {
372      InetAddress ip = InetAddresses.forString(validCompatAddresses[i]);
373      assertTrue("checking '" + validCompatAddresses[i] + "'", ip instanceof Inet6Address);
374      assertTrue("checking '" + validCompatAddresses[i] + "'",
375          InetAddresses.isCompatIPv4Address((Inet6Address) ip));
376      assertEquals("checking '" + validCompatAddresses[i] + "'", compat,
377                   InetAddresses.getCompatIPv4Address((Inet6Address) ip));
378    }
379  }
380
381  public void testMappedIPv4Addresses() throws UnknownHostException {
382    /*
383     * Verify that it is not possible to instantiate an Inet6Address
384     * from an "IPv4 mapped" IPv6 address.  Our String-based method can
385     * at least identify them, however.
386     */
387    String mappedStr = "::ffff:192.168.0.1";
388    assertTrue(InetAddresses.isMappedIPv4Address(mappedStr));
389    InetAddress mapped = InetAddresses.forString(mappedStr);
390    assertFalse(mapped instanceof Inet6Address);
391    assertEquals(InetAddress.getByName("192.168.0.1"), mapped);
392
393    // check upper case
394    mappedStr = "::FFFF:192.168.0.1";
395    assertTrue(InetAddresses.isMappedIPv4Address(mappedStr));
396    mapped = InetAddresses.forString(mappedStr);
397    assertFalse(mapped instanceof Inet6Address);
398    assertEquals(InetAddress.getByName("192.168.0.1"), mapped);
399
400    mappedStr = "0:00:000:0000:0:ffff:1.2.3.4";
401    assertTrue(InetAddresses.isMappedIPv4Address(mappedStr));
402    mapped = InetAddresses.forString(mappedStr);
403    assertFalse(mapped instanceof Inet6Address);
404    assertEquals(InetAddress.getByName("1.2.3.4"), mapped);
405
406    mappedStr = "::ffff:0102:0304";
407    assertTrue(InetAddresses.isMappedIPv4Address(mappedStr));
408    mapped = InetAddresses.forString(mappedStr);
409    assertFalse(mapped instanceof Inet6Address);
410    assertEquals(InetAddress.getByName("1.2.3.4"), mapped);
411
412    assertFalse(InetAddresses.isMappedIPv4Address("::"));
413    assertFalse(InetAddresses.isMappedIPv4Address("::ffff"));
414    assertFalse(InetAddresses.isMappedIPv4Address("::ffff:0"));
415    assertFalse(InetAddresses.isMappedIPv4Address("::fffe:0:0"));
416    assertFalse(InetAddresses.isMappedIPv4Address("::1:ffff:0:0"));
417    assertFalse(InetAddresses.isMappedIPv4Address("foo"));
418    assertFalse(InetAddresses.isMappedIPv4Address("192.0.2.1"));
419  }
420
421  public void test6to4Addresses() {
422    String[] non6to4Addresses = {
423        "::1.2.3.4",
424        "3ffe::1",
425        "::",
426        "::1",
427    };
428
429    for (int i = 0; i < non6to4Addresses.length; i++) {
430      InetAddress ip = InetAddresses.forString(non6to4Addresses[i]);
431      assertFalse(InetAddresses.is6to4Address((Inet6Address) ip));
432      try {
433        InetAddresses.get6to4IPv4Address(
434            (Inet6Address) ip);
435        fail("IllegalArgumentException expected for '" +
436             non6to4Addresses[i] + "'");
437      } catch (IllegalArgumentException expected) {
438        // expected behavior
439      }
440    }
441
442    String valid6to4Address = "2002:0102:0304::1";
443    String ipv4Str = "1.2.3.4";
444
445    InetAddress ipv4 = InetAddresses.forString(ipv4Str);
446    InetAddress ip = InetAddresses.forString(valid6to4Address);
447    assertTrue(InetAddresses.is6to4Address((Inet6Address) ip));
448    assertEquals(ipv4, InetAddresses.get6to4IPv4Address((Inet6Address) ip));
449  }
450
451  public void testTeredoAddresses() {
452    String[] nonTeredoAddresses = {
453        "::1.2.3.4",
454        "3ffe::1",
455        "::",
456        "::1",
457    };
458
459    for (int i = 0; i < nonTeredoAddresses.length; i++) {
460      InetAddress ip = InetAddresses.forString(nonTeredoAddresses[i]);
461      assertFalse(InetAddresses.isTeredoAddress((Inet6Address) ip));
462      try {
463        InetAddresses.getTeredoInfo((Inet6Address) ip);
464        fail("IllegalArgumentException expected for '" +
465             nonTeredoAddresses[i] + "'");
466      } catch (IllegalArgumentException expected) {
467        // expected behavior
468      }
469    }
470
471    String validTeredoAddress = "2001:0000:4136:e378:8000:63bf:3fff:fdd2";
472    String serverStr = "65.54.227.120";
473    String clientStr = "192.0.2.45";
474    int port = 40000;
475    int flags = 0x8000;
476
477    InetAddress ip = InetAddresses.forString(validTeredoAddress);
478    assertTrue(InetAddresses.isTeredoAddress((Inet6Address) ip));
479    InetAddresses.TeredoInfo teredo =
480        InetAddresses.getTeredoInfo((Inet6Address) ip);
481
482    InetAddress server = InetAddresses.forString(serverStr);
483    assertEquals(server, teredo.getServer());
484
485    InetAddress client = InetAddresses.forString(clientStr);
486    assertEquals(client, teredo.getClient());
487
488    assertEquals(port, teredo.getPort());
489    assertEquals(flags, teredo.getFlags());
490  }
491
492  public void testTeredoAddress_nullServer() {
493    InetAddresses.TeredoInfo info = new InetAddresses.TeredoInfo(null, null, 80, 1000);
494    assertEquals(InetAddresses.forString("0.0.0.0"), info.getServer());
495    assertEquals(InetAddresses.forString("0.0.0.0"), info.getClient());
496    assertEquals(80, info.getPort());
497    assertEquals(1000, info.getFlags());
498  }
499
500  public void testIsatapAddresses() {
501    InetAddress ipv4 = InetAddresses.forString("1.2.3.4");
502    String[] validIsatapAddresses = {
503        "2001:db8::5efe:102:304",
504        "2001:db8::100:5efe:102:304",  // Private Multicast? Not likely.
505        "2001:db8::200:5efe:102:304",
506        "2001:db8::300:5efe:102:304"   // Public Multicast? Also unlikely.
507    };
508    String[] nonIsatapAddresses = {
509        "::1.2.3.4",
510        "3ffe::1",
511        "::",
512        "::1",
513        "2001:db8::0040:5efe:102:304",
514        "2001:db8::5ffe:102:304",
515        "2001:db8::5eff:102:304",
516        "2001:0:102:203:200:5efe:506:708",  // Teredo address; not ISATAP
517    };
518
519    for (int i = 0; i < validIsatapAddresses.length; i++) {
520      InetAddress ip = InetAddresses.forString(validIsatapAddresses[i]);
521      assertTrue(InetAddresses.isIsatapAddress((Inet6Address) ip));
522      assertEquals("checking '" + validIsatapAddresses[i] + "'", ipv4,
523                   InetAddresses.getIsatapIPv4Address((Inet6Address) ip));
524    }
525    for (int i = 0; i < nonIsatapAddresses.length; i++) {
526      InetAddress ip = InetAddresses.forString(nonIsatapAddresses[i]);
527      assertFalse(InetAddresses.isIsatapAddress((Inet6Address) ip));
528      try {
529        InetAddresses.getIsatapIPv4Address((Inet6Address) ip);
530        fail("IllegalArgumentException expected for '" +
531             nonIsatapAddresses[i] + "'");
532      } catch (IllegalArgumentException expected) {
533        // expected behavior
534      }
535    }
536  }
537
538  public void testGetEmbeddedIPv4ClientAddress() {
539    Inet6Address testIp;
540
541    // Test regular global unicast address.
542    testIp = (Inet6Address) InetAddresses.forString("2001:db8::1");
543    assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
544
545    // Test ISATAP address.
546    testIp = (Inet6Address) InetAddresses.forString("2001:db8::5efe:102:304");
547    assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
548
549    // Test compat address.
550    testIp = (Inet6Address) InetAddresses.forString("::1.2.3.4");
551    assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
552    InetAddress ipv4 = InetAddresses.forString("1.2.3.4");
553    assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp));
554
555    // Test 6to4 address.
556    testIp = (Inet6Address) InetAddresses.forString("2002:0102:0304::1");
557    assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
558    ipv4 = InetAddresses.forString("1.2.3.4");
559    assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp));
560
561    // Test Teredo address.
562    testIp = (Inet6Address) InetAddresses.forString(
563        "2001:0000:4136:e378:8000:63bf:3fff:fdd2");
564    assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
565    ipv4 = InetAddresses.forString("192.0.2.45");
566    assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp));
567  }
568
569  public void testGetCoercedIPv4Address() {
570    // Check that a coerced IPv4 address is unaltered.
571    InetAddress localHost4 = InetAddresses.forString("127.0.0.1");
572    assertEquals(localHost4,
573                 InetAddresses.getCoercedIPv4Address(localHost4));
574
575    // ::1 special case
576    assertEquals(localHost4,
577                 InetAddresses.getCoercedIPv4Address(
578                     InetAddresses.forString("::1")));
579
580    // :: special case
581    assertEquals(InetAddresses.forString("0.0.0.0"),
582                 InetAddresses.getCoercedIPv4Address(
583                     InetAddresses.forString("::")));
584
585    // test compat address (should be hashed)
586    assertTrue(InetAddresses.forString("1.2.3.4") !=
587               InetAddresses.getCoercedIPv4Address(
588                   InetAddresses.forString("::1.2.3.4")));
589
590    // test 6to4 address (should be hashed)
591    assertTrue(InetAddresses.forString("1.2.3.4") !=
592               InetAddresses.getCoercedIPv4Address(
593                   InetAddresses.forString("2002:0102:0304::1")));
594
595    // 2 6to4 addresses differing in the embedded IPv4 address should
596    // hash to the different values.
597    assertTrue(InetAddresses.getCoercedIPv4Address(
598                   InetAddresses.forString("2002:0102:0304::1")) !=
599               InetAddresses.getCoercedIPv4Address(
600                   InetAddresses.forString("2002:0506:0708::1")));
601
602    // 2 6to4 addresses NOT differing in the embedded IPv4 address should
603    // hash to the same value.
604    assertTrue(InetAddresses.getCoercedIPv4Address(
605                   InetAddresses.forString("2002:0102:0304::1")) !=
606               InetAddresses.getCoercedIPv4Address(
607                   InetAddresses.forString("2002:0102:0304::2")));
608
609    // test Teredo address (should be hashed)
610    assertTrue(InetAddresses.forString("192.0.2.45") !=
611               InetAddresses.getCoercedIPv4Address(
612                   InetAddresses.forString(
613                       "2001:0000:4136:e378:8000:63bf:3fff:fdd2")));
614
615    // 2 Teredo addresses differing in the embedded IPv4 address should
616    // hash to the different values.
617    assertTrue(InetAddresses.getCoercedIPv4Address(
618                   InetAddresses.forString(
619                       "2001:0000:4136:e378:8000:63bf:3fff:fdd2")) !=
620               InetAddresses.getCoercedIPv4Address(
621                   InetAddresses.forString(
622                       "2001:0000:4136:e379:8000:63bf:3fff:fdd2")));
623
624    // 2 Teredo addresses NOT differing in the embedded IPv4 address should
625    // hash to the same value.
626    assertEquals(InetAddresses.getCoercedIPv4Address(
627                     InetAddresses.forString(
628                         "2001:0000:4136:e378:8000:63bf:3fff:fdd2")),
629                 InetAddresses.getCoercedIPv4Address(
630                     InetAddresses.forString(
631                         "2001:0000:4136:e378:9000:63bf:3fff:fdd2")));
632
633    // Test that an address hashes in to the 224.0.0.0/3 number-space.
634    InetAddress coerced = InetAddresses.getCoercedIPv4Address(
635                              InetAddresses.forString("2001:4860::1"));
636    assertTrue(0xe0000000 <= InetAddresses.coerceToInteger(coerced));
637    assertTrue(InetAddresses.coerceToInteger(coerced) <= 0xfffffffe);
638  }
639
640  public void testToInteger() {
641    InetAddress ipv4Addr = InetAddresses.forString("127.0.0.1");
642    assertEquals(0x7f000001, InetAddresses.coerceToInteger(ipv4Addr));
643  }
644
645  public void testFromInteger() {
646    assertEquals(InetAddresses.fromInteger(0x7f000001),
647                 InetAddresses.forString("127.0.0.1"));
648  }
649
650  public void testFromLittleEndianByteArray() throws UnknownHostException {
651    assertEquals(
652        InetAddresses.fromLittleEndianByteArray(new byte[] {1, 2, 3, 4}),
653        InetAddress.getByAddress(new byte[] {4, 3, 2, 1}));
654
655    assertEquals(
656        InetAddresses.fromLittleEndianByteArray(
657            new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}),
658        InetAddress.getByAddress(
659            new byte[] {16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}));
660
661    try {
662      InetAddresses.fromLittleEndianByteArray(new byte[3]);
663      fail("expected exception");
664    } catch (UnknownHostException expected) {
665      // success
666    }
667  }
668
669  public void testIsMaximum() throws UnknownHostException {
670    InetAddress address = InetAddress.getByName("255.255.255.254");
671    assertFalse(InetAddresses.isMaximum(address));
672
673    address = InetAddress.getByName("255.255.255.255");
674    assertTrue(InetAddresses.isMaximum(address));
675
676    address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe");
677    assertFalse(InetAddresses.isMaximum(address));
678
679    address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
680    assertTrue(InetAddresses.isMaximum(address));
681  }
682
683  public void testIncrementIPv4() throws UnknownHostException {
684    InetAddress address_66_0 = InetAddress.getByName("172.24.66.0");
685    InetAddress address_66_255 = InetAddress.getByName("172.24.66.255");
686    InetAddress address_67_0 = InetAddress.getByName("172.24.67.0");
687
688    InetAddress address = address_66_0;
689    for (int i = 0; i < 255; i++) {
690      address = InetAddresses.increment(address);
691    }
692    assertEquals(address_66_255, address);
693
694    address = InetAddresses.increment(address);
695    assertEquals(address_67_0, address);
696
697    InetAddress address_ffffff = InetAddress.getByName("255.255.255.255");
698    address = address_ffffff;
699    try {
700      address = InetAddresses.increment(address);
701      fail();
702    } catch (IllegalArgumentException expected) {}
703  }
704
705  public void testIncrementIPv6() throws UnknownHostException {
706    InetAddress addressV6_66_0 = InetAddress.getByName("2001:db8::6600");
707    InetAddress addressV6_66_ff = InetAddress.getByName("2001:db8::66ff");
708    InetAddress addressV6_67_0 = InetAddress.getByName("2001:db8::6700");
709
710    InetAddress address = addressV6_66_0;
711    for (int i = 0; i < 255; i++) {
712      address = InetAddresses.increment(address);
713    }
714    assertEquals(addressV6_66_ff, address);
715
716    address = InetAddresses.increment(address);
717    assertEquals(addressV6_67_0, address);
718
719    InetAddress addressV6_ffffff =
720        InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
721    address = addressV6_ffffff;
722    try {
723      address = InetAddresses.increment(address);
724      fail();
725    } catch (IllegalArgumentException expected) {}
726  }
727}
728