ceph/src/boost/libs/chrono/stopwatches/test/stopwatch/basic_stopwatch_laps_accumulator_set_pass.cpp

   1 //  Copyright 2010-2011 Vicente J. Botet Escriba
   2 //  Distributed under the Boost Software License, Version 1.0.
   3 //  See http://www.boost.org/LICENSE_1_0.txt
   4
   5 #define BOOST_CHRONO_VERSION 2
   6
   7 #include <iostream>
   8 #include <boost/type_traits/is_same.hpp>
   9 #include <boost/chrono/stopwatches/stopwatch.hpp>
  10 #include <boost/chrono/stopwatches/collectors/laps_accumulator_set.hpp>
  11 #include "../cycle_count.hpp"
  12 #include <boost/detail/lightweight_test.hpp>
  13
  14 #if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
  15 #define NOTHING ""
  16 #endif
  17
  18
  19 template <typename Stopwatch>
  20 void check_invariants()
  21 {
  22     BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Stopwatch::rep, typename Stopwatch::clock::duration::rep>::value), NOTHING, ());
  23     BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Stopwatch::period, typename Stopwatch::clock::duration::period>::value), NOTHING, ());
  24     BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Stopwatch::duration, typename Stopwatch::clock::time_point::duration>::value), NOTHING, ());
  25     BOOST_CHRONO_STATIC_ASSERT(Stopwatch::is_steady == Stopwatch::clock::is_steady, NOTHING, ());
  26 }
  27
  28 template <typename Stopwatch>
  29 void check_default_constructor()
  30 {
  31   Stopwatch sw;
  32   BOOST_TEST(sw.is_running());
  33   BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
  34   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==0);
  35 }
  36
  37 template <typename Stopwatch>
  38 void check_dont_start_constructor()
  39 {
  40   Stopwatch sw(boost::chrono::dont_start);
  41   BOOST_TEST(!sw.is_running());
  42   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  43   typename Stopwatch::duration d=sw.elapsed();
  44   BOOST_TEST(d == Stopwatch::duration::zero());
  45   BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
  46   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==0);
  47 }
  48
  49 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  50 template <typename Stopwatch>
  51 void check_constructor_ec()
  52 {
  53   boost::system::error_code ec;
  54   Stopwatch sw(ec);
  55   BOOST_TEST(sw.is_running());
  56   BOOST_TEST(ec.value()==0);
  57   BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
  58   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==0);
  59 }
  60
  61 template <typename Stopwatch>
  62 void check_constructor_throws()
  63 {
  64   Stopwatch sw(boost::throws());
  65   BOOST_TEST(sw.is_running());
  66   BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
  67   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==0);
  68 }
  69 #endif
  70
  71 template <typename Stopwatch>
  72 void check_elapsed()
  73 {
  74   Stopwatch sw;
  75   BOOST_TEST(sw.is_running());
  76   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  77   typename Stopwatch::duration d=sw.elapsed();
  78   BOOST_TEST(sw.is_running());
  79   BOOST_TEST(d >= boost::chrono::milliseconds(100));
  80   BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
  81   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==0);
  82 }
  83
  84 template <typename Stopwatch>
  85 void check_start_start()
  86 {
  87   Stopwatch sw;
  88   BOOST_TEST(sw.is_running());
  89   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  90   sw.start();
  91   BOOST_TEST(sw.is_running());
  92   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  93   typename Stopwatch::duration d=sw.elapsed();
  94   BOOST_TEST(sw.is_running());
  95   BOOST_TEST(d >= boost::chrono::milliseconds(100));
  96   BOOST_TEST(d < boost::chrono::milliseconds(200));
  97   BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
  98   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==0);
  99 }
 100
 101 template <typename Stopwatch>
 102 void check_dont_start_start()
 103 {
 104   Stopwatch sw(boost::chrono::dont_start);
 105   BOOST_TEST(!sw.is_running());
 106   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 107   sw.start();
 108   BOOST_TEST(sw.is_running());
 109   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 110   typename Stopwatch::duration d=sw.elapsed();
 111   BOOST_TEST(sw.is_running());
 112   BOOST_TEST(d >= boost::chrono::milliseconds(100));
 113   BOOST_TEST(d < boost::chrono::milliseconds(200));
 114   BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
 115   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==0);
 116 }
 117
 118 template <typename Stopwatch>
 119 void check_dont_start_start_stop()
 120 {
 121   Stopwatch sw(boost::chrono::dont_start);
 122   BOOST_TEST(!sw.is_running());
 123   sw.start();
 124   BOOST_TEST(sw.is_running());
 125   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 126   sw.stop();
 127   BOOST_TEST(!sw.is_running());
 128   typename Stopwatch::duration d=sw.elapsed();
 129   BOOST_TEST(!sw.is_running());
 130   BOOST_TEST(d == boost::chrono::milliseconds(100));
 131   BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
 132   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==1);
 133 }
 134
 135 template <typename Stopwatch>
 136 void check_dont_start_scoped_run()
 137 {
 138   Stopwatch sw(boost::chrono::dont_start);
 139   BOOST_TEST(!sw.is_running());
 140   {
 141     typename Stopwatch::scoped_run _(sw);
 142     BOOST_TEST(sw.is_running());
 143     ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 144   }
 145   BOOST_TEST(!sw.is_running());
 146   typename Stopwatch::duration d=sw.elapsed();
 147   BOOST_TEST(!sw.is_running());
 148   BOOST_TEST(d == boost::chrono::milliseconds(100));
 149   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==1);
 150 }
 151
 152 template <typename Stopwatch>
 153 void check_stop()
 154 {
 155   Stopwatch sw;
 156   BOOST_TEST(sw.is_running());
 157   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 158   sw.stop();
 159   BOOST_TEST(!sw.is_running());
 160   typename Stopwatch::duration d=sw.elapsed();
 161   BOOST_TEST(!sw.is_running());
 162   BOOST_TEST(d == boost::chrono::milliseconds(100));
 163   BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
 164   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==1);
 165 }
 166
 167 template <typename Stopwatch>
 168 void check_stop_stop()
 169 {
 170   Stopwatch sw;
 171   BOOST_TEST(sw.is_running());
 172   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 173   sw.stop();
 174   BOOST_TEST(!sw.is_running());
 175   typename Stopwatch::duration d=sw.elapsed();
 176   BOOST_TEST(!sw.is_running());
 177   BOOST_TEST(d == boost::chrono::milliseconds(100));
 178   BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
 179   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 180   sw.stop();
 181   BOOST_TEST(!sw.is_running());
 182   d=sw.elapsed();
 183   BOOST_TEST(!sw.is_running());
 184   BOOST_TEST(d == boost::chrono::milliseconds(100));
 185   BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
 186   BOOST_TEST(boost::accumulators::count(sw.get_laps_collector().accumulator_set())==1);
 187 }
 188
 189
 190 template <typename Stopwatch>
 191 void check_all()
 192 {
 193   check_invariants<Stopwatch>();
 194   check_default_constructor<Stopwatch>();
 195 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
 196   check_constructor_ec<Stopwatch>();
 197   check_constructor_throws<Stopwatch>();
 198 #endif
 199   check_elapsed<Stopwatch>();
 200
 201   check_start_start<Stopwatch>();
 202   check_dont_start_constructor<Stopwatch>();
 203   check_dont_start_start<Stopwatch>();
 204   check_dont_start_start_stop<Stopwatch>();
 205   check_dont_start_scoped_run<Stopwatch>();
 206   check_stop<Stopwatch>();
 207   check_stop_stop<Stopwatch>();
 208
 209 }
 210
 211
 212 int main()
 213 {
 214   std::cout << "cycle_count=";
 215   check_all<boost::chrono::stopwatch< ex::cycle_count<1500>, boost::chrono::laps_accumulator_set<ex::cycle_count<1500>::duration> > >();
 216   return boost::report_errors();
 217 }