Re: [PATCH 8/8] regex: fix glibc bug 20381

From 5ab7a04761dac69403f677de4ee44c1940777b46 Mon Sep 17 00:00:00 2001
From: Paul Eggert <[email protected]>
Date: Fri, 22 May 2026 08:44:12 -0700
Subject: [PATCH] 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.
---
 ChangeLog             |   9 ++++
 tests/test-regex-en.c | 109 +-----------------------------------------
 tests/test-regex-tr.c |   2 +-
 tests/test-regex.c    |   2 +-
 4 files changed, 12 insertions(+), 110 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index f3cd5f3b0e..8892a3d09b 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+2026-05-22  Paul Eggert  <[email protected]>
+
+	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  <[email protected]>
 
 	doc: Update for OpenBSD 7.9.
diff --git a/tests/test-regex-en.c b/tests/test-regex-en.c
index 7317961bc5..c8d2304642 100644
--- 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 3c234c26dc..88263f3d1c 100644
--- 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 d5d33606eb..b0a22b54f4 100644
--- 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];
-- 
2.53.0