2 * Copyright (C) 2017 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include <radio_hidl_hal_utils.h>
20 * Test IRadio.getSignalStrength() for the response returned.
22 TEST_F(RadioHidlTest, getSignalStrength) {
23 int serial = GetRandomSerialNumber();
25 radio->getSignalStrength(serial);
26 EXPECT_EQ(std::cv_status::no_timeout, wait());
27 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
28 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
30 if (cardStatus.cardState == CardState::ABSENT) {
31 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
36 * Test IRadio.getVoiceRegistrationState() for the response returned.
38 TEST_F(RadioHidlTest, getVoiceRegistrationState) {
39 int serial = GetRandomSerialNumber();
41 radio->getVoiceRegistrationState(serial);
42 EXPECT_EQ(std::cv_status::no_timeout, wait());
43 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
44 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
46 if (cardStatus.cardState == CardState::ABSENT) {
47 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
52 * Test IRadio.getOperator() for the response returned.
54 TEST_F(RadioHidlTest, getOperator) {
55 int serial = GetRandomSerialNumber();
57 radio->getOperator(serial);
58 EXPECT_EQ(std::cv_status::no_timeout, wait());
59 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
60 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
62 if (cardStatus.cardState == CardState::ABSENT) {
63 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
68 * Test IRadio.setRadioPower() for the response returned.
70 TEST_F(RadioHidlTest, setRadioPower) {
71 int serial = GetRandomSerialNumber();
73 radio->setRadioPower(serial, 1);
74 EXPECT_EQ(std::cv_status::no_timeout, wait());
75 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
76 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
78 if (cardStatus.cardState == CardState::ABSENT) {
79 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
84 * Test IRadio.getNetworkSelectionMode() for the response returned.
86 TEST_F(RadioHidlTest, getNetworkSelectionMode) {
87 int serial = GetRandomSerialNumber();
89 radio->getNetworkSelectionMode(serial);
90 EXPECT_EQ(std::cv_status::no_timeout, wait());
91 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
92 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
94 if (cardStatus.cardState == CardState::ABSENT) {
95 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
100 * Test IRadio.setNetworkSelectionModeAutomatic() for the response returned.
102 TEST_F(RadioHidlTest, setNetworkSelectionModeAutomatic) {
103 int serial = GetRandomSerialNumber();
105 radio->setNetworkSelectionModeAutomatic(serial);
106 EXPECT_EQ(std::cv_status::no_timeout, wait());
107 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
108 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
110 if (cardStatus.cardState == CardState::ABSENT) {
111 ASSERT_TRUE(CheckGeneralError() ||
112 radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME ||
113 radioRsp->rspInfo.error == RadioError::NONE ||
114 radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED);
119 * Test IRadio.setNetworkSelectionModeManual() for the response returned.
121 TEST_F(RadioHidlTest, setNetworkSelectionModeManual) {
122 int serial = GetRandomSerialNumber();
124 radio->setNetworkSelectionModeManual(serial, "123456");
125 EXPECT_EQ(std::cv_status::no_timeout, wait());
126 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
127 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
129 if (cardStatus.cardState == CardState::ABSENT) {
130 ASSERT_TRUE(CheckGeneralError() ||
131 radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
132 radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME ||
133 radioRsp->rspInfo.error == RadioError::NONE ||
134 radioRsp->rspInfo.error == RadioError::INVALID_STATE);
139 * Test IRadio.getAvailableNetworks() for the response returned.
141 TEST_F(RadioHidlTest, getAvailableNetworks) {
142 int serial = GetRandomSerialNumber();
144 radio->getAvailableNetworks(serial);
145 EXPECT_EQ(std::cv_status::no_timeout, wait());
146 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
147 ASSERT_TRUE(radioRsp->rspInfo.type == RadioResponseType::SOLICITED ||
148 radioRsp->rspInfo.type == RadioResponseType::SOLICITED_ACK_EXP);
150 if (cardStatus.cardState == CardState::ABSENT) {
151 ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
152 radioRsp->rspInfo.error == RadioError::DEVICE_IN_USE ||
153 radioRsp->rspInfo.error == RadioError::CANCELLED ||
154 radioRsp->rspInfo.error == RadioError::OPERATION_NOT_ALLOWED ||
155 radioRsp->rspInfo.error == RadioError::MODEM_ERR);
160 * Test IRadio.getBasebandVersion() for the response returned.
162 TEST_F(RadioHidlTest, getBasebandVersion) {
163 int serial = GetRandomSerialNumber();
165 radio->getBasebandVersion(serial);
166 EXPECT_EQ(std::cv_status::no_timeout, wait());
167 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
168 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
170 if (cardStatus.cardState == CardState::ABSENT) {
171 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
176 * Test IRadio.setBandMode() for the response returned.
178 TEST_F(RadioHidlTest, setBandMode) {
179 int serial = GetRandomSerialNumber();
181 radio->setBandMode(serial, RadioBandMode::BAND_MODE_USA);
182 EXPECT_EQ(std::cv_status::no_timeout, wait());
183 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
184 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
186 if (cardStatus.cardState == CardState::ABSENT) {
187 EXPECT_EQ(radioRsp->rspInfo.error, RadioError::NONE);
192 * Test IRadio.getAvailableBandModes() for the response returned.
194 TEST_F(RadioHidlTest, getAvailableBandModes) {
195 int serial = GetRandomSerialNumber();
197 radio->getAvailableBandModes(serial);
198 EXPECT_EQ(std::cv_status::no_timeout, wait());
199 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
200 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
202 if (cardStatus.cardState == CardState::ABSENT) {
203 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
208 * Test IRadio.setPreferredNetworkType() for the response returned.
210 TEST_F(RadioHidlTest, setPreferredNetworkType) {
211 int serial = GetRandomSerialNumber();
213 radio->setPreferredNetworkType(serial, PreferredNetworkType::GSM_ONLY);
214 EXPECT_EQ(std::cv_status::no_timeout, wait());
215 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
216 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
218 if (cardStatus.cardState == CardState::ABSENT) {
219 EXPECT_EQ(radioRsp->rspInfo.error, RadioError::NONE);
224 * Test IRadio.getPreferredNetworkType() for the response returned.
226 TEST_F(RadioHidlTest, getPreferredNetworkType) {
227 int serial = GetRandomSerialNumber();
229 radio->getPreferredNetworkType(serial);
230 EXPECT_EQ(std::cv_status::no_timeout, wait());
231 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
232 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
234 if (cardStatus.cardState == CardState::ABSENT) {
235 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
240 * Test IRadio.getNeighboringCids() for the response returned.
242 TEST_F(RadioHidlTest, getNeighboringCids) {
243 int serial = GetRandomSerialNumber();
245 radio->getNeighboringCids(serial);
246 EXPECT_EQ(std::cv_status::no_timeout, wait());
247 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
248 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
250 if (cardStatus.cardState == CardState::ABSENT) {
251 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
252 radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
257 * Test IRadio.setLocationUpdates() for the response returned.
259 TEST_F(RadioHidlTest, setLocationUpdates) {
260 int serial = GetRandomSerialNumber();
262 radio->setLocationUpdates(serial, true);
263 EXPECT_EQ(std::cv_status::no_timeout, wait());
264 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
265 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
267 if (cardStatus.cardState == CardState::ABSENT) {
268 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
273 * Test IRadio.setCdmaRoamingPreference() for the response returned.
275 TEST_F(RadioHidlTest, setCdmaRoamingPreference) {
276 int serial = GetRandomSerialNumber();
278 radio->setCdmaRoamingPreference(serial, CdmaRoamingType::HOME_NETWORK);
279 EXPECT_EQ(std::cv_status::no_timeout, wait());
280 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
281 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
283 if (cardStatus.cardState == CardState::ABSENT) {
284 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
285 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
290 * Test IRadio.getCdmaRoamingPreference() for the response returned.
292 TEST_F(RadioHidlTest, getCdmaRoamingPreference) {
293 int serial = GetRandomSerialNumber();
295 radio->getCdmaRoamingPreference(serial);
296 EXPECT_EQ(std::cv_status::no_timeout, wait());
297 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
298 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
300 if (cardStatus.cardState == CardState::ABSENT) {
301 ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
302 radioRsp->rspInfo.error == RadioError::MODEM_ERR);
307 * Test IRadio.getTTYMode() for the response returned.
309 TEST_F(RadioHidlTest, getTTYMode) {
310 int serial = GetRandomSerialNumber();
312 radio->getTTYMode(serial);
313 EXPECT_EQ(std::cv_status::no_timeout, wait());
314 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
315 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
317 if (cardStatus.cardState == CardState::ABSENT) {
318 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
323 * Test IRadio.setTTYMode() for the response returned.
325 TEST_F(RadioHidlTest, setTTYMode) {
326 int serial = GetRandomSerialNumber();
328 radio->setTTYMode(serial, TtyMode::OFF);
329 EXPECT_EQ(std::cv_status::no_timeout, wait());
330 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
331 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
333 if (cardStatus.cardState == CardState::ABSENT) {
334 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
339 * Test IRadio.setPreferredVoicePrivacy() for the response returned.
341 TEST_F(RadioHidlTest, setPreferredVoicePrivacy) {
342 int serial = GetRandomSerialNumber();
344 radio->setPreferredVoicePrivacy(serial, true);
345 EXPECT_EQ(std::cv_status::no_timeout, wait());
346 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
347 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
349 if (cardStatus.cardState == CardState::ABSENT) {
350 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
351 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
356 * Test IRadio.getPreferredVoicePrivacy() for the response returned.
358 TEST_F(RadioHidlTest, getPreferredVoicePrivacy) {
359 int serial = GetRandomSerialNumber();
361 radio->getPreferredVoicePrivacy(serial);
362 EXPECT_EQ(std::cv_status::no_timeout, wait());
363 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
364 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
366 if (cardStatus.cardState == CardState::ABSENT) {
367 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
368 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
373 * Test IRadio.getCDMASubscription() for the response returned.
375 TEST_F(RadioHidlTest, getCDMASubscription) {
376 int serial = GetRandomSerialNumber();
378 radio->getCDMASubscription(serial);
379 EXPECT_EQ(std::cv_status::no_timeout, wait());
380 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
381 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
383 if (cardStatus.cardState == CardState::ABSENT) {
384 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
389 * Test IRadio.getDeviceIdentity() for the response returned.
391 TEST_F(RadioHidlTest, getDeviceIdentity) {
392 int serial = GetRandomSerialNumber();
394 radio->getDeviceIdentity(serial);
395 EXPECT_EQ(std::cv_status::no_timeout, wait());
396 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
397 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
399 if (cardStatus.cardState == CardState::ABSENT) {
400 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
401 radioRsp->rspInfo.error == RadioError::EMPTY_RECORD);
406 * Test IRadio.exitEmergencyCallbackMode() for the response returned.
408 TEST_F(RadioHidlTest, exitEmergencyCallbackMode) {
409 int serial = GetRandomSerialNumber();
411 radio->exitEmergencyCallbackMode(serial);
412 EXPECT_EQ(std::cv_status::no_timeout, wait());
413 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
414 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
416 if (cardStatus.cardState == CardState::ABSENT) {
417 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
422 * Test IRadio.getCdmaSubscriptionSource() for the response returned.
424 TEST_F(RadioHidlTest, getCdmaSubscriptionSource) {
425 int serial = GetRandomSerialNumber();
427 radio->getCdmaSubscriptionSource(serial);
428 EXPECT_EQ(std::cv_status::no_timeout, wait());
429 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
430 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
432 if (cardStatus.cardState == CardState::ABSENT) {
433 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
438 * Test IRadio.setCdmaSubscriptionSource() for the response returned.
440 TEST_F(RadioHidlTest, setCdmaSubscriptionSource) {
441 int serial = GetRandomSerialNumber();
443 radio->setCdmaSubscriptionSource(serial, CdmaSubscriptionSource::RUIM_SIM);
444 EXPECT_EQ(std::cv_status::no_timeout, wait());
445 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
446 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
448 if (cardStatus.cardState == CardState::ABSENT) {
449 std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
450 ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::SIM_ABSENT ||
451 radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_AVAILABLE ||
452 radioRsp->rspInfo.error == RadioError::NONE);
457 * Test IRadio.getVoiceRadioTechnology() for the response returned.
459 TEST_F(RadioHidlTest, getVoiceRadioTechnology) {
460 int serial = GetRandomSerialNumber();
462 radio->getVoiceRadioTechnology(serial);
463 EXPECT_EQ(std::cv_status::no_timeout, wait());
464 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
465 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
467 if (cardStatus.cardState == CardState::ABSENT) {
468 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
473 * Test IRadio.getCellInfoList() for the response returned.
475 TEST_F(RadioHidlTest, getCellInfoList) {
476 int serial = GetRandomSerialNumber();
478 radio->getCellInfoList(serial);
479 EXPECT_EQ(std::cv_status::no_timeout, wait());
480 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
481 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
483 if (cardStatus.cardState == CardState::ABSENT) {
484 ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE ||
485 radioRsp->rspInfo.error == RadioError::NO_NETWORK_FOUND);
490 * Test IRadio.setCellInfoListRate() for the response returned.
492 TEST_F(RadioHidlTest, setCellInfoListRate) {
493 int serial = GetRandomSerialNumber();
495 // TODO(sanketpadawe): RIL crashes with value of rate = 10
496 radio->setCellInfoListRate(serial, 10);
497 EXPECT_EQ(std::cv_status::no_timeout, wait());
498 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
499 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
501 if (cardStatus.cardState == CardState::ABSENT) {
502 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
503 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
508 * Test IRadio.nvReadItem() for the response returned.
510 TEST_F(RadioHidlTest, nvReadItem) {
511 int serial = GetRandomSerialNumber();
513 radio->nvReadItem(serial, NvItem::LTE_BAND_ENABLE_25);
514 EXPECT_EQ(std::cv_status::no_timeout, wait());
515 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
516 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
518 if (cardStatus.cardState == CardState::ABSENT) {
519 ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
524 * Test IRadio.nvWriteItem() for the response returned.
526 TEST_F(RadioHidlTest, nvWriteItem) {
527 int serial = GetRandomSerialNumber();
529 memset(&item, 0, sizeof(item));
530 item.value = hidl_string();
532 radio->nvWriteItem(serial, item);
533 EXPECT_EQ(std::cv_status::no_timeout, wait());
534 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
535 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
537 if (cardStatus.cardState == CardState::ABSENT) {
538 ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
543 * Test IRadio.nvWriteCdmaPrl() for the response returned.
545 TEST_F(RadioHidlTest, nvWriteCdmaPrl) {
546 int serial = GetRandomSerialNumber();
547 std::vector<uint8_t> prl = {1, 2, 3, 4, 5};
549 radio->nvWriteCdmaPrl(serial, hidl_vec<uint8_t>(prl));
550 EXPECT_EQ(std::cv_status::no_timeout, wait());
551 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
552 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
554 if (cardStatus.cardState == CardState::ABSENT) {
555 ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
560 * Test IRadio.nvResetConfig() for the response returned.
562 TEST_F(RadioHidlTest, nvResetConfig) {
563 int serial = GetRandomSerialNumber();
565 radio->nvResetConfig(++serial, ResetNvType::ERASE);
566 EXPECT_EQ(std::cv_status::no_timeout, wait());
567 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
568 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
570 if (cardStatus.cardState == CardState::ABSENT) {
571 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
572 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
577 * Test IRadio.setUiccSubscription() for the response returned.
579 TEST_F(RadioHidlTest, setUiccSubscription) {
580 int serial = GetRandomSerialNumber();
582 memset(&item, 0, sizeof(item));
584 radio->setUiccSubscription(serial, item);
585 EXPECT_EQ(std::cv_status::no_timeout, wait());
586 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
587 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
589 if (cardStatus.cardState == CardState::ABSENT) {
590 ASSERT_TRUE(CheckGeneralError() ||
591 radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
592 radioRsp->rspInfo.error == RadioError::NONE ||
593 radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_SUPPORTED ||
594 radioRsp->rspInfo.error == RadioError::MODEM_ERR);
599 * Test IRadio.getHardwareConfig() for the response returned.
601 TEST_F(RadioHidlTest, getHardwareConfig) {
602 int serial = GetRandomSerialNumber();
604 radio->getHardwareConfig(serial);
605 EXPECT_EQ(std::cv_status::no_timeout, wait());
606 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
607 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
609 if (cardStatus.cardState == CardState::ABSENT) {
610 ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
615 * Test IRadio.requestShutdown() for the response returned.
617 TEST_F(RadioHidlTest, requestShutdown) {
618 int serial = GetRandomSerialNumber();
620 radio->requestShutdown(serial);
621 EXPECT_EQ(std::cv_status::no_timeout, wait());
622 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
623 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
625 if (cardStatus.cardState == CardState::ABSENT) {
626 ASSERT_TRUE(CheckGeneralError() || radioRsp->rspInfo.error == RadioError::NONE);
631 * Test IRadio.getRadioCapability() for the response returned.
633 TEST_F(RadioHidlTest, getRadioCapability) {
634 int serial = GetRandomSerialNumber();
636 radio->getRadioCapability(serial);
637 EXPECT_EQ(std::cv_status::no_timeout, wait());
638 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
639 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
641 if (cardStatus.cardState == CardState::ABSENT) {
642 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
647 * Test IRadio.setRadioCapability() for the response returned.
649 TEST_F(RadioHidlTest, setRadioCapability) {
650 int serial = GetRandomSerialNumber();
652 memset(&rc, 0, sizeof(rc));
653 rc.logicalModemUuid = hidl_string();
655 radio->setRadioCapability(serial, rc);
656 EXPECT_EQ(std::cv_status::no_timeout, wait());
657 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
658 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
660 if (cardStatus.cardState == CardState::ABSENT) {
661 std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
662 ASSERT_TRUE(CheckGeneralError() ||
663 radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
664 radioRsp->rspInfo.error == RadioError::INVALID_STATE);
669 * Test IRadio.startLceService() for the response returned.
671 TEST_F(RadioHidlTest, startLceService) {
672 int serial = GetRandomSerialNumber();
674 radio->startLceService(serial, 5, true);
675 EXPECT_EQ(std::cv_status::no_timeout, wait());
676 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
677 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
679 if (cardStatus.cardState == CardState::ABSENT) {
680 std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
681 ASSERT_TRUE(radioRsp->rspInfo.error ==
682 RadioError::RADIO_NOT_AVAILABLE ||
683 radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED ||
684 radioRsp->rspInfo.error == RadioError::INTERNAL_ERR ||
685 radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
690 * Test IRadio.stopLceService() for the response returned.
692 TEST_F(RadioHidlTest, stopLceService) {
693 int serial = GetRandomSerialNumber();
695 radio->stopLceService(serial);
696 EXPECT_EQ(std::cv_status::no_timeout, wait());
697 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
698 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
700 if (cardStatus.cardState == CardState::ABSENT) {
701 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
702 radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED ||
703 radioRsp->rspInfo.error ==
704 RadioError::REQUEST_NOT_SUPPORTED ||
705 radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
710 * Test IRadio.pullLceData() for the response returned.
712 TEST_F(RadioHidlTest, pullLceData) {
713 int serial = GetRandomSerialNumber();
715 radio->pullLceData(serial);
716 EXPECT_EQ(std::cv_status::no_timeout, wait());
717 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
718 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
720 if (cardStatus.cardState == CardState::ABSENT) {
721 ASSERT_TRUE(radioRsp->rspInfo.error ==
722 RadioError::RADIO_NOT_AVAILABLE ||
724 radioRsp->rspInfo.error == RadioError::INTERNAL_ERR ||
725 radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
730 * Test IRadio.getModemActivityInfo() for the response returned.
732 TEST_F(RadioHidlTest, getModemActivityInfo) {
733 int serial = GetRandomSerialNumber();
735 radio->getModemActivityInfo(serial);
736 EXPECT_EQ(std::cv_status::no_timeout, wait());
737 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
738 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
740 if (cardStatus.cardState == CardState::ABSENT) {
741 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
742 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
747 * Test IRadio.setAllowedCarriers() for the response returned.
749 TEST_F(RadioHidlTest, setAllowedCarriers) {
750 int serial = GetRandomSerialNumber();
751 CarrierRestrictions carriers;
752 memset(&carriers, 0, sizeof(carriers));
753 carriers.allowedCarriers.resize(1);
754 carriers.excludedCarriers.resize(0);
755 carriers.allowedCarriers[0].mcc = hidl_string();
756 carriers.allowedCarriers[0].mnc = hidl_string();
757 carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
758 carriers.allowedCarriers[0].matchData = hidl_string();
760 radio->setAllowedCarriers(serial, false, carriers);
761 EXPECT_EQ(std::cv_status::no_timeout, wait());
762 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
763 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
765 if (cardStatus.cardState == CardState::ABSENT) {
766 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
767 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
770 /* Reset back to no carrier restriction */
771 memset(&carriers, 0, sizeof(carriers));
772 carriers.allowedCarriers.resize(0);
773 carriers.excludedCarriers.resize(0);
775 radio->setAllowedCarriers(++serial, true, carriers);
776 EXPECT_EQ(std::cv_status::no_timeout, wait());
777 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
778 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
780 if (cardStatus.cardState == CardState::ABSENT) {
781 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
782 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
787 * Test IRadio.getAllowedCarriers() for the response returned.
789 TEST_F(RadioHidlTest, getAllowedCarriers) {
790 int serial = GetRandomSerialNumber();
792 radio->getAllowedCarriers(serial);
793 EXPECT_EQ(std::cv_status::no_timeout, wait());
794 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
795 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
797 if (cardStatus.cardState == CardState::ABSENT) {
798 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
799 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
804 * Test IRadio.sendDeviceState() for the response returned.
806 TEST_F(RadioHidlTest, sendDeviceState) {
807 int serial = GetRandomSerialNumber();
809 radio->sendDeviceState(serial, DeviceStateType::POWER_SAVE_MODE, true);
810 EXPECT_EQ(std::cv_status::no_timeout, wait());
811 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
812 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
814 std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
816 if (cardStatus.cardState == CardState::ABSENT) {
817 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
818 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
823 * Test IRadio.setIndicationFilter() for the response returned.
825 TEST_F(RadioHidlTest, setIndicationFilter) {
826 int serial = GetRandomSerialNumber();
828 radio->setIndicationFilter(serial, 1);
829 EXPECT_EQ(std::cv_status::no_timeout, wait());
830 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
831 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
833 std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
835 if (cardStatus.cardState == CardState::ABSENT) {
836 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
837 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);
842 * Test IRadio.setSimCardPower() for the response returned.
844 TEST_F(RadioHidlTest, setSimCardPower) {
845 int serial = GetRandomSerialNumber();
847 radio->setSimCardPower(serial, true);
848 EXPECT_EQ(std::cv_status::no_timeout, wait());
849 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
850 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
852 if (cardStatus.cardState == CardState::ABSENT) {
853 std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
854 ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
855 radioRsp->rspInfo.error == RadioError::REQUEST_NOT_SUPPORTED);