?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Refer to C23 in place of C2X in glibc
[glibc.git] / posix / bug-regex19.c
blob6e07dd1fac86a8c9a3db7fb6ba6ac1eacb9c2d55
1 /* Regular expression tests.
2 Copyright (C) 2003-2024 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <sys/types.h>
20 #include <mcheck.h>
21 #include <regex.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <locale.h>
26 #include <libc-diag.h>
27 #include <support/support.h>
28
29 #define BRE RE_SYNTAX_POSIX_BASIC
30 #define ERE RE_SYNTAX_POSIX_EXTENDED
31
32 static struct test_s
33 {
34 int syntax;
35 const char *pattern;
36 const char *string;
37 int start, res;
38 } tests[] = {
39 {BRE, "\\<A", "CBAA", 0, -1},
40 {BRE, "\\<A", "CBAA", 2, -1},
41 {BRE, "A\\>", "CAAB", 1, -1},
42 {BRE, "\\bA", "CBAA", 0, -1},
43 {BRE, "\\bA", "CBAA", 2, -1},
44 {BRE, "A\\b", "CAAB", 1, -1},
45 {BRE, "\\<A", "AA", 0, 0},
46 {BRE, "\\<A", "C-AA", 2, 2},
47 {BRE, "A\\>", "CAA-", 1, 2},
48 {BRE, "A\\>", "CAA", 1, 2},
49 {BRE, "\\bA", "AA", 0, 0},
50 {BRE, "\\bA", "C-AA", 2, 2},
51 {BRE, "A\\b", "CAA-", 1, 2},
52 {BRE, "A\\b", "CAA", 1, 2},
53 {BRE, "\\<[A]", "CBAA", 0, -1},
54 {BRE, "\\<[A]", "CBAA", 2, -1},
55 {BRE, "[A]\\>", "CAAB", 1, -1},
56 {BRE, "\\b[A]", "CBAA", 0, -1},
57 {BRE, "\\b[A]", "CBAA", 2, -1},
58 {BRE, "[A]\\b", "CAAB", 1, -1},
59 {BRE, "\\<[A]", "AA", 0, 0},
60 {BRE, "\\<[A]", "C-AA", 2, 2},
61 {BRE, "[A]\\>", "CAA-", 1, 2},
62 {BRE, "[A]\\>", "CAA", 1, 2},
63 {BRE, "\\b[A]", "AA", 0, 0},
64 {BRE, "\\b[A]", "C-AA", 2, 2},
65 {BRE, "[A]\\b", "CAA-", 1, 2},
66 {BRE, "[A]\\b", "CAA", 1, 2},
67 {ERE, "\\b(A|!|.B)", "A=AC", 0, 0},
68 {ERE, "\\b(A|!|.B)", "=AC", 0, 1},
69 {ERE, "\\b(A|!|.B)", "!AC", 0, 1},
70 {ERE, "\\b(A|!|.B)", "=AB", 0, 1},
71 {ERE, "\\b(A|!|.B)", "DA!C", 0, 2},
72 {ERE, "\\b(A|!|.B)", "=CB", 0, 1},
73 {ERE, "\\b(A|!|.B)", "!CB", 0, 1},
74 {ERE, "\\b(A|!|.B)", "D,B", 0, 1},
75 {ERE, "\\b(A|!|.B)", "!.C", 0, -1},
76 {ERE, "\\b(A|!|.B)", "BCB", 0, -1},
77 {ERE, "(A|\\b)(A|B|C)", "DAAD", 0, 1},
78 {ERE, "(A|\\b)(A|B|C)", "DABD", 0, 1},
79 {ERE, "(A|\\b)(A|B|C)", "AD", 0, 0},
80 {ERE, "(A|\\b)(A|B|C)", "C!", 0, 0},
81 {ERE, "(A|\\b)(A|B|C)", "D,B", 0, 2},
82 {ERE, "(A|\\b)(A|B|C)", "DA?A", 0, 3},
83 {ERE, "(A|\\b)(A|B|C)", "BBC", 0, 0},
84 {ERE, "(A|\\b)(A|B|C)", "DA", 0, -1},
85 {ERE, "(!|\\b)(!|=|~)", "A!=\\", 0, 1},
86 {ERE, "(!|\\b)(!|=|~)", "/!=A", 0, 1},
87 {ERE, "(!|\\b)(!|=|~)", "A=A", 0, 1},
88 {ERE, "(!|\\b)(!|=|~)", "==!=", 0, 2},
89 {ERE, "(!|\\b)(!|=|~)", "==C~", 0, 3},
90 {ERE, "(!|\\b)(!|=|~)", "=~=", 0, -1},
91 {ERE, "(!|\\b)(!|=|~)", "~!", 0, -1},
92 {ERE, "(!|\\b)(!|=|~)", "~=~", 0, -1},
93 {ERE, "(\\b|A.)[ABC]", "AC", 0, 0},
94 {ERE, "(\\b|A.)[ABC]", "=A", 0, 1},
95 {ERE, "(\\b|A.)[ABC]", "DACC", 0, 1},
96 {ERE, "(\\b|A.)[A~C]", "AC", 0, 0},
97 {ERE, "(\\b|A.)[A~C]", "=A", 0, 1},
98 {ERE, "(\\b|A.)[A~C]", "DACC", 0, 1},
99 {ERE, "(\\b|A.)[A~C]", "B!A=", 0, 2},
100 {ERE, "(\\b|A.)[A~C]", "B~C", 0, 1},
101 {ERE, ".\\b.", "AA~", 0, 1},
102 {ERE, ".\\b.", "=A=", 0, 0},
103 {ERE, ".\\b.", "==", 0, -1},
104 {ERE, ".\\b.", "ABA", 0, -1},
105 {ERE, "[^k]\\b[^k]", "AA~", 0, 1},
106 {ERE, "[^k]\\b[^k]", "=A=", 0, 0},
107 {ERE, "[^k]\\b[^k]", "Ak~kA~", 0, 4},
108 {ERE, "[^k]\\b[^k]", "==", 0, -1},
109 {ERE, "[^k]\\b[^k]", "ABA", 0, -1},
110 {ERE, "[^k]\\b[^k]", "Ak~", 0, -1},
111 {ERE, "[^k]\\b[^k]", "k=k", 0, -1},
112 {ERE, "[^C]\\b[^C]", "AA~", 0, 1},
113 {ERE, "[^C]\\b[^C]", "=A=", 0, 0},
114 {ERE, "[^C]\\b[^C]", "AC~CA~", 0, 4},
115 {ERE, "[^C]\\b[^C]", "==", 0, -1},
116 {ERE, "[^C]\\b[^C]", "ABA", 0, -1},
117 {ERE, "[^C]\\b[^C]", "AC~", 0, -1},
118 {ERE, "[^C]\\b[^C]", "C=C", 0, -1},
119 {ERE, "\\<(A|!|.B)", "A=AC", 0, 0},
120 {ERE, "\\<(A|!|.B)", "=AC", 0, 1},
121 {ERE, "\\<(A|!|.B)", "!AC", 0, 1},
122 {ERE, "\\<(A|!|.B)", "=AB", 0, 1},
123 {ERE, "\\<(A|!|.B)", "=CB", 0, 1},
124 {ERE, "\\<(A|!|.B)", "!CB", 0, 1},
125 {ERE, "\\<(A|!|.B)", "DA!C", 0, -1},
126 {ERE, "\\<(A|!|.B)", "D,B", 0, -1},
127 {ERE, "\\<(A|!|.B)", "!.C", 0, -1},
128 {ERE, "\\<(A|!|.B)", "BCB", 0, -1},
129 {ERE, "(A|\\<)(A|B|C)", "DAAD", 0, 1},
130 {ERE, "(A|\\<)(A|B|C)", "DABD", 0, 1},
131 {ERE, "(A|\\<)(A|B|C)", "AD", 0, 0},
132 {ERE, "(A|\\<)(A|B|C)", "C!", 0, 0},
133 {ERE, "(A|\\<)(A|B|C)", "D,B", 0, 2},
134 {ERE, "(A|\\<)(A|B|C)", "DA?A", 0, 3},
135 {ERE, "(A|\\<)(A|B|C)", "BBC", 0, 0},
136 {ERE, "(A|\\<)(A|B|C)", "DA", 0, -1},
137 {ERE, "(!|\\<)(!|=|~)", "A!=\\", 0, 1},
138 {ERE, "(!|\\<)(!|=|~)", "/!=A", 0, 1},
139 {ERE, "(!|\\<)(!|=|~)", "==!=", 0, 2},
140 {ERE, "(!|\\<)(!|=|~)", "==C~", 0, -1},
141 {ERE, "(!|\\<)(!|=|~)", "A=A", 0, -1},
142 {ERE, "(!|\\<)(!|=|~)", "=~=", 0, -1},
143 {ERE, "(!|\\<)(!|=|~)", "~!", 0, -1},
144 {ERE, "(!|\\<)(!|=|~)", "~=~", 0, -1},
145 {ERE, "(\\<|A.)[ABC]", "AC", 0, 0},
146 {ERE, "(\\<|A.)[ABC]", "=A", 0, 1},
147 {ERE, "(\\<|A.)[ABC]", "DACC", 0, 1},
148 {ERE, "(\\<|A.)[A~C]", "AC", 0, 0},
149 {ERE, "(\\<|A.)[A~C]", "=A", 0, 1},
150 {ERE, "(\\<|A.)[A~C]", "DACC", 0, 1},
151 {ERE, "(\\<|A.)[A~C]", "B!A=", 0, 2},
152 {ERE, "(\\<|A.)[A~C]", "B~C", 0, 2},
153 {ERE, ".\\<.", "=A=", 0, 0},
154 {ERE, ".\\<.", "AA~", 0, -1},
155 {ERE, ".\\<.", "==", 0, -1},
156 {ERE, ".\\<.", "ABA", 0, -1},
157 {ERE, "[^k]\\<[^k]", "=k=A=", 0, 2},
158 {ERE, "[^k]\\<[^k]", "kk~", 0, -1},
159 {ERE, "[^k]\\<[^k]", "==", 0, -1},
160 {ERE, "[^k]\\<[^k]", "ABA", 0, -1},
161 {ERE, "[^k]\\<[^k]", "=k=", 0, -1},
162 {ERE, "[^C]\\<[^C]", "=C=A=", 0, 2},
163 {ERE, "[^C]\\<[^C]", "CC~", 0, -1},
164 {ERE, "[^C]\\<[^C]", "==", 0, -1},
165 {ERE, "[^C]\\<[^C]", "ABA", 0, -1},
166 {ERE, "[^C]\\<[^C]", "=C=", 0, -1},
167 {ERE, ".\\B.", "ABA", 0, 0},
168 {ERE, ".\\B.", "=BDC", 0, 1},
169 {ERE, "[^k]\\B[^k]", "kkkABA", 0, 3},
170 {ERE, "[^k]\\B[^k]", "kBk", 0, -1},
171 {ERE, "[^C]\\B[^C]", "CCCABA", 0, 3},
172 {ERE, "[^C]\\B[^C]", "CBC", 0, -1},
173 {ERE, ".(\\b|\\B).", "=~AB", 0, 0},
174 {ERE, ".(\\b|\\B).", "A=C", 0, 0},
175 {ERE, ".(\\b|\\B).", "ABC", 0, 0},
176 {ERE, ".(\\b|\\B).", "=~\\!", 0, 0},
177 {ERE, "[^k](\\b|\\B)[^k]", "=~AB", 0, 0},
178 {ERE, "[^k](\\b|\\B)[^k]", "A=C", 0, 0},
179 {ERE, "[^k](\\b|\\B)[^k]", "ABC", 0, 0},
180 {ERE, "[^k](\\b|\\B)[^k]", "=~kBD", 0, 0},
181 {ERE, "[^k](\\b|\\B)[^k]", "=~\\!", 0, 0},
182 {ERE, "[^k](\\b|\\B)[^k]", "=~kB", 0, 0},
183 {ERE, "[^C](\\b|\\B)[^C]", "=~AB", 0, 0},
184 {ERE, "[^C](\\b|\\B)[^C]", "A=C", 0, 0},
185 {ERE, "[^C](\\b|\\B)[^C]", "ABC", 0, 0},
186 {ERE, "[^C](\\b|\\B)[^C]", "=~CBD", 0, 0},
187 {ERE, "[^C](\\b|\\B)[^C]", "=~\\!", 0, 0},
188 {ERE, "[^C](\\b|\\B)[^C]", "=~CB", 0, 0},
189 {ERE, "\\b([A]|[!]|.B)", "A=AC", 0, 0},
190 {ERE, "\\b([A]|[!]|.B)", "=AC", 0, 1},
191 {ERE, "\\b([A]|[!]|.B)", "!AC", 0, 1},
192 {ERE, "\\b([A]|[!]|.B)", "=AB", 0, 1},
193 {ERE, "\\b([A]|[!]|.B)", "DA!C", 0, 2},
194 {ERE, "\\b([A]|[!]|.B)", "=CB", 0, 1},
195 {ERE, "\\b([A]|[!]|.B)", "!CB", 0, 1},
196 {ERE, "\\b([A]|[!]|.B)", "D,B", 0, 1},
197 {ERE, "\\b([A]|[!]|.B)", "!.C", 0, -1},
198 {ERE, "\\b([A]|[!]|.B)", "BCB", 0, -1},
199 {ERE, "([A]|\\b)([A]|[B]|[C])", "DAAD", 0, 1},
200 {ERE, "([A]|\\b)([A]|[B]|[C])", "DABD", 0, 1},
201 {ERE, "([A]|\\b)([A]|[B]|[C])", "AD", 0, 0},
202 {ERE, "([A]|\\b)([A]|[B]|[C])", "C!", 0, 0},
203 {ERE, "([A]|\\b)([A]|[B]|[C])", "D,B", 0, 2},
204 {ERE, "([A]|\\b)([A]|[B]|[C])", "DA?A", 0, 3},
205 {ERE, "([A]|\\b)([A]|[B]|[C])", "BBC", 0, 0},
206 {ERE, "([A]|\\b)([A]|[B]|[C])", "DA", 0, -1},
207 {ERE, "([!]|\\b)([!]|[=]|[~])", "A!=\\", 0, 1},
208 {ERE, "([!]|\\b)([!]|[=]|[~])", "/!=A", 0, 1},
209 {ERE, "([!]|\\b)([!]|[=]|[~])", "A=A", 0, 1},
210 {ERE, "([!]|\\b)([!]|[=]|[~])", "==!=", 0, 2},
211 {ERE, "([!]|\\b)([!]|[=]|[~])", "==C~", 0, 3},
212 {ERE, "([!]|\\b)([!]|[=]|[~])", "=~=", 0, -1},
213 {ERE, "([!]|\\b)([!]|[=]|[~])", "~!", 0, -1},
214 {ERE, "([!]|\\b)([!]|[=]|[~])", "~=~", 0, -1},
215 {ERE, "\\<([A]|[!]|.B)", "A=AC", 0, 0},
216 {ERE, "\\<([A]|[!]|.B)", "=AC", 0, 1},
217 {ERE, "\\<([A]|[!]|.B)", "!AC", 0, 1},
218 {ERE, "\\<([A]|[!]|.B)", "=AB", 0, 1},
219 {ERE, "\\<([A]|[!]|.B)", "=CB", 0, 1},
220 {ERE, "\\<([A]|[!]|.B)", "!CB", 0, 1},
221 {ERE, "\\<([A]|[!]|.B)", "DA!C", 0, -1},
222 {ERE, "\\<([A]|[!]|.B)", "D,B", 0, -1},
223 {ERE, "\\<([A]|[!]|.B)", "!.C", 0, -1},
224 {ERE, "\\<([A]|[!]|.B)", "BCB", 0, -1},
225 {ERE, "([A]|\\<)([A]|[B]|[C])", "DAAD", 0, 1},
226 {ERE, "([A]|\\<)([A]|[B]|[C])", "DABD", 0, 1},
227 {ERE, "([A]|\\<)([A]|[B]|[C])", "AD", 0, 0},
228 {ERE, "([A]|\\<)([A]|[B]|[C])", "C!", 0, 0},
229 {ERE, "([A]|\\<)([A]|[B]|[C])", "D,B", 0, 2},
230 {ERE, "([A]|\\<)([A]|[B]|[C])", "DA?A", 0, 3},
231 {ERE, "([A]|\\<)([A]|[B]|[C])", "BBC", 0, 0},
232 {ERE, "([A]|\\<)([A]|[B]|[C])", "DA", 0, -1},
233 {ERE, "([!]|\\<)([!=]|[~])", "A!=\\", 0, 1},
234 {ERE, "([!]|\\<)([!=]|[~])", "/!=A", 0, 1},
235 {ERE, "([!]|\\<)([!=]|[~])", "==!=", 0, 2},
236 {ERE, "([!]|\\<)([!=]|[~])", "==C~", 0, -1},
237 {ERE, "([!]|\\<)([!=]|[~])", "A=A", 0, -1},
238 {ERE, "([!]|\\<)([!=]|[~])", "=~=", 0, -1},
239 {ERE, "([!]|\\<)([!=]|[~])", "~!", 0, -1},
240 {ERE, "([!]|\\<)([!=]|[~])", "~=~", 0, -1},
241 {ERE, "(\\<|[A].)[ABC]", "AC", 0, 0},
242 {ERE, "(\\<|[A].)[ABC]", "=A", 0, 1},
243 {ERE, "(\\<|[A].)[ABC]", "DACC", 0, 1},
244 {ERE, "(\\<|[A].)[A~C]", "AC", 0, 0},
245 {ERE, "(\\<|[A].)[A~C]", "=A", 0, 1},
246 {ERE, "(\\<|[A].)[A~C]", "DACC", 0, 1},
247 {ERE, "(\\<|[A].)[A~C]", "B!A=", 0, 2},
248 {ERE, "(\\<|[A].)[A~C]", "B~C", 0, 2},
249 {ERE, "^[^A]*\\bB", "==B", 0, 0},
250 {ERE, "^[^A]*\\bB", "CBD!=B", 0, 0},
251 {ERE, "[^A]*\\bB", "==B", 2, 2}
252 };
253
254 int
255 do_one_test (const struct test_s *test, const char *fail)
256 {
257 int res;
258 const char *err;
259 struct re_pattern_buffer regbuf;
260
261 re_set_syntax (test->syntax);
262 memset (&regbuf, '\0', sizeof (regbuf));
263 err = re_compile_pattern (test->pattern, strlen (test->pattern),
264 &regbuf);
265 if (err != NULL)
266 {
267 printf ("%sre_compile_pattern \"%s\" failed: %s\n", fail, test->pattern,
268 err);
269 return 1;
270 }
271
272 #if __GNUC_PREREQ (10, 0) && !__GNUC_PREREQ (11, 0)
273 DIAG_PUSH_NEEDS_COMMENT;
274 /* Avoid GCC 10 false positive warning: specified size exceeds maximum
275 object size. */
276 DIAG_IGNORE_NEEDS_COMMENT (10, "-Wstringop-overflow");
277 #endif
278 res = re_search (&regbuf, test->string, strlen (test->string),
279 test->start, strlen (test->string) - test->start, NULL);
280 #if __GNUC_PREREQ (10, 0) && !__GNUC_PREREQ (11, 0)
281 DIAG_POP_NEEDS_COMMENT;
282 #endif
283 if (res != test->res)
284 {
285 printf ("%sre_search \"%s\" \"%s\" failed: %d (expected %d)\n",
286 fail, test->pattern, test->string, res, test->res);
287 regfree (&regbuf);
288 return 1;
289 }
290
291 if (test->res > 0 && test->start == 0)
292 {
293 #if __GNUC_PREREQ (10, 0) && !__GNUC_PREREQ (11, 0)
294 DIAG_PUSH_NEEDS_COMMENT;
295 /* Avoid GCC 10 false positive warning: specified size exceeds maximum
296 object size. */
297 DIAG_IGNORE_NEEDS_COMMENT (10, "-Wstringop-overflow");
298 #endif
299 res = re_search (&regbuf, test->string, strlen (test->string),
300 test->res, strlen (test->string) - test->res, NULL);
301 #if __GNUC_PREREQ (10, 0) && !__GNUC_PREREQ (11, 0)
302 DIAG_POP_NEEDS_COMMENT;
303 #endif
304 if (res != test->res)
305 {
306 printf ("%sre_search from expected \"%s\" \"%s\" failed: %d (expected %d)\n",
307 fail, test->pattern, test->string, res, test->res);
308 regfree (&regbuf);
309 return 1;
310 }
311 }
312
313 regfree (&regbuf);
314 return 0;
315 }
316
317 static char *
318 replace (char *p, char c)
319 {
320 switch (c)
321 {
322 /* A -> A" */
323 case 'A': *p++ = '\xc3'; *p++ = '\x84'; break;
324 /* B -> O" */
325 case 'B': *p++ = '\xc3'; *p++ = '\x96'; break;
326 /* C -> U" */
327 case 'C': *p++ = '\xc3'; *p++ = '\x9c'; break;
328 /* D -> a" */
329 case 'D': *p++ = '\xc3'; *p++ = '\xa4'; break;
330 /* ! -> MULTIPLICATION SIGN */
331 case '!': *p++ = '\xc3'; *p++ = '\x97'; break;
332 /* = -> EM DASH */
333 case '=': *p++ = '\xe2'; *p++ = '\x80'; *p++ = '\x94'; break;
334 /* ~ -> MUSICAL SYMBOL HALF NOTE */
335 case '~': *p++ = '\xf0'; *p++ = '\x9d'; *p++ = '\x85'; *p++ = '\x9e';
336 break;
337 }
338 return p;
339 }
340
341 int
342 do_mb_tests (const struct test_s *test)
343 {
344 int i, j;
345 struct test_s t;
346 const char *const chars = "ABCD!=~";
347 char repl[8], *p;
348 char pattern[strlen (test->pattern) * 4 + 1];
349 char string[strlen (test->string) * 4 + 1];
350 char fail[8 + sizeof ("UTF-8 ")];
351
352 t = *test;
353 t.pattern = pattern;
354 t.string = string;
355 strcpy (fail, "UTF-8 ");
356 for (i = 1; i < 128; ++i)
357 {
358 p = repl;
359 for (j = 0; j < 7; ++j)
360 if (i & (1 << j))
361 {
362 if (!strchr (test->pattern, chars[j])
363 && !strchr (test->string, chars[j]))
364 break;
365 *p++ = chars[j];
366 }
367 if (j < 7)
368 continue;
369 *p = '\0';
370
371 for (j = 0, p = pattern; test->pattern[j]; ++j)
372 if (strchr (repl, test->pattern[j]))
373 p = replace (p, test->pattern[j]);
374 else if (test->pattern[j] == '\\' && test->pattern[j + 1])
375 {
376 *p++ = test->pattern[j++];
377 *p++ = test->pattern[j];
378 }
379 else
380 *p++ = test->pattern[j];
381 *p = '\0';
382
383 t.start = test->start;
384 t.res = test->res;
385
386 for (j = 0, p = string; test->string[j]; ++j)
387 if (strchr (repl, test->string[j]))
388 {
389 char *d = replace (p, test->string[j]);
390 if (test->start > j)
391 t.start += d - p - 1;
392 if (test->res > j)
393 t.res += d - p - 1;
394 p = d;
395 }
396 else
397 *p++ = test->string[j];
398 *p = '\0';
399
400 p = stpcpy (fail + strlen ("UTF-8 "), repl);
401 *p++ = ' ';
402 *p = '\0';
403
404 if (do_one_test (&t, fail))
405 return 1;
406 }
407 return 0;
408 }
409
410 static int
411 do_test (void)
412 {
413 size_t i;
414 int ret = 0;
415
416 mtrace ();
417
418 for (i = 0; i < sizeof (tests) / sizeof (tests[0]); ++i)
419 {
420 xsetlocale (LC_ALL, "de_DE.ISO-8859-1");
421 ret |= do_one_test (&tests[i], "");
422 xsetlocale (LC_ALL, "de_DE.UTF-8");
423 ret |= do_one_test (&tests[i], "UTF-8 ");
424 ret |= do_mb_tests (&tests[i]);
425 xsetlocale (LC_ALL, "C.UTF-8");
426 ret |= do_one_test (&tests[i], "UTF-8 ");
427 ret |= do_mb_tests (&tests[i]);
428 }
429
430 return ret;
431 }
432
433 #include <support/test-driver.c>
sources.redhat.com git mirror of glibc CVS