Mercurial > dedupe

diff BurnBitArray.cpp @ 76:8136057988bc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixes to automatic report generating system. A lot of new unittests.
author Tom Fredrik Blenning Klaussen <bfg@bfgconsult.no>
date Sat, 16 Feb 2013 15:32:20 +0100
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/BurnBitArray.cpp	Sat Feb 16 15:32:20 2013 +0100
@@ -0,0 +1,198 @@
+#include "TestFramework.hpp"
+
+#include "BitDecoder.hpp"
+
+#define BURN_MAX 100000
+#define BURN for(size_t burn_counter = BURN_MAX; burn_counter > 0; --burn_counter)
+
+BOOST_AUTO_TEST_CASE( TestBasic )
+{
+  BURN {
+    BitArray tbits(16, true);
+    BitArray fbits(16, false);
+    for (uint i = 0; i < tbits.size(); ++i) {
+      BOOST_REQUIRE_EQUAL(tbits.testBit(i), true);
+      BOOST_REQUIRE_EQUAL(fbits.testBit(i), false);
+    }
+  }
+
+  BURN {
+    BitArray tbits(9, true);
+    BitArray fbits(9, false);
+    for (uint i = 0; i < tbits.size(); ++i) {
+      BOOST_REQUIRE_EQUAL(tbits.testBit(i), true);
+      BOOST_REQUIRE_EQUAL(fbits.testBit(i), false);
+    }
+  }
+
+  BURN {
+    BitArray tbits(13, true);
+    BitArray fbits(13, false);
+    for (uint i = 0; i < tbits.size(); ++i) {
+      BOOST_REQUIRE_EQUAL(tbits.testBit(i), true);
+      BOOST_REQUIRE_EQUAL(fbits.testBit(i), false);
+    }
+  }
+
+}
+
+
+BOOST_AUTO_TEST_CASE( TestSetBit )
+{
+
+  BURN {
+    for (uint i = 0; i < 13; ++i) {
+      BitArray tbits(13, true);
+      BitArray fbits(13, false);
+      tbits.setBit(i, false);
+      fbits.setBit(i, true);
+      for (uint j = 0; j < tbits.size(); ++j) {
+	BOOST_REQUIRE_EQUAL(tbits.testBit(j), i != j);
+	BOOST_REQUIRE_EQUAL(fbits.testBit(j), i == j);
+      }
+    }
+  }
+
+}
+
+BOOST_AUTO_TEST_CASE( TestSetBit2 )
+{
+  BURN {
+  BitArray tbits(8, true);
+  BitArray fbits(8, false);
+  BOOST_REQUIRE_EQUAL(tbits, BitDecoder::bitsFromString("11111111"));
+  BOOST_REQUIRE_EQUAL(fbits, BitDecoder::bitsFromString("00000000"));
+
+  tbits.setBit(0, false);
+  fbits.setBit(0, false);
+  BOOST_REQUIRE_EQUAL(tbits, BitDecoder::bitsFromString("01111111"));
+  BOOST_REQUIRE_EQUAL(fbits, BitDecoder::bitsFromString("00000000"));
+
+  tbits.setBit(1, true);
+  fbits.setBit(1, true);
+  BOOST_REQUIRE_EQUAL(tbits, BitDecoder::bitsFromString("01111111"));
+  BOOST_REQUIRE_EQUAL(fbits, BitDecoder::bitsFromString("01000000"));
+
+  tbits.setBit(2, false);
+  fbits.setBit(2, false);
+  BOOST_REQUIRE_EQUAL(tbits, BitDecoder::bitsFromString("01011111"));
+  BOOST_REQUIRE_EQUAL(fbits, BitDecoder::bitsFromString("01000000"));
+
+  tbits.setBit(3, false);
+  fbits.setBit(3, false);
+  BOOST_REQUIRE_EQUAL(tbits, BitDecoder::bitsFromString("01001111"));
+  BOOST_REQUIRE_EQUAL(fbits, BitDecoder::bitsFromString("01000000"));
+
+  tbits.setBit(4, false);
+  fbits.setBit(4, false);
+  BOOST_REQUIRE_EQUAL(tbits, BitDecoder::bitsFromString("01000111"));
+  BOOST_REQUIRE_EQUAL(fbits, BitDecoder::bitsFromString("01000000"));
+
+  tbits.setBit(5, true);
+  fbits.setBit(5, true);
+  BOOST_REQUIRE_EQUAL(tbits, BitDecoder::bitsFromString("01000111"));
+  BOOST_REQUIRE_EQUAL(fbits, BitDecoder::bitsFromString("01000100"));
+
+  tbits.setBit(6, true);
+  fbits.setBit(6, true);
+  BOOST_REQUIRE_EQUAL(tbits, BitDecoder::bitsFromString("01000111"));
+  BOOST_REQUIRE_EQUAL(fbits, BitDecoder::bitsFromString("01000110"));
+
+  tbits.setBit(7, false);
+  fbits.setBit(7, false);
+  BOOST_REQUIRE_EQUAL(tbits, BitDecoder::bitsFromString("01000110"));
+  BOOST_REQUIRE_EQUAL(fbits, BitDecoder::bitsFromString("01000110"));
+
+  }
+}
+
+BOOST_AUTO_TEST_CASE( TestPaddedChar )
+{
+  BURN {
+  BitArray bits = BitDecoder::bitsFromString("0100011011");
+
+  BOOST_REQUIRE_EQUAL(bits.size(), 10u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(0), 70);
+
+  bits = BitDecoder::bitsFromString("0000000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 10u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(2), 1u);
+
+  bits = BitDecoder::bitsFromString("0000000011");
+  BOOST_REQUIRE_EQUAL(bits.size(), 10u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(2), 3u);
+
+  bits = BitDecoder::bitsFromString("000000000011");
+  BOOST_REQUIRE_EQUAL(bits.size(), 12u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(4), 3u);
+
+  bits = BitDecoder::bitsFromString("0000000000011");
+  BOOST_REQUIRE_EQUAL(bits.size(), 13u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(5), 3u);
+
+  bits = BitDecoder::bitsFromString("00000000000011");
+  BOOST_REQUIRE_EQUAL(bits.size(), 14u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(6), 3u);
+
+  bits = BitDecoder::bitsFromString("000000000000011");
+  BOOST_REQUIRE_EQUAL(bits.size(), 15u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(7), 3u);
+
+  bits = BitDecoder::bitsFromString("10000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 8u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(0), 129u);
+
+  bits = BitDecoder::bitsFromString("010000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 9u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(1), 129u);
+
+  bits = BitDecoder::bitsFromString("0010000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 10u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(2), 129u);
+
+  bits = BitDecoder::bitsFromString("00010000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 11u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(3), 129u);
+
+  bits = BitDecoder::bitsFromString("000010000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 12u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(4), 129u);
+
+  bits = BitDecoder::bitsFromString("0000010000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 13u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(5), 129u);
+
+  bits = BitDecoder::bitsFromString("00000010000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 14u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(6), 129u);
+
+  bits = BitDecoder::bitsFromString("000000010000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 15u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(7), 129u);
+
+
+  bits = BitDecoder::bitsFromString("0100011011");
+  BOOST_REQUIRE_EQUAL(bits.size(), 10u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(2), 27u);
+  }
+}
+
+BOOST_AUTO_TEST_CASE( TestCorrectChar )
+{
+  BURN {
+  BitArray bits = BitDecoder::bitsFromString("00000001");
+  BOOST_REQUIRE_EQUAL(bits.size(), 8u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(0), 1u);
+
+  bits = BitDecoder::bitsFromString("00000011");
+  BOOST_REQUIRE_EQUAL(bits.size(), 8u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(0), 3u);
+
+  bits = BitDecoder::bitsFromString("10000000");
+  BOOST_REQUIRE_EQUAL(bits.size(), 8u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(0), 128u);
+  bits = BitDecoder::bitsFromString("11000000");
+  BOOST_REQUIRE_EQUAL(bits.size(), 8u);
+  BOOST_REQUIRE_EQUAL(bits.getPaddedChar(0), 192u);
+  }
+}