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

Commit 177d2862 authored by Nagendra Prasad Nagarle Basavaraju's avatar Nagendra Prasad Nagarle Basavaraju Committed by sangyun
Browse files

[Data Validation Api] Add Unit test coverage 

- Add unit test coverage to newly added network
  validation api/code

Bug: 303006275
Test: atest FrameworksTelephonyTests
Change-Id: I5ffc74c5edbd683aa201e1f70636e672d65387fe
parent f6feb7cf

tests/telephonytests/src/com/android/internal/telephony/TelephonyTest.java

+33 −1
Original line number Diff line number Diff line
@@ -152,7 +152,9 @@ import java.util.HashSet; 
import java.util.List;

import java.util.Set;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.Semaphore;

import java.util.concurrent.TimeUnit;

import java.util.function.Consumer;



public abstract class TelephonyTest {

    protected static String TAG;
@@ -315,7 +317,37 @@ public abstract class TelephonyTest { 


    private final List<InstanceKey> mInstanceKeys = new ArrayList<>();



    private static class InstanceKey {

    protected int mIntegerConsumerResult;

    protected Semaphore mIntegerConsumerSemaphore = new Semaphore(0);

    protected  Consumer<Integer> mIntegerConsumer = new Consumer<Integer>() {

        @Override

        public void accept(Integer integer) {

            logd("mIIntegerConsumer: result=" + integer);

            mIntegerConsumerResult =  integer;

            try {

                mIntegerConsumerSemaphore.release();

            } catch (Exception ex) {

                logd("mIIntegerConsumer: Got exception in releasing semaphore, ex=" + ex);

            }

        }

    };



    protected boolean waitForIntegerConsumerResponse(int expectedNumberOfEvents) {

        for (int i = 0; i < expectedNumberOfEvents; i++) {

            try {

                if (!mIntegerConsumerSemaphore.tryAcquire(500 /*Timeout*/, TimeUnit.MILLISECONDS)) {

                    logd("Timeout to receive IIntegerConsumer() callback");

                    return false;

                }

            } catch (Exception ex) {

                logd("waitForIIntegerConsumerResult: Got exception=" + ex);

                return false;

            }

        }

        return true;

    }



    private class InstanceKey {

        public final Class mClass;

        public final String mInstName;

        public final Object mObj;

tests/telephonytests/src/com/android/internal/telephony/data/AccessNetworksManagerTest.java

+65 −1
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ import static org.mockito.ArgumentMatchers.eq; 
import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;
@@ -41,11 +42,13 @@ import android.telephony.AccessNetworkConstants; 
import android.telephony.AccessNetworkConstants.AccessNetworkType;

import android.telephony.NetworkService;

import android.telephony.data.ApnSetting;

import android.telephony.data.DataServiceCallback;

import android.telephony.data.IQualifiedNetworksService;

import android.telephony.data.IQualifiedNetworksServiceCallback;

import android.testing.AndroidTestingRunner;

import android.testing.TestableLooper;



import com.android.internal.telephony.IIntegerConsumer;

import com.android.internal.telephony.TelephonyTest;

import com.android.internal.telephony.data.AccessNetworksManager.AccessNetworksManagerCallback;
@@ -55,6 +58,11 @@ import org.junit.Test; 
import org.junit.runner.RunWith;

import org.mockito.Mockito;



import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.Semaphore;

import java.util.concurrent.TimeUnit;



@RunWith(AndroidTestingRunner.class)

@TestableLooper.RunWithLooper

public class AccessNetworksManagerTest extends TelephonyTest {
@@ -68,8 +76,37 @@ public class AccessNetworksManagerTest extends TelephonyTest { 


    // The real callback passed created by AccessNetworksManager.

    private IQualifiedNetworksServiceCallback.Stub mQnsCallback;



    private PersistableBundle mBundle;

    private List<Integer> mIIntegerConsumerResults =  new ArrayList<>();

    private Semaphore mIIntegerConsumerSemaphore = new Semaphore(0);

    private IIntegerConsumer mIIntegerConsumer = new IIntegerConsumer.Stub() {

        @Override

        public void accept(int result) {

            logd("mIIntegerConsumer: result=" + result);

            mIIntegerConsumerResults.add(result);

            try {

                mIIntegerConsumerSemaphore.release();

            } catch (Exception ex) {

                logd("mIIntegerConsumer: Got exception in releasing semaphore, ex=" + ex);

            }

        }

    };



    private boolean waitForIIntegerConsumerResult(int expectedNumberOfEvents) {

        for (int i = 0; i < expectedNumberOfEvents; i++) {

            try {

                if (!mIIntegerConsumerSemaphore.tryAcquire(500 /* Timeout */,

                        TimeUnit.MILLISECONDS)) {

                    logd("Timeout to receive IIntegerConsumer() callback");

                    return false;

                }

            } catch (Exception ex) {

                logd("waitForIIntegerConsumerResult: Got exception=" + ex);

                return false;

            }

        }

        return true;

    }



    private void addQnsService() throws Exception {

        ServiceInfo QnsInfo = new ServiceInfo();
@@ -282,6 +319,33 @@ public class AccessNetworksManagerTest extends TelephonyTest { 
        assertThat(mAccessNetworksManager.getPreferredTransportByNetworkCapability(

                NetworkCapabilities.NET_CAPABILITY_XCAP)).isEqualTo(

                AccessNetworkConstants.TRANSPORT_TYPE_WWAN);

    }



    @Test

    public void testRequestNetworkValidation_WithFlagEnabled()  throws Exception {

        when(mFeatureFlags.networkValidation()).thenReturn(true);



        mQnsCallback.onNetworkValidationRequested(NetworkCapabilities.NET_CAPABILITY_IMS,

                mIIntegerConsumer);

        processAllMessages();

        assertThat(waitForIIntegerConsumerResult(1 /*numOfEvents*/)).isFalse();

    }



    @Test

    public void testRequestNetworkValidation_WithFlagDisabled() throws Exception {

        mIIntegerConsumerResults.clear();

        when(mFeatureFlags.networkValidation()).thenReturn(false);



        mQnsCallback.onNetworkValidationRequested(NetworkCapabilities.NET_CAPABILITY_IMS,

                mIIntegerConsumer);

        processAllMessages();



        assertThat(waitForIIntegerConsumerResult(1 /*numOfEvents*/)).isTrue();

        assertThat((long) mIIntegerConsumerResults.get(0))

                .isEqualTo(DataServiceCallback.RESULT_ERROR_UNSUPPORTED);

        verify(mDataNetworkController, never()).requestNetworkValidation(

                NetworkCapabilities.NET_CAPABILITY_IMS,

                mIntegerConsumer);

    }



}

tests/telephonytests/src/com/android/internal/telephony/data/DataCallResponseTest.java

+15 −0
Original line number Diff line number Diff line
@@ -16,9 +16,12 @@ 


package com.android.internal.telephony.data;



import static org.junit.Assert.assertNotEquals;



import android.net.InetAddresses;

import android.net.LinkAddress;

import android.os.Parcel;

import android.telephony.PreciseDataConnectionState;

import android.telephony.data.ApnSetting;

import android.telephony.data.DataCallResponse;

import android.telephony.data.EpsQos;
@@ -71,6 +74,8 @@ public class DataCallResponseTest extends AndroidTestCase { 
                .setQosBearerSessions(new ArrayList<>())

                .setTrafficDescriptors(

                        Arrays.asList(new TrafficDescriptor(FAKE_DNN, FAKE_OS_APP_ID)))

                .setNetworkValidationStatus(

                        PreciseDataConnectionState.NETWORK_VALIDATION_UNSUPPORTED)

                .build();



        Parcel p = Parcel.obtain();
@@ -100,6 +105,8 @@ public class DataCallResponseTest extends AndroidTestCase { 
                .setMtuV6(1400)

                .setTrafficDescriptors(

                        Arrays.asList(new TrafficDescriptor(FAKE_DNN, FAKE_OS_APP_ID)))

                .setNetworkValidationStatus(

                        PreciseDataConnectionState.NETWORK_VALIDATION_IN_PROGRESS)

                .build();



        DataCallResponse response1 = new DataCallResponse.Builder()
@@ -119,6 +126,8 @@ public class DataCallResponseTest extends AndroidTestCase { 
                .setMtuV6(1400)

                .setTrafficDescriptors(

                        Arrays.asList(new TrafficDescriptor(FAKE_DNN, FAKE_OS_APP_ID)))

                .setNetworkValidationStatus(

                        PreciseDataConnectionState.NETWORK_VALIDATION_IN_PROGRESS)

                .build();



        assertEquals(response, response);
@@ -145,11 +154,14 @@ public class DataCallResponseTest extends AndroidTestCase { 
                .setTrafficDescriptors(Arrays.asList(

                        new TrafficDescriptor(FAKE_DNN, FAKE_OS_APP_ID),

                        new TrafficDescriptor(FAKE_DNN_2, FAKE_OS_APP_ID_2)))

                .setNetworkValidationStatus(PreciseDataConnectionState.NETWORK_VALIDATION_SUCCESS)

                .build();



        assertNotSame(response1, response2);

        assertNotSame(response1, null);

        assertNotSame(response1, new String[1]);

        assertNotEquals(response1.getNetworkValidationStatus(),

                response2.getNetworkValidationStatus());

        assertNotSame(response1.hashCode(), response2.hashCode());



        DataCallResponse response3 = new DataCallResponse.Builder()
@@ -172,9 +184,12 @@ public class DataCallResponseTest extends AndroidTestCase { 
                .setTrafficDescriptors(Arrays.asList(

                        new TrafficDescriptor(FAKE_DNN_2, FAKE_OS_APP_ID_2),

                        new TrafficDescriptor(FAKE_DNN, FAKE_OS_APP_ID)))

                .setNetworkValidationStatus(PreciseDataConnectionState.NETWORK_VALIDATION_SUCCESS)

                .build();



        assertEquals(response2, response3);

        assertEquals(response2.getNetworkValidationStatus(),

                response3.getNetworkValidationStatus());

        assertEquals(response2.hashCode(), response3.hashCode());

    }

}

tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkControllerTest.java

+56 −0
Original line number Diff line number Diff line
@@ -4874,4 +4874,60 @@ public class DataNetworkControllerTest extends TelephonyTest { 
        verifyConnectedNetworkHasNoDataProfile(mNtnDataProfile);

        verifyConnectedNetworkHasNoDataProfile(mEsimBootstrapRcsInfraStructureProfile);

    }



    @Test

    public void testRequestNetworkValidationWithConnectedNetwork() throws Exception {

        // IMS preferred on IWLAN.

        doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager)

                .getPreferredTransportByNetworkCapability(

                        eq(NetworkCapabilities.NET_CAPABILITY_IMS));



        // Request IMS

        mDataNetworkControllerUT.addNetworkRequest(

                createNetworkRequest(NetworkCapabilities.NET_CAPABILITY_IMS,

                        NetworkCapabilities.NET_CAPABILITY_MMTEL));

        setSuccessfulSetupDataResponse(mMockedDataServiceManagers

                .get(AccessNetworkConstants.TRANSPORT_TYPE_WLAN), 3);

        processAllMessages();



        // Make sure IMS on IWLAN.

        verifyConnectedNetworkHasCapabilities(NetworkCapabilities.NET_CAPABILITY_IMS);

        DataNetwork dataNetwork = getDataNetworks().get(0);

        assertThat(dataNetwork.getTransport()).isEqualTo(

                AccessNetworkConstants.TRANSPORT_TYPE_WLAN);



        mDataNetworkControllerUT.requestNetworkValidation(NetworkCapabilities.NET_CAPABILITY_IMS,

                mIntegerConsumer);

        processAllMessages();

        assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isFalse();

    }



    @Test

    public void testRequestNetworkValidationWithNoConnectedNetwork()

            throws Exception {

        // IMS preferred on IWLAN.

        doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager)

                .getPreferredTransportByNetworkCapability(

                        eq(NetworkCapabilities.NET_CAPABILITY_IMS));



        // IMS On Wlan not connected

        verifyNoConnectedNetworkHasCapability(NetworkCapabilities.NET_CAPABILITY_IMS);



        //Connected List is Empty

        mDataNetworkControllerUT.requestNetworkValidation(NetworkCapabilities.NET_CAPABILITY_IMS,

                mIntegerConsumer);

        processAllMessages();

        assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isTrue();

        assertThat(mIntegerConsumerResult).isEqualTo(DataServiceCallback.RESULT_ERROR_INVALID_ARG);

    }



    @Test

    public void testRequestNetworkValidationWithInvalidArg() {

        mDataNetworkControllerUT.requestNetworkValidation(

                NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY,

                mIntegerConsumer);

        processAllMessages();

        assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isTrue();

        assertThat(mIntegerConsumerResult).isEqualTo(DataServiceCallback.RESULT_ERROR_INVALID_ARG);

    }

}

tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkTest.java

+172 −3
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ import static org.mockito.Mockito.doReturn; 
import static org.mockito.Mockito.never;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.net.ConnectivityManager;

import android.net.InetAddresses;
@@ -238,7 +239,8 @@ public class DataNetworkTest extends TelephonyTest { 
            final Message msg = (Message) invocation.getArguments()[10];



            DataCallResponse response = createDataCallResponse(

                    cid, DataCallResponse.LINK_STATUS_ACTIVE, tds, defaultQos);

                    cid, DataCallResponse.LINK_STATUS_ACTIVE, tds, defaultQos,

                    PreciseDataConnectionState.NETWORK_VALIDATION_UNSUPPORTED);

            msg.getData().putParcelable("data_call_response", response);

            msg.arg1 = DataServiceCallback.RESULT_SUCCESS;

            msg.sendToTarget();
@@ -249,7 +251,7 @@ public class DataNetworkTest extends TelephonyTest { 
    }



    private DataCallResponse createDataCallResponse(int cid, int linkStatus,

            List<TrafficDescriptor> tds, Qos defaultQos) {

            List<TrafficDescriptor> tds, Qos defaultQos, int validationStatus) {

        return new DataCallResponse.Builder()

                .setCause(0)

                .setRetryDurationMillis(-1L)
@@ -274,6 +276,7 @@ public class DataNetworkTest extends TelephonyTest { 
                .setQosBearerSessions(new ArrayList<>())

                .setTrafficDescriptors(tds)

                .setDefaultQos(defaultQos)

                .setNetworkValidationStatus(validationStatus)

                .build();

    }
@@ -1996,7 +1999,8 @@ public class DataNetworkTest extends TelephonyTest { 


        // data state updated

        DataCallResponse response = createDataCallResponse(123,

                DataCallResponse.LINK_STATUS_DORMANT, Collections.emptyList(), null);

                DataCallResponse.LINK_STATUS_DORMANT, Collections.emptyList(), null,

                PreciseDataConnectionState.NETWORK_VALIDATION_UNSUPPORTED);

        mDataNetworkUT.sendMessage(8 /*EVENT_DATA_STATE_CHANGED*/, new AsyncResult(

                AccessNetworkConstants.TRANSPORT_TYPE_WWAN, List.of(response), null));

        processAllMessages();
@@ -2017,6 +2021,171 @@ public class DataNetworkTest extends TelephonyTest { 
                eq(DataCallResponse.LINK_STATUS_INACTIVE));

    }



    @Test

    public void testHandleDataNetworkValidationRequestOnDataConnectedState() throws Exception {

        setupIwlanDataNetwork();



        // First Request

        mDataNetworkUT.requestNetworkValidation(mIntegerConsumer);

        processAllMessages();

        verify(mMockedWlanDataServiceManager).requestValidation(eq(123 /*cid*/),

                any(Message.class));



        // Duplicate Request

        mDataNetworkUT.requestNetworkValidation(mIntegerConsumer);

        processAllMessages();

        verify(mMockedWlanDataServiceManager).requestValidation(eq(123 /*cid*/),

                any(Message.class));

        assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isTrue();

        assertThat(mIntegerConsumerResult).isEqualTo(DataServiceCallback.RESULT_ERROR_BUSY);

    }



    @Test

    public void testHandleDataNetworkValidationRequestResultCode() throws Exception {

        setupDataNetwork();

        mDataNetworkUT.requestNetworkValidation(mIntegerConsumer);

        processAllMessages();



        mDataNetworkUT.sendMessage(29 /*EVENT_DATA_NETWORK_VALIDATION_RESPONSE*/,

                DataServiceCallback.RESULT_SUCCESS);

        processAllMessages();



        assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isTrue();

        assertThat(mIntegerConsumerResult).isEqualTo(DataServiceCallback.RESULT_SUCCESS);



        //mNetworkValidationResultCodeCallback null case

        mIntegerConsumerResult = DataServiceCallback.RESULT_ERROR_UNSUPPORTED;

        mDataNetworkUT.sendMessage(29 /*EVENT_DATA_NETWORK_VALIDATION_RESPONSE*/,

                DataServiceCallback.RESULT_SUCCESS);

        processAllMessages();

        assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isFalse();

        assertThat(mIntegerConsumerResult).isNotEqualTo(DataServiceCallback.RESULT_SUCCESS);

    }



    @Test

    public void testHandleDataNetworkValidationRequestNotConnectedState() throws Exception {

        NetworkRequestList networkRequestList = new NetworkRequestList();

        NetworkRequest.Builder builder = new NetworkRequest.Builder()

                .addCapability(NetworkCapabilities.NET_CAPABILITY_IMS);

        builder.addCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL);

        networkRequestList.add(new TelephonyNetworkRequest(builder.build(), mPhone));

        mDataNetworkUT = new DataNetwork(mPhone, mFeatureFlags, Looper.myLooper(),

                mDataServiceManagers, mImsDataProfile, networkRequestList,

                AccessNetworkConstants.TRANSPORT_TYPE_WLAN,

                DataAllowedReason.NORMAL, mDataNetworkCallback);

        replaceInstance(DataNetwork.class, "mDataCallSessionStats",

                mDataNetworkUT, mDataCallSessionStats);

        processAllMessages();



        // Data Not connected State

        mDataNetworkUT.requestNetworkValidation(mIntegerConsumer);

        processAllMessages();



        assertThat(waitForIntegerConsumerResponse(1 /*numOfEvents*/)).isTrue();

        assertThat(mIntegerConsumerResult)

                .isEqualTo(DataServiceCallback.RESULT_ERROR_ILLEGAL_STATE);

    }



    @Test

    public void testValidationStatusOnPreciseDataConnectionState_FlagEnabled() throws Exception {

        when(mFeatureFlags.networkValidation()).thenReturn(true);

        setupIwlanDataNetwork();



        ArgumentCaptor<PreciseDataConnectionState> pdcsCaptor =

                ArgumentCaptor.forClass(PreciseDataConnectionState.class);

        verify(mPhone, times(2)).notifyDataConnection(pdcsCaptor.capture());

        List<PreciseDataConnectionState> pdcsList = pdcsCaptor.getAllValues();



        assertThat(pdcsList.get(1).getApnSetting()).isEqualTo(mImsApnSetting);

        assertThat(pdcsList.get(1).getState()).isEqualTo(TelephonyManager.DATA_CONNECTED);

        assertThat(pdcsList.get(1).getNetworkType()).isEqualTo(TelephonyManager.NETWORK_TYPE_IWLAN);

        assertThat(pdcsList.get(1).getTransportType())

                .isEqualTo(AccessNetworkConstants.TRANSPORT_TYPE_WLAN);

        assertThat(pdcsList.get(1).getNetworkValidationStatus())

                .isEqualTo(PreciseDataConnectionState.NETWORK_VALIDATION_UNSUPPORTED);



        // Request Network Validation

        mDataNetworkUT.requestNetworkValidation(mIntegerConsumer);

        processAllMessages();

        verify(mMockedWlanDataServiceManager).requestValidation(eq(123 /*cid*/),

                any(Message.class));



        // data state updated with network validation status

        DataCallResponse response = createDataCallResponse(123,

                DataCallResponse.LINK_STATUS_ACTIVE, Collections.emptyList(), null,

                PreciseDataConnectionState.NETWORK_VALIDATION_SUCCESS);

        mDataNetworkUT.sendMessage(8 /*EVENT_DATA_STATE_CHANGED*/, new AsyncResult(

                AccessNetworkConstants.TRANSPORT_TYPE_WLAN, List.of(response), null));

        processAllMessages();



        // Verify updated validation status at precise data connection state

        pdcsCaptor = ArgumentCaptor.forClass(PreciseDataConnectionState.class);

        verify(mPhone, times(3)).notifyDataConnection(pdcsCaptor.capture());





        // data state updated with same network validation status

        response = createDataCallResponse(123,

                DataCallResponse.LINK_STATUS_ACTIVE, Collections.emptyList(), null,

                PreciseDataConnectionState.NETWORK_VALIDATION_SUCCESS);

        mDataNetworkUT.sendMessage(8 /*EVENT_DATA_STATE_CHANGED*/, new AsyncResult(

                AccessNetworkConstants.TRANSPORT_TYPE_WLAN, List.of(response), null));

        processAllMessages();



        // Verify precise data connection state not posted again

        pdcsCaptor = ArgumentCaptor.forClass(PreciseDataConnectionState.class);

        verify(mPhone, times(3)).notifyDataConnection(pdcsCaptor.capture());

    }



    @Test

    public void testValidationStatus_FlagDisabled() throws Exception {

        // network validation flag disabled

        when(mFeatureFlags.networkValidation()).thenReturn(false);

        setupIwlanDataNetwork();



        // precise data connection state posted for setup data call response

        ArgumentCaptor<PreciseDataConnectionState> pdcsCaptor =

                ArgumentCaptor.forClass(PreciseDataConnectionState.class);

        verify(mPhone, times(2)).notifyDataConnection(pdcsCaptor.capture());



        // data state updated with network validation status

        DataCallResponse response = createDataCallResponse(123,

                DataCallResponse.LINK_STATUS_ACTIVE, Collections.emptyList(), null,

                PreciseDataConnectionState.NETWORK_VALIDATION_SUCCESS);

        mDataNetworkUT.sendMessage(8 /*EVENT_DATA_STATE_CHANGED*/, new AsyncResult(

                AccessNetworkConstants.TRANSPORT_TYPE_WLAN, List.of(response), null));

        processAllMessages();



        // Verify updated validation status at precise data connection state not posted due to flag

        // disabled

        pdcsCaptor = ArgumentCaptor.forClass(PreciseDataConnectionState.class);

        verify(mPhone, times(2)).notifyDataConnection(pdcsCaptor.capture());

        List<PreciseDataConnectionState> pdcsList = pdcsCaptor.getAllValues();

        assertThat(pdcsList.get(1).getNetworkValidationStatus())

                .isEqualTo(PreciseDataConnectionState.NETWORK_VALIDATION_UNSUPPORTED);

    }



    private void setupIwlanDataNetwork() throws Exception {

        // setup iwlan data network over ims

        doReturn(mIwlanNetworkRegistrationInfo).when(mServiceState).getNetworkRegistrationInfo(

                eq(NetworkRegistrationInfo.DOMAIN_PS),

                eq(AccessNetworkConstants.TRANSPORT_TYPE_WLAN));

        doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WLAN).when(mAccessNetworksManager)

                .getPreferredTransportByNetworkCapability(NetworkCapabilities.NET_CAPABILITY_IMS);



        NetworkRequestList networkRequestList = new NetworkRequestList();

        networkRequestList.add(new TelephonyNetworkRequest(new NetworkRequest.Builder()

                .addCapability(NetworkCapabilities.NET_CAPABILITY_IMS)

                .build(), mPhone));

        setSuccessfulSetupDataResponse(mMockedWlanDataServiceManager, 123);

        mDataNetworkUT = new DataNetwork(mPhone, mFeatureFlags, Looper.myLooper(),

                mDataServiceManagers, mImsDataProfile, networkRequestList,

                AccessNetworkConstants.TRANSPORT_TYPE_WLAN,

                DataAllowedReason.NORMAL, mDataNetworkCallback);

        replaceInstance(DataNetwork.class, "mDataCallSessionStats",

                mDataNetworkUT, mDataCallSessionStats);

        processAllMessages();

    }



    private void createImsDataNetwork(boolean isMmtel) throws Exception {

        NetworkRequestList networkRequestList = new NetworkRequestList();

        NetworkRequest.Builder builder = new NetworkRequest.Builder()