1 /* psx-group.c: test POSIX grouping, both basic and extended. */
9 printf ("\nStarting POSIX grouping tests.\n");
11 test_should_match = true;
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);
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);
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);
27 TEST_REGISTERS (PARENS_TO_OPS ("(a)(b)"), "xabx", 1, 3, 1, 2, 2, 3);
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);
33 /* Test that we simply ignore groups past the 255th. */
34 test_match (PARENS_TO_OPS ("((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((a))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))"), "a");
37 /* Per POSIX D11.1, p. 125. */
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);
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);
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);
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);
56 test_match (PARENS_TO_OPS ("(a*)b"), "ab");
57 TEST_REGISTERS (PARENS_TO_OPS ("(a*)b"), "ab", 0, 2, 0, 1, -1, -1);
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);
63 test_match (PARENS_TO_OPS ("((a*)b)*"), "ab");
64 TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "ab", 0, 2, 0, 2, 0, 1);
66 test_match (PARENS_TO_OPS ("((a*)b)*"), "abb");
67 TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "abb", 0, 3, 2, 3, 2, 2);
69 test_match (PARENS_TO_OPS ("((a*)b)*"), "aabab");
70 TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "aabab", 0, 5, 3, 5, 3, 4);
72 test_match (PARENS_TO_OPS ("((a*)b)*"), "abbab");
73 TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "abbab", 0, 5, 3, 5, 3, 4);
75 TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "xabbabx", 0, 0, -1, -1, -1, -1);
77 test_match (PARENS_TO_OPS ("((a*)b)*"), "abaabaaaab");
78 TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "abaabaaab", 0, 9, 5, 9, 5, 8);
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);
84 test_match (PARENS_TO_OPS ("(ab)*"), "abab");
85 TEST_REGISTERS (PARENS_TO_OPS ("(ab)*"), "abab", 0, 4, 2, 4, -1, -1);
87 /* We match the empty string here. */
88 TEST_REGISTERS (PARENS_TO_OPS ("(ab)*"), "xababx", 0, 0, -1, -1, -1, -1);
90 /* Per David A. Willcox. */
91 TEST_REGISTERS (PARENS_TO_OPS ("a(b*)c"), "ac", 0, 2, 1, 1, -1, -1);
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);
97 test_match (PARENS_TO_OPS ("(a)*b"), "ab");
98 TEST_REGISTERS (PARENS_TO_OPS ("(a)*b"), "ab", 0, 2, 0, 1, -1, -1);
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);
103 test_match (PARENS_TO_OPS ("(a)*b"), "aab");
104 TEST_REGISTERS (PARENS_TO_OPS ("(a)*b"), "aab", 0, 3, 1, 2, -1, -1);
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);
110 TEST_REGISTERS (PARENS_TO_OPS ("(a*)*"), "", 0, 0, 0, 0, 0, 0);
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");
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);
120 TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "xbx", 1, 2, 1, 1, -1, -1);
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);
125 TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "xabx", 1, 3, 1, 2, -1, -1);
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);
131 TEST_REGISTERS_2 (PARENS_TO_OPS ("(a*)*b"), "a", "ab", 0, 3, 0, 2, -1, -1);
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);
138 test_match (PARENS_TO_OPS ("(a*)a"), "aa");
139 TEST_REGISTERS (PARENS_TO_OPS ("(a*)a"), "aa", 0, 2, 0, 1, -1, -1);
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);
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);
154 test_match (PARENS_TO_OPS ("(a)*ab"), "aab");
155 TEST_REGISTERS (PARENS_TO_OPS ("(a)*ab"), "aab", 0, 3, 0, 1, -1, -1);
157 TEST_REGISTERS (PARENS_TO_OPS("(a)*ab"), "xaabx", 1, 4, 1, 2, -1, -1);
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);
163 test_match (PARENS_TO_OPS ("(a*)ab"), "aab");
164 TEST_REGISTERS (PARENS_TO_OPS ("(a*)ab"), "aab", 0, 3, 0, 1, -1, -1);
166 TEST_REGISTERS (PARENS_TO_OPS ("(a*)ab"), "xaabx", 1, 4, 1, 2, -1, -1);
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);
172 test_match (PARENS_TO_OPS ("(a*)*ab"), "aab");
173 TEST_REGISTERS (PARENS_TO_OPS ("(a*)*ab"), "aab", 0, 3, 0, 1, -1, -1);
175 TEST_REGISTERS (PARENS_TO_OPS("(a*)*ab"), "xaabx", 1, 4, 1, 2, -1, -1);
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);
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);
187 test_match (PARENS_TO_OPS ("(a*)*(ab)*"), "ab");
188 TEST_REGISTERS (PARENS_TO_OPS ("(a*)*(ab)*"), "ab", 0, 2, 0, 0, 0, 2);
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);
194 test_match (PARENS_TO_OPS ("(a*b)*"), "b");
195 TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*"), "b", 0, 1, 0, 1, -1, -1);
197 test_match (PARENS_TO_OPS ("(a*b)*"), "baab");
198 TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*"), "baab", 0, 4, 1, 4, -1, -1);
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);
204 test_match (PARENS_TO_OPS ("(a*b*)*"), "a");
205 TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "a", 0, 1, 0, 1, -1, -1);
207 test_match (PARENS_TO_OPS ("(a*b*)*"), "ba");
208 TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "ba", 0, 2, 1, 2, -1, -1);
210 test_match (PARENS_TO_OPS ("(a*b*)*"), "ab");
211 TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "ab", 0, 2, 0, 2, -1, -1);
213 test_match (PARENS_TO_OPS ("(a*b*)*"), "aa");
214 TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "aa", 0, 2, 0, 2, -1, -1);
216 test_match (PARENS_TO_OPS ("(a*b*)*"), "bb");
217 TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "bb", 0, 2, 0, 2, -1, -1);
219 test_match (PARENS_TO_OPS ("(a*b*)*"), "aba");
220 TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "aba", 0, 3, 2, 3, -1, -1);
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);
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);
230 test_match (PARENS_TO_OPS ("((a*)*(b*)*)*"), "aba");
231 /* Perhaps register 3 should be 3/3 here? Not sure if standard
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);
236 test_fastmap (PARENS_TO_OPS ("((a*)(b*))*"), "ab", 0, 0);
237 test_match (PARENS_TO_OPS ("((a*)(b*))*"), "");
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);
242 test_match (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "");
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);
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);
253 test_match (PARENS_TO_OPS ("((a)*(b)*)*"), "aba");
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);
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);
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);
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);
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);
277 test_match (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "");
278 test_fastmap (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "c", 0, 0);
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);
283 test_fastmap (PARENS_TO_OPS ("((a)*b)*"), "ab", 0, 0);
284 test_match (PARENS_TO_OPS ("((a)*b)*"), "");
286 test_match (PARENS_TO_OPS ("((a)*b)*"), "");
287 TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "", 0, 0, -1, -1, -1, -1);
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*/
292 test_match (PARENS_TO_OPS ("((a)*b)*"), "abbab");
293 TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "abbab", 0, 5, 3, 5, 3, 4);
295 /* We match the empty string here. */
296 TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "xabbabx", 0, 0, -1, -1, -1, -1);
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);
302 test_match (PARENS_TO_OPS ("(a*)*"), "aa");
303 TEST_REGISTERS (PARENS_TO_OPS ("(a*)*"), "aa", 0, 2, 0, 2, -1, -1);
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);
309 test_match (PARENS_TO_OPS ("((a*)*)*"), "a");
310 TEST_REGISTERS (PARENS_TO_OPS ("((a*)*)*"), "a", 0, 1, 0, 1, 0, 1);
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);
316 test_match (PARENS_TO_OPS ("(ab*)*"), "aa");
317 TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*"), "aa", 0, 2, 1, 2, -1, -1);
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);
323 test_match (PARENS_TO_OPS ("(ab*)*c"), "abbac");
324 TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*c"), "abbac", 0, 5, 3, 4, -1, -1);
326 test_match (PARENS_TO_OPS ("(ab*)*c"), "abac");
327 TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*c"), "abac", 0, 4, 2, 3, -1, -1);
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);
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);
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);
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);
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);
346 test_match (PARENS_TO_OPS ("((a*)b*)"), "a");
347 TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)"), "a", 0, 1, 0, 1, 0, 1);
349 test_match (PARENS_TO_OPS ("((a*)b*)"), "b");
350 TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)"), "b", 0, 1, 0, 1, 0, 0);
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);
356 test_match (PARENS_TO_OPS ("((a)*b*)"), "a");
357 TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "a", 0, 1, 0, 1, 0, 1);
359 test_match (PARENS_TO_OPS ("((a)*b*)"), "b");
360 TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "b", 0, 1, 0, 1, -1, -1);
362 test_match (PARENS_TO_OPS ("((a)*b*)"), "ab");
363 TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "ab", 0, 2, 0, 2, 0, 1);
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);
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);
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);
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);
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);
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);
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)*))))))))"), "");
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);
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);
413 test_should_match = false;
415 invalid_pattern (REG_EPAREN, PARENS_TO_OPS ("(a"));
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");
435 /* Expression anchoring. */
436 TEST_SEARCH (PARENS_TO_OPS ("(^b)"), "ab", 0, 2);
437 TEST_SEARCH (PARENS_TO_OPS ("(a$)"), "ab", 0, 2);
439 printf ("\nFinished POSIX grouping tests.\n");