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