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

   1 /* psx-group.c: test POSIX grouping, both basic and extended.  */
   2
   3 #include "test.h"
   4
   5
   6 void
   7 test_grouping ()
   8 {
   9   printf ("\nStarting POSIX grouping tests.\n");
  10
  11   test_should_match = true;
  12
  13   test_fastmap (PARENS_TO_OPS ("(a)"), "a", 0, 0);
  14   test_match (PARENS_TO_OPS ("(a)"), "a");
  15   TEST_REGISTERS (PARENS_TO_OPS ("(a)"), "a", 0, 1, 0, 1, -1, -1);
  16   TEST_REGISTERS (PARENS_TO_OPS ("(a)"), "xax", 1, 2, 1, 2, -1, -1);
  17
  18   test_match (PARENS_TO_OPS ("((a))"), "a");
  19   test_fastmap (PARENS_TO_OPS ("((a))"), "a", 0, 0);
  20   TEST_REGISTERS (PARENS_TO_OPS ("((a))"), "a", 0, 1, 0, 1, 0, 1);
  21   TEST_REGISTERS (PARENS_TO_OPS ("((a))"), "xax", 1, 2, 1, 2, 1, 2);
  22
  23   test_fastmap (PARENS_TO_OPS ("(a)(b)"), "a", 0, 0);
  24   test_match (PARENS_TO_OPS ("(a)(b)"), "ab");
  25   TEST_REGISTERS (PARENS_TO_OPS ("(a)(b)"), "ab", 0, 2, 0, 1, 1, 2);
  26
  27   TEST_REGISTERS (PARENS_TO_OPS ("(a)(b)"), "xabx", 1, 3, 1, 2, 2, 3);
  28
  29   test_all_registers (PARENS_TO_OPS ("((a)(b))"), "ab", "", 0, 2, 0, 2, 0, 1,
  30                    1, 2,  -1, -1,  -1, -1,  -1, -1,  -1, -1,  -1, -1,  -1, -1);
  31
  32
  33   /* Test that we simply ignore groups past the 255th.  */
  34   test_match (PARENS_TO_OPS ("((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((a))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))"), "a");
  35
  36
  37   /* Per POSIX D11.1, p. 125.  */
  38
  39   test_fastmap (PARENS_TO_OPS ("(a)*"), "a", 0, 0);
  40   test_match (PARENS_TO_OPS ("(a)*"), "");
  41   TEST_REGISTERS (PARENS_TO_OPS ("(a)*"), "", 0, 0, -1, -1, -1, -1);
  42   TEST_REGISTERS (PARENS_TO_OPS ("(a)*"), "aa", 0, 2, 1, 2, -1, -1);
  43
  44   test_fastmap (PARENS_TO_OPS ("(a*)"), "a", 0, 0);
  45   test_match (PARENS_TO_OPS ("(a*)"), "");
  46   TEST_REGISTERS (PARENS_TO_OPS ("(a*)"), "", 0, 0, 0, 0, -1, -1);
  47
  48   test_fastmap (PARENS_TO_OPS ("(a*)"), "a", 0, 0);
  49   test_match (PARENS_TO_OPS ("(a*)"), "a");
  50   TEST_REGISTERS (PARENS_TO_OPS ("(a*)"), "a", 0, 1, 0, 1, -1, -1);
  51
  52   test_fastmap (PARENS_TO_OPS ("(a*)b"), "ab", 0, 0);
  53   test_match (PARENS_TO_OPS ("(a*)b"), "b");
  54   TEST_REGISTERS (PARENS_TO_OPS ("(a*)b"), "b", 0, 1, 0, 0, -1, -1);
  55
  56   test_match (PARENS_TO_OPS ("(a*)b"), "ab");
  57   TEST_REGISTERS (PARENS_TO_OPS ("(a*)b"), "ab", 0, 2, 0, 1, -1, -1);
  58
  59   test_fastmap (PARENS_TO_OPS ("((a*)b)*"), "ab", 0, 0);
  60   test_match (PARENS_TO_OPS ("((a*)b)*"), "");
  61   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "", 0, 0, -1, -1, -1, -1);
  62
  63   test_match (PARENS_TO_OPS ("((a*)b)*"), "ab");
  64   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "ab", 0, 2, 0, 2, 0, 1);
  65
  66   test_match (PARENS_TO_OPS ("((a*)b)*"), "abb");
  67   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "abb", 0, 3, 2, 3, 2, 2);
  68
  69   test_match (PARENS_TO_OPS ("((a*)b)*"), "aabab");
  70   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "aabab", 0, 5, 3, 5, 3, 4);
  71
  72   test_match (PARENS_TO_OPS ("((a*)b)*"), "abbab");
  73   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "abbab", 0, 5, 3, 5, 3, 4);
  74
  75   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "xabbabx", 0, 0, -1, -1, -1, -1);
  76
  77   test_match (PARENS_TO_OPS ("((a*)b)*"), "abaabaaaab");
  78   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "abaabaaab", 0, 9, 5, 9, 5, 8);
  79
  80   test_fastmap (PARENS_TO_OPS ("(ab)*"), "a", 0, 0);
  81   test_match (PARENS_TO_OPS ("(ab)*"), "");
  82   TEST_REGISTERS (PARENS_TO_OPS ("(ab)*"), "", 0, 0, -1, -1, -1, -1);
  83
  84   test_match (PARENS_TO_OPS ("(ab)*"), "abab");
  85   TEST_REGISTERS (PARENS_TO_OPS ("(ab)*"), "abab", 0, 4, 2, 4, -1, -1);
  86
  87   /* We match the empty string here.  */
  88   TEST_REGISTERS (PARENS_TO_OPS ("(ab)*"), "xababx", 0, 0, -1, -1, -1, -1);
  89
  90   /* Per David A. Willcox.  */
  91   TEST_REGISTERS (PARENS_TO_OPS ("a(b*)c"), "ac", 0, 2, 1, 1, -1, -1);
  92
  93   test_fastmap (PARENS_TO_OPS ("(a)*b"), "ab", 0, 0);
  94   test_match (PARENS_TO_OPS ("(a)*b"), "b");
  95   TEST_REGISTERS (PARENS_TO_OPS ("(a)*b"), "b", 0, 1, -1, -1, -1, -1);
  96
  97   test_match (PARENS_TO_OPS ("(a)*b"), "ab");
  98   TEST_REGISTERS (PARENS_TO_OPS ("(a)*b"), "ab", 0, 2, 0, 1, -1, -1);
  99
 100   test_match_2 (PARENS_TO_OPS ("(a)*b"), "a", "ab");
 101   TEST_REGISTERS_2 (PARENS_TO_OPS ("(a)*b"), "a", "ab", 0, 3, 1, 2, -1, -1);
 102
 103   test_match (PARENS_TO_OPS ("(a)*b"), "aab");
 104   TEST_REGISTERS (PARENS_TO_OPS ("(a)*b"), "aab", 0, 3, 1, 2, -1, -1);
 105
 106   test_fastmap (PARENS_TO_OPS ("(a)*a"), "a", 0, 0);
 107   test_match (PARENS_TO_OPS ("(a)*a"), "a");
 108   TEST_REGISTERS (PARENS_TO_OPS ("(a)*a"), "a", 0, 1, -1, -1, -1, -1);
 109
 110   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*"), "", 0, 0, 0, 0, 0, 0);
 111
 112   test_match (PARENS_TO_OPS ("((a*))*"), "");
 113   TEST_REGISTERS (PARENS_TO_OPS ("((a*))*"), "", 0, 0, 0, 0, 0, 0);
 114   test_match (PARENS_TO_OPS ("((a*))*"), "aa");
 115
 116   test_fastmap (PARENS_TO_OPS ("(a*)*b"), "ab", 0, 0);
 117   test_match (PARENS_TO_OPS ("(a*)*b"), "b");
 118   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "b", 0, 1, 0, 0, -1, -1);
 119
 120   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "xbx", 1, 2, 1, 1, -1, -1);
 121
 122   test_match (PARENS_TO_OPS ("(a*)*b"), "ab");  /* Per rms.  */
 123   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "ab", 0, 2, 0, 1, -1, -1);
 124
 125   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "xabx", 1, 3, 1, 2, -1, -1);
 126
 127   /* Test register restores.  */
 128   test_match (PARENS_TO_OPS ("(a*)*b"), "aab");
 129   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "aab", 0, 3, 0, 2, -1, -1);
 130
 131   TEST_REGISTERS_2 (PARENS_TO_OPS ("(a*)*b"), "a", "ab", 0, 3, 0, 2, -1, -1);
 132
 133   /* We are matching the empty string, with backtracking.  */
 134   test_fastmap (PARENS_TO_OPS ("(a*)a"), "a", 0, 0);
 135   test_match (PARENS_TO_OPS ("(a*)a"), "a");
 136   TEST_REGISTERS (PARENS_TO_OPS ("(a*)a"), "a", 0, 1, 0, 0, -1, -1);
 137
 138   test_match (PARENS_TO_OPS ("(a*)a"), "aa");
 139   TEST_REGISTERS (PARENS_TO_OPS ("(a*)a"), "aa", 0, 2, 0, 1, -1, -1);
 140
 141   /* We are matching the empty string, with backtracking.  */
 142 /*fails  test_match (PARENS_TO_OPS ("(a*)*a"), "a"); */
 143   test_match (PARENS_TO_OPS ("(a*)*a"), "aa");
 144   /* Match the empty string.  */
 145   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*a"), "a", 0, 1, 0, 0, -1, -1);
 146   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*a"), "xax", 1, 2, 1, 1, -1, -1);
 147   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*a"), "aa", 0, 2, 0, 1, -1, -1);
 148   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*a"), "xaax", 1, 3, 1, 2, -1, -1);
 149
 150   test_fastmap (PARENS_TO_OPS ("(a)*ab"), "a", 0 , 0);
 151   test_match (PARENS_TO_OPS ("(a)*ab"), "ab");
 152   TEST_REGISTERS (PARENS_TO_OPS ("(a)*ab"), "ab", 0, 2, -1, -1, -1, -1);
 153
 154   test_match (PARENS_TO_OPS ("(a)*ab"), "aab");
 155   TEST_REGISTERS (PARENS_TO_OPS ("(a)*ab"), "aab", 0, 3, 0, 1, -1, -1);
 156
 157   TEST_REGISTERS (PARENS_TO_OPS("(a)*ab"), "xaabx", 1, 4, 1, 2, -1, -1);
 158
 159   test_fastmap (PARENS_TO_OPS ("(a*)ab"), "a", 0 , 0);
 160   test_match (PARENS_TO_OPS ("(a*)ab"), "ab");
 161   TEST_REGISTERS (PARENS_TO_OPS ("(a*)ab"), "ab", 0, 2, 0, 0, -1, -1);
 162
 163   test_match (PARENS_TO_OPS ("(a*)ab"), "aab");
 164   TEST_REGISTERS (PARENS_TO_OPS ("(a*)ab"), "aab", 0, 3, 0, 1, -1, -1);
 165
 166   TEST_REGISTERS (PARENS_TO_OPS ("(a*)ab"), "xaabx", 1, 4, 1, 2, -1, -1);
 167
 168   test_fastmap (PARENS_TO_OPS ("(a*)*ab"), "a", 0 , 0);
 169   test_match (PARENS_TO_OPS ("(a*)*ab"), "ab");
 170   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*ab"), "ab", 0, 2, 0, 0, -1, -1);
 171
 172   test_match (PARENS_TO_OPS ("(a*)*ab"), "aab");
 173   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*ab"), "aab", 0, 3, 0, 1, -1, -1);
 174
 175   TEST_REGISTERS (PARENS_TO_OPS("(a*)*ab"), "xaabx", 1, 4, 1, 2, -1, -1);
 176
 177   test_fastmap (PARENS_TO_OPS ("(a*)*b*c"), "abc", 0, 0);
 178   test_match (PARENS_TO_OPS ("(a*)*b*c"), "c");
 179   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b*c"), "c", 0, 1, 0, 0, -1, -1);
 180
 181   test_fastmap (PARENS_TO_OPS ("(a)*(ab)*"), "a", 0, 0);
 182   test_match (PARENS_TO_OPS ("(a)*(ab)*"), "ab");
 183   /* Register 1 doesn't match at all (vs. matching the empty string)
 184      because of backtracking, hence -1's.  */
 185   TEST_REGISTERS (PARENS_TO_OPS ("(a)*(ab)*"), "ab", 0, 2, -1, -1, 0, 2);
 186
 187   test_match (PARENS_TO_OPS ("(a*)*(ab)*"), "ab");
 188   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*(ab)*"), "ab", 0, 2, 0, 0, 0, 2);
 189
 190   test_fastmap (PARENS_TO_OPS ("(a*b)*"), "ab", 0, 0);
 191   test_match (PARENS_TO_OPS ("(a*b)*"), "");
 192   TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*"), "", 0, 0, -1, -1, -1, -1);
 193
 194   test_match (PARENS_TO_OPS ("(a*b)*"), "b");
 195   TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*"), "b", 0, 1, 0, 1, -1, -1);
 196
 197   test_match (PARENS_TO_OPS ("(a*b)*"), "baab");
 198   TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*"), "baab", 0, 4, 1, 4, -1, -1);
 199
 200   test_fastmap (PARENS_TO_OPS ("(a*b*)*"), "ab", 0, 0);
 201   test_match (PARENS_TO_OPS ("(a*b*)*"), "");
 202   TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "", 0, 0, 0, 0, -1, -1);
 203
 204   test_match (PARENS_TO_OPS ("(a*b*)*"), "a");
 205   TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "a", 0, 1, 0, 1, -1, -1);
 206
 207   test_match (PARENS_TO_OPS ("(a*b*)*"), "ba");
 208   TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "ba", 0, 2, 1, 2, -1, -1);
 209
 210   test_match (PARENS_TO_OPS ("(a*b*)*"), "ab");
 211   TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "ab", 0, 2, 0, 2, -1, -1);
 212
 213   test_match (PARENS_TO_OPS ("(a*b*)*"), "aa");
 214   TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "aa", 0, 2, 0, 2, -1, -1);
 215
 216   test_match (PARENS_TO_OPS ("(a*b*)*"), "bb");
 217   TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "bb", 0, 2, 0, 2, -1, -1);
 218
 219   test_match (PARENS_TO_OPS ("(a*b*)*"), "aba");
 220   TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "aba", 0, 3, 2, 3, -1, -1);
 221
 222   test_match (PARENS_TO_OPS ("(a*b*)b"), "b");
 223   TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)b"), "b", 0, 1, 0, 0, -1, -1);
 224
 225   test_fastmap (PARENS_TO_OPS ("((a*)*(b*)*)*"), "ab", 0, 0);
 226   test_match (PARENS_TO_OPS ("((a*)*(b*)*)*"), "");
 227   test_all_registers (PARENS_TO_OPS ("((a*)*(b*)*)*"), "", "", 0, 0, 0, 0,
 228                   0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 229
 230   test_match (PARENS_TO_OPS ("((a*)*(b*)*)*"), "aba");
 231   /* Perhaps register 3 should be 3/3 here?  Not sure if standard
 232      specifies this.  xx*/
 233   test_all_registers (PARENS_TO_OPS ("((a*)*(b*)*)*"), "aba", "", 0, 3, 2, 3,
 234                   2, 3, 1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 235
 236   test_fastmap (PARENS_TO_OPS ("((a*)(b*))*"), "ab", 0, 0);
 237   test_match (PARENS_TO_OPS ("((a*)(b*))*"), "");
 238
 239   test_all_registers (PARENS_TO_OPS ("((a*)(b*))*"), "", "", 0, 0, 0, 0,
 240                   0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 241
 242   test_match (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "");
 243
 244   test_match (PARENS_TO_OPS ("((a*)(b*))*"), "aba");
 245   test_all_registers (PARENS_TO_OPS ("((a*)(b*))*"), "aba", "", 0, 3, 2, 3,
 246                   2, 3, 3, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 247
 248   test_fastmap (PARENS_TO_OPS ("((a)*(b)*)*"), "ab", 0, 0);
 249   test_match (PARENS_TO_OPS ("((a)*(b)*)*"), "");
 250   test_all_registers (PARENS_TO_OPS ("((a)*(b)*)*"), "", "", 0, 0, 0, 0,
 251         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 252
 253   test_match (PARENS_TO_OPS ("((a)*(b)*)*"), "aba");
 254
 255   test_all_registers (PARENS_TO_OPS ("((a)*(b)*)*"), "aba", "", 0, 3, 2, 3,
 256                   2, 3, 1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 257
 258   test_fastmap (PARENS_TO_OPS ("(c(a)*(b)*)*"), "c", 0, 0);
 259   test_match (PARENS_TO_OPS ("(c(a)*(b)*)*"), "");
 260   test_all_registers (PARENS_TO_OPS ("(c(a)*(b)*)*"), "", "", 0, 0, -1, -1,
 261         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 262
 263   test_match (PARENS_TO_OPS ("(c(a)*(b)*)*"), "c");
 264   test_all_registers (PARENS_TO_OPS ("(c(a)*(b)*)*"), "c", "", 0, 1, 0, 1,
 265         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 266
 267   test_fastmap (PARENS_TO_OPS ("c((a)*(b)*)*"), "c", 0, 0);
 268   test_match (PARENS_TO_OPS ("c((a)*(b)*)*"), "c");
 269   test_all_registers (PARENS_TO_OPS ("c((a)*(b)*)*"), "c", "", 0, 1, 1, 1,
 270         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 271
 272   test_fastmap (PARENS_TO_OPS ("(((a)*(b)*)*)*"), "ab", 0, 0);
 273   test_match (PARENS_TO_OPS ("(((a)*(b)*)*)*"), "");
 274   test_all_registers (PARENS_TO_OPS ("(((a)*(b)*)*)*"), "", "", 0, 0, 0, 0,
 275         0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 276
 277   test_match (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "");
 278   test_fastmap (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "c", 0, 0);
 279
 280   test_all_registers (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "", "", 0, 0, -1, -1,
 281         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
 282
 283   test_fastmap (PARENS_TO_OPS ("((a)*b)*"), "ab", 0, 0);
 284   test_match (PARENS_TO_OPS ("((a)*b)*"), "");
 285
 286   test_match (PARENS_TO_OPS ("((a)*b)*"), "");
 287   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "", 0, 0, -1, -1, -1, -1);
 288
 289   test_match (PARENS_TO_OPS ("((a)*b)*"), "abb");
 290   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "abb", 0, 3, 2, 3, 0, 1); /*zz*/
 291
 292   test_match (PARENS_TO_OPS ("((a)*b)*"), "abbab");
 293   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "abbab", 0, 5, 3, 5, 3, 4);
 294
 295   /* We match the empty string here.  */
 296   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "xabbabx", 0, 0, -1, -1, -1, -1);
 297
 298   test_fastmap (PARENS_TO_OPS ("(a*)*"), "a", 0, 0);
 299   test_match (PARENS_TO_OPS ("(a*)*"), "");
 300   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*"), "", 0, 0, 0, 0, -1, -1);
 301
 302   test_match (PARENS_TO_OPS ("(a*)*"), "aa");
 303   TEST_REGISTERS (PARENS_TO_OPS ("(a*)*"), "aa", 0, 2, 0, 2, -1, -1);
 304
 305   test_fastmap (PARENS_TO_OPS ("((a*)*)*"), "a", 0, 0);
 306   test_match (PARENS_TO_OPS ("((a*)*)*"), "");
 307   TEST_REGISTERS (PARENS_TO_OPS ("((a*)*)*"), "", 0, 0, 0, 0, 0, 0);
 308
 309   test_match (PARENS_TO_OPS ("((a*)*)*"), "a");
 310   TEST_REGISTERS (PARENS_TO_OPS ("((a*)*)*"), "a", 0, 1, 0, 1, 0, 1);
 311
 312   test_fastmap (PARENS_TO_OPS ("(ab*)*"), "a", 0, 0);
 313   test_match (PARENS_TO_OPS ("(ab*)*"), "");
 314   TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*"), "", 0, 0, -1, -1, -1, -1);
 315
 316   test_match (PARENS_TO_OPS ("(ab*)*"), "aa");
 317   TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*"), "aa", 0, 2, 1, 2, -1, -1);
 318
 319   test_fastmap (PARENS_TO_OPS ("(ab*)*c"), "ac", 0, 0);
 320   test_match (PARENS_TO_OPS ("(ab*)*c"), "c");
 321   TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*c"), "c", 0, 1, -1, -1, -1, -1);
 322
 323   test_match (PARENS_TO_OPS ("(ab*)*c"), "abbac");
 324   TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*c"), "abbac", 0, 5, 3, 4, -1, -1);
 325
 326   test_match (PARENS_TO_OPS ("(ab*)*c"), "abac");
 327   TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*c"), "abac", 0, 4, 2, 3, -1, -1);
 328
 329   test_fastmap (PARENS_TO_OPS ("(a*b)*c"), "abc", 0, 0);
 330   test_match (PARENS_TO_OPS ("(a*b)*c"), "c");
 331   TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*c"), "c", 0, 1, -1, -1, -1, -1);
 332
 333   test_match (PARENS_TO_OPS ("(a*b)*c"), "bbc");
 334   TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*c"), "bbc", 0, 3, 1, 2, -1, -1);
 335
 336   test_match (PARENS_TO_OPS ("(a*b)*c"), "aababc");
 337   TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*c"), "aababc", 0, 6, 3, 5, -1, -1);
 338
 339   test_match (PARENS_TO_OPS ("(a*b)*c"), "aabaabc");
 340   TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*c"), "aabaabc", 0, 7, 3, 6, -1, -1);
 341
 342   test_fastmap (PARENS_TO_OPS ("((a*)b*)"), "ab", 0, 0);
 343   test_match (PARENS_TO_OPS ("((a*)b*)"), "");
 344   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)"), "", 0, 0, 0, 0, 0, 0);
 345
 346   test_match (PARENS_TO_OPS ("((a*)b*)"), "a");
 347   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)"), "a", 0, 1, 0, 1, 0, 1);
 348
 349   test_match (PARENS_TO_OPS ("((a*)b*)"), "b");
 350   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)"), "b", 0, 1, 0, 1, 0, 0);
 351
 352   test_fastmap (PARENS_TO_OPS ("((a)*b*)"), "ab", 0, 0);
 353   test_match (PARENS_TO_OPS ("((a)*b*)"), "");
 354   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "", 0, 0, 0, 0, -1, -1);
 355
 356   test_match (PARENS_TO_OPS ("((a)*b*)"), "a");
 357   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "a", 0, 1, 0, 1, 0, 1);
 358
 359   test_match (PARENS_TO_OPS ("((a)*b*)"), "b");
 360   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "b", 0, 1, 0, 1, -1, -1);
 361
 362   test_match (PARENS_TO_OPS ("((a)*b*)"), "ab");
 363   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "ab", 0, 2, 0, 2, 0, 1);
 364
 365   test_fastmap (PARENS_TO_OPS ("((a*)b*)c"), "abc", 0, 0);
 366   test_match (PARENS_TO_OPS ("((a*)b*)c"), "c");
 367   TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)c"), "c", 0, 1, 0, 0, 0, 0);
 368
 369   test_fastmap (PARENS_TO_OPS ("((a)*b*)c"), "abc", 0, 0);
 370   test_match (PARENS_TO_OPS ("((a)*b*)c"), "c");
 371   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)c"), "c", 0, 1, 0, 0, -1, -1);
 372
 373   test_fastmap (PARENS_TO_OPS ("(a*b*)*"), "ab", 0, 0);
 374   test_match (PARENS_TO_OPS ("(a*b*)*"), "");
 375   TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "", 0, 0, 0, 0, -1, -1);
 376
 377   test_fastmap (PARENS_TO_OPS ("(((a*))((b*)))*"), "ab", 0, 0);
 378   test_match (PARENS_TO_OPS ("(((a*))((b*)))*"), "");
 379   test_all_registers (PARENS_TO_OPS ("(((a*))((b*)))*"), "", "", 0, 0,
 380     0, 0,  0, 0,  0, 0,  0, 0,  0, 0,  -1, -1,  -1, -1,  -1, -1,  -1, -1);
 381
 382   test_fastmap (PARENS_TO_OPS ("(c*((a*))d*((b*))e*)*"), "abcde", 0, 0);
 383   test_match (PARENS_TO_OPS ("(c*((a*))d*((b*))e*)*"), "");
 384   test_all_registers (PARENS_TO_OPS ("(c*((a*))d*((b*))e*)*"), "", "", 0, 0,
 385     0, 0,  0, 0,  0, 0,  0, 0,  0, 0,  -1, -1,  -1, -1,  -1, -1,  -1, -1);
 386
 387   test_fastmap (PARENS_TO_OPS ("((a)*b)*c"), "abc", 0, 0);
 388   test_match (PARENS_TO_OPS ("((a)*b)*c"), "c");
 389   TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*c"), "c", 0, 1, -1, -1, -1, -1);
 390
 391   test_match (PARENS_TO_OPS ("(ab)*"), "");
 392   test_match (PARENS_TO_OPS ("((ab)*)"), "");
 393   test_match (PARENS_TO_OPS ("(((ab)*))"), "");
 394   test_match (PARENS_TO_OPS ("((((ab)*)))"), "");
 395   test_match (PARENS_TO_OPS ("(((((ab)*))))"), "");
 396   test_match (PARENS_TO_OPS ("((((((ab)*)))))"), "");
 397   test_match (PARENS_TO_OPS ("(((((((ab)*))))))"), "");
 398   test_match (PARENS_TO_OPS ("((((((((ab)*)))))))"), "");
 399   test_match (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "");
 400
 401
 402   test_fastmap (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "a", 0, 0);
 403   test_match (PARENS_TO_OPS ("((((((((((ab)*)))))))))"), "");
 404   test_match (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "");
 405   test_all_registers (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "", NULL,
 406         0, 0,  0, 0,  0, 0,  0, 0,  0, 0,  0, 0,  0, 0,  0, 0,  0, 0,  -1, -1);
 407
 408   test_match (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "abab");
 409   test_all_registers (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "abab", NULL,
 410           0, 4,  0, 4,  0, 4,  0, 4,  0, 4,  0, 4,  0, 4,  0, 4,  0, 4,  2, 4);
 411
 412
 413   test_should_match = false;
 414
 415   invalid_pattern (REG_EPAREN, PARENS_TO_OPS ("(a"));
 416
 417   test_match (PARENS_TO_OPS ("(a)"), "");
 418   test_match (PARENS_TO_OPS ("((a))"), "b");
 419   test_match (PARENS_TO_OPS ("(a)(b)"), "ac");
 420   test_match (PARENS_TO_OPS ("(ab)*"), "acab");
 421   test_match (PARENS_TO_OPS ("(a*)*b"), "c");
 422   test_match (PARENS_TO_OPS ("(a*b)*"), "baa");
 423   test_match (PARENS_TO_OPS ("(a*b)*"), "baabc");
 424   test_match (PARENS_TO_OPS ("(a*b*)*"), "c");
 425   test_match (PARENS_TO_OPS ("((a*)*(b*)*)*"), "c");
 426   test_match (PARENS_TO_OPS ("(a*)*"), "ab");
 427   test_match (PARENS_TO_OPS ("((a*)*)*"), "ab");
 428   test_match (PARENS_TO_OPS ("((a*)*)*"), "b");
 429   test_match (PARENS_TO_OPS ("(ab*)*"), "abc");
 430   test_match (PARENS_TO_OPS ("(ab*)*c"), "abbad");
 431   test_match (PARENS_TO_OPS ("(a*c)*b"), "aacaacd");
 432   test_match (PARENS_TO_OPS ("(a*)"), "b");
 433   test_match (PARENS_TO_OPS ("((a*)b*)"), "c");
 434
 435                                                 /* Expression anchoring.  */
 436   TEST_SEARCH (PARENS_TO_OPS ("(^b)"), "ab", 0, 2);
 437   TEST_SEARCH (PARENS_TO_OPS ("(a$)"), "ab", 0, 2);
 438
 439   printf ("\nFinished POSIX grouping tests.\n");
 440 }