Merge "Fix TelephonyNetworkFactoryTest#testRequests" am: 22f7db5b

        return makeNetworkFilter(subscriptionId);

    }

    private NetworkCapabilities makeNetworkFilter(int subscriptionId) {

    /**

     * Build the network request filter used by this factory.

     * @param subscriptionId the subscription ID to listen to

     * @return the filter to send to the system server

     */

    // This is used by the test to simulate the behavior of the system server, which is to

    // send requests that match the network filter.

    @VisibleForTesting

    public NetworkCapabilities makeNetworkFilter(int subscriptionId) {

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

                .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)

                .addCapability(NetworkCapabilities.NET_CAPABILITY_MMS)

import static org.mockito.Mockito.verify;

import android.net.NetworkCapabilities;

import android.net.NetworkProvider;

import android.net.NetworkRequest;

import android.net.TelephonyNetworkSpecifier;

import android.os.AsyncResult;

import android.test.suitebuilder.annotation.SmallTest;

import android.testing.AndroidTestingRunner;

import android.testing.TestableLooper;

import android.util.ArraySet;

import androidx.test.filters.FlakyTest;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.Mock;

import org.mockito.Mockito;

    private String mTestName = "";

    // List of all requests filed by a test

    private final ArraySet<NetworkRequest> mAllNetworkRequestSet = new ArraySet<>();

    // List of requests active in DcTracker

    private final ArrayList<NetworkRequest> mNetworkRequestList = new ArrayList<>();

    private TelephonyNetworkFactory mTelephonyNetworkFactoryUT;

                        "mobile_ia,14,0,2,-1,true", "mobile_emergency,15,0,2,-1,true"});

        doAnswer(invocation -> {

            mNetworkRequestList.add((NetworkRequest) invocation.getArguments()[0]);

            final NetworkRequest req = (NetworkRequest) invocation.getArguments()[0];

            mNetworkRequestList.add(req);

            mAllNetworkRequestSet.add(req);

            return null;

        }).when(mDcTracker).requestNetwork(any(), anyInt(), any());

        replaceInstance(PhoneSwitcher.class, "sPhoneSwitcher", null, mPhoneSwitcher);

        mTelephonyNetworkFactoryUT = new TelephonyNetworkFactory(Looper.myLooper(), mPhone);

        verify(mConnectivityManager).registerNetworkProvider(any());

        final ArgumentCaptor<NetworkProvider> providerCaptor =

                ArgumentCaptor.forClass(NetworkProvider.class);

        verify(mConnectivityManager).registerNetworkProvider(providerCaptor.capture());

        // For NetworkFactory to function as expected, the provider ID must be set to some

        // number > 0.

        providerCaptor.getValue().setProviderId(1);

        verify(mPhoneSwitcher).registerForActivePhoneSwitch(any(), anyInt(), any());

        // Simulate the behavior of the system server. When offerNetwork is called, it will

        // update the factory about all requests that pass the registered filter, by calling

        // NetworkProvider#onNetworkNeeded or onNetworkUnneeded.

        // Note that this simulation is a little bit incomplete, as the system server will

        // *update* only for those requests for which the status has changed, but this

        // simulation will send REQUEST_NETWORK or CANCEL_REQUEST for all registered requests.

        // At this time it makes no difference in this test.

        // Also, this test reads from mAllNetworkRequestSet, which is not really the list of

        // requests sent to the system server as the test doesn't instrument that. Instead, it's

        // the list of requests ever sent to the factory. This also makes no difference in this

        // test at this time.

        doAnswer(invocation -> {

            final NetworkCapabilities capabilitiesFilter =

                    mTelephonyNetworkFactoryUT.makeNetworkFilter(

                            mSubscriptionController.getSubIdUsingPhoneId(0));

            for (final NetworkRequest request : mAllNetworkRequestSet) {

                final int message = request.canBeSatisfiedBy(capabilitiesFilter)

                        ? CMD_REQUEST_NETWORK : CMD_CANCEL_REQUEST;

                mTelephonyNetworkFactoryUT.obtainMessage(message, 0, 0, request).sendToTarget();

            }

            return null;

        }).when(mConnectivityManager).offerNetwork(anyInt(), any(), any(), any());

    }

    /**