Fix bugs in last patch.

* lib/memchr2.c (memchr2): Fix typo.
* tests/test-memchr2.c: Test previous bug, and don't use GNU
extension.
Reported by Bruce Korb.

Signed-off-by: Eric Blake <ebb9@byu.net>

diff --git a/ChangeLog b/ChangeLog
index 01f036192e0372b791289b511dbb162053edbdb4..b0040fb17d801180c520cc42d8f5b41229c114b5 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -6,6 +6,12 @@
 
 2008-03-01  Eric Blake  <ebb9@byu.net>
 
+       Fix bugs in last patch.
+       * lib/memchr2.c (memchr2): Fix typo.
+       * tests/test-memchr2.c: Test previous bug, and don't use GNU
+       extension.
+       Reported by Bruce Korb.
+
        New module 'memchr2'.
        * modules/memchr2: New file.
        * modules/memchr2-tests: Likewise.

diff --git a/lib/memchr2.c b/lib/memchr2.c
index 540ed9fc3b6a74d4e7b6b22568b79f243ec2c54f..d5b0a787a84710a8957dc066f418472e40c04937 100644 (file)
--- a/lib/memchr2.c
+++ b/lib/memchr2.c
@@ -81,8 +81,8 @@ memchr2 (void const *s, int c1_in, int c2_in, size_t n)
   magic_bits = 0xfefefefe;
   charmask1 = c1 | (c1 << 8);
   charmask2 = c2 | (c2 << 8);
-  charmask1 |= charmask2 << 16;
-  charmask1 |= charmask2 << 16;
+  charmask1 |= charmask1 << 16;
+  charmask2 |= charmask2 << 16;
 #if 0xffffffffU < UINTMAX_MAX
   magic_bits |= magic_bits << 32;
   charmask1 |= charmask1 << 32;

diff --git a/tests/test-memchr2.c b/tests/test-memchr2.c
index 68e85952219d15537c10bda2927bcec285f055c2..639ecd30ed6da46f788f68842097a647e42758b3 100644 (file)
--- a/tests/test-memchr2.c
+++ b/tests/test-memchr2.c
@@ -34,6 +34,10 @@
     }                                                                       \
   while (0)
 
+/* Calculating void * + int is not portable, so this wrapper converts
+   to char * to make the tests easier to write.  */
+#define MEMCHR2 (char *) memchr2
+
 int
 main ()
 {
@@ -48,27 +52,28 @@ main ()
   input[n - 2] = 'e';
   input[n - 1] = 'a';
 
-  ASSERT (memchr2 (input, 'a', 'b', n) == input);
-  ASSERT (memchr2 (input, 'b', 'a', n) == input);
+  /* Basic behavior tests.  */
+  ASSERT (MEMCHR2 (input, 'a', 'b', n) == input);
+  ASSERT (MEMCHR2 (input, 'b', 'a', n) == input);
 
-  ASSERT (memchr2 (input, 'a', 'b', 0) == NULL);
-  ASSERT (memchr2 (NULL, 'a', 'b', 0) == NULL);
+  ASSERT (MEMCHR2 (input, 'a', 'b', 0) == NULL);
+  ASSERT (MEMCHR2 (NULL, 'a', 'b', 0) == NULL);
 
-  ASSERT (memchr2 (input, 'b', 'd', n) == input + 1);
-  ASSERT (memchr2 (input + 2, 'b', 'd', n - 2) == input + 1026);
+  ASSERT (MEMCHR2 (input, 'b', 'd', n) == input + 1);
+  ASSERT (MEMCHR2 (input + 2, 'b', 'd', n - 2) == input + 1026);
 
-  ASSERT (memchr2 (input, 'd', 'e', n) == input + 1026);
-  ASSERT (memchr2 (input, 'e', 'd', n) == input + 1026);
+  ASSERT (MEMCHR2 (input, 'd', 'e', n) == input + 1026);
+  ASSERT (MEMCHR2 (input, 'e', 'd', n) == input + 1026);
 
-  ASSERT (memchr2 (input + 1, 'a', 'e', n - 1) == input + n - 2);
-  ASSERT (memchr2 (input + 1, 'e', 'a', n - 1) == input + n - 2);
+  ASSERT (MEMCHR2 (input + 1, 'a', 'e', n - 1) == input + n - 2);
+  ASSERT (MEMCHR2 (input + 1, 'e', 'a', n - 1) == input + n - 2);
 
-  ASSERT (memchr2 (input, 'f', 'g', n) == NULL);
-  ASSERT (memchr2 (input, 'f', '\0', n) == NULL);
+  ASSERT (MEMCHR2 (input, 'f', 'g', n) == NULL);
+  ASSERT (MEMCHR2 (input, 'f', '\0', n) == NULL);
 
-  ASSERT (memchr2 (input, 'a', 'a', n) == input);
-  ASSERT (memchr2 (input + 1, 'a', 'a', n - 1) == input + n - 1);
-  ASSERT (memchr2 (input, 'f', 'f', n) == NULL);
+  ASSERT (MEMCHR2 (input, 'a', 'a', n) == input);
+  ASSERT (MEMCHR2 (input + 1, 'a', 'a', n - 1) == input + n - 1);
+  ASSERT (MEMCHR2 (input, 'f', 'f', n) == NULL);
 
   /* Check that a very long haystack is handled quickly if one of the
      two bytes is found near the beginning.  */
@@ -76,10 +81,25 @@ main ()
     size_t repeat = 10000;
     for (; repeat > 0; repeat--)
       {
-       ASSERT (memchr2 (input, 'c', 'e', n) == input + 2);
-       ASSERT (memchr2 (input, 'e', 'c', n) == input + 2);
-       ASSERT (memchr2 (input, 'c', '\0', n) == input + 2);
-       ASSERT (memchr2 (input, '\0', 'c', n) == input + 2);
+       ASSERT (MEMCHR2 (input, 'c', 'e', n) == input + 2);
+       ASSERT (MEMCHR2 (input, 'e', 'c', n) == input + 2);
+       ASSERT (MEMCHR2 (input, 'c', '\0', n) == input + 2);
+       ASSERT (MEMCHR2 (input, '\0', 'c', n) == input + 2);
+      }
+  }
+
+  /* Alignment tests.  */
+  {
+    int i, j;
+    for (i = 0; i < 32; i++)
+      {
+       for (j = 0; j < 256; j++)
+         input[i + j] = j;
+       for (j = 0; j < 256; j++)
+         {
+           ASSERT (MEMCHR2 (input + i, j, 0xff, 256) == input + i + j);
+           ASSERT (MEMCHR2 (input + i, 0xff, j, 256) == input + i + j);
+         }
       }
   }