LinkPropertiesTest.java revision 64483947fdb03bf838e317ac0a4af5e0f53a5bbf 
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.test.suitebuilder.annotation.SmallTest;
22import junit.framework.TestCase;
23
24import java.net.InetAddress;
25import java.util.ArrayList;
26
27import libcore.io.OsConstants;
28
29public class LinkPropertiesTest extends TestCase {
30    private static InetAddress ADDRV4 = NetworkUtils.numericToInetAddress("75.208.6.1");
31    private static InetAddress ADDRV6 = NetworkUtils.numericToInetAddress(
32            "2001:0db8:85a3:0000:0000:8a2e:0370:7334");
33    private static InetAddress DNS1 = NetworkUtils.numericToInetAddress("75.208.7.1");
34    private static InetAddress DNS2 = NetworkUtils.numericToInetAddress("69.78.7.1");
35    private static InetAddress GATEWAY1 = NetworkUtils.numericToInetAddress("75.208.8.1");
36    private static InetAddress GATEWAY2 = NetworkUtils.numericToInetAddress("69.78.8.1");
37    private static String NAME = "qmi0";
38    private static int MTU = 1500;
39
40    private static LinkAddress LINKADDRV4 = new LinkAddress(ADDRV4, 32);
41    private static LinkAddress LINKADDRV6 = new LinkAddress(ADDRV6, 128);
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.addDns(DNS1);
93            source.addDns(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.addDns(DNS1);
106            target.addDns(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.addDns(DNS1);
119            target.addDns(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.addDns(DNS1);
132            target.addDns(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.addDns(NetworkUtils.numericToInetAddress("75.208.7.2"));
144            target.addDns(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.addDns(DNS1);
155            target.addDns(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.addDns(DNS1);
167            target.addDns(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.addDns(DNS1);
190            source.addDns(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.addDns(DNS2);
202            target.addDns(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        lp.addRoute(r);
250        assertEquals(1, lp.getRoutes().size());
251        assertAllRoutesHaveInterface(null, lp);
252
253        // Add a route with an interface. Except an exception.
254        r = new RouteInfo(prefix, address, "wlan0");
255        try {
256          lp.addRoute(r);
257          fail("Adding wlan0 route to LP with no interface, expect exception");
258        } catch (IllegalArgumentException expected) {}
259
260        // Change the interface name. All the routes should change their interface name too.
261        lp.setInterfaceName("rmnet0");
262        assertAllRoutesHaveInterface("rmnet0", lp);
263
264        // Now add a route with the wrong interface. This causes an exception too.
265        try {
266          lp.addRoute(r);
267          fail("Adding wlan0 route to rmnet0 LP, expect exception");
268        } catch (IllegalArgumentException expected) {}
269
270        // If the interface name matches, the route is added.
271        lp.setInterfaceName("wlan0");
272        lp.addRoute(r);
273        assertEquals(2, lp.getRoutes().size());
274        assertAllRoutesHaveInterface("wlan0", lp);
275
276        // Routes with null interfaces are converted to wlan0.
277        r = RouteInfo.makeHostRoute(ADDRV6, null);
278        lp.addRoute(r);
279        assertEquals(3, lp.getRoutes().size());
280        assertAllRoutesHaveInterface("wlan0", lp);
281
282        // Check comparisons work.
283        LinkProperties lp2 = new LinkProperties(lp);
284        assertAllRoutesHaveInterface("wlan0", lp);
285        assertEquals(0, lp.compareAllRoutes(lp2).added.size());
286        assertEquals(0, lp.compareAllRoutes(lp2).removed.size());
287
288        lp2.setInterfaceName("p2p0");
289        assertAllRoutesHaveInterface("p2p0", lp2);
290        assertEquals(3, lp.compareAllRoutes(lp2).added.size());
291        assertEquals(3, lp.compareAllRoutes(lp2).removed.size());
292    }
293
294    @SmallTest
295    public void testStackedInterfaces() {
296        LinkProperties rmnet0 = new LinkProperties();
297        rmnet0.setInterfaceName("rmnet0");
298        rmnet0.addLinkAddress(LINKADDRV6);
299
300        LinkProperties clat4 = new LinkProperties();
301        clat4.setInterfaceName("clat4");
302        clat4.addLinkAddress(LINKADDRV4);
303
304        assertEquals(0, rmnet0.getStackedLinks().size());
305        assertEquals(1, rmnet0.getAddresses().size());
306        assertEquals(1, rmnet0.getLinkAddresses().size());
307        assertEquals(1, rmnet0.getAllAddresses().size());
308        assertEquals(1, rmnet0.getAllLinkAddresses().size());
309
310        rmnet0.addStackedLink(clat4);
311        assertEquals(1, rmnet0.getStackedLinks().size());
312        assertEquals(1, rmnet0.getAddresses().size());
313        assertEquals(1, rmnet0.getLinkAddresses().size());
314        assertEquals(2, rmnet0.getAllAddresses().size());
315        assertEquals(2, rmnet0.getAllLinkAddresses().size());
316
317        rmnet0.addStackedLink(clat4);
318        assertEquals(1, rmnet0.getStackedLinks().size());
319        assertEquals(1, rmnet0.getAddresses().size());
320        assertEquals(1, rmnet0.getLinkAddresses().size());
321        assertEquals(2, rmnet0.getAllAddresses().size());
322        assertEquals(2, rmnet0.getAllLinkAddresses().size());
323
324        assertEquals(0, clat4.getStackedLinks().size());
325
326        // Modify an item in the returned collection to see what happens.
327        for (LinkProperties link : rmnet0.getStackedLinks()) {
328            if (link.getInterfaceName().equals("clat4")) {
329               link.setInterfaceName("newname");
330            }
331        }
332        for (LinkProperties link : rmnet0.getStackedLinks()) {
333            assertFalse("newname".equals(link.getInterfaceName()));
334        }
335
336        assertTrue(rmnet0.removeStackedLink(clat4));
337        assertEquals(0, rmnet0.getStackedLinks().size());
338        assertEquals(1, rmnet0.getAddresses().size());
339        assertEquals(1, rmnet0.getLinkAddresses().size());
340        assertEquals(1, rmnet0.getAllAddresses().size());
341        assertEquals(1, rmnet0.getAllLinkAddresses().size());
342
343        assertFalse(rmnet0.removeStackedLink(clat4));
344    }
345
346    private LinkAddress getFirstLinkAddress(LinkProperties lp) {
347        return lp.getLinkAddresses().iterator().next();
348    }
349
350    @SmallTest
351    public void testAddressMethods() {
352        LinkProperties lp = new LinkProperties();
353
354        // No addresses.
355        assertFalse(lp.hasIPv4Address());
356        assertFalse(lp.hasIPv6Address());
357
358        // Addresses on stacked links don't count.
359        LinkProperties stacked = new LinkProperties();
360        stacked.setInterfaceName("stacked");
361        lp.addStackedLink(stacked);
362        stacked.addLinkAddress(LINKADDRV4);
363        stacked.addLinkAddress(LINKADDRV6);
364        assertTrue(stacked.hasIPv4Address());
365        assertTrue(stacked.hasIPv6Address());
366        assertFalse(lp.hasIPv4Address());
367        assertFalse(lp.hasIPv6Address());
368        lp.removeStackedLink(stacked);
369        assertFalse(lp.hasIPv4Address());
370        assertFalse(lp.hasIPv6Address());
371
372        // Addresses on the base link.
373        // Check the return values of hasIPvXAddress and ensure the add/remove methods return true
374        // iff something changes.
375        assertEquals(0, lp.getLinkAddresses().size());
376        assertTrue(lp.addLinkAddress(LINKADDRV6));
377        assertEquals(1, lp.getLinkAddresses().size());
378        assertFalse(lp.hasIPv4Address());
379        assertTrue(lp.hasIPv6Address());
380
381        assertTrue(lp.removeLinkAddress(LINKADDRV6));
382        assertEquals(0, lp.getLinkAddresses().size());
383        assertTrue(lp.addLinkAddress(LINKADDRV4));
384        assertEquals(1, lp.getLinkAddresses().size());
385        assertTrue(lp.hasIPv4Address());
386        assertFalse(lp.hasIPv6Address());
387
388        assertTrue(lp.addLinkAddress(LINKADDRV6));
389        assertEquals(2, lp.getLinkAddresses().size());
390        assertTrue(lp.hasIPv4Address());
391        assertTrue(lp.hasIPv6Address());
392
393        // Adding an address twice has no effect.
394        // Removing an address that's not present has no effect.
395        assertFalse(lp.addLinkAddress(LINKADDRV4));
396        assertEquals(2, lp.getLinkAddresses().size());
397        assertTrue(lp.hasIPv4Address());
398        assertTrue(lp.removeLinkAddress(LINKADDRV4));
399        assertEquals(1, lp.getLinkAddresses().size());
400        assertFalse(lp.hasIPv4Address());
401        assertFalse(lp.removeLinkAddress(LINKADDRV4));
402        assertEquals(1, lp.getLinkAddresses().size());
403
404        // Adding an address that's already present but with different properties causes the
405        // existing address to be updated and returns true.
406        // Start with only LINKADDRV6.
407        assertEquals(1, lp.getLinkAddresses().size());
408        assertEquals(LINKADDRV6, getFirstLinkAddress(lp));
409
410        // Create a LinkAddress object for the same address, but with different flags.
411        LinkAddress deprecated = new LinkAddress(ADDRV6, 128,
412                OsConstants.IFA_F_DEPRECATED, OsConstants.RT_SCOPE_UNIVERSE);
413        assertTrue(deprecated.isSameAddressAs(LINKADDRV6));
414        assertFalse(deprecated.equals(LINKADDRV6));
415
416        // Check that adding it updates the existing address instead of adding a new one.
417        assertTrue(lp.addLinkAddress(deprecated));
418        assertEquals(1, lp.getLinkAddresses().size());
419        assertEquals(deprecated, getFirstLinkAddress(lp));
420        assertFalse(LINKADDRV6.equals(getFirstLinkAddress(lp)));
421
422        // Removing LINKADDRV6 removes deprecated, because removing addresses ignores properties.
423        assertTrue(lp.removeLinkAddress(LINKADDRV6));
424        assertEquals(0, lp.getLinkAddresses().size());
425    }
426
427    @SmallTest
428    public void testSetLinkAddresses() {
429        LinkProperties lp = new LinkProperties();
430        lp.addLinkAddress(LINKADDRV4);
431        lp.addLinkAddress(LINKADDRV6);
432
433        LinkProperties lp2 = new LinkProperties();
434        lp2.addLinkAddress(LINKADDRV6);
435
436        assertFalse(lp.equals(lp2));
437
438        lp2.setLinkAddresses(lp.getLinkAddresses());
439        assertTrue(lp.equals(lp));
440    }
441}
442