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 ArrayList<UiccCardInfo> uiccCardInfoList = new ArrayList<>(); 108 ArrayList<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).get(TEST_SUBID_0); 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).get(TEST_SUBID_0); 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 269 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 270 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 271 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 272 mMockONSStats); 273 274 assertEquals(ONSProfileActivator.Result.ERR_NO_SIM_INSERTED, 275 onsProfileActivator.handleCarrierConfigChange()); 276 } 277 testNullActiveSubscriptionList()278 public void testNullActiveSubscriptionList() { 279 280 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 281 doReturn(true).when(mMockEuiccManager).isEnabled(); 282 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 283 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 284 doReturn(null).when(mMockSubManager).getActiveSubscriptionInfoList(); 285 286 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 287 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 288 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 289 mMockONSStats); 290 291 assertEquals(ONSProfileActivator.Result.ERR_NO_SIM_INSERTED, 292 onsProfileActivator.handleCarrierConfigChange()); 293 } 294 295 @Test 296 //@DisplayName("Dual SIM device and non CBRS carrier pSIM inserted") testNonCBRSCarrierPSIMInserted()297 public void testNonCBRSCarrierPSIMInserted() { 298 299 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 300 doReturn(true).when(mMockEuiccManager).isEnabled(); 301 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 302 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 303 304 PersistableBundle persistableBundle = new PersistableBundle(); 305 persistableBundle.putBoolean(CarrierConfigManager 306 .KEY_CARRIER_SUPPORTS_OPP_DATA_AUTO_PROVISIONING_BOOL, false); 307 doReturn(persistableBundle).when(mMockCarrierConfigManager).getConfigForSubId(TEST_SUBID_0); 308 309 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 310 doReturn(1).when(mMockactiveSubInfos).size(); 311 doReturn(mMockSubInfo).when(mMockactiveSubInfos).get(TEST_SUBID_0); 312 doReturn(TEST_SUBID_0).when(mMockSubInfo).getSubscriptionId(); 313 doReturn(false).when(mMockSubInfo).isOpportunistic(); 314 315 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 316 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 317 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 318 mMockONSStats); 319 320 assertEquals(ONSProfileActivator.Result.ERR_CARRIER_DOESNT_SUPPORT_CBRS, 321 onsProfileActivator.handleCarrierConfigChange()); 322 } 323 324 @Test 325 //@DisplayName("Dual SIM device with Two PSIM active subscriptions") testTwoActivePSIMSubscriptions()326 public void testTwoActivePSIMSubscriptions() { 327 328 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 329 doReturn(true).when(mMockEuiccManager).isEnabled(); 330 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 331 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 332 333 ArrayList<SubscriptionInfo> mActiveSubInfos = new ArrayList<>(); 334 mActiveSubInfos.add(mMockSubInfo); 335 mActiveSubInfos.add(mMockSubInfo1); 336 doReturn(mActiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 337 doReturn(false).when(mMockSubInfo).isEmbedded(); 338 doReturn(false).when(mMockSubInfo1).isEmbedded(); 339 340 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 341 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 342 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 343 mMockONSStats); 344 345 assertEquals(ONSProfileActivator.Result.ERR_DUAL_ACTIVE_SUBSCRIPTIONS, 346 onsProfileActivator.handleCarrierConfigChange()); 347 } 348 349 @Test testOneCBRSPSIMAndOneNonCBRSESIM()350 public void testOneCBRSPSIMAndOneNonCBRSESIM() { 351 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 352 doReturn(true).when(mMockEuiccManager).isEnabled(); 353 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 354 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 355 356 ArrayList<SubscriptionInfo> mActiveSubInfos = new ArrayList<>(); 357 mActiveSubInfos.add(mMockSubInfo); 358 mActiveSubInfos.add(mMockSubInfo1); 359 doReturn(mActiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 360 doReturn(false).when(mMockSubInfo).isEmbedded(); 361 doReturn(true).when(mMockSubInfo1).isEmbedded(); 362 doReturn(TEST_SUBID_0).when(mMockSubInfo).getSubscriptionId(); 363 doReturn(TEST_SUBID_1).when(mMockSubInfo1).getSubscriptionId(); 364 365 PersistableBundle persistableBundle = new PersistableBundle(); 366 persistableBundle.putBoolean(CarrierConfigManager 367 .KEY_CARRIER_SUPPORTS_OPP_DATA_AUTO_PROVISIONING_BOOL, false); 368 doReturn(persistableBundle).when(mMockCarrierConfigManager).getConfigForSubId(TEST_SUBID_0); 369 370 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 371 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 372 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 373 mMockONSStats); 374 375 assertEquals(ONSProfileActivator.Result.ERR_DUAL_ACTIVE_SUBSCRIPTIONS, 376 onsProfileActivator.handleCarrierConfigChange()); 377 } 378 379 @Test testOneCBRSPSIMAndOneOpportunisticESIM()380 public void testOneCBRSPSIMAndOneOpportunisticESIM() { 381 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 382 doReturn(true).when(mMockEuiccManager).isEnabled(); 383 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 384 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 385 386 ArrayList<SubscriptionInfo> mActiveSubInfos = new ArrayList<>(); 387 mActiveSubInfos.add(mMockSubInfo); //Primary CBRS SIM 388 mActiveSubInfos.add(mMockSubInfo1); //Opportunistic eSIM 389 doReturn(mActiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 390 doReturn(mActiveSubInfos).when(mMockSubManager).getAvailableSubscriptionInfoList(); 391 392 doReturn(mMockSubInfo).when(mMockSubManager).getActiveSubscriptionInfo(TEST_SUBID_0); 393 doReturn(TEST_SUBID_0).when(mMockSubInfo).getSubscriptionId(); 394 doReturn(true).when(mMockSubManager).isActiveSubscriptionId(TEST_SUBID_0); 395 doReturn(false).when(mMockSubInfo).isOpportunistic(); 396 doReturn(false).when(mMockSubInfo).isEmbedded(); 397 ParcelUuid pSIMSubGroupId = new ParcelUuid(new UUID(0, 1)); 398 doReturn(pSIMSubGroupId).when(mMockSubInfo).getGroupUuid(); 399 PersistableBundle persistableBundle = new PersistableBundle(); 400 persistableBundle.putBoolean(CarrierConfigManager 401 .KEY_CARRIER_SUPPORTS_OPP_DATA_AUTO_PROVISIONING_BOOL, true); 402 persistableBundle.putIntArray(CarrierConfigManager 403 .KEY_OPPORTUNISTIC_CARRIER_IDS_INT_ARRAY, new int[]{1, 2}); 404 doReturn(persistableBundle).when(mMockCarrierConfigManager).getConfigForSubId(TEST_SUBID_0); 405 406 doReturn(mMockSubInfo1).when(mMockSubManager).getActiveSubscriptionInfo(TEST_SUBID_1); 407 doReturn(TEST_SUBID_1).when(mMockSubInfo1).getSubscriptionId(); 408 doReturn(true).when(mMockSubManager).isActiveSubscriptionId(TEST_SUBID_1); 409 doReturn(true).when(mMockSubInfo1).isOpportunistic(); 410 doReturn(true).when(mMockSubInfo1).isEmbedded(); 411 doReturn(pSIMSubGroupId).when(mMockSubInfo1).getGroupUuid(); 412 doReturn(1).when(mMockSubInfo1).getCarrierId(); 413 414 doReturn(mMockSubInfo1).when(mMockONSProfileConfigurator) 415 .findOpportunisticSubscription(TEST_SUBID_0); 416 417 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 418 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 419 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 420 mMockONSStats); 421 422 assertEquals(ONSProfileActivator.Result.SUCCESS, 423 onsProfileActivator.handleCarrierConfigChange()); 424 } 425 426 @Test 427 //@DisplayName("Dual SIM device with only opportunistic eSIM active") testOnlyOpportunisticESIMActive()428 public void testOnlyOpportunisticESIMActive() { 429 430 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 431 doReturn(true).when(mMockEuiccManager).isEnabled(); 432 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 433 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 434 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 435 doReturn(1).when(mMockactiveSubInfos).size(); 436 doReturn(mMockSubInfo).when(mMockactiveSubInfos).get(0); 437 doReturn(true).when(mMockSubInfo).isOpportunistic(); 438 439 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 440 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 441 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 442 mMockONSStats); 443 444 assertEquals(ONSProfileActivator.Result.ERR_SINGLE_ACTIVE_OPPORTUNISTIC_SIM, 445 onsProfileActivator.handleCarrierConfigChange()); 446 } 447 448 @Test 449 //@DisplayName("Dual SIM device, only CBRS carrier pSIM inserted and pSIM not Grouped") testCBRSpSIMAndNotGrouped()450 public void testCBRSpSIMAndNotGrouped() { 451 452 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 453 doReturn(true).when(mMockEuiccManager).isEnabled(); 454 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 455 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 456 457 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 458 doReturn(1).when(mMockactiveSubInfos).size(); 459 doReturn(mMockSubInfo).when(mMockactiveSubInfos).get(0); 460 doReturn(false).when(mMockSubInfo).isOpportunistic(); 461 doReturn(TEST_SUBID_1).when(mMockSubInfo).getSubscriptionId(); 462 doReturn(null).when(mMockSubInfo).getGroupUuid(); 463 doReturn(ONSProfileDownloader.DownloadProfileResult.SUCCESS).when(mMockONSProfileDownloader) 464 .downloadProfile(TEST_SUBID_1); 465 466 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 467 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, mMockEuiccManager, 468 mMockConnectivityManager, mMockONSProfileConfigurator, mMockONSProfileDownloader, 469 mMockONSStats); 470 471 onsProfileActivator.mIsInternetConnAvailable = true; 472 assertEquals(ONSProfileActivator.Result.DOWNLOAD_REQUESTED, 473 onsProfileActivator.handleCarrierConfigChange()); 474 } 475 476 @Test testCalculateBackoffDelay()477 public void testCalculateBackoffDelay() { 478 final Object lock = new Object(); 479 480 Runnable runnable = new Runnable() { 481 @Override 482 public void run() { 483 int delay = ONSProfileActivator.calculateBackoffDelay(1, 1) / 1000; 484 assertEquals(true, (delay >= 1 && delay <= 2)); 485 486 Log.i(TAG, "calculateBackoffDelay(2, 1)"); 487 delay = ONSProfileActivator.calculateBackoffDelay(2, 1) / 1000; 488 assertEquals(true, (delay >= 1 && delay < 4)); 489 490 delay = ONSProfileActivator.calculateBackoffDelay(3, 1) / 1000; 491 assertEquals(true, (delay >= 1 && delay < 8)); 492 493 delay = ONSProfileActivator.calculateBackoffDelay(4, 1) / 1000; 494 assertEquals(true, (delay >= 1 && delay < 16)); 495 496 delay = ONSProfileActivator.calculateBackoffDelay(1, 2) / 1000; 497 assertEquals(true, (delay >= 1 && delay <= 4)); 498 499 delay = ONSProfileActivator.calculateBackoffDelay(1, 3) / 1000; 500 assertEquals(true, (delay >= 1 && delay <= 6)); 501 502 delay = ONSProfileActivator.calculateBackoffDelay(2, 2) / 1000; 503 assertEquals(true, (delay >= 2 && delay < 8)); 504 505 synchronized (lock) { 506 lock.notifyAll(); 507 } 508 } 509 }; 510 511 WorkerThread workerThread = new WorkerThread(runnable); 512 workerThread.start(); 513 514 synchronized (lock) { 515 try { 516 lock.wait(); 517 } catch (Exception e) { 518 Log.e(TAG, e.getLocalizedMessage()); 519 } 520 } 521 522 workerThread.exit(); 523 } 524 525 /* Unable to mock final class ParcelUuid. These testcases should be enabled once the solution 526 is found */ 527 /*@Test 528 //@DisplayName("Dual SIM device, only CBRS carrier pSIM inserted and pSIM Grouped") 529 public void testOneSubscriptionInCBRSpSIMGroup() { 530 ParcelUuid mMockParcelUuid = crateMock(ParcelUuid.class); 531 532 doReturn(true).when(mMockONSProfileConfigurator) 533 .isESIMSupported(); 534 doReturn(true).when(mMockONSUtil).isMultiSIMPhone(); 535 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 536 mMockPrimaryCBRSSubInfo); 537 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 538 doReturn(1).when(mMockactiveSubInfos).size(); 539 doReturn(mMockPrimaryCBRSSubInfo).when(mMockactiveSubInfos).get(0); 540 doReturn(false).when(mMockPrimaryCBRSSubInfo).isOpportunistic(); 541 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 542 mMockPrimaryCBRSSubInfo); 543 doReturn(mMockParcelUuid).when(mMockPrimaryCBRSSubInfo).getGroupUuid(); 544 doReturn(mMocksubsInPSIMGroup).when(mMockSubManager).getSubscriptionsInGroup( 545 mMockParcelUuid); 546 doReturn(1).when(mMocksubsInPSIMGroup).size(); 547 548 ONSProfileActivator onsProfileActivator = 549 new ONSProfileActivator(mMockContext, mMockSubManager, mMockEuiCCManager, 550 mMockTeleManager, 551 mMockONSProfileConfigurator, mMockONSProfileDownloader, mMockONSStats); 552 553 assertEquals(ONSProfileActivator.Result.SUCCESS, 554 onsProfileActivator.handleSimStateChange()); 555 } 556 557 @Test 558 //@DisplayName("Dual SIM device, only CBRS carrier pSIM inserted and pSIM Group has two 559 subscription info.") 560 public void testTwoSubscriptionsInCBRSpSIMGroup() { 561 ParcelUuid mMockParcelUuid = crateMock(ParcelUuid.class); 562 563 doReturn(true).when(mMockONSProfileConfigurator) 564 .isESIMSupported(); 565 doReturn(true).when(mMockONSUtil).isMultiSIMPhone(); 566 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 567 mMockPrimaryCBRSSubInfo); 568 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 569 doReturn(1).when(mMockactiveSubInfos).size(); 570 doReturn(mMockPrimaryCBRSSubInfo).when(mMockactiveSubInfos).get(0); 571 doReturn(false).when(mMockPrimaryCBRSSubInfo).isOpportunistic(); 572 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 573 mMockPrimaryCBRSSubInfo); 574 doReturn(mMockParcelUuid).when(mMockPrimaryCBRSSubInfo).getGroupUuid(); 575 doReturn(mMocksubsInPSIMGroup).when(mMockSubManager).getSubscriptionsInGroup( 576 mMockParcelUuid); 577 doReturn(2).when(mMocksubsInPSIMGroup).size(); 578 579 ONSProfileActivator onsProfileActivator = 580 new ONSProfileActivator(mMockContext, mMockSubManager, mMockEuiCCManager, 581 mMockTeleManager, mMockONSProfileConfigurator, mMockONSProfileDownloader); 582 583 assertEquals(ONSProfileActivator.Result.SUCCESS, 584 onsProfileActivator.handleSimStateChange()); 585 } 586 587 @Test 588 //@DisplayName("Dual SIM device, only CBRS carrier pSIM inserted and pSIM Group has more than 589 two subscription info.") 590 public void testMoreThanTwoSubscriptionsInCBRSpSIMGroup() { 591 ParcelUuid mMockParcelUuid = crateMock(ParcelUuid.class); 592 593 doReturn(true).when(mMockONSProfileConfigurator) 594 .isESIMSupported(); 595 doReturn(true).when(mMockONSUtil).isMultiSIMPhone(); 596 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 597 mMockPrimaryCBRSSubInfo); 598 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 599 doReturn(1).when(mMockactiveSubInfos).size(); 600 doReturn(mMockPrimaryCBRSSubInfo).when(mMockactiveSubInfos).get(0); 601 doReturn(false).when(mMockPrimaryCBRSSubInfo).isOpportunistic(); 602 doReturn(true).when(mMockONSProfileConfigurator).isOppDataAutoProvisioningSupported( 603 mMockPrimaryCBRSSubInfo); 604 doReturn(mMockParcelUuid).when(mMockPrimaryCBRSSubInfo).getGroupUuid(); 605 doReturn(mMocksubsInPSIMGroup).when(mMockSubManager).getSubscriptionsInGroup( 606 mMockParcelUuid); 607 doReturn(3).when(mMocksubsInPSIMGroup).size(); 608 609 ONSProfileActivator onsProfileActivator = 610 new ONSProfileActivator(mMockContext, mMockSubManager, mMockEuiCCManager, 611 mMockTeleManager, mMockONSProfileConfigurator, mMockONSProfileDownloader); 612 613 assertEquals(ONSProfileActivator.Result.SUCCESS, 614 onsProfileActivator.handleSimStateChange()); 615 } 616 617 @Test 618 public void testRetryDownloadAfterRebootWithOppESIMAlreadyDownloaded() { 619 doReturn(true).when(mMockONSProfileConfigurator).getRetryDownloadAfterReboot(); 620 doReturn(1).when(mMockONSProfileConfigurator).getRetryDownloadPSIMSubId(); 621 doReturn(mMockSubManager).when(mMockONSUtil).getSubscriptionManager(); 622 doReturn(mMocksubsInPSIMGroup).when(mMockSubManager).getActiveSubscriptionInfo(); 623 //TODO: mock ParcelUuid - pSIM group 624 625 ONSProfileActivator onsProfileActivator = new ONSProfileActivator(mMockContext, 626 mMockONSProfileConfigurator, mMockONSProfileDownloader, mMockONSStats); 627 628 assertEquals(ONSProfileActivator.Result.ERR_INVALID_PSIM_SUBID, 629 onsProfileActivator.retryDownloadAfterReboot()); 630 } 631 */ 632 633 /*@Test 634 public void testNoInternetDownloadRequest() { 635 doReturn(TEST_SUB_ID).when(mMockSubInfo).getSubscriptionId(); 636 637 ONSProfileDownloader onsProfileDownloader = new ONSProfileDownloader(mMockContext, 638 mMockCarrierConfigManager, mMockEUICCManager, mMockONSProfileConfig, null); 639 640 onsProfileDownloader.mIsInternetConnAvailable = false; 641 onsProfileDownloader.downloadOpportunisticESIM(mMockSubInfo); 642 643 assertEquals(onsProfileDownloader.mRetryDownloadWhenNWConnected, true); 644 verify(mMockEUICCManager, never()).downloadSubscription(null, true, null); 645 }*/ 646 647 @Test testESIMDownloadFailureAndRetry()648 public void testESIMDownloadFailureAndRetry() { 649 doReturn(true).when(mMockResources).getBoolean(R.bool.enable_ons_auto_provisioning); 650 doReturn(true).when(mMockEuiccManager).isEnabled(); 651 doReturn(2).when(mMockTeleManager).getSupportedModemCount(); 652 doReturn(2).when(mMockTeleManager).getActiveModemCount(); 653 doReturn(ONSProfileDownloader.DownloadProfileResult.SUCCESS).when(mMockONSProfileDownloader) 654 .downloadProfile(TEST_SUBID_0); 655 656 doReturn(mMockactiveSubInfos).when(mMockSubManager).getActiveSubscriptionInfoList(); 657 doReturn(1).when(mMockactiveSubInfos).size(); 658 doReturn(mMockSubInfo).when(mMockactiveSubInfos).get(0); 659 doReturn(false).when(mMockSubInfo).isOpportunistic(); 660 doReturn(TEST_SUBID_0).when(mMockSubInfo).getSubscriptionId(); 661 doReturn(null).when(mMockSubInfo).getGroupUuid(); 662 663 final int maxRetryCount = 5; 664 665 // Retry immediately without wait. To reduce UT execution time. 666 final int retryBackoffTime = 0; 667 668 PersistableBundle persistableBundle = new PersistableBundle(); 669 persistableBundle.putBoolean(CarrierConfigManager 670 .KEY_CARRIER_SUPPORTS_OPP_DATA_AUTO_PROVISIONING_BOOL, true); 671 persistableBundle.putInt(CarrierConfigManager 672 .KEY_ESIM_MAX_DOWNLOAD_RETRY_ATTEMPTS_INT, maxRetryCount); 673 persistableBundle.putInt(CarrierConfigManager 674 .KEY_ESIM_DOWNLOAD_RETRY_BACKOFF_TIMER_SEC_INT, retryBackoffTime); 675 doReturn(persistableBundle).when(mMockCarrierConfigManager).getConfigForSubId(TEST_SUBID_0); 676 677 final Object lock = new Object(); 678 class TestRunnable implements Runnable { 679 public ONSProfileActivator mOnsProfileActivator; 680 681 @Override 682 public void run() { 683 mOnsProfileActivator = new ONSProfileActivator(mMockContext, 684 mMockSubManager, mMockTeleManager, mMockCarrierConfigManager, 685 mMockEuiccManager, mMockConnectivityManager, mMockONSProfileConfigurator, 686 mMockONSProfileDownloader, mMockONSStats); 687 688 synchronized (lock) { 689 lock.notify(); 690 } 691 } 692 } 693 694 TestRunnable runnable = new TestRunnable(); 695 WorkerThread workerThread = new WorkerThread(runnable); 696 workerThread.start(); 697 698 synchronized (lock) { 699 try { 700 lock.wait(); 701 } catch (InterruptedException e) { 702 e.printStackTrace(); 703 } 704 } 705 706 ONSProfileActivator onsProfileActivator = runnable.mOnsProfileActivator; 707 onsProfileActivator.mIsInternetConnAvailable = true; 708 709 for (int idx = 0; idx <= maxRetryCount; idx++) { 710 onsProfileActivator.onDownloadError( 711 TEST_SUBID_0, 712 ONSProfileDownloader.DownloadRetryResultCode.ERR_RETRY_DOWNLOAD, 0); 713 714 //Wait for Handler to process download message. Backoff delay + 500 milli secs. 715 try { 716 Thread.sleep(onsProfileActivator.calculateBackoffDelay( 717 onsProfileActivator.mDownloadRetryCount, retryBackoffTime) + 1000); 718 } catch (Exception e) { 719 e.printStackTrace(); 720 } 721 } 722 723 workerThread.exit(); 724 725 verify(mMockONSProfileDownloader, times(maxRetryCount)).downloadProfile(TEST_SUBID_0); 726 } 727 728 @After tearDown()729 public void tearDown() throws Exception { 730 super.tearDown(); 731 } 732 } 733 734