283 lines
9.2 KiB
C
283 lines
9.2 KiB
C
#include "test_main.h"
|
|
#include "lb/salloc.h"
|
|
#include "test_case.h"
|
|
|
|
typedef union
|
|
{
|
|
uint32 size;
|
|
uint32 flags;
|
|
} salloc_header;
|
|
|
|
static const uint32 salloc_header_size = sizeof(salloc_header);
|
|
|
|
static char buffer[1024];
|
|
|
|
static bool salloc_init_test(void)
|
|
{
|
|
lb_salloc_init(buffer, 1024);
|
|
uint32 blk_size[] = {1024};
|
|
bool blk_free[] = {TRUE};
|
|
return lb_salloc_assert(buffer, blk_size, blk_free, 1);
|
|
}
|
|
|
|
static bool salloc_basic_alloc(void)
|
|
{
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
result = result && (lb_salloc(buffer, 10) != NULL);
|
|
uint32 blk_size[] = {10 + salloc_header_size, 1024 - 10 - salloc_header_size};
|
|
bool blk_free[] = {FALSE, TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 2);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_full_alloc(void)
|
|
{
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
result = result && (lb_salloc(buffer, 1024 - salloc_header_size) != NULL);
|
|
uint32 blk_size[] = {1024};
|
|
bool blk_free[] = {FALSE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_overflow_alloc(void)
|
|
{
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
result = result && (lb_salloc(buffer, 1024 - salloc_header_size + 1) == NULL);
|
|
uint32 blk_size[] = {1024};
|
|
bool blk_free[] = {TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_multiple_alloc(void)
|
|
{
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
result = result && (lb_salloc(buffer, 10) != NULL);
|
|
result = result && (lb_salloc(buffer, 10) != NULL);
|
|
result = result && (lb_salloc(buffer, 10) != NULL);
|
|
uint32 blk_size[] = {10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
1024 - 3 * (10 + salloc_header_size)};
|
|
bool blk_free[] = {FALSE, FALSE, FALSE, TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 4);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_alloc_not_enough(void)
|
|
{
|
|
void *ptr;
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, salloc_header_size + salloc_header_size + salloc_header_size - 1);
|
|
ptr = lb_salloc(buffer, salloc_header_size);
|
|
result = result && (ptr != NULL);
|
|
uint32 blk_size[] = {salloc_header_size + salloc_header_size + salloc_header_size - 1};
|
|
bool blk_free[] = {FALSE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
|
|
return result;
|
|
}
|
|
|
|
|
|
static bool salloc_basic_free(void)
|
|
{
|
|
void *ptr;
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
ptr = lb_salloc(buffer, 10);
|
|
result = result && (ptr != NULL);
|
|
|
|
lb_sfree(buffer, ptr);
|
|
uint32 blk_size[] = {1024};
|
|
bool blk_free[] = {TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_full_free(void)
|
|
{
|
|
void *ptr;
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
ptr = lb_salloc(buffer, 1024 - salloc_header_size);
|
|
result = result && (ptr != NULL);
|
|
|
|
lb_sfree(buffer, ptr);
|
|
uint32 blk_size[] = {1024};
|
|
bool blk_free[] = {TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_multiple_free(void)
|
|
{
|
|
void *ptr1, *ptr2, *ptr3, *ptr4;
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
ptr1 = lb_salloc(buffer, 10);
|
|
ptr2 = lb_salloc(buffer, 10);
|
|
ptr3 = lb_salloc(buffer, 10);
|
|
ptr4 = lb_salloc(buffer, 10);
|
|
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
|
|
lb_sfree(buffer, ptr1);
|
|
lb_sfree(buffer, ptr3);
|
|
|
|
uint32 blk_size[] = {10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
1024 - 4 * (10 + salloc_header_size)};
|
|
bool blk_free[] = {TRUE, FALSE, TRUE, FALSE, TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 5);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_free_join_tail(void)
|
|
{
|
|
void *ptr1, *ptr2, *ptr3, *ptr4;
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
ptr1 = lb_salloc(buffer, 10);
|
|
ptr2 = lb_salloc(buffer, 10);
|
|
ptr3 = lb_salloc(buffer, 10);
|
|
ptr4 = lb_salloc(buffer, 10);
|
|
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
|
|
lb_sfree(buffer, ptr4);
|
|
|
|
uint32 blk_size[] = {10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
1024 - 3 * (10 + salloc_header_size)};
|
|
bool blk_free[] = {FALSE, FALSE, FALSE, TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 4);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_free_join_head(void)
|
|
{
|
|
void *ptr1, *ptr2, *ptr3, *ptr4;
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
ptr1 = lb_salloc(buffer, 10);
|
|
ptr2 = lb_salloc(buffer, 10);
|
|
ptr3 = lb_salloc(buffer, 10);
|
|
ptr4 = lb_salloc(buffer, 10);
|
|
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
|
|
lb_sfree(buffer, ptr1);
|
|
lb_sfree(buffer, ptr2);
|
|
|
|
uint32 blk_size[] = {2 * (10 + salloc_header_size),
|
|
10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
1024 - 4 * (10 + salloc_header_size)};
|
|
bool blk_free[] = {TRUE, FALSE, FALSE, TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 4);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_free_join_mid(void)
|
|
{
|
|
void *ptr1, *ptr2, *ptr3, *ptr4;
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
ptr1 = lb_salloc(buffer, 10);
|
|
ptr2 = lb_salloc(buffer, 10);
|
|
ptr3 = lb_salloc(buffer, 10);
|
|
ptr4 = lb_salloc(buffer, 10);
|
|
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
|
|
lb_sfree(buffer, ptr2);
|
|
lb_sfree(buffer, ptr3);
|
|
|
|
uint32 blk_size[] = {10 + salloc_header_size,
|
|
2 * (10 + salloc_header_size),
|
|
10 + salloc_header_size,
|
|
1024 - 4 * (10 + salloc_header_size)};
|
|
bool blk_free[] = {FALSE, TRUE, FALSE, TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 4);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_free_join_consecutive(void)
|
|
{
|
|
void *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
ptr1 = lb_salloc(buffer, 10);
|
|
ptr2 = lb_salloc(buffer, 10);
|
|
ptr3 = lb_salloc(buffer, 10);
|
|
ptr4 = lb_salloc(buffer, 10);
|
|
ptr5 = lb_salloc(buffer, 10);
|
|
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL) && (ptr5 != NULL);
|
|
lb_sfree(buffer, ptr2);
|
|
lb_sfree(buffer, ptr4);
|
|
|
|
uint32 blk_size[] = {10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
10 + salloc_header_size,
|
|
1024 - 5 * (10 + salloc_header_size)};
|
|
bool blk_free[] = {FALSE, TRUE, FALSE, TRUE, FALSE, TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 6);
|
|
|
|
lb_sfree(buffer, ptr3);
|
|
|
|
uint32 blk_size2[] = {10 + salloc_header_size,
|
|
3 * (10 + salloc_header_size),
|
|
10 + salloc_header_size,
|
|
1024 - 5 * (10 + salloc_header_size)};
|
|
bool blk_free2[] = {FALSE, TRUE, FALSE, TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size2, blk_free2, 4);
|
|
return result;
|
|
}
|
|
|
|
static bool salloc_free_all(void)
|
|
{
|
|
void *ptr1, *ptr2, *ptr3, *ptr4;
|
|
bool result = TRUE;
|
|
lb_salloc_init(buffer, 1024);
|
|
ptr1 = lb_salloc(buffer, 10);
|
|
ptr2 = lb_salloc(buffer, 10);
|
|
ptr3 = lb_salloc(buffer, 10);
|
|
ptr4 = lb_salloc(buffer, 10);
|
|
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
|
|
lb_sfree(buffer, ptr1);
|
|
lb_sfree(buffer, ptr2);
|
|
lb_sfree(buffer, ptr3);
|
|
lb_sfree(buffer, ptr4);
|
|
|
|
uint32 blk_size[] = {1024};
|
|
bool blk_free[] = {TRUE};
|
|
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
|
|
return result;
|
|
}
|
|
|
|
|
|
void salloc_test(void)
|
|
{
|
|
test_begin("salloc test");
|
|
|
|
run_case("salloc_init_test", salloc_init_test());
|
|
|
|
run_case("salloc_basic_alloc", salloc_basic_alloc());
|
|
run_case("salloc_full_alloc", salloc_full_alloc());
|
|
run_case("salloc_overflow_alloc", salloc_overflow_alloc());
|
|
run_case("salloc_multiple_alloc", salloc_multiple_alloc());
|
|
run_case("salloc_alloc_not_enough", salloc_alloc_not_enough());
|
|
|
|
run_case("salloc_basic_free", salloc_basic_free());
|
|
run_case("salloc_full_free", salloc_full_free());
|
|
run_case("salloc_multiple_free", salloc_multiple_free());
|
|
run_case("salloc_free_join_tail", salloc_free_join_tail());
|
|
run_case("salloc_free_join_head", salloc_free_join_head());
|
|
run_case("salloc_free_join_mid", salloc_free_join_mid());
|
|
run_case("salloc_free_join_consecutive", salloc_free_join_consecutive());
|
|
run_case("salloc_free_all", salloc_free_all());
|
|
|
|
test_end();
|
|
}
|