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