HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/test/test-time-util.c
Git blob: 4f9f5033e7fec8806601c21388d0e89e9cb50873
Lines 1001–1373 of 1,373
test_parse_timestamp_one("69-12-31 18:00:01 -0600", 0, USEC_PER_SEC);
test_parse_timestamp_one("69-12-31 18:00:01.001 -0600", 0, USEC_PER_SEC + 1000);
test_parse_timestamp_one("69-12-31 18:00:01.0010 -0600", 0, USEC_PER_SEC + 1000);
/* -06:00 */
test_parse_timestamp_one("Wed 1969-12-31 18:01 -06:00", 0, USEC_PER_MINUTE);
test_parse_timestamp_one("Wed 1969-12-31 18:00:01 -06:00", 0, USEC_PER_SEC);
test_parse_timestamp_one("Wed 1969-12-31 18:00:01.001 -06:00", 0, USEC_PER_SEC + 1000);
test_parse_timestamp_one("Wed 1969-12-31 18:00:01.0010 -06:00", 0, USEC_PER_SEC + 1000);
test_parse_timestamp_one("Wed 69-12-31 18:01 -06:00", 0, USEC_PER_MINUTE);
test_parse_timestamp_one("Wed 69-12-31 18:00:01 -06:00", 0, USEC_PER_SEC);
test_parse_timestamp_one("Wed 69-12-31 18:00:01.001 -06:00", 0, USEC_PER_SEC + 1000);
test_parse_timestamp_one("Wed 69-12-31 18:00:01.0010 -06:00", 0, USEC_PER_SEC + 1000);
test_parse_timestamp_one("1969-12-31 18:01 -06:00", 0, USEC_PER_MINUTE);
test_parse_timestamp_one("1969-12-31 18:00:01 -06:00", 0, USEC_PER_SEC);
test_parse_timestamp_one("1969-12-31 18:00:01.001 -06:00", 0, USEC_PER_SEC + 1000);
test_parse_timestamp_one("1969-12-31 18:00:01.0010 -06:00", 0, USEC_PER_SEC + 1000);
test_parse_timestamp_one("69-12-31 18:01 -06:00", 0, USEC_PER_MINUTE);
test_parse_timestamp_one("69-12-31 18:00:01 -06:00", 0, USEC_PER_SEC);
test_parse_timestamp_one("69-12-31 18:00:01.001 -06:00", 0, USEC_PER_SEC + 1000);
test_parse_timestamp_one("69-12-31 18:00:01.0010 -06:00", 0, USEC_PER_SEC + 1000);
/* without date */
assert_se(parse_timestamp("today", &today) == 0);
if (time_is_zero(today)) {
test_parse_timestamp_one("00:01", 0, today + USEC_PER_MINUTE);
test_parse_timestamp_one("00:00:01", 0, today + USEC_PER_SEC);
test_parse_timestamp_one("00:00:01.001", 0, today + USEC_PER_SEC + 1000);
test_parse_timestamp_one("00:00:01.0010", 0, today + USEC_PER_SEC + 1000);
if (timezone_equal(today, today + USEC_PER_DAY) && time_is_zero(today + USEC_PER_DAY) &&
midnight_is_unambiguous(today + USEC_PER_DAY))
test_parse_timestamp_one("tomorrow", 0, today + USEC_PER_DAY);
if (timezone_equal(today, today - USEC_PER_DAY) && time_is_zero(today - USEC_PER_DAY) &&
midnight_is_unambiguous(today - USEC_PER_DAY))
test_parse_timestamp_one("yesterday", 0, today - USEC_PER_DAY);
}
/* with timezone */
if (tz) {
_cleanup_free_ char *s = NULL;
ASSERT_NOT_NULL((s = strjoin("Fri 2012-11-23 23:02:15 ", tz)));
ASSERT_OK(parse_timestamp(s, NULL));
}
/* relative */
assert_se(parse_timestamp("now", &now_usec) == 0);
test_parse_timestamp_one("+5hours", USEC_PER_MINUTE, now_usec + 5 * USEC_PER_HOUR);
if (now_usec >= 10 * USEC_PER_DAY)
test_parse_timestamp_one("-10days", USEC_PER_MINUTE, now_usec - 10 * USEC_PER_DAY);
test_parse_timestamp_one("2weeks left", USEC_PER_MINUTE, now_usec + 2 * USEC_PER_WEEK);
if (now_usec >= 30 * USEC_PER_MINUTE)
test_parse_timestamp_one("30minutes ago", USEC_PER_MINUTE, now_usec - 30 * USEC_PER_MINUTE);
}
TEST(parse_timestamp) {
test_parse_timestamp_impl(NULL);
}
static void test_parse_timestamp_with_tz_one(const char *tz) {
if (!timezone_is_valid(tz, LOG_DEBUG))
return;
SAVE_TIMEZONE;
set_timezone(tz);
test_parse_timestamp_impl(tz);
}
TEST(parse_timestamp_with_tz) {
_cleanup_strv_free_ char **timezones = NULL;
test_parse_timestamp_with_tz_one("UTC");
if (!slow_tests_enabled())
return (void) log_tests_skipped("slow tests are disabled");
assert_se(get_timezones(&timezones) >= 0);
STRV_FOREACH(tz, timezones)
test_parse_timestamp_with_tz_one(*tz);
}
TEST(deserialize_dual_timestamp) {
int r;
dual_timestamp t;
r = deserialize_dual_timestamp("1234 5678", &t);
assert_se(r == 0);
assert_se(t.realtime == 1234);
assert_se(t.monotonic == 5678);
r = deserialize_dual_timestamp("1234x 5678", &t);
assert_se(r == -EINVAL);
r = deserialize_dual_timestamp("1234 5678y", &t);
assert_se(r == -EINVAL);
r = deserialize_dual_timestamp("-1234 5678", &t);
assert_se(r == -EINVAL);
r = deserialize_dual_timestamp("1234 -5678", &t);
assert_se(r == -EINVAL);
/* Check that output wasn't modified. */
assert_se(t.realtime == 1234);
assert_se(t.monotonic == 5678);
r = deserialize_dual_timestamp("+123 567", &t);
assert_se(r == 0);
assert_se(t.realtime == 123);
assert_se(t.monotonic == 567);
/* Check that we get "infinity" on overflow. */
r = deserialize_dual_timestamp("18446744073709551617 0", &t);
assert_se(r == 0);
assert_se(t.realtime == USEC_INFINITY);
assert_se(t.monotonic == 0);
}
static void assert_similar(usec_t a, usec_t b) {
usec_t d;
if (a > b)
d = a - b;
else
d = b - a;
assert_se(d < 10*USEC_PER_SEC);
}
TEST(usec_shift_clock) {
usec_t rt, mn, bt;
rt = now(CLOCK_REALTIME);
mn = now(CLOCK_MONOTONIC);
bt = now(CLOCK_BOOTTIME);
assert_se(usec_shift_clock(USEC_INFINITY, CLOCK_REALTIME, CLOCK_MONOTONIC) == USEC_INFINITY);
/* Silence static analyzers */
assert_cc(9 * USEC_PER_HOUR <= USEC_INFINITY);
assert_similar(usec_shift_clock(rt + USEC_PER_HOUR, CLOCK_REALTIME, CLOCK_MONOTONIC), mn + USEC_PER_HOUR);
assert_similar(usec_shift_clock(rt + 2*USEC_PER_HOUR, CLOCK_REALTIME, CLOCK_BOOTTIME), bt + 2*USEC_PER_HOUR);
assert_se(usec_shift_clock(rt + 3*USEC_PER_HOUR, CLOCK_REALTIME, CLOCK_REALTIME_ALARM) == rt + 3*USEC_PER_HOUR);
assert_similar(usec_shift_clock(mn + 4*USEC_PER_HOUR, CLOCK_MONOTONIC, CLOCK_REALTIME_ALARM), rt + 4*USEC_PER_HOUR);
assert_similar(usec_shift_clock(mn + 5*USEC_PER_HOUR, CLOCK_MONOTONIC, CLOCK_BOOTTIME), bt + 5*USEC_PER_HOUR);
assert_se(usec_shift_clock(mn + 6*USEC_PER_HOUR, CLOCK_MONOTONIC, CLOCK_MONOTONIC) == mn + 6*USEC_PER_HOUR);
assert_similar(usec_shift_clock(bt + 7*USEC_PER_HOUR, CLOCK_BOOTTIME, CLOCK_MONOTONIC), mn + 7*USEC_PER_HOUR);
assert_similar(usec_shift_clock(bt + 8*USEC_PER_HOUR, CLOCK_BOOTTIME, CLOCK_REALTIME_ALARM), rt + 8*USEC_PER_HOUR);
assert_se(usec_shift_clock(bt + 9*USEC_PER_HOUR, CLOCK_BOOTTIME, CLOCK_BOOTTIME) == bt + 9*USEC_PER_HOUR);
if (mn > USEC_PER_MINUTE) {
assert_similar(usec_shift_clock(rt - 30 * USEC_PER_SEC, CLOCK_REALTIME_ALARM, CLOCK_MONOTONIC), mn - 30 * USEC_PER_SEC);
assert_similar(usec_shift_clock(rt - 50 * USEC_PER_SEC, CLOCK_REALTIME, CLOCK_BOOTTIME), bt - 50 * USEC_PER_SEC);
}
}
TEST(in_utc_timezone) {
SAVE_TIMEZONE;
assert_se(setenv("TZ", "UTC", 1) >= 0);
assert_se(in_utc_timezone());
ASSERT_STREQ(get_tzname(/* dst= */ false), "UTC");
ASSERT_STREQ(get_tzname(/* dst= */ true), "UTC");
assert_se(timezone == 0);
assert_se(daylight == 0);
assert_se(setenv("TZ", "Europe/Berlin", 1) >= 0);
assert_se(!in_utc_timezone());
ASSERT_STREQ(get_tzname(/* dst= */ false), "CET");
ASSERT_STREQ(get_tzname(/* dst= */ true), "CEST");
}
TEST(map_clock_usec) {
usec_t nowr, x, y, z;
x = nowr = now(CLOCK_REALTIME); /* right now */
y = map_clock_usec(x, CLOCK_REALTIME, CLOCK_MONOTONIC);
z = map_clock_usec(y, CLOCK_MONOTONIC, CLOCK_REALTIME);
/* Converting forth and back will introduce inaccuracies, since we cannot query both clocks atomically, but it should be small. Even on the slowest CI smaller than 1h */
assert_se((z > x ? z - x : x - z) < USEC_PER_HOUR);
assert_se(nowr < USEC_INFINITY - USEC_PER_DAY*7); /* overflow check */
x = nowr + USEC_PER_DAY*7; /* 1 week from now */
y = map_clock_usec(x, CLOCK_REALTIME, CLOCK_MONOTONIC);
assert_se(timestamp_is_set(y));
z = map_clock_usec(y, CLOCK_MONOTONIC, CLOCK_REALTIME);
assert_se(timestamp_is_set(z));
assert_se((z > x ? z - x : x - z) < USEC_PER_HOUR);
assert_se(nowr > USEC_PER_DAY * 7); /* underflow check */
x = nowr - USEC_PER_DAY*7; /* 1 week ago */
y = map_clock_usec(x, CLOCK_REALTIME, CLOCK_MONOTONIC);
if (y != 0) { /* might underflow if machine is not up long enough for the monotonic clock to be beyond 1w */
assert_se(y < USEC_INFINITY);
z = map_clock_usec(y, CLOCK_MONOTONIC, CLOCK_REALTIME);
assert_se(timestamp_is_set(z));
assert_se((z > x ? z - x : x - z) < USEC_PER_HOUR);
}
}
static void test_timezone_offset_change_one(const char *utc, const char *pretty) {
usec_t x, y, z;
char *s;
assert_se(parse_timestamp(utc, &x) >= 0);
s = FORMAT_TIMESTAMP_STYLE(x, TIMESTAMP_UTC);
assert_se(parse_timestamp(s, &y) >= 0);
log_debug("%s -> " USEC_FMT " -> %s -> " USEC_FMT, utc, x, s, y);
ASSERT_STREQ(s, utc);
assert_se(x == y);
assert_se(parse_timestamp(pretty, &y) >= 0);
s = FORMAT_TIMESTAMP_STYLE(y, TIMESTAMP_PRETTY);
assert_se(parse_timestamp(s, &z) >= 0);
log_debug("%s -> " USEC_FMT " -> %s -> " USEC_FMT, pretty, y, s, z);
ASSERT_STREQ(s, pretty);
assert_se(x == y);
assert_se(x == z);
}
TEST(timezone_offset_change) {
SAVE_TIMEZONE;
/* See issue #26370. */
if (timezone_is_valid("Africa/Casablanca", LOG_DEBUG)) {
set_timezone("Africa/Casablanca");
test_timezone_offset_change_one("Sun 2015-10-25 01:59:59 UTC", "Sun 2015-10-25 02:59:59 +01");
test_timezone_offset_change_one("Sun 2015-10-25 02:00:00 UTC", "Sun 2015-10-25 02:00:00 +00");
test_timezone_offset_change_one("Sun 2018-06-17 01:59:59 UTC", "Sun 2018-06-17 01:59:59 +00");
test_timezone_offset_change_one("Sun 2018-06-17 02:00:00 UTC", "Sun 2018-06-17 03:00:00 +01");
test_timezone_offset_change_one("Sun 2018-10-28 01:59:59 UTC", "Sun 2018-10-28 02:59:59 +01");
test_timezone_offset_change_one("Sun 2018-10-28 02:00:00 UTC", "Sun 2018-10-28 03:00:00 +01");
}
if (timezone_is_valid("Asia/Atyrau", LOG_DEBUG)) {
set_timezone("Asia/Atyrau");
test_timezone_offset_change_one("Sat 2004-03-27 21:59:59 UTC", "Sun 2004-03-28 01:59:59 +04");
test_timezone_offset_change_one("Sat 2004-03-27 22:00:00 UTC", "Sun 2004-03-28 03:00:00 +05");
test_timezone_offset_change_one("Sat 2004-10-30 21:59:59 UTC", "Sun 2004-10-31 02:59:59 +05");
test_timezone_offset_change_one("Sat 2004-10-30 22:00:00 UTC", "Sun 2004-10-31 03:00:00 +05");
}
if (timezone_is_valid("Chile/EasterIsland", LOG_DEBUG)) {
set_timezone("Chile/EasterIsland");
test_timezone_offset_change_one("Sun 1981-10-11 03:59:59 UTC", "Sat 1981-10-10 20:59:59 -07");
test_timezone_offset_change_one("Sun 1981-10-11 04:00:00 UTC", "Sat 1981-10-10 22:00:00 -06");
test_timezone_offset_change_one("Sun 1982-03-14 02:59:59 UTC", "Sat 1982-03-13 20:59:59 -06");
test_timezone_offset_change_one("Sun 1982-03-14 03:00:00 UTC", "Sat 1982-03-13 21:00:00 -06");
}
}
static usec_t absdiff(usec_t a, usec_t b) {
return a > b ? a - b : b - a;
}
TEST(mktime_or_timegm_usec) {
usec_t n = now(CLOCK_REALTIME), m;
struct tm tm;
assert_se(localtime_or_gmtime_usec(n, /* utc= */ false, &tm) >= 0);
assert_se(mktime_or_timegm_usec(&tm, /* utc= */ false, &m) >= 0);
assert_se(absdiff(n, m) < 2 * USEC_PER_DAY);
assert_se(localtime_or_gmtime_usec(n, /* utc= */ true, &tm) >= 0);
assert_se(mktime_or_timegm_usec(&tm, /* utc= */ true, &m) >= 0);
assert_se(absdiff(n, m) < USEC_PER_SEC);
/* This definitely should fail, because we refuse dates before the UNIX epoch */
tm = (struct tm) {
.tm_mday = 15,
.tm_mon = 11,
.tm_year = 1969 - 1900,
};
assert_se(mktime_or_timegm_usec(&tm, /* utc= */ true, NULL) == -ERANGE);
}
static int intro(void) {
/* Tests have hard-coded results that do not expect a specific timezone to be set by the caller */
assert_se(unsetenv("TZ") >= 0);
log_info("realtime=" USEC_FMT "\n"
"monotonic=" USEC_FMT "\n"
"boottime=" USEC_FMT "\n",
now(CLOCK_REALTIME),
now(CLOCK_MONOTONIC),
now(CLOCK_BOOTTIME));
/* Ensure time_t is signed */
assert_cc((time_t) -1 < (time_t) 1);
/* Ensure TIME_T_MAX works correctly */
uintmax_t x = TIME_T_MAX;
x++;
assert_se((time_t) x < 0);
return EXIT_SUCCESS;
}
TEST(parse_calendar_date) {
usec_t usec;
/* Valid dates */
ASSERT_OK(parse_calendar_date("2000-01-01", &usec));
ASSERT_OK(parse_calendar_date("1970-01-01", &usec));
ASSERT_EQ(usec, 0u); /* epoch */
ASSERT_OK(parse_calendar_date("2000-02-29", &usec)); /* leap year */
/* NULL ret is allowed (validation only) */
ASSERT_OK(parse_calendar_date("2000-06-15", NULL));
/* Non-normalized dates */
ASSERT_ERROR(parse_calendar_date("2023-02-29", &usec), EINVAL); /* not a leap year */
ASSERT_ERROR(parse_calendar_date("2023-04-31", &usec), EINVAL); /* April has 30 days */
ASSERT_ERROR(parse_calendar_date("2023-13-01", &usec), EINVAL); /* month 13 */
ASSERT_ERROR(parse_calendar_date("2023-00-01", &usec), EINVAL); /* month 0 */
/* Malformed input */
ASSERT_ERROR(parse_calendar_date("", &usec), EINVAL);
ASSERT_ERROR(parse_calendar_date("not-a-date", &usec), EINVAL);
ASSERT_ERROR(parse_calendar_date("2023-06-15T00:00:00", &usec), EINVAL); /* trailing time */
ASSERT_ERROR(parse_calendar_date("2023/06/15", &usec), EINVAL); /* wrong separator */
ASSERT_ERROR(parse_calendar_date("06-15-2023", &usec), EINVAL); /* wrong order */
}
TEST(parse_birth_date) {
struct tm tm;
/* Valid dates */
ASSERT_OK(parse_birth_date("2000-06-15", &tm));
ASSERT_EQ(tm.tm_year, 100); /* 2000 - 1900 */
ASSERT_EQ(tm.tm_mon, 5); /* June, 0-indexed */
ASSERT_EQ(tm.tm_mday, 15);
/* Pre-epoch dates */
ASSERT_OK(parse_birth_date("1960-03-25", &tm));
ASSERT_EQ(tm.tm_year, 60);
ASSERT_EQ(tm.tm_mon, 2);
ASSERT_EQ(tm.tm_mday, 25);
/* NULL ret is allowed (validation only) */
ASSERT_OK(parse_birth_date("2000-01-01", NULL));
/* Non-date fields should not be relied upon */
ASSERT_OK(parse_birth_date("2000-06-15", &tm));
ASSERT_FALSE(BIRTH_DATE_IS_SET(BIRTH_DATE_UNSET));
/* Non-normalized dates */
ASSERT_ERROR(parse_birth_date("2023-02-29", &tm), EINVAL);
ASSERT_ERROR(parse_birth_date("2023-04-31", &tm), EINVAL);
/* Malformed input */
ASSERT_ERROR(parse_birth_date("", &tm), EINVAL);
ASSERT_ERROR(parse_birth_date("not-a-date", &tm), EINVAL);
ASSERT_ERROR(parse_birth_date("2023-06-15T00:00:00", &tm), EINVAL);
}
DEFINE_TEST_MAIN_WITH_INTRO(LOG_INFO, intro);