Attachment #1551 for bug #954

View | Details | Raw Unified | Return to bug 954
Collapse All | Expand All




``Debugging`` book and then select the ``Logging`` page.

You should now be looking at the Doxygen documentation for the Logging module.
In the list of ``#define's at the top of the page you will see the entry
for ``NS_LOG_COMPONENT_DEFINE``.  Before jumping in, it would probably be 
good to look for the "Detailed Description" of the logging module to get a 
feel for the overall operation.  You can either scroll down or select the

the first function run.  There is nothing at all special here.  Your 
|ns3| script is just a C++ program.

The next line sets the time resolution to one nanosecond, which happens
to be the default value:

::

    Time::SetResolution (Time::NS);

The resolution is the smallest time value that can be represented (as well as
the smallest representable difference between two time values).
You can change the resolution exactly once.  The mechanism enabling this
flexibility is somewhat memory hungry, so once the resolution has been
set explicitly we release the memory, preventing further updates.   (If
you don't set the resolution explicitly, it will default to one nanosecond,
and the memory will be released when the simulation starts.)

The next two lines of the script are used to enable two logging components that
are built into the Echo Client and Echo Server applications:


(-)a/examples/tutorial/first.cc (+1 lines)

Lines 27-32	Link Here

int

int

main (int argc, char *argv[])

main (int argc, char *argv[])

  Time::SetResolution (Time::NS);

  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);

  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);

  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);

  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);




#include "int64x64.h"
#include <stdint.h>
#include <cmath>
#include <set>
#include <ostream>

namespace ns3 {

// Forward declaration
class Simulator;
  
/**
 * \ingroup core
 * \defgroup time Time
 */
/**
 * \ingroup time
 * \brief Keep track of time values and allow control of global simulation resolution.
 *
 * This class defines the classic addition/subtraction C++ arithmetic
 * operators +, -, +=, -=, and all the classic comparison operators:
 * keep track of seconds, the type TimeUnit<2> is used to keep
 * track of seconds squared, the type TimeUnit<-1> is used to
 * keep track of 1/seconds, etc.
 *
 * This base class defines all the functionality shared by all
 * these time unit objects: it defines all the classic arithmetic
 * operators +, -, *, /, and all the classic comparison operators:
 * ==, !=, <, >, <=, >=. It is thus easy to add, substract, or
 * compare Time objects.
 * arithmetic expression is always a TimeUnit object.
 *
 * The ns3::uint64_t, ns3::Time, ns3::TimeSquare, and ns3::TimeInvert classes
 * are aliases for the TimeUnit<0>, TimeUnit<1>, TimeUnit<2> and TimeUnit<-1>
 * types respectively.
 *
 * For example:
 * \code
 * Time<1> t1 = Seconds (10.0);
 * Time<1> t2 = Seconds (10.0);
 * Time<2> t3 = t1 * t2;
 * Time<0> t4 = t1 / t2;
 * Time<3> t5 = t3 * t1;
 * Time<-2> t6 = t1 / t5;
 * TimeSquare t7 = t3;
 * uint64_t s = t4;
 * \endcode
 *
 * If you try to assign the result of an expression which does not
 * match the type of the variable it is assigned to, you will get a
 * compiler error. For example, the following will not compile:
 * \code
 * Time<1> = Seconds (10.0) * Seconds (1.5);
 * \endcode
 *
 * You can also use the following non-member functions to manipulate
 * any of these ns3::TimeUnit object:
 *  - \ref ns3-Time-Abs ns3::Abs
 *  - \ref ns3-Time-Max ns3::Max
 *  - \ref ns3-Time-Min ns3::Min
 */
/**
 * \ingroup time
 * \brief keep track of time values and allow control of global simulation resolution
 *
 * This class defines all the classic C++ arithmetic
 * operators +, -, *, /, and all the classic comparison operators:
 * ==, !=, <, >, <=, >=. It is thus easy to add, substract, or
 * multiply multiple Time objects.
 *
 * The ns3::uint64_t, ns3::TimeSquare, and ns3::TimeInvert classes
 * are backward-compatibility aliases for ns3::Time.
 *
 * For example:
 * \code
 * Time t1 = Seconds (10.0);
 * Time t2 = Seconds (10.0);
 * Time t3 = t1;
 * t3 += t2;
 * Time t5 = t3 * t1;
 * Time t6 = t1 / t5;
 * Time t7 = t3;
 * \endcode
 *
 * You can also use the following non-member functions to manipulate
 * any of these ns3::Time object:
 *  - \ref Abs()
 *  - \ref Max()
 *  - \ref Min()
 *
 * This class also controls the resolution of the underlying time value.
 * The resolution is the smallest representable time interval.
 * The default resolution is nanoseconds.  
 * 1. It is possible to either increase or decrease the resolution and the
 * code tries really hard to make this easy.
 *
 * To change the resolution, use SetResolution().  All Time objects created
 * before the call to SetResolution() will be updated to the new resolution.
 * This can only be done once!  (Tracking each Time object uses 4 pointers.
 * For speed, once we convert the existing instances we discard the recording
 * data structure and stop tracking new instances, so we have no way
 * to do a second conversion.)
 * value 1000, the result is unlikely to be 1 exactly. It will be close to
 * 1 but not exactly 1.
 * 
 * In general, it is thus a really bad idea to try to use time objects of a
 * resolution higher than the global resolution controlled through 
 * Time::SetResolution. If you do need to use picoseconds, it's thus best
 * to switch the global resolution to picoseconds to avoid nasty surprises.
 *
 * Because of the memory (and modest construction cost) of tracking Time
 * objects, simulations should explicitly choose a resolution before
 * calling Simulator::Run ().  If you don't set the resolution explicitly,
 * it will default to one nanosecond, and the memory will be released
 * when the simulation starts.
 * is smaller than 2^64 nanoseconds which is the maximum duration of your simulation
 * if the global resolution is nanoseconds.
 *
 * If you increase the global resolution, you also implicitly decrease
 * the range of your simulation.  The global simulation time is stored
 * in a 64 bit integer, whose interpretation will depend on the global
 * resolution.  Therefore the maximum duration of your simulation,
 * if you use picoseconds, is 2^64 ps = 2^24 s = 7 months, whereas,
 * had you used nanoseconds, you could have run for 584 years.
 * the global simulation resolution in a way which gives reasonable results. This
 * issue has been filed as bug 954 in the ns-3 bugzilla installation.
 */
class Time
{

   */
  enum Unit
  {
    S  = 0,   //!< second
    MS = 1,   //!< millisecond
    US = 2,   //!< microsecond
    NS = 3,   //!< nanosecond
    PS = 4,   //!< picosecond
    FS = 5,   //!< femtosecond
    LAST = 6
  };


    m_data = o.m_data;
    return *this;
  }
  inline Time &operator = (const int64_t &value)
  {
    m_data = value;
    return *this;
  }
  inline Time ()
    : m_data ()
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  inline Time(const Time &o)
    : m_data (o.m_data)
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  explicit inline Time (double v)
    : m_data (lround (v))
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  explicit inline Time (int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  explicit inline Time (long int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  explicit inline Time (long long int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  explicit inline Time (unsigned int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  explicit inline Time (unsigned long int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  explicit inline Time (unsigned long long int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  /**
   * \brief Construct Time object from common time expressions like "1ms"
   *
   * Supported units include:
   * - `s`  (seconds)
   * - `ms` (milliseconds)
   * - `us` (microseconds)
   * - `ns` (nanoseconds)
   * - `ps` (picoseconds)
   * - `fs` (femtoseconds)
   *
   * There can be no white space between the numerical portion
   * and the units.  Any otherwise malformed string causes a fatal error to

  explicit Time (const std::string & s);

  /**
   *  Destructor
   */
  ~Time ()
  {
    if (g_markingTimes)
      {
        Clear (this);
      }
  }
  
  /**
   * \return true if the time is zero, false otherwise.
   */
  inline bool IsZero (void) const

  {
    return m_data > 0;
  }
  /**
   *  \return -1,0,+1 if `this < o`, `this == o`, or `this > o`
   */
  inline int Compare (const Time &o) const
  {
    return (m_data < o.m_data) ? -1 : (m_data == o.m_data) ? 0 : 1;

    return ToInteger (Time::FS);
  }
  /**
   * \returns the raw time value, in the current units
   *          instance in the units specified in m_tsPrecision.
   */
  inline int64_t GetTimeStep (void) const
  {

  }
  explicit inline Time (const int64x64_t &value)
    : m_data (value.GetHigh ())
  {
    if (g_markingTimes)
      {
	Mark (this);
      }
  }
  inline static Time From (const int64x64_t &value)
  {
    return Time (value);
  }

private:
  /**
   * How to convert between other units and the current unit
   */
  struct Information
  {
    bool toMul;                     //!< Multiply when converting To, otherwise divide
    bool fromMul;                   //!< Multiple when converting From, otherwise divide
    uint64_t factor;                //!< Ratio of this unit / current unit
    int64x64_t timeTo;              //!< Multiplier to convert to this unit
    int64x64_t timeFrom;            //!< Multiplier to convert from this unit
  };
  /**
   * Current time unit, and conversion info.
   */
  struct Resolution
  {
    struct Information info[LAST];  //!<  Conversion info from current unit
    enum Time::Unit unit;           //!<  Current time unit
  };

  static inline struct Resolution *PeekResolution (void)
  {
    static struct Time::Resolution resolution = SetDefaultNsResolution ();
    return &resolution;
  }
  static inline struct Information *PeekInformation (enum Unit timeUnit)

    return &(PeekResolution ()->info[timeUnit]);
  }

  static struct Resolution SetDefaultNsResolution (void);
  static void SetResolution (enum Unit unit, struct Resolution *resolution,
                             const bool convert = true);

  /**
   *  Record all instances of Time, so we can rescale them when
   *  the resolution changes.
   *
   *  \intern
   *
   *  We use a std::set so we can remove the record easily when
   *  ~Time() is called.
   *
   *  We don't use Ptr<Time>, because we would have to bloat every Time
   *  instance with SimpleRefCount<Time>.
   *
   *  Seems like this should be std::set< Time * const >, but
   *  [Stack Overflow](http://stackoverflow.com/questions/5526019/compile-errors-stdset-with-const-members)
   *  says otherwise, quoting the standard:
   *
   *  > &sect;23.1/3 states that std::set key types must be assignable
   *  > and copy constructable; clearly a const type will not be assignable.
   */
  typedef std::set< Time * > MarkedTimes;
  /**
   *  Record of outstanding Time objects which will need conversion
   *  when the resolution is set.
   *
   *  \intern
   *
   *  Use a classic static variable so we can check in Time ctors
   *  without a function call.  
   *
   *  We'd really like to initialize this here, but we don't want to require
   *  C++0x, so we init in time.cc.  To ensure that happens before first use,
   *  we add a call to StaticInit (below) to every compilation unit which
   *  includes nstime.h.
   */
  static MarkedTimes * g_markingTimes;
public:
  /**
   *  Function to force static initialization of Time
   */
  static bool StaticInit ();
private:

  friend class Simulator;
  /**
   *  Remove all MarkedTimes.
   *
   *  \intern
   *  Has to be visible to the Simulator class, hence the friending.
   */
  static void ClearMarkedTimes ();
  /**
   *  Record a Time instance with the MarkedTimes
   */
  static void Mark (Time * const time);
  /**
   *  Remove a Time instance from the MarkedTimes, called by ~Time()
   */
  static void Clear (Time * const time);
  /**
   *  Convert existing Times to the new unit.
   */
  static void ConvertTimes (const enum Unit unit);

  friend bool operator == (const Time &lhs, const Time &rhs);
  friend bool operator != (const Time &lhs, const Time &rhs);

  friend Time Max (const Time &ta, const Time &tb);
  friend Time Min (const Time &ta, const Time &tb);

  
  int64_t m_data;                   //!< Virtual time value, in the current unit.
  
};  // class Time
  

// Force static initialization of Time
static bool g_TimeStaticInit = Time::StaticInit ();
  
inline bool
operator == (const Time &lhs, const Time &rhs)
{

}

/**
 * Absolute value function for Time
 *
 * \param time the input value
 * \returns the absolute value of the input value.
 */

  return Time ((time.m_data < 0) ? -time.m_data : time.m_data);
}
/**
 * \anchor ns3-Time-Max
 * \relates ns3::TimeUnit
 * \param ta the first value
 * \param tb the seconds value
 * \returns the max of the two input values.

  return Time ((ta.m_data < tb.m_data) ? tb : ta);
}
/**
 * \anchor ns3-Time-Min
 * \relates ns3::TimeUnit
 * \param ta the first value
 * \param tb the seconds value
 * \returns the min of the two input values.

}


/**
 * \brief Time output streamer.
 * 
 * Generates output such as "3.96ns"
 * \relates ns3::Time
 */
std::ostream& operator<< (std::ostream& os, const Time & time);
/**
 * \brief Time input streamer
 *
 * Uses the Time::Time (const std::string &) constructor
 * \relates ns3::Time
 */
std::istream& operator>> (std::istream& is, Time & time);

/**

 * Simulator::Schedule (Seconds (5.0), ...);
 * \endcode
 * \param seconds seconds value
 * \relates ns3::Time
 */
inline Time Seconds (double seconds)
{

 * Simulator::Schedule (MilliSeconds (5), ...);
 * \endcode
 * \param ms milliseconds value
 * \relates ns3::Time
 */
inline Time MilliSeconds (uint64_t ms)
{

 * Simulator::Schedule (MicroSeconds (5), ...);
 * \endcode
 * \param us microseconds value
 * \relates ns3::Time
 */
inline Time MicroSeconds (uint64_t us)
{

 * Simulator::Schedule (NanoSeconds (5), ...);
 * \endcode
 * \param ns nanoseconds value
 * \relates ns3::Time
 */
inline Time NanoSeconds (uint64_t ns)
{

 * Simulator::Schedule (PicoSeconds (5), ...);
 * \endcode
 * \param ps picoseconds value
 * \relates ns3::Time
 */
inline Time PicoSeconds (uint64_t ps)
{

 * Simulator::Schedule (FemtoSeconds (5), ...);
 * \endcode
 * \param fs femtoseconds value
 * \relates ns3::Time
 */
inline Time FemtoSeconds (uint64_t fs)
{

}


/**
 * \see Seconds(double)
 * \relates ns3::Time
 */ 
inline Time Seconds (int64x64_t seconds)
{
  return Time::From (seconds, Time::S);
}
/**
 * \see MilliSeconds(uint64_t)
 * \relates ns3::Time
 */ 
inline Time MilliSeconds (int64x64_t ms)
{
  return Time::From (ms, Time::MS);
}
/**
 * \see MicroSeconds(uint64_t)
 * \relates ns3::Time
 */ 
inline Time MicroSeconds (int64x64_t us)
{
  return Time::From (us, Time::US);
}
/**
 * \see NanoSeconds(uint64_t)
 * \relates ns3::Time
 */ 
inline Time NanoSeconds (int64x64_t ns)
{
  return Time::From (ns, Time::NS);
}
/**
 * \see PicoSeconds(uint64_t)
 * \relates ns3::Time
 */ 
inline Time PicoSeconds (int64x64_t ps)
{
  return Time::From (ps, Time::PS);
}
/**
 * \see FemtoSeconds(uint64_t)
 * \relates ns3::Time
 */ 
inline Time FemtoSeconds (int64x64_t fs)
{
  return Time::From (fs, Time::FS);

(-)a/src/core/model/simulator.cc (+1 lines)

Lines 157-162	Link Here

157

Simulator::Run (void)

157

Simulator::Run (void)

158

159

  NS_LOG_FUNCTION_NOARGS ();

159

  NS_LOG_FUNCTION_NOARGS ();

160

  Time::ClearMarkedTimes ();

160

  GetImpl ()->Run ();

161

  GetImpl ()->Run ();

161

162

163

(-)a/src/core/model/time.cc (-24 / +164 lines)

Lines 27-39	Link Here

#include "object.h"

#include "object.h"

#include "config.h"

#include "config.h"

#include "log.h"

#include "log.h"

#include "simulator.h"

#include <cmath>

#include <cmath>

#include <sstream>

#include <sstream>

NS_LOG_COMPONENT_DEFINE ("Time");

namespace ns3 {

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("Time");

// The set of marked times

// static

Time::MarkedTimes * Time::g_markingTimes;

// Function called to force static initialization

// static

bool Time::StaticInit ()

  static bool firstTime = true;

  if (firstTime)

      if (! g_markingTimes)

	  g_markingTimes = new Time::MarkedTimes;

      // Schedule the cleanup.

      // We'd really like:

      //   NS_LOG_LOGIC ("scheduling ClearMarkedTimes()");

      //   Simulator::Schedule ( Seconds (0), & ClearMarkedTimes);

      //   [or even better:  Simulator::AtStart ( & ClearMarkedTimes ); ]

      // But this triggers a static initialization order error,

      // since the Simulator static initialization may not have occurred.

      // Instead, we call ClearMarkedTimes directly from Simulator::Run ()

      firstTime = false;

  return firstTime;

Time::Time (const std::string& s)

Time::Time (const std::string& s)

  NS_LOG_FUNCTION (this << &s);

  NS_LOG_FUNCTION (this << &s);

Lines 48-109	Link Here

      if (trailer == std::string ("s"))

      if (trailer == std::string ("s"))

          *this = Time::FromDouble (r, Time::S);

          *this = Time::FromDouble (r, Time::S);

          return;

      if (trailer == std::string ("ms"))

      else if (trailer == std::string ("ms"))

          *this = Time::FromDouble (r, Time::MS);

          *this = Time::FromDouble (r, Time::MS);

          return;

      if (trailer == std::string ("us"))

      else if (trailer == std::string ("us"))

          *this = Time::FromDouble (r, Time::US);

          *this = Time::FromDouble (r, Time::US);

          return;

      if (trailer == std::string ("ns"))

      else if (trailer == std::string ("ns"))

          *this = Time::FromDouble (r, Time::NS);

          *this = Time::FromDouble (r, Time::NS);

          return;

      if (trailer == std::string ("ps"))

      else if (trailer == std::string ("ps"))

          *this = Time::FromDouble (r, Time::PS);

          *this = Time::FromDouble (r, Time::PS);

          return;

100

      if (trailer == std::string ("fs"))

101

      else if (trailer == std::string ("fs"))

102

          *this = Time::FromDouble (r, Time::FS);

103

          *this = Time::FromDouble (r, Time::FS);

          return;

104

      NS_ABORT_MSG ("Can't Parse Time " << s);

105

      else

106

107

          NS_ABORT_MSG ("Can't Parse Time " << s);

108

109

  // else

110

  else

  // they didn't provide units, assume seconds

111

  std::istringstream iss;

112

      // they didn't provide units, assume seconds

  iss.str (s);

113

      std::istringstream iss;

  double v;

114

      iss.str (s);

  iss >> v;

115

      double v;

  *this = Time::FromDouble (v, Time::S);

116

      iss >> v;

117

      *this = Time::FromDouble (v, Time::S);

118

119

120

  if (g_markingTimes)

121

122

      Mark (this);

123

124

125

126

// static

struct Time::Resolution

127

struct Time::Resolution

Time::GetNsResolution (void)

128

Time::SetDefaultNsResolution (void)

129

  NS_LOG_FUNCTION_NOARGS ();

130

  NS_LOG_FUNCTION_NOARGS ();

  struct Resolution resolution;

131

  struct Resolution resolution;

  SetResolution (Time::NS, &resolution);

132

  SetResolution (Time::NS, &resolution, false);

  return resolution;

133

  return resolution;

134

135

136

// static

void

137

void

Time::SetResolution (enum Unit resolution)

138

Time::SetResolution (enum Unit resolution)

139

100

  NS_LOG_FUNCTION (resolution);

140

  NS_LOG_FUNCTION (resolution);

101

  SetResolution (resolution, PeekResolution ());

141

  SetResolution (resolution, PeekResolution ());

102

142

143

144

145

// static

103

void

146

void

104

Time::SetResolution (enum Unit unit, struct Resolution *resolution)

147

Time::SetResolution (enum Unit unit, struct Resolution *resolution,

148

                     const bool convert /* = true */)

105

149

106

  NS_LOG_FUNCTION (unit << resolution);

150

  NS_LOG_FUNCTION (resolution);

151

  if (convert)

152

    { // We have to convert old values

153

      ConvertTimes (unit);

154

155

107

  int8_t power [LAST] = { 15, 12, 9, 6, 3, 0};

156

  int8_t power [LAST] = { 15, 12, 9, 6, 3, 0};

108

  for (int i = 0; i < Time::LAST; i++)

157

  for (int i = 0; i < Time::LAST; i++)

109

158

Lines 136-141	Link Here

136

185

137

  resolution->unit = unit;

186

  resolution->unit = unit;

138

187

188

189

190

// static

191

void

192

Time::ClearMarkedTimes ()

193

194

  NS_LOG_FUNCTION_NOARGS ();

195

  if (g_markingTimes)

196

197

      NS_LOG_LOGIC ("clearing MarkedTimes");

198

      delete g_markingTimes;

199

      g_markingTimes = 0;

200

201

}  // Time::ClearMarkedTimes

202

203

204

// static

205

void

206

Time::Mark (Time * const time)

207

208

  NS_LOG_FUNCTION (time);

209

  NS_ASSERT (time != 0);

210

211

  if (g_markingTimes)

212

213

      std::pair< MarkedTimes::iterator, bool> ret;

214

215

      ret = g_markingTimes->insert ( time);

216

      NS_LOG_LOGIC ("\t[" << g_markingTimes->size () << "] recording " << time);

217

218

      if (ret.second == false)

219

220

          NS_LOG_WARN ("already recorded " << time << "!");

221

222

223

}  // Time::Mark ()

224

225

226

// static

227

void

228

Time::Clear (Time * const time)

229

230

  NS_LOG_FUNCTION (time);

231

  NS_ASSERT (time != 0);

232

233

  if (g_markingTimes)

234

235

      NS_ASSERT_MSG (g_markingTimes->count (time) == 1,

236

		     "Time object " << time <<

237

		     " registered " << g_markingTimes->count (time) <<

238

		     " times (should be 1)." );

239

240

      MarkedTimes::size_type num = g_markingTimes->erase (time);

241

      if (num != 1)

242

243

	  NS_LOG_WARN ("unexpected result erasing " << time << "!");

244

	  NS_LOG_WARN ("got " << num << ", expected 1");

245

246

      else

247

248

	  NS_LOG_LOGIC ("\t[" << g_markingTimes->size () << "] removing  " << time);

249

250

251

}  // Time::Clear ()

252

253

254

// static

255

void

256

Time::ConvertTimes (const enum Unit unit)

257

258

  NS_LOG_FUNCTION_NOARGS();

259

260

  NS_ASSERT_MSG (g_markingTimes != 0,

261

		 "No MarkedTimes registry. "

262

		 "Time::SetResolution () called more than once?");

263

264

  for ( MarkedTimes::iterator it = g_markingTimes->begin();

265

	it != g_markingTimes->end();

266

	it++ )

267

268

      Time * const tp = *it;

269

      (*tp) = tp->ToInteger (unit);

270

271

272

  NS_LOG_LOGIC ("logged " << g_markingTimes->size () << " Time objects.");

273

274

  ClearMarkedTimes ();

275

}  // Time::ConvertTimes ()

276

277

278

// static

139

enum Time::Unit

279

enum Time::Unit

140

Time::GetResolution (void)

280

Time::GetResolution (void)

141

281




class TimeSimpleTestCase : public TestCase
{
public:
  TimeSimpleTestCase ();
private:
  virtual void DoSetup (void);
  virtual void DoRun (void);
  virtual void DoTeardown (void);
  enum Time::Unit m_originalResolution;
  enum Time::Unit m_resolution;
};

TimeSimpleTestCase::TimeSimpleTestCase ()
  : TestCase ("Sanity check of common time operations")
    m_resolution (resolution)
{
}

void
TimeSimpleTestCase::DoSetup (void)
{
  m_originalResolution = Time::GetResolution ();
}

void
TimeSimpleTestCase::DoRun (void)
{
  Time::SetResolution (m_resolution);
  NS_TEST_ASSERT_MSG_EQ_TOL (Seconds (1.0).GetSeconds (), 1.0, TimeStep (1).GetSeconds (), 
                             "is 1 really 1 ?");
  NS_TEST_ASSERT_MSG_EQ_TOL (Seconds (10.0).GetSeconds (), 10.0, TimeStep (1).GetSeconds (), 

  NS_TEST_ASSERT_MSG_EQ (FemtoSeconds (1).GetFemtoSeconds (), 1, 
                         "is 1fs really 1fs ?");
#endif

  Time ten = NanoSeconds (10);
  int64_t tenValue = ten.GetInteger ();
  Time::SetResolution (Time::PS);
  int64_t tenKValue = ten.GetInteger ();
  NS_TEST_ASSERT_MSG_EQ (tenValue * 1000, tenKValue,
                         "change resolution to PS");
}

void 
TimeSimpleTestCase::DoTeardown (void)
{
  Time::SetResolution (m_originalResolution);
}

class TimesWithSignsTestCase : public TestCase

  TimeTestSuite ()
    : TestSuite ("time", UNIT)
  {
    AddTestCase (new TimeSimpleTestCase (), TestCase::QUICK);
    AddTestCase (new TimesWithSignsTestCase (), TestCase::QUICK);
  }
} g_timeTestSuite;

Return to bug 954