Update N1 mode when preferred network type change via UI/UX

Enables a 5G SA capable UE to re-establish PDN connections over Wi-Fi with/without N1_MODE_CAPABILITY, when the user enables/disables 5G via UI/UX.

Bug: 273384888
Test: atest IwlanTests (new test cases)
Test: On-device Test
Change-Id: Ib287339a5c9f1b2c73e3f07200cdccaedbd8a680

3 files changed, 339 insertions, 57 deletions

diff --git a/test/com/google/android/iwlan/IwlanDataServiceTest.java b/test/com/google/android/iwlan/IwlanDataServiceTest.java
index c2b4e28..5ef5009 100644
--- a/test/com/google/android/iwlan/IwlanDataServiceTest.java
+++ b/test/com/google/android/iwlan/IwlanDataServiceTest.java
@@ -19,6 +19,11 @@ package com.google.android.iwlan;
 import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
 import static android.net.NetworkCapabilities.TRANSPORT_ETHERNET;
 import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
+import static android.net.ipsec.ike.ike3gpp.Ike3gppParams.PDU_SESSION_ID_UNSET;
+import static android.telephony.TelephonyManager.CALL_STATE_IDLE;
+import static android.telephony.TelephonyManager.CALL_STATE_RINGING;
+import static android.telephony.TelephonyManager.NETWORK_TYPE_BITMASK_LTE;
+import static android.telephony.TelephonyManager.NETWORK_TYPE_BITMASK_NR;
 
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession;
 
@@ -56,8 +61,10 @@ import android.net.NetworkCapabilities;
 import android.net.TelephonyNetworkSpecifier;
 import android.net.ipsec.ike.exceptions.IkeInternalException;
 import android.net.vcn.VcnTransportInfo;
+import android.os.PersistableBundle;
 import android.os.test.TestLooper;
 import android.telephony.AccessNetworkConstants.AccessNetworkType;
+import android.telephony.CarrierConfigManager;
 import android.telephony.DataFailCause;
 import android.telephony.SubscriptionInfo;
 import android.telephony.SubscriptionManager;
@@ -80,6 +87,7 @@ import com.google.android.iwlan.epdg.EpdgTunnelManager;
 import com.google.android.iwlan.epdg.NetworkSliceSelectionAssistanceInformation;
 import com.google.android.iwlan.epdg.TunnelLinkProperties;
 import com.google.android.iwlan.epdg.TunnelSetupRequest;
+import com.google.android.iwlan.flags.FeatureFlags;
 import com.google.android.iwlan.proto.MetricsAtom;
 
 import org.junit.After;
@@ -133,6 +141,8 @@ public class IwlanDataServiceTest {
     @Mock private LinkAddress mMockIPv6LinkAddress;
     @Mock private Inet4Address mMockInet4Address;
     @Mock private Inet6Address mMockInet6Address;
+    @Mock private CarrierConfigManager mMockCarrierConfigManager;
+    @Mock private FeatureFlags mFakeFeatureFlags;
 
     MockitoSession mStaticMockSession;
 
@@ -249,7 +259,10 @@ public class IwlanDataServiceTest {
         when(mMockIPv4LinkAddress.getAddress()).thenReturn(mMockInet4Address);
         when(mMockIPv6LinkAddress.getAddress()).thenReturn(mMockInet6Address);
 
-        mIwlanDataService = spy(new IwlanDataService());
+        mIwlanDataService = spy(new IwlanDataService(mFakeFeatureFlags));
+
+        when(mMockContext.getSystemService(eq(CarrierConfigManager.class)))
+                .thenReturn(mMockCarrierConfigManager);
         // Injects the test looper into the IwlanDataServiceHandler
         doReturn(mTestLooper.getLooper()).when(mIwlanDataService).getLooper();
         mIwlanDataService.setAppContext(mMockContext);
@@ -1117,7 +1130,7 @@ public class IwlanDataServiceTest {
                 .obtainMessage(
                         IwlanEventListener.CALL_STATE_CHANGED_EVENT,
                         DEFAULT_SLOT_INDEX,
-                        TelephonyManager.CALL_STATE_IDLE)
+                        CALL_STATE_IDLE)
                 .sendToTarget();
 
         mSpyIwlanDataServiceProvider.setTunnelState(
@@ -1175,7 +1188,7 @@ public class IwlanDataServiceTest {
                 .obtainMessage(
                         IwlanEventListener.CALL_STATE_CHANGED_EVENT,
                         DEFAULT_SLOT_INDEX,
-                        TelephonyManager.CALL_STATE_IDLE)
+                        CALL_STATE_IDLE)
                 .sendToTarget();
 
         mSpyIwlanDataServiceProvider.setTunnelState(
@@ -1671,7 +1684,7 @@ public class IwlanDataServiceTest {
                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
 
         // Simulate IwlanDataService.onUnbind() which force close all tunnels
-        mSpyIwlanDataServiceProvider.forceCloseTunnels();
+        mSpyIwlanDataServiceProvider.forceCloseTunnels(EpdgTunnelManager.BRINGDOWN_REASON_UNKNOWN);
         // Simulate DataService.onUnbind() which remove all IwlanDataServiceProviders
         mSpyIwlanDataServiceProvider.close();
         mTestLooper.dispatchAll();
@@ -1681,7 +1694,8 @@ public class IwlanDataServiceTest {
                         eq(TEST_APN_NAME),
                         eq(true),
                         any(IwlanTunnelCallback.class),
-                        any(IwlanTunnelMetricsImpl.class));
+                        any(IwlanTunnelMetricsImpl.class),
+                        eq(EpdgTunnelManager.BRINGDOWN_REASON_UNKNOWN));
         assertNotNull(mIwlanDataService.mIwlanDataServiceHandler);
         // Should not raise NullPointerException
         mSpyIwlanDataServiceProvider
@@ -2003,4 +2017,249 @@ public class IwlanDataServiceTest {
                 .setSliceInfo(SLICE_INFO)
                 .build();
     }
+
+    private void setupMockForGetConfig(PersistableBundle bundle) {
+        if (bundle == null) {
+            bundle = new PersistableBundle();
+        }
+        when(mMockContext.getSystemService(eq(CarrierConfigManager.class)))
+                .thenReturn(mMockCarrierConfigManager);
+        when(mMockCarrierConfigManager.getConfigForSubId(DEFAULT_SLOT_INDEX)).thenReturn(bundle);
+    }
+
+    private void mockCarrierConfigForN1Mode(boolean supportN1Mode) {
+        PersistableBundle bundle = new PersistableBundle();
+        if (supportN1Mode) {
+            bundle.putIntArray(
+                    CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY,
+                    new int[] {
+                        CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA,
+                        CarrierConfigManager.CARRIER_NR_AVAILABILITY_SA
+                    });
+        } else {
+            bundle.putIntArray(
+                    CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY,
+                    new int[] {CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA});
+        }
+        setupMockForGetConfig(bundle);
+    }
+
+    private void mockCallState(int callState) {
+        onSystemDefaultNetworkConnected(TRANSPORT_CELLULAR);
+
+        mIwlanDataService
+                .mIwlanDataServiceHandler
+                .obtainMessage(
+                        IwlanEventListener.CALL_STATE_CHANGED_EVENT, DEFAULT_SLOT_INDEX, callState)
+                .sendToTarget();
+
+        mSpyIwlanDataServiceProvider.setMetricsAtom(
+                TEST_APN_NAME, 64, true, TelephonyManager.NETWORK_TYPE_LTE, false, true, 1);
+    }
+
+    private void updatePreferredNetworkType(long networkTypeBitmask) {
+        mIwlanDataService
+                .mIwlanDataServiceHandler
+                .obtainMessage(
+                        IwlanEventListener.PREFERRED_NETWORK_TYPE_CHANGED_EVENT,
+                        DEFAULT_SLOT_INDEX,
+                        0 /* unused */,
+                        networkTypeBitmask)
+                .sendToTarget();
+        mTestLooper.dispatchAll();
+    }
+
+    @Test
+    public void testIsN1ModeSupported() {
+        PersistableBundle bundle = new PersistableBundle();
+        bundle.putIntArray(
+                CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY,
+                new int[] {
+                    CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA,
+                    CarrierConfigManager.CARRIER_NR_AVAILABILITY_SA
+                });
+        setupMockForGetConfig(bundle);
+        assertTrue(mSpyIwlanDataServiceProvider.isN1ModeSupported());
+
+        bundle.putIntArray(
+                CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY,
+                new int[] {
+                    CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA,
+                });
+        setupMockForGetConfig(bundle);
+        assertFalse(mSpyIwlanDataServiceProvider.isN1ModeSupported());
+    }
+
+    @Test
+    public void testMultipleAllowedNetworkTypeChangeInIdle_updateN1Mode() throws Exception {
+        when(mFakeFeatureFlags.updateN1ModeOnUiChange()).thenReturn(true);
+        mockCarrierConfigForN1Mode(true);
+        mockCallState(CALL_STATE_IDLE);
+        mockSetupDataCallWithPduSessionId(0);
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
+
+        /* Check closeTunnel() is called. */
+        verify(mMockEpdgTunnelManager, atLeastOnce())
+                .closeTunnel(
+                        eq(TEST_APN_NAME),
+                        eq(true),
+                        any(IwlanTunnelCallback.class),
+                        any(IwlanTunnelMetricsImpl.class),
+                        eq(EpdgTunnelManager.BRINGDOWN_REASON_ENABLE_N1_MODE));
+
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_LTE);
+
+        verify(mMockEpdgTunnelManager, atLeastOnce())
+                .closeTunnel(
+                        eq(TEST_APN_NAME),
+                        eq(true),
+                        any(IwlanTunnelCallback.class),
+                        any(IwlanTunnelMetricsImpl.class),
+                        eq(EpdgTunnelManager.BRINGDOWN_REASON_DISABLE_N1_MODE));
+    }
+
+    @Test
+    public void testMultipleAllowedNetworkTypeChangeInCall_preferenceChanged_updateAfterCallEnds()
+            throws Exception {
+        when(mFakeFeatureFlags.updateN1ModeOnUiChange()).thenReturn(true);
+        mockCarrierConfigForN1Mode(true);
+        mockCallState(CALL_STATE_RINGING);
+        mockSetupDataCallWithPduSessionId(0);
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_LTE);
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
+
+        verify(mMockEpdgTunnelManager, never())
+                .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
+
+        // in idle call state
+        mIwlanDataService
+                .mIwlanDataServiceHandler
+                .obtainMessage(
+                        IwlanEventListener.CALL_STATE_CHANGED_EVENT,
+                        DEFAULT_SLOT_INDEX,
+                        CALL_STATE_IDLE)
+                .sendToTarget();
+        mTestLooper.dispatchAll();
+
+        verify(mMockEpdgTunnelManager, atLeastOnce())
+                .closeTunnel(
+                        eq(TEST_APN_NAME),
+                        eq(true),
+                        any(IwlanTunnelCallback.class),
+                        any(IwlanTunnelMetricsImpl.class),
+                        eq(EpdgTunnelManager.BRINGDOWN_REASON_ENABLE_N1_MODE));
+    }
+
+    @Test
+    public void testMultipleAllowedNetworkTypeChangeInCall_preferenceNotChanged_noUpdate()
+            throws Exception {
+        when(mFakeFeatureFlags.updateN1ModeOnUiChange()).thenReturn(true);
+        mockCarrierConfigForN1Mode(true);
+        mockCallState(CALL_STATE_RINGING);
+        mockSetupDataCallWithPduSessionId(0);
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_LTE);
+
+        verify(mMockEpdgTunnelManager, never())
+                .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
+
+        // in idle call state
+        mIwlanDataService
+                .mIwlanDataServiceHandler
+                .obtainMessage(
+                        IwlanEventListener.CALL_STATE_CHANGED_EVENT,
+                        DEFAULT_SLOT_INDEX,
+                        CALL_STATE_IDLE)
+                .sendToTarget();
+        mTestLooper.dispatchAll();
+
+        verify(mMockEpdgTunnelManager, never())
+                .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
+    }
+
+    @Test
+    public void testOnAllowedNetworkTypeChange_flagDisabled_noTunnelClose() {
+        when(mFakeFeatureFlags.updateN1ModeOnUiChange()).thenReturn(false);
+        mockCarrierConfigForN1Mode(true);
+        mockCallState(CALL_STATE_IDLE);
+        mockSetupDataCallWithPduSessionId(0);
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
+
+        verify(mMockEpdgTunnelManager, never())
+                .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
+    }
+
+    @Test
+    public void testOnAllowedNetworkTypeChange_n1ModeNotSupported_noTunnelClose() {
+        when(mFakeFeatureFlags.updateN1ModeOnUiChange()).thenReturn(true);
+        mockCarrierConfigForN1Mode(false);
+        mockCallState(CALL_STATE_IDLE);
+        mockSetupDataCallWithPduSessionId(0);
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
+
+        verify(mMockEpdgTunnelManager, never())
+                .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
+    }
+
+    @Test
+    public void testN1ModeNotSupported_tunnelBringupWithNoN1ModeCapability() {
+        when(mFakeFeatureFlags.updateN1ModeOnUiChange()).thenReturn(true);
+        mockCarrierConfigForN1Mode(false);
+        mockSetupDataCallWithPduSessionId(1);
+
+        ArgumentCaptor<TunnelSetupRequest> tunnelSetupRequestCaptor =
+                ArgumentCaptor.forClass(TunnelSetupRequest.class);
+        verify(mMockEpdgTunnelManager, times(1))
+                .bringUpTunnel(tunnelSetupRequestCaptor.capture(), any(), any());
+        TunnelSetupRequest tunnelSetupRequest = tunnelSetupRequestCaptor.getValue();
+        assertEquals(PDU_SESSION_ID_UNSET, tunnelSetupRequest.getPduSessionId());
+    }
+
+    @Test
+    public void testNoN1ModeCapabilityInOngoingDataCall_newTunnelBringup_doNotIncludeN1() {
+        when(mFakeFeatureFlags.updateN1ModeOnUiChange()).thenReturn(true);
+        mockCarrierConfigForN1Mode(true);
+        mockSetupDataCallWithPduSessionId(0);
+
+        ArgumentCaptor<TunnelSetupRequest> tunnelSetupRequestCaptor =
+                ArgumentCaptor.forClass(TunnelSetupRequest.class);
+        verify(mMockEpdgTunnelManager, times(1))
+                .bringUpTunnel(tunnelSetupRequestCaptor.capture(), any(), any());
+        TunnelSetupRequest tunnelSetupRequest = tunnelSetupRequestCaptor.getValue();
+        assertEquals(PDU_SESSION_ID_UNSET, tunnelSetupRequest.getPduSessionId());
+
+        updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
+        mockSetupDataCallWithPduSessionId(1);
+
+        verify(mMockEpdgTunnelManager, times(1))
+                .bringUpTunnel(tunnelSetupRequestCaptor.capture(), any(), any());
+        tunnelSetupRequest = tunnelSetupRequestCaptor.getValue();
+        assertEquals(PDU_SESSION_ID_UNSET, tunnelSetupRequest.getPduSessionId());
+    }
+
+    private void mockSetupDataCallWithPduSessionId(int pduSessionId) {
+        DataProfile dp = buildImsDataProfile();
+        onSystemDefaultNetworkConnected(
+                mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
+        mSpyIwlanDataServiceProvider.setupDataCall(
+                AccessNetworkType.IWLAN, /* AccessNetworkType */
+                dp, /* dataProfile */
+                false, /* isRoaming */
+                false, /* allowRoaming */
+                DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
+                null, /* LinkProperties */
+                pduSessionId, /* pduSessionId */
+                null, /* sliceInfo */
+                null, /* trafficDescriptor */
+                true, /* matchAllRuleAllowed */
+                mMockDataServiceCallback);
+        mTestLooper.dispatchAll();
+
+        verify(mMockEpdgTunnelManager, times(1))
+                .bringUpTunnel(
+                        any(TunnelSetupRequest.class),
+                        any(IwlanTunnelCallback.class),
+                        any(IwlanTunnelMetricsImpl.class));
+    }
 }
diff --git a/test/com/google/android/iwlan/IwlanEventListenerTest.java b/test/com/google/android/iwlan/IwlanEventListenerTest.java
index 1552c97..a922a10 100644
--- a/test/com/google/android/iwlan/IwlanEventListenerTest.java
+++ b/test/com/google/android/iwlan/IwlanEventListenerTest.java
@@ -18,8 +18,17 @@ package com.google.android.iwlan;
 
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession;
 
-import static org.mockito.Mockito.*;
-
+import static org.mockito.Mockito.anyInt;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.annotation.SuppressLint;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.net.Uri;
@@ -35,6 +44,8 @@ import android.telephony.TelephonyManager;
 import android.telephony.ims.ImsManager;
 import android.telephony.ims.ImsMmTelManager;
 
+import com.google.android.iwlan.flags.FeatureFlags;
+
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -42,7 +53,8 @@ import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.MockitoSession;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
 
 public class IwlanEventListenerTest {
     private static final String TAG = "IwlanEventListenerTest";
@@ -59,6 +71,7 @@ public class IwlanEventListenerTest {
     @Mock private ImsManager mMockImsManager;
     @Mock private ImsMmTelManager mMockImsMmTelManager;
     @Mock private TelephonyManager mMockTelephonyManager;
+    @Mock private FeatureFlags mFakeFeatureFlags;
 
     private static final int DEFAULT_SLOT_INDEX = 0;
     private static final int OTHER_SLOT_INDEX = 1;
@@ -70,6 +83,7 @@ public class IwlanEventListenerTest {
             Uri.parse("content://telephony/siminfo/cross_sim_calling_enabled/2");
     private static final Uri WFC_ENABLED_URI = Uri.parse("content://telephony/siminfo/wfc/2");
     private IwlanEventListener mIwlanEventListener;
+    private IwlanEventListener mSpyIwlanEventListener;
     private List<Integer> events;
 
     MockitoSession mStaticMockSession;
@@ -111,6 +125,8 @@ public class IwlanEventListenerTest {
 
         IwlanEventListener.resetAllInstances();
         mIwlanEventListener = IwlanEventListener.getInstance(mMockContext, DEFAULT_SLOT_INDEX);
+        mSpyIwlanEventListener =
+                spy(new IwlanEventListener(mMockContext, DEFAULT_SLOT_INDEX, mFakeFeatureFlags));
     }
 
     @After
@@ -348,4 +364,54 @@ public class IwlanEventListenerTest {
         mIwlanEventListener.notifyCurrentSetting(WFC_ENABLED_URI);
         verify(mMockMessage, times(1)).sendToTarget();
     }
+
+    @SuppressLint("MissingPermission")
+    @Test
+    public void testDisable5gViaUi() throws Exception {
+        when(mFakeFeatureFlags.updateN1ModeOnUiChange()).thenReturn(true);
+
+        when(mMockHandler.obtainMessage(
+                        eq(IwlanEventListener.PREFERRED_NETWORK_TYPE_CHANGED_EVENT),
+                        eq(DEFAULT_SLOT_INDEX),
+                        anyInt(),
+                        eq(TelephonyManager.NETWORK_TYPE_BITMASK_LTE)))
+                .thenReturn(mMockMessage);
+
+        events = new ArrayList<>();
+        events.add(IwlanEventListener.PREFERRED_NETWORK_TYPE_CHANGED_EVENT);
+        mIwlanEventListener.addEventListener(events, mMockHandler);
+        mSpyIwlanEventListener.registerTelephonyCallback();
+        TelephonyCallback.AllowedNetworkTypesListener mTelephonyCallback =
+                mSpyIwlanEventListener.getTelephonyCallback();
+
+        mTelephonyCallback.onAllowedNetworkTypesChanged(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,
+                TelephonyManager.NETWORK_TYPE_BITMASK_LTE);
+        verify(mMockMessage, times(1)).sendToTarget();
+    }
+
+    @SuppressLint("MissingPermission")
+    @Test
+    public void testEnable5gViaUi() throws Exception {
+        when(mFakeFeatureFlags.updateN1ModeOnUiChange()).thenReturn(true);
+
+        when(mMockHandler.obtainMessage(
+                        eq(IwlanEventListener.PREFERRED_NETWORK_TYPE_CHANGED_EVENT),
+                        eq(DEFAULT_SLOT_INDEX),
+                        anyInt(),
+                        eq(TelephonyManager.NETWORK_TYPE_BITMASK_NR)))
+                .thenReturn(mMockMessage);
+
+        events = new ArrayList<>();
+        events.add(IwlanEventListener.PREFERRED_NETWORK_TYPE_CHANGED_EVENT);
+        mIwlanEventListener.addEventListener(events, mMockHandler);
+        mSpyIwlanEventListener.registerTelephonyCallback();
+        TelephonyCallback.AllowedNetworkTypesListener mTelephonyCallback =
+                mSpyIwlanEventListener.getTelephonyCallback();
+
+        mTelephonyCallback.onAllowedNetworkTypesChanged(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,
+                TelephonyManager.NETWORK_TYPE_BITMASK_NR);
+        verify(mMockMessage, times(1)).sendToTarget();
+    }
 }
diff --git a/test/com/google/android/iwlan/epdg/EpdgTunnelManagerTest.java b/test/com/google/android/iwlan/epdg/EpdgTunnelManagerTest.java
index fe2cf94..ff413b5 100644
--- a/test/com/google/android/iwlan/epdg/EpdgTunnelManagerTest.java
+++ b/test/com/google/android/iwlan/epdg/EpdgTunnelManagerTest.java
@@ -1867,23 +1867,13 @@ public class EpdgTunnelManagerTest {
     }
 
     @Test
-    public void testEnableN1modeCapabilityWithValidPduSessionId_nonInclusion() throws Exception {
-        verifyN1modeCapability(0, false);
+    public void testUnsetPduSessionIdInclusion() throws Exception {
+        verifyN1modeCapability(0);
     }
 
     @Test
-    public void testDisableN1modeCapabilityWithInvalidPduSessionId_nonInclusion() throws Exception {
-        verifyN1modeCapability(0, false);
-    }
-
-    @Test
-    public void testEnableN1modeCapabilityWithValidPduSessionId_inclusion() throws Exception {
-        verifyN1modeCapability(8, true);
-    }
-
-    @Test
-    public void testDisableN1modeCapabilityWithValidPduSessionId_nonInclusion() throws Exception {
-        verifyN1modeCapability(8, false);
+    public void testPduSessionIdInclusion() throws Exception {
+        verifyN1modeCapability(8);
     }
 
     @Test
@@ -1992,9 +1982,7 @@ public class EpdgTunnelManagerTest {
         verify(mMockIwlanTunnelCallback, times(1)).onClosed(eq(testApnName), eq(error));
     }
 
-    private void verifyN1modeCapability(int pduSessionId, boolean isN1ModeSupported)
-            throws Exception {
-        doReturn(isN1ModeSupported).when(mEpdgTunnelManager).isN1ModeSupported();
+    private void verifyN1modeCapability(int pduSessionId) throws Exception {
 
         String testApnName = "www.xyz.com";
         byte pduSessionIdToByte = (byte) pduSessionId;
@@ -2048,11 +2036,7 @@ public class EpdgTunnelManagerTest {
 
         byte pduSessionIdByte =
                 ikeSessionParams.getIke3gppExtension().getIke3gppParams().getPduSessionId();
-        if (isN1ModeSupported && pduSessionId != 0) {
-            assertEquals(pduSessionIdToByte, pduSessionIdByte);
-        } else {
-            assertEquals(0, pduSessionIdByte);
-        }
+        assertEquals(pduSessionIdToByte, pduSessionIdByte);
     }
 
     @Test
@@ -2632,33 +2616,6 @@ public class EpdgTunnelManagerTest {
         verify(mMockIwlanTunnelCallback, times(1)).onClosed(eq(TEST_APN_NAME), eq(error));
     }
 
-    private boolean verifyIsN1ModeSupported(int[] nrAvailability) {
-        PersistableBundle bundle = new PersistableBundle();
-        bundle.putIntArray(
-                CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY, nrAvailability);
-
-        setupMockForGetConfig(bundle);
-
-        return mEpdgTunnelManager.isN1ModeSupported();
-    }
-
-    @Test
-    public void testIsN1ModeSupportedTrue() throws Exception {
-        assertTrue(
-                verifyIsN1ModeSupported(
-                        new int[] {
-                            CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA,
-                            CarrierConfigManager.CARRIER_NR_AVAILABILITY_SA
-                        }));
-    }
-
-    @Test
-    public void testIsN1ModeSupportedFalse() throws Exception {
-        assertFalse(
-                verifyIsN1ModeSupported(
-                        new int[] {CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA}));
-    }
-
     @Test
     public void testUpdateNetworkToOpenedTunnel() throws Exception {
         String apnName = "ims";