1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.net;
18
19 import com.google.common.testing.NullPointerTester;
20
21 import junit.framework.TestCase;
22
23 import java.net.Inet4Address;
24 import java.net.Inet6Address;
25 import java.net.InetAddress;
26 import java.net.UnknownHostException;
27
28
29
30
31
32
33 public 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:",
78 ":6:5:4:3:2:1::",
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",
84 "7:6:5:4:3:2:1:0::",
85 "9:8:7:6:5:4:3::2:1",
86 "0:1:2:3::4:5:6:7",
87 "3ffe:0:0:0:0:0:0:0:1",
88 "3ffe::10000",
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
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
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
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
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
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
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
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
228
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");
270 } catch (IllegalArgumentException e) {
271
272 }
273
274 try {
275 InetAddresses.forUriString("192.168.999.888");
276 fail("expected IllegalArgumentException");
277 } catch (IllegalArgumentException e) {
278
279 }
280
281 try {
282 InetAddresses.forUriString("www.google.com");
283 fail("expected IllegalArgumentException");
284 } catch (IllegalArgumentException e) {
285
286 }
287
288 try {
289 InetAddresses.forUriString("[1:2e]");
290 fail("expected IllegalArgumentException");
291 } catch (IllegalArgumentException e) {
292
293 }
294
295 try {
296 InetAddresses.forUriString("[192.168.1.1]");
297 fail("expected IllegalArgumentException");
298 } catch (IllegalArgumentException e) {
299
300 }
301
302 try {
303 InetAddresses.forUriString("192.168.1.1]");
304 fail("expected IllegalArgumentException");
305 } catch (IllegalArgumentException e) {
306
307 }
308
309 try {
310 InetAddresses.forUriString("[192.168.1.1");
311 fail("expected IllegalArgumentException");
312 } catch (IllegalArgumentException e) {
313
314 }
315
316 try {
317 InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1");
318 fail("expected IllegalArgumentException");
319 } catch (IllegalArgumentException e) {
320
321 }
322
323 try {
324 InetAddresses.forUriString("3ffe:0:0:0:0:0:0:1]");
325 fail("expected IllegalArgumentException");
326 } catch (IllegalArgumentException e) {
327
328 }
329
330 try {
331 InetAddresses.forUriString("3ffe:0:0:0:0:0:0:1");
332 fail("expected IllegalArgumentException");
333 } catch (IllegalArgumentException e) {
334
335 }
336
337 try {
338 InetAddresses.forUriString("::ffff:192.0.2.1");
339 fail("expected IllegalArgumentException");
340 } catch (IllegalArgumentException e) {
341
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
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
384
385
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
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
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
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",
505 "2001:db8::200:5efe:102:304",
506 "2001:db8::300:5efe:102:304"
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",
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
534 }
535 }
536 }
537
538 public void testGetEmbeddedIPv4ClientAddress() {
539 Inet6Address testIp;
540
541
542 testIp = (Inet6Address) InetAddresses.forString("2001:db8::1");
543 assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
544
545
546 testIp = (Inet6Address) InetAddresses.forString("2001:db8::5efe:102:304");
547 assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp));
548
549
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
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
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
571 InetAddress localHost4 = InetAddresses.forString("127.0.0.1");
572 assertEquals(localHost4,
573 InetAddresses.getCoercedIPv4Address(localHost4));
574
575
576 assertEquals(localHost4,
577 InetAddresses.getCoercedIPv4Address(
578 InetAddresses.forString("::1")));
579
580
581 assertEquals(InetAddresses.forString("0.0.0.0"),
582 InetAddresses.getCoercedIPv4Address(
583 InetAddresses.forString("::")));
584
585
586 assertTrue(InetAddresses.forString("1.2.3.4") !=
587 InetAddresses.getCoercedIPv4Address(
588 InetAddresses.forString("::1.2.3.4")));
589
590
591 assertTrue(InetAddresses.forString("1.2.3.4") !=
592 InetAddresses.getCoercedIPv4Address(
593 InetAddresses.forString("2002:0102:0304::1")));
594
595
596
597 assertTrue(InetAddresses.getCoercedIPv4Address(
598 InetAddresses.forString("2002:0102:0304::1")) !=
599 InetAddresses.getCoercedIPv4Address(
600 InetAddresses.forString("2002:0506:0708::1")));
601
602
603
604 assertTrue(InetAddresses.getCoercedIPv4Address(
605 InetAddresses.forString("2002:0102:0304::1")) !=
606 InetAddresses.getCoercedIPv4Address(
607 InetAddresses.forString("2002:0102:0304::2")));
608
609
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
616
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
625
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
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
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 public void testDecrementIPv4() throws UnknownHostException {
729 InetAddress address660 = InetAddress.getByName("172.24.66.0");
730 InetAddress address66255 = InetAddress.getByName("172.24.66.255");
731 InetAddress address670 = InetAddress.getByName("172.24.67.0");
732
733 InetAddress address = address670;
734 address = InetAddresses.decrement(address);
735
736 assertEquals(address66255, address);
737
738 for (int i = 0; i < 255; i++) {
739 address = InetAddresses.decrement(address);
740 }
741 assertEquals(address660, address);
742
743 InetAddress address0000 = InetAddress.getByName("0.0.0.0");
744 address = address0000;
745 try {
746 address = InetAddresses.decrement(address);
747 fail();
748 } catch (IllegalArgumentException expected) {}
749 }
750
751 public void testDecrementIPv6() throws UnknownHostException {
752 InetAddress addressV6660 = InetAddress.getByName("2001:db8::6600");
753 InetAddress addressV666ff = InetAddress.getByName("2001:db8::66ff");
754 InetAddress addressV6670 = InetAddress.getByName("2001:db8::6700");
755
756 InetAddress address = addressV6670;
757 address = InetAddresses.decrement(address);
758
759 assertEquals(addressV666ff, address);
760
761 for (int i = 0; i < 255; i++) {
762 address = InetAddresses.decrement(address);
763 }
764 assertEquals(addressV6660, address);
765
766 InetAddress addressV6000000 =
767 InetAddress.getByName("0:0:0:0:0:0:0:0");
768 address = addressV6000000;
769 try {
770 address = InetAddresses.decrement(address);
771 fail();
772 } catch (IllegalArgumentException expected) {}
773 }
774 }