From dadf23f06c134d09b5930e09bddfdab2c0ca6150 Mon Sep 17 00:00:00 2001 From: Florian Weimer Date: Mon, 30 Oct 2017 13:31:30 +0100 Subject: [PATCH] tst-gnuglob64: New test for glob64 based on tst-gnuglob Reviewed-by: Adhemerval Zanella --- ChangeLog | 11 + posix/Makefile | 2 +- posix/tst-gnuglob-skeleton.c | 519 +++++++++++++++++++++++++++++++++++ posix/tst-gnuglob.c | 493 +-------------------------------- posix/tst-gnuglob64.c | 25 ++ 5 files changed, 564 insertions(+), 486 deletions(-) create mode 100644 posix/tst-gnuglob-skeleton.c create mode 100644 posix/tst-gnuglob64.c diff --git a/ChangeLog b/ChangeLog index 87851c13c8..48357859f5 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,14 @@ +2017-10-30 Florian Weimer + + * posix/tst-gnuglob-skeleton.c: Renamed from tst-gnuglob.c. + Convert to support/test-driver.c. + (GLOB_FUNC, GLOB_TYPE, GLOBFREE_FUNC, DIRENT_STRUCT, STAT_STRUCT): + New macro parameters. + (PRINTF): Remove macro. Use test_verbose conditionals instead. + * posix/tst-gnuglob.c: New file. + * posix/tst-gnuglob64.c: Likewise. + * posix/Makefile (tests): Add tst-gnuglob64. + 2017-10-30 Michal Ostrowski [BZ #19485] diff --git a/posix/Makefile b/posix/Makefile index d4a5299a52..532f2c73c5 100644 --- a/posix/Makefile +++ b/posix/Makefile @@ -70,7 +70,7 @@ tests := test-errno tstgetopt testfnm runtests runptests \ tst-mmap tst-mmap-offset tst-getaddrinfo tst-truncate \ tst-truncate64 tst-fork tst-fnmatch tst-regexloc tst-dir \ tst-chmod bug-regex1 bug-regex2 bug-regex3 bug-regex4 \ - tst-gnuglob tst-regex bug-regex6 bug-regex7 \ + tst-gnuglob tst-gnuglob64 tst-regex bug-regex6 bug-regex7 \ bug-regex8 bug-regex9 bug-regex10 bug-regex11 bug-regex12 \ bug-regex13 bug-regex14 bug-regex15 bug-regex16 \ bug-regex17 bug-regex18 bug-regex19 \ diff --git a/posix/tst-gnuglob-skeleton.c b/posix/tst-gnuglob-skeleton.c new file mode 100644 index 0000000000..9276297c7c --- /dev/null +++ b/posix/tst-gnuglob-skeleton.c @@ -0,0 +1,519 @@ +/* Template for tests of the GNU extension GLOB_ALTDIRFUNC. + Copyright (C) 2001-2017 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2001. + + 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 + . */ + +/* To use this skeleton, the following macros need to be defined + before inclusion of this file: + + GLOB_FUNC The glob function to test (glob or glob64) + GLOB_TYPE The glob type expected by the function (glob_t, glob64_t) + GLOBFREE_FUNC The corresponding deallocation function + DIRENT_STRUCT The struct tag of the dirent type + STAT_STRUCT The struct tag of the stat type +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +static struct +{ + const char *name; + int level; + int type; +} filesystem[] = +{ + { ".", 1, DT_DIR }, + { "..", 1, DT_DIR }, + { "file1lev1", 1, DT_REG }, + { "file2lev1", 1, DT_UNKNOWN }, + { "dir1lev1", 1, DT_UNKNOWN }, + { ".", 2, DT_DIR }, + { "..", 2, DT_DIR }, + { "file1lev2", 2, DT_REG }, + { "dir1lev2", 2, DT_DIR }, + { ".", 3, DT_DIR }, + { "..", 3, DT_DIR }, + { "dir2lev2", 2, DT_DIR }, + { ".", 3, DT_DIR }, + { "..", 3, DT_DIR }, + { ".foo", 3, DT_REG }, + { "dir1lev3", 3, DT_DIR }, + { ".", 4, DT_DIR }, + { "..", 4, DT_DIR }, + { "file1lev4", 4, DT_REG }, + { "file1lev3", 3, DT_REG }, + { "file2lev3", 3, DT_REG }, + { "file2lev2", 2, DT_REG }, + { "file3lev2", 2, DT_REG }, + { "dir3lev2", 2, DT_DIR }, + { ".", 3, DT_DIR }, + { "..", 3, DT_DIR }, + { "file3lev3", 3, DT_REG }, + { "file4lev3", 3, DT_REG }, + { "dir2lev1", 1, DT_DIR }, + { ".", 2, DT_DIR }, + { "..", 2, DT_DIR }, + { "dir1lev2", 2, DT_UNKNOWN }, + { ".", 3, DT_DIR }, + { "..", 3, DT_DIR }, + { ".foo", 3, DT_REG }, + { ".dir", 3, DT_DIR }, + { ".", 4, DT_DIR }, + { "..", 4, DT_DIR }, + { "hidden", 4, DT_REG } +}; +#define nfiles (sizeof (filesystem) / sizeof (filesystem[0])) + + +typedef struct +{ + int level; + int idx; + struct DIRENT_STRUCT d; + char room_for_dirent[NAME_MAX]; +} my_DIR; + + +static long int +find_file (const char *s) +{ + int level = 1; + long int idx = 0; + + while (s[0] == '/') + { + if (s[1] == '\0') + { + s = "."; + break; + } + ++s; + } + + if (strcmp (s, ".") == 0) + return 0; + + if (s[0] == '.' && s[1] == '/') + s += 2; + + while (*s != '\0') + { + char *endp = strchrnul (s, '/'); + + if (test_verbose> 0) + printf ("info: looking for %.*s, level %d\n", + (int) (endp - s), s, level); + + while (idx < nfiles && filesystem[idx].level >= level) + { + if (filesystem[idx].level == level + && memcmp (s, filesystem[idx].name, endp - s) == 0 + && filesystem[idx].name[endp - s] == '\0') + break; + ++idx; + } + + if (idx == nfiles || filesystem[idx].level < level) + { + errno = ENOENT; + return -1; + } + + if (*endp == '\0') + return idx + 1; + + if (filesystem[idx].type != DT_DIR + && (idx + 1 >= nfiles + || filesystem[idx].level >= filesystem[idx + 1].level)) + { + errno = ENOTDIR; + return -1; + } + + ++idx; + + s = endp + 1; + ++level; + } + + errno = ENOENT; + return -1; +} + + +static void * +my_opendir (const char *s) +{ + long int idx = find_file (s); + my_DIR *dir; + + + if (idx == -1 || filesystem[idx].type != DT_DIR) + { + if (test_verbose > 0) + printf ("info: my_opendir(\"%s\") == NULL\n", s); + return NULL; + } + + dir = (my_DIR *) malloc (sizeof (my_DIR)); + if (dir == NULL) + error (EXIT_FAILURE, errno, "cannot allocate directory handle"); + + dir->level = filesystem[idx].level; + dir->idx = idx; + + if (test_verbose > 0) + printf ("info: my_opendir(\"%s\") == { level: %d, idx: %ld }\n", + s, filesystem[idx].level, idx); + + return dir; +} + + +static struct DIRENT_STRUCT * +my_readdir (void *gdir) +{ + my_DIR *dir = gdir; + + if (dir->idx == -1) + { + if (test_verbose > 0) + printf ("info: my_readdir ({ level: %d, idx: %ld }) = NULL\n", + dir->level, (long int) dir->idx); + return NULL; + } + + while (dir->idx < nfiles && filesystem[dir->idx].level > dir->level) + ++dir->idx; + + if (dir->idx == nfiles || filesystem[dir->idx].level < dir->level) + { + dir->idx = -1; + if (test_verbose > 0) + printf ("info: my_readdir ({ level: %d, idx: %ld }) = NULL\n", + dir->level, (long int) dir->idx); + return NULL; + } + + dir->d.d_ino = 1; /* glob should not skip this entry. */ + +#ifdef _DIRENT_HAVE_D_TYPE + dir->d.d_type = filesystem[dir->idx].type; +#endif + + strcpy (dir->d.d_name, filesystem[dir->idx].name); + +#ifdef _DIRENT_HAVE_D_TYPE + if (test_verbose > 0) + printf ("info: my_readdir ({ level: %d, idx: %ld })" + " = { d_ino: %lld, d_type: %d, d_name: \"%s\" }\n", + dir->level, (long int) dir->idx, + (long long) dir->d.d_ino, dir->d.d_type, + dir->d.d_name); +#else + if (test_verbose > 0) + printf ("info: my_readdir ({ level: %d, idx: %ld })" + " = { d_ino: %lld, d_name: \"%s\" }\n", + dir->level, (long int) dir->idx, + (long long) dir->d.d_ino, + dir->d.d_name); +#endif + + ++dir->idx; + + return &dir->d; +} + + +static void +my_closedir (void *dir) +{ + if (test_verbose > 0) + printf ("info: my_closedir ()\n"); + free (dir); +} + + +/* We use this function for lstat as well since we don't have any. */ +static int +my_stat (const char *name, struct STAT_STRUCT *st) +{ + long int idx = find_file (name); + + if (idx == -1) + { + if (test_verbose > 0) + printf ("info: my_stat (\"%s\", ...) = -1 (%s)\n", + name, strerror (errno)); + return -1; + } + + memset (st, '\0', sizeof (*st)); + + if (filesystem[idx].type == DT_UNKNOWN) + st->st_mode = DTTOIF (idx + 1 < nfiles + && filesystem[idx].level < filesystem[idx + 1].level + ? DT_DIR : DT_REG) | 0777; + else + st->st_mode = DTTOIF (filesystem[idx].type) | 0777; + + if (test_verbose > 0) + printf ("info: my_stat (\"%s\", { st_mode: %o }) = 0\n", name, st->st_mode); + + return 0; +} + + +static const char *glob_errstring[] = +{ + [GLOB_NOSPACE] = "out of memory", + [GLOB_ABORTED] = "read error", + [GLOB_NOMATCH] = "no matches found" +}; +#define nglob_errstring (sizeof (glob_errstring) / sizeof (glob_errstring[0])) + + +static const char * +flagstr (int flags) +{ + static const char *const strs[] = + { + "GLOB_ERR", "GLOB_MARK", "GLOB_NOSORT", "GLOB_DOOFSS", "GLOB_NOCHECK", + "GLOB_APPEND", "GLOB_NOESCAPE", "GLOB_PERIOD", "GLOB_MAGCHAR", + "GLOB_ALTDIRFUNC", "GLOB_BRACE", "GLOB_NOMAGIC", "GLOB_TILDE", + "GLOB_ONLYDIR", "GLOB_TILDECHECK" + }; +#define nstrs (sizeof (strs) / sizeof (strs[0])) + static char buf[100]; + char *cp = buf; + int cnt; + + for (cnt = 0; cnt < nstrs; ++cnt) + if (flags & (1 << cnt)) + { + flags &= ~(1 << cnt); + if (cp != buf) + *cp++ = '|'; + cp = stpcpy (cp, strs[cnt]); + } + + if (flags != 0) + { + if (cp != buf) + *cp++ = '|'; + sprintf (cp, "%#x", flags); + } + + return buf; +#undef nstrs +} + + +static const char * +errstr (int val) +{ + static const char *const strs[] = + { + [GLOB_NOSPACE] = "GLOB_NOSPACE", + [GLOB_ABORTED] = "GLOB_ABORTED", + [GLOB_NOMATCH] = "GLOB_NOMATCH", + [GLOB_NOSYS] = "GLOB_NOSYS" + }; +#define nstrs (sizeof (strs) / sizeof (strs[0])) + static char buf[100]; + if (val < 0 || val >= nstrs || strs[val] == NULL) + { + snprintf (buf, sizeof (buf), "GLOB_??? (%d)", val); + return buf; + } + return strs[val]; +#undef nstrs +} + + +static int +test_result (const char *fmt, int flags, GLOB_TYPE *gl, const char *str[]) +{ + size_t cnt; + int result = 0; + + printf ("results for glob (\"%s\", %s)\n", fmt, flagstr (flags)); + for (cnt = 0; cnt < gl->gl_pathc && str[cnt] != NULL; ++cnt) + { + int ok = strcmp (gl->gl_pathv[cnt], str[cnt]) == 0; + const char *errstr = ""; + + if (! ok) + { + size_t inner; + + for (inner = 0; str[inner] != NULL; ++inner) + if (strcmp (gl->gl_pathv[cnt], str[inner]) == 0) + break; + + if (str[inner] == NULL) + errstr = ok ? "" : " *** WRONG"; + else + errstr = ok ? "" : " * wrong position"; + + result = 1; + } + + printf (" %s%s\n", gl->gl_pathv[cnt], errstr); + } + puts (""); + + if (str[cnt] != NULL || cnt < gl->gl_pathc) + { + puts (" *** incorrect number of entries"); + result = 1; + } + + return result; +} + + +static int +do_test (void) +{ + GLOB_TYPE gl; + int errval; + int result = 0; + const char *fmt; + int flags; + + mtrace (); + + memset (&gl, '\0', sizeof (gl)); + + gl.gl_closedir = my_closedir; + gl.gl_readdir = my_readdir; + gl.gl_opendir = my_opendir; + gl.gl_lstat = my_stat; + gl.gl_stat = my_stat; + +#define test(a, b, r, c...) \ + fmt = a; \ + flags = GLOB_ALTDIRFUNC | b; \ + errval = GLOB_FUNC (fmt, flags, NULL, &gl); \ + if (errval != r) \ + { \ + if (r == 0) \ + printf ("glob (\"%s\", %s) failed: %s\n", fmt, flagstr (flags), \ + errval >= 0 && errval < nglob_errstring \ + ? glob_errstring[errval] : "???"); \ + else \ + printf ("glob (\"%s\", %s) did not fail\n", fmt, flagstr (flags)); \ + result = 1; \ + } \ + else if (r == 0) \ + result |= test_result (fmt, flags, &gl, (const char *[]) { c, NULL }); \ + else \ + printf ("result for glob (\"%s\", %s) = %s\n\n", fmt, flagstr (flags), \ + errstr (errval)) + + test ("*/*/*", 0, 0, + "dir1lev1/dir2lev2/dir1lev3", + "dir1lev1/dir2lev2/file1lev3", + "dir1lev1/dir2lev2/file2lev3", + "dir1lev1/dir3lev2/file3lev3", + "dir1lev1/dir3lev2/file4lev3"); + + test ("*/*/*", GLOB_PERIOD, 0, + "dir1lev1/dir1lev2/.", + "dir1lev1/dir1lev2/..", + "dir1lev1/dir2lev2/.", + "dir1lev1/dir2lev2/..", + "dir1lev1/dir2lev2/.foo", + "dir1lev1/dir2lev2/dir1lev3", + "dir1lev1/dir2lev2/file1lev3", + "dir1lev1/dir2lev2/file2lev3", + "dir1lev1/dir3lev2/.", + "dir1lev1/dir3lev2/..", + "dir1lev1/dir3lev2/file3lev3", + "dir1lev1/dir3lev2/file4lev3", + "dir2lev1/dir1lev2/.", + "dir2lev1/dir1lev2/..", + "dir2lev1/dir1lev2/.dir", + "dir2lev1/dir1lev2/.foo"); + + test ("*/*/.*", 0, 0, + "dir1lev1/dir1lev2/.", + "dir1lev1/dir1lev2/..", + "dir1lev1/dir2lev2/.", + "dir1lev1/dir2lev2/..", + "dir1lev1/dir2lev2/.foo", + "dir1lev1/dir3lev2/.", + "dir1lev1/dir3lev2/..", + "dir2lev1/dir1lev2/.", + "dir2lev1/dir1lev2/..", + "dir2lev1/dir1lev2/.dir", + "dir2lev1/dir1lev2/.foo"); + + test ("*1*/*2*/.*", 0, 0, + "dir1lev1/dir1lev2/.", + "dir1lev1/dir1lev2/..", + "dir1lev1/dir2lev2/.", + "dir1lev1/dir2lev2/..", + "dir1lev1/dir2lev2/.foo", + "dir1lev1/dir3lev2/.", + "dir1lev1/dir3lev2/..", + "dir2lev1/dir1lev2/.", + "dir2lev1/dir1lev2/..", + "dir2lev1/dir1lev2/.dir", + "dir2lev1/dir1lev2/.foo"); + + test ("*1*/*1*/.*", 0, 0, + "dir1lev1/dir1lev2/.", + "dir1lev1/dir1lev2/..", + "dir2lev1/dir1lev2/.", + "dir2lev1/dir1lev2/..", + "dir2lev1/dir1lev2/.dir", + "dir2lev1/dir1lev2/.foo"); + + test ("\\/*", 0, 0, + "/dir1lev1", + "/dir2lev1", + "/file1lev1", + "/file2lev1"); + + test ("*/*/", 0 , 0, + "dir1lev1/dir1lev2/", + "dir1lev1/dir2lev2/", + "dir1lev1/dir3lev2/", + "dir2lev1/dir1lev2/"); + + test ("", 0, GLOB_NOMATCH, NULL); + + test ("", GLOB_NOCHECK, 0, ""); + + GLOBFREE_FUNC (&gl); + + return result; +} + +#include diff --git a/posix/tst-gnuglob.c b/posix/tst-gnuglob.c index d753674c5f..b65e4cf6de 100644 --- a/posix/tst-gnuglob.c +++ b/posix/tst-gnuglob.c @@ -1,8 +1,6 @@ -/* Test the GNU extensions in glob which allow the user to provide callbacks - for the filesystem access functions. - Copyright (C) 2001-2017 Free Software Foundation, Inc. +/* Test glob with GLOB_ALTDIRFUNC. + Copyright (C) 2017 Free Software Foundation, Inc. This file is part of the GNU C Library. - Contributed by Ulrich Drepper , 2001. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -18,485 +16,10 @@ License along with the GNU C Library; if not, see . */ -#include -#include -#include -#include -#include -#include -#include -#include -#include +#define GLOB_FUNC glob +#define GLOB_TYPE glob_t +#define GLOBFREE_FUNC globfree +#define DIRENT_STRUCT dirent +#define STAT_STRUCT stat - -// #define DEBUG -#ifdef DEBUG -# define PRINTF(fmt, args...) printf (fmt, ##args) -#else -# define PRINTF(fmt, args...) -#endif - - -static struct -{ - const char *name; - int level; - int type; -} filesystem[] = -{ - { ".", 1, DT_DIR }, - { "..", 1, DT_DIR }, - { "file1lev1", 1, DT_REG }, - { "file2lev1", 1, DT_UNKNOWN }, - { "dir1lev1", 1, DT_UNKNOWN }, - { ".", 2, DT_DIR }, - { "..", 2, DT_DIR }, - { "file1lev2", 2, DT_REG }, - { "dir1lev2", 2, DT_DIR }, - { ".", 3, DT_DIR }, - { "..", 3, DT_DIR }, - { "dir2lev2", 2, DT_DIR }, - { ".", 3, DT_DIR }, - { "..", 3, DT_DIR }, - { ".foo", 3, DT_REG }, - { "dir1lev3", 3, DT_DIR }, - { ".", 4, DT_DIR }, - { "..", 4, DT_DIR }, - { "file1lev4", 4, DT_REG }, - { "file1lev3", 3, DT_REG }, - { "file2lev3", 3, DT_REG }, - { "file2lev2", 2, DT_REG }, - { "file3lev2", 2, DT_REG }, - { "dir3lev2", 2, DT_DIR }, - { ".", 3, DT_DIR }, - { "..", 3, DT_DIR }, - { "file3lev3", 3, DT_REG }, - { "file4lev3", 3, DT_REG }, - { "dir2lev1", 1, DT_DIR }, - { ".", 2, DT_DIR }, - { "..", 2, DT_DIR }, - { "dir1lev2", 2, DT_UNKNOWN }, - { ".", 3, DT_DIR }, - { "..", 3, DT_DIR }, - { ".foo", 3, DT_REG }, - { ".dir", 3, DT_DIR }, - { ".", 4, DT_DIR }, - { "..", 4, DT_DIR }, - { "hidden", 4, DT_REG } -}; -#define nfiles (sizeof (filesystem) / sizeof (filesystem[0])) - - -typedef struct -{ - int level; - int idx; - struct dirent d; - char room_for_dirent[NAME_MAX]; -} my_DIR; - - -static long int -find_file (const char *s) -{ - int level = 1; - long int idx = 0; - - while (s[0] == '/') - { - if (s[1] == '\0') - { - s = "."; - break; - } - ++s; - } - - if (strcmp (s, ".") == 0) - return 0; - - if (s[0] == '.' && s[1] == '/') - s += 2; - - while (*s != '\0') - { - char *endp = strchrnul (s, '/'); - - PRINTF ("looking for %.*s, level %d\n", (int) (endp - s), s, level); - - while (idx < nfiles && filesystem[idx].level >= level) - { - if (filesystem[idx].level == level - && memcmp (s, filesystem[idx].name, endp - s) == 0 - && filesystem[idx].name[endp - s] == '\0') - break; - ++idx; - } - - if (idx == nfiles || filesystem[idx].level < level) - { - errno = ENOENT; - return -1; - } - - if (*endp == '\0') - return idx + 1; - - if (filesystem[idx].type != DT_DIR - && (idx + 1 >= nfiles - || filesystem[idx].level >= filesystem[idx + 1].level)) - { - errno = ENOTDIR; - return -1; - } - - ++idx; - - s = endp + 1; - ++level; - } - - errno = ENOENT; - return -1; -} - - -static void * -my_opendir (const char *s) -{ - long int idx = find_file (s); - my_DIR *dir; - - - if (idx == -1 || filesystem[idx].type != DT_DIR) - { - PRINTF ("my_opendir(\"%s\") == NULL\n", s); - return NULL; - } - - dir = (my_DIR *) malloc (sizeof (my_DIR)); - if (dir == NULL) - error (EXIT_FAILURE, errno, "cannot allocate directory handle"); - - dir->level = filesystem[idx].level; - dir->idx = idx; - - PRINTF ("my_opendir(\"%s\") == { level: %d, idx: %ld }\n", - s, filesystem[idx].level, idx); - - return dir; -} - - -static struct dirent * -my_readdir (void *gdir) -{ - my_DIR *dir = gdir; - - if (dir->idx == -1) - { - PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n", - dir->level, (long int) dir->idx); - return NULL; - } - - while (dir->idx < nfiles && filesystem[dir->idx].level > dir->level) - ++dir->idx; - - if (dir->idx == nfiles || filesystem[dir->idx].level < dir->level) - { - dir->idx = -1; - PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n", - dir->level, (long int) dir->idx); - return NULL; - } - - dir->d.d_ino = 1; /* glob should not skip this entry. */ - -#ifdef _DIRENT_HAVE_D_TYPE - dir->d.d_type = filesystem[dir->idx].type; -#endif - - strcpy (dir->d.d_name, filesystem[dir->idx].name); - -#ifdef _DIRENT_HAVE_D_TYPE - PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_type: %d, d_name: \"%s\" }\n", - dir->level, (long int) dir->idx, dir->d.d_ino, dir->d.d_type, - dir->d.d_name); -#else - PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_name: \"%s\" }\n", - dir->level, (long int) dir->idx, dir->d.d_ino, - dir->d.d_name); -#endif - - ++dir->idx; - - return &dir->d; -} - - -static void -my_closedir (void *dir) -{ - PRINTF ("my_closedir ()\n"); - free (dir); -} - - -/* We use this function for lstat as well since we don't have any. */ -static int -my_stat (const char *name, struct stat *st) -{ - long int idx = find_file (name); - - if (idx == -1) - { - PRINTF ("my_stat (\"%s\", ...) = -1 (%s)\n", name, strerror (errno)); - return -1; - } - - memset (st, '\0', sizeof (*st)); - - if (filesystem[idx].type == DT_UNKNOWN) - st->st_mode = DTTOIF (idx + 1 < nfiles - && filesystem[idx].level < filesystem[idx + 1].level - ? DT_DIR : DT_REG) | 0777; - else - st->st_mode = DTTOIF (filesystem[idx].type) | 0777; - - PRINTF ("my_stat (\"%s\", { st_mode: %o }) = 0\n", name, st->st_mode); - - return 0; -} - - -static const char *glob_errstring[] = -{ - [GLOB_NOSPACE] = "out of memory", - [GLOB_ABORTED] = "read error", - [GLOB_NOMATCH] = "no matches found" -}; -#define nglob_errstring (sizeof (glob_errstring) / sizeof (glob_errstring[0])) - - -static const char * -flagstr (int flags) -{ - static const char *const strs[] = - { - "GLOB_ERR", "GLOB_MARK", "GLOB_NOSORT", "GLOB_DOOFSS", "GLOB_NOCHECK", - "GLOB_APPEND", "GLOB_NOESCAPE", "GLOB_PERIOD", "GLOB_MAGCHAR", - "GLOB_ALTDIRFUNC", "GLOB_BRACE", "GLOB_NOMAGIC", "GLOB_TILDE", - "GLOB_ONLYDIR", "GLOB_TILDECHECK" - }; -#define nstrs (sizeof (strs) / sizeof (strs[0])) - static char buf[100]; - char *cp = buf; - int cnt; - - for (cnt = 0; cnt < nstrs; ++cnt) - if (flags & (1 << cnt)) - { - flags &= ~(1 << cnt); - if (cp != buf) - *cp++ = '|'; - cp = stpcpy (cp, strs[cnt]); - } - - if (flags != 0) - { - if (cp != buf) - *cp++ = '|'; - sprintf (cp, "%#x", flags); - } - - return buf; -#undef nstrs -} - - -static const char * -errstr (int val) -{ - static const char *const strs[] = - { - [GLOB_NOSPACE] = "GLOB_NOSPACE", - [GLOB_ABORTED] = "GLOB_ABORTED", - [GLOB_NOMATCH] = "GLOB_NOMATCH", - [GLOB_NOSYS] = "GLOB_NOSYS" - }; -#define nstrs (sizeof (strs) / sizeof (strs[0])) - static char buf[100]; - if (val < 0 || val >= nstrs || strs[val] == NULL) - { - snprintf (buf, sizeof (buf), "GLOB_??? (%d)", val); - return buf; - } - return strs[val]; -#undef nstrs -} - - -static int -test_result (const char *fmt, int flags, glob_t *gl, const char *str[]) -{ - size_t cnt; - int result = 0; - - printf ("results for glob (\"%s\", %s)\n", fmt, flagstr (flags)); - for (cnt = 0; cnt < gl->gl_pathc && str[cnt] != NULL; ++cnt) - { - int ok = strcmp (gl->gl_pathv[cnt], str[cnt]) == 0; - const char *errstr = ""; - - if (! ok) - { - size_t inner; - - for (inner = 0; str[inner] != NULL; ++inner) - if (strcmp (gl->gl_pathv[cnt], str[inner]) == 0) - break; - - if (str[inner] == NULL) - errstr = ok ? "" : " *** WRONG"; - else - errstr = ok ? "" : " * wrong position"; - - result = 1; - } - - printf (" %s%s\n", gl->gl_pathv[cnt], errstr); - } - puts (""); - - if (str[cnt] != NULL || cnt < gl->gl_pathc) - { - puts (" *** incorrect number of entries"); - result = 1; - } - - return result; -} - - -static int -do_test (void) -{ - glob_t gl; - int errval; - int result = 0; - const char *fmt; - int flags; - - mtrace (); - - memset (&gl, '\0', sizeof (gl)); - - gl.gl_closedir = my_closedir; - gl.gl_readdir = my_readdir; - gl.gl_opendir = my_opendir; - gl.gl_lstat = my_stat; - gl.gl_stat = my_stat; - -#define test(a, b, r, c...) \ - fmt = a; \ - flags = GLOB_ALTDIRFUNC | b; \ - errval = glob (fmt, flags, NULL, &gl); \ - if (errval != r) \ - { \ - if (r == 0) \ - printf ("glob (\"%s\", %s) failed: %s\n", fmt, flagstr (flags), \ - errval >= 0 && errval < nglob_errstring \ - ? glob_errstring[errval] : "???"); \ - else \ - printf ("glob (\"%s\", %s) did not fail\n", fmt, flagstr (flags)); \ - result = 1; \ - } \ - else if (r == 0) \ - result |= test_result (fmt, flags, &gl, (const char *[]) { c, NULL }); \ - else \ - printf ("result for glob (\"%s\", %s) = %s\n\n", fmt, flagstr (flags), \ - errstr (errval)) - - test ("*/*/*", 0, 0, - "dir1lev1/dir2lev2/dir1lev3", - "dir1lev1/dir2lev2/file1lev3", - "dir1lev1/dir2lev2/file2lev3", - "dir1lev1/dir3lev2/file3lev3", - "dir1lev1/dir3lev2/file4lev3"); - - test ("*/*/*", GLOB_PERIOD, 0, - "dir1lev1/dir1lev2/.", - "dir1lev1/dir1lev2/..", - "dir1lev1/dir2lev2/.", - "dir1lev1/dir2lev2/..", - "dir1lev1/dir2lev2/.foo", - "dir1lev1/dir2lev2/dir1lev3", - "dir1lev1/dir2lev2/file1lev3", - "dir1lev1/dir2lev2/file2lev3", - "dir1lev1/dir3lev2/.", - "dir1lev1/dir3lev2/..", - "dir1lev1/dir3lev2/file3lev3", - "dir1lev1/dir3lev2/file4lev3", - "dir2lev1/dir1lev2/.", - "dir2lev1/dir1lev2/..", - "dir2lev1/dir1lev2/.dir", - "dir2lev1/dir1lev2/.foo"); - - test ("*/*/.*", 0, 0, - "dir1lev1/dir1lev2/.", - "dir1lev1/dir1lev2/..", - "dir1lev1/dir2lev2/.", - "dir1lev1/dir2lev2/..", - "dir1lev1/dir2lev2/.foo", - "dir1lev1/dir3lev2/.", - "dir1lev1/dir3lev2/..", - "dir2lev1/dir1lev2/.", - "dir2lev1/dir1lev2/..", - "dir2lev1/dir1lev2/.dir", - "dir2lev1/dir1lev2/.foo"); - - test ("*1*/*2*/.*", 0, 0, - "dir1lev1/dir1lev2/.", - "dir1lev1/dir1lev2/..", - "dir1lev1/dir2lev2/.", - "dir1lev1/dir2lev2/..", - "dir1lev1/dir2lev2/.foo", - "dir1lev1/dir3lev2/.", - "dir1lev1/dir3lev2/..", - "dir2lev1/dir1lev2/.", - "dir2lev1/dir1lev2/..", - "dir2lev1/dir1lev2/.dir", - "dir2lev1/dir1lev2/.foo"); - - test ("*1*/*1*/.*", 0, 0, - "dir1lev1/dir1lev2/.", - "dir1lev1/dir1lev2/..", - "dir2lev1/dir1lev2/.", - "dir2lev1/dir1lev2/..", - "dir2lev1/dir1lev2/.dir", - "dir2lev1/dir1lev2/.foo"); - - test ("\\/*", 0, 0, - "/dir1lev1", - "/dir2lev1", - "/file1lev1", - "/file2lev1"); - - test ("*/*/", 0 , 0, - "dir1lev1/dir1lev2/", - "dir1lev1/dir2lev2/", - "dir1lev1/dir3lev2/", - "dir2lev1/dir1lev2/"); - - test ("", 0, GLOB_NOMATCH, NULL); - - test ("", GLOB_NOCHECK, 0, ""); - - globfree (&gl); - - return result; -} - -#define TEST_FUNCTION do_test () -#include "../test-skeleton.c" +#include "tst-gnuglob-skeleton.c" diff --git a/posix/tst-gnuglob64.c b/posix/tst-gnuglob64.c new file mode 100644 index 0000000000..dd6f73d74e --- /dev/null +++ b/posix/tst-gnuglob64.c @@ -0,0 +1,25 @@ +/* Test glob64 with GLOB_ALTDIRFUNC. + Copyright (C) 2017 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 + . */ + +#define GLOB_FUNC glob64 +#define GLOB_TYPE glob64_t +#define GLOBFREE_FUNC globfree64 +#define DIRENT_STRUCT dirent64 +#define STAT_STRUCT stat64 + +#include "tst-gnuglob-skeleton.c" -- 2.43.5