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
Loading
Loading
Loading
Loading
+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;
+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);
    }

}
+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());
    }
}
+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);
    }
}
+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()
Loading