* tests/test-bitset.c (compare): Also check count.
Deal only with random values, move the one-bit tests to...
(check_one_bit): this new function.
(check_attributes): Call it.
---
ChangeLog | 8 +++
tests/test-bitset.c | 165 +++++++++++++++++++++++---------------------
2 files changed, 93 insertions(+), 80 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 82b67f481..ad9c9e153 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2020-11-17 Akim Demaille <a...@lrde.epita.fr>
+
+ bitset: strengthen tests
+ * tests/test-bitset.c (compare): Also check count.
+ Deal only with random values, move the one-bit tests to...
+ (check_one_bit): this new function.
+ (check_attributes): Call it.
+
2020-11-17 Akim Demaille <a...@lrde.epita.fr>
bitset: test: run deterministic tests on several bitset sizes
diff --git a/tests/test-bitset.c b/tests/test-bitset.c
index 9c79d04ff..5068ae782 100644
--- a/tests/test-bitset.c
+++ b/tests/test-bitset.c
@@ -72,6 +72,9 @@ void compare (enum bitset_attr a, enum bitset_attr b)
bitset adst = bitset_create (nbits, a);
bitset bdst = bitset_create (nbits, b);
+ /* count */
+ ASSERT (bitset_count (asrc0) == bitset_count (bsrc0));
+
/* not */
bitset_not (adst, asrc0);
bitset_not (bdst, bsrc0);
@@ -143,88 +146,57 @@ 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 */
+ /* first and last and FOR_EACH. */
+ /* Work on bdst to exercise all the bitset types (adst is
+ BITSET_VARIABLE). */
+ bitset_copy (bdst, bsrc0);
+ debug_bitset (bdst);
+ debug_bitset (bsrc0);
+ bitset_copy (adst, bdst);
+
+ /* count. */
+ ASSERT (bitset_count (adst) == bitset_count (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));
+
+ ASSERT (first <= last);
+ }
+
+
+ /* 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)
{
- 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);
+ ASSERT (first <= j && j <= last);
+ ASSERT (bitset_test (bdst, j));
+ if (j == first)
+ seen_first = true;
+ if (j == last)
+ seen_last = true;
}
-
-
- /* FOR_EACH. */
+ if (first == BITSET_BINDEX_MAX)
{
- 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);
- }
+ ASSERT (!seen_first);
+ ASSERT (!seen_last);
}
- }
-
+ else
+ {
+ ASSERT (seen_first);
+ ASSERT (seen_last);
+ }
+ }
/* resize.
@@ -252,11 +224,39 @@ void compare (enum bitset_attr a, enum bitset_attr b)
}
+/* Exercise on a single-bit values: it's easy to get the handling of
+ the most significant bit wrong. */
+
+static void
+check_one_bit (bitset bs, int bitno)
+{
+ bitset_zero (bs);
+ bitset_set (bs, bitno);
+
+ /* count. */
+ ASSERT (bitset_count (bs) == 1);
+
+ /* test. */
+ ASSERT (bitset_test (bs, bitno));
+
+ /* first and last */
+ ASSERT (bitset_first (bs) == bitno);
+ ASSERT (bitset_last (bs) == bitno);
+
+ /* FOR_EACH. */
+ {
+ bitset_iterator iter;
+ bitset_bindex i;
+ BITSET_FOR_EACH (iter, bs, i, 0)
+ ASSERT (i == bitno);
+ }
+}
+
/* Check various operations against expected values for a bitset
having attributes ATTR. */
-static
-void check_attributes (enum bitset_attr attr, int nbits)
+static void
+check_attributes (enum bitset_attr attr, int nbits)
{
bitset bs0 = bitset_create (nbits, attr);
ASSERT (bitset_size (bs0) == nbits);
@@ -287,6 +287,11 @@ void check_attributes (enum bitset_attr attr, int nbits)
bitset_or (bs, bs1, bs2);
ASSERT (bitset_count (bs) == 6);
+ /* Exercise on all the single-bit values: it's easy to get the
+ handling of the most significant bit wrong. */
+ for (int bitno = 0; bitno < nbits; ++bitno)
+ check_one_bit (bs, bitno);
+
bitset_free (bs);
bitset_free (bs2);
bitset_free (bs1);
--
2.29.2
