bytemark/flexnbd-c
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

test: Add some tests for bitset_run_count

Browse Source
This commit is contained in:
nick
2013-07-23 17:13:40 +01:00
parent 5c5636b053
commit 1b0fe24529
1 changed files with 75 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
tests/unit/check_bitset.c
View File

@@ -2,15 +2,20 @@
#include "bitset.h" #include "bitset.h"
#define assert_bitset_is( map, val ) { \
uint64_t *num = map->bits; \
ck_assert_int_eq( val, *num ); \
}
START_TEST(test_bit_set) START_TEST(test_bit_set)
{ {
uint64_t num = 0; uint64_t num = 0;
char *bits = (char*) # char *bits = (char*) #
#define TEST_BIT_SET(bit, newvalue) \ #define TEST_BIT_SET(bit, newvalue) \
bit_set(bits, (bit)); \ bit_set(bits, (bit)); \
fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue)); fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue));
TEST_BIT_SET(0, 1); TEST_BIT_SET(0, 1);
TEST_BIT_SET(1, 3); TEST_BIT_SET(1, 3);
TEST_BIT_SET(2, 7); TEST_BIT_SET(2, 7);
@@ -23,11 +28,11 @@ START_TEST(test_bit_clear)
{ {
uint64_t num = 0xffffffffffffffff; uint64_t num = 0xffffffffffffffff;
char *bits = (char*) # char *bits = (char*) #
#define TEST_BIT_CLEAR(bit, newvalue) \ #define TEST_BIT_CLEAR(bit, newvalue) \
bit_clear(bits, (bit)); \ bit_clear(bits, (bit)); \
fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue)); fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue));
TEST_BIT_CLEAR(0, 0xfffffffffffffffe); TEST_BIT_CLEAR(0, 0xfffffffffffffffe);
TEST_BIT_CLEAR(1, 0xfffffffffffffffc); TEST_BIT_CLEAR(1, 0xfffffffffffffffc);
TEST_BIT_CLEAR(2, 0xfffffffffffffff8); TEST_BIT_CLEAR(2, 0xfffffffffffffff8);
@@ -40,7 +45,7 @@ START_TEST(test_bit_tests)
{ {
uint64_t num = 0x5555555555555555; uint64_t num = 0x5555555555555555;
char *bits = (char*) # char *bits = (char*) #
fail_unless(bit_has_value(bits, 0, 1), "bit_has_value malfunction"); fail_unless(bit_has_value(bits, 0, 1), "bit_has_value malfunction");
fail_unless(bit_has_value(bits, 1, 0), "bit_has_value malfunction"); fail_unless(bit_has_value(bits, 1, 0), "bit_has_value malfunction");
fail_unless(bit_has_value(bits, 63, 0), "bit_has_value malfunction"); fail_unless(bit_has_value(bits, 63, 0), "bit_has_value malfunction");
@@ -56,9 +61,9 @@ START_TEST(test_bit_ranges)
char buffer[4160]; char buffer[4160];
uint64_t *longs = (unsigned long*) buffer; uint64_t *longs = (unsigned long*) buffer;
uint64_t i; uint64_t i;
memset(buffer, 0, 4160); memset(buffer, 0, 4160);
for (i=0; i<64; i++) { for (i=0; i<64; i++) {
bit_set_range(buffer, i*64, i); bit_set_range(buffer, i*64, i);
fail_unless( fail_unless(
@@ -66,10 +71,10 @@ START_TEST(test_bit_ranges)
"longs[%ld] = %lx SHOULD BE %lx", "longs[%ld] = %lx SHOULD BE %lx",
i, longs[i], (1L<<i)-1 i, longs[i], (1L<<i)-1
); );
fail_unless(longs[i+1] == 0, "bit_set_range overshot at i=%d", i); fail_unless(longs[i+1] == 0, "bit_set_range overshot at i=%d", i);
} }
for (i=0; i<64; i++) { for (i=0; i<64; i++) {
bit_clear_range(buffer, i*64, i); bit_clear_range(buffer, i*64, i);
fail_unless(longs[i] == 0, "bit_clear_range didn't work at i=%d", i); fail_unless(longs[i] == 0, "bit_clear_range didn't work at i=%d", i);
@@ -83,17 +88,17 @@ START_TEST(test_bit_runs)
int i, ptr=0, runs[] = { int i, ptr=0, runs[] = {
56,97,22,12,83,1,45,80,85,51,64,40,63,67,75,64,94,81,79,62 56,97,22,12,83,1,45,80,85,51,64,40,63,67,75,64,94,81,79,62
}; };
memset(buffer,0,256); memset(buffer,0,256);
for (i=0; i < 20; i += 2) { for (i=0; i < 20; i += 2) {
ptr += runs[i]; ptr += runs[i];
bit_set_range(buffer, ptr, runs[i+1]); bit_set_range(buffer, ptr, runs[i+1]);
ptr += runs[i+1]; ptr += runs[i+1];
} }
ptr = 0; ptr = 0;
for (i=0; i < 20; i += 1) { for (i=0; i < 20; i += 1) {
int run = bit_run_count(buffer, ptr, 2048-ptr); int run = bit_run_count(buffer, ptr, 2048-ptr);
fail_unless( fail_unless(
@@ -110,10 +115,10 @@ START_TEST(test_bitset)
{ {
struct bitset_mapping* map; struct bitset_mapping* map;
uint64_t *num; uint64_t *num;
map = bitset_alloc(6400, 100); map = bitset_alloc(6400, 100);
num = (uint64_t*) map->bits; num = (uint64_t*) map->bits;
bitset_set_range(map,0,50); bitset_set_range(map,0,50);
ck_assert_int_eq(1, *num); ck_assert_int_eq(1, *num);
bitset_set_range(map,99,1); bitset_set_range(map,99,1);
@@ -126,12 +131,12 @@ START_TEST(test_bitset)
ck_assert_int_eq(0xc0ff, *num); ck_assert_int_eq(0xc0ff, *num);
bitset_clear_range(map,1499,2); bitset_clear_range(map,1499,2);
ck_assert_int_eq(255, *num); ck_assert_int_eq(255, *num);
*num = 0; *num = 0;
bitset_set_range(map, 1499, 2); bitset_set_range(map, 1499, 2);
bitset_clear_range(map, 1300, 200); bitset_clear_range(map, 1300, 200);
ck_assert_int_eq(0x8000, *num); ck_assert_int_eq(0x8000, *num);
*num = 0; *num = 0;
bitset_set_range(map, 0, 6400); bitset_set_range(map, 0, 6400);
ck_assert_int_eq(0xffffffffffffffff, *num); ck_assert_int_eq(0xffffffffffffffff, *num);
@@ -145,7 +150,7 @@ START_TEST( test_bitset_set )
{ {
struct bitset_mapping* map; struct bitset_mapping* map;
uint64_t *num; uint64_t *num;
map = bitset_alloc(64, 1); map = bitset_alloc(64, 1);
num = (uint64_t*) map->bits; num = (uint64_t*) map->bits;
@@ -160,7 +165,7 @@ START_TEST( test_bitset_clear )
{ {
struct bitset_mapping* map; struct bitset_mapping* map;
uint64_t *num; uint64_t *num;
map = bitset_alloc(64, 1); map = bitset_alloc(64, 1);
num = (uint64_t*) map->bits; num = (uint64_t*) map->bits;
@@ -171,6 +176,55 @@ START_TEST( test_bitset_clear )
} }
END_TEST END_TEST
START_TEST( test_bitset_run_count )
{
struct bitset_mapping* map = bitset_alloc( 64, 1 );
uint64_t run;
assert_bitset_is( map, 0x0000000000000000 );
bitset_set_range( map, 0, 32 );
assert_bitset_is( map, 0x00000000ffffffff );
run = bitset_run_count( map, 0, 64 );
ck_assert_int_eq( 32, run );
run = bitset_run_count( map, 0, 16 );
ck_assert_int_eq( 16, run );
run = bitset_run_count( map, 16, 64 );
ck_assert_int_eq( 16, run );
run = bitset_run_count( map, 31, 64 );
ck_assert_int_eq( 1, run );
run = bitset_run_count( map, 32, 64 );
ck_assert_int_eq( 32, run );
run = bitset_run_count( map, 32, 32 );
ck_assert_int_eq( 32, run );
run = bitset_run_count( map, 32, 16 );
ck_assert_int_eq( 16, run );
free( map );
map = bitset_alloc( 6400, 100 );
bitset_set_range( map, 0, 3200 );
run = bitset_run_count( map, 0, 6400 );
ck_assert_int_eq( 3200, run );
run = bitset_run_count( map, 1, 6400 );
ck_assert_int_eq( 3199, run );
run = bitset_run_count( map, 3200, 6400 );
ck_assert_int_eq( 3200, run );
run = bitset_run_count( map, 6500, 6400 );
ck_assert_int_eq( 0, run );
}
END_TEST
Suite* bitset_suite(void) Suite* bitset_suite(void)
{ {
@@ -185,9 +239,10 @@ Suite* bitset_suite(void)
tcase_add_test(tc_bitset, test_bitset); tcase_add_test(tc_bitset, test_bitset);
tcase_add_test(tc_bitset, test_bitset_set); tcase_add_test(tc_bitset, test_bitset_set);
tcase_add_test(tc_bitset, test_bitset_clear); tcase_add_test(tc_bitset, test_bitset_clear);
tcase_add_test(tc_bitset, test_bitset_run_count);
suite_add_tcase(s, tc_bit); suite_add_tcase(s, tc_bit);
suite_add_tcase(s, tc_bitset); suite_add_tcase(s, tc_bitset);
return s; return s;
} }