static void
init(void **state) {
t_array array;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(int)));
D_ARRAY(destroy)(&array);
(void)state;
}
static void
data(void **state) {
t_array array;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(size_t)));
assert_ptr_equal(F_ARRAY_DATA(&array, size_t *), array.v_data);
D_ARRAY(destroy)(&array);
(void)state;
}
static void
multiple_destroy(void **state) {
t_array array;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(size_t)));
D_ARRAY(destroy)(&array);
D_ARRAY(destroy)(&array);
(void)state;
}
static void
at_out_of_range(void **state) {
t_array array;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(size_t)));
assert_null(F_ARRAY_AT(&array, 0, size_t));
D_ARRAY(destroy)(&array);
(void)state;
}
static void
resize_fail(void **state) {
t_array array;
assert_true(D_ARRAY(init)(&array, uf_realloc, 0, sizeof(size_t)));
assert_true(D_ARRAY(resize)(&array, 10));
assert_false(D_ARRAY(resize)(&array, 1));
D_ARRAY(destroy)(&array);
(void)state;
}
static void
resize(void **state) {
t_array array;
assert_true(D_ARRAY(init)(&array, uf_realloc, 0, sizeof(size_t)));
assert_true(D_ARRAY(resize)(&array, 10));
assert_int_equal(D_ARRAY(capacity)(&array), 10);
assert_int_equal(D_ARRAY(size)(&array), 0);
D_ARRAY(destroy)(&array);
(void)state;
}
static void
push_back(void **state) {
t_array array;
size_t put = 4;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(size_t)));
assert_true(D_ARRAY(push_back)(&array, &put));
assert_int_equal(D_ARRAY(size)(&array), 1);
assert_int_equal(*(size_t *)F_ARRAY_AT(&array, 0, size_t), 4);
D_ARRAY(destroy)(&array);
(void)state;
}
static void
at(void **state) {
t_array array;
size_t put = 0;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(size_t)));
assert_true(D_ARRAY(push_back)(&array, &put));
put++;
assert_non_null(F_ARRAY_AT(&array, 0, size_t));
assert_int_equal(*(size_t *)F_ARRAY_AT(&array, 0, size_t), 0);
D_ARRAY(destroy)(&array);
(void)state;
}
void D_UNIT_FUNCT(memleaks)
{
int i;
t_array array;
struct s_leaks leak;
i = 0;
D_ARRAY(init)(&array, 0, 0, sizeof(int));
while (i < 987654)
{
D_ARRAY(push_back)(&array, &i);
i = i + 1;
}
i = 67;
D_ARRAY(delete_if)(&array, uf_cmp, &i);
D_ARRAY(resize)(&array, 9876543);
D_ARRAY(destroy)(&array);
i = 0;
D_ARRAY(init)(&array, 0, uf_delete_leak, sizeof(struct s_leaks));
while (i < 987654)
{
leak.v_leak = malloc(sizeof(int));
D_ARRAY(push_back)(&array, &leak);
i = i + 1;
}
D_ARRAY(destroy)(&array);
(void)t;
}
void D_UNIT_FUNCT(ret_val)
{
int i;
t_array array;
i = 0;
F_UNIT_ASSERT(D_ARRAY(init)(&array, 0, 0, sizeof(int)) == 1);
while (i < 987654)
{
F_UNIT_ASSERT(D_ARRAY(push_back)(&array, &i) == 1);
i = i + 1;
}
F_UNIT_ASSERT(D_ARRAY(foreach)(&array, uf_foreach) == 1);
D_ARRAY(destroy)(&array);
}
void f_htable_destroy(t_htable *v_this)
{
D_ARRAY(destroy)(&v_this->v_array);
v_this->v_prime = 0;
v_this->f_delete = NULL;
v_this->f_generate_key = NULL;
}
static void
clear(void **state) {
t_array array;
size_t put;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(int)));
put = 0;
while (put < 10) {
assert_true(D_ARRAY(push_back)(&array, &put));
put++;
}
D_ARRAY(clear)(&array);
assert_int_equal(D_ARRAY(size)(&array), 0);
D_ARRAY(destroy)(&array);
(void)state;
}
static void
push_back_10_values(void **state) {
t_array array;
size_t put;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(size_t)));
put = 0;
while (put < 10) {
assert_true(D_ARRAY(push_back)(&array, &put));
assert_int_equal(D_ARRAY(size)(&array), put + 1);
put++;
}
put = 0;
while (put < 10) {
assert_int_equal(*(size_t *)F_ARRAY_AT(&array, put, size_t), put);
put++;
}
D_ARRAY(destroy)(&array);
(void)state;
}
static void
foreach(void **state) {
t_array array;
size_t put;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(size_t)));
put = 0;
while (put < 10) {
assert_true(D_ARRAY(push_back)(&array, &put));
put++;
}
D_ARRAY(foreach)(&array, uf_foreach);
put = 0;
while (put < 10) {
assert_int_equal(*(size_t *)F_ARRAY_AT(&array, put, size_t), put + 10);
put++;
}
D_ARRAY(destroy)(&array);
(void)state;
}
bool f_array_push_back(t_array *v_this, void *data)
{
char *to;
size_t new_size;
new_size = v_this->f_realloc(v_this->v_capacity);
if (v_this->v_size + 1 > v_this->v_capacity
&& D_ARRAY(realloc)(v_this, new_size) == false)
return (false);
to = (char *)v_this->v_data;
to = to + v_this->v_size * v_this->v_type_size;
uf_memcpy(to, data, v_this->v_type_size);
v_this->v_size = v_this->v_size + 1;
return (true);
}
bool f_htable_init(t_htable *v_this, size_t prime,
size_t (*f_generate_key)(size_t prime, const char *str),
void (*f_delete)(void *ptr))
{
size_t i;
t_list list;
i = 0;
if (D_ARRAY(init)(&v_this->v_array, NULL, (void (*)(void *))D_LIST(destroy),
sizeof(t_list)) == false)
return (M_ERROR(false, "Could not initialize array"));
D_LIST(init)(&list, D_HTABLE(delete_cell));
while (i < prime)
{
D_ARRAY(push_back)(&v_this->v_array, &list);
i = i + 1;
}
v_this->v_prime = prime;
v_this->f_delete = f_delete;
v_this->f_generate_key = D_HTABLE(generate_key);
if (f_generate_key != NULL)
v_this->f_generate_key = f_generate_key;
return (true);
}
static void
capacity(void **state) {
t_array array;
size_t put = 0;
assert_true(D_ARRAY(init)(&array, uf_realloc, 0, sizeof(size_t)));
assert_true(D_ARRAY(push_back)(&array, &put));
put++;
assert_true(D_ARRAY(push_back)(&array, &put));
assert_int_equal(D_ARRAY(capacity)(&array), 2);
put++;
assert_true(D_ARRAY(push_back)(&array, &put));
assert_int_equal(D_ARRAY(capacity)(&array), 3);
D_ARRAY(destroy)(&array);
(void)state;
}
static void
delete_if_double(void **state) {
t_array array;
size_t put = 0;
size_t cmp = 1;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(size_t)));
assert_true(D_ARRAY(push_back)(&array, &put));
put++;
assert_true(D_ARRAY(push_back)(&array, &put));
assert_true(D_ARRAY(push_back)(&array, &put));
put++;
assert_true(D_ARRAY(push_back)(&array, &put));
put++;
D_ARRAY(delete_if)(&array, uf_cmp, &cmp);
assert_int_equal(*(size_t *)F_ARRAY_AT(&array, 0, size_t), 0);
assert_int_equal(*(size_t *)F_ARRAY_AT(&array, 1, size_t), 2);
assert_int_equal(D_ARRAY(size)(&array), 2);
D_ARRAY(destroy)(&array);
(void)state;
}
void D_UNIT_FUNCT(getter)
{
int i;
t_array array;
i = 0;
D_ARRAY(init)(&array, 0, 0, sizeof(size_t));
F_UNIT_ASSERT(F_ARRAY_DATA(&array, void *) != NULL);
F_UNIT_ASSERT(F_ARRAY_AT(&array, 0, void *) != NULL);
F_UNIT_ASSERT(D_ARRAY(size)(&array) == 0);
F_UNIT_ASSERT(D_ARRAY(empty)(&array) == 1);
while (i < 987654)
{
D_ARRAY(push_back)(&array, &i);
i = i + 1;
}
F_UNIT_ASSERT(D_ARRAY(size)(&array) == 987654);
F_UNIT_ASSERT(D_ARRAY(empty)(&array) == 0);
D_ARRAY(destroy)(&array);
}
static void
empty(void **state) {
t_array array;
size_t put;
assert_true(D_ARRAY(init)(&array, 0, 0, sizeof(int)));
put = 0;
while (put < 10) {
assert_true(D_ARRAY(push_back)(&array, &put));
put++;
}
assert_false(D_ARRAY(empty)(&array));
D_ARRAY(clear)(&array);
assert_true(D_ARRAY(empty)(&array));
D_ARRAY(destroy)(&array);
(void)state;
}
bool f_array_resize(t_array *v_this, size_t size)
{
if (size < v_this->v_capacity)
return (M_ERROR(false, "Size %d is lower than capacity", size));
return (D_ARRAY(realloc)(v_this, size));
}
void f_array_destroy(t_array *v_this)
{
D_ARRAY(clear)(v_this);
free(v_this->v_data);
uf_memset(v_this, 0, sizeof(*v_this));
}
