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