Message ID | 20210319183121.2252064-6-adhemerval.zanella@linaro.org |
---|---|
State | New |
Headers | show |
Series | More stat fixes | expand |
On 19/03/2021 19:31, Adhemerval Zanella via Libc-alpha wrote: > The tests are refactored to use a common skeleton that handles whether > the underlying filesystem supports 64 bit time, skips 64 bit time > tests when the TU only supports 32 bit, and also skip 64 bit time > tests larger than 32 unsigned int (y2106) if the system does not > support it (MIPSn64 on kernels without statx support). > > Checked on x86_64-linux-gnu and i686-linux-gnu. I also checked > on a mips64el-linux-gnu with 4.1.4 and 5.10.0-4-5kc-malta kernel > to verify if the y2106 are indeed skipped. > --- > sysdeps/unix/sysv/linux/tst-futimens.c | 63 ++----------- > sysdeps/unix/sysv/linux/tst-utime.c | 63 ++----------- > .../unix/sysv/linux/tst-utimensat-skeleton.c | 92 +++++++++++++++++++ > sysdeps/unix/sysv/linux/tst-utimes.c | 68 +++----------- > 4 files changed, 120 insertions(+), 166 deletions(-) > create mode 100644 sysdeps/unix/sysv/linux/tst-utimensat-skeleton.c > > diff --git a/sysdeps/unix/sysv/linux/tst-futimens.c b/sysdeps/unix/sysv/linux/tst-futimens.c > index 785cd87557..ac7a980017 100644 > --- a/sysdeps/unix/sysv/linux/tst-futimens.c > +++ b/sysdeps/unix/sysv/linux/tst-futimens.c > @@ -16,57 +16,18 @@ > License along with the GNU C Library; if not, see > <https://www.gnu.org/licenses/>. */ > > -#include <time.h> > -#include <stdio.h> > -#include <stdlib.h> > -#include <sys/stat.h> > #include <support/check.h> > -#include <support/support.h> > #include <support/xunistd.h> > -#include <support/temp_file.h> > - > -static int temp_fd = -1; > -static char *testfile; > - > -/* struct timespec array with Y2038 threshold minus 2 and 1 seconds. */ > -const struct timespec t1[2] = { { 0x7FFFFFFE, 0 }, { 0x7FFFFFFF, 0 } }; > - > -/* struct timespec array with Y2038 threshold plus 1 and 2 seconds. */ > -const struct timespec t2[2] = { { 0x80000001ULL, 0 }, { 0x80000002ULL, 0 } }; > - > -/* struct timespec array around Y2038 threshold. */ > -const struct timespec t3[2] = { { 0x7FFFFFFE, 0 }, { 0x80000002ULL, 0 } }; > - > -#define PREPARE do_prepare > -static void > -do_prepare (int argc, char *argv[]) > -{ > - temp_fd = create_temp_file ("futimensat", &testfile); > - TEST_VERIFY_EXIT (temp_fd > 0); > -} > +#include <sys/stat.h> > > static int > -test_futimens_helper (const struct timespec *ts) > +test_futimens_helper (const char *file, int fd, const struct timespec *ts) > { > - if (!support_path_support_time64 (testfile)) > - FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps", > - testfile); > - > - struct stat64 st; > - int result; > - time_t t; > - > - /* Check if we run on port with 32 bit time_t size */ > - if (__builtin_add_overflow (ts->tv_sec, 0, &t)) > - { > - printf("time_t overflow!"); > - return 0; > - } > - > - result = futimens (temp_fd, ts); > + int result = futimens (fd, ts); > TEST_VERIFY_EXIT (result == 0); > > - xfstat (temp_fd, &st); > + struct stat64 st; > + xfstat (fd, &st); > > /* Check if seconds for atime match */ > TEST_COMPARE (st.st_atime, ts[0].tv_sec); > @@ -77,14 +38,8 @@ test_futimens_helper (const struct timespec *ts) > return 0; > } > > -static int > -do_test (void) > -{ > - test_futimens_helper (&t1[0]); > - test_futimens_helper (&t2[0]); > - test_futimens_helper (&t3[0]); > - > - return 0; > -} > +#define TEST_CALL(fname, fd, v1, v2) \ > + test_futimens_helper (fname, fd, (struct timespec[]) { { v1, 0 }, \ > + { v2, 0 } }) > > -#include <support/test-driver.c> > +#include "tst-utimensat-skeleton.c" OK > diff --git a/sysdeps/unix/sysv/linux/tst-utime.c b/sysdeps/unix/sysv/linux/tst-utime.c > index 21e4e41dea..c1c7e75a29 100644 > --- a/sysdeps/unix/sysv/linux/tst-utime.c > +++ b/sysdeps/unix/sysv/linux/tst-utime.c > @@ -16,59 +16,19 @@ > License along with the GNU C Library; if not, see > <https://www.gnu.org/licenses/>. */ > > -#include <time.h> > -#include <stdio.h> > -#include <stdlib.h> > -#include <sys/stat.h> > -#include <sys/types.h> > #include <utime.h> > #include <support/check.h> > -#include <support/support.h> > #include <support/xunistd.h> > -#include <support/temp_file.h> > - > -static int temp_fd = -1; > -static char *testfile; > - > -/* struct utimbuf with Y2038 threshold minus 2 and 1 seconds. */ > -const static struct utimbuf t1 = { 0x7FFFFFFE, 0x7FFFFFFF }; > - > -/* struct utimbuf with Y2038 threshold plus 1 and 2 seconds. */ > -const static struct utimbuf t2 = { 0x80000001ULL, 0x80000002ULL }; > - > -/* struct utimbuf around Y2038 threshold. */ > -const static struct utimbuf t3 = { 0x7FFFFFFE, 0x80000002ULL }; > - > -#define PREPARE do_prepare > -static void > -do_prepare (int argc, char *argv[]) > -{ > - temp_fd = create_temp_file ("utime", &testfile); > - TEST_VERIFY_EXIT (temp_fd > 0); > -} > +#include <sys/stat.h> > > static int > -test_utime_helper (const struct utimbuf *ut) > +test_utime_helper (const char *file, int fd, const struct utimbuf *ut) > { > - if (!support_path_support_time64 (testfile)) > - FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps", > - testfile); > - > - struct stat64 st; > - int result; > - time_t t; > - > - /* Check if we run on port with 32 bit time_t size */ > - if (__builtin_add_overflow (ut->actime, 0, &t)) > - { > - printf("time_t overflow!"); > - return 0; > - } > - > - result = utime (testfile, ut); > + int result = utime (file, ut); > TEST_VERIFY_EXIT (result == 0); > > - xfstat (temp_fd, &st); > + struct stat64 st; > + xfstat (fd, &st); > > /* Check if seconds for actime match */ > TEST_COMPARE (st.st_atime, ut->actime); > @@ -79,14 +39,7 @@ test_utime_helper (const struct utimbuf *ut) > return 0; > } > > -static int > -do_test (void) > -{ > - test_utime_helper (&t1); > - test_utime_helper (&t2); > - test_utime_helper (&t3); > - > - return 0; > -} > +#define TEST_CALL(fname, fd, v1, v2) \ > + test_utime_helper (fname, fd, &(struct utimbuf) { (v1), (v2) }) > > -#include <support/test-driver.c> > +#include "tst-utimensat-skeleton.c" OK > diff --git a/sysdeps/unix/sysv/linux/tst-utimensat-skeleton.c b/sysdeps/unix/sysv/linux/tst-utimensat-skeleton.c > new file mode 100644 > index 0000000000..ed3d537b1f > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/tst-utimensat-skeleton.c > @@ -0,0 +1,92 @@ > +/* Common tests for utimensat routines. > + Copyright (C) 2021 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 <array_length.h> > +#include <inttypes.h> > +#include <support/support.h> > +#include <support/temp_file.h> > +#include <stdio.h> > + > +static int temp_fd = -1; > +static char *testfile; > + > +const static struct { > + int64_t v1; > + int64_t v2; > +} tests[] = { > + /* Y2038 threshold minus 2 and 1 seconds. */ > + { 0x7FFFFFFELL, 0x7FFFFFFFLL }, > + /* Y2038 threshold plus 1 and 2 seconds. */ > + { 0x80000001LL, 0x80000002LL }, > + /* Around Y2038 threshold. */ > + { 0x7FFFFFFELL, 0x80000002LL }, > + /* Y2106 threshold minus 2 and 1 seconds. */ > + { 0x100000000LL, 0xFFFFFFFELL }, > + /* Y2106 threshold plus 1 and 2 seconds. */ > + { 0x100000001LL, 0x100000002LL }, > + /* Around Y2106 threshold. */ > + { 0xFFFFFFFELL, 0xFFFFFFFELL }, > +}; > + > +#define PREPARE do_prepare > +static void > +do_prepare (int argc, char *argv[]) > +{ > + temp_fd = create_temp_file ("utime", &testfile); > + TEST_VERIFY_EXIT (temp_fd > 0); > +} > + > +static int > +do_test (void) > +{ > + if (!support_path_support_time64 (testfile)) > + FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps", > + testfile); > + > + bool y2106 = support_path_support_time64_value (testfile, > + 0x100000001LL, > + 0x100000002LL); > + > + for (int i = 0; i < array_length (tests); i++) > + { > + /* Check if we run on port with 32 bit time_t size. */ > + time_t t; > + if (__builtin_add_overflow (tests[i].v1, 0, &t) > + || __builtin_add_overflow (tests[i].v2, 0, &t)) Thanks for also testing v2 instead of only v1 in the former tests. > + { > + printf ("warning: skipping tests[%d] { %" PRIx64 ", %" PRIx64 " }: " > + "time_t overflows\n", i, tests[i].v1, tests[i].v2); > + continue; > + } > + > + if (tests[i].v1 >= 0x100000000LL && !y2106) > + { > + printf ("warning: skipping tests[%d] { %" PRIx64 ", %" PRIx64 " }: " > + "unsupported timestamp value\n", > + i, tests[i].v1, tests[i].v2); > + continue; > + } > + > + //test_utime_helper (&(struct utimbuf) { tests[i].v1, tests[i].v2 }); Do we need this comment? > + TEST_CALL (testfile, temp_fd, tests[i].v1, tests[i].v2); > + } > + > + return 0; > +} > + > +#include <support/test-driver.c> OK > diff --git a/sysdeps/unix/sysv/linux/tst-utimes.c b/sysdeps/unix/sysv/linux/tst-utimes.c > index 0f23e44897..ba710508b7 100644 > --- a/sysdeps/unix/sysv/linux/tst-utimes.c > +++ b/sysdeps/unix/sysv/linux/tst-utimes.c > @@ -16,60 +16,20 @@ > License along with the GNU C Library; if not, see > <https://www.gnu.org/licenses/>. */ > > -#include <time.h> > -#include <stdio.h> > -#include <stdlib.h> > -#include <sys/stat.h> > -#include <sys/time.h> > #include <support/check.h> > -#include <support/support.h> > #include <support/xunistd.h> > -#include <support/temp_file.h> > - > -static int temp_fd = -1; > -static char *testfile; > - > -/* struct timeval array with Y2038 threshold minus 2 and 1 seconds. */ > -const static struct timeval t1[2] = { { 0x7FFFFFFE, 0 }, { 0x7FFFFFFF, 0 } }; > - > -/* struct timeval array with Y2038 threshold plus 1 and 2 seconds. */ > -const static > -struct timeval t2[2] = { { 0x80000001ULL, 0 }, { 0x80000002ULL, 0 } }; > - > -/* struct timeval array around Y2038 threshold. */ > -const static > -struct timeval t3[2] = { { 0x7FFFFFFE, 0 }, { 0x80000002ULL, 0 } }; > - > -#define PREPARE do_prepare > -static void > -do_prepare (int argc, char *argv[]) > -{ > - temp_fd = create_temp_file ("utimes", &testfile); > - TEST_VERIFY_EXIT (temp_fd > 0); > -} > +#include <sys/stat.h> > +#include <sys/time.h> > +#include <time.h> > > static int > -test_utime_helper (const struct timeval *tv) > +test_utimes_helper (const char *file, int fd, const struct timeval *tv) > { > - if (!support_path_support_time64 (testfile)) > - FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps", > - testfile); > - > - struct stat64 st; > - int result; > - time_t t; > - > - /* Check if we run on port with 32 bit time_t size */ > - if (__builtin_add_overflow (tv->tv_sec, 0, &t)) > - { > - printf("time_t overflow!"); > - return 0; > - } > - > - result = utimes (testfile, tv); > + int result = utimes (file, tv); > TEST_VERIFY_EXIT (result == 0); > > - xfstat (temp_fd, &st); > + struct stat64 st; > + xfstat (fd, &st); > > /* Check if seconds for atime match */ > TEST_COMPARE (st.st_atime, tv[0].tv_sec); > @@ -80,14 +40,8 @@ test_utime_helper (const struct timeval *tv) > return 0; > } > > -static int > -do_test (void) > -{ > - test_utime_helper (&t1[0]); > - test_utime_helper (&t2[0]); > - test_utime_helper (&t3[0]); > - > - return 0; > -} > +#define TEST_CALL(fname, fd, v1, v2) \ > + test_utimes_helper (fname, fd, (struct timeval[]) { { v1, 0 }, \ > + { v2, 0 } }) > > -#include <support/test-driver.c> > +#include "tst-utimensat-skeleton.c" > Ok
On 26/03/2021 06:24, Stefan Liebler via Libc-alpha wrote: > On 19/03/2021 19:31, Adhemerval Zanella via Libc-alpha wrote: >> + //test_utime_helper (&(struct utimbuf) { tests[i].v1, tests[i].v2 }); > Do we need this comment? No, I will remove it.
diff --git a/sysdeps/unix/sysv/linux/tst-futimens.c b/sysdeps/unix/sysv/linux/tst-futimens.c index 785cd87557..ac7a980017 100644 --- a/sysdeps/unix/sysv/linux/tst-futimens.c +++ b/sysdeps/unix/sysv/linux/tst-futimens.c @@ -16,57 +16,18 @@ License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ -#include <time.h> -#include <stdio.h> -#include <stdlib.h> -#include <sys/stat.h> #include <support/check.h> -#include <support/support.h> #include <support/xunistd.h> -#include <support/temp_file.h> - -static int temp_fd = -1; -static char *testfile; - -/* struct timespec array with Y2038 threshold minus 2 and 1 seconds. */ -const struct timespec t1[2] = { { 0x7FFFFFFE, 0 }, { 0x7FFFFFFF, 0 } }; - -/* struct timespec array with Y2038 threshold plus 1 and 2 seconds. */ -const struct timespec t2[2] = { { 0x80000001ULL, 0 }, { 0x80000002ULL, 0 } }; - -/* struct timespec array around Y2038 threshold. */ -const struct timespec t3[2] = { { 0x7FFFFFFE, 0 }, { 0x80000002ULL, 0 } }; - -#define PREPARE do_prepare -static void -do_prepare (int argc, char *argv[]) -{ - temp_fd = create_temp_file ("futimensat", &testfile); - TEST_VERIFY_EXIT (temp_fd > 0); -} +#include <sys/stat.h> static int -test_futimens_helper (const struct timespec *ts) +test_futimens_helper (const char *file, int fd, const struct timespec *ts) { - if (!support_path_support_time64 (testfile)) - FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps", - testfile); - - struct stat64 st; - int result; - time_t t; - - /* Check if we run on port with 32 bit time_t size */ - if (__builtin_add_overflow (ts->tv_sec, 0, &t)) - { - printf("time_t overflow!"); - return 0; - } - - result = futimens (temp_fd, ts); + int result = futimens (fd, ts); TEST_VERIFY_EXIT (result == 0); - xfstat (temp_fd, &st); + struct stat64 st; + xfstat (fd, &st); /* Check if seconds for atime match */ TEST_COMPARE (st.st_atime, ts[0].tv_sec); @@ -77,14 +38,8 @@ test_futimens_helper (const struct timespec *ts) return 0; } -static int -do_test (void) -{ - test_futimens_helper (&t1[0]); - test_futimens_helper (&t2[0]); - test_futimens_helper (&t3[0]); - - return 0; -} +#define TEST_CALL(fname, fd, v1, v2) \ + test_futimens_helper (fname, fd, (struct timespec[]) { { v1, 0 }, \ + { v2, 0 } }) -#include <support/test-driver.c> +#include "tst-utimensat-skeleton.c" diff --git a/sysdeps/unix/sysv/linux/tst-utime.c b/sysdeps/unix/sysv/linux/tst-utime.c index 21e4e41dea..c1c7e75a29 100644 --- a/sysdeps/unix/sysv/linux/tst-utime.c +++ b/sysdeps/unix/sysv/linux/tst-utime.c @@ -16,59 +16,19 @@ License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ -#include <time.h> -#include <stdio.h> -#include <stdlib.h> -#include <sys/stat.h> -#include <sys/types.h> #include <utime.h> #include <support/check.h> -#include <support/support.h> #include <support/xunistd.h> -#include <support/temp_file.h> - -static int temp_fd = -1; -static char *testfile; - -/* struct utimbuf with Y2038 threshold minus 2 and 1 seconds. */ -const static struct utimbuf t1 = { 0x7FFFFFFE, 0x7FFFFFFF }; - -/* struct utimbuf with Y2038 threshold plus 1 and 2 seconds. */ -const static struct utimbuf t2 = { 0x80000001ULL, 0x80000002ULL }; - -/* struct utimbuf around Y2038 threshold. */ -const static struct utimbuf t3 = { 0x7FFFFFFE, 0x80000002ULL }; - -#define PREPARE do_prepare -static void -do_prepare (int argc, char *argv[]) -{ - temp_fd = create_temp_file ("utime", &testfile); - TEST_VERIFY_EXIT (temp_fd > 0); -} +#include <sys/stat.h> static int -test_utime_helper (const struct utimbuf *ut) +test_utime_helper (const char *file, int fd, const struct utimbuf *ut) { - if (!support_path_support_time64 (testfile)) - FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps", - testfile); - - struct stat64 st; - int result; - time_t t; - - /* Check if we run on port with 32 bit time_t size */ - if (__builtin_add_overflow (ut->actime, 0, &t)) - { - printf("time_t overflow!"); - return 0; - } - - result = utime (testfile, ut); + int result = utime (file, ut); TEST_VERIFY_EXIT (result == 0); - xfstat (temp_fd, &st); + struct stat64 st; + xfstat (fd, &st); /* Check if seconds for actime match */ TEST_COMPARE (st.st_atime, ut->actime); @@ -79,14 +39,7 @@ test_utime_helper (const struct utimbuf *ut) return 0; } -static int -do_test (void) -{ - test_utime_helper (&t1); - test_utime_helper (&t2); - test_utime_helper (&t3); - - return 0; -} +#define TEST_CALL(fname, fd, v1, v2) \ + test_utime_helper (fname, fd, &(struct utimbuf) { (v1), (v2) }) -#include <support/test-driver.c> +#include "tst-utimensat-skeleton.c" diff --git a/sysdeps/unix/sysv/linux/tst-utimensat-skeleton.c b/sysdeps/unix/sysv/linux/tst-utimensat-skeleton.c new file mode 100644 index 0000000000..ed3d537b1f --- /dev/null +++ b/sysdeps/unix/sysv/linux/tst-utimensat-skeleton.c @@ -0,0 +1,92 @@ +/* Common tests for utimensat routines. + Copyright (C) 2021 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 <array_length.h> +#include <inttypes.h> +#include <support/support.h> +#include <support/temp_file.h> +#include <stdio.h> + +static int temp_fd = -1; +static char *testfile; + +const static struct { + int64_t v1; + int64_t v2; +} tests[] = { + /* Y2038 threshold minus 2 and 1 seconds. */ + { 0x7FFFFFFELL, 0x7FFFFFFFLL }, + /* Y2038 threshold plus 1 and 2 seconds. */ + { 0x80000001LL, 0x80000002LL }, + /* Around Y2038 threshold. */ + { 0x7FFFFFFELL, 0x80000002LL }, + /* Y2106 threshold minus 2 and 1 seconds. */ + { 0x100000000LL, 0xFFFFFFFELL }, + /* Y2106 threshold plus 1 and 2 seconds. */ + { 0x100000001LL, 0x100000002LL }, + /* Around Y2106 threshold. */ + { 0xFFFFFFFELL, 0xFFFFFFFELL }, +}; + +#define PREPARE do_prepare +static void +do_prepare (int argc, char *argv[]) +{ + temp_fd = create_temp_file ("utime", &testfile); + TEST_VERIFY_EXIT (temp_fd > 0); +} + +static int +do_test (void) +{ + if (!support_path_support_time64 (testfile)) + FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps", + testfile); + + bool y2106 = support_path_support_time64_value (testfile, + 0x100000001LL, + 0x100000002LL); + + for (int i = 0; i < array_length (tests); i++) + { + /* Check if we run on port with 32 bit time_t size. */ + time_t t; + if (__builtin_add_overflow (tests[i].v1, 0, &t) + || __builtin_add_overflow (tests[i].v2, 0, &t)) + { + printf ("warning: skipping tests[%d] { %" PRIx64 ", %" PRIx64 " }: " + "time_t overflows\n", i, tests[i].v1, tests[i].v2); + continue; + } + + if (tests[i].v1 >= 0x100000000LL && !y2106) + { + printf ("warning: skipping tests[%d] { %" PRIx64 ", %" PRIx64 " }: " + "unsupported timestamp value\n", + i, tests[i].v1, tests[i].v2); + continue; + } + + //test_utime_helper (&(struct utimbuf) { tests[i].v1, tests[i].v2 }); + TEST_CALL (testfile, temp_fd, tests[i].v1, tests[i].v2); + } + + return 0; +} + +#include <support/test-driver.c> diff --git a/sysdeps/unix/sysv/linux/tst-utimes.c b/sysdeps/unix/sysv/linux/tst-utimes.c index 0f23e44897..ba710508b7 100644 --- a/sysdeps/unix/sysv/linux/tst-utimes.c +++ b/sysdeps/unix/sysv/linux/tst-utimes.c @@ -16,60 +16,20 @@ License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ -#include <time.h> -#include <stdio.h> -#include <stdlib.h> -#include <sys/stat.h> -#include <sys/time.h> #include <support/check.h> -#include <support/support.h> #include <support/xunistd.h> -#include <support/temp_file.h> - -static int temp_fd = -1; -static char *testfile; - -/* struct timeval array with Y2038 threshold minus 2 and 1 seconds. */ -const static struct timeval t1[2] = { { 0x7FFFFFFE, 0 }, { 0x7FFFFFFF, 0 } }; - -/* struct timeval array with Y2038 threshold plus 1 and 2 seconds. */ -const static -struct timeval t2[2] = { { 0x80000001ULL, 0 }, { 0x80000002ULL, 0 } }; - -/* struct timeval array around Y2038 threshold. */ -const static -struct timeval t3[2] = { { 0x7FFFFFFE, 0 }, { 0x80000002ULL, 0 } }; - -#define PREPARE do_prepare -static void -do_prepare (int argc, char *argv[]) -{ - temp_fd = create_temp_file ("utimes", &testfile); - TEST_VERIFY_EXIT (temp_fd > 0); -} +#include <sys/stat.h> +#include <sys/time.h> +#include <time.h> static int -test_utime_helper (const struct timeval *tv) +test_utimes_helper (const char *file, int fd, const struct timeval *tv) { - if (!support_path_support_time64 (testfile)) - FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps", - testfile); - - struct stat64 st; - int result; - time_t t; - - /* Check if we run on port with 32 bit time_t size */ - if (__builtin_add_overflow (tv->tv_sec, 0, &t)) - { - printf("time_t overflow!"); - return 0; - } - - result = utimes (testfile, tv); + int result = utimes (file, tv); TEST_VERIFY_EXIT (result == 0); - xfstat (temp_fd, &st); + struct stat64 st; + xfstat (fd, &st); /* Check if seconds for atime match */ TEST_COMPARE (st.st_atime, tv[0].tv_sec); @@ -80,14 +40,8 @@ test_utime_helper (const struct timeval *tv) return 0; } -static int -do_test (void) -{ - test_utime_helper (&t1[0]); - test_utime_helper (&t2[0]); - test_utime_helper (&t3[0]); - - return 0; -} +#define TEST_CALL(fname, fd, v1, v2) \ + test_utimes_helper (fname, fd, (struct timeval[]) { { v1, 0 }, \ + { v2, 0 } }) -#include <support/test-driver.c> +#include "tst-utimensat-skeleton.c"