wifi-emlsr-test.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Universita' degli Studi di Napoli Federico II
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Stefano Avallone <stavallo@unina.it>
 */
 
#ifndef WIFI_EMLSR_TEST_H
#define WIFI_EMLSR_TEST_H
 
#include "ns3/ap-wifi-mac.h"
#include "ns3/error-model.h"
#include "ns3/header-serialization-test.h"
#include "ns3/packet-socket-address.h"
#include "ns3/packet-socket-client.h"
#include "ns3/sta-wifi-mac.h"
#include "ns3/test.h"
#include "ns3/wifi-mac-queue-scheduler.h"
#include "ns3/wifi-mac.h"
#include "ns3/wifi-ppdu.h"
#include "ns3/wifi-psdu.h"
 
using namespace ns3;
 
class EmlOperatingModeNotificationTest : public HeaderSerializationTestCase
{
  public:
    EmlOperatingModeNotificationTest();
    ~EmlOperatingModeNotificationTest() override = default;
 
  private:
    void DoRun() override;
};
 
class EmlsrOperationsTestBase : public TestCase
{
  public:
    EmlsrOperationsTestBase(const std::string& name);
    ~EmlsrOperationsTestBase() override = default;
 
    enum TrafficDirection : uint8_t
    {
        DOWNLINK = 0,
        UPLINK
    };
 
  protected:
    virtual void Transmit(Ptr<WifiMac> mac,
                          uint8_t phyId,
                          WifiConstPsduMap psduMap,
                          WifiTxVector txVector,
                          double txPowerW);
 
    Ptr<PacketSocketClient> GetApplication(TrafficDirection dir,
                                           std::size_t staId,
                                           std::size_t count,
                                           std::size_t pktSize) const;
 
    void CheckBlockedLink(Ptr<WifiMac> mac,
                          Mac48Address dest,
                          uint8_t linkId,
                          WifiQueueBlockedReason reason,
                          bool blocked,
                          std::string description,
                          bool testUnblockedForOtherReasons = true);
 
    void DoSetup() override;
 
    struct FrameInfo
    {
        Time startTx;             
        WifiConstPsduMap psduMap; 
        WifiTxVector txVector;    
        uint8_t linkId;           
        uint8_t phyId;            
    };
 
    uint8_t m_mainPhyId{0};                   
    std::set<uint8_t> m_linksToEnableEmlsrOn; 
    std::size_t m_nEmlsrStations{1};          
    std::size_t m_nNonEmlsrStations{0};       
    Time m_transitionTimeout{MicroSeconds(128)}; 
    std::vector<Time> m_paddingDelay{
        {MicroSeconds(32)}}; 
    std::vector<Time> m_transitionDelay{
        {MicroSeconds(16)}};                
    bool m_establishBaDl{false};            
    bool m_establishBaUl{false};            
    std::vector<FrameInfo> m_txPsdus;       
    Ptr<ApWifiMac> m_apMac;                 
    std::vector<Ptr<StaWifiMac>> m_staMacs; 
    std::vector<PacketSocketAddress> m_dlSockets; 
    std::vector<PacketSocketAddress> m_ulSockets; 
    uint16_t m_lastAid{0};                        
    Time m_duration{0};                           
 
  private:
    void SetSsid(uint16_t aid, Mac48Address /* addr */);
 
    virtual void StartTraffic()
    {
    }
};
 
class EmlOmnExchangeTest : public EmlsrOperationsTestBase
{
  public:
    EmlOmnExchangeTest(const std::set<uint8_t>& linksToEnableEmlsrOn, Time transitionTimeout);
    ~EmlOmnExchangeTest() override = default;
 
  protected:
    void DoSetup() override;
    void DoRun() override;
    void Transmit(Ptr<WifiMac> mac,
                  uint8_t phyId,
                  WifiConstPsduMap psduMap,
                  WifiTxVector txVector,
                  double txPowerW) override;
 
    void TxOk(Ptr<const WifiMpdu> mpdu);
    void TxDropped(WifiMacDropReason reason, Ptr<const WifiMpdu> mpdu);
 
    void CheckEmlCapabilitiesInAssocReq(Ptr<const WifiMpdu> mpdu,
                                        const WifiTxVector& txVector,
                                        uint8_t linkId);
    void CheckEmlCapabilitiesInAssocResp(Ptr<const WifiMpdu> mpdu,
                                         const WifiTxVector& txVector,
                                         uint8_t linkId);
    void CheckEmlNotification(Ptr<const WifiPsdu> psdu,
                              const WifiTxVector& txVector,
                              uint8_t linkId);
    void CheckEmlsrLinks();
 
  private:
    std::size_t m_checkEmlsrLinksCount;        
    std::size_t m_emlNotificationDroppedCount; 
    Ptr<ListErrorModel> m_errorModel;          
    std::list<uint64_t> m_uidList;             
};
 
class EmlsrDlTxopTest : public EmlsrOperationsTestBase
{
  public:
    struct Params
    {
        std::size_t nEmlsrStations;    
        std::size_t nNonEmlsrStations; 
        std::set<uint8_t>
            linksToEnableEmlsrOn;       
        std::vector<Time> paddingDelay; 
        std::vector<Time>
            transitionDelay;    
        Time transitionTimeout; 
    };
 
    EmlsrDlTxopTest(const Params& params);
    ~EmlsrDlTxopTest() override = default;
 
  protected:
    void DoSetup() override;
    void DoRun() override;
    void Transmit(Ptr<WifiMac> mac,
                  uint8_t phyId,
                  WifiConstPsduMap psduMap,
                  WifiTxVector txVector,
                  double txPowerW) override;
 
    void CheckResults();
 
    void CheckPmModeAfterAssociation(const Mac48Address& address);
 
    void CheckEmlNotificationFrame(Ptr<const WifiMpdu> mpdu,
                                   const WifiTxVector& txVector,
                                   uint8_t linkId);
 
    void CheckInitialControlFrame(Ptr<const WifiMpdu> mpdu,
                                  const WifiTxVector& txVector,
                                  uint8_t linkId);
 
    void CheckQosFrames(const WifiConstPsduMap& psduMap,
                        const WifiTxVector& txVector,
                        uint8_t linkId);
 
    void CheckBlockAck(const WifiConstPsduMap& psduMap,
                       const WifiTxVector& txVector,
                       uint8_t phyId);
 
  private:
    void StartTraffic() override;
 
    void EnableEmlsrMode();
 
    std::set<uint8_t> m_emlsrLinks; 
    Time m_emlsrEnabledTime;        
    const Time m_fe2to3delay;       
    std::size_t m_countQoSframes;   
    std::size_t m_countBlockAck;    
    Ptr<ListErrorModel> m_errorModel; 
};
 
class EmlsrUlTxopTest : public EmlsrOperationsTestBase
{
  public:
    struct Params
    {
        std::set<uint8_t>
            linksToEnableEmlsrOn;       
        uint16_t channelWidth;          
        uint16_t auxPhyChannelWidth;    
        Time mediumSyncDuration;        
        uint8_t msdMaxNTxops;           
        bool genBackoffIfTxopWithoutTx; 
    };
 
    EmlsrUlTxopTest(const Params& params);
    ~EmlsrUlTxopTest() override = default;
 
  protected:
    void DoSetup() override;
    void DoRun() override;
    void Transmit(Ptr<WifiMac> mac,
                  uint8_t phyId,
                  WifiConstPsduMap psduMap,
                  WifiTxVector txVector,
                  double txPowerW) override;
 
    void CheckResults();
 
    void CheckRtsFrames(Ptr<const WifiMpdu> mpdu, const WifiTxVector& txVector, uint8_t linkId);
 
    void CheckCtsFrames(Ptr<const WifiMpdu> mpdu, const WifiTxVector& txVector, uint8_t linkId);
 
    void CheckQosFrames(const WifiConstPsduMap& psduMap,
                        const WifiTxVector& txVector,
                        uint8_t linkId);
 
    void CheckBlockAck(const WifiConstPsduMap& psduMap,
                       const WifiTxVector& txVector,
                       uint8_t linkId);
 
  private:
    void StartTraffic() override;
 
    void BackoffGenerated(uint32_t backoff, uint8_t linkId);
 
    std::set<uint8_t> m_emlsrLinks; 
    uint16_t m_channelWidth;        
    uint16_t m_auxPhyChannelWidth;  
    Time m_mediumSyncDuration;      
    uint8_t m_msdMaxNTxops;         
    std::optional<uint8_t> m_nonEmlsrLink; 
    Time m_emlsrEnabledTime;              
    Time m_firstUlPktsGenTime;            
    const Time m_unblockMainPhyLinkDelay; 
    Time m_lastMsdExpiryTime;             
    bool m_checkBackoffStarted;           
    std::optional<Time> m_backoffEndTime; 
    Ptr<ListErrorModel> m_errorModel;     
    std::size_t m_countQoSframes;         
    std::size_t m_countBlockAck;          
    std::size_t m_countRtsframes;         
    bool m_genBackoffIfTxopWithoutTx;     
    std::optional<bool> m_corruptCts;     
};
 
class EmlsrLinkSwitchTest : public EmlsrOperationsTestBase
{
  public:
    struct Params
    {
        bool
            switchAuxPhy; 
        bool resetCamState; 
        uint16_t auxPhyMaxChWidth; 
    };
 
    EmlsrLinkSwitchTest(const Params& params);
 
    ~EmlsrLinkSwitchTest() override = default;
 
  protected:
    void DoSetup() override;
    void DoRun() override;
    void Transmit(Ptr<WifiMac> mac,
                  uint8_t phyId,
                  WifiConstPsduMap psduMap,
                  WifiTxVector txVector,
                  double txPowerW) override;
 
    void CheckResults();
 
    void CheckInitialControlFrame(const WifiConstPsduMap& psduMap,
                                  const WifiTxVector& txVector,
                                  uint8_t linkId);
 
    void CheckQosFrames(const WifiConstPsduMap& psduMap,
                        const WifiTxVector& txVector,
                        uint8_t linkId);
 
  private:
    bool m_switchAuxPhy;  
    bool m_resetCamState; 
    uint16_t m_auxPhyMaxChWidth;  
    std::size_t m_countQoSframes; 
    std::size_t m_txPsdusPos;     
};
 
class WifiEmlsrTestSuite : public TestSuite
{
  public:
    WifiEmlsrTestSuite();
};
 
#endif /* WIFI_EMLSR_TEST_H */