A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
test-lte-x2-handover.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Nicola Baldo <nbaldo@cttc.es>
19  */
20 
21 
22 #include <ns3/core-module.h>
23 #include <ns3/network-module.h>
24 #include <ns3/mobility-module.h>
25 #include <ns3/lte-module.h>
26 #include <ns3/internet-module.h>
27 #include <ns3/applications-module.h>
28 #include <ns3/point-to-point-module.h>
29 
30 NS_LOG_COMPONENT_DEFINE ("LteX2HandoverTest");
31 
32 namespace ns3 {
33 
34 struct HandoverEvent
35 {
36  Time startTime;
37  uint32_t ueDeviceIndex;
38  uint32_t sourceEnbDeviceIndex;
39  uint32_t targetEnbDeviceIndex;
40 };
41 
42 
43 class LteX2HandoverTestCase : public TestCase
44 {
45 public:
46 
58  LteX2HandoverTestCase (uint32_t nUes, uint32_t nDedicatedBearers, std::list<HandoverEvent> handoverEventList, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc);
59 
60 private:
61  static std::string BuildNameString (uint32_t nUes, uint32_t nDedicatedBearers, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc);
62  virtual void DoRun (void);
63  void CheckConnected (Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice);
64 
65  uint32_t m_nUes; // number of UEs in the test
66  uint32_t m_nDedicatedBearers; // number of UEs in the test
67  std::list<HandoverEvent> m_handoverEventList;
68  std::string m_handoverEventListName;
69  bool m_epc;
70  bool m_useUdp;
71  std::string m_schedulerType;
72  bool m_admitHo;
73  bool m_useIdealRrc;
74  Ptr<LteHelper> m_lteHelper;
75  Ptr<EpcHelper> m_epcHelper;
76 
77  struct BearerData
78  {
79  uint32_t bid;
80  Ptr<PacketSink> dlSink;
81  Ptr<PacketSink> ulSink;
82  uint32_t dlOldTotalRx;
83  uint32_t ulOldTotalRx;
84  };
85 
86  struct UeData
87  {
88  uint32_t id;
89  std::list<BearerData> bearerDataList;
90  };
91 
92  void SaveStatsAfterHandover (uint32_t ueIndex);
93  void CheckStatsAWhileAfterHandover (uint32_t ueIndex);
94 
95  std::vector<UeData> m_ueDataVector;
96 
97  const Time m_maxHoDuration;
98  const Time m_statsDuration;
99  const Time m_udpClientInterval;
100  const uint32_t m_udpClientPktSize;
101 
102 };
103 
104 
105 std::string LteX2HandoverTestCase::BuildNameString (uint32_t nUes, uint32_t nDedicatedBearers, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc)
106 {
107  std::ostringstream oss;
108  oss << " nUes=" << nUes
109  << " nDedicatedBearers=" << nDedicatedBearers
110  << " udp=" << useUdp
111  << " " << schedulerType
112  << " admitHo=" << admitHo
113  << " hoList: " << handoverEventListName;
114  if (useIdealRrc)
115  {
116  oss << ", ideal RRC";
117  }
118  else
119  {
120  oss << ", real RRC";
121  }
122  return oss.str ();
123 }
124 
125 LteX2HandoverTestCase::LteX2HandoverTestCase (uint32_t nUes, uint32_t nDedicatedBearers, std::list<HandoverEvent> handoverEventList, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc)
126  : TestCase (BuildNameString (nUes, nDedicatedBearers, handoverEventListName, useUdp, schedulerType, admitHo, useIdealRrc)),
127  m_nUes (nUes),
128  m_nDedicatedBearers (nDedicatedBearers),
129  m_handoverEventList (handoverEventList),
130  m_handoverEventListName (handoverEventListName),
131  m_epc (true),
132  m_useUdp (useUdp),
133  m_schedulerType (schedulerType),
134  m_admitHo (admitHo),
135  m_useIdealRrc (useIdealRrc),
136  m_maxHoDuration (Seconds (0.1)),
137  m_statsDuration (Seconds (0.1)),
138  m_udpClientInterval (Seconds (0.01)),
139  m_udpClientPktSize (100)
140 
141 {
142 }
143 
144 void
145 LteX2HandoverTestCase::DoRun ()
146 {
147  NS_LOG_FUNCTION (this << BuildNameString (m_nUes, m_nDedicatedBearers, m_handoverEventListName, m_useUdp, m_schedulerType, m_admitHo, m_useIdealRrc));
148 
149  Config::Reset ();
150  Config::SetDefault ("ns3::UdpClient::Interval", TimeValue (m_udpClientInterval));
151  Config::SetDefault ("ns3::UdpClient::MaxPackets", UintegerValue (1000000));
152  Config::SetDefault ("ns3::UdpClient::PacketSize", UintegerValue (m_udpClientPktSize));
153 
154  int64_t stream = 1;
155 
156  m_lteHelper = CreateObject<LteHelper> ();
157  m_lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel"));
158  m_lteHelper->SetSchedulerType (m_schedulerType);
159  m_lteHelper->SetAttribute ("UseIdealRrc", BooleanValue (m_useIdealRrc));
160 
161 
162  NodeContainer enbNodes;
163  enbNodes.Create (2);
164  NodeContainer ueNodes;
165  ueNodes.Create (m_nUes);
166 
167  if (m_epc)
168  {
169  m_epcHelper = CreateObject<EpcHelper> ();
170  m_lteHelper->SetEpcHelper (m_epcHelper);
171  }
172 
173  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
174  positionAlloc->Add (Vector (-3000, 0, 0)); // enb0
175  positionAlloc->Add (Vector ( 3000, 0, 0)); // enb1
176  for (uint16_t i = 0; i < m_nUes; i++)
177  {
178  positionAlloc->Add (Vector (0, 0, 0));
179  }
180  MobilityHelper mobility;
181  mobility.SetPositionAllocator (positionAlloc);
182  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
183  mobility.Install (enbNodes);
184  mobility.Install (ueNodes);
185 
186  NetDeviceContainer enbDevices;
187  enbDevices = m_lteHelper->InstallEnbDevice (enbNodes);
188  stream += m_lteHelper->AssignStreams (enbDevices, stream);
189  for (NetDeviceContainer::Iterator it = enbDevices.Begin ();
190  it != enbDevices.End ();
191  ++it)
192  {
193  Ptr<LteEnbRrc> enbRrc = (*it)->GetObject<LteEnbNetDevice> ()->GetRrc ();
194  enbRrc->SetAttribute ("AdmitHandoverRequest", BooleanValue (m_admitHo));
195  }
196 
197  NetDeviceContainer ueDevices;
198  ueDevices = m_lteHelper->InstallUeDevice (ueNodes);
199  stream += m_lteHelper->AssignStreams (ueDevices, stream);
200 
201  Ipv4Address remoteHostAddr;
202  Ipv4StaticRoutingHelper ipv4RoutingHelper;
203  Ipv4InterfaceContainer ueIpIfaces;
204  Ptr<Node> remoteHost;
205  if (m_epc)
206  {
207  // Create a single RemoteHost
208  NodeContainer remoteHostContainer;
209  remoteHostContainer.Create (1);
210  remoteHost = remoteHostContainer.Get (0);
211  InternetStackHelper internet;
212  internet.Install (remoteHostContainer);
213 
214  // Create the Internet
215  PointToPointHelper p2ph;
216  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
217  p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));
218  p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.010)));
219  Ptr<Node> pgw = m_epcHelper->GetPgwNode ();
220  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);
221  Ipv4AddressHelper ipv4h;
222  ipv4h.SetBase ("1.0.0.0", "255.0.0.0");
223  Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign (internetDevices);
224  // in this container, interface 0 is the pgw, 1 is the remoteHost
225  remoteHostAddr = internetIpIfaces.GetAddress (1);
226 
227  Ipv4StaticRoutingHelper ipv4RoutingHelper;
228  Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());
229  remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.0.0.0"), 1);
230 
231  // Install the IP stack on the UEs
232  internet.Install (ueNodes);
233  ueIpIfaces = m_epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevices));
234  }
235 
236  // attachment (needs to be done after IP stack configuration)
237  // all UEs attached to eNB 0 at the beginning
238  m_lteHelper->Attach (ueDevices, enbDevices.Get (0));
239 
240  if (m_epc)
241  {
242  // always true: bool epcDl = true;
243  // always true: bool epcUl = true;
244  // the rest of this block is copied from lena-dual-stripe
245 
246 
247  // Install and start applications on UEs and remote host
248  uint16_t dlPort = 10000;
249  uint16_t ulPort = 20000;
250 
251  // randomize a bit start times to avoid simulation artifacts
252  // (e.g., buffer overflows due to packet transmissions happening
253  // exactly at the same time)
254  Ptr<UniformRandomVariable> startTimeSeconds = CreateObject<UniformRandomVariable> ();
255  startTimeSeconds->SetAttribute ("Min", DoubleValue (0));
256  startTimeSeconds->SetAttribute ("Max", DoubleValue (0.010));
257  startTimeSeconds->SetStream (stream++);
258 
259  for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
260  {
261  Ptr<Node> ue = ueNodes.Get (u);
262  // Set the default gateway for the UE
263  Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ue->GetObject<Ipv4> ());
264  ueStaticRouting->SetDefaultRoute (m_epcHelper->GetUeDefaultGatewayAddress (), 1);
265 
266  UeData ueData;
267 
268  for (uint32_t b = 0; b < m_nDedicatedBearers; ++b)
269  {
270  ++dlPort;
271  ++ulPort;
272 
273  ApplicationContainer clientApps;
274  ApplicationContainer serverApps;
275  BearerData bearerData;
276 
277  if (m_useUdp)
278  {
279  // always true: if (epcDl)
280  {
281  UdpClientHelper dlClientHelper (ueIpIfaces.GetAddress (u), dlPort);
282  clientApps.Add (dlClientHelper.Install (remoteHost));
283  PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory",
284  InetSocketAddress (Ipv4Address::GetAny (), dlPort));
285  ApplicationContainer sinkContainer = dlPacketSinkHelper.Install (ue);
286  bearerData.dlSink = sinkContainer.Get (0)->GetObject<PacketSink> ();
287  serverApps.Add (sinkContainer);
288 
289  }
290  // always true: if (epcUl)
291  {
292  UdpClientHelper ulClientHelper (remoteHostAddr, ulPort);
293  clientApps.Add (ulClientHelper.Install (ue));
294  PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory",
295  InetSocketAddress (Ipv4Address::GetAny (), ulPort));
296  ApplicationContainer sinkContainer = ulPacketSinkHelper.Install (remoteHost);
297  bearerData.ulSink = sinkContainer.Get (0)->GetObject<PacketSink> ();
298  serverApps.Add (sinkContainer);
299  }
300  }
301  else // use TCP
302  {
303  // always true: if (epcDl)
304  {
305  BulkSendHelper dlClientHelper ("ns3::TcpSocketFactory",
306  InetSocketAddress (ueIpIfaces.GetAddress (u), dlPort));
307  dlClientHelper.SetAttribute ("MaxBytes", UintegerValue (0));
308  clientApps.Add (dlClientHelper.Install (remoteHost));
309  PacketSinkHelper dlPacketSinkHelper ("ns3::TcpSocketFactory",
310  InetSocketAddress (Ipv4Address::GetAny (), dlPort));
311  ApplicationContainer sinkContainer = dlPacketSinkHelper.Install (ue);
312  bearerData.dlSink = sinkContainer.Get (0)->GetObject<PacketSink> ();
313  serverApps.Add (sinkContainer);
314  }
315  // always true: if (epcUl)
316  {
317  BulkSendHelper ulClientHelper ("ns3::TcpSocketFactory",
318  InetSocketAddress (remoteHostAddr, ulPort));
319  ulClientHelper.SetAttribute ("MaxBytes", UintegerValue (0));
320  clientApps.Add (ulClientHelper.Install (ue));
321  PacketSinkHelper ulPacketSinkHelper ("ns3::TcpSocketFactory",
322  InetSocketAddress (Ipv4Address::GetAny (), ulPort));
323  ApplicationContainer sinkContainer = ulPacketSinkHelper.Install (remoteHost);
324  bearerData.ulSink = sinkContainer.Get (0)->GetObject<PacketSink> ();
325  serverApps.Add (sinkContainer);
326  }
327  } // end if (useUdp)
328 
329  Ptr<EpcTft> tft = Create<EpcTft> ();
330  // always true: if (epcDl)
331  {
332  EpcTft::PacketFilter dlpf;
333  dlpf.localPortStart = dlPort;
334  dlpf.localPortEnd = dlPort;
335  tft->Add (dlpf);
336  }
337  // always true: if (epcUl)
338  {
339  EpcTft::PacketFilter ulpf;
340  ulpf.remotePortStart = ulPort;
341  ulpf.remotePortEnd = ulPort;
342  tft->Add (ulpf);
343  }
344 
345  // always true: if (epcDl || epcUl)
346  {
347  EpsBearer bearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT);
348  m_lteHelper->ActivateDedicatedEpsBearer (ueDevices.Get (u), bearer, tft);
349  }
350  Time startTime = Seconds (startTimeSeconds->GetValue ());
351  serverApps.Start (startTime);
352  clientApps.Start (startTime);
353 
354  ueData.bearerDataList.push_back (bearerData);
355 
356  } // end for b
357 
358  m_ueDataVector.push_back (ueData);
359  }
360 
361  }
362  else // (epc == false)
363  {
364  // for radio bearer activation purposes, consider together home UEs and macro UEs
365  for (uint32_t u = 0; u < ueDevices.GetN (); ++u)
366  {
367  Ptr<NetDevice> ueDev = ueDevices.Get (u);
368  for (uint32_t b = 0; b < m_nDedicatedBearers; ++b)
369  {
370  enum EpsBearer::Qci q = EpsBearer::NGBR_VIDEO_TCP_DEFAULT;
371  EpsBearer bearer (q);
372  m_lteHelper->ActivateDataRadioBearer (ueDev, bearer);
373  }
374  }
375  }
376 
377 
378  m_lteHelper->AddX2Interface (enbNodes);
379 
380  // check initial RRC connection
381  const Time maxRrcConnectionEstablishmentDuration = Seconds (0.080);
382  for (NetDeviceContainer::Iterator it = ueDevices.Begin (); it != ueDevices.End (); ++it)
383  {
384  Simulator::Schedule (maxRrcConnectionEstablishmentDuration,
385  &LteX2HandoverTestCase::CheckConnected,
386  this, *it, enbDevices.Get (0));
387  }
388 
389  // schedule handover events and corresponding checks
390 
391  Time stopTime = Seconds (0);
392  for (std::list<HandoverEvent>::iterator hoEventIt = m_handoverEventList.begin ();
393  hoEventIt != m_handoverEventList.end ();
394  ++hoEventIt)
395  {
396  Simulator::Schedule (hoEventIt->startTime,
397  &LteX2HandoverTestCase::CheckConnected,
398  this,
399  ueDevices.Get (hoEventIt->ueDeviceIndex),
400  enbDevices.Get (hoEventIt->sourceEnbDeviceIndex));
401  m_lteHelper->HandoverRequest (hoEventIt->startTime,
402  ueDevices.Get (hoEventIt->ueDeviceIndex),
403  enbDevices.Get (hoEventIt->sourceEnbDeviceIndex),
404  enbDevices.Get (hoEventIt->targetEnbDeviceIndex));
405  Time hoEndTime = hoEventIt->startTime + m_maxHoDuration;
406  Simulator::Schedule (hoEndTime,
407  &LteX2HandoverTestCase::CheckConnected,
408  this,
409  ueDevices.Get (hoEventIt->ueDeviceIndex),
410  enbDevices.Get (m_admitHo ? hoEventIt->targetEnbDeviceIndex : hoEventIt->sourceEnbDeviceIndex));
411  Simulator::Schedule (hoEndTime, &LteX2HandoverTestCase::SaveStatsAfterHandover,
412  this, hoEventIt->ueDeviceIndex);
413 
414  Time checkStatsAfterHoTime = hoEndTime + m_statsDuration;
415  Simulator::Schedule (checkStatsAfterHoTime, &LteX2HandoverTestCase::CheckStatsAWhileAfterHandover,
416  this, hoEventIt->ueDeviceIndex);
417  if (stopTime <= checkStatsAfterHoTime)
418  {
419  stopTime = checkStatsAfterHoTime + MilliSeconds (1);
420  }
421  }
422 
423  // m_lteHelper->EnableRlcTraces ();
424  // m_lteHelper->EnablePdcpTraces();
425 
426 
427  Simulator::Stop (stopTime);
428 
429  Simulator::Run ();
430 
431  Simulator::Destroy ();
432 
433 }
434 
435 void
436 LteX2HandoverTestCase::CheckConnected (Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice)
437 {
438  Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice> ();
439  Ptr<LteUeRrc> ueRrc = ueLteDevice->GetRrc ();
440  NS_TEST_ASSERT_MSG_EQ (ueRrc->GetState (), LteUeRrc::CONNECTED_NORMALLY, "Wrong LteUeRrc state!");
441 
442 
443  Ptr<LteEnbNetDevice> enbLteDevice = enbDevice->GetObject<LteEnbNetDevice> ();
444  Ptr<LteEnbRrc> enbRrc = enbLteDevice->GetRrc ();
445  uint16_t rnti = ueRrc->GetRnti ();
446  Ptr<UeManager> ueManager = enbRrc->GetUeManager (rnti);
447  NS_TEST_ASSERT_MSG_NE (ueManager, 0, "RNTI " << rnti << " not found in eNB");
448 
449  UeManager::State ueManagerState = ueManager->GetState ();
450  NS_TEST_ASSERT_MSG_EQ (ueManagerState, UeManager::CONNECTED_NORMALLY, "Wrong UeManager state!");
451  NS_ASSERT_MSG (ueManagerState == UeManager::CONNECTED_NORMALLY, "Wrong UeManager state!");
452 
453  uint16_t ueCellId = ueRrc->GetCellId ();
454  uint16_t enbCellId = enbLteDevice->GetCellId ();
455  uint8_t ueDlBandwidth = ueRrc->GetDlBandwidth ();
456  uint8_t enbDlBandwidth = enbLteDevice->GetDlBandwidth ();
457  uint8_t ueUlBandwidth = ueRrc->GetUlBandwidth ();
458  uint8_t enbUlBandwidth = enbLteDevice->GetUlBandwidth ();
459  uint8_t ueDlEarfcn = ueRrc->GetDlEarfcn ();
460  uint8_t enbDlEarfcn = enbLteDevice->GetDlEarfcn ();
461  uint8_t ueUlEarfcn = ueRrc->GetUlEarfcn ();
462  uint8_t enbUlEarfcn = enbLteDevice->GetUlEarfcn ();
463  uint64_t ueImsi = ueLteDevice->GetImsi ();
464  uint64_t enbImsi = ueManager->GetImsi ();
465 
466  NS_TEST_ASSERT_MSG_EQ (ueImsi, enbImsi, "inconsistent IMSI");
467  NS_TEST_ASSERT_MSG_EQ (ueCellId, enbCellId, "inconsistent CellId");
468  NS_TEST_ASSERT_MSG_EQ (ueDlBandwidth, enbDlBandwidth, "inconsistent DlBandwidth");
469  NS_TEST_ASSERT_MSG_EQ (ueUlBandwidth, enbUlBandwidth, "inconsistent UlBandwidth");
470  NS_TEST_ASSERT_MSG_EQ (ueDlEarfcn, enbDlEarfcn, "inconsistent DlEarfcn");
471  NS_TEST_ASSERT_MSG_EQ (ueUlEarfcn, enbUlEarfcn, "inconsistent UlEarfcn");
472 
473  ObjectMapValue enbDataRadioBearerMapValue;
474  ueManager->GetAttribute ("DataRadioBearerMap", enbDataRadioBearerMapValue);
475  NS_TEST_ASSERT_MSG_EQ (enbDataRadioBearerMapValue.GetN (), m_nDedicatedBearers + 1, "wrong num bearers at eNB");
476 
477  ObjectMapValue ueDataRadioBearerMapValue;
478  ueRrc->GetAttribute ("DataRadioBearerMap", ueDataRadioBearerMapValue);
479  NS_TEST_ASSERT_MSG_EQ (ueDataRadioBearerMapValue.GetN (), m_nDedicatedBearers + 1, "wrong num bearers at UE");
480 
481  ObjectMapValue::Iterator enbBearerIt = enbDataRadioBearerMapValue.Begin ();
482  ObjectMapValue::Iterator ueBearerIt = ueDataRadioBearerMapValue.Begin ();
483  while (enbBearerIt != enbDataRadioBearerMapValue.End () &&
484  ueBearerIt != ueDataRadioBearerMapValue.End ())
485  {
486  Ptr<LteDataRadioBearerInfo> enbDrbInfo = enbBearerIt->second->GetObject<LteDataRadioBearerInfo> ();
487  Ptr<LteDataRadioBearerInfo> ueDrbInfo = ueBearerIt->second->GetObject<LteDataRadioBearerInfo> ();
488  //NS_TEST_ASSERT_MSG_EQ (enbDrbInfo->m_epsBearer, ueDrbInfo->m_epsBearer, "epsBearer differs");
489  NS_TEST_ASSERT_MSG_EQ ((uint32_t) enbDrbInfo->m_epsBearerIdentity, (uint32_t) ueDrbInfo->m_epsBearerIdentity, "epsBearerIdentity differs");
490  NS_TEST_ASSERT_MSG_EQ ((uint32_t) enbDrbInfo->m_drbIdentity, (uint32_t) ueDrbInfo->m_drbIdentity, "drbIdentity differs");
491  //NS_TEST_ASSERT_MSG_EQ (enbDrbInfo->m_rlcConfig, ueDrbInfo->m_rlcConfig, "rlcConfig differs");
492  NS_TEST_ASSERT_MSG_EQ ((uint32_t) enbDrbInfo->m_logicalChannelIdentity, (uint32_t) ueDrbInfo->m_logicalChannelIdentity, "logicalChannelIdentity differs");
493  //NS_TEST_ASSERT_MSG_EQ (enbDrbInfo->m_logicalChannelConfig, ueDrbInfo->m_logicalChannelConfig, "logicalChannelConfig differs");
494 
495  ++enbBearerIt;
496  ++ueBearerIt;
497  }
498  NS_ASSERT_MSG (enbBearerIt == enbDataRadioBearerMapValue.End (), "too many bearers at eNB");
499  NS_ASSERT_MSG (ueBearerIt == ueDataRadioBearerMapValue.End (), "too many bearers at UE");
500 }
501 
502 void
503 LteX2HandoverTestCase::SaveStatsAfterHandover (uint32_t ueIndex)
504 {
505  for (std::list<BearerData>::iterator it = m_ueDataVector.at (ueIndex).bearerDataList.begin ();
506  it != m_ueDataVector.at (ueIndex).bearerDataList.end ();
507  ++it)
508  {
509  it->dlOldTotalRx = it->dlSink->GetTotalRx ();
510  it->ulOldTotalRx = it->ulSink->GetTotalRx ();
511  }
512 }
513 
514 void
515 LteX2HandoverTestCase::CheckStatsAWhileAfterHandover (uint32_t ueIndex)
516 {
517  uint32_t b = 1;
518  for (std::list<BearerData>::iterator it = m_ueDataVector.at (ueIndex).bearerDataList.begin ();
519  it != m_ueDataVector.at (ueIndex).bearerDataList.end ();
520  ++it)
521  {
522  uint32_t dlRx = it->dlSink->GetTotalRx () - it->dlOldTotalRx;
523  uint32_t ulRx = it->ulSink->GetTotalRx () - it->ulOldTotalRx;
524  uint32_t expectedBytes = m_udpClientPktSize * (m_statsDuration.GetSeconds () / m_udpClientInterval.GetSeconds ());
525  // tolerance
526  NS_TEST_ASSERT_MSG_GT (dlRx, 0.500 * expectedBytes, "too few RX bytes in DL, ue=" << ueIndex << ", b=" << b);
527  NS_TEST_ASSERT_MSG_GT (ulRx, 0.500 * expectedBytes, "too few RX bytes in UL, ue=" << ueIndex << ", b=" << b);
528  ++b;
529  }
530 }
531 
532 
533 class LteX2HandoverTestSuite : public TestSuite
534 {
535 public:
536  LteX2HandoverTestSuite ();
537 };
538 
539 
540 LteX2HandoverTestSuite::LteX2HandoverTestSuite ()
541  : TestSuite ("lte-x2-handover", SYSTEM)
542 {
543  // in the following:
544  // fwd means handover from enb 0 to enb 1
545  // bwd means handover from enb 1 to enb 0
546 
547  HandoverEvent ue1fwd;
548  ue1fwd.startTime = MilliSeconds (100);
549  ue1fwd.ueDeviceIndex = 0;
550  ue1fwd.sourceEnbDeviceIndex = 0;
551  ue1fwd.targetEnbDeviceIndex = 1;
552 
553  HandoverEvent ue1bwd;
554  ue1bwd.startTime = MilliSeconds (300);
555  ue1bwd.ueDeviceIndex = 0;
556  ue1bwd.sourceEnbDeviceIndex = 1;
557  ue1bwd.targetEnbDeviceIndex = 0;
558 
559  HandoverEvent ue1fwdagain;
560  ue1fwdagain.startTime = MilliSeconds (500);
561  ue1fwdagain.ueDeviceIndex = 0;
562  ue1fwdagain.sourceEnbDeviceIndex = 0;
563  ue1fwdagain.targetEnbDeviceIndex = 1;
564 
565  HandoverEvent ue2fwd;
566  ue2fwd.startTime = MilliSeconds (110);
567  ue2fwd.ueDeviceIndex = 1;
568  ue2fwd.sourceEnbDeviceIndex = 0;
569  ue2fwd.targetEnbDeviceIndex = 1;
570 
571  HandoverEvent ue2bwd;
572  ue2bwd.startTime = MilliSeconds (250);
573  ue2bwd.ueDeviceIndex = 1;
574  ue2bwd.sourceEnbDeviceIndex = 1;
575  ue2bwd.targetEnbDeviceIndex = 0;
576 
577  std::string hel0name ("none");
578  std::list<HandoverEvent> hel0;
579 
580  std::string hel1name ("1 fwd");
581  std::list<HandoverEvent> hel1;
582  hel1.push_back (ue1fwd);
583 
584  std::string hel2name ("1 fwd & bwd");
585  std::list<HandoverEvent> hel2;
586  hel2.push_back (ue1fwd);
587  hel2.push_back (ue1bwd);
588 
589  std::string hel3name ("1 fwd & bwd & fwd");
590  std::list<HandoverEvent> hel3;
591  hel3.push_back (ue1fwd);
592  hel3.push_back (ue1bwd);
593  hel3.push_back (ue1fwdagain);
594 
595  std::string hel4name ("1+2 fwd");
596  std::list<HandoverEvent> hel4;
597  hel4.push_back (ue1fwd);
598  hel4.push_back (ue2fwd);
599 
600  std::string hel5name ("1+2 fwd & bwd");
601  std::list<HandoverEvent> hel5;
602  hel5.push_back (ue1fwd);
603  hel5.push_back (ue1bwd);
604  hel5.push_back (ue2fwd);
605  hel5.push_back (ue2bwd);
606 
607  std::string hel6name ("2 fwd");
608  std::list<HandoverEvent> hel6;
609  hel6.push_back (ue2fwd);
610 
611  std::string hel7name ("2 fwd & bwd");
612  std::list<HandoverEvent> hel7;
613  hel7.push_back (ue2fwd);
614  hel7.push_back (ue2bwd);
615 
616  std::vector<std::string> schedulers;
617  schedulers.push_back ("ns3::RrFfMacScheduler");
618  schedulers.push_back ("ns3::PfFfMacScheduler");
619  for (std::vector<std::string>::iterator schedIt = schedulers.begin (); schedIt != schedulers.end (); ++schedIt)
620  {
621  for (int32_t useIdealRrc = 1; useIdealRrc >= 0; --useIdealRrc)
622  {
623  // nUes, nDBearers, helist, name, useUdp, sched, admitHo, idealRrc
624  AddTestCase (new LteX2HandoverTestCase ( 1, 0, hel0, hel0name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
625  AddTestCase (new LteX2HandoverTestCase ( 2, 0, hel0, hel0name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
626  AddTestCase (new LteX2HandoverTestCase ( 1, 5, hel0, hel0name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
627  AddTestCase (new LteX2HandoverTestCase ( 2, 5, hel0, hel0name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
628  AddTestCase (new LteX2HandoverTestCase ( 1, 0, hel1, hel1name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
629  AddTestCase (new LteX2HandoverTestCase ( 1, 1, hel1, hel1name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
630  AddTestCase (new LteX2HandoverTestCase ( 1, 2, hel1, hel1name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
631  AddTestCase (new LteX2HandoverTestCase ( 1, 0, hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);
632  AddTestCase (new LteX2HandoverTestCase ( 1, 1, hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);
633  AddTestCase (new LteX2HandoverTestCase ( 1, 2, hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);
634  AddTestCase (new LteX2HandoverTestCase ( 2, 0, hel1, hel1name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
635  AddTestCase (new LteX2HandoverTestCase ( 2, 1, hel1, hel1name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
636  AddTestCase (new LteX2HandoverTestCase ( 2, 2, hel1, hel1name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
637  AddTestCase (new LteX2HandoverTestCase ( 2, 0, hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);
638  AddTestCase (new LteX2HandoverTestCase ( 2, 1, hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);
639  AddTestCase (new LteX2HandoverTestCase ( 2, 2, hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);
640  AddTestCase (new LteX2HandoverTestCase ( 1, 0, hel2, hel2name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
641  AddTestCase (new LteX2HandoverTestCase ( 1, 1, hel2, hel2name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
642  AddTestCase (new LteX2HandoverTestCase ( 1, 2, hel2, hel2name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
643  AddTestCase (new LteX2HandoverTestCase ( 1, 0, hel3, hel3name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
644  AddTestCase (new LteX2HandoverTestCase ( 1, 1, hel3, hel3name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
645  AddTestCase (new LteX2HandoverTestCase ( 1, 2, hel3, hel3name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
646  AddTestCase (new LteX2HandoverTestCase ( 2, 0, hel3, hel3name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
647  AddTestCase (new LteX2HandoverTestCase ( 2, 1, hel3, hel3name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
648  AddTestCase (new LteX2HandoverTestCase ( 2, 2, hel3, hel3name, true, *schedIt, true, useIdealRrc), TestCase::QUICK);
649  AddTestCase (new LteX2HandoverTestCase ( 2, 0, hel4, hel4name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
650  AddTestCase (new LteX2HandoverTestCase ( 2, 1, hel4, hel4name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
651  AddTestCase (new LteX2HandoverTestCase ( 2, 2, hel4, hel4name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
652  AddTestCase (new LteX2HandoverTestCase ( 2, 0, hel5, hel5name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
653  AddTestCase (new LteX2HandoverTestCase ( 2, 1, hel5, hel5name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
654  AddTestCase (new LteX2HandoverTestCase ( 2, 2, hel5, hel5name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
655  AddTestCase (new LteX2HandoverTestCase ( 3, 0, hel3, hel3name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
656  AddTestCase (new LteX2HandoverTestCase ( 3, 1, hel3, hel3name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
657  AddTestCase (new LteX2HandoverTestCase ( 3, 2, hel3, hel3name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
658  AddTestCase (new LteX2HandoverTestCase ( 3, 0, hel4, hel4name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
659  AddTestCase (new LteX2HandoverTestCase ( 3, 1, hel4, hel4name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
660  AddTestCase (new LteX2HandoverTestCase ( 3, 2, hel4, hel4name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
661  AddTestCase (new LteX2HandoverTestCase ( 3, 0, hel5, hel5name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
662  AddTestCase (new LteX2HandoverTestCase ( 3, 1, hel5, hel5name, true, *schedIt, true, useIdealRrc), TestCase::EXTENSIVE);
663  AddTestCase (new LteX2HandoverTestCase ( 3, 2, hel5, hel5name, true, *schedIt, true, useIdealRrc), TestCase::QUICK);
664 
665  }
666  }
667 }
668 
669 static LteX2HandoverTestSuite g_lteX2HandoverTestSuiteInstance;
670 
671 
672 
673 } // namespace ns3