New test for the TBits class by Filip Pizlo <pizlo@purdue.edu>

git-svn-id: http://root.cern.ch/svn/root/trunk@8009 27541ba8-7e3a-0410-8455-c3a389f83636

test/testbits.cxx

+/*
+ * testbits.cxx -- unit tests for the new functionality in the TBits class
+ * by Filip Pizlo, 2004
+ */
+
+#include "TROOT.h"
+#include "TBits.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+static const char *current_test;
+static unsigned test_count;
+
+#define A(exp) do {\
+    if (!(exp)) {\
+        fprintf(stderr," FAILURE!\n\nIn %s:\n\n",current_test);\
+        fprintf(stderr,"Assertion (%s) failed at %s:%d.\n\n",\
+                       #exp,__FILE__,__LINE__);\
+        exit(1);\
+    }\
+} while (0)
+
+#define DO_TEST(exp) do {\
+    current_test=#exp;\
+    fprintf(stderr,".");\
+    fflush(stderr);\
+    exp;\
+    ++test_count;\
+} while (0)
+
+static void test_set_bit() {
+    TBits b;
+    b.SetBitNumber(0);
+    A(b.TestBitNumber(0));
+}
+
+static const Char_t char_bits[] = {
+    0,
+    1,
+    3,
+    7,
+    15,
+    31,
+    63,
+    127
+};
+
+static const Short_t short_bits[] = {
+    0 + 1 * 256,
+    3 + 7 * 256,
+    15 + 31 * 256,
+    63 + 127 * 256
+};
+
+static const Int_t int_bits[] = {
+    0 + 1 * 256 + 3 * 65536 + 7 * 16777216,
+    15 + 31 * 256 + 63 * 65536 + 127 * 16777216
+};
+
+static void set_bits_by_char(TBits &bits,
+                             UInt_t nbits) {
+    bits.Set(nbits, char_bits);
+}
+
+static void assert_bits_by_char(const TBits &bits,
+                                UInt_t nbits) {
+    Char_t buf[8];
+    memset(buf,0,sizeof(buf));
+    bits.Get(buf);
+    for (UInt_t i=0;i<nbits;++i) {
+        A((buf[i>>3]&(1<<(i&7))) == (char_bits[i>>3]&(1<<(i&7))));
+    }
+}
+
+static void set_bits_by_short(TBits &bits,
+                              UInt_t nbits) {
+    bits.Set(nbits, short_bits);
+}
+
+static void assert_bits_by_short(const TBits &bits,
+                                 UInt_t nbits) {
+    Short_t buf[4];
+    memset(buf,0,sizeof(buf));
+    bits.Get(buf);
+    for (UInt_t i=0;i<nbits;++i) {
+        A((buf[i>>4]&(1<<(i&15))) == (short_bits[i>>4]&(1<<(i&15))));
+    }
+}
+
+static void set_bits_by_int(TBits &bits,
+                            UInt_t nbits) {
+    bits.Set(nbits, int_bits);
+}
+
+static void assert_bits_by_int(const TBits &bits,
+                               UInt_t nbits) {
+    Int_t buf[2];
+    memset(buf,0,sizeof(buf));
+    bits.Get(buf);
+    for (UInt_t i=0;i<nbits;++i) {
+        A((buf[i>>5]&(1<<(i&31))) == (int_bits[i>>5]&(1<<(i&31))));
+    }
+}
+
+static void set_bits(TBits &bits,
+                     UInt_t nbits) {
+    for (UInt_t i=0;
+         i<8;
+         ++i) {
+        for (UInt_t j=i*8;
+             j<i*8+i && j<nbits;
+             ++j) {
+            bits.SetBitNumber(j);
+        }
+        for (UInt_t j=i*8+i;
+             j<i*8+8 && j<nbits;
+             ++j) {
+            bits.ResetBitNumber(j);
+        }
+    }
+}
+
+static void assert_bits(const TBits &bits,
+                        UInt_t nbits) {
+    for (UInt_t i=0;
+         i<8;
+         ++i) {
+        for (UInt_t j=i*8;
+             j<i*8+i && j<nbits;
+             ++j) {
+            A(bits.TestBitNumber(j));
+        }
+        for (UInt_t j=i*8+i;
+             j<i*8+8 && j<nbits;
+             ++j) {
+            A(!bits.TestBitNumber(j));
+        }
+    }
+}
+
+static void test_set_from_char(UInt_t nbits) {
+    TBits b;
+    set_bits_by_char(b,nbits);
+    assert_bits(b,nbits);
+}
+
+static void test_set_from_short(UInt_t nbits) {
+    TBits b;
+    set_bits_by_short(b,nbits);
+    assert_bits(b,nbits);
+}
+
+static void test_set_from_int(UInt_t nbits) {
+    TBits b;
+    set_bits_by_int(b,nbits);
+    assert_bits(b,nbits);
+}
+
+static void test_get_to_char(UInt_t nbits) {
+    TBits b;
+    set_bits(b,nbits);
+    assert_bits_by_char(b,nbits);
+}
+
+static void test_get_to_short(UInt_t nbits) {
+    TBits b;
+    set_bits(b,nbits);
+    assert_bits_by_short(b,nbits);
+}
+
+static void test_get_to_int(UInt_t nbits) {
+    TBits b;
+    set_bits(b,nbits);
+    assert_bits_by_int(b,nbits);
+}
+
+// don't have access to a 64-bit machine at the moment so long test would be
+// pointless...
+
+int main(int c,char **v) {
+    TROOT app("bits_test", "Tests the TBits class's new functionality");
+    
+    fprintf(stderr,"%s: ",v[0]);
+    
+    DO_TEST(test_set_bit());
+    
+    DO_TEST(test_set_from_char(64));
+    DO_TEST(test_set_from_char(64-1));
+    DO_TEST(test_set_from_char(64-7));
+    DO_TEST(test_set_from_char(64-8));
+    
+    DO_TEST(test_set_from_short(64));
+    DO_TEST(test_set_from_short(64-1));
+    DO_TEST(test_set_from_short(64-7));
+    DO_TEST(test_set_from_short(64-8));
+    DO_TEST(test_set_from_short(64-15));
+    DO_TEST(test_set_from_short(64-16));
+    
+    DO_TEST(test_set_from_int(64));
+    DO_TEST(test_set_from_int(64-1));
+    DO_TEST(test_set_from_int(64-7));
+    DO_TEST(test_set_from_int(64-8));
+    DO_TEST(test_set_from_int(64-15));
+    DO_TEST(test_set_from_int(64-16));
+    DO_TEST(test_set_from_int(64-23));
+    DO_TEST(test_set_from_int(64-24));
+    DO_TEST(test_set_from_int(64-31));
+    DO_TEST(test_set_from_int(64-32));
+    
+    DO_TEST(test_get_to_char(64));
+    DO_TEST(test_get_to_char(64-1));
+    DO_TEST(test_get_to_char(64-7));
+    DO_TEST(test_get_to_char(64-8));
+    
+    DO_TEST(test_get_to_short(64));
+    DO_TEST(test_get_to_short(64-1));
+    DO_TEST(test_get_to_short(64-7));
+    DO_TEST(test_get_to_short(64-8));
+    DO_TEST(test_get_to_short(64-15));
+    DO_TEST(test_get_to_short(64-16));
+    
+    DO_TEST(test_get_to_int(64));
+    DO_TEST(test_get_to_int(64-1));
+    DO_TEST(test_get_to_int(64-7));
+    DO_TEST(test_get_to_int(64-8));
+    DO_TEST(test_get_to_int(64-15));
+    DO_TEST(test_get_to_int(64-16));
+    DO_TEST(test_get_to_int(64-23));
+    DO_TEST(test_get_to_int(64-24));
+    DO_TEST(test_get_to_int(64-31));
+    DO_TEST(test_get_to_int(64-32));
+    
+    fprintf(stderr," OK! (%d tests)\n",test_count);
+    
+    return 0;
+}
+
+