A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-test-ue-measurements.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: Manuel Requena <manuel.requena@cttc.es>
18 * Nicola Baldo <nbaldo@cttc.es>
19 * Marco Miozzo <mmiozzo@cttc.es>
20 * Budiarto Herman <budiarto.herman@magister.fi>
21 */
22
23#include "lte-test-ue-measurements.h"
24
25#include <ns3/boolean.h>
26#include <ns3/callback.h>
27#include <ns3/config.h>
28#include <ns3/double.h>
29#include <ns3/enum.h>
30#include <ns3/ff-mac-scheduler.h>
31#include <ns3/internet-stack-helper.h>
32#include <ns3/ipv4-address-helper.h>
33#include <ns3/ipv4-interface-container.h>
34#include <ns3/ipv4-static-routing-helper.h>
35#include <ns3/log.h>
36#include <ns3/lte-common.h>
37#include <ns3/lte-enb-net-device.h>
38#include <ns3/lte-enb-phy.h>
39#include <ns3/lte-enb-rrc.h>
40#include <ns3/lte-helper.h>
41#include <ns3/lte-ue-net-device.h>
42#include <ns3/lte-ue-phy.h>
43#include <ns3/lte-ue-rrc.h>
44#include <ns3/mobility-helper.h>
45#include <ns3/net-device-container.h>
46#include <ns3/node-container.h>
47#include <ns3/point-to-point-epc-helper.h>
48#include <ns3/point-to-point-helper.h>
49#include <ns3/simulator.h>
50#include <ns3/string.h>
51
52using namespace ns3;
53
54NS_LOG_COMPONENT_DEFINE("LteUeMeasurementsTest");
55
56// ===== LTE-UE-MEASUREMENTS TEST SUITE ==================================== //
57
58void
59ReportUeMeasurementsCallback(LteUeMeasurementsTestCase* testcase,
60 std::string path,
61 uint16_t rnti,
62 uint16_t cellId,
63 double rsrp,
64 double rsrq,
65 bool servingCell,
66 uint8_t componentCarrierId)
67{
68 testcase->ReportUeMeasurements(rnti, cellId, rsrp, rsrq, servingCell);
69}
70
71void
72RecvMeasurementReportCallback(LteUeMeasurementsTestCase* testcase,
73 std::string path,
74 uint64_t imsi,
75 uint16_t cellId,
76 uint16_t rnti,
77 LteRrcSap::MeasurementReport meas)
78{
79 testcase->RecvMeasurementReport(imsi, cellId, rnti, meas);
80}
81
82/*
83 * Test Suite
84 */
85
86LteUeMeasurementsTestSuite::LteUeMeasurementsTestSuite()
87 : TestSuite("lte-ue-measurements", SYSTEM)
88{
89 AddTestCase(new LteUeMeasurementsTestCase("d1=10, d2=10000",
90 10.000000,
91 10000.000000,
92 -53.739702,
93 -113.739702,
94 -3.010305,
95 -63.010305),
96 TestCase::EXTENSIVE);
97 AddTestCase(new LteUeMeasurementsTestCase("d1=20, d2=10000",
98 20.000000,
99 10000.000000,
100 -59.760302,
101 -113.739702,
102 -3.010319,
103 -56.989719),
104 TestCase::EXTENSIVE);
105 AddTestCase(new LteUeMeasurementsTestCase("d1=50, d2=10000",
106 50.000000,
107 10000.000000,
108 -67.719102,
109 -113.739702,
110 -3.010421,
111 -49.031021),
112 TestCase::EXTENSIVE);
113 AddTestCase(new LteUeMeasurementsTestCase("d1=100, d2=10000",
114 100.000000,
115 10000.000000,
116 -73.739702,
117 -113.739702,
118 -3.010783,
119 -43.010783),
120 TestCase::EXTENSIVE);
121 AddTestCase(new LteUeMeasurementsTestCase("d1=200, d2=10000",
122 200.000000,
123 10000.000000,
124 -79.760302,
125 -113.739702,
126 -3.012232,
127 -36.991632),
128 TestCase::EXTENSIVE);
129 AddTestCase(new LteUeMeasurementsTestCase("d1=100, d2=10000",
130 100.000000,
131 10000.000000,
132 -73.739702,
133 -113.739702,
134 -3.010783,
135 -43.010783),
136 TestCase::EXTENSIVE);
137 AddTestCase(new LteUeMeasurementsTestCase("d1=200, d2=10000",
138 200.000000,
139 10000.000000,
140 -79.760302,
141 -113.739702,
142 -3.012232,
143 -36.991632),
144 TestCase::EXTENSIVE);
145 AddTestCase(new LteUeMeasurementsTestCase("d1=500, d2=10000",
146 500.000000,
147 10000.000000,
148 -87.719102,
149 -113.739702,
150 -3.022359,
151 -29.042959),
152 TestCase::EXTENSIVE);
153 AddTestCase(new LteUeMeasurementsTestCase("d1=1000, d2=10000",
154 1000.000000,
155 10000.000000,
156 -93.739702,
157 -113.739702,
158 -3.058336,
159 -23.058336),
160 TestCase::EXTENSIVE);
161 AddTestCase(new LteUeMeasurementsTestCase("d1=2000, d2=10000",
162 2000.000000,
163 10000.000000,
164 -99.760302,
165 -113.739702,
166 -3.199337,
167 -17.178738),
168 TestCase::EXTENSIVE);
169 AddTestCase(new LteUeMeasurementsTestCase("d1=5000, d2=10000",
170 5000.000000,
171 10000.000000,
172 -107.719102,
173 -113.739702,
174 -4.075793,
175 -10.096393),
176 TestCase::QUICK);
177 AddTestCase(new LteUeMeasurementsTestCase("d1=10000, d2=10000",
178 10000.000000,
179 10000.000000,
180 -113.739702,
181 -113.739702,
182 -6.257687,
183 -6.257687),
184 TestCase::EXTENSIVE);
185 AddTestCase(new LteUeMeasurementsTestCase("d1=20000, d2=10000",
186 20000.000000,
187 10000.000000,
188 -119.760302,
189 -113.739702,
190 -10.373365,
191 -4.352765),
192 TestCase::EXTENSIVE);
193 AddTestCase(new LteUeMeasurementsTestCase("d1=50000, d2=10000",
194 50000.000000,
195 10000.000000,
196 -127.719102,
197 -113.739702,
198 -17.605046,
199 -3.625645),
200 TestCase::EXTENSIVE);
201 AddTestCase(new LteUeMeasurementsTestCase("d1=100000, d2=10000",
202 100000.000000,
203 10000.000000,
204 -133.739702,
205 -113.739702,
206 -23.511071,
207 -3.511071),
208 TestCase::EXTENSIVE);
209 AddTestCase(new LteUeMeasurementsTestCase("d1=200000, d2=10000",
210 200000.000000,
211 10000.000000,
212 -139.760302,
213 -113.739702,
214 -29.502549,
215 -3.481949),
216 TestCase::EXTENSIVE);
217 AddTestCase(new LteUeMeasurementsTestCase("d1=500000, d2=10000",
218 500000.000000,
219 10000.000000,
220 -147.719102,
221 -113.739702,
222 -37.453160,
223 -3.473760),
224 TestCase::EXTENSIVE);
225 AddTestCase(new LteUeMeasurementsTestCase("d1=1000000, d2=10000",
226 1000000.000000,
227 10000.000000,
228 -153.739702,
229 -113.739702,
230 -43.472589,
231 -3.472589),
232 TestCase::EXTENSIVE);
233}
234
239static LteUeMeasurementsTestSuite lteUeMeasurementsTestSuite;
240
241/*
242 * Test Case
243 */
244
245LteUeMeasurementsTestCase::LteUeMeasurementsTestCase(std::string name,
246 double d1,
247 double d2,
248 double rsrpDbmUe1,
249 double rsrpDbmUe2,
250 double rsrqDbUe1,
251 double rsrqDbUe2)
252 : TestCase(name),
253 m_d1(d1),
254 m_d2(d2),
255 m_rsrpDbmUeServingCell(rsrpDbmUe1),
256 m_rsrpDbmUeNeighborCell(rsrpDbmUe2),
257 m_rsrqDbUeServingCell(rsrqDbUe1),
258 m_rsrqDbUeNeighborCell(rsrqDbUe2)
259{
260 NS_LOG_INFO("Test UE Measurements d1 = " << d1 << " m. and d2 = " << d2 << " m.");
261}
262
263LteUeMeasurementsTestCase::~LteUeMeasurementsTestCase()
264{
265}
266
267void
268LteUeMeasurementsTestCase::DoRun()
269{
270 NS_LOG_INFO(this << " " << GetName());
271
272 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
273 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
274 Config::SetDefault("ns3::LteAmc::AmcModel", EnumValue(LteAmc::PiroEW2010));
275 Config::SetDefault("ns3::LteAmc::Ber", DoubleValue(0.00005));
276 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
277 lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisSpectrumPropagationLossModel"));
278 lteHelper->SetAttribute("UseIdealRrc", BooleanValue(false));
279
280 // Disable Uplink Power Control
281 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));
282
283 // LogComponentEnable ("LteUeMeasurementsTest", LOG_LEVEL_ALL);
284
285 // Create Nodes: eNodeB and UE
286 NodeContainer enbNodes;
287 NodeContainer ueNodes1;
288 NodeContainer ueNodes2;
289 enbNodes.Create(2);
290 ueNodes1.Create(1);
291 ueNodes2.Create(1);
292 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes1, ueNodes2);
293
294 // the topology is the following:
295 // d2
296 // UE1-----------eNB2
297 // | |
298 // d1| |d1
299 // | d2 |
300 // eNB1----------UE2
301 //
302 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
303 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
304 positionAlloc->Add(Vector(m_d2, m_d1, 0.0)); // eNB2
305 positionAlloc->Add(Vector(0.0, m_d1, 0.0)); // UE1
306 positionAlloc->Add(Vector(m_d2, 0.0, 0.0)); // UE2
307 MobilityHelper mobility;
308 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
309 mobility.SetPositionAllocator(positionAlloc);
310 mobility.Install(allNodes);
311
312 // Create Devices and install them in the Nodes (eNB and UE)
313 NetDeviceContainer enbDevs;
314 NetDeviceContainer ueDevs1;
315 NetDeviceContainer ueDevs2;
316 lteHelper->SetSchedulerType("ns3::RrFfMacScheduler");
317 lteHelper->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
318 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
319 ueDevs1 = lteHelper->InstallUeDevice(ueNodes1);
320 ueDevs2 = lteHelper->InstallUeDevice(ueNodes2);
321
322 // Attach UEs to eNodeBs
323 lteHelper->Attach(ueDevs1, enbDevs.Get(0));
324 lteHelper->Attach(ueDevs2, enbDevs.Get(1));
325
326 // Activate an EPS bearer
327 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
328 EpsBearer bearer(q);
329 lteHelper->ActivateDataRadioBearer(ueDevs1, bearer);
330 lteHelper->ActivateDataRadioBearer(ueDevs2, bearer);
331
332 Config::Connect(
333 "/NodeList/2/DeviceList/0/ComponentCarrierMapUe/0/LteUePhy/ReportUeMeasurements",
334 MakeBoundCallback(&ReportUeMeasurementsCallback, this));
335 Config::Connect("/NodeList/0/DeviceList/0/LteEnbRrc/RecvMeasurementReport",
336 MakeBoundCallback(&RecvMeasurementReportCallback, this));
337
338 Config::Connect(
339 "/NodeList/3/DeviceList/0/ComponentCarrierMapUe/0/LteUePhy/ReportUeMeasurements",
340 MakeBoundCallback(&ReportUeMeasurementsCallback, this));
341 Config::Connect("/NodeList/1/DeviceList/0/LteEnbRrc/RecvMeasurementReport",
342 MakeBoundCallback(&RecvMeasurementReportCallback, this));
343
344 // need to allow for RRC connection establishment + SRS
345 Simulator::Stop(Seconds(0.800));
346 Simulator::Run();
347
348 Simulator::Destroy();
349}
350
351void
352LteUeMeasurementsTestCase::ReportUeMeasurements(uint16_t rnti,
353 uint16_t cellId,
354 double rsrp,
355 double rsrq,
356 bool servingCell)
357{
358 // need to allow for RRC connection establishment + CQI feedback reception + UE measurements
359 // filtering (200 ms)
360 if (Simulator::Now() > MilliSeconds(400))
361 {
362 if (servingCell)
363 {
364 NS_LOG_DEBUG("UE serving cellId " << cellId << " Rxed RSRP " << rsrp << " thr "
365 << m_rsrpDbmUeServingCell << " RSRQ " << rsrq
366 << " thr " << m_rsrqDbUeServingCell);
367 NS_TEST_ASSERT_MSG_EQ_TOL(m_rsrpDbmUeServingCell, rsrp, 0.2, "Wrong RSRP UE 1");
368 NS_TEST_ASSERT_MSG_EQ_TOL(m_rsrqDbUeServingCell, rsrq, 0.2, "Wrong RSRQ UE 1");
369 }
370 else
371 {
372 NS_LOG_DEBUG("UE neighbor cellId " << cellId << " Rxed RSRP " << rsrp << " thr "
373 << m_rsrpDbmUeNeighborCell << " RSRQ " << rsrq
374 << " thr " << m_rsrqDbUeNeighborCell);
375 NS_TEST_ASSERT_MSG_EQ_TOL(m_rsrpDbmUeNeighborCell, rsrp, 0.2, "Wrong RSRP UE 2");
376 NS_TEST_ASSERT_MSG_EQ_TOL(m_rsrqDbUeNeighborCell, rsrq, 0.2, "Wrong RSRQ UE ");
377 }
378 }
379}
380
381void
382LteUeMeasurementsTestCase::RecvMeasurementReport(uint64_t imsi,
383 uint16_t cellId,
384 uint16_t rnti,
385 LteRrcSap::MeasurementReport meas)
386{
387 // need to allow for RRC connection establishment + CQI feedback reception + UE measurements
388 // filtering (200 ms)
389 if (Simulator::Now() > MilliSeconds(400))
390 {
391 if (cellId == imsi)
392 {
393 NS_LOG_DEBUG(
394 this << "Serving Cell: received IMSI " << imsi << " CellId " << cellId << " RNTI "
395 << rnti << " thr "
396 << (uint16_t)EutranMeasurementMapping::Dbm2RsrpRange(m_rsrpDbmUeServingCell)
397 << " RSRP " << (uint16_t)meas.measResults.measResultPCell.rsrpResult
398 << " RSRQ " << (uint16_t)meas.measResults.measResultPCell.rsrqResult << " thr "
399 << (uint16_t)EutranMeasurementMapping::Db2RsrqRange(m_rsrqDbUeServingCell));
400 NS_TEST_ASSERT_MSG_EQ(meas.measResults.measResultPCell.rsrpResult,
401 EutranMeasurementMapping::Dbm2RsrpRange(m_rsrpDbmUeServingCell),
402 "Wrong RSRP ");
403 NS_TEST_ASSERT_MSG_EQ(meas.measResults.measResultPCell.rsrqResult,
404 EutranMeasurementMapping::Db2RsrqRange(m_rsrqDbUeServingCell),
405 "Wrong RSRQ ");
406 }
407 else
408 {
409 NS_LOG_DEBUG(
410 this << "Neighbor cell: received IMSI " << imsi << " CellId " << cellId << " RNTI "
411 << rnti << " thr "
412 << (uint16_t)EutranMeasurementMapping::Dbm2RsrpRange(m_rsrpDbmUeNeighborCell)
413 << " RSRP " << (uint16_t)meas.measResults.measResultPCell.rsrpResult
414 << " RSRQ " << (uint16_t)meas.measResults.measResultPCell.rsrqResult << " thr "
415 << (uint16_t)EutranMeasurementMapping::Db2RsrqRange(m_rsrqDbUeNeighborCell));
416 NS_TEST_ASSERT_MSG_EQ(meas.measResults.measResultPCell.rsrpResult,
417 EutranMeasurementMapping::Dbm2RsrpRange(m_rsrpDbmUeNeighborCell),
418 "Wrong RSRP ");
419 NS_TEST_ASSERT_MSG_EQ(meas.measResults.measResultPCell.rsrqResult,
420 EutranMeasurementMapping::Db2RsrqRange(m_rsrqDbUeNeighborCell),
421 "Wrong RSRQ ");
422 }
423 }
424}
425
426// ===== LTE-UE-MEASUREMENTS-PIECEWISE-1 TEST SUITE ======================== //
427
428/*
429 * Overloaded operators, for the convenience of defining test cases
430 */
431
432std::vector<Time>&
433operator<<(std::vector<Time>& v, const uint64_t& ms)
434{
435 /*
436 * Prior attempt to use seconds as unit of choice resulted in precision lost.
437 * Therefore milliseconds are used now instead.
438 */
439 v.push_back(MilliSeconds(ms) + UE_MEASUREMENT_REPORT_DELAY);
440 return v;
441}
442
443std::vector<uint8_t>&
444operator<<(std::vector<uint8_t>& v, const uint8_t& range)
445{
446 v.push_back(range);
447 return v;
448}
449
450/*
451 * Test Suite
452 */
453
454LteUeMeasurementsPiecewiseTestSuite1::LteUeMeasurementsPiecewiseTestSuite1()
455 : TestSuite("lte-ue-measurements-piecewise-1", SYSTEM)
456{
457 std::vector<Time> expectedTime;
458 std::vector<uint8_t> expectedRsrp;
459
460 // === Event A1 (serving cell becomes better than threshold) ===
461
462 // With very low threshold
463 LteRrcSap::ReportConfigEutra config;
464 config.triggerType = LteRrcSap::ReportConfigEutra::EVENT;
465 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
466 config.threshold1.choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP;
467 config.threshold1.range = 0;
468 config.triggerQuantity = LteRrcSap::ReportConfigEutra::RSRP;
469 config.reportInterval = LteRrcSap::ReportConfigEutra::MS120;
470 expectedTime.clear();
471 expectedTime << 200 << 320 << 440 << 560 << 680 << 800 << 920 << 1040 << 1160 << 1280 << 1400
472 << 1520 << 1640 << 1760 << 1880 << 2000 << 2120;
473 expectedRsrp.clear();
474 expectedRsrp << 67 << 67 << 57 << 57 << 66 << 47 << 47 << 66 << 66 << 57 << 51 << 51 << 47 << 47
475 << 51 << 57 << 57;
476 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
477 "Piecewise test case 1 - Event A1 with very low threshold",
478 config,
479 expectedTime,
480 expectedRsrp),
481 TestCase::EXTENSIVE);
482
483 // With normal threshold
484 config.threshold1.range = 54;
485 expectedTime.clear();
486 expectedTime << 200 << 320 << 440 << 560 << 680 << 1000 << 1120 << 1240 << 1360 << 2000 << 2120;
487 expectedRsrp.clear();
488 expectedRsrp << 67 << 67 << 57 << 57 << 66 << 66 << 66 << 57 << 57 << 57 << 57;
489 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
490 "Piecewise test case 1 - Event A1 with normal threshold",
491 config,
492 expectedTime,
493 expectedRsrp),
494 TestCase::EXTENSIVE);
495
496 // With short time-to-trigger
497 config.timeToTrigger = 64;
498 expectedTime.clear();
499 expectedTime << 264 << 384 << 504 << 624 << 744 << 1064 << 1184 << 1304 << 1424 << 2064 << 2184;
500 expectedRsrp.clear();
501 expectedRsrp << 67 << 67 << 57 << 66 << 66 << 66 << 66 << 57 << 51 << 57 << 57;
502 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
503 "Piecewise test case 1 - Event A1 with short time-to-trigger",
504 config,
505 expectedTime,
506 expectedRsrp),
507 TestCase::QUICK);
508
509 // With long time-to-trigger
510 config.timeToTrigger = 128;
511 expectedTime.clear();
512 expectedTime << 328 << 448 << 568 << 688 << 808 << 1128 << 1248 << 1368 << 1488 << 2128;
513 expectedRsrp.clear();
514 expectedRsrp << 67 << 57 << 57 << 66 << 47 << 66 << 57 << 57 << 51 << 57;
515 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
516 "Piecewise test case 1 - Event A1 with long time-to-trigger",
517 config,
518 expectedTime,
519 expectedRsrp),
520 TestCase::EXTENSIVE);
521
522 // With super time-to-trigger
523 config.timeToTrigger = 256;
524 expectedTime.clear();
525 expectedTime << 456 << 576 << 696 << 816 << 936 << 1056 << 1176 << 1296 << 1416 << 1536;
526 expectedRsrp.clear();
527 expectedRsrp << 57 << 57 << 66 << 47 << 47 << 66 << 66 << 57 << 51 << 51;
528 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
529 "Piecewise test case 1 - Event A1 with super time-to-trigger",
530 config,
531 expectedTime,
532 expectedRsrp),
533 TestCase::EXTENSIVE);
534
535 // With hysteresis
536 config.hysteresis = 8;
537 config.timeToTrigger = 0;
538 expectedTime.clear();
539 expectedTime << 200 << 320 << 440 << 560 << 680 << 1000 << 1120 << 1240 << 1360 << 1480 << 2200;
540 expectedRsrp.clear();
541 expectedRsrp << 67 << 67 << 57 << 57 << 66 << 66 << 66 << 57 << 57 << 51 << 67;
542 AddTestCase(
543 new LteUeMeasurementsPiecewiseTestCase1("Piecewise test case 1 - Event A1 with hysteresis",
544 config,
545 expectedTime,
546 expectedRsrp),
547 TestCase::QUICK);
548
549 // With very high threshold
550 config.threshold1.range = 97;
551 config.hysteresis = 0;
552 expectedTime.clear();
553 expectedRsrp.clear();
554 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
555 "Piecewise test case 1 - Event A1 with very high threshold",
556 config,
557 expectedTime,
558 expectedRsrp),
559 TestCase::TAKES_FOREVER);
560
561 // === Event A2 (serving cell becomes worse than threshold) ===
562
563 // With very low threshold
564 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;
565 config.threshold1.range = 0;
566 expectedTime.clear();
567 expectedRsrp.clear();
568 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
569 "Piecewise test case 1 - Event A2 with very low threshold",
570 config,
571 expectedTime,
572 expectedRsrp),
573 TestCase::TAKES_FOREVER);
574
575 // With normal threshold
576 config.threshold1.range = 54;
577 expectedTime.clear();
578 expectedTime << 800 << 920 << 1400 << 1520 << 1640 << 1760 << 1880;
579 expectedRsrp.clear();
580 expectedRsrp << 47 << 47 << 51 << 51 << 47 << 47 << 51;
581 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
582 "Piecewise test case 1 - Event A2 with normal threshold",
583 config,
584 expectedTime,
585 expectedRsrp),
586 TestCase::QUICK);
587
588 // With short time-to-trigger
589 config.timeToTrigger = 64;
590 expectedTime.clear();
591 expectedTime << 864 << 984 << 1464 << 1584 << 1704 << 1824 << 1944;
592 expectedRsrp.clear();
593 expectedRsrp << 47 << 47 << 51 << 51 << 47 << 51 << 51;
594 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
595 "Piecewise test case 1 - Event A2 with short time-to-trigger",
596 config,
597 expectedTime,
598 expectedRsrp),
599 TestCase::EXTENSIVE);
600
601 // With long time-to-trigger
602 config.timeToTrigger = 128;
603 expectedTime.clear();
604 expectedTime << 928 << 1048 << 1528 << 1648 << 1768 << 1888 << 2008;
605 expectedRsrp.clear();
606 expectedRsrp << 47 << 66 << 51 << 47 << 47 << 51 << 57;
607 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
608 "Piecewise test case 1 - Event A2 with long time-to-trigger",
609 config,
610 expectedTime,
611 expectedRsrp),
612 TestCase::TAKES_FOREVER);
613
614 // With super time-to-trigger
615 config.timeToTrigger = 256;
616 expectedTime.clear();
617 expectedTime << 1656 << 1776 << 1896 << 2016 << 2136;
618 expectedRsrp.clear();
619 expectedRsrp << 47 << 47 << 51 << 57 << 57;
620 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
621 "Piecewise test case 1 - Event A2 with super time-to-trigger",
622 config,
623 expectedTime,
624 expectedRsrp),
625 TestCase::QUICK);
626
627 // With hysteresis
628 config.hysteresis = 8;
629 config.timeToTrigger = 0;
630 expectedTime.clear();
631 expectedTime << 800 << 920 << 1600 << 1720 << 1840 << 1960 << 2080;
632 expectedRsrp.clear();
633 expectedRsrp << 47 << 47 << 47 << 47 << 51 << 51 << 57;
634 AddTestCase(
635 new LteUeMeasurementsPiecewiseTestCase1("Piecewise test case 1 - Event A2 with hysteresis",
636 config,
637 expectedTime,
638 expectedRsrp),
639 TestCase::EXTENSIVE);
640
641 // With very high threshold
642 config.threshold1.range = 97;
643 config.hysteresis = 0;
644 expectedTime.clear();
645 expectedTime << 200 << 320 << 440 << 560 << 680 << 800 << 920 << 1040 << 1160 << 1280 << 1400
646 << 1520 << 1640 << 1760 << 1880 << 2000 << 2120;
647 expectedRsrp.clear();
648 expectedRsrp << 67 << 67 << 57 << 57 << 66 << 47 << 47 << 66 << 66 << 57 << 51 << 51 << 47 << 47
649 << 51 << 57 << 57;
650 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1(
651 "Piecewise test case 1 - Event A2 with very high threshold",
652 config,
653 expectedTime,
654 expectedRsrp),
655 TestCase::EXTENSIVE);
656
657 /*
658 * Event A3, A4, and A5 are not tested intensively here because they depend on
659 * the existence of at least one neighbouring cell, which is not available in
660 * this configuration. Piecewise configuration #2 includes a neighbouring
661 * cell, hence more thorough tests on these events are performed there.
662 */
663
664 expectedTime.clear();
665 expectedRsrp.clear();
666
667 // === Event A3 (neighbour becomes offset better than PCell) ===
668
669 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;
670 config.a3Offset = 0;
671 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1("Piecewise test case 1 - Event A3",
672 config,
673 expectedTime,
674 expectedRsrp),
675 TestCase::EXTENSIVE);
676
677 // === Event A4 (neighbour becomes better than threshold) ===
678
679 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
680 config.threshold1.range = 54;
681 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1("Piecewise test case 1 - Event A4",
682 config,
683 expectedTime,
684 expectedRsrp),
685 TestCase::EXTENSIVE);
686
687 // === Event A5 (PCell becomes worse than absolute threshold1 AND neighbour becomes better than
688 // another absolute threshold2) ===
689
690 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A5;
691 config.threshold2.range = 58;
692 AddTestCase(new LteUeMeasurementsPiecewiseTestCase1("Piecewise test case 1 - Event A5",
693 config,
694 expectedTime,
695 expectedRsrp),
696 TestCase::EXTENSIVE);
697
698} // end of LteUeMeasurementsPiecewiseTestSuite1::LteUeMeasurementsPiecewiseTestSuite1
699
704static LteUeMeasurementsPiecewiseTestSuite1 lteUeMeasurementsPiecewiseTestSuite1;
705
706/*
707 * Test Case
708 */
709
710LteUeMeasurementsPiecewiseTestCase1::LteUeMeasurementsPiecewiseTestCase1(
711 std::string name,
712 LteRrcSap::ReportConfigEutra config,
713 std::vector<Time> expectedTime,
714 std::vector<uint8_t> expectedRsrp)
715 : TestCase(name),
716 m_config(config),
717 m_expectedTime(expectedTime),
718 m_expectedRsrp(expectedRsrp)
719{
720 // input sanity check
721 uint16_t size = m_expectedTime.size();
722
723 if (size != m_expectedRsrp.size())
724 {
725 NS_FATAL_ERROR("Vectors of expected results are not of the same size");
726 }
727
728 m_itExpectedTime = m_expectedTime.begin();
729 m_itExpectedRsrp = m_expectedRsrp.begin();
730
731 NS_LOG_INFO(this << " name=" << name);
732}
733
734LteUeMeasurementsPiecewiseTestCase1::~LteUeMeasurementsPiecewiseTestCase1()
735{
736 NS_LOG_FUNCTION(this);
737}
738
739void
740LteUeMeasurementsPiecewiseTestCase1::DoRun()
741{
742 NS_LOG_INFO(this << " " << GetName());
743
744 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
745 lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisSpectrumPropagationLossModel"));
746 lteHelper->SetAttribute("UseIdealRrc", BooleanValue(true));
747
748 // Disable Uplink Power Control
749 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));
750
751 // Create Nodes: eNodeB and UE
752 NodeContainer enbNodes;
753 NodeContainer ueNodes;
754 enbNodes.Create(1);
755 ueNodes.Create(1);
756
757 /*
758 * The topology is the following:
759 *
760 * eNodeB UE
761 * | |
762 * x ----- x --------- x --------------- x ------------------- x
763 * 100 m | 200 m | 300 m | 400 m |
764 * | | | |
765 * VeryNear Near Far VeryFar
766 */
767
768 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
769 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNodeB
770 positionAlloc->Add(Vector(100.0, 0.0, 0.0)); // UE
771 MobilityHelper mobility;
772 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
773 mobility.SetPositionAllocator(positionAlloc);
774 mobility.Install(enbNodes);
775 mobility.Install(ueNodes);
776 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
777
778 // Disable layer-3 filtering
779 Config::SetDefault("ns3::LteEnbRrc::RsrpFilterCoefficient", UintegerValue(0));
780
781 // Create Devices and install them in the Nodes (eNB and UE)
782 NetDeviceContainer enbDevs;
783 NetDeviceContainer ueDevs;
784 lteHelper->SetSchedulerType("ns3::RrFfMacScheduler");
785 lteHelper->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
786 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
787 ueDevs = lteHelper->InstallUeDevice(ueNodes);
788
789 // Setup UE measurement configuration
790 Ptr<LteEnbRrc> enbRrc = enbDevs.Get(0)->GetObject<LteEnbNetDevice>()->GetRrc();
791 m_expectedMeasId = enbRrc->AddUeMeasReportConfig(m_config).at(0);
792
793 // Attach UE to eNodeB
794 lteHelper->Attach(ueDevs.Get(0), enbDevs.Get(0));
795
796 // Activate an EPS bearer
797 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
798 EpsBearer bearer(q);
799 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
800
801 // Connect to trace sources
802 Config::Connect(
803 "/NodeList/0/DeviceList/0/LteEnbRrc/RecvMeasurementReport",
804 MakeCallback(&LteUeMeasurementsPiecewiseTestCase1::RecvMeasurementReportCallback, this));
805
806 /*
807 * Schedule "teleports"
808 * 0 1 2
809 * +-------------------+-------------------+---------> time
810 * VeryNear |------ ---- ---- --------
811 * Near | ---- ----
812 * Far | ---- ----
813 * VeryFar | -- ---- ----
814 */
815 Simulator::Schedule(MilliSeconds(301),
816 &LteUeMeasurementsPiecewiseTestCase1::TeleportVeryFar,
817 this);
818 Simulator::Schedule(MilliSeconds(401),
819 &LteUeMeasurementsPiecewiseTestCase1::TeleportVeryNear,
820 this);
821 Simulator::Schedule(MilliSeconds(601),
822 &LteUeMeasurementsPiecewiseTestCase1::TeleportVeryFar,
823 this);
824 Simulator::Schedule(MilliSeconds(801),
825 &LteUeMeasurementsPiecewiseTestCase1::TeleportVeryNear,
826 this);
827 Simulator::Schedule(MilliSeconds(1001),
828 &LteUeMeasurementsPiecewiseTestCase1::TeleportNear,
829 this);
830 Simulator::Schedule(MilliSeconds(1201),
831 &LteUeMeasurementsPiecewiseTestCase1::TeleportFar,
832 this);
833 Simulator::Schedule(MilliSeconds(1401),
834 &LteUeMeasurementsPiecewiseTestCase1::TeleportVeryFar,
835 this);
836 Simulator::Schedule(MilliSeconds(1601),
837 &LteUeMeasurementsPiecewiseTestCase1::TeleportFar,
838 this);
839 Simulator::Schedule(MilliSeconds(1801),
840 &LteUeMeasurementsPiecewiseTestCase1::TeleportNear,
841 this);
842 Simulator::Schedule(MilliSeconds(2001),
843 &LteUeMeasurementsPiecewiseTestCase1::TeleportVeryNear,
844 this);
845
846 // Run simulation
847 Simulator::Stop(Seconds(2.201));
848 Simulator::Run();
849 Simulator::Destroy();
850
851} // end of void LteUeMeasurementsPiecewiseTestCase1::DoRun ()
852
853void
854LteUeMeasurementsPiecewiseTestCase1::DoTeardown()
855{
856 NS_LOG_FUNCTION(this);
857 bool hasEnded = m_itExpectedTime == m_expectedTime.end();
858 NS_TEST_ASSERT_MSG_EQ(hasEnded,
859 true,
860 "Reporting should have occurred at " << m_itExpectedTime->As(Time::S));
861 hasEnded = m_itExpectedRsrp == m_expectedRsrp.end();
862 NS_ASSERT(hasEnded);
863}
864
865void
866LteUeMeasurementsPiecewiseTestCase1::RecvMeasurementReportCallback(
867 std::string context,
868 uint64_t imsi,
869 uint16_t cellId,
870 uint16_t rnti,
871 LteRrcSap::MeasurementReport report)
872{
873 NS_LOG_FUNCTION(this << context);
874 NS_ASSERT(rnti == 1);
875 NS_ASSERT(cellId == 1);
876
877 if (report.measResults.measId == m_expectedMeasId)
878 {
879 // verifying the report completeness
880 LteRrcSap::MeasResults measResults = report.measResults;
881 NS_LOG_DEBUG(
882 this << " rsrp=" << (uint16_t)measResults.measResultPCell.rsrpResult << " ("
883 << EutranMeasurementMapping::RsrpRange2Dbm(measResults.measResultPCell.rsrpResult)
884 << " dBm)"
885 << " rsrq=" << (uint16_t)measResults.measResultPCell.rsrqResult << " ("
886 << EutranMeasurementMapping::RsrqRange2Db(measResults.measResultPCell.rsrqResult)
887 << " dB)");
888 NS_TEST_ASSERT_MSG_EQ(measResults.haveMeasResultNeighCells,
889 false,
890 "Report should not have neighboring cells information");
891 NS_TEST_ASSERT_MSG_EQ(measResults.measResultListEutra.size(), 0, "Unexpected report size");
892
893 bool hasEnded = m_itExpectedTime == m_expectedTime.end();
894 NS_TEST_ASSERT_MSG_EQ(hasEnded,
895 false,
896 "Reporting should not have occurred at "
897 << Simulator::Now().As(Time::S));
898 if (!hasEnded)
899 {
900 hasEnded = m_itExpectedRsrp == m_expectedRsrp.end();
901 NS_ASSERT(!hasEnded);
902
903 // using milliseconds to avoid floating-point comparison
904 uint64_t timeNowMs = Simulator::Now().GetMilliSeconds();
905 uint64_t timeExpectedMs = m_itExpectedTime->GetMilliSeconds();
906 m_itExpectedTime++;
907
908 uint16_t observedRsrp = measResults.measResultPCell.rsrpResult;
909 uint16_t referenceRsrp = *m_itExpectedRsrp;
910 m_itExpectedRsrp++;
911
912 NS_TEST_ASSERT_MSG_EQ(timeNowMs,
913 timeExpectedMs,
914 "Reporting should not have occurred at this time");
915 NS_TEST_ASSERT_MSG_EQ(observedRsrp,
916 referenceRsrp,
917 "The RSRP observed differs with the reference RSRP");
918 } // end of if (!hasEnded)
919
920 } // end of if (measResults.measId == m_expectedMeasId)
921
922} // end of LteUeMeasurementsPiecewiseTestCase1::RecvMeasurementReportCallback
923
924void
925LteUeMeasurementsPiecewiseTestCase1::TeleportVeryNear()
926{
927 NS_LOG_FUNCTION(this);
928 m_ueMobility->SetPosition(Vector(100.0, 0.0, 0.0));
929}
930
931void
932LteUeMeasurementsPiecewiseTestCase1::TeleportNear()
933{
934 NS_LOG_FUNCTION(this);
935 m_ueMobility->SetPosition(Vector(300.0, 0.0, 0.0));
936}
937
938void
939LteUeMeasurementsPiecewiseTestCase1::TeleportFar()
940{
941 NS_LOG_FUNCTION(this);
942 m_ueMobility->SetPosition(Vector(600.0, 0.0, 0.0));
943}
944
945void
946LteUeMeasurementsPiecewiseTestCase1::TeleportVeryFar()
947{
948 NS_LOG_FUNCTION(this);
949 m_ueMobility->SetPosition(Vector(1000.0, 0.0, 0.0));
950}
951
952// ===== LTE-UE-MEASUREMENTS-PIECEWISE-2 TEST SUITE ======================== //
953
954/*
955 * Test Suite
956 */
957
958LteUeMeasurementsPiecewiseTestSuite2::LteUeMeasurementsPiecewiseTestSuite2()
959 : TestSuite("lte-ue-measurements-piecewise-2", SYSTEM)
960{
961 std::vector<Time> expectedTime;
962 std::vector<uint8_t> expectedRsrp;
963
964 /*
965 * Higher level of fullness/duration are given to Event A1 and A2 because they
966 * are supposed to be more intensively tested in Piecewise configuration #1.
967 */
968
969 // === Event A1 (serving cell becomes better than threshold) ===
970
971 // With very low threshold
972 LteRrcSap::ReportConfigEutra config;
973 config.triggerType = LteRrcSap::ReportConfigEutra::EVENT;
974 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
975 config.threshold1.choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP;
976 config.threshold1.range = 0;
977 config.triggerQuantity = LteRrcSap::ReportConfigEutra::RSRP;
978 config.reportInterval = LteRrcSap::ReportConfigEutra::MS240;
979 expectedTime.clear();
980 expectedTime << 200 << 440 << 680 << 920 << 1160 << 1400 << 1640 << 1880 << 2120;
981 expectedRsrp.clear();
982 expectedRsrp << 73 << 63 << 72 << 52 << 72 << 56 << 52 << 56 << 59;
983 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
984 "Piecewise test case 2 - Event A1 with very low threshold",
985 config,
986 expectedTime,
987 expectedRsrp),
988 TestCase::EXTENSIVE);
989
990 // With normal threshold
991 config.threshold1.range = 58;
992 expectedTime.clear();
993 expectedTime << 200 << 440 << 680 << 1000 << 1240 << 2000;
994 expectedRsrp.clear();
995 expectedRsrp << 73 << 63 << 72 << 72 << 59 << 59;
996 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
997 "Piecewise test case 2 - Event A1 with normal threshold",
998 config,
999 expectedTime,
1000 expectedRsrp),
1001 TestCase::TAKES_FOREVER);
1002
1003 // With hysteresis
1004 config.hysteresis = 6;
1005 expectedTime.clear();
1006 expectedTime << 200 << 440 << 680 << 1000 << 1240 << 1480 << 2200;
1007 expectedRsrp.clear();
1008 expectedRsrp << 73 << 63 << 72 << 72 << 59 << 56 << 72;
1009 AddTestCase(
1010 new LteUeMeasurementsPiecewiseTestCase2("Piecewise test case 2 - Event A1 with hysteresis",
1011 config,
1012 expectedTime,
1013 expectedRsrp),
1014 TestCase::EXTENSIVE);
1015
1016 // With very high threshold
1017 config.threshold1.range = 97;
1018 config.hysteresis = 0;
1019 expectedTime.clear();
1020 expectedRsrp.clear();
1021 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1022 "Piecewise test case 2 - Event A1 with very high threshold",
1023 config,
1024 expectedTime,
1025 expectedRsrp),
1026 TestCase::TAKES_FOREVER);
1027
1028 // === Event A2 (serving cell becomes worse than threshold) ===
1029
1030 // With very low threshold
1031 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;
1032 config.threshold1.range = 0;
1033 expectedTime.clear();
1034 expectedRsrp.clear();
1035 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1036 "Piecewise test case 2 - Event A2 with very low threshold",
1037 config,
1038 expectedTime,
1039 expectedRsrp),
1040 TestCase::TAKES_FOREVER);
1041
1042 // With normal threshold
1043 config.threshold1.range = 58;
1044 expectedTime.clear();
1045 expectedTime << 800 << 1400 << 1640 << 1880;
1046 expectedRsrp.clear();
1047 expectedRsrp << 52 << 56 << 52 << 56;
1048 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1049 "Piecewise test case 2 - Event A2 with normal threshold",
1050 config,
1051 expectedTime,
1052 expectedRsrp),
1053 TestCase::TAKES_FOREVER);
1054
1055 // With hysteresis
1056 config.hysteresis = 6;
1057 expectedTime.clear();
1058 expectedTime << 800 << 1600 << 1840 << 2080;
1059 expectedRsrp.clear();
1060 expectedRsrp << 52 << 52 << 56 << 59;
1061 AddTestCase(
1062 new LteUeMeasurementsPiecewiseTestCase2("Piecewise test case 2 - Event A2 with hysteresis",
1063 config,
1064 expectedTime,
1065 expectedRsrp),
1066 TestCase::EXTENSIVE);
1067
1068 // With very high threshold
1069 config.threshold1.range = 97;
1070 config.hysteresis = 0;
1071 expectedTime.clear();
1072 expectedTime << 200 << 440 << 680 << 920 << 1160 << 1400 << 1640 << 1880 << 2120;
1073 expectedRsrp.clear();
1074 expectedRsrp << 73 << 63 << 72 << 52 << 72 << 56 << 52 << 56 << 59;
1075 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1076 "Piecewise test case 2 - Event A2 with very high threshold",
1077 config,
1078 expectedTime,
1079 expectedRsrp),
1080 TestCase::TAKES_FOREVER);
1081
1082 // === Event A3 (neighbour becomes offset better than PCell) ===
1083
1084 // With positive offset
1085 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;
1086 config.threshold1.range = 0;
1087 config.a3Offset = 7;
1088 expectedTime.clear();
1089 expectedTime << 800 << 1600;
1090 expectedRsrp.clear();
1091 expectedRsrp << 52 << 52;
1092 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1093 "Piecewise test case 2 - Event A3 with positive offset",
1094 config,
1095 expectedTime,
1096 expectedRsrp),
1097 TestCase::QUICK);
1098
1099 // With zero offset
1100 config.a3Offset = 0;
1101 expectedTime.clear();
1102 expectedTime << 800 << 1400 << 1640 << 1880;
1103 expectedRsrp.clear();
1104 expectedRsrp << 52 << 56 << 52 << 56;
1105 AddTestCase(
1106 new LteUeMeasurementsPiecewiseTestCase2("Piecewise test case 2 - Event A3 with zero offset",
1107 config,
1108 expectedTime,
1109 expectedRsrp),
1110 TestCase::EXTENSIVE);
1111
1112 // With short time-to-trigger
1113 config.timeToTrigger = 160;
1114 expectedTime.clear();
1115 expectedTime << 960 << 1560 << 1800 << 2040;
1116 expectedRsrp.clear();
1117 expectedRsrp << 52 << 56 << 56 << 59;
1118 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1119 "Piecewise test case 2 - Event A3 with short time-to-trigger",
1120 config,
1121 expectedTime,
1122 expectedRsrp),
1123 TestCase::EXTENSIVE);
1124
1125 // With super time-to-trigger
1126 config.timeToTrigger = 320;
1127 expectedTime.clear();
1128 expectedTime << 1720 << 1960 << 2200;
1129 expectedRsrp.clear();
1130 expectedRsrp << 52 << 56 << 72;
1131 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1132 "Piecewise test case 2 - Event A3 with super time-to-trigger",
1133 config,
1134 expectedTime,
1135 expectedRsrp),
1136 TestCase::QUICK);
1137
1138 // With hysteresis and reportOnLeave
1139 config.hysteresis = 6;
1140 config.reportOnLeave = true;
1141 config.timeToTrigger = 0;
1142 expectedTime.clear();
1143 expectedTime << 800 << 1000 << 1600 << 1840 << 2080 << 2200;
1144 expectedRsrp.clear();
1145 expectedRsrp << 52 << 72 << 52 << 56 << 59 << 72;
1146 AddTestCase(
1147 new LteUeMeasurementsPiecewiseTestCase2("Piecewise test case 2 - Event A3 with hysteresis",
1148 config,
1149 expectedTime,
1150 expectedRsrp),
1151 TestCase::QUICK);
1152
1153 // With negative offset
1154 config.a3Offset = -7;
1155 config.hysteresis = 0;
1156 config.reportOnLeave = false;
1157 expectedTime.clear();
1158 expectedTime << 400 << 800 << 1200 << 1440 << 1680 << 1920 << 2160;
1159 expectedRsrp.clear();
1160 expectedRsrp << 63 << 52 << 59 << 56 << 52 << 56 << 59;
1161 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1162 "Piecewise test case 2 - Event A3 with negative offset",
1163 config,
1164 expectedTime,
1165 expectedRsrp),
1166 TestCase::EXTENSIVE);
1167
1168 // === Event A4 (neighbour becomes better than threshold) ===
1169
1170 // With very low threshold
1171 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
1172 config.threshold1.range = 0;
1173 config.a3Offset = 0;
1174 expectedTime.clear();
1175 expectedTime << 200 << 440 << 680 << 920 << 1160 << 1400 << 1640 << 1880 << 2120;
1176 expectedRsrp.clear();
1177 expectedRsrp << 73 << 63 << 72 << 52 << 72 << 56 << 52 << 56 << 59;
1178 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1179 "Piecewise test case 2 - Event A4 with very low threshold",
1180 config,
1181 expectedTime,
1182 expectedRsrp),
1183 TestCase::QUICK);
1184
1185 // With normal threshold
1186 config.threshold1.range = 58;
1187 expectedTime.clear();
1188 expectedTime << 400 << 800 << 1400 << 1640 << 1880;
1189 expectedRsrp.clear();
1190 expectedRsrp << 63 << 52 << 56 << 52 << 56;
1191 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1192 "Piecewise test case 2 - Event A4 with normal threshold",
1193 config,
1194 expectedTime,
1195 expectedRsrp),
1196 TestCase::EXTENSIVE);
1197
1198 // With short time-to-trigger
1199 config.timeToTrigger = 160;
1200 expectedTime.clear();
1201 expectedTime << 560 << 960 << 1560 << 1800 << 2040;
1202 expectedRsrp.clear();
1203 expectedRsrp << 63 << 52 << 56 << 56 << 59;
1204 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1205 "Piecewise test case 2 - Event A4 with short time-to-trigger",
1206 config,
1207 expectedTime,
1208 expectedRsrp),
1209 TestCase::QUICK);
1210
1211 // With super time-to-trigger
1212 config.timeToTrigger = 320;
1213 expectedTime.clear();
1214 expectedTime << 1720 << 1960 << 2200;
1215 expectedRsrp.clear();
1216 expectedRsrp << 52 << 56 << 72;
1217 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1218 "Piecewise test case 2 - Event A4 with super time-to-trigger",
1219 config,
1220 expectedTime,
1221 expectedRsrp),
1222 TestCase::TAKES_FOREVER);
1223
1224 // With hysteresis
1225 config.hysteresis = 6;
1226 config.timeToTrigger = 0;
1227 expectedTime.clear();
1228 expectedTime << 400 << 800 << 1600 << 1840 << 2080;
1229 expectedRsrp.clear();
1230 expectedRsrp << 63 << 52 << 52 << 56 << 59;
1231 AddTestCase(
1232 new LteUeMeasurementsPiecewiseTestCase2("Piecewise test case 2 - Event A4 with hysteresis",
1233 config,
1234 expectedTime,
1235 expectedRsrp),
1236 TestCase::QUICK);
1237
1238 // With very high threshold
1239 config.threshold1.range = 97;
1240 config.hysteresis = 0;
1241 expectedTime.clear();
1242 expectedRsrp.clear();
1243 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1244 "Piecewise test case 2 - Event A4 with very high threshold",
1245 config,
1246 expectedTime,
1247 expectedRsrp),
1248 TestCase::TAKES_FOREVER);
1249
1250 // === Event A5 (PCell becomes worse than absolute threshold1 AND neighbour becomes better than
1251 // another absolute threshold2) ===
1252
1253 // With low-low threshold
1254 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A5;
1255 config.threshold1.range = 0;
1256 config.threshold2.range = 0;
1257 expectedTime.clear();
1258 expectedRsrp.clear();
1259 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1260 "Piecewise test case 2 - Event A5 with low-low threshold",
1261 config,
1262 expectedTime,
1263 expectedRsrp),
1264 TestCase::EXTENSIVE);
1265
1266 // With low-normal threshold
1267 config.threshold2.range = 58;
1268 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1269 "Piecewise test case 2 - Event A5 with low-normal threshold",
1270 config,
1271 expectedTime,
1272 expectedRsrp),
1273 TestCase::TAKES_FOREVER);
1274
1275 // With low-high threshold
1276 config.threshold2.range = 97;
1277 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1278 "Piecewise test case 2 - Event A5 with low-high threshold",
1279 config,
1280 expectedTime,
1281 expectedRsrp),
1282 TestCase::TAKES_FOREVER);
1283
1284 // With normal-low threshold
1285 config.threshold1.range = 58;
1286 config.threshold2.range = 0;
1287 expectedTime.clear();
1288 expectedTime << 800 << 1400 << 1640 << 1880;
1289 expectedRsrp.clear();
1290 expectedRsrp << 52 << 56 << 52 << 56;
1291 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1292 "Piecewise test case 2 - Event A5 with normal-low threshold",
1293 config,
1294 expectedTime,
1295 expectedRsrp),
1296 TestCase::EXTENSIVE);
1297
1298 // With normal-normal threshold
1299 config.threshold2.range = 58;
1300 expectedTime.clear();
1301 expectedTime << 800 << 1400 << 1640 << 1880;
1302 expectedRsrp.clear();
1303 expectedRsrp << 52 << 56 << 52 << 56;
1304 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1305 "Piecewise test case 2 - Event A5 with normal-normal threshold",
1306 config,
1307 expectedTime,
1308 expectedRsrp),
1309 TestCase::EXTENSIVE);
1310
1311 // With short time-to-trigger
1312 config.timeToTrigger = 160;
1313 expectedTime.clear();
1314 expectedTime << 960 << 1560 << 1800 << 2040;
1315 expectedRsrp.clear();
1316 expectedRsrp << 52 << 56 << 56 << 59;
1317 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1318 "Piecewise test case 2 - Event A5 with short time-to-trigger",
1319 config,
1320 expectedTime,
1321 expectedRsrp),
1322 TestCase::TAKES_FOREVER);
1323
1324 // With super time-to-trigger
1325 config.timeToTrigger = 320;
1326 expectedTime.clear();
1327 expectedTime << 1720 << 1960 << 2200;
1328 expectedRsrp.clear();
1329 expectedRsrp << 52 << 56 << 72;
1330 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1331 "Piecewise test case 2 - Event A5 with super time-to-trigger",
1332 config,
1333 expectedTime,
1334 expectedRsrp),
1335 TestCase::QUICK);
1336
1337 // With hysteresis
1338 config.hysteresis = 6;
1339 config.timeToTrigger = 0;
1340 expectedTime.clear();
1341 expectedTime << 800 << 1600 << 1840 << 2080;
1342 expectedRsrp.clear();
1343 expectedRsrp << 52 << 52 << 56 << 59;
1344 AddTestCase(
1345 new LteUeMeasurementsPiecewiseTestCase2("Piecewise test case 2 - Event A5 with hysteresis",
1346 config,
1347 expectedTime,
1348 expectedRsrp),
1349 TestCase::QUICK);
1350
1351 // With normal-high threshold
1352 config.threshold2.range = 97;
1353 config.hysteresis = 0;
1354 expectedTime.clear();
1355 expectedRsrp.clear();
1356 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1357 "Piecewise test case 2 - Event A5 with normal-high threshold",
1358 config,
1359 expectedTime,
1360 expectedRsrp),
1361 TestCase::TAKES_FOREVER);
1362
1363 // With high-low threshold
1364 config.threshold1.range = 97;
1365 config.threshold2.range = 0;
1366 expectedTime.clear();
1367 expectedTime << 200 << 440 << 680 << 920 << 1160 << 1400 << 1640 << 1880 << 2120;
1368 expectedRsrp.clear();
1369 expectedRsrp << 73 << 63 << 72 << 52 << 72 << 56 << 52 << 56 << 59;
1370 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1371 "Piecewise test case 2 - Event A5 with high-low threshold",
1372 config,
1373 expectedTime,
1374 expectedRsrp),
1375 TestCase::EXTENSIVE);
1376
1377 // With high-normal threshold
1378 config.threshold2.range = 58;
1379 expectedTime.clear();
1380 expectedTime << 400 << 800 << 1400 << 1640 << 1880;
1381 expectedRsrp.clear();
1382 expectedRsrp << 63 << 52 << 56 << 52 << 56;
1383 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1384 "Piecewise test case 2 - Event A5 with high-normal threshold",
1385 config,
1386 expectedTime,
1387 expectedRsrp),
1388 TestCase::TAKES_FOREVER);
1389
1390 // With high-high threshold
1391 config.threshold2.range = 97;
1392 expectedTime.clear();
1393 expectedRsrp.clear();
1394 AddTestCase(new LteUeMeasurementsPiecewiseTestCase2(
1395 "Piecewise test case 2 - Event A5 with high-high threshold",
1396 config,
1397 expectedTime,
1398 expectedRsrp),
1399 TestCase::EXTENSIVE);
1400
1401} // end of LteUeMeasurementsPiecewiseTestSuite2::LteUeMeasurementsPiecewiseTestSuite2
1402
1407static LteUeMeasurementsPiecewiseTestSuite2 lteUeMeasurementsPiecewiseTestSuite2;
1408
1409/*
1410 * Test Case
1411 */
1412
1413LteUeMeasurementsPiecewiseTestCase2::LteUeMeasurementsPiecewiseTestCase2(
1414 std::string name,
1415 LteRrcSap::ReportConfigEutra config,
1416 std::vector<Time> expectedTime,
1417 std::vector<uint8_t> expectedRsrp)
1418 : TestCase(name),
1419 m_config(config),
1420 m_expectedTime(expectedTime),
1421 m_expectedRsrp(expectedRsrp)
1422{
1423 // input sanity check
1424 uint16_t size = m_expectedTime.size();
1425
1426 if (size != m_expectedRsrp.size())
1427 {
1428 NS_FATAL_ERROR("Vectors of expected results are not of the same size");
1429 }
1430
1431 m_itExpectedTime = m_expectedTime.begin();
1432 m_itExpectedRsrp = m_expectedRsrp.begin();
1433
1434 NS_LOG_INFO(this << " name=" << name);
1435}
1436
1437LteUeMeasurementsPiecewiseTestCase2::~LteUeMeasurementsPiecewiseTestCase2()
1438{
1439 NS_LOG_FUNCTION(this);
1440}
1441
1442void
1443LteUeMeasurementsPiecewiseTestCase2::DoRun()
1444{
1445 NS_LOG_INFO(this << " " << GetName());
1446
1447 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
1448 lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisSpectrumPropagationLossModel"));
1449 lteHelper->SetAttribute("UseIdealRrc", BooleanValue(true));
1450
1451 // Disable Uplink Power Control
1452 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));
1453
1454 // Create Nodes: eNodeB and UE
1455 NodeContainer enbNodes;
1456 NodeContainer ueNodes;
1457 enbNodes.Create(2);
1458 ueNodes.Create(1);
1459
1460 /*
1461 * The topology is the following:
1462 *
1463 * eNodeB UE eNodeB
1464 * | | |
1465 * x ---- x --------------- x ------- x --------------- x ---- x
1466 * 50 m | 200 m | 100 m | 200 m | 50 m
1467 * | | | |
1468 * VeryNear Near Far VeryFar
1469 */
1470
1471 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
1472 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // Serving eNodeB
1473 positionAlloc->Add(Vector(600.0, 0.0, 0.0)); // Neighbour eNodeB
1474 positionAlloc->Add(Vector(50.0, 0.0, 0.0)); // UE
1475 MobilityHelper mobility;
1476 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
1477 mobility.SetPositionAllocator(positionAlloc);
1478 mobility.Install(enbNodes);
1479 mobility.Install(ueNodes);
1480 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
1481
1482 // Disable layer-3 filtering
1483 Config::SetDefault("ns3::LteEnbRrc::RsrpFilterCoefficient", UintegerValue(0));
1484
1485 // Create Devices and install them in the Nodes (eNB and UE)
1486 NetDeviceContainer enbDevs;
1487 NetDeviceContainer ueDevs;
1488 lteHelper->SetSchedulerType("ns3::RrFfMacScheduler");
1489 lteHelper->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
1490 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
1491 ueDevs = lteHelper->InstallUeDevice(ueNodes);
1492
1493 // Setup UE measurement configuration in serving cell
1494 Ptr<LteEnbRrc> enbRrc1 = enbDevs.Get(0)->GetObject<LteEnbNetDevice>()->GetRrc();
1495 m_expectedMeasId = enbRrc1->AddUeMeasReportConfig(m_config).at(0);
1496
1497 // Disable handover in neighbour cell
1498 Ptr<LteEnbRrc> enbRrc2 = enbDevs.Get(1)->GetObject<LteEnbNetDevice>()->GetRrc();
1499 enbRrc2->SetAttribute("AdmitHandoverRequest", BooleanValue(false));
1500
1501 // Attach UE to serving eNodeB
1502 lteHelper->Attach(ueDevs.Get(0), enbDevs.Get(0));
1503
1504 // Activate an EPS bearer
1505 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
1506 EpsBearer bearer(q);
1507 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
1508
1509 // Connect to trace sources in serving eNodeB
1510 Config::Connect(
1511 "/NodeList/0/DeviceList/0/LteEnbRrc/RecvMeasurementReport",
1512 MakeCallback(&LteUeMeasurementsPiecewiseTestCase2::RecvMeasurementReportCallback, this));
1513
1514 /*
1515 * Schedule "teleports"
1516 * 0 1 2
1517 * +-------------------+-------------------+---------> time
1518 * VeryNear |------ ---- ---- --------
1519 * Near | ---- ----
1520 * Far | ---- ----
1521 * VeryFar | -- ---- ----
1522 */
1523 Simulator::Schedule(MilliSeconds(301),
1524 &LteUeMeasurementsPiecewiseTestCase2::TeleportVeryFar,
1525 this);
1526 Simulator::Schedule(MilliSeconds(401),
1527 &LteUeMeasurementsPiecewiseTestCase2::TeleportVeryNear,
1528 this);
1529 Simulator::Schedule(MilliSeconds(601),
1530 &LteUeMeasurementsPiecewiseTestCase2::TeleportVeryFar,
1531 this);
1532 Simulator::Schedule(MilliSeconds(801),
1533 &LteUeMeasurementsPiecewiseTestCase2::TeleportVeryNear,
1534 this);
1535 Simulator::Schedule(MilliSeconds(1001),
1536 &LteUeMeasurementsPiecewiseTestCase2::TeleportNear,
1537 this);
1538 Simulator::Schedule(MilliSeconds(1201),
1539 &LteUeMeasurementsPiecewiseTestCase2::TeleportFar,
1540 this);
1541 Simulator::Schedule(MilliSeconds(1401),
1542 &LteUeMeasurementsPiecewiseTestCase2::TeleportVeryFar,
1543 this);
1544 Simulator::Schedule(MilliSeconds(1601),
1545 &LteUeMeasurementsPiecewiseTestCase2::TeleportFar,
1546 this);
1547 Simulator::Schedule(MilliSeconds(1801),
1548 &LteUeMeasurementsPiecewiseTestCase2::TeleportNear,
1549 this);
1550 Simulator::Schedule(MilliSeconds(2001),
1551 &LteUeMeasurementsPiecewiseTestCase2::TeleportVeryNear,
1552 this);
1553
1554 // Run simulation
1555 Simulator::Stop(Seconds(2.201));
1556 Simulator::Run();
1557 Simulator::Destroy();
1558
1559} // end of void LteUeMeasurementsPiecewiseTestCase2::DoRun ()
1560
1561void
1562LteUeMeasurementsPiecewiseTestCase2::DoTeardown()
1563{
1564 NS_LOG_FUNCTION(this);
1565 bool hasEnded = m_itExpectedTime == m_expectedTime.end();
1566 NS_TEST_ASSERT_MSG_EQ(hasEnded,
1567 true,
1568 "Reporting should have occurred at " << m_itExpectedTime->As(Time::S));
1569 hasEnded = m_itExpectedRsrp == m_expectedRsrp.end();
1570 NS_ASSERT(hasEnded);
1571}
1572
1573void
1574LteUeMeasurementsPiecewiseTestCase2::RecvMeasurementReportCallback(
1575 std::string context,
1576 uint64_t imsi,
1577 uint16_t cellId,
1578 uint16_t rnti,
1579 LteRrcSap::MeasurementReport report)
1580{
1581 NS_LOG_FUNCTION(this << context);
1582 NS_ASSERT(rnti == 1);
1583 NS_ASSERT(cellId == 1);
1584
1585 if (report.measResults.measId == m_expectedMeasId)
1586 {
1587 // verifying the report completeness
1588 LteRrcSap::MeasResults measResults = report.measResults;
1589 NS_LOG_DEBUG(
1590 this << " Serving cellId=" << cellId
1591 << " rsrp=" << (uint16_t)measResults.measResultPCell.rsrpResult << " ("
1592 << EutranMeasurementMapping::RsrpRange2Dbm(measResults.measResultPCell.rsrpResult)
1593 << " dBm)"
1594 << " rsrq=" << (uint16_t)measResults.measResultPCell.rsrqResult << " ("
1595 << EutranMeasurementMapping::RsrqRange2Db(measResults.measResultPCell.rsrqResult)
1596 << " dB)");
1597
1598 // verifying reported best cells
1599 if (measResults.measResultListEutra.empty())
1600 {
1601 NS_TEST_ASSERT_MSG_EQ(measResults.haveMeasResultNeighCells,
1602 false,
1603 "Unexpected report content");
1604 }
1605 else
1606 {
1607 NS_TEST_ASSERT_MSG_EQ(measResults.haveMeasResultNeighCells,
1608 true,
1609 "Unexpected report content");
1610 std::list<LteRrcSap::MeasResultEutra>::iterator it =
1611 measResults.measResultListEutra.begin();
1612 NS_ASSERT(it != measResults.measResultListEutra.end());
1613 NS_ASSERT(it->physCellId == 2);
1614 NS_TEST_ASSERT_MSG_EQ(it->haveCgiInfo,
1615 false,
1616 "Report contains cgi-info, which is not supported");
1617 NS_TEST_ASSERT_MSG_EQ(it->haveRsrpResult,
1618 true,
1619 "Report does not contain measured RSRP result");
1620 NS_TEST_ASSERT_MSG_EQ(it->haveRsrqResult,
1621 true,
1622 "Report does not contain measured RSRQ result");
1623 NS_LOG_DEBUG(this << " Neighbour cellId=" << it->physCellId
1624 << " rsrp=" << (uint16_t)it->rsrpResult << " ("
1625 << EutranMeasurementMapping::RsrpRange2Dbm(it->rsrpResult) << " dBm)"
1626 << " rsrq=" << (uint16_t)it->rsrqResult << " ("
1627 << EutranMeasurementMapping::RsrqRange2Db(it->rsrqResult) << " dB)");
1628
1629 } // end of else of if (measResults.measResultListEutra.size () == 0)
1630
1631 // verifying the report timing
1632 bool hasEnded = m_itExpectedTime == m_expectedTime.end();
1633 NS_TEST_ASSERT_MSG_EQ(hasEnded,
1634 false,
1635 "Reporting should not have occurred at "
1636 << Simulator::Now().As(Time::S));
1637 if (!hasEnded)
1638 {
1639 hasEnded = m_itExpectedRsrp == m_expectedRsrp.end();
1640 NS_ASSERT(!hasEnded);
1641
1642 // using milliseconds to avoid floating-point comparison
1643 uint64_t timeNowMs = Simulator::Now().GetMilliSeconds();
1644 uint64_t timeExpectedMs = m_itExpectedTime->GetMilliSeconds();
1645 m_itExpectedTime++;
1646
1647 uint16_t observedRsrp = measResults.measResultPCell.rsrpResult;
1648 uint16_t referenceRsrp = *m_itExpectedRsrp;
1649 m_itExpectedRsrp++;
1650
1651 NS_TEST_ASSERT_MSG_EQ(timeNowMs,
1652 timeExpectedMs,
1653 "Reporting should not have occurred at this time");
1654 NS_TEST_ASSERT_MSG_EQ(observedRsrp,
1655 referenceRsrp,
1656 "The RSRP observed differs with the reference RSRP");
1657
1658 } // end of if (!hasEnded)
1659
1660 } // end of if (report.measResults.measId == m_expectedMeasId)
1661
1662} // end of void LteUeMeasurementsPiecewiseTestCase2::RecvMeasurementReportCallback
1663
1664void
1665LteUeMeasurementsPiecewiseTestCase2::TeleportVeryNear()
1666{
1667 NS_LOG_FUNCTION(this);
1668 m_ueMobility->SetPosition(Vector(50.0, 0.0, 0.0));
1669}
1670
1671void
1672LteUeMeasurementsPiecewiseTestCase2::TeleportNear()
1673{
1674 NS_LOG_FUNCTION(this);
1675 m_ueMobility->SetPosition(Vector(250.0, 0.0, 0.0));
1676}
1677
1678void
1679LteUeMeasurementsPiecewiseTestCase2::TeleportFar()
1680{
1681 NS_LOG_FUNCTION(this);
1682 m_ueMobility->SetPosition(Vector(350.0, 0.0, 0.0));
1683}
1684
1685void
1686LteUeMeasurementsPiecewiseTestCase2::TeleportVeryFar()
1687{
1688 NS_LOG_FUNCTION(this);
1689 m_ueMobility->SetPosition(Vector(550.0, 0.0, 0.0));
1690}
1691
1692// ===== LTE-UE-MEASUREMENTS-PIECEWISE-3 TEST SUITE ======================== //
1693
1694/*
1695 * Test Suite
1696 */
1697
1698LteUeMeasurementsPiecewiseTestSuite3::LteUeMeasurementsPiecewiseTestSuite3()
1699 : TestSuite("lte-ue-measurements-piecewise-3", SYSTEM)
1700{
1701 std::vector<Time> expectedTime;
1702
1703 // === Event A4 (neighbor becomes better than threshold) ===
1704
1705 // The threshold value was chosen to achieve the following:
1706 // 1. Neighbor 1 (eNB2) RSRP would be above the chosen threshold, hence,
1707 // the UE will include it in its reports to its eNB (eNB1) from the beginning
1708 // of the simulation.
1709 // 2. When neighbor 2 (eNB3) is placed at a very far position, its RSRP would
1710 // be less than the chosen threshold, hence, UE will not include it in its
1711 // initial report(s) to its eNB.
1712 // 3. When neighbor 2 (eNB3) is placed at a near position, its RSRP would
1713 // always be above the chosen threshold, hence, the UE will include it in its
1714 // reports to its eNB (eNB1).
1715 LteRrcSap::ReportConfigEutra config;
1716 config.triggerType = LteRrcSap::ReportConfigEutra::EVENT;
1717 config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
1718 config.threshold1.choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP;
1719 config.threshold1.range = 6;
1720 config.triggerQuantity = LteRrcSap::ReportConfigEutra::RSRP;
1721 config.reportInterval = LteRrcSap::ReportConfigEutra::MS240;
1722 expectedTime.clear();
1723 expectedTime << 200 << 440 << 680 << 920 << 1160 << 1400 << 1640 << 1880 << 2120;
1724
1725 AddTestCase(new LteUeMeasurementsPiecewiseTestCase3("Piecewise test case 3 - Event A4",
1726 config,
1727 expectedTime),
1728 TestCase::QUICK);
1729} // end of LteUeMeasurementsPiecewiseTestSuite3::LteUeMeasurementsPiecewiseTestSuite3
1730
1735static LteUeMeasurementsPiecewiseTestSuite3 lteUeMeasurementsPiecewiseTestSuite3;
1736
1737/*
1738 * Test Case
1739 */
1740
1741LteUeMeasurementsPiecewiseTestCase3::LteUeMeasurementsPiecewiseTestCase3(
1742 std::string name,
1743 LteRrcSap::ReportConfigEutra config,
1744 std::vector<Time> expectedTime)
1745 : TestCase(name),
1746 m_config(config),
1747 m_expectedTime(expectedTime)
1748{
1749 m_expectedMeasId = std::numeric_limits<uint8_t>::max();
1750
1751 m_itExpectedTime = m_expectedTime.begin();
1752
1753 NS_LOG_INFO(this << " name=" << name);
1754}
1755
1756LteUeMeasurementsPiecewiseTestCase3::~LteUeMeasurementsPiecewiseTestCase3()
1757{
1758 NS_LOG_FUNCTION(this);
1759}
1760
1761void
1762LteUeMeasurementsPiecewiseTestCase3::DoRun()
1763{
1764 NS_LOG_INFO(this << " " << GetName());
1765
1766 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
1767 lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisSpectrumPropagationLossModel"));
1768 lteHelper->SetAttribute("UseIdealRrc", BooleanValue(true));
1769
1770 // Disable Uplink Power Control
1771 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));
1772
1773 // Create Nodes: eNodeB and UE
1774 NodeContainer enbNodes;
1775 NodeContainer ueNodes;
1776 enbNodes.Create(3);
1777 ueNodes.Create(1);
1778
1779 /*
1780 * The topology is the following:
1781 *
1782 * We place the 3rd eNB initially very far so it does not fulfills
1783 * the entry condition to be reported.
1784 *
1785 * eNodeB UE eNodeB eNodeB
1786 * | | | |
1787 * x ---- x --------------- x -------------- x ---------------------x
1788 * 50 m 100 m 500 | 1000000
1789 * Near
1790 */
1791
1792 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
1793 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // Serving eNodeB
1794 positionAlloc->Add(Vector(200.0, 0.0, 0.0)); // Neighbour eNodeB1
1795 positionAlloc->Add(Vector(1000700.0, 0.0, 0.0)); // Neighbour eNodeB2
1796 positionAlloc->Add(Vector(50.0, 0.0, 0.0)); // UE
1797 MobilityHelper mobility;
1798 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
1799 mobility.SetPositionAllocator(positionAlloc);
1800 mobility.Install(enbNodes);
1801 mobility.Install(ueNodes);
1802 m_enbMobility = enbNodes.Get(2)->GetObject<MobilityModel>();
1803
1804 // Disable layer-3 filtering
1805 Config::SetDefault("ns3::LteEnbRrc::RsrpFilterCoefficient", UintegerValue(0));
1806
1807 // Create Devices and install them in the Nodes (eNB and UE)
1808 NetDeviceContainer enbDevs;
1809 NetDeviceContainer ueDevs;
1810 lteHelper->SetSchedulerType("ns3::RrFfMacScheduler");
1811 lteHelper->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
1812 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
1813 ueDevs = lteHelper->InstallUeDevice(ueNodes);
1814
1815 // Setup UE measurement configuration in serving cell
1816 Ptr<LteEnbRrc> enbRrc1 = enbDevs.Get(0)->GetObject<LteEnbNetDevice>()->GetRrc();
1817 m_expectedMeasId = enbRrc1->AddUeMeasReportConfig(m_config).at(0);
1818
1819 // Disable handover in neighbour cells
1820 Ptr<LteEnbRrc> enbRrc2 = enbDevs.Get(1)->GetObject<LteEnbNetDevice>()->GetRrc();
1821 enbRrc2->SetAttribute("AdmitHandoverRequest", BooleanValue(false));
1822 Ptr<LteEnbRrc> enbRrc3 = enbDevs.Get(2)->GetObject<LteEnbNetDevice>()->GetRrc();
1823 enbRrc3->SetAttribute("AdmitHandoverRequest", BooleanValue(false));
1824
1825 // Attach UE to serving eNodeB
1826 lteHelper->Attach(ueDevs.Get(0), enbDevs.Get(0));
1827
1828 // Activate an EPS bearer
1829 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
1830 EpsBearer bearer(q);
1831 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
1832
1833 // Connect to trace sources in serving eNodeB
1834 Config::Connect(
1835 "/NodeList/0/DeviceList/0/LteEnbRrc/RecvMeasurementReport",
1836 MakeCallback(&LteUeMeasurementsPiecewiseTestCase3::RecvMeasurementReportCallback, this));
1837 /*
1838 * Schedule "teleport" for the 2nd neighbour
1839 *
1840 * We bring the 2nd neighbour near once the UE has already scheduled the periodic
1841 * reporting after detecting the 1st neighbour, which ideally should be at
1842 * 200 ms.
1843 */
1844 Simulator::Schedule(MilliSeconds(301),
1845 &LteUeMeasurementsPiecewiseTestCase3::TeleportEnbNear,
1846 this);
1847
1848 // Run simulation
1849 Simulator::Stop(Seconds(2.201));
1850 Simulator::Run();
1851 Simulator::Destroy();
1852
1853} // end of void LteUeMeasurementsPiecewiseTestCase3::DoRun ()
1854
1855void
1856LteUeMeasurementsPiecewiseTestCase3::DoTeardown()
1857{
1858 NS_LOG_FUNCTION(this);
1859 bool hasEnded = m_itExpectedTime == m_expectedTime.end();
1860 NS_TEST_ASSERT_MSG_EQ(hasEnded,
1861 true,
1862 "Reporting should have occurred at " << m_itExpectedTime->GetSeconds()
1863 << "s");
1864}
1865
1866void
1867LteUeMeasurementsPiecewiseTestCase3::RecvMeasurementReportCallback(
1868 std::string context,
1869 uint64_t imsi,
1870 uint16_t cellId,
1871 uint16_t rnti,
1872 LteRrcSap::MeasurementReport report)
1873{
1874 NS_LOG_FUNCTION(this << context);
1875 NS_ASSERT(rnti == 1);
1876 NS_ASSERT(cellId == 1);
1877
1878 if (report.measResults.measId == m_expectedMeasId)
1879 {
1880 // verifying the report completeness
1881 LteRrcSap::MeasResults measResults = report.measResults;
1882 NS_LOG_DEBUG(
1883 this << " Serving cellId=" << cellId
1884 << " rsrp=" << (uint16_t)measResults.measResultPCell.rsrpResult << " ("
1885 << EutranMeasurementMapping::RsrpRange2Dbm(measResults.measResultPCell.rsrpResult)
1886 << " dBm)"
1887 << " rsrq=" << (uint16_t)measResults.measResultPCell.rsrqResult << " ("
1888 << EutranMeasurementMapping::RsrqRange2Db(measResults.measResultPCell.rsrqResult)
1889 << " dB)");
1890
1891 // verifying reported best cells
1892 if (measResults.measResultListEutra.empty())
1893 {
1894 NS_TEST_ASSERT_MSG_EQ(measResults.haveMeasResultNeighCells,
1895 false,
1896 "Unexpected report content");
1897 }
1898 else
1899 {
1900 NS_TEST_ASSERT_MSG_EQ(measResults.haveMeasResultNeighCells,
1901 true,
1902 "Unexpected report content");
1903 std::list<LteRrcSap::MeasResultEutra>::iterator it =
1904 measResults.measResultListEutra.begin();
1905 NS_ASSERT(it != measResults.measResultListEutra.end());
1906 for (const auto& it : measResults.measResultListEutra)
1907 {
1908 NS_ASSERT(it.physCellId == 2 || it.physCellId == 3);
1909 NS_TEST_ASSERT_MSG_EQ(it.haveCgiInfo,
1910 false,
1911 "Report contains cgi-info, which is not supported");
1912 NS_TEST_ASSERT_MSG_EQ(it.haveRsrpResult,
1913 true,
1914 "Report does not contain measured RSRP result");
1915 NS_TEST_ASSERT_MSG_EQ(it.haveRsrqResult,
1916 true,
1917 "Report does not contain measured RSRQ result");
1918 NS_LOG_DEBUG(
1919 this << " Neighbour cellId=" << it.physCellId
1920 << " rsrp=" << (uint16_t)it.rsrpResult << " ("
1921 << EutranMeasurementMapping::RsrpRange2Dbm(it.rsrpResult) << " dBm)"
1922 << " rsrq=" << (uint16_t)it.rsrqResult << " ("
1923 << EutranMeasurementMapping::RsrqRange2Db(it.rsrqResult) << " dB)");
1924 }
1925
1926 } // end of else of if (measResults.measResultListEutra.size () == 0)
1927
1928 // verifying the report timing
1929 bool hasEnded = m_itExpectedTime == m_expectedTime.end();
1930 NS_TEST_ASSERT_MSG_EQ(hasEnded,
1931 false,
1932 "Reporting should not have occurred at "
1933 << Simulator::Now().GetSeconds() << "s");
1934 if (!hasEnded)
1935 {
1936 // using milliseconds to avoid floating-point comparison
1937 uint64_t timeNowMs = Simulator::Now().GetMilliSeconds();
1938 uint64_t timeExpectedMs = m_itExpectedTime->GetMilliSeconds();
1939 m_itExpectedTime++;
1940
1941 NS_TEST_ASSERT_MSG_EQ(timeNowMs,
1942 timeExpectedMs,
1943 "Reporting should not have occurred at this time");
1944
1945 } // end of if (!hasEnded)
1946
1947 } // end of if (report.measResults.measId == m_expectedMeasId)
1948
1949} // end of void LteUeMeasurementsPiecewiseTestCase3::RecvMeasurementReportCallback
1950
1951void
1952LteUeMeasurementsPiecewiseTestCase3::TeleportEnbNear()
1953{
1954 NS_LOG_FUNCTION(this);
1955 m_enbMobility->SetPosition(Vector(700.0, 0.0, 0.0));
1956}
1957
1958// ===== LTE-UE-MEASUREMENTS-HANDOVER TEST SUITE =========================== //
1959
1960/*
1961 * Test Suite
1962 */
1963
1964LteUeMeasurementsHandoverTestSuite::LteUeMeasurementsHandoverTestSuite()
1965 : TestSuite("lte-ue-measurements-handover", SYSTEM)
1966{
1967 std::list<LteRrcSap::ReportConfigEutra> sourceConfigList;
1968 std::list<LteRrcSap::ReportConfigEutra> targetConfigList;
1969 std::vector<Time> expectedTime;
1970 std::vector<uint8_t> expectedRsrp;
1971
1972 LteRrcSap::ReportConfigEutra sourceConfig;
1973 sourceConfig.triggerType = LteRrcSap::ReportConfigEutra::EVENT;
1974 sourceConfig.eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
1975 sourceConfig.threshold1.choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP;
1976 sourceConfig.threshold1.range = 0;
1977 sourceConfig.triggerQuantity = LteRrcSap::ReportConfigEutra::RSRP;
1978 sourceConfig.reportInterval = LteRrcSap::ReportConfigEutra::MS240;
1979 sourceConfigList.push_back(sourceConfig);
1980
1981 LteRrcSap::ReportConfigEutra targetConfig;
1982 targetConfig.triggerType = LteRrcSap::ReportConfigEutra::EVENT;
1983 targetConfig.eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
1984 targetConfig.threshold1.choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP;
1985 targetConfig.threshold1.range = 0;
1986 targetConfig.triggerQuantity = LteRrcSap::ReportConfigEutra::RSRP;
1987 targetConfig.reportInterval = LteRrcSap::ReportConfigEutra::MS240;
1988 targetConfigList.push_back(targetConfig);
1989
1990 // === Report interval difference ===
1991
1992 // decreasing report interval
1993 sourceConfigList.front().reportInterval = LteRrcSap::ReportConfigEutra::MS480;
1994 targetConfigList.front().reportInterval = LteRrcSap::ReportConfigEutra::MS240;
1995 expectedTime.clear();
1996 expectedTime << 200 << 680 << 1200 << 1440 << 1680 << 1920;
1997 expectedRsrp.clear();
1998 expectedRsrp << 55 << 55 << 53 << 53 << 53 << 53;
1999 AddTestCase(
2000 new LteUeMeasurementsHandoverTestCase("Handover test case - decreasing report interval",
2001 sourceConfigList,
2002 targetConfigList,
2003 expectedTime,
2004 expectedRsrp,
2005 Seconds(2)),
2006 TestCase::TAKES_FOREVER);
2007
2008 // increasing report interval
2009 sourceConfigList.front().reportInterval = LteRrcSap::ReportConfigEutra::MS120;
2010 targetConfigList.front().reportInterval = LteRrcSap::ReportConfigEutra::MS640;
2011 expectedTime.clear();
2012 expectedTime << 200 << 320 << 440 << 560 << 680 << 800 << 920 << 1200 << 1840;
2013 expectedRsrp.clear();
2014 expectedRsrp << 55 << 55 << 55 << 55 << 55 << 55 << 55 << 53 << 53;
2015 AddTestCase(
2016 new LteUeMeasurementsHandoverTestCase("Handover test case - increasing report interval",
2017 sourceConfigList,
2018 targetConfigList,
2019 expectedTime,
2020 expectedRsrp,
2021 Seconds(2)),
2022 TestCase::QUICK);
2023
2024 // === Event difference ===
2025
2026 sourceConfigList.front().reportInterval = LteRrcSap::ReportConfigEutra::MS240;
2027 targetConfigList.front().reportInterval = LteRrcSap::ReportConfigEutra::MS240;
2028 sourceConfigList.front().threshold1.range = 54;
2029 sourceConfigList.front().threshold2.range = 54;
2030 sourceConfigList.front().a3Offset = 1;
2031 targetConfigList.front().threshold1.range = 54;
2032 targetConfigList.front().threshold2.range = 54;
2033 targetConfigList.front().a3Offset = 1;
2034
2035 // Event A1 to Event A2
2036 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
2037 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;
2038 expectedTime.clear();
2039 expectedTime << 200 << 440 << 680 << 920 << 1200 << 1440 << 1680 << 1920;
2040 expectedRsrp.clear();
2041 expectedRsrp << 55 << 55 << 55 << 55 << 53 << 53 << 53 << 53;
2042 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - Event A1 to Event A2",
2043 sourceConfigList,
2044 targetConfigList,
2045 expectedTime,
2046 expectedRsrp,
2047 Seconds(2)),
2048 TestCase::EXTENSIVE);
2049
2050 // Event A2 to Event A1
2051 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;
2052 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
2053 expectedTime.clear();
2054 expectedRsrp.clear();
2055 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - Event A2 to Event A1",
2056 sourceConfigList,
2057 targetConfigList,
2058 expectedTime,
2059 expectedRsrp,
2060 Seconds(2)),
2061 TestCase::TAKES_FOREVER);
2062
2063 // Event A3 to Event A4
2064 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;
2065 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
2066 expectedTime.clear();
2067 expectedTime << 1200 << 1440 << 1680 << 1920;
2068 expectedRsrp.clear();
2069 expectedRsrp << 53 << 53 << 53 << 53;
2070 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - Event A3 to Event A4",
2071 sourceConfigList,
2072 targetConfigList,
2073 expectedTime,
2074 expectedRsrp,
2075 Seconds(2)),
2076 TestCase::TAKES_FOREVER);
2077
2078 // Event A4 to Event A3
2079 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
2080 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;
2081 expectedTime.clear();
2082 expectedTime << 1200 << 1440 << 1680 << 1920;
2083 expectedRsrp.clear();
2084 expectedRsrp << 53 << 53 << 53 << 53;
2085 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - Event A4 to Event A3",
2086 sourceConfigList,
2087 targetConfigList,
2088 expectedTime,
2089 expectedRsrp,
2090 Seconds(2)),
2091 TestCase::QUICK);
2092
2093 // Event A2 to Event A3
2094 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;
2095 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;
2096 expectedTime.clear();
2097 expectedTime << 1200 << 1440 << 1680 << 1920;
2098 expectedRsrp.clear();
2099 expectedRsrp << 53 << 53 << 53 << 53;
2100 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - Event A2 to Event A3",
2101 sourceConfigList,
2102 targetConfigList,
2103 expectedTime,
2104 expectedRsrp,
2105 Seconds(2)),
2106 TestCase::EXTENSIVE);
2107
2108 // Event A3 to Event A2
2109 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;
2110 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;
2111 expectedTime.clear();
2112 expectedTime << 1200 << 1440 << 1680 << 1920;
2113 expectedRsrp.clear();
2114 expectedRsrp << 53 << 53 << 53 << 53;
2115 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - Event A3 to Event A2",
2116 sourceConfigList,
2117 targetConfigList,
2118 expectedTime,
2119 expectedRsrp,
2120 Seconds(2)),
2121 TestCase::TAKES_FOREVER);
2122
2123 // Event A4 to Event A5
2124 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
2125 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A5;
2126 expectedTime.clear();
2127 expectedTime << 1200 << 1440 << 1680 << 1920;
2128 expectedRsrp.clear();
2129 expectedRsrp << 53 << 53 << 53 << 53;
2130 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - Event A4 to Event A5",
2131 sourceConfigList,
2132 targetConfigList,
2133 expectedTime,
2134 expectedRsrp,
2135 Seconds(2)),
2136 TestCase::TAKES_FOREVER);
2137
2138 // Event A5 to Event A4
2139 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A5;
2140 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
2141 expectedTime.clear();
2142 expectedTime << 1200 << 1440 << 1680 << 1920;
2143 expectedRsrp.clear();
2144 expectedRsrp << 53 << 53 << 53 << 53;
2145 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - Event A5 to Event A4",
2146 sourceConfigList,
2147 targetConfigList,
2148 expectedTime,
2149 expectedRsrp,
2150 Seconds(2)),
2151 TestCase::EXTENSIVE);
2152
2153 // === Threshold/offset difference ===
2154
2155 sourceConfigList.front().threshold1.range = 52;
2156 targetConfigList.front().threshold1.range = 56;
2157
2158 // Event A1
2159 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
2160 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
2161 expectedTime.clear();
2162 expectedTime << 200 << 440 << 680 << 920;
2163 expectedRsrp.clear();
2164 expectedRsrp << 55 << 55 << 55 << 55;
2165 AddTestCase(
2166 new LteUeMeasurementsHandoverTestCase("Handover test case - Event A1 threshold difference",
2167 sourceConfigList,
2168 targetConfigList,
2169 expectedTime,
2170 expectedRsrp,
2171 Seconds(2)),
2172 TestCase::EXTENSIVE);
2173
2174 // Event A2
2175 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;
2176 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;
2177 expectedTime.clear();
2178 expectedTime << 1200 << 1440 << 1680 << 1920;
2179 expectedRsrp.clear();
2180 expectedRsrp << 53 << 53 << 53 << 53;
2181 AddTestCase(
2182 new LteUeMeasurementsHandoverTestCase("Handover test case - Event A2 threshold difference",
2183 sourceConfigList,
2184 targetConfigList,
2185 expectedTime,
2186 expectedRsrp,
2187 Seconds(2)),
2188 TestCase::QUICK);
2189
2190 // Event A3
2191 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;
2192 sourceConfigList.front().a3Offset = -30;
2193 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;
2194 targetConfigList.front().a3Offset = 30;
2195 expectedTime.clear();
2196 expectedTime << 200 << 440 << 680 << 920;
2197 expectedRsrp.clear();
2198 expectedRsrp << 55 << 55 << 55 << 55;
2199 AddTestCase(
2200 new LteUeMeasurementsHandoverTestCase("Handover test case - Event A3 offset difference",
2201 sourceConfigList,
2202 targetConfigList,
2203 expectedTime,
2204 expectedRsrp,
2205 Seconds(2)),
2206 TestCase::QUICK);
2207
2208 // Event A4
2209 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
2210 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;
2211 expectedTime.clear();
2212 expectedTime << 200 << 440 << 680 << 920;
2213 expectedRsrp.clear();
2214 expectedRsrp << 55 << 55 << 55 << 55;
2215 AddTestCase(
2216 new LteUeMeasurementsHandoverTestCase("Handover test case - Event A4 threshold difference",
2217 sourceConfigList,
2218 targetConfigList,
2219 expectedTime,
2220 expectedRsrp,
2221 Seconds(2)),
2222 TestCase::EXTENSIVE);
2223
2224 // Event A5
2225 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A5;
2226 sourceConfigList.front().threshold2.range = 52;
2227 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A5;
2228 targetConfigList.front().threshold2.range = 56;
2229 expectedTime.clear();
2230 expectedRsrp.clear();
2231 AddTestCase(
2232 new LteUeMeasurementsHandoverTestCase("Handover test case - Event A5 threshold difference",
2233 sourceConfigList,
2234 targetConfigList,
2235 expectedTime,
2236 expectedRsrp,
2237 Seconds(2)),
2238 TestCase::EXTENSIVE);
2239
2240 // === Time-to-trigger (TTT) difference ===
2241
2242 sourceConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
2243 sourceConfigList.front().a3Offset = 1;
2244 sourceConfigList.front().threshold1.range = 0;
2245 sourceConfigList.front().threshold2.range = 0;
2246 targetConfigList.front().eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;
2247 targetConfigList.front().a3Offset = 1;
2248 targetConfigList.front().threshold1.range = 0;
2249 targetConfigList.front().threshold2.range = 0;
2250
2251 // decreasing time-to-trigger (short duration)
2252 sourceConfigList.front().timeToTrigger = 1024;
2253 targetConfigList.front().timeToTrigger = 100;
2254 expectedTime.clear();
2255 expectedTime << 1300 << 1540 << 1780;
2256 expectedRsrp.clear();
2257 expectedRsrp << 53 << 53 << 53;
2258 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - decreasing TTT (short)",
2259 sourceConfigList,
2260 targetConfigList,
2261 expectedTime,
2262 expectedRsrp,
2263 Seconds(2)),
2264 TestCase::QUICK);
2265
2266 // decreasing time-to-trigger (longer duration)
2267 sourceConfigList.front().timeToTrigger = 1024;
2268 targetConfigList.front().timeToTrigger = 640;
2269 expectedTime.clear();
2270 expectedTime << 1224 << 1464 << 1704 << 1944 << 2840 << 3080 << 3320 << 3560 << 3800 << 4040;
2271 expectedRsrp.clear();
2272 expectedRsrp << 55 << 55 << 55 << 55 << 53 << 53 << 53 << 53 << 53 << 53;
2273 AddTestCase(new LteUeMeasurementsHandoverTestCase("Handover test case - decreasing TTT (long)",
2274 sourceConfigList,
2275 targetConfigList,
2276 expectedTime,
2277 expectedRsrp,
2278 Seconds(4.2)),
2279 TestCase::EXTENSIVE);
2280
2281} // end of LteUeMeasurementsHandoverTestSuite::LteUeMeasurementsHandoverTestSuite
2282
2287static LteUeMeasurementsHandoverTestSuite lteUeMeasurementsHandoverTestSuite;
2288
2289/*
2290 * Test Case
2291 */
2292
2293LteUeMeasurementsHandoverTestCase::LteUeMeasurementsHandoverTestCase(
2294 std::string name,
2295 std::list<LteRrcSap::ReportConfigEutra> sourceConfigList,
2296 std::list<LteRrcSap::ReportConfigEutra> targetConfigList,
2297 std::vector<Time> expectedTime,
2298 std::vector<uint8_t> expectedRsrp,
2299 Time duration)
2300 : TestCase(name),
2301 m_sourceConfigList(sourceConfigList),
2302 m_targetConfigList(targetConfigList),
2303 m_expectedTime(expectedTime),
2304 m_expectedRsrp(expectedRsrp),
2305 m_duration(duration)
2306{
2307 // input sanity check
2308 uint16_t size = m_expectedTime.size();
2309
2310 if (size != m_expectedRsrp.size())
2311 {
2312 NS_FATAL_ERROR("Vectors of expected results are not of the same size");
2313 }
2314
2315 m_itExpectedTime = m_expectedTime.begin();
2316 m_itExpectedRsrp = m_expectedRsrp.begin();
2317
2318 NS_LOG_INFO(this << " name=" << name);
2319}
2320
2321LteUeMeasurementsHandoverTestCase::~LteUeMeasurementsHandoverTestCase()
2322{
2323 NS_LOG_FUNCTION(this);
2324}
2325
2326void
2327LteUeMeasurementsHandoverTestCase::DoRun()
2328{
2329 NS_LOG_INFO(this << " " << GetName());
2330
2331 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
2332 Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper>();
2333 lteHelper->SetEpcHelper(epcHelper);
2334 lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisSpectrumPropagationLossModel"));
2335 lteHelper->SetAttribute("UseIdealRrc", BooleanValue(true));
2336
2337 // Disable Uplink Power Control
2338 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));
2339
2340 // Create Nodes: eNodeB and UE
2341 NodeContainer enbNodes;
2342 NodeContainer ueNodes;
2343 enbNodes.Create(2);
2344 ueNodes.Create(1);
2345
2346 /*
2347 * The topology is the following:
2348 *
2349 * eNodeB UE eNodeB
2350 * | | |
2351 * x ------------------- x ----------------------- x
2352 * 400 m 500 m
2353 */
2354
2355 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
2356 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // Source eNodeB
2357 positionAlloc->Add(Vector(900.0, 0.0, 0.0)); // Target eNodeB
2358 positionAlloc->Add(Vector(400.0, 0.0, 0.0)); // UE
2359 MobilityHelper mobility;
2360 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
2361 mobility.SetPositionAllocator(positionAlloc);
2362 mobility.Install(enbNodes);
2363 mobility.Install(ueNodes);
2364
2365 // Create P-GW node
2366 Ptr<Node> pgw = epcHelper->GetPgwNode();
2367
2368 // Create a single RemoteHost
2369 NodeContainer remoteHostContainer;
2370 remoteHostContainer.Create(1);
2371 Ptr<Node> remoteHost = remoteHostContainer.Get(0);
2372 InternetStackHelper internet;
2373 internet.Install(remoteHostContainer);
2374
2375 // Create the Internet
2376 PointToPointHelper p2ph;
2377 p2ph.SetDeviceAttribute("DataRate", DataRateValue(DataRate("100Gb/s")));
2378 p2ph.SetDeviceAttribute("Mtu", UintegerValue(1500));
2379 p2ph.SetChannelAttribute("Delay", TimeValue(Seconds(0.010)));
2380 NetDeviceContainer internetDevices = p2ph.Install(pgw, remoteHost);
2381 Ipv4AddressHelper ipv4h;
2382 ipv4h.SetBase("1.0.0.0", "255.0.0.0");
2383 Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign(internetDevices);
2384
2385 // Routing of the Internet Host (towards the LTE network)
2386 Ipv4StaticRoutingHelper ipv4RoutingHelper;
2387 Ptr<Ipv4StaticRouting> remoteHostStaticRouting =
2388 ipv4RoutingHelper.GetStaticRouting(remoteHost->GetObject<Ipv4>());
2389 remoteHostStaticRouting->AddNetworkRouteTo(Ipv4Address("7.0.0.0"), Ipv4Mask("255.0.0.0"), 1);
2390
2391 // Enable layer-3 filtering
2392 Config::SetDefault("ns3::LteEnbRrc::RsrpFilterCoefficient", UintegerValue(4));
2393
2394 // Disable control channel error model
2395 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
2396
2397 // Create Devices and install them in the Nodes (eNB and UE)
2398 NetDeviceContainer enbDevs;
2399 NetDeviceContainer ueDevs;
2400 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
2401 ueDevs = lteHelper->InstallUeDevice(ueNodes);
2402
2403 // Setup UE measurement configuration in eNodeBs
2404 uint8_t measId;
2405 std::list<LteRrcSap::ReportConfigEutra>::const_iterator itReportConfig;
2406 Ptr<LteEnbRrc> enbRrc1 = enbDevs.Get(0)->GetObject<LteEnbNetDevice>()->GetRrc();
2407 Ptr<LteEnbRrc> enbRrc2 = enbDevs.Get(1)->GetObject<LteEnbNetDevice>()->GetRrc();
2408
2409 for (itReportConfig = m_sourceConfigList.begin(); itReportConfig != m_sourceConfigList.end();
2410 itReportConfig++)
2411 {
2412 measId = enbRrc1->AddUeMeasReportConfig(*itReportConfig).at(0);
2413 m_expectedSourceCellMeasId.insert(measId);
2414 }
2415
2416 for (itReportConfig = m_targetConfigList.begin(); itReportConfig != m_targetConfigList.end();
2417 itReportConfig++)
2418 {
2419 measId = enbRrc2->AddUeMeasReportConfig(*itReportConfig).at(0);
2420 m_expectedTargetCellMeasId.insert(measId);
2421 }
2422
2423 // Install the IP stack on the UEs
2424 internet.Install(ueNodes);
2425 Ipv4InterfaceContainer ueIpIfaces;
2426 ueIpIfaces = epcHelper->AssignUeIpv4Address(NetDeviceContainer(ueDevs));
2427
2428 // Assign IP address to UEs
2429 for (uint32_t u = 0; u < ueNodes.GetN(); ++u)
2430 {
2431 Ptr<Node> ueNode = ueNodes.Get(u);
2432 // Set the default gateway for the UE
2433 Ptr<Ipv4StaticRouting> ueStaticRouting =
2434 ipv4RoutingHelper.GetStaticRouting(ueNode->GetObject<Ipv4>());
2435 ueStaticRouting->SetDefaultRoute(epcHelper->GetUeDefaultGatewayAddress(), 1);
2436 }
2437
2438 // Attach UE to serving eNodeB
2439 lteHelper->Attach(ueDevs.Get(0), enbDevs.Get(0));
2440
2441 // Add X2 interface
2442 lteHelper->AddX2Interface(enbNodes);
2443
2444 // Connect to trace sources in source eNodeB
2445 Config::Connect(
2446 "/NodeList/3/DeviceList/0/LteEnbRrc/RecvMeasurementReport",
2447 MakeCallback(&LteUeMeasurementsHandoverTestCase::RecvMeasurementReportCallback, this));
2448
2449 // Connect to trace sources in target eNodeB
2450 Config::Connect(
2451 "/NodeList/4/DeviceList/0/LteEnbRrc/RecvMeasurementReport",
2452 MakeCallback(&LteUeMeasurementsHandoverTestCase::RecvMeasurementReportCallback, this));
2453
2454 // Schedule handover
2455 lteHelper->HandoverRequest(MilliSeconds(m_duration.GetMilliSeconds() / 2),
2456 ueDevs.Get(0),
2457 enbDevs.Get(0),
2458 enbDevs.Get(1));
2459
2460 // Run simulation
2461 Simulator::Stop(m_duration);
2462 Simulator::Run();
2463 Simulator::Destroy();
2464
2465} // end of void LteUeMeasurementsHandoverTestCase::DoRun ()
2466
2467void
2468LteUeMeasurementsHandoverTestCase::DoTeardown()
2469{
2470 NS_LOG_FUNCTION(this);
2471 bool hasEnded = m_itExpectedTime == m_expectedTime.end();
2472 NS_TEST_ASSERT_MSG_EQ(hasEnded,
2473 true,
2474 "Reporting should have occurred at " << m_itExpectedTime->As(Time::S));
2475 hasEnded = m_itExpectedRsrp == m_expectedRsrp.end();
2476 NS_ASSERT(hasEnded);
2477}
2478
2479void
2480LteUeMeasurementsHandoverTestCase::RecvMeasurementReportCallback(
2481 std::string context,
2482 uint64_t imsi,
2483 uint16_t cellId,
2484 uint16_t rnti,
2485 LteRrcSap::MeasurementReport report)
2486{
2487 uint8_t measId = report.measResults.measId;
2488 NS_LOG_FUNCTION(this << context << (uint16_t)measId);
2489
2490 bool isCorrectMeasId;
2491 if (cellId == 1)
2492 {
2493 std::set<uint8_t>::iterator itMeasId = m_expectedSourceCellMeasId.find(measId);
2494 isCorrectMeasId = (itMeasId != m_expectedSourceCellMeasId.end());
2495 }
2496 else if (cellId == 2)
2497 {
2498 std::set<uint8_t>::iterator itMeasId = m_expectedTargetCellMeasId.find(measId);
2499 isCorrectMeasId = (itMeasId != m_expectedTargetCellMeasId.end());
2500 }
2501 else
2502 {
2503 NS_FATAL_ERROR("Invalid cell ID " << cellId);
2504 }
2505
2506 if (isCorrectMeasId)
2507 {
2508 // verifying the report completeness
2509 LteRrcSap::MeasResults measResults = report.measResults;
2510 NS_LOG_DEBUG(
2511 this << " Serving cellId=" << cellId
2512 << " rsrp=" << (uint16_t)measResults.measResultPCell.rsrpResult << " ("
2513 << EutranMeasurementMapping::RsrpRange2Dbm(measResults.measResultPCell.rsrpResult)
2514 << " dBm)"
2515 << " rsrq=" << (uint16_t)measResults.measResultPCell.rsrqResult << " ("
2516 << EutranMeasurementMapping::RsrqRange2Db(measResults.measResultPCell.rsrqResult)
2517 << " dB)");
2518
2519 // verifying reported best cells
2520 if (measResults.measResultListEutra.empty())
2521 {
2522 NS_TEST_ASSERT_MSG_EQ(measResults.haveMeasResultNeighCells,
2523 false,
2524 "Unexpected report content");
2525 }
2526 else
2527 {
2528 NS_TEST_ASSERT_MSG_EQ(measResults.haveMeasResultNeighCells,
2529 true,
2530 "Unexpected report content");
2531 std::list<LteRrcSap::MeasResultEutra>::iterator it =
2532 measResults.measResultListEutra.begin();
2533 NS_ASSERT(it != measResults.measResultListEutra.end());
2534 NS_ASSERT(it->physCellId != cellId);
2535 NS_ASSERT(it->physCellId <= 2);
2536 NS_TEST_ASSERT_MSG_EQ(it->haveCgiInfo,
2537 false,
2538 "Report contains cgi-info, which is not supported");
2539 NS_TEST_ASSERT_MSG_EQ(it->haveRsrpResult,
2540 true,
2541 "Report does not contain measured RSRP result");
2542 NS_TEST_ASSERT_MSG_EQ(it->haveRsrqResult,
2543 true,
2544 "Report does not contain measured RSRQ result");
2545 NS_LOG_DEBUG(this << " Neighbour cellId=" << it->physCellId
2546 << " rsrp=" << (uint16_t)it->rsrpResult << " ("
2547 << EutranMeasurementMapping::RsrpRange2Dbm(it->rsrpResult) << " dBm)"
2548 << " rsrq=" << (uint16_t)it->rsrqResult << " ("
2549 << EutranMeasurementMapping::RsrqRange2Db(it->rsrqResult) << " dB)");
2550
2551 } // end of else of if (measResults.measResultListEutra.size () == 0)
2552
2553 // verifying the report timing
2554 bool hasEnded = m_itExpectedTime == m_expectedTime.end();
2555 NS_TEST_ASSERT_MSG_EQ(hasEnded,
2556 false,
2557 "Reporting should not have occurred at "
2558 << Simulator::Now().As(Time::S));
2559 if (!hasEnded)
2560 {
2561 hasEnded = m_itExpectedRsrp == m_expectedRsrp.end();
2562 NS_ASSERT(!hasEnded);
2563
2564 // using milliseconds to avoid floating-point comparison
2565 uint64_t timeNowMs = Simulator::Now().GetMilliSeconds();
2566 uint64_t timeExpectedMs = m_itExpectedTime->GetMilliSeconds();
2567 m_itExpectedTime++;
2568
2569 uint16_t observedRsrp = measResults.measResultPCell.rsrpResult;
2570 uint16_t referenceRsrp = *m_itExpectedRsrp;
2571 m_itExpectedRsrp++;
2572
2573 NS_TEST_ASSERT_MSG_EQ(timeNowMs,
2574 timeExpectedMs,
2575 "Reporting should not have occurred at this time");
2576 NS_TEST_ASSERT_MSG_EQ(observedRsrp,
2577 referenceRsrp,
2578 "The RSRP observed differs with the reference RSRP");
2579
2580 } // end of if (!hasEnded)
2581
2582 } // end of if (report.measResults.measId == correctMeasId)
2583
2584} // end of void LteUeMeasurementsHandoverTestCase::RecvMeasurementReportCallback
LteUeMeasurementsHandoverTestCase
Testing UE measurements in LTE with simulation of 2 eNodeB and 1 UE in a handover configuration.
Definition: lte-test-ue-measurements.h:560
LteUeMeasurementsHandoverTestCase::m_itExpectedRsrp
std::vector< uint8_t >::iterator m_itExpectedRsrp
Pointer to the element of m_expectedRsrp which is expected to occur next in the simulation.
Definition: lte-test-ue-measurements.h:652
LteUeMeasurementsHandoverTestCase::m_expectedTime
std::vector< Time > m_expectedTime
The list of expected time when measurement reports are received by eNodeB.
Definition: lte-test-ue-measurements.h:634
LteUeMeasurementsHandoverTestCase::m_sourceConfigList
std::list< LteRrcSap::ReportConfigEutra > m_sourceConfigList
The list of active report triggering configuration for the source eNodeB.
Definition: lte-test-ue-measurements.h:622
LteUeMeasurementsHandoverTestCase::DoRun
void DoRun() override
Setup the simulation with the intended UE measurement reporting configuration, run it,...
Definition: lte-test-ue-measurements.cc:2327
LteUeMeasurementsHandoverTestCase::m_expectedTargetCellMeasId
std::set< uint8_t > m_expectedTargetCellMeasId
The list of measurement identities being tested in the target cell.
Definition: lte-test-ue-measurements.h:671
LteUeMeasurementsHandoverTestCase::LteUeMeasurementsHandoverTestCase
LteUeMeasurementsHandoverTestCase(std::string name, std::list< LteRrcSap::ReportConfigEutra > sourceConfigList, std::list< LteRrcSap::ReportConfigEutra > targetConfigList, std::vector< Time > expectedTime, std::vector< uint8_t > expectedRsrp, Time duration)
Constructor.
Definition: lte-test-ue-measurements.cc:2293
LteUeMeasurementsHandoverTestCase::RecvMeasurementReportCallback
void RecvMeasurementReportCallback(std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti, LteRrcSap::MeasurementReport report)
Triggers when either one of the eNodeBs receives measurement report from UE, then perform verificatio...
Definition: lte-test-ue-measurements.cc:2480
LteUeMeasurementsHandoverTestCase::DoTeardown
void DoTeardown() override
Runs at the end of the simulation, verifying that all expected measurement reports have been examined...
Definition: lte-test-ue-measurements.cc:2468
LteUeMeasurementsHandoverTestCase::m_duration
Time m_duration
Duration of simulation.
Definition: lte-test-ue-measurements.h:657
LteUeMeasurementsHandoverTestCase::m_itExpectedTime
std::vector< Time >::iterator m_itExpectedTime
Pointer to the element of m_expectedTime which is expected to occur next in the simulation.
Definition: lte-test-ue-measurements.h:646
LteUeMeasurementsHandoverTestCase::m_targetConfigList
std::list< LteRrcSap::ReportConfigEutra > m_targetConfigList
The list of active report triggering configuration for the target eNodeB.
Definition: lte-test-ue-measurements.h:628
LteUeMeasurementsHandoverTestCase::m_expectedSourceCellMeasId
std::set< uint8_t > m_expectedSourceCellMeasId
The list of measurement identities being tested in the source cell.
Definition: lte-test-ue-measurements.h:664
LteUeMeasurementsHandoverTestCase::m_expectedRsrp
std::vector< uint8_t > m_expectedRsrp
The list of expected values of RSRP (in 3GPP range unit) from the measurement reports received.
Definition: lte-test-ue-measurements.h:640
LteUeMeasurementsHandoverTestSuite
Test suite for generating calls to UE measurements test case ns3::LteUeMeasurementsHandoverTestCase.
Definition: lte-test-ue-measurements.h:537
LteUeMeasurementsPiecewiseTestCase1
Testing UE measurements in LTE with simulation of 1 eNodeB and 1 UE in piecewise configuration and 12...
Definition: lte-test-ue-measurements.h:157
LteUeMeasurementsPiecewiseTestCase1::m_expectedTime
std::vector< Time > m_expectedTime
The list of expected time when measurement reports are received by eNodeB.
Definition: lte-test-ue-measurements.h:229
LteUeMeasurementsPiecewiseTestCase1::TeleportVeryFar
void TeleportVeryFar()
Teleport far function.
Definition: lte-test-ue-measurements.cc:946
LteUeMeasurementsPiecewiseTestCase1::m_config
LteRrcSap::ReportConfigEutra m_config
The active report triggering configuration.
Definition: lte-test-ue-measurements.h:223
LteUeMeasurementsPiecewiseTestCase1::m_expectedMeasId
uint8_t m_expectedMeasId
The measurement identity being tested.
Definition: lte-test-ue-measurements.h:254
LteUeMeasurementsPiecewiseTestCase1::LteUeMeasurementsPiecewiseTestCase1
LteUeMeasurementsPiecewiseTestCase1(std::string name, LteRrcSap::ReportConfigEutra config, std::vector< Time > expectedTime, std::vector< uint8_t > expectedRsrp)
Constructor.
Definition: lte-test-ue-measurements.cc:710
LteUeMeasurementsPiecewiseTestCase1::m_itExpectedTime
std::vector< Time >::iterator m_itExpectedTime
Pointer to the element of m_expectedTime which is expected to occur next in the simulation.
Definition: lte-test-ue-measurements.h:241
LteUeMeasurementsPiecewiseTestCase1::m_ueMobility
Ptr< MobilityModel > m_ueMobility
the mobility model
Definition: lte-test-ue-measurements.h:256
LteUeMeasurementsPiecewiseTestCase1::TeleportVeryNear
void TeleportVeryNear()
Teleport very near function.
Definition: lte-test-ue-measurements.cc:925
LteUeMeasurementsPiecewiseTestCase1::TeleportNear
void TeleportNear()
Teleport near function.
Definition: lte-test-ue-measurements.cc:932
LteUeMeasurementsPiecewiseTestCase1::m_expectedRsrp
std::vector< uint8_t > m_expectedRsrp
The list of expected values of RSRP (in 3GPP range unit) from the measurement reports received.
Definition: lte-test-ue-measurements.h:235
LteUeMeasurementsPiecewiseTestCase1::DoTeardown
void DoTeardown() override
Runs at the end of the simulation, verifying that all expected measurement reports have been examined...
Definition: lte-test-ue-measurements.cc:854
LteUeMeasurementsPiecewiseTestCase1::m_itExpectedRsrp
std::vector< uint8_t >::iterator m_itExpectedRsrp
Pointer to the element of m_expectedRsrp which is expected to occur next in the simulation.
Definition: lte-test-ue-measurements.h:247
LteUeMeasurementsPiecewiseTestCase1::RecvMeasurementReportCallback
void RecvMeasurementReportCallback(std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti, LteRrcSap::MeasurementReport report)
Triggers when eNodeB receives measurement report from UE, then perform verification on it.
Definition: lte-test-ue-measurements.cc:866
LteUeMeasurementsPiecewiseTestCase1::DoRun
void DoRun() override
Setup the simulation with the intended UE measurement reporting configuration, run it,...
Definition: lte-test-ue-measurements.cc:740
LteUeMeasurementsPiecewiseTestCase2
Testing UE measurements in LTE with simulation of 2 eNodeB and 1 UE in piecewise configuration and 24...
Definition: lte-test-ue-measurements.h:292
LteUeMeasurementsPiecewiseTestCase2::m_ueMobility
Ptr< MobilityModel > m_ueMobility
the mobility model
Definition: lte-test-ue-measurements.h:391
LteUeMeasurementsPiecewiseTestCase2::m_itExpectedTime
std::vector< Time >::iterator m_itExpectedTime
Pointer to the element of m_expectedTime which is expected to occur next in the simulation.
Definition: lte-test-ue-measurements.h:376
LteUeMeasurementsPiecewiseTestCase2::TeleportVeryNear
void TeleportVeryNear()
Teleport very near function.
Definition: lte-test-ue-measurements.cc:1665
LteUeMeasurementsPiecewiseTestCase2::m_expectedRsrp
std::vector< uint8_t > m_expectedRsrp
The list of expected values of RSRP (in 3GPP range unit) from the measurement reports received.
Definition: lte-test-ue-measurements.h:370
LteUeMeasurementsPiecewiseTestCase2::DoTeardown
void DoTeardown() override
Runs at the end of the simulation, verifying that all expected measurement reports have been examined...
Definition: lte-test-ue-measurements.cc:1562
LteUeMeasurementsPiecewiseTestCase2::LteUeMeasurementsPiecewiseTestCase2
LteUeMeasurementsPiecewiseTestCase2(std::string name, LteRrcSap::ReportConfigEutra config, std::vector< Time > expectedTime, std::vector< uint8_t > expectedRsrp)
Constructor.
Definition: lte-test-ue-measurements.cc:1413
LteUeMeasurementsPiecewiseTestCase2::m_config
LteRrcSap::ReportConfigEutra m_config
The active report triggering configuration.
Definition: lte-test-ue-measurements.h:358
LteUeMeasurementsPiecewiseTestCase2::DoRun
void DoRun() override
Setup the simulation with the intended UE measurement reporting configuration, run it,...
Definition: lte-test-ue-measurements.cc:1443
LteUeMeasurementsPiecewiseTestCase2::RecvMeasurementReportCallback
void RecvMeasurementReportCallback(std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti, LteRrcSap::MeasurementReport report)
Triggers when eNodeB receives measurement report from UE, then perform verification on it.
Definition: lte-test-ue-measurements.cc:1574
LteUeMeasurementsPiecewiseTestCase2::TeleportVeryFar
void TeleportVeryFar()
Teleport very far function.
Definition: lte-test-ue-measurements.cc:1686
LteUeMeasurementsPiecewiseTestCase2::TeleportNear
void TeleportNear()
Teleport near function.
Definition: lte-test-ue-measurements.cc:1672
LteUeMeasurementsPiecewiseTestCase2::m_itExpectedRsrp
std::vector< uint8_t >::iterator m_itExpectedRsrp
Pointer to the element of m_expectedRsrp which is expected to occur next in the simulation.
Definition: lte-test-ue-measurements.h:382
LteUeMeasurementsPiecewiseTestCase2::m_expectedMeasId
uint8_t m_expectedMeasId
The measurement identity being tested.
Definition: lte-test-ue-measurements.h:389
LteUeMeasurementsPiecewiseTestCase2::m_expectedTime
std::vector< Time > m_expectedTime
The list of expected time when measurement reports are received by eNodeB.
Definition: lte-test-ue-measurements.h:364
LteUeMeasurementsPiecewiseTestCase3
Testing UE measurements in LTE with simulation of 3 eNodeB and 1 UE in piecewise configuration and 24...
Definition: lte-test-ue-measurements.h:445
LteUeMeasurementsPiecewiseTestCase3::m_enbMobility
Ptr< MobilityModel > m_enbMobility
the mobility model
Definition: lte-test-ue-measurements.h:524
LteUeMeasurementsPiecewiseTestCase3::LteUeMeasurementsPiecewiseTestCase3
LteUeMeasurementsPiecewiseTestCase3(std::string name, LteRrcSap::ReportConfigEutra config, std::vector< Time > expectedTime)
Constructor.
Definition: lte-test-ue-measurements.cc:1741
LteUeMeasurementsPiecewiseTestCase3::DoTeardown
void DoTeardown() override
Runs at the end of the simulation, verifying that all expected measurement reports have been examined...
Definition: lte-test-ue-measurements.cc:1856
LteUeMeasurementsPiecewiseTestCase3::DoRun
void DoRun() override
Setup the simulation with the intended UE measurement reporting configuration, run it,...
Definition: lte-test-ue-measurements.cc:1762
LteUeMeasurementsPiecewiseTestCase3::RecvMeasurementReportCallback
void RecvMeasurementReportCallback(std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti, LteRrcSap::MeasurementReport report)
Triggers when eNodeB receives measurement report from UE, then perform verification on it.
Definition: lte-test-ue-measurements.cc:1867
LteUeMeasurementsPiecewiseTestCase3::m_config
LteRrcSap::ReportConfigEutra m_config
The active report triggering configuration.
Definition: lte-test-ue-measurements.h:503
LteUeMeasurementsPiecewiseTestCase3::m_expectedMeasId
uint8_t m_expectedMeasId
The measurement identity being tested.
Definition: lte-test-ue-measurements.h:522
LteUeMeasurementsPiecewiseTestCase3::m_expectedTime
std::vector< Time > m_expectedTime
The list of expected time when measurement reports are received by eNodeB.
Definition: lte-test-ue-measurements.h:509
LteUeMeasurementsPiecewiseTestCase3::TeleportEnbNear
void TeleportEnbNear()
Teleport the eNb near function.
Definition: lte-test-ue-measurements.cc:1952
LteUeMeasurementsPiecewiseTestCase3::m_itExpectedTime
std::vector< Time >::iterator m_itExpectedTime
Pointer to the element of m_expectedTime which is expected to occur next in the simulation.
Definition: lte-test-ue-measurements.h:515
LteUeMeasurementsPiecewiseTestSuite1
Test suite for generating calls to UE measurements test case ns3::LteUeMeasurementsPiecewiseTestCase1...
Definition: lte-test-ue-measurements.h:134
LteUeMeasurementsPiecewiseTestSuite2
Test suite for generating calls to UE measurements test case ns3::LteUeMeasurementsPiecewiseTestCase2...
Definition: lte-test-ue-measurements.h:269
LteUeMeasurementsPiecewiseTestSuite3
Test suite for generating calls to UE measurements test case ns3::LteUeMeasurementsPiecewiseTestCase3...
Definition: lte-test-ue-measurements.h:404
LteUeMeasurementsTestCase
Test that UE measurements calculation works properly in a scenario with 2 eNodeBs and 2UEs.
Definition: lte-test-ue-measurements.h:66
LteUeMeasurementsTestCase::m_d1
double m_d1
distance between UE and ENB node pair
Definition: lte-test-ue-measurements.h:117
LteUeMeasurementsTestCase::m_rsrqDbUeServingCell
double m_rsrqDbUeServingCell
RSRQ in dBm UE 1.
Definition: lte-test-ue-measurements.h:121
LteUeMeasurementsTestCase::m_rsrpDbmUeServingCell
double m_rsrpDbmUeServingCell
RSRP in dBm UE 1.
Definition: lte-test-ue-measurements.h:119
LteUeMeasurementsTestCase::LteUeMeasurementsTestCase
LteUeMeasurementsTestCase(std::string name, double d1, double d2, double rsrpDbmUe1, double rsrpDbmUe2, double rsrqDbUe1, double rsrqDbUe2)
Constructor.
Definition: lte-test-ue-measurements.cc:245
LteUeMeasurementsTestCase::ReportUeMeasurements
void ReportUeMeasurements(uint16_t rnti, uint16_t cellId, double rsrp, double rsrq, bool servingCell)
Report UE measurements function.
Definition: lte-test-ue-measurements.cc:352
LteUeMeasurementsTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-ue-measurements.cc:268
LteUeMeasurementsTestCase::m_rsrqDbUeNeighborCell
double m_rsrqDbUeNeighborCell
RSRQ in dBm UE 2.
Definition: lte-test-ue-measurements.h:122
LteUeMeasurementsTestCase::m_d2
double m_d2
distance between UE and other ENB node
Definition: lte-test-ue-measurements.h:118
LteUeMeasurementsTestCase::m_rsrpDbmUeNeighborCell
double m_rsrpDbmUeNeighborCell
RSRP in dBm UE 2.
Definition: lte-test-ue-measurements.h:120
LteUeMeasurementsTestCase::RecvMeasurementReport
void RecvMeasurementReport(uint64_t imsi, uint16_t cellId, uint16_t rnti, LteRrcSap::MeasurementReport meas)
Reeive measurement report function.
Definition: lte-test-ue-measurements.cc:382
LteUeMeasurementsTestSuite
Test that UE Measurements (see 36.214) calculation works fine in a multi-cell interference scenario.
Definition: lte-test-ue-measurements.h:53
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37
ns3::DataRate
Class for representing data rates.
Definition: data-rate.h:89
DataRateValue
AttributeValue implementation for DataRate.
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
ns3::EnumValue
Hold variables of type enum.
Definition: enum.h:56
ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
ns3::EpsBearer::Qci
Qci
QoS Class Indicator.
Definition: eps-bearer.h:106
ns3::EpsBearer::GBR_CONV_VOICE
@ GBR_CONV_VOICE
GBR Conversational Voice.
Definition: eps-bearer.h:107
ns3::EutranMeasurementMapping::Dbm2RsrpRange
static uint8_t Dbm2RsrpRange(double dbm)
convert an RSRP value in dBm to the corresponding range as per 3GPP TS 36.133 section 9....
Definition: lte-common.cc:242
ns3::EutranMeasurementMapping::RsrpRange2Dbm
static double RsrpRange2Dbm(uint8_t range)
converts an RSRP range to dBm as per 3GPP TS 36.133 section 9.1.4 RSRP Measurement Report Mapping
Definition: lte-common.cc:234
ns3::EutranMeasurementMapping::RsrqRange2Db
static double RsrqRange2Db(uint8_t range)
converts an RSRQ range to dB as per 3GPP TS 36.133 section 9.1.7 RSRQ Measurement Report Mapping
Definition: lte-common.cc:250
ns3::EutranMeasurementMapping::Db2RsrqRange
static uint8_t Db2RsrqRange(double db)
convert an RSRQ value in dB to the corresponding range as per 3GPP TS 36.133 section 9....
Definition: lte-common.cc:258
ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition: internet-stack-helper.h:92
ns3::Ipv4AddressHelper
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Definition: ipv4-address-helper.h:49
ns3::Ipv4AddressHelper::SetBase
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Definition: ipv4-address-helper.cc:64
ns3::Ipv4AddressHelper::Assign
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Definition: ipv4-address-helper.cc:132
ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:42
ns3::Ipv4
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:79
ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Definition: ipv4-interface-container.h:56
ns3::Ipv4Mask
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:257
ns3::Ipv4StaticRoutingHelper
Helper class that adds ns3::Ipv4StaticRouting objects.
Definition: ipv4-static-routing-helper.h:43
ns3::Ipv4StaticRoutingHelper::GetStaticRouting
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...
Definition: ipv4-static-routing-helper.cc:59
ns3::LteAmc::PiroEW2010
@ PiroEW2010
Definition: lte-amc.h:63
ns3::LteEnbNetDevice
The eNodeB device implementation.
Definition: lte-enb-net-device.h:59
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:44
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:40
ns3::MobilityModel::SetPosition
void SetPosition(const Vector &position)
Definition: mobility-model.cc:92
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43
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:67
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:40
ns3::NodeContainer::GetN
uint32_t GetN() const
Get the number of Ptr<Node> stored in this container.
Definition: node-container.cc:72
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:84
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:78
ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
ns3::PointToPointHelper
Build a set of PointToPointNetDevice objects.
Definition: point-to-point-helper.h:44
ns3::PointToPointHelper::SetDeviceAttribute
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
Definition: point-to-point-helper.cc:54
ns3::PointToPointHelper::SetChannelAttribute
void SetChannelAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each Channel created by the helper.
Definition: point-to-point-helper.cc:60
ns3::PointToPointHelper::Install
NetDeviceContainer Install(NodeContainer c)
Definition: point-to-point-helper.cc:233
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:568
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:140
ns3::Simulator::Now
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:199
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition: simulator.cc:176
ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:184
ns3::StringValue
Hold variables of type string.
Definition: string.h:56
ns3::TestCase
encapsulates test code
Definition: test.h:1060
ns3::TestCase::EXTENSIVE
@ EXTENSIVE
Medium length test.
Definition: test.h:1066
ns3::TestCase::TAKES_FOREVER
@ TAKES_FOREVER
Very long running test.
Definition: test.h:1067
ns3::TestCase::QUICK
@ QUICK
Fast test.
Definition: test.h:1065
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:301
ns3::TestCase::GetName
std::string GetName() const
Definition: test.cc:373
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
ns3::Time::GetMilliSeconds
int64_t GetMilliSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:407
ns3::Time::S
@ S
second
Definition: nstime.h:116
ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1423
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:45
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:66
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:891
ns3::Config::Connect
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:975
NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:179
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
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:238
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
lteUeMeasurementsPiecewiseTestSuite2
static LteUeMeasurementsPiecewiseTestSuite2 lteUeMeasurementsPiecewiseTestSuite2
Static variable for test initialization.
Definition: lte-test-ue-measurements.cc:1407
lteUeMeasurementsHandoverTestSuite
static LteUeMeasurementsHandoverTestSuite lteUeMeasurementsHandoverTestSuite
Static variable for test initialization.
Definition: lte-test-ue-measurements.cc:2287
lteUeMeasurementsTestSuite
static LteUeMeasurementsTestSuite lteUeMeasurementsTestSuite
Static variable for test initialization.
Definition: lte-test-ue-measurements.cc:239
lteUeMeasurementsPiecewiseTestSuite1
static LteUeMeasurementsPiecewiseTestSuite1 lteUeMeasurementsPiecewiseTestSuite1
Static variable for test initialization.
Definition: lte-test-ue-measurements.cc:704
lteUeMeasurementsPiecewiseTestSuite3
static LteUeMeasurementsPiecewiseTestSuite3 lteUeMeasurementsPiecewiseTestSuite3
Static variable for test initialization.
Definition: lte-test-ue-measurements.cc:1735
ns3::MakeBoundCallback
auto MakeBoundCallback(R(*fnPtr)(Args...), BArgs &&... bargs)
Make Callbacks with varying number of bound arguments.
Definition: callback.h:763
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:144
NS_TEST_ASSERT_MSG_EQ_TOL
#define NS_TEST_ASSERT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report and...
Definition: test.h:337
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1348
ReportUeMeasurementsCallback
void ReportUeMeasurementsCallback(LteUeMeasurementsTestCase *testcase, std::string path, uint16_t rnti, uint16_t cellId, double rsrp, double rsrq, bool servingCell, uint8_t componentCarrierId)
Definition: lte-test-ue-measurements.cc:59
operator<<
std::vector< Time > & operator<<(std::vector< Time > &v, const uint64_t &ms)
Definition: lte-test-ue-measurements.cc:433
RecvMeasurementReportCallback
void RecvMeasurementReportCallback(LteUeMeasurementsTestCase *testcase, std::string path, uint64_t imsi, uint16_t cellId, uint16_t rnti, LteRrcSap::MeasurementReport meas)
Definition: lte-test-ue-measurements.cc:72
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:702
ns3::UE_MEASUREMENT_REPORT_DELAY
static const Time UE_MEASUREMENT_REPORT_DELAY
Artificial delay of UE measurements procedure.
Definition: lte-ue-rrc.h:63
ns3::LteRrcSap::MeasResultPCell::rsrqResult
uint8_t rsrqResult
the RSRQ result
Definition: lte-rrc-sap.h:675
ns3::LteRrcSap::MeasResultPCell::rsrpResult
uint8_t rsrpResult
the RSRP result
Definition: lte-rrc-sap.h:674
ns3::LteRrcSap::MeasResults
MeasResults structure.
Definition: lte-rrc-sap.h:717
ns3::LteRrcSap::MeasResults::measId
uint8_t measId
measure ID
Definition: lte-rrc-sap.h:718
ns3::LteRrcSap::MeasResults::haveMeasResultNeighCells
bool haveMeasResultNeighCells
have measure result neighbor cells
Definition: lte-rrc-sap.h:720
ns3::LteRrcSap::MeasResults::measResultListEutra
std::list< MeasResultEutra > measResultListEutra
measure result list eutra
Definition: lte-rrc-sap.h:721
ns3::LteRrcSap::MeasResults::measResultPCell
MeasResultPCell measResultPCell
measurement result primary cell
Definition: lte-rrc-sap.h:719
ns3::LteRrcSap::MeasurementReport
MeasurementReport structure.
Definition: lte-rrc-sap.h:948
ns3::LteRrcSap::MeasurementReport::measResults
MeasResults measResults
measure results
Definition: lte-rrc-sap.h:949
ns3::LteRrcSap::ReportConfigEutra
Specifies criteria for triggering of an E-UTRA measurement reporting event.
Definition: lte-rrc-sap.h:373
ns3::LteRrcSap::ReportConfigEutra::reportOnLeave
bool reportOnLeave
Indicates whether or not the UE shall initiate the measurement reporting procedure when the leaving c...
Definition: lte-rrc-sap.h:399
ns3::LteRrcSap::ReportConfigEutra::eventId
enum ns3::LteRrcSap::ReportConfigEutra::@62 eventId
Event enumeration.
ns3::LteRrcSap::ReportConfigEutra::triggerType
enum ns3::LteRrcSap::ReportConfigEutra::@61 triggerType
Trigger enumeration.
ns3::LteRrcSap::ReportConfigEutra::hysteresis
uint8_t hysteresis
Parameter used within the entry and leave condition of an event triggered reporting condition.
Definition: lte-rrc-sap.h:407
ns3::LteRrcSap::ReportConfigEutra::RSRP
@ RSRP
Reference Signal Received Power.
Definition: lte-rrc-sap.h:425
ns3::LteRrcSap::ReportConfigEutra::EVENT_A2
@ EVENT_A2
Event A2: Serving becomes worse than absolute threshold.
Definition: lte-rrc-sap.h:385
ns3::LteRrcSap::ReportConfigEutra::EVENT_A3
@ EVENT_A3
Event A3: Neighbour becomes amount of offset better than PCell.
Definition: lte-rrc-sap.h:386
ns3::LteRrcSap::ReportConfigEutra::EVENT_A4
@ EVENT_A4
Event A4: Neighbour becomes better than absolute threshold.
Definition: lte-rrc-sap.h:387
ns3::LteRrcSap::ReportConfigEutra::EVENT_A1
@ EVENT_A1
Event A1: Serving becomes better than absolute threshold.
Definition: lte-rrc-sap.h:384
ns3::LteRrcSap::ReportConfigEutra::EVENT_A5
@ EVENT_A5
Event A5: PCell becomes worse than absolute threshold1 AND Neighbour becomes better than another abso...
Definition: lte-rrc-sap.h:388
ns3::LteRrcSap::ReportConfigEutra::reportInterval
enum ns3::LteRrcSap::ReportConfigEutra::@65 reportInterval
Report interval enumeration.
ns3::LteRrcSap::ReportConfigEutra::threshold2
ThresholdEutra threshold2
Threshold for event A5.
Definition: lte-rrc-sap.h:394
ns3::LteRrcSap::ReportConfigEutra::triggerQuantity
enum ns3::LteRrcSap::ReportConfigEutra::@63 triggerQuantity
Trigger type enumeration.
ns3::LteRrcSap::ReportConfigEutra::threshold1
ThresholdEutra threshold1
Threshold for event A1, A2, A4, and A5.
Definition: lte-rrc-sap.h:393
ns3::LteRrcSap::ReportConfigEutra::a3Offset
int8_t a3Offset
Offset value for Event A3.
Definition: lte-rrc-sap.h:403
ns3::LteRrcSap::ReportConfigEutra::timeToTrigger
uint16_t timeToTrigger
Time during which specific criteria for the event needs to be met in order to trigger a measurement r...
Definition: lte-rrc-sap.h:411
ns3::LteRrcSap::ThresholdEutra::THRESHOLD_RSRP
@ THRESHOLD_RSRP
RSRP is used for the threshold.
Definition: lte-rrc-sap.h:364
ns3::LteRrcSap::ThresholdEutra::choice
enum ns3::LteRrcSap::ThresholdEutra::@60 choice
Threshold enumeration.
ns3::LteRrcSap::ThresholdEutra::range
uint8_t range
Value range used in RSRP/RSRQ threshold.
Definition: lte-rrc-sap.h:368