d8/d3b/test-lte-x2-handover_8cc_source.html

/*

 * 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/internet-module.h>

#include <ns3/lte-module.h>

#include <ns3/mobility-module.h>

#include <ns3/network-module.h>

#include <ns3/packet-sink-helper.h>

#include <ns3/packet-sink.h>

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

#include <ns3/udp-client-server-helper.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,

                          std::string schedulerType,

                          bool admitHo,

                          bool useIdealRrc);


  private:

    static std::string BuildNameString(uint32_t nUes,

                                       uint32_t nDedicatedBearers,

                                       std::string handoverEventListName,

                                       std::string schedulerType,

                                       bool admitHo,

                                       bool useIdealRrc);

    void DoRun() override;

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


    void TeleportUeToMiddle(Ptr<Node> ueNode);


    void TeleportUeNearTargetEnb(Ptr<Node> ueNode, Ptr<Node> enbNode);


    uint32_t m_nUes;

    uint32_t m_nDedicatedBearers;

    std::list<HandoverEvent> m_handoverEventList;

    std::string m_handoverEventListName;

    bool m_epc;

    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,

                                       std::string schedulerType,

                                       bool admitHo,

                                       bool useIdealRrc)

{

    std::ostringstream oss;

    oss << " nUes=" << nUes << " nDedicatedBearers=" << nDedicatedBearers << " " << 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,

                                             std::string schedulerType,

                                             bool admitHo,

                                             bool useIdealRrc)

    : TestCase(BuildNameString(nUes,

                               nDedicatedBearers,

                               handoverEventListName,

                               schedulerType,

                               admitHo,

                               useIdealRrc)),

      m_nUes(nUes),

      m_nDedicatedBearers(nDedicatedBearers),

      m_handoverEventList(handoverEventList),

      m_handoverEventListName(handoverEventListName),

      m_epc(true),

      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_schedulerType,

                                            m_admitHo,

                                            m_useIdealRrc));


    uint32_t previousSeed = RngSeedManager::GetSeed();

    uint64_t previousRun = RngSeedManager::GetRun();

    Config::Reset();

    // This test is sensitive to random variable stream assignments

    RngSeedManager::SetSeed(1);

    RngSeedManager::SetRun(3);

    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 (uint32_t i = 0; i < m_nUes; i++)

    {

        positionAlloc->Add(Vector(-3000, 100, 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 (auto 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 = BearerData();


                // 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);

                }


                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);

                }

                double d = startTimeSeconds->GetValue();

                Time startTime = Seconds(d);

                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)

            {

                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 (auto 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 (auto hoEventIt = m_handoverEventList.begin(); hoEventIt != m_handoverEventList.end();

         ++hoEventIt)

    {

        // Teleport the UE between both eNBs just before the handover starts

        Simulator::Schedule(hoEventIt->startTime - MilliSeconds(10),

                            &LteX2HandoverTestCase::TeleportUeToMiddle,

                            this,

                            ueNodes.Get(hoEventIt->ueDeviceIndex));


        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));


        // Once the handover is finished, teleport the UE near the target eNB

        Simulator::Schedule(hoEventIt->startTime + MilliSeconds(40),

                            &LteX2HandoverTestCase::TeleportUeNearTargetEnb,

                            this,

                            ueNodes.Get(hoEventIt->ueDeviceIndex),

                            enbNodes.Get(m_admitHo ? hoEventIt->targetEnbDeviceIndex

                                                   : hoEventIt->sourceEnbDeviceIndex));


        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();


    // Undo changes to default settings

    Config::Reset();

    // Restore the previous settings of RngSeed and RngRun

    RngSeedManager::SetSeed(previousSeed);

    RngSeedManager::SetRun(previousRun);

}


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, nullptr, "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");


    auto enbBearerIt = enbDataRadioBearerMapValue.Begin();

    auto 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::TeleportUeToMiddle(Ptr<Node> ueNode)

{

    Ptr<MobilityModel> ueMobility = ueNode->GetObject<MobilityModel>();

    ueMobility->SetPosition(Vector(0.0, 0.0, 0.0));

}


void

LteX2HandoverTestCase::TeleportUeNearTargetEnb(Ptr<Node> ueNode, Ptr<Node> enbNode)

{

    Ptr<MobilityModel> enbMobility = enbNode->GetObject<MobilityModel>();

    Vector pos = enbMobility->GetPosition();


    Ptr<MobilityModel> ueMobility = ueNode->GetObject<MobilityModel>();

    ueMobility->SetPosition(pos + Vector(0.0, 100.0, 0.0));

}


void

LteX2HandoverTestCase::SaveStatsAfterHandover(uint32_t ueIndex)

{

    for (auto 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 (auto 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 / m_udpClientInterval).GetDouble();


        NS_TEST_ASSERT_MSG_EQ(dlRx,

                              expectedBytes,

                              "too few RX bytes in DL, ue=" << ueIndex << ", b=" << b);

        NS_TEST_ASSERT_MSG_EQ(ulRx,

                              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(400);

    ue1bwd.ueDeviceIndex = 0;

    ue1bwd.sourceEnbDeviceIndex = 1;

    ue1bwd.targetEnbDeviceIndex = 0;


    HandoverEvent ue1fwdagain;

    ue1fwdagain.startTime = MilliSeconds(700);

    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(350);

    ue2bwd.ueDeviceIndex = 1;

    ue2bwd.sourceEnbDeviceIndex = 1;

    ue2bwd.targetEnbDeviceIndex = 0;


    std::string handoverEventList0name("none");

    std::list<HandoverEvent> handoverEventList0;


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

    const std::list<HandoverEvent> handoverEventList1{

        ue1fwd,

    };


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

    const std::list<HandoverEvent> handoverEventList2{

        ue1fwd,

        ue1bwd,

    };


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

    const std::list<HandoverEvent> handoverEventList3{

        ue1fwd,

        ue1bwd,

        ue1fwdagain,

    };


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

    const std::list<HandoverEvent> handoverEventList4{

        ue1fwd,

        ue2fwd,

    };


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

    const std::list<HandoverEvent> handoverEventList5{

        ue1fwd,

        ue1bwd,

        ue2fwd,

        ue2bwd,

    };


    // std::string handoverEventList6name("2 fwd");

    // const std::list<HandoverEvent> handoverEventList6{

    //     ue2fwd,

    // };


    // std::string handoverEventList7name("2 fwd & bwd");

    // const std::list<HandoverEvent> handoverEventList7{

    //     ue2fwd,

    //     ue2bwd,

    // };


    std::vector<std::string> schedulers{

        "ns3::RrFfMacScheduler",

        "ns3::PfFfMacScheduler",

    };


    for (auto schedIt = schedulers.begin(); schedIt != schedulers.end(); ++schedIt)

    {

        for (auto useIdealRrc : {true, false})

        {

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

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  0,

                                                  handoverEventList0,

                                                  handoverEventList0name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  0,

                                                  handoverEventList0,

                                                  handoverEventList0name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  5,

                                                  handoverEventList0,

                                                  handoverEventList0name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  5,

                                                  handoverEventList0,

                                                  handoverEventList0name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  0,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  1,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  2,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  0,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  false,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  1,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  false,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  2,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  false,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  0,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  1,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  2,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  0,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  false,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  1,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  false,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  2,

                                                  handoverEventList1,

                                                  handoverEventList1name,

                                                  *schedIt,

                                                  false,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  0,

                                                  handoverEventList2,

                                                  handoverEventList2name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  1,

                                                  handoverEventList2,

                                                  handoverEventList2name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  2,

                                                  handoverEventList2,

                                                  handoverEventList2name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  0,

                                                  handoverEventList3,

                                                  handoverEventList3name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  1,

                                                  handoverEventList3,

                                                  handoverEventList3name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(1,

                                                  2,

                                                  handoverEventList3,

                                                  handoverEventList3name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  0,

                                                  handoverEventList3,

                                                  handoverEventList3name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  1,

                                                  handoverEventList3,

                                                  handoverEventList3name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  2,

                                                  handoverEventList3,

                                                  handoverEventList3name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::QUICK);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  0,

                                                  handoverEventList4,

                                                  handoverEventList4name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  1,

                                                  handoverEventList4,

                                                  handoverEventList4name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  2,

                                                  handoverEventList4,

                                                  handoverEventList4name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  0,

                                                  handoverEventList5,

                                                  handoverEventList5name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  1,

                                                  handoverEventList5,

                                                  handoverEventList5name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(2,

                                                  2,

                                                  handoverEventList5,

                                                  handoverEventList5name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(3,

                                                  0,

                                                  handoverEventList3,

                                                  handoverEventList3name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(3,

                                                  1,

                                                  handoverEventList3,

                                                  handoverEventList3name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(3,

                                                  2,

                                                  handoverEventList3,

                                                  handoverEventList3name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(3,

                                                  0,

                                                  handoverEventList4,

                                                  handoverEventList4name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(3,

                                                  1,

                                                  handoverEventList4,

                                                  handoverEventList4name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(3,

                                                  2,

                                                  handoverEventList4,

                                                  handoverEventList4name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(3,

                                                  0,

                                                  handoverEventList5,

                                                  handoverEventList5name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(3,

                                                  1,

                                                  handoverEventList5,

                                                  handoverEventList5name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::EXTENSIVE);

            AddTestCase(new LteX2HandoverTestCase(3,

                                                  2,

                                                  handoverEventList5,

                                                  handoverEventList5name,

                                                  *schedIt,

                                                  true,

                                                  useIdealRrc),

                        TestCase::QUICK);

        }

    }

}


static LteX2HandoverTestSuite g_lteX2HandoverTestSuiteInstance;

LteX2HandoverTestCase
Test X2 Handover.
Definition: test-lte-x2-handover.cc:54

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

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

LteX2HandoverTestCase::m_epcHelper
Ptr< PointToPointEpcHelper > m_epcHelper
EPC helper.
Definition: test-lte-x2-handover.cc:122

LteX2HandoverTestCase::m_nUes
uint32_t m_nUes
number of UEs in the test
Definition: test-lte-x2-handover.cc:113

LteX2HandoverTestCase::m_handoverEventListName
std::string m_handoverEventListName
handover event list name
Definition: test-lte-x2-handover.cc:116

LteX2HandoverTestCase::m_schedulerType
std::string m_schedulerType
scheduler type
Definition: test-lte-x2-handover.cc:118

LteX2HandoverTestCase::m_udpClientPktSize
const uint32_t m_udpClientPktSize
UDP client packet size.
Definition: test-lte-x2-handover.cc:165

LteX2HandoverTestCase::m_useIdealRrc
bool m_useIdealRrc
whether to use the ideal RRC
Definition: test-lte-x2-handover.cc:120

LteX2HandoverTestCase::m_statsDuration
const Time m_statsDuration
stats duration
Definition: test-lte-x2-handover.cc:163

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

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

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

LteX2HandoverTestCase::TeleportUeNearTargetEnb
void TeleportUeNearTargetEnb(Ptr< Node > ueNode, Ptr< Node > enbNode)
Teleport UE near the target eNB of the handover.
Definition: test-lte-x2-handover.cc:611

LteX2HandoverTestCase::m_admitHo
bool m_admitHo
whether to admit the handover request
Definition: test-lte-x2-handover.cc:119

LteX2HandoverTestCase::m_epc
bool m_epc
whether to use EPC
Definition: test-lte-x2-handover.cc:117

LteX2HandoverTestCase::SaveStatsAfterHandover
void SaveStatsAfterHandover(uint32_t ueIndex)
Save stats after handover function.
Definition: test-lte-x2-handover.cc:621

LteX2HandoverTestCase::m_maxHoDuration
const Time m_maxHoDuration
maximum HO duration
Definition: test-lte-x2-handover.cc:162

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

LteX2HandoverTestCase::CheckStatsAWhileAfterHandover
void CheckStatsAWhileAfterHandover(uint32_t ueIndex)
Check stats a while after handover function.
Definition: test-lte-x2-handover.cc:633

LteX2HandoverTestCase::m_nDedicatedBearers
uint32_t m_nDedicatedBearers
number of UEs in the test
Definition: test-lte-x2-handover.cc:114

LteX2HandoverTestCase::m_udpClientInterval
const Time m_udpClientInterval
UDP client interval.
Definition: test-lte-x2-handover.cc:164

LteX2HandoverTestCase::TeleportUeToMiddle
void TeleportUeToMiddle(Ptr< Node > ueNode)
Teleport UE between both eNBs of the test.
Definition: test-lte-x2-handover.cc:604

LteX2HandoverTestCase::m_lteHelper
Ptr< LteHelper > m_lteHelper
LTE helper.
Definition: test-lte-x2-handover.cc:121

LteX2HandoverTestSuite
LTE X2 Handover Test Suite.
Definition: test-lte-x2-handover.cc:670

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

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

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

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::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::NGBR_VIDEO_TCP_DEFAULT
@ NGBR_VIDEO_TCP_DEFAULT
Non-GBR TCP-based Video (Buffered Streaming, e.g., www, e-mail...)
Definition: eps-bearer.h:126

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

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::Ipv4Address::GetAny
static Ipv4Address GetAny()
Definition: ipv4-address.cc:378

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

ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Definition: ipv4-interface-container.h:56

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

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

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::LteDataRadioBearerInfo
store information on active data radio bearer instance
Definition: lte-radio-bearer-info.h:77

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

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

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

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

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

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

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

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

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

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

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

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

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

ns3::LteUeRrc::CONNECTED_NORMALLY
@ CONNECTED_NORMALLY
Definition: lte-ue-rrc.h:109

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::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43

ns3::NetDeviceContainer::GetN
uint32_t GetN() const
Get the number of Ptr<NetDevice> stored in this container.
Definition: net-device-container.cc:61

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

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

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::NoBackhaulEpcHelper::GetPgwNode
Ptr< Node > GetPgwNode() const override
Get the PGW node.
Definition: no-backhaul-epc-helper.cc:529

ns3::NoBackhaulEpcHelper::GetUeDefaultGatewayAddress
Ipv4Address GetUeDefaultGatewayAddress() override
Definition: no-backhaul-epc-helper.cc:552

ns3::NoBackhaulEpcHelper::AssignUeIpv4Address
Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices) override
Assign IPv4 addresses to UE devices.
Definition: no-backhaul-epc-helper.cc:535

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::ObjectBase::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:204

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

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

ns3::ObjectPtrContainerValue::GetN
std::size_t GetN() const
Get the number of Objects.
Definition: object-ptr-container.cc:54

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

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

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

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

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

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

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

ns3::RngSeedManager::SetRun
static void SetRun(uint64_t run)
Set the run number of simulation.
Definition: rng-seed-manager.cc:90

ns3::RngSeedManager::SetSeed
static void SetSeed(uint32_t seed)
Set the seed.
Definition: rng-seed-manager.cc:83

ns3::RngSeedManager::GetRun
static uint64_t GetRun()
Get the current run number.
Definition: rng-seed-manager.cc:97

ns3::RngSeedManager::GetSeed
static uint32_t GetSeed()
Get the current seed value which will be used by all subsequently instantiated RandomVariableStream o...
Definition: rng-seed-manager.cc:74

ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:571

ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:142

ns3::Simulator::Run
static void Run()
Run the simulation.
Definition: simulator.cc:178

ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:186

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::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::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::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1413

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

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

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

ns3::UeManager::CONNECTED_NORMALLY
@ CONNECTED_NORMALLY
Definition: lte-enb-rrc.h:83

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

uint32_t

stopTime
Time stopTime
Definition: tcp-linux-reno.cc:52

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

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

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

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

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

g_lteX2HandoverTestSuiteInstance
static LteX2HandoverTestSuite g_lteX2HandoverTestSuiteInstance
Static variable for test initialization.
Definition: test-lte-x2-handover.cc:1096

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_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:564

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

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

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

HandoverEvent
HandoverEvent structure.
Definition: test-lte-x2-handover.cc:40

HandoverEvent::ueDeviceIndex
uint32_t ueDeviceIndex
UE device index.
Definition: test-lte-x2-handover.cc:42

HandoverEvent::startTime
Time startTime
start time
Definition: test-lte-x2-handover.cc:41

HandoverEvent::targetEnbDeviceIndex
uint32_t targetEnbDeviceIndex
target ENB device index
Definition: test-lte-x2-handover.cc:44

HandoverEvent::sourceEnbDeviceIndex
uint32_t sourceEnbDeviceIndex
source ENB device index
Definition: test-lte-x2-handover.cc:43

LteX2HandoverTestCase::BearerData
BearerData structure.
Definition: test-lte-x2-handover.cc:130

LteX2HandoverTestCase::BearerData::dlOldTotalRx
uint32_t dlOldTotalRx
DL old total receive.
Definition: test-lte-x2-handover.cc:134

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

LteX2HandoverTestCase::BearerData::ulOldTotalRx
uint32_t ulOldTotalRx
UL old total receive.
Definition: test-lte-x2-handover.cc:135

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

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

LteX2HandoverTestCase::UeData
UeData structure.
Definition: test-lte-x2-handover.cc:144

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

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

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

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

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

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

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