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