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

Commit 6c5d6bf8 authored by Les Lee's avatar Les Lee
Browse files

wifi vts: Add vts test case for new aidl API about mlo SAP 

IWifiChip#createApOrBridgedApIfaceWithParams
IWifiApIface#usesMlo

Bug: 385776312
Test: atest -c  VtsHalWifiChipTargetTest
Change-Id: Ifca8004c535f84a38da2260fff0a2c4388c14acc
parent c96df1bc

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