mirror of
https://github.com/Evolution-X/hardware_interfaces
synced 2026-02-01 11:36:00 +00:00
f56b9a41dd
Currently tests that check for incremental scan interval
range-checking have incremental scans disabled.
This CL turns on incremental scans for tests where the
invalid interval range checks are being validated.
Bug: 112486807
Test: atest RadioHidlTest_v1_2#startNetworkScan_InvalidPeriodicity1;
atest RadioHidlTest_v1_2#startNetworkScan_InvalidPeriodicity2;
Change-Id: I94874f538d2df70a72913b489d9298f8d1cf9b56
809 lines
35 KiB
C++
809 lines
35 KiB
C++
/*
|
|
* Copyright (C) 2017 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 <radio_hidl_hal_utils_v1_2.h>
|
|
#include <vector>
|
|
|
|
#define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
|
|
|
|
namespace {
|
|
const RadioAccessSpecifier GERAN_SPECIFIER_P900 = {.radioAccessNetwork = RadioAccessNetworks::GERAN,
|
|
.geranBands = {GeranBands::BAND_P900},
|
|
.channels = {1, 2}};
|
|
const RadioAccessSpecifier GERAN_SPECIFIER_850 = {.radioAccessNetwork = RadioAccessNetworks::GERAN,
|
|
.geranBands = {GeranBands::BAND_850},
|
|
.channels = {128, 129}};
|
|
} // namespace
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() for the response returned.
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {
|
|
.type = ScanType::ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850}};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan, rspInfo.error = %s\n", toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::SIM_ABSENT}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
// REQUEST_NOT_SUPPORTED should not be allowed as it is not an optional API. However, the
|
|
// comments in the hal were not updated to indicate that, hence allowing it as a valid
|
|
// error for now. This should be fixed correctly, possibly in a future version of the hal
|
|
// (b/110421924). This is being allowed because some vendors do not support
|
|
// this request on dual sim devices.
|
|
// 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.
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,
|
|
RadioError::OPERATION_NOT_ALLOWED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() with invalid specifier.
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidArgument) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {.type = ScanType::ONE_SHOT,
|
|
.interval = 60};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() with invalid interval (lower boundary).
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidInterval1) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {
|
|
.type = ScanType::ONE_SHOT,
|
|
.interval = 4,
|
|
.specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
|
|
.maxSearchTime = 60,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 1};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan_InvalidInterval1, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() with invalid interval (upper boundary).
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidInterval2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {
|
|
.type = ScanType::ONE_SHOT,
|
|
.interval = 301,
|
|
.specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
|
|
.maxSearchTime = 60,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 1};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan_InvalidInterval2, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() with invalid max search time (lower boundary).
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidMaxSearchTime1) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {
|
|
.type = ScanType::ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
|
|
.maxSearchTime = 59,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 1};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan_InvalidMaxSearchTime1, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() with invalid max search time (upper boundary).
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidMaxSearchTime2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {
|
|
.type = ScanType::ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
|
|
.maxSearchTime = 3601,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 1};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan_InvalidMaxSearchTime2, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() with invalid periodicity (lower boundary).
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidPeriodicity1) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {
|
|
.type = ScanType::ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
|
|
.maxSearchTime = 600,
|
|
.incrementalResults = true,
|
|
.incrementalResultsPeriodicity = 0};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan_InvalidPeriodicity1, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() with invalid periodicity (upper boundary).
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan_InvalidPeriodicity2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {
|
|
.type = ScanType::ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
|
|
.maxSearchTime = 600,
|
|
.incrementalResults = true,
|
|
.incrementalResultsPeriodicity = 11};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan_InvalidPeriodicity2, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::INVALID_ARGUMENTS}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() with valid periodicity
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan_GoodRequest1) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {
|
|
.type = ScanType::ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
|
|
// Some vendor may not support max search time of 360s.
|
|
// This issue is tracked in b/112205669.
|
|
.maxSearchTime = 300,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 10};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::SIM_ABSENT}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.startNetworkScan() with valid periodicity and plmns
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, startNetworkScan_GoodRequest2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::NetworkScanRequest request = {
|
|
.type = ScanType::ONE_SHOT,
|
|
.interval = 60,
|
|
.specifiers = {::GERAN_SPECIFIER_P900, ::GERAN_SPECIFIER_850},
|
|
// Some vendor may not support max search time of 360s.
|
|
// This issue is tracked in b/112205669.
|
|
.maxSearchTime = 300,
|
|
.incrementalResults = false,
|
|
.incrementalResultsPeriodicity = 10,
|
|
.mccMncs = {"310410"}};
|
|
|
|
Return<void> res = radio_v1_2->startNetworkScan_1_2(serial, request);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("startNetworkScan_InvalidArgument, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::SIM_ABSENT}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setIndicationFilter_1_2()
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setIndicationFilter_1_2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setIndicationFilter_1_2(
|
|
serial, static_cast<int>(::android::hardware::radio::V1_2::IndicationFilter::ALL));
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setIndicationFilter_1_2, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setSignalStrengthReportingCriteria() with invalid hysteresisDb
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_invalidHysteresisDb) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
|
|
serial, 5000,
|
|
10, // hysteresisDb too large given threshold list deltas
|
|
{-109, -103, -97, -89}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_invalidHysteresisDb, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::INVALID_ARGUMENTS}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setSignalStrengthReportingCriteria() with empty parameters
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_EmptyParams) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
|
|
serial, 0, 0, {}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_EmptyParams, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setSignalStrengthReportingCriteria() for GERAN
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Geran) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
|
|
serial, 5000, 2, {-109, -103, -97, -89},
|
|
::android::hardware::radio::V1_2::AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_Geran, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setSignalStrengthReportingCriteria() for UTRAN
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Utran) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
|
|
serial, 5000, 2, {-110, -97, -73, -49, -25},
|
|
::android::hardware::radio::V1_2::AccessNetwork::UTRAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_Utran, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setSignalStrengthReportingCriteria() for EUTRAN
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Eutran) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
|
|
serial, 5000, 2, {-140, -128, -118, -108, -98, -44},
|
|
::android::hardware::radio::V1_2::AccessNetwork::EUTRAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_Eutran, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setSignalStrengthReportingCriteria() for CDMA2000
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setSignalStrengthReportingCriteria_Cdma2000) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setSignalStrengthReportingCriteria(
|
|
serial, 5000, 2, {-105, -90, -75, -65},
|
|
::android::hardware::radio::V1_2::AccessNetwork::CDMA2000);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setSignalStrengthReportingCriteria_Cdma2000, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error, {RadioError::NONE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setLinkCapacityReportingCriteria() invalid hysteresisDlKbps
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_invalidHysteresisDlKbps) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
|
|
serial, 5000,
|
|
5000, // hysteresisDlKbps too big for thresholds delta
|
|
100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
|
|
::android::hardware::radio::V1_2::AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisDlKbps, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
// Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported for
|
|
// GERAN
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setLinkCapacityReportingCriteria() invalid hysteresisUlKbps
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_invalidHysteresisUlKbps) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
|
|
serial, 5000, 500,
|
|
1000, // hysteresisUlKbps too big for thresholds delta
|
|
{1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
|
|
::android::hardware::radio::V1_2::AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
// Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported for
|
|
// GERAN
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setLinkCapacityReportingCriteria() empty params
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_emptyParams) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
|
|
serial, 0, 0, 0, {}, {}, ::android::hardware::radio::V1_2::AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setLinkCapacityReportingCriteria_emptyParams, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
// Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported for
|
|
// GERAN
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setLinkCapacityReportingCriteria() GERAN
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setLinkCapacityReportingCriteria_Geran) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->setLinkCapacityReportingCriteria(
|
|
serial, 5000, 500, 100, {1000, 5000, 10000, 20000}, {500, 1000, 5000, 10000},
|
|
::android::hardware::radio::V1_2::AccessNetwork::GERAN);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("setLinkCapacityReportingCriteria_invalidHysteresisUlKbps, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
// Allow REQUEST_NOT_SUPPORTED as setLinkCapacityReportingCriteria() may not be supported for
|
|
// GERAN
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.setupDataCall_1_2() for the response returned.
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, setupDataCall_1_2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
::android::hardware::radio::V1_2::AccessNetwork accessNetwork =
|
|
::android::hardware::radio::V1_2::AccessNetwork::EUTRAN;
|
|
|
|
DataProfileInfo dataProfileInfo;
|
|
memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
|
|
dataProfileInfo.profileId = DataProfileId::IMS;
|
|
dataProfileInfo.apn = hidl_string("VZWIMS");
|
|
dataProfileInfo.protocol = hidl_string("IPV4V6");
|
|
dataProfileInfo.roamingProtocol = hidl_string("IPV6");
|
|
dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
|
|
dataProfileInfo.user = "";
|
|
dataProfileInfo.password = "";
|
|
dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
|
|
dataProfileInfo.maxConnsTime = 300;
|
|
dataProfileInfo.maxConns = 20;
|
|
dataProfileInfo.waitTime = 0;
|
|
dataProfileInfo.enabled = true;
|
|
dataProfileInfo.supportedApnTypesBitmap = 320;
|
|
dataProfileInfo.bearerBitmap = 161543;
|
|
dataProfileInfo.mtu = 0;
|
|
dataProfileInfo.mvnoType = MvnoType::NONE;
|
|
dataProfileInfo.mvnoMatchData = hidl_string();
|
|
|
|
bool modemCognitive = false;
|
|
bool roamingAllowed = false;
|
|
bool isRoaming = false;
|
|
|
|
::android::hardware::radio::V1_2::DataRequestReason reason =
|
|
::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
|
|
std::vector<hidl_string> addresses = {""};
|
|
std::vector<hidl_string> dnses = {""};
|
|
|
|
Return<void> res = radio_v1_2->setupDataCall_1_2(serial, accessNetwork, dataProfileInfo,
|
|
modemCognitive, roamingAllowed, isRoaming,
|
|
reason, addresses, dnses);
|
|
ASSERT_OK(res);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
|
|
RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
|
|
RadioError::OP_NOT_ALLOWED_BEFORE_REG_TO_NW, RadioError::REQUEST_NOT_SUPPORTED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.deactivateDataCall_1_2() for the response returned.
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, deactivateDataCall_1_2) {
|
|
serial = GetRandomSerialNumber();
|
|
int cid = 1;
|
|
::android::hardware::radio::V1_2::DataRequestReason reason =
|
|
::android::hardware::radio::V1_2::DataRequestReason::NORMAL;
|
|
|
|
Return<void> res = radio_v1_2->deactivateDataCall_1_2(serial, cid, reason);
|
|
ASSERT_OK(res);
|
|
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
if (cardStatus.base.cardState == CardState::ABSENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_CALL_ID,
|
|
RadioError::INVALID_STATE, RadioError::INVALID_ARGUMENTS,
|
|
RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED, RadioError::SIM_ABSENT}));
|
|
} else if (cardStatus.base.cardState == CardState::PRESENT) {
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_CALL_ID,
|
|
RadioError::INVALID_STATE, RadioError::INVALID_ARGUMENTS,
|
|
RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED}));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.getCellInfoList() for the response returned.
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, getCellInfoList_1_2) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->getCellInfoList(serial);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("getCellInfoList_1_2, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::NO_NETWORK_FOUND}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.getVoiceRegistrationState() for the response returned.
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, getVoiceRegistrationState) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->getVoiceRegistrationState(serial);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("getVoiceRegistrationStateResponse_1_2, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.getDataRegistrationState() for the response returned.
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, getDataRegistrationState) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->getDataRegistrationState(serial);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
|
|
ALOGI("getVoiceRegistrationStateResponse_1_2, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(CheckAnyOfErrors(
|
|
radioRsp_v1_2->rspInfo.error,
|
|
{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::NOT_PROVISIONED}));
|
|
|
|
// Check the mcc [0, 999] and mnc [0, 999].
|
|
string hidl_mcc;
|
|
string hidl_mnc;
|
|
bool checkMccMnc = true;
|
|
int totalIdentitySizeExpected = 1;
|
|
::android::hardware::radio::V1_2::CellIdentity cellIdentities =
|
|
radioRsp_v1_2->dataRegResp.cellIdentity;
|
|
CellInfoType cellInfoType = cellIdentities.cellInfoType;
|
|
|
|
if (cellInfoType == CellInfoType::NONE) {
|
|
// All the fields are 0
|
|
totalIdentitySizeExpected = 0;
|
|
checkMccMnc = false;
|
|
} else if (cellInfoType == CellInfoType::GSM) {
|
|
EXPECT_EQ(1, cellIdentities.cellIdentityGsm.size());
|
|
::android::hardware::radio::V1_2::CellIdentityGsm cig = cellIdentities.cellIdentityGsm[0];
|
|
hidl_mcc = cig.base.mcc;
|
|
hidl_mnc = cig.base.mnc;
|
|
} else if (cellInfoType == CellInfoType::LTE) {
|
|
EXPECT_EQ(1, cellIdentities.cellIdentityLte.size());
|
|
::android::hardware::radio::V1_2::CellIdentityLte cil = cellIdentities.cellIdentityLte[0];
|
|
hidl_mcc = cil.base.mcc;
|
|
hidl_mnc = cil.base.mnc;
|
|
} else if (cellInfoType == CellInfoType::WCDMA) {
|
|
EXPECT_EQ(1, cellIdentities.cellIdentityWcdma.size());
|
|
::android::hardware::radio::V1_2::CellIdentityWcdma ciw =
|
|
cellIdentities.cellIdentityWcdma[0];
|
|
hidl_mcc = ciw.base.mcc;
|
|
hidl_mnc = ciw.base.mnc;
|
|
} else if (cellInfoType == CellInfoType::TD_SCDMA) {
|
|
EXPECT_EQ(1, cellIdentities.cellIdentityTdscdma.size());
|
|
::android::hardware::radio::V1_2::CellIdentityTdscdma cit =
|
|
cellIdentities.cellIdentityTdscdma[0];
|
|
hidl_mcc = cit.base.mcc;
|
|
hidl_mnc = cit.base.mnc;
|
|
} else {
|
|
// CellIndentityCdma has no mcc and mnc.
|
|
EXPECT_EQ(CellInfoType::CDMA, cellInfoType);
|
|
EXPECT_EQ(1, cellIdentities.cellIdentityCdma.size());
|
|
checkMccMnc = false;
|
|
}
|
|
|
|
// Check only one CellIdentity is size 1, and others must be 0.
|
|
EXPECT_EQ(totalIdentitySizeExpected,
|
|
cellIdentities.cellIdentityGsm.size() + cellIdentities.cellIdentityCdma.size() +
|
|
cellIdentities.cellIdentityLte.size() + cellIdentities.cellIdentityWcdma.size() +
|
|
cellIdentities.cellIdentityTdscdma.size());
|
|
|
|
// 32 bit system might return invalid mcc and mnc hidl string "\xff\xff..."
|
|
if (checkMccMnc && hidl_mcc.size() < 4 && hidl_mnc.size() < 4) {
|
|
int mcc = stoi(hidl_mcc);
|
|
int mnc = stoi(hidl_mnc);
|
|
EXPECT_TRUE(mcc >= 0 && mcc <= 999);
|
|
EXPECT_TRUE(mnc >= 0 && mnc <= 999);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test IRadio.getAvailableBandModes() for the response returned.
|
|
*/
|
|
TEST_F(RadioHidlTest_v1_2, getAvailableBandModes) {
|
|
serial = GetRandomSerialNumber();
|
|
|
|
Return<void> res = radio_v1_2->getAvailableBandModes(serial);
|
|
ASSERT_OK(res);
|
|
EXPECT_EQ(std::cv_status::no_timeout, wait());
|
|
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_v1_2->rspInfo.type);
|
|
EXPECT_EQ(serial, radioRsp_v1_2->rspInfo.serial);
|
|
ALOGI("getAvailableBandModes, rspInfo.error = %s\n",
|
|
toString(radioRsp_v1_2->rspInfo.error).c_str());
|
|
ASSERT_TRUE(
|
|
CheckAnyOfErrors(radioRsp_v1_2->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 setRandMode().
|
|
RadioError::REQUEST_NOT_SUPPORTED}));
|
|
bool hasUnspecifiedBandMode = false;
|
|
if (radioRsp_v1_2->rspInfo.error == RadioError::NONE) {
|
|
for (const RadioBandMode& mode : radioRsp_v1_2->radioBandModes) {
|
|
// Automatic mode selection must be supported
|
|
if (mode == RadioBandMode::BAND_MODE_UNSPECIFIED) hasUnspecifiedBandMode = true;
|
|
}
|
|
ASSERT_TRUE(hasUnspecifiedBandMode);
|
|
}
|
|
}
|