Add VTS tests for Supplicant P2P networks. (eeba2df5) · Commits · e / os / android_hardware_interfaces

wifi/supplicant/aidl/vts/functional/Android.bp

+38 −0

Original line number	Diff line number	Diff line
		@@ -137,3 +137,41 @@ cc_test {
		"vts",
		],
		}

		cc_test {
		name: "VtsHalWifiSupplicantP2pNetworkTargetTest",
		defaults: [
		"VtsHalTargetTestDefaults",
		"use_libaidlvintf_gtest_helper_static",
		],
		srcs: ["supplicant_p2p_network_aidl_test.cpp"],
		shared_libs: [
		"libbinder",
		"libbinder_ndk",
		"libvndksupport",
		],
		static_libs: [
		"android.hardware.wifi@1.0",
		"android.hardware.wifi@1.1",
		"android.hardware.wifi@1.2",
		"android.hardware.wifi@1.3",
		"android.hardware.wifi@1.4",
		"android.hardware.wifi@1.5",
		"android.hardware.wifi.common-V2-ndk",
		"android.hardware.wifi.supplicant@1.0",
		"android.hardware.wifi.supplicant@1.1",
		"android.hardware.wifi.supplicant-V4-ndk",
		"libwifi-system",
		"libwifi-system-iface",
		"VtsHalWifiV1_0TargetTestUtil",
		"VtsHalWifiV1_5TargetTestUtil",
		"VtsHalWifiSupplicantV1_0TargetTestUtil",
		"android.hardware.wifi.common-V2-ndk",
		"android.hardware.wifi-V3-ndk",
		"VtsHalWifiTargetTestUtil",
		],
		test_suites: [
		"general-tests",
		"vts",
		],
		}

wifi/supplicant/aidl/vts/functional/supplicant_p2p_iface_aidl_test.cpp

+19 −0

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@ using aidl::android::hardware::wifi::supplicant::FreqRange;
		using aidl::android::hardware::wifi::supplicant::IfaceType;
		using aidl::android::hardware::wifi::supplicant::ISupplicant;
		using aidl::android::hardware::wifi::supplicant::ISupplicantP2pIface;
		using aidl::android::hardware::wifi::supplicant::ISupplicantP2pNetwork;
		using aidl::android::hardware::wifi::supplicant::MiracastMode;
		using aidl::android::hardware::wifi::supplicant::P2pAddGroupConfigurationParams;
		using aidl::android::hardware::wifi::supplicant::P2pConnectInfo;
		@@ -981,6 +982,24 @@ TEST_P(SupplicantP2pIfaceAidlTest, ReinvokePersistentGroup) {
		EXPECT_TRUE(p2p_iface_->reinvokePersistentGroup(params).isOk());
		}

		/*
		* Test the P2P network management functions.
		*/
		TEST_P(SupplicantP2pIfaceAidlTest, ManageNetworks) {
		std::shared_ptr<ISupplicantP2pNetwork> network;
		EXPECT_TRUE(p2p_iface_->addNetwork(&network).isOk());
		ASSERT_NE(network, nullptr);

		std::vector<int32_t> networkList;
		EXPECT_TRUE(p2p_iface_->listNetworks(&networkList).isOk());
		ASSERT_FALSE(networkList.empty());

		int networkId = networkList[0];
		EXPECT_TRUE(p2p_iface_->getNetwork(networkId, &network).isOk());
		ASSERT_NE(network, nullptr);
		EXPECT_TRUE(p2p_iface_->removeNetwork(networkId).isOk());
		}

		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SupplicantP2pIfaceAidlTest);
		INSTANTIATE_TEST_SUITE_P(Supplicant, SupplicantP2pIfaceAidlTest,
		testing::ValuesIn(android::getAidlHalInstanceNames(

wifi/supplicant/aidl/vts/functional/supplicant_p2p_network_aidl_test.cpp

0 → 100644

+165 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2025 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 <VtsCoreUtil.h>
		#include <aidl/Gtest.h>
		#include <aidl/Vintf.h>
		#include <aidl/android/hardware/wifi/supplicant/BnSupplicant.h>
		#include <android/binder_manager.h>
		#include <android/binder_status.h>
		#include <binder/IServiceManager.h>
		#include <binder/ProcessState.h>
		#include <cutils/properties.h>

		#include "supplicant_test_utils.h"
		#include "wifi_aidl_test_utils.h"

		using aidl::android::hardware::wifi::supplicant::DebugLevel;
		using aidl::android::hardware::wifi::supplicant::IfaceType;
		using aidl::android::hardware::wifi::supplicant::ISupplicantP2pNetwork;
		using aidl::android::hardware::wifi::supplicant::MacAddress;
		using android::ProcessState;

		class SupplicantP2pNetworkAidlTest : public testing::TestWithParam<std::string> {
		public:
		void SetUp() override {
		initializeService();
		supplicant_ = getSupplicant(GetParam().c_str());
		ASSERT_NE(supplicant_, nullptr);
		ASSERT_TRUE(supplicant_->setDebugParams(DebugLevel::EXCESSIVE, true, true).isOk());

		bool p2pEnabled = testing::deviceSupportsFeature("android.hardware.wifi.direct");
		if (!p2pEnabled) {
		GTEST_SKIP() << "Wi-Fi Direct is not supported, skip this test.";
		}

		EXPECT_TRUE(supplicant_->getP2pInterface(getP2pIfaceName(), &p2p_iface_).isOk());
		ASSERT_NE(p2p_iface_, nullptr);
		EXPECT_TRUE(p2p_iface_->addNetwork(&p2p_network_).isOk());
		ASSERT_NE(p2p_network_, nullptr);
		}

		void TearDown() override {
		stopSupplicantService();
		startWifiFramework();
		}

		protected:
		std::shared_ptr<ISupplicant> supplicant_;
		std::shared_ptr<ISupplicantP2pIface> p2p_iface_;
		std::shared_ptr<ISupplicantP2pNetwork> p2p_network_;
		};

		/*
		* GetBssid
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, GetBssid) {
		std::vector<uint8_t> bssid;
		EXPECT_TRUE(p2p_network_->getBssid(&bssid).isOk());
		}

		/*
		* GetClientList
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, GetClientList) {
		// Expect failure if there are no clients
		std::vector<MacAddress> clientList;
		EXPECT_FALSE(p2p_network_->getClientList(&clientList).isOk());
		}

		/*
		* GetId
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, GetId) {
		int networkId;
		EXPECT_TRUE(p2p_network_->getId(&networkId).isOk());
		}

		/*
		* GetInterfaceName
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, GetInterfaceName) {
		std::string expectedName = getP2pIfaceName();
		std::string retrievedName;
		EXPECT_TRUE(p2p_network_->getInterfaceName(&retrievedName).isOk());
		EXPECT_EQ(retrievedName, expectedName);
		}

		/*
		* GetSsid
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, GetSsid) {
		std::vector<uint8_t> ssid;
		EXPECT_TRUE(p2p_network_->getSsid(&ssid).isOk());
		}

		/*
		* GetType
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, GetType) {
		IfaceType ifaceType;
		EXPECT_TRUE(p2p_network_->getType(&ifaceType).isOk());
		EXPECT_EQ(ifaceType, IfaceType::P2P);
		}

		/*
		* IsCurrent
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, IsCurrent) {
		bool isCurrent;
		EXPECT_TRUE(p2p_network_->isCurrent(&isCurrent).isOk());
		EXPECT_FALSE(isCurrent);
		}

		/*
		* IsGroupOwner
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, IsGroupOwner) {
		bool isGroupOwner;
		EXPECT_TRUE(p2p_network_->isGroupOwner(&isGroupOwner).isOk());
		EXPECT_FALSE(isGroupOwner);
		}

		/*
		* IsPersistent
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, IsPersistent) {
		bool isPersistent;
		EXPECT_TRUE(p2p_network_->isPersistent(&isPersistent).isOk());
		EXPECT_FALSE(isPersistent);
		}

		/*
		* SetClientList
		*/
		TEST_P(SupplicantP2pNetworkAidlTest, SetClientList) {
		MacAddress client = {{0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}};
		std::vector clientList = {client};
		EXPECT_TRUE(p2p_network_->setClientList(clientList).isOk());
		}

		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SupplicantP2pNetworkAidlTest);
		INSTANTIATE_TEST_SUITE_P(
		Supplicant, SupplicantP2pNetworkAidlTest,
		testing::ValuesIn(android::getAidlHalInstanceNames(ISupplicant::descriptor)),
		android::PrintInstanceNameToString);

		int main(int argc, char** argv) {
		::testing::InitGoogleTest(&argc, argv);
		ProcessState::self()->setThreadPoolMaxThreadCount(1);
		ProcessState::self()->startThreadPool();
		return RUN_ALL_TESTS();
		}