1 /* psx-generic.c: test POSIX re's independent of us using basic or
10 int omit_generic_tests = 0; /* reset in debugger to skip */
12 if (omit_generic_tests)
14 /* Tests somewhat in the order of P1003.2. */
16 /* Both posix basic and extended; should match. */
18 printf ("\nStarting generic POSIX tests.\n");
22 test_should_match = true;
23 /* Ordinary characters. */
24 printf ("\nContinuing generic POSIX tests.\n");
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);
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);
38 test_match ("\\a","a");
39 test_match ("\\0", "0");
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);
48 test_match ("\n", "\n");
49 test_match ("a\n", "a\n");
50 test_match ("\nb", "\nb");
51 test_match ("a\nb", "a\nb");
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);
59 test_match ("a*b", "aab");
60 test_fastmap ("a*b", "ab", 0, 0);
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);
66 test_match ("\\{", "{");
67 test_match ("\\^", "^");
68 test_match ("\\.", ".");
69 test_match ("\\*", "*");
70 test_match ("\\[", "[");
71 test_match ("\\$", "$");
72 test_match ("\\\\", "\\");
74 test_match ("ab*", "a");
75 test_match ("ab*", "abb");
77 /* Valid consecutive repetitions. */
78 test_match ("a**", "a");
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);
91 test_fastmap ("[^ab]", "ab", 1, 1);
92 test_match ("[^ab]", "c");
93 test_match ("[^a]", "\n");
95 test_match ("[a]*a", "aa");
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");
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);
116 /* Collating, noncollating,
117 equivalence classes aren't
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");
132 test_match ("[[:digit:]]", "0");
133 test_match ("[[:digit:]]", "9");
134 test_fastmap ("[[:digit:]]", "0123456789", 0, 0);
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]", "[");
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);
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. */
176 test_match ("[%--a]", "%"); /* Ending point. */
177 test_match ("[%--a]", "-"); /* Ditto. */
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. */
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);
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);
199 test_match ("^", "");
200 TEST_REGISTERS ("^", "", 0, 0, -1, -1, -1, -1);
201 test_match ("$", "");
202 TEST_REGISTERS ("$", "", 0, 0, -1, -1, -1, -1);
204 test_match ("a$", "a");
205 test_fastmap ("a$", "a", 0, 0);
206 TEST_REGISTERS ("a$", "xa", 1, 2, -1, -1, -1, -1);
208 test_match ("^ab$", "ab");
209 test_fastmap ("^ab$", "a", 0, 0);
210 TEST_REGISTERS ("^a$", "a", 0, 1, -1, -1, -1, -1);
212 test_fastmap ("^$", "", 0, 0);
213 test_match ("^$", "");
214 TEST_REGISTERS ("^$", "", 0, 0, -1, -1, -1, -1);
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);
222 test_match_2 ("ab", "a", "b");
223 TEST_REGISTERS_2 ("ab", "a", "b", 0, 2, -1, -1, -1, -1);
225 test_match_2 ("a", "", "a");
226 test_match_2 ("a", "a", "");
227 test_match_2 ("ab", "a", "b");
229 TEST_POSITIONED_MATCH ("b", "ab", 1);
231 TEST_TRUNCATED_MATCH ("a", "ab", 1);
234 /* Both basic and extended, continued; should not match. */
236 test_should_match = false;
237 /* Ordinary characters. */
238 test_match ("abc", "ab");
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);
251 TEST_SEARCH ("c", "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 236, -237);
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 ("[^]]", "]");
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");
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:]");
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");
303 test_match ("[ab][cd]", "ae"); /* Concatenation. */
304 test_match ("b*c", "b"); /* Star. */
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");
314 TEST_SEARCH ("^a", "b\na", 0, 3);
315 TEST_SEARCH ("b$", "b\na", 0, 3);
317 test_match_2 ("^a", "\n", "a");
318 test_match_2 ("a$", "a", "\n");
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);
325 printf ("\nFinished generic POSIX tests.\n");
334 trim-versions-without-asking: nil