ceph/src/boost/libs/chrono/stopwatches/test/stopwatch/laps_stopclock_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/reporters/stopclock.hpp>
  10 #include "../cycle_count.hpp"
  11 #include <boost/chrono/stopwatches/reporters/system_default_formatter.hpp>
  12
  13 #include <boost/chrono/chrono_io.hpp>
  14 #include <boost/system/system_error.hpp>
  15 #include <boost/detail/lightweight_test.hpp>
  16
  17 #if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
  18 #define NOTHING ""
  19 #endif
  20
  21 using namespace boost::chrono;
  22
  23
  24 template <typename Stopwatch>
  25 void check_invariants()
  26 {
  27     BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Stopwatch::rep, typename Stopwatch::clock::duration::rep>::value), NOTHING, ());
  28     BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Stopwatch::period, typename Stopwatch::clock::duration::period>::value), NOTHING, ());
  29     BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Stopwatch::duration, typename Stopwatch::clock::time_point::duration>::value), NOTHING, ());
  30     BOOST_CHRONO_STATIC_ASSERT(Stopwatch::is_steady == Stopwatch::clock::is_steady, NOTHING, ());
  31 }
  32
  33 template <typename Stopwatch>
  34 void check_default_constructor()
  35 {
  36   Stopwatch sw;
  37   BOOST_TEST(sw.is_running());
  38 }
  39
  40 template <typename Stopwatch>
  41 void check_dont_start_constructor()
  42 {
  43   Stopwatch sw(boost::chrono::dont_start);
  44   BOOST_TEST(!sw.is_running());
  45   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  46   typename Stopwatch::duration d=sw.elapsed();
  47   BOOST_TEST(d == Stopwatch::duration::zero());
  48 }
  49
  50 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  51 template <typename Stopwatch>
  52 void check_constructor_ec()
  53 {
  54   boost::system::error_code ec;
  55   Stopwatch sw(ec);
  56   BOOST_TEST(sw.is_running());
  57   BOOST_TEST(ec.value()==0);
  58 }
  59
  60 template <typename Stopwatch>
  61 void check_constructor_throws()
  62 {
  63   Stopwatch sw(boost::throws());
  64   BOOST_TEST(sw.is_running());
  65 }
  66 #endif
  67
  68 template <typename Stopwatch>
  69 void check_elapsed()
  70 {
  71   Stopwatch sw;
  72   BOOST_TEST(sw.is_running());
  73   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  74   typename Stopwatch::duration d=sw.elapsed();
  75   BOOST_TEST(sw.is_running());
  76   BOOST_TEST(d >= boost::chrono::milliseconds(100));
  77 }
  78
  79 template <typename Stopwatch>
  80 void check_start_start()
  81 {
  82   Stopwatch sw;
  83   BOOST_TEST(sw.is_running());
  84   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  85   sw.start();
  86   BOOST_TEST(sw.is_running());
  87   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  88   typename Stopwatch::duration d=sw.elapsed();
  89   BOOST_TEST(sw.is_running());
  90   BOOST_TEST(d >= boost::chrono::milliseconds(100));
  91   BOOST_TEST(d < boost::chrono::milliseconds(200));
  92 }
  93
  94 template <typename Stopwatch>
  95 void check_dont_start_start()
  96 {
  97   Stopwatch sw(boost::chrono::dont_start);
  98   BOOST_TEST(!sw.is_running());
  99   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 100   sw.start();
 101   BOOST_TEST(sw.is_running());
 102   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 103   typename Stopwatch::duration d=sw.elapsed();
 104   BOOST_TEST(sw.is_running());
 105   BOOST_TEST(d >= boost::chrono::milliseconds(100));
 106   BOOST_TEST(d < boost::chrono::milliseconds(200));
 107 }
 108
 109 template <typename Stopwatch>
 110 void check_dont_start_start_stop()
 111 {
 112   Stopwatch sw(boost::chrono::dont_start);
 113   BOOST_TEST(!sw.is_running());
 114   sw.start();
 115   BOOST_TEST(sw.is_running());
 116   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 117   sw.stop();
 118   BOOST_TEST(!sw.is_running());
 119   typename Stopwatch::duration d=sw.elapsed();
 120   BOOST_TEST(!sw.is_running());
 121   BOOST_TEST(d >= boost::chrono::milliseconds(0));
 122 }
 123
 124 template <typename Stopwatch>
 125 void check_dont_start_scoped_run()
 126 {
 127   Stopwatch sw(boost::chrono::dont_start);
 128   BOOST_TEST(!sw.is_running());
 129   {
 130     typename Stopwatch::scoped_run _(sw);
 131     BOOST_TEST(sw.is_running());
 132     ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 133   }
 134   BOOST_TEST(!sw.is_running());
 135   typename Stopwatch::duration d=sw.elapsed();
 136   BOOST_TEST(!sw.is_running());
 137   BOOST_TEST(d >= boost::chrono::milliseconds(0));
 138 }
 139
 140 template <typename Stopwatch>
 141 void check_stop()
 142 {
 143   Stopwatch sw;
 144   BOOST_TEST(sw.is_running());
 145   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 146   sw.stop();
 147   BOOST_TEST(!sw.is_running());
 148   typename Stopwatch::duration d=sw.elapsed();
 149   BOOST_TEST(!sw.is_running());
 150   BOOST_TEST(d == boost::chrono::milliseconds(0));
 151 }
 152
 153 template <typename Stopwatch>
 154 void check_stop_stop()
 155 {
 156   Stopwatch sw;
 157   BOOST_TEST(sw.is_running());
 158   ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
 159   sw.stop();
 160   BOOST_TEST(!sw.is_running());
 161   typename Stopwatch::duration d=sw.elapsed();
 162   BOOST_TEST(!sw.is_running());
 163   BOOST_TEST(d == boost::chrono::milliseconds(0));
 164   sw.stop();
 165   BOOST_TEST(!sw.is_running());
 166   d=sw.elapsed();
 167   BOOST_TEST(!sw.is_running());
 168   BOOST_TEST(d == boost::chrono::milliseconds(0));
 169 }
 170
 171
 172
 173 struct file_line {
 174   file_line(const char* file, std::size_t line)
 175   : fmt("%1%[%2%] Elapsed time:")
 176   {
 177     fmt % file % line;
 178   }
 179   ~file_line()
 180   {
 181     std::cout << fmt;
 182   }
 183   boost::format fmt;
 184
 185 };
 186
 187 template <typename Reporter>
 188 void check_file_line2()
 189 {
 190   Reporter _("%1%\n");
 191   file_line fl(__FILE__, __LINE__);
 192   ex::sleep_for<typename Reporter::clock>(milliseconds(100));
 193
 194 }
 195 template <typename Reporter>
 196 void check_file_line()
 197 {
 198   Reporter rp("%1%[%2%] Elapsed time: %3%\n");
 199   rp.format() % __FILE__ % __LINE__;
 200
 201   ex::sleep_for<typename Reporter::clock>(milliseconds(100));
 202
 203 }
 204
 205 template <typename Reporter>
 206 void check_report()
 207 {
 208   Reporter sw;
 209   ex::sleep_for<typename Reporter::clock>(milliseconds(100));
 210   sw.report();
 211 }
 212
 213
 214
 215
 216 template <typename Clock>
 217 void check_all()
 218 {
 219   typedef stopclock<Clock> Reporter;
 220   typedef stopclock<Clock, no_memory<typename Clock::duration>, elapsed_formatter > ReporterE;
 221
 222   check_invariants<Reporter>();
 223   check_default_constructor<Reporter>();
 224 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
 225   check_constructor_ec<Reporter>();
 226   check_constructor_throws<Reporter>();
 227 #endif
 228   check_elapsed<Reporter>();
 229
 230   check_report<Reporter>();
 231   check_file_line<ReporterE>();
 232
 233   check_start_start<Reporter>();
 234   check_dont_start_constructor<Reporter>();
 235   check_dont_start_start<Reporter>();
 236   check_dont_start_start_stop<Reporter>();
 237   check_dont_start_scoped_run<Reporter>();
 238   check_stop<Reporter>();
 239   check_stop_stop<Reporter>();
 240
 241
 242 }
 243
 244 int main()
 245 {
 246   typedef stopclock<high_resolution_clock > Reporter;
 247
 248   static Reporter::formatter_type fmtr;
 249
 250   //Reporter _(fmtr);
 251   Reporter _;
 252
 253   check_all<ex::cycle_count<1500> >();
 254
 255   return boost::report_errors();
 256 }