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