Change most SAME-AS-FNMATCH "false" values to "true" (since we _should_
[rsync.git] / wildtest.c
1 /*
2 **  wildmatch test suite.
3 */
4
5 #include "rsync.h"
6 #include "lib/wildmatch.h"
7
8 /*#define COMPARE_WITH_FNMATCH*/
9
10 #ifdef COMPARE_WITH_FNMATCH
11 #include <fnmatch.h>
12 #endif
13
14 typedef char bool;
15
16 #define false 0
17 #define true 1
18
19 /* match just at the start of string (anchored tests) */
20 static void
21 beg(int n, const char *text, const char *pattern, bool matches, bool same_as_fnmatch)
22 {
23     bool matched;
24 #ifdef COMPARE_WITH_FNMATCH
25     bool fn_matched;
26     int flags = strstr(pattern, "**")? 0 : FNM_PATHNAME;
27 #else
28     same_as_fnmatch = 0; /* Get rid of unused-variable compiler warning. */
29 #endif
30
31     matched = wildmatch(pattern, text);
32 #ifdef COMPARE_WITH_FNMATCH
33     fn_matched = !fnmatch(pattern, text, flags);
34 #endif
35     if (matched != matches) {
36         printf("wildmatch failure on #%d:\n  %s\n  %s\n  expected %d\n",
37                n, text, pattern, matches);
38     }
39 #ifdef COMPARE_WITH_FNMATCH
40     if (fn_matched != (matches ^ !same_as_fnmatch)) {
41         printf("fnmatch disagreement on #%d:\n  %s\n  %s\n  expected %d\n",
42                n, text, pattern, matches ^ !same_as_fnmatch);
43     }
44 #endif
45 }
46
47 /* match after any slash (non-anchored tests) */
48 static void
49 end(int n, const char *text, const char *pattern, bool matches, bool same_as_fnmatch)
50 {
51     bool matched = false;
52 #ifdef COMPARE_WITH_FNMATCH
53     bool fn_matched = false;
54     int flags = strstr(pattern, "**")? 0 : FNM_PATHNAME;
55 #else
56     same_as_fnmatch = 0; /* Get rid of unused-variable compiler warning. */
57 #endif
58
59     if (strncmp(pattern, "**", 2) == 0) {
60         matched = wildmatch(pattern, text);
61 #ifdef COMPARE_WITH_FNMATCH
62         fn_matched = !fnmatch(pattern, text, flags);
63 #endif
64     }
65     else {
66         const char *t = text;
67         while (1) {
68 #ifdef COMPARE_WITH_FNMATCH
69             if (!fn_matched)
70                 fn_matched = !fnmatch(pattern, t, flags);
71 #endif
72             if (wildmatch(pattern, t)) {
73                 matched = true;
74                 break;
75             }
76 #ifdef COMPARE_WITH_FNMATCH
77             if (fn_matched)
78                 fn_matched = -1;
79 #endif
80             if (!(t = strchr(t, '/')))
81                 break;
82             t++;
83         }
84     }
85     if (matched != matches) {
86         printf("wildmatch failure on #%d:\n  %s\n  %s\n  expected %d\n",
87                n, text, pattern, matches);
88     }
89 #ifdef COMPARE_WITH_FNMATCH
90     if (fn_matched < 0 || fn_matched != (matches ^ !same_as_fnmatch)) {
91         printf("fnmatch disagreement on #%d:\n  %s\n  %s\n  expected %d\n",
92                n, text, pattern, matches ^ !same_as_fnmatch);
93     }
94 #endif
95 }
96
97 int
98 main(int argc, char **argv)
99 {
100     /* Use our args to avoid a compiler warning. */
101     if (argc)
102         argv++;
103
104     /* Basic wildmat features. */
105     /* TEST, "text",            "pattern",              MATCH?, SAME-AS-FNMATCH? */
106     beg(100, "foo",             "foo",                  true,   true);
107     beg(101, "foo",             "bar",                  false,  true);
108     beg(102, "",                "",                     true,   true);
109     beg(103, "foo",             "???",                  true,   true);
110     beg(104, "foo",             "??",                   false,  true);
111     beg(105, "foo",             "*",                    true,   true);
112     beg(106, "foo",             "f*",                   true,   true);
113     beg(107, "foo",             "*f",                   false,  true);
114     beg(108, "foo",             "*foo*",                true,   true);
115     beg(109, "foobar",          "*ob*a*r*",             true,   true);
116     beg(110, "aaaaaaabababab",  "*ab",                  true,   true);
117     beg(111, "foo*",            "foo\\*",               true,   true);
118     beg(112, "foobar",          "foo\\*bar",            false,  true);
119     beg(113, "f\\oo",           "f\\\\oo",              true,   true);
120     beg(114, "ball",            "*[al]?",               true,   true);
121     beg(115, "ten",             "[ten]",                false,  true);
122     beg(116, "ten",             "**[!te]",              true,   true);
123     beg(117, "ten",             "**[!ten]",             false,  true);
124     beg(118, "ten",             "t[a-g]n",              true,   true);
125     beg(119, "ten",             "t[!a-g]n",             false,  true);
126     beg(120, "ton",             "t[!a-g]n",             true,   true);
127     beg(121, "]",               "]",                    true,   true);
128     beg(122, "a]b",             "a[]]b",                true,   true);
129     beg(123, "a-b",             "a[]-]b",               true,   true);
130     beg(124, "a]b",             "a[]-]b",               true,   true);
131     beg(125, "aab",             "a[]-]b",               false,  true);
132     beg(126, "aab",             "a[]a-]b",              true,   true);
133
134     /* Extended slash-matching features */
135     /* TEST, "text",            "pattern",              MATCH?, SAME-AS-FNMATCH? */
136     beg(200, "foo/baz/bar",     "foo*bar",              false,  true);
137     beg(201, "foo/baz/bar",     "foo**bar",             true,   true);
138     beg(202, "foo/bar",         "foo?bar",              false,  true);
139     beg(203, "foo/bar",         "foo[/]bar",            true,   false);
140     beg(204, "foo",             "**/foo",               false,  true);
141     beg(205, "/foo",            "**/foo",               true,   true);
142     beg(206, "bar/baz/foo",     "**/foo",               true,   true);
143     beg(207, "bar/baz/foo",     "*/foo",                false,  true);
144     beg(208, "foo/bar/baz",     "**/bar*",              false,  false);
145     beg(209, "foo/bar/baz",     "**/bar**",             true,   true);
146
147     /* Various additional tests. */
148     /* TEST, "text",            "pattern",              MATCH?, SAME-AS-FNMATCH? */
149     beg(300, "acrt",            "a[c-c]st",             false,  true);
150     beg(301, "]",               "[!]-]",                false,  true);
151     beg(302, "a",               "[!]-]",                true,   true);
152     beg(303, "",                "\\",                   false,  true);
153     beg(304, "\\",              "\\",                   false,  true);
154     beg(305, "foo",             "foo",                  true,   true);
155     beg(306, "@foo",            "@foo",                 true,   true);
156     beg(307, "foo",             "@foo",                 false,  true);
157     beg(308, "[ab]",            "\\[ab]",               true,   true);
158     beg(309, "?a?b",            "\\??\\?b",             true,   true);
159     beg(310, "abc",             "\\a\\b\\c",            true,   true);
160     beg(311, "foo",             "",                     false,  true);
161
162     /* Tail-match tests */
163     /* TEST, "text",            "pattern",              MATCH?, SAME-AS-FNMATCH? */
164     end(400, "foo/bar/baz",     "baz",                  true,   true);
165     end(401, "foo/bar/baz",     "bar/baz",              true,   true);
166     end(402, "foo/bar/baz",     "ar/baz",               false,  true);
167     end(403, "foo/bar/baz",     "/bar/baz",             false,  true);
168     end(404, "foo/bar/baz",     "bar",                  false,  true);
169     end(405, "foo/bar/baz/to",  "t[o]",                 true,   true);
170
171     /* Additional tests, including some malformed wildmats. */
172     /* TEST, "text",            "pattern",              MATCH?, SAME-AS-FNMATCH? */
173     beg(500, "]",               "[\\-_]",               true,   true);
174     beg(501, "[",               "[\\-_]",               false,  true);
175     beg(502, ".",               "[\\\\-_]",             false,  true);
176     beg(503, "^",               "[\\\\-_]",             true,   true);
177     beg(504, "Z",               "[\\\\-_]",             false,  true);
178     beg(505, "\\",              "[\\]]",                false,  true);
179     beg(506, "ab",              "a[]b",                 false,  true);
180     beg(507, "a[]b",            "a[]b",                 false,  true);
181     beg(508, "ab[",             "ab[",                  false,  true);
182     beg(509, "ab",              "[!",                   false,  true);
183     beg(510, "ab",              "[-",                   false,  true);
184     beg(511, "-",               "[-]",                  true,   true);
185     beg(512, "-",               "[a-",                  false,  true);
186     beg(513, "-",               "[!a-",                 false,  true);
187     beg(514, "-",               "[--A]",                true,   true);
188     beg(515, "5",               "[--A]",                true,   true);
189     beg(516, "\303\206",        "[--A]",                false,  true);
190     beg(517, " ",               "[ --]",                true,   true);
191     beg(518, "$",               "[ --]",                true,   true);
192     beg(519, "-",               "[ --]",                true,   true);
193     beg(520, "0",               "[ --]",                false,  true);
194     beg(521, "-",               "[---]",                true,   true);
195     beg(522, "-",               "[------]",             true,   true);
196     beg(523, "j",               "[a-e-n]",              false,  true);
197     beg(524, "-",               "[a-e-n]",              true,   true);
198     beg(525, "a",               "[!------]",            true,   true);
199     beg(526, "[",               "[]-a]",                false,  true);
200     beg(527, "^",               "[]-a]",                true,   true);
201     beg(528, "^",               "[!]-a]",               false,  true);
202     beg(529, "[",               "[!]-a]",               true,   true);
203     beg(530, "^",               "[a^bc]",               true,   true);
204     beg(531, "-b]",             "[a-]b]",               true,   true);
205     beg(532, "\\]",             "[\\]]",                true,   true);
206     beg(533, "\\",              "[\\]",                 true,   true);
207     beg(534, "\\",              "[!\\]",                false,  true);
208     beg(535, "G",               "[A-\\]",               true,   true);
209     beg(536, "aaabbb",          "b*a",                  false,  true);
210     beg(537, "aabcaa",          "*ba*",                 false,  true);
211     beg(538, ",",               "[,]",                  true,   true);
212     beg(539, ",",               "[\\,]",                true,   true);
213     beg(540, "\\",              "[\\,]",                true,   true);
214     beg(541, "-",               "[,-.]",                true,   true);
215     beg(542, "+",               "[,-.]",                false,  true);
216     beg(543, "-.]",             "[,-.]",                false,  true);
217
218     return 0;
219 }