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     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
236                                  {RadioError::NONE, RadioError::MODE_NOT_SUPPORTED}));
237     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
238          // give some time for modem to set the value.
239         sleep(3);
240         serial = GetRandomSerialNumber();
241         Return<void> res = radio_v1_4->getPreferredNetworkTypeBitmap(serial);
242 
243         ASSERT_OK(res);
244         EXPECT_EQ(std::cv_status::no_timeout, wait());
245         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
246         EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
247         ALOGI("getPreferredNetworkTypeBitmap, rspInfo.error = %s\n",
248               toString(radioRsp_v1_4->rspInfo.error).c_str());
249         EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
250         EXPECT_EQ(network_type_bitmap, radioRsp_v1_4->networkTypeBitmapResponse);
251     }
252 }
253 
254 /*
255  * Test IRadio.startNetworkScan() for the response returned.
256  *
257  * REQUEST_NOT_SUPPORTED is temporarily returned because of vendors failed to fully implement
258  * startNetworkScan in HAL @1.4 (see b/137298570 and b/135595082). Starting from @1.5, however,
259  * REQUEST_NOT_SUPPORTED will be disallowed for all tests. Modems have "GSM" rat scan need to
260  * support scanning requests combined with some parameters.
261  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan)262 TEST_P(RadioHidlTest_v1_4, startNetworkScan) {
263     serial = GetRandomSerialNumber();
264 
265     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
266             .type = ScanType::ONE_SHOT,
267             .interval = 60,
268             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
269             .maxSearchTime = 60,
270             .incrementalResults = false,
271             .incrementalResultsPeriodicity = 1};
272 
273     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
274     ASSERT_OK(res);
275     EXPECT_EQ(std::cv_status::no_timeout, wait());
276     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
277     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
278 
279     ALOGI("startNetworkScan, rspInfo.error = %s\n", toString(radioRsp_v1_4->rspInfo.error).c_str());
280 
281     if (cardStatus.base.base.cardState == CardState::ABSENT) {
282         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error, {RadioError::SIM_ABSENT}));
283     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
284       // OPERATION_NOT_ALLOWED should not be allowed; however, some vendors do
285       // not support the required manual GSM search functionality. This is
286       // tracked in b/112206766. REQUEST_NOT_SUPPORTED is temporarily added back
287       // because of vendors failed to implement startNetworkScan in HAL 1.4 (see
288       // b/137298570 and b/135595082). Starting from 1.5, however,
289       // REQUEST_NOT_SUPPORTED will be disallowed. Modems have "GSM" rat scan
290       // need to support scanning requests combined with some parameters.
291       ASSERT_TRUE(
292           CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
293                            {RadioError::NONE, RadioError::OPERATION_NOT_ALLOWED,
294                             RadioError::REQUEST_NOT_SUPPORTED}));
295     }
296 
297     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
298         ALOGI("Stop Network Scan");
299         stopNetworkScan();
300     }
301 }
302 
303 /*
304  * Test IRadio.startNetworkScan() with invalid specifier.
305  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidArgument)306 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidArgument) {
307     serial = GetRandomSerialNumber();
308 
309     ::android::hardware::radio::V1_2::NetworkScanRequest request = {.type = ScanType::ONE_SHOT,
310                                                                     .interval = 60};
311 
312     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
313 
314     ASSERT_OK(res);
315     EXPECT_EQ(std::cv_status::no_timeout, wait());
316     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
317     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
318 
319     ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
320           toString(radioRsp_v1_4->rspInfo.error).c_str());
321     if (cardStatus.base.base.cardState == CardState::ABSENT) {
322         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
323                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
324     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
325       ASSERT_TRUE(CheckAnyOfErrors(
326           radioRsp_v1_4->rspInfo.error,
327           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
328     }
329 }
330 
331 /*
332  * Test IRadio.startNetworkScan() with invalid interval (lower boundary).
333  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidInterval1)334 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidInterval1) {
335     serial = GetRandomSerialNumber();
336 
337     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
338             .type = ScanType::PERIODIC,
339             .interval = 4,
340             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
341             .maxSearchTime = 60,
342             .incrementalResults = false,
343             .incrementalResultsPeriodicity = 1};
344 
345     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
346 
347     ASSERT_OK(res);
348     EXPECT_EQ(std::cv_status::no_timeout, wait());
349     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
350     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
351 
352     ALOGI("startNetworkScan_InvalidInterval1, rspInfo.error = %s\n",
353           toString(radioRsp_v1_4->rspInfo.error).c_str());
354     if (cardStatus.base.base.cardState == CardState::ABSENT) {
355         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
356                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
357     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
358       ASSERT_TRUE(CheckAnyOfErrors(
359           radioRsp_v1_4->rspInfo.error,
360           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
361     }
362 }
363 
364 /*
365  * Test IRadio.startNetworkScan() with invalid interval (upper boundary).
366  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidInterval2)367 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidInterval2) {
368     serial = GetRandomSerialNumber();
369 
370     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
371             .type = ScanType::PERIODIC,
372             .interval = 301,
373             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
374             .maxSearchTime = 60,
375             .incrementalResults = false,
376             .incrementalResultsPeriodicity = 1};
377 
378     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
379     ASSERT_OK(res);
380     EXPECT_EQ(std::cv_status::no_timeout, wait());
381     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
382     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
383 
384     ALOGI("startNetworkScan_InvalidInterval2, rspInfo.error = %s\n",
385           toString(radioRsp_v1_4->rspInfo.error).c_str());
386     if (cardStatus.base.base.cardState == CardState::ABSENT) {
387         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
388                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
389     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
390       ASSERT_TRUE(CheckAnyOfErrors(
391           radioRsp_v1_4->rspInfo.error,
392           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
393     }
394 }
395 
396 /*
397  * Test IRadio.startNetworkScan() with invalid max search time (lower boundary).
398  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidMaxSearchTime1)399 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidMaxSearchTime1) {
400     serial = GetRandomSerialNumber();
401 
402     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
403             .type = ScanType::ONE_SHOT,
404             .interval = 60,
405             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
406             .maxSearchTime = 59,
407             .incrementalResults = false,
408             .incrementalResultsPeriodicity = 1};
409 
410     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
411     ASSERT_OK(res);
412     EXPECT_EQ(std::cv_status::no_timeout, wait());
413     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
414     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
415 
416     ALOGI("startNetworkScan_InvalidMaxSearchTime1, rspInfo.error = %s\n",
417           toString(radioRsp_v1_4->rspInfo.error).c_str());
418     if (cardStatus.base.base.cardState == CardState::ABSENT) {
419         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
420                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
421     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
422       ASSERT_TRUE(CheckAnyOfErrors(
423           radioRsp_v1_4->rspInfo.error,
424           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
425     }
426 }
427 
428 /*
429  * Test IRadio.startNetworkScan() with invalid max search time (upper boundary).
430  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidMaxSearchTime2)431 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidMaxSearchTime2) {
432     serial = GetRandomSerialNumber();
433 
434     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
435             .type = ScanType::ONE_SHOT,
436             .interval = 60,
437             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
438             .maxSearchTime = 3601,
439             .incrementalResults = false,
440             .incrementalResultsPeriodicity = 1};
441 
442     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
443     ASSERT_OK(res);
444     EXPECT_EQ(std::cv_status::no_timeout, wait());
445     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
446     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
447 
448     ALOGI("startNetworkScan_InvalidMaxSearchTime2, rspInfo.error = %s\n",
449           toString(radioRsp_v1_4->rspInfo.error).c_str());
450     if (cardStatus.base.base.cardState == CardState::ABSENT) {
451         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
452                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
453     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
454       ASSERT_TRUE(CheckAnyOfErrors(
455           radioRsp_v1_4->rspInfo.error,
456           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
457     }
458 }
459 
460 /*
461  * Test IRadio.startNetworkScan() with invalid periodicity (lower boundary).
462  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidPeriodicity1)463 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidPeriodicity1) {
464     serial = GetRandomSerialNumber();
465 
466     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
467             .type = ScanType::ONE_SHOT,
468             .interval = 60,
469             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
470             .maxSearchTime = 600,
471             .incrementalResults = true,
472             .incrementalResultsPeriodicity = 0};
473 
474     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
475     ASSERT_OK(res);
476     EXPECT_EQ(std::cv_status::no_timeout, wait());
477     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
478     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
479 
480     ALOGI("startNetworkScan_InvalidPeriodicity1, rspInfo.error = %s\n",
481           toString(radioRsp_v1_4->rspInfo.error).c_str());
482     if (cardStatus.base.base.cardState == CardState::ABSENT) {
483         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
484                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
485     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
486       ASSERT_TRUE(CheckAnyOfErrors(
487           radioRsp_v1_4->rspInfo.error,
488           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
489     }
490 }
491 
492 /*
493  * Test IRadio.startNetworkScan() with invalid periodicity (upper boundary).
494  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_InvalidPeriodicity2)495 TEST_P(RadioHidlTest_v1_4, startNetworkScan_InvalidPeriodicity2) {
496     serial = GetRandomSerialNumber();
497 
498     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
499             .type = ScanType::ONE_SHOT,
500             .interval = 60,
501             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
502             .maxSearchTime = 600,
503             .incrementalResults = true,
504             .incrementalResultsPeriodicity = 11};
505 
506     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
507     ASSERT_OK(res);
508     EXPECT_EQ(std::cv_status::no_timeout, wait());
509     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
510     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
511 
512     ALOGI("startNetworkScan_InvalidPeriodicity2, rspInfo.error = %s\n",
513           toString(radioRsp_v1_4->rspInfo.error).c_str());
514     if (cardStatus.base.base.cardState == CardState::ABSENT) {
515         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
516                                      {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
517     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
518       ASSERT_TRUE(CheckAnyOfErrors(
519           radioRsp_v1_4->rspInfo.error,
520           {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
521     }
522 }
523 
524 /*
525  * Test IRadio.startNetworkScan() with valid periodicity
526  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_GoodRequest1)527 TEST_P(RadioHidlTest_v1_4, startNetworkScan_GoodRequest1) {
528     serial = GetRandomSerialNumber();
529 
530     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
531             .type = ScanType::ONE_SHOT,
532             .interval = 60,
533             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
534             // Some vendor may not support max search time of 360s.
535             // This issue is tracked in b/112205669.
536             .maxSearchTime = 300,
537             .incrementalResults = false,
538             .incrementalResultsPeriodicity = 10};
539 
540     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
541     ASSERT_OK(res);
542     EXPECT_EQ(std::cv_status::no_timeout, wait());
543     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
544     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
545 
546     ALOGI("startNetworkScan_GoodRequest1, rspInfo.error = %s\n",
547           toString(radioRsp_v1_4->rspInfo.error).c_str());
548     if (cardStatus.base.base.cardState == CardState::ABSENT) {
549         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
550                                      {RadioError::NONE, RadioError::SIM_ABSENT}));
551     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
552       ASSERT_TRUE(
553           CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
554                            {RadioError::NONE, RadioError::INVALID_ARGUMENTS,
555                             RadioError::REQUEST_NOT_SUPPORTED}));
556     }
557 
558     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
559         ALOGI("Stop Network Scan");
560         stopNetworkScan();
561     }
562 }
563 
564 /*
565  * Test IRadio.startNetworkScan() with valid periodicity and plmns
566  */
TEST_P(RadioHidlTest_v1_4,startNetworkScan_GoodRequest2)567 TEST_P(RadioHidlTest_v1_4, startNetworkScan_GoodRequest2) {
568     serial = GetRandomSerialNumber();
569 
570     ::android::hardware::radio::V1_2::NetworkScanRequest request = {
571             .type = ScanType::ONE_SHOT,
572             .interval = 60,
573             .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
574             // Some vendor may not support max search time of 360s.
575             // This issue is tracked in b/112205669.
576             .maxSearchTime = 300,
577             .incrementalResults = false,
578             .incrementalResultsPeriodicity = 10,
579             .mccMncs = {"310410"}};
580 
581     Return<void> res = radio_v1_4->startNetworkScan_1_4(serial, request);
582 
583     ASSERT_OK(res);
584     EXPECT_EQ(std::cv_status::no_timeout, wait());
585     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
586     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
587 
588     ALOGI("startNetworkScan_GoodRequest2, rspInfo.error = %s\n",
589           toString(radioRsp_v1_4->rspInfo.error).c_str());
590     if (cardStatus.base.base.cardState == CardState::ABSENT) {
591         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
592                                      {RadioError::NONE, RadioError::SIM_ABSENT}));
593     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
594       ASSERT_TRUE(
595           CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
596                            {RadioError::NONE, RadioError::INVALID_ARGUMENTS,
597                             RadioError::REQUEST_NOT_SUPPORTED}));
598     }
599 
600     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
601         ALOGI("Stop Network Scan");
602         stopNetworkScan();
603     }
604 }
605 
606 /*
607  * Test IRadio.getSignalStrength_1_4() for the response returned.
608  */
TEST_P(RadioHidlTest_v1_4,getSignalStrength_1_4)609 TEST_P(RadioHidlTest_v1_4, getSignalStrength_1_4) {
610     serial = GetRandomSerialNumber();
611 
612     radio_v1_4->getSignalStrength_1_4(serial);
613     EXPECT_EQ(std::cv_status::no_timeout, wait());
614     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
615     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
616 
617     if (cardStatus.base.base.cardState == CardState::ABSENT) {
618         EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
619     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
620         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
621                                      {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
622     }
623 }
624 
625 /*
626  * Test IRadio.setupDataCall_1_4() for the response returned.
627  */
TEST_P(RadioHidlTest_v1_4,setupDataCall_1_4)628 TEST_P(RadioHidlTest_v1_4, setupDataCall_1_4) {
629     serial = GetRandomSerialNumber();
630 
631     ::android::hardware::radio::V1_4::AccessNetwork accessNetwork =
632             ::android::hardware::radio::V1_4::AccessNetwork::EUTRAN;
633 
634     android::hardware::radio::V1_4::DataProfileInfo dataProfileInfo;
635     memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
636     dataProfileInfo.profileId = DataProfileId::DEFAULT;
637     dataProfileInfo.apn = hidl_string("internet");
638     dataProfileInfo.protocol = PdpProtocolType::IP;
639     dataProfileInfo.roamingProtocol = PdpProtocolType::IP;
640     dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
641     dataProfileInfo.user = hidl_string("username");
642     dataProfileInfo.password = hidl_string("password");
643     dataProfileInfo.type = DataProfileInfoType::THREE_GPP;
644     dataProfileInfo.maxConnsTime = 300;
645     dataProfileInfo.maxConns = 20;
646     dataProfileInfo.waitTime = 0;
647     dataProfileInfo.enabled = true;
648     dataProfileInfo.supportedApnTypesBitmap = 320;
649     dataProfileInfo.bearerBitmap = 161543;
650     dataProfileInfo.mtu = 0;
651     dataProfileInfo.preferred = true;
652     dataProfileInfo.persistent = false;
653 
654     bool roamingAllowed = false;
655 
656     ::android::hardware::radio::V1_2::DataRequestReason reason =
657             ::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
658     std::vector<hidl_string> addresses = {""};
659     std::vector<hidl_string> dnses = {""};
660 
661     Return<void> res = radio_v1_4->setupDataCall_1_4(serial, accessNetwork, dataProfileInfo,
662                                                      roamingAllowed, reason, addresses, dnses);
663     ASSERT_OK(res);
664 
665     EXPECT_EQ(std::cv_status::no_timeout, wait());
666     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
667     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
668 
669     if (cardStatus.base.base.cardState == CardState::ABSENT) {
670         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
671                                      {RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE,
672                                       RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW}));
673     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
674         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
675                                      {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
676                                       RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW}));
677     }
678 }
679 
680 /*
681  * Test IRadio.getAllowedCarriers_1_4() for the response returned.
682  */
TEST_P(RadioHidlTest_v1_4,getAllowedCarriers_1_4)683 TEST_P(RadioHidlTest_v1_4, getAllowedCarriers_1_4) {
684     serial = GetRandomSerialNumber();
685 
686     radio_v1_4->getAllowedCarriers_1_4(serial);
687     EXPECT_EQ(std::cv_status::no_timeout, wait());
688     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
689     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
690 
691     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
692                                  {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
693 }
694 
695 /**
696  * Test IRadio.setAllowedCarriers_1_4() for the response returned.
697  */
TEST_P(RadioHidlTest_v1_4,setAllowedCarriers_1_4)698 TEST_P(RadioHidlTest_v1_4, setAllowedCarriers_1_4) {
699     serial = GetRandomSerialNumber();
700     CarrierRestrictionsWithPriority carrierRestrictions;
701     memset(&carrierRestrictions, 0, sizeof(carrierRestrictions));
702     carrierRestrictions.allowedCarriers.resize(1);
703     carrierRestrictions.excludedCarriers.resize(0);
704     carrierRestrictions.allowedCarriers[0].mcc = hidl_string("123");
705     carrierRestrictions.allowedCarriers[0].mnc = hidl_string("456");
706     carrierRestrictions.allowedCarriers[0].matchType = CarrierMatchType::ALL;
707     carrierRestrictions.allowedCarriers[0].matchData = hidl_string();
708     carrierRestrictions.allowedCarriersPrioritized = true;
709     SimLockMultiSimPolicy multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;
710 
711     radio_v1_4->setAllowedCarriers_1_4(serial, carrierRestrictions, multisimPolicy);
712     EXPECT_EQ(std::cv_status::no_timeout, wait());
713     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
714     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
715 
716     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
717                                  {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
718 
719     if (radioRsp_v1_4->rspInfo.error == RadioError::NONE) {
720         /* Verify the update of the SIM status. This might need some time */
721         if (cardStatus.base.base.cardState != CardState::ABSENT) {
722             updateSimCardStatus();
723             auto startTime = std::chrono::system_clock::now();
724             while (cardStatus.base.base.cardState != CardState::RESTRICTED &&
725                    std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() -
726                                                                startTime)
727                                    .count() < 10) {
728                 /* Set 2 seconds as interval to check card status */
729                 sleep(2);
730                 updateSimCardStatus();
731             }
732             EXPECT_EQ(CardState::RESTRICTED, cardStatus.base.base.cardState);
733         }
734 
735         /* Verify that configuration was set correctly, retrieving it from the modem */
736         serial = GetRandomSerialNumber();
737 
738         radio_v1_4->getAllowedCarriers_1_4(serial);
739         EXPECT_EQ(std::cv_status::no_timeout, wait());
740         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
741         EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
742         EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
743 
744         EXPECT_EQ(1, radioRsp_v1_4->carrierRestrictionsResp.allowedCarriers.size());
745         EXPECT_EQ(0, radioRsp_v1_4->carrierRestrictionsResp.excludedCarriers.size());
746         ASSERT_TRUE(hidl_string("123") ==
747                     radioRsp_v1_4->carrierRestrictionsResp.allowedCarriers[0].mcc);
748         ASSERT_TRUE(hidl_string("456") ==
749                     radioRsp_v1_4->carrierRestrictionsResp.allowedCarriers[0].mnc);
750         EXPECT_EQ(CarrierMatchType::ALL,
751                   radioRsp_v1_4->carrierRestrictionsResp.allowedCarriers[0].matchType);
752         ASSERT_TRUE(radioRsp_v1_4->carrierRestrictionsResp.allowedCarriersPrioritized);
753         EXPECT_EQ(SimLockMultiSimPolicy::NO_MULTISIM_POLICY, radioRsp_v1_4->multiSimPolicyResp);
754 
755         sleep(10);
756 
757         /**
758          * Another test case of the API to cover to allow carrier.
759          * If the API is supported, this is also used to reset to no carrier restriction
760          * status for cardStatus.
761          */
762         memset(&carrierRestrictions, 0, sizeof(carrierRestrictions));
763         carrierRestrictions.allowedCarriers.resize(0);
764         carrierRestrictions.excludedCarriers.resize(0);
765         carrierRestrictions.allowedCarriersPrioritized = false;
766 
767         serial = GetRandomSerialNumber();
768         radio_v1_4->setAllowedCarriers_1_4(serial, carrierRestrictions, multisimPolicy);
769         EXPECT_EQ(std::cv_status::no_timeout, wait());
770         EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
771         EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
772 
773         EXPECT_EQ(RadioError::NONE, radioRsp_v1_4->rspInfo.error);
774 
775         if (cardStatus.base.base.cardState != CardState::ABSENT) {
776             /* Resetting back to no carrier restriction needs some time */
777             updateSimCardStatus();
778             auto startTime = std::chrono::system_clock::now();
779             while (cardStatus.base.base.cardState == CardState::RESTRICTED &&
780                    std::chrono::duration_cast<chrono::seconds>(std::chrono::system_clock::now() -
781                                                                startTime)
782                                    .count() < 10) {
783                 /* Set 2 seconds as interval to check card status */
784                 sleep(2);
785                 updateSimCardStatus();
786             }
787             EXPECT_NE(CardState::RESTRICTED, cardStatus.base.base.cardState);
788             sleep(10);
789         }
790     }
791 }
792 
TEST_P(RadioHidlTest_v1_4,setDataProfile_1_4)793 TEST_P(RadioHidlTest_v1_4, setDataProfile_1_4) {
794     serial = GetRandomSerialNumber();
795 
796     // Create a dataProfileInfo
797     android::hardware::radio::V1_4::DataProfileInfo dataProfileInfo;
798     memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
799     dataProfileInfo.profileId = DataProfileId::DEFAULT;
800     dataProfileInfo.apn = hidl_string("internet");
801     dataProfileInfo.protocol = PdpProtocolType::IPV4V6;
802     dataProfileInfo.roamingProtocol = PdpProtocolType::IPV4V6;
803     dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
804     dataProfileInfo.user = hidl_string("username");
805     dataProfileInfo.password = hidl_string("password");
806     dataProfileInfo.type = DataProfileInfoType::THREE_GPP;
807     dataProfileInfo.maxConnsTime = 300;
808     dataProfileInfo.maxConns = 20;
809     dataProfileInfo.waitTime = 0;
810     dataProfileInfo.enabled = true;
811     dataProfileInfo.supportedApnTypesBitmap = 320;
812     dataProfileInfo.bearerBitmap = 161543;
813     dataProfileInfo.mtu = 0;
814     dataProfileInfo.preferred = true;
815     dataProfileInfo.persistent = true;
816 
817     // Create a dataProfileInfoList
818     android::hardware::hidl_vec<android::hardware::radio::V1_4::DataProfileInfo>
819             dataProfileInfoList = {dataProfileInfo};
820 
821     radio_v1_4->setDataProfile_1_4(serial, dataProfileInfoList);
822 
823     EXPECT_EQ(std::cv_status::no_timeout, wait());
824     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
825     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
826 
827     if (cardStatus.base.base.cardState == CardState::ABSENT) {
828         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
829                                      {RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE}));
830     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
831         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
832                                      {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
833     }
834 }
835 
TEST_P(RadioHidlTest_v1_4,setInitialAttachApn_1_4)836 TEST_P(RadioHidlTest_v1_4, setInitialAttachApn_1_4) {
837     serial = GetRandomSerialNumber();
838 
839     // Create a dataProfileInfo
840     android::hardware::radio::V1_4::DataProfileInfo dataProfileInfo;
841     memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
842     dataProfileInfo.profileId = DataProfileId::DEFAULT;
843     dataProfileInfo.apn = hidl_string("internet");
844     dataProfileInfo.protocol = PdpProtocolType::IPV4V6;
845     dataProfileInfo.roamingProtocol = PdpProtocolType::IPV4V6;
846     dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
847     dataProfileInfo.user = hidl_string("username");
848     dataProfileInfo.password = hidl_string("password");
849     dataProfileInfo.type = DataProfileInfoType::THREE_GPP;
850     dataProfileInfo.maxConnsTime = 300;
851     dataProfileInfo.maxConns = 20;
852     dataProfileInfo.waitTime = 0;
853     dataProfileInfo.enabled = true;
854     dataProfileInfo.supportedApnTypesBitmap = 320;
855     dataProfileInfo.bearerBitmap = 161543;
856     dataProfileInfo.mtu = 0;
857     dataProfileInfo.preferred = true;
858     dataProfileInfo.persistent = false;
859 
860     radio_v1_4->setInitialAttachApn_1_4(serial, dataProfileInfo);
861 
862     EXPECT_EQ(std::cv_status::no_timeout, wait());
863     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
864     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
865 
866     if (cardStatus.base.base.cardState == CardState::ABSENT) {
867         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
868                                      {RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE}));
869     } else if (cardStatus.base.base.cardState == CardState::PRESENT) {
870         ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_4->rspInfo.error,
871                                      {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
872     }
873 }
874 
875 /*
876  * Test IRadio.getDataRegistrationStateResponse_1_4() for the response returned.
877  */
TEST_P(RadioHidlTest_v1_4,getDataRegistrationState_1_4)878 TEST_P(RadioHidlTest_v1_4, getDataRegistrationState_1_4) {
879     int rat;
880     serial = GetRandomSerialNumber();
881 
882     Return<void> res = radio_v1_4->getDataRegistrationState(serial);
883     ASSERT_OK(res);
884     EXPECT_EQ(std::cv_status::no_timeout, wait());
885     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_4->rspInfo.type);
886     EXPECT_EQ(serial, radioRsp_v1_4->rspInfo.serial);
887 
888     ALOGI("getDataRegistrationStateResponse_1_4, rspInfo.error = %s\n",
889           toString(radioRsp_v1_4->rspInfo.error).c_str());
890 
891     ASSERT_TRUE(CheckAnyOfErrors(
892         radioRsp_v1_4->rspInfo.error,
893         {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NOT_PROVISIONED}));
894 
895     rat = radioRsp_v1_4->dataRegResp.base.rat;
896     /*
897      *  - Expect Valid vopsinfo when device is on LTE
898      *  - Expect empty vopsInfo when device is not on LTE
899      */
900     if (rat == ((int )::android::hardware::radio::V1_4::RadioTechnology::LTE)
901         || (rat == (int )::android::hardware::radio::V1_4::RadioTechnology::LTE_CA)) {
902 
903         EXPECT_EQ(::android::hardware::radio::V1_4::DataRegStateResult::VopsInfo::hidl_discriminator
904                   ::lteVopsInfo, radioRsp_v1_4->dataRegResp.vopsInfo.getDiscriminator());
905     } else {
906 
907         EXPECT_EQ(::android::hardware::radio::V1_4::DataRegStateResult::VopsInfo::hidl_discriminator
908                   ::noinit, radioRsp_v1_4->dataRegResp.vopsInfo.getDiscriminator());
909     }
910 }
911