Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 98eab1d1 authored by Ahmed ElArabawy's avatar Ahmed ElArabawy
Browse files

Add VTS tests to RTT impact of support of 11ax 

This commit adds missing VTS tests for the support of 80211ax and its
impact to RTT.

Bug: 139354972
Test: atest VtsHalWifiApV1_4TargetTest
Change-Id: Ib13b65b5b76d1d940ac784a4a3b4899af88e541a
parent 82e3c6bb

wifi/1.4/vts/functional/Android.bp

+7 −3
Original line number Diff line number Diff line
@@ -22,7 +22,8 @@ cc_test { 
        "VtsHalWifiV1_4TargetTest.cpp",

        "wifi_ap_iface_hidl_test.cpp",

        "wifi_chip_hidl_test.cpp",

		"wifi_nan_iface_hidl_test.cpp"

        "wifi_nan_iface_hidl_test.cpp",

        "wifi_rtt_controller_hidl_test.cpp",

    ],

    static_libs: [

        "VtsHalWifiV1_0TargetTestUtil",
@@ -31,7 +32,10 @@ cc_test { 
        "android.hardware.wifi@1.2",

        "android.hardware.wifi@1.3",

        "android.hardware.wifi@1.4",

        "libwifi-system-iface"

        "libwifi-system-iface",

    ],

    test_suites: [

        "general-tests",

        "vts-core",

    ],

    test_suites: ["general-tests", "vts-core"],

}

wifi/1.4/vts/functional/wifi_chip_hidl_test.cpp

+35 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 


#undef NAN  // NAN is defined in bionic/libc/include/math.h:38



#include <android/hardware/wifi/1.3/IWifiStaIface.h>

#include <android/hardware/wifi/1.4/IWifi.h>

#include <android/hardware/wifi/1.4/IWifiChip.h>

#include <android/hardware/wifi/1.4/IWifiChipEventCallback.h>
@@ -34,10 +35,12 @@ 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::WifiDebugRingBufferStatus;

using ::android::hardware::wifi::V1_0::WifiStatus;

using ::android::hardware::wifi::V1_0::WifiStatusCode;

using ::android::hardware::wifi::V1_3::IWifiStaIface;

using ::android::hardware::wifi::V1_4::IWifiChip;

using ::android::hardware::wifi::V1_4::IWifiChipEventCallback;
@@ -110,6 +113,16 @@ class WifiChipHidlTest : public ::testing::TestWithParam<std::string> { 
    };



   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:
@@ -137,6 +150,28 @@ TEST_P(WifiChipHidlTest, registerEventCallback_1_4) { 
    }

}



/*

 * createRttController_1_4

 * Ensures that an instance of the IWifiRttController proxy object is

 * successfully created.

 */

TEST_P(WifiChipHidlTest, createRttController_1_4) {

    configureChipForIfaceType(IfaceType::STA, true);



    const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createStaIface);

    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface.first.code);

    sp<IWifiStaIface> iface = IWifiStaIface::castFrom(status_and_iface.second);

    EXPECT_NE(nullptr, iface.get());



    const auto& status_and_controller =

        HIDL_INVOKE(wifi_chip_, createRttController_1_4, iface);

    if (status_and_controller.first.code !=

        WifiStatusCode::ERROR_NOT_SUPPORTED) {

        EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_controller.first.code);

        EXPECT_NE(nullptr, status_and_controller.second.get());

    }

}



INSTANTIATE_TEST_SUITE_P(

    PerInstance, WifiChipHidlTest,

    testing::ValuesIn(android::hardware::getAllHalInstanceNames(

wifi/1.4/vts/functional/wifi_rtt_controller_hidl_test.cpp

0 → 100644
+224 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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.3/IWifiStaIface.h>

#include <android/hardware/wifi/1.4/IWifi.h>

#include <android/hardware/wifi/1.4/IWifiChip.h>

#include <android/hardware/wifi/1.4/IWifiRttController.h>

#include <android/hardware/wifi/1.4/IWifiRttControllerEventCallback.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::RttBw;

using ::android::hardware::wifi::V1_0::RttPeerType;

using ::android::hardware::wifi::V1_0::RttType;

using ::android::hardware::wifi::V1_0::WifiChannelInfo;

using ::android::hardware::wifi::V1_0::WifiChannelWidthInMhz;

using ::android::hardware::wifi::V1_0::WifiStatus;

using ::android::hardware::wifi::V1_0::WifiStatusCode;

using ::android::hardware::wifi::V1_3::IWifiStaIface;

using ::android::hardware::wifi::V1_4::IWifiChip;

using ::android::hardware::wifi::V1_4::IWifiRttController;

using ::android::hardware::wifi::V1_4::IWifiRttControllerEventCallback;

using ::android::hardware::wifi::V1_4::RttCapabilities;

using ::android::hardware::wifi::V1_4::RttConfig;

using ::android::hardware::wifi::V1_4::RttPreamble;

using ::android::hardware::wifi::V1_4::RttResponder;

using ::android::hardware::wifi::V1_4::RttResult;



/**

 * Fixture to use for all RTT controller HIDL interface tests.

 */

class WifiRttControllerHidlTest : public ::testing::TestWithParam<std::string> {

   public:

    virtual void SetUp() override {

        // Make sure to start with a clean state

        stopWifi(GetInstanceName());



        wifi_rtt_controller_ = getWifiRttController();

        ASSERT_NE(nullptr, wifi_rtt_controller_.get());

    }



    virtual void TearDown() override { stopWifi(GetInstanceName()); }



    // A simple test implementation of WifiChipEventCallback.

    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<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_4, 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_4

 * This test case tests the registerEventCallback_1_4() 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_4) {

    sp<WifiRttControllerEventCallback> wifiRttControllerEventCallback =

        new WifiRttControllerEventCallback();

    const auto& status =

        HIDL_INVOKE(wifi_rtt_controller_, registerEventCallback_1_4,

                    wifiRttControllerEventCallback);

    EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);

}



/*

 * rangeRequest_1_4

 */

TEST_P(WifiRttControllerHidlTest, RangeRequest_1_4) {

    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::STA;

    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::HE;

    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_4, cmdId, configs);

    EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);

}



/*

 * getCapabilities_1_4

 */

TEST_P(WifiRttControllerHidlTest, GetCapabilities_1_4) {

    std::pair<WifiStatus, RttCapabilities> status_and_caps;



    // Invoke the call

    status_and_caps = HIDL_INVOKE(wifi_rtt_controller_, getCapabilities_1_4);

    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);

}



/*

 * getResponderInfo_1_4

 */

TEST_P(WifiRttControllerHidlTest, GetResponderInfo_1_4) {

    std::pair<WifiStatus, RttResponder> status_and_info;



    // Invoke the call

    status_and_info = HIDL_INVOKE(wifi_rtt_controller_, getResponderInfo_1_4);

    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_info.first.code);

}



/*

 * enableResponder_1_4

 */

TEST_P(WifiRttControllerHidlTest, EnableResponder_1_4) {

    std::pair<WifiStatus, RttResponder> status_and_info;

    int cmdId = 55;

    WifiChannelInfo channelInfo;

    channelInfo.width = WifiChannelWidthInMhz::WIDTH_80;

    channelInfo.centerFreq = 5690;

    channelInfo.centerFreq0 = 5690;

    channelInfo.centerFreq1 = 0;



    // Get the responder first

    status_and_info = HIDL_INVOKE(wifi_rtt_controller_, getResponderInfo_1_4);

    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_info.first.code);



    // Invoke the call

    const auto& status =

        HIDL_INVOKE(wifi_rtt_controller_, enableResponder_1_4, cmdId,

                    channelInfo, 10, status_and_info.second);

    EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);

}



INSTANTIATE_TEST_SUITE_P(

    PerInstance, WifiRttControllerHidlTest,

    testing::ValuesIn(android::hardware::getAllHalInstanceNames(

        ::android::hardware::wifi::V1_4::IWifi::descriptor)),

    android::hardware::PrintInstanceNameToString);