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