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 /*
23 * Test IRadio.startNetworkScan() for the response returned.
24 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan)25 TEST_F(RadioHidlTest_v1_2, startNetworkScan) {
26 serial = GetRandomSerialNumber();
27
28 RadioAccessSpecifier specifier = {
29 .radioAccessNetwork = RadioAccessNetworks::GERAN,
30 .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
31 .channels = {1,2}};
32
33 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
34 .type = ScanType::ONE_SHOT, .interval = 60, .specifiers = {specifier}};
35
36 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
37 ASSERT_OK(res);
38 EXPECT_EQ(std::cv_status::no_timeout, wait());
39 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
40 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
41
42 ALOGI("startNetworkScan, rspInfo.error = %s\n", toString(radioRsp_v1_2->rspInfo.error).c_str());
43 if (cardStatus.base.cardState == CardState::ABSENT) {
44 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::SIM_ABSENT}));
45 } else if (cardStatus.base.cardState == CardState::PRESENT) {
46 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
47 }
48 }
49
50 /*
51 * Test IRadio.startNetworkScan() with invalid specifier.
52 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan_InvalidArgument)53 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidArgument) {
54 serial = GetRandomSerialNumber();
55
56 ::android::hardware::radio::V1_2::NetworkScanRequest request = {.type = ScanType::ONE_SHOT,
57 .interval = 60};
58
59 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
60 ASSERT_OK(res);
61 EXPECT_EQ(std::cv_status::no_timeout, wait());
62 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
63 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
64
65 ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
66 toString(radioRsp_v1_2->rspInfo.error).c_str());
67 if (cardStatus.base.cardState == CardState::ABSENT) {
68 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
69 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
70 } else if (cardStatus.base.cardState == CardState::PRESENT) {
71 ASSERT_TRUE(
72 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
73 }
74 }
75
76 /*
77 * Test IRadio.startNetworkScan() with invalid interval (lower boundary).
78 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan_InvalidInterval1)79 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidInterval1) {
80 serial = GetRandomSerialNumber();
81
82 RadioAccessSpecifier specifier = {
83 .radioAccessNetwork = RadioAccessNetworks::GERAN,
84 .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
85 .channels = {1,2}};
86
87 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
88 .type = ScanType::ONE_SHOT,
89 .interval = 4,
90 .specifiers = {specifier},
91 .maxSearchTime = 60,
92 .incrementalResults = false,
93 .incrementalResultsPeriodicity = 1};
94
95 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
96 ASSERT_OK(res);
97 EXPECT_EQ(std::cv_status::no_timeout, wait());
98 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
99 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
100
101 ALOGI("startNetworkScan_InvalidInterval1, rspInfo.error = %s\n",
102 toString(radioRsp_v1_2->rspInfo.error).c_str());
103 if (cardStatus.base.cardState == CardState::ABSENT) {
104 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
105 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
106 } else if (cardStatus.base.cardState == CardState::PRESENT) {
107 ASSERT_TRUE(
108 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
109 }
110 }
111
112 /*
113 * Test IRadio.startNetworkScan() with invalid interval (upper boundary).
114 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan_InvalidInterval2)115 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidInterval2) {
116 serial = GetRandomSerialNumber();
117
118 RadioAccessSpecifier specifier = {
119 .radioAccessNetwork = RadioAccessNetworks::GERAN,
120 .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
121 .channels = {1,2}};
122
123 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
124 .type = ScanType::ONE_SHOT,
125 .interval = 301,
126 .specifiers = {specifier},
127 .maxSearchTime = 60,
128 .incrementalResults = false,
129 .incrementalResultsPeriodicity = 1};
130
131 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
132 ASSERT_OK(res);
133 EXPECT_EQ(std::cv_status::no_timeout, wait());
134 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
135 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
136
137 ALOGI("startNetworkScan_InvalidInterval2, rspInfo.error = %s\n",
138 toString(radioRsp_v1_2->rspInfo.error).c_str());
139 if (cardStatus.base.cardState == CardState::ABSENT) {
140 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
141 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
142 } else if (cardStatus.base.cardState == CardState::PRESENT) {
143 ASSERT_TRUE(
144 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
145 }
146 }
147
148 /*
149 * Test IRadio.startNetworkScan() with invalid max search time (lower boundary).
150 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan_InvalidMaxSearchTime1)151 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidMaxSearchTime1) {
152 serial = GetRandomSerialNumber();
153
154 RadioAccessSpecifier specifier = {
155 .radioAccessNetwork = RadioAccessNetworks::GERAN,
156 .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
157 .channels = {1,2}};
158
159 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
160 .type = ScanType::ONE_SHOT,
161 .interval = 60,
162 .specifiers = {specifier},
163 .maxSearchTime = 59,
164 .incrementalResults = false,
165 .incrementalResultsPeriodicity = 1};
166
167 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
168 ASSERT_OK(res);
169 EXPECT_EQ(std::cv_status::no_timeout, wait());
170 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
171 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
172
173 ALOGI("startNetworkScan_InvalidMaxSearchTime1, rspInfo.error = %s\n",
174 toString(radioRsp_v1_2->rspInfo.error).c_str());
175 if (cardStatus.base.cardState == CardState::ABSENT) {
176 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
177 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
178 } else if (cardStatus.base.cardState == CardState::PRESENT) {
179 ASSERT_TRUE(
180 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
181 }
182 }
183
184 /*
185 * Test IRadio.startNetworkScan() with invalid max search time (upper boundary).
186 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan_InvalidMaxSearchTime2)187 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidMaxSearchTime2) {
188 serial = GetRandomSerialNumber();
189
190 RadioAccessSpecifier specifier = {
191 .radioAccessNetwork = RadioAccessNetworks::GERAN,
192 .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
193 .channels = {1,2}};
194
195 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
196 .type = ScanType::ONE_SHOT,
197 .interval = 60,
198 .specifiers = {specifier},
199 .maxSearchTime = 3601,
200 .incrementalResults = false,
201 .incrementalResultsPeriodicity = 1};
202
203 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
204 ASSERT_OK(res);
205 EXPECT_EQ(std::cv_status::no_timeout, wait());
206 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
207 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
208
209 ALOGI("startNetworkScan_InvalidMaxSearchTime2, rspInfo.error = %s\n",
210 toString(radioRsp_v1_2->rspInfo.error).c_str());
211 if (cardStatus.base.cardState == CardState::ABSENT) {
212 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
213 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
214 } else if (cardStatus.base.cardState == CardState::PRESENT) {
215 ASSERT_TRUE(
216 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
217 }
218 }
219
220 /*
221 * Test IRadio.startNetworkScan() with invalid periodicity (lower boundary).
222 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan_InvalidPeriodicity1)223 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidPeriodicity1) {
224 serial = GetRandomSerialNumber();
225
226 RadioAccessSpecifier specifier = {
227 .radioAccessNetwork = RadioAccessNetworks::GERAN,
228 .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
229 .channels = {1,2}};
230
231 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
232 .type = ScanType::ONE_SHOT,
233 .interval = 60,
234 .specifiers = {specifier},
235 .maxSearchTime = 600,
236 .incrementalResults = false,
237 .incrementalResultsPeriodicity = 0};
238
239 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
240 ASSERT_OK(res);
241 EXPECT_EQ(std::cv_status::no_timeout, wait());
242 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
243 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
244
245 ALOGI("startNetworkScan_InvalidPeriodicity1, rspInfo.error = %s\n",
246 toString(radioRsp_v1_2->rspInfo.error).c_str());
247 if (cardStatus.base.cardState == CardState::ABSENT) {
248 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
249 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
250 } else if (cardStatus.base.cardState == CardState::PRESENT) {
251 ASSERT_TRUE(
252 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
253 }
254 }
255
256 /*
257 * Test IRadio.startNetworkScan() with invalid periodicity (upper boundary).
258 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan_InvalidPeriodicity2)259 TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidPeriodicity2) {
260 serial = GetRandomSerialNumber();
261
262 RadioAccessSpecifier specifier = {
263 .radioAccessNetwork = RadioAccessNetworks::GERAN,
264 .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
265 .channels = {1,2}};
266
267 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
268 .type = ScanType::ONE_SHOT,
269 .interval = 60,
270 .specifiers = {specifier},
271 .maxSearchTime = 600,
272 .incrementalResults = false,
273 .incrementalResultsPeriodicity = 11};
274
275 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
276 ASSERT_OK(res);
277 EXPECT_EQ(std::cv_status::no_timeout, wait());
278 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
279 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
280
281 ALOGI("startNetworkScan_InvalidPeriodicity2, rspInfo.error = %s\n",
282 toString(radioRsp_v1_2->rspInfo.error).c_str());
283 if (cardStatus.base.cardState == CardState::ABSENT) {
284 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
285 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
286 } else if (cardStatus.base.cardState == CardState::PRESENT) {
287 ASSERT_TRUE(
288 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
289 }
290 }
291
292 /*
293 * Test IRadio.startNetworkScan() with valid periodicity
294 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan_GoodRequest1)295 TEST_F(RadioHidlTest_v1_2, startNetworkScan_GoodRequest1) {
296 serial = GetRandomSerialNumber();
297
298 RadioAccessSpecifier specifier = {
299 .radioAccessNetwork = RadioAccessNetworks::GERAN,
300 .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
301 .channels = {1,2}};
302
303 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
304 .type = ScanType::ONE_SHOT,
305 .interval = 60,
306 .specifiers = {specifier},
307 .maxSearchTime = 600,
308 .incrementalResults = false,
309 .incrementalResultsPeriodicity = 10};
310
311 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
312 ASSERT_OK(res);
313 EXPECT_EQ(std::cv_status::no_timeout, wait());
314 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
315 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
316
317 ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
318 toString(radioRsp_v1_2->rspInfo.error).c_str());
319 if (cardStatus.base.cardState == CardState::ABSENT) {
320 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
321 {RadioError::NONE, RadioError::SIM_ABSENT}));
322 } else if (cardStatus.base.cardState == CardState::PRESENT) {
323 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
324 }
325 }
326
327 /*
328 * Test IRadio.startNetworkScan() with valid periodicity and plmns
329 */
TEST_F(RadioHidlTest_v1_2,startNetworkScan_GoodRequest2)330 TEST_F(RadioHidlTest_v1_2, startNetworkScan_GoodRequest2) {
331 serial = GetRandomSerialNumber();
332
333 RadioAccessSpecifier specifier = {
334 .radioAccessNetwork = RadioAccessNetworks::GERAN,
335 .geranBands = {GeranBands::BAND_450, GeranBands::BAND_480},
336 .channels = {1,2}};
337
338 ::android::hardware::radio::V1_2::NetworkScanRequest request = {
339 .type = ScanType::ONE_SHOT,
340 .interval = 60,
341 .specifiers = {specifier},
342 .maxSearchTime = 600,
343 .incrementalResults = false,
344 .incrementalResultsPeriodicity = 10,
345 .mccMncs = {"310410"}};
346
347 Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
348 ASSERT_OK(res);
349 EXPECT_EQ(std::cv_status::no_timeout, wait());
350 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
351 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
352
353 ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
354 toString(radioRsp_v1_2->rspInfo.error).c_str());
355 if (cardStatus.base.cardState == CardState::ABSENT) {
356 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
357 {RadioError::NONE, RadioError::SIM_ABSENT}));
358 } else if (cardStatus.base.cardState == CardState::PRESENT) {
359 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
360 }
361 }
362
363 /*
364 * Test IRadio.setIndicationFilter_1_2()
365 */
TEST_F(RadioHidlTest_v1_2,setIndicationFilter_1_2)366 TEST_F(RadioHidlTest_v1_2, setIndicationFilter_1_2) {
367 serial = GetRandomSerialNumber();
368
369 Return<void> res = radio_v1_2->setIndicationFilter_1_2(
370 serial, static_cast<int>(::android::hardware::radio::V1_2::IndicationFilter::ALL));
371 ASSERT_OK(res);
372 EXPECT_EQ(std::cv_status::no_timeout, wait());
373 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
374 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
375
376 ALOGI("setIndicationFilter_1_2, rspInfo.error = %s\n",
377 toString(radioRsp_v1_2->rspInfo.error).c_str());
378 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
379 }
380
381 /*
382 * Test IRadio.setSignalStrengthReportingCriteria() with invalid hysteresisDb
383 */
TEST_F(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_invalidHysteresisDb)384 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_invalidHysteresisDb) {
385 serial = GetRandomSerialNumber();
386
387 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
388 serial, 5000,
389 10, // hysteresisDb too large given threshold list deltas
390 {-109, -103, -97, -89}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
391 ASSERT_OK(res);
392 EXPECT_EQ(std::cv_status::no_timeout, wait());
393 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
394 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
395
396 ALOGI("setSignalStrengthReportingCriteria_invalidHysteresisDb, rspInfo.error = %s\n",
397 toString(radioRsp_v1_2->rspInfo.error).c_str());
398 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
399 }
400
401 /*
402 * Test IRadio.setSignalStrengthReportingCriteria() with empty parameters
403 */
TEST_F(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_EmptyParams)404 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_EmptyParams) {
405 serial = GetRandomSerialNumber();
406
407 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
408 serial, 0, 0, {}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
409 ASSERT_OK(res);
410 EXPECT_EQ(std::cv_status::no_timeout, wait());
411 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
412 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
413
414 ALOGI("setSignalStrengthReportingCriteria_EmptyParams, rspInfo.error = %s\n",
415 toString(radioRsp_v1_2->rspInfo.error).c_str());
416 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
417 }
418
419 /*
420 * Test IRadio.setSignalStrengthReportingCriteria() for GERAN
421 */
TEST_F(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_Geran)422 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Geran) {
423 serial = GetRandomSerialNumber();
424
425 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
426 serial, 5000, 2, {-109, -103, -97, -89},
427 ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
428 ASSERT_OK(res);
429 EXPECT_EQ(std::cv_status::no_timeout, wait());
430 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
431 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
432
433 ALOGI("setSignalStrengthReportingCriteria_Geran, rspInfo.error = %s\n",
434 toString(radioRsp_v1_2->rspInfo.error).c_str());
435 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
436 }
437
438 /*
439 * Test IRadio.setSignalStrengthReportingCriteria() for UTRAN
440 */
TEST_F(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_Utran)441 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Utran) {
442 serial = GetRandomSerialNumber();
443
444 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
445 serial, 5000, 2, {-110, -97, -73, -49, -25},
446 ::android::hardware::radio::V1_2::AccessNetwork::UTRAN);
447 ASSERT_OK(res);
448 EXPECT_EQ(std::cv_status::no_timeout, wait());
449 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
450 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
451
452 ALOGI("setSignalStrengthReportingCriteria_Utran, rspInfo.error = %s\n",
453 toString(radioRsp_v1_2->rspInfo.error).c_str());
454 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
455 }
456
457 /*
458 * Test IRadio.setSignalStrengthReportingCriteria() for EUTRAN
459 */
TEST_F(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_Eutran)460 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Eutran) {
461 serial = GetRandomSerialNumber();
462
463 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
464 serial, 5000, 2, {-140, -128, -118, -108, -98, -44},
465 ::android::hardware::radio::V1_2::AccessNetwork::EUTRAN);
466 ASSERT_OK(res);
467 EXPECT_EQ(std::cv_status::no_timeout, wait());
468 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
469 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
470
471 ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
472 toString(radioRsp_v1_2->rspInfo.error).c_str());
473 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
474 }
475
476 /*
477 * Test IRadio.setSignalStrengthReportingCriteria() for CDMA2000
478 */
TEST_F(RadioHidlTest_v1_2,setSignalStrengthReportingCriteria_Cdma2000)479 TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Cdma2000) {
480 serial = GetRandomSerialNumber();
481
482 Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
483 serial, 5000, 2, {-105, -90, -75, -65},
484 ::android::hardware::radio::V1_2::AccessNetwork::CDMA2000);
485 ASSERT_OK(res);
486 EXPECT_EQ(std::cv_status::no_timeout, wait());
487 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
488 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
489
490 ALOGI("setSignalStrengthReportingCriteria_Cdma2000, rspInfo.error = %s\n",
491 toString(radioRsp_v1_2->rspInfo.error).c_str());
492 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
493 }
494
495 /*
496 * Test IRadio.setLinkCapacityReportingCriteria() invalid hysteresisDlKbps
497 */
TEST_F(RadioHidlTest_v1_2,setLinkCapacityReportingCriteria_invalidHysteresisDlKbps)498 TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_invalidHysteresisDlKbps) {
499 serial = GetRandomSerialNumber();
500
501 Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
502 serial, 5000,
503 5000, // hysteresisDlKbps too big for thresholds delta
504 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
505 ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
506 ASSERT_OK(res);
507 EXPECT_EQ(std::cv_status::no_timeout, wait());
508 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
509 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
510
511 ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisDlKbps, rspInfo.error = %s\n",
512 toString(radioRsp_v1_2->rspInfo.error).c_str());
513 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
514 }
515
516 /*
517 * Test IRadio.setLinkCapacityReportingCriteria() invalid hysteresisUlKbps
518 */
TEST_F(RadioHidlTest_v1_2,setLinkCapacityReportingCriteria_invalidHysteresisUlKbps)519 TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_invalidHysteresisUlKbps) {
520 serial = GetRandomSerialNumber();
521
522 Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
523 serial, 5000, 500,
524 1000, // hysteresisUlKbps too big for thresholds delta
525 {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
526 ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
527 ASSERT_OK(res);
528 EXPECT_EQ(std::cv_status::no_timeout, wait());
529 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
530 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
531
532 ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
533 toString(radioRsp_v1_2->rspInfo.error).c_str());
534 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
535 }
536
537 /*
538 * Test IRadio.setLinkCapacityReportingCriteria() empty params
539 */
TEST_F(RadioHidlTest_v1_2,setLinkCapacityReportingCriteria_emptyParams)540 TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_emptyParams) {
541 serial = GetRandomSerialNumber();
542
543 Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
544 serial, 0, 0, 0, {}, {}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
545 ASSERT_OK(res);
546 EXPECT_EQ(std::cv_status::no_timeout, wait());
547 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
548 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
549
550 ALOGI("setLinkCapacityReportingCriteria_emptyParams, rspInfo.error = %s\n",
551 toString(radioRsp_v1_2->rspInfo.error).c_str());
552 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
553 }
554
555 /*
556 * Test IRadio.setLinkCapacityReportingCriteria() GERAN
557 */
TEST_F(RadioHidlTest_v1_2,setLinkCapacityReportingCriteria_Geran)558 TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_Geran) {
559 serial = GetRandomSerialNumber();
560
561 Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
562 serial, 5000, 500, 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
563 ::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_invalidHysteresisUlKbps, rspInfo.error = %s\n",
570 toString(radioRsp_v1_2->rspInfo.error).c_str());
571 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
572 }
573
574 /*
575 * Test IRadio.setupDataCall_1_2() for the response returned.
576 */
TEST_F(RadioHidlTest_v1_2,setupDataCall_1_2)577 TEST_F(RadioHidlTest_v1_2, setupDataCall_1_2) {
578 serial = GetRandomSerialNumber();
579
580 ::android::hardware::radio::V1_2::AccessNetwork accessNetwork =
581 ::android::hardware::radio::V1_2::AccessNetwork::EUTRAN;
582
583 DataProfileInfo dataProfileInfo;
584 memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
585 dataProfileInfo.profileId = DataProfileId::IMS;
586 dataProfileInfo.apn = hidl_string("VZWIMS");
587 dataProfileInfo.protocol = hidl_string("IPV4V6");
588 dataProfileInfo.roamingProtocol = hidl_string("IPV6");
589 dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
590 dataProfileInfo.user = "";
591 dataProfileInfo.password = "";
592 dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
593 dataProfileInfo.maxConnsTime = 300;
594 dataProfileInfo.maxConns = 20;
595 dataProfileInfo.waitTime = 0;
596 dataProfileInfo.enabled = true;
597 dataProfileInfo.supportedApnTypesBitmap = 320;
598 dataProfileInfo.bearerBitmap = 161543;
599 dataProfileInfo.mtu = 0;
600 dataProfileInfo.mvnoType = MvnoType::NONE;
601 dataProfileInfo.mvnoMatchData = hidl_string();
602
603 bool modemCognitive = false;
604 bool roamingAllowed = false;
605 bool isRoaming = false;
606
607 ::android::hardware::radio::V1_2::DataRequestReason reason =
608 ::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
609 std::vector<hidl_string> addresses = {""};
610 std::vector<hidl_string> dnses = {""};
611
612 Return<void> res = radio_v1_2->setupDataCall_1_2(serial, accessNetwork, dataProfileInfo,
613 modemCognitive, roamingAllowed, isRoaming,
614 reason, addresses, dnses);
615 ASSERT_OK(res);
616
617 EXPECT_EQ(std::cv_status::no_timeout, wait());
618 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
619 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
620
621 if (cardStatus.base.cardState == CardState::ABSENT) {
622 ASSERT_TRUE(CheckAnyOfErrors(
623 radioRsp_v1_2->rspInfo.error,
624 {RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
625 RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW, RadioError::REQUEST_NOT_SUPPORTED}));
626 } else if (cardStatus.base.cardState == CardState::PRESENT) {
627 ASSERT_TRUE(CheckAnyOfErrors(
628 radioRsp_v1_2->rspInfo.error,
629 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
630 RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW, RadioError::REQUEST_NOT_SUPPORTED}));
631 }
632 }
633
634 /*
635 * Test IRadio.deactivateDataCall_1_2() for the response returned.
636 */
TEST_F(RadioHidlTest_v1_2,deactivateDataCall_1_2)637 TEST_F(RadioHidlTest_v1_2, deactivateDataCall_1_2) {
638 serial = GetRandomSerialNumber();
639 int cid = 1;
640 ::android::hardware::radio::V1_2::DataRequestReason reason =
641 ::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
642
643 Return<void> res = radio_v1_2->deactivateDataCall_1_2(serial, cid, reason);
644 ASSERT_OK(res);
645
646 EXPECT_EQ(std::cv_status::no_timeout, wait());
647 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
648 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
649
650 if (cardStatus.base.cardState == CardState::ABSENT) {
651 ASSERT_TRUE(CheckAnyOfErrors(
652 radioRsp_v1_2->rspInfo.error,
653 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_CALL_ID,
654 RadioError::INVALID_STATE, RadioError::INVALID_ARGUMENTS,
655 RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED, RadioError::SIM_ABSENT}));
656 } else if (cardStatus.base.cardState == CardState::PRESENT) {
657 ASSERT_TRUE(CheckAnyOfErrors(
658 radioRsp_v1_2->rspInfo.error,
659 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_CALL_ID,
660 RadioError::INVALID_STATE, RadioError::INVALID_ARGUMENTS,
661 RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED}));
662 }
663 }
664
665 /*
666 * Test IRadio.getCellInfoList() for the response returned.
667 */
TEST_F(RadioHidlTest_v1_2,getCellInfoList_1_2)668 TEST_F(RadioHidlTest_v1_2, getCellInfoList_1_2) {
669 int serial = GetRandomSerialNumber();
670
671 Return<void> res = radio_v1_2->getCellInfoList(serial);
672 ASSERT_OK(res);
673 EXPECT_EQ(std::cv_status::no_timeout, wait());
674 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
675 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
676
677 ALOGI("getCellInfoList_1_2, rspInfo.error = %s\n",
678 toString(radioRsp_v1_2->rspInfo.error).c_str());
679 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
680 {RadioError::NONE, RadioError::NO_NETWORK_FOUND}));
681 }
682
683 /*
684 * Test IRadio.getVoiceRegistrationState() for the response returned.
685 */
TEST_F(RadioHidlTest_v1_2,getVoiceRegistrationState)686 TEST_F(RadioHidlTest_v1_2, getVoiceRegistrationState) {
687 int serial = GetRandomSerialNumber();
688
689 Return<void> res = radio_v1_2->getVoiceRegistrationState(serial);
690 ASSERT_OK(res);
691 EXPECT_EQ(std::cv_status::no_timeout, wait());
692 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
693 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
694
695 ALOGI("getVoiceRegistrationStateResponse_1_2, rspInfo.error = %s\n",
696 toString(radioRsp_v1_2->rspInfo.error).c_str());
697 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
698 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
699 }
700
701 /*
702 * Test IRadio.getDataRegistrationState() for the response returned.
703 */
TEST_F(RadioHidlTest_v1_2,getDataRegistrationState)704 TEST_F(RadioHidlTest_v1_2, getDataRegistrationState) {
705 int serial = GetRandomSerialNumber();
706
707 Return<void> res = radio_v1_2->getDataRegistrationState(serial);
708 ASSERT_OK(res);
709 EXPECT_EQ(std::cv_status::no_timeout, wait());
710 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
711 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
712
713 ALOGI("getVoiceRegistrationStateResponse_1_2, rspInfo.error = %s\n",
714 toString(radioRsp_v1_2->rspInfo.error).c_str());
715 ASSERT_TRUE(CheckAnyOfErrors(
716 radioRsp_v1_2->rspInfo.error,
717 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NOT_PROVISIONED}));
718 }
719
720 /*
721 * Test IRadio.getAvailableBandModes() for the response returned.
722 */
TEST_F(RadioHidlTest_v1_2,getAvailableBandModes)723 TEST_F(RadioHidlTest_v1_2, getAvailableBandModes) {
724 int serial = GetRandomSerialNumber();
725
726 Return<void> res = radio_v1_2->getAvailableBandModes(serial);
727 ASSERT_OK(res);
728 EXPECT_EQ(std::cv_status::no_timeout, wait());
729 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
730 EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
731 ALOGI("getAvailableBandModes, rspInfo.error = %s\n",
732 toString(radioRsp_v1_2->rspInfo.error).c_str());
733 ASSERT_TRUE(
734 CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
735 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR,
736 RadioError::INTERNAL_ERR,
737 // If REQUEST_NOT_SUPPORTED is returned, then it should also be returned
738 // for setRandMode().
739 RadioError::REQUEST_NOT_SUPPORTED}));
740 bool hasUnspecifiedBandMode = false;
741 if (radioRsp_v1_2->rspInfo.error == RadioError::NONE) {
742 for (const RadioBandMode& mode : radioRsp_v1_2->radioBandModes) {
743 // Automatic mode selection must be supported
744 if (mode == RadioBandMode::BAND_MODE_UNSPECIFIED) hasUnspecifiedBandMode = true;
745 }
746 ASSERT_TRUE(hasUnspecifiedBandMode);
747 }
748 }
749