3.28/doxygen/wifi-test_8cc_source.html

 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

 /*

  * Copyright (c) 2005,2006 INRIA

  *               2010      NICTA

  *

  * 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: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

  *          Quincy Tse <quincy.tse@nicta.com.au>

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

  */


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

 #include "ns3/mobility-helper.h"

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

 #include "ns3/adhoc-wifi-mac.h"

 #include "ns3/propagation-delay-model.h"

 #include "ns3/propagation-loss-model.h"

 #include "ns3/yans-error-rate-model.h"

 #include "ns3/constant-position-mobility-model.h"

 #include "ns3/test.h"

 #include "ns3/pointer.h"

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

 #include "ns3/config.h"

 #include "ns3/string.h"

 #include "ns3/packet-socket-server.h"

 #include "ns3/packet-socket-client.h"

 #include "ns3/packet-socket-helper.h"

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

 #include "ns3/spectrum-value.h"

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

 #include "ns3/wifi-spectrum-signal-parameters.h"

 #include "ns3/wifi-phy-tag.h"

 #include <tuple>

 #include <vector>


 using namespace ns3;


 //Helper function to assign streams to random variables, to control

 //randomness in the tests

 static void

 AssignWifiRandomStreams (Ptr<WifiMac> mac, int64_t stream)

 {

   int64_t currentStream = stream;

   Ptr<RegularWifiMac> rmac = DynamicCast<RegularWifiMac> (mac);

   if (rmac)

     {

       PointerValue ptr;

       rmac->GetAttribute ("DcaTxop", ptr);

       Ptr<DcaTxop> dcaTxop = ptr.Get<DcaTxop> ();

       currentStream += dcaTxop->AssignStreams (currentStream);


       rmac->GetAttribute ("VO_EdcaTxopN", ptr);

       Ptr<EdcaTxopN> vo_edcaTxopN = ptr.Get<EdcaTxopN> ();

       currentStream += vo_edcaTxopN->AssignStreams (currentStream);


       rmac->GetAttribute ("VI_EdcaTxopN", ptr);

       Ptr<EdcaTxopN> vi_edcaTxopN = ptr.Get<EdcaTxopN> ();

       currentStream += vi_edcaTxopN->AssignStreams (currentStream);


       rmac->GetAttribute ("BE_EdcaTxopN", ptr);

       Ptr<EdcaTxopN> be_edcaTxopN = ptr.Get<EdcaTxopN> ();

       currentStream += be_edcaTxopN->AssignStreams (currentStream);


       rmac->GetAttribute ("BK_EdcaTxopN", ptr);

       Ptr<EdcaTxopN> bk_edcaTxopN = ptr.Get<EdcaTxopN> ();

       bk_edcaTxopN->AssignStreams (currentStream);

     }

 }


 class WifiTest : public TestCase

 {

 public:

   WifiTest ();


   virtual void DoRun (void);


 private:

   void RunOne (void);

   void CreateOne (Vector pos, Ptr<YansWifiChannel> channel);

   void SendOnePacket (Ptr<WifiNetDevice> dev);


   ObjectFactory m_manager;

   ObjectFactory m_mac;

   ObjectFactory m_propDelay;

 };


 WifiTest::WifiTest ()

   : TestCase ("Wifi")

 {

 }


 void

 WifiTest::SendOnePacket (Ptr<WifiNetDevice> dev)

 {

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

   dev->Send (p, dev->GetBroadcast (), 1);

 }


 void

 WifiTest::CreateOne (Vector pos, Ptr<YansWifiChannel> channel)

 {

   Ptr<Node> node = CreateObject<Node> ();

   Ptr<WifiNetDevice> dev = CreateObject<WifiNetDevice> ();


   Ptr<WifiMac> mac = m_mac.Create<WifiMac> ();

   mac->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

   Ptr<ConstantPositionMobilityModel> mobility = CreateObject<ConstantPositionMobilityModel> ();

   Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy> ();

   Ptr<ErrorRateModel> error = CreateObject<YansErrorRateModel> ();

   phy->SetErrorRateModel (error);

   phy->SetChannel (channel);

   phy->SetDevice (dev);

   phy->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

   Ptr<WifiRemoteStationManager> manager = m_manager.Create<WifiRemoteStationManager> ();


   mobility->SetPosition (pos);

   node->AggregateObject (mobility);

   mac->SetAddress (Mac48Address::Allocate ());

   dev->SetMac (mac);

   dev->SetPhy (phy);

   dev->SetRemoteStationManager (manager);

   node->AddDevice (dev);


   Simulator::Schedule (Seconds (1.0), &WifiTest::SendOnePacket, this, dev);

 }


 void

 WifiTest::RunOne (void)

 {

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

   Ptr<PropagationDelayModel> propDelay = m_propDelay.Create<PropagationDelayModel> ();

   Ptr<PropagationLossModel> propLoss = CreateObject<RandomPropagationLossModel> ();

   channel->SetPropagationDelayModel (propDelay);

   channel->SetPropagationLossModel (propLoss);


   CreateOne (Vector (0.0, 0.0, 0.0), channel);

   CreateOne (Vector (5.0, 0.0, 0.0), channel);

   CreateOne (Vector (5.0, 0.0, 0.0), channel);


   Simulator::Stop (Seconds (10.0));


   Simulator::Run ();

   Simulator::Destroy ();

 }


 void

 WifiTest::DoRun (void)

 {

   m_mac.SetTypeId ("ns3::AdhocWifiMac");

   m_propDelay.SetTypeId ("ns3::ConstantSpeedPropagationDelayModel");


   m_manager.SetTypeId ("ns3::ArfWifiManager");

   RunOne ();

   m_manager.SetTypeId ("ns3::AarfWifiManager");

   RunOne ();

   m_manager.SetTypeId ("ns3::ConstantRateWifiManager");

   RunOne ();

   m_manager.SetTypeId ("ns3::OnoeWifiManager");

   RunOne ();

   m_manager.SetTypeId ("ns3::AmrrWifiManager");

   RunOne ();

   m_manager.SetTypeId ("ns3::IdealWifiManager");

   RunOne ();


   m_mac.SetTypeId ("ns3::AdhocWifiMac");

   RunOne ();

   m_mac.SetTypeId ("ns3::ApWifiMac");

   RunOne ();

   m_mac.SetTypeId ("ns3::StaWifiMac");

   RunOne ();


   m_propDelay.SetTypeId ("ns3::RandomPropagationDelayModel");

   m_mac.SetTypeId ("ns3::AdhocWifiMac");

   RunOne ();

 }


 class QosUtilsIsOldPacketTest : public TestCase

 {

 public:

   QosUtilsIsOldPacketTest () : TestCase ("QosUtilsIsOldPacket")

   {

   }

   virtual void DoRun (void)

   {

     //startingSeq=0, seqNum=2047

     NS_TEST_EXPECT_MSG_EQ (QosUtilsIsOldPacket (0, 2047), false, "2047 is new in comparison to 0");

     //startingSeq=0, seqNum=2048

     NS_TEST_EXPECT_MSG_EQ (QosUtilsIsOldPacket (0, 2048), true, "2048 is old in comparison to 0");

     //startingSeq=2048, seqNum=0

     NS_TEST_EXPECT_MSG_EQ (QosUtilsIsOldPacket (2048, 0), true, "0 is old in comparison to 2048");

     //startingSeq=4095, seqNum=0

     NS_TEST_EXPECT_MSG_EQ (QosUtilsIsOldPacket (4095, 0), false, "0 is new in comparison to 4095");

     //startingSeq=0, seqNum=4095

     NS_TEST_EXPECT_MSG_EQ (QosUtilsIsOldPacket (0, 4095), true, "4095 is old in comparison to 0");

     //startingSeq=4095 seqNum=2047

     NS_TEST_EXPECT_MSG_EQ (QosUtilsIsOldPacket (4095, 2047), true, "2047 is old in comparison to 4095");

     //startingSeq=2048 seqNum=4095

     NS_TEST_EXPECT_MSG_EQ (QosUtilsIsOldPacket (2048, 4095), false, "4095 is new in comparison to 2048");

     //startingSeq=2049 seqNum=0

     NS_TEST_EXPECT_MSG_EQ (QosUtilsIsOldPacket (2049, 0), false, "0 is new in comparison to 2049");

   }

 };


 class InterferenceHelperSequenceTest : public TestCase

 {

 public:

   InterferenceHelperSequenceTest ();


   virtual void DoRun (void);


 private:

   Ptr<Node> CreateOne (Vector pos, Ptr<YansWifiChannel> channel);

   void SendOnePacket (Ptr<WifiNetDevice> dev);

   void SwitchCh (Ptr<WifiNetDevice> dev);


   ObjectFactory m_manager;

   ObjectFactory m_mac;

   ObjectFactory m_propDelay;

 };


 InterferenceHelperSequenceTest::InterferenceHelperSequenceTest ()

   : TestCase ("InterferenceHelperSequence")

 {

 }


 void

 InterferenceHelperSequenceTest::SendOnePacket (Ptr<WifiNetDevice> dev)

 {

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

   dev->Send (p, dev->GetBroadcast (), 1);

 }


 void

 InterferenceHelperSequenceTest::SwitchCh (Ptr<WifiNetDevice> dev)

 {

   Ptr<WifiPhy> p = dev->GetPhy ();

   p->SetChannelNumber (1);

 }


 Ptr<Node>

 InterferenceHelperSequenceTest::CreateOne (Vector pos, Ptr<YansWifiChannel> channel)

 {

   Ptr<Node> node = CreateObject<Node> ();

   Ptr<WifiNetDevice> dev = CreateObject<WifiNetDevice> ();


   Ptr<WifiMac> mac = m_mac.Create<WifiMac> ();

   mac->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

   Ptr<ConstantPositionMobilityModel> mobility = CreateObject<ConstantPositionMobilityModel> ();

   Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy> ();

   Ptr<ErrorRateModel> error = CreateObject<YansErrorRateModel> ();

   phy->SetErrorRateModel (error);

   phy->SetChannel (channel);

   phy->SetDevice (dev);

   phy->SetMobility (mobility);

   phy->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

   Ptr<WifiRemoteStationManager> manager = m_manager.Create<WifiRemoteStationManager> ();


   mobility->SetPosition (pos);

   node->AggregateObject (mobility);

   mac->SetAddress (Mac48Address::Allocate ());

   dev->SetMac (mac);

   dev->SetPhy (phy);

   dev->SetRemoteStationManager (manager);

   node->AddDevice (dev);


   return node;

 }


 void

 InterferenceHelperSequenceTest::DoRun (void)

 {

   m_mac.SetTypeId ("ns3::AdhocWifiMac");

   m_propDelay.SetTypeId ("ns3::ConstantSpeedPropagationDelayModel");

   m_manager.SetTypeId ("ns3::ConstantRateWifiManager");


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

   Ptr<PropagationDelayModel> propDelay = m_propDelay.Create<PropagationDelayModel> ();

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

   channel->SetPropagationDelayModel (propDelay);

   channel->SetPropagationLossModel (propLoss);


   Ptr<Node> rxOnly = CreateOne (Vector (0.0, 0.0, 0.0), channel);

   Ptr<Node> senderA = CreateOne (Vector (5.0, 0.0, 0.0), channel);

   Ptr<Node> senderB = CreateOne (Vector (-5.0, 0.0, 0.0), channel);


   propLoss->SetLoss (senderB->GetObject<MobilityModel> (), rxOnly->GetObject<MobilityModel> (), 0, true);

   propLoss->SetDefaultLoss (999);


   Simulator::Schedule (Seconds (1.0),

                        &InterferenceHelperSequenceTest::SendOnePacket, this,

                        DynamicCast<WifiNetDevice> (senderB->GetDevice (0)));


   Simulator::Schedule (Seconds (1.0000001),

                        &InterferenceHelperSequenceTest::SwitchCh, this,

                        DynamicCast<WifiNetDevice> (rxOnly->GetDevice (0)));


   Simulator::Schedule (Seconds (5.0),

                        &InterferenceHelperSequenceTest::SendOnePacket, this,

                        DynamicCast<WifiNetDevice> (senderA->GetDevice (0)));


   Simulator::Schedule (Seconds (7.0),

                        &InterferenceHelperSequenceTest::SendOnePacket, this,

                        DynamicCast<WifiNetDevice> (senderB->GetDevice (0)));


   Simulator::Stop (Seconds (100.0));

   Simulator::Run ();


   Simulator::Destroy ();

 }


 //-----------------------------------------------------------------------------

 class DcfImmediateAccessBroadcastTestCase : public TestCase

 {

 public:

   DcfImmediateAccessBroadcastTestCase ();


   virtual void DoRun (void);


 private:

   void SendOnePacket (Ptr<WifiNetDevice> dev);


   ObjectFactory m_manager;

   ObjectFactory m_mac;

   ObjectFactory m_propDelay;


   Time m_firstTransmissionTime;

   Time m_secondTransmissionTime;

   unsigned int m_numSentPackets;


   void NotifyPhyTxBegin (Ptr<const Packet> p);

 };


 DcfImmediateAccessBroadcastTestCase::DcfImmediateAccessBroadcastTestCase ()

   : TestCase ("Test case for DCF immediate access with broadcast frames")

 {

 }


 void

 DcfImmediateAccessBroadcastTestCase::NotifyPhyTxBegin (Ptr<const Packet> p)

 {

   if (m_numSentPackets == 0)

     {

       NS_ASSERT_MSG (Simulator::Now () == Time (Seconds (1)), "Packet 0 not transmitted at 1 second");

       m_numSentPackets++;

       m_firstTransmissionTime = Simulator::Now ();

     }

   else if (m_numSentPackets == 1)

     {

       m_secondTransmissionTime = Simulator::Now ();

     }

 }


 void

 DcfImmediateAccessBroadcastTestCase::SendOnePacket (Ptr<WifiNetDevice> dev)

 {

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

   dev->Send (p, dev->GetBroadcast (), 1);

 }


 void

 DcfImmediateAccessBroadcastTestCase::DoRun (void)

 {

   m_mac.SetTypeId ("ns3::AdhocWifiMac");

   m_propDelay.SetTypeId ("ns3::ConstantSpeedPropagationDelayModel");

   m_manager.SetTypeId ("ns3::ConstantRateWifiManager");


   //Assign a seed and run number, and later fix the assignment of streams to

   //WiFi random variables, so that the first backoff used is one slot

   RngSeedManager::SetSeed (1);

   RngSeedManager::SetRun (40);  // a value of 17 will result in zero slots


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

   Ptr<PropagationDelayModel> propDelay = m_propDelay.Create<PropagationDelayModel> ();

   Ptr<PropagationLossModel> propLoss = CreateObject<RandomPropagationLossModel> ();

   channel->SetPropagationDelayModel (propDelay);

   channel->SetPropagationLossModel (propLoss);


   Ptr<Node> txNode = CreateObject<Node> ();

   Ptr<WifiNetDevice> txDev = CreateObject<WifiNetDevice> ();

   Ptr<WifiMac> txMac = m_mac.Create<WifiMac> ();

   txMac->ConfigureStandard (WIFI_PHY_STANDARD_80211a);

   //Fix the stream assignment to the Dcf Txop objects (backoffs)

   //The below stream assignment will result in the DcaTxop object

   //using a backoff value of zero for this test when the

   //DcaTxop::EndTxNoAck() calls to StartBackoffNow()

   AssignWifiRandomStreams (txMac, 23);


   Ptr<ConstantPositionMobilityModel> txMobility = CreateObject<ConstantPositionMobilityModel> ();

   Ptr<YansWifiPhy> txPhy = CreateObject<YansWifiPhy> ();

   Ptr<ErrorRateModel> txError = CreateObject<YansErrorRateModel> ();

   txPhy->SetErrorRateModel (txError);

   txPhy->SetChannel (channel);

   txPhy->SetDevice (txDev);

   txPhy->SetMobility (txMobility);

   txPhy->ConfigureStandard (WIFI_PHY_STANDARD_80211a);


   txPhy->TraceConnectWithoutContext ("PhyTxBegin", MakeCallback (&DcfImmediateAccessBroadcastTestCase::NotifyPhyTxBegin, this));


   txMobility->SetPosition (Vector (0.0, 0.0, 0.0));

   txNode->AggregateObject (txMobility);

   txMac->SetAddress (Mac48Address::Allocate ());

   txDev->SetMac (txMac);

   txDev->SetPhy (txPhy);

   txDev->SetRemoteStationManager (m_manager.Create<WifiRemoteStationManager> ());

   txNode->AddDevice (txDev);


   m_firstTransmissionTime = Seconds (0.0);

   m_secondTransmissionTime = Seconds (0.0);

   m_numSentPackets = 0;


   Simulator::Schedule (Seconds (1.0), &DcfImmediateAccessBroadcastTestCase::SendOnePacket, this, txDev);

   Simulator::Schedule (Seconds (1.0) + MicroSeconds (1), &DcfImmediateAccessBroadcastTestCase::SendOnePacket, this, txDev);


   Simulator::Stop (Seconds (2.0));

   Simulator::Run ();

   Simulator::Destroy ();


   //First packet has 1408 us of transmit time.   Slot time is 9 us.

   //Backoff is 1 slots.  SIFS is 16 us.  DIFS is 2 slots = 18 us.

   //Should send next packet at 1408 us + (1 * 9 us) + 16 us + (2 * 9) us

   //1451 us after the first one.

   uint32_t expectedWait1 = 1408 + (1 * 9) + 16 + (2 * 9);

   Time expectedSecondTransmissionTime = MicroSeconds (expectedWait1) + MilliSeconds (1000);

   NS_TEST_ASSERT_MSG_EQ (m_firstTransmissionTime, MilliSeconds (1000), "The first transmission time not correct!");


   NS_TEST_ASSERT_MSG_EQ (m_secondTransmissionTime, expectedSecondTransmissionTime, "The second transmission time not correct!");

 }


 //-----------------------------------------------------------------------------

 class Bug730TestCase : public TestCase

 {

 public:

   Bug730TestCase ();

   virtual ~Bug730TestCase ();


   virtual void DoRun (void);


 private:

   uint32_t m_received;


   void Receive (std::string context, Ptr<const Packet> p, const Address &adr);


 };


 Bug730TestCase::Bug730TestCase ()

   : TestCase ("Test case for Bug 730"),

     m_received (0)

 {

 }


 Bug730TestCase::~Bug730TestCase ()

 {

 }


 void

 Bug730TestCase::Receive (std::string context, Ptr<const Packet> p, const Address &adr)

 {

   if ((p->GetSize () == 1460) && (Simulator::Now () > Seconds (20)))

     {

       m_received++;

     }

 }


 void

 Bug730TestCase::DoRun (void)

 {

   m_received = 0;


   Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("2304"));


   NodeContainer wifiStaNode;

   wifiStaNode.Create (1);


   NodeContainer wifiApNode;

   wifiApNode.Create (1);


   YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();

   YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

   phy.SetChannel (channel.Create ());


   WifiHelper wifi;

   wifi.SetStandard (WIFI_PHY_STANDARD_80211b);

   wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",

                                 "DataMode", StringValue ("DsssRate1Mbps"),

                                 "ControlMode", StringValue ("DsssRate1Mbps"));


   WifiMacHelper mac;

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

   mac.SetType ("ns3::StaWifiMac",

                "Ssid", SsidValue (ssid),

                "ActiveProbing", BooleanValue (false));


   NetDeviceContainer staDevices;

   staDevices = wifi.Install (phy, mac, wifiStaNode);


   mac.SetType ("ns3::ApWifiMac",

                "Ssid", SsidValue (ssid),

                "BeaconGeneration", BooleanValue (true));


   NetDeviceContainer apDevices;

   apDevices = wifi.Install (phy, mac, wifiApNode);


   MobilityHelper mobility;

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


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

   positionAlloc->Add (Vector (1.0, 0.0, 0.0));

   mobility.SetPositionAllocator (positionAlloc);


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

   mobility.Install (wifiApNode);

   mobility.Install (wifiStaNode);


   Ptr<WifiNetDevice> ap_device = DynamicCast<WifiNetDevice> (apDevices.Get (0));

   Ptr<WifiNetDevice> sta_device = DynamicCast<WifiNetDevice> (staDevices.Get (0));


   PacketSocketAddress socket;

   socket.SetSingleDevice (sta_device->GetIfIndex ());

   socket.SetPhysicalAddress (ap_device->GetAddress ());

   socket.SetProtocol (1);


   // give packet socket powers to nodes.

   PacketSocketHelper packetSocket;

   packetSocket.Install (wifiStaNode);

   packetSocket.Install (wifiApNode);


   Ptr<PacketSocketClient> client = CreateObject<PacketSocketClient> ();

   client->SetAttribute ("PacketSize", UintegerValue (1460));

   client->SetRemote (socket);

   wifiStaNode.Get (0)->AddApplication (client);

   client->SetStartTime (Seconds (1));

   client->SetStopTime (Seconds (51.0));


   Ptr<PacketSocketServer> server = CreateObject<PacketSocketServer> ();

   server->SetLocal (socket);

   wifiApNode.Get (0)->AddApplication (server);

   server->SetStartTime (Seconds (0.0));

   server->SetStopTime (Seconds (52.0));


   Config::Connect ("/NodeList/*/ApplicationList/0/$ns3::PacketSocketServer/Rx", MakeCallback (&Bug730TestCase::Receive, this));


   Simulator::Schedule (Seconds (10.0), Config::Set, "/NodeList/0/DeviceList/0/RemoteStationManager/FragmentationThreshold", StringValue ("800"));


   Simulator::Stop (Seconds (55));

   Simulator::Run ();


   Simulator::Destroy ();


   bool result = (m_received > 0);

   NS_TEST_ASSERT_MSG_EQ (result, true, "packet reception unexpectedly stopped after adapting fragmentation threshold!");

 }


 class SetChannelFrequencyTest : public TestCase

 {

 public:

   SetChannelFrequencyTest ();


   virtual void DoRun (void);


 private:

   Ptr<YansWifiPhy> GetYansWifiPhyPtr (const NetDeviceContainer &nc) const;


 };


 SetChannelFrequencyTest::SetChannelFrequencyTest ()

   : TestCase ("Test case for setting WifiPhy channel and frequency")

 {

 }


 Ptr<YansWifiPhy>

 SetChannelFrequencyTest::GetYansWifiPhyPtr (const NetDeviceContainer &nc) const

 {

   Ptr<WifiNetDevice> wnd = nc.Get (0)->GetObject<WifiNetDevice> ();

   Ptr<WifiPhy> wp = wnd->GetPhy ();

   return wp->GetObject<YansWifiPhy> ();

 }


 void

 SetChannelFrequencyTest::DoRun ()

 {

   NodeContainer wifiStaNode;

   wifiStaNode.Create (1);

   NodeContainer wifiApNode;

   wifiApNode.Create (1);


   YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();

   YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

   phy.SetChannel (channel.Create ());


   // Configure and declare other generic components of this example

   Ssid ssid;

   ssid = Ssid ("wifi-phy-configuration");

   WifiMacHelper macSta;

   macSta.SetType ("ns3::StaWifiMac",

                   "Ssid", SsidValue (ssid),

                   "ActiveProbing", BooleanValue (false));

   NetDeviceContainer staDevice;

   Ptr<YansWifiPhy> phySta;


   // Cases taken from src/wifi/examples/wifi-phy-configuration.cc example

   {

     // case 0

     // Default configuration, without WifiHelper::SetStandard or WifiHelper

     phySta = CreateObject<YansWifiPhy> ();

     // The default results in an invalid configuration of channel 0,

     // width 20, and frequency 0 MHz

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 0, "default configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "default configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 0, "default configuration");

   }

   {

     // case 1

     WifiHelper wifi;

     // By default, WifiHelper will use WIFI_PHY_STANDARD_80211a

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     // We expect channel 36, width 20, frequency 5180

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 36, "default configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "default configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5180, "default configuration");

   }

   {

     // case 2

     WifiHelper wifi;

     wifi.SetStandard (WIFI_PHY_STANDARD_80211b);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     // We expect channel 1, width 22, frequency 2412

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 1, "802.11b configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 22, "802.11b configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 2412, "802.11b configuration");

   }

   {

     // case 3

     WifiHelper wifi;

     wifi.SetStandard (WIFI_PHY_STANDARD_80211g);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     // We expect channel 1, width 20, frequency 2412

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 1, "802.11g configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11g configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 2412, "802.11g configuration");

   }

   {

     // case 4

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 36, "802.11n-5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11n-5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5180, "802.11n-5GHz configuration");

   }

   {

     // case 5

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_80211n_2_4GHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 1, "802.11n-2.4GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11n-2.4GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 2412, "802.11n-2.4GHz configuration");

   }

   {

     // case 6

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_80211ac);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 42, "802.11ac configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 80, "802.11ac configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5210, "802.11ac configuration");

   }

   {

     // case 7

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_80211_10MHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 172, "802.11 10Mhz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 10, "802.11 10Mhz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5860, "802.11 10Mhz configuration");

   }

   {

     // case 8

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_80211_5MHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 0, "802.11 5Mhz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 5, "802.11 5Mhz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5860, "802.11 5Mhz configuration");

   }

   {

     // case 9

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_holland);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     // We expect channel 36, width 20, frequency 5180

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 36, "802.11 5Mhz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5Mhz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5180, "802.11 5Mhz configuration");

   }

   {

     // case 10

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

     phy.Set ("ChannelNumber", UintegerValue (44));

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 44, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5220, "802.11 5GHz configuration");

   }

   {

     // case 11

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     phy.Set ("ChannelNumber", UintegerValue (44));

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     // Post-install reconfiguration to channel number 40

     Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::YansWifiPhy/ChannelNumber", UintegerValue (40));

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 40, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5200, "802.11 5GHz configuration");

   }

   {

     // case 12

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     phy.Set ("ChannelNumber", UintegerValue (44));

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     // Post-install reconfiguration to channel width 40 MHz

     Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::YansWifiPhy/ChannelWidth", UintegerValue (40));

     // Although channel 44 is configured originally for 20 MHz, we

     // allow it to be used for 40 MHz here

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 44, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 40, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5220, "802.11 5GHz configuration");

   }

   // modify cases 13 and 14 to avoid Config::SetDefault ()

   {

     // case 13

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     phySta->SetAttribute ("ChannelNumber", UintegerValue (44));

     // Post-install reconfiguration to channel width 40 MHz

     Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::YansWifiPhy/ChannelWidth", UintegerValue (40));

     // Although channel 44 is configured originally for 20 MHz, we

     // allow it to be used for 40 MHz here

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 44, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 40, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5220, "802.11 5GHz configuration");

   }

   {

     // case 14

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     // Test that setting Frequency to a non-standard value will zero the

     // channel number

     wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     phySta->SetAttribute ("Frequency", UintegerValue (5281));

     // We expect channel number to be zero since frequency doesn't match

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 0, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5281, "802.11 5GHz configuration");

   }

   {

     // case 15:

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     // Test that setting Frequency to a standard value will set the

     // channel number correctly

     phySta->SetAttribute ("Frequency", UintegerValue (5500));

     // We expect channel number to be 100 due to frequency 5500

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 100, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5500, "802.11 5GHz configuration");

   }

   {

     // case 16:

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     // This case will error exit due to invalid channel number unless

     // we provide the DefineChannelNumber() below

     phySta->DefineChannelNumber (99, WIFI_PHY_STANDARD_80211n_5GHZ, 5185, 40);

     phySta->SetAttribute ("ChannelNumber", UintegerValue (99));

   }

   {

     // case 17:

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     // Test how channel number behaves when frequency is non-standard

     wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     phySta->SetAttribute ("Frequency", UintegerValue (5181));

     // We expect channel number to be 0 due to unknown center frequency 5181

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 0, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5181, "802.11 5GHz configuration");

     phySta->SetAttribute ("Frequency", UintegerValue (5180));

     // We expect channel number to be 36 due to known center frequency 5180

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 36, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5180, "802.11 5GHz configuration");

     phySta->SetAttribute ("Frequency", UintegerValue (5179));

     // We expect channel number to be 0 due to unknown center frequency 5179

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 0, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5179, "802.11 5GHz configuration");

     phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 36, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5180, "802.11 5GHz configuration");

   }

   {

     // case 18:

     WifiHelper wifi;

     wifi.SetRemoteStationManager ("ns3::IdealWifiManager");

     // Set both channel and frequency to consistent values

     wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

     staDevice = wifi.Install (phy, macSta, wifiStaNode.Get (0));

     phySta = GetYansWifiPhyPtr (staDevice);

     phySta->SetAttribute ("Frequency", UintegerValue (5200));

     phySta->SetAttribute ("ChannelNumber", UintegerValue (40));

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 40, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5200, "802.11 5GHz configuration");

     // Set both channel and frequency to inconsistent values

     phySta->SetAttribute ("Frequency", UintegerValue (5200));

     phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

     // We expect channel number to be 36

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 36, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5180, "802.11 5GHz configuration");

     phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

     phySta->SetAttribute ("Frequency", UintegerValue (5200));

     // We expect channel number to be 40

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 40, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5200, "802.11 5GHz configuration");

     phySta->SetAttribute ("Frequency", UintegerValue (5179));

     phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

     // We expect channel number to be 36

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 36, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5180, "802.11 5GHz configuration");

     phySta->SetAttribute ("ChannelNumber", UintegerValue (36));

     phySta->SetAttribute ("Frequency", UintegerValue (5179));

     // We expect channel number to be 0

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelNumber (), 0, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 20, "802.11 5GHz configuration");

     NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5179, "802.11 5GHz configuration");

   }


   Simulator::Destroy ();


 }


 //-----------------------------------------------------------------------------

 class Bug2222TestCase : public TestCase

 {

 public:

   Bug2222TestCase ();

   virtual ~Bug2222TestCase ();


   virtual void DoRun (void);


 private:

   uint32_t m_countInternalCollisions;


   void PopulateArpCache ();

   void TxDataFailedTrace (std::string context, Mac48Address adr);

 };


 Bug2222TestCase::Bug2222TestCase ()

   : TestCase ("Test case for Bug 2222"),

     m_countInternalCollisions (0)

 {

 }


 Bug2222TestCase::~Bug2222TestCase ()

 {

 }


 void

 Bug2222TestCase::TxDataFailedTrace (std::string context, Mac48Address adr)

 {

   //Indicate the long retry counter has been increased in the wifi remote station manager

   m_countInternalCollisions++;

 }


 void

 Bug2222TestCase::DoRun (void)

 {

   m_countInternalCollisions = 0;


   //Generate same backoff for AC_VI and AC_VO

   //The below combination will work

   RngSeedManager::SetSeed (1);

   RngSeedManager::SetRun (2);

   int64_t streamNumber = 100;


   NodeContainer wifiNodes;

   wifiNodes.Create (2);


   YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();

   YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

   phy.SetChannel (channel.Create ());


   WifiHelper wifi;

   wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",

                                 "DataMode", StringValue ("OfdmRate54Mbps"),

                                 "ControlMode", StringValue ("OfdmRate24Mbps"));

   WifiMacHelper mac;

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

   mac.SetType ("ns3::AdhocWifiMac",

                "QosSupported", BooleanValue (true));


   NetDeviceContainer wifiDevices;

   wifiDevices = wifi.Install (phy, mac, wifiNodes);


   // Assign fixed streams to random variables in use

   wifi.AssignStreams (wifiDevices, streamNumber);


   MobilityHelper mobility;

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


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

   positionAlloc->Add (Vector (10.0, 0.0, 0.0));

   mobility.SetPositionAllocator (positionAlloc);


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

   mobility.Install (wifiNodes);


   Ptr<WifiNetDevice> device1 = DynamicCast<WifiNetDevice> (wifiDevices.Get (0));

   Ptr<WifiNetDevice> device2 = DynamicCast<WifiNetDevice> (wifiDevices.Get (1));


   PacketSocketAddress socket;

   socket.SetSingleDevice (device1->GetIfIndex ());

   socket.SetPhysicalAddress (device2->GetAddress ());

   socket.SetProtocol (1);


   PacketSocketHelper packetSocket;

   packetSocket.Install (wifiNodes);


   Ptr<PacketSocketClient> clientLowPriority = CreateObject<PacketSocketClient> ();

   clientLowPriority->SetAttribute ("PacketSize", UintegerValue (1460));

   clientLowPriority->SetAttribute ("MaxPackets", UintegerValue (1));

   clientLowPriority->SetAttribute ("Priority", UintegerValue (4)); //AC_VI

   clientLowPriority->SetRemote (socket);

   wifiNodes.Get (0)->AddApplication (clientLowPriority);

   clientLowPriority->SetStartTime (Seconds (1.0));

   clientLowPriority->SetStopTime (Seconds (2.0));


   Ptr<PacketSocketClient> clientHighPriority = CreateObject<PacketSocketClient> ();

   clientHighPriority->SetAttribute ("PacketSize", UintegerValue (1460));

   clientHighPriority->SetAttribute ("MaxPackets", UintegerValue (1));

   clientHighPriority->SetAttribute ("Priority", UintegerValue (6)); //AC_VO

   clientHighPriority->SetRemote (socket);

   wifiNodes.Get (0)->AddApplication (clientHighPriority);

   clientHighPriority->SetStartTime (Seconds (1.0));

   clientHighPriority->SetStopTime (Seconds (2.0));


   Ptr<PacketSocketServer> server = CreateObject<PacketSocketServer> ();

   server->SetLocal (socket);

   wifiNodes.Get (1)->AddApplication (server);

   server->SetStartTime (Seconds (1.0));

   server->SetStopTime (Seconds (2.0));


   Config::Connect ("/NodeList/*/DeviceList/*/RemoteStationManager/MacTxDataFailed", MakeCallback (&Bug2222TestCase::TxDataFailedTrace, this));


   Simulator::Stop (Seconds (2.0));

   Simulator::Run ();

   Simulator::Destroy ();


   NS_TEST_ASSERT_MSG_EQ (m_countInternalCollisions, 1, "unexpected number of internal collisions!");

 }


 //-----------------------------------------------------------------------------

 class Bug2483TestCase : public TestCase

 {

 public:

   Bug2483TestCase ();

   virtual ~Bug2483TestCase ();

   virtual void DoRun (void);


 private:

   typedef std::tuple<double, uint8_t, uint32_t, WifiModulationClass> FreqWidthSubbandModulationTuple;

   std::vector<FreqWidthSubbandModulationTuple> m_distinctTuples;


   void StoreDistinctTuple (std::string context, Ptr<SpectrumSignalParameters> txParams);

   void SendPacketBurst (uint8_t numPackets, Ptr<NetDevice> sourceDevice, Address& destination) const;

 };


 Bug2483TestCase::Bug2483TestCase ()

   : TestCase ("Test case for Bug 2483")

 {

 }


 Bug2483TestCase::~Bug2483TestCase ()

 {

 }


 void

 Bug2483TestCase::StoreDistinctTuple (std::string context,  Ptr<SpectrumSignalParameters> txParams)

 {

   // Extract starting frequency and number of subbands

   Ptr<const SpectrumModel> c = txParams->psd->GetSpectrumModel ();

   uint32_t numBands = c->GetNumBands ();

   double startingFreq = c->Begin ()->fl;


   // Get channel bandwidth and modulation class

   Ptr<const WifiSpectrumSignalParameters> wifiTxParams = DynamicCast<WifiSpectrumSignalParameters> (txParams);

   Ptr<Packet> packet = wifiTxParams->packet->Copy ();

   WifiPhyTag tag;

   if (!packet->RemovePacketTag (tag))

     {

       NS_FATAL_ERROR ("Received Wi-Fi Signal with no WifiPhyTag");

       return;

     }

   WifiTxVector txVector = tag.GetWifiTxVector ();

   uint8_t channelWidth = txVector.GetChannelWidth ();

   WifiModulationClass modulationClass = txVector.GetMode ().GetModulationClass ();


   // Build a tuple and check if seen before (if so store it)

   FreqWidthSubbandModulationTuple tupleForCurrentTx = std::make_tuple (startingFreq, channelWidth,

                                                                        numBands, modulationClass);

   bool found = false;

   for (std::vector<FreqWidthSubbandModulationTuple>::const_iterator it = m_distinctTuples.begin (); it != m_distinctTuples.end (); it++)

     {

       if (*it == tupleForCurrentTx)

         {

           found = true;

         }

     }

   if (!found)

     {

       m_distinctTuples.push_back (tupleForCurrentTx);

     }

 }


 void

 Bug2483TestCase::SendPacketBurst (uint8_t numPackets, Ptr<NetDevice> sourceDevice,

                                   Address& destination) const

 {

   for (uint8_t i = 0; i < numPackets; i++)

     {

       Ptr<Packet> pkt = Create<Packet> (1000);  // 1000 dummy bytes of data

       sourceDevice->Send (pkt, destination, 0);

     }

 }


 void

 Bug2483TestCase::DoRun (void)

 {

   Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("500")); // so as to force RTS/CTS for data frames

   Config::SetDefault ("ns3::WifiPhy::CcaMode1Threshold", DoubleValue (-62.0));


   uint8_t channelWidth = 40; // at least 40 MHz expected here


   NodeContainer wifiStaNode;

   wifiStaNode.Create (1);


   NodeContainer wifiApNode;

   wifiApNode.Create (1);


   SpectrumWifiPhyHelper spectrumPhy = SpectrumWifiPhyHelper::Default ();

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

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

   lossModel->SetFrequency (5.180e9);

   spectrumChannel->AddPropagationLossModel (lossModel);


   Ptr<ConstantSpeedPropagationDelayModel> delayModel

     = CreateObject<ConstantSpeedPropagationDelayModel> ();

   spectrumChannel->SetPropagationDelayModel (delayModel);


   spectrumPhy.SetChannel (spectrumChannel);

   spectrumPhy.SetErrorRateModel ("ns3::NistErrorRateModel");

   spectrumPhy.Set ("Frequency", UintegerValue (5180));

   spectrumPhy.Set ("ChannelWidth", UintegerValue (channelWidth));

   spectrumPhy.Set ("TxPowerStart", DoubleValue (10));

   spectrumPhy.Set ("TxPowerEnd", DoubleValue (10));


   WifiHelper wifi;

   wifi.SetStandard (WIFI_PHY_STANDARD_80211ac);

   wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",

                                 "DataMode", StringValue ("VhtMcs8"),

                                 "ControlMode", StringValue ("VhtMcs8"));


   WifiMacHelper mac;

   mac.SetType ("ns3::StaWifiMac");

   NetDeviceContainer staDevice;

   staDevice = wifi.Install (spectrumPhy, mac, wifiStaNode);


   mac.SetType ("ns3::ApWifiMac");

   NetDeviceContainer apDevice;

   apDevice = wifi.Install (spectrumPhy, mac, wifiApNode);


   MobilityHelper mobility;

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

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

   positionAlloc->Add (Vector (1.0, 0.0, 0.0)); // put close enough in order to use MCS

   mobility.SetPositionAllocator (positionAlloc);


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

   mobility.Install (wifiApNode);

   mobility.Install (wifiStaNode);


   // Send two 5 packet-bursts

   Simulator::Schedule (Seconds (0.5), &Bug2483TestCase::SendPacketBurst, this, 5, apDevice.Get (0), staDevice.Get (0)->GetAddress ());

   Simulator::Schedule (Seconds (0.6), &Bug2483TestCase::SendPacketBurst, this, 5, apDevice.Get (0), staDevice.Get (0)->GetAddress ());


   Config::Connect ("/ChannelList/*/$ns3::MultiModelSpectrumChannel/TxSigParams", MakeCallback (&Bug2483TestCase::StoreDistinctTuple, this));


   Simulator::Stop (Seconds (0.8));

   Simulator::Run ();


   Simulator::Destroy ();


   // {starting frequency, channelWidth, Number of subbands in SpectrumModel, modulation type} tuples

   uint8_t numberTuples = m_distinctTuples.size ();

   NS_TEST_ASSERT_MSG_EQ (numberTuples, 2, "Only two distinct tuples expected");

   NS_TEST_ASSERT_MSG_EQ (std::get<0> (m_distinctTuples[0]) - 20e6, std::get<0> (m_distinctTuples[1]), "The starting frequency of the first tuple should be shifted 20 MHz to the right wrt second tuple");

   // Note that the first tuple should the one initiated by the beacon, i.e. legacy OFDM (20 MHz)

   NS_TEST_ASSERT_MSG_EQ (std::get<1> (m_distinctTuples[0]), 20, "First tuple's channel width should be 20 MHz");

   NS_TEST_ASSERT_MSG_EQ (std::get<2> (m_distinctTuples[0]), 193, "First tuple should have 193 subbands (64+DC, 20MHz+DC, inband and 64*2 out-of-band, 20MHz on each side)");

   NS_TEST_ASSERT_MSG_EQ (std::get<3> (m_distinctTuples[0]), WifiModulationClass::WIFI_MOD_CLASS_OFDM, "First tuple should be OFDM");

   // Second tuple

   NS_TEST_ASSERT_MSG_EQ (std::get<1> (m_distinctTuples[1]), channelWidth, "Second tuple's channel width should be 40 MHz");

   NS_TEST_ASSERT_MSG_EQ (std::get<2> (m_distinctTuples[1]), 385, "Second tuple should have 385 subbands (128+DC, 40MHz+DC, inband and 128*2 out-of-band, 40MHz on each side)");

   NS_TEST_ASSERT_MSG_EQ (std::get<3> (m_distinctTuples[1]), WifiModulationClass::WIFI_MOD_CLASS_VHT, "Second tuple should be VHT_OFDM");

 }


 //-----------------------------------------------------------------------------

 class Bug2831TestCase : public TestCase

 {

 public:

   Bug2831TestCase ();

   virtual ~Bug2831TestCase ();

   virtual void DoRun (void);


 private:

   void ChangeSupportedChannelWidth (void);

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


   Ptr<YansWifiPhy> m_apPhy;

   Ptr<YansWifiPhy> m_staPhy;


   uint8_t m_reassocReqCount;

   uint8_t m_reassocRespCount;

   uint8_t m_countOperationalChannelWidth20;

   uint8_t m_countOperationalChannelWidth40;

 };


 Bug2831TestCase::Bug2831TestCase ()

   : TestCase ("Test case for Bug 2831"),

     m_reassocReqCount (0),

     m_reassocRespCount (0),

     m_countOperationalChannelWidth20 (0),

     m_countOperationalChannelWidth40 (0)

 {

 }


 Bug2831TestCase::~Bug2831TestCase ()

 {

 }


 void

 Bug2831TestCase::ChangeSupportedChannelWidth ()

 {

   m_apPhy->SetChannelNumber (38);

   m_apPhy->SetChannelWidth (40);

   m_staPhy->SetChannelNumber (38);

   m_staPhy->SetChannelWidth (40);

 }


 void

 Bug2831TestCase::RxCallback (std::string context, Ptr<const Packet> p)

 {

   Ptr<Packet> packet = p->Copy ();

   WifiMacHeader hdr;

   packet->RemoveHeader (hdr);

   if (hdr.IsReassocReq ())

     {

       m_reassocReqCount++;

     }

   else if (hdr.IsReassocResp ())

     {

       m_reassocRespCount++;

     }

   else if (hdr.IsBeacon ())

     {

       MgtBeaconHeader beacon;

       packet->RemoveHeader (beacon);

       HtOperation htOperation = beacon.GetHtOperation ();

       if (htOperation.GetStaChannelWidth () > 0)

         {

           m_countOperationalChannelWidth40++;

         }

       else

         {

           m_countOperationalChannelWidth20++;

         }

     }

 }


 void

 Bug2831TestCase::DoRun (void)

 {

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

   ObjectFactory propDelay;

   propDelay.SetTypeId ("ns3::ConstantSpeedPropagationDelayModel");

   Ptr<PropagationDelayModel> propagationDelay = propDelay.Create<PropagationDelayModel> ();

   Ptr<PropagationLossModel> propagationLoss = CreateObject<RandomPropagationLossModel> ();

   channel->SetPropagationDelayModel (propagationDelay);

   channel->SetPropagationLossModel (propagationLoss);


   Ptr<Node> apNode = CreateObject<Node> ();

   Ptr<WifiNetDevice> apDev = CreateObject<WifiNetDevice> ();

   ObjectFactory mac;

   mac.SetTypeId ("ns3::ApWifiMac");

   Ptr<WifiMac> apMac = mac.Create<WifiMac> ();

   apMac->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);


   Ptr<Node> staNode = CreateObject<Node> ();

   Ptr<WifiNetDevice> staDev = CreateObject<WifiNetDevice> ();

   mac.SetTypeId ("ns3::StaWifiMac");

   Ptr<WifiMac> staMac = mac.Create<WifiMac> ();

   staMac->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);


   Ptr<ConstantPositionMobilityModel> apMobility = CreateObject<ConstantPositionMobilityModel> ();

   apMobility->SetPosition (Vector (0.0, 0.0, 0.0));

   apNode->AggregateObject (apMobility);


   Ptr<ErrorRateModel> error = CreateObject<YansErrorRateModel> ();

   m_apPhy = CreateObject<YansWifiPhy> ();

   m_apPhy->SetErrorRateModel (error);

   m_apPhy->SetChannel (channel);

   m_apPhy->SetMobility (apMobility);

   m_apPhy->SetDevice (apDev);

   m_apPhy->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

   m_apPhy->SetChannelNumber (36);

   m_apPhy->SetChannelWidth (20);


   Ptr<ConstantPositionMobilityModel> staMobility = CreateObject<ConstantPositionMobilityModel> ();

   staMobility->SetPosition (Vector (1.0, 0.0, 0.0));

   staNode->AggregateObject (staMobility);


   m_staPhy = CreateObject<YansWifiPhy> ();

   m_staPhy->SetErrorRateModel (error);

   m_staPhy->SetChannel (channel);

   m_staPhy->SetMobility (staMobility);

   m_staPhy->SetDevice (apDev);

   m_staPhy->ConfigureStandard (WIFI_PHY_STANDARD_80211ac);

   m_staPhy->SetChannelNumber (36);

   m_staPhy->SetChannelWidth (20);


   apMac->SetAddress (Mac48Address::Allocate ());

   apDev->SetMac (apMac);

   apDev->SetPhy (m_apPhy);

   ObjectFactory manager;

   manager.SetTypeId ("ns3::ConstantRateWifiManager");

   apDev->SetRemoteStationManager (manager.Create<WifiRemoteStationManager> ());

   apNode->AddDevice (apDev);


   staMac->SetAddress (Mac48Address::Allocate ());

   staDev->SetMac (staMac);

   staDev->SetPhy (m_staPhy);

   staDev->SetRemoteStationManager (manager.Create<WifiRemoteStationManager> ());

   staNode->AddDevice (staDev);


   Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxBegin", MakeCallback (&Bug2831TestCase::RxCallback, this));


   Simulator::Schedule (Seconds (1.0), &Bug2831TestCase::ChangeSupportedChannelWidth, this);


   Simulator::Stop (Seconds (3.0));

   Simulator::Run ();

   Simulator::Destroy ();


   NS_TEST_ASSERT_MSG_EQ (m_reassocReqCount, 1, "Reassociation request not received");

   NS_TEST_ASSERT_MSG_EQ (m_reassocRespCount, 1, "Reassociation response not received");

   NS_TEST_ASSERT_MSG_EQ (m_countOperationalChannelWidth20, 10, "Incorrect operational channel width before channel change");

   NS_TEST_ASSERT_MSG_EQ (m_countOperationalChannelWidth40, 20, "Incorrect operational channel width after channel change");

 }


 class WifiTestSuite : public TestSuite

 {

 public:

   WifiTestSuite ();

 };


 WifiTestSuite::WifiTestSuite ()

   : TestSuite ("devices-wifi", UNIT)

 {

   AddTestCase (new WifiTest, TestCase::QUICK);

   AddTestCase (new QosUtilsIsOldPacketTest, TestCase::QUICK);

   AddTestCase (new InterferenceHelperSequenceTest, TestCase::QUICK); //Bug 991

   AddTestCase (new DcfImmediateAccessBroadcastTestCase, TestCase::QUICK);

   AddTestCase (new Bug730TestCase, TestCase::QUICK); //Bug 730

   AddTestCase (new SetChannelFrequencyTest, TestCase::QUICK);

   AddTestCase (new Bug2222TestCase, TestCase::QUICK); //Bug 2222

   AddTestCase (new Bug2483TestCase, TestCase::QUICK); //Bug 2483

   AddTestCase (new Bug2831TestCase, TestCase::QUICK); //Bug 2831

 }


 static WifiTestSuite g_wifiTestSuite;

ns3::WIFI_PHY_STANDARD_80211g
ERP-OFDM PHY (Clause 19, Section 19.5)
Definition: wifi-phy-standard.h:37

ns3::WifiMacHeader::IsBeacon
bool IsBeacon(void) const
Return true if the header is a Beacon header.
Definition: wifi-mac-header.cc:600

ns3::Packet::RemoveHeader
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280

WifiTest::RunOne
void RunOne(void)
Run one function.
Definition: wifi-test.cc:157

third.channel
tuple channel
Definition: third.py:85

ns3::WifiPhyHelper::Set
void Set(std::string name, const AttributeValue &v)
Definition: wifi-helper.cc:133

ns3::Node::AddApplication
uint32_t AddApplication(Ptr< Application > application)
Associate an Application to this Node.
Definition: node.cc:157

Bug730TestCase::Bug730TestCase
Bug730TestCase()
Definition: wifi-test.cc:580

Bug2831TestCase::m_countOperationalChannelWidth20
uint8_t m_countOperationalChannelWidth20
count number of beacon frames announcing a 20 MHz operating channel width
Definition: wifi-test.cc:1382

ns3::WifiPhy::GetChannelNumber
uint8_t GetChannelNumber(void) const
Return current channel number.
Definition: wifi-phy.cc:1482

ns3::Application::SetStopTime
void SetStopTime(Time stop)
Specify application stop time.
Definition: application.cc:75

ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102

Bug2483TestCase::m_distinctTuples
std::vector< FreqWidthSubbandModulationTuple > m_distinctTuples
vector of distinct {starting frequency, channelWidth, Number of subbands in SpectrumModel, modulation type} tuples
Definition: wifi-test.cc:1189

Bug730TestCase::~Bug730TestCase
virtual ~Bug730TestCase()
Definition: wifi-test.cc:586

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

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

ns3::WIFI_PHY_STANDARD_80211_5MHZ
OFDM PHY for the 5 GHz band (Clause 17 with 5 MHz channel bandwidth)
Definition: wifi-phy-standard.h:41

Bug2222TestCase::PopulateArpCache
void PopulateArpCache()
Populate ARP cache function.

ns3::SpectrumModel::GetNumBands
size_t GetNumBands() const
Definition: spectrum-model.cc:93

ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:36

ns3::PacketSocketServer::SetLocal
void SetLocal(PacketSocketAddress addr)
set the local address and protocol to be used
Definition: packet-socket-server.cc:102

ns3::YansWifiChannel::SetPropagationLossModel
void SetPropagationLossModel(const Ptr< PropagationLossModel > loss)
Definition: yans-wifi-channel.cc:66

ns3::WIFI_PHY_STANDARD_80211n_5GHZ
HT PHY for the 5 GHz band (clause 20)
Definition: wifi-phy-standard.h:51

ns3::WifiTxVector
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
Definition: wifi-tx-vector.h:61

Bug730TestCase::Receive
void Receive(std::string context, Ptr< const Packet > p, const Address &adr)
Receive function.
Definition: wifi-test.cc:591

ns3::WifiMacHeader::IsReassocResp
bool IsReassocResp(void) const
Return true if the header is a Reassociation Response header.
Definition: wifi-mac-header.cc:582

ns3::YansWifiChannelHelper::Create
Ptr< YansWifiChannel > Create(void) const
Definition: yans-wifi-helper.cc:95

ns3::WifiHelper::SetRemoteStationManager
void SetRemoteStationManager(std::string type, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue())
Definition: wifi-helper.cc:700

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

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

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

Bug2831TestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: wifi-test.cc:1439

ns3::YansWifiPhyHelper
Make it easy to create and manage PHY objects for the yans model.
Definition: yans-wifi-helper.h:160

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

ns3::YansWifiPhy::SetChannel
void SetChannel(const Ptr< YansWifiChannel > channel)
Set the YansWifiChannel this YansWifiPhy is to be connected to.
Definition: yans-wifi-phy.cc:70

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

ns3::Object::AggregateObject
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:252

ns3::WifiNetDevice::GetAddress
Address GetAddress(void) const
Definition: wifi-net-device.cc:265

ns3::PacketSocketAddress
an address for a packet socket
Definition: packet-socket-address.h:38

Bug2831TestCase::RxCallback
void RxCallback(std::string context, Ptr< const Packet > p)
Callback triggered when a packet is received by the PHYs.
Definition: wifi-test.cc:1409

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

ns3::MultiModelSpectrumChannel::AddPropagationLossModel
virtual void AddPropagationLossModel(Ptr< PropagationLossModel > loss)
Add the single-frequency propagation loss model to be used.
Definition: multi-model-spectrum-channel.cc:445

ns3::ObjectFactory::SetTypeId
void SetTypeId(TypeId tid)
Set the TypeId of the Objects to be created by this factory.
Definition: object-factory.cc:46

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:285

ns3::Packet::GetSize
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:821

ns3::WIFI_PHY_STANDARD_80211_10MHZ
OFDM PHY for the 5 GHz band (Clause 17 with 10 MHz channel bandwidth)
Definition: wifi-phy-standard.h:39

ns3::WifiMac::ConfigureStandard
void ConfigureStandard(WifiPhyStandard standard)
Definition: wifi-mac.cc:289

ns3::WifiPhy::SetMobility
void SetMobility(const Ptr< MobilityModel > mobility)
assign a mobility model to this device
Definition: wifi-phy.cc:666

ns3::HtOperation
The HT Operation Information ElementThis class knows how to serialise and deserialise the HT Operatio...
Definition: ht-operation.h:52

NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:162

ns3::QosUtilsIsOldPacket
bool QosUtilsIsOldPacket(uint16_t startingSeq, uint16_t seqNumber)
This function checks if packet with sequence number seqNumber is an "old" packet. ...
Definition: qos-utils.cc:80

Bug2483TestCase::StoreDistinctTuple
void StoreDistinctTuple(std::string context, Ptr< SpectrumSignalParameters > txParams)
Stores the distinct {starting frequency, channelWidth, Number of subbands in SpectrumModel, modulation type} tuples that have been used during the testcase run.
Definition: wifi-test.cc:1217

ns3::WIFI_PHY_STANDARD_80211n_2_4GHZ
HT PHY for the 2.4 GHz band (clause 20)
Definition: wifi-phy-standard.h:49

ns3::WIFI_MOD_CLASS_VHT
VHT PHY (Clause 22)
Definition: wifi-mode.h:60

QosUtilsIsOldPacketTest
Qos Utils Is Old Packet Test.
Definition: wifi-test.cc:213

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

ns3::DcaTxop::AssignStreams
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model...
Definition: dca-txop.cc:228

Bug2831TestCase::m_reassocReqCount
uint8_t m_reassocReqCount
count number of reassociation requests
Definition: wifi-test.cc:1380

Bug730TestCase
Make sure that when changing the fragmentation threshold during the simulation, the TCP transmission ...
Definition: wifi-test.cc:558

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

InterferenceHelperSequenceTest::InterferenceHelperSequenceTest
InterferenceHelperSequenceTest()
Definition: wifi-test.cc:276

ns3::WifiPhy::GetFrequency
uint16_t GetFrequency(void) const
Definition: wifi-phy.cc:1260

ns3::PacketSocketHelper
Give ns3::PacketSocket powers to ns3::Node.
Definition: packet-socket-helper.h:31

ns3::PacketSocketAddress::SetSingleDevice
void SetSingleDevice(uint32_t device)
Set the address to match only a specified NetDevice.
Definition: packet-socket-address.cc:46

ns3::Address
a polymophic address class
Definition: address.h:90

DcfImmediateAccessBroadcastTestCase::m_numSentPackets
unsigned int m_numSentPackets
number of sent packets
Definition: wifi-test.cc:439

ns3::WifiTxVector::GetChannelWidth
uint8_t GetChannelWidth(void) const
Definition: wifi-tx-vector.cc:92

DcfImmediateAccessBroadcastTestCase::m_propDelay
ObjectFactory m_propDelay
propagation delay
Definition: wifi-test.cc:435

ns3::WifiPhy::SetDevice
void SetDevice(const Ptr< NetDevice > device)
Sets the device this PHY is associated with.
Definition: wifi-phy.cc:654

Bug2483TestCase::Bug2483TestCase
Bug2483TestCase()
Definition: wifi-test.cc:1207

ns3::WifiHelper::SetStandard
virtual void SetStandard(WifiPhyStandard standard)
Definition: wifi-helper.cc:723

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

ns3::YansWifiPhyHelper::SetChannel
void SetChannel(Ptr< YansWifiChannel > channel)
Definition: yans-wifi-helper.cc:138

Bug2483TestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: wifi-test.cc:1266

ns3::WifiNetDevice::GetPhy
Ptr< WifiPhy > GetPhy(void) const
Definition: wifi-net-device.cc:229

InterferenceHelperSequenceTest::CreateOne
Ptr< Node > CreateOne(Vector pos, Ptr< YansWifiChannel > channel)
Create one function.
Definition: wifi-test.cc:296

ns3::EdcaTxopN
This queue contains packets for a particular access class.
Definition: edca-txop-n.h:68

Bug2831TestCase::~Bug2831TestCase
virtual ~Bug2831TestCase()
Definition: wifi-test.cc:1395

ns3::WifiMacHeader::IsReassocReq
bool IsReassocReq(void) const
Return true if the header is a Reassociation Request header.
Definition: wifi-mac-header.cc:576

ns3::YansWifiChannel::SetPropagationDelayModel
void SetPropagationDelayModel(const Ptr< PropagationDelayModel > delay)
Definition: yans-wifi-channel.cc:73

NS_ASSERT_MSG
NS_ASSERT_MSG(false,"Ipv4AddressGenerator::MaskToIndex(): Impossible")

ns3::MobilityHelper::Install
void Install(Ptr< Node > node) const
"Layout" a single node according to the current position allocator type.
Definition: mobility-helper.cc:130

third.mobility
tuple mobility
Definition: third.py:101

third.phy
tuple phy
Definition: third.py:86

DcfImmediateAccessBroadcastTestCase::m_firstTransmissionTime
Time m_firstTransmissionTime
first transmission time
Definition: wifi-test.cc:437

Bug2483TestCase::FreqWidthSubbandModulationTuple
std::tuple< double, uint8_t, uint32_t, WifiModulationClass > FreqWidthSubbandModulationTuple
A tuple of {starting frequency, channelWidth, Number of subbands in SpectrumModel, modulation type}.
Definition: wifi-test.cc:1188

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

ns3::ObjectFactory::Create
Ptr< Object > Create(void) const
Create an Object instance of the configured TypeId.
Definition: object-factory.cc:95

ns3::WifiMac
base class for all MAC-level wifi objects.
Definition: wifi-mac.h:41

Bug2222TestCase::m_countInternalCollisions
uint32_t m_countInternalCollisions
count internal collisions
Definition: wifi-test.cc:1048

ns3::SpectrumWifiPhyHelper::SetChannel
void SetChannel(Ptr< SpectrumChannel > channel)
Definition: spectrum-wifi-helper.cc:46

ns3::SpectrumValue::GetSpectrumModel
Ptr< const SpectrumModel > GetSpectrumModel() const
Definition: spectrum-value.cc:62

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

ns3::Vector3D::Vector
Vector3D Vector
Definition: vector.h:217

DcfImmediateAccessBroadcastTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: wifi-test.cc:476

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:168

QosUtilsIsOldPacketTest::QosUtilsIsOldPacketTest
QosUtilsIsOldPacketTest()
Definition: wifi-test.cc:216

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

SetChannelFrequencyTest::GetYansWifiPhyPtr
Ptr< YansWifiPhy > GetYansWifiPhyPtr(const NetDeviceContainer &nc) const
Get yans wifi phy function.
Definition: wifi-test.cc:719

ns3::WifiHelper::Install
virtual NetDeviceContainer Install(const WifiPhyHelper &phy, const WifiMacHelper &mac, NodeContainer::Iterator first, NodeContainer::Iterator last) const
Definition: wifi-helper.cc:729

ns3::PropagationDelayModel
calculate a propagation delay.
Definition: propagation-delay-model.h:37

ns3::WifiHelper::AssignStreams
int64_t AssignStreams(NetDeviceContainer c, int64_t stream)
Assign a fixed random variable stream number to the random variables used by the Phy and Mac aspects ...
Definition: wifi-helper.cc:831

ns3::Node::GetDevice
Ptr< NetDevice > GetDevice(uint32_t index) const
Retrieve the index-th NetDevice associated to this node.
Definition: node.cc:142

ns3::WifiNetDevice
Hold together all Wifi-related objects.
Definition: wifi-net-device.h:49

ns3::MakeCallback
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489

Bug2222TestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: wifi-test.cc:1078

third.staDevices
tuple staDevices
Definition: third.py:96

Bug730TestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: wifi-test.cc:601

Bug2831TestCase
Make sure that the channel width and the channel number can be changed at runtime.
Definition: wifi-test.cc:1358

ns3::WifiMac::SetAddress
virtual void SetAddress(Mac48Address address)=0

third.mac
tuple mac
Definition: third.py:92

InterferenceHelperSequenceTest::m_mac
ObjectFactory m_mac
MAC.
Definition: wifi-test.cc:272

ns3::WifiRemoteStationManager
hold a list of per-remote-station state.
Definition: wifi-remote-station-manager.h:89

DcfImmediateAccessBroadcastTestCase::m_mac
ObjectFactory m_mac
MAC.
Definition: wifi-test.cc:434

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

DcfImmediateAccessBroadcastTestCase::DcfImmediateAccessBroadcastTestCase
DcfImmediateAccessBroadcastTestCase()
Definition: wifi-test.cc:448

ns3::WIFI_PHY_STANDARD_holland
This is intended to be the configuration used in this paper: Gavin Holland, Nitin Vaidya and Paramvir...
Definition: wifi-phy-standard.h:47

ns3::WifiPhy::SetErrorRateModel
void SetErrorRateModel(const Ptr< ErrorRateModel > rate)
Sets the error rate model.
Definition: wifi-phy.cc:685

SetChannelFrequencyTest::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: wifi-test.cc:727

third.wifiApNode
tuple wifiApNode
Definition: third.py:83

InterferenceHelperSequenceTest::SwitchCh
void SwitchCh(Ptr< WifiNetDevice > dev)
Switch channel function.
Definition: wifi-test.cc:289

ns3::Packet::Copy
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121

Bug2831TestCase::m_staPhy
Ptr< YansWifiPhy > m_staPhy
STA PHY.
Definition: wifi-test.cc:1378

WifiTest::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: wifi-test.cc:176

ns3::WIFI_PHY_STANDARD_80211a
OFDM PHY for the 5 GHz band (Clause 17)
Definition: wifi-phy-standard.h:33

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

third.apDevices
tuple apDevices
Definition: third.py:99

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

ns3::WifiPhy::SetChannelWidth
virtual void SetChannelWidth(uint8_t channelwidth)
Definition: wifi-phy.cc:1266

ns3::PointerValue
Hold objects of type Ptr.
Definition: pointer.h:36

ns3::WIFI_PHY_STANDARD_80211ac
VHT PHY (clause 22)
Definition: wifi-phy-standard.h:53

g_wifiTestSuite
static WifiTestSuite g_wifiTestSuite
the test suite
Definition: wifi-test.cc:1543

ns3::YansWifiPhy
802.11 PHY layer modelThis PHY implements a model of 802.11a.
Definition: yans-wifi-phy.h:47

ns3::WifiNetDevice::Send
bool Send(Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber)
Definition: wifi-net-device.cc:341

WifiTest::m_mac
ObjectFactory m_mac
MAC.
Definition: wifi-test.cc:112

ns3::WIFI_PHY_STANDARD_80211b
DSSS PHY (Clause 15) and HR/DSSS PHY (Clause 18)
Definition: wifi-phy-standard.h:35

ns3::MobilityHelper::SetMobilityModel
void SetMobilityModel(std::string type, std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue(), std::string n8="", const AttributeValue &v8=EmptyAttributeValue(), std::string n9="", const AttributeValue &v9=EmptyAttributeValue())
Definition: mobility-helper.cc:79

QosUtilsIsOldPacketTest::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: wifi-test.cc:219

ns3::NetDevice::Send
virtual bool Send(Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber)=0

ns3::WifiNetDevice::GetIfIndex
uint32_t GetIfIndex(void) const
Definition: wifi-net-device.cc:247

ns3::Mac48Address
an EUI-48 address
Definition: mac48-address.h:43

DcfImmediateAccessBroadcastTestCase::m_manager
ObjectFactory m_manager
manager
Definition: wifi-test.cc:433

third.ssid
tuple ssid
Definition: third.py:93

Bug2222TestCase::~Bug2222TestCase
virtual ~Bug2222TestCase()
Definition: wifi-test.cc:1066

ns3::WifiPhy::SetChannelNumber
virtual void SetChannelNumber(uint8_t id)
Set channel number.
Definition: wifi-phy.cc:1428

ns3::WifiSpectrumSignalParameters::packet
Ptr< Packet > packet
The packet being transmitted with this signal.
Definition: wifi-spectrum-signal-parameters.h:57

ns3::YansWifiChannelHelper
manage and create wifi channel objects for the yans model.
Definition: yans-wifi-helper.h:36

WifiTest::m_propDelay
ObjectFactory m_propDelay
propagation delay
Definition: wifi-test.cc:113

ns3::PacketSocketHelper::Install
void Install(Ptr< Node > node) const
Aggregate an instance of a ns3::PacketSocketFactory onto the provided node.
Definition: packet-socket-helper.cc:37

DcfImmediateAccessBroadcastTestCase::SendOnePacket
void SendOnePacket(Ptr< WifiNetDevice > dev)
Send one packet function.
Definition: wifi-test.cc:469

ns3::ObjectBase::GetAttribute
void GetAttribute(std::string name, AttributeValue &value) const
Get the value of an attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:223

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

SendOnePacket
void SendOnePacket(Ptr< LrWpanPhy > sender, Ptr< LrWpanPhy > receiver)
Definition: lr-wpan-phy-test.cc:48

Bug2222TestCase::Bug2222TestCase
Bug2222TestCase()
Definition: wifi-test.cc:1060

Bug2831TestCase::m_countOperationalChannelWidth40
uint8_t m_countOperationalChannelWidth40
count number of beacon frames announcing a 40 MHz operating channel width
Definition: wifi-test.cc:1383

Bug2831TestCase::Bug2831TestCase
Bug2831TestCase()
Definition: wifi-test.cc:1386

ns3::WifiPhyHelper::SetErrorRateModel
void SetErrorRateModel(std::string name, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue())
Definition: wifi-helper.cc:139

ns3::MobilityModel::SetPosition
void SetPosition(const Vector &position)
Definition: mobility-model.cc:75

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

InterferenceHelperSequenceTest::m_propDelay
ObjectFactory m_propDelay
propagation delay
Definition: wifi-test.cc:273

WifiTestSuite
Wifi Test Suite.
Definition: wifi-test.cc:1523

Bug2222TestCase
Make sure that when virtual collision occurs the wifi remote station manager is triggered and the ret...
Definition: wifi-test.cc:1038

ns3::WifiMacHelper::SetType
virtual void SetType(std::string type, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue(), std::string n8="", const AttributeValue &v8=EmptyAttributeValue(), std::string n9="", const AttributeValue &v9=EmptyAttributeValue(), std::string n10="", const AttributeValue &v10=EmptyAttributeValue())
Definition: wifi-mac-helper.cc:39

InterferenceHelperSequenceTest
See Bug 991
Definition: wifi-test.cc:244

ns3::WifiPhy::GetChannelWidth
uint8_t GetChannelWidth(void) const
Definition: wifi-phy.cc:1280

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

ns3::WifiPhyTag::GetWifiTxVector
WifiTxVector GetWifiTxVector(void) const
Getter for WifiTxVector parameter.
Definition: wifi-phy-tag.cc:79

ns3::WifiNetDevice::GetBroadcast
Address GetBroadcast(void) const
Definition: wifi-net-device.cc:306

WifiTest::m_manager
ObjectFactory m_manager
manager
Definition: wifi-test.cc:111

ns3::ObjectFactory
Instantiate subclasses of ns3::Object.
Definition: object-factory.h:47

ns3::WifiModulationClass
WifiModulationClass
This enumeration defines the modulation classes per (Table 9-4 "Modulation classes"; IEEE 802...
Definition: wifi-mode.h:36

ns3::Node::AddDevice
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:128

Bug2483TestCase::~Bug2483TestCase
virtual ~Bug2483TestCase()
Definition: wifi-test.cc:1212

ns3::PacketSocketClient::SetRemote
void SetRemote(PacketSocketAddress addr)
set the remote address and protocol to be used
Definition: packet-socket-client.cc:91

ns3::SpectrumSignalParameters::psd
Ptr< SpectrumValue > psd
The Power Spectral Density of the waveform, in linear units.
Definition: spectrum-signal-parameters.h:94

AssignWifiRandomStreams
static void AssignWifiRandomStreams(Ptr< WifiMac > mac, int64_t stream)
Definition: wifi-test.cc:53

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

Bug2831TestCase::m_apPhy
Ptr< YansWifiPhy > m_apPhy
AP PHY.
Definition: wifi-test.cc:1377

ns3::MultiModelSpectrumChannel::SetPropagationDelayModel
virtual void SetPropagationDelayModel(Ptr< PropagationDelayModel > delay)
Set the propagation delay model to be used.
Definition: multi-model-spectrum-channel.cc:467

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

ns3::SsidValue
AttributeValue implementation for Ssid.
Definition: ssid.h:110

InterferenceHelperSequenceTest::m_manager
ObjectFactory m_manager
manager
Definition: wifi-test.cc:271

ns3::WIFI_MOD_CLASS_OFDM
OFDM PHY (Clause 17)
Definition: wifi-mode.h:56

ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:782

ns3::SpectrumModel::Begin
Bands::const_iterator Begin() const
Const Iterator to the model Bands container start.
Definition: spectrum-model.cc:81

Bug2483TestCase::SendPacketBurst
void SendPacketBurst(uint8_t numPackets, Ptr< NetDevice > sourceDevice, Address &destination) const
Triggers the arrival of a burst of 1000 Byte-long packets in the source device.
Definition: wifi-test.cc:1255

DcfImmediateAccessBroadcastTestCase::NotifyPhyTxBegin
void NotifyPhyTxBegin(Ptr< const Packet > p)
Notify Phy transmit begin.
Definition: wifi-test.cc:454

Bug730TestCase::m_received
uint32_t m_received
received
Definition: wifi-test.cc:568

ns3::ListPositionAllocator::Add
void Add(Vector v)
Add a position to the list of positions.
Definition: position-allocator.cc:68

ns3::MgtProbeResponseHeader::GetHtOperation
HtOperation GetHtOperation(void) const
Return the HT operation.
Definition: mgt-headers.cc:266

InterferenceHelperSequenceTest::SendOnePacket
void SendOnePacket(Ptr< WifiNetDevice > dev)
Send one packet function.
Definition: wifi-test.cc:282

ns3::WifiPhyTag
Tag for WifiTxVector and WifiPreamble information to be embedded in outgoing transmissions as a Packe...
Definition: wifi-phy-tag.h:35

ns3::WifiPhy::DefineChannelNumber
bool DefineChannelNumber(uint8_t channelNumber, WifiPhyStandard standard, uint16_t frequency, uint8_t channelWidth)
Add a channel definition to the WifiPhy.
Definition: wifi-phy.cc:1042

WifiTest::SendOnePacket
void SendOnePacket(Ptr< WifiNetDevice > dev)
Send one packet function.
Definition: wifi-test.cc:122

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

SetChannelFrequencyTest::SetChannelFrequencyTest
SetChannelFrequencyTest()
Definition: wifi-test.cc:713

ns3::Now
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:365

third.wifi
tuple wifi
Definition: third.py:89

WifiTest
Wifi Test.
Definition: wifi-test.cc:88

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:93

WifiTestSuite::WifiTestSuite
WifiTestSuite()
Definition: wifi-test.cc:1529

ns3::WifiPhy::ConfigureStandard
virtual void ConfigureStandard(WifiPhyStandard standard)
Configure the PHY-level parameters for different Wi-Fi standard.
Definition: wifi-phy.cc:1137

ns3::WifiMode::GetModulationClass
WifiModulationClass GetModulationClass() const
Definition: wifi-mode.cc:487

Bug2483TestCase
Make sure that the correct channel width and center frequency have been set for OFDM basic rate trans...
Definition: wifi-test.cc:1177

ns3::WifiTxVector::GetMode
WifiMode GetMode(void) const
Definition: wifi-tx-vector.cc:66

Bug2222TestCase::TxDataFailedTrace
void TxDataFailedTrace(std::string context, Mac48Address adr)
Transmit data failed function.
Definition: wifi-test.cc:1071

ns3::MobilityHelper::SetPositionAllocator
void SetPositionAllocator(Ptr< PositionAllocator > allocator)
Set the position allocator which will be used to allocate the initial position of every node initiali...
Definition: mobility-helper.cc:47

DcfImmediateAccessBroadcastTestCase::m_secondTransmissionTime
Time m_secondTransmissionTime
second transmission time
Definition: wifi-test.cc:438

ns3::HtOperation::GetStaChannelWidth
uint8_t GetStaChannelWidth(void) const
Return the STA channel width.
Definition: ht-operation.cc:207

Bug2831TestCase::ChangeSupportedChannelWidth
void ChangeSupportedChannelWidth(void)
Function called to change the supported channel width at runtime.
Definition: wifi-test.cc:1400

ns3::DcaTxop
handle packet fragmentation and retransmissions.
Definition: dca-txop.h:58

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

ns3::ObjectBase::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:185

ns3::Application::SetStartTime
void SetStartTime(Time start)
Specify application start time.
Definition: application.cc:69

ns3::MgtBeaconHeader
Implement the header for management frames of type beacon.
Definition: mgt-headers.h:827

Bug2831TestCase::m_reassocRespCount
uint8_t m_reassocRespCount
count number of reassociation responses
Definition: wifi-test.cc:1381

ns3::WifiMacHeader
Implements the IEEE 802.11 MAC header.
Definition: wifi-mac-header.h:80

WifiTest::CreateOne
void CreateOne(Vector pos, Ptr< YansWifiChannel > channel)
Create one function.
Definition: wifi-test.cc:129

WifiTest::WifiTest
WifiTest()
Definition: wifi-test.cc:116

SetChannelFrequencyTest
Set Channel Frequency Test.
Definition: wifi-test.cc:695

DcfImmediateAccessBroadcastTestCase
Make sure that when multiple broadcast packets are queued on the same device in a short succession...
Definition: wifi-test.cc:418

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

InterferenceHelperSequenceTest::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: wifi-test.cc:325