Merge "Removed CDMA related VTS" into main (29aea558) · Commits · e / os / android_hardware_interfaces

radio/aidl/vts/radio_aidl_hal_utils.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -65,8 +65,6 @@ static constexpr const char* FEATURE_VOICE_CALL = "android.software.connectionse

		static constexpr const char* FEATURE_TELEPHONY = "android.hardware.telephony";

		static constexpr const char* FEATURE_TELEPHONY_CDMA = "android.hardware.telephony.cdma";

		static constexpr const char* FEATURE_TELEPHONY_IMS = "android.hardware.telephony.ims";

		static constexpr const char* FEATURE_TELEPHONY_CALLING = "android.hardware.telephony.calling";

radio/aidl/vts/radio_messaging_test.cpp

+0 −318

Original line number	Diff line number	Diff line
		@@ -112,104 +112,6 @@ TEST_P(RadioMessagingTest, sendSmsExpectMore) {
		}
		}

		/*
		* Test IRadioMessaging.sendCdmaSms() for the response returned.
		*/
		TEST_P(RadioMessagingTest, sendCdmaSms) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping sendCdmaSms "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();

		// Create a CdmaSmsAddress
		CdmaSmsAddress cdmaSmsAddress;
		cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
		cdmaSmsAddress.isNumberModeDataNetwork = false;
		cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
		cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
		cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};

		// Create a CdmaSmsSubAddress
		CdmaSmsSubaddress cdmaSmsSubaddress;
		cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
		cdmaSmsSubaddress.odd = false;
		cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};

		// Create a CdmaSmsMessage
		CdmaSmsMessage cdmaSmsMessage;
		cdmaSmsMessage.teleserviceId = 4098;
		cdmaSmsMessage.isServicePresent = false;
		cdmaSmsMessage.serviceCategory = 0;
		cdmaSmsMessage.address = cdmaSmsAddress;
		cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
		cdmaSmsMessage.bearerData =
		(std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};

		radio_messaging->sendCdmaSms(serial, cdmaSmsMessage);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_messaging->rspInfo.error,
		{RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioMessaging.sendCdmaSmsExpectMore() for the response returned.
		*/
		TEST_P(RadioMessagingTest, sendCdmaSmsExpectMore) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping sendCdmaSmsExpectMore "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();

		// Create a CdmaSmsAddress
		CdmaSmsAddress cdmaSmsAddress;
		cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
		cdmaSmsAddress.isNumberModeDataNetwork = false;
		cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
		cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
		cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};

		// Create a CdmaSmsSubAddress
		CdmaSmsSubaddress cdmaSmsSubaddress;
		cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
		cdmaSmsSubaddress.odd = false;
		cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};

		// Create a CdmaSmsMessage
		CdmaSmsMessage cdmaSmsMessage;
		cdmaSmsMessage.teleserviceId = 4098;
		cdmaSmsMessage.isServicePresent = false;
		cdmaSmsMessage.serviceCategory = 0;
		cdmaSmsMessage.address = cdmaSmsAddress;
		cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
		cdmaSmsMessage.bearerData =
		(std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};

		radio_messaging->sendCdmaSmsExpectMore(serial, cdmaSmsMessage);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_messaging->rspInfo.error,
		{RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioMessaging.setGsmBroadcastConfig() for the response returned.
		*/
		@@ -303,85 +205,6 @@ TEST_P(RadioMessagingTest, getGsmBroadcastConfig) {
		}
		}

		/*
		* Test IRadioMessaging.setCdmaBroadcastConfig() for the response returned.
		*/
		TEST_P(RadioMessagingTest, setCdmaBroadcastConfig) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping setCdmaBroadcastConfig "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();

		CdmaBroadcastSmsConfigInfo cbSmsConfig;
		cbSmsConfig.serviceCategory = 4096;
		cbSmsConfig.language = 1;
		cbSmsConfig.selected = true;

		std::vector<CdmaBroadcastSmsConfigInfo> cdmaBroadcastSmsConfigInfoList = {cbSmsConfig};

		radio_messaging->setCdmaBroadcastConfig(serial, cdmaBroadcastSmsConfigInfoList);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
		{RadioError::NONE, RadioError::INVALID_MODEM_STATE},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioMessaging.getCdmaBroadcastConfig() for the response returned.
		*/
		TEST_P(RadioMessagingTest, getCdmaBroadcastConfig) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping getCdmaBroadcastConfig "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();

		radio_messaging->getCdmaBroadcastConfig(serial);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error, {RadioError::NONE},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioMessaging.setCdmaBroadcastActivation() for the response returned.
		*/
		TEST_P(RadioMessagingTest, setCdmaBroadcastActivation) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping setCdmaBroadcastActivation "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();
		bool activate = false;

		radio_messaging->setCdmaBroadcastActivation(serial, activate);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
		{RadioError::NONE, RadioError::INVALID_ARGUMENTS},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioMessaging.setGsmBroadcastActivation() for the response returned.
		*/
		@@ -461,35 +284,6 @@ TEST_P(RadioMessagingTest, acknowledgeIncomingGsmSmsWithPdu) {
		}
		}

		/*
		* Test IRadioMessaging.acknowledgeLastIncomingCdmaSms() for the response returned.
		*/
		TEST_P(RadioMessagingTest, acknowledgeLastIncomingCdmaSms) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping acknowledgeIncomingGsmSmsWithPdu "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();

		// Create a CdmaSmsAck
		CdmaSmsAck cdmaSmsAck;
		cdmaSmsAck.errorClass = false;
		cdmaSmsAck.smsCauseCode = 1;

		radio_messaging->acknowledgeLastIncomingCdmaSms(serial, cdmaSmsAck);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
		{RadioError::INVALID_ARGUMENTS, RadioError::NO_SMS_TO_ACK},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioMessaging.sendImsSms() for the response returned.
		*/
		@@ -655,118 +449,6 @@ TEST_P(RadioMessagingTest, deleteSmsOnSim) {
		}
		}

		/*
		* Test IRadioMessaging.writeSmsToRuim() for the response returned.
		*/
		TEST_P(RadioMessagingTest, writeSmsToRuim) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping writeSmsToRuim "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();

		// Create a CdmaSmsAddress
		CdmaSmsAddress cdmaSmsAddress;
		cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
		cdmaSmsAddress.isNumberModeDataNetwork = false;
		cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
		cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
		cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};

		// Create a CdmaSmsSubAddress
		CdmaSmsSubaddress cdmaSmsSubaddress;
		cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
		cdmaSmsSubaddress.odd = false;
		cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};

		// Create a CdmaSmsMessage
		CdmaSmsMessage cdmaSmsMessage;
		cdmaSmsMessage.teleserviceId = 4098;
		cdmaSmsMessage.isServicePresent = false;
		cdmaSmsMessage.serviceCategory = 0;
		cdmaSmsMessage.address = cdmaSmsAddress;
		cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
		cdmaSmsMessage.bearerData =
		(std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};

		// Create a CdmaSmsWriteArgs
		CdmaSmsWriteArgs cdmaSmsWriteArgs;
		cdmaSmsWriteArgs.status = CdmaSmsWriteArgs::STATUS_REC_UNREAD;
		cdmaSmsWriteArgs.message = cdmaSmsMessage;

		radio_messaging->writeSmsToRuim(serial, cdmaSmsWriteArgs);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_messaging->rspInfo.error,
		{RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_SMS_FORMAT,
		RadioError::INVALID_SMSC_ADDRESS, RadioError::INVALID_STATE, RadioError::MODEM_ERR,
		RadioError::NO_SUCH_ENTRY, RadioError::SIM_ABSENT},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioMessaging.deleteSmsOnRuim() for the response returned.
		*/
		TEST_P(RadioMessagingTest, deleteSmsOnRuim) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping deleteSmsOnRuim "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();
		int index = 1;

		// Create a CdmaSmsAddress
		CdmaSmsAddress cdmaSmsAddress;
		cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
		cdmaSmsAddress.isNumberModeDataNetwork = false;
		cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
		cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
		cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};

		// Create a CdmaSmsSubAddress
		CdmaSmsSubaddress cdmaSmsSubaddress;
		cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
		cdmaSmsSubaddress.odd = false;
		cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};

		// Create a CdmaSmsMessage
		CdmaSmsMessage cdmaSmsMessage;
		cdmaSmsMessage.teleserviceId = 4098;
		cdmaSmsMessage.isServicePresent = false;
		cdmaSmsMessage.serviceCategory = 0;
		cdmaSmsMessage.address = cdmaSmsAddress;
		cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
		cdmaSmsMessage.bearerData =
		(std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};

		// Create a CdmaSmsWriteArgs
		CdmaSmsWriteArgs cdmaSmsWriteArgs;
		cdmaSmsWriteArgs.status = CdmaSmsWriteArgs::STATUS_REC_UNREAD;
		cdmaSmsWriteArgs.message = cdmaSmsMessage;

		radio_messaging->deleteSmsOnRuim(serial, index);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_messaging->rspInfo.error,
		{RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_MODEM_STATE,
		RadioError::MODEM_ERR, RadioError::NO_SUCH_ENTRY, RadioError::SIM_ABSENT},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioMessaging.reportSmsMemoryStatus() for the response returned.
		*/

radio/aidl/vts/radio_modem_test.cpp

+0 −23

Original line number	Diff line number	Diff line
		@@ -284,29 +284,6 @@ TEST_P(RadioModemTest, nvWriteItem) {
		}
		}

		/*
		* Test IRadioModem.nvWriteCdmaPrl() for the response returned.
		*/
		TEST_P(RadioModemTest, nvWriteCdmaPrl) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping nvWriteCdmaPrl "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();
		std::vector<uint8_t> prl = {1, 2, 3, 4, 5};

		radio_modem->nvWriteCdmaPrl(serial, std::vector<uint8_t>(prl));
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_modem->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_modem->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_modem->rspInfo.error, {RadioError::NONE},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioModem.nvResetConfig() for the response returned.
		*/

radio/aidl/vts/radio_network_test.cpp

+0 −95

Original line number	Diff line number	Diff line
		@@ -589,42 +589,6 @@ TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Eutran_RSSNR) {
		EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
		}

		/*
		* Test IRadioNetwork.setSignalStrengthReportingCriteria() for CDMA2000
		*/
		TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_Cdma2000) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_RADIO_ACCESS)) {
		GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Cdma2000 "
		"due to undefined FEATURE_TELEPHONY_RADIO_ACCESS";
		}

		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping setSignalStrengthReportingCriteria_Cdma2000 "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		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
		*/
		@@ -790,15 +754,6 @@ TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_multiRansPerRequest)
		signalThresholdInfoEutran.isEnabled = true;
		signalThresholdInfoEutran.ran = AccessNetwork::EUTRAN;

		SignalThresholdInfo signalThresholdInfoCdma2000;
		signalThresholdInfoCdma2000.signalMeasurement =
		SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_RSSI;
		signalThresholdInfoCdma2000.hysteresisMs = 5000;
		signalThresholdInfoCdma2000.hysteresisDb = 2;
		signalThresholdInfoCdma2000.thresholds = {-105, -90, -75, -65};
		signalThresholdInfoCdma2000.isEnabled = true;
		signalThresholdInfoCdma2000.ran = AccessNetwork::CDMA2000;

		SignalThresholdInfo signalThresholdInfoNgran;
		signalThresholdInfoNgran.signalMeasurement =
		SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_SSRSRP;
		@@ -811,9 +766,6 @@ TEST_P(RadioNetworkTest, setSignalStrengthReportingCriteria_multiRansPerRequest)
		std::vector<SignalThresholdInfo> candidateSignalThresholdInfos = {
		signalThresholdInfoGeran, signalThresholdInfoUtran, signalThresholdInfoEutran,
		signalThresholdInfoNgran};
		if (deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		candidateSignalThresholdInfos.push_back(signalThresholdInfoCdma2000);
		}

		std::vector<SignalThresholdInfo> supportedSignalThresholdInfos;
		for (size_t i = 0; i < candidateSignalThresholdInfos.size(); i++) {
		@@ -2014,53 +1966,6 @@ TEST_P(RadioNetworkTest, setLocationUpdates) {
		}
		}

		/*
		* Test IRadioNetwork.setCdmaRoamingPreference() for the response returned.
		*/
		TEST_P(RadioNetworkTest, setCdmaRoamingPreference) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping setCdmaRoamingPreference "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

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

		/*
		* Test IRadioNetwork.getCdmaRoamingPreference() for the response returned.
		*/
		TEST_P(RadioNetworkTest, getCdmaRoamingPreference) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping getCdmaRoamingPreference "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

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

		/*
		* Test IRadioNetwork.getVoiceRadioTechnology() for the response returned.
		*/

radio/aidl/vts/radio_sim_test.cpp

+0 −100

Original line number	Diff line number	Diff line
		@@ -1065,106 +1065,6 @@ TEST_P(RadioSimTest, setFacilityLockForApp) {
		}
		}

		/*
		* Test IRadioSim.getCdmaSubscription() for the response returned.
		*/
		TEST_P(RadioSimTest, getCdmaSubscription) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping getCdmaSubscription "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();

		radio_sim->getCdmaSubscription(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_sim->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_sim->rspInfo.error,
		{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
		}
		}

		/*
		* Test IRadioSim.getCdmaSubscriptionSource() for the response returned.
		*/
		TEST_P(RadioSimTest, getCdmaSubscriptionSource) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping getCdmaSubscriptionSource "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();

		radio_sim->getCdmaSubscriptionSource(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_sim->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_sim->rspInfo.error,
		{RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::SIM_ABSENT}));
		}
		}

		/*
		* Test IRadioSim.setCdmaSubscriptionSource() for the response returned.
		*/
		TEST_P(RadioSimTest, setCdmaSubscriptionSource) {
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
		GTEST_SKIP() << "Skipping setCdmaSubscriptionSource "
		"due to undefined FEATURE_TELEPHONY_CDMA";
		}

		serial = GetRandomSerialNumber();

		radio_sim->setCdmaSubscriptionSource(serial, CdmaSubscriptionSource::RUIM_SIM);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_sim->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_sim->rspInfo.error,
		{RadioError::NONE, RadioError::SIM_ABSENT, RadioError::SUBSCRIPTION_NOT_AVAILABLE},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioSim.setUiccSubscription() for the response returned.
		*/
		TEST_P(RadioSimTest, setUiccSubscription) {
		if (!shouldTestCdma()) {
		GTEST_SKIP() << "Skipping CDMA testing (deprecated)";
		}
		if (!deviceSupportsFeature(FEATURE_TELEPHONY_SUBSCRIPTION)) {
		GTEST_SKIP() << "Skipping setUiccSubscription "
		"due to undefined FEATURE_TELEPHONY_SUBSCRIPTION";
		}

		serial = GetRandomSerialNumber();
		SelectUiccSub item;
		memset(&item, 0, sizeof(item));

		radio_sim->setUiccSubscription(serial, item);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_sim->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(
		CheckAnyOfErrors(radioRsp_sim->rspInfo.error,
		{RadioError::NONE, RadioError::INVALID_ARGUMENTS,
		RadioError::MODEM_ERR, RadioError::SUBSCRIPTION_NOT_SUPPORTED},
		CHECK_GENERAL_ERROR));
		}
		}

		/*
		* Test IRadioSim.sendEnvelope() for the response returned.
		*/