END_TEST
START_TEST(Server_HistorizingUpdateInsert)
{
UA_HistoryDataBackend backend = UA_HistoryDataBackend_Memory(1, 1);
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = backend;
setting.maxHistoryDataResponseSize = 1000;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_USER;
serverMutexLock();
UA_StatusCode ret = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
serverMutexUnlock();
ck_assert_str_eq(UA_StatusCode_name(ret), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// fill backend with insert
ck_assert_str_eq(UA_StatusCode_name(updateHistory(UA_PERFORMUPDATETYPE_INSERT, testData, NULL, NULL))
, UA_StatusCode_name(UA_STATUSCODE_GOOD));
UA_HistoryData data;
UA_HistoryData_init(&data);
testResult(testDataSorted, &data);
for (size_t i = 0; i < data.dataValuesSize; ++i) {
ck_assert_uint_eq(data.dataValues[i].hasValue, true);
ck_assert(data.dataValues[i].value.type == &UA_TYPES[UA_TYPES_INT64]);
ck_assert_uint_eq(*((UA_Int64*)data.dataValues[i].value.data), UA_PERFORMUPDATETYPE_INSERT);
}
UA_HistoryData_deleteMembers(&data);
UA_HistoryDataBackend_Memory_deleteMembers(&setting.historizingBackend);
}
} END_TEST
/*
* Read a 64-bit variable-sized integer from an underruning binary stream.
*/
START_TEST(test_read_svarint64_underrun) {
const uint8_t data[] = { 128, 128, 184, 226, 226, 148, 233, 135 };
const size_t size = 8;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Read signed 64-bit variabled-sized integer */
int64_t value;
ck_assert_uint_eq(PB_ERROR_UNDERRUN,
pb_binary_stream_read_svarint64(&stream, &value));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(8, pb_binary_stream_size(&stream));
ck_assert_uint_eq(8, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(0, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
END_TEST
START_TEST (test_enq_init)
{
int err;
if ((err =
memif_init (control_fd_update, TEST_APP_NAME, NULL,
NULL, NULL)) != MEMIF_ERR_SUCCESS)
ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
memif_connection_t conn;
conn.msg_queue = NULL;
conn.args.interface_id = 69;
conn.args.mode = 0;
strncpy ((char *) conn.args.secret, TEST_SECRET, strlen (TEST_SECRET));
if ((err = memif_msg_enq_init (&conn)) != MEMIF_ERR_SUCCESS)
ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
memif_msg_queue_elt_t *e = conn.msg_queue;
ck_assert_uint_eq (e->msg.type, MEMIF_MSG_TYPE_INIT);
ck_assert_int_eq (e->fd, -1);
memif_msg_init_t *i = &e->msg.init;
ck_assert_uint_eq (i->version, MEMIF_VERSION);
ck_assert_uint_eq (i->id, conn.args.interface_id);
ck_assert_uint_eq (i->mode, conn.args.mode);
ck_assert_str_eq ((char *)i->secret, (char *)conn.args.secret);
queue_free (&conn.msg_queue);
}
END_TEST
#ifdef UA_ENABLE_DISCOVERY_SEMAPHORE
#ifndef WIN32
#define SEMAPHORE_PATH "/tmp/open62541-unit-test-semaphore"
#else
#define SEMAPHORE_PATH ".\\open62541-unit-test-semaphore"
#endif
START_TEST(Server_register_semaphore) {
// create the semaphore
#ifndef WIN32
int fd = open(SEMAPHORE_PATH, O_RDWR|O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO);
ck_assert_int_ne(fd, -1);
close(fd);
#else
FILE *fp;
fopen_s(&fp, SEMAPHORE_PATH, "ab+");
ck_assert_ptr_ne(fp, NULL);
fclose(fp);
#endif
UA_Client *clientRegister = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(clientRegister));
UA_StatusCode retval = UA_Client_connect_noSession(clientRegister, "opc.tcp://localhost:4840");
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
retval = UA_Server_register_discovery(server_register, clientRegister, SEMAPHORE_PATH);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_Client_disconnect(clientRegister);
UA_Client_delete(clientRegister);
}
} END_TEST
START_TEST (test_type_get_uid) {
static const struct RFstring s = RF_STRING_STATIC_INIT(
"type foo {a:i8, b:string}\n"
"fn do_something()\n"
"{\n"
"a:foo = foo(15, \"name\")\n"
"b:u32 = 15\n"
"}"
);
front_testdriver_new_ast_main_source(&s);
ck_assert_typecheck_ok();
struct ast_node *fn_impl = ast_node_get_child(front_testdriver_root(), 1);
ck_assert(fn_impl->type == AST_FUNCTION_IMPLEMENTATION);
struct ast_node *block = ast_fnimpl_body_get(fn_impl);
struct ast_node *bop1 = ast_node_get_child(block, 0);
ck_assert(ast_node_is_specific_binaryop(bop1, BINARYOP_ASSIGN));
struct ast_node *a_foo = ast_binaryop_left(bop1);
ck_assert(a_foo);
const struct type *t1 = ast_node_get_type_or_die(a_foo);
size_t s1 = type_get_uid(t1);
ck_assert_uint_eq(s1, 590239457);
struct ast_node *bop2 = ast_node_get_child(block, 1);
ck_assert(ast_node_is_specific_binaryop(bop2, BINARYOP_ASSIGN));
struct ast_node *b_u32 = ast_binaryop_left(bop2);
ck_assert(b_u32);
const struct type *t2 = ast_node_get_type_or_die(b_u32);
size_t s2 = type_get_uid(t2);
ck_assert_uint_eq(s2, 3813314396);
} END_TEST
END_TEST
// check the get length routine for bit order arrays
START_TEST(bitOrderLengthTest)
{
int8_t bitOrder1[] = {
0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
0x01, 0x11, 0x21, -1, -1, 0x51, 0x61, 0x71,
0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
-1, -1, -1, -1, -1, -1, -1, -1,
0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1 };
int8_t bitOrder2[] = {
0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
-1, -1, -1, -1, -1, -1, -1, -1,
0x03, 0x13, -1, 0x33, -1, 0x53, 0x63, 0x73,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1 };
// check lengths
ck_assert_uint_eq(bitOrderLength(bitOrder1), 11);
ck_assert_uint_eq(bitOrderLength(bitOrder2), 16);
}
} END_TEST
/*
* Skip a length-prefixed byte sequence in an underruning binary stream.
*/
START_TEST(test_skip_length_prefix_underrun) {
const uint8_t data[] = { 137, 138, 139, 140 };
const size_t size = 4;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Skip length-prefixed byte sequence */
ck_assert_uint_eq(PB_ERROR_UNDERRUN, pb_binary_stream_skip_length(&stream));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(4, pb_binary_stream_size(&stream));
ck_assert_uint_eq(4, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(0, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
} END_TEST
/*
* Create a copy of a binary stream.
*/
START_TEST(test_copy) {
const uint8_t data[] = { 11, 13, 17 };
const size_t size = 3;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
pb_binary_stream_t copy = pb_binary_stream_copy(&stream);
/* Assert binary stream copy size and offset */
fail_if(pb_binary_stream_empty(©));
ck_assert_uint_eq(3, pb_binary_stream_size(&stream));
ck_assert_uint_eq(0, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(3, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(©);
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
} END_TEST
/*
* Skip a variable-sized integer in a binary stream.
*/
START_TEST(test_skip_varint) {
const uint8_t data[] = { 137, 138, 139, 13, 0, 0, 0, 0 };
const size_t size = 8;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Skip variable-sized integer */
ck_assert_uint_eq(PB_ERROR_NONE, pb_binary_stream_skip_varint(&stream));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(8, pb_binary_stream_size(&stream));
ck_assert_uint_eq(4, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(4, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
} END_TEST
/*
* Skip a length-prefixed byte sequence in a binary stream.
*/
START_TEST(test_skip_length) {
const uint8_t data[] = { 3, 0, 0, 0, 0, 0, 0, 0 };
const size_t size = 8;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Skip length-prefixed byte sequence */
ck_assert_uint_eq(PB_ERROR_NONE, pb_binary_stream_skip_length(&stream));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(8, pb_binary_stream_size(&stream));
ck_assert_uint_eq(4, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(4, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
} END_TEST
/*
* Skip a fixed-sized 64-bit value in a binary stream.
*/
START_TEST(test_skip_fixed64) {
const uint8_t data[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
const size_t size = 8;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Skip 64-bit value (= 8 bytes) */
ck_assert_uint_eq(PB_ERROR_NONE, pb_binary_stream_skip_fixed64(&stream));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(8, pb_binary_stream_size(&stream));
ck_assert_uint_eq(8, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(0, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
} END_TEST
/*
* Skip too many bytes in a binary stream.
*/
START_TEST(test_skip_underrun) {
const uint8_t data[] = { 11, 13, 17 };
const size_t size = 3;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Skip bytes */
ck_assert_uint_eq(PB_ERROR_UNDERRUN, pb_binary_stream_skip(&stream, 10));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(3, pb_binary_stream_size(&stream));
ck_assert_uint_eq(3, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(0, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
END_TEST
START_TEST(SecureChannel_cableunplugged) {
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
UA_StatusCode retval = UA_Client_connect(client, "opc.tcp://localhost:4840");
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant val;
UA_Variant_init(&val);
UA_NodeId nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE);
retval = UA_Client_readValueAttribute(client, nodeId, &val);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant_deleteMembers(&val);
UA_Client_recv = client->connection.recv;
client->connection.recv = UA_Client_recvTesting;
/* Simulate network cable unplugged (no response from server) */
UA_Client_recvTesting_result = UA_STATUSCODE_GOODNONCRITICALTIMEOUT;
UA_Variant_init(&val);
retval = UA_Client_readValueAttribute(client, nodeId, &val);
ck_assert_uint_eq(retval, UA_STATUSCODE_BADCONNECTIONCLOSED);
ck_assert_msg(UA_Client_getState(client) == UA_CLIENTSTATE_DISCONNECTED);
UA_Client_recvTesting_result = UA_STATUSCODE_GOOD;
UA_Client_delete(client);
}
END_TEST
START_TEST(test__ot_erase_sub_tree__write_simple__delete)
{
struct ot_head_t octree;
uint8_t max_tree_height, read_tree_height;
unsigned int i, go_down_steps;
otv_t *read_value, write_value, erase_replace_value, default_value;
struct ot_traversal_state_t node;
ot_vector_t position = {.dim = {0, 0, 0}};
/* Options. */
max_tree_height = 31;
default_value = 5;
write_value = 7;
erase_replace_value = 5;
go_down_steps = 3;
ot_create (&octree, max_tree_height, default_value, 1);
ot_write_simple (&octree, &position, &write_value);
ot_get_head_ptr (&octree, &node);
for (i = 0; i < go_down_steps; ++i) {
ot_move_down_single_step( &node, 0);
}
ot_erase_sub_tree (&octree, &node, 0, &erase_replace_value);
read_value = ot_read_simple (&octree, &position, &read_tree_height);
ck_assert_uint_eq(*read_value, erase_replace_value);
ck_assert_uint_eq( read_tree_height, max_tree_height - go_down_steps);
ot_destroy(&octree);
}
} END_TEST
/*
* Read a byte from a binary stream.
*/
START_TEST(test_read) {
const uint8_t data[] = { 11, 13, 17 };
const size_t size = 3;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create_at(&binary, 2);
/* Read next byte */
uint8_t byte;
ck_assert_uint_eq(PB_ERROR_NONE, pb_binary_stream_read(&stream, &byte));
ck_assert_uint_eq(17, byte);
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(3, pb_binary_stream_size(&stream));
ck_assert_uint_eq(3, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(0, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
} END_TEST
/*
* Read a length-prefixed byte sequence with zero bytes from a binary stream.
*/
START_TEST(test_read_length_zero) {
const uint8_t data[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
const size_t size = 8;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Read length-prefixed byte sequence */
pb_string_t string;
ck_assert_uint_eq(PB_ERROR_NONE,
pb_binary_stream_read_length(&stream, &string));
ck_assert_uint_eq(0, string.size);
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(8, pb_binary_stream_size(&stream));
ck_assert_uint_eq(1, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(7, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
} END_TEST
/*
* Read a fixed-sized 64-bit value from an underruning binary stream.
*/
START_TEST(test_read_fixed64_underrun) {
const uint8_t data[] = { 0, 0, 100, 167, 179, 182, 224 };
const size_t size = 7;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Read 32-bit fixed-sized integer */
uint32_t value;
ck_assert_uint_eq(PB_ERROR_UNDERRUN,
pb_binary_stream_read_fixed64(&stream, &value));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(7, pb_binary_stream_size(&stream));
ck_assert_uint_eq(7, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(0, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
} END_TEST
START_TEST (test_string_buffer_fillfmt) {
unsigned int size;
RFS_PUSH();
char *buff1;
char *buff2;
ck_assert(test_rf_strings_buffer_fillfmt(
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz%d%s",
&size,
&buff1,
42, "ABCD"));
ck_assert_uint_eq(size, 58);
ck_assert_nnt_str_eq_cstr(
buff1,
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz42ABCD");
RFS_PUSH();
ck_assert(test_rf_strings_buffer_fillfmt(
"ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ%s",
&size,
&buff2,
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
ck_assert_uint_eq(size, 104);
ck_assert_nnt_str_eq_cstr(
buff2,
"ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
RFS_POP();
RFS_POP();
} END_TEST
} END_TEST
/*
* Read a 8-bit variable-sized integer from an underruning binary stream.
*/
START_TEST(test_read_varint8_underrun) {
const uint8_t data[] = { 11, 13, 17 };
const size_t size = 3;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create_at(&binary, 3);
/* Read 8-bit variabled-sized integer */
uint8_t value;
ck_assert_uint_eq(PB_ERROR_UNDERRUN,
pb_binary_stream_read_varint8(&stream, &value));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(3, pb_binary_stream_size(&stream));
ck_assert_uint_eq(3, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(0, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
END_TEST
START_TEST(pack_1702_rec_null_ptrs)
{
slurmdb_user_rec_t pack_rec = {0};
pack_rec.admin_level = 1;
pack_rec.uid = 12345;
Buf buf = init_buf(1024);
slurmdb_pack_user_rec(&pack_rec, SLURM_MIN_PROTOCOL_VERSION, buf);
set_buf_offset(buf, 0);
slurmdb_user_rec_t *unpack_rec;
int rc = slurmdb_unpack_user_rec((void **)&unpack_rec, SLURM_MIN_PROTOCOL_VERSION, buf);
ck_assert_int_eq(rc, SLURM_SUCCESS);
ck_assert_uint_eq(pack_rec.admin_level, unpack_rec->admin_level);
ck_assert(pack_rec.assoc_list == unpack_rec->assoc_list);
ck_assert(pack_rec.coord_accts == unpack_rec->coord_accts);
ck_assert(pack_rec.wckey_list == unpack_rec->wckey_list);
ck_assert(pack_rec.default_acct == unpack_rec->default_acct);
ck_assert(pack_rec.default_wckey == unpack_rec->default_wckey);
ck_assert(pack_rec.name == unpack_rec->name);
ck_assert(pack_rec.old_name == unpack_rec->old_name);
ck_assert_uint_eq(pack_rec.uid, unpack_rec->uid);
free_buf(buf);
slurmdb_destroy_user_rec(unpack_rec);
}
} END_TEST
/*
* Read an overflowing 8-bit variable-sized integer from a binary stream.
*/
START_TEST(test_read_varint8_overflow) {
const uint8_t data[] = { 137, 0, 0 };
const size_t size = 3;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Read 8-bit variabled-sized integer */
uint8_t value;
ck_assert_uint_eq(PB_ERROR_OVERFLOW,
pb_binary_stream_read_varint8(&stream, &value));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(3, pb_binary_stream_size(&stream));
ck_assert_uint_eq(1, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(2, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
END_TEST
START_TEST(test_store_load)
{
int res;
uproc_matrix *mat;
size_t rows, cols;
double data[] = {
0.0, 0.1, 0.2, 0.3,
1.0, 1.1, 1.2, 1.3 };
mat = uproc_matrix_create(2, 4, data);
res = uproc_matrix_store(mat, UPROC_IO_GZIP, TMPDATADIR "test.matrix");
ck_assert_msg(res == 0, "storing failed");
uproc_matrix_destroy(mat);
mat = uproc_matrix_load(UPROC_IO_GZIP, TMPDATADIR "test.matrix");
ck_assert_ptr_ne(mat, NULL);
uproc_matrix_dimensions(mat, &rows, &cols);
ck_assert_uint_eq(rows, 2);
ck_assert_uint_eq(cols, 4);
ck_assert(uproc_matrix_get(mat, 0, 0) == 0.0);
ck_assert(uproc_matrix_get(mat, 0, 2) == 0.2);
ck_assert(uproc_matrix_get(mat, 0, 3) == 0.3);
ck_assert(uproc_matrix_get(mat, 1, 0) == 1.0);
ck_assert(uproc_matrix_get(mat, 1, 2) == 1.2);
ck_assert(uproc_matrix_get(mat, 1, 3) == 1.3);
}
} END_TEST
/*
* Read a 32-bit variable-sized integer from a binary stream.
*/
START_TEST(test_read_varint32) {
const uint8_t data[] = { 128, 148, 235, 220, 3 };
const size_t size = 5;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Read 32-bit variabled-sized integer */
uint32_t value;
ck_assert_uint_eq(PB_ERROR_NONE,
pb_binary_stream_read_varint32(&stream, &value));
ck_assert_uint_eq(1000000000, value);
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(5, pb_binary_stream_size(&stream));
ck_assert_uint_eq(5, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(0, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
END_TEST
START_TEST (test_enq_add_region)
{
int err;
if ((err =
memif_init (control_fd_update, TEST_APP_NAME, NULL,
NULL, NULL)) != MEMIF_ERR_SUCCESS)
ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
memif_connection_t conn;
conn.msg_queue = NULL;
conn.regions = (memif_region_t *) malloc (sizeof (memif_region_t));
memif_region_t *mr = conn.regions;
mr->fd = 5;
mr->region_size = 2048;
uint8_t region_index = 0;
if ((err =
memif_msg_enq_add_region (&conn, region_index)) != MEMIF_ERR_SUCCESS)
ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
memif_msg_queue_elt_t *e = conn.msg_queue;
ck_assert_uint_eq (e->msg.type, MEMIF_MSG_TYPE_ADD_REGION);
ck_assert_int_eq (e->fd, mr->fd);
memif_msg_add_region_t *ar = &e->msg.add_region;
ck_assert_uint_eq (ar->index, region_index);
ck_assert_uint_eq (ar->size, mr->region_size);
free (conn.regions);
conn.regions = NULL;
mr = NULL;
queue_free (&conn.msg_queue);
}
} END_TEST
/*
* Read a zig-zag encoded 64-bit variable-sized integer from a binary stream.
*/
START_TEST(test_read_svarint64) {
const uint8_t data[] = { 128, 128, 184, 226, 226, 148, 233, 135, 121, 0 };
const size_t size = 10;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Read signed 64-bit variabled-sized integer */
int64_t value;
ck_assert_uint_eq(PB_ERROR_NONE,
pb_binary_stream_read_svarint64(&stream, &value));
ck_assert_int_eq(-1000000000000000000, value);
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(10, pb_binary_stream_size(&stream));
ck_assert_uint_eq(9, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(1, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
static void
GetEndpointsAndCheck(const char* discoveryUrl, const char* filterTransportProfileUri,
const UA_String expectedEndpointUrls[], size_t expectedEndpointUrlsSize) {
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
ck_assert_uint_eq(UA_Client_connect(client, discoveryUrl), UA_STATUSCODE_GOOD);
UA_EndpointDescription* endpointArray = NULL;
size_t endpointArraySize = 0;
UA_String discoveryUrlUA = UA_String_fromChars(discoveryUrl);
UA_StatusCode retval = GetEndpoints(client, &discoveryUrlUA, &endpointArraySize,
&endpointArray, filterTransportProfileUri);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_String_deleteMembers(&discoveryUrlUA);
ck_assert_uint_eq(endpointArraySize , expectedEndpointUrlsSize);
for(size_t j = 0; j < endpointArraySize && j < expectedEndpointUrlsSize; j++) {
UA_EndpointDescription* endpoint = &endpointArray[j];
ck_assert(UA_String_equal(&endpoint->endpointUrl, &expectedEndpointUrls[j]));
}
UA_Array_delete(endpointArray, endpointArraySize, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
UA_Client_delete(client);
}
} END_TEST
/*
* Read an overflowing 64-bit variable-sized integer from a binary stream.
*/
START_TEST(test_read_svarint64_overflow) {
const uint8_t data[] = { 137, 138, 139, 140, 141, 142, 143, 144, 145, 146 };
const size_t size = 10;
/* Create binary and stream */
pb_binary_t binary = pb_binary_create(data, size);
pb_binary_stream_t stream = pb_binary_stream_create(&binary);
/* Read signed 64-bit variabled-sized integer */
int64_t value;
ck_assert_uint_eq(PB_ERROR_OVERFLOW,
pb_binary_stream_read_svarint64(&stream, &value));
/* Assert binary stream size and offset */
fail_if(pb_binary_stream_empty(&stream));
ck_assert_uint_eq(10, pb_binary_stream_size(&stream));
ck_assert_uint_eq(10, pb_binary_stream_offset(&stream));
ck_assert_uint_eq(0, pb_binary_stream_left(&stream));
/* Free all allocated memory */
pb_binary_stream_destroy(&stream);
pb_binary_destroy(&binary);
} END_TEST
END_TEST
START_TEST(Server_HistorizingRandomIndexBackend)
{
UA_HistoryDataBackend backend = UA_HistoryDataBackend_randomindextest(testData);
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = backend;
setting.maxHistoryDataResponseSize = 1000;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_USER;
serverMutexLock();
UA_StatusCode ret = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
serverMutexUnlock();
ck_assert_str_eq(UA_StatusCode_name(ret), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// read all in one
UA_UInt32 retval = testHistoricalDataBackend(100);
fprintf(stderr, "%d tests failed.\n", retval);
ck_assert_uint_eq(retval, 0);
// read continuous one at one request
retval = testHistoricalDataBackend(1);
fprintf(stderr, "%d tests failed.\n", retval);
ck_assert_uint_eq(retval, 0);
// read continuous two at one request
retval = testHistoricalDataBackend(2);
fprintf(stderr, "%d tests failed.\n", retval);
ck_assert_uint_eq(retval, 0);
UA_HistoryDataBackend_randomindextest_deleteMembers(&backend);
}
} END_TEST
/*
* Create a part from an invalid cursor.
*/
START_TEST(test_create_from_cursor_invalid) {
pb_binary_t binary = pb_binary_create_empty();
pb_message_t message = pb_message_create(&descriptor, &binary);
pb_cursor_t cursor = pb_cursor_create_invalid();
/* Assert cursor validity and error */
fail_if(pb_cursor_valid(&cursor));
ck_assert_uint_eq(PB_ERROR_INVALID, pb_cursor_error(&cursor));
/* Create part from cursor */
pb_part_t part = pb_part_create_from_cursor(&cursor);
/* Assert part validity and error */
fail_if(pb_part_valid(&part));
ck_assert_uint_eq(PB_ERROR_INVALID, pb_part_error(&part));
/* Free all allocated memory */
pb_part_destroy(&part);
pb_cursor_destroy(&cursor);
pb_message_destroy(&message);
pb_binary_destroy(&binary);
} END_TEST
END_TEST
START_TEST(Server_HistorizingStrategyValueSet)
{
// init to a defined value
UA_StatusCode retval = setUInt32(client, outNodeId, 43);
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// set a data backend
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = UA_HistoryDataBackend_Memory(3, 100);
setting.maxHistoryDataResponseSize = 100;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_VALUESET;
serverMutexLock();
retval = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
serverMutexUnlock();
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// fill the data
UA_fakeSleep(100);
UA_DateTime start = UA_DateTime_now();
UA_fakeSleep(100);
for (UA_UInt32 i = 0; i < 10; ++i) {
retval = setUInt32(client, outNodeId, i);
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
UA_fakeSleep(100);
}
UA_DateTime end = UA_DateTime_now();
// request
UA_HistoryReadResponse response;
UA_HistoryReadResponse_init(&response);
requestHistory(start, end, &response, 0, false, NULL);
// test the response
ck_assert_str_eq(UA_StatusCode_name(response.responseHeader.serviceResult), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(response.resultsSize, 1);
for (size_t i = 0; i < response.resultsSize; ++i) {
ck_assert_str_eq(UA_StatusCode_name(response.results[i].statusCode), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(response.results[i].historyData.encoding, UA_EXTENSIONOBJECT_DECODED);
ck_assert(response.results[i].historyData.content.decoded.type == &UA_TYPES[UA_TYPES_HISTORYDATA]);
UA_HistoryData * data = (UA_HistoryData *)response.results[i].historyData.content.decoded.data;
ck_assert(data->dataValuesSize > 0);
for (size_t j = 0; j < data->dataValuesSize; ++j) {
ck_assert(data->dataValues[j].sourceTimestamp >= start && data->dataValues[j].sourceTimestamp < end);
ck_assert_uint_eq(data->dataValues[j].hasSourceTimestamp, true);
ck_assert_str_eq(UA_StatusCode_name(data->dataValues[j].status), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(data->dataValues[j].hasValue, true);
ck_assert(data->dataValues[j].value.type == &UA_TYPES[UA_TYPES_UINT32]);
UA_UInt32 * value = (UA_UInt32 *)data->dataValues[j].value.data;
ck_assert_uint_eq(*value, j);
}
}
UA_HistoryReadResponse_deleteMembers(&response);
UA_HistoryDataBackend_Memory_deleteMembers(&setting.historizingBackend);
}
