Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit fb4ee18a authored by lucaslin's avatar lucaslin Committed by Lucas Lin
Browse files

Add more tests in NetworkCapabilitiesTest.java 

Test deduceRestrictedCapability(), getAdministratorUids(),
setAdministratorUids(), getNetworkSpecifier(), getOwnerUid(),
setLinkDownstreamBandwidthKbps(), setLinkUpstreamBandwidthKbps(),
setSignalStrength() and Builder().

Bug: 139268426
Bug: 135998869
Bug: 138306002
Test: atest CtsNetTestCasesLatestSdk:android.net.NetworkCapabilitiesTest
Change-Id: I525941c47b71cd61ee872fd4d71b02a5d3767e21
Merged-In: I90c7a8c47710ea4ad8e8d2682c10440fd7f82270
parent 18eb7e55

tests/net/common/java/android/net/NetworkCapabilitiesTest.java

+241 −0
Original line number Diff line number Diff line
@@ -17,6 +17,8 @@ 
package android.net;



import static android.net.NetworkCapabilities.LINK_BANDWIDTH_UNSPECIFIED;

import static android.net.NetworkCapabilities.MAX_TRANSPORT;

import static android.net.NetworkCapabilities.MIN_TRANSPORT;

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;
@@ -32,10 +34,12 @@ import static android.net.NetworkCapabilities.NET_CAPABILITY_PARTIAL_CONNECTIVIT 
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.SIGNAL_STRENGTH_UNSPECIFIED;

import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;

import static android.net.NetworkCapabilities.TRANSPORT_TEST;

import static android.net.NetworkCapabilities.TRANSPORT_VPN;

import static android.net.NetworkCapabilities.TRANSPORT_WIFI;

import static android.net.NetworkCapabilities.TRANSPORT_WIFI_AWARE;

import static android.net.NetworkCapabilities.UNRESTRICTED_CAPABILITIES;



import static com.android.testutils.ParcelUtilsKt.assertParcelSane;
@@ -45,10 +49,15 @@ 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.assertNull;

import static org.junit.Assert.assertTrue;

import static org.junit.Assert.fail;



import android.net.wifi.aware.DiscoverySession;

import android.net.wifi.aware.PeerHandle;

import android.net.wifi.aware.WifiAwareNetworkSpecifier;

import android.os.Build;

import android.os.Process;

import android.test.suitebuilder.annotation.SmallTest;

import android.util.ArraySet;
@@ -61,6 +70,7 @@ import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo; 
import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mockito;



import java.util.Arrays;

import java.util.Set;
@@ -74,6 +84,9 @@ public class NetworkCapabilitiesTest { 
    @Rule

    public DevSdkIgnoreRule mDevSdkIgnoreRule = new DevSdkIgnoreRule();



    private DiscoverySession mDiscoverySession = Mockito.mock(DiscoverySession.class);

    private PeerHandle mPeerHandle = Mockito.mock(PeerHandle.class);



    private boolean isAtLeastR() {

        // BuildCompat.isAtLeastR() is used to check the Android version before releasing Android R.

        // Build.VERSION.SDK_INT > Build.VERSION_CODES.Q is used to check the Android version after
@@ -685,4 +698,232 @@ public class NetworkCapabilitiesTest { 
        assertEquals(TRANSPORT_VPN, transportTypes[2]);

        assertEquals(TRANSPORT_TEST, transportTypes[3]);

    }



    @Test @IgnoreUpTo(Build.VERSION_CODES.Q)

    public void testTelephonyNetworkSpecifier() {

        final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(1);

        final NetworkCapabilities nc1 = new NetworkCapabilities.Builder()

                .addTransportType(TRANSPORT_WIFI)

                .setNetworkSpecifier(specifier)

                .build();

        assertEquals(specifier, nc1.getNetworkSpecifier());

        try {

            final NetworkCapabilities nc2 = new NetworkCapabilities.Builder()

                    .setNetworkSpecifier(specifier)

                    .build();

            fail("Must have a single transport type. Without transport type or multiple transport"

                    + " types is invalid.");

        } catch (IllegalStateException expected) { }

    }



    @Test

    public void testWifiAwareNetworkSpecifier() {

        final NetworkCapabilities nc = new NetworkCapabilities()

                .addTransportType(TRANSPORT_WIFI_AWARE);

        // If NetworkSpecifier is not set, the default value is null.

        assertNull(nc.getNetworkSpecifier());

        final WifiAwareNetworkSpecifier specifier = new WifiAwareNetworkSpecifier.Builder(

                mDiscoverySession, mPeerHandle).build();

        nc.setNetworkSpecifier(specifier);

        assertEquals(specifier, nc.getNetworkSpecifier());

    }



    @Test @IgnoreUpTo(Build.VERSION_CODES.Q)

    public void testAdministratorUidsAndOwnerUid() {

        // Test default owner uid.

        // If the owner uid is not set, the default value should be Process.INVALID_UID.

        final NetworkCapabilities nc1 = new NetworkCapabilities.Builder().build();

        assertEquals(Process.INVALID_UID, nc1.getOwnerUid());

        // Test setAdministratorUids and getAdministratorUids.

        final int[] administratorUids = {1001, 10001};

        final NetworkCapabilities nc2 = new NetworkCapabilities.Builder()

                .setAdministratorUids(administratorUids)

                .build();

        assertTrue(Arrays.equals(administratorUids, nc2.getAdministratorUids()));

        // Test setOwnerUid and getOwnerUid.

        // The owner UID must be included in administrator UIDs, or throw IllegalStateException.

        try {

            final NetworkCapabilities nc3 = new NetworkCapabilities.Builder()

                    .setOwnerUid(1001)

                    .build();

            fail("The owner UID must be included in administrator UIDs.");

        } catch (IllegalStateException expected) { }

        final NetworkCapabilities nc4 = new NetworkCapabilities.Builder()

                .setAdministratorUids(administratorUids)

                .setOwnerUid(1001)

                .build();

        assertEquals(1001, nc4.getOwnerUid());

        try {

            final NetworkCapabilities nc5 = new NetworkCapabilities.Builder()

                    .setAdministratorUids(null)

                    .build();

            fail("Should not set null into setAdministratorUids");

        } catch (NullPointerException expected) { }

    }



    @Test

    public void testLinkBandwidthKbps() {

        final NetworkCapabilities nc = new NetworkCapabilities();

        // The default value of LinkDown/UpstreamBandwidthKbps should be LINK_BANDWIDTH_UNSPECIFIED.

        assertEquals(LINK_BANDWIDTH_UNSPECIFIED, nc.getLinkDownstreamBandwidthKbps());

        assertEquals(LINK_BANDWIDTH_UNSPECIFIED, nc.getLinkUpstreamBandwidthKbps());

        nc.setLinkDownstreamBandwidthKbps(512);

        nc.setLinkUpstreamBandwidthKbps(128);

        assertEquals(512, nc.getLinkDownstreamBandwidthKbps());

        assertNotEquals(128, nc.getLinkDownstreamBandwidthKbps());

        assertEquals(128, nc.getLinkUpstreamBandwidthKbps());

        assertNotEquals(512, nc.getLinkUpstreamBandwidthKbps());

    }



    @Test

    public void testSignalStrength() {

        final NetworkCapabilities nc = new NetworkCapabilities();

        // The default value of signal strength should be SIGNAL_STRENGTH_UNSPECIFIED.

        assertEquals(SIGNAL_STRENGTH_UNSPECIFIED, nc.getSignalStrength());

        nc.setSignalStrength(-80);

        assertEquals(-80, nc.getSignalStrength());

        assertNotEquals(-50, nc.getSignalStrength());

    }



    @Test @IgnoreUpTo(Build.VERSION_CODES.Q)

    public void testDeduceRestrictedCapability() {

        final NetworkCapabilities nc = new NetworkCapabilities();

        // Default capabilities don't have restricted capability.

        assertFalse(nc.deduceRestrictedCapability());

        // If there is a force restricted capability, then the network capabilities is restricted.

        nc.addCapability(NET_CAPABILITY_OEM_PAID);

        nc.addCapability(NET_CAPABILITY_INTERNET);

        assertTrue(nc.deduceRestrictedCapability());

        // Except for the force restricted capability, if there is any unrestricted capability in

        // capabilities, then the network capabilities is not restricted.

        nc.removeCapability(NET_CAPABILITY_OEM_PAID);

        nc.addCapability(NET_CAPABILITY_CBS);

        assertFalse(nc.deduceRestrictedCapability());

        // Except for the force restricted capability, the network capabilities will only be treated

        // as restricted when there is no any unrestricted capability.

        nc.removeCapability(NET_CAPABILITY_INTERNET);

        assertTrue(nc.deduceRestrictedCapability());

    }



    private void assertNoTransport(NetworkCapabilities nc) {

        for (int i = MIN_TRANSPORT; i <= MAX_TRANSPORT; i++) {

            assertFalse(nc.hasTransport(i));

        }

    }



    // Checks that all transport types from MIN_TRANSPORT to maxTransportType are set and all

    // transport types from maxTransportType + 1 to MAX_TRANSPORT are not set when positiveSequence

    // is true. If positiveSequence is false, then the check sequence is opposite.

    private void checkCurrentTransportTypes(NetworkCapabilities nc, int maxTransportType,

            boolean positiveSequence) {

        for (int i = MIN_TRANSPORT; i <= maxTransportType; i++) {

            if (positiveSequence) {

                assertTrue(nc.hasTransport(i));

            } else {

                assertFalse(nc.hasTransport(i));

            }

        }

        for (int i = MAX_TRANSPORT; i > maxTransportType; i--) {

            if (positiveSequence) {

                assertFalse(nc.hasTransport(i));

            } else {

                assertTrue(nc.hasTransport(i));

            }

        }

    }



    @Test

    public void testMultipleTransportTypes() {

        final NetworkCapabilities nc = new NetworkCapabilities();

        assertNoTransport(nc);

        // Test adding multiple transport types.

        for (int i = MIN_TRANSPORT; i <= MAX_TRANSPORT; i++) {

            nc.addTransportType(i);

            checkCurrentTransportTypes(nc, i, true /* positiveSequence */);

        }

        // Test removing multiple transport types.

        for (int i = MIN_TRANSPORT; i <= MAX_TRANSPORT; i++) {

            nc.removeTransportType(i);

            checkCurrentTransportTypes(nc, i, false /* positiveSequence */);

        }

        assertNoTransport(nc);

        nc.addTransportType(TRANSPORT_WIFI);

        assertTrue(nc.hasTransport(TRANSPORT_WIFI));

        assertFalse(nc.hasTransport(TRANSPORT_VPN));

        nc.addTransportType(TRANSPORT_VPN);

        assertTrue(nc.hasTransport(TRANSPORT_WIFI));

        assertTrue(nc.hasTransport(TRANSPORT_VPN));

        nc.removeTransportType(TRANSPORT_WIFI);

        assertFalse(nc.hasTransport(TRANSPORT_WIFI));

        assertTrue(nc.hasTransport(TRANSPORT_VPN));

        nc.removeTransportType(TRANSPORT_VPN);

        assertFalse(nc.hasTransport(TRANSPORT_WIFI));

        assertFalse(nc.hasTransport(TRANSPORT_VPN));

        assertNoTransport(nc);

    }



    @Test

    public void testAddAndRemoveTransportType() {

        final NetworkCapabilities nc = new NetworkCapabilities();

        try {

            nc.addTransportType(-1);

            fail("Should not set invalid transport type into addTransportType");

        } catch (IllegalArgumentException expected) { }

        try {

            nc.removeTransportType(-1);

            fail("Should not set invalid transport type into removeTransportType");

        } catch (IllegalArgumentException e) { }

    }



    @Test @IgnoreUpTo(Build.VERSION_CODES.Q)

    public void testBuilder() {

        final int ownerUid = 1001;

        final int signalStrength = -80;

        final int requestUid = 10100;

        final int[] administratorUids = {ownerUid, 10001};

        final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(1);

        final String ssid = "TEST_SSID";

        final String packageName = "com.google.test.networkcapabilities";

        final NetworkCapabilities nc = new NetworkCapabilities.Builder()

                .addTransportType(TRANSPORT_WIFI)

                .addTransportType(TRANSPORT_CELLULAR)

                .removeTransportType(TRANSPORT_CELLULAR)

                .addCapability(NET_CAPABILITY_EIMS)

                .addCapability(NET_CAPABILITY_CBS)

                .removeCapability(NET_CAPABILITY_CBS)

                .setAdministratorUids(administratorUids)

                .setOwnerUid(ownerUid)

                .setLinkDownstreamBandwidthKbps(512)

                .setLinkUpstreamBandwidthKbps(128)

                .setNetworkSpecifier(specifier)

                .setTransportInfo(null)

                .setSignalStrength(signalStrength)

                .setSsid(ssid)

                .setRequestorUid(requestUid)

                .setRequestorPackageName(packageName)

                .build();

        assertEquals(1, nc.getTransportTypes().length);

        assertEquals(TRANSPORT_WIFI, nc.getTransportTypes()[0]);

        assertTrue(nc.hasCapability(NET_CAPABILITY_EIMS));

        assertFalse(nc.hasCapability(NET_CAPABILITY_CBS));

        assertTrue(Arrays.equals(administratorUids, nc.getAdministratorUids()));

        assertEquals(ownerUid, nc.getOwnerUid());

        assertEquals(512, nc.getLinkDownstreamBandwidthKbps());

        assertNotEquals(128, nc.getLinkDownstreamBandwidthKbps());

        assertEquals(128, nc.getLinkUpstreamBandwidthKbps());

        assertNotEquals(512, nc.getLinkUpstreamBandwidthKbps());

        assertEquals(specifier, nc.getNetworkSpecifier());

        assertNull(nc.getTransportInfo());

        assertEquals(signalStrength, nc.getSignalStrength());

        assertNotEquals(-50, nc.getSignalStrength());

        assertEquals(ssid, nc.getSsid());

        assertEquals(requestUid, nc.getRequestorUid());

        assertEquals(packageName, nc.getRequestorPackageName());

        // Cannot assign null into NetworkCapabilities.Builder

        try {

            final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder(null);

            fail("Should not set null into NetworkCapabilities.Builder");

        } catch (NullPointerException expected) { }

        assertEquals(nc, new NetworkCapabilities.Builder(nc).build());

    }

}