• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2020 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.android.iwlan;
18 
19 import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
20 import static android.net.NetworkCapabilities.TRANSPORT_ETHERNET;
21 import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
22 import static android.net.ipsec.ike.ike3gpp.Ike3gppParams.PDU_SESSION_ID_UNSET;
23 import static android.telephony.TelephonyManager.CALL_STATE_IDLE;
24 import static android.telephony.TelephonyManager.CALL_STATE_RINGING;
25 import static android.telephony.TelephonyManager.NETWORK_TYPE_BITMASK_LTE;
26 import static android.telephony.TelephonyManager.NETWORK_TYPE_BITMASK_NR;
27 
28 import static com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession;
29 
30 import static com.google.android.iwlan.epdg.EpdgTunnelManager.BRINGDOWN_REASON_DEACTIVATE_DATA_CALL;
31 import static com.google.android.iwlan.epdg.EpdgTunnelManager.BRINGDOWN_REASON_NETWORK_UPDATE_WHEN_TUNNEL_IN_BRINGUP;
32 import static com.google.android.iwlan.epdg.EpdgTunnelManager.BRINGDOWN_REASON_SERVICE_OUT_OF_SYNC;
33 
34 import static org.junit.Assert.assertEquals;
35 import static org.junit.Assert.assertFalse;
36 import static org.junit.Assert.assertNotEquals;
37 import static org.junit.Assert.assertNotNull;
38 import static org.junit.Assert.assertNull;
39 import static org.junit.Assert.assertThrows;
40 import static org.junit.Assert.assertTrue;
41 import static org.mockito.ArgumentMatchers.isNull;
42 import static org.mockito.Mockito.any;
43 import static org.mockito.Mockito.anyBoolean;
44 import static org.mockito.Mockito.anyInt;
45 import static org.mockito.Mockito.atLeastOnce;
46 import static org.mockito.Mockito.clearInvocations;
47 import static org.mockito.Mockito.doNothing;
48 import static org.mockito.Mockito.doReturn;
49 import static org.mockito.Mockito.eq;
50 import static org.mockito.Mockito.lenient;
51 import static org.mockito.Mockito.mock;
52 import static org.mockito.Mockito.never;
53 import static org.mockito.Mockito.spy;
54 import static org.mockito.Mockito.timeout;
55 import static org.mockito.Mockito.times;
56 import static org.mockito.Mockito.verify;
57 import static org.mockito.Mockito.when;
58 
59 import android.content.ContentResolver;
60 import android.content.Context;
61 import android.net.ConnectivityManager;
62 import android.net.ConnectivityManager.NetworkCallback;
63 import android.net.LinkAddress;
64 import android.net.LinkProperties;
65 import android.net.Network;
66 import android.net.NetworkCapabilities;
67 import android.net.TelephonyNetworkSpecifier;
68 import android.net.ipsec.ike.exceptions.IkeInternalException;
69 import android.net.vcn.VcnTransportInfo;
70 import android.os.PersistableBundle;
71 import android.os.test.TestLooper;
72 import android.telephony.AccessNetworkConstants.AccessNetworkType;
73 import android.telephony.CarrierConfigManager;
74 import android.telephony.DataFailCause;
75 import android.telephony.PreciseDataConnectionState;
76 import android.telephony.SubscriptionInfo;
77 import android.telephony.SubscriptionManager;
78 import android.telephony.TelephonyManager;
79 import android.telephony.data.ApnSetting;
80 import android.telephony.data.DataCallResponse;
81 import android.telephony.data.DataProfile;
82 import android.telephony.data.DataService;
83 import android.telephony.data.DataServiceCallback;
84 import android.telephony.data.IDataServiceCallback;
85 import android.telephony.data.NetworkSliceInfo;
86 import android.telephony.data.TrafficDescriptor;
87 import android.telephony.ims.ImsManager;
88 import android.telephony.ims.ImsMmTelManager;
89 
90 import com.google.android.iwlan.IwlanDataService.IwlanDataServiceProvider;
91 import com.google.android.iwlan.IwlanDataService.IwlanDataServiceProvider.IwlanTunnelCallback;
92 import com.google.android.iwlan.IwlanDataService.IwlanDataServiceProvider.TunnelState;
93 import com.google.android.iwlan.epdg.EpdgSelector;
94 import com.google.android.iwlan.epdg.EpdgTunnelManager;
95 import com.google.android.iwlan.epdg.NetworkSliceSelectionAssistanceInformation;
96 import com.google.android.iwlan.epdg.TunnelLinkProperties;
97 import com.google.android.iwlan.epdg.TunnelSetupRequest;
98 import com.google.android.iwlan.flags.FeatureFlags;
99 import com.google.android.iwlan.proto.MetricsAtom;
100 
101 import org.junit.After;
102 import org.junit.Before;
103 import org.junit.Test;
104 import org.mockito.ArgumentCaptor;
105 import org.mockito.Mock;
106 import org.mockito.MockitoAnnotations;
107 import org.mockito.MockitoSession;
108 import org.mockito.quality.Strictness;
109 
110 import java.lang.reflect.Method;
111 import java.net.Inet4Address;
112 import java.net.Inet6Address;
113 import java.net.InetAddress;
114 import java.util.ArrayList;
115 import java.util.Calendar;
116 import java.util.Collections;
117 import java.util.Date;
118 import java.util.List;
119 import java.util.LongSummaryStatistics;
120 
121 public class IwlanDataServiceTest {
122     private static final int DEFAULT_SLOT_INDEX = 0;
123     private static final int DEFAULT_SUB_INDEX = 0;
124     private static final int INVALID_SUB_INDEX = -1;
125     private static final int LINK_MTU = 1280;
126     private static final String TEST_APN_NAME = "ims";
127     private static final String IP_ADDRESS = "192.0.2.1";
128     private static final String DNS_ADDRESS = "8.8.8.8";
129     private static final String GATEWAY_ADDRESS = "0.0.0.0";
130     private static final String PSCF_ADDRESS = "10.159.204.230";
131     private static final String INTERFACE_NAME = "ipsec6";
132 
133     @Mock private Context mMockContext;
134     @Mock private SubscriptionManager mMockSubscriptionManager;
135     @Mock private SubscriptionInfo mMockSubscriptionInfo;
136     @Mock private ContentResolver mMockContentResolver;
137     @Mock private ConnectivityManager mMockConnectivityManager;
138     @Mock private DataServiceCallback mMockDataServiceCallback;
139     @Mock private EpdgTunnelManager mMockEpdgTunnelManager;
140     @Mock private IwlanDataServiceProvider mMockIwlanDataServiceProvider;
141     @Mock private Network mMockNetwork;
142     @Mock private TunnelLinkProperties mMockTunnelLinkProperties;
143     @Mock private ErrorPolicyManager mMockErrorPolicyManager;
144     @Mock private ImsManager mMockImsManager;
145     @Mock private ImsMmTelManager mMockImsMmTelManager;
146     @Mock private TelephonyManager mMockTelephonyManager;
147     @Mock private EpdgSelector mMockEpdgSelector;
148     @Mock private LinkAddress mMockIPv4LinkAddress;
149     @Mock private LinkAddress mMockIPv6LinkAddress;
150     @Mock private Inet4Address mMockInet4Address;
151     @Mock private Inet6Address mMockInet6Address;
152     @Mock private FeatureFlags mFakeFeatureFlags;
153 
154     MockitoSession mStaticMockSession;
155 
156     private LinkProperties mLinkProperties;
157     private List<DataCallResponse> mResultDataCallList;
158     private @DataServiceCallback.ResultCode int mResultCode;
159     private IwlanDataService mIwlanDataService;
160     private IwlanDataServiceProvider mSpyIwlanDataServiceProvider;
161     private final TestLooper mTestLooper = new TestLooper();
162     private long mMockedCalendarTime;
163     private final ArgumentCaptor<NetworkCallback> mNetworkCallbackCaptor =
164             ArgumentCaptor.forClass(NetworkCallback.class);
165 
166     private final class IwlanDataServiceCallback extends IDataServiceCallback.Stub {
167 
168         private final String mTag;
169 
IwlanDataServiceCallback(String tag)170         IwlanDataServiceCallback(String tag) {
171             mTag = tag;
172         }
173 
174         @Override
onSetupDataCallComplete( @ataServiceCallback.ResultCode int resultCode, DataCallResponse response)175         public void onSetupDataCallComplete(
176                 @DataServiceCallback.ResultCode int resultCode, DataCallResponse response) {}
177 
178         @Override
onDeactivateDataCallComplete(@ataServiceCallback.ResultCode int resultCode)179         public void onDeactivateDataCallComplete(@DataServiceCallback.ResultCode int resultCode) {}
180 
181         @Override
onSetInitialAttachApnComplete(@ataServiceCallback.ResultCode int resultCode)182         public void onSetInitialAttachApnComplete(@DataServiceCallback.ResultCode int resultCode) {}
183 
184         @Override
onSetDataProfileComplete(@ataServiceCallback.ResultCode int resultCode)185         public void onSetDataProfileComplete(@DataServiceCallback.ResultCode int resultCode) {}
186 
187         @Override
onRequestDataCallListComplete( @ataServiceCallback.ResultCode int resultCode, List<DataCallResponse> dataCallList)188         public void onRequestDataCallListComplete(
189                 @DataServiceCallback.ResultCode int resultCode,
190                 List<DataCallResponse> dataCallList) {
191             mResultCode = resultCode;
192             mResultDataCallList = new ArrayList<DataCallResponse>(dataCallList);
193         }
194 
195         @Override
onDataCallListChanged(List<DataCallResponse> dataCallList)196         public void onDataCallListChanged(List<DataCallResponse> dataCallList) {}
197 
198         @Override
onHandoverStarted(@ataServiceCallback.ResultCode int result)199         public void onHandoverStarted(@DataServiceCallback.ResultCode int result) {}
200 
201         @Override
onHandoverCancelled(@ataServiceCallback.ResultCode int result)202         public void onHandoverCancelled(@DataServiceCallback.ResultCode int result) {}
203 
204         @Override
onApnUnthrottled(String apn)205         public void onApnUnthrottled(String apn) {}
206 
207         @Override
onDataProfileUnthrottled(DataProfile dataProfile)208         public void onDataProfileUnthrottled(DataProfile dataProfile) {}
209     }
210 
211     @Before
setUp()212     public void setUp() throws Exception {
213         MockitoAnnotations.initMocks(this);
214 
215         mStaticMockSession =
216                 mockitoSession()
217                         .mockStatic(EpdgSelector.class)
218                         .mockStatic(EpdgTunnelManager.class)
219                         .mockStatic(ErrorPolicyManager.class)
220                         .mockStatic(IwlanBroadcastReceiver.class)
221                         .mockStatic(SubscriptionManager.class)
222                         .strictness(Strictness.LENIENT)
223                         .startMocking();
224 
225         lenient()
226                 .when(SubscriptionManager.getDefaultDataSubscriptionId())
227                 .thenReturn(DEFAULT_SUB_INDEX);
228         lenient()
229                 .when(SubscriptionManager.getSlotIndex(eq(DEFAULT_SUB_INDEX)))
230                 .thenReturn(DEFAULT_SUB_INDEX);
231         lenient()
232                 .when(SubscriptionManager.getSlotIndex(eq(DEFAULT_SUB_INDEX + 1)))
233                 .thenReturn(DEFAULT_SUB_INDEX + 1);
234 
235         when(mMockContext.getSystemService(eq(ConnectivityManager.class)))
236                 .thenReturn(mMockConnectivityManager);
237         when(mMockContext.getSystemService(eq(SubscriptionManager.class)))
238                 .thenReturn(mMockSubscriptionManager);
239 
240         doNothing()
241                 .when(mMockConnectivityManager)
242                 .registerSystemDefaultNetworkCallback(mNetworkCallbackCaptor.capture(), any());
243 
244         when(EpdgTunnelManager.getInstance(mMockContext, DEFAULT_SLOT_INDEX))
245                 .thenReturn(mMockEpdgTunnelManager);
246         when(ErrorPolicyManager.getInstance(eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
247                 .thenReturn(mMockErrorPolicyManager);
248         when(mMockSubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(anyInt()))
249                 .thenReturn(mMockSubscriptionInfo);
250 
251         when(mMockSubscriptionInfo.getSubscriptionId()).thenReturn(DEFAULT_SUB_INDEX);
252 
253         when(mMockContext.getSystemService(eq(TelephonyManager.class)))
254                 .thenReturn(mMockTelephonyManager);
255 
256         when(mMockTelephonyManager.createForSubscriptionId(eq(DEFAULT_SUB_INDEX)))
257                 .thenReturn(mMockTelephonyManager);
258 
259         when(mMockTelephonyManager.isNetworkRoaming()).thenReturn(false);
260 
261         when(mMockContext.getContentResolver()).thenReturn(mMockContentResolver);
262 
263         when(mMockContext.getSystemService(eq(ImsManager.class))).thenReturn(mMockImsManager);
264 
265         when(mMockImsManager.getImsMmTelManager(anyInt())).thenReturn(mMockImsMmTelManager);
266 
267         when(mMockImsMmTelManager.isVoWiFiSettingEnabled()).thenReturn(false);
268 
269         when(EpdgSelector.getSelectorInstance(eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
270                 .thenReturn(mMockEpdgSelector);
271 
272         when(mMockIPv4LinkAddress.getAddress()).thenReturn(mMockInet4Address);
273         when(mMockIPv6LinkAddress.getAddress()).thenReturn(mMockInet6Address);
274 
275         mIwlanDataService = spy(new IwlanDataService(mFakeFeatureFlags));
276 
277         // Injects the test looper into the IwlanDataServiceHandler
278         doReturn(mTestLooper.getLooper()).when(mIwlanDataService).getLooper();
279         mIwlanDataService.setAppContext(mMockContext);
280         mSpyIwlanDataServiceProvider =
281                 spy(
282                         (IwlanDataServiceProvider)
283                                 mIwlanDataService.onCreateDataServiceProvider(DEFAULT_SLOT_INDEX));
284         mTestLooper.dispatchAll();
285 
286         when(Calendar.getInstance().getTime()).thenAnswer(i -> mMockedCalendarTime);
287 
288         mLinkProperties = new LinkProperties();
289         mLinkProperties.setInterfaceName("wlan0");
290         mLinkProperties.addLinkAddress(mMockIPv4LinkAddress);
291 
292         when(mMockConnectivityManager.getLinkProperties(eq(mMockNetwork)))
293                 .thenReturn(mLinkProperties);
294         when(mMockTunnelLinkProperties.ifaceName()).thenReturn("mockipsec0");
295 
296         mockCarrierConfigForN1Mode(true);
297     }
298 
moveTimeForwardAndDispatch(long milliSeconds)299     private void moveTimeForwardAndDispatch(long milliSeconds) {
300         mTestLooper.moveTimeForward(milliSeconds);
301         mTestLooper.dispatchAll();
302     }
303 
304     @After
cleanUp()305     public void cleanUp() throws Exception {
306         mStaticMockSession.finishMocking();
307         IwlanCarrierConfig.resetTestConfig();
308         mSpyIwlanDataServiceProvider.close();
309         mTestLooper.dispatchAll();
310         if (mIwlanDataService != null) {
311             mIwlanDataService.onDestroy();
312         }
313     }
314 
createMockNetwork(LinkProperties linkProperties)315     public Network createMockNetwork(LinkProperties linkProperties) {
316         Network network = mock(Network.class);
317         when(mMockConnectivityManager.getLinkProperties(eq(network))).thenReturn(linkProperties);
318         return network;
319     }
320 
getNetworkMonitorCallback()321     private NetworkCallback getNetworkMonitorCallback() {
322         return mNetworkCallbackCaptor.getValue();
323     }
324 
onSystemDefaultNetworkConnected( Network network, LinkProperties linkProperties, int transportType, int subId)325     private void onSystemDefaultNetworkConnected(
326             Network network, LinkProperties linkProperties, int transportType, int subId) {
327         NetworkCapabilities nc =
328                 prepareNetworkCapabilitiesForTest(
329                         transportType,
330                         subId /* unused if transportType is TRANSPORT_WIFI */,
331                         false /* isVcn */);
332         NetworkCallback networkMonitorCallback = getNetworkMonitorCallback();
333         networkMonitorCallback.onCapabilitiesChanged(network, nc);
334         networkMonitorCallback.onLinkPropertiesChanged(network, linkProperties);
335         mTestLooper.dispatchAll();
336     }
337 
onSystemDefaultNetworkConnected(int transportType)338     private void onSystemDefaultNetworkConnected(int transportType) {
339         Network newNetwork = createMockNetwork(mLinkProperties);
340         onSystemDefaultNetworkConnected(
341                 newNetwork, mLinkProperties, transportType, DEFAULT_SUB_INDEX);
342     }
343 
onSystemDefaultNetworkLost()344     private void onSystemDefaultNetworkLost() {
345         NetworkCallback networkMonitorCallback = getNetworkMonitorCallback();
346         networkMonitorCallback.onLost(mMockNetwork);
347         mTestLooper.dispatchAll();
348     }
349 
350     @Test
testWifiOnConnected()351     public void testWifiOnConnected() {
352         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
353         assertTrue(
354                 IwlanDataService.isNetworkConnected(
355                         false /* isActiveDataOnOtherSub */, false /* isCstEnabled */));
356     }
357 
358     @Test
testWifiOnLost()359     public void testWifiOnLost() {
360         when(mMockIwlanDataServiceProvider.getSlotIndex()).thenReturn(DEFAULT_SLOT_INDEX + 1);
361         mIwlanDataService.addIwlanDataServiceProvider(mMockIwlanDataServiceProvider);
362 
363         onSystemDefaultNetworkLost();
364         assertFalse(
365                 IwlanDataService.isNetworkConnected(
366                         false /* isActiveDataOnOtherSub */, false /* isCstEnabled */));
367         verify(mMockIwlanDataServiceProvider).forceCloseTunnelsInDeactivatingState();
368         mIwlanDataService.removeDataServiceProvider(mMockIwlanDataServiceProvider);
369         mTestLooper.dispatchAll();
370     }
371 
372     @Test
testWifiOnReconnected()373     public void testWifiOnReconnected() {
374         Network newNetwork = createMockNetwork(mLinkProperties);
375         onSystemDefaultNetworkConnected(
376                 newNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
377         verify(mMockEpdgTunnelManager, times(1)).updateNetwork(eq(newNetwork), eq(mLinkProperties));
378 
379         onSystemDefaultNetworkLost();
380         onSystemDefaultNetworkConnected(
381                 newNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
382         verify(mMockEpdgTunnelManager, times(2)).updateNetwork(eq(newNetwork), eq(mLinkProperties));
383     }
384 
385     @Test
testOnLinkPropertiesChangedForConnectedNetwork()386     public void testOnLinkPropertiesChangedForConnectedNetwork() {
387         NetworkCallback networkCallback = getNetworkMonitorCallback();
388         onSystemDefaultNetworkConnected(
389                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
390 
391         clearInvocations(mMockEpdgTunnelManager);
392 
393         LinkProperties newLinkProperties = new LinkProperties(mLinkProperties);
394         newLinkProperties.setInterfaceName("wlan0");
395         newLinkProperties.addLinkAddress(mMockIPv6LinkAddress);
396 
397         networkCallback.onLinkPropertiesChanged(mMockNetwork, newLinkProperties);
398         verify(mMockEpdgTunnelManager, times(1))
399                 .updateNetwork(eq(mMockNetwork), eq(newLinkProperties));
400     }
401 
402     @Test
testOnLinkPropertiesChangedForNonConnectedNetwork()403     public void testOnLinkPropertiesChangedForNonConnectedNetwork() {
404         NetworkCallback networkCallback = getNetworkMonitorCallback();
405         onSystemDefaultNetworkConnected(
406                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
407 
408         clearInvocations(mMockEpdgTunnelManager);
409 
410         LinkProperties newLinkProperties = new LinkProperties();
411         newLinkProperties.setInterfaceName("wlan0");
412         newLinkProperties.addLinkAddress(mMockIPv6LinkAddress);
413         Network newNetwork = createMockNetwork(newLinkProperties);
414 
415         networkCallback.onLinkPropertiesChanged(newNetwork, newLinkProperties);
416         verify(mMockEpdgTunnelManager, never())
417                 .updateNetwork(eq(newNetwork), any(LinkProperties.class));
418     }
419 
420     @Test
testOnLinkPropertiesChangedWithClatInstalled()421     public void testOnLinkPropertiesChangedWithClatInstalled() throws Exception {
422         NetworkCallback networkCallback = getNetworkMonitorCallback();
423         mLinkProperties.setLinkAddresses(
424                 new ArrayList<>(Collections.singletonList(mMockIPv6LinkAddress)));
425         onSystemDefaultNetworkConnected(
426                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
427 
428         clearInvocations(mMockEpdgTunnelManager);
429 
430         // LinkProperties#addStackedLink() is marked with @UnsupportedAppUsage
431         LinkProperties newLinkProperties = new LinkProperties(mLinkProperties);
432         newLinkProperties.setInterfaceName("wlan0");
433         LinkProperties stackedLink = new LinkProperties();
434         stackedLink.setInterfaceName("v4-wlan0");
435         stackedLink.addLinkAddress(mMockIPv4LinkAddress);
436         Class<?>[] parameterTypes = new Class<?>[] {LinkProperties.class};
437         Object[] args = new Object[] {stackedLink};
438         callUnsupportedAppUsageMethod(newLinkProperties, "addStackedLink", parameterTypes, args);
439         assertNotEquals(mLinkProperties, newLinkProperties);
440 
441         networkCallback.onLinkPropertiesChanged(mMockNetwork, newLinkProperties);
442         verify(mMockEpdgTunnelManager, times(1))
443                 .updateNetwork(eq(mMockNetwork), eq(newLinkProperties));
444     }
445 
446     @Test
testOnLinkPropertiesChangedForBringingUpIkeSession()447     public void testOnLinkPropertiesChangedForBringingUpIkeSession() {
448         DataProfile dp = buildImsDataProfile();
449 
450         NetworkCallback networkCallback = getNetworkMonitorCallback();
451         onSystemDefaultNetworkConnected(
452                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
453 
454         clearInvocations(mMockEpdgTunnelManager);
455 
456         mSpyIwlanDataServiceProvider.setTunnelState(
457                 dp,
458                 mMockDataServiceCallback,
459                 TunnelState.TUNNEL_IN_BRINGUP,
460                 null, /* linkProperties */
461                 false /* isHandover */,
462                 1 /* pduSessionId */,
463                 true /* isImsOrEmergency */,
464                 true /* isDataCallSetupWithN1 */);
465 
466         LinkProperties newLinkProperties = new LinkProperties(mLinkProperties);
467         newLinkProperties.setInterfaceName("wlan0");
468         newLinkProperties.addLinkAddress(mMockIPv6LinkAddress);
469 
470         networkCallback.onLinkPropertiesChanged(mMockNetwork, newLinkProperties);
471         verify(mMockEpdgTunnelManager, times(1))
472                 .updateNetwork(eq(mMockNetwork), eq(newLinkProperties));
473         verify(mMockEpdgTunnelManager, never())
474                 .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
475     }
476 
477     @Test
testNetworkNotConnectedWithCellularOnSameSubAndCrossSimEnabled()478     public void testNetworkNotConnectedWithCellularOnSameSubAndCrossSimEnabled()
479             throws InterruptedException {
480         NetworkCapabilities nc =
481                 prepareNetworkCapabilitiesForTest(
482                         TRANSPORT_CELLULAR, DEFAULT_SUB_INDEX, false /* isVcn */);
483         getNetworkMonitorCallback().onCapabilitiesChanged(mMockNetwork, nc);
484 
485         boolean isActiveDataOnOtherSub =
486                 IwlanDataService.isActiveDataOnOtherSub(DEFAULT_SLOT_INDEX);
487 
488         assertFalse(isActiveDataOnOtherSub);
489         assertFalse(
490                 IwlanDataService.isNetworkConnected(
491                         isActiveDataOnOtherSub, true /* isCstEnabled */));
492     }
493 
494     @Test
testCrossSimNetworkConnectedWithCellularOnDifferentSub()495     public void testCrossSimNetworkConnectedWithCellularOnDifferentSub()
496             throws InterruptedException {
497         NetworkCapabilities nc =
498                 prepareNetworkCapabilitiesForTest(
499                         TRANSPORT_CELLULAR, DEFAULT_SUB_INDEX + 1, false /* isVcn */);
500         getNetworkMonitorCallback().onCapabilitiesChanged(mMockNetwork, nc);
501 
502         boolean isActiveDataOnOtherSub =
503                 IwlanDataService.isActiveDataOnOtherSub(DEFAULT_SLOT_INDEX);
504 
505         assertTrue(isActiveDataOnOtherSub);
506         assertTrue(
507                 IwlanDataService.isNetworkConnected(
508                         isActiveDataOnOtherSub, true /* isCstEnabled */));
509     }
510 
511     @Test
testCrossSimNetworkConnectedWithVcnCellularOnDifferentSub()512     public void testCrossSimNetworkConnectedWithVcnCellularOnDifferentSub()
513             throws InterruptedException {
514         NetworkCapabilities nc =
515                 prepareNetworkCapabilitiesForTest(
516                         TRANSPORT_CELLULAR, DEFAULT_SUB_INDEX + 1, true /* isVcn */);
517         getNetworkMonitorCallback().onCapabilitiesChanged(mMockNetwork, nc);
518 
519         boolean isActiveDataOnOtherSub =
520                 IwlanDataService.isActiveDataOnOtherSub(DEFAULT_SLOT_INDEX);
521 
522         assertTrue(isActiveDataOnOtherSub);
523         assertTrue(
524                 IwlanDataService.isNetworkConnected(
525                         isActiveDataOnOtherSub, true /* isCstEnabled */));
526     }
527 
528     @Test
testOnCrossSimCallingEnable_doNotUpdateTunnelManagerIfCellularDataOnSameSub()529     public void testOnCrossSimCallingEnable_doNotUpdateTunnelManagerIfCellularDataOnSameSub()
530             throws Exception {
531         when(mMockImsMmTelManager.isCrossSimCallingEnabled()).thenReturn(true);
532 
533         Network newNetwork = createMockNetwork(mLinkProperties);
534         onSystemDefaultNetworkConnected(
535                 newNetwork, mLinkProperties, TRANSPORT_CELLULAR, DEFAULT_SUB_INDEX);
536 
537         mIwlanDataService
538                 .mIwlanDataServiceHandler
539                 .obtainMessage(
540                         IwlanEventListener.CROSS_SIM_CALLING_ENABLE_EVENT,
541                         DEFAULT_SLOT_INDEX,
542                         0 /* unused */)
543                 .sendToTarget();
544         mTestLooper.dispatchAll();
545         verify(mMockEpdgTunnelManager, never())
546                 .updateNetwork(eq(newNetwork), any(LinkProperties.class));
547     }
548 
549     @Test
testOnCrossSimCallingEnable_updateTunnelManagerIfCellularDataOnDifferentSub()550     public void testOnCrossSimCallingEnable_updateTunnelManagerIfCellularDataOnDifferentSub()
551             throws Exception {
552         when(mMockImsMmTelManager.isCrossSimCallingEnabled()).thenReturn(true);
553 
554         Network newNetwork = createMockNetwork(mLinkProperties);
555         onSystemDefaultNetworkConnected(
556                 newNetwork, mLinkProperties, TRANSPORT_CELLULAR, DEFAULT_SUB_INDEX + 1);
557         verify(mMockEpdgTunnelManager, times(1)).updateNetwork(eq(newNetwork), eq(mLinkProperties));
558 
559         mIwlanDataService
560                 .mIwlanDataServiceHandler
561                 .obtainMessage(
562                         IwlanEventListener.CROSS_SIM_CALLING_ENABLE_EVENT,
563                         DEFAULT_SLOT_INDEX,
564                         0 /* unused */)
565                 .sendToTarget();
566         mTestLooper.dispatchAll();
567         verify(mMockEpdgTunnelManager, times(2)).updateNetwork(eq(newNetwork), eq(mLinkProperties));
568     }
569 
570     @Test
testOnCrossSimCallingEnable_doNotUpdateTunnelManagerIfNoNetwork()571     public void testOnCrossSimCallingEnable_doNotUpdateTunnelManagerIfNoNetwork() throws Exception {
572         when(mMockImsMmTelManager.isCrossSimCallingEnabled()).thenReturn(true);
573         onSystemDefaultNetworkLost();
574 
575         mIwlanDataService
576                 .mIwlanDataServiceHandler
577                 .obtainMessage(
578                         IwlanEventListener.CROSS_SIM_CALLING_ENABLE_EVENT,
579                         DEFAULT_SLOT_INDEX,
580                         0 /* unused */)
581                 .sendToTarget();
582         mTestLooper.dispatchAll();
583         verify(mMockEpdgTunnelManager, never())
584                 .updateNetwork(any(Network.class), any(LinkProperties.class));
585     }
586 
587     @Test
testOnEthernetConnection_doNotUpdateTunnelManager()588     public void testOnEthernetConnection_doNotUpdateTunnelManager() throws Exception {
589         Network newNetwork = createMockNetwork(mLinkProperties);
590         onSystemDefaultNetworkConnected(
591                 newNetwork, mLinkProperties, TRANSPORT_ETHERNET, DEFAULT_SUB_INDEX);
592         verify(mMockEpdgTunnelManager, never())
593                 .updateNetwork(eq(newNetwork), any(LinkProperties.class));
594     }
595 
596     @Test
testAddDuplicateDataServiceProviderThrows()597     public void testAddDuplicateDataServiceProviderThrows() throws Exception {
598         when(mMockIwlanDataServiceProvider.getSlotIndex()).thenReturn(DEFAULT_SLOT_INDEX);
599         assertThrows(
600                 IllegalStateException.class,
601                 () -> mIwlanDataService.addIwlanDataServiceProvider(mMockIwlanDataServiceProvider));
602     }
603 
604     @Test
testRemoveDataServiceProvider()605     public void testRemoveDataServiceProvider() {
606         when(mMockIwlanDataServiceProvider.getSlotIndex()).thenReturn(DEFAULT_SLOT_INDEX);
607         mIwlanDataService.removeDataServiceProvider(mMockIwlanDataServiceProvider);
608         mTestLooper.dispatchAll();
609         verify(mIwlanDataService, times(1)).deinitNetworkCallback();
610         mIwlanDataService.onCreateDataServiceProvider(DEFAULT_SLOT_INDEX);
611         mTestLooper.dispatchAll();
612     }
613 
614     @Test
testRequestDataCallListPass()615     public void testRequestDataCallListPass() throws Exception {
616         DataProfile dp = buildImsDataProfile();
617         List<LinkAddress> mInternalAddressList;
618         List<InetAddress> mDNSAddressList;
619         List<InetAddress> mGatewayAddressList;
620         List<InetAddress> mPCSFAddressList;
621 
622         IwlanDataServiceCallback callback = new IwlanDataServiceCallback("requestDataCallList");
623         TunnelLinkProperties mLinkProperties = createTunnelLinkProperties();
624         mSpyIwlanDataServiceProvider.setTunnelState(
625                 dp,
626                 new DataServiceCallback(callback),
627                 TunnelState.TUNNEL_UP,
628                 mLinkProperties,
629                 false, /* isHandover */
630                 1, /* pduSessionId */
631                 true /* isImsOrEmergency */,
632                 true /* isDataCallSetupWithN1 */);
633         mSpyIwlanDataServiceProvider.requestDataCallList(new DataServiceCallback(callback));
634         mTestLooper.dispatchAll();
635 
636         assertEquals(DataServiceCallback.RESULT_SUCCESS, mResultCode);
637         assertEquals(1, mResultDataCallList.size());
638         for (DataCallResponse dataCallInfo : mResultDataCallList) {
639             assertEquals(TEST_APN_NAME.hashCode(), dataCallInfo.getId());
640             assertEquals(DataCallResponse.LINK_STATUS_ACTIVE, dataCallInfo.getLinkStatus());
641             assertEquals(ApnSetting.PROTOCOL_IP, dataCallInfo.getProtocolType());
642             assertEquals(INTERFACE_NAME, dataCallInfo.getInterfaceName());
643 
644             mInternalAddressList = dataCallInfo.getAddresses();
645             assertEquals(1, mInternalAddressList.size());
646             for (LinkAddress mLinkAddress : mInternalAddressList) {
647                 assertEquals(new LinkAddress(InetAddress.getByName(IP_ADDRESS), 3), mLinkAddress);
648             }
649 
650             mDNSAddressList = dataCallInfo.getDnsAddresses();
651             assertEquals(1, mDNSAddressList.size());
652             for (InetAddress mInetAddress : mDNSAddressList) {
653                 assertEquals(InetAddress.getByName(DNS_ADDRESS), mInetAddress);
654             }
655 
656             mGatewayAddressList = dataCallInfo.getGatewayAddresses();
657             assertEquals(mGatewayAddressList.size(), 1);
658             for (InetAddress mInetAddress : mGatewayAddressList) {
659                 assertEquals(mInetAddress, Inet4Address.getByName(GATEWAY_ADDRESS));
660             }
661 
662             mPCSFAddressList = dataCallInfo.getPcscfAddresses();
663             assertEquals(1, mPCSFAddressList.size());
664             for (InetAddress mInetAddress : mPCSFAddressList) {
665                 assertEquals(InetAddress.getByName(PSCF_ADDRESS), mInetAddress);
666             }
667 
668             assertEquals(LINK_MTU, dataCallInfo.getMtuV4());
669             assertEquals(LINK_MTU, dataCallInfo.getMtuV6());
670         }
671     }
672 
673     @Test
testRequestDataCallListEmpty()674     public void testRequestDataCallListEmpty() throws Exception {
675         IwlanDataServiceCallback callback = new IwlanDataServiceCallback("requestDataCallList");
676         mSpyIwlanDataServiceProvider.requestDataCallList(new DataServiceCallback(callback));
677         mTestLooper.dispatchAll();
678 
679         assertEquals(DataServiceCallback.RESULT_SUCCESS, mResultCode);
680         assertEquals(0, mResultDataCallList.size());
681     }
682 
683     @Test
testIwlanSetupDataCallWithInvalidArg()684     public void testIwlanSetupDataCallWithInvalidArg() {
685         mSpyIwlanDataServiceProvider.setupDataCall(
686                 AccessNetworkType.UNKNOWN, /* AccessNetworkType */
687                 null, /* dataProfile */
688                 false, /* isRoaming */
689                 true, /* allowRoaming */
690                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
691                 null, /* LinkProperties */
692                 2, /* pdu session id */
693                 null, /* sliceInfo */
694                 null, /* trafficDescriptor */
695                 true, /* matchAllRuleAllowed */
696                 mMockDataServiceCallback);
697         mTestLooper.dispatchAll();
698 
699         verify(mMockDataServiceCallback, timeout(1000).times(1))
700                 .onSetupDataCallComplete(
701                         eq(DataServiceCallback.RESULT_ERROR_INVALID_ARG), isNull());
702     }
703 
704     @Test
testIwlanSetupDataCallWithIllegalState()705     public void testIwlanSetupDataCallWithIllegalState() {
706         DataProfile dp = buildImsDataProfile();
707 
708         /* Wifi is not connected */
709         onSystemDefaultNetworkLost();
710 
711         mSpyIwlanDataServiceProvider.setupDataCall(
712                 AccessNetworkType.IWLAN, /* AccessNetworkType */
713                 dp, /* dataProfile */
714                 false, /* isRoaming */
715                 true, /* allowRoaming */
716                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
717                 null, /* LinkProperties */
718                 1, /* pdu session id */
719                 null, /* sliceInfo */
720                 null, /* trafficDescriptor */
721                 true, /* matchAllRuleAllowed */
722                 mMockDataServiceCallback);
723         mTestLooper.dispatchAll();
724 
725         verify(mMockDataServiceCallback, timeout(1000).times(1))
726                 .onSetupDataCallComplete(
727                         eq(5 /*DataServiceCallback.RESULT_ERROR_TEMPORARILY_UNAVAILABLE */),
728                         isNull());
729     }
730 
731     @Test
testIwlanDeactivateDataCallWithInvalidArg()732     public void testIwlanDeactivateDataCallWithInvalidArg() {
733         mSpyIwlanDataServiceProvider.deactivateDataCall(
734                 0, /* cid */
735                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
736                 mMockDataServiceCallback);
737         mTestLooper.dispatchAll();
738 
739         verify(mMockDataServiceCallback, timeout(1000).times(1))
740                 .onDeactivateDataCallComplete(eq(DataServiceCallback.RESULT_ERROR_INVALID_ARG));
741     }
742 
743     @Test
testIwlanSetupDataCallWithBringUpTunnel()744     public void testIwlanSetupDataCallWithBringUpTunnel() {
745         DataProfile dp = buildImsDataProfile();
746 
747         /* Wifi is connected */
748         onSystemDefaultNetworkConnected(
749                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
750 
751         mSpyIwlanDataServiceProvider.setupDataCall(
752                 AccessNetworkType.IWLAN, /* AccessNetworkType */
753                 dp, /* dataProfile */
754                 false, /* isRoaming */
755                 true, /* allowRoaming */
756                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
757                 null, /* LinkProperties */
758                 1, /* pduSessionId */
759                 null, /* sliceInfo */
760                 null, /* trafficDescriptor */
761                 true, /* matchAllRuleAllowed */
762                 mMockDataServiceCallback);
763         mTestLooper.dispatchAll();
764 
765         /* Check bringUpTunnel() is called. */
766         verify(mMockEpdgTunnelManager, times(1))
767                 .bringUpTunnel(
768                         any(TunnelSetupRequest.class),
769                         any(IwlanTunnelCallback.class),
770                         any(IwlanTunnelMetricsImpl.class));
771 
772         /* Check callback result is RESULT_SUCCESS when onOpened() is called. */
773         mSpyIwlanDataServiceProvider
774                 .getIwlanTunnelCallback()
775                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
776         mTestLooper.dispatchAll();
777         verify(mMockDataServiceCallback, times(1))
778                 .onSetupDataCallComplete(
779                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
780     }
781 
782     @Test
testIwlanSetupDataCallWithBringUpTunnelAndNullApnSetting()783     public void testIwlanSetupDataCallWithBringUpTunnelAndNullApnSetting() {
784         DataProfile dp = buildImsDataProfileWithEmptyApnSetting();
785 
786         /* Wifi is connected */
787         onSystemDefaultNetworkConnected(
788                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
789 
790         mSpyIwlanDataServiceProvider.setupDataCall(
791                 AccessNetworkType.IWLAN, /* AccessNetworkType */
792                 dp, /* dataProfile */
793                 false, /* isRoaming */
794                 true, /* allowRoaming */
795                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
796                 null, /* LinkProperties */
797                 1, /* pduSessionId */
798                 null, /* sliceInfo */
799                 null, /* trafficDescriptor */
800                 true, /* matchAllRuleAllowed */
801                 mMockDataServiceCallback);
802         mTestLooper.dispatchAll();
803 
804         verify(mMockDataServiceCallback, times(1))
805                 .onSetupDataCallComplete(
806                         eq(DataServiceCallback.RESULT_ERROR_INVALID_ARG), isNull());
807     }
808 
809     @Test
testSliceInfoInclusionInDataCallResponse()810     public void testSliceInfoInclusionInDataCallResponse() throws Exception {
811         DataProfile dp = buildImsDataProfile();
812 
813         /* Wifi is connected */
814         onSystemDefaultNetworkConnected(
815                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
816 
817         mSpyIwlanDataServiceProvider.setupDataCall(
818                 AccessNetworkType.IWLAN, /* AccessNetworkType */
819                 dp, /* dataProfile */
820                 false, /* isRoaming */
821                 true, /* allowRoaming */
822                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
823                 null, /* LinkProperties */
824                 1, /* pduSessionId */
825                 null, /* sliceInfo */
826                 null, /* trafficDescriptor */
827                 true, /* matchAllRuleAllowed */
828                 mMockDataServiceCallback);
829         mTestLooper.dispatchAll();
830 
831         /* Check bringUpTunnel() is called. */
832         verify(mMockEpdgTunnelManager, times(1))
833                 .bringUpTunnel(
834                         any(TunnelSetupRequest.class),
835                         any(IwlanTunnelCallback.class),
836                         any(IwlanTunnelMetricsImpl.class));
837 
838         /* Check callback result is RESULT_SUCCESS when onOpened() is called. */
839         TunnelLinkProperties tp = createTunnelLinkProperties();
840 
841         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
842                 ArgumentCaptor.forClass(DataCallResponse.class);
843 
844         mSpyIwlanDataServiceProvider.getIwlanTunnelCallback().onOpened(TEST_APN_NAME, tp);
845         mTestLooper.dispatchAll();
846         verify(mMockDataServiceCallback, times(1))
847                 .onSetupDataCallComplete(
848                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
849 
850         /* check that slice info is filled up and matches */
851         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
852         assertNotNull(dataCallResponse.getSliceInfo());
853         assertEquals(dataCallResponse.getSliceInfo(), tp.sliceInfo().get());
854     }
855 
856     @Test
testIwlanDeactivateDataCallWithCloseTunnel()857     public void testIwlanDeactivateDataCallWithCloseTunnel() {
858         DataProfile dp = buildImsDataProfile();
859 
860         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
861 
862         mSpyIwlanDataServiceProvider.setTunnelState(
863                 dp,
864                 mMockDataServiceCallback,
865                 TunnelState.TUNNEL_IN_BRINGUP,
866                 null, /* linkProperties */
867                 false, /* isHandover */
868                 1, /* pduSessionId */
869                 true /* isImsOrEmergency */,
870                 true /* isDataCallSetupWithN1 */);
871 
872         mSpyIwlanDataServiceProvider.deactivateDataCall(
873                 TEST_APN_NAME.hashCode() /* cid: hashcode() of "ims" */,
874                 DataService.REQUEST_REASON_NORMAL,
875                 mMockDataServiceCallback);
876         mTestLooper.dispatchAll();
877         /* Check closeTunnel() is called. */
878         verify(mMockEpdgTunnelManager, times(1))
879                 .closeTunnel(
880                         eq(TEST_APN_NAME),
881                         eq(false),
882                         any(IwlanTunnelCallback.class),
883                         any(IwlanTunnelMetricsImpl.class),
884                         eq(BRINGDOWN_REASON_DEACTIVATE_DATA_CALL));
885 
886         /* Check callback result is RESULT_SUCCESS when onClosed() is called. */
887         mSpyIwlanDataServiceProvider
888                 .getIwlanTunnelCallback()
889                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
890         mTestLooper.dispatchAll();
891         verify(mMockDataServiceCallback, times(1))
892                 .onDeactivateDataCallComplete(eq(DataServiceCallback.RESULT_SUCCESS));
893     }
894 
895     @Test
testDeactivateDataCall_ImmediateReleaseAfterHandover()896     public void testDeactivateDataCall_ImmediateReleaseAfterHandover() {
897         DataProfile dp = buildImsDataProfile();
898 
899         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
900 
901         mSpyIwlanDataServiceProvider.setTunnelState(
902                 dp,
903                 mMockDataServiceCallback,
904                 TunnelState.TUNNEL_UP,
905                 null, /* linkProperties */
906                 false, /* isHandover */
907                 1, /* pduSessionId */
908                 true /* isImsOrEmergency */,
909                 true /* isDataCallSetupWithN1 */);
910 
911         mSpyIwlanDataServiceProvider.deactivateDataCall(
912                 TEST_APN_NAME.hashCode() /* cid: hashcode() of "ims" */,
913                 DataService.REQUEST_REASON_HANDOVER,
914                 mMockDataServiceCallback);
915         mTestLooper.dispatchAll();
916 
917         moveTimeForwardAndDispatch(50);
918         /* Check closeTunnel() is called. */
919         verify(mMockEpdgTunnelManager, times(1))
920                 .closeTunnel(
921                         eq(TEST_APN_NAME),
922                         eq(true) /* forceClose */,
923                         any(IwlanTunnelCallback.class),
924                         any(IwlanTunnelMetricsImpl.class),
925                         eq(BRINGDOWN_REASON_DEACTIVATE_DATA_CALL));
926 
927         /* Check callback result is RESULT_SUCCESS when onClosed() is called. */
928         mSpyIwlanDataServiceProvider
929                 .getIwlanTunnelCallback()
930                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
931         mTestLooper.dispatchAll();
932         verify(mMockDataServiceCallback, times(1))
933                 .onDeactivateDataCallComplete(eq(DataServiceCallback.RESULT_SUCCESS));
934     }
935 
936     @Test
testDeactivateDataCall_DelayedReleaseAfterHandover()937     public void testDeactivateDataCall_DelayedReleaseAfterHandover() {
938         DataProfile dp = buildImsDataProfile();
939 
940         IwlanCarrierConfig.putTestConfigInt(
941                 IwlanCarrierConfig.KEY_HANDOVER_TO_WWAN_RELEASE_DELAY_SECOND_INT, 3);
942         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
943 
944         mSpyIwlanDataServiceProvider.setTunnelState(
945                 dp,
946                 mMockDataServiceCallback,
947                 TunnelState.TUNNEL_UP,
948                 null, /* linkProperties */
949                 false, /* isHandover */
950                 1, /* pduSessionId */
951                 true /* isImsOrEmergency */,
952                 true /* isDataCallSetupWithN1 */);
953 
954         mSpyIwlanDataServiceProvider.deactivateDataCall(
955                 TEST_APN_NAME.hashCode() /* cid: hashcode() of "ims" */,
956                 DataService.REQUEST_REASON_HANDOVER,
957                 mMockDataServiceCallback);
958         mTestLooper.dispatchAll();
959 
960         moveTimeForwardAndDispatch(2950);
961         /* Check closeTunnel() is called. */
962         verify(mMockEpdgTunnelManager, never())
963                 .closeTunnel(
964                         eq(TEST_APN_NAME),
965                         anyBoolean(),
966                         any(IwlanTunnelCallback.class),
967                         any(IwlanTunnelMetricsImpl.class),
968                         eq(BRINGDOWN_REASON_DEACTIVATE_DATA_CALL));
969 
970         moveTimeForwardAndDispatch(50);
971         /* Check closeTunnel() is called. */
972         verify(mMockEpdgTunnelManager, times(1))
973                 .closeTunnel(
974                         eq(TEST_APN_NAME),
975                         eq(true) /* forceClose */,
976                         any(IwlanTunnelCallback.class),
977                         any(IwlanTunnelMetricsImpl.class),
978                         eq(BRINGDOWN_REASON_DEACTIVATE_DATA_CALL));
979 
980         /* Check callback result is RESULT_SUCCESS when onClosed() is called. */
981         mSpyIwlanDataServiceProvider
982                 .getIwlanTunnelCallback()
983                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
984         mTestLooper.dispatchAll();
985         verify(mMockDataServiceCallback, times(1))
986                 .onDeactivateDataCallComplete(eq(DataServiceCallback.RESULT_SUCCESS));
987     }
988 
989     @Test
testDeactivateDataCall_DelayedReleaseAfterHandover_NetworkReleaseBeforeDelay()990     public void testDeactivateDataCall_DelayedReleaseAfterHandover_NetworkReleaseBeforeDelay() {
991         DataProfile dp = buildImsDataProfile();
992 
993         IwlanCarrierConfig.putTestConfigInt(
994                 IwlanCarrierConfig.KEY_HANDOVER_TO_WWAN_RELEASE_DELAY_SECOND_INT, 3);
995         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
996                 .thenReturn(DataFailCause.NONE);
997 
998         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
999 
1000         mSpyIwlanDataServiceProvider.setTunnelState(
1001                 dp,
1002                 mMockDataServiceCallback,
1003                 TunnelState.TUNNEL_UP,
1004                 null, /* linkProperties */
1005                 false, /* isHandover */
1006                 1, /* pduSessionId */
1007                 true /* isImsOrEmergency */,
1008                 true /* isDataCallSetupWithN1 */);
1009 
1010         mSpyIwlanDataServiceProvider.setMetricsAtom(
1011                 TEST_APN_NAME,
1012                 64, /* type IMS */
1013                 true,
1014                 13, /* LTE */
1015                 false,
1016                 true,
1017                 1 /* Transport WiFi */);
1018 
1019         mSpyIwlanDataServiceProvider.deactivateDataCall(
1020                 TEST_APN_NAME.hashCode() /* cid: hashcode() of "ims" */,
1021                 DataService.REQUEST_REASON_HANDOVER,
1022                 mMockDataServiceCallback);
1023         mTestLooper.dispatchAll();
1024 
1025         moveTimeForwardAndDispatch(50);
1026         /* Check closeTunnel() is not called. */
1027         verify(mMockEpdgTunnelManager, never())
1028                 .closeTunnel(
1029                         eq(TEST_APN_NAME),
1030                         anyBoolean(),
1031                         any(IwlanTunnelCallback.class),
1032                         any(IwlanTunnelMetricsImpl.class),
1033                         anyInt());
1034 
1035         /* Check callback result is RESULT_SUCCESS when onClosed() is called. */
1036         mSpyIwlanDataServiceProvider
1037                 .getIwlanTunnelCallback()
1038                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
1039         mTestLooper.dispatchAll();
1040         verify(mMockDataServiceCallback, times(1))
1041                 .onDeactivateDataCallComplete(eq(DataServiceCallback.RESULT_SUCCESS));
1042 
1043         moveTimeForwardAndDispatch(4000);
1044 
1045         verify(mMockEpdgTunnelManager, never())
1046                 .closeTunnel(
1047                         eq(TEST_APN_NAME),
1048                         anyBoolean(),
1049                         any(IwlanTunnelCallback.class),
1050                         any(IwlanTunnelMetricsImpl.class),
1051                         anyInt());
1052 
1053         // No additional callbacks are involved.
1054         verify(mMockDataServiceCallback, times(1)).onDeactivateDataCallComplete(anyInt());
1055     }
1056 
1057     @Test
testHandoverFailureModeDefault()1058     public void testHandoverFailureModeDefault() {
1059         DataProfile dp = buildImsDataProfile();
1060 
1061         when(mMockErrorPolicyManager.getRemainingRetryTimeMs(eq(TEST_APN_NAME))).thenReturn(5L);
1062         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1063                 .thenReturn(DataFailCause.USER_AUTHENTICATION);
1064 
1065         mSpyIwlanDataServiceProvider.setTunnelState(
1066                 dp,
1067                 mMockDataServiceCallback,
1068                 TunnelState.TUNNEL_IN_BRINGUP,
1069                 null, /* linkProperties */
1070                 false /* isHandover */,
1071                 1 /* pduSessionId */,
1072                 true /* isImsOrEmergency */,
1073                 true /* isDataCallSetupWithN1 */);
1074 
1075         mSpyIwlanDataServiceProvider.setMetricsAtom(
1076                 TEST_APN_NAME,
1077                 64, // type IMS
1078                 true,
1079                 13, // LTE
1080                 false,
1081                 true,
1082                 1 // Transport Wi-Fi
1083                 );
1084 
1085         mSpyIwlanDataServiceProvider
1086                 .getIwlanTunnelCallback()
1087                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
1088         mTestLooper.dispatchAll();
1089 
1090         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
1091                 ArgumentCaptor.forClass(DataCallResponse.class);
1092 
1093         verify(mMockDataServiceCallback, times(1))
1094                 .onSetupDataCallComplete(
1095                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
1096 
1097         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
1098         assertEquals(
1099                 DataCallResponse.HANDOVER_FAILURE_MODE_LEGACY,
1100                 dataCallResponse.getHandoverFailureMode());
1101         assertEquals(DataFailCause.USER_AUTHENTICATION, dataCallResponse.getCause());
1102         assertEquals(5L, dataCallResponse.getRetryDurationMillis());
1103     }
1104 
1105     @Test
testHandoverFailureModeHandover()1106     public void testHandoverFailureModeHandover() {
1107         DataProfile dp = buildImsDataProfile();
1108 
1109         when(mMockErrorPolicyManager.getRemainingRetryTimeMs(eq(TEST_APN_NAME))).thenReturn(-1L);
1110         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1111                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1112         when(mMockErrorPolicyManager.shouldRetryWithInitialAttach(eq(TEST_APN_NAME)))
1113                 .thenReturn(false);
1114 
1115         mSpyIwlanDataServiceProvider.setTunnelState(
1116                 dp,
1117                 mMockDataServiceCallback,
1118                 TunnelState.TUNNEL_IN_BRINGUP,
1119                 null, /* linkProperties */
1120                 true /* isHandover */,
1121                 1 /* pduSessionId */,
1122                 true /* isImsOrEmergency */,
1123                 true /* isDataCallSetupWithN1 */);
1124 
1125         mSpyIwlanDataServiceProvider.setMetricsAtom(
1126                 TEST_APN_NAME,
1127                 64, // type IMS
1128                 true,
1129                 13, // LTE
1130                 false,
1131                 true,
1132                 1 // Transport Wi-Fi
1133                 );
1134 
1135         mSpyIwlanDataServiceProvider
1136                 .getIwlanTunnelCallback()
1137                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
1138         mTestLooper.dispatchAll();
1139 
1140         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
1141                 ArgumentCaptor.forClass(DataCallResponse.class);
1142 
1143         verify(mMockDataServiceCallback, times(1))
1144                 .onSetupDataCallComplete(
1145                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
1146 
1147         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
1148         assertEquals(
1149                 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_HANDOVER,
1150                 dataCallResponse.getHandoverFailureMode());
1151         assertEquals(DataFailCause.ERROR_UNSPECIFIED, dataCallResponse.getCause());
1152         assertEquals(-1L, dataCallResponse.getRetryDurationMillis());
1153     }
1154 
1155     @Test
testSupportInitialAttachSuccessOnIms()1156     public void testSupportInitialAttachSuccessOnIms() {
1157         DataProfile dp = buildImsDataProfile();
1158 
1159         when(mMockErrorPolicyManager.getRemainingRetryTimeMs(eq(TEST_APN_NAME))).thenReturn(-1L);
1160         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1161                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1162         when(mMockErrorPolicyManager.shouldRetryWithInitialAttach(eq(TEST_APN_NAME)))
1163                 .thenReturn(true);
1164 
1165         // APN = IMS, in idle call state
1166         mIwlanDataService
1167                 .mIwlanDataServiceHandler
1168                 .obtainMessage(
1169                         IwlanEventListener.CALL_STATE_CHANGED_EVENT,
1170                         DEFAULT_SLOT_INDEX,
1171                         CALL_STATE_IDLE)
1172                 .sendToTarget();
1173 
1174         mSpyIwlanDataServiceProvider.setTunnelState(
1175                 dp,
1176                 mMockDataServiceCallback,
1177                 TunnelState.TUNNEL_IN_BRINGUP,
1178                 null, /* linkProperties */
1179                 true /* isHandover */,
1180                 1 /* pduSessionId */,
1181                 true /* isImsOrEmergency */,
1182                 true /* isDataCallSetupWithN1 */);
1183 
1184         mSpyIwlanDataServiceProvider.setMetricsAtom(
1185                 TEST_APN_NAME,
1186                 64, // type IMS
1187                 true,
1188                 13, // LTE
1189                 false,
1190                 true,
1191                 1 // Transport Wi-Fi
1192                 );
1193 
1194         mSpyIwlanDataServiceProvider
1195                 .getIwlanTunnelCallback()
1196                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
1197         mTestLooper.dispatchAll();
1198 
1199         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
1200                 ArgumentCaptor.forClass(DataCallResponse.class);
1201         verify(mMockDataServiceCallback, times(1))
1202                 .onSetupDataCallComplete(
1203                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
1204         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
1205         // Not on video or voice call
1206         assertEquals(
1207                 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_SETUP_NORMAL,
1208                 dataCallResponse.getHandoverFailureMode());
1209     }
1210 
1211     @Test
testSupportInitialAttachSuccessOnEmergency()1212     public void testSupportInitialAttachSuccessOnEmergency() {
1213         DataProfile dp = buildDataProfile(ApnSetting.TYPE_EMERGENCY);
1214 
1215         when(mMockErrorPolicyManager.getRemainingRetryTimeMs(eq(TEST_APN_NAME))).thenReturn(-1L);
1216         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1217                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1218         when(mMockErrorPolicyManager.shouldRetryWithInitialAttach(eq(TEST_APN_NAME)))
1219                 .thenReturn(true);
1220 
1221         // APN = Emergency, in idle call state
1222         mIwlanDataService
1223                 .mIwlanDataServiceHandler
1224                 .obtainMessage(
1225                         IwlanEventListener.CALL_STATE_CHANGED_EVENT,
1226                         DEFAULT_SLOT_INDEX,
1227                         CALL_STATE_IDLE)
1228                 .sendToTarget();
1229 
1230         mSpyIwlanDataServiceProvider.setTunnelState(
1231                 dp,
1232                 mMockDataServiceCallback,
1233                 TunnelState.TUNNEL_IN_BRINGUP,
1234                 null, /* linkProperties */
1235                 true /* isHandover */,
1236                 1 /* pduSessionId */,
1237                 true /* isImsOrEmergency */,
1238                 true /* isDataCallSetupWithN1 */);
1239 
1240         mSpyIwlanDataServiceProvider.setMetricsAtom(
1241                 TEST_APN_NAME,
1242                 512, // type Emergency
1243                 true,
1244                 13, // LTE
1245                 false,
1246                 true,
1247                 1 // Transport Wi-Fi
1248                 );
1249 
1250         mSpyIwlanDataServiceProvider
1251                 .getIwlanTunnelCallback()
1252                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
1253         mTestLooper.dispatchAll();
1254 
1255         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
1256                 ArgumentCaptor.forClass(DataCallResponse.class);
1257         verify(mMockDataServiceCallback, times(1))
1258                 .onSetupDataCallComplete(
1259                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
1260         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
1261         // Not on video or voice call
1262         assertEquals(
1263                 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_SETUP_NORMAL,
1264                 dataCallResponse.getHandoverFailureMode());
1265     }
1266 
1267     @Test
testSupportInitialAttachOnImsCall()1268     public void testSupportInitialAttachOnImsCall() {
1269         DataProfile dp = buildImsDataProfile();
1270 
1271         when(mMockErrorPolicyManager.getRemainingRetryTimeMs(eq(TEST_APN_NAME))).thenReturn(-1L);
1272         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1273                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1274         when(mMockErrorPolicyManager.shouldRetryWithInitialAttach(eq(TEST_APN_NAME)))
1275                 .thenReturn(true);
1276 
1277         // APN = IMS, in call
1278         mIwlanDataService
1279                 .mIwlanDataServiceHandler
1280                 .obtainMessage(
1281                         IwlanEventListener.CALL_STATE_CHANGED_EVENT,
1282                         DEFAULT_SLOT_INDEX,
1283                         TelephonyManager.CALL_STATE_OFFHOOK)
1284                 .sendToTarget();
1285 
1286         mSpyIwlanDataServiceProvider.setTunnelState(
1287                 dp,
1288                 mMockDataServiceCallback,
1289                 TunnelState.TUNNEL_IN_BRINGUP,
1290                 null /* linkProperties */,
1291                 true /* isHandover */,
1292                 1 /* pduSessionId */,
1293                 true /* isImsOrEmergency */,
1294                 true /* isDataCallSetupWithN1 */);
1295 
1296         mSpyIwlanDataServiceProvider.setMetricsAtom(
1297                 TEST_APN_NAME,
1298                 64, // type IMS
1299                 true,
1300                 13, // LTE
1301                 false,
1302                 true,
1303                 1 // Transport Wi-Fi
1304                 );
1305 
1306         mSpyIwlanDataServiceProvider
1307                 .getIwlanTunnelCallback()
1308                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
1309         mTestLooper.dispatchAll();
1310 
1311         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
1312                 ArgumentCaptor.forClass(DataCallResponse.class);
1313         verify(mMockDataServiceCallback, times(1))
1314                 .onSetupDataCallComplete(
1315                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
1316         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
1317         // In call state
1318         assertEquals(
1319                 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_HANDOVER,
1320                 dataCallResponse.getHandoverFailureMode());
1321     }
1322 
1323     @Test
testSupportInitialAttachOnEmergencyCall()1324     public void testSupportInitialAttachOnEmergencyCall() {
1325         DataProfile dp = buildDataProfile(ApnSetting.TYPE_EMERGENCY);
1326 
1327         when(mMockErrorPolicyManager.getRemainingRetryTimeMs(eq(TEST_APN_NAME))).thenReturn(-1L);
1328         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1329                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1330         when(mMockErrorPolicyManager.shouldRetryWithInitialAttach(eq(TEST_APN_NAME)))
1331                 .thenReturn(true);
1332 
1333         // APN = Emergency, in call
1334         mIwlanDataService
1335                 .mIwlanDataServiceHandler
1336                 .obtainMessage(
1337                         IwlanEventListener.CALL_STATE_CHANGED_EVENT,
1338                         DEFAULT_SLOT_INDEX,
1339                         TelephonyManager.CALL_STATE_OFFHOOK)
1340                 .sendToTarget();
1341 
1342         mSpyIwlanDataServiceProvider.setTunnelState(
1343                 dp,
1344                 mMockDataServiceCallback,
1345                 TunnelState.TUNNEL_IN_BRINGUP,
1346                 null /* linkProperties */,
1347                 true /* isHandover */,
1348                 1 /* pduSessionId */,
1349                 true /* isImsOrEmergency */,
1350                 true /* isDataCallSetupWithN1 */);
1351 
1352         mSpyIwlanDataServiceProvider.setMetricsAtom(
1353                 TEST_APN_NAME,
1354                 512, // type Emergency
1355                 true,
1356                 13, // LTE
1357                 false,
1358                 true,
1359                 1 // Transport Wi-Fi
1360                 );
1361 
1362         mSpyIwlanDataServiceProvider
1363                 .getIwlanTunnelCallback()
1364                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
1365         mTestLooper.dispatchAll();
1366 
1367         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
1368                 ArgumentCaptor.forClass(DataCallResponse.class);
1369         verify(mMockDataServiceCallback, times(1))
1370                 .onSetupDataCallComplete(
1371                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
1372         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
1373         // In call state
1374         assertEquals(
1375                 DataCallResponse.HANDOVER_FAILURE_MODE_NO_FALLBACK_RETRY_HANDOVER,
1376                 dataCallResponse.getHandoverFailureMode());
1377     }
1378 
1379     @Test
testDnsPrefetching()1380     public void testDnsPrefetching() throws Exception {
1381         NetworkCallback networkCallback = getNetworkMonitorCallback();
1382         /* Wifi is connected */
1383         onSystemDefaultNetworkConnected(
1384                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
1385         networkCallback.onLinkPropertiesChanged(mMockNetwork, mLinkProperties);
1386 
1387         mIwlanDataService
1388                 .mIwlanDataServiceHandler
1389                 .obtainMessage(
1390                         IwlanEventListener.CARRIER_CONFIG_CHANGED_EVENT,
1391                         DEFAULT_SLOT_INDEX,
1392                         0 /* unused */)
1393                 .sendToTarget();
1394 
1395         mIwlanDataService
1396                 .mIwlanDataServiceHandler
1397                 .obtainMessage(
1398                         IwlanEventListener.WIFI_CALLING_ENABLE_EVENT,
1399                         DEFAULT_SLOT_INDEX,
1400                         0 /* unused */)
1401                 .sendToTarget();
1402         mTestLooper.dispatchAll();
1403 
1404         LinkProperties newLinkProperties = new LinkProperties();
1405         newLinkProperties.setInterfaceName("wlan0");
1406         newLinkProperties.addLinkAddress(mMockIPv4LinkAddress);
1407         newLinkProperties.addLinkAddress(mMockIPv6LinkAddress);
1408 
1409         networkCallback.onLinkPropertiesChanged(mMockNetwork, newLinkProperties);
1410 
1411         /* Prefetching will be triggered twice.
1412            1. Network connected, CarrierConfig ready, WifiCallingSetting enabled
1413            2. Connection ipFamily changed.
1414         */
1415         verify(mMockEpdgSelector, times(2))
1416                 .getValidatedServerList(
1417                         eq(0),
1418                         eq(EpdgSelector.PROTO_FILTER_IPV4V6),
1419                         eq(EpdgSelector.SYSTEM_PREFERRED),
1420                         eq(false),
1421                         eq(false),
1422                         eq(mMockNetwork),
1423                         isNull());
1424         verify(mMockEpdgSelector, times(2))
1425                 .getValidatedServerList(
1426                         eq(0),
1427                         eq(EpdgSelector.PROTO_FILTER_IPV4V6),
1428                         eq(EpdgSelector.SYSTEM_PREFERRED),
1429                         eq(false),
1430                         eq(true),
1431                         eq(mMockNetwork),
1432                         isNull());
1433     }
1434 
advanceCalendarByTimeMs(long time, Calendar calendar)1435     private void advanceCalendarByTimeMs(long time, Calendar calendar) {
1436         mMockedCalendarTime += time;
1437         if (calendar != null) {
1438             calendar.setTimeInMillis(mMockedCalendarTime);
1439         }
1440         mTestLooper.dispatchAll();
1441     }
1442 
buildImsDataProfileWithEmptyApnSetting()1443     private DataProfile buildImsDataProfileWithEmptyApnSetting() {
1444         return new DataProfile.Builder()
1445                 .setTrafficDescriptor(
1446                         new TrafficDescriptor.Builder().setDataNetworkName("").build())
1447                 .setType(1)
1448                 .enable(true)
1449                 .setPreferred(true)
1450                 .build();
1451     }
1452 
buildImsDataProfile()1453     private DataProfile buildImsDataProfile() {
1454         return buildDataProfile(ApnSetting.TYPE_IMS);
1455     }
1456 
buildDataProfile(int supportedApnTypesBitmask)1457     private DataProfile buildDataProfile(int supportedApnTypesBitmask) {
1458         return new DataProfile.Builder()
1459                 .setApnSetting(
1460                         new ApnSetting.Builder()
1461                                 .setProfileId(1)
1462                                 .setEntryName(TEST_APN_NAME)
1463                                 .setApnName(TEST_APN_NAME)
1464                                 .setProtocol(ApnSetting.PROTOCOL_IPV4V6)
1465                                 .setAuthType(ApnSetting.AUTH_TYPE_NONE)
1466                                 .setUser("")
1467                                 .setPassword("")
1468                                 .setApnTypeBitmask(supportedApnTypesBitmask)
1469                                 .setRoamingProtocol(ApnSetting.PROTOCOL_IPV4V6)
1470                                 .setNetworkTypeBitmask(
1471                                         (int) TelephonyManager.NETWORK_TYPE_BITMASK_IWLAN)
1472                                 .setPersistent(true)
1473                                 .build())
1474                 .setType(1) // 3gpp
1475                 .enable(true)
1476                 .setPreferred(true)
1477                 .build();
1478     }
1479 
prepareNetworkCapabilitiesForTest( int transportType, int subId, boolean isVcn)1480     private NetworkCapabilities prepareNetworkCapabilitiesForTest(
1481             int transportType, int subId, boolean isVcn) {
1482         NetworkCapabilities.Builder builder =
1483                 new NetworkCapabilities.Builder().addTransportType(transportType);
1484         if (isVcn) {
1485             builder.setTransportInfo(new VcnTransportInfo(subId));
1486         } else {
1487             builder.setNetworkSpecifier(new TelephonyNetworkSpecifier(subId));
1488         }
1489         return builder.build();
1490     }
1491 
1492     @Test
testIwlanSetupDataCallFailsWithCellularAndCstDisabled()1493     public void testIwlanSetupDataCallFailsWithCellularAndCstDisabled() throws Exception {
1494         DataProfile dp = buildImsDataProfile();
1495         /* CST is disabled, and data is on the same sub as the data service provider */
1496         when(mMockImsMmTelManager.isCrossSimCallingEnabled()).thenReturn(false);
1497 
1498         NetworkCapabilities nc =
1499                 prepareNetworkCapabilitiesForTest(
1500                         TRANSPORT_CELLULAR, DEFAULT_SUB_INDEX, false /* isVcn */);
1501         getNetworkMonitorCallback().onCapabilitiesChanged(mMockNetwork, nc);
1502 
1503         mSpyIwlanDataServiceProvider.setupDataCall(
1504                 AccessNetworkType.IWLAN, /* AccessNetworkType */
1505                 dp, /* dataProfile */
1506                 false, /* isRoaming */
1507                 true, /* allowRoaming */
1508                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
1509                 null, /* LinkProperties */
1510                 1, /* pdu session id */
1511                 null, /* sliceInfo */
1512                 null, /* trafficDescriptor */
1513                 true, /* matchAllRuleAllowed */
1514                 mMockDataServiceCallback);
1515         mTestLooper.dispatchAll();
1516 
1517         verify(mMockDataServiceCallback, timeout(1000).times(1))
1518                 .onSetupDataCallComplete(
1519                         eq(5 /* DataServiceCallback.RESULT_ERROR_TEMPORARILY_UNAVAILABLE */),
1520                         isNull());
1521     }
1522 
1523     @Test
testIwlanSetupDataCallFailsWithCellularOnSameSubAndCstEnabled()1524     public void testIwlanSetupDataCallFailsWithCellularOnSameSubAndCstEnabled() throws Exception {
1525         DataProfile dp = buildImsDataProfile();
1526 
1527         /* CST is enabled, but data is on the same sub as the DataServiceProvider */
1528         when(mMockImsMmTelManager.isCrossSimCallingEnabled()).thenReturn(true);
1529 
1530         NetworkCapabilities nc =
1531                 prepareNetworkCapabilitiesForTest(
1532                         TRANSPORT_CELLULAR, DEFAULT_SUB_INDEX, false /* isVcn */);
1533         getNetworkMonitorCallback().onCapabilitiesChanged(mMockNetwork, nc);
1534 
1535         mSpyIwlanDataServiceProvider.setupDataCall(
1536                 AccessNetworkType.IWLAN, /* AccessNetworkType */
1537                 dp, /* dataProfile */
1538                 false, /* isRoaming */
1539                 true, /* allowRoaming */
1540                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
1541                 null, /* LinkProperties */
1542                 1, /* pduSessionId */
1543                 null, /* sliceInfo */
1544                 null, /* trafficDescriptor */
1545                 true, /* matchAllRuleAllowed */
1546                 mMockDataServiceCallback);
1547         mTestLooper.dispatchAll();
1548 
1549         verify(mMockDataServiceCallback, timeout(1000).times(1))
1550                 .onSetupDataCallComplete(
1551                         eq(5 /* DataServiceCallback.RESULT_ERROR_TEMPORARILY_UNAVAILABLE */),
1552                         isNull());
1553     }
1554 
1555     @Test
testIwlanSetupDataCallSucceedsWithCellularOnDifferentSubAndCstEnabled()1556     public void testIwlanSetupDataCallSucceedsWithCellularOnDifferentSubAndCstEnabled()
1557             throws Exception {
1558         DataProfile dp = buildImsDataProfile();
1559 
1560         /* CST is enabled, but data is on the same sub as the DataServiceProvider */
1561         when(mMockImsMmTelManager.isCrossSimCallingEnabled()).thenReturn(true);
1562 
1563         NetworkCapabilities nc =
1564                 prepareNetworkCapabilitiesForTest(
1565                         TRANSPORT_CELLULAR, DEFAULT_SUB_INDEX + 1, false /* isVcn */);
1566         getNetworkMonitorCallback().onCapabilitiesChanged(mMockNetwork, nc);
1567 
1568         mSpyIwlanDataServiceProvider.setupDataCall(
1569                 AccessNetworkType.IWLAN, /* AccessNetworkType */
1570                 dp, /* dataProfile */
1571                 false, /* isRoaming */
1572                 true, /* allowRoaming */
1573                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
1574                 null, /* LinkProperties */
1575                 1, /* pduSessionId */
1576                 null, /* sliceInfo */
1577                 null, /* trafficDescriptor */
1578                 true, /* matchAllRuleAllowed */
1579                 mMockDataServiceCallback);
1580         mTestLooper.dispatchAll();
1581 
1582         /* Check bringUpTunnel() is called. */
1583         verify(mMockEpdgTunnelManager, times(1))
1584                 .bringUpTunnel(
1585                         any(TunnelSetupRequest.class),
1586                         any(IwlanTunnelCallback.class),
1587                         any(IwlanTunnelMetricsImpl.class));
1588 
1589         /* Check callback result is RESULT_SUCCESS when onOpened() is called. */
1590         mSpyIwlanDataServiceProvider
1591                 .getIwlanTunnelCallback()
1592                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
1593         mTestLooper.dispatchAll();
1594         verify(mMockDataServiceCallback, times(1))
1595                 .onSetupDataCallComplete(
1596                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
1597     }
1598 
1599     @Test
testIwlanTunnelStatsFailureCounts()1600     public void testIwlanTunnelStatsFailureCounts() {
1601         DataProfile dp = buildImsDataProfile();
1602 
1603         onSystemDefaultNetworkConnected(
1604                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
1605 
1606         long count = 3L;
1607         for (int i = 0; i < count; i++) {
1608             mockTunnelSetupFail(dp);
1609             mTestLooper.dispatchAll();
1610         }
1611 
1612         IwlanDataServiceProvider.IwlanDataTunnelStats stats =
1613                 mSpyIwlanDataServiceProvider.getTunnelStats();
1614         long result = stats.mTunnelSetupFailureCounts.get(TEST_APN_NAME);
1615         assertEquals(count, result);
1616     }
1617 
1618     @Test
testIwlanTunnelStatsUnsolDownCounts()1619     public void testIwlanTunnelStatsUnsolDownCounts() {
1620         DataProfile dp = buildImsDataProfile();
1621 
1622         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1623                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1624 
1625         onSystemDefaultNetworkConnected(
1626                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
1627 
1628         long count = 3L;
1629         for (int i = 0; i < count; i++) {
1630             mockTunnelSetupSuccess(dp, 0, null);
1631             mockUnsolTunnelDown();
1632         }
1633 
1634         IwlanDataServiceProvider.IwlanDataTunnelStats stats =
1635                 mSpyIwlanDataServiceProvider.getTunnelStats();
1636         long result = stats.mUnsolTunnelDownCounts.get(TEST_APN_NAME);
1637         assertEquals(result, count);
1638     }
1639 
1640     @Test
testIwlanTunnelStats()1641     public void testIwlanTunnelStats() {
1642         DataProfile dp = buildImsDataProfile();
1643         Calendar calendar = mock(Calendar.class);
1644         when(calendar.getTime()).thenAnswer(i -> new Date(mMockedCalendarTime));
1645 
1646         mSpyIwlanDataServiceProvider.setCalendar(calendar);
1647         onSystemDefaultNetworkConnected(
1648                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
1649 
1650         LongSummaryStatistics tunnelSetupSuccessStats = new LongSummaryStatistics();
1651         LongSummaryStatistics tunnelUpStats = new LongSummaryStatistics();
1652 
1653         Date beforeSetup = calendar.getTime();
1654         mockTunnelSetupSuccess(dp, 0, calendar);
1655         Date tunnelUp = calendar.getTime();
1656         mockDeactivateTunnel(0, calendar);
1657         Date tunnelDown = calendar.getTime();
1658         tunnelSetupSuccessStats.accept(tunnelUp.getTime() - beforeSetup.getTime());
1659         tunnelUpStats.accept(tunnelDown.getTime() - tunnelUp.getTime());
1660 
1661         beforeSetup = calendar.getTime();
1662         mockTunnelSetupSuccess(dp, 1000, calendar);
1663         tunnelUp = calendar.getTime();
1664         mockDeactivateTunnel(3000, calendar);
1665         tunnelDown = calendar.getTime();
1666         tunnelSetupSuccessStats.accept(tunnelUp.getTime() - beforeSetup.getTime());
1667         tunnelUpStats.accept(tunnelDown.getTime() - tunnelUp.getTime());
1668 
1669         beforeSetup = calendar.getTime();
1670         mockTunnelSetupSuccess(dp, 600, calendar);
1671         tunnelUp = calendar.getTime();
1672         mockDeactivateTunnel(500, calendar);
1673         tunnelDown = calendar.getTime();
1674         tunnelSetupSuccessStats.accept(tunnelUp.getTime() - beforeSetup.getTime());
1675         tunnelUpStats.accept(tunnelDown.getTime() - tunnelUp.getTime());
1676 
1677         IwlanDataServiceProvider.IwlanDataTunnelStats stats =
1678                 mSpyIwlanDataServiceProvider.getTunnelStats();
1679         LongSummaryStatistics finalSetupStats = stats.mTunnelSetupSuccessStats.get(TEST_APN_NAME);
1680         LongSummaryStatistics finalUpStats = stats.mTunnelUpStats.get(TEST_APN_NAME);
1681 
1682         assertEquals(tunnelSetupSuccessStats.getAverage(), finalSetupStats.getAverage(), 0);
1683         assertEquals(tunnelSetupSuccessStats.getCount(), finalSetupStats.getCount());
1684         assertEquals(tunnelSetupSuccessStats.getMax(), finalSetupStats.getMax(), 0);
1685 
1686         assertEquals(tunnelUpStats.getAverage(), finalUpStats.getAverage(), 0);
1687         assertEquals(tunnelUpStats.getCount(), finalUpStats.getCount());
1688         assertEquals(tunnelUpStats.getMax(), finalUpStats.getMax(), 0);
1689     }
1690 
1691     @Test
testUnexpectedTunnelClosedIsSuppressed()1692     public void testUnexpectedTunnelClosedIsSuppressed() {
1693         mockUnsolTunnelDown();
1694     }
1695 
1696     @Test
testIwlanDataServiceHandlerOnUnbind()1697     public void testIwlanDataServiceHandlerOnUnbind() {
1698         DataProfile dp = buildImsDataProfile();
1699 
1700         mSpyIwlanDataServiceProvider.setTunnelState(
1701                 dp,
1702                 mMockDataServiceCallback,
1703                 TunnelState.TUNNEL_UP,
1704                 null /* linkProperties */,
1705                 false /* isHandover */,
1706                 1 /* pduSessionId */,
1707                 true /* isImsOrEmergency */,
1708                 true /* isDataCallSetupWithN1 */);
1709 
1710         mSpyIwlanDataServiceProvider.setMetricsAtom(
1711                 TEST_APN_NAME,
1712                 64, // type IMS
1713                 true,
1714                 13, // LTE
1715                 false,
1716                 true,
1717                 1 // Transport Wi-Fi
1718                 );
1719 
1720         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1721                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1722 
1723         // Simulate IwlanDataService.onUnbind() which force close all tunnels
1724         mSpyIwlanDataServiceProvider.forceCloseTunnels(EpdgTunnelManager.BRINGDOWN_REASON_UNKNOWN);
1725         // Simulate DataService.onUnbind() which remove all IwlanDataServiceProviders
1726         mSpyIwlanDataServiceProvider.close();
1727         mTestLooper.dispatchAll();
1728 
1729         verify(mMockEpdgTunnelManager, atLeastOnce())
1730                 .closeTunnel(
1731                         eq(TEST_APN_NAME),
1732                         eq(true),
1733                         any(IwlanTunnelCallback.class),
1734                         any(IwlanTunnelMetricsImpl.class),
1735                         eq(EpdgTunnelManager.BRINGDOWN_REASON_UNKNOWN));
1736         assertNotNull(mIwlanDataService.mIwlanDataServiceHandler);
1737         // Should not raise NullPointerException
1738         mSpyIwlanDataServiceProvider
1739                 .getIwlanTunnelCallback()
1740                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
1741         mTestLooper.dispatchAll();
1742     }
1743 
1744     @Test
testBackToBackOnBindAndOnUnbindDoesNotThrow()1745     public void testBackToBackOnBindAndOnUnbindDoesNotThrow() {
1746         mIwlanDataService.onBind(null);
1747         mIwlanDataService.onUnbind(null);
1748     }
1749 
1750     @Test
testMetricsWhenTunnelClosedWithWrappedException()1751     public void testMetricsWhenTunnelClosedWithWrappedException() {
1752         DataProfile dp = buildImsDataProfile();
1753 
1754         mSpyIwlanDataServiceProvider.setTunnelState(
1755                 dp,
1756                 mMockDataServiceCallback,
1757                 TunnelState.TUNNEL_IN_BRINGUP,
1758                 null, /* linkProperties */
1759                 false /* isHandover */,
1760                 1 /* pduSessionId */,
1761                 true /* isImsOrEmergency */,
1762                 true /* isDataCallSetupWithN1 */);
1763 
1764         mSpyIwlanDataServiceProvider.setMetricsAtom(
1765                 TEST_APN_NAME,
1766                 64, // type IMS
1767                 true,
1768                 13, // LTE
1769                 false,
1770                 true,
1771                 1 // Transport Wi-Fi
1772                 );
1773 
1774         MetricsAtom metricsAtom = mSpyIwlanDataServiceProvider.getMetricsAtomByApn(TEST_APN_NAME);
1775         assertNotNull(metricsAtom);
1776 
1777         String exceptionMessage = "Some exception message";
1778         Exception mockException = spy(new IllegalStateException(exceptionMessage));
1779         String firstDeclaringClassName = "test.test.TestClass";
1780         String firstMethodName = "someMethod";
1781         String firstFileName = "TestClass.java";
1782         int firstLineNumber = 12345;
1783         StackTraceElement[] stackTraceElements = {
1784             new StackTraceElement(
1785                     firstDeclaringClassName, firstMethodName, firstFileName, firstLineNumber),
1786             new StackTraceElement("test", "test", "test.java", 123)
1787         };
1788         doReturn(stackTraceElements).when(mockException).getStackTrace();
1789 
1790         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1791                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1792 
1793         mSpyIwlanDataServiceProvider
1794                 .getIwlanTunnelCallback()
1795                 .onClosed(TEST_APN_NAME, new IwlanError(new IkeInternalException(mockException)));
1796 
1797         mTestLooper.dispatchAll();
1798 
1799         var expectedStackFirstFrame =
1800                 firstDeclaringClassName
1801                         + "."
1802                         + firstMethodName
1803                         + "("
1804                         + firstFileName
1805                         + ":"
1806                         + firstLineNumber
1807                         + ")";
1808 
1809         assertEquals(
1810                 mockException.getClass().getCanonicalName(),
1811                 metricsAtom.getIwlanErrorWrappedClassname());
1812 
1813         assertEquals(expectedStackFirstFrame, metricsAtom.getIwlanErrorWrappedStackFirstFrame());
1814     }
1815 
1816     @Test
testMetricsWhenTunnelClosedWithoutWrappedException()1817     public void testMetricsWhenTunnelClosedWithoutWrappedException() {
1818         DataProfile dp = buildImsDataProfile();
1819 
1820         mSpyIwlanDataServiceProvider.setTunnelState(
1821                 dp,
1822                 mMockDataServiceCallback,
1823                 TunnelState.TUNNEL_IN_BRINGUP,
1824                 null, /* linkProperties */
1825                 false /* isHandover */,
1826                 1 /* pduSessionId */,
1827                 true /* isImsOrEmergency */,
1828                 true /* isDataCallSetupWithN1 */);
1829 
1830         mSpyIwlanDataServiceProvider.setMetricsAtom(
1831                 TEST_APN_NAME,
1832                 64, // type IMS
1833                 true,
1834                 13, // LTE
1835                 false,
1836                 true,
1837                 1 // Transport Wi-Fi
1838                 );
1839 
1840         MetricsAtom metricsAtom = mSpyIwlanDataServiceProvider.getMetricsAtomByApn(TEST_APN_NAME);
1841         assertNotNull(metricsAtom);
1842 
1843         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1844                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1845 
1846         mSpyIwlanDataServiceProvider
1847                 .getIwlanTunnelCallback()
1848                 .onClosed(
1849                         TEST_APN_NAME,
1850                         new IwlanError(IwlanError.EPDG_SELECTOR_SERVER_SELECTION_FAILED));
1851 
1852         mTestLooper.dispatchAll();
1853 
1854         assertNull(metricsAtom.getIwlanErrorWrappedClassname());
1855         assertNull(metricsAtom.getIwlanErrorWrappedStackFirstFrame());
1856     }
1857 
1858     @Test
testMetricsWhenTunnelClosedWithErrorCount()1859     public void testMetricsWhenTunnelClosedWithErrorCount() {
1860         DataProfile dp = buildImsDataProfile();
1861 
1862         mSpyIwlanDataServiceProvider.setTunnelState(
1863                 dp,
1864                 mMockDataServiceCallback,
1865                 TunnelState.TUNNEL_IN_BRINGUP,
1866                 null, /* linkProperties */
1867                 false /* isHandover */,
1868                 1 /* pduSessionId */,
1869                 true /* isImsOrEmergency */,
1870                 true /* isDataCallSetupWithN1 */);
1871 
1872         mSpyIwlanDataServiceProvider.setMetricsAtom(
1873                 TEST_APN_NAME,
1874                 64, /* type IMS */
1875                 true,
1876                 13, /* LTE */
1877                 false,
1878                 true,
1879                 1 /* Transport Wi-Fi */);
1880 
1881         MetricsAtom metricsAtom = mSpyIwlanDataServiceProvider.getMetricsAtomByApn(TEST_APN_NAME);
1882         assertNotNull(metricsAtom);
1883 
1884         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
1885                 .thenReturn(DataFailCause.ERROR_UNSPECIFIED);
1886 
1887         when(mMockErrorPolicyManager.getLastErrorCountOfSameCause(eq(TEST_APN_NAME))).thenReturn(5);
1888 
1889         mSpyIwlanDataServiceProvider
1890                 .getIwlanTunnelCallback()
1891                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.IKE_PROTOCOL_EXCEPTION));
1892         mTestLooper.dispatchAll();
1893 
1894         assertEquals(5, metricsAtom.getErrorCountOfSameCause());
1895     }
1896 
mockTunnelSetupFail(DataProfile dp)1897     private void mockTunnelSetupFail(DataProfile dp) {
1898         mSpyIwlanDataServiceProvider.setupDataCall(
1899                 AccessNetworkType.IWLAN, /* AccessNetworkType */
1900                 dp, /* dataProfile */
1901                 false, /* isRoaming */
1902                 true, /* allowRoaming */
1903                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
1904                 null, /* LinkProperties */
1905                 1, /* pduSessionId */
1906                 null, /* sliceInfo */
1907                 null, /* trafficDescriptor */
1908                 true, /* matchAllRuleAllowed */
1909                 mMockDataServiceCallback);
1910         doReturn(true)
1911                 .when(mMockEpdgTunnelManager)
1912                 .bringUpTunnel(
1913                         any(TunnelSetupRequest.class),
1914                         any(IwlanTunnelCallback.class),
1915                         any(IwlanTunnelMetricsImpl.class));
1916 
1917         mSpyIwlanDataServiceProvider
1918                 .getIwlanTunnelCallback()
1919                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.IKE_INTERNAL_IO_EXCEPTION));
1920         mTestLooper.dispatchAll();
1921         verify(mMockDataServiceCallback, atLeastOnce())
1922                 .onSetupDataCallComplete(
1923                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
1924     }
1925 
mockTunnelSetupSuccess(DataProfile dp, long setupTime, Calendar calendar)1926     private void mockTunnelSetupSuccess(DataProfile dp, long setupTime, Calendar calendar) {
1927         mSpyIwlanDataServiceProvider.setupDataCall(
1928                 AccessNetworkType.IWLAN, /* AccessNetworkType */
1929                 dp, /* dataProfile */
1930                 false, /* isRoaming */
1931                 true, /* allowRoaming */
1932                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
1933                 null, /* LinkProperties */
1934                 1, /* pduSessionId */
1935                 null, /* sliceInfo */
1936                 null, /* trafficDescriptor */
1937                 true, /* matchAllRuleAllowed */
1938                 mMockDataServiceCallback);
1939         doReturn(true)
1940                 .when(mMockEpdgTunnelManager)
1941                 .bringUpTunnel(
1942                         any(TunnelSetupRequest.class),
1943                         any(IwlanTunnelCallback.class),
1944                         any(IwlanTunnelMetricsImpl.class));
1945         mTestLooper.dispatchAll();
1946 
1947         advanceCalendarByTimeMs(setupTime, calendar);
1948 
1949         mSpyIwlanDataServiceProvider
1950                 .getIwlanTunnelCallback()
1951                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
1952         mTestLooper.dispatchAll();
1953         verify(mMockDataServiceCallback, atLeastOnce())
1954                 .onSetupDataCallComplete(
1955                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
1956     }
1957 
mockUnsolTunnelDown()1958     private void mockUnsolTunnelDown() {
1959         mSpyIwlanDataServiceProvider
1960                 .getIwlanTunnelCallback()
1961                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.IKE_INTERNAL_IO_EXCEPTION));
1962         mTestLooper.dispatchAll();
1963     }
1964 
mockDeactivateTunnel(long deactivationTime, Calendar calendar)1965     private void mockDeactivateTunnel(long deactivationTime, Calendar calendar) {
1966         mSpyIwlanDataServiceProvider.deactivateDataCall(
1967                 TEST_APN_NAME.hashCode() /* cid: hashcode() of "ims" */,
1968                 DataService.REQUEST_REASON_NORMAL /* DataService.REQUEST_REASON_NORMAL */,
1969                 mMockDataServiceCallback);
1970         mTestLooper.dispatchAll();
1971         verify(mMockEpdgTunnelManager, atLeastOnce())
1972                 .closeTunnel(
1973                         eq(TEST_APN_NAME),
1974                         anyBoolean(),
1975                         any(IwlanTunnelCallback.class),
1976                         any(IwlanTunnelMetricsImpl.class),
1977                         eq(BRINGDOWN_REASON_DEACTIVATE_DATA_CALL));
1978 
1979         advanceCalendarByTimeMs(deactivationTime, calendar);
1980 
1981         mSpyIwlanDataServiceProvider
1982                 .getIwlanTunnelCallback()
1983                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
1984         mTestLooper.dispatchAll();
1985         verify(mMockDataServiceCallback, atLeastOnce())
1986                 .onDeactivateDataCallComplete(eq(DataServiceCallback.RESULT_SUCCESS));
1987     }
1988 
callUnsupportedAppUsageMethod( Object target, String methodName, Class<?>[] parameterTypes, Object[] args)1989     private void callUnsupportedAppUsageMethod(
1990             Object target, String methodName, Class<?>[] parameterTypes, Object[] args)
1991             throws Exception {
1992         Method method = target.getClass().getDeclaredMethod(methodName, parameterTypes);
1993         method.setAccessible(true);
1994         method.invoke(target, args);
1995     }
1996 
1997     @Test
testNetworkChangeDuringTunnelBringUp_closeTunnel()1998     public void testNetworkChangeDuringTunnelBringUp_closeTunnel() {
1999         DataProfile dp = buildImsDataProfile();
2000         Network newNetwork1 = createMockNetwork(mLinkProperties);
2001         onSystemDefaultNetworkConnected(
2002                 newNetwork1, mLinkProperties, TRANSPORT_WIFI, DEFAULT_SUB_INDEX);
2003 
2004         mSpyIwlanDataServiceProvider.setupDataCall(
2005                 AccessNetworkType.IWLAN, /* AccessNetworkType */
2006                 dp, /* dataProfile */
2007                 false, /* isRoaming */
2008                 true, /* allowRoaming */
2009                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
2010                 null, /* LinkProperties */
2011                 1, /* pduSessionId */
2012                 null, /* sliceInfo */
2013                 null, /* trafficDescriptor */
2014                 true, /* matchAllRuleAllowed */
2015                 mMockDataServiceCallback);
2016         mTestLooper.dispatchAll();
2017 
2018         /* Check bringUpTunnel() is called. */
2019         verify(mMockEpdgTunnelManager, times(1))
2020                 .bringUpTunnel(
2021                         any(TunnelSetupRequest.class),
2022                         any(IwlanTunnelCallback.class),
2023                         any(IwlanTunnelMetricsImpl.class));
2024 
2025         Network newNetwork2 = createMockNetwork(mLinkProperties);
2026         onSystemDefaultNetworkConnected(
2027                 newNetwork2, mLinkProperties, TRANSPORT_WIFI, DEFAULT_SUB_INDEX);
2028         verify(mMockEpdgTunnelManager, times(1))
2029                 .closeTunnel(
2030                         any(),
2031                         anyBoolean(),
2032                         any(),
2033                         any(),
2034                         eq(BRINGDOWN_REASON_NETWORK_UPDATE_WHEN_TUNNEL_IN_BRINGUP));
2035     }
2036 
createTunnelLinkProperties()2037     public static TunnelLinkProperties createTunnelLinkProperties() throws Exception {
2038         final String IP_ADDRESS = "192.0.2.1";
2039         final String DNS_ADDRESS = "8.8.8.8";
2040         final String PSCF_ADDRESS = "10.159.204.230";
2041         final String INTERFACE_NAME = "ipsec6";
2042         final NetworkSliceInfo SLICE_INFO =
2043                 NetworkSliceSelectionAssistanceInformation.getSliceInfo(new byte[] {1});
2044 
2045         List<LinkAddress> mInternalAddressList = new ArrayList<>();
2046         List<InetAddress> mDNSAddressList = new ArrayList<>();
2047         List<InetAddress> mPCSFAddressList = new ArrayList<>();
2048 
2049         mInternalAddressList.add(new LinkAddress(InetAddress.getByName(IP_ADDRESS), 3));
2050         mDNSAddressList.add(InetAddress.getByName(DNS_ADDRESS));
2051         mPCSFAddressList.add(InetAddress.getByName(PSCF_ADDRESS));
2052 
2053         return TunnelLinkProperties.builder()
2054                 .setInternalAddresses(mInternalAddressList)
2055                 .setDnsAddresses(mDNSAddressList)
2056                 .setPcscfAddresses(mPCSFAddressList)
2057                 .setIfaceName(INTERFACE_NAME)
2058                 .setSliceInfo(SLICE_INFO)
2059                 .build();
2060     }
2061 
mockCarrierConfigForN1Mode(boolean supportN1Mode)2062     private void mockCarrierConfigForN1Mode(boolean supportN1Mode) {
2063         PersistableBundle bundle = new PersistableBundle();
2064         if (supportN1Mode) {
2065             bundle.putIntArray(
2066                     CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY,
2067                     new int[] {
2068                         CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA,
2069                         CarrierConfigManager.CARRIER_NR_AVAILABILITY_SA
2070                     });
2071         } else {
2072             bundle.putIntArray(
2073                     CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY,
2074                     new int[] {CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA});
2075         }
2076         IwlanCarrierConfig.putTestConfigBundle(bundle);
2077     }
2078 
mockCallState(int callState)2079     private void mockCallState(int callState) {
2080         onSystemDefaultNetworkConnected(TRANSPORT_CELLULAR);
2081 
2082         mIwlanDataService
2083                 .mIwlanDataServiceHandler
2084                 .obtainMessage(
2085                         IwlanEventListener.CALL_STATE_CHANGED_EVENT, DEFAULT_SLOT_INDEX, callState)
2086                 .sendToTarget();
2087 
2088         mSpyIwlanDataServiceProvider.setMetricsAtom(
2089                 TEST_APN_NAME, 64, true, TelephonyManager.NETWORK_TYPE_LTE, false, true, 1);
2090     }
2091 
updatePreferredNetworkType(long networkTypeBitmask)2092     private void updatePreferredNetworkType(long networkTypeBitmask) {
2093         mIwlanDataService
2094                 .mIwlanDataServiceHandler
2095                 .obtainMessage(
2096                         IwlanEventListener.PREFERRED_NETWORK_TYPE_CHANGED_EVENT,
2097                         DEFAULT_SLOT_INDEX,
2098                         0 /* unused */,
2099                         networkTypeBitmask)
2100                 .sendToTarget();
2101         mTestLooper.dispatchAll();
2102     }
2103 
2104     @Test
testIsN1ModeSupported()2105     public void testIsN1ModeSupported() {
2106         PersistableBundle bundle = new PersistableBundle();
2107         bundle.putIntArray(
2108                 CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY,
2109                 new int[] {
2110                     CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA,
2111                     CarrierConfigManager.CARRIER_NR_AVAILABILITY_SA
2112                 });
2113         IwlanCarrierConfig.putTestConfigBundle(bundle);
2114         assertTrue(mSpyIwlanDataServiceProvider.isN1ModeSupported());
2115 
2116         bundle.putIntArray(
2117                 CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY,
2118                 new int[] {
2119                     CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA,
2120                 });
2121         IwlanCarrierConfig.putTestConfigBundle(bundle);
2122         assertFalse(mSpyIwlanDataServiceProvider.isN1ModeSupported());
2123     }
2124 
2125     @Test
testAllowedNetworkTypeChangeFromLteToNrInIdle_enableN1Mode()2126     public void testAllowedNetworkTypeChangeFromLteToNrInIdle_enableN1Mode() throws Exception {
2127         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
2128                 .thenReturn(DataFailCause.NONE);
2129         mockCarrierConfigForN1Mode(true);
2130         IwlanCarrierConfig.putTestConfigBoolean(
2131                 IwlanCarrierConfig.KEY_UPDATE_N1_MODE_ON_UI_CHANGE_BOOL, true);
2132         mockCallState(CALL_STATE_IDLE);
2133         mockSetupDataCallWithPduSessionId(0);
2134         mSpyIwlanDataServiceProvider
2135                 .getIwlanTunnelCallback()
2136                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
2137         mTestLooper.dispatchAll();
2138         verify(mMockDataServiceCallback, times(1))
2139                 .onSetupDataCallComplete(
2140                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2141         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2142 
2143         /* Check closeTunnel() is called. */
2144         verify(mMockEpdgTunnelManager, atLeastOnce())
2145                 .closeTunnel(
2146                         eq(TEST_APN_NAME),
2147                         eq(true),
2148                         any(IwlanTunnelCallback.class),
2149                         any(IwlanTunnelMetricsImpl.class),
2150                         eq(EpdgTunnelManager.BRINGDOWN_REASON_ENABLE_N1_MODE));
2151 
2152         mSpyIwlanDataServiceProvider
2153                 .getIwlanTunnelCallback()
2154                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
2155         mTestLooper.dispatchAll();
2156 
2157         // No additional DataServiceCallback response
2158         verify(mMockDataServiceCallback, times(1))
2159                 .onSetupDataCallComplete(
2160                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2161         verify(mMockDataServiceCallback, never()).onDeactivateDataCallComplete(anyInt());
2162     }
2163 
2164     @Test
testAllowedNetworkTypeChangeFromNrToLteInIdle_disableN1Mode()2165     public void testAllowedNetworkTypeChangeFromNrToLteInIdle_disableN1Mode() throws Exception {
2166         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
2167                 .thenReturn(DataFailCause.NONE);
2168         mockCarrierConfigForN1Mode(true);
2169         IwlanCarrierConfig.putTestConfigBoolean(
2170                 IwlanCarrierConfig.KEY_UPDATE_N1_MODE_ON_UI_CHANGE_BOOL, true);
2171         mockCallState(CALL_STATE_IDLE);
2172         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2173         mockSetupDataCallWithPduSessionId(5 /* pduSessionId */);
2174         mSpyIwlanDataServiceProvider
2175                 .getIwlanTunnelCallback()
2176                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
2177         mTestLooper.dispatchAll();
2178         verify(mMockDataServiceCallback, times(1))
2179                 .onSetupDataCallComplete(
2180                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2181         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_LTE);
2182 
2183         /* Check closeTunnel() is called. */
2184         verify(mMockEpdgTunnelManager, atLeastOnce())
2185                 .closeTunnel(
2186                         eq(TEST_APN_NAME),
2187                         eq(true),
2188                         any(IwlanTunnelCallback.class),
2189                         any(IwlanTunnelMetricsImpl.class),
2190                         eq(EpdgTunnelManager.BRINGDOWN_REASON_DISABLE_N1_MODE));
2191 
2192         mSpyIwlanDataServiceProvider
2193                 .getIwlanTunnelCallback()
2194                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
2195         mTestLooper.dispatchAll();
2196 
2197         // No additional DataServiceCallback response
2198         verify(mMockDataServiceCallback, times(1))
2199                 .onSetupDataCallComplete(
2200                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2201         verify(mMockDataServiceCallback, never()).onDeactivateDataCallComplete(anyInt());
2202     }
2203 
2204     @Test
testMultipleAllowedNetworkTypeChangeInCall_preferenceChanged_updateAfterCallEnds()2205     public void testMultipleAllowedNetworkTypeChangeInCall_preferenceChanged_updateAfterCallEnds()
2206             throws Exception {
2207         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
2208                 .thenReturn(DataFailCause.NONE);
2209         mockCarrierConfigForN1Mode(true);
2210         IwlanCarrierConfig.putTestConfigBoolean(
2211                 IwlanCarrierConfig.KEY_UPDATE_N1_MODE_ON_UI_CHANGE_BOOL, true);
2212 
2213         mockCallState(CALL_STATE_RINGING);
2214         mockSetupDataCallWithPduSessionId(0);
2215         mSpyIwlanDataServiceProvider
2216                 .getIwlanTunnelCallback()
2217                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
2218         mTestLooper.dispatchAll();
2219         verify(mMockDataServiceCallback, times(1))
2220                 .onSetupDataCallComplete(
2221                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2222         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2223         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_LTE);
2224         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2225 
2226         verify(mMockEpdgTunnelManager, never())
2227                 .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
2228 
2229         // in idle call state
2230         mIwlanDataService
2231                 .mIwlanDataServiceHandler
2232                 .obtainMessage(
2233                         IwlanEventListener.CALL_STATE_CHANGED_EVENT,
2234                         DEFAULT_SLOT_INDEX,
2235                         CALL_STATE_IDLE)
2236                 .sendToTarget();
2237         mTestLooper.dispatchAll();
2238 
2239         verify(mMockEpdgTunnelManager, atLeastOnce())
2240                 .closeTunnel(
2241                         eq(TEST_APN_NAME),
2242                         eq(true),
2243                         any(IwlanTunnelCallback.class),
2244                         any(IwlanTunnelMetricsImpl.class),
2245                         eq(EpdgTunnelManager.BRINGDOWN_REASON_ENABLE_N1_MODE));
2246 
2247         mSpyIwlanDataServiceProvider
2248                 .getIwlanTunnelCallback()
2249                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
2250         mTestLooper.dispatchAll();
2251 
2252         // No additional DataServiceCallback response
2253         verify(mMockDataServiceCallback, times(1))
2254                 .onSetupDataCallComplete(
2255                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2256         verify(mMockDataServiceCallback, never()).onDeactivateDataCallComplete(anyInt());
2257     }
2258 
2259     @Test
testMultipleAllowedNetworkTypeChangeInCall_preferenceNotChanged_noUpdate()2260     public void testMultipleAllowedNetworkTypeChangeInCall_preferenceNotChanged_noUpdate()
2261             throws Exception {
2262         mockCarrierConfigForN1Mode(true);
2263         IwlanCarrierConfig.putTestConfigBoolean(
2264                 IwlanCarrierConfig.KEY_UPDATE_N1_MODE_ON_UI_CHANGE_BOOL, true);
2265 
2266         mockCallState(CALL_STATE_RINGING);
2267         mockSetupDataCallWithPduSessionId(0);
2268         mSpyIwlanDataServiceProvider
2269                 .getIwlanTunnelCallback()
2270                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
2271         mTestLooper.dispatchAll();
2272         verify(mMockDataServiceCallback, times(1))
2273                 .onSetupDataCallComplete(
2274                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2275         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2276         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_LTE);
2277 
2278         verify(mMockEpdgTunnelManager, never())
2279                 .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
2280 
2281         // in idle call state
2282         mIwlanDataService
2283                 .mIwlanDataServiceHandler
2284                 .obtainMessage(
2285                         IwlanEventListener.CALL_STATE_CHANGED_EVENT,
2286                         DEFAULT_SLOT_INDEX,
2287                         CALL_STATE_IDLE)
2288                 .sendToTarget();
2289         mTestLooper.dispatchAll();
2290 
2291         verify(mMockEpdgTunnelManager, never())
2292                 .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
2293     }
2294 
2295     @Test
testOnAllowedNetworkTypeChange_flagDisabled_noTunnelClose()2296     public void testOnAllowedNetworkTypeChange_flagDisabled_noTunnelClose() {
2297         mockCarrierConfigForN1Mode(true);
2298         IwlanCarrierConfig.putTestConfigBoolean(
2299                 IwlanCarrierConfig.KEY_UPDATE_N1_MODE_ON_UI_CHANGE_BOOL, false);
2300 
2301         mockCallState(CALL_STATE_IDLE);
2302         mockSetupDataCallWithPduSessionId(0);
2303         mSpyIwlanDataServiceProvider
2304                 .getIwlanTunnelCallback()
2305                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
2306         mTestLooper.dispatchAll();
2307         verify(mMockDataServiceCallback, times(1))
2308                 .onSetupDataCallComplete(
2309                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2310         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2311 
2312         verify(mMockEpdgTunnelManager, never())
2313                 .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
2314     }
2315 
2316     @Test
testOnAllowedNetworkTypeChange_n1ModeNotSupported_noTunnelClose()2317     public void testOnAllowedNetworkTypeChange_n1ModeNotSupported_noTunnelClose() {
2318         mockCarrierConfigForN1Mode(false);
2319         IwlanCarrierConfig.putTestConfigBoolean(
2320                 IwlanCarrierConfig.KEY_UPDATE_N1_MODE_ON_UI_CHANGE_BOOL, true);
2321 
2322         mockCallState(CALL_STATE_IDLE);
2323         mockSetupDataCallWithPduSessionId(0);
2324         mSpyIwlanDataServiceProvider
2325                 .getIwlanTunnelCallback()
2326                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
2327         mTestLooper.dispatchAll();
2328         verify(mMockDataServiceCallback, times(1))
2329                 .onSetupDataCallComplete(
2330                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2331         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2332 
2333         verify(mMockEpdgTunnelManager, never())
2334                 .closeTunnel(any(), anyBoolean(), any(), any(), anyInt());
2335     }
2336 
2337     @Test
testN1ModeNotSupported_tunnelBringUpWithNoN1ModeCapability()2338     public void testN1ModeNotSupported_tunnelBringUpWithNoN1ModeCapability() {
2339         mockCarrierConfigForN1Mode(false);
2340         IwlanCarrierConfig.putTestConfigBoolean(
2341                 IwlanCarrierConfig.KEY_UPDATE_N1_MODE_ON_UI_CHANGE_BOOL, true);
2342 
2343         mockSetupDataCallWithPduSessionId(1);
2344         mSpyIwlanDataServiceProvider
2345                 .getIwlanTunnelCallback()
2346                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
2347         mTestLooper.dispatchAll();
2348         verify(mMockDataServiceCallback, times(1))
2349                 .onSetupDataCallComplete(
2350                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2351 
2352         ArgumentCaptor<TunnelSetupRequest> tunnelSetupRequestCaptor =
2353                 ArgumentCaptor.forClass(TunnelSetupRequest.class);
2354         verify(mMockEpdgTunnelManager, times(1))
2355                 .bringUpTunnel(tunnelSetupRequestCaptor.capture(), any(), any());
2356         TunnelSetupRequest tunnelSetupRequest = tunnelSetupRequestCaptor.getValue();
2357         assertEquals(PDU_SESSION_ID_UNSET, tunnelSetupRequest.getPduSessionId());
2358     }
2359 
2360     @Test
testNoN1ModeCapabilityInOngoingDataCall_newTunnelBringUp_doNotIncludeN1()2361     public void testNoN1ModeCapabilityInOngoingDataCall_newTunnelBringUp_doNotIncludeN1() {
2362         mockCarrierConfigForN1Mode(true);
2363         IwlanCarrierConfig.putTestConfigBoolean(
2364                 IwlanCarrierConfig.KEY_UPDATE_N1_MODE_ON_UI_CHANGE_BOOL, true);
2365 
2366         mockSetupDataCallWithPduSessionId(0);
2367         mSpyIwlanDataServiceProvider
2368                 .getIwlanTunnelCallback()
2369                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
2370         mTestLooper.dispatchAll();
2371         verify(mMockDataServiceCallback, times(1))
2372                 .onSetupDataCallComplete(
2373                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2374 
2375         ArgumentCaptor<TunnelSetupRequest> tunnelSetupRequestCaptor =
2376                 ArgumentCaptor.forClass(TunnelSetupRequest.class);
2377         verify(mMockEpdgTunnelManager, times(1))
2378                 .bringUpTunnel(tunnelSetupRequestCaptor.capture(), any(), any());
2379         TunnelSetupRequest tunnelSetupRequest = tunnelSetupRequestCaptor.getValue();
2380         assertEquals(PDU_SESSION_ID_UNSET, tunnelSetupRequest.getPduSessionId());
2381 
2382         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2383         mockSetupDataCallWithPduSessionId(1);
2384         mSpyIwlanDataServiceProvider
2385                 .getIwlanTunnelCallback()
2386                 .onOpened(TEST_APN_NAME, mMockTunnelLinkProperties);
2387         mTestLooper.dispatchAll();
2388         verify(mMockDataServiceCallback, times(2))
2389                 .onSetupDataCallComplete(
2390                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2391 
2392         verify(mMockEpdgTunnelManager, times(1))
2393                 .bringUpTunnel(tunnelSetupRequestCaptor.capture(), any(), any());
2394         tunnelSetupRequest = tunnelSetupRequestCaptor.getValue();
2395         assertEquals(PDU_SESSION_ID_UNSET, tunnelSetupRequest.getPduSessionId());
2396     }
2397 
mockSetupDataCallWithPduSessionId(int pduSessionId)2398     private void mockSetupDataCallWithPduSessionId(int pduSessionId) {
2399         DataProfile dp = buildImsDataProfile();
2400         verifySetupDataCallRequestHandled(pduSessionId, dp);
2401     }
2402 
verifySetupDataCallRequestHandled(int pduSessionId, DataProfile dp)2403     private void verifySetupDataCallRequestHandled(int pduSessionId, DataProfile dp) {
2404         onSystemDefaultNetworkConnected(
2405                 mMockNetwork, mLinkProperties, TRANSPORT_WIFI, INVALID_SUB_INDEX);
2406         mSpyIwlanDataServiceProvider.setupDataCall(
2407                 AccessNetworkType.IWLAN, /* AccessNetworkType */
2408                 dp, /* dataProfile */
2409                 false, /* isRoaming */
2410                 false, /* allowRoaming */
2411                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
2412                 null, /* LinkProperties */
2413                 pduSessionId, /* pduSessionId */
2414                 null, /* sliceInfo */
2415                 null, /* trafficDescriptor */
2416                 true, /* matchAllRuleAllowed */
2417                 mMockDataServiceCallback);
2418         mTestLooper.dispatchAll();
2419 
2420         verify(mMockEpdgTunnelManager, times(1))
2421                 .bringUpTunnel(
2422                         any(TunnelSetupRequest.class),
2423                         any(IwlanTunnelCallback.class),
2424                         any(IwlanTunnelMetricsImpl.class));
2425     }
2426 
2427     @Test
testN1ModeForEmergencySession()2428     public void testN1ModeForEmergencySession() {
2429         int pduSessionId = 5;
2430         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2431         DataProfile dp = buildDataProfile(ApnSetting.TYPE_EMERGENCY);
2432         verifySetupDataCallRequestHandled(pduSessionId, dp);
2433 
2434         ArgumentCaptor<TunnelSetupRequest> tunnelSetupRequestCaptor =
2435                 ArgumentCaptor.forClass(TunnelSetupRequest.class);
2436         verify(mMockEpdgTunnelManager, times(1))
2437                 .bringUpTunnel(tunnelSetupRequestCaptor.capture(), any(), any());
2438         TunnelSetupRequest tunnelSetupRequest = tunnelSetupRequestCaptor.getValue();
2439         assertEquals(pduSessionId, tunnelSetupRequest.getPduSessionId());
2440     }
2441 
2442     @Test
testN1ModeExclusionForEmergencySession()2443     public void testN1ModeExclusionForEmergencySession() {
2444         IwlanCarrierConfig.putTestConfigBoolean(
2445                 IwlanCarrierConfig.KEY_N1_MODE_EXCLUSION_FOR_EMERGENCY_SESSION_BOOL, true);
2446         updatePreferredNetworkType(NETWORK_TYPE_BITMASK_NR);
2447         DataProfile dp = buildDataProfile(ApnSetting.TYPE_EMERGENCY);
2448         verifySetupDataCallRequestHandled(5 /* pduSessionId */, dp);
2449 
2450         ArgumentCaptor<TunnelSetupRequest> tunnelSetupRequestCaptor =
2451                 ArgumentCaptor.forClass(TunnelSetupRequest.class);
2452         verify(mMockEpdgTunnelManager, times(1))
2453                 .bringUpTunnel(tunnelSetupRequestCaptor.capture(), any(), any());
2454         TunnelSetupRequest tunnelSetupRequest = tunnelSetupRequestCaptor.getValue();
2455         assertEquals(PDU_SESSION_ID_UNSET, tunnelSetupRequest.getPduSessionId());
2456     }
2457 
2458     @Test
testRequestNetworkValidationForUnregisteredApn()2459     public void testRequestNetworkValidationForUnregisteredApn() {
2460         int index = 0;
2461         String apnName = "mms";
2462         ArrayList<Integer> resultCodeCallback = new ArrayList<>();
2463         mSpyIwlanDataServiceProvider.requestNetworkValidation(
2464                 apnName.hashCode(), Runnable::run, resultCodeCallback::add);
2465         mTestLooper.dispatchAll();
2466 
2467         assertEquals(1, resultCodeCallback.size());
2468         assertEquals(
2469                 DataServiceCallback.RESULT_ERROR_UNSUPPORTED,
2470                 resultCodeCallback.get(index).intValue());
2471         verify(mMockEpdgTunnelManager, never()).requestNetworkValidationForApn(eq(apnName));
2472     }
2473 
verifySetupDataCallSuccess(DataProfile dp)2474     private void verifySetupDataCallSuccess(DataProfile dp) {
2475         verifySetupDataCallRequestHandled(5 /* pduSessionId */, dp);
2476 
2477         mSpyIwlanDataServiceProvider
2478                 .getIwlanTunnelCallback()
2479                 .onOpened(dp.getApnSetting().getApnName(), mMockTunnelLinkProperties);
2480         mTestLooper.dispatchAll();
2481     }
2482 
verifyDataCallListChangeAndCaptureUpdatedList()2483     private List<DataCallResponse> verifyDataCallListChangeAndCaptureUpdatedList() {
2484         ArgumentCaptor<List<DataCallResponse>> dataCallListCaptor =
2485                 ArgumentCaptor.forClass((Class) List.class);
2486         verify(mSpyIwlanDataServiceProvider, atLeastOnce())
2487                 .notifyDataCallListChanged(dataCallListCaptor.capture());
2488         return dataCallListCaptor.getValue();
2489     }
2490 
assertDataCallResponsePresentByCidAndStatus( int cid, int status, List<DataCallResponse> dataCallList)2491     private void assertDataCallResponsePresentByCidAndStatus(
2492             int cid, int status, List<DataCallResponse> dataCallList) {
2493         boolean isMatchFound = false;
2494 
2495         for (DataCallResponse response : dataCallList) {
2496             if (response.getId() == cid && response.getNetworkValidationStatus() == status) {
2497                 isMatchFound = true;
2498                 break;
2499             }
2500         }
2501 
2502         assertTrue(
2503                 "Expected CID and Network Validation Status not found in DataCallResponse list",
2504                 isMatchFound);
2505     }
2506 
2507     @Test
testOnNetworkValidationStatusChangedForRegisteredApn()2508     public void testOnNetworkValidationStatusChangedForRegisteredApn() {
2509         List<DataCallResponse> dataCallList;
2510 
2511         ArrayList<Integer> resultCodeCallback = new ArrayList<>();
2512         DataProfile dp = buildImsDataProfile();
2513         String apnName = dp.getApnSetting().getApnName();
2514         int cid = apnName.hashCode();
2515 
2516         verifySetupDataCallSuccess(dp);
2517         dataCallList = verifyDataCallListChangeAndCaptureUpdatedList();
2518         assertEquals(1, dataCallList.size());
2519         // TODO: b/324874097 - Fix IwlanDataServiceTest to correctly spy on
2520         // IwlanDataServiceProvider. Address flakiness caused by Mockito spy instrumentation issues
2521         // on Android. Investigate solutions.
2522         //
2523         // assertDataCallResponsePresentByCidAndStatus(
2524         //        cid, PreciseDataConnectionState.NETWORK_VALIDATION_SUCCESS, dataCallList);
2525 
2526         // Requests network validation
2527         mSpyIwlanDataServiceProvider.requestNetworkValidation(
2528                 cid, Runnable::run, resultCodeCallback::add);
2529         mTestLooper.dispatchAll();
2530 
2531         dataCallList = verifyDataCallListChangeAndCaptureUpdatedList();
2532         assertEquals(1, dataCallList.size());
2533         // TODO: b/324874097 - Fix IwlanDataServiceTest to correctly spy on
2534         // IwlanDataServiceProvider. Address flakiness caused by Mockito spy instrumentation issues
2535         // on Android. Investigate solutions.
2536         //
2537         // assertDataCallResponsePresentByCidAndStatus(
2538         //        cid, PreciseDataConnectionState.NETWORK_VALIDATION_IN_PROGRESS, dataCallList);
2539 
2540         // Validation success
2541         mSpyIwlanDataServiceProvider
2542                 .getIwlanTunnelCallback()
2543                 .onNetworkValidationStatusChanged(
2544                         dp.getApnSetting().getApnName(),
2545                         PreciseDataConnectionState.NETWORK_VALIDATION_SUCCESS);
2546         mTestLooper.dispatchAll();
2547 
2548         dataCallList = verifyDataCallListChangeAndCaptureUpdatedList();
2549         assertEquals(1, dataCallList.size());
2550         // TODO: b/324874097 - Fix IwlanDataServiceTest to correctly spy on
2551         // IwlanDataServiceProvider. Address flakiness caused by Mockito spy instrumentation issues
2552         // on Android. Investigate solutions.
2553         //
2554         // assertDataCallResponsePresentByCidAndStatus(
2555         //        cid, PreciseDataConnectionState.NETWORK_VALIDATION_SUCCESS, dataCallList);
2556     }
2557 
2558     @Test
testGetCallListWithRequestNetworkValidationInProgress()2559     public void testGetCallListWithRequestNetworkValidationInProgress() {
2560         ArgumentCaptor<List<DataCallResponse>> dataCallListCaptor =
2561                 ArgumentCaptor.forClass((Class) List.class);
2562         DataProfile dp = buildImsDataProfile();
2563         String apnName = dp.getApnSetting().getApnName();
2564         int cid = apnName.hashCode();
2565         verifySetupDataCallSuccess(dp);
2566 
2567         // Requests network validation, network validation status in progress
2568         ArrayList<Integer> resultCodeCallback = new ArrayList<>();
2569         mSpyIwlanDataServiceProvider.requestNetworkValidation(
2570                 cid, Runnable::run, resultCodeCallback::add);
2571         mTestLooper.dispatchAll();
2572 
2573         // Requests data call list
2574         mSpyIwlanDataServiceProvider.requestDataCallList(mMockDataServiceCallback);
2575         mTestLooper.dispatchAll();
2576 
2577         verify(mMockDataServiceCallback, times(1))
2578                 .onRequestDataCallListComplete(
2579                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallListCaptor.capture());
2580 
2581         List<DataCallResponse> dataCallList = dataCallListCaptor.getValue();
2582         assertEquals(1, dataCallList.size());
2583         assertDataCallResponsePresentByCidAndStatus(
2584                 cid, PreciseDataConnectionState.NETWORK_VALIDATION_IN_PROGRESS, dataCallList);
2585     }
2586 
2587     @Test
testSetupDataCallDuringDeactivateDataCallWithDelay_tunnelCloseWithOutOfSync()2588     public void testSetupDataCallDuringDeactivateDataCallWithDelay_tunnelCloseWithOutOfSync() {
2589         IwlanCarrierConfig.putTestConfigInt(
2590                 IwlanCarrierConfig.KEY_HANDOVER_TO_WWAN_RELEASE_DELAY_SECOND_INT, 3);
2591         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
2592                 .thenReturn(DataFailCause.NONE);
2593 
2594         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
2595 
2596         DataProfile dp = buildImsDataProfile();
2597         mSpyIwlanDataServiceProvider.setTunnelState(
2598                 dp,
2599                 mMockDataServiceCallback,
2600                 TunnelState.TUNNEL_UP,
2601                 null, /* linkProperties */
2602                 false, /* isHandover */
2603                 1, /* pduSessionId */
2604                 true /* isImsOrEmergency */,
2605                 true /* isDataCallSetupWithN1 */);
2606 
2607         mSpyIwlanDataServiceProvider.deactivateDataCall(
2608                 TEST_APN_NAME.hashCode() /* cid: hashcode() of "ims" */,
2609                 DataService.REQUEST_REASON_HANDOVER,
2610                 mMockDataServiceCallback);
2611 
2612         moveTimeForwardAndDispatch(50);
2613 
2614         /* Check closeTunnel() is not called. */
2615         verify(mMockEpdgTunnelManager, never())
2616                 .closeTunnel(
2617                         eq(TEST_APN_NAME),
2618                         anyBoolean(),
2619                         any(IwlanTunnelCallback.class),
2620                         any(IwlanTunnelMetricsImpl.class),
2621                         anyInt());
2622 
2623         mSpyIwlanDataServiceProvider.setupDataCall(
2624                 AccessNetworkType.IWLAN, /* AccessNetworkType */
2625                 dp, /* dataProfile */
2626                 false, /* isRoaming */
2627                 true, /* allowRoaming */
2628                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
2629                 null, /* LinkProperties */
2630                 1, /* pduSessionId */
2631                 null, /* sliceInfo */
2632                 null, /* trafficDescriptor */
2633                 true, /* matchAllRuleAllowed */
2634                 mMockDataServiceCallback);
2635         mTestLooper.dispatchAll();
2636 
2637         verify(mMockEpdgTunnelManager, times(1))
2638                 .closeTunnel(
2639                         eq(TEST_APN_NAME),
2640                         anyBoolean(),
2641                         any(IwlanTunnelCallback.class),
2642                         any(IwlanTunnelMetricsImpl.class),
2643                         eq(BRINGDOWN_REASON_SERVICE_OUT_OF_SYNC));
2644         verify(mMockDataServiceCallback, times(1))
2645                 .onSetupDataCallComplete(
2646                         eq(DataServiceCallback.RESULT_ERROR_TEMPORARILY_UNAVAILABLE), isNull());
2647         mSpyIwlanDataServiceProvider
2648                 .getIwlanTunnelCallback()
2649                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
2650         mTestLooper.dispatchAll();
2651         verify(mMockDataServiceCallback, times(1))
2652                 .onDeactivateDataCallComplete(eq(DataServiceCallback.RESULT_SUCCESS));
2653         moveTimeForwardAndDispatch(3000);
2654 
2655         // No additional callbacks are involved.
2656         verify(mMockDataServiceCallback, times(1)).onDeactivateDataCallComplete(anyInt());
2657     }
2658 
2659     @Test
testUpdateNetworkDuringTunnelBringUp_TunnelCloseWithOnSetupDataCallComplete()2660     public void testUpdateNetworkDuringTunnelBringUp_TunnelCloseWithOnSetupDataCallComplete() {
2661         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
2662                 .thenReturn(DataFailCause.NONE);
2663         // Wifi connected
2664         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
2665 
2666         DataProfile dp = buildImsDataProfile();
2667         mSpyIwlanDataServiceProvider.setupDataCall(
2668                 AccessNetworkType.IWLAN, /* AccessNetworkType */
2669                 dp, /* dataProfile */
2670                 false, /* isRoaming */
2671                 true, /* allowRoaming */
2672                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
2673                 null, /* LinkProperties */
2674                 1, /* pduSessionId */
2675                 null, /* sliceInfo */
2676                 null, /* trafficDescriptor */
2677                 true, /* matchAllRuleAllowed */
2678                 mMockDataServiceCallback);
2679         mTestLooper.dispatchAll();
2680 
2681         // Wifi reconnect
2682         onSystemDefaultNetworkLost();
2683         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
2684         verify(mMockEpdgTunnelManager, atLeastOnce())
2685                 .closeTunnel(
2686                         eq(TEST_APN_NAME),
2687                         eq(true),
2688                         any(IwlanTunnelCallback.class),
2689                         any(IwlanTunnelMetricsImpl.class),
2690                         eq(
2691                                 EpdgTunnelManager
2692                                         .BRINGDOWN_REASON_NETWORK_UPDATE_WHEN_TUNNEL_IN_BRINGUP));
2693 
2694         mSpyIwlanDataServiceProvider
2695                 .getIwlanTunnelCallback()
2696                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
2697         mTestLooper.dispatchAll();
2698 
2699         verify(mMockDataServiceCallback, times(1))
2700                 .onSetupDataCallComplete(
2701                         eq(DataServiceCallback.RESULT_SUCCESS), any(DataCallResponse.class));
2702         verify(mMockDataServiceCallback, never()).onDeactivateDataCallComplete(anyInt());
2703     }
2704 
2705     @Test
testNormalRetryTimer()2706     public void testNormalRetryTimer() {
2707         // Wifi connected
2708         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
2709 
2710         DataProfile dp = buildImsDataProfile();
2711         when(mMockErrorPolicyManager.getRemainingRetryTimeMs(eq(TEST_APN_NAME))).thenReturn(5L);
2712         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
2713                 .thenReturn(DataFailCause.USER_AUTHENTICATION);
2714 
2715         mSpyIwlanDataServiceProvider.setupDataCall(
2716                 AccessNetworkType.IWLAN, /* AccessNetworkType */
2717                 dp, /* dataProfile */
2718                 false, /* isRoaming */
2719                 true, /* allowRoaming */
2720                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
2721                 null, /* LinkProperties */
2722                 1, /* pduSessionId */
2723                 null, /* sliceInfo */
2724                 null, /* trafficDescriptor */
2725                 true, /* matchAllRuleAllowed */
2726                 mMockDataServiceCallback);
2727         mTestLooper.dispatchAll();
2728 
2729         mSpyIwlanDataServiceProvider.setMetricsAtom(
2730                 TEST_APN_NAME,
2731                 64, /* type IMS */
2732                 true,
2733                 13, /* LTE */
2734                 false,
2735                 true,
2736                 1 /* Transport Wi-Fi */);
2737 
2738         mSpyIwlanDataServiceProvider
2739                 .getIwlanTunnelCallback()
2740                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
2741         mTestLooper.dispatchAll();
2742 
2743         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
2744                 ArgumentCaptor.forClass(DataCallResponse.class);
2745 
2746         verify(mMockDataServiceCallback, times(1))
2747                 .onSetupDataCallComplete(
2748                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
2749         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
2750         assertEquals(5L, dataCallResponse.getRetryDurationMillis());
2751     }
2752 
2753     @Test
testEmergencyRetryTimerWithHandover()2754     public void testEmergencyRetryTimerWithHandover() {
2755         // Wifi connected
2756         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
2757 
2758         DataProfile dp = buildDataProfile(ApnSetting.TYPE_EMERGENCY);
2759         when(mMockErrorPolicyManager.getRemainingRetryTimeMs(eq(TEST_APN_NAME))).thenReturn(5L);
2760         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
2761                 .thenReturn(DataFailCause.USER_AUTHENTICATION);
2762 
2763         mSpyIwlanDataServiceProvider.setupDataCall(
2764                 AccessNetworkType.IWLAN, /* AccessNetworkType */
2765                 dp, /* dataProfile */
2766                 false, /* isRoaming */
2767                 true, /* allowRoaming */
2768                 DataService.REQUEST_REASON_HANDOVER, /* DataService.REQUEST_REASON_HANDOVER */
2769                 mLinkProperties, /* LinkProperties */
2770                 1, /* pduSessionId */
2771                 null, /* sliceInfo */
2772                 null, /* trafficDescriptor */
2773                 true, /* matchAllRuleAllowed */
2774                 mMockDataServiceCallback);
2775         mTestLooper.dispatchAll();
2776 
2777         mSpyIwlanDataServiceProvider.setMetricsAtom(
2778                 TEST_APN_NAME,
2779                 64, /* type IMS */
2780                 true,
2781                 13, /* LTE */
2782                 false,
2783                 true,
2784                 1 /* Transport Wi-Fi */);
2785 
2786         mSpyIwlanDataServiceProvider
2787                 .getIwlanTunnelCallback()
2788                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
2789         mTestLooper.dispatchAll();
2790 
2791         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
2792                 ArgumentCaptor.forClass(DataCallResponse.class);
2793 
2794         verify(mMockDataServiceCallback, times(1))
2795                 .onSetupDataCallComplete(
2796                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
2797         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
2798         assertEquals(5L, dataCallResponse.getRetryDurationMillis());
2799     }
2800 
2801     @Test
testEmergencyRetryTimerWithNoHandover()2802     public void testEmergencyRetryTimerWithNoHandover() {
2803         // Wifi connected
2804         onSystemDefaultNetworkConnected(TRANSPORT_WIFI);
2805 
2806         DataProfile dp = buildDataProfile(ApnSetting.TYPE_EMERGENCY);
2807         when(mMockErrorPolicyManager.getRemainingRetryTimeMs(eq(TEST_APN_NAME))).thenReturn(5L);
2808         when(mMockErrorPolicyManager.getDataFailCause(eq(TEST_APN_NAME)))
2809                 .thenReturn(DataFailCause.USER_AUTHENTICATION);
2810 
2811         mSpyIwlanDataServiceProvider.setupDataCall(
2812                 AccessNetworkType.IWLAN, /* AccessNetworkType */
2813                 dp, /* dataProfile */
2814                 false, /* isRoaming */
2815                 true, /* allowRoaming */
2816                 DataService.REQUEST_REASON_NORMAL, /* DataService.REQUEST_REASON_NORMAL */
2817                 null, /* LinkProperties */
2818                 1, /* pduSessionId */
2819                 null, /* sliceInfo */
2820                 null, /* trafficDescriptor */
2821                 true, /* matchAllRuleAllowed */
2822                 mMockDataServiceCallback);
2823         mTestLooper.dispatchAll();
2824 
2825         mSpyIwlanDataServiceProvider.setMetricsAtom(
2826                 TEST_APN_NAME,
2827                 64, /* type IMS */
2828                 true,
2829                 13, /* LTE */
2830                 false,
2831                 true,
2832                 1 /* Transport Wi-Fi */);
2833 
2834         mSpyIwlanDataServiceProvider
2835                 .getIwlanTunnelCallback()
2836                 .onClosed(TEST_APN_NAME, new IwlanError(IwlanError.NO_ERROR));
2837         mTestLooper.dispatchAll();
2838 
2839         ArgumentCaptor<DataCallResponse> dataCallResponseCaptor =
2840                 ArgumentCaptor.forClass(DataCallResponse.class);
2841 
2842         verify(mMockDataServiceCallback, times(1))
2843                 .onSetupDataCallComplete(
2844                         eq(DataServiceCallback.RESULT_SUCCESS), dataCallResponseCaptor.capture());
2845         DataCallResponse dataCallResponse = dataCallResponseCaptor.getValue();
2846         assertEquals(
2847                 DataCallResponse.RETRY_DURATION_UNDEFINED,
2848                 dataCallResponse.getRetryDurationMillis());
2849     }
2850 }
2851