#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wtype-limits"

#include <stdlib.h>
#include <check.h>
#include "refuse.h"
#include "deque.h"

struct mock
{
    int a;
};

START_TEST(test_refuse_new)
{
    refuse_t* refuse = refuse_new();
    ck_assert(refuse != NULL);
}
END_TEST

START_TEST(test_refuse_alloc_1)
{
    refuse_t* refuse = refuse_new();
    struct mock* t = refuse_alloc(refuse, sizeof(struct mock));
    ck_assert(t != NULL);
    refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
    ck_assert_int_eq(hdr->retainCount, 0);
    ck_assert_int_eq(hdr->new, 1);
    ck_assert_int_eq(hdr->dirty, 0);
}
END_TEST

START_TEST(test_refuse_retain_1)
{
    refuse_t* refuse = refuse_new();
    struct mock* t = refuse_alloc(refuse, sizeof(struct mock));
    t->a = 42;
    refuse_retain(refuse, t);
    refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
    ck_assert_int_eq(hdr->retainCount, 0);
    ck_assert_int_eq(hdr->new, 1);
    ck_assert_int_eq(hdr->dirty, 0);
    refhdr_t* popped = refdeque_pop_back(refuse->mod);
    struct mock* s = (struct mock*)((char*)popped + sizeof(refhdr_t));
    ck_assert_int_eq(s->a, 42);
}
END_TEST

START_TEST(test_refuse_retain_2)
{
    refuse_t* refuse = refuse_new();
    struct mock* t = refuse_alloc(refuse, sizeof(struct mock));
    refuse_retain(refuse, t);
    refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
    ck_assert_int_eq(hdr->retainCount, 0);
    ck_assert_int_eq(hdr->new, 1);
    ck_assert_int_eq(hdr->dirty, 0);
    refuse_reconcile(refuse);
    ck_assert_int_eq(hdr->new, 0);
    ck_assert_int_eq(hdr->retainCount, 1);
}
END_TEST

START_TEST(test_refuse_retain_3)
{
    refuse_t* refuse = refuse_new();
    struct mock* t = refuse_alloc(refuse, sizeof(struct mock));
    refuse_set_dirty(refuse, t);
    refuse_retain(refuse, t);
    refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
    ck_assert_int_eq(hdr->retainCount, 0);
    refuse_reconcile(refuse);
    ck_assert_int_eq(hdr->retainCount, 0);
}
END_TEST

START_TEST(test_refuse_release_1)
{
    refuse_t* refuse = refuse_new();
    struct mock* t = refuse_alloc(refuse, sizeof(struct mock));
    refuse_retain(refuse, t);
    refuse_reconcile(refuse);
    refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
    ck_assert_int_eq(hdr->retainCount, 1);
    refuse_release(refuse, t);
    ck_assert_int_eq(hdr->retainCount, 1);
    refuse_reconcile(refuse);
    ck_assert_int_eq(hdr->retainCount, 0);
}
END_TEST

static Suite* refuse_suite(void)
{
    Suite *s = suite_create("refuse");

    TCase* tc_refuse_new = tcase_create("refuse_new");
    tcase_add_test(tc_refuse_new, test_refuse_new);
    suite_add_tcase(s, tc_refuse_new);
    
    TCase* tc_refuse_alloc = tcase_create("refuse_alloc");
    tcase_add_test(tc_refuse_alloc, test_refuse_alloc_1);
    suite_add_tcase(s, tc_refuse_alloc);
    
    TCase* tc_refuse_retain = tcase_create("refuse_retain");
    tcase_add_test(tc_refuse_retain, test_refuse_retain_1);
    tcase_add_test(tc_refuse_retain, test_refuse_retain_2);
    tcase_add_test(tc_refuse_retain, test_refuse_retain_3);
    suite_add_tcase(s, tc_refuse_retain);
    
    TCase* tc_refuse_release = tcase_create("refuse_release");
    tcase_add_test(tc_refuse_release, test_refuse_release_1);
    suite_add_tcase(s, tc_refuse_release);

    return s;
}

int main(void)
{
    int number_failed;
    Suite *s = refuse_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) ? EXIT_SUCCESS : EXIT_FAILURE;
}