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>
check_invariants()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>
check_default_constructor()34 void check_default_constructor()
35 {
36   Stopwatch sw;
37   BOOST_TEST(sw.is_running());
38 }
39 
40 template <typename Stopwatch>
check_dont_start_constructor()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>
check_constructor_ec()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>
check_constructor_throws()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>
check_elapsed()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>
check_start_start()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>
check_dont_start_start()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>
check_dont_start_start_stop()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>
check_dont_start_scoped_run()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>
check_stop()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>
check_stop_stop()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 {
file_linefile_line174   file_line(const char* file, std::size_t line)
175   : fmt("%1%[%2%] Elapsed time:")
176   {
177     fmt % file % line;
178   }
~file_linefile_line179   ~file_line()
180   {
181     std::cout << fmt;
182   }
183   boost::format fmt;
184 
185 };
186 
187 template <typename Reporter>
check_file_line2()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>
check_file_line()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>
check_report()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>
check_all()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 
main()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 }
257