A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
test-lte-handover-failure.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2013 Magister Solutions (original test-lte-handover-delay.cc)
3 * Copyright (c) 2021 University of Washington (handover failure cases)
4 *
5 * SPDX-License-Identifier: GPL-2.0-only
6 *
7 * Author: Sachin Nayak <sachinnn@uw.edu>
8 */
9
10#include <ns3/boolean.h>
11#include <ns3/callback.h>
12#include <ns3/config.h>
13#include <ns3/data-rate.h>
14#include <ns3/internet-stack-helper.h>
15#include <ns3/ipv4-address-helper.h>
16#include <ns3/ipv4-interface-container.h>
17#include <ns3/ipv4-static-routing-helper.h>
18#include <ns3/ipv4-static-routing.h>
19#include <ns3/log.h>
20#include <ns3/lte-helper.h>
21#include <ns3/lte-ue-net-device.h>
22#include <ns3/mobility-helper.h>
23#include <ns3/net-device-container.h>
24#include <ns3/node-container.h>
25#include <ns3/nstime.h>
26#include <ns3/point-to-point-epc-helper.h>
27#include <ns3/point-to-point-helper.h>
28#include <ns3/position-allocator.h>
29#include <ns3/rng-seed-manager.h>
30#include <ns3/simulator.h>
31#include <ns3/test.h>
32
33using namespace ns3;
34
35NS_LOG_COMPONENT_DEFINE("LteHandoverFailureTest");
36
37/**
38 * \ingroup lte-test
39 *
40 * \brief Verifying that a handover failure occurs due to various causes
41 *
42 * Handover failure cases dealt with in this test include the below.
43 *
44 * 1. Handover failure due to max random access channel (RACH) attempts from UE to target eNodeB
45 * 2. Handover failure due to non-allocation of non-contention preamble to UE at target eNodeB
46 * 3. Handover failure due to HANDOVER JOINING timeout (3 cases)
47 * 4. Handover failure due to HANDOVER LEAVING timeout (3 cases)
48 *
49 * \sa ns3::LteHandoverFailureTestCase
50 */
52{
53 public:
54 /**
55 * Constructor
56 *
57 * \param name the name of the test case, to be displayed in the test result
58 * \param useIdealRrc if true, use the ideal RRC
59 * \param handoverTime the time of handover
60 * \param simulationDuration duration of the simulation
61 * \param numberOfRaPreambles number of random access preambles available for contention based
62 RACH process
63 * number of non-contention preambles available for handover = (64 -
64 numberRaPreambles)
65 * as numberOfRaPreambles out of the max 64 are reserved contention
66 based RACH process
67 * \param preambleTransMax maximum number of random access preamble transmissions from UE to
68 eNodeB
69 * \param raResponseWindowSize window length for reception of random access response (RAR)
70 * \param handoverJoiningTimeout time before which RRC RECONFIGURATION COMPLETE must be received
71 at target eNodeB after it receives a handover request
72 Else, the UE context is destroyed in the RRC.
73 Timeout can occur before different stages as below.
74 i. Reception of RRC CONNECTION RECONFIGURATION at source eNodeB
75 ii. Non-contention random access procedure from UE to target
76 eNodeB iii. Reception of RRC CONNECTION RECONFIGURATION COMPLETE at target eNodeB
77 * \param handoverLeavingTimeout time before which source eNodeB must receive a UE context
78 release from target eNodeB or RRC CONNECTION RESTABLISHMENT from UE after issuing a handover
79 request Else, the UE context is destroyed in the RRC. Timeout can occur before any of the cases
80 in HANDOVER JOINING TIMEOUT
81 * \param targeteNodeBPosition position of the target eNodeB
82 */
84 bool useIdealRrc,
85 Time handoverTime,
86 Time simulationDuration,
87 uint8_t numberOfRaPreambles,
88 uint8_t preambleTransMax,
89 uint8_t raResponseWindowSize,
90 Time handoverJoiningTimeout,
91 Time handoverLeavingTimeout,
92 uint16_t targeteNodeBPosition)
93 : TestCase(name),
94 m_useIdealRrc(useIdealRrc),
95 m_handoverTime(handoverTime),
96 m_simulationDuration(simulationDuration),
97 m_numberOfRaPreambles(numberOfRaPreambles),
98 m_preambleTransMax(preambleTransMax),
99 m_raResponseWindowSize(raResponseWindowSize),
100 m_handoverJoiningTimeout(handoverJoiningTimeout),
101 m_handoverLeavingTimeout(handoverLeavingTimeout),
102 m_targeteNodeBPosition(targeteNodeBPosition),
104 {
105 }
106
107 private:
108 /**
109 * \brief Run a simulation of a two eNodeB network using the parameters
110 * provided to the constructor function.
111 */
112 void DoRun() override;
113
114 /**
115 * \brief Called at the end of simulation and verifies that a handover
116 * and a handover failure has occurred in the simulation.
117 */
118 void DoTeardown() override;
119
120 /**
121 * UE handover start callback function to indicate start of handover
122 * \param context the context string
123 * \param imsi the IMSI
124 * \param sourceCellId the source cell ID
125 * \param rnti the RNTI
126 * \param targetCellId the target cell ID
127 */
128 void UeHandoverStartCallback(std::string context,
129 uint64_t imsi,
130 uint16_t sourceCellId,
131 uint16_t rnti,
132 uint16_t targetCellId);
133
134 /**
135 * Handover failure callback due to maximum RACH transmissions reached from UE to target eNodeB
136 * \param context the context string
137 * \param imsi the IMSI
138 * \param rnti the RNTI
139 * \param targetCellId the target cell ID
140 */
141 void HandoverFailureMaxRach(std::string context,
142 uint64_t imsi,
143 uint16_t rnti,
144 uint16_t targetCellId);
145
146 /**
147 * Handover failure callback due to non-allocation of non-contention preamble at target eNodeB
148 * \param context the context string
149 * \param imsi the IMSI
150 * \param rnti the RNTI
151 * \param targetCellId the target cell ID
152 */
153 void HandoverFailureNoPreamble(std::string context,
154 uint64_t imsi,
155 uint16_t rnti,
156 uint16_t targetCellId);
157
158 /**
159 * Handover failure callback due to handover joining timeout at target eNodeB
160 * \param context the context string
161 * \param imsi the IMSI
162 * \param rnti the RNTI
163 * \param targetCellId the target cell ID
164 */
165 void HandoverFailureJoining(std::string context,
166 uint64_t imsi,
167 uint16_t rnti,
168 uint16_t targetCellId);
169
170 /**
171 * Handover failure callback due to handover leaving timeout at source eNodeB
172 * \param context the context string
173 * \param imsi the IMSI
174 * \param rnti the RNTI
175 * \param targetCellId the target cell ID
176 */
177 void HandoverFailureLeaving(std::string context,
178 uint64_t imsi,
179 uint16_t rnti,
180 uint16_t targetCellId);
181
182 bool m_useIdealRrc; ///< use ideal RRC?
183 Time m_handoverTime; ///< handover time
184 Time m_simulationDuration; ///< the simulation duration
185 uint8_t m_numberOfRaPreambles; ///< number of random access preambles for contention based RACH
186 ///< process
187 uint8_t m_preambleTransMax; ///< max number of RACH preambles possible from UE to eNodeB
188 uint8_t m_raResponseWindowSize; ///< window length for reception of RAR
189 Time m_handoverJoiningTimeout; ///< handover joining timeout duration at target eNodeB
190 Time m_handoverLeavingTimeout; ///< handover leaving timeout duration at source eNodeB
191 uint16_t m_targeteNodeBPosition; ///< position of the target eNodeB
192 bool m_hasHandoverFailureOccurred; ///< has handover failure occurred in simulation
193
194}; // end of class LteHandoverFailureTestCase
195
196void
198{
199 NS_LOG_INFO(this << " " << GetName());
200 uint32_t previousSeed = RngSeedManager::GetSeed();
201 uint64_t previousRun = RngSeedManager::GetRun();
204
205 /*
206 * Helpers.
207 */
208 auto epcHelper = CreateObject<PointToPointEpcHelper>();
209
210 auto lteHelper = CreateObject<LteHelper>();
211 lteHelper->SetEpcHelper(epcHelper);
212
213 // Set parameters for helpers based on the test case parameters.
214 lteHelper->SetAttribute("UseIdealRrc", BooleanValue(m_useIdealRrc));
215 Config::SetDefault("ns3::LteEnbMac::NumberOfRaPreambles", UintegerValue(m_numberOfRaPreambles));
216 Config::SetDefault("ns3::LteEnbMac::PreambleTransMax", UintegerValue(m_preambleTransMax));
217 Config::SetDefault("ns3::LteEnbMac::RaResponseWindowSize",
219 Config::SetDefault("ns3::LteEnbRrc::HandoverJoiningTimeoutDuration",
221 Config::SetDefault("ns3::LteEnbRrc::HandoverLeavingTimeoutDuration",
223
224 // Set PHY model to drastically decrease with distance.
225 lteHelper->SetPathlossModelType(TypeId::LookupByName("ns3::LogDistancePropagationLossModel"));
226 lteHelper->SetPathlossModelAttribute("Exponent", DoubleValue(3.5));
227 lteHelper->SetPathlossModelAttribute("ReferenceLoss", DoubleValue(35));
228 /*
229 * Physical layer.
230 *
231 * eNodeB 0 UE eNodeB 1
232 *
233 * x ----------------------- x -------------------------- x
234 * 200 m m_targeteNodeBPosition
235 * source target
236 */
237 // Create nodes.
238 NodeContainer enbNodes;
239 enbNodes.Create(2);
240 auto ueNode = CreateObject<Node>();
241
242 // Setup mobility
243 auto posAlloc = CreateObject<ListPositionAllocator>();
244 posAlloc->Add(Vector(0, 0, 0));
245 posAlloc->Add(Vector(m_targeteNodeBPosition, 0, 0));
246 posAlloc->Add(Vector(200, 0, 0));
247
248 MobilityHelper mobilityHelper;
249 mobilityHelper.SetMobilityModel("ns3::ConstantPositionMobilityModel");
250 mobilityHelper.SetPositionAllocator(posAlloc);
251 mobilityHelper.Install(enbNodes);
252 mobilityHelper.Install(ueNode);
253
254 /*
255 * Link layer.
256 */
257 auto enbDevs = lteHelper->InstallEnbDevice(enbNodes);
258 auto ueDev = lteHelper->InstallUeDevice(ueNode).Get(0);
259 auto castedUeDev = DynamicCast<LteUeNetDevice>(ueDev);
260 // Working value from before we started resetting g_nextStreamIndex. For more details
261 // see https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/2178#note_2143793903
262 castedUeDev->GetPhy()->GetDlSpectrumPhy()->AssignStreams(175);
263
264 /*
265 * Network layer.
266 */
267 InternetStackHelper inetStackHelper;
268 inetStackHelper.Install(ueNode);
270 ueIfs = epcHelper->AssignUeIpv4Address(ueDev);
271
272 // Setup traces.
273 Config::Connect("/NodeList/*/DeviceList/*/LteUeRrc/HandoverStart",
275 Config::Connect("/NodeList/*/DeviceList/*/LteEnbRrc/HandoverFailureMaxRach",
277 Config::Connect("/NodeList/*/DeviceList/*/LteEnbRrc/HandoverFailureNoPreamble",
279 Config::Connect("/NodeList/*/DeviceList/*/LteEnbRrc/HandoverFailureJoining",
281 Config::Connect("/NodeList/*/DeviceList/*/LteEnbRrc/HandoverFailureLeaving",
283
284 // Prepare handover.
285 lteHelper->AddX2Interface(enbNodes);
286 lteHelper->Attach(ueDev, enbDevs.Get(0));
287 lteHelper->HandoverRequest(m_handoverTime, ueDev, enbDevs.Get(0), enbDevs.Get(1));
288
289 // Run simulation.
293
294 RngSeedManager::SetSeed(previousSeed);
295 RngSeedManager::SetRun(previousRun);
296} // end of void LteHandoverFailureTestCase::DoRun ()
297
298void
300 uint64_t imsi,
301 uint16_t sourceCellId,
302 uint16_t rnti,
303 uint16_t targetCellId)
304{
305 NS_LOG_FUNCTION(this << " " << context << " IMSI-" << imsi << " sourceCellID-" << sourceCellId
306 << " RNTI-" << rnti << " targetCellID-" << targetCellId);
307 NS_LOG_INFO("HANDOVER COMMAND received through at UE "
308 << imsi << " to handover from " << sourceCellId << " to " << targetCellId);
309}
310
311void
313 uint64_t imsi,
314 uint16_t rnti,
315 uint16_t targetCellId)
316{
317 NS_LOG_FUNCTION(this << context << imsi << rnti << targetCellId);
319}
320
321void
323 uint64_t imsi,
324 uint16_t rnti,
325 uint16_t targetCellId)
326{
327 NS_LOG_FUNCTION(this << context << imsi << rnti << targetCellId);
329}
330
331void
333 uint64_t imsi,
334 uint16_t rnti,
335 uint16_t targetCellId)
336{
337 NS_LOG_FUNCTION(this << context << imsi << rnti << targetCellId);
339}
340
341void
343 uint64_t imsi,
344 uint16_t rnti,
345 uint16_t targetCellId)
346{
347 NS_LOG_FUNCTION(this << context << imsi << rnti << targetCellId);
349}
350
351void
353{
354 NS_LOG_FUNCTION(this);
355 NS_TEST_ASSERT_MSG_EQ(m_hasHandoverFailureOccurred, true, "Handover failure did not occur");
356}
357
358/**
359 * \ingroup lte-test
360 *
361 * The following log components can be used to debug this test's behavior:
362 * LteHandoverFailureTest:LteEnbRrc:LteEnbMac:LteUeRrc:EpcX2
363 *
364 * \brief Lte Handover Failure Test Suite
365 */
367{
368 public:
370 : TestSuite("lte-handover-failure", Type::SYSTEM)
371 {
372 // Argument sequence for all test cases: useIdealRrc, handoverTime, simulationDuration,
373 // numberOfRaPreambles, preambleTransMax, raResponseWindowSize,
374 // handoverJoiningTimeout, handoverLeavingTimeout
375
376 // Test cases for REAL RRC protocol
377 AddTestCase(new LteHandoverFailureTestCase("REAL Handover failure due to maximum RACH "
378 "transmissions reached from UE to target eNodeB",
379 false,
380 Seconds(0.200),
381 Seconds(0.300),
382 52,
383 3,
384 3,
385 MilliSeconds(200),
386 MilliSeconds(500),
387 2500),
388 TestCase::Duration::QUICK);
390 "REAL Handover failure due to non-allocation of non-contention preamble at "
391 "target eNodeB due to max number reached",
392 false,
393 Seconds(0.100),
394 Seconds(0.200),
395 64,
396 50,
397 3,
398 MilliSeconds(200),
399 MilliSeconds(500),
400 1500),
401 TestCase::Duration::QUICK);
403 "REAL Handover failure due to HANDOVER JOINING timeout before reception of "
404 "RRC CONNECTION RECONFIGURATION at source eNodeB",
405 false,
406 Seconds(0.100),
407 Seconds(0.200),
408 52,
409 50,
410 3,
411 MilliSeconds(0),
412 MilliSeconds(500),
413 1500),
414 TestCase::Duration::QUICK);
416 "REAL Handover failure due to HANDOVER JOINING timeout before completion "
417 "of non-contention RACH process to target eNodeB",
418 false,
419 Seconds(0.100),
420 Seconds(0.200),
421 52,
422 50,
423 3,
424 MilliSeconds(15),
425 MilliSeconds(500),
426 1500),
427 TestCase::Duration::QUICK);
429 "REAL Handover failure due to HANDOVER JOINING timeout before reception of "
430 "RRC CONNECTION RECONFIGURATION COMPLETE at target eNodeB",
431 false,
432 Seconds(0.100),
433 Seconds(0.200),
434 52,
435 50,
436 3,
437 MilliSeconds(18),
438 MilliSeconds(500),
439 500),
440 TestCase::Duration::QUICK);
442 "REAL Handover failure due to HANDOVER LEAVING timeout before reception of "
443 "RRC CONNECTION RECONFIGURATION at source eNodeB",
444 false,
445 Seconds(0.100),
446 Seconds(0.200),
447 52,
448 50,
449 3,
450 MilliSeconds(200),
451 MilliSeconds(0),
452 1500),
453 TestCase::Duration::QUICK);
455 "REAL Handover failure due to HANDOVER LEAVING timeout before completion "
456 "of non-contention RACH process to target eNodeB",
457 false,
458 Seconds(0.100),
459 Seconds(0.200),
460 52,
461 50,
462 3,
463 MilliSeconds(200),
464 MilliSeconds(15),
465 1500),
466 TestCase::Duration::QUICK);
468 "REAL Handover failure due to HANDOVER LEAVING timeout before reception of "
469 "RRC CONNECTION RECONFIGURATION COMPLETE at target eNodeB",
470 false,
471 Seconds(0.100),
472 Seconds(0.200),
473 52,
474 50,
475 3,
476 MilliSeconds(200),
477 MilliSeconds(18),
478 500),
479 TestCase::Duration::QUICK);
480
481 // Test cases for IDEAL RRC protocol
482 AddTestCase(new LteHandoverFailureTestCase("IDEAL Handover failure due to maximum RACH "
483 "transmissions reached from UE to target eNodeB",
484 true,
485 Seconds(0.100),
486 Seconds(0.200),
487 52,
488 3,
489 3,
490 MilliSeconds(200),
491 MilliSeconds(500),
492 1500),
493 TestCase::Duration::QUICK);
495 "IDEAL Handover failure due to non-allocation of non-contention preamble "
496 "at target eNodeB due to max number reached",
497 true,
498 Seconds(0.100),
499 Seconds(0.200),
500 64,
501 50,
502 3,
503 MilliSeconds(200),
504 MilliSeconds(500),
505 1500),
506 TestCase::Duration::QUICK);
508 "IDEAL Handover failure due to HANDOVER JOINING timeout before reception "
509 "of RRC CONNECTION RECONFIGURATION at source eNodeB",
510 true,
511 Seconds(0.100),
512 Seconds(0.200),
513 52,
514 50,
515 3,
516 MilliSeconds(0),
517 MilliSeconds(500),
518 1500),
519 TestCase::Duration::QUICK);
521 "IDEAL Handover failure due to HANDOVER JOINING timeout before completion "
522 "of non-contention RACH process to target eNodeB",
523 true,
524 Seconds(0.100),
525 Seconds(0.200),
526 52,
527 50,
528 3,
529 MilliSeconds(10),
530 MilliSeconds(500),
531 1500),
532 TestCase::Duration::QUICK);
534 "IDEAL Handover failure due to HANDOVER JOINING timeout before reception "
535 "of RRC CONNECTION RECONFIGURATION COMPLETE at target eNodeB",
536 true,
537 Seconds(0.100),
538 Seconds(0.200),
539 52,
540 50,
541 3,
542 MilliSeconds(4),
543 MilliSeconds(500),
544 500),
545 TestCase::Duration::QUICK);
547 "IDEAL Handover failure due to HANDOVER LEAVING timeout before reception "
548 "of RRC CONNECTION RECONFIGURATION at source eNodeB",
549 true,
550 Seconds(0.100),
551 Seconds(0.200),
552 52,
553 50,
554 3,
555 MilliSeconds(500),
556 MilliSeconds(0),
557 1500),
558 TestCase::Duration::QUICK);
560 "IDEAL Handover failure due to HANDOVER LEAVING timeout before completion "
561 "of non-contention RACH process to target eNodeB",
562 true,
563 Seconds(0.100),
564 Seconds(0.200),
565 52,
566 50,
567 3,
568 MilliSeconds(500),
569 MilliSeconds(10),
570 1500),
571 TestCase::Duration::QUICK);
573 "IDEAL Handover failure due to HANDOVER LEAVING timeout before reception "
574 "of RRC CONNECTION RECONFIGURATION COMPLETE at target eNodeB",
575 true,
576 Seconds(0.100),
577 Seconds(0.200),
578 52,
579 50,
580 3,
581 MilliSeconds(500),
582 MilliSeconds(4),
583 500),
584 TestCase::Duration::QUICK);
585 }
586} g_lteHandoverFailureTestSuite; ///< end of LteHandoverFailureTestSuite ()
Verifying that a handover failure occurs due to various causes.
LteHandoverFailureTestCase(std::string name, bool useIdealRrc, Time handoverTime, Time simulationDuration, uint8_t numberOfRaPreambles, uint8_t preambleTransMax, uint8_t raResponseWindowSize, Time handoverJoiningTimeout, Time handoverLeavingTimeout, uint16_t targeteNodeBPosition)
Constructor.
Time m_handoverJoiningTimeout
handover joining timeout duration at target eNodeB
Time m_handoverLeavingTimeout
handover leaving timeout duration at source eNodeB
uint8_t m_preambleTransMax
max number of RACH preambles possible from UE to eNodeB
uint8_t m_numberOfRaPreambles
number of random access preambles for contention based RACH process
void HandoverFailureMaxRach(std::string context, uint64_t imsi, uint16_t rnti, uint16_t targetCellId)
Handover failure callback due to maximum RACH transmissions reached from UE to target eNodeB.
void DoRun() override
Run a simulation of a two eNodeB network using the parameters provided to the constructor function.
uint16_t m_targeteNodeBPosition
position of the target eNodeB
void HandoverFailureJoining(std::string context, uint64_t imsi, uint16_t rnti, uint16_t targetCellId)
Handover failure callback due to handover joining timeout at target eNodeB.
void HandoverFailureNoPreamble(std::string context, uint64_t imsi, uint16_t rnti, uint16_t targetCellId)
Handover failure callback due to non-allocation of non-contention preamble at target eNodeB.
void HandoverFailureLeaving(std::string context, uint64_t imsi, uint16_t rnti, uint16_t targetCellId)
Handover failure callback due to handover leaving timeout at source eNodeB.
bool m_hasHandoverFailureOccurred
has handover failure occurred in simulation
void UeHandoverStartCallback(std::string context, uint64_t imsi, uint16_t sourceCellId, uint16_t rnti, uint16_t targetCellId)
UE handover start callback function to indicate start of handover.
void DoTeardown() override
Called at the end of simulation and verifies that a handover and a handover failure has occurred in t...
uint8_t m_raResponseWindowSize
window length for reception of RAR
Time m_simulationDuration
the simulation duration
The following log components can be used to debug this test's behavior: LteHandoverFailureTest:LteEnb...
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition double.h:31
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...
holds a vector of std::pair of Ptr<Ipv4> and interface index.
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 a set of node pointers.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
static void SetRun(uint64_t run)
Set the run number of simulation.
static void SetSeed(uint32_t seed)
Set the seed.
static uint64_t GetRun()
Get the current run number.
static uint32_t GetSeed()
Get the current seed value which will be used by all subsequently instantiated RandomVariableStream o...
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
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 GetName() const
Definition test.cc:367
A suite of tests to run.
Definition test.h:1267
Type
Type of test.
Definition test.h:1274
static constexpr auto SYSTEM
Definition test.h:1293
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
static TypeId LookupByName(std::string name)
Get a TypeId by name.
Definition type-id.cc:872
Hold an unsigned integer type.
Definition uinteger.h:34
void SetDefault(std::string name, const AttributeValue &value)
Definition config.cc:883
void Connect(std::string path, const CallbackBase &cb)
Definition config.cc:967
#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 ",...
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition log.h:264
LteHandoverFailureTestSuite g_lteHandoverFailureTestSuite
end of LteHandoverFailureTestSuite ()
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619
#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:1308
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1320
Every class exported by the ns3 library is enclosed in the ns3 namespace.
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:684
Ptr< T1 > DynamicCast(const Ptr< T2 > &p)
Cast a Ptr.
Definition ptr.h:580