mirror of
https://github.com/emqx/neuron.git
synced 2026-10-18 21:50:42 +08:00
lixiumei
2482 lines
96 KiB
C++
2482 lines
96 KiB
C++
#include <gtest/gtest.h>
|
|
|
|
#include "neu_data_expr.h"
|
|
#include "neu_types.h"
|
|
|
|
TEST(DataValueTest, neu_dvalue_init_set_get_prim_val)
|
|
{
|
|
neu_data_val_t *val;
|
|
|
|
uint8_t ret_bit;
|
|
int8_t ret_int8;
|
|
int16_t ret_int16;
|
|
int32_t ret_int32;
|
|
int64_t ret_int64;
|
|
|
|
uint8_t ret_uint8;
|
|
uint16_t ret_uint16;
|
|
uint32_t ret_uint32;
|
|
uint64_t ret_uint64;
|
|
|
|
float ret_float;
|
|
double ret_double;
|
|
bool b;
|
|
|
|
/** test bit **/
|
|
val = neu_dvalue_new(NEU_DTYPE_BIT);
|
|
neu_dvalue_init_bit(val, 1);
|
|
EXPECT_EQ(0, neu_dvalue_get_bit(val, &ret_bit));
|
|
EXPECT_EQ(1, ret_bit);
|
|
|
|
neu_dvalue_set_bit(val, 0);
|
|
EXPECT_EQ(0, neu_dvalue_get_bit(val, &ret_bit));
|
|
EXPECT_EQ(0, ret_bit);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test bool **/
|
|
val = neu_dvalue_new(NEU_DTYPE_BOOL);
|
|
neu_dvalue_init_bool(val, true);
|
|
EXPECT_EQ(0, neu_dvalue_get_bool(val, &b));
|
|
EXPECT_EQ(true, b);
|
|
|
|
neu_dvalue_set_bool(val, false);
|
|
EXPECT_EQ(0, neu_dvalue_get_bool(val, &b));
|
|
EXPECT_EQ(false, b);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test int8 **/
|
|
val = neu_dvalue_new(NEU_DTYPE_INT8);
|
|
neu_dvalue_init_int8(val, 16);
|
|
EXPECT_EQ(0, neu_dvalue_get_int8(val, &ret_int8));
|
|
EXPECT_EQ(16, ret_int8);
|
|
|
|
neu_dvalue_set_int8(val, 17);
|
|
EXPECT_EQ(0, neu_dvalue_get_int8(val, &ret_int8));
|
|
EXPECT_EQ(17, ret_int8);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test int16 **/
|
|
val = neu_dvalue_new(NEU_DTYPE_INT16);
|
|
neu_dvalue_init_int16(val, 4096);
|
|
EXPECT_EQ(0, neu_dvalue_get_int16(val, &ret_int16));
|
|
EXPECT_EQ(4096, ret_int16);
|
|
|
|
neu_dvalue_set_int16(val, 32767);
|
|
EXPECT_EQ(0, neu_dvalue_get_int16(val, &ret_int16));
|
|
EXPECT_EQ(32767, ret_int16);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test int32 **/
|
|
val = neu_dvalue_new(NEU_DTYPE_INT32);
|
|
neu_dvalue_init_int32(val, 268435456);
|
|
EXPECT_EQ(0, neu_dvalue_get_int32(val, &ret_int32));
|
|
EXPECT_EQ(268435456, ret_int32);
|
|
|
|
neu_dvalue_set_int32(val, 268435457);
|
|
EXPECT_EQ(0, neu_dvalue_get_int32(val, &ret_int32));
|
|
EXPECT_EQ(268435457, ret_int32);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test int64 **/
|
|
val = neu_dvalue_new(NEU_DTYPE_INT64);
|
|
neu_dvalue_init_int64(val, 100010111010);
|
|
EXPECT_EQ(0, neu_dvalue_get_int64(val, &ret_int64));
|
|
EXPECT_EQ(100010111010, ret_int64);
|
|
|
|
neu_dvalue_set_int64(val, 100010111011);
|
|
EXPECT_EQ(0, neu_dvalue_get_int64(val, &ret_int64));
|
|
EXPECT_EQ(100010111011, ret_int64);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test uint8**/
|
|
val = neu_dvalue_new(NEU_DTYPE_UINT8);
|
|
neu_dvalue_init_uint8(val, 16);
|
|
EXPECT_EQ(0, neu_dvalue_get_uint8(val, &ret_uint8));
|
|
EXPECT_EQ(16, ret_uint8);
|
|
|
|
neu_dvalue_set_uint8(val, 17);
|
|
EXPECT_EQ(0, neu_dvalue_get_uint8(val, &ret_uint8));
|
|
EXPECT_EQ(17, ret_uint8);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test uint16**/
|
|
val = neu_dvalue_new(NEU_DTYPE_UINT16);
|
|
neu_dvalue_init_uint16(val, 4096);
|
|
EXPECT_EQ(0, neu_dvalue_get_uint16(val, &ret_uint16));
|
|
EXPECT_EQ(4096, ret_uint16);
|
|
|
|
neu_dvalue_set_uint16(val, 65535);
|
|
EXPECT_EQ(0, neu_dvalue_get_uint16(val, &ret_uint16));
|
|
EXPECT_EQ(65535, ret_uint16);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test uint32 **/
|
|
val = neu_dvalue_new(NEU_DTYPE_UINT32);
|
|
neu_dvalue_init_uint32(val, 268435456);
|
|
EXPECT_EQ(0, neu_dvalue_get_uint32(val, &ret_uint32));
|
|
EXPECT_EQ(268435456, ret_uint32);
|
|
|
|
neu_dvalue_set_uint32(val, 268435457);
|
|
EXPECT_EQ(0, neu_dvalue_get_uint32(val, &ret_uint32));
|
|
EXPECT_EQ(268435457, ret_uint32);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test uint64 **/
|
|
val = neu_dvalue_new(NEU_DTYPE_UINT64);
|
|
neu_dvalue_init_uint64(val, 100010111010);
|
|
EXPECT_EQ(0, neu_dvalue_get_uint64(val, &ret_uint64));
|
|
EXPECT_EQ(100010111010, ret_uint64);
|
|
|
|
neu_dvalue_set_uint64(val, 100010111011);
|
|
EXPECT_EQ(0, neu_dvalue_get_uint64(val, &ret_uint64));
|
|
EXPECT_EQ(100010111011, ret_uint64);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test float **/
|
|
val = neu_dvalue_new(NEU_DTYPE_FLOAT);
|
|
neu_dvalue_init_float(val, (float) 100.101);
|
|
EXPECT_EQ(0, neu_dvalue_get_float(val, &ret_float));
|
|
EXPECT_EQ((float) 100.101, ret_float);
|
|
|
|
neu_dvalue_set_float(val, (float) 101.101);
|
|
EXPECT_EQ(0, neu_dvalue_get_float(val, &ret_float));
|
|
EXPECT_EQ((float) 101.101, ret_float);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test double **/
|
|
val = neu_dvalue_new(NEU_DTYPE_DOUBLE);
|
|
neu_dvalue_init_double(val, 100010111010.010603);
|
|
EXPECT_EQ(0, neu_dvalue_get_double(val, &ret_double));
|
|
EXPECT_EQ(100010111010.010603, ret_double);
|
|
|
|
neu_dvalue_set_double(val, 100010111010.010604);
|
|
EXPECT_EQ(0, neu_dvalue_get_double(val, &ret_double));
|
|
EXPECT_EQ(100010111010.010604, ret_double);
|
|
neu_dvalue_free(val);
|
|
|
|
/** test errorcode **/
|
|
int32_t ret_error = 0;
|
|
val = neu_dvalue_new(NEU_DTYPE_ERRORCODE);
|
|
neu_dvalue_init_errorcode(val, -1);
|
|
EXPECT_EQ(0, neu_dvalue_get_errorcode(val, &ret_error));
|
|
EXPECT_EQ(NEU_DTYPE_ERRORCODE, neu_dvalue_get_type(val));
|
|
EXPECT_EQ(-1, ret_error);
|
|
|
|
EXPECT_EQ(0, neu_dvalue_set_errorcode(val, 0));
|
|
EXPECT_EQ(0, neu_dvalue_get_errorcode(val, &ret_error));
|
|
EXPECT_EQ(0, ret_error);
|
|
|
|
EXPECT_EQ(0, neu_dvalue_set_errorcode(val, 1));
|
|
EXPECT_EQ(0, neu_dvalue_get_errorcode(val, &ret_error));
|
|
EXPECT_EQ(1, ret_error);
|
|
neu_dvalue_free(val);
|
|
|
|
val = neu_dvalue_new(NEU_DTYPE_ERRORCODE);
|
|
EXPECT_EQ(NEU_DTYPE_ERRORCODE, neu_dvalue_get_type(val));
|
|
EXPECT_EQ(0, neu_dvalue_set_errorcode(val, 2));
|
|
EXPECT_EQ(0, neu_dvalue_get_errorcode(val, &ret_error));
|
|
EXPECT_EQ(2, ret_error);
|
|
neu_dvalue_free(val);
|
|
}
|
|
|
|
#define INT_VAL_TEST_STR "hello int-val"
|
|
#define STRING_KEY_TEST_STR "string-key"
|
|
#define STRING_VAL_TEST_STR "hello string-val"
|
|
TEST(DataValueTest, neu_dvalue_set_get_keyvalue)
|
|
{
|
|
/* teset set/get int_val */
|
|
neu_int_val_t int_val;
|
|
neu_data_val_t *input_val;
|
|
input_val = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_val, (char *) INT_VAL_TEST_STR);
|
|
neu_int_val_init(&int_val, 21, input_val);
|
|
|
|
neu_data_val_t *val;
|
|
int rc;
|
|
val = neu_dvalue_new(NEU_DTYPE_INT_VAL);
|
|
rc = neu_dvalue_set_int_val(val, int_val);
|
|
EXPECT_EQ(0, rc);
|
|
|
|
neu_int_val_t int_val_get;
|
|
char * cstr;
|
|
rc = neu_dvalue_get_int_val(val, &int_val_get);
|
|
EXPECT_EQ(0, rc);
|
|
rc = neu_dvalue_get_ref_cstr(int_val_get.val, &cstr);
|
|
EXPECT_EQ(0, rc);
|
|
EXPECT_STREQ((char *) INT_VAL_TEST_STR, cstr);
|
|
neu_int_val_uninit(&int_val_get);
|
|
neu_dvalue_free(val);
|
|
|
|
/* teset set/get string_val */
|
|
neu_string_t *input_key;
|
|
neu_string_t *test_string;
|
|
// neu_data_val_t* input_val;
|
|
neu_string_val_t string_val;
|
|
input_key = neu_string_from_cstr((char *) STRING_KEY_TEST_STR);
|
|
test_string = neu_string_from_cstr((char *) STRING_VAL_TEST_STR);
|
|
input_val = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_val, test_string);
|
|
neu_string_val_init(&string_val, input_key, input_val);
|
|
|
|
val = neu_dvalue_new(NEU_DTYPE_STRING_VAL);
|
|
rc = neu_dvalue_set_string_val(val, string_val);
|
|
EXPECT_EQ(0, rc);
|
|
|
|
neu_string_val_t string_val_get;
|
|
char * key_cstr;
|
|
char * val_cstr;
|
|
neu_string_t * string_get;
|
|
rc = neu_dvalue_get_string_val(val, &string_val_get);
|
|
EXPECT_EQ(0, rc);
|
|
key_cstr = neu_string_get_ref_cstr(string_val_get.key);
|
|
EXPECT_STREQ((char *) STRING_KEY_TEST_STR, key_cstr);
|
|
rc = neu_dvalue_get_ref_string(string_val_get.val, &string_get);
|
|
EXPECT_EQ(0, rc);
|
|
EXPECT_STREQ((char *) STRING_VAL_TEST_STR,
|
|
neu_string_get_ref_cstr(string_get));
|
|
neu_string_val_uninit(&string_val_get);
|
|
neu_dvalue_free(val);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_set_get_cstr)
|
|
{
|
|
neu_data_val_t *val = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
int rc = neu_dvalue_set_cstr(val, (char *) "Hello, Neuron!");
|
|
EXPECT_EQ(0, rc);
|
|
char *ret = NULL;
|
|
rc = neu_dvalue_get_cstr(val, &ret);
|
|
EXPECT_EQ(0, rc);
|
|
EXPECT_STREQ("Hello, Neuron!", ret);
|
|
free(ret);
|
|
neu_dvalue_free(val);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_set_get_string)
|
|
{
|
|
neu_data_val_t *val = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_string_t * string_set = NULL;
|
|
|
|
// To do
|
|
|
|
neu_dvalue_free(val);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_set_get_bytes)
|
|
{
|
|
neu_data_val_t *val = neu_dvalue_new(NEU_DTYPE_BYTES);
|
|
neu_bytes_t * bytes_set;
|
|
neu_bytes_t * bytes_get;
|
|
int rc;
|
|
|
|
bytes_set = neu_bytes_new(16);
|
|
rc = neu_dvalue_set_bytes(val, bytes_set);
|
|
EXPECT_EQ(0, rc);
|
|
rc = neu_dvalue_get_bytes(val, &bytes_get);
|
|
EXPECT_EQ(0, rc);
|
|
|
|
size_t bytes_length = bytes_set->length;
|
|
EXPECT_EQ(0, memcmp(bytes_set->buf, bytes_get->buf, bytes_length));
|
|
EXPECT_EQ(bytes_set->length, bytes_get->length);
|
|
|
|
neu_bytes_free(bytes_set);
|
|
neu_bytes_free(bytes_get);
|
|
neu_dvalue_free(val);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_set_get_array)
|
|
{
|
|
int rc;
|
|
neu_fixed_array_t *array_set;
|
|
neu_fixed_array_t *array_get;
|
|
neu_fixed_array_t *array_get_ref;
|
|
|
|
int8_t i8_arr[4] = { 2, 7, 1, 8 };
|
|
array_set = neu_fixed_array_new(4, sizeof(int8_t));
|
|
neu_fixed_array_set(array_set, 0, &i8_arr[0]);
|
|
neu_fixed_array_set(array_set, 1, &i8_arr[1]);
|
|
neu_fixed_array_set(array_set, 2, &i8_arr[2]);
|
|
neu_fixed_array_set(array_set, 3, &i8_arr[3]);
|
|
|
|
neu_data_val_t *val = neu_dvalue_unit_new();
|
|
neu_dvalue_init_move_array(val, NEU_DTYPE_INT8, array_set);
|
|
|
|
size_t array_length = array_set->length;
|
|
neu_dvalue_get_ref_array(val, &array_get_ref);
|
|
EXPECT_EQ(0, memcmp(array_set->buf, array_get_ref->buf, array_length));
|
|
EXPECT_EQ(array_set->esize, array_get_ref->esize);
|
|
EXPECT_EQ(array_set->length, array_get_ref->length);
|
|
|
|
rc = neu_dvalue_get_move_array(val, &array_get);
|
|
EXPECT_EQ(0, rc);
|
|
|
|
EXPECT_EQ(0, memcmp(array_set->buf, array_get->buf, array_length));
|
|
EXPECT_EQ(array_set->esize, array_get->esize);
|
|
EXPECT_EQ(array_set->length, array_get->length);
|
|
|
|
neu_fixed_array_free(array_get);
|
|
neu_dvalue_free(val);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_set_get_vec)
|
|
{
|
|
int rc;
|
|
vector_t *vec_set;
|
|
int8_t i8_arr[4] = { 2, 7, 1, 8 };
|
|
vec_set = vector_new(4, sizeof(int8_t));
|
|
vector_push_back(vec_set, &i8_arr[0]);
|
|
vector_push_back(vec_set, &i8_arr[1]);
|
|
vector_push_back(vec_set, &i8_arr[2]);
|
|
vector_push_back(vec_set, &i8_arr[3]);
|
|
|
|
neu_data_val_t *val = neu_dvalue_unit_new();
|
|
neu_dvalue_init_move_vec(val, NEU_DTYPE_INT8, vec_set);
|
|
vector_t *vec_get;
|
|
rc = neu_dvalue_get_move_vec(val, &vec_get);
|
|
|
|
// TODO: assert two vector is equal
|
|
|
|
vector_free(vec_get);
|
|
neu_dvalue_free(val);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_prim_val_deser)
|
|
{
|
|
ssize_t size;
|
|
uint8_t *buf = NULL;
|
|
|
|
neu_data_val_t *val = NULL;
|
|
neu_data_val_t *val1 = NULL;
|
|
|
|
/** bit serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_BIT);
|
|
EXPECT_EQ(0, neu_dvalue_set_bit(val, 1));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
uint8_t bit;
|
|
EXPECT_EQ(0, neu_dvalue_get_bit(val1, &bit));
|
|
EXPECT_EQ(1, bit);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** bool serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_BOOL);
|
|
EXPECT_EQ(0, neu_dvalue_set_bool(val, true));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
bool b;
|
|
EXPECT_EQ(0, neu_dvalue_get_bool(val1, &b));
|
|
EXPECT_EQ(true, b);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** int8 serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_INT8);
|
|
EXPECT_EQ(0, neu_dvalue_set_int8(val, 8));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
int8_t i8;
|
|
EXPECT_EQ(0, neu_dvalue_get_int8(val1, &i8));
|
|
EXPECT_EQ(8, i8);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** int16 serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_INT16);
|
|
EXPECT_EQ(0, neu_dvalue_set_int16(val, 16));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
int16_t i16;
|
|
EXPECT_EQ(0, neu_dvalue_get_int16(val1, &i16));
|
|
EXPECT_EQ(16, i16);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** int32 serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_INT32);
|
|
EXPECT_EQ(0, neu_dvalue_set_int32(val, 32));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
int32_t i32;
|
|
EXPECT_EQ(0, neu_dvalue_get_int32(val1, &i32));
|
|
EXPECT_EQ(32, i32);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** int64 serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_INT64);
|
|
EXPECT_EQ(0, neu_dvalue_set_int64(val, 100));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
int64_t i64;
|
|
EXPECT_EQ(0, neu_dvalue_get_int64(val1, &i64));
|
|
EXPECT_EQ(100, i64);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** uint8 serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_UINT8);
|
|
EXPECT_EQ(0, neu_dvalue_set_uint8(val, 8));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
uint8_t ui8;
|
|
EXPECT_EQ(0, neu_dvalue_get_uint8(val1, &ui8));
|
|
EXPECT_EQ(8, ui8);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** uint16 serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_UINT16);
|
|
EXPECT_EQ(0, neu_dvalue_set_uint16(val, 16));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
uint16_t ui16;
|
|
EXPECT_EQ(0, neu_dvalue_get_uint16(val1, &ui16));
|
|
EXPECT_EQ(16, ui16);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** uint32 serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_UINT32);
|
|
EXPECT_EQ(0, neu_dvalue_set_uint32(val, 32));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
uint32_t ui32;
|
|
EXPECT_EQ(0, neu_dvalue_get_uint32(val1, &ui32));
|
|
EXPECT_EQ(32, ui32);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** uint64 serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_UINT64);
|
|
EXPECT_EQ(0, neu_dvalue_set_uint64(val, 100));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
uint64_t ui64;
|
|
EXPECT_EQ(0, neu_dvalue_get_uint64(val1, &ui64));
|
|
EXPECT_EQ(100, ui64);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** float serialize and deserialize test **/
|
|
val = neu_dvalue_new(NEU_DTYPE_FLOAT);
|
|
EXPECT_EQ(0, neu_dvalue_set_float(val, (float) 3.14159));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
float f32;
|
|
EXPECT_EQ(0, neu_dvalue_get_float(val1, &f32));
|
|
EXPECT_EQ((float) 3.14159, f32);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** double serialize and deserialize **/
|
|
val = neu_dvalue_new(NEU_DTYPE_DOUBLE);
|
|
EXPECT_EQ(0, neu_dvalue_set_double(val, 3.14159265));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
double f64;
|
|
EXPECT_EQ(0, neu_dvalue_get_double(val1, &f64));
|
|
EXPECT_EQ(3.14159265, f64);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_cstr_deser)
|
|
{
|
|
uint8_t *buf = NULL;
|
|
ssize_t size;
|
|
|
|
neu_data_val_t *val = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_data_val_t *val_des;
|
|
char * get_cstr = NULL;
|
|
|
|
EXPECT_EQ(0, neu_dvalue_set_cstr(val, (char *) "Hello, Neuron!"));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val_des);
|
|
EXPECT_LT(0, size);
|
|
EXPECT_EQ(0, neu_dvalue_get_cstr(val_des, &get_cstr));
|
|
EXPECT_STREQ("Hello, Neuron!", get_cstr);
|
|
|
|
free(buf);
|
|
free(get_cstr);
|
|
neu_dvalue_free(val_des);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_keyvalue_deser)
|
|
{
|
|
ssize_t size;
|
|
uint8_t *buf = NULL;
|
|
|
|
neu_data_val_t *val;
|
|
neu_data_val_t *val1;
|
|
|
|
/** test int_val serialize **/
|
|
neu_int_val_t int_val;
|
|
neu_data_val_t *input_val = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_val, (char *) INT_VAL_TEST_STR);
|
|
neu_int_val_init(&int_val, 21, input_val);
|
|
|
|
val = neu_dvalue_new(NEU_DTYPE_INT_VAL);
|
|
EXPECT_EQ(0, neu_dvalue_set_int_val(val, int_val));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
neu_int_val_t int_val_get;
|
|
char * cstr;
|
|
EXPECT_EQ(0, neu_dvalue_get_int_val(val1, &int_val_get));
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(int_val_get.val, &cstr));
|
|
EXPECT_STREQ((char *) INT_VAL_TEST_STR, cstr);
|
|
neu_int_val_uninit(&int_val_get);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val1);
|
|
|
|
/** test string_val serialize **/
|
|
neu_string_val_t string_val;
|
|
neu_string_t * input_key =
|
|
neu_string_from_cstr((char *) STRING_KEY_TEST_STR);
|
|
neu_string_t *test_string =
|
|
neu_string_from_cstr((char *) STRING_VAL_TEST_STR);
|
|
input_val = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_val, test_string);
|
|
neu_string_val_init(&string_val, input_key, input_val);
|
|
|
|
val = neu_dvalue_new(NEU_DTYPE_STRING_VAL);
|
|
EXPECT_EQ(0, neu_dvalue_set_string_val(val, string_val));
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
neu_data_val_t *val_des = NULL;
|
|
size = neu_dvalue_deserialize(buf, size, &val_des);
|
|
neu_string_val_t string_val_get;
|
|
neu_dvalue_get_string_val(val_des, &string_val_get);
|
|
EXPECT_STREQ((char *) STRING_KEY_TEST_STR,
|
|
neu_string_get_ref_cstr(string_val_get.key));
|
|
neu_string_t *string_get = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_string(string_val_get.val, &string_get));
|
|
EXPECT_STREQ((char *) STRING_VAL_TEST_STR,
|
|
neu_string_get_ref_cstr(string_get));
|
|
neu_string_val_uninit(&string_val_get);
|
|
|
|
free(buf);
|
|
neu_dvalue_free(val_des);
|
|
}
|
|
|
|
neu_fixed_array_t *ser_deser_with_fixed_array(neu_fixed_array_t *array_set,
|
|
neu_dtype_e type)
|
|
{
|
|
uint8_t *buf = NULL;
|
|
ssize_t size;
|
|
|
|
neu_data_val_t *val = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(val, type, array_set);
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
neu_data_val_t *val_des;
|
|
EXPECT_LT(0, neu_dvalue_deserialize(buf, size, &val_des));
|
|
neu_fixed_array_t *array_get;
|
|
EXPECT_EQ(0, neu_dvalue_get_move_array(val_des, &array_get));
|
|
|
|
EXPECT_EQ(array_set->esize, array_get->esize);
|
|
EXPECT_EQ(array_set->length, array_get->length);
|
|
|
|
free(buf);
|
|
neu_fixed_array_free(array_set);
|
|
neu_dvalue_free(val_des);
|
|
|
|
return array_get;
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_array_deser)
|
|
{
|
|
/** int64 **/
|
|
int64_t i64_arr[4] = { 2, 7, 1, 8 };
|
|
neu_fixed_array_t *set_array_int = neu_fixed_array_new(4, sizeof(int64_t));
|
|
neu_fixed_array_set(set_array_int, 0, &i64_arr[0]);
|
|
neu_fixed_array_set(set_array_int, 1, &i64_arr[1]);
|
|
neu_fixed_array_set(set_array_int, 2, &i64_arr[2]);
|
|
neu_fixed_array_set(set_array_int, 3, &i64_arr[3]);
|
|
|
|
neu_fixed_array_t *get_array_int =
|
|
ser_deser_with_fixed_array(set_array_int, NEU_DTYPE_INT64);
|
|
int64_t *int_get1 = (int64_t *) neu_fixed_array_get(get_array_int, 0);
|
|
EXPECT_EQ(2, *int_get1);
|
|
int64_t *int_get2 = (int64_t *) neu_fixed_array_get(get_array_int, 1);
|
|
EXPECT_EQ(7, *int_get2);
|
|
int64_t *int_get3 = (int64_t *) neu_fixed_array_get(get_array_int, 2);
|
|
EXPECT_EQ(1, *int_get3);
|
|
int64_t *int_get4 = (int64_t *) neu_fixed_array_get(get_array_int, 3);
|
|
EXPECT_EQ(8, *int_get4);
|
|
neu_fixed_array_free(get_array_int);
|
|
|
|
/** double **/
|
|
double double_arr[4] = { 0.11, 0.222, 0.3333, 0.4444 };
|
|
neu_fixed_array_t *set_array_double =
|
|
neu_fixed_array_new(4, sizeof(double));
|
|
neu_fixed_array_set(set_array_double, 0, &double_arr[0]);
|
|
neu_fixed_array_set(set_array_double, 1, &double_arr[1]);
|
|
neu_fixed_array_set(set_array_double, 2, &double_arr[2]);
|
|
neu_fixed_array_set(set_array_double, 3, &double_arr[3]);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_double =
|
|
ser_deser_with_fixed_array(set_array_double, NEU_DTYPE_DOUBLE);
|
|
|
|
/** Compare **/
|
|
double *double_get1 = (double *) neu_fixed_array_get(get_array_double, 0);
|
|
EXPECT_EQ(0.11, *double_get1);
|
|
double *double_get2 = (double *) neu_fixed_array_get(get_array_double, 1);
|
|
EXPECT_EQ(0.222, *double_get2);
|
|
double *double_get3 = (double *) neu_fixed_array_get(get_array_double, 2);
|
|
EXPECT_EQ(0.3333, *double_get3);
|
|
double *double_get4 = (double *) neu_fixed_array_get(get_array_double, 3);
|
|
EXPECT_EQ(0.4444, *double_get4);
|
|
neu_fixed_array_free(get_array_double);
|
|
|
|
/** cstr **/
|
|
char *cstr_arr1 = (char *) "Hello,cstr-test1";
|
|
char *cstr_arr2 = (char *) "Hello,cstr-test2";
|
|
char *cstr_arr3 = (char *) "Hello,cstr-test3";
|
|
char *cstr_arr4 = (char *) "Hello,cstr-test4";
|
|
|
|
neu_fixed_array_t *set_array_cstr = neu_fixed_array_new(4, sizeof(char *));
|
|
neu_fixed_array_set(set_array_cstr, 0, &cstr_arr1);
|
|
neu_fixed_array_set(set_array_cstr, 1, &cstr_arr2);
|
|
neu_fixed_array_set(set_array_cstr, 2, &cstr_arr3);
|
|
neu_fixed_array_set(set_array_cstr, 3, &cstr_arr4);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_cstr =
|
|
ser_deser_with_fixed_array(set_array_cstr, NEU_DTYPE_CSTR);
|
|
|
|
/** Compare **/
|
|
char *cstr_get1 = *(char **) neu_fixed_array_get(get_array_cstr, 0);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test1", cstr_get1);
|
|
char *cstr_get2 = *(char **) neu_fixed_array_get(get_array_cstr, 1);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test2", cstr_get2);
|
|
char *cstr_get3 = *(char **) neu_fixed_array_get(get_array_cstr, 2);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test3", cstr_get3);
|
|
char *cstr_get4 = *(char **) neu_fixed_array_get(get_array_cstr, 3);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test4", cstr_get4);
|
|
free(cstr_get1);
|
|
free(cstr_get2);
|
|
free(cstr_get3);
|
|
free(cstr_get4);
|
|
neu_fixed_array_free(get_array_cstr);
|
|
|
|
/** int_val **/
|
|
/** the fist element **/
|
|
neu_int_val_t int_val1;
|
|
neu_data_val_t *input_val1 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_val1, (char *) "hello,int-val1");
|
|
neu_int_val_init(&int_val1, 21, input_val1);
|
|
|
|
/** the second element **/
|
|
neu_int_val_t int_val2;
|
|
neu_data_val_t *input_val2;
|
|
input_val2 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_val2, (char *) "hello,int-val2");
|
|
neu_int_val_init(&int_val2, 22, input_val2);
|
|
|
|
/** set array **/
|
|
neu_fixed_array_t *set_array_int_val =
|
|
neu_fixed_array_new(2, sizeof(neu_int_val_t));
|
|
neu_fixed_array_set(set_array_int_val, 0, &int_val1);
|
|
neu_fixed_array_set(set_array_int_val, 1, &int_val2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_int_val =
|
|
ser_deser_with_fixed_array(set_array_int_val, NEU_DTYPE_INT_VAL);
|
|
|
|
/** Compare the first int_val element **/
|
|
neu_int_val_t *get_int_val1 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array_int_val, 0);
|
|
EXPECT_EQ(21, get_int_val1->key);
|
|
char *cstr1 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val1->val, &cstr1));
|
|
EXPECT_STREQ((char *) "hello,int-val1", cstr1);
|
|
neu_int_val_uninit(get_int_val1);
|
|
|
|
/** Compare the second int_val element **/
|
|
neu_int_val_t *get_int_val2 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array_int_val, 1);
|
|
EXPECT_EQ(22, get_int_val2->key);
|
|
char *cstr2 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val2->val, &cstr2));
|
|
EXPECT_STREQ((char *) "hello,int-val2", cstr2);
|
|
neu_int_val_uninit(get_int_val2);
|
|
|
|
neu_fixed_array_free(get_array_int_val);
|
|
|
|
neu_dvalue_free(input_val1);
|
|
neu_dvalue_free(input_val2);
|
|
|
|
/** string_val **/
|
|
/** the fist element **/
|
|
neu_string_t *input_str_key1 = neu_string_from_cstr((char *) "string-key1");
|
|
neu_string_t *test_string1 =
|
|
neu_string_from_cstr((char *) "hello,string-val1");
|
|
neu_data_val_t *input_str_val1 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_val1, test_string1);
|
|
neu_string_val_t string_val1;
|
|
neu_string_val_init(&string_val1, input_str_key1, input_str_val1);
|
|
|
|
/** the second element **/
|
|
neu_string_t *input_str_key2 = neu_string_from_cstr((char *) "string-key2");
|
|
neu_string_t *test_string2 =
|
|
neu_string_from_cstr((char *) "hello,string-val2");
|
|
neu_data_val_t *input_str_val2 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_val2, test_string2);
|
|
neu_string_val_t string_val2;
|
|
neu_string_val_init(&string_val2, input_str_key2, input_str_val2);
|
|
|
|
/** set array **/
|
|
neu_fixed_array_t *set_array_str_val =
|
|
neu_fixed_array_new(2, sizeof(neu_string_val_t));
|
|
neu_fixed_array_set(set_array_str_val, 0, &string_val1);
|
|
neu_fixed_array_set(set_array_str_val, 1, &string_val2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_str_val =
|
|
ser_deser_with_fixed_array(set_array_str_val, NEU_DTYPE_STRING_VAL);
|
|
|
|
/** Compare the first str_val element **/
|
|
neu_string_val_t *get_str_val1 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array_str_val, 0);
|
|
|
|
EXPECT_STREQ((char *) "string-key1",
|
|
neu_string_get_ref_cstr(get_str_val1->key));
|
|
neu_string_t *string_get1 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val1->val, &string_get1));
|
|
EXPECT_STREQ((char *) "hello,string-val1",
|
|
neu_string_get_ref_cstr(string_get1));
|
|
neu_string_val_uninit(get_str_val1);
|
|
|
|
/** Compare the second str_val element **/
|
|
neu_string_val_t *get_str_val2 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array_str_val, 1);
|
|
|
|
EXPECT_STREQ((char *) "string-key2",
|
|
neu_string_get_ref_cstr(get_str_val2->key));
|
|
neu_string_t *string_get2 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val2->val, &string_get2));
|
|
EXPECT_STREQ((char *) "hello,string-val2",
|
|
neu_string_get_ref_cstr(string_get2));
|
|
neu_string_val_uninit(get_str_val2);
|
|
|
|
neu_fixed_array_free(get_array_str_val);
|
|
|
|
neu_dvalue_free(input_str_val1);
|
|
neu_dvalue_free(input_str_val2);
|
|
|
|
neu_string_free(input_str_key1);
|
|
neu_string_free(input_str_key2);
|
|
}
|
|
|
|
void comp_arr_2d_int(neu_fixed_array_t *get_array_int)
|
|
{
|
|
/** Compare the first element of 2D array **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_int, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
int64_t *get_int11 = (int64_t *) neu_fixed_array_get(get_array1, 0);
|
|
EXPECT_EQ(3, *get_int11);
|
|
int64_t *get_int12 = (int64_t *) neu_fixed_array_get(get_array1, 1);
|
|
EXPECT_EQ(2, *get_int12);
|
|
int64_t *get_int13 = (int64_t *) neu_fixed_array_get(get_array1, 2);
|
|
EXPECT_EQ(1, *get_int13);
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
|
|
/** Compare the second element of 2D array **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_int, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
int64_t *get_int21 = (int64_t *) neu_fixed_array_get(get_array2, 0);
|
|
EXPECT_EQ(6, *get_int21);
|
|
int64_t *get_int22 = (int64_t *) neu_fixed_array_get(get_array2, 1);
|
|
EXPECT_EQ(5, *get_int22);
|
|
int64_t *get_int23 = (int64_t *) neu_fixed_array_get(get_array2, 2);
|
|
EXPECT_EQ(4, *get_int23);
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
|
|
neu_fixed_array_free(get_array_int);
|
|
}
|
|
|
|
void comp_arr_2d_double(neu_fixed_array_t *get_array_double)
|
|
{
|
|
/** Compare the first element **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_double, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
double *get_double11 = (double *) neu_fixed_array_get(get_array1, 0);
|
|
EXPECT_EQ(0.3, *get_double11);
|
|
double *get_double12 = (double *) neu_fixed_array_get(get_array1, 1);
|
|
EXPECT_EQ(0.2, *get_double12);
|
|
double *get_double13 = (double *) neu_fixed_array_get(get_array1, 2);
|
|
EXPECT_EQ(0.1, *get_double13);
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
|
|
/** Compare the second element **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_double, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
double *get_double21 = (double *) neu_fixed_array_get(get_array2, 0);
|
|
EXPECT_EQ(0.66, *get_double21);
|
|
double *get_double22 = (double *) neu_fixed_array_get(get_array2, 1);
|
|
EXPECT_EQ(0.555, *get_double22);
|
|
double *get_double23 = (double *) neu_fixed_array_get(get_array2, 2);
|
|
EXPECT_EQ(0.4444, *get_double23);
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
|
|
neu_fixed_array_free(get_array_double);
|
|
}
|
|
|
|
void comp_arr_2d_int_val(neu_fixed_array_t *get_array_int_val)
|
|
{
|
|
/** Compare the first element of 2D array **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_int_val, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
|
|
/** Compare the first element of 1D array1 **/
|
|
neu_int_val_t *get_int_val11 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array1, 0);
|
|
EXPECT_EQ(21, get_int_val11->key);
|
|
char *output_val11 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val11->val, &output_val11));
|
|
EXPECT_STREQ((char *) "hello,int-val1", output_val11);
|
|
neu_int_val_uninit(get_int_val11);
|
|
|
|
/** Compare the second element of 1D array1 **/
|
|
neu_int_val_t *get_int_val12 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array1, 1);
|
|
EXPECT_EQ(22, get_int_val12->key);
|
|
char *output_val12 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val12->val, &output_val12));
|
|
EXPECT_STREQ((char *) "hello,int-val2", output_val12);
|
|
neu_int_val_uninit(get_int_val12);
|
|
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
|
|
/** Compare the second element of 2D array **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_int_val, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
|
|
/** Compare the first element of 1D array2 **/
|
|
neu_int_val_t *get_int_val21 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array2, 0);
|
|
EXPECT_EQ(23, get_int_val21->key);
|
|
char *output_val21 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val21->val, &output_val21));
|
|
EXPECT_STREQ((char *) "hello,int-val3", output_val21);
|
|
neu_int_val_uninit(get_int_val21);
|
|
|
|
/** Compare the second element of 1D array2 **/
|
|
neu_int_val_t *get_int_val22 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array2, 1);
|
|
EXPECT_EQ(24, get_int_val22->key);
|
|
char *output_val22 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val22->val, &output_val22));
|
|
EXPECT_STREQ((char *) "hello,int-val4", output_val22);
|
|
neu_int_val_uninit(get_int_val22);
|
|
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
|
|
neu_fixed_array_free(get_array_int_val);
|
|
}
|
|
|
|
void comp_arr_2d_str_val(neu_fixed_array_t *get_array_str_val)
|
|
{
|
|
/** Compare the first element of 2D array **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_str_val, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
|
|
/** Compare the first str_val element of 1D array1 **/
|
|
neu_string_val_t *get_str_val11 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array1, 0);
|
|
|
|
EXPECT_STREQ((char *) "string-key1",
|
|
neu_string_get_ref_cstr(get_str_val11->key));
|
|
neu_string_t *get_string11 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val11->val, &get_string11));
|
|
EXPECT_STREQ((char *) "hello,string-val1",
|
|
neu_string_get_ref_cstr(get_string11));
|
|
neu_string_val_uninit(get_str_val11);
|
|
|
|
/** Compare the second str_val element of 1D array1 **/
|
|
neu_string_val_t *get_str_val12 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array1, 1);
|
|
|
|
EXPECT_STREQ((char *) "string-key2",
|
|
neu_string_get_ref_cstr(get_str_val12->key));
|
|
neu_string_t *get_string12 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val12->val, &get_string12));
|
|
EXPECT_STREQ((char *) "hello,string-val2",
|
|
neu_string_get_ref_cstr(get_string12));
|
|
neu_string_val_uninit(get_str_val12);
|
|
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
|
|
/** Compare the second element of 2D array **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_str_val, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
|
|
/** Compare the first str_val element of 1D array2 **/
|
|
neu_string_val_t *get_str_val21 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array2, 0);
|
|
|
|
EXPECT_STREQ((char *) "string-key3",
|
|
neu_string_get_ref_cstr(get_str_val21->key));
|
|
neu_string_t *get_string21 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val21->val, &get_string21));
|
|
EXPECT_STREQ((char *) "hello,string-val3",
|
|
neu_string_get_ref_cstr(get_string21));
|
|
neu_string_val_uninit(get_str_val21);
|
|
|
|
/** Compare the second str_val element of 1D array1 **/
|
|
neu_string_val_t *get_str_val22 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array2, 1);
|
|
|
|
EXPECT_STREQ((char *) "string-key4",
|
|
neu_string_get_ref_cstr(get_str_val22->key));
|
|
neu_string_t *get_string22 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val22->val, &get_string22));
|
|
EXPECT_STREQ((char *) "hello,string-val4",
|
|
neu_string_get_ref_cstr(get_string22));
|
|
neu_string_val_uninit(get_str_val22);
|
|
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
|
|
neu_fixed_array_free(get_array_str_val);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_2D_array_deser)
|
|
{
|
|
/** int64 **/
|
|
/** set array **/
|
|
int64_t i64_arr[2][3] = { { 3, 2, 1 }, { 6, 5, 4 } };
|
|
|
|
neu_fixed_array_t *set_int_array1 = neu_fixed_array_new(3, sizeof(int64_t));
|
|
neu_fixed_array_set(set_int_array1, 0, &i64_arr[0][0]);
|
|
neu_fixed_array_set(set_int_array1, 1, &i64_arr[0][1]);
|
|
neu_fixed_array_set(set_int_array1, 2, &i64_arr[0][2]);
|
|
neu_data_val_t *array_int_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_dval1, NEU_DTYPE_INT64, set_int_array1);
|
|
|
|
neu_fixed_array_t *set_int_array2 = neu_fixed_array_new(3, sizeof(int64_t));
|
|
neu_fixed_array_set(set_int_array2, 0, &i64_arr[1][0]);
|
|
neu_fixed_array_set(set_int_array2, 1, &i64_arr[1][1]);
|
|
neu_fixed_array_set(set_int_array2, 2, &i64_arr[1][2]);
|
|
neu_data_val_t *array_int_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_dval2, NEU_DTYPE_INT64, set_int_array2);
|
|
|
|
neu_fixed_array_t *set_int_array =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_int_array, 0, &array_int_dval1);
|
|
neu_fixed_array_set(set_int_array, 1, &array_int_dval2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_int_array =
|
|
ser_deser_with_fixed_array(set_int_array, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** free **/
|
|
neu_fixed_array_free(set_int_array1);
|
|
neu_fixed_array_free(set_int_array2);
|
|
|
|
neu_dvalue_free(array_int_dval1);
|
|
neu_dvalue_free(array_int_dval2);
|
|
|
|
/** Compare **/
|
|
comp_arr_2d_int(get_int_array);
|
|
|
|
/** double **/
|
|
/** set array **/
|
|
double double_arr[2][3] = { { 0.3, 0.2, 0.1 }, { 0.66, 0.555, 0.4444 } };
|
|
|
|
/** set the first elem**/
|
|
neu_fixed_array_t *set_double_array1 =
|
|
neu_fixed_array_new(3, sizeof(double));
|
|
neu_fixed_array_set(set_double_array1, 0, &double_arr[0][0]);
|
|
neu_fixed_array_set(set_double_array1, 1, &double_arr[0][1]);
|
|
neu_fixed_array_set(set_double_array1, 2, &double_arr[0][2]);
|
|
neu_data_val_t *array_double_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_double_dval1, NEU_DTYPE_DOUBLE,
|
|
set_double_array1);
|
|
|
|
neu_fixed_array_t *set_double_array2 =
|
|
neu_fixed_array_new(3, sizeof(double));
|
|
neu_fixed_array_set(set_double_array2, 0, &double_arr[1][0]);
|
|
neu_fixed_array_set(set_double_array2, 1, &double_arr[1][1]);
|
|
neu_fixed_array_set(set_double_array2, 2, &double_arr[1][2]);
|
|
neu_data_val_t *array_double_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_double_dval2, NEU_DTYPE_DOUBLE,
|
|
set_double_array2);
|
|
|
|
neu_fixed_array_t *set_double_array =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_double_array, 0, &array_double_dval1);
|
|
neu_fixed_array_set(set_double_array, 1, &array_double_dval2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_double_array =
|
|
ser_deser_with_fixed_array(set_double_array, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** free **/
|
|
neu_fixed_array_free(set_double_array1);
|
|
neu_fixed_array_free(set_double_array2);
|
|
|
|
neu_dvalue_free(array_double_dval1);
|
|
neu_dvalue_free(array_double_dval2);
|
|
|
|
/** Compare **/
|
|
comp_arr_2d_double(get_double_array);
|
|
|
|
/** int_val **/
|
|
/** the fist element of 1D array **/
|
|
neu_data_val_t *input_int_val11 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val11, (char *) "hello,int-val1");
|
|
neu_int_val_t int_val11;
|
|
neu_int_val_init(&int_val11, 21, input_int_val11);
|
|
|
|
/** the second element of 1D array **/
|
|
neu_data_val_t *input_int_val12 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val12, (char *) "hello,int-val2");
|
|
neu_int_val_t int_val12;
|
|
neu_int_val_init(&int_val12, 22, input_int_val12);
|
|
|
|
/** set the first element of 2D array **/
|
|
neu_fixed_array_t *set_int_val_array1 =
|
|
neu_fixed_array_new(2, sizeof(neu_int_val_t));
|
|
neu_fixed_array_set(set_int_val_array1, 0, &int_val11);
|
|
neu_fixed_array_set(set_int_val_array1, 1, &int_val12);
|
|
|
|
neu_data_val_t *array_int_val_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_val_dval1, NEU_DTYPE_INT_VAL,
|
|
set_int_val_array1);
|
|
|
|
/** the third element of 1D array **/
|
|
neu_data_val_t *input_int_val21 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val21, (char *) "hello,int-val3");
|
|
neu_int_val_t int_val21;
|
|
neu_int_val_init(&int_val21, 23, input_int_val21);
|
|
|
|
/** the fourth element of 1D array **/
|
|
neu_data_val_t *input_int_val22 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val22, (char *) "hello,int-val4");
|
|
neu_int_val_t int_val22;
|
|
neu_int_val_init(&int_val22, 24, input_int_val22);
|
|
|
|
/** set the second element of 2D array **/
|
|
neu_fixed_array_t *set_int_val_array2 =
|
|
neu_fixed_array_new(2, sizeof(neu_int_val_t));
|
|
neu_fixed_array_set(set_int_val_array2, 0, &int_val21);
|
|
neu_fixed_array_set(set_int_val_array2, 1, &int_val22);
|
|
|
|
neu_data_val_t *array_int_val_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_val_dval2, NEU_DTYPE_INT_VAL,
|
|
set_int_val_array2);
|
|
|
|
/** set int_val 2D array **/
|
|
neu_fixed_array_t *set_arr_2d_int_val =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_arr_2d_int_val, 0, &array_int_val_dval1);
|
|
neu_fixed_array_set(set_arr_2d_int_val, 1, &array_int_val_dval2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_int_val =
|
|
ser_deser_with_fixed_array(set_arr_2d_int_val, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** free **/
|
|
neu_dvalue_free(input_int_val11);
|
|
neu_dvalue_free(input_int_val12);
|
|
neu_dvalue_free(input_int_val21);
|
|
neu_dvalue_free(input_int_val22);
|
|
neu_fixed_array_free(set_int_val_array1);
|
|
neu_dvalue_free(array_int_val_dval1);
|
|
neu_fixed_array_free(set_int_val_array2);
|
|
neu_dvalue_free(array_int_val_dval2);
|
|
|
|
/* Compare **/
|
|
comp_arr_2d_int_val(get_array_int_val);
|
|
|
|
/** string_val **/
|
|
/** set the first element of 1D array **/
|
|
neu_string_t *input_str_key1 = neu_string_from_cstr((char *) "string-key1");
|
|
neu_string_t *test_string1 =
|
|
neu_string_from_cstr((char *) "hello,string-val1");
|
|
neu_data_val_t *input_str_dval1 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval1, test_string1);
|
|
neu_string_val_t string_val1;
|
|
neu_string_val_init(&string_val1, input_str_key1, input_str_dval1);
|
|
|
|
/** set the second element of 1D array **/
|
|
neu_string_t *input_str_key2 = neu_string_from_cstr((char *) "string-key2");
|
|
neu_string_t *test_string2 =
|
|
neu_string_from_cstr((char *) "hello,string-val2");
|
|
neu_data_val_t *input_str_dval2 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval2, test_string2);
|
|
neu_string_val_t string_val2;
|
|
neu_string_val_init(&string_val2, input_str_key2, input_str_dval2);
|
|
|
|
/** set the first element of 2D array **/
|
|
neu_fixed_array_t *set_str_val_array1 =
|
|
neu_fixed_array_new(2, sizeof(neu_string_val_t));
|
|
neu_fixed_array_set(set_str_val_array1, 0, &string_val1);
|
|
neu_fixed_array_set(set_str_val_array1, 1, &string_val2);
|
|
|
|
neu_data_val_t *arr_2d_str_val_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(arr_2d_str_val_dval1, NEU_DTYPE_STRING_VAL,
|
|
set_str_val_array1);
|
|
|
|
/** set the third element of 1D array **/
|
|
neu_string_t *input_str_key3 = neu_string_from_cstr((char *) "string-key3");
|
|
neu_string_t *test_string3 =
|
|
neu_string_from_cstr((char *) "hello,string-val3");
|
|
neu_data_val_t *input_str_dval3 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval3, test_string3);
|
|
neu_string_val_t string_val3;
|
|
neu_string_val_init(&string_val3, input_str_key3, input_str_dval3);
|
|
|
|
/** set the fourth element of 1D array **/
|
|
neu_string_t *input_str_key4 = neu_string_from_cstr((char *) "string-key4");
|
|
neu_string_t *test_string4 =
|
|
neu_string_from_cstr((char *) "hello,string-val4");
|
|
neu_data_val_t *input_str_dval4 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval4, test_string4);
|
|
neu_string_val_t string_val4;
|
|
neu_string_val_init(&string_val4, input_str_key4, input_str_dval4);
|
|
|
|
/** set the second element of 2D array **/
|
|
neu_fixed_array_t *set_str_val_array2 =
|
|
neu_fixed_array_new(2, sizeof(neu_string_val_t));
|
|
neu_fixed_array_set(set_str_val_array2, 0, &string_val3);
|
|
neu_fixed_array_set(set_str_val_array2, 1, &string_val4);
|
|
|
|
neu_data_val_t *arr_2d_str_val_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(arr_2d_str_val_dval2, NEU_DTYPE_STRING_VAL,
|
|
set_str_val_array2);
|
|
|
|
/** set string_val 2D array **/
|
|
neu_fixed_array_t *set_arr_2d_str_val =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_arr_2d_str_val, 0, &arr_2d_str_val_dval1);
|
|
neu_fixed_array_set(set_arr_2d_str_val, 1, &arr_2d_str_val_dval2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_str_val =
|
|
ser_deser_with_fixed_array(set_arr_2d_str_val, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** free **/
|
|
neu_string_free(input_str_key1);
|
|
neu_dvalue_free(input_str_dval1);
|
|
|
|
neu_string_free(input_str_key2);
|
|
neu_dvalue_free(input_str_dval2);
|
|
|
|
neu_string_free(input_str_key3);
|
|
neu_dvalue_free(input_str_dval3);
|
|
|
|
neu_string_free(input_str_key4);
|
|
neu_dvalue_free(input_str_dval4);
|
|
|
|
neu_fixed_array_free(set_str_val_array1);
|
|
neu_fixed_array_free(set_str_val_array2);
|
|
neu_dvalue_free(arr_2d_str_val_dval1);
|
|
neu_dvalue_free(arr_2d_str_val_dval2);
|
|
|
|
/** Compare **/
|
|
comp_arr_2d_str_val(get_array_str_val);
|
|
|
|
/** cstr **/
|
|
/** set array **/
|
|
char *cstr1 = (char *) "Hello,cstr-test1";
|
|
char *cstr2 = (char *) "Hello,cstr-test2";
|
|
char *cstr3 = (char *) "Hello,cstr-test3";
|
|
char *cstr4 = (char *) "Hello,cstr-test4";
|
|
|
|
neu_fixed_array_t *set_cstr_array1 = neu_fixed_array_new(2, sizeof(char *));
|
|
neu_fixed_array_set(set_cstr_array1, 0, &cstr1);
|
|
neu_fixed_array_set(set_cstr_array1, 1, &cstr2);
|
|
neu_data_val_t *array_cstr_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_cstr_dval1, NEU_DTYPE_CSTR,
|
|
set_cstr_array1);
|
|
|
|
neu_fixed_array_t *set_cstr_array2 = neu_fixed_array_new(2, sizeof(char *));
|
|
neu_fixed_array_set(set_cstr_array2, 0, &cstr3);
|
|
neu_fixed_array_set(set_cstr_array2, 1, &cstr4);
|
|
neu_data_val_t *array_cstr_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_cstr_dval2, NEU_DTYPE_CSTR,
|
|
set_cstr_array2);
|
|
|
|
neu_fixed_array_t *set_cstr_array =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_cstr_array, 0, &array_cstr_dval1);
|
|
neu_fixed_array_set(set_cstr_array, 1, &array_cstr_dval2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_cstr_array =
|
|
ser_deser_with_fixed_array(set_cstr_array, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** Compare the first element of 2D array **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_cstr_array, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
char *get_cstr1 = *(char **) neu_fixed_array_get(get_array1, 0);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test1", get_cstr1);
|
|
char *get_cstr2 = *(char **) neu_fixed_array_get(get_array1, 1);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test2", get_cstr2);
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
free(get_cstr1);
|
|
free(get_cstr2);
|
|
|
|
/** Compare the second element of 2D array **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_cstr_array, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
char *get_cstr3 = *(char **) neu_fixed_array_get(get_array2, 0);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test3", get_cstr3);
|
|
char *get_cstr4 = *(char **) neu_fixed_array_get(get_array2, 1);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test4", get_cstr4);
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
free(get_cstr3);
|
|
free(get_cstr4);
|
|
|
|
neu_fixed_array_free(get_cstr_array);
|
|
|
|
/** free **/
|
|
neu_fixed_array_free(set_cstr_array1);
|
|
neu_fixed_array_free(set_cstr_array2);
|
|
|
|
neu_dvalue_free(array_cstr_dval1);
|
|
neu_dvalue_free(array_cstr_dval2);
|
|
}
|
|
|
|
void comp_arr_3d_int(neu_fixed_array_t *get_array_int)
|
|
{
|
|
/** Get the first element of the 3D array **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_int, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
|
|
/** Get the first element of the first 2D array **/
|
|
neu_data_val_t *get_array_dval11 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 0);
|
|
neu_fixed_array_t *get_array11 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval11, &get_array11);
|
|
int64_t *int_get111 = (int64_t *) neu_fixed_array_get(get_array11, 0);
|
|
EXPECT_EQ(1, *int_get111);
|
|
int64_t *int_get112 = (int64_t *) neu_fixed_array_get(get_array11, 1);
|
|
EXPECT_EQ(2, *int_get112);
|
|
int64_t *int_get113 = (int64_t *) neu_fixed_array_get(get_array11, 2);
|
|
EXPECT_EQ(3, *int_get113);
|
|
neu_fixed_array_free(get_array11);
|
|
neu_dvalue_free(get_array_dval11);
|
|
|
|
/** Get the second element of the first 2D array **/
|
|
neu_data_val_t *get_array_dval12 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 1);
|
|
neu_fixed_array_t *get_array12 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval12, &get_array12);
|
|
int64_t *int_get121 = (int64_t *) neu_fixed_array_get(get_array12, 0);
|
|
EXPECT_EQ(11, *int_get121);
|
|
int64_t *int_get122 = (int64_t *) neu_fixed_array_get(get_array12, 1);
|
|
EXPECT_EQ(22, *int_get122);
|
|
int64_t *int_get123 = (int64_t *) neu_fixed_array_get(get_array12, 2);
|
|
EXPECT_EQ(33, *int_get123);
|
|
neu_fixed_array_free(get_array12);
|
|
neu_dvalue_free(get_array_dval12);
|
|
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
|
|
/** Get the second element of the 3D array **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_int, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
|
|
/** Get the first element of the second 2D array **/
|
|
neu_data_val_t *get_array_dval21 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 0);
|
|
neu_fixed_array_t *get_array21 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval21, &get_array21);
|
|
int64_t *int_get311 = (int64_t *) neu_fixed_array_get(get_array21, 0);
|
|
EXPECT_EQ(5, *int_get311);
|
|
int64_t *int_get312 = (int64_t *) neu_fixed_array_get(get_array21, 1);
|
|
EXPECT_EQ(6, *int_get312);
|
|
int64_t *int_get313 = (int64_t *) neu_fixed_array_get(get_array21, 2);
|
|
EXPECT_EQ(7, *int_get313);
|
|
neu_fixed_array_free(get_array21);
|
|
neu_dvalue_free(get_array_dval21);
|
|
|
|
/** Get the second element of the second 2D array **/
|
|
neu_data_val_t *get_array_dval22 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 1);
|
|
neu_fixed_array_t *get_array22 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval22, &get_array22);
|
|
int64_t *int_get321 = (int64_t *) neu_fixed_array_get(get_array22, 0);
|
|
EXPECT_EQ(55, *int_get321);
|
|
int64_t *int_get322 = (int64_t *) neu_fixed_array_get(get_array22, 1);
|
|
EXPECT_EQ(66, *int_get322);
|
|
int64_t *int_get323 = (int64_t *) neu_fixed_array_get(get_array22, 2);
|
|
EXPECT_EQ(77, *int_get323);
|
|
neu_fixed_array_free(get_array22);
|
|
neu_dvalue_free(get_array_dval22);
|
|
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
|
|
neu_fixed_array_free(get_array_int);
|
|
}
|
|
|
|
void comp_arr_3d_double(neu_fixed_array_t *get_array_double)
|
|
{
|
|
/** Get the first element of the 3D array **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_double, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
|
|
/** Get the first element of the first 2D array **/
|
|
neu_data_val_t *get_array_dval11 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 0);
|
|
neu_fixed_array_t *get_array11 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval11, &get_array11);
|
|
double *get_double111 = (double *) neu_fixed_array_get(get_array11, 0);
|
|
EXPECT_EQ(0.11, *get_double111);
|
|
double *get_double112 = (double *) neu_fixed_array_get(get_array11, 1);
|
|
EXPECT_EQ(0.22, *get_double112);
|
|
double *get_double113 = (double *) neu_fixed_array_get(get_array11, 2);
|
|
EXPECT_EQ(0.33, *get_double113);
|
|
neu_fixed_array_free(get_array11);
|
|
neu_dvalue_free(get_array_dval11);
|
|
|
|
/** Get the second element of the first 2D array **/
|
|
neu_data_val_t *get_array_dval12 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 1);
|
|
neu_fixed_array_t *get_array12 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval12, &get_array12);
|
|
double *get_double121 = (double *) neu_fixed_array_get(get_array12, 0);
|
|
EXPECT_EQ(0.111, *get_double121);
|
|
double *get_double122 = (double *) neu_fixed_array_get(get_array12, 1);
|
|
EXPECT_EQ(0.222, *get_double122);
|
|
double *get_double123 = (double *) neu_fixed_array_get(get_array12, 2);
|
|
EXPECT_EQ(0.333, *get_double123);
|
|
neu_fixed_array_free(get_array12);
|
|
neu_dvalue_free(get_array_dval12);
|
|
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
|
|
/** Get the second element of the 3D array **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_double, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
|
|
/** Get the first element of the second 2D array **/
|
|
neu_data_val_t *get_array_dval21 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 0);
|
|
neu_fixed_array_t *get_array21 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval21, &get_array21);
|
|
double *get_double311 = (double *) neu_fixed_array_get(get_array21, 0);
|
|
EXPECT_EQ(0.55, *get_double311);
|
|
double *get_double312 = (double *) neu_fixed_array_get(get_array21, 1);
|
|
EXPECT_EQ(0.66, *get_double312);
|
|
double *get_double313 = (double *) neu_fixed_array_get(get_array21, 2);
|
|
EXPECT_EQ(0.77, *get_double313);
|
|
neu_fixed_array_free(get_array21);
|
|
neu_dvalue_free(get_array_dval21);
|
|
|
|
/** Get the second element of the second 2D array **/
|
|
neu_data_val_t *get_array_dval22 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 1);
|
|
neu_fixed_array_t *get_array22 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval22, &get_array22);
|
|
double *get_double321 = (double *) neu_fixed_array_get(get_array22, 0);
|
|
EXPECT_EQ(0.555, *get_double321);
|
|
double *get_double322 = (double *) neu_fixed_array_get(get_array22, 1);
|
|
EXPECT_EQ(0.666, *get_double322);
|
|
double *get_double323 = (double *) neu_fixed_array_get(get_array22, 2);
|
|
EXPECT_EQ(0.777, *get_double323);
|
|
neu_fixed_array_free(get_array22);
|
|
neu_dvalue_free(get_array_dval22);
|
|
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
|
|
neu_fixed_array_free(get_array_double);
|
|
}
|
|
|
|
void comp_arr_3d_cstr(neu_fixed_array_t *get_array_cstr)
|
|
{
|
|
/** Get the first element of the 3D array **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_cstr, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
|
|
/** Get the first element of the first 2D array **/
|
|
neu_data_val_t *get_array_dval11 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 0);
|
|
neu_fixed_array_t *get_array11 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval11, &get_array11);
|
|
char *get_cstr111 = *(char **) neu_fixed_array_get(get_array11, 0);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test1", get_cstr111);
|
|
char *get_cstr112 = *(char **) neu_fixed_array_get(get_array11, 1);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test2", get_cstr112);
|
|
neu_fixed_array_free(get_array11);
|
|
neu_dvalue_free(get_array_dval11);
|
|
free(get_cstr111);
|
|
free(get_cstr112);
|
|
|
|
/** Get the second element of the first 2D array **/
|
|
neu_data_val_t *get_array_dval12 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 1);
|
|
neu_fixed_array_t *get_array12 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval12, &get_array12);
|
|
char *get_cstr121 = *(char **) neu_fixed_array_get(get_array12, 0);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test3", get_cstr121);
|
|
char *get_cstr122 = *(char **) neu_fixed_array_get(get_array12, 1);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test4", get_cstr122);
|
|
neu_fixed_array_free(get_array12);
|
|
neu_dvalue_free(get_array_dval12);
|
|
free(get_cstr121);
|
|
free(get_cstr122);
|
|
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
|
|
/** Get the second element of the 3D array **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_cstr, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
|
|
/** Get the first element of the second 2D array **/
|
|
neu_data_val_t *get_array_dval21 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 0);
|
|
neu_fixed_array_t *get_array21 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval21, &get_array21);
|
|
char *get_cstr311 = *(char **) neu_fixed_array_get(get_array21, 0);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test5", get_cstr311);
|
|
char *get_cstr312 = *(char **) neu_fixed_array_get(get_array21, 1);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test6", get_cstr312);
|
|
neu_fixed_array_free(get_array21);
|
|
neu_dvalue_free(get_array_dval21);
|
|
free(get_cstr311);
|
|
free(get_cstr312);
|
|
|
|
/** Get the second element of the second 2D array **/
|
|
neu_data_val_t *get_array_dval22 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 1);
|
|
neu_fixed_array_t *get_array22 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval22, &get_array22);
|
|
char *get_cstr321 = *(char **) neu_fixed_array_get(get_array22, 0);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test7", get_cstr321);
|
|
char *get_cstr322 = *(char **) neu_fixed_array_get(get_array22, 1);
|
|
EXPECT_STREQ((char *) "Hello,cstr-test8", get_cstr322);
|
|
neu_fixed_array_free(get_array22);
|
|
neu_dvalue_free(get_array_dval22);
|
|
free(get_cstr321);
|
|
free(get_cstr322);
|
|
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
|
|
neu_fixed_array_free(get_array_cstr);
|
|
}
|
|
|
|
void comp_arr_3d_int_val(neu_fixed_array_t *get_array_int_val)
|
|
{
|
|
/** Get the first 2D array1 within 3D array **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_int_val, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
|
|
/** Get the first 1D array11 within the first 2D array1 **/
|
|
neu_data_val_t *get_array_dval11 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 0);
|
|
neu_fixed_array_t *get_array11 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval11, &get_array11);
|
|
|
|
/** Compare the first element of the first 1D array11 **/
|
|
neu_int_val_t *get_int_val111 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array11, 0);
|
|
EXPECT_EQ(111, get_int_val111->key);
|
|
char *output_val111 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val111->val, &output_val111));
|
|
EXPECT_STREQ((char *) "hello,int-val1", output_val111);
|
|
neu_int_val_uninit(get_int_val111);
|
|
|
|
/** Compare the second element of the first 1D array11 **/
|
|
neu_int_val_t *get_int_val112 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array11, 1);
|
|
EXPECT_EQ(112, get_int_val112->key);
|
|
char *output_val112 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val112->val, &output_val112));
|
|
EXPECT_STREQ((char *) "hello,int-val2", output_val112);
|
|
neu_int_val_uninit(get_int_val112);
|
|
|
|
neu_fixed_array_free(get_array11);
|
|
neu_dvalue_free(get_array_dval11);
|
|
|
|
/** Get the second 1D array12 within the first 2D array1 **/
|
|
neu_data_val_t *get_array_dval12 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 1);
|
|
neu_fixed_array_t *get_array12 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval12, &get_array12);
|
|
|
|
/** Compare the first element of the first 1D array12 **/
|
|
neu_int_val_t *get_int_val121 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array12, 0);
|
|
EXPECT_EQ(121, get_int_val121->key);
|
|
char *output_val121 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val121->val, &output_val121));
|
|
EXPECT_STREQ((char *) "hello,int-val3", output_val121);
|
|
neu_int_val_uninit(get_int_val121);
|
|
|
|
/** Compare the second element of the first 1D array12 **/
|
|
neu_int_val_t *get_int_val122 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array12, 1);
|
|
EXPECT_EQ(122, get_int_val122->key);
|
|
char *output_val122 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val122->val, &output_val122));
|
|
EXPECT_STREQ((char *) "hello,int-val4", output_val122);
|
|
neu_int_val_uninit(get_int_val122);
|
|
|
|
neu_fixed_array_free(get_array12);
|
|
neu_dvalue_free(get_array_dval12);
|
|
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
|
|
/** Get the second 2D array2 within 3D array **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_int_val, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
|
|
/** Get the first 1D array21 within the second 2D array2 **/
|
|
neu_data_val_t *get_array_dval21 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 0);
|
|
neu_fixed_array_t *get_array21 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval21, &get_array21);
|
|
|
|
/** Compare the first element of the first 1D array21 **/
|
|
neu_int_val_t *get_int_val211 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array21, 0);
|
|
EXPECT_EQ(211, get_int_val211->key);
|
|
char *output_val211 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val211->val, &output_val211));
|
|
EXPECT_STREQ((char *) "hello,int-val5", output_val211);
|
|
neu_int_val_uninit(get_int_val211);
|
|
|
|
/** Compare the second element of the first 1D array21 **/
|
|
neu_int_val_t *get_int_val212 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array21, 1);
|
|
EXPECT_EQ(212, get_int_val212->key);
|
|
char *output_val212 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val212->val, &output_val212));
|
|
EXPECT_STREQ((char *) "hello,int-val6", output_val212);
|
|
neu_int_val_uninit(get_int_val212);
|
|
|
|
neu_fixed_array_free(get_array21);
|
|
neu_dvalue_free(get_array_dval21);
|
|
|
|
/** Get the second 1D array22 within the second 2D array2 **/
|
|
neu_data_val_t *get_array_dval22 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 1);
|
|
neu_fixed_array_t *get_array22 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval22, &get_array22);
|
|
|
|
/** Compare the first element of the first 1D array22 **/
|
|
neu_int_val_t *get_int_val221 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array22, 0);
|
|
EXPECT_EQ(221, get_int_val221->key);
|
|
char *output_val221 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val221->val, &output_val221));
|
|
EXPECT_STREQ((char *) "hello,int-val7", output_val221);
|
|
neu_int_val_uninit(get_int_val221);
|
|
|
|
/** Compare the second element of the first 1D array22 **/
|
|
neu_int_val_t *get_int_val222 =
|
|
(neu_int_val_t *) neu_fixed_array_get(get_array22, 1);
|
|
EXPECT_EQ(222, get_int_val222->key);
|
|
char *output_val222 = NULL;
|
|
EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val222->val, &output_val222));
|
|
EXPECT_STREQ((char *) "hello,int-val8", output_val222);
|
|
neu_int_val_uninit(get_int_val222);
|
|
|
|
neu_fixed_array_free(get_array22);
|
|
neu_dvalue_free(get_array_dval22);
|
|
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
|
|
neu_fixed_array_free(get_array_int_val);
|
|
}
|
|
|
|
void comp_arr_3d_str_val(neu_fixed_array_t *get_array_str_val)
|
|
{
|
|
/** Get the first 2D array1 within 3D array **/
|
|
neu_data_val_t *get_array_dval1 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_str_val, 0);
|
|
neu_fixed_array_t *get_array1 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval1, &get_array1);
|
|
|
|
/** Get the first 1D array11 within the first 2D array1 **/
|
|
neu_data_val_t *get_array_dval11 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 0);
|
|
neu_fixed_array_t *get_array11 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval11, &get_array11);
|
|
|
|
/** Compare the first element of the first 1D array11 **/
|
|
neu_string_val_t *get_str_val111 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array11, 0);
|
|
EXPECT_STREQ((char *) "string-key1",
|
|
neu_string_get_ref_cstr(get_str_val111->key));
|
|
neu_string_t *get_string111 = NULL;
|
|
EXPECT_EQ(0,
|
|
neu_dvalue_get_ref_string(get_str_val111->val, &get_string111));
|
|
EXPECT_STREQ((char *) "hello,string-val1",
|
|
neu_string_get_ref_cstr(get_string111));
|
|
neu_string_val_uninit(get_str_val111);
|
|
|
|
/** Compare the second element of the first 1D array11 **/
|
|
neu_string_val_t *get_str_val112 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array11, 1);
|
|
EXPECT_STREQ((char *) "string-key2",
|
|
neu_string_get_ref_cstr(get_str_val112->key));
|
|
neu_string_t *get_string112 = NULL;
|
|
EXPECT_EQ(0,
|
|
neu_dvalue_get_ref_string(get_str_val112->val, &get_string112));
|
|
EXPECT_STREQ((char *) "hello,string-val2",
|
|
neu_string_get_ref_cstr(get_string112));
|
|
neu_string_val_uninit(get_str_val112);
|
|
|
|
neu_fixed_array_free(get_array11);
|
|
neu_dvalue_free(get_array_dval11);
|
|
|
|
/** Get the second 1D array12 within the first 2D array1 **/
|
|
neu_data_val_t *get_array_dval12 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array1, 1);
|
|
neu_fixed_array_t *get_array12 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval12, &get_array12);
|
|
|
|
/** Compare the first element of the first 1D array12 **/
|
|
neu_string_val_t *get_str_val121 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array12, 0);
|
|
EXPECT_STREQ((char *) "string-key3",
|
|
neu_string_get_ref_cstr(get_str_val121->key));
|
|
neu_string_t *get_string121 = NULL;
|
|
EXPECT_EQ(0,
|
|
neu_dvalue_get_ref_string(get_str_val121->val, &get_string121));
|
|
EXPECT_STREQ((char *) "hello,string-val3",
|
|
neu_string_get_ref_cstr(get_string121));
|
|
neu_string_val_uninit(get_str_val121);
|
|
|
|
/** Compare the second element of the first 1D array12 **/
|
|
neu_string_val_t *get_str_val122 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array12, 1);
|
|
EXPECT_STREQ((char *) "string-key4",
|
|
neu_string_get_ref_cstr(get_str_val122->key));
|
|
neu_string_t *get_string122 = NULL;
|
|
EXPECT_EQ(0,
|
|
neu_dvalue_get_ref_string(get_str_val122->val, &get_string122));
|
|
EXPECT_STREQ((char *) "hello,string-val4",
|
|
neu_string_get_ref_cstr(get_string122));
|
|
neu_string_val_uninit(get_str_val122);
|
|
|
|
neu_fixed_array_free(get_array12);
|
|
neu_dvalue_free(get_array_dval12);
|
|
|
|
neu_fixed_array_free(get_array1);
|
|
neu_dvalue_free(get_array_dval1);
|
|
|
|
/** Get the second 2D array2 within 3D array **/
|
|
neu_data_val_t *get_array_dval2 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array_str_val, 1);
|
|
neu_fixed_array_t *get_array2 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval2, &get_array2);
|
|
|
|
/** Get the first 1D array21 within the second 2D array2 **/
|
|
neu_data_val_t *get_array_dval21 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 0);
|
|
neu_fixed_array_t *get_array21 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval21, &get_array21);
|
|
|
|
/** Compare the first element of the first 1D array21 **/
|
|
neu_string_val_t *get_str_val211 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array21, 0);
|
|
EXPECT_STREQ((char *) "string-key5",
|
|
neu_string_get_ref_cstr(get_str_val211->key));
|
|
neu_string_t *get_string211 = NULL;
|
|
EXPECT_EQ(0,
|
|
neu_dvalue_get_ref_string(get_str_val211->val, &get_string211));
|
|
EXPECT_STREQ((char *) "hello,string-val5",
|
|
neu_string_get_ref_cstr(get_string211));
|
|
neu_string_val_uninit(get_str_val211);
|
|
|
|
/** Compare the second element of the first 1D array21 **/
|
|
neu_string_val_t *get_str_val212 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array21, 1);
|
|
EXPECT_STREQ((char *) "string-key6",
|
|
neu_string_get_ref_cstr(get_str_val212->key));
|
|
neu_string_t *get_string212 = NULL;
|
|
EXPECT_EQ(0,
|
|
neu_dvalue_get_ref_string(get_str_val212->val, &get_string212));
|
|
EXPECT_STREQ((char *) "hello,string-val6",
|
|
neu_string_get_ref_cstr(get_string212));
|
|
neu_string_val_uninit(get_str_val212);
|
|
|
|
neu_fixed_array_free(get_array21);
|
|
neu_dvalue_free(get_array_dval21);
|
|
|
|
/** Get the second 1D array22 within the second 2D array2 **/
|
|
neu_data_val_t *get_array_dval22 =
|
|
*(neu_data_val_t **) neu_fixed_array_get(get_array2, 1);
|
|
neu_fixed_array_t *get_array22 = NULL;
|
|
neu_dvalue_get_move_array(get_array_dval22, &get_array22);
|
|
|
|
/** Compare the first element of the first 1D array22 **/
|
|
neu_string_val_t *get_str_val221 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array22, 0);
|
|
EXPECT_STREQ((char *) "string-key7",
|
|
neu_string_get_ref_cstr(get_str_val221->key));
|
|
neu_string_t *get_string221 = NULL;
|
|
EXPECT_EQ(0,
|
|
neu_dvalue_get_ref_string(get_str_val221->val, &get_string221));
|
|
EXPECT_STREQ((char *) "hello,string-val7",
|
|
neu_string_get_ref_cstr(get_string221));
|
|
neu_string_val_uninit(get_str_val221);
|
|
|
|
/** Compare the second element of the first 1D array22 **/
|
|
neu_string_val_t *get_str_val222 =
|
|
(neu_string_val_t *) neu_fixed_array_get(get_array22, 1);
|
|
EXPECT_STREQ((char *) "string-key8",
|
|
neu_string_get_ref_cstr(get_str_val222->key));
|
|
neu_string_t *get_string222 = NULL;
|
|
EXPECT_EQ(0,
|
|
neu_dvalue_get_ref_string(get_str_val222->val, &get_string222));
|
|
EXPECT_STREQ((char *) "hello,string-val8",
|
|
neu_string_get_ref_cstr(get_string222));
|
|
neu_string_val_uninit(get_str_val222);
|
|
|
|
neu_fixed_array_free(get_array22);
|
|
neu_dvalue_free(get_array_dval22);
|
|
|
|
neu_fixed_array_free(get_array2);
|
|
neu_dvalue_free(get_array_dval2);
|
|
|
|
neu_fixed_array_free(get_array_str_val);
|
|
}
|
|
|
|
TEST(DataValuTest, neu_dvalue_3D_array_deser)
|
|
{
|
|
/** int64 **/
|
|
int64_t i64_arr[2][2][3] = { { { 1, 2, 3 }, { 11, 22, 33 } },
|
|
{ { 5, 6, 7 }, { 55, 66, 77 } } };
|
|
|
|
neu_fixed_array_t *set_array_int11 =
|
|
neu_fixed_array_new(3, sizeof(int64_t));
|
|
neu_fixed_array_set(set_array_int11, 0, &i64_arr[0][0][0]);
|
|
neu_fixed_array_set(set_array_int11, 1, &i64_arr[0][0][1]);
|
|
neu_fixed_array_set(set_array_int11, 2, &i64_arr[0][0][2]);
|
|
neu_fixed_array_t *set_array_int12 =
|
|
neu_fixed_array_new(3, sizeof(int64_t));
|
|
neu_fixed_array_set(set_array_int12, 0, &i64_arr[0][1][0]);
|
|
neu_fixed_array_set(set_array_int12, 1, &i64_arr[0][1][1]);
|
|
neu_fixed_array_set(set_array_int12, 2, &i64_arr[0][1][2]);
|
|
neu_fixed_array_t *set_array_int21 =
|
|
neu_fixed_array_new(3, sizeof(int64_t));
|
|
neu_fixed_array_set(set_array_int21, 0, &i64_arr[1][0][0]);
|
|
neu_fixed_array_set(set_array_int21, 1, &i64_arr[1][0][1]);
|
|
neu_fixed_array_set(set_array_int21, 2, &i64_arr[1][0][2]);
|
|
neu_fixed_array_t *set_array_int22 =
|
|
neu_fixed_array_new(3, sizeof(int64_t));
|
|
neu_fixed_array_set(set_array_int22, 0, &i64_arr[1][1][0]);
|
|
neu_fixed_array_set(set_array_int22, 1, &i64_arr[1][1][1]);
|
|
neu_fixed_array_set(set_array_int22, 2, &i64_arr[1][1][2]);
|
|
|
|
neu_data_val_t *array_int_dval11 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_dval11, NEU_DTYPE_INT64,
|
|
set_array_int11);
|
|
neu_data_val_t *array_int_dval12 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_dval12, NEU_DTYPE_INT64,
|
|
set_array_int12);
|
|
neu_data_val_t *array_int_dval21 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_dval21, NEU_DTYPE_INT64,
|
|
set_array_int21);
|
|
neu_data_val_t *array_int_dval22 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_dval22, NEU_DTYPE_INT64,
|
|
set_array_int22);
|
|
|
|
neu_fixed_array_t *set_array1 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array1, 0, &array_int_dval11);
|
|
neu_fixed_array_set(set_array1, 1, &array_int_dval12);
|
|
neu_fixed_array_t *set_array2 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array2, 0, &array_int_dval21);
|
|
neu_fixed_array_set(set_array2, 1, &array_int_dval22);
|
|
|
|
neu_data_val_t *array_int_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_dval1, NEU_DTYPE_DATA_VAL, set_array1);
|
|
neu_data_val_t *array_int_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_dval2, NEU_DTYPE_DATA_VAL, set_array2);
|
|
|
|
neu_fixed_array_t *set_array_3d =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_3d, 0, &array_int_dval1);
|
|
neu_fixed_array_set(set_array_3d, 1, &array_int_dval2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_int =
|
|
ser_deser_with_fixed_array(set_array_3d, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** free **/
|
|
neu_fixed_array_free(set_array_int11);
|
|
neu_fixed_array_free(set_array_int12);
|
|
neu_fixed_array_free(set_array_int21);
|
|
neu_fixed_array_free(set_array_int22);
|
|
|
|
neu_dvalue_free(array_int_dval11);
|
|
neu_dvalue_free(array_int_dval12);
|
|
neu_dvalue_free(array_int_dval21);
|
|
neu_dvalue_free(array_int_dval22);
|
|
|
|
neu_fixed_array_free(set_array1);
|
|
neu_fixed_array_free(set_array2);
|
|
|
|
neu_dvalue_free(array_int_dval1);
|
|
neu_dvalue_free(array_int_dval2);
|
|
|
|
/** Compare **/
|
|
comp_arr_3d_int(get_array_int);
|
|
|
|
/** double **/
|
|
/** set array **/
|
|
double double_arr[2][2][3] = {
|
|
{ { 0.11, 0.22, 0.33 }, { 0.111, 0.222, 0.333 } },
|
|
{ { 0.55, 0.66, 0.77 }, { 0.555, 0.666, 0.777 } }
|
|
};
|
|
neu_fixed_array_t *set_array_double11 =
|
|
neu_fixed_array_new(3, sizeof(double));
|
|
neu_fixed_array_set(set_array_double11, 0, &double_arr[0][0][0]);
|
|
neu_fixed_array_set(set_array_double11, 1, &double_arr[0][0][1]);
|
|
neu_fixed_array_set(set_array_double11, 2, &double_arr[0][0][2]);
|
|
neu_data_val_t *array_double_dval11 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_double_dval11, NEU_DTYPE_DOUBLE,
|
|
set_array_double11);
|
|
|
|
neu_fixed_array_t *set_array_double12 =
|
|
neu_fixed_array_new(3, sizeof(double));
|
|
neu_fixed_array_set(set_array_double12, 0, &double_arr[0][1][0]);
|
|
neu_fixed_array_set(set_array_double12, 1, &double_arr[0][1][1]);
|
|
neu_fixed_array_set(set_array_double12, 2, &double_arr[0][1][2]);
|
|
neu_data_val_t *array_double_dval12 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_double_dval12, NEU_DTYPE_DOUBLE,
|
|
set_array_double12);
|
|
|
|
neu_fixed_array_t *set_array_double21 =
|
|
neu_fixed_array_new(3, sizeof(double));
|
|
neu_fixed_array_set(set_array_double21, 0, &double_arr[1][0][0]);
|
|
neu_fixed_array_set(set_array_double21, 1, &double_arr[1][0][1]);
|
|
neu_fixed_array_set(set_array_double21, 2, &double_arr[1][0][2]);
|
|
neu_data_val_t *array_double_dval21 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_double_dval21, NEU_DTYPE_DOUBLE,
|
|
set_array_double21);
|
|
|
|
neu_fixed_array_t *set_array_double22 =
|
|
neu_fixed_array_new(3, sizeof(double));
|
|
neu_fixed_array_set(set_array_double22, 0, &double_arr[1][1][0]);
|
|
neu_fixed_array_set(set_array_double22, 1, &double_arr[1][1][1]);
|
|
neu_fixed_array_set(set_array_double22, 2, &double_arr[1][1][2]);
|
|
neu_data_val_t *array_double_dval22 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_double_dval22, NEU_DTYPE_DOUBLE,
|
|
set_array_double22);
|
|
|
|
neu_fixed_array_t *set_array_double1 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_double1, 0, &array_double_dval11);
|
|
neu_fixed_array_set(set_array_double1, 1, &array_double_dval12);
|
|
neu_data_val_t *array_double_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_double_dval1, NEU_DTYPE_DATA_VAL,
|
|
set_array_double1);
|
|
|
|
neu_fixed_array_t *set_array_double2 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_double2, 0, &array_double_dval21);
|
|
neu_fixed_array_set(set_array_double2, 1, &array_double_dval22);
|
|
neu_data_val_t *array_double_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_double_dval2, NEU_DTYPE_DATA_VAL,
|
|
set_array_double2);
|
|
|
|
neu_fixed_array_t *set_array_double =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_double, 0, &array_double_dval1);
|
|
neu_fixed_array_set(set_array_double, 1, &array_double_dval2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_double =
|
|
ser_deser_with_fixed_array(set_array_double, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** free **/
|
|
neu_fixed_array_free(set_array_double11);
|
|
neu_fixed_array_free(set_array_double12);
|
|
neu_fixed_array_free(set_array_double21);
|
|
neu_fixed_array_free(set_array_double22);
|
|
|
|
neu_dvalue_free(array_double_dval11);
|
|
neu_dvalue_free(array_double_dval12);
|
|
neu_dvalue_free(array_double_dval21);
|
|
neu_dvalue_free(array_double_dval22);
|
|
|
|
neu_fixed_array_free(set_array_double1);
|
|
neu_fixed_array_free(set_array_double2);
|
|
|
|
neu_dvalue_free(array_double_dval1);
|
|
neu_dvalue_free(array_double_dval2);
|
|
|
|
/** Compare **/
|
|
comp_arr_3d_double(get_array_double);
|
|
|
|
/** cstr **/
|
|
/** set array **/
|
|
char *cstr1 = (char *) "Hello,cstr-test1";
|
|
char *cstr2 = (char *) "Hello,cstr-test2";
|
|
char *cstr3 = (char *) "Hello,cstr-test3";
|
|
char *cstr4 = (char *) "Hello,cstr-test4";
|
|
char *cstr5 = (char *) "Hello,cstr-test5";
|
|
char *cstr6 = (char *) "Hello,cstr-test6";
|
|
char *cstr7 = (char *) "Hello,cstr-test7";
|
|
char *cstr8 = (char *) "Hello,cstr-test8";
|
|
|
|
neu_fixed_array_t *set_array_cstr11 =
|
|
neu_fixed_array_new(2, sizeof(char *));
|
|
neu_fixed_array_set(set_array_cstr11, 0, &cstr1);
|
|
neu_fixed_array_set(set_array_cstr11, 1, &cstr2);
|
|
neu_data_val_t *array_cstr_dval11 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_cstr_dval11, NEU_DTYPE_CSTR,
|
|
set_array_cstr11);
|
|
|
|
neu_fixed_array_t *set_array_cstr12 =
|
|
neu_fixed_array_new(2, sizeof(char *));
|
|
neu_fixed_array_set(set_array_cstr12, 0, &cstr3);
|
|
neu_fixed_array_set(set_array_cstr12, 1, &cstr4);
|
|
neu_data_val_t *array_cstr_dval12 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_cstr_dval12, NEU_DTYPE_CSTR,
|
|
set_array_cstr12);
|
|
|
|
neu_fixed_array_t *set_array_cstr21 =
|
|
neu_fixed_array_new(2, sizeof(char *));
|
|
neu_fixed_array_set(set_array_cstr21, 0, &cstr5);
|
|
neu_fixed_array_set(set_array_cstr21, 1, &cstr6);
|
|
neu_data_val_t *array_cstr_dval21 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_cstr_dval21, NEU_DTYPE_CSTR,
|
|
set_array_cstr21);
|
|
|
|
neu_fixed_array_t *set_array_cstr22 =
|
|
neu_fixed_array_new(2, sizeof(char *));
|
|
neu_fixed_array_set(set_array_cstr22, 0, &cstr7);
|
|
neu_fixed_array_set(set_array_cstr22, 1, &cstr8);
|
|
neu_data_val_t *array_cstr_dval22 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_cstr_dval22, NEU_DTYPE_CSTR,
|
|
set_array_cstr22);
|
|
|
|
neu_fixed_array_t *set_array_cstr1 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_cstr1, 0, &array_cstr_dval11);
|
|
neu_fixed_array_set(set_array_cstr1, 1, &array_cstr_dval12);
|
|
neu_data_val_t *array_cstr_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_cstr_dval1, NEU_DTYPE_DATA_VAL,
|
|
set_array_cstr1);
|
|
|
|
neu_fixed_array_t *set_array_cstr2 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_cstr2, 0, &array_cstr_dval21);
|
|
neu_fixed_array_set(set_array_cstr2, 1, &array_cstr_dval22);
|
|
neu_data_val_t *array_cstr_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_cstr_dval2, NEU_DTYPE_DATA_VAL,
|
|
set_array_cstr2);
|
|
|
|
neu_fixed_array_t *set_array_cstr =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_cstr, 0, &array_cstr_dval1);
|
|
neu_fixed_array_set(set_array_cstr, 1, &array_cstr_dval2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_cstr =
|
|
ser_deser_with_fixed_array(set_array_cstr, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** Compare **/
|
|
comp_arr_3d_cstr(get_array_cstr);
|
|
|
|
/** free **/
|
|
neu_fixed_array_free(set_array_cstr11);
|
|
neu_fixed_array_free(set_array_cstr12);
|
|
neu_fixed_array_free(set_array_cstr21);
|
|
neu_fixed_array_free(set_array_cstr22);
|
|
|
|
neu_dvalue_free(array_cstr_dval11);
|
|
neu_dvalue_free(array_cstr_dval12);
|
|
neu_dvalue_free(array_cstr_dval21);
|
|
neu_dvalue_free(array_cstr_dval22);
|
|
|
|
neu_fixed_array_free(set_array_cstr1);
|
|
neu_fixed_array_free(set_array_cstr2);
|
|
|
|
neu_dvalue_free(array_cstr_dval1);
|
|
neu_dvalue_free(array_cstr_dval2);
|
|
|
|
/** int_val **/
|
|
/** the fist element of 1D array **/
|
|
neu_data_val_t *input_int_val111 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val111, (char *) "hello,int-val1");
|
|
neu_int_val_t int_val111;
|
|
neu_int_val_init(&int_val111, 111, input_int_val111);
|
|
|
|
/** the second element of 1D array **/
|
|
neu_data_val_t *input_int_val112 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val112, (char *) "hello,int-val2");
|
|
neu_int_val_t int_val112;
|
|
neu_int_val_init(&int_val112, 112, input_int_val112);
|
|
|
|
/** the third element of 1D array **/
|
|
neu_data_val_t *input_int_val121 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val121, (char *) "hello,int-val3");
|
|
neu_int_val_t int_val121;
|
|
neu_int_val_init(&int_val121, 121, input_int_val121);
|
|
|
|
/** the fourth element of 1D array **/
|
|
neu_data_val_t *input_int_val122 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val122, (char *) "hello,int-val4");
|
|
neu_int_val_t int_val122;
|
|
neu_int_val_init(&int_val122, 122, input_int_val122);
|
|
|
|
/** the fifth element of 1D array **/
|
|
neu_data_val_t *input_int_val211 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val211, (char *) "hello,int-val5");
|
|
neu_int_val_t int_val211;
|
|
neu_int_val_init(&int_val211, 211, input_int_val211);
|
|
|
|
/** the sixth element of 1D array **/
|
|
neu_data_val_t *input_int_val212 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val212, (char *) "hello,int-val6");
|
|
neu_int_val_t int_val212;
|
|
neu_int_val_init(&int_val212, 212, input_int_val212);
|
|
|
|
/** the seventh element of 1D array **/
|
|
neu_data_val_t *input_int_val221 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val221, (char *) "hello,int-val7");
|
|
neu_int_val_t int_val221;
|
|
neu_int_val_init(&int_val221, 221, input_int_val221);
|
|
|
|
/** the eighth element of 1D array **/
|
|
neu_data_val_t *input_int_val222 = neu_dvalue_new(NEU_DTYPE_CSTR);
|
|
neu_dvalue_set_cstr(input_int_val222, (char *) "hello,int-val8");
|
|
neu_int_val_t int_val222;
|
|
neu_int_val_init(&int_val222, 222, input_int_val222);
|
|
|
|
/** set the first element of 2D array11 **/
|
|
neu_fixed_array_t *set_array_int_val11 =
|
|
neu_fixed_array_new(2, sizeof(neu_int_val_t));
|
|
neu_fixed_array_set(set_array_int_val11, 0, &int_val111);
|
|
neu_fixed_array_set(set_array_int_val11, 1, &int_val112);
|
|
neu_data_val_t *array_int_val_dval11 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_val_dval11, NEU_DTYPE_INT_VAL,
|
|
set_array_int_val11);
|
|
|
|
/** set the second element of 2D array12 **/
|
|
neu_fixed_array_t *set_array_int_val12 =
|
|
neu_fixed_array_new(2, sizeof(neu_int_val_t));
|
|
neu_fixed_array_set(set_array_int_val12, 0, &int_val121);
|
|
neu_fixed_array_set(set_array_int_val12, 1, &int_val122);
|
|
neu_data_val_t *array_int_val_dval12 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_val_dval12, NEU_DTYPE_INT_VAL,
|
|
set_array_int_val12);
|
|
|
|
/** set the first element of 2D array21 **/
|
|
neu_fixed_array_t *set_array_int_val21 =
|
|
neu_fixed_array_new(2, sizeof(neu_int_val_t));
|
|
neu_fixed_array_set(set_array_int_val21, 0, &int_val211);
|
|
neu_fixed_array_set(set_array_int_val21, 1, &int_val212);
|
|
neu_data_val_t *array_int_val_dval21 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_val_dval21, NEU_DTYPE_INT_VAL,
|
|
set_array_int_val21);
|
|
|
|
/** set the second element of 2D array22 **/
|
|
neu_fixed_array_t *set_array_int_val22 =
|
|
neu_fixed_array_new(2, sizeof(neu_int_val_t));
|
|
neu_fixed_array_set(set_array_int_val22, 0, &int_val221);
|
|
neu_fixed_array_set(set_array_int_val22, 1, &int_val222);
|
|
neu_data_val_t *array_int_val_dval22 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_val_dval22, NEU_DTYPE_INT_VAL,
|
|
set_array_int_val22);
|
|
|
|
/** set the first element of 3D array1 **/
|
|
neu_fixed_array_t *set_array_int_val1 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_int_val1, 0, &array_int_val_dval11);
|
|
neu_fixed_array_set(set_array_int_val1, 1, &array_int_val_dval12);
|
|
neu_data_val_t *array_int_val_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_val_dval1, NEU_DTYPE_DATA_VAL,
|
|
set_array_int_val1);
|
|
|
|
/** set the second element of 3D array1 **/
|
|
neu_fixed_array_t *set_array_int_val2 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_int_val2, 0, &array_int_val_dval21);
|
|
neu_fixed_array_set(set_array_int_val2, 1, &array_int_val_dval22);
|
|
neu_data_val_t *array_int_val_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_int_val_dval2, NEU_DTYPE_DATA_VAL,
|
|
set_array_int_val2);
|
|
|
|
/** set 3D array **/
|
|
neu_fixed_array_t *set_array_int_val =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_int_val, 0, &array_int_val_dval1);
|
|
neu_fixed_array_set(set_array_int_val, 1, &array_int_val_dval2);
|
|
|
|
/** serialize and deserialize return **/
|
|
neu_fixed_array_t *get_array_int_val =
|
|
ser_deser_with_fixed_array(set_array_int_val, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** free **/
|
|
neu_dvalue_free(input_int_val111);
|
|
neu_dvalue_free(input_int_val112);
|
|
neu_dvalue_free(input_int_val121);
|
|
neu_dvalue_free(input_int_val122);
|
|
neu_dvalue_free(input_int_val211);
|
|
neu_dvalue_free(input_int_val212);
|
|
neu_dvalue_free(input_int_val221);
|
|
neu_dvalue_free(input_int_val222);
|
|
|
|
neu_fixed_array_free(set_array_int_val11);
|
|
neu_fixed_array_free(set_array_int_val12);
|
|
neu_fixed_array_free(set_array_int_val21);
|
|
neu_fixed_array_free(set_array_int_val22);
|
|
|
|
neu_dvalue_free(array_int_val_dval11);
|
|
neu_dvalue_free(array_int_val_dval12);
|
|
neu_dvalue_free(array_int_val_dval21);
|
|
neu_dvalue_free(array_int_val_dval22);
|
|
|
|
neu_fixed_array_free(set_array_int_val1);
|
|
neu_fixed_array_free(set_array_int_val2);
|
|
|
|
neu_dvalue_free(array_int_val_dval1);
|
|
neu_dvalue_free(array_int_val_dval2);
|
|
|
|
/** Compare **/
|
|
comp_arr_3d_int_val(get_array_int_val);
|
|
|
|
/** string_val **/
|
|
/** set the first element of 1D array **/
|
|
neu_string_t *input_str_key1 = neu_string_from_cstr((char *) "string-key1");
|
|
neu_string_t *test_string1 =
|
|
neu_string_from_cstr((char *) "hello,string-val1");
|
|
neu_data_val_t *input_str_dval1 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval1, test_string1);
|
|
neu_string_val_t string_val1;
|
|
neu_string_val_init(&string_val1, input_str_key1, input_str_dval1);
|
|
|
|
/** set the second element of 1D array **/
|
|
neu_string_t *input_str_key2 = neu_string_from_cstr((char *) "string-key2");
|
|
neu_string_t *test_string2 =
|
|
neu_string_from_cstr((char *) "hello,string-val2");
|
|
neu_data_val_t *input_str_dval2 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval2, test_string2);
|
|
neu_string_val_t string_val2;
|
|
neu_string_val_init(&string_val2, input_str_key2, input_str_dval2);
|
|
|
|
/** set the third element of 1D array **/
|
|
neu_string_t *input_str_key3 = neu_string_from_cstr((char *) "string-key3");
|
|
neu_string_t *test_string3 =
|
|
neu_string_from_cstr((char *) "hello,string-val3");
|
|
neu_data_val_t *input_str_dval3 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval3, test_string3);
|
|
neu_string_val_t string_val3;
|
|
neu_string_val_init(&string_val3, input_str_key3, input_str_dval3);
|
|
|
|
/** set the fourth element of 1D array **/
|
|
neu_string_t *input_str_key4 = neu_string_from_cstr((char *) "string-key4");
|
|
neu_string_t *test_string4 =
|
|
neu_string_from_cstr((char *) "hello,string-val4");
|
|
neu_data_val_t *input_str_dval4 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval4, test_string4);
|
|
neu_string_val_t string_val4;
|
|
neu_string_val_init(&string_val4, input_str_key4, input_str_dval4);
|
|
|
|
/** set the fifth element of 1D array **/
|
|
neu_string_t *input_str_key5 = neu_string_from_cstr((char *) "string-key5");
|
|
neu_string_t *test_string5 =
|
|
neu_string_from_cstr((char *) "hello,string-val5");
|
|
neu_data_val_t *input_str_dval5 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval5, test_string5);
|
|
neu_string_val_t string_val5;
|
|
neu_string_val_init(&string_val5, input_str_key5, input_str_dval5);
|
|
|
|
/** set the sixth element of 1D array **/
|
|
neu_string_t *input_str_key6 = neu_string_from_cstr((char *) "string-key6");
|
|
neu_string_t *test_string6 =
|
|
neu_string_from_cstr((char *) "hello,string-val6");
|
|
neu_data_val_t *input_str_dval6 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval6, test_string6);
|
|
neu_string_val_t string_val6;
|
|
neu_string_val_init(&string_val6, input_str_key6, input_str_dval6);
|
|
|
|
/** set the seventh element of 1D array **/
|
|
neu_string_t *input_str_key7 = neu_string_from_cstr((char *) "string-key7");
|
|
neu_string_t *test_string7 =
|
|
neu_string_from_cstr((char *) "hello,string-val7");
|
|
neu_data_val_t *input_str_dval7 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval7, test_string7);
|
|
neu_string_val_t string_val7;
|
|
neu_string_val_init(&string_val7, input_str_key7, input_str_dval7);
|
|
|
|
/** set the eighth element of 1D array **/
|
|
neu_string_t *input_str_key8 = neu_string_from_cstr((char *) "string-key8");
|
|
neu_string_t *test_string8 =
|
|
neu_string_from_cstr((char *) "hello,string-val8");
|
|
neu_data_val_t *input_str_dval8 = neu_dvalue_new(NEU_DTYPE_STRING);
|
|
neu_dvalue_set_move_string(input_str_dval8, test_string8);
|
|
neu_string_val_t string_val8;
|
|
neu_string_val_init(&string_val8, input_str_key8, input_str_dval8);
|
|
|
|
/** set the first element of 2D array11 **/
|
|
neu_fixed_array_t *set_str_val_array11 =
|
|
neu_fixed_array_new(2, sizeof(neu_string_val_t));
|
|
neu_fixed_array_set(set_str_val_array11, 0, &string_val1);
|
|
neu_fixed_array_set(set_str_val_array11, 1, &string_val2);
|
|
|
|
neu_data_val_t *array_str_val_dval11 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_str_val_dval11, NEU_DTYPE_STRING_VAL,
|
|
set_str_val_array11);
|
|
|
|
/** set the second element of 2D array12 **/
|
|
neu_fixed_array_t *set_str_val_array12 =
|
|
neu_fixed_array_new(2, sizeof(neu_string_val_t));
|
|
neu_fixed_array_set(set_str_val_array12, 0, &string_val3);
|
|
neu_fixed_array_set(set_str_val_array12, 1, &string_val4);
|
|
|
|
neu_data_val_t *array_str_val_dval12 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_str_val_dval12, NEU_DTYPE_STRING_VAL,
|
|
set_str_val_array12);
|
|
|
|
/** set the first element of 2D array21 **/
|
|
neu_fixed_array_t *set_str_val_array21 =
|
|
neu_fixed_array_new(2, sizeof(neu_string_val_t));
|
|
neu_fixed_array_set(set_str_val_array21, 0, &string_val5);
|
|
neu_fixed_array_set(set_str_val_array21, 1, &string_val6);
|
|
|
|
neu_data_val_t *array_str_val_dval21 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_str_val_dval21, NEU_DTYPE_STRING_VAL,
|
|
set_str_val_array21);
|
|
|
|
/** set the second element of 2D array22 **/
|
|
neu_fixed_array_t *set_str_val_array22 =
|
|
neu_fixed_array_new(2, sizeof(neu_string_val_t));
|
|
neu_fixed_array_set(set_str_val_array22, 0, &string_val7);
|
|
neu_fixed_array_set(set_str_val_array22, 1, &string_val8);
|
|
|
|
neu_data_val_t *array_str_val_dval22 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_str_val_dval22, NEU_DTYPE_STRING_VAL,
|
|
set_str_val_array22);
|
|
|
|
/** set the first element of 3D array1 **/
|
|
neu_fixed_array_t *set_str_val_array1 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_str_val_array1, 0, &array_str_val_dval11);
|
|
neu_fixed_array_set(set_str_val_array1, 1, &array_str_val_dval12);
|
|
|
|
neu_data_val_t *array_str_val_dval1 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_str_val_dval1, NEU_DTYPE_DATA_VAL,
|
|
set_str_val_array1);
|
|
|
|
/** set the second element of 3D array1 **/
|
|
neu_fixed_array_t *set_str_val_array2 =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_str_val_array2, 0, &array_str_val_dval21);
|
|
neu_fixed_array_set(set_str_val_array2, 1, &array_str_val_dval22);
|
|
|
|
neu_data_val_t *array_str_val_dval2 = neu_dvalue_unit_new();
|
|
neu_dvalue_init_ref_array(array_str_val_dval2, NEU_DTYPE_DATA_VAL,
|
|
set_str_val_array2);
|
|
|
|
/** set 3D array **/
|
|
neu_fixed_array_t *set_array_str_val =
|
|
neu_fixed_array_new(2, sizeof(neu_data_val_t *));
|
|
neu_fixed_array_set(set_array_str_val, 0, &array_str_val_dval1);
|
|
neu_fixed_array_set(set_array_str_val, 1, &array_str_val_dval2);
|
|
|
|
/** serialize and deserializa return **/
|
|
neu_fixed_array_t *get_array_str_val =
|
|
ser_deser_with_fixed_array(set_array_str_val, NEU_DTYPE_DATA_VAL);
|
|
|
|
/** free **/
|
|
neu_string_free(input_str_key1);
|
|
neu_string_free(input_str_key2);
|
|
neu_string_free(input_str_key3);
|
|
neu_string_free(input_str_key4);
|
|
neu_string_free(input_str_key5);
|
|
neu_string_free(input_str_key6);
|
|
neu_string_free(input_str_key7);
|
|
neu_string_free(input_str_key8);
|
|
|
|
neu_dvalue_free(input_str_dval1);
|
|
neu_dvalue_free(input_str_dval2);
|
|
neu_dvalue_free(input_str_dval3);
|
|
neu_dvalue_free(input_str_dval4);
|
|
neu_dvalue_free(input_str_dval5);
|
|
neu_dvalue_free(input_str_dval6);
|
|
neu_dvalue_free(input_str_dval7);
|
|
neu_dvalue_free(input_str_dval8);
|
|
|
|
neu_fixed_array_free(set_str_val_array11);
|
|
neu_fixed_array_free(set_str_val_array12);
|
|
neu_fixed_array_free(set_str_val_array21);
|
|
neu_fixed_array_free(set_str_val_array22);
|
|
|
|
neu_dvalue_free(array_str_val_dval11);
|
|
neu_dvalue_free(array_str_val_dval12);
|
|
neu_dvalue_free(array_str_val_dval21);
|
|
neu_dvalue_free(array_str_val_dval22);
|
|
|
|
neu_fixed_array_free(set_str_val_array1);
|
|
neu_fixed_array_free(set_str_val_array2);
|
|
|
|
neu_dvalue_free(array_str_val_dval1);
|
|
neu_dvalue_free(array_str_val_dval2);
|
|
|
|
/** Compare **/
|
|
comp_arr_3d_str_val(get_array_str_val);
|
|
}
|
|
|
|
TEST(DataValueTest, neu_dvalue_vec_deser)
|
|
{
|
|
int rc;
|
|
ssize_t size;
|
|
uint8_t *buf;
|
|
|
|
vector_t *vec_set;
|
|
int8_t i8_arr[4] = { 2, 7, 1, 8 };
|
|
vec_set = vector_new(4, sizeof(int8_t));
|
|
vector_push_back(vec_set, &i8_arr[0]);
|
|
vector_push_back(vec_set, &i8_arr[1]);
|
|
vector_push_back(vec_set, &i8_arr[2]);
|
|
vector_push_back(vec_set, &i8_arr[3]);
|
|
|
|
neu_data_val_t *val = neu_dvalue_unit_new();
|
|
neu_dvalue_init_move_vec(val, NEU_DTYPE_INT8, vec_set);
|
|
size = neu_dvalue_serialize(val, &buf);
|
|
EXPECT_LT(0, size);
|
|
neu_dvalue_free(val);
|
|
|
|
neu_data_val_t *val1;
|
|
size = neu_dvalue_deserialize(buf, size, &val1);
|
|
EXPECT_LT(0, size);
|
|
vector_t *vec_get;
|
|
rc = neu_dvalue_get_move_vec(val1, &vec_get);
|
|
EXPECT_EQ(0, rc);
|
|
// TODO: assert two vector is euqal
|
|
|
|
free(buf);
|
|
vector_free(vec_get);
|
|
neu_dvalue_free(val1);
|
|
}
|