mirror of
https://github.com/Evolution-X/hardware_interfaces
synced 2026-02-05 01:41:12 +00:00
374bec341f
The final step of the RadioNewtorkTest#setUsageSetting is to restore the original value to the modem in case it was changed. After doing that, the locally cached value in the VTS layer needs to be updated before comparing it with the originally queried value to ensure that the modem was restored to its initial state. Bug: 211819471 Test: m VtsHalRadioTargetTest Change-Id: Ibdd584d91b16bb779a0cefa2f45d2704cdcf7288
1737 lines
76 KiB
C++
1737 lines
76 KiB
C++
/*
|
|
* Copyright (C) 2021 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <aidl/android/hardware/radio/RadioAccessFamily.h>
|
|
#include <aidl/android/hardware/radio/config/IRadioConfig.h>
|
|
#include <aidl/android/hardware/radio/network/IndicationFilter.h>
|
|
#include <android-base/logging.h>
|
|
#include <android/binder_manager.h>
|
|
|
|
#include "radio_network_utils.h"
|
|
|
|
#define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
|
|
|
|
void RadioNetworkTest::SetUp() {
|
|
std::string serviceName = GetParam();
|
|
|
|
if (!isServiceValidForDeviceConfiguration(serviceName)) {
|
|
ALOGI("Skipped the test due to device configuration.");
|
|
GTEST_SKIP();
|
|
}
|
|
|
|
radio_network = IRadioNetwork::fromBinder(
|
|
ndk::SpAIBinder(AServiceManager_waitForService(GetParam().c_str())));
|
|
ASSERT_NE(nullptr, radio_network.get());
|
|
|
|
radioRsp_network = ndk::SharedRefBase::make<RadioNetworkResponse>(*this);
|
|
ASSERT_NE(nullptr, radioRsp_network.get());
|
|
|
|
count_ = 0;
|
|
|
|
radioInd_network = ndk::SharedRefBase::make<RadioNetworkIndication>(*this);
|
|
ASSERT_NE(nullptr, radioInd_network.get());
|
|
|
|
radio_network->setResponseFunctions(radioRsp_network, radioInd_network);
|
|
|
|
// Assert IRadioSim exists and SIM is present before testing
|
|
radio_sim = sim::IRadioSim::fromBinder(ndk::SpAIBinder(
|
|
AServiceManager_waitForService("android.hardware.radio.sim.IRadioSim/slot1")));
|
|
ASSERT_NE(nullptr, radio_sim.get());
|
|
updateSimCardStatus();
|
|
EXPECT_EQ(CardStatus::STATE_PRESENT, cardStatus.cardState);
|
|
|
|
// Assert IRadioConfig exists before testing
|
|
radio_config = config::IRadioConfig::fromBinder(ndk::SpAIBinder(
|
|
AServiceManager_waitForService("android.hardware.radio.config.IRadioConfig/default")));
|
|
ASSERT_NE(nullptr, radio_config.get());
|
|
}
|
|
|
|
void RadioNetworkTest::stopNetworkScan() {
|
|
serial = GetRandomSerialNumber();
|
|
radio_network->stopNetworkScan(serial);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setAllowedNetworkTypesBitmap for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setAllowedNetworkTypesBitmap) {
|
|
serial = GetRandomSerialNumber();
|
|
int32_t allowedNetworkTypesBitmap = static_cast<int32_t>(RadioAccessFamily::LTE);
|
|
|
|
radio_network->setAllowedNetworkTypesBitmap(serial, allowedNetworkTypesBitmap);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::OPERATION_NOT_ALLOWED,
|
|
RadioError::MODE_NOT_SUPPORTED, RadioError::INTERNAL_ERR, RadioError::MODEM_ERR,
|
|
RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED,
|
|
RadioError::NO_RESOURCES}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getAllowedNetworkTypesBitmap for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getAllowedNetworkTypesBitmap) {
|
|
serial = GetRandomSerialNumber();
|
|
int32_t allowedNetworkTypesBitmap = static_cast<int32_t>(RadioAccessFamily::LTE);
|
|
|
|
radio_network->setAllowedNetworkTypesBitmap(serial, allowedNetworkTypesBitmap);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (radioRsp_network->rspInfo.error == RadioError::NONE) {
|
|
sleep(3); // wait for modem
|
|
serial = GetRandomSerialNumber();
|
|
radio_network->getAllowedNetworkTypesBitmap(serial);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
|
|
RadioError::OPERATION_NOT_ALLOWED, RadioError::MODE_NOT_SUPPORTED,
|
|
RadioError::INVALID_ARGUMENTS, RadioError::MODEM_ERR,
|
|
RadioError::REQUEST_NOT_SUPPORTED, RadioError::NO_RESOURCES}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setNrDualConnectivityState() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setNrDualConnectivityState) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setNrDualConnectivityState(serial, NrDualConnectivityState::DISABLE);
|
|
ASSERT_OK(res);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
if (getRadioHalCapabilities()) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::REQUEST_NOT_SUPPORTED}));
|
|
} else {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR,
|
|
RadioError::INVALID_STATE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::NONE}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.isNrDualConnectivityEnabled() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, isNrDualConnectivityEnabled) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = radio_network->isNrDualConnectivityEnabled(serial);
|
|
ASSERT_OK(res);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
if (getRadioHalCapabilities()) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::REQUEST_NOT_SUPPORTED}));
|
|
} else {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR, RadioError::NONE}));
|
|
}
|
|
}
|
|
|
|
void RadioNetworkTest::invokeAndExpectResponse(
|
|
std::function<ndk::ScopedAStatus(int32_t serial)> request,
|
|
std::vector<RadioError> errors_to_check) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = request(serial);
|
|
ASSERT_OK(res);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, errors_to_check));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getUsageSetting()
|
|
*
|
|
* Verify that the usage setting can be retrieved.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getUsageSetting) {
|
|
invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
|
|
{RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_STATE,
|
|
RadioError::SIM_ABSENT, RadioError::INTERNAL_ERR, RadioError::NONE});
|
|
|
|
ASSERT_TRUE(radioRsp_network->usageSetting == UsageSetting::VOICE_CENTRIC ||
|
|
radioRsp_network->usageSetting == UsageSetting::DATA_CENTRIC);
|
|
}
|
|
|
|
void RadioNetworkTest::testSetUsageSetting_InvalidValues(std::vector<RadioError> errors) {
|
|
invokeAndExpectResponse(
|
|
[&](int serial) {
|
|
return radio_network->setUsageSetting(serial,
|
|
UsageSetting(0) /*below valid range*/);
|
|
},
|
|
errors);
|
|
invokeAndExpectResponse(
|
|
[&](int serial) {
|
|
return radio_network->setUsageSetting(serial, UsageSetting(-1) /*negative*/);
|
|
},
|
|
errors);
|
|
invokeAndExpectResponse(
|
|
[&](int serial) {
|
|
return radio_network->setUsageSetting(serial,
|
|
UsageSetting(3) /*above valid range*/);
|
|
},
|
|
errors);
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setUsageSetting() and IRadioNetwork.getUsageSetting()
|
|
*
|
|
* Verify the following:
|
|
* -That the usage setting can be retrieved.
|
|
* -That the usage setting can be successfully set to allowed values.
|
|
* -That the usage setting cannot be set to invalid values.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setUsageSetting) {
|
|
invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
|
|
{RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_STATE,
|
|
RadioError::SIM_ABSENT, RadioError::INTERNAL_ERR, RadioError::NONE});
|
|
|
|
if (radioRsp_network->rspInfo.error != RadioError::NONE) {
|
|
// Test only for invalid values, with the only allowable response being the same error
|
|
// that was previously provided, or an error indicating invalid arguments.
|
|
testSetUsageSetting_InvalidValues(
|
|
{radioRsp_network->rspInfo.error, RadioError::INVALID_ARGUMENTS});
|
|
// It is unsafe to proceed with setting valid values without knowing the starting value, but
|
|
// we expect errors anyway, so not necessary.
|
|
return;
|
|
} else {
|
|
// Because querying succeeded, the device is in a valid state to test for invalid values
|
|
// and the only thing that can change is that we expect to have an EINVAL return each time.
|
|
testSetUsageSetting_InvalidValues({RadioError::INVALID_ARGUMENTS});
|
|
}
|
|
|
|
// Store the original setting value to reset later.
|
|
const UsageSetting originalSetting = radioRsp_network->usageSetting;
|
|
|
|
// Choose the "other" value that is not the current value for test.
|
|
const UsageSetting testSetting = radioRsp_network->usageSetting == UsageSetting::VOICE_CENTRIC
|
|
? UsageSetting::DATA_CENTRIC
|
|
: UsageSetting::VOICE_CENTRIC;
|
|
|
|
// Set an alternative setting; it may either succeed or be disallowed as out of range for
|
|
// the current device (if the device only supports its current mode).
|
|
invokeAndExpectResponse(
|
|
[&](int serial) { return radio_network->setUsageSetting(serial, testSetting); },
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::NONE});
|
|
|
|
// If there was no error, then we expect the test setting to be set, or if there is an error
|
|
// we expect the original setting to be maintained.
|
|
const UsageSetting expectedSetting =
|
|
radioRsp_network->rspInfo.error == RadioError::NONE ? testSetting : originalSetting;
|
|
invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
|
|
{RadioError::NONE});
|
|
|
|
const UsageSetting updatedSetting = radioRsp_network->usageSetting;
|
|
|
|
// Re-set the original setting, which must always succeed.
|
|
invokeAndExpectResponse(
|
|
[&](int serial) { return radio_network->setUsageSetting(serial, originalSetting); },
|
|
{RadioError::NONE});
|
|
|
|
// After resetting the value to its original value, update the local cache, which must
|
|
// always succeed.
|
|
invokeAndExpectResponse([&](int serial) { return radio_network->getUsageSetting(serial); },
|
|
{RadioError::NONE});
|
|
|
|
// Check that indeed the updated setting was set. We do this after resetting to original
|
|
// conditions to avoid early-exiting the test and leaving the device in a modified state.
|
|
EXPECT_EQ(expectedSetting, updatedSetting);
|
|
// Check that indeed the original setting was reset.
|
|
EXPECT_EQ(originalSetting, radioRsp_network->usageSetting);
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() with invalid hysteresisDb
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_invalidHysteresisDb) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 10; // hysteresisDb too large given threshold list deltas
|
|
signalThresholdInfo.thresholds = {-109, -103, -97, -89};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::GERAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_invalidHysteresisDb, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() with empty thresholds
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_EmptyThresholds) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
|
|
signalThresholdInfo.hysteresisMs = 0;
|
|
signalThresholdInfo.hysteresisDb = 0;
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::GERAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_EmptyParams, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for GERAN
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Geran) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 2;
|
|
signalThresholdInfo.thresholds = {-109, -103, -97, -89};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::GERAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_Geran, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for UTRAN
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Utran) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSCP;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 2;
|
|
signalThresholdInfo.thresholds = {-110, -97, -73, -49, -25};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::UTRAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_Utran, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSRP) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSRP;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 2;
|
|
signalThresholdInfo.thresholds = {-128, -108, -88, -68};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::EUTRAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSRQ) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSRQ;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 2;
|
|
signalThresholdInfo.thresholds = {-27, -20, -13, -6};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::EUTRAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSSNR) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSNR;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 2;
|
|
signalThresholdInfo.thresholds = {-10, 0, 10, 20};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::EUTRAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for CDMA2000
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Cdma2000) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 2;
|
|
signalThresholdInfo.thresholds = {-105, -90, -75, -65};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::CDMA2000;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_Cdma2000, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSRSRP
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_NGRAN_SSRSRP) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRP;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 0;
|
|
signalThresholdInfo.thresholds = {-105, -90, -75, -65};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::NGRAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_NGRAN_SSRSRP, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
|
|
// Allow REQUEST_NOT_SUPPORTED because some non-5G device may not support NGRAN for
|
|
// setSignalStrengthReportingCriteria()
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSRSRQ
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_NGRAN_SSRSRQ) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRQ;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 0;
|
|
signalThresholdInfo.thresholds = {-43, -20, 0, 20};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::NGRAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_NGRAN_SSRSRQ, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
|
|
// Allow REQUEST_NOT_SUPPORTED because some non-5G device may not support NGRAN for
|
|
// setSignalStrengthReportingCriteria()
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for EUTRAN
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Disable_RSSNR) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSNR;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 2;
|
|
signalThresholdInfo.thresholds = {-10, 0, 10, 20};
|
|
signalThresholdInfo.isEnabled = false;
|
|
signalThresholdInfo.ran = AccessNetwork::EUTRAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSignalStrengthReportingCriteria() for NGRAN_SSSINR
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_NGRAN_SSSINR) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
SignalThresholdInfo signalThresholdInfo;
|
|
signalThresholdInfo.signalMeasurement = SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSSINR;
|
|
signalThresholdInfo.hysteresisMs = 5000;
|
|
signalThresholdInfo.hysteresisDb = 0;
|
|
signalThresholdInfo.thresholds = {-10, 3, 16, 18};
|
|
signalThresholdInfo.isEnabled = true;
|
|
signalThresholdInfo.ran = AccessNetwork::NGRAN;
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSignalStrengthReportingCriteria(serial, {signalThresholdInfo});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_NGRAN_SSSINR, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
|
|
// Allow REQUEST_NOT_SUPPORTED because some non-5G device may not support NGRAN for
|
|
// setSignalStrengthReportingCriteria()
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setLinkCapacityReportingCriteria() invalid hysteresisDlKbps
|
|
*/
|
|
TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_invalidHysteresisDlKbps) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
|
|
serial, 5000,
|
|
5000, // hysteresisDlKbps too big for thresholds delta
|
|
100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000}, AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisDlKbps, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
// Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported
|
|
// for GERAN
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setLinkCapacityReportingCriteria() invalid hysteresisUlKbps
|
|
*/
|
|
TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_invalidHysteresisUlKbps) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
|
|
serial, 5000, 500, 1000, // hysteresisUlKbps too big for thresholds delta
|
|
{1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000}, AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
// Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported
|
|
// for GERAN
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setLinkCapacityReportingCriteria() empty params
|
|
*/
|
|
TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_emptyParams) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
|
|
serial, 0, 0, 0, {}, {}, AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setLinkCapacityReportingCriteria_emptyParams, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
// Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported
|
|
// for GERAN
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setLinkCapacityReportingCriteria() for GERAN
|
|
*/
|
|
TEST_P(RadioNetworkTest, setLinkCapacityReportingCriteria_Geran) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = radio_network->setLinkCapacityReportingCriteria(
|
|
serial, 5000, 500, 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
|
|
AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setLinkCapacityReportingCriteria_Geran, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
// Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported
|
|
// for GERAN
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSystemSelectionChannels() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSystemSelectionChannels) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setSystemSelectionChannels(serial, true, {specifierP900, specifier850});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("setSystemSelectionChannels, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR}));
|
|
|
|
if (radioRsp_network->rspInfo.error == RadioError::NONE) {
|
|
serial = GetRandomSerialNumber();
|
|
ndk::ScopedAStatus res = radio_network->setSystemSelectionChannels(
|
|
serial, false, {specifierP900, specifier850});
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("setSystemSelectionChannels, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {specifierP900, specifier850},
|
|
.maxSearchTime = 60,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 1};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::SIM_ABSENT}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
// OPERATION_NOT_ALLOWED should not be allowed; however, some vendors do
|
|
// not support the required manual GSM search functionality. This is
|
|
// tracked in b/112206766. Modems have "GSM" rat scan need to
|
|
// support scanning requests combined with some parameters.
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::OPERATION_NOT_ALLOWED}));
|
|
}
|
|
|
|
if (radioRsp_network->rspInfo.error == RadioError::NONE) {
|
|
ALOGI("Stop Network Scan");
|
|
stopNetworkScan();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() with invalid specifier.
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan_InvalidArgument) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT, .interval = 60};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() with invalid interval (lower boundary).
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan_InvalidInterval1) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
|
|
.interval = 4,
|
|
.specifiers = {specifierP900, specifier850},
|
|
.maxSearchTime = 60,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 1};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan_InvalidInterval1, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() with invalid interval (upper boundary).
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan_InvalidInterval2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
|
|
.interval = 301,
|
|
.specifiers = {specifierP900, specifier850},
|
|
.maxSearchTime = 60,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 1};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan_InvalidInterval2, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() with invalid max search time (lower boundary).
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan_InvalidMaxSearchTime1) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {specifierP900, specifier850},
|
|
.maxSearchTime = 59,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 1};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan_InvalidMaxSearchTime1, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() with invalid max search time (upper boundary).
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan_InvalidMaxSearchTime2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {specifierP900, specifier850},
|
|
.maxSearchTime = 3601,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 1};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan_InvalidMaxSearchTime2, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() with invalid periodicity (lower boundary).
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan_InvalidPeriodicity1) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {specifierP900, specifier850},
|
|
.maxSearchTime = 600,
|
|
.incrementalResults = true,
|
|
.incrementalResultsPeriodicity = 0};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan_InvalidPeriodicity1, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() with invalid periodicity (upper boundary).
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan_InvalidPeriodicity2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {specifierP900, specifier850},
|
|
.maxSearchTime = 600,
|
|
.incrementalResults = true,
|
|
.incrementalResultsPeriodicity = 11};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan_InvalidPeriodicity2, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() with valid periodicity
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan_GoodRequest1) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {specifierP900, specifier850},
|
|
.maxSearchTime = 360,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 10};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan_GoodRequest1, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::SIM_ABSENT}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::INVALID_ARGUMENTS,
|
|
RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
if (radioRsp_network->rspInfo.error == RadioError::NONE) {
|
|
ALOGI("Stop Network Scan");
|
|
stopNetworkScan();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.startNetworkScan() with valid periodicity and plmns
|
|
*/
|
|
TEST_P(RadioNetworkTest, startNetworkScan_GoodRequest2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
RadioAccessSpecifierBands bandP900 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_P900});
|
|
RadioAccessSpecifierBands band850 =
|
|
RadioAccessSpecifierBands::make<RadioAccessSpecifierBands::geranBands>(
|
|
{GeranBands::BAND_850});
|
|
RadioAccessSpecifier specifierP900 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = bandP900, .channels = {1, 2}};
|
|
RadioAccessSpecifier specifier850 = {
|
|
.accessNetwork = AccessNetwork::GERAN, .bands = band850, .channels = {128, 129}};
|
|
|
|
NetworkScanRequest request = {.type = NetworkScanRequest::SCAN_TYPE_ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {specifierP900, specifier850},
|
|
.maxSearchTime = 360,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 10,
|
|
.mccMncs = {"310410"}};
|
|
|
|
ndk::ScopedAStatus res = radio_network->startNetworkScan(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("startNetworkScan_GoodRequest2, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::SIM_ABSENT}));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::INVALID_ARGUMENTS,
|
|
RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
if (radioRsp_network->rspInfo.error == RadioError::NONE) {
|
|
ALOGI("Stop Network Scan");
|
|
stopNetworkScan();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setNetworkSelectionModeManual() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setNetworkSelectionModeManual) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
// can't camp on nonexistent MCCMNC, so we expect this to fail.
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setNetworkSelectionModeManual(serial, "123456", AccessNetwork::GERAN);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::ILLEGAL_SIM_OR_ME,
|
|
RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE},
|
|
CHECK_GENERAL_ERROR));
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
|
|
RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE},
|
|
CHECK_GENERAL_ERROR));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getBarringInfo() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getBarringInfo) {
|
|
serial = GetRandomSerialNumber();
|
|
ndk::ScopedAStatus res = radio_network->getBarringInfo(serial);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ASSERT_TRUE(radioRsp_network->barringInfoList.size() > 0);
|
|
|
|
std::set<int> reportedServices;
|
|
|
|
// validate that the service types are in range
|
|
for (const auto& info : radioRsp_network->barringInfoList) {
|
|
ASSERT_TRUE((info.serviceType >= BarringInfo::SERVICE_TYPE_CS_SERVICE &&
|
|
info.serviceType <= BarringInfo::SERVICE_TYPE_SMS) ||
|
|
(info.serviceType >= BarringInfo::SERVICE_TYPE_OPERATOR_1 &&
|
|
info.serviceType <= BarringInfo::SERVICE_TYPE_OPERATOR_32));
|
|
reportedServices.insert(info.serviceType);
|
|
|
|
// Any type that is "conditional" must have valid values for conditional barring
|
|
// factor and time.
|
|
switch (info.barringType) {
|
|
case BarringInfo::BARRING_TYPE_NONE: // fall through
|
|
case BarringInfo::BARRING_TYPE_UNCONDITIONAL:
|
|
break;
|
|
case BarringInfo::BARRING_TYPE_CONDITIONAL: {
|
|
const int32_t barringFactor = info.barringTypeSpecificInfo->factor;
|
|
ASSERT_TRUE(barringFactor >= 0 && barringFactor <= 100);
|
|
ASSERT_TRUE(info.barringTypeSpecificInfo->timeSeconds > 0);
|
|
break;
|
|
}
|
|
default:
|
|
FAIL();
|
|
}
|
|
}
|
|
|
|
// Certain types of barring are relevant for certain RANs. Ensure that only the right
|
|
// types are reported. Note that no types are required, simply that for a given technology
|
|
// only certain types are valid. This is one way to check that implementations are
|
|
// not providing information that they don't have.
|
|
static const std::set<int> UTRA_SERVICES{
|
|
BarringInfo::SERVICE_TYPE_CS_SERVICE, BarringInfo::SERVICE_TYPE_PS_SERVICE,
|
|
BarringInfo::SERVICE_TYPE_CS_VOICE, BarringInfo::SERVICE_TYPE_EMERGENCY,
|
|
BarringInfo::SERVICE_TYPE_SMS,
|
|
};
|
|
|
|
static const std::set<int> EUTRA_SERVICES{
|
|
BarringInfo::SERVICE_TYPE_MO_SIGNALLING, BarringInfo::SERVICE_TYPE_MO_DATA,
|
|
BarringInfo::SERVICE_TYPE_CS_FALLBACK, BarringInfo::SERVICE_TYPE_MMTEL_VOICE,
|
|
BarringInfo::SERVICE_TYPE_MMTEL_VIDEO, BarringInfo::SERVICE_TYPE_EMERGENCY,
|
|
BarringInfo::SERVICE_TYPE_SMS,
|
|
};
|
|
|
|
static const std::set<int> NGRA_SERVICES = {
|
|
BarringInfo::SERVICE_TYPE_MO_SIGNALLING, BarringInfo::SERVICE_TYPE_MO_DATA,
|
|
BarringInfo::SERVICE_TYPE_CS_FALLBACK, BarringInfo::SERVICE_TYPE_MMTEL_VOICE,
|
|
BarringInfo::SERVICE_TYPE_MMTEL_VIDEO, BarringInfo::SERVICE_TYPE_EMERGENCY,
|
|
BarringInfo::SERVICE_TYPE_SMS, BarringInfo::SERVICE_TYPE_OPERATOR_1,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_2, BarringInfo::SERVICE_TYPE_OPERATOR_3,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_4, BarringInfo::SERVICE_TYPE_OPERATOR_5,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_6, BarringInfo::SERVICE_TYPE_OPERATOR_7,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_8, BarringInfo::SERVICE_TYPE_OPERATOR_9,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_10, BarringInfo::SERVICE_TYPE_OPERATOR_11,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_12, BarringInfo::SERVICE_TYPE_OPERATOR_13,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_14, BarringInfo::SERVICE_TYPE_OPERATOR_15,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_16, BarringInfo::SERVICE_TYPE_OPERATOR_17,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_18, BarringInfo::SERVICE_TYPE_OPERATOR_19,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_20, BarringInfo::SERVICE_TYPE_OPERATOR_21,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_22, BarringInfo::SERVICE_TYPE_OPERATOR_23,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_24, BarringInfo::SERVICE_TYPE_OPERATOR_25,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_26, BarringInfo::SERVICE_TYPE_OPERATOR_27,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_28, BarringInfo::SERVICE_TYPE_OPERATOR_29,
|
|
BarringInfo::SERVICE_TYPE_OPERATOR_30, BarringInfo::SERVICE_TYPE_OPERATOR_31,
|
|
};
|
|
|
|
const std::set<int>* compareTo = nullptr;
|
|
|
|
switch (radioRsp_network->barringCellIdentity.getTag()) {
|
|
case CellIdentity::Tag::wcdma:
|
|
// fall through
|
|
case CellIdentity::Tag::tdscdma:
|
|
compareTo = &UTRA_SERVICES;
|
|
break;
|
|
case CellIdentity::Tag::lte:
|
|
compareTo = &EUTRA_SERVICES;
|
|
break;
|
|
case CellIdentity::Tag::nr:
|
|
compareTo = &NGRA_SERVICES;
|
|
break;
|
|
case CellIdentity::Tag::cdma:
|
|
// fall through
|
|
default:
|
|
FAIL();
|
|
break;
|
|
}
|
|
|
|
std::set<int> diff;
|
|
|
|
std::set_difference(reportedServices.begin(), reportedServices.end(), compareTo->begin(),
|
|
compareTo->end(), std::inserter(diff, diff.begin()));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getSignalStrength() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getSignalStrength) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->getSignalStrength(serial);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
|
|
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getCellInfoList() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getCellInfoList) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = radio_network->getCellInfoList(serial);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("getCellInfoList, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::NO_NETWORK_FOUND}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getVoiceRegistrationState() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getVoiceRegistrationState) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = radio_network->getVoiceRegistrationState(serial);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("getVoiceRegistrationStateResponse, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getDataRegistrationState() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getDataRegistrationState) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = radio_network->getDataRegistrationState(serial);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("getDataRegistrationStateResponse, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NOT_PROVISIONED}));
|
|
|
|
// Check the mcc [0, 999] and mnc [0, 999].
|
|
std::string mcc;
|
|
std::string mnc;
|
|
bool checkMccMnc = true;
|
|
CellIdentity cellIdentity = radioRsp_network->dataRegResp.cellIdentity;
|
|
switch (cellIdentity.getTag()) {
|
|
case CellIdentity::noinit: {
|
|
checkMccMnc = false;
|
|
break;
|
|
}
|
|
case CellIdentity::gsm: {
|
|
CellIdentityGsm cig = cellIdentity.get<CellIdentity::gsm>();
|
|
mcc = cig.mcc;
|
|
mnc = cig.mnc;
|
|
break;
|
|
}
|
|
case CellIdentity::wcdma: {
|
|
CellIdentityWcdma ciw = cellIdentity.get<CellIdentity::wcdma>();
|
|
mcc = ciw.mcc;
|
|
mnc = ciw.mnc;
|
|
break;
|
|
}
|
|
case CellIdentity::tdscdma: {
|
|
CellIdentityTdscdma cit = cellIdentity.get<CellIdentity::tdscdma>();
|
|
mcc = cit.mcc;
|
|
mnc = cit.mnc;
|
|
break;
|
|
}
|
|
case CellIdentity::cdma: {
|
|
// CellIdentityCdma has no mcc/mnc
|
|
CellIdentityCdma cic = cellIdentity.get<CellIdentity::cdma>();
|
|
checkMccMnc = false;
|
|
break;
|
|
}
|
|
case CellIdentity::lte: {
|
|
CellIdentityLte cil = cellIdentity.get<CellIdentity::lte>();
|
|
mcc = cil.mcc;
|
|
mnc = cil.mnc;
|
|
break;
|
|
}
|
|
case CellIdentity::nr: {
|
|
CellIdentityNr cin = cellIdentity.get<CellIdentity::nr>();
|
|
mcc = cin.mcc;
|
|
mnc = cin.mnc;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 32 bit system might return invalid mcc and mnc string "\xff\xff..."
|
|
if (checkMccMnc && mcc.size() < 4 && mnc.size() < 4) {
|
|
int mcc_int = stoi(mcc);
|
|
int mnc_int = stoi(mnc);
|
|
EXPECT_TRUE(mcc_int >= 0 && mcc_int <= 999);
|
|
EXPECT_TRUE(mnc_int >= 0 && mnc_int <= 999);
|
|
}
|
|
|
|
// Check for access technology specific info
|
|
AccessTechnologySpecificInfo info = radioRsp_network->dataRegResp.accessTechnologySpecificInfo;
|
|
RadioTechnology rat = radioRsp_network->dataRegResp.rat;
|
|
// TODO: add logic for cdmaInfo
|
|
if (rat == RadioTechnology::LTE || rat == RadioTechnology::LTE_CA) {
|
|
ASSERT_EQ(info.getTag(), AccessTechnologySpecificInfo::eutranInfo);
|
|
} else if (rat == RadioTechnology::NR) {
|
|
ASSERT_EQ(info.getTag(), AccessTechnologySpecificInfo::ngranNrVopsInfo);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getAvailableBandModes() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getAvailableBandModes) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res = radio_network->getAvailableBandModes(serial);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ALOGI("getAvailableBandModes, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
|
|
RadioError::MODEM_ERR, RadioError::INTERNAL_ERR,
|
|
// If REQUEST_NOT_SUPPORTED is returned, then it should also be
|
|
// returned for setBandMode().
|
|
RadioError::REQUEST_NOT_SUPPORTED}));
|
|
bool hasUnspecifiedBandMode = false;
|
|
if (radioRsp_network->rspInfo.error == RadioError::NONE) {
|
|
for (const RadioBandMode& mode : radioRsp_network->radioBandModes) {
|
|
// Automatic mode selection must be supported
|
|
if (mode == RadioBandMode::BAND_MODE_UNSPECIFIED) hasUnspecifiedBandMode = true;
|
|
}
|
|
ASSERT_TRUE(hasUnspecifiedBandMode);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setIndicationFilter()
|
|
*/
|
|
TEST_P(RadioNetworkTest, setIndicationFilter) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
ndk::ScopedAStatus res =
|
|
radio_network->setIndicationFilter(serial, static_cast<int>(IndicationFilter::ALL));
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
ALOGI("setIndicationFilter, rspInfo.error = %s\n",
|
|
toString(radioRsp_network->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setBarringPassword() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setBarringPassword) {
|
|
serial = GetRandomSerialNumber();
|
|
std::string facility = "";
|
|
std::string oldPassword = "";
|
|
std::string newPassword = "";
|
|
|
|
radio_network->setBarringPassword(serial, facility, oldPassword, newPassword);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::FDN_CHECK_FAILURE,
|
|
RadioError::INVALID_ARGUMENTS, RadioError::MODEM_ERR},
|
|
CHECK_GENERAL_ERROR));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setSuppServiceNotifications() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setSuppServiceNotifications) {
|
|
serial = GetRandomSerialNumber();
|
|
bool enable = false;
|
|
|
|
radio_network->setSuppServiceNotifications(serial, enable);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::SIM_ABSENT}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getImsRegistrationState() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getImsRegistrationState) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->getImsRegistrationState(serial);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::MODEM_ERR, RadioError::INVALID_MODEM_STATE},
|
|
CHECK_GENERAL_ERROR));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getOperator() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getOperator) {
|
|
LOG(DEBUG) << "getOperator";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->getOperator(serial);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
|
|
}
|
|
LOG(DEBUG) << "getOperator finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getNetworkSelectionMode() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getNetworkSelectionMode) {
|
|
LOG(DEBUG) << "getNetworkSelectionMode";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->getNetworkSelectionMode(serial);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
|
|
}
|
|
LOG(DEBUG) << "getNetworkSelectionMode finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setNetworkSelectionModeAutomatic() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setNetworkSelectionModeAutomatic) {
|
|
LOG(DEBUG) << "setNetworkSelectionModeAutomatic";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->setNetworkSelectionModeAutomatic(serial);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::ILLEGAL_SIM_OR_ME,
|
|
RadioError::OPERATION_NOT_ALLOWED},
|
|
CHECK_GENERAL_ERROR));
|
|
}
|
|
LOG(DEBUG) << "setNetworkSelectionModeAutomatic finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getAvailableNetworks() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getAvailableNetworks) {
|
|
LOG(DEBUG) << "getAvailableNetworks";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->getAvailableNetworks(serial);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
ASSERT_TRUE(radioRsp_network->rspInfo.type == RadioResponseType::SOLICITED ||
|
|
radioRsp_network->rspInfo.type == RadioResponseType::SOLICITED_ACK_EXP);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::CANCELLED, RadioError::DEVICE_IN_USE,
|
|
RadioError::MODEM_ERR, RadioError::OPERATION_NOT_ALLOWED},
|
|
CHECK_GENERAL_ERROR));
|
|
}
|
|
LOG(DEBUG) << "getAvailableNetworks finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setBandMode() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setBandMode) {
|
|
LOG(DEBUG) << "setBandMode";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->setBandMode(serial, RadioBandMode::BAND_MODE_USA);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::NONE},
|
|
CHECK_GENERAL_ERROR));
|
|
}
|
|
LOG(DEBUG) << "setBandMode finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setLocationUpdates() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setLocationUpdates) {
|
|
LOG(DEBUG) << "setLocationUpdates";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->setLocationUpdates(serial, true);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::SIM_ABSENT}));
|
|
}
|
|
LOG(DEBUG) << "setLocationUpdates finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setCdmaRoamingPreference() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setCdmaRoamingPreference) {
|
|
LOG(DEBUG) << "setCdmaRoamingPreference";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->setCdmaRoamingPreference(serial, CdmaRoamingType::HOME_NETWORK);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::SIM_ABSENT, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
LOG(DEBUG) << "setCdmaRoamingPreference finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getCdmaRoamingPreference() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getCdmaRoamingPreference) {
|
|
LOG(DEBUG) << "getCdmaRoamingPreference";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->getCdmaRoamingPreference(serial);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::SIM_ABSENT, RadioError::MODEM_ERR},
|
|
CHECK_GENERAL_ERROR));
|
|
}
|
|
LOG(DEBUG) << "getCdmaRoamingPreference finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.getVoiceRadioTechnology() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, getVoiceRadioTechnology) {
|
|
LOG(DEBUG) << "getVoiceRadioTechnology";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->getVoiceRadioTechnology(serial);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
EXPECT_EQ(RadioError::NONE, radioRsp_network->rspInfo.error);
|
|
}
|
|
LOG(DEBUG) << "getVoiceRadioTechnology finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.setCellInfoListRate() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, setCellInfoListRate) {
|
|
LOG(DEBUG) << "setCellInfoListRate";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->setCellInfoListRate(serial, 10);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
LOG(DEBUG) << "setCellInfoListRate finished";
|
|
}
|
|
|
|
/*
|
|
* Test IRadioNetwork.supplyNetworkDepersonalization() for the response returned.
|
|
*/
|
|
TEST_P(RadioNetworkTest, supplyNetworkDepersonalization) {
|
|
LOG(DEBUG) << "supplyNetworkDepersonalization";
|
|
serial = GetRandomSerialNumber();
|
|
|
|
radio_network->supplyNetworkDepersonalization(serial, std::string("test"));
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
|
|
|
|
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_network->rspInfo.error,
|
|
{RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INTERNAL_ERR,
|
|
RadioError::INVALID_SIM_STATE, RadioError::MODEM_ERR, RadioError::NO_MEMORY,
|
|
RadioError::PASSWORD_INCORRECT, RadioError::SIM_ABSENT, RadioError::SYSTEM_ERR}));
|
|
}
|
|
LOG(DEBUG) << "supplyNetworkDepersonalization finished";
|
|
}
|