| /* Copyright (C) 2001-2016 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <spawn.h> |
| #include "spawn_int.h" |
| |
| #include <assert.h> |
| #include <errno.h> |
| #include <error.h> |
| #include <fcntl.h> |
| #include <getopt.h> |
| #include <iconv.h> |
| #include <locale.h> |
| #include <mcheck.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <time.h> |
| #include <unistd.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <regex.h> |
| |
| |
| #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0 |
| static clockid_t cl; |
| static int use_clock; |
| #endif |
| static iconv_t cd; |
| static char *mem; |
| static char *umem; |
| static size_t memlen; |
| static size_t umemlen; |
| static int timing; |
| |
| static int test_expr (const char *expr, int expected, int expectedicase); |
| static int run_test (const char *expr, const char *mem, size_t memlen, |
| int icase, int expected); |
| static int run_test_backwards (const char *expr, const char *mem, |
| size_t memlen, int icase, int expected); |
| |
| |
| static int |
| do_test (void) |
| { |
| const char *file; |
| int fd; |
| struct stat st; |
| int result; |
| char *inmem; |
| char *outmem; |
| size_t inlen; |
| size_t outlen; |
| |
| mtrace (); |
| |
| /* Make the content of the file available in memory. */ |
| file = "../ChangeLog.8"; |
| fd = open (file, O_RDONLY); |
| if (fd == -1) |
| error (EXIT_FAILURE, errno, "cannot open %s", basename (file)); |
| |
| if (fstat (fd, &st) != 0) |
| error (EXIT_FAILURE, errno, "cannot stat %s", basename (file)); |
| memlen = st.st_size; |
| |
| mem = (char *) malloc (memlen + 1); |
| if (mem == NULL) |
| error (EXIT_FAILURE, errno, "while allocating buffer"); |
| |
| if ((size_t) read (fd, mem, memlen) != memlen) |
| error (EXIT_FAILURE, 0, "cannot read entire file"); |
| mem[memlen] = '\0'; |
| |
| close (fd); |
| |
| /* We have to convert a few things from Latin-1 to UTF-8. */ |
| cd = iconv_open ("UTF-8", "ISO-8859-1"); |
| if (cd == (iconv_t) -1) |
| error (EXIT_FAILURE, errno, "cannot get conversion descriptor"); |
| |
| /* For the second test we have to convert the file content to UTF-8. |
| Since the text is mostly ASCII it should be enough to allocate |
| twice as much memory for the UTF-8 text than for the Latin-1 |
| text. */ |
| umem = (char *) calloc (2, memlen); |
| if (umem == NULL) |
| error (EXIT_FAILURE, errno, "while allocating buffer"); |
| |
| inmem = mem; |
| inlen = memlen; |
| outmem = umem; |
| outlen = 2 * memlen - 1; |
| iconv (cd, &inmem, &inlen, &outmem, &outlen); |
| umemlen = outmem - umem; |
| if (inlen != 0) |
| error (EXIT_FAILURE, errno, "cannot convert buffer"); |
| |
| #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0 |
| # if _POSIX_CPUTIME == 0 |
| if (sysconf (_SC_CPUTIME) < 0) |
| use_clock = 0; |
| else |
| # endif |
| /* See whether we can use the CPU clock. */ |
| use_clock = clock_getcpuclockid (0, &cl) == 0; |
| #endif |
| |
| #ifdef DEBUG |
| re_set_syntax (RE_DEBUG); |
| #endif |
| |
| /* Run the actual tests. All tests are run in a single-byte and a |
| multi-byte locale. */ |
| result = test_expr ("[äáàâéèêíìîñöóòôüúùû]", 2, 2); |
| result |= test_expr ("G.ran", 2, 3); |
| result |= test_expr ("G.\\{1\\}ran", 2, 3); |
| result |= test_expr ("G.*ran", 3, 44); |
| result |= test_expr ("[äáàâ]", 0, 0); |
| result |= test_expr ("Uddeborg", 2, 2); |
| result |= test_expr (".Uddeborg", 2, 2); |
| |
| /* Free the resources. */ |
| free (umem); |
| iconv_close (cd); |
| free (mem); |
| |
| return result; |
| } |
| |
| |
| static int |
| test_expr (const char *expr, int expected, int expectedicase) |
| { |
| int result; |
| char *inmem; |
| char *outmem; |
| size_t inlen; |
| size_t outlen; |
| char *uexpr; |
| |
| /* First test: search with an ISO-8859-1 locale. */ |
| if (setlocale (LC_ALL, "de_DE.ISO-8859-1") == NULL) |
| error (EXIT_FAILURE, 0, "cannot set locale de_DE.ISO-8859-1"); |
| |
| printf ("\nTest \"%s\" with 8-bit locale\n", expr); |
| result = run_test (expr, mem, memlen, 0, expected); |
| printf ("\nTest \"%s\" with 8-bit locale, case insensitive\n", expr); |
| result |= run_test (expr, mem, memlen, 1, expectedicase); |
| printf ("\nTest \"%s\" backwards with 8-bit locale\n", expr); |
| result |= run_test_backwards (expr, mem, memlen, 0, expected); |
| printf ("\nTest \"%s\" backwards with 8-bit locale, case insensitive\n", |
| expr); |
| result |= run_test_backwards (expr, mem, memlen, 1, expectedicase); |
| |
| /* Second test: search with an UTF-8 locale. */ |
| if (setlocale (LC_ALL, "de_DE.UTF-8") == NULL) |
| error (EXIT_FAILURE, 0, "cannot set locale de_DE.UTF-8"); |
| |
| inmem = (char *) expr; |
| inlen = strlen (expr); |
| outlen = inlen * MB_CUR_MAX; |
| outmem = uexpr = alloca (outlen + 1); |
| memset (outmem, '\0', outlen + 1); |
| iconv (cd, &inmem, &inlen, &outmem, &outlen); |
| if (inlen != 0) |
| error (EXIT_FAILURE, errno, "cannot convert expression"); |
| |
| /* Run the tests. */ |
| printf ("\nTest \"%s\" with multi-byte locale\n", expr); |
| result |= run_test (uexpr, umem, umemlen, 0, expected); |
| printf ("\nTest \"%s\" with multi-byte locale, case insensitive\n", expr); |
| result |= run_test (uexpr, umem, umemlen, 1, expectedicase); |
| printf ("\nTest \"%s\" backwards with multi-byte locale\n", expr); |
| result |= run_test_backwards (uexpr, umem, umemlen, 0, expected); |
| printf ("\nTest \"%s\" backwards with multi-byte locale, case insensitive\n", |
| expr); |
| result |= run_test_backwards (uexpr, umem, umemlen, 1, expectedicase); |
| |
| return result; |
| } |
| |
| |
| static int |
| run_test (const char *expr, const char *mem, size_t memlen, int icase, |
| int expected) |
| { |
| #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0 |
| struct timespec start; |
| struct timespec finish; |
| #endif |
| regex_t re; |
| int err; |
| size_t offset; |
| int cnt; |
| |
| #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0 |
| if (use_clock && !timing) |
| use_clock = clock_gettime (cl, &start) == 0; |
| #endif |
| |
| err = regcomp (&re, expr, REG_NEWLINE | (icase ? REG_ICASE : 0)); |
| if (err != REG_NOERROR) |
| { |
| char buf[200]; |
| regerror (err, &re, buf, sizeof buf); |
| error (EXIT_FAILURE, 0, "cannot compile expression: %s", buf); |
| } |
| |
| cnt = 0; |
| offset = 0; |
| assert (mem[memlen] == '\0'); |
| while (offset < memlen) |
| { |
| regmatch_t ma[1]; |
| const char *sp; |
| const char *ep; |
| |
| err = regexec (&re, mem + offset, 1, ma, 0); |
| if (err == REG_NOMATCH) |
| break; |
| |
| if (err != REG_NOERROR) |
| { |
| char buf[200]; |
| regerror (err, &re, buf, sizeof buf); |
| error (EXIT_FAILURE, 0, "cannot use expression: %s", buf); |
| } |
| |
| assert (ma[0].rm_so >= 0); |
| sp = mem + offset + ma[0].rm_so; |
| while (sp > mem && sp[-1] != '\n') |
| --sp; |
| |
| ep = mem + offset + ma[0].rm_so; |
| while (*ep != '\0' && *ep != '\n') |
| ++ep; |
| |
| printf ("match %d: \"%.*s\"\n", ++cnt, (int) (ep - sp), sp); |
| |
| offset = ep + 1 - mem; |
| } |
| |
| regfree (&re); |
| |
| #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0 |
| if (use_clock && !timing) |
| { |
| use_clock = clock_gettime (cl, &finish) == 0; |
| if (use_clock) |
| { |
| if (finish.tv_nsec < start.tv_nsec) |
| { |
| finish.tv_nsec -= start.tv_nsec - 1000000000; |
| finish.tv_sec -= 1 + start.tv_sec; |
| } |
| else |
| { |
| finish.tv_nsec -= start.tv_nsec; |
| finish.tv_sec -= start.tv_sec; |
| } |
| |
| printf ("elapsed time: %jd.%09jd sec\n", |
| (intmax_t) finish.tv_sec, (intmax_t) finish.tv_nsec); |
| } |
| } |
| |
| if (use_clock && timing) |
| { |
| struct timespec mintime = { .tv_sec = 24 * 60 * 60 }; |
| |
| for (int i = 0; i < 10; ++i) |
| { |
| offset = 0; |
| use_clock = clock_gettime (cl, &start) == 0; |
| |
| if (!use_clock) |
| continue; |
| |
| err = regcomp (&re, expr, REG_NEWLINE | (icase ? REG_ICASE : 0)); |
| if (err != REG_NOERROR) |
| continue; |
| |
| while (offset < memlen) |
| { |
| regmatch_t ma[1]; |
| |
| err = regexec (&re, mem + offset, 1, ma, 0); |
| if (err != REG_NOERROR) |
| break; |
| |
| offset += ma[0].rm_eo; |
| } |
| |
| regfree (&re); |
| |
| use_clock = clock_gettime (cl, &finish) == 0; |
| if (use_clock) |
| { |
| if (finish.tv_nsec < start.tv_nsec) |
| { |
| finish.tv_nsec -= start.tv_nsec - 1000000000; |
| finish.tv_sec -= 1 + start.tv_sec; |
| } |
| else |
| { |
| finish.tv_nsec -= start.tv_nsec; |
| finish.tv_sec -= start.tv_sec; |
| } |
| if (finish.tv_sec < mintime.tv_sec |
| || (finish.tv_sec == mintime.tv_sec |
| && finish.tv_nsec < mintime.tv_nsec)) |
| mintime = finish; |
| } |
| } |
| printf ("elapsed time: %jd.%09jd sec\n", |
| (intmax_t) mintime.tv_sec, (intmax_t) mintime.tv_nsec); |
| } |
| #endif |
| |
| /* Return an error if the number of matches found is not match we |
| expect. */ |
| return cnt != expected; |
| } |
| |
| |
| static int |
| run_test_backwards (const char *expr, const char *mem, size_t memlen, |
| int icase, int expected) |
| { |
| #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0 |
| struct timespec start; |
| struct timespec finish; |
| #endif |
| struct re_pattern_buffer re; |
| const char *err; |
| size_t offset; |
| int cnt; |
| |
| #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0 |
| if (use_clock && !timing) |
| use_clock = clock_gettime (cl, &start) == 0; |
| #endif |
| |
| re_set_syntax ((RE_SYNTAX_POSIX_BASIC & ~RE_DOT_NEWLINE) |
| | RE_HAT_LISTS_NOT_NEWLINE |
| | (icase ? RE_ICASE : 0)); |
| |
| memset (&re, 0, sizeof (re)); |
| re.fastmap = malloc (256); |
| if (re.fastmap == NULL) |
| error (EXIT_FAILURE, errno, "cannot allocate fastmap"); |
| |
| err = re_compile_pattern (expr, strlen (expr), &re); |
| if (err != NULL) |
| error (EXIT_FAILURE, 0, "cannot compile expression: %s", err); |
| |
| if (re_compile_fastmap (&re)) |
| error (EXIT_FAILURE, 0, "couldn't compile fastmap"); |
| |
| cnt = 0; |
| offset = memlen; |
| assert (mem[memlen] == '\0'); |
| while (offset <= memlen) |
| { |
| int start; |
| const char *sp; |
| const char *ep; |
| |
| start = re_search (&re, mem, memlen, offset, -offset, NULL); |
| if (start == -1) |
| break; |
| |
| if (start == -2) |
| error (EXIT_FAILURE, 0, "internal error in re_search"); |
| |
| sp = mem + start; |
| while (sp > mem && sp[-1] != '\n') |
| --sp; |
| |
| ep = mem + start; |
| while (*ep != '\0' && *ep != '\n') |
| ++ep; |
| |
| printf ("match %d: \"%.*s\"\n", ++cnt, (int) (ep - sp), sp); |
| |
| offset = sp - 1 - mem; |
| } |
| |
| regfree (&re); |
| |
| #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0 |
| if (use_clock && !timing) |
| { |
| use_clock = clock_gettime (cl, &finish) == 0; |
| if (use_clock) |
| { |
| if (finish.tv_nsec < start.tv_nsec) |
| { |
| finish.tv_nsec -= start.tv_nsec - 1000000000; |
| finish.tv_sec -= 1 + start.tv_sec; |
| } |
| else |
| { |
| finish.tv_nsec -= start.tv_nsec; |
| finish.tv_sec -= start.tv_sec; |
| } |
| |
| printf ("elapsed time: %jd.%09jd sec\n", |
| (intmax_t) finish.tv_sec, (intmax_t) finish.tv_nsec); |
| } |
| } |
| |
| if (use_clock && timing) |
| { |
| struct timespec mintime = { .tv_sec = 24 * 60 * 60 }; |
| |
| for (int i = 0; i < 10; ++i) |
| { |
| offset = memlen; |
| use_clock = clock_gettime (cl, &start) == 0; |
| |
| if (!use_clock) |
| continue; |
| |
| memset (&re, 0, sizeof (re)); |
| re.fastmap = malloc (256); |
| if (re.fastmap == NULL) |
| continue; |
| |
| err = re_compile_pattern (expr, strlen (expr), &re); |
| if (err != NULL) |
| continue; |
| |
| if (re_compile_fastmap (&re)) |
| { |
| regfree (&re); |
| continue; |
| } |
| |
| while (offset <= memlen) |
| { |
| int start; |
| const char *sp; |
| |
| start = re_search (&re, mem, memlen, offset, -offset, NULL); |
| if (start < -1) |
| break; |
| |
| sp = mem + start; |
| while (sp > mem && sp[-1] != '\n') |
| --sp; |
| |
| offset = sp - 1 - mem; |
| } |
| |
| regfree (&re); |
| |
| use_clock = clock_gettime (cl, &finish) == 0; |
| if (use_clock) |
| { |
| if (finish.tv_nsec < start.tv_nsec) |
| { |
| finish.tv_nsec -= start.tv_nsec - 1000000000; |
| finish.tv_sec -= 1 + start.tv_sec; |
| } |
| else |
| { |
| finish.tv_nsec -= start.tv_nsec; |
| finish.tv_sec -= start.tv_sec; |
| } |
| if (finish.tv_sec < mintime.tv_sec |
| || (finish.tv_sec == mintime.tv_sec |
| && finish.tv_nsec < mintime.tv_nsec)) |
| mintime = finish; |
| } |
| } |
| printf ("elapsed time: %jd.%09jd sec\n", |
| (intmax_t) mintime.tv_sec, (intmax_t) mintime.tv_nsec); |
| } |
| #endif |
| |
| /* Return an error if the number of matches found is not match we |
| expect. */ |
| return cnt != expected; |
| } |
| |
| /* If --timing is used we will need a larger timout. */ |
| #define TIMEOUT 50 |
| #define CMDLINE_OPTIONS \ |
| {"timing", no_argument, &timing, 1 }, |
| #define TEST_FUNCTION do_test () |
| #include "../test-skeleton.c" |