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

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

 /*

  * Copyright (c) 2016 NITK Surathkal

  *

  * 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: Shravya Ks <shravya.ks0@gmail.com>

  *          Smriti Murali <m.smriti.95@gmail.com>

  *          Mohit P. Tahiliani <tahiliani@nitk.edu.in>

  *

  */


 #include "ns3/test.h"

 #include "ns3/pie-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"


 using namespace ns3;


 class PieQueueDiscTestItem : public QueueDiscItem

 {

 public:

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

   virtual ~PieQueueDiscTestItem ();

   virtual void AddHeader (void);

   virtual bool Mark (void);


 private:

   PieQueueDiscTestItem ();

   PieQueueDiscTestItem (const PieQueueDiscTestItem &);

   PieQueueDiscTestItem &operator = (const PieQueueDiscTestItem &);

 };


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

   : QueueDiscItem (p, addr, 0)

 {

 }


 PieQueueDiscTestItem::~PieQueueDiscTestItem ()

 {

 }


 void

 PieQueueDiscTestItem::AddHeader (void)

 {

 }


 bool

 PieQueueDiscTestItem::Mark (void)

 {

   return false;

 }


 class PieQueueDiscTestCase : public TestCase

 {

 public:

   PieQueueDiscTestCase ();

   virtual void DoRun (void);

 private:

   void Enqueue (Ptr<PieQueueDisc> queue, uint32_t size, uint32_t nPkt);

   void EnqueueWithDelay (Ptr<PieQueueDisc> queue, uint32_t size, uint32_t nPkt);

   void Dequeue (Ptr<PieQueueDisc> queue, uint32_t nPkt);

   void DequeueWithDelay (Ptr<PieQueueDisc> queue, double delay, uint32_t nPkt);

   void RunPieTest (QueueSizeUnit mode);

 };


 PieQueueDiscTestCase::PieQueueDiscTestCase ()

   : TestCase ("Sanity check on the pie queue disc implementation")

 {

 }


 void

 PieQueueDiscTestCase::RunPieTest (QueueSizeUnit mode)

 {

   uint32_t pktSize = 0;


   // 1 for packets; pktSize for bytes

   uint32_t modeSize = 1;


   uint32_t qSize = 300;

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


   // test 1: simple enqueue/dequeue with defaults, no drops

   Address dest;


   if (mode == QueueSizeUnit::BYTES)

     {

       // pktSize should be same as MeanPktSize to avoid performance gap between byte and packet mode

       pktSize = 1000;

       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");


   Ptr<Packet> p1, p2, p3, p4, p5, p6, p7, p8;

   p1 = Create<Packet> (pktSize);

   p2 = Create<Packet> (pktSize);

   p3 = Create<Packet> (pktSize);

   p4 = Create<Packet> (pktSize);

   p5 = Create<Packet> (pktSize);

   p6 = Create<Packet> (pktSize);

   p7 = Create<Packet> (pktSize);

   p8 = 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<PieQueueDiscTestItem> (p1, dest));

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

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

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

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

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

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

   queue->Enqueue (Create<PieQueueDiscTestItem> (p6, dest));

   queue->Enqueue (Create<PieQueueDiscTestItem> (p7, dest));

   queue->Enqueue (Create<PieQueueDiscTestItem> (p8, dest));

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


   Ptr<QueueDiscItem> item;


   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 (), 7 * modeSize, "There should be seven packets in there");

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


   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 (), 6 * modeSize, "There should be six packet in there");

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


   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 (), 5 * modeSize, "There should be five packets in there");

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


   item = queue->Dequeue ();

   item = queue->Dequeue ();

   item = queue->Dequeue ();

   item = queue->Dequeue ();

   item = queue->Dequeue ();


   item = queue->Dequeue ();

   NS_TEST_EXPECT_MSG_EQ ((item == 0), true, "There are really no packets in there");


   // test 2: more data with defaults, unforced drops but no forced drops

   queue = CreateObject<PieQueueDisc> ();

   pktSize = 1000;  // pktSize != 0 because DequeueThreshold always works in bytes

   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 ("A", DoubleValue (0.125)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("B", DoubleValue (1.25)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Tupdate", TimeValue (Seconds (0.03))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Supdate", TimeValue (Seconds (0.0))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("DequeueThreshold", UintegerValue (10000)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QueueDelayReference", TimeValue (Seconds (0.02))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxBurstAllowance", TimeValue (Seconds (0.1))), true,

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

   queue->Initialize ();

   EnqueueWithDelay (queue, pktSize, 400);

   DequeueWithDelay (queue, 0.012, 400);

   Simulator::Stop (Seconds (8.0));

   Simulator::Run ();

   QueueDisc::Stats st = queue->GetStats ();

   uint32_t test2 = st.GetNDroppedPackets (PieQueueDisc::UNFORCED_DROP);

   NS_TEST_EXPECT_MSG_NE (test2, 0, "There should be some unforced drops");

   NS_TEST_EXPECT_MSG_EQ (st.GetNDroppedPackets (PieQueueDisc::FORCED_DROP), 0, "There should be zero forced drops");


   // test 3: same as test 2, but with higher QueueDelayReference

   queue = CreateObject<PieQueueDisc> ();

   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 ("A", DoubleValue (0.125)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("B", DoubleValue (1.25)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Tupdate", TimeValue (Seconds (0.03))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Supdate", TimeValue (Seconds (0.0))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("DequeueThreshold", UintegerValue (10000)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QueueDelayReference", TimeValue (Seconds (0.08))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxBurstAllowance", TimeValue (Seconds (0.1))), true,

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

   queue->Initialize ();

   EnqueueWithDelay (queue, pktSize, 400);

   DequeueWithDelay (queue, 0.012, 400);

   Simulator::Stop (Seconds (8.0));

   Simulator::Run ();

   st = queue->GetStats ();

   uint32_t test3 = st.GetNDroppedPackets (PieQueueDisc::UNFORCED_DROP);

   NS_TEST_EXPECT_MSG_LT (test3, test2, "Test 3 should have less unforced drops than test 2");

   NS_TEST_EXPECT_MSG_EQ (st.GetNDroppedPackets (PieQueueDisc::FORCED_DROP), 0, "There should be zero forced drops");


   // test 4: same as test 2, but with reduced dequeue rate

   queue = CreateObject<PieQueueDisc> ();

   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 ("A", DoubleValue (0.125)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("B", DoubleValue (1.25)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Tupdate", TimeValue (Seconds (0.03))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Supdate", TimeValue (Seconds (0.0))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("DequeueThreshold", UintegerValue (10000)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QueueDelayReference", TimeValue (Seconds (0.02))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxBurstAllowance", TimeValue (Seconds (0.1))), true,

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

   queue->Initialize ();

   EnqueueWithDelay (queue, pktSize, 400);

   DequeueWithDelay (queue, 0.015, 400); // delay between two successive dequeue events is increased

   Simulator::Stop (Seconds (8.0));

   Simulator::Run ();

   st = queue->GetStats ();

   uint32_t test4 = st.GetNDroppedPackets (PieQueueDisc::UNFORCED_DROP);

   NS_TEST_EXPECT_MSG_GT (test4, test2, "Test 4 should have more unforced drops than test 2");

   NS_TEST_EXPECT_MSG_EQ (st.GetNDroppedPackets (PieQueueDisc::FORCED_DROP), 0, "There should be zero forced drops");


   // test 5: same dequeue rate as test 4, but with higher Tupdate

   queue = CreateObject<PieQueueDisc> ();

   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 ("A", DoubleValue (0.125)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("B", DoubleValue (1.25)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Tupdate", TimeValue (Seconds (0.09))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Supdate", TimeValue (Seconds (0.0))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("DequeueThreshold", UintegerValue (10000)), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QueueDelayReference", TimeValue (Seconds (0.02))), true,

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

   NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxBurstAllowance", TimeValue (Seconds (0.1))), true,

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

   queue->Initialize ();

   EnqueueWithDelay (queue, pktSize, 400);

   DequeueWithDelay (queue, 0.015, 400);

   Simulator::Stop (Seconds (8.0));

   Simulator::Run ();

   st = queue->GetStats ();

   uint32_t test5 = st.GetNDroppedPackets (PieQueueDisc::UNFORCED_DROP);

   NS_TEST_EXPECT_MSG_LT (test5, test4, "Test 5 should have less unforced drops than test 4");

   NS_TEST_EXPECT_MSG_EQ (st.GetNDroppedPackets (PieQueueDisc::FORCED_DROP), 0, "There should be zero forced drops");

 }


 void

 PieQueueDiscTestCase::Enqueue (Ptr<PieQueueDisc> queue, uint32_t size, uint32_t nPkt)

 {

   Address dest;

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

     {

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

     }

 }


 void

 PieQueueDiscTestCase::EnqueueWithDelay (Ptr<PieQueueDisc> queue, uint32_t size, uint32_t nPkt)

 {

   Address dest;

   double delay = 0.01;  // enqueue packets with delay

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

     {

       Simulator::Schedule (Time (Seconds ((i + 1) * delay)), &PieQueueDiscTestCase::Enqueue, this, queue, size, 1);

     }

 }


 void

 PieQueueDiscTestCase::Dequeue (Ptr<PieQueueDisc> queue, uint32_t nPkt)

 {

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

     {

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

     }

 }


 void

 PieQueueDiscTestCase::DequeueWithDelay (Ptr<PieQueueDisc> queue, double delay, uint32_t nPkt)

 {

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

     {

       Simulator::Schedule (Time (Seconds ((i + 1) * delay)), &PieQueueDiscTestCase::Dequeue, this, queue, 1);

     }

 }


 void

 PieQueueDiscTestCase::DoRun (void)

 {

   RunPieTest (QueueSizeUnit::PACKETS);

   RunPieTest (QueueSizeUnit::BYTES);

   Simulator::Destroy ();

 }


 static class PieQueueDiscTestSuite : public TestSuite

 {

 public:

   PieQueueDiscTestSuite ()

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

   {

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

   }

 } g_pieQueueTestSuite;

ns3::QueueDisc::Stats
Structure that keeps the queue disc statistics.
Definition: queue-disc.h:185

PieQueueDiscTestCase
Pie Queue Disc Test Case.
Definition: pie-queue-disc-test-suite.cc:96

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

PieQueueDiscTestCase::PieQueueDiscTestCase
PieQueueDiscTestCase()
Definition: pie-queue-disc-test-suite.cc:136

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

ns3::Ptr< Packet >

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

PieQueueDiscTestCase::RunPieTest
void RunPieTest(QueueSizeUnit mode)
Run test function.
Definition: pie-queue-disc-test-suite.cc:142

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

PieQueueDiscTestCase::Dequeue
void Dequeue(Ptr< PieQueueDisc > queue, uint32_t nPkt)
Dequeue function.
Definition: pie-queue-disc-test-suite.cc:357

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

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

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

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

PieQueueDiscTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: pie-queue-disc-test-suite.cc:375

ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1069

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

PieQueueDiscTestItem::AddHeader
virtual void AddHeader(void)
Add the header to the packet.
Definition: pie-queue-disc-test-suite.cc:80

ns3::QueueDisc::GetStats
const Stats & GetStats(void)
Retrieve all the collected statistics.
Definition: queue-disc.cc:421

ns3::QueueDisc::Stats::GetNDroppedPackets
uint32_t GetNDroppedPackets(std::string reason) const
Get the number of packets dropped for the given reason.
Definition: queue-disc.cc:113

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.

PieQueueDiscTestItem::PieQueueDiscTestItem
PieQueueDiscTestItem()

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

PieQueueDiscTestSuite::PieQueueDiscTestSuite
PieQueueDiscTestSuite()
Definition: pie-queue-disc-test-suite.cc:391

NS_TEST_EXPECT_MSG_GT
#define NS_TEST_EXPECT_MSG_GT(actual, limit, msg)
Test that an actual value is greater than a limit and report if not.
Definition: test.h:1090

PieQueueDiscTestCase::EnqueueWithDelay
void EnqueueWithDelay(Ptr< PieQueueDisc > queue, uint32_t size, uint32_t nPkt)
Enqueue with delay function.
Definition: pie-queue-disc-test-suite.cc:346

PieQueueDiscTestItem
Pie Queue Disc Test Item.
Definition: pie-queue-disc-test-suite.cc:41

g_pieQueueTestSuite
PieQueueDiscTestSuite g_pieQueueTestSuite
the test suite

PieQueueDiscTestItem::~PieQueueDiscTestItem
virtual ~PieQueueDiscTestItem()
Definition: pie-queue-disc-test-suite.cc:75

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

NS_TEST_EXPECT_MSG_LT
#define NS_TEST_EXPECT_MSG_LT(actual, limit, msg)
Test that an actual value is less than a limit and report if not.
Definition: test.h:903

PieQueueDiscTestSuite
Pie Queue Disc Test Suite.
Definition: pie-queue-disc-test-suite.cc:388

PieQueueDiscTestCase::DequeueWithDelay
void DequeueWithDelay(Ptr< PieQueueDisc > queue, double delay, uint32_t nPkt)
Dequeue with delay function.
Definition: pie-queue-disc-test-suite.cc:366

PieQueueDiscTestCase::Enqueue
void Enqueue(Ptr< PieQueueDisc > queue, uint32_t size, uint32_t nPkt)
Enqueue function.
Definition: pie-queue-disc-test-suite.cc:336

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

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

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