Resources/Documents/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:186

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

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

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

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::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::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::Dequeue
Ptr< QueueDiscItem > Dequeue(void)
Extract from the queue disc the packet that has been dequeued by calling Peek, if any...
Definition: queue-disc.cc:879

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

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

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

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 &#39;double&#39; or &#39;float&#39;...
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