mxlib
c++ tools for analyzing astronomical data and other tasks by Jared R. Males. [git repo]
Loading...
Searching...
No Matches
timeUtils_test.cpp
Go to the documentation of this file.
1/** \file timeUtils_test.cpp
2 */
3#include "../../catch2/catch.hpp"
4
5#include "../../../include/sys/timeUtils.hpp"
6
7/** Verify operation of get_curr_time. This only
8 * checks for increasing time on subsequent calls.
9 *
10 * \anchor tests_sys_timeUtils_get_curr_time
11 */
12SCENARIO( "getting the current time in seconds", "[timeutils]" )
13{
14 GIVEN( "getting the time" )
15 {
16 WHEN( "the same timespec is used" )
17 {
18 timespec ts;
19 double t0 = mx::sys::get_curr_time( ts );
20 REQUIRE( t0 > 0 );
21 std::cout << std::endl; // Do something to make sure some time passes.
22 double t1 = mx::sys::get_curr_time( ts );
23
24 REQUIRE( t1 > t0 );
25 }
26
27 WHEN( "no timespec is provided" )
28 {
29 double t0 = mx::sys::get_curr_time();
30 REQUIRE( t0 > 0 );
31 std::cout << std::endl; // Do something to make sure some time passes.
32 double t1 = mx::sys::get_curr_time();
33
34 REQUIRE( t1 > t0 );
35 }
36 }
37}
38
39/** Verify operation of thread sleep functions.
40 *
41 * Uses mx::sys::get_curr_time to verify duration of sleep.
42 *
43 * \anchor tests_sys_timeUtils_sleep
44 */
45SCENARIO( "putting a thread to sleep", "[timeutils]" )
46{
47 GIVEN( "sleeping for 1 second" )
48 {
49 WHEN( "sleeping in seconds" )
50 {
51 double t0 = mx::sys::get_curr_time();
52 mx::sys::sleep( 1 );
53 double t1 = mx::sys::get_curr_time();
54
55 REQUIRE( t1 >= t0 + 1.0 );
56 }
57 WHEN( "sleeping in milliseconds" )
58 {
59 double t0 = mx::sys::get_curr_time();
60 mx::sys::milliSleep( 1000 );
61 double t1 = mx::sys::get_curr_time();
62
63 REQUIRE( t1 >= t0 + 1.0 );
64 }
65 WHEN( "sleeping in microseconds" )
66 {
67 double t0 = mx::sys::get_curr_time();
68 mx::sys::microSleep( 1000000 );
69 double t1 = mx::sys::get_curr_time();
70
71 REQUIRE( t1 >= t0 + 1.0 );
72 }
73 WHEN( "sleeping in nanoseconds" )
74 {
75 double t0 = mx::sys::get_curr_time();
76 mx::sys::nanoSleep( 1000000000 );
77 double t1 = mx::sys::get_curr_time();
78
79 REQUIRE( t1 >= t0 + 1.0 );
80 }
81 }
82}
83
84/** Verify operation of timespecAddNsec.
85 *
86 * \anchor tests_sys_timeUtils_timespecAddNsec
87 */
88SCENARIO( "adding time to a timespec", "[timeutils]" )
89{
90 GIVEN( "a timespec" )
91 {
92 WHEN( "adding less than 1e9 nanoseconds" )
93 {
94 timespec ts;
95 ts.tv_sec = 1;
96 ts.tv_nsec = 0;
97
98 mx::sys::timespecAddNsec( ts, 10 );
99 REQUIRE( ts.tv_sec == 1 );
100 REQUIRE( ts.tv_nsec == 10 );
101
102 mx::sys::timespecAddNsec( ts, 100 );
103 REQUIRE( ts.tv_sec == 1 );
104 REQUIRE( ts.tv_nsec == 110 );
105
106 mx::sys::timespecAddNsec( ts, 1000 );
107 REQUIRE( ts.tv_sec == 1 );
108 REQUIRE( ts.tv_nsec == 1110 );
109
110 mx::sys::timespecAddNsec( ts, 10000 );
111 REQUIRE( ts.tv_sec == 1 );
112 REQUIRE( ts.tv_nsec == 11110 );
113
114 mx::sys::timespecAddNsec( ts, 100000 );
115 REQUIRE( ts.tv_sec == 1 );
116 REQUIRE( ts.tv_nsec == 111110 );
117
118 mx::sys::timespecAddNsec( ts, 1000000 );
119 REQUIRE( ts.tv_sec == 1 );
120 REQUIRE( ts.tv_nsec == 1111110 );
121
122 mx::sys::timespecAddNsec( ts, 10000000 );
123 REQUIRE( ts.tv_sec == 1 );
124 REQUIRE( ts.tv_nsec == 11111110 );
125
126 mx::sys::timespecAddNsec( ts, 100000000 );
127 REQUIRE( ts.tv_sec == 1 );
128 REQUIRE( ts.tv_nsec == 111111110 );
129 }
130
131 WHEN( "adding more than 1e9 nanoseconds but less than 2e9" )
132 {
133 timespec ts;
134 ts.tv_sec = 1;
135 ts.tv_nsec = 0;
136
137 mx::sys::timespecAddNsec( ts, 1000000000 );
138 REQUIRE( ts.tv_sec == 2 );
139 REQUIRE( ts.tv_nsec == 0 );
140
141 mx::sys::timespecAddNsec( ts, 1000000000 + 10 );
142 REQUIRE( ts.tv_sec == 3 );
143 REQUIRE( ts.tv_nsec == 10 );
144
145 mx::sys::timespecAddNsec( ts, 1000000000 + 100 );
146 REQUIRE( ts.tv_sec == 4 );
147 REQUIRE( ts.tv_nsec == 110 );
148
149 mx::sys::timespecAddNsec( ts, 1000000000 + 1000 );
150 REQUIRE( ts.tv_sec == 5 );
151 REQUIRE( ts.tv_nsec == 1110 );
152
153 mx::sys::timespecAddNsec( ts, 1000000000 + 10000 );
154 REQUIRE( ts.tv_sec == 6 );
155 REQUIRE( ts.tv_nsec == 11110 );
156
157 mx::sys::timespecAddNsec( ts, 1000000000 + 100000 );
158 REQUIRE( ts.tv_sec == 7 );
159 REQUIRE( ts.tv_nsec == 111110 );
160
161 mx::sys::timespecAddNsec( ts, 1000000000 + 1000000 );
162 REQUIRE( ts.tv_sec == 8 );
163 REQUIRE( ts.tv_nsec == 1111110 );
164
165 mx::sys::timespecAddNsec( ts, 1000000000 + 10000000 );
166 REQUIRE( ts.tv_sec == 9 );
167 REQUIRE( ts.tv_nsec == 11111110 );
168
169 mx::sys::timespecAddNsec( ts, 1000000000 + 100000000 );
170 REQUIRE( ts.tv_sec == 10 );
171 REQUIRE( ts.tv_nsec == 111111110 );
172 }
173
174 WHEN( "adding more than 2e9" )
175 {
176 timespec ts;
177 ts.tv_sec = 1;
178 ts.tv_nsec = 0;
179
180 mx::sys::timespecAddNsec( ts, 2000000010 );
181 REQUIRE( ts.tv_sec == 3 );
182 REQUIRE( ts.tv_nsec == 10 );
183 }
184 }
185}
186
187/** Verify parsing of a formatted time string.
188 * Tests parsing of a string of format hh:mm:ss.s
189 *
190 * \anchor tests_sys_timeUtils_parse_hms
191 */
192SCENARIO( "parsing a formatted time string", "[timeutils]" )
193{
194 GIVEN( "a valid time string" )
195 {
196 WHEN( "integer seconds" )
197 {
198 float hr;
199 float mn;
200 float sec;
201
202 mx::sys::parse_hms( hr, mn, sec, "1:2:3" );
203
204 REQUIRE( hr == 1 );
205 REQUIRE( mn == 2 );
206 REQUIRE( sec == 3 );
207 }
208
209 WHEN( "floating seconds" )
210 {
211 float hr;
212 float mn;
213 float sec;
214
215 mx::sys::parse_hms( hr, mn, sec, "1:2:3.23" );
216
217 REQUIRE( hr == 1 );
218 REQUIRE( mn == 2 );
219 REQUIRE( fabs( sec - 3.23 ) < 1e-7 );
220 }
221
222 WHEN( "negative hour" )
223 {
224 float hr;
225 float mn;
226 float sec;
227
228 mx::sys::parse_hms( hr, mn, sec, "-1:2:3.23" );
229
230 REQUIRE( hr == -1 );
231 REQUIRE( mn == -2 );
232 REQUIRE( fabs( sec - -3.23 ) < 1e-7 );
233 }
234
235 WHEN( "0 pads" )
236 {
237 float hr;
238 float mn;
239 float sec;
240
241 mx::sys::parse_hms( hr, mn, sec, "01:02:03.23" );
242
243 REQUIRE( hr == 1 );
244 REQUIRE( mn == 2 );
245 REQUIRE( fabs( sec - 3.23 ) < 1e-7 );
246 }
247 }
248}
249
250/** Verify calculation of MJD.
251 *
252 * \anchor tests_sys_timeUtils_Cal2mjd
253 */
254SCENARIO( "calculating MJD from a Gregorian date", "[timeutils]" )
255{
256 GIVEN( "a valid Gregorian date" )
257 {
258 WHEN( "integer seconds" )
259 {
260 double mjd = mx::sys::Cal2mjd( 2020, 12, 31, 0, 0, 0 );
261 REQUIRE( mjd == 59214.0 );
262 }
263 }
264
265 GIVEN( "a valid Gregorian date" )
266 {
267 WHEN( "floating seconds" )
268 {
269 double mjd = mx::sys::Cal2mjd( 2020, 12, 31, 0, 0, 10.2357 );
270 REQUIRE( fabs( mjd - 59214.00011846875 ) < 1e-14 );
271 }
272 }
273}
274
275/** Verify parsing of an ISO 8601 time string.
276 *
277 * \anchor tests_sys_timeUtils_ISO8601dateBreakdown
278 */
279SCENARIO( "parsing an ISO 8601 time string", "[timeutils]" )
280{
281 GIVEN( "a valid ISO 8601 time string" )
282 {
283 WHEN( "integer seconds" )
284 {
285 int yr, mon, day, hr, min;
286 double sec;
287
288 int rv = mx::sys::ISO8601dateBreakdown( yr, mon, day, hr, min, sec, "2020-12-31T00:00:00" );
289
290 REQUIRE( rv == 0 );
291 REQUIRE( yr == 2020 );
292 REQUIRE( mon == 12 );
293 REQUIRE( day == 31 );
294 REQUIRE( hr == 0 );
295 REQUIRE( min == 0 );
296 REQUIRE( sec == 0 );
297 }
298
299 WHEN( "fractional seconds" )
300 {
301 int yr, mon, day, hr, min;
302 double sec;
303
304 int rv = mx::sys::ISO8601dateBreakdown( yr, mon, day, hr, min, sec, "2020-12-31T00:00:10.2357" );
305
306 REQUIRE( rv == 0 );
307 REQUIRE( yr == 2020 );
308 REQUIRE( mon == 12 );
309 REQUIRE( day == 31 );
310 REQUIRE( hr == 0 );
311 REQUIRE( min == 0 );
312 REQUIRE( fabs( sec - 10.2357 ) < 1e-14 );
313 }
314 }
315
316 GIVEN( "an invalid ISO 8601 time string" )
317 {
318 WHEN( "string too short" )
319 {
320 int yr, mon, day, hr, min;
321 double sec;
322
323 int rv = mx::sys::ISO8601dateBreakdown( yr, mon, day, hr, min, sec, "2020-12-31" );
324
325 REQUIRE( rv == -4 );
326 }
327 }
328}
329
330/** Verify conversion of an ISO 8601 time string to MJD.
331 *
332 * \anchor tests_sys_timeUtils_ISO8601date2mjd
333 */
334SCENARIO( "coverting an ISO 8601 time string to MJD", "[timeutils]" )
335{
336 GIVEN( "a valid ISO 8601 time string" )
337 {
338 WHEN( "integer seconds" )
339 {
340 double mjd = mx::sys::ISO8601date2mjd( "2020-12-31T00:00:00" );
341
342 REQUIRE( mjd == 59214.0 );
343 }
344
345 WHEN( "fractional seconds" )
346 {
347 double mjd = mx::sys::ISO8601date2mjd( "2020-12-31T00:00:10.2357" );
348
349 REQUIRE( fabs( mjd - 59214.00011846875 ) < 1e-14 );
350 }
351 }
352}
mx::sys::nanoSleep
void nanoSleep(unsigned nsec)
Sleep for a specified period in nanoseconds.
Definition timeUtils.cpp:66
mx::sys::sleep
void sleep(unsigned sec)
Sleep for a specified period in seconds.
Definition timeUtils.cpp:51
mx::sys::milliSleep
void milliSleep(unsigned msec)
Sleep for a specified period in milliseconds.
Definition timeUtils.cpp:56
mx::sys::microSleep
void microSleep(unsigned usec)
Sleep for a specified period in microseconds.
Definition timeUtils.cpp:61
mx::sys::ISO8601dateBreakdown
int ISO8601dateBreakdown(int &yr, int &mon, int &day, int &hr, int &min, double &sec, const std::string &fdate)
Parse an ISO8601 date of the form "YYYY-MM-DDTHH:MM:SS.S" into the individual components.
Definition timeUtils.cpp:98
mx::sys::timespecAddNsec
void timespecAddNsec(timespec &ts, unsigned nsec)
Adds a time offset to an existing timespec.
Definition timeUtils.cpp:71
mx::sys::parse_hms
void parse_hms(floatT &h, floatT &m, floatT &s, const std::string &hmsstr)
Definition timeUtils.hpp:153
mx::sys::get_curr_time
typeT get_curr_time()
Get the current system time in seconds.
Definition timeUtils.hpp:90
mx::sys::Cal2mjd
double Cal2mjd(int yr, int mon, int day, int hr, int min, double sec)
Converts a Gregorian calendar date into modified Julian date (MJD).
Definition timeUtils.cpp:83
mx::sys::ISO8601date2mjd
double ISO8601date2mjd(const std::string &fdate)
Parse an ISO8601 date of the form "YYYY-MM-DDTHH:MM:SS.S" and return the modified Julian date (MJD)
Definition timeUtils.cpp:116
SCENARIO
SCENARIO("getting the current time in seconds", "[timeutils]")
Definition timeUtils_test.cpp:12