/* -*- 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/core-config.h"

 #include "simulator.h"

 #include "simulator-impl.h"

 #include "default-simulator-impl.h"

 #ifdef HAVE_PTHREAD_H

 # include "realtime-simulator-impl.h"

 #endif

 #include "scheduler.h"

 #include "map-scheduler.h"

 #include "event-impl.h"

 #include "ns3/ptr.h"

 #include "ns3/string.h"

 #include "ns3/object-factory.h"

 #include "ns3/global-value.h"

 #include "ns3/assert.h"

 #include "ns3/log.h"

 #include <math.h>

 #include <fstream>

 #include <list>

 #include <vector>

 #include <iostream>

 NS_LOG_COMPONENT_DEFINE ("Simulator");

 namespace ns3 {

 GlobalValue g_simTypeImpl = GlobalValue ("SimulatorImplementationType", 

   "The object class to use as the simulator implementation",

   StringValue ("ns3::DefaultSimulatorImpl"),

   MakeStringChecker ());

 GlobalValue g_schedTypeImpl = GlobalValue ("SchedulerType", 

   "The object class to use as the scheduler implementation",

   TypeIdValue (MapScheduler::GetTypeId ()),

   MakeTypeIdChecker ());

 #ifdef NS3_LOG_ENABLE

 //

 // Note:  Calls that take TimePrinter as a parameter are defined as nothing

 // in the logging module if NS3_LOG_ENABLE is not defined.

 // 

 static void

 TimePrinter (std::ostream &os)

 {

   os << Simulator::Now ().GetSeconds () << "s";

 }

 #endif /* NS3_LOG_ENABLE */

 static Ptr<SimulatorImpl> *PeekImpl (void)

 {

   static Ptr<SimulatorImpl> impl = 0;

   return &impl;

 }

 static SimulatorImpl * GetImpl (void)

 {

   Ptr<SimulatorImpl> &impl = *PeekImpl ();

   /* Please, don't include any calls to logging macros in this function

    * or pay the price, that is, stack explosions.

    */

   if (impl == 0) 

     {

       {

         ObjectFactory factory;

         StringValue s;

         g_simTypeImpl.GetValue (s);

         factory.SetTypeId (s.Get ());

         impl = factory.Create<SimulatorImpl> ();

       }

       {

         ObjectFactory factory;

         StringValue s;

         g_schedTypeImpl.GetValue (s);

         factory.SetTypeId (s.Get ());

         impl->SetScheduler (factory);

       }

 //

 // Note: we call LogSetTimePrinter _after_ creating the implementation

 // object because the act of creation can trigger calls to the logging 

 // framework which would call the TimePrinter function which would call 

 // Simulator::Now which would call Simulator::GetImpl, and, thus, get us 

 // in an infinite recursion until the stack explodes.

 //

       LogSetTimePrinter (&TimePrinter);

     }

   return PeekPointer (impl);

 }

 void

 Simulator::Destroy (void)

 {

   NS_LOG_FUNCTION_NOARGS ();

   Ptr<SimulatorImpl> &impl = *PeekImpl (); 

   if (impl == 0)

     {

       return;

     }

   /* Note: we have to call LogSetTimePrinter (0) below because if we do not do

    * this, and restart a simulation after this call to Destroy, (which is 

    * legal), Simulator::GetImpl will trigger again an infinite recursion until

    * the stack explodes.

    */

   LogSetTimePrinter (0);

   impl->Destroy ();

   impl = 0;

 }

 void

 Simulator::SetScheduler (ObjectFactory schedulerFactory)

 {

   NS_LOG_FUNCTION (schedulerFactory);

   GetImpl ()->SetScheduler (schedulerFactory);

 }

 bool 

 Simulator::IsFinished (void)

 {

   NS_LOG_FUNCTION_NOARGS ();

   return GetImpl ()->IsFinished ();

 }

 Time

 Simulator::Next (void)

 {

   NS_LOG_FUNCTION_NOARGS ();

   return GetImpl ()->Next ();

 }

 void 

 Simulator::Run (void)

 {

   NS_LOG_FUNCTION_NOARGS ();

   GetImpl ()->Run ();

 }

 void 

 Simulator::RunOneEvent (void)

 {

   NS_LOG_FUNCTION_NOARGS ();

   GetImpl ()->RunOneEvent ();

 }

 void 

 Simulator::Stop (void)

 {

   NS_LOG_LOGIC ("stop");

   GetImpl ()->Stop ();

 }

 void 

 Simulator::Stop (Time const &time)

 {

   NS_LOG_FUNCTION (time);

   Simulator::Schedule (time, &Simulator::Stop);

 }

 Time

 Simulator::Now (void)

 {

   /* Please, don't include any calls to logging macros in this function

    * or pay the price, that is, stack explosions.

    */

   return GetImpl ()->Now ();

 }

 Time

 Simulator::GetDelayLeft (const EventId &id)

 {

   NS_LOG_FUNCTION (&id);

   return GetImpl ()->GetDelayLeft (id);

 }

 EventId

 Simulator::Schedule (Time const &time, const Ptr<EventImpl> &ev)

 {

   NS_LOG_FUNCTION (time << ev);

   return DoSchedule (time, GetPointer (ev));

 }

 EventId

 Simulator::ScheduleNow (const Ptr<EventImpl> &ev)

 {

   NS_LOG_FUNCTION (ev);

   return DoScheduleNow (GetPointer (ev));

 }

 EventId

 Simulator::ScheduleDestroy (const Ptr<EventImpl> &ev)

 {

   NS_LOG_FUNCTION (ev);

   return DoScheduleDestroy (GetPointer (ev));

 }

 EventId 

 Simulator::DoSchedule (Time const &time, EventImpl *impl)

 {

   return GetImpl ()->Schedule (time, impl);

 }

 EventId 

 Simulator::DoScheduleNow (EventImpl *impl)

 {

   return GetImpl ()->ScheduleNow (impl);

 }

 EventId 

 Simulator::DoScheduleDestroy (EventImpl *impl)

 {

   return GetImpl ()->ScheduleDestroy (impl);

 }

 EventId

 Simulator::Schedule (Time const &time, void (*f) (void))

 {

   NS_LOG_FUNCTION (time << f);

   return DoSchedule (time, MakeEvent (f));

 }

 EventId

 Simulator::ScheduleNow (void (*f) (void))

 {

   NS_LOG_FUNCTION (f);

   return DoScheduleNow (MakeEvent (f));

 }

 EventId

 Simulator::ScheduleDestroy (void (*f) (void))

 {

   NS_LOG_FUNCTION (f);

   return DoScheduleDestroy (MakeEvent (f));

 }

 void

 Simulator::Remove (const EventId &ev)

 {

   NS_LOG_FUNCTION (&ev);

   return GetImpl ()->Remove (ev);

 }

 void

 Simulator::Cancel (const EventId &ev)

 {

   NS_LOG_FUNCTION (&ev);

   return GetImpl ()->Cancel (ev);

 }

 bool 

 Simulator::IsExpired (const EventId &id)

 {

   NS_LOG_FUNCTION (&id);

   return GetImpl ()->IsExpired (id);

 }

 Time Now (void)

 {

   NS_LOG_FUNCTION_NOARGS ();

   return Time (Simulator::Now ());

 }

 Time 

 Simulator::GetMaximumSimulationTime (void)

 {

   NS_LOG_FUNCTION_NOARGS ();

   return GetImpl ()->GetMaximumSimulationTime ();

 }

 void

 Simulator::SetImplementation (Ptr<SimulatorImpl> impl)

 {

   if (*PeekImpl () != 0)

     {

       NS_FATAL_ERROR ("It is not possible to set the implementation after calling any Simulator:: function. Call Simulator::SetImplementation earlier or after Simulator::Destroy.");

     }

   *PeekImpl () = impl;

   // Set the default scheduler

   ObjectFactory factory;

   StringValue s;

   g_schedTypeImpl.GetValue (s);

   factory.SetTypeId (s.Get ());

   impl->SetScheduler (factory);

 //

 // Note: we call LogSetTimePrinter _after_ creating the implementation

 // object because the act of creation can trigger calls to the logging 

 // framework which would call the TimePrinter function which would call 

 // Simulator::Now which would call Simulator::GetImpl, and, thus, get us 

 // in an infinite recursion until the stack explodes.

 //

   LogSetTimePrinter (&TimePrinter);

 }

 Ptr<SimulatorImpl>

 Simulator::GetImplementation (void)

 {

   return GetImpl ();

 }

 } // namespace ns3

 #include "ns3/test.h"

 #include "list-scheduler.h"

 #include "heap-scheduler.h"

 #include "map-scheduler.h"

 #include "calendar-scheduler.h"

 #include "ns2-calendar-scheduler.h"

 namespace ns3 {

 class SimulatorEventsTestCase : public TestCase

 {

 public:

   SimulatorEventsTestCase (ObjectFactory schedulerFactory);

   virtual bool DoRun (void);

   void A (int a);

   void B (int b);

   void C (int c);

   void D (int d);

   void foo0 (void);

   uint64_t NowUs (void);

   void destroy(void);

   bool m_b;

   bool m_a;

   bool m_c;

   bool m_d;

   EventId m_idC;

   bool m_destroy;

   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::A (int a)

 {

   m_a = false;

 }

 void

 SimulatorEventsTestCase::B (int b)

 {

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

     {

       m_b = false;

     } 

   else 

     {

       m_b = true;

     }

   Simulator::Remove (m_idC);

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

 }

 void

 SimulatorEventsTestCase::C (int c)

 {

   m_c = false;

 }

 void

 SimulatorEventsTestCase::D (int d)

 {

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

     {

       m_d = false;

     } 

   else 

     {

       m_d = true;

     }

 }

 void

 SimulatorEventsTestCase::foo0(void)

 {}

 void

 SimulatorEventsTestCase::destroy (void)

 {

   if (m_destroyId.IsExpired ())

     {

       m_destroy = true; 

     }

 }

 bool 

 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::A, this, 1);

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

   m_idC = Simulator::Schedule (MicroSeconds (12), &SimulatorEventsTestCase::C, 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::foo0, 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");

   return false;

 }

 class SimulatorTemplateTestCase : public TestCase

 {

 public:

   SimulatorTemplateTestCase ();

   // only here for testing of Ptr<>

   void Ref (void) const {}

   void Unref (void) const {}

 private:

   virtual bool DoRun (void);

   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 {}

 };

 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 instanciated correctly. This is a compilation test, it cannot fail at runtime.")

 {}

 bool 

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

   return false;

 }

 class SimulatorTestSuite : public TestSuite

 {

 public:

   SimulatorTestSuite ()

     : TestSuite ("simulator")

   {

     ObjectFactory factory;

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

     AddTestCase (new SimulatorEventsTestCase (factory));

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

     AddTestCase (new SimulatorEventsTestCase (factory));

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

     AddTestCase (new SimulatorEventsTestCase (factory));

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

     AddTestCase (new SimulatorEventsTestCase (factory));

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

     AddTestCase (new SimulatorEventsTestCase (factory));

   }

 } g_simulatorTestSuite;

 } // namespace ns3