/* -*- 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 * TimeStep support by Emmanuelle Laprise */ #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 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 class Bug863TestCase : public TestCase { public: Bug863TestCase (); virtual bool DoRun (void); }; Bug863TestCase::Bug863TestCase () : TestCase ("Bug 863") { } bool Bug863TestCase::DoRun (void) { Scalar result = Scalar (0.9) / Scalar (1.0); NS_TEST_ASSERT_MSG_EQ ((result == Scalar (0.9)), true, "Invalid arithmetic result"); return false; } static class TimeTestSuite : public TestSuite { public: TimeTestSuite () : TestSuite ("time", UNIT) { AddTestCase (new OldTimeTestCase ()); AddTestCase (new OperationsTimeTestCase ()); AddTestCase (new TimeStepTestCase ()); AddTestCase (new GlobalPrecisionTestCase ()); AddTestCase (new Bug863TestCase ()); // AddTestCase(new ConversionTestCase()); } } g_timeTestSuite; } // namespace ns3