gnu/lib/libregex/test/psx-generic.c

   1 /* psx-generic.c: test POSIX re's independent of us using basic or
   2    extended syntax.  */
   3
   4 #include "test.h"
   5
   6
   7 void
   8 test_posix_generic ()
   9 {
  10   int omit_generic_tests = 0; /* reset in debugger to skip */
  11
  12   if (omit_generic_tests)
  13     return;
  14                                 /* Tests somewhat in the order of P1003.2.  */
  15
  16   /* Both posix basic and extended; should match.  */
  17
  18   printf ("\nStarting generic POSIX tests.\n");
  19   test_grouping ();
  20   test_intervals ();
  21
  22   test_should_match = true;
  23                                                   /* Ordinary characters.  */
  24   printf ("\nContinuing generic POSIX tests.\n");
  25
  26   MATCH_SELF ("");
  27   test_fastmap ("", "", 0, 0);
  28   test_fastmap_search ("", "", "", 0, 0, 2, 0, 0);
  29   TEST_REGISTERS ("", "", 0, 0, -1, -1, -1, -1);
  30   TEST_SEARCH ("", "", 0, 0);
  31   TEST_SEARCH_2 ("", "", "", 0, 1, 0);
  32
  33   MATCH_SELF ("abc");
  34   test_fastmap ("abc", "a", 0, 0);
  35   TEST_REGISTERS ("abc", "abc", 0, 3, -1, -1, -1, -1);
  36   TEST_REGISTERS ("abc", "xabcx", 1, 4, -1, -1, -1, -1);
  37
  38   test_match ("\\a","a");
  39   test_match ("\\0", "0");
  40
  41   TEST_SEARCH ("a", "ab", 0, 2);
  42   TEST_SEARCH ("b", "ab", 0, 2);
  43   TEST_SEARCH ("a", "ab", 1, -2);
  44   TEST_SEARCH_2 ("a", "a", "b", 0, 2, 2);
  45   TEST_SEARCH_2 ("b", "a", "b", 0, 2, 2);
  46   TEST_SEARCH_2 ("a", "a", "b", 1, -2, 2);
  47
  48   test_match ("\n", "\n");
  49   test_match ("a\n", "a\n");
  50   test_match ("\nb", "\nb");
  51   test_match ("a\nb", "a\nb");
  52
  53   TEST_SEARCH ("b", "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 236, -237);
  54                                         /* Valid use of special characters. */
  55   test_match ("a*", "aa");
  56   test_fastmap ("a*", "a", 0, 0);
  57   TEST_REGISTERS ("a*", "aa", 0, 2, -1, -1, -1, -1);
  58
  59   test_match ("a*b", "aab");
  60   test_fastmap ("a*b", "ab", 0, 0);
  61
  62   test_match ("a*ab", "aab");
  63   TEST_REGISTERS ("a*a", "aa", 0, 2, -1, -1, -1, -1);
  64   TEST_REGISTERS ("a*a", "xaax", 1, 3, -1, -1, -1, -1);
  65
  66   test_match ("\\{", "{");
  67   test_match ("\\^", "^");
  68   test_match ("\\.", ".");
  69   test_match ("\\*", "*");
  70   test_match ("\\[", "[");
  71   test_match ("\\$", "$");
  72   test_match ("\\\\", "\\");
  73
  74   test_match ("ab*", "a");
  75   test_match ("ab*", "abb");
  76
  77   /* Valid consecutive repetitions.  */
  78   test_match ("a**", "a");
  79                                                 /* Valid period.  */
  80   test_match (".", "a");
  81   TEST_REGISTERS (".", "a", 0, 1, -1, -1, -1, -1);
  82   test_match (".", "\004");
  83   test_match (".", "\n");
  84                                               /* Valid bracket expressions.  */
  85   test_match ("[ab]", "a");
  86   test_match ("[ab]", "b");
  87   test_fastmap ("[ab]", "ab", 0, 0);
  88   TEST_REGISTERS ("[ab]", "a", 0, 1, -1, -1, -1, -1);
  89   TEST_REGISTERS ("[ab]", "xax", 1, 2, -1, -1, -1, -1);
  90
  91   test_fastmap ("[^ab]", "ab", 1, 1);
  92   test_match ("[^ab]", "c");
  93   test_match ("[^a]", "\n");
  94
  95   test_match ("[a]*a", "aa");
  96
  97   test_match ("[[]", "[");
  98   test_match ("[]]", "]");
  99   test_match ("[.]", ".");
 100   test_match ("[*]", "*");
 101   test_match ("[\\]", "\\");
 102   test_match ("[\\(]", "(");
 103   test_match ("[\\)]", ")");
 104   test_match ("[^]]", "a");
 105   test_match ("[a^]", "^");
 106   test_match ("[a$]", "$");
 107   test_match ("[]a]", "]");
 108   test_match ("[a][]]", "a]");
 109   test_match ("[\n]", "\n");
 110   test_match ("[^a]", "\n");
 111   test_match ("[a-]", "a");
 112
 113   TEST_REGISTERS ("\\`[ \t\n]*", " karl (Karl Berry)", 0, 1, -1, -1, -1, -1);
 114   TEST_REGISTERS ("[ \t\n]*\\'", " karl (Karl Berry)", 18, 18, -1, -1, -1, -1);
 115
 116                                                 /* Collating, noncollating,
 117                                                    equivalence classes aren't
 118                                                    implemented yet.  */
 119
 120
 121                                                 /* Character classes.  */
 122   test_match ("[:alpha:]", "p");
 123   test_match ("[[:alpha:]]", "a");
 124   test_match ("[[:alpha:]]", "z");
 125   test_match ("[[:alpha:]]", "A");
 126   test_match ("[[:alpha:]]", "Z");
 127   test_match ("[[:upper:]]", "A");
 128   test_match ("[[:upper:]]", "Z");
 129   test_match ("[[:lower:]]", "a");
 130   test_match ("[[:lower:]]", "z");
 131
 132   test_match ("[[:digit:]]", "0");
 133   test_match ("[[:digit:]]", "9");
 134   test_fastmap ("[[:digit:]]", "0123456789", 0, 0);
 135
 136   test_match ("[[:alnum:]]", "0");
 137   test_match ("[[:alnum:]]", "9");
 138   test_match ("[[:alnum:]]", "a");
 139   test_match ("[[:alnum:]]", "z");
 140   test_match ("[[:alnum:]]", "A");
 141   test_match ("[[:alnum:]]", "Z");
 142   test_match ("[[:xdigit:]]", "0");
 143   test_match ("[[:xdigit:]]", "9");
 144   test_match ("[[:xdigit:]]", "A");
 145   test_match ("[[:xdigit:]]", "F");
 146   test_match ("[[:xdigit:]]", "a");
 147   test_match ("[[:xdigit:]]", "f");
 148   test_match ("[[:space:]]", " ");
 149   test_match ("[[:print:]]", " ");
 150   test_match ("[[:print:]]", "~");
 151   test_match ("[[:punct:]]", ",");
 152   test_match ("[[:graph:]]", "!");
 153   test_match ("[[:graph:]]", "~");
 154   test_match ("[[:cntrl:]]", "\177");
 155   test_match ("[[:digit:]a]", "a");
 156   test_match ("[[:digit:]a]", "2");
 157   test_match ("[a[:digit:]]", "a");
 158   test_match ("[a[:digit:]]", "2");
 159   test_match ("[[:]", "[");
 160   test_match ("[:]", ":");
 161   test_match ("[[:a]", "[");
 162   test_match ("[[:alpha:a]", "[");
 163                                                 /* Valid ranges.  */
 164   test_match ("[a-a]", "a");
 165   test_fastmap ("[a-a]", "a", 0, 0);
 166   TEST_REGISTERS ("[a-a]", "xax", 1, 2, -1, -1, -1, -1);
 167
 168   test_match ("[a-z]", "z");
 169   test_fastmap ("[a-z]", "abcdefghijklmnopqrstuvwxyz", 0, 0);
 170   test_match ("[-a]", "-");             /* First  */
 171   test_match ("[-a]", "a");
 172   test_match ("[a-]", "-");             /* Last  */
 173   test_match ("[a-]", "a");
 174   test_match ("[--@]", "@");            /* First and starting point.  */
 175
 176   test_match ("[%--a]", "%");           /* Ending point.  */
 177   test_match ("[%--a]", "-");           /* Ditto.  */
 178
 179   test_match ("[a%--]", "%");           /* Both ending point and last.  */
 180   test_match ("[a%--]", "-");
 181   test_match ("[%--a]", "a");           /* Ending point only.  */
 182   test_match ("[a-c-f]", "e");          /* Piggyback.  */
 183
 184   test_match ("[)-+--/]", "*");
 185   test_match ("[)-+--/]", ",");
 186   test_match ("[)-+--/]", "/");
 187   test_match ("[[:digit:]-]", "-");
 188                                         /* Concatenation  ????*/
 189   test_match ("[ab][cd]", "ac");
 190   test_fastmap ("[ab][cd]", "ab", 0, 0);
 191   TEST_REGISTERS ("[ab][cd]", "ad", 0, 2, -1, -1, -1, -1);
 192   TEST_REGISTERS ("[ab][cd]", "xadx", 1, 3, -1, -1, -1, -1);
 193
 194                                              /* Valid expression anchoring.  */
 195   test_match ("^a", "a");
 196   test_fastmap ("^a", "a", 0, 0);
 197   TEST_REGISTERS ("^a", "ax", 0, 1, -1, -1, -1, -1);
 198
 199   test_match ("^", "");
 200   TEST_REGISTERS ("^", "", 0, 0, -1, -1, -1, -1);
 201   test_match ("$", "");
 202   TEST_REGISTERS ("$", "", 0, 0, -1, -1, -1, -1);
 203
 204   test_match ("a$", "a");
 205   test_fastmap ("a$", "a", 0, 0);
 206   TEST_REGISTERS ("a$", "xa", 1, 2, -1, -1, -1, -1);
 207
 208   test_match ("^ab$", "ab");
 209   test_fastmap ("^ab$", "a", 0, 0);
 210   TEST_REGISTERS ("^a$", "a", 0, 1, -1, -1, -1, -1);
 211
 212   test_fastmap ("^$", "", 0, 0);
 213   test_match ("^$", "");
 214   TEST_REGISTERS ("^$", "", 0, 0, -1, -1, -1, -1);
 215
 216   TEST_SEARCH (PARENS_TO_OPS ("(^a)"), "ab", 0, 2);
 217   TEST_SEARCH (PARENS_TO_OPS ("(a$)"), "ba", 0, 2);
 218   TEST_SEARCH (PARENS_TO_OPS ("^(^a)"), "ab", 0, 2);
 219   TEST_SEARCH (PARENS_TO_OPS ("(a$)$"), "ba", 0, 2);
 220
 221                                                 /* Two strings.  */
 222   test_match_2 ("ab", "a", "b");
 223   TEST_REGISTERS_2 ("ab", "a", "b", 0, 2, -1, -1, -1, -1);
 224
 225   test_match_2 ("a", "", "a");
 226   test_match_2 ("a", "a", "");
 227   test_match_2 ("ab", "a", "b");
 228                                                 /* (start)pos.  */
 229   TEST_POSITIONED_MATCH ("b", "ab", 1);
 230                                                 /* mstop.  */
 231   TEST_TRUNCATED_MATCH ("a", "ab", 1);
 232
 233
 234   /* Both basic and extended, continued; should not match.  */
 235
 236   test_should_match = false;
 237                                           /* Ordinary characters.  */
 238   test_match ("abc", "ab");
 239
 240   TEST_SEARCH ("c", "ab", 0, 2);
 241   TEST_SEARCH ("c", "ab", 0, 2);
 242   TEST_SEARCH ("c", "ab", 1, -2);
 243   TEST_SEARCH ("c", "ab", 0, 10);
 244   TEST_SEARCH ("c", "ab", 1, -10);
 245   TEST_SEARCH_2 ("c", "a", "b", 0, 2, 2);
 246   TEST_SEARCH_2 ("c", "a", "b", 0, 2, 2);
 247   TEST_SEARCH_2 ("c", "a", "b", 0, 2, 2);
 248   TEST_SEARCH_2 ("c", "a", "b", 1, -2, 2);
 249   TEST_SEARCH_2 ("c", "a", "b", 1, -2, 2);
 250
 251   TEST_SEARCH ("c", "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 236, -237);
 252
 253                                 /* Invalid use of special characters.  */
 254   invalid_pattern (REG_EESCAPE, "\\");
 255   invalid_pattern (REG_EESCAPE, "a\\");
 256   invalid_pattern (REG_EESCAPE, "a*\\");
 257                                                   /* Invalid period.  */
 258   test_match (".", "");
 259                                           /* Invalid bracket expressions.  */
 260   test_match ("[ab]", "c");
 261   test_match ("[^b]", "b");
 262   test_match ("[^]]", "]");
 263
 264   invalid_pattern (REG_EBRACK, "[");
 265   invalid_pattern (REG_EBRACK, "[^");
 266   invalid_pattern (REG_EBRACK, "[a");
 267   invalid_pattern (REG_EBRACK, "[]");
 268   invalid_pattern (REG_EBRACK, "[]a");
 269   invalid_pattern (REG_EBRACK, "a[]a");
 270
 271
 272   test_match ("[:alpha:]", "q");               /* Character classes.  */
 273   test_match ("[[:alpha:]]", "2");
 274   test_match ("[[:upper:]]", "a");
 275   test_match ("[[:lower:]]", "A");
 276   test_match ("[[:digit:]]", "a");
 277   test_match ("[[:alnum:]]", ":");
 278   test_match ("[[:xdigit:]]", "g");
 279   test_match ("[[:space:]]", "a");
 280   test_match ("[[:print:]]", "\177");
 281   test_match ("[[:punct:]]", "a");
 282   test_match ("[[:graph:]]", " ");
 283   test_match ("[[:cntrl:]]", "a");
 284   invalid_pattern (REG_EBRACK, "[[:");
 285   invalid_pattern (REG_EBRACK, "[[:alpha:");
 286   invalid_pattern (REG_EBRACK, "[[:alpha:]");
 287   invalid_pattern (REG_ECTYPE, "[[::]]");
 288   invalid_pattern (REG_ECTYPE, "[[:a:]]");
 289   invalid_pattern (REG_ECTYPE, "[[:alpo:]]");
 290   invalid_pattern (REG_ECTYPE, "[[:a:]");
 291
 292   test_match ("[a-z]", "2");                    /* Invalid ranges.  */
 293   test_match ("[^-a]", "-");
 294   test_match ("[^a-]", "-");
 295   test_match ("[)-+--/]", ".");
 296   invalid_pattern (REG_ERANGE, "[z-a]");                /* Empty  */
 297   invalid_pattern (REG_ERANGE, "[a--]");                /* Empty  */
 298   invalid_pattern (REG_ERANGE, "[[:digit:]-9]");
 299   invalid_pattern (REG_ERANGE, "[a-[:alpha:]]");
 300   invalid_pattern (REG_ERANGE, "[a-");
 301   invalid_pattern (REG_EBRACK, "[a-z");
 302
 303   test_match ("[ab][cd]", "ae");                /* Concatenation.  */
 304   test_match ("b*c", "b");                      /* Star.  */
 305
 306                                                 /* Invalid anchoring.  */
 307   test_match ("^", "a");
 308   test_match ("^a", "ba");
 309   test_match ("$", "b");
 310   test_match ("a$", "ab");
 311   test_match ("^$", "a");
 312   test_match ("^ab$", "a");
 313
 314   TEST_SEARCH ("^a", "b\na", 0, 3);
 315   TEST_SEARCH ("b$", "b\na", 0, 3);
 316
 317   test_match_2 ("^a", "\n", "a");
 318   test_match_2 ("a$", "a", "\n");
 319
 320   TEST_SEARCH (PARENS_TO_OPS ("(^a)"), "ba", 0, 2);
 321   TEST_SEARCH (PARENS_TO_OPS ("(a$)"), "ab", 0, 2);
 322   TEST_SEARCH (PARENS_TO_OPS ("^(^a)"), "ba", 0, 2);
 323   TEST_SEARCH (PARENS_TO_OPS ("(a$)$"), "ab", 0, 2);
 324
 325   printf ("\nFinished generic POSIX tests.\n");
 326 }
 327
 328
 329 \f
 330 /*
 331 Local variables:
 332 make-backup-files: t
 333 version-control: t
 334 trim-versions-without-asking: nil
 335 End:
 336 */