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

Commit 1211941a authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "ConnectivityServiceTest: fix flaky testNetworkRequestMaximum"

parents d30e47ec 893a762c
Loading
Loading
Loading
Loading
+56 −57
Original line number Original line Diff line number Diff line
@@ -121,7 +121,6 @@ import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.BooleanSupplier;
import java.util.function.Predicate;
import java.util.function.Predicate;


/**
/**
@@ -3212,68 +3211,68 @@ public class ConnectivityServiceTest extends AndroidTestCase {
    }
    }


    @SmallTest
    @SmallTest
    public void testNetworkRequestMaximum() {
    public void testNetworkCallbackMaximum() {
        final int MAX_REQUESTS = 100;
        final int MAX_REQUESTS = 100;
        // Test that the limit is enforced when MAX_REQUESTS simultaneous requests are added.
        final int CALLBACKS = 90;
        final int INTENTS = 10;
        assertEquals(MAX_REQUESTS, CALLBACKS + INTENTS);

        NetworkRequest networkRequest = new NetworkRequest.Builder().build();
        NetworkRequest networkRequest = new NetworkRequest.Builder().build();
        ArrayList<NetworkCallback> networkCallbacks = new ArrayList<NetworkCallback>();
        ArrayList<Object> registered = new ArrayList<>();
        try {

            for (int i = 0; i < MAX_REQUESTS; i++) {
        int j = 0;
                NetworkCallback networkCallback = new NetworkCallback();
        while (j++ < CALLBACKS / 2) {
                mCm.requestNetwork(networkRequest, networkCallback);
            NetworkCallback cb = new NetworkCallback();
                networkCallbacks.add(networkCallback);
            mCm.requestNetwork(networkRequest, cb);
            registered.add(cb);
        }
        }
            fail("Registering " + MAX_REQUESTS + " NetworkRequests did not throw exception");
        while (j++ < CALLBACKS) {
        } catch (TooManyRequestsException expected) {}
            NetworkCallback cb = new NetworkCallback();
        for (NetworkCallback networkCallback : networkCallbacks) {
            mCm.registerNetworkCallback(networkRequest, cb);
            mCm.unregisterNetworkCallback(networkCallback);
            registered.add(cb);
        }
        }
        networkCallbacks.clear();
        j = 0;

        while (j++ < INTENTS / 2) {
        try {
            PendingIntent pi = PendingIntent.getBroadcast(mContext, 0, new Intent("a" + j), 0);
            for (int i = 0; i < MAX_REQUESTS; i++) {
            mCm.requestNetwork(networkRequest, pi);
                NetworkCallback networkCallback = new NetworkCallback();
            registered.add(pi);
                mCm.registerNetworkCallback(networkRequest, networkCallback);
                networkCallbacks.add(networkCallback);
        }
        }
            fail("Registering " + MAX_REQUESTS + " NetworkCallbacks did not throw exception");
        while (j++ < INTENTS) {
        } catch (TooManyRequestsException expected) {}
            PendingIntent pi = PendingIntent.getBroadcast(mContext, 0, new Intent("b" + j), 0);
        for (NetworkCallback networkCallback : networkCallbacks) {
            mCm.registerNetworkCallback(networkRequest, pi);
            mCm.unregisterNetworkCallback(networkCallback);
            registered.add(pi);
        }
        }
        networkCallbacks.clear();


        ArrayList<PendingIntent> pendingIntents = new ArrayList<PendingIntent>();
        // Test that the limit is enforced when MAX_REQUESTS simultaneous requests are added.
        try {
        try {
            for (int i = 0; i < MAX_REQUESTS + 1; i++) {
            mCm.requestNetwork(networkRequest, new NetworkCallback());
                PendingIntent pendingIntent =
            fail("Registering " + MAX_REQUESTS + " network requests did not throw exception");
                        PendingIntent.getBroadcast(mContext, 0, new Intent("a" + i), 0);
                mCm.requestNetwork(networkRequest, pendingIntent);
                pendingIntents.add(pendingIntent);
            }
            fail("Registering " + MAX_REQUESTS +
                    " PendingIntent NetworkRequests did not throw exception");
        } catch (TooManyRequestsException expected) {}
        } catch (TooManyRequestsException expected) {}
        for (PendingIntent pendingIntent : pendingIntents) {
            mCm.unregisterNetworkCallback(pendingIntent);
        }
        pendingIntents.clear();

        try {
        try {
            for (int i = 0; i < MAX_REQUESTS + 1; i++) {
            mCm.registerNetworkCallback(networkRequest, new NetworkCallback());
                PendingIntent pendingIntent =
            fail("Registering " + MAX_REQUESTS + " network callbacks did not throw exception");
                        PendingIntent.getBroadcast(mContext, 0, new Intent("a" + i), 0);
                mCm.registerNetworkCallback(networkRequest, pendingIntent);
                pendingIntents.add(pendingIntent);
            }
            fail("Registering " + MAX_REQUESTS +
                    " PendingIntent NetworkCallbacks did not throw exception");
        } catch (TooManyRequestsException expected) {}
        } catch (TooManyRequestsException expected) {}
        for (PendingIntent pendingIntent : pendingIntents) {
        try {
            mCm.unregisterNetworkCallback(pendingIntent);
            mCm.requestNetwork(networkRequest,
                PendingIntent.getBroadcast(mContext, 0, new Intent("c"), 0));
            fail("Registering " + MAX_REQUESTS + " PendingIntent requests did not throw exception");
        } catch (TooManyRequestsException expected) {}
        try {
            mCm.registerNetworkCallback(networkRequest,
                PendingIntent.getBroadcast(mContext, 0, new Intent("d"), 0));
            fail("Registering " + MAX_REQUESTS
                    + " PendingIntent callbacks did not throw exception");
        } catch (TooManyRequestsException expected) {}

        for (Object o : registered) {
            if (o instanceof NetworkCallback) {
                mCm.unregisterNetworkCallback((NetworkCallback)o);
            }
            if (o instanceof PendingIntent) {
                mCm.unregisterNetworkCallback((PendingIntent)o);
            }
        }
        }
        pendingIntents.clear();
        waitForIdle();
        waitForIdle(5000);


        // Test that the limit is not hit when MAX_REQUESTS requests are added and removed.
        // Test that the limit is not hit when MAX_REQUESTS requests are added and removed.
        for (int i = 0; i < MAX_REQUESTS; i++) {
        for (int i = 0; i < MAX_REQUESTS; i++) {
@@ -3281,23 +3280,23 @@ public class ConnectivityServiceTest extends AndroidTestCase {
            mCm.requestNetwork(networkRequest, networkCallback);
            mCm.requestNetwork(networkRequest, networkCallback);
            mCm.unregisterNetworkCallback(networkCallback);
            mCm.unregisterNetworkCallback(networkCallback);
        }
        }
        waitForIdle();

        for (int i = 0; i < MAX_REQUESTS; i++) {
        for (int i = 0; i < MAX_REQUESTS; i++) {
            NetworkCallback networkCallback = new NetworkCallback();
            NetworkCallback networkCallback = new NetworkCallback();
            mCm.registerNetworkCallback(networkRequest, networkCallback);
            mCm.registerNetworkCallback(networkRequest, networkCallback);
            mCm.unregisterNetworkCallback(networkCallback);
            mCm.unregisterNetworkCallback(networkCallback);
        }
        }
        waitForIdle();

        for (int i = 0; i < MAX_REQUESTS; i++) {
        for (int i = 0; i < MAX_REQUESTS; i++) {
            PendingIntent pendingIntent =
            PendingIntent pendingIntent =
                    PendingIntent.getBroadcast(mContext, 0, new Intent("b" + i), 0);
                    PendingIntent.getBroadcast(mContext, 0, new Intent("e" + i), 0);
            mCm.requestNetwork(networkRequest, pendingIntent);
            mCm.requestNetwork(networkRequest, pendingIntent);
            mCm.unregisterNetworkCallback(pendingIntent);
            mCm.unregisterNetworkCallback(pendingIntent);
        }
        }
        waitForIdle();

        for (int i = 0; i < MAX_REQUESTS; i++) {
        for (int i = 0; i < MAX_REQUESTS; i++) {
            PendingIntent pendingIntent =
            PendingIntent pendingIntent =
                    PendingIntent.getBroadcast(mContext, 0, new Intent("c" + i), 0);
                    PendingIntent.getBroadcast(mContext, 0, new Intent("f" + i), 0);
            mCm.registerNetworkCallback(networkRequest, pendingIntent);
            mCm.registerNetworkCallback(networkRequest, pendingIntent);
            mCm.unregisterNetworkCallback(pendingIntent);
            mCm.unregisterNetworkCallback(pendingIntent);
        }
        }