A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
tbf-queue-disc-test-suite.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2017 Kungliga Tekniska Högskolan
3 * 2017 Universita' degli Studi di Napoli Federico II
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation;
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * Authors: Surya Seetharaman <suryaseetharaman.9@gmail.com>
19 * Stefano Avallone <stavallo@unina.it>
20 */
21
22#include "ns3/config.h"
23#include "ns3/double.h"
24#include "ns3/log.h"
25#include "ns3/node-container.h"
26#include "ns3/packet.h"
27#include "ns3/simple-channel.h"
28#include "ns3/simple-net-device.h"
29#include "ns3/simulator.h"
30#include "ns3/string.h"
31#include "ns3/tbf-queue-disc.h"
32#include "ns3/test.h"
33#include "ns3/traffic-control-layer.h"
34#include "ns3/uinteger.h"
35
36using namespace ns3;
37
38/**
39 * \ingroup traffic-control-test
40 *
41 * \brief Tbf Queue Disc Test Item
42 */
43class TbfQueueDiscTestItem : public QueueDiscItem
44{
45 public:
46 /**
47 * Constructor
48 *
49 * \param p the packet
50 * \param addr the address
51 */
52 TbfQueueDiscTestItem(Ptr<Packet> p, const Address& addr);
53 ~TbfQueueDiscTestItem() override;
54
55 // Delete default constructor, copy constructor and assignment operator to avoid misuse
56 TbfQueueDiscTestItem() = delete;
57 TbfQueueDiscTestItem(const TbfQueueDiscTestItem&) = delete;
58 TbfQueueDiscTestItem& operator=(const TbfQueueDiscTestItem&) = delete;
59
60 void AddHeader() override;
61 bool Mark() override;
62};
63
64TbfQueueDiscTestItem::TbfQueueDiscTestItem(Ptr<Packet> p, const Address& addr)
65 : QueueDiscItem(p, addr, 0)
66{
67}
68
69TbfQueueDiscTestItem::~TbfQueueDiscTestItem()
70{
71}
72
73void
74TbfQueueDiscTestItem::AddHeader()
75{
76}
77
78bool
79TbfQueueDiscTestItem::Mark()
80{
81 return false;
82}
83
84/**
85 * \ingroup traffic-control-test
86 *
87 * \brief Tbf Queue Disc Test Case
88 */
89class TbfQueueDiscTestCase : public TestCase
90{
91 public:
92 TbfQueueDiscTestCase();
93 void DoRun() override;
94
95 private:
96 /**
97 * Enqueue function
98 * \param queue the queue disc into which enqueue needs to be done
99 * \param dest the destination address
100 * \param size the size of the packet in bytes to be enqueued
101 */
102 void Enqueue(Ptr<TbfQueueDisc> queue, Address dest, uint32_t size);
103 /**
104 * DequeueAndCheck function to check if a packet is blocked or not after dequeuing and verify
105 * against expected result
106 * \param queue the queue disc on which DequeueAndCheck needs to be done
107 * \param flag the boolean value against which the return value of dequeue ()
108 * has to be compared with
109 * \param printStatement the string to be printed in the NS_TEST_EXPECT_MSG_EQ
110 */
111 void DequeueAndCheck(Ptr<TbfQueueDisc> queue, bool flag, std::string printStatement);
112 /**
113 * Run TBF test function
114 * \param mode the mode
115 */
116 void RunTbfTest(QueueSizeUnit mode);
117};
118
119TbfQueueDiscTestCase::TbfQueueDiscTestCase()
120 : TestCase("Sanity check on the TBF queue implementation")
121{
122}
123
124void
125TbfQueueDiscTestCase::RunTbfTest(QueueSizeUnit mode)
126{
127 uint32_t pktSize = 1500;
128 // 1 for packets; pktSize for bytes
129 uint32_t modeSize = 1;
130 uint32_t qSize = 4;
131 uint32_t burst = 6000;
132 uint32_t mtu = 0;
133 DataRate rate = DataRate("6KB/s");
134 DataRate peakRate = DataRate("0KB/s");
135
136 Ptr<TbfQueueDisc> queue = CreateObject<TbfQueueDisc>();
137
138 // test 1: Simple Enqueue/Dequeue with verification of attribute setting
139 /* 1. There is no second bucket since "peakRate" is set to 0.
140 2. A simple enqueue of five packets, each containing 1500B is followed by
141 the dequeue those five packets.
142 3. The subtraction of tokens from the first bucket to send out each of the
143 five packets is monitored and verified.
144 Note : The number of tokens in the first bucket is full at the beginning.
145 With the dequeuing of each packet, the number of tokens keeps decreasing.
146 So packets are dequeued as long as there are enough tokens in the bucket. */
147
148 if (mode == QueueSizeUnit::BYTES)
149 {
150 modeSize = pktSize;
151 qSize = qSize * modeSize;
152 }
153
154 NS_TEST_ASSERT_MSG_EQ(
155 queue->SetAttributeFailSafe("MaxSize", QueueSizeValue(QueueSize(mode, qSize))),
156 true,
157 "Verify that we can actually set the attribute MaxSize");
158 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Burst", UintegerValue(burst)),
159 true,
160 "Verify that we can actually set the attribute Burst");
161 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Mtu", UintegerValue(mtu)),
162 true,
163 "Verify that we can actually set the attribute Mtu");
164 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Rate", DataRateValue(rate)),
165 true,
166 "Verify that we can actually set the attribute Rate");
167 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("PeakRate", DataRateValue(peakRate)),
168 true,
169 "Verify that we can actually set the attribute PeakRate");
170
171 Address dest;
172
173 Ptr<Packet> p1;
174 Ptr<Packet> p2;
175 Ptr<Packet> p3;
176 Ptr<Packet> p4;
177 Ptr<Packet> p5;
178 p1 = Create<Packet>(pktSize);
179 p2 = Create<Packet>(pktSize);
180 p3 = Create<Packet>(pktSize);
181 p4 = Create<Packet>(pktSize);
182 p5 = Create<Packet>(pktSize);
183
184 queue->Initialize();
185 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
186 0 * modeSize,
187 "There should be no packets in there");
188 queue->Enqueue(Create<TbfQueueDiscTestItem>(p1, dest));
189 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
190 1 * modeSize,
191 "There should be one packet in there");
192 queue->Enqueue(Create<TbfQueueDiscTestItem>(p2, dest));
193 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
194 2 * modeSize,
195 "There should be two packets in there");
196 queue->Enqueue(Create<TbfQueueDiscTestItem>(p3, dest));
197 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
198 3 * modeSize,
199 "There should be three packets in there");
200 queue->Enqueue(Create<TbfQueueDiscTestItem>(p4, dest));
201 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
202 4 * modeSize,
203 "There should be four packets in there");
204 queue->Enqueue(Create<TbfQueueDiscTestItem>(p5, dest));
205 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
206 4 * modeSize,
207 "There should still be four packets in there as this enqueue cannot "
208 "happen since QueueLimit will be exceeded");
209
210 Ptr<QueueDiscItem> item;
211 NS_TEST_ASSERT_MSG_EQ(queue->GetFirstBucketTokens(),
212 burst,
213 "The first token bucket should be full");
214 item = queue->Dequeue();
215 NS_TEST_ASSERT_MSG_NE(item, nullptr, "I want to remove the first packet");
216 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
217 3 * modeSize,
218 "There should be three packets in there");
219 NS_TEST_ASSERT_MSG_EQ(item->GetPacket()->GetUid(), p1->GetUid(), "was this the first packet ?");
220 NS_TEST_ASSERT_MSG_EQ(queue->GetFirstBucketTokens(),
221 burst - (1 * pktSize),
222 "The number of tokens in the first bucket should be one pktSize lesser");
223
224 item = queue->Dequeue();
225 NS_TEST_ASSERT_MSG_NE(item, nullptr, "I want to remove the second packet");
226 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
227 2 * modeSize,
228 "There should be two packets in there");
229 NS_TEST_ASSERT_MSG_EQ(item->GetPacket()->GetUid(),
230 p2->GetUid(),
231 "Was this the second packet ?");
232 NS_TEST_ASSERT_MSG_EQ(queue->GetFirstBucketTokens(),
233 burst - (2 * pktSize),
234 "The number of tokens in the first bucket should be two pktSizes lesser");
235
236 item = queue->Dequeue();
237 NS_TEST_ASSERT_MSG_NE(item, nullptr, "I want to remove the third packet");
238 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
239 1 * modeSize,
240 "There should be one packet in there");
241 NS_TEST_ASSERT_MSG_EQ(item->GetPacket()->GetUid(), p3->GetUid(), "Was this the third packet ?");
242 NS_TEST_ASSERT_MSG_EQ(
243 queue->GetFirstBucketTokens(),
244 burst - (3 * pktSize),
245 "The number of tokens in the first bucket should be three pktSizes lesser");
246
247 item = queue->Dequeue();
248 NS_TEST_ASSERT_MSG_NE(item, nullptr, "I want to remove the fourth packet");
249 NS_TEST_ASSERT_MSG_EQ(queue->GetCurrentSize().GetValue(),
250 0 * modeSize,
251 "There should be zero packet in there");
252 NS_TEST_ASSERT_MSG_EQ(item->GetPacket()->GetUid(),
253 p4->GetUid(),
254 "Was this the fourth packet ?");
255 NS_TEST_ASSERT_MSG_EQ(
256 queue->GetFirstBucketTokens(),
257 burst - (4 * pktSize),
258 "The number of tokens in the first bucket should be four pktSizes lesser");
259
260 // test 2 : When DataRate == FirstBucketTokenRate; packets should pass smoothly.
261 queue = CreateObject<TbfQueueDisc>();
262 qSize = 10;
263 pktSize = 1000;
264 burst = 10000;
265 mtu = 1000;
266 rate = DataRate("10KB/s");
267 peakRate = DataRate("100KB/s");
268 uint32_t nPkt = qSize;
269
270 if (mode == QueueSizeUnit::BYTES)
271 {
272 modeSize = pktSize;
273 qSize = qSize * modeSize;
274 }
275
276 NS_TEST_ASSERT_MSG_EQ(
277 queue->SetAttributeFailSafe("MaxSize", QueueSizeValue(QueueSize(mode, qSize))),
278 true,
279 "Verify that we can actually set the attribute MaxSize");
280 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Burst", UintegerValue(burst)),
281 true,
282 "Verify that we can actually set the attribute Burst");
283 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Mtu", UintegerValue(mtu)),
284 true,
285 "Verify that we can actually set the attribute Mtu");
286 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Rate", DataRateValue(rate)),
287 true,
288 "Verify that we can actually set the attribute Rate");
289 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("PeakRate", DataRateValue(peakRate)),
290 true,
291 "Verify that we can actually set the attribute PeakRate");
292
293 queue->Initialize();
294 double delay = 0.09;
295 for (uint32_t i = 1; i <= nPkt; i++)
296 {
297 Simulator::Schedule(Time(Seconds((i + 1) * delay)),
298 &TbfQueueDiscTestCase::Enqueue,
299 this,
300 queue,
301 dest,
302 pktSize);
303 }
304 delay = 0.1;
305 for (uint32_t i = 1; i <= nPkt; i++)
306 {
307 Simulator::Schedule(Time(Seconds((i + 1) * delay)),
308 &TbfQueueDiscTestCase::DequeueAndCheck,
309 this,
310 queue,
311 true,
312 "No packet should be blocked");
313 }
314 Simulator::Stop(Seconds(1));
315 Simulator::Run();
316
317 // test 3 : When DataRate >>> FirstBucketTokenRate; some packets should get blocked and waking
318 // of queue should get scheduled.
319 /* 10 packets are enqueued and then dequeued. Since the token rate is less than the data rate,
320 the last packet i.e the 10th packet gets blocked and waking of queue is scheduled after a
321 time when enough tokens will be available. At that time the 10th packet passes through. */
322 queue = CreateObject<TbfQueueDisc>();
323
324 Config::SetDefault("ns3::QueueDisc::Quota", UintegerValue(1));
325 NodeContainer nodesA;
326 nodesA.Create(2);
327 Ptr<SimpleNetDevice> txDevA = CreateObject<SimpleNetDevice>();
328 nodesA.Get(0)->AddDevice(txDevA);
329 Ptr<SimpleNetDevice> rxDevA = CreateObject<SimpleNetDevice>();
330 nodesA.Get(1)->AddDevice(rxDevA);
331 Ptr<SimpleChannel> channelA = CreateObject<SimpleChannel>();
332 txDevA->SetChannel(channelA);
333 rxDevA->SetChannel(channelA);
334 txDevA->SetNode(nodesA.Get(0));
335 rxDevA->SetNode(nodesA.Get(1));
336
337 dest = txDevA->GetAddress();
338
339 Ptr<TrafficControlLayer> tcA = CreateObject<TrafficControlLayer>();
340 nodesA.Get(0)->AggregateObject(tcA);
341 tcA->SetRootQueueDiscOnDevice(txDevA, queue);
342 tcA->Initialize();
343
344 burst = 5000;
345 mtu = 1000;
346 rate = DataRate("5KB/s");
347 peakRate = DataRate("100KB/s");
348
349 if (mode == QueueSizeUnit::BYTES)
350 {
351 modeSize = pktSize;
352 qSize = qSize * modeSize;
353 }
354
355 NS_TEST_ASSERT_MSG_EQ(
356 queue->SetAttributeFailSafe("MaxSize", QueueSizeValue(QueueSize(mode, qSize))),
357 true,
358 "Verify that we can actually set the attribute MaxSize");
359 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Burst", UintegerValue(burst)),
360 true,
361 "Verify that we can actually set the attribute Burst");
362 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Mtu", UintegerValue(mtu)),
363 true,
364 "Verify that we can actually set the attribute Mtu");
365 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Rate", DataRateValue(rate)),
366 true,
367 "Verify that we can actually set the attribute Rate");
368 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("PeakRate", DataRateValue(peakRate)),
369 true,
370 "Verify that we can actually set the attribute PeakRate");
371
372 delay = 0.09;
373 for (uint32_t i = 1; i <= nPkt; i++)
374 {
375 Simulator::Schedule(Time(Seconds((i + 1) * delay)),
376 &TbfQueueDiscTestCase::Enqueue,
377 this,
378 queue,
379 dest,
380 pktSize);
381 }
382 delay = 0.1;
383 for (uint32_t i = 1; i <= nPkt; i++)
384 {
385 if (i == 10)
386 {
387 Simulator::Schedule(Time(Seconds((i + 1) * delay)),
388 &TbfQueueDiscTestCase::DequeueAndCheck,
389 this,
390 queue,
391 false,
392 "10th packet should be blocked");
393 }
394 else
395 {
396 Simulator::Schedule(Time(Seconds((i + 1) * delay)),
397 &TbfQueueDiscTestCase::DequeueAndCheck,
398 this,
399 queue,
400 true,
401 "This packet should not be blocked");
402 }
403 }
404 Simulator::Stop(Seconds(1.3));
405 Simulator::Run();
406
407 // test 4 : This test checks the peakRate control of packet dequeue, when DataRate <
408 // FirstBucketTokenRate.
409 /* 10 packets each of size 1000 bytes are enqueued followed by
410 their dequeue. The data rate (25 KB/s) is not sufficiently higher than the btokens rate (15
411 KB/s), so that in the startup phase the first bucket is not empty. Hence when adequate tokens
412 are present in the second (peak) bucket, the packets get transmitted, otherwise they are
413 blocked. So basically the transmission of packets falls under the regulation of the second
414 bucket since first bucket will always have excess tokens. TBF does not let all the packets go
415 smoothly without any control just because there are excess tokens in the first bucket. */
416 queue = CreateObject<TbfQueueDisc>();
417
418 Config::SetDefault("ns3::QueueDisc::Quota", UintegerValue(1));
419 NodeContainer nodesB;
420 nodesB.Create(2);
421 Ptr<SimpleNetDevice> txDevB = CreateObject<SimpleNetDevice>();
422 nodesB.Get(0)->AddDevice(txDevB);
423 Ptr<SimpleNetDevice> rxDevB = CreateObject<SimpleNetDevice>();
424 nodesB.Get(1)->AddDevice(rxDevB);
425 Ptr<SimpleChannel> channelB = CreateObject<SimpleChannel>();
426 txDevB->SetChannel(channelB);
427 rxDevB->SetChannel(channelB);
428 txDevB->SetNode(nodesB.Get(0));
429 rxDevB->SetNode(nodesB.Get(1));
430
431 dest = txDevB->GetAddress();
432
433 Ptr<TrafficControlLayer> tcB = CreateObject<TrafficControlLayer>();
434 nodesB.Get(0)->AggregateObject(tcB);
435 tcB->SetRootQueueDiscOnDevice(txDevB, queue);
436 tcB->Initialize();
437
438 burst = 15000;
439 mtu = 1000;
440 pktSize = 1000;
441 rate = DataRate("15KB/s");
442 peakRate = DataRate("20KB/s");
443
444 if (mode == QueueSizeUnit::BYTES)
445 {
446 modeSize = pktSize;
447 qSize = qSize * modeSize;
448 }
449
450 NS_TEST_ASSERT_MSG_EQ(
451 queue->SetAttributeFailSafe("MaxSize", QueueSizeValue(QueueSize(mode, qSize))),
452 true,
453 "Verify that we can actually set the attribute MaxSize");
454 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Burst", UintegerValue(burst)),
455 true,
456 "Verify that we can actually set the attribute Burst");
457 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Mtu", UintegerValue(mtu)),
458 true,
459 "Verify that we can actually set the attribute Mtu");
460 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("Rate", DataRateValue(rate)),
461 true,
462 "Verify that we can actually set the attribute Rate");
463 NS_TEST_ASSERT_MSG_EQ(queue->SetAttributeFailSafe("PeakRate", DataRateValue(peakRate)),
464 true,
465 "Verify that we can actually set the attribute PeakRate");
466
467 queue->Initialize();
468 delay = 0.04;
469 for (uint32_t i = 1; i <= nPkt; i++)
470 {
471 Simulator::Schedule(Time(Seconds((i + 1) * delay)),
472 &TbfQueueDiscTestCase::Enqueue,
473 this,
474 queue,
475 dest,
476 pktSize);
477 }
478
479 // The pattern being checked is a pattern of dequeue followed by blocked. The delay between
480 // enqueues is not sufficient to allow ptokens to refill before the next dequeue. The first
481 // enqueue is at 1.08s in the future, and the attempted dequeue is at 1.10s in the future. The
482 // first dequeue will always succeed. The second enqueue is 1.12s and attempted dequeue is
483 // at 1.14s in the future, but the last dequeue was 0.04s prior; only 800 tokens can be refilled
484 // in 0.04s at a peak rate of 20Kbps. The actual dequeue occurs at 0.01s further into the
485 // future when ptokens refills to 1000. To repeat the pattern, odd-numbered dequeue events
486 // should be spaced at intervals of at least 100ms, and the even-numbered dequeue events (that
487 // block) should be 0.04s (delay) following the last odd-numbered dequeue event.
488 double nextDelay = (2 * delay) + 0.02; // 20ms after first enqueue to attempt the first dequeue;
489 for (uint32_t i = 1; i <= nPkt; i++)
490 {
491 if (i % 2 == 1)
492 {
493 Simulator::Schedule(Seconds(nextDelay),
494 &TbfQueueDiscTestCase::DequeueAndCheck,
495 this,
496 queue,
497 true,
498 "1st packet should not be blocked");
499 nextDelay += 0.04;
500 }
501 else
502 {
503 Simulator::Schedule(Seconds(nextDelay),
504 &TbfQueueDiscTestCase::DequeueAndCheck,
505 this,
506 queue,
507 false,
508 "This packet should be blocked");
509 nextDelay += 0.06; // Need 0.04 + 0.06 seconds to allow the next packet to be dequeued
510 // without block
511 }
512 }
513 Simulator::Stop(Seconds(0.55));
514 Simulator::Run();
515}
516
517void
518TbfQueueDiscTestCase::Enqueue(Ptr<TbfQueueDisc> queue, Address dest, uint32_t size)
519{
520 queue->Enqueue(Create<TbfQueueDiscTestItem>(Create<Packet>(size), dest));
521}
522
523void
524TbfQueueDiscTestCase::DequeueAndCheck(Ptr<TbfQueueDisc> queue,
525 bool flag,
526 std::string printStatement)
527{
528 Ptr<QueueDiscItem> item = queue->Dequeue();
529 NS_TEST_EXPECT_MSG_EQ((item != nullptr), flag, printStatement);
530}
531
532void
533TbfQueueDiscTestCase::DoRun()
534{
535 RunTbfTest(QueueSizeUnit::PACKETS);
536 RunTbfTest(QueueSizeUnit::BYTES);
537 Simulator::Destroy();
538}
539
540/**
541 * \ingroup traffic-control-test
542 *
543 * \brief Tbf Queue Disc Test Suite
544 */
545static class TbfQueueDiscTestSuite : public TestSuite
546{
547 public:
548 TbfQueueDiscTestSuite()
549 : TestSuite("tbf-queue-disc", Type::UNIT)
550 {
551 AddTestCase(new TbfQueueDiscTestCase(), TestCase::Duration::QUICK);
552 }
553} g_tbfQueueTestSuite; ///< the test suite
TbfQueueDiscTestCase
Tbf Queue Disc Test Case.
Definition: tbf-queue-disc-test-suite.cc:90
TbfQueueDiscTestCase::RunTbfTest
void RunTbfTest(QueueSizeUnit mode)
Run TBF test function.
Definition: tbf-queue-disc-test-suite.cc:125
TbfQueueDiscTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tbf-queue-disc-test-suite.cc:533
TbfQueueDiscTestCase::Enqueue
void Enqueue(Ptr< TbfQueueDisc > queue, Address dest, uint32_t size)
Enqueue function.
Definition: tbf-queue-disc-test-suite.cc:518
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:524
TbfQueueDiscTestItem
Tbf Queue Disc Test Item.
Definition: tbf-queue-disc-test-suite.cc:44
TbfQueueDiscTestItem::TbfQueueDiscTestItem
TbfQueueDiscTestItem()=delete
TbfQueueDiscTestItem::Mark
bool Mark() override
Marks the packet as a substitute for dropping it, such as for Explicit Congestion Notification.
Definition: tbf-queue-disc-test-suite.cc:79
TbfQueueDiscTestItem::TbfQueueDiscTestItem
TbfQueueDiscTestItem(const TbfQueueDiscTestItem &)=delete
TbfQueueDiscTestItem::AddHeader
void AddHeader() override
Add the header to the packet.
Definition: tbf-queue-disc-test-suite.cc:74
TbfQueueDiscTestItem::operator=
TbfQueueDiscTestItem & operator=(const TbfQueueDiscTestItem &)=delete
TbfQueueDiscTestSuite
Tbf Queue Disc Test Suite.
Definition: tbf-queue-disc-test-suite.cc:546
ns3::Address
a polymophic address class
Definition: address.h:101
ns3::DataRate
Class for representing data rates.
Definition: data-rate.h:89
ns3::DataRateValue
AttributeValue implementation for DataRate.
Definition: data-rate.h:296
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:40
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:84
ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Definition: node-container.cc:78
ns3::Node::AddDevice
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:135
ns3::Object::AggregateObject
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:309
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:77
ns3::QueueDiscItem
QueueDiscItem is the abstract base class for items that are stored in a queue disc.
Definition: queue-item.h:133
ns3::QueueSize
Class for representing queue sizes.
Definition: queue-size.h:96
ns3::QueueSizeValue
AttributeValue implementation for QueueSize.
Definition: queue-size.h:221
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:571
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:142
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition: simulator.cc:178
ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:186
ns3::TestCase
encapsulates test code
Definition: test.h:1061
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:301
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1268
ns3::TestSuite::Type
Type
Type of test.
Definition: test.h:1275
ns3::TestSuite::UNIT
static constexpr auto UNIT
Definition: test.h:1286
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:45
uint32_t
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:894
ns3::QueueSizeUnit
QueueSizeUnit
Enumeration of the operating modes of queues.
Definition: queue-size.h:44
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:145
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:252
NS_TEST_ASSERT_MSG_NE
#define NS_TEST_ASSERT_MSG_NE(actual, limit, msg)
Test that an actual and expected (limit) value are not equal and report and abort if not.
Definition: test.h:565
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1326
g_tbfQueueTestSuite
TbfQueueDiscTestSuite g_tbfQueueTestSuite
the test suite
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
pktSize
uint32_t pktSize
packet size used for the simulation (in bytes)
Definition: wifi-bianchi.cc:116