1 /*
2 * Copyright (C) 2017 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 #include <radio_hidl_hal_utils_v1_0.h>
18
19 /*
20 * Test IRadio.getSignalStrength() for the response returned.
21 */
TEST_F(RadioHidlTest,getSignalStrength)22 TEST_F(RadioHidlTest, getSignalStrength) {
23 serial = GetRandomSerialNumber();
24
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);
29
30 if (cardStatus.cardState == CardState::ABSENT) {
31 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
32 }
33 }
34
35 /*
36 * Test IRadio.getVoiceRegistrationState() for the response returned.
37 */
TEST_F(RadioHidlTest,getVoiceRegistrationState)38 TEST_F(RadioHidlTest, getVoiceRegistrationState) {
39 serial = GetRandomSerialNumber();
40
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);
45
46 if (cardStatus.cardState == CardState::ABSENT) {
47 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
48 }
49 }
50
51 /*
52 * Test IRadio.getOperator() for the response returned.
53 */
TEST_F(RadioHidlTest,getOperator)54 TEST_F(RadioHidlTest, getOperator) {
55 serial = GetRandomSerialNumber();
56
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);
61
62 if (cardStatus.cardState == CardState::ABSENT) {
63 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
64 }
65 }
66
67 /*
68 * Test IRadio.setRadioPower() for the response returned.
69 */
TEST_F(RadioHidlTest,setRadioPower)70 TEST_F(RadioHidlTest, setRadioPower) {
71 serial = GetRandomSerialNumber();
72
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);
77
78 if (cardStatus.cardState == CardState::ABSENT) {
79 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
80 }
81 }
82
83 /*
84 * Test IRadio.getNetworkSelectionMode() for the response returned.
85 */
TEST_F(RadioHidlTest,getNetworkSelectionMode)86 TEST_F(RadioHidlTest, getNetworkSelectionMode) {
87 serial = GetRandomSerialNumber();
88
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);
93
94 if (cardStatus.cardState == CardState::ABSENT) {
95 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
96 }
97 }
98
99 /*
100 * Test IRadio.setNetworkSelectionModeAutomatic() for the response returned.
101 */
TEST_F(RadioHidlTest,setNetworkSelectionModeAutomatic)102 TEST_F(RadioHidlTest, setNetworkSelectionModeAutomatic) {
103 serial = GetRandomSerialNumber();
104
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);
109
110 if (cardStatus.cardState == CardState::ABSENT) {
111 ASSERT_TRUE(CheckAnyOfErrors(
112 radioRsp->rspInfo.error,
113 {RadioError::NONE, RadioError::ILLEGAL_SIM_OR_ME, RadioError::OPERATION_NOT_ALLOWED},
114 CHECK_GENERAL_ERROR));
115 }
116 }
117
118 /*
119 * Test IRadio.setNetworkSelectionModeManual() for the response returned.
120 */
TEST_F(RadioHidlTest,setNetworkSelectionModeManual)121 TEST_F(RadioHidlTest, setNetworkSelectionModeManual) {
122 serial = GetRandomSerialNumber();
123
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);
128
129 if (cardStatus.cardState == CardState::ABSENT) {
130 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
131 {RadioError::NONE, RadioError::ILLEGAL_SIM_OR_ME,
132 RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE},
133 CHECK_GENERAL_ERROR));
134 }
135 }
136
137 /*
138 * Test IRadio.getAvailableNetworks() for the response returned.
139 */
TEST_F(RadioHidlTest,getAvailableNetworks)140 TEST_F(RadioHidlTest, getAvailableNetworks) {
141 serial = GetRandomSerialNumber();
142
143 radio->getAvailableNetworks(serial);
144 EXPECT_EQ(std::cv_status::no_timeout, wait(300));
145 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
146 ASSERT_TRUE(radioRsp->rspInfo.type == RadioResponseType::SOLICITED ||
147 radioRsp->rspInfo.type == RadioResponseType::SOLICITED_ACK_EXP);
148
149 if (cardStatus.cardState == CardState::ABSENT) {
150 ASSERT_TRUE(
151 CheckAnyOfErrors(radioRsp->rspInfo.error,
152 {RadioError::NONE, RadioError::CANCELLED, RadioError::DEVICE_IN_USE,
153 RadioError::MODEM_ERR, RadioError::OPERATION_NOT_ALLOWED},
154 CHECK_GENERAL_ERROR));
155 }
156 }
157
158 /*
159 * Test IRadio.getBasebandVersion() for the response returned.
160 */
TEST_F(RadioHidlTest,getBasebandVersion)161 TEST_F(RadioHidlTest, getBasebandVersion) {
162 serial = GetRandomSerialNumber();
163
164 radio->getBasebandVersion(serial);
165 EXPECT_EQ(std::cv_status::no_timeout, wait());
166 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
167 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
168
169 if (cardStatus.cardState == CardState::ABSENT) {
170 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
171 }
172 }
173
174 /*
175 * Test IRadio.setBandMode() for the response returned.
176 */
TEST_F(RadioHidlTest,setBandMode)177 TEST_F(RadioHidlTest, setBandMode) {
178 serial = GetRandomSerialNumber();
179
180 radio->setBandMode(serial, RadioBandMode::BAND_MODE_USA);
181 EXPECT_EQ(std::cv_status::no_timeout, wait());
182 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
183 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
184
185 if (cardStatus.cardState == CardState::ABSENT) {
186 ASSERT_TRUE(
187 CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
188 }
189 }
190
191 /*
192 * Test IRadio.getAvailableBandModes() for the response returned.
193 */
TEST_F(RadioHidlTest,getAvailableBandModes)194 TEST_F(RadioHidlTest, getAvailableBandModes) {
195 serial = GetRandomSerialNumber();
196
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);
201
202 if (cardStatus.cardState == CardState::ABSENT) {
203 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
204 }
205 }
206
207 /*
208 * Test IRadio.setPreferredNetworkType() for the response returned.
209 */
TEST_F(RadioHidlTest,setPreferredNetworkType)210 TEST_F(RadioHidlTest, setPreferredNetworkType) {
211 serial = GetRandomSerialNumber();
212
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);
217
218 if (cardStatus.cardState == CardState::ABSENT) {
219 ASSERT_TRUE(
220 CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
221 }
222 }
223
224 /*
225 * Test IRadio.getPreferredNetworkType() for the response returned.
226 */
TEST_F(RadioHidlTest,getPreferredNetworkType)227 TEST_F(RadioHidlTest, getPreferredNetworkType) {
228 serial = GetRandomSerialNumber();
229
230 radio->getPreferredNetworkType(serial);
231 EXPECT_EQ(std::cv_status::no_timeout, wait());
232 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
233 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
234
235 if (cardStatus.cardState == CardState::ABSENT) {
236 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
237 }
238 }
239
240 /*
241 * Test IRadio.getNeighboringCids() for the response returned.
242 */
TEST_F(RadioHidlTest,getNeighboringCids)243 TEST_F(RadioHidlTest, getNeighboringCids) {
244 serial = GetRandomSerialNumber();
245
246 radio->getNeighboringCids(serial);
247 EXPECT_EQ(std::cv_status::no_timeout, wait());
248 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
249 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
250
251 if (cardStatus.cardState == CardState::ABSENT) {
252 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
253 {RadioError::NONE, RadioError::SIM_ABSENT},
254 CHECK_GENERAL_ERROR));
255 }
256 }
257
258 /*
259 * Test IRadio.setLocationUpdates() for the response returned.
260 */
TEST_F(RadioHidlTest,setLocationUpdates)261 TEST_F(RadioHidlTest, setLocationUpdates) {
262 serial = GetRandomSerialNumber();
263
264 radio->setLocationUpdates(serial, true);
265 EXPECT_EQ(std::cv_status::no_timeout, wait());
266 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
267 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
268
269 if (cardStatus.cardState == CardState::ABSENT) {
270 ASSERT_TRUE(
271 CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE, RadioError::SIM_ABSENT}));
272 }
273 }
274
275 /*
276 * Test IRadio.setCdmaRoamingPreference() for the response returned.
277 */
TEST_F(RadioHidlTest,setCdmaRoamingPreference)278 TEST_F(RadioHidlTest, setCdmaRoamingPreference) {
279 serial = GetRandomSerialNumber();
280
281 radio->setCdmaRoamingPreference(serial, CdmaRoamingType::HOME_NETWORK);
282 EXPECT_EQ(std::cv_status::no_timeout, wait());
283 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
284 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
285
286 if (cardStatus.cardState == CardState::ABSENT) {
287 ASSERT_TRUE(CheckAnyOfErrors(
288 radioRsp->rspInfo.error,
289 {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::REQUEST_NOT_SUPPORTED}));
290 }
291 }
292
293 /*
294 * Test IRadio.getCdmaRoamingPreference() for the response returned.
295 */
TEST_F(RadioHidlTest,getCdmaRoamingPreference)296 TEST_F(RadioHidlTest, getCdmaRoamingPreference) {
297 serial = GetRandomSerialNumber();
298
299 radio->getCdmaRoamingPreference(serial);
300 EXPECT_EQ(std::cv_status::no_timeout, wait());
301 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
302 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
303
304 if (cardStatus.cardState == CardState::ABSENT) {
305 ASSERT_TRUE(
306 CheckAnyOfErrors(radioRsp->rspInfo.error,
307 {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::MODEM_ERR},
308 CHECK_GENERAL_ERROR));
309 }
310 }
311
312 /*
313 * Test IRadio.getTTYMode() for the response returned.
314 */
TEST_F(RadioHidlTest,getTTYMode)315 TEST_F(RadioHidlTest, getTTYMode) {
316 serial = GetRandomSerialNumber();
317
318 radio->getTTYMode(serial);
319 EXPECT_EQ(std::cv_status::no_timeout, wait());
320 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
321 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
322
323 if (cardStatus.cardState == CardState::ABSENT) {
324 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
325 }
326 }
327
328 /*
329 * Test IRadio.setTTYMode() for the response returned.
330 */
TEST_F(RadioHidlTest,setTTYMode)331 TEST_F(RadioHidlTest, setTTYMode) {
332 serial = GetRandomSerialNumber();
333
334 radio->setTTYMode(serial, TtyMode::OFF);
335 EXPECT_EQ(std::cv_status::no_timeout, wait());
336 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
337 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
338
339 if (cardStatus.cardState == CardState::ABSENT) {
340 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
341 }
342 }
343
344 /*
345 * Test IRadio.setPreferredVoicePrivacy() for the response returned.
346 */
TEST_F(RadioHidlTest,setPreferredVoicePrivacy)347 TEST_F(RadioHidlTest, setPreferredVoicePrivacy) {
348 serial = GetRandomSerialNumber();
349
350 radio->setPreferredVoicePrivacy(serial, true);
351 EXPECT_EQ(std::cv_status::no_timeout, wait());
352 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
353 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
354
355 if (cardStatus.cardState == CardState::ABSENT) {
356 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
357 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
358 }
359 }
360
361 /*
362 * Test IRadio.getPreferredVoicePrivacy() for the response returned.
363 */
TEST_F(RadioHidlTest,getPreferredVoicePrivacy)364 TEST_F(RadioHidlTest, getPreferredVoicePrivacy) {
365 serial = GetRandomSerialNumber();
366
367 radio->getPreferredVoicePrivacy(serial);
368 EXPECT_EQ(std::cv_status::no_timeout, wait());
369 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
370 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
371
372 if (cardStatus.cardState == CardState::ABSENT) {
373 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
374 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
375 }
376 }
377
378 /*
379 * Test IRadio.getCDMASubscription() for the response returned.
380 */
TEST_F(RadioHidlTest,getCDMASubscription)381 TEST_F(RadioHidlTest, getCDMASubscription) {
382 serial = GetRandomSerialNumber();
383
384 radio->getCDMASubscription(serial);
385 EXPECT_EQ(std::cv_status::no_timeout, wait());
386 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
387 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
388
389 if (cardStatus.cardState == CardState::ABSENT) {
390 ASSERT_TRUE(CheckAnyOfErrors(
391 radioRsp->rspInfo.error,
392 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
393 }
394 }
395
396 /*
397 * Test IRadio.getDeviceIdentity() for the response returned.
398 */
TEST_F(RadioHidlTest,getDeviceIdentity)399 TEST_F(RadioHidlTest, getDeviceIdentity) {
400 serial = GetRandomSerialNumber();
401
402 radio->getDeviceIdentity(serial);
403 EXPECT_EQ(std::cv_status::no_timeout, wait());
404 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
405 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
406
407 if (cardStatus.cardState == CardState::ABSENT) {
408 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
409 {RadioError::NONE, RadioError::EMPTY_RECORD}));
410 }
411 }
412
413 /*
414 * Test IRadio.exitEmergencyCallbackMode() for the response returned.
415 */
TEST_F(RadioHidlTest,exitEmergencyCallbackMode)416 TEST_F(RadioHidlTest, exitEmergencyCallbackMode) {
417 serial = GetRandomSerialNumber();
418
419 radio->exitEmergencyCallbackMode(serial);
420 EXPECT_EQ(std::cv_status::no_timeout, wait());
421 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
422 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
423
424 if (cardStatus.cardState == CardState::ABSENT) {
425 ASSERT_TRUE(CheckAnyOfErrors(
426 radioRsp->rspInfo.error,
427 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
428 }
429 }
430
431 /*
432 * Test IRadio.getCdmaSubscriptionSource() for the response returned.
433 */
TEST_F(RadioHidlTest,getCdmaSubscriptionSource)434 TEST_F(RadioHidlTest, getCdmaSubscriptionSource) {
435 serial = GetRandomSerialNumber();
436
437 radio->getCdmaSubscriptionSource(serial);
438 EXPECT_EQ(std::cv_status::no_timeout, wait());
439 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
440 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
441
442 if (cardStatus.cardState == CardState::ABSENT) {
443 ASSERT_TRUE(CheckAnyOfErrors(
444 radioRsp->rspInfo.error,
445 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
446 }
447 }
448
449 /*
450 * Test IRadio.setCdmaSubscriptionSource() for the response returned.
451 */
TEST_F(RadioHidlTest,setCdmaSubscriptionSource)452 TEST_F(RadioHidlTest, setCdmaSubscriptionSource) {
453 serial = GetRandomSerialNumber();
454
455 radio->setCdmaSubscriptionSource(serial, CdmaSubscriptionSource::RUIM_SIM);
456 EXPECT_EQ(std::cv_status::no_timeout, wait());
457 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
458 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
459
460 if (cardStatus.cardState == CardState::ABSENT) {
461 ASSERT_TRUE(CheckAnyOfErrors(
462 radioRsp->rspInfo.error,
463 {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::SUBSCRIPTION_NOT_AVAILABLE},
464 CHECK_GENERAL_ERROR));
465 }
466 }
467
468 /*
469 * Test IRadio.getVoiceRadioTechnology() for the response returned.
470 */
TEST_F(RadioHidlTest,getVoiceRadioTechnology)471 TEST_F(RadioHidlTest, getVoiceRadioTechnology) {
472 serial = GetRandomSerialNumber();
473
474 radio->getVoiceRadioTechnology(serial);
475 EXPECT_EQ(std::cv_status::no_timeout, wait());
476 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
477 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
478
479 if (cardStatus.cardState == CardState::ABSENT) {
480 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
481 }
482 }
483
484 /*
485 * Test IRadio.getCellInfoList() for the response returned.
486 */
TEST_F(RadioHidlTest,getCellInfoList)487 TEST_F(RadioHidlTest, getCellInfoList) {
488 serial = GetRandomSerialNumber();
489
490 radio->getCellInfoList(serial);
491 EXPECT_EQ(std::cv_status::no_timeout, wait());
492 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
493 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
494
495 if (cardStatus.cardState == CardState::ABSENT) {
496 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
497 {RadioError::NONE, RadioError::NO_NETWORK_FOUND},
498 CHECK_GENERAL_ERROR));
499 }
500 }
501
502 /*
503 * Test IRadio.setCellInfoListRate() for the response returned.
504 */
TEST_F(RadioHidlTest,setCellInfoListRate)505 TEST_F(RadioHidlTest, setCellInfoListRate) {
506 serial = GetRandomSerialNumber();
507
508 // TODO(sanketpadawe): RIL crashes with value of rate = 10
509 radio->setCellInfoListRate(serial, 10);
510 EXPECT_EQ(std::cv_status::no_timeout, wait());
511 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
512 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
513
514 if (cardStatus.cardState == CardState::ABSENT) {
515 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
516 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
517 }
518 }
519
520 /*
521 * Test IRadio.nvReadItem() for the response returned.
522 */
TEST_F(RadioHidlTest,nvReadItem)523 TEST_F(RadioHidlTest, nvReadItem) {
524 serial = GetRandomSerialNumber();
525
526 radio->nvReadItem(serial, NvItem::LTE_BAND_ENABLE_25);
527 EXPECT_EQ(std::cv_status::no_timeout, wait());
528 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
529 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
530
531 if (cardStatus.cardState == CardState::ABSENT) {
532 ASSERT_TRUE(
533 CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
534 }
535 }
536
537 /*
538 * Test IRadio.nvWriteItem() for the response returned.
539 */
TEST_F(RadioHidlTest,nvWriteItem)540 TEST_F(RadioHidlTest, nvWriteItem) {
541 serial = GetRandomSerialNumber();
542 NvWriteItem item;
543 memset(&item, 0, sizeof(item));
544 item.value = hidl_string();
545
546 radio->nvWriteItem(serial, item);
547 EXPECT_EQ(std::cv_status::no_timeout, wait());
548 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
549 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
550
551 if (cardStatus.cardState == CardState::ABSENT) {
552 ASSERT_TRUE(
553 CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
554 }
555 }
556
557 /*
558 * Test IRadio.nvWriteCdmaPrl() for the response returned.
559 */
TEST_F(RadioHidlTest,nvWriteCdmaPrl)560 TEST_F(RadioHidlTest, nvWriteCdmaPrl) {
561 serial = GetRandomSerialNumber();
562 std::vector<uint8_t> prl = {1, 2, 3, 4, 5};
563
564 radio->nvWriteCdmaPrl(serial, hidl_vec<uint8_t>(prl));
565 EXPECT_EQ(std::cv_status::no_timeout, wait());
566 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
567 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
568
569 if (cardStatus.cardState == CardState::ABSENT) {
570 ASSERT_TRUE(
571 CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
572 }
573 }
574
575 /*
576 * Test IRadio.nvResetConfig() for the response returned.
577 */
TEST_F(RadioHidlTest,nvResetConfig)578 TEST_F(RadioHidlTest, nvResetConfig) {
579 serial = GetRandomSerialNumber();
580
581 radio->nvResetConfig(serial, ResetNvType::ERASE);
582 EXPECT_EQ(std::cv_status::no_timeout, wait());
583 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
584 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
585
586 if (cardStatus.cardState == CardState::ABSENT) {
587 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
588 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
589 }
590 }
591
592 /*
593 * Test IRadio.setUiccSubscription() for the response returned.
594 */
TEST_F(RadioHidlTest,setUiccSubscription)595 TEST_F(RadioHidlTest, setUiccSubscription) {
596 serial = GetRandomSerialNumber();
597 SelectUiccSub item;
598 memset(&item, 0, sizeof(item));
599
600 radio->setUiccSubscription(serial, item);
601 EXPECT_EQ(std::cv_status::no_timeout, wait());
602 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
603 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
604
605 if (cardStatus.cardState == CardState::ABSENT) {
606 ASSERT_TRUE(
607 CheckAnyOfErrors(radioRsp->rspInfo.error,
608 {RadioError::NONE, RadioError::INVALID_ARGUMENTS,
609 RadioError::MODEM_ERR, RadioError::SUBSCRIPTION_NOT_SUPPORTED},
610 CHECK_GENERAL_ERROR));
611 }
612 }
613
614 /*
615 * Test IRadio.getHardwareConfig() for the response returned.
616 */
TEST_F(RadioHidlTest,getHardwareConfig)617 TEST_F(RadioHidlTest, getHardwareConfig) {
618 serial = GetRandomSerialNumber();
619
620 radio->getHardwareConfig(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);
624
625 if (cardStatus.cardState == CardState::ABSENT) {
626 ASSERT_TRUE(
627 CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
628 }
629 }
630
631 /*
632 * Test IRadio.requestShutdown() for the response returned.
633 */
TEST_F(RadioHidlTest,requestShutdown)634 TEST_F(RadioHidlTest, requestShutdown) {
635 serial = GetRandomSerialNumber();
636
637 radio->requestShutdown(serial);
638 EXPECT_EQ(std::cv_status::no_timeout, wait());
639 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
640 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
641
642 if (cardStatus.cardState == CardState::ABSENT) {
643 ASSERT_TRUE(
644 CheckAnyOfErrors(radioRsp->rspInfo.error, {RadioError::NONE}, CHECK_GENERAL_ERROR));
645 }
646 }
647
648 /*
649 * Test IRadio.getRadioCapability() for the response returned.
650 */
TEST_F(RadioHidlTest,getRadioCapability)651 TEST_F(RadioHidlTest, getRadioCapability) {
652 serial = GetRandomSerialNumber();
653
654 radio->getRadioCapability(serial);
655 EXPECT_EQ(std::cv_status::no_timeout, wait());
656 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
657 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
658
659 if (cardStatus.cardState == CardState::ABSENT) {
660 EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
661 }
662 }
663
664 /*
665 * Test IRadio.setRadioCapability() for the response returned.
666 */
TEST_F(RadioHidlTest,setRadioCapability)667 TEST_F(RadioHidlTest, setRadioCapability) {
668 serial = GetRandomSerialNumber();
669 RadioCapability rc;
670 memset(&rc, 0, sizeof(rc));
671 rc.logicalModemUuid = hidl_string();
672
673 radio->setRadioCapability(serial, rc);
674 EXPECT_EQ(std::cv_status::no_timeout, wait());
675 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
676 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
677
678 if (cardStatus.cardState == CardState::ABSENT) {
679 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
680 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE},
681 CHECK_GENERAL_ERROR));
682 }
683 }
684
685 /*
686 * Test IRadio.startLceService() for the response returned.
687 */
TEST_F(RadioHidlTest,startLceService)688 TEST_F(RadioHidlTest, startLceService) {
689 serial = GetRandomSerialNumber();
690
691 radio->startLceService(serial, 5, true);
692 EXPECT_EQ(std::cv_status::no_timeout, wait());
693 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
694 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
695
696 if (cardStatus.cardState == CardState::ABSENT) {
697 ASSERT_TRUE(CheckAnyOfErrors(
698 radioRsp->rspInfo.error,
699 {RadioError::INTERNAL_ERR, RadioError::LCE_NOT_SUPPORTED,
700 RadioError::RADIO_NOT_AVAILABLE, RadioError::SIM_ABSENT, RadioError::NONE}));
701 }
702 }
703
704 /*
705 * Test IRadio.stopLceService() for the response returned.
706 */
TEST_F(RadioHidlTest,stopLceService)707 TEST_F(RadioHidlTest, stopLceService) {
708 serial = GetRandomSerialNumber();
709
710 radio->stopLceService(serial);
711 EXPECT_EQ(std::cv_status::no_timeout, wait());
712 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
713 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
714
715 if (cardStatus.cardState == CardState::ABSENT) {
716 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
717 {RadioError::NONE, RadioError::LCE_NOT_SUPPORTED,
718 RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
719 }
720 }
721
722 /*
723 * Test IRadio.pullLceData() for the response returned.
724 */
TEST_F(RadioHidlTest,pullLceData)725 TEST_F(RadioHidlTest, pullLceData) {
726 serial = GetRandomSerialNumber();
727
728 radio->pullLceData(serial);
729 EXPECT_EQ(std::cv_status::no_timeout, wait());
730 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
731 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
732
733 if (cardStatus.cardState == CardState::ABSENT) {
734 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
735 {RadioError::NONE, RadioError::INTERNAL_ERR,
736 RadioError::RADIO_NOT_AVAILABLE, RadioError::SIM_ABSENT},
737 CHECK_OEM_ERROR));
738 }
739 }
740
741 /*
742 * Test IRadio.getModemActivityInfo() for the response returned.
743 */
TEST_F(RadioHidlTest,getModemActivityInfo)744 TEST_F(RadioHidlTest, getModemActivityInfo) {
745 serial = GetRandomSerialNumber();
746
747 radio->getModemActivityInfo(serial);
748 EXPECT_EQ(std::cv_status::no_timeout, wait());
749 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
750 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
751
752 if (cardStatus.cardState == CardState::ABSENT) {
753 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
754 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
755 }
756 }
757
758 /*
759 * Test IRadio.setAllowedCarriers() for the response returned.
760 */
TEST_F(RadioHidlTest,setAllowedCarriers)761 TEST_F(RadioHidlTest, setAllowedCarriers) {
762 serial = GetRandomSerialNumber();
763 CarrierRestrictions carriers;
764 memset(&carriers, 0, sizeof(carriers));
765 carriers.allowedCarriers.resize(1);
766 carriers.excludedCarriers.resize(0);
767 carriers.allowedCarriers[0].mcc = hidl_string();
768 carriers.allowedCarriers[0].mnc = hidl_string();
769 carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
770 carriers.allowedCarriers[0].matchData = hidl_string();
771
772 radio->setAllowedCarriers(serial, false, carriers);
773 EXPECT_EQ(std::cv_status::no_timeout, wait());
774 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
775 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
776
777 if (cardStatus.cardState == CardState::ABSENT) {
778 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
779 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
780 }
781
782 if (radioRsp->rspInfo.error == RadioError::NONE) {
783 /* Setting to carrier restriction needs some time */
784 updateSimCardStatus();
785 auto startTime = std::chrono::system_clock::now();
786 while (cardStatus.cardState != CardState::RESTRICTED &&
787 std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() -
788 startTime)
789 .count() < 10) {
790 /* Set 2 seconds as interval to check card status */
791 sleep(2);
792 updateSimCardStatus();
793 }
794 EXPECT_EQ(CardState::RESTRICTED, cardStatus.cardState);
795 }
796 sleep(10);
797
798 /**
799 * Another test case of the API to cover to allow carrier.
800 * If the API is supported, this is also used to reset to no carrier restriction
801 * status for cardStatus.
802 */
803 memset(&carriers, 0, sizeof(carriers));
804 carriers.allowedCarriers.resize(0);
805 carriers.excludedCarriers.resize(0);
806
807 serial = GetRandomSerialNumber();
808 radio->setAllowedCarriers(serial, true, carriers);
809 EXPECT_EQ(std::cv_status::no_timeout, wait());
810 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
811 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
812
813 if (cardStatus.cardState == CardState::ABSENT) {
814 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
815 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
816 }
817
818 if (radioRsp->rspInfo.error == RadioError::NONE) {
819 /* Resetting back to no carrier restriction needs some time */
820 updateSimCardStatus();
821 auto startTime = std::chrono::system_clock::now();
822 while (cardStatus.cardState == CardState::RESTRICTED &&
823 std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() -
824 startTime)
825 .count() < 10) {
826 /* Set 2 seconds as interval to check card status */
827 sleep(2);
828 updateSimCardStatus();
829 }
830 EXPECT_NE(CardState::RESTRICTED, cardStatus.cardState);
831 sleep(10);
832 }
833 }
834
835 /*
836 * Test IRadio.getAllowedCarriers() for the response returned.
837 */
TEST_F(RadioHidlTest,getAllowedCarriers)838 TEST_F(RadioHidlTest, getAllowedCarriers) {
839 serial = GetRandomSerialNumber();
840
841 radio->getAllowedCarriers(serial);
842 EXPECT_EQ(std::cv_status::no_timeout, wait());
843 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
844 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
845
846 if (cardStatus.cardState == CardState::ABSENT) {
847 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
848 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
849 }
850 }
851
852 /*
853 * Test IRadio.sendDeviceState() for the response returned.
854 */
TEST_F(RadioHidlTest,sendDeviceState)855 TEST_F(RadioHidlTest, sendDeviceState) {
856 serial = GetRandomSerialNumber();
857
858 radio->sendDeviceState(serial, DeviceStateType::POWER_SAVE_MODE, true);
859 EXPECT_EQ(std::cv_status::no_timeout, wait());
860 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
861 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
862
863 std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
864
865 if (cardStatus.cardState == CardState::ABSENT) {
866 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
867 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
868 }
869 }
870
871 /*
872 * Test IRadio.setIndicationFilter() for the response returned.
873 */
TEST_F(RadioHidlTest,setIndicationFilter)874 TEST_F(RadioHidlTest, setIndicationFilter) {
875 serial = GetRandomSerialNumber();
876
877 radio->setIndicationFilter(serial, 1);
878 EXPECT_EQ(std::cv_status::no_timeout, wait());
879 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
880 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
881
882 std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
883
884 if (cardStatus.cardState == CardState::ABSENT) {
885 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
886 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
887 }
888 }
889
890 /*
891 * Test IRadio.setSimCardPower() for the response returned.
892 */
TEST_F(RadioHidlTest,setSimCardPower)893 TEST_F(RadioHidlTest, setSimCardPower) {
894 serial = GetRandomSerialNumber();
895
896 radio->setSimCardPower(serial, true);
897 EXPECT_EQ(std::cv_status::no_timeout, wait());
898 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
899 EXPECT_EQ(serial, radioRsp->rspInfo.serial);
900
901 if (cardStatus.cardState == CardState::ABSENT) {
902 ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
903 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
904 }
905 }
906