radio/aidl/vts/radio_aidl_hal_utils.cpp - platform/hardware/interfaces - Git at Google

 /*
  * 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.
  */
 #define LOG_TAG "RadioTest"

 #include "radio_aidl_hal_utils.h"
 #include "VtsCoreUtil.h"
 #include "radio_config_utils.h"
 #include "radio_sim_utils.h"

 #define WAIT_TIMEOUT_PERIOD 75

 sim::CardStatus cardStatus = {};
 config::SimSlotStatus slotStatus = {};
 int serial = 0;
 int count_ = 0;

 int GetRandomSerialNumber() {
     return rand();
 }

 ::testing::AssertionResult CheckAnyOfErrors(RadioError err, std::vector<RadioError> errors,
                                             CheckFlag flag) {
     const static std::vector<RadioError> generalErrors = {
             RadioError::RADIO_NOT_AVAILABLE,   RadioError::NO_MEMORY,
             RadioError::INTERNAL_ERR,          RadioError::SYSTEM_ERR,
             RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED};
     if (flag == CHECK_GENERAL_ERROR || flag == CHECK_OEM_AND_GENERAL_ERROR) {
         for (size_t i = 0; i < generalErrors.size(); i++) {
             if (err == generalErrors[i]) {
                 return testing::AssertionSuccess();
             }
         }
     }
     if (flag == CHECK_OEM_ERROR || flag == CHECK_OEM_AND_GENERAL_ERROR) {
         if (err >= RadioError::OEM_ERROR_1 && err <= RadioError::OEM_ERROR_25) {
             return testing::AssertionSuccess();
         }
     }
     for (size_t i = 0; i < errors.size(); i++) {
         if (err == errors[i]) {
             return testing::AssertionSuccess();
         }
     }
     return testing::AssertionFailure() << "RadioError:" + toString(err) + " is returned";
 }

 // Runs "pm list features" and attempts to find the specified feature in its output.
 bool deviceSupportsFeature(const char* feature) {
     bool hasFeature = false;
     FILE* p = popen("/system/bin/pm list features", "re");
     if (p) {
         char* line = NULL;
         size_t len = 0;
         while (getline(&line, &len, p) > 0) {
             if (strstr(line, feature)) {
                 hasFeature = true;
                 break;
             }
         }
         pclose(p);
     } else {
         __android_log_print(ANDROID_LOG_FATAL, LOG_TAG, "popen failed: %d", errno);
         _exit(EXIT_FAILURE);
     }
     __android_log_print(ANDROID_LOG_INFO, LOG_TAG, "Feature %s: %ssupported", feature,
                         hasFeature ? "" : "not ");
     return hasFeature;
 }

 bool isSsSsEnabled() {
     // Do not use checkSubstringInCommandOutput("getprop persist.radio.multisim.config", "")
     // until b/148904287 is fixed. We need exact matching instead of partial matching. (i.e.
     // by definition the empty string "" is a substring of any string).
     return !isDsDsEnabled() && !isTsTsEnabled() && !isDsDaEnabled();
 }

 bool isDsDsEnabled() {
     return testing::checkSubstringInCommandOutput("getprop persist.radio.multisim.config", "dsds");
 }

 bool isDsDaEnabled() {
     return testing::checkSubstringInCommandOutput("getprop persist.radio.multisim.config", "dsda");
 }

 bool isTsTsEnabled() {
     return testing::checkSubstringInCommandOutput("getprop persist.radio.multisim.config", "tsts");
 }

 bool isVoiceInService(RegState state) {
     return RegState::REG_HOME == state || RegState::REG_ROAMING == state;
 }

 bool isVoiceEmergencyOnly(RegState state) {
     return RegState::NOT_REG_MT_NOT_SEARCHING_OP_EM == state ||
            RegState::NOT_REG_MT_SEARCHING_OP_EM == state || RegState::REG_DENIED_EM == state ||
            RegState::UNKNOWN_EM == state;
 }

 bool stringEndsWith(std::string const& string, std::string const& end) {
     if (string.size() >= end.size()) {
         return std::equal(end.rbegin(), end.rend(), string.rbegin());
     } else {
         return false;
     }
 }

 bool isServiceValidForDeviceConfiguration(std::string& serviceName) {
     if (isSsSsEnabled()) {
         // Device is configured as SSSS.
         if (!stringEndsWith(serviceName, RADIO_SERVICE_SLOT1_NAME)) {
             ALOGI("%s instance is not valid for SSSS device.", serviceName.c_str());
             return false;
         }
     } else if (isDsDsEnabled() || isDsDaEnabled()) {
         // Device is configured as DSDS or DSDA.
         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 (!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;
         }
     }
     return true;
 }

 void RadioServiceTest::SetUp() {
     ALOGD("BEGIN %s#%s", ::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name(),
           ::testing::UnitTest::GetInstance()->current_test_info()->name());
     count_ = 0;
     serial = -1;
 }

 void RadioServiceTest::TearDown() {
     count_ = 0;
     serial = -1;
     ALOGD("END %s#%s", ::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name(),
           ::testing::UnitTest::GetInstance()->current_test_info()->name());
 }

 /*
  * Notify that the response message is received.
  */
 void RadioServiceTest::notify(int receivedSerial) {
     std::lock_guard<std::mutex> lock(mtx_);
     if (serial == receivedSerial) {
         count_++;
         cv_.notify_one();
     }
 }

 /*
  * Wait till the response message is notified or till WAIT_TIMEOUT_PERIOD.
  */
 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();
     while (count_ == 0) {
         status = cv_.wait_until(lock, now + std::chrono::seconds(WAIT_TIMEOUT_PERIOD));
         if (status == std::cv_status::timeout) {
             return status;
         }
     }
     count_--;
     return status;
 }

 /**
  * 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;
  */
 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;
 }

 /**
  * 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);
 }

 void RadioServiceTest::updateSimSlotStatus(int physicalSlotId) {
     // Update SimSlotStatus 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->getSimSlotsStatus(serial);
     EXPECT_EQ(std::cv_status::no_timeout, wait());
     EXPECT_EQ(RadioResponseType::SOLICITED, radioConfigRsp->rspInfo.type);
     EXPECT_EQ(serial, radioConfigRsp->rspInfo.serial);
     EXPECT_EQ(RadioError::NONE, radioConfigRsp->rspInfo.error);
     if (radioConfigRsp->simSlotStatus.size() > physicalSlotId) {
         slotStatus = radioConfigRsp->simSlotStatus[physicalSlotId];
     }
 }

 bool isLteConnected(){
     return testing::checkSubstringInCommandOutput("getprop gsm.network.type", "LTE");
 }
	/*
	* 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.
	*/
	#define LOG_TAG "RadioTest"

	#include "radio_aidl_hal_utils.h"
	#include "VtsCoreUtil.h"
	#include "radio_config_utils.h"
	#include "radio_sim_utils.h"

	#define WAIT_TIMEOUT_PERIOD 75

	sim::CardStatus cardStatus = {};
	config::SimSlotStatus slotStatus = {};
	int serial = 0;
	int count_ = 0;

	int GetRandomSerialNumber() {
	return rand();
	}

	::testing::AssertionResult CheckAnyOfErrors(RadioError err, std::vector<RadioError> errors,
	CheckFlag flag) {
	const static std::vector<RadioError> generalErrors = {
	RadioError::RADIO_NOT_AVAILABLE, RadioError::NO_MEMORY,
	RadioError::INTERNAL_ERR, RadioError::SYSTEM_ERR,
	RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED};
	if (flag == CHECK_GENERAL_ERROR \|\| flag == CHECK_OEM_AND_GENERAL_ERROR) {
	for (size_t i = 0; i < generalErrors.size(); i++) {
	if (err == generalErrors[i]) {
	return testing::AssertionSuccess();
	}
	}
	}
	if (flag == CHECK_OEM_ERROR \|\| flag == CHECK_OEM_AND_GENERAL_ERROR) {
	if (err >= RadioError::OEM_ERROR_1 && err <= RadioError::OEM_ERROR_25) {
	return testing::AssertionSuccess();
	}
	}
	for (size_t i = 0; i < errors.size(); i++) {
	if (err == errors[i]) {
	return testing::AssertionSuccess();
	}
	}
	return testing::AssertionFailure() << "RadioError:" + toString(err) + " is returned";
	}

	// Runs "pm list features" and attempts to find the specified feature in its output.
	bool deviceSupportsFeature(const char* feature) {
	bool hasFeature = false;
	FILE* p = popen("/system/bin/pm list features", "re");
	if (p) {
	char* line = NULL;
	size_t len = 0;
	while (getline(&line, &len, p) > 0) {
	if (strstr(line, feature)) {
	hasFeature = true;
	break;
	}
	}
	pclose(p);
	} else {
	__android_log_print(ANDROID_LOG_FATAL, LOG_TAG, "popen failed: %d", errno);
	_exit(EXIT_FAILURE);
	}
	__android_log_print(ANDROID_LOG_INFO, LOG_TAG, "Feature %s: %ssupported", feature,
	hasFeature ? "" : "not ");
	return hasFeature;
	}

	bool isSsSsEnabled() {
	// Do not use checkSubstringInCommandOutput("getprop persist.radio.multisim.config", "")
	// until b/148904287 is fixed. We need exact matching instead of partial matching. (i.e.
	// by definition the empty string "" is a substring of any string).
	return !isDsDsEnabled() && !isTsTsEnabled() && !isDsDaEnabled();
	}

	bool isDsDsEnabled() {
	return testing::checkSubstringInCommandOutput("getprop persist.radio.multisim.config", "dsds");
	}

	bool isDsDaEnabled() {
	return testing::checkSubstringInCommandOutput("getprop persist.radio.multisim.config", "dsda");
	}

	bool isTsTsEnabled() {
	return testing::checkSubstringInCommandOutput("getprop persist.radio.multisim.config", "tsts");
	}

	bool isVoiceInService(RegState state) {
	return RegState::REG_HOME == state \|\| RegState::REG_ROAMING == state;
	}

	bool isVoiceEmergencyOnly(RegState state) {
	return RegState::NOT_REG_MT_NOT_SEARCHING_OP_EM == state \|\|
	RegState::NOT_REG_MT_SEARCHING_OP_EM == state \|\| RegState::REG_DENIED_EM == state \|\|
	RegState::UNKNOWN_EM == state;
	}

	bool stringEndsWith(std::string const& string, std::string const& end) {
	if (string.size() >= end.size()) {
	return std::equal(end.rbegin(), end.rend(), string.rbegin());
	} else {
	return false;
	}
	}

	bool isServiceValidForDeviceConfiguration(std::string& serviceName) {
	if (isSsSsEnabled()) {
	// Device is configured as SSSS.
	if (!stringEndsWith(serviceName, RADIO_SERVICE_SLOT1_NAME)) {
	ALOGI("%s instance is not valid for SSSS device.", serviceName.c_str());
	return false;
	}
	} else if (isDsDsEnabled() \|\| isDsDaEnabled()) {
	// Device is configured as DSDS or DSDA.
	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 (!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;
	}
	}
	return true;
	}

	void RadioServiceTest::SetUp() {
	ALOGD("BEGIN %s#%s", ::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name(),
	::testing::UnitTest::GetInstance()->current_test_info()->name());
	count_ = 0;
	serial = -1;
	}

	void RadioServiceTest::TearDown() {
	count_ = 0;
	serial = -1;
	ALOGD("END %s#%s", ::testing::UnitTest::GetInstance()->current_test_info()->test_suite_name(),
	::testing::UnitTest::GetInstance()->current_test_info()->name());
	}

	/*
	* Notify that the response message is received.
	*/
	void RadioServiceTest::notify(int receivedSerial) {
	std::lock_guard<std::mutex> lock(mtx_);
	if (serial == receivedSerial) {
	count_++;
	cv_.notify_one();
	}
	}

	/*
	* Wait till the response message is notified or till WAIT_TIMEOUT_PERIOD.
	*/
	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();
	while (count_ == 0) {
	status = cv_.wait_until(lock, now + std::chrono::seconds(WAIT_TIMEOUT_PERIOD));
	if (status == std::cv_status::timeout) {
	return status;
	}
	}
	count_--;
	return status;
	}

	/**
	* 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;
	*/
	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;
	}

	/**
	* 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);
	}

	void RadioServiceTest::updateSimSlotStatus(int physicalSlotId) {
	// Update SimSlotStatus 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->getSimSlotsStatus(serial);
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(RadioResponseType::SOLICITED, radioConfigRsp->rspInfo.type);
	EXPECT_EQ(serial, radioConfigRsp->rspInfo.serial);
	EXPECT_EQ(RadioError::NONE, radioConfigRsp->rspInfo.error);
	if (radioConfigRsp->simSlotStatus.size() > physicalSlotId) {
	slotStatus = radioConfigRsp->simSlotStatus[physicalSlotId];
	}
	}

	bool isLteConnected(){
	return testing::checkSubstringInCommandOutput("getprop gsm.network.type", "LTE");
	}