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