[ceph.git] / ceph / src / boost / libs / chrono / stopwatches / test / stopwatch / basic_stopwatch_last_lap_pass.cpp

//  Copyright 2010-2011 Vicente J. Botet Escriba
//  Distributed under the Boost Software License, Version 1.0.
//  See http://www.boost.org/LICENSE_1_0.txt

#define BOOST_CHRONO_VERSION 2

#include <iostream>
#include <boost/type_traits/is_same.hpp>
#include <boost/chrono/stopwatches/stopwatch.hpp>
#include <boost/chrono/stopwatches/collectors/last_lap.hpp>
#include "../cycle_count.hpp"
#include <boost/detail/lightweight_test.hpp>

#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif


template <typename Stopwatch>
void check_invariants()
{
    BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Stopwatch::rep, typename Stopwatch::clock::duration::rep>::value), NOTHING, ());
    BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Stopwatch::period, typename Stopwatch::clock::duration::period>::value), NOTHING, ());
    BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Stopwatch::duration, typename Stopwatch::clock::time_point::duration>::value), NOTHING, ());
    BOOST_CHRONO_STATIC_ASSERT(Stopwatch::is_steady == Stopwatch::clock::is_steady, NOTHING, ());
}

template <typename Stopwatch>
void check_default_constructor()
{
  Stopwatch sw;
  BOOST_TEST(sw.is_running());
  BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
}

template <typename Stopwatch>
void check_dont_start_constructor()
{
  Stopwatch sw(boost::chrono::dont_start);
  BOOST_TEST(!sw.is_running());
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  typename Stopwatch::duration d=sw.elapsed();
  BOOST_TEST(d == Stopwatch::duration::zero());
  BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
}

#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
template <typename Stopwatch>
void check_constructor_ec()
{
  boost::system::error_code ec;
  Stopwatch sw(ec);
  BOOST_TEST(sw.is_running());
  BOOST_TEST(ec.value()==0);
  BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
}

template <typename Stopwatch>
void check_constructor_throws()
{
  Stopwatch sw(boost::throws());
  BOOST_TEST(sw.is_running());
  BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
}
#endif

template <typename Stopwatch>
void check_elapsed()
{
  Stopwatch sw;
  BOOST_TEST(sw.is_running());
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  typename Stopwatch::duration d=sw.elapsed();
  BOOST_TEST(sw.is_running());
  BOOST_TEST(d >= boost::chrono::milliseconds(100));
  BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
}

template <typename Stopwatch>
void check_start_start()
{
  Stopwatch sw;
  BOOST_TEST(sw.is_running());
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  sw.start();
  BOOST_TEST(sw.is_running());
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  typename Stopwatch::duration d=sw.elapsed();
  BOOST_TEST(sw.is_running());
  BOOST_TEST(d >= boost::chrono::milliseconds(100));
  BOOST_TEST(d < boost::chrono::milliseconds(200));
  BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
}

template <typename Stopwatch>
void check_dont_start_start()
{
  Stopwatch sw(boost::chrono::dont_start);
  BOOST_TEST(!sw.is_running());
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  sw.start();
  BOOST_TEST(sw.is_running());
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  typename Stopwatch::duration d=sw.elapsed();
  BOOST_TEST(sw.is_running());
  BOOST_TEST(d >= boost::chrono::milliseconds(100));
  BOOST_TEST(d < boost::chrono::milliseconds(200));
  BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
}

template <typename Stopwatch>
void check_dont_start_start_stop()
{
  Stopwatch sw(boost::chrono::dont_start);
  BOOST_TEST(!sw.is_running());
  sw.start();
  BOOST_TEST(sw.is_running());
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  sw.stop();
  BOOST_TEST(!sw.is_running());
  typename Stopwatch::duration d=sw.elapsed();
  BOOST_TEST(!sw.is_running());
  BOOST_TEST(d >= boost::chrono::milliseconds(0));
  BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
}

template <typename Stopwatch>
void check_dont_start_scoped_run()
{
  Stopwatch sw(boost::chrono::dont_start);
  BOOST_TEST(!sw.is_running());
  {
    typename Stopwatch::scoped_run _(sw);
    BOOST_TEST(sw.is_running());
    ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  }
  BOOST_TEST(!sw.is_running());
  typename Stopwatch::duration d=sw.elapsed();
  BOOST_TEST(!sw.is_running());
  BOOST_TEST(d >= boost::chrono::milliseconds(0));
  BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));

  BOOST_TEST(!sw.is_running());
  {
    typename Stopwatch::scoped_run _(sw);
    BOOST_TEST(sw.is_running());
    ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(200));
  }
  BOOST_TEST(!sw.is_running());
  d=sw.elapsed();
  BOOST_TEST(!sw.is_running());
  BOOST_TEST(d >= boost::chrono::milliseconds(0));
  BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(200));
}

template <typename Stopwatch>
void check_stop()
{
  Stopwatch sw;
  BOOST_TEST(sw.is_running());
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  sw.stop();
  BOOST_TEST(!sw.is_running());
  typename Stopwatch::duration d=sw.elapsed();
  BOOST_TEST(!sw.is_running());
  BOOST_TEST(d == boost::chrono::milliseconds(0));
  BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
}

template <typename Stopwatch>
void check_stop_stop()
{
  Stopwatch sw;
  BOOST_TEST(sw.is_running());
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  sw.stop();
  BOOST_TEST(!sw.is_running());
  typename Stopwatch::duration d=sw.elapsed();
  BOOST_TEST(!sw.is_running());
  BOOST_TEST(d == boost::chrono::milliseconds(0));
  BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
  ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
  sw.stop();
  BOOST_TEST(!sw.is_running());
  d=sw.elapsed();
  BOOST_TEST(!sw.is_running());
  BOOST_TEST(d == boost::chrono::milliseconds(0));
  BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
}


template <typename Stopwatch>
void check_all()
{
  check_invariants<Stopwatch>();
  check_default_constructor<Stopwatch>();
#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  check_constructor_ec<Stopwatch>();
  check_constructor_throws<Stopwatch>();
#endif
  check_elapsed<Stopwatch>();

  check_start_start<Stopwatch>();
  check_dont_start_constructor<Stopwatch>();
  check_dont_start_start<Stopwatch>();
  check_dont_start_start_stop<Stopwatch>();
  check_dont_start_scoped_run<Stopwatch>();
  check_stop<Stopwatch>();
  check_stop_stop<Stopwatch>();

}


int main()
{
  std::cout << "cycle_count=";
  check_all<boost::chrono::stopwatch< ex::cycle_count<1500>, boost::chrono::last_lap<ex::cycle_count<1500>::duration> > >();
  return boost::report_errors();
}
Commit	Line	Data
7c673cae FG	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/last_lap.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	}
	35
	36	template <typename Stopwatch>
	37	void check_dont_start_constructor()
	38	{
	39	Stopwatch sw(boost::chrono::dont_start);
	40	BOOST_TEST(!sw.is_running());
	41	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
	42	typename Stopwatch::duration d=sw.elapsed();
	43	BOOST_TEST(d == Stopwatch::duration::zero());
	44	BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
	45	}
	46
	47	#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
	48	template <typename Stopwatch>
	49	void check_constructor_ec()
	50	{
	51	boost::system::error_code ec;
	52	Stopwatch sw(ec);
	53	BOOST_TEST(sw.is_running());
	54	BOOST_TEST(ec.value()==0);
	55	BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
	56	}
	57
	58	template <typename Stopwatch>
	59	void check_constructor_throws()
	60	{
	61	Stopwatch sw(boost::throws());
	62	BOOST_TEST(sw.is_running());
	63	BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
	64	}
65	#endif
66
67	template <typename Stopwatch>
68	void check_elapsed()
69	{
70	Stopwatch sw;
71	BOOST_TEST(sw.is_running());
72	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
73	typename Stopwatch::duration d=sw.elapsed();
74	BOOST_TEST(sw.is_running());
75	BOOST_TEST(d >= boost::chrono::milliseconds(100));
76	BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
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	BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
93	}
94
95	template <typename Stopwatch>
96	void check_dont_start_start()
97	{
98	Stopwatch sw(boost::chrono::dont_start);
99	BOOST_TEST(!sw.is_running());
100	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
101	sw.start();
102	BOOST_TEST(sw.is_running());
103	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
104	typename Stopwatch::duration d=sw.elapsed();
105	BOOST_TEST(sw.is_running());
106	BOOST_TEST(d >= boost::chrono::milliseconds(100));
107	BOOST_TEST(d < boost::chrono::milliseconds(200));
108	BOOST_TEST(sw.get_laps_collector().last()==Stopwatch::duration::zero());
109	}
110
111	template <typename Stopwatch>
112	void check_dont_start_start_stop()
113	{
114	Stopwatch sw(boost::chrono::dont_start);
115	BOOST_TEST(!sw.is_running());
116	sw.start();
117	BOOST_TEST(sw.is_running());
118	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
119	sw.stop();
120	BOOST_TEST(!sw.is_running());
121	typename Stopwatch::duration d=sw.elapsed();
122	BOOST_TEST(!sw.is_running());
123	BOOST_TEST(d >= boost::chrono::milliseconds(0));
124	BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
125	}
126
127	template <typename Stopwatch>
128	void check_dont_start_scoped_run()
129	{
130	Stopwatch sw(boost::chrono::dont_start);
131	BOOST_TEST(!sw.is_running());
132	{
133	typename Stopwatch::scoped_run _(sw);
134	BOOST_TEST(sw.is_running());
135	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
136	}
137	BOOST_TEST(!sw.is_running());
138	typename Stopwatch::duration d=sw.elapsed();
139	BOOST_TEST(!sw.is_running());
140	BOOST_TEST(d >= boost::chrono::milliseconds(0));
141	BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
142
143	BOOST_TEST(!sw.is_running());
144	{
145	typename Stopwatch::scoped_run _(sw);
146	BOOST_TEST(sw.is_running());
147	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(200));
148	}
149	BOOST_TEST(!sw.is_running());
150	d=sw.elapsed();
151	BOOST_TEST(!sw.is_running());
152	BOOST_TEST(d >= boost::chrono::milliseconds(0));
153	BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(200));
154	}
155
156	template <typename Stopwatch>
157	void check_stop()
158	{
159	Stopwatch sw;
160	BOOST_TEST(sw.is_running());
161	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
162	sw.stop();
163	BOOST_TEST(!sw.is_running());
164	typename Stopwatch::duration d=sw.elapsed();
165	BOOST_TEST(!sw.is_running());
166	BOOST_TEST(d == boost::chrono::milliseconds(0));
167	BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
168	}
169
170	template <typename Stopwatch>
171	void check_stop_stop()
172	{
173	Stopwatch sw;
174	BOOST_TEST(sw.is_running());
175	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
176	sw.stop();
177	BOOST_TEST(!sw.is_running());
178	typename Stopwatch::duration d=sw.elapsed();
179	BOOST_TEST(!sw.is_running());
180	BOOST_TEST(d == boost::chrono::milliseconds(0));
181	BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
182	ex::sleep_for<typename Stopwatch::clock>(boost::chrono::milliseconds(100));
183	sw.stop();
184	BOOST_TEST(!sw.is_running());
185	d=sw.elapsed();
186	BOOST_TEST(!sw.is_running());
187	BOOST_TEST(d == boost::chrono::milliseconds(0));
188	BOOST_TEST(sw.get_laps_collector().last()==boost::chrono::milliseconds(100));
189	}
190
191
192	template <typename Stopwatch>
193	void check_all()
194	{
195	check_invariants<Stopwatch>();
196	check_default_constructor<Stopwatch>();
197	#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
198	check_constructor_ec<Stopwatch>();
199	check_constructor_throws<Stopwatch>();
200	#endif
201	check_elapsed<Stopwatch>();
202
203	check_start_start<Stopwatch>();
204	check_dont_start_constructor<Stopwatch>();
205	check_dont_start_start<Stopwatch>();
206	check_dont_start_start_stop<Stopwatch>();
207	check_dont_start_scoped_run<Stopwatch>();
208	check_stop<Stopwatch>();
209	check_stop_stop<Stopwatch>();
210
211	}
212
213
214	int main()
215	{
216	std::cout << "cycle_count=";
217	check_all<boost::chrono::stopwatch< ex::cycle_count<1500>, boost::chrono::last_lap<ex::cycle_count<1500>::duration> > >();
218	return boost::report_errors();
219	}