1 /*
2 * Copyright (C) 2021 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 <aidl/android/hardware/radio/RadioAccessFamily.h>
18 #include <aidl/android/hardware/radio/config/IRadioConfig.h>
19 #include <aidl/android/hardware/radio/network/IndicationFilter.h>
20 #include <android/binder_manager.h>
21
22 #include "radio_network_utils.h"
23
24 #define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
25
26 namespace {
27 const RadioAccessSpecifierBands EUTRAN_BAND_17 =
28 RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::eutranBands>(
29 {EutranBands::BAND_17});
30 const RadioAccessSpecifierBands EUTRAN_BAND_20 =
31 RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::eutranBands>(
32 {EutranBands::BAND_20});
33 const RadioAccessSpecifier EUTRAN_SPECIFIER_17 = {
34 .accessNetwork = AccessNetwork::EUTRAN, .bands = EUTRAN_BAND_17, .channels = {1, 2}};
35 const RadioAccessSpecifier EUTRAN_SPECIFIER_20 = {
36 .accessNetwork = AccessNetwork::EUTRAN, .bands = EUTRAN_BAND_20, .channels = {128, 129}};
37 } // namespace
38
SetUp()39 void RadioNetworkTest::SetUp() {
40 RadioServiceTest::SetUp();
41 std::string serviceName = GetParam();
42
43 if (!isServiceValidForDeviceConfiguration(serviceName)) {
44 ALOGI("Skipped the test due to device configuration.");
45 GTEST_SKIP();
46 }
47
48 radio_network = IRadioNetwork::fromBinder(
49 ndk::SpAIBinder(AServiceManager_waitForService(GetParam().c_str())));
50 ASSERT_NE(nullptr, radio_network.get());
51
52 radioRsp_network = ndk::SharedRefBase::make<RadioNetworkResponse>(*this);
53 ASSERT_NE(nullptr, radioRsp_network.get());
54
55 radioInd_network = ndk::SharedRefBase::make<RadioNetworkIndication>(*this);
56 ASSERT_NE(nullptr, radioInd_network.get());
57
58 radio_network->setResponseFunctions(radioRsp_network, radioInd_network);
59
60 // Assert IRadioSim exists and SIM is present before testing
61 radio_sim = sim::IRadioSim::fromBinder(ndk::SpAIBinder(
62 AServiceManager_waitForService("android.hardware.radio.sim.IRadioSim/slot1")));
63 ASSERT_NE(nullptr, radio_sim.get());
64 updateSimCardStatus();
65 EXPECT_EQ(CardStatus::STATE_PRESENT, cardStatus.cardState);
66
67 // Assert IRadioConfig exists before testing
68 radio_config = config::IRadioConfig::fromBinder(ndk::SpAIBinder(
69 AServiceManager_waitForService("android.hardware.radio.config.IRadioConfig/default")));
70 ASSERT_NE(nullptr, radio_config.get());
71 }
72
stopNetworkScan()73 void RadioNetworkTest::stopNetworkScan() {
74 serial = GetRandomSerialNumber();
75 radio_network->stopNetworkScan(serial);
76 EXPECT_EQ(std::cv_status::no_timeout, wait());
77 }
78
79 /*
80 * Test IRadioNetwork.setAllowedNetworkTypesBitmap and IRadioNetwork.getAllowedNetworkTypesBitmap
81 * for the response returned.
82 */
TEST_P(RadioNetworkTest,setGetAllowedNetworkTypesBitmap)83 TEST_P(RadioNetworkTest, setGetAllowedNetworkTypesBitmap) {
84 serial = GetRandomSerialNumber();
85
86 // save current value
87 radio_network->getAllowedNetworkTypesBitmap(serial);
88 EXPECT_EQ(std::cv_status::no_timeout, wait());
89 int32_t currentAllowedNetworkTypesBitmap = radioRsp_network->networkTypeBitmapResponse;
90
91 // set new value
92 int32_t allowedNetworkTypesBitmap = static_cast<int32_t>(RadioAccessFamily::LTE);
93 serial = GetRandomSerialNumber();
94 radio_network->setAllowedNetworkTypesBitmap(serial, allowedNetworkTypesBitmap);
95
96 EXPECT_EQ(std::cv_status::no_timeout, wait());
97 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
98 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
99 ASSERT_TRUE(CheckAnyOfErrors(
100 radioRsp_network->rspInfo.error,
101 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::OPERATION_NOT_ALLOWED,
102 RadioError::MODE_NOT_SUPPORTED, RadioError::INTERNAL_ERR, RadioError::MODEM_ERR,
103 RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED,
104 RadioError::NO_RESOURCES}));
105
106 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
107 sleep(3); // wait for modem
108 serial = GetRandomSerialNumber();
109 radio_network->getAllowedNetworkTypesBitmap(serial);
110
111 EXPECT_EQ(std::cv_status::no_timeout, wait());
112 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
113 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
114 ASSERT_TRUE(CheckAnyOfErrors(
115 radioRsp_network->rspInfo.error,
116 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
117 RadioError::OPERATION_NOT_ALLOWED, RadioError::MODE_NOT_SUPPORTED,
118 RadioError::INVALID_ARGUMENTS, RadioError::MODEM_ERR,
119 RadioError::REQUEST_NOT_SUPPORTED, RadioError::NO_RESOURCES}));
120 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
121 // verify we get the value we set
122 EXPECT_EQ(radioRsp_network->networkTypeBitmapResponse, allowedNetworkTypesBitmap);
123 }
124 }
125
126 // reset value to previous
127 serial = GetRandomSerialNumber();
128 radio_network->setAllowedNetworkTypesBitmap(serial, currentAllowedNetworkTypesBitmap);
129 EXPECT_EQ(std::cv_status::no_timeout, wait());
130 }
131
132 /*
133 * Test IRadioNetwork.setNrDualConnectivityState() for the response returned.
134 */
TEST_P(RadioNetworkTest,setNrDualConnectivityState)135 TEST_P(RadioNetworkTest, setNrDualConnectivityState) {
136 serial = GetRandomSerialNumber();
137
138 ndk::ScopedAStatus res =
139 radio_network->setNrDualConnectivityState(serial, NrDualConnectivityState::DISABLE);
140 ASSERT_OK(res);
141
142 EXPECT_EQ(std::cv_status::no_timeout, wait());
143 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
144 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
145 if (getRadioHalCapabilities()) {
146 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
147 {RadioError::REQUEST_NOT_SUPPORTED}));
148 } else {
149 ASSERT_TRUE(CheckAnyOfErrors(
150 radioRsp_network->rspInfo.error,
151 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
152 RadioError::INVALID_STATE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::NONE}));
153 }
154 }
155
156 /*
157 * Test IRadioNetwork.isNrDualConnectivityEnabled() for the response returned.
158 */
TEST_P(RadioNetworkTest,isNrDualConnectivityEnabled)159 TEST_P(RadioNetworkTest, isNrDualConnectivityEnabled) {
160 serial = GetRandomSerialNumber();
161
162 ndk::ScopedAStatus res = radio_network->isNrDualConnectivityEnabled(serial);
163 ASSERT_OK(res);
164
165 EXPECT_EQ(std::cv_status::no_timeout, wait());
166 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
167 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
168 if (getRadioHalCapabilities()) {
169 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
170 {RadioError::REQUEST_NOT_SUPPORTED}));
171 } else {
172 ASSERT_TRUE(CheckAnyOfErrors(
173 radioRsp_network->rspInfo.error,
174 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR, RadioError::NONE}));
175 }
176 }
177
invokeAndExpectResponse(std::function<ndk::ScopedAStatus (int32_t serial)> request,std::vector<RadioError> errors_to_check)178 void RadioNetworkTest::invokeAndExpectResponse(
179 std::function<ndk::ScopedAStatus(int32_t serial)> request,
180 std::vector<RadioError> errors_to_check) {
181 serial = GetRandomSerialNumber();
182
183 ndk::ScopedAStatus res = request(serial);
184 ASSERT_OK(res);
185
186 EXPECT_EQ(std::cv_status::no_timeout, wait());
187 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
188 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
189 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, errors_to_check));
190 }
191
192 /*
193 * Test IRadioNetwork.getUsageSetting()
194 *
195 * Verify that the usage setting can be retrieved.
196 */
TEST_P(RadioNetworkTest,getUsageSetting)197 TEST_P(RadioNetworkTest, getUsageSetting) {
198 invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
199 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_STATE,
200 RadioError::SIM_ABSENT, RadioError::INTERNAL_ERR, RadioError::NONE});
201
202 ASSERT_TRUE(radioRsp_network->usageSetting == UsageSetting::VOICE_CENTRIC ||
203 radioRsp_network->usageSetting == UsageSetting::DATA_CENTRIC);
204 }
205
testSetUsageSetting_InvalidValues(std::vector<RadioError> errors)206 void RadioNetworkTest::testSetUsageSetting_InvalidValues(std::vector<RadioError> errors) {
207 invokeAndExpectResponse(
208 [&](int serial) {
209 return radio_network->setUsageSetting(serial,
210 UsageSetting(0) /*below valid range*/);
211 },
212 errors);
213 invokeAndExpectResponse(
214 [&](int serial) {
215 return radio_network->setUsageSetting(serial, UsageSetting(-1) /*negative*/);
216 },
217 errors);
218 invokeAndExpectResponse(
219 [&](int serial) {
220 return radio_network->setUsageSetting(serial,
221 UsageSetting(3) /*above valid range*/);
222 },
223 errors);
224 }
225
226 /*
227 * Test IRadioNetwork.setUsageSetting() and IRadioNetwork.getUsageSetting()
228 *
229 * Verify the following:
230 * -That the usage setting can be retrieved.
231 * -That the usage setting can be successfully set to allowed values.
232 * -That the usage setting cannot be set to invalid values.
233 */
TEST_P(RadioNetworkTest,setUsageSetting)234 TEST_P(RadioNetworkTest, setUsageSetting) {
235 invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
236 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_STATE,
237 RadioError::SIM_ABSENT, RadioError::INTERNAL_ERR, RadioError::NONE});
238
239 if (radioRsp_network->rspInfo.error != RadioError::NONE) {
240 // Test only for invalid values, with the only allowable response being the same error
241 // that was previously provided, or an error indicating invalid arguments.
242 testSetUsageSetting_InvalidValues(
243 {radioRsp_network->rspInfo.error, RadioError::INVALID_ARGUMENTS});
244 // It is unsafe to proceed with setting valid values without knowing the starting value, but
245 // we expect errors anyway, so not necessary.
246 return;
247 } else {
248 // Because querying succeeded, the device is in a valid state to test for invalid values
249 // and the only thing that can change is that we expect to have an EINVAL return each time.
250 testSetUsageSetting_InvalidValues({RadioError::INVALID_ARGUMENTS});
251 }
252
253 // Store the original setting value to reset later.
254 const UsageSetting originalSetting = radioRsp_network->usageSetting;
255
256 // Choose the "other" value that is not the current value for test.
257 const UsageSetting testSetting = radioRsp_network->usageSetting == UsageSetting::VOICE_CENTRIC
258 ? UsageSetting::DATA_CENTRIC
259 : UsageSetting::VOICE_CENTRIC;
260
261 // Set an alternative setting; it may either succeed or be disallowed as out of range for
262 // the current device (if the device only supports its current mode).
263 invokeAndExpectResponse(
264 [&](int serial) { return radio_network->setUsageSetting(serial, testSetting); },
265 {RadioError::INVALID_ARGUMENTS, RadioError::NONE});
266
267 // If there was no error, then we expect the test setting to be set, or if there is an error
268 // we expect the original setting to be maintained.
269 const UsageSetting expectedSetting =
270 radioRsp_network->rspInfo.error == RadioError::NONE ? testSetting : originalSetting;
271 invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
272 {RadioError::NONE});
273
274 const UsageSetting updatedSetting = radioRsp_network->usageSetting;
275
276 // Re-set the original setting, which must always succeed.
277 invokeAndExpectResponse(
278 [&](int serial) { return radio_network->setUsageSetting(serial, originalSetting); },
279 {RadioError::NONE});
280
281 // After resetting the value to its original value, update the local cache, which must
282 // always succeed.
283 invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
284 {RadioError::NONE});
285
286 // Check that indeed the updated setting was set. We do this after resetting to original
287 // conditions to avoid early-exiting the test and leaving the device in a modified state.
288 EXPECT_EQ(expectedSetting, updatedSetting);
289 // Check that indeed the original setting was reset.
290 EXPECT_EQ(originalSetting, radioRsp_network->usageSetting);
291 }
292
293 /*
294 * Test IRadioNetwork.setSignalStrengthReportingCriteria() with invalid hysteresisDb
295 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_invalidHysteresisDb)296 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_invalidHysteresisDb) {
297 serial = GetRandomSerialNumber();
298
299 SignalThresholdInfo signalThresholdInfo;
300 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
301 signalThresholdInfo.hysteresisMs = 5000;
302 signalThresholdInfo.hysteresisDb = 10; // hysteresisDb too large given threshold list deltas
303 signalThresholdInfo.thresholds = {-109, -103, -97, -89};
304 signalThresholdInfo.isEnabled = true;
305 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
306
307 ndk::ScopedAStatus res =
308 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
309 ASSERT_OK(res);
310 EXPECT_EQ(std::cv_status::no_timeout, wait());
311 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
312 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
313
314 ALOGI("setSignalStrengthReportingCriteria_invalidHysteresisDb, rspInfo.error = %s\n",
315 toString(radioRsp_network->rspInfo.error).c_str());
316 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
317 }
318
319 /*
320 * Test IRadioNetwork.setSignalStrengthReportingCriteria() with empty thresholds
321 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_EmptyThresholds)322 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_EmptyThresholds) {
323 serial = GetRandomSerialNumber();
324
325 SignalThresholdInfo signalThresholdInfo;
326 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
327 signalThresholdInfo.hysteresisMs = 0;
328 signalThresholdInfo.hysteresisDb = 0;
329 signalThresholdInfo.isEnabled = true;
330 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
331
332 ndk::ScopedAStatus res =
333 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
334 ASSERT_OK(res);
335 EXPECT_EQ(std::cv_status::no_timeout, wait());
336 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
337 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
338
339 ALOGI("setSignalStrengthReportingCriteria_EmptyParams, rspInfo.error = %s\n",
340 toString(radioRsp_network->rspInfo.error).c_str());
341 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
342 }
343
344 /*
345 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for GERAN
346 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Geran)347 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Geran) {
348 serial = GetRandomSerialNumber();
349
350 SignalThresholdInfo signalThresholdInfo;
351 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
352 signalThresholdInfo.hysteresisMs = 5000;
353 signalThresholdInfo.hysteresisDb = 2;
354 signalThresholdInfo.thresholds = {-109, -103, -97, -89};
355 signalThresholdInfo.isEnabled = true;
356 signalThresholdInfo.ran = AccessNetwork::GERAN;
357
358 ndk::ScopedAStatus res =
359 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
360 ASSERT_OK(res);
361 EXPECT_EQ(std::cv_status::no_timeout, wait());
362 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
363 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
364
365 ALOGI("setSignalStrengthReportingCriteria_Geran, rspInfo.error = %s\n",
366 toString(radioRsp_network->rspInfo.error).c_str());
367 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
368 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
369 }
370
371 /*
372 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for UTRAN
373 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Utran_Rscp)374 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Utran_Rscp) {
375 serial = GetRandomSerialNumber();
376
377 SignalThresholdInfo signalThresholdInfo;
378 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSCP;
379 signalThresholdInfo.hysteresisMs = 5000;
380 signalThresholdInfo.hysteresisDb = 2;
381 signalThresholdInfo.thresholds = {-110, -97, -73, -49, -25};
382 signalThresholdInfo.isEnabled = true;
383 signalThresholdInfo.ran = AccessNetwork::UTRAN;
384
385 ndk::ScopedAStatus res =
386 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
387 ASSERT_OK(res);
388 EXPECT_EQ(std::cv_status::no_timeout, wait());
389 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
390 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
391
392 ALOGI("setSignalStrengthReportingCriteria_Utran, rspInfo.error = %s\n",
393 toString(radioRsp_network->rspInfo.error).c_str());
394 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
395 }
396
397 /*
398 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for UTRAN
399 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Utran_Ecno)400 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Utran_Ecno) {
401 serial = GetRandomSerialNumber();
402
403 SignalThresholdInfo signalThresholdInfo;
404 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_ECNO;
405 signalThresholdInfo.hysteresisMs = 5000;
406 signalThresholdInfo.hysteresisDb = 2;
407 signalThresholdInfo.thresholds = {-22, -18, 0};
408 signalThresholdInfo.isEnabled = true;
409 signalThresholdInfo.ran = AccessNetwork::UTRAN;
410
411 ndk::ScopedAStatus res =
412 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
413 ASSERT_OK(res);
414 EXPECT_EQ(std::cv_status::no_timeout, wait());
415 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
416 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
417
418 ALOGI("setSignalStrengthReportingCriteria_Utran, rspInfo.error = %s\n",
419 toString(radioRsp_network->rspInfo.error).c_str());
420 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
421 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
422 }
423
424 /*
425 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
426 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Eutran_RSRP)427 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSRP) {
428 serial = GetRandomSerialNumber();
429
430 SignalThresholdInfo signalThresholdInfo;
431 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSRP;
432 signalThresholdInfo.hysteresisMs = 5000;
433 signalThresholdInfo.hysteresisDb = 2;
434 signalThresholdInfo.thresholds = {-128, -108, -88, -68};
435 signalThresholdInfo.isEnabled = true;
436 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
437
438 ndk::ScopedAStatus res =
439 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
440 ASSERT_OK(res);
441 EXPECT_EQ(std::cv_status::no_timeout, wait());
442 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
443 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
444
445 ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
446 toString(radioRsp_network->rspInfo.error).c_str());
447 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
448 }
449
450 /*
451 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
452 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Eutran_RSRQ)453 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSRQ) {
454 serial = GetRandomSerialNumber();
455
456 SignalThresholdInfo signalThresholdInfo;
457 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSRQ;
458 signalThresholdInfo.hysteresisMs = 5000;
459 signalThresholdInfo.hysteresisDb = 2;
460 signalThresholdInfo.thresholds = {-27, -20, -13, -6};
461 signalThresholdInfo.isEnabled = true;
462 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
463
464 ndk::ScopedAStatus res =
465 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
466 ASSERT_OK(res);
467 EXPECT_EQ(std::cv_status::no_timeout, wait());
468 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
469 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
470
471 ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
472 toString(radioRsp_network->rspInfo.error).c_str());
473 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
474 }
475
476 /*
477 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
478 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Eutran_RSSNR)479 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSSNR) {
480 serial = GetRandomSerialNumber();
481
482 SignalThresholdInfo signalThresholdInfo;
483 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSNR;
484 signalThresholdInfo.hysteresisMs = 5000;
485 signalThresholdInfo.hysteresisDb = 2;
486 signalThresholdInfo.thresholds = {-10, 0, 10, 20};
487 signalThresholdInfo.isEnabled = true;
488 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
489
490 ndk::ScopedAStatus res =
491 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
492 ASSERT_OK(res);
493 EXPECT_EQ(std::cv_status::no_timeout, wait());
494 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
495 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
496 }
497
498 /*
499 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for CDMA2000
500 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Cdma2000)501 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Cdma2000) {
502 serial = GetRandomSerialNumber();
503
504 SignalThresholdInfo signalThresholdInfo;
505 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
506 signalThresholdInfo.hysteresisMs = 5000;
507 signalThresholdInfo.hysteresisDb = 2;
508 signalThresholdInfo.thresholds = {-105, -90, -75, -65};
509 signalThresholdInfo.isEnabled = true;
510 signalThresholdInfo.ran = AccessNetwork::CDMA2000;
511
512 ndk::ScopedAStatus res =
513 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
514 ASSERT_OK(res);
515 EXPECT_EQ(std::cv_status::no_timeout, wait());
516 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
517 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
518
519 ALOGI("setSignalStrengthReportingCriteria_Cdma2000, rspInfo.error = %s\n",
520 toString(radioRsp_network->rspInfo.error).c_str());
521 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
522 }
523
524 /*
525 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSRSRP
526 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_NGRAN_SSRSRP)527 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_NGRAN_SSRSRP) {
528 serial = GetRandomSerialNumber();
529
530 SignalThresholdInfo signalThresholdInfo;
531 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRP;
532 signalThresholdInfo.hysteresisMs = 5000;
533 signalThresholdInfo.hysteresisDb = 0;
534 signalThresholdInfo.thresholds = {-105, -90, -75, -65};
535 signalThresholdInfo.isEnabled = true;
536 signalThresholdInfo.ran = AccessNetwork::NGRAN;
537
538 ndk::ScopedAStatus res =
539 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
540 ASSERT_OK(res);
541 EXPECT_EQ(std::cv_status::no_timeout, wait());
542 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
543 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
544
545 ALOGI("setSignalStrengthReportingCriteria_NGRAN_SSRSRP, rspInfo.error = %s\n",
546 toString(radioRsp_network->rspInfo.error).c_str());
547
548 // Allow REQUEST_NOT_SUPPORTED because some non-5G device may not support NGRAN for
549 // setSignalStrengthReportingCriteria()
550 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
551 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
552 }
553
554 /*
555 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSRSRQ
556 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_NGRAN_SSRSRQ)557 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_NGRAN_SSRSRQ) {
558 serial = GetRandomSerialNumber();
559
560 SignalThresholdInfo signalThresholdInfo;
561 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRQ;
562 signalThresholdInfo.hysteresisMs = 5000;
563 signalThresholdInfo.hysteresisDb = 0;
564 signalThresholdInfo.thresholds = {-43, -20, 0, 20};
565 signalThresholdInfo.isEnabled = true;
566 signalThresholdInfo.ran = AccessNetwork::NGRAN;
567
568 ndk::ScopedAStatus res =
569 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
570 ASSERT_OK(res);
571 EXPECT_EQ(std::cv_status::no_timeout, wait());
572 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
573 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
574
575 ALOGI("setSignalStrengthReportingCriteria_NGRAN_SSRSRQ, rspInfo.error = %s\n",
576 toString(radioRsp_network->rspInfo.error).c_str());
577
578 // Allow REQUEST_NOT_SUPPORTED because some non-5G device may not support NGRAN for
579 // setSignalStrengthReportingCriteria()
580 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
581 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
582 }
583
584 /*
585 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
586 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Disable_RSSNR)587 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Disable_RSSNR) {
588 serial = GetRandomSerialNumber();
589
590 SignalThresholdInfo signalThresholdInfo;
591 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSNR;
592 signalThresholdInfo.hysteresisMs = 5000;
593 signalThresholdInfo.hysteresisDb = 2;
594 signalThresholdInfo.thresholds = {-10, 0, 10, 20};
595 signalThresholdInfo.isEnabled = false;
596 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
597
598 ndk::ScopedAStatus res =
599 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
600 ASSERT_OK(res);
601 EXPECT_EQ(std::cv_status::no_timeout, wait());
602 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
603 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
604 }
605
606 /*
607 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSSINR
608 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_NGRAN_SSSINR)609 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_NGRAN_SSSINR) {
610 serial = GetRandomSerialNumber();
611
612 SignalThresholdInfo signalThresholdInfo;
613 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSSINR;
614 signalThresholdInfo.hysteresisMs = 5000;
615 signalThresholdInfo.hysteresisDb = 0;
616 signalThresholdInfo.thresholds = {-10, 3, 16, 18};
617 signalThresholdInfo.isEnabled = true;
618 signalThresholdInfo.ran = AccessNetwork::NGRAN;
619
620 ndk::ScopedAStatus res =
621 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
622 ASSERT_OK(res);
623 EXPECT_EQ(std::cv_status::no_timeout, wait());
624 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
625 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
626
627 ALOGI("setSignalStrengthReportingCriteria_NGRAN_SSSINR, rspInfo.error = %s\n",
628 toString(radioRsp_network->rspInfo.error).c_str());
629
630 // Allow REQUEST_NOT_SUPPORTED because some non-5G device may not support NGRAN for
631 // setSignalStrengthReportingCriteria()
632 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
633 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
634 }
635
636 /*
637 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for multi-RANs per request
638 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_multiRansPerRequest)639 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_multiRansPerRequest) {
640 SignalThresholdInfo signalThresholdInfoGeran;
641 signalThresholdInfoGeran.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
642 signalThresholdInfoGeran.hysteresisMs = 5000;
643 signalThresholdInfoGeran.hysteresisDb = 2;
644 signalThresholdInfoGeran.thresholds = {-109, -103, -97, -89};
645 signalThresholdInfoGeran.isEnabled = true;
646 signalThresholdInfoGeran.ran = AccessNetwork::GERAN;
647
648 SignalThresholdInfo signalThresholdInfoUtran;
649 signalThresholdInfoUtran.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSCP;
650 signalThresholdInfoUtran.hysteresisMs = 5000;
651 signalThresholdInfoUtran.hysteresisDb = 2;
652 signalThresholdInfoUtran.thresholds = {-110, -97, -73, -49, -25};
653 signalThresholdInfoUtran.isEnabled = true;
654 signalThresholdInfoUtran.ran = AccessNetwork::UTRAN;
655
656 SignalThresholdInfo signalThresholdInfoEutran;
657 signalThresholdInfoEutran.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSRP;
658 signalThresholdInfoEutran.hysteresisMs = 5000;
659 signalThresholdInfoEutran.hysteresisDb = 2;
660 signalThresholdInfoEutran.thresholds = {-128, -108, -88, -68};
661 signalThresholdInfoEutran.isEnabled = true;
662 signalThresholdInfoEutran.ran = AccessNetwork::EUTRAN;
663
664 SignalThresholdInfo signalThresholdInfoCdma2000;
665 signalThresholdInfoCdma2000.signalMeasurement =
666 SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
667 signalThresholdInfoCdma2000.hysteresisMs = 5000;
668 signalThresholdInfoCdma2000.hysteresisDb = 2;
669 signalThresholdInfoCdma2000.thresholds = {-105, -90, -75, -65};
670 signalThresholdInfoCdma2000.isEnabled = true;
671 signalThresholdInfoCdma2000.ran = AccessNetwork::CDMA2000;
672
673 SignalThresholdInfo signalThresholdInfoNgran;
674 signalThresholdInfoNgran.signalMeasurement =
675 SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRP;
676 signalThresholdInfoNgran.hysteresisMs = 5000;
677 signalThresholdInfoNgran.hysteresisDb = 0;
678 signalThresholdInfoNgran.thresholds = {-105, -90, -75, -65};
679 signalThresholdInfoNgran.isEnabled = true;
680 signalThresholdInfoNgran.ran = AccessNetwork::NGRAN;
681
682 const static std::vector<SignalThresholdInfo> candidateSignalThresholdInfos = {
683 signalThresholdInfoGeran, signalThresholdInfoUtran, signalThresholdInfoEutran,
684 signalThresholdInfoCdma2000, signalThresholdInfoNgran};
685
686 std::vector<SignalThresholdInfo> supportedSignalThresholdInfos;
687 for (size_t i = 0; i < candidateSignalThresholdInfos.size(); i++) {
688 serial = GetRandomSerialNumber();
689 ndk::ScopedAStatus res = radio_network->setSignalStrengthReportingCriteria(
690 serial, {candidateSignalThresholdInfos[i]});
691 ASSERT_OK(res);
692 EXPECT_EQ(std::cv_status::no_timeout, wait());
693 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
694 supportedSignalThresholdInfos.push_back(signalThresholdInfoEutran);
695 } else {
696 // Refer to IRadioNetworkResponse#setSignalStrengthReportingCriteriaResponse
697 ASSERT_TRUE(CheckAnyOfErrors(
698 radioRsp_network->rspInfo.error,
699 {RadioError::INVALID_ARGUMENTS, RadioError::RADIO_NOT_AVAILABLE}));
700 }
701 }
702
703 ASSERT_FALSE(supportedSignalThresholdInfos.empty());
704
705 serial = GetRandomSerialNumber();
706 ndk::ScopedAStatus res = radio_network->setSignalStrengthReportingCriteria(
707 serial, supportedSignalThresholdInfos);
708 ASSERT_OK(res);
709 EXPECT_EQ(std::cv_status::no_timeout, wait());
710 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
711 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
712
713 ALOGI("setSignalStrengthReportingCriteria_multiRansPerRequest, rspInfo.error = %s\n",
714 toString(radioRsp_network->rspInfo.error).c_str());
715
716 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
717 }
718
719 /*
720 * Test IRadioNetwork.setLinkCapacityReportingCriteria() invalid hysteresisDlKbps
721 */
TEST_P(RadioNetworkTest,setLinkCapacityReportingCriteria_invalidHysteresisDlKbps)722 TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_invalidHysteresisDlKbps) {
723 serial = GetRandomSerialNumber();
724
725 ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
726 serial, 5000,
727 5000, // hysteresisDlKbps too big for thresholds delta
728 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000}, AccessNetwork::EUTRAN);
729 ASSERT_OK(res);
730 EXPECT_EQ(std::cv_status::no_timeout, wait());
731 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
732 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
733
734 ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisDlKbps, rspInfo.error = %s\n",
735 toString(radioRsp_network->rspInfo.error).c_str());
736 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
737 }
738
739 /*
740 * Test IRadioNetwork.setLinkCapacityReportingCriteria() invalid hysteresisUlKbps
741 */
TEST_P(RadioNetworkTest,setLinkCapacityReportingCriteria_invalidHysteresisUlKbps)742 TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_invalidHysteresisUlKbps) {
743 serial = GetRandomSerialNumber();
744
745 ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
746 serial, 5000, 500, 1000, // hysteresisUlKbps too big for thresholds delta
747 {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000}, AccessNetwork::EUTRAN);
748 ASSERT_OK(res);
749 EXPECT_EQ(std::cv_status::no_timeout, wait());
750 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
751 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
752
753 ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
754 toString(radioRsp_network->rspInfo.error).c_str());
755 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
756 }
757
758 /*
759 * Test IRadioNetwork.setLinkCapacityReportingCriteria() empty params
760 */
TEST_P(RadioNetworkTest,setLinkCapacityReportingCriteria_emptyParams)761 TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_emptyParams) {
762 serial = GetRandomSerialNumber();
763
764 ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
765 serial, 0, 0, 0, {}, {}, AccessNetwork::EUTRAN);
766 ASSERT_OK(res);
767 EXPECT_EQ(std::cv_status::no_timeout, wait());
768 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
769 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
770
771 ALOGI("setLinkCapacityReportingCriteria_emptyParams, rspInfo.error = %s\n",
772 toString(radioRsp_network->rspInfo.error).c_str());
773 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
774 }
775
776 /*
777 * Test IRadioNetwork.setLinkCapacityReportingCriteria() for GERAN
778 */
TEST_P(RadioNetworkTest,setLinkCapacityReportingCriteria_Geran)779 TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_Geran) {
780 serial = GetRandomSerialNumber();
781
782 ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
783 serial, 5000, 500, 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
784 AccessNetwork::GERAN);
785 ASSERT_OK(res);
786 EXPECT_EQ(std::cv_status::no_timeout, wait());
787 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
788 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
789
790 ALOGI("setLinkCapacityReportingCriteria_Geran, rspInfo.error = %s\n",
791 toString(radioRsp_network->rspInfo.error).c_str());
792 // Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported
793 // for GERAN
794 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
795 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
796 }
797
798 /*
799 * Test IRadioNetwork.setSystemSelectionChannels() for the response returned.
800 */
TEST_P(RadioNetworkTest,setSystemSelectionChannels)801 TEST_P(RadioNetworkTest, setSystemSelectionChannels) {
802 serial = GetRandomSerialNumber();
803 ndk::ScopedAStatus res = radio_network->getSystemSelectionChannels(serial);
804 EXPECT_EQ(std::cv_status::no_timeout, wait());
805 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
806 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
807 if (radioRsp_network->specifiers.size() == 0) {
808 // TODO (b/189255895): Throw an error once getSystemSelectionChannels is functional.
809 ALOGI("Skipped the test due to empty system selection channels.");
810 GTEST_SKIP();
811 }
812 std::vector<RadioAccessSpecifier> originalSpecifiers = radioRsp_network->specifiers;
813
814 serial = GetRandomSerialNumber();
815 res = radio_network->setSystemSelectionChannels(serial, true,
816 {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20});
817 ASSERT_OK(res);
818 EXPECT_EQ(std::cv_status::no_timeout, wait());
819 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
820 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
821 ALOGI("setSystemSelectionChannels, rspInfo.error = %s\n",
822 toString(radioRsp_network->rspInfo.error).c_str());
823 ASSERT_TRUE(CheckAnyOfErrors(
824 radioRsp_network->rspInfo.error,
825 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR}));
826
827 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
828 serial = GetRandomSerialNumber();
829 res = radio_network->setSystemSelectionChannels(
830 serial, false, {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20});
831 ASSERT_OK(res);
832 EXPECT_EQ(std::cv_status::no_timeout, wait());
833 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
834 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
835 ALOGI("setSystemSelectionChannels, rspInfo.error = %s\n",
836 toString(radioRsp_network->rspInfo.error).c_str());
837 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
838 }
839
840 serial = GetRandomSerialNumber();
841 res = radio_network->setSystemSelectionChannels(serial, true, originalSpecifiers);
842 EXPECT_EQ(std::cv_status::no_timeout, wait());
843 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
844 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
845 }
846
847 /*
848 * Test IRadioNetwork.startNetworkScan() for the response returned.
849 */
TEST_P(RadioNetworkTest,startNetworkScan)850 TEST_P(RadioNetworkTest, startNetworkScan) {
851 serial = GetRandomSerialNumber();
852
853 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
854 .interval = 60,
855 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
856 .maxSearchTime = 60,
857 .incrementalResults = false,
858 .incrementalResultsPeriodicity = 1};
859
860 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
861 ASSERT_OK(res);
862 EXPECT_EQ(std::cv_status::no_timeout, wait());
863 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
864 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
865 ALOGI("startNetworkScan, rspInfo.error = %s\n",
866 toString(radioRsp_network->rspInfo.error).c_str());
867
868 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
869 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::SIM_ABSENT}));
870 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
871 if (deviceSupportsFeature(FEATURE_TELEPHONY_GSM) && isLteConnected()) {
872 // Modems support 3GPP RAT family need to
873 // support scanning requests combined with some parameters.
874 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
875 {RadioError::NONE, RadioError::OPERATION_NOT_ALLOWED}));
876 } else {
877 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
878 {RadioError::NONE, RadioError::OPERATION_NOT_ALLOWED,
879 RadioError::INVALID_ARGUMENTS}));
880 }
881 }
882
883 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
884 ALOGI("Stop Network Scan");
885 stopNetworkScan();
886 }
887 }
888
889 /*
890 * Test IRadioNetwork.startNetworkScan() with invalid specifier.
891 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidArgument)892 TEST_P(RadioNetworkTest, startNetworkScan_InvalidArgument) {
893 serial = GetRandomSerialNumber();
894
895 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT, .interval = 60};
896
897 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
898 ASSERT_OK(res);
899 EXPECT_EQ(std::cv_status::no_timeout, wait());
900 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
901 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
902 ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
903 toString(radioRsp_network->rspInfo.error).c_str());
904
905 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
906 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
907 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
908 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
909 ASSERT_TRUE(
910 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
911 }
912 }
913
914 /*
915 * Test IRadioNetwork.startNetworkScan() with invalid interval (lower boundary).
916 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidInterval1)917 TEST_P(RadioNetworkTest, startNetworkScan_InvalidInterval1) {
918 serial = GetRandomSerialNumber();
919
920 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_PERIODIC,
921 .interval = 4,
922 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
923 .maxSearchTime = 60,
924 .incrementalResults = false,
925 .incrementalResultsPeriodicity = 1};
926
927 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
928 ASSERT_OK(res);
929 EXPECT_EQ(std::cv_status::no_timeout, wait());
930 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
931 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
932 ALOGI("startNetworkScan_InvalidInterval1, rspInfo.error = %s\n",
933 toString(radioRsp_network->rspInfo.error).c_str());
934 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
935 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
936 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
937 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
938 ASSERT_TRUE(
939 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
940 }
941 }
942
943 /*
944 * Test IRadioNetwork.startNetworkScan() with invalid interval (upper boundary).
945 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidInterval2)946 TEST_P(RadioNetworkTest, startNetworkScan_InvalidInterval2) {
947 serial = GetRandomSerialNumber();
948
949 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_PERIODIC,
950 .interval = 301,
951 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
952 .maxSearchTime = 60,
953 .incrementalResults = false,
954 .incrementalResultsPeriodicity = 1};
955
956 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
957 ASSERT_OK(res);
958 EXPECT_EQ(std::cv_status::no_timeout, wait());
959 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
960 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
961 ALOGI("startNetworkScan_InvalidInterval2, rspInfo.error = %s\n",
962 toString(radioRsp_network->rspInfo.error).c_str());
963 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
964 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
965 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
966 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
967 ASSERT_TRUE(
968 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
969 }
970 }
971
972 /*
973 * Test IRadioNetwork.startNetworkScan() with invalid max search time (lower boundary).
974 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidMaxSearchTime1)975 TEST_P(RadioNetworkTest, startNetworkScan_InvalidMaxSearchTime1) {
976 serial = GetRandomSerialNumber();
977
978 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
979 .interval = 60,
980 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
981 .maxSearchTime = 59,
982 .incrementalResults = false,
983 .incrementalResultsPeriodicity = 1};
984
985 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
986 ASSERT_OK(res);
987 EXPECT_EQ(std::cv_status::no_timeout, wait());
988 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
989 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
990 ALOGI("startNetworkScan_InvalidMaxSearchTime1, rspInfo.error = %s\n",
991 toString(radioRsp_network->rspInfo.error).c_str());
992 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
993 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
994 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
995 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
996 ASSERT_TRUE(
997 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
998 }
999 }
1000
1001 /*
1002 * Test IRadioNetwork.startNetworkScan() with invalid max search time (upper boundary).
1003 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidMaxSearchTime2)1004 TEST_P(RadioNetworkTest, startNetworkScan_InvalidMaxSearchTime2) {
1005 serial = GetRandomSerialNumber();
1006
1007 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1008 .interval = 60,
1009 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1010 .maxSearchTime = 3601,
1011 .incrementalResults = false,
1012 .incrementalResultsPeriodicity = 1};
1013
1014 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1015 ASSERT_OK(res);
1016 EXPECT_EQ(std::cv_status::no_timeout, wait());
1017 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1018 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1019 ALOGI("startNetworkScan_InvalidMaxSearchTime2, rspInfo.error = %s\n",
1020 toString(radioRsp_network->rspInfo.error).c_str());
1021 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1022 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1023 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1024 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1025 ASSERT_TRUE(
1026 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1027 }
1028 }
1029
1030 /*
1031 * Test IRadioNetwork.startNetworkScan() with invalid periodicity (lower boundary).
1032 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidPeriodicity1)1033 TEST_P(RadioNetworkTest, startNetworkScan_InvalidPeriodicity1) {
1034 serial = GetRandomSerialNumber();
1035
1036 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1037 .interval = 60,
1038 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1039 .maxSearchTime = 600,
1040 .incrementalResults = true,
1041 .incrementalResultsPeriodicity = 0};
1042
1043 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1044 ASSERT_OK(res);
1045 EXPECT_EQ(std::cv_status::no_timeout, wait());
1046 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1047 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1048 ALOGI("startNetworkScan_InvalidPeriodicity1, rspInfo.error = %s\n",
1049 toString(radioRsp_network->rspInfo.error).c_str());
1050 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1051 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1052 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1053 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1054 ASSERT_TRUE(
1055 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1056 }
1057 }
1058
1059 /*
1060 * Test IRadioNetwork.startNetworkScan() with invalid periodicity (upper boundary).
1061 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidPeriodicity2)1062 TEST_P(RadioNetworkTest, startNetworkScan_InvalidPeriodicity2) {
1063 serial = GetRandomSerialNumber();
1064
1065 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1066 .interval = 60,
1067 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1068 .maxSearchTime = 600,
1069 .incrementalResults = true,
1070 .incrementalResultsPeriodicity = 11};
1071
1072 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1073 ASSERT_OK(res);
1074 EXPECT_EQ(std::cv_status::no_timeout, wait());
1075 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1076 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1077 ALOGI("startNetworkScan_InvalidPeriodicity2, rspInfo.error = %s\n",
1078 toString(radioRsp_network->rspInfo.error).c_str());
1079 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1080 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1081 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1082 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1083 ASSERT_TRUE(
1084 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1085 }
1086 }
1087
1088 /*
1089 * Test IRadioNetwork.startNetworkScan() with valid periodicity
1090 */
TEST_P(RadioNetworkTest,startNetworkScan_GoodRequest1)1091 TEST_P(RadioNetworkTest, startNetworkScan_GoodRequest1) {
1092 serial = GetRandomSerialNumber();
1093
1094 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1095 .interval = 60,
1096 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1097 .maxSearchTime = 360,
1098 .incrementalResults = false,
1099 .incrementalResultsPeriodicity = 10};
1100
1101 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1102 ASSERT_OK(res);
1103 EXPECT_EQ(std::cv_status::no_timeout, wait());
1104 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1105 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1106 ALOGI("startNetworkScan_GoodRequest1, rspInfo.error = %s\n",
1107 toString(radioRsp_network->rspInfo.error).c_str());
1108 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1109 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1110 {RadioError::NONE, RadioError::SIM_ABSENT}));
1111 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1112 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1113 {RadioError::NONE, RadioError::INVALID_ARGUMENTS}));
1114 }
1115
1116 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
1117 ALOGI("Stop Network Scan");
1118 stopNetworkScan();
1119 }
1120 }
1121
1122 /*
1123 * Test IRadioNetwork.startNetworkScan() with valid periodicity and plmns
1124 */
TEST_P(RadioNetworkTest,startNetworkScan_GoodRequest2)1125 TEST_P(RadioNetworkTest, startNetworkScan_GoodRequest2) {
1126 serial = GetRandomSerialNumber();
1127
1128 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1129 .interval = 60,
1130 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1131 .maxSearchTime = 360,
1132 .incrementalResults = false,
1133 .incrementalResultsPeriodicity = 10,
1134 .mccMncs = {"310410"}};
1135
1136 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1137 ASSERT_OK(res);
1138 EXPECT_EQ(std::cv_status::no_timeout, wait());
1139 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1140 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1141 ALOGI("startNetworkScan_GoodRequest2, rspInfo.error = %s\n",
1142 toString(radioRsp_network->rspInfo.error).c_str());
1143 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1144 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1145 {RadioError::NONE, RadioError::SIM_ABSENT}));
1146 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1147 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1148 {RadioError::NONE, RadioError::INVALID_ARGUMENTS}));
1149 }
1150
1151 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
1152 ALOGI("Stop Network Scan");
1153 stopNetworkScan();
1154 }
1155 }
1156
1157 /*
1158 * Test IRadioNetwork.setNetworkSelectionModeManual() for the response returned.
1159 */
TEST_P(RadioNetworkTest,setNetworkSelectionModeManual)1160 TEST_P(RadioNetworkTest, setNetworkSelectionModeManual) {
1161 serial = GetRandomSerialNumber();
1162
1163 // can't camp on nonexistent MCCMNC, so we expect this to fail.
1164 ndk::ScopedAStatus res =
1165 radio_network->setNetworkSelectionModeManual(serial, "123456", AccessNetwork::EUTRAN);
1166 EXPECT_EQ(std::cv_status::no_timeout, wait());
1167 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1168 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1169
1170 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1171 ASSERT_TRUE(CheckAnyOfErrors(
1172 radioRsp_network->rspInfo.error,
1173 {RadioError::NONE, RadioError::ILLEGAL_SIM_OR_ME, RadioError::INVALID_ARGUMENTS,
1174 RadioError::INVALID_STATE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NO_MEMORY,
1175 RadioError::INTERNAL_ERR, RadioError::SYSTEM_ERR, RadioError::CANCELLED}));
1176 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1177 ASSERT_TRUE(CheckAnyOfErrors(
1178 radioRsp_network->rspInfo.error,
1179 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
1180 RadioError::INVALID_STATE, RadioError::NO_MEMORY, RadioError::INTERNAL_ERR,
1181 RadioError::SYSTEM_ERR, RadioError::CANCELLED}));
1182 }
1183 }
1184
1185 /*
1186 * Test IRadioNetwork.getBarringInfo() for the response returned.
1187 */
TEST_P(RadioNetworkTest,getBarringInfo)1188 TEST_P(RadioNetworkTest, getBarringInfo) {
1189 serial = GetRandomSerialNumber();
1190 ndk::ScopedAStatus res = radio_network->getBarringInfo(serial);
1191 EXPECT_EQ(std::cv_status::no_timeout, wait());
1192 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1193 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1194 ASSERT_TRUE(radioRsp_network->barringInfoList.size() > 0);
1195
1196 std::set<int> reportedServices;
1197
1198 // validate that the service types are in range
1199 for (const auto& info : radioRsp_network->barringInfoList) {
1200 ASSERT_TRUE((info.serviceType >= BarringInfo::SERVICE_TYPE_CS_SERVICE &&
1201 info.serviceType <= BarringInfo::SERVICE_TYPE_SMS) ||
1202 (info.serviceType >= BarringInfo::SERVICE_TYPE_OPERATOR_1 &&
1203 info.serviceType <= BarringInfo::SERVICE_TYPE_OPERATOR_32));
1204 reportedServices.insert(info.serviceType);
1205
1206 // Any type that is "conditional" must have valid values for conditional barring
1207 // factor and time.
1208 switch (info.barringType) {
1209 case BarringInfo::BARRING_TYPE_NONE: // fall through
1210 case BarringInfo::BARRING_TYPE_UNCONDITIONAL:
1211 break;
1212 case BarringInfo::BARRING_TYPE_CONDITIONAL: {
1213 const int32_t barringFactor = info.barringTypeSpecificInfo->factor;
1214 ASSERT_TRUE(barringFactor >= 0 && barringFactor <= 100);
1215 ASSERT_TRUE(info.barringTypeSpecificInfo->timeSeconds > 0);
1216 break;
1217 }
1218 default:
1219 FAIL();
1220 }
1221 }
1222
1223 // Certain types of barring are relevant for certain RANs. Ensure that only the right
1224 // types are reported. Note that no types are required, simply that for a given technology
1225 // only certain types are valid. This is one way to check that implementations are
1226 // not providing information that they don't have.
1227 static const std::set<int> UTRA_SERVICES{
1228 BarringInfo::SERVICE_TYPE_CS_SERVICE, BarringInfo::SERVICE_TYPE_PS_SERVICE,
1229 BarringInfo::SERVICE_TYPE_CS_VOICE, BarringInfo::SERVICE_TYPE_EMERGENCY,
1230 BarringInfo::SERVICE_TYPE_SMS,
1231 };
1232
1233 static const std::set<int> EUTRA_SERVICES{
1234 BarringInfo::SERVICE_TYPE_MO_SIGNALLING, BarringInfo::SERVICE_TYPE_MO_DATA,
1235 BarringInfo::SERVICE_TYPE_CS_FALLBACK, BarringInfo::SERVICE_TYPE_MMTEL_VOICE,
1236 BarringInfo::SERVICE_TYPE_MMTEL_VIDEO, BarringInfo::SERVICE_TYPE_EMERGENCY,
1237 BarringInfo::SERVICE_TYPE_SMS,
1238 };
1239
1240 static const std::set<int> NGRA_SERVICES = {
1241 BarringInfo::SERVICE_TYPE_MO_SIGNALLING, BarringInfo::SERVICE_TYPE_MO_DATA,
1242 BarringInfo::SERVICE_TYPE_CS_FALLBACK, BarringInfo::SERVICE_TYPE_MMTEL_VOICE,
1243 BarringInfo::SERVICE_TYPE_MMTEL_VIDEO, BarringInfo::SERVICE_TYPE_EMERGENCY,
1244 BarringInfo::SERVICE_TYPE_SMS, BarringInfo::SERVICE_TYPE_OPERATOR_1,
1245 BarringInfo::SERVICE_TYPE_OPERATOR_2, BarringInfo::SERVICE_TYPE_OPERATOR_3,
1246 BarringInfo::SERVICE_TYPE_OPERATOR_4, BarringInfo::SERVICE_TYPE_OPERATOR_5,
1247 BarringInfo::SERVICE_TYPE_OPERATOR_6, BarringInfo::SERVICE_TYPE_OPERATOR_7,
1248 BarringInfo::SERVICE_TYPE_OPERATOR_8, BarringInfo::SERVICE_TYPE_OPERATOR_9,
1249 BarringInfo::SERVICE_TYPE_OPERATOR_10, BarringInfo::SERVICE_TYPE_OPERATOR_11,
1250 BarringInfo::SERVICE_TYPE_OPERATOR_12, BarringInfo::SERVICE_TYPE_OPERATOR_13,
1251 BarringInfo::SERVICE_TYPE_OPERATOR_14, BarringInfo::SERVICE_TYPE_OPERATOR_15,
1252 BarringInfo::SERVICE_TYPE_OPERATOR_16, BarringInfo::SERVICE_TYPE_OPERATOR_17,
1253 BarringInfo::SERVICE_TYPE_OPERATOR_18, BarringInfo::SERVICE_TYPE_OPERATOR_19,
1254 BarringInfo::SERVICE_TYPE_OPERATOR_20, BarringInfo::SERVICE_TYPE_OPERATOR_21,
1255 BarringInfo::SERVICE_TYPE_OPERATOR_22, BarringInfo::SERVICE_TYPE_OPERATOR_23,
1256 BarringInfo::SERVICE_TYPE_OPERATOR_24, BarringInfo::SERVICE_TYPE_OPERATOR_25,
1257 BarringInfo::SERVICE_TYPE_OPERATOR_26, BarringInfo::SERVICE_TYPE_OPERATOR_27,
1258 BarringInfo::SERVICE_TYPE_OPERATOR_28, BarringInfo::SERVICE_TYPE_OPERATOR_29,
1259 BarringInfo::SERVICE_TYPE_OPERATOR_30, BarringInfo::SERVICE_TYPE_OPERATOR_31,
1260 };
1261
1262 const std::set<int>* compareTo = nullptr;
1263
1264 switch (radioRsp_network->barringCellIdentity.getTag()) {
1265 case CellIdentity::Tag::wcdma:
1266 // fall through
1267 case CellIdentity::Tag::tdscdma:
1268 compareTo = &UTRA_SERVICES;
1269 break;
1270 case CellIdentity::Tag::lte:
1271 compareTo = &EUTRA_SERVICES;
1272 break;
1273 case CellIdentity::Tag::nr:
1274 compareTo = &NGRA_SERVICES;
1275 break;
1276 case CellIdentity::Tag::cdma:
1277 // fall through
1278 default:
1279 FAIL();
1280 break;
1281 }
1282
1283 std::set<int> diff;
1284
1285 std::set_difference(reportedServices.begin(), reportedServices.end(), compareTo->begin(),
1286 compareTo->end(), std::inserter(diff, diff.begin()));
1287 }
1288
1289 /*
1290 * Test IRadioNetwork.getSignalStrength() for the response returned.
1291 */
TEST_P(RadioNetworkTest,getSignalStrength)1292 TEST_P(RadioNetworkTest, getSignalStrength) {
1293 serial = GetRandomSerialNumber();
1294
1295 radio_network->getSignalStrength(serial);
1296 EXPECT_EQ(std::cv_status::no_timeout, wait());
1297 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1298 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1299
1300 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1301 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
1302 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1303 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1304 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
1305 }
1306 }
1307
1308 /*
1309 * Test IRadioNetwork.getCellInfoList() for the response returned.
1310 */
TEST_P(RadioNetworkTest,getCellInfoList)1311 TEST_P(RadioNetworkTest, getCellInfoList) {
1312 serial = GetRandomSerialNumber();
1313
1314 ndk::ScopedAStatus res = radio_network->getCellInfoList(serial);
1315 ASSERT_OK(res);
1316 EXPECT_EQ(std::cv_status::no_timeout, wait());
1317 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1318 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1319
1320 ALOGI("getCellInfoList, rspInfo.error = %s\n",
1321 toString(radioRsp_network->rspInfo.error).c_str());
1322 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1323 {RadioError::NONE, RadioError::NO_NETWORK_FOUND}));
1324 }
1325
1326 /*
1327 * Test IRadioNetwork.getVoiceRegistrationState() for the response returned.
1328 */
TEST_P(RadioNetworkTest,getVoiceRegistrationState)1329 TEST_P(RadioNetworkTest, getVoiceRegistrationState) {
1330 serial = GetRandomSerialNumber();
1331
1332 ndk::ScopedAStatus res = radio_network->getVoiceRegistrationState(serial);
1333 ASSERT_OK(res);
1334 EXPECT_EQ(std::cv_status::no_timeout, wait());
1335 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1336 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1337
1338 ALOGI("getVoiceRegistrationStateResponse, rspInfo.error = %s\n",
1339 toString(radioRsp_network->rspInfo.error).c_str());
1340 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1341 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
1342 }
1343
1344 /*
1345 * Test IRadioNetwork.getDataRegistrationState() for the response returned.
1346 */
TEST_P(RadioNetworkTest,getDataRegistrationState)1347 TEST_P(RadioNetworkTest, getDataRegistrationState) {
1348 serial = GetRandomSerialNumber();
1349
1350 ndk::ScopedAStatus res = radio_network->getDataRegistrationState(serial);
1351 ASSERT_OK(res);
1352 EXPECT_EQ(std::cv_status::no_timeout, wait());
1353 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1354 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1355
1356 ALOGI("getDataRegistrationStateResponse, rspInfo.error = %s\n",
1357 toString(radioRsp_network->rspInfo.error).c_str());
1358 ASSERT_TRUE(CheckAnyOfErrors(
1359 radioRsp_network->rspInfo.error,
1360 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NOT_PROVISIONED}));
1361
1362 // Check the mcc [0, 999] and mnc [0, 999].
1363 std::string mcc;
1364 std::string mnc;
1365 bool checkMccMnc = true;
1366 CellIdentity cellIdentity = radioRsp_network->dataRegResp.cellIdentity;
1367 switch (cellIdentity.getTag()) {
1368 case CellIdentity::noinit: {
1369 checkMccMnc = false;
1370 break;
1371 }
1372 case CellIdentity::gsm: {
1373 CellIdentityGsm cig = cellIdentity.get<CellIdentity::gsm>();
1374 mcc = cig.mcc;
1375 mnc = cig.mnc;
1376 break;
1377 }
1378 case CellIdentity::wcdma: {
1379 CellIdentityWcdma ciw = cellIdentity.get<CellIdentity::wcdma>();
1380 mcc = ciw.mcc;
1381 mnc = ciw.mnc;
1382 break;
1383 }
1384 case CellIdentity::tdscdma: {
1385 CellIdentityTdscdma cit = cellIdentity.get<CellIdentity::tdscdma>();
1386 mcc = cit.mcc;
1387 mnc = cit.mnc;
1388 break;
1389 }
1390 case CellIdentity::cdma: {
1391 // CellIdentityCdma has no mcc/mnc
1392 CellIdentityCdma cic = cellIdentity.get<CellIdentity::cdma>();
1393 checkMccMnc = false;
1394 break;
1395 }
1396 case CellIdentity::lte: {
1397 CellIdentityLte cil = cellIdentity.get<CellIdentity::lte>();
1398 mcc = cil.mcc;
1399 mnc = cil.mnc;
1400 break;
1401 }
1402 case CellIdentity::nr: {
1403 CellIdentityNr cin = cellIdentity.get<CellIdentity::nr>();
1404 mcc = cin.mcc;
1405 mnc = cin.mnc;
1406 break;
1407 }
1408 }
1409
1410 // 32 bit system might return invalid mcc and mnc string "\xff\xff..."
1411 if (checkMccMnc) {
1412 int mccSize = mcc.size();
1413 EXPECT_TRUE(mccSize == 0 || mccSize == 3);
1414 if (mccSize > 0) {
1415 int mcc_int = stoi(mcc);
1416 EXPECT_TRUE(mcc_int >= 0 && mcc_int <= 999);
1417 }
1418
1419 int mncSize = mnc.size();
1420 EXPECT_TRUE(mncSize == 0 || mncSize == 2 || mncSize == 3);
1421 if (mncSize > 0) {
1422 int mnc_int = stoi(mnc);
1423 EXPECT_TRUE(mnc_int >= 0 && mnc_int <= 999);
1424 }
1425 }
1426
1427 // Check for access technology specific info
1428 AccessTechnologySpecificInfo info = radioRsp_network->dataRegResp.accessTechnologySpecificInfo;
1429 RadioTechnology rat = radioRsp_network->dataRegResp.rat;
1430
1431 // TODO: add logic for cdmaInfo
1432 if (rat == RadioTechnology::LTE) {
1433 ASSERT_EQ(info.getTag(), AccessTechnologySpecificInfo::eutranInfo);
1434 } else if (rat == RadioTechnology::NR) {
1435 ASSERT_TRUE(info.getTag() == AccessTechnologySpecificInfo::ngranNrVopsInfo);
1436 }
1437 }
1438
1439 /*
1440 * Test IRadioNetwork.getAvailableBandModes() for the response returned.
1441 */
TEST_P(RadioNetworkTest,getAvailableBandModes)1442 TEST_P(RadioNetworkTest, getAvailableBandModes) {
1443 serial = GetRandomSerialNumber();
1444
1445 ndk::ScopedAStatus res = radio_network->getAvailableBandModes(serial);
1446 ASSERT_OK(res);
1447 EXPECT_EQ(std::cv_status::no_timeout, wait());
1448 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1449 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1450 ALOGI("getAvailableBandModes, rspInfo.error = %s\n",
1451 toString(radioRsp_network->rspInfo.error).c_str());
1452 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1453 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
1454 RadioError::MODEM_ERR, RadioError::INTERNAL_ERR,
1455 // If REQUEST_NOT_SUPPORTED is returned, then it should also be
1456 // returned for setBandMode().
1457 RadioError::REQUEST_NOT_SUPPORTED}));
1458 bool hasUnspecifiedBandMode = false;
1459 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
1460 for (const RadioBandMode& mode : radioRsp_network->radioBandModes) {
1461 // Automatic mode selection must be supported
1462 if (mode == RadioBandMode::BAND_MODE_UNSPECIFIED) hasUnspecifiedBandMode = true;
1463 }
1464 ASSERT_TRUE(hasUnspecifiedBandMode);
1465 }
1466 }
1467
1468 /*
1469 * Test IRadioNetwork.setIndicationFilter()
1470 */
TEST_P(RadioNetworkTest,setIndicationFilter)1471 TEST_P(RadioNetworkTest, setIndicationFilter) {
1472 serial = GetRandomSerialNumber();
1473
1474 ndk::ScopedAStatus res =
1475 radio_network->setIndicationFilter(serial, static_cast<int>(IndicationFilter::ALL));
1476 ASSERT_OK(res);
1477 EXPECT_EQ(std::cv_status::no_timeout, wait());
1478 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1479 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1480
1481 ALOGI("setIndicationFilter, rspInfo.error = %s\n",
1482 toString(radioRsp_network->rspInfo.error).c_str());
1483 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
1484 }
1485
1486 /*
1487 * Test IRadioNetwork.setBarringPassword() for the response returned.
1488 */
TEST_P(RadioNetworkTest,setBarringPassword)1489 TEST_P(RadioNetworkTest, setBarringPassword) {
1490 serial = GetRandomSerialNumber();
1491 std::string facility = "";
1492 std::string oldPassword = "";
1493 std::string newPassword = "";
1494
1495 radio_network->setBarringPassword(serial, facility, oldPassword, newPassword);
1496
1497 EXPECT_EQ(std::cv_status::no_timeout, wait());
1498 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1499 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1500
1501 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1502 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1503 {RadioError::NONE, RadioError::FDN_CHECK_FAILURE,
1504 RadioError::INVALID_ARGUMENTS, RadioError::MODEM_ERR},
1505 CHECK_GENERAL_ERROR));
1506 }
1507 }
1508
1509 /*
1510 * Test IRadioNetwork.setSuppServiceNotifications() for the response returned.
1511 */
TEST_P(RadioNetworkTest,setSuppServiceNotifications)1512 TEST_P(RadioNetworkTest, setSuppServiceNotifications) {
1513 serial = GetRandomSerialNumber();
1514 bool enable = false;
1515
1516 radio_network->setSuppServiceNotifications(serial, enable);
1517
1518 EXPECT_EQ(std::cv_status::no_timeout, wait());
1519 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1520 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1521
1522 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1523 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1524 {RadioError::NONE, RadioError::SIM_ABSENT}));
1525 }
1526 }
1527
1528 /*
1529 * Test IRadioNetwork.getImsRegistrationState() for the response returned.
1530 */
TEST_P(RadioNetworkTest,getImsRegistrationState)1531 TEST_P(RadioNetworkTest, getImsRegistrationState) {
1532 serial = GetRandomSerialNumber();
1533
1534 radio_network->getImsRegistrationState(serial);
1535
1536 EXPECT_EQ(std::cv_status::no_timeout, wait());
1537 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1538 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1539
1540 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1541 ASSERT_TRUE(CheckAnyOfErrors(
1542 radioRsp_network->rspInfo.error,
1543 {RadioError::NONE, RadioError::MODEM_ERR, RadioError::INVALID_MODEM_STATE},
1544 CHECK_GENERAL_ERROR));
1545 }
1546 }
1547
1548 /*
1549 * Test IRadioNetwork.getOperator() for the response returned.
1550 */
TEST_P(RadioNetworkTest,getOperator)1551 TEST_P(RadioNetworkTest, getOperator) {
1552 serial = GetRandomSerialNumber();
1553
1554 radio_network->getOperator(serial);
1555 EXPECT_EQ(std::cv_status::no_timeout, wait());
1556 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1557 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1558
1559 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1560 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
1561 }
1562 }
1563
1564 /*
1565 * Test IRadioNetwork.getNetworkSelectionMode() for the response returned.
1566 */
TEST_P(RadioNetworkTest,getNetworkSelectionMode)1567 TEST_P(RadioNetworkTest, getNetworkSelectionMode) {
1568 serial = GetRandomSerialNumber();
1569
1570 radio_network->getNetworkSelectionMode(serial);
1571 EXPECT_EQ(std::cv_status::no_timeout, wait());
1572 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1573 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1574
1575 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1576 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
1577 }
1578 }
1579
1580 /*
1581 * Test IRadioNetwork.setNetworkSelectionModeAutomatic() for the response returned.
1582 */
TEST_P(RadioNetworkTest,setNetworkSelectionModeAutomatic)1583 TEST_P(RadioNetworkTest, setNetworkSelectionModeAutomatic) {
1584 serial = GetRandomSerialNumber();
1585
1586 radio_network->setNetworkSelectionModeAutomatic(serial);
1587 EXPECT_EQ(std::cv_status::no_timeout, wait());
1588 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1589 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1590
1591 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1592 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1593 {RadioError::NONE, RadioError::ILLEGAL_SIM_OR_ME,
1594 RadioError::OPERATION_NOT_ALLOWED},
1595 CHECK_GENERAL_ERROR));
1596 }
1597 }
1598
1599 /*
1600 * Test IRadioNetwork.getAvailableNetworks() for the response returned.
1601 */
TEST_P(RadioNetworkTest,getAvailableNetworks)1602 TEST_P(RadioNetworkTest, getAvailableNetworks) {
1603 serial = GetRandomSerialNumber();
1604
1605 radio_network->getAvailableNetworks(serial);
1606 EXPECT_EQ(std::cv_status::no_timeout, wait());
1607 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1608 ASSERT_TRUE(radioRsp_network->rspInfo.type == RadioResponseType::SOLICITED ||
1609 radioRsp_network->rspInfo.type == RadioResponseType::SOLICITED_ACK_EXP);
1610
1611 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1612 ASSERT_TRUE(CheckAnyOfErrors(
1613 radioRsp_network->rspInfo.error,
1614 {RadioError::NONE, RadioError::CANCELLED, RadioError::DEVICE_IN_USE,
1615 RadioError::MODEM_ERR, RadioError::OPERATION_NOT_ALLOWED},
1616 CHECK_GENERAL_ERROR));
1617 }
1618 }
1619
1620 /*
1621 * Test IRadioNetwork.setBandMode() for the response returned.
1622 */
TEST_P(RadioNetworkTest,setBandMode)1623 TEST_P(RadioNetworkTest, setBandMode) {
1624 serial = GetRandomSerialNumber();
1625
1626 radio_network->setBandMode(serial, RadioBandMode::BAND_MODE_USA);
1627 EXPECT_EQ(std::cv_status::no_timeout, wait());
1628 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1629 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1630
1631 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1632 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE},
1633 CHECK_GENERAL_ERROR));
1634 }
1635 }
1636
1637 /*
1638 * Test IRadioNetwork.setLocationUpdates() for the response returned.
1639 */
TEST_P(RadioNetworkTest,setLocationUpdates)1640 TEST_P(RadioNetworkTest, setLocationUpdates) {
1641 serial = GetRandomSerialNumber();
1642
1643 radio_network->setLocationUpdates(serial, true);
1644 EXPECT_EQ(std::cv_status::no_timeout, wait());
1645 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1646 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1647
1648 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1649 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1650 {RadioError::NONE, RadioError::SIM_ABSENT}));
1651 }
1652 }
1653
1654 /*
1655 * Test IRadioNetwork.setCdmaRoamingPreference() for the response returned.
1656 */
TEST_P(RadioNetworkTest,setCdmaRoamingPreference)1657 TEST_P(RadioNetworkTest, setCdmaRoamingPreference) {
1658 serial = GetRandomSerialNumber();
1659
1660 radio_network->setCdmaRoamingPreference(serial, CdmaRoamingType::HOME_NETWORK);
1661 EXPECT_EQ(std::cv_status::no_timeout, wait());
1662 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1663 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1664
1665 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1666 ASSERT_TRUE(CheckAnyOfErrors(
1667 radioRsp_network->rspInfo.error,
1668 {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::REQUEST_NOT_SUPPORTED}));
1669 }
1670 }
1671
1672 /*
1673 * Test IRadioNetwork.getCdmaRoamingPreference() for the response returned.
1674 */
TEST_P(RadioNetworkTest,getCdmaRoamingPreference)1675 TEST_P(RadioNetworkTest, getCdmaRoamingPreference) {
1676 serial = GetRandomSerialNumber();
1677
1678 radio_network->getCdmaRoamingPreference(serial);
1679 EXPECT_EQ(std::cv_status::no_timeout, wait());
1680 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1681 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1682
1683 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1684 ASSERT_TRUE(
1685 CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1686 {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::MODEM_ERR},
1687 CHECK_GENERAL_ERROR));
1688 }
1689 }
1690
1691 /*
1692 * Test IRadioNetwork.getVoiceRadioTechnology() for the response returned.
1693 */
TEST_P(RadioNetworkTest,getVoiceRadioTechnology)1694 TEST_P(RadioNetworkTest, getVoiceRadioTechnology) {
1695 serial = GetRandomSerialNumber();
1696
1697 radio_network->getVoiceRadioTechnology(serial);
1698 EXPECT_EQ(std::cv_status::no_timeout, wait());
1699 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1700 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1701
1702 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1703 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
1704 }
1705 }
1706
1707 /*
1708 * Test IRadioNetwork.setCellInfoListRate() for the response returned.
1709 */
TEST_P(RadioNetworkTest,setCellInfoListRate)1710 TEST_P(RadioNetworkTest, setCellInfoListRate) {
1711 serial = GetRandomSerialNumber();
1712
1713 radio_network->setCellInfoListRate(serial, 10);
1714 EXPECT_EQ(std::cv_status::no_timeout, wait());
1715 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1716 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1717
1718 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1719 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1720 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
1721 }
1722 }
1723
1724 /*
1725 * Test IRadioNetwork.supplyNetworkDepersonalization() for the response returned.
1726 */
TEST_P(RadioNetworkTest,supplyNetworkDepersonalization)1727 TEST_P(RadioNetworkTest, supplyNetworkDepersonalization) {
1728 serial = GetRandomSerialNumber();
1729
1730 radio_network->supplyNetworkDepersonalization(serial, std::string("test"));
1731 EXPECT_EQ(std::cv_status::no_timeout, wait());
1732 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1733 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1734
1735 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1736 ASSERT_TRUE(CheckAnyOfErrors(
1737 radioRsp_network->rspInfo.error,
1738 {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INTERNAL_ERR,
1739 RadioError::INVALID_SIM_STATE, RadioError::MODEM_ERR, RadioError::NO_MEMORY,
1740 RadioError::PASSWORD_INCORRECT, RadioError::SIM_ABSENT, RadioError::SYSTEM_ERR}));
1741 }
1742 }
1743
1744 /*
1745 * Test IRadioNetwork.setEmergencyMode() for the response returned.
1746 */
TEST_P(RadioNetworkTest,setEmergencyMode)1747 TEST_P(RadioNetworkTest, setEmergencyMode) {
1748 int32_t aidl_version;
1749 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
1750 ASSERT_OK(aidl_status);
1751 if (aidl_version < 2) {
1752 ALOGI("Skipped the test since setEmergencyMode is not supported on version < 2.");
1753 GTEST_SKIP();
1754 }
1755
1756 serial = GetRandomSerialNumber();
1757
1758 radio_network->setEmergencyMode(serial, EmergencyMode::EMERGENCY_WWAN);
1759 EXPECT_EQ(std::cv_status::no_timeout, wait());
1760 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1761 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1762
1763 ASSERT_TRUE(CheckAnyOfErrors(
1764 radioRsp_network->rspInfo.error,
1765 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::RADIO_NOT_AVAILABLE,
1766 RadioError::MODEM_ERR, RadioError::INVALID_ARGUMENTS}));
1767
1768 // exit emergency mode for other tests
1769 serial = GetRandomSerialNumber();
1770 radio_network->exitEmergencyMode(serial);
1771 }
1772
1773 /*
1774 * Test IRadioNetwork.triggerEmergencyNetworkScan() for the response returned.
1775 */
TEST_P(RadioNetworkTest,triggerEmergencyNetworkScan)1776 TEST_P(RadioNetworkTest, triggerEmergencyNetworkScan) {
1777 int32_t aidl_version;
1778 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
1779 ASSERT_OK(aidl_status);
1780 if (aidl_version < 2) {
1781 ALOGI("Skipped the test since"
1782 " triggerEmergencyNetworkScan is not supported on version < 2.");
1783 GTEST_SKIP();
1784 }
1785
1786 serial = GetRandomSerialNumber();
1787
1788 EmergencyNetworkScanTrigger scanRequest;
1789 scanRequest.accessNetwork = {AccessNetwork::EUTRAN};
1790 scanRequest.scanType = EmergencyScanType::NO_PREFERENCE;
1791
1792 radio_network->triggerEmergencyNetworkScan(serial, scanRequest);
1793 EXPECT_EQ(std::cv_status::no_timeout, wait());
1794 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1795 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1796
1797 ASSERT_TRUE(CheckAnyOfErrors(
1798 radioRsp_network->rspInfo.error,
1799 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::RADIO_NOT_AVAILABLE,
1800 RadioError::MODEM_ERR, RadioError::INVALID_ARGUMENTS}));
1801 }
1802
1803 /*
1804 * Test IRadioNetwork.cancelEmergencyNetworkScan() for the response returned.
1805 */
TEST_P(RadioNetworkTest,cancelEmergencyNetworkScan)1806 TEST_P(RadioNetworkTest, cancelEmergencyNetworkScan) {
1807 int32_t aidl_version;
1808 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
1809 ASSERT_OK(aidl_status);
1810 if (aidl_version < 2) {
1811 ALOGI("Skipped the test since cancelEmergencyNetworkScan is not supported on version < 2.");
1812 GTEST_SKIP();
1813 }
1814
1815 serial = GetRandomSerialNumber();
1816
1817 radio_network->cancelEmergencyNetworkScan(serial, true);
1818 EXPECT_EQ(std::cv_status::no_timeout, wait());
1819 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1820 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1821
1822 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1823 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,
1824 RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR}));
1825 }
1826
1827 /*
1828 * Test IRadioNetwork.exitEmergencyMode() for the response returned.
1829 */
TEST_P(RadioNetworkTest,exitEmergencyMode)1830 TEST_P(RadioNetworkTest, exitEmergencyMode) {
1831 int32_t aidl_version;
1832 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
1833 ASSERT_OK(aidl_status);
1834 if (aidl_version < 2) {
1835 ALOGI("Skipped the test since exitEmergencyMode is not supported on version < 2.");
1836 GTEST_SKIP();
1837 }
1838
1839 serial = GetRandomSerialNumber();
1840
1841 radio_network->exitEmergencyMode(serial);
1842 EXPECT_EQ(std::cv_status::no_timeout, wait());
1843 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1844 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1845
1846 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1847 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,
1848 RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR}));
1849 }
1850
1851 /*
1852 * Test IRadioNetwork.setN1ModeEnabled() for the response returned.
1853 */
TEST_P(RadioNetworkTest,setN1ModeEnabled)1854 TEST_P(RadioNetworkTest, setN1ModeEnabled) {
1855 int32_t aidl_version;
1856 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
1857 ASSERT_OK(aidl_status);
1858 if (aidl_version < 2) {
1859 ALOGI("Skipped the test since setN1ModeEnabled is not supported on version < 2.");
1860 GTEST_SKIP();
1861 }
1862
1863 serial = GetRandomSerialNumber();
1864
1865 ndk::ScopedAStatus res =
1866 radio_network->setN1ModeEnabled(serial, false);
1867 ASSERT_OK(res);
1868
1869 EXPECT_EQ(std::cv_status::no_timeout, wait());
1870 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1871 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1872 if (getRadioHalCapabilities()) {
1873 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1874 {RadioError::REQUEST_NOT_SUPPORTED}));
1875 } else {
1876 ASSERT_TRUE(CheckAnyOfErrors(
1877 radioRsp_network->rspInfo.error,
1878 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
1879 RadioError::INVALID_STATE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::NONE}));
1880 }
1881 }
1882
1883 /*
1884 * Test IRadioNetwork.isN1ModeEnabled() for the response returned.
1885 */
TEST_P(RadioNetworkTest,isN1ModeEnabled)1886 TEST_P(RadioNetworkTest, isN1ModeEnabled) {
1887 int32_t aidl_version;
1888 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
1889 ASSERT_OK(aidl_status);
1890 if (aidl_version < 2) {
1891 ALOGI("Skipped the test since isN1ModeEnabled is not supported on version < 2.");
1892 GTEST_SKIP();
1893 }
1894
1895 serial = GetRandomSerialNumber();
1896
1897 ndk::ScopedAStatus res = radio_network->isN1ModeEnabled(serial);
1898 ASSERT_OK(res);
1899
1900 EXPECT_EQ(std::cv_status::no_timeout, wait());
1901 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1902 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1903 if (getRadioHalCapabilities()) {
1904 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1905 {RadioError::REQUEST_NOT_SUPPORTED}));
1906 } else {
1907 ASSERT_TRUE(CheckAnyOfErrors(
1908 radioRsp_network->rspInfo.error,
1909 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
1910 RadioError::REQUEST_NOT_SUPPORTED, RadioError::NONE}));
1911 }
1912 }
1913
1914 /*
1915 * Test IRadioNetwork.setNullCipherAndIntegrityEnabled() for the response returned.
1916 */
TEST_P(RadioNetworkTest,setNullCipherAndIntegrityEnabled)1917 TEST_P(RadioNetworkTest, setNullCipherAndIntegrityEnabled) {
1918 int32_t aidl_version;
1919 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
1920 ASSERT_OK(aidl_status);
1921 if (aidl_version < 2) {
1922 ALOGI("Skipped the test since"
1923 " setNullCipherAndIntegrityEnabled is not supported on version < 2.");
1924 GTEST_SKIP();
1925 }
1926
1927 serial = GetRandomSerialNumber();
1928
1929 radio_network->setNullCipherAndIntegrityEnabled(serial, false);
1930 EXPECT_EQ(std::cv_status::no_timeout, wait());
1931 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1932 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1933
1934 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1935 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,
1936 RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR}));
1937 }
1938
1939 /**
1940 * Test IRadioNetwork.isNullCipherAndIntegrityEnabled() for the response returned.
1941 */
TEST_P(RadioNetworkTest,isNullCipherAndIntegrityEnabled)1942 TEST_P(RadioNetworkTest, isNullCipherAndIntegrityEnabled) {
1943 int32_t aidl_version;
1944 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
1945 ASSERT_OK(aidl_status);
1946 if (aidl_version < 2) {
1947 ALOGI("Skipped the test since"
1948 " isNullCipherAndIntegrityEnabled is not supported on version < 2.");
1949 GTEST_SKIP();
1950 }
1951
1952 serial = GetRandomSerialNumber();
1953
1954 ndk::ScopedAStatus res = radio_network->isNullCipherAndIntegrityEnabled(serial);
1955 ASSERT_OK(res);
1956
1957 EXPECT_EQ(std::cv_status::no_timeout, wait());
1958 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1959 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1960
1961 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1962 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
1963 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
1964 }
1965