Merge "VTS to verify set/get AllowedCarriers for HAL 2.2" into android15-tests-dev (0a93bdbd) · Commits · e / os / android_hardware_interfaces

radio/aidl/compat/libradiocompat/sim/structs.cpp

+40 −6

Original line number	Diff line number	Diff line
		@@ -70,26 +70,60 @@ V1_0::Carrier toHidl(const aidl::Carrier& carrier) {
		};
		}

		static aidl::CarrierInfo toCarrierInfo(const aidl::Carrier& carrier) {
		return {
		.mcc = carrier.mcc,
		.mnc = carrier.mnc,
		};
		}

		static std::vector<aidl::CarrierInfo> toCarrierInfos(const std::vector<aidl::Carrier>& carriers) {
		std::vector<aidl::CarrierInfo> infos(carriers.size());
		for (size_t i = 0; i < carriers.size(); i++) {
		infos[i] = toCarrierInfo(carriers[i]);
		}
		return infos;
		}

		V1_0::Carrier toHidl(const aidl::CarrierInfo& carrierInfo) {
		return {
		.mcc = carrierInfo.mcc,
		.mnc = carrierInfo.mnc,
		};
		}

		aidl::CarrierRestrictions toAidl(const V1_0::CarrierRestrictions& cr) {
		auto allowedCarriers = toAidl(cr.allowedCarriers);
		auto excludedCarriers = toAidl(cr.excludedCarriers);
		return {
		.allowedCarriers = toAidl(cr.allowedCarriers),
		.excludedCarriers = toAidl(cr.excludedCarriers),
		.allowedCarriers = allowedCarriers,
		.excludedCarriers = excludedCarriers,
		.allowedCarriersPrioritized = true,
		.allowedCarrierInfoList = toCarrierInfos(allowedCarriers),
		.excludedCarrierInfoList = toCarrierInfos(excludedCarriers),
		};
		}

		aidl::CarrierRestrictions toAidl(const V1_4::CarrierRestrictionsWithPriority& cr) {
		auto allowedCarriers = toAidl(cr.allowedCarriers);
		auto excludedCarriers = toAidl(cr.excludedCarriers);
		return {
		.allowedCarriers = toAidl(cr.allowedCarriers),
		.excludedCarriers = toAidl(cr.excludedCarriers),
		.allowedCarriers = allowedCarriers,
		.excludedCarriers = excludedCarriers,
		.allowedCarriersPrioritized = cr.allowedCarriersPrioritized,
		.allowedCarrierInfoList = toCarrierInfos(allowedCarriers),
		.excludedCarrierInfoList = toCarrierInfos(excludedCarriers),
		};
		}

		V1_4::CarrierRestrictionsWithPriority toHidl(const aidl::CarrierRestrictions& cr) {
		return {
		.allowedCarriers = toHidl(cr.allowedCarriers),
		.excludedCarriers = toHidl(cr.excludedCarriers),
		.allowedCarriers = (cr.allowedCarriers.size() > cr.allowedCarrierInfoList.size())
		? toHidl(cr.allowedCarriers)
		: toHidl(cr.allowedCarrierInfoList),
		.excludedCarriers = (cr.excludedCarriers.size() > cr.excludedCarrierInfoList.size())
		? toHidl(cr.excludedCarriers)
		: toHidl(cr.excludedCarrierInfoList),
		.allowedCarriersPrioritized = cr.allowedCarriersPrioritized,
		};
		}

radio/aidl/compat/libradiocompat/sim/structs.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -37,6 +37,7 @@ V1_0::SimApdu toHidl(const ::aidl::android::hardware::radio::sim::SimApdu& apdu)

		::aidl::android::hardware::radio::sim::Carrier toAidl(const V1_0::Carrier& carrier);
		V1_0::Carrier toHidl(const ::aidl::android::hardware::radio::sim::Carrier& carrier);
		V1_0::Carrier toHidl(const ::aidl::android::hardware::radio::sim::CarrierInfo& carrierInfo);

		::aidl::android::hardware::radio::sim::CarrierRestrictions //
		toAidl(const V1_0::CarrierRestrictions& cr);

radio/aidl/vts/radio_sim_test.cpp

+78 −22

Original line number	Diff line number	Diff line
		@@ -460,6 +460,20 @@ TEST_P(RadioSimTest, setAllowedCarriers) {
		serial = GetRandomSerialNumber();
		CarrierRestrictions carrierRestrictions;
		memset(&carrierRestrictions, 0, sizeof(carrierRestrictions));
		int32_t aidl_version;
		ndk::ScopedAStatus aidl_status = radio_sim->getInterfaceVersion(&aidl_version);
		ASSERT_OK(aidl_status);

		// Changes start

		SimLockMultiSimPolicy multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;
		ALOGI("VTSAllowedCarriers Current AIDL version is %d ", aidl_version);
		if (aidl_version <= 2) {
		ALOGI("VTSAllowedCarriers If aidl_version is below 3 then , it will consider old AIDLs");
		carrierRestrictions.allowedCarrierInfoList.resize(1);
		if ((carrierRestrictions.allowedCarrierInfoList.size() > 0)) {
		ALOGI("VTSAllowedCarriers If size of allowedCarrierInfoList is greater than 0");
		}
		carrierRestrictions.allowedCarriers.resize(1);
		carrierRestrictions.excludedCarriers.resize(0);
		carrierRestrictions.allowedCarriers[0].mcc = std::string("123");
		@@ -467,7 +481,22 @@ TEST_P(RadioSimTest, setAllowedCarriers) {
		carrierRestrictions.allowedCarriers[0].matchType = Carrier::MATCH_TYPE_ALL;
		carrierRestrictions.allowedCarriers[0].matchData = std::string();
		carrierRestrictions.allowedCarriersPrioritized = true;
		SimLockMultiSimPolicy multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;
		multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;
		} else {
		carrierRestrictions.allowedCarrierInfoList.resize(1);
		carrierRestrictions.excludedCarrierInfoList.resize(0);
		// TODO(b/365568518): change mcc/mnc to something else once CF fully supports
		// setAllowedCarriers
		carrierRestrictions.allowedCarrierInfoList[0].mcc = std::string("123");
		carrierRestrictions.allowedCarrierInfoList[0].mnc = std::string("456");
		carrierRestrictions.allowedCarrierInfoList[0].spn = std::string("TestNetwork");
		carrierRestrictions.allowedCarrierInfoList[0].gid1 = std::string("BAE000000000000");
		carrierRestrictions.allowedCarrierInfoList[0].gid2 = std::string("AE0000000000000");
		carrierRestrictions.allowedCarrierInfoList[0].imsiPrefix = std::string("9987");
		carrierRestrictions.allowedCarriersPrioritized = true;
		carrierRestrictions.status = CarrierRestrictions::CarrierRestrictionStatus::RESTRICTED;
		multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;
		}

		radio_sim->setAllowedCarriers(serial, carrierRestrictions, multisimPolicy);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		@@ -490,7 +519,7 @@ TEST_P(RadioSimTest, setAllowedCarriers) {
		sleep(2);
		updateSimCardStatus();
		}
		// TODO: uncomment once CF fully supports setAllowedCarriers
		// TODO(b/365568518): uncomment once CF fully supports setAllowedCarriers
		// EXPECT_EQ(CardStatus::STATE_RESTRICTED, cardStatus.cardState);
		}

		@@ -503,8 +532,10 @@ TEST_P(RadioSimTest, setAllowedCarriers) {
		EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);
		EXPECT_EQ(RadioError::NONE, radioRsp_sim->rspInfo.error);

		if (aidl_version <= 2) {
		EXPECT_EQ(1, radioRsp_sim->carrierRestrictionsResp.allowedCarriers.size());
		EXPECT_EQ(0, radioRsp_sim->carrierRestrictionsResp.excludedCarriers.size());

		ASSERT_TRUE(std::string("123") ==
		radioRsp_sim->carrierRestrictionsResp.allowedCarriers[0].mcc);
		ASSERT_TRUE(std::string("456") ==
		@@ -513,7 +544,26 @@ TEST_P(RadioSimTest, setAllowedCarriers) {
		radioRsp_sim->carrierRestrictionsResp.allowedCarriers[0].matchType);
		ASSERT_TRUE(radioRsp_sim->carrierRestrictionsResp.allowedCarriersPrioritized);
		EXPECT_EQ(SimLockMultiSimPolicy::NO_MULTISIM_POLICY, radioRsp_sim->multiSimPolicyResp);

		} else {
		EXPECT_EQ(1, radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList.size());
		EXPECT_EQ(0, radioRsp_sim->carrierRestrictionsResp.excludedCarrierInfoList.size());
		ASSERT_EQ(std::string("123"),
		radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].mcc);
		ASSERT_EQ(std::string("456"),
		radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].mnc);
		#if 0 // TODO(b/365568518): enable once CF fully supports setAllowedCarriers
		ASSERT_EQ(std::string("BAE000000000000"),
		radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].gid1);
		ASSERT_EQ(std::string("AE0000000000000"),
		radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].gid2);
		ASSERT_EQ(std::string("9987"),
		radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].imsiPrefix);
		EXPECT_EQ(CarrierRestrictions::CarrierRestrictionStatus::RESTRICTED,
		radioRsp_sim->carrierRestrictionsResp.status);
		#endif
		ASSERT_TRUE(radioRsp_sim->carrierRestrictionsResp.allowedCarriersPrioritized);
		EXPECT_EQ(SimLockMultiSimPolicy::NO_MULTISIM_POLICY, radioRsp_sim->multiSimPolicyResp);
		}
		sleep(10);

		/**
		@@ -522,9 +572,15 @@ TEST_P(RadioSimTest, setAllowedCarriers) {
		* status for cardStatus.
		*/
		memset(&carrierRestrictions, 0, sizeof(carrierRestrictions));
		if (aidl_version <= 2) {
		carrierRestrictions.allowedCarriers.resize(0);
		carrierRestrictions.excludedCarriers.resize(0);
		carrierRestrictions.allowedCarriersPrioritized = false;
		} else {
		carrierRestrictions.allowedCarrierInfoList.resize(0);
		carrierRestrictions.excludedCarrierInfoList.resize(0);
		carrierRestrictions.allowedCarriersPrioritized = false;
		}

		serial = GetRandomSerialNumber();
		radio_sim->setAllowedCarriers(serial, carrierRestrictions, multisimPolicy);