1 /* 2 * Copyright (C) 2020 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.cellbroadcastreceiver.unit; 18 19 import static com.google.common.truth.Truth.assertThat; 20 21 import static org.junit.Assert.assertArrayEquals; 22 import static org.junit.Assert.assertFalse; 23 import static org.junit.Assert.assertTrue; 24 import static org.mockito.ArgumentMatchers.any; 25 import static org.mockito.ArgumentMatchers.anyBoolean; 26 import static org.mockito.ArgumentMatchers.anyInt; 27 import static org.mockito.ArgumentMatchers.anyString; 28 import static org.mockito.ArgumentMatchers.eq; 29 import static org.mockito.Mockito.doNothing; 30 import static org.mockito.Mockito.doReturn; 31 import static org.mockito.Mockito.doThrow; 32 import static org.mockito.Mockito.mock; 33 import static org.mockito.Mockito.never; 34 import static org.mockito.Mockito.spy; 35 import static org.mockito.Mockito.times; 36 import static org.mockito.Mockito.verify; 37 38 import android.content.ContentResolver; 39 import android.content.Context; 40 import android.content.IContentProvider; 41 import android.content.Intent; 42 import android.content.pm.ActivityInfo; 43 import android.content.pm.PackageInfo; 44 import android.content.pm.PackageManager; 45 import android.content.res.Configuration; 46 import android.content.res.Resources; 47 import android.media.AudioDeviceInfo; 48 import android.os.RemoteException; 49 import android.os.UserManager; 50 import android.provider.Telephony; 51 import android.telephony.CarrierConfigManager; 52 import android.telephony.ServiceState; 53 import android.telephony.SubscriptionInfo; 54 import android.telephony.SubscriptionManager; 55 import android.telephony.TelephonyManager; 56 import android.telephony.cdma.CdmaSmsCbProgramData; 57 58 import com.android.cellbroadcastreceiver.CellBroadcastAlertService; 59 import com.android.cellbroadcastreceiver.CellBroadcastListActivity; 60 import com.android.cellbroadcastreceiver.CellBroadcastReceiver; 61 import com.android.cellbroadcastreceiver.CellBroadcastSettings; 62 import com.android.cellbroadcastreceiver.R; 63 64 import org.junit.After; 65 import org.junit.Assert; 66 import org.junit.Before; 67 import org.junit.Test; 68 import org.mockito.Mock; 69 70 import java.util.ArrayList; 71 import java.util.List; 72 import java.util.Map; 73 74 public class CellBroadcastReceiverTest extends CellBroadcastTest { 75 private static final long MAX_INIT_WAIT_MS = 5000; 76 77 private static final String[] MCC_TABLE = { 78 "gr:202", "nL:204", "Be:206", "US:310" 79 }; 80 81 CellBroadcastReceiver mCellBroadcastReceiver; 82 String mPackageName = "testPackageName"; 83 84 @Mock 85 UserManager mUserManager; 86 @Mock 87 Intent mIntent; 88 @Mock 89 PackageManager mPackageManager; 90 @Mock 91 PackageInfo mPackageInfo; 92 @Mock 93 ContentResolver mContentResolver; 94 @Mock 95 IContentProvider mContentProviderClient; 96 @Mock 97 TelephonyManager mMockTelephonyManager; 98 @Mock 99 SubscriptionManager mSubscriptionManager; 100 FakeSharedPreferences mFakeSharedPreferences = new FakeSharedPreferences(); 101 102 private Configuration mConfiguration = new Configuration(); 103 private AudioDeviceInfo[] mDevices = new AudioDeviceInfo[0]; 104 private Object mLock = new Object(); 105 private boolean mReady; 106 waitUntilReady()107 protected void waitUntilReady() { 108 synchronized (mLock) { 109 if (!mReady) { 110 try { 111 mLock.wait(MAX_INIT_WAIT_MS); 112 } catch (InterruptedException ie) { 113 } 114 115 if (!mReady) { 116 Assert.fail("Telephony tests failed to initialize"); 117 } 118 } 119 } 120 } 121 setReady(boolean ready)122 protected void setReady(boolean ready) { 123 synchronized (mLock) { 124 mReady = ready; 125 mLock.notifyAll(); 126 } 127 } 128 129 @Before setUp()130 public void setUp() throws Exception { 131 super.setUp(this.getClass().getSimpleName()); 132 doReturn(mConfiguration).when(mResources).getConfiguration(); 133 doReturn(MCC_TABLE).when(mResources).getStringArray(R.array.iso_country_code_mcc_table); 134 mCellBroadcastReceiver = spy(new CellBroadcastReceiver()); 135 doReturn(mResources).when(mCellBroadcastReceiver).getResourcesMethod(); 136 doNothing().when(mCellBroadcastReceiver).startConfigServiceToEnableChannels(); 137 doReturn(mContext).when(mContext).getApplicationContext(); 138 doReturn(mPackageName).when(mContext).getPackageName(); 139 doReturn(mFakeSharedPreferences).when(mContext).getSharedPreferences(anyString(), anyInt()); 140 doReturn(mUserManager).when(mContext).getSystemService(Context.USER_SERVICE); 141 doReturn(false).when(mUserManager).isSystemUser(); 142 setContext(); 143 } 144 145 @Test testOnReceive_actionCarrierConfigChanged()146 public void testOnReceive_actionCarrierConfigChanged() { 147 doReturn(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED).when(mIntent).getAction(); 148 doNothing().when(mCellBroadcastReceiver).enableLauncher(); 149 mCellBroadcastReceiver.onReceive(mContext, mIntent); 150 verify(mCellBroadcastReceiver).initializeSharedPreference(any(), anyInt()); 151 verify(mCellBroadcastReceiver).startConfigServiceToEnableChannels(); 152 verify(mCellBroadcastReceiver).enableLauncher(); 153 verify(mCellBroadcastReceiver).resetCellBroadcastChannelRanges(); 154 } 155 156 @Test testOnReceive_actionCarrierConfigChangedOnRebroadcast()157 public void testOnReceive_actionCarrierConfigChangedOnRebroadcast() { 158 doReturn(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED).when(mIntent).getAction(); 159 doReturn(true).when(mIntent) 160 .getBooleanExtra("android.telephony.extra.REBROADCAST_ON_UNLOCK", false); 161 mCellBroadcastReceiver.onReceive(mContext, mIntent); 162 verify(mCellBroadcastReceiver, never()).initializeSharedPreference(any(), anyInt()); 163 verify(mCellBroadcastReceiver, never()).startConfigServiceToEnableChannels(); 164 verify(mCellBroadcastReceiver, never()).enableLauncher(); 165 } 166 167 @Test testOnReceive_actionBootCompleted()168 public void testOnReceive_actionBootCompleted() { 169 doReturn(mContentResolver).when(mContext).getContentResolver(); 170 doReturn(mContentProviderClient).when(mContentResolver).acquireContentProviderClient( 171 "cellbroadcasts-app"); 172 doReturn(Intent.ACTION_BOOT_COMPLETED).when(mIntent).getAction(); 173 mCellBroadcastReceiver.onReceive(mContext, mIntent); 174 } 175 176 @Test testOnReceive_cellbroadcastStartConfigAction()177 public void testOnReceive_cellbroadcastStartConfigAction() { 178 doReturn(CellBroadcastReceiver.CELLBROADCAST_START_CONFIG_ACTION).when(mIntent).getAction(); 179 mCellBroadcastReceiver.onReceive(mContext, mIntent); 180 181 verify(mCellBroadcastReceiver, never()).initializeSharedPreference(any(), anyInt()); 182 verify(mCellBroadcastReceiver, never()).startConfigServiceToEnableChannels(); 183 } 184 185 @Test testOnReceive_actionDefaultSmsSubscriptionChanged()186 public void testOnReceive_actionDefaultSmsSubscriptionChanged() { 187 doReturn(SubscriptionManager.ACTION_DEFAULT_SMS_SUBSCRIPTION_CHANGED) 188 .when(mIntent).getAction(); 189 doReturn(mUserManager).when(mContext).getSystemService(anyString()); 190 mCellBroadcastReceiver.onReceive(mContext, mIntent); 191 verify(mCellBroadcastReceiver, never()).initializeSharedPreference(any(), anyInt()); 192 verify(mCellBroadcastReceiver).startConfigServiceToEnableChannels(); 193 194 doReturn(true).when(mCellBroadcastReceiver).isMockModemRunning(); 195 mCellBroadcastReceiver.onReceive(mContext, mIntent); 196 verify(mCellBroadcastReceiver, times(1)).startConfigServiceToEnableChannels(); 197 198 doReturn(false).when(mCellBroadcastReceiver).isMockModemRunning(); 199 mCellBroadcastReceiver.onReceive(mContext, mIntent); 200 verify(mCellBroadcastReceiver, times(2)).startConfigServiceToEnableChannels(); 201 } 202 203 @Test testOnReceive_actionSmsEmergencyCbReceived()204 public void testOnReceive_actionSmsEmergencyCbReceived() { 205 doReturn(Telephony.Sms.Intents.ACTION_SMS_EMERGENCY_CB_RECEIVED).when(mIntent).getAction(); 206 doReturn(mIntent).when(mIntent).setClass(mContext, CellBroadcastAlertService.class); 207 doReturn(null).when(mContext).startService(mIntent); 208 209 mCellBroadcastReceiver.onReceive(mContext, mIntent); 210 verify(mIntent).setClass(mContext, CellBroadcastAlertService.class); 211 verify(mContext).startService(mIntent); 212 } 213 214 @Test testOnReceive_smsCbReceivedAction()215 public void testOnReceive_smsCbReceivedAction() { 216 doReturn(Telephony.Sms.Intents.SMS_CB_RECEIVED_ACTION).when(mIntent).getAction(); 217 doReturn(mIntent).when(mIntent).setClass(mContext, CellBroadcastAlertService.class); 218 doReturn(null).when(mContext).startService(any()); 219 220 mCellBroadcastReceiver.onReceive(mContext, mIntent); 221 verify(mIntent).setClass(mContext, CellBroadcastAlertService.class); 222 verify(mContext).startService(mIntent); 223 } 224 225 @Test testOnReceive_smsServiceCategoryProgramDataReceivedAction()226 public void testOnReceive_smsServiceCategoryProgramDataReceivedAction() { 227 doReturn(Telephony.Sms.Intents.SMS_SERVICE_CATEGORY_PROGRAM_DATA_RECEIVED_ACTION) 228 .when(mIntent).getAction(); 229 doReturn(null).when(mIntent).getParcelableArrayListExtra(anyString()); 230 231 mCellBroadcastReceiver.onReceive(mContext, mIntent); 232 verify(mIntent).getParcelableArrayListExtra(anyString()); 233 } 234 235 @Test testInitializeSharedPreference_ifSystemUser_invalidSub()236 public void testInitializeSharedPreference_ifSystemUser_invalidSub() throws RemoteException { 237 doReturn("An invalid action").when(mIntent).getAction(); 238 doReturn(true).when(mUserManager).isSystemUser(); 239 doReturn(true).when(mCellBroadcastReceiver).sharedPrefsHaveDefaultValues(); 240 doNothing().when(mCellBroadcastReceiver).adjustReminderInterval(); 241 mockTelephonyManager(); 242 243 int subId = 1; 244 // Not starting ConfigService, as default subId is valid and subId are invalid 245 mockDefaultSubId(subId); 246 mCellBroadcastReceiver.initializeSharedPreference(mContext, 247 SubscriptionManager.INVALID_SUBSCRIPTION_ID); 248 verify(mContext, never()).startService(any()); 249 verify(mCellBroadcastReceiver, never()).saveCarrierIdForDefaultSub(anyInt()); 250 251 // Not starting ConfigService, as both default subId and subId are invalid 252 mockDefaultSubId(SubscriptionManager.INVALID_SUBSCRIPTION_ID); 253 mCellBroadcastReceiver.initializeSharedPreference(mContext, 254 SubscriptionManager.INVALID_SUBSCRIPTION_ID); 255 verify(mContext, never()).startService(any()); 256 verify(mCellBroadcastReceiver).saveCarrierIdForDefaultSub(anyInt()); 257 } 258 mockTelephonyManager()259 private void mockTelephonyManager() { 260 doReturn(mMockTelephonyManager).when(mMockTelephonyManager) 261 .createForSubscriptionId(anyInt()); 262 doReturn(Context.TELEPHONY_SERVICE).when(mContext).getSystemServiceName( 263 TelephonyManager.class); 264 doReturn(mMockTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE); 265 } 266 267 @Test testInitializeSharedPreference_ifSystemUser_firstSub()268 public void testInitializeSharedPreference_ifSystemUser_firstSub() throws Exception { 269 doReturn("An invalid action").when(mIntent).getAction(); 270 doReturn(true).when(mUserManager).isSystemUser(); 271 doReturn(true).when(mCellBroadcastReceiver).sharedPrefsHaveDefaultValues(); 272 doNothing().when(mCellBroadcastReceiver).adjustReminderInterval(); 273 mockTelephonyManager(); 274 275 int subId = 1; 276 int otherSubId = 2; 277 // The subId has to match default sub for it to take action. 278 mockDefaultSubId(SubscriptionManager.INVALID_SUBSCRIPTION_ID); 279 mCellBroadcastReceiver.initializeSharedPreference(mContext, subId); 280 verify(mContext, never()).startService(any()); 281 282 // Not starting ConfigService, not matching default subId. 283 mockDefaultSubId(otherSubId); 284 mCellBroadcastReceiver.initializeSharedPreference(mContext, subId); 285 verify(mContext, never()).startService(any()); 286 287 // Not starting ConfigService, simCarrierId is UNKNOWN. 288 mockDefaultSubId(subId); 289 doReturn(TelephonyManager.UNKNOWN_CARRIER_ID).when(mMockTelephonyManager) 290 .getSimCarrierId(); 291 mCellBroadcastReceiver.initializeSharedPreference(mContext, subId); 292 verify(mContext, never()).startService(any()); 293 294 // Not starting ConfigService, as there was no previous carrierId. 295 doReturn(subId).when(mMockTelephonyManager).getSimCarrierId(); 296 mCellBroadcastReceiver.initializeSharedPreference(mContext, subId); 297 verify(mContext, never()).startService(any()); 298 } 299 300 @Test testInitializeSharedPreference_ifSystemUser_carrierChange()301 public void testInitializeSharedPreference_ifSystemUser_carrierChange() throws Exception { 302 doReturn("An invalid action").when(mIntent).getAction(); 303 doReturn(true).when(mUserManager).isSystemUser(); 304 doReturn(true).when(mCellBroadcastReceiver).sharedPrefsHaveDefaultValues(); 305 doNothing().when(mCellBroadcastReceiver).adjustReminderInterval(); 306 mockTelephonyManager(); 307 308 int firstSubId = 1; 309 int secondSubId = 2; 310 // Initialize for first sub. 311 mockDefaultSubId(firstSubId); 312 doReturn(firstSubId).when(mMockTelephonyManager).getSimCarrierId(); 313 mCellBroadcastReceiver.initializeSharedPreference(mContext, firstSubId); 314 verify(mContext, never()).startService(any()); 315 316 // InitializeSharedPreference for second sub. 317 // Starting ConfigService, as there's a carrierId change. 318 mockDefaultSubId(secondSubId); 319 doReturn(secondSubId).when(mMockTelephonyManager).getSimCarrierId(); 320 mCellBroadcastReceiver.initializeSharedPreference(mContext, secondSubId); 321 verify(mContext).startService(any()); 322 323 // Initialize for first sub and starting ConfigService as same carrierId change. 324 mockDefaultSubId(firstSubId); 325 doReturn(secondSubId).when(mMockTelephonyManager).getSimCarrierId(); 326 mCellBroadcastReceiver.initializeSharedPreference(mContext, firstSubId); 327 verify(mContext, times(2)).startService(any()); 328 } 329 330 @Test testInitializeSharedPreference_ifNotSystemUser()331 public void testInitializeSharedPreference_ifNotSystemUser() { 332 doReturn("An invalid action").when(mIntent).getAction(); 333 doReturn(false).when(mUserManager).isSystemUser(); 334 335 mCellBroadcastReceiver.initializeSharedPreference(any(), anyInt()); 336 assertThat(mFakeSharedPreferences.getValueCount()).isEqualTo(0); 337 } 338 339 @Test testMigrateSharedPreferenceFromLegacyWhenNoLegacyProvider()340 public void testMigrateSharedPreferenceFromLegacyWhenNoLegacyProvider() { 341 doReturn(mContentResolver).when(mContext).getContentResolver(); 342 doReturn(null).when(mContentResolver).acquireContentProviderClient( 343 Telephony.CellBroadcasts.AUTHORITY_LEGACY); 344 345 mCellBroadcastReceiver.migrateSharedPreferenceFromLegacy(); 346 verify(mContext, never()).getSharedPreferences(anyString(), anyInt()); 347 } 348 349 @Test testMigrateSharedPreferenceFromLegacyWhenBundleNull()350 public void testMigrateSharedPreferenceFromLegacyWhenBundleNull() throws RemoteException { 351 doReturn(mContentResolver).when(mContext).getContentResolver(); 352 doReturn(mContentProviderClient).when(mContentResolver).acquireContentProviderClient( 353 Telephony.CellBroadcasts.AUTHORITY_LEGACY); 354 doReturn(null).when(mContentProviderClient).call( 355 anyString(), anyString(), anyString(), any()); 356 357 mCellBroadcastReceiver.migrateSharedPreferenceFromLegacy(); 358 verify(mContext).getSharedPreferences(anyString(), anyInt()); 359 assertThat(mFakeSharedPreferences.getValueCount()).isEqualTo(0); 360 } 361 362 @Test testSetTestingMode()363 public void testSetTestingMode() { 364 assertThat(mCellBroadcastReceiver.isTestingMode(mContext)).isFalse(); 365 mCellBroadcastReceiver.setTestingMode(true); 366 assertThat(mCellBroadcastReceiver.isTestingMode(mContext)).isTrue(); 367 } 368 369 @Test testAdjustReminderInterval()370 public void testAdjustReminderInterval() { 371 mFakeSharedPreferences.putString(CellBroadcastReceiver.CURRENT_INTERVAL_DEFAULT, 372 "currentInterval"); 373 doReturn(mResources).when(mContext).getResources(); 374 doReturn(mContext).when(mContext).createConfigurationContext(any()); 375 doReturn(mSubscriptionManager).when(mContext).getSystemService( 376 Context.TELEPHONY_SUBSCRIPTION_SERVICE); 377 doReturn("newInterval").when(mResources).getString( 378 R.string.alert_reminder_interval_in_min_default); 379 380 mCellBroadcastReceiver.adjustReminderInterval(); 381 assertThat(mFakeSharedPreferences.getString( 382 CellBroadcastReceiver.CURRENT_INTERVAL_DEFAULT, "")) 383 .isEqualTo("newInterval"); 384 } 385 386 @Test testEnableLauncherIfNoLauncherActivity()387 public void testEnableLauncherIfNoLauncherActivity() throws 388 PackageManager.NameNotFoundException { 389 doReturn(mPackageManager).when(mContext).getPackageManager(); 390 doReturn(mPackageInfo).when(mPackageManager).getPackageInfo(anyString(), anyInt()); 391 392 ActivityInfo activityInfo = new ActivityInfo(); 393 String activityInfoName = ""; 394 activityInfo.targetActivity = CellBroadcastListActivity.class.getName(); 395 activityInfo.name = activityInfoName; 396 ActivityInfo[] activityInfos = new ActivityInfo[1]; 397 activityInfos[0] = activityInfo; 398 mPackageInfo.activities = activityInfos; 399 400 mCellBroadcastReceiver.enableLauncher(); 401 verify(mPackageManager, never()).setComponentEnabledSetting(any(), anyInt(), anyInt()); 402 } 403 404 @Test testEnableLauncherIfEnableTrue()405 public void testEnableLauncherIfEnableTrue() throws PackageManager.NameNotFoundException { 406 doReturn(mPackageManager).when(mContext).getPackageManager(); 407 doReturn(mPackageInfo).when(mPackageManager).getPackageInfo(anyString(), anyInt()); 408 doReturn(true).when(mResources) 409 .getBoolean(R.bool.show_message_history_in_launcher); 410 411 ActivityInfo activityInfo = new ActivityInfo(); 412 String activityInfoName = "testName"; 413 activityInfo.targetActivity = CellBroadcastListActivity.class.getName(); 414 activityInfo.name = activityInfoName; 415 ActivityInfo[] activityInfos = new ActivityInfo[1]; 416 activityInfos[0] = activityInfo; 417 mPackageInfo.activities = activityInfos; 418 419 mCellBroadcastReceiver.enableLauncher(); 420 verify(mPackageManager).setComponentEnabledSetting(any(), 421 eq(PackageManager.COMPONENT_ENABLED_STATE_ENABLED), anyInt()); 422 } 423 424 @Test testEnableLauncherIfEnableFalse()425 public void testEnableLauncherIfEnableFalse() throws PackageManager.NameNotFoundException { 426 doReturn(mPackageManager).when(mContext).getPackageManager(); 427 doReturn(mPackageInfo).when(mPackageManager).getPackageInfo(anyString(), anyInt()); 428 doReturn(false).when(mResources) 429 .getBoolean(R.bool.show_message_history_in_launcher); 430 431 ActivityInfo activityInfo = new ActivityInfo(); 432 String activityInfoName = "testName"; 433 activityInfo.targetActivity = CellBroadcastListActivity.class.getName(); 434 activityInfo.name = activityInfoName; 435 ActivityInfo[] activityInfos = new ActivityInfo[1]; 436 activityInfos[0] = activityInfo; 437 mPackageInfo.activities = activityInfos; 438 439 mCellBroadcastReceiver.enableLauncher(); 440 verify(mPackageManager).setComponentEnabledSetting(any(), 441 eq(PackageManager.COMPONENT_ENABLED_STATE_DISABLED), anyInt()); 442 } 443 444 @Test testTryCdmaSetCatergory()445 public void testTryCdmaSetCatergory() { 446 boolean enable = true; 447 448 mCellBroadcastReceiver.tryCdmaSetCategory(mContext, 449 CdmaSmsCbProgramData.CATEGORY_CMAS_EXTREME_THREAT, enable); 450 assertThat(mFakeSharedPreferences.getBoolean( 451 CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, !enable)) 452 .isEqualTo(enable); 453 454 mCellBroadcastReceiver.tryCdmaSetCategory(mContext, 455 CdmaSmsCbProgramData.CATEGORY_CMAS_SEVERE_THREAT, enable); 456 assertThat(mFakeSharedPreferences.getBoolean( 457 CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, !enable)) 458 .isEqualTo(enable); 459 460 mCellBroadcastReceiver.tryCdmaSetCategory(mContext, 461 CdmaSmsCbProgramData.CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, enable); 462 assertThat(mFakeSharedPreferences.getBoolean( 463 CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, !enable)) 464 .isEqualTo(enable); 465 466 mCellBroadcastReceiver.tryCdmaSetCategory(mContext, 467 CdmaSmsCbProgramData.CATEGORY_CMAS_TEST_MESSAGE, enable); 468 assertThat(mFakeSharedPreferences.getBoolean( 469 CellBroadcastSettings.KEY_ENABLE_TEST_ALERTS, !enable)) 470 .isEqualTo(enable); 471 472 // set the not defined category 473 FakeSharedPreferences mockSharedPreferences = spy(mFakeSharedPreferences); 474 doReturn(mockSharedPreferences).when(mContext).getSharedPreferences(anyString(), anyInt()); 475 mCellBroadcastReceiver.tryCdmaSetCategory(mContext, 476 CdmaSmsCbProgramData.CATEGORY_CMAS_LAST_RESERVED_VALUE + 1, enable); 477 verify(mockSharedPreferences, never()).apply(); 478 } 479 480 @Test testHandleCdmaSmsCbProgramDataOperationAddAndDelete()481 public void testHandleCdmaSmsCbProgramDataOperationAddAndDelete() { 482 CdmaSmsCbProgramData programData = new CdmaSmsCbProgramData( 483 CdmaSmsCbProgramData.OPERATION_ADD_CATEGORY, 484 CdmaSmsCbProgramData.CATEGORY_CMAS_EXTREME_THREAT, 485 1, 1, 1, "catergoryName"); 486 mCellBroadcastReceiver.handleCdmaSmsCbProgramData(new ArrayList<>(List.of(programData))); 487 verify(mCellBroadcastReceiver).tryCdmaSetCategory(mContext, 488 CdmaSmsCbProgramData.CATEGORY_CMAS_EXTREME_THREAT, true); 489 490 programData = new CdmaSmsCbProgramData(CdmaSmsCbProgramData.OPERATION_DELETE_CATEGORY, 491 CdmaSmsCbProgramData.CATEGORY_CMAS_EXTREME_THREAT, 492 1, 1, 1, "catergoryName"); 493 mCellBroadcastReceiver.handleCdmaSmsCbProgramData(new ArrayList<>(List.of(programData))); 494 verify(mCellBroadcastReceiver).tryCdmaSetCategory(mContext, 495 CdmaSmsCbProgramData.CATEGORY_CMAS_EXTREME_THREAT, false); 496 } 497 498 @Test testHandleCdmaSmsCbProgramDataOprationClear()499 public void testHandleCdmaSmsCbProgramDataOprationClear() { 500 CdmaSmsCbProgramData programData = new CdmaSmsCbProgramData( 501 CdmaSmsCbProgramData.OPERATION_CLEAR_CATEGORIES, 502 CdmaSmsCbProgramData.CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, 503 1, 1, 1, "catergoryName"); 504 mCellBroadcastReceiver.handleCdmaSmsCbProgramData(new ArrayList<>(List.of(programData))); 505 verify(mCellBroadcastReceiver).tryCdmaSetCategory(mContext, 506 CdmaSmsCbProgramData.CATEGORY_CMAS_EXTREME_THREAT, false); 507 verify(mCellBroadcastReceiver).tryCdmaSetCategory(mContext, 508 CdmaSmsCbProgramData.CATEGORY_CMAS_SEVERE_THREAT, false); 509 verify(mCellBroadcastReceiver).tryCdmaSetCategory(mContext, 510 CdmaSmsCbProgramData.CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, false); 511 verify(mCellBroadcastReceiver).tryCdmaSetCategory(mContext, 512 CdmaSmsCbProgramData.CATEGORY_CMAS_TEST_MESSAGE, false); 513 } 514 515 @Test testHandleCdmaSmsCbProgramDataNotDefinedOperation()516 public void testHandleCdmaSmsCbProgramDataNotDefinedOperation() { 517 CdmaSmsCbProgramData programData = new CdmaSmsCbProgramData( 518 -1, CdmaSmsCbProgramData.CATEGORY_CMAS_LAST_RESERVED_VALUE + 1, 1, 1, 1, ""); 519 mCellBroadcastReceiver.handleCdmaSmsCbProgramData(new ArrayList<>(List.of(programData))); 520 verify(mCellBroadcastReceiver, never()).tryCdmaSetCategory(any(), anyInt(), anyBoolean()); 521 } 522 523 //this method is just to assign mContext to the spied instance mCellBroadcastReceiver setContext()524 private void setContext() { 525 doReturn("dummy action").when(mIntent).getAction(); 526 527 mCellBroadcastReceiver.onReceive(mContext, mIntent); 528 } 529 530 @Test testOnServiceStateChange()531 public void testOnServiceStateChange() { 532 mFakeSharedPreferences.putInt("service_state", ServiceState.STATE_OUT_OF_SERVICE); 533 mFakeSharedPreferences.putString("roaming_operator_supported", ""); 534 mockTelephonyManager(); 535 doReturn("android.intent.action.SERVICE_STATE").when(mIntent).getAction(); 536 doReturn(ServiceState.STATE_IN_SERVICE).when(mIntent).getIntExtra(anyString(), anyInt()); 537 doReturn(false).when(mMockTelephonyManager).isNetworkRoaming(); 538 doReturn("123456").when(mMockTelephonyManager).getNetworkOperator(); 539 540 mCellBroadcastReceiver.onReceive(mContext, mIntent); 541 542 verify(mCellBroadcastReceiver, never()).startConfigServiceToEnableChannels(); 543 assertThat(mFakeSharedPreferences.getInt("service_state", ServiceState.STATE_POWER_OFF)) 544 .isEqualTo(ServiceState.STATE_IN_SERVICE); 545 546 mFakeSharedPreferences.putInt("service_state", ServiceState.STATE_POWER_OFF); 547 548 mCellBroadcastReceiver.onReceive(mContext, mIntent); 549 550 verify(mCellBroadcastReceiver).startConfigServiceToEnableChannels(); 551 assertThat(mFakeSharedPreferences.getInt("service_state", ServiceState.STATE_POWER_OFF)) 552 .isEqualTo(ServiceState.STATE_IN_SERVICE); 553 554 doReturn(true).when(mCellBroadcastReceiver).isMockModemRunning(); 555 mFakeSharedPreferences.putInt("service_state", ServiceState.STATE_POWER_OFF); 556 mCellBroadcastReceiver.onReceive(mContext, mIntent); 557 verify(mCellBroadcastReceiver, times(1)).startConfigServiceToEnableChannels(); 558 559 doReturn(false).when(mCellBroadcastReceiver).isMockModemRunning(); 560 mFakeSharedPreferences.putInt("service_state", ServiceState.STATE_POWER_OFF); 561 mCellBroadcastReceiver.onReceive(mContext, mIntent); 562 verify(mCellBroadcastReceiver, times(2)).startConfigServiceToEnableChannels(); 563 } 564 565 566 @Test testOnNetworkRoamingChange()567 public void testOnNetworkRoamingChange() { 568 doReturn("").when(mCellBroadcastReceiver).getSystemProperties(any()); 569 570 mFakeSharedPreferences.putInt("service_state", ServiceState.STATE_IN_SERVICE); 571 mFakeSharedPreferences.putString("roaming_operator_supported", ""); 572 mockTelephonyManager(); 573 doReturn("android.intent.action.SERVICE_STATE").when(mIntent).getAction(); 574 doReturn(ServiceState.STATE_IN_SERVICE).when(mIntent).getIntExtra(anyString(), anyInt()); 575 doReturn("123456").when(mMockTelephonyManager).getNetworkOperator(); 576 577 // not roaming, verify not to store the network operator, or call enable channel 578 doReturn(false).when(mMockTelephonyManager).isNetworkRoaming(); 579 580 mCellBroadcastReceiver.onReceive(mContext, mIntent); 581 582 verify(mCellBroadcastReceiver, never()).startConfigServiceToEnableChannels(); 583 assertThat(mFakeSharedPreferences.getString( 584 "roaming_operator_supported", "123456")).isEqualTo(""); 585 586 // roaming and network operator changed with wild match, verify to 587 // update the network operator, and call enable channel 588 doReturn(true).when(mMockTelephonyManager).isNetworkRoaming(); 589 doReturn(new String[] {"XXXXXX"}).when(mResources).getStringArray(anyInt()); 590 doReturn("654321").when(mMockTelephonyManager).getSimOperator(); 591 592 mCellBroadcastReceiver.onReceive(mContext, mIntent); 593 594 verify(mCellBroadcastReceiver, times(1)).startConfigServiceToEnableChannels(); 595 assertThat(mFakeSharedPreferences.getString( 596 "roaming_operator_supported", "")).isEqualTo("123456"); 597 598 // roaming to home case, verify to call enable channel 599 doReturn(false).when(mMockTelephonyManager).isNetworkRoaming(); 600 601 mCellBroadcastReceiver.onReceive(mContext, mIntent); 602 603 verify(mCellBroadcastReceiver, times(2)).startConfigServiceToEnableChannels(); 604 assertThat(mFakeSharedPreferences.getString( 605 "roaming_operator_supported", "123456")).isEqualTo(""); 606 607 // roaming and network operator changed with exact mcc match, verify to 608 // update the network operator, and call enable channel 609 doReturn(true).when(mMockTelephonyManager).isNetworkRoaming(); 610 doReturn(new String[] {"123"}).when(mResources).getStringArray(anyInt()); 611 doReturn("654321").when(mMockTelephonyManager).getSimOperator(); 612 613 mCellBroadcastReceiver.onReceive(mContext, mIntent); 614 615 verify(mCellBroadcastReceiver, times(3)).startConfigServiceToEnableChannels(); 616 assertThat(mFakeSharedPreferences.getString( 617 "roaming_operator_supported", "")).isEqualTo("123"); 618 619 // roaming to network operator with same mcc and configured as exact mcc match, 620 // verify to update the network operator, but not call enable channel 621 doReturn("123654").when(mMockTelephonyManager).getNetworkOperator(); 622 623 mCellBroadcastReceiver.onReceive(mContext, mIntent); 624 625 verify(mCellBroadcastReceiver, times(3)).startConfigServiceToEnableChannels(); 626 assertThat(mFakeSharedPreferences.getString( 627 "roaming_operator_supported", "")).isEqualTo("123"); 628 629 // roaming and network operator changed with exact match, verify to 630 // update the network operator, and call enable channel 631 doReturn(new String[] {"123456"}).when(mResources).getStringArray(anyInt()); 632 doReturn("123456").when(mMockTelephonyManager).getNetworkOperator(); 633 634 mCellBroadcastReceiver.onReceive(mContext, mIntent); 635 636 verify(mCellBroadcastReceiver, times(4)).startConfigServiceToEnableChannels(); 637 assertThat(mFakeSharedPreferences.getString( 638 "roaming_operator_supported", "")).isEqualTo("123456"); 639 640 // roaming to network operator with different mcc and configured as any mcc match, 641 // verify to update the network operator, and call enable channel 642 doReturn("321456").when(mMockTelephonyManager).getNetworkOperator(); 643 doReturn(new String[] {"XXX"}).when(mResources).getStringArray(anyInt()); 644 645 mCellBroadcastReceiver.onReceive(mContext, mIntent); 646 647 verify(mCellBroadcastReceiver, times(5)).startConfigServiceToEnableChannels(); 648 assertThat(mFakeSharedPreferences.getString( 649 "roaming_operator_supported", "")).isEqualTo("321"); 650 651 // roaming to network operator which does not match the configuration, 652 // verify to update the network operator to empty, and call enable channel 653 doReturn("321456").when(mMockTelephonyManager).getNetworkOperator(); 654 doReturn(new String[] {"123"}).when(mResources).getStringArray(anyInt()); 655 656 mCellBroadcastReceiver.onReceive(mContext, mIntent); 657 658 verify(mCellBroadcastReceiver, times(6)).startConfigServiceToEnableChannels(); 659 assertThat(mFakeSharedPreferences.getString( 660 "roaming_operator_supported", "321")).isEqualTo(""); 661 662 // roaming to network operator with different mcc and configured as any mcc match, 663 // verify to update the network operator, and call enable channel 664 doReturn("310240").when(mMockTelephonyManager).getNetworkOperator(); 665 doReturn("310260").when(mMockTelephonyManager).getSimOperator(); 666 doReturn(new String[] {"XXX"}).when(mResources).getStringArray(anyInt()); 667 668 mCellBroadcastReceiver.onReceive(mContext, mIntent); 669 670 verify(mCellBroadcastReceiver, times(6)).startConfigServiceToEnableChannels(); 671 assertThat(mFakeSharedPreferences.getString( 672 "roaming_operator_supported", "")).isEqualTo(""); 673 } 674 675 @Test testOnSimlessChange()676 public void testOnSimlessChange() { 677 doReturn("").when(mCellBroadcastReceiver).getSystemProperties(any()); 678 679 mFakeSharedPreferences.putInt("service_state", ServiceState.STATE_IN_SERVICE); 680 mFakeSharedPreferences.putString("roaming_operator_supported", ""); 681 doReturn("Us").when(mMockTelephonyManager).getNetworkCountryIso(); 682 mockTelephonyManager(); 683 doReturn("android.intent.action.SERVICE_STATE").when(mIntent).getAction(); 684 doReturn(ServiceState.STATE_OUT_OF_SERVICE).when(mIntent) 685 .getIntExtra(anyString(), anyInt()); 686 doReturn("").when(mMockTelephonyManager).getSimOperator(); 687 doReturn("").when(mMockTelephonyManager).getNetworkOperator(); 688 doReturn(false).when(mMockTelephonyManager).isNetworkRoaming(); 689 doReturn(new String[] {"XXX"}).when(mResources).getStringArray(anyInt()); 690 691 mCellBroadcastReceiver.onReceive(mContext, mIntent); 692 693 // verify the roaming operator is set correctly for simless case 694 verify(mCellBroadcastReceiver, times(1)).startConfigServiceToEnableChannels(); 695 assertThat(mFakeSharedPreferences.getString( 696 "roaming_operator_supported", "")).isEqualTo("310"); 697 698 doThrow(new IllegalArgumentException("test")) 699 .when(mMockTelephonyManager).getNetworkCountryIso(); 700 try { 701 mCellBroadcastReceiver.onReceive(mContext, mIntent); 702 } catch (Exception IllegalArgumentException) { 703 throw new AssertionError("not expected exception", IllegalArgumentException); 704 } 705 706 doReturn(ServiceState.STATE_OUT_OF_SERVICE).when(mIntent) 707 .getIntExtra(anyString(), anyInt()); 708 doReturn("123456").when(mMockTelephonyManager).getSimOperator(); 709 doReturn("123456").when(mMockTelephonyManager).getNetworkOperator(); 710 711 mCellBroadcastReceiver.onReceive(mContext, mIntent); 712 713 // verify the roaming operator is reset when sim loaded 714 verify(mCellBroadcastReceiver, times(2)).startConfigServiceToEnableChannels(); 715 assertThat(mFakeSharedPreferences.getString( 716 "roaming_operator_supported", "")).isEqualTo(""); 717 } 718 719 @Test testResourceOnRoamingState()720 public void testResourceOnRoamingState() throws RemoteException { 721 int subId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID; 722 723 doReturn(subId).when(mSubService).getDefaultSubId(); 724 doReturn(subId).when(mSubService).getDefaultSmsSubId(); 725 726 SubscriptionInfo mockSubInfo = mock(SubscriptionInfo.class); 727 doReturn(mockSubInfo).when(mSubscriptionManager).getActiveSubscriptionInfo(anyInt()); 728 Context newContext = mock(Context.class); 729 Resources roamingResource = mock(Resources.class); 730 doReturn(newContext).when(mContext).createConfigurationContext(any()); 731 doReturn(roamingResource).when(newContext).getResources(); 732 733 doReturn(false).when(mResources).getBoolean(R.bool.enable_led_flash); 734 doReturn(true).when(roamingResource).getBoolean(R.bool.enable_led_flash); 735 736 Resources res = CellBroadcastSettings.getResourcesByOperator(mContext, subId, ""); 737 assertFalse(res.getBoolean(R.bool.enable_led_flash)); 738 res = CellBroadcastSettings.getResourcesByOperator(mContext, subId, "530"); 739 assertTrue(res.getBoolean(R.bool.enable_led_flash)); 740 741 int[] mexico_vib_pattern = {0, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 742 500, 500, 500, 500, 500}; 743 int[] normal_vib_pattern = {0, 2000, 500, 1000, 500, 1000, 500, 2000, 500, 1000, 500, 1000}; 744 745 doReturn(normal_vib_pattern).when(mResources) 746 .getIntArray(R.array.default_vibration_pattern); 747 doReturn(mexico_vib_pattern).when(roamingResource) 748 .getIntArray(R.array.default_vibration_pattern); 749 750 res = CellBroadcastSettings.getResourcesByOperator(mContext, subId, ""); 751 assertArrayEquals(res.getIntArray(R.array.default_vibration_pattern), normal_vib_pattern); 752 mFakeSharedPreferences.putString("roaming_operator_supported", "334"); 753 res = CellBroadcastSettings.getResourcesByOperator(mContext, subId, "334"); 754 assertArrayEquals(res.getIntArray(R.array.default_vibration_pattern), mexico_vib_pattern); 755 756 doReturn(false).when(mResources) 757 .getBoolean(R.bool.mute_by_physical_button); 758 doReturn(true).when(roamingResource) 759 .getBoolean(R.bool.mute_by_physical_button); 760 761 res = CellBroadcastSettings.getResourcesByOperator(mContext, subId, ""); 762 assertFalse(res.getBoolean(R.bool.mute_by_physical_button)); 763 res = CellBroadcastSettings.getResourcesByOperator(mContext, subId, "730"); 764 assertTrue(res.getBoolean(R.bool.mute_by_physical_button)); 765 } 766 767 @Test testGetMccMap()768 public void testGetMccMap() { 769 final String[] mccArray = new String[] { 770 //valid values 771 "gr:202", "nL:204", "Be:206", "US:310", 772 //invalid values 773 "aaa", "123", "aaa123", "aaa 123" 774 }; 775 int validNum = 4; 776 doReturn(mccArray).when(mResources).getStringArray(anyInt()); 777 778 Map<String, String> map = CellBroadcastReceiver.getMccMap(mResources); 779 780 assertThat(map.size()).isEqualTo(validNum); 781 // 2 times expected as it has been called in setup 782 verify(mResources, times(2)).getStringArray(eq(R.array.iso_country_code_mcc_table)); 783 784 for (int i = 0; i < validNum; i++) { 785 String[] values = mccArray[i].split(":"); 786 assertThat(map.get(values[0].toLowerCase())).isEqualTo(values[1]); 787 assertThat(map.get(values[0].toUpperCase())).isEqualTo(null); 788 } 789 } 790 791 @After tearDown()792 public void tearDown() throws Exception { 793 super.tearDown(); 794 } 795 } 796