fixup - add macos special casesbagder/system-fnmatch

1 files changed, 46 insertions, 26 deletions

diff --git a/tests/unit/unit1307.c b/tests/unit/unit1307.c
index ed533bd6b..22afa4bf2 100644
--- a/tests/unit/unit1307.c
+++ b/tests/unit/unit1307.c
@@ -31,10 +31,18 @@
 
 #define MATCH   CURL_FNMATCH_MATCH
 #define NOMATCH CURL_FNMATCH_NOMATCH
-#define DIFFER 0x80
-#define POSIX_MATCH ((CURL_FNMATCH_MATCH << 8) | DIFFER)
-#define POSIX_NOMATCH ((CURL_FNMATCH_NOMATCH << 8) | DIFFER)
-#define POSIX_FAIL ((CURL_FNMATCH_FAIL << 8) | DIFFER)
+
+#define LINUX_DIFFER 0x80
+#define LINUX_SHIFT 8
+#define LINUX_MATCH ((CURL_FNMATCH_MATCH << LINUX_SHIFT) | LINUX_DIFFER)
+#define LINUX_NOMATCH ((CURL_FNMATCH_NOMATCH << LINUX_SHIFT) | LINUX_DIFFER)
+#define LINUX_FAIL ((CURL_FNMATCH_FAIL << LINUX_SHIFT) | LINUX_DIFFER)
+
+#define MAC_DIFFER 0x40
+#define MAC_SHIFT 16
+#define MAC_MATCH ((CURL_FNMATCH_MATCH << MAC_SHIFT) | MAC_DIFFER)
+#define MAC_NOMATCH ((CURL_FNMATCH_NOMATCH << MAC_SHIFT) | MAC_DIFFER)
+#define MAC_FAIL ((CURL_FNMATCH_FAIL << MAC_SHIFT) | MAC_DIFFER)
 
 struct testcase {
   const char *pattern;
@@ -50,11 +58,11 @@ static const struct testcase tests[] = {
    "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["
    "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["
    "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[",
-   NOMATCH},
+   NOMATCH|MAC_FAIL},
 
   { "\\[",                      "[",                      MATCH },
-  { "[",                        "[",                      NOMATCH|POSIX_MATCH},
-  { "[]",                       "[]",                     NOMATCH|POSIX_MATCH},
+  { "[",                        "[",             NOMATCH|LINUX_MATCH|MAC_FAIL},
+  { "[]",                       "[]",            NOMATCH|LINUX_MATCH|MAC_FAIL},
   { "[][]",                     "[",                      MATCH },
   { "[][]",                     "]",                      MATCH },
   { "[[]",                      "[",                      MATCH },
@@ -96,7 +104,7 @@ static const struct testcase tests[] = {
   { "[][?*-]",                  "*",                      MATCH },
   { "[][?*-]",                  "-",                      MATCH },
   { "[]?*-]",                   "-",                      MATCH },
-  { "[\xFF]",                   "\xFF",                   MATCH | POSIX_FAIL},
+  { "[\xFF]",                   "\xFF", MATCH|LINUX_FAIL|MAC_FAIL},
   { "?/b/c",                    "a/b/c",                  MATCH },
   { "^_{}~",                    "^_{}~",                  MATCH },
   { "!#%+,-./01234567889",      "!#%+,-./01234567889",    MATCH },
@@ -118,9 +126,9 @@ static const struct testcase tests[] = {
   { "*[^a].t?t",                "ba.txt",                 NOMATCH },
   { "*[^a].t?t",                "ab.txt",                 MATCH },
   { "*[^a]",                    "",                       NOMATCH },
-  { "[!\xFF]",                  "",                       NOMATCH|POSIX_FAIL},
-  { "[!\xFF]",                  "\xFF",                   NOMATCH|POSIX_FAIL},
-  { "[!\xFF]",                  "a",                      MATCH | POSIX_FAIL},
+  { "[!\xFF]",                  "",             NOMATCH|LINUX_FAIL},
+  { "[!\xFF]",                  "\xFF",  NOMATCH|LINUX_FAIL|MAC_FAIL},
+  { "[!\xFF]",                  "a",      MATCH|LINUX_FAIL|MAC_FAIL},
   { "[!?*[]",                   "?",                      NOMATCH },
   { "[!!]",                     "!",                      NOMATCH },
   { "[!!]",                     "x",                      MATCH },
@@ -152,8 +160,8 @@ static const struct testcase tests[] = {
   { "[^[:blank:]]",             "\t",                     NOMATCH },
   { "[^[:print:]]",             "\10",                    MATCH },
   { "[[:lower:]][[:lower:]]",   "ll",                     MATCH },
-  { "[[:foo:]]",                "bar",                    NOMATCH },
-  { "[[:foo:]]",                "f]",                     MATCH|POSIX_NOMATCH},
+  { "[[:foo:]]",                "bar",                    NOMATCH|MAC_FAIL},
+  { "[[:foo:]]",                "f]",         MATCH|LINUX_NOMATCH|MAC_FAIL},
 
   { "Curl[[:blank:]];-)",       "Curl ;-)",               MATCH },
   { "*[[:blank:]]*",            " ",                      MATCH },
@@ -191,7 +199,7 @@ static const struct testcase tests[] = {
   { "x",                        "",                       NOMATCH },
 
   /* backslash */
-  { "\\",                       "\\",                     MATCH|POSIX_NOMATCH},
+  { "\\",                       "\\",                     MATCH|LINUX_NOMATCH},
   { "\\\\",                     "\\",                     MATCH },
   { "\\\\",                     "\\\\",                   NOMATCH },
   { "\\?",                      "?",                      MATCH },
@@ -228,7 +236,7 @@ static const struct testcase tests[] = {
   {"**]*[*[\x13]**[*\x13)]*]*[**[*\x13~r-]*]**[.*]*[\xe3\xe3\xe3\xe3\xe3\xe3"
    "\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3\xe3"
    "\xe3\xe3\xe3\xe3\xe3*[\x13]**[*\x13)]*]*[*[\x13]*[~r]*]*\xba\x13\xa6~b-]*",
-                                "a",                      NOMATCH|POSIX_FAIL}
+                                "a",                      NOMATCH|LINUX_FAIL}
 };
 
 static CURLcode unit_setup(void)
@@ -255,28 +263,40 @@ static const char *ret2name(int i)
   /* not reached */
 }
 
-UNITTEST_START
+enum system {
+  SYSTEM_CUSTOM,
+  SYSTEM_LINUX,
+  SYSTEM_MACOS
+};
 
+UNITTEST_START
+{
   int testnum = sizeof(tests) / sizeof(struct testcase);
   int i, rc;
-  bool posix;
+  enum system machine;
 
 #ifdef HAVE_FNMATCH
-  printf("Tested with system fnmatch()\n");
-  posix = TRUE;
+  if(strstr(OS, "apple") || strstr(OS, "darwin")) {
+    machine = SYSTEM_MACOS;
+  }
+  else
+    machine = SYSTEM_LINUX;
+  printf("Tested with system fnmatch(), %s-style\n",
+         machine == SYSTEM_LINUX ? "linux" : "mac");
 #else
   printf("Tested with custom fnmatch()\n");
-  posix = FALSE;
+  machine = SYSTEM_CUSTOM;
 #endif
 
   for(i = 0; i < testnum; i++) {
     int result = tests[i].result;
     rc = Curl_fnmatch(NULL, tests[i].pattern, tests[i].string);
-    if(result & DIFFER) {
-      if(posix)
-        result >>= 8;
-      else
-        result &= 0x7f;
+    if(result & (LINUX_DIFFER|MAC_DIFFER)) {
+      if((result & LINUX_DIFFER) && (machine == SYSTEM_LINUX))
+        result >>= LINUX_SHIFT;
+      else if((result & MAC_DIFFER) && (machine == SYSTEM_MACOS))
+        result >>= MAC_SHIFT;
+      result &= 0x03; /* filter off all high bits */
     }
     if(rc != result) {
       printf("Curl_fnmatch(\"%s\", \"%s\") should return %s (returns %s)"
@@ -286,5 +306,5 @@ UNITTEST_START
       fail("pattern mismatch");
     }
   }
-
+}
 UNITTEST_STOP