1 /* 2 * Copyright (C) 2016 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.android.internal.telephony.dataconnection; 18 19 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED; 20 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_METERED; 21 import static android.net.NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED; 22 23 import static com.android.internal.telephony.TelephonyTestUtils.waitForMs; 24 import static com.android.internal.telephony.dataconnection.DcTrackerTest.FAKE_ADDRESS; 25 import static com.android.internal.telephony.dataconnection.DcTrackerTest.FAKE_DNS; 26 import static com.android.internal.telephony.dataconnection.DcTrackerTest.FAKE_GATEWAY; 27 import static com.android.internal.telephony.dataconnection.DcTrackerTest.FAKE_IFNAME; 28 import static com.android.internal.telephony.dataconnection.DcTrackerTest.FAKE_PCSCF_ADDRESS; 29 30 import static org.junit.Assert.assertEquals; 31 import static org.junit.Assert.assertFalse; 32 import static org.junit.Assert.assertTrue; 33 import static org.mockito.ArgumentMatchers.anyString; 34 import static org.mockito.Matchers.argThat; 35 import static org.mockito.Mockito.any; 36 import static org.mockito.Mockito.anyBoolean; 37 import static org.mockito.Mockito.anyInt; 38 import static org.mockito.Mockito.atLeastOnce; 39 import static org.mockito.Mockito.doAnswer; 40 import static org.mockito.Mockito.doReturn; 41 import static org.mockito.Mockito.eq; 42 import static org.mockito.Mockito.mock; 43 import static org.mockito.Mockito.times; 44 import static org.mockito.Mockito.verify; 45 46 import android.content.Context; 47 import android.content.pm.PackageManager; 48 import android.content.pm.UserInfo; 49 import android.net.InetAddresses; 50 import android.net.KeepalivePacketData; 51 import android.net.LinkAddress; 52 import android.net.LinkProperties; 53 import android.net.NattKeepalivePacketData; 54 import android.net.Network; 55 import android.net.NetworkCapabilities; 56 import android.net.vcn.VcnNetworkPolicyResult; 57 import android.os.AsyncResult; 58 import android.os.Handler; 59 import android.os.HandlerThread; 60 import android.os.Message; 61 import android.os.UserManager; 62 import android.provider.Telephony; 63 import android.telephony.AccessNetworkConstants; 64 import android.telephony.AccessNetworkConstants.AccessNetworkType; 65 import android.telephony.CarrierConfigManager; 66 import android.telephony.ServiceState; 67 import android.telephony.ServiceState.RegState; 68 import android.telephony.ServiceState.RilRadioTechnology; 69 import android.telephony.TelephonyManager; 70 import android.telephony.data.ApnSetting; 71 import android.telephony.data.DataCallResponse; 72 import android.telephony.data.DataProfile; 73 import android.telephony.data.DataService; 74 import android.telephony.data.DataServiceCallback; 75 import android.telephony.data.TrafficDescriptor; 76 import android.test.suitebuilder.annotation.MediumTest; 77 import android.test.suitebuilder.annotation.SmallTest; 78 import android.util.Pair; 79 80 import com.android.internal.R; 81 import com.android.internal.telephony.PhoneConstants; 82 import com.android.internal.telephony.RetryManager; 83 import com.android.internal.telephony.TelephonyTest; 84 import com.android.internal.telephony.data.KeepaliveStatus; 85 import com.android.internal.telephony.dataconnection.DataConnection.ConnectionParams; 86 import com.android.internal.telephony.dataconnection.DataConnection.DisconnectParams; 87 import com.android.internal.telephony.dataconnection.DataConnection.SetupResult; 88 import com.android.internal.telephony.metrics.DataCallSessionStats; 89 90 import org.junit.After; 91 import org.junit.Before; 92 import org.junit.Test; 93 import org.mockito.ArgumentCaptor; 94 95 import java.lang.reflect.Field; 96 import java.lang.reflect.Method; 97 import java.util.ArrayList; 98 import java.util.Arrays; 99 import java.util.Collections; 100 import java.util.function.Consumer; 101 102 public class DataConnectionTest extends TelephonyTest { 103 private static final int DEFAULT_DC_CID = 10; 104 private static final ArrayList<TrafficDescriptor> DEFAULT_TD_LIST = new ArrayList<>(); 105 106 // Mocked classes 107 DcTesterFailBringUpAll mDcTesterFailBringUpAll; 108 ConnectionParams mCp; 109 DisconnectParams mDcp; 110 ApnContext mApnContext; 111 ApnContext mEnterpriseApnContext; 112 DcFailBringUp mDcFailBringUp; 113 DataCallSessionStats mDataCallSessionStats; 114 DataConnection mDefaultDc; 115 DataServiceManager mDataServiceManager; 116 117 private DataConnection mDc; 118 private DataConnectionTestHandler mDataConnectionTestHandler; 119 private DcController mDcc; 120 121 private final ApnSetting mApn1 = new ApnSetting.Builder() 122 .setId(2163) 123 .setOperatorNumeric("44010") 124 .setEntryName("sp-mode") 125 .setApnName("spmode.ne.jp") 126 .setApnTypeBitmask(ApnSetting.TYPE_DEFAULT | ApnSetting.TYPE_SUPL) 127 .setProtocol(ApnSetting.PROTOCOL_IP) 128 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 129 .setCarrierEnabled(true) 130 .build(); 131 132 private final ApnSetting mApn2 = new ApnSetting.Builder() 133 .setId(2164) 134 .setOperatorNumeric("44010") 135 .setEntryName("sp-mode") 136 .setApnName("spmode.ne.jp") 137 .setApnTypeBitmask(ApnSetting.TYPE_DEFAULT | ApnSetting.TYPE_DUN) 138 .setProtocol(ApnSetting.PROTOCOL_IP) 139 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 140 .setCarrierEnabled(true) 141 .build(); 142 143 private final ApnSetting mApn3 = new ApnSetting.Builder() 144 .setId(2165) 145 .setOperatorNumeric("44010") 146 .setEntryName("sp-mode") 147 .setApnName("spmode.ne.jp") 148 .setApnTypeBitmask(ApnSetting.TYPE_DEFAULT) 149 .setProtocol(ApnSetting.PROTOCOL_IPV6) 150 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 151 .setNetworkTypeBitmask(0) 152 .setCarrierEnabled(true) 153 .setCarrierId(1) 154 .setSkip464Xlat(1) 155 .build(); 156 157 private final ApnSetting mApn4 = new ApnSetting.Builder() 158 .setId(2166) 159 .setOperatorNumeric("44010") 160 .setEntryName("sp-mode") 161 .setApnName("spmode.ne.jp") 162 .setApnTypeBitmask(ApnSetting.TYPE_IMS) 163 .setProtocol(ApnSetting.PROTOCOL_IPV6) 164 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 165 .setCarrierEnabled(true) 166 .build(); 167 168 private final ApnSetting mApn5 = new ApnSetting.Builder() 169 .setId(2167) 170 .setOperatorNumeric("44010") 171 .setEntryName("sp-mode") 172 .setApnName("spmode.ne.jp") 173 .setApnTypeBitmask(ApnSetting.TYPE_IMS) 174 .setProtocol(ApnSetting.PROTOCOL_IPV6) 175 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 176 .setCarrierEnabled(true) 177 .setSkip464Xlat(Telephony.Carriers.SKIP_464XLAT_DISABLE) 178 .build(); 179 180 private final ApnSetting mApn6 = new ApnSetting.Builder() 181 .setId(2168) 182 .setOperatorNumeric("44010") 183 .setEntryName("sp-mode") 184 .setApnName("spmode.ne.jp") 185 .setApnTypeBitmask(ApnSetting.TYPE_EMERGENCY) 186 .setProtocol(ApnSetting.PROTOCOL_IP) 187 .setRoamingProtocol(ApnSetting.PROTOCOL_IP) 188 .setCarrierEnabled(true) 189 .build(); 190 191 private class DataConnectionTestHandler extends HandlerThread { 192 DataConnectionTestHandler(String name)193 private DataConnectionTestHandler(String name) { 194 super(name); 195 } 196 197 @Override onLooperPrepared()198 public void onLooperPrepared() { 199 Handler h = new Handler(); 200 mDcc = DcController.makeDcc(mPhone, mDcTracker, mDataServiceManager, h.getLooper(), ""); 201 mDc = DataConnection.makeDataConnection(mPhone, 0, mDcTracker, mDataServiceManager, 202 mDcTesterFailBringUpAll, mDcc); 203 } 204 } 205 setSuccessfulSetupDataResponse(int cid, ArrayList<TrafficDescriptor> tds)206 private void setSuccessfulSetupDataResponse(int cid, ArrayList<TrafficDescriptor> tds) { 207 doAnswer(invocation -> { 208 final Message msg = (Message) invocation.getArguments()[10]; 209 210 DataCallResponse response = new DataCallResponse.Builder() 211 .setCause(0) 212 .setRetryDurationMillis(-1L) 213 .setId(cid) 214 .setLinkStatus(2) 215 .setProtocolType(ApnSetting.PROTOCOL_IPV4V6) 216 .setInterfaceName("ifname") 217 .setAddresses(Arrays.asList( 218 new LinkAddress(InetAddresses.parseNumericAddress("10.0.2.15"), 32), 219 new LinkAddress("2607:fb90:a620:651d:eabe:f8da:c107:44be/64"))) 220 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress("10.0.2.3"), 221 InetAddresses.parseNumericAddress("fd00:976a::9"))) 222 .setGatewayAddresses(Arrays.asList( 223 InetAddresses.parseNumericAddress("10.0.2.15"), 224 InetAddresses.parseNumericAddress("fe80::2"))) 225 .setPcscfAddresses(Arrays.asList( 226 InetAddresses.parseNumericAddress("fd00:976a:c305:1d::8"), 227 InetAddresses.parseNumericAddress("fd00:976a:c202:1d::7"), 228 InetAddresses.parseNumericAddress("fd00:976a:c305:1d::5"))) 229 .setMtu(1500) 230 .setMtuV4(1500) 231 .setMtuV6(1500) 232 .setPduSessionId(1) 233 .setQosBearerSessions(new ArrayList<>()) 234 .setTrafficDescriptors(tds) 235 .build(); 236 msg.getData().putParcelable("data_call_response", response); 237 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 238 msg.sendToTarget(); 239 return null; 240 }).when(mDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), anyBoolean(), 241 anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 242 any(Message.class)); 243 } 244 setFailedSetupDataResponse(@ataServiceCallback.ResultCode int resultCode)245 private void setFailedSetupDataResponse(@DataServiceCallback.ResultCode int resultCode) { 246 doAnswer(invocation -> { 247 final Message msg = (Message) invocation.getArguments()[10]; 248 msg.arg1 = resultCode; 249 msg.sendToTarget(); 250 return null; 251 }).when(mDataServiceManager).setupDataCall(anyInt(), any(DataProfile.class), anyBoolean(), 252 anyBoolean(), anyInt(), any(), anyInt(), any(), any(), anyBoolean(), 253 any(Message.class)); 254 } 255 256 @Before setUp()257 public void setUp() throws Exception { 258 super.setUp(getClass().getSimpleName()); 259 mDcTesterFailBringUpAll = mock(DcTesterFailBringUpAll.class); 260 mCp = mock(ConnectionParams.class); 261 mDcp = mock(DisconnectParams.class); 262 mApnContext = mock(ApnContext.class); 263 mEnterpriseApnContext = mock(ApnContext.class); 264 mDcFailBringUp = mock(DcFailBringUp.class); 265 mDataCallSessionStats = mock(DataCallSessionStats.class); 266 mDefaultDc = mock(DataConnection.class); 267 mDataServiceManager = mock(DataServiceManager.class); 268 logd("+Setup!"); 269 doReturn("fake.action_detached").when(mPhone).getActionDetached(); 270 doReturn(false).when(mPhone).isUsingNewDataStack(); 271 replaceInstance(ConnectionParams.class, "mApnContext", mCp, mApnContext); 272 replaceInstance(ConnectionParams.class, "mRilRat", mCp, 273 ServiceState.RIL_RADIO_TECHNOLOGY_UMTS); 274 doReturn(mApn1).when(mApnContext).getApnSetting(); 275 doReturn(ApnSetting.TYPE_DEFAULT_STRING).when(mApnContext).getApnType(); 276 doReturn(ApnSetting.TYPE_DEFAULT).when(mApnContext).getApnTypeBitmask(); 277 278 mDcFailBringUp.saveParameters(0, 0, -2); 279 doReturn(mDcFailBringUp).when(mDcTesterFailBringUpAll).getDcFailBringUp(); 280 281 mContextFixture.putStringArrayResource(com.android.internal.R.array 282 .config_mobile_tcp_buffers, new String[]{ 283 "umts:131072,262144,1452032,4096,16384,399360", 284 "hspa:131072,262144,2441216,4096,16384,399360", 285 "hsupa:131072,262144,2441216,4096,16384,399360", 286 "hsdpa:131072,262144,2441216,4096,16384,399360", 287 "hspap:131072,262144,2441216,4096,16384,399360", 288 "edge:16384,32768,131072,4096,16384,65536", 289 "gprs:4096,8192,24576,4096,8192,24576", 290 "1xrtt:16384,32768,131070,4096,16384,102400", 291 "evdo:131072,262144,1048576,4096,16384,524288", 292 "lte:524288,1048576,8388608,262144,524288,4194304"}); 293 294 mContextFixture.putResource(R.string.config_wwan_data_service_package, 295 "com.android.phone"); 296 297 mDcp.mApnContext = mApnContext; 298 299 setSuccessfulSetupDataResponse(DEFAULT_DC_CID, DEFAULT_TD_LIST); 300 301 doAnswer(invocation -> { 302 final Message msg = (Message) invocation.getArguments()[2]; 303 msg.arg1 = DataServiceCallback.RESULT_SUCCESS; 304 msg.sendToTarget(); 305 return null; 306 }).when(mDataServiceManager).deactivateDataCall(anyInt(), anyInt(), any(Message.class)); 307 308 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mDataServiceManager) 309 .getTransportType(); 310 311 mDataConnectionTestHandler = new DataConnectionTestHandler(getClass().getSimpleName()); 312 mDataConnectionTestHandler.start(); 313 314 waitForMs(200); 315 mDc.setDataCallSessionStats(mDataCallSessionStats); 316 317 logd("-Setup!"); 318 } 319 320 @After tearDown()321 public void tearDown() throws Exception { 322 logd("tearDown"); 323 mDc.quitNow(); 324 mDc = null; 325 mDataConnectionTestHandler.quit(); 326 mDataConnectionTestHandler.join(); 327 mDataConnectionTestHandler = null; 328 mDcc.removeCallbacksAndMessages(null); 329 mDcc = null; 330 DEFAULT_TD_LIST.clear(); 331 waitForMs(100); 332 super.tearDown(); 333 } 334 getSuggestedRetryDelay(DataCallResponse response)335 private long getSuggestedRetryDelay(DataCallResponse response) throws Exception { 336 Class[] cArgs = new Class[1]; 337 cArgs[0] = DataCallResponse.class; 338 Method method = DataConnection.class.getDeclaredMethod("getSuggestedRetryDelay", cArgs); 339 method.setAccessible(true); 340 return (long) method.invoke(mDc, response); 341 } 342 isUnmeteredUseOnly()343 private boolean isUnmeteredUseOnly() throws Exception { 344 Method method = DataConnection.class.getDeclaredMethod("isUnmeteredUseOnly"); 345 method.setAccessible(true); 346 return (boolean) method.invoke(mDc); 347 } 348 isEnterpriseUse()349 private boolean isEnterpriseUse() throws Exception { 350 Method method = DataConnection.class.getDeclaredMethod("isEnterpriseUse"); 351 method.setAccessible(true); 352 return (boolean) method.invoke(mDc); 353 } 354 isSuspended()355 private boolean isSuspended() throws Exception { 356 Field field = DataConnection.class.getDeclaredField("mIsSuspended"); 357 field.setAccessible(true); 358 return field.getBoolean(mDc); 359 } 360 setLinkProperties(DataCallResponse response, LinkProperties linkProperties)361 private SetupResult setLinkProperties(DataCallResponse response, LinkProperties linkProperties) 362 throws Exception { 363 Class[] cArgs = new Class[2]; 364 cArgs[0] = DataCallResponse.class; 365 cArgs[1] = LinkProperties.class; 366 Method method = DataConnection.class.getDeclaredMethod("setLinkProperties", cArgs); 367 method.setAccessible(true); 368 return (SetupResult) method.invoke(mDc, response, linkProperties); 369 } 370 371 @Test 372 @SmallTest testConnectEvent()373 public void testConnectEvent() { 374 assertTrue(mDc.isInactive()); 375 connectEvent(true); 376 377 verify(mCT, times(1)).registerForVoiceCallStarted(any(Handler.class), 378 eq(DataConnection.EVENT_DATA_CONNECTION_VOICE_CALL_STARTED), eq(null)); 379 verify(mCT, times(1)).registerForVoiceCallEnded(any(Handler.class), 380 eq(DataConnection.EVENT_DATA_CONNECTION_VOICE_CALL_ENDED), eq(null)); 381 verify(mSimulatedCommandsVerifier, times(1)) 382 .registerForNattKeepaliveStatus(any(Handler.class), 383 eq(DataConnection.EVENT_KEEPALIVE_STATUS), eq(null)); 384 verify(mSimulatedCommandsVerifier, times(1)) 385 .registerForLceInfo(any(Handler.class), 386 eq(DataConnection.EVENT_LINK_CAPACITY_CHANGED), eq(null)); 387 verify(mVcnManager, atLeastOnce()) 388 .applyVcnNetworkPolicy( 389 argThat(caps -> 390 caps.hasCapability( 391 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)), 392 any()); 393 394 ArgumentCaptor<DataProfile> dpCaptor = ArgumentCaptor.forClass(DataProfile.class); 395 ArgumentCaptor<TrafficDescriptor> tdCaptor = 396 ArgumentCaptor.forClass(TrafficDescriptor.class); 397 verify(mDataServiceManager, times(1)).setupDataCall( 398 eq(AccessNetworkType.UTRAN), dpCaptor.capture(), eq(false), 399 eq(false), eq(DataService.REQUEST_REASON_NORMAL), any(), 400 anyInt(), any(), tdCaptor.capture(), anyBoolean(), any(Message.class)); 401 402 verify(mSimulatedCommandsVerifier, times(0)) 403 .allocatePduSessionId(any()); 404 405 assertEquals("spmode.ne.jp", dpCaptor.getValue().getApn()); 406 if (tdCaptor.getValue() != null) { 407 if (mApnContext.getApnTypeBitmask() == ApnSetting.TYPE_ENTERPRISE) { 408 assertEquals(null, tdCaptor.getValue().getDataNetworkName()); 409 assertTrue(Arrays.equals(DataConnection.getEnterpriseOsAppId(), 410 tdCaptor.getValue().getOsAppId())); 411 } else { 412 assertEquals("spmode.ne.jp", tdCaptor.getValue().getDataNetworkName()); 413 assertEquals(null, tdCaptor.getValue().getOsAppId()); 414 } 415 } 416 assertTrue(mDc.isActive()); 417 418 assertEquals(1, mDc.getPduSessionId()); 419 assertEquals(3, mDc.getPcscfAddresses().length); 420 assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c305:1d::8"::equals)); 421 assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c202:1d::7"::equals)); 422 assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c305:1d::5"::equals)); 423 } 424 425 @Test 426 @SmallTest testConnectOnIwlan()427 public void testConnectOnIwlan() throws Exception { 428 assertTrue(mDc.isInactive()); 429 Field field = DataConnection.class.getDeclaredField("mTransportType"); 430 field.setAccessible(true); 431 field.setInt(mDc, AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 432 connectEvent(true); 433 434 verify(mCT, times(1)).registerForVoiceCallStarted(any(Handler.class), 435 eq(DataConnection.EVENT_DATA_CONNECTION_VOICE_CALL_STARTED), eq(null)); 436 verify(mCT, times(1)).registerForVoiceCallEnded(any(Handler.class), 437 eq(DataConnection.EVENT_DATA_CONNECTION_VOICE_CALL_ENDED), eq(null)); 438 verify(mSimulatedCommandsVerifier, times(0)) 439 .registerForNattKeepaliveStatus(any(Handler.class), 440 eq(DataConnection.EVENT_KEEPALIVE_STATUS), eq(null)); 441 verify(mSimulatedCommandsVerifier, times(0)) 442 .registerForLceInfo(any(Handler.class), 443 eq(DataConnection.EVENT_LINK_CAPACITY_CHANGED), eq(null)); 444 verify(mVcnManager, atLeastOnce()) 445 .applyVcnNetworkPolicy( 446 argThat(caps -> 447 caps.hasCapability( 448 NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)), 449 any()); 450 451 ArgumentCaptor<DataProfile> dpCaptor = ArgumentCaptor.forClass(DataProfile.class); 452 ArgumentCaptor<TrafficDescriptor> tdCaptor = 453 ArgumentCaptor.forClass(TrafficDescriptor.class); 454 verify(mDataServiceManager, times(1)).setupDataCall( 455 eq(AccessNetworkType.UTRAN), dpCaptor.capture(), eq(false), 456 eq(false), eq(DataService.REQUEST_REASON_NORMAL), any(), 457 anyInt(), any(), tdCaptor.capture(), anyBoolean(), any(Message.class)); 458 459 verify(mSimulatedCommandsVerifier, times(1)) 460 .allocatePduSessionId(any()); 461 462 assertEquals("spmode.ne.jp", dpCaptor.getValue().getApn()); 463 if (tdCaptor.getValue() != null) { 464 if (mApnContext.getApnTypeBitmask() == ApnSetting.TYPE_ENTERPRISE) { 465 assertEquals(null, tdCaptor.getValue().getDataNetworkName()); 466 assertTrue(Arrays.equals(DataConnection.getEnterpriseOsAppId(), 467 tdCaptor.getValue().getOsAppId())); 468 } else { 469 assertEquals("spmode.ne.jp", tdCaptor.getValue().getDataNetworkName()); 470 assertEquals(null, tdCaptor.getValue().getOsAppId()); 471 } 472 } 473 assertTrue(mDc.isActive()); 474 475 assertEquals(1, mDc.getPduSessionId()); 476 assertEquals(3, mDc.getPcscfAddresses().length); 477 assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c305:1d::8"::equals)); 478 assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c202:1d::7"::equals)); 479 assertTrue(Arrays.stream(mDc.getPcscfAddresses()).anyMatch("fd00:976a:c305:1d::5"::equals)); 480 } 481 482 @Test testConnectEventDuplicateContextIds()483 public void testConnectEventDuplicateContextIds() throws Exception { 484 setUpDefaultData(DEFAULT_DC_CID); 485 486 // Try to connect ENTERPRISE with the same CID as default 487 replaceInstance(ConnectionParams.class, "mApnContext", mCp, mEnterpriseApnContext); 488 doReturn(mApn1).when(mEnterpriseApnContext).getApnSetting(); 489 doReturn(ApnSetting.TYPE_ENTERPRISE_STRING).when(mEnterpriseApnContext).getApnType(); 490 doReturn(ApnSetting.TYPE_ENTERPRISE).when(mEnterpriseApnContext).getApnTypeBitmask(); 491 492 // Verify that ENTERPRISE wasn't set up 493 connectEvent(false); 494 assertTrue(mDc.isInactive()); 495 496 // Change the CID 497 setSuccessfulSetupDataResponse(DEFAULT_DC_CID + 1, DEFAULT_TD_LIST); 498 499 // Verify that ENTERPRISE was set up 500 connectEvent(true); 501 assertTrue(mDc.getNetworkCapabilities().hasCapability( 502 NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 503 } 504 505 @Test testConnectEventDuplicateContextIdsDifferentTDs()506 public void testConnectEventDuplicateContextIdsDifferentTDs() throws Exception { 507 setUpDefaultData(DEFAULT_DC_CID); 508 509 // Try to connect ENTERPRISE with the same CID as default but different TrafficDescriptors 510 replaceInstance(ConnectionParams.class, "mApnContext", mCp, mEnterpriseApnContext); 511 doReturn(mApn1).when(mEnterpriseApnContext).getApnSetting(); 512 doReturn(ApnSetting.TYPE_ENTERPRISE_STRING).when(mEnterpriseApnContext).getApnType(); 513 doReturn(ApnSetting.TYPE_ENTERPRISE).when(mEnterpriseApnContext).getApnTypeBitmask(); 514 ArrayList<TrafficDescriptor> tdList = new ArrayList<>(); 515 tdList.add(new TrafficDescriptor("dnn", DataConnection.getEnterpriseOsAppId())); 516 setSuccessfulSetupDataResponse(DEFAULT_DC_CID, tdList); 517 518 // Verify that ENTERPRISE wasn't set up but the TD list was updated 519 connectEvent(false); 520 assertTrue(mDc.isInactive()); 521 ArgumentCaptor<DataCallResponse> captor = ArgumentCaptor.forClass(DataCallResponse.class); 522 verify(mDefaultDc).updateTrafficDescriptors(captor.capture()); 523 assertEquals(tdList, captor.getValue().getTrafficDescriptors()); 524 } 525 526 @Test testConnectEventNoDefaultData()527 public void testConnectEventNoDefaultData() throws Exception { 528 assertFalse(mDefaultDc.isActive()); 529 530 // Try to connect ENTERPRISE when default data doesn't exist 531 replaceInstance(ConnectionParams.class, "mApnContext", mCp, mEnterpriseApnContext); 532 doReturn(mApn1).when(mEnterpriseApnContext).getApnSetting(); 533 doReturn(ApnSetting.TYPE_ENTERPRISE_STRING).when(mEnterpriseApnContext).getApnType(); 534 doReturn(ApnSetting.TYPE_ENTERPRISE).when(mEnterpriseApnContext).getApnTypeBitmask(); 535 536 // Verify that ENTERPRISE wasn't set up 537 connectEvent(false); 538 assertTrue(mDc.isInactive()); 539 540 // Set up default data 541 replaceInstance(ConnectionParams.class, "mApnContext", mCp, mApnContext); 542 setUpDefaultData(1); 543 544 // Verify that ENTERPRISE was set up 545 replaceInstance(ConnectionParams.class, "mApnContext", mCp, mEnterpriseApnContext); 546 connectEvent(true); 547 assertTrue(mDc.getNetworkCapabilities().hasCapability( 548 NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 549 } 550 setUpDefaultData(int cid)551 private void setUpDefaultData(int cid) throws Exception { 552 replaceInstance(DataConnection.class, "mCid", mDefaultDc, cid); 553 doReturn(true).when(mDefaultDc).isActive(); 554 doReturn(Arrays.asList(mApnContext)).when(mDefaultDc).getApnContexts(); 555 mDcc.addActiveDcByCid(mDefaultDc); 556 assertTrue(mDefaultDc.getApnContexts().stream() 557 .anyMatch(apn -> apn.getApnTypeBitmask() == ApnSetting.TYPE_DEFAULT)); 558 } 559 560 @Test 561 @SmallTest testDisconnectEvent()562 public void testDisconnectEvent() { 563 testConnectEvent(); 564 565 mDc.setPduSessionId(5); 566 disconnectEvent(); 567 568 verify(mSimulatedCommandsVerifier, times(1)).unregisterForLceInfo(any(Handler.class)); 569 verify(mSimulatedCommandsVerifier, times(1)) 570 .unregisterForNattKeepaliveStatus(any(Handler.class)); 571 verify(mDataServiceManager, times(1)).deactivateDataCall(eq(DEFAULT_DC_CID), 572 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 573 verify(mSimulatedCommandsVerifier, times(0)) 574 .releasePduSessionId(any(), eq(5)); 575 576 assertTrue(mDc.isInactive()); 577 } 578 579 @Test 580 @SmallTest testDisconnectOnIwlan()581 public void testDisconnectOnIwlan() throws Exception { 582 testConnectEvent(); 583 584 Field field = DataConnection.class.getDeclaredField("mTransportType"); 585 field.setAccessible(true); 586 field.setInt(mDc, AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 587 mDc.setPduSessionId(5); 588 disconnectEvent(); 589 590 verify(mSimulatedCommandsVerifier, times(0)).unregisterForLceInfo(any(Handler.class)); 591 verify(mSimulatedCommandsVerifier, times(0)) 592 .unregisterForNattKeepaliveStatus(any(Handler.class)); 593 verify(mDataServiceManager, times(1)).deactivateDataCall(eq(DEFAULT_DC_CID), 594 eq(DataService.REQUEST_REASON_NORMAL), any(Message.class)); 595 verify(mSimulatedCommandsVerifier, times(1)) 596 .releasePduSessionId(any(), eq(5)); 597 598 assertTrue(mDc.isInactive()); 599 } 600 601 @Test 602 @SmallTest testModemSuggestRetry()603 public void testModemSuggestRetry() throws Exception { 604 DataCallResponse response = new DataCallResponse.Builder() 605 .setCause(0) 606 .setRetryDurationMillis(0) 607 .setId(1) 608 .setLinkStatus(2) 609 .setProtocolType(ApnSetting.PROTOCOL_IP) 610 .setInterfaceName(FAKE_IFNAME) 611 .setAddresses(Arrays.asList( 612 new LinkAddress(InetAddresses.parseNumericAddress(FAKE_ADDRESS), 0))) 613 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_DNS))) 614 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 615 .setPcscfAddresses( 616 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 617 .setMtuV4(1440) 618 .setMtuV6(1440) 619 .build(); 620 assertEquals(response.getSuggestedRetryTime(), getSuggestedRetryDelay(response)); 621 622 response = new DataCallResponse.Builder() 623 .setCause(0) 624 .setRetryDurationMillis(1000) 625 .setId(1) 626 .setLinkStatus(2) 627 .setProtocolType(ApnSetting.PROTOCOL_IP) 628 .setInterfaceName(FAKE_IFNAME) 629 .setAddresses(Arrays.asList( 630 new LinkAddress(InetAddresses.parseNumericAddress(FAKE_ADDRESS), 0))) 631 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_DNS))) 632 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 633 .setPcscfAddresses( 634 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 635 .setMtuV4(1440) 636 .setMtuV6(1440) 637 .build(); 638 assertEquals(response.getSuggestedRetryTime(), getSuggestedRetryDelay(response)); 639 640 response = new DataCallResponse.Builder() 641 .setCause(0) 642 .setRetryDurationMillis(9999) 643 .setId(1) 644 .setLinkStatus(2) 645 .setProtocolType(ApnSetting.PROTOCOL_IP) 646 .setInterfaceName(FAKE_IFNAME) 647 .setAddresses(Arrays.asList( 648 new LinkAddress(InetAddresses.parseNumericAddress(FAKE_ADDRESS), 0))) 649 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_DNS))) 650 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 651 .setPcscfAddresses( 652 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 653 .setMtuV4(1440) 654 .setMtuV6(1440) 655 .build(); 656 assertEquals(response.getSuggestedRetryTime(), getSuggestedRetryDelay(response)); 657 } 658 659 @Test 660 @SmallTest testModemNotSuggestRetry()661 public void testModemNotSuggestRetry() throws Exception { 662 DataCallResponse response = new DataCallResponse.Builder() 663 .setCause(0) 664 .setRetryDurationMillis(-1) 665 .setId(1) 666 .setLinkStatus(2) 667 .setProtocolType(ApnSetting.PROTOCOL_IP) 668 .setInterfaceName(FAKE_IFNAME) 669 .setAddresses(Arrays.asList( 670 new LinkAddress(InetAddresses.parseNumericAddress(FAKE_ADDRESS), 0))) 671 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_DNS))) 672 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 673 .setPcscfAddresses( 674 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 675 .setMtuV4(1440) 676 .setMtuV6(1440) 677 .build(); 678 assertEquals(RetryManager.NO_SUGGESTED_RETRY_DELAY, getSuggestedRetryDelay(response)); 679 680 response = new DataCallResponse.Builder() 681 .setCause(0) 682 .setRetryDurationMillis(-5) 683 .setId(1) 684 .setLinkStatus(2) 685 .setProtocolType(ApnSetting.PROTOCOL_IP) 686 .setInterfaceName(FAKE_IFNAME) 687 .setAddresses(Arrays.asList( 688 new LinkAddress(InetAddresses.parseNumericAddress(FAKE_ADDRESS), 0))) 689 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_DNS))) 690 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 691 .setPcscfAddresses( 692 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 693 .setMtuV4(1440) 694 .setMtuV6(1440) 695 .build(); 696 assertEquals(RetryManager.NO_SUGGESTED_RETRY_DELAY, getSuggestedRetryDelay(response)); 697 698 response = new DataCallResponse.Builder() 699 .setCause(0) 700 .setRetryDurationMillis(Long.MIN_VALUE) 701 .setId(1) 702 .setLinkStatus(2) 703 .setProtocolType(ApnSetting.PROTOCOL_IP) 704 .setInterfaceName(FAKE_IFNAME) 705 .setAddresses(Arrays.asList( 706 new LinkAddress(InetAddresses.parseNumericAddress(FAKE_ADDRESS), 0))) 707 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_DNS))) 708 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 709 .setPcscfAddresses( 710 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 711 .setMtuV4(1440) 712 .setMtuV6(1440) 713 .build(); 714 assertEquals(RetryManager.NO_SUGGESTED_RETRY_DELAY, getSuggestedRetryDelay(response)); 715 } 716 717 @Test 718 @SmallTest testModemSuggestNoRetry()719 public void testModemSuggestNoRetry() throws Exception { 720 DataCallResponse response = new DataCallResponse.Builder() 721 .setCause(0) 722 .setRetryDurationMillis(Long.MAX_VALUE) 723 .setId(1) 724 .setLinkStatus(2) 725 .setProtocolType(ApnSetting.PROTOCOL_IP) 726 .setInterfaceName(FAKE_IFNAME) 727 .setAddresses(Arrays.asList( 728 new LinkAddress(InetAddresses.parseNumericAddress(FAKE_ADDRESS), 0))) 729 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_DNS))) 730 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 731 .setPcscfAddresses( 732 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 733 .setMtuV4(1440) 734 .setMtuV6(1440) 735 .build(); 736 assertEquals(RetryManager.NO_RETRY, getSuggestedRetryDelay(response)); 737 } 738 getNetworkCapabilities()739 private NetworkCapabilities getNetworkCapabilities() throws Exception { 740 Method method = DataConnection.class.getDeclaredMethod("getNetworkCapabilities"); 741 method.setAccessible(true); 742 return (NetworkCapabilities) method.invoke(mDc); 743 } 744 getDisallowedApnTypes()745 private int getDisallowedApnTypes() throws Exception { 746 Method method = DataConnection.class.getDeclaredMethod("getDisallowedApnTypes"); 747 method.setAccessible(true); 748 return (int) method.invoke(mDc); 749 } 750 751 @Test 752 @SmallTest testNetworkCapability()753 public void testNetworkCapability() throws Exception { 754 mContextFixture.getCarrierConfigBundle().putStringArray( 755 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 756 new String[] { "default" }); 757 doReturn(mApn2).when(mApnContext).getApnSetting(); 758 testConnectEvent(); 759 760 assertTrue("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 761 .hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)); 762 assertTrue("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 763 .hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 764 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 765 .hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)); 766 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 767 .hasCapability(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 768 769 mContextFixture.getCarrierConfigBundle().putStringArray( 770 CarrierConfigManager.KEY_CARRIER_WWAN_DISALLOWED_APN_TYPES_STRING_ARRAY, 771 new String[] {"supl"}); 772 773 disconnectEvent(); 774 doReturn(mApn1).when(mApnContext).getApnSetting(); 775 connectEvent(true); 776 777 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 778 .hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)); 779 assertTrue("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 780 .hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 781 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 782 .hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)); 783 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 784 .hasCapability(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 785 } 786 787 @Test 788 @SmallTest testVcnNetworkCapability()789 public void testVcnNetworkCapability() throws Exception { 790 mContextFixture.getCarrierConfigBundle().putStringArray( 791 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 792 new String[] { "default" }); 793 doReturn(mApn2).when(mApnContext).getApnSetting(); 794 795 doAnswer(invocation -> { 796 NetworkCapabilities nc = invocation.getArgument(0); 797 NetworkCapabilities policyNc = new NetworkCapabilities.Builder(nc) 798 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED) 799 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED) 800 .build(); 801 802 return new VcnNetworkPolicyResult( 803 false /* isTearDownRequested */, policyNc); 804 }).when(mVcnManager).applyVcnNetworkPolicy(any(), any()); 805 connectEvent(true); 806 807 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 808 .hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)); 809 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 810 .hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)); 811 812 disconnectEvent(); 813 814 doAnswer(invocation -> { 815 NetworkCapabilities nc = invocation.getArgument(0); 816 NetworkCapabilities policyNc = new NetworkCapabilities.Builder(nc) 817 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED) 818 .build(); 819 820 return new VcnNetworkPolicyResult( 821 false /* isTearDownRequested */, policyNc); 822 }).when(mVcnManager).applyVcnNetworkPolicy(any(), any()); 823 connectEvent(true); 824 825 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 826 .hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)); 827 assertTrue("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 828 .hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)); 829 } 830 831 @Test 832 @SmallTest testEnterpriseNetworkCapability()833 public void testEnterpriseNetworkCapability() throws Exception { 834 mContextFixture.getCarrierConfigBundle().putStringArray( 835 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 836 new String[] { "default" }); 837 doReturn(mApn2).when(mApnContext).getApnSetting(); 838 testConnectEvent(); 839 840 assertTrue("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 841 .hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)); 842 assertTrue("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 843 .hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 844 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 845 .hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)); 846 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 847 .hasCapability(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 848 849 disconnectEvent(); 850 setUpDefaultData(1); 851 replaceInstance(ConnectionParams.class, "mApnContext", mCp, mEnterpriseApnContext); 852 doReturn(mApn1).when(mEnterpriseApnContext).getApnSetting(); 853 doReturn(ApnSetting.TYPE_ENTERPRISE_STRING).when(mEnterpriseApnContext).getApnType(); 854 doReturn(ApnSetting.TYPE_ENTERPRISE).when(mEnterpriseApnContext).getApnTypeBitmask(); 855 connectEvent(true); 856 857 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 858 .hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)); 859 assertTrue("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 860 .hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)); 861 assertFalse("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 862 .hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)); 863 assertTrue("capabilities: " + getNetworkCapabilities(), getNetworkCapabilities() 864 .hasCapability(NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 865 } 866 867 @Test 868 @SmallTest testMeteredCapability()869 public void testMeteredCapability() throws Exception { 870 871 mContextFixture.getCarrierConfigBundle(). 872 putStringArray(CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 873 new String[] {"default"}); 874 875 testConnectEvent(); 876 877 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_METERED)); 878 } 879 880 @Test 881 @SmallTest testNonMeteredCapability()882 public void testNonMeteredCapability() throws Exception { 883 884 doReturn(2819).when(mPhone).getSubId(); 885 mContextFixture.getCarrierConfigBundle(). 886 putStringArray(CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 887 new String[] {"mms"}); 888 889 testConnectEvent(); 890 891 assertTrue(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_METERED)); 892 } 893 894 @Test testOverrideUnmetered()895 public void testOverrideUnmetered() throws Exception { 896 mContextFixture.getCarrierConfigBundle().putStringArray( 897 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 898 new String[] { "default" }); 899 testConnectEvent(); 900 901 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_METERED)); 902 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 903 assertTrue(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_CONGESTED)); 904 905 mDc.onMeterednessChanged(true); 906 waitForMs(100); 907 908 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_METERED)); 909 assertTrue(getNetworkCapabilities().hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 910 assertTrue(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_CONGESTED)); 911 912 mDc.onMeterednessChanged(false); 913 waitForMs(100); 914 915 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_METERED)); 916 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 917 assertTrue(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_CONGESTED)); 918 } 919 920 @Test testOverrideCongested()921 public void testOverrideCongested() throws Exception { 922 mContextFixture.getCarrierConfigBundle().putStringArray( 923 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 924 new String[] { "default" }); 925 testConnectEvent(); 926 927 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_METERED)); 928 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 929 assertTrue(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_CONGESTED)); 930 931 mDc.onCongestednessChanged(true); 932 waitForMs(100); 933 934 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_METERED)); 935 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 936 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_CONGESTED)); 937 938 mDc.onCongestednessChanged(false); 939 waitForMs(100); 940 941 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_METERED)); 942 assertFalse(getNetworkCapabilities().hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)); 943 assertTrue(getNetworkCapabilities().hasCapability(NET_CAPABILITY_NOT_CONGESTED)); 944 } 945 946 @Test testOwnerUid()947 public void testOwnerUid() throws Exception { 948 Context mockContext = mContextFixture.getTestDouble(); 949 doReturn(mockContext).when(mPhone).getContext(); 950 951 String testPkg = "com.android.telephony.test"; 952 TelephonyManager telMgr = mockContext.getSystemService(TelephonyManager.class); 953 doReturn(testPkg).when(telMgr).getCarrierServicePackageNameForLogicalSlot(anyInt()); 954 955 UserInfo info = new UserInfo(0 /* id */, "TEST_USER", 0 /* flags */); 956 UserManager userMgr = mockContext.getSystemService(UserManager.class); 957 doReturn(Collections.singletonList(info)).when(userMgr).getUsers(); 958 959 int carrierConfigPkgUid = 12345; 960 PackageManager pkgMgr = mockContext.getPackageManager(); 961 doReturn(carrierConfigPkgUid).when(pkgMgr).getPackageUidAsUser(eq(testPkg), anyInt()); 962 963 mContextFixture 964 .getCarrierConfigBundle() 965 .putStringArray( 966 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 967 new String[] {"default"}); 968 testConnectEvent(); 969 AsyncResult adminUidsResult = new AsyncResult(null, new int[] {carrierConfigPkgUid}, null); 970 mDc.sendMessage(DataConnection.EVENT_CARRIER_PRIVILEGED_UIDS_CHANGED, adminUidsResult); 971 // Wait for carirer privilege UIDs to be updated 972 waitForMs(100); 973 974 assertEquals(carrierConfigPkgUid, getNetworkCapabilities().getOwnerUid()); 975 assertEquals( 976 Collections.singleton(carrierConfigPkgUid), 977 getNetworkCapabilities().getAllowedUids()); 978 } 979 980 @Test testSubscriptionIds()981 public void testSubscriptionIds() throws Exception { 982 mContextFixture.getCarrierConfigBundle().putStringArray( 983 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 984 new String[] { "default" }); 985 testConnectEvent(); 986 987 assertEquals(Collections.singleton(0), getNetworkCapabilities().getSubscriptionIds()); 988 } 989 990 @Test testShouldSkip464Xlat()991 public void testShouldSkip464Xlat() throws Exception { 992 assertFalse(testShouldSkip464XlatEvent(mApn1)); 993 disconnectEvent(); 994 995 assertTrue(testShouldSkip464XlatEvent(mApn3)); 996 disconnectEvent(); 997 998 assertTrue(testShouldSkip464XlatEvent(mApn4)); 999 disconnectEvent(); 1000 1001 assertFalse(testShouldSkip464XlatEvent(mApn5)); 1002 disconnectEvent(); 1003 } 1004 testShouldSkip464XlatEvent(ApnSetting apn)1005 private boolean testShouldSkip464XlatEvent(ApnSetting apn) throws Exception { 1006 Method method = DataConnection.class.getDeclaredMethod("shouldSkip464Xlat"); 1007 method.setAccessible(true); 1008 1009 doReturn(apn).when(mApnContext).getApnSetting(); 1010 doReturn(apn.getApnTypeBitmask()).when(mApnContext).getApnTypeBitmask(); 1011 connectEvent(true); 1012 logd(getNetworkCapabilities().toString()); 1013 1014 return (Boolean) method.invoke(mDc); 1015 } 1016 connectEvent(boolean validate)1017 private void connectEvent(boolean validate) { 1018 mDc.sendMessage(DataConnection.EVENT_CONNECT, mCp); 1019 waitForMs(200); 1020 if (validate) { 1021 assertTrue(mDc.isActive()); 1022 } 1023 } 1024 disconnectEvent()1025 private void disconnectEvent() { 1026 mDc.sendMessage(DataConnection.EVENT_DISCONNECT, mDcp); 1027 waitForMs(100); 1028 assertTrue(mDc.isInactive()); 1029 } 1030 serviceStateChangedEvent(@egState int dataRegState, @RilRadioTechnology int rat)1031 private void serviceStateChangedEvent(@RegState int dataRegState, @RilRadioTechnology int rat) { 1032 mDc.obtainMessage(DataConnection.EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED, 1033 new AsyncResult(null, new Pair<>(dataRegState, rat), null)).sendToTarget(); 1034 waitForMs(100); 1035 } 1036 1037 @Test 1038 @SmallTest testIsIpAddress()1039 public void testIsIpAddress() { 1040 // IPv4 1041 assertTrue(DataConnection.isIpAddress("1.2.3.4")); 1042 assertTrue(DataConnection.isIpAddress("127.0.0.1")); 1043 1044 // IPv6 1045 assertTrue(DataConnection.isIpAddress("::1")); 1046 assertTrue(DataConnection.isIpAddress("2001:4860:800d::68")); 1047 } 1048 1049 @Test 1050 @SmallTest testSetLinkProperties()1051 public void testSetLinkProperties() throws Exception { 1052 DataCallResponse response = new DataCallResponse.Builder() 1053 .setCause(0) 1054 .setRetryDurationMillis(-1) 1055 .setId(1) 1056 .setLinkStatus(2) 1057 .setProtocolType(ApnSetting.PROTOCOL_IP) 1058 .setInterfaceName(FAKE_IFNAME) 1059 .setAddresses(Arrays.asList( 1060 new LinkAddress(InetAddresses.parseNumericAddress(FAKE_ADDRESS), 0))) 1061 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_DNS))) 1062 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 1063 .setPcscfAddresses( 1064 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 1065 .setMtuV4(1440) 1066 .setMtuV6(1440) 1067 .build(); 1068 1069 LinkProperties linkProperties = new LinkProperties(); 1070 assertEquals(SetupResult.SUCCESS, setLinkProperties(response, linkProperties)); 1071 logd(linkProperties.toString()); 1072 assertEquals(response.getInterfaceName(), linkProperties.getInterfaceName()); 1073 assertEquals(response.getAddresses().size(), linkProperties.getAddresses().size()); 1074 for (int i = 0; i < response.getAddresses().size(); ++i) { 1075 assertEquals(response.getAddresses().get(i).getAddress(), 1076 InetAddresses.parseNumericAddress(linkProperties.getLinkAddresses().get(i) 1077 .getAddress().getHostAddress())); 1078 } 1079 1080 assertEquals(response.getDnsAddresses().size(), linkProperties.getDnsServers().size()); 1081 for (int i = 0; i < response.getDnsAddresses().size(); ++i) { 1082 assertEquals("i = " + i, response.getDnsAddresses().get(i), 1083 InetAddresses.parseNumericAddress( 1084 linkProperties.getDnsServers().get(i).getHostAddress())); 1085 } 1086 1087 assertEquals(response.getGatewayAddresses().size(), linkProperties.getRoutes().size()); 1088 for (int i = 0; i < response.getGatewayAddresses().size(); ++i) { 1089 assertEquals("i = " + i, response.getGatewayAddresses().get(i), 1090 InetAddresses.parseNumericAddress(linkProperties.getRoutes().get(i) 1091 .getGateway().getHostAddress())); 1092 } 1093 1094 assertEquals(response.getPcscfAddresses().size(), linkProperties.getPcscfServers().size()); 1095 for (int i = 0; i < response.getPcscfAddresses().size(); ++i) { 1096 assertEquals("i = " + i, response.getPcscfAddresses().get(i), 1097 InetAddresses.parseNumericAddress(linkProperties.getPcscfServers().get(i) 1098 .getHostAddress())); 1099 } 1100 1101 assertEquals(response.getMtu(), linkProperties.getMtu()); 1102 } 1103 1104 @Test 1105 @SmallTest testSetLinkPropertiesEmptyAddress()1106 public void testSetLinkPropertiesEmptyAddress() throws Exception { 1107 // 224.224.224.224 is an invalid address. 1108 DataCallResponse response = new DataCallResponse.Builder() 1109 .setCause(0) 1110 .setRetryDurationMillis(-1) 1111 .setId(1) 1112 .setLinkStatus(2) 1113 .setProtocolType(ApnSetting.PROTOCOL_IP) 1114 .setInterfaceName(FAKE_IFNAME) 1115 .setDnsAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_DNS))) 1116 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 1117 .setPcscfAddresses( 1118 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 1119 .setMtuV4(1440) 1120 .setMtuV6(1440) 1121 .build(); 1122 1123 LinkProperties linkProperties = new LinkProperties(); 1124 assertEquals(SetupResult.ERROR_INVALID_ARG, setLinkProperties(response, linkProperties)); 1125 } 1126 1127 @Test 1128 @SmallTest testSetLinkPropertiesEmptyDns()1129 public void testSetLinkPropertiesEmptyDns() throws Exception { 1130 // Empty dns entry. 1131 DataCallResponse response = new DataCallResponse.Builder() 1132 .setCause(0) 1133 .setRetryDurationMillis(-1) 1134 .setId(1) 1135 .setLinkStatus(2) 1136 .setProtocolType(ApnSetting.PROTOCOL_IP) 1137 .setInterfaceName(FAKE_IFNAME) 1138 .setAddresses(Arrays.asList( 1139 new LinkAddress(InetAddresses.parseNumericAddress(FAKE_ADDRESS), 0))) 1140 .setGatewayAddresses(Arrays.asList(InetAddresses.parseNumericAddress(FAKE_GATEWAY))) 1141 .setPcscfAddresses( 1142 Arrays.asList(InetAddresses.parseNumericAddress(FAKE_PCSCF_ADDRESS))) 1143 .setMtuV4(1440) 1144 .setMtuV6(1440) 1145 .build(); 1146 1147 // Make sure no exception was thrown 1148 LinkProperties linkProperties = new LinkProperties(); 1149 assertEquals(SetupResult.SUCCESS, setLinkProperties(response, linkProperties)); 1150 } 1151 1152 @Test 1153 @SmallTest testStartKeepaliveWLAN()1154 public void testStartKeepaliveWLAN() throws Exception { 1155 testConnectEvent(); 1156 waitForMs(200); 1157 1158 Field field = DataConnection.class.getDeclaredField("mTransportType"); 1159 field.setAccessible(true); 1160 field.setInt(mDc, AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 1161 1162 final int sessionHandle = 0xF00; 1163 final int slotId = 3; 1164 final int interval = 10; // seconds 1165 // Construct a new KeepalivePacketData request as we would receive from a Network Agent, 1166 // and check that the packet is sent to the RIL. 1167 KeepalivePacketData kd = NattKeepalivePacketData.nattKeepalivePacket( 1168 InetAddresses.parseNumericAddress("1.2.3.4"), 1169 1234, 1170 InetAddresses.parseNumericAddress("8.8.8.8"), 1171 4500); 1172 mDc.obtainMessage( 1173 DataConnection.EVENT_KEEPALIVE_START_REQUEST, slotId, interval, kd).sendToTarget(); 1174 waitForMs(100); 1175 // testStartStopNattKeepalive() verifies that this request is passed with WWAN. 1176 // Thus, even though we can't see the response in NetworkAgent, we can verify that the 1177 // CommandsInterface never receives a request and infer that it was dropped due to WLAN. 1178 verify(mSimulatedCommandsVerifier, times(0)) 1179 .startNattKeepalive(anyInt(), eq(kd), eq(interval * 1000), any(Message.class)); 1180 } 1181 checkStartStopNattKeepalive(boolean useCondensedFlow)1182 public void checkStartStopNattKeepalive(boolean useCondensedFlow) throws Exception { 1183 testConnectEvent(); 1184 waitForMs(200); 1185 1186 final int sessionHandle = 0xF00; 1187 final int slotId = 3; 1188 final int interval = 10; // seconds 1189 // Construct a new KeepalivePacketData request as we would receive from a Network Agent, 1190 // and check that the packet is sent to the RIL. 1191 KeepalivePacketData kd = NattKeepalivePacketData.nattKeepalivePacket( 1192 InetAddresses.parseNumericAddress("1.2.3.4"), 1193 1234, 1194 InetAddresses.parseNumericAddress("8.8.8.8"), 1195 4500); 1196 mDc.obtainMessage( 1197 DataConnection.EVENT_KEEPALIVE_START_REQUEST, slotId, interval, kd).sendToTarget(); 1198 waitForMs(100); 1199 verify(mSimulatedCommandsVerifier, times(1)) 1200 .startNattKeepalive(anyInt(), eq(kd), eq(interval * 1000), any(Message.class)); 1201 1202 Message kaStarted = mDc.obtainMessage(DataConnection.EVENT_KEEPALIVE_STARTED, slotId, 0); 1203 if (useCondensedFlow) { 1204 // Send a singled condensed response that a keepalive have been requested and the 1205 // activation is completed. This flow should be used if the keepalive offload request 1206 // is handled by a high-priority signalling path. 1207 AsyncResult.forMessage( 1208 kaStarted, new KeepaliveStatus( 1209 sessionHandle, KeepaliveStatus.STATUS_ACTIVE), null); 1210 kaStarted.sendToTarget(); 1211 } else { 1212 // Send the sequential responses indicating first that the request was received and 1213 // then that the keepalive is running. This should create an active record of the 1214 // keepalive in DataConnection while permitting the status from a low priority or other 1215 // high-latency handler to activate the keepalive without blocking a request. 1216 AsyncResult.forMessage( 1217 kaStarted, new KeepaliveStatus( 1218 sessionHandle, KeepaliveStatus.STATUS_PENDING), null); 1219 kaStarted.sendToTarget(); 1220 Message kaRunning = mDc.obtainMessage(DataConnection.EVENT_KEEPALIVE_STATUS); 1221 AsyncResult.forMessage( 1222 kaRunning, new KeepaliveStatus( 1223 sessionHandle, KeepaliveStatus.STATUS_ACTIVE), null); 1224 kaRunning.sendToTarget(); 1225 } 1226 waitForMs(100); 1227 1228 // Verify that we can stop the connection, which checks that the record in DataConnection 1229 // has a valid mapping between slotId (from network agent) to sessionHandle (from Radio). 1230 mDc.obtainMessage(DataConnection.EVENT_KEEPALIVE_STOP_REQUEST, slotId).sendToTarget(); 1231 waitForMs(100); 1232 verify(mSimulatedCommandsVerifier, times(1)) 1233 .stopNattKeepalive(eq(sessionHandle), any(Message.class)); 1234 1235 Message kaStopped = mDc.obtainMessage( 1236 DataConnection.EVENT_KEEPALIVE_STOPPED, sessionHandle, slotId); 1237 AsyncResult.forMessage(kaStopped); 1238 kaStopped.sendToTarget(); 1239 // Verify that after the connection is stopped, the mapping for a Keepalive Session is 1240 // removed. Thus, subsequent calls to stop the same keepalive are ignored. 1241 mDc.obtainMessage(DataConnection.EVENT_KEEPALIVE_STOP_REQUEST, slotId).sendToTarget(); 1242 waitForMs(100); 1243 // Check that the mock has not been called subsequent to the previous invocation 1244 // while avoiding the use of reset() 1245 verify(mSimulatedCommandsVerifier, times(1)) 1246 .stopNattKeepalive(anyInt(), any(Message.class)); 1247 } 1248 1249 @Test 1250 @MediumTest testStartStopNattKeepalive()1251 public void testStartStopNattKeepalive() throws Exception { 1252 checkStartStopNattKeepalive(false); 1253 } 1254 1255 @Test 1256 @MediumTest testStartStopNattKeepaliveCondensed()1257 public void testStartStopNattKeepaliveCondensed() throws Exception { 1258 checkStartStopNattKeepalive(true); 1259 } 1260 checkStartNattKeepaliveFail(boolean useCondensedFlow)1261 public void checkStartNattKeepaliveFail(boolean useCondensedFlow) throws Exception { 1262 testConnectEvent(); 1263 waitForMs(200); 1264 1265 final int sessionHandle = 0xF00; 1266 final int slotId = 3; 1267 final int interval = 10; // seconds 1268 // Construct a new KeepalivePacketData request as we would receive from a Network Agent, 1269 // and check that the packet is sent to the RIL. 1270 KeepalivePacketData kd = NattKeepalivePacketData.nattKeepalivePacket( 1271 InetAddresses.parseNumericAddress("1.2.3.4"), 1272 1234, 1273 InetAddresses.parseNumericAddress("8.8.8.8"), 1274 4500); 1275 mDc.obtainMessage( 1276 DataConnection.EVENT_KEEPALIVE_START_REQUEST, slotId, interval, kd).sendToTarget(); 1277 waitForMs(100); 1278 verify(mSimulatedCommandsVerifier, times(1)) 1279 .startNattKeepalive(anyInt(), eq(kd), eq(interval * 1000), any(Message.class)); 1280 1281 Message kaStarted = mDc.obtainMessage(DataConnection.EVENT_KEEPALIVE_STARTED, slotId, 0); 1282 if (useCondensedFlow) { 1283 // Indicate in the response that the keepalive has failed. 1284 AsyncResult.forMessage( 1285 kaStarted, new KeepaliveStatus(KeepaliveStatus.ERROR_UNSUPPORTED), 1286 null); 1287 kaStarted.sendToTarget(); 1288 } else { 1289 // Indicate that the keepalive is queued, and then signal a failure from the modem 1290 // such that a pending keepalive fails to activate. 1291 AsyncResult.forMessage( 1292 kaStarted, new KeepaliveStatus( 1293 sessionHandle, KeepaliveStatus.STATUS_PENDING), null); 1294 kaStarted.sendToTarget(); 1295 Message kaRunning = mDc.obtainMessage(DataConnection.EVENT_KEEPALIVE_STATUS); 1296 AsyncResult.forMessage( 1297 kaRunning, new KeepaliveStatus( 1298 sessionHandle, KeepaliveStatus.STATUS_INACTIVE), null); 1299 kaRunning.sendToTarget(); 1300 } 1301 waitForMs(100); 1302 // Verify that a failed connection request cannot be stopped due to no record in 1303 // the DataConnection. 1304 mDc.obtainMessage(DataConnection.EVENT_KEEPALIVE_STOP_REQUEST, slotId).sendToTarget(); 1305 waitForMs(100); 1306 verify(mSimulatedCommandsVerifier, times(0)) 1307 .stopNattKeepalive(anyInt(), any(Message.class)); 1308 } 1309 1310 @Test 1311 @SmallTest testStartNattKeepaliveFail()1312 public void testStartNattKeepaliveFail() throws Exception { 1313 checkStartNattKeepaliveFail(false); 1314 } 1315 1316 @Test 1317 @SmallTest testStartNattKeepaliveFailCondensed()1318 public void testStartNattKeepaliveFailCondensed() throws Exception { 1319 checkStartNattKeepaliveFail(true); 1320 } 1321 1322 @Test 1323 @SmallTest testIsUnmeteredUseOnly()1324 public void testIsUnmeteredUseOnly() throws Exception { 1325 Field field = DataConnection.class.getDeclaredField("mTransportType"); 1326 field.setAccessible(true); 1327 field.setInt(mDc, AccessNetworkConstants.TRANSPORT_TYPE_WLAN); 1328 1329 assertFalse(isUnmeteredUseOnly()); 1330 1331 field = DataConnection.class.getDeclaredField("mTransportType"); 1332 field.setAccessible(true); 1333 field.setInt(mDc, AccessNetworkConstants.TRANSPORT_TYPE_WWAN); 1334 1335 doReturn(false).when(mDataEnabledSettings).isDataEnabled(); 1336 doReturn(false).when(mServiceState).getDataRoaming(); 1337 doReturn(ApnSetting.TYPE_MMS).when(mApnContext).getApnTypeBitmask(); 1338 1339 mContextFixture.getCarrierConfigBundle().putStringArray( 1340 CarrierConfigManager.KEY_CARRIER_METERED_APN_TYPES_STRINGS, 1341 new String[] { "default" }); 1342 1343 assertTrue(isUnmeteredUseOnly()); 1344 } 1345 1346 @Test testIsEnterpriseUse()1347 public void testIsEnterpriseUse() throws Exception { 1348 assertFalse(isEnterpriseUse()); 1349 assertFalse(mDc.getNetworkCapabilities().hasCapability( 1350 NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 1351 1352 setUpDefaultData(1); 1353 replaceInstance(ConnectionParams.class, "mApnContext", mCp, mEnterpriseApnContext); 1354 doReturn(mApn1).when(mEnterpriseApnContext).getApnSetting(); 1355 doReturn(ApnSetting.TYPE_ENTERPRISE_STRING).when(mEnterpriseApnContext).getApnType(); 1356 doReturn(ApnSetting.TYPE_ENTERPRISE).when(mEnterpriseApnContext).getApnTypeBitmask(); 1357 connectEvent(true); 1358 1359 assertTrue(isEnterpriseUse()); 1360 assertTrue(mDc.getNetworkCapabilities().hasCapability( 1361 NetworkCapabilities.NET_CAPABILITY_ENTERPRISE)); 1362 } 1363 1364 @Test 1365 @SmallTest testGetDisallowedApnTypes()1366 public void testGetDisallowedApnTypes() throws Exception { 1367 mContextFixture.getCarrierConfigBundle().putStringArray( 1368 CarrierConfigManager.KEY_CARRIER_WWAN_DISALLOWED_APN_TYPES_STRING_ARRAY, 1369 new String[] { "mms", "supl", "fota" }); 1370 testConnectEvent(); 1371 1372 assertEquals(ApnSetting.TYPE_MMS | ApnSetting.TYPE_SUPL | ApnSetting.TYPE_FOTA, 1373 getDisallowedApnTypes()); 1374 } 1375 1376 @Test testIsSuspended()1377 public void testIsSuspended() throws Exception { 1378 // Return false if not active state 1379 assertTrue(mDc.isInactive()); 1380 assertFalse(isSuspended()); 1381 1382 // Return false for emergency APN 1383 doReturn(mApn6).when(mApnContext).getApnSetting(); 1384 doReturn(ApnSetting.TYPE_EMERGENCY).when(mApnContext).getApnTypeBitmask(); 1385 connectEvent(true); 1386 assertFalse(isSuspended()); 1387 1388 // Back to DEFAULT APN 1389 disconnectEvent(); 1390 assertTrue(mDc.isInactive()); 1391 doReturn(mApn1).when(mApnContext).getApnSetting(); 1392 doReturn(ApnSetting.TYPE_DEFAULT).when(mApnContext).getApnTypeBitmask(); 1393 doReturn(true).when(mSST).isConcurrentVoiceAndDataAllowed(); 1394 connectEvent(true); 1395 1396 // Before getting any service state event, the connection should not be suspended. 1397 assertFalse(isSuspended()); 1398 1399 // Return true if combined reg state is not in service 1400 serviceStateChangedEvent(ServiceState.STATE_OUT_OF_SERVICE, 1401 ServiceState.RIL_RADIO_TECHNOLOGY_UNKNOWN); 1402 assertTrue(isSuspended()); 1403 1404 // Return false if in service and concurrent voice and data is allowed 1405 serviceStateChangedEvent(ServiceState.STATE_IN_SERVICE, 1406 ServiceState.RIL_RADIO_TECHNOLOGY_LTE); 1407 assertFalse(isSuspended()); 1408 1409 // Return false if in service and concurrent voice/data not allowed but call state is idle 1410 doReturn(false).when(mSST).isConcurrentVoiceAndDataAllowed(); 1411 doReturn(PhoneConstants.State.IDLE).when(mCT).getState(); 1412 mDc.sendMessage(DataConnection.EVENT_DATA_CONNECTION_VOICE_CALL_STARTED); 1413 waitForMs(100); 1414 assertFalse(isSuspended()); 1415 1416 // Return true if in service, concurrent voice/data not allowed, and call state not idle 1417 doReturn(PhoneConstants.State.RINGING).when(mCT).getState(); 1418 mDc.sendMessage(DataConnection.EVENT_DATA_CONNECTION_VOICE_CALL_STARTED); 1419 waitForMs(100); 1420 assertTrue(isSuspended()); 1421 } 1422 1423 @Test testDataCreatedWhenOutOfService()1424 public void testDataCreatedWhenOutOfService() throws Exception { 1425 serviceStateChangedEvent(ServiceState.STATE_OUT_OF_SERVICE, 1426 ServiceState.RIL_RADIO_TECHNOLOGY_UNKNOWN); 1427 ArgumentCaptor<NetworkCapabilities> ncCaptor = 1428 ArgumentCaptor.forClass(NetworkCapabilities.class); 1429 doReturn(mock(Network.class)).when(mConnectivityManager).registerNetworkAgent( 1430 any(), any(), any(), ncCaptor.capture(), any(), any(), anyInt()); 1431 1432 doReturn(mApn1).when(mApnContext).getApnSetting(); 1433 doReturn(ApnSetting.TYPE_DEFAULT).when(mApnContext).getApnTypeBitmask(); 1434 doReturn(true).when(mSST).isConcurrentVoiceAndDataAllowed(); 1435 connectEvent(true); 1436 waitForMs(100); 1437 1438 NetworkCapabilities nc = ncCaptor.getValue(); 1439 // The network must be created with NOT_SUSPENDED capability. 1440 assertTrue(nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED)); 1441 1442 // But it's final state must be suspended. 1443 assertTrue(isSuspended()); 1444 } 1445 1446 @Test testDataServiceTempUnavailable()1447 public void testDataServiceTempUnavailable() throws Exception { 1448 setFailedSetupDataResponse(DataServiceCallback.RESULT_ERROR_TEMPORARILY_UNAVAILABLE); 1449 replaceInstance(ConnectionParams.class, "mRequestType", mCp, 1450 DcTracker.REQUEST_TYPE_NORMAL); 1451 // Verify that no data was setup 1452 connectEvent(false); 1453 assertTrue(mDc.isInactive()); 1454 1455 // Verify that data service did not suggest any retry (i.e. Frameworks uses configured 1456 // retry timer). 1457 verify(mDataThrottler).setRetryTime(eq(ApnSetting.TYPE_DEFAULT | ApnSetting.TYPE_SUPL), 1458 eq(RetryManager.NO_SUGGESTED_RETRY_DELAY), eq(DcTracker.REQUEST_TYPE_NORMAL)); 1459 } 1460 1461 @Test testDataHandoverFailed()1462 public void testDataHandoverFailed() throws Exception { 1463 doReturn(mDefaultDc).when(mDcTracker).getDataConnectionByApnType(anyString()); 1464 1465 doAnswer(invocation -> { 1466 final Consumer<Integer> consumer = (Consumer<Integer>) invocation.getArguments()[0]; 1467 consumer.accept(DataServiceCallback.RESULT_SUCCESS); 1468 return null; 1469 }).when(mDefaultDc).startHandover(any(Consumer.class)); 1470 1471 replaceInstance(ConnectionParams.class, "mRequestType", mCp, 1472 DcTracker.REQUEST_TYPE_HANDOVER); 1473 assertTrue(mDc.isInactive()); 1474 connectEvent(false); 1475 1476 // Make sure the data connection is still in inactive state 1477 assertTrue(mDc.isInactive()); 1478 } 1479 } 1480