@@ -53,6 +53,7 @@ tests := \
tst-adjtime \
tst-clock \
tst-clock2 \
+ tst-clock_gettime \
tst-clock_nanosleep \
tst-clock_settime \
tst-cpuclock1 \
@@ -61,6 +62,7 @@ tests := \
tst-ftime \
tst-ftime_l \
tst-getdate \
+ tst-gettimeofday \
tst-gmtime \
tst-itimer \
tst-mktime \
@@ -77,6 +79,7 @@ tests := \
tst-strptime-whitespace \
tst-strptime2 \
tst-strptime3 \
+ tst-time \
tst-timegm \
tst-timespec_get \
tst-timespec_getres \
@@ -90,16 +93,19 @@ tests-time64 := \
tst-adjtime-time64 \
tst-clock-time64 \
tst-clock2-time64 \
+ tst-clock_gettime-time64 \
tst-clock_nanosleep-time64 \
tst-clock_settime-time64 \
tst-cpuclock1-time64 \
tst-ctime-time64 \
tst-difftime-time64 \
+ tst-gettimeofday-time64 \
tst-gmtime-time64 \
tst-itimer-time64 \
tst-mktime4-time64 \
tst-settimeofday-time64 \
tst-strftime4-time64 \
+ tst-time-time64 \
tst-timegm-time64 \
tst-timespec_get-time64 \
tst-timespec_getres-time64 \
new file mode 100644
@@ -0,0 +1 @@
+#include "tst-clock_gettime.c"
new file mode 100644
@@ -0,0 +1,155 @@
+/* Test clock_gettime function.
+ Copyright (C) 2024 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <support/check.h>
+#include <support/test-driver.h>
+
+/* Compare two struct timespec values, returning a value -1, 0 or 1. */
+
+int
+compare_timespec (const struct timespec *tv1, const struct timespec *tv2)
+{
+ if (tv1->tv_sec < tv2->tv_sec)
+ return -1;
+ if (tv1->tv_sec > tv2->tv_sec)
+ return 1;
+ if (tv1->tv_nsec < tv2->tv_nsec)
+ return -1;
+ if (tv1->tv_nsec > tv2->tv_nsec)
+ return 1;
+ return 0;
+}
+
+struct test_clockid
+{
+ clockid_t clockid;
+ const char *name;
+ bool is_cputime;
+ bool fail_ok;
+};
+
+#define CLOCK(clockid) { clockid, # clockid, false, false }
+#define CLOCK_CPU(clockid) { clockid, # clockid, true, false }
+#define CLOCK_FAIL_OK(clockid) { clockid, # clockid, false, true }
+
+static const struct test_clockid clocks[] =
+ {
+ CLOCK (CLOCK_REALTIME),
+#ifdef CLOCK_MONOTONIC
+ CLOCK (CLOCK_MONOTONIC),
+#endif
+#ifdef CLOCK_PROCESS_CPUTIME_ID
+ CLOCK_CPU (CLOCK_PROCESS_CPUTIME_ID),
+#endif
+#ifdef CLOCK_THREAD_CPUTIME_ID
+ CLOCK_CPU (CLOCK_THREAD_CPUTIME_ID),
+#endif
+#ifdef CLOCK_MONOTONIC_RAW
+ CLOCK (CLOCK_MONOTONIC_RAW),
+#endif
+#ifdef CLOCK_REALTIME_COARSE
+ CLOCK (CLOCK_REALTIME_COARSE),
+#endif
+#ifdef CLOCK_MONOTONIC_COARSE
+ CLOCK (CLOCK_MONOTONIC_COARSE),
+#endif
+#ifdef CLOCK_BOOTTIME
+ CLOCK (CLOCK_BOOTTIME),
+#endif
+#ifdef CLOCK_REALTIME_ALARM
+ CLOCK_FAIL_OK (CLOCK_REALTIME_ALARM),
+#endif
+#ifdef CLOCK_BOOTTIME_ALARM
+ CLOCK_FAIL_OK (CLOCK_BOOTTIME_ALARM),
+#endif
+#ifdef CLOCK_TAI
+ CLOCK (CLOCK_TAI),
+#endif
+ };
+
+int
+do_test (void)
+{
+ /* Verify that the calls to clock_gettime succeed, that the time does
+ not decrease, and that time returns a truncated (not rounded)
+ version of the time. */
+ for (size_t i = 0; i < sizeof clocks / sizeof clocks[0]; i++)
+ {
+ printf ("testing %s\n", clocks[i].name);
+ struct timespec ts1, ts2, ts3;
+ int ret;
+ time_t t1;
+ t1 = time (NULL);
+ TEST_VERIFY_EXIT (t1 != (time_t) -1);
+ ret = clock_gettime (clocks[i].clockid, &ts1);
+ if (clocks[i].fail_ok && ret == -1)
+ {
+ printf ("failed (OK for this clock): %m\n");
+ continue;
+ }
+ TEST_VERIFY_EXIT (ret == 0);
+ if (clocks[i].clockid == CLOCK_REALTIME)
+ TEST_VERIFY (t1 <= ts1.tv_sec);
+ TEST_VERIFY (ts1.tv_nsec >= 0);
+ TEST_VERIFY (ts1.tv_nsec < 1000000000);
+ ret = clock_gettime (clocks[i].clockid, &ts2);
+ TEST_VERIFY_EXIT (ret == 0);
+ TEST_VERIFY (compare_timespec (&ts1, &ts2) <= 0);
+ TEST_VERIFY (ts2.tv_nsec >= 0);
+ TEST_VERIFY (ts2.tv_nsec < 1000000000);
+ /* Also verify that after sleeping, the time returned has
+ increased. Repeat several times to verify that each time,
+ the time from the time function is truncated not rounded.
+ For CPU time clocks, the time spent spinning on the CPU, and
+ so whether we end in the later half of a second, is not
+ predictable; thus, only test once for those clocks. */
+ const struct timespec duration = { .tv_nsec = 100000000 };
+ for (int j = 0; j < 5; j++)
+ {
+ if (clocks[i].is_cputime)
+ for (volatile unsigned int x = 0; x != (unsigned int) -1; x++)
+ ;
+ else
+ {
+ ret = nanosleep (&duration, NULL);
+ TEST_VERIFY_EXIT (ret == 0);
+ }
+ t1 = time (NULL);
+ TEST_VERIFY_EXIT (t1 != (time_t) -1);
+ ret = clock_gettime (clocks[i].clockid, &ts3);
+ TEST_VERIFY_EXIT (ret == 0);
+ TEST_VERIFY (compare_timespec (&ts2, &ts3) < 0);
+ if (clocks[i].clockid == CLOCK_REALTIME)
+ TEST_VERIFY (t1 <= ts3.tv_sec);
+ TEST_VERIFY (ts3.tv_nsec >= 0);
+ TEST_VERIFY (ts3.tv_nsec < 1000000000);
+ ts2 = ts3;
+ if (clocks[i].is_cputime)
+ break;
+ }
+ }
+ return 0;
+}
+
+#define TIMEOUT 60
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1 @@
+#include "tst-gettimeofday.c"
new file mode 100644
@@ -0,0 +1,93 @@
+/* Test gettimeofday function.
+ Copyright (C) 2024 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+
+#include <sys/time.h>
+#include <time.h>
+
+#include <support/check.h>
+#include <support/test-driver.h>
+
+/* Compare two struct timeval values, returning a value -1, 0 or 1. */
+
+int
+compare_timeval (const struct timeval *tv1, const struct timeval *tv2)
+{
+ if (tv1->tv_sec < tv2->tv_sec)
+ return -1;
+ if (tv1->tv_sec > tv2->tv_sec)
+ return 1;
+ if (tv1->tv_usec < tv2->tv_usec)
+ return -1;
+ if (tv1->tv_usec > tv2->tv_usec)
+ return 1;
+ return 0;
+}
+
+int
+do_test (void)
+{
+ struct timeval tv1, tv2, tv3;
+ int ret;
+ time_t t1;
+ /* Verify that the calls to gettimeofday succeed, that the time does
+ not decrease, and that time returns a truncated (not rounded)
+ version of the time. */
+ t1 = time (NULL);
+ TEST_VERIFY_EXIT (t1 != (time_t) -1);
+ ret = gettimeofday (&tv1, NULL);
+ TEST_VERIFY_EXIT (ret == 0);
+ TEST_VERIFY (t1 <= tv1.tv_sec);
+ TEST_VERIFY (tv1.tv_usec >= 0);
+ TEST_VERIFY (tv1.tv_usec < 1000000);
+ ret = gettimeofday (&tv2, NULL);
+ TEST_VERIFY_EXIT (ret == 0);
+ TEST_VERIFY (compare_timeval (&tv1, &tv2) <= 0);
+ TEST_VERIFY (tv2.tv_usec >= 0);
+ TEST_VERIFY (tv2.tv_usec < 1000000);
+ /* Also verify that after sleeping, the time returned has increased.
+ Repeat several times to verify that each time, the time from the
+ time function is truncated not rounded. */
+ const struct timespec duration = { .tv_nsec = 100000000 };
+ for (int i = 0; i < 10; i++)
+ {
+ ret = nanosleep (&duration, NULL);
+ TEST_VERIFY_EXIT (ret == 0);
+ t1 = time (NULL);
+ TEST_VERIFY_EXIT (t1 != (time_t) -1);
+ ret = gettimeofday (&tv3, NULL);
+ TEST_VERIFY_EXIT (ret == 0);
+ TEST_VERIFY (compare_timeval (&tv2, &tv3) < 0);
+ TEST_VERIFY (t1 <= tv3.tv_sec);
+ TEST_VERIFY (tv3.tv_usec >= 0);
+ TEST_VERIFY (tv3.tv_usec < 1000000);
+ tv2 = tv3;
+ }
+ /* Also test with the obsolete tz argument not being NULL. */
+ struct timezone tz = { 0 };
+ t1 = time (NULL);
+ TEST_VERIFY_EXIT (t1 != (time_t) -1);
+ ret = gettimeofday (&tv3, &tz);
+ TEST_VERIFY_EXIT (ret == 0);
+ TEST_VERIFY (t1 <= tv3.tv_sec);
+ TEST_VERIFY (compare_timeval (&tv2, &tv3) <= 0);
+ TEST_VERIFY (tv3.tv_usec >= 0);
+ TEST_VERIFY (tv3.tv_usec < 1000000);
+ return 0;
+}
+
+#include <support/test-driver.c>
new file mode 100644
@@ -0,0 +1 @@
+#include "tst-time.c"
new file mode 100644
@@ -0,0 +1,51 @@
+/* Test time function.
+ Copyright (C) 2024 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+
+#include <time.h>
+#include <unistd.h>
+
+#include <support/check.h>
+#include <support/test-driver.h>
+
+int
+do_test (void)
+{
+ time_t t1, t2, t3, t4, t5, t6;
+ /* Verify that the calls to time succeed, that the value returned
+ directly equals that returned through the pointer passed, and
+ that the time does not decrease. */
+ t1 = time (&t2);
+ TEST_VERIFY_EXIT (t1 != (time_t) -1);
+ TEST_VERIFY (t1 == t2);
+ t3 = time (NULL);
+ TEST_VERIFY_EXIT (t3 != (time_t) -1);
+ TEST_VERIFY (t3 >= t1);
+ /* Also verify that after sleeping, the time returned has
+ increased. */
+ sleep (2);
+ t4 = time (&t5);
+ TEST_VERIFY_EXIT (t4 != (time_t) -1);
+ TEST_VERIFY (t4 == t5);
+ TEST_VERIFY (t4 > t3);
+ t6 = time (NULL);
+ TEST_VERIFY_EXIT (t6 != (time_t) -1);
+ TEST_VERIFY (t6 >= t4);
+ return 0;
+}
+
+#include <support/test-driver.c>