m_noRaResponseReceivedEvent.Cancel ();

    .AddAttribute ("T300",

                   "Timer for the RRC Connection Establishment procedure "

                   "(i.e., the procedure is deemed as failed if it takes longer than this)",

                   TimeValue (MilliSeconds (100)),

                   MakeTimeAccessor (&LteUeRrc::m_t300),

                   MakeTimeChecker ())

    .AddTraceSource ("ConnectionTimeout",

                     "trace fired upon timeout RRC connection establishment because of T300",

                     MakeTraceSourceAccessor (&LteUeRrc::m_connectionTimeoutTrace))

        m_connectionTimeout = Simulator::Schedule (m_t300,

                                                   &LteUeRrc::ConnectionTimeout,

                                                   this);

        m_connectionTimeout.Cancel ();

  m_connectionTimeout.Cancel ();

LteUeRrc::ConnectionTimeout ()

{

  NS_LOG_FUNCTION (this << m_imsi);

  m_cmacSapProvider->Reset ();

  SwitchToState (IDLE_CAMPED_NORMALLY);

  m_connectionTimeoutTrace (m_imsi, m_cellId, m_rnti);

  m_asSapUser->NotifyConnectionFailed ();

}

void

  TracedCallback<uint64_t, uint16_t, uint16_t> m_connectionTimeoutTrace;

  //             imsi      cellId    rnti

  /**

   * \brief Timer for RRC connection establishment procedure.

   *

   * Section 7.3 TS 36.331.

   */

  Time m_t300;

  /**

   * \brief Invokes ConnectionEstablishmentTimeout() if RRC connection

   *        establishment procedure for this UE takes longer than T300.

   */

  EventId m_connectionTimeout;

  /**

   * \brief Invoked after timer T300 expires, notifying upper layers that RRC

   *        connection establishment procedure has failed.

   */

  void ConnectionTimeout ();

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

/*

 * Copyright (c) 2013 Budiarto Herman

 *

 * 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: Budiarto Herman <budiarto.herman@magister.fi>

 *

 */

#include <ns3/test.h>

#include <ns3/lte-ue-rrc.h>

#include <ns3/lte-ue-net-device.h>

#include <ns3/lte-enb-rrc.h>

#include <ns3/lte-enb-net-device.h>

#include <ns3/simulator.h>

#include <ns3/log.h>

#include <ns3/boolean.h>

#include <ns3/integer.h>

#include <ns3/string.h>

#include <ns3/mobility-helper.h>

#include <ns3/lte-helper.h>

#include <ns3/node-container.h>

#include <ns3/net-device-container.h>

NS_LOG_COMPONENT_DEFINE ("LteRrcConnEstablishmentTest");

namespace ns3 {

/**

 * \brief TODO

 */

class LteRrcConnEstablishmentTestCase : public TestCase

{

public:

  /**

   * \brief TODO

   */

  LteRrcConnEstablishmentTestCase (uint16_t nUe, double distance,

                                   int64_t rngRun);

  virtual ~LteRrcConnEstablishmentTestCase ();

private:

  virtual void DoRun ();

//  void DlSchedulingCallback (std::string context, uint32_t frameNo,

//                             uint32_t subframeNo, uint16_t rnti,

//                             uint8_t mcs1, uint16_t tbSize1,

//                             uint8_t mcs2, uint16_t tbSize2);

//  void UlSchedulingCallback (std::string context, uint32_t frameNo,

//                             uint32_t subframeNo, uint16_t rnti,

//                             uint8_t mcs, uint16_t tbSize);

//  void UeStateTransitionCallback (std::string context, uint64_t imsi,

//                                  uint16_t cellId, uint16_t rnti,

//                                  LteUeRrc::State oldState, LteUeRrc::State newState);

//  void EnbStateTransitionCallback (std::string context, uint64_t imsi,

//                                  uint16_t cellId, uint16_t rnti,

//                                  UeManager::State oldState, UeManager::State newState);

  void ConnectionEstablishedCallback (std::string context, uint64_t imsi,

                                      uint16_t cellId, uint16_t rnti);

  void ConnectionTimeoutCallback (std::string context, uint64_t imsi,

                                  uint16_t cellId, uint16_t rnti);

  uint16_t m_nUe;

  double m_distance;

  int64_t m_rngRun;

  bool m_isConnectionEstablished;

  bool m_isConnectionTimeout;

};

LteRrcConnEstablishmentTestCase::LteRrcConnEstablishmentTestCase (

  uint16_t nUe, double distance, int64_t rngRun)

  : TestCase (""),

    m_nUe (nUe),

    m_distance (distance),

    m_rngRun (rngRun),

    m_isConnectionEstablished (false),

    m_isConnectionTimeout (false)

{

  NS_LOG_FUNCTION (this << GetName ());

}

LteRrcConnEstablishmentTestCase::~LteRrcConnEstablishmentTestCase ()

{

  NS_LOG_FUNCTION (this << GetName ());

}

void

LteRrcConnEstablishmentTestCase::DoRun ()

{

  NS_LOG_FUNCTION (this << GetName ());

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

  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();

  lteHelper->SetAttribute ("PathlossModel",

                           StringValue ("ns3::FriisSpectrumPropagationLossModel"));

  lteHelper->SetAttribute ("UseIdealRrc", BooleanValue (false));

  // Create Nodes

  NodeContainer enbNodes;

  enbNodes.Create (4);

  NodeContainer ueNodes;

  ueNodes.Create (m_nUe);

  // Assign nodes to position

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

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

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

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

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

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

    {

      positionAlloc->Add (Vector (0.55 * m_distance, 0.55 * m_distance, 0));

    }

  MobilityHelper mobility;

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

  mobility.SetPositionAllocator (positionAlloc);

  mobility.Install (enbNodes);

  mobility.Install (ueNodes);

  // Create Devices and install them in the Nodes (eNB and UE)

  int64_t stream = 1;

  NetDeviceContainer enbDevs;

  enbDevs = lteHelper->InstallEnbDevice (enbNodes);

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

  NetDeviceContainer ueDevs;

  ueDevs = lteHelper->InstallUeDevice (ueNodes);

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

  // Connect to trace sources in UEs

//  Config::Connect ("/NodeList/*/DeviceList/*/LteEnbMac/DlScheduling",

//                   MakeCallback (&LteRrcConnEstablishmentTestCase::DlSchedulingCallback,

//                                 this));

//  Config::Connect ("/NodeList/*/DeviceList/*/LteEnbMac/UlScheduling",

//                   MakeCallback (&LteRrcConnEstablishmentTestCase::UlSchedulingCallback,

//                                 this));

//  Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/StateTransition",

//                   MakeCallback (&LteRrcConnEstablishmentTestCase::UeStateTransitionCallback,

//                                 this));

  Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/ConnectionEstablished",

                   MakeCallback (&LteRrcConnEstablishmentTestCase::ConnectionEstablishedCallback,

                                 this));

  Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/ConnectionTimeout",

                   MakeCallback (&LteRrcConnEstablishmentTestCase::ConnectionTimeoutCallback,

                                 this));

  // Connect to trace source in serving eNodeB

//  Config::Connect ("/NodeList/*/DeviceList/*/LteEnbRrc/UeMap/StateTransition",

//                   MakeCallback (&LteRrcConnEstablishmentTestCase::EnbStateTransitionCallback,

//                                 this));

  lteHelper->Attach (ueDevs, enbDevs.Get (0));

  // Activate an EPS bearer

  enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;

  EpsBearer bearer (q);

  lteHelper->ActivateDataRadioBearer (ueDevs, bearer);

  // Run simulation

  Simulator::Stop (MilliSeconds (150));

  Simulator::Run ();

  NS_LOG_INFO ("Simulation ends");

  // Verification

  Ptr<LteEnbNetDevice> servingEnb = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();

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

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

    {

      // verify UE state in UE RRC

      Ptr<LteUeNetDevice> ueDev = ueDevs.Get (i)->GetObject<LteUeNetDevice> ();

      NS_ASSERT (ueDev != 0);

      if (m_isConnectionEstablished)

        {

          // connection establishment was successful

          NS_TEST_ASSERT_MSG_EQ (ueDev->GetRrc ()->GetState (), LteUeRrc::CONNECTED_NORMALLY,

                                 "UE " << i << " is not at CONNECTED_NORMALLY state");

        }

      else

        {

          /*

           * T300 has expired, thus connection establishment was failed. The UE

           * should be back to Idle state.

           */

          NS_TEST_ASSERT_MSG_EQ (m_isConnectionTimeout, true,

                                 "Connection timeout should have occurred");

          NS_TEST_ASSERT_MSG_EQ (ueDev->GetRrc ()->GetState (), LteUeRrc::IDLE_CAMPED_NORMALLY,

                                 "UE " << i << " but it is not at IDLE_CAMPED_NORMALLY state");

        }

      // verify UE state in eNodeB RRC

      Ptr<UeManager> ueManager = enbRrc->GetUeManager (i + 1);

      NS_ASSERT (ueManager != 0);

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

      if (m_isConnectionEstablished)

        {

          /*

           * At this point, UE side's of connection has been established. But

           * several "failures" may follow after this point:

           * (1) failure in the RRC Connection Reconfiguration procedure (which

           *     immediately follows the RRC Connection Establishment procedure)

           * (2) eNodeB's failure in receiving RRC Connection Setup Complete

           *     message from the UE.

           * Those failure cases are outside the scope of this test case, so we

           * simply include them as the accepted cases.

           */

          bool isValidState =

            (state == UeManager::CONNECTED_NORMALLY) // successful establishment

              || (state == UeManager::CONNECTION_RECONFIGURATION) // failure (1)

              || (state == UeManager::CONNECTION_SETUP); // failure (2)

          NS_TEST_ASSERT_MSG_EQ (isValidState, true,

                                 "The context of UE " << i << " is invalid on eNodeB side");

        }

      else

        {

          /*

           * When T300 expires on the UE side, the corresponding UE's context on

           * the eNodeB side would stay indefinitely in CONNECTION_SETUP state.

           */

          NS_TEST_ASSERT_MSG_EQ (state, UeManager::CONNECTION_SETUP,

                                 "The context of UE " << i << " is not at CONNECTION_SETUP state");

        }

    }

  Simulator::Destroy ();

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

//void

//LteRrcConnEstablishmentTestCase::DlSchedulingCallback (

//  std::string context, uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,

//  uint8_t mcs1, uint16_t tbSize1, uint8_t mcs2, uint16_t tbSize2)

//{

//  NS_LOG_FUNCTION (this << frameNo << subframeNo << rnti

//                        << (uint16_t) mcs1 << tbSize1

//                        << (uint16_t) mcs2 << tbSize2);

//}

//void

//LteRrcConnEstablishmentTestCase::UlSchedulingCallback (

//  std::string context, uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,

//  uint8_t mcs, uint16_t tbSize)

//{

//  NS_LOG_FUNCTION (this << frameNo << subframeNo << rnti

//                        << (uint16_t) mcs << tbSize);

//}

//void

//LteRrcConnEstablishmentTestCase::UeStateTransitionCallback (

//  std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti,

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

//{

//  //NS_LOG_FUNCTION (this << imsi << cellId << rnti << oldState << newState);

//}

//void

//LteRrcConnEstablishmentTestCase::EnbStateTransitionCallback (

//  std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti,

//  UeManager::State oldState, UeManager::State newState)

//{

//  //NS_LOG_FUNCTION (this << imsi << cellId << rnti << oldState << newState);

//}

void

LteRrcConnEstablishmentTestCase::ConnectionEstablishedCallback (

  std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti)

{

  NS_LOG_FUNCTION (this << imsi << cellId);

  m_isConnectionEstablished = true;

}

void

LteRrcConnEstablishmentTestCase::ConnectionTimeoutCallback (

  std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti)

{

  NS_LOG_FUNCTION (this << imsi << cellId);

  m_isConnectionTimeout = true;

}

/**

 * \brief TODO

 *

 * \sa ns3::LteRrcConnEstablishmentTestCase

 */

class LteRrcConnEstablishmentTestSuite : public TestSuite

{

public:

  LteRrcConnEstablishmentTestSuite ();

};

LteRrcConnEstablishmentTestSuite::LteRrcConnEstablishmentTestSuite ()

  : TestSuite ("lte-rrc-conn-establishment", SYSTEM)

{

//  LogComponentEnable ("LteRrcConnEstablishmentTest", LOG_PREFIX_ALL);

//  LogComponentEnable ("LteRrcConnEstablishmentTest", LOG_FUNCTION);

//  LogComponentEnable ("LteRrcConnEstablishmentTest", LOG_INFO);

////  LogComponentEnable ("LteSpectrumPhy", LOG_PREFIX_ALL);

////  LogComponentEnable ("LteSpectrumPhy", LOG_DEBUG);

//  LogComponentEnable ("LteUeMac", LOG_PREFIX_ALL);

//  LogComponentEnable ("LteUeMac", LOG_INFO);

////  LogComponentEnable ("LteUeMac", LOG_LOGIC);

////  LogComponentEnable ("LteUeMac", LOG_DEBUG);

////  LogComponentEnable ("LteUeMac", LOG_FUNCTION);

////  LogComponentEnable ("LteRlcTm", LOG_PREFIX_ALL);

////  LogComponentEnable ("LteRlcTm", LOG_FUNCTION);

////  LogComponentEnable ("LteRlcTm", LOG_LOGIC);

////  LogComponentEnable ("LteRlcTm", LOG_WARN);

//  LogComponentEnable ("LteEnbRrc", LOG_PREFIX_ALL);

//  LogComponentEnable ("LteEnbRrc", LOG_INFO);

//  LogComponentEnable ("LteUeRrc", LOG_PREFIX_ALL);

//  LogComponentEnable ("LteUeRrc", LOG_INFO);

  // assuming T300 is 100 ms

  // RngRun 1: transmission failure in RRC Connection Setup message

  // RngRun 2: successful establishment, followed by successful reconfiguration

  // RngRun 3: successful establishment, followed by failed reconfiguration

  // RngRun 4: successful establishment, followed by successful reconfiguration

  // RngRun 5: transmission failure in RRC Connection Setup message

  // RngRun 6: transmission failure in RRC Connection Setup Complete message

  for (int64_t i = 3; i <= 6; i++)

    {

      AddTestCase (new LteRrcConnEstablishmentTestCase (1, 100, i),

                   TestCase::QUICK);

    }

}

static LteRrcConnEstablishmentTestSuite g_lteRrcConnEstablishmentTestSuite;

} // end of namespace ns3

        'test/test-lte-rrc-conn-establishment.cc',