A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
test-lte-epc-e2e-data.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Nicola Baldo <nbaldo@cttc.es>
7 */
8
9#include "ns3/abort.h"
10#include "ns3/boolean.h"
11#include "ns3/double.h"
12#include "ns3/inet-socket-address.h"
13#include "ns3/internet-stack-helper.h"
14#include "ns3/ipv4-address-helper.h"
15#include "ns3/log.h"
16#include "ns3/lte-helper.h"
17#include "ns3/mobility-helper.h"
18#include "ns3/packet-sink-helper.h"
19#include "ns3/packet-sink.h"
20#include "ns3/point-to-point-epc-helper.h"
21#include "ns3/point-to-point-helper.h"
22#include "ns3/simulator.h"
23#include "ns3/test.h"
24#include "ns3/udp-client-server-helper.h"
25#include "ns3/udp-echo-helper.h"
26#include "ns3/uinteger.h"
27#include <ns3/ipv4-static-routing-helper.h>
28#include <ns3/ipv4-static-routing.h>
29
30using namespace ns3;
31
32NS_LOG_COMPONENT_DEFINE("LteEpcE2eData");
33
34/**
35 * @ingroup lte-test
36 */
37
38/// BearerTestData structure
40{
41 /**
42 * Constructor
43 *
44 * @param n the number of packets
45 * @param s the packet size
46 * @param i the inter packet interval in seconds
47 */
48 BearerTestData(uint32_t n, uint32_t s, double i);
49
50 uint32_t numPkts; ///< the number of packets
51 uint32_t pktSize; ///< the packet size
52 Time interPacketInterval; ///< the inter packet interval time
53
54 Ptr<PacketSink> dlServerApp; ///< the DL server app
55 Ptr<Application> dlClientApp; ///< the DL client app
56
57 Ptr<PacketSink> ulServerApp; ///< the UL server app
58 Ptr<Application> ulClientApp; ///< the UL client app
59};
60
62 : numPkts(n),
63 pktSize(s),
64 interPacketInterval(Seconds(i))
65{
66}
67
68/// UeTestData structure
70{
71 std::vector<BearerTestData> bearers; ///< the bearer test data
72};
73
74/// EnbTestData structure
76{
77 std::vector<UeTestData> ues; ///< the list of UEs
78};
79
80/**
81 * @ingroup lte-test
82 *
83 * @brief Test that e2e packet flow is correct. Compares the data send and the
84 * data received. Test uses mostly the PDCP stats to check the performance.
85 */
86
88{
89 public:
90 /**
91 * Constructor
92 *
93 * @param name the reference name
94 * @param v the ENB test data
95 */
96 LteEpcE2eDataTestCase(std::string name, std::vector<EnbTestData> v);
97 ~LteEpcE2eDataTestCase() override;
98
99 private:
100 void DoRun() override;
101 std::vector<EnbTestData> m_enbTestData; ///< the ENB test data
102};
103
104LteEpcE2eDataTestCase::LteEpcE2eDataTestCase(std::string name, std::vector<EnbTestData> v)
105 : TestCase(name),
106 m_enbTestData(v)
107{
108 NS_LOG_FUNCTION(this << name);
109}
110
114
115void
117{
118 NS_LOG_FUNCTION(this << GetName());
120 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
121 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
122 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
123
124 Config::SetDefault("ns3::RadioBearerStatsCalculator::DlPdcpOutputFilename",
125 StringValue(CreateTempDirFilename("DlPdcpStats.txt")));
126 Config::SetDefault("ns3::RadioBearerStatsCalculator::UlPdcpOutputFilename",
127 StringValue(CreateTempDirFilename("UlPdcpStats.txt")));
128
131 lteHelper->SetEpcHelper(epcHelper);
132
133 lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisPropagationLossModel"));
134
135 // allow jumbo frames on the S1-U link
136 epcHelper->SetAttribute("S1uLinkMtu", UintegerValue(30000));
137
138 Ptr<Node> pgw = epcHelper->GetPgwNode();
139
140 // Create a single RemoteHost
141 NodeContainer remoteHostContainer;
142 remoteHostContainer.Create(1);
143 Ptr<Node> remoteHost = remoteHostContainer.Get(0);
144 InternetStackHelper internet;
145 internet.Install(remoteHostContainer);
146
147 // Create the internet
149 p2ph.SetDeviceAttribute("DataRate", DataRateValue(DataRate("100Gb/s")));
150 p2ph.SetDeviceAttribute("Mtu", UintegerValue(30000)); // jumbo frames here as well
151 p2ph.SetChannelAttribute("Delay", TimeValue(Seconds(0.010)));
152 NetDeviceContainer internetDevices = p2ph.Install(pgw, remoteHost);
153 Ipv4AddressHelper ipv4h;
154 ipv4h.SetBase("1.0.0.0", "255.0.0.0");
155 Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign(internetDevices);
156 Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress(1);
157
158 // setup default gateway for the remote hosts
159 Ipv4StaticRoutingHelper ipv4RoutingHelper;
160 Ptr<Ipv4StaticRouting> remoteHostStaticRouting =
161 ipv4RoutingHelper.GetStaticRouting(remoteHost->GetObject<Ipv4>());
162
163 // hardcoded UE addresses for now
164 remoteHostStaticRouting->AddNetworkRouteTo(Ipv4Address("7.0.0.0"),
165 Ipv4Mask("255.255.255.0"),
166 1);
167
168 NodeContainer enbs;
169 enbs.Create(m_enbTestData.size());
170 MobilityHelper enbMobility;
171 enbMobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
172 enbMobility.SetPositionAllocator("ns3::GridPositionAllocator",
173 "MinX",
174 DoubleValue(0.0),
175 "MinY",
176 DoubleValue(0.0),
177 "DeltaX",
178 DoubleValue(10000.0),
179 "DeltaY",
180 DoubleValue(10000.0),
181 "GridWidth",
182 UintegerValue(3),
183 "LayoutType",
184 StringValue("RowFirst"));
185 enbMobility.Install(enbs);
186 NetDeviceContainer enbLteDevs = lteHelper->InstallEnbDevice(enbs);
187 auto enbLteDevIt = enbLteDevs.Begin();
188
189 uint16_t ulPort = 1000;
190
191 for (auto enbit = m_enbTestData.begin(); enbit < m_enbTestData.end(); ++enbit, ++enbLteDevIt)
192 {
193 NS_ABORT_IF(enbLteDevIt == enbLteDevs.End());
194
195 NodeContainer ues;
196 ues.Create(enbit->ues.size());
197 Vector enbPosition = (*enbLteDevIt)->GetNode()->GetObject<MobilityModel>()->GetPosition();
198 MobilityHelper ueMobility;
199 ueMobility.SetPositionAllocator("ns3::UniformDiscPositionAllocator",
200 "X",
201 DoubleValue(enbPosition.x),
202 "Y",
203 DoubleValue(enbPosition.y),
204 "rho",
205 DoubleValue(100.0));
206 ueMobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
207 ueMobility.Install(ues);
208 NetDeviceContainer ueLteDevs = lteHelper->InstallUeDevice(ues);
209
210 // we install the IP stack on the UEs
211 InternetStackHelper internet;
212 internet.Install(ues);
213
214 // assign IP address to UEs, and install applications
215 for (uint32_t u = 0; u < ues.GetN(); ++u)
216 {
217 Ptr<Node> ue = ues.Get(u);
218 Ptr<NetDevice> ueLteDevice = ueLteDevs.Get(u);
219 Ipv4InterfaceContainer ueIpIface =
220 epcHelper->AssignUeIpv4Address(NetDeviceContainer(ueLteDevice));
221 // set the default gateway for the UE
222 Ptr<Ipv4StaticRouting> ueStaticRouting =
223 ipv4RoutingHelper.GetStaticRouting(ue->GetObject<Ipv4>());
224 ueStaticRouting->SetDefaultRoute(epcHelper->GetUeDefaultGatewayAddress(), 1);
225
226 // we can now attach the UE, which will also activate the default EPS bearer
227 lteHelper->Attach(ueLteDevice, *enbLteDevIt);
228
229 uint16_t dlPort = 2000;
230 for (uint32_t b = 0; b < enbit->ues.at(u).bearers.size(); ++b)
231 {
232 BearerTestData& bearerTestData = enbit->ues.at(u).bearers.at(b);
233
234 { // Downlink
235 ++dlPort;
236 PacketSinkHelper packetSinkHelper(
237 "ns3::UdpSocketFactory",
239 ApplicationContainer apps = packetSinkHelper.Install(ue);
240 apps.Start(Seconds(0.04));
241 bearerTestData.dlServerApp = apps.Get(0)->GetObject<PacketSink>();
242
243 UdpEchoClientHelper client(ueIpIface.GetAddress(0), dlPort);
244 client.SetAttribute("MaxPackets", UintegerValue(bearerTestData.numPkts));
245 client.SetAttribute("Interval", TimeValue(bearerTestData.interPacketInterval));
246 client.SetAttribute("PacketSize", UintegerValue(bearerTestData.pktSize));
247 apps = client.Install(remoteHost);
248 apps.Start(Seconds(0.04));
249 bearerTestData.dlClientApp = apps.Get(0);
250 }
251
252 { // Uplink
253 ++ulPort;
254 PacketSinkHelper packetSinkHelper(
255 "ns3::UdpSocketFactory",
257 ApplicationContainer apps = packetSinkHelper.Install(remoteHost);
258 apps.Start(Seconds(0.8));
259 bearerTestData.ulServerApp = apps.Get(0)->GetObject<PacketSink>();
260
261 UdpEchoClientHelper client(remoteHostAddr, ulPort);
262 client.SetAttribute("MaxPackets", UintegerValue(bearerTestData.numPkts));
263 client.SetAttribute("Interval", TimeValue(bearerTestData.interPacketInterval));
264 client.SetAttribute("PacketSize", UintegerValue(bearerTestData.pktSize));
265 apps = client.Install(ue);
266 apps.Start(Seconds(0.8));
267 bearerTestData.ulClientApp = apps.Get(0);
268 }
269
271
274 dlpf.localPortStart = dlPort;
275 dlpf.localPortEnd = dlPort;
276 tft->Add(dlpf);
278 ulpf.remotePortStart = ulPort;
279 ulpf.remotePortEnd = ulPort;
280 tft->Add(ulpf);
281
282 // all data will go over the dedicated bearer instead of the default EPS bearer
283 lteHelper->ActivateDedicatedEpsBearer(ueLteDevice, epsBearer, tft);
284 }
285 }
286 }
287
289 "/NodeList/*/DeviceList/*/LteEnbRrc/UeMap/*/RadioBearerMap/*/LteRlc/MaxTxBufferSize",
290 UintegerValue(2 * 1024 * 1024));
291 Config::Set("/NodeList/*/DeviceList/*/LteUeRrc/RadioBearerMap/*/LteRlc/MaxTxBufferSize",
292 UintegerValue(2 * 1024 * 1024));
293
294 double statsStartTime = 0.040; // need to allow for RRC connection establishment + SRS
295 double statsDuration = 2.0;
296
297 lteHelper->EnablePdcpTraces();
298
299 lteHelper->GetPdcpStats()->SetAttribute("StartTime", TimeValue(Seconds(statsStartTime)));
300 lteHelper->GetPdcpStats()->SetAttribute("EpochDuration", TimeValue(Seconds(statsDuration)));
301
302 Simulator::Stop(Seconds(statsStartTime + statsDuration - 0.0001));
304
305 uint64_t imsiCounter = 0;
306
307 for (auto enbit = m_enbTestData.begin(); enbit < m_enbTestData.end(); ++enbit)
308 {
309 for (auto ueit = enbit->ues.begin(); ueit < enbit->ues.end(); ++ueit)
310 {
311 uint64_t imsi = ++imsiCounter;
312 for (uint32_t b = 0; b < ueit->bearers.size(); ++b)
313 {
314 // LCID 0, 1, 2 are for SRBs
315 // LCID 3 is (at the moment) the Default EPS bearer, and is unused in this test
316 // program
317 uint8_t lcid = b + 4;
318 uint32_t expectedPkts = ueit->bearers.at(b).numPkts;
319 uint32_t expectedBytes =
320 (ueit->bearers.at(b).numPkts) * (ueit->bearers.at(b).pktSize);
321 uint32_t txPktsPdcpDl = lteHelper->GetPdcpStats()->GetDlTxPackets(imsi, lcid);
322 uint32_t rxPktsPdcpDl = lteHelper->GetPdcpStats()->GetDlRxPackets(imsi, lcid);
323 uint32_t txPktsPdcpUl = lteHelper->GetPdcpStats()->GetUlTxPackets(imsi, lcid);
324 uint32_t rxPktsPdcpUl = lteHelper->GetPdcpStats()->GetUlRxPackets(imsi, lcid);
325 uint32_t rxBytesDl = ueit->bearers.at(b).dlServerApp->GetTotalRx();
326 uint32_t rxBytesUl = ueit->bearers.at(b).ulServerApp->GetTotalRx();
327
328 NS_TEST_ASSERT_MSG_EQ(txPktsPdcpDl,
329 expectedPkts,
330 "wrong TX PDCP packets in downlink for IMSI="
331 << imsi << " LCID=" << (uint16_t)lcid);
332
333 NS_TEST_ASSERT_MSG_EQ(rxPktsPdcpDl,
334 expectedPkts,
335 "wrong RX PDCP packets in downlink for IMSI="
336 << imsi << " LCID=" << (uint16_t)lcid);
337 NS_TEST_ASSERT_MSG_EQ(txPktsPdcpUl,
338 expectedPkts,
339 "wrong TX PDCP packets in uplink for IMSI="
340 << imsi << " LCID=" << (uint16_t)lcid);
341 NS_TEST_ASSERT_MSG_EQ(rxPktsPdcpUl,
342 expectedPkts,
343 "wrong RX PDCP packets in uplink for IMSI="
344 << imsi << " LCID=" << (uint16_t)lcid);
345
346 NS_TEST_ASSERT_MSG_EQ(rxBytesDl,
347 expectedBytes,
348 "wrong total received bytes in downlink");
349 NS_TEST_ASSERT_MSG_EQ(rxBytesUl,
350 expectedBytes,
351 "wrong total received bytes in uplink");
352 }
353 }
354 }
355
357}
358
359/**
360 * @ingroup lte-test
361 *
362 * @brief Test that the S1-U interface implementation works correctly
363 */
365{
366 public:
368
369} g_lteEpcE2eDataTestSuite; ///< the test suite
370
372 : TestSuite("lte-epc-e2e-data", Type::SYSTEM)
373{
374 std::vector<EnbTestData> v1;
375 EnbTestData e1;
376 UeTestData u1;
377 BearerTestData f1(1, 100, 0.01);
378 u1.bearers.push_back(f1);
379 e1.ues.push_back(u1);
380 v1.push_back(e1);
381 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE", v1), TestCase::Duration::QUICK);
382
383 std::vector<EnbTestData> v2;
384 EnbTestData e2;
385 UeTestData u2_1;
386 BearerTestData f2_1(1, 100, 0.01);
387 u2_1.bearers.push_back(f2_1);
388 e2.ues.push_back(u2_1);
389 UeTestData u2_2;
390 BearerTestData f2_2(2, 200, 0.01);
391 u2_2.bearers.push_back(f2_2);
392 e2.ues.push_back(u2_2);
393 v2.push_back(e2);
394 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 2UEs", v2), TestCase::Duration::EXTENSIVE);
395
396 std::vector<EnbTestData> v3;
397 v3.push_back(e1);
398 v3.push_back(e2);
399 AddTestCase(new LteEpcE2eDataTestCase("2 eNBs", v3), TestCase::Duration::EXTENSIVE);
400
401 EnbTestData e4;
402 UeTestData u4_1;
403 BearerTestData f4_1(3, 50, 0.01);
404 u4_1.bearers.push_back(f4_1);
405 e4.ues.push_back(u4_1);
406 UeTestData u4_2;
407 BearerTestData f4_2(5, 1400, 0.01);
408 u4_2.bearers.push_back(f4_2);
409 e4.ues.push_back(u4_2);
410 UeTestData u4_3;
411 BearerTestData f4_3(1, 12, 0.01);
412 u4_3.bearers.push_back(f4_3);
413 e4.ues.push_back(u4_3);
414 std::vector<EnbTestData> v4;
415 v4.push_back(e4);
416 v4.push_back(e1);
417 v4.push_back(e2);
418 AddTestCase(new LteEpcE2eDataTestCase("3 eNBs", v4), TestCase::Duration::EXTENSIVE);
419
420 EnbTestData e5;
421 UeTestData u5;
422 BearerTestData f5(5, 1000, 0.01);
423 u5.bearers.push_back(f5);
424 e5.ues.push_back(u5);
425 std::vector<EnbTestData> v5;
426 v5.push_back(e5);
427 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with 1000 byte packets", v5),
428 TestCase::Duration::EXTENSIVE);
429
430 EnbTestData e6;
431 UeTestData u6;
432 BearerTestData f6(5, 1400, 0.01);
433 u6.bearers.push_back(f6);
434 e6.ues.push_back(u6);
435 std::vector<EnbTestData> v6;
436 v6.push_back(e6);
437 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with 1400 byte packets", v6),
438 TestCase::Duration::EXTENSIVE);
439
440 EnbTestData e7;
441 UeTestData u7;
442 BearerTestData f7_1(1, 1400, 0.01);
443 u7.bearers.push_back(f7_1);
444 BearerTestData f7_2(1, 100, 0.01);
445 u7.bearers.push_back(f7_2);
446 e7.ues.push_back(u7);
447 std::vector<EnbTestData> v7;
448 v7.push_back(e7);
449 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with 2 bearers", v7),
450 TestCase::Duration::EXTENSIVE);
451
452 EnbTestData e8;
453 UeTestData u8;
454 BearerTestData f8(50, 8000, 0.02); // watch out for ns3::LteRlcUm::MaxTxBufferSize
455 u8.bearers.push_back(f8);
456 e8.ues.push_back(u8);
457 std::vector<EnbTestData> v8;
458 v8.push_back(e8);
459 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with fragmentation", v8),
460 TestCase::Duration::EXTENSIVE);
461
462 EnbTestData e9;
463 UeTestData u9;
464 BearerTestData f9(1000, 20, 0.0001);
465 u9.bearers.push_back(f9);
466 e9.ues.push_back(u9);
467 std::vector<EnbTestData> v9;
468 v9.push_back(e9);
469 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with aggregation", v9),
470 TestCase::Duration::EXTENSIVE);
471}
Test that e2e packet flow is correct.
LteEpcE2eDataTestCase(std::string name, std::vector< EnbTestData > v)
Constructor.
void DoRun() override
Implementation to actually run this TestCase.
std::vector< EnbTestData > m_enbTestData
the ENB test data
Test that the S1-U interface implementation works correctly.
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.
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
AttributeValue implementation for Boolean.
Definition boolean.h:26
Class for representing data rates.
Definition data-rate.h:78
AttributeValue implementation for DataRate.
Definition data-rate.h:285
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition double.h:31
This class contains the specification of EPS Bearers.
Definition eps-bearer.h:80
@ NGBR_VOICE_VIDEO_GAMING
Non-GBR Voice, Video, Interactive Streaming.
Definition eps-bearer.h:112
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.
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Ipv4 addresses are stored in host order in this class.
static Ipv4Address GetAny()
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition ipv4.h:69
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
a class to represent an Ipv4 address mask
Helper class that adds ns3::Ipv4StaticRouting objects.
Ptr< Ipv4StaticRouting > GetStaticRouting(Ptr< Ipv4 > ipv4) const
Try and find the static routing protocol as either the main routing protocol or in the list of routin...
Helper class used to assign positions and mobility models to nodes.
void Install(Ptr< Node > node) const
"Layout" a single node according to the current position allocator type.
void SetMobilityModel(std::string type, Ts &&... args)
void SetPositionAllocator(Ptr< PositionAllocator > allocator)
Set the position allocator which will be used to allocate the initial position of every node initiali...
Keep track of the current position and velocity of an object.
holds a vector of ns3::NetDevice pointers
Iterator Begin() const
Get an iterator which refers to the first NetDevice in the container.
Iterator End() const
Get an iterator which indicates past-the-last NetDevice in the container.
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.
uint32_t GetN() const
Get the number of Ptr<Node> stored in this container.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
Receive and consume traffic generated to an IP address and port.
Definition packet-sink.h:62
Build a set of PointToPointNetDevice objects.
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
void SetChannelAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each Channel created by the helper.
NetDeviceContainer Install(NodeContainer c)
Smart pointer class similar to boost::intrusive_ptr.
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:131
static void Run()
Run the simulation.
Definition simulator.cc:167
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition simulator.cc:175
Hold variables of type string.
Definition string.h:45
encapsulates test code
Definition test.h:1050
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition test.cc:292
std::string CreateTempDirFilename(std::string filename)
Construct the full path to a file in a temporary directory.
Definition test.cc:432
std::string GetName() const
Definition test.cc:367
A suite of tests to run.
Definition test.h:1267
Type
Type of test.
Definition test.h:1274
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
AttributeValue implementation for Time.
Definition nstime.h:1431
Create an application which sends a UDP packet and waits for an echo of this packet.
Hold an unsigned integer type.
Definition uinteger.h:34
void Reset()
Reset the initial value of every attribute as well as the value of every global to what they were bef...
Definition config.cc:848
void SetDefault(std::string name, const AttributeValue &value)
Definition config.cc:883
void Set(std::string path, const AttributeValue &value)
Definition config.cc:869
#define NS_ABORT_IF(cond)
Abnormal program termination if a condition is true.
Definition abort.h:65
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
LteEpcE2eDataTestSuite g_lteEpcE2eDataTestSuite
the test suite
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition ptr.h:436
#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:134
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1344
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Time interPacketInterval
the inter packet interval time
uint32_t numPkts
the number of packets
uint32_t pktSize
the packet size
BearerTestData(uint32_t n, uint32_t s, double i)
Constructor.
Ptr< PacketSink > dlServerApp
the DL server app
Ptr< Application > ulClientApp
the UL client app
Ptr< PacketSink > ulServerApp
the UL server app
Ptr< Application > dlClientApp
the DL client app
EnbTestData structure.
std::vector< UeTestData > ues
the list of UEs
UeTestData structure.
std::vector< BearerTestData > bearers
the bearer test data
Implement the data structure representing a TrafficFlowTemplate Packet Filter.
Definition epc-tft.h:60
uint16_t localPortEnd
end of the port number range of the UE
Definition epc-tft.h:121
uint16_t remotePortEnd
end of the port number range of the remote host
Definition epc-tft.h:119
uint16_t remotePortStart
start of the port number range of the remote host
Definition epc-tft.h:118
uint16_t localPortStart
start of the port number range of the UE
Definition epc-tft.h:120
uint32_t pktSize
packet size used for the simulation (in bytes)