From d91fd3df631db5886d470ccc83afdea7ff4b1e1f Mon Sep 17 00:00:00 2001 From: Sharan Naribole Date: Thu, 10 Apr 2025 18:41:00 -0700 Subject: [PATCH] wifi: Add tests for static Infra BSS association * Infra BSS association * ADDBA agreement exchange * UL MU Disable exchange --- src/wifi/CMakeLists.txt | 1 + src/wifi/model/he/rr-multi-user-scheduler.cc | 6 + src/wifi/model/he/rr-multi-user-scheduler.h | 27 +- src/wifi/test/wifi-static-infra-bss-test.cc | 532 +++++++++++++++++++ 4 files changed, 556 insertions(+), 10 deletions(-) create mode 100644 src/wifi/test/wifi-static-infra-bss-test.cc diff --git a/src/wifi/CMakeLists.txt b/src/wifi/CMakeLists.txt index dc9f19026..cee2297b2 100644 --- a/src/wifi/CMakeLists.txt +++ b/src/wifi/CMakeLists.txt @@ -407,6 +407,7 @@ build_lib( test/wifi-retransmit-test.cc test/wifi-ru-allocation-test.cc test/wifi-channel-switching-test.cc + test/wifi-static-infra-bss-test.cc test/wifi-test.cc test/wifi-transmit-mask-test.cc test/wifi-txop-test.cc diff --git a/src/wifi/model/he/rr-multi-user-scheduler.cc b/src/wifi/model/he/rr-multi-user-scheduler.cc index e5ba3ebfa..1621cc271 100644 --- a/src/wifi/model/he/rr-multi-user-scheduler.cc +++ b/src/wifi/model/he/rr-multi-user-scheduler.cc @@ -1118,4 +1118,10 @@ RrMultiUserScheduler::ComputeUlMuInfo() return UlMuInfo{m_trigger, m_triggerMacHdr, std::move(m_txParams)}; } +const std::list& +RrMultiUserScheduler::GetUlMuStas() const +{ + return m_staListUl; +} + } // namespace ns3 diff --git a/src/wifi/model/he/rr-multi-user-scheduler.h b/src/wifi/model/he/rr-multi-user-scheduler.h index f44e77fad..022f9ef60 100644 --- a/src/wifi/model/he/rr-multi-user-scheduler.h +++ b/src/wifi/model/he/rr-multi-user-scheduler.h @@ -44,6 +44,23 @@ class RrMultiUserScheduler : public MultiUserScheduler Time GetExtraTimeForBsrpTfDurationId(uint8_t linkId) const override; + /** + * Information used to sort stations + */ + struct MasterInfo + { + uint16_t aid{0}; //!< station's AID + Mac48Address address; //!< station's MAC Address + double credits{0.}; //!< credits accumulated by the station + }; + + /** + * @brief Get UL MU eligible stations list + * + * @return list of UL MU eligible stations + */ + virtual const std::list& GetUlMuStas() const; + protected: void DoDispose() override; void DoInitialize() override; @@ -55,16 +72,6 @@ class RrMultiUserScheduler : public MultiUserScheduler WifiPsduMap& psduMap, WifiTxParameters& txParams) const override; - /** - * Information used to sort stations - */ - struct MasterInfo - { - uint16_t aid; //!< station's AID - Mac48Address address; //!< station's MAC Address - double credits; //!< credits accumulated by the station - }; - /** * Determine whether the given STA can be solicited via a Basic Trigger Frame. * diff --git a/src/wifi/test/wifi-static-infra-bss-test.cc b/src/wifi/test/wifi-static-infra-bss-test.cc new file mode 100644 index 000000000..e410f15ca --- /dev/null +++ b/src/wifi/test/wifi-static-infra-bss-test.cc @@ -0,0 +1,532 @@ +/* + * Copyright (c) 2025 + * + * SPDX-License-Identifier: GPL-2.0-only + * + * Author: Sharan Naribole + */ + +#include "ns3/ap-wifi-mac.h" +#include "ns3/assert.h" +#include "ns3/boolean.h" +#include "ns3/frame-exchange-manager.h" +#include "ns3/log.h" +#include "ns3/mac48-address.h" +#include "ns3/multi-model-spectrum-channel.h" +#include "ns3/node-container.h" +#include "ns3/rng-seed-manager.h" +#include "ns3/rr-multi-user-scheduler.h" +#include "ns3/simulator.h" +#include "ns3/spectrum-wifi-helper.h" +#include "ns3/sta-wifi-mac.h" +#include "ns3/string.h" +#include "ns3/test.h" +#include "ns3/wifi-mac-header.h" +#include "ns3/wifi-mac-helper.h" +#include "ns3/wifi-mac.h" +#include "ns3/wifi-net-device.h" +#include "ns3/wifi-ns3-constants.h" +#include "ns3/wifi-static-setup-helper.h" +#include "ns3/wifi-utils.h" + +#include +#include +#include + +/// @ingroup wifi-test +/// @ingroup tests +/// @brief WifiStaticSetupHelper test suite +/// Test suite intended to test static management exchanges between +/// AP device and client device for single link and multi +/// link operations. +/// The test prepares AP WifiNetDevice and client WifiNetDevice +/// based on test vector input and performs static exchanges for +/// association, Block ACK agreement, UL MU disable etc. +/// using WifiStaticSetupHelper. The test verifies if state machines +/// at ApWifiMac and StaWifiMac has been updated correctly. + +using namespace ns3; +NS_LOG_COMPONENT_DEFINE("WifiStaticInfraBssTestSuite"); + +/// @brief Constants used in test suite +namespace WifiStaticInfraBssTestConstants +{ +const auto DEFAULT_RNG_SEED = 3; ///< default RNG seed +const auto DEFAULT_RNG_RUN = 7; ///< default RNG run +const auto DEFAULT_STREAM_INDEX = 100; ///< default stream index +const auto DEFAULT_SIM_STOP_TIME = NanoSeconds(1); ///< default simulation stop time +const auto DEFAULT_BEACON_GEN = false; ///< default beacon generation value +const auto DEFAULT_DATA_MODE = "HeMcs3"; ///< default data mode +const auto DEFAULT_CONTROL_MODE = "OfdmRate24Mbps"; ///< default control mode +const auto DEFAULT_WIFI_STANDARD = WifiStandard::WIFI_STANDARD_80211be; ///< default Wi-Fi standard +const auto DEFAULT_SSID = Ssid("wifi-static-setup"); ///< default SSID +const tid_t DEFAULT_TEST_TID = 0; ///< default TID +const uint16_t DEFAULT_BA_BUFFER_SIZE = 64; ///< default MPDU buffer size +const uint8_t DEFAULT_WIFI_UL_MU_NUM_RU = 4; ///< default number of RUs in UL MU PPDUs +} // namespace WifiStaticInfraBssTestConstants + +namespace consts = WifiStaticInfraBssTestConstants; + +/// @brief channel map typedef +using ChannelMap = std::unordered_map>; + +/// @brief test case information +struct WifiStaticInfraBssTestVector +{ + std::string name; ///< Test case name + StringVector apChs{}; ///< Channel setting for AP device + StringVector clientChs{}; ///< Channel settings for client device + uint16_t apBufferSize{consts::DEFAULT_BA_BUFFER_SIZE}; ///< Originator Buffer Size + uint16_t clientBufferSize{consts::DEFAULT_BA_BUFFER_SIZE}; ///< Recipient Buffer Size + std::optional apMulticastIp{std::nullopt}; ///< AP multicast IP + bool ulMuDataDisable{DEFAULT_WIFI_UL_MU_DATA_DISABLE}; ///< UL MU Data Disable +}; + +/** + * Test static setup of an infrastructure BSS. + */ +class WifiStaticInfraBssTest : public TestCase +{ + public: + /** + * Constructor. + * + * @param testVec the test vector + */ + WifiStaticInfraBssTest(const WifiStaticInfraBssTestVector& testVec); + + private: + /// Construct WifiNetDevice + /// @param isAp true if AP, false otherwise + /// @param channelMap created spectrum channels + /// @return constructed WifiNetDevice + Ptr GetWifiNetDevice(bool isAp, const ChannelMap& channelMap); + + /// Construct PHY helper based on input operating channels + /// @param settings vector of strings specifying the operating channels to configure + /// @param channelMap created spectrum channels + /// @return PHY helper + SpectrumWifiPhyHelper GetPhyHelper(const StringVector& settings, + const ChannelMap& channelMap) const; + + /// @return the WifiHelper + WifiHelper GetWifiHelper() const; + /// @return the AP MAC helper + WifiMacHelper GetApMacHelper() const; + /// @return the Client MAC helper + WifiMacHelper GetClientMacHelper() const; + void ValidateAssoc(); ///< Validate Association + + /// Validate Multi-user scheduler setup + /// @param apMac AP MAC + /// @param clientMac Non-AP MAC + void ValidateMuScheduler(Ptr apMac, Ptr clientMac); + + /// Validate association state machine at AP and client + /// for input link + /// @param clientLinkId client local Link ID + /// @param apMac AP MAC + /// @param clientMac Client MAC + void ValidateAssocForLink(linkId_t clientLinkId, + Ptr apMac, + Ptr clientMac); + + /// Validate Block ACK Agreement at AP and client + /// @param apMac AP MAC + /// @param clientMac Client MAC + void ValidateBaAgr(Ptr apMac, Ptr clientMac); + + void DoRun() override; + void DoSetup() override; + + WifiStaticInfraBssTestVector m_testVec; ///< Test vector + Ptr m_apDev{nullptr}; ///< AP WiFi device + Ptr m_clientDev{nullptr}; ///< client WiFi device + std::optional m_apGcrGroupAddr; ///< GCR group address +}; + +WifiStaticInfraBssTest::WifiStaticInfraBssTest(const WifiStaticInfraBssTestVector& testVec) + : TestCase(testVec.name), + m_testVec(testVec) +{ +} + +WifiHelper +WifiStaticInfraBssTest::GetWifiHelper() const +{ + WifiHelper wifiHelper; + wifiHelper.SetStandard(consts::DEFAULT_WIFI_STANDARD); + wifiHelper.SetRemoteStationManager("ns3::ConstantRateWifiManager", + "DataMode", + StringValue(consts::DEFAULT_DATA_MODE), + "ControlMode", + StringValue(consts::DEFAULT_CONTROL_MODE)); + return wifiHelper; +} + +SpectrumWifiPhyHelper +WifiStaticInfraBssTest::GetPhyHelper(const StringVector& settings, + const ChannelMap& channelMap) const +{ + NS_ASSERT(!settings.empty()); + SpectrumWifiPhyHelper helper(settings.size()); + + linkId_t linkId = 0; + for (const auto& str : settings) + { + helper.Set(linkId, "ChannelSettings", StringValue(str)); + + auto channelConfig = WifiChannelConfig::FromString(str); + auto phyBand = channelConfig.front().band; + auto freqRange = GetFrequencyRange(phyBand); + helper.AddPhyToFreqRangeMapping(linkId, freqRange); + helper.AddChannel(channelMap.at(phyBand), freqRange); + + ++linkId; + } + return helper; +} + +WifiMacHelper +WifiStaticInfraBssTest::GetApMacHelper() const +{ + WifiMacHelper macHelper; + auto ssid = Ssid(consts::DEFAULT_SSID); + + macHelper.SetType("ns3::ApWifiMac", + "Ssid", + SsidValue(ssid), + "BeaconGeneration", + BooleanValue(consts::DEFAULT_BEACON_GEN), + "MpduBufferSize", + UintegerValue(m_testVec.apBufferSize)); + macHelper.SetMultiUserScheduler("ns3::RrMultiUserScheduler", + "NStations", + UintegerValue(consts::DEFAULT_WIFI_UL_MU_NUM_RU)); + return macHelper; +} + +WifiMacHelper +WifiStaticInfraBssTest::GetClientMacHelper() const +{ + WifiMacHelper macHelper; + Ssid ssid = Ssid(consts::DEFAULT_SSID); + macHelper.SetType("ns3::StaWifiMac", + "Ssid", + SsidValue(ssid), + "MpduBufferSize", + UintegerValue(m_testVec.clientBufferSize)); + return macHelper; +} + +Ptr +WifiStaticInfraBssTest::GetWifiNetDevice(bool isAp, const ChannelMap& channelMap) +{ + NodeContainer node(1); + auto wifiHelper = GetWifiHelper(); + auto settings = isAp ? m_testVec.apChs : m_testVec.clientChs; + auto phyHelper = GetPhyHelper(settings, channelMap); + auto macHelper = isAp ? GetApMacHelper() : GetClientMacHelper(); + auto netDev = wifiHelper.Install(phyHelper, macHelper, node); + WifiHelper::AssignStreams(netDev, consts::DEFAULT_STREAM_INDEX); + return DynamicCast(netDev.Get(0)); +} + +void +WifiStaticInfraBssTest::DoSetup() +{ + RngSeedManager::SetSeed(consts::DEFAULT_RNG_SEED); + RngSeedManager::SetRun(consts::DEFAULT_RNG_RUN); + + ChannelMap channelMap = {{WIFI_PHY_BAND_2_4GHZ, CreateObject()}, + {WIFI_PHY_BAND_5GHZ, CreateObject()}, + {WIFI_PHY_BAND_6GHZ, CreateObject()}}; + + m_apDev = GetWifiNetDevice(true, channelMap); // AP + NS_ASSERT(m_apDev); + m_clientDev = GetWifiNetDevice(false, channelMap); // Client + NS_ASSERT(m_clientDev); + + WifiStaticSetupHelper::SetStaticAssociation(m_apDev, m_clientDev); + if (auto multicastIp = m_testVec.apMulticastIp) + { + NS_ASSERT_MSG(multicastIp->IsMulticast(), + "Assigned IP " << multicastIp.value() << " is not multicast"); + m_apGcrGroupAddr = Mac48Address::ConvertFrom(m_apDev->GetMulticast(multicastIp.value())); + } + WifiStaticSetupHelper::SetStaticBlockAck(m_apDev, + m_clientDev, + consts::DEFAULT_TEST_TID, + m_apGcrGroupAddr); + WifiStaticSetupHelper::SetStaticBlockAck(m_clientDev, m_apDev, consts::DEFAULT_TEST_TID); +} + +void +WifiStaticInfraBssTest::ValidateAssocForLink(linkId_t clientLinkId, + Ptr apMac, + Ptr clientMac) +{ + const auto isMldAssoc = (apMac->GetNLinks() > 1) && (clientMac->GetNLinks() > 1); + const auto apLinkId = clientLinkId; + const auto clientFem = clientMac->GetFrameExchangeManager(clientLinkId); + const auto apFem = apMac->GetFrameExchangeManager(apLinkId); + const auto staAddr = clientFem->GetAddress(); + const auto apAddr = apFem->GetAddress(); + const auto staRemoteMgr = clientMac->GetWifiRemoteStationManager(clientLinkId); + const auto apRemoteMgr = apMac->GetWifiRemoteStationManager(apLinkId); + + NS_TEST_ASSERT_MSG_EQ(clientFem->GetBssid(), + apAddr, + "Unexpected BSSID for STA link ID " << +clientLinkId); + NS_TEST_ASSERT_MSG_EQ(apRemoteMgr->IsAssociated(staAddr), + true, + "Expecting STA " << staAddr << " to be associated on AP link " + << +apLinkId); + + const auto aid = apMac->GetAssociationId(staAddr, apLinkId); + NS_TEST_ASSERT_MSG_EQ(apMac->GetStaList(apLinkId).contains(aid), + true, + "STA " << staAddr << " not found in list of associated STAs"); + + if (!isMldAssoc) + { + return; + } + + NS_TEST_ASSERT_MSG_EQ((staRemoteMgr->GetMldAddress(apAddr) == apMac->GetAddress()), + true, + "Incorrect MLD address stored by STA on link ID " << +clientLinkId); + NS_TEST_ASSERT_MSG_EQ((staRemoteMgr->GetAffiliatedStaAddress(apMac->GetAddress()) == apAddr), + true, + "Incorrect affiliated address stored by STA on link ID " + << +clientLinkId); + + NS_TEST_ASSERT_MSG_EQ((apRemoteMgr->GetMldAddress(staAddr) == clientMac->GetAddress()), + true, + "Incorrect MLD address stored by AP on link ID " << +apLinkId); + NS_TEST_ASSERT_MSG_EQ( + (apRemoteMgr->GetAffiliatedStaAddress(clientMac->GetAddress()) == staAddr), + true, + "Incorrect affiliated address stored by AP on link ID " << +apLinkId); +} + +void +WifiStaticInfraBssTest::ValidateMuScheduler(Ptr apMac, Ptr clientMac) +{ + auto muScheduler = apMac->GetObject(); + NS_ASSERT(muScheduler); + auto clientList = muScheduler->GetUlMuStas(); + std::size_t expectedSize = m_testVec.ulMuDataDisable ? 0 : 1; + if (expectedSize == 0) + { + return; + } + auto clientAddr = clientList.front().address; + auto expectedAddr = clientMac->GetAddress(); + NS_TEST_ASSERT_MSG_EQ(clientAddr, expectedAddr, "Client MAC address mismatch"); +} + +void +WifiStaticInfraBssTest::ValidateBaAgr(Ptr apMac, Ptr clientMac) +{ + auto isMldAssoc = (apMac->GetNLinks() > 1) && (clientMac->GetNLinks() > 1); + auto setupLinks = clientMac->GetSetupLinkIds(); + auto linkId = *(setupLinks.begin()); + auto apAddr = + isMldAssoc ? apMac->GetAddress() : clientMac->GetFrameExchangeManager(linkId)->GetBssid(); + auto clientAddr = isMldAssoc ? clientMac->GetAddress() + : clientMac->GetFrameExchangeManager(linkId)->GetAddress(); + + auto expectedBufferSize = std::min(m_testVec.apBufferSize, m_testVec.clientBufferSize); + + // AP Block ACK Manager + auto baApOrig = apMac->GetBaAgreementEstablishedAsOriginator(clientAddr, + consts::DEFAULT_TEST_TID, + m_apGcrGroupAddr); + NS_TEST_ASSERT_MSG_EQ(baApOrig.has_value(), + true, + "BA Agreement not established at AP as originator"); + NS_TEST_ASSERT_MSG_EQ(baApOrig->get().GetBufferSize(), + expectedBufferSize, + "BA Agreement buffer size mismatch"); + auto baApRecip = + apMac->GetBaAgreementEstablishedAsRecipient(clientAddr, consts::DEFAULT_TEST_TID); + NS_TEST_ASSERT_MSG_EQ(baApRecip.has_value(), + true, + "BA Agreement not established at AP as recipient"); + NS_TEST_ASSERT_MSG_EQ(baApRecip->get().GetBufferSize(), + expectedBufferSize, + "BA Agreement buffer size mismatch"); + + // Non-AP Block ACK Manager + auto baClientOrig = + clientMac->GetBaAgreementEstablishedAsOriginator(apAddr, consts::DEFAULT_TEST_TID); + NS_TEST_ASSERT_MSG_EQ(baClientOrig.has_value(), + true, + "BA Agreement not established at client as originator"); + NS_TEST_ASSERT_MSG_EQ(baClientOrig->get().GetBufferSize(), + expectedBufferSize, + "BA Agreement buffer size mismatch"); + auto baClientRecip = clientMac->GetBaAgreementEstablishedAsRecipient(apAddr, + consts::DEFAULT_TEST_TID, + m_apGcrGroupAddr); + NS_TEST_ASSERT_MSG_EQ(baClientRecip.has_value(), + true, + "BA Agreement not established at client as recipient"); + NS_TEST_ASSERT_MSG_EQ(baClientOrig->get().GetBufferSize(), + expectedBufferSize, + "BA Agreement buffer size mismatch"); +} + +void +WifiStaticInfraBssTest::ValidateAssoc() +{ + auto apMac = DynamicCast(m_apDev->GetMac()); + NS_ASSERT(apMac); + auto clientMac = DynamicCast(m_clientDev->GetMac()); + NS_ASSERT(clientMac); + + NS_TEST_ASSERT_MSG_EQ(clientMac->IsAssociated(), true, "Expected the STA to be associated"); + const auto nClientLinks = m_testVec.clientChs.size(); + auto clientLinkIds = clientMac->GetLinkIds(); + NS_TEST_EXPECT_MSG_EQ(clientLinkIds.size(), nClientLinks, "Client number of links mismatch"); + for (auto linkId : clientLinkIds) + { + ValidateAssocForLink(linkId, apMac, clientMac); + } + + ValidateBaAgr(apMac, clientMac); + ValidateMuScheduler(apMac, clientMac); +} + +void +WifiStaticInfraBssTest::DoRun() +{ + Simulator::Stop(consts::DEFAULT_SIM_STOP_TIME); + Simulator::Run(); + ValidateAssoc(); + Simulator::Destroy(); +} + +/** + * @ingroup wifi-test + * @ingroup tests + * + * @brief WifiStaticSetupHelper test suite + */ +class WifiStaticInfraBssTestSuite : public TestSuite +{ + public: + WifiStaticInfraBssTestSuite(); +}; + +WifiStaticInfraBssTestSuite::WifiStaticInfraBssTestSuite() + : TestSuite("wifi-static-infra-bss-test", Type::UNIT) +{ + for (const std::vector inputs{ + {"AP-1-link-Client-1-link", + {"{36, 0, BAND_5GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"AP-1-link-Client-1-link-multicast", + {"{36, 0, BAND_5GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + "239.192.1.1", + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"AP-2-link-Client-1-link", + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"AP-2-link-Client-1-link-Diff-Order", + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}"}, + {"{2, 0, BAND_2_4GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"AP-3-link-Client-2-link", + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"AP-3-link-Client-2-link-Diff-Order", + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + {"{2, 0, BAND_2_4GHZ, 0}", "{36, 0, BAND_5GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"AP-3-link-Client-3-link", + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"AP-80MHz-Client-20MHz", + {"{42, 80, BAND_5GHZ, 0}"}, + {"{36, 20, BAND_5GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"Single-linkBuffer-Size-Test", + {"{36, 0, BAND_5GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}"}, + 64, + 256, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"Single-linkBuffer-Size-Test-Alt", + {"{36, 0, BAND_5GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}"}, + 1024, + 256, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"Multi-link-Buffer-Size-Test", + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + 256, + 64, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"Multi-link-Buffer-Size-Test-Alt", + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + 1024, + 1024, + std::nullopt, + DEFAULT_WIFI_UL_MU_DATA_DISABLE}, + {"Single-link-UL-MU-Disable", + {"{36, 0, BAND_5GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + std::nullopt, + true}, + {"2-link-UL-MU-Disable", + {"{36, 0, BAND_5GHZ, 0}", "{2, 0, BAND_2_4GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + {"{36, 0, BAND_5GHZ, 0}", "{1, 0, BAND_6GHZ, 0}"}, + consts::DEFAULT_BA_BUFFER_SIZE, + consts::DEFAULT_BA_BUFFER_SIZE, + std::nullopt, + true}}; + + const auto& input : inputs) + { + AddTestCase(new WifiStaticInfraBssTest(input), TestCase::Duration::QUICK); + } +} + +static WifiStaticInfraBssTestSuite g_wifiStaticInfraBssTestSuite;