InetAddressTest.java revision 2ea0b34ba1e3bf712e052304747a3bc6c78e8208 
1/*
2 * Copyright (C) 2011 The Android Open Source Project
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 libcore.java.net;
18
19import java.net.Inet4Address;
20import java.net.Inet6Address;
21import java.net.InetAddress;
22import java.net.NetworkInterface;
23import java.net.UnknownHostException;
24import java.util.Collections;
25import libcore.util.SerializationTester;
26
27public class InetAddressTest extends junit.framework.TestCase {
28    private static final byte[] LOOPBACK6_BYTES = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
29
30    private static final String[] INVALID_IPv4_NUMERIC_ADDRESSES = new String[] {
31        // IPv4 addresses may not be surrounded by square brackets.
32        "[127.0.0.1]",
33
34        // Trailing dots are not allowed.
35        "1.2.3.4.",
36        // Nor is any kind of trailing junk.
37        "1.2.3.4hello",
38
39        // Out of range.
40        "256.2.3.4",
41        "1.256.3.4",
42        "1.2.256.4",
43        "1.2.3.256",
44
45        // Deprecated.
46        "1.2.3",
47        "1.2",
48        "1",
49        "1234",
50        "0", // Single out the deprecated form of the ANY address.
51
52        // Hex.
53        "0x1.0x2.0x3.0x4",
54        "0x7f.0x00.0x00.0x01",
55        "7f.0.0.1",
56
57        // Octal.
58        "0177.00.00.01", // Historically, this would have been interpreted as 127.0.0.1.
59
60        // Negative numbers.
61        "-1.0.0.1",
62        "1.-1.0.1",
63        "1.0.-1.1",
64        "1.0.0.-1",
65    };
66
67    private static Inet6Address loopback6() throws Exception {
68        return (Inet6Address) InetAddress.getByAddress(LOOPBACK6_BYTES);
69    }
70
71    private static Inet6Address localhost6() throws Exception {
72        return (Inet6Address) InetAddress.getByAddress("localhost", LOOPBACK6_BYTES);
73    }
74
75    public void test_parseNumericAddress() throws Exception {
76        // Regular IPv4.
77        assertEquals("/1.2.3.4", InetAddress.parseNumericAddress("1.2.3.4").toString());
78        // Regular IPv6.
79        assertEquals("/2001:4860:800d::68", InetAddress.parseNumericAddress("2001:4860:800d::68").toString());
80        // Mapped IPv4
81        assertEquals("/127.0.0.1", InetAddress.parseNumericAddress("::ffff:127.0.0.1").toString());
82        // Optional square brackets around IPv6 addresses, including mapped IPv4.
83        assertEquals("/2001:4860:800d::68", InetAddress.parseNumericAddress("[2001:4860:800d::68]").toString());
84        assertEquals("/127.0.0.1", InetAddress.parseNumericAddress("[::ffff:127.0.0.1]").toString());
85
86        try {
87            InetAddress.parseNumericAddress("example.com"); // Not numeric.
88            fail();
89        } catch (IllegalArgumentException expected) {
90        }
91
92        for (String invalid : INVALID_IPv4_NUMERIC_ADDRESSES) {
93            try {
94                InetAddress.parseNumericAddress(invalid);
95                fail(invalid);
96            } catch (IllegalArgumentException expected) {
97            }
98        }
99
100        // Strange special cases, for compatibility with InetAddress.getByName.
101        assertTrue(InetAddress.parseNumericAddress(null).isLoopbackAddress());
102        assertTrue(InetAddress.parseNumericAddress("").isLoopbackAddress());
103    }
104
105    public void test_isNumeric() throws Exception {
106        // IPv4
107        assertTrue(InetAddress.isNumeric("1.2.3.4"));
108        assertTrue(InetAddress.isNumeric("127.0.0.1"));
109
110        // IPv6
111        assertTrue(InetAddress.isNumeric("::1"));
112        assertTrue(InetAddress.isNumeric("2001:4860:800d::68"));
113
114        // Mapped IPv4
115        assertTrue(InetAddress.isNumeric("::ffff:127.0.0.1"));
116
117        // Optional square brackets around IPv6 addresses, including mapped IPv4.
118        assertTrue(InetAddress.isNumeric("[2001:4860:800d::68]"));
119        assertTrue(InetAddress.isNumeric("[::ffff:127.0.0.1]"));
120
121        // Negative test
122        assertFalse(InetAddress.isNumeric("example.com"));
123
124        for (String invalid : INVALID_IPv4_NUMERIC_ADDRESSES) {
125            assertFalse(invalid, InetAddress.isNumeric(invalid));
126        }
127    }
128
129    public void test_isLinkLocalAddress() throws Exception {
130        assertFalse(InetAddress.getByName("127.0.0.1").isLinkLocalAddress());
131        assertFalse(InetAddress.getByName("::ffff:127.0.0.1").isLinkLocalAddress());
132        assertTrue(InetAddress.getByName("169.254.1.2").isLinkLocalAddress());
133
134        assertFalse(InetAddress.getByName("fec0::").isLinkLocalAddress());
135        assertTrue(InetAddress.getByName("fe80::").isLinkLocalAddress());
136    }
137
138    public void test_isMCSiteLocalAddress() throws Exception {
139        assertFalse(InetAddress.getByName("239.254.255.255").isMCSiteLocal());
140        assertTrue(InetAddress.getByName("239.255.0.0").isMCSiteLocal());
141        assertTrue(InetAddress.getByName("239.255.255.255").isMCSiteLocal());
142        assertFalse(InetAddress.getByName("240.0.0.0").isMCSiteLocal());
143
144        assertFalse(InetAddress.getByName("ff06::").isMCSiteLocal());
145        assertTrue(InetAddress.getByName("ff05::").isMCSiteLocal());
146        assertTrue(InetAddress.getByName("ff15::").isMCSiteLocal());
147    }
148
149    public void test_isReachable() throws Exception {
150        // http://code.google.com/p/android/issues/detail?id=20203
151        String s = "aced0005737200146a6176612e6e65742e496e6574416464726573732d9b57af"
152                + "9fe3ebdb0200034900076164647265737349000666616d696c794c0008686f737"
153                + "44e616d657400124c6a6176612f6c616e672f537472696e673b78704a7d9d6300"
154                + "00000274000e7777772e676f6f676c652e636f6d";
155        InetAddress inetAddress = InetAddress.getByName("www.google.com");
156        new SerializationTester<InetAddress>(inetAddress, s) {
157            @Override protected void verify(InetAddress deserialized) throws Exception {
158                deserialized.isReachable(500);
159                for (NetworkInterface nif
160                        : Collections.list(NetworkInterface.getNetworkInterfaces())) {
161                    deserialized.isReachable(nif, 20, 500);
162                }
163            }
164            @Override protected boolean equals(InetAddress a, InetAddress b) {
165                return a.getHostName().equals(b.getHostName());
166            }
167        }.test();
168    }
169
170    public void test_isSiteLocalAddress() throws Exception {
171        assertFalse(InetAddress.getByName("144.32.32.1").isSiteLocalAddress());
172        assertTrue(InetAddress.getByName("10.0.0.1").isSiteLocalAddress());
173        assertTrue(InetAddress.getByName("172.16.0.1").isSiteLocalAddress());
174        assertFalse(InetAddress.getByName("172.32.0.1").isSiteLocalAddress());
175        assertTrue(InetAddress.getByName("192.168.0.1").isSiteLocalAddress());
176
177        assertFalse(InetAddress.getByName("fc00::").isSiteLocalAddress());
178        assertTrue(InetAddress.getByName("fec0::").isSiteLocalAddress());
179    }
180
181    public void test_getByName() throws Exception {
182        for (String invalid : INVALID_IPv4_NUMERIC_ADDRESSES) {
183            try {
184                InetAddress.getByName(invalid);
185                fail(invalid);
186            } catch (UnknownHostException expected) {
187            }
188        }
189    }
190
191    public void test_getLoopbackAddress() throws Exception {
192        assertTrue(InetAddress.getLoopbackAddress().isLoopbackAddress());
193    }
194
195    public void test_equals() throws Exception {
196        InetAddress addr = InetAddress.getByName("239.191.255.255");
197        assertTrue(addr.equals(addr));
198        assertTrue(loopback6().equals(localhost6()));
199        assertFalse(addr.equals(loopback6()));
200
201        assertTrue(Inet4Address.LOOPBACK.equals(Inet4Address.LOOPBACK));
202
203        // http://b/4328294 - the scope id isn't included when comparing Inet6Address instances.
204        byte[] bs = new byte[16];
205        assertEquals(Inet6Address.getByAddress("1", bs, 1), Inet6Address.getByAddress("2", bs, 2));
206    }
207
208    public void test_getHostAddress() throws Exception {
209        assertEquals("::1", localhost6().getHostAddress());
210        assertEquals("::1", InetAddress.getByName("::1").getHostAddress());
211
212        assertEquals("127.0.0.1", Inet4Address.LOOPBACK.getHostAddress());
213
214        // IPv4 mapped address
215        assertEquals("127.0.0.1", InetAddress.getByName("::ffff:127.0.0.1").getHostAddress());
216
217        InetAddress aAddr = InetAddress.getByName("224.0.0.0");
218        assertEquals("224.0.0.0", aAddr.getHostAddress());
219
220
221        try {
222            InetAddress.getByName("1");
223            fail();
224        } catch (UnknownHostException expected) {
225        }
226
227        byte[] bAddr = {
228            (byte) 0xFE, (byte) 0x80, (byte) 0x00, (byte) 0x00,
229            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
230            (byte) 0x02, (byte) 0x11, (byte) 0x25, (byte) 0xFF,
231            (byte) 0xFE, (byte) 0xF8, (byte) 0x7C, (byte) 0xB2
232        };
233        aAddr = Inet6Address.getByAddress(bAddr);
234        String aString = aAddr.getHostAddress();
235        assertTrue(aString.equals("fe80:0:0:0:211:25ff:fef8:7cb2") || aString.equals("fe80::211:25ff:fef8:7cb2"));
236
237        byte[] cAddr = {
238            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
239            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
240            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
241            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF
242        };
243        aAddr = Inet6Address.getByAddress(cAddr);
244        assertEquals("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", aAddr.getHostAddress());
245
246        byte[] dAddr = {
247            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
248            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
249            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
250            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00
251        };
252        aAddr = Inet6Address.getByAddress(dAddr);
253        aString = aAddr.getHostAddress();
254        assertTrue(aString.equals("0:0:0:0:0:0:0:0") || aString.equals("::"));
255
256        byte[] eAddr = {
257            (byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03,
258            (byte) 0x04, (byte) 0x05, (byte) 0x06, (byte) 0x07,
259            (byte) 0x08, (byte) 0x09, (byte) 0x0a, (byte) 0x0b,
260            (byte) 0x0c, (byte) 0x0d, (byte) 0x0e, (byte) 0x0f
261        };
262        aAddr = Inet6Address.getByAddress(eAddr);
263        assertEquals("1:203:405:607:809:a0b:c0d:e0f", aAddr.getHostAddress());
264
265        byte[] fAddr = {
266            (byte) 0x00, (byte) 0x10, (byte) 0x20, (byte) 0x30,
267            (byte) 0x40, (byte) 0x50, (byte) 0x60, (byte) 0x70,
268            (byte) 0x80, (byte) 0x90, (byte) 0xa0, (byte) 0xb0,
269            (byte) 0xc0, (byte) 0xd0, (byte) 0xe0, (byte) 0xf0
270        };
271        aAddr = Inet6Address.getByAddress(fAddr);
272        assertEquals("10:2030:4050:6070:8090:a0b0:c0d0:e0f0", aAddr.getHostAddress());
273    }
274
275    public void test_hashCode() throws Exception {
276        InetAddress addr1 = InetAddress.getByName("1.0.0.1");
277        InetAddress addr2 = InetAddress.getByName("1.0.0.1");
278        assertTrue(addr1.hashCode() == addr2.hashCode());
279
280        assertTrue(loopback6().hashCode() == localhost6().hashCode());
281    }
282
283    public void test_toString() throws Exception {
284        String validIPAddresses[] = {
285            "::1.2.3.4", "::", "::", "1::0", "1::", "::1",
286            "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF",
287            "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:255.255.255.255",
288            "0:0:0:0:0:0:0:0", "0:0:0:0:0:0:0.0.0.0"
289        };
290
291        String [] resultStrings = {
292            "/::1.2.3.4", "/::", "/::", "/1::", "/1::", "/::1",
293            "/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
294            "/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "/::",
295            "/::"
296        };
297
298        for(int i = 0; i < validIPAddresses.length; i++) {
299            InetAddress ia = InetAddress.getByName(validIPAddresses[i]);
300            String result = ia.toString();
301            assertNotNull(result);
302            assertEquals(resultStrings[i], result);
303        }
304    }
305}
306