d1d8b627dd
P introduced setSSID, UIDs and unwanted capabilities. None of these exhibit commutative behavior through combineCapabilities because their semantics don't allow it. Therefore NetworkRequest.setCapabilities() is badly broken around any of these. Look at the comments in the new tests to realize the extent of the damage. Clean cherry-pick of ag/4083952 Bug: 79748782 Test: new tests written, old tests pass Change-Id: Iafe074126132a82af37f4bf056c4a7b8d56bdc83 Merged-In: Ia5bebf8a233775367bbf1b788870528934ecbcfb Merged-In: I13d7782a6c0c7b1f94137995bbb0d257a58d89c1
506 lines
22 KiB
Java
506 lines
22 KiB
Java
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.net;
|
|
|
|
import static android.net.NetworkCapabilities.LINK_BANDWIDTH_UNSPECIFIED;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_CBS;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_EIMS;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_MMS;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_METERED;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_OEM_PAID;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VPN;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED;
|
|
import static android.net.NetworkCapabilities.NET_CAPABILITY_WIFI_P2P;
|
|
import static android.net.NetworkCapabilities.RESTRICTED_CAPABILITIES;
|
|
import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
|
|
import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
|
|
import static android.net.NetworkCapabilities.UNRESTRICTED_CAPABILITIES;
|
|
|
|
import static org.junit.Assert.assertArrayEquals;
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertNotEquals;
|
|
import static org.junit.Assert.assertTrue;
|
|
import static org.junit.Assert.fail;
|
|
|
|
import android.os.Parcel;
|
|
import android.support.test.runner.AndroidJUnit4;
|
|
import android.test.suitebuilder.annotation.SmallTest;
|
|
import android.util.ArraySet;
|
|
|
|
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
|
|
import java.util.Set;
|
|
|
|
@RunWith(AndroidJUnit4.class)
|
|
@SmallTest
|
|
public class NetworkCapabilitiesTest {
|
|
private static final String TEST_SSID = "TEST_SSID";
|
|
private static final String DIFFERENT_TEST_SSID = "DIFFERENT_TEST_SSID";
|
|
|
|
@Test
|
|
public void testMaybeMarkCapabilitiesRestricted() {
|
|
// verify EIMS is restricted
|
|
assertEquals((1 << NET_CAPABILITY_EIMS) & RESTRICTED_CAPABILITIES,
|
|
(1 << NET_CAPABILITY_EIMS));
|
|
|
|
// verify CBS is also restricted
|
|
assertEquals((1 << NET_CAPABILITY_CBS) & RESTRICTED_CAPABILITIES,
|
|
(1 << NET_CAPABILITY_CBS));
|
|
|
|
// verify default is not restricted
|
|
assertEquals((1 << NET_CAPABILITY_INTERNET) & RESTRICTED_CAPABILITIES, 0);
|
|
|
|
// just to see
|
|
assertEquals(RESTRICTED_CAPABILITIES & UNRESTRICTED_CAPABILITIES, 0);
|
|
|
|
// check that internet does not get restricted
|
|
NetworkCapabilities netCap = new NetworkCapabilities();
|
|
netCap.addCapability(NET_CAPABILITY_INTERNET);
|
|
netCap.maybeMarkCapabilitiesRestricted();
|
|
assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
|
|
// metered-ness shouldn't matter
|
|
netCap = new NetworkCapabilities();
|
|
netCap.addCapability(NET_CAPABILITY_INTERNET);
|
|
netCap.addCapability(NET_CAPABILITY_NOT_METERED);
|
|
netCap.maybeMarkCapabilitiesRestricted();
|
|
assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
netCap = new NetworkCapabilities();
|
|
netCap.addCapability(NET_CAPABILITY_INTERNET);
|
|
netCap.removeCapability(NET_CAPABILITY_NOT_METERED);
|
|
netCap.maybeMarkCapabilitiesRestricted();
|
|
assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
|
|
// add EIMS - bundled with unrestricted means it's unrestricted
|
|
netCap = new NetworkCapabilities();
|
|
netCap.addCapability(NET_CAPABILITY_INTERNET);
|
|
netCap.addCapability(NET_CAPABILITY_EIMS);
|
|
netCap.addCapability(NET_CAPABILITY_NOT_METERED);
|
|
netCap.maybeMarkCapabilitiesRestricted();
|
|
assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
netCap = new NetworkCapabilities();
|
|
netCap.addCapability(NET_CAPABILITY_INTERNET);
|
|
netCap.addCapability(NET_CAPABILITY_EIMS);
|
|
netCap.removeCapability(NET_CAPABILITY_NOT_METERED);
|
|
netCap.maybeMarkCapabilitiesRestricted();
|
|
assertTrue(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
|
|
// just a restricted cap should be restricted regardless of meteredness
|
|
netCap = new NetworkCapabilities();
|
|
netCap.addCapability(NET_CAPABILITY_EIMS);
|
|
netCap.addCapability(NET_CAPABILITY_NOT_METERED);
|
|
netCap.maybeMarkCapabilitiesRestricted();
|
|
assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
netCap = new NetworkCapabilities();
|
|
netCap.addCapability(NET_CAPABILITY_EIMS);
|
|
netCap.removeCapability(NET_CAPABILITY_NOT_METERED);
|
|
netCap.maybeMarkCapabilitiesRestricted();
|
|
assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
|
|
// try 2 restricted caps
|
|
netCap = new NetworkCapabilities();
|
|
netCap.addCapability(NET_CAPABILITY_CBS);
|
|
netCap.addCapability(NET_CAPABILITY_EIMS);
|
|
netCap.addCapability(NET_CAPABILITY_NOT_METERED);
|
|
netCap.maybeMarkCapabilitiesRestricted();
|
|
assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
netCap = new NetworkCapabilities();
|
|
netCap.addCapability(NET_CAPABILITY_CBS);
|
|
netCap.addCapability(NET_CAPABILITY_EIMS);
|
|
netCap.removeCapability(NET_CAPABILITY_NOT_METERED);
|
|
netCap.maybeMarkCapabilitiesRestricted();
|
|
assertFalse(netCap.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
}
|
|
|
|
@Test
|
|
public void testDescribeImmutableDifferences() {
|
|
NetworkCapabilities nc1;
|
|
NetworkCapabilities nc2;
|
|
|
|
// Transports changing
|
|
nc1 = new NetworkCapabilities().addTransportType(TRANSPORT_CELLULAR);
|
|
nc2 = new NetworkCapabilities().addTransportType(TRANSPORT_WIFI);
|
|
assertNotEquals("", nc1.describeImmutableDifferences(nc2));
|
|
assertEquals("", nc1.describeImmutableDifferences(nc1));
|
|
|
|
// Mutable capability changing
|
|
nc1 = new NetworkCapabilities().addCapability(NET_CAPABILITY_VALIDATED);
|
|
nc2 = new NetworkCapabilities();
|
|
assertEquals("", nc1.describeImmutableDifferences(nc2));
|
|
assertEquals("", nc1.describeImmutableDifferences(nc1));
|
|
|
|
// NOT_METERED changing (http://b/63326103)
|
|
nc1 = new NetworkCapabilities()
|
|
.addCapability(NET_CAPABILITY_NOT_METERED)
|
|
.addCapability(NET_CAPABILITY_INTERNET);
|
|
nc2 = new NetworkCapabilities().addCapability(NET_CAPABILITY_INTERNET);
|
|
assertEquals("", nc1.describeImmutableDifferences(nc2));
|
|
assertEquals("", nc1.describeImmutableDifferences(nc1));
|
|
|
|
// Immutable capability changing
|
|
nc1 = new NetworkCapabilities()
|
|
.addCapability(NET_CAPABILITY_INTERNET)
|
|
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
|
|
nc2 = new NetworkCapabilities().addCapability(NET_CAPABILITY_INTERNET);
|
|
assertNotEquals("", nc1.describeImmutableDifferences(nc2));
|
|
assertEquals("", nc1.describeImmutableDifferences(nc1));
|
|
|
|
// Specifier changing
|
|
nc1 = new NetworkCapabilities().addTransportType(TRANSPORT_WIFI);
|
|
nc2 = new NetworkCapabilities()
|
|
.addTransportType(TRANSPORT_WIFI)
|
|
.setNetworkSpecifier(new StringNetworkSpecifier("specs"));
|
|
assertNotEquals("", nc1.describeImmutableDifferences(nc2));
|
|
assertEquals("", nc1.describeImmutableDifferences(nc1));
|
|
}
|
|
|
|
@Test
|
|
public void testLinkBandwidthUtils() {
|
|
assertEquals(LINK_BANDWIDTH_UNSPECIFIED, NetworkCapabilities
|
|
.minBandwidth(LINK_BANDWIDTH_UNSPECIFIED, LINK_BANDWIDTH_UNSPECIFIED));
|
|
assertEquals(10, NetworkCapabilities
|
|
.minBandwidth(LINK_BANDWIDTH_UNSPECIFIED, 10));
|
|
assertEquals(10, NetworkCapabilities
|
|
.minBandwidth(10, LINK_BANDWIDTH_UNSPECIFIED));
|
|
assertEquals(10, NetworkCapabilities
|
|
.minBandwidth(10, 20));
|
|
|
|
assertEquals(LINK_BANDWIDTH_UNSPECIFIED, NetworkCapabilities
|
|
.maxBandwidth(LINK_BANDWIDTH_UNSPECIFIED, LINK_BANDWIDTH_UNSPECIFIED));
|
|
assertEquals(10, NetworkCapabilities
|
|
.maxBandwidth(LINK_BANDWIDTH_UNSPECIFIED, 10));
|
|
assertEquals(10, NetworkCapabilities
|
|
.maxBandwidth(10, LINK_BANDWIDTH_UNSPECIFIED));
|
|
assertEquals(20, NetworkCapabilities
|
|
.maxBandwidth(10, 20));
|
|
}
|
|
|
|
@Test
|
|
public void testSetUids() {
|
|
final NetworkCapabilities netCap = new NetworkCapabilities();
|
|
final Set<UidRange> uids = new ArraySet<>();
|
|
uids.add(new UidRange(50, 100));
|
|
uids.add(new UidRange(3000, 4000));
|
|
netCap.setUids(uids);
|
|
assertTrue(netCap.appliesToUid(50));
|
|
assertTrue(netCap.appliesToUid(80));
|
|
assertTrue(netCap.appliesToUid(100));
|
|
assertTrue(netCap.appliesToUid(3000));
|
|
assertTrue(netCap.appliesToUid(3001));
|
|
assertFalse(netCap.appliesToUid(10));
|
|
assertFalse(netCap.appliesToUid(25));
|
|
assertFalse(netCap.appliesToUid(49));
|
|
assertFalse(netCap.appliesToUid(101));
|
|
assertFalse(netCap.appliesToUid(2000));
|
|
assertFalse(netCap.appliesToUid(100000));
|
|
|
|
assertTrue(netCap.appliesToUidRange(new UidRange(50, 100)));
|
|
assertTrue(netCap.appliesToUidRange(new UidRange(70, 72)));
|
|
assertTrue(netCap.appliesToUidRange(new UidRange(3500, 3912)));
|
|
assertFalse(netCap.appliesToUidRange(new UidRange(1, 100)));
|
|
assertFalse(netCap.appliesToUidRange(new UidRange(49, 100)));
|
|
assertFalse(netCap.appliesToUidRange(new UidRange(1, 10)));
|
|
assertFalse(netCap.appliesToUidRange(new UidRange(60, 101)));
|
|
assertFalse(netCap.appliesToUidRange(new UidRange(60, 3400)));
|
|
|
|
NetworkCapabilities netCap2 = new NetworkCapabilities();
|
|
// A new netcap object has null UIDs, so anything will satisfy it.
|
|
assertTrue(netCap2.satisfiedByUids(netCap));
|
|
// Still not equal though.
|
|
assertFalse(netCap2.equalsUids(netCap));
|
|
netCap2.setUids(uids);
|
|
assertTrue(netCap2.satisfiedByUids(netCap));
|
|
assertTrue(netCap.equalsUids(netCap2));
|
|
assertTrue(netCap2.equalsUids(netCap));
|
|
|
|
uids.add(new UidRange(600, 700));
|
|
netCap2.setUids(uids);
|
|
assertFalse(netCap2.satisfiedByUids(netCap));
|
|
assertFalse(netCap.appliesToUid(650));
|
|
assertTrue(netCap2.appliesToUid(650));
|
|
netCap.combineCapabilities(netCap2);
|
|
assertTrue(netCap2.satisfiedByUids(netCap));
|
|
assertTrue(netCap.appliesToUid(650));
|
|
assertFalse(netCap.appliesToUid(500));
|
|
|
|
assertTrue(new NetworkCapabilities().satisfiedByUids(netCap));
|
|
netCap.combineCapabilities(new NetworkCapabilities());
|
|
assertTrue(netCap.appliesToUid(500));
|
|
assertTrue(netCap.appliesToUidRange(new UidRange(1, 100000)));
|
|
assertFalse(netCap2.appliesToUid(500));
|
|
assertFalse(netCap2.appliesToUidRange(new UidRange(1, 100000)));
|
|
assertTrue(new NetworkCapabilities().satisfiedByUids(netCap));
|
|
}
|
|
|
|
@Test
|
|
public void testParcelNetworkCapabilities() {
|
|
final Set<UidRange> uids = new ArraySet<>();
|
|
uids.add(new UidRange(50, 100));
|
|
uids.add(new UidRange(3000, 4000));
|
|
final NetworkCapabilities netCap = new NetworkCapabilities()
|
|
.addCapability(NET_CAPABILITY_INTERNET)
|
|
.setUids(uids)
|
|
.addCapability(NET_CAPABILITY_EIMS)
|
|
.addCapability(NET_CAPABILITY_NOT_METERED);
|
|
assertEqualsThroughMarshalling(netCap);
|
|
netCap.setSSID(TEST_SSID);
|
|
assertEqualsThroughMarshalling(netCap);
|
|
}
|
|
|
|
@Test
|
|
public void testOemPaid() {
|
|
NetworkCapabilities nc = new NetworkCapabilities();
|
|
// By default OEM_PAID is neither in the unwanted or required lists and the network is not
|
|
// restricted.
|
|
assertFalse(nc.hasUnwantedCapability(NET_CAPABILITY_OEM_PAID));
|
|
assertFalse(nc.hasCapability(NET_CAPABILITY_OEM_PAID));
|
|
nc.maybeMarkCapabilitiesRestricted();
|
|
assertTrue(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
|
|
// Adding OEM_PAID to capability list should make network restricted.
|
|
nc.addCapability(NET_CAPABILITY_OEM_PAID);
|
|
nc.addCapability(NET_CAPABILITY_INTERNET); // Combine with unrestricted capability.
|
|
nc.maybeMarkCapabilitiesRestricted();
|
|
assertTrue(nc.hasCapability(NET_CAPABILITY_OEM_PAID));
|
|
assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
|
|
// Now let's make request for OEM_PAID network.
|
|
NetworkCapabilities nr = new NetworkCapabilities();
|
|
nr.addCapability(NET_CAPABILITY_OEM_PAID);
|
|
nr.maybeMarkCapabilitiesRestricted();
|
|
assertTrue(nr.satisfiedByNetworkCapabilities(nc));
|
|
|
|
// Request fails for network with the default capabilities.
|
|
assertFalse(nr.satisfiedByNetworkCapabilities(new NetworkCapabilities()));
|
|
}
|
|
|
|
@Test
|
|
public void testUnwantedCapabilities() {
|
|
NetworkCapabilities network = new NetworkCapabilities();
|
|
|
|
NetworkCapabilities request = new NetworkCapabilities();
|
|
assertTrue("Request: " + request + ", Network:" + network,
|
|
request.satisfiedByNetworkCapabilities(network));
|
|
|
|
// Requesting absence of capabilities that network doesn't have. Request should satisfy.
|
|
request.addUnwantedCapability(NET_CAPABILITY_WIFI_P2P);
|
|
request.addUnwantedCapability(NET_CAPABILITY_NOT_METERED);
|
|
assertTrue(request.satisfiedByNetworkCapabilities(network));
|
|
assertArrayEquals(new int[] {NET_CAPABILITY_WIFI_P2P,
|
|
NET_CAPABILITY_NOT_METERED},
|
|
request.getUnwantedCapabilities());
|
|
|
|
// This is a default capability, just want to make sure its there because we use it below.
|
|
assertTrue(network.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
|
|
// Verify that adding unwanted capability will effectively remove it from capability list.
|
|
request.addUnwantedCapability(NET_CAPABILITY_NOT_RESTRICTED);
|
|
assertTrue(request.hasUnwantedCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
assertFalse(request.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
|
|
// Now this request won't be satisfied because network contains NOT_RESTRICTED.
|
|
assertFalse(request.satisfiedByNetworkCapabilities(network));
|
|
network.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
|
|
assertTrue(request.satisfiedByNetworkCapabilities(network));
|
|
|
|
// Verify that adding capability will effectively remove it from unwanted list
|
|
request.addCapability(NET_CAPABILITY_NOT_RESTRICTED);
|
|
assertTrue(request.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
assertFalse(request.hasUnwantedCapability(NET_CAPABILITY_NOT_RESTRICTED));
|
|
|
|
assertFalse(request.satisfiedByNetworkCapabilities(network));
|
|
network.addCapability(NET_CAPABILITY_NOT_RESTRICTED);
|
|
assertTrue(request.satisfiedByNetworkCapabilities(network));
|
|
}
|
|
|
|
@Test
|
|
public void testEqualsNetCapabilities() {
|
|
NetworkCapabilities nc1 = new NetworkCapabilities();
|
|
NetworkCapabilities nc2 = new NetworkCapabilities();
|
|
assertTrue(nc1.equalsNetCapabilities(nc2));
|
|
assertEquals(nc1, nc2);
|
|
|
|
nc1.addCapability(NET_CAPABILITY_MMS);
|
|
assertFalse(nc1.equalsNetCapabilities(nc2));
|
|
assertNotEquals(nc1, nc2);
|
|
nc2.addCapability(NET_CAPABILITY_MMS);
|
|
assertTrue(nc1.equalsNetCapabilities(nc2));
|
|
assertEquals(nc1, nc2);
|
|
|
|
nc1.addUnwantedCapability(NET_CAPABILITY_INTERNET);
|
|
assertFalse(nc1.equalsNetCapabilities(nc2));
|
|
nc2.addUnwantedCapability(NET_CAPABILITY_INTERNET);
|
|
assertTrue(nc1.equalsNetCapabilities(nc2));
|
|
|
|
nc1.removeCapability(NET_CAPABILITY_INTERNET);
|
|
assertFalse(nc1.equalsNetCapabilities(nc2));
|
|
nc2.removeCapability(NET_CAPABILITY_INTERNET);
|
|
assertTrue(nc1.equalsNetCapabilities(nc2));
|
|
}
|
|
|
|
@Test
|
|
public void testSSID() {
|
|
NetworkCapabilities nc1 = new NetworkCapabilities();
|
|
NetworkCapabilities nc2 = new NetworkCapabilities();
|
|
assertTrue(nc2.satisfiedBySSID(nc1));
|
|
|
|
nc1.setSSID(TEST_SSID);
|
|
assertTrue(nc2.satisfiedBySSID(nc1));
|
|
nc2.setSSID("different " + TEST_SSID);
|
|
assertFalse(nc2.satisfiedBySSID(nc1));
|
|
|
|
assertTrue(nc1.satisfiedByImmutableNetworkCapabilities(nc2));
|
|
assertFalse(nc1.satisfiedByNetworkCapabilities(nc2));
|
|
}
|
|
|
|
private ArraySet<UidRange> uidRange(int from, int to) {
|
|
final ArraySet<UidRange> range = new ArraySet<>(1);
|
|
range.add(new UidRange(from, to));
|
|
return range;
|
|
}
|
|
|
|
@Test
|
|
public void testCombineCapabilities() {
|
|
NetworkCapabilities nc1 = new NetworkCapabilities();
|
|
NetworkCapabilities nc2 = new NetworkCapabilities();
|
|
|
|
nc1.addUnwantedCapability(NET_CAPABILITY_CAPTIVE_PORTAL);
|
|
nc1.addCapability(NET_CAPABILITY_NOT_ROAMING);
|
|
assertNotEquals(nc1, nc2);
|
|
nc2.combineCapabilities(nc1);
|
|
assertEquals(nc1, nc2);
|
|
assertTrue(nc2.hasCapability(NET_CAPABILITY_NOT_ROAMING));
|
|
assertTrue(nc2.hasUnwantedCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
|
|
|
|
// This will effectively move NOT_ROAMING capability from required to unwanted for nc1.
|
|
nc1.addUnwantedCapability(NET_CAPABILITY_NOT_ROAMING);
|
|
|
|
nc2.combineCapabilities(nc1);
|
|
// We will get this capability in both requested and unwanted lists thus this request
|
|
// will never be satisfied.
|
|
assertTrue(nc2.hasCapability(NET_CAPABILITY_NOT_ROAMING));
|
|
assertTrue(nc2.hasUnwantedCapability(NET_CAPABILITY_NOT_ROAMING));
|
|
|
|
nc1.setSSID(TEST_SSID);
|
|
nc2.combineCapabilities(nc1);
|
|
assertTrue(TEST_SSID.equals(nc2.getSSID()));
|
|
|
|
// Because they now have the same SSID, the following call should not throw
|
|
nc2.combineCapabilities(nc1);
|
|
|
|
nc1.setSSID(DIFFERENT_TEST_SSID);
|
|
try {
|
|
nc2.combineCapabilities(nc1);
|
|
fail("Expected IllegalStateException: can't combine different SSIDs");
|
|
} catch (IllegalStateException expected) {}
|
|
nc1.setSSID(TEST_SSID);
|
|
|
|
nc1.setUids(uidRange(10, 13));
|
|
assertNotEquals(nc1, nc2);
|
|
nc2.combineCapabilities(nc1); // Everything + 10~13 is still everything.
|
|
assertNotEquals(nc1, nc2);
|
|
nc1.combineCapabilities(nc2); // 10~13 + everything is everything.
|
|
assertEquals(nc1, nc2);
|
|
nc1.setUids(uidRange(10, 13));
|
|
nc2.setUids(uidRange(20, 23));
|
|
assertNotEquals(nc1, nc2);
|
|
nc1.combineCapabilities(nc2);
|
|
assertTrue(nc1.appliesToUid(12));
|
|
assertFalse(nc2.appliesToUid(12));
|
|
assertTrue(nc1.appliesToUid(22));
|
|
assertTrue(nc2.appliesToUid(22));
|
|
}
|
|
|
|
@Test
|
|
public void testSetCapabilities() {
|
|
final int[] REQUIRED_CAPABILITIES = new int[] {
|
|
NET_CAPABILITY_INTERNET, NET_CAPABILITY_NOT_VPN };
|
|
final int[] UNWANTED_CAPABILITIES = new int[] {
|
|
NET_CAPABILITY_NOT_RESTRICTED, NET_CAPABILITY_NOT_METERED
|
|
};
|
|
|
|
NetworkCapabilities nc1 = new NetworkCapabilities();
|
|
NetworkCapabilities nc2 = new NetworkCapabilities();
|
|
|
|
nc1.setCapabilities(REQUIRED_CAPABILITIES, UNWANTED_CAPABILITIES);
|
|
assertArrayEquals(REQUIRED_CAPABILITIES, nc1.getCapabilities());
|
|
|
|
// Verify that setting and adding capabilities leads to the same object state.
|
|
nc2.clearAll();
|
|
for (int cap : REQUIRED_CAPABILITIES) {
|
|
nc2.addCapability(cap);
|
|
}
|
|
for (int cap : UNWANTED_CAPABILITIES) {
|
|
nc2.addUnwantedCapability(cap);
|
|
}
|
|
assertEquals(nc1, nc2);
|
|
}
|
|
|
|
private void assertEqualsThroughMarshalling(NetworkCapabilities netCap) {
|
|
Parcel p = Parcel.obtain();
|
|
netCap.writeToParcel(p, /* flags */ 0);
|
|
p.setDataPosition(0);
|
|
byte[] marshalledData = p.marshall();
|
|
|
|
p = Parcel.obtain();
|
|
p.unmarshall(marshalledData, 0, marshalledData.length);
|
|
p.setDataPosition(0);
|
|
assertEquals(NetworkCapabilities.CREATOR.createFromParcel(p), netCap);
|
|
}
|
|
|
|
@Test
|
|
public void testSet() {
|
|
NetworkCapabilities nc1 = new NetworkCapabilities();
|
|
NetworkCapabilities nc2 = new NetworkCapabilities();
|
|
|
|
nc1.addUnwantedCapability(NET_CAPABILITY_CAPTIVE_PORTAL);
|
|
nc1.addCapability(NET_CAPABILITY_NOT_ROAMING);
|
|
assertNotEquals(nc1, nc2);
|
|
nc2.set(nc1);
|
|
assertEquals(nc1, nc2);
|
|
assertTrue(nc2.hasCapability(NET_CAPABILITY_NOT_ROAMING));
|
|
assertTrue(nc2.hasUnwantedCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
|
|
|
|
// This will effectively move NOT_ROAMING capability from required to unwanted for nc1.
|
|
nc1.addUnwantedCapability(NET_CAPABILITY_NOT_ROAMING);
|
|
nc1.setSSID(TEST_SSID);
|
|
nc2.set(nc1);
|
|
assertEquals(nc1, nc2);
|
|
// Contrary to combineCapabilities, set() will have removed the NOT_ROAMING capability
|
|
// from nc2.
|
|
assertFalse(nc2.hasCapability(NET_CAPABILITY_NOT_ROAMING));
|
|
assertTrue(nc2.hasUnwantedCapability(NET_CAPABILITY_NOT_ROAMING));
|
|
assertTrue(TEST_SSID.equals(nc2.getSSID()));
|
|
|
|
nc1.setSSID(DIFFERENT_TEST_SSID);
|
|
nc2.set(nc1);
|
|
assertEquals(nc1, nc2);
|
|
assertTrue(DIFFERENT_TEST_SSID.equals(nc2.getSSID()));
|
|
|
|
nc1.setUids(uidRange(10, 13));
|
|
nc2.set(nc1); // Overwrites, as opposed to combineCapabilities
|
|
assertEquals(nc1, nc2);
|
|
}
|
|
}
|