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