#include <ns3/integer.h>

  //LogComponentEnable ("LteCellSelectionTest", LOG_PREFIX_ALL);

  //LogComponentEnable ("LteCellSelectionTest", LOG_FUNCTION);

  //LogComponentEnable ("LteCellSelectionTest", LOG_INFO);

  //LogComponentEnable ("LteSpectrumPhy", LOG_PREFIX_ALL);

  //LogComponentEnable ("LteSpectrumPhy", LOG_DEBUG);

  std::ostringstream oss;

  std::vector<LteCellSelectionTestCase::UeSetup_t> w;

  w.clear ();

  //                                                     x     y    csgMember

  //                                                     checkPoint     cell1, cell2

  w.push_back (LteCellSelectionTestCase::UeSetup_t (0.0, 1.55, false,

                                                    MilliSeconds (266), 1, 0));

  w.push_back (LteCellSelectionTestCase::UeSetup_t (0.0, 1.45, false,

                                                    MilliSeconds (266), 1, 0));

  w.push_back (LteCellSelectionTestCase::UeSetup_t (0.5, 2.0,  false,

                                                    MilliSeconds (266), 1, 4));

  w.push_back (LteCellSelectionTestCase::UeSetup_t (0.5, 1.45, false,

                                                    MilliSeconds (341), 1, 4));

  w.push_back (LteCellSelectionTestCase::UeSetup_t (0.5, 0.55, true,

                                                    MilliSeconds (266), 2, 5));

  w.push_back (LteCellSelectionTestCase::UeSetup_t (0.5, 0.0,  true,

                                                    MilliSeconds (266), 3, 6));

  w.push_back (LteCellSelectionTestCase::UeSetup_t (1.0, 0.55, true,

                                                    MilliSeconds (266), 5, 0));

  w.push_back (LteCellSelectionTestCase::UeSetup_t (1.0, 0.45, true,

                                                    MilliSeconds (266), 6, 0));

  AddTestCase (new LteCellSelectionTestCase ("EPC, ideal RRC, RngNum=1",

                                             true, true,

                                             60.0, 20.0, w, 1),

                                          // isd   txpow    rngrun

  for (int64_t i = 2; i <= 4; i++)

    {

      oss.str ("");

      oss << "EPC, ideal RRC, RngNum=" << i;

      AddTestCase (new LteCellSelectionTestCase (oss.str (), true, true,

                                                 60.0, 20.0, w, 1),

                                              // isd   txpow    rngrun

                   TestCase::TAKES_FOREVER);

    }

 * 6-cell Test Case

LteCellSelectionTestCase::UeSetup_t::UeSetup_t (

  double relPosX, double relPosY, bool isCsgMember, Time checkPoint,

  uint16_t expectedCellId1, uint16_t expectedCellId2)

  : position (Vector (relPosX, relPosY, 0.0)),

    isCsgMember (isCsgMember),

    checkPoint (checkPoint),

    expectedCellId1 (expectedCellId1),

    expectedCellId2 (expectedCellId2)

  std::string name, bool isEpcMode, bool isIdealRrc,

  double interSiteDistance, double enbTxPower,

  std::vector<UeSetup_t> ueSetupList, int64_t rngRun)

    m_interSiteDistance (interSiteDistance),

    m_enbTxPower (enbTxPower),

    m_rngRun (rngRun)

  Config::SetGlobal ("RngRun", IntegerValue (m_rngRun));

   * TODO

  enbNodes.Create (6);

  // eNodeB

  positionAlloc->Add (Vector (                0.0, 2 * m_interSiteDistance, 0.0));

  positionAlloc->Add (Vector (                0.0,     m_interSiteDistance, 0.0));

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

  positionAlloc->Add (Vector (m_interSiteDistance, 2 * m_interSiteDistance, 0.0));

  positionAlloc->Add (Vector (m_interSiteDistance,     m_interSiteDistance, 0.0));

  positionAlloc->Add (Vector (m_interSiteDistance,                     0.0, 0.0));

  // UE

  for (itSetup = m_ueSetupList.begin ();

       itSetup != m_ueSetupList.end (); itSetup++)

      Vector uePos (m_interSiteDistance * itSetup->position.x,

                    m_interSiteDistance * itSetup->position.y,

                    m_interSiteDistance * itSetup->position.z);

      NS_LOG_INFO ("UE position " << uePos);

      positionAlloc->Add (uePos);

  int64_t stream = 1;

  enbDevs = lteHelper->InstallEnbDevice (enbNodes);

  stream += lteHelper->AssignStreams (enbDevs, stream);

  lteHelper->SetEnbCsgId (enbDevs.Get (1), 1, true); // cell ID 2

  lteHelper->SetEnbCsgId (enbDevs.Get (4), 1, true); // cell ID 5

  stream += lteHelper->AssignStreams (ueDevs, stream);

  Time lastCheckPoint = MilliSeconds (0);

      if (itSetup->isCsgMember)

        {

          lteHelper->SetUeCsgId (*itDev, 1);

        }

      Ptr<LteUeNetDevice> ueDev = (*itDev)->GetObject<LteUeNetDevice> ();

      NS_ASSERT (ueDev != 0);

      Simulator::Schedule (itSetup->checkPoint,

                           &LteCellSelectionTestCase::CheckPoint,

                           this, ueDev,

                           itSetup->expectedCellId1, itSetup->expectedCellId2);

      if (lastCheckPoint < itSetup->checkPoint)

        {

          lastCheckPoint = itSetup->checkPoint;

        }

    }

  // Tests

  NS_ASSERT (m_ueSetupList.size () == ueDevs.GetN ());

  for (itSetup = m_ueSetupList.begin (), itDev = ueDevs.Begin ();

       itSetup != m_ueSetupList.end () || itDev != ueDevs.End ();

       itSetup++, itDev++)

    {

      Ptr<LteUeNetDevice> ueDev = (*itDev)->GetObject<LteUeNetDevice> ();

                   MakeCallback (&LteCellSelectionTestCase::StateTransitionCallback,

                                 this));

                   MakeCallback (&LteCellSelectionTestCase::InitialCellSelectionEndOkCallback,

                                 this));

                   MakeCallback (&LteCellSelectionTestCase::InitialCellSelectionEndErrorCallback,

                                 this));

                   MakeCallback (&LteCellSelectionTestCase::ConnectionEstablishedCallback,

                                 this));

  Simulator::Stop (lastCheckPoint);

  NS_LOG_INFO ("Simulation ends");

} // end of void LteCellSelection6CellTestCase::DoRun ()

LteCellSelectionTestCase::CheckPoint (Ptr<LteUeNetDevice> ueDev,

                                      uint16_t expectedCellId1,

                                      uint16_t expectedCellId2)

  uint16_t actualCellId = ueDev->GetRrc ()->GetCellId ();

  if (expectedCellId2 == 0)

    {

      NS_TEST_ASSERT_MSG_EQ (actualCellId, expectedCellId1,

                             "IMSI " << ueDev->GetImsi ()

                                     << " has attached to an unexpected cell");

    }

  else

    {

      bool pass = (actualCellId == expectedCellId1) ||

        (actualCellId == expectedCellId2);

      NS_TEST_ASSERT_MSG_EQ (pass, true,

                             "IMSI " << ueDev->GetImsi ()

                                     << " has attached to an unexpected cell"

                                     << " (actual: " << actualCellId << ","

                                     << " expected: " << expectedCellId1

                                     << " or " << expectedCellId2 << ")");

    }

  if (expectedCellId1 > 0)

    {

      NS_TEST_ASSERT_MSG_EQ (m_lastState.at (ueDev->GetImsi () - 1),

                             LteUeRrc::CONNECTED_NORMALLY,

                             "UE " << ueDev->GetImsi ()

                                   << " is not at CONNECTED_NORMALLY state");

    }

LteCellSelectionTestCase::StateTransitionCallback (

  LteUeRrc::State oldState, LteUeRrc::State newState)