Line data Source code
1 : /* SPDX-License-Identifier: LGPL-2.1+ */
2 :
3 : #include "random-util.h"
4 : #include "serialize.h"
5 : #include "string-util.h"
6 : #include "strv.h"
7 : #include "tests.h"
8 : #include "time-util.h"
9 :
10 1 : static void test_parse_sec(void) {
11 : usec_t u;
12 :
13 1 : log_info("/* %s */", __func__);
14 :
15 1 : assert_se(parse_sec("5s", &u) >= 0);
16 1 : assert_se(u == 5 * USEC_PER_SEC);
17 1 : assert_se(parse_sec("5s500ms", &u) >= 0);
18 1 : assert_se(u == 5 * USEC_PER_SEC + 500 * USEC_PER_MSEC);
19 1 : assert_se(parse_sec(" 5s 500ms ", &u) >= 0);
20 1 : assert_se(u == 5 * USEC_PER_SEC + 500 * USEC_PER_MSEC);
21 1 : assert_se(parse_sec(" 5.5s ", &u) >= 0);
22 1 : assert_se(u == 5 * USEC_PER_SEC + 500 * USEC_PER_MSEC);
23 1 : assert_se(parse_sec(" 5.5s 0.5ms ", &u) >= 0);
24 1 : assert_se(u == 5 * USEC_PER_SEC + 500 * USEC_PER_MSEC + 500);
25 1 : assert_se(parse_sec(" .22s ", &u) >= 0);
26 1 : assert_se(u == 220 * USEC_PER_MSEC);
27 1 : assert_se(parse_sec(" .50y ", &u) >= 0);
28 1 : assert_se(u == USEC_PER_YEAR / 2);
29 1 : assert_se(parse_sec("2.5", &u) >= 0);
30 1 : assert_se(u == 2500 * USEC_PER_MSEC);
31 1 : assert_se(parse_sec(".7", &u) >= 0);
32 1 : assert_se(u == 700 * USEC_PER_MSEC);
33 1 : assert_se(parse_sec("23us", &u) >= 0);
34 1 : assert_se(u == 23);
35 1 : assert_se(parse_sec("23µs", &u) >= 0);
36 1 : assert_se(u == 23);
37 1 : assert_se(parse_sec("infinity", &u) >= 0);
38 1 : assert_se(u == USEC_INFINITY);
39 1 : assert_se(parse_sec(" infinity ", &u) >= 0);
40 1 : assert_se(u == USEC_INFINITY);
41 1 : assert_se(parse_sec("+3.1s", &u) >= 0);
42 1 : assert_se(u == 3100 * USEC_PER_MSEC);
43 1 : assert_se(parse_sec("3.1s.2", &u) >= 0);
44 1 : assert_se(u == 3300 * USEC_PER_MSEC);
45 1 : assert_se(parse_sec("3.1 .2", &u) >= 0);
46 1 : assert_se(u == 3300 * USEC_PER_MSEC);
47 1 : assert_se(parse_sec("3.1 sec .2 sec", &u) >= 0);
48 1 : assert_se(u == 3300 * USEC_PER_MSEC);
49 1 : assert_se(parse_sec("3.1 sec 1.2 sec", &u) >= 0);
50 1 : assert_se(u == 4300 * USEC_PER_MSEC);
51 :
52 1 : assert_se(parse_sec(" xyz ", &u) < 0);
53 1 : assert_se(parse_sec("", &u) < 0);
54 1 : assert_se(parse_sec(" . ", &u) < 0);
55 1 : assert_se(parse_sec(" 5. ", &u) < 0);
56 1 : assert_se(parse_sec(".s ", &u) < 0);
57 1 : assert_se(parse_sec("-5s ", &u) < 0);
58 1 : assert_se(parse_sec("-0.3s ", &u) < 0);
59 1 : assert_se(parse_sec("-0.0s ", &u) < 0);
60 1 : assert_se(parse_sec("-0.-0s ", &u) < 0);
61 1 : assert_se(parse_sec("0.-0s ", &u) < 0);
62 1 : assert_se(parse_sec("3.-0s ", &u) < 0);
63 1 : assert_se(parse_sec(" infinity .7", &u) < 0);
64 1 : assert_se(parse_sec(".3 infinity", &u) < 0);
65 1 : assert_se(parse_sec("3.+1s", &u) < 0);
66 1 : assert_se(parse_sec("3. 1s", &u) < 0);
67 1 : assert_se(parse_sec("3.s", &u) < 0);
68 1 : assert_se(parse_sec("12.34.56", &u) < 0);
69 1 : assert_se(parse_sec("12..34", &u) < 0);
70 1 : assert_se(parse_sec("..1234", &u) < 0);
71 1 : assert_se(parse_sec("1234..", &u) < 0);
72 1 : }
73 :
74 1 : static void test_parse_sec_fix_0(void) {
75 : usec_t u;
76 :
77 1 : log_info("/* %s */", __func__);
78 :
79 1 : assert_se(parse_sec_fix_0("5s", &u) >= 0);
80 1 : assert_se(u == 5 * USEC_PER_SEC);
81 1 : assert_se(parse_sec_fix_0("0s", &u) >= 0);
82 1 : assert_se(u == USEC_INFINITY);
83 1 : assert_se(parse_sec_fix_0("0", &u) >= 0);
84 1 : assert_se(u == USEC_INFINITY);
85 1 : assert_se(parse_sec_fix_0(" 0", &u) >= 0);
86 1 : assert_se(u == USEC_INFINITY);
87 1 : }
88 :
89 1 : static void test_parse_sec_def_infinity(void) {
90 : usec_t u;
91 :
92 1 : log_info("/* %s */", __func__);
93 :
94 1 : assert_se(parse_sec_def_infinity("5s", &u) >= 0);
95 1 : assert_se(u == 5 * USEC_PER_SEC);
96 1 : assert_se(parse_sec_def_infinity("", &u) >= 0);
97 1 : assert_se(u == USEC_INFINITY);
98 1 : assert_se(parse_sec_def_infinity(" ", &u) >= 0);
99 1 : assert_se(u == USEC_INFINITY);
100 1 : assert_se(parse_sec_def_infinity("0s", &u) >= 0);
101 1 : assert_se(u == 0);
102 1 : assert_se(parse_sec_def_infinity("0", &u) >= 0);
103 1 : assert_se(u == 0);
104 1 : assert_se(parse_sec_def_infinity(" 0", &u) >= 0);
105 1 : assert_se(u == 0);
106 1 : assert_se(parse_sec_def_infinity("-5s", &u) < 0);
107 1 : }
108 :
109 1 : static void test_parse_time(void) {
110 : usec_t u;
111 :
112 1 : log_info("/* %s */", __func__);
113 :
114 1 : assert_se(parse_time("5", &u, 1) >= 0);
115 1 : assert_se(u == 5);
116 :
117 1 : assert_se(parse_time("5", &u, USEC_PER_MSEC) >= 0);
118 1 : assert_se(u == 5 * USEC_PER_MSEC);
119 :
120 1 : assert_se(parse_time("5", &u, USEC_PER_SEC) >= 0);
121 1 : assert_se(u == 5 * USEC_PER_SEC);
122 :
123 1 : assert_se(parse_time("5s", &u, 1) >= 0);
124 1 : assert_se(u == 5 * USEC_PER_SEC);
125 :
126 1 : assert_se(parse_time("5s", &u, USEC_PER_SEC) >= 0);
127 1 : assert_se(u == 5 * USEC_PER_SEC);
128 :
129 1 : assert_se(parse_time("5s", &u, USEC_PER_MSEC) >= 0);
130 1 : assert_se(u == 5 * USEC_PER_SEC);
131 :
132 1 : assert_se(parse_time("11111111111111y", &u, 1) == -ERANGE);
133 1 : assert_se(parse_time("1.1111111111111y", &u, 1) >= 0);
134 1 : }
135 :
136 1 : static void test_parse_nsec(void) {
137 : nsec_t u;
138 :
139 1 : log_info("/* %s */", __func__);
140 :
141 1 : assert_se(parse_nsec("5s", &u) >= 0);
142 1 : assert_se(u == 5 * NSEC_PER_SEC);
143 1 : assert_se(parse_nsec("5s500ms", &u) >= 0);
144 1 : assert_se(u == 5 * NSEC_PER_SEC + 500 * NSEC_PER_MSEC);
145 1 : assert_se(parse_nsec(" 5s 500ms ", &u) >= 0);
146 1 : assert_se(u == 5 * NSEC_PER_SEC + 500 * NSEC_PER_MSEC);
147 1 : assert_se(parse_nsec(" 5.5s ", &u) >= 0);
148 1 : assert_se(u == 5 * NSEC_PER_SEC + 500 * NSEC_PER_MSEC);
149 1 : assert_se(parse_nsec(" 5.5s 0.5ms ", &u) >= 0);
150 1 : assert_se(u == 5 * NSEC_PER_SEC + 500 * NSEC_PER_MSEC + 500 * NSEC_PER_USEC);
151 1 : assert_se(parse_nsec(" .22s ", &u) >= 0);
152 1 : assert_se(u == 220 * NSEC_PER_MSEC);
153 1 : assert_se(parse_nsec(" .50y ", &u) >= 0);
154 1 : assert_se(u == NSEC_PER_YEAR / 2);
155 1 : assert_se(parse_nsec("2.5", &u) >= 0);
156 1 : assert_se(u == 2);
157 1 : assert_se(parse_nsec(".7", &u) >= 0);
158 1 : assert_se(u == 0);
159 1 : assert_se(parse_nsec("infinity", &u) >= 0);
160 1 : assert_se(u == NSEC_INFINITY);
161 1 : assert_se(parse_nsec(" infinity ", &u) >= 0);
162 1 : assert_se(u == NSEC_INFINITY);
163 1 : assert_se(parse_nsec("+3.1s", &u) >= 0);
164 1 : assert_se(u == 3100 * NSEC_PER_MSEC);
165 1 : assert_se(parse_nsec("3.1s.2", &u) >= 0);
166 1 : assert_se(u == 3100 * NSEC_PER_MSEC);
167 1 : assert_se(parse_nsec("3.1 .2s", &u) >= 0);
168 1 : assert_se(u == 200 * NSEC_PER_MSEC + 3);
169 1 : assert_se(parse_nsec("3.1 sec .2 sec", &u) >= 0);
170 1 : assert_se(u == 3300 * NSEC_PER_MSEC);
171 1 : assert_se(parse_nsec("3.1 sec 1.2 sec", &u) >= 0);
172 1 : assert_se(u == 4300 * NSEC_PER_MSEC);
173 :
174 1 : assert_se(parse_nsec(" xyz ", &u) < 0);
175 1 : assert_se(parse_nsec("", &u) < 0);
176 1 : assert_se(parse_nsec(" . ", &u) < 0);
177 1 : assert_se(parse_nsec(" 5. ", &u) < 0);
178 1 : assert_se(parse_nsec(".s ", &u) < 0);
179 1 : assert_se(parse_nsec(" infinity .7", &u) < 0);
180 1 : assert_se(parse_nsec(".3 infinity", &u) < 0);
181 1 : assert_se(parse_nsec("-5s ", &u) < 0);
182 1 : assert_se(parse_nsec("-0.3s ", &u) < 0);
183 1 : assert_se(parse_nsec("-0.0s ", &u) < 0);
184 1 : assert_se(parse_nsec("-0.-0s ", &u) < 0);
185 1 : assert_se(parse_nsec("0.-0s ", &u) < 0);
186 1 : assert_se(parse_nsec("3.-0s ", &u) < 0);
187 1 : assert_se(parse_nsec(" infinity .7", &u) < 0);
188 1 : assert_se(parse_nsec(".3 infinity", &u) < 0);
189 1 : assert_se(parse_nsec("3.+1s", &u) < 0);
190 1 : assert_se(parse_nsec("3. 1s", &u) < 0);
191 1 : assert_se(parse_nsec("3.s", &u) < 0);
192 1 : assert_se(parse_nsec("12.34.56", &u) < 0);
193 1 : assert_se(parse_nsec("12..34", &u) < 0);
194 1 : assert_se(parse_nsec("..1234", &u) < 0);
195 1 : assert_se(parse_nsec("1234..", &u) < 0);
196 1 : assert_se(parse_nsec("1111111111111y", &u) == -ERANGE);
197 1 : assert_se(parse_nsec("1.111111111111y", &u) >= 0);
198 1 : }
199 :
200 66 : static void test_format_timespan_one(usec_t x, usec_t accuracy) {
201 : char l[FORMAT_TIMESPAN_MAX];
202 : const char *t;
203 : usec_t y;
204 :
205 66 : log_info(USEC_FMT" (at accuracy "USEC_FMT")", x, accuracy);
206 :
207 66 : assert_se(t = format_timespan(l, sizeof l, x, accuracy));
208 66 : log_info(" = <%s>", t);
209 :
210 66 : assert_se(parse_sec(t, &y) >= 0);
211 66 : log_info(" = "USEC_FMT, y);
212 :
213 66 : if (accuracy <= 0)
214 0 : accuracy = 1;
215 :
216 66 : assert_se(x / accuracy == y / accuracy);
217 66 : }
218 :
219 3 : static void test_format_timespan(usec_t accuracy) {
220 3 : log_info("/* %s accuracy="USEC_FMT" */", __func__, accuracy);
221 :
222 3 : test_format_timespan_one(0, accuracy);
223 3 : test_format_timespan_one(1, accuracy);
224 3 : test_format_timespan_one(1*USEC_PER_SEC, accuracy);
225 3 : test_format_timespan_one(999*USEC_PER_MSEC, accuracy);
226 3 : test_format_timespan_one(1234567, accuracy);
227 3 : test_format_timespan_one(12, accuracy);
228 3 : test_format_timespan_one(123, accuracy);
229 3 : test_format_timespan_one(1234, accuracy);
230 3 : test_format_timespan_one(12345, accuracy);
231 3 : test_format_timespan_one(123456, accuracy);
232 3 : test_format_timespan_one(1234567, accuracy);
233 3 : test_format_timespan_one(12345678, accuracy);
234 3 : test_format_timespan_one(1200000, accuracy);
235 3 : test_format_timespan_one(1230000, accuracy);
236 3 : test_format_timespan_one(1234000, accuracy);
237 3 : test_format_timespan_one(1234500, accuracy);
238 3 : test_format_timespan_one(1234560, accuracy);
239 3 : test_format_timespan_one(1234567, accuracy);
240 3 : test_format_timespan_one(986087, accuracy);
241 3 : test_format_timespan_one(500 * USEC_PER_MSEC, accuracy);
242 3 : test_format_timespan_one(9*USEC_PER_YEAR/5 - 23, accuracy);
243 3 : test_format_timespan_one(USEC_INFINITY, accuracy);
244 3 : }
245 :
246 1 : static void test_timezone_is_valid(void) {
247 1 : log_info("/* %s */", __func__);
248 :
249 1 : assert_se(timezone_is_valid("Europe/Berlin", LOG_ERR));
250 1 : assert_se(timezone_is_valid("Australia/Sydney", LOG_ERR));
251 1 : assert_se(!timezone_is_valid("Europe/Do not exist", LOG_ERR));
252 1 : }
253 :
254 1 : static void test_get_timezones(void) {
255 1 : _cleanup_strv_free_ char **zones = NULL;
256 : int r;
257 : char **zone;
258 :
259 1 : log_info("/* %s */", __func__);
260 :
261 1 : r = get_timezones(&zones);
262 1 : assert_se(r == 0);
263 :
264 350 : STRV_FOREACH(zone, zones) {
265 349 : log_info("zone: %s", *zone);
266 349 : assert_se(timezone_is_valid(*zone, LOG_ERR));
267 : }
268 1 : }
269 :
270 1 : static void test_usec_add(void) {
271 1 : log_info("/* %s */", __func__);
272 :
273 1 : assert_se(usec_add(0, 0) == 0);
274 1 : assert_se(usec_add(1, 4) == 5);
275 1 : assert_se(usec_add(USEC_INFINITY, 5) == USEC_INFINITY);
276 1 : assert_se(usec_add(5, USEC_INFINITY) == USEC_INFINITY);
277 1 : assert_se(usec_add(USEC_INFINITY-5, 2) == USEC_INFINITY-3);
278 1 : assert_se(usec_add(USEC_INFINITY-2, 2) == USEC_INFINITY);
279 1 : assert_se(usec_add(USEC_INFINITY-1, 2) == USEC_INFINITY);
280 1 : assert_se(usec_add(USEC_INFINITY, 2) == USEC_INFINITY);
281 1 : }
282 :
283 1 : static void test_usec_sub_unsigned(void) {
284 1 : log_info("/* %s */", __func__);
285 :
286 1 : assert_se(usec_sub_unsigned(0, 0) == 0);
287 1 : assert_se(usec_sub_unsigned(0, 2) == 0);
288 1 : assert_se(usec_sub_unsigned(0, USEC_INFINITY) == 0);
289 1 : assert_se(usec_sub_unsigned(1, 0) == 1);
290 1 : assert_se(usec_sub_unsigned(1, 1) == 0);
291 1 : assert_se(usec_sub_unsigned(1, 2) == 0);
292 1 : assert_se(usec_sub_unsigned(1, 3) == 0);
293 1 : assert_se(usec_sub_unsigned(1, USEC_INFINITY) == 0);
294 1 : assert_se(usec_sub_unsigned(USEC_INFINITY-1, 0) == USEC_INFINITY-1);
295 1 : assert_se(usec_sub_unsigned(USEC_INFINITY-1, 1) == USEC_INFINITY-2);
296 1 : assert_se(usec_sub_unsigned(USEC_INFINITY-1, 2) == USEC_INFINITY-3);
297 1 : assert_se(usec_sub_unsigned(USEC_INFINITY-1, USEC_INFINITY-2) == 1);
298 1 : assert_se(usec_sub_unsigned(USEC_INFINITY-1, USEC_INFINITY-1) == 0);
299 1 : assert_se(usec_sub_unsigned(USEC_INFINITY-1, USEC_INFINITY) == 0);
300 1 : assert_se(usec_sub_unsigned(USEC_INFINITY, 0) == USEC_INFINITY);
301 1 : assert_se(usec_sub_unsigned(USEC_INFINITY, 1) == USEC_INFINITY);
302 1 : assert_se(usec_sub_unsigned(USEC_INFINITY, 2) == USEC_INFINITY);
303 1 : assert_se(usec_sub_unsigned(USEC_INFINITY, USEC_INFINITY) == USEC_INFINITY);
304 1 : }
305 :
306 1 : static void test_usec_sub_signed(void) {
307 1 : log_info("/* %s */", __func__);
308 :
309 1 : assert_se(usec_sub_signed(0, 0) == 0);
310 1 : assert_se(usec_sub_signed(4, 1) == 3);
311 1 : assert_se(usec_sub_signed(4, 4) == 0);
312 1 : assert_se(usec_sub_signed(4, 5) == 0);
313 1 : assert_se(usec_sub_signed(USEC_INFINITY-3, -3) == USEC_INFINITY);
314 1 : assert_se(usec_sub_signed(USEC_INFINITY-3, -4) == USEC_INFINITY);
315 1 : assert_se(usec_sub_signed(USEC_INFINITY-3, -5) == USEC_INFINITY);
316 1 : assert_se(usec_sub_signed(USEC_INFINITY, 5) == USEC_INFINITY);
317 1 : }
318 :
319 1 : static void test_format_timestamp(void) {
320 : unsigned i;
321 :
322 1 : log_info("/* %s */", __func__);
323 :
324 101 : for (i = 0; i < 100; i++) {
325 100 : char buf[MAX(FORMAT_TIMESTAMP_MAX, FORMAT_TIMESPAN_MAX)];
326 : usec_t x, y;
327 :
328 100 : random_bytes(&x, sizeof(x));
329 100 : x = x % (2147483600 * USEC_PER_SEC) + 1;
330 :
331 100 : assert_se(format_timestamp(buf, sizeof(buf), x));
332 100 : log_info("%s", buf);
333 100 : assert_se(parse_timestamp(buf, &y) >= 0);
334 100 : assert_se(x / USEC_PER_SEC == y / USEC_PER_SEC);
335 :
336 100 : assert_se(format_timestamp_utc(buf, sizeof(buf), x));
337 100 : log_info("%s", buf);
338 100 : assert_se(parse_timestamp(buf, &y) >= 0);
339 100 : assert_se(x / USEC_PER_SEC == y / USEC_PER_SEC);
340 :
341 100 : assert_se(format_timestamp_us(buf, sizeof(buf), x));
342 100 : log_info("%s", buf);
343 100 : assert_se(parse_timestamp(buf, &y) >= 0);
344 100 : assert_se(x == y);
345 :
346 100 : assert_se(format_timestamp_us_utc(buf, sizeof(buf), x));
347 100 : log_info("%s", buf);
348 100 : assert_se(parse_timestamp(buf, &y) >= 0);
349 100 : assert_se(x == y);
350 :
351 100 : assert_se(format_timestamp_relative(buf, sizeof(buf), x));
352 100 : log_info("%s", buf);
353 100 : assert_se(parse_timestamp(buf, &y) >= 0);
354 :
355 : /* The two calls above will run with a slightly different local time. Make sure we are in the same
356 : * range however, but give enough leeway that this is unlikely to explode. And of course,
357 : * format_timestamp_relative() scales the accuracy with the distance from the current time up to one
358 : * month, cover for that too. */
359 100 : assert_se(y > x ? y - x : x - y <= USEC_PER_MONTH + USEC_PER_DAY);
360 : }
361 1 : }
362 :
363 6 : static void test_format_timestamp_utc_one(usec_t val, const char *result) {
364 : char buf[FORMAT_TIMESTAMP_MAX];
365 : const char *t;
366 :
367 6 : t = format_timestamp_utc(buf, sizeof(buf), val);
368 6 : assert_se(streq_ptr(t, result));
369 6 : }
370 :
371 1 : static void test_format_timestamp_utc(void) {
372 1 : log_info("/* %s */", __func__);
373 :
374 1 : test_format_timestamp_utc_one(0, NULL);
375 1 : test_format_timestamp_utc_one(1, "Thu 1970-01-01 00:00:00 UTC");
376 1 : test_format_timestamp_utc_one(USEC_PER_SEC, "Thu 1970-01-01 00:00:01 UTC");
377 :
378 : #if SIZEOF_TIME_T == 8
379 1 : test_format_timestamp_utc_one(USEC_TIMESTAMP_FORMATTABLE_MAX, "Thu 9999-12-30 23:59:59 UTC");
380 1 : test_format_timestamp_utc_one(USEC_TIMESTAMP_FORMATTABLE_MAX + 1, "--- XXXX-XX-XX XX:XX:XX");
381 : #elif SIZEOF_TIME_T == 4
382 : test_format_timestamp_utc_one(USEC_TIMESTAMP_FORMATTABLE_MAX, "Tue 2038-01-19 03:14:07 UTC");
383 : test_format_timestamp_utc_one(USEC_TIMESTAMP_FORMATTABLE_MAX + 1, "--- XXXX-XX-XX XX:XX:XX");
384 : #endif
385 :
386 1 : test_format_timestamp_utc_one(USEC_INFINITY, NULL);
387 1 : }
388 :
389 1 : static void test_deserialize_dual_timestamp(void) {
390 : int r;
391 : dual_timestamp t;
392 :
393 1 : log_info("/* %s */", __func__);
394 :
395 1 : r = deserialize_dual_timestamp("1234 5678", &t);
396 1 : assert_se(r == 0);
397 1 : assert_se(t.realtime == 1234);
398 1 : assert_se(t.monotonic == 5678);
399 :
400 1 : r = deserialize_dual_timestamp("1234x 5678", &t);
401 1 : assert_se(r == -EINVAL);
402 :
403 1 : r = deserialize_dual_timestamp("1234 5678y", &t);
404 1 : assert_se(r == -EINVAL);
405 :
406 1 : r = deserialize_dual_timestamp("-1234 5678", &t);
407 1 : assert_se(r == -EINVAL);
408 :
409 1 : r = deserialize_dual_timestamp("1234 -5678", &t);
410 1 : assert_se(r == -EINVAL);
411 :
412 : /* Check that output wasn't modified. */
413 1 : assert_se(t.realtime == 1234);
414 1 : assert_se(t.monotonic == 5678);
415 :
416 1 : r = deserialize_dual_timestamp("+123 567", &t);
417 1 : assert_se(r == 0);
418 1 : assert_se(t.realtime == 123);
419 1 : assert_se(t.monotonic == 567);
420 :
421 : /* Check that we get "infinity" on overflow. */
422 1 : r = deserialize_dual_timestamp("18446744073709551617 0", &t);
423 1 : assert_se(r == 0);
424 1 : assert_se(t.realtime == USEC_INFINITY);
425 1 : assert_se(t.monotonic == 0);
426 1 : }
427 :
428 8 : static void assert_similar(usec_t a, usec_t b) {
429 : usec_t d;
430 :
431 8 : if (a > b)
432 2 : d = a - b;
433 : else
434 6 : d = b - a;
435 :
436 8 : assert(d < 10*USEC_PER_SEC);
437 8 : }
438 :
439 1 : static void test_usec_shift_clock(void) {
440 : usec_t rt, mn, bt;
441 :
442 1 : log_info("/* %s */", __func__);
443 :
444 1 : rt = now(CLOCK_REALTIME);
445 1 : mn = now(CLOCK_MONOTONIC);
446 1 : bt = now(clock_boottime_or_monotonic());
447 :
448 1 : assert_se(usec_shift_clock(USEC_INFINITY, CLOCK_REALTIME, CLOCK_MONOTONIC) == USEC_INFINITY);
449 :
450 1 : assert_similar(usec_shift_clock(rt + USEC_PER_HOUR, CLOCK_REALTIME, CLOCK_MONOTONIC), mn + USEC_PER_HOUR);
451 1 : assert_similar(usec_shift_clock(rt + 2*USEC_PER_HOUR, CLOCK_REALTIME, clock_boottime_or_monotonic()), bt + 2*USEC_PER_HOUR);
452 1 : assert_se(usec_shift_clock(rt + 3*USEC_PER_HOUR, CLOCK_REALTIME, CLOCK_REALTIME_ALARM) == rt + 3*USEC_PER_HOUR);
453 :
454 1 : assert_similar(usec_shift_clock(mn + 4*USEC_PER_HOUR, CLOCK_MONOTONIC, CLOCK_REALTIME_ALARM), rt + 4*USEC_PER_HOUR);
455 1 : assert_similar(usec_shift_clock(mn + 5*USEC_PER_HOUR, CLOCK_MONOTONIC, clock_boottime_or_monotonic()), bt + 5*USEC_PER_HOUR);
456 1 : assert_se(usec_shift_clock(mn + 6*USEC_PER_HOUR, CLOCK_MONOTONIC, CLOCK_MONOTONIC) == mn + 6*USEC_PER_HOUR);
457 :
458 1 : assert_similar(usec_shift_clock(bt + 7*USEC_PER_HOUR, clock_boottime_or_monotonic(), CLOCK_MONOTONIC), mn + 7*USEC_PER_HOUR);
459 1 : assert_similar(usec_shift_clock(bt + 8*USEC_PER_HOUR, clock_boottime_or_monotonic(), CLOCK_REALTIME_ALARM), rt + 8*USEC_PER_HOUR);
460 1 : assert_se(usec_shift_clock(bt + 9*USEC_PER_HOUR, clock_boottime_or_monotonic(), clock_boottime_or_monotonic()) == bt + 9*USEC_PER_HOUR);
461 :
462 1 : if (mn > USEC_PER_MINUTE) {
463 1 : assert_similar(usec_shift_clock(rt - 30 * USEC_PER_SEC, CLOCK_REALTIME_ALARM, CLOCK_MONOTONIC), mn - 30 * USEC_PER_SEC);
464 1 : assert_similar(usec_shift_clock(rt - 50 * USEC_PER_SEC, CLOCK_REALTIME, clock_boottime_or_monotonic()), bt - 50 * USEC_PER_SEC);
465 : }
466 1 : }
467 :
468 1 : static void test_in_utc_timezone(void) {
469 1 : log_info("/* %s */", __func__);
470 :
471 1 : assert_se(setenv("TZ", ":UTC", 1) >= 0);
472 1 : assert_se(in_utc_timezone());
473 1 : assert_se(streq(tzname[0], "UTC"));
474 1 : assert_se(streq(tzname[1], "UTC"));
475 1 : assert_se(timezone == 0);
476 1 : assert_se(daylight == 0);
477 :
478 1 : assert_se(setenv("TZ", "Europe/Berlin", 1) >= 0);
479 1 : assert_se(!in_utc_timezone());
480 1 : assert_se(streq(tzname[0], "CET"));
481 1 : assert_se(streq(tzname[1], "CEST"));
482 :
483 1 : assert_se(unsetenv("TZ") >= 0);
484 1 : }
485 :
486 1 : int main(int argc, char *argv[]) {
487 1 : test_setup_logging(LOG_INFO);
488 :
489 1 : log_info("realtime=" USEC_FMT "\n"
490 : "monotonic=" USEC_FMT "\n"
491 : "boottime=" USEC_FMT "\n",
492 : now(CLOCK_REALTIME),
493 : now(CLOCK_MONOTONIC),
494 : now(clock_boottime_or_monotonic()));
495 :
496 1 : test_parse_sec();
497 1 : test_parse_sec_fix_0();
498 1 : test_parse_sec_def_infinity();
499 1 : test_parse_time();
500 1 : test_parse_nsec();
501 1 : test_format_timespan(1);
502 1 : test_format_timespan(USEC_PER_MSEC);
503 1 : test_format_timespan(USEC_PER_SEC);
504 1 : test_timezone_is_valid();
505 1 : test_get_timezones();
506 1 : test_usec_add();
507 1 : test_usec_sub_signed();
508 1 : test_usec_sub_unsigned();
509 1 : test_format_timestamp();
510 1 : test_format_timestamp_utc();
511 1 : test_deserialize_dual_timestamp();
512 1 : test_usec_shift_clock();
513 1 : test_in_utc_timezone();
514 :
515 : /* Ensure time_t is signed */
516 : assert_cc((time_t) -1 < (time_t) 1);
517 :
518 : /* Ensure TIME_T_MAX works correctly */
519 1 : uintmax_t x = TIME_T_MAX;
520 1 : x++;
521 1 : assert((time_t) x < 0);
522 :
523 1 : return 0;
524 : }
|
