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 */
22TEST_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 */
38TEST_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 */
54TEST_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 */
70TEST_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 */
86TEST_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 */
102TEST_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 */
121TEST_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 */
140TEST_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 */
161TEST_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 */
177TEST_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 */
194TEST_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 */
210TEST_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 */
227TEST_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 */
243TEST_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 */
261TEST_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 */
278TEST_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 */
296TEST_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 */
315TEST_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 */
331TEST_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 */
347TEST_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 */
364TEST_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 */
381TEST_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 */
399TEST_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 */
416TEST_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 */
434TEST_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 */
452TEST_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 */
471TEST_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 */
487TEST_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 */
505TEST_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 */
523TEST_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 */
540TEST_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 */
560TEST_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 */
578TEST_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 */
595TEST_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 */
617TEST_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 */
634TEST_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 */
651TEST_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 */
667TEST_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 */
688TEST_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(radioRsp->rspInfo.error,
698                                     {RadioError::INTERNAL_ERR, RadioError::LCE_NOT_SUPPORTED,
699                                      RadioError::RADIO_NOT_AVAILABLE, RadioError::SIM_ABSENT}));
700    }
701}
702
703/*
704 * Test IRadio.stopLceService() for the response returned.
705 */
706TEST_F(RadioHidlTest, stopLceService) {
707    serial = GetRandomSerialNumber();
708
709    radio->stopLceService(serial);
710    EXPECT_EQ(std::cv_status::no_timeout, wait());
711    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
712    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
713
714    if (cardStatus.cardState == CardState::ABSENT) {
715        ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
716                                     {RadioError::NONE, RadioError::LCE_NOT_SUPPORTED,
717                                      RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
718    }
719}
720
721/*
722 * Test IRadio.pullLceData() for the response returned.
723 */
724TEST_F(RadioHidlTest, pullLceData) {
725    serial = GetRandomSerialNumber();
726
727    radio->pullLceData(serial);
728    EXPECT_EQ(std::cv_status::no_timeout, wait());
729    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
730    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
731
732    if (cardStatus.cardState == CardState::ABSENT) {
733        ASSERT_TRUE(CheckAnyOfErrors(
734            radioRsp->rspInfo.error,
735            {RadioError::NONE, RadioError::INTERNAL_ERR, RadioError::RADIO_NOT_AVAILABLE},
736            CHECK_OEM_ERROR));
737    }
738}
739
740/*
741 * Test IRadio.getModemActivityInfo() for the response returned.
742 */
743TEST_F(RadioHidlTest, getModemActivityInfo) {
744    serial = GetRandomSerialNumber();
745
746    radio->getModemActivityInfo(serial);
747    EXPECT_EQ(std::cv_status::no_timeout, wait());
748    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
749    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
750
751    if (cardStatus.cardState == CardState::ABSENT) {
752        ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
753                                     {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
754    }
755}
756
757/*
758 * Test IRadio.setAllowedCarriers() for the response returned.
759 */
760TEST_F(RadioHidlTest, setAllowedCarriers) {
761    serial = GetRandomSerialNumber();
762    CarrierRestrictions carriers;
763    memset(&carriers, 0, sizeof(carriers));
764    carriers.allowedCarriers.resize(1);
765    carriers.excludedCarriers.resize(0);
766    carriers.allowedCarriers[0].mcc = hidl_string();
767    carriers.allowedCarriers[0].mnc = hidl_string();
768    carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
769    carriers.allowedCarriers[0].matchData = hidl_string();
770
771    radio->setAllowedCarriers(serial, false, carriers);
772    EXPECT_EQ(std::cv_status::no_timeout, wait());
773    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
774    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
775
776    if (cardStatus.cardState == CardState::ABSENT) {
777        ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
778                                     {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
779    }
780
781    /* Setting to carrier restriction needs some time */
782    updateSimCardStatus();
783    auto startTime = std::chrono::system_clock::now();
784    while (cardStatus.cardState != CardState::RESTRICTED &&
785           std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() - startTime)
786                   .count() < 10) {
787        /* Set 2 seconds as interval to check card status */
788        sleep(2);
789        updateSimCardStatus();
790    }
791    EXPECT_EQ(CardState::RESTRICTED, cardStatus.cardState);
792    sleep(10);
793
794    /* Reset back to no carrier restriction */
795    memset(&carriers, 0, sizeof(carriers));
796    carriers.allowedCarriers.resize(0);
797    carriers.excludedCarriers.resize(0);
798
799    serial = GetRandomSerialNumber();
800    radio->setAllowedCarriers(serial, true, carriers);
801    EXPECT_EQ(std::cv_status::no_timeout, wait());
802    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
803    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
804
805    if (cardStatus.cardState == CardState::ABSENT) {
806        ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
807                                     {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
808    }
809
810    /* Resetting back to no carrier restriction needs some time */
811    updateSimCardStatus();
812    startTime = std::chrono::system_clock::now();
813    while (cardStatus.cardState == CardState::RESTRICTED &&
814           std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() - startTime)
815                   .count() < 10) {
816        /* Set 2 seconds as interval to check card status */
817        sleep(2);
818        updateSimCardStatus();
819    }
820    EXPECT_NE(CardState::RESTRICTED, cardStatus.cardState);
821    sleep(10);
822}
823
824/*
825 * Test IRadio.getAllowedCarriers() for the response returned.
826 */
827TEST_F(RadioHidlTest, getAllowedCarriers) {
828    serial = GetRandomSerialNumber();
829
830    radio->getAllowedCarriers(serial);
831    EXPECT_EQ(std::cv_status::no_timeout, wait());
832    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
833    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
834
835    if (cardStatus.cardState == CardState::ABSENT) {
836        ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
837                                     {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
838    }
839}
840
841/*
842 * Test IRadio.sendDeviceState() for the response returned.
843 */
844TEST_F(RadioHidlTest, sendDeviceState) {
845    serial = GetRandomSerialNumber();
846
847    radio->sendDeviceState(serial, DeviceStateType::POWER_SAVE_MODE, 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);
851
852    std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
853
854    if (cardStatus.cardState == CardState::ABSENT) {
855        ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
856                                     {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
857    }
858}
859
860/*
861 * Test IRadio.setIndicationFilter() for the response returned.
862 */
863TEST_F(RadioHidlTest, setIndicationFilter) {
864    serial = GetRandomSerialNumber();
865
866    radio->setIndicationFilter(serial, 1);
867    EXPECT_EQ(std::cv_status::no_timeout, wait());
868    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
869    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
870
871    std::cout << static_cast<int>(radioRsp->rspInfo.error) << std::endl;
872
873    if (cardStatus.cardState == CardState::ABSENT) {
874        ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
875                                     {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
876    }
877}
878
879/*
880 * Test IRadio.setSimCardPower() for the response returned.
881 */
882TEST_F(RadioHidlTest, setSimCardPower) {
883    serial = GetRandomSerialNumber();
884
885    radio->setSimCardPower(serial, true);
886    EXPECT_EQ(std::cv_status::no_timeout, wait());
887    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
888    EXPECT_EQ(serial, radioRsp->rspInfo.serial);
889
890    if (cardStatus.cardState == CardState::ABSENT) {
891        ASSERT_TRUE(CheckAnyOfErrors(radioRsp->rspInfo.error,
892                                     {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
893    }
894}
895