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 if (telephony_flags::enforce_telephony_feature_mapping()) {
85 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
86 GTEST_SKIP() << "Skipping setGetAllowedNetworkTypesBitmap "
87 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
88 }
89 }
90
91 serial = GetRandomSerialNumber();
92
93 // get aidl version
94 int32_t aidl_version;
95 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
96 ASSERT_OK(aidl_status);
97
98 // save current value
99 radio_network->getAllowedNetworkTypesBitmap(serial);
100 EXPECT_EQ(std::cv_status::no_timeout, wait());
101 int32_t currentAllowedNetworkTypesBitmap = radioRsp_network->networkTypeBitmapResponse;
102
103 // set new value
104 int32_t allowedNetworkTypesBitmap = static_cast<int32_t>(RadioAccessFamily::LTE);
105 serial = GetRandomSerialNumber();
106 radio_network->setAllowedNetworkTypesBitmap(serial, allowedNetworkTypesBitmap);
107
108 EXPECT_EQ(std::cv_status::no_timeout, wait());
109 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
110 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
111 ASSERT_TRUE(CheckAnyOfErrors(
112 radioRsp_network->rspInfo.error,
113 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::OPERATION_NOT_ALLOWED,
114 RadioError::MODE_NOT_SUPPORTED, RadioError::INTERNAL_ERR, RadioError::MODEM_ERR,
115 RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED,
116 RadioError::NO_RESOURCES}));
117
118 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
119 sleep(3); // wait for modem
120 serial = GetRandomSerialNumber();
121 radio_network->getAllowedNetworkTypesBitmap(serial);
122
123 EXPECT_EQ(std::cv_status::no_timeout, wait());
124 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
125 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
126 ASSERT_TRUE(CheckAnyOfErrors(
127 radioRsp_network->rspInfo.error,
128 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
129 RadioError::OPERATION_NOT_ALLOWED, RadioError::MODE_NOT_SUPPORTED,
130 RadioError::INVALID_ARGUMENTS, RadioError::MODEM_ERR,
131 RadioError::REQUEST_NOT_SUPPORTED, RadioError::NO_RESOURCES}));
132 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
133 if (aidl_version < 2) {
134 radioRsp_network->networkTypeBitmapResponse
135 &= ~static_cast<int32_t>(RadioAccessFamily::LTE_CA);
136 }
137
138 // verify we get the value we set
139 EXPECT_EQ(radioRsp_network->networkTypeBitmapResponse, allowedNetworkTypesBitmap);
140 }
141 }
142
143 // reset value to previous
144 serial = GetRandomSerialNumber();
145 radio_network->setAllowedNetworkTypesBitmap(serial, currentAllowedNetworkTypesBitmap);
146 EXPECT_EQ(std::cv_status::no_timeout, wait());
147 }
148
149 /*
150 * Test IRadioNetwork.setNrDualConnectivityState() for the response returned.
151 */
TEST_P(RadioNetworkTest,setNrDualConnectivityState)152 TEST_P(RadioNetworkTest, setNrDualConnectivityState) {
153 if (telephony_flags::enforce_telephony_feature_mapping()) {
154 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
155 GTEST_SKIP() << "Skipping setNrDualConnectivityState "
156 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
157 }
158 }
159
160 serial = GetRandomSerialNumber();
161
162 ndk::ScopedAStatus res =
163 radio_network->setNrDualConnectivityState(serial, NrDualConnectivityState::DISABLE);
164 ASSERT_OK(res);
165
166 EXPECT_EQ(std::cv_status::no_timeout, wait());
167 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
168 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
169 if (getRadioHalCapabilities()) {
170 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
171 {RadioError::REQUEST_NOT_SUPPORTED}));
172 } else {
173 ASSERT_TRUE(CheckAnyOfErrors(
174 radioRsp_network->rspInfo.error,
175 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
176 RadioError::INVALID_STATE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::NONE}));
177 }
178 }
179
180 /*
181 * Test IRadioNetwork.isNrDualConnectivityEnabled() for the response returned.
182 */
TEST_P(RadioNetworkTest,isNrDualConnectivityEnabled)183 TEST_P(RadioNetworkTest, isNrDualConnectivityEnabled) {
184 if (telephony_flags::enforce_telephony_feature_mapping()) {
185 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
186 GTEST_SKIP() << "Skipping isNrDualConnectivityEnabled "
187 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
188 }
189 }
190
191 serial = GetRandomSerialNumber();
192
193 ndk::ScopedAStatus res = radio_network->isNrDualConnectivityEnabled(serial);
194 ASSERT_OK(res);
195
196 EXPECT_EQ(std::cv_status::no_timeout, wait());
197 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
198 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
199 if (getRadioHalCapabilities()) {
200 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
201 {RadioError::REQUEST_NOT_SUPPORTED}));
202 } else {
203 ASSERT_TRUE(CheckAnyOfErrors(
204 radioRsp_network->rspInfo.error,
205 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR, RadioError::NONE}));
206 }
207 }
208
invokeAndExpectResponse(std::function<ndk::ScopedAStatus (int32_t serial)> request,std::vector<RadioError> errors_to_check)209 void RadioNetworkTest::invokeAndExpectResponse(
210 std::function<ndk::ScopedAStatus(int32_t serial)> request,
211 std::vector<RadioError> errors_to_check) {
212 serial = GetRandomSerialNumber();
213
214 ndk::ScopedAStatus res = request(serial);
215 ASSERT_OK(res);
216
217 EXPECT_EQ(std::cv_status::no_timeout, wait());
218 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
219 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
220 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, errors_to_check));
221 }
222
223 /*
224 * Test IRadioNetwork.getUsageSetting()
225 *
226 * Verify that the usage setting can be retrieved.
227 */
TEST_P(RadioNetworkTest,getUsageSetting)228 TEST_P(RadioNetworkTest, getUsageSetting) {
229 if (telephony_flags::enforce_telephony_feature_mapping()) {
230 if (!deviceSupportsFeature(FEATURE_TELEPHONY)) {
231 GTEST_SKIP() << "Skipping getUsageSetting "
232 "due to undefined FEATURE_TELEPHONY";
233 }
234 }
235
236 invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
237 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_STATE,
238 RadioError::SIM_ABSENT, RadioError::INTERNAL_ERR, RadioError::NONE});
239
240 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
241 ASSERT_TRUE(radioRsp_network->usageSetting == UsageSetting::VOICE_CENTRIC ||
242 radioRsp_network->usageSetting == UsageSetting::DATA_CENTRIC);
243 }
244 }
245
testSetUsageSetting_InvalidValues(std::vector<RadioError> errors)246 void RadioNetworkTest::testSetUsageSetting_InvalidValues(std::vector<RadioError> errors) {
247 invokeAndExpectResponse(
248 [&](int serial) {
249 return radio_network->setUsageSetting(serial,
250 UsageSetting(0) /*below valid range*/);
251 },
252 errors);
253 invokeAndExpectResponse(
254 [&](int serial) {
255 return radio_network->setUsageSetting(serial, UsageSetting(-1) /*negative*/);
256 },
257 errors);
258 invokeAndExpectResponse(
259 [&](int serial) {
260 return radio_network->setUsageSetting(serial,
261 UsageSetting(3) /*above valid range*/);
262 },
263 errors);
264 }
265
266 /*
267 * Test IRadioNetwork.setUsageSetting() and IRadioNetwork.getUsageSetting()
268 *
269 * Verify the following:
270 * -That the usage setting can be retrieved.
271 * -That the usage setting can be successfully set to allowed values.
272 * -That the usage setting cannot be set to invalid values.
273 */
TEST_P(RadioNetworkTest,setUsageSetting)274 TEST_P(RadioNetworkTest, setUsageSetting) {
275 if (telephony_flags::enforce_telephony_feature_mapping()) {
276 if (!deviceSupportsFeature(FEATURE_TELEPHONY)) {
277 GTEST_SKIP() << "Skipping setUsageSetting "
278 "due to undefined FEATURE_TELEPHONY";
279 }
280 }
281
282 invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
283 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_STATE,
284 RadioError::SIM_ABSENT, RadioError::INTERNAL_ERR, RadioError::NONE});
285
286 if (radioRsp_network->rspInfo.error != RadioError::NONE) {
287 // Test only for invalid values, with the only allowable response being the same error
288 // that was previously provided, or an error indicating invalid arguments.
289 testSetUsageSetting_InvalidValues(
290 {radioRsp_network->rspInfo.error, RadioError::INVALID_ARGUMENTS});
291 // It is unsafe to proceed with setting valid values without knowing the starting value, but
292 // we expect errors anyway, so not necessary.
293 return;
294 } else {
295 // Because querying succeeded, the device is in a valid state to test for invalid values
296 // and the only thing that can change is that we expect to have an EINVAL return each time.
297 testSetUsageSetting_InvalidValues({RadioError::INVALID_ARGUMENTS});
298 }
299
300 // Store the original setting value to reset later.
301 const UsageSetting originalSetting = radioRsp_network->usageSetting;
302
303 // Choose the "other" value that is not the current value for test.
304 const UsageSetting testSetting = radioRsp_network->usageSetting == UsageSetting::VOICE_CENTRIC
305 ? UsageSetting::DATA_CENTRIC
306 : UsageSetting::VOICE_CENTRIC;
307
308 // Set an alternative setting; it may either succeed or be disallowed as out of range for
309 // the current device (if the device only supports its current mode).
310 invokeAndExpectResponse(
311 [&](int serial) { return radio_network->setUsageSetting(serial, testSetting); },
312 {RadioError::INVALID_ARGUMENTS, RadioError::NONE});
313
314 // If there was no error, then we expect the test setting to be set, or if there is an error
315 // we expect the original setting to be maintained.
316 const UsageSetting expectedSetting =
317 radioRsp_network->rspInfo.error == RadioError::NONE ? testSetting : originalSetting;
318 invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
319 {RadioError::NONE});
320
321 const UsageSetting updatedSetting = radioRsp_network->usageSetting;
322
323 // Re-set the original setting, which must always succeed.
324 invokeAndExpectResponse(
325 [&](int serial) { return radio_network->setUsageSetting(serial, originalSetting); },
326 {RadioError::NONE});
327
328 // After resetting the value to its original value, update the local cache, which must
329 // always succeed.
330 invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
331 {RadioError::NONE});
332
333 // Check that indeed the updated setting was set. We do this after resetting to original
334 // conditions to avoid early-exiting the test and leaving the device in a modified state.
335 EXPECT_EQ(expectedSetting, updatedSetting);
336 // Check that indeed the original setting was reset.
337 EXPECT_EQ(originalSetting, radioRsp_network->usageSetting);
338 }
339
340 /*
341 * Test IRadioNetwork.setSignalStrengthReportingCriteria() with invalid hysteresisDb
342 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_invalidHysteresisDb)343 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_invalidHysteresisDb) {
344 if (telephony_flags::enforce_telephony_feature_mapping()) {
345 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
346 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_invalidHysteresisDb "
347 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
348 }
349 }
350
351 serial = GetRandomSerialNumber();
352
353 SignalThresholdInfo signalThresholdInfo;
354 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
355 signalThresholdInfo.hysteresisMs = 5000;
356 signalThresholdInfo.hysteresisDb = 10; // hysteresisDb too large given threshold list deltas
357 signalThresholdInfo.thresholds = {-109, -103, -97, -89};
358 signalThresholdInfo.isEnabled = true;
359 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
360
361 ndk::ScopedAStatus res =
362 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
363 ASSERT_OK(res);
364 EXPECT_EQ(std::cv_status::no_timeout, wait());
365 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
366 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
367
368 ALOGI("setSignalStrengthReportingCriteria_invalidHysteresisDb, rspInfo.error = %s\n",
369 toString(radioRsp_network->rspInfo.error).c_str());
370 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
371 }
372
373 /*
374 * Test IRadioNetwork.setSignalStrengthReportingCriteria() with empty thresholds
375 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_EmptyThresholds)376 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_EmptyThresholds) {
377 if (telephony_flags::enforce_telephony_feature_mapping()) {
378 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
379 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_EmptyThresholds "
380 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
381 }
382 }
383
384 serial = GetRandomSerialNumber();
385
386 SignalThresholdInfo signalThresholdInfo;
387 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
388 signalThresholdInfo.hysteresisMs = 0;
389 signalThresholdInfo.hysteresisDb = 0;
390 signalThresholdInfo.isEnabled = true;
391 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
392
393 ndk::ScopedAStatus res =
394 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
395 ASSERT_OK(res);
396 EXPECT_EQ(std::cv_status::no_timeout, wait());
397 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
398 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
399
400 ALOGI("setSignalStrengthReportingCriteria_EmptyParams, rspInfo.error = %s\n",
401 toString(radioRsp_network->rspInfo.error).c_str());
402 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
403 }
404
405 /*
406 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for GERAN
407 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Geran)408 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Geran) {
409 if (telephony_flags::enforce_telephony_feature_mapping()) {
410 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
411 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Geran "
412 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
413 }
414 }
415
416 serial = GetRandomSerialNumber();
417
418 SignalThresholdInfo signalThresholdInfo;
419 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
420 signalThresholdInfo.hysteresisMs = 5000;
421 signalThresholdInfo.hysteresisDb = 2;
422 signalThresholdInfo.thresholds = {-109, -103, -97, -89};
423 signalThresholdInfo.isEnabled = true;
424 signalThresholdInfo.ran = AccessNetwork::GERAN;
425
426 ndk::ScopedAStatus res =
427 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
428 ASSERT_OK(res);
429 EXPECT_EQ(std::cv_status::no_timeout, wait());
430 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
431 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
432
433 ALOGI("setSignalStrengthReportingCriteria_Geran, rspInfo.error = %s\n",
434 toString(radioRsp_network->rspInfo.error).c_str());
435 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
436 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
437 }
438
439 /*
440 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for UTRAN
441 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Utran_Rscp)442 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Utran_Rscp) {
443 if (telephony_flags::enforce_telephony_feature_mapping()) {
444 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
445 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Utran_Rscp "
446 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
447 }
448 }
449
450 serial = GetRandomSerialNumber();
451
452 SignalThresholdInfo signalThresholdInfo;
453 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSCP;
454 signalThresholdInfo.hysteresisMs = 5000;
455 signalThresholdInfo.hysteresisDb = 2;
456 signalThresholdInfo.thresholds = {-110, -97, -73, -49, -25};
457 signalThresholdInfo.isEnabled = true;
458 signalThresholdInfo.ran = AccessNetwork::UTRAN;
459
460 ndk::ScopedAStatus res =
461 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
462 ASSERT_OK(res);
463 EXPECT_EQ(std::cv_status::no_timeout, wait());
464 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
465 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
466
467 ALOGI("setSignalStrengthReportingCriteria_Utran, rspInfo.error = %s\n",
468 toString(radioRsp_network->rspInfo.error).c_str());
469 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
470 }
471
472 /*
473 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for UTRAN
474 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Utran_Ecno)475 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Utran_Ecno) {
476 if (telephony_flags::enforce_telephony_feature_mapping()) {
477 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
478 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Utran_Ecno "
479 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
480 }
481 }
482
483 serial = GetRandomSerialNumber();
484
485 SignalThresholdInfo signalThresholdInfo;
486 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_ECNO;
487 signalThresholdInfo.hysteresisMs = 5000;
488 signalThresholdInfo.hysteresisDb = 2;
489 signalThresholdInfo.thresholds = {-22, -18, 0};
490 signalThresholdInfo.isEnabled = true;
491 signalThresholdInfo.ran = AccessNetwork::UTRAN;
492
493 ndk::ScopedAStatus res =
494 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
495 ASSERT_OK(res);
496 EXPECT_EQ(std::cv_status::no_timeout, wait());
497 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
498 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
499
500 ALOGI("setSignalStrengthReportingCriteria_Utran, rspInfo.error = %s\n",
501 toString(radioRsp_network->rspInfo.error).c_str());
502 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
503 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
504 }
505
506 /*
507 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
508 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Eutran_RSRP)509 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSRP) {
510 if (telephony_flags::enforce_telephony_feature_mapping()) {
511 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
512 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Eutran_RSRP "
513 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
514 }
515 }
516
517 serial = GetRandomSerialNumber();
518
519 SignalThresholdInfo signalThresholdInfo;
520 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSRP;
521 signalThresholdInfo.hysteresisMs = 5000;
522 signalThresholdInfo.hysteresisDb = 2;
523 signalThresholdInfo.thresholds = {-128, -108, -88, -68};
524 signalThresholdInfo.isEnabled = true;
525 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
526
527 ndk::ScopedAStatus res =
528 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
529 ASSERT_OK(res);
530 EXPECT_EQ(std::cv_status::no_timeout, wait());
531 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
532 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
533
534 ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
535 toString(radioRsp_network->rspInfo.error).c_str());
536 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
537 }
538
539 /*
540 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
541 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Eutran_RSRQ)542 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSRQ) {
543 if (telephony_flags::enforce_telephony_feature_mapping()) {
544 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
545 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Eutran_RSRQ "
546 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
547 }
548 }
549
550 serial = GetRandomSerialNumber();
551
552 SignalThresholdInfo signalThresholdInfo;
553 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSRQ;
554 signalThresholdInfo.hysteresisMs = 5000;
555 signalThresholdInfo.hysteresisDb = 2;
556 signalThresholdInfo.thresholds = {-27, -20, -13, -6};
557 signalThresholdInfo.isEnabled = true;
558 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
559
560 ndk::ScopedAStatus res =
561 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
562 ASSERT_OK(res);
563 EXPECT_EQ(std::cv_status::no_timeout, wait());
564 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
565 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
566
567 ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
568 toString(radioRsp_network->rspInfo.error).c_str());
569 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
570 }
571
572 /*
573 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
574 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Eutran_RSSNR)575 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSSNR) {
576 if (telephony_flags::enforce_telephony_feature_mapping()) {
577 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
578 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Eutran_RSSNR "
579 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
580 }
581 }
582
583 serial = GetRandomSerialNumber();
584
585 SignalThresholdInfo signalThresholdInfo;
586 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSNR;
587 signalThresholdInfo.hysteresisMs = 5000;
588 signalThresholdInfo.hysteresisDb = 2;
589 signalThresholdInfo.thresholds = {-10, 0, 10, 20};
590 signalThresholdInfo.isEnabled = true;
591 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
592
593 ndk::ScopedAStatus res =
594 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
595 ASSERT_OK(res);
596 EXPECT_EQ(std::cv_status::no_timeout, wait());
597 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
598 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
599 }
600
601 /*
602 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for CDMA2000
603 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Cdma2000)604 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Cdma2000) {
605 if (telephony_flags::enforce_telephony_feature_mapping()) {
606 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
607 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Cdma2000 "
608 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
609 }
610 }
611
612 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
613 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Cdma2000 "
614 "due to undefined FEATURE_TELEPHONY_CDMA";
615 }
616
617 serial = GetRandomSerialNumber();
618
619 SignalThresholdInfo signalThresholdInfo;
620 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
621 signalThresholdInfo.hysteresisMs = 5000;
622 signalThresholdInfo.hysteresisDb = 2;
623 signalThresholdInfo.thresholds = {-105, -90, -75, -65};
624 signalThresholdInfo.isEnabled = true;
625 signalThresholdInfo.ran = AccessNetwork::CDMA2000;
626
627 ndk::ScopedAStatus res =
628 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
629 ASSERT_OK(res);
630 EXPECT_EQ(std::cv_status::no_timeout, wait());
631 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
632 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
633
634 ALOGI("setSignalStrengthReportingCriteria_Cdma2000, rspInfo.error = %s\n",
635 toString(radioRsp_network->rspInfo.error).c_str());
636 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
637 }
638
639 /*
640 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSRSRP
641 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_NGRAN_SSRSRP)642 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_NGRAN_SSRSRP) {
643 if (telephony_flags::enforce_telephony_feature_mapping()) {
644 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
645 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_NGRAN_SSRSRP "
646 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
647 }
648 }
649
650 serial = GetRandomSerialNumber();
651
652 SignalThresholdInfo signalThresholdInfo;
653 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRP;
654 signalThresholdInfo.hysteresisMs = 5000;
655 signalThresholdInfo.hysteresisDb = 0;
656 signalThresholdInfo.thresholds = {-105, -90, -75, -65};
657 signalThresholdInfo.isEnabled = true;
658 signalThresholdInfo.ran = AccessNetwork::NGRAN;
659
660 ndk::ScopedAStatus res =
661 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
662 ASSERT_OK(res);
663 EXPECT_EQ(std::cv_status::no_timeout, wait());
664 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
665 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
666
667 ALOGI("setSignalStrengthReportingCriteria_NGRAN_SSRSRP, rspInfo.error = %s\n",
668 toString(radioRsp_network->rspInfo.error).c_str());
669
670 // Allow REQUEST_NOT_SUPPORTED because some non-5G device may not support NGRAN for
671 // setSignalStrengthReportingCriteria()
672 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
673 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
674 }
675
676 /*
677 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSRSRQ
678 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_NGRAN_SSRSRQ)679 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_NGRAN_SSRSRQ) {
680 if (telephony_flags::enforce_telephony_feature_mapping()) {
681 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
682 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_NGRAN_SSRSRQ "
683 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
684 }
685 }
686
687 serial = GetRandomSerialNumber();
688
689 SignalThresholdInfo signalThresholdInfo;
690 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRQ;
691 signalThresholdInfo.hysteresisMs = 5000;
692 signalThresholdInfo.hysteresisDb = 0;
693 signalThresholdInfo.thresholds = {-43, -20, 0, 20};
694 signalThresholdInfo.isEnabled = true;
695 signalThresholdInfo.ran = AccessNetwork::NGRAN;
696
697 ndk::ScopedAStatus res =
698 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
699 ASSERT_OK(res);
700 EXPECT_EQ(std::cv_status::no_timeout, wait());
701 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
702 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
703
704 ALOGI("setSignalStrengthReportingCriteria_NGRAN_SSRSRQ, rspInfo.error = %s\n",
705 toString(radioRsp_network->rspInfo.error).c_str());
706
707 // Allow REQUEST_NOT_SUPPORTED because some non-5G device may not support NGRAN for
708 // setSignalStrengthReportingCriteria()
709 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
710 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
711 }
712
713 /*
714 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
715 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_Disable_RSSNR)716 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Disable_RSSNR) {
717 if (telephony_flags::enforce_telephony_feature_mapping()) {
718 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
719 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Disable_RSSNR "
720 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
721 }
722 }
723
724 serial = GetRandomSerialNumber();
725
726 SignalThresholdInfo signalThresholdInfo;
727 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSNR;
728 signalThresholdInfo.hysteresisMs = 5000;
729 signalThresholdInfo.hysteresisDb = 2;
730 signalThresholdInfo.thresholds = {-10, 0, 10, 20};
731 signalThresholdInfo.isEnabled = false;
732 signalThresholdInfo.ran = AccessNetwork::EUTRAN;
733
734 ndk::ScopedAStatus res =
735 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
736 ASSERT_OK(res);
737 EXPECT_EQ(std::cv_status::no_timeout, wait());
738 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
739 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
740 }
741
742 /*
743 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSSINR
744 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_NGRAN_SSSINR)745 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_NGRAN_SSSINR) {
746 if (telephony_flags::enforce_telephony_feature_mapping()) {
747 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
748 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_NGRAN_SSSINR "
749 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
750 }
751 }
752
753 serial = GetRandomSerialNumber();
754
755 SignalThresholdInfo signalThresholdInfo;
756 signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSSINR;
757 signalThresholdInfo.hysteresisMs = 5000;
758 signalThresholdInfo.hysteresisDb = 0;
759 signalThresholdInfo.thresholds = {-10, 3, 16, 18};
760 signalThresholdInfo.isEnabled = true;
761 signalThresholdInfo.ran = AccessNetwork::NGRAN;
762
763 ndk::ScopedAStatus res =
764 radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
765 ASSERT_OK(res);
766 EXPECT_EQ(std::cv_status::no_timeout, wait());
767 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
768 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
769
770 ALOGI("setSignalStrengthReportingCriteria_NGRAN_SSSINR, rspInfo.error = %s\n",
771 toString(radioRsp_network->rspInfo.error).c_str());
772
773 // Allow REQUEST_NOT_SUPPORTED because some non-5G device may not support NGRAN for
774 // setSignalStrengthReportingCriteria()
775 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
776 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
777 }
778
779 /*
780 * Test IRadioNetwork.setSignalStrengthReportingCriteria() for multi-RANs per request
781 */
TEST_P(RadioNetworkTest,setSignalStrengthReportingCriteria_multiRansPerRequest)782 TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_multiRansPerRequest) {
783 if (telephony_flags::enforce_telephony_feature_mapping()) {
784 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
785 GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_multiRansPerRequest "
786 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
787 }
788 }
789
790 SignalThresholdInfo signalThresholdInfoGeran;
791 signalThresholdInfoGeran.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
792 signalThresholdInfoGeran.hysteresisMs = 5000;
793 signalThresholdInfoGeran.hysteresisDb = 2;
794 signalThresholdInfoGeran.thresholds = {-109, -103, -97, -89};
795 signalThresholdInfoGeran.isEnabled = true;
796 signalThresholdInfoGeran.ran = AccessNetwork::GERAN;
797
798 SignalThresholdInfo signalThresholdInfoUtran;
799 signalThresholdInfoUtran.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSCP;
800 signalThresholdInfoUtran.hysteresisMs = 5000;
801 signalThresholdInfoUtran.hysteresisDb = 2;
802 signalThresholdInfoUtran.thresholds = {-110, -97, -73, -49, -25};
803 signalThresholdInfoUtran.isEnabled = true;
804 signalThresholdInfoUtran.ran = AccessNetwork::UTRAN;
805
806 SignalThresholdInfo signalThresholdInfoEutran;
807 signalThresholdInfoEutran.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSRP;
808 signalThresholdInfoEutran.hysteresisMs = 5000;
809 signalThresholdInfoEutran.hysteresisDb = 2;
810 signalThresholdInfoEutran.thresholds = {-128, -108, -88, -68};
811 signalThresholdInfoEutran.isEnabled = true;
812 signalThresholdInfoEutran.ran = AccessNetwork::EUTRAN;
813
814 SignalThresholdInfo signalThresholdInfoCdma2000;
815 signalThresholdInfoCdma2000.signalMeasurement =
816 SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
817 signalThresholdInfoCdma2000.hysteresisMs = 5000;
818 signalThresholdInfoCdma2000.hysteresisDb = 2;
819 signalThresholdInfoCdma2000.thresholds = {-105, -90, -75, -65};
820 signalThresholdInfoCdma2000.isEnabled = true;
821 signalThresholdInfoCdma2000.ran = AccessNetwork::CDMA2000;
822
823 SignalThresholdInfo signalThresholdInfoNgran;
824 signalThresholdInfoNgran.signalMeasurement =
825 SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRP;
826 signalThresholdInfoNgran.hysteresisMs = 5000;
827 signalThresholdInfoNgran.hysteresisDb = 0;
828 signalThresholdInfoNgran.thresholds = {-105, -90, -75, -65};
829 signalThresholdInfoNgran.isEnabled = true;
830 signalThresholdInfoNgran.ran = AccessNetwork::NGRAN;
831
832 std::vector<SignalThresholdInfo> candidateSignalThresholdInfos = {
833 signalThresholdInfoGeran, signalThresholdInfoUtran, signalThresholdInfoEutran,
834 signalThresholdInfoNgran};
835 if (deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
836 candidateSignalThresholdInfos.push_back(signalThresholdInfoCdma2000);
837 }
838
839 std::vector<SignalThresholdInfo> supportedSignalThresholdInfos;
840 for (size_t i = 0; i < candidateSignalThresholdInfos.size(); i++) {
841 serial = GetRandomSerialNumber();
842 ndk::ScopedAStatus res = radio_network->setSignalStrengthReportingCriteria(
843 serial, {candidateSignalThresholdInfos[i]});
844 ASSERT_OK(res);
845 EXPECT_EQ(std::cv_status::no_timeout, wait());
846 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
847 supportedSignalThresholdInfos.push_back(signalThresholdInfoEutran);
848 } else {
849 // Refer to IRadioNetworkResponse#setSignalStrengthReportingCriteriaResponse
850 ASSERT_TRUE(CheckAnyOfErrors(
851 radioRsp_network->rspInfo.error,
852 {RadioError::INVALID_ARGUMENTS, RadioError::RADIO_NOT_AVAILABLE}));
853 }
854 }
855
856 ASSERT_FALSE(supportedSignalThresholdInfos.empty());
857
858 serial = GetRandomSerialNumber();
859 ndk::ScopedAStatus res = radio_network->setSignalStrengthReportingCriteria(
860 serial, supportedSignalThresholdInfos);
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
866 ALOGI("setSignalStrengthReportingCriteria_multiRansPerRequest, rspInfo.error = %s\n",
867 toString(radioRsp_network->rspInfo.error).c_str());
868
869 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
870 }
871
872 /*
873 * Test IRadioNetwork.setLinkCapacityReportingCriteria() invalid hysteresisDlKbps
874 */
TEST_P(RadioNetworkTest,setLinkCapacityReportingCriteria_invalidHysteresisDlKbps)875 TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_invalidHysteresisDlKbps) {
876 if (telephony_flags::enforce_telephony_feature_mapping()) {
877 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
878 GTEST_SKIP() << "Skipping setLinkCapacityReportingCriteria_invalidHysteresisDlKbps "
879 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
880 }
881 }
882
883 serial = GetRandomSerialNumber();
884
885 ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
886 serial, 5000,
887 5000, // hysteresisDlKbps too big for thresholds delta
888 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000}, AccessNetwork::EUTRAN);
889 ASSERT_OK(res);
890 EXPECT_EQ(std::cv_status::no_timeout, wait());
891 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
892 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
893
894 ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisDlKbps, rspInfo.error = %s\n",
895 toString(radioRsp_network->rspInfo.error).c_str());
896 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
897 }
898
899 /*
900 * Test IRadioNetwork.setLinkCapacityReportingCriteria() invalid hysteresisUlKbps
901 */
TEST_P(RadioNetworkTest,setLinkCapacityReportingCriteria_invalidHysteresisUlKbps)902 TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_invalidHysteresisUlKbps) {
903 if (telephony_flags::enforce_telephony_feature_mapping()) {
904 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
905 GTEST_SKIP() << "Skipping setLinkCapacityReportingCriteria_invalidHysteresisUlKbps "
906 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
907 }
908 }
909
910 serial = GetRandomSerialNumber();
911
912 ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
913 serial, 5000, 500, 1000, // hysteresisUlKbps too big for thresholds delta
914 {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000}, AccessNetwork::EUTRAN);
915 ASSERT_OK(res);
916 EXPECT_EQ(std::cv_status::no_timeout, wait());
917 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
918 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
919
920 ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
921 toString(radioRsp_network->rspInfo.error).c_str());
922 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
923 }
924
925 /*
926 * Test IRadioNetwork.setLinkCapacityReportingCriteria() empty params
927 */
TEST_P(RadioNetworkTest,setLinkCapacityReportingCriteria_emptyParams)928 TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_emptyParams) {
929 if (telephony_flags::enforce_telephony_feature_mapping()) {
930 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
931 GTEST_SKIP() << "Skipping setLinkCapacityReportingCriteria_emptyParams "
932 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
933 }
934 }
935
936 serial = GetRandomSerialNumber();
937
938 ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
939 serial, 0, 0, 0, {}, {}, AccessNetwork::EUTRAN);
940 ASSERT_OK(res);
941 EXPECT_EQ(std::cv_status::no_timeout, wait());
942 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
943 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
944
945 ALOGI("setLinkCapacityReportingCriteria_emptyParams, rspInfo.error = %s\n",
946 toString(radioRsp_network->rspInfo.error).c_str());
947 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
948 }
949
950 /*
951 * Test IRadioNetwork.setLinkCapacityReportingCriteria() for GERAN
952 */
TEST_P(RadioNetworkTest,setLinkCapacityReportingCriteria_Geran)953 TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_Geran) {
954 if (telephony_flags::enforce_telephony_feature_mapping()) {
955 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
956 GTEST_SKIP() << "Skipping setLinkCapacityReportingCriteria_Geran "
957 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
958 }
959 }
960
961 serial = GetRandomSerialNumber();
962
963 ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
964 serial, 5000, 500, 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
965 AccessNetwork::GERAN);
966 ASSERT_OK(res);
967 EXPECT_EQ(std::cv_status::no_timeout, wait());
968 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
969 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
970
971 ALOGI("setLinkCapacityReportingCriteria_Geran, rspInfo.error = %s\n",
972 toString(radioRsp_network->rspInfo.error).c_str());
973 // Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported
974 // for GERAN
975 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
976 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
977 }
978
979 /*
980 * Test IRadioNetwork.setSystemSelectionChannels() for the response returned.
981 */
TEST_P(RadioNetworkTest,setSystemSelectionChannels)982 TEST_P(RadioNetworkTest, setSystemSelectionChannels) {
983 if (telephony_flags::enforce_telephony_feature_mapping()) {
984 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
985 GTEST_SKIP() << "Skipping setSystemSelectionChannels "
986 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
987 }
988 }
989
990 serial = GetRandomSerialNumber();
991 ndk::ScopedAStatus res = radio_network->getSystemSelectionChannels(serial);
992 EXPECT_EQ(std::cv_status::no_timeout, wait());
993 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
994 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
995 if (radioRsp_network->specifiers.size() == 0) {
996 // TODO (b/189255895): Throw an error once getSystemSelectionChannels is functional.
997 ALOGI("Skipped the test due to empty system selection channels.");
998 GTEST_SKIP();
999 }
1000 std::vector<RadioAccessSpecifier> originalSpecifiers = radioRsp_network->specifiers;
1001
1002 serial = GetRandomSerialNumber();
1003 res = radio_network->setSystemSelectionChannels(serial, true,
1004 {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20});
1005 ASSERT_OK(res);
1006 EXPECT_EQ(std::cv_status::no_timeout, wait());
1007 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1008 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1009 ALOGI("setSystemSelectionChannels, rspInfo.error = %s\n",
1010 toString(radioRsp_network->rspInfo.error).c_str());
1011 ASSERT_TRUE(CheckAnyOfErrors(
1012 radioRsp_network->rspInfo.error,
1013 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR}));
1014
1015 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
1016 serial = GetRandomSerialNumber();
1017 res = radio_network->setSystemSelectionChannels(
1018 serial, false, {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20});
1019 ASSERT_OK(res);
1020 EXPECT_EQ(std::cv_status::no_timeout, wait());
1021 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1022 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1023 ALOGI("setSystemSelectionChannels, rspInfo.error = %s\n",
1024 toString(radioRsp_network->rspInfo.error).c_str());
1025 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
1026 }
1027
1028 serial = GetRandomSerialNumber();
1029 res = radio_network->setSystemSelectionChannels(serial, true, originalSpecifiers);
1030 EXPECT_EQ(std::cv_status::no_timeout, wait());
1031 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1032 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1033 }
1034
1035 /*
1036 * Test IRadioNetwork.startNetworkScan() for the response returned.
1037 */
TEST_P(RadioNetworkTest,startNetworkScan)1038 TEST_P(RadioNetworkTest, startNetworkScan) {
1039 if (telephony_flags::enforce_telephony_feature_mapping()) {
1040 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1041 GTEST_SKIP() << "Skipping startNetworkScan "
1042 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1043 }
1044 }
1045
1046 serial = GetRandomSerialNumber();
1047
1048 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1049 .interval = 60,
1050 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1051 .maxSearchTime = 60,
1052 .incrementalResults = false,
1053 .incrementalResultsPeriodicity = 1};
1054
1055 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1056 ASSERT_OK(res);
1057 EXPECT_EQ(std::cv_status::no_timeout, wait());
1058 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1059 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1060 ALOGI("startNetworkScan, rspInfo.error = %s\n",
1061 toString(radioRsp_network->rspInfo.error).c_str());
1062
1063 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1064 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::SIM_ABSENT}));
1065 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1066 if (deviceSupportsFeature(FEATURE_TELEPHONY_GSM) && isLteConnected()) {
1067 // Modems support 3GPP RAT family need to
1068 // support scanning requests combined with some parameters.
1069 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1070 {RadioError::NONE, RadioError::OPERATION_NOT_ALLOWED}));
1071 } else {
1072 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1073 {RadioError::NONE, RadioError::OPERATION_NOT_ALLOWED,
1074 RadioError::INVALID_ARGUMENTS}));
1075 }
1076 }
1077
1078 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
1079 ALOGI("Stop Network Scan");
1080 stopNetworkScan();
1081 }
1082 }
1083
1084 /*
1085 * Test IRadioNetwork.startNetworkScan() with invalid specifier.
1086 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidArgument)1087 TEST_P(RadioNetworkTest, startNetworkScan_InvalidArgument) {
1088 if (telephony_flags::enforce_telephony_feature_mapping()) {
1089 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1090 GTEST_SKIP() << "Skipping startNetworkScan_InvalidArgument "
1091 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1092 }
1093 }
1094
1095 serial = GetRandomSerialNumber();
1096
1097 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT, .interval = 60};
1098
1099 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1100 ASSERT_OK(res);
1101 EXPECT_EQ(std::cv_status::no_timeout, wait());
1102 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1103 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1104 ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
1105 toString(radioRsp_network->rspInfo.error).c_str());
1106
1107 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1108 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1109 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1110 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1111 ASSERT_TRUE(
1112 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1113 }
1114 }
1115
1116 /*
1117 * Test IRadioNetwork.startNetworkScan() with invalid interval (lower boundary).
1118 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidInterval1)1119 TEST_P(RadioNetworkTest, startNetworkScan_InvalidInterval1) {
1120 if (telephony_flags::enforce_telephony_feature_mapping()) {
1121 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1122 GTEST_SKIP() << "Skipping startNetworkScan_InvalidInterval1 "
1123 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1124 }
1125 }
1126
1127 serial = GetRandomSerialNumber();
1128
1129 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_PERIODIC,
1130 .interval = 4,
1131 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1132 .maxSearchTime = 60,
1133 .incrementalResults = false,
1134 .incrementalResultsPeriodicity = 1};
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_InvalidInterval1, 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::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1146 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1147 ASSERT_TRUE(
1148 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1149 }
1150 }
1151
1152 /*
1153 * Test IRadioNetwork.startNetworkScan() with invalid interval (upper boundary).
1154 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidInterval2)1155 TEST_P(RadioNetworkTest, startNetworkScan_InvalidInterval2) {
1156 if (telephony_flags::enforce_telephony_feature_mapping()) {
1157 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1158 GTEST_SKIP() << "Skipping startNetworkScan_InvalidInterval2 "
1159 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1160 }
1161 }
1162
1163 serial = GetRandomSerialNumber();
1164
1165 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_PERIODIC,
1166 .interval = 301,
1167 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1168 .maxSearchTime = 60,
1169 .incrementalResults = false,
1170 .incrementalResultsPeriodicity = 1};
1171
1172 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1173 ASSERT_OK(res);
1174 EXPECT_EQ(std::cv_status::no_timeout, wait());
1175 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1176 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1177 ALOGI("startNetworkScan_InvalidInterval2, rspInfo.error = %s\n",
1178 toString(radioRsp_network->rspInfo.error).c_str());
1179 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1180 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1181 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1182 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1183 ASSERT_TRUE(
1184 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1185 }
1186 }
1187
1188 /*
1189 * Test IRadioNetwork.startNetworkScan() with invalid max search time (lower boundary).
1190 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidMaxSearchTime1)1191 TEST_P(RadioNetworkTest, startNetworkScan_InvalidMaxSearchTime1) {
1192 if (telephony_flags::enforce_telephony_feature_mapping()) {
1193 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1194 GTEST_SKIP() << "Skipping startNetworkScan_InvalidMaxSearchTime1 "
1195 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1196 }
1197 }
1198
1199 serial = GetRandomSerialNumber();
1200
1201 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1202 .interval = 60,
1203 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1204 .maxSearchTime = 59,
1205 .incrementalResults = false,
1206 .incrementalResultsPeriodicity = 1};
1207
1208 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1209 ASSERT_OK(res);
1210 EXPECT_EQ(std::cv_status::no_timeout, wait());
1211 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1212 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1213 ALOGI("startNetworkScan_InvalidMaxSearchTime1, rspInfo.error = %s\n",
1214 toString(radioRsp_network->rspInfo.error).c_str());
1215 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1216 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1217 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1218 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1219 ASSERT_TRUE(
1220 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1221 }
1222 }
1223
1224 /*
1225 * Test IRadioNetwork.startNetworkScan() with invalid max search time (upper boundary).
1226 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidMaxSearchTime2)1227 TEST_P(RadioNetworkTest, startNetworkScan_InvalidMaxSearchTime2) {
1228 if (telephony_flags::enforce_telephony_feature_mapping()) {
1229 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1230 GTEST_SKIP() << "Skipping startNetworkScan_InvalidMaxSearchTime2 "
1231 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1232 }
1233 }
1234
1235 serial = GetRandomSerialNumber();
1236
1237 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1238 .interval = 60,
1239 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1240 .maxSearchTime = 3601,
1241 .incrementalResults = false,
1242 .incrementalResultsPeriodicity = 1};
1243
1244 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1245 ASSERT_OK(res);
1246 EXPECT_EQ(std::cv_status::no_timeout, wait());
1247 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1248 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1249 ALOGI("startNetworkScan_InvalidMaxSearchTime2, rspInfo.error = %s\n",
1250 toString(radioRsp_network->rspInfo.error).c_str());
1251 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1252 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1253 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1254 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1255 ASSERT_TRUE(
1256 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1257 }
1258 }
1259
1260 /*
1261 * Test IRadioNetwork.startNetworkScan() with invalid periodicity (lower boundary).
1262 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidPeriodicity1)1263 TEST_P(RadioNetworkTest, startNetworkScan_InvalidPeriodicity1) {
1264 if (telephony_flags::enforce_telephony_feature_mapping()) {
1265 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1266 GTEST_SKIP() << "Skipping startNetworkScan_InvalidPeriodicity1 "
1267 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1268 }
1269 }
1270
1271 serial = GetRandomSerialNumber();
1272
1273 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1274 .interval = 60,
1275 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1276 .maxSearchTime = 600,
1277 .incrementalResults = true,
1278 .incrementalResultsPeriodicity = 0};
1279
1280 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1281 ASSERT_OK(res);
1282 EXPECT_EQ(std::cv_status::no_timeout, wait());
1283 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1284 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1285 ALOGI("startNetworkScan_InvalidPeriodicity1, rspInfo.error = %s\n",
1286 toString(radioRsp_network->rspInfo.error).c_str());
1287 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1288 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1289 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1290 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1291 ASSERT_TRUE(
1292 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1293 }
1294 }
1295
1296 /*
1297 * Test IRadioNetwork.startNetworkScan() with invalid periodicity (upper boundary).
1298 */
TEST_P(RadioNetworkTest,startNetworkScan_InvalidPeriodicity2)1299 TEST_P(RadioNetworkTest, startNetworkScan_InvalidPeriodicity2) {
1300 if (telephony_flags::enforce_telephony_feature_mapping()) {
1301 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1302 GTEST_SKIP() << "Skipping startNetworkScan_InvalidPeriodicity2 "
1303 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1304 }
1305 }
1306
1307 serial = GetRandomSerialNumber();
1308
1309 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1310 .interval = 60,
1311 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1312 .maxSearchTime = 600,
1313 .incrementalResults = true,
1314 .incrementalResultsPeriodicity = 11};
1315
1316 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1317 ASSERT_OK(res);
1318 EXPECT_EQ(std::cv_status::no_timeout, wait());
1319 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1320 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1321 ALOGI("startNetworkScan_InvalidPeriodicity2, rspInfo.error = %s\n",
1322 toString(radioRsp_network->rspInfo.error).c_str());
1323 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1324 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1325 {RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
1326 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1327 ASSERT_TRUE(
1328 CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
1329 }
1330 }
1331
1332 /*
1333 * Test IRadioNetwork.startNetworkScan() with valid periodicity
1334 */
TEST_P(RadioNetworkTest,startNetworkScan_GoodRequest1)1335 TEST_P(RadioNetworkTest, startNetworkScan_GoodRequest1) {
1336 if (telephony_flags::enforce_telephony_feature_mapping()) {
1337 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1338 GTEST_SKIP() << "Skipping startNetworkScan_GoodRequest1 "
1339 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1340 }
1341 }
1342
1343 serial = GetRandomSerialNumber();
1344
1345 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1346 .interval = 60,
1347 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1348 .maxSearchTime = 360,
1349 .incrementalResults = false,
1350 .incrementalResultsPeriodicity = 10};
1351
1352 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1353 ASSERT_OK(res);
1354 EXPECT_EQ(std::cv_status::no_timeout, wait());
1355 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1356 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1357 ALOGI("startNetworkScan_GoodRequest1, rspInfo.error = %s\n",
1358 toString(radioRsp_network->rspInfo.error).c_str());
1359 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1360 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1361 {RadioError::NONE, RadioError::SIM_ABSENT}));
1362 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1363 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1364 {RadioError::NONE, RadioError::INVALID_ARGUMENTS}));
1365 }
1366
1367 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
1368 ALOGI("Stop Network Scan");
1369 stopNetworkScan();
1370 }
1371 }
1372
1373 /*
1374 * Test IRadioNetwork.startNetworkScan() with valid periodicity and plmns
1375 */
TEST_P(RadioNetworkTest,startNetworkScan_GoodRequest2)1376 TEST_P(RadioNetworkTest, startNetworkScan_GoodRequest2) {
1377 if (telephony_flags::enforce_telephony_feature_mapping()) {
1378 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1379 GTEST_SKIP() << "Skipping startNetworkScan_GoodRequest2 "
1380 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1381 }
1382 }
1383
1384 serial = GetRandomSerialNumber();
1385
1386 NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
1387 .interval = 60,
1388 .specifiers = {::EUTRAN_SPECIFIER_17, ::EUTRAN_SPECIFIER_20},
1389 .maxSearchTime = 360,
1390 .incrementalResults = false,
1391 .incrementalResultsPeriodicity = 10,
1392 .mccMncs = {"310410"}};
1393
1394 ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
1395 ASSERT_OK(res);
1396 EXPECT_EQ(std::cv_status::no_timeout, wait());
1397 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1398 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1399 ALOGI("startNetworkScan_GoodRequest2, rspInfo.error = %s\n",
1400 toString(radioRsp_network->rspInfo.error).c_str());
1401 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1402 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1403 {RadioError::NONE, RadioError::SIM_ABSENT}));
1404 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1405 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1406 {RadioError::NONE, RadioError::INVALID_ARGUMENTS}));
1407 }
1408
1409 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
1410 ALOGI("Stop Network Scan");
1411 stopNetworkScan();
1412 }
1413 }
1414
1415 /*
1416 * Test IRadioNetwork.setNetworkSelectionModeManual() for the response returned.
1417 */
TEST_P(RadioNetworkTest,setNetworkSelectionModeManual)1418 TEST_P(RadioNetworkTest, setNetworkSelectionModeManual) {
1419 if (telephony_flags::enforce_telephony_feature_mapping()) {
1420 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1421 GTEST_SKIP() << "Skipping setNetworkSelectionModeManual "
1422 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1423 }
1424 }
1425
1426 serial = GetRandomSerialNumber();
1427
1428 // can't camp on nonexistent MCCMNC, so we expect this to fail.
1429 ndk::ScopedAStatus res =
1430 radio_network->setNetworkSelectionModeManual(serial, "123456", AccessNetwork::EUTRAN);
1431 EXPECT_EQ(std::cv_status::no_timeout, wait());
1432 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1433 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1434
1435 ASSERT_TRUE(CheckAnyOfErrors(
1436 radioRsp_network->rspInfo.error,
1437 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
1438 RadioError::INVALID_STATE, RadioError::NO_MEMORY, RadioError::INTERNAL_ERR,
1439 RadioError::SYSTEM_ERR, RadioError::CANCELLED, RadioError::MODEM_ERR}));
1440 }
1441
1442 /*
1443 * Test IRadioNetwork.getBarringInfo() for the response returned.
1444 */
TEST_P(RadioNetworkTest,getBarringInfo)1445 TEST_P(RadioNetworkTest, getBarringInfo) {
1446 if (telephony_flags::enforce_telephony_feature_mapping()) {
1447 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1448 GTEST_SKIP() << "Skipping getBarringInfo "
1449 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1450 }
1451 }
1452
1453 serial = GetRandomSerialNumber();
1454 ndk::ScopedAStatus res = radio_network->getBarringInfo(serial);
1455 EXPECT_EQ(std::cv_status::no_timeout, wait());
1456 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1457 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1458 ASSERT_TRUE(radioRsp_network->barringInfoList.size() > 0);
1459
1460 std::set<int> reportedServices;
1461
1462 // validate that the service types are in range
1463 for (const auto& info : radioRsp_network->barringInfoList) {
1464 ASSERT_TRUE((info.serviceType >= BarringInfo::SERVICE_TYPE_CS_SERVICE &&
1465 info.serviceType <= BarringInfo::SERVICE_TYPE_SMS) ||
1466 (info.serviceType >= BarringInfo::SERVICE_TYPE_OPERATOR_1 &&
1467 info.serviceType <= BarringInfo::SERVICE_TYPE_OPERATOR_32));
1468 reportedServices.insert(info.serviceType);
1469
1470 // Any type that is "conditional" must have valid values for conditional barring
1471 // factor and time.
1472 switch (info.barringType) {
1473 case BarringInfo::BARRING_TYPE_NONE: // fall through
1474 case BarringInfo::BARRING_TYPE_UNCONDITIONAL:
1475 break;
1476 case BarringInfo::BARRING_TYPE_CONDITIONAL: {
1477 const int32_t barringFactor = info.barringTypeSpecificInfo->factor;
1478 ASSERT_TRUE(barringFactor >= 0 && barringFactor <= 100);
1479 ASSERT_TRUE(info.barringTypeSpecificInfo->timeSeconds > 0);
1480 break;
1481 }
1482 default:
1483 FAIL();
1484 }
1485 }
1486
1487 // Certain types of barring are relevant for certain RANs. Ensure that only the right
1488 // types are reported. Note that no types are required, simply that for a given technology
1489 // only certain types are valid. This is one way to check that implementations are
1490 // not providing information that they don't have.
1491 static const std::set<int> UTRA_SERVICES{
1492 BarringInfo::SERVICE_TYPE_CS_SERVICE, BarringInfo::SERVICE_TYPE_PS_SERVICE,
1493 BarringInfo::SERVICE_TYPE_CS_VOICE, BarringInfo::SERVICE_TYPE_EMERGENCY,
1494 BarringInfo::SERVICE_TYPE_SMS,
1495 };
1496
1497 static const std::set<int> EUTRA_SERVICES{
1498 BarringInfo::SERVICE_TYPE_MO_SIGNALLING, BarringInfo::SERVICE_TYPE_MO_DATA,
1499 BarringInfo::SERVICE_TYPE_CS_FALLBACK, BarringInfo::SERVICE_TYPE_MMTEL_VOICE,
1500 BarringInfo::SERVICE_TYPE_MMTEL_VIDEO, BarringInfo::SERVICE_TYPE_EMERGENCY,
1501 BarringInfo::SERVICE_TYPE_SMS,
1502 };
1503
1504 static const std::set<int> NGRA_SERVICES = {
1505 BarringInfo::SERVICE_TYPE_MO_SIGNALLING, BarringInfo::SERVICE_TYPE_MO_DATA,
1506 BarringInfo::SERVICE_TYPE_CS_FALLBACK, BarringInfo::SERVICE_TYPE_MMTEL_VOICE,
1507 BarringInfo::SERVICE_TYPE_MMTEL_VIDEO, BarringInfo::SERVICE_TYPE_EMERGENCY,
1508 BarringInfo::SERVICE_TYPE_SMS, BarringInfo::SERVICE_TYPE_OPERATOR_1,
1509 BarringInfo::SERVICE_TYPE_OPERATOR_2, BarringInfo::SERVICE_TYPE_OPERATOR_3,
1510 BarringInfo::SERVICE_TYPE_OPERATOR_4, BarringInfo::SERVICE_TYPE_OPERATOR_5,
1511 BarringInfo::SERVICE_TYPE_OPERATOR_6, BarringInfo::SERVICE_TYPE_OPERATOR_7,
1512 BarringInfo::SERVICE_TYPE_OPERATOR_8, BarringInfo::SERVICE_TYPE_OPERATOR_9,
1513 BarringInfo::SERVICE_TYPE_OPERATOR_10, BarringInfo::SERVICE_TYPE_OPERATOR_11,
1514 BarringInfo::SERVICE_TYPE_OPERATOR_12, BarringInfo::SERVICE_TYPE_OPERATOR_13,
1515 BarringInfo::SERVICE_TYPE_OPERATOR_14, BarringInfo::SERVICE_TYPE_OPERATOR_15,
1516 BarringInfo::SERVICE_TYPE_OPERATOR_16, BarringInfo::SERVICE_TYPE_OPERATOR_17,
1517 BarringInfo::SERVICE_TYPE_OPERATOR_18, BarringInfo::SERVICE_TYPE_OPERATOR_19,
1518 BarringInfo::SERVICE_TYPE_OPERATOR_20, BarringInfo::SERVICE_TYPE_OPERATOR_21,
1519 BarringInfo::SERVICE_TYPE_OPERATOR_22, BarringInfo::SERVICE_TYPE_OPERATOR_23,
1520 BarringInfo::SERVICE_TYPE_OPERATOR_24, BarringInfo::SERVICE_TYPE_OPERATOR_25,
1521 BarringInfo::SERVICE_TYPE_OPERATOR_26, BarringInfo::SERVICE_TYPE_OPERATOR_27,
1522 BarringInfo::SERVICE_TYPE_OPERATOR_28, BarringInfo::SERVICE_TYPE_OPERATOR_29,
1523 BarringInfo::SERVICE_TYPE_OPERATOR_30, BarringInfo::SERVICE_TYPE_OPERATOR_31,
1524 };
1525
1526 const std::set<int>* compareTo = nullptr;
1527
1528 switch (radioRsp_network->barringCellIdentity.getTag()) {
1529 case CellIdentity::Tag::wcdma:
1530 // fall through
1531 case CellIdentity::Tag::tdscdma:
1532 compareTo = &UTRA_SERVICES;
1533 break;
1534 case CellIdentity::Tag::lte:
1535 compareTo = &EUTRA_SERVICES;
1536 break;
1537 case CellIdentity::Tag::nr:
1538 compareTo = &NGRA_SERVICES;
1539 break;
1540 case CellIdentity::Tag::cdma:
1541 // fall through
1542 default:
1543 FAIL();
1544 break;
1545 }
1546
1547 std::set<int> diff;
1548
1549 std::set_difference(reportedServices.begin(), reportedServices.end(), compareTo->begin(),
1550 compareTo->end(), std::inserter(diff, diff.begin()));
1551 }
1552
1553 /*
1554 * Test IRadioNetwork.getSignalStrength() for the response returned.
1555 */
TEST_P(RadioNetworkTest,getSignalStrength)1556 TEST_P(RadioNetworkTest, getSignalStrength) {
1557 if (telephony_flags::enforce_telephony_feature_mapping()) {
1558 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1559 GTEST_SKIP() << "Skipping getSignalStrength "
1560 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1561 }
1562 }
1563
1564 serial = GetRandomSerialNumber();
1565
1566 radio_network->getSignalStrength(serial);
1567 EXPECT_EQ(std::cv_status::no_timeout, wait());
1568 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1569 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1570
1571 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1572 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
1573 } else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
1574 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1575 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
1576 }
1577 }
1578
1579 /*
1580 * Test IRadioNetwork.getCellInfoList() for the response returned.
1581 */
TEST_P(RadioNetworkTest,getCellInfoList)1582 TEST_P(RadioNetworkTest, getCellInfoList) {
1583 if (telephony_flags::enforce_telephony_feature_mapping()) {
1584 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1585 GTEST_SKIP() << "Skipping getCellInfoList "
1586 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1587 }
1588 }
1589
1590 serial = GetRandomSerialNumber();
1591
1592 ndk::ScopedAStatus res = radio_network->getCellInfoList(serial);
1593 ASSERT_OK(res);
1594 EXPECT_EQ(std::cv_status::no_timeout, wait());
1595 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1596 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1597
1598 ALOGI("getCellInfoList, rspInfo.error = %s\n",
1599 toString(radioRsp_network->rspInfo.error).c_str());
1600 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1601 {RadioError::NONE, RadioError::NO_NETWORK_FOUND}));
1602 }
1603
1604 /*
1605 * Test IRadioNetwork.getVoiceRegistrationState() for the response returned.
1606 */
TEST_P(RadioNetworkTest,getVoiceRegistrationState)1607 TEST_P(RadioNetworkTest, getVoiceRegistrationState) {
1608 if (telephony_flags::enforce_telephony_feature_mapping()) {
1609 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1610 GTEST_SKIP() << "Skipping getVoiceRegistrationState "
1611 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1612 }
1613 }
1614
1615 serial = GetRandomSerialNumber();
1616
1617 ndk::ScopedAStatus res = radio_network->getVoiceRegistrationState(serial);
1618 ASSERT_OK(res);
1619 EXPECT_EQ(std::cv_status::no_timeout, wait());
1620 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1621 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1622
1623 ALOGI("getVoiceRegistrationStateResponse, rspInfo.error = %s\n",
1624 toString(radioRsp_network->rspInfo.error).c_str());
1625 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1626 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
1627 }
1628
1629 /*
1630 * Test IRadioNetwork.getDataRegistrationState() for the response returned.
1631 */
TEST_P(RadioNetworkTest,getDataRegistrationState)1632 TEST_P(RadioNetworkTest, getDataRegistrationState) {
1633 if (telephony_flags::enforce_telephony_feature_mapping()) {
1634 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1635 GTEST_SKIP() << "Skipping getDataRegistrationState "
1636 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1637 }
1638 }
1639
1640 serial = GetRandomSerialNumber();
1641
1642 ndk::ScopedAStatus res = radio_network->getDataRegistrationState(serial);
1643 ASSERT_OK(res);
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 ALOGI("getDataRegistrationStateResponse, rspInfo.error = %s\n",
1649 toString(radioRsp_network->rspInfo.error).c_str());
1650 ASSERT_TRUE(CheckAnyOfErrors(
1651 radioRsp_network->rspInfo.error,
1652 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NOT_PROVISIONED}));
1653
1654 // Check the mcc [0, 999] and mnc [0, 999].
1655 std::string mcc;
1656 std::string mnc;
1657 bool checkMccMnc = true;
1658 CellIdentity cellIdentity = radioRsp_network->dataRegResp.cellIdentity;
1659 switch (cellIdentity.getTag()) {
1660 case CellIdentity::noinit: {
1661 checkMccMnc = false;
1662 break;
1663 }
1664 case CellIdentity::gsm: {
1665 CellIdentityGsm cig = cellIdentity.get<CellIdentity::gsm>();
1666 mcc = cig.mcc;
1667 mnc = cig.mnc;
1668 break;
1669 }
1670 case CellIdentity::wcdma: {
1671 CellIdentityWcdma ciw = cellIdentity.get<CellIdentity::wcdma>();
1672 mcc = ciw.mcc;
1673 mnc = ciw.mnc;
1674 break;
1675 }
1676 case CellIdentity::tdscdma: {
1677 CellIdentityTdscdma cit = cellIdentity.get<CellIdentity::tdscdma>();
1678 mcc = cit.mcc;
1679 mnc = cit.mnc;
1680 break;
1681 }
1682 case CellIdentity::cdma: {
1683 // CellIdentityCdma has no mcc/mnc
1684 CellIdentityCdma cic = cellIdentity.get<CellIdentity::cdma>();
1685 checkMccMnc = false;
1686 break;
1687 }
1688 case CellIdentity::lte: {
1689 CellIdentityLte cil = cellIdentity.get<CellIdentity::lte>();
1690 mcc = cil.mcc;
1691 mnc = cil.mnc;
1692 break;
1693 }
1694 case CellIdentity::nr: {
1695 CellIdentityNr cin = cellIdentity.get<CellIdentity::nr>();
1696 mcc = cin.mcc;
1697 mnc = cin.mnc;
1698 break;
1699 }
1700 }
1701
1702 // 32 bit system might return invalid mcc and mnc string "\xff\xff..."
1703 if (checkMccMnc) {
1704 int mccSize = mcc.size();
1705 EXPECT_TRUE(mccSize == 0 || mccSize == 3);
1706 if (mccSize > 0) {
1707 int mcc_int = stoi(mcc);
1708 EXPECT_TRUE(mcc_int >= 0 && mcc_int <= 999);
1709 }
1710
1711 int mncSize = mnc.size();
1712 EXPECT_TRUE(mncSize == 0 || mncSize == 2 || mncSize == 3);
1713 if (mncSize > 0) {
1714 int mnc_int = stoi(mnc);
1715 EXPECT_TRUE(mnc_int >= 0 && mnc_int <= 999);
1716 }
1717 }
1718
1719 // Check for access technology specific info
1720 AccessTechnologySpecificInfo info = radioRsp_network->dataRegResp.accessTechnologySpecificInfo;
1721 RadioTechnology rat = radioRsp_network->dataRegResp.rat;
1722
1723 // TODO: add logic for cdmaInfo
1724 if (rat == RadioTechnology::LTE) {
1725 ASSERT_EQ(info.getTag(), AccessTechnologySpecificInfo::eutranInfo);
1726 } else if (rat == RadioTechnology::NR) {
1727 ASSERT_TRUE(info.getTag() == AccessTechnologySpecificInfo::ngranNrVopsInfo);
1728 }
1729 }
1730
1731 /*
1732 * Test IRadioNetwork.getAvailableBandModes() for the response returned.
1733 */
TEST_P(RadioNetworkTest,getAvailableBandModes)1734 TEST_P(RadioNetworkTest, getAvailableBandModes) {
1735 if (telephony_flags::enforce_telephony_feature_mapping()) {
1736 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1737 GTEST_SKIP() << "Skipping getAvailableBandModes "
1738 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1739 }
1740 }
1741
1742 serial = GetRandomSerialNumber();
1743
1744 ndk::ScopedAStatus res = radio_network->getAvailableBandModes(serial);
1745 ASSERT_OK(res);
1746 EXPECT_EQ(std::cv_status::no_timeout, wait());
1747 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1748 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1749 ALOGI("getAvailableBandModes, rspInfo.error = %s\n",
1750 toString(radioRsp_network->rspInfo.error).c_str());
1751 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1752 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
1753 RadioError::MODEM_ERR, RadioError::INTERNAL_ERR,
1754 // If REQUEST_NOT_SUPPORTED is returned, then it should also be
1755 // returned for setBandMode().
1756 RadioError::REQUEST_NOT_SUPPORTED}));
1757 bool hasUnspecifiedBandMode = false;
1758 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
1759 for (const RadioBandMode& mode : radioRsp_network->radioBandModes) {
1760 // Automatic mode selection must be supported
1761 if (mode == RadioBandMode::BAND_MODE_UNSPECIFIED) hasUnspecifiedBandMode = true;
1762 }
1763 ASSERT_TRUE(hasUnspecifiedBandMode);
1764 }
1765 }
1766
1767 /*
1768 * Test IRadioNetwork.setIndicationFilter()
1769 */
TEST_P(RadioNetworkTest,setIndicationFilter)1770 TEST_P(RadioNetworkTest, setIndicationFilter) {
1771 if (telephony_flags::enforce_telephony_feature_mapping()) {
1772 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1773 GTEST_SKIP() << "Skipping setIndicationFilter "
1774 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1775 }
1776 }
1777
1778 serial = GetRandomSerialNumber();
1779
1780 ndk::ScopedAStatus res =
1781 radio_network->setIndicationFilter(serial, static_cast<int>(IndicationFilter::ALL));
1782 ASSERT_OK(res);
1783 EXPECT_EQ(std::cv_status::no_timeout, wait());
1784 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1785 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1786
1787 ALOGI("setIndicationFilter, rspInfo.error = %s\n",
1788 toString(radioRsp_network->rspInfo.error).c_str());
1789 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
1790 }
1791
1792 /*
1793 * Test IRadioNetwork.setBarringPassword() for the response returned.
1794 */
TEST_P(RadioNetworkTest,setBarringPassword)1795 TEST_P(RadioNetworkTest, setBarringPassword) {
1796 if (telephony_flags::enforce_telephony_feature_mapping()) {
1797 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1798 GTEST_SKIP() << "Skipping setBarringPassword "
1799 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1800 }
1801 }
1802
1803 serial = GetRandomSerialNumber();
1804 std::string facility = "";
1805 std::string oldPassword = "";
1806 std::string newPassword = "";
1807
1808 radio_network->setBarringPassword(serial, facility, oldPassword, newPassword);
1809
1810 EXPECT_EQ(std::cv_status::no_timeout, wait());
1811 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1812 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1813
1814 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1815 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1816 {RadioError::NONE, RadioError::FDN_CHECK_FAILURE,
1817 RadioError::INVALID_ARGUMENTS, RadioError::MODEM_ERR},
1818 CHECK_GENERAL_ERROR));
1819 }
1820 }
1821
1822 /*
1823 * Test IRadioNetwork.setSuppServiceNotifications() for the response returned.
1824 */
TEST_P(RadioNetworkTest,setSuppServiceNotifications)1825 TEST_P(RadioNetworkTest, setSuppServiceNotifications) {
1826 if (telephony_flags::enforce_telephony_feature_mapping()) {
1827 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CALLING)) {
1828 GTEST_SKIP() << "Skipping setSuppServiceNotifications "
1829 "due to undefined FEATURE_TELEPHONY_CALLING";
1830 }
1831 }
1832
1833 serial = GetRandomSerialNumber();
1834 bool enable = false;
1835
1836 radio_network->setSuppServiceNotifications(serial, enable);
1837
1838 EXPECT_EQ(std::cv_status::no_timeout, wait());
1839 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1840 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1841
1842 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1843 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1844 {RadioError::NONE, RadioError::SIM_ABSENT}));
1845 }
1846 }
1847
1848 /*
1849 * Test IRadioNetwork.getImsRegistrationState() for the response returned.
1850 */
TEST_P(RadioNetworkTest,getImsRegistrationState)1851 TEST_P(RadioNetworkTest, getImsRegistrationState) {
1852 if (telephony_flags::enforce_telephony_feature_mapping()) {
1853 if (!deviceSupportsFeature(FEATURE_TELEPHONY_IMS)) {
1854 GTEST_SKIP() << "Skipping getImsRegistrationState "
1855 "due to undefined FEATURE_TELEPHONY_IMS";
1856 }
1857 }
1858
1859 serial = GetRandomSerialNumber();
1860
1861 radio_network->getImsRegistrationState(serial);
1862
1863 EXPECT_EQ(std::cv_status::no_timeout, wait());
1864 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1865 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1866
1867 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1868 ASSERT_TRUE(CheckAnyOfErrors(
1869 radioRsp_network->rspInfo.error,
1870 {RadioError::NONE, RadioError::MODEM_ERR, RadioError::INVALID_MODEM_STATE},
1871 CHECK_GENERAL_ERROR));
1872 }
1873 }
1874
1875 /*
1876 * Test IRadioNetwork.getOperator() for the response returned.
1877 */
TEST_P(RadioNetworkTest,getOperator)1878 TEST_P(RadioNetworkTest, getOperator) {
1879 if (telephony_flags::enforce_telephony_feature_mapping()) {
1880 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1881 GTEST_SKIP() << "Skipping getOperator "
1882 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1883 }
1884 }
1885
1886 serial = GetRandomSerialNumber();
1887
1888 radio_network->getOperator(serial);
1889 EXPECT_EQ(std::cv_status::no_timeout, wait());
1890 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1891 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1892
1893 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1894 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
1895 }
1896 }
1897
1898 /*
1899 * Test IRadioNetwork.getNetworkSelectionMode() for the response returned.
1900 */
TEST_P(RadioNetworkTest,getNetworkSelectionMode)1901 TEST_P(RadioNetworkTest, getNetworkSelectionMode) {
1902 if (telephony_flags::enforce_telephony_feature_mapping()) {
1903 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1904 GTEST_SKIP() << "Skipping getNetworkSelectionMode "
1905 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1906 }
1907 }
1908
1909 serial = GetRandomSerialNumber();
1910
1911 radio_network->getNetworkSelectionMode(serial);
1912 EXPECT_EQ(std::cv_status::no_timeout, wait());
1913 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1914 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1915
1916 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1917 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
1918 }
1919 }
1920
1921 /*
1922 * Test IRadioNetwork.setNetworkSelectionModeAutomatic() for the response returned.
1923 */
TEST_P(RadioNetworkTest,setNetworkSelectionModeAutomatic)1924 TEST_P(RadioNetworkTest, setNetworkSelectionModeAutomatic) {
1925 if (telephony_flags::enforce_telephony_feature_mapping()) {
1926 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1927 GTEST_SKIP() << "Skipping setNetworkSelectionModeAutomatic "
1928 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1929 }
1930 }
1931
1932 serial = GetRandomSerialNumber();
1933
1934 radio_network->setNetworkSelectionModeAutomatic(serial);
1935 EXPECT_EQ(std::cv_status::no_timeout, wait());
1936 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1937 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1938
1939 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1940 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
1941 {RadioError::NONE, RadioError::ILLEGAL_SIM_OR_ME,
1942 RadioError::OPERATION_NOT_ALLOWED},
1943 CHECK_GENERAL_ERROR));
1944 }
1945 }
1946
1947 /*
1948 * Test IRadioNetwork.getAvailableNetworks() for the response returned.
1949 */
TEST_P(RadioNetworkTest,getAvailableNetworks)1950 TEST_P(RadioNetworkTest, getAvailableNetworks) {
1951 if (telephony_flags::enforce_telephony_feature_mapping()) {
1952 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1953 GTEST_SKIP() << "Skipping getAvailableNetworks "
1954 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1955 }
1956 }
1957
1958 serial = GetRandomSerialNumber();
1959
1960 radio_network->getAvailableNetworks(serial);
1961 EXPECT_EQ(std::cv_status::no_timeout, wait());
1962 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1963 ASSERT_TRUE(radioRsp_network->rspInfo.type == RadioResponseType::SOLICITED ||
1964 radioRsp_network->rspInfo.type == RadioResponseType::SOLICITED_ACK_EXP);
1965
1966 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1967 ASSERT_TRUE(CheckAnyOfErrors(
1968 radioRsp_network->rspInfo.error,
1969 {RadioError::NONE, RadioError::CANCELLED, RadioError::DEVICE_IN_USE,
1970 RadioError::MODEM_ERR, RadioError::OPERATION_NOT_ALLOWED},
1971 CHECK_GENERAL_ERROR));
1972 }
1973 }
1974
1975 /*
1976 * Test IRadioNetwork.setBandMode() for the response returned.
1977 */
TEST_P(RadioNetworkTest,setBandMode)1978 TEST_P(RadioNetworkTest, setBandMode) {
1979 if (telephony_flags::enforce_telephony_feature_mapping()) {
1980 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
1981 GTEST_SKIP() << "Skipping setBandMode "
1982 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
1983 }
1984 }
1985
1986 serial = GetRandomSerialNumber();
1987
1988 radio_network->setBandMode(serial, RadioBandMode::BAND_MODE_USA);
1989 EXPECT_EQ(std::cv_status::no_timeout, wait());
1990 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
1991 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
1992
1993 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
1994 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE},
1995 CHECK_GENERAL_ERROR));
1996 }
1997 }
1998
1999 /*
2000 * Test IRadioNetwork.setLocationUpdates() for the response returned.
2001 */
TEST_P(RadioNetworkTest,setLocationUpdates)2002 TEST_P(RadioNetworkTest, setLocationUpdates) {
2003 if (telephony_flags::enforce_telephony_feature_mapping()) {
2004 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2005 GTEST_SKIP() << "Skipping setLocationUpdates "
2006 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2007 }
2008 }
2009
2010 serial = GetRandomSerialNumber();
2011
2012 radio_network->setLocationUpdates(serial, true);
2013 EXPECT_EQ(std::cv_status::no_timeout, wait());
2014 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2015 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2016
2017 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
2018 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2019 {RadioError::NONE, RadioError::SIM_ABSENT}));
2020 }
2021 }
2022
2023 /*
2024 * Test IRadioNetwork.setCdmaRoamingPreference() for the response returned.
2025 */
TEST_P(RadioNetworkTest,setCdmaRoamingPreference)2026 TEST_P(RadioNetworkTest, setCdmaRoamingPreference) {
2027 if (telephony_flags::enforce_telephony_feature_mapping()) {
2028 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
2029 GTEST_SKIP() << "Skipping setCdmaRoamingPreference "
2030 "due to undefined FEATURE_TELEPHONY_CDMA";
2031 }
2032 }
2033
2034 serial = GetRandomSerialNumber();
2035
2036 radio_network->setCdmaRoamingPreference(serial, CdmaRoamingType::HOME_NETWORK);
2037 EXPECT_EQ(std::cv_status::no_timeout, wait());
2038 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2039 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2040
2041 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
2042 ASSERT_TRUE(CheckAnyOfErrors(
2043 radioRsp_network->rspInfo.error,
2044 {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::REQUEST_NOT_SUPPORTED}));
2045 }
2046 }
2047
2048 /*
2049 * Test IRadioNetwork.getCdmaRoamingPreference() for the response returned.
2050 */
TEST_P(RadioNetworkTest,getCdmaRoamingPreference)2051 TEST_P(RadioNetworkTest, getCdmaRoamingPreference) {
2052 if (telephony_flags::enforce_telephony_feature_mapping()) {
2053 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
2054 GTEST_SKIP() << "Skipping getCdmaRoamingPreference "
2055 "due to undefined FEATURE_TELEPHONY_CDMA";
2056 }
2057 }
2058
2059 serial = GetRandomSerialNumber();
2060
2061 radio_network->getCdmaRoamingPreference(serial);
2062 EXPECT_EQ(std::cv_status::no_timeout, wait());
2063 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2064 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2065
2066 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
2067 ASSERT_TRUE(
2068 CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2069 {RadioError::NONE, RadioError::SIM_ABSENT, RadioError::MODEM_ERR},
2070 CHECK_GENERAL_ERROR));
2071 }
2072 }
2073
2074 /*
2075 * Test IRadioNetwork.getVoiceRadioTechnology() for the response returned.
2076 */
TEST_P(RadioNetworkTest,getVoiceRadioTechnology)2077 TEST_P(RadioNetworkTest, getVoiceRadioTechnology) {
2078 if (telephony_flags::enforce_telephony_feature_mapping()) {
2079 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2080 GTEST_SKIP() << "Skipping getVoiceRadioTechnology "
2081 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2082 }
2083 }
2084
2085 serial = GetRandomSerialNumber();
2086
2087 radio_network->getVoiceRadioTechnology(serial);
2088 EXPECT_EQ(std::cv_status::no_timeout, wait());
2089 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2090 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2091
2092 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
2093 EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
2094 }
2095 }
2096
2097 /*
2098 * Test IRadioNetwork.setCellInfoListRate() for the response returned.
2099 */
TEST_P(RadioNetworkTest,setCellInfoListRate)2100 TEST_P(RadioNetworkTest, setCellInfoListRate) {
2101 if (telephony_flags::enforce_telephony_feature_mapping()) {
2102 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2103 GTEST_SKIP() << "Skipping setCellInfoListRate "
2104 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2105 }
2106 }
2107
2108 serial = GetRandomSerialNumber();
2109
2110 radio_network->setCellInfoListRate(serial, 10);
2111 EXPECT_EQ(std::cv_status::no_timeout, wait());
2112 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2113 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2114
2115 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
2116 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2117 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
2118 }
2119 }
2120
2121 /*
2122 * Test IRadioNetwork.supplyNetworkDepersonalization() for the response returned.
2123 */
TEST_P(RadioNetworkTest,supplyNetworkDepersonalization)2124 TEST_P(RadioNetworkTest, supplyNetworkDepersonalization) {
2125 if (telephony_flags::enforce_telephony_feature_mapping()) {
2126 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2127 GTEST_SKIP() << "Skipping supplyNetworkDepersonalization "
2128 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2129 }
2130 }
2131
2132 serial = GetRandomSerialNumber();
2133
2134 radio_network->supplyNetworkDepersonalization(serial, std::string("test"));
2135 EXPECT_EQ(std::cv_status::no_timeout, wait());
2136 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2137 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2138
2139 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
2140 ASSERT_TRUE(CheckAnyOfErrors(
2141 radioRsp_network->rspInfo.error,
2142 {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INTERNAL_ERR,
2143 RadioError::INVALID_SIM_STATE, RadioError::MODEM_ERR, RadioError::NO_MEMORY,
2144 RadioError::PASSWORD_INCORRECT, RadioError::SIM_ABSENT, RadioError::SYSTEM_ERR}));
2145 }
2146 }
2147
2148 /*
2149 * Test IRadioNetwork.setEmergencyMode() for the response returned.
2150 */
TEST_P(RadioNetworkTest,setEmergencyMode)2151 TEST_P(RadioNetworkTest, setEmergencyMode) {
2152 if (telephony_flags::enforce_telephony_feature_mapping()) {
2153 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2154 GTEST_SKIP() << "Skipping setEmergencyMode "
2155 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2156 }
2157 }
2158
2159 int32_t aidl_version;
2160 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2161 ASSERT_OK(aidl_status);
2162 if (aidl_version < 2) {
2163 ALOGI("Skipped the test since setEmergencyMode is not supported on version < 2.");
2164 GTEST_SKIP();
2165 }
2166
2167 serial = GetRandomSerialNumber();
2168
2169 radio_network->setEmergencyMode(serial, EmergencyMode::EMERGENCY_WWAN);
2170 EXPECT_EQ(std::cv_status::no_timeout, wait());
2171 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2172 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2173
2174 ASSERT_TRUE(CheckAnyOfErrors(
2175 radioRsp_network->rspInfo.error,
2176 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::RADIO_NOT_AVAILABLE,
2177 RadioError::MODEM_ERR, RadioError::INVALID_ARGUMENTS}));
2178
2179 // exit emergency mode for other tests
2180 serial = GetRandomSerialNumber();
2181 radio_network->exitEmergencyMode(serial);
2182
2183 EXPECT_EQ(std::cv_status::no_timeout, wait());
2184 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2185 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2186
2187 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2188 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,
2189 RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR}));
2190 }
2191
2192 /*
2193 * Test IRadioNetwork.triggerEmergencyNetworkScan() for the response returned.
2194 */
TEST_P(RadioNetworkTest,triggerEmergencyNetworkScan)2195 TEST_P(RadioNetworkTest, triggerEmergencyNetworkScan) {
2196 if (telephony_flags::enforce_telephony_feature_mapping()) {
2197 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2198 GTEST_SKIP() << "Skipping triggerEmergencyNetworkScan "
2199 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2200 }
2201 }
2202
2203 int32_t aidl_version;
2204 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2205 ASSERT_OK(aidl_status);
2206 if (aidl_version < 2) {
2207 ALOGI("Skipped the test since"
2208 " triggerEmergencyNetworkScan is not supported on version < 2.");
2209 GTEST_SKIP();
2210 }
2211
2212 serial = GetRandomSerialNumber();
2213
2214 radio_network->setEmergencyMode(serial, EmergencyMode::EMERGENCY_WWAN);
2215 EXPECT_EQ(std::cv_status::no_timeout, wait());
2216 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2217 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2218
2219 ASSERT_TRUE(CheckAnyOfErrors(
2220 radioRsp_network->rspInfo.error,
2221 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::RADIO_NOT_AVAILABLE,
2222 RadioError::MODEM_ERR, RadioError::INVALID_ARGUMENTS}));
2223
2224 serial = GetRandomSerialNumber();
2225
2226 EmergencyNetworkScanTrigger scanRequest;
2227 scanRequest.accessNetwork = {AccessNetwork::EUTRAN};
2228 scanRequest.scanType = EmergencyScanType::NO_PREFERENCE;
2229
2230 radio_network->triggerEmergencyNetworkScan(serial, scanRequest);
2231 EXPECT_EQ(std::cv_status::no_timeout, wait());
2232 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2233 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2234
2235 ASSERT_TRUE(CheckAnyOfErrors(
2236 radioRsp_network->rspInfo.error,
2237 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::RADIO_NOT_AVAILABLE,
2238 RadioError::MODEM_ERR, RadioError::INVALID_ARGUMENTS}));
2239
2240 // exit emergency mode for other tests
2241 serial = GetRandomSerialNumber();
2242
2243 radio_network->exitEmergencyMode(serial);
2244
2245 EXPECT_EQ(std::cv_status::no_timeout, wait());
2246 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2247 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2248
2249 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2250 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,
2251 RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR}));
2252 }
2253
2254 /*
2255 * Test IRadioNetwork.cancelEmergencyNetworkScan() for the response returned.
2256 */
TEST_P(RadioNetworkTest,cancelEmergencyNetworkScan)2257 TEST_P(RadioNetworkTest, cancelEmergencyNetworkScan) {
2258 if (telephony_flags::enforce_telephony_feature_mapping()) {
2259 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2260 GTEST_SKIP() << "Skipping cancelEmergencyNetworkScan "
2261 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2262 }
2263 }
2264
2265 int32_t aidl_version;
2266 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2267 ASSERT_OK(aidl_status);
2268 if (aidl_version < 2) {
2269 ALOGI("Skipped the test since cancelEmergencyNetworkScan is not supported on version < 2.");
2270 GTEST_SKIP();
2271 }
2272
2273 serial = GetRandomSerialNumber();
2274
2275 radio_network->cancelEmergencyNetworkScan(serial, true);
2276 EXPECT_EQ(std::cv_status::no_timeout, wait());
2277 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2278 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2279
2280 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2281 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,
2282 RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR}));
2283 }
2284
2285 /*
2286 * Test IRadioNetwork.exitEmergencyMode() for the response returned.
2287 */
TEST_P(RadioNetworkTest,exitEmergencyMode)2288 TEST_P(RadioNetworkTest, exitEmergencyMode) {
2289 if (telephony_flags::enforce_telephony_feature_mapping()) {
2290 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2291 GTEST_SKIP() << "Skipping exitEmergencyMode "
2292 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2293 }
2294 }
2295
2296 int32_t aidl_version;
2297 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2298 ASSERT_OK(aidl_status);
2299 if (aidl_version < 2) {
2300 ALOGI("Skipped the test since exitEmergencyMode is not supported on version < 2.");
2301 GTEST_SKIP();
2302 }
2303
2304 serial = GetRandomSerialNumber();
2305
2306 radio_network->exitEmergencyMode(serial);
2307 EXPECT_EQ(std::cv_status::no_timeout, wait());
2308 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2309 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2310
2311 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2312 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,
2313 RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR}));
2314 }
2315
2316 /*
2317 * Test IRadioNetwork.setN1ModeEnabled() for the response returned.
2318 */
TEST_P(RadioNetworkTest,setN1ModeEnabled)2319 TEST_P(RadioNetworkTest, setN1ModeEnabled) {
2320 if (telephony_flags::enforce_telephony_feature_mapping()) {
2321 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2322 GTEST_SKIP() << "Skipping setN1ModeEnabled "
2323 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2324 }
2325 }
2326
2327 int32_t aidl_version;
2328 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2329 ASSERT_OK(aidl_status);
2330 if (aidl_version < 2) {
2331 ALOGI("Skipped the test since setN1ModeEnabled is not supported on version < 2.");
2332 GTEST_SKIP();
2333 }
2334
2335 serial = GetRandomSerialNumber();
2336
2337 ndk::ScopedAStatus res =
2338 radio_network->setN1ModeEnabled(serial, false);
2339 ASSERT_OK(res);
2340
2341 EXPECT_EQ(std::cv_status::no_timeout, wait());
2342 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2343 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2344 if (getRadioHalCapabilities()) {
2345 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2346 {RadioError::REQUEST_NOT_SUPPORTED}));
2347 } else {
2348 ASSERT_TRUE(CheckAnyOfErrors(
2349 radioRsp_network->rspInfo.error,
2350 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
2351 RadioError::INVALID_STATE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::NONE}));
2352 }
2353 }
2354
2355 /*
2356 * Test IRadioNetwork.isN1ModeEnabled() for the response returned.
2357 */
TEST_P(RadioNetworkTest,isN1ModeEnabled)2358 TEST_P(RadioNetworkTest, isN1ModeEnabled) {
2359 if (telephony_flags::enforce_telephony_feature_mapping()) {
2360 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2361 GTEST_SKIP() << "Skipping isN1ModeEnabled "
2362 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2363 }
2364 }
2365
2366 int32_t aidl_version;
2367 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2368 ASSERT_OK(aidl_status);
2369 if (aidl_version < 2) {
2370 ALOGI("Skipped the test since isN1ModeEnabled is not supported on version < 2.");
2371 GTEST_SKIP();
2372 }
2373
2374 serial = GetRandomSerialNumber();
2375
2376 ndk::ScopedAStatus res = radio_network->isN1ModeEnabled(serial);
2377 ASSERT_OK(res);
2378
2379 EXPECT_EQ(std::cv_status::no_timeout, wait());
2380 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2381 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2382 if (getRadioHalCapabilities()) {
2383 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2384 {RadioError::REQUEST_NOT_SUPPORTED}));
2385 } else {
2386 ASSERT_TRUE(CheckAnyOfErrors(
2387 radioRsp_network->rspInfo.error,
2388 {RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
2389 RadioError::REQUEST_NOT_SUPPORTED, RadioError::NONE}));
2390 }
2391 }
2392
2393 /*
2394 * Test IRadioNetwork.setNullCipherAndIntegrityEnabled() for the response returned.
2395 */
TEST_P(RadioNetworkTest,setNullCipherAndIntegrityEnabled)2396 TEST_P(RadioNetworkTest, setNullCipherAndIntegrityEnabled) {
2397 if (telephony_flags::enforce_telephony_feature_mapping()) {
2398 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2399 GTEST_SKIP() << "Skipping setNullCipherAndIntegrityEnabled "
2400 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2401 }
2402 }
2403
2404 int32_t aidl_version;
2405 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2406 ASSERT_OK(aidl_status);
2407 if (aidl_version < 2) {
2408 ALOGI("Skipped the test since"
2409 " setNullCipherAndIntegrityEnabled is not supported on version < 2.");
2410 GTEST_SKIP();
2411 }
2412
2413 serial = GetRandomSerialNumber();
2414
2415 radio_network->setNullCipherAndIntegrityEnabled(serial, false);
2416 EXPECT_EQ(std::cv_status::no_timeout, wait());
2417 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2418 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2419
2420 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2421 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2422 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2423 }
2424
2425 /**
2426 * Test IRadioNetwork.isNullCipherAndIntegrityEnabled() for the response returned.
2427 */
TEST_P(RadioNetworkTest,isNullCipherAndIntegrityEnabled)2428 TEST_P(RadioNetworkTest, isNullCipherAndIntegrityEnabled) {
2429 if (telephony_flags::enforce_telephony_feature_mapping()) {
2430 if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
2431 GTEST_SKIP() << "Skipping isNullCipherAndIntegrityEnabled "
2432 "due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
2433 }
2434 }
2435
2436 int32_t aidl_version;
2437 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2438 ASSERT_OK(aidl_status);
2439 if (aidl_version < 2) {
2440 ALOGI("Skipped the test since"
2441 " isNullCipherAndIntegrityEnabled is not supported on version < 2.");
2442 GTEST_SKIP();
2443 }
2444
2445 serial = GetRandomSerialNumber();
2446
2447 ndk::ScopedAStatus res = radio_network->isNullCipherAndIntegrityEnabled(serial);
2448 ASSERT_OK(res);
2449
2450 EXPECT_EQ(std::cv_status::no_timeout, wait());
2451 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2452 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2453
2454 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2455 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2456 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2457 }
2458
TEST_P(RadioNetworkTest,isCellularIdentifierTransparencyEnabled)2459 TEST_P(RadioNetworkTest, isCellularIdentifierTransparencyEnabled) {
2460 int32_t aidl_version;
2461 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2462 ASSERT_OK(aidl_status);
2463 if (aidl_version < 3) {
2464 ALOGI("Skipped the test since"
2465 " isCellularIdentifierTransparencyEnabled is not supported on version < 3.");
2466 GTEST_SKIP();
2467 }
2468
2469 serial = GetRandomSerialNumber();
2470
2471 ndk::ScopedAStatus res = radio_network->isCellularIdentifierTransparencyEnabled(serial);
2472 ASSERT_OK(res);
2473
2474 EXPECT_EQ(std::cv_status::no_timeout, wait());
2475 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2476 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2477
2478 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2479 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2480 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2481 }
2482
TEST_P(RadioNetworkTest,setCellularIdentifierTransparencyEnabled)2483 TEST_P(RadioNetworkTest, setCellularIdentifierTransparencyEnabled) {
2484 int32_t aidl_version;
2485 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2486 ASSERT_OK(aidl_status);
2487 if (aidl_version < 3) {
2488 ALOGI("Skipped the test since"
2489 " setCellularIdentifierTransparencyEnabled is not supported on version < 3.");
2490 GTEST_SKIP();
2491 }
2492
2493 // Get current value
2494 serial = GetRandomSerialNumber();
2495 radio_network->isCellularIdentifierTransparencyEnabled(serial);
2496 EXPECT_EQ(std::cv_status::no_timeout, wait());
2497 bool originalTransparencySetting = radioRsp_network->isCellularIdentifierTransparencyEnabled;
2498
2499 // We want to test flipping the value, so we are going to set it to the opposite of what
2500 // the existing setting is. The test for isCellularIdentifierTransparencyEnabled should check
2501 // for the right default value.
2502 bool valueToSet = !originalTransparencySetting;
2503 serial = GetRandomSerialNumber();
2504 radio_network->setCellularIdentifierTransparencyEnabled(serial, valueToSet);
2505 EXPECT_EQ(std::cv_status::no_timeout, wait());
2506 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2507 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2508
2509 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2510 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2511 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2512
2513 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
2514 // Assert the value has changed
2515 serial = GetRandomSerialNumber();
2516 ndk::ScopedAStatus res = radio_network->isCellularIdentifierTransparencyEnabled(serial);
2517
2518 ASSERT_OK(res);
2519 EXPECT_EQ(std::cv_status::no_timeout, wait());
2520 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2521 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2522 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2523 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2524 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2525 EXPECT_EQ(valueToSet, radioRsp_network->isCellularIdentifierTransparencyEnabled);
2526
2527 // Reset original state
2528 radio_network->setCellularIdentifierTransparencyEnabled(serial,
2529 originalTransparencySetting);
2530 EXPECT_EQ(std::cv_status::no_timeout, wait());
2531 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2532 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2533 }
2534 }
2535
2536 /*
2537 * Test IRadioNetwork.setSecurityAlgorithmsUpdatedEnabled for the response returned.
2538 */
TEST_P(RadioNetworkTest,setSecurityAlgorithmsUpdatedEnabled)2539 TEST_P(RadioNetworkTest, setSecurityAlgorithmsUpdatedEnabled) {
2540 int32_t aidl_version;
2541 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2542 ASSERT_OK(aidl_status);
2543 if (aidl_version < 3) {
2544 ALOGI("Skipped the test since"
2545 " setSecurityAlgorithmsUpdatedEnabled is not supported on version < 3");
2546 GTEST_SKIP();
2547 }
2548
2549 // Get current value
2550 serial = GetRandomSerialNumber();
2551 radio_network->isSecurityAlgorithmsUpdatedEnabled(serial);
2552 EXPECT_EQ(std::cv_status::no_timeout, wait());
2553 bool originalSecuritySetting = radioRsp_network->isSecurityAlgorithmsUpdatedEnabled;
2554
2555 // We want to test flipping the value, so we are going to set it to the opposite of what
2556 // the existing setting is. The test for isSecurityAlgorithmsUpdatedEnabled should check
2557 // for the right default value.
2558 bool valueToSet = !originalSecuritySetting;
2559 serial = GetRandomSerialNumber();
2560 radio_network->setSecurityAlgorithmsUpdatedEnabled(serial, valueToSet);
2561 EXPECT_EQ(std::cv_status::no_timeout, wait());
2562 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2563 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2564
2565 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2566 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2567 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2568
2569 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
2570 // Assert the value has changed
2571 serial = GetRandomSerialNumber();
2572 ndk::ScopedAStatus res = radio_network->isSecurityAlgorithmsUpdatedEnabled(serial);
2573
2574 ASSERT_OK(res);
2575 EXPECT_EQ(std::cv_status::no_timeout, wait());
2576 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2577 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2578 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2579 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2580 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2581 EXPECT_EQ(valueToSet, radioRsp_network->isSecurityAlgorithmsUpdatedEnabled);
2582
2583 // Reset original state
2584 radio_network->setSecurityAlgorithmsUpdatedEnabled(serial, originalSecuritySetting);
2585 EXPECT_EQ(std::cv_status::no_timeout, wait());
2586 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2587 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2588 }
2589 }
2590
2591 /**
2592 * Test IRadioNetwork.isSecurityAlgorithmsUpdatedEnabled for the response returned.
2593 */
TEST_P(RadioNetworkTest,isSecurityAlgorithmsUpdatedEnabled)2594 TEST_P(RadioNetworkTest, isSecurityAlgorithmsUpdatedEnabled) {
2595 int32_t aidl_version;
2596 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2597 ASSERT_OK(aidl_status);
2598 if (aidl_version < 3) {
2599 ALOGI("Skipped the test since"
2600 " isSecurityAlgorithmsUpdatedEnabled is not supported on version < 3");
2601 GTEST_SKIP();
2602 }
2603
2604 serial = GetRandomSerialNumber();
2605
2606 ndk::ScopedAStatus res = radio_network->isSecurityAlgorithmsUpdatedEnabled(serial);
2607 ASSERT_OK(res);
2608
2609 EXPECT_EQ(std::cv_status::no_timeout, wait());
2610 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2611 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2612
2613 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2614 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2615 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2616 }
2617
2618 /*
2619 * Test IRadioNetwork.setSatellitePlmn for the response returned.
2620 */
TEST_P(RadioNetworkTest,setSatellitePlmn)2621 TEST_P(RadioNetworkTest, setSatellitePlmn) {
2622 int32_t aidl_version;
2623 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2624 ASSERT_OK(aidl_status);
2625 if (aidl_version < 4) {
2626 ALOGI("Skipped the test since"
2627 " setSatellitePlmn is not supported on version < 4");
2628 GTEST_SKIP();
2629 }
2630
2631 serial = GetRandomSerialNumber();
2632 radio_network->setSatellitePlmn(serial, 0, {"123456"}, {"123456, 3456789"});
2633 EXPECT_EQ(std::cv_status::no_timeout, wait());
2634 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2635 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2636
2637 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2638 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2639 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2640 }
2641
2642 /*
2643 * Test IRadioNetwork.setSatelliteEnabledForCarrier for the response returned.
2644 */
TEST_P(RadioNetworkTest,setSatelliteEnabledForCarrier)2645 TEST_P(RadioNetworkTest, setSatelliteEnabledForCarrier) {
2646 int32_t aidl_version;
2647 ndk::ScopedAStatus aidl_status = radio_network->getInterfaceVersion(&aidl_version);
2648 ASSERT_OK(aidl_status);
2649 if (aidl_version < 4) {
2650 ALOGI("Skipped the test since"
2651 " setSatelliteEnabledForCarrier is not supported on version < 4");
2652 GTEST_SKIP();
2653 }
2654
2655 // Get current value
2656 serial = GetRandomSerialNumber();
2657 radio_network->isSatelliteEnabledForCarrier(serial, 0);
2658 EXPECT_EQ(std::cv_status::no_timeout, wait());
2659 bool originalSatelliteEnabledSetting = radioRsp_network->isSatelliteEnabledForCarrier;
2660
2661 // We want to test flipping the value, so we are going to set it to the opposite of what
2662 // the existing setting is. The test for isSatelliteEnabledForCarrier should check
2663 // for the right default value.
2664 bool valueToSet = !originalSatelliteEnabledSetting;
2665 serial = GetRandomSerialNumber();
2666 radio_network->setSatelliteEnabledForCarrier(serial, 0, valueToSet);
2667 EXPECT_EQ(std::cv_status::no_timeout, wait());
2668 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2669 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2670
2671 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2672 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2673 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2674
2675 if (radioRsp_network->rspInfo.error == RadioError::NONE) {
2676 // Assert the value has changed
2677 serial = GetRandomSerialNumber();
2678 ndk::ScopedAStatus res = radio_network->isSatelliteEnabledForCarrier(serial, 0);
2679
2680 ASSERT_OK(res);
2681 EXPECT_EQ(std::cv_status::no_timeout, wait());
2682 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2683 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2684 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
2685 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
2686 RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
2687 EXPECT_EQ(valueToSet, radioRsp_network->isSatelliteEnabledForCarrier);
2688
2689 // Reset original state
2690 radio_network->setSatelliteEnabledForCarrier(serial, 0, originalSatelliteEnabledSetting);
2691 EXPECT_EQ(std::cv_status::no_timeout, wait());
2692 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
2693 EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
2694 }
2695 }
2696