1 /* 2 * Copyright (C) 2017 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 static android.net.NetworkCapabilities.LINK_BANDWIDTH_UNSPECIFIED; 20 import static android.net.NetworkCapabilities.MAX_TRANSPORT; 21 import static android.net.NetworkCapabilities.MIN_TRANSPORT; 22 import static android.net.NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL; 23 import static android.net.NetworkCapabilities.NET_CAPABILITY_CBS; 24 import static android.net.NetworkCapabilities.NET_CAPABILITY_DUN; 25 import static android.net.NetworkCapabilities.NET_CAPABILITY_EIMS; 26 import static android.net.NetworkCapabilities.NET_CAPABILITY_ENTERPRISE; 27 import static android.net.NetworkCapabilities.NET_CAPABILITY_FOREGROUND; 28 import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET; 29 import static android.net.NetworkCapabilities.NET_CAPABILITY_LOCAL_NETWORK; 30 import static android.net.NetworkCapabilities.NET_CAPABILITY_MMS; 31 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_METERED; 32 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED; 33 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING; 34 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED; 35 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VPN; 36 import static android.net.NetworkCapabilities.NET_CAPABILITY_OEM_PAID; 37 import static android.net.NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE; 38 import static android.net.NetworkCapabilities.NET_CAPABILITY_PARTIAL_CONNECTIVITY; 39 import static android.net.NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH; 40 import static android.net.NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY; 41 import static android.net.NetworkCapabilities.NET_CAPABILITY_RCS; 42 import static android.net.NetworkCapabilities.NET_CAPABILITY_SUPL; 43 import static android.net.NetworkCapabilities.NET_CAPABILITY_TRUSTED; 44 import static android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED; 45 import static android.net.NetworkCapabilities.NET_CAPABILITY_WIFI_P2P; 46 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_1; 47 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_2; 48 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_3; 49 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_4; 50 import static android.net.NetworkCapabilities.NET_ENTERPRISE_ID_5; 51 import static android.net.NetworkCapabilities.REDACT_FOR_ACCESS_FINE_LOCATION; 52 import static android.net.NetworkCapabilities.REDACT_FOR_LOCAL_MAC_ADDRESS; 53 import static android.net.NetworkCapabilities.REDACT_FOR_NETWORK_SETTINGS; 54 import static android.net.NetworkCapabilities.SIGNAL_STRENGTH_UNSPECIFIED; 55 import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR; 56 import static android.net.NetworkCapabilities.TRANSPORT_ETHERNET; 57 import static android.net.NetworkCapabilities.TRANSPORT_SATELLITE; 58 import static android.net.NetworkCapabilities.TRANSPORT_TEST; 59 import static android.net.NetworkCapabilities.TRANSPORT_THREAD; 60 import static android.net.NetworkCapabilities.TRANSPORT_USB; 61 import static android.net.NetworkCapabilities.TRANSPORT_VPN; 62 import static android.net.NetworkCapabilities.TRANSPORT_WIFI; 63 import static android.net.NetworkCapabilities.TRANSPORT_WIFI_AWARE; 64 import static android.os.Process.INVALID_UID; 65 66 import static com.android.modules.utils.build.SdkLevel.isAtLeastS; 67 import static com.android.modules.utils.build.SdkLevel.isAtLeastT; 68 import static com.android.modules.utils.build.SdkLevel.isAtLeastV; 69 import static com.android.testutils.DevSdkIgnoreRuleKt.SC_V2; 70 import static com.android.testutils.MiscAsserts.assertEmpty; 71 import static com.android.testutils.MiscAsserts.assertThrows; 72 import static com.android.testutils.ParcelUtils.assertParcelingIsLossless; 73 74 import static org.junit.Assert.assertArrayEquals; 75 import static org.junit.Assert.assertEquals; 76 import static org.junit.Assert.assertFalse; 77 import static org.junit.Assert.assertNotEquals; 78 import static org.junit.Assert.assertNull; 79 import static org.junit.Assert.assertTrue; 80 import static org.junit.Assert.fail; 81 import static org.junit.Assume.assumeTrue; 82 83 import android.net.wifi.aware.DiscoverySession; 84 import android.net.wifi.aware.PeerHandle; 85 import android.net.wifi.aware.WifiAwareNetworkSpecifier; 86 import android.os.Build; 87 import android.util.ArraySet; 88 import android.util.Range; 89 90 import androidx.test.filters.SmallTest; 91 92 import com.android.testutils.CompatUtil; 93 import com.android.testutils.ConnectivityModuleTest; 94 import com.android.testutils.DevSdkIgnoreRule; 95 import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo; 96 import com.android.testutils.DevSdkIgnoreRunner; 97 98 import org.junit.Rule; 99 import org.junit.Test; 100 import org.junit.runner.RunWith; 101 import org.mockito.Mockito; 102 103 import java.util.ArrayList; 104 import java.util.Arrays; 105 import java.util.List; 106 import java.util.Set; 107 108 @SmallTest 109 @RunWith(DevSdkIgnoreRunner.class) 110 // NetworkCapabilities is only updatable on S+, and this test covers behavior which implementation 111 // is self-contained within NetworkCapabilities.java, so it does not need to be run on, or 112 // compatible with, earlier releases. 113 @IgnoreUpTo(Build.VERSION_CODES.R) 114 @ConnectivityModuleTest 115 public class NetworkCapabilitiesTest { 116 private static final String TEST_SSID = "TEST_SSID"; 117 private static final String DIFFERENT_TEST_SSID = "DIFFERENT_TEST_SSID"; 118 private static final int TEST_SUBID1 = 1; 119 private static final int TEST_SUBID2 = 2; 120 private static final int TEST_SUBID3 = 3; 121 122 private static final Set<Integer> TEST_NETWORKS_EXTRA_ALLOWED_CAPS_ON_NON_CELL = 123 Set.of(NET_CAPABILITY_CBS, NET_CAPABILITY_DUN, NET_CAPABILITY_RCS); 124 125 @Rule 126 public DevSdkIgnoreRule mDevSdkIgnoreRule = new DevSdkIgnoreRule(); 127 128 private DiscoverySession mDiscoverySession = Mockito.mock(DiscoverySession.class); 129 private PeerHandle mPeerHandle = Mockito.mock(PeerHandle.class); 130 131 @Test testMaybeMarkCapabilitiesRestricted()132 public void testMaybeMarkCapabilitiesRestricted() { 133 // check that internet does not get restricted 134 NetworkCapabilities netCap = new NetworkCapabilities(); 135 netCap.addCapability(NET_CAPABILITY_INTERNET); 136 netCap.maybeMarkCapabilitiesRestricted(); 137 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 138 139 // metered-ness shouldn't matter 140 netCap = new NetworkCapabilities(); 141 netCap.addCapability(NET_CAPABILITY_INTERNET); 142 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 143 netCap.maybeMarkCapabilitiesRestricted(); 144 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 145 netCap = new NetworkCapabilities(); 146 netCap.addCapability(NET_CAPABILITY_INTERNET); 147 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 148 netCap.maybeMarkCapabilitiesRestricted(); 149 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 150 151 // add EIMS - bundled with unrestricted means it's unrestricted 152 netCap = new NetworkCapabilities(); 153 netCap.addCapability(NET_CAPABILITY_INTERNET); 154 netCap.addCapability(NET_CAPABILITY_EIMS); 155 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 156 netCap.maybeMarkCapabilitiesRestricted(); 157 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 158 netCap = new NetworkCapabilities(); 159 netCap.addCapability(NET_CAPABILITY_INTERNET); 160 netCap.addCapability(NET_CAPABILITY_EIMS); 161 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 162 netCap.maybeMarkCapabilitiesRestricted(); 163 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 164 165 // just a restricted cap should be restricted regardless of meteredness 166 netCap = new NetworkCapabilities(); 167 netCap.addCapability(NET_CAPABILITY_EIMS); 168 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 169 netCap.maybeMarkCapabilitiesRestricted(); 170 assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 171 netCap = new NetworkCapabilities(); 172 netCap.addCapability(NET_CAPABILITY_EIMS); 173 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 174 netCap.maybeMarkCapabilitiesRestricted(); 175 assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 176 177 // try 2 restricted caps 178 netCap = new NetworkCapabilities(); 179 netCap.addCapability(NET_CAPABILITY_CBS); 180 netCap.addCapability(NET_CAPABILITY_EIMS); 181 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 182 netCap.maybeMarkCapabilitiesRestricted(); 183 assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 184 netCap = new NetworkCapabilities(); 185 netCap.addCapability(NET_CAPABILITY_CBS); 186 netCap.addCapability(NET_CAPABILITY_EIMS); 187 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 188 netCap.maybeMarkCapabilitiesRestricted(); 189 assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 190 } 191 192 @Test testDescribeImmutableDifferences()193 public void testDescribeImmutableDifferences() { 194 NetworkCapabilities nc1; 195 NetworkCapabilities nc2; 196 197 // Transports changing 198 nc1 = new NetworkCapabilities().addTransportType(TRANSPORT_CELLULAR); 199 nc2 = new NetworkCapabilities().addTransportType(TRANSPORT_WIFI); 200 assertNotEquals("", nc1.describeImmutableDifferences(nc2)); 201 assertEquals("", nc1.describeImmutableDifferences(nc1)); 202 203 // Mutable capability changing 204 nc1 = new NetworkCapabilities().addCapability(NET_CAPABILITY_VALIDATED); 205 nc2 = new NetworkCapabilities(); 206 assertEquals("", nc1.describeImmutableDifferences(nc2)); 207 assertEquals("", nc1.describeImmutableDifferences(nc1)); 208 209 // NOT_METERED changing (http://b/63326103) 210 nc1 = new NetworkCapabilities() 211 .addCapability(NET_CAPABILITY_NOT_METERED) 212 .addCapability(NET_CAPABILITY_INTERNET); 213 nc2 = new NetworkCapabilities().addCapability(NET_CAPABILITY_INTERNET); 214 assertEquals("", nc1.describeImmutableDifferences(nc2)); 215 assertEquals("", nc1.describeImmutableDifferences(nc1)); 216 217 // Immutable capability changing 218 nc1 = new NetworkCapabilities() 219 .addCapability(NET_CAPABILITY_INTERNET) 220 .removeCapability(NET_CAPABILITY_NOT_RESTRICTED); 221 nc2 = new NetworkCapabilities().addCapability(NET_CAPABILITY_INTERNET); 222 assertNotEquals("", nc1.describeImmutableDifferences(nc2)); 223 assertEquals("", nc1.describeImmutableDifferences(nc1)); 224 225 // Specifier changing 226 nc1 = new NetworkCapabilities().addTransportType(TRANSPORT_WIFI); 227 nc2 = new NetworkCapabilities() 228 .addTransportType(TRANSPORT_WIFI) 229 .setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier("eth42")); 230 assertNotEquals("", nc1.describeImmutableDifferences(nc2)); 231 assertEquals("", nc1.describeImmutableDifferences(nc1)); 232 } 233 234 @Test testLinkBandwidthUtils()235 public void testLinkBandwidthUtils() { 236 assertEquals(LINK_BANDWIDTH_UNSPECIFIED, NetworkCapabilities 237 .minBandwidth(LINK_BANDWIDTH_UNSPECIFIED, LINK_BANDWIDTH_UNSPECIFIED)); 238 assertEquals(10, NetworkCapabilities 239 .minBandwidth(LINK_BANDWIDTH_UNSPECIFIED, 10)); 240 assertEquals(10, NetworkCapabilities 241 .minBandwidth(10, LINK_BANDWIDTH_UNSPECIFIED)); 242 assertEquals(10, NetworkCapabilities 243 .minBandwidth(10, 20)); 244 245 assertEquals(LINK_BANDWIDTH_UNSPECIFIED, NetworkCapabilities 246 .maxBandwidth(LINK_BANDWIDTH_UNSPECIFIED, LINK_BANDWIDTH_UNSPECIFIED)); 247 assertEquals(10, NetworkCapabilities 248 .maxBandwidth(LINK_BANDWIDTH_UNSPECIFIED, 10)); 249 assertEquals(10, NetworkCapabilities 250 .maxBandwidth(10, LINK_BANDWIDTH_UNSPECIFIED)); 251 assertEquals(20, NetworkCapabilities 252 .maxBandwidth(10, 20)); 253 } 254 255 @Test testSetUids()256 public void testSetUids() { 257 final NetworkCapabilities netCap = new NetworkCapabilities(); 258 // Null uids match all UIDs 259 netCap.setUids(null); 260 assertTrue(netCap.appliesToUid(10)); 261 assertTrue(netCap.appliesToUid(200)); 262 assertTrue(netCap.appliesToUid(3000)); 263 assertTrue(netCap.appliesToUid(10010)); 264 assertTrue(netCap.appliesToUidRange(new UidRange(50, 100))); 265 assertTrue(netCap.appliesToUidRange(new UidRange(70, 72))); 266 assertTrue(netCap.appliesToUidRange(new UidRange(3500, 3912))); 267 assertTrue(netCap.appliesToUidRange(new UidRange(1, 100000))); 268 269 if (isAtLeastS()) { 270 final Set<Range<Integer>> uids = new ArraySet<>(); 271 uids.add(uidRange(50, 100)); 272 uids.add(uidRange(3000, 4000)); 273 netCap.setUids(uids); 274 assertTrue(netCap.appliesToUid(50)); 275 assertTrue(netCap.appliesToUid(80)); 276 assertTrue(netCap.appliesToUid(100)); 277 assertTrue(netCap.appliesToUid(3000)); 278 assertTrue(netCap.appliesToUid(3001)); 279 assertFalse(netCap.appliesToUid(10)); 280 assertFalse(netCap.appliesToUid(25)); 281 assertFalse(netCap.appliesToUid(49)); 282 assertFalse(netCap.appliesToUid(101)); 283 assertFalse(netCap.appliesToUid(2000)); 284 assertFalse(netCap.appliesToUid(100000)); 285 286 assertTrue(netCap.appliesToUidRange(new UidRange(50, 100))); 287 assertTrue(netCap.appliesToUidRange(new UidRange(70, 72))); 288 assertTrue(netCap.appliesToUidRange(new UidRange(3500, 3912))); 289 assertFalse(netCap.appliesToUidRange(new UidRange(1, 100))); 290 assertFalse(netCap.appliesToUidRange(new UidRange(49, 100))); 291 assertFalse(netCap.appliesToUidRange(new UidRange(1, 10))); 292 assertFalse(netCap.appliesToUidRange(new UidRange(60, 101))); 293 assertFalse(netCap.appliesToUidRange(new UidRange(60, 3400))); 294 295 NetworkCapabilities netCap2 = new NetworkCapabilities(); 296 // A new netcap object has null UIDs, so anything will satisfy it. 297 assertTrue(netCap2.satisfiedByUids(netCap)); 298 // Still not equal though. 299 assertFalse(netCap2.equalsUids(netCap)); 300 netCap2.setUids(uids); 301 assertTrue(netCap2.satisfiedByUids(netCap)); 302 assertTrue(netCap.equalsUids(netCap2)); 303 assertTrue(netCap2.equalsUids(netCap)); 304 305 uids.add(uidRange(600, 700)); 306 netCap2.setUids(uids); 307 assertFalse(netCap2.satisfiedByUids(netCap)); 308 assertFalse(netCap.appliesToUid(650)); 309 assertTrue(netCap2.appliesToUid(650)); 310 netCap.setUids(uids); 311 assertTrue(netCap2.satisfiedByUids(netCap)); 312 assertTrue(netCap.appliesToUid(650)); 313 assertFalse(netCap.appliesToUid(500)); 314 315 // Null uids satisfies everything. 316 netCap.setUids(null); 317 assertTrue(netCap2.satisfiedByUids(netCap)); 318 assertTrue(netCap.satisfiedByUids(netCap2)); 319 netCap2.setUids(null); 320 assertTrue(netCap2.satisfiedByUids(netCap)); 321 assertTrue(netCap.satisfiedByUids(netCap2)); 322 } 323 } 324 325 @Test @IgnoreUpTo(SC_V2) testSetAllowedUids()326 public void testSetAllowedUids() { 327 final NetworkCapabilities nc = new NetworkCapabilities(); 328 assertThrows(NullPointerException.class, () -> nc.setAllowedUids(null)); 329 assertFalse(nc.hasAllowedUids()); 330 assertFalse(nc.isUidWithAccess(0)); 331 assertFalse(nc.isUidWithAccess(1000)); 332 assertEquals(0, nc.getAllowedUids().size()); 333 nc.setAllowedUids(new ArraySet<>()); 334 assertFalse(nc.hasAllowedUids()); 335 assertFalse(nc.isUidWithAccess(0)); 336 assertFalse(nc.isUidWithAccess(1000)); 337 assertEquals(0, nc.getAllowedUids().size()); 338 339 final ArraySet<Integer> uids = new ArraySet<>(); 340 uids.add(200); 341 uids.add(250); 342 uids.add(-1); 343 uids.add(Integer.MAX_VALUE); 344 nc.setAllowedUids(uids); 345 assertNotEquals(nc, new NetworkCapabilities()); 346 assertTrue(nc.hasAllowedUids()); 347 348 final List<Integer> includedList = List.of(-2, 0, 199, 700, 901, 1000, Integer.MIN_VALUE); 349 final List<Integer> excludedList = List.of(-1, 200, 250, Integer.MAX_VALUE); 350 for (final int uid : includedList) { 351 assertFalse(nc.isUidWithAccess(uid)); 352 } 353 for (final int uid : excludedList) { 354 assertTrue(nc.isUidWithAccess(uid)); 355 } 356 357 final Set<Integer> outUids = nc.getAllowedUids(); 358 assertEquals(4, outUids.size()); 359 for (final int uid : includedList) { 360 assertFalse(outUids.contains(uid)); 361 } 362 for (final int uid : excludedList) { 363 assertTrue(outUids.contains(uid)); 364 } 365 } 366 367 @Test testParcelNetworkCapabilities()368 public void testParcelNetworkCapabilities() { 369 final Set<Range<Integer>> uids = new ArraySet<>(); 370 uids.add(uidRange(50, 100)); 371 uids.add(uidRange(3000, 4000)); 372 final NetworkCapabilities netCap = new NetworkCapabilities() 373 .addCapability(NET_CAPABILITY_INTERNET) 374 .addCapability(NET_CAPABILITY_EIMS) 375 .addCapability(NET_CAPABILITY_NOT_METERED); 376 if (isAtLeastV()) { 377 netCap.addCapability(NET_CAPABILITY_LOCAL_NETWORK); 378 } 379 if (isAtLeastS()) { 380 final ArraySet<Integer> allowedUids = new ArraySet<>(); 381 allowedUids.add(4); 382 allowedUids.add(9); 383 netCap.setAllowedUids(allowedUids); 384 netCap.setSubscriptionIds(Set.of(TEST_SUBID1, TEST_SUBID2)); 385 netCap.setUids(uids); 386 netCap.setReservationId(42); 387 } 388 389 netCap.setOwnerUid(123); 390 netCap.setAdministratorUids(new int[] {5, 11}); 391 assertParcelingIsLossless(netCap); 392 netCap.setSSID(TEST_SSID); 393 testParcelSane(netCap); 394 } 395 396 @Test testParcelNetworkCapabilitiesWithRequestorUidAndPackageName()397 public void testParcelNetworkCapabilitiesWithRequestorUidAndPackageName() { 398 final NetworkCapabilities netCap = new NetworkCapabilities() 399 .addCapability(NET_CAPABILITY_INTERNET) 400 .addCapability(NET_CAPABILITY_EIMS) 401 .addCapability(NET_CAPABILITY_NOT_METERED); 402 netCap.setRequestorPackageName("com.android.test"); 403 netCap.setRequestorUid(9304); 404 assertParcelingIsLossless(netCap); 405 netCap.setSSID(TEST_SSID); 406 testParcelSane(netCap); 407 } 408 testParcelSane(NetworkCapabilities cap)409 private void testParcelSane(NetworkCapabilities cap) { 410 assertParcelingIsLossless(cap); 411 } 412 createNetworkCapabilitiesWithTransportInfo()413 private static NetworkCapabilities createNetworkCapabilitiesWithTransportInfo() { 414 return new NetworkCapabilities() 415 .addCapability(NET_CAPABILITY_INTERNET) 416 .addCapability(NET_CAPABILITY_EIMS) 417 .addCapability(NET_CAPABILITY_NOT_METERED) 418 .setSSID(TEST_SSID) 419 .setTransportInfo(new TestTransportInfo()) 420 .setRequestorPackageName("com.android.test") 421 .setRequestorUid(9304); 422 } 423 424 @Test testNetworkCapabilitiesCopyWithNoRedactions()425 public void testNetworkCapabilitiesCopyWithNoRedactions() { 426 assumeTrue(isAtLeastS()); 427 428 final NetworkCapabilities netCap = createNetworkCapabilitiesWithTransportInfo(); 429 final NetworkCapabilities netCapWithNoRedactions = 430 new NetworkCapabilities(netCap, NetworkCapabilities.REDACT_NONE); 431 TestTransportInfo testTransportInfo = 432 (TestTransportInfo) netCapWithNoRedactions.getTransportInfo(); 433 assertFalse(testTransportInfo.locationRedacted); 434 assertFalse(testTransportInfo.localMacAddressRedacted); 435 assertFalse(testTransportInfo.settingsRedacted); 436 } 437 438 @Test testNetworkCapabilitiesCopyWithoutLocationSensitiveFields()439 public void testNetworkCapabilitiesCopyWithoutLocationSensitiveFields() { 440 assumeTrue(isAtLeastS()); 441 442 final NetworkCapabilities netCap = createNetworkCapabilitiesWithTransportInfo(); 443 final NetworkCapabilities netCapWithNoRedactions = 444 new NetworkCapabilities(netCap, REDACT_FOR_ACCESS_FINE_LOCATION); 445 TestTransportInfo testTransportInfo = 446 (TestTransportInfo) netCapWithNoRedactions.getTransportInfo(); 447 assertTrue(testTransportInfo.locationRedacted); 448 assertFalse(testTransportInfo.localMacAddressRedacted); 449 assertFalse(testTransportInfo.settingsRedacted); 450 } 451 452 @Test testOemPaid()453 public void testOemPaid() { 454 NetworkCapabilities nc = new NetworkCapabilities(); 455 // By default OEM_PAID is neither in the required or forbidden lists and the network is not 456 // restricted. 457 if (isAtLeastS()) { 458 assertFalse(nc.hasForbiddenCapability(NET_CAPABILITY_OEM_PAID)); 459 } 460 assertFalse(nc.hasCapability(NET_CAPABILITY_OEM_PAID)); 461 nc.maybeMarkCapabilitiesRestricted(); 462 assertTrue(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 463 464 // Adding OEM_PAID to capability list should make network restricted. 465 nc.addCapability(NET_CAPABILITY_OEM_PAID); 466 nc.addCapability(NET_CAPABILITY_INTERNET); // Combine with unrestricted capability. 467 nc.maybeMarkCapabilitiesRestricted(); 468 assertTrue(nc.hasCapability(NET_CAPABILITY_OEM_PAID)); 469 assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 470 471 // Now let's make request for OEM_PAID network. 472 NetworkCapabilities nr = new NetworkCapabilities(); 473 nr.addCapability(NET_CAPABILITY_OEM_PAID); 474 nr.maybeMarkCapabilitiesRestricted(); 475 assertTrue(nr.satisfiedByNetworkCapabilities(nc)); 476 477 // Request fails for network with the default capabilities. 478 assertFalse(nr.satisfiedByNetworkCapabilities(new NetworkCapabilities())); 479 } 480 481 @Test @IgnoreUpTo(SC_V2) // TODO: Use to Build.VERSION_CODES.SC_V2 when available testPrioritizeLatencyAndBandwidth()482 public void testPrioritizeLatencyAndBandwidth() { 483 NetworkCapabilities netCap = new NetworkCapabilities(); 484 netCap.addCapability(NET_CAPABILITY_PRIORITIZE_LATENCY); 485 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 486 netCap.maybeMarkCapabilitiesRestricted(); 487 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 488 netCap = new NetworkCapabilities(); 489 netCap.addCapability(NET_CAPABILITY_PRIORITIZE_LATENCY); 490 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 491 netCap.maybeMarkCapabilitiesRestricted(); 492 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 493 494 netCap = new NetworkCapabilities(); 495 netCap.addCapability(NET_CAPABILITY_PRIORITIZE_BANDWIDTH); 496 netCap.addCapability(NET_CAPABILITY_NOT_METERED); 497 netCap.maybeMarkCapabilitiesRestricted(); 498 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 499 netCap = new NetworkCapabilities(); 500 netCap.addCapability(NET_CAPABILITY_PRIORITIZE_BANDWIDTH); 501 netCap.removeCapability(NET_CAPABILITY_NOT_METERED); 502 netCap.maybeMarkCapabilitiesRestricted(); 503 assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 504 } 505 506 @Test testOemPrivate()507 public void testOemPrivate() { 508 NetworkCapabilities nc = new NetworkCapabilities(); 509 // By default OEM_PRIVATE is neither in the required or forbidden lists and the network is 510 // not restricted. 511 assertFalse(nc.hasForbiddenCapability(NET_CAPABILITY_OEM_PRIVATE)); 512 assertFalse(nc.hasCapability(NET_CAPABILITY_OEM_PRIVATE)); 513 nc.maybeMarkCapabilitiesRestricted(); 514 assertTrue(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 515 516 // Adding OEM_PRIVATE to capability list should make network restricted. 517 nc.addCapability(NET_CAPABILITY_OEM_PRIVATE); 518 nc.addCapability(NET_CAPABILITY_INTERNET); // Combine with unrestricted capability. 519 nc.maybeMarkCapabilitiesRestricted(); 520 assertTrue(nc.hasCapability(NET_CAPABILITY_OEM_PRIVATE)); 521 assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 522 523 // Now let's make request for OEM_PRIVATE network. 524 NetworkCapabilities nr = new NetworkCapabilities(); 525 nr.addCapability(NET_CAPABILITY_OEM_PRIVATE); 526 nr.maybeMarkCapabilitiesRestricted(); 527 assertTrue(nr.satisfiedByNetworkCapabilities(nc)); 528 529 // Request fails for network with the default capabilities. 530 assertFalse(nr.satisfiedByNetworkCapabilities(new NetworkCapabilities())); 531 } 532 533 @Test testForbiddenCapabilities()534 public void testForbiddenCapabilities() { 535 NetworkCapabilities network = new NetworkCapabilities(); 536 537 NetworkCapabilities request = new NetworkCapabilities(); 538 assertTrue("Request: " + request + ", Network:" + network, 539 request.satisfiedByNetworkCapabilities(network)); 540 541 // Requesting absence of capabilities that network doesn't have. Request should satisfy. 542 request.addForbiddenCapability(NET_CAPABILITY_WIFI_P2P); 543 request.addForbiddenCapability(NET_CAPABILITY_NOT_METERED); 544 assertTrue(request.satisfiedByNetworkCapabilities(network)); 545 assertArrayEquals(new int[]{NET_CAPABILITY_WIFI_P2P, 546 NET_CAPABILITY_NOT_METERED}, 547 request.getForbiddenCapabilities()); 548 549 // This is a default capability, just want to make sure its there because we use it below. 550 assertTrue(network.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 551 552 // Verify that adding forbidden capability will effectively remove it from capability list. 553 request.addForbiddenCapability(NET_CAPABILITY_NOT_RESTRICTED); 554 assertTrue(request.hasForbiddenCapability(NET_CAPABILITY_NOT_RESTRICTED)); 555 assertFalse(request.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 556 557 // Now this request won't be satisfied because network contains NOT_RESTRICTED. 558 assertFalse(request.satisfiedByNetworkCapabilities(network)); 559 network.removeCapability(NET_CAPABILITY_NOT_RESTRICTED); 560 assertTrue(request.satisfiedByNetworkCapabilities(network)); 561 562 // Verify that adding capability will effectively remove it from forbidden list 563 request.addCapability(NET_CAPABILITY_NOT_RESTRICTED); 564 assertTrue(request.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 565 assertFalse(request.hasForbiddenCapability(NET_CAPABILITY_NOT_RESTRICTED)); 566 567 assertFalse(request.satisfiedByNetworkCapabilities(network)); 568 network.addCapability(NET_CAPABILITY_NOT_RESTRICTED); 569 assertTrue(request.satisfiedByNetworkCapabilities(network)); 570 } 571 572 @Test testConnectivityManagedCapabilities()573 public void testConnectivityManagedCapabilities() { 574 NetworkCapabilities nc = new NetworkCapabilities(); 575 assertFalse(nc.hasConnectivityManagedCapability()); 576 // Check every single system managed capability. 577 nc.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL); 578 assertTrue(nc.hasConnectivityManagedCapability()); 579 nc.removeCapability(NET_CAPABILITY_CAPTIVE_PORTAL); 580 nc.addCapability(NET_CAPABILITY_FOREGROUND); 581 assertTrue(nc.hasConnectivityManagedCapability()); 582 nc.removeCapability(NET_CAPABILITY_FOREGROUND); 583 nc.addCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY); 584 assertTrue(nc.hasConnectivityManagedCapability()); 585 nc.removeCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY); 586 nc.addCapability(NET_CAPABILITY_VALIDATED); 587 assertTrue(nc.hasConnectivityManagedCapability()); 588 } 589 590 @Test testEqualsNetCapabilities()591 public void testEqualsNetCapabilities() { 592 NetworkCapabilities nc1 = new NetworkCapabilities(); 593 NetworkCapabilities nc2 = new NetworkCapabilities(); 594 assertTrue(nc1.equalsNetCapabilities(nc2)); 595 assertEquals(nc1, nc2); 596 597 nc1.addCapability(NET_CAPABILITY_MMS); 598 assertFalse(nc1.equalsNetCapabilities(nc2)); 599 assertNotEquals(nc1, nc2); 600 nc2.addCapability(NET_CAPABILITY_MMS); 601 assertTrue(nc1.equalsNetCapabilities(nc2)); 602 assertEquals(nc1, nc2); 603 604 if (isAtLeastS()) { 605 nc1.addForbiddenCapability(NET_CAPABILITY_INTERNET); 606 assertFalse(nc1.equalsNetCapabilities(nc2)); 607 nc2.addForbiddenCapability(NET_CAPABILITY_INTERNET); 608 assertTrue(nc1.equalsNetCapabilities(nc2)); 609 610 // Remove a required capability doesn't affect forbidden capabilities. 611 // This is a behaviour change from R to S. 612 nc1.removeCapability(NET_CAPABILITY_INTERNET); 613 assertTrue(nc1.equalsNetCapabilities(nc2)); 614 615 nc1.removeForbiddenCapability(NET_CAPABILITY_INTERNET); 616 assertFalse(nc1.equalsNetCapabilities(nc2)); 617 nc2.removeForbiddenCapability(NET_CAPABILITY_INTERNET); 618 assertTrue(nc1.equalsNetCapabilities(nc2)); 619 } 620 } 621 622 @Test testSSID()623 public void testSSID() { 624 NetworkCapabilities nc1 = new NetworkCapabilities(); 625 NetworkCapabilities nc2 = new NetworkCapabilities(); 626 assertTrue(nc2.satisfiedBySSID(nc1)); 627 628 nc1.setSSID(TEST_SSID); 629 assertTrue(nc2.satisfiedBySSID(nc1)); 630 nc2.setSSID("different " + TEST_SSID); 631 assertFalse(nc2.satisfiedBySSID(nc1)); 632 633 assertTrue(nc1.satisfiedByImmutableNetworkCapabilities(nc2)); 634 assertFalse(nc1.satisfiedByNetworkCapabilities(nc2)); 635 } 636 uidRanges(int from, int to)637 private ArraySet<Range<Integer>> uidRanges(int from, int to) { 638 final ArraySet<Range<Integer>> range = new ArraySet<>(1); 639 range.add(uidRange(from, to)); 640 return range; 641 } 642 uidRange(int from, int to)643 private Range<Integer> uidRange(int from, int to) { 644 return new Range<Integer>(from, to); 645 } 646 647 @Test testSetAdministratorUids()648 public void testSetAdministratorUids() { 649 NetworkCapabilities nc = 650 new NetworkCapabilities().setAdministratorUids(new int[] {2, 1, 3}); 651 652 assertArrayEquals(new int[] {1, 2, 3}, nc.getAdministratorUids()); 653 } 654 655 @Test testSetAdministratorUidsWithDuplicates()656 public void testSetAdministratorUidsWithDuplicates() { 657 try { 658 new NetworkCapabilities().setAdministratorUids(new int[] {1, 1}); 659 fail("Expected IllegalArgumentException for duplicate uids"); 660 } catch (IllegalArgumentException expected) { 661 } 662 } 663 664 @Test testSetCapabilities()665 public void testSetCapabilities() { 666 final int[] REQUIRED_CAPABILITIES = new int[] { 667 NET_CAPABILITY_INTERNET, NET_CAPABILITY_NOT_VPN }; 668 669 NetworkCapabilities nc1 = new NetworkCapabilities(); 670 NetworkCapabilities nc2 = new NetworkCapabilities(); 671 672 nc1.setCapabilities(REQUIRED_CAPABILITIES); 673 assertArrayEquals(REQUIRED_CAPABILITIES, nc1.getCapabilities()); 674 675 // Verify that setting and adding capabilities leads to the same object state. 676 nc2.clearAll(); 677 for (int cap : REQUIRED_CAPABILITIES) { 678 nc2.addCapability(cap); 679 } 680 assertEquals(nc1, nc2); 681 682 if (isAtLeastS()) { 683 final int[] forbiddenCapabilities = new int[]{ 684 NET_CAPABILITY_NOT_METERED, NET_CAPABILITY_NOT_RESTRICTED }; 685 686 nc1.setCapabilities(REQUIRED_CAPABILITIES, forbiddenCapabilities); 687 assertArrayEquals(REQUIRED_CAPABILITIES, nc1.getCapabilities()); 688 assertArrayEquals(forbiddenCapabilities, nc1.getForbiddenCapabilities()); 689 690 nc2.clearAll(); 691 for (int cap : REQUIRED_CAPABILITIES) { 692 nc2.addCapability(cap); 693 } 694 for (int cap : forbiddenCapabilities) { 695 nc2.addForbiddenCapability(cap); 696 } 697 assertEquals(nc1, nc2); 698 } 699 } 700 701 @Test testUnderlyingNetworks()702 public void testUnderlyingNetworks() { 703 assumeTrue(isAtLeastT()); 704 final NetworkCapabilities nc = new NetworkCapabilities(); 705 final Network network1 = new Network(100); 706 final Network network2 = new Network(101); 707 final ArrayList<Network> inputNetworks = new ArrayList<>(); 708 inputNetworks.add(network1); 709 inputNetworks.add(network2); 710 nc.setUnderlyingNetworks(inputNetworks); 711 final ArrayList<Network> outputNetworks = new ArrayList<>(nc.getUnderlyingNetworks()); 712 assertEquals(network1, outputNetworks.get(0)); 713 assertEquals(network2, outputNetworks.get(1)); 714 nc.setUnderlyingNetworks(null); 715 assertNull(nc.getUnderlyingNetworks()); 716 } 717 718 @Test testEqualsForUnderlyingNetworks()719 public void testEqualsForUnderlyingNetworks() { 720 assumeTrue(isAtLeastT()); 721 final NetworkCapabilities nc1 = new NetworkCapabilities(); 722 final NetworkCapabilities nc2 = new NetworkCapabilities(); 723 assertEquals(nc1, nc2); 724 final Network network = new Network(100); 725 final ArrayList<Network> inputNetworks = new ArrayList<>(); 726 final ArrayList<Network> emptyList = new ArrayList<>(); 727 inputNetworks.add(network); 728 nc1.setUnderlyingNetworks(inputNetworks); 729 assertNotEquals(nc1, nc2); 730 nc2.setUnderlyingNetworks(inputNetworks); 731 assertEquals(nc1, nc2); 732 nc1.setUnderlyingNetworks(emptyList); 733 assertNotEquals(nc1, nc2); 734 nc2.setUnderlyingNetworks(emptyList); 735 assertEquals(nc1, nc2); 736 nc1.setUnderlyingNetworks(null); 737 assertNotEquals(nc1, nc2); 738 nc2.setUnderlyingNetworks(null); 739 assertEquals(nc1, nc2); 740 } 741 742 @Test testSetNetworkSpecifierOnMultiTransportNc()743 public void testSetNetworkSpecifierOnMultiTransportNc() { 744 // Sequence 1: Transport + Transport + NetworkSpecifier 745 NetworkCapabilities.Builder nc1 = new NetworkCapabilities.Builder(); 746 nc1.addTransportType(TRANSPORT_CELLULAR).addTransportType(TRANSPORT_WIFI); 747 final NetworkSpecifier specifier = CompatUtil.makeEthernetNetworkSpecifier("eth0"); 748 assertThrows("Cannot set NetworkSpecifier on a NetworkCapability with multiple transports!", 749 IllegalStateException.class, 750 () -> nc1.build().setNetworkSpecifier(specifier)); 751 assertThrows("Cannot set NetworkSpecifier on a NetworkCapability with multiple transports!", 752 IllegalStateException.class, 753 () -> nc1.setNetworkSpecifier(specifier)); 754 755 // Sequence 2: Transport + NetworkSpecifier + Transport 756 NetworkCapabilities.Builder nc2 = new NetworkCapabilities.Builder(); 757 nc2.addTransportType(TRANSPORT_CELLULAR).setNetworkSpecifier(specifier); 758 759 assertThrows("Cannot set a second TransportType of a network which has a NetworkSpecifier!", 760 IllegalStateException.class, 761 () -> nc2.build().addTransportType(TRANSPORT_WIFI)); 762 assertThrows("Cannot set a second TransportType of a network which has a NetworkSpecifier!", 763 IllegalStateException.class, 764 () -> nc2.addTransportType(TRANSPORT_WIFI)); 765 } 766 767 @Test testSetNetworkSpecifierWithCellularAndSatelliteMultiTransportNc()768 public void testSetNetworkSpecifierWithCellularAndSatelliteMultiTransportNc() { 769 final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(1); 770 NetworkCapabilities nc = new NetworkCapabilities.Builder() 771 .addTransportType(TRANSPORT_CELLULAR) 772 .addTransportType(TRANSPORT_SATELLITE) 773 .setNetworkSpecifier(specifier) 774 .build(); 775 // Adding a specifier did not crash with 2 transports if it is cellular + satellite 776 assertEquals(specifier, nc.getNetworkSpecifier()); 777 } 778 779 @Test testSetNetworkSpecifierWithWifiAndSatelliteMultiTransportNc()780 public void testSetNetworkSpecifierWithWifiAndSatelliteMultiTransportNc() { 781 final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(1); 782 NetworkCapabilities.Builder nc1 = new NetworkCapabilities.Builder(); 783 nc1.addTransportType(TRANSPORT_SATELLITE).addTransportType(TRANSPORT_WIFI); 784 // Adding multiple transports specifier to crash, apart from cellular + satellite 785 // combination 786 assertThrows("Cannot set NetworkSpecifier on a NetworkCapability with multiple transports!", 787 IllegalStateException.class, 788 () -> nc1.build().setNetworkSpecifier(specifier)); 789 assertThrows("Cannot set NetworkSpecifier on a NetworkCapability with multiple transports!", 790 IllegalStateException.class, 791 () -> nc1.setNetworkSpecifier(specifier)); 792 } 793 794 @Test testSetNetworkSpecifierOnTestWithCellularAndSatelliteMultiTransportNc()795 public void testSetNetworkSpecifierOnTestWithCellularAndSatelliteMultiTransportNc() { 796 final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(1); 797 NetworkCapabilities nc = new NetworkCapabilities.Builder() 798 .addTransportType(TRANSPORT_TEST) 799 .addTransportType(TRANSPORT_CELLULAR) 800 .addTransportType(TRANSPORT_SATELLITE) 801 .setNetworkSpecifier(specifier) 802 .build(); 803 // Adding a specifier did not crash with 3 transports , TEST + CELLULAR + SATELLITE and if 804 // one is test 805 assertEquals(specifier, nc.getNetworkSpecifier()); 806 } 807 808 @Test testSetNetworkSpecifierOnTestMultiTransportNc()809 public void testSetNetworkSpecifierOnTestMultiTransportNc() { 810 final NetworkSpecifier specifier = CompatUtil.makeEthernetNetworkSpecifier("eth0"); 811 NetworkCapabilities nc = new NetworkCapabilities.Builder() 812 .addTransportType(TRANSPORT_TEST) 813 .addTransportType(TRANSPORT_ETHERNET) 814 .setNetworkSpecifier(specifier) 815 .build(); 816 // Adding a specifier did not crash with 2 transports if one is TEST 817 assertEquals(specifier, nc.getNetworkSpecifier()); 818 } 819 820 @Test testSetTransportInfoOnMultiTransportNc()821 public void testSetTransportInfoOnMultiTransportNc() { 822 // Sequence 1: Transport + Transport + TransportInfo 823 NetworkCapabilities nc1 = new NetworkCapabilities(); 824 nc1.addTransportType(TRANSPORT_CELLULAR).addTransportType(TRANSPORT_WIFI) 825 .setTransportInfo(new TestTransportInfo()); 826 827 // Sequence 2: Transport + NetworkSpecifier + Transport 828 NetworkCapabilities nc2 = new NetworkCapabilities(); 829 nc2.addTransportType(TRANSPORT_CELLULAR).setTransportInfo(new TestTransportInfo()) 830 .addTransportType(TRANSPORT_WIFI); 831 } 832 833 @Test testSet()834 public void testSet() { 835 NetworkCapabilities nc1 = new NetworkCapabilities(); 836 NetworkCapabilities nc2 = new NetworkCapabilities(); 837 838 if (isAtLeastS()) { 839 nc1.addForbiddenCapability(NET_CAPABILITY_CAPTIVE_PORTAL); 840 } 841 nc1.addCapability(NET_CAPABILITY_NOT_ROAMING); 842 assertNotEquals(nc1, nc2); 843 nc2.set(nc1); 844 assertEquals(nc1, nc2); 845 assertTrue(nc2.hasCapability(NET_CAPABILITY_NOT_ROAMING)); 846 if (isAtLeastS()) { 847 assertTrue(nc2.hasForbiddenCapability(NET_CAPABILITY_CAPTIVE_PORTAL)); 848 } 849 850 if (isAtLeastS()) { 851 // This will effectively move NOT_ROAMING capability from required to forbidden for nc1. 852 nc1.addForbiddenCapability(NET_CAPABILITY_NOT_ROAMING); 853 } 854 nc1.setSSID(TEST_SSID); 855 nc2.set(nc1); 856 assertEquals(nc1, nc2); 857 if (isAtLeastS()) { 858 // Contrary to combineCapabilities, set() will have removed the NOT_ROAMING capability 859 // from nc2. 860 assertFalse(nc2.hasCapability(NET_CAPABILITY_NOT_ROAMING)); 861 assertTrue(nc2.hasForbiddenCapability(NET_CAPABILITY_NOT_ROAMING)); 862 } 863 864 assertTrue(TEST_SSID.equals(nc2.getSsid())); 865 nc1.setSSID(DIFFERENT_TEST_SSID); 866 nc2.set(nc1); 867 assertEquals(nc1, nc2); 868 assertTrue(DIFFERENT_TEST_SSID.equals(nc2.getSsid())); 869 870 if (isAtLeastS()) { 871 nc1.setUids(uidRanges(10, 13)); 872 } else { 873 nc1.setUids(null); 874 } 875 nc2.set(nc1); // Overwrites, as opposed to combineCapabilities 876 assertEquals(nc1, nc2); 877 878 if (isAtLeastS()) { 879 assertThrows(NullPointerException.class, () -> nc1.setSubscriptionIds(null)); 880 nc1.setSubscriptionIds(Set.of()); 881 nc2.set(nc1); 882 assertEquals(nc1, nc2); 883 884 nc1.setSubscriptionIds(Set.of(TEST_SUBID1)); 885 nc2.set(nc1); 886 assertEquals(nc1, nc2); 887 888 nc2.setSubscriptionIds(Set.of(TEST_SUBID2, TEST_SUBID1)); 889 nc2.set(nc1); 890 assertEquals(nc1, nc2); 891 892 nc2.setSubscriptionIds(Set.of(TEST_SUBID3, TEST_SUBID2)); 893 assertNotEquals(nc1, nc2); 894 } 895 } 896 897 @Test testGetTransportTypes()898 public void testGetTransportTypes() { 899 final NetworkCapabilities nc = new NetworkCapabilities(); 900 nc.addTransportType(TRANSPORT_CELLULAR); 901 nc.addTransportType(TRANSPORT_WIFI); 902 nc.addTransportType(TRANSPORT_VPN); 903 nc.addTransportType(TRANSPORT_TEST); 904 905 final int[] transportTypes = nc.getTransportTypes(); 906 assertEquals(4, transportTypes.length); 907 assertEquals(TRANSPORT_CELLULAR, transportTypes[0]); 908 assertEquals(TRANSPORT_WIFI, transportTypes[1]); 909 assertEquals(TRANSPORT_VPN, transportTypes[2]); 910 assertEquals(TRANSPORT_TEST, transportTypes[3]); 911 } 912 913 @Test testTelephonyNetworkSpecifier()914 public void testTelephonyNetworkSpecifier() { 915 final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(1); 916 final NetworkCapabilities nc1 = new NetworkCapabilities.Builder() 917 .addTransportType(TRANSPORT_WIFI) 918 .setNetworkSpecifier(specifier) 919 .build(); 920 assertEquals(specifier, nc1.getNetworkSpecifier()); 921 try { 922 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 923 .setNetworkSpecifier(specifier) 924 .build(); 925 fail("Must have a single transport type. Without transport type or multiple transport" 926 + " types is invalid."); 927 } catch (IllegalStateException expected) { } 928 } 929 930 @Test @IgnoreUpTo(SC_V2) // TODO: Use to Build.VERSION_CODES.SC_V2 when available testEnterpriseId()931 public void testEnterpriseId() { 932 final NetworkCapabilities nc1 = new NetworkCapabilities.Builder() 933 .addCapability(NET_CAPABILITY_ENTERPRISE) 934 .addEnterpriseId(NET_ENTERPRISE_ID_1) 935 .build(); 936 assertEquals(1, nc1.getEnterpriseIds().length); 937 assertEquals(NET_ENTERPRISE_ID_1, 938 nc1.getEnterpriseIds()[0]); 939 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 940 .addCapability(NET_CAPABILITY_ENTERPRISE) 941 .addEnterpriseId(NET_ENTERPRISE_ID_1) 942 .addEnterpriseId(NET_ENTERPRISE_ID_2) 943 .build(); 944 assertEquals(2, nc2.getEnterpriseIds().length); 945 assertEquals(NET_ENTERPRISE_ID_1, 946 nc2.getEnterpriseIds()[0]); 947 assertEquals(NET_ENTERPRISE_ID_2, 948 nc2.getEnterpriseIds()[1]); 949 final NetworkCapabilities nc3 = new NetworkCapabilities.Builder() 950 .addCapability(NET_CAPABILITY_ENTERPRISE) 951 .addEnterpriseId(NET_ENTERPRISE_ID_1) 952 .addEnterpriseId(NET_ENTERPRISE_ID_2) 953 .addEnterpriseId(NET_ENTERPRISE_ID_3) 954 .addEnterpriseId(NET_ENTERPRISE_ID_4) 955 .addEnterpriseId(NET_ENTERPRISE_ID_5) 956 .build(); 957 assertEquals(5, nc3.getEnterpriseIds().length); 958 assertEquals(NET_ENTERPRISE_ID_1, 959 nc3.getEnterpriseIds()[0]); 960 assertEquals(NET_ENTERPRISE_ID_2, 961 nc3.getEnterpriseIds()[1]); 962 assertEquals(NET_ENTERPRISE_ID_3, 963 nc3.getEnterpriseIds()[2]); 964 assertEquals(NET_ENTERPRISE_ID_4, 965 nc3.getEnterpriseIds()[3]); 966 assertEquals(NET_ENTERPRISE_ID_5, 967 nc3.getEnterpriseIds()[4]); 968 969 final Class<IllegalArgumentException> illegalArgumentExceptionClass = 970 IllegalArgumentException.class; 971 assertThrows(illegalArgumentExceptionClass, () -> new NetworkCapabilities.Builder() 972 .addEnterpriseId(6) 973 .build()); 974 assertThrows(illegalArgumentExceptionClass, () -> new NetworkCapabilities.Builder() 975 .removeEnterpriseId(6) 976 .build()); 977 978 final Class<IllegalStateException> illegalStateException = 979 IllegalStateException.class; 980 assertThrows(illegalStateException, () -> new NetworkCapabilities.Builder() 981 .addEnterpriseId(NET_ENTERPRISE_ID_1) 982 .build()); 983 984 final NetworkCapabilities nc4 = new NetworkCapabilities.Builder() 985 .addCapability(NET_CAPABILITY_ENTERPRISE) 986 .addEnterpriseId(NET_ENTERPRISE_ID_1) 987 .addEnterpriseId(NET_ENTERPRISE_ID_2) 988 .removeEnterpriseId(NET_ENTERPRISE_ID_1) 989 .removeEnterpriseId(NET_ENTERPRISE_ID_2) 990 .build(); 991 assertEquals(1, nc4.getEnterpriseIds().length); 992 assertTrue(nc4.hasEnterpriseId(NET_ENTERPRISE_ID_1)); 993 994 final NetworkCapabilities nc5 = new NetworkCapabilities.Builder() 995 .addCapability(NET_CAPABILITY_CBS) 996 .addEnterpriseId(NET_ENTERPRISE_ID_1) 997 .addEnterpriseId(NET_ENTERPRISE_ID_2) 998 .removeEnterpriseId(NET_ENTERPRISE_ID_1) 999 .removeEnterpriseId(NET_ENTERPRISE_ID_2) 1000 .build(); 1001 1002 assertTrue(nc4.satisfiedByNetworkCapabilities(nc1)); 1003 assertTrue(nc1.satisfiedByNetworkCapabilities(nc4)); 1004 1005 assertFalse(nc3.satisfiedByNetworkCapabilities(nc2)); 1006 assertTrue(nc2.satisfiedByNetworkCapabilities(nc3)); 1007 1008 assertFalse(nc1.satisfiedByNetworkCapabilities(nc5)); 1009 assertFalse(nc5.satisfiedByNetworkCapabilities(nc1)); 1010 } 1011 1012 @Test testWifiAwareNetworkSpecifier()1013 public void testWifiAwareNetworkSpecifier() { 1014 final NetworkCapabilities nc = new NetworkCapabilities() 1015 .addTransportType(TRANSPORT_WIFI_AWARE); 1016 // If NetworkSpecifier is not set, the default value is null. 1017 assertNull(nc.getNetworkSpecifier()); 1018 final WifiAwareNetworkSpecifier specifier = new WifiAwareNetworkSpecifier.Builder( 1019 mDiscoverySession, mPeerHandle).build(); 1020 nc.setNetworkSpecifier(specifier); 1021 assertEquals(specifier, nc.getNetworkSpecifier()); 1022 } 1023 1024 @Test testAdministratorUidsAndOwnerUid()1025 public void testAdministratorUidsAndOwnerUid() { 1026 // Test default owner uid. 1027 // If the owner uid is not set, the default value should be Process.INVALID_UID. 1028 final NetworkCapabilities nc1 = new NetworkCapabilities.Builder().build(); 1029 assertEquals(INVALID_UID, nc1.getOwnerUid()); 1030 // Test setAdministratorUids and getAdministratorUids. 1031 final int[] administratorUids = {1001, 10001}; 1032 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 1033 .setAdministratorUids(administratorUids) 1034 .build(); 1035 assertTrue(Arrays.equals(administratorUids, nc2.getAdministratorUids())); 1036 // Test setOwnerUid and getOwnerUid. 1037 // The owner UID must be included in administrator UIDs, or throw IllegalStateException. 1038 try { 1039 final NetworkCapabilities nc3 = new NetworkCapabilities.Builder() 1040 .setOwnerUid(1001) 1041 .build(); 1042 fail("The owner UID must be included in administrator UIDs."); 1043 } catch (IllegalStateException expected) { } 1044 final NetworkCapabilities nc4 = new NetworkCapabilities.Builder() 1045 .setAdministratorUids(administratorUids) 1046 .setOwnerUid(1001) 1047 .build(); 1048 assertEquals(1001, nc4.getOwnerUid()); 1049 try { 1050 final NetworkCapabilities nc5 = new NetworkCapabilities.Builder() 1051 .setAdministratorUids(null) 1052 .build(); 1053 fail("Should not set null into setAdministratorUids"); 1054 } catch (NullPointerException expected) { } 1055 } 1056 capsWithSubIds(Integer .... subIds)1057 private static NetworkCapabilities capsWithSubIds(Integer ... subIds) { 1058 // Since the NetworkRequest would put NOT_VCN_MANAGED capabilities in general, for 1059 // every NetworkCapabilities that simulates networks needs to add it too in order to 1060 // satisfy these requests. 1061 final NetworkCapabilities nc = new NetworkCapabilities.Builder() 1062 .addCapability(NET_CAPABILITY_NOT_VCN_MANAGED) 1063 .setSubscriptionIds(new ArraySet<>(subIds)).build(); 1064 assertEquals(new ArraySet<>(subIds), nc.getSubscriptionIds()); 1065 return nc; 1066 } 1067 1068 @Test testSubIds()1069 public void testSubIds() throws Exception { 1070 final NetworkCapabilities ncWithoutId = capsWithSubIds(); 1071 final NetworkCapabilities ncWithId = capsWithSubIds(TEST_SUBID1); 1072 final NetworkCapabilities ncWithOtherIds = capsWithSubIds(TEST_SUBID1, TEST_SUBID3); 1073 final NetworkCapabilities ncWithoutRequestedIds = capsWithSubIds(TEST_SUBID3); 1074 1075 final NetworkRequest requestWithoutId = new NetworkRequest.Builder().build(); 1076 assertEmpty(requestWithoutId.networkCapabilities.getSubscriptionIds()); 1077 final NetworkRequest requestWithIds = new NetworkRequest.Builder() 1078 .setSubscriptionIds(Set.of(TEST_SUBID1, TEST_SUBID2)).build(); 1079 assertEquals(Set.of(TEST_SUBID1, TEST_SUBID2), 1080 requestWithIds.networkCapabilities.getSubscriptionIds()); 1081 1082 assertFalse(requestWithIds.canBeSatisfiedBy(ncWithoutId)); 1083 assertTrue(requestWithIds.canBeSatisfiedBy(ncWithOtherIds)); 1084 assertFalse(requestWithIds.canBeSatisfiedBy(ncWithoutRequestedIds)); 1085 assertTrue(requestWithIds.canBeSatisfiedBy(ncWithId)); 1086 assertTrue(requestWithoutId.canBeSatisfiedBy(ncWithoutId)); 1087 assertTrue(requestWithoutId.canBeSatisfiedBy(ncWithId)); 1088 } 1089 1090 @Test testEqualsSubIds()1091 public void testEqualsSubIds() throws Exception { 1092 assertEquals(capsWithSubIds(), capsWithSubIds()); 1093 assertNotEquals(capsWithSubIds(), capsWithSubIds(TEST_SUBID1)); 1094 assertEquals(capsWithSubIds(TEST_SUBID1), capsWithSubIds(TEST_SUBID1)); 1095 assertNotEquals(capsWithSubIds(TEST_SUBID1), capsWithSubIds(TEST_SUBID2)); 1096 assertNotEquals(capsWithSubIds(TEST_SUBID1), capsWithSubIds(TEST_SUBID2, TEST_SUBID1)); 1097 assertEquals(capsWithSubIds(TEST_SUBID1, TEST_SUBID2), 1098 capsWithSubIds(TEST_SUBID2, TEST_SUBID1)); 1099 } 1100 1101 @Test testLinkBandwidthKbps()1102 public void testLinkBandwidthKbps() { 1103 final NetworkCapabilities nc = new NetworkCapabilities(); 1104 // The default value of LinkDown/UpstreamBandwidthKbps should be LINK_BANDWIDTH_UNSPECIFIED. 1105 assertEquals(LINK_BANDWIDTH_UNSPECIFIED, nc.getLinkDownstreamBandwidthKbps()); 1106 assertEquals(LINK_BANDWIDTH_UNSPECIFIED, nc.getLinkUpstreamBandwidthKbps()); 1107 nc.setLinkDownstreamBandwidthKbps(512); 1108 nc.setLinkUpstreamBandwidthKbps(128); 1109 assertEquals(512, nc.getLinkDownstreamBandwidthKbps()); 1110 assertNotEquals(128, nc.getLinkDownstreamBandwidthKbps()); 1111 assertEquals(128, nc.getLinkUpstreamBandwidthKbps()); 1112 assertNotEquals(512, nc.getLinkUpstreamBandwidthKbps()); 1113 } 1114 getMaxTransport()1115 private int getMaxTransport() { 1116 if (!isAtLeastS() && MAX_TRANSPORT == TRANSPORT_USB) return MAX_TRANSPORT - 1; 1117 return MAX_TRANSPORT; 1118 } 1119 1120 @Test testSignalStrength()1121 public void testSignalStrength() { 1122 final NetworkCapabilities nc = new NetworkCapabilities(); 1123 // The default value of signal strength should be SIGNAL_STRENGTH_UNSPECIFIED. 1124 assertEquals(SIGNAL_STRENGTH_UNSPECIFIED, nc.getSignalStrength()); 1125 nc.setSignalStrength(-80); 1126 assertEquals(-80, nc.getSignalStrength()); 1127 assertNotEquals(-50, nc.getSignalStrength()); 1128 } 1129 assertNoTransport(NetworkCapabilities nc)1130 private void assertNoTransport(NetworkCapabilities nc) { 1131 for (int i = MIN_TRANSPORT; i <= getMaxTransport(); i++) { 1132 assertFalse(nc.hasTransport(i)); 1133 } 1134 } 1135 1136 // Checks that all transport types from MIN_TRANSPORT to maxTransportType are set and all 1137 // transport types from maxTransportType + 1 to MAX_TRANSPORT are not set when positiveSequence 1138 // is true. If positiveSequence is false, then the check sequence is opposite. checkCurrentTransportTypes(NetworkCapabilities nc, int maxTransportType, boolean positiveSequence)1139 private void checkCurrentTransportTypes(NetworkCapabilities nc, int maxTransportType, 1140 boolean positiveSequence) { 1141 for (int i = MIN_TRANSPORT; i <= maxTransportType; i++) { 1142 if (positiveSequence) { 1143 assertTrue(nc.hasTransport(i)); 1144 } else { 1145 assertFalse(nc.hasTransport(i)); 1146 } 1147 } 1148 for (int i = getMaxTransport(); i > maxTransportType; i--) { 1149 if (positiveSequence) { 1150 assertFalse(nc.hasTransport(i)); 1151 } else { 1152 assertTrue(nc.hasTransport(i)); 1153 } 1154 } 1155 } 1156 1157 @Test testMultipleTransportTypes()1158 public void testMultipleTransportTypes() { 1159 final NetworkCapabilities nc = new NetworkCapabilities(); 1160 assertNoTransport(nc); 1161 // Test adding multiple transport types. 1162 for (int i = MIN_TRANSPORT; i <= getMaxTransport(); i++) { 1163 nc.addTransportType(i); 1164 checkCurrentTransportTypes(nc, i, true /* positiveSequence */); 1165 } 1166 // Test removing multiple transport types. 1167 for (int i = MIN_TRANSPORT; i <= getMaxTransport(); i++) { 1168 nc.removeTransportType(i); 1169 checkCurrentTransportTypes(nc, i, false /* positiveSequence */); 1170 } 1171 assertNoTransport(nc); 1172 nc.addTransportType(TRANSPORT_WIFI); 1173 assertTrue(nc.hasTransport(TRANSPORT_WIFI)); 1174 assertFalse(nc.hasTransport(TRANSPORT_VPN)); 1175 nc.addTransportType(TRANSPORT_VPN); 1176 assertTrue(nc.hasTransport(TRANSPORT_WIFI)); 1177 assertTrue(nc.hasTransport(TRANSPORT_VPN)); 1178 nc.removeTransportType(TRANSPORT_WIFI); 1179 assertFalse(nc.hasTransport(TRANSPORT_WIFI)); 1180 assertTrue(nc.hasTransport(TRANSPORT_VPN)); 1181 nc.removeTransportType(TRANSPORT_VPN); 1182 assertFalse(nc.hasTransport(TRANSPORT_WIFI)); 1183 assertFalse(nc.hasTransport(TRANSPORT_VPN)); 1184 assertNoTransport(nc); 1185 } 1186 1187 @Test testAddAndRemoveTransportType()1188 public void testAddAndRemoveTransportType() { 1189 final NetworkCapabilities nc = new NetworkCapabilities(); 1190 try { 1191 nc.addTransportType(-1); 1192 fail("Should not set invalid transport type into addTransportType"); 1193 } catch (IllegalArgumentException expected) { } 1194 try { 1195 nc.removeTransportType(-1); 1196 fail("Should not set invalid transport type into removeTransportType"); 1197 } catch (IllegalArgumentException e) { } 1198 } 1199 1200 /** 1201 * Test TransportInfo to verify redaction mechanism. 1202 */ 1203 private static class TestTransportInfo implements TransportInfo { 1204 public final boolean locationRedacted; 1205 public final boolean localMacAddressRedacted; 1206 public final boolean settingsRedacted; 1207 TestTransportInfo()1208 TestTransportInfo() { 1209 locationRedacted = false; 1210 localMacAddressRedacted = false; 1211 settingsRedacted = false; 1212 } 1213 TestTransportInfo(boolean locationRedacted, boolean localMacAddressRedacted, boolean settingsRedacted)1214 TestTransportInfo(boolean locationRedacted, 1215 boolean localMacAddressRedacted, 1216 boolean settingsRedacted) { 1217 this.locationRedacted = locationRedacted; 1218 this.localMacAddressRedacted = 1219 localMacAddressRedacted; 1220 this.settingsRedacted = settingsRedacted; 1221 } 1222 1223 @Override makeCopy(@etworkCapabilities.RedactionType long redactions)1224 public TransportInfo makeCopy(@NetworkCapabilities.RedactionType long redactions) { 1225 return new TestTransportInfo( 1226 (redactions & NetworkCapabilities.REDACT_FOR_ACCESS_FINE_LOCATION) != 0, 1227 (redactions & REDACT_FOR_LOCAL_MAC_ADDRESS) != 0, 1228 (redactions & REDACT_FOR_NETWORK_SETTINGS) != 0 1229 ); 1230 } 1231 1232 @Override getApplicableRedactions()1233 public @NetworkCapabilities.RedactionType long getApplicableRedactions() { 1234 return REDACT_FOR_ACCESS_FINE_LOCATION | REDACT_FOR_LOCAL_MAC_ADDRESS 1235 | REDACT_FOR_NETWORK_SETTINGS; 1236 } 1237 } 1238 1239 @Test testBuilder()1240 public void testBuilder() { 1241 final int ownerUid = 1001; 1242 final int signalStrength = -80; 1243 final int requestUid = 10100; 1244 final int[] administratorUids = {ownerUid, 10001}; 1245 final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(1); 1246 final TransportInfo transportInfo = new TransportInfo() {}; 1247 final String ssid = "TEST_SSID"; 1248 final String packageName = "com.google.test.networkcapabilities"; 1249 final NetworkCapabilities.Builder capBuilder = new NetworkCapabilities.Builder() 1250 .addTransportType(TRANSPORT_WIFI) 1251 .addTransportType(TRANSPORT_CELLULAR) 1252 .removeTransportType(TRANSPORT_CELLULAR) 1253 .addCapability(NET_CAPABILITY_EIMS) 1254 .addCapability(NET_CAPABILITY_CBS) 1255 .removeCapability(NET_CAPABILITY_CBS) 1256 .setAdministratorUids(administratorUids) 1257 .setOwnerUid(ownerUid) 1258 .setLinkDownstreamBandwidthKbps(512) 1259 .setLinkUpstreamBandwidthKbps(128) 1260 .setNetworkSpecifier(specifier) 1261 .setTransportInfo(transportInfo) 1262 .setSignalStrength(signalStrength) 1263 .setSsid(ssid) 1264 .setRequestorUid(requestUid) 1265 .setRequestorPackageName(packageName); 1266 final Network network1 = new Network(100); 1267 final Network network2 = new Network(101); 1268 final List<Network> inputNetworks = List.of(network1, network2); 1269 if (isAtLeastT()) { 1270 capBuilder.setUnderlyingNetworks(inputNetworks); 1271 } 1272 final NetworkCapabilities nc = capBuilder.build(); 1273 assertEquals(1, nc.getTransportTypes().length); 1274 assertEquals(TRANSPORT_WIFI, nc.getTransportTypes()[0]); 1275 assertTrue(nc.hasCapability(NET_CAPABILITY_EIMS)); 1276 assertFalse(nc.hasCapability(NET_CAPABILITY_CBS)); 1277 assertTrue(Arrays.equals(administratorUids, nc.getAdministratorUids())); 1278 assertEquals(ownerUid, nc.getOwnerUid()); 1279 assertEquals(512, nc.getLinkDownstreamBandwidthKbps()); 1280 assertNotEquals(128, nc.getLinkDownstreamBandwidthKbps()); 1281 assertEquals(128, nc.getLinkUpstreamBandwidthKbps()); 1282 assertNotEquals(512, nc.getLinkUpstreamBandwidthKbps()); 1283 assertEquals(specifier, nc.getNetworkSpecifier()); 1284 assertEquals(transportInfo, nc.getTransportInfo()); 1285 assertEquals(signalStrength, nc.getSignalStrength()); 1286 assertNotEquals(-50, nc.getSignalStrength()); 1287 assertEquals(ssid, nc.getSsid()); 1288 assertEquals(requestUid, nc.getRequestorUid()); 1289 assertEquals(packageName, nc.getRequestorPackageName()); 1290 if (isAtLeastT()) { 1291 final List<Network> outputNetworks = nc.getUnderlyingNetworks(); 1292 assertEquals(network1, outputNetworks.get(0)); 1293 assertEquals(network2, outputNetworks.get(1)); 1294 } 1295 // Cannot assign null into NetworkCapabilities.Builder 1296 try { 1297 final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder(null); 1298 fail("Should not set null into NetworkCapabilities.Builder"); 1299 } catch (NullPointerException expected) { } 1300 assertEquals(nc, new NetworkCapabilities.Builder(nc).build()); 1301 1302 if (isAtLeastS()) { 1303 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 1304 .setSubscriptionIds(Set.of(TEST_SUBID1)).build(); 1305 assertEquals(Set.of(TEST_SUBID1), nc2.getSubscriptionIds()); 1306 } 1307 } 1308 1309 @Test testBuilderWithoutDefaultCap()1310 public void testBuilderWithoutDefaultCap() { 1311 final NetworkCapabilities nc = 1312 NetworkCapabilities.Builder.withoutDefaultCapabilities().build(); 1313 assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED)); 1314 assertFalse(nc.hasCapability(NET_CAPABILITY_TRUSTED)); 1315 assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_VPN)); 1316 // Ensure test case fails if new net cap is added into default cap but no update here. 1317 assertEquals(0, nc.getCapabilities().length); 1318 } 1319 1320 @Test testRestrictCapabilitiesForTestNetworkByNotOwnerWithNonRestrictedNc()1321 public void testRestrictCapabilitiesForTestNetworkByNotOwnerWithNonRestrictedNc() { 1322 testRestrictCapabilitiesForTestNetworkWithNonRestrictedNc(false /* isOwner */); 1323 } 1324 1325 @Test testRestrictCapabilitiesForTestNetworkByOwnerWithNonRestrictedNc()1326 public void testRestrictCapabilitiesForTestNetworkByOwnerWithNonRestrictedNc() { 1327 testRestrictCapabilitiesForTestNetworkWithNonRestrictedNc(true /* isOwner */); 1328 } 1329 testRestrictCapabilitiesForTestNetworkWithNonRestrictedNc(boolean isOwner)1330 private void testRestrictCapabilitiesForTestNetworkWithNonRestrictedNc(boolean isOwner) { 1331 final int ownerUid = 1234; 1332 final int signalStrength = -80; 1333 final int[] administratorUids = {1001, ownerUid}; 1334 final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(TEST_SUBID1); 1335 final TransportInfo transportInfo = new TransportInfo() {}; 1336 final NetworkCapabilities nonRestrictedNc = new NetworkCapabilities.Builder() 1337 .addTransportType(TRANSPORT_CELLULAR) 1338 .addCapability(NET_CAPABILITY_MMS) 1339 .addCapability(NET_CAPABILITY_NOT_METERED) 1340 .setAdministratorUids(administratorUids) 1341 .setOwnerUid(ownerUid) 1342 .setNetworkSpecifier(specifier) 1343 .setSignalStrength(signalStrength) 1344 .setTransportInfo(transportInfo) 1345 .setSubscriptionIds(Set.of(TEST_SUBID1)).build(); 1346 final int creatorUid = isOwner ? ownerUid : INVALID_UID; 1347 nonRestrictedNc.restrictCapabilitiesForTestNetwork(creatorUid); 1348 1349 final NetworkCapabilities.Builder expectedNcBuilder = new NetworkCapabilities.Builder(); 1350 // Non-UNRESTRICTED_TEST_NETWORKS_ALLOWED_TRANSPORTS will be removed and TRANSPORT_TEST will 1351 // be appended for non-restricted net cap. 1352 expectedNcBuilder.addTransportType(TRANSPORT_TEST); 1353 // Only TEST_NETWORKS_ALLOWED_CAPABILITIES will be kept. SubIds are only allowed for Test 1354 // Networks that only declare TRANSPORT_TEST. 1355 expectedNcBuilder.addCapability(NET_CAPABILITY_NOT_METERED) 1356 .removeCapability(NET_CAPABILITY_TRUSTED) 1357 .setSubscriptionIds(Set.of(TEST_SUBID1)); 1358 1359 expectedNcBuilder.setNetworkSpecifier(specifier) 1360 .setSignalStrength(signalStrength).setTransportInfo(transportInfo); 1361 if (creatorUid == ownerUid) { 1362 // Only retain the owner and administrator UIDs if they match the app registering the 1363 // remote caller that registered the network. 1364 expectedNcBuilder.setAdministratorUids(new int[]{ownerUid}).setOwnerUid(ownerUid); 1365 } 1366 1367 assertEquals(expectedNcBuilder.build(), nonRestrictedNc); 1368 } 1369 1370 @Test testRestrictCapabilitiesForTestNetworkRestrictedNc_NotOwner_NotCell()1371 public void testRestrictCapabilitiesForTestNetworkRestrictedNc_NotOwner_NotCell() { 1372 testRestrictCapabilitiesForTestNetworkWithRestrictedNc( 1373 false /* isOwner */, false /* isCell */); 1374 } 1375 1376 @Test testRestrictCapabilitiesForTestNetworkRestrictedNc_Owner_NotCell()1377 public void testRestrictCapabilitiesForTestNetworkRestrictedNc_Owner_NotCell() { 1378 testRestrictCapabilitiesForTestNetworkWithRestrictedNc( 1379 true /* isOwner */, false /* isCell */); 1380 } 1381 1382 @Test testRestrictCapabilitiesForTestNetworkRestrictedNc_NotOwner_Cell()1383 public void testRestrictCapabilitiesForTestNetworkRestrictedNc_NotOwner_Cell() { 1384 testRestrictCapabilitiesForTestNetworkWithRestrictedNc( 1385 false /* isOwner */, true /* isCell */); 1386 } 1387 1388 @Test testRestrictCapabilitiesForTestNetworkRestrictedNc_Owner_Cell()1389 public void testRestrictCapabilitiesForTestNetworkRestrictedNc_Owner_Cell() { 1390 testRestrictCapabilitiesForTestNetworkWithRestrictedNc( 1391 true /* isOwner */, false /* isCell */); 1392 } 1393 testRestrictCapabilitiesForTestNetworkWithRestrictedNc( boolean isOwner, boolean isCell)1394 private void testRestrictCapabilitiesForTestNetworkWithRestrictedNc( 1395 boolean isOwner, boolean isCell) { 1396 final int ownerUid = 1234; 1397 final int signalStrength = -80; 1398 final int[] administratorUids = {1001, ownerUid}; 1399 final TransportInfo transportInfo = new TransportInfo() {}; 1400 // No NetworkSpecifier is set because after performing restrictCapabilitiesForTestNetwork 1401 // the networkCapabilities will contain more than one transport type. However, 1402 // networkCapabilities must have a single transport specified to use NetworkSpecifier. Thus, 1403 // do not verify this part since it's verified in other tests. 1404 final NetworkCapabilities.Builder restrictedNcBuilder = new NetworkCapabilities.Builder() 1405 .removeCapability(NET_CAPABILITY_NOT_RESTRICTED) 1406 .addCapability(NET_CAPABILITY_MMS) 1407 .addCapability(NET_CAPABILITY_NOT_METERED) 1408 .setAdministratorUids(administratorUids) 1409 .setOwnerUid(ownerUid) 1410 .setSignalStrength(signalStrength) 1411 .setTransportInfo(transportInfo) 1412 .setSubscriptionIds(Set.of(TEST_SUBID1)); 1413 for (int cap : TEST_NETWORKS_EXTRA_ALLOWED_CAPS_ON_NON_CELL) { 1414 restrictedNcBuilder.addCapability(cap); 1415 } 1416 1417 if (isCell) { 1418 restrictedNcBuilder.addTransportType(TRANSPORT_CELLULAR); 1419 } 1420 final NetworkCapabilities restrictedNc = restrictedNcBuilder.build(); 1421 1422 final int creatorUid = isOwner ? ownerUid : INVALID_UID; 1423 restrictedNc.restrictCapabilitiesForTestNetwork(creatorUid); 1424 1425 final NetworkCapabilities.Builder expectedNcBuilder = new NetworkCapabilities.Builder() 1426 .removeCapability(NET_CAPABILITY_NOT_RESTRICTED); 1427 1428 if (isCell) { 1429 // If the test network is restricted, then the network may declare any transport, and 1430 // appended with TRANSPORT_TEST. 1431 expectedNcBuilder.addTransportType(TRANSPORT_CELLULAR); 1432 } else { 1433 // If the test network only has TRANSPORT_TEST, then it can keep the subscription IDs. 1434 expectedNcBuilder.setSubscriptionIds(Set.of(TEST_SUBID1)); 1435 } 1436 expectedNcBuilder.addTransportType(TRANSPORT_TEST); 1437 1438 // Only TEST_NETWORKS_ALLOWED_CAPABILITIES will be kept. 1439 expectedNcBuilder.addCapability(NET_CAPABILITY_NOT_METERED); 1440 expectedNcBuilder.removeCapability(NET_CAPABILITY_TRUSTED); 1441 1442 if (!isCell) { 1443 for (int cap : TEST_NETWORKS_EXTRA_ALLOWED_CAPS_ON_NON_CELL) { 1444 expectedNcBuilder.addCapability(cap); 1445 } 1446 } 1447 1448 expectedNcBuilder.setSignalStrength(signalStrength).setTransportInfo(transportInfo); 1449 if (creatorUid == ownerUid) { 1450 // Only retain the owner and administrator UIDs if they match the app registering the 1451 // remote caller that registered the network. 1452 expectedNcBuilder.setAdministratorUids(new int[]{ownerUid}).setOwnerUid(ownerUid); 1453 } 1454 1455 assertEquals(expectedNcBuilder.build(), restrictedNc); 1456 } 1457 1458 @Test testDescribeCapsDifferences()1459 public void testDescribeCapsDifferences() throws Exception { 1460 final NetworkCapabilities nc1 = new NetworkCapabilities.Builder() 1461 .addCapability(NET_CAPABILITY_MMS) 1462 .addCapability(NET_CAPABILITY_OEM_PAID) 1463 .addCapability(NET_CAPABILITY_INTERNET) 1464 .build(); 1465 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 1466 .addCapability(NET_CAPABILITY_CAPTIVE_PORTAL) 1467 .addCapability(NET_CAPABILITY_SUPL) 1468 .addCapability(NET_CAPABILITY_VALIDATED) 1469 .addCapability(NET_CAPABILITY_INTERNET) 1470 .build(); 1471 assertEquals("-MMS-OEM_PAID+SUPL+VALIDATED+CAPTIVE_PORTAL", 1472 nc2.describeCapsDifferencesFrom(nc1)); 1473 assertEquals("-SUPL-VALIDATED-CAPTIVE_PORTAL+MMS+OEM_PAID", 1474 nc1.describeCapsDifferencesFrom(nc2)); 1475 } 1476 1477 @Test testInvalidCapability()1478 public void testInvalidCapability() { 1479 final int invalidCapability = Integer.MAX_VALUE; 1480 // Passing invalid capability does not throw 1481 final NetworkCapabilities nc1 = new NetworkCapabilities.Builder() 1482 .addCapability(NET_CAPABILITY_INTERNET) 1483 .addForbiddenCapability(NET_CAPABILITY_NOT_ROAMING) 1484 .removeCapability(invalidCapability) 1485 .removeForbiddenCapability(invalidCapability) 1486 .addCapability(invalidCapability) 1487 .addForbiddenCapability(invalidCapability) 1488 .build(); 1489 1490 final NetworkCapabilities nc2 = new NetworkCapabilities.Builder() 1491 .addCapability(NET_CAPABILITY_INTERNET) 1492 .addForbiddenCapability(NET_CAPABILITY_NOT_ROAMING) 1493 .build(); 1494 1495 // nc1 and nc2 are the same since invalid capability is ignored 1496 assertEquals(nc1, nc2); 1497 } 1498 1499 @Test testReservationIdMatching()1500 public void testReservationIdMatching() { 1501 final NetworkCapabilities requestNc = new NetworkCapabilities(); 1502 final NetworkCapabilities reservationNc = new NetworkCapabilities(); 1503 reservationNc.setReservationId(42); 1504 1505 final NetworkCapabilities reservedNetworkNc = new NetworkCapabilities(reservationNc); 1506 final NetworkCapabilities otherNetworkNc = new NetworkCapabilities(); 1507 final NetworkCapabilities otherReservedNetworkNc = new NetworkCapabilities(); 1508 otherReservedNetworkNc.setReservationId(99); 1509 final NetworkCapabilities offerNc = new NetworkCapabilities(); 1510 offerNc.setReservationId(NetworkCapabilities.RES_ID_MATCH_ALL_RESERVATIONS); 1511 1512 // A regular request can match any network or offer except one with MATCH_ALL_RESERVATIONS 1513 assertTrue(requestNc.satisfiedByNetworkCapabilities(reservedNetworkNc)); 1514 assertTrue(requestNc.satisfiedByNetworkCapabilities(otherNetworkNc)); 1515 assertTrue(requestNc.satisfiedByNetworkCapabilities(otherReservedNetworkNc)); 1516 assertFalse(requestNc.satisfiedByNetworkCapabilities(offerNc)); 1517 1518 // A reservation request can only match the reservedNetwork and the blanket offer. 1519 assertTrue(reservationNc.satisfiedByNetworkCapabilities(reservedNetworkNc)); 1520 assertFalse(reservationNc.satisfiedByNetworkCapabilities(otherNetworkNc)); 1521 assertFalse(reservationNc.satisfiedByNetworkCapabilities(otherReservedNetworkNc)); 1522 assertTrue(reservationNc.satisfiedByNetworkCapabilities(offerNc)); 1523 } 1524 1525 @Test @IgnoreUpTo(SC_V2) testReservationIdEquals()1526 public void testReservationIdEquals() { 1527 final NetworkCapabilities nc = new NetworkCapabilities(); 1528 nc.setReservationId(42); 1529 final NetworkCapabilities other = new NetworkCapabilities(nc); 1530 1531 assertEquals(nc, other); 1532 1533 nc.setReservationId(43); 1534 assertNotEquals(nc, other); 1535 } 1536 1537 @Test testMatchNonThreadLocalNetworks_equals()1538 public void testMatchNonThreadLocalNetworks_equals() { 1539 final NetworkCapabilities nc = new NetworkCapabilities(); 1540 nc.setMatchNonThreadLocalNetworks(true); 1541 final NetworkCapabilities other = new NetworkCapabilities(nc); 1542 assertEquals(nc, other); 1543 1544 nc.setMatchNonThreadLocalNetworks(false); 1545 assertNotEquals(nc, other); 1546 } 1547 1548 @Test testMatchNonThreadLocalNetworks_enabled()1549 public void testMatchNonThreadLocalNetworks_enabled() { 1550 doTestMatchNonThreadLocalNetworks(true); 1551 } 1552 1553 @Test testMatchNonThreadLocalNetworks_disabled()1554 public void testMatchNonThreadLocalNetworks_disabled() { 1555 doTestMatchNonThreadLocalNetworks(false); 1556 } 1557 doTestMatchNonThreadLocalNetworks(boolean enabled)1558 private void doTestMatchNonThreadLocalNetworks(boolean enabled) { 1559 // Setup request NCs. 1560 final NetworkCapabilities noTransportRequestNc = new NetworkCapabilities(); 1561 final NetworkCapabilities threadRequestNc = 1562 new NetworkCapabilities.Builder().addTransportType(TRANSPORT_THREAD).build(); 1563 final NetworkCapabilities wifiRequestNc = 1564 new NetworkCapabilities.Builder().addTransportType(TRANSPORT_WIFI).build(); 1565 final NetworkCapabilities multiTransportRequestNc = 1566 new NetworkCapabilities.Builder().addTransportType( 1567 TRANSPORT_THREAD).addTransportType(TRANSPORT_WIFI).build(); 1568 1569 // Setup network NCs. 1570 final NetworkCapabilities localNoTransportNc = new NetworkCapabilities.Builder() 1571 .addCapability(NET_CAPABILITY_LOCAL_NETWORK).build(); 1572 final NetworkCapabilities localThreadsNc = new NetworkCapabilities.Builder() 1573 .addCapability(NET_CAPABILITY_LOCAL_NETWORK) 1574 .addTransportType(TRANSPORT_THREAD).build(); 1575 final NetworkCapabilities localWifiNc = new NetworkCapabilities.Builder() 1576 .addCapability(NET_CAPABILITY_LOCAL_NETWORK) 1577 .addTransportType(TRANSPORT_WIFI).build(); 1578 final NetworkCapabilities wanWifiNc = new NetworkCapabilities.Builder() 1579 .addTransportType(TRANSPORT_WIFI).build(); 1580 1581 // Mark flags accordingly. 1582 noTransportRequestNc.setMatchNonThreadLocalNetworks(enabled); 1583 threadRequestNc.setMatchNonThreadLocalNetworks(enabled); 1584 wifiRequestNc.setMatchNonThreadLocalNetworks(enabled); 1585 multiTransportRequestNc.setMatchNonThreadLocalNetworks(enabled); 1586 1587 if (enabled) { 1588 // A request with no specific transport matches all networks. 1589 assertTrue(noTransportRequestNc.satisfiedByNetworkCapabilities(localNoTransportNc)); 1590 assertTrue(noTransportRequestNc.satisfiedByNetworkCapabilities(localWifiNc)); 1591 } else { 1592 // A request with no specific transport only matches thread networks. 1593 assertFalse(noTransportRequestNc.satisfiedByNetworkCapabilities(localNoTransportNc)); 1594 assertFalse(noTransportRequestNc.satisfiedByNetworkCapabilities(localWifiNc)); 1595 } 1596 assertTrue(noTransportRequestNc.satisfiedByNetworkCapabilities(localThreadsNc)); 1597 assertTrue(noTransportRequestNc.satisfiedByNetworkCapabilities(wanWifiNc)); 1598 1599 // A request with TRANSPORT_THREAD only matches thread networks. 1600 assertFalse(threadRequestNc.satisfiedByNetworkCapabilities(localNoTransportNc)); 1601 assertTrue(threadRequestNc.satisfiedByNetworkCapabilities(localThreadsNc)); 1602 assertFalse(threadRequestNc.satisfiedByNetworkCapabilities(localWifiNc)); 1603 assertFalse(threadRequestNc.satisfiedByNetworkCapabilities(wanWifiNc)); 1604 1605 assertFalse(multiTransportRequestNc.satisfiedByNetworkCapabilities(localNoTransportNc)); 1606 assertTrue(multiTransportRequestNc.satisfiedByNetworkCapabilities(localThreadsNc)); 1607 assertTrue(multiTransportRequestNc.satisfiedByNetworkCapabilities(wanWifiNc)); 1608 if (enabled) { 1609 assertTrue(multiTransportRequestNc.satisfiedByNetworkCapabilities(localWifiNc)); 1610 } else { 1611 // A request with multiple transports only matches thread networks. 1612 assertFalse(multiTransportRequestNc.satisfiedByNetworkCapabilities(localWifiNc)); 1613 } 1614 1615 assertFalse(wifiRequestNc.satisfiedByNetworkCapabilities(localNoTransportNc)); 1616 assertFalse(wifiRequestNc.satisfiedByNetworkCapabilities(localThreadsNc)); 1617 assertTrue(wifiRequestNc.satisfiedByNetworkCapabilities(wanWifiNc)); 1618 if (enabled) { 1619 assertTrue(wifiRequestNc.satisfiedByNetworkCapabilities(localWifiNc)); 1620 } else { 1621 // A request without TRANSPORT_THREAD matches nothing. 1622 assertFalse(wifiRequestNc.satisfiedByNetworkCapabilities(localWifiNc)); 1623 } 1624 } 1625 } 1626