tests/patterntest.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 2001 Matthias Clasen <matthiasc@poet.de>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #undef G_DISABLE_ASSERT
  21 #undef G_LOG_DOMAIN
  22 #undef NOISY
  23
  24 #include <string.h>
  25
  26 #include "glib.h"
  27 #include "glib/gpattern.h"
  28
  29
  30 /* keep enum and structure of gpattern.c and patterntest.c in sync */
  31 typedef enum
  32 {
  33   G_MATCH_ALL,       /* "*A?A*" */
  34   G_MATCH_ALL_TAIL,  /* "*A?AA" */
  35   G_MATCH_HEAD,      /* "AAAA*" */
  36   G_MATCH_TAIL,      /* "*AAAA" */
  37   G_MATCH_EXACT,     /* "AAAAA" */
  38   G_MATCH_LAST
  39 } GMatchType;
  40
  41 struct _GPatternSpec
  42 {
  43   GMatchType match_type;
  44   guint      pattern_length;
  45   guint      min_length;
  46   gchar     *pattern;
  47 };
  48
  49 static gchar *
  50 match_type_name (GMatchType match_type)
  51 {
  52   switch (match_type)
  53     {
  54     case G_MATCH_ALL:
  55       return "G_MATCH_ALL";
  56       break;
  57     case G_MATCH_ALL_TAIL:
  58       return "G_MATCH_ALL_TAIL";
  59       break;
  60     case G_MATCH_HEAD:
  61       return "G_MATCH_HEAD";
  62       break;
  63     case G_MATCH_TAIL:
  64       return "G_MATCH_TAIL";
  65       break;
  66     case G_MATCH_EXACT:
  67       return "G_MATCH_EXACT";
  68       break;
  69     default:
  70       return "unknown GMatchType";
  71       break;
  72     }
  73 }
  74
  75 /* This leakes memory, but we don't care. The utf8 macro used to convert utf8
  76    back to Latin1 for feeding it to g_print. As of 2.0.1, g_print expects utf8,
  77    so this is no longer necessary */
  78 #define utf8(str) str
  79 #define latin1(str) g_convert (str, -1, "UTF-8", "Latin1", NULL, NULL, NULL)
  80
  81 static gboolean
  82 test_compilation (gchar *src,
  83                   GMatchType match_type,
  84                   gchar *pattern,
  85                   guint min)
  86 {
  87   GPatternSpec *spec;
  88
  89 #ifdef NOISY
  90   g_print ("compiling \"%s\" \t", utf8(src));
  91 #endif
  92   spec = g_pattern_spec_new (src);
  93
  94   if (spec->match_type != match_type)
  95     {
  96       g_print ("failed \t(match_type: %s, expected %s)\n",
  97                match_type_name (spec->match_type),
  98                match_type_name (match_type));
  99       return FALSE;
 100     }
 101
 102   if (strcmp (spec->pattern, pattern) != 0)
 103     {
 104       g_print ("failed \t(pattern: \"%s\", expected \"%s\")\n",
 105                utf8(spec->pattern),
 106                utf8(pattern));
 107       return FALSE;
 108     }
 109
 110   if (spec->pattern_length != strlen (spec->pattern))
 111     {
 112       g_print ("failed \t(pattern_length: %d, expected %d)\n",
 113                spec->pattern_length,
 114                (gint)strlen (spec->pattern));
 115       return FALSE;
 116     }
 117
 118   if (spec->min_length != min)
 119     {
 120       g_print ("failed \t(min_length: %d, expected %d)\n",
 121                spec->min_length,
 122                min);
 123       return FALSE;
 124     }
 125
 126 #ifdef NOISY
 127   g_print ("passed (%s: \"%s\")\n",
 128            match_type_name (spec->match_type),
 129            spec->pattern);
 130 #endif
 131
 132   return TRUE;
 133 }
 134
 135 static gboolean
 136 test_match (gchar *pattern,
 137             gchar *string,
 138             gboolean match)
 139 {
 140 #ifdef NOISY
 141   g_print ("matching \"%s\" against \"%s\" \t", utf8(string), utf8(pattern));
 142 #endif
 143
 144   if (g_pattern_match_simple (pattern, string) != match)
 145     {
 146       g_print ("failed \t(unexpected %s)\n", (match ? "mismatch" : "match"));
 147       return FALSE;
 148     }
 149
 150 #ifdef NOISY
 151   g_print ("passed (%s)\n", match ? "match" : "nomatch");
 152 #endif
 153   return TRUE;
 154 }
 155
 156 static gboolean
 157 test_equal (gchar *pattern1,
 158             gchar *pattern2,
 159             gboolean expected)
 160 {
 161   GPatternSpec *p1 = g_pattern_spec_new (pattern1);
 162   GPatternSpec *p2 = g_pattern_spec_new (pattern2);
 163   gboolean equal = g_pattern_spec_equal (p1, p2);
 164
 165 #ifdef NOISY
 166   g_print ("comparing \"%s\" with \"%s\" \t", utf8(pattern1), utf8(pattern2));
 167 #endif
 168
 169   if (expected != equal)
 170     {
 171       g_print ("failed \t{%s, %u, \"%s\"} %s {%s, %u, \"%s\"}\n",
 172                match_type_name (p1->match_type), p1->pattern_length, utf8(p1->pattern),
 173                expected ? "!=" : "==",
 174                match_type_name (p2->match_type), p2->pattern_length, utf8(p2->pattern));
 175     }
 176 #ifdef NOISY
 177   else
 178     g_print ("passed (%s)\n", equal ? "equal" : "unequal");
 179 #endif
 180
 181   g_pattern_spec_free (p1);
 182   g_pattern_spec_free (p2);
 183
 184   return expected == equal;
 185 }
 186
 187 #define TEST_COMPILATION(src, type, pattern, min) { \
 188   total++; \
 189   if (test_compilation (latin1(src), type, latin1(pattern), min)) \
 190     passed++; \
 191   else \
 192     failed++; \
 193 }
 194
 195 #define TEST_MATCH(pattern, string, match) { \
 196   total++; \
 197   if (test_match (latin1(pattern), latin1(string), match)) \
 198     passed++; \
 199   else \
 200     failed++; \
 201 }
 202
 203 #define TEST_EQUAL(pattern1, pattern2, match) { \
 204   total++; \
 205   if (test_equal (latin1(pattern1), latin1(pattern2), match)) \
 206     passed++; \
 207   else \
 208     failed++; \
 209 }
 210
 211 int
 212 main (int argc, char** argv)
 213 {
 214   gint total = 0;
 215   gint passed = 0;
 216   gint failed = 0;
 217
 218   TEST_COMPILATION("*A?B*", G_MATCH_ALL, "*A?B*", 3);
 219   TEST_COMPILATION("ABC*DEFGH", G_MATCH_ALL_TAIL, "HGFED*CBA", 8);
 220   TEST_COMPILATION("ABCDEF*GH", G_MATCH_ALL, "ABCDEF*GH", 8);
 221   TEST_COMPILATION("ABC**?***??**DEF*GH", G_MATCH_ALL, "ABC*???DEF*GH", 11);
 222   TEST_COMPILATION("*A?AA", G_MATCH_ALL_TAIL, "AA?A*", 4);
 223   TEST_COMPILATION("ABCD*", G_MATCH_HEAD, "ABCD", 4);
 224   TEST_COMPILATION("*ABCD", G_MATCH_TAIL, "ABCD", 4);
 225   TEST_COMPILATION("ABCDE", G_MATCH_EXACT, "ABCDE", 5);
 226   TEST_COMPILATION("A?C?E", G_MATCH_ALL, "A?C?E", 5);
 227   TEST_COMPILATION("*?x", G_MATCH_ALL_TAIL, "x?*", 2);
 228   TEST_COMPILATION("?*x", G_MATCH_ALL_TAIL, "x?*", 2);
 229   TEST_COMPILATION("*?*x", G_MATCH_ALL_TAIL, "x?*", 2);
 230   TEST_COMPILATION("x*??", G_MATCH_ALL_TAIL, "??*x", 3);
 231
 232   TEST_EQUAL("*A?B*", "*A?B*", TRUE);
 233   TEST_EQUAL("A*BCD", "A*BCD", TRUE);
 234   TEST_EQUAL("ABCD*", "ABCD****", TRUE);
 235   TEST_EQUAL("A1*", "A1*", TRUE);
 236   TEST_EQUAL("*YZ", "*YZ", TRUE);
 237   TEST_EQUAL("A1x", "A1x", TRUE);
 238   TEST_EQUAL("AB*CD", "AB**CD", TRUE);
 239   TEST_EQUAL("AB*?*CD", "AB*?CD", TRUE);
 240   TEST_EQUAL("AB*?CD", "AB?*CD", TRUE);
 241   TEST_EQUAL("AB*CD", "AB*?*CD", FALSE);
 242   TEST_EQUAL("ABC*", "ABC?", FALSE);
 243
 244   TEST_MATCH("*x", "x", TRUE);
 245   TEST_MATCH("*x", "xx", TRUE);
 246   TEST_MATCH("*x", "yyyx", TRUE);
 247   TEST_MATCH("*x", "yyxy", FALSE);
 248   TEST_MATCH("?x", "x", FALSE);
 249   TEST_MATCH("?x", "xx", TRUE);
 250   TEST_MATCH("?x", "yyyx", FALSE);
 251   TEST_MATCH("?x", "yyxy", FALSE);
 252   TEST_MATCH("*?x", "xx", TRUE);
 253   TEST_MATCH("?*x", "xx", TRUE);
 254   TEST_MATCH("*?x", "x", FALSE);
 255   TEST_MATCH("?*x", "x", FALSE);
 256   TEST_MATCH("*?*x", "yx", TRUE);
 257   TEST_MATCH("*?*x", "xxxx", TRUE);
 258   TEST_MATCH("x*??", "xyzw", TRUE);
 259   TEST_MATCH("*x", "\xc4x", TRUE);
 260   TEST_MATCH("?x", "\xc4x", TRUE);
 261   TEST_MATCH("??x", "\xc4x", FALSE);
 262   TEST_MATCH("ab\xe4\xf6", "ab\xe4\xf6", TRUE);
 263   TEST_MATCH("ab\xe4\xf6", "abao", FALSE);
 264   TEST_MATCH("ab?\xf6", "ab\xe4\xf6", TRUE);
 265   TEST_MATCH("ab?\xf6", "abao", FALSE);
 266   TEST_MATCH("ab\xe4?", "ab\xe4\xf6", TRUE);
 267   TEST_MATCH("ab\xe4?", "abao", FALSE);
 268   TEST_MATCH("ab??", "ab\xe4\xf6", TRUE);
 269   TEST_MATCH("ab*", "ab\xe4\xf6", TRUE);
 270   TEST_MATCH("ab*\xf6", "ab\xe4\xf6", TRUE);
 271   TEST_MATCH("ab*\xf6", "aba\xf6x\xf6", TRUE);
 272
 273 #ifdef NOISY
 274   g_print ("\n%u tests passed, %u failed\n", passed, failed);
 275 #endif
 276
 277   return failed;
 278 }
 279
 280