A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
test-lte-rrc.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2012 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 * Budiarto Herman <budiarto.herman@magister.fi>
8 */
9
10#include <ns3/core-module.h>
11#include <ns3/lte-module.h>
12#include <ns3/mobility-module.h>
13#include <ns3/network-module.h>
14
15#include <cmath>
16
17using namespace ns3;
18
19NS_LOG_COMPONENT_DEFINE("LteRrcTest");
20
21/**
22 * \ingroup lte-test
23 *
24 * \brief Test rrc connection establishment.
25 */
26class LteRrcConnectionEstablishmentTestCase : public TestCase
27{
28 public:
29 /**
30 *
31 *
32 * \param nUes number of UEs in the test
33 * \param nBearers number of bearers to be setup in each connection
34 * \param tConnBase connection time base value for all UEs in ms
35 * \param tConnIncrPerUe additional connection time increment for each UE index (0...nUes-1) in
36 * ms
37 * \param delayDiscStart expected duration to perform connection establishment in ms
38 * \param errorExpected if true, test case will wait a bit longer to accommodate for
39 * transmission error
40 * \param useIdealRrc If set to false, real RRC protocol model will be used
41 * \param admitRrcConnectionRequest If set to false, eNb will not allow UE connections
42 * \param description additional description of the test case
43 */
44 LteRrcConnectionEstablishmentTestCase(uint32_t nUes,
45 uint32_t nBearers,
46 uint32_t tConnBase,
47 uint32_t tConnIncrPerUe,
48 uint32_t delayDiscStart,
49 bool errorExpected,
50 bool useIdealRrc,
51 bool admitRrcConnectionRequest,
52 std::string description = "");
53
54 protected:
55 void DoRun() override;
56 uint32_t m_nUes; ///< number of UEs in the test
57
58 /**
59 * Build name string function
60 *
61 * \param nUes number of UEs in the test
62 * \param nBearers number of bearers to be setup in each connection
63 * \param tConnBase connection time base value for all UEs in ms
64 * \param tConnIncrPerUe additional connection time increment for each UE index (0...nUes-1)
65 * in ms
66 * \param delayDiscStart expected duration to perform connection establishment in ms
67 * \param useIdealRrc If set to false, real RRC protocol model will be used
68 * \param admitRrcConnectionRequest If set to false, eNb will not allow UE connections
69 * \param description additional description of the test case
70 * \returns the name string
71 */
72 static std::string BuildNameString(uint32_t nUes,
73 uint32_t nBearers,
74 uint32_t tConnBase,
75 uint32_t tConnIncrPerUe,
76 uint32_t delayDiscStart,
77 bool useIdealRrc,
78 bool admitRrcConnectionRequest,
79 std::string description = "");
80 /**
81 * Connect function
82 * \param ueDevice the UE device
83 * \param enbDevice the ENB device
84 */
85 void Connect(Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice);
86 /**
87 * Check connected function
88 * \param ueDevice the UE device
89 * \param enbDevice the ENB device
90 */
91 void CheckConnected(Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice);
92 /**
93 * Check not connected function
94 * \param ueDevice the UE device
95 * \param enbDevice the ENB device
96 */
97 void CheckNotConnected(Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice);
98 /**
99 * Connection established callback function
100 * \param context the context string
101 * \param imsi the IMSI
102 * \param cellId the cell ID
103 * \param rnti the RNTI
104 */
105 void ConnectionEstablishedCallback(std::string context,
106 uint64_t imsi,
107 uint16_t cellId,
108 uint16_t rnti);
109 /**
110 * Connection timeout callback function
111 * \param context the context string
112 * \param imsi the IMSI
113 * \param cellId the cell ID
114 * \param rnti the RNTI
115 * \param connEstFailCount the T300 timer expiration counter value
116 */
117 void ConnectionTimeoutCallback(std::string context,
118 uint64_t imsi,
119 uint16_t cellId,
120 uint16_t rnti,
121 uint8_t connEstFailCount);
122
123 uint32_t m_nBearers; ///< number of bearers to be setup in each connection
124 uint32_t m_tConnBase; ///< connection time base value for all UEs in ms
125 uint32_t m_tConnIncrPerUe; ///< additional connection time increment for each UE index
126 ///< (0...nUes-1) in ms
127 uint32_t m_delayConnEnd; ///< expected duration to perform connection establishment in ms
128 uint32_t
129 m_delayDiscStart; ///< delay between connection completed and disconnection request in ms
130 uint32_t m_delayDiscEnd; ///< expected duration to complete disconnection in ms
131 bool m_useIdealRrc; ///< If set to false, real RRC protocol model will be used
132 bool m_admitRrcConnectionRequest; ///< If set to false, eNb will not allow UE connections
133 Ptr<LteHelper> m_lteHelper; ///< LTE helper
134
135 /// key: IMSI
136 std::map<uint64_t, bool> m_isConnectionEstablished;
137};
138
139std::string
140LteRrcConnectionEstablishmentTestCase::BuildNameString(uint32_t nUes,
141 uint32_t nBearers,
142 uint32_t tConnBase,
143 uint32_t tConnIncrPerUe,
144 uint32_t delayDiscStart,
145 bool useIdealRrc,
146 bool admitRrcConnectionRequest,
147 std::string description)
148{
149 std::ostringstream oss;
150 oss << "nUes=" << nUes << ", nBearers=" << nBearers << ", tConnBase=" << tConnBase
151 << ", tConnIncrPerUe=" << tConnIncrPerUe << ", delayDiscStart=" << delayDiscStart;
152
153 if (useIdealRrc)
154 {
155 oss << ", ideal RRC";
156 }
157 else
158 {
159 oss << ", real RRC";
160 }
161
162 if (admitRrcConnectionRequest)
163 {
164 oss << ", admitRrcConnectionRequest = true";
165 }
166 else
167 {
168 oss << ", admitRrcConnectionRequest = false";
169 }
170
171 if (!description.empty())
172 {
173 oss << ", " << description;
174 }
175
176 return oss.str();
177}
178
179LteRrcConnectionEstablishmentTestCase::LteRrcConnectionEstablishmentTestCase(
180 uint32_t nUes,
181 uint32_t nBearers,
182 uint32_t tConnBase,
183 uint32_t tConnIncrPerUe,
184 uint32_t delayDiscStart,
185 bool errorExpected,
186 bool useIdealRrc,
187 bool admitRrcConnectionRequest,
188 std::string description)
189 : TestCase(BuildNameString(nUes,
190 nBearers,
191 tConnBase,
192 tConnIncrPerUe,
193 delayDiscStart,
194 useIdealRrc,
195 admitRrcConnectionRequest,
196 description)),
197 m_nUes(nUes),
198 m_nBearers(nBearers),
199 m_tConnBase(tConnBase),
200 m_tConnIncrPerUe(tConnIncrPerUe),
201
202 m_delayDiscStart(delayDiscStart),
203 m_delayDiscEnd(10),
204 m_useIdealRrc(useIdealRrc),
205 m_admitRrcConnectionRequest(admitRrcConnectionRequest)
206{
207 NS_LOG_FUNCTION(this << GetName());
208
209 // see the description of d^e in the LTE testing docs
210 double dsi = 90;
211 double nRaAttempts = 0;
212 if (nUes <= 20)
213 {
214 nRaAttempts += 5;
215 }
216 else
217 {
218 NS_ASSERT(nUes <= 50);
219 nRaAttempts += 10;
220 }
221
222 nRaAttempts += std::ceil(nUes / 4.0);
223 double dra = nRaAttempts * 7;
224 double dce = 10.0 + (2.0 * nUes) / 4.0;
225 if (errorExpected)
226 {
227 /*
228 * If transmission error happens, the UE has to repeat again from
229 * acquiring system information.
230 */
231 dce += dsi + dce;
232 }
233 double nCrs;
234 if (nUes <= 2)
235 {
236 nCrs = 0;
237 }
238 else if (nUes <= 5)
239 {
240 nCrs = 1;
241 }
242 else if (nUes <= 10)
243 {
244 nCrs = 2;
245 }
246 else if (nUes <= 20)
247 {
248 nCrs = 3;
249 }
250 else
251 {
252 nCrs = 4;
253 }
254 double dcr = (10.0 + (2.0 * nUes) / 4.0) * (m_nBearers + nCrs);
255
256 m_delayConnEnd = round(dsi + dra + dce + dcr);
257 NS_LOG_LOGIC(this << " " << GetName() << " dsi=" << dsi << " dra=" << dra << " dce=" << dce
258 << " dcr=" << dcr << " m_delayConnEnd=" << m_delayConnEnd);
259}
260
261void
262LteRrcConnectionEstablishmentTestCase::DoRun()
263{
264 NS_LOG_FUNCTION(this << GetName());
265 Config::Reset();
266
267 if (m_nUes < 25)
268 {
269 Config::SetDefault("ns3::LteEnbRrc::SrsPeriodicity", UintegerValue(40));
270 }
271 else if (m_nUes < 60)
272 {
273 Config::SetDefault("ns3::LteEnbRrc::SrsPeriodicity", UintegerValue(80));
274 }
275 else if (m_nUes < 120)
276 {
277 Config::SetDefault("ns3::LteEnbRrc::SrsPeriodicity", UintegerValue(160));
278 }
279 else
280 {
281 Config::SetDefault("ns3::LteEnbRrc::SrsPeriodicity", UintegerValue(320));
282 }
283
284 // normal code
285 m_lteHelper = CreateObject<LteHelper>();
286 m_lteHelper->SetAttribute("UseIdealRrc", BooleanValue(m_useIdealRrc));
287
288 NodeContainer enbNodes;
289 NodeContainer ueNodes;
290
291 enbNodes.Create(1);
292 ueNodes.Create(m_nUes);
293
294 // the following positions all nodes at (0, 0, 0)
295 MobilityHelper mobility;
296 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
297 mobility.Install(enbNodes);
298 mobility.Install(ueNodes);
299
300 int64_t stream = 1;
301 NetDeviceContainer enbDevs;
302 enbDevs = m_lteHelper->InstallEnbDevice(enbNodes);
303 stream += m_lteHelper->AssignStreams(enbDevs, stream);
304
305 NetDeviceContainer ueDevs;
306 ueDevs = m_lteHelper->InstallUeDevice(ueNodes);
307 stream += m_lteHelper->AssignStreams(ueDevs, stream);
308
309 // custom code used for testing purposes
310 // instead of lteHelper->Attach () and lteHelper->ActivateXxx
311
312 // Set AdmitConnectionRequest attribute
313 for (auto it = enbDevs.Begin(); it != enbDevs.End(); ++it)
314 {
315 Ptr<LteEnbRrc> enbRrc = (*it)->GetObject<LteEnbNetDevice>()->GetRrc();
316 enbRrc->SetAttribute("AdmitRrcConnectionRequest",
317 BooleanValue(m_admitRrcConnectionRequest));
318 }
319
320 uint32_t i = 0;
321 uint32_t tmax = 0;
322 for (auto it = ueDevs.Begin(); it != ueDevs.End(); ++it)
323 {
324 Ptr<NetDevice> ueDevice = *it;
325 Ptr<NetDevice> enbDevice = enbDevs.Get(0);
326 Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice>();
327
328 uint32_t tc = m_tConnBase + m_tConnIncrPerUe * i; // time connection start
329 uint32_t tcc = tc + m_delayConnEnd; // time check connection completed;
330 uint32_t td = tcc + m_delayDiscStart; // time disconnect start
331 uint32_t tcd = td + m_delayDiscEnd; // time check disconnection completed
332 tmax = std::max(tmax, tcd);
333
334 // trick to resolve overloading
335 // void (LteHelper::* overloadedAttachFunctionPointer) (Ptr<NetDevice>, Ptr<NetDevice>) =
336 // &LteHelper::Attach; Simulator::Schedule (MilliSeconds (tc),
337 // overloadedAttachFunctionPointer, lteHelper, *it, enbDevice);
338 Simulator::Schedule(MilliSeconds(tc),
339 &LteRrcConnectionEstablishmentTestCase::Connect,
340 this,
341 ueDevice,
342 enbDevice);
343
344 Simulator::Schedule(MilliSeconds(tcc),
345 &LteRrcConnectionEstablishmentTestCase::CheckConnected,
346 this,
347 *it,
348 enbDevice);
349
350 // disconnection not supported yet
351
352 uint64_t imsi = ueLteDevice->GetImsi();
353 m_isConnectionEstablished[imsi] = false;
354
355 ++i;
356 }
357
358 // Connect to trace sources in UEs
359 Config::Connect(
360 "/NodeList/*/DeviceList/*/LteUeRrc/ConnectionEstablished",
361 MakeCallback(&LteRrcConnectionEstablishmentTestCase::ConnectionEstablishedCallback, this));
362 Config::Connect(
363 "/NodeList/*/DeviceList/*/LteUeRrc/ConnectionTimeout",
364 MakeCallback(&LteRrcConnectionEstablishmentTestCase::ConnectionTimeoutCallback, this));
365
366 Simulator::Stop(MilliSeconds(tmax + 1));
367
368 Simulator::Run();
369
370 Simulator::Destroy();
371}
372
373void
374LteRrcConnectionEstablishmentTestCase::Connect(Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice)
375{
376 NS_LOG_FUNCTION(this);
377 m_lteHelper->Attach(ueDevice, enbDevice);
378
379 for (uint32_t b = 0; b < m_nBearers; ++b)
380 {
381 EpsBearer::Qci q = EpsBearer::NGBR_VIDEO_TCP_DEFAULT;
382 EpsBearer bearer(q);
383 m_lteHelper->ActivateDataRadioBearer(ueDevice, bearer);
384 }
385}
386
387void
388LteRrcConnectionEstablishmentTestCase::CheckConnected(Ptr<NetDevice> ueDevice,
389 Ptr<NetDevice> enbDevice)
390{
391 Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice>();
392 Ptr<LteUeRrc> ueRrc = ueLteDevice->GetRrc();
393 const uint64_t imsi = ueLteDevice->GetImsi();
394 const uint16_t rnti = ueRrc->GetRnti();
395 NS_LOG_FUNCTION(this << imsi << rnti);
396 NS_ASSERT_MSG(m_isConnectionEstablished.find(imsi) != m_isConnectionEstablished.end(),
397 "Invalid IMSI " << imsi);
398
399 if (!m_admitRrcConnectionRequest)
400 {
401 NS_TEST_ASSERT_MSG_EQ(m_isConnectionEstablished[imsi],
402 false,
403 "Connection with RNTI " << rnti << " should have been rejected");
404 return;
405 }
406
407 /*
408 * Verifying UE state in UE RRC. Try to increase the test case duration if
409 * the following checks.
410 */
411 NS_TEST_ASSERT_MSG_EQ(m_isConnectionEstablished[imsi],
412 true,
413 "RNTI " << rnti << " fails to establish connection");
414 NS_TEST_ASSERT_MSG_EQ(ueRrc->GetState(),
415 LteUeRrc::CONNECTED_NORMALLY,
416 "RNTI " << rnti << " is not at CONNECTED_NORMALLY state");
417
418 // Verifying UE context state in eNodeB RRC.
419
420 Ptr<LteEnbNetDevice> enbLteDevice = enbDevice->GetObject<LteEnbNetDevice>();
421 Ptr<LteEnbRrc> enbRrc = enbLteDevice->GetRrc();
422 const bool hasContext = enbRrc->HasUeManager(rnti);
423
424 if (hasContext)
425 {
426 Ptr<UeManager> ueManager = enbRrc->GetUeManager(rnti);
427 NS_ASSERT(ueManager);
428 NS_TEST_ASSERT_MSG_EQ(ueManager->GetState(),
429 UeManager::CONNECTED_NORMALLY,
430 "The context of RNTI " << rnti << " is in invalid state");
431 }
432 else
433 {
434 NS_LOG_WARN(this << " RNTI " << rnti << " thinks that it has"
435 << " established connection but the eNodeB thinks"
436 << " that the UE has failed on connection setup.");
437 /*
438 * The standard specifies that this case would exceed the maximum
439 * retransmission limit at UE RLC (SRB1), which will then trigger an RLF.
440 * However, this behaviour is not implemented yet.
441 */
442 }
443
444 // Verifying other attributes on both sides.
445
446 uint16_t ueCellId = ueRrc->GetCellId();
447 uint16_t enbCellId = enbLteDevice->GetCellId();
448 uint16_t ueImsi = ueLteDevice->GetImsi();
449
450 uint8_t ueDlBandwidth = ueRrc->GetDlBandwidth();
451 uint8_t enbDlBandwidth = enbLteDevice->GetDlBandwidth();
452 uint8_t ueUlBandwidth = ueRrc->GetUlBandwidth();
453 uint8_t enbUlBandwidth = enbLteDevice->GetUlBandwidth();
454 uint8_t ueDlEarfcn = ueRrc->GetDlEarfcn();
455 uint8_t enbDlEarfcn = enbLteDevice->GetDlEarfcn();
456 uint8_t ueUlEarfcn = ueRrc->GetUlEarfcn();
457 uint8_t enbUlEarfcn = enbLteDevice->GetUlEarfcn();
458
459 NS_TEST_ASSERT_MSG_EQ(ueCellId, enbCellId, "inconsistent CellId");
460 NS_TEST_ASSERT_MSG_EQ(ueDlBandwidth, enbDlBandwidth, "inconsistent DlBandwidth");
461 NS_TEST_ASSERT_MSG_EQ(ueUlBandwidth, enbUlBandwidth, "inconsistent UlBandwidth");
462 NS_TEST_ASSERT_MSG_EQ(ueDlEarfcn, enbDlEarfcn, "inconsistent DlEarfcn");
463 NS_TEST_ASSERT_MSG_EQ(ueUlEarfcn, enbUlEarfcn, "inconsistent UlEarfcn");
464
465 if (hasContext)
466 {
467 Ptr<UeManager> ueManager = enbRrc->GetUeManager(rnti);
468 NS_ASSERT(ueManager);
469 UeManager::State state = ueManager->GetState();
470 uint16_t enbImsi = ueManager->GetImsi();
471 NS_TEST_ASSERT_MSG_EQ(ueImsi, enbImsi, "inconsistent Imsi");
472
473 if (state == UeManager::CONNECTED_NORMALLY)
474 {
475 ObjectMapValue enbDataRadioBearerMapValue;
476 ueManager->GetAttribute("DataRadioBearerMap", enbDataRadioBearerMapValue);
477 NS_TEST_ASSERT_MSG_EQ(enbDataRadioBearerMapValue.GetN(),
478 m_nBearers,
479 "wrong num bearers at eNB");
480 ObjectMapValue ueDataRadioBearerMapValue;
481 ueRrc->GetAttribute("DataRadioBearerMap", ueDataRadioBearerMapValue);
482 NS_TEST_ASSERT_MSG_EQ(ueDataRadioBearerMapValue.GetN(),
483 m_nBearers,
484 "wrong num bearers at UE");
485
486 auto enbBearerIt = enbDataRadioBearerMapValue.Begin();
487 auto ueBearerIt = ueDataRadioBearerMapValue.Begin();
488 while (enbBearerIt != enbDataRadioBearerMapValue.End() &&
489 ueBearerIt != ueDataRadioBearerMapValue.End())
490 {
491 Ptr<LteDataRadioBearerInfo> enbDrbInfo =
492 enbBearerIt->second->GetObject<LteDataRadioBearerInfo>();
493 Ptr<LteDataRadioBearerInfo> ueDrbInfo =
494 ueBearerIt->second->GetObject<LteDataRadioBearerInfo>();
495 // NS_TEST_ASSERT_MSG_EQ (enbDrbInfo->m_epsBearer, ueDrbInfo->m_epsBearer,
496 // "epsBearer differs");
497 NS_TEST_ASSERT_MSG_EQ((uint32_t)enbDrbInfo->m_epsBearerIdentity,
498 (uint32_t)ueDrbInfo->m_epsBearerIdentity,
499 "epsBearerIdentity differs");
500 NS_TEST_ASSERT_MSG_EQ((uint32_t)enbDrbInfo->m_drbIdentity,
501 (uint32_t)ueDrbInfo->m_drbIdentity,
502 "drbIdentity differs");
503 // NS_TEST_ASSERT_MSG_EQ (enbDrbInfo->m_rlcConfig, ueDrbInfo->m_rlcConfig,
504 // "rlcConfig differs");
505 NS_TEST_ASSERT_MSG_EQ((uint32_t)enbDrbInfo->m_logicalChannelIdentity,
506 (uint32_t)ueDrbInfo->m_logicalChannelIdentity,
507 "logicalChannelIdentity differs");
508 // NS_TEST_ASSERT_MSG_EQ (enbDrbInfo->m_logicalChannelConfig,
509 // ueDrbInfo->m_logicalChannelConfig, "logicalChannelConfig differs");
510
511 ++enbBearerIt;
512 ++ueBearerIt;
513 }
514
515 NS_ASSERT_MSG(enbBearerIt == enbDataRadioBearerMapValue.End(),
516 "too many bearers at eNB");
517 NS_ASSERT_MSG(ueBearerIt == ueDataRadioBearerMapValue.End(), "too many bearers at UE");
518 }
519 }
520}
521
522void
523LteRrcConnectionEstablishmentTestCase::CheckNotConnected(Ptr<NetDevice> ueDevice,
524 Ptr<NetDevice> enbDevice)
525{
526 Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice>();
527 Ptr<LteUeRrc> ueRrc = ueLteDevice->GetRrc();
528 const uint64_t imsi = ueLteDevice->GetImsi();
529 const uint16_t rnti = ueRrc->GetRnti();
530 NS_LOG_FUNCTION(this << imsi << rnti);
531 NS_ASSERT_MSG(m_isConnectionEstablished.find(imsi) != m_isConnectionEstablished.end(),
532 "Invalid IMSI " << imsi);
533
534 bool ueStateIsConnectedNormally = (LteUeRrc::CONNECTED_NORMALLY == ueRrc->GetState());
535
536 Ptr<LteEnbNetDevice> enbLteDevice = enbDevice->GetObject<LteEnbNetDevice>();
537 Ptr<LteEnbRrc> enbRrc = enbLteDevice->GetRrc();
538 const bool hasContext = enbRrc->HasUeManager(rnti);
539 bool contextStateIsConnectedNormally = false;
540 if (hasContext)
541 {
542 Ptr<UeManager> ueManager = enbRrc->GetUeManager(rnti);
543 NS_ASSERT(ueManager);
544 contextStateIsConnectedNormally = (UeManager::CONNECTED_NORMALLY == ueManager->GetState());
545 }
546 NS_TEST_ASSERT_MSG_EQ(
547 (!m_isConnectionEstablished[imsi] || !ueStateIsConnectedNormally || !hasContext ||
548 !contextStateIsConnectedNormally),
549 true,
550 "it should not happen that connection is completed both at the UE and at the eNB side");
551}
552
553void
554LteRrcConnectionEstablishmentTestCase::ConnectionEstablishedCallback(std::string context,
555 uint64_t imsi,
556 uint16_t cellId,
557 uint16_t rnti)
558{
559 NS_LOG_FUNCTION(this << imsi << cellId);
560 m_isConnectionEstablished[imsi] = true;
561}
562
563void
564LteRrcConnectionEstablishmentTestCase::ConnectionTimeoutCallback(std::string context,
565 uint64_t imsi,
566 uint16_t cellId,
567 uint16_t rnti,
568 uint8_t connEstFailCount)
569{
570 NS_LOG_FUNCTION(this << imsi << cellId);
571}
572
573/**
574 * \ingroup lte-test
575 *
576 * \brief Lte Rrc Connection Establishment Error Test Case
577 */
578class LteRrcConnectionEstablishmentErrorTestCase : public LteRrcConnectionEstablishmentTestCase
579{
580 public:
581 /**
582 *
583 *
584 * \param jumpAwayTime the time when all the UEs 'teleport' to a pre-defined
585 * high-interference position and stay there for 100 ms
586 * \param description additional description of the test case
587 */
588 LteRrcConnectionEstablishmentErrorTestCase(Time jumpAwayTime, std::string description = "");
589
590 protected:
591 void DoRun() override;
592
593 private:
594 /// Jump away function
595 void JumpAway();
596 /// Jump back function
597 void JumpBack();
598
599 Time m_jumpAwayTime; ///< jump away time
600 Ptr<MobilityModel> m_ueMobility; ///< UE mobility model
601};
602
603LteRrcConnectionEstablishmentErrorTestCase::LteRrcConnectionEstablishmentErrorTestCase(
604 Time jumpAwayTime,
605 std::string description)
606 : LteRrcConnectionEstablishmentTestCase(1, 1, 0, 0, 1, true, false, true, description),
607 m_jumpAwayTime(jumpAwayTime)
608{
609 NS_LOG_FUNCTION(this << GetName());
610}
611
612void
613LteRrcConnectionEstablishmentErrorTestCase::DoRun()
614{
615 NS_LOG_FUNCTION(this << GetName());
616 Config::Reset();
617
618 if (m_nUes < 25)
619 {
620 Config::SetDefault("ns3::LteEnbRrc::SrsPeriodicity", UintegerValue(40));
621 }
622 else if (m_nUes < 60)
623 {
624 Config::SetDefault("ns3::LteEnbRrc::SrsPeriodicity", UintegerValue(80));
625 }
626 else if (m_nUes < 120)
627 {
628 Config::SetDefault("ns3::LteEnbRrc::SrsPeriodicity", UintegerValue(160));
629 }
630 else
631 {
632 Config::SetDefault("ns3::LteEnbRrc::SrsPeriodicity", UintegerValue(320));
633 }
634
635 // normal code
636 m_lteHelper = CreateObject<LteHelper>();
637 m_lteHelper->SetAttribute("UseIdealRrc", BooleanValue(m_useIdealRrc));
638
639 NodeContainer enbNodes;
640 NodeContainer ueNodes;
641
642 enbNodes.Create(4);
643 ueNodes.Create(1);
644
645 MobilityHelper mobility;
646 mobility.Install(ueNodes); // UE position at (0, 0, 0)
647 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
648
649 Ptr<ListPositionAllocator> enbPosition = CreateObject<ListPositionAllocator>();
650 enbPosition->Add(Vector(0, 0, 0));
651 enbPosition->Add(Vector(100.0, 0, 0));
652 enbPosition->Add(Vector(0, 100.0, 0));
653 enbPosition->Add(Vector(100.0, 100.0, 0));
654 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
655 mobility.SetPositionAllocator(enbPosition);
656 mobility.Install(enbNodes);
657
658 int64_t stream = 1;
659 NetDeviceContainer enbDevs;
660 enbDevs = m_lteHelper->InstallEnbDevice(enbNodes);
661 stream += m_lteHelper->AssignStreams(enbDevs, stream);
662
663 NetDeviceContainer ueDevs;
664 ueDevs = m_lteHelper->InstallUeDevice(ueNodes);
665 stream += m_lteHelper->AssignStreams(ueDevs, stream);
666
667 // custom code used for testing purposes
668 // instead of lteHelper->Attach () and lteHelper->ActivateXxx
669
670 // Set AdmitConnectionRequest attribute
671 for (auto it = enbDevs.Begin(); it != enbDevs.End(); ++it)
672 {
673 Ptr<LteEnbRrc> enbRrc = (*it)->GetObject<LteEnbNetDevice>()->GetRrc();
674 enbRrc->SetAttribute("AdmitRrcConnectionRequest",
675 BooleanValue(m_admitRrcConnectionRequest));
676 }
677
678 uint32_t i = 0;
679 uint32_t tmax = 0;
680 for (auto it = ueDevs.Begin(); it != ueDevs.End(); ++it)
681 {
682 Ptr<NetDevice> ueDevice = *it;
683 Ptr<NetDevice> enbDevice = enbDevs.Get(0);
684 Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice>();
685
686 uint32_t tc = m_tConnBase + m_tConnIncrPerUe * i; // time connection start
687 uint32_t tcc = tc + m_delayConnEnd; // time check connection completed;
688 uint32_t td = tcc + m_delayDiscStart; // time disconnect start
689 uint32_t tcd = td + m_delayDiscEnd; // time check disconnection completed
690 tmax = std::max(tmax, tcd);
691
692 // trick to resolve overloading
693 // void (LteHelper::* overloadedAttachFunctionPointer) (Ptr<NetDevice>, Ptr<NetDevice>) =
694 // &LteHelper::Attach; Simulator::Schedule (MilliSeconds (tc),
695 // overloadedAttachFunctionPointer, lteHelper, *it, enbDevice);
696 Simulator::Schedule(MilliSeconds(tc),
697 &LteRrcConnectionEstablishmentErrorTestCase::Connect,
698 this,
699 ueDevice,
700 enbDevice);
701
702 // disconnection not supported yet
703
704 uint64_t imsi = ueLteDevice->GetImsi();
705 m_isConnectionEstablished[imsi] = false;
706
707 ++i;
708 }
709
710 // Connect to trace sources in UEs
711 Config::Connect(
712 "/NodeList/*/DeviceList/*/LteUeRrc/ConnectionEstablished",
713 MakeCallback(&LteRrcConnectionEstablishmentErrorTestCase::ConnectionEstablishedCallback,
714 this));
715 Config::Connect(
716 "/NodeList/*/DeviceList/*/LteUeRrc/ConnectionTimeout",
717 MakeCallback(&LteRrcConnectionEstablishmentErrorTestCase::ConnectionTimeoutCallback, this));
718
719 Simulator::Schedule(m_jumpAwayTime,
720 &LteRrcConnectionEstablishmentErrorTestCase::JumpAway,
721 this);
722 Simulator::Schedule(m_jumpAwayTime + MilliSeconds(99),
723 &LteRrcConnectionEstablishmentErrorTestCase::CheckNotConnected,
724 this,
725 ueDevs.Get(0),
726 enbDevs.Get(0));
727 Simulator::Schedule(m_jumpAwayTime + MilliSeconds(100),
728 &LteRrcConnectionEstablishmentErrorTestCase::JumpBack,
729 this);
730
731 Simulator::Stop(MilliSeconds(tmax + 1));
732
733 Simulator::Run();
734
735 Simulator::Destroy();
736}
737
738void
739LteRrcConnectionEstablishmentErrorTestCase::JumpAway()
740{
741 NS_LOG_FUNCTION(this);
742 // move to a really far away location so that transmission errors occur
743 m_ueMobility->SetPosition(Vector(100000.0, 100000.0, 0.0));
744}
745
746void
747LteRrcConnectionEstablishmentErrorTestCase::JumpBack()
748{
749 NS_LOG_FUNCTION(this);
750 m_ueMobility->SetPosition(Vector(0.0, 0.0, 0.0));
751}
752
753/**
754 * \ingroup lte-test
755 *
756 * \brief Lte Rrc Test Suite
757 */
758class LteRrcTestSuite : public TestSuite
759{
760 public:
761 LteRrcTestSuite();
762};
763
764LteRrcTestSuite::LteRrcTestSuite()
765 : TestSuite("lte-rrc", Type::SYSTEM)
766{
767 // LogComponentEnableAll (LOG_PREFIX_ALL);
768 // LogComponentEnable ("LteRrcTest", LOG_LEVEL_ALL);
769 // LogComponentEnable ("LteEnbRrc", LOG_INFO);
770 // LogComponentEnable ("LteUeRrc", LOG_INFO);
771
772 NS_LOG_FUNCTION(this);
773
774 for (auto useIdealRrc : {false, true})
775 {
776 // <----- all times in ms ----------------->
777
778 // nUes tConnBase delayDiscStart useIdealRrc nBearers tConnIncrPerUe errorExpected
779 // admitRrcConnectionRequest
780 AddTestCase(
781 new LteRrcConnectionEstablishmentTestCase(1, 0, 0, 0, 1, false, useIdealRrc, true),
782 TestCase::Duration::EXTENSIVE);
783 AddTestCase(
784 new LteRrcConnectionEstablishmentTestCase(1, 0, 100, 0, 1, false, useIdealRrc, true),
785 TestCase::Duration::EXTENSIVE);
786 AddTestCase(
787 new LteRrcConnectionEstablishmentTestCase(1, 1, 0, 0, 1, false, useIdealRrc, true),
788 TestCase::Duration::EXTENSIVE);
789 AddTestCase(
790 new LteRrcConnectionEstablishmentTestCase(1, 1, 100, 0, 1, false, useIdealRrc, true),
791 TestCase::Duration::EXTENSIVE);
792 AddTestCase(
793 new LteRrcConnectionEstablishmentTestCase(1, 2, 0, 0, 1, false, useIdealRrc, true),
794 TestCase::Duration::EXTENSIVE);
795 AddTestCase(
796 new LteRrcConnectionEstablishmentTestCase(1, 2, 100, 0, 1, false, useIdealRrc, true),
797 TestCase::Duration::EXTENSIVE);
798 AddTestCase(
799 new LteRrcConnectionEstablishmentTestCase(2, 0, 20, 0, 1, false, useIdealRrc, true),
800 TestCase::Duration::EXTENSIVE);
801 AddTestCase(
802 new LteRrcConnectionEstablishmentTestCase(2, 0, 20, 10, 1, false, useIdealRrc, true),
803 TestCase::Duration::EXTENSIVE);
804 AddTestCase(
805 new LteRrcConnectionEstablishmentTestCase(2, 0, 20, 100, 1, false, useIdealRrc, true),
806 TestCase::Duration::EXTENSIVE);
807 AddTestCase(
808 new LteRrcConnectionEstablishmentTestCase(2, 1, 20, 0, 1, false, useIdealRrc, true),
809 TestCase::Duration::EXTENSIVE);
810 AddTestCase(
811 new LteRrcConnectionEstablishmentTestCase(2, 1, 20, 10, 1, false, useIdealRrc, true),
812 TestCase::Duration::EXTENSIVE);
813 AddTestCase(
814 new LteRrcConnectionEstablishmentTestCase(2, 1, 20, 100, 1, false, useIdealRrc, true),
815 TestCase::Duration::EXTENSIVE);
816 AddTestCase(
817 new LteRrcConnectionEstablishmentTestCase(2, 2, 20, 0, 1, false, useIdealRrc, true),
818 TestCase::Duration::EXTENSIVE);
819 AddTestCase(
820 new LteRrcConnectionEstablishmentTestCase(2, 2, 20, 10, 1, false, useIdealRrc, true),
821 TestCase::Duration::QUICK);
822 AddTestCase(
823 new LteRrcConnectionEstablishmentTestCase(2, 2, 20, 100, 1, false, useIdealRrc, true),
824 TestCase::Duration::EXTENSIVE);
825 AddTestCase(
826 new LteRrcConnectionEstablishmentTestCase(3, 0, 20, 0, 1, false, useIdealRrc, true),
827 TestCase::Duration::EXTENSIVE);
828 AddTestCase(
829 new LteRrcConnectionEstablishmentTestCase(4, 0, 20, 0, 1, false, useIdealRrc, true),
830 TestCase::Duration::EXTENSIVE);
831 AddTestCase(
832 new LteRrcConnectionEstablishmentTestCase(4, 0, 20, 300, 1, false, useIdealRrc, true),
833 TestCase::Duration::EXTENSIVE);
834 AddTestCase(
835 new LteRrcConnectionEstablishmentTestCase(20, 0, 10, 1, 1, false, useIdealRrc, true),
836 TestCase::Duration::EXTENSIVE);
837 AddTestCase(
838 new LteRrcConnectionEstablishmentTestCase(50, 0, 0, 0, 1, false, useIdealRrc, true),
839 TestCase::Duration::EXTENSIVE);
840
841 // Test cases to check admitRrcConnectionRequest=false
842 // nUes tConnBase delayDiscStart
843 // useIdealRrc
844 // nBearers tConnIncrPerUe
845 // errorExpected
846 // admitRrcConnectionRequest
847 AddTestCase(
848 new LteRrcConnectionEstablishmentTestCase(1, 0, 0, 0, 1, false, useIdealRrc, false),
849 TestCase::Duration::EXTENSIVE);
850 AddTestCase(
851 new LteRrcConnectionEstablishmentTestCase(1, 2, 100, 0, 1, false, useIdealRrc, false),
852 TestCase::Duration::EXTENSIVE);
853 AddTestCase(
854 new LteRrcConnectionEstablishmentTestCase(2, 0, 20, 0, 1, false, useIdealRrc, false),
855 TestCase::Duration::EXTENSIVE);
856 AddTestCase(
857 new LteRrcConnectionEstablishmentTestCase(2, 1, 20, 0, 1, false, useIdealRrc, false),
858 TestCase::Duration::QUICK);
859 AddTestCase(
860 new LteRrcConnectionEstablishmentTestCase(3, 0, 20, 0, 1, false, useIdealRrc, false),
861 TestCase::Duration::EXTENSIVE);
862 }
863
864 // Test cases with transmission error
865 AddTestCase(new LteRrcConnectionEstablishmentErrorTestCase(Seconds(0.020214),
866 "failure at RRC Connection Request"),
867 TestCase::Duration::QUICK);
868 AddTestCase(new LteRrcConnectionEstablishmentErrorTestCase(Seconds(0.025),
869 "failure at RRC Connection Setup"),
870 TestCase::Duration::QUICK);
871 /*
872 * With RLF implementation we now do support the Idle mode,
873 * thus it solve Bug 1762 Comment #25.
874 */
875 AddTestCase(
876 new LteRrcConnectionEstablishmentErrorTestCase(Seconds(0.030),
877 "failure at RRC Connection Setup Complete"),
878 TestCase::Duration::QUICK);
879}
880
881/**
882 * \ingroup lte-test
883 * Static variable for test initialization
884 */
885static LteRrcTestSuite g_lteRrcTestSuiteInstance;
LteRrcConnectionEstablishmentErrorTestCase
Lte Rrc Connection Establishment Error Test Case.
Definition test-lte-rrc.cc:579
LteRrcConnectionEstablishmentErrorTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition test-lte-rrc.cc:613
LteRrcConnectionEstablishmentErrorTestCase::LteRrcConnectionEstablishmentErrorTestCase
LteRrcConnectionEstablishmentErrorTestCase(Time jumpAwayTime, std::string description="")
Definition test-lte-rrc.cc:603
LteRrcConnectionEstablishmentErrorTestCase::m_ueMobility
Ptr< MobilityModel > m_ueMobility
UE mobility model.
Definition test-lte-rrc.cc:600
LteRrcConnectionEstablishmentTestCase
Test rrc connection establishment.
Definition test-lte-rrc.cc:27
LteRrcConnectionEstablishmentTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition test-lte-rrc.cc:262
LteRrcConnectionEstablishmentTestCase::BuildNameString
static std::string BuildNameString(uint32_t nUes, uint32_t nBearers, uint32_t tConnBase, uint32_t tConnIncrPerUe, uint32_t delayDiscStart, bool useIdealRrc, bool admitRrcConnectionRequest, std::string description="")
Build name string function.
Definition test-lte-rrc.cc:140
LteRrcConnectionEstablishmentTestCase::m_isConnectionEstablished
std::map< uint64_t, bool > m_isConnectionEstablished
key: IMSI
Definition test-lte-rrc.cc:136
LteRrcConnectionEstablishmentTestCase::CheckNotConnected
void CheckNotConnected(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice)
Check not connected function.
Definition test-lte-rrc.cc:523
LteRrcConnectionEstablishmentTestCase::LteRrcConnectionEstablishmentTestCase
LteRrcConnectionEstablishmentTestCase(uint32_t nUes, uint32_t nBearers, uint32_t tConnBase, uint32_t tConnIncrPerUe, uint32_t delayDiscStart, bool errorExpected, bool useIdealRrc, bool admitRrcConnectionRequest, std::string description="")
Definition test-lte-rrc.cc:179
LteRrcConnectionEstablishmentTestCase::m_admitRrcConnectionRequest
bool m_admitRrcConnectionRequest
If set to false, eNb will not allow UE connections.
Definition test-lte-rrc.cc:132
LteRrcConnectionEstablishmentTestCase::ConnectionEstablishedCallback
void ConnectionEstablishedCallback(std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti)
Connection established callback function.
Definition test-lte-rrc.cc:554
LteRrcConnectionEstablishmentTestCase::m_nUes
uint32_t m_nUes
number of UEs in the test
Definition test-lte-rrc.cc:56
LteRrcConnectionEstablishmentTestCase::CheckConnected
void CheckConnected(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice)
Check connected function.
Definition test-lte-rrc.cc:388
LteRrcConnectionEstablishmentTestCase::m_useIdealRrc
bool m_useIdealRrc
If set to false, real RRC protocol model will be used.
Definition test-lte-rrc.cc:131
LteRrcConnectionEstablishmentTestCase::m_delayConnEnd
uint32_t m_delayConnEnd
expected duration to perform connection establishment in ms
Definition test-lte-rrc.cc:127
LteRrcConnectionEstablishmentTestCase::m_tConnBase
uint32_t m_tConnBase
connection time base value for all UEs in ms
Definition test-lte-rrc.cc:124
LteRrcConnectionEstablishmentTestCase::m_lteHelper
Ptr< LteHelper > m_lteHelper
LTE helper.
Definition test-lte-rrc.cc:133
LteRrcConnectionEstablishmentTestCase::ConnectionTimeoutCallback
void ConnectionTimeoutCallback(std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti, uint8_t connEstFailCount)
Connection timeout callback function.
Definition test-lte-rrc.cc:564
LteRrcConnectionEstablishmentTestCase::m_delayDiscStart
uint32_t m_delayDiscStart
delay between connection completed and disconnection request in ms
Definition test-lte-rrc.cc:129
LteRrcConnectionEstablishmentTestCase::m_tConnIncrPerUe
uint32_t m_tConnIncrPerUe
additional connection time increment for each UE index (0...nUes-1) in ms
Definition test-lte-rrc.cc:125
LteRrcConnectionEstablishmentTestCase::Connect
void Connect(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice)
Connect function.
Definition test-lte-rrc.cc:374
LteRrcConnectionEstablishmentTestCase::m_delayDiscEnd
uint32_t m_delayDiscEnd
expected duration to complete disconnection in ms
Definition test-lte-rrc.cc:130
LteRrcConnectionEstablishmentTestCase::m_nBearers
uint32_t m_nBearers
number of bearers to be setup in each connection
Definition test-lte-rrc.cc:123
LteRrcTestSuite
Lte Rrc Test Suite.
Definition test-lte-rrc.cc:759
ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition eps-bearer.h:80
ns3::EpsBearer::Qci
Qci
QoS Class Indicator.
Definition eps-bearer.h:95
ns3::EpsBearer::NGBR_VIDEO_TCP_DEFAULT
@ NGBR_VIDEO_TCP_DEFAULT
Non-GBR TCP-based Video (Buffered Streaming, e.g., www, e-mail...)
Definition eps-bearer.h:115
ns3::LteDataRadioBearerInfo
store information on active data radio bearer instance
Definition lte-radio-bearer-info.h:66
ns3::LteEnbNetDevice
The eNodeB device implementation.
Definition lte-enb-net-device.h:48
ns3::LteUeNetDevice
The LteUeNetDevice class implements the UE net device.
Definition lte-ue-net-device.h:46
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition mobility-helper.h:33
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition mobility-model.h:29
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition net-device-container.h:32
ns3::NetDeviceContainer::Begin
Iterator Begin() const
Get an iterator which refers to the first NetDevice in the container.
Definition net-device-container.cc:38
ns3::NetDeviceContainer::End
Iterator End() const
Get an iterator which indicates past-the-last NetDevice in the container.
Definition net-device-container.cc:44
ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition net-device-container.cc:56
ns3::NodeContainer
keep track of a set of node pointers.
Definition node-container.h:29
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:73
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:67
ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition object.h:511
ns3::ObjectPtrContainerValue
Container for a set of ns3::Object pointers.
Definition object-ptr-container.h:46
ns3::ObjectPtrContainerValue::GetN
std::size_t GetN() const
Get the number of Objects.
Definition object-ptr-container.cc:43
ns3::ObjectPtrContainerValue::End
Iterator End() const
Get an iterator to the past-the-end Object.
Definition object-ptr-container.cc:36
ns3::ObjectPtrContainerValue::Begin
Iterator Begin() const
Get an iterator to the first Object.
Definition object-ptr-container.cc:29
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition mpi-test-fixtures.h:37
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition simulator.h:560
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:131
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition simulator.cc:167
ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition simulator.cc:175
ns3::TestCase
encapsulates test code
Definition test.h:1050
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition test.cc:292
ns3::TestCase::GetName
std::string GetName() const
Definition test.cc:367
ns3::TestSuite
A suite of tests to run.
Definition test.h:1267
ns3::TestSuite::Type
Type
Type of test.
Definition test.h:1274
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
ns3::UeManager::State
State
The state of the UeManager at the eNB RRC.
Definition lte-enb-rrc.h:67
ns3::UintegerValue
Hold an unsigned integer type.
Definition uinteger.h:34
uint32_t
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition assert.h:55
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition assert.h:75
ns3::Config::Reset
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
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition config.cc:883
ns3::Config::Connect
void Connect(std::string path, const CallbackBase &cb)
Definition config.cc:967
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
NS_LOG_LOGIC
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition log.h:271
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition log-macros-enabled.h:229
NS_LOG_WARN
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition log.h:250
g_lteRrcTestSuiteInstance
static LteRrcTestSuite g_lteRrcTestSuiteInstance
Static variable for test initialization.
Definition test-lte-rrc.cc:885
ns3::CreateObject
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619
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:134
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1308
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1320
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::MakeCallback
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