]> Savannah Git Hosting - gnulib.git/commitdiff
bitset: more tests
authorAkim Demaille <akim.demaille@gmail.com>
Sat, 14 Nov 2020 15:01:23 +0000 (16:01 +0100)
committerAkim Demaille <akim.demaille@gmail.com>
Sun, 15 Nov 2020 17:00:20 +0000 (18:00 +0100)
These new tests managed to uncover shortcomings in previous versions
of the following commit.

* tests/test-bitset.c (compare): Make it clear that the random values
should not be modified.
Check bitset_first, bitset_last and BITSET_FOR_EACH.

ChangeLog
tests/test-bitset.c

index 64cacdefb0ee1aee46ab8da66b6317bf8f070c9e..1eb7396d76b8479f25f014067b5577691c284a33 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2020-11-15  Akim Demaille  <akim@lrde.epita.fr>
+
+       bitset: more tests
+       * tests/test-bitset.c (compare): Make it clear that the random values
+       should not be modified.
+       Check bitset_first, bitset_last and BITSET_FOR_EACH.
+
 2020-11-15  Akim Demaille  <akim@lrde.epita.fr>
 
        bitset: fix the copy from lbitset to other types
index 02d7cda82b7636e6f8a21fcebd69c3c0048a9a38..ebe9e1d55984b7789e63b262e1d81435eaa3f916 100644 (file)
@@ -48,24 +48,28 @@ void compare (enum bitset_attr a, enum bitset_attr b)
 {
   const int nbits = RANDOM (256);
 
-  bitset asrc0 = bitset_create (nbits, a);
+  /* Four read only random initial values of type A.  */
+  const bitset asrc0 = bitset_create (nbits, a);
   bitset_random (asrc0);
-  bitset asrc1 = bitset_create (nbits, a);
+  const bitset asrc1 = bitset_create (nbits, a);
   bitset_random (asrc1);
-  bitset asrc2 = bitset_create (nbits, a);
+  const bitset asrc2 = bitset_create (nbits, a);
   bitset_random (asrc2);
-  bitset asrc3 = bitset_create (nbits, a);
+  const bitset asrc3 = bitset_create (nbits, a);
   bitset_random (asrc3);
-  bitset adst = bitset_create (nbits, a);
 
-  bitset bsrc0 = bitset_create (nbits, b);
+  /* Four read only values of type B, equal to the values of type A. */
+  const bitset bsrc0 = bitset_create (nbits, b);
   bitset_copy (bsrc0, asrc0);
-  bitset bsrc1 = bitset_create (nbits, b);
+  const bitset bsrc1 = bitset_create (nbits, b);
   bitset_copy (bsrc1, asrc1);
-  bitset bsrc2 = bitset_create (nbits, b);
+  const bitset bsrc2 = bitset_create (nbits, b);
   bitset_copy (bsrc2, asrc2);
-  bitset bsrc3 = bitset_create (nbits, b);
+  const bitset bsrc3 = bitset_create (nbits, b);
   bitset_copy (bsrc3, asrc3);
+
+  /* Destinations for each operation.  */
+  bitset adst = bitset_create (nbits, a);
   bitset bdst = bitset_create (nbits, b);
 
   /* not */
@@ -139,6 +143,89 @@ void compare (enum bitset_attr a, enum bitset_attr b)
   bitset_zero (bdst);
   assert_bitset_equal (adst, bdst);
 
+  /* first and last and FOR_EACH.
+
+     Exercise on random values (i == -1), but also on all the
+     single-bit values: it's easy to get the handling of the most
+     significant bit wrong.  */
+  for (int i = -1; i < nbits; ++i)
+    {
+      /* Work on bdst to exercise all the bitset types (adst is
+         BITSET_VARIABLE).  */
+      if (i >= 0)
+        {
+          bitset_zero (bdst);
+          bitset_set (bdst, i);
+        }
+      else
+        {
+          bitset_copy (bdst, bsrc0);
+          debug_bitset (bdst);
+          debug_bitset (bsrc0);
+        }
+      bitset_copy (adst, bdst);
+
+      /* first and last */
+      {
+        bitset_bindex first = bitset_first (adst);
+        ASSERT (first == bitset_first (bdst));
+
+        bitset_bindex last  = bitset_last (adst);
+        ASSERT (last == bitset_last (bdst));
+
+        if (i >= 0)
+          {
+            ASSERT (first == i);
+            ASSERT (last == i);
+          }
+
+        if (first != BITSET_BINDEX_MAX)
+          {
+            ASSERT (last != BITSET_BINDEX_MAX);
+            ASSERT (first <= last);
+            ASSERT (bitset_test (adst, first));
+            ASSERT (bitset_test (adst, last));
+            ASSERT (bitset_test (bdst, first));
+            ASSERT (bitset_test (bdst, last));
+          }
+        else
+          ASSERT (last == BITSET_BINDEX_MAX);
+      }
+
+
+      /* FOR_EACH.  */
+      {
+        bitset_iterator iter;
+        bitset_bindex j;
+        bitset_bindex first = bitset_first (bdst);
+        bitset_bindex last  = bitset_last (bdst);
+        bool seen_first = false;
+        bool seen_last = false;
+        BITSET_FOR_EACH (iter, bdst, j, 0)
+          {
+            ASSERT (first <= j && j <= last);
+            ASSERT (bitset_test (bdst, j));
+            if (j == first)
+              seen_first = true;
+            if (j == last)
+              seen_last = true;
+            if (0 <= i)
+              ASSERT (j == i);
+          }
+        if (first == BITSET_BINDEX_MAX)
+          {
+            ASSERT (!seen_first);
+            ASSERT (!seen_last);
+          }
+        else
+          {
+            ASSERT (seen_first);
+            ASSERT (seen_last);
+          }
+      }
+    }
+
+
   /* resize.
 
      ARRAY bitsets cannot be resized.  */