jer/refuse
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

require consumers to supply their own instance of the collector, initialize it

Browse Source
This commit is contained in:
Jeremy Tregunna 2016-04-26 22:07:37 -06:00
parent 002caadb81
commit 6a7d90145c
No known key found for this signature in database
GPG Key ID: 1A042D7269D00255
3 changed files with 39 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
refuse.c
View File

@ -8,13 +8,10 @@ static inline refhdr_t* _refuse_header(void* ptr)
return (refhdr_t*)((char*)ptr - sizeof(refhdr_t)); return (refhdr_t*)((char*)ptr - sizeof(refhdr_t));
} }
refuse_t* refuse_new(void) void refuse_init(refuse_t* refuse)
{ {
refuse_t* refuse = malloc(sizeof(refuse_t));
refuse->dec = refdeque_alloc(); refuse->dec = refdeque_alloc();
refuse->mod = refdeque_alloc(); refuse->mod = refdeque_alloc();
return refuse;
} }
void refuse_destroy(refuse_t* refuse) void refuse_destroy(refuse_t* refuse)

4
refuse.h
View File

@ -18,12 +18,12 @@ typedef struct
refdeque_t* mod; refdeque_t* mod;
} refuse_t; } refuse_t;
// Create a new garbage collector. It should be noted, that refuse is // Initialize the garbage collector. It should be noted, that refuse is
// not yet thread safe. Therefore it's recommended that refuse run in // not yet thread safe. Therefore it's recommended that refuse run in
// its own thread. Objects may be shared across thread boundaries for // its own thread. Objects may be shared across thread boundaries for
// the purposes of your use case, however, all operations, save for // the purposes of your use case, however, all operations, save for
// refuse_alloc, must be run on the thread that owns refuse. // refuse_alloc, must be run on the thread that owns refuse.
extern refuse_t* refuse_new(void); extern void refuse_init(refuse_t*);
// Allocate a chunk of memory and place it under control of an instance // Allocate a chunk of memory and place it under control of an instance
// of refuse. The pointer returned points at the start of memory for // of refuse. The pointer returned points at the start of memory for

61
tests.c
View File

@ -11,17 +11,20 @@ struct mock
int a; int a;
}; };
START_TEST(test_refuse_new) START_TEST(test_refuse_init)
{ {
refuse_t* refuse = refuse_new(); refuse_t refuse = {0};
ck_assert(refuse != NULL); refuse_init(&refuse);
ck_assert(refuse.mod != NULL);
ck_assert(refuse.dec != NULL);
} }
END_TEST END_TEST
START_TEST(test_refuse_alloc_1) START_TEST(test_refuse_alloc_1)
{ {
refuse_t* refuse = refuse_new(); refuse_t refuse = {0};
struct mock* t = refuse_alloc(refuse, sizeof(struct mock)); refuse_init(&refuse);
struct mock* t = refuse_alloc(&refuse, sizeof(struct mock));
ck_assert(t != NULL); ck_assert(t != NULL);
refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t)); refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
ck_assert_int_eq(hdr->retainCount, 0); ck_assert_int_eq(hdr->retainCount, 0);
@ -32,15 +35,16 @@ END_TEST
START_TEST(test_refuse_retain_1) START_TEST(test_refuse_retain_1)
{ {
refuse_t* refuse = refuse_new(); refuse_t refuse = {0};
struct mock* t = refuse_alloc(refuse, sizeof(struct mock)); refuse_init(&refuse);
struct mock* t = refuse_alloc(&refuse, sizeof(struct mock));
t->a = 42; t->a = 42;
refuse_retain(refuse, t); refuse_retain(&refuse, t);
refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t)); refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
ck_assert_int_eq(hdr->retainCount, 0); ck_assert_int_eq(hdr->retainCount, 0);
ck_assert_int_eq(hdr->new, 1); ck_assert_int_eq(hdr->new, 1);
ck_assert_int_eq(hdr->dirty, 0); ck_assert_int_eq(hdr->dirty, 0);
refhdr_t* popped = refdeque_pop_back(refuse->mod); refhdr_t* popped = refdeque_pop_back(refuse.mod);
struct mock* s = (struct mock*)((char*)popped + sizeof(refhdr_t)); struct mock* s = (struct mock*)((char*)popped + sizeof(refhdr_t));
ck_assert_int_eq(s->a, 42); ck_assert_int_eq(s->a, 42);
} }
@ -48,14 +52,15 @@ END_TEST
START_TEST(test_refuse_retain_2) START_TEST(test_refuse_retain_2)
{ {
refuse_t* refuse = refuse_new(); refuse_t refuse = {0};
struct mock* t = refuse_alloc(refuse, sizeof(struct mock)); refuse_init(&refuse);
refuse_retain(refuse, t); struct mock* t = refuse_alloc(&refuse, sizeof(struct mock));
refuse_retain(&refuse, t);
refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t)); refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
ck_assert_int_eq(hdr->retainCount, 0); ck_assert_int_eq(hdr->retainCount, 0);
ck_assert_int_eq(hdr->new, 1); ck_assert_int_eq(hdr->new, 1);
ck_assert_int_eq(hdr->dirty, 0); ck_assert_int_eq(hdr->dirty, 0);
refuse_reconcile(refuse); refuse_reconcile(&refuse);
ck_assert_int_eq(hdr->new, 0); ck_assert_int_eq(hdr->new, 0);
ck_assert_int_eq(hdr->retainCount, 1); ck_assert_int_eq(hdr->retainCount, 1);
} }
@ -63,28 +68,30 @@ END_TEST
START_TEST(test_refuse_retain_3) START_TEST(test_refuse_retain_3)
{ {
refuse_t* refuse = refuse_new(); refuse_t refuse = {0};
struct mock* t = refuse_alloc(refuse, sizeof(struct mock)); refuse_init(&refuse);
refuse_set_dirty(refuse, t); struct mock* t = refuse_alloc(&refuse, sizeof(struct mock));
refuse_retain(refuse, t); refuse_set_dirty(&refuse, t);
refuse_retain(&refuse, t);
refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t)); refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
ck_assert_int_eq(hdr->retainCount, 0); ck_assert_int_eq(hdr->retainCount, 0);
refuse_reconcile(refuse); refuse_reconcile(&refuse);
ck_assert_int_eq(hdr->retainCount, 0); ck_assert_int_eq(hdr->retainCount, 0);
} }
END_TEST END_TEST
START_TEST(test_refuse_release_1) START_TEST(test_refuse_release_1)
{ {
refuse_t* refuse = refuse_new(); refuse_t refuse = {0};
struct mock* t = refuse_alloc(refuse, sizeof(struct mock)); refuse_init(&refuse);
refuse_retain(refuse, t); struct mock* t = refuse_alloc(&refuse, sizeof(struct mock));
refuse_reconcile(refuse); refuse_retain(&refuse, t);
refuse_reconcile(&refuse);
refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t)); refhdr_t* hdr = (refhdr_t*)((char*)t - sizeof(refhdr_t));
ck_assert_int_eq(hdr->retainCount, 1); ck_assert_int_eq(hdr->retainCount, 1);
refuse_release(refuse, t); refuse_release(&refuse, t);
ck_assert_int_eq(hdr->retainCount, 1); ck_assert_int_eq(hdr->retainCount, 1);
refuse_reconcile(refuse); refuse_reconcile(&refuse);
ck_assert_int_eq(hdr->retainCount, 0); ck_assert_int_eq(hdr->retainCount, 0);
} }
END_TEST END_TEST
@ -93,9 +100,9 @@ static Suite* refuse_suite(void)
{ {
Suite *s = suite_create("refuse"); Suite *s = suite_create("refuse");
TCase* tc_refuse_new = tcase_create("refuse_new"); TCase* tc_refuse_init = tcase_create("refuse_init");
tcase_add_test(tc_refuse_new, test_refuse_new); tcase_add_test(tc_refuse_init, test_refuse_init);
suite_add_tcase(s, tc_refuse_new); suite_add_tcase(s, tc_refuse_init);
TCase* tc_refuse_alloc = tcase_create("refuse_alloc"); TCase* tc_refuse_alloc = tcase_create("refuse_alloc");
tcase_add_test(tc_refuse_alloc, test_refuse_alloc_1); tcase_add_test(tc_refuse_alloc, test_refuse_alloc_1);