mirror of
https://gitee.com/zlgopen/awtk.git
synced 2024-11-30 02:58:26 +08:00
377 lines
9.7 KiB
C++
377 lines
9.7 KiB
C++
#include "tkc/darray.h"
|
|
#include "tkc/utils.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
#define NR 1000
|
|
|
|
static void test_add(darray_t* darray, void* pv) {
|
|
ASSERT_EQ(RET_OK, darray_push(darray, pv));
|
|
ASSERT_EQ(pv, darray_find(darray, pv));
|
|
}
|
|
|
|
TEST(DArrayTest, init) {
|
|
darray_t darray;
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
ASSERT_EQ(darray.size, 0);
|
|
ASSERT_EQ(darray.capacity, 10);
|
|
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
TEST(DArrayTest, create) {
|
|
darray_t* darray = darray_create(10, NULL, NULL);
|
|
ASSERT_EQ(darray->size, 0);
|
|
ASSERT_EQ(darray->capacity, 10);
|
|
darray_destroy(darray);
|
|
}
|
|
|
|
TEST(DArrayTest, stack) {
|
|
char* p = NULL;
|
|
darray_t* darray = darray_create(10, NULL, NULL);
|
|
ASSERT_EQ(darray->size, 0);
|
|
ASSERT_EQ(darray->capacity, 10);
|
|
|
|
ASSERT_EQ(darray_tail(darray), p);
|
|
ASSERT_EQ(darray_head(darray), p);
|
|
|
|
ASSERT_EQ(RET_OK, darray_push(darray, p + 1));
|
|
ASSERT_EQ(darray_tail(darray), p + 1);
|
|
ASSERT_EQ(darray_head(darray), p + 1);
|
|
ASSERT_EQ(1, darray_count(darray, p + 1));
|
|
|
|
ASSERT_EQ(darray_pop(darray), p + 1);
|
|
ASSERT_EQ(darray->size, 0);
|
|
|
|
darray_destroy(darray);
|
|
}
|
|
|
|
TEST(DArrayTest, basic) {
|
|
char* p = NULL;
|
|
darray_t* darray = darray_create(10, NULL, NULL);
|
|
ASSERT_EQ(darray->size, 0);
|
|
ASSERT_EQ(darray->capacity, 10);
|
|
|
|
ASSERT_EQ(RET_OK, darray_push(darray, p + 1));
|
|
ASSERT_EQ(1, darray_count(darray, p + 1));
|
|
|
|
ASSERT_EQ(RET_OK, darray_push(darray, p + 1));
|
|
ASSERT_EQ(2, darray_count(darray, p + 1));
|
|
|
|
ASSERT_EQ(RET_OK, darray_remove(darray, p + 1));
|
|
ASSERT_EQ(1, darray_count(darray, p + 1));
|
|
|
|
ASSERT_EQ(RET_OK, darray_push(darray, p + 1));
|
|
ASSERT_EQ(2, darray_count(darray, p + 1));
|
|
|
|
ASSERT_EQ(RET_OK, darray_remove_all(darray, NULL, p + 1));
|
|
ASSERT_EQ(darray->size, 0);
|
|
ASSERT_EQ(0, darray_count(darray, p + 1));
|
|
|
|
ASSERT_EQ(RET_OK, darray_push(darray, p + 1));
|
|
ASSERT_EQ(RET_OK, darray_push(darray, p + 2));
|
|
ASSERT_EQ(RET_OK, darray_push(darray, p + 3));
|
|
ASSERT_EQ(RET_OK, darray_clear(darray));
|
|
|
|
ASSERT_EQ(darray->size, 0);
|
|
|
|
darray_destroy(darray);
|
|
}
|
|
|
|
TEST(DArrayTest, popPush) {
|
|
uint32_t i = 0;
|
|
char* p = NULL;
|
|
darray_t darray;
|
|
int cases[] = {1, 2, 13, 14, 12, 41, 34, 34, 5, 563, 12, 1, 2, 33};
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(cases); i++) {
|
|
ASSERT_EQ(RET_OK, darray_push(&darray, p + cases[i]));
|
|
ASSERT_EQ(i + 1, darray.size);
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(cases); i++) {
|
|
int k = ARRAY_SIZE(cases) - i - 1;
|
|
void* data = darray_pop(&darray);
|
|
ASSERT_EQ(data, p + cases[k]);
|
|
ASSERT_EQ(k, darray.size);
|
|
}
|
|
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
TEST(DArrayTest, random) {
|
|
int i = 0;
|
|
int n = NR;
|
|
char* p = NULL;
|
|
darray_t darray;
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
long v = random() + 1;
|
|
void* pv = p + v;
|
|
ASSERT_EQ(darray.size, i);
|
|
test_add(&darray, pv);
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
long k = random() % darray.size;
|
|
void* pv = darray.elms[k];
|
|
|
|
ASSERT_EQ(RET_OK, darray_remove(&darray, pv));
|
|
}
|
|
ASSERT_EQ(darray.size, 0);
|
|
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
TEST(DArrayTest, inc) {
|
|
int i = 0;
|
|
int n = NR;
|
|
char* p = NULL;
|
|
darray_t darray;
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
void* pv = p + i;
|
|
ASSERT_EQ(darray.size, i);
|
|
test_add(&darray, pv);
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
long k = random() % darray.size;
|
|
void* pv = darray.elms[k];
|
|
|
|
ASSERT_EQ(RET_OK, darray_remove(&darray, pv));
|
|
}
|
|
ASSERT_EQ(darray.size, 0);
|
|
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
TEST(DArrayTest, dec) {
|
|
int i = 0;
|
|
char* p = NULL;
|
|
int n = NR;
|
|
darray_t darray;
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
void* pv = p + (n - i);
|
|
ASSERT_EQ(darray.size, i);
|
|
test_add(&darray, pv);
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
long k = random() % darray.size;
|
|
void* pv = darray.elms[k];
|
|
|
|
ASSERT_EQ(pv, darray_find(&darray, pv));
|
|
ASSERT_EQ(RET_OK, darray_remove(&darray, pv));
|
|
ASSERT_EQ(NULL, darray_find(&darray, pv));
|
|
}
|
|
ASSERT_EQ(darray.size, 0);
|
|
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
TEST(DArrayTest, removeAll) {
|
|
uint32_t i = 0;
|
|
char* p = NULL;
|
|
darray_t darray;
|
|
int cases[] = {1, 2, 2, 2, 13, 14, 12, 41, 34, 34, 5, 563, 12, 1, 2, 33};
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(cases); i++) {
|
|
ASSERT_EQ(RET_OK, darray_push(&darray, p + cases[i]));
|
|
ASSERT_EQ(i + 1, darray.size);
|
|
}
|
|
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases));
|
|
ASSERT_EQ(darray_remove_all(&darray, NULL, p + 2), RET_OK);
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases) - 4);
|
|
|
|
ASSERT_EQ(darray_remove_all(&darray, NULL, p + 1), RET_OK);
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases) - 4 - 2);
|
|
|
|
ASSERT_EQ(darray_remove_all(&darray, NULL, p + 12), RET_OK);
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases) - 4 - 2 - 2);
|
|
|
|
ASSERT_EQ(darray_remove_all(&darray, NULL, p + 13), RET_OK);
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases) - 4 - 2 - 2 - 1);
|
|
|
|
ASSERT_EQ(darray_remove_all(&darray, NULL, p + 14), RET_OK);
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases) - 4 - 2 - 2 - 1 - 1);
|
|
|
|
ASSERT_EQ(darray_remove_all(&darray, NULL, p + 33), RET_OK);
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases) - 4 - 2 - 2 - 1 - 1 - 1);
|
|
|
|
ASSERT_EQ(darray_remove_all(&darray, NULL, p + 34), RET_OK);
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases) - 4 - 2 - 2 - 1 - 1 - 1 - 2);
|
|
|
|
ASSERT_EQ(darray_remove_all(&darray, NULL, p + 0), RET_OK);
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases) - 4 - 2 - 2 - 1 - 1 - 1 - 2);
|
|
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
static int cmp_le(const void* a, const void* b) {
|
|
int ia = tk_pointer_to_int((void*)a);
|
|
int ib = tk_pointer_to_int((void*)b);
|
|
|
|
if (ia <= ib) {
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
TEST(DArrayTest, removeAll1) {
|
|
uint32_t i = 0;
|
|
char* p = NULL;
|
|
darray_t darray;
|
|
int cases[] = {1, 2, 2, 2, 13, 14, 12, 41, 34, 34, 5, 563, 12, 1, 2, 33};
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(cases); i++) {
|
|
ASSERT_EQ(RET_OK, darray_push(&darray, p + cases[i]));
|
|
ASSERT_EQ(i + 1, darray.size);
|
|
}
|
|
|
|
ASSERT_EQ(darray.size, ARRAY_SIZE(cases));
|
|
ASSERT_EQ(darray_remove_all(&darray, cmp_le, tk_pointer_from_int(100)), RET_OK);
|
|
ASSERT_EQ(darray.size, 1);
|
|
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
TEST(DArrayTest, findAll) {
|
|
uint32_t i = 0;
|
|
char* p = NULL;
|
|
darray_t darray;
|
|
darray_t matched;
|
|
int cases[] = {1, 2, 2, 2, 13, 14, 12, 41, 34, 34, 5, 563, 12, 1, 2, 33};
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(cases); i++) {
|
|
ASSERT_EQ(RET_OK, darray_push(&darray, p + cases[i]));
|
|
ASSERT_EQ(i + 1, darray.size);
|
|
}
|
|
|
|
darray_init(&matched, 10, NULL, NULL);
|
|
ASSERT_EQ(darray_find_all(&darray, cmp_le, tk_pointer_from_int(10), &matched), RET_OK);
|
|
ASSERT_EQ(matched.size, 7);
|
|
darray_clear(&matched);
|
|
|
|
ASSERT_EQ(darray_find_all(&darray, cmp_le, tk_pointer_from_int(100), &matched), RET_OK);
|
|
ASSERT_EQ(matched.size, ARRAY_SIZE(cases) - 1);
|
|
darray_clear(&matched);
|
|
|
|
darray_deinit(&matched);
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
static int cmp_int(const void* a, const void* b) {
|
|
int ia = tk_pointer_to_int(a);
|
|
int ib = tk_pointer_to_int(b);
|
|
|
|
return ia - ib;
|
|
}
|
|
|
|
TEST(DArrayTest, sort) {
|
|
uint32_t i = 0;
|
|
char* p = NULL;
|
|
darray_t darray;
|
|
int cases[] = {100, 1, 2, 2, 13, 14, 12, 4};
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(cases); i++) {
|
|
ASSERT_EQ(RET_OK, darray_push(&darray, p + cases[i]));
|
|
ASSERT_EQ(i + 1, darray.size);
|
|
}
|
|
|
|
ASSERT_EQ(darray_sort(&darray, cmp_int), RET_OK);
|
|
ASSERT_EQ(tk_pointer_to_int(darray.elms[0]), 1);
|
|
ASSERT_EQ(tk_pointer_to_int(darray.elms[1]), 2);
|
|
ASSERT_EQ(tk_pointer_to_int(darray.elms[2]), 2);
|
|
ASSERT_EQ(tk_pointer_to_int(darray.elms[3]), 4);
|
|
ASSERT_EQ(tk_pointer_to_int(darray.elms[4]), 12);
|
|
ASSERT_EQ(tk_pointer_to_int(darray.elms[5]), 13);
|
|
ASSERT_EQ(tk_pointer_to_int(darray.elms[6]), 14);
|
|
ASSERT_EQ(tk_pointer_to_int(darray.elms[7]), 100);
|
|
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(1)), 0);
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(4)), 3);
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(12)), 4);
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(13)), 5);
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(14)), 6);
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(100)), 7);
|
|
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
TEST(DArrayTest, bsearch) {
|
|
darray_t darray;
|
|
darray_init(&darray, 10, NULL, NULL);
|
|
|
|
darray_push(&darray, tk_pointer_from_int(1));
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(1)), 0);
|
|
|
|
darray_push(&darray, tk_pointer_from_int(2));
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(2)), 1);
|
|
|
|
darray_push(&darray, tk_pointer_from_int(3));
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(3)), 2);
|
|
|
|
ASSERT_EQ(darray_bsearch_index(&darray, NULL, tk_pointer_from_int(30)), -1);
|
|
|
|
darray_deinit(&darray);
|
|
}
|
|
|
|
#include "tkc/mem.h"
|
|
|
|
typedef struct _my_data_t {
|
|
char name[TK_NAME_LEN + 1];
|
|
int value;
|
|
} my_data_t;
|
|
|
|
static my_data_t* my_data_create(const char* name, int value) {
|
|
my_data_t* data = TKMEM_ZALLOC(my_data_t);
|
|
return_value_if_fail(data != NULL, NULL);
|
|
|
|
tk_strncpy(data->name, name, TK_NAME_LEN);
|
|
data->value = value;
|
|
|
|
return data;
|
|
}
|
|
|
|
static ret_t my_data_destroy(my_data_t* data) {
|
|
TKMEM_FREE(data);
|
|
|
|
return RET_OK;
|
|
}
|
|
|
|
TEST(DArrayTest, struct) {
|
|
darray_t darray;
|
|
my_data_t* p = NULL;
|
|
darray_init(&darray, 10, (tk_destroy_t)my_data_destroy, NULL);
|
|
|
|
darray_push(&darray, my_data_create("jack", 100));
|
|
darray_push(&darray, my_data_create("tom", 10));
|
|
|
|
ASSERT_EQ(darray.size, 2);
|
|
|
|
p = (my_data_t*)darray_get(&darray, 0);
|
|
ASSERT_STREQ(p->name, "jack");
|
|
ASSERT_EQ(p->value, 100);
|
|
|
|
p = (my_data_t*)darray_get(&darray, 1);
|
|
ASSERT_STREQ(p->name, "tom");
|
|
ASSERT_EQ(p->value, 10);
|
|
|
|
darray_deinit(&darray);
|
|
}
|