3.28/doxygen/tbf-queue-disc-test-suite_8cc_source.html

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

 /*

  * Copyright (c) 2017 Kungliga Tekniska Högskolan

  *               2017 Universita' degli Studi di Napoli Federico II

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License version 2 as

  * published by the Free Software Foundation;

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  * Authors: Surya Seetharaman <suryaseetharaman.9@gmail.com>

  *          Stefano Avallone <stavallo@unina.it>

  */


 #include "ns3/test.h"

 #include "ns3/tbf-queue-disc.h"

 #include "ns3/packet.h"

 #include "ns3/uinteger.h"

 #include "ns3/string.h"

 #include "ns3/double.h"

 #include "ns3/log.h"

 #include "ns3/simulator.h"

 #include "ns3/node-container.h"

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

 #include "ns3/simple-channel.h"

 #include "ns3/traffic-control-layer.h"

 #include "ns3/config.h"


 using namespace ns3;


 class TbfQueueDiscTestItem : public QueueDiscItem {

 public:

   TbfQueueDiscTestItem (Ptr<Packet> p, const Address & addr);

   virtual ~TbfQueueDiscTestItem ();

   virtual void AddHeader (void);

   virtual bool Mark (void);


 private:

   TbfQueueDiscTestItem ();

   TbfQueueDiscTestItem (const TbfQueueDiscTestItem &);

   TbfQueueDiscTestItem &operator = (const TbfQueueDiscTestItem &);

 };


 TbfQueueDiscTestItem::TbfQueueDiscTestItem (Ptr<Packet> p, const Address & addr)

   : QueueDiscItem (p, addr, 0)

 {

 }


 TbfQueueDiscTestItem::~TbfQueueDiscTestItem ()

 {

 }


 void

 TbfQueueDiscTestItem::AddHeader (void)

 {

 }


 bool

 TbfQueueDiscTestItem::Mark (void)

 {

   return false;

 }


 class TbfQueueDiscTestCase : public TestCase

 {

 public:

   TbfQueueDiscTestCase ();

   virtual void DoRun (void);

 private:

   void Enqueue (Ptr<TbfQueueDisc> queue, Address dest, uint32_t size);

   void DequeueAndCheck (Ptr<TbfQueueDisc> queue, bool flag, std::string printStatement);

   void RunTbfTest (QueueSizeUnit mode);

 };


 TbfQueueDiscTestCase::TbfQueueDiscTestCase ()

   : TestCase ("Sanity check on the TBF queue implementation")

 {

 }


 void

 TbfQueueDiscTestCase::RunTbfTest (QueueSizeUnit mode)

 {

   uint32_t pktSize = 1500;

   // 1 for packets; pktSize for bytes

   uint32_t modeSize = 1;

   uint32_t qSize = 4;

   uint32_t burst = 6000;

   uint32_t mtu = 0;

   DataRate rate = DataRate ("6KB/s");

   DataRate peakRate = DataRate ("0KB/s");


   Ptr<TbfQueueDisc> queue = CreateObject<TbfQueueDisc> ();


   // test 1: Simple Enqueue/Dequeue with verification of attribute setting

   /* 1. There is no second bucket since "peakRate" is set to 0.

      2. A simple enqueue of five packets, each containing 1500B is followed by

         the dequeue those five packets.

      3. The subtraction of tokens from the first bucket to send out each of the

         five packets is monitored and verified.

      Note : The number of tokens in the first bucket is full at the beginning.

             With the dequeuing of each packet, the number of tokens keeps decreasing.

             So packets are dequeued as long as there are enough tokens in the bucket. */


   if (mode == QueueSizeUnit::BYTES)

     {

       modeSize = pktSize;

       qSize = qSize * modeSize;

     }


   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxSize", QueueSizeValue (QueueSize (mode, qSize))),

                          true, "Verify that we can actually set the attribute MaxSize");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Burst", UintegerValue (burst)), true,

                          "Verify that we can actually set the attribute Burst");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Mtu", UintegerValue (mtu)), true,

                          "Verify that we can actually set the attribute Mtu");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Rate", DataRateValue (rate)), true,

                          "Verify that we can actually set the attribute Rate");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("PeakRate", DataRateValue (peakRate)), true,

                          "Verify that we can actually set the attribute PeakRate");


   Address dest;


   Ptr<Packet> p1, p2, p3, p4, p5;

   p1 = Create<Packet> (pktSize);

   p2 = Create<Packet> (pktSize);

   p3 = Create<Packet> (pktSize);

   p4 = Create<Packet> (pktSize);

   p5 = Create<Packet> (pktSize);


   queue->Initialize ();

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 0 * modeSize, "There should be no packets in there");

   queue->Enqueue (Create<TbfQueueDiscTestItem> (p1, dest));

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 1 * modeSize, "There should be one packet in there");

   queue->Enqueue (Create<TbfQueueDiscTestItem> (p2, dest));

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 2 * modeSize, "There should be two packets in there");

   queue->Enqueue (Create<TbfQueueDiscTestItem> (p3, dest));

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 3 * modeSize, "There should be three packets in there");

   queue->Enqueue (Create<TbfQueueDiscTestItem> (p4, dest));

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 4 * modeSize, "There should be four packets in there");

   queue->Enqueue (Create<TbfQueueDiscTestItem> (p5, dest));

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 4 * modeSize,

                          "There should still be four packets in there as this enqueue cannot happen since QueueLimit will be exceeded");


   Ptr<QueueDiscItem> item;

   NS_TEST_EXPECT_MSG_EQ (queue->GetFirstBucketTokens (), burst, "The first token bucket should be full");

   item = queue->Dequeue ();

   NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the first packet");

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 3 * modeSize, "There should be three packets in there");

   NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p1->GetUid (), "was this the first packet ?");

   NS_TEST_EXPECT_MSG_EQ (queue->GetFirstBucketTokens (), burst - (1 * pktSize),

                          "The number of tokens in the first bucket should be one pktSize lesser");


   item = queue->Dequeue ();

   NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the second packet");

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 2 * modeSize, "There should be two packets in there");

   NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p2->GetUid (), "Was this the second packet ?");

   NS_TEST_EXPECT_MSG_EQ (queue->GetFirstBucketTokens (), burst - (2 * pktSize),

                          "The number of tokens in the first bucket should be two pktSizes lesser");


   item = queue->Dequeue ();

   NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the third packet");

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 1 * modeSize, "There should be one packet in there");

   NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p3->GetUid (), "Was this the third packet ?");

   NS_TEST_EXPECT_MSG_EQ (queue->GetFirstBucketTokens (), burst - (3 * pktSize),

                          "The number of tokens in the first bucket should be three pktSizes lesser");


   item = queue->Dequeue ();

   NS_TEST_EXPECT_MSG_EQ ((item != 0), true, "I want to remove the fourth packet");

   NS_TEST_EXPECT_MSG_EQ (queue->GetCurrentSize ().GetValue (), 0 * modeSize, "There should be zero packet in there");

   NS_TEST_EXPECT_MSG_EQ (item->GetPacket ()->GetUid (), p4->GetUid (), "Was this the fourth packet ?");

   NS_TEST_EXPECT_MSG_EQ (queue->GetFirstBucketTokens (), burst - (4 * pktSize),

                          "The number of tokens in the first bucket should be four pktSizes lesser");


   // test 2 : When DataRate == FirstBucketTokenRate; packets should pass smoothly.

   queue = CreateObject<TbfQueueDisc> ();

   qSize = 10;

   pktSize = 1000;

   burst = 10000;

   mtu = 1000;

   rate = DataRate ("10KB/s");

   peakRate = DataRate ("100KB/s");

   uint32_t nPkt = qSize;


   if (mode == QueueSizeUnit::BYTES)

     {

       modeSize = pktSize;

       qSize = qSize * modeSize;

     }


   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxSize", QueueSizeValue (QueueSize (mode, qSize))),

                          true, "Verify that we can actually set the attribute MaxSize");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Burst", UintegerValue (burst)), true,

                          "Verify that we can actually set the attribute Burst");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Mtu", UintegerValue (mtu)), true,

                          "Verify that we can actually set the attribute Mtu");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Rate", DataRateValue (rate)), true,

                          "Verify that we can actually set the attribute Rate");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("PeakRate", DataRateValue (peakRate)), true,

                          "Verify that we can actually set the attribute PeakRate");


   queue->Initialize ();

   double delay = 0.09;

   for (uint32_t i = 1; i <= nPkt; i++)

     {

       Simulator::Schedule (Time (Seconds ((i + 1) * delay)), &TbfQueueDiscTestCase::Enqueue, this, queue, dest, pktSize);

     }

   delay = 0.1;

   for (uint32_t i = 1; i <= nPkt; i++)

     {

       Simulator::Schedule (Time (Seconds ((i + 1) * delay)), &TbfQueueDiscTestCase::DequeueAndCheck, this,

                            queue, true, "No packet should be blocked");

     }

   Simulator::Stop (Seconds (1));

   Simulator::Run ();


   // test 3 : When DataRate >>> FirstBucketTokenRate; some packets should get blocked and waking of queue should get scheduled.

   /* 10 packets are enqueued and then dequeued. Since the token rate is less than the data rate, the last packet i.e the 10th

      packet gets blocked and waking of queue is scheduled after a time when enough tokens will be available. At that time the

      10th packet passes through. */

   queue = CreateObject<TbfQueueDisc> ();


   Config::SetDefault ("ns3::QueueDisc::Quota", UintegerValue (1));

   NodeContainer nodesA;

   nodesA.Create (2);

   Ptr<SimpleNetDevice> txDevA = CreateObject<SimpleNetDevice> ();

   nodesA.Get (0)->AddDevice (txDevA);

   Ptr<SimpleNetDevice> rxDevA = CreateObject<SimpleNetDevice> ();

   nodesA.Get (1)->AddDevice (rxDevA);

   Ptr<SimpleChannel> channelA = CreateObject<SimpleChannel> ();

   txDevA->SetChannel (channelA);

   rxDevA->SetChannel (channelA);

   txDevA->SetNode (nodesA.Get (0));

   rxDevA->SetNode (nodesA.Get (1));


   dest = txDevA->GetAddress ();


   Ptr<TrafficControlLayer> tcA = CreateObject<TrafficControlLayer> ();

   nodesA.Get (0)->AggregateObject (tcA);

   queue->SetNetDevice (txDevA);

   tcA->SetRootQueueDiscOnDevice (txDevA, queue);

   tcA->Initialize ();


   burst = 5000;

   mtu = 1000;

   rate = DataRate ("5KB/s");

   peakRate = DataRate ("100KB/s");


   if (mode == QueueSizeUnit::BYTES)

     {

       modeSize = pktSize;

       qSize = qSize * modeSize;

     }


   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxSize", QueueSizeValue (QueueSize (mode, qSize))),

                          true, "Verify that we can actually set the attribute MaxSize");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Burst", UintegerValue (burst)), true,

                          "Verify that we can actually set the attribute Burst");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Mtu", UintegerValue (mtu)), true,

                          "Verify that we can actually set the attribute Mtu");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Rate", DataRateValue (rate)), true,

                          "Verify that we can actually set the attribute Rate");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("PeakRate", DataRateValue (peakRate)), true,

                          "Verify that we can actually set the attribute PeakRate");


   delay = 0.09;

   for (uint32_t i = 1; i <= nPkt; i++)

     {

       Simulator::Schedule (Time (Seconds ((i + 1) * delay)), &TbfQueueDiscTestCase::Enqueue, this, queue, dest, pktSize);

     }

   delay = 0.1;

   for (uint32_t i = 1; i <= nPkt; i++)

     {

       if (i == 10)

         {

           Simulator::Schedule (Time (Seconds ((i + 1) * delay)), &TbfQueueDiscTestCase::DequeueAndCheck, this,

                                queue, false, "10th packet should be blocked");

         }

       else

         {

           Simulator::Schedule (Time (Seconds ((i + 1) * delay)), &TbfQueueDiscTestCase::DequeueAndCheck, this,

                                queue, true, "This packet should not be blocked");

         }

     }

   Simulator::Stop (Seconds (1.3));

   Simulator::Run ();


   // test 4 : When DataRate < FirstBucketTokenRate; burst condition, peakRate is set so that bursts are controlled.

   /* This test checks the burst control ability of TBF. 10 packets each of size 1000 bytes are enqueued followed by

      their dequeue. The data rate (25 KB/s) is not sufficiently higher than the btokens rate (15 KB/s), so that in

      the startup phase the first bucket is not empty. Hence when adequate tokens are present in the second bucket,

      the packets get transmitted, otherwise they are blocked. So basically the transmission of packets falls under the

      regulation of the second bucket since first bucket will always have excess tokens. TBF does not let all

      the packets go smoothly without any control just because there are excess tokens in the first bucket. */

   queue = CreateObject<TbfQueueDisc> ();


   Config::SetDefault ("ns3::QueueDisc::Quota", UintegerValue (1));

   NodeContainer nodesB;

   nodesB.Create (2);

   Ptr<SimpleNetDevice> txDevB = CreateObject<SimpleNetDevice> ();

   nodesB.Get (0)->AddDevice (txDevB);

   Ptr<SimpleNetDevice> rxDevB = CreateObject<SimpleNetDevice> ();

   nodesB.Get (1)->AddDevice (rxDevB);

   Ptr<SimpleChannel> channelB = CreateObject<SimpleChannel> ();

   txDevB->SetChannel (channelB);

   rxDevB->SetChannel (channelB);

   txDevB->SetNode (nodesB.Get (0));

   rxDevB->SetNode (nodesB.Get (1));


   dest = txDevB->GetAddress ();


   Ptr<TrafficControlLayer> tcB = CreateObject<TrafficControlLayer> ();

   nodesB.Get (0)->AggregateObject (tcB);

   queue->SetNetDevice (txDevB);

   tcB->SetRootQueueDiscOnDevice (txDevB, queue);

   tcB->Initialize ();


   burst = 15000;

   mtu = 1000;

   rate = DataRate ("15KB/s");

   peakRate = DataRate ("20KB/s");


   if (mode == QueueSizeUnit::BYTES)

     {

       modeSize = pktSize;

       qSize = qSize * modeSize;

     }


   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxSize", QueueSizeValue (QueueSize (mode, qSize))),

                          true, "Verify that we can actually set the attribute MaxSize");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Burst", UintegerValue (burst)), true,

                          "Verify that we can actually set the attribute Burst");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Mtu", UintegerValue (mtu)), true,

                          "Verify that we can actually set the attribute Mtu");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Rate", DataRateValue (rate)), true,

                          "Verify that we can actually set the attribute Rate");

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("PeakRate", DataRateValue (peakRate)), true,

                          "Verify that we can actually set the attribute PeakRate");


   queue->Initialize ();

   delay = 0.04;

   for (uint32_t i = 1; i <= nPkt; i++)

     {

       Simulator::Schedule (Time (Seconds ((i + 1) * delay)), &TbfQueueDiscTestCase::Enqueue, this, queue, dest, pktSize);

     }


   for (uint32_t i = 1; i <= nPkt; i++)

     {

       if (i % 2 == 1)

         {

           Simulator::Schedule (Time (Seconds ((i + 1) * delay + 0.02)), &TbfQueueDiscTestCase::DequeueAndCheck, this,

                                queue, true, "1st packet should not be blocked");

         }

       else

         {

           Simulator::Schedule (Time (Seconds ((i + 1) * delay + 0.02)), &TbfQueueDiscTestCase::DequeueAndCheck, this,

                                queue, false, "This packet should be blocked");

         }

     }

   Simulator::Stop (Seconds (0.55));

   Simulator::Run ();


 }


 void

 TbfQueueDiscTestCase::Enqueue (Ptr<TbfQueueDisc> queue, Address dest, uint32_t size)

 {

   queue->Enqueue (Create<TbfQueueDiscTestItem> (Create<Packet> (size), dest));

 }


 void

 TbfQueueDiscTestCase::DequeueAndCheck (Ptr<TbfQueueDisc> queue, bool flag, std::string printStatement)

 {

   Ptr<QueueDiscItem> item = queue->Dequeue ();

   NS_TEST_EXPECT_MSG_EQ ((item != 0), flag, printStatement);

 }


 void

 TbfQueueDiscTestCase::DoRun (void)

 {

   RunTbfTest (QueueSizeUnit::PACKETS);

   RunTbfTest (QueueSizeUnit::BYTES);

   Simulator::Destroy ();


 }


 static class TbfQueueDiscTestSuite : public TestSuite

 {

 public:

   TbfQueueDiscTestSuite ()

     : TestSuite ("tbf-queue-disc", UNIT)

   {

     AddTestCase (new TbfQueueDiscTestCase (), TestCase::QUICK);

   }

 } g_tbfQueueTestSuite;

ns3::SimpleNetDevice::GetAddress
virtual Address GetAddress(void) const
Definition: simple-net-device.cc:363

TbfQueueDiscTestItem
Tbf Queue Disc Test Item.
Definition: tbf-queue-disc-test-suite.cc:45

TbfQueueDiscTestCase
Tbf Queue Disc Test Case.
Definition: tbf-queue-disc-test-suite.cc:99

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

TbfQueueDiscTestItem::~TbfQueueDiscTestItem
virtual ~TbfQueueDiscTestItem()
Definition: tbf-queue-disc-test-suite.cc:78

ns3::Ptr< Packet >

ns3::TrafficControlLayer::SetRootQueueDiscOnDevice
virtual void SetRootQueueDiscOnDevice(Ptr< NetDevice > device, Ptr< QueueDisc > qDisc)
This method can be used to set the root queue disc installed on a device.
Definition: traffic-control-layer.cc:192

ns3::QueueSize
Class for representing queue sizes.
Definition: queue-size.h:94

ns3::QueueDisc::Enqueue
bool Enqueue(Ptr< QueueDiscItem > item)
Pass a packet to store to the queue discipline.
Definition: queue-disc.cc:825

ns3::QueueSizeUnit
QueueSizeUnit
Enumeration of the operating modes of queues.
Definition: queue-size.h:42

ns3::QueueDisc::GetCurrentSize
QueueSize GetCurrentSize(void)
Get the current size of the queue disc in bytes, if operating in bytes mode, or packets, otherwise.
Definition: queue-disc.cc:523

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::Packet::GetUid
uint64_t GetUid(void) const
Returns the packet's Uid.
Definition: packet.cc:390

TbfQueueDiscTestSuite::TbfQueueDiscTestSuite
TbfQueueDiscTestSuite()
Definition: tbf-queue-disc-test-suite.cc:446

TbfQueueDiscTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: tbf-queue-disc-test-suite.cc:429

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

TbfQueueDiscTestCase::TbfQueueDiscTestCase
TbfQueueDiscTestCase()
Definition: tbf-queue-disc-test-suite.cc:126

ns3::ObjectBase::SetAttributeFailSafe
bool SetAttributeFailSafe(std::string name, const AttributeValue &value)
Set a single attribute without raising errors.
Definition: object-base.cc:205

ns3::QueueDiscItem
QueueDiscItem is the abstract base class for items that are stored in a queue disc.
Definition: queue-item.h:148

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

ns3::TestSuite::UNIT
This test suite implements a Unit Test.
Definition: test.h:1352

g_tbfQueueTestSuite
TbfQueueDiscTestSuite g_tbfQueueTestSuite
the test suite

ns3::TbfQueueDisc::GetFirstBucketTokens
uint32_t GetFirstBucketTokens(void) const
Get the current number of tokens inside the first bucket in bytes.
Definition: tbf-queue-disc.cc:168

ns3::QueueSize::GetValue
uint32_t GetValue() const
Get the underlying value.
Definition: queue-size.cc:175

TbfQueueDiscTestSuite
Tbf Queue Disc Test Suite.
Definition: tbf-queue-disc-test-suite.cc:443

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

ns3::QueueSizeValue
Definition: queue-size.h:221

TbfQueueDiscTestItem::TbfQueueDiscTestItem
TbfQueueDiscTestItem()

ns3::DataRate
Class for representing data rates.
Definition: data-rate.h:88

ns3::SimpleNetDevice::SetNode
virtual void SetNode(Ptr< Node > node)
Definition: simple-net-device.cc:545

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

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

ns3::PACKETS
Use number of packets for queue size.
Definition: queue-size.h:44

TbfQueueDiscTestCase::Enqueue
void Enqueue(Ptr< TbfQueueDisc > queue, Address dest, uint32_t size)
Enqueue function.
Definition: tbf-queue-disc-test-suite.cc:416

TbfQueueDiscTestCase::DequeueAndCheck
void DequeueAndCheck(Ptr< TbfQueueDisc > queue, bool flag, std::string printStatement)
DequeueAndCheck function to check if a packet is blocked or not after dequeuing and verify against ex...
Definition: tbf-queue-disc-test-suite.cc:422

TbfQueueDiscTestItem::Mark
virtual bool Mark(void)
Marks the packet as a substitute for dropping it, such as for Explicit Congestion Notification...
Definition: tbf-queue-disc-test-suite.cc:88

ns3::QueueDisc::Dequeue
Ptr< QueueDiscItem > Dequeue(void)
Request the queue discipline to extract a packet.
Definition: queue-disc.cc:860

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

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

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

ns3::DataRateValue
AttributeValue implementation for DataRate.
Definition: data-rate.h:242

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

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

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

TbfQueueDiscTestItem::AddHeader
virtual void AddHeader(void)
Add the header to the packet.
Definition: tbf-queue-disc-test-suite.cc:83

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

ns3::SimpleNetDevice::SetChannel
void SetChannel(Ptr< SimpleChannel > channel)
Attach a channel to this net device.
Definition: simple-net-device.cc:308

ns3::BYTES
Use number of bytes for queue size.
Definition: queue-size.h:45

TbfQueueDiscTestCase::RunTbfTest
void RunTbfTest(QueueSizeUnit mode)
Run TBF test function.
Definition: tbf-queue-disc-test-suite.cc:132

ns3::Object::Initialize
void Initialize(void)
Invoke DoInitialize on all Objects aggregated to this one.
Definition: object.cc:183

ns3::QueueDisc::SetNetDevice
void SetNetDevice(Ptr< NetDevice > device)
Set the NetDevice on which this queue discipline is installed.
Definition: queue-disc.cc:539