#include "SizedBuffer.h"

#undef NDBEUG
#include <assert.h>
#define NDEBUG
#include <stdio.h>
#include <string.h>
#include <limits.h>


void test_sb_check(void) {
        SizedBuf t = { .size = 0 };
        assert(sb_check(t, 0) == 0);
        assert(sb_check(t, 1) != 0);
        assert(sb_check(t, SIZE_MAX) != 0);

        t.size = 100;
        assert(sb_check(t, 99) == 0);
        assert(sb_check(t, 100) == 0);
        assert(sb_check(t, 101) != 0);
        assert(sb_check(t, SIZE_MAX) != 0);

        t.size = SIZE_MAX;
        assert(sb_check(t, 0) == 0);
        assert(sb_check(t, 1) == 0);
        assert(sb_check(t, SIZE_MAX) == 0);
}

void test_sb_update(void) {
        SizedBuf t;

        t = (SizedBuf){ .data = 0, .size = 0 };
        sb_update(&t, 0);
        assert(t.data == 0 && t.size == 0);

        t.size = 100;
        sb_update(&t, 25);
        assert(t.data == (void *)25 && t.size == 75);

        sb_update(&t, 75);
        assert(t.data == (void *)100 && t.size == 0);
}

void test_sb_copyin(void) {
#define TEST_SIZE 128
        char buf[TEST_SIZE] = { 0 };
        SizedBuf sb = { .data = buf, .size = TEST_SIZE };

        char test_buf[TEST_SIZE] = { 0 };
        memset(test_buf, 0xff, TEST_SIZE);
        
        int ret = 0;

        assert(sb_copyin(&sb, NULL, SIZE_MAX) != 0);
        assert(sb_copyin(&sb, NULL, TEST_SIZE + 1) != 0);
        assert(sb_copyin(&sb, test_buf, TEST_SIZE) == 0);
        assert(memcmp(buf, test_buf, TEST_SIZE) == 0);
        assert(sb.size == 0);
        assert(sb.data == buf + TEST_SIZE);
#undef TEST_SIZE
}

void test_sb_recast(void) {
#define TEST_SIZE 33
        char *const start = NULL;
        SizedBuf t = { .data = start, .size = TEST_SIZE };
        void *out = NULL;

        assert(sb_recast(&t, SIZE_MAX, &out) != 0);
        assert(sb_recast(&t, TEST_SIZE + 1, &out) != 0);
        assert(sb_recast(&t, 13, &out) == 0);
        assert(t.data == start + 13);
        assert(t.size == TEST_SIZE - 13);
        assert(out == NULL);
        assert(sb_recast(&t, 8, &out) == 0);
        assert(t.data == (void *)(13 + 8));
        assert(t.size == TEST_SIZE - 13 - 8);
        assert(out == (void *)13);
#undef TEST_SIZE
}

void test_sb_end(void) {
        SizedBuf sb = { .data = NULL, .size = SIZE_MAX };
        assert(sb_end(sb) == (void *)SIZE_MAX);

        sb = (SizedBuf){ .data = (void *)0xdeadbeefull, .size = 0x1337 };
        assert(sb_end(sb) == (void *)(0xdeadbeefull + 0x1337ull));
}

void test_sb_empty(void) {
        SizedBuf sb = { .data = NULL, .size = SIZE_MAX };
        assert(!sb_empty(sb));
        sb.size = 1;
        assert(!sb_empty(sb));
        sb.size = 0;
        assert(sb_empty(sb));
}

void test_sb_peek(void) {
#define TEST_SIZE 128
        SizedBuf sb = { .data = NULL, .size = TEST_SIZE };
        void *test = (void *)0xdeadbeefull;
        assert(sb_peek(sb, SIZE_MAX, &test) != 0);
        assert(sb_peek(sb, TEST_SIZE + 1, &test) != 0);
        assert(sb_peek(sb, TEST_SIZE, &test) == 0);
        assert(sb.data == test);
        assert(sb.size == TEST_SIZE);
        test = (void *)'FOUR';
        assert(sb_peek(sb, 0, &test) == 0);
        assert(sb.data == test);
        assert(sb.size == TEST_SIZE);
#undef TEST_SIZE
}

typedef struct {
        void (*test)(void);
        const char *const name;
} Test;

#define TEST(x) { x, #x }
Test tests[] = {
        TEST(test_sb_check),
        TEST(test_sb_update),
        TEST(test_sb_copyin),
        TEST(test_sb_recast),
        TEST(test_sb_end),
        TEST(test_sb_empty),
        TEST(test_sb_peek),
};
#undef TEST

int main() {
#ifdef DISABLE_STDOUT
        fclose(stdout);
#endif

        // run all tests
        size_t num_tests = sizeof(tests) / sizeof(tests[0]);
        for (size_t i = 0; i < num_tests; i++) {
                tests[i].test();
                fprintf(stderr, "Test passed: %s\n", tests[i].name);
        }

        fprintf(stderr, "All tests passed.\n");

        return 0;
}