regex-tests: omit unused parts

Problem reported by Bruno Haible in:
https://lists.gnu.org/r/bug-gnulib/2026-05/msg00137.html
* tests/test-regex-en.c (tests, bug_regex11): Remove; unused.
* tests/test-regex-en.c, tests/test-regex-tr.c, tests/test-regex.c:
(main): Omit unused args.

diff --git a/ChangeLog b/ChangeLog
index f3cd5f3b0ef5fbedde65b3d5f73442640af47adf..8892a3d09bbd1304ce14350cc1691f21bfc8a990 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+2026-05-22  Paul Eggert  <eggert@cs.ucla.edu>
+
+       regex-tests: omit unused parts
+       Problem reported by Bruno Haible in:
+       https://lists.gnu.org/r/bug-gnulib/2026-05/msg00137.html
+       * tests/test-regex-en.c (tests, bug_regex11): Remove; unused.
+       * tests/test-regex-en.c, tests/test-regex-tr.c, tests/test-regex.c:
+       (main): Omit unused args.
+
 2026-05-22  Bruno Haible  <bruno@clisp.org>
 
        doc: Update for OpenBSD 7.9.

diff --git a/tests/test-regex-en.c b/tests/test-regex-en.c
index 7317961bc5824972c80ef3a8c9490554b7ca40ff..c8d23046420e1da4564f4ceab47a82a492e47776 100644 (file)
--- a/tests/test-regex-en.c
+++ b/tests/test-regex-en.c
@@ -54,115 +54,8 @@ really_utf8 (void)
   return streq (locale_charset (), "UTF-8");
 }
 
-/* Tests supposed to match; copied from glibc posix/bug-regex11.c.  */
-static struct
-{
-  const char *pattern;
-  const char *string;
-  int flags, nmatch;
-  regmatch_t rm[5];
-} const tests[] = {
-  /* Test for newline handling in regex.  */
-  { "[^~]*~", "\nx~y", 0, 2, { { 0, 3 }, { -1, -1 } } },
-  /* Other tests.  */
-  { "a(.*)b", "a b", REG_EXTENDED, 2, { { 0, 3 }, { 1, 2 } } },
-  { ".*|\\([KIO]\\)\\([^|]*\\).*|?[KIO]", "10~.~|P|K0|I10|O16|?KSb", 0, 3,
-    { { 0, 21 }, { 15, 16 }, { 16, 18 } } },
-  { ".*|\\([KIO]\\)\\([^|]*\\).*|?\\1", "10~.~|P|K0|I10|O16|?KSb", 0, 3,
-    { { 0, 21 }, { 8, 9 }, { 9, 10 } } },
-  { "^\\(a*\\)\\1\\{9\\}\\(a\\{0,9\\}\\)\\([0-9]*;.*[^a]\\2\\([0-9]\\)\\)",
-    "a1;;0a1aa2aaa3aaaa4aaaaa5aaaaaa6aaaaaaa7aaaaaaaa8aaaaaaaaa9aa2aa1a0", 0,
-    5, { { 0, 67 }, { 0, 0 }, { 0, 1 }, { 1, 67 }, { 66, 67 } } },
-  /* Test for BRE expression anchoring.  POSIX says just that this may match;
-     in glibc regex it always matched, so avoid changing it.  */
-  { "\\(^\\|foo\\)bar", "bar", 0, 2, { { 0, 3 }, { -1, -1 } } },
-  { "\\(foo\\|^\\)bar", "bar", 0, 2, { { 0, 3 }, { -1, -1 } } },
-  /* In ERE this must be treated as an anchor.  */
-  { "(^|foo)bar", "bar", REG_EXTENDED, 2, { { 0, 3 }, { -1, -1 } } },
-  { "(foo|^)bar", "bar", REG_EXTENDED, 2, { { 0, 3 }, { -1, -1 } } },
-  /* Here ^ cannot be treated as an anchor according to POSIX.  */
-  { "(^|foo)bar", "(^|foo)bar", 0, 2, { { 0, 10 }, { -1, -1 } } },
-  { "(foo|^)bar", "(foo|^)bar", 0, 2, { { 0, 10 }, { -1, -1 } } },
-  /* More tests on backreferences.  */
-  { "()\\1", "x", REG_EXTENDED, 2, { { 0, 0 }, { 0, 0 } } },
-  { "()x\\1", "x", REG_EXTENDED, 2, { { 0, 1 }, { 0, 0 } } },
-  { "()\\1*\\1*", "", REG_EXTENDED, 2, { { 0, 0 }, { 0, 0 } } },
-  { "([0-9]).*\\1(a*)", "7;7a6", REG_EXTENDED, 3, { { 0, 4 }, { 0, 1 }, { 3, 4 } } },
-  { "([0-9]).*\\1(a*)", "7;7a", REG_EXTENDED, 3, { { 0, 4 }, { 0, 1 }, { 3, 4 } } },
-  { "(b)()c\\1", "bcb", REG_EXTENDED, 3, { { 0, 3 }, { 0, 1 }, { 1, 1 } } },
-  { "()(b)c\\2", "bcb", REG_EXTENDED, 3, { { 0, 3 }, { 0, 0 }, { 0, 1 } } },
-  { "a(b)()c\\1", "abcb", REG_EXTENDED, 3, { { 0, 4 }, { 1, 2 }, { 2, 2 } } },
-  { "a()(b)c\\2", "abcb", REG_EXTENDED, 3, { { 0, 4 }, { 1, 1 }, { 1, 2 } } },
-  { "()(b)\\1c\\2", "bcb", REG_EXTENDED, 3, { { 0, 3 }, { 0, 0 }, { 0, 1 } } },
-  { "(b())\\2\\1", "bbbb", REG_EXTENDED, 3, { { 0, 2 }, { 0, 1 }, { 1, 1 } } },
-  { "a()(b)\\1c\\2", "abcb", REG_EXTENDED, 3, { { 0, 4 }, { 1, 1 }, { 1, 2 } } },
-  { "a()d(b)\\1c\\2", "adbcb", REG_EXTENDED, 3, { { 0, 5 }, { 1, 1 }, { 2, 3 } } },
-  { "a(b())\\2\\1", "abbbb", REG_EXTENDED, 3, { { 0, 3 }, { 1, 2 }, { 2, 2 } } },
-  { "(bb())\\2\\1", "bbbb", REG_EXTENDED, 3, { { 0, 4 }, { 0, 2 }, { 2, 2 } } },
-  { "^([^,]*),\\1,\\1$", "a,a,a", REG_EXTENDED, 2, { { 0, 5 }, { 0, 1 } } },
-  { "^([^,]*),\\1,\\1$", "ab,ab,ab", REG_EXTENDED, 2, { { 0, 8 }, { 0, 2 } } },
-  { "^([^,]*),\\1,\\1,\\1$", "abc,abc,abc,abc", REG_EXTENDED, 2,
-    { { 0, 15 }, { 0, 3 } } },
-  { "^(.?)(.?)(.?)(.?)(.?).?\\5\\4\\3\\2\\1$",
-    "level", REG_NOSUB | REG_EXTENDED, 0, { { -1, -1 } } },
-  { "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$|^.?$",
-    "level", REG_NOSUB | REG_EXTENDED, 0, { { -1, -1 } } },
-  { "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$|^.?$",
-    "abcdedcba", REG_EXTENDED, 1, { { 0, 9 } } },
-  { "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$|^.?$",
-    "ababababa", REG_EXTENDED, 1, { { 0, 9 } } },
-  { "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$",
-    "level", REG_NOSUB | REG_EXTENDED, 0, { { -1, -1 } } },
-  { "^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?).?\\9\\8\\7\\6\\5\\4\\3\\2\\1$",
-    "ababababa", REG_EXTENDED, 1, { { 0, 9 } } },
-  /* Test for *+ match.  */
-  { "^a*+(.)", "ab", REG_EXTENDED, 2, { { 0, 2 }, { 1, 2 } } },
-  /* Test for ** match.  */
-  { "^(a*)*(.)", "ab", REG_EXTENDED, 3, { { 0, 2 }, { 0, 1 }, { 1, 2 } } },
-};
-
-static void
-bug_regex11 (void)
-{
-  regex_t re;
-  regmatch_t rm[5];
-
-  for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); ++i)
-    {
-      int err = regcomp (&re, tests[i].pattern, tests[i].flags);
-      if (err != 0)
-        {
-          char buf[500];
-          regerror (err, &re, buf, sizeof (buf));
-          report_error ("%s: regcomp %zd failed: %s", tests[i].pattern, i, buf);
-          continue;
-        }
-
-      if (regexec (&re, tests[i].string, tests[i].nmatch, rm, 0))
-        {
-          report_error ("%s: regexec %zd failed", tests[i].pattern, i);
-          regfree (&re);
-          continue;
-        }
-
-      for (int n = 0; n < tests[i].nmatch; ++n)
-        if (rm[n].rm_so != tests[i].rm[n].rm_so
-              || rm[n].rm_eo != tests[i].rm[n].rm_eo)
-          {
-            if (tests[i].rm[n].rm_so == -1 && tests[i].rm[n].rm_eo == -1)
-              break;
-            report_error ("%s: regexec %zd match failure rm[%d] %d..%d",
-                          tests[i].pattern, i, n,
-                          (int) rm[n].rm_so, (int) rm[n].rm_eo);
-            break;
-          }
-
-      regfree (&re);
-    }
-}
-
 int
-main (int argc, char *argv[])
+main ()
 {
   struct re_pattern_buffer regex;
   const char *s;

diff --git a/tests/test-regex-tr.c b/tests/test-regex-tr.c
index 3c234c26dcca2856089dda761e5ed06c5a777fba..88263f3d1ce92d05faa02adb055284f28b64979f 100644 (file)
--- a/tests/test-regex-tr.c
+++ b/tests/test-regex-tr.c
@@ -55,7 +55,7 @@ really_utf8 (void)
 }
 
 int
-main (int argc, char **argv)
+main ()
 {
   struct re_pattern_buffer regex;
   const char *s;

diff --git a/tests/test-regex.c b/tests/test-regex.c
index d5d33606eb3f6e4083d7acba3ca78ae543908a82..b0a22b54f407af67f6bcbab0b80aeebe09635909 100644 (file)
--- a/tests/test-regex.c
+++ b/tests/test-regex.c
@@ -151,7 +151,7 @@ bug_regex11 (void)
 }
 
 int
-main (void)
+main ()
 {
   struct re_pattern_buffer regex;
   unsigned char folded_chars[UCHAR_MAX + 1];