static void test_list_sort()
{
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
uint64_t node_number = 100;
for (uint64_t i = 0; i < node_number; ++i) {
test_list_node_t *node = KAA_MALLOC(sizeof(test_list_node_t));
ASSERT_NOT_NULL(node);
node->id = (uint64_t) rand();
kaa_list_push_back(list, node);
}
ASSERT_EQUAL(kaa_list_get_size(list), node_number);
kaa_list_sort(list,&test_kaa_list_predicate);
kaa_list_node_t *it,*next;
it = kaa_list_begin(list);
next = kaa_list_next(it);
while (it && next) {
ASSERT_TRUE(((test_list_node_t*)kaa_list_get_data(it))->id <=
((test_list_node_t*)kaa_list_get_data(next))->id);
it = next;
next = kaa_list_next(it);
}
kaa_list_destroy(list, NULL);
}
void test_list_push_front()
{
KAA_TRACE_IN(logger);
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
int32_t *number;
int node_number = 2;
for (int i = 0; i < node_number; ++i) {
number = (int32_t *)KAA_MALLOC(sizeof(int32_t *));
ASSERT_NOT_NULL(number);
*number = rand();
kaa_list_push_front(list, number);
}
ASSERT_EQUAL(kaa_list_get_size(list), node_number);
ASSERT_NOT_NULL(kaa_list_begin(list));
ASSERT_NULL(kaa_list_prev(kaa_list_begin(list)));
ASSERT_EQUAL((*(int32_t *)kaa_list_get_data(kaa_list_begin(list))), *number);
kaa_list_destroy(list, NULL);
KAA_TRACE_OUT(logger);
}
void test_list_for_each()
{
KAA_TRACE_IN(logger);
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
int32_t *number1_ptr;
int node_number = 4;
for (int i = 0; i < node_number; ++i) {
number1_ptr = (int32_t *)KAA_MALLOC(sizeof(int32_t *));
ASSERT_NOT_NULL(number1_ptr);
*number1_ptr = rand();
kaa_list_push_back(list, number1_ptr);
}
int number2 = rand();
kaa_list_for_each(kaa_list_begin(list), kaa_list_back(list), (process_data)&test_process_data, &number2);
kaa_list_node_t *it = kaa_list_begin(list);
while (it) {
ASSERT_EQUAL(*(int32_t *)kaa_list_get_data(kaa_list_begin(list)), number2);
it = kaa_list_next(it);
}
kaa_list_destroy(list, NULL);
KAA_TRACE_OUT(logger);
}
static void test_array_get_size(void **state)
{
(void)state;
srand(time(NULL));
ASSERT_EQUAL(kaa_array_get_size(NULL, NULL), 0);
ASSERT_EQUAL(kaa_array_get_size(NULL, (get_size_fn)kaa_null_get_size), avro_long_get_size(0));
const char *plain_str = "data";
kaa_string_t *reference_kaa_str = kaa_string_copy_create(plain_str);
size_t element_size = kaa_string_get_size(reference_kaa_str);
kaa_string_destroy(reference_kaa_str);
size_t array_size = 1 + rand() % 10;
kaa_list_t *avro_array = kaa_list_create();
size_t i = 0;
for (i = 0; i < array_size; ++i) {
kaa_list_push_back(avro_array, kaa_string_copy_create(plain_str));
}
size_t expected_size = avro_long_get_size(array_size)
+ array_size * element_size
+ avro_long_get_size(0);
ASSERT_EQUAL(kaa_array_get_size(avro_array, &kaa_string_get_size), expected_size);
kaa_list_destroy(avro_array, kaa_string_destroy);
}
kaa_error_t ext_log_storage_destroy(void *context)
{
if (context) {
kaa_list_destroy(((mock_storage_context_t *)context)->logs, &destroy_log_record);
KAA_FREE(context);
}
return KAA_ERR_NONE;
}
static void test_list_create()
{
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
ASSERT_EQUAL(kaa_list_get_size(list), 0);
ASSERT_NULL(kaa_list_begin(list));
ASSERT_NULL(kaa_list_back(list));
kaa_list_destroy(list, NULL);
}
static void test_list_empty_sort()
{
/* Purpose of this test is to show that no crash occur if
* list was initially empty.
*/
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
kaa_list_sort(list, &test_kaa_list_predicate);
kaa_list_destroy(list, NULL);
}
static void test_array_deserialize_w_ctx(void **state)
{
(void)state;
const uint8_t plain_fixed[] = { 0x0, 0x1, 0x2, 0x3, 0x4 };
size_t plain_fixed_size = sizeof(plain_fixed) / sizeof(char);
size_t array_size = 1 + rand() % 10;
kaa_list_t *avro_array1 = kaa_list_create();
size_t i = 0;
for (i = 0; i < array_size; ++i) {
kaa_list_push_back(avro_array1, kaa_fixed_copy_create(plain_fixed, plain_fixed_size));
}
size_t buffer_size = kaa_array_get_size(avro_array1, kaa_fixed_get_size);
char buffer[buffer_size];
avro_writer_t avro_writer = avro_writer_memory(buffer, buffer_size);
kaa_array_serialize(avro_writer, avro_array1, kaa_fixed_serialize);
avro_reader_t avro_reader = avro_reader_memory(buffer, buffer_size);
kaa_list_t *avro_array2 = kaa_array_deserialize_w_ctx(avro_reader, (deserialize_w_ctx_fn)kaa_fixed_deserialize, &plain_fixed_size);
ASSERT_NOT_NULL(avro_array2);
ASSERT_EQUAL(kaa_list_get_size(avro_array2), array_size);
kaa_list_node_t *it = kaa_list_begin(avro_array2);
while (it) {
kaa_bytes_t *fixed = kaa_list_get_data(it);
ASSERT_NOT_NULL(fixed);
ASSERT_EQUAL((size_t)fixed->size, plain_fixed_size);
ASSERT_EQUAL(memcmp(fixed->buffer, plain_fixed, plain_fixed_size), 0);
it = kaa_list_next(it);
}
kaa_list_destroy(avro_array2, kaa_fixed_destroy);
avro_reader_free(avro_reader);
avro_writer_free(avro_writer);
kaa_list_destroy(avro_array1, kaa_fixed_destroy);
}
void test_list_create()
{
KAA_TRACE_IN(logger);
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
ASSERT_EQUAL(kaa_list_get_size(list), 0);
ASSERT_NULL(kaa_list_begin(list));
ASSERT_NULL(kaa_list_back(list));
kaa_list_destroy(list, NULL);
KAA_TRACE_OUT(logger);
}
static void test_empty_array_serialize(void **state)
{
(void)state;
size_t empty_array_buffer_size = 1;
char empty_array_buffer[empty_array_buffer_size];
memset(empty_array_buffer, 1 + rand(), empty_array_buffer_size);
avro_writer_t avro_writer = avro_writer_memory(empty_array_buffer, empty_array_buffer_size);
kaa_list_t *empty_array = kaa_list_create();
kaa_array_serialize(avro_writer, empty_array, NULL);
ASSERT_EQUAL((int)empty_array_buffer[0], 0);
kaa_list_destroy(empty_array, NULL);
avro_writer_free(avro_writer);
}
static void test_list_push_back()
{
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
int32_t *number;
int node_number = 2;
for (int i = 0; i < node_number; ++i) {
number = KAA_MALLOC(sizeof(int32_t *));
ASSERT_NOT_NULL(number);
*number = rand();
kaa_list_push_back(list, number);
}
ASSERT_EQUAL(kaa_list_get_size(list), node_number);
ASSERT_EQUAL((*(int32_t *)kaa_list_get_data(kaa_list_back(list))), *number);
kaa_list_destroy(list, NULL);
}
static void test_array_serialize(void **state)
{
(void)state;
const char *plain_str = "data";
kaa_string_t *reference_kaa_str = kaa_string_copy_create(plain_str);
size_t element_size = kaa_string_get_size(reference_kaa_str);
kaa_string_destroy(reference_kaa_str);
size_t array_size = 1 + rand() % 10;
size_t expected_size = avro_long_get_size(array_size)
+ array_size * element_size
+ avro_long_get_size(0);
char manual_buffer[expected_size];
avro_writer_t manual_avro_writer = avro_writer_memory(manual_buffer, expected_size);
avro_binary_encoding.write_long(manual_avro_writer, array_size);
kaa_list_t *avro_array = kaa_list_create();
size_t i = 0;
for (i = 0; i < array_size; ++i) {
kaa_string_t *array_data = kaa_string_copy_create(plain_str);
kaa_list_push_back(avro_array, array_data);
avro_binary_encoding.write_string(manual_avro_writer, array_data->data);
}
avro_binary_encoding.write_long(manual_avro_writer, 0);
size_t actual_size = kaa_array_get_size(avro_array, kaa_string_get_size);
ASSERT_EQUAL(actual_size, expected_size);
char auto_buffer[actual_size];
avro_writer_t auto_avro_writer = avro_writer_memory(auto_buffer, actual_size);
kaa_array_serialize(auto_avro_writer, avro_array, kaa_string_serialize);
ASSERT_EQUAL(memcmp(auto_buffer, manual_buffer, expected_size), 0);
kaa_list_destroy(avro_array, kaa_string_destroy);
avro_writer_free(manual_avro_writer);
avro_writer_free(auto_avro_writer);
}
static void test_list_hash()
{
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
uint64_t node_number = 100;
for (uint64_t i = 0; i < node_number; ++i) {
test_list_node_t *node = KAA_MALLOC(sizeof(test_list_node_t));
ASSERT_NOT_NULL(node);
node->id = (uint64_t) node_number - i;
kaa_list_push_back(list, node);
}
ASSERT_EQUAL(kaa_list_get_size(list), node_number);
kaa_list_sort(list,&test_kaa_list_predicate);
ASSERT_EQUAL(kaa_list_hash(list,&test_kaa_list_hash),-974344717);
kaa_list_destroy(list, NULL);
}
static void test_array_deserialize_wo_ctx(void **state)
{
(void)state;
size_t array_size = 1 + rand() % 10;
kaa_list_t *avro_array1 = kaa_list_create();
size_t i = 0;
for (i = 0; i < array_size; ++i) {
kaa_list_push_back(avro_array1, create_float());
}
size_t buffer_size = kaa_array_get_size(avro_array1, kaa_float_get_size);
char buffer[buffer_size];
avro_writer_t avro_writer = avro_writer_memory(buffer, buffer_size);
kaa_array_serialize(avro_writer, avro_array1, kaa_float_serialize);
avro_reader_t avro_reader = avro_reader_memory(buffer, buffer_size);
kaa_list_t *avro_array2 = kaa_array_deserialize_wo_ctx(avro_reader, (deserialize_wo_ctx_fn)kaa_float_deserialize);
ASSERT_NOT_NULL(avro_array2);
ASSERT_EQUAL(kaa_list_get_size(avro_array2), array_size);
// /*
// * Deserialized array has a back order, so reverse the original.
// */
// kaa_list_t *reverse_avro_array = NULL;
// kaa_list_t *it = avro_array1;
// while (it) {
// if (reverse_avro_array) {
// reverse_avro_array = kaa_list_push_front(reverse_avro_array, kaa_list_get_data(it));
// } else {
// reverse_avro_array = kaa_list_create(kaa_list_get_data(it));
// }
// it = kaa_list_next(it);
// }
//
// kaa_list_destroy(avro_array1, kaa_null_destroy);
// avro_array1 = reverse_avro_array;
/*
* Compare origin and deserialized arrays.
*/
kaa_list_node_t *it1 = kaa_list_begin(avro_array1);
kaa_list_node_t *it2 = kaa_list_begin(avro_array2);
while (it1 && it2) {
float *float_value1 = kaa_list_get_data(it1);
float *float_value2 = kaa_list_get_data(it2);
ASSERT_NOT_NULL(float_value1);
ASSERT_NOT_NULL(float_value2);
ASSERT_EQUAL(*float_value2, *float_value1);
it1 = kaa_list_next(it1);
it2 = kaa_list_next(it2);
}
kaa_list_destroy(avro_array2, kaa_data_destroy);
avro_reader_free(avro_reader);
avro_writer_free(avro_writer);
kaa_list_destroy(avro_array1, kaa_data_destroy);
}
