Added a --depth option to report recursion depth values.

1 files changed, 129 insertions, 159 deletions

diff --git a/wildtest.c b/wildtest.c
index 1f7516e0..b64d671d 100644
--- a/wildtest.c
+++ b/wildtest.c
@@ -2,11 +2,13 @@
 **  wildmatch test suite.
 */
 
-#include "rsync.h"
-#include "lib/wildmatch.h"
-
 /*#define COMPARE_WITH_FNMATCH*/
 
+#define WILD_TEST_DEPTH
+#include "lib/wildmatch.c"
+
+#include "popt.h"
+
 #ifdef COMPARE_WITH_FNMATCH
 #include <fnmatch.h>
 #endif
@@ -16,9 +18,17 @@ typedef char bool;
 #define false 0
 #define true 1
 
+int output_depth = 0;
+
+static struct poptOption long_options[] = {
+  /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
+  {"depth",          'd', POPT_ARG_NONE,   &output_depth, 0, 0, 0},
+  {0,0,0,0, 0, 0, 0}
+};
+
 /* match just at the start of string (anchored tests) */
 static void
-beg(int n, const char *text, const char *pattern, bool matches, bool same_as_fnmatch)
+ok(int n, const char *text, const char *pattern, bool matches, bool same_as_fnmatch)
 {
     bool matched;
 #ifdef COMPARE_WITH_FNMATCH
@@ -42,178 +52,138 @@ beg(int n, const char *text, const char *pattern, bool matches, bool same_as_fnm
 	       n, text, pattern, matches ^ !same_as_fnmatch);
     }
 #endif
-}
-
-/* match after any slash (non-anchored tests) */
-static void
-end(int n, const char *text, const char *pattern, bool matches, bool same_as_fnmatch)
-{
-    bool matched = false;
-#ifdef COMPARE_WITH_FNMATCH
-    bool fn_matched = false;
-    int flags = strstr(pattern, "**")? 0 : FNM_PATHNAME;
-#else
-    same_as_fnmatch = 0; /* Get rid of unused-variable compiler warning. */
-#endif
-
-    if (strncmp(pattern, "**", 2) == 0) {
-	matched = wildmatch(pattern, text);
-#ifdef COMPARE_WITH_FNMATCH
-	fn_matched = !fnmatch(pattern, text, flags);
-#endif
-    }
-    else {
-	const char *t = text;
-	while (1) {
-#ifdef COMPARE_WITH_FNMATCH
-	    if (!fn_matched)
-		fn_matched = !fnmatch(pattern, t, flags);
-#endif
-	    if (wildmatch(pattern, t)) {
-		matched = true;
-		break;
-	    }
-#ifdef COMPARE_WITH_FNMATCH
-	    if (fn_matched)
-		fn_matched = -1;
-#endif
-	    if (!(t = strchr(t, '/')))
-		break;
-	    t++;
-	}
-    }
-    if (matched != matches) {
-	printf("wildmatch failure on #%d:\n  %s\n  %s\n  expected %d\n",
-	       n, text, pattern, matches);
-    }
-#ifdef COMPARE_WITH_FNMATCH
-    if (fn_matched < 0 || fn_matched != (matches ^ !same_as_fnmatch)) {
-	printf("fnmatch disagreement on #%d:\n  %s\n  %s\n  expected %d\n",
-	       n, text, pattern, matches ^ !same_as_fnmatch);
-    }
-#endif
+    if (output_depth)
+	printf("[%s] depth = %d\n", pattern, wildmatch_depth);
 }
 
 int
 main(int argc, char **argv)
 {
-    /* Use our args to avoid a compiler warning. */
-    if (argc)
-	argv++;
+    int opt;
+    poptContext pc = poptGetContext("wildtest", argc, (const char**)argv,
+				    long_options, 0);
+
+    while ((opt = poptGetNextOpt(pc)) != -1) {
+	switch (opt) {
+	  default:
+	    fprintf(stderr, "Unknown option: `%c'\n", opt);
+	    exit(1);
+	}
+    }
 
     /* Basic wildmat features. */
     /* TEST, "text",		"pattern",		MATCH?, SAME-AS-FNMATCH? */
-    beg(100, "foo",		"foo",			true,	true);
-    beg(101, "foo",		"bar",			false,	true);
-    beg(102, "",		"",			true,	true);
-    beg(103, "foo",		"???",			true,	true);
-    beg(104, "foo",		"??",			false,	true);
-    beg(105, "foo",		"*",			true,	true);
-    beg(106, "foo",		"f*",			true,	true);
-    beg(107, "foo",		"*f",			false,	true);
-    beg(108, "foo",		"*foo*",		true,	true);
-    beg(109, "foobar",		"*ob*a*r*",		true,	true);
-    beg(110, "aaaaaaabababab",	"*ab",			true,	true);
-    beg(111, "foo*",		"foo\\*",		true,	true);
-    beg(112, "foobar",		"foo\\*bar",		false,	true);
-    beg(113, "f\\oo",		"f\\\\oo",		true,	true);
-    beg(114, "ball",		"*[al]?",		true,	true);
-    beg(115, "ten",		"[ten]",		false,	true);
-    beg(116, "ten",		"**[!te]",		true,	true);
-    beg(117, "ten",		"**[!ten]",		false,	true);
-    beg(118, "ten",		"t[a-g]n",		true,	true);
-    beg(119, "ten",		"t[!a-g]n",		false,	true);
-    beg(120, "ton",		"t[!a-g]n",		true,	true);
-    beg(121, "]",		"]",			true,	true);
-    beg(122, "a]b",		"a[]]b",		true,	true);
-    beg(123, "a-b",		"a[]-]b",		true,	true);
-    beg(124, "a]b",		"a[]-]b",		true,	true);
-    beg(125, "aab",		"a[]-]b",		false,	true);
-    beg(126, "aab",		"a[]a-]b",		true,	true);
+    ok(100, "foo",		"foo",			true,	true);
+    ok(101, "foo",		"bar",			false,	true);
+    ok(102, "",			"",			true,	true);
+    ok(103, "foo",		"???",			true,	true);
+    ok(104, "foo",		"??",			false,	true);
+    ok(105, "foo",		"*",			true,	true);
+    ok(106, "foo",		"f*",			true,	true);
+    ok(107, "foo",		"*f",			false,	true);
+    ok(108, "foo",		"*foo*",		true,	true);
+    ok(109, "foobar",		"*ob*a*r*",		true,	true);
+    ok(110, "aaaaaaabababab",	"*ab",			true,	true);
+    ok(111, "foo*",		"foo\\*",		true,	true);
+    ok(112, "foobar",		"foo\\*bar",		false,	true);
+    ok(113, "f\\oo",		"f\\\\oo",		true,	true);
+    ok(114, "ball",		"*[al]?",		true,	true);
+    ok(115, "ten",		"[ten]",		false,	true);
+    ok(116, "ten",		"**[!te]",		true,	true);
+    ok(117, "ten",		"**[!ten]",		false,	true);
+    ok(118, "ten",		"t[a-g]n",		true,	true);
+    ok(119, "ten",		"t[!a-g]n",		false,	true);
+    ok(120, "ton",		"t[!a-g]n",		true,	true);
+    ok(121, "]",		"]",			true,	true);
+    ok(122, "a]b",		"a[]]b",		true,	true);
+    ok(123, "a-b",		"a[]-]b",		true,	true);
+    ok(124, "a]b",		"a[]-]b",		true,	true);
+    ok(125, "aab",		"a[]-]b",		false,	true);
+    ok(126, "aab",		"a[]a-]b",		true,	true);
 
     /* Extended slash-matching features */
     /* TEST, "text",		"pattern",		MATCH?, SAME-AS-FNMATCH? */
-    beg(200, "foo/baz/bar",	"foo*bar",		false,	true);
-    beg(201, "foo/baz/bar",	"foo**bar",		true,	true);
-    beg(202, "foo/bar",		"foo?bar",		false,	true);
-    beg(203, "foo/bar",		"foo[/]bar",		true,	false);
-    beg(204, "foo",		"**/foo",		false,	true);
-    beg(205, "/foo",		"**/foo",		true,	true);
-    beg(206, "bar/baz/foo",	"**/foo",		true,	true);
-    beg(207, "bar/baz/foo",	"*/foo",		false,	true);
-    beg(208, "foo/bar/baz",	"**/bar*",		false,	false);
-    beg(209, "foo/bar/baz",	"**/bar**",		true,	true);
+    ok(200, "foo/baz/bar",	"foo*bar",		false,	true);
+    ok(201, "foo/baz/bar",	"foo**bar",		true,	true);
+    ok(202, "foo/bar",		"foo?bar",		false,	true);
+    ok(203, "foo/bar",		"foo[/]bar",		true,	false);
+    ok(204, "foo",		"**/foo",		false,	true);
+    ok(205, "/foo",		"**/foo",		true,	true);
+    ok(206, "bar/baz/foo",	"**/foo",		true,	true);
+    ok(207, "bar/baz/foo",	"*/foo",		false,	true);
+    ok(208, "foo/bar/baz",	"**/bar*",		false,	false);
+    ok(209, "foo/bar/baz",	"**/bar**",		true,	true);
 
     /* Various additional tests. */
     /* TEST, "text",		"pattern",		MATCH?, SAME-AS-FNMATCH? */
-    beg(300, "acrt",		"a[c-c]st",		false,	true);
-    beg(301, "]",		"[!]-]",		false,	true);
-    beg(302, "a",		"[!]-]",		true,	true);
-    beg(303, "",		"\\",			false,	true);
-    beg(304, "\\",		"\\",			false,	true);
-    beg(305, "foo",		"foo",			true,	true);
-    beg(306, "@foo",		"@foo",			true,	true);
-    beg(307, "foo",		"@foo",			false,	true);
-    beg(308, "[ab]",		"\\[ab]",		true,	true);
-    beg(309, "?a?b",		"\\??\\?b",		true,	true);
-    beg(310, "abc",		"\\a\\b\\c",		true,	true);
-    beg(311, "foo",		"",			false,	true);
-
-    /* Tail-match tests */
-    /* TEST, "text",		"pattern",		MATCH?, SAME-AS-FNMATCH? */
-    end(400, "foo/bar/baz",	"baz",			true,	true);
-    end(401, "foo/bar/baz",	"bar/baz",		true,	true);
-    end(402, "foo/bar/baz",	"ar/baz",		false,	true);
-    end(403, "foo/bar/baz",	"/bar/baz",		false,	true);
-    end(404, "foo/bar/baz",	"bar",			false,	true);
-    end(405, "foo/bar/baz/to",	"t[o]",			true,	true);
+    ok(300, "acrt",		"a[c-c]st",		false,	true);
+    ok(301, "]",		"[!]-]",		false,	true);
+    ok(302, "a",		"[!]-]",		true,	true);
+    ok(303, "",			"\\",			false,	true);
+    ok(304, "\\",		"\\",			false,	true);
+    ok(305, "foo",		"foo",			true,	true);
+    ok(306, "@foo",		"@foo",			true,	true);
+    ok(307, "foo",		"@foo",			false,	true);
+    ok(308, "[ab]",		"\\[ab]",		true,	true);
+    ok(309, "?a?b",		"\\??\\?b",		true,	true);
+    ok(310, "abc",		"\\a\\b\\c",		true,	true);
+    ok(311, "foo",		"",			false,	true);
+    ok(312, "foo/bar/baz/to",	"**/t[o]",		true,	true);
 
     /* Additional tests, including some malformed wildmats. */
     /* TEST, "text",		"pattern",		MATCH?, SAME-AS-FNMATCH? */
-    beg(500, "]",		"[\\-_]",		true,	true);
-    beg(501, "[",		"[\\-_]",		false,	true);
-    beg(502, ".",		"[\\\\-_]",		false,	true);
-    beg(503, "^",		"[\\\\-_]",		true,	true);
-    beg(504, "Z",		"[\\\\-_]",		false,	true);
-    beg(505, "\\",		"[\\]]",		false,	true);
-    beg(506, "ab",		"a[]b",			false,	true);
-    beg(507, "a[]b",		"a[]b",			false,	true);
-    beg(508, "ab[",		"ab[",			false,	true);
-    beg(509, "ab",		"[!",			false,	true);
-    beg(510, "ab",		"[-",			false,	true);
-    beg(511, "-",		"[-]",			true,	true);
-    beg(512, "-",		"[a-",			false,	true);
-    beg(513, "-",		"[!a-",			false,	true);
-    beg(514, "-",		"[--A]",		true,	true);
-    beg(515, "5",		"[--A]",		true,	true);
-    beg(516, "\303\206",	"[--A]",		false,	true);
-    beg(517, " ",		"[ --]",		true,	true);
-    beg(518, "$",		"[ --]",		true,	true);
-    beg(519, "-",		"[ --]",		true,	true);
-    beg(520, "0",		"[ --]",		false,	true);
-    beg(521, "-",		"[---]",		true,	true);
-    beg(522, "-",		"[------]",		true,	true);
-    beg(523, "j",		"[a-e-n]",		false,	true);
-    beg(524, "-",		"[a-e-n]",		true,	true);
-    beg(525, "a",		"[!------]",		true,	true);
-    beg(526, "[",		"[]-a]",		false,	true);
-    beg(527, "^",		"[]-a]",		true,	true);
-    beg(528, "^",		"[!]-a]",		false,	true);
-    beg(529, "[",		"[!]-a]",		true,	true);
-    beg(530, "^",		"[a^bc]",		true,	true);
-    beg(531, "-b]",		"[a-]b]",		true,	true);
-    beg(532, "\\]",		"[\\]]",		true,	true);
-    beg(533, "\\",		"[\\]",			true,	true);
-    beg(534, "\\",		"[!\\]",		false,	true);
-    beg(535, "G",		"[A-\\]",		true,	true);
-    beg(536, "aaabbb",		"b*a",			false,	true);
-    beg(537, "aabcaa",		"*ba*",			false,	true);
-    beg(538, ",",		"[,]",			true,	true);
-    beg(539, ",",		"[\\,]",		true,	true);
-    beg(540, "\\",		"[\\,]",		true,	true);
-    beg(541, "-",		"[,-.]",		true,	true);
-    beg(542, "+",		"[,-.]",		false,	true);
-    beg(543, "-.]",		"[,-.]",		false,	true);
+    ok(500, "]",		"[\\-_]",		true,	true);
+    ok(501, "[",		"[\\-_]",		false,	true);
+    ok(502, ".",		"[\\\\-_]",		false,	true);
+    ok(503, "^",		"[\\\\-_]",		true,	true);
+    ok(504, "Z",		"[\\\\-_]",		false,	true);
+    ok(505, "\\",		"[\\]]",		false,	true);
+    ok(506, "ab",		"a[]b",			false,	true);
+    ok(507, "a[]b",		"a[]b",			false,	true);
+    ok(508, "ab[",		"ab[",			false,	true);
+    ok(509, "ab",		"[!",			false,	true);
+    ok(510, "ab",		"[-",			false,	true);
+    ok(511, "-",		"[-]",			true,	true);
+    ok(512, "-",		"[a-",			false,	true);
+    ok(513, "-",		"[!a-",			false,	true);
+    ok(514, "-",		"[--A]",		true,	true);
+    ok(515, "5",		"[--A]",		true,	true);
+    ok(516, "\303\206",		"[--A]",		false,	true);
+    ok(517, " ",		"[ --]",		true,	true);
+    ok(518, "$",		"[ --]",		true,	true);
+    ok(519, "-",		"[ --]",		true,	true);
+    ok(520, "0",		"[ --]",		false,	true);
+    ok(521, "-",		"[---]",		true,	true);
+    ok(522, "-",		"[------]",		true,	true);
+    ok(523, "j",		"[a-e-n]",		false,	true);
+    ok(524, "-",		"[a-e-n]",		true,	true);
+    ok(525, "a",		"[!------]",		true,	true);
+    ok(526, "[",		"[]-a]",		false,	true);
+    ok(527, "^",		"[]-a]",		true,	true);
+    ok(528, "^",		"[!]-a]",		false,	true);
+    ok(529, "[",		"[!]-a]",		true,	true);
+    ok(530, "^",		"[a^bc]",		true,	true);
+    ok(531, "-b]",		"[a-]b]",		true,	true);
+    ok(532, "\\]",		"[\\]]",		true,	true);
+    ok(533, "\\",		"[\\]",			true,	true);
+    ok(534, "\\",		"[!\\]",		false,	true);
+    ok(535, "G",		"[A-\\]",		true,	true);
+    ok(536, "aaabbb",		"b*a",			false,	true);
+    ok(537, "aabcaa",		"*ba*",			false,	true);
+    ok(538, ",",		"[,]",			true,	true);
+    ok(539, ",",		"[\\,]",		true,	true);
+    ok(540, "\\",		"[\\,]",		true,	true);
+    ok(541, "-",		"[,-.]",		true,	true);
+    ok(542, "+",		"[,-.]",		false,	true);
+    ok(543, "-.]",		"[,-.]",		false,	true);
+
+    /* Test recursive calls and the ABORT code. */
+    ok(600, "-adobe-courier-bold-o-normal--12-120-75-75-m-70-iso8859-1", "-*-*-*-*-*-*-12-*-*-*-m-*-*-*", true, true);
+    ok(601, "-adobe-courier-bold-o-normal--12-120-75-75-X-70-iso8859-1", "-*-*-*-*-*-*-12-*-*-*-m-*-*-*", false, true);
+    ok(601, "-adobe-courier-bold-o-normal--12-120-75-75-/-70-iso8859-1", "-*-*-*-*-*-*-12-*-*-*-m-*-*-*", false, true);
+    ok(602, "/adobe/courier/bold/o/normal//12/120/75/75/m/70/iso8859/1", "/*/*/*/*/*/*/12/*/*/*/m/*/*/*", true, true);
+    ok(603, "/adobe/courier/bold/o/normal//12/120/75/75/X/70/iso8859/1", "/*/*/*/*/*/*/12/*/*/*/m/*/*/*", false, true);
+    ok(604, "abcd/abcdefg/abcdefghijk/abcdefghijklmnop.txt", "**/*a*b*g*n*t", true, true);
 
     return 0;
 }