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