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