/home/mhx/git/github/libmoost/test/timer/timer.cpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#include <boost/test/unit_test.hpp>
#include <boost/test/test_tools.hpp>

#include <limits>

#include <boost/thread.hpp>

#include "../../include/moost/thread/xtime_util.hpp"
#include "../../include/moost/timer.h"

using namespace moost;
using namespace moost::thread;

BOOST_AUTO_TEST_SUITE( timer_test )

struct Fixture
{
   Fixture()
   : timer_(48)
   {
   }

   ~Fixture()
   {
   }

   timer timer_;
};

struct FixtureThreshold
{
   FixtureThreshold()
      : timer_(48, 10, 5)
   {
   }

   ~FixtureThreshold()
   {
   }

   timer timer_;
};

BOOST_FIXTURE_TEST_CASE( test_timer_empty, Fixture )
{
  // test preconditions of timer
  BOOST_CHECK_EQUAL(timer_.avg_time(), -1);
  BOOST_CHECK_EQUAL(timer_.min_time(), -1);
  BOOST_CHECK_EQUAL(timer_.max_time(), -1);
  BOOST_CHECK_EQUAL(timer_.count_per_second(), 0);
}

BOOST_FIXTURE_TEST_CASE( test_timer_time, Fixture )
{
  {
    timer::scoped_time lock(timer_);
    boost::thread::sleep(xtime_util::add_ms(xtime_util::now(), 100));
  }
  double time = timer_.avg_time();
  double eps = 0.0000001;
  BOOST_CHECK( fabs(timer_.avg_time() - time) < eps );
  BOOST_CHECK( fabs(timer_.min_time() - time) < eps );
  BOOST_CHECK( fabs(timer_.max_time() - time) < eps );
  //BOOST_CHECK(timer_.count_per_second() > 1);
}


BOOST_FIXTURE_TEST_CASE( test_past_threshold, FixtureThreshold )
{
   std::vector< std::pair<int, boost::posix_time::ptime> > past_thresholds = timer_.past_threshold_times(2);
   BOOST_REQUIRE( past_thresholds.empty() );

   {
      timer::scoped_time lock(timer_);
      boost::thread::sleep(xtime_util::add_ms(xtime_util::now(), 1));
   }

   int longTimeMs = 25;
   {
      timer::scoped_time lock(timer_);
      boost::thread::sleep(xtime_util::add_ms(xtime_util::now(), longTimeMs));
   }

   past_thresholds = timer_.past_threshold_times(2);
   BOOST_REQUIRE( past_thresholds.size() == 1 );
   int tolerance = 1; //ms
   BOOST_CHECK( abs( past_thresholds[0].first - longTimeMs ) < tolerance );
}

BOOST_FIXTURE_TEST_CASE( test_past_threshold_rollover, FixtureThreshold )
{
   {
      timer::scoped_time lock(timer_);
      boost::thread::sleep(xtime_util::add_ms(xtime_util::now(), 1));
   }

   int longTimeMs = 25;
   for ( int i = 0; i < 6; ++i ) // 6 times, but the size of the threshold vector is 5!
   {
      timer::scoped_time lock(timer_);
      boost::thread::sleep(xtime_util::add_ms(xtime_util::now(), longTimeMs+i));
   }

   std::vector< std::pair<int, boost::posix_time::ptime> > past_thresholds = timer_.past_threshold_times(10);
   BOOST_REQUIRE( past_thresholds.size() == 5 ); // the size of the threshold vector is 5!

   boost::posix_time::time_duration dur;
   int totMs;
   int tolerance = 1; //ms

   for ( int i = 0; i < 4; ++i )
   {
      dur = past_thresholds[i].second - past_thresholds[i+1].second;
      totMs = static_cast<int>(dur.total_milliseconds());
      BOOST_CHECK( abs(totMs - (longTimeMs + 5 - i)) < tolerance );
   }

}

/*BOOST_FIXTURE_TEST_CASE( test_timer_rollover, Fixture )
{
  for (int i = 0; i != 49; ++i)
  {
    timer::scoped_time lock(timer_);
    boost::thread::sleep(xtime_util::add_ms(xtime_util::now(), 10));
  }
  int cps = timer_.count_per_second();
  int time = timer_.avg_time();
  BOOST_CHECK_PREDICATE( std::greater_equal<int>(), (time) (8) );
  BOOST_CHECK_PREDICATE( std::less_equal<int>(), (time) (12) );
  BOOST_CHECK_PREDICATE( std::greater<int>(), (timer_.min_time()) (5) );
  BOOST_CHECK_PREDICATE( std::less<int>(), (timer_.max_time()) (15) );
  BOOST_CHECK_PREDICATE( std::greater<int>(), (cps) (95) );
  BOOST_CHECK_PREDICATE( std::less<int>(), (cps) (105) );
}*/

BOOST_AUTO_TEST_SUITE_END()