static void test_list_free(void)
{
struct property_list_t list;
CU_ASSERT_EQUAL(proplist_free(NULL), -1);
CU_ASSERT_EQUAL(proplist_init(&list), 0);
CU_ASSERT_EQUAL(proplist_free(&list), 0);
}
static void test_init_exit(void)
{
struct filter_context_t ctx;
struct property_list_t properties;
const char SCRIPT[] = "\n";
memset(&ctx, 0, sizeof(ctx));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
CU_ASSERT_EQUAL(filter->init(NULL, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(filter->init(NULL, &properties), EXIT_FAILURE);
CU_ASSERT_EQUAL(filter->init(&ctx, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(filter->init(&ctx, &properties), EXIT_FAILURE);
proplist_set(&properties, "script", "");
CU_ASSERT_EQUAL_FATAL(filter->init(&ctx, &properties), EXIT_FAILURE);
prepare_script(SCRIPT);
proplist_set(&properties, "script", tmpfilename);
CU_ASSERT_EQUAL(filter->init(&ctx, &properties), EXIT_SUCCESS);
CU_ASSERT_NOT_EQUAL(ctx.data, NULL);
CU_ASSERT_EQUAL(filter->exit(&ctx), EXIT_SUCCESS);
proplist_free(&properties);
}
static void test_read_device(void)
{
struct property_list_t list;
struct serial_config_t cfg = {
"/dev/ttyUSB0",
BAUD_4800,
DATA_BIT_8,
STOP_BIT_1,
PARITY_NONE
};
proplist_init(&list);
CU_ASSERT_EQUAL(prop_serial_read_device(NULL, NULL, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_device(NULL, NULL, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_device(NULL, &list, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_device(NULL, &list, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_device(&cfg, NULL, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_device(&cfg, NULL, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_device(&cfg, &list, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_device(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_device(&cfg, &list, "device"), EXIT_SUCCESS);
proplist_set(&list, "device", "/dev/ttyUSB1");
CU_ASSERT_EQUAL(prop_serial_read_device(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_device(&cfg, &list, "device"), EXIT_SUCCESS);
CU_ASSERT_STRING_EQUAL(cfg.name, "/dev/ttyUSB1");
proplist_free(&list);
}
static void test_func_syslog(void)
{
struct filter_context_t ctx;
struct property_list_t properties;
struct message_t msg_in;
struct message_t msg_out;
const char SCRIPT[] =
"function filter(mout, min)\n"
" syslog(LOG_NOTICE, 'executing filter: testing syslog')\n"
" return FILTER_DISCARD\n"
"end\n"
"\n"
;
memset(&msg_in, 0, sizeof(msg_in));
memset(&msg_out, 0, sizeof(msg_out));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->func);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
proplist_set(&properties, "script", tmpfilename);
prepare_script(SCRIPT);
CU_ASSERT_EQUAL_FATAL(filter->init(&ctx, &properties), EXIT_SUCCESS);
CU_ASSERT_EQUAL(filter->func(&msg_out, &msg_in, &ctx, &properties), FILTER_DISCARD);
CU_ASSERT_EQUAL(filter->exit(&ctx), FILTER_SUCCESS);
proplist_free(&properties);
}
static void test_init_write_timeout(void)
{
struct proc_config_t config;
struct property_list_t properties;
proc_config_init(&config);
proplist_init(&properties);
proplist_set(&properties, "save_timer_id", "5");
proplist_set(&properties, "filename", "/dev/null");
proplist_set(&properties, "min_position_change", "5");
proplist_set(&properties, "write_timeout", "");
CU_ASSERT_EQUAL(proc->init(&config, &properties), EXIT_FAILURE);
CU_ASSERT_EQUAL(proc->exit(&config), EXIT_SUCCESS);
proplist_set(&properties, "write_timeout", "zzz");
CU_ASSERT_EQUAL(proc->init(&config, &properties), EXIT_FAILURE);
CU_ASSERT_EQUAL(proc->exit(&config), EXIT_SUCCESS);
proplist_set(&properties, "write_timeout", "5");
CU_ASSERT_EQUAL(proc->init(&config, &properties), EXIT_SUCCESS);
CU_ASSERT_EQUAL(proc->exit(&config), EXIT_SUCCESS);
proplist_free(&properties);
}
void sv_free( void )
{
proplist_free( the_prop_list );
formula_free( the_formula );
common_sv_free();
global_sv_free();
safe_free( common_l_members );
}
static void test_func_msg_to_table_nmea(void)
{
int rc;
struct filter_context_t ctx;
struct property_list_t properties;
struct message_t msg_in;
struct message_t msg_out;
const char SCRIPT[] =
"function filter(msg_out, msg_in)\n"
" local t = msg_to_table(msg_in)\n"
" if t == nil then\n"
" return FILTER_DISCARD\n"
" end\n"
" if t.msg_type == MSG_NMEA then\n"
" if t.data.nmea.nmea_type == NMEA_RMB then\n"
" if t.data.nmea.raw == 'hello world' then\n"
" return FILTER_SUCCESS\n"
" end\n"
" end\n"
" end\n"
" return FILTER_FAILURE\n"
"end\n"
"\n"
;
memset(&msg_in, 0, sizeof(msg_in));
memset(&msg_out, 0, sizeof(msg_out));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->func);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
proplist_set(&properties, "script", tmpfilename);
prepare_script(SCRIPT);
rc = filter->init(&ctx, &properties);
CU_ASSERT_EQUAL_FATAL(rc, EXIT_SUCCESS);
msg_in.type = MSG_NMEA;
msg_in.data.attr.nmea.type = NMEA_RMB;
strncpy(msg_in.data.attr.nmea.raw, "hello world", sizeof(msg_in.data.attr.nmea.raw));
rc = filter->func(&msg_out, &msg_in, &ctx, &properties);
CU_ASSERT_EQUAL(rc, FILTER_SUCCESS);
CU_ASSERT_EQUAL(filter->exit(&ctx), EXIT_SUCCESS);
proplist_free(&properties);
}
static void test_func_msg_to_table_timer(void) /* TODO: move test to test_lua_message? */
{
int rc;
struct filter_context_t ctx;
struct property_list_t properties;
struct message_t msg_in;
struct message_t msg_out;
const char SCRIPT[] =
"function filter(msg_out, msg_in)\n"
" local t = msg_to_table(msg_in)\n"
" if t == nil then\n"
" return FILTER_DISCARD\n"
" end\n"
" if t.msg_type == MSG_TIMER then\n"
" if t.data.timer_id == 12345678 then\n"
" return FILTER_SUCCESS\n"
" end\n"
" end\n"
" return FILTER_FAILURE\n"
"end\n"
"\n"
;
memset(&msg_in, 0, sizeof(msg_in));
memset(&msg_out, 0, sizeof(msg_out));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->func);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
proplist_set(&properties, "script", tmpfilename);
prepare_script(SCRIPT);
rc = filter->init(&ctx, &properties);
CU_ASSERT_EQUAL_FATAL(rc, EXIT_SUCCESS);
msg_in.type = MSG_TIMER;
msg_in.data.attr.timer_id = 12345678;
rc = filter->func(&msg_out, &msg_in, &ctx, &properties);
CU_ASSERT_EQUAL(rc, FILTER_SUCCESS);
CU_ASSERT_EQUAL(filter->exit(&ctx), EXIT_SUCCESS);
proplist_free(&properties);
}
static void test_read_databits(void)
{
struct property_list_t list;
struct serial_config_t cfg = {
"/dev/ttyUSB0",
BAUD_4800,
DATA_BIT_8,
STOP_BIT_1,
PARITY_NONE
};
proplist_init(&list);
CU_ASSERT_EQUAL(prop_serial_read_databits(NULL, NULL, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_databits(NULL, NULL, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_databits(NULL, &list, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_databits(NULL, &list, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, NULL, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, NULL, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, &list, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, &list, "data"), EXIT_SUCCESS);
proplist_set(&list, "data", "7");
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.data_bits, DATA_BIT_8);
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, &list, "data"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.data_bits, DATA_BIT_7);
proplist_set(&list, "data", "8");
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, &list, "data"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.data_bits, DATA_BIT_8);
proplist_set(&list, "data", "5");
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, &list, "data"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.data_bits, DATA_BIT_5);
proplist_set(&list, "data", "6");
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, &list, "data"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.data_bits, DATA_BIT_6);
proplist_set(&list, "data", "99");
CU_ASSERT_EQUAL(prop_serial_read_databits(&cfg, &list, "data"), EXIT_FAILURE);
proplist_free(&list);
}
static void test_func_msg_clone(void)
{
struct filter_context_t ctx;
struct property_list_t properties;
struct message_t msg_in;
struct message_t msg_out;
const char SCRIPT[] =
"function filter(msg_out, msg_in)\n"
" return msg_clone(msg_out, msg_in)\n"
"end\n"
"\n"
;
memset(&msg_in, 0, sizeof(msg_in));
memset(&msg_out, 0, sizeof(msg_out));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->func);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
proplist_set(&properties, "script", tmpfilename);
prepare_script(SCRIPT);
CU_ASSERT_EQUAL_FATAL(filter->init(&ctx, &properties), EXIT_SUCCESS);
msg_in.type = MSG_TIMER;
msg_in.data.attr.timer_id = 12345678;
CU_ASSERT_EQUAL(filter->func(&msg_out, NULL, &ctx, &properties), FILTER_FAILURE);
CU_ASSERT_EQUAL(filter->func(NULL, &msg_in, &ctx, &properties), FILTER_FAILURE);
CU_ASSERT_EQUAL(filter->func(&msg_out, &msg_in, &ctx, &properties), FILTER_SUCCESS);
CU_ASSERT_EQUAL(msg_out.type, msg_in.type);
CU_ASSERT_EQUAL(msg_out.data.attr.timer_id, msg_in.data.attr.timer_id);
CU_ASSERT_EQUAL(msg_in.type, MSG_TIMER);
CU_ASSERT_EQUAL(msg_in.data.attr.timer_id, 12345678);
CU_ASSERT_EQUAL(msg_out.type, MSG_TIMER);
CU_ASSERT_EQUAL(msg_out.data.attr.timer_id, 12345678);
CU_ASSERT_EQUAL(filter->exit(&ctx), FILTER_SUCCESS);
proplist_free(&properties);
}
static void test_read_parity(void)
{
struct property_list_t list;
struct serial_config_t cfg = {
"/dev/ttyUSB0",
BAUD_4800,
DATA_BIT_8,
STOP_BIT_1,
PARITY_NONE
};
proplist_init(&list);
CU_ASSERT_EQUAL(prop_serial_read_parity(NULL, NULL, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_parity(NULL, NULL, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_parity(NULL, &list, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_parity(NULL, &list, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, NULL, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, NULL, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, &list, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, &list, "parity"), EXIT_SUCCESS);
proplist_set(&list, "parity", "none");
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.parity, PARITY_NONE);
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, &list, "parity"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.parity, PARITY_NONE);
proplist_set(&list, "parity", "even");
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, &list, "parity"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.parity, PARITY_EVEN);
proplist_set(&list, "parity", "odd");
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, &list, "parity"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.parity, PARITY_ODD);
proplist_set(&list, "parity", "mark");
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, &list, "parity"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.parity, PARITY_MARK);
proplist_set(&list, "parity", "zzz");
CU_ASSERT_EQUAL(prop_serial_read_parity(&cfg, &list, "parity"), EXIT_FAILURE);
proplist_free(&list);
}
static void test_list_contains(void)
{
struct property_list_t list;
CU_ASSERT_EQUAL(proplist_init(&list), 0);
CU_ASSERT_EQUAL(proplist_append(&list, "key0", NULL), 0);
CU_ASSERT_EQUAL(proplist_append(&list, "key1", "value"), 0);
CU_ASSERT_EQUAL(proplist_contains(NULL, NULL), 0);
CU_ASSERT_EQUAL(proplist_contains(NULL, ""), 0);
CU_ASSERT_EQUAL(proplist_contains(NULL, "key0"), 0);
CU_ASSERT_EQUAL(proplist_contains(&list, NULL), 0);
CU_ASSERT_EQUAL(proplist_contains(&list, ""), 0);
CU_ASSERT_NOT_EQUAL(proplist_contains(&list, "key0"), 0);
CU_ASSERT_NOT_EQUAL(proplist_contains(&list, "key1"), 0);
CU_ASSERT_EQUAL(proplist_free(&list), 0);
}
static void test_func_msg_to_table(void)
{
int rc;
struct filter_context_t ctx;
struct property_list_t properties;
struct message_t msg_in;
struct message_t msg_out;
const char SCRIPT[] =
"function filter(msg_out, msg_in)\n"
" local t = msg_to_table(msg_in)\n"
" if t == nil then\n"
" return FILTER_DISCARD\n"
" end\n"
" return FILTER_SUCCESS\n"
"end\n"
"\n"
;
memset(&msg_in, 0, sizeof(msg_in));
memset(&msg_out, 0, sizeof(msg_out));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->func);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
proplist_set(&properties, "script", tmpfilename);
prepare_script(SCRIPT);
rc = filter->init(&ctx, &properties);
CU_ASSERT_EQUAL_FATAL(rc, EXIT_SUCCESS);
rc = filter->func(&msg_out, NULL, &ctx, &properties);
CU_ASSERT_EQUAL(rc, FILTER_FAILURE);
msg_in.type = MSG_SYSTEM;
rc = filter->func(&msg_out, &msg_in, &ctx, &properties);
CU_ASSERT_EQUAL(rc, FILTER_SUCCESS);
CU_ASSERT_EQUAL(filter->exit(&ctx), EXIT_SUCCESS);
proplist_free(&properties);
}
static void test_init_name(void)
{
struct property_list_t properties;
struct proc_config_t config;
struct seatalk_serial_data_t * data;
proc_config_init(&config);
proplist_init(&properties);
proplist_set(&properties, "device", "/dev/null");
CU_ASSERT_EQUAL(proc->init(&config, &properties), EXIT_SUCCESS);
CU_ASSERT_PTR_NOT_NULL_FATAL(config.data);
data = (struct seatalk_serial_data_t *)config.data;
CU_ASSERT_STRING_EQUAL(data->config.serial.name, "/dev/null");
CU_ASSERT_EQUAL(proc->exit(&config), EXIT_SUCCESS);
proplist_free(&properties);
}
static void test_init(void)
{
struct property_list_t properties;
struct proc_config_t config;
proc_config_init(&config);
proplist_init(&properties);
CU_ASSERT_EQUAL(proc->init(NULL, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(proc->init(NULL, &properties), EXIT_FAILURE);
CU_ASSERT_EQUAL(proc->init(&config, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(proc->init(&config, &properties), EXIT_SUCCESS);
CU_ASSERT_PTR_NOT_NULL_FATAL(config.data);
CU_ASSERT_EQUAL(proc->exit(&config), EXIT_SUCCESS);
proplist_free(&properties);
}
static void test_read_baudrate(void)
{
struct property_list_t list;
struct serial_config_t cfg = {
"/dev/ttyUSB0",
BAUD_4800,
DATA_BIT_8,
STOP_BIT_1,
PARITY_NONE
};
proplist_init(&list);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(NULL, NULL, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(NULL, NULL, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(NULL, &list, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(NULL, &list, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, NULL, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, NULL, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, &list, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, &list, "baud"), EXIT_SUCCESS);
proplist_set(&list, "baud", "9600");
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.baud_rate, BAUD_4800);
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, &list, "baud"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.baud_rate, BAUD_9600);
proplist_set(&list, "baud", "12345");
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, &list, "baud"), EXIT_FAILURE);
CU_ASSERT_EQUAL(cfg.baud_rate, BAUD_9600);
proplist_set(&list, "baud", "4800");
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, &list, "baud"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.baud_rate, BAUD_4800);
proplist_set(&list, "baud", "99");
CU_ASSERT_EQUAL(prop_serial_read_baudrate(&cfg, &list, "baud"), EXIT_FAILURE);
proplist_free(&list);
}
static void test_debug(void)
{
struct filter_context_t ctx;
struct property_list_t properties;
struct message_t msg_in;
struct message_t msg_out;
const char SCRIPT[] =
"function barfoo()\n"
" return FILTER_DISCARD\n"
"end\n"
"\n"
"function foobar()\n"
" barfoo()\n"
" return FILTER_DISCARD\n"
"end\n"
"\n"
"function filter(mo, mi)\n"
" foobar()\n"
" return FILTER_SUCCESS\n"
"end\n"
;
memset(&msg_in, 0, sizeof(msg_in));
memset(&msg_out, 0, sizeof(msg_out));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->func);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
prepare_script(SCRIPT);
proplist_set(&properties, "script", tmpfilename);
proplist_set(&properties, "DEBUG", "crl");
CU_ASSERT_EQUAL_FATAL(filter->init(&ctx, &properties), EXIT_SUCCESS);
CU_ASSERT_EQUAL(filter->func(&msg_out, &msg_in, &ctx, &properties), FILTER_SUCCESS);
CU_ASSERT_EQUAL(filter->exit(&ctx), EXIT_SUCCESS);
proplist_free(&properties);
}
static void test_list_set(void)
{
struct property_list_t list;
CU_ASSERT_EQUAL(proplist_init(&list), 0);
CU_ASSERT_EQUAL(list.num, 0);
CU_ASSERT_EQUAL(proplist_set(&list, "key", "value"), 0);
CU_ASSERT_EQUAL(list.num, 1);
CU_ASSERT_STRING_EQUAL(proplist_value(&list, "key"), "value");
CU_ASSERT_EQUAL(proplist_set(&list, "key", "value1"), 1);
CU_ASSERT_EQUAL(list.num, 1);
CU_ASSERT_STRING_EQUAL(proplist_value(&list, "key"), "value1");
CU_ASSERT_EQUAL(proplist_set(&list, "key1", NULL), 0);
CU_ASSERT_EQUAL(list.num, 2);
CU_ASSERT_EQUAL(proplist_value(&list, "key1"), NULL);
CU_ASSERT_EQUAL(proplist_set(&list, "key1", "value2"), 1);
CU_ASSERT_EQUAL(list.num, 2);
CU_ASSERT_STRING_EQUAL(proplist_value(&list, "key1"), "value2");
CU_ASSERT_EQUAL(proplist_free(&list), 0);
CU_ASSERT_EQUAL(list.num, 0);
}
static void test_read_stopbits(void)
{
struct property_list_t list;
struct serial_config_t cfg = {
"/dev/ttyUSB0",
BAUD_4800,
DATA_BIT_8,
STOP_BIT_1,
PARITY_NONE
};
proplist_init(&list);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(NULL, NULL, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(NULL, NULL, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(NULL, &list, NULL), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(NULL, &list, ""), EXIT_FAILURE);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(&cfg, NULL, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(&cfg, NULL, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(&cfg, &list, NULL), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(&cfg, &list, "stop"), EXIT_SUCCESS);
proplist_set(&list, "stop", "2");
CU_ASSERT_EQUAL(prop_serial_read_stopbits(&cfg, &list, ""), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.stop_bits, STOP_BIT_1);
CU_ASSERT_EQUAL(prop_serial_read_stopbits(&cfg, &list, "stop"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.stop_bits, STOP_BIT_2);
proplist_set(&list, "stop", "1");
CU_ASSERT_EQUAL(prop_serial_read_stopbits(&cfg, &list, "stop"), EXIT_SUCCESS);
CU_ASSERT_EQUAL(cfg.stop_bits, STOP_BIT_1);
proplist_set(&list, "stop", "99");
CU_ASSERT_EQUAL(prop_serial_read_stopbits(&cfg, &list, "stop"), EXIT_FAILURE);
proplist_free(&list);
}
static void test_func_msg_to_table_nmea_rmc(void) /* TODO: move test to test_lua_message? */
{
struct filter_context_t ctx;
struct property_list_t properties;
struct message_t msg_in;
struct message_t msg_out;
const char SCRIPT[] =
"function filter(msg_out, msg_in)\n"
" local t = msg_to_table(msg_in)\n"
" if t == nil then\n"
" return FILTER_DISCARD\n"
" end\n"
" if t.msg_type ~= MSG_NMEA then\n"
" return FILTER_FAILURE\n"
" end\n"
" if t.data.nmea.nmea_type ~= NMEA_RMC then\n"
" return FILTER_FAILURE\n"
" end\n"
" if t.data.nmea.sentence.status ~= NMEA_STATUS_OK then\n"
" return FILTER_FAILURE\n"
" end\n"
" if t.data.nmea.sentence.lat ~= 1.5 then\n"
" return FILTER_FAILURE\n"
" end\n"
" if t.data.nmea.sentence.lat_dir ~= NMEA_NORTH then\n"
" return FILTER_FAILURE\n"
" end\n"
" if t.data.nmea.sentence.lon ~= 1.5 then\n"
" return FILTER_FAILURE\n"
" end\n"
" if t.data.nmea.sentence.lon_dir ~= NMEA_WEST then\n"
" return FILTER_FAILURE\n"
" end\n"
" if t.data.nmea.sentence.sog ~= 5.0 then\n"
" return FILTER_FAILURE\n"
" end\n"
" if t.data.nmea.sentence.head ~= 10.0 then\n"
" return FILTER_FAILURE\n"
" end\n"
" return FILTER_SUCCESS\n"
"end\n"
"\n"
;
memset(&msg_in, 0, sizeof(msg_in));
memset(&msg_out, 0, sizeof(msg_out));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->func);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
proplist_set(&properties, "script", tmpfilename);
prepare_script(SCRIPT);
CU_ASSERT_EQUAL_FATAL(filter->init(&ctx, &properties), EXIT_SUCCESS);
msg_in.type = MSG_NMEA;
msg_in.data.attr.nmea.type = NMEA_RMC;
msg_in.data.attr.nmea.sentence.rmc.status = NMEA_STATUS_OK;
msg_in.data.attr.nmea.sentence.rmc.lat.d = 1;
msg_in.data.attr.nmea.sentence.rmc.lat.m = 30;
msg_in.data.attr.nmea.sentence.rmc.lat.s.i = 0;
msg_in.data.attr.nmea.sentence.rmc.lat.s.d = 0;
msg_in.data.attr.nmea.sentence.rmc.lat_dir = NMEA_NORTH;
msg_in.data.attr.nmea.sentence.rmc.lon.d = 1;
msg_in.data.attr.nmea.sentence.rmc.lon.m = 30;
msg_in.data.attr.nmea.sentence.rmc.lon.s.i = 0;
msg_in.data.attr.nmea.sentence.rmc.lon.s.d = 0;
msg_in.data.attr.nmea.sentence.rmc.lon_dir = NMEA_WEST;
msg_in.data.attr.nmea.sentence.rmc.sog.i = 5;
msg_in.data.attr.nmea.sentence.rmc.sog.d = 0;
msg_in.data.attr.nmea.sentence.rmc.head.i = 10;
msg_in.data.attr.nmea.sentence.rmc.head.d = 0;
CU_ASSERT_EQUAL(filter->func(&msg_out, &msg_in, &ctx, &properties), FILTER_SUCCESS);
CU_ASSERT_EQUAL(filter->exit(&ctx), EXIT_SUCCESS);
proplist_free(&properties);
}
