LinkPropertiesTest.java revision f3cab63ef2248aebf2c931cd1e84d5739791fa50 
1/*
2 * Copyright (C) 2010 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 android.net;
18
19import android.net.LinkProperties;
20import android.net.RouteInfo;
21import android.system.OsConstants;
22import android.test.suitebuilder.annotation.SmallTest;
23import junit.framework.TestCase;
24
25import java.net.InetAddress;
26import java.util.ArrayList;
27
28public class LinkPropertiesTest extends TestCase {
29    private static InetAddress ADDRV4 = NetworkUtils.numericToInetAddress("75.208.6.1");
30    private static InetAddress ADDRV6 = NetworkUtils.numericToInetAddress(
31            "2001:0db8:85a3:0000:0000:8a2e:0370:7334");
32    private static InetAddress DNS1 = NetworkUtils.numericToInetAddress("75.208.7.1");
33    private static InetAddress DNS2 = NetworkUtils.numericToInetAddress("69.78.7.1");
34    private static InetAddress GATEWAY1 = NetworkUtils.numericToInetAddress("75.208.8.1");
35    private static InetAddress GATEWAY2 = NetworkUtils.numericToInetAddress("69.78.8.1");
36    private static String NAME = "qmi0";
37    private static int MTU = 1500;
38
39    private static LinkAddress LINKADDRV4 = new LinkAddress(ADDRV4, 32);
40    private static LinkAddress LINKADDRV6 = new LinkAddress(ADDRV6, 128);
41    private static LinkAddress LINKADDRV6LINKLOCAL = new LinkAddress("fe80::1/64");
42
43    public void assertLinkPropertiesEqual(LinkProperties source, LinkProperties target) {
44        // Check implementation of equals(), element by element.
45        assertTrue(source.isIdenticalInterfaceName(target));
46        assertTrue(target.isIdenticalInterfaceName(source));
47
48        assertTrue(source.isIdenticalAddresses(target));
49        assertTrue(target.isIdenticalAddresses(source));
50
51        assertTrue(source.isIdenticalDnses(target));
52        assertTrue(target.isIdenticalDnses(source));
53
54        assertTrue(source.isIdenticalRoutes(target));
55        assertTrue(target.isIdenticalRoutes(source));
56
57        assertTrue(source.isIdenticalHttpProxy(target));
58        assertTrue(target.isIdenticalHttpProxy(source));
59
60        assertTrue(source.isIdenticalStackedLinks(target));
61        assertTrue(target.isIdenticalStackedLinks(source));
62
63        assertTrue(source.isIdenticalMtu(target));
64        assertTrue(target.isIdenticalMtu(source));
65
66        // Check result of equals().
67        assertTrue(source.equals(target));
68        assertTrue(target.equals(source));
69
70        // Check hashCode.
71        assertEquals(source.hashCode(), target.hashCode());
72    }
73
74    @SmallTest
75    public void testEqualsNull() {
76        LinkProperties source = new LinkProperties();
77        LinkProperties target = new LinkProperties();
78
79        assertFalse(source == target);
80        assertLinkPropertiesEqual(source, target);
81    }
82
83    @SmallTest
84    public void testEqualsSameOrder() {
85        try {
86            LinkProperties source = new LinkProperties();
87            source.setInterfaceName(NAME);
88            // set 2 link addresses
89            source.addLinkAddress(LINKADDRV4);
90            source.addLinkAddress(LINKADDRV6);
91            // set 2 dnses
92            source.addDnsServer(DNS1);
93            source.addDnsServer(DNS2);
94            // set 2 gateways
95            source.addRoute(new RouteInfo(GATEWAY1));
96            source.addRoute(new RouteInfo(GATEWAY2));
97            source.setMtu(MTU);
98
99            LinkProperties target = new LinkProperties();
100
101            // All fields are same
102            target.setInterfaceName(NAME);
103            target.addLinkAddress(LINKADDRV4);
104            target.addLinkAddress(LINKADDRV6);
105            target.addDnsServer(DNS1);
106            target.addDnsServer(DNS2);
107            target.addRoute(new RouteInfo(GATEWAY1));
108            target.addRoute(new RouteInfo(GATEWAY2));
109            target.setMtu(MTU);
110
111            assertLinkPropertiesEqual(source, target);
112
113            target.clear();
114            // change Interface Name
115            target.setInterfaceName("qmi1");
116            target.addLinkAddress(LINKADDRV4);
117            target.addLinkAddress(LINKADDRV6);
118            target.addDnsServer(DNS1);
119            target.addDnsServer(DNS2);
120            target.addRoute(new RouteInfo(GATEWAY1));
121            target.addRoute(new RouteInfo(GATEWAY2));
122            target.setMtu(MTU);
123            assertFalse(source.equals(target));
124
125            target.clear();
126            target.setInterfaceName(NAME);
127            // change link addresses
128            target.addLinkAddress(new LinkAddress(
129                    NetworkUtils.numericToInetAddress("75.208.6.2"), 32));
130            target.addLinkAddress(LINKADDRV6);
131            target.addDnsServer(DNS1);
132            target.addDnsServer(DNS2);
133            target.addRoute(new RouteInfo(GATEWAY1));
134            target.addRoute(new RouteInfo(GATEWAY2));
135            target.setMtu(MTU);
136            assertFalse(source.equals(target));
137
138            target.clear();
139            target.setInterfaceName(NAME);
140            target.addLinkAddress(LINKADDRV4);
141            target.addLinkAddress(LINKADDRV6);
142            // change dnses
143            target.addDnsServer(NetworkUtils.numericToInetAddress("75.208.7.2"));
144            target.addDnsServer(DNS2);
145            target.addRoute(new RouteInfo(GATEWAY1));
146            target.addRoute(new RouteInfo(GATEWAY2));
147            target.setMtu(MTU);
148            assertFalse(source.equals(target));
149
150            target.clear();
151            target.setInterfaceName(NAME);
152            target.addLinkAddress(LINKADDRV4);
153            target.addLinkAddress(LINKADDRV6);
154            target.addDnsServer(DNS1);
155            target.addDnsServer(DNS2);
156            // change gateway
157            target.addRoute(new RouteInfo(NetworkUtils.numericToInetAddress("75.208.8.2")));
158            target.addRoute(new RouteInfo(GATEWAY2));
159            target.setMtu(MTU);
160            assertFalse(source.equals(target));
161
162            target.clear();
163            target.setInterfaceName(NAME);
164            target.addLinkAddress(LINKADDRV4);
165            target.addLinkAddress(LINKADDRV6);
166            target.addDnsServer(DNS1);
167            target.addDnsServer(DNS2);
168            target.addRoute(new RouteInfo(GATEWAY1));
169            target.addRoute(new RouteInfo(GATEWAY2));
170            // change mtu
171            target.setMtu(1440);
172            assertFalse(source.equals(target));
173
174        } catch (Exception e) {
175            throw new RuntimeException(e.toString());
176            //fail();
177        }
178    }
179
180    @SmallTest
181    public void testEqualsDifferentOrder() {
182        try {
183            LinkProperties source = new LinkProperties();
184            source.setInterfaceName(NAME);
185            // set 2 link addresses
186            source.addLinkAddress(LINKADDRV4);
187            source.addLinkAddress(LINKADDRV6);
188            // set 2 dnses
189            source.addDnsServer(DNS1);
190            source.addDnsServer(DNS2);
191            // set 2 gateways
192            source.addRoute(new RouteInfo(GATEWAY1));
193            source.addRoute(new RouteInfo(GATEWAY2));
194            source.setMtu(MTU);
195
196            LinkProperties target = new LinkProperties();
197            // Exchange order
198            target.setInterfaceName(NAME);
199            target.addLinkAddress(LINKADDRV6);
200            target.addLinkAddress(LINKADDRV4);
201            target.addDnsServer(DNS2);
202            target.addDnsServer(DNS1);
203            target.addRoute(new RouteInfo(GATEWAY2));
204            target.addRoute(new RouteInfo(GATEWAY1));
205            target.setMtu(MTU);
206
207            assertLinkPropertiesEqual(source, target);
208        } catch (Exception e) {
209            fail();
210        }
211    }
212
213    @SmallTest
214    public void testEqualsDuplicated() {
215        try {
216            LinkProperties source = new LinkProperties();
217            // set 3 link addresses, eg, [A, A, B]
218            source.addLinkAddress(LINKADDRV4);
219            source.addLinkAddress(LINKADDRV4);
220            source.addLinkAddress(LINKADDRV6);
221
222            LinkProperties target = new LinkProperties();
223            // set 3 link addresses, eg, [A, B, B]
224            target.addLinkAddress(LINKADDRV4);
225            target.addLinkAddress(LINKADDRV6);
226            target.addLinkAddress(LINKADDRV6);
227
228            assertLinkPropertiesEqual(source, target);
229        } catch (Exception e) {
230            fail();
231        }
232    }
233
234    private void assertAllRoutesHaveInterface(String iface, LinkProperties lp) {
235        for (RouteInfo r : lp.getRoutes()) {
236            assertEquals(iface, r.getInterface());
237        }
238    }
239
240    @SmallTest
241    public void testRouteInterfaces() {
242        LinkAddress prefix = new LinkAddress(
243            NetworkUtils.numericToInetAddress("2001:db8::"), 32);
244        InetAddress address = ADDRV6;
245
246        // Add a route with no interface to a LinkProperties with no interface. No errors.
247        LinkProperties lp = new LinkProperties();
248        RouteInfo r = new RouteInfo(prefix, address, null);
249        assertTrue(lp.addRoute(r));
250        assertEquals(1, lp.getRoutes().size());
251        assertAllRoutesHaveInterface(null, lp);
252
253        // Adding the same route twice has no effect.
254        assertFalse(lp.addRoute(r));
255        assertEquals(1, lp.getRoutes().size());
256
257        // Add a route with an interface. Expect an exception.
258        r = new RouteInfo(prefix, address, "wlan0");
259        try {
260          lp.addRoute(r);
261          fail("Adding wlan0 route to LP with no interface, expect exception");
262        } catch (IllegalArgumentException expected) {}
263
264        // Change the interface name. All the routes should change their interface name too.
265        lp.setInterfaceName("rmnet0");
266        assertAllRoutesHaveInterface("rmnet0", lp);
267
268        // Now add a route with the wrong interface. This causes an exception too.
269        try {
270          lp.addRoute(r);
271          fail("Adding wlan0 route to rmnet0 LP, expect exception");
272        } catch (IllegalArgumentException expected) {}
273
274        // If the interface name matches, the route is added.
275        r = new RouteInfo(prefix, null, "wlan0");
276        lp.setInterfaceName("wlan0");
277        lp.addRoute(r);
278        assertEquals(2, lp.getRoutes().size());
279        assertAllRoutesHaveInterface("wlan0", lp);
280
281        // Routes with null interfaces are converted to wlan0.
282        r = RouteInfo.makeHostRoute(ADDRV6, null);
283        lp.addRoute(r);
284        assertEquals(3, lp.getRoutes().size());
285        assertAllRoutesHaveInterface("wlan0", lp);
286
287        // Check comparisons work.
288        LinkProperties lp2 = new LinkProperties(lp);
289        assertAllRoutesHaveInterface("wlan0", lp);
290        assertEquals(0, lp.compareAllRoutes(lp2).added.size());
291        assertEquals(0, lp.compareAllRoutes(lp2).removed.size());
292
293        lp2.setInterfaceName("p2p0");
294        assertAllRoutesHaveInterface("p2p0", lp2);
295        assertEquals(3, lp.compareAllRoutes(lp2).added.size());
296        assertEquals(3, lp.compareAllRoutes(lp2).removed.size());
297    }
298
299    @SmallTest
300    public void testStackedInterfaces() {
301        LinkProperties rmnet0 = new LinkProperties();
302        rmnet0.setInterfaceName("rmnet0");
303        rmnet0.addLinkAddress(LINKADDRV6);
304
305        LinkProperties clat4 = new LinkProperties();
306        clat4.setInterfaceName("clat4");
307        clat4.addLinkAddress(LINKADDRV4);
308
309        assertEquals(0, rmnet0.getStackedLinks().size());
310        assertEquals(1, rmnet0.getAddresses().size());
311        assertEquals(1, rmnet0.getLinkAddresses().size());
312        assertEquals(1, rmnet0.getAllAddresses().size());
313        assertEquals(1, rmnet0.getAllLinkAddresses().size());
314
315        rmnet0.addStackedLink(clat4);
316        assertEquals(1, rmnet0.getStackedLinks().size());
317        assertEquals(1, rmnet0.getAddresses().size());
318        assertEquals(1, rmnet0.getLinkAddresses().size());
319        assertEquals(2, rmnet0.getAllAddresses().size());
320        assertEquals(2, rmnet0.getAllLinkAddresses().size());
321
322        rmnet0.addStackedLink(clat4);
323        assertEquals(1, rmnet0.getStackedLinks().size());
324        assertEquals(1, rmnet0.getAddresses().size());
325        assertEquals(1, rmnet0.getLinkAddresses().size());
326        assertEquals(2, rmnet0.getAllAddresses().size());
327        assertEquals(2, rmnet0.getAllLinkAddresses().size());
328
329        assertEquals(0, clat4.getStackedLinks().size());
330
331        // Modify an item in the returned collection to see what happens.
332        for (LinkProperties link : rmnet0.getStackedLinks()) {
333            if (link.getInterfaceName().equals("clat4")) {
334               link.setInterfaceName("newname");
335            }
336        }
337        for (LinkProperties link : rmnet0.getStackedLinks()) {
338            assertFalse("newname".equals(link.getInterfaceName()));
339        }
340
341        assertTrue(rmnet0.removeStackedLink("clat4"));
342        assertEquals(0, rmnet0.getStackedLinks().size());
343        assertEquals(1, rmnet0.getAddresses().size());
344        assertEquals(1, rmnet0.getLinkAddresses().size());
345        assertEquals(1, rmnet0.getAllAddresses().size());
346        assertEquals(1, rmnet0.getAllLinkAddresses().size());
347
348        assertFalse(rmnet0.removeStackedLink("clat4"));
349    }
350
351    private LinkAddress getFirstLinkAddress(LinkProperties lp) {
352        return lp.getLinkAddresses().iterator().next();
353    }
354
355    @SmallTest
356    public void testAddressMethods() {
357        LinkProperties lp = new LinkProperties();
358
359        // No addresses.
360        assertFalse(lp.hasIPv4Address());
361        assertFalse(lp.hasGlobalIPv6Address());
362
363        // Addresses on stacked links don't count.
364        LinkProperties stacked = new LinkProperties();
365        stacked.setInterfaceName("stacked");
366        lp.addStackedLink(stacked);
367        stacked.addLinkAddress(LINKADDRV4);
368        stacked.addLinkAddress(LINKADDRV6);
369        assertTrue(stacked.hasIPv4Address());
370        assertTrue(stacked.hasGlobalIPv6Address());
371        assertFalse(lp.hasIPv4Address());
372        assertFalse(lp.hasGlobalIPv6Address());
373        lp.removeStackedLink("stacked");
374        assertFalse(lp.hasIPv4Address());
375        assertFalse(lp.hasGlobalIPv6Address());
376
377        // Addresses on the base link.
378        // Check the return values of hasIPvXAddress and ensure the add/remove methods return true
379        // iff something changes.
380        assertEquals(0, lp.getLinkAddresses().size());
381        assertTrue(lp.addLinkAddress(LINKADDRV6));
382        assertEquals(1, lp.getLinkAddresses().size());
383        assertFalse(lp.hasIPv4Address());
384        assertTrue(lp.hasGlobalIPv6Address());
385
386        assertTrue(lp.removeLinkAddress(LINKADDRV6));
387        assertEquals(0, lp.getLinkAddresses().size());
388
389        assertTrue(lp.addLinkAddress(LINKADDRV6LINKLOCAL));
390        assertEquals(1, lp.getLinkAddresses().size());
391        assertFalse(lp.hasGlobalIPv6Address());
392
393        assertTrue(lp.addLinkAddress(LINKADDRV4));
394        assertEquals(2, lp.getLinkAddresses().size());
395        assertTrue(lp.hasIPv4Address());
396        assertFalse(lp.hasGlobalIPv6Address());
397
398        assertTrue(lp.addLinkAddress(LINKADDRV6));
399        assertEquals(3, lp.getLinkAddresses().size());
400        assertTrue(lp.hasIPv4Address());
401        assertTrue(lp.hasGlobalIPv6Address());
402
403        assertTrue(lp.removeLinkAddress(LINKADDRV6LINKLOCAL));
404        assertEquals(2, lp.getLinkAddresses().size());
405        assertTrue(lp.hasIPv4Address());
406        assertTrue(lp.hasGlobalIPv6Address());
407
408        // Adding an address twice has no effect.
409        // Removing an address that's not present has no effect.
410        assertFalse(lp.addLinkAddress(LINKADDRV4));
411        assertEquals(2, lp.getLinkAddresses().size());
412        assertTrue(lp.hasIPv4Address());
413        assertTrue(lp.removeLinkAddress(LINKADDRV4));
414        assertEquals(1, lp.getLinkAddresses().size());
415        assertFalse(lp.hasIPv4Address());
416        assertFalse(lp.removeLinkAddress(LINKADDRV4));
417        assertEquals(1, lp.getLinkAddresses().size());
418
419        // Adding an address that's already present but with different properties causes the
420        // existing address to be updated and returns true.
421        // Start with only LINKADDRV6.
422        assertEquals(1, lp.getLinkAddresses().size());
423        assertEquals(LINKADDRV6, getFirstLinkAddress(lp));
424
425        // Create a LinkAddress object for the same address, but with different flags.
426        LinkAddress deprecated = new LinkAddress(ADDRV6, 128,
427                OsConstants.IFA_F_DEPRECATED, OsConstants.RT_SCOPE_UNIVERSE);
428        assertTrue(deprecated.isSameAddressAs(LINKADDRV6));
429        assertFalse(deprecated.equals(LINKADDRV6));
430
431        // Check that adding it updates the existing address instead of adding a new one.
432        assertTrue(lp.addLinkAddress(deprecated));
433        assertEquals(1, lp.getLinkAddresses().size());
434        assertEquals(deprecated, getFirstLinkAddress(lp));
435        assertFalse(LINKADDRV6.equals(getFirstLinkAddress(lp)));
436
437        // Removing LINKADDRV6 removes deprecated, because removing addresses ignores properties.
438        assertTrue(lp.removeLinkAddress(LINKADDRV6));
439        assertEquals(0, lp.getLinkAddresses().size());
440    }
441
442    @SmallTest
443    public void testSetLinkAddresses() {
444        LinkProperties lp = new LinkProperties();
445        lp.addLinkAddress(LINKADDRV4);
446        lp.addLinkAddress(LINKADDRV6);
447
448        LinkProperties lp2 = new LinkProperties();
449        lp2.addLinkAddress(LINKADDRV6);
450
451        assertFalse(lp.equals(lp2));
452
453        lp2.setLinkAddresses(lp.getLinkAddresses());
454        assertTrue(lp.equals(lp));
455    }
456}
457