A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
ns3tcp-loss-test-suite.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2010 University of Washington
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 */
17
19
20#include "ns3/abort.h"
21#include "ns3/config.h"
22#include "ns3/data-rate.h"
23#include "ns3/error-model.h"
24#include "ns3/inet-socket-address.h"
25#include "ns3/internet-stack-helper.h"
26#include "ns3/ipv4-address-helper.h"
27#include "ns3/ipv4-global-routing-helper.h"
28#include "ns3/log.h"
29#include "ns3/node-container.h"
30#include "ns3/packet-sink-helper.h"
31#include "ns3/pcap-file.h"
32#include "ns3/point-to-point-helper.h"
33#include "ns3/pointer.h"
34#include "ns3/simulator.h"
35#include "ns3/string.h"
36#include "ns3/tcp-header.h"
37#include "ns3/tcp-socket-factory.h"
38#include "ns3/tcp-westwood-plus.h"
39#include "ns3/test.h"
40#include "ns3/uinteger.h"
41
42#include <iomanip>
43
44using namespace ns3;
45
46NS_LOG_COMPONENT_DEFINE("Ns3TcpLossTest");
47
48// The below boolean constants should only be changed to 'true'
49// during test debugging (i.e. do not commit the value 'true')
50
51// set to 'true' to have the test suite overwrite the response vectors
52// stored in the test directory. This should only be done if you are
53// convinced through other means (e.g. pcap tracing or logging) that the
54// revised vectors are the correct ones. In other words, don't simply
55// enable this to true to clear a failing test without looking at the
56// results closely.
57const bool WRITE_VECTORS = false;
58const bool WRITE_PCAP = false;
59const bool WRITE_LOGGING = false;
61 1187373557;
63
70{
71 public:
73
80 Ns3TcpLossTestCase(std::string tcpModel, uint32_t testCase);
81
83 {
84 }
85
86 private:
87 void DoSetup() override;
88 void DoRun() override;
89 void DoTeardown() override;
90
92 std::string m_pcapFilename;
101 std::string m_tcpModel;
102
112 void Ipv4L3Tx(std::string context,
113 Ptr<const Packet> packet,
114 Ptr<Ipv4> ipv4,
115 uint32_t interface);
122 void CwndTracer(uint32_t oldval, uint32_t newval);
129 void WriteUntilBufferFull(Ptr<Socket> localSocket, uint32_t txSpace);
137 void StartFlow(Ptr<Socket> localSocket, Ipv4Address servAddress, uint16_t servPort);
138};
139
141 : TestCase("Check the operation of the TCP state machine for several cases"),
142 m_testCase(0),
143 m_totalTxBytes(200000),
144 m_currentTxBytes(0),
145 m_writeVectors(WRITE_VECTORS),
146 m_writeResults(WRITE_PCAP),
147 m_writeLogging(WRITE_LOGGING),
148 m_needToClose(true),
149 m_tcpModel("ns3::TcpWestwoodPlus")
150{
151}
152
154 : TestCase("Check the behaviour of TCP upon packet losses"),
155 m_testCase(testCase),
156 m_totalTxBytes(200000),
157 m_currentTxBytes(0),
158 m_writeVectors(WRITE_VECTORS),
159 m_writeResults(WRITE_PCAP),
160 m_writeLogging(WRITE_LOGGING),
161 m_needToClose(true),
162 m_tcpModel(tcpModel)
163{
164}
165
166void
168{
169 // This test was written before SACK was added to ns-3
170 Config::SetDefault("ns3::TcpSocketBase::Sack", BooleanValue(false));
171 // This test was written with initial window of 1 segment
172 Config::SetDefault("ns3::TcpSocket::InitialCwnd", UintegerValue(1));
173 // This test was written with the TCP Classic Recovery algorithm
174 Config::SetDefault("ns3::TcpL4Protocol::RecoveryType",
176
177 //
178 // We expect there to be a file called ns3tcp-state-response-vectors.pcap in
179 // the data directory
180 //
181 std::ostringstream oss;
182 oss << "ns3tcp-loss-" << m_tcpModel << m_testCase << "-response-vectors.pcap";
184
185 if (m_writeVectors)
186 {
187 m_pcapFile.Open(m_pcapFilename, std::ios::out | std::ios::binary);
189 }
190 else
191 {
192 m_pcapFile.Open(m_pcapFilename, std::ios::in | std::ios::binary);
194 "Wrong response vectors in directory: opening " << m_pcapFilename);
195 }
196}
197
198void
200{
202}
203
204void
206{
207 //
208 // We're not testing IP so remove and toss the header. In order to do this,
209 // though, we need to copy the packet since we have a const version.
210 //
211 Ptr<Packet> received = packet->Copy();
212 Ipv4Header ipHeader;
213 received->RemoveHeader(ipHeader);
214
215 //
216 // What is left is the TCP header and any data that may be sent. We aren't
217 // sending any TCP data, so we expect what remains is only TCP header, which
218 // is a small thing to save.
219 //
220 if (m_writeVectors)
221 {
222 //
223 // Save the TCP under test response for later testing.
224 //
225 Time tNow = Simulator::Now();
226 int64_t tMicroSeconds = tNow.GetMicroSeconds();
227
228 m_pcapFile.Write(uint32_t(tMicroSeconds / 1000000),
229 uint32_t(tMicroSeconds % 1000000),
230 received);
231 }
232 else
233 {
234 //
235 // Read the TCP under test expected response from the expected vector
236 // file and see if it still does the right thing.
237 //
238 uint8_t expectedBuffer[PCAP_SNAPLEN];
239 uint32_t tsSec;
240 uint32_t tsUsec;
241 uint32_t inclLen;
242 uint32_t origLen;
243 uint32_t readLen;
245 .Read(expectedBuffer, sizeof(expectedBuffer), tsSec, tsUsec, inclLen, origLen, readLen);
246
247 NS_LOG_INFO("read " << readLen << " bytes");
248
249 auto actual = new uint8_t[readLen];
250 received->CopyData(actual, readLen);
251
252 int result = memcmp(actual, expectedBuffer, readLen);
253
254 TcpHeader expectedHeader;
255 TcpHeader receivedHeader;
256 Ptr<Packet> expected = Create<Packet>(expectedBuffer, readLen);
257
258 expected->RemoveHeader(expectedHeader);
259 received->RemoveHeader(receivedHeader);
260
261 NS_LOG_DEBUG("Expected " << expectedHeader << " received: " << receivedHeader);
262
263 delete[] actual;
264
265 //
266 // Avoid streams of errors -- only report the first.
267 //
268 if (IsStatusSuccess())
269 {
271 0,
272 "Expected data comparison error: " << m_tcpModel << "-"
273 << m_testCase);
274 }
275 }
276}
277
278void
280{
281 if (m_writeLogging)
282 {
283 *(m_osw->GetStream()) << "Moving cwnd from " << oldval << " to " << newval << " at time "
284 << Simulator::Now().GetSeconds() << " seconds" << std::endl;
285 }
286}
287
289// Implementing an "application" to send bytes over a TCP connection
290void
292{
294 {
296 uint32_t dataOffset = m_currentTxBytes % 1040;
297 uint32_t toWrite = 1040 - dataOffset;
298 uint32_t txAvail = localSocket->GetTxAvailable();
299 toWrite = std::min(toWrite, left);
300 toWrite = std::min(toWrite, txAvail);
301 if (txAvail == 0)
302 {
303 return;
304 }
305 if (m_writeLogging)
306 {
307 std::clog << "Submitting " << toWrite << " bytes to TCP socket" << std::endl;
308 }
309 int amountSent = localSocket->Send(nullptr, toWrite, 0);
310 NS_ASSERT(amountSent > 0); // Given GetTxAvailable() non-zero, amountSent should not be zero
311 m_currentTxBytes += amountSent;
312 }
313 if (m_needToClose)
314 {
315 if (m_writeLogging)
316 {
317 std::clog << "Close socket at " << Simulator::Now().GetSeconds() << std::endl;
318 }
319 localSocket->Close();
320 m_needToClose = false;
321 }
322}
323
324void
325Ns3TcpLossTestCase::StartFlow(Ptr<Socket> localSocket, Ipv4Address servAddress, uint16_t servPort)
326{
327 if (m_writeLogging)
328 {
329 std::clog << "Starting flow at time " << Simulator::Now().GetSeconds() << std::endl;
330 }
331 localSocket->Connect(InetSocketAddress(servAddress, servPort)); // connect
332
333 // tell the tcp implementation to call WriteUntilBufferFull again
334 // if we blocked and new tx buffer space becomes available
335 localSocket->SetSendCallback(MakeCallback(&Ns3TcpLossTestCase::WriteUntilBufferFull, this));
336 WriteUntilBufferFull(localSocket, localSocket->GetTxAvailable());
337}
338
339void
341{
342 // Network topology
343 //
344 // 8Mb/s, 0.1ms 0.8Mb/s, 100ms
345 // s1-----------------r1-----------------k1
346 //
347 // Example corresponding to simulations in the paper "Simulation-based
348 // Comparisons of Tahoe, Reno, and SACK TCP
349
350 Config::SetDefault("ns3::TcpSocketBase::Sack", BooleanValue(false));
351
352 std::ostringstream tcpModel;
353 tcpModel << "ns3::Tcp" << m_tcpModel;
354 Config::SetDefault("ns3::TcpL4Protocol::SocketType", StringValue(tcpModel.str()));
355
356 Config::SetDefault("ns3::TcpSocket::SegmentSize", UintegerValue(1000));
357 Config::SetDefault("ns3::TcpSocket::DelAckCount", UintegerValue(1));
358 Config::SetDefault("ns3::TcpSocketBase::Timestamp", BooleanValue(false));
359
360 if (m_writeLogging)
361 {
363 LogComponentEnable("Ns3TcpLossTest", LOG_LEVEL_ALL);
364 LogComponentEnable("ErrorModel", LOG_LEVEL_DEBUG);
365 LogComponentEnable("TcpWestwoodPlus", LOG_LEVEL_ALL);
366 LogComponentEnable("TcpCongestionOps", LOG_LEVEL_INFO);
367 LogComponentEnable("TcpSocketBase", LOG_LEVEL_INFO);
368 }
369
371 // Topology construction
372 //
373
374 // Create three nodes: s1, r1, and k1
375 NodeContainer s1r1;
376 s1r1.Create(2);
377
378 NodeContainer r1k1;
379 r1k1.Add(s1r1.Get(1));
380 r1k1.Create(1);
381
382 // Set up TCP/IP stack to all nodes (and create loopback device at device 0)
383 InternetStackHelper internet;
384 internet.InstallAll();
385
386 // Connect the nodes
388 p2p.SetDeviceAttribute("DataRate", DataRateValue(DataRate(8000000)));
389 p2p.SetChannelAttribute("Delay", TimeValue(Seconds(0.0001)));
390 NetDeviceContainer dev0 = p2p.Install(s1r1);
391 p2p.SetDeviceAttribute("DataRate", DataRateValue(DataRate(800000)));
392 p2p.SetChannelAttribute("Delay", TimeValue(Seconds(0.1)));
393 NetDeviceContainer dev1 = p2p.Install(r1k1);
394
395 // Add IP addresses to each network interfaces
397 ipv4.SetBase("10.1.3.0", "255.255.255.0");
398 ipv4.Assign(dev0);
399 ipv4.SetBase("10.1.2.0", "255.255.255.0");
400 Ipv4InterfaceContainer ipInterfs = ipv4.Assign(dev1);
401
402 // Set up routes to all nodes
404
406 // Send 20000 (totalTxBytes) bytes from node s1 to node k1
407 //
408
409 // Create a packet sink to receive packets on node k1
410 uint16_t servPort = 50000; // Destination port number
411 PacketSinkHelper sink("ns3::TcpSocketFactory",
413 ApplicationContainer apps = sink.Install(r1k1.Get(1));
414 apps.Start(Seconds(0.0));
415 apps.Stop(Seconds(100.0));
416
417 // Create a data source to send packets on node s0.
418 // Instead of full application, here use the socket directly by
419 // registering callbacks in function StarFlow().
421 localSocket->Bind();
423 this,
424 localSocket,
425 ipInterfs.GetAddress(1),
426 servPort);
427
428 Config::Connect("/NodeList/0/$ns3::Ipv4L3Protocol/Tx",
430
431 Config::ConnectWithoutContext("/NodeList/0/$ns3::TcpL4Protocol/SocketList/0/CongestionWindow",
433
435 // Set up loss model at node k1
436 //
437 std::list<uint32_t> sampleList;
438 switch (m_testCase)
439 {
440 case 0:
441 break;
442 case 1:
443 // Force a loss for 15th data packet. TCP cwnd will be at 14 segments
444 // (14000 bytes) when duplicate acknowledgments start to come.
445 sampleList.push_back(16);
446 break;
447 case 2:
448 sampleList.push_back(16);
449 sampleList.push_back(17);
450 break;
451 case 3:
452 sampleList.push_back(16);
453 sampleList.push_back(17);
454 sampleList.push_back(18);
455 break;
456 case 4:
457 sampleList.push_back(16);
458 sampleList.push_back(17);
459 sampleList.push_back(18);
460 sampleList.push_back(19);
461 break;
462 default:
463 NS_FATAL_ERROR("Program fatal error: loss value " << m_testCase << " not supported.");
464 break;
465 }
466
467 Ptr<ReceiveListErrorModel> pem = CreateObject<ReceiveListErrorModel>();
468 pem->SetList(sampleList);
469 dev1.Get(1)->SetAttribute("ReceiveErrorModel", PointerValue(pem));
470
471 // One can toggle the comment for the following line on or off to see the
472 // effects of finite send buffer modelling. One can also change the size of
473 // that buffer.
474 // localSocket->SetAttribute("SndBufSize", UintegerValue(4096));
475
476 std::ostringstream oss;
477 oss << "tcp-loss-" << m_tcpModel << m_testCase << "-test-case";
478 if (m_writeResults)
479 {
480 p2p.EnablePcapAll(oss.str());
481 p2p.EnableAsciiAll(oss.str());
482 }
483
484 std::ostringstream oss2;
485 oss2 << "src/test/ns3tcp/Tcp" << m_tcpModel << "." << m_testCase << ".log";
486 AsciiTraceHelper ascii;
487 if (m_writeLogging)
488 {
489 m_osw = ascii.CreateFileStream(oss2.str());
490 *(m_osw->GetStream()) << std::setprecision(9) << std::fixed;
491 p2p.EnableAsciiAll(m_osw);
492 }
493
494 // Finally, set up the simulator to run. The 1000 second hard limit is a
495 // failsafe in case some change above causes the simulation to never end
499}
500
507{
508 public:
510};
511
513 : TestSuite("ns3-tcp-loss", Type::SYSTEM)
514{
515 // We can't use NS_TEST_SOURCEDIR variable here because we use subdirectories
516 SetDataDir("src/test/ns3tcp/response-vectors");
517 Packet::EnablePrinting(); // Enable packet metadata for all test cases
518
519 AddTestCase(new Ns3TcpLossTestCase("NewReno", 0), TestCase::Duration::QUICK);
520 AddTestCase(new Ns3TcpLossTestCase("NewReno", 1), TestCase::Duration::QUICK);
521 AddTestCase(new Ns3TcpLossTestCase("NewReno", 2), TestCase::Duration::QUICK);
522 AddTestCase(new Ns3TcpLossTestCase("NewReno", 3), TestCase::Duration::QUICK);
523 AddTestCase(new Ns3TcpLossTestCase("NewReno", 4), TestCase::Duration::QUICK);
524
525 AddTestCase(new Ns3TcpLossTestCase("WestwoodPlus", 0), TestCase::Duration::QUICK);
526 AddTestCase(new Ns3TcpLossTestCase("WestwoodPlus", 1), TestCase::Duration::QUICK);
527 AddTestCase(new Ns3TcpLossTestCase("WestwoodPlus", 2), TestCase::Duration::QUICK);
528 AddTestCase(new Ns3TcpLossTestCase("WestwoodPlus", 3), TestCase::Duration::QUICK);
529 AddTestCase(new Ns3TcpLossTestCase("WestwoodPlus", 4), TestCase::Duration::QUICK);
530}
531
Tests of TCP implementation loss behavior.
void CwndTracer(uint32_t oldval, uint32_t newval)
CWND trace.
void DoSetup() override
Implementation to do any local setup required for this TestCase.
void DoRun() override
Implementation to actually run this TestCase.
uint32_t m_currentTxBytes
Current number of bytes sent.
void StartFlow(Ptr< Socket > localSocket, Ipv4Address servAddress, uint16_t servPort)
Start transmitting a TCP flow.
PcapFile m_pcapFile
The PCAP ffile.
bool m_writeVectors
True if response vectors have to be written (and not read).
uint32_t m_testCase
Testcase number.
Ptr< OutputStreamWrapper > m_osw
The output stream.
bool m_writeResults
True if write PCAP files.
bool m_writeLogging
True if write logging.
uint32_t m_totalTxBytes
Total number of bytes to send.
void WriteUntilBufferFull(Ptr< Socket > localSocket, uint32_t txSpace)
Write to the socket until the buffer is full.
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
std::string m_pcapFilename
The PCAP filename.
void Ipv4L3Tx(std::string context, Ptr< const Packet > packet, Ptr< Ipv4 > ipv4, uint32_t interface)
Check that the transmitted packets are consistent with the trace.
std::string m_tcpModel
The TCP model name.
bool m_needToClose
Check if the sending socket need to be closed.
TCP implementation loss behavior TestSuite.
holds a vector of ns3::Application pointers.
void Start(Time start) const
Start all of the Applications in this container at the start time given as a parameter.
void Stop(Time stop) const
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
Manage ASCII trace files for device models.
Definition: trace-helper.h:174
Ptr< OutputStreamWrapper > CreateFileStream(std::string filename, std::ios::openmode filemode=std::ios::out)
Create and initialize an output stream object we'll use to write the traced bits.
AttributeValue implementation for Boolean.
Definition: boolean.h:37
Class for representing data rates.
Definition: data-rate.h:89
AttributeValue implementation for DataRate.
Definition: data-rate.h:296
an Inet address class
aggregate IP/TCP/UDP functionality to existing Nodes.
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:42
static Ipv4Address GetAny()
static void PopulateRoutingTables()
Build a routing database and initialize the routing tables of the nodes in the simulation.
Packet header for IPv4.
Definition: ipv4-header.h:34
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
holds a vector of ns3::NetDevice pointers
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
keep track of a set of node pointers.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
void Add(const NodeContainer &nc)
Append the contents of another NodeContainer to the end of this container.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
std::ostream * GetStream()
Return a pointer to an ostream previously set in the wrapper.
static void EnablePrinting()
Enable printing packets metadata.
Definition: packet.cc:596
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
A class representing a pcap file.
Definition: pcap-file.h:43
void Close()
Close the underlying file.
Definition: pcap-file.cc:92
void Open(const std::string &filename, std::ios::openmode mode)
Create a new pcap file or open an existing pcap file.
Definition: pcap-file.cc:331
uint32_t GetDataLinkType()
Returns the data link type field of the pcap file as defined by the network field in the pcap global ...
Definition: pcap-file.cc:141
void Read(uint8_t *const data, uint32_t maxBytes, uint32_t &tsSec, uint32_t &tsUsec, uint32_t &inclLen, uint32_t &origLen, uint32_t &readLen)
Read next packet from file.
Definition: pcap-file.cc:479
void Init(uint32_t dataLinkType, uint32_t snapLen=SNAPLEN_DEFAULT, int32_t timeZoneCorrection=ZONE_DEFAULT, bool swapMode=false, bool nanosecMode=false)
Initialize the pcap file associated with this object.
Definition: pcap-file.cc:351
void Write(uint32_t tsSec, uint32_t tsUsec, const uint8_t *const data, uint32_t totalLen)
Write next packet to file.
Definition: pcap-file.cc:444
Build a set of PointToPointNetDevice objects.
AttributeValue implementation for Pointer.
Definition: pointer.h:48
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:77
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:142
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:208
static void Run()
Run the simulation.
Definition: simulator.cc:178
static EventId ScheduleNow(FUNC f, Ts &&... args)
Schedule an event to expire Now.
Definition: simulator.h:605
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:186
static Ptr< Socket > CreateSocket(Ptr< Node > node, TypeId tid)
This method wraps the creation of sockets that is performed on a given node by a SocketFactory specif...
Definition: socket.cc:72
Hold variables of type string.
Definition: string.h:56
static TypeId GetTypeId()
Get the type ID.
Header for the Transmission Control Protocol.
Definition: tcp-header.h:47
static TypeId GetTypeId()
Get the type ID.
encapsulates test code
Definition: test.h:1061
std::string CreateDataDirFilename(std::string filename)
Construct the full path to a file in the data directory.
Definition: test.cc:419
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:301
bool IsStatusSuccess() const
Check if all tests passed.
Definition: test.cc:471
void SetDataDir(std::string directory)
Set the data directory where reference trace files can be found.
Definition: test.cc:478
A suite of tests to run.
Definition: test.h:1268
Type
Type of test.
Definition: test.h:1275
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:403
int64_t GetMicroSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:413
AttributeValue implementation for Time.
Definition: nstime.h:1413
a unique identifier for an interface.
Definition: type-id.h:59
AttributeValue implementation for TypeId.
Definition: type-id.h:598
Hold an unsigned integer type.
Definition: uinteger.h:45
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:894
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:978
void ConnectWithoutContext(std::string path, const CallbackBase &cb)
Definition: config.cc:954
#define NS_ABORT_MSG_UNLESS(cond, msg)
Abnormal program termination if a condition is false, with a message.
Definition: abort.h:144
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:179
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
#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
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1326
Every class exported by the ns3 library is enclosed in the ns3 namespace.
void LogComponentEnable(const std::string &name, LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:302
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:704
@ LOG_LEVEL_ALL
Print everything.
Definition: log.h:116
@ LOG_PREFIX_FUNC
Prefix all trace prints with function.
Definition: log.h:118
@ LOG_LEVEL_DEBUG
LOG_DEBUG and above.
Definition: log.h:113
@ LOG_LEVEL_INFO
LOG_INFO and above.
Definition: log.h:104
void LogComponentEnableAll(LogLevel level)
Enable the logging output for all registered log components.
Definition: log.cc:320
const uint32_t PCAP_LINK_TYPE
Some large random number – we use to verify data was written by this program.
const bool WRITE_VECTORS
Set to true to write response vectors.
const bool WRITE_PCAP
Set to true to write out pcap.
static Ns3TcpLossTestSuite g_ns3TcpLossTestSuite
Do not forget to allocate an instance of this TestSuite.
const bool WRITE_LOGGING
Set to true to write logging.
const uint32_t PCAP_SNAPLEN
Don't bother to save much data.
Ptr< PacketSink > sink
Pointer to the packet sink application.
Definition: wifi-tcp.cc:55