1 /*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <radio_hidl_hal_utils_v1_2.h>
18 #include <vector>
19
20 #define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
21
22 namespace {
23 const RadioAccessSpecifier GERAN_SPECIFIER_P900 = {.radioAccessNetwork = RadioAccessNetworks::GERAN,
24 .geranBands = {GeranBands::BAND_P900},
25 .channels = {1, 2}};
26 const RadioAccessSpecifier GERAN_SPECIFIER_850 = {.radioAccessNetwork = RadioAccessNetworks::GERAN,
27 .geranBands = {GeranBands::BAND_850},
28 .channels = {128, 129}};
29 } // namespace
30
31 /*
32 * Test IRadio.startNetworkScan() for the response returned.
33 */
TEST_P(RadioHidlTest_v1_2,startNetworkScan)34 TEST_P(RadioHidlTest_v1_2, startNetworkScan) {
35 serial = GetRandomSerialNumber();
36
37 if (radioConfig != NULL && DDS_LOGICAL_SLOT_INDEX != logicalSlotId) {
38 // Some DSDS devices have a limitation that network scans can only be performed on the
39 // logical modem that currently used for packet data. For now, skip the test on the
40 // non-data SIM. This exemption is removed in HAL version 1.4. See b/135243177 for
41 // additional information.
42 ALOGI("Skip network scan on non-dds SIM, slot id = %d", logicalSlotId);
43 return;
44 }
45
46 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
47 .type = ScanType::ONE_SHOT,
48 .interval = 60,
49 .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
50 .maxSearchTime = 60,
51 .incrementalResults = false,
52 .incrementalResultsPeriodicity = 1};
53
54 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
55 ASSERT_OK(res);
56 EXPECT_EQ(std::cv_status::no_timeout, wait());
57 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
58 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
59
60 ALOGI("startNetworkScan, rspInfo.error = %s\n", toString(radioRsp_v1_2->rspInfo.error).c_str());
61 if (cardStatus.base.cardState == CardState::ABSENT) {
62 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::SIM_ABSENT}));
63 } else if (cardStatus.base.cardState == CardState::PRESENT) {
64 // REQUEST_NOT_SUPPORTED should not be allowed as it is not an optional API. However, the
65 // comments in the hal were not updated to indicate that, hence allowing it as a valid
66 // error for now. This should be fixed correctly, possibly in a future version of the hal
67 // (b/110421924). This is being allowed because some vendors do not support
68 // this request on dual sim devices.
69 // OPERATION_NOT_ALLOWED should not be allowed; however, some vendors do not support the
70 // required manual GSM search functionality. This is tracked in b/112206766.
71 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
72 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,
73 RadioError::OPERATION_NOT_ALLOWED}));
74 }
75
76 if (radioRsp_v1_2->rspInfo.error == RadioError::NONE) {
77 ALOGI("Stop Network Scan");
78 stopNetworkScan();
79 }
80 }
81
82 /*
83 * Test IRadio.startNetworkScan() with invalid specifier.
84 */
TEST_P(RadioHidlTest_v1_2,startNetworkScan_InvalidArgument)85 TEST_P(RadioHidlTest_v1_2, startNetworkScan_InvalidArgument) {
86 serial = GetRandomSerialNumber();
87
88 ::android::hardware::radio::V1_2::NetworkScanRequest request = {.type = ScanType::ONE_SHOT,
89 .interval = 60};
90
91 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
92 ASSERT_OK(res);
93 EXPECT_EQ(std::cv_status::no_timeout, wait());
94 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
95 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
96
97 ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
98 toString(radioRsp_v1_2->rspInfo.error).c_str());
99 if (cardStatus.base.cardState == CardState::ABSENT) {
100 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
101 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
102 } else if (cardStatus.base.cardState == CardState::PRESENT) {
103 ASSERT_TRUE(
104 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
105 {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
106 }
107 }
108
109 /*
110 * Test IRadio.startNetworkScan() with invalid interval (lower boundary).
111 */
TEST_P(RadioHidlTest_v1_2,startNetworkScan_InvalidInterval1)112 TEST_P(RadioHidlTest_v1_2, startNetworkScan_InvalidInterval1) {
113 serial = GetRandomSerialNumber();
114
115 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
116 .type = ScanType::ONE_SHOT,
117 .interval = 4,
118 .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
119 .maxSearchTime = 60,
120 .incrementalResults = false,
121 .incrementalResultsPeriodicity = 1};
122
123 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
124 ASSERT_OK(res);
125 EXPECT_EQ(std::cv_status::no_timeout, wait());
126 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
127 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
128
129 ALOGI("startNetworkScan_InvalidInterval1, rspInfo.error = %s\n",
130 toString(radioRsp_v1_2->rspInfo.error).c_str());
131 if (cardStatus.base.cardState == CardState::ABSENT) {
132 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
133 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
134 } else if (cardStatus.base.cardState == CardState::PRESENT) {
135 ASSERT_TRUE(
136 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
137 {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
138 }
139 }
140
141 /*
142 * Test IRadio.startNetworkScan() with invalid interval (upper boundary).
143 */
TEST_P(RadioHidlTest_v1_2,startNetworkScan_InvalidInterval2)144 TEST_P(RadioHidlTest_v1_2, startNetworkScan_InvalidInterval2) {
145 serial = GetRandomSerialNumber();
146
147 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
148 .type = ScanType::ONE_SHOT,
149 .interval = 301,
150 .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
151 .maxSearchTime = 60,
152 .incrementalResults = false,
153 .incrementalResultsPeriodicity = 1};
154
155 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
156 ASSERT_OK(res);
157 EXPECT_EQ(std::cv_status::no_timeout, wait());
158 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
159 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
160
161 ALOGI("startNetworkScan_InvalidInterval2, rspInfo.error = %s\n",
162 toString(radioRsp_v1_2->rspInfo.error).c_str());
163 if (cardStatus.base.cardState == CardState::ABSENT) {
164 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
165 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
166 } else if (cardStatus.base.cardState == CardState::PRESENT) {
167 ASSERT_TRUE(
168 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
169 {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
170 }
171 }
172
173 /*
174 * Test IRadio.startNetworkScan() with invalid max search time (lower boundary).
175 */
TEST_P(RadioHidlTest_v1_2,startNetworkScan_InvalidMaxSearchTime1)176 TEST_P(RadioHidlTest_v1_2, startNetworkScan_InvalidMaxSearchTime1) {
177 serial = GetRandomSerialNumber();
178
179 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
180 .type = ScanType::ONE_SHOT,
181 .interval = 60,
182 .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
183 .maxSearchTime = 59,
184 .incrementalResults = false,
185 .incrementalResultsPeriodicity = 1};
186
187 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
188 ASSERT_OK(res);
189 EXPECT_EQ(std::cv_status::no_timeout, wait());
190 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
191 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
192
193 ALOGI("startNetworkScan_InvalidMaxSearchTime1, rspInfo.error = %s\n",
194 toString(radioRsp_v1_2->rspInfo.error).c_str());
195 if (cardStatus.base.cardState == CardState::ABSENT) {
196 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
197 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
198 } else if (cardStatus.base.cardState == CardState::PRESENT) {
199 ASSERT_TRUE(
200 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
201 {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
202 }
203 }
204
205 /*
206 * Test IRadio.startNetworkScan() with invalid max search time (upper boundary).
207 */
TEST_P(RadioHidlTest_v1_2,startNetworkScan_InvalidMaxSearchTime2)208 TEST_P(RadioHidlTest_v1_2, startNetworkScan_InvalidMaxSearchTime2) {
209 serial = GetRandomSerialNumber();
210
211 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
212 .type = ScanType::ONE_SHOT,
213 .interval = 60,
214 .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
215 .maxSearchTime = 3601,
216 .incrementalResults = false,
217 .incrementalResultsPeriodicity = 1};
218
219 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
220 ASSERT_OK(res);
221 EXPECT_EQ(std::cv_status::no_timeout, wait());
222 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
223 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
224
225 ALOGI("startNetworkScan_InvalidMaxSearchTime2, rspInfo.error = %s\n",
226 toString(radioRsp_v1_2->rspInfo.error).c_str());
227 if (cardStatus.base.cardState == CardState::ABSENT) {
228 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
229 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
230 } else if (cardStatus.base.cardState == CardState::PRESENT) {
231 ASSERT_TRUE(
232 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
233 {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
234 }
235 }
236
237 /*
238 * Test IRadio.startNetworkScan() with invalid periodicity (lower boundary).
239 */
TEST_P(RadioHidlTest_v1_2,startNetworkScan_InvalidPeriodicity1)240 TEST_P(RadioHidlTest_v1_2, startNetworkScan_InvalidPeriodicity1) {
241 serial = GetRandomSerialNumber();
242
243 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
244 .type = ScanType::ONE_SHOT,
245 .interval = 60,
246 .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
247 .maxSearchTime = 600,
248 .incrementalResults = true,
249 .incrementalResultsPeriodicity = 0};
250
251 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
252 ASSERT_OK(res);
253 EXPECT_EQ(std::cv_status::no_timeout, wait());
254 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
255 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
256
257 ALOGI("startNetworkScan_InvalidPeriodicity1, rspInfo.error = %s\n",
258 toString(radioRsp_v1_2->rspInfo.error).c_str());
259 if (cardStatus.base.cardState == CardState::ABSENT) {
260 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
261 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
262 } else if (cardStatus.base.cardState == CardState::PRESENT) {
263 ASSERT_TRUE(
264 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
265 {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
266 }
267 }
268
269 /*
270 * Test IRadio.startNetworkScan() with invalid periodicity (upper boundary).
271 */
TEST_P(RadioHidlTest_v1_2,startNetworkScan_InvalidPeriodicity2)272 TEST_P(RadioHidlTest_v1_2, startNetworkScan_InvalidPeriodicity2) {
273 serial = GetRandomSerialNumber();
274
275 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
276 .type = ScanType::ONE_SHOT,
277 .interval = 60,
278 .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
279 .maxSearchTime = 600,
280 .incrementalResults = true,
281 .incrementalResultsPeriodicity = 11};
282
283 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
284 ASSERT_OK(res);
285 EXPECT_EQ(std::cv_status::no_timeout, wait());
286 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
287 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
288
289 ALOGI("startNetworkScan_InvalidPeriodicity2, rspInfo.error = %s\n",
290 toString(radioRsp_v1_2->rspInfo.error).c_str());
291 if (cardStatus.base.cardState == CardState::ABSENT) {
292 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
293 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
294 } else if (cardStatus.base.cardState == CardState::PRESENT) {
295 ASSERT_TRUE(
296 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
297 {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
298 }
299 }
300
301 /*
302 * The following test is disabled due to b/112206766
303 *
304 * Test IRadio.startNetworkScan() with valid periodicity
305 */
TEST_P(RadioHidlTest_v1_2,DISABLED_startNetworkScan_GoodRequest1)306 TEST_P(RadioHidlTest_v1_2, DISABLED_startNetworkScan_GoodRequest1) {
307 serial = GetRandomSerialNumber();
308
309 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
310 .type = ScanType::ONE_SHOT,
311 .interval = 60,
312 .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
313 // Some vendor may not support max search time of 360s.
314 // This issue is tracked in b/112205669.
315 .maxSearchTime = 300,
316 .incrementalResults = false,
317 .incrementalResultsPeriodicity = 10};
318
319 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
320 ASSERT_OK(res);
321 EXPECT_EQ(std::cv_status::no_timeout, wait());
322 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
323 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
324
325 ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
326 toString(radioRsp_v1_2->rspInfo.error).c_str());
327 if (cardStatus.base.cardState == CardState::ABSENT) {
328 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
329 {RadioError::NONE, RadioError::SIM_ABSENT}));
330 } else if (cardStatus.base.cardState == CardState::PRESENT) {
331 ASSERT_TRUE(CheckAnyOfErrors(
332 radioRsp_v1_2->rspInfo.error,
333 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
334 }
335 }
336
337 /*
338 * The following test is disabled due to b/112206766
339 *
340 * Test IRadio.startNetworkScan() with valid periodicity and plmns
341 */
TEST_P(RadioHidlTest_v1_2,DISABLED_startNetworkScan_GoodRequest2)342 TEST_P(RadioHidlTest_v1_2, DISABLED_startNetworkScan_GoodRequest2) {
343 serial = GetRandomSerialNumber();
344
345 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
346 .type = ScanType::ONE_SHOT,
347 .interval = 60,
348 .specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
349 // Some vendor may not support max search time of 360s.
350 // This issue is tracked in b/112205669.
351 .maxSearchTime = 300,
352 .incrementalResults = false,
353 .incrementalResultsPeriodicity = 10,
354 .mccMncs = {"310410"}};
355
356 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
357 ASSERT_OK(res);
358 EXPECT_EQ(std::cv_status::no_timeout, wait());
359 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
360 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
361
362 ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
363 toString(radioRsp_v1_2->rspInfo.error).c_str());
364 if (cardStatus.base.cardState == CardState::ABSENT) {
365 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
366 {RadioError::NONE, RadioError::SIM_ABSENT}));
367 } else if (cardStatus.base.cardState == CardState::PRESENT) {
368 ASSERT_TRUE(CheckAnyOfErrors(
369 radioRsp_v1_2->rspInfo.error,
370 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
371 }
372 }
373
374 /*
375 * Test IRadio.setIndicationFilter_1_2()
376 */
TEST_P(RadioHidlTest_v1_2,setIndicationFilter_1_2)377 TEST_P(RadioHidlTest_v1_2, setIndicationFilter_1_2) {
378 serial = GetRandomSerialNumber();
379
380 Return<void> res = radio_v1_2->setIndicationFilter_1_2(
381 serial, static_cast<int>(::android::hardware::radio::V1_2::IndicationFilter::ALL));
382 ASSERT_OK(res);
383 EXPECT_EQ(std::cv_status::no_timeout, wait());
384 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
385 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
386
387 ALOGI("setIndicationFilter_1_2, rspInfo.error = %s\n",
388 toString(radioRsp_v1_2->rspInfo.error).c_str());
389 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
390 }
391
392 /*
393 * Test IRadio.setSignalStrengthReportingCriteria() with invalid hysteresisDb
394 */
TEST_P(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_invalidHysteresisDb)395 TEST_P(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_invalidHysteresisDb) {
396 serial = GetRandomSerialNumber();
397
398 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
399 serial, 5000,
400 10, // hysteresisDb too large given threshold list deltas
401 {-109, -103, -97, -89}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
402 ASSERT_OK(res);
403 EXPECT_EQ(std::cv_status::no_timeout, wait());
404 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
405 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
406
407 ALOGI("setSignalStrengthReportingCriteria_invalidHysteresisDb, rspInfo.error = %s\n",
408 toString(radioRsp_v1_2->rspInfo.error).c_str());
409 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
410 }
411
412 /*
413 * Test IRadio.setSignalStrengthReportingCriteria() with empty parameters
414 */
TEST_P(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_EmptyParams)415 TEST_P(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_EmptyParams) {
416 serial = GetRandomSerialNumber();
417
418 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
419 serial, 0, 0, {}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
420 ASSERT_OK(res);
421 EXPECT_EQ(std::cv_status::no_timeout, wait());
422 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
423 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
424
425 ALOGI("setSignalStrengthReportingCriteria_EmptyParams, rspInfo.error = %s\n",
426 toString(radioRsp_v1_2->rspInfo.error).c_str());
427 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
428 }
429
430 /*
431 * Test IRadio.setSignalStrengthReportingCriteria() for GERAN
432 */
TEST_P(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_Geran)433 TEST_P(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Geran) {
434 serial = GetRandomSerialNumber();
435
436 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
437 serial, 5000, 2, {-109, -103, -97, -89},
438 ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
439 ASSERT_OK(res);
440 EXPECT_EQ(std::cv_status::no_timeout, wait());
441 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
442 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
443
444 ALOGI("setSignalStrengthReportingCriteria_Geran, rspInfo.error = %s\n",
445 toString(radioRsp_v1_2->rspInfo.error).c_str());
446 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
447 }
448
449 /*
450 * Test IRadio.setSignalStrengthReportingCriteria() for UTRAN
451 */
TEST_P(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_Utran)452 TEST_P(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Utran) {
453 serial = GetRandomSerialNumber();
454
455 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
456 serial, 5000, 2, {-110, -97, -73, -49, -25},
457 ::android::hardware::radio::V1_2::AccessNetwork::UTRAN);
458 ASSERT_OK(res);
459 EXPECT_EQ(std::cv_status::no_timeout, wait());
460 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
461 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
462
463 ALOGI("setSignalStrengthReportingCriteria_Utran, rspInfo.error = %s\n",
464 toString(radioRsp_v1_2->rspInfo.error).c_str());
465 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
466 }
467
468 /*
469 * Test IRadio.setSignalStrengthReportingCriteria() for EUTRAN
470 */
TEST_P(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_Eutran)471 TEST_P(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Eutran) {
472 serial = GetRandomSerialNumber();
473
474 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
475 serial, 5000, 2, {-140, -128, -118, -108, -98, -44},
476 ::android::hardware::radio::V1_2::AccessNetwork::EUTRAN);
477 ASSERT_OK(res);
478 EXPECT_EQ(std::cv_status::no_timeout, wait());
479 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
480 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
481
482 ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
483 toString(radioRsp_v1_2->rspInfo.error).c_str());
484 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
485 }
486
487 /*
488 * Test IRadio.setSignalStrengthReportingCriteria() for CDMA2000
489 */
TEST_P(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_Cdma2000)490 TEST_P(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Cdma2000) {
491 serial = GetRandomSerialNumber();
492
493 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
494 serial, 5000, 2, {-105, -90, -75, -65},
495 ::android::hardware::radio::V1_2::AccessNetwork::CDMA2000);
496 ASSERT_OK(res);
497 EXPECT_EQ(std::cv_status::no_timeout, wait());
498 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
499 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
500
501 ALOGI("setSignalStrengthReportingCriteria_Cdma2000, rspInfo.error = %s\n",
502 toString(radioRsp_v1_2->rspInfo.error).c_str());
503 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
504 }
505
506 /*
507 * Test IRadio.setLinkCapacityReportingCriteria() invalid hysteresisDlKbps
508 */
TEST_P(RadioHidlTest_v1_2,setLinkCapacityReportingCriteria_invalidHysteresisDlKbps)509 TEST_P(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_invalidHysteresisDlKbps) {
510 serial = GetRandomSerialNumber();
511
512 Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
513 serial, 5000,
514 5000, // hysteresisDlKbps too big for thresholds delta
515 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
516 ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
517 ASSERT_OK(res);
518 EXPECT_EQ(std::cv_status::no_timeout, wait());
519 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
520 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
521
522 ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisDlKbps, rspInfo.error = %s\n",
523 toString(radioRsp_v1_2->rspInfo.error).c_str());
524 // Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported for
525 // GERAN
526 ASSERT_TRUE(
527 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
528 {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
529 }
530
531 /*
532 * Test IRadio.setLinkCapacityReportingCriteria() invalid hysteresisUlKbps
533 */
TEST_P(RadioHidlTest_v1_2,setLinkCapacityReportingCriteria_invalidHysteresisUlKbps)534 TEST_P(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_invalidHysteresisUlKbps) {
535 serial = GetRandomSerialNumber();
536
537 Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
538 serial, 5000, 500,
539 1000, // hysteresisUlKbps too big for thresholds delta
540 {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
541 ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
542 ASSERT_OK(res);
543 EXPECT_EQ(std::cv_status::no_timeout, wait());
544 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
545 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
546
547 ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
548 toString(radioRsp_v1_2->rspInfo.error).c_str());
549 // Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported for
550 // GERAN
551 ASSERT_TRUE(
552 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
553 {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
554 }
555
556 /*
557 * Test IRadio.setLinkCapacityReportingCriteria() empty params
558 */
TEST_P(RadioHidlTest_v1_2,setLinkCapacityReportingCriteria_emptyParams)559 TEST_P(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_emptyParams) {
560 serial = GetRandomSerialNumber();
561
562 Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
563 serial, 0, 0, 0, {}, {}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
564 ASSERT_OK(res);
565 EXPECT_EQ(std::cv_status::no_timeout, wait());
566 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
567 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
568
569 ALOGI("setLinkCapacityReportingCriteria_emptyParams, rspInfo.error = %s\n",
570 toString(radioRsp_v1_2->rspInfo.error).c_str());
571 // Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported for
572 // GERAN
573 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
574 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
575 }
576
577 /*
578 * Test IRadio.setLinkCapacityReportingCriteria() GERAN
579 */
TEST_P(RadioHidlTest_v1_2,setLinkCapacityReportingCriteria_Geran)580 TEST_P(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_Geran) {
581 serial = GetRandomSerialNumber();
582
583 Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
584 serial, 5000, 500, 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
585 ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
586 ASSERT_OK(res);
587 EXPECT_EQ(std::cv_status::no_timeout, wait());
588 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
589 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
590
591 ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
592 toString(radioRsp_v1_2->rspInfo.error).c_str());
593 // Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported for
594 // GERAN
595 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
596 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
597 }
598
599 /*
600 * Test IRadio.setupDataCall_1_2() for the response returned.
601 */
TEST_P(RadioHidlTest_v1_2,setupDataCall_1_2)602 TEST_P(RadioHidlTest_v1_2, setupDataCall_1_2) {
603 serial = GetRandomSerialNumber();
604
605 ::android::hardware::radio::V1_2::AccessNetwork accessNetwork =
606 ::android::hardware::radio::V1_2::AccessNetwork::EUTRAN;
607
608 DataProfileInfo dataProfileInfo;
609 memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
610 dataProfileInfo.profileId = DataProfileId::IMS;
611 dataProfileInfo.apn = hidl_string("VZWIMS");
612 dataProfileInfo.protocol = hidl_string("IPV4V6");
613 dataProfileInfo.roamingProtocol = hidl_string("IPV6");
614 dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
615 dataProfileInfo.user = "";
616 dataProfileInfo.password = "";
617 dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
618 dataProfileInfo.maxConnsTime = 300;
619 dataProfileInfo.maxConns = 20;
620 dataProfileInfo.waitTime = 0;
621 dataProfileInfo.enabled = true;
622 dataProfileInfo.supportedApnTypesBitmap = 320;
623 dataProfileInfo.bearerBitmap = 161543;
624 dataProfileInfo.mtu = 0;
625 dataProfileInfo.mvnoType = MvnoType::NONE;
626 dataProfileInfo.mvnoMatchData = hidl_string();
627
628 bool modemCognitive = false;
629 bool roamingAllowed = false;
630 bool isRoaming = false;
631
632 ::android::hardware::radio::V1_2::DataRequestReason reason =
633 ::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
634 std::vector<hidl_string> addresses = {""};
635 std::vector<hidl_string> dnses = {""};
636
637 Return<void> res = radio_v1_2->setupDataCall_1_2(serial, accessNetwork, dataProfileInfo,
638 modemCognitive, roamingAllowed, isRoaming,
639 reason, addresses, dnses);
640 ASSERT_OK(res);
641
642 EXPECT_EQ(std::cv_status::no_timeout, wait());
643 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
644 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
645
646 if (cardStatus.base.cardState == CardState::ABSENT) {
647 ASSERT_TRUE(CheckAnyOfErrors(
648 radioRsp_v1_2->rspInfo.error,
649 {RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
650 RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW, RadioError::REQUEST_NOT_SUPPORTED}));
651 } else if (cardStatus.base.cardState == CardState::PRESENT) {
652 ASSERT_TRUE(CheckAnyOfErrors(
653 radioRsp_v1_2->rspInfo.error,
654 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
655 RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW, RadioError::REQUEST_NOT_SUPPORTED}));
656 }
657 }
658
659 /*
660 * Test IRadio.deactivateDataCall_1_2() for the response returned.
661 */
TEST_P(RadioHidlTest_v1_2,deactivateDataCall_1_2)662 TEST_P(RadioHidlTest_v1_2, deactivateDataCall_1_2) {
663 serial = GetRandomSerialNumber();
664 int cid = 1;
665 ::android::hardware::radio::V1_2::DataRequestReason reason =
666 ::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
667
668 Return<void> res = radio_v1_2->deactivateDataCall_1_2(serial, cid, reason);
669 ASSERT_OK(res);
670
671 EXPECT_EQ(std::cv_status::no_timeout, wait());
672 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
673 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
674
675 if (cardStatus.base.cardState == CardState::ABSENT) {
676 ASSERT_TRUE(CheckAnyOfErrors(
677 radioRsp_v1_2->rspInfo.error,
678 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_CALL_ID,
679 RadioError::INVALID_STATE, RadioError::INVALID_ARGUMENTS,
680 RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED, RadioError::SIM_ABSENT}));
681 } else if (cardStatus.base.cardState == CardState::PRESENT) {
682 ASSERT_TRUE(CheckAnyOfErrors(
683 radioRsp_v1_2->rspInfo.error,
684 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_CALL_ID,
685 RadioError::INVALID_STATE, RadioError::INVALID_ARGUMENTS,
686 RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED}));
687 }
688 }
689
690 /*
691 * Test IRadio.getCellInfoList() for the response returned.
692 */
TEST_P(RadioHidlTest_v1_2,getCellInfoList_1_2)693 TEST_P(RadioHidlTest_v1_2, getCellInfoList_1_2) {
694 serial = GetRandomSerialNumber();
695
696 Return<void> res = radio_v1_2->getCellInfoList(serial);
697 ASSERT_OK(res);
698 EXPECT_EQ(std::cv_status::no_timeout, wait());
699 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
700 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
701
702 ALOGI("getCellInfoList_1_2, rspInfo.error = %s\n",
703 toString(radioRsp_v1_2->rspInfo.error).c_str());
704 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
705 {RadioError::NONE, RadioError::NO_NETWORK_FOUND}));
706 }
707
708 /*
709 * Test IRadio.getVoiceRegistrationState() for the response returned.
710 */
TEST_P(RadioHidlTest_v1_2,getVoiceRegistrationState)711 TEST_P(RadioHidlTest_v1_2, getVoiceRegistrationState) {
712 serial = GetRandomSerialNumber();
713
714 Return<void> res = radio_v1_2->getVoiceRegistrationState(serial);
715 ASSERT_OK(res);
716 EXPECT_EQ(std::cv_status::no_timeout, wait());
717 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
718 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
719
720 ALOGI("getVoiceRegistrationStateResponse_1_2, rspInfo.error = %s\n",
721 toString(radioRsp_v1_2->rspInfo.error).c_str());
722 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
723 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
724 }
725
726 /*
727 * Test IRadio.getDataRegistrationState() for the response returned.
728 */
TEST_P(RadioHidlTest_v1_2,getDataRegistrationState)729 TEST_P(RadioHidlTest_v1_2, getDataRegistrationState) {
730 serial = GetRandomSerialNumber();
731
732 Return<void> res = radio_v1_2->getDataRegistrationState(serial);
733 ASSERT_OK(res);
734 EXPECT_EQ(std::cv_status::no_timeout, wait());
735 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
736 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
737
738 ALOGI("getDataRegistrationStateResponse_1_2, rspInfo.error = %s\n",
739 toString(radioRsp_v1_2->rspInfo.error).c_str());
740 ASSERT_TRUE(CheckAnyOfErrors(
741 radioRsp_v1_2->rspInfo.error,
742 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NOT_PROVISIONED}));
743
744 // Check the mcc [0, 999] and mnc [0, 999].
745 string hidl_mcc;
746 string hidl_mnc;
747 bool checkMccMnc = true;
748 int totalIdentitySizeExpected = 1;
749 ::android::hardware::radio::V1_2::CellIdentity cellIdentities =
750 radioRsp_v1_2->dataRegResp.cellIdentity;
751 CellInfoType cellInfoType = cellIdentities.cellInfoType;
752
753 if (cellInfoType == CellInfoType::NONE) {
754 // All the fields are 0
755 totalIdentitySizeExpected = 0;
756 checkMccMnc = false;
757 } else if (cellInfoType == CellInfoType::GSM) {
758 EXPECT_EQ(1, cellIdentities.cellIdentityGsm.size());
759 ::android::hardware::radio::V1_2::CellIdentityGsm cig = cellIdentities.cellIdentityGsm[0];
760 hidl_mcc = cig.base.mcc;
761 hidl_mnc = cig.base.mnc;
762 } else if (cellInfoType == CellInfoType::LTE) {
763 EXPECT_EQ(1, cellIdentities.cellIdentityLte.size());
764 ::android::hardware::radio::V1_2::CellIdentityLte cil = cellIdentities.cellIdentityLte[0];
765 hidl_mcc = cil.base.mcc;
766 hidl_mnc = cil.base.mnc;
767 } else if (cellInfoType == CellInfoType::WCDMA) {
768 EXPECT_EQ(1, cellIdentities.cellIdentityWcdma.size());
769 ::android::hardware::radio::V1_2::CellIdentityWcdma ciw =
770 cellIdentities.cellIdentityWcdma[0];
771 hidl_mcc = ciw.base.mcc;
772 hidl_mnc = ciw.base.mnc;
773 } else if (cellInfoType == CellInfoType::TD_SCDMA) {
774 EXPECT_EQ(1, cellIdentities.cellIdentityTdscdma.size());
775 ::android::hardware::radio::V1_2::CellIdentityTdscdma cit =
776 cellIdentities.cellIdentityTdscdma[0];
777 hidl_mcc = cit.base.mcc;
778 hidl_mnc = cit.base.mnc;
779 } else {
780 // CellIndentityCdma has no mcc and mnc.
781 EXPECT_EQ(CellInfoType::CDMA, cellInfoType);
782 EXPECT_EQ(1, cellIdentities.cellIdentityCdma.size());
783 checkMccMnc = false;
784 }
785
786 // Check only one CellIdentity is size 1, and others must be 0.
787 EXPECT_EQ(totalIdentitySizeExpected,
788 cellIdentities.cellIdentityGsm.size() + cellIdentities.cellIdentityCdma.size() +
789 cellIdentities.cellIdentityLte.size() + cellIdentities.cellIdentityWcdma.size() +
790 cellIdentities.cellIdentityTdscdma.size());
791
792 // 32 bit system might return invalid mcc and mnc hidl string "\xff\xff..."
793 if (checkMccMnc && hidl_mcc.size() < 4 && hidl_mnc.size() < 4) {
794 int mcc = stoi(hidl_mcc);
795 int mnc = stoi(hidl_mnc);
796 EXPECT_TRUE(mcc >= 0 && mcc <= 999);
797 EXPECT_TRUE(mnc >= 0 && mnc <= 999);
798 }
799 }
800
801 /*
802 * Test IRadio.getAvailableBandModes() for the response returned.
803 */
TEST_P(RadioHidlTest_v1_2,getAvailableBandModes)804 TEST_P(RadioHidlTest_v1_2, getAvailableBandModes) {
805 serial = GetRandomSerialNumber();
806
807 Return<void> res = radio_v1_2->getAvailableBandModes(serial);
808 ASSERT_OK(res);
809 EXPECT_EQ(std::cv_status::no_timeout, wait());
810 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
811 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
812 ALOGI("getAvailableBandModes, rspInfo.error = %s\n",
813 toString(radioRsp_v1_2->rspInfo.error).c_str());
814 ASSERT_TRUE(
815 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
816 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR,
817 RadioError::INTERNAL_ERR,
818 // If REQUEST_NOT_SUPPORTED is returned, then it should also be returned
819 // for setRandMode().
820 RadioError::REQUEST_NOT_SUPPORTED}));
821 bool hasUnspecifiedBandMode = false;
822 if (radioRsp_v1_2->rspInfo.error == RadioError::NONE) {
823 for (const RadioBandMode& mode : radioRsp_v1_2->radioBandModes) {
824 // Automatic mode selection must be supported
825 if (mode == RadioBandMode::BAND_MODE_UNSPECIFIED) hasUnspecifiedBandMode = true;
826 }
827 ASSERT_TRUE(hasUnspecifiedBandMode);
828 }
829 }
830