HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/test/test-time-util.c

66,713 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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);