Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:50:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "Wifi: Add VTS tests for Vendor HAL 1.6" into tm-dev

Browse Source
This commit is contained in:
Ahmed ElArabawy
2022-02-18 22:22:52 +00:00
committed by Android (Google) Code Review
parent 98112251b1 b2c8852cba
commit 25692880c0
6 changed files with 1215 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
wifi/1.6/vts/OWNERS Normal file
View File

@@ -0,0 +1,2 @@
# Bug component: 33618
include ../../1.0/vts/OWNERS

98
wifi/1.6/vts/functional/Android.bp Normal file
View File

@@ -0,0 +1,98 @@
//
// Copyright (C) 2022 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.
//
package {
// See: http://go/android-license-faq
// A large-scale-change added 'default_applicable_licenses' to import
// all of the 'license_kinds' from "hardware_interfaces_license"
// to get the below license kinds:
// SPDX-license-identifier-Apache-2.0
default_applicable_licenses: ["hardware_interfaces_license"],
}
cc_test {
name: "VtsHalWifiV1_6TargetTest",
defaults: ["VtsHalTargetTestDefaults"],
srcs: [
"wifi_chip_hidl_test.cpp",
"wifi_sta_iface_hidl_test.cpp",
],
static_libs: [
"VtsHalWifiV1_0TargetTestUtil",
"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@1.6",
"libwifi-system-iface",
],
test_suites: [
"general-tests",
"vts",
],
}
// These tests are split out so that they can be conditioned on presence of the
// "android.hardware.wifi.rtt" feature.
cc_test {
name: "VtsHalWifiRttV1_6TargetTest",
defaults: ["VtsHalTargetTestDefaults"],
srcs: [
"wifi_rtt_controller_hidl_test.cpp",
],
static_libs: [
"VtsHalWifiV1_0TargetTestUtil",
"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@1.6",
"libwifi-system-iface",
],
test_suites: [
"general-tests",
"vts",
],
}
// These tests are split out so that they can be conditioned on presence of the
// "android.hardware.wifi.aware" feature.
cc_test {
name: "VtsHalWifiNanV1_6TargetTest",
defaults: ["VtsHalTargetTestDefaults"],
srcs: [
"wifi_nan_iface_hidl_test.cpp",
],
static_libs: [
"VtsHalWifiV1_0TargetTestUtil",
"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@1.6",
"libwifi-system-iface",
],
test_suites: [
"general-tests",
"vts",
],
}

102
wifi/1.6/vts/functional/wifi_chip_hidl_test.cpp Normal file
View File

@@ -0,0 +1,102 @@
/*
* Copyright (C) 2022 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 <VtsHalHidlTargetCallbackBase.h>
#include <android-base/logging.h>
#undef NAN // NAN is defined in bionic/libc/include/math.h:38
#include <android/hardware/wifi/1.4/IWifiChipEventCallback.h>
#include <android/hardware/wifi/1.6/IWifi.h>
#include <android/hardware/wifi/1.6/IWifiChip.h>
#include <android/hardware/wifi/1.6/IWifiStaIface.h>
#include <gtest/gtest.h>
#include <hidl/GtestPrinter.h>
#include <hidl/ServiceManagement.h>
#include "wifi_hidl_call_util.h"
#include "wifi_hidl_test_utils.h"
using ::android::sp;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::wifi::V1_0::ChipModeId;
using ::android::hardware::wifi::V1_0::IfaceType;
using ::android::hardware::wifi::V1_0::IWifiIface;
using ::android::hardware::wifi::V1_0::IWifiStaIface;
using ::android::hardware::wifi::V1_0::WifiDebugRingBufferStatus;
using ::android::hardware::wifi::V1_0::WifiStatus;
using ::android::hardware::wifi::V1_0::WifiStatusCode;
using ::android::hardware::wifi::V1_4::IWifiChipEventCallback;
using ::android::hardware::wifi::V1_5::WifiBand;
using ::android::hardware::wifi::V1_5::WifiIfaceMode;
using ::android::hardware::wifi::V1_6::IWifiChip;
/**
* Fixture to use for all Wifi chip HIDL interface tests.
*/
class WifiChipHidlTest : public ::testing::TestWithParam<std::string> {
public:
virtual void SetUp() override {
// Make sure to start with a clean state
stopWifi(GetInstanceName());
wifi_chip_ = IWifiChip::castFrom(getWifiChip(GetInstanceName()));
ASSERT_NE(nullptr, wifi_chip_.get());
}
virtual void TearDown() override { stopWifi(GetInstanceName()); }
protected:
// Helper function to configure the Chip in one of the supported modes.
// Most of the non-mode-configuration-related methods require chip
// to be first configured.
ChipModeId configureChipForIfaceType(IfaceType type, bool expectSuccess) {
ChipModeId mode_id;
EXPECT_EQ(expectSuccess, configureChipToSupportIfaceType(wifi_chip_, type, &mode_id));
return mode_id;
}
sp<IWifiChip> wifi_chip_;
private:
std::string GetInstanceName() { return GetParam(); }
};
/* getUsableChannels_1_6:
* Ensure that a call to getUsableChannels_1_6 will return with a success
* status for valid inputs.
*/
TEST_P(WifiChipHidlTest, getUsableChannels_1_6) {
uint32_t ifaceModeMask =
WifiIfaceMode::IFACE_MODE_P2P_CLIENT | WifiIfaceMode::IFACE_MODE_P2P_GO;
uint32_t filterMask = IWifiChip::UsableChannelFilter::CELLULAR_COEXISTENCE |
IWifiChip::UsableChannelFilter::CONCURRENCY;
configureChipForIfaceType(IfaceType::STA, true);
WifiBand band = WifiBand::BAND_24GHZ_5GHZ_6GHZ;
const auto& statusNonEmpty =
HIDL_INVOKE(wifi_chip_, getUsableChannels_1_6, band, ifaceModeMask, filterMask);
EXPECT_EQ(WifiStatusCode::SUCCESS, statusNonEmpty.first.code);
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiChipHidlTest);
INSTANTIATE_TEST_SUITE_P(PerInstance, WifiChipHidlTest,
testing::ValuesIn(android::hardware::getAllHalInstanceNames(
::android::hardware::wifi::V1_6::IWifi::descriptor)),
android::hardware::PrintInstanceNameToString);

611
wifi/1.6/vts/functional/wifi_nan_iface_hidl_test.cpp Normal file
View File

@@ -0,0 +1,611 @@
/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Nanache 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 <android-base/logging.h>
#include <VtsCoreUtil.h>
#include <android/hardware/wifi/1.6/IWifi.h>
#include <android/hardware/wifi/1.6/IWifiNanIface.h>
#include <android/hardware/wifi/1.6/IWifiNanIfaceEventCallback.h>
#include <gtest/gtest.h>
#include <hidl/GtestPrinter.h>
#include <hidl/ServiceManagement.h>
#include <chrono>
#include <condition_variable>
#include <mutex>
#include "wifi_hidl_call_util.h"
#include "wifi_hidl_test_utils.h"
using namespace ::android::hardware::wifi::V1_0;
using namespace ::android::hardware::wifi::V1_2;
using namespace ::android::hardware::wifi::V1_4;
using namespace ::android::hardware::wifi::V1_5;
using namespace ::android::hardware::wifi::V1_6;
using ::android::sp;
using ::android::hardware::Return;
using ::android::hardware::Void;
#define TIMEOUT_PERIOD 10
android::sp<android::hardware::wifi::V1_6::IWifiNanIface> getWifiNanIface_1_6(
const std::string& instance_name) {
return android::hardware::wifi::V1_6::IWifiNanIface::castFrom(getWifiNanIface(instance_name));
}
/**
* Fixture to use for all NAN Iface HIDL interface tests.
*/
class WifiNanIfaceHidlTest : public ::testing::TestWithParam<std::string> {
public:
virtual void SetUp() override {
if (!::testing::deviceSupportsFeature("android.hardware.wifi.aware"))
GTEST_SKIP() << "Skipping this test since NAN is not supported.";
// Make sure to start with a clean state
stopWifi(GetInstanceName());
iwifiNanIface = getWifiNanIface_1_6(GetInstanceName());
ASSERT_NE(nullptr, iwifiNanIface.get());
ASSERT_EQ(WifiStatusCode::SUCCESS, HIDL_INVOKE(iwifiNanIface, registerEventCallback_1_6,
new WifiNanIfaceEventCallback(*this))
.code);
}
virtual void TearDown() override { stopWifi(GetInstanceName()); }
/* Used as a mechanism to inform the test about data/event callback */
inline void notify() {
std::unique_lock<std::mutex> lock(mtx_);
count_++;
cv_.notify_one();
}
enum CallbackType {
INVALID = -2,
ANY_CALLBACK = -1,
NOTIFY_CAPABILITIES_RESPONSE = 0,
NOTIFY_ENABLE_RESPONSE,
NOTIFY_CONFIG_RESPONSE,
NOTIFY_DISABLE_RESPONSE,
NOTIFY_START_PUBLISH_RESPONSE,
NOTIFY_STOP_PUBLISH_RESPONSE,
NOTIFY_START_SUBSCRIBE_RESPONSE,
NOTIFY_STOP_SUBSCRIBE_RESPONSE,
NOTIFY_TRANSMIT_FOLLOWUP_RESPONSE,
NOTIFY_CREATE_DATA_INTERFACE_RESPONSE,
NOTIFY_DELETE_DATA_INTERFACE_RESPONSE,
NOTIFY_INITIATE_DATA_PATH_RESPONSE,
NOTIFY_RESPOND_TO_DATA_PATH_INDICATION_RESPONSE,
NOTIFY_TERMINATE_DATA_PATH_RESPONSE,
NOTIFY_CAPABILITIES_RESPONSE_1_5,
NOTIFY_CAPABILITIES_RESPONSE_1_6,
EVENT_CLUSTER_EVENT,
EVENT_DISABLED,
EVENT_PUBLISH_TERMINATED,
EVENT_SUBSCRIBE_TERMINATED,
EVENT_MATCH,
EVENT_MATCH_EXPIRED,
EVENT_FOLLOWUP_RECEIVED,
EVENT_TRANSMIT_FOLLOWUP,
EVENT_DATA_PATH_REQUEST,
EVENT_DATA_PATH_CONFIRM,
EVENT_DATA_PATH_TERMINATED,
EVENT_DATA_PATH_CONFIRM_1_2,
EVENT_DATA_PATH_SCHEDULE_UPDATE,
EVENT_MATCH_1_6,
EVENT_DATA_PATH_SCHEDULE_UPDATE_1_6,
EVENT_DATA_PATH_CONFIRM_1_6,
};
/* Test code calls this function to wait for data/event callback */
/* Must set callbackType = INVALID before call this function */
inline std::cv_status wait(CallbackType waitForCallbackType) {
std::unique_lock<std::mutex> lock(mtx_);
EXPECT_NE(INVALID, waitForCallbackType); // can't ASSERT in a
// non-void-returning method
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(TIMEOUT_PERIOD));
if (status == std::cv_status::timeout) return status;
if (waitForCallbackType != ANY_CALLBACK && callbackType != INVALID &&
callbackType != waitForCallbackType) {
count_--;
}
}
count_--;
return status;
}
class WifiNanIfaceEventCallback
: public ::android::hardware::wifi::V1_6::IWifiNanIfaceEventCallback {
WifiNanIfaceHidlTest& parent_;
public:
WifiNanIfaceEventCallback(WifiNanIfaceHidlTest& parent) : parent_(parent){};
virtual ~WifiNanIfaceEventCallback() = default;
Return<void> notifyCapabilitiesResponse(
uint16_t id, const WifiNanStatus& status,
const ::android::hardware::wifi::V1_0::NanCapabilities& capabilities) override {
parent_.callbackType = NOTIFY_CAPABILITIES_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.capabilities = capabilities;
parent_.notify();
return Void();
}
Return<void> notifyCapabilitiesResponse_1_5(
uint16_t id, const WifiNanStatus& status,
const ::android::hardware::wifi::V1_5::NanCapabilities& capabilities) override {
parent_.callbackType = NOTIFY_CAPABILITIES_RESPONSE_1_5;
parent_.id = id;
parent_.status = status;
parent_.capabilities_1_5 = capabilities;
parent_.notify();
return Void();
}
Return<void> notifyEnableResponse(uint16_t id, const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_ENABLE_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> notifyConfigResponse(uint16_t id, const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_CONFIG_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> notifyDisableResponse(uint16_t id, const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_DISABLE_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> notifyStartPublishResponse(uint16_t id, const WifiNanStatus& status,
uint8_t sessionId) override {
parent_.callbackType = NOTIFY_START_PUBLISH_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.sessionId = sessionId;
parent_.notify();
return Void();
}
Return<void> notifyStopPublishResponse(uint16_t id, const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_STOP_PUBLISH_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> notifyStartSubscribeResponse(uint16_t id, const WifiNanStatus& status,
uint8_t sessionId) override {
parent_.callbackType = NOTIFY_START_SUBSCRIBE_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.sessionId = sessionId;
parent_.notify();
return Void();
}
Return<void> notifyStopSubscribeResponse(uint16_t id,
const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_STOP_SUBSCRIBE_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> notifyTransmitFollowupResponse(uint16_t id,
const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_TRANSMIT_FOLLOWUP_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> notifyCreateDataInterfaceResponse(uint16_t id,
const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_CREATE_DATA_INTERFACE_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> notifyDeleteDataInterfaceResponse(uint16_t id,
const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_DELETE_DATA_INTERFACE_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> notifyInitiateDataPathResponse(uint16_t id, const WifiNanStatus& status,
uint32_t ndpInstanceId) override {
parent_.callbackType = NOTIFY_INITIATE_DATA_PATH_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.ndpInstanceId = ndpInstanceId;
parent_.notify();
return Void();
}
Return<void> notifyRespondToDataPathIndicationResponse(
uint16_t id, const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_RESPOND_TO_DATA_PATH_INDICATION_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> notifyTerminateDataPathResponse(uint16_t id,
const WifiNanStatus& status) override {
parent_.callbackType = NOTIFY_TERMINATE_DATA_PATH_RESPONSE;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> eventClusterEvent(const NanClusterEventInd& event) override {
parent_.callbackType = EVENT_CLUSTER_EVENT;
parent_.nanClusterEventInd = event;
parent_.notify();
return Void();
}
Return<void> eventDisabled(const WifiNanStatus& status) override {
parent_.callbackType = EVENT_DISABLED;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> eventPublishTerminated(uint8_t sessionId,
const WifiNanStatus& status) override {
parent_.callbackType = EVENT_PUBLISH_TERMINATED;
parent_.sessionId = sessionId;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> eventSubscribeTerminated(uint8_t sessionId,
const WifiNanStatus& status) override {
parent_.callbackType = EVENT_SUBSCRIBE_TERMINATED;
parent_.sessionId = sessionId;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> eventMatch(
const ::android::hardware::wifi::V1_0::NanMatchInd& event) override {
parent_.callbackType = EVENT_MATCH;
parent_.nanMatchInd = event;
parent_.notify();
return Void();
}
Return<void> eventMatchExpired(uint8_t discoverySessionId, uint32_t peerId) override {
parent_.callbackType = EVENT_MATCH_EXPIRED;
parent_.sessionId = discoverySessionId;
parent_.peerId = peerId;
parent_.notify();
return Void();
}
Return<void> eventFollowupReceived(const NanFollowupReceivedInd& event) override {
parent_.callbackType = EVENT_FOLLOWUP_RECEIVED;
parent_.nanFollowupReceivedInd = event;
parent_.notify();
return Void();
}
Return<void> eventTransmitFollowup(uint16_t id, const WifiNanStatus& status) override {
parent_.callbackType = EVENT_TRANSMIT_FOLLOWUP;
parent_.id = id;
parent_.status = status;
parent_.notify();
return Void();
}
Return<void> eventDataPathRequest(const NanDataPathRequestInd& event) override {
parent_.callbackType = EVENT_DATA_PATH_REQUEST;
parent_.nanDataPathRequestInd = event;
parent_.notify();
return Void();
}
Return<void> eventDataPathConfirm(
const ::android::hardware::wifi::V1_0::NanDataPathConfirmInd& event) override {
parent_.callbackType = EVENT_DATA_PATH_CONFIRM;
parent_.nanDataPathConfirmInd = event;
parent_.notify();
return Void();
}
Return<void> eventDataPathTerminated(uint32_t ndpInstanceId) override {
parent_.callbackType = EVENT_DATA_PATH_TERMINATED;
parent_.ndpInstanceId = ndpInstanceId;
parent_.notify();
return Void();
}
Return<void> eventDataPathConfirm_1_2(
const ::android::hardware::wifi::V1_2::NanDataPathConfirmInd& event) override {
parent_.callbackType = EVENT_DATA_PATH_CONFIRM_1_2;
parent_.nanDataPathConfirmInd_1_2 = event;
parent_.notify();
return Void();
}
Return<void> eventDataPathScheduleUpdate(
const ::android::hardware::wifi::V1_2::NanDataPathScheduleUpdateInd& event)
override {
parent_.callbackType = EVENT_DATA_PATH_SCHEDULE_UPDATE;
parent_.nanDataPathScheduleUpdateInd_1_2 = event;
parent_.notify();
return Void();
}
Return<void> eventMatch_1_6(
const ::android::hardware::wifi::V1_6::NanMatchInd& event) override {
parent_.callbackType = EVENT_MATCH_1_6;
parent_.nanMatchInd_1_6 = event;
parent_.notify();
return Void();
}
Return<void> notifyCapabilitiesResponse_1_6(
uint16_t id, const WifiNanStatus& status,
const ::android::hardware::wifi::V1_6::NanCapabilities& capabilities) override {
parent_.callbackType = NOTIFY_CAPABILITIES_RESPONSE_1_6;
parent_.id = id;
parent_.status = status;
parent_.capabilities_1_6 = capabilities;
parent_.notify();
return Void();
}
Return<void> eventDataPathScheduleUpdate_1_6(
const ::android::hardware::wifi::V1_6::NanDataPathScheduleUpdateInd& event)
override {
parent_.callbackType = EVENT_DATA_PATH_SCHEDULE_UPDATE_1_6;
parent_.nanDataPathScheduleUpdateInd_1_6 = event;
parent_.notify();
return Void();
}
Return<void> eventDataPathConfirm_1_6(
const ::android::hardware::wifi::V1_6::NanDataPathConfirmInd& event) override {
parent_.callbackType = EVENT_DATA_PATH_CONFIRM_1_6;
parent_.nanDataPathConfirmInd_1_6 = event;
parent_.notify();
return Void();
}
};
private:
// synchronization objects
std::mutex mtx_;
std::condition_variable cv_;
int count_ = 0;
protected:
android::sp<::android::hardware::wifi::V1_6::IWifiNanIface> iwifiNanIface;
// Data from IWifiNanIfaceEventCallback callbacks: this is the collection of
// all arguments to all callbacks. They are set by the callback
// (notifications or events) and can be retrieved by tests.
CallbackType callbackType;
uint16_t id;
WifiNanStatus status;
uint8_t sessionId;
uint32_t ndpInstanceId;
NanClusterEventInd nanClusterEventInd;
::android::hardware::wifi::V1_0::NanMatchInd nanMatchInd;
::android::hardware::wifi::V1_6::NanMatchInd nanMatchInd_1_6;
uint32_t peerId;
NanFollowupReceivedInd nanFollowupReceivedInd;
NanDataPathRequestInd nanDataPathRequestInd;
::android::hardware::wifi::V1_0::NanCapabilities capabilities;
::android::hardware::wifi::V1_5::NanCapabilities capabilities_1_5;
::android::hardware::wifi::V1_6::NanCapabilities capabilities_1_6;
::android::hardware::wifi::V1_0::NanDataPathConfirmInd nanDataPathConfirmInd;
::android::hardware::wifi::V1_2::NanDataPathConfirmInd nanDataPathConfirmInd_1_2;
::android::hardware::wifi::V1_6::NanDataPathConfirmInd nanDataPathConfirmInd_1_6;
::android::hardware::wifi::V1_2::NanDataPathScheduleUpdateInd nanDataPathScheduleUpdateInd_1_2;
::android::hardware::wifi::V1_6::NanDataPathScheduleUpdateInd nanDataPathScheduleUpdateInd_1_6;
std::string GetInstanceName() { return GetParam(); }
};
/*
* Create:
* Ensures that an instance of the IWifiNanIface proxy object is
* successfully created.
*/
TEST_P(WifiNanIfaceHidlTest, Create) {
// The creation of a proxy object is tested as part of SetUp method.
}
/*
* enableRequest_1_6InvalidArgs: validate that fails with invalid arguments
*/
TEST_P(WifiNanIfaceHidlTest, enableRequest_1_6InvalidArgs) {
uint16_t inputCmdId = 10;
callbackType = INVALID;
::android::hardware::wifi::V1_4::NanEnableRequest nanEnableRequest = {};
::android::hardware::wifi::V1_6::NanConfigRequestSupplemental nanConfigRequestSupp = {};
const auto& halStatus = HIDL_INVOKE(iwifiNanIface, enableRequest_1_6, inputCmdId,
nanEnableRequest, nanConfigRequestSupp);
if (halStatus.code != WifiStatusCode::ERROR_NOT_SUPPORTED) {
ASSERT_EQ(WifiStatusCode::SUCCESS, halStatus.code);
// wait for a callback
ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_ENABLE_RESPONSE));
ASSERT_EQ(NOTIFY_ENABLE_RESPONSE, callbackType);
ASSERT_EQ(id, inputCmdId);
ASSERT_EQ(status.status, NanStatusType::INVALID_ARGS);
}
}
/*
* enableRequest_1_6ShimInvalidArgs: validate that fails with invalid arguments
* to the shim
*/
TEST_P(WifiNanIfaceHidlTest, enableRequest_1_6ShimInvalidArgs) {
uint16_t inputCmdId = 10;
::android::hardware::wifi::V1_4::NanEnableRequest nanEnableRequest = {};
nanEnableRequest.configParams.numberOfPublishServiceIdsInBeacon = 128; // must be <= 127
::android::hardware::wifi::V1_6::NanConfigRequestSupplemental nanConfigRequestSupp = {};
const auto& halStatus = HIDL_INVOKE(iwifiNanIface, enableRequest_1_6, inputCmdId,
nanEnableRequest, nanConfigRequestSupp);
if (halStatus.code != WifiStatusCode::ERROR_NOT_SUPPORTED) {
ASSERT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, halStatus.code);
}
}
/*
* configRequest_1_6InvalidArgs: validate that fails with invalid arguments
*/
TEST_P(WifiNanIfaceHidlTest, configRequest_1_6InvalidArgs) {
uint16_t inputCmdId = 10;
callbackType = INVALID;
::android::hardware::wifi::V1_4::NanConfigRequest nanConfigRequest = {};
::android::hardware::wifi::V1_6::NanConfigRequestSupplemental nanConfigRequestSupp = {};
const auto& halStatus = HIDL_INVOKE(iwifiNanIface, configRequest_1_6, inputCmdId,
nanConfigRequest, nanConfigRequestSupp);
if (halStatus.code != WifiStatusCode::ERROR_NOT_SUPPORTED) {
ASSERT_EQ(WifiStatusCode::SUCCESS, halStatus.code);
// wait for a callback
ASSERT_EQ(std::cv_status::no_timeout, wait(NOTIFY_CONFIG_RESPONSE));
ASSERT_EQ(NOTIFY_CONFIG_RESPONSE, callbackType);
ASSERT_EQ(id, inputCmdId);
ASSERT_EQ(status.status, NanStatusType::INVALID_ARGS);
}
}
/*
* configRequest_1_6ShimInvalidArgs: validate that fails with invalid arguments
* to the shim
*/
TEST_P(WifiNanIfaceHidlTest, configRequest_1_6ShimInvalidArgs) {
uint16_t inputCmdId = 10;
::android::hardware::wifi::V1_4::NanConfigRequest nanConfigRequest = {};
nanConfigRequest.numberOfPublishServiceIdsInBeacon = 128; // must be <= 127
::android::hardware::wifi::V1_6::NanConfigRequestSupplemental nanConfigRequestSupp = {};
const auto& halStatus = HIDL_INVOKE(iwifiNanIface, configRequest_1_6, inputCmdId,
nanConfigRequest, nanConfigRequestSupp);
if (halStatus.code != WifiStatusCode::ERROR_NOT_SUPPORTED) {
ASSERT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, halStatus.code);
}
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiNanIfaceHidlTest);
INSTANTIATE_TEST_SUITE_P(PerInstance, WifiNanIfaceHidlTest,
testing::ValuesIn(android::hardware::getAllHalInstanceNames(
::android::hardware::wifi::V1_6::IWifi::descriptor)),
android::hardware::PrintInstanceNameToString);

295
wifi/1.6/vts/functional/wifi_rtt_controller_hidl_test.cpp Normal file
View File

@@ -0,0 +1,295 @@
/*
* Copyright (C) 2022 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 <VtsHalHidlTargetCallbackBase.h>
#include <android-base/logging.h>
#undef NAN // NAN is defined in bionic/libc/include/math.h:38
#include <VtsCoreUtil.h>
#include <android/hardware/wifi/1.6/IWifi.h>
#include <android/hardware/wifi/1.6/IWifiChip.h>
#include <android/hardware/wifi/1.6/IWifiRttController.h>
#include <android/hardware/wifi/1.6/IWifiRttControllerEventCallback.h>
#include <android/hardware/wifi/1.6/IWifiStaIface.h>
#include <gtest/gtest.h>
#include <hidl/GtestPrinter.h>
#include <hidl/ServiceManagement.h>
#include "wifi_hidl_call_util.h"
#include "wifi_hidl_test_utils.h"
using ::android::sp;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::wifi::V1_0::CommandId;
using ::android::hardware::wifi::V1_0::RttPeerType;
using ::android::hardware::wifi::V1_0::RttType;
using ::android::hardware::wifi::V1_0::WifiStatus;
using ::android::hardware::wifi::V1_0::WifiStatusCode;
using ::android::hardware::wifi::V1_6::IWifiChip;
using ::android::hardware::wifi::V1_6::IWifiRttController;
using ::android::hardware::wifi::V1_6::IWifiRttControllerEventCallback;
using ::android::hardware::wifi::V1_6::IWifiStaIface;
using ::android::hardware::wifi::V1_6::RttBw;
using ::android::hardware::wifi::V1_6::RttCapabilities;
using ::android::hardware::wifi::V1_6::RttConfig;
using ::android::hardware::wifi::V1_6::RttPreamble;
using ::android::hardware::wifi::V1_6::RttResponder;
using ::android::hardware::wifi::V1_6::RttResult;
using ::android::hardware::wifi::V1_6::WifiChannelInfo;
using ::android::hardware::wifi::V1_6::WifiChannelWidthInMhz;
/**
* Fixture to use for all RTT controller HIDL interface tests.
*/
class WifiRttControllerHidlTest : public ::testing::TestWithParam<std::string> {
public:
virtual void SetUp() override {
if (!::testing::deviceSupportsFeature("android.hardware.wifi.rtt"))
GTEST_SKIP() << "Skipping this test since RTT is not supported.";
// Make sure to start with a clean state
stopWifi(GetInstanceName());
wifi_rtt_controller_ = getWifiRttController();
ASSERT_NE(nullptr, wifi_rtt_controller_.get());
// Check RTT support before we run the test.
std::pair<WifiStatus, RttCapabilities> status_and_caps;
status_and_caps = HIDL_INVOKE(wifi_rtt_controller_, getCapabilities_1_6);
if (status_and_caps.first.code == WifiStatusCode::ERROR_NOT_SUPPORTED) {
GTEST_SKIP() << "Skipping this test since RTT is not supported.";
}
}
virtual void TearDown() override { stopWifi(GetInstanceName()); }
// A simple test implementation of WifiRttControllerEventCallback.
class WifiRttControllerEventCallback
: public ::testing::VtsHalHidlTargetCallbackBase<WifiRttControllerHidlTest>,
public IWifiRttControllerEventCallback {
public:
WifiRttControllerEventCallback(){};
virtual ~WifiRttControllerEventCallback() = default;
Return<void> onResults(CommandId cmdId __unused,
const hidl_vec<::android::hardware::wifi::V1_0::RttResult>& results
__unused) {
return Void();
};
Return<void> onResults_1_4(
CommandId cmdId __unused,
const hidl_vec<::android::hardware::wifi::V1_4::RttResult>& results __unused) {
return Void();
};
Return<void> onResults_1_6(CommandId cmdId __unused,
const hidl_vec<RttResult>& results __unused) {
return Void();
};
};
protected:
sp<IWifiRttController> wifi_rtt_controller_;
private:
std::string GetInstanceName() { return GetParam(); }
sp<IWifiRttController> getWifiRttController() {
const std::string& instance_name = GetInstanceName();
sp<IWifiChip> wifi_chip = IWifiChip::castFrom(getWifiChip(instance_name));
EXPECT_NE(nullptr, wifi_chip.get());
sp<IWifiStaIface> wifi_sta_iface = IWifiStaIface::castFrom(getWifiStaIface(instance_name));
EXPECT_NE(nullptr, wifi_sta_iface.get());
const auto& status_and_controller =
HIDL_INVOKE(wifi_chip, createRttController_1_6, wifi_sta_iface);
EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_controller.first.code);
EXPECT_NE(nullptr, status_and_controller.second.get());
return status_and_controller.second.get();
}
};
/*
* registerEventCallback_1_6
* This test case tests the registerEventCallback_1_6() API which registers
* a call back function with the hal implementation
*
* Note: it is not feasible to test the invocation of the call back function
* since event is triggered internally in the HAL implementation, and can not be
* triggered from the test case
*/
TEST_P(WifiRttControllerHidlTest, RegisterEventCallback_1_6) {
sp<WifiRttControllerEventCallback> wifiRttControllerEventCallback =
new WifiRttControllerEventCallback();
const auto& status = HIDL_INVOKE(wifi_rtt_controller_, registerEventCallback_1_6,
wifiRttControllerEventCallback);
EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
}
/*
* Request2SidedRangeMeasurement
* This test case tests the two sided ranging - 802.11mc FTM protocol.
*/
TEST_P(WifiRttControllerHidlTest, Request2SidedRangeMeasurement) {
std::pair<WifiStatus, RttCapabilities> status_and_caps;
// Get the Capabilities
status_and_caps = HIDL_INVOKE(wifi_rtt_controller_, getCapabilities_1_6);
EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
if (!status_and_caps.second.rttFtmSupported) {
GTEST_SKIP() << "Skipping two sided RTT since driver/fw doesn't support";
}
std::vector<RttConfig> configs;
RttConfig config;
int cmdId = 55;
// Set the config with test data
for (int i = 0; i < 6; i++) {
config.addr[i] = i;
}
config.type = RttType::TWO_SIDED;
config.peer = RttPeerType::AP;
config.channel.width = WifiChannelWidthInMhz::WIDTH_80;
config.channel.centerFreq = 5180;
config.channel.centerFreq0 = 5210;
config.channel.centerFreq1 = 0;
config.bw = RttBw::BW_20MHZ;
config.preamble = RttPreamble::HT;
config.mustRequestLci = false;
config.mustRequestLcr = false;
config.burstPeriod = 0;
config.numBurst = 0;
config.numFramesPerBurst = 8;
config.numRetriesPerRttFrame = 0;
config.numRetriesPerFtmr = 0;
config.burstDuration = 9;
// Insert config in the vector
configs.push_back(config);
// Invoke the call
const auto& status = HIDL_INVOKE(wifi_rtt_controller_, rangeRequest_1_6, cmdId, configs);
EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
// sleep for 2 seconds to wait for driver/firmware to complete RTT
sleep(2);
}
/*
* rangeRequest_1_6
*/
TEST_P(WifiRttControllerHidlTest, RangeRequest_1_6) {
std::pair<WifiStatus, RttCapabilities> status_and_caps;
// Get the Capabilities
status_and_caps = HIDL_INVOKE(wifi_rtt_controller_, getCapabilities_1_6);
EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
if (!status_and_caps.second.rttOneSidedSupported) {
GTEST_SKIP() << "Skipping one sided RTT since driver/fw doesn't support";
}
// Get the highest support preamble
int preamble = 1;
status_and_caps.second.preambleSupport >>= 1;
while (status_and_caps.second.preambleSupport != 0) {
status_and_caps.second.preambleSupport >>= 1;
preamble <<= 1;
}
std::vector<RttConfig> configs;
RttConfig config;
int cmdId = 55;
// Set the config with test data
for (int i = 0; i < 6; i++) {
config.addr[i] = i;
}
config.type = RttType::ONE_SIDED;
config.peer = RttPeerType::AP;
config.channel.width = WifiChannelWidthInMhz::WIDTH_80;
config.channel.centerFreq = 5765;
config.channel.centerFreq0 = 5775;
config.channel.centerFreq1 = 0;
config.bw = RttBw::BW_80MHZ;
config.preamble = (RttPreamble)preamble;
config.mustRequestLci = false;
config.mustRequestLcr = false;
config.burstPeriod = 0;
config.numBurst = 0;
config.numFramesPerBurst = 8;
config.numRetriesPerRttFrame = 3;
config.numRetriesPerFtmr = 3;
config.burstDuration = 9;
// Insert config in the vector
configs.push_back(config);
// Invoke the call
const auto& status = HIDL_INVOKE(wifi_rtt_controller_, rangeRequest_1_6, cmdId, configs);
EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
// sleep for 2 seconds to wait for driver/firmware to complete RTT
sleep(2);
}
/*
* getCapabilities_1_6
*/
TEST_P(WifiRttControllerHidlTest, GetCapabilities_1_6) {
std::pair<WifiStatus, RttCapabilities> status_and_caps;
// Invoke the call
status_and_caps = HIDL_INVOKE(wifi_rtt_controller_, getCapabilities_1_6);
EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
}
/*
* getResponderInfo_1_6
*/
TEST_P(WifiRttControllerHidlTest, GetResponderInfo_1_6) {
std::pair<WifiStatus, RttResponder> status_and_info;
// Invoke the call
status_and_info = HIDL_INVOKE(wifi_rtt_controller_, getResponderInfo_1_6);
EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_info.first.code);
}
/*
* enableResponder_1_6
*/
TEST_P(WifiRttControllerHidlTest, EnableResponder_1_6) {
std::pair<WifiStatus, RttResponder> status_and_info;
int cmdId = 55;
WifiChannelInfo channelInfo;
channelInfo.width = WifiChannelWidthInMhz::WIDTH_80;
channelInfo.centerFreq = 5660;
channelInfo.centerFreq0 = 5660;
channelInfo.centerFreq1 = 0;
// Get the responder first
status_and_info = HIDL_INVOKE(wifi_rtt_controller_, getResponderInfo_1_6);
EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_info.first.code);
// Invoke the call
const auto& status = HIDL_INVOKE(wifi_rtt_controller_, enableResponder_1_6, cmdId, channelInfo,
10, status_and_info.second);
EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiRttControllerHidlTest);
INSTANTIATE_TEST_SUITE_P(PerInstance, WifiRttControllerHidlTest,
testing::ValuesIn(android::hardware::getAllHalInstanceNames(
::android::hardware::wifi::V1_6::IWifi::descriptor)),
android::hardware::PrintInstanceNameToString);

107
wifi/1.6/vts/functional/wifi_sta_iface_hidl_test.cpp Normal file
View File

@@ -0,0 +1,107 @@
/*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Staache 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 <numeric>
#include <vector>
#include <android-base/logging.h>
#include <android/hardware/wifi/1.6/IWifi.h>
#include <android/hardware/wifi/1.6/IWifiChip.h>
#include <android/hardware/wifi/1.6/IWifiStaIface.h>
#include <gtest/gtest.h>
#include <hidl/GtestPrinter.h>
#include <hidl/ServiceManagement.h>
#include "wifi_hidl_call_util.h"
#include "wifi_hidl_test_utils.h"
using ::android::sp;
using ::android::hardware::hidl_array;
using ::android::hardware::wifi::V1_0::WifiStatus;
using ::android::hardware::wifi::V1_0::WifiStatusCode;
using ::android::hardware::wifi::V1_6::IWifiChip;
using ::android::hardware::wifi::V1_6::IWifiStaIface;
/**
* Fixture to use for all STA Iface HIDL interface tests.
*/
class WifiStaIfaceHidlTest : public ::testing::TestWithParam<std::string> {
public:
virtual void SetUp() override {
// Make sure to start with a clean state
stopWifi(GetInstanceName());
wifi_sta_iface_ = IWifiStaIface::castFrom(getWifiStaIface(GetInstanceName()));
ASSERT_NE(nullptr, wifi_sta_iface_.get());
}
virtual void TearDown() override { stopWifi(GetInstanceName()); }
protected:
bool isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask cap_mask) {
const auto& status_and_caps = HIDL_INVOKE(wifi_sta_iface_, getCapabilities);
EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
return (status_and_caps.second & cap_mask) != 0;
}
WifiStatusCode createStaIface(sp<IWifiStaIface>* sta_iface) {
sp<IWifiChip> wifi_chip = IWifiChip::castFrom(getWifiChip(GetInstanceName()));
EXPECT_NE(nullptr, wifi_chip.get());
const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createStaIface);
*sta_iface = IWifiStaIface::castFrom(status_and_iface.second);
return status_and_iface.first.code;
}
sp<IWifiStaIface> wifi_sta_iface_;
private:
std::string GetInstanceName() { return GetParam(); }
};
/*
* GetLinkLayerStats_1_6
* Ensures that calls to get link layer stats V1_6 will retrieve a non-empty
* StaLinkLayerStats after link layer stats collection is enabled.
*/
TEST_P(WifiStaIfaceHidlTest, GetLinkLayerStats_1_6) {
if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::LINK_LAYER_STATS)) {
GTEST_SKIP() << "Skipping this test since link layer stats are not supported.";
}
// Enable link layer stats collection.
EXPECT_EQ(WifiStatusCode::SUCCESS,
HIDL_INVOKE(wifi_sta_iface_, enableLinkLayerStatsCollection, true).code);
// Retrieve link layer stats.
const auto& status_and_stats = HIDL_INVOKE(wifi_sta_iface_, getLinkLayerStats_1_6);
EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_stats.first.code);
EXPECT_GT(status_and_stats.second.timeStampInMs, 0u);
// Try to create 2nd iface. If yes, it should fill in the duty cycle field.
sp<IWifiStaIface> iface;
auto status = createStaIface(&iface);
if (status == WifiStatusCode::SUCCESS) {
EXPECT_GT(status_and_stats.second.iface.timeSliceDutyCycleInPercent, 0u);
}
// Disable link layer stats collection.
EXPECT_EQ(WifiStatusCode::SUCCESS,
HIDL_INVOKE(wifi_sta_iface_, disableLinkLayerStatsCollection).code);
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WifiStaIfaceHidlTest);
INSTANTIATE_TEST_SUITE_P(PerInstance, WifiStaIfaceHidlTest,
testing::ValuesIn(android::hardware::getAllHalInstanceNames(
::android::hardware::wifi::V1_6::IWifi::descriptor)),
android::hardware::PrintInstanceNameToString);