1 /* 2 * Copyright (C) 2021 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.ons; 18 19 import static org.mockito.Mockito.doNothing; 20 import static org.mockito.Mockito.doReturn; 21 import static org.mockito.Mockito.times; 22 import static org.mockito.Mockito.verify; 23 24 import android.content.Context; 25 import android.content.res.Resources; 26 import android.net.ConnectivityManager; 27 import android.net.NetworkCapabilities; 28 import android.net.NetworkRequest; 29 import android.os.Looper; 30 import android.os.ParcelUuid; 31 import android.os.PersistableBundle; 32 import android.telephony.CarrierConfigManager; 33 import android.telephony.SubscriptionInfo; 34 import android.telephony.SubscriptionManager; 35 import android.telephony.TelephonyManager; 36 import android.telephony.UiccCardInfo; 37 import android.telephony.UiccPortInfo; 38 import android.telephony.euicc.EuiccManager; 39 import android.util.Log; 40 41 import org.junit.After; 42 import org.junit.Before; 43 import org.junit.Test; 44 import org.mockito.Mock; 45 import org.mockito.MockitoAnnotations; 46 47 import java.util.ArrayList; 48 import java.util.List; 49 import java.util.UUID; 50 51 public class ONSProfileActivatorTest extends ONSBaseTest { 52 private static final String TAG = ONSProfileActivatorTest.class.getName(); 53 private static final int TEST_SUBID_0 = 0; 54 private static final int TEST_SUBID_1 = 1; 55 56 @Mock 57 Context mMockContext; 58 @Mock 59 SubscriptionManager mMockSubManager; 60 @Mock 61 EuiccManager mMockEuiccManager; 62 @Mock 63 TelephonyManager mMockTeleManager; 64 @Mock 65 ConnectivityManager mMockConnectivityManager; 66 @Mock 67 CarrierConfigManager mMockCarrierConfigManager; 68 @Mock 69 ONSProfileConfigurator mMockONSProfileConfigurator; 70 @Mock 71 ONSProfileDownloader mMockONSProfileDownloader; 72 @Mock 73 List<SubscriptionInfo> mMockactiveSubInfos; 74 @Mock 75 SubscriptionInfo mMockSubInfo; 76 @Mock 77 SubscriptionInfo mMockSubInfo1; 78 @Mock 79 List<SubscriptionInfo> mMocksubsInPSIMGroup; 80 @Mock 81 Resources mMockResources; 82 @Mock 83 ONSStats mMockONSStats; 84 @Mock 85 EuiccManager mMockEuiccManagerCard1; 86 87 @Before setUp()88 public void setUp() throws Exception { 89 super.setUp("ONSTest"); 90 MockitoAnnotations.initMocks(this); 91 Looper.prepare(); 92 93 doReturn(mMockResources).when(mMockContext).getResources(); 94 95 doReturn(mMockConnectivityManager).when(mMockContext).getSystemService( 96 Context.CONNECTIVITY_SERVICE); 97 NetworkRequest request = new NetworkRequest.Builder().addCapability( 98 NetworkCapabilities.NET_CAPABILITY_VALIDATED).build(); 99 doNothing().when(mMockConnectivityManager).registerNetworkCallback(request, 100 new ConnectivityManager.NetworkCallback()); 101 102 PersistableBundle persistableBundle = new PersistableBundle(); 103 persistableBundle.putBoolean(CarrierConfigManager 104 .KEY_CARRIER_SUPPORTS_OPP_DATA_AUTO_PROVISIONING_BOOL, true); 105 doReturn(persistableBundle).when(mMockCarrierConfigManager).getConfigForSubId(TEST_SUBID_1); 106 107 List<UiccCardInfo> uiccCardInfoList = new ArrayList<>(); 108 List<UiccPortInfo> uiccPortInfoList = new ArrayList<>(); 109 uiccPortInfoList.add( 110 new UiccPortInfo("123451234567890" /* iccId */, 111 0 /* portIdx */, 112 0 /* logicalSlotIdx */, 113 true /* isActive */)); 114 UiccCardInfo uiccCardInfo = new UiccCardInfo(true, /* isEuicc */ 115 1 /* cardId */, 116 "123451234567890" /* eid */, 117 0 /* physicalSlotIndex */, 118 true /* isRemovable */, 119 true /* isMultipleEnabledProfilesSupported */, 120 uiccPortInfoList /* portList */); 121 uiccCardInfoList.add(uiccCardInfo); 122 doReturn(mMockEuiccManagerCard1).when(mMockEuiccManager).createForCardId(1); 123 doReturn(true).when(mMockEuiccManagerCard1).isEnabled(); 124 doReturn(uiccCardInfoList).when(mMockTeleManager).getUiccCardsInfo(); 125 } 126 127 // Worker thread is used for testing asynchronous APIs and Message Handlers. 128 // ASync APIs are called and Handler messages are processed by Worker thread. Test results are 129 // verified by Main Thread. 130 static class WorkerThread extends Thread { 131 Looper mWorkerLooper; 132 private final Runnable mRunnable; 133 WorkerThread(Runnable runnable)134 WorkerThread(Runnable runnable) { 135 mRunnable = runnable; 136 } 137 138 @Override run()139 public void run() { 140 super.run(); 141 Looper.prepare(); 142 mWorkerLooper = Looper.myLooper(); 143 mRunnable.run(); 144 mWorkerLooper.loop(); 145 } 146 exit()147 public void exit() { 148 mWorkerLooper.quitSafely(); 149 } 150 } 151 152 /*@Test 153 public void testSIMNotReady() { 154 doReturn(TelephonyManager.SIM_STATE_NOT_READY).when(mMockTeleManager).getSimState(); 155 156 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 157 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 158 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader); 159 160 assertEquals(ONSProfileActivator.Result.ERR_SIM_NOT_READY, 161 onsProfileActivator.handleSimStateChange()); 162 }*/ 163 164 @Test testONSAutoProvisioningDisabled()165 public void testONSAutoProvisioningDisabled() { 166 167 doReturn(false).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 168 169 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 170 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 171 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 172 mMockONSStats); 173 174 assertEquals(ONSProfileActivator.Result.ERR_AUTO_PROVISIONING_DISABLED, 175 onsProfileActivator.handleCarrierConfigChange()); 176 } 177 178 @Test testESIMNotSupported()179 public void testESIMNotSupported() { 180 181 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 182 doReturn(false).when(mMockEuiccManager).isEnabled(); 183 doReturn(false).when(mMockEuiccManagerCard1).isEnabled(); 184 185 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 186 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 187 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 188 mMockONSStats); 189 190 assertEquals(ONSProfileActivator.Result.ERR_ESIM_NOT_SUPPORTED, 191 onsProfileActivator.handleCarrierConfigChange()); 192 } 193 194 @Test 195 //@DisplayName("Single SIM Device with eSIM support") testMultiSIMNotSupported()196 public void testMultiSIMNotSupported() { 197 198 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 199 doReturn(true).when(mMockEuiccManager).isEnabled(); 200 doReturn(1).when(mMockTeleManager).getSupportedModemCount(); 201 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 202 203 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 204 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 205 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 206 mMockONSStats); 207 208 assertEquals(ONSProfileActivator.Result.ERR_MULTISIM_NOT_SUPPORTED, 209 onsProfileActivator.handleCarrierConfigChange()); 210 } 211 212 @Test testDeviceSwitchToDualSIMModeFailed()213 public void testDeviceSwitchToDualSIMModeFailed() { 214 215 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 216 doReturn(true).when(mMockEuiccManager).isEnabled(); 217 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 218 doReturn(1).when(mMockTeleManager).getActiveModemCount(); 219 doReturn(true).when(mMockTeleManager).doesSwitchMultiSimConfigTriggerReboot(); 220 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 221 doReturn(1).when(mMockactiveSubInfos).size(); 222 doReturn(mMockSubInfo).when(mMockactiveSubInfos).getFirst(); 223 doReturn(1).when(mMockSubInfo).getSubscriptionId(); 224 doReturn(false).when(mMockSubInfo).isOpportunistic(); 225 226 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 227 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 228 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 229 mMockONSStats); 230 231 assertEquals(ONSProfileActivator.Result.ERR_CANNOT_SWITCH_TO_DUAL_SIM_MODE, 232 onsProfileActivator.handleCarrierConfigChange()); 233 } 234 235 @Test testDeviceSwitchToDualSIMModeSuccess()236 public void testDeviceSwitchToDualSIMModeSuccess() { 237 238 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 239 doReturn(true).when(mMockEuiccManager).isEnabled(); 240 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 241 doReturn(1).when(mMockTeleManager).getActiveModemCount(); 242 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 243 doReturn(1).when(mMockactiveSubInfos).size(); 244 doReturn(mMockSubInfo).when(mMockactiveSubInfos).getFirst(); 245 doReturn(1).when(mMockSubInfo).getSubscriptionId(); 246 doReturn(false).when(mMockSubInfo).isOpportunistic(); 247 248 doReturn(false).when(mMockTeleManager).doesSwitchMultiSimConfigTriggerReboot(); 249 250 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 251 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 252 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 253 mMockONSStats); 254 255 assertEquals(ONSProfileActivator.Result.ERR_SWITCHING_TO_DUAL_SIM_MODE, 256 onsProfileActivator.handleCarrierConfigChange()); 257 } 258 259 //@DisplayName("Dual SIM device with no SIM inserted") testNoActiveSubscriptions()260 public void testNoActiveSubscriptions() { 261 262 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 263 doReturn(true).when(mMockEuiccManager).isEnabled(); 264 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 265 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 266 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 267 doReturn(0).when(mMockactiveSubInfos).size(); 268 doReturn(true).when(mMockactiveSubInfos).isEmpty(); 269 270 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 271 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 272 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 273 mMockONSStats); 274 275 assertEquals(ONSProfileActivator.Result.ERR_NO_SIM_INSERTED, 276 onsProfileActivator.handleCarrierConfigChange()); 277 } 278 testNullActiveSubscriptionList()279 public void testNullActiveSubscriptionList() { 280 281 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 282 doReturn(true).when(mMockEuiccManager).isEnabled(); 283 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 284 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 285 doReturn(null).when(mMockSubManager).getActiveSubscriptionInfoList(); 286 287 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 288 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 289 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 290 mMockONSStats); 291 292 assertEquals(ONSProfileActivator.Result.ERR_NO_SIM_INSERTED, 293 onsProfileActivator.handleCarrierConfigChange()); 294 } 295 296 @Test 297 //@DisplayName("Dual SIM device and non CBRS carrier pSIM inserted") testNonCBRSCarrierPSIMInserted()298 public void testNonCBRSCarrierPSIMInserted() { 299 300 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 301 doReturn(true).when(mMockEuiccManager).isEnabled(); 302 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 303 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 304 305 PersistableBundle persistableBundle = new PersistableBundle(); 306 persistableBundle.putBoolean(CarrierConfigManager 307 .KEY_CARRIER_SUPPORTS_OPP_DATA_AUTO_PROVISIONING_BOOL, false); 308 doReturn(persistableBundle).when(mMockCarrierConfigManager).getConfigForSubId(TEST_SUBID_0); 309 310 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 311 doReturn(1).when(mMockactiveSubInfos).size(); 312 doReturn(mMockSubInfo).when(mMockactiveSubInfos).getFirst(); 313 doReturn(TEST_SUBID_0).when(mMockSubInfo).getSubscriptionId(); 314 doReturn(false).when(mMockSubInfo).isOpportunistic(); 315 316 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 317 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 318 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 319 mMockONSStats); 320 321 assertEquals(ONSProfileActivator.Result.ERR_CARRIER_DOESNT_SUPPORT_CBRS, 322 onsProfileActivator.handleCarrierConfigChange()); 323 } 324 325 @Test 326 //@DisplayName("Dual SIM device with Two PSIM active subscriptions") testTwoActivePSIMSubscriptions()327 public void testTwoActivePSIMSubscriptions() { 328 329 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 330 doReturn(true).when(mMockEuiccManager).isEnabled(); 331 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 332 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 333 334 List<SubscriptionInfo> mActiveSubInfos = new ArrayList<>(); 335 mActiveSubInfos.add(mMockSubInfo); 336 mActiveSubInfos.add(mMockSubInfo1); 337 doReturn(mActiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 338 doReturn(false).when(mMockSubInfo).isEmbedded(); 339 doReturn(false).when(mMockSubInfo1).isEmbedded(); 340 341 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 342 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 343 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 344 mMockONSStats); 345 346 assertEquals(ONSProfileActivator.Result.ERR_DUAL_ACTIVE_SUBSCRIPTIONS, 347 onsProfileActivator.handleCarrierConfigChange()); 348 } 349 350 @Test testOneCBRSPSIMAndOneNonCBRSESIM()351 public void testOneCBRSPSIMAndOneNonCBRSESIM() { 352 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 353 doReturn(true).when(mMockEuiccManager).isEnabled(); 354 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 355 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 356 357 List<SubscriptionInfo> mActiveSubInfos = new ArrayList<>(); 358 mActiveSubInfos.add(mMockSubInfo); 359 mActiveSubInfos.add(mMockSubInfo1); 360 doReturn(mActiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 361 doReturn(false).when(mMockSubInfo).isEmbedded(); 362 doReturn(true).when(mMockSubInfo1).isEmbedded(); 363 doReturn(TEST_SUBID_0).when(mMockSubInfo).getSubscriptionId(); 364 doReturn(TEST_SUBID_1).when(mMockSubInfo1).getSubscriptionId(); 365 366 PersistableBundle persistableBundle = new PersistableBundle(); 367 persistableBundle.putBoolean(CarrierConfigManager 368 .KEY_CARRIER_SUPPORTS_OPP_DATA_AUTO_PROVISIONING_BOOL, false); 369 doReturn(persistableBundle).when(mMockCarrierConfigManager).getConfigForSubId(TEST_SUBID_0); 370 371 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 372 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 373 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 374 mMockONSStats); 375 376 assertEquals(ONSProfileActivator.Result.ERR_DUAL_ACTIVE_SUBSCRIPTIONS, 377 onsProfileActivator.handleCarrierConfigChange()); 378 } 379 380 @Test testOneCBRSPSIMAndOneOpportunisticESIM()381 public void testOneCBRSPSIMAndOneOpportunisticESIM() { 382 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 383 doReturn(true).when(mMockEuiccManager).isEnabled(); 384 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 385 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 386 387 List<SubscriptionInfo> mActiveSubInfos = new ArrayList<>(); 388 mActiveSubInfos.add(mMockSubInfo); //Primary CBRS SIM 389 mActiveSubInfos.add(mMockSubInfo1); //Opportunistic eSIM 390 doReturn(mActiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 391 doReturn(mActiveSubInfos).when(mMockSubManager).getAvailableSubscriptionInfoList(); 392 393 doReturn(mMockSubInfo).when(mMockSubManager).getActiveSubscriptionInfo(TEST_SUBID_0); 394 doReturn(TEST_SUBID_0).when(mMockSubInfo).getSubscriptionId(); 395 doReturn(true).when(mMockSubManager).isActiveSubscriptionId(TEST_SUBID_0); 396 doReturn(false).when(mMockSubInfo).isOpportunistic(); 397 doReturn(false).when(mMockSubInfo).isEmbedded(); 398 ParcelUuid pSIMSubGroupId = new ParcelUuid(new UUID(0, 1)); 399 doReturn(pSIMSubGroupId).when(mMockSubInfo).getGroupUuid(); 400 PersistableBundle persistableBundle = new PersistableBundle(); 401 persistableBundle.putBoolean(CarrierConfigManager 402 .KEY_CARRIER_SUPPORTS_OPP_DATA_AUTO_PROVISIONING_BOOL, true); 403 persistableBundle.putIntArray(CarrierConfigManager 404 .KEY_OPPORTUNISTIC_CARRIER_IDS_INT_ARRAY, new int[]{1, 2}); 405 doReturn(persistableBundle).when(mMockCarrierConfigManager).getConfigForSubId(TEST_SUBID_0); 406 407 doReturn(mMockSubInfo1).when(mMockSubManager).getActiveSubscriptionInfo(TEST_SUBID_1); 408 doReturn(TEST_SUBID_1).when(mMockSubInfo1).getSubscriptionId(); 409 doReturn(true).when(mMockSubManager).isActiveSubscriptionId(TEST_SUBID_1); 410 doReturn(true).when(mMockSubInfo1).isOpportunistic(); 411 doReturn(true).when(mMockSubInfo1).isEmbedded(); 412 doReturn(pSIMSubGroupId).when(mMockSubInfo1).getGroupUuid(); 413 doReturn(1).when(mMockSubInfo1).getCarrierId(); 414 415 doReturn(mMockSubInfo1).when(mMockONSProfileConfigurator) 416 .findOpportunisticSubscription(TEST_SUBID_0); 417 418 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 419 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 420 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 421 mMockONSStats); 422 423 assertEquals(ONSProfileActivator.Result.SUCCESS, 424 onsProfileActivator.handleCarrierConfigChange()); 425 } 426 427 @Test 428 //@DisplayName("Dual SIM device with only opportunistic eSIM active") testOnlyOpportunisticESIMActive()429 public void testOnlyOpportunisticESIMActive() { 430 431 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 432 doReturn(true).when(mMockEuiccManager).isEnabled(); 433 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 434 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 435 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 436 doReturn(1).when(mMockactiveSubInfos).size(); 437 doReturn(mMockSubInfo).when(mMockactiveSubInfos).getFirst(); 438 doReturn(true).when(mMockSubInfo).isOpportunistic(); 439 440 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 441 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 442 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 443 mMockONSStats); 444 445 assertEquals(ONSProfileActivator.Result.ERR_SINGLE_ACTIVE_OPPORTUNISTIC_SIM, 446 onsProfileActivator.handleCarrierConfigChange()); 447 } 448 449 @Test 450 //@DisplayName("Dual SIM device, only CBRS carrier pSIM inserted and pSIM not Grouped") testCBRSpSIMAndNotGrouped()451 public void testCBRSpSIMAndNotGrouped() { 452 453 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 454 doReturn(true).when(mMockEuiccManager).isEnabled(); 455 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 456 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 457 458 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 459 doReturn(1).when(mMockactiveSubInfos).size(); 460 doReturn(mMockSubInfo).when(mMockactiveSubInfos).getFirst(); 461 doReturn(false).when(mMockSubInfo).isOpportunistic(); 462 doReturn(TEST_SUBID_1).when(mMockSubInfo).getSubscriptionId(); 463 doReturn(null).when(mMockSubInfo).getGroupUuid(); 464 doReturn(ONSProfileDownloader.DownloadProfileResult.SUCCESS).when(mMockONSProfileDownloader) 465 .downloadProfile(TEST_SUBID_1); 466 467 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 468 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 469 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 470 mMockONSStats); 471 472 onsProfileActivator.mIsInternetConnAvailable = true; 473 assertEquals(ONSProfileActivator.Result.DOWNLOAD_REQUESTED, 474 onsProfileActivator.handleCarrierConfigChange()); 475 } 476 477 @Test testCalculateBackoffDelay()478 public void testCalculateBackoffDelay() { 479 final Object lock = new Object(); 480 481 Runnable runnable = new Runnable() { 482 @Override 483 public void run() { 484 int delay = ONSProfileActivator.calculateBackoffDelay(1, 1) / 1000; 485 assertEquals(true, (delay >= 1 && delay <= 2)); 486 487 Log.i(TAG, "calculateBackoffDelay(2, 1)"); 488 delay = ONSProfileActivator.calculateBackoffDelay(2, 1) / 1000; 489 assertEquals(true, (delay >= 1 && delay < 4)); 490 491 delay = ONSProfileActivator.calculateBackoffDelay(3, 1) / 1000; 492 assertEquals(true, (delay >= 1 && delay < 8)); 493 494 delay = ONSProfileActivator.calculateBackoffDelay(4, 1) / 1000; 495 assertEquals(true, (delay >= 1 && delay < 16)); 496 497 delay = ONSProfileActivator.calculateBackoffDelay(1, 2) / 1000; 498 assertEquals(true, (delay >= 1 && delay <= 4)); 499 500 delay = ONSProfileActivator.calculateBackoffDelay(1, 3) / 1000; 501 assertEquals(true, (delay >= 1 && delay <= 6)); 502 503 delay = ONSProfileActivator.calculateBackoffDelay(2, 2) / 1000; 504 assertEquals(true, (delay >= 2 && delay < 8)); 505 506 synchronized (lock) { 507 lock.notifyAll(); 508 } 509 } 510 }; 511 512 WorkerThread workerThread = new WorkerThread(runnable); 513 workerThread.start(); 514 515 synchronized (lock) { 516 try { 517 lock.wait(); 518 } catch (Exception e) { 519 Log.e(TAG, e.getLocalizedMessage()); 520 } 521 } 522 523 workerThread.exit(); 524 } 525 526 /* Unable to mock final class ParcelUuid. These testcases should be enabled once the solution 527 is found */ 528 /*@Test 529 //@DisplayName("Dual SIM device, only CBRS carrier pSIM inserted and pSIM Grouped") 530 public void testOneSubscriptionInCBRSpSIMGroup() { 531 ParcelUuid mMockParcelUuid = crateMock(ParcelUuid.class); 532 533 doReturn(true).when(mMockONSProfileConfigurator) 534 .isESIMSupported(); 535 doReturn(true).when(mMockONSUtil).isMultiSIMPhone(); 536 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 537 mMockPrimaryCBRSSubInfo); 538 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 539 doReturn(1).when(mMockactiveSubInfos).size(); 540 doReturn(mMockPrimaryCBRSSubInfo).when(mMockactiveSubInfos).get(0); 541 doReturn(false).when(mMockPrimaryCBRSSubInfo).isOpportunistic(); 542 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 543 mMockPrimaryCBRSSubInfo); 544 doReturn(mMockParcelUuid).when(mMockPrimaryCBRSSubInfo).getGroupUuid(); 545 doReturn(mMocksubsInPSIMGroup).when(mMockSubManager).getSubscriptionsInGroup( 546 mMockParcelUuid); 547 doReturn(1).when(mMocksubsInPSIMGroup).size(); 548 549 ONSProfileActivator onsProfileActivator = 550 new ONSProfileActivator(mMockContext, mMockSubManager, mMockEuiCCManager, 551 mMockTeleManager, 552 mMockONSProfileConfigurator, mMockONSProfileDownloader, mMockONSStats); 553 554 assertEquals(ONSProfileActivator.Result.SUCCESS, 555 onsProfileActivator.handleSimStateChange()); 556 } 557 558 @Test 559 //@DisplayName("Dual SIM device, only CBRS carrier pSIM inserted and pSIM Group has two 560 subscription info.") 561 public void testTwoSubscriptionsInCBRSpSIMGroup() { 562 ParcelUuid mMockParcelUuid = crateMock(ParcelUuid.class); 563 564 doReturn(true).when(mMockONSProfileConfigurator) 565 .isESIMSupported(); 566 doReturn(true).when(mMockONSUtil).isMultiSIMPhone(); 567 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 568 mMockPrimaryCBRSSubInfo); 569 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 570 doReturn(1).when(mMockactiveSubInfos).size(); 571 doReturn(mMockPrimaryCBRSSubInfo).when(mMockactiveSubInfos).get(0); 572 doReturn(false).when(mMockPrimaryCBRSSubInfo).isOpportunistic(); 573 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 574 mMockPrimaryCBRSSubInfo); 575 doReturn(mMockParcelUuid).when(mMockPrimaryCBRSSubInfo).getGroupUuid(); 576 doReturn(mMocksubsInPSIMGroup).when(mMockSubManager).getSubscriptionsInGroup( 577 mMockParcelUuid); 578 doReturn(2).when(mMocksubsInPSIMGroup).size(); 579 580 ONSProfileActivator onsProfileActivator = 581 new ONSProfileActivator(mMockContext, mMockSubManager, mMockEuiCCManager, 582 mMockTeleManager, mMockONSProfileConfigurator, mMockONSProfileDownloader); 583 584 assertEquals(ONSProfileActivator.Result.SUCCESS, 585 onsProfileActivator.handleSimStateChange()); 586 } 587 588 @Test 589 //@DisplayName("Dual SIM device, only CBRS carrier pSIM inserted and pSIM Group has more than 590 two subscription info.") 591 public void testMoreThanTwoSubscriptionsInCBRSpSIMGroup() { 592 ParcelUuid mMockParcelUuid = crateMock(ParcelUuid.class); 593 594 doReturn(true).when(mMockONSProfileConfigurator) 595 .isESIMSupported(); 596 doReturn(true).when(mMockONSUtil).isMultiSIMPhone(); 597 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 598 mMockPrimaryCBRSSubInfo); 599 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 600 doReturn(1).when(mMockactiveSubInfos).size(); 601 doReturn(mMockPrimaryCBRSSubInfo).when(mMockactiveSubInfos).get(0); 602 doReturn(false).when(mMockPrimaryCBRSSubInfo).isOpportunistic(); 603 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 604 mMockPrimaryCBRSSubInfo); 605 doReturn(mMockParcelUuid).when(mMockPrimaryCBRSSubInfo).getGroupUuid(); 606 doReturn(mMocksubsInPSIMGroup).when(mMockSubManager).getSubscriptionsInGroup( 607 mMockParcelUuid); 608 doReturn(3).when(mMocksubsInPSIMGroup).size(); 609 610 ONSProfileActivator onsProfileActivator = 611 new ONSProfileActivator(mMockContext, mMockSubManager, mMockEuiCCManager, 612 mMockTeleManager, mMockONSProfileConfigurator, mMockONSProfileDownloader); 613 614 assertEquals(ONSProfileActivator.Result.SUCCESS, 615 onsProfileActivator.handleSimStateChange()); 616 } 617 618 @Test 619 public void testRetryDownloadAfterRebootWithOppESIMAlreadyDownloaded() { 620 doReturn(true).when(mMockONSProfileConfigurator).getRetryDownloadAfterReboot(); 621 doReturn(1).when(mMockONSProfileConfigurator).getRetryDownloadPSIMSubId(); 622 doReturn(mMockSubManager).when(mMockONSUtil).getSubscriptionManager(); 623 doReturn(mMocksubsInPSIMGroup).when(mMockSubManager).getActiveSubscriptionInfo(); 624 //TODO: mock ParcelUuid - pSIM group 625 626 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 627 mMockONSProfileConfigurator, mMockONSProfileDownloader, mMockONSStats); 628 629 assertEquals(ONSProfileActivator.Result.ERR_INVALID_PSIM_SUBID, 630 onsProfileActivator.retryDownloadAfterReboot()); 631 } 632 */ 633 634 /*@Test 635 public void testNoInternetDownloadRequest() { 636 doReturn(TEST_SUB_ID).when(mMockSubInfo).getSubscriptionId(); 637 638 ONSProfileDownloader onsProfileDownloader = new ONSProfileDownloader(mMockContext, 639 mMockCarrierConfigManager, mMockEUICCManager, mMockONSProfileConfig, null); 640 641 onsProfileDownloader.mIsInternetConnAvailable = false; 642 onsProfileDownloader.downloadOpportunisticESIM(mMockSubInfo); 643 644 assertEquals(onsProfileDownloader.mRetryDownloadWhenNWConnected, true); 645 verify(mMockEUICCManager, never()).downloadSubscription(null, true, null); 646 }*/ 647 648 @Test testESIMDownloadFailureAndRetry()649 public void testESIMDownloadFailureAndRetry() { 650 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 651 doReturn(true).when(mMockEuiccManager).isEnabled(); 652 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 653 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 654 doReturn(ONSProfileDownloader.DownloadProfileResult.SUCCESS).when(mMockONSProfileDownloader) 655 .downloadProfile(TEST_SUBID_0); 656 657 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 658 doReturn(1).when(mMockactiveSubInfos).size(); 659 doReturn(mMockSubInfo).when(mMockactiveSubInfos).getFirst(); 660 doReturn(false).when(mMockSubInfo).isOpportunistic(); 661 doReturn(TEST_SUBID_0).when(mMockSubInfo).getSubscriptionId(); 662 doReturn(null).when(mMockSubInfo).getGroupUuid(); 663 664 final int maxRetryCount = 5; 665 666 // Retry immediately without wait. To reduce UT execution time. 667 final int retryBackoffTime = 0; 668 669 PersistableBundle persistableBundle = new PersistableBundle(); 670 persistableBundle.putBoolean(CarrierConfigManager 671 .KEY_CARRIER_SUPPORTS_OPP_DATA_AUTO_PROVISIONING_BOOL, true); 672 persistableBundle.putInt(CarrierConfigManager 673 .KEY_ESIM_MAX_DOWNLOAD_RETRY_ATTEMPTS_INT, maxRetryCount); 674 persistableBundle.putInt(CarrierConfigManager 675 .KEY_ESIM_DOWNLOAD_RETRY_BACKOFF_TIMER_SEC_INT, retryBackoffTime); 676 doReturn(persistableBundle).when(mMockCarrierConfigManager).getConfigForSubId(TEST_SUBID_0); 677 678 final Object lock = new Object(); 679 class TestRunnable implements Runnable { 680 public ONSProfileActivator mOnsProfileActivator; 681 682 @Override 683 public void run() { 684 mOnsProfileActivator = new ONSProfileActivator(mMockContext, 685 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, 686 mMockEuiccManager, mMockConnectivityManager, mMockONSProfileConfigurator, 687 mMockONSProfileDownloader, mMockONSStats); 688 689 synchronized (lock) { 690 lock.notify(); 691 } 692 } 693 } 694 695 TestRunnable runnable = new TestRunnable(); 696 WorkerThread workerThread = new WorkerThread(runnable); 697 workerThread.start(); 698 699 synchronized (lock) { 700 try { 701 lock.wait(); 702 } catch (InterruptedException e) { 703 e.printStackTrace(); 704 } 705 } 706 707 ONSProfileActivator onsProfileActivator = runnable.mOnsProfileActivator; 708 onsProfileActivator.mIsInternetConnAvailable = true; 709 710 for (int idx = 0; idx <= maxRetryCount; idx++) { 711 onsProfileActivator.onDownloadError( 712 TEST_SUBID_0, 713 ONSProfileDownloader.DownloadRetryResultCode.ERR_RETRY_DOWNLOAD, 0); 714 715 //Wait for Handler to process download message. Backoff delay + 500 milli secs. 716 try { 717 Thread.sleep(onsProfileActivator.calculateBackoffDelay( 718 onsProfileActivator.mDownloadRetryCount, retryBackoffTime) + 1000); 719 } catch (Exception e) { 720 e.printStackTrace(); 721 } 722 } 723 724 workerThread.exit(); 725 726 verify(mMockONSProfileDownloader, times(maxRetryCount)).downloadProfile(TEST_SUBID_0); 727 } 728 729 @After tearDown()730 public void tearDown() throws Exception { 731 super.tearDown(); 732 } 733 } 734 735