doc/html/simulator-test-suite_8cc_source.html

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

 /*

  * Copyright (c) 2005,2006 INRIA

  *

  * 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: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

  */

 #include "ns3/test.h"

 #include "ns3/simulator.h"

 #include "ns3/list-scheduler.h"

 #include "ns3/heap-scheduler.h"

 #include "ns3/map-scheduler.h"

 #include "ns3/calendar-scheduler.h"

 #include "ns3/priority-queue-scheduler.h"


 using namespace ns3;


 class SimulatorEventsTestCase : public TestCase

 {

 public:

   SimulatorEventsTestCase (ObjectFactory schedulerFactory);

   virtual void DoRun (void);

   void EventA (int value);

   void EventB (int value);

   void EventC (int value);

   void EventD (int value);

   void Eventfoo0 (void);


   uint64_t NowUs (void);

   void Destroy (void);

   bool m_a;

   bool m_b;

   bool m_c;

   bool m_d;

   bool m_destroy;

   EventId m_idC;

   EventId m_destroyId;

   ObjectFactory m_schedulerFactory;

 };


 SimulatorEventsTestCase::SimulatorEventsTestCase (ObjectFactory schedulerFactory)

   : TestCase ("Check that basic event handling is working with " +

               schedulerFactory.GetTypeId ().GetName ()),

     m_schedulerFactory (schedulerFactory)

 {}

 uint64_t

 SimulatorEventsTestCase::NowUs (void)

 {

   uint64_t ns = Now ().GetNanoSeconds ();

   return ns / 1000;

 }


 void

 SimulatorEventsTestCase::EventA ([[maybe_unused]] int a)

 {

   m_a = false;

 }


 void

 SimulatorEventsTestCase::EventB (int b)

 {

   if (b != 2 || NowUs () != 11)

     {

       m_b = false;

     }

   else

     {

       m_b = true;

     }

   Simulator::Remove (m_idC);

   Simulator::Schedule (MicroSeconds (10), &SimulatorEventsTestCase::EventD, this, 4);

 }


 void

 SimulatorEventsTestCase::EventC ([[maybe_unused]] int c)

 {

   m_c = false;

 }


 void

 SimulatorEventsTestCase::EventD (int d)

 {

   if (d != 4 || NowUs () != (11 + 10))

     {

       m_d = false;

     }

   else

     {

       m_d = true;

     }

 }


 void

 SimulatorEventsTestCase::Eventfoo0 (void)

 {}


 void

 SimulatorEventsTestCase::Destroy (void)

 {

   if (m_destroyId.IsExpired ())

     {

       m_destroy = true;

     }

 }

 void

 SimulatorEventsTestCase::DoRun (void)

 {

   m_a = true;

   m_b = false;

   m_c = true;

   m_d = false;


   Simulator::SetScheduler (m_schedulerFactory);


   EventId a = Simulator::Schedule (MicroSeconds (10), &SimulatorEventsTestCase::EventA, this, 1);

   Simulator::Schedule (MicroSeconds (11), &SimulatorEventsTestCase::EventB, this, 2);

   m_idC = Simulator::Schedule (MicroSeconds (12), &SimulatorEventsTestCase::EventC, this, 3);


   NS_TEST_EXPECT_MSG_EQ (!m_idC.IsExpired (), true, "");

   NS_TEST_EXPECT_MSG_EQ (!a.IsExpired (), true, "");

   Simulator::Cancel (a);

   NS_TEST_EXPECT_MSG_EQ (a.IsExpired (), true, "");

   Simulator::Run ();

   NS_TEST_EXPECT_MSG_EQ (m_a, true, "Event A did not run ?");

   NS_TEST_EXPECT_MSG_EQ (m_b, true, "Event B did not run ?");

   NS_TEST_EXPECT_MSG_EQ (m_c, true, "Event C did not run ?");

   NS_TEST_EXPECT_MSG_EQ (m_d, true, "Event D did not run ?");


   EventId anId = Simulator::ScheduleNow (&SimulatorEventsTestCase::Eventfoo0, this);

   EventId anotherId = anId;

   NS_TEST_EXPECT_MSG_EQ (!(anId.IsExpired () || anotherId.IsExpired ()), true, "Event should not have expired yet.");


   Simulator::Remove (anId);

   NS_TEST_EXPECT_MSG_EQ (anId.IsExpired (), true, "Event was removed: it is now expired");

   NS_TEST_EXPECT_MSG_EQ (anotherId.IsExpired (), true, "Event was removed: it is now expired");


   m_destroy = false;

   m_destroyId = Simulator::ScheduleDestroy (&SimulatorEventsTestCase::Destroy, this);

   NS_TEST_EXPECT_MSG_EQ (!m_destroyId.IsExpired (), true, "Event should not have expired yet");

   m_destroyId.Cancel ();

   NS_TEST_EXPECT_MSG_EQ (m_destroyId.IsExpired (), true, "Event was canceled: should have expired now");


   m_destroyId = Simulator::ScheduleDestroy (&SimulatorEventsTestCase::Destroy, this);

   NS_TEST_EXPECT_MSG_EQ (!m_destroyId.IsExpired (), true, "Event should not have expired yet");

   Simulator::Remove (m_destroyId);

   NS_TEST_EXPECT_MSG_EQ (m_destroyId.IsExpired (), true, "Event was canceled: should have expired now");


   m_destroyId = Simulator::ScheduleDestroy (&SimulatorEventsTestCase::Destroy, this);

   NS_TEST_EXPECT_MSG_EQ (!m_destroyId.IsExpired (), true, "Event should not have expired yet");


   Simulator::Run ();

   NS_TEST_EXPECT_MSG_EQ (!m_destroyId.IsExpired (), true, "Event should not have expired yet");

   NS_TEST_EXPECT_MSG_EQ (!m_destroy, true, "Event should not have run");


   Simulator::Destroy ();

   NS_TEST_EXPECT_MSG_EQ (m_destroyId.IsExpired (), true, "Event should have expired now");

   NS_TEST_EXPECT_MSG_EQ (m_destroy, true, "Event should have run");

 }


 class SimulatorTemplateTestCase : public TestCase

 {

 public:

   SimulatorTemplateTestCase ();

   void Ref (void) const {};

   void Unref (void) const {};

 private:

   virtual void DoRun (void);


   /* *NS_CHECK_STYLE_OFF* */

   void bar0 (void) {}

   void bar1 (int) {}

   void bar2 (int, int) {}

   void bar3 (int, int, int) {}

   void bar4 (int, int, int, int) {}

   void bar5 (int, int, int, int, int) {}

   void baz1 (int &) {}

   void baz2 (int &, int &) {}

   void baz3 (int &, int &, int &) {}

   void baz4 (int &, int &, int &, int &) {}

   void baz5 (int &, int &, int &, int &, int &) {}

   void cbaz1 (const int &) {}

   void cbaz2 (const int &, const int &) {}

   void cbaz3 (const int &, const int &, const int &) {}

   void cbaz4 (const int &, const int &, const int &, const int &) {}

   void cbaz5 (const int &, const int &, const int &, const int &, const int &) {}


   void bar0c (void) const {}

   void bar1c (int) const {}

   void bar2c (int, int) const {}

   void bar3c (int, int, int) const {}

   void bar4c (int, int, int, int) const {}

   void bar5c (int, int, int, int, int) const {}

   void baz1c (int &) const {}

   void baz2c (int &, int &) const {}

   void baz3c (int &, int &, int &) const {}

   void baz4c (int &, int &, int &, int &) const {}

   void baz5c (int &, int &, int &, int &, int &) const {}

   void cbaz1c (const int &) const {}

   void cbaz2c (const int &, const int &) const {}

   void cbaz3c (const int &, const int &, const int &) const {}

   void cbaz4c (const int &, const int &, const int &, const int &) const {}

   void cbaz5c (const int &, const int &, const int &, const int &, const int &) const {}

   /* *NS_CHECK_STYLE_ON* */


 };


 static void foo0 (void)

 {}

 static void foo1 (int)

 {}

 static void foo2 (int, int)

 {}

 static void foo3 (int, int, int)

 {}

 static void foo4 (int, int, int, int)

 {}

 static void foo5 (int, int, int, int, int)

 {}

 static void ber1 (int &)

 {}

 static void ber2 (int &, int &)

 {}

 static void ber3 (int &, int &, int &)

 {}

 static void ber4 (int &, int &, int &, int &)

 {}

 static void ber5 (int &, int &, int &, int &, int &)

 {}

 static void cber1 (const int &)

 {}

 static void cber2 (const int &, const int &)

 {}

 static void cber3 (const int &, const int &, const int &)

 {}

 static void cber4 (const int &, const int &, const int &, const int &)

 {}

 static void cber5 (const int &, const int &, const int &, const int &, const int &)

 {}

 SimulatorTemplateTestCase::SimulatorTemplateTestCase ()

   : TestCase ("Check that all templates are instantiated correctly. This is a compilation test, it cannot fail at runtime.")

 {}

 void

 SimulatorTemplateTestCase::DoRun (void)

 {

   // Test schedule of const methods

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar0c, this);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar1c, this, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar2c, this, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar3c, this, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar4c, this, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar5c, this, 0, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz1c, this, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz2c, this, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz3c, this, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz4c, this, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz5c, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar0c, this);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar1c, this, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar2c, this, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar3c, this, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar4c, this, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar5c, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz1c, this, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz2c, this, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz3c, this, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz4c, this, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz5c, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar0c, this);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar1c, this, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar2c, this, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar3c, this, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar4c, this, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar5c, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz1c, this, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz2c, this, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz3c, this, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz4c, this, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz5c, this, 0, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz1c, this, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz2c, this, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz3c, this, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz4c, this, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz5c, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz1c, this, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz2c, this, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz3c, this, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz4c, this, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz5c, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz1c, this, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz2c, this, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz3c, this, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz4c, this, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz5c, this, 0, 0, 0, 0, 0);


   // Test of schedule const methods with Ptr<> pointers

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar0c, Ptr<const SimulatorTemplateTestCase> (this));

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar1c, Ptr<const SimulatorTemplateTestCase> (this), 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar2c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar3c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar4c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar5c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar0c, Ptr<const SimulatorTemplateTestCase> (this));

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar1c, Ptr<const SimulatorTemplateTestCase> (this), 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar2c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar3c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar4c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar5c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar0c, Ptr<const SimulatorTemplateTestCase> (this));

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar1c, Ptr<const SimulatorTemplateTestCase> (this), 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar2c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar3c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar4c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar5c, Ptr<const SimulatorTemplateTestCase> (this), 0, 0, 0, 0, 0);


   // Test schedule of raw functions

   Simulator::Schedule (Seconds (0.0), &foo0);

   Simulator::Schedule (Seconds (0.0), &foo1, 0);

   Simulator::Schedule (Seconds (0.0), &foo2, 0, 0);

   Simulator::Schedule (Seconds (0.0), &foo3, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &foo4, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &foo5, 0, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &cber1, 0);

   Simulator::Schedule (Seconds (0.0), &cber2, 0, 0);

   Simulator::Schedule (Seconds (0.0), &cber3, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &cber4, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &cber5, 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&foo0);

   Simulator::ScheduleNow (&foo1, 0);

   Simulator::ScheduleNow (&foo2, 0, 0);

   Simulator::ScheduleNow (&foo3, 0, 0, 0);

   Simulator::ScheduleNow (&foo4, 0, 0, 0, 0);

   Simulator::ScheduleNow (&foo5, 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&cber1, 0);

   Simulator::ScheduleNow (&cber2, 0, 0);

   Simulator::ScheduleNow (&cber3, 0, 0, 0);

   Simulator::ScheduleNow (&cber4, 0, 0, 0, 0);

   Simulator::ScheduleNow (&cber5, 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&foo0);

   Simulator::ScheduleDestroy (&foo1, 0);

   Simulator::ScheduleDestroy (&foo2, 0, 0);

   Simulator::ScheduleDestroy (&foo3, 0, 0, 0);

   Simulator::ScheduleDestroy (&foo4, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&foo5, 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&cber1, 0);

   Simulator::ScheduleDestroy (&cber2, 0, 0);

   Simulator::ScheduleDestroy (&cber3, 0, 0, 0);

   Simulator::ScheduleDestroy (&cber4, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&cber5, 0, 0, 0, 0, 0);


   // Test schedule of normal member methods

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar0, this);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar1, this, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar2, this, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar3, this, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar4, this, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar5, this, 0, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz1, this, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz2, this, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz3, this, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz4, this, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::cbaz5, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar0, this);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar1, this, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar2, this, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar3, this, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar4, this, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar5, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz1, this, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz2, this, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz3, this, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz4, this, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::cbaz5, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar0, this);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar1, this, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar2, this, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar3, this, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar4, this, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar5, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz1, this, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz2, this, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz3, this, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz4, this, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::cbaz5, this, 0, 0, 0, 0, 0);


   // test schedule of normal methods with Ptr<> pointers

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar0, Ptr<SimulatorTemplateTestCase> (this));

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar1, Ptr<SimulatorTemplateTestCase> (this), 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar2, Ptr<SimulatorTemplateTestCase> (this), 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar3, Ptr<SimulatorTemplateTestCase> (this), 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar4, Ptr<SimulatorTemplateTestCase> (this), 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::bar5, Ptr<SimulatorTemplateTestCase> (this), 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar0, Ptr<SimulatorTemplateTestCase> (this));

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar1, Ptr<SimulatorTemplateTestCase> (this), 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar2, Ptr<SimulatorTemplateTestCase> (this), 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar3, Ptr<SimulatorTemplateTestCase> (this), 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar4, Ptr<SimulatorTemplateTestCase> (this), 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::bar5, Ptr<SimulatorTemplateTestCase> (this), 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar0, Ptr<SimulatorTemplateTestCase> (this));

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar1, Ptr<SimulatorTemplateTestCase> (this), 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar2, Ptr<SimulatorTemplateTestCase> (this), 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar3, Ptr<SimulatorTemplateTestCase> (this), 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar4, Ptr<SimulatorTemplateTestCase> (this), 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::bar5, Ptr<SimulatorTemplateTestCase> (this), 0, 0, 0, 0, 0);


   // the code below does not compile, as expected.

   //Simulator::Schedule (Seconds (0.0), &cber1, 0.0);


   // This code appears to be duplicate test code.

   Simulator::Schedule (Seconds (0.0), &ber1, 0);

   Simulator::Schedule (Seconds (0.0), &ber2, 0, 0);

   Simulator::Schedule (Seconds (0.0), &ber3, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &ber4, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &ber5, 0, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz1, this, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz2, this, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz3, this, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz4, this, 0, 0, 0, 0);

   Simulator::Schedule (Seconds (0.0), &SimulatorTemplateTestCase::baz5, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&ber1, 0);

   Simulator::ScheduleNow (&ber2, 0, 0);

   Simulator::ScheduleNow (&ber3, 0, 0, 0);

   Simulator::ScheduleNow (&ber4, 0, 0, 0, 0);

   Simulator::ScheduleNow (&ber5, 0, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz1, this, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz2, this, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz3, this, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz4, this, 0, 0, 0, 0);

   Simulator::ScheduleNow (&SimulatorTemplateTestCase::baz5, this, 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&ber1, 0);

   Simulator::ScheduleDestroy (&ber2, 0, 0);

   Simulator::ScheduleDestroy (&ber3, 0, 0, 0);

   Simulator::ScheduleDestroy (&ber4, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&ber5, 0, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz1, this, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz2, this, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz3, this, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz4, this, 0, 0, 0, 0);

   Simulator::ScheduleDestroy (&SimulatorTemplateTestCase::baz5, this, 0, 0, 0, 0, 0);


   Simulator::Run ();

   Simulator::Destroy ();

 }


 class SimulatorTestSuite : public TestSuite

 {

 public:

   SimulatorTestSuite ()

     : TestSuite ("simulator")

   {

     ObjectFactory factory;

     factory.SetTypeId (ListScheduler::GetTypeId ());


     AddTestCase (new SimulatorEventsTestCase (factory), TestCase::QUICK);

     factory.SetTypeId (MapScheduler::GetTypeId ());

     AddTestCase (new SimulatorEventsTestCase (factory), TestCase::QUICK);

     factory.SetTypeId (HeapScheduler::GetTypeId ());

     AddTestCase (new SimulatorEventsTestCase (factory), TestCase::QUICK);

     factory.SetTypeId (CalendarScheduler::GetTypeId ());

     AddTestCase (new SimulatorEventsTestCase (factory), TestCase::QUICK);

     factory.SetTypeId (PriorityQueueScheduler::GetTypeId ());

     AddTestCase (new SimulatorEventsTestCase (factory), TestCase::QUICK);

   }

 };


 static SimulatorTestSuite g_simulatorTestSuite;

SimulatorEventsTestCase
Check that basic event handling is working with different Simulator implementations.
Definition: simulator-test-suite.cc:47

SimulatorEventsTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: simulator-test-suite.cc:161

SimulatorEventsTestCase::EventD
void EventD(int value)
Test Event.
Definition: simulator-test-suite.cc:136

SimulatorEventsTestCase::m_idC
EventId m_idC
Event C.
Definition: simulator-test-suite.cc:91

SimulatorEventsTestCase::EventC
void EventC(int value)
Test Event.
Definition: simulator-test-suite.cc:130

SimulatorEventsTestCase::m_c
bool m_c
Checks that events are properly handled.
Definition: simulator-test-suite.cc:86

SimulatorEventsTestCase::SimulatorEventsTestCase
SimulatorEventsTestCase(ObjectFactory schedulerFactory)
Constructor.
Definition: simulator-test-suite.cc:96

SimulatorEventsTestCase::NowUs
uint64_t NowUs(void)
Get the simulator time.
Definition: simulator-test-suite.cc:102

SimulatorEventsTestCase::m_a
bool m_a
Checks that events are properly handled.
Definition: simulator-test-suite.cc:84

SimulatorEventsTestCase::m_destroy
bool m_destroy
Checks that events are properly handled.
Definition: simulator-test-suite.cc:88

SimulatorEventsTestCase::m_b
bool m_b
Checks that events are properly handled.
Definition: simulator-test-suite.cc:85

SimulatorEventsTestCase::Eventfoo0
void Eventfoo0(void)
Test Event.
Definition: simulator-test-suite.cc:149

SimulatorEventsTestCase::EventB
void EventB(int value)
Test Event.
Definition: simulator-test-suite.cc:115

SimulatorEventsTestCase::m_schedulerFactory
ObjectFactory m_schedulerFactory
Scheduler factory.
Definition: simulator-test-suite.cc:93

SimulatorEventsTestCase::m_destroyId
EventId m_destroyId
Event to check event lifetime.
Definition: simulator-test-suite.cc:92

SimulatorEventsTestCase::Destroy
void Destroy(void)
Checks that the events has been detroyed.
Definition: simulator-test-suite.cc:153

SimulatorEventsTestCase::EventA
void EventA(int value)
Test Event.
Definition: simulator-test-suite.cc:109

SimulatorEventsTestCase::m_d
bool m_d
Checks that events are properly handled.
Definition: simulator-test-suite.cc:87

SimulatorTemplateTestCase
Check that all templates are instantiated correctly.
Definition: simulator-test-suite.cc:224

SimulatorTemplateTestCase::bar2
void bar2(int, int)
Function used for scheduling.
Definition: simulator-test-suite.cc:247

SimulatorTemplateTestCase::bar4
void bar4(int, int, int, int)
Function used for scheduling.
Definition: simulator-test-suite.cc:249

SimulatorTemplateTestCase::bar1c
void bar1c(int) const
Function used for scheduling.
Definition: simulator-test-suite.cc:263

SimulatorTemplateTestCase::cbaz2
void cbaz2(const int &, const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:257

SimulatorTemplateTestCase::Ref
void Ref(void) const
Ref and Unref - only here for testing of Ptr<>
Definition: simulator-test-suite.cc:232

SimulatorTemplateTestCase::baz5c
void baz5c(int &, int &, int &, int &, int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:272

SimulatorTemplateTestCase::baz1
void baz1(int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:251

SimulatorTemplateTestCase::Unref
void Unref(void) const
Ref and Unref - only here for testing of Ptr<>
Definition: simulator-test-suite.cc:233

SimulatorTemplateTestCase::cbaz4c
void cbaz4c(const int &, const int &, const int &, const int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:276

SimulatorTemplateTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: simulator-test-suite.cc:326

SimulatorTemplateTestCase::baz3c
void baz3c(int &, int &, int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:270

SimulatorTemplateTestCase::baz4c
void baz4c(int &, int &, int &, int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:271

SimulatorTemplateTestCase::cbaz2c
void cbaz2c(const int &, const int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:274

SimulatorTemplateTestCase::baz4
void baz4(int &, int &, int &, int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:254

SimulatorTemplateTestCase::baz1c
void baz1c(int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:268

SimulatorTemplateTestCase::cbaz5c
void cbaz5c(const int &, const int &, const int &, const int &, const int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:277

SimulatorTemplateTestCase::SimulatorTemplateTestCase
SimulatorTemplateTestCase()
Definition: simulator-test-suite.cc:322

SimulatorTemplateTestCase::cbaz5
void cbaz5(const int &, const int &, const int &, const int &, const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:260

SimulatorTemplateTestCase::bar5
void bar5(int, int, int, int, int)
Function used for scheduling.
Definition: simulator-test-suite.cc:250

SimulatorTemplateTestCase::baz2c
void baz2c(int &, int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:269

SimulatorTemplateTestCase::baz5
void baz5(int &, int &, int &, int &, int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:255

SimulatorTemplateTestCase::bar0
void bar0(void)
Function used for scheduling.
Definition: simulator-test-suite.cc:245

SimulatorTemplateTestCase::bar0c
void bar0c(void) const
Function used for scheduling.
Definition: simulator-test-suite.cc:262

SimulatorTemplateTestCase::bar1
void bar1(int)
Function used for scheduling.
Definition: simulator-test-suite.cc:246

SimulatorTemplateTestCase::cbaz1
void cbaz1(const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:256

SimulatorTemplateTestCase::cbaz3
void cbaz3(const int &, const int &, const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:258

SimulatorTemplateTestCase::bar4c
void bar4c(int, int, int, int) const
Function used for scheduling.
Definition: simulator-test-suite.cc:266

SimulatorTemplateTestCase::bar3c
void bar3c(int, int, int) const
Function used for scheduling.
Definition: simulator-test-suite.cc:265

SimulatorTemplateTestCase::cbaz3c
void cbaz3c(const int &, const int &, const int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:275

SimulatorTemplateTestCase::cbaz1c
void cbaz1c(const int &) const
Function used for scheduling.
Definition: simulator-test-suite.cc:273

SimulatorTemplateTestCase::cbaz4
void cbaz4(const int &, const int &, const int &, const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:259

SimulatorTemplateTestCase::baz2
void baz2(int &, int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:252

SimulatorTemplateTestCase::bar5c
void bar5c(int, int, int, int, int) const
Function used for scheduling.
Definition: simulator-test-suite.cc:267

SimulatorTemplateTestCase::bar2c
void bar2c(int, int) const
Function used for scheduling.
Definition: simulator-test-suite.cc:264

SimulatorTemplateTestCase::bar3
void bar3(int, int, int)
Function used for scheduling.
Definition: simulator-test-suite.cc:248

SimulatorTemplateTestCase::baz3
void baz3(int &, int &, int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:253

SimulatorTestSuite
The simulator Test Suite.
Definition: simulator-test-suite.cc:540

SimulatorTestSuite::SimulatorTestSuite
SimulatorTestSuite()
Definition: simulator-test-suite.cc:542

ns3::EventId
An identifier for simulation events.
Definition: event-id.h:54

ns3::EventId::Cancel
void Cancel(void)
This method is syntactic sugar for the ns3::Simulator::Cancel method.
Definition: event-id.cc:53

ns3::EventId::IsExpired
bool IsExpired(void) const
This method is syntactic sugar for the ns3::Simulator::IsExpired method.
Definition: event-id.cc:65

ns3::ObjectFactory
Instantiate subclasses of ns3::Object.
Definition: object-factory.h:48

ns3::ObjectFactory::SetTypeId
void SetTypeId(TypeId tid)
Set the TypeId of the Objects to be created by this factory.
Definition: object-factory.cc:40

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

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

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

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

ns3::Time::GetNanoSeconds
int64_t GetNanoSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:391

ns3::Now
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:287

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

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

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

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

ber5
static void ber5(int &, int &, int &, int &, int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:308

foo3
static void foo3(int, int, int)
Function used for scheduling.
Definition: simulator-test-suite.cc:294

ber4
static void ber4(int &, int &, int &, int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:306

cber5
static void cber5(const int &, const int &, const int &, const int &, const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:318

cber1
static void cber1(const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:310

ber3
static void ber3(int &, int &, int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:304

g_simulatorTestSuite
static SimulatorTestSuite g_simulatorTestSuite
Static variable for test initialization.
Definition: simulator-test-suite.cc:560

cber3
static void cber3(const int &, const int &, const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:314

foo4
static void foo4(int, int, int, int)
Function used for scheduling.
Definition: simulator-test-suite.cc:296

foo2
static void foo2(int, int)
Function used for scheduling.
Definition: simulator-test-suite.cc:292

cber2
static void cber2(const int &, const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:312

cber4
static void cber4(const int &, const int &, const int &, const int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:316

ber1
static void ber1(int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:300

foo5
static void foo5(int, int, int, int, int)
Function used for scheduling.
Definition: simulator-test-suite.cc:298

foo1
static void foo1(int)
Function used for scheduling.
Definition: simulator-test-suite.cc:290

ber2
static void ber2(int &, int &)
Function used for scheduling.
Definition: simulator-test-suite.cc:302

foo0
static void foo0(void)
Function used for scheduling.
Definition: simulator-test-suite.cc:288