A Discrete-Event Network Simulator
API
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 * 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 * Author: Nicola Baldo <nbaldo@cttc.es>
18 */
19
20#include "ns3/abort.h"
21#include "ns3/boolean.h"
22#include "ns3/double.h"
23#include "ns3/inet-socket-address.h"
24#include "ns3/internet-stack-helper.h"
25#include "ns3/ipv4-address-helper.h"
26#include "ns3/log.h"
27#include "ns3/lte-helper.h"
28#include "ns3/mobility-helper.h"
29#include "ns3/packet-sink-helper.h"
30#include "ns3/packet-sink.h"
31#include "ns3/point-to-point-epc-helper.h"
32#include "ns3/point-to-point-helper.h"
33#include "ns3/simulator.h"
34#include "ns3/test.h"
35#include "ns3/udp-client-server-helper.h"
36#include "ns3/udp-echo-helper.h"
37#include "ns3/uinteger.h"
38#include <ns3/ipv4-static-routing-helper.h>
39#include <ns3/ipv4-static-routing.h>
40
41using namespace ns3;
42
43NS_LOG_COMPONENT_DEFINE("LteEpcE2eData");
44
51{
59 BearerTestData(uint32_t n, uint32_t s, double i);
60
64
67
70};
71
73 : numPkts(n),
74 pktSize(s),
75 interPacketInterval(Seconds(i))
76{
77}
78
81{
82 std::vector<BearerTestData> bearers;
83};
84
87{
88 std::vector<UeTestData> ues;
89};
90
99{
100 public:
107 LteEpcE2eDataTestCase(std::string name, std::vector<EnbTestData> v);
108 ~LteEpcE2eDataTestCase() override;
109
110 private:
111 void DoRun() override;
112 std::vector<EnbTestData> m_enbTestData;
113};
114
115LteEpcE2eDataTestCase::LteEpcE2eDataTestCase(std::string name, std::vector<EnbTestData> v)
116 : TestCase(name),
117 m_enbTestData(v)
118{
119 NS_LOG_FUNCTION(this << name);
120}
121
123{
124}
125
126void
128{
129 NS_LOG_FUNCTION(this << GetName());
131 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
132 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
133 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
134
135 Config::SetDefault("ns3::RadioBearerStatsCalculator::DlPdcpOutputFilename",
136 StringValue(CreateTempDirFilename("DlPdcpStats.txt")));
137 Config::SetDefault("ns3::RadioBearerStatsCalculator::UlPdcpOutputFilename",
138 StringValue(CreateTempDirFilename("UlPdcpStats.txt")));
139
140 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
141 Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper>();
142 lteHelper->SetEpcHelper(epcHelper);
143
144 lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisPropagationLossModel"));
145
146 // allow jumbo frames on the S1-U link
147 epcHelper->SetAttribute("S1uLinkMtu", UintegerValue(30000));
148
149 Ptr<Node> pgw = epcHelper->GetPgwNode();
150
151 // Create a single RemoteHost
152 NodeContainer remoteHostContainer;
153 remoteHostContainer.Create(1);
154 Ptr<Node> remoteHost = remoteHostContainer.Get(0);
155 InternetStackHelper internet;
156 internet.Install(remoteHostContainer);
157
158 // Create the internet
160 p2ph.SetDeviceAttribute("DataRate", DataRateValue(DataRate("100Gb/s")));
161 p2ph.SetDeviceAttribute("Mtu", UintegerValue(30000)); // jumbo frames here as well
162 p2ph.SetChannelAttribute("Delay", TimeValue(Seconds(0.010)));
163 NetDeviceContainer internetDevices = p2ph.Install(pgw, remoteHost);
164 Ipv4AddressHelper ipv4h;
165 ipv4h.SetBase("1.0.0.0", "255.0.0.0");
166 Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign(internetDevices);
167 Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress(1);
168
169 // setup default gateway for the remote hosts
170 Ipv4StaticRoutingHelper ipv4RoutingHelper;
171 Ptr<Ipv4StaticRouting> remoteHostStaticRouting =
172 ipv4RoutingHelper.GetStaticRouting(remoteHost->GetObject<Ipv4>());
173
174 // hardcoded UE addresses for now
175 remoteHostStaticRouting->AddNetworkRouteTo(Ipv4Address("7.0.0.0"),
176 Ipv4Mask("255.255.255.0"),
177 1);
178
179 NodeContainer enbs;
180 enbs.Create(m_enbTestData.size());
181 MobilityHelper enbMobility;
182 enbMobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
183 enbMobility.SetPositionAllocator("ns3::GridPositionAllocator",
184 "MinX",
185 DoubleValue(0.0),
186 "MinY",
187 DoubleValue(0.0),
188 "DeltaX",
189 DoubleValue(10000.0),
190 "DeltaY",
191 DoubleValue(10000.0),
192 "GridWidth",
193 UintegerValue(3),
194 "LayoutType",
195 StringValue("RowFirst"));
196 enbMobility.Install(enbs);
197 NetDeviceContainer enbLteDevs = lteHelper->InstallEnbDevice(enbs);
198 NetDeviceContainer::Iterator enbLteDevIt = enbLteDevs.Begin();
199
200 uint16_t ulPort = 1000;
201
202 for (std::vector<EnbTestData>::iterator enbit = m_enbTestData.begin();
203 enbit < m_enbTestData.end();
204 ++enbit, ++enbLteDevIt)
205 {
206 NS_ABORT_IF(enbLteDevIt == enbLteDevs.End());
207
208 NodeContainer ues;
209 ues.Create(enbit->ues.size());
210 Vector enbPosition = (*enbLteDevIt)->GetNode()->GetObject<MobilityModel>()->GetPosition();
211 MobilityHelper ueMobility;
212 ueMobility.SetPositionAllocator("ns3::UniformDiscPositionAllocator",
213 "X",
214 DoubleValue(enbPosition.x),
215 "Y",
216 DoubleValue(enbPosition.y),
217 "rho",
218 DoubleValue(100.0));
219 ueMobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
220 ueMobility.Install(ues);
221 NetDeviceContainer ueLteDevs = lteHelper->InstallUeDevice(ues);
222
223 // we install the IP stack on the UEs
224 InternetStackHelper internet;
225 internet.Install(ues);
226
227 // assign IP address to UEs, and install applications
228 for (uint32_t u = 0; u < ues.GetN(); ++u)
229 {
230 Ptr<Node> ue = ues.Get(u);
231 Ptr<NetDevice> ueLteDevice = ueLteDevs.Get(u);
232 Ipv4InterfaceContainer ueIpIface =
233 epcHelper->AssignUeIpv4Address(NetDeviceContainer(ueLteDevice));
234 // set the default gateway for the UE
235 Ptr<Ipv4StaticRouting> ueStaticRouting =
236 ipv4RoutingHelper.GetStaticRouting(ue->GetObject<Ipv4>());
237 ueStaticRouting->SetDefaultRoute(epcHelper->GetUeDefaultGatewayAddress(), 1);
238
239 // we can now attach the UE, which will also activate the default EPS bearer
240 lteHelper->Attach(ueLteDevice, *enbLteDevIt);
241
242 uint16_t dlPort = 2000;
243 for (uint32_t b = 0; b < enbit->ues.at(u).bearers.size(); ++b)
244 {
245 BearerTestData& bearerTestData = enbit->ues.at(u).bearers.at(b);
246
247 { // Downlink
248 ++dlPort;
249 PacketSinkHelper packetSinkHelper(
250 "ns3::UdpSocketFactory",
251 InetSocketAddress(Ipv4Address::GetAny(), dlPort));
252 ApplicationContainer apps = packetSinkHelper.Install(ue);
253 apps.Start(Seconds(0.04));
254 bearerTestData.dlServerApp = apps.Get(0)->GetObject<PacketSink>();
255
256 UdpEchoClientHelper client(ueIpIface.GetAddress(0), dlPort);
257 client.SetAttribute("MaxPackets", UintegerValue(bearerTestData.numPkts));
258 client.SetAttribute("Interval", TimeValue(bearerTestData.interPacketInterval));
259 client.SetAttribute("PacketSize", UintegerValue(bearerTestData.pktSize));
260 apps = client.Install(remoteHost);
261 apps.Start(Seconds(0.04));
262 bearerTestData.dlClientApp = apps.Get(0);
263 }
264
265 { // Uplink
266 ++ulPort;
267 PacketSinkHelper packetSinkHelper(
268 "ns3::UdpSocketFactory",
269 InetSocketAddress(Ipv4Address::GetAny(), ulPort));
270 ApplicationContainer apps = packetSinkHelper.Install(remoteHost);
271 apps.Start(Seconds(0.8));
272 bearerTestData.ulServerApp = apps.Get(0)->GetObject<PacketSink>();
273
274 UdpEchoClientHelper client(remoteHostAddr, ulPort);
275 client.SetAttribute("MaxPackets", UintegerValue(bearerTestData.numPkts));
276 client.SetAttribute("Interval", TimeValue(bearerTestData.interPacketInterval));
277 client.SetAttribute("PacketSize", UintegerValue(bearerTestData.pktSize));
278 apps = client.Install(ue);
279 apps.Start(Seconds(0.8));
280 bearerTestData.ulClientApp = apps.Get(0);
281 }
282
283 EpsBearer epsBearer(EpsBearer::NGBR_VOICE_VIDEO_GAMING);
284
285 Ptr<EpcTft> tft = Create<EpcTft>();
287 dlpf.localPortStart = dlPort;
288 dlpf.localPortEnd = dlPort;
289 tft->Add(dlpf);
291 ulpf.remotePortStart = ulPort;
292 ulpf.remotePortEnd = ulPort;
293 tft->Add(ulpf);
294
295 // all data will go over the dedicated bearer instead of the default EPS bearer
296 lteHelper->ActivateDedicatedEpsBearer(ueLteDevice, epsBearer, tft);
297 }
298 }
299 }
300
302 "/NodeList/*/DeviceList/*/LteEnbRrc/UeMap/*/RadioBearerMap/*/LteRlc/MaxTxBufferSize",
303 UintegerValue(2 * 1024 * 1024));
304 Config::Set("/NodeList/*/DeviceList/*/LteUeRrc/RadioBearerMap/*/LteRlc/MaxTxBufferSize",
305 UintegerValue(2 * 1024 * 1024));
306
307 double statsStartTime = 0.040; // need to allow for RRC connection establishment + SRS
308 double statsDuration = 2.0;
309
310 lteHelper->EnablePdcpTraces();
311
312 lteHelper->GetPdcpStats()->SetAttribute("StartTime", TimeValue(Seconds(statsStartTime)));
313 lteHelper->GetPdcpStats()->SetAttribute("EpochDuration", TimeValue(Seconds(statsDuration)));
314
315 Simulator::Stop(Seconds(statsStartTime + statsDuration - 0.0001));
316 Simulator::Run();
317
318 uint64_t imsiCounter = 0;
319
320 for (std::vector<EnbTestData>::iterator enbit = m_enbTestData.begin();
321 enbit < m_enbTestData.end();
322 ++enbit)
323 {
324 for (std::vector<UeTestData>::iterator ueit = enbit->ues.begin(); ueit < enbit->ues.end();
325 ++ueit)
326 {
327 uint64_t imsi = ++imsiCounter;
328 for (uint32_t b = 0; b < ueit->bearers.size(); ++b)
329 {
330 // LCID 0, 1, 2 are for SRBs
331 // LCID 3 is (at the moment) the Default EPS bearer, and is unused in this test
332 // program
333 uint8_t lcid = b + 4;
334 uint32_t expectedPkts = ueit->bearers.at(b).numPkts;
335 uint32_t expectedBytes =
336 (ueit->bearers.at(b).numPkts) * (ueit->bearers.at(b).pktSize);
337 uint32_t txPktsPdcpDl = lteHelper->GetPdcpStats()->GetDlTxPackets(imsi, lcid);
338 uint32_t rxPktsPdcpDl = lteHelper->GetPdcpStats()->GetDlRxPackets(imsi, lcid);
339 uint32_t txPktsPdcpUl = lteHelper->GetPdcpStats()->GetUlTxPackets(imsi, lcid);
340 uint32_t rxPktsPdcpUl = lteHelper->GetPdcpStats()->GetUlRxPackets(imsi, lcid);
341 uint32_t rxBytesDl = ueit->bearers.at(b).dlServerApp->GetTotalRx();
342 uint32_t rxBytesUl = ueit->bearers.at(b).ulServerApp->GetTotalRx();
343
344 NS_TEST_ASSERT_MSG_EQ(txPktsPdcpDl,
345 expectedPkts,
346 "wrong TX PDCP packets in downlink for IMSI="
347 << imsi << " LCID=" << (uint16_t)lcid);
348
349 NS_TEST_ASSERT_MSG_EQ(rxPktsPdcpDl,
350 expectedPkts,
351 "wrong RX PDCP packets in downlink for IMSI="
352 << imsi << " LCID=" << (uint16_t)lcid);
353 NS_TEST_ASSERT_MSG_EQ(txPktsPdcpUl,
354 expectedPkts,
355 "wrong TX PDCP packets in uplink for IMSI="
356 << imsi << " LCID=" << (uint16_t)lcid);
357 NS_TEST_ASSERT_MSG_EQ(rxPktsPdcpUl,
358 expectedPkts,
359 "wrong RX PDCP packets in uplink for IMSI="
360 << imsi << " LCID=" << (uint16_t)lcid);
361
362 NS_TEST_ASSERT_MSG_EQ(rxBytesDl,
363 expectedBytes,
364 "wrong total received bytes in downlink");
365 NS_TEST_ASSERT_MSG_EQ(rxBytesUl,
366 expectedBytes,
367 "wrong total received bytes in uplink");
368 }
369 }
370 }
371
372 Simulator::Destroy();
373}
374
381{
382 public:
384
386
388 : TestSuite("lte-epc-e2e-data", SYSTEM)
389{
390 std::vector<EnbTestData> v1;
391 EnbTestData e1;
392 UeTestData u1;
393 BearerTestData f1(1, 100, 0.01);
394 u1.bearers.push_back(f1);
395 e1.ues.push_back(u1);
396 v1.push_back(e1);
397 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE", v1), TestCase::QUICK);
398
399 std::vector<EnbTestData> v2;
400 EnbTestData e2;
401 UeTestData u2_1;
402 BearerTestData f2_1(1, 100, 0.01);
403 u2_1.bearers.push_back(f2_1);
404 e2.ues.push_back(u2_1);
405 UeTestData u2_2;
406 BearerTestData f2_2(2, 200, 0.01);
407 u2_2.bearers.push_back(f2_2);
408 e2.ues.push_back(u2_2);
409 v2.push_back(e2);
410 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 2UEs", v2), TestCase::EXTENSIVE);
411
412 std::vector<EnbTestData> v3;
413 v3.push_back(e1);
414 v3.push_back(e2);
415 AddTestCase(new LteEpcE2eDataTestCase("2 eNBs", v3), TestCase::EXTENSIVE);
416
417 EnbTestData e4;
418 UeTestData u4_1;
419 BearerTestData f4_1(3, 50, 0.01);
420 u4_1.bearers.push_back(f4_1);
421 e4.ues.push_back(u4_1);
422 UeTestData u4_2;
423 BearerTestData f4_2(5, 1400, 0.01);
424 u4_2.bearers.push_back(f4_2);
425 e4.ues.push_back(u4_2);
426 UeTestData u4_3;
427 BearerTestData f4_3(1, 12, 0.01);
428 u4_3.bearers.push_back(f4_3);
429 e4.ues.push_back(u4_3);
430 std::vector<EnbTestData> v4;
431 v4.push_back(e4);
432 v4.push_back(e1);
433 v4.push_back(e2);
434 AddTestCase(new LteEpcE2eDataTestCase("3 eNBs", v4), TestCase::EXTENSIVE);
435
436 EnbTestData e5;
437 UeTestData u5;
438 BearerTestData f5(5, 1000, 0.01);
439 u5.bearers.push_back(f5);
440 e5.ues.push_back(u5);
441 std::vector<EnbTestData> v5;
442 v5.push_back(e5);
443 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with 1000 byte packets", v5),
444 TestCase::EXTENSIVE);
445
446 EnbTestData e6;
447 UeTestData u6;
448 BearerTestData f6(5, 1400, 0.01);
449 u6.bearers.push_back(f6);
450 e6.ues.push_back(u6);
451 std::vector<EnbTestData> v6;
452 v6.push_back(e6);
453 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with 1400 byte packets", v6),
454 TestCase::EXTENSIVE);
455
456 EnbTestData e7;
457 UeTestData u7;
458 BearerTestData f7_1(1, 1400, 0.01);
459 u7.bearers.push_back(f7_1);
460 BearerTestData f7_2(1, 100, 0.01);
461 u7.bearers.push_back(f7_2);
462 e7.ues.push_back(u7);
463 std::vector<EnbTestData> v7;
464 v7.push_back(e7);
465 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with 2 bearers", v7), TestCase::EXTENSIVE);
466
467 EnbTestData e8;
468 UeTestData u8;
469 BearerTestData f8(50, 8000, 0.02); // watch out for ns3::LteRlcUm::MaxTxBufferSize
470 u8.bearers.push_back(f8);
471 e8.ues.push_back(u8);
472 std::vector<EnbTestData> v8;
473 v8.push_back(e8);
474 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with fragmentation", v8),
475 TestCase::EXTENSIVE);
476
477 EnbTestData e9;
478 UeTestData u9;
479 BearerTestData f9(1000, 20, 0.0001);
480 u9.bearers.push_back(f9);
481 e9.ues.push_back(u9);
482 std::vector<EnbTestData> v9;
483 v9.push_back(e9);
484 AddTestCase(new LteEpcE2eDataTestCase("1 eNB, 1UE with aggregation", v9), TestCase::EXTENSIVE);
485}
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.
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
void Start(Time start)
Start all of the Applications in this container at the start time given as a parameter.
AttributeValue implementation for Boolean.
Definition: boolean.h:37
AttributeValue implementation for DataRate.
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
an Inet address class
aggregate IP/TCP/UDP functionality to existing Nodes.
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
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.
Definition: ipv4-address.h:43
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:79
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
Definition: ipv4-address.h:258
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...
void SetEpcHelper(Ptr< EpcHelper > h)
Set the EpcHelper to be used to setup the EPC network in conjunction with the setup of the LTE radio ...
Definition: lte-helper.cc:282
Ptr< RadioBearerStatsCalculator > GetPdcpStats()
Definition: lte-helper.cc:1723
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:482
void EnablePdcpTraces()
Enable trace sinks for PDCP layer.
Definition: lte-helper.cc:1714
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:1044
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:497
uint8_t ActivateDedicatedEpsBearer(NetDeviceContainer ueDevices, EpsBearer bearer, Ptr< EpcTft > tft)
Activate a dedicated EPS bearer on a given set of UE devices.
Definition: lte-helper.cc:1159
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
std::vector< Ptr< NetDevice > >::const_iterator Iterator
NetDevice container iterator.
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.
Ptr< Node > GetPgwNode() const override
Get the PGW node.
Ipv4Address GetUeDefaultGatewayAddress() override
Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices) override
Assign IPv4 addresses to UE devices.
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.
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:200
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
ApplicationContainer Install(NodeContainer c) const
Install an ns3::PacketSinkApplication on each node of the input container configured with all the att...
Receive and consume traffic generated to an IP address and port.
Definition: packet-sink.h:74
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)
Hold variables of type string.
Definition: string.h:56
encapsulates test code
Definition: test.h:1060
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305
std::string CreateTempDirFilename(std::string filename)
Construct the full path to a file in a temporary directory.
Definition: test.cc:442
std::string GetName() const
Definition: test.cc:377
A suite of tests to run.
Definition: test.h:1256
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
AttributeValue implementation for Time.
Definition: nstime.h:1423
Create an application which sends a UDP packet and waits for an echo of this packet.
Hold an unsigned integer type.
Definition: uinteger.h:45
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:856
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:891
void Set(std::string path, const AttributeValue &value)
Definition: config.cc:877
#define NS_ABORT_IF(cond)
Abnormal program termination if a condition is true.
Definition: abort.h:76
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#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
void(* DataRate)(DataRate oldValue, DataRate newValue)
TracedValue callback signature for DataRate.
Definition: data-rate.h:328
#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:144
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336
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:71
uint16_t localPortEnd
end of the port number range of the UE
Definition: epc-tft.h:132
uint16_t remotePortEnd
end of the port number range of the remote host
Definition: epc-tft.h:130
uint16_t remotePortStart
start of the port number range of the remote host
Definition: epc-tft.h:129
uint16_t localPortStart
start of the port number range of the UE
Definition: epc-tft.h:131
uint32_t pktSize
packet size used for the simulation (in bytes)