Updated to fedora-glibc-20080703T1203
[kopensolaris-gnu/glibc.git] / posix / tst-regex.c
1 /* Copyright (C) 2001, 2003, 2008 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Lesser General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8
9    The GNU C Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Lesser General Public License for more details.
13
14    You should have received a copy of the GNU Lesser General Public
15    License along with the GNU C Library; if not, write to the Free
16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
17    02111-1307 USA.  */
18
19 #include <spawn.h>
20 #include "spawn_int.h"
21
22 #include <assert.h>
23 #include <errno.h>
24 #include <error.h>
25 #include <fcntl.h>
26 #include <getopt.h>
27 #include <iconv.h>
28 #include <locale.h>
29 #include <mcheck.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <time.h>
34 #include <unistd.h>
35 #include <sys/stat.h>
36 #include <sys/types.h>
37 #include <regex.h>
38
39
40 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
41 static clockid_t cl;
42 static int use_clock;
43 #endif
44 static iconv_t cd;
45 static char *mem;
46 static char *umem;
47 static size_t memlen;
48 static size_t umemlen;
49 static int timing;
50
51 static int test_expr (const char *expr, int expected, int expectedicase);
52 static int run_test (const char *expr, const char *mem, size_t memlen,
53                      int icase, int expected);
54 static int run_test_backwards (const char *expr, const char *mem,
55                                size_t memlen, int icase, int expected);
56
57
58 static int
59 do_test (void)
60 {
61   const char *file;
62   int fd;
63   struct stat st;
64   int result;
65   char *inmem;
66   char *outmem;
67   size_t inlen;
68   size_t outlen;
69
70   mtrace ();
71
72   /* Make the content of the file available in memory.  */
73   file = "../ChangeLog.8";
74   fd = open (file, O_RDONLY);
75   if (fd == -1)
76     error (EXIT_FAILURE, errno, "cannot open %s", basename (file));
77
78   if (fstat (fd, &st) != 0)
79     error (EXIT_FAILURE, errno, "cannot stat %s", basename (file));
80   memlen = st.st_size;
81
82   mem = (char *) malloc (memlen + 1);
83   if (mem == NULL)
84     error (EXIT_FAILURE, errno, "while allocating buffer");
85
86   if ((size_t) read (fd, mem, memlen) != memlen)
87     error (EXIT_FAILURE, 0, "cannot read entire file");
88   mem[memlen] = '\0';
89
90   close (fd);
91
92   /* We have to convert a few things from Latin-1 to UTF-8.  */
93   cd = iconv_open ("UTF-8", "ISO-8859-1");
94   if (cd == (iconv_t) -1)
95     error (EXIT_FAILURE, errno, "cannot get conversion descriptor");
96
97   /* For the second test we have to convert the file content to UTF-8.
98      Since the text is mostly ASCII it should be enough to allocate
99      twice as much memory for the UTF-8 text than for the Latin-1
100      text.  */
101   umem = (char *) calloc (2, memlen);
102   if (umem == NULL)
103     error (EXIT_FAILURE, errno, "while allocating buffer");
104
105   inmem = mem;
106   inlen = memlen;
107   outmem = umem;
108   outlen = 2 * memlen - 1;
109   iconv (cd, &inmem, &inlen, &outmem, &outlen);
110   umemlen = outmem - umem;
111   if (inlen != 0)
112     error (EXIT_FAILURE, errno, "cannot convert buffer");
113
114 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
115 # if _POSIX_CPUTIME == 0
116   if (sysconf (_SC_CPUTIME) < 0)
117     use_clock = 0;
118   else
119 # endif
120     /* See whether we can use the CPU clock.  */
121     use_clock = clock_getcpuclockid (0, &cl) == 0;
122 #endif
123
124 #ifdef DEBUG
125   re_set_syntax (RE_DEBUG);
126 #endif
127
128   /* Run the actual tests.  All tests are run in a single-byte and a
129      multi-byte locale.  */
130   result = test_expr ("[äáàâéèêíìîñöóòôüúùû]", 2, 2);
131   result |= test_expr ("G.ran", 2, 3);
132   result |= test_expr ("G.\\{1\\}ran", 2, 3);
133   result |= test_expr ("G.*ran", 3, 44);
134   result |= test_expr ("[äáàâ]", 0, 0);
135   result |= test_expr ("Uddeborg", 2, 2);
136   result |= test_expr (".Uddeborg", 2, 2);
137
138   /* Free the resources.  */
139   free (umem);
140   iconv_close (cd);
141   free (mem);
142
143   return result;
144 }
145
146
147 static int
148 test_expr (const char *expr, int expected, int expectedicase)
149 {
150   int result;
151   char *inmem;
152   char *outmem;
153   size_t inlen;
154   size_t outlen;
155   char *uexpr;
156
157   /* First test: search with an ISO-8859-1 locale.  */
158   if (setlocale (LC_ALL, "de_DE.ISO-8859-1") == NULL)
159     error (EXIT_FAILURE, 0, "cannot set locale de_DE.ISO-8859-1");
160
161   printf ("\nTest \"%s\" with 8-bit locale\n", expr);
162   result = run_test (expr, mem, memlen, 0, expected);
163   printf ("\nTest \"%s\" with 8-bit locale, case insensitive\n", expr);
164   result |= run_test (expr, mem, memlen, 1, expectedicase);
165   printf ("\nTest \"%s\" backwards with 8-bit locale\n", expr);
166   result |= run_test_backwards (expr, mem, memlen, 0, expected);
167   printf ("\nTest \"%s\" backwards with 8-bit locale, case insensitive\n",
168           expr);
169   result |= run_test_backwards (expr, mem, memlen, 1, expectedicase);
170
171   /* Second test: search with an UTF-8 locale.  */
172   if (setlocale (LC_ALL, "de_DE.UTF-8") == NULL)
173     error (EXIT_FAILURE, 0, "cannot set locale de_DE.UTF-8");
174
175   inmem = (char *) expr;
176   inlen = strlen (expr);
177   outlen = inlen * MB_CUR_MAX;
178   outmem = uexpr = alloca (outlen + 1);
179   memset (outmem, '\0', outlen + 1);
180   iconv (cd, &inmem, &inlen, &outmem, &outlen);
181   if (inlen != 0)
182     error (EXIT_FAILURE, errno, "cannot convert expression");
183
184   /* Run the tests.  */
185   printf ("\nTest \"%s\" with multi-byte locale\n", expr);
186   result |= run_test (uexpr, umem, umemlen, 0, expected);
187   printf ("\nTest \"%s\" with multi-byte locale, case insensitive\n", expr);
188   result |= run_test (uexpr, umem, umemlen, 1, expectedicase);
189   printf ("\nTest \"%s\" backwards with multi-byte locale\n", expr);
190   result |= run_test_backwards (uexpr, umem, umemlen, 0, expected);
191   printf ("\nTest \"%s\" backwards with multi-byte locale, case insensitive\n",
192           expr);
193   result |= run_test_backwards (uexpr, umem, umemlen, 1, expectedicase);
194
195   return result;
196 }
197
198
199 static int
200 run_test (const char *expr, const char *mem, size_t memlen, int icase,
201           int expected)
202 {
203 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
204   struct timespec start;
205   struct timespec finish;
206 #endif
207   regex_t re;
208   int err;
209   size_t offset;
210   int cnt;
211
212 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
213   if (use_clock && !timing)
214     use_clock = clock_gettime (cl, &start) == 0;
215 #endif
216
217   err = regcomp (&re, expr, REG_NEWLINE | (icase ? REG_ICASE : 0));
218   if (err != REG_NOERROR)
219     {
220       char buf[200];
221       regerror (err, &re, buf, sizeof buf);
222       error (EXIT_FAILURE, 0, "cannot compile expression: %s", buf);
223     }
224
225   cnt = 0;
226   offset = 0;
227   assert (mem[memlen] == '\0');
228   while (offset < memlen)
229     {
230       regmatch_t ma[1];
231       const char *sp;
232       const char *ep;
233
234       err = regexec (&re, mem + offset, 1, ma, 0);
235       if (err == REG_NOMATCH)
236         break;
237
238       if (err != REG_NOERROR)
239         {
240           char buf[200];
241           regerror (err, &re, buf, sizeof buf);
242           error (EXIT_FAILURE, 0, "cannot use expression: %s", buf);
243         }
244
245       assert (ma[0].rm_so >= 0);
246       sp = mem + offset + ma[0].rm_so;
247       while (sp > mem && sp[-1] != '\n')
248         --sp;
249
250       ep = mem + offset + ma[0].rm_so;
251       while (*ep != '\0' && *ep != '\n')
252         ++ep;
253
254       printf ("match %d: \"%.*s\"\n", ++cnt, (int) (ep - sp), sp);
255
256       offset = ep + 1 - mem;
257     }
258
259   regfree (&re);
260
261 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
262   if (use_clock && !timing)
263     {
264       use_clock = clock_gettime (cl, &finish) == 0;
265       if (use_clock)
266         {
267           if (finish.tv_nsec < start.tv_nsec)
268             {
269               finish.tv_nsec -= start.tv_nsec - 1000000000;
270               finish.tv_sec -= 1 + start.tv_sec;
271             }
272           else
273             {
274               finish.tv_nsec -= start.tv_nsec;
275               finish.tv_sec -= start.tv_sec;
276             }
277
278           printf ("elapsed time: %ld.%09ld sec\n",
279                   finish.tv_sec, finish.tv_nsec);
280         }
281     }
282
283   if (use_clock && timing)
284     {
285       struct timespec mintime = { .tv_sec = 24 * 60 * 60 };
286
287       for (int i = 0; i < 10; ++i)
288         {
289           offset = 0;
290           use_clock = clock_gettime (cl, &start) == 0;
291
292           if (!use_clock)
293             continue;
294
295           err = regcomp (&re, expr, REG_NEWLINE | (icase ? REG_ICASE : 0));
296           if (err != REG_NOERROR)
297             continue;
298
299           while (offset < memlen)
300             {
301               regmatch_t ma[1];
302
303               err = regexec (&re, mem + offset, 1, ma, 0);
304               if (err != REG_NOERROR)
305                 break;
306
307               offset += ma[0].rm_eo;
308             }
309
310           regfree (&re);
311
312           use_clock = clock_gettime (cl, &finish) == 0;
313           if (use_clock)
314             {
315               if (finish.tv_nsec < start.tv_nsec)
316                 {
317                   finish.tv_nsec -= start.tv_nsec - 1000000000;
318                   finish.tv_sec -= 1 + start.tv_sec;
319                 }
320               else
321                 {
322                   finish.tv_nsec -= start.tv_nsec;
323                   finish.tv_sec -= start.tv_sec;
324                 }
325               if (finish.tv_sec < mintime.tv_sec
326                   || (finish.tv_sec == mintime.tv_sec
327                       && finish.tv_nsec < mintime.tv_nsec))
328                 mintime = finish;
329             }
330         }
331       printf ("elapsed time: %ld.%09ld sec\n",
332               mintime.tv_sec, mintime.tv_nsec);
333     }
334 #endif
335
336   /* Return an error if the number of matches found is not match we
337      expect.  */
338   return cnt != expected;
339 }
340
341
342 static int
343 run_test_backwards (const char *expr, const char *mem, size_t memlen,
344                     int icase, int expected)
345 {
346 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
347   struct timespec start;
348   struct timespec finish;
349 #endif
350   struct re_pattern_buffer re;
351   const char *err;
352   size_t offset;
353   int cnt;
354
355 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
356   if (use_clock && !timing)
357     use_clock = clock_gettime (cl, &start) == 0;
358 #endif
359
360   re_set_syntax ((RE_SYNTAX_POSIX_BASIC & ~RE_DOT_NEWLINE)
361                  | RE_HAT_LISTS_NOT_NEWLINE
362                  | (icase ? RE_ICASE : 0));
363
364   memset (&re, 0, sizeof (re));
365   re.fastmap = malloc (256);
366   if (re.fastmap == NULL)
367     error (EXIT_FAILURE, errno, "cannot allocate fastmap");
368
369   err = re_compile_pattern (expr, strlen (expr), &re);
370   if (err != NULL)
371     error (EXIT_FAILURE, 0, "cannot compile expression: %s", err);
372
373   if (re_compile_fastmap (&re))
374     error (EXIT_FAILURE, 0, "couldn't compile fastmap");
375
376   cnt = 0;
377   offset = memlen;
378   assert (mem[memlen] == '\0');
379   while (offset <= memlen)
380     {
381       int start;
382       const char *sp;
383       const char *ep;
384
385       start = re_search (&re, mem, memlen, offset, -offset, NULL);
386       if (start == -1)
387         break;
388
389       if (start == -2)
390         error (EXIT_FAILURE, 0, "internal error in re_search");
391
392       sp = mem + start;
393       while (sp > mem && sp[-1] != '\n')
394         --sp;
395
396       ep = mem + start;
397       while (*ep != '\0' && *ep != '\n')
398         ++ep;
399
400       printf ("match %d: \"%.*s\"\n", ++cnt, (int) (ep - sp), sp);
401
402       offset = sp - 1 - mem;
403     }
404
405   regfree (&re);
406
407 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
408   if (use_clock && !timing)
409     {
410       use_clock = clock_gettime (cl, &finish) == 0;
411       if (use_clock)
412         {
413           if (finish.tv_nsec < start.tv_nsec)
414             {
415               finish.tv_nsec -= start.tv_nsec - 1000000000;
416               finish.tv_sec -= 1 + start.tv_sec;
417             }
418           else
419             {
420               finish.tv_nsec -= start.tv_nsec;
421               finish.tv_sec -= start.tv_sec;
422             }
423
424           printf ("elapsed time: %ld.%09ld sec\n",
425                   finish.tv_sec, finish.tv_nsec);
426         }
427     }
428
429   if (use_clock && timing)
430     {
431       struct timespec mintime = { .tv_sec = 24 * 60 * 60 };
432
433       for (int i = 0; i < 10; ++i)
434         {
435           offset = memlen;
436           use_clock = clock_gettime (cl, &start) == 0;
437
438           if (!use_clock)
439             continue;
440
441           memset (&re, 0, sizeof (re));
442           re.fastmap = malloc (256);
443           if (re.fastmap == NULL)
444             continue;
445
446           err = re_compile_pattern (expr, strlen (expr), &re);
447           if (err != NULL)
448             continue;
449
450           if (re_compile_fastmap (&re))
451             {
452               regfree (&re);
453               continue;
454             }
455
456           while (offset <= memlen)
457             {
458               int start;
459               const char *sp;
460
461               start = re_search (&re, mem, memlen, offset, -offset, NULL);
462               if (start < -1)
463                 break;
464
465               sp = mem + start;
466               while (sp > mem && sp[-1] != '\n')
467                 --sp;
468
469               offset = sp - 1 - mem;
470             }
471
472           regfree (&re);
473
474           use_clock = clock_gettime (cl, &finish) == 0;
475           if (use_clock)
476             {
477               if (finish.tv_nsec < start.tv_nsec)
478                 {
479                   finish.tv_nsec -= start.tv_nsec - 1000000000;
480                   finish.tv_sec -= 1 + start.tv_sec;
481                 }
482               else
483                 {
484                   finish.tv_nsec -= start.tv_nsec;
485                   finish.tv_sec -= start.tv_sec;
486                 }
487               if (finish.tv_sec < mintime.tv_sec
488                   || (finish.tv_sec == mintime.tv_sec
489                       && finish.tv_nsec < mintime.tv_nsec))
490                 mintime = finish;
491             }
492         }
493       printf ("elapsed time: %ld.%09ld sec\n",
494               mintime.tv_sec, mintime.tv_nsec);
495     }
496 #endif
497
498   /* Return an error if the number of matches found is not match we
499      expect.  */
500   return cnt != expected;
501 }
502
503 /* If --timing is used we will need a larger timout.  */
504 #define TIMEOUT 50
505 #define CMDLINE_OPTIONS \
506    {"timing", no_argument, &timing, 1 },
507 #define TEST_FUNCTION do_test ()
508 #include "../test-skeleton.c"