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 17package com.android.internal.telephony; 18 19import android.app.IAlarmManager; 20import android.content.Context; 21import android.content.Intent; 22import android.os.AsyncResult; 23import android.os.Bundle; 24import android.os.Handler; 25import android.os.HandlerThread; 26import android.os.IBinder; 27import android.os.Message; 28import android.os.Parcel; 29import android.os.SystemClock; 30import android.os.UserHandle; 31import android.platform.test.annotations.Postsubmit; 32import android.telephony.CellInfo; 33import android.telephony.CellInfoGsm; 34import android.telephony.ServiceState; 35import android.telephony.SignalStrength; 36import android.telephony.SubscriptionManager; 37import android.telephony.gsm.GsmCellLocation; 38import android.test.suitebuilder.annotation.MediumTest; 39import android.test.suitebuilder.annotation.SmallTest; 40import android.util.Pair; 41 42import com.android.internal.telephony.cdma.CdmaSubscriptionSourceManager; 43import com.android.internal.telephony.dataconnection.DcTracker; 44import com.android.internal.telephony.test.SimulatedCommands; 45import com.android.internal.telephony.uicc.IccCardApplicationStatus; 46 47import org.junit.After; 48import org.junit.Before; 49import org.junit.Test; 50import org.mockito.ArgumentCaptor; 51import org.mockito.Mock; 52 53import java.util.ArrayList; 54 55import static com.android.internal.telephony.TelephonyTestUtils.waitForMs; 56import static org.junit.Assert.assertEquals; 57import static org.junit.Assert.assertFalse; 58import static org.junit.Assert.assertTrue; 59import static org.mockito.Matchers.any; 60import static org.mockito.Matchers.anyLong; 61import static org.mockito.Matchers.anyString; 62import static org.mockito.Mockito.anyInt; 63import static org.mockito.Mockito.atLeast; 64import static org.mockito.Mockito.doReturn; 65import static org.mockito.Mockito.eq; 66import static org.mockito.Mockito.times; 67import static org.mockito.Mockito.verify; 68 69public class ServiceStateTrackerTest extends TelephonyTest { 70 71 @Mock 72 private DcTracker mDct; 73 @Mock 74 private ProxyController mProxyController; 75 @Mock 76 private Handler mTestHandler; 77 @Mock 78 protected IAlarmManager mAlarmManager; 79 80 private ServiceStateTracker sst; 81 private ServiceStateTrackerTestHandler mSSTTestHandler; 82 83 private static final int EVENT_REGISTERED_TO_NETWORK = 1; 84 private static final int EVENT_SUBSCRIPTION_INFO_READY = 2; 85 private static final int EVENT_ROAMING_ON = 3; 86 private static final int EVENT_ROAMING_OFF = 4; 87 private static final int EVENT_DATA_CONNECTION_ATTACHED = 5; 88 private static final int EVENT_DATA_CONNECTION_DETACHED = 6; 89 private static final int EVENT_DATA_RAT_CHANGED = 7; 90 private static final int EVENT_PS_RESTRICT_ENABLED = 8; 91 private static final int EVENT_PS_RESTRICT_DISABLED = 9; 92 93 private class ServiceStateTrackerTestHandler extends HandlerThread { 94 95 private ServiceStateTrackerTestHandler(String name) { 96 super(name); 97 } 98 99 @Override 100 public void onLooperPrepared() { 101 sst = new ServiceStateTracker(mPhone, mSimulatedCommands); 102 setReady(true); 103 } 104 } 105 106 @Before 107 public void setUp() throws Exception { 108 109 logd("ServiceStateTrackerTest +Setup!"); 110 super.setUp("ServiceStateTrackerTest"); 111 112 doReturn(true).when(mDct).isDisconnected(); 113 mPhone.mDcTracker = mDct; 114 115 replaceInstance(ProxyController.class, "sProxyController", null, mProxyController); 116 117 mContextFixture.putStringArrayResource( 118 com.android.internal.R.array.config_sameNamedOperatorConsideredRoaming, 119 new String[]{"123456"}); 120 121 mContextFixture.putStringArrayResource( 122 com.android.internal.R.array.config_operatorConsideredNonRoaming, 123 new String[]{"123456"}); 124 125 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME); 126 mSimulatedCommands.setVoiceRadioTech(ServiceState.RIL_RADIO_TECHNOLOGY_HSPA); 127 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME); 128 mSimulatedCommands.setDataRadioTech(ServiceState.RIL_RADIO_TECHNOLOGY_HSPA); 129 130 int dds = SubscriptionManager.getDefaultDataSubscriptionId(); 131 doReturn(dds).when(mPhone).getSubId(); 132 133 mSSTTestHandler = new ServiceStateTrackerTestHandler(getClass().getSimpleName()); 134 mSSTTestHandler.start(); 135 waitUntilReady(); 136 waitForMs(600); 137 logd("ServiceStateTrackerTest -Setup!"); 138 } 139 140 @After 141 public void tearDown() throws Exception { 142 sst = null; 143 mSSTTestHandler.quitSafely(); 144 super.tearDown(); 145 } 146 147 @Test 148 @MediumTest 149 public void testSetRadioPower() { 150 boolean oldState = mSimulatedCommands.getRadioState().isOn(); 151 sst.setRadioPower(!oldState); 152 waitForMs(100); 153 assertTrue(oldState != mSimulatedCommands.getRadioState().isOn()); 154 } 155 156 @Test 157 @MediumTest 158 public void testSetRadioPowerFromCarrier() { 159 // Carrier disable radio power 160 sst.setRadioPowerFromCarrier(false); 161 waitForMs(100); 162 assertFalse(mSimulatedCommands.getRadioState().isOn()); 163 assertTrue(sst.getDesiredPowerState()); 164 assertFalse(sst.getPowerStateFromCarrier()); 165 166 // User toggle radio power will not overrides carrier settings 167 sst.setRadioPower(true); 168 waitForMs(100); 169 assertFalse(mSimulatedCommands.getRadioState().isOn()); 170 assertTrue(sst.getDesiredPowerState()); 171 assertFalse(sst.getPowerStateFromCarrier()); 172 173 // Carrier re-enable radio power 174 sst.setRadioPowerFromCarrier(true); 175 waitForMs(100); 176 assertTrue(mSimulatedCommands.getRadioState().isOn()); 177 assertTrue(sst.getDesiredPowerState()); 178 assertTrue(sst.getPowerStateFromCarrier()); 179 180 // User toggle radio power off (airplane mode) and set carrier on 181 sst.setRadioPower(false); 182 sst.setRadioPowerFromCarrier(true); 183 waitForMs(100); 184 assertFalse(mSimulatedCommands.getRadioState().isOn()); 185 assertFalse(sst.getDesiredPowerState()); 186 assertTrue(sst.getPowerStateFromCarrier()); 187 } 188 189 @Test 190 @MediumTest 191 public void testRilTrafficAfterSetRadioPower() { 192 sst.setRadioPower(true); 193 final int getOperatorCallCount = mSimulatedCommands.getGetOperatorCallCount(); 194 final int getDataRegistrationStateCallCount = 195 mSimulatedCommands.getGetDataRegistrationStateCallCount(); 196 final int getVoiceRegistrationStateCallCount = 197 mSimulatedCommands.getGetVoiceRegistrationStateCallCount(); 198 final int getNetworkSelectionModeCallCount = 199 mSimulatedCommands.getGetNetworkSelectionModeCallCount(); 200 sst.setRadioPower(false); 201 202 waitForMs(500); 203 sst.pollState(); 204 waitForMs(250); 205 206 // This test was meant to be for *no* ril traffic. However, RADIO_STATE_CHANGED is 207 // considered a modem triggered action and that causes a pollState() to be done 208 assertEquals(getOperatorCallCount + 1, mSimulatedCommands.getGetOperatorCallCount()); 209 assertEquals(getDataRegistrationStateCallCount + 1, 210 mSimulatedCommands.getGetDataRegistrationStateCallCount()); 211 assertEquals(getVoiceRegistrationStateCallCount + 1, 212 mSimulatedCommands.getGetVoiceRegistrationStateCallCount()); 213 assertEquals(getNetworkSelectionModeCallCount + 1, 214 mSimulatedCommands.getGetNetworkSelectionModeCallCount()); 215 216 // Note that if the poll is triggered by a network change notification 217 // and the modem is supposed to be off, we should still do the poll 218 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 219 waitForMs(250); 220 221 assertEquals(getOperatorCallCount + 2 , mSimulatedCommands.getGetOperatorCallCount()); 222 assertEquals(getDataRegistrationStateCallCount + 2, 223 mSimulatedCommands.getGetDataRegistrationStateCallCount()); 224 assertEquals(getVoiceRegistrationStateCallCount + 2, 225 mSimulatedCommands.getGetVoiceRegistrationStateCallCount()); 226 assertEquals(getNetworkSelectionModeCallCount + 2, 227 mSimulatedCommands.getGetNetworkSelectionModeCallCount()); 228 } 229 230 @Test 231 @MediumTest 232 public void testSpnUpdateShowPlmnOnly() { 233 doReturn(0x02).when(mSimRecords).getDisplayRule(anyString()); 234 doReturn(IccCardApplicationStatus.AppState.APPSTATE_UNKNOWN). 235 when(mUiccCardApplication3gpp).getState(); 236 237 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_NETWORK_STATE_CHANGED, null)); 238 239 waitForMs(750); 240 241 ArgumentCaptor<Intent> intentArgumentCaptor = ArgumentCaptor.forClass(Intent.class); 242 verify(mContextFixture.getTestDouble(), atLeast(2)). 243 sendStickyBroadcastAsUser(intentArgumentCaptor.capture(), eq(UserHandle.ALL)); 244 245 // We only want to verify the intent SPN_STRINGS_UPDATED_ACTION. 246 Intent intent = intentArgumentCaptor.getValue(); 247 assertEquals(TelephonyIntents.SPN_STRINGS_UPDATED_ACTION, intent.getAction()); 248 assertEquals(Intent.FLAG_RECEIVER_REPLACE_PENDING, intent.getFlags()); 249 250 Bundle b = intent.getExtras(); 251 252 // For boolean we need to make sure the key exists first 253 assertTrue(b.containsKey(TelephonyIntents.EXTRA_SHOW_SPN)); 254 assertFalse(b.getBoolean(TelephonyIntents.EXTRA_SHOW_SPN)); 255 256 assertEquals(null, b.getString(TelephonyIntents.EXTRA_SPN)); 257 assertEquals(null, b.getString(TelephonyIntents.EXTRA_DATA_SPN)); 258 259 // For boolean we need to make sure the key exists first 260 assertTrue(b.containsKey(TelephonyIntents.EXTRA_SHOW_PLMN)); 261 assertTrue(b.getBoolean(TelephonyIntents.EXTRA_SHOW_PLMN)); 262 263 assertEquals(SimulatedCommands.FAKE_LONG_NAME, b.getString(TelephonyIntents.EXTRA_PLMN)); 264 265 ArgumentCaptor<Integer> intArgumentCaptor = ArgumentCaptor.forClass(Integer.class); 266 verify(mTelephonyManager).setDataNetworkTypeForPhone(anyInt(), intArgumentCaptor.capture()); 267 assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_HSPA, 268 intArgumentCaptor.getValue().intValue()); 269 } 270 271 @Test 272 @MediumTest 273 public void testCellInfoList() { 274 Parcel p = Parcel.obtain(); 275 p.writeInt(1); 276 p.writeInt(1); 277 p.writeInt(2); 278 p.writeLong(1453510289108L); 279 p.writeInt(310); 280 p.writeInt(260); 281 p.writeInt(123); 282 p.writeInt(456); 283 p.writeInt(99); 284 p.writeInt(3); 285 p.setDataPosition(0); 286 287 CellInfoGsm cellInfo = CellInfoGsm.CREATOR.createFromParcel(p); 288 289 ArrayList<CellInfo> list = new ArrayList(); 290 list.add(cellInfo); 291 mSimulatedCommands.setCellInfoList(list); 292 293 assertEquals(sst.getAllCellInfo(), list); 294 } 295 296 @Test 297 @MediumTest 298 public void testImsRegState() { 299 // Simulate IMS registered 300 mSimulatedCommands.setImsRegistrationState(new int[]{1, PhoneConstants.PHONE_TYPE_GSM}); 301 302 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_IMS_STATE_CHANGED, null)); 303 waitForMs(200); 304 305 assertTrue(sst.isImsRegistered()); 306 307 // Simulate IMS unregistered 308 mSimulatedCommands.setImsRegistrationState(new int[]{0, PhoneConstants.PHONE_TYPE_GSM}); 309 310 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_IMS_STATE_CHANGED, null)); 311 waitForMs(200); 312 313 assertFalse(sst.isImsRegistered()); 314 } 315 316 @Postsubmit 317 @Test 318 @MediumTest 319 public void testSignalStrength() { 320 SignalStrength ss = new SignalStrength( 321 30, // gsmSignalStrength 322 0, // gsmBitErrorRate 323 -1, // cdmaDbm 324 -1, // cdmaEcio 325 -1, // evdoDbm 326 -1, // evdoEcio 327 -1, // evdoSnr 328 99, // lteSignalStrength 329 SignalStrength.INVALID, // lteRsrp 330 SignalStrength.INVALID, // lteRsrq 331 SignalStrength.INVALID, // lteRssnr 332 SignalStrength.INVALID, // lteCqi 333 SignalStrength.INVALID, // tdScdmaRscp 334 true // gsmFlag 335 ); 336 337 mSimulatedCommands.setSignalStrength(ss); 338 mSimulatedCommands.notifySignalStrength(); 339 waitForMs(300); 340 assertEquals(sst.getSignalStrength(), ss); 341 assertEquals(sst.getSignalStrength().isGsm(), true); 342 343 // switch to CDMA 344 doReturn(false).when(mPhone).isPhoneTypeGsm(); 345 doReturn(true).when(mPhone).isPhoneTypeCdmaLte(); 346 sst.updatePhoneType(); 347 sst.mSS.setRilDataRadioTechnology(ServiceState.RIL_RADIO_TECHNOLOGY_LTE); 348 349 mSimulatedCommands.notifySignalStrength(); 350 waitForMs(200); 351 assertEquals(sst.getSignalStrength(), ss); 352 assertEquals(sst.getSignalStrength().isGsm(), true); 353 354 // notify signal strength again, but this time data RAT is not LTE 355 sst.mSS.setRilDataRadioTechnology(ServiceState.RIL_RADIO_TECHNOLOGY_EHRPD); 356 mSimulatedCommands.notifySignalStrength(); 357 waitForMs(200); 358 assertEquals(sst.getSignalStrength(), ss); 359 assertEquals(sst.getSignalStrength().isGsm(), false); 360 } 361 362 @Test 363 @MediumTest 364 public void testGsmCellLocation() { 365 366 sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_GET_LOC_DONE, 367 new AsyncResult(null, new String[]{"1", "2", "3", "4", "5", "6", "7", "8", "9", 368 "10", "11", "12", "13", "14", "15"}, null))); 369 370 waitForMs(200); 371 GsmCellLocation cl = (GsmCellLocation) sst.getCellLocation(); 372 assertEquals(2, cl.getLac()); 373 assertEquals(3, cl.getCid()); 374 } 375 376 @Test 377 @MediumTest 378 public void testUpdatePhoneType() { 379 doReturn(false).when(mPhone).isPhoneTypeGsm(); 380 doReturn(true).when(mPhone).isPhoneTypeCdmaLte(); 381 doReturn(CdmaSubscriptionSourceManager.SUBSCRIPTION_FROM_RUIM).when(mCdmaSSM). 382 getCdmaSubscriptionSource(); 383 384 logd("Calling updatePhoneType"); 385 // switch to CDMA 386 sst.updatePhoneType(); 387 388 ArgumentCaptor<Integer> integerArgumentCaptor = ArgumentCaptor.forClass(Integer.class); 389 verify(mRuimRecords).registerForRecordsLoaded(eq(sst), integerArgumentCaptor.capture(), 390 any(Object.class)); 391 392 // response for mRuimRecords.registerForRecordsLoaded() 393 Message msg = Message.obtain(); 394 msg.what = integerArgumentCaptor.getValue(); 395 msg.obj = new AsyncResult(null, null, null); 396 sst.sendMessage(msg); 397 waitForMs(100); 398 399 // on RUIM_RECORDS_LOADED, sst is expected to call following apis 400 verify(mRuimRecords, times(1)).isProvisioned(); 401 402 // switch back to GSM 403 doReturn(true).when(mPhone).isPhoneTypeGsm(); 404 doReturn(false).when(mPhone).isPhoneTypeCdmaLte(); 405 406 // response for mRuimRecords.registerForRecordsLoaded() can be sent after switching to GSM 407 msg = Message.obtain(); 408 msg.what = integerArgumentCaptor.getValue(); 409 msg.obj = new AsyncResult(null, null, null); 410 sst.sendMessage(msg); 411 412 // There's no easy way to check if the msg was handled or discarded. Wait to make sure sst 413 // did not crash, and then verify that the functions called records loaded are not called 414 // again 415 waitForMs(200); 416 417 verify(mRuimRecords, times(1)).isProvisioned(); 418 } 419 420 @Test 421 @MediumTest 422 public void testRegAndUnregForVoiceRoamingOn() throws Exception { 423 sst.registerForVoiceRoamingOn(mTestHandler, EVENT_ROAMING_ON, null); 424 425 // Enable roaming and trigger events to notify handler registered 426 doReturn(true).when(mPhone).isPhoneTypeGsm(); 427 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 428 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 429 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 430 431 waitForMs(100); 432 433 // verify if registered handler has message posted to it 434 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 435 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 436 assertEquals(EVENT_ROAMING_ON, messageArgumentCaptor.getValue().what); 437 438 // Disable roaming 439 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME); 440 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME); 441 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 442 443 waitForMs(100); 444 445 // Unregister registrant 446 sst.unregisterForVoiceRoamingOn(mTestHandler); 447 448 // Enable roaming 449 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 450 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 451 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 452 453 waitForMs(100); 454 455 // verify that no new message posted to handler 456 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 457 } 458 459 @Test 460 @MediumTest 461 public void testRegAndUnregForVoiceRoamingOff() throws Exception { 462 // Enable roaming 463 doReturn(true).when(mPhone).isPhoneTypeGsm(); 464 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 465 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 466 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 467 468 waitForMs(100); 469 470 sst.registerForVoiceRoamingOff(mTestHandler, EVENT_ROAMING_OFF, null); 471 472 // Disable roaming 473 doReturn(true).when(mPhone).isPhoneTypeGsm(); 474 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME); 475 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME); 476 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 477 478 waitForMs(100); 479 480 // verify if registered handler has message posted to it 481 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 482 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 483 assertEquals(EVENT_ROAMING_OFF, messageArgumentCaptor.getValue().what); 484 485 // Enable roaming 486 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 487 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 488 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 489 490 waitForMs(100); 491 492 // Unregister registrant 493 sst.unregisterForVoiceRoamingOff(mTestHandler); 494 495 // Disable roaming 496 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME); 497 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME); 498 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 499 500 waitForMs(100); 501 502 // verify that no new message posted to handler 503 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 504 } 505 506 @Test 507 @MediumTest 508 public void testRegAndUnregForDataRoamingOn() throws Exception { 509 sst.registerForDataRoamingOn(mTestHandler, EVENT_ROAMING_ON, null); 510 511 // Enable roaming and trigger events to notify handler registered 512 doReturn(true).when(mPhone).isPhoneTypeGsm(); 513 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 514 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 515 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 516 517 waitForMs(100); 518 519 // verify if registered handler has message posted to it 520 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 521 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 522 assertEquals(EVENT_ROAMING_ON, messageArgumentCaptor.getValue().what); 523 524 // Disable roaming 525 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME); 526 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME); 527 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 528 529 waitForMs(100); 530 531 // Unregister registrant 532 sst.unregisterForDataRoamingOn(mTestHandler); 533 534 // Enable roaming 535 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 536 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 537 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 538 539 waitForMs(100); 540 541 // verify that no new message posted to handler 542 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 543 } 544 545 @Test 546 @MediumTest 547 public void testRegAndUnregForDataRoamingOff() throws Exception { 548 // Enable roaming 549 doReturn(true).when(mPhone).isPhoneTypeGsm(); 550 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 551 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 552 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 553 554 waitForMs(100); 555 556 sst.registerForDataRoamingOff(mTestHandler, EVENT_ROAMING_OFF, null); 557 558 // Disable roaming 559 doReturn(true).when(mPhone).isPhoneTypeGsm(); 560 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME); 561 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME); 562 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 563 564 waitForMs(100); 565 566 // verify if registered handler has message posted to it 567 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 568 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 569 assertEquals(EVENT_ROAMING_OFF, messageArgumentCaptor.getValue().what); 570 571 // Enable roaming 572 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 573 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 574 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 575 576 waitForMs(100); 577 578 // Unregister registrant 579 sst.unregisterForDataRoamingOff(mTestHandler); 580 581 // Disable roaming 582 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME); 583 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME); 584 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 585 586 waitForMs(100); 587 588 // verify that no new message posted to handler 589 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 590 } 591 592 @Test 593 @MediumTest 594 public void testRegAndUnregForDataConnAttach() throws Exception { 595 // Initially set service state out of service 596 doReturn(true).when(mPhone).isPhoneTypeGsm(); 597 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 598 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 599 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 600 601 waitForMs(100); 602 603 sst.registerForDataConnectionAttached(mTestHandler, EVENT_DATA_CONNECTION_ATTACHED, null); 604 605 // set service state in service and trigger events to post message on handler 606 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 607 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 608 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 609 610 waitForMs(200); 611 612 // verify if registered handler has message posted to it 613 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 614 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 615 assertEquals(EVENT_DATA_CONNECTION_ATTACHED, messageArgumentCaptor.getValue().what); 616 617 // set service state out of service 618 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 619 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 620 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 621 622 waitForMs(100); 623 624 // Unregister registrant 625 sst.unregisterForDataConnectionAttached(mTestHandler); 626 627 // set service state in service 628 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 629 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 630 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 631 632 waitForMs(100); 633 634 // verify that no new message posted to handler 635 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 636 } 637 638 @Test 639 @MediumTest 640 public void testRegAndUnregForDataConnDetach() throws Exception { 641 // Initially set service state in service 642 doReturn(true).when(mPhone).isPhoneTypeGsm(); 643 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 644 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 645 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 646 647 sst.registerForDataConnectionDetached(mTestHandler, EVENT_DATA_CONNECTION_DETACHED, null); 648 649 // set service state out of service and trigger events to post message on handler 650 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 651 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 652 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 653 654 waitForMs(100); 655 656 // verify if registered handler has message posted to it 657 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 658 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 659 assertEquals(EVENT_DATA_CONNECTION_DETACHED, messageArgumentCaptor.getValue().what); 660 661 // set service state in service 662 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 663 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 664 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 665 666 waitForMs(100); 667 668 // Unregister registrant 669 sst.unregisterForDataConnectionDetached(mTestHandler); 670 671 // set service state out of service 672 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 673 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 674 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 675 676 waitForMs(100); 677 678 // verify that no new message posted to handler 679 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 680 } 681 682 @Test 683 @MediumTest 684 public void testRegisterForDataRegStateOrRatChange() { 685 int drs = sst.mSS.RIL_REG_STATE_HOME; 686 int rat = sst.mSS.RIL_RADIO_TECHNOLOGY_LTE; 687 sst.mSS.setRilDataRadioTechnology(rat); 688 sst.mSS.setDataRegState(drs); 689 sst.registerForDataRegStateOrRatChanged(mTestHandler, EVENT_DATA_RAT_CHANGED, null); 690 691 waitForMs(100); 692 693 // Verify if message was posted to handler and value of result 694 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 695 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 696 assertEquals(EVENT_DATA_RAT_CHANGED, messageArgumentCaptor.getValue().what); 697 assertEquals(new Pair<Integer, Integer>(drs, rat), 698 ((AsyncResult)messageArgumentCaptor.getValue().obj).result); 699 } 700 701 @Test 702 @MediumTest 703 public void testRegAndUnregForNetworkAttached() throws Exception { 704 // Initially set service state out of service 705 doReturn(true).when(mPhone).isPhoneTypeGsm(); 706 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 707 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 708 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 709 710 waitForMs(100); 711 712 sst.registerForNetworkAttached(mTestHandler, EVENT_REGISTERED_TO_NETWORK, null); 713 714 // set service state in service and trigger events to post message on handler 715 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 716 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 717 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 718 719 waitForMs(100); 720 721 // verify if registered handler has message posted to it 722 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 723 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 724 assertEquals(EVENT_REGISTERED_TO_NETWORK, messageArgumentCaptor.getValue().what); 725 726 // set service state out of service 727 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 728 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN); 729 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 730 731 waitForMs(100); 732 733 // Unregister registrant 734 sst.unregisterForNetworkAttached(mTestHandler); 735 736 // set service state in service 737 mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING); 738 mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING); 739 mSimulatedCommands.notifyVoiceNetworkStateChanged(); 740 741 waitForMs(100); 742 743 // verify that no new message posted to handler 744 verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong()); 745 } 746 747 @Test 748 @MediumTest 749 public void testRegisterForPsRestrictedEnabled() throws Exception { 750 sst.mRestrictedState.setPsRestricted(true); 751 // Since PsRestricted is set to true, registerForPsRestrictedEnabled will 752 // also post message to handler 753 sst.registerForPsRestrictedEnabled(mTestHandler, EVENT_PS_RESTRICT_ENABLED, null); 754 755 waitForMs(100); 756 757 // verify posted message 758 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 759 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 760 assertEquals(EVENT_PS_RESTRICT_ENABLED, messageArgumentCaptor.getValue().what); 761 } 762 763 @Test 764 @MediumTest 765 public void testRegisterForPsRestrictedDisabled() throws Exception { 766 sst.mRestrictedState.setPsRestricted(true); 767 // Since PsRestricted is set to true, registerForPsRestrictedDisabled will 768 // also post message to handler 769 sst.registerForPsRestrictedDisabled(mTestHandler, EVENT_PS_RESTRICT_DISABLED, null); 770 771 waitForMs(100); 772 773 // verify posted message 774 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 775 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 776 assertEquals(EVENT_PS_RESTRICT_DISABLED, messageArgumentCaptor.getValue().what); 777 } 778 779 @Test 780 @MediumTest 781 public void testRegisterForSubscriptionInfoReady() { 782 sst.registerForSubscriptionInfoReady(mTestHandler, EVENT_SUBSCRIPTION_INFO_READY, null); 783 784 // Call functions which would trigger posting of message on test handler 785 doReturn(false).when(mPhone).isPhoneTypeGsm(); 786 sst.updatePhoneType(); 787 mSimulatedCommands.notifyOtaProvisionStatusChanged(); 788 789 waitForMs(200); 790 791 // verify posted message 792 ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); 793 verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong()); 794 assertEquals(EVENT_SUBSCRIPTION_INFO_READY, messageArgumentCaptor.getValue().what); 795 } 796 797 @Test 798 @SmallTest 799 public void testGetDesiredPowerState() { 800 sst.setRadioPower(true); 801 assertEquals(sst.getDesiredPowerState(), true); 802 } 803 804 @Test 805 @MediumTest 806 public void testEnableLocationUpdates() throws Exception { 807 sst.enableLocationUpdates(); 808 verify(mSimulatedCommandsVerifier, times(1)).setLocationUpdates(eq(true), 809 any(Message.class)); 810 } 811 812 @Test 813 @SmallTest 814 public void testDisableLocationUpdates() throws Exception { 815 sst.disableLocationUpdates(); 816 verify(mSimulatedCommandsVerifier, times(1)).setLocationUpdates(eq(false), 817 any(Message.class)); 818 } 819 820 @Test 821 @SmallTest 822 public void testGetCurrentDataRegState() throws Exception { 823 sst.mSS.setDataRegState(ServiceState.STATE_OUT_OF_SERVICE); 824 assertEquals(sst.getCurrentDataConnectionState(), ServiceState.STATE_OUT_OF_SERVICE); 825 } 826 827 @Test 828 @SmallTest 829 public void testIsConcurrentVoiceAndDataAllowed() { 830 // Verify all 3 branches in the function isConcurrentVoiceAndDataAllowed 831 doReturn(true).when(mPhone).isPhoneTypeGsm(); 832 sst.mSS.setRilVoiceRadioTechnology(sst.mSS.RIL_RADIO_TECHNOLOGY_HSPA); 833 assertEquals(true, sst.isConcurrentVoiceAndDataAllowed()); 834 835 doReturn(false).when(mPhone).isPhoneTypeGsm(); 836 doReturn(true).when(mPhone).isPhoneTypeCdma(); 837 assertEquals(false, sst.isConcurrentVoiceAndDataAllowed()); 838 839 doReturn(false).when(mPhone).isPhoneTypeGsm(); 840 doReturn(false).when(mPhone).isPhoneTypeCdma(); 841 sst.mSS.setCssIndicator(1); 842 assertEquals(true, sst.isConcurrentVoiceAndDataAllowed()); 843 sst.mSS.setCssIndicator(0); 844 assertEquals(false, sst.isConcurrentVoiceAndDataAllowed()); 845 } 846 847 @Test 848 @MediumTest 849 public void testIsImsRegistered() throws Exception { 850 mSimulatedCommands.setImsRegistrationState(new int[]{1, PhoneConstants.PHONE_TYPE_GSM}); 851 mSimulatedCommands.notifyImsNetworkStateChanged(); 852 waitForMs(200); 853 assertEquals(sst.isImsRegistered(), true); 854 } 855 856 @Test 857 @SmallTest 858 public void testIsDeviceShuttingDown() throws Exception { 859 sst.requestShutdown(); 860 assertEquals(true, sst.isDeviceShuttingDown()); 861 } 862 863 @Test 864 @SmallTest 865 public void testSetTimeFromNITZStr() throws Exception { 866 doReturn(mAlarmManager).when(mIBinder).queryLocalInterface(anyString()); 867 mServiceManagerMockedServices.put(Context.ALARM_SERVICE, mIBinder); 868 869 // Mock sending incorrect nitz str from RIL 870 mSimulatedCommands.triggerNITZupdate("38/06/20,00:00:00+0"); 871 waitForMs(100); 872 // AlarmManger.setTime is triggered by SystemClock.setCurrentTimeMillis(). 873 // Verify system time is not set to incorrect NITZ time 874 verify(mAlarmManager, times(0)).setTime(anyLong()); 875 876 // Mock sending correct nitz str from RIL 877 mSimulatedCommands.triggerNITZupdate("15/06/20,00:00:00+0"); 878 waitForMs(100); 879 verify(mAlarmManager, times(1)).setTime(anyLong()); 880 } 881} 882