3.23/doxygen-old/test-lte-x2-handover_8cc_source.html

 /* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

 /*

  * Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License version 2 as

  * published by the Free Software Foundation;

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  * Author: Nicola Baldo <nbaldo@cttc.es>

  */


 #include <ns3/core-module.h>

 #include <ns3/network-module.h>

 #include <ns3/mobility-module.h>

 #include <ns3/lte-module.h>

 #include <ns3/internet-module.h>

 #include <ns3/applications-module.h>

 #include <ns3/point-to-point-module.h>


 using namespace ns3;


 NS_LOG_COMPONENT_DEFINE ("LteX2HandoverTest");


 struct HandoverEvent

 {

   Time startTime;

   uint32_t ueDeviceIndex;

   uint32_t sourceEnbDeviceIndex;

   uint32_t targetEnbDeviceIndex;

 };


 class LteX2HandoverTestCase : public TestCase

 {

 public:


   LteX2HandoverTestCase (uint32_t nUes, uint32_t nDedicatedBearers, std::list<HandoverEvent> handoverEventList, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc);


 private:

   static std::string BuildNameString (uint32_t nUes, uint32_t nDedicatedBearers, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc);

   virtual void DoRun (void);

   void CheckConnected (Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice);


   uint32_t m_nUes; // number of UEs in the test

   uint32_t m_nDedicatedBearers; // number of UEs in the test

   std::list<HandoverEvent> m_handoverEventList;

   std::string m_handoverEventListName;

   bool m_epc;

   bool m_useUdp;

   std::string m_schedulerType;

   bool m_admitHo;

   bool     m_useIdealRrc;

   Ptr<LteHelper> m_lteHelper;

   Ptr<PointToPointEpcHelper> m_epcHelper;


   struct BearerData

   {

     uint32_t bid;

     Ptr<PacketSink> dlSink;

     Ptr<PacketSink> ulSink;

     uint32_t dlOldTotalRx;

     uint32_t ulOldTotalRx;

   };


   struct UeData

   {

     uint32_t id;

     std::list<BearerData> bearerDataList;

   };


   void SaveStatsAfterHandover (uint32_t ueIndex);

   void CheckStatsAWhileAfterHandover (uint32_t ueIndex);


   std::vector<UeData> m_ueDataVector;


   const Time m_maxHoDuration;

   const Time m_statsDuration;

   const Time m_udpClientInterval;

   const uint32_t m_udpClientPktSize;


 };


 std::string LteX2HandoverTestCase::BuildNameString (uint32_t nUes, uint32_t nDedicatedBearers, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc)

 {

   std::ostringstream oss;

   oss << " nUes=" << nUes

       << " nDedicatedBearers=" << nDedicatedBearers

       << " udp=" << useUdp

       << " " << schedulerType

       << " admitHo=" << admitHo

       << " hoList: " << handoverEventListName;

   if (useIdealRrc)

     {

       oss << ", ideal RRC";

     }

   else

     {

       oss << ", real RRC";

     }

   return oss.str ();

 }


 LteX2HandoverTestCase::LteX2HandoverTestCase (uint32_t nUes, uint32_t nDedicatedBearers, std::list<HandoverEvent> handoverEventList, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc)

   : TestCase (BuildNameString (nUes, nDedicatedBearers, handoverEventListName, useUdp, schedulerType, admitHo, useIdealRrc)),

     m_nUes (nUes),

     m_nDedicatedBearers (nDedicatedBearers),

     m_handoverEventList (handoverEventList),

     m_handoverEventListName (handoverEventListName),

     m_epc (true),

     m_useUdp (useUdp),

     m_schedulerType (schedulerType),

     m_admitHo (admitHo),

     m_useIdealRrc (useIdealRrc),

     m_maxHoDuration (Seconds (0.1)),

     m_statsDuration (Seconds (0.1)),

     m_udpClientInterval (Seconds (0.01)),

     m_udpClientPktSize (100)


 {

 }


 void

 LteX2HandoverTestCase::DoRun ()

 {

   NS_LOG_FUNCTION (this << BuildNameString (m_nUes, m_nDedicatedBearers, m_handoverEventListName, m_useUdp, m_schedulerType, m_admitHo, m_useIdealRrc));


   Config::Reset ();

   Config::SetDefault ("ns3::UdpClient::Interval",  TimeValue (m_udpClientInterval));

   Config::SetDefault ("ns3::UdpClient::MaxPackets", UintegerValue (1000000));

   Config::SetDefault ("ns3::UdpClient::PacketSize", UintegerValue (m_udpClientPktSize));


   //Disable Uplink Power Control

   Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (false));


   int64_t stream = 1;


   m_lteHelper = CreateObject<LteHelper> ();

   m_lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel"));

   m_lteHelper->SetSchedulerType (m_schedulerType);

   m_lteHelper->SetHandoverAlgorithmType ("ns3::NoOpHandoverAlgorithm"); // disable automatic handover

   m_lteHelper->SetAttribute ("UseIdealRrc", BooleanValue (m_useIdealRrc));


   NodeContainer enbNodes;

   enbNodes.Create (2);

   NodeContainer ueNodes;

   ueNodes.Create (m_nUes);


   if (m_epc)

     {

       m_epcHelper = CreateObject<PointToPointEpcHelper> ();

       m_lteHelper->SetEpcHelper (m_epcHelper);

     }


   Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

   positionAlloc->Add (Vector (-3000, 0, 0)); // enb0

   positionAlloc->Add (Vector ( 3000, 0, 0)); // enb1

   for (uint16_t i = 0; i < m_nUes; i++)

     {

       positionAlloc->Add (Vector (0, 0, 0));

     }

   MobilityHelper mobility;

   mobility.SetPositionAllocator (positionAlloc);

   mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

   mobility.Install (enbNodes);

   mobility.Install (ueNodes);


   NetDeviceContainer enbDevices;

   enbDevices = m_lteHelper->InstallEnbDevice (enbNodes);

   stream += m_lteHelper->AssignStreams (enbDevices, stream);

   for (NetDeviceContainer::Iterator it = enbDevices.Begin ();

        it != enbDevices.End ();

        ++it)

     {

       Ptr<LteEnbRrc> enbRrc = (*it)->GetObject<LteEnbNetDevice> ()->GetRrc ();

       enbRrc->SetAttribute ("AdmitHandoverRequest", BooleanValue (m_admitHo));

     }


   NetDeviceContainer ueDevices;

   ueDevices = m_lteHelper->InstallUeDevice (ueNodes);

   stream += m_lteHelper->AssignStreams (ueDevices, stream);


   Ipv4Address remoteHostAddr;

   Ipv4StaticRoutingHelper ipv4RoutingHelper;

   Ipv4InterfaceContainer ueIpIfaces;

   Ptr<Node> remoteHost;

   if (m_epc)

     {

       // Create a single RemoteHost

       NodeContainer remoteHostContainer;

       remoteHostContainer.Create (1);

       remoteHost = remoteHostContainer.Get (0);

       InternetStackHelper internet;

       internet.Install (remoteHostContainer);


       // Create the Internet

       PointToPointHelper p2ph;

       p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));

       p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));

       p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.010)));

       Ptr<Node> pgw = m_epcHelper->GetPgwNode ();

       NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);

       Ipv4AddressHelper ipv4h;

       ipv4h.SetBase ("1.0.0.0", "255.0.0.0");

       Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign (internetDevices);

       // in this container, interface 0 is the pgw, 1 is the remoteHost

       remoteHostAddr = internetIpIfaces.GetAddress (1);


       Ipv4StaticRoutingHelper ipv4RoutingHelper;

       Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());

       remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.0.0.0"), 1);


       // Install the IP stack on the UEs

       internet.Install (ueNodes);

       ueIpIfaces = m_epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevices));

     }


   // attachment (needs to be done after IP stack configuration)

   // all UEs attached to eNB 0 at the beginning

   m_lteHelper->Attach (ueDevices, enbDevices.Get (0));


   if (m_epc)

     {

       // always true: bool epcDl = true;

       // always true: bool epcUl = true;

       // the rest of this block is copied from lena-dual-stripe


       // Install and start applications on UEs and remote host

       uint16_t dlPort = 10000;

       uint16_t ulPort = 20000;


       // randomize a bit start times to avoid simulation artifacts

       // (e.g., buffer overflows due to packet transmissions happening

       // exactly at the same time)

       Ptr<UniformRandomVariable> startTimeSeconds = CreateObject<UniformRandomVariable> ();

       startTimeSeconds->SetAttribute ("Min", DoubleValue (0));

       startTimeSeconds->SetAttribute ("Max", DoubleValue (0.010));

       startTimeSeconds->SetStream (stream++);


       for (uint32_t u = 0; u < ueNodes.GetN (); ++u)

         {

           Ptr<Node> ue = ueNodes.Get (u);

           // Set the default gateway for the UE

           Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ue->GetObject<Ipv4> ());

           ueStaticRouting->SetDefaultRoute (m_epcHelper->GetUeDefaultGatewayAddress (), 1);


           UeData ueData;


           for (uint32_t b = 0; b < m_nDedicatedBearers; ++b)

             {

               ++dlPort;

               ++ulPort;


               ApplicationContainer clientApps;

               ApplicationContainer serverApps;

               BearerData bearerData;


               if (m_useUdp)

                 {

                   // always true: if (epcDl)

                     {

                       UdpClientHelper dlClientHelper (ueIpIfaces.GetAddress (u), dlPort);

                       clientApps.Add (dlClientHelper.Install (remoteHost));

                       PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory",

                                                            InetSocketAddress (Ipv4Address::GetAny (), dlPort));

                       ApplicationContainer sinkContainer = dlPacketSinkHelper.Install (ue);

                       bearerData.dlSink = sinkContainer.Get (0)->GetObject<PacketSink> ();

                       serverApps.Add (sinkContainer);


                     }

                   // always true: if (epcUl)

                     {

                       UdpClientHelper ulClientHelper (remoteHostAddr, ulPort);

                       clientApps.Add (ulClientHelper.Install (ue));

                       PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory",

                                                            InetSocketAddress (Ipv4Address::GetAny (), ulPort));

                       ApplicationContainer sinkContainer = ulPacketSinkHelper.Install (remoteHost);

                       bearerData.ulSink = sinkContainer.Get (0)->GetObject<PacketSink> ();

                       serverApps.Add (sinkContainer);

                     }

                 }

               else // use TCP

                 {

                   // always true: if (epcDl)

                     {

                       BulkSendHelper dlClientHelper ("ns3::TcpSocketFactory",

                                                      InetSocketAddress (ueIpIfaces.GetAddress (u), dlPort));

                       dlClientHelper.SetAttribute ("MaxBytes", UintegerValue (0));

                       clientApps.Add (dlClientHelper.Install (remoteHost));

                       PacketSinkHelper dlPacketSinkHelper ("ns3::TcpSocketFactory",

                                                            InetSocketAddress (Ipv4Address::GetAny (), dlPort));

                       ApplicationContainer sinkContainer = dlPacketSinkHelper.Install (ue);

                       bearerData.dlSink = sinkContainer.Get (0)->GetObject<PacketSink> ();

                       serverApps.Add (sinkContainer);

                     }

                   // always true: if (epcUl)

                     {

                       BulkSendHelper ulClientHelper ("ns3::TcpSocketFactory",

                                                      InetSocketAddress (remoteHostAddr, ulPort));

                       ulClientHelper.SetAttribute ("MaxBytes", UintegerValue (0));

                       clientApps.Add (ulClientHelper.Install (ue));

                       PacketSinkHelper ulPacketSinkHelper ("ns3::TcpSocketFactory",

                                                            InetSocketAddress (Ipv4Address::GetAny (), ulPort));

                       ApplicationContainer sinkContainer = ulPacketSinkHelper.Install (remoteHost);

                       bearerData.ulSink = sinkContainer.Get (0)->GetObject<PacketSink> ();

                       serverApps.Add (sinkContainer);

                     }

                 } // end if (useUdp)


               Ptr<EpcTft> tft = Create<EpcTft> ();

               // always true: if (epcDl)

                 {

                   EpcTft::PacketFilter dlpf;

                   dlpf.localPortStart = dlPort;

                   dlpf.localPortEnd = dlPort;

                   tft->Add (dlpf);

                 }

               // always true: if (epcUl)

                 {

                   EpcTft::PacketFilter ulpf;

                   ulpf.remotePortStart = ulPort;

                   ulpf.remotePortEnd = ulPort;

                   tft->Add (ulpf);

                 }


               // always true: if (epcDl || epcUl)

                 {

                   EpsBearer bearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT);

                   m_lteHelper->ActivateDedicatedEpsBearer (ueDevices.Get (u), bearer, tft);

                 }

               Time startTime = Seconds (startTimeSeconds->GetValue ());

               serverApps.Start (startTime);

               clientApps.Start (startTime);


               ueData.bearerDataList.push_back (bearerData);


             } // end for b


           m_ueDataVector.push_back (ueData);

         }


     }

   else // (epc == false)

     {

       // for radio bearer activation purposes, consider together home UEs and macro UEs

       for (uint32_t u = 0; u < ueDevices.GetN (); ++u)

         {

           Ptr<NetDevice> ueDev = ueDevices.Get (u);

           for (uint32_t b = 0; b < m_nDedicatedBearers; ++b)

             {

               enum EpsBearer::Qci q = EpsBearer::NGBR_VIDEO_TCP_DEFAULT;

               EpsBearer bearer (q);

               m_lteHelper->ActivateDataRadioBearer (ueDev, bearer);

             }

         }

     }


   m_lteHelper->AddX2Interface (enbNodes);


   // check initial RRC connection

   const Time maxRrcConnectionEstablishmentDuration = Seconds (0.080);

   for (NetDeviceContainer::Iterator it = ueDevices.Begin (); it != ueDevices.End (); ++it)

     {

       Simulator::Schedule (maxRrcConnectionEstablishmentDuration,

                            &LteX2HandoverTestCase::CheckConnected,

                            this, *it, enbDevices.Get (0));

     }


   // schedule handover events and corresponding checks


   Time stopTime = Seconds (0);

   for (std::list<HandoverEvent>::iterator hoEventIt = m_handoverEventList.begin ();

        hoEventIt != m_handoverEventList.end ();

        ++hoEventIt)

     {

       Simulator::Schedule (hoEventIt->startTime,

                            &LteX2HandoverTestCase::CheckConnected,

                            this,

                            ueDevices.Get (hoEventIt->ueDeviceIndex),

                            enbDevices.Get (hoEventIt->sourceEnbDeviceIndex));

       m_lteHelper->HandoverRequest (hoEventIt->startTime,

                                     ueDevices.Get (hoEventIt->ueDeviceIndex),

                                     enbDevices.Get (hoEventIt->sourceEnbDeviceIndex),

                                     enbDevices.Get (hoEventIt->targetEnbDeviceIndex));

       Time hoEndTime = hoEventIt->startTime + m_maxHoDuration;

       Simulator::Schedule (hoEndTime,

                            &LteX2HandoverTestCase::CheckConnected,

                            this,

                            ueDevices.Get (hoEventIt->ueDeviceIndex),

                            enbDevices.Get (m_admitHo ? hoEventIt->targetEnbDeviceIndex : hoEventIt->sourceEnbDeviceIndex));

       Simulator::Schedule (hoEndTime, &LteX2HandoverTestCase::SaveStatsAfterHandover,

                            this, hoEventIt->ueDeviceIndex);


       Time checkStatsAfterHoTime = hoEndTime + m_statsDuration;

       Simulator::Schedule (checkStatsAfterHoTime, &LteX2HandoverTestCase::CheckStatsAWhileAfterHandover,

                            this, hoEventIt->ueDeviceIndex);

       if (stopTime <= checkStatsAfterHoTime)

         {

           stopTime = checkStatsAfterHoTime + MilliSeconds (1);

         }

     }


   // m_lteHelper->EnableRlcTraces ();

   // m_lteHelper->EnablePdcpTraces();


   Simulator::Stop (stopTime);


   Simulator::Run ();


   Simulator::Destroy ();


 }


 void

 LteX2HandoverTestCase::CheckConnected (Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice)

 {

   Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice> ();

   Ptr<LteUeRrc> ueRrc = ueLteDevice->GetRrc ();

   NS_TEST_ASSERT_MSG_EQ (ueRrc->GetState (), LteUeRrc::CONNECTED_NORMALLY, "Wrong LteUeRrc state!");


   Ptr<LteEnbNetDevice> enbLteDevice = enbDevice->GetObject<LteEnbNetDevice> ();

   Ptr<LteEnbRrc> enbRrc = enbLteDevice->GetRrc ();

   uint16_t rnti = ueRrc->GetRnti ();

   Ptr<UeManager> ueManager = enbRrc->GetUeManager (rnti);

   NS_TEST_ASSERT_MSG_NE (ueManager, 0, "RNTI " << rnti << " not found in eNB");


   UeManager::State ueManagerState = ueManager->GetState ();

   NS_TEST_ASSERT_MSG_EQ (ueManagerState, UeManager::CONNECTED_NORMALLY, "Wrong UeManager state!");

   NS_ASSERT_MSG (ueManagerState == UeManager::CONNECTED_NORMALLY, "Wrong UeManager state!");


   uint16_t ueCellId = ueRrc->GetCellId ();

   uint16_t enbCellId = enbLteDevice->GetCellId ();

   uint8_t ueDlBandwidth = ueRrc->GetDlBandwidth ();

   uint8_t enbDlBandwidth = enbLteDevice->GetDlBandwidth ();

   uint8_t ueUlBandwidth = ueRrc->GetUlBandwidth ();

   uint8_t enbUlBandwidth = enbLteDevice->GetUlBandwidth ();

   uint8_t ueDlEarfcn = ueRrc->GetDlEarfcn ();

   uint8_t enbDlEarfcn = enbLteDevice->GetDlEarfcn ();

   uint8_t ueUlEarfcn = ueRrc->GetUlEarfcn ();

   uint8_t enbUlEarfcn = enbLteDevice->GetUlEarfcn ();

   uint64_t ueImsi = ueLteDevice->GetImsi ();

   uint64_t enbImsi = ueManager->GetImsi ();


   NS_TEST_ASSERT_MSG_EQ (ueImsi, enbImsi, "inconsistent IMSI");

   NS_TEST_ASSERT_MSG_EQ (ueCellId, enbCellId, "inconsistent CellId");

   NS_TEST_ASSERT_MSG_EQ (ueDlBandwidth, enbDlBandwidth, "inconsistent DlBandwidth");

   NS_TEST_ASSERT_MSG_EQ (ueUlBandwidth, enbUlBandwidth, "inconsistent UlBandwidth");

   NS_TEST_ASSERT_MSG_EQ (ueDlEarfcn, enbDlEarfcn, "inconsistent DlEarfcn");

   NS_TEST_ASSERT_MSG_EQ (ueUlEarfcn, enbUlEarfcn, "inconsistent UlEarfcn");


   ObjectMapValue enbDataRadioBearerMapValue;

   ueManager->GetAttribute ("DataRadioBearerMap", enbDataRadioBearerMapValue);

   NS_TEST_ASSERT_MSG_EQ (enbDataRadioBearerMapValue.GetN (), m_nDedicatedBearers + 1, "wrong num bearers at eNB");


   ObjectMapValue ueDataRadioBearerMapValue;

   ueRrc->GetAttribute ("DataRadioBearerMap", ueDataRadioBearerMapValue);

   NS_TEST_ASSERT_MSG_EQ (ueDataRadioBearerMapValue.GetN (), m_nDedicatedBearers + 1, "wrong num bearers at UE");


   ObjectMapValue::Iterator enbBearerIt = enbDataRadioBearerMapValue.Begin ();

   ObjectMapValue::Iterator ueBearerIt = ueDataRadioBearerMapValue.Begin ();

   while (enbBearerIt != enbDataRadioBearerMapValue.End () &&

          ueBearerIt != ueDataRadioBearerMapValue.End ())

     {

       Ptr<LteDataRadioBearerInfo> enbDrbInfo = enbBearerIt->second->GetObject<LteDataRadioBearerInfo> ();

       Ptr<LteDataRadioBearerInfo> ueDrbInfo = ueBearerIt->second->GetObject<LteDataRadioBearerInfo> ();

       //NS_TEST_ASSERT_MSG_EQ (enbDrbInfo->m_epsBearer, ueDrbInfo->m_epsBearer, "epsBearer differs");

       NS_TEST_ASSERT_MSG_EQ ((uint32_t) enbDrbInfo->m_epsBearerIdentity, (uint32_t) ueDrbInfo->m_epsBearerIdentity, "epsBearerIdentity differs");

       NS_TEST_ASSERT_MSG_EQ ((uint32_t) enbDrbInfo->m_drbIdentity, (uint32_t) ueDrbInfo->m_drbIdentity, "drbIdentity differs");

       //NS_TEST_ASSERT_MSG_EQ (enbDrbInfo->m_rlcConfig, ueDrbInfo->m_rlcConfig, "rlcConfig differs");

       NS_TEST_ASSERT_MSG_EQ ((uint32_t) enbDrbInfo->m_logicalChannelIdentity, (uint32_t) ueDrbInfo->m_logicalChannelIdentity, "logicalChannelIdentity differs");

       //NS_TEST_ASSERT_MSG_EQ (enbDrbInfo->m_logicalChannelConfig, ueDrbInfo->m_logicalChannelConfig, "logicalChannelConfig differs");


       ++enbBearerIt;

       ++ueBearerIt;

     }

   NS_ASSERT_MSG (enbBearerIt == enbDataRadioBearerMapValue.End (), "too many bearers at eNB");

   NS_ASSERT_MSG (ueBearerIt == ueDataRadioBearerMapValue.End (), "too many bearers at UE");

 }


 void

 LteX2HandoverTestCase::SaveStatsAfterHandover (uint32_t ueIndex)

 {

   for (std::list<BearerData>::iterator it = m_ueDataVector.at (ueIndex).bearerDataList.begin ();

        it != m_ueDataVector.at (ueIndex).bearerDataList.end ();

        ++it)

     {

       it->dlOldTotalRx = it->dlSink->GetTotalRx ();

       it->ulOldTotalRx = it->ulSink->GetTotalRx ();

     }

 }


 void

 LteX2HandoverTestCase::CheckStatsAWhileAfterHandover (uint32_t ueIndex)

 {

   uint32_t b = 1;

   for (std::list<BearerData>::iterator it = m_ueDataVector.at (ueIndex).bearerDataList.begin ();

        it != m_ueDataVector.at (ueIndex).bearerDataList.end ();

        ++it)

     {

       uint32_t dlRx = it->dlSink->GetTotalRx () - it->dlOldTotalRx;

       uint32_t ulRx = it->ulSink->GetTotalRx () - it->ulOldTotalRx;

       uint32_t expectedBytes = m_udpClientPktSize * (m_statsDuration.GetSeconds () / m_udpClientInterval.GetSeconds ());

       //                           tolerance

       NS_TEST_ASSERT_MSG_GT (dlRx,   0.500 * expectedBytes, "too few RX bytes in DL, ue=" << ueIndex << ", b=" << b);

       NS_TEST_ASSERT_MSG_GT (ulRx,   0.500 * expectedBytes, "too few RX bytes in UL, ue=" << ueIndex << ", b=" << b);

       ++b;

     }

 }


 class LteX2HandoverTestSuite : public TestSuite

 {

 public:

   LteX2HandoverTestSuite ();

 };


 LteX2HandoverTestSuite::LteX2HandoverTestSuite ()

   : TestSuite ("lte-x2-handover", SYSTEM)

 {

   // in the following:

   // fwd means handover from enb 0 to enb 1

   // bwd means handover from enb 1 to enb 0


   HandoverEvent ue1fwd;

   ue1fwd.startTime = MilliSeconds (100);

   ue1fwd.ueDeviceIndex = 0;

   ue1fwd.sourceEnbDeviceIndex = 0;

   ue1fwd.targetEnbDeviceIndex = 1;


   HandoverEvent ue1bwd;

   ue1bwd.startTime = MilliSeconds (300);

   ue1bwd.ueDeviceIndex = 0;

   ue1bwd.sourceEnbDeviceIndex = 1;

   ue1bwd.targetEnbDeviceIndex = 0;


   HandoverEvent ue1fwdagain;

   ue1fwdagain.startTime = MilliSeconds (500);

   ue1fwdagain.ueDeviceIndex = 0;

   ue1fwdagain.sourceEnbDeviceIndex = 0;

   ue1fwdagain.targetEnbDeviceIndex = 1;


   HandoverEvent ue2fwd;

   ue2fwd.startTime = MilliSeconds (110);

   ue2fwd.ueDeviceIndex = 1;

   ue2fwd.sourceEnbDeviceIndex = 0;

   ue2fwd.targetEnbDeviceIndex = 1;


   HandoverEvent ue2bwd;

   ue2bwd.startTime = MilliSeconds (250);

   ue2bwd.ueDeviceIndex = 1;

   ue2bwd.sourceEnbDeviceIndex = 1;

   ue2bwd.targetEnbDeviceIndex = 0;


   std::string hel0name ("none");

   std::list<HandoverEvent> hel0;


   std::string hel1name ("1 fwd");

   std::list<HandoverEvent> hel1;

   hel1.push_back (ue1fwd);


   std::string hel2name ("1 fwd & bwd");

   std::list<HandoverEvent> hel2;

   hel2.push_back (ue1fwd);

   hel2.push_back (ue1bwd);


   std::string hel3name ("1 fwd & bwd & fwd");

   std::list<HandoverEvent> hel3;

   hel3.push_back (ue1fwd);

   hel3.push_back (ue1bwd);

   hel3.push_back (ue1fwdagain);


   std::string hel4name ("1+2 fwd");

   std::list<HandoverEvent> hel4;

   hel4.push_back (ue1fwd);

   hel4.push_back (ue2fwd);


   std::string hel5name ("1+2 fwd & bwd");

   std::list<HandoverEvent> hel5;

   hel5.push_back (ue1fwd);

   hel5.push_back (ue1bwd);

   hel5.push_back (ue2fwd);

   hel5.push_back (ue2bwd);


   std::string hel6name ("2 fwd");

   std::list<HandoverEvent> hel6;

   hel6.push_back (ue2fwd);


   std::string hel7name ("2 fwd & bwd");

   std::list<HandoverEvent> hel7;

   hel7.push_back (ue2fwd);

   hel7.push_back (ue2bwd);


   std::vector<std::string> schedulers;

   schedulers.push_back ("ns3::RrFfMacScheduler");

   schedulers.push_back ("ns3::PfFfMacScheduler");

   for (std::vector<std::string>::iterator schedIt = schedulers.begin (); schedIt != schedulers.end (); ++schedIt)

     {

       for (int32_t useIdealRrc = 1; useIdealRrc >= 0; --useIdealRrc)

         {

           //                                     nUes, nDBearers, helist, name, useUdp, sched, admitHo, idealRrc

           AddTestCase (new LteX2HandoverTestCase (  1,    0,    hel0, hel0name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    0,    hel0, hel0name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    5,    hel0, hel0name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    5,    hel0, hel0name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    0,    hel1, hel1name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    1,    hel1, hel1name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    2,    hel1, hel1name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    0,    hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    1,    hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    2,    hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    0,    hel1, hel1name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    1,    hel1, hel1name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    2,    hel1, hel1name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    0,    hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    1,    hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    2,    hel1, hel1name, true, *schedIt, false, useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    0,    hel2, hel2name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    1,    hel2, hel2name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    2,    hel2, hel2name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    0,    hel3, hel3name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    1,    hel3, hel3name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  1,    2,    hel3, hel3name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    0,    hel3, hel3name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    1,    hel3, hel3name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    2,    hel3, hel3name, true, *schedIt, true,  useIdealRrc), TestCase::QUICK);

           AddTestCase (new LteX2HandoverTestCase (  2,    0,    hel4, hel4name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    1,    hel4, hel4name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    2,    hel4, hel4name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    0,    hel5, hel5name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    1,    hel5, hel5name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  2,    2,    hel5, hel5name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  3,    0,    hel3, hel3name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  3,    1,    hel3, hel3name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  3,    2,    hel3, hel3name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  3,    0,    hel4, hel4name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  3,    1,    hel4, hel4name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  3,    2,    hel4, hel4name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  3,    0,    hel5, hel5name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  3,    1,    hel5, hel5name, true, *schedIt, true,  useIdealRrc), TestCase::EXTENSIVE);

           AddTestCase (new LteX2HandoverTestCase (  3,    2,    hel5, hel5name, true, *schedIt, true,  useIdealRrc), TestCase::QUICK);


         }

     }

 }


 static LteX2HandoverTestSuite g_lteX2HandoverTestSuiteInstance;

LteX2HandoverTestCase::BearerData::dlSink
Ptr< PacketSink > dlSink
Definition: test-lte-x2-handover.cc:80

ns3::ApplicationContainer
holds a vector of ns3::Application pointers.
Definition: application-container.h:41

ns3::NetDeviceContainer::Begin
Iterator Begin(void) const
Get an iterator which refers to the first NetDevice in the container.
Definition: net-device-container.cc:46

ns3::EpcTft::Add
uint8_t Add(PacketFilter f)
add a PacketFilter to the Traffic Flow Template
Definition: epc-tft.cc:157

LteX2HandoverTestCase::m_nDedicatedBearers
uint32_t m_nDedicatedBearers
Definition: test-lte-x2-handover.cc:66

ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102

ns3::InetSocketAddress
an Inet address class
Definition: inet-socket-address.h:40

LteX2HandoverTestCase::UeData::bearerDataList
std::list< BearerData > bearerDataList
Definition: test-lte-x2-handover.cc:89

ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:73

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:213

ns3::RandomVariableStream::SetStream
void SetStream(int64_t stream)
Specifies the stream number for this RNG stream.
Definition: random-variable-stream.cc:98

LteX2HandoverTestCase::m_handoverEventListName
std::string m_handoverEventListName
Definition: test-lte-x2-handover.cc:68

ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:34

ns3::LteHelper::InstallEnbDevice
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:382

LteX2HandoverTestCase::m_udpClientPktSize
const uint32_t m_udpClientPktSize
Definition: test-lte-x2-handover.cc:100

ns3::BulkSendHelper
A helper to make it easier to instantiate an ns3::BulkSendApplication on a set of nodes...
Definition: bulk-send-helper.h:42

LteX2HandoverTestCase::UeData::id
uint32_t id
Definition: test-lte-x2-handover.cc:88

LteX2HandoverTestCase::m_lteHelper
Ptr< LteHelper > m_lteHelper
Definition: test-lte-x2-handover.cc:74

ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr and interface index.
Definition: ipv4-interface-container.h:32

ns3::Ipv4StaticRouting::SetDefaultRoute
void SetDefaultRoute(Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a default route to the static routing table.
Definition: ipv4-static-routing.cc:112

HandoverEvent::startTime
Time startTime
Definition: test-lte-x2-handover.cc:36

ns3::StringValue
Hold variables of type string.
Definition: string.h:41

ns3::LteHelper::HandoverRequest
void HandoverRequest(Time hoTime, Ptr< NetDevice > ueDev, Ptr< NetDevice > sourceEnbDev, Ptr< NetDevice > targetEnbDev)
Manually trigger an X2-based handover.
Definition: lte-helper.cc:1001

ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr stored in this container at a given index.
Definition: net-device-container.cc:62

ns3::PointToPointHelper::Install
NetDeviceContainer Install(NodeContainer c)
Definition: point-to-point-helper.cc:218

ns3::Ipv4Mask
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:226

ns3::ApplicationContainer::Add
void Add(ApplicationContainer other)
Append the contents of another ApplicationContainer to the end of this container. ...
Definition: application-container.cc:64

ns3::TestSuite
A suite of tests to run.
Definition: test.h:1276

ns3::PointToPointEpcHelper::GetPgwNode
virtual Ptr< Node > GetPgwNode()
Definition: point-to-point-epc-helper.cc:324

LteX2HandoverTestCase::BearerData::ulSink
Ptr< PacketSink > ulSink
Definition: test-lte-x2-handover.cc:81

ns3::LteUeNetDevice::GetRrc
Ptr< LteUeRrc > GetRrc() const
Definition: lte-ue-net-device.cc:168

ns3::LteUeNetDevice::GetImsi
uint64_t GetImsi() const
Definition: lte-ue-net-device.cc:190

ns3::LteHelper::Attach
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:716

NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:201

ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:874

ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition: internet-stack-helper.h:64

ns3::EpcTft::PacketFilter::localPortEnd
uint16_t localPortEnd
end of the port number range of the UE
Definition: epc-tft.h:115

ns3::PacketSinkHelper
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes...
Definition: packet-sink-helper.h:35

ns3::PointToPointHelper
Build a set of PointToPointNetDevice objects.
Definition: point-to-point-helper.h:44

LteX2HandoverTestCase
Definition: test-lte-x2-handover.cc:43

ns3::TestCase
encapsulates test code
Definition: test.h:1108

ns3::LteHelper::AssignStreams
int64_t AssignStreams(NetDeviceContainer c, int64_t stream)
Assign a fixed random variable stream number to the random variables used.
Definition: lte-helper.cc:1110

LteX2HandoverTestCase::BuildNameString
static std::string BuildNameString(uint32_t nUes, uint32_t nDedicatedBearers, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc)
Definition: test-lte-x2-handover.cc:105

ns3::LteHelper::ActivateDataRadioBearer
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1046

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:64

ns3::UeManager::GetState
State GetState() const
Definition: lte-enb-rrc.cc:1090

ns3::LteHelper::ActivateDedicatedEpsBearer
uint8_t ActivateDedicatedEpsBearer(NetDeviceContainer ueDevices, EpsBearer bearer, Ptr< EpcTft > tft)
Activate a dedicated EPS bearer on a given set of UE devices.
Definition: lte-helper.cc:824

HandoverEvent::targetEnbDeviceIndex
uint32_t targetEnbDeviceIndex
Definition: test-lte-x2-handover.cc:39

LteX2HandoverTestCase::BearerData::bid
uint32_t bid
Definition: test-lte-x2-handover.cc:79

LteX2HandoverTestCase::m_useUdp
bool m_useUdp
Definition: test-lte-x2-handover.cc:70

ns3::LteHelper::SetHandoverAlgorithmType
void SetHandoverAlgorithmType(std::string type)
Set the type of handover algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:273

ns3::UdpClientHelper::Install
ApplicationContainer Install(NodeContainer c)
Definition: udp-client-server-helper.cc:99

stopTime
double stopTime
Definition: tcp-nsc-comparison.cc:46

first.clientApps
tuple clientApps
Definition: first.py:54

ns3::ObjectPtrContainerValue::Iterator
std::map< uint32_t, Ptr< Object > >::const_iterator Iterator
Iterator type for traversing this container.
Definition: object-ptr-container.h:49

ns3::LteHelper::SetSchedulerType
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:225

ns3::NodeContainer::GetN
uint32_t GetN(void) const
Get the number of Ptr stored in this container.
Definition: node-container.cc:83

ns3::NetDeviceContainer::GetN
uint32_t GetN(void) const
Get the number of Ptr stored in this container.
Definition: net-device-container.cc:57

ns3::DataRate
Class for representing data rates.
Definition: data-rate.h:88

ns3::Time::GetSeconds
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:334

ns3::BulkSendHelper::Install
ApplicationContainer Install(NodeContainer c) const
Install an ns3::BulkSendApplication on each node of the input container configured with all the attri...
Definition: bulk-send-helper.cc:58

ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:71

LteX2HandoverTestCase::LteX2HandoverTestCase
LteX2HandoverTestCase(uint32_t nUes, uint32_t nDedicatedBearers, std::list< HandoverEvent > handoverEventList, std::string handoverEventListName, bool useUdp, std::string schedulerType, bool admitHo, bool useIdealRrc)
Definition: test-lte-x2-handover.cc:125

LteX2HandoverTestCase::SaveStatsAfterHandover
void SaveStatsAfterHandover(uint32_t ueIndex)
Definition: test-lte-x2-handover.cc:507

ns3::MobilityHelper::Install
void Install(Ptr< Node > node) const
"Layout" a single node according to the current position allocator type.
Definition: mobility-helper.cc:130

ns3::LteDataRadioBearerInfo
store information on active data radio bearer instance
Definition: lte-radio-bearer-info.h:71

ns3::LteDataRadioBearerInfo::m_logicalChannelIdentity
uint8_t m_logicalChannelIdentity
Definition: lte-radio-bearer-info.h:81

ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, enum TestDuration duration)
Add an individual child TestCase to this test suite.
Definition: test.cc:190

ns3::UdpClientHelper
Create a client application which sends UDP packets carrying a 32bit sequence number and a 64 bit tim...
Definition: udp-client-server-helper.h:93

LteX2HandoverTestCase::m_nUes
uint32_t m_nUes
Definition: test-lte-x2-handover.cc:65

ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:928

HandoverEvent::ueDeviceIndex
uint32_t ueDeviceIndex
Definition: test-lte-x2-handover.cc:37

LteX2HandoverTestSuite
Definition: test-lte-x2-handover.cc:537

ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:44

startTime
double startTime
Definition: tcp-nsc-comparison.cc:45

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:158

LteX2HandoverTestCase::m_admitHo
bool m_admitHo
Definition: test-lte-x2-handover.cc:72

LteX2HandoverTestCase::m_schedulerType
std::string m_schedulerType
Definition: test-lte-x2-handover.cc:71

ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:41

LteX2HandoverTestSuite::LteX2HandoverTestSuite
LteX2HandoverTestSuite()
Definition: test-lte-x2-handover.cc:544

g_lteX2HandoverTestSuiteInstance
static LteX2HandoverTestSuite g_lteX2HandoverTestSuiteInstance
Definition: test-lte-x2-handover.cc:673

LteX2HandoverTestCase::m_ueDataVector
std::vector< UeData > m_ueDataVector
Definition: test-lte-x2-handover.cc:95

LteX2HandoverTestCase::m_statsDuration
const Time m_statsDuration
Definition: test-lte-x2-handover.cc:98

ns3::ApplicationContainer::Start
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter...
Definition: application-container.cc:84

HandoverEvent::sourceEnbDeviceIndex
uint32_t sourceEnbDeviceIndex
Definition: test-lte-x2-handover.cc:38

first.serverApps
tuple serverApps
Definition: first.py:45

ns3::Ipv4
Access to the Ipv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:76

LteX2HandoverTestCase::BearerData
Definition: test-lte-x2-handover.cc:77

LteX2HandoverTestCase::m_handoverEventList
std::list< HandoverEvent > m_handoverEventList
Definition: test-lte-x2-handover.cc:67

ns3::EpcTft::PacketFilter::remotePortEnd
uint16_t remotePortEnd
end of the port number range of the remote host
Definition: epc-tft.h:113

ns3::PointToPointEpcHelper::GetUeDefaultGatewayAddress
virtual Ipv4Address GetUeDefaultGatewayAddress()
Definition: point-to-point-epc-helper.cc:339

LteX2HandoverTestCase::m_useIdealRrc
bool m_useIdealRrc
Definition: test-lte-x2-handover.cc:73

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.

ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:38

ns3::ApplicationContainer::Get
Ptr< Application > Get(uint32_t i) const
Get the Ptr stored in this container at a given index.
Definition: application-container.cc:59

LteX2HandoverTestCase::m_udpClientInterval
const Time m_udpClientInterval
Definition: test-lte-x2-handover.cc:99

ns3::UeManager::State
State
The state of the UeManager at the eNB RRC.
Definition: lte-enb-rrc.h:73

LteX2HandoverTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: test-lte-x2-handover.cc:145

ns3::MobilityHelper::SetMobilityModel
void SetMobilityModel(std::string type, std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue(), std::string n8="", const AttributeValue &v8=EmptyAttributeValue(), std::string n9="", const AttributeValue &v9=EmptyAttributeValue())
Definition: mobility-helper.cc:79

ns3::UniformRandomVariable::GetValue
double GetValue(double min, double max)
Returns a random double from the uniform distribution with the specified range.
Definition: random-variable-stream.cc:180

ns3::InternetStackHelper::Install
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Definition: internet-stack-helper.cc:487

ns3::LteHelper::AddX2Interface
void AddX2Interface(NodeContainer enbNodes)
Create an X2 interface between all the eNBs in a given set.
Definition: lte-helper.cc:976

ns3::ObjectPtrContainerValue::Begin
Iterator Begin(void) const
Get an iterator to the first Object.
Definition: object-ptr-container.cc:39

ns3::ObjectBase::GetAttribute
void GetAttribute(std::string name, AttributeValue &value) const
Get the value of an attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:228

LteX2HandoverTestCase::UeData
Definition: test-lte-x2-handover.cc:86

LteX2HandoverTestCase::m_epcHelper
Ptr< PointToPointEpcHelper > m_epcHelper
Definition: test-lte-x2-handover.cc:75

ns3::UeManager::GetImsi
uint64_t GetImsi(void) const
Definition: lte-enb-rrc.cc:1059

ns3::Config::Reset
void Reset(void)
Reset the initial value of every attribute as well as the value of every global to what they were bef...
Definition: config.cc:658

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:70

NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:90

ns3::LteHelper::InstallUeDevice
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:397

ns3::PointToPointEpcHelper::AssignUeIpv4Address
virtual Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices)
Assign IPv4 addresses to UE devices.
Definition: point-to-point-epc-helper.cc:331

LteX2HandoverTestCase::CheckConnected
void CheckConnected(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice)
Definition: test-lte-x2-handover.cc:440

ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:42

ns3::Ipv4StaticRouting::AddNetworkRouteTo
void AddNetworkRouteTo(Ipv4Address network, Ipv4Mask networkMask, Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a network route to the static routing table.
Definition: ipv4-static-routing.cc:63

ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40

LteX2HandoverTestCase::m_maxHoDuration
const Time m_maxHoDuration
Definition: test-lte-x2-handover.cc:97

LteX2HandoverTestCase::CheckStatsAWhileAfterHandover
void CheckStatsAWhileAfterHandover(uint32_t ueIndex)
Definition: test-lte-x2-handover.cc:519

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:131

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:58

ns3::LteHelper::SetEpcHelper
void SetEpcHelper(Ptr< EpcHelper > h)
Set the EpcHelper to be used to setup the EPC network in conjunction with the setup of the LTE radio ...
Definition: lte-helper.cc:218

NS_TEST_ASSERT_MSG_NE
#define NS_TEST_ASSERT_MSG_NE(actual, limit, msg)
Test that an actual and expected (limit) value are not equal and report and abort if not...
Definition: test.h:593

ns3::LteDataRadioBearerInfo::m_drbIdentity
uint8_t m_drbIdentity
Definition: lte-radio-bearer-info.h:79

ns3::Ipv4StaticRoutingHelper
Helper class that adds ns3::Ipv4StaticRouting objects.
Definition: ipv4-static-routing-helper.h:40

ns3::DataRateValue
AttributeValue implementation for DataRate.
Definition: data-rate.h:238

ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr stored in this container at a given index.
Definition: node-container.cc:88

ns3::ObjectPtrContainerValue::End
Iterator End(void) const
Get an iterator to the past-the-end Object.
Definition: object-ptr-container.cc:45

ns3::NetDeviceContainer::Iterator
std::vector< Ptr< NetDevice > >::const_iterator Iterator
NetDevice container iterator.
Definition: net-device-container.h:45

ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:866

LteX2HandoverTestCase::BearerData::dlOldTotalRx
uint32_t dlOldTotalRx
Definition: test-lte-x2-handover.cc:82

ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:683

ns3::ListPositionAllocator::Add
void Add(Vector v)
Add a position to the list of positions.
Definition: position-allocator.cc:66

LteX2HandoverTestCase::BearerData::ulOldTotalRx
uint32_t ulOldTotalRx
Definition: test-lte-x2-handover.cc:83

LteX2HandoverTestCase::m_epc
bool m_epc
Definition: test-lte-x2-handover.cc:69

ns3::PacketSinkHelper::Install
ApplicationContainer Install(NodeContainer c) const
Install an ns3::PacketSinkApplication on each node of the input container configured with all the att...
Definition: packet-sink-helper.cc:55

HandoverEvent
Definition: test-lte-x2-handover.cc:34

ns3::Ipv4AddressHelper
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Definition: ipv4-address-helper.h:45

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:93

ns3::BulkSendHelper::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Helper function used to set the underlying application attributes, not the socket attributes...
Definition: bulk-send-helper.cc:39

ns3::ObjectPtrContainerValue::GetN
uint32_t GetN(void) const
Get the number of Objects.
Definition: object-ptr-container.cc:51

ns3::ObjectPtrContainerValue
Container for a set of ns3::Object pointers.
Definition: object-ptr-container.h:45

ns3::PacketSink
Receive and consume traffic generated to an IP address and port.
Definition: packet-sink.h:68

ns3::MobilityHelper::SetPositionAllocator
void SetPositionAllocator(Ptr< PositionAllocator > allocator)
Set the position allocator which will be used to allocate the initial position of every node initiali...
Definition: mobility-helper.cc:47

ns3::NetDeviceContainer::End
Iterator End(void) const
Get an iterator which indicates past-the-last NetDevice in the container.
Definition: net-device-container.cc:51

NS_TEST_ASSERT_MSG_GT
#define NS_TEST_ASSERT_MSG_GT(actual, limit, msg)
Test that an actual value is greater than a limit and report and abort if not.
Definition: test.h:960

ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'...
Definition: double.h:41

ns3::ObjectBase::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:190

ns3::LteEnbNetDevice
The eNodeB device implementation.
Definition: lte-enb-net-device.h:52

ns3::Object::GetObject
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:455

ns3::EpsBearer::Qci
Qci
QoS Class Indicator.
Definition: eps-bearer.h:77

ns3::EpcTft::PacketFilter::remotePortStart
uint16_t remotePortStart
start of the port number range of the remote host
Definition: epc-tft.h:112

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:60

ns3::EpcTft::PacketFilter
Implement the data structure representing a TrafficFlowTemplate Packet Filter.
Definition: epc-tft.h:73

ns3::Ipv4InterfaceContainer::GetAddress
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Definition: ipv4-interface-container.cc:39

ns3::EpcTft::PacketFilter::localPortStart
uint16_t localPortStart
start of the port number range of the UE
Definition: epc-tft.h:114

ns3::LteDataRadioBearerInfo::m_epsBearerIdentity
uint8_t m_epsBearerIdentity
Definition: lte-radio-bearer-info.h:78

ns3::LteUeNetDevice
The LteUeNetDevice class implements the UE net device.
Definition: lte-ue-net-device.h:51