1 /*
2  * Copyright (C) 2018 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_4.h>
18 
19 #define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
20 
21 namespace {
22 const RadioAccessSpecifier GERAN_SPECIFIER_P900 = {.radioAccessNetwork = RadioAccessNetworks::GERAN,
23                                                    .geranBands = {GeranBands::BAND_P900},
24                                                    .channels = {1, 2}};
25 const RadioAccessSpecifier GERAN_SPECIFIER_850 = {.radioAccessNetwork = RadioAccessNetworks::GERAN,
26                                                   .geranBands = {GeranBands::BAND_850},
27                                                   .channels = {128, 129}};
28 }  // namespace
29 
30 /*
31  * Test IRadio.emergencyDial() for the response returned.
32  */
TEST_P(RadioHidlTest_v1_4,emergencyDial)33 TEST_P(RadioHidlTest_v1_4, emergencyDial) {
34     if (!deviceSupportsFeature(FEATURE_VOICE_CALL)) {
35         ALOGI("Skipping emergencyDial because voice call is not supported in device");
36         return;
37     } else if (!deviceSupportsFeature(FEATURE_TELEPHONY_GSM) &&
38                !deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
39         ALOGI("Skipping emergencyDial because gsm/cdma radio is not supported in device");
40         return;
41     } else {
42         ALOGI("Running emergencyDial because voice call is supported in device");
43     }
44 
45     serial = GetRandomSerialNumber();
46 
47     ::android::hardware::radio::V1_0::Dial dialInfo;
48     dialInfo.address = hidl_string("911");
49     int categories = static_cast<int>(
50             ::android::hardware::radio::V1_4::EmergencyServiceCategory::UNSPECIFIED);
51     std::vector<hidl_string> urns = {""};
52     ::android::hardware::radio::V1_4::EmergencyCallRouting routing =
53             ::android::hardware::radio::V1_4::EmergencyCallRouting::UNKNOWN;
54 
55     Return<void> res =
56             radio_v1_4->emergencyDial(serial, dialInfo, categories, urns, routing, true, true);
57     ASSERT_OK(res);
58     EXPECT_EQ(std::cv_status::no_timeout, wait());
59     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
60     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
61 
62     ALOGI("emergencyDial, rspInfo.error = %s\n", toString(radioRsp_v1_4->rspInfo.error).c_str());
63 
64     ::android::hardware::radio::V1_0::RadioError rspEmergencyDial = radioRsp_v1_4->rspInfo.error;
65     // In DSDS or TSTS, we only check the result if the current slot is IN_SERVICE
66     // or Emergency_Only.
67     if (isDsDsEnabled() || isTsTsEnabled()) {
68         serial = GetRandomSerialNumber();
69         radio_v1_4->getVoiceRegistrationState(serial);
70         EXPECT_EQ(std::cv_status::no_timeout, wait());
71         if (isVoiceEmergencyOnly(radioRsp_v1_4->voiceRegResp.regState) ||
72             isVoiceInService(radioRsp_v1_4->voiceRegResp.regState)) {
73             EXPECT_EQ(RadioError::NONE, rspEmergencyDial);
74         }
75     } else {
76         EXPECT_EQ(RadioError::NONE, rspEmergencyDial);
77     }
78 
79     // Give some time for modem to establish the emergency call channel.
80     sleep(MODEM_EMERGENCY_CALL_ESTABLISH_TIME);
81 
82     // Disconnect all the potential established calls to prevent them affecting other tests.
83     clearPotentialEstablishedCalls();
84 }
85 
86 /*
87  * Test IRadio.emergencyDial() with specified service and its response returned.
88  */
TEST_P(RadioHidlTest_v1_4,emergencyDial_withServices)89 TEST_P(RadioHidlTest_v1_4, emergencyDial_withServices) {
90     if (!deviceSupportsFeature(FEATURE_VOICE_CALL)) {
91         ALOGI("Skipping emergencyDial because voice call is not supported in device");
92         return;
93     } else if (!deviceSupportsFeature(FEATURE_TELEPHONY_GSM) &&
94                !deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
95         ALOGI("Skipping emergencyDial because gsm/cdma radio is not supported in device");
96         return;
97     } else {
98         ALOGI("Running emergencyDial because voice call is supported in device");
99     }
100 
101     serial = GetRandomSerialNumber();
102 
103     ::android::hardware::radio::V1_0::Dial dialInfo;
104     dialInfo.address = hidl_string("911");
105     int categories =
106             static_cast<int>(::android::hardware::radio::V1_4::EmergencyServiceCategory::AMBULANCE);
107     std::vector<hidl_string> urns = {"urn:service:sos.ambulance"};
108     ::android::hardware::radio::V1_4::EmergencyCallRouting routing =
109             ::android::hardware::radio::V1_4::EmergencyCallRouting::UNKNOWN;
110 
111     Return<void> res =
112             radio_v1_4->emergencyDial(serial, dialInfo, categories, urns, routing, true, true);
113     ASSERT_OK(res);
114     EXPECT_EQ(std::cv_status::no_timeout, wait());
115     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
116     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
117 
118     ALOGI("emergencyDial_withServices, rspInfo.error = %s\n",
119           toString(radioRsp_v1_4->rspInfo.error).c_str());
120     ::android::hardware::radio::V1_0::RadioError rspEmergencyDial = radioRsp_v1_4->rspInfo.error;
121 
122     // In DSDS or TSTS, we only check the result if the current slot is IN_SERVICE
123     // or Emergency_Only.
124     if (isDsDsEnabled() || isTsTsEnabled()) {
125         serial = GetRandomSerialNumber();
126         radio_v1_4->getVoiceRegistrationState(serial);
127         EXPECT_EQ(std::cv_status::no_timeout, wait());
128         if (isVoiceEmergencyOnly(radioRsp_v1_4->voiceRegResp.regState) ||
129             isVoiceInService(radioRsp_v1_4->voiceRegResp.regState)) {
130             EXPECT_EQ(RadioError::NONE, rspEmergencyDial);
131         }
132     } else {
133         EXPECT_EQ(RadioError::NONE, rspEmergencyDial);
134     }
135     // Give some time for modem to establish the emergency call channel.
136     sleep(MODEM_EMERGENCY_CALL_ESTABLISH_TIME);
137 
138     // Disconnect all the potential established calls to prevent them affecting other tests.
139     clearPotentialEstablishedCalls();
140 }
141 
142 /*
143  * Test IRadio.emergencyDial() with known emergency call routing and its response returned.
144  */
TEST_P(RadioHidlTest_v1_4,emergencyDial_withEmergencyRouting)145 TEST_P(RadioHidlTest_v1_4, emergencyDial_withEmergencyRouting) {
146     if (!deviceSupportsFeature(FEATURE_VOICE_CALL)) {
147         ALOGI("Skipping emergencyDial because voice call is not supported in device");
148         return;
149     } else if (!deviceSupportsFeature(FEATURE_TELEPHONY_GSM) &&
150                !deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
151         ALOGI("Skipping emergencyDial because gsm/cdma radio is not supported in device");
152         return;
153     } else {
154         ALOGI("Running emergencyDial because voice call is supported in device");
155     }
156 
157     serial = GetRandomSerialNumber();
158 
159     ::android::hardware::radio::V1_0::Dial dialInfo;
160     dialInfo.address = hidl_string("911");
161     int categories = static_cast<int>(
162             ::android::hardware::radio::V1_4::EmergencyServiceCategory::UNSPECIFIED);
163     std::vector<hidl_string> urns = {""};
164     ::android::hardware::radio::V1_4::EmergencyCallRouting routing =
165             ::android::hardware::radio::V1_4::EmergencyCallRouting::EMERGENCY;
166 
167     Return<void> res =
168             radio_v1_4->emergencyDial(serial, dialInfo, categories, urns, routing, true, true);
169     ASSERT_OK(res);
170     EXPECT_EQ(std::cv_status::no_timeout, wait());
171     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
172     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
173 
174     ALOGI("emergencyDial_withEmergencyRouting, rspInfo.error = %s\n",
175           toString(radioRsp_v1_4->rspInfo.error).c_str());
176     ::android::hardware::radio::V1_0::RadioError rspEmergencyDial = radioRsp_v1_4->rspInfo.error;
177 
178     // In DSDS or TSTS, we only check the result if the current slot is IN_SERVICE
179     // or Emergency_Only.
180     if (isDsDsEnabled() || isTsTsEnabled()) {
181         serial = GetRandomSerialNumber();
182         radio_v1_4->getVoiceRegistrationState(serial);
183         EXPECT_EQ(std::cv_status::no_timeout, wait());
184         if (isVoiceEmergencyOnly(radioRsp_v1_4->voiceRegResp.regState) ||
185             isVoiceInService(radioRsp_v1_4->voiceRegResp.regState)) {
186             EXPECT_EQ(RadioError::NONE, rspEmergencyDial);
187         }
188     } else {
189         EXPECT_EQ(RadioError::NONE, rspEmergencyDial);
190     }
191 
192     // Give some time for modem to establish the emergency call channel.
193     sleep(MODEM_EMERGENCY_CALL_ESTABLISH_TIME);
194 
195     // Disconnect all the potential established calls to prevent them affecting other tests.
196     clearPotentialEstablishedCalls();
197 }
198 
199 /*
200  * Test IRadio.getPreferredNetworkTypeBitmap() for the response returned.
201  */
TEST_P(RadioHidlTest_v1_4,getPreferredNetworkTypeBitmap)202 TEST_P(RadioHidlTest_v1_4, getPreferredNetworkTypeBitmap) {
203     serial = GetRandomSerialNumber();
204 
205     Return<void> res = radio_v1_4->getPreferredNetworkTypeBitmap(serial);
206 
207     ASSERT_OK(res);
208     EXPECT_EQ(std::cv_status::no_timeout, wait());
209     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
210     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
211     ALOGI("getPreferredNetworkTypeBitmap, rspInfo.error = %s\n",
212           toString(radioRsp_v1_4->rspInfo.error).c_str());
213     EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
214 }
215 
TEST_P(RadioHidlTest_v1_4,setPreferredNetworkTypeBitmap)216 TEST_P(RadioHidlTest_v1_4, setPreferredNetworkTypeBitmap) {
217     serial = GetRandomSerialNumber();
218     ::android::hardware::hidl_bitfield<::android::hardware::radio::V1_4::RadioAccessFamily>
219             network_type_bitmap{};
220 
221     network_type_bitmap |= ::android::hardware::radio::V1_4::RadioAccessFamily::LTE;
222 
223     // TODO(b/131634656): LTE_CA will be sent to modem as a RAF in Q, but LTE_CA is not a RAF,
224     // we will not send it to modem as a RAF in R.
225     network_type_bitmap |= ::android::hardware::radio::V1_4::RadioAccessFamily::LTE_CA;
226 
227     Return<void> res = radio_v1_4->setPreferredNetworkTypeBitmap(serial, network_type_bitmap);
228 
229     ASSERT_OK(res);
230     EXPECT_EQ(std::cv_status::no_timeout, wait());
231     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
232     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
233     ALOGI("setPreferredNetworkTypeBitmap, rspInfo.error = %s\n",
234           toString(radioRsp_v1_4->rspInfo.error).c_str());
235     EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
236     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
237          // give some time for modem to set the value.
238         sleep(3);
239         serial = GetRandomSerialNumber();
240         Return<void> res = radio_v1_4->getPreferredNetworkTypeBitmap(serial);
241 
242         ASSERT_OK(res);
243         EXPECT_EQ(std::cv_status::no_timeout, wait());
244         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
245         EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
246         ALOGI("getPreferredNetworkTypeBitmap, rspInfo.error = %s\n",
247               toString(radioRsp_v1_4->rspInfo.error).c_str());
248         EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
249         EXPECT_EQ(network_type_bitmap, radioRsp_v1_4->networkTypeBitmapResponse);
250     }
251 }
252 
253 /*
254  * Test IRadio.startNetworkScan() for the response returned.
255  *
256  * REQUEST_NOT_SUPPORTED is temporarily returned because of vendors failed to fully implement
257  * startNetworkScan in HAL @1.4 (see b/137298570 and b/135595082). Starting from @1.5, however,
258  * REQUEST_NOT_SUPPORTED will be disallowed for all tests. Modems have "GSM" rat scan need to
259  * support scanning requests combined with some parameters.
260  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan)261 TEST_P(RadioHidlTest_v1_4, startNetworkScan) {
262     serial = GetRandomSerialNumber();
263 
264     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
265             .type = ScanType::ONE_SHOT,
266             .interval = 60,
267             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
268             .maxSearchTime = 60,
269             .incrementalResults = false,
270             .incrementalResultsPeriodicity = 1};
271 
272     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
273     ASSERT_OK(res);
274     EXPECT_EQ(std::cv_status::no_timeout, wait());
275     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
276     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
277 
278     ALOGI("startNetworkScan, rspInfo.error = %s\n", toString(radioRsp_v1_4->rspInfo.error).c_str());
279 
280     if (cardStatus.base.base.cardState == CardState::ABSENT) {
281         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error, {RadioError::SIM_ABSENT}));
282     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
283       // OPERATION_NOT_ALLOWED should not be allowed; however, some vendors do
284       // not support the required manual GSM search functionality. This is
285       // tracked in b/112206766. REQUEST_NOT_SUPPORTED is temporarily added back
286       // because of vendors failed to implement startNetworkScan in HAL 1.4 (see
287       // b/137298570 and b/135595082). Starting from 1.5, however,
288       // REQUEST_NOT_SUPPORTED will be disallowed. Modems have "GSM" rat scan
289       // need to support scanning requests combined with some parameters.
290       ASSERT_TRUE(
291           CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
292                            {RadioError::NONE, RadioError::OPERATION_NOT_ALLOWED,
293                             RadioError::REQUEST_NOT_SUPPORTED}));
294     }
295 
296     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
297         ALOGI("Stop Network Scan");
298         stopNetworkScan();
299     }
300 }
301 
302 /*
303  * Test IRadio.startNetworkScan() with invalid specifier.
304  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidArgument)305 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidArgument) {
306     serial = GetRandomSerialNumber();
307 
308     ::android::hardware::radio::V1_2::NetworkScanRequest request = {.type = ScanType::ONE_SHOT,
309                                                                     .interval = 60};
310 
311     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
312 
313     ASSERT_OK(res);
314     EXPECT_EQ(std::cv_status::no_timeout, wait());
315     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
316     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
317 
318     ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
319           toString(radioRsp_v1_4->rspInfo.error).c_str());
320     if (cardStatus.base.base.cardState == CardState::ABSENT) {
321         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
322                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
323     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
324       ASSERT_TRUE(CheckAnyOfErrors(
325           radioRsp_v1_4->rspInfo.error,
326           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
327     }
328 }
329 
330 /*
331  * Test IRadio.startNetworkScan() with invalid interval (lower boundary).
332  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidInterval1)333 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidInterval1) {
334     serial = GetRandomSerialNumber();
335 
336     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
337             .type = ScanType::ONE_SHOT,
338             .interval = 4,
339             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
340             .maxSearchTime = 60,
341             .incrementalResults = false,
342             .incrementalResultsPeriodicity = 1};
343 
344     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
345 
346     ASSERT_OK(res);
347     EXPECT_EQ(std::cv_status::no_timeout, wait());
348     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
349     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
350 
351     ALOGI("startNetworkScan_InvalidInterval1, rspInfo.error = %s\n",
352           toString(radioRsp_v1_4->rspInfo.error).c_str());
353     if (cardStatus.base.base.cardState == CardState::ABSENT) {
354         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
355                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
356     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
357       ASSERT_TRUE(CheckAnyOfErrors(
358           radioRsp_v1_4->rspInfo.error,
359           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
360     }
361 }
362 
363 /*
364  * Test IRadio.startNetworkScan() with invalid interval (upper boundary).
365  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidInterval2)366 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidInterval2) {
367     serial = GetRandomSerialNumber();
368 
369     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
370             .type = ScanType::ONE_SHOT,
371             .interval = 301,
372             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
373             .maxSearchTime = 60,
374             .incrementalResults = false,
375             .incrementalResultsPeriodicity = 1};
376 
377     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
378     ASSERT_OK(res);
379     EXPECT_EQ(std::cv_status::no_timeout, wait());
380     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
381     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
382 
383     ALOGI("startNetworkScan_InvalidInterval2, rspInfo.error = %s\n",
384           toString(radioRsp_v1_4->rspInfo.error).c_str());
385     if (cardStatus.base.base.cardState == CardState::ABSENT) {
386         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
387                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
388     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
389       ASSERT_TRUE(CheckAnyOfErrors(
390           radioRsp_v1_4->rspInfo.error,
391           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
392     }
393 }
394 
395 /*
396  * Test IRadio.startNetworkScan() with invalid max search time (lower boundary).
397  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidMaxSearchTime1)398 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidMaxSearchTime1) {
399     serial = GetRandomSerialNumber();
400 
401     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
402             .type = ScanType::ONE_SHOT,
403             .interval = 60,
404             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
405             .maxSearchTime = 59,
406             .incrementalResults = false,
407             .incrementalResultsPeriodicity = 1};
408 
409     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
410     ASSERT_OK(res);
411     EXPECT_EQ(std::cv_status::no_timeout, wait());
412     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
413     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
414 
415     ALOGI("startNetworkScan_InvalidMaxSearchTime1, rspInfo.error = %s\n",
416           toString(radioRsp_v1_4->rspInfo.error).c_str());
417     if (cardStatus.base.base.cardState == CardState::ABSENT) {
418         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
419                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
420     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
421       ASSERT_TRUE(CheckAnyOfErrors(
422           radioRsp_v1_4->rspInfo.error,
423           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
424     }
425 }
426 
427 /*
428  * Test IRadio.startNetworkScan() with invalid max search time (upper boundary).
429  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidMaxSearchTime2)430 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidMaxSearchTime2) {
431     serial = GetRandomSerialNumber();
432 
433     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
434             .type = ScanType::ONE_SHOT,
435             .interval = 60,
436             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
437             .maxSearchTime = 3601,
438             .incrementalResults = false,
439             .incrementalResultsPeriodicity = 1};
440 
441     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
442     ASSERT_OK(res);
443     EXPECT_EQ(std::cv_status::no_timeout, wait());
444     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
445     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
446 
447     ALOGI("startNetworkScan_InvalidMaxSearchTime2, rspInfo.error = %s\n",
448           toString(radioRsp_v1_4->rspInfo.error).c_str());
449     if (cardStatus.base.base.cardState == CardState::ABSENT) {
450         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
451                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
452     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
453       ASSERT_TRUE(CheckAnyOfErrors(
454           radioRsp_v1_4->rspInfo.error,
455           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
456     }
457 }
458 
459 /*
460  * Test IRadio.startNetworkScan() with invalid periodicity (lower boundary).
461  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidPeriodicity1)462 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidPeriodicity1) {
463     serial = GetRandomSerialNumber();
464 
465     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
466             .type = ScanType::ONE_SHOT,
467             .interval = 60,
468             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
469             .maxSearchTime = 600,
470             .incrementalResults = true,
471             .incrementalResultsPeriodicity = 0};
472 
473     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
474     ASSERT_OK(res);
475     EXPECT_EQ(std::cv_status::no_timeout, wait());
476     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
477     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
478 
479     ALOGI("startNetworkScan_InvalidPeriodicity1, rspInfo.error = %s\n",
480           toString(radioRsp_v1_4->rspInfo.error).c_str());
481     if (cardStatus.base.base.cardState == CardState::ABSENT) {
482         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
483                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
484     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
485       ASSERT_TRUE(CheckAnyOfErrors(
486           radioRsp_v1_4->rspInfo.error,
487           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
488     }
489 }
490 
491 /*
492  * Test IRadio.startNetworkScan() with invalid periodicity (upper boundary).
493  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidPeriodicity2)494 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidPeriodicity2) {
495     serial = GetRandomSerialNumber();
496 
497     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
498             .type = ScanType::ONE_SHOT,
499             .interval = 60,
500             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
501             .maxSearchTime = 600,
502             .incrementalResults = true,
503             .incrementalResultsPeriodicity = 11};
504 
505     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
506     ASSERT_OK(res);
507     EXPECT_EQ(std::cv_status::no_timeout, wait());
508     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
509     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
510 
511     ALOGI("startNetworkScan_InvalidPeriodicity2, rspInfo.error = %s\n",
512           toString(radioRsp_v1_4->rspInfo.error).c_str());
513     if (cardStatus.base.base.cardState == CardState::ABSENT) {
514         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
515                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
516     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
517       ASSERT_TRUE(CheckAnyOfErrors(
518           radioRsp_v1_4->rspInfo.error,
519           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
520     }
521 }
522 
523 /*
524  * Test IRadio.startNetworkScan() with valid periodicity
525  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_GoodRequest1)526 TEST_P(RadioHidlTest_v1_4, startNetworkScan_GoodRequest1) {
527     serial = GetRandomSerialNumber();
528 
529     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
530             .type = ScanType::ONE_SHOT,
531             .interval = 60,
532             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
533             // Some vendor may not support max search time of 360s.
534             // This issue is tracked in b/112205669.
535             .maxSearchTime = 300,
536             .incrementalResults = false,
537             .incrementalResultsPeriodicity = 10};
538 
539     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
540     ASSERT_OK(res);
541     EXPECT_EQ(std::cv_status::no_timeout, wait());
542     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
543     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
544 
545     ALOGI("startNetworkScan_GoodRequest1, rspInfo.error = %s\n",
546           toString(radioRsp_v1_4->rspInfo.error).c_str());
547     if (cardStatus.base.base.cardState == CardState::ABSENT) {
548         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
549                                      {RadioError::NONE, RadioError::SIM_ABSENT}));
550     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
551       ASSERT_TRUE(
552           CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
553                            {RadioError::NONE, RadioError::INVALID_ARGUMENTS,
554                             RadioError::REQUEST_NOT_SUPPORTED}));
555     }
556 
557     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
558         ALOGI("Stop Network Scan");
559         stopNetworkScan();
560     }
561 }
562 
563 /*
564  * Test IRadio.startNetworkScan() with valid periodicity and plmns
565  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_GoodRequest2)566 TEST_P(RadioHidlTest_v1_4, startNetworkScan_GoodRequest2) {
567     serial = GetRandomSerialNumber();
568 
569     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
570             .type = ScanType::ONE_SHOT,
571             .interval = 60,
572             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
573             // Some vendor may not support max search time of 360s.
574             // This issue is tracked in b/112205669.
575             .maxSearchTime = 300,
576             .incrementalResults = false,
577             .incrementalResultsPeriodicity = 10,
578             .mccMncs = {"310410"}};
579 
580     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
581 
582     ASSERT_OK(res);
583     EXPECT_EQ(std::cv_status::no_timeout, wait());
584     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
585     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
586 
587     ALOGI("startNetworkScan_GoodRequest2, rspInfo.error = %s\n",
588           toString(radioRsp_v1_4->rspInfo.error).c_str());
589     if (cardStatus.base.base.cardState == CardState::ABSENT) {
590         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
591                                      {RadioError::NONE, RadioError::SIM_ABSENT}));
592     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
593       ASSERT_TRUE(
594           CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
595                            {RadioError::NONE, RadioError::INVALID_ARGUMENTS,
596                             RadioError::REQUEST_NOT_SUPPORTED}));
597     }
598 
599     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
600         ALOGI("Stop Network Scan");
601         stopNetworkScan();
602     }
603 }
604 
605 /*
606  * Test IRadio.getSignalStrength_1_4() for the response returned.
607  */
TEST_P(RadioHidlTest_v1_4,getSignalStrength_1_4)608 TEST_P(RadioHidlTest_v1_4, getSignalStrength_1_4) {
609     serial = GetRandomSerialNumber();
610 
611     radio_v1_4->getSignalStrength_1_4(serial);
612     EXPECT_EQ(std::cv_status::no_timeout, wait());
613     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
614     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
615 
616     if (cardStatus.base.base.cardState == CardState::ABSENT) {
617         EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
618     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
619         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
620                                      {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
621     }
622 }
623 
624 /*
625  * Test IRadio.setupDataCall_1_4() for the response returned.
626  */
TEST_P(RadioHidlTest_v1_4,setupDataCall_1_4)627 TEST_P(RadioHidlTest_v1_4, setupDataCall_1_4) {
628     serial = GetRandomSerialNumber();
629 
630     ::android::hardware::radio::V1_4::AccessNetwork accessNetwork =
631             ::android::hardware::radio::V1_4::AccessNetwork::EUTRAN;
632 
633     android::hardware::radio::V1_4::DataProfileInfo dataProfileInfo;
634     memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
635     dataProfileInfo.profileId = DataProfileId::DEFAULT;
636     dataProfileInfo.apn = hidl_string("internet");
637     dataProfileInfo.protocol = PdpProtocolType::IP;
638     dataProfileInfo.roamingProtocol = PdpProtocolType::IP;
639     dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
640     dataProfileInfo.user = hidl_string("username");
641     dataProfileInfo.password = hidl_string("password");
642     dataProfileInfo.type = DataProfileInfoType::THREE_GPP;
643     dataProfileInfo.maxConnsTime = 300;
644     dataProfileInfo.maxConns = 20;
645     dataProfileInfo.waitTime = 0;
646     dataProfileInfo.enabled = true;
647     dataProfileInfo.supportedApnTypesBitmap = 320;
648     dataProfileInfo.bearerBitmap = 161543;
649     dataProfileInfo.mtu = 0;
650     dataProfileInfo.preferred = true;
651     dataProfileInfo.persistent = false;
652 
653     bool roamingAllowed = false;
654 
655     ::android::hardware::radio::V1_2::DataRequestReason reason =
656             ::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
657     std::vector<hidl_string> addresses = {""};
658     std::vector<hidl_string> dnses = {""};
659 
660     Return<void> res = radio_v1_4->setupDataCall_1_4(serial, accessNetwork, dataProfileInfo,
661                                                      roamingAllowed, reason, addresses, dnses);
662     ASSERT_OK(res);
663 
664     EXPECT_EQ(std::cv_status::no_timeout, wait());
665     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
666     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
667 
668     if (cardStatus.base.base.cardState == CardState::ABSENT) {
669         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
670                                      {RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE,
671                                       RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW}));
672     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
673         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
674                                      {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
675                                       RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW}));
676     }
677 }
678 
679 /*
680  * Test IRadio.getAllowedCarriers_1_4() for the response returned.
681  */
TEST_P(RadioHidlTest_v1_4,getAllowedCarriers_1_4)682 TEST_P(RadioHidlTest_v1_4, getAllowedCarriers_1_4) {
683     serial = GetRandomSerialNumber();
684 
685     radio_v1_4->getAllowedCarriers_1_4(serial);
686     EXPECT_EQ(std::cv_status::no_timeout, wait());
687     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
688     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
689 
690     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
691                                  {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
692 }
693 
694 /**
695  * Test IRadio.setAllowedCarriers_1_4() for the response returned.
696  */
TEST_P(RadioHidlTest_v1_4,setAllowedCarriers_1_4)697 TEST_P(RadioHidlTest_v1_4, setAllowedCarriers_1_4) {
698     serial = GetRandomSerialNumber();
699     CarrierRestrictionsWithPriority carrierRestrictions;
700     memset(&carrierRestrictions, 0, sizeof(carrierRestrictions));
701     carrierRestrictions.allowedCarriers.resize(1);
702     carrierRestrictions.excludedCarriers.resize(0);
703     carrierRestrictions.allowedCarriers[0].mcc = hidl_string("123");
704     carrierRestrictions.allowedCarriers[0].mnc = hidl_string("456");
705     carrierRestrictions.allowedCarriers[0].matchType = CarrierMatchType::ALL;
706     carrierRestrictions.allowedCarriers[0].matchData = hidl_string();
707     carrierRestrictions.allowedCarriersPrioritized = true;
708     SimLockMultiSimPolicy multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;
709 
710     radio_v1_4->setAllowedCarriers_1_4(serial, carrierRestrictions, multisimPolicy);
711     EXPECT_EQ(std::cv_status::no_timeout, wait());
712     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
713     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
714 
715     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
716                                  {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
717 
718     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
719         /* Verify the update of the SIM status. This might need some time */
720         if (cardStatus.base.base.cardState != CardState::ABSENT) {
721             updateSimCardStatus();
722             auto startTime = std::chrono::system_clock::now();
723             while (cardStatus.base.base.cardState != CardState::RESTRICTED &&
724                    std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() -
725                                                                startTime)
726                                    .count() < 10) {
727                 /* Set 2 seconds as interval to check card status */
728                 sleep(2);
729                 updateSimCardStatus();
730             }
731             EXPECT_EQ(CardState::RESTRICTED, cardStatus.base.base.cardState);
732         }
733 
734         /* Verify that configuration was set correctly, retrieving it from the modem */
735         serial = GetRandomSerialNumber();
736 
737         radio_v1_4->getAllowedCarriers_1_4(serial);
738         EXPECT_EQ(std::cv_status::no_timeout, wait());
739         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
740         EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
741         EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
742 
743         EXPECT_EQ(1, radioRsp_v1_4->carrierRestrictionsResp.allowedCarriers.size());
744         EXPECT_EQ(0, radioRsp_v1_4->carrierRestrictionsResp.excludedCarriers.size());
745         ASSERT_TRUE(hidl_string("123") ==
746                     radioRsp_v1_4->carrierRestrictionsResp.allowedCarriers[0].mcc);
747         ASSERT_TRUE(hidl_string("456") ==
748                     radioRsp_v1_4->carrierRestrictionsResp.allowedCarriers[0].mnc);
749         EXPECT_EQ(CarrierMatchType::ALL,
750                   radioRsp_v1_4->carrierRestrictionsResp.allowedCarriers[0].matchType);
751         ASSERT_TRUE(radioRsp_v1_4->carrierRestrictionsResp.allowedCarriersPrioritized);
752         EXPECT_EQ(SimLockMultiSimPolicy::NO_MULTISIM_POLICY, radioRsp_v1_4->multiSimPolicyResp);
753 
754         sleep(10);
755 
756         /**
757          * Another test case of the API to cover to allow carrier.
758          * If the API is supported, this is also used to reset to no carrier restriction
759          * status for cardStatus.
760          */
761         memset(&carrierRestrictions, 0, sizeof(carrierRestrictions));
762         carrierRestrictions.allowedCarriers.resize(0);
763         carrierRestrictions.excludedCarriers.resize(0);
764         carrierRestrictions.allowedCarriersPrioritized = false;
765 
766         serial = GetRandomSerialNumber();
767         radio_v1_4->setAllowedCarriers_1_4(serial, carrierRestrictions, multisimPolicy);
768         EXPECT_EQ(std::cv_status::no_timeout, wait());
769         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
770         EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
771 
772         EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
773 
774         if (cardStatus.base.base.cardState != CardState::ABSENT) {
775             /* Resetting back to no carrier restriction needs some time */
776             updateSimCardStatus();
777             auto startTime = std::chrono::system_clock::now();
778             while (cardStatus.base.base.cardState == CardState::RESTRICTED &&
779                    std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() -
780                                                                startTime)
781                                    .count() < 10) {
782                 /* Set 2 seconds as interval to check card status */
783                 sleep(2);
784                 updateSimCardStatus();
785             }
786             EXPECT_NE(CardState::RESTRICTED, cardStatus.base.base.cardState);
787             sleep(10);
788         }
789     }
790 }
791 
TEST_P(RadioHidlTest_v1_4,setDataProfile_1_4)792 TEST_P(RadioHidlTest_v1_4, setDataProfile_1_4) {
793     serial = GetRandomSerialNumber();
794 
795     // Create a dataProfileInfo
796     android::hardware::radio::V1_4::DataProfileInfo dataProfileInfo;
797     memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
798     dataProfileInfo.profileId = DataProfileId::DEFAULT;
799     dataProfileInfo.apn = hidl_string("internet");
800     dataProfileInfo.protocol = PdpProtocolType::IPV4V6;
801     dataProfileInfo.roamingProtocol = PdpProtocolType::IPV4V6;
802     dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
803     dataProfileInfo.user = hidl_string("username");
804     dataProfileInfo.password = hidl_string("password");
805     dataProfileInfo.type = DataProfileInfoType::THREE_GPP;
806     dataProfileInfo.maxConnsTime = 300;
807     dataProfileInfo.maxConns = 20;
808     dataProfileInfo.waitTime = 0;
809     dataProfileInfo.enabled = true;
810     dataProfileInfo.supportedApnTypesBitmap = 320;
811     dataProfileInfo.bearerBitmap = 161543;
812     dataProfileInfo.mtu = 0;
813     dataProfileInfo.preferred = true;
814     dataProfileInfo.persistent = true;
815 
816     // Create a dataProfileInfoList
817     android::hardware::hidl_vec<android::hardware::radio::V1_4::DataProfileInfo>
818             dataProfileInfoList = {dataProfileInfo};
819 
820     radio_v1_4->setDataProfile_1_4(serial, dataProfileInfoList);
821 
822     EXPECT_EQ(std::cv_status::no_timeout, wait());
823     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
824     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
825 
826     if (cardStatus.base.base.cardState == CardState::ABSENT) {
827         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
828                                      {RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE}));
829     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
830         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
831                                      {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
832     }
833 }
834 
TEST_P(RadioHidlTest_v1_4,setInitialAttachApn_1_4)835 TEST_P(RadioHidlTest_v1_4, setInitialAttachApn_1_4) {
836     serial = GetRandomSerialNumber();
837 
838     // Create a dataProfileInfo
839     android::hardware::radio::V1_4::DataProfileInfo dataProfileInfo;
840     memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
841     dataProfileInfo.profileId = DataProfileId::DEFAULT;
842     dataProfileInfo.apn = hidl_string("internet");
843     dataProfileInfo.protocol = PdpProtocolType::IPV4V6;
844     dataProfileInfo.roamingProtocol = PdpProtocolType::IPV4V6;
845     dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
846     dataProfileInfo.user = hidl_string("username");
847     dataProfileInfo.password = hidl_string("password");
848     dataProfileInfo.type = DataProfileInfoType::THREE_GPP;
849     dataProfileInfo.maxConnsTime = 300;
850     dataProfileInfo.maxConns = 20;
851     dataProfileInfo.waitTime = 0;
852     dataProfileInfo.enabled = true;
853     dataProfileInfo.supportedApnTypesBitmap = 320;
854     dataProfileInfo.bearerBitmap = 161543;
855     dataProfileInfo.mtu = 0;
856     dataProfileInfo.preferred = true;
857     dataProfileInfo.persistent = false;
858 
859     radio_v1_4->setInitialAttachApn_1_4(serial, dataProfileInfo);
860 
861     EXPECT_EQ(std::cv_status::no_timeout, wait());
862     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
863     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
864 
865     if (cardStatus.base.base.cardState == CardState::ABSENT) {
866         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
867                                      {RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE}));
868     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
869         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
870                                      {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
871     }
872 }
873 
874 /*
875  * Test IRadio.getDataRegistrationStateResponse_1_4() for the response returned.
876  */
TEST_P(RadioHidlTest_v1_4,getDataRegistrationState_1_4)877 TEST_P(RadioHidlTest_v1_4, getDataRegistrationState_1_4) {
878     int rat;
879     serial = GetRandomSerialNumber();
880 
881     Return<void> res = radio_v1_4->getDataRegistrationState(serial);
882     ASSERT_OK(res);
883     EXPECT_EQ(std::cv_status::no_timeout, wait());
884     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
885     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
886 
887     ALOGI("getDataRegistrationStateResponse_1_4, rspInfo.error = %s\n",
888           toString(radioRsp_v1_4->rspInfo.error).c_str());
889 
890     ASSERT_TRUE(CheckAnyOfErrors(
891         radioRsp_v1_4->rspInfo.error,
892         {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NOT_PROVISIONED}));
893 
894     rat = radioRsp_v1_4->dataRegResp.base.rat;
895     /*
896      *  - Expect Valid vopsinfo when device is on LTE
897      *  - Expect empty vopsInfo when device is not on LTE
898      */
899     if (rat == ((int )::android::hardware::radio::V1_4::RadioTechnology::LTE)
900         || (rat == (int )::android::hardware::radio::V1_4::RadioTechnology::LTE_CA)) {
901 
902         EXPECT_EQ(::android::hardware::radio::V1_4::DataRegStateResult::VopsInfo::hidl_discriminator
903                   ::lteVopsInfo, radioRsp_v1_4->dataRegResp.vopsInfo.getDiscriminator());
904     } else {
905 
906         EXPECT_EQ(::android::hardware::radio::V1_4::DataRegStateResult::VopsInfo::hidl_discriminator
907                   ::noinit, radioRsp_v1_4->dataRegResp.vopsInfo.getDiscriminator());
908     }
909 }
910