Add test case from a recent glibc bug.

* tests/test-strstr.c (main): Add test of long needle.
* tests/test-strcasestr.c (main): Likewise.
* tests/test-c-strstr.c (main): Likewise.
* tests/test-c-strcasestr.c (main): Likewise.
* tests/test-memmem.c (main): Likewise.

diff --git a/ChangeLog b/ChangeLog
index c5b5118848d7970630f65d017802167f1c17dbfc..2f89dcdbd5b8ad57ad9b95b244afb5fed4fecabe 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+2018-09-12  Bruno Haible  <bruno@clisp.org>
+
+       Add test case from a recent glibc bug.
+       * tests/test-strstr.c (main): Add test of long needle.
+       * tests/test-strcasestr.c (main): Likewise.
+       * tests/test-c-strstr.c (main): Likewise.
+       * tests/test-c-strcasestr.c (main): Likewise.
+       * tests/test-memmem.c (main): Likewise.
+
 2018-09-12  Bruno Haible  <bruno@clisp.org>
 
        Apply Eric Blake's improvements from 2011-02-25 to more tests.

diff --git a/tests/test-c-strcasestr.c b/tests/test-c-strcasestr.c
index ac1c44d41fb18540091bd96003c500aa9c6bc824..f594be6749af370349aa6a1a9e6554873a338bfb 100644 (file)
--- a/tests/test-c-strcasestr.c
+++ b/tests/test-c-strcasestr.c
@@ -238,5 +238,27 @@ main ()
     free (haystack);
   }
 
+  /* Test long needles.  */
+  {
+    size_t m = 1024;
+    char *haystack = (char *) malloc (2 * m + 1);
+    char *needle = (char *) malloc (m + 1);
+    if (haystack != NULL && needle != NULL)
+      {
+        const char *p;
+        haystack[0] = 'x';
+        memset (haystack + 1, ' ', m - 1);
+        memset (haystack + m, 'x', m);
+        haystack[2 * m] = '\0';
+        memset (needle, 'X', m);
+        needle[m] = '\0';
+        p = c_strcasestr (haystack, needle);
+        ASSERT (p);
+        ASSERT (p - haystack == m);
+      }
+    free (needle);
+    free (haystack);
+  }
+
   return 0;
 }

diff --git a/tests/test-c-strstr.c b/tests/test-c-strstr.c
index 307dde772ee938a4730c21808fcb482b48ac06cc..25e7d43c2692824e0db6b0762c572242a3033319 100644 (file)
--- a/tests/test-c-strstr.c
+++ b/tests/test-c-strstr.c
@@ -212,5 +212,27 @@ main ()
     free (haystack);
   }
 
+  /* Test long needles.  */
+  {
+    size_t m = 1024;
+    char *haystack = (char *) malloc (2 * m + 1);
+    char *needle = (char *) malloc (m + 1);
+    if (haystack != NULL && needle != NULL)
+      {
+        const char *p;
+        haystack[0] = 'x';
+        memset (haystack + 1, ' ', m - 1);
+        memset (haystack + m, 'x', m);
+        haystack[2 * m] = '\0';
+        memset (needle, 'x', m);
+        needle[m] = '\0';
+        p = c_strstr (haystack, needle);
+        ASSERT (p);
+        ASSERT (p - haystack == m);
+      }
+    free (needle);
+    free (haystack);
+  }
+
   return 0;
 }

diff --git a/tests/test-memmem.c b/tests/test-memmem.c
index 622932d25c1ee0075f69cf560653b98cf96a0f59..264e82456ae432a2b249c77670e163338c2c85ba 100644 (file)
--- a/tests/test-memmem.c
+++ b/tests/test-memmem.c
@@ -289,5 +289,27 @@ main (int argc, char *argv[])
     free (haystack);
   }
 
+  /* Test long needles.  */
+  {
+    size_t m = 1024;
+    char *haystack = (char *) malloc (2 * m + 1);
+    char *needle = (char *) malloc (m + 1);
+    if (haystack != NULL && needle != NULL)
+      {
+        const char *p;
+        haystack[0] = 'x';
+        memset (haystack + 1, ' ', m - 1);
+        memset (haystack + m, 'x', m);
+        haystack[2 * m] = '\0';
+        memset (needle, 'x', m);
+        needle[m] = '\0';
+        p = memmem (haystack, strlen (haystack), needle, strlen (needle));
+        ASSERT (p);
+        ASSERT (p - haystack == m);
+      }
+    free (needle);
+    free (haystack);
+  }
+
   return 0;
 }

diff --git a/tests/test-strcasestr.c b/tests/test-strcasestr.c
index 21192bc2a88c97e3cc4fae79ca9b8a276e312e83..4c651ecc09a14724a8ff6fbf3b86fd5435d769cc 100644 (file)
--- a/tests/test-strcasestr.c
+++ b/tests/test-strcasestr.c
@@ -252,5 +252,27 @@ main ()
     free (haystack);
   }
 
+  /* Test long needles.  */
+  {
+    size_t m = 1024;
+    char *haystack = (char *) malloc (2 * m + 1);
+    char *needle = (char *) malloc (m + 1);
+    if (haystack != NULL && needle != NULL)
+      {
+        const char *p;
+        haystack[0] = 'x';
+        memset (haystack + 1, ' ', m - 1);
+        memset (haystack + m, 'x', m);
+        haystack[2 * m] = '\0';
+        memset (needle, 'X', m);
+        needle[m] = '\0';
+        p = strcasestr (haystack, needle);
+        ASSERT (p);
+        ASSERT (p - haystack == m);
+      }
+    free (needle);
+    free (haystack);
+  }
+
   return 0;
 }

diff --git a/tests/test-strstr.c b/tests/test-strstr.c
index 5ba6cb823d2f09241e0c05d4a2d6038748f4c205..9538403eeabe47aa8dffe1fb2a1d0bf5f7ecbc8f 100644 (file)
--- a/tests/test-strstr.c
+++ b/tests/test-strstr.c
@@ -275,5 +275,27 @@ main (int argc, char *argv[])
     free (haystack);
   }
 
+  /* Test long needles.  */
+  {
+    size_t m = 1024;
+    char *haystack = (char *) malloc (2 * m + 1);
+    char *needle = (char *) malloc (m + 1);
+    if (haystack != NULL && needle != NULL)
+      {
+        const char *p;
+        haystack[0] = 'x';
+        memset (haystack + 1, ' ', m - 1);
+        memset (haystack + m, 'x', m);
+        haystack[2 * m] = '\0';
+        memset (needle, 'x', m);
+        needle[m] = '\0';
+        p = strstr (haystack, needle);
+        ASSERT (p);
+        ASSERT (p - haystack == m);
+      }
+    free (needle);
+    free (haystack);
+  }
+
   return 0;
 }