nsz Git - libc-test/blob - src/regex/fnmatch.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <fnmatch.h>
   4 #include <unistd.h>
   5 #include "test.h"
   6
   7 /* adapted from dietlibc's test-newfnmatch.c */
   8
   9 /* xlat / printflags adapted from http://www.liacs.nl/~wichert/strace/ */
  10 #define FLAG(f) { f, #f }
  11
  12 struct xlat {
  13         int val;
  14         char *str;
  15 } fnmatch_flags[] = {
  16         FLAG(FNM_NOESCAPE),
  17         FLAG(FNM_PATHNAME),
  18         FLAG(FNM_PERIOD),
  19         {0, NULL},
  20 };
  21
  22 static void printflags(const struct xlat *map, int flags) {
  23         char *sep;
  24
  25         if (!flags) {
  26                 fprintf(stderr, "0");
  27                 return;
  28         }
  29         sep = "";
  30         for (; map->str; map++) {
  31                 if (map->val && (flags & map->val) == map->val) {
  32                         fprintf(stderr, "%s%s", sep, map->str);
  33                         sep = "|";
  34                         flags &= ~(map->val);
  35                 }
  36         }
  37         if (flags) fprintf(stderr, "%sunknown=%#x", sep, flags);
  38 }
  39
  40 /* tests harness adapted from glibc testfnm.c */
  41 struct {
  42         const char *pattern;
  43         const char *string;
  44         int flags;
  45         int expected;
  46 } tests[] = {
  47         /* begin dietlibc tests */
  48         { "*.c", "foo.c", 0, 0 },
  49         { "*.c", ".c", 0, 0 },
  50         { "*.a", "foo.c", 0, FNM_NOMATCH },
  51         { "*.c", ".foo.c", 0, 0 },
  52         { "*.c", ".foo.c", FNM_PERIOD, FNM_NOMATCH },
  53         { "*.c", "foo.c", FNM_PERIOD, 0 },
  54         { "a\\*.c", "a*.c", FNM_NOESCAPE, FNM_NOMATCH },
  55         { "a\\*.c", "ax.c", 0, FNM_NOMATCH },
  56         { "a[xy].c", "ax.c", 0, 0 },
  57         { "a[!y].c", "ax.c", 0, 0 },
  58         { "a[a/z]*.c", "a/x.c", FNM_PATHNAME, FNM_NOMATCH },
  59         { "a/*.c", "a/x.c", FNM_PATHNAME, 0 },
  60         { "a*.c", "a/x.c", FNM_PATHNAME, FNM_NOMATCH },
  61         { "*/foo", "/foo", FNM_PATHNAME, 0 },
  62         { "-O[01]", "-O1", 0, 0 },
  63         { "[[?*\\]", "\\", 0, 0 },
  64         { "[]?*\\]", "]", 0, 0 },
  65         /* initial right-bracket tests */
  66         { "[!]a-]", "b", 0, 0 },
  67         { "[]-_]", "^", 0, 0 }, /* range: ']', '^', '_' */
  68         { "[!]-_]", "X", 0, 0 },
  69         { "??", "-", 0, FNM_NOMATCH },
  70         /* begin glibc tests */
  71         { "*LIB*", "lib", FNM_PERIOD, FNM_NOMATCH },
  72         { "a[/]b", "a/b", 0, 0 },
  73         { "a[/]b", "a/b", FNM_PATHNAME, FNM_NOMATCH },
  74         { "[a-z]/[a-z]", "a/b", 0, 0 },
  75         { "*", "a/b", FNM_PATHNAME, FNM_NOMATCH },
  76         { "*[/]b", "a/b", FNM_PATHNAME, FNM_NOMATCH },
  77         { "*[b]", "a/b", FNM_PATHNAME, FNM_NOMATCH },
  78         { "[*]/b", "a/b", 0, FNM_NOMATCH },
  79         { "[*]/b", "*/b", 0, 0 },
  80         { "[?]/b", "a/b", 0, FNM_NOMATCH },
  81         { "[?]/b", "?/b", 0, 0 },
  82         { "[[a]/b", "a/b", 0, 0 },
  83         { "[[a]/b", "[/b", 0, 0 },
  84         { "\\*/b", "a/b", 0, FNM_NOMATCH },
  85         { "\\*/b", "*/b", 0, 0 },
  86         { "\\?/b", "a/b", 0, FNM_NOMATCH },
  87         { "\\?/b", "?/b", 0, 0 },
  88         { "[/b", "[/b", 0, 0 },
  89         { "\\[/b", "[/b", 0, 0 },
  90         { "??""/b", "aa/b", 0, 0 },
  91         { "???b", "aa/b", 0, 0 },
  92         { "???b", "aa/b", FNM_PATHNAME, FNM_NOMATCH },
  93         { "?a/b", ".a/b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
  94         { "a/?b", "a/.b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
  95         { "*a/b", ".a/b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
  96         { "a/*b", "a/.b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
  97         { "[.]a/b", ".a/b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
  98         { "a/[.]b", "a/.b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
  99         { "*/?", "a/b", FNM_PATHNAME|FNM_PERIOD, 0 },
 100         { "?/*", "a/b", FNM_PATHNAME|FNM_PERIOD, 0 },
 101         { ".*/?", ".a/b", FNM_PATHNAME|FNM_PERIOD, 0 },
 102         { "*/.?", "a/.b", FNM_PATHNAME|FNM_PERIOD, 0 },
 103         { "*/*", "a/.b", FNM_PATHNAME|FNM_PERIOD, FNM_NOMATCH },
 104         { "*?*/*", "a/.b", FNM_PERIOD, 0 },
 105         { "*[.]/b", "a./b", FNM_PATHNAME|FNM_PERIOD, 0 },
 106         { "*[[:alpha:]]/*[[:alnum:]]", "a/b", FNM_PATHNAME, 0 },
 107         /* These three tests should result in error according to SUSv3.
 108          * See XCU 2.13.1, XBD 9.3.5, & fnmatch() */
 109         { "*[![:digit:]]*/[![:d-d]", "a/b", FNM_PATHNAME, -FNM_NOMATCH },
 110         { "*[![:digit:]]*/[[:d-d]", "a/[", FNM_PATHNAME, -FNM_NOMATCH },
 111         { "*[![:digit:]]*/[![:d-d]", "a/[", FNM_PATHNAME, -FNM_NOMATCH },
 112         { "a?b", "a.b", FNM_PATHNAME|FNM_PERIOD, 0 },
 113         { "a*b", "a.b", FNM_PATHNAME|FNM_PERIOD, 0 },
 114         { "a[.]b", "a.b", FNM_PATHNAME|FNM_PERIOD, 0 },
 115 };
 116
 117 void test_fnmatch(void) {
 118         int i;
 119
 120         for (i = 0; i < sizeof(tests) / sizeof(*tests); i++) {
 121                 int r, x;
 122
 123                 r = fnmatch(tests[i].pattern, tests[i].string, tests[i].flags);
 124                 x = tests[i].expected;
 125                 if (r != x && (r != FNM_NOMATCH || x != -FNM_NOMATCH)) {
 126                         error("fail - fnmatch(\"%s\", \"%s\", ",
 127                                         tests[i].pattern, tests[i].string);
 128                         printflags(fnmatch_flags, tests[i].flags);
 129                         fprintf(stderr, ") => %d (expected %d)\n",
 130                                         r, tests[i].expected);
 131                 }
 132         }
 133 }