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