d5/d14/inter-bss-test-suite_8cc_source.html

/*

 * Copyright (c) 2018 University of Washington

 *

 * 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

 *

 * Authors: Sébastien Deronne <sebastien.deronne@gmail.com>

 *          Scott Carpenter <scarpenter44@windstream.net>

 */


#include "ns3/config.h"

#include "ns3/constant-obss-pd-algorithm.h"

#include "ns3/double.h"

#include "ns3/he-configuration.h"

#include "ns3/log.h"

#include "ns3/mobility-helper.h"

#include "ns3/multi-model-spectrum-channel.h"

#include "ns3/pointer.h"

#include "ns3/rng-seed-manager.h"

#include "ns3/spectrum-wifi-helper.h"

#include "ns3/ssid.h"

#include "ns3/string.h"

#include "ns3/test.h"

#include "ns3/uinteger.h"

#include "ns3/wifi-net-device.h"

#include "ns3/wifi-utils.h"


using namespace ns3;


NS_LOG_COMPONENT_DEFINE("InterBssTestSuite");


static uint32_t

ConvertContextToNodeId(std::string context)

{

    std::string sub = context.substr(10);

    uint32_t pos = sub.find("/Device");

    uint32_t nodeId = std::stoi(sub.substr(0, pos));

    return nodeId;

}


class TestInterBssConstantObssPdAlgo : public TestCase

{

  public:

    TestInterBssConstantObssPdAlgo(WifiStandard standard);

    ~TestInterBssConstantObssPdAlgo() override;


    void DoRun() override;


  private:

    void SendOnePacket(Ptr<WifiNetDevice> tx_dev, Ptr<WifiNetDevice> rx_dev, uint32_t payloadSize);


    Ptr<ListPositionAllocator> AllocatePositions(double d1,

                                                 double d2,

                                                 double d3,

                                                 double d4,

                                                 double d5);


    void SetExpectedTxPower(double txPowerDbm);


    void SetupSimulation();


    void CheckResults();


    void ResetResults();


    void ClearDropReasons();


    void RunOne();


    void CheckPhyState(Ptr<WifiNetDevice> device, WifiPhyState expectedState);


    void CheckPhyDropReasons(Ptr<WifiNetDevice> device,

                             std::vector<WifiPhyRxfailureReason> expectedDropReasons);


    void NotifyPhyTxBegin(std::string context, Ptr<const Packet> p, double txPowerW);


    void NotifyPhyRxEnd(std::string context, Ptr<const Packet> p);


    void NotifyPhyRxDrop(std::string context, Ptr<const Packet> p, WifiPhyRxfailureReason reason);


    unsigned int m_numSta1PacketsSent;

    unsigned int m_numSta2PacketsSent;

    unsigned int m_numAp1PacketsSent;

    unsigned int m_numAp2PacketsSent;


    unsigned int m_numSta1PacketsReceived;

    unsigned int m_numSta2PacketsReceived;

    unsigned int m_numAp1PacketsReceived;

    unsigned int m_numAp2PacketsReceived;


    std::vector<WifiPhyRxfailureReason> m_dropReasonsSta1;

    std::vector<WifiPhyRxfailureReason> m_dropReasonsSta2;

    std::vector<WifiPhyRxfailureReason> m_dropReasonsAp1;

    std::vector<WifiPhyRxfailureReason> m_dropReasonsAp2;


    unsigned int m_payloadSize1;

    unsigned int m_payloadSize2;

    unsigned int m_payloadSize3;


    NetDeviceContainer m_staDevices;

    NetDeviceContainer m_apDevices;


    double m_txPowerDbm;

    double m_obssPdLevelDbm;

    double m_obssRxPowerDbm;

    double m_expectedTxPowerDbm;


    uint8_t m_bssColor1;

    uint8_t m_bssColor2;

    uint8_t m_bssColor3;


    WifiStandard m_standard;

};


TestInterBssConstantObssPdAlgo::TestInterBssConstantObssPdAlgo(WifiStandard standard)

    : TestCase("InterBssConstantObssPd"),

      m_numSta1PacketsSent(0),

      m_numSta2PacketsSent(0),

      m_numAp1PacketsSent(0),

      m_numAp2PacketsSent(0),

      m_numSta1PacketsReceived(0),

      m_numSta2PacketsReceived(0),

      m_numAp1PacketsReceived(0),

      m_numAp2PacketsReceived(0),

      m_payloadSize1(1000),

      m_payloadSize2(1500),

      m_payloadSize3(2000),

      m_txPowerDbm(15),

      m_obssPdLevelDbm(-72),

      m_obssRxPowerDbm(-82),

      m_expectedTxPowerDbm(15),

      m_bssColor1(1),

      m_bssColor2(2),

      m_bssColor3(3),

      m_standard(standard)

{

}


TestInterBssConstantObssPdAlgo::~TestInterBssConstantObssPdAlgo()

{

    ClearDropReasons();

}


Ptr<ListPositionAllocator>

TestInterBssConstantObssPdAlgo::AllocatePositions(double d1,

                                                  double d2,

                                                  double d3,

                                                  double d4,

                                                  double d5)

{

    Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();

    positionAlloc->Add(Vector(0.0, 0.0, 0.0));                    // AP1

    positionAlloc->Add(Vector(d1 + d2, 0.0, 0.0));                // AP2

    positionAlloc->Add(Vector(d1 + d2 + d3 + d4, 0.0, 0.0));      // AP3

    positionAlloc->Add(Vector(d1, 0.0, 0.0));                     // STA1

    positionAlloc->Add(Vector(d1 + d2 + d3, 0.0, 0.0));           // STA2

    positionAlloc->Add(Vector(d1 + d2 + d3 + d4 + d5, 0.0, 0.0)); // STA3

    return positionAlloc;

}


void

TestInterBssConstantObssPdAlgo::SetupSimulation()

{

    Ptr<WifiNetDevice> ap_device1 = DynamicCast<WifiNetDevice>(m_apDevices.Get(0));

    Ptr<WifiNetDevice> ap_device2 = DynamicCast<WifiNetDevice>(m_apDevices.Get(1));

    Ptr<WifiNetDevice> ap_device3 = DynamicCast<WifiNetDevice>(m_apDevices.Get(2));

    Ptr<WifiNetDevice> sta_device1 = DynamicCast<WifiNetDevice>(m_staDevices.Get(0));

    Ptr<WifiNetDevice> sta_device2 = DynamicCast<WifiNetDevice>(m_staDevices.Get(1));

    Ptr<WifiNetDevice> sta_device3 = DynamicCast<WifiNetDevice>(m_staDevices.Get(2));


    bool expectFilter = (m_bssColor1 != 0) && (m_bssColor2 != 0);

    bool expectPhyReset = expectFilter && (m_obssPdLevelDbm >= m_obssRxPowerDbm);

    std::vector<WifiPhyRxfailureReason> dropReasons;

    WifiPhyState stateDuringPayloadNeighboringBss =

        expectFilter ? WifiPhyState::CCA_BUSY : WifiPhyState::RX;

    if (expectFilter)

    {

        dropReasons.push_back(FILTERED);

    }

    if (expectPhyReset)

    {

        dropReasons.push_back(OBSS_PD_CCA_RESET);

    }


    // In order to have all ADDBA handshakes established, each AP and STA sends a packet.


    Simulator::Schedule(Seconds(0.25),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device1,

                        sta_device1,

                        m_payloadSize1);

    Simulator::Schedule(Seconds(0.5),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        sta_device1,

                        ap_device1,

                        m_payloadSize1);

    Simulator::Schedule(Seconds(0.75),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device2,

                        sta_device2,

                        m_payloadSize2);

    Simulator::Schedule(Seconds(1),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        sta_device2,

                        ap_device2,

                        m_payloadSize2);

    Simulator::Schedule(Seconds(1.25),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device3,

                        sta_device3,

                        m_payloadSize3);

    Simulator::Schedule(Seconds(1.5),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        sta_device3,

                        ap_device3,

                        m_payloadSize3);


    // We test PHY state and verify whether a CCA reset did occur.


    // AP2 sends a packet 0.5s later.

    Simulator::Schedule(Seconds(2.0), &TestInterBssConstantObssPdAlgo::ClearDropReasons, this);

    Simulator::Schedule(Seconds(2.0),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device2,

                        sta_device2,

                        m_payloadSize2);

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(10),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device2,

                        WifiPhyState::TX);

    // All other PHYs should have stay idle until 4us (preamble detection time).

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(13),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device1,

                        WifiPhyState::IDLE);

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(13),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device2,

                        WifiPhyState::IDLE);

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(13),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device1,

                        WifiPhyState::IDLE);

    // All PHYs should be receiving the PHY header (i.e. PHY state is CCA_BUSY) if preamble has been

    // detected (always the case in this test).

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(14),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device1,

                        WifiPhyState::CCA_BUSY);

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(14),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device2,

                        WifiPhyState::CCA_BUSY);

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(14),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device1,

                        WifiPhyState::CCA_BUSY);

    // PHYs of AP1 and STA1 should be idle after HE-SIG-A if they were reset by OBSS_PD SR,

    // otherwise they should be CCA_busy until beginning of payload.

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(43),

                        &TestInterBssConstantObssPdAlgo::CheckPhyDropReasons,

                        this,

                        sta_device1,

                        dropReasons);

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(43),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device1,

                        expectPhyReset ? WifiPhyState::IDLE : WifiPhyState::CCA_BUSY);

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(43),

                        &TestInterBssConstantObssPdAlgo::CheckPhyDropReasons,

                        this,

                        ap_device1,

                        dropReasons);

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(43),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device1,

                        expectPhyReset ? WifiPhyState::IDLE : WifiPhyState::CCA_BUSY);

    // PHYs of AP1 and STA1 should be idle if they were reset by OBSS_PD SR, otherwise they should

    // be CCA_busy/Rx (since filtered/not filtered, resp.).

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(54),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device1,

                        expectPhyReset ? WifiPhyState::IDLE : stateDuringPayloadNeighboringBss);

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(54),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device1,

                        expectPhyReset ? WifiPhyState::IDLE : stateDuringPayloadNeighboringBss);

    // STA2 should be receiving

    Simulator::Schedule(Seconds(2.0) + MicroSeconds(54),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device2,

                        WifiPhyState::RX);


    // We test whether two networks can transmit simultaneously, and whether transmit power

    // restrictions are applied.


    // AP2 sends another packet 0.1s later.

    Simulator::Schedule(Seconds(2.1), &TestInterBssConstantObssPdAlgo::ClearDropReasons, this);

    Simulator::Schedule(Seconds(2.1),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device2,

                        sta_device2,

                        m_payloadSize2);

    // STA1 sends a packet 42us later (i.e. right after HE-SIG-A of AP2). Even though AP2 is still

    // transmitting, STA1 can transmit simultaneously if it's PHY was reset by OBSS_PD SR.

    Simulator::Schedule(Seconds(2.1) + MicroSeconds(42),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        sta_device1,

                        ap_device1,

                        m_payloadSize1);

    if (expectPhyReset)

    {

        // In this case, we check the TX power is restricted (and set the expected value slightly

        // before transmission should occur)

        double expectedTxPower = std::min(m_txPowerDbm, 21 - (m_obssPdLevelDbm + 82));

        Simulator::Schedule(Seconds(2.1) + MicroSeconds(41),

                            &TestInterBssConstantObssPdAlgo::SetExpectedTxPower,

                            this,

                            expectedTxPower);

    }

    // Check simultaneous transmissions

    Simulator::Schedule(Seconds(2.1) + MicroSeconds(100),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device2,

                        WifiPhyState::TX);

    Simulator::Schedule(Seconds(2.1) + MicroSeconds(100),

                        &TestInterBssConstantObssPdAlgo::CheckPhyDropReasons,

                        this,

                        sta_device1,

                        dropReasons);

    Simulator::Schedule(Seconds(2.1) + MicroSeconds(100),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device1,

                        expectPhyReset ? WifiPhyState::TX : stateDuringPayloadNeighboringBss);

    Simulator::Schedule(Seconds(2.1) + MicroSeconds(100),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device2,

                        WifiPhyState::RX);

    Simulator::Schedule(Seconds(2.1) + MicroSeconds(100),

                        &TestInterBssConstantObssPdAlgo::CheckPhyDropReasons,

                        this,

                        ap_device1,

                        dropReasons);

    Simulator::Schedule(Seconds(2.1) + MicroSeconds(100),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device1,

                        stateDuringPayloadNeighboringBss);

    Simulator::Schedule(Seconds(2.1) + MicroSeconds(142),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device1,

                        expectPhyReset ? WifiPhyState::RX : stateDuringPayloadNeighboringBss);


    // AP2 sends another packet 0.1s later, and STA1 wanting to send a packet during the payload of

    // the former.

    Simulator::Schedule(Seconds(2.2), &TestInterBssConstantObssPdAlgo::ClearDropReasons, this);

    Simulator::Schedule(Seconds(2.2),

                        &TestInterBssConstantObssPdAlgo::SetExpectedTxPower,

                        this,

                        m_txPowerDbm);

    Simulator::Schedule(Seconds(2.2),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device2,

                        sta_device2,

                        m_payloadSize2);

    // STA1 sends a packet 90us later (i.e. during payload of AP2). Even though AP2 is still

    // transmitting, STA1 can transmit simultaneously if it's PHY was reset by OBSS_PD SR.

    Simulator::Schedule(Seconds(2.2) + MicroSeconds(90),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        sta_device1,

                        ap_device1,

                        m_payloadSize1);

    if (expectPhyReset)

    {

        // In this case, we check the TX power is restricted (and set the expected value slightly

        // before transmission should occur)

        double expectedTxPower = std::min(m_txPowerDbm, 21 - (m_obssPdLevelDbm + 82));

        Simulator::Schedule(Seconds(2.2) + MicroSeconds(89),

                            &TestInterBssConstantObssPdAlgo::SetExpectedTxPower,

                            this,

                            expectedTxPower);

    }

    // Check simultaneous transmissions

    Simulator::Schedule(Seconds(2.2) + MicroSeconds(105),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device2,

                        WifiPhyState::TX);

    Simulator::Schedule(Seconds(2.2) + MicroSeconds(105),

                        &TestInterBssConstantObssPdAlgo::CheckPhyDropReasons,

                        this,

                        sta_device1,

                        dropReasons);

    Simulator::Schedule(Seconds(2.2) + MicroSeconds(105),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device1,

                        expectPhyReset ? WifiPhyState::TX : stateDuringPayloadNeighboringBss);

    Simulator::Schedule(Seconds(2.2) + MicroSeconds(105),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        sta_device2,

                        WifiPhyState::RX);

    Simulator::Schedule(Seconds(2.2) + MicroSeconds(105),

                        &TestInterBssConstantObssPdAlgo::CheckPhyDropReasons,

                        this,

                        ap_device1,

                        dropReasons);

    Simulator::Schedule(Seconds(2.2) + MicroSeconds(105),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device1,

                        stateDuringPayloadNeighboringBss);

    Simulator::Schedule(Seconds(2.2) + MicroSeconds(195),

                        &TestInterBssConstantObssPdAlgo::CheckPhyState,

                        this,

                        ap_device1,

                        expectPhyReset ? WifiPhyState::RX : stateDuringPayloadNeighboringBss);


    // Verify transmit power restrictions are not applied if access to the channel is requested

    // after ignored OBSS transmissions.


    Simulator::Schedule(Seconds(2.3),

                        &TestInterBssConstantObssPdAlgo::SetExpectedTxPower,

                        this,

                        m_txPowerDbm);

    // AP2 sends another packet 0.1s later. Power restriction should not be applied.

    Simulator::Schedule(Seconds(2.3),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device2,

                        sta_device2,

                        m_payloadSize2);

    // STA1 sends a packet 0.1s later. Power restriction should not be applied.

    Simulator::Schedule(Seconds(2.4),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        sta_device1,

                        ap_device1,

                        m_payloadSize1);


    // Verify a scenario that involves 3 networks in order to verify corner cases for transmit power

    // restrictions. First, there is a transmission on network 2 from STA to AP, followed by a

    // response from AP to STA. During that time, the STA on network 1 has a packet to send and

    // request access to the channel. If a CCA reset occurred, it starts deferring while

    // transmissions are ongoing from network 2. Before its backoff expires, a transmission on

    // network 3 occurs, also eventually triggering another CCA reset (depending on the scenario

    // that is being run). This test checks whether this sequence preserves transmit power

    // restrictions if CCA resets occurred, since STA 1 has been deferring during ignored OBSS

    // transmissions.


    Simulator::Schedule(Seconds(2.5),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        sta_device2,

                        ap_device2,

                        m_payloadSize2 / 10);

    Simulator::Schedule(Seconds(2.5) + MicroSeconds(15),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device2,

                        sta_device2,

                        m_payloadSize2 / 10);

    Simulator::Schedule(Seconds(2.5) + MicroSeconds(270),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device1,

                        sta_device1,

                        m_payloadSize1 / 10);

    Simulator::Schedule(Seconds(2.5) + MicroSeconds(300),

                        &TestInterBssConstantObssPdAlgo::SendOnePacket,

                        this,

                        ap_device3,

                        sta_device3,

                        m_payloadSize3 / 10);

    if (expectPhyReset)

    {

        // In this case, we check the TX power is restricted (and set the expected value slightly

        // before transmission should occur)

        double expectedTxPower = std::min(m_txPowerDbm, 21 - (m_obssPdLevelDbm + 82));

        Simulator::Schedule(Seconds(2.5) + MicroSeconds(338),

                            &TestInterBssConstantObssPdAlgo::SetExpectedTxPower,

                            this,

                            expectedTxPower);

    }


    Simulator::Stop(Seconds(2.6));

}


void

TestInterBssConstantObssPdAlgo::ResetResults()

{

    m_numSta1PacketsSent = 0;

    m_numSta2PacketsSent = 0;

    m_numAp1PacketsSent = 0;

    m_numAp2PacketsSent = 0;

    m_numSta1PacketsReceived = 0;

    m_numSta2PacketsReceived = 0;

    m_numAp1PacketsReceived = 0;

    m_numAp2PacketsReceived = 0;

    ClearDropReasons();

    m_expectedTxPowerDbm = m_txPowerDbm;

}


void

TestInterBssConstantObssPdAlgo::ClearDropReasons()

{

    m_dropReasonsSta1.clear();

    m_dropReasonsSta2.clear();

    m_dropReasonsAp1.clear();

    m_dropReasonsAp2.clear();

}


void

TestInterBssConstantObssPdAlgo::CheckResults()

{

    NS_TEST_ASSERT_MSG_EQ(m_numSta1PacketsSent,

                          4,

                          "The number of packets sent by STA1 is not correct!");

    NS_TEST_ASSERT_MSG_EQ(m_numSta2PacketsSent,

                          2,

                          "The number of packets sent by STA2 is not correct!");

    NS_TEST_ASSERT_MSG_EQ(m_numAp1PacketsSent,

                          2,

                          "The number of packets sent by AP1 is not correct!");

    NS_TEST_ASSERT_MSG_EQ(m_numAp2PacketsSent,

                          6,

                          "The number of packets sent by AP2 is not correct!");

    NS_TEST_ASSERT_MSG_EQ(m_numSta1PacketsReceived,

                          2,

                          "The number of packets received by STA1 is not correct!");

    NS_TEST_ASSERT_MSG_EQ(m_numSta2PacketsReceived,

                          6,

                          "The number of packets received by STA2 is not correct!");

    NS_TEST_ASSERT_MSG_EQ(m_numAp1PacketsReceived,

                          4,

                          "The number of packets received by AP1 is not correct!");

    NS_TEST_ASSERT_MSG_EQ(m_numAp2PacketsReceived,

                          2,

                          "The number of packets received by AP2 is not correct!");

}


void

TestInterBssConstantObssPdAlgo::NotifyPhyTxBegin(std::string context,

                                                 Ptr<const Packet> p,

                                                 double txPowerW)

{

    uint32_t idx = ConvertContextToNodeId(context);

    uint32_t pktSize = p->GetSize() - 38;

    if ((idx == 0) && ((pktSize == m_payloadSize1) || (pktSize == (m_payloadSize1 / 10))))

    {

        m_numSta1PacketsSent++;

        NS_TEST_EXPECT_MSG_EQ(TestDoubleIsEqual(WToDbm(txPowerW), m_expectedTxPowerDbm, 1e-12),

                              true,

                              "Tx power is not correct!");

    }

    else if ((idx == 1) && ((pktSize == m_payloadSize2) || (pktSize == (m_payloadSize2 / 10))))

    {

        m_numSta2PacketsSent++;

        NS_TEST_EXPECT_MSG_EQ(TestDoubleIsEqual(WToDbm(txPowerW), m_expectedTxPowerDbm, 1e-12),

                              true,

                              "Tx power is not correct!");

    }

    else if ((idx == 3) && ((pktSize == m_payloadSize1) || (pktSize == (m_payloadSize1 / 10))))

    {

        m_numAp1PacketsSent++;

        NS_TEST_EXPECT_MSG_EQ(TestDoubleIsEqual(WToDbm(txPowerW), m_expectedTxPowerDbm, 1e-12),

                              true,

                              "Tx power is not correct!");

    }

    else if ((idx == 4) && ((pktSize == m_payloadSize2) || (pktSize == (m_payloadSize2 / 10))))

    {

        m_numAp2PacketsSent++;

        NS_TEST_EXPECT_MSG_EQ(TestDoubleIsEqual(WToDbm(txPowerW), m_expectedTxPowerDbm, 1e-12),

                              true,

                              "Tx power is not correct!");

    }

}


void

TestInterBssConstantObssPdAlgo::NotifyPhyRxEnd(std::string context, Ptr<const Packet> p)

{

    uint32_t idx = ConvertContextToNodeId(context);

    uint32_t pktSize = p->GetSize() - 38;

    if ((idx == 0) && ((pktSize == m_payloadSize1) || (pktSize == (m_payloadSize1 / 10))))

    {

        m_numSta1PacketsReceived++;

    }

    else if ((idx == 1) && ((pktSize == m_payloadSize2) || (pktSize == (m_payloadSize2 / 10))))

    {

        m_numSta2PacketsReceived++;

    }

    else if ((idx == 3) && ((pktSize == m_payloadSize1) || (pktSize == (m_payloadSize1 / 10))))

    {

        m_numAp1PacketsReceived++;

    }

    else if ((idx == 4) && ((pktSize == m_payloadSize2) || (pktSize == (m_payloadSize2 / 10))))

    {

        m_numAp2PacketsReceived++;

    }

}


void

TestInterBssConstantObssPdAlgo::NotifyPhyRxDrop(std::string context,

                                                Ptr<const Packet> p,

                                                WifiPhyRxfailureReason reason)

{

    uint32_t idx = ConvertContextToNodeId(context);

    uint32_t pktSize = p->GetSize() - 38;

    if ((idx == 0) && ((pktSize != m_payloadSize1) && (pktSize != (m_payloadSize1 / 10))))

    {

        m_dropReasonsSta1.push_back(reason);

    }

    else if ((idx == 1) && ((pktSize != m_payloadSize2) && (pktSize != (m_payloadSize2 / 10))))

    {

        m_dropReasonsSta2.push_back(reason);

    }

    else if ((idx == 3) && ((pktSize != m_payloadSize1) && (pktSize != (m_payloadSize1 / 10))))

    {

        m_dropReasonsAp1.push_back(reason);

    }

    else if ((idx == 4) && ((pktSize != m_payloadSize2) && (pktSize != (m_payloadSize2 / 10))))

    {

        m_dropReasonsAp2.push_back(reason);

    }

}


void

TestInterBssConstantObssPdAlgo::SendOnePacket(Ptr<WifiNetDevice> tx_dev,

                                              Ptr<WifiNetDevice> rx_dev,

                                              uint32_t payloadSize)

{

    Ptr<Packet> p = Create<Packet>(payloadSize);

    tx_dev->Send(p, rx_dev->GetAddress(), 1);

}


void

TestInterBssConstantObssPdAlgo::SetExpectedTxPower(double txPowerDbm)

{

    m_expectedTxPowerDbm = txPowerDbm;

}


void

TestInterBssConstantObssPdAlgo::CheckPhyState(Ptr<WifiNetDevice> device, WifiPhyState expectedState)

{

    WifiPhyState currentState;

    PointerValue ptr;

    Ptr<WifiPhy> phy = DynamicCast<WifiPhy>(device->GetPhy());

    phy->GetAttribute("State", ptr);

    Ptr<WifiPhyStateHelper> state = DynamicCast<WifiPhyStateHelper>(ptr.Get<WifiPhyStateHelper>());

    currentState = state->GetState();

    NS_TEST_ASSERT_MSG_EQ(currentState,

                          expectedState,

                          "PHY State " << currentState << " does not match expected state "

                                       << expectedState << " at " << Simulator::Now());

}


void

TestInterBssConstantObssPdAlgo::CheckPhyDropReasons(

    Ptr<WifiNetDevice> device,

    std::vector<WifiPhyRxfailureReason> expectedDropReasons)

{

    std::vector<WifiPhyRxfailureReason> currentDropReasons;

    uint32_t nodeId = device->GetNode()->GetId();

    switch (nodeId)

    {

    case 0: // STA1

        currentDropReasons = m_dropReasonsSta1;

        break;

    case 1: // STA2

        currentDropReasons = m_dropReasonsSta2;

        break;

    case 3: // AP1

        currentDropReasons = m_dropReasonsAp1;

        break;

    case 4: // AP2

        currentDropReasons = m_dropReasonsAp2;

        break;

    default: // others, no attribute

        return;

    }

    NS_TEST_ASSERT_MSG_EQ(currentDropReasons.size(),

                          expectedDropReasons.size(),

                          "Number of drop reasons "

                              << currentDropReasons.size() << " does not match expected one "

                              << expectedDropReasons.size() << " at " << Simulator::Now());

    for (std::size_t i = 0; i < currentDropReasons.size(); ++i)

    {

        NS_TEST_ASSERT_MSG_EQ(currentDropReasons[i],

                              expectedDropReasons[i],

                              "Drop reason " << i << ": " << currentDropReasons[i]

                                             << " does not match expected reason "

                                             << expectedDropReasons[i] << " at "

                                             << Simulator::Now());

    }

}


void

TestInterBssConstantObssPdAlgo::RunOne()

{

    RngSeedManager::SetSeed(1);

    RngSeedManager::SetRun(3);

    int64_t streamNumber = 50;


    Config::Set("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/BE_MaxAmpduSize",

                UintegerValue(0));


    ResetResults();


    NodeContainer wifiStaNodes;

    wifiStaNodes.Create(3);


    NodeContainer wifiApNodes;

    wifiApNodes.Create(3);


    Ptr<MatrixPropagationLossModel> lossModel = CreateObject<MatrixPropagationLossModel>();

    lossModel->SetDefaultLoss(

        m_txPowerDbm - m_obssRxPowerDbm); // Force received RSSI to be equal to m_obssRxPowerDbm


    SpectrumWifiPhyHelper phy;

    phy.DisablePreambleDetectionModel();

    phy.SetFrameCaptureModel("ns3::SimpleFrameCaptureModel");

    Ptr<MultiModelSpectrumChannel> channel = CreateObject<MultiModelSpectrumChannel>();

    channel->SetPropagationDelayModel(CreateObject<ConstantSpeedPropagationDelayModel>());

    channel->AddPropagationLossModel(lossModel);

    phy.SetChannel(channel);

    phy.Set("TxPowerStart", DoubleValue(m_txPowerDbm));

    phy.Set("TxPowerEnd", DoubleValue(m_txPowerDbm));

    phy.Set("ChannelSettings", StringValue("{36, 20, BAND_5GHZ, 0}"));


    WifiHelper wifi;

    wifi.SetStandard(m_standard);

    wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager",

                                 "DataMode",

                                 StringValue("HeMcs5"),

                                 "ControlMode",

                                 StringValue("HeMcs0"));


    wifi.SetObssPdAlgorithm("ns3::ConstantObssPdAlgorithm",

                            "ObssPdLevel",

                            DoubleValue(m_obssPdLevelDbm));


    WifiMacHelper mac;

    Ssid ssid = Ssid("ns-3-ssid");

    mac.SetType("ns3::StaWifiMac", "Ssid", SsidValue(ssid));

    m_staDevices = wifi.Install(phy, mac, wifiStaNodes);


    // Assign fixed streams to random variables in use

    wifi.AssignStreams(m_staDevices, streamNumber);


    mac.SetType("ns3::ApWifiMac", "Ssid", SsidValue(ssid));

    m_apDevices = wifi.Install(phy, mac, wifiApNodes);


    // Assign fixed streams to random variables in use

    wifi.AssignStreams(m_apDevices, streamNumber);


    for (uint32_t i = 0; i < m_apDevices.GetN(); i++)

    {

        Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice>(m_apDevices.Get(i));

        Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration();

        if (i == 0)

        {

            heConfiguration->SetAttribute("BssColor", UintegerValue(m_bssColor1));

        }

        else if (i == 1)

        {

            heConfiguration->SetAttribute("BssColor", UintegerValue(m_bssColor2));

        }

        else

        {

            heConfiguration->SetAttribute("BssColor", UintegerValue(m_bssColor3));

        }

    }


    MobilityHelper mobility;

    Ptr<ListPositionAllocator> positionAlloc = AllocatePositions(

        10,

        50,

        10,

        50,

        10); // distances do not really matter since we set RSSI per TX-RX pair to have full control

    mobility.SetPositionAllocator(positionAlloc);

    mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");

    mobility.Install(wifiApNodes);

    mobility.Install(wifiStaNodes);


    lossModel->SetLoss(wifiStaNodes.Get(0)->GetObject<MobilityModel>(),

                       wifiApNodes.Get(0)->GetObject<MobilityModel>(),

                       m_txPowerDbm + 30); // Low attenuation for IBSS transmissions

    lossModel->SetLoss(wifiStaNodes.Get(1)->GetObject<MobilityModel>(),

                       wifiApNodes.Get(1)->GetObject<MobilityModel>(),

                       m_txPowerDbm + 30); // Low attenuation for IBSS transmissions

    lossModel->SetLoss(wifiStaNodes.Get(2)->GetObject<MobilityModel>(),

                       wifiApNodes.Get(2)->GetObject<MobilityModel>(),

                       m_txPowerDbm + 30); // Low attenuation for IBSS transmissions


    Config::Connect("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxBegin",

                    MakeCallback(&TestInterBssConstantObssPdAlgo::NotifyPhyTxBegin, this));

    Config::Connect("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxEnd",

                    MakeCallback(&TestInterBssConstantObssPdAlgo::NotifyPhyRxEnd, this));

    Config::Connect("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxDrop",

                    MakeCallback(&TestInterBssConstantObssPdAlgo::NotifyPhyRxDrop, this));


    SetupSimulation();


    Simulator::Run();

    Simulator::Destroy();


    CheckResults();

}


void

TestInterBssConstantObssPdAlgo::DoRun()

{

    // Test case 1: CCA CS Threshold = m_obssRxPowerDbm < m_obssPdLevelDbm

    m_obssPdLevelDbm = -72;

    m_obssRxPowerDbm = -82;

    m_bssColor1 = 1;

    m_bssColor2 = 2;

    m_bssColor3 = 3;

    RunOne();


    // Test case 2: CCA CS Threshold < m_obssPdLevelDbm < m_obssRxPowerDbm

    m_obssPdLevelDbm = -72;

    m_obssRxPowerDbm = -62;

    m_bssColor1 = 1;

    m_bssColor2 = 2;

    m_bssColor3 = 3;

    RunOne();


    // Test case 3: CCA CS Threshold < m_obssPdLevelDbm = m_obssRxPowerDbm

    m_obssPdLevelDbm = -72;

    m_obssRxPowerDbm = -72;

    m_bssColor1 = 1;

    m_bssColor2 = 2;

    m_bssColor3 = 3;

    RunOne();


    // Test case 4: CCA CS Threshold = m_obssRxPowerDbm < m_obssPdLevelDbm with BSS color 2 and 3

    // set to 0

    m_obssPdLevelDbm = -72;

    m_obssRxPowerDbm = -82;

    m_bssColor1 = 1;

    m_bssColor2 = 0;

    m_bssColor3 = 0;

    RunOne();


    // Test case 5: CCA CS Threshold = m_obssRxPowerDbm < m_obssPdLevelDbm with BSS color 1 set to 0

    m_obssPdLevelDbm = -72;

    m_obssRxPowerDbm = -82;

    m_bssColor1 = 0;

    m_bssColor2 = 2;

    m_bssColor3 = 3;

    RunOne();

}


class InterBssTestSuite : public TestSuite

{

  public:

    InterBssTestSuite();

};


InterBssTestSuite::InterBssTestSuite()

    : TestSuite("wifi-inter-bss", UNIT)

{

    AddTestCase(new TestInterBssConstantObssPdAlgo(WIFI_STANDARD_80211ax), TestCase::QUICK);

    AddTestCase(new TestInterBssConstantObssPdAlgo(WIFI_STANDARD_80211be), TestCase::QUICK);

}


// Do not forget to allocate an instance of this TestSuite

static InterBssTestSuite interBssTestSuite;

InterBssTestSuite
Inter BSS Test Suite.
Definition: inter-bss-test-suite.cc:994

InterBssTestSuite::InterBssTestSuite
InterBssTestSuite()
Definition: inter-bss-test-suite.cc:999

TestInterBssConstantObssPdAlgo
Wifi Test.
Definition: inter-bss-test-suite.cc:78

TestInterBssConstantObssPdAlgo::m_numSta2PacketsSent
unsigned int m_numSta2PacketsSent
number of sent packets from STA2
Definition: inter-bss-test-suite.cc:184

TestInterBssConstantObssPdAlgo::m_numAp2PacketsReceived
unsigned int m_numAp2PacketsReceived
number of received packets from AP2
Definition: inter-bss-test-suite.cc:191

TestInterBssConstantObssPdAlgo::m_numSta1PacketsSent
unsigned int m_numSta1PacketsSent
number of sent packets from STA1
Definition: inter-bss-test-suite.cc:183

TestInterBssConstantObssPdAlgo::m_obssRxPowerDbm
double m_obssRxPowerDbm
forced RX power in dBm for OBSS
Definition: inter-bss-test-suite.cc:207

TestInterBssConstantObssPdAlgo::m_payloadSize2
unsigned int m_payloadSize2
size in bytes of packet payload in BSS 2
Definition: inter-bss-test-suite.cc:199

TestInterBssConstantObssPdAlgo::AllocatePositions
Ptr< ListPositionAllocator > AllocatePositions(double d1, double d2, double d3, double d4, double d5)
Allocate the node positions.
Definition: inter-bss-test-suite.cc:247

TestInterBssConstantObssPdAlgo::ClearDropReasons
void ClearDropReasons()
Clear the drop reasons.
Definition: inter-bss-test-suite.cc:635

TestInterBssConstantObssPdAlgo::m_dropReasonsAp2
std::vector< WifiPhyRxfailureReason > m_dropReasonsAp2
drop reasons for AP2
Definition: inter-bss-test-suite.cc:196

TestInterBssConstantObssPdAlgo::RunOne
void RunOne()
Run one function.
Definition: inter-bss-test-suite.cc:828

TestInterBssConstantObssPdAlgo::SetupSimulation
void SetupSimulation()
Setup the simulation.
Definition: inter-bss-test-suite.cc:264

TestInterBssConstantObssPdAlgo::CheckPhyDropReasons
void CheckPhyDropReasons(Ptr< WifiNetDevice > device, std::vector< WifiPhyRxfailureReason > expectedDropReasons)
Check if the Phy drop reasons for a device are as expected.
Definition: inter-bss-test-suite.cc:788

TestInterBssConstantObssPdAlgo::SetExpectedTxPower
void SetExpectedTxPower(double txPowerDbm)
Set the expected transmit power in dBm.
Definition: inter-bss-test-suite.cc:767

TestInterBssConstantObssPdAlgo::m_payloadSize3
unsigned int m_payloadSize3
size in bytes of packet payload in BSS 3
Definition: inter-bss-test-suite.cc:200

TestInterBssConstantObssPdAlgo::NotifyPhyTxBegin
void NotifyPhyTxBegin(std::string context, Ptr< const Packet > p, double txPowerW)
Notify Phy transmit begin.
Definition: inter-bss-test-suite.cc:673

TestInterBssConstantObssPdAlgo::m_payloadSize1
unsigned int m_payloadSize1
size in bytes of packet payload in BSS 1
Definition: inter-bss-test-suite.cc:198

TestInterBssConstantObssPdAlgo::ResetResults
void ResetResults()
Reset the results.
Definition: inter-bss-test-suite.cc:620

TestInterBssConstantObssPdAlgo::m_numSta2PacketsReceived
unsigned int m_numSta2PacketsReceived
number of received packets from STA2
Definition: inter-bss-test-suite.cc:189

TestInterBssConstantObssPdAlgo::m_numAp2PacketsSent
unsigned int m_numAp2PacketsSent
number of sent packets from AP2
Definition: inter-bss-test-suite.cc:186

TestInterBssConstantObssPdAlgo::CheckPhyState
void CheckPhyState(Ptr< WifiNetDevice > device, WifiPhyState expectedState)
Check if the Phy State for a device is an expected value.
Definition: inter-bss-test-suite.cc:773

TestInterBssConstantObssPdAlgo::CheckResults
void CheckResults()
Check the results.
Definition: inter-bss-test-suite.cc:644

TestInterBssConstantObssPdAlgo::NotifyPhyRxDrop
void NotifyPhyRxDrop(std::string context, Ptr< const Packet > p, WifiPhyRxfailureReason reason)
Notify Phy receive drops.
Definition: inter-bss-test-suite.cc:733

TestInterBssConstantObssPdAlgo::m_bssColor1
uint8_t m_bssColor1
color for BSS 1
Definition: inter-bss-test-suite.cc:210

TestInterBssConstantObssPdAlgo::m_staDevices
NetDeviceContainer m_staDevices
STA devices.
Definition: inter-bss-test-suite.cc:202

TestInterBssConstantObssPdAlgo::m_dropReasonsSta1
std::vector< WifiPhyRxfailureReason > m_dropReasonsSta1
drop reasons for STA1
Definition: inter-bss-test-suite.cc:193

TestInterBssConstantObssPdAlgo::NotifyPhyRxEnd
void NotifyPhyRxEnd(std::string context, Ptr< const Packet > p)
Notify Phy receive ends.
Definition: inter-bss-test-suite.cc:710

TestInterBssConstantObssPdAlgo::SendOnePacket
void SendOnePacket(Ptr< WifiNetDevice > tx_dev, Ptr< WifiNetDevice > rx_dev, uint32_t payloadSize)
Send one packet function.
Definition: inter-bss-test-suite.cc:758

TestInterBssConstantObssPdAlgo::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: inter-bss-test-suite.cc:942

TestInterBssConstantObssPdAlgo::TestInterBssConstantObssPdAlgo
TestInterBssConstantObssPdAlgo(WifiStandard standard)
Constructor.
Definition: inter-bss-test-suite.cc:217

TestInterBssConstantObssPdAlgo::m_dropReasonsSta2
std::vector< WifiPhyRxfailureReason > m_dropReasonsSta2
drop reasons for STA2
Definition: inter-bss-test-suite.cc:194

TestInterBssConstantObssPdAlgo::m_apDevices
NetDeviceContainer m_apDevices
AP devices.
Definition: inter-bss-test-suite.cc:203

TestInterBssConstantObssPdAlgo::m_bssColor3
uint8_t m_bssColor3
color for BSS 3
Definition: inter-bss-test-suite.cc:212

TestInterBssConstantObssPdAlgo::m_numAp1PacketsSent
unsigned int m_numAp1PacketsSent
number of sent packets from AP1
Definition: inter-bss-test-suite.cc:185

TestInterBssConstantObssPdAlgo::m_bssColor2
uint8_t m_bssColor2
color for BSS 2
Definition: inter-bss-test-suite.cc:211

TestInterBssConstantObssPdAlgo::m_txPowerDbm
double m_txPowerDbm
configured transmit power in dBm
Definition: inter-bss-test-suite.cc:205

TestInterBssConstantObssPdAlgo::m_dropReasonsAp1
std::vector< WifiPhyRxfailureReason > m_dropReasonsAp1
drop reasons for AP1
Definition: inter-bss-test-suite.cc:195

TestInterBssConstantObssPdAlgo::m_numSta1PacketsReceived
unsigned int m_numSta1PacketsReceived
number of received packets from STA1
Definition: inter-bss-test-suite.cc:188

TestInterBssConstantObssPdAlgo::m_numAp1PacketsReceived
unsigned int m_numAp1PacketsReceived
number of received packets from AP1
Definition: inter-bss-test-suite.cc:190

TestInterBssConstantObssPdAlgo::~TestInterBssConstantObssPdAlgo
~TestInterBssConstantObssPdAlgo() override
Definition: inter-bss-test-suite.cc:241

TestInterBssConstantObssPdAlgo::m_standard
WifiStandard m_standard
the standard to use for the test
Definition: inter-bss-test-suite.cc:214

TestInterBssConstantObssPdAlgo::m_obssPdLevelDbm
double m_obssPdLevelDbm
OBSS-PD level in dBm.
Definition: inter-bss-test-suite.cc:206

TestInterBssConstantObssPdAlgo::m_expectedTxPowerDbm
double m_expectedTxPowerDbm
expected transmit power in dBm
Definition: inter-bss-test-suite.cc:208

ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42

ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:44

ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:40

ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43

ns3::NetDeviceContainer::GetN
uint32_t GetN() const
Get the number of Ptr<NetDevice> stored in this container.
Definition: net-device-container.cc:61

ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition: net-device-container.cc:67

ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:40

ns3::NodeContainer::Create
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Definition: node-container.cc:84

ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Definition: node-container.cc:78

ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471

ns3::PointerValue
Hold objects of type Ptr<T>.
Definition: pointer.h:37

ns3::PointerValue::Get
Ptr< T > Get() const
Definition: pointer.h:202

ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78

ns3::RngSeedManager::SetRun
static void SetRun(uint64_t run)
Set the run number of simulation.
Definition: rng-seed-manager.cc:90

ns3::RngSeedManager::SetSeed
static void SetSeed(uint32_t seed)
Set the seed.
Definition: rng-seed-manager.cc:83

ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:568

ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:140

ns3::Simulator::Now
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:199

ns3::Simulator::Run
static void Run()
Run the simulation.
Definition: simulator.cc:176

ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:184

ns3::SpectrumWifiPhyHelper
Make it easy to create and manage PHY objects for the spectrum model.
Definition: spectrum-wifi-helper.h:41

ns3::Ssid
The IEEE 802.11 SSID Information Element.
Definition: ssid.h:36

SsidValue
AttributeValue implementation for Ssid.

ns3::StringValue
Hold variables of type string.
Definition: string.h:56

ns3::TestCase
encapsulates test code
Definition: test.h:1060

ns3::TestCase::QUICK
@ QUICK
Fast test.
Definition: test.h:1065

ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:301

ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256

ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:45

ns3::WifiHelper
helps to create WifiNetDevice objects
Definition: wifi-helper.h:324

ns3::WifiMacHelper
create MAC layers for a ns3::WifiNetDevice.
Definition: wifi-mac-helper.h:48

ns3::WifiPhyStateHelper
This objects implements the PHY state machine of the Wifi device.
Definition: wifi-phy-state-helper.h:69

uint32_t

ns3::Config::Connect
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:975

ns3::Config::Set
void Set(std::string path, const AttributeValue &value)
Definition: config.cc:877

NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202

ns3::TestDoubleIsEqual
bool TestDoubleIsEqual(const double x1, const double x2, const double epsilon)
Compare two double precision floating point numbers and declare them equal if they are within some ep...
Definition: test.cc:45

NS_TEST_ASSERT_MSG_EQ
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:144

NS_TEST_EXPECT_MSG_EQ
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
Definition: test.h:251

ns3::MicroSeconds
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1360

ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336

ns3::WifiStandard
WifiStandard
Identifies the IEEE 802.11 specifications that a Wifi device can be configured to use.
Definition: wifi-standards.h:38

ns3::WifiPhyRxfailureReason
WifiPhyRxfailureReason
Enumeration of the possible reception failure reasons.
Definition: wifi-phy-common.h:401

ns3::WIFI_STANDARD_80211be
@ WIFI_STANDARD_80211be
Definition: wifi-standards.h:48

ns3::WIFI_STANDARD_80211ax
@ WIFI_STANDARD_80211ax
Definition: wifi-standards.h:47

ns3::OBSS_PD_CCA_RESET
@ OBSS_PD_CCA_RESET
Definition: wifi-phy-common.h:421

ns3::FILTERED
@ FILTERED
Definition: wifi-phy-common.h:423

ConvertContextToNodeId
static uint32_t ConvertContextToNodeId(std::string context)
Definition: inter-bss-test-suite.cc:43

interBssTestSuite
static InterBssTestSuite interBssTestSuite
Definition: inter-bss-test-suite.cc:1007

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.

ns3::WToDbm
double WToDbm(double w)
Convert from Watts to dBm.
Definition: wifi-utils.cc:46

ns3::MakeCallback
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:702

pktSize
uint32_t pktSize
packet size used for the simulation (in bytes)
Definition: wifi-bianchi.cc:115

WifiPhyState
WifiPhyState
The state of the PHY layer.
Definition: wifi-phy-state.h:31