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