F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

traffic-control: Eliminate Visual Studio compiler warnings (based on Robert Ammon's patch)

Browse Source
This commit is contained in:
Stefano Avallone
2018-02-23 15:46:09 +01:00
parent 9ade1f55fa
commit 946e70807f
16 changed files with 73 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/traffic-control/examples/codel-vs-pfifo-asymmetric.cc
View File

@@ -232,7 +232,7 @@ int main (int argc, char *argv[])
uint32_t numOfDownLoadOnOffFlows = 1; // # of download onoff flows
bool isPcapEnabled = true;
float startTime = 0.1;
float startTime = 0.1f;
float simDuration = 60; //in seconds
std::string fileNamePrefix = "codel-vs-pfifo-fast-asymmetric";

2
src/traffic-control/examples/codel-vs-pfifo-basic-test.cc
View File

@@ -87,7 +87,7 @@ int main (int argc, char *argv[])
uint32_t queueDiscSize = 1000; //in packets
uint32_t queueSize = 10; //in packets
uint32_t pktSize = 1458; //in bytes. 1458 to prevent fragments
float startTime = 0.1;
float startTime = 0.1f;
float simDuration = 60; //in seconds
bool isPcapEnabled = true;

2
src/traffic-control/examples/pfifo-vs-red.cc
View File

@@ -166,7 +166,7 @@ int main (int argc, char *argv[])
std::cout << "Running the simulation" << std::endl;
Simulator::Run ();
uint32_t totalRxBytesCounter = 0;
uint64_t totalRxBytesCounter = 0;
for (uint32_t i = 0; i < sinkApps.GetN (); i++)
{
Ptr <Application> app = sinkApps.Get (i);

2
src/traffic-control/helper/queue-disc-container.cc
View File

@@ -46,7 +46,7 @@ QueueDiscContainer::End (void) const
uint32_t
QueueDiscContainer::GetN (void) const
{
return m_queueDiscs.size ();
return static_cast<uint32_t>(m_queueDiscs.size ());
}
Ptr<QueueDisc>

8
src/traffic-control/helper/traffic-control-helper.cc
View File

@@ -53,7 +53,7 @@ uint16_t
QueueDiscFactory::AddQueueDiscClass (ObjectFactory factory)
{
m_queueDiscClassesFactory.push_back (factory);
return m_queueDiscClassesFactory.size () - 1;
return static_cast<uint16_t>(m_queueDiscClassesFactory.size () - 1);
}
void
@@ -85,7 +85,7 @@ QueueDiscFactory::CreateQueueDisc (const std::vector<Ptr<QueueDisc> > & queueDis
}
// create and add the queue disc classes
for (uint32_t i = 0; i < m_queueDiscClassesFactory.size (); i++)
for (uint16_t i = 0; i < m_queueDiscClassesFactory.size (); i++)
{
// the class ID is given by the index i of the vector
NS_ABORT_MSG_IF (m_classIdChildHandleMap.find (i) == m_classIdChildHandleMap.end (),
@@ -293,7 +293,7 @@ TrafficControlHelper::AddChildQueueDisc (uint16_t handle, uint16_t classId, std:
factory.Set (n14, v14);
factory.Set (n15, v15);
uint16_t childHandle = m_queueDiscFactory.size ();
uint16_t childHandle = static_cast<uint16_t>(m_queueDiscFactory.size ());
m_queueDiscFactory.push_back (QueueDiscFactory (factory));
m_queueDiscFactory[handle].SetChildQueueDisc (classId, childHandle);
@@ -367,7 +367,7 @@ TrafficControlHelper::Install (Ptr<NetDevice> d)
m_queueDiscs.resize (m_queueDiscFactory.size ());
// Create queue discs (from leaves to root)
for (int i = m_queueDiscFactory.size () - 1; i >= 0; i--)
for (auto i = m_queueDiscFactory.size () - 1; i >= 0; i--)
{
Ptr<QueueDisc> q = m_queueDiscFactory[i].CreateQueueDisc (m_queueDiscs);
q->SetNetDevice (d);

6
src/traffic-control/model/codel-queue-disc.cc
View File

@@ -62,7 +62,7 @@ static uint32_t CoDelGetTime (void)
Time time = Simulator::Now ();
uint64_t ns = time.GetNanoSeconds ();
return ns >> CODEL_SHIFT;
return static_cast<uint32_t>(ns >> CODEL_SHIFT);
}
@@ -158,7 +158,7 @@ CoDelQueueDisc::NewtonStep (void)
val >>= 2; /* avoid overflow */
val = (val * invsqrt) >> (32 - 2 + 1);
m_recInvSqrt = val >> REC_INV_SQRT_SHIFT;
m_recInvSqrt = static_cast<uint16_t>(val >> REC_INV_SQRT_SHIFT);
}
uint32_t
@@ -458,7 +458,7 @@ CoDelQueueDisc::CoDelTimeBeforeEq (uint32_t a, uint32_t b)
uint32_t
CoDelQueueDisc::Time2CoDel (Time t)
{
return (t.GetNanoSeconds () >> CODEL_SHIFT);
return static_cast<uint32_t>(t.GetNanoSeconds () >> CODEL_SHIFT);
}
bool

2
src/traffic-control/model/fq-codel-queue-disc.cc
View File

@@ -279,7 +279,7 @@ FqCoDelQueueDisc::DoDequeue (void)
}
} while (item == 0);
flow->IncreaseDeficit (-item->GetSize ());
flow->IncreaseDeficit (item->GetSize () * -1);
return item;
}

6
src/traffic-control/model/pie-queue-disc.cc
View File

@@ -217,7 +217,7 @@ PieQueueDisc::InitializeParams (void)
{
// Initially queue is empty so variables are initialize to zero except m_dqCount
m_inMeasurement = false;
m_dqCount = -1;
m_dqCount = DQCOUNT_INVALID;
m_dropProb = 0;
m_avgDqRate = 0.0;
m_dqStart = 0;
@@ -354,10 +354,10 @@ void PieQueueDisc::CalculateP ()
m_burstAllowance -= m_tUpdate;
}
uint32_t burstResetLimit = BURST_RESET_TIMEOUT / m_tUpdate.GetSeconds ();
uint32_t burstResetLimit = static_cast<uint32_t>(BURST_RESET_TIMEOUT / m_tUpdate.GetSeconds ());
if ( (qDelay.GetSeconds () < 0.5 * m_qDelayRef.GetSeconds ()) && (m_qDelayOld.GetSeconds () < (0.5 * m_qDelayRef.GetSeconds ())) && (m_dropProb == 0) && !missingInitFlag )
{
m_dqCount = -1;
m_dqCount = DQCOUNT_INVALID;
m_avgDqRate = 0.0;
}
if ( (qDelay.GetSeconds () < 0.5 * m_qDelayRef.GetSeconds ()) && (m_qDelayOld.GetSeconds () < (0.5 * m_qDelayRef.GetSeconds ())) && (m_dropProb == 0) && (m_burstAllowance.GetSeconds () == 0))

4
src/traffic-control/model/pie-queue-disc.h
View File

@@ -168,6 +168,8 @@ private:
*/
void CalculateP ();
static const uint64_t DQCOUNT_INVALID = std::numeric_limits<uint64_t>::max(); //!< Invalid dqCount value
// ** Variables supplied by user
QueueDiscMode m_mode; //!< Mode (bytes or packets)
uint32_t m_queueLimit; //!< Queue limit in bytes / packets
@@ -190,7 +192,7 @@ private:
bool m_inMeasurement; //!< Indicates whether we are in a measurement cycle
double m_avgDqRate; //!< Time averaged dequeue rate
double m_dqStart; //!< Start timestamp of current measurement cycle
uint32_t m_dqCount; //!< Number of bytes departed since current measurement cycle starts
uint64_t m_dqCount; //!< Number of bytes departed since current measurement cycle starts
EventId m_rtrsEvent; //!< Event used to decide the decision of interval of drop probability calculation
Ptr<UniformRandomVariable> m_uv; //!< Rng stream
};

6
src/traffic-control/model/queue-disc.cc
View File

@@ -498,7 +498,7 @@ QueueDisc::GetInternalQueue (uint32_t i) const
uint32_t
QueueDisc::GetNInternalQueues (void) const
{
return m_queues.size ();
return static_cast<uint32_t>(m_queues.size ());
}
void
@@ -518,7 +518,7 @@ QueueDisc::GetPacketFilter (uint32_t i) const
uint32_t
QueueDisc::GetNPacketFilters (void) const
{
return m_filters.size ();
return static_cast<uint32_t>(m_filters.size ());
}
void
@@ -556,7 +556,7 @@ QueueDisc::GetQueueDiscClass (uint32_t i) const
uint32_t
QueueDisc::GetNQueueDiscClasses (void) const
{
return m_classes.size ();
return static_cast<uint32_t>(m_classes.size ());
}
int32_t

2
src/traffic-control/model/red-queue-disc.cc
View File

@@ -669,7 +669,7 @@ RedQueueDisc::Estimator (uint32_t nQueued, uint32_t m, double qAvg, double qW)
{
NS_LOG_FUNCTION (this << nQueued << m << qAvg << qW);
double newAve = qAvg * pow(1.0-qW, m);
double newAve = qAvg * std::pow (1.0 - qW, m);
newAve += qW * nQueued;
Time now = Simulator::Now ();

4
src/traffic-control/model/traffic-control-layer.cc
View File

@@ -106,7 +106,7 @@ TrafficControlLayer::DoInitialize (void)
// set the wake callbacks on netdevice queues
if (ndi->second.m_rootQueueDisc->GetWakeMode () == QueueDisc::WAKE_ROOT)
{
for (uint32_t i = 0; i < devQueueIface->GetNTxQueues (); i++)
for (uint8_t i = 0; i < devQueueIface->GetNTxQueues (); i++)
{
devQueueIface->GetTxQueue (i)->SetWakeCallback (MakeCallback (&QueueDisc::Run, ndi->second.m_rootQueueDisc));
ndi->second.m_queueDiscsToWake.push_back (ndi->second.m_rootQueueDisc);
@@ -116,7 +116,7 @@ TrafficControlLayer::DoInitialize (void)
{
NS_ASSERT_MSG (ndi->second.m_rootQueueDisc->GetNQueueDiscClasses () == devQueueIface->GetNTxQueues (),
"The number of child queue discs does not match the number of netdevice queues");
for (uint32_t i = 0; i < devQueueIface->GetNTxQueues (); i++)
for (uint8_t i = 0; i < devQueueIface->GetNTxQueues (); i++)
{
devQueueIface->GetTxQueue (i)->SetWakeCallback (MakeCallback (&QueueDisc::Run,
ndi->second.m_rootQueueDisc->GetQueueDiscClass (i)->GetQueueDisc ()));

9
src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc
View File

@@ -49,9 +49,8 @@ public:
*
* \param p packet
* \param addr address
* \param protocol protocol
*/
AredQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol);
AredQueueDiscTestItem (Ptr<Packet> p, const Address & addr);
virtual ~AredQueueDiscTestItem ();
virtual void AddHeader (void);
virtual bool Mark(void);
@@ -71,8 +70,8 @@ private:
AredQueueDiscTestItem &operator = (const AredQueueDiscTestItem &);
};
AredQueueDiscTestItem::AredQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol)
: QueueDiscItem (p, addr, protocol)
AredQueueDiscTestItem::AredQueueDiscTestItem (Ptr<Packet> p, const Address & addr)
: QueueDiscItem (p, addr, 0)
{
}
@@ -356,7 +355,7 @@ AredQueueDiscTestCase::Enqueue (Ptr<RedQueueDisc> queue, uint32_t size, uint32_t
Address dest;
for (uint32_t i = 0; i < nPkt; i++)
{
queue->Enqueue (Create<AredQueueDiscTestItem> (Create<Packet> (size), dest, 0));
queue->Enqueue (Create<AredQueueDiscTestItem> (Create<Packet> (size), dest));
}
}

43
src/traffic-control/test/codel-queue-disc-test-suite.cc
View File

@@ -45,7 +45,7 @@ static uint16_t _codel_Newton_step (uint32_t count, uint16_t rec_inv_sqrt)
val >>= 2; /* avoid overflow in following multiply */
val = (val * invsqrt) >> (32 - 2 + 1);
return (val >> REC_INV_SQRT_SHIFT_ns3);
return static_cast<uint16_t>(val >> REC_INV_SQRT_SHIFT_ns3);
}
static uint32_t _reciprocal_scale (uint32_t val, uint32_t ep_ro)
@@ -67,9 +67,8 @@ public:
*
* \param p packet
* \param addr address
* \param protocol
*/
CodelQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol);
CodelQueueDiscTestItem (Ptr<Packet> p, const Address & addr);
virtual ~CodelQueueDiscTestItem ();
virtual void AddHeader (void);
virtual bool Mark(void);
@@ -89,8 +88,8 @@ private:
CodelQueueDiscTestItem &operator = (const CodelQueueDiscTestItem &);
};
CodelQueueDiscTestItem::CodelQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol)
: QueueDiscItem (p, addr, protocol)
CodelQueueDiscTestItem::CodelQueueDiscTestItem (Ptr<Packet> p, const Address & addr)
: QueueDiscItem (p, addr, 0)
{
}
@@ -198,17 +197,17 @@ CoDelQueueDiscBasicEnqueueDequeue::DoRun (void)
p6 = Create<Packet> (pktSize);
QueueTestSize (queue, 0 * modeSize, "There should be no packets in queue");
queue->Enqueue (Create<CodelQueueDiscTestItem> (p1, dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p1, dest));
QueueTestSize (queue, 1 * modeSize, "There should be one packet in queue");
queue->Enqueue (Create<CodelQueueDiscTestItem> (p2, dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p2, dest));
QueueTestSize (queue, 2 * modeSize, "There should be two packets in queue");
queue->Enqueue (Create<CodelQueueDiscTestItem> (p3, dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p3, dest));
QueueTestSize (queue, 3 * modeSize, "There should be three packets in queue");
queue->Enqueue (Create<CodelQueueDiscTestItem> (p4, dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p4, dest));
QueueTestSize (queue, 4 * modeSize, "There should be four packets in queue");
queue->Enqueue (Create<CodelQueueDiscTestItem> (p5, dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p5, dest));
QueueTestSize (queue, 5 * modeSize, "There should be five packets in queue");
queue->Enqueue (Create<CodelQueueDiscTestItem> (p6, dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p6, dest));
QueueTestSize (queue, 6 * modeSize, "There should be six packets in queue");
NS_TEST_EXPECT_MSG_EQ (queue->GetStats ().GetNDroppedPackets (CoDelQueueDisc::OVERLIMIT_DROP),
@@ -343,9 +342,9 @@ CoDelQueueDiscBasicOverflow::DoRun (void)
queue->Initialize ();
Enqueue (queue, pktSize, 500);
queue->Enqueue (Create<CodelQueueDiscTestItem> (p1, dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p2, dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p3, dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p1, dest));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p2, dest));
queue->Enqueue (Create<CodelQueueDiscTestItem> (p3, dest));
QueueTestSize (queue, 500 * modeSize, "There should be 500 packets in queue");
NS_TEST_EXPECT_MSG_EQ (queue->GetStats ().GetNDroppedPackets (CoDelQueueDisc::OVERLIMIT_DROP),
@@ -358,7 +357,7 @@ CoDelQueueDiscBasicOverflow::Enqueue (Ptr<CoDelQueueDisc> queue, uint32_t size,
Address dest;
for (uint32_t i = 0; i < nPkt; i++)
{
queue->Enqueue (Create<CodelQueueDiscTestItem> (Create<Packet> (size), dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (Create<Packet> (size), dest));
}
}
@@ -453,12 +452,10 @@ CoDelQueueDiscControlLawTest::DoRun (void)
for (int i = 0; i < 4; ++i)
{
uint32_t ns3Result = queue->ControlLaw (dropNextTestVals[i]);
uint32_t upperBound = ns3Result + 0.02 * ns3Result;
uint32_t lowerBound = ns3Result - 0.02 * ns3Result;
uint32_t linuxResult = _codel_control_law (queue, dropNextTestVals[i]);
NS_TEST_EXPECT_MSG_EQ ((lowerBound < linuxResult || linuxResult < upperBound), true,
"Linux result should stay within 2% of ns-3 result");
uint32_t ns3Result = queue->ControlLaw(dropNextTestVals[i]);
uint32_t linuxResult = _codel_control_law(queue, dropNextTestVals[i]);
NS_TEST_EXPECT_MSG_EQ((0.98 * ns3Result < linuxResult && linuxResult < 1.02 * ns3Result), true,
"Linux result should stay within 2% of ns-3 result");
}
}
@@ -532,6 +529,8 @@ CoDelQueueDiscBasicDrop::CoDelQueueDiscBasicDrop (std::string mode)
void
CoDelQueueDiscBasicDrop::DropNextTracer (uint32_t oldVal, uint32_t newVal)
{
NS_UNUSED(oldVal);
NS_UNUSED(newVal);
m_dropNextCount++;
}
@@ -586,7 +585,7 @@ CoDelQueueDiscBasicDrop::Enqueue (Ptr<CoDelQueueDisc> queue, uint32_t size, uint
Address dest;
for (uint32_t i = 0; i < nPkt; i++)
{
queue->Enqueue (Create<CodelQueueDiscTestItem> (Create<Packet> (size), dest, 0));
queue->Enqueue (Create<CodelQueueDiscTestItem> (Create<Packet> (size), dest));
}
}

25
src/traffic-control/test/pie-queue-disc-test-suite.cc
View File

@@ -46,9 +46,8 @@ public:
*
* \param p the packet
* \param addr the address
* \param protocol the protocol
*/
PieQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol);
PieQueueDiscTestItem (Ptr<Packet> p, const Address & addr);
virtual ~PieQueueDiscTestItem ();
virtual void AddHeader (void);
virtual bool Mark (void);
@@ -68,8 +67,8 @@ private:
PieQueueDiscTestItem &operator = (const PieQueueDiscTestItem &);
};
PieQueueDiscTestItem::PieQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol)
: QueueDiscItem (p, addr, protocol)
PieQueueDiscTestItem::PieQueueDiscTestItem (Ptr<Packet> p, const Address & addr)
: QueueDiscItem (p, addr, 0)
{
}
@@ -180,16 +179,16 @@ PieQueueDiscTestCase::RunPieTest (StringValue mode)
queue->Initialize ();
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 0 * modeSize, "There should be no packets in there");
queue->Enqueue (Create<PieQueueDiscTestItem> (p1, dest, 0));
queue->Enqueue (Create<PieQueueDiscTestItem> (p1, dest));
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 1 * modeSize, "There should be one packet in there");
queue->Enqueue (Create<PieQueueDiscTestItem> (p2, dest, 0));
queue->Enqueue (Create<PieQueueDiscTestItem> (p2, dest));
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 2 * modeSize, "There should be two packets in there");
queue->Enqueue (Create<PieQueueDiscTestItem> (p3, dest, 0));
queue->Enqueue (Create<PieQueueDiscTestItem> (p4, dest, 0));
queue->Enqueue (Create<PieQueueDiscTestItem> (p5, dest, 0));
queue->Enqueue (Create<PieQueueDiscTestItem> (p6, dest, 0));
queue->Enqueue (Create<PieQueueDiscTestItem> (p7, dest, 0));
queue->Enqueue (Create<PieQueueDiscTestItem> (p8, dest, 0));
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->GetQueueSize (), 8 * modeSize, "There should be eight packets in there");
Ptr<QueueDiscItem> item;
@@ -350,7 +349,7 @@ PieQueueDiscTestCase::Enqueue (Ptr<PieQueueDisc> queue, uint32_t size, uint32_t
Address dest;
for (uint32_t i = 0; i < nPkt; i++)
{
queue->Enqueue (Create<PieQueueDiscTestItem> (Create<Packet> (size), dest, 0));
queue->Enqueue (Create<PieQueueDiscTestItem> (Create<Packet> (size), dest));
}
}

25
src/traffic-control/test/red-queue-disc-test-suite.cc
View File

@@ -44,10 +44,9 @@ public:
*
* \param p packet
* \param addr address
* \param protocol protocol
* \param ecnCapable ECN capable flag
*/
RedQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol, bool ecnCapable);
RedQueueDiscTestItem (Ptr<Packet> p, const Address & addr, bool ecnCapable);
virtual ~RedQueueDiscTestItem ();
virtual void AddHeader (void);
virtual bool Mark(void);
@@ -68,8 +67,8 @@ private:
bool m_ecnCapablePacket; ///< ECN capable packet?
};
RedQueueDiscTestItem::RedQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol, bool ecnCapable)
: QueueDiscItem (p, addr, protocol),
RedQueueDiscTestItem::RedQueueDiscTestItem (Ptr<Packet> p, const Address & addr, bool ecnCapable)
: QueueDiscItem (p, addr, 0),
m_ecnCapablePacket (ecnCapable)
{
}
@@ -171,16 +170,16 @@ RedQueueDiscTestCase::RunRedTest (StringValue mode)
queue->Initialize ();
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 0 * modeSize, "There should be no packets in there");
queue->Enqueue (Create<RedQueueDiscTestItem> (p1, dest, 0, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p1, dest, false));
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 1 * modeSize, "There should be one packet in there");
queue->Enqueue (Create<RedQueueDiscTestItem> (p2, dest, 0, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p2, dest, false));
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 2 * modeSize, "There should be two packets in there");
queue->Enqueue (Create<RedQueueDiscTestItem> (p3, dest, 0, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p4, dest, 0, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p5, dest, 0, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p6, dest, 0, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p7, dest, 0, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p8, dest, 0, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p3, dest, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p4, dest, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p5, dest, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p6, dest, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p7, dest, false));
queue->Enqueue (Create<RedQueueDiscTestItem> (p8, dest, false));
NS_TEST_EXPECT_MSG_EQ (queue->GetQueueSize (), 8 * modeSize, "There should be eight packets in there");
Ptr<QueueDiscItem> item;
@@ -529,7 +528,7 @@ RedQueueDiscTestCase::Enqueue (Ptr<RedQueueDisc> queue, uint32_t size, uint32_t
Address dest;
for (uint32_t i = 0; i < nPkt; i++)
{
queue->Enqueue (Create<RedQueueDiscTestItem> (Create<Packet> (size), dest, 0, ecnCapable));
queue->Enqueue (Create<RedQueueDiscTestItem> (Create<Packet> (size), dest, ecnCapable));
}
}