701 lines
21 KiB
C++
701 lines
21 KiB
C++
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
|
|
/*
|
|
* Copyright (c) 2005,2006 INRIA
|
|
* Copyright (c) 2007 Emmanuelle Laprise
|
|
*
|
|
* 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>
|
|
* TimeStep support by Emmanuelle Laprise <emmanuelle.laprise@bluekazoo.ca>
|
|
*/
|
|
#include "nstime.h"
|
|
#include "ns3/fatal-error.h"
|
|
#include "ns3/global-value.h"
|
|
#include "ns3/enum.h"
|
|
#include "ns3/string.h"
|
|
#include "ns3/object.h"
|
|
#include "ns3/config.h"
|
|
#include <math.h>
|
|
|
|
namespace ns3 {
|
|
|
|
namespace TimeStepPrecision {
|
|
|
|
static const uint64_t MS_FACTOR = (uint64_t)1000;
|
|
static const uint64_t US_FACTOR = (uint64_t)1000000;
|
|
static const uint64_t NS_FACTOR = (uint64_t)1000000 * (uint64_t)1000;
|
|
static const uint64_t PS_FACTOR = (uint64_t)1000000 * (uint64_t)1000000;
|
|
static const uint64_t FS_FACTOR = (uint64_t)1000000 * (uint64_t)1000000 * (uint64_t)1000;
|
|
static uint64_t g_tsPrecFactor = NS_FACTOR;
|
|
|
|
static GlobalValue g_precisionDefaultValue ("TimeStepPrecision",
|
|
"The time unit of the internal 64 bit integer time.",
|
|
EnumValue (NS),
|
|
MakeEnumChecker (NS, "NS",
|
|
S, "S",
|
|
MS, "MS",
|
|
US, "US",
|
|
PS, "PS",
|
|
FS, "FS")
|
|
);
|
|
|
|
precision_t
|
|
Get (void)
|
|
{
|
|
EnumValue v;
|
|
g_precisionDefaultValue.GetValue (v);
|
|
return (precision_t) v.Get ();
|
|
}
|
|
|
|
void
|
|
Set (precision_t precision)
|
|
{
|
|
g_precisionDefaultValue.SetValue (EnumValue (precision));
|
|
g_tsPrecFactor = (uint64_t)pow(10, precision);
|
|
}
|
|
|
|
} // namespace TimeStepPrecision
|
|
|
|
TimeUnit<1>::TimeUnit(const std::string& s)
|
|
{
|
|
std::string::size_type n = s.find_first_not_of("0123456789.");
|
|
if (n != std::string::npos)
|
|
{ // Found non-numeric
|
|
std::istringstream iss;
|
|
iss.str (s.substr(0, n));
|
|
double r;
|
|
iss >> r;
|
|
std::string trailer = s.substr(n, std::string::npos);
|
|
if (trailer == std::string("s"))
|
|
{
|
|
m_data = HighPrecision (r * TimeStepPrecision::g_tsPrecFactor);
|
|
return;
|
|
}
|
|
if (trailer == std::string("ms"))
|
|
{
|
|
m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,3))),
|
|
false);
|
|
return;
|
|
}
|
|
if (trailer == std::string("us"))
|
|
{
|
|
m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,6))),
|
|
false);
|
|
return;
|
|
}
|
|
if (trailer == std::string("ns"))
|
|
{
|
|
m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,9))),
|
|
false);
|
|
return;
|
|
}
|
|
if (trailer == std::string("ps"))
|
|
{
|
|
m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,12))),
|
|
false);
|
|
return;
|
|
}
|
|
if (trailer == std::string("fs"))
|
|
{
|
|
m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,15))),
|
|
false);
|
|
return;
|
|
}
|
|
NS_FATAL_ERROR("Can't Parse Time "<<s);
|
|
}
|
|
//else
|
|
//they didn't provide units, assume seconds
|
|
std::istringstream iss;
|
|
iss. str (s);
|
|
double v;
|
|
iss >> v;
|
|
m_data = HighPrecision (v * TimeStepPrecision::g_tsPrecFactor);
|
|
}
|
|
|
|
double
|
|
TimeUnit<1>::GetSeconds (void) const
|
|
{
|
|
double timeValue = GetHighPrecision ().GetDouble ();
|
|
return timeValue/TimeStepPrecision::g_tsPrecFactor;
|
|
}
|
|
|
|
int64_t
|
|
TimeUnit<1>::ConvertToUnits (int64_t timeValue, uint64_t unitFactor) const
|
|
{
|
|
uint64_t precFactor;
|
|
// In order to avoid conversion to double, precFactor can't be less 1
|
|
if (TimeStepPrecision::g_tsPrecFactor < unitFactor)
|
|
{
|
|
precFactor = unitFactor / TimeStepPrecision::g_tsPrecFactor;
|
|
timeValue = timeValue * precFactor;
|
|
}
|
|
else
|
|
{
|
|
precFactor = TimeStepPrecision::g_tsPrecFactor / unitFactor;
|
|
timeValue = timeValue / precFactor;
|
|
}
|
|
return timeValue;
|
|
}
|
|
|
|
|
|
int64_t
|
|
TimeUnit<1>::GetMilliSeconds (void) const
|
|
{
|
|
int64_t ts = GetTimeStep();
|
|
int64_t ms = ConvertToUnits(ts, TimeStepPrecision::MS_FACTOR);
|
|
|
|
return ms;
|
|
}
|
|
int64_t
|
|
TimeUnit<1>::GetMicroSeconds (void) const
|
|
{
|
|
int64_t ts = GetTimeStep();
|
|
int64_t us = ConvertToUnits(ts, TimeStepPrecision::US_FACTOR);
|
|
|
|
return us;
|
|
}
|
|
int64_t
|
|
TimeUnit<1>::GetNanoSeconds (void) const
|
|
{
|
|
int64_t ts = GetTimeStep();
|
|
int64_t ns = ConvertToUnits(ts, TimeStepPrecision::NS_FACTOR);
|
|
|
|
return ns;
|
|
}
|
|
int64_t
|
|
TimeUnit<1>::GetPicoSeconds (void) const
|
|
{
|
|
int64_t ts = GetTimeStep();
|
|
int64_t ps = ConvertToUnits(ts, TimeStepPrecision::PS_FACTOR);
|
|
|
|
return ps;
|
|
}
|
|
int64_t
|
|
TimeUnit<1>::GetFemtoSeconds (void) const
|
|
{
|
|
int64_t ts = GetTimeStep();
|
|
int64_t fs = ConvertToUnits(ts, TimeStepPrecision::FS_FACTOR);
|
|
|
|
return fs;
|
|
}
|
|
|
|
/**
|
|
* This returns the value with the precision returned by TimeStepPrecision::Get
|
|
*/
|
|
int64_t
|
|
TimeUnit<1>::GetTimeStep (void) const
|
|
{
|
|
int64_t timeValue = GetHighPrecision ().GetInteger ();
|
|
return timeValue;
|
|
}
|
|
|
|
|
|
std::ostream&
|
|
operator<< (std::ostream& os, const Time & time)
|
|
{
|
|
std::string unit;
|
|
switch (TimeStepPrecision::Get ()) {
|
|
case TimeStepPrecision::S:
|
|
unit = "s";
|
|
break;
|
|
case TimeStepPrecision::MS:
|
|
unit = "ms";
|
|
break;
|
|
case TimeStepPrecision::US:
|
|
unit = "us";
|
|
break;
|
|
case TimeStepPrecision::NS:
|
|
unit = "ns";
|
|
break;
|
|
case TimeStepPrecision::PS:
|
|
unit = "ps";
|
|
break;
|
|
case TimeStepPrecision::FS:
|
|
unit = "fs";
|
|
break;
|
|
}
|
|
os << time.GetTimeStep () << unit;
|
|
return os;
|
|
}
|
|
std::istream& operator>> (std::istream& is, Time & time)
|
|
{
|
|
std::string value;
|
|
is >> value;
|
|
std::string::size_type n = value.find_first_not_of("0123456789.");
|
|
if (n == std::string::npos)
|
|
{
|
|
is.setstate (std::ios_base::failbit);
|
|
return is;
|
|
}
|
|
std::string trailer = value.substr(n, value.size ()-n);
|
|
std::istringstream iss;
|
|
iss.str (value.substr(0, n));
|
|
|
|
if (trailer == std::string("s"))
|
|
{
|
|
double v;
|
|
iss >> v;
|
|
time = Seconds (v);
|
|
return is;
|
|
}
|
|
uint64_t integer;
|
|
iss >> integer;
|
|
if (is.bad () || is.fail ())
|
|
{
|
|
is.setstate (std::ios_base::failbit);
|
|
}
|
|
else if (trailer == std::string("ms"))
|
|
{
|
|
time = MilliSeconds (integer);
|
|
}
|
|
else if (trailer == std::string("us"))
|
|
{
|
|
time = MicroSeconds (integer);
|
|
}
|
|
else if (trailer == std::string("ns"))
|
|
{
|
|
time = NanoSeconds (integer);
|
|
}
|
|
else if (trailer == std::string("ps"))
|
|
{
|
|
time = PicoSeconds (integer);
|
|
}
|
|
else if (trailer == std::string("fs"))
|
|
{
|
|
time = FemtoSeconds (integer);
|
|
}
|
|
else
|
|
{
|
|
is.setstate (std::ios_base::failbit);
|
|
}
|
|
return is;
|
|
}
|
|
|
|
Time Seconds (double seconds)
|
|
{
|
|
double d_sec = seconds * TimeStepPrecision::g_tsPrecFactor;
|
|
return Time (HighPrecision (d_sec));
|
|
// return Time (HighPrecision ((int64_t)d_sec, false));
|
|
}
|
|
|
|
uint64_t
|
|
TimeUnit<1>::UnitsToTimestep (uint64_t unitValue,
|
|
uint64_t unitFactor)
|
|
{
|
|
uint64_t precFactor;
|
|
// In order to avoid conversion to double, precFactor can't be less 1
|
|
if (TimeStepPrecision::g_tsPrecFactor < unitFactor)
|
|
{
|
|
precFactor = unitFactor / TimeStepPrecision::g_tsPrecFactor;
|
|
unitValue = unitValue / precFactor;
|
|
}
|
|
else
|
|
{
|
|
precFactor = TimeStepPrecision::g_tsPrecFactor / unitFactor;
|
|
unitValue = unitValue * precFactor;
|
|
}
|
|
return unitValue;
|
|
}
|
|
|
|
ATTRIBUTE_VALUE_IMPLEMENT (Time);
|
|
ATTRIBUTE_CHECKER_IMPLEMENT (Time);
|
|
|
|
Time MilliSeconds (uint64_t ms)
|
|
{
|
|
uint64_t ts = TimeUnit<1>::UnitsToTimestep(ms, TimeStepPrecision::MS_FACTOR);
|
|
return TimeStep(ts);
|
|
}
|
|
|
|
Time MicroSeconds (uint64_t us)
|
|
{
|
|
uint64_t ts = TimeUnit<1>::UnitsToTimestep(us, TimeStepPrecision::US_FACTOR);
|
|
return TimeStep(ts);
|
|
}
|
|
|
|
Time NanoSeconds (uint64_t ns)
|
|
{
|
|
uint64_t ts = TimeUnit<1>::UnitsToTimestep(ns, TimeStepPrecision::NS_FACTOR);
|
|
return TimeStep(ts);
|
|
}
|
|
Time PicoSeconds (uint64_t ps)
|
|
{
|
|
uint64_t ts = TimeUnit<1>::UnitsToTimestep(ps, TimeStepPrecision::PS_FACTOR);
|
|
return TimeStep(ts);
|
|
}
|
|
Time FemtoSeconds (uint64_t fs)
|
|
{
|
|
uint64_t ts = TimeUnit<1>::UnitsToTimestep(fs, TimeStepPrecision::FS_FACTOR);
|
|
return TimeStep(ts);
|
|
}
|
|
|
|
|
|
/*
|
|
* The timestep value passed to this function must be of the precision
|
|
* of TimeStepPrecision::Get
|
|
*/
|
|
Time TimeStep (uint64_t ts)
|
|
{
|
|
return Time (HighPrecision (ts, false));
|
|
}
|
|
|
|
TimeUnit<0>::TimeUnit (double scalar)
|
|
: m_data (HighPrecision (scalar))
|
|
{}
|
|
|
|
double
|
|
TimeUnit<0>::GetDouble (void) const
|
|
{
|
|
return GetHighPrecision ().GetDouble ();
|
|
}
|
|
|
|
} // namespace ns3
|
|
|
|
#include "ns3/test.h"
|
|
|
|
namespace ns3 {
|
|
|
|
#define PRECISION(mult) (pow(10,-((double)(ns3::TimeStepPrecision::Get ())))*mult)
|
|
#define ASSERT_MSG_EQ(a,b,mult,msg) \
|
|
NS_TEST_ASSERT_MSG_EQ(((a)<((b)-PRECISION(mult)) || (a)>((b)+PRECISION(mult))),false, \
|
|
msg << " Values are not equal within requested precision range: " << \
|
|
(a) << "!=" << (b) << " ~ " << PRECISION(mult))
|
|
#define ASSERT_MSG_EQ_INT(a,b,mult,msg) \
|
|
ASSERT_MSG_EQ(((int64_t)(a)),((int64_t)(b)),mult,msg)
|
|
#define ASSERT_EQ(a,b) \
|
|
ASSERT_MSG_EQ(a,b,1,"")
|
|
|
|
class OldTimeTestCase : public TestCase
|
|
{
|
|
public:
|
|
OldTimeTestCase();
|
|
virtual bool DoRun (void);
|
|
};
|
|
|
|
OldTimeTestCase::OldTimeTestCase()
|
|
: TestCase("Sanity check of common time operations")
|
|
{}
|
|
bool
|
|
OldTimeTestCase::DoRun (void)
|
|
{
|
|
NS_TEST_ASSERT_MSG_EQ(TimeStepPrecision::Get(),
|
|
TimeStepPrecision::NS,
|
|
"Invalid precision mode");
|
|
|
|
Time t0 = Seconds (10.0);
|
|
ASSERT_EQ(t0.GetSeconds(), 10.0);
|
|
|
|
Time t1 = Seconds (11.0);
|
|
ASSERT_EQ(t1.GetSeconds(), 11.0);
|
|
|
|
t0 = Seconds (1.5);
|
|
ASSERT_EQ(t0.GetSeconds(), 1.5);
|
|
|
|
t0 = Seconds (-1.5);
|
|
ASSERT_EQ(t0.GetSeconds(), -1.5);
|
|
|
|
t0 = MilliSeconds ((uint64_t)10.0);
|
|
ASSERT_EQ(t0.GetSeconds(), 0.01);
|
|
|
|
t1 = MilliSeconds ((uint64_t)11.0);
|
|
ASSERT_EQ(t1.GetSeconds(), 0.011);
|
|
|
|
|
|
Time t2, t3;
|
|
|
|
t2 = t1 - t0;
|
|
NS_TEST_ASSERT_MSG_EQ(t2.IsStrictlyPositive (),true, "Variable should be positive");
|
|
ASSERT_EQ(t2.GetSeconds(), t1.GetSeconds()-t0.GetSeconds());
|
|
|
|
t2 = t1 - t1;
|
|
NS_TEST_ASSERT_MSG_EQ(t2.IsZero (),true, "Variable should be zero");
|
|
ASSERT_EQ(t2.GetSeconds(), t1.GetSeconds()-t1.GetSeconds());
|
|
|
|
t2 = t0 - t1;
|
|
NS_TEST_ASSERT_MSG_EQ(t2.IsStrictlyNegative (),true, "Variable should be negative");
|
|
ASSERT_EQ(t2.GetSeconds(), t0.GetSeconds()-t1.GetSeconds());
|
|
|
|
Time tmp = MilliSeconds (0);
|
|
NS_TEST_ASSERT_MSG_EQ((MilliSeconds (0) == NanoSeconds(0)), true, "Zero is not Zero ?");
|
|
NS_TEST_ASSERT_MSG_EQ((MilliSeconds (0) > NanoSeconds(0)), false, "Zero is bigger than Zero ?");
|
|
NS_TEST_ASSERT_MSG_EQ((MilliSeconds (0) < NanoSeconds(0)), false, "Zero is smaller than Zero ?");
|
|
|
|
Time t4 = Seconds (10.0) * Scalar (1.5);
|
|
ASSERT_EQ(t4.GetSeconds(), 15.0);
|
|
|
|
Time t5 = NanoSeconds (10) * Scalar (1.5);
|
|
ASSERT_EQ(t5.GetNanoSeconds(), 15.0);
|
|
|
|
Time t6 = Seconds (10.0) * Scalar (15) / Scalar (10);
|
|
ASSERT_EQ(t6.GetSeconds (), 15.0);
|
|
|
|
Time t7 = NanoSeconds (10) * Scalar (15) / Scalar (10);
|
|
ASSERT_EQ(t7.GetNanoSeconds (), 15.0);
|
|
|
|
ASSERT_EQ((t1 + t2).GetSeconds (), t1.GetSeconds()+t2.GetSeconds());
|
|
|
|
ASSERT_EQ((t1 / t2).GetDouble (), t1.GetSeconds()/t2.GetSeconds());
|
|
|
|
return false;
|
|
}
|
|
|
|
class OperationsTimeTestCase : public TestCase
|
|
{
|
|
public:
|
|
OperationsTimeTestCase();
|
|
virtual bool DoRun(void);
|
|
};
|
|
|
|
OperationsTimeTestCase::OperationsTimeTestCase()
|
|
: TestCase ("Check the +, -, * and / operators for the TimeUnit<1>")
|
|
{}
|
|
|
|
bool
|
|
OperationsTimeTestCase::DoRun(void)
|
|
{
|
|
// What happens if you set these values ?
|
|
// t0 = Seconds ((uint64_t)10.0);
|
|
// t1 = Seconds ((uint64_t)11.0);
|
|
|
|
Time t0 = MilliSeconds(10);
|
|
Time t1 = MilliSeconds(11);
|
|
|
|
ASSERT_EQ((t0-t1).GetSeconds(),
|
|
(t0.GetSeconds()-t1.GetSeconds()));
|
|
ASSERT_EQ(((t0-t1) * t0 / t0).GetSeconds(),
|
|
((t0.GetSeconds()-t1.GetSeconds()) * t0.GetSeconds () / t0.GetSeconds ()));
|
|
ASSERT_EQ(((t0-t1) * t0 / t1).GetSeconds(),
|
|
((t0.GetSeconds()-t1.GetSeconds()) * t0.GetSeconds () / t1.GetSeconds ()));
|
|
ASSERT_EQ((t0 * (t0-t1) / t1).GetSeconds(),
|
|
(t0.GetSeconds () * (t0.GetSeconds()-t1.GetSeconds()) / t1.GetSeconds ()));
|
|
ASSERT_EQ((t0 * t1 / (t0-t1)).GetSeconds(),
|
|
(t0.GetSeconds () * t1.GetSeconds() / (t0.GetSeconds()-t1.GetSeconds())));
|
|
ASSERT_EQ((t0 * (t1 / (t0-t1))).GetSeconds(),
|
|
(t0.GetSeconds () * (t1.GetSeconds() / (t0.GetSeconds()-t1.GetSeconds()))));
|
|
ASSERT_EQ(((t0 * t1) / (t0-t1)).GetSeconds(),
|
|
((t0.GetSeconds () * t1.GetSeconds()) / (t0.GetSeconds()-t1.GetSeconds())));
|
|
ASSERT_EQ((t0 / t1 * (t0-t1)).GetSeconds(),
|
|
(t0.GetSeconds () / t1.GetSeconds() * (t0.GetSeconds()-t1.GetSeconds())));
|
|
ASSERT_EQ(((t0 / t1) * (t0-t1)).GetSeconds(),
|
|
(t0.GetSeconds () / t1.GetSeconds()) * (t0.GetSeconds()-t1.GetSeconds()));
|
|
ASSERT_EQ((t0 * Scalar(10.0)).GetSeconds (), (t0.GetSeconds () * 10.0));
|
|
ASSERT_EQ((Scalar(10.0) * t0).GetSeconds (), (10.0 * t0.GetSeconds ()));
|
|
|
|
// Note: we need to multiply by 1e9 because GetSeconds is multiplying
|
|
ASSERT_EQ(((t0/(t1*(t0-t1))).GetHighPrecision().GetDouble() * 1e9),
|
|
(t0.GetSeconds()/(t1.GetSeconds()*(t0.GetSeconds()-t1.GetSeconds()))));
|
|
|
|
ASSERT_EQ((t0/t1).GetDouble(),(t0.GetSeconds()/t1.GetSeconds()));
|
|
|
|
|
|
ASSERT_EQ((t0 * t1 / ((t0-t1) * t0)).GetDouble (),
|
|
(t0.GetSeconds () * t1.GetSeconds () / ((t0.GetSeconds () - t1.GetSeconds()) * t0.GetSeconds ())));
|
|
return false;
|
|
}
|
|
|
|
class TimeStepTestCase : public TestCase
|
|
{
|
|
public:
|
|
TimeStepTestCase ();
|
|
virtual bool DoRun (void);
|
|
};
|
|
|
|
TimeStepTestCase::TimeStepTestCase ()
|
|
: TestCase("Check boundaries of TimeStep")
|
|
{}
|
|
bool
|
|
TimeStepTestCase::DoRun (void)
|
|
{
|
|
Time tooBig = TimeStep (0x8000000000000000LL);
|
|
NS_TEST_ASSERT_MSG_EQ (tooBig.IsNegative (), true, "Is not negative ?");
|
|
tooBig = TimeStep (0xffffffffffffffffLL);
|
|
NS_TEST_ASSERT_MSG_EQ (tooBig.IsNegative (), true, "Is not negative ?");
|
|
tooBig = TimeStep (0x7fffffffffffffffLL);
|
|
NS_TEST_ASSERT_MSG_EQ (tooBig.IsPositive (), true, "Is not negative ?");
|
|
tooBig += TimeStep (1);
|
|
NS_TEST_ASSERT_MSG_EQ (tooBig.IsNegative (), true, "Is not negative ?");
|
|
return false;
|
|
}
|
|
|
|
class GlobalPrecisionTestCase : public TestCase
|
|
{
|
|
public:
|
|
GlobalPrecisionTestCase ();
|
|
virtual bool DoRun (void);
|
|
virtual void DoTeardown (void);
|
|
};
|
|
|
|
GlobalPrecisionTestCase::GlobalPrecisionTestCase ()
|
|
: TestCase ("Check that global value actually changes the underlying precision")
|
|
{}
|
|
#define CHECK_PRECISION(prec) \
|
|
Config::SetGlobal ("TimeStepPrecision", StringValue (#prec)); \
|
|
NS_TEST_ASSERT_MSG_EQ(TimeStepPrecision::Get(), TimeStepPrecision::prec, "Could not set precision " << #prec)
|
|
bool
|
|
GlobalPrecisionTestCase::DoRun (void)
|
|
{
|
|
CHECK_PRECISION(S);
|
|
CHECK_PRECISION(MS);
|
|
CHECK_PRECISION(US);
|
|
CHECK_PRECISION(NS);
|
|
CHECK_PRECISION(PS);
|
|
CHECK_PRECISION(FS);
|
|
return false;
|
|
}
|
|
|
|
void
|
|
GlobalPrecisionTestCase::DoTeardown (void)
|
|
{
|
|
TimeStepPrecision::Set (TimeStepPrecision::NS);
|
|
}
|
|
|
|
#if 0
|
|
// disable this test because it triggers crazy
|
|
// compiler behavior (ICE+unbounded memory usage)
|
|
class ConversionTestCase : public TestCase
|
|
{
|
|
public:
|
|
ConversionTestCase ();
|
|
virtual bool DoRun (void);
|
|
virtual void DoTeardown (void);
|
|
};
|
|
|
|
ConversionTestCase::ConversionTestCase ()
|
|
: TestCase ("Check crazy time conversions")
|
|
{}
|
|
|
|
void ConversionTestCase::DoTeardown (void)
|
|
{
|
|
TimeStepPrecision::Set (TimeStepPrecision::NS);
|
|
}
|
|
|
|
#define CHECK_CONVERSIONS(tmp) \
|
|
do { \
|
|
double val = tmp; \
|
|
Time t_sec = Seconds(val); \
|
|
ASSERT_MSG_EQ(t_sec.GetSeconds(), val*1e0, 1e0, "conv sec s"); \
|
|
ASSERT_MSG_EQ_INT(t_sec.GetMilliSeconds(), val*1e3, 1e3, "conv sec ms"); \
|
|
ASSERT_MSG_EQ_INT(t_sec.GetMicroSeconds(), val*1e6, 1e6, "conv sec us"); \
|
|
ASSERT_MSG_EQ_INT(t_sec.GetNanoSeconds(), val*1e9, 1e9, "conv sec ns"); \
|
|
ASSERT_MSG_EQ_INT(t_sec.GetPicoSeconds(), val*1e12, 1e12, "conv sec ps"); \
|
|
ASSERT_MSG_EQ_INT(t_sec.GetFemtoSeconds(), val*1e15, 1e15, "conv sec fs"); \
|
|
uint64_t int_val = (uint64_t)val; \
|
|
Time t_ms = MilliSeconds(int_val); \
|
|
ASSERT_MSG_EQ(t_ms.GetSeconds(), val*1e-3, 1e0, "conv ms s"); \
|
|
ASSERT_MSG_EQ_INT(t_ms.GetMilliSeconds(), val*1e0, 1e3, "conv ms ms"); \
|
|
ASSERT_MSG_EQ_INT(t_ms.GetMicroSeconds(), val*1e3, 1e6, "conv ms us"); \
|
|
ASSERT_MSG_EQ_INT(t_ms.GetNanoSeconds(), val*1e6, 1e9, "conv ms ns"); \
|
|
ASSERT_MSG_EQ_INT(t_ms.GetPicoSeconds(), val*1e9, 1e12, "conv ms fs"); \
|
|
ASSERT_MSG_EQ_INT(t_ms.GetFemtoSeconds(), val*1e12, 1e15, "conv ms ps"); \
|
|
Time t_us = MicroSeconds(int_val); \
|
|
ASSERT_MSG_EQ(t_us.GetSeconds(), val*1e-6, 1e0, "conv us s"); \
|
|
ASSERT_MSG_EQ_INT(t_us.GetMilliSeconds(), val*1e-3, 1e3, "conv us ms"); \
|
|
ASSERT_MSG_EQ_INT(t_us.GetMicroSeconds(), val*1e0, 1e6, "conv us us"); \
|
|
ASSERT_MSG_EQ_INT(t_us.GetNanoSeconds(), val*1e3, 1e9, "conv us ns"); \
|
|
ASSERT_MSG_EQ_INT(t_us.GetPicoSeconds(), val*1e6, 1e12, "conv us ps"); \
|
|
ASSERT_MSG_EQ_INT(t_us.GetFemtoSeconds(), val*1e9, 1e15, "conv us fs"); \
|
|
Time t_ns = NanoSeconds(int_val); \
|
|
ASSERT_MSG_EQ(t_ns.GetSeconds(), val*1e-9, 1e0, "conv ns s"); \
|
|
ASSERT_MSG_EQ_INT(t_ns.GetMilliSeconds(), val*1e-6, 1e3, "conv ns ms"); \
|
|
ASSERT_MSG_EQ_INT(t_ns.GetMicroSeconds(), val*1e-3, 1e6, "conv ns us"); \
|
|
ASSERT_MSG_EQ_INT(t_ns.GetNanoSeconds(), val*1e0, 1e9, "conv ns ns"); \
|
|
ASSERT_MSG_EQ_INT(t_ns.GetPicoSeconds(), val*1e3, 1e12, "conv ns ps"); \
|
|
ASSERT_MSG_EQ_INT(t_ns.GetFemtoSeconds(), val*1e6, 1e15, "conv ns fs"); \
|
|
Time t_ps = PicoSeconds(int_val); \
|
|
ASSERT_MSG_EQ(t_ps.GetSeconds(), val*1e-12, 1e0, "conv ps s"); \
|
|
ASSERT_MSG_EQ_INT(t_ps.GetMilliSeconds(), val*1e-9, 1e3, "conv ps ms"); \
|
|
ASSERT_MSG_EQ_INT(t_ps.GetMicroSeconds(), val*1e-6, 1e6, "conv ps us"); \
|
|
ASSERT_MSG_EQ_INT(t_ps.GetNanoSeconds(), val*1e-3, 1e9, "conv ps ns"); \
|
|
ASSERT_MSG_EQ_INT(t_ps.GetPicoSeconds(), val*1e0, 1e12, "conv ps ps"); \
|
|
ASSERT_MSG_EQ_INT(t_ps.GetFemtoSeconds(), val*1e3, 1e15, "conv ps fs"); \
|
|
Time t_fs = FemtoSeconds(int_val); \
|
|
ASSERT_MSG_EQ(t_fs.GetSeconds(), val*1e-15, 1e0, "conv fs sec"); \
|
|
ASSERT_MSG_EQ_INT(t_fs.GetMilliSeconds(), val*1e-12, 1e3, "conv fs ms"); \
|
|
ASSERT_MSG_EQ_INT(t_fs.GetMicroSeconds(), val*1e-9, 1e6, "conv fs us"); \
|
|
ASSERT_MSG_EQ_INT(t_fs.GetNanoSeconds(), val*1e-6, 1e9, "conv fs ns"); \
|
|
ASSERT_MSG_EQ_INT(t_fs.GetPicoSeconds(), val*1e-3, 1e12, "conv fs ps"); \
|
|
ASSERT_MSG_EQ_INT(t_fs.GetFemtoSeconds(), val*1e0, 1e15, "conv fs fs"); \
|
|
} while (false)
|
|
|
|
bool
|
|
ConversionTestCase::DoRun (void)
|
|
{
|
|
CHECK_CONVERSIONS(5);
|
|
CHECK_CONVERSIONS(0);
|
|
CHECK_CONVERSIONS(783);
|
|
CHECK_CONVERSIONS(1132);
|
|
// triggers overflow
|
|
// XXX
|
|
// CHECK_CONVERSIONS(3341039);
|
|
|
|
TimeStepPrecision::Set (TimeStepPrecision::US);
|
|
CHECK_CONVERSIONS(7);
|
|
CHECK_CONVERSIONS(546);
|
|
CHECK_CONVERSIONS(6231);
|
|
// triggers overflow
|
|
// XXX
|
|
// CHECK_CONVERSIONS(1234639);
|
|
|
|
TimeStepPrecision::Set (TimeStepPrecision::MS);
|
|
CHECK_CONVERSIONS(3);
|
|
CHECK_CONVERSIONS(134);
|
|
CHECK_CONVERSIONS(2341);
|
|
// triggers overflow
|
|
// XXX
|
|
// CHECK_CONVERSIONS(8956239);
|
|
|
|
TimeStepPrecision::Set (TimeStepPrecision::NS);
|
|
CHECK_CONVERSIONS(4);
|
|
CHECK_CONVERSIONS(342);
|
|
CHECK_CONVERSIONS(1327);
|
|
// triggers overflow
|
|
// XXX
|
|
// CHECK_CONVERSIONS(5439627);
|
|
|
|
TimeStepPrecision::Set (TimeStepPrecision::PS);
|
|
CHECK_CONVERSIONS(4);
|
|
CHECK_CONVERSIONS(342);
|
|
CHECK_CONVERSIONS(1327);
|
|
// triggers overflow
|
|
// XXX
|
|
// CHECK_CONVERSIONS(5439627);
|
|
|
|
TimeStepPrecision::Set (TimeStepPrecision::NS);
|
|
CHECK_CONVERSIONS(12);
|
|
|
|
TimeStepPrecision::Set (TimeStepPrecision::S);
|
|
CHECK_CONVERSIONS(7);
|
|
|
|
TimeStepPrecision::Set (TimeStepPrecision::FS);
|
|
CHECK_CONVERSIONS(5);
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
static class TimeTestSuite : public TestSuite
|
|
{
|
|
public:
|
|
TimeTestSuite()
|
|
: TestSuite("time", UNIT)
|
|
{
|
|
AddTestCase(new OldTimeTestCase());
|
|
AddTestCase(new OperationsTimeTestCase());
|
|
AddTestCase(new TimeStepTestCase());
|
|
AddTestCase(new GlobalPrecisionTestCase());
|
|
//AddTestCase(new ConversionTestCase());
|
|
}
|
|
} g_timeTestSuite;
|
|
|
|
} // namespace ns3
|