John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 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 | |
| 17 | package android.net; |
| 18 | |
| 19 | import android.net.LinkProperties; |
Robert Greenwalt | aa70f10 | 2011-04-28 14:28:50 -0700 | [diff] [blame] | 20 | import android.net.RouteInfo; |
Elliott Hughes | 34385d3 | 2014-04-28 11:11:32 -0700 | [diff] [blame] | 21 | import android.system.OsConstants; |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 22 | import android.test.suitebuilder.annotation.SmallTest; |
| 23 | import junit.framework.TestCase; |
| 24 | |
| 25 | import java.net.InetAddress; |
Lorenzo Colitti | 419a4ce | 2013-03-07 10:59:25 -0800 | [diff] [blame] | 26 | import java.util.ArrayList; |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 27 | |
| 28 | public class LinkPropertiesTest extends TestCase { |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 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"); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 36 | private static String NAME = "qmi0"; |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 37 | private static int MTU = 1500; |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 38 | |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 39 | private static LinkAddress LINKADDRV4 = new LinkAddress(ADDRV4, 32); |
| 40 | private static LinkAddress LINKADDRV6 = new LinkAddress(ADDRV6, 128); |
| 41 | |
Lorenzo Colitti | 213f98b | 2013-04-01 10:47:43 +0900 | [diff] [blame] | 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 | |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 62 | assertTrue(source.isIdenticalMtu(target)); |
| 63 | assertTrue(target.isIdenticalMtu(source)); |
| 64 | |
Lorenzo Colitti | 213f98b | 2013-04-01 10:47:43 +0900 | [diff] [blame] | 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 | |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 73 | @SmallTest |
| 74 | public void testEqualsNull() { |
| 75 | LinkProperties source = new LinkProperties(); |
| 76 | LinkProperties target = new LinkProperties(); |
| 77 | |
| 78 | assertFalse(source == target); |
Lorenzo Colitti | 213f98b | 2013-04-01 10:47:43 +0900 | [diff] [blame] | 79 | assertLinkPropertiesEqual(source, target); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 80 | } |
| 81 | |
| 82 | @SmallTest |
| 83 | public void testEqualsSameOrder() { |
| 84 | try { |
| 85 | LinkProperties source = new LinkProperties(); |
| 86 | source.setInterfaceName(NAME); |
| 87 | // set 2 link addresses |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 88 | source.addLinkAddress(LINKADDRV4); |
| 89 | source.addLinkAddress(LINKADDRV6); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 90 | // set 2 dnses |
Robert Greenwalt | df2b878 | 2014-06-06 10:30:11 -0700 | [diff] [blame] | 91 | source.addDnsServer(DNS1); |
| 92 | source.addDnsServer(DNS2); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 93 | // set 2 gateways |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 94 | source.addRoute(new RouteInfo(GATEWAY1)); |
| 95 | source.addRoute(new RouteInfo(GATEWAY2)); |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 96 | source.setMtu(MTU); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 97 | |
| 98 | LinkProperties target = new LinkProperties(); |
| 99 | |
| 100 | // All fields are same |
| 101 | target.setInterfaceName(NAME); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 102 | target.addLinkAddress(LINKADDRV4); |
| 103 | target.addLinkAddress(LINKADDRV6); |
Robert Greenwalt | df2b878 | 2014-06-06 10:30:11 -0700 | [diff] [blame] | 104 | target.addDnsServer(DNS1); |
| 105 | target.addDnsServer(DNS2); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 106 | target.addRoute(new RouteInfo(GATEWAY1)); |
| 107 | target.addRoute(new RouteInfo(GATEWAY2)); |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 108 | target.setMtu(MTU); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 109 | |
Lorenzo Colitti | 213f98b | 2013-04-01 10:47:43 +0900 | [diff] [blame] | 110 | assertLinkPropertiesEqual(source, target); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 111 | |
| 112 | target.clear(); |
| 113 | // change Interface Name |
| 114 | target.setInterfaceName("qmi1"); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 115 | target.addLinkAddress(LINKADDRV4); |
| 116 | target.addLinkAddress(LINKADDRV6); |
Robert Greenwalt | df2b878 | 2014-06-06 10:30:11 -0700 | [diff] [blame] | 117 | target.addDnsServer(DNS1); |
| 118 | target.addDnsServer(DNS2); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 119 | target.addRoute(new RouteInfo(GATEWAY1)); |
| 120 | target.addRoute(new RouteInfo(GATEWAY2)); |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 121 | target.setMtu(MTU); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 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)); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 129 | target.addLinkAddress(LINKADDRV6); |
Robert Greenwalt | df2b878 | 2014-06-06 10:30:11 -0700 | [diff] [blame] | 130 | target.addDnsServer(DNS1); |
| 131 | target.addDnsServer(DNS2); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 132 | target.addRoute(new RouteInfo(GATEWAY1)); |
| 133 | target.addRoute(new RouteInfo(GATEWAY2)); |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 134 | target.setMtu(MTU); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 135 | assertFalse(source.equals(target)); |
| 136 | |
| 137 | target.clear(); |
| 138 | target.setInterfaceName(NAME); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 139 | target.addLinkAddress(LINKADDRV4); |
| 140 | target.addLinkAddress(LINKADDRV6); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 141 | // change dnses |
Robert Greenwalt | df2b878 | 2014-06-06 10:30:11 -0700 | [diff] [blame] | 142 | target.addDnsServer(NetworkUtils.numericToInetAddress("75.208.7.2")); |
| 143 | target.addDnsServer(DNS2); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 144 | target.addRoute(new RouteInfo(GATEWAY1)); |
| 145 | target.addRoute(new RouteInfo(GATEWAY2)); |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 146 | target.setMtu(MTU); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 147 | assertFalse(source.equals(target)); |
| 148 | |
| 149 | target.clear(); |
| 150 | target.setInterfaceName(NAME); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 151 | target.addLinkAddress(LINKADDRV4); |
| 152 | target.addLinkAddress(LINKADDRV6); |
Robert Greenwalt | df2b878 | 2014-06-06 10:30:11 -0700 | [diff] [blame] | 153 | target.addDnsServer(DNS1); |
| 154 | target.addDnsServer(DNS2); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 155 | // change gateway |
Robert Greenwalt | aa70f10 | 2011-04-28 14:28:50 -0700 | [diff] [blame] | 156 | target.addRoute(new RouteInfo(NetworkUtils.numericToInetAddress("75.208.8.2"))); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 157 | target.addRoute(new RouteInfo(GATEWAY2)); |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 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); |
Robert Greenwalt | df2b878 | 2014-06-06 10:30:11 -0700 | [diff] [blame] | 165 | target.addDnsServer(DNS1); |
| 166 | target.addDnsServer(DNS2); |
Robert Greenwalt | 69df743 | 2013-09-06 16:49:37 -0700 | [diff] [blame] | 167 | target.addRoute(new RouteInfo(GATEWAY1)); |
| 168 | target.addRoute(new RouteInfo(GATEWAY2)); |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 169 | // change mtu |
| 170 | target.setMtu(1440); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 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 |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 185 | source.addLinkAddress(LINKADDRV4); |
| 186 | source.addLinkAddress(LINKADDRV6); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 187 | // set 2 dnses |
Robert Greenwalt | df2b878 | 2014-06-06 10:30:11 -0700 | [diff] [blame] | 188 | source.addDnsServer(DNS1); |
| 189 | source.addDnsServer(DNS2); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 190 | // set 2 gateways |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 191 | source.addRoute(new RouteInfo(GATEWAY1)); |
| 192 | source.addRoute(new RouteInfo(GATEWAY2)); |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 193 | source.setMtu(MTU); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 194 | |
| 195 | LinkProperties target = new LinkProperties(); |
| 196 | // Exchange order |
| 197 | target.setInterfaceName(NAME); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 198 | target.addLinkAddress(LINKADDRV6); |
| 199 | target.addLinkAddress(LINKADDRV4); |
Robert Greenwalt | df2b878 | 2014-06-06 10:30:11 -0700 | [diff] [blame] | 200 | target.addDnsServer(DNS2); |
| 201 | target.addDnsServer(DNS1); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 202 | target.addRoute(new RouteInfo(GATEWAY2)); |
| 203 | target.addRoute(new RouteInfo(GATEWAY1)); |
sy.yun | 9d9b74a | 2013-09-02 05:24:09 +0900 | [diff] [blame] | 204 | target.setMtu(MTU); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 205 | |
Lorenzo Colitti | 213f98b | 2013-04-01 10:47:43 +0900 | [diff] [blame] | 206 | assertLinkPropertiesEqual(source, target); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 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] |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 217 | source.addLinkAddress(LINKADDRV4); |
| 218 | source.addLinkAddress(LINKADDRV4); |
| 219 | source.addLinkAddress(LINKADDRV6); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 220 | |
| 221 | LinkProperties target = new LinkProperties(); |
| 222 | // set 3 link addresses, eg, [A, B, B] |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 223 | target.addLinkAddress(LINKADDRV4); |
| 224 | target.addLinkAddress(LINKADDRV6); |
| 225 | target.addLinkAddress(LINKADDRV6); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 226 | |
Lorenzo Colitti | 213f98b | 2013-04-01 10:47:43 +0900 | [diff] [blame] | 227 | assertLinkPropertiesEqual(source, target); |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 228 | } catch (Exception e) { |
| 229 | fail(); |
| 230 | } |
| 231 | } |
| 232 | |
Lorenzo Colitti | 1994bc1 | 2013-03-08 19:11:40 -0800 | [diff] [blame] | 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); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 243 | InetAddress address = ADDRV6; |
Lorenzo Colitti | 1994bc1 | 2013-03-08 19:11:40 -0800 | [diff] [blame] | 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. |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 276 | r = RouteInfo.makeHostRoute(ADDRV6, null); |
Lorenzo Colitti | 1994bc1 | 2013-03-08 19:11:40 -0800 | [diff] [blame] | 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); |
Lorenzo Colitti | d1e0fae | 2013-07-31 23:23:21 +0900 | [diff] [blame] | 284 | assertEquals(0, lp.compareAllRoutes(lp2).added.size()); |
| 285 | assertEquals(0, lp.compareAllRoutes(lp2).removed.size()); |
Lorenzo Colitti | 1994bc1 | 2013-03-08 19:11:40 -0800 | [diff] [blame] | 286 | |
| 287 | lp2.setInterfaceName("p2p0"); |
| 288 | assertAllRoutesHaveInterface("p2p0", lp2); |
Lorenzo Colitti | d1e0fae | 2013-07-31 23:23:21 +0900 | [diff] [blame] | 289 | assertEquals(3, lp.compareAllRoutes(lp2).added.size()); |
| 290 | assertEquals(3, lp.compareAllRoutes(lp2).removed.size()); |
Lorenzo Colitti | b91e50c | 2013-03-16 02:42:30 +0900 | [diff] [blame] | 291 | } |
Lorenzo Colitti | 419a4ce | 2013-03-07 10:59:25 -0800 | [diff] [blame] | 292 | |
| 293 | @SmallTest |
| 294 | public void testStackedInterfaces() { |
| 295 | LinkProperties rmnet0 = new LinkProperties(); |
| 296 | rmnet0.setInterfaceName("rmnet0"); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 297 | rmnet0.addLinkAddress(LINKADDRV6); |
Lorenzo Colitti | 419a4ce | 2013-03-07 10:59:25 -0800 | [diff] [blame] | 298 | |
| 299 | LinkProperties clat4 = new LinkProperties(); |
| 300 | clat4.setInterfaceName("clat4"); |
Lorenzo Colitti | 3f1e1b2 | 2013-08-08 10:56:22 +0900 | [diff] [blame] | 301 | clat4.addLinkAddress(LINKADDRV4); |
Lorenzo Colitti | 419a4ce | 2013-03-07 10:59:25 -0800 | [diff] [blame] | 302 | |
| 303 | assertEquals(0, rmnet0.getStackedLinks().size()); |
Lorenzo Colitti | d1e0fae | 2013-07-31 23:23:21 +0900 | [diff] [blame] | 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 | |
Lorenzo Colitti | 419a4ce | 2013-03-07 10:59:25 -0800 | [diff] [blame] | 309 | rmnet0.addStackedLink(clat4); |
| 310 | assertEquals(1, rmnet0.getStackedLinks().size()); |
Lorenzo Colitti | d1e0fae | 2013-07-31 23:23:21 +0900 | [diff] [blame] | 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 | |
Lorenzo Colitti | 419a4ce | 2013-03-07 10:59:25 -0800 | [diff] [blame] | 316 | rmnet0.addStackedLink(clat4); |
| 317 | assertEquals(1, rmnet0.getStackedLinks().size()); |
Lorenzo Colitti | d1e0fae | 2013-07-31 23:23:21 +0900 | [diff] [blame] | 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 | |
Lorenzo Colitti | 419a4ce | 2013-03-07 10:59:25 -0800 | [diff] [blame] | 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 | } |
Lorenzo Colitti | 4faa027 | 2013-08-08 11:00:12 +0900 | [diff] [blame] | 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 | |
Lorenzo Colitti | 6448394 | 2013-11-15 18:43:52 +0900 | [diff] [blame] | 345 | private LinkAddress getFirstLinkAddress(LinkProperties lp) { |
| 346 | return lp.getLinkAddresses().iterator().next(); |
| 347 | } |
| 348 | |
Lorenzo Colitti | 4faa027 | 2013-08-08 11:00:12 +0900 | [diff] [blame] | 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. |
Lorenzo Colitti | 6448394 | 2013-11-15 18:43:52 +0900 | [diff] [blame] | 374 | assertEquals(0, lp.getLinkAddresses().size()); |
Lorenzo Colitti | 4faa027 | 2013-08-08 11:00:12 +0900 | [diff] [blame] | 375 | assertTrue(lp.addLinkAddress(LINKADDRV6)); |
Lorenzo Colitti | 6448394 | 2013-11-15 18:43:52 +0900 | [diff] [blame] | 376 | assertEquals(1, lp.getLinkAddresses().size()); |
Lorenzo Colitti | 4faa027 | 2013-08-08 11:00:12 +0900 | [diff] [blame] | 377 | assertFalse(lp.hasIPv4Address()); |
| 378 | assertTrue(lp.hasIPv6Address()); |
| 379 | |
| 380 | assertTrue(lp.removeLinkAddress(LINKADDRV6)); |
Lorenzo Colitti | 6448394 | 2013-11-15 18:43:52 +0900 | [diff] [blame] | 381 | assertEquals(0, lp.getLinkAddresses().size()); |
Lorenzo Colitti | 4faa027 | 2013-08-08 11:00:12 +0900 | [diff] [blame] | 382 | assertTrue(lp.addLinkAddress(LINKADDRV4)); |
Lorenzo Colitti | 6448394 | 2013-11-15 18:43:52 +0900 | [diff] [blame] | 383 | assertEquals(1, lp.getLinkAddresses().size()); |
Lorenzo Colitti | 4faa027 | 2013-08-08 11:00:12 +0900 | [diff] [blame] | 384 | assertTrue(lp.hasIPv4Address()); |
| 385 | assertFalse(lp.hasIPv6Address()); |
| 386 | |
| 387 | assertTrue(lp.addLinkAddress(LINKADDRV6)); |
Lorenzo Colitti | 6448394 | 2013-11-15 18:43:52 +0900 | [diff] [blame] | 388 | assertEquals(2, lp.getLinkAddresses().size()); |
Lorenzo Colitti | 4faa027 | 2013-08-08 11:00:12 +0900 | [diff] [blame] | 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)); |
Lorenzo Colitti | 6448394 | 2013-11-15 18:43:52 +0900 | [diff] [blame] | 395 | assertEquals(2, lp.getLinkAddresses().size()); |
Lorenzo Colitti | 4faa027 | 2013-08-08 11:00:12 +0900 | [diff] [blame] | 396 | assertTrue(lp.hasIPv4Address()); |
| 397 | assertTrue(lp.removeLinkAddress(LINKADDRV4)); |
Lorenzo Colitti | 6448394 | 2013-11-15 18:43:52 +0900 | [diff] [blame] | 398 | assertEquals(1, lp.getLinkAddresses().size()); |
Lorenzo Colitti | 4faa027 | 2013-08-08 11:00:12 +0900 | [diff] [blame] | 399 | assertFalse(lp.hasIPv4Address()); |
| 400 | assertFalse(lp.removeLinkAddress(LINKADDRV4)); |
Lorenzo Colitti | 6448394 | 2013-11-15 18:43:52 +0900 | [diff] [blame] | 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()); |
Lorenzo Colitti | 1994bc1 | 2013-03-08 19:11:40 -0800 | [diff] [blame] | 424 | } |
Lorenzo Colitti | 22f407b | 2013-08-23 20:54:49 +0900 | [diff] [blame] | 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 | } |
John Wang | 4e90009 | 2011-04-04 12:35:42 -0700 | [diff] [blame] | 440 | } |