Finish IRadio 1.6/IRadioConfig 1.3 AIDL VTS (c83bce4c) · Commits · e / os / android_hardware_interfaces

radio/aidl/vts/Android.bp

+3 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,9 @@ cc_test {
		],
		srcs: [
		"radio_aidl_hal_utils.cpp",
		"radio_config_indication.cpp",
		"radio_config_response.cpp",
		"radio_config_test.cpp",
		"radio_data_indication.cpp",
		"radio_data_response.cpp",
		"radio_data_test.cpp",

radio/aidl/vts/VtsHalRadioTargetTest.cpp

+7 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@

		#include <android/binder_process.h>

		#include "radio_config_utils.h"
		#include "radio_data_utils.h"
		#include "radio_messaging_utils.h"
		#include "radio_modem_utils.h"
		@@ -23,6 +24,12 @@
		#include "radio_sim_utils.h"
		#include "radio_voice_utils.h"

		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(RadioConfigTest);
		INSTANTIATE_TEST_SUITE_P(
		PerInstance, RadioConfigTest,
		testing::ValuesIn(android::getAidlHalInstanceNames(IRadioConfig::descriptor)),
		android::PrintInstanceNameToString);

		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(RadioDataTest);
		INSTANTIATE_TEST_SUITE_P(
		PerInstance, RadioDataTest,

radio/aidl/vts/radio_aidl_hal_utils.cpp

+52 −22

Original line number	Diff line number	Diff line
		@@ -18,12 +18,14 @@
		#include "radio_aidl_hal_utils.h"
		#include <iostream>
		#include "VtsCoreUtil.h"

		using namespace aidl::android::hardware::radio::network;
		#include "radio_config_utils.h"
		#include "radio_sim_utils.h"

		#define WAIT_TIMEOUT_PERIOD 75

		aidl::android::hardware::radio::sim::CardStatus cardStatus = {};
		sim::CardStatus cardStatus = {};
		int serial = 0;
		int count_ = 0;

		int GetRandomSerialNumber() {
		return rand();
		@@ -103,23 +105,33 @@ bool isVoiceEmergencyOnly(RegState state) {
		RegState::UNKNOWN_EM == state;
		}

		bool stringEndsWith(std::string const& string, std::string const& end) {
		if (string.size() >= end.size()) {
		return (0 == string.compare(string.size() - end.size() - 1, end.size(), end));
		} else {
		return false;
		}
		}

		bool isServiceValidForDeviceConfiguration(std::string& serviceName) {
		if (isSsSsEnabled()) {
		// Device is configured as SSSS.
		if (serviceName != RADIO_SERVICE_SLOT1_NAME) {
		if (stringEndsWith(serviceName, RADIO_SERVICE_SLOT1_NAME)) {
		ALOGI("%s instance is not valid for SSSS device.", serviceName.c_str());
		return false;
		}
		} else if (isDsDsEnabled()) {
		// Device is configured as DSDS.
		if (serviceName != RADIO_SERVICE_SLOT1_NAME && serviceName != RADIO_SERVICE_SLOT2_NAME) {
		if (!stringEndsWith(serviceName, RADIO_SERVICE_SLOT1_NAME) &&
		!stringEndsWith(serviceName, RADIO_SERVICE_SLOT2_NAME)) {
		ALOGI("%s instance is not valid for DSDS device.", serviceName.c_str());
		return false;
		}
		} else if (isTsTsEnabled()) {
		// Device is configured as TSTS.
		if (serviceName != RADIO_SERVICE_SLOT1_NAME && serviceName != RADIO_SERVICE_SLOT2_NAME &&
		serviceName != RADIO_SERVICE_SLOT3_NAME) {
		if (!stringEndsWith(serviceName, RADIO_SERVICE_SLOT1_NAME) &&
		!stringEndsWith(serviceName, RADIO_SERVICE_SLOT2_NAME) &&
		!stringEndsWith(serviceName, RADIO_SERVICE_SLOT3_NAME)) {
		ALOGI("%s instance is not valid for TSTS device.", serviceName.c_str());
		return false;
		}
		@@ -130,7 +142,7 @@ bool isServiceValidForDeviceConfiguration(std::string& serviceName) {
		/*
		* Notify that the response message is received.
		*/
		void RadioResponseWaiter::notify(int receivedSerial) {
		void RadioServiceTest::notify(int receivedSerial) {
		std::unique_lock<std::mutex> lock(mtx_);
		if (serial == receivedSerial) {
		count_++;
		@@ -141,7 +153,7 @@ void RadioResponseWaiter::notify(int receivedSerial) {
		/*
		* Wait till the response message is notified or till WAIT_TIMEOUT_PERIOD.
		*/
		std::cv_status RadioResponseWaiter::wait() {
		std::cv_status RadioServiceTest::wait() {
		std::unique_lock<std::mutex> lock(mtx_);
		std::cv_status status = std::cv_status::no_timeout;
		auto now = std::chrono::system_clock::now();
		@@ -158,19 +170,37 @@ std::cv_status RadioResponseWaiter::wait() {
		/**
		* Specific features on the Radio HAL rely on Radio HAL Capabilities.
		* The VTS test related to those features must not run if the related capability is disabled.
		* Typical usage within VTS: if (getRadioHalCapabilities()) return;
		* Typical usage within VTS:
		* if (getRadioHalCapabilities()) return;
		*/
		bool RadioResponseWaiter::getRadioHalCapabilities() {
		// TODO(b/210712359): implement after RadioConfig VTS is created
		/**
		// Get HalDeviceCapabilities from the radio config
		std::shared_ptr<RadioConfigResponse> radioConfigRsp = new (std::nothrow)
		RadioConfigResponse(*this); radioConfig->setResponseFunctions(radioConfigRsp, nullptr); serial =
		GetRandomSerialNumber();

		radioConfig->getHalDeviceCapabilities(serial);
		bool RadioServiceTest::getRadioHalCapabilities() {
		// Get HalDeviceCapabilities from RadioConfig
		std::shared_ptr<RadioConfigResponse> radioConfigRsp =
		ndk::SharedRefBase::make<RadioConfigResponse>(*this);
		std::shared_ptr<RadioConfigIndication> radioConfigInd =
		ndk::SharedRefBase::make<RadioConfigIndication>(*this);
		radio_config->setResponseFunctions(radioConfigRsp, radioConfigInd);
		serial = GetRandomSerialNumber();
		radio_config->getHalDeviceCapabilities(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		return radioConfigRsp->modemReducedFeatureSet1;
		**/
		return true;
		}

		/**
		* Some VTS tests require the SIM card status to be present before running.
		* Update the SIM card status, which can be accessed via the extern cardStatus.
		*/
		void RadioServiceTest::updateSimCardStatus() {
		// Update CardStatus from RadioSim
		std::shared_ptr<RadioSimResponse> radioSimRsp =
		ndk::SharedRefBase::make<RadioSimResponse>(*this);
		std::shared_ptr<RadioSimIndication> radioSimInd =
		ndk::SharedRefBase::make<RadioSimIndication>(*this);
		radio_sim->setResponseFunctions(radioSimRsp, radioSimInd);
		serial = GetRandomSerialNumber();
		radio_sim->getIccCardStatus(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioSimRsp->rspInfo.type);
		EXPECT_EQ(serial, radioSimRsp->rspInfo.serial);
		EXPECT_EQ(RadioError::NONE, radioSimRsp->rspInfo.error);
		}

radio/aidl/vts/radio_aidl_hal_utils.h

+15 −11

Original line number	Diff line number	Diff line
		@@ -19,15 +19,20 @@
		#include <aidl/Gtest.h>
		#include <aidl/Vintf.h>
		#include <aidl/android/hardware/radio/RadioError.h>
		#include <aidl/android/hardware/radio/config/IRadioConfig.h>
		#include <aidl/android/hardware/radio/network/RegState.h>
		#include <aidl/android/hardware/radio/sim/CardStatus.h>
		#include <aidl/android/hardware/radio/sim/IRadioSim.h>
		#include <utils/Log.h>
		#include <vector>

		using namespace aidl::android::hardware::radio;
		using aidl::android::hardware::radio::network::RegState;
		using aidl::android::hardware::radio::sim::CardStatus;

		extern CardStatus cardStatus;
		extern int serial;
		extern int count_;

		/*
		* MACRO used to skip test case when radio response return error REQUEST_NOT_SUPPORTED
		@@ -102,12 +107,12 @@ bool isTsTsEnabled();
		/*
		* Check if voice status is in emergency only.
		*/
		bool isVoiceEmergencyOnly(aidl::android::hardware::radio::network::RegState state);
		bool isVoiceEmergencyOnly(RegState state);

		/*
		* Check if voice status is in service.
		*/
		bool isVoiceInService(aidl::android::hardware::radio::network::RegState state);
		bool isVoiceInService(RegState state);

		/*
		* Check if service is valid for device configuration
		@@ -115,26 +120,25 @@ bool isVoiceInService(aidl::android::hardware::radio::network::RegState state);
		bool isServiceValidForDeviceConfiguration(std::string& serviceName);

		/**
		* Used when waiting for an asynchronous response from the HAL.
		* RadioServiceTest base class
		*/
		class RadioResponseWaiter {
		class RadioServiceTest {
		protected:
		std::mutex mtx_;
		std::condition_variable cv_;
		int count_;
		std::shared_ptr<config::IRadioConfig> radio_config;
		std::shared_ptr<sim::IRadioSim> radio_sim;

		public:
		/* Serial number for radio request */
		int serial;

		/* Used as a mechanism to inform the test about data/event callback */
		void notify(int receivedSerial);

		/* Test code calls this function to wait for response */
		std::cv_status wait();

		// TODO(b/210712359): this probably isn't the best place to put this, but it works for now
		// since all RadioXTest extend RadioResponseWaiter
		/* Used to get the radio HAL capabilities */
		/* Get the radio HAL capabilities */
		bool getRadioHalCapabilities();

		/* Update SIM card status */
		void updateSimCardStatus();
		};

radio/aidl/vts/radio_config_indication.cpp

0 → 100644

+24 −0

Original line number	Diff line number	Diff line
		/*
		* 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 "radio_config_utils.h"

		RadioConfigIndication::RadioConfigIndication(RadioServiceTest& parent) : parent_config(parent) {}

		ndk::ScopedAStatus RadioConfigIndication::simSlotsStatusChanged(
		RadioIndicationType /type/, const std::vector<SimSlotStatus>& /slotStatus/) {
		return ndk::ScopedAStatus::ok();
		}