1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.internal.telephony; 18 19 import static org.junit.Assert.assertNotNull; 20 import static org.junit.Assert.assertTrue; 21 import static org.junit.Assert.fail; 22 import static org.mockito.ArgumentMatchers.anyString; 23 import static org.mockito.Matchers.anyBoolean; 24 import static org.mockito.Matchers.nullable; 25 import static org.mockito.Mockito.any; 26 import static org.mockito.Mockito.anyInt; 27 import static org.mockito.Mockito.doAnswer; 28 import static org.mockito.Mockito.doReturn; 29 import static org.mockito.Mockito.eq; 30 31 import android.app.ActivityManager; 32 import android.app.AppOpsManager; 33 import android.app.IActivityManager; 34 import android.app.KeyguardManager; 35 import android.app.usage.NetworkStatsManager; 36 import android.content.ContentResolver; 37 import android.content.Context; 38 import android.content.IIntentSender; 39 import android.content.Intent; 40 import android.content.SharedPreferences; 41 import android.content.pm.ApplicationInfo; 42 import android.content.pm.PackageInfo; 43 import android.content.pm.PackageManager; 44 import android.location.LocationManager; 45 import android.net.ConnectivityManager; 46 import android.net.NetworkCapabilities; 47 import android.net.vcn.VcnManager; 48 import android.net.vcn.VcnNetworkPolicyResult; 49 import android.net.wifi.WifiInfo; 50 import android.net.wifi.WifiManager; 51 import android.os.Build; 52 import android.os.Bundle; 53 import android.os.Handler; 54 import android.os.IBinder; 55 import android.os.Looper; 56 import android.os.Message; 57 import android.os.MessageQueue; 58 import android.os.RegistrantList; 59 import android.os.ServiceManager; 60 import android.os.UserManager; 61 import android.permission.LegacyPermissionManager; 62 import android.provider.BlockedNumberContract; 63 import android.provider.DeviceConfig; 64 import android.provider.Settings; 65 import android.telephony.AccessNetworkConstants; 66 import android.telephony.CarrierConfigManager; 67 import android.telephony.CellIdentity; 68 import android.telephony.CellLocation; 69 import android.telephony.NetworkRegistrationInfo; 70 import android.telephony.ServiceState; 71 import android.telephony.SignalStrength; 72 import android.telephony.SubscriptionManager; 73 import android.telephony.TelephonyManager; 74 import android.telephony.TelephonyRegistryManager; 75 import android.telephony.emergency.EmergencyNumber; 76 import android.telephony.euicc.EuiccManager; 77 import android.telephony.ims.ImsCallProfile; 78 import android.test.mock.MockContentProvider; 79 import android.test.mock.MockContentResolver; 80 import android.testing.TestableLooper; 81 import android.util.Log; 82 import android.util.Singleton; 83 84 import com.android.ims.ImsCall; 85 import com.android.ims.ImsEcbm; 86 import com.android.ims.ImsManager; 87 import com.android.internal.telephony.cdma.CdmaSubscriptionSourceManager; 88 import com.android.internal.telephony.cdma.EriManager; 89 import com.android.internal.telephony.dataconnection.DataEnabledOverride; 90 import com.android.internal.telephony.dataconnection.DataEnabledSettings; 91 import com.android.internal.telephony.dataconnection.DataThrottler; 92 import com.android.internal.telephony.dataconnection.DcTracker; 93 import com.android.internal.telephony.dataconnection.LinkBandwidthEstimator; 94 import com.android.internal.telephony.dataconnection.TransportManager; 95 import com.android.internal.telephony.emergency.EmergencyNumberTracker; 96 import com.android.internal.telephony.imsphone.ImsExternalCallTracker; 97 import com.android.internal.telephony.imsphone.ImsPhone; 98 import com.android.internal.telephony.imsphone.ImsPhoneCallTracker; 99 import com.android.internal.telephony.metrics.ImsStats; 100 import com.android.internal.telephony.metrics.MetricsCollector; 101 import com.android.internal.telephony.metrics.PersistAtomsStorage; 102 import com.android.internal.telephony.metrics.SmsStats; 103 import com.android.internal.telephony.metrics.VoiceCallSessionStats; 104 import com.android.internal.telephony.test.SimulatedCommands; 105 import com.android.internal.telephony.test.SimulatedCommandsVerifier; 106 import com.android.internal.telephony.uicc.IccCardStatus; 107 import com.android.internal.telephony.uicc.IccRecords; 108 import com.android.internal.telephony.uicc.IsimUiccRecords; 109 import com.android.internal.telephony.uicc.PinStorage; 110 import com.android.internal.telephony.uicc.RuimRecords; 111 import com.android.internal.telephony.uicc.SIMRecords; 112 import com.android.internal.telephony.uicc.UiccCard; 113 import com.android.internal.telephony.uicc.UiccCardApplication; 114 import com.android.internal.telephony.uicc.UiccController; 115 import com.android.internal.telephony.uicc.UiccProfile; 116 import com.android.internal.telephony.uicc.UiccSlot; 117 import com.android.server.pm.PackageManagerService; 118 import com.android.server.pm.permission.LegacyPermissionManagerService; 119 120 import org.mockito.Mock; 121 import org.mockito.Mockito; 122 import org.mockito.MockitoAnnotations; 123 import org.mockito.invocation.InvocationOnMock; 124 import org.mockito.stubbing.Answer; 125 126 import java.lang.reflect.Field; 127 import java.lang.reflect.InvocationTargetException; 128 import java.lang.reflect.Method; 129 import java.util.ArrayList; 130 import java.util.HashMap; 131 import java.util.HashSet; 132 import java.util.Iterator; 133 import java.util.LinkedList; 134 import java.util.List; 135 import java.util.Set; 136 import java.util.concurrent.CountDownLatch; 137 import java.util.concurrent.TimeUnit; 138 139 public abstract class TelephonyTest { 140 protected static String TAG; 141 142 private static final int MAX_INIT_WAIT_MS = 30000; // 30 seconds 143 144 private static final EmergencyNumber SAMPLE_EMERGENCY_NUMBER = 145 new EmergencyNumber("911", "us", "30", 146 EmergencyNumber.EMERGENCY_SERVICE_CATEGORY_UNSPECIFIED, 147 new ArrayList<String>(), EmergencyNumber.EMERGENCY_NUMBER_SOURCE_NETWORK_SIGNALING, 148 EmergencyNumber.EMERGENCY_CALL_ROUTING_NORMAL); 149 150 private static final Field MESSAGE_QUEUE_FIELD; 151 private static final Field MESSAGE_WHEN_FIELD; 152 private static final Field MESSAGE_NEXT_FIELD; 153 154 static { 155 try { 156 MESSAGE_QUEUE_FIELD = MessageQueue.class.getDeclaredField("mMessages"); 157 MESSAGE_QUEUE_FIELD.setAccessible(true); 158 MESSAGE_WHEN_FIELD = Message.class.getDeclaredField("when"); 159 MESSAGE_WHEN_FIELD.setAccessible(true); 160 MESSAGE_NEXT_FIELD = Message.class.getDeclaredField("next"); 161 MESSAGE_NEXT_FIELD.setAccessible(true); 162 } catch (NoSuchFieldException e) { 163 throw new RuntimeException("Failed to initialize TelephonyTest", e); 164 } 165 } 166 167 @Mock 168 protected GsmCdmaPhone mPhone; 169 @Mock 170 protected ImsPhone mImsPhone; 171 @Mock 172 protected ServiceStateTracker mSST; 173 @Mock 174 protected EmergencyNumberTracker mEmergencyNumberTracker; 175 @Mock 176 protected GsmCdmaCallTracker mCT; 177 @Mock 178 protected ImsPhoneCallTracker mImsCT; 179 @Mock 180 protected UiccController mUiccController; 181 @Mock 182 protected UiccProfile mUiccProfile; 183 @Mock 184 protected CallManager mCallManager; 185 @Mock 186 protected PhoneNotifier mNotifier; 187 @Mock 188 protected TelephonyComponentFactory mTelephonyComponentFactory; 189 @Mock 190 protected CdmaSubscriptionSourceManager mCdmaSSM; 191 @Mock 192 protected RegistrantList mRegistrantList; 193 @Mock 194 protected IccPhoneBookInterfaceManager mIccPhoneBookIntManager; 195 @Mock 196 protected ImsManager mImsManager; 197 @Mock 198 protected DcTracker mDcTracker; 199 @Mock 200 protected DisplayInfoController mDisplayInfoController; 201 @Mock 202 protected GsmCdmaCall mGsmCdmaCall; 203 @Mock 204 protected ImsCall mImsCall; 205 @Mock 206 protected ImsEcbm mImsEcbm; 207 @Mock 208 protected SubscriptionController mSubscriptionController; 209 @Mock 210 protected ServiceState mServiceState; 211 @Mock 212 protected PackageManagerService mMockPackageManager; 213 @Mock 214 protected LegacyPermissionManagerService mMockLegacyPermissionManager; 215 216 protected NetworkRegistrationInfo mNetworkRegistrationInfo = 217 new NetworkRegistrationInfo.Builder() 218 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE) 219 .setRegistrationState(NetworkRegistrationInfo.REGISTRATION_STATE_HOME) 220 .build(); 221 @Mock 222 protected SimulatedCommandsVerifier mSimulatedCommandsVerifier; 223 @Mock 224 protected InboundSmsHandler mInboundSmsHandler; 225 @Mock 226 protected WspTypeDecoder mWspTypeDecoder; 227 @Mock 228 protected UiccCardApplication mUiccCardApplication3gpp; 229 @Mock 230 protected UiccCardApplication mUiccCardApplication3gpp2; 231 @Mock 232 protected UiccCardApplication mUiccCardApplicationIms; 233 @Mock 234 protected SIMRecords mSimRecords; 235 @Mock 236 protected RuimRecords mRuimRecords; 237 @Mock 238 protected IsimUiccRecords mIsimUiccRecords; 239 @Mock 240 protected ProxyController mProxyController; 241 @Mock 242 protected Singleton<IActivityManager> mIActivityManagerSingleton; 243 @Mock 244 protected IActivityManager mIActivityManager; 245 @Mock 246 protected IIntentSender mIIntentSender; 247 @Mock 248 protected IBinder mIBinder; 249 @Mock 250 protected SmsStorageMonitor mSmsStorageMonitor; 251 @Mock 252 protected SmsUsageMonitor mSmsUsageMonitor; 253 @Mock 254 protected PackageInfo mPackageInfo; 255 @Mock 256 protected ApplicationInfo mApplicationInfo; 257 @Mock 258 protected EriManager mEriManager; 259 @Mock 260 protected IBinder mConnMetLoggerBinder; 261 @Mock 262 protected CarrierSignalAgent mCarrierSignalAgent; 263 @Mock 264 protected CarrierActionAgent mCarrierActionAgent; 265 @Mock 266 protected ImsExternalCallTracker mImsExternalCallTracker; 267 @Mock 268 protected AppSmsManager mAppSmsManager; 269 @Mock 270 protected IccSmsInterfaceManager mIccSmsInterfaceManager; 271 @Mock 272 protected SmsDispatchersController mSmsDispatchersController; 273 @Mock 274 protected DeviceStateMonitor mDeviceStateMonitor; 275 @Mock 276 protected TransportManager mTransportManager; 277 @Mock 278 protected IntentBroadcaster mIntentBroadcaster; 279 @Mock 280 protected NitzStateMachine mNitzStateMachine; 281 @Mock 282 protected RadioConfig mMockRadioConfig; 283 @Mock 284 protected SubscriptionInfoUpdater mSubInfoRecordUpdater; 285 @Mock 286 protected LocaleTracker mLocaleTracker; 287 @Mock 288 protected RestrictedState mRestrictedState; 289 @Mock 290 protected DataEnabledSettings mDataEnabledSettings; 291 @Mock 292 protected DataEnabledOverride mDataEnabledOverride; 293 @Mock 294 protected PhoneConfigurationManager mPhoneConfigurationManager; 295 @Mock 296 protected CellularNetworkValidator mCellularNetworkValidator; 297 @Mock 298 protected UiccCard mUiccCard; 299 @Mock 300 protected MultiSimSettingController mMultiSimSettingController; 301 @Mock 302 protected IccCard mIccCard; 303 @Mock 304 protected NetworkStatsManager mStatsManager; 305 @Mock 306 protected CarrierPrivilegesTracker mCarrierPrivilegesTracker; 307 @Mock 308 protected VoiceCallSessionStats mVoiceCallSessionStats; 309 @Mock 310 protected PersistAtomsStorage mPersistAtomsStorage; 311 @Mock 312 protected MetricsCollector mMetricsCollector; 313 @Mock 314 protected SmsStats mSmsStats; 315 @Mock 316 protected DataThrottler mDataThrottler; 317 @Mock 318 protected SignalStrength mSignalStrength; 319 @Mock 320 protected WifiManager mWifiManager; 321 @Mock 322 protected WifiInfo mWifiInfo; 323 @Mock 324 protected ImsStats mImsStats; 325 @Mock 326 protected LinkBandwidthEstimator mLinkBandwidthEstimator; 327 @Mock 328 protected PinStorage mPinStorage; 329 @Mock 330 protected LocationManager mLocationManager; 331 @Mock 332 protected CellIdentity mCellIdentity; 333 @Mock 334 protected CellLocation mCellLocation; 335 336 protected ActivityManager mActivityManager; 337 protected ImsCallProfile mImsCallProfile; 338 protected TelephonyManager mTelephonyManager; 339 protected TelephonyRegistryManager mTelephonyRegistryManager; 340 protected SubscriptionManager mSubscriptionManager; 341 protected EuiccManager mEuiccManager; 342 protected PackageManager mPackageManager; 343 protected ConnectivityManager mConnectivityManager; 344 protected AppOpsManager mAppOpsManager; 345 protected CarrierConfigManager mCarrierConfigManager; 346 protected UserManager mUserManager; 347 protected KeyguardManager mKeyguardManager; 348 protected VcnManager mVcnManager; 349 protected SimulatedCommands mSimulatedCommands; 350 protected ContextFixture mContextFixture; 351 protected Context mContext; 352 protected FakeBlockedNumberContentProvider mFakeBlockedNumberContentProvider; 353 private Object mLock = new Object(); 354 private boolean mReady; 355 protected HashMap<String, IBinder> mServiceManagerMockedServices = new HashMap<>(); 356 protected Phone[] mPhones; 357 protected List<TestableLooper> mTestableLoopers = new ArrayList<>(); 358 protected TestableLooper mTestableLooper; 359 360 private HashMap<InstanceKey, Object> mOldInstances = new HashMap<InstanceKey, Object>(); 361 362 private LinkedList<InstanceKey> mInstanceKeys = new LinkedList<InstanceKey>(); 363 364 private class InstanceKey { 365 public final Class mClass; 366 public final String mInstName; 367 public final Object mObj; InstanceKey(final Class c, final String instName, final Object obj)368 InstanceKey(final Class c, final String instName, final Object obj) { 369 mClass = c; 370 mInstName = instName; 371 mObj = obj; 372 } 373 374 @Override hashCode()375 public int hashCode() { 376 return (mClass.getName().hashCode() * 31 + mInstName.hashCode()) * 31; 377 } 378 379 @Override equals(Object obj)380 public boolean equals(Object obj) { 381 if (obj == null || obj.getClass() != getClass()) { 382 return false; 383 } 384 385 InstanceKey other = (InstanceKey) obj; 386 return (other.mClass == mClass && other.mInstName.equals(mInstName) 387 && other.mObj == mObj); 388 } 389 } 390 waitUntilReady()391 protected void waitUntilReady() { 392 synchronized (mLock) { 393 if (!mReady) { 394 try { 395 mLock.wait(MAX_INIT_WAIT_MS); 396 } catch (InterruptedException ie) { 397 } 398 399 if (!mReady) { 400 fail("Telephony tests failed to initialize"); 401 } 402 } 403 } 404 } 405 setReady(boolean ready)406 protected void setReady(boolean ready) { 407 synchronized (mLock) { 408 mReady = ready; 409 mLock.notifyAll(); 410 } 411 } 412 replaceInstance(final Class c, final String instanceName, final Object obj, final Object newValue)413 protected synchronized void replaceInstance(final Class c, final String instanceName, 414 final Object obj, final Object newValue) 415 throws Exception { 416 Field field = c.getDeclaredField(instanceName); 417 field.setAccessible(true); 418 419 InstanceKey key = new InstanceKey(c, instanceName, obj); 420 if (!mOldInstances.containsKey(key)) { 421 mOldInstances.put(key, field.get(obj)); 422 mInstanceKeys.add(key); 423 } 424 field.set(obj, newValue); 425 } 426 restoreInstance(final Class c, final String instanceName, final Object obj)427 protected synchronized void restoreInstance(final Class c, final String instanceName, 428 final Object obj) throws Exception { 429 InstanceKey key = new InstanceKey(c, instanceName, obj); 430 if (mOldInstances.containsKey(key)) { 431 Field field = c.getDeclaredField(instanceName); 432 field.setAccessible(true); 433 field.set(obj, mOldInstances.get(key)); 434 mOldInstances.remove(key); 435 mInstanceKeys.remove(key); 436 } 437 } 438 restoreInstances()439 protected synchronized void restoreInstances() throws Exception { 440 Iterator<InstanceKey> it = mInstanceKeys.descendingIterator(); 441 442 while (it.hasNext()) { 443 InstanceKey key = it.next(); 444 Field field = key.mClass.getDeclaredField(key.mInstName); 445 field.setAccessible(true); 446 field.set(key.mObj, mOldInstances.get(key)); 447 } 448 449 mInstanceKeys.clear(); 450 mOldInstances.clear(); 451 } 452 setUp(String tag)453 protected void setUp(String tag) throws Exception { 454 TAG = tag; 455 MockitoAnnotations.initMocks(this); 456 TelephonyManager.disableServiceHandleCaching(); 457 SubscriptionController.disableCaching(); 458 // For testing do not allow Log.WTF as it can cause test process to crash 459 Log.setWtfHandler((tagString, what, system) -> Log.d(TAG, "WTF captured, ignoring. Tag: " 460 + tagString + ", exception: " + what)); 461 462 mPhones = new Phone[] {mPhone}; 463 mImsCallProfile = new ImsCallProfile(); 464 mImsCallProfile.setCallerNumberVerificationStatus( 465 ImsCallProfile.VERIFICATION_STATUS_PASSED); 466 mSimulatedCommands = new SimulatedCommands(); 467 mContextFixture = new ContextFixture(); 468 mContext = mContextFixture.getTestDouble(); 469 mFakeBlockedNumberContentProvider = new FakeBlockedNumberContentProvider(); 470 ((MockContentResolver)mContext.getContentResolver()).addProvider( 471 BlockedNumberContract.AUTHORITY, mFakeBlockedNumberContentProvider); 472 mPhone.mCi = mSimulatedCommands; 473 mCT.mCi = mSimulatedCommands; 474 doReturn(mUiccCard).when(mPhone).getUiccCard(); 475 doReturn(mUiccProfile).when(mUiccCard).getUiccProfile(); 476 477 mTelephonyManager = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); 478 mActivityManager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE); 479 mTelephonyRegistryManager = (TelephonyRegistryManager) mContext.getSystemService( 480 Context.TELEPHONY_REGISTRY_SERVICE); 481 mSubscriptionManager = (SubscriptionManager) mContext.getSystemService( 482 Context.TELEPHONY_SUBSCRIPTION_SERVICE); 483 mEuiccManager = (EuiccManager) mContext.getSystemService(Context.EUICC_SERVICE); 484 mConnectivityManager = (ConnectivityManager) 485 mContext.getSystemService(Context.CONNECTIVITY_SERVICE); 486 mPackageManager = mContext.getPackageManager(); 487 mAppOpsManager = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE); 488 mCarrierConfigManager = 489 (CarrierConfigManager) mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE); 490 mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE); 491 mKeyguardManager = (KeyguardManager) mContext.getSystemService(Context.KEYGUARD_SERVICE); 492 mVcnManager = mContext.getSystemService(VcnManager.class); 493 mLocationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE); 494 495 //mTelephonyComponentFactory 496 doReturn(mTelephonyComponentFactory).when(mTelephonyComponentFactory).inject(anyString()); 497 doReturn(mSST).when(mTelephonyComponentFactory) 498 .makeServiceStateTracker(nullable(GsmCdmaPhone.class), 499 nullable(CommandsInterface.class)); 500 doReturn(mEmergencyNumberTracker).when(mTelephonyComponentFactory) 501 .makeEmergencyNumberTracker(nullable(Phone.class), 502 nullable(CommandsInterface.class)); 503 doReturn(getTestEmergencyNumber()).when(mEmergencyNumberTracker) 504 .getEmergencyNumber(any()); 505 doReturn(mUiccProfile).when(mTelephonyComponentFactory) 506 .makeUiccProfile(nullable(Context.class), nullable(CommandsInterface.class), 507 nullable(IccCardStatus.class), anyInt(), nullable(UiccCard.class), 508 nullable(Object.class)); 509 doReturn(mCT).when(mTelephonyComponentFactory) 510 .makeGsmCdmaCallTracker(nullable(GsmCdmaPhone.class)); 511 doReturn(mIccPhoneBookIntManager).when(mTelephonyComponentFactory) 512 .makeIccPhoneBookInterfaceManager(nullable(Phone.class)); 513 doReturn(mDcTracker).when(mTelephonyComponentFactory) 514 .makeDcTracker(nullable(Phone.class), anyInt()); 515 doReturn(mDisplayInfoController).when(mTelephonyComponentFactory) 516 .makeDisplayInfoController(nullable(Phone.class)); 517 doReturn(mWspTypeDecoder).when(mTelephonyComponentFactory) 518 .makeWspTypeDecoder(nullable(byte[].class)); 519 doReturn(mImsCT).when(mTelephonyComponentFactory) 520 .makeImsPhoneCallTracker(nullable(ImsPhone.class)); 521 doReturn(mCdmaSSM).when(mTelephonyComponentFactory) 522 .getCdmaSubscriptionSourceManagerInstance(nullable(Context.class), 523 nullable(CommandsInterface.class), nullable(Handler.class), 524 anyInt(), nullable(Object.class)); 525 doReturn(mImsExternalCallTracker).when(mTelephonyComponentFactory) 526 .makeImsExternalCallTracker(nullable(ImsPhone.class)); 527 doReturn(mAppSmsManager).when(mTelephonyComponentFactory) 528 .makeAppSmsManager(nullable(Context.class)); 529 doReturn(mCarrierSignalAgent).when(mTelephonyComponentFactory) 530 .makeCarrierSignalAgent(nullable(Phone.class)); 531 doReturn(mCarrierActionAgent).when(mTelephonyComponentFactory) 532 .makeCarrierActionAgent(nullable(Phone.class)); 533 doReturn(mDeviceStateMonitor).when(mTelephonyComponentFactory) 534 .makeDeviceStateMonitor(nullable(Phone.class)); 535 doReturn(mTransportManager).when(mTelephonyComponentFactory) 536 .makeTransportManager(nullable(Phone.class)); 537 doReturn(mNitzStateMachine).when(mTelephonyComponentFactory) 538 .makeNitzStateMachine(nullable(GsmCdmaPhone.class)); 539 doReturn(mLocaleTracker).when(mTelephonyComponentFactory) 540 .makeLocaleTracker(nullable(Phone.class), nullable(NitzStateMachine.class), 541 nullable(Looper.class)); 542 doReturn(mDataEnabledSettings).when(mTelephonyComponentFactory) 543 .makeDataEnabledSettings(nullable(Phone.class)); 544 doReturn(mEriManager).when(mTelephonyComponentFactory) 545 .makeEriManager(nullable(Phone.class), anyInt()); 546 doReturn(mLinkBandwidthEstimator).when(mTelephonyComponentFactory) 547 .makeLinkBandwidthEstimator(nullable(Phone.class)); 548 549 //mPhone 550 doReturn(mContext).when(mPhone).getContext(); 551 doReturn(mContext).when(mImsPhone).getContext(); 552 doReturn(true).when(mPhone).getUnitTestMode(); 553 doReturn(mUiccProfile).when(mPhone).getIccCard(); 554 doReturn(mServiceState).when(mPhone).getServiceState(); 555 doReturn(mServiceState).when(mImsPhone).getServiceState(); 556 doReturn(mPhone).when(mImsPhone).getDefaultPhone(); 557 doReturn(true).when(mPhone).isPhoneTypeGsm(); 558 doReturn(PhoneConstants.PHONE_TYPE_GSM).when(mPhone).getPhoneType(); 559 doReturn(mCT).when(mPhone).getCallTracker(); 560 doReturn(mSST).when(mPhone).getServiceStateTracker(); 561 doReturn(mDeviceStateMonitor).when(mPhone).getDeviceStateMonitor(); 562 doReturn(mDisplayInfoController).when(mPhone).getDisplayInfoController(); 563 doReturn(mEmergencyNumberTracker).when(mPhone).getEmergencyNumberTracker(); 564 doReturn(mCarrierSignalAgent).when(mPhone).getCarrierSignalAgent(); 565 doReturn(mCarrierActionAgent).when(mPhone).getCarrierActionAgent(); 566 doReturn(mAppSmsManager).when(mPhone).getAppSmsManager(); 567 doReturn(mIccSmsInterfaceManager).when(mPhone).getIccSmsInterfaceManager(); 568 doReturn(mTransportManager).when(mPhone).getTransportManager(); 569 doReturn(mDataEnabledSettings).when(mPhone).getDataEnabledSettings(); 570 doReturn(mDcTracker).when(mPhone).getDcTracker(anyInt()); 571 doReturn(mCarrierPrivilegesTracker).when(mPhone).getCarrierPrivilegesTracker(); 572 doReturn(mSignalStrength).when(mPhone).getSignalStrength(); 573 doReturn(mVoiceCallSessionStats).when(mPhone).getVoiceCallSessionStats(); 574 doReturn(mVoiceCallSessionStats).when(mImsPhone).getVoiceCallSessionStats(); 575 doReturn(mSmsStats).when(mPhone).getSmsStats(); 576 doReturn(mImsStats).when(mImsPhone).getImsStats(); 577 mIccSmsInterfaceManager.mDispatchersController = mSmsDispatchersController; 578 doReturn(mLinkBandwidthEstimator).when(mPhone).getLinkBandwidthEstimator(); 579 doReturn(mCellIdentity).when(mPhone).getCurrentCellIdentity(); 580 doReturn(mCellLocation).when(mCellIdentity).asCellLocation(); 581 582 //mUiccController 583 doReturn(mUiccCardApplication3gpp).when(mUiccController).getUiccCardApplication(anyInt(), 584 eq(UiccController.APP_FAM_3GPP)); 585 doReturn(mUiccCardApplication3gpp2).when(mUiccController).getUiccCardApplication(anyInt(), 586 eq(UiccController.APP_FAM_3GPP2)); 587 doReturn(mUiccCardApplicationIms).when(mUiccController).getUiccCardApplication(anyInt(), 588 eq(UiccController.APP_FAM_IMS)); 589 doReturn(mUiccCard).when(mUiccController).getUiccCard(anyInt()); 590 591 doAnswer(new Answer<IccRecords>() { 592 public IccRecords answer(InvocationOnMock invocation) { 593 switch ((Integer) invocation.getArguments()[1]) { 594 case UiccController.APP_FAM_3GPP: 595 return mSimRecords; 596 case UiccController.APP_FAM_3GPP2: 597 return mRuimRecords; 598 case UiccController.APP_FAM_IMS: 599 return mIsimUiccRecords; 600 default: 601 logd("Unrecognized family " + invocation.getArguments()[1]); 602 return null; 603 } 604 } 605 }).when(mUiccController).getIccRecords(anyInt(), anyInt()); 606 doReturn(new UiccSlot[] {}).when(mUiccController).getUiccSlots(); 607 doReturn(mPinStorage).when(mUiccController).getPinStorage(); 608 609 //UiccCardApplication 610 doReturn(mSimRecords).when(mUiccCardApplication3gpp).getIccRecords(); 611 doReturn(mRuimRecords).when(mUiccCardApplication3gpp2).getIccRecords(); 612 doReturn(mIsimUiccRecords).when(mUiccCardApplicationIms).getIccRecords(); 613 614 //mUiccProfile 615 doReturn(mSimRecords).when(mUiccProfile).getIccRecords(); 616 doAnswer(new Answer<IccRecords>() { 617 public IccRecords answer(InvocationOnMock invocation) { 618 return (mPhone.isPhoneTypeGsm()) ? mSimRecords : mRuimRecords; 619 } 620 }).when(mUiccProfile).getIccRecords(); 621 622 //mUiccProfile 623 doReturn(mUiccCardApplication3gpp).when(mUiccProfile).getApplication( 624 eq(UiccController.APP_FAM_3GPP)); 625 doReturn(mUiccCardApplication3gpp2).when(mUiccProfile).getApplication( 626 eq(UiccController.APP_FAM_3GPP2)); 627 doReturn(mUiccCardApplicationIms).when(mUiccProfile).getApplication( 628 eq(UiccController.APP_FAM_IMS)); 629 630 //SMS 631 doReturn(true).when(mSmsStorageMonitor).isStorageAvailable(); 632 doReturn(true).when(mSmsUsageMonitor).check(nullable(String.class), anyInt()); 633 doReturn(true).when(mTelephonyManager).getSmsReceiveCapableForPhone(anyInt(), anyBoolean()); 634 doReturn(true).when(mTelephonyManager).getSmsSendCapableForPhone( 635 anyInt(), anyBoolean()); 636 637 //Misc 638 doReturn(ServiceState.RIL_RADIO_TECHNOLOGY_UMTS).when(mServiceState). 639 getRilDataRadioTechnology(); 640 doReturn(mPhone).when(mCT).getPhone(); 641 doReturn(mImsEcbm).when(mImsManager).getEcbmInterface(); 642 doReturn(mPhone).when(mInboundSmsHandler).getPhone(); 643 doReturn(mImsCallProfile).when(mImsCall).getCallProfile(); 644 doReturn(mIBinder).when(mIIntentSender).asBinder(); 645 doReturn(mIIntentSender).when(mIActivityManager).getIntentSenderWithFeature(anyInt(), 646 nullable(String.class), nullable(String.class), nullable(IBinder.class), 647 nullable(String.class), anyInt(), nullable(Intent[].class), 648 nullable(String[].class), anyInt(), nullable(Bundle.class), anyInt()); 649 doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(anyInt()); 650 doReturn(true).when(mTelephonyManager).isDataCapable(); 651 652 doReturn(TelephonyManager.PHONE_TYPE_GSM).when(mTelephonyManager).getPhoneType(); 653 doReturn(mServiceState).when(mSST).getServiceState(); 654 mSST.mSS = mServiceState; 655 mSST.mRestrictedState = mRestrictedState; 656 mServiceManagerMockedServices.put("connectivity_metrics_logger", mConnMetLoggerBinder); 657 mServiceManagerMockedServices.put("package", mMockPackageManager); 658 mServiceManagerMockedServices.put("legacy_permission", mMockLegacyPermissionManager); 659 logd("mMockLegacyPermissionManager replaced"); 660 doReturn(new int[]{AccessNetworkConstants.TRANSPORT_TYPE_WWAN, 661 AccessNetworkConstants.TRANSPORT_TYPE_WLAN}) 662 .when(mTransportManager).getAvailableTransports(); 663 doReturn(AccessNetworkConstants.TRANSPORT_TYPE_WWAN).when(mTransportManager) 664 .getCurrentTransport(anyInt()); 665 doReturn(true).when(mDataEnabledSettings).isDataEnabled(); 666 doReturn(true).when(mDataEnabledSettings).isDataEnabled(anyInt()); 667 doReturn(true).when(mDataEnabledSettings).isInternalDataEnabled(); 668 doReturn(mNetworkRegistrationInfo).when(mServiceState).getNetworkRegistrationInfo( 669 anyInt(), anyInt()); 670 doReturn(new HalVersion(1, 4)).when(mPhone).getHalVersion(); 671 doReturn(2).when(mSignalStrength).getLevel(); 672 673 // WiFi 674 doReturn(mWifiInfo).when(mWifiManager).getConnectionInfo(); 675 doReturn(2).when(mWifiManager).calculateSignalLevel(anyInt()); 676 doReturn(4).when(mWifiManager).getMaxSignalLevel(); 677 678 doAnswer(invocation -> { 679 NetworkCapabilities nc = invocation.getArgument(0); 680 return new VcnNetworkPolicyResult( 681 false /* isTearDownRequested */, nc); 682 }).when(mVcnManager).applyVcnNetworkPolicy(any(), any()); 683 684 //SIM 685 doReturn(1).when(mTelephonyManager).getSimCount(); 686 doReturn(1).when(mTelephonyManager).getPhoneCount(); 687 doReturn(1).when(mTelephonyManager).getActiveModemCount(); 688 // Have getMaxPhoneCount always return the same value with getPhoneCount by default. 689 doAnswer((invocation)->Math.max(mTelephonyManager.getActiveModemCount(), 690 mTelephonyManager.getPhoneCount())) 691 .when(mTelephonyManager).getSupportedModemCount(); 692 doReturn(mStatsManager).when(mContext).getSystemService(eq(Context.NETWORK_STATS_SERVICE)); 693 694 //Data 695 //Initial state is: userData enabled, provisioned. 696 ContentResolver resolver = mContext.getContentResolver(); 697 Settings.Global.putInt(resolver, Settings.Global.MOBILE_DATA, 1); 698 Settings.Global.putInt(resolver, Settings.Global.DEVICE_PROVISIONED, 1); 699 Settings.Global.putInt(resolver, 700 Settings.Global.DEVICE_PROVISIONING_MOBILE_DATA_ENABLED, 1); 701 doReturn(mDataThrottler).when(mDcTracker).getDataThrottler(); 702 doReturn(-1L).when(mDataThrottler).getRetryTime(anyInt()); 703 704 // CellularNetworkValidator 705 doReturn(SubscriptionManager.INVALID_PHONE_INDEX) 706 .when(mCellularNetworkValidator).getSubIdInValidation(); 707 doReturn(true).when(mCellularNetworkValidator).isValidationFeatureSupported(); 708 709 // Metrics 710 doReturn(null).when(mContext).getFileStreamPath(anyString()); 711 doReturn(mPersistAtomsStorage).when(mMetricsCollector).getAtomsStorage(); 712 doReturn(mWifiManager).when(mContext).getSystemService(eq(Context.WIFI_SERVICE)); 713 714 //Use reflection to mock singletons 715 replaceInstance(CallManager.class, "INSTANCE", null, mCallManager); 716 replaceInstance(TelephonyComponentFactory.class, "sInstance", null, 717 mTelephonyComponentFactory); 718 replaceInstance(UiccController.class, "mInstance", null, mUiccController); 719 replaceInstance(CdmaSubscriptionSourceManager.class, "sInstance", null, mCdmaSSM); 720 replaceInstance(SubscriptionController.class, "sInstance", null, mSubscriptionController); 721 replaceInstance(ProxyController.class, "sProxyController", null, mProxyController); 722 replaceInstance(ActivityManager.class, "IActivityManagerSingleton", null, 723 mIActivityManagerSingleton); 724 replaceInstance(CdmaSubscriptionSourceManager.class, 725 "mCdmaSubscriptionSourceChangedRegistrants", mCdmaSSM, mRegistrantList); 726 replaceInstance(SimulatedCommandsVerifier.class, "sInstance", null, 727 mSimulatedCommandsVerifier); 728 replaceInstance(Singleton.class, "mInstance", mIActivityManagerSingleton, 729 mIActivityManager); 730 replaceInstance(ServiceManager.class, "sCache", null, mServiceManagerMockedServices); 731 replaceInstance(IntentBroadcaster.class, "sIntentBroadcaster", null, mIntentBroadcaster); 732 replaceInstance(TelephonyManager.class, "sInstance", null, 733 mContext.getSystemService(Context.TELEPHONY_SERVICE)); 734 replaceInstance(TelephonyManager.class, "sServiceHandleCacheEnabled", null, false); 735 replaceInstance(PhoneFactory.class, "sMadeDefaults", null, true); 736 replaceInstance(PhoneFactory.class, "sPhone", null, mPhone); 737 replaceInstance(PhoneFactory.class, "sPhones", null, mPhones); 738 replaceInstance(PhoneFactory.class, "sSubInfoRecordUpdater", null, mSubInfoRecordUpdater); 739 replaceInstance(RadioConfig.class, "sRadioConfig", null, mMockRadioConfig); 740 replaceInstance(PhoneConfigurationManager.class, "sInstance", null, 741 mPhoneConfigurationManager); 742 replaceInstance(CellularNetworkValidator.class, "sInstance", null, 743 mCellularNetworkValidator); 744 replaceInstance(MultiSimSettingController.class, "sInstance", null, 745 mMultiSimSettingController); 746 replaceInstance(SubscriptionInfoUpdater.class, "sIsSubInfoInitialized", null, true); 747 replaceInstance(PhoneFactory.class, "sCommandsInterfaces", null, 748 new CommandsInterface[] {mSimulatedCommands}); 749 replaceInstance(PhoneFactory.class, "sMetricsCollector", null, mMetricsCollector); 750 751 assertNotNull("Failed to set up SubscriptionController singleton", 752 SubscriptionController.getInstance()); 753 setReady(false); 754 // create default TestableLooper for test and add to list of monitored loopers 755 mTestableLooper = TestableLooper.get(TelephonyTest.this); 756 if (mTestableLooper != null) { 757 monitorTestableLooper(mTestableLooper); 758 } 759 } 760 tearDown()761 protected void tearDown() throws Exception { 762 // Ensure there are no references to handlers between tests. 763 PhoneConfigurationManager.unregisterAllMultiSimConfigChangeRegistrants(); 764 // unmonitor TestableLooper for TelephonyTest class 765 if (mTestableLooper != null) { 766 unmonitorTestableLooper(mTestableLooper); 767 } 768 // destroy all newly created TestableLoopers so they can be reused 769 for (TestableLooper looper : mTestableLoopers) { 770 looper.destroy(); 771 } 772 TestableLooper.remove(TelephonyTest.this); 773 774 mSimulatedCommands.dispose(); 775 SharedPreferences sharedPreferences = mContext.getSharedPreferences((String) null, 0); 776 sharedPreferences.edit().clear().commit(); 777 778 restoreInstances(); 779 TelephonyManager.enableServiceHandleCaching(); 780 SubscriptionController.enableCaching(); 781 } 782 logd(String s)783 protected static void logd(String s) { 784 Log.d(TAG, s); 785 } 786 787 public static class FakeBlockedNumberContentProvider extends MockContentProvider { 788 public Set<String> mBlockedNumbers = new HashSet<>(); 789 public int mNumEmergencyContactNotifications = 0; 790 791 @Override call(String method, String arg, Bundle extras)792 public Bundle call(String method, String arg, Bundle extras) { 793 switch (method) { 794 case BlockedNumberContract.SystemContract.METHOD_SHOULD_SYSTEM_BLOCK_NUMBER: 795 Bundle bundle = new Bundle(); 796 int blockStatus = mBlockedNumbers.contains(arg) 797 ? BlockedNumberContract.STATUS_BLOCKED_IN_LIST 798 : BlockedNumberContract.STATUS_NOT_BLOCKED; 799 bundle.putInt(BlockedNumberContract.RES_BLOCK_STATUS, blockStatus); 800 return bundle; 801 case BlockedNumberContract.SystemContract.METHOD_NOTIFY_EMERGENCY_CONTACT: 802 mNumEmergencyContactNotifications++; 803 return new Bundle(); 804 default: 805 fail("Method not expected: " + method); 806 } 807 return null; 808 } 809 } 810 811 public static class FakeSettingsConfigProvider extends MockContentProvider { 812 private static final String PROPERTY_DEVICE_IDENTIFIER_ACCESS_RESTRICTIONS_DISABLED = 813 DeviceConfig.NAMESPACE_PRIVACY + "/" 814 + "device_identifier_access_restrictions_disabled"; 815 816 @Override call(String method, String arg, Bundle extras)817 public Bundle call(String method, String arg, Bundle extras) { 818 switch (method) { 819 case Settings.CALL_METHOD_GET_CONFIG: { 820 switch (arg) { 821 case PROPERTY_DEVICE_IDENTIFIER_ACCESS_RESTRICTIONS_DISABLED: { 822 Bundle bundle = new Bundle(); 823 bundle.putString( 824 PROPERTY_DEVICE_IDENTIFIER_ACCESS_RESTRICTIONS_DISABLED, 825 "0"); 826 return bundle; 827 } 828 default: { 829 fail("arg not expected: " + arg); 830 } 831 } 832 break; 833 } 834 default: 835 fail("Method not expected: " + method); 836 } 837 return null; 838 } 839 } 840 setupMockPackagePermissionChecks()841 protected void setupMockPackagePermissionChecks() throws Exception { 842 doReturn(new String[]{TAG}).when(mPackageManager).getPackagesForUid(anyInt()); 843 doReturn(mPackageInfo).when(mPackageManager).getPackageInfo(eq(TAG), anyInt()); 844 } 845 setupMocksForTelephonyPermissions()846 protected void setupMocksForTelephonyPermissions() throws Exception { 847 setupMocksForTelephonyPermissions(Build.VERSION_CODES.Q); 848 } 849 setupMocksForTelephonyPermissions(int targetSdkVersion)850 protected void setupMocksForTelephonyPermissions(int targetSdkVersion) 851 throws Exception { 852 // If the calling package does not meet the new requirements for device identifier access 853 // TelephonyPermissions will query the PackageManager for the ApplicationInfo of the package 854 // to determine the target SDK. For apps targeting Q a SecurityException is thrown 855 // regardless of if the package satisfies the previous requirements for device ID access. 856 857 // Any tests that query for SubscriptionInfo objects will trigger a phone number access 858 // check that will first query the ApplicationInfo as apps targeting R+ can no longer 859 // access the phone number with the READ_PHONE_STATE permission and instead must meet one of 860 // the other requirements. This ApplicationInfo is generalized to any package name since 861 // some tests will simulate invocation from other packages. 862 mApplicationInfo.targetSdkVersion = targetSdkVersion; 863 doReturn(mApplicationInfo).when(mPackageManager).getApplicationInfoAsUser(anyString(), 864 anyInt(), any()); 865 866 // TelephonyPermissions uses a SystemAPI to check if the calling package meets any of the 867 // generic requirements for device identifier access (currently READ_PRIVILEGED_PHONE_STATE, 868 // appop, and device / profile owner checks). This sets up the PermissionManager to return 869 // that access requirements are met. 870 setIdentifierAccess(true); 871 LegacyPermissionManager legacyPermissionManager = 872 new LegacyPermissionManager(mMockLegacyPermissionManager); 873 doReturn(legacyPermissionManager).when(mContext) 874 .getSystemService(Context.LEGACY_PERMISSION_SERVICE); 875 // Also make sure all appop checks fails, to not interfere tests. Tests should explicitly 876 // mock AppOpManager to return allowed/default mode. Note by default a mock returns 0 which 877 // is MODE_ALLOWED, hence this setup is necessary. 878 doReturn(AppOpsManager.MODE_IGNORED).when(mAppOpsManager).noteOpNoThrow( 879 /* op= */ anyString(), /* uid= */ anyInt(), 880 /* packageName= */ nullable(String.class), 881 /* attributionTag= */ nullable(String.class), 882 /* message= */ nullable(String.class)); 883 884 // TelephonyPermissions queries DeviceConfig to determine if the identifier access 885 // restrictions should be enabled; this results in a NPE when DeviceConfig uses 886 // Activity.currentActivity.getContentResolver as the resolver for Settings.Config.getString 887 // since the IContentProvider in the NameValueCache's provider holder is null. 888 Class c = Class.forName("android.provider.Settings$Config"); 889 Field field = c.getDeclaredField("sNameValueCache"); 890 field.setAccessible(true); 891 Object cache = field.get(null); 892 893 c = Class.forName("android.provider.Settings$NameValueCache"); 894 field = c.getDeclaredField("mProviderHolder"); 895 field.setAccessible(true); 896 Object providerHolder = field.get(cache); 897 898 FakeSettingsConfigProvider fakeSettingsProvider = new FakeSettingsConfigProvider(); 899 field = MockContentProvider.class.getDeclaredField("mIContentProvider"); 900 field.setAccessible(true); 901 Object iContentProvider = field.get(fakeSettingsProvider); 902 903 replaceInstance(Class.forName("android.provider.Settings$ContentProviderHolder"), 904 "mContentProvider", providerHolder, iContentProvider); 905 } 906 setIdentifierAccess(boolean hasAccess)907 protected void setIdentifierAccess(boolean hasAccess) { 908 doReturn(hasAccess ? PackageManager.PERMISSION_GRANTED 909 : PackageManager.PERMISSION_DENIED).when(mMockLegacyPermissionManager) 910 .checkDeviceIdentifierAccess(any(), any(), any(), anyInt(), anyInt()); 911 } 912 setPhoneNumberAccess(int value)913 protected void setPhoneNumberAccess(int value) { 914 doReturn(value).when(mMockLegacyPermissionManager).checkPhoneNumberAccess(any(), any(), 915 any(), anyInt(), anyInt()); 916 } 917 setCarrierPrivileges(boolean hasCarrierPrivileges)918 protected void setCarrierPrivileges(boolean hasCarrierPrivileges) { 919 doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(anyInt()); 920 doReturn(hasCarrierPrivileges ? TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS 921 : TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS).when( 922 mTelephonyManager).getCarrierPrivilegeStatus(anyInt()); 923 } 924 setCarrierPrivilegesForSubId(boolean hasCarrierPrivileges, int subId)925 protected void setCarrierPrivilegesForSubId(boolean hasCarrierPrivileges, int subId) { 926 TelephonyManager mockTelephonyManager = Mockito.mock(TelephonyManager.class); 927 doReturn(mockTelephonyManager).when(mTelephonyManager).createForSubscriptionId(subId); 928 doReturn(hasCarrierPrivileges ? TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS 929 : TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS).when( 930 mockTelephonyManager).getCarrierPrivilegeStatus(anyInt()); 931 } 932 waitForDelayedHandlerAction(Handler h, long delayMillis, long timeoutMillis)933 protected final void waitForDelayedHandlerAction(Handler h, long delayMillis, 934 long timeoutMillis) { 935 final CountDownLatch lock = new CountDownLatch(1); 936 h.postDelayed(lock::countDown, delayMillis); 937 while (lock.getCount() > 0) { 938 try { 939 lock.await(delayMillis + timeoutMillis, TimeUnit.MILLISECONDS); 940 } catch (InterruptedException e) { 941 // do nothing 942 } 943 } 944 } 945 waitForHandlerAction(Handler h, long timeoutMillis)946 protected final void waitForHandlerAction(Handler h, long timeoutMillis) { 947 final CountDownLatch lock = new CountDownLatch(1); 948 h.post(lock::countDown); 949 while (lock.getCount() > 0) { 950 try { 951 lock.await(timeoutMillis, TimeUnit.MILLISECONDS); 952 } catch (InterruptedException e) { 953 // do nothing 954 } 955 } 956 } 957 958 /** 959 * Wait for up to 1 second for the handler message queue to clear. 960 */ waitForLastHandlerAction(Handler h)961 protected final void waitForLastHandlerAction(Handler h) { 962 CountDownLatch lock = new CountDownLatch(1); 963 // Allow the handler to start work on stuff. 964 h.postDelayed(lock::countDown, 100); 965 int timeoutCount = 0; 966 while (timeoutCount < 5) { 967 try { 968 if (lock.await(200, TimeUnit.MILLISECONDS)) { 969 // no messages in queue, stop waiting. 970 if (!h.hasMessagesOrCallbacks()) break; 971 lock = new CountDownLatch(1); 972 // Delay to allow the handler thread to start work on stuff. 973 h.postDelayed(lock::countDown, 100); 974 } 975 976 } catch (InterruptedException e) { 977 // do nothing 978 } 979 timeoutCount++; 980 } 981 assertTrue("Handler was not empty before timeout elapsed", timeoutCount < 5); 982 } 983 getTestEmergencyNumber()984 protected final EmergencyNumber getTestEmergencyNumber() { 985 return SAMPLE_EMERGENCY_NUMBER; 986 } 987 invokeMethod( Object instance, String methodName, Class<?>[] parameterClasses, Object[] parameters)988 public static Object invokeMethod( 989 Object instance, String methodName, Class<?>[] parameterClasses, Object[] parameters) { 990 try { 991 Method method = instance.getClass().getDeclaredMethod(methodName, parameterClasses); 992 method.setAccessible(true); 993 return method.invoke(instance, parameters); 994 } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { 995 fail(instance.getClass() + " " + methodName + " " + e.getClass().getName()); 996 } 997 return null; 998 } 999 1000 /** 1001 * Add a TestableLooper to the list of monitored loopers 1002 * @param looper added if it doesn't already exist 1003 */ monitorTestableLooper(TestableLooper looper)1004 public void monitorTestableLooper(TestableLooper looper) { 1005 if (!mTestableLoopers.contains(looper)) { 1006 mTestableLoopers.add(looper); 1007 } 1008 } 1009 1010 /** 1011 * Remove a TestableLooper from the list of monitored loopers 1012 * @param looper removed if it does exist 1013 */ unmonitorTestableLooper(TestableLooper looper)1014 public void unmonitorTestableLooper(TestableLooper looper) { 1015 if (mTestableLoopers.contains(looper)) { 1016 mTestableLoopers.remove(looper); 1017 } 1018 } 1019 1020 /** 1021 * Handle all messages that can be processed at the current time 1022 * for all monitored TestableLoopers 1023 */ processAllMessages()1024 public void processAllMessages() { 1025 if (mTestableLoopers.isEmpty()) { 1026 fail("mTestableLoopers is empty. Please make sure to add @RunWithLooper annotation"); 1027 } 1028 while (!areAllTestableLoopersIdle()) { 1029 for (TestableLooper looper : mTestableLoopers) looper.processAllMessages(); 1030 } 1031 } 1032 1033 /** 1034 * Check if there are any messages to be processed in any monitored TestableLooper 1035 * Delayed messages to be handled at a later time will be ignored 1036 * @return true if there are no messages that can be handled at the current time 1037 * across all monitored TestableLoopers 1038 */ areAllTestableLoopersIdle()1039 private boolean areAllTestableLoopersIdle() { 1040 for (TestableLooper looper : mTestableLoopers) { 1041 if (!looper.getLooper().getQueue().isIdle()) return false; 1042 } 1043 return true; 1044 } 1045 1046 /** 1047 * Effectively moves time forward by reducing the time of all messages 1048 * for all monitored TestableLoopers 1049 * @param milliSeconds number of milliseconds to move time forward by 1050 */ moveTimeForward(long milliSeconds)1051 public void moveTimeForward(long milliSeconds) { 1052 for (TestableLooper looper : mTestableLoopers) { 1053 MessageQueue queue = looper.getLooper().getQueue(); 1054 try { 1055 Message msg = (Message) MESSAGE_QUEUE_FIELD.get(queue); 1056 while (msg != null) { 1057 long updatedWhen = msg.getWhen() - milliSeconds; 1058 if (updatedWhen < 0) { 1059 updatedWhen = 0; 1060 } 1061 MESSAGE_WHEN_FIELD.set(msg, updatedWhen); 1062 msg = (Message) MESSAGE_NEXT_FIELD.get(msg); 1063 } 1064 } catch (IllegalAccessException e) { 1065 throw new RuntimeException("Access failed in TelephonyTest", e); 1066 } 1067 } 1068 } 1069 } 1070