#include <check.h>

#include "bitset.h"

#define assert_bitset_is( map, val ) {\
	uint64_t *num = (uint64_t*) map->bits; \
	ck_assert_int_eq( val, *num ); \
}

START_TEST(test_bit_set)
{
    uint64_t num = 0;
    bitfield_p bits = (bitfield_p) & num;

#define TEST_BIT_SET(bit, newvalue) \
	bit_set(bits, (bit)); \
	fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue));

    TEST_BIT_SET(0, 1);
    TEST_BIT_SET(1, 3);
    TEST_BIT_SET(2, 7);
    TEST_BIT_SET(7, 0x87);
    TEST_BIT_SET(63, 0x8000000000000087);
}
END_TEST

START_TEST(test_bit_clear)
{
    uint64_t num = 0xffffffffffffffff;
    bitfield_p bits = (bitfield_p) & num;

#define TEST_BIT_CLEAR(bit, newvalue) \
	bit_clear(bits, (bit)); \
	fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue));

    TEST_BIT_CLEAR(0, 0xfffffffffffffffe);
    TEST_BIT_CLEAR(1, 0xfffffffffffffffc);
    TEST_BIT_CLEAR(2, 0xfffffffffffffff8);
    TEST_BIT_CLEAR(7, 0xffffffffffffff78);
    TEST_BIT_CLEAR(63, 0x7fffffffffffff78);
}
END_TEST

START_TEST(test_bit_tests)
{
    uint64_t num = 0x5555555555555555;
    bitfield_p bits = (bitfield_p) & num;

    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, 63, 0), "bit_has_value malfunction");
    fail_unless(bit_is_set(bits, 0), "bit_is_set malfunction");
    fail_unless(bit_is_clear(bits, 1), "bit_is_clear malfunction");
    fail_unless(bit_is_set(bits, 62), "bit_is_set malfunction");
    fail_unless(bit_is_clear(bits, 63), "bit_is_clear malfunction");
}
END_TEST

START_TEST(test_bit_ranges)
{
    bitfield_word_t buffer[BIT_WORDS_FOR_SIZE(4160)];
    uint64_t *longs = (uint64_t *) buffer;
    uint64_t i;

    memset(buffer, 0, 4160);

    for (i = 0; i < 64; i++) {
	bit_set_range(buffer, i * 64, i);
	fail_unless(longs[i] == (1ULL << i) - 1,
		    "longs[%ld] = %lx SHOULD BE %lx",
		    i, longs[i], (1ULL << i) - 1);

	fail_unless(longs[i + 1] == 0, "bit_set_range overshot at i=%d",
		    i);
    }

    for (i = 0; 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);
    }
}
END_TEST

START_TEST(test_bit_runs)
{
    bitfield_word_t buffer[BIT_WORDS_FOR_SIZE(256)];
    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
    };

    memset(buffer, 0, 256);

    for (i = 0; i < 20; i += 2) {
	ptr += runs[i];
	bit_set_range(buffer, ptr, runs[i + 1]);
	ptr += runs[i + 1];
    }

    ptr = 0;

    for (i = 0; i < 20; i += 1) {
	int run = bit_run_count(buffer, ptr, 2048 - ptr, NULL);
	fail_unless(run == runs[i],
		    "run %d should have been %d, was %d", i, runs[i], run);
	ptr += runs[i];
    }
}
END_TEST

START_TEST(test_bitset)
{
    struct bitset *map;
    uint64_t *num;

    map = bitset_alloc(6400, 100);
    num = (uint64_t *) map->bits;

    bitset_set_range(map, 0, 50);
    ck_assert_int_eq(1, *num);
    bitset_set_range(map, 99, 1);
    ck_assert_int_eq(1, *num);
    bitset_set_range(map, 100, 1);
    ck_assert_int_eq(3, *num);
    bitset_set_range(map, 0, 800);
    ck_assert_int_eq(255, *num);
    bitset_set_range(map, 1499, 2);
    ck_assert_int_eq(0xc0ff, *num);
    bitset_clear_range(map, 1499, 2);
    ck_assert_int_eq(255, *num);

    *num = 0;
    bitset_set_range(map, 1499, 2);
    bitset_clear_range(map, 1300, 200);
    ck_assert_int_eq(0x8000, *num);

    *num = 0;
    bitset_set_range(map, 0, 6400);
    ck_assert_int_eq(0xffffffffffffffff, *num);
    bitset_clear_range(map, 3200, 400);
    ck_assert_int_eq(0xfffffff0ffffffff, *num);
}
END_TEST

START_TEST(test_bitset_set)
{
    struct bitset *map;
    uint64_t run;

    map = bitset_alloc(64, 1);

    assert_bitset_is(map, 0x0000000000000000);
    bitset_set(map);
    assert_bitset_is(map, 0xffffffffffffffff);
    bitset_free(map);

    map = bitset_alloc(6400, 100);
    assert_bitset_is(map, 0x0000000000000000);
    bitset_set(map);
    assert_bitset_is(map, 0xffffffffffffffff);
    bitset_free(map);

    // Now do something large and representative
    map = bitset_alloc(53687091200, 4096);
    bitset_set(map);

    run = bitset_run_count(map, 0, 53687091200);
    ck_assert_int_eq(run, 53687091200);
    bitset_free(map);


}
END_TEST

START_TEST(test_bitset_clear)
{
    struct bitset *map;
    uint64_t *num;
    uint64_t run;

    map = bitset_alloc(64, 1);
    num = (uint64_t *) map->bits;

    ck_assert_int_eq(0x0000000000000000, *num);
    bitset_set(map);
    bitset_clear(map);
    ck_assert_int_eq(0x0000000000000000, *num);

    bitset_free(map);

    // Now do something large and representative
    map = bitset_alloc(53687091200, 4096);
    bitset_set(map);
    bitset_clear(map);
    run = bitset_run_count(map, 0, 53687091200);
    ck_assert_int_eq(run, 53687091200);
    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_set_range)
{
    struct bitset *map = bitset_alloc(64, 1);
    assert_bitset_is(map, 0x0000000000000000);

    bitset_set_range(map, 8, 8);
    assert_bitset_is(map, 0x000000000000ff00);

    bitset_clear(map);
    assert_bitset_is(map, 0x0000000000000000);
    bitset_set_range(map, 0, 0);
    assert_bitset_is(map, 0x0000000000000000);

    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_clear_range)
{
    struct bitset *map = bitset_alloc(64, 1);
    bitset_set(map);
    assert_bitset_is(map, 0xffffffffffffffff);

    bitset_clear_range(map, 8, 8);
    assert_bitset_is(map, 0xffffffffffff00ff);

    bitset_set(map);
    assert_bitset_is(map, 0xffffffffffffffff);
    bitset_clear_range(map, 0, 0);
    assert_bitset_is(map, 0xffffffffffffffff);

    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_run_count)
{
    struct bitset *map = bitset_alloc(64, 1);
    uint64_t run;

    assert_bitset_is(map, 0x0000000000000000);

    run = bitset_run_count(map, 0, 64);
    ck_assert_int_eq(64, run);

    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);

    bitset_free(map);

    map = bitset_alloc(6400, 100);
    assert_bitset_is(map, 0x0000000000000000);

    run = bitset_run_count(map, 0, 6400);
    ck_assert_int_eq(6400, run);

    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);
    bitset_free(map);

    // Now do something large and representative
    map = bitset_alloc(53687091200, 4096);
    bitset_set(map);
    run = bitset_run_count(map, 0, 53687091200);
    ck_assert_int_eq(run, 53687091200);

    bitset_free(map);

}
END_TEST

START_TEST(test_bitset_set_range_doesnt_push_to_stream)
{
    struct bitset *map = bitset_alloc(64, 1);
    bitset_set_range(map, 0, 64);
    ck_assert_int_eq(0, bitset_stream_size(map));
    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_clear_range_doesnt_push_to_stream)
{
    struct bitset *map = bitset_alloc(64, 1);
    bitset_clear_range(map, 0, 64);
    ck_assert_int_eq(0, bitset_stream_size(map));
    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_enable_stream)
{
    struct bitset *map = bitset_alloc(64, 1);
    struct bitset_stream_entry result;
    memset(&result, 0, sizeof(result));

    bitset_enable_stream(map);

    ck_assert_int_eq(1, map->stream_enabled);

    bitset_stream_dequeue(map, &result);

    ck_assert_int_eq(BITSET_STREAM_ON, result.event);
    ck_assert_int_eq(0, result.from);
    ck_assert_int_eq(64, result.len);

    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_disable_stream)
{
    struct bitset *map = bitset_alloc(64, 1);
    struct bitset_stream_entry result;
    memset(&result, 0, sizeof(result));

    bitset_enable_stream(map);
    bitset_disable_stream(map);

    ck_assert_int_eq(0, map->stream_enabled);
    ck_assert_int_eq(2, bitset_stream_size(map));

    bitset_stream_dequeue(map, NULL);	// ON
    bitset_stream_dequeue(map, &result);	// OFF

    ck_assert_int_eq(BITSET_STREAM_OFF, result.event);
    ck_assert_int_eq(0, result.from);
    ck_assert_int_eq(64, result.len);

    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_stream_with_set_range)
{
    struct bitset *map = bitset_alloc(64, 1);
    struct bitset_stream_entry result;
    memset(&result, 0, sizeof(result));

    bitset_enable_stream(map);
    bitset_set_range(map, 0, 32);

    ck_assert_int_eq(2, bitset_stream_size(map));

    bitset_stream_dequeue(map, NULL);	// ON
    bitset_stream_dequeue(map, &result);	// SET

    ck_assert_int_eq(BITSET_STREAM_SET, result.event);
    ck_assert_int_eq(0, result.from);
    ck_assert_int_eq(32, result.len);

    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_stream_with_clear_range)
{
    struct bitset *map = bitset_alloc(64, 1);
    struct bitset_stream_entry result;
    memset(&result, 0, sizeof(result));

    bitset_enable_stream(map);
    bitset_clear_range(map, 0, 32);
    ck_assert_int_eq(2, bitset_stream_size(map));

    bitset_stream_dequeue(map, NULL);	// ON
    bitset_stream_dequeue(map, &result);	// UNSET

    ck_assert_int_eq(BITSET_STREAM_UNSET, result.event);
    ck_assert_int_eq(0, result.from);
    ck_assert_int_eq(32, result.len);

    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_stream_size)
{
    struct bitset *map = bitset_alloc(64, 1);
    bitset_enable_stream(map);
    bitset_set_range(map, 0, 32);
    bitset_set_range(map, 16, 32);
    bitset_set_range(map, 7, 16);

    bitset_clear_range(map, 0, 32);
    bitset_clear_range(map, 16, 32);
    bitset_clear_range(map, 48, 16);
    bitset_disable_stream(map);

    ck_assert_int_eq(8, bitset_stream_size(map));

    bitset_free(map);
}
END_TEST

START_TEST(test_bitset_stream_queued_bytes)
{
    struct bitset *map = bitset_alloc(64, 1);
    bitset_enable_stream(map);
    bitset_set_range(map, 0, 32);
    bitset_set_range(map, 16, 32);
    bitset_set_range(map, 7, 16);

    bitset_clear_range(map, 0, 32);
    bitset_clear_range(map, 16, 32);
    bitset_clear_range(map, 48, 16);
    bitset_clear_range(map, 0, 2);
    bitset_disable_stream(map);

    ck_assert_int_eq(64,
		     bitset_stream_queued_bytes(map, BITSET_STREAM_ON));
    ck_assert_int_eq(80,
		     bitset_stream_queued_bytes(map, BITSET_STREAM_SET));
    ck_assert_int_eq(82,
		     bitset_stream_queued_bytes(map, BITSET_STREAM_UNSET));
    ck_assert_int_eq(64,
		     bitset_stream_queued_bytes(map, BITSET_STREAM_OFF));
    bitset_free(map);
}
END_TEST

Suite * bitset_suite(void)
{
    Suite *s = suite_create("bitset");

    TCase *tc_bit = tcase_create("bit");
    tcase_add_test(tc_bit, test_bit_set);
    tcase_add_test(tc_bit, test_bit_clear);
    tcase_add_test(tc_bit, test_bit_tests);
    tcase_add_test(tc_bit, test_bit_ranges);
    tcase_add_test(tc_bit, test_bit_runs);
    suite_add_tcase(s, tc_bit);

    TCase *tc_bitset = tcase_create("bitset");
    tcase_add_test(tc_bitset, test_bitset);
    tcase_add_test(tc_bitset, test_bitset_set);
    tcase_add_test(tc_bitset, test_bitset_clear);
    tcase_add_test(tc_bitset, test_bitset_run_count);
    tcase_add_test(tc_bitset, test_bitset_set_range);
    tcase_add_test(tc_bitset, test_bitset_clear_range);
    tcase_add_test(tc_bitset, test_bitset_set_range_doesnt_push_to_stream);
    tcase_add_test(tc_bitset,
		   test_bitset_clear_range_doesnt_push_to_stream);
    suite_add_tcase(s, tc_bitset);


    TCase *tc_bitset_stream = tcase_create("bitset_stream");
    tcase_add_test(tc_bitset_stream, test_bitset_enable_stream);
    tcase_add_test(tc_bitset_stream, test_bitset_disable_stream);
    tcase_add_test(tc_bitset_stream, test_bitset_stream_with_set_range);
    tcase_add_test(tc_bitset_stream, test_bitset_stream_with_clear_range);
    tcase_add_test(tc_bitset_stream, test_bitset_stream_size);
    tcase_add_test(tc_bitset_stream, test_bitset_stream_queued_bytes);
    suite_add_tcase(s, tc_bitset_stream);

    return s;
}

int main(void)
{
    int number_failed;
    Suite *s = bitset_suite();
    SRunner *sr = srunner_create(s);
    srunner_run_all(sr, CK_NORMAL);
    number_failed = srunner_ntests_failed(sr);
    srunner_free(sr);
    return (number_failed == 0) ? 0 : 1;
}