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

/*

 * Copyright (c) 2011 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: Manuel Requena <manuel.requena@cttc.es>

 *         Nicola Baldo <nbaldo@cttc.es>

 *         Marco Miozzo <mmiozzo@cttc.es>

 *         Budiarto Herman <budiarto.herman@magister.fi>

 */

#include <ns3/simulator.h>

#include <ns3/log.h>

#include <ns3/callback.h>

#include <ns3/config.h>

#include <ns3/string.h>

#include <ns3/double.h>

#include <ns3/enum.h>

#include <ns3/boolean.h>

#include <ns3/mobility-helper.h>

#include <ns3/lte-helper.h>

#include <ns3/point-to-point-epc-helper.h>

#include <ns3/internet-stack-helper.h>

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

#include <ns3/ipv4-address-helper.h>

#include <ns3/ipv4-static-routing-helper.h>

#include <ns3/node-container.h>

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

#include <ns3/ipv4-interface-container.h>

#include <ns3/ff-mac-scheduler.h>

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

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

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

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

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

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

#include "lte-test-ue-measurements.h"

#include <ns3/lte-common.h>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("LteUeMeasurementsTest");

// ===== LTE-UE-MEASUREMENTS TEST SUITE ==================================== //

void

ReportUeMeasurementsCallback (LteUeMeasurementsTestCase *testcase,

                              std::string path, uint16_t rnti, uint16_t cellId,

                              double rsrp, double rsrq, bool servingCell)

{

  testcase->ReportUeMeasurements (rnti, cellId, rsrp, rsrq, servingCell);

}

void

RecvMeasurementReportCallback (LteUeMeasurementsTestCase *testcase,

                               std::string path, uint64_t imsi, uint16_t cellId,

                               uint16_t rnti, LteRrcSap::MeasurementReport meas)

{

  testcase->RecvMeasurementReport (imsi, cellId, rnti, meas);

}

/*

 * Test Suite

 */

LteUeMeasurementsTestSuite::LteUeMeasurementsTestSuite ()

  : TestSuite ("lte-ue-measurements", SYSTEM)

{

  AddTestCase (new LteUeMeasurementsTestCase ("d1=10, d2=10000",  10.000000, 10000.000000, -53.739702, -113.739702, -3.010305, -63.010305), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=20, d2=10000",  20.000000, 10000.000000, -59.760302, -113.739702, -3.010319, -56.989719), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=50, d2=10000",  50.000000, 10000.000000, -67.719102, -113.739702, -3.010421, -49.031021), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=100, d2=10000",  100.000000, 10000.000000, -73.739702, -113.739702, -3.010783, -43.010783), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=200, d2=10000",  200.000000, 10000.000000, -79.760302, -113.739702, -3.012232, -36.991632), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=100, d2=10000",  100.000000, 10000.000000, -73.739702, -113.739702, -3.010783, -43.010783), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=200, d2=10000",  200.000000, 10000.000000, -79.760302, -113.739702, -3.012232, -36.991632), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=500, d2=10000",  500.000000, 10000.000000, -87.719102, -113.739702, -3.022359, -29.042959), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=1000, d2=10000",  1000.000000, 10000.000000, -93.739702, -113.739702, -3.058336, -23.058336), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=2000, d2=10000",  2000.000000, 10000.000000, -99.760302, -113.739702, -3.199337, -17.178738), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=5000, d2=10000",  5000.000000, 10000.000000, -107.719102, -113.739702, -4.075793, -10.096393), TestCase::QUICK);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=10000, d2=10000",  10000.000000, 10000.000000, -113.739702, -113.739702, -6.257687, -6.257687), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=20000, d2=10000",  20000.000000, 10000.000000, -119.760302, -113.739702, -10.373365, -4.352765), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=50000, d2=10000",  50000.000000, 10000.000000, -127.719102, -113.739702, -17.605046, -3.625645), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=100000, d2=10000",  100000.000000, 10000.000000, -133.739702, -113.739702, -23.511071, -3.511071), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=200000, d2=10000",  200000.000000, 10000.000000, -139.760302, -113.739702, -29.502549, -3.481949), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=500000, d2=10000",  500000.000000, 10000.000000, -147.719102, -113.739702, -37.453160, -3.473760), TestCase::EXTENSIVE);

  AddTestCase (new LteUeMeasurementsTestCase ("d1=1000000, d2=10000",  1000000.000000, 10000.000000, -153.739702, -113.739702, -43.472589, -3.472589), TestCase::EXTENSIVE);

}

static LteUeMeasurementsTestSuite lteUeMeasurementsTestSuite;

/*

 * Test Case

 */

LteUeMeasurementsTestCase::LteUeMeasurementsTestCase (std::string name,

                                                      double d1, double d2,

                                                      double rsrpDbmUe1,

                                                      double rsrpDbmUe2,

                                                      double rsrqDbUe1,

                                                      double rsrqDbUe2)

  : TestCase (name),

    m_d1 (d1),

    m_d2 (d2),

    m_rsrpDbmUeServingCell (rsrpDbmUe1),

    m_rsrpDbmUeNeighborCell (rsrpDbmUe2),

    m_rsrqDbUeServingCell (rsrqDbUe1),

    m_rsrqDbUeNeighborCell (rsrqDbUe2)

{

  NS_LOG_INFO ("Test UE Measurements d1 = " << d1 << " m. and d2 = " << d2 << " m.");

}

LteUeMeasurementsTestCase::~LteUeMeasurementsTestCase ()

{

}

void

LteUeMeasurementsTestCase::DoRun (void)

{

  NS_LOG_INFO (this << " " << GetName ());

  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));

  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));

  Config::SetDefault ("ns3::LteAmc::AmcModel", EnumValue (LteAmc::PiroEW2010));

  Config::SetDefault ("ns3::LteAmc::Ber", DoubleValue (0.00005));

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

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

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

  //Disable Uplink Power Control

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

  // LogComponentEnable ("LteUeMeasurementsTest", LOG_LEVEL_ALL);

  // Create Nodes: eNodeB and UE

  NodeContainer enbNodes;

  NodeContainer ueNodes1;

  NodeContainer ueNodes2;

  enbNodes.Create (2);

  ueNodes1.Create (1);

  ueNodes2.Create (1);

  NodeContainer allNodes = NodeContainer (enbNodes, ueNodes1, ueNodes2);

  // the topology is the following:

  //         d2

  //  UE1-----------eNB2

  //   |             |

  // d1|             |d1

  //   |     d2      |

  //  eNB1----------UE2

  //

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

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

  positionAlloc->Add (Vector (m_d2, m_d1, 0.0)); // eNB2

  positionAlloc->Add (Vector (0.0, m_d1, 0.0));  // UE1

  positionAlloc->Add (Vector (m_d2, 0.0, 0.0));  // UE2

  MobilityHelper mobility;

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

  mobility.SetPositionAllocator (positionAlloc);

  mobility.Install (allNodes);

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

  NetDeviceContainer enbDevs;

  NetDeviceContainer ueDevs1;

  NetDeviceContainer ueDevs2;

  lteHelper->SetSchedulerType ("ns3::RrFfMacScheduler");

  lteHelper->SetSchedulerAttribute ("UlCqiFilter", EnumValue (FfMacScheduler::PUSCH_UL_CQI));

  enbDevs = lteHelper->InstallEnbDevice (enbNodes);

  ueDevs1 = lteHelper->InstallUeDevice (ueNodes1);

  ueDevs2 = lteHelper->InstallUeDevice (ueNodes2);

  // Attach UEs to eNodeBs

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

  lteHelper->Attach (ueDevs2, enbDevs.Get (1));

  // Activate an EPS bearer

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

  EpsBearer bearer (q);

  lteHelper->ActivateDataRadioBearer (ueDevs1, bearer);

  lteHelper->ActivateDataRadioBearer (ueDevs2, bearer);

  Config::Connect ("/NodeList/2/DeviceList/0/LteUePhy/ReportUeMeasurements",

                   MakeBoundCallback (&ReportUeMeasurementsCallback, this));

  Config::Connect ("/NodeList/0/DeviceList/0/LteEnbRrc/RecvMeasurementReport",

                   MakeBoundCallback (&RecvMeasurementReportCallback, this));

  Config::Connect ("/NodeList/3/DeviceList/0/LteUePhy/ReportUeMeasurements",

                   MakeBoundCallback (&ReportUeMeasurementsCallback, this));

  Config::Connect ("/NodeList/1/DeviceList/0/LteEnbRrc/RecvMeasurementReport",

                   MakeBoundCallback (&RecvMeasurementReportCallback, this));

  // need to allow for RRC connection establishment + SRS

  Simulator::Stop (Seconds (0.800));

  Simulator::Run ();

  Simulator::Destroy ();

}

void

LteUeMeasurementsTestCase::ReportUeMeasurements (uint16_t rnti, uint16_t cellId,

                                                 double rsrp, double rsrq,

                                                 bool servingCell)

{

  // need to allow for RRC connection establishment + CQI feedback reception + UE measurements filtering (200 ms)

  if (Simulator::Now () > MilliSeconds (400))

    {

      if (servingCell)

        {

          NS_LOG_DEBUG ("UE serving cellId " << cellId << " Rxed RSRP " << rsrp << " thr " << m_rsrpDbmUeServingCell << " RSRQ " << rsrq << " thr " << m_rsrqDbUeServingCell);

          NS_TEST_ASSERT_MSG_EQ_TOL (m_rsrpDbmUeServingCell, rsrp, 0.2, "Wrong RSRP UE 1");

          NS_TEST_ASSERT_MSG_EQ_TOL (m_rsrqDbUeServingCell, rsrq, 0.2, "Wrong RSRQ UE 1");

        }

      else

        {

          NS_LOG_DEBUG ("UE neighbor cellId " << cellId << " Rxed RSRP " << rsrp << " thr " << m_rsrpDbmUeNeighborCell << " RSRQ " << rsrq << " thr " << m_rsrqDbUeNeighborCell);

          NS_TEST_ASSERT_MSG_EQ_TOL (m_rsrpDbmUeNeighborCell, rsrp, 0.2, "Wrong RSRP UE 2");

          NS_TEST_ASSERT_MSG_EQ_TOL (m_rsrqDbUeNeighborCell, rsrq, 0.2, "Wrong RSRQ UE ");

        }

    }

}

void

LteUeMeasurementsTestCase::RecvMeasurementReport (uint64_t imsi, uint16_t cellId, uint16_t rnti,

                                                  LteRrcSap::MeasurementReport meas)

{

  // need to allow for RRC connection establishment + CQI feedback reception + UE measurements filtering (200 ms)

  if (Simulator::Now () > MilliSeconds (400))

    {

      if (cellId == imsi)

        {

          NS_LOG_DEBUG (this << "Serving Cell: received IMSI " << imsi << " CellId " << cellId << " RNTI " << rnti

                             << " thr " << (uint16_t) EutranMeasurementMapping::Dbm2RsrpRange (m_rsrpDbmUeServingCell)

                             << " RSRP " << (uint16_t) meas.measResults.rsrpResult

                             << " RSRQ " << (uint16_t)meas.measResults.rsrqResult

                             << " thr " << (uint16_t) EutranMeasurementMapping::Db2RsrqRange (m_rsrqDbUeServingCell));

          NS_TEST_ASSERT_MSG_EQ (meas.measResults.rsrpResult,

                                 EutranMeasurementMapping::Dbm2RsrpRange (m_rsrpDbmUeServingCell),

                                 "Wrong RSRP ");

          NS_TEST_ASSERT_MSG_EQ (meas.measResults.rsrqResult,

                                 EutranMeasurementMapping::Db2RsrqRange (m_rsrqDbUeServingCell),

                                 "Wrong RSRQ ");

        }

      else

        {

          NS_LOG_DEBUG (this << "Neighbor cell: received IMSI " << imsi << " CellId " << cellId << " RNTI " << rnti

                             << " thr " << (uint16_t) EutranMeasurementMapping::Dbm2RsrpRange (m_rsrpDbmUeNeighborCell)

                             << " RSRP " << (uint16_t) meas.measResults.rsrpResult

                             << " RSRQ " << (uint16_t)meas.measResults.rsrqResult

                             << " thr " << (uint16_t) EutranMeasurementMapping::Db2RsrqRange (m_rsrqDbUeNeighborCell));

          NS_TEST_ASSERT_MSG_EQ (meas.measResults.rsrpResult,

                                 EutranMeasurementMapping::Dbm2RsrpRange (m_rsrpDbmUeNeighborCell),

                                 "Wrong RSRP ");

          NS_TEST_ASSERT_MSG_EQ (meas.measResults.rsrqResult,

                                 EutranMeasurementMapping::Db2RsrqRange (m_rsrqDbUeNeighborCell),

                                 "Wrong RSRQ ");

        }

    }

}

// ===== LTE-UE-MEASUREMENTS-PIECEWISE-1 TEST SUITE ======================== //

/*

 * Overloaded operators, for the convenience of defining test cases

 */

std::vector<Time>&

operator<< (std::vector<Time>& v, const uint64_t& ms)

{

  /*

   * Prior attempt to use seconds as unit of choice resulted in precision lost.

   * Therefore milliseconds are used now instead.

   */

  v.push_back (MilliSeconds (ms) + UE_MEASUREMENT_REPORT_DELAY);

  return v;

}

std::vector<uint8_t>&

operator<< (std::vector<uint8_t>& v, const uint8_t& range)

{

  v.push_back (range);

  return v;

}

/*

 * Test Suite

 */

LteUeMeasurementsPiecewiseTestSuite1::LteUeMeasurementsPiecewiseTestSuite1 ()

  : TestSuite ("lte-ue-measurements-piecewise-1", SYSTEM)

{

  std::vector<Time> expectedTime;

  std::vector<uint8_t> expectedRsrp;

  // === Event A1 (serving cell becomes better than threshold) ===

  // With very low threshold

  LteRrcSap::ReportConfigEutra config;

  config.triggerType = LteRrcSap::ReportConfigEutra::EVENT;

  config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A1;

  config.threshold1.choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP;

  config.threshold1.range = 0;

  config.triggerQuantity = LteRrcSap::ReportConfigEutra::RSRP;

  config.reportInterval = LteRrcSap::ReportConfigEutra::MS120;

  expectedTime.clear ();

  expectedTime << 200 << 320 << 440 << 560 << 680 << 800 << 920 << 1040 << 1160 << 1280

               << 1400 << 1520 << 1640 << 1760 << 1880 << 2000 << 2120;

  expectedRsrp.clear ();

  expectedRsrp << 67 << 67 << 57 << 57 << 66 << 47 << 47 << 66 << 66 << 57

               << 51 << 51 << 47 << 47 << 51 << 57 << 57;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A1 with very low threshold",

                                                        config, expectedTime, expectedRsrp),

               TestCase::EXTENSIVE);

  // With normal threshold

  config.threshold1.range = 54;

  expectedTime.clear ();

  expectedTime << 200 << 320 << 440 << 560 << 680 << 1000 << 1120 << 1240 << 1360 << 2000

               << 2120;

  expectedRsrp.clear ();

  expectedRsrp << 67 << 67 << 57 << 57 << 66 << 66 << 66 << 57 << 57 << 57

               << 57;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A1 with normal threshold",

                                                        config, expectedTime, expectedRsrp),

               TestCase::EXTENSIVE);

  // With short time-to-trigger

  config.timeToTrigger = 64;

  expectedTime.clear ();

  expectedTime << 264 << 384 << 504 << 624 << 744 << 1064 << 1184 << 1304 << 1424 << 2064

               << 2184;

  expectedRsrp.clear ();

  expectedRsrp << 67 << 67 << 57 << 66 << 66 << 66 << 66 << 57 << 51 << 57

               << 57;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A1 with short time-to-trigger",

                                                        config, expectedTime, expectedRsrp),

               TestCase::QUICK);

  // With long time-to-trigger

  config.timeToTrigger = 128;

  expectedTime.clear ();

  expectedTime << 328 << 448 << 568 << 688 << 808 << 1128 << 1248 << 1368 << 1488 << 2128;

  expectedRsrp.clear ();

  expectedRsrp << 67 << 57 << 57 << 66 << 47 << 66 << 57 << 57 << 51 << 57;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A1 with long time-to-trigger",

                                                        config, expectedTime, expectedRsrp),

               TestCase::EXTENSIVE);

  // With super time-to-trigger

  config.timeToTrigger = 256;

  expectedTime.clear ();

  expectedTime << 456 << 576 << 696 << 816 << 936 << 1056 << 1176 << 1296 << 1416 << 1536;

  expectedRsrp.clear ();

  expectedRsrp << 57 << 57 << 66 << 47 << 47 << 66 << 66 << 57 << 51 << 51;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A1 with super time-to-trigger",

                                                        config, expectedTime, expectedRsrp),

               TestCase::EXTENSIVE);

  // With hysteresis

  config.hysteresis = 8;

  config.timeToTrigger = 0;

  expectedTime.clear ();

  expectedTime << 200 << 320 << 440 << 560 << 680 << 1000 << 1120 << 1240 << 1360 << 1480

               << 2200;

  expectedRsrp.clear ();

  expectedRsrp << 67 << 67 << 57 << 57 << 66 << 66 << 66 << 57 << 57 << 51

               << 67;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A1 with hysteresis",

                                                        config, expectedTime, expectedRsrp),

               TestCase::QUICK);

  // With very high threshold

  config.threshold1.range = 97;

  config.hysteresis = 0;

  expectedTime.clear ();

  expectedRsrp.clear ();

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A1 with very high threshold",

                                                        config, expectedTime, expectedRsrp),

               TestCase::TAKES_FOREVER);

  // === Event A2 (serving cell becomes worse than threshold) ===

  // With very low threshold

  config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A2;

  config.threshold1.range = 0;

  expectedTime.clear ();

  expectedRsrp.clear ();

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A2 with very low threshold",

                                                        config, expectedTime, expectedRsrp),

               TestCase::TAKES_FOREVER);

  // With normal threshold

  config.threshold1.range = 54;

  expectedTime.clear ();

  expectedTime << 800 << 920 << 1400 << 1520 << 1640 << 1760 << 1880;

  expectedRsrp.clear ();

  expectedRsrp << 47 << 47 << 51 << 51 << 47 << 47 << 51;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A2 with normal threshold",

                                                        config, expectedTime, expectedRsrp),

               TestCase::QUICK);

  // With short time-to-trigger

  config.timeToTrigger = 64;

  expectedTime.clear ();

  expectedTime << 864 << 984 << 1464 << 1584 << 1704 << 1824 << 1944;

  expectedRsrp.clear ();

  expectedRsrp << 47 << 47 << 51 << 51 << 47 << 51 << 51;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A2 with short time-to-trigger",

                                                        config, expectedTime, expectedRsrp),

               TestCase::EXTENSIVE);

  // With long time-to-trigger

  config.timeToTrigger = 128;

  expectedTime.clear ();

  expectedTime << 928 << 1048 << 1528 << 1648 << 1768 << 1888 << 2008;

  expectedRsrp.clear ();

  expectedRsrp << 47 << 66 << 51 << 47 << 47 << 51 << 57;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A2 with long time-to-trigger",

                                                        config, expectedTime, expectedRsrp),

               TestCase::TAKES_FOREVER);

  // With super time-to-trigger

  config.timeToTrigger = 256;

  expectedTime.clear ();

  expectedTime << 1656 << 1776 << 1896 << 2016 << 2136;

  expectedRsrp.clear ();

  expectedRsrp << 47 << 47 << 51 << 57 << 57;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A2 with super time-to-trigger",

                                                        config, expectedTime, expectedRsrp),

               TestCase::QUICK);

  // With hysteresis

  config.hysteresis = 8;

  config.timeToTrigger = 0;

  expectedTime.clear ();

  expectedTime << 800 << 920 << 1600 << 1720 << 1840 << 1960 << 2080;

  expectedRsrp.clear ();

  expectedRsrp << 47 << 47 << 47 << 47 << 51 << 51 << 57;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A2 with hysteresis",

                                                        config, expectedTime, expectedRsrp),

               TestCase::EXTENSIVE);

  // With very high threshold

  config.threshold1.range = 97;

  config.hysteresis = 0;

  expectedTime.clear ();

  expectedTime << 200 << 320 << 440 << 560 << 680 << 800 << 920 << 1040 << 1160 << 1280

               << 1400 << 1520 << 1640 << 1760 << 1880 << 2000 << 2120;

  expectedRsrp.clear ();

  expectedRsrp << 67 << 67 << 57 << 57 << 66 << 47 << 47 << 66 << 66 << 57

               << 51 << 51 << 47 << 47 << 51 << 57 << 57;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A2 with very high threshold",

                                                        config, expectedTime, expectedRsrp),

               TestCase::EXTENSIVE);

  /*

   * Event A3, A4, and A5 are not tested intensively here because they depend on

   * the existence of at least one neighbouring cell, which is not available in

   * this configuration. Piecewise configuration #2 includes a neighbouring

   * cell, hence more thorough tests on these events are performed there.

   */

  expectedTime.clear ();

  expectedRsrp.clear ();

  // === Event A3 (neighbour becomes offset better than PCell) ===

  config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A3;

  config.a3Offset = 0;

  AddTestCase (new LteUeMeasurementsPiecewiseTestCase1 ("Piecewise test case 1 - Event A3",

                                                        config, expectedTime, expectedRsrp),

               TestCase::EXTENSIVE);

  // === Event A4 (neighbour becomes better than threshold) ===

  config.eventId = LteRrcSap::ReportConfigEutra::EVENT_A4;

  config.threshold1.range = 54;