Merge "wifi vts: Add vts test case for new aidl API about mlo SAP" into main (f325a862) · Commits · e / os / android_hardware_interfaces

wifi/aidl/vts/functional/wifi_aidl_test_utils.cpp

+25 −0

Original line number	Diff line number	Diff line
		@@ -276,3 +276,28 @@ std::optional<std::vector<std::optional<OuiKeyedData>>> generateOuiKeyedDataList
		}
		return std::optional<std::vector<std::optional<OuiKeyedData>>>{dataList};
		}

		IWifiChip::ApIfaceParams generateApIfaceParams(IfaceConcurrencyType type, bool uses_mlo,
		int oui_size) {
		IWifiChip::ApIfaceParams params;
		params.ifaceType = type;
		params.usesMlo = uses_mlo;
		params.vendorData = generateOuiKeyedDataListOptional(oui_size);
		return params;
		}

		std::shared_ptr<IWifiApIface> getWifiApOrBridgedApIface(std::shared_ptr<IWifiChip> wifi_chip,
		IWifiChip::ApIfaceParams params) {
		if (!wifi_chip.get()) {
		return nullptr;
		}
		std::shared_ptr<IWifiApIface> iface;
		if (!configureChipToSupportConcurrencyTypeInternal(wifi_chip, IfaceConcurrencyType::AP)) {
		return nullptr;
		}
		auto status = wifi_chip->createApOrBridgedApIfaceWithParams(params, &iface);
		if (!status.isOk()) {
		return nullptr;
		}
		return iface;
		}

wifi/aidl/vts/functional/wifi_aidl_test_utils.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -43,6 +43,8 @@ std::shared_ptr<IWifiApIface> getWifiApIface(const char* instance_name);
		std::shared_ptr<IWifiApIface> getWifiApIface(std::shared_ptr<IWifiChip> wifi_chip);
		std::shared_ptr<IWifiApIface> getBridgedWifiApIface(const char* instance_name);
		std::shared_ptr<IWifiApIface> getBridgedWifiApIface(std::shared_ptr<IWifiChip> wifi_chip);
		std::shared_ptr<IWifiApIface> getWifiApOrBridgedApIface(std::shared_ptr<IWifiChip> wifi_chip,
		IWifiChip::ApIfaceParams params);
		// Configure the chip in a mode to support the creation of the provided iface type.
		bool configureChipToSupportConcurrencyType(const std::shared_ptr<IWifiChip>& wifi_chip,
		IfaceConcurrencyType type, int* configured_mode_id);
		@@ -57,3 +59,7 @@ bool isAidlServiceAvailable(const char* instance_name);
		// Generate test vendor data.
		std::vector<OuiKeyedData> generateOuiKeyedDataList(int size);
		std::optional<std::vector<std::optional<OuiKeyedData>>> generateOuiKeyedDataListOptional(int size);

		// Generate test ApIfaceParams
		IWifiChip::ApIfaceParams generateApIfaceParams(IfaceConcurrencyType type, bool uses_mlo,
		int oui_size);

wifi/aidl/vts/functional/wifi_chip_aidl_test.cpp

+85 −0

Original line number	Diff line number	Diff line
		@@ -52,6 +52,7 @@ class WifiChipAidlTest : public testing::TestWithParam<std::string> {
		stopWifiService(getInstanceName());
		wifi_chip_ = getWifiChip(getInstanceName());
		ASSERT_NE(nullptr, wifi_chip_.get());
		ASSERT_TRUE(wifi_chip_->getInterfaceVersion(&interface_version_).isOk());
		}

		void TearDown() override { stopWifiService(getInstanceName()); }
		@@ -139,6 +140,7 @@ class WifiChipAidlTest : public testing::TestWithParam<std::string> {
		const char* getInstanceName() { return GetParam().c_str(); }

		std::shared_ptr<IWifiChip> wifi_chip_;
		int interface_version_;
		};

		class WifiChipEventCallback : public BnWifiChipEventCallback {
		@@ -902,6 +904,89 @@ TEST_P(WifiChipAidlTest, SetVoipMode_voice) {
		}
		}

		/**
		* CreateApOrBridgedApIfaceWithParams for signal ap.
		*/
		TEST_P(WifiChipAidlTest, CreateApOrBridgedApIfaceWithParams_signal_ap) {
		if (interface_version_ < 3) {
		GTEST_SKIP() << "CreateApOrBridgedApIfaceWithParams is available as of WifiChip V3";
		}
		if (!isConcurrencyTypeSupported(IfaceConcurrencyType::AP)) {
		GTEST_SKIP() << "AP is not supported";
		}

		std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
		ASSERT_NE(nullptr, wifi_chip.get());
		std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApOrBridgedApIface(
		wifi_chip, generateApIfaceParams(IfaceConcurrencyType::AP, false, 0));
		ASSERT_NE(nullptr, wifi_ap_iface.get());
		}

		/**
		* CreateApOrBridgedApIfaceWithParams for non mlo bridged ap.
		*/
		TEST_P(WifiChipAidlTest, CreateApOrBridgedApIfaceWithParams_non_mlo_bridged_ap) {
		if (interface_version_ < 3) {
		GTEST_SKIP() << "CreateApOrBridgedApIfaceWithParams is available as of WifiChip V3";
		}
		bool isBridgedSupport = testing::checkSubstringInCommandOutput(
		"/system/bin/cmd wifi get-softap-supported-features",
		"wifi_softap_bridged_ap_supported");
		if (!isBridgedSupport) {
		GTEST_SKIP() << "Missing Bridged AP support";
		}

		std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
		ASSERT_NE(nullptr, wifi_chip.get());
		std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApOrBridgedApIface(
		wifi_chip, generateApIfaceParams(IfaceConcurrencyType::AP_BRIDGED, false, 0));
		ASSERT_NE(nullptr, wifi_ap_iface.get());

		std::string br_name;
		std::vector<std::string> instances;
		bool uses_mlo;
		EXPECT_TRUE(wifi_ap_iface->getName(&br_name).isOk());
		EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
		EXPECT_TRUE(wifi_ap_iface->usesMlo(&uses_mlo).isOk());
		EXPECT_FALSE(uses_mlo);
		EXPECT_EQ(instances.size(), 2);
		}

		/**
		* CreateApOrBridgedApIfaceWithParams for mlo bridged ap.
		*/
		TEST_P(WifiChipAidlTest, CreateApOrBridgedApIfaceWithParams_mlo_bridged_ap) {
		if (interface_version_ < 3) {
		GTEST_SKIP() << "CreateApOrBridgedApIfaceWithParams is available as of WifiChip V3";
		}
		bool isBridgedSupport = testing::checkSubstringInCommandOutput(
		"/system/bin/cmd wifi get-softap-supported-features",
		"wifi_softap_bridged_ap_supported");
		if (!isBridgedSupport) {
		GTEST_SKIP() << "Missing Bridged AP support";
		}

		configureChipForConcurrencyType(IfaceConcurrencyType::STA);
		int32_t features = getChipFeatureSet(wifi_chip_);
		if (!(features & static_cast<int32_t>(IWifiChip::FeatureSetMask::MLO_SAP))) {
		GTEST_SKIP() << "MLO_SAP is not supported by vendor.";
		}
		std::shared_ptr<IWifiChip> wifi_chip = getWifiChip(getInstanceName());
		ASSERT_NE(nullptr, wifi_chip.get());
		std::shared_ptr<IWifiApIface> wifi_ap_iface = getWifiApOrBridgedApIface(
		wifi_chip, generateApIfaceParams(IfaceConcurrencyType::AP_BRIDGED, true, 0));
		ASSERT_NE(nullptr, wifi_ap_iface.get());

		std::string br_name;
		std::vector<std::string> instances;
		bool uses_mlo;
		EXPECT_TRUE(wifi_ap_iface->getName(&br_name).isOk());
		EXPECT_TRUE(wifi_ap_iface->getBridgedInstances(&instances).isOk());
		EXPECT_TRUE(wifi_ap_iface->usesMlo(&uses_mlo).isOk());
		EXPECT_TRUE(uses_mlo);
		EXPECT_EQ(instances.size(), 2);
		}

		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiChipAidlTest);
		INSTANTIATE_TEST_SUITE_P(WifiTest, WifiChipAidlTest,
		testing::ValuesIn(android::getAidlHalInstanceNames(IWifi::descriptor)),