Test(systemd_journal, test_journald_helper)
{
const gchar *persist_file = "test_systemd_journal2.persist";
_init_cfg_with_persist_file(persist_file);
Journald *journald = journald_mock_new();
journald_open(journald, 0);
MockEntry *entry = mock_entry_new("test_data1");
mock_entry_add_data(entry, "MESSAGE=test message");
mock_entry_add_data(entry, "KEY=VALUE");
mock_entry_add_data(entry, "HOST=testhost");
journald_mock_add_entry(journald, entry);
journald_seek_head(journald);
journald_next(journald);
GHashTable *result = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
journald_foreach_data(journald, __helper_test, result);
gchar *message = g_hash_table_lookup(result, "MESSAGE");
gchar *key = g_hash_table_lookup(result, "KEY");
gchar *host = g_hash_table_lookup(result, "HOST");
cr_assert_str_eq(message, "test message", "%s", "Bad item");
cr_assert_str_eq(key, "VALUE", "%s", "Bad item");
cr_assert_str_eq(host, "testhost", "%s", "Bad item");
journald_close(journald);
journald_free(journald);
g_hash_table_unref(result);
_deinit_cfg(persist_file);
}
Test(wildcard_source, test_option_duplication)
{
WildcardSourceDriver *driver = _create_wildcard_filesource("base-dir(/tmp)"
"filename-pattern(*.txt)"
"base-dir(/test_non_existent_dir)"
"filename-pattern(*.log)");
cr_assert_str_eq(driver->base_dir, "/test_non_existent_dir");
cr_assert_str_eq(driver->filename_pattern, "*.log");
}
Test(test_pathutils, test_get_filename_extension)
{
cr_assert_str_eq(get_filename_extension("test.foo"), "foo", "wrong file name extension returned");
cr_assert_str_eq(get_filename_extension("/test/test.foo.bar"), "bar", "wrong file name extension returned");
cr_assert_str_eq(get_filename_extension("/test/.test/test.foo.bar"), "bar", "wrong file name extension returned");
cr_assert_null(get_filename_extension("/test"), "wrong file name extension returned");
cr_assert_null(get_filename_extension("test."), "wrong file name extension returned");
cr_assert_null(get_filename_extension(""), "wrong file name extension returned");
cr_assert_null(get_filename_extension(NULL), "wrong file name extension returned");
}
Test(test_pathutils, test_find_file_in_path)
{
gchar *file;
file = find_file_in_path("/dev", "null", G_FILE_TEST_EXISTS);
cr_assert_str_eq(file, "/dev/null");
g_free(file);
file = find_file_in_path("/home:/dev:/root", "null", G_FILE_TEST_EXISTS);
cr_assert_str_eq(file, "/dev/null");
g_free(file);
}
Test(wildcard_source, initial_test)
{
WildcardSourceDriver *driver = _create_wildcard_filesource("base-dir(/test_non_existent_dir)"
"filename-pattern(*.log)"
"recursive(yes)"
"max-files(100)"
"monitor-method(poll)");
cr_assert_str_eq(driver->base_dir, "/test_non_existent_dir");
cr_assert_str_eq(driver->filename_pattern, "*.log");
cr_assert_eq(driver->max_files, 100);
cr_assert_eq(driver->recursive, TRUE);
cr_assert_eq(driver->monitor_method, MM_POLL);
}
void
_test_default_working_test(TestCase *self, TestSource *src, LogMessage *msg)
{
const gchar *message = log_msg_get_value(msg, LM_V_MESSAGE, NULL);
JournalReaderOptions *options = self->user_data;
cr_assert_str_eq(message, "Dummy message", "%s", "Bad message");
cr_assert_eq(msg->pri, options->default_pri, "%s", "Bad default prio");
cr_assert_eq(options->fetch_limit, 10, "%s", "Bad default fetch_limit");
cr_assert_eq(options->max_field_size, 64 * 1024, "%s", "Bad max field size");
cr_assert_str_eq(options->prefix, ".journald.", "%s", "Bad default prefix value");
cr_assert_str_eq(options->recv_time_zone, cfg->recv_time_zone, "%s", "Bad default timezone");
test_source_finish_tc(src);
}
static void
_assert_control_command_eq(ControlCommand *cmd, ControlCommand *cmd_other)
{
cr_assert_eq(cmd->func, cmd_other->func);
cr_assert_str_eq(cmd->command_name, cmd_other->command_name);
cr_assert_eq(cmd->user_data, cmd_other->user_data);
}
Test(Player, inventory_list_gfx)
{
player_t *pl = player_create_at((vector2d_t){4, 7});
player_inventory_add(pl, FOOD);
dynbuf_t *buf = player_inventory_list(pl);
cr_log_info(buf->b_data);
cr_expect_neq(strstr(buf->b_data, "food 1"), 0);
dynbuf_delete(buf);
player_inventory_add(pl, FOOD);
buf = player_inventory_list(pl);
cr_log_info(buf->b_data);
cr_expect_neq(strstr(buf->b_data, "food 2"), 0);
dynbuf_delete(buf);
player_inventory_add(pl, SIBUR);
player_inventory_add(pl, SIBUR);
player_inventory_add(pl, SIBUR);
player_inventory_add(pl, SIBUR);
buf = player_inventory_list_gfx(pl);
cr_log_info(buf->b_data);
cr_assert_str_eq(buf->b_data, "2 0 0 4 0 0 0");
dynbuf_delete(buf);
player_delete(pl);
}
Test(Player, look_up)
{
player_t *pl = player_create_at((vector2d_t){9, 9});
game_t *gm = game_create(20, 20, 7, 5);
cr_assert(pl);
cr_assert(gm);
game_add_team(gm, "pandas");
pl->p_teamname = strdup("pandas");
cr_assert_neq(game_register_player(gm, pl), -1);
pl->p_dir = (vector2d_t){0, -1};
board_put_resource(gm->ga_board, (vector2d_t){9, 9}, SIBUR);
board_put_resource(gm->ga_board, (vector2d_t){8, 8}, THYSTAME);
board_put_resource(gm->ga_board, (vector2d_t){9, 8}, LINEMATE);
board_put_resource(gm->ga_board, (vector2d_t){10, 8}, DERAUMERE);
board_inc_food(gm->ga_board, (vector2d_t){10, 8});
board_inc_food(gm->ga_board, (vector2d_t){10, 8});
dynbuf_t *buf = player_look(pl, gm);
cr_assert(buf);
cr_log_info(buf->b_data);
cr_assert(strstr(buf->b_data, "player"));
cr_assert_eq(count_char(buf->b_data, ','), 3);
cr_assert_str_eq(buf->b_data,
"[sibur player,thystame,linemate,food food deraumere]");
dynbuf_delete(buf);
game_delete(gm);
}
static void
assert_stomp_header(stomp_frame *frame, char *key, char *value)
{
char *myvalue = g_hash_table_lookup(frame->headers, key);
cr_assert_str_eq(myvalue, value, "Stomp header assertion failed!");
}
Test(add_contextual_data, test_get_selectors)
{
ContextInfoDB *context_info_db = context_info_db_new();
_fill_context_info_db(context_info_db, "selector", "name", "value", 2, 5);
GList *selectors = context_info_db_get_selectors(context_info_db);
GList *selector0 = g_list_find_custom(selectors, "selector-0", _g_strcmp);
GList *selector1 = g_list_find_custom(selectors, "selector-1", _g_strcmp);
cr_assert_str_eq((const gchar *)selector0->data, "selector-0");
cr_assert_str_eq((const gchar *)selector1->data, "selector-1");
context_info_db_unref(context_info_db);
g_list_free(selectors);
}
static void
assert_log_kmsg_value(LogMessage *message, const gchar *key,
const gchar *expected_value)
{
const gchar *actual_value = log_msg_get_value(message,
log_msg_get_value_handle(key),
NULL);
cr_assert_str_eq(actual_value, expected_value);
}
void
_test_program_field_test(TestCase *self, TestSource *src, LogMessage *msg)
{
Journald *journal = self->user_data;
gchar *cursor;
journald_get_cursor(journal, &cursor);
if (strcmp(cursor, "no SYSLOG_IDENTIFIER") != 0)
{
cr_assert_str_eq(log_msg_get_value(msg, LM_V_PROGRAM, NULL), "syslog_program", "%s", "Bad program name");
g_free(cursor);
}
else
{
cr_assert_str_eq(log_msg_get_value(msg, LM_V_PROGRAM, NULL), "comm_program", "%s", "Bad program name");
g_free(cursor);
test_source_finish_tc(src);
}
}
void
__test_other_has_prefix(TestCase *self, LogMessage *msg)
{
gchar *requested_name = g_strdup_printf("%s%s", (gchar *) self->user_data, "_CMDLINE");
gssize value_len;
const gchar *value = log_msg_get_value_by_name(msg, requested_name, &value_len);
cr_assert_str_eq(value, "sshd: foo_user [priv]", "%s", "Bad value for prefixed key");
g_free(requested_name);
}
void
assert_log_message_sdata_pairs(LogMessage *message, struct sdata_pair *expected_sd_pairs)
{
gint i;
for (i = 0; expected_sd_pairs && expected_sd_pairs[i].name != NULL; i++)
{
const gchar *actual_value = log_msg_get_value_by_name(message, expected_sd_pairs[i].name, NULL);
cr_assert_str_eq(actual_value, expected_sd_pairs[i].value);
}
}
void
_test_prefix_test(TestCase *self, TestSource *src, LogMessage *msg)
{
const gchar *message = log_msg_get_value(msg, LM_V_MESSAGE, NULL);
cr_assert_str_eq(message, "pam_unix(sshd:session): session opened for user foo_user by (uid=0)",
"%s", "Bad message");
__test_other_has_prefix(self, msg);
test_source_finish_tc(src);
}
Test(test_run_id, macro_is_empty_if_run_id_is_not_inited)
{
GString *res = g_string_sized_new(0);
run_id_deinit();
run_id_append_formatted_id(res);
cr_assert_str_eq(res->str, "", "Run id is not empty if it is not inited");
g_string_free(res, TRUE);
};
Test(tilde_expansion, in_the_middle)
{
char *result = expand_tilde(
"xstarter, ~/xstarter, xstarter",
mock_home
);
cr_assert_str_eq(
result,
"xstarter, /xstarter/xstarter, xstarter"
);
}
Test(tilde_expansion, multiple_expansions)
{
char *result = expand_tilde(
"~/xs1, $PATH, ~/xs2, ~/xs3, xs",
mock_home
);
cr_assert_str_eq(
result,
"/xstarter/xs1, $PATH, /xstarter/xs2, /xstarter/xs3, xs"
);
}
Test(stomp_proto, test_generate_gstring_from_frame)
{
stomp_frame frame;
GString *actual;
stomp_frame_init(&frame, "SEND", sizeof("SEND"));
stomp_frame_add_header(&frame, "header_name", "header_value");
stomp_frame_set_body(&frame, "body", sizeof("body"));
actual = create_gstring_from_frame(&frame);
cr_assert_str_eq(actual->str, "SEND\nheader_name:header_value\n\nbody", "Generated stomp frame does not match");
stomp_frame_deinit(&frame);
};
Test(tilde_expansion, two_expansions)
{
char *result = expand_tilde(
"~/xstarter, $PATH, ~/xstarter",
mock_home
);
cr_assert_str_eq(
result,
"/xstarter/xstarter, $PATH, /xstarter/xstarter"
);
}
Test(test_run_id, macro_has_the_same_value_as_run_id)
{
PersistState *state;
GString *res = g_string_sized_new(0);
state = create_persist_state("test_run_id__macro_has_the_same_value_as_run_id");
run_id_init(state);
run_id_append_formatted_id(res);
cr_assert_str_eq(res->str, "1", "Run id is formatted incorrectly: %s", res->str);
destroy_persist_state(state);
g_string_free(res, TRUE);
};
void
test_log_messages_can_be_parsed(struct msgparse_params *param)
{
LogMessage *parsed_message;
LogStamp *parsed_timestamp;
time_t now;
GString *sd_str;
parsed_message = _parse_log_message(param->msg, param->parse_flags, param->bad_hostname_re);
parsed_timestamp = &(parsed_message->timestamps[LM_TS_STAMP]);
if (param->expected_stamp_sec)
{
if (param->expected_stamp_sec != 1)
cr_assert_eq(parsed_timestamp->tv_sec, param->expected_stamp_sec,
"Unexpected timestamp, value=%ld, expected=%ld, msg=%s",
parsed_timestamp->tv_sec, param->expected_stamp_sec, param->msg);
cr_assert_eq(parsed_timestamp->tv_usec, param->expected_stamp_usec, "Unexpected microseconds");
cr_assert_eq(parsed_timestamp->zone_offset, param->expected_stamp_ofs, "Unexpected timezone offset");
}
else
{
time(&now);
cr_assert(_absolute_value(parsed_timestamp->tv_sec - now) <= 5,
"Expected parsed message timestamp to be set to now; now='%d', timestamp->tv_sec='%d'",
(gint)now, (gint)parsed_timestamp->tv_sec);
}
cr_assert_eq(parsed_message->pri, param->expected_pri, "Unexpected message priority");
assert_log_message_value(parsed_message, LM_V_HOST, param->expected_host);
assert_log_message_value(parsed_message, LM_V_PROGRAM, param->expected_program);
assert_log_message_value(parsed_message, LM_V_MESSAGE, param->expected_msg);
if (param->expected_pid)
assert_log_message_value(parsed_message, LM_V_PID, param->expected_pid);
if (param->expected_msgid)
assert_log_message_value(parsed_message, LM_V_MSGID, param->expected_msgid);
if (param->expected_sd_str)
{
sd_str = g_string_sized_new(0);
log_msg_format_sdata(parsed_message, sd_str, 0);
cr_assert_str_eq(sd_str->str, param->expected_sd_str, "Unexpected formatted SData");
g_string_free(sd_str, TRUE);
}
assert_log_message_sdata_pairs(parsed_message, param->expected_sd_pairs);
log_msg_unref(parsed_message);
}
void
__test_cursors(Journald *journald)
{
gchar *cursor;
journald_seek_head(journald);
journald_next(journald);
gint result = journald_get_cursor(journald, &cursor);
cr_assert_str_eq(cursor, "test_data1", "%s", "Bad cursor fetched");
\
g_free(cursor);
result = journald_next(journald);
cr_assert_eq(result, 1, "%s", "Bad next step result");
result = journald_get_cursor(journald, &cursor);
cr_assert_str_eq(cursor, "test_data2", "%s", "Bad cursor fetched");
g_free(cursor);
result = journald_next(journald);
cr_assert_eq(result, 0, "%s", "Should not contain more elements");
result = journald_seek_cursor(journald, "test_data1");
cr_assert_eq(result, 0, "%s", "Should find cursor");
result = journald_next(journald);
cr_assert_eq(result, 1, "%s", "Bad next step result");
result = journald_get_cursor(journald, &cursor);
cr_assert_str_eq(cursor, "test_data1", "%s", "Bad cursor fetched");
g_free(cursor);
result = journald_seek_cursor(journald, "test_data2");
cr_assert_eq(result, 0, "%s", "Should find cursor");
result = journald_next(journald);
cr_assert_eq(result, 1, "%s", "Bad next step result");
result = journald_get_cursor(journald, &cursor);
cr_assert_str_eq(cursor, "test_data2", "%s", "Bad cursor fetched");
g_free(cursor);
}
Test(control_cmds, test_stats)
{
StatsCounterItem *counter = NULL;
gchar **stats_result;
const gchar *response;
stats_init();
stats_lock();
StatsClusterKey sc_key;
stats_cluster_logpipe_key_set(&sc_key, SCS_CENTER, "id", "received" );
stats_register_counter(0, &sc_key, SC_TYPE_PROCESSED, &counter);
stats_unlock();
_run_command("STATS", &response);
stats_result = g_strsplit(response, "\n", 2);
cr_assert_str_eq(stats_result[0], "SourceName;SourceId;SourceInstance;State;Type;Number",
"Bad reply");
g_strfreev(stats_result);
stats_destroy();
}
Test(date, test_date_with_guess_timezone)
{
const gchar *msg = "2015-12-30T12:00:00+05:00";
GString *res = g_string_sized_new(128);
LogParser *parser = _construct_parser(NULL, NULL, LM_TS_STAMP);
date_parser_process_flag(parser, "guess-timezone");
LogMessage *logmsg = _construct_logmsg(msg);
gboolean success = log_parser_process(parser, &logmsg, NULL, log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), -1);
cr_assert(success, "failed to parse timestamp, msg=%s", msg);
append_format_unix_time(&logmsg->timestamps[LM_TS_STAMP], res, TS_FMT_ISO, -1, 0);
/* this should fix up the timezone */
cr_assert_str_eq(res->str, "2015-12-30T12:00:00+01:00",
"incorrect date parsed msg=%s result=%s",
msg, res->str);
log_pipe_unref(&parser->super);
log_msg_unref(logmsg);
g_string_free(res, TRUE);
}
Test(control_cmds, test_reset_stats)
{
StatsCounterItem *counter = NULL;
const gchar *response;
stats_init();
stats_lock();
StatsClusterKey sc_key;
stats_cluster_logpipe_key_set(&sc_key, SCS_CENTER, "id", "received" );
stats_register_counter(0, &sc_key, SC_TYPE_PROCESSED, &counter);
stats_counter_set(counter, 666);
stats_unlock();
_run_command("RESET_STATS", &response);
cr_assert(first_line_eq(response, "OK The statistics of syslog-ng have been reset to 0."), "Bad reply");
_run_command("STATS", &response);
cr_assert_str_eq(response,
"SourceName;SourceId;SourceInstance;State;Type;Number\ncenter;id;received;a;processed;0\n.\n",
"Bad reply");
stats_destroy();
}
Test(string_add, simple_line) {
char *str = NULL;
struct descriptor_data d = {
.character = NULL,
.str = &str,
.max_str = 2048
};
char input_str[] = "Tell me what you want, what you really really want.";
char expect_str[sizeof(input_str) + 3];
strcpy(expect_str, input_str);
strcat(expect_str, "\n\r");
string_add(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(d.str);
}
Test(string_add, simple_line_no_menu) {
char *str = NULL;
struct descriptor_data d = {
.character = NULL,
.str = &str,
.max_str = 2048,
.connected = CON_EXDSCR,
};
char input_str[] = "Tell me what you want, what you really really want.";
char expect_str[sizeof(input_str) + 3];
strcpy(expect_str, input_str);
strcat(expect_str, "\n\r");
string_add(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(d.str);
}
Test(string_add, line_with_terminator) {
char *str = NULL;
struct descriptor_data d = {
.character = NULL,
.str = &str,
.max_str = 2048,
};
char input_str[] = "Tell me what you want, what you really really want.@";
char expect_str[] = "Tell me what you want, what you really really want.";
string_add(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(!d.str);
}
Test(string_add, menu_output) {
char *str = NULL;
struct descriptor_data d = {
.character = NULL,
.str = &str,
.max_str = 2048,
.connected = CON_EXDSCR,
};
d.output.head = NULL;
char input_str[] = "Tell me what you want, what you really really want.@";
char expect_str[] = "Tell me what you want, what you really really want.";
string_add(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_str_eq(d.output.head->text, MENU);
cr_assert(!d.str);
}
Test(string_add, line_too_long) {
char *str = NULL;
struct descriptor_data d = {
.character = NULL,
.str = &str,
.max_str = 20
};
char input_str[] = "Tell me what you want, what you really really want.@";
char expect_str[] = "Tell me what you wan";
string_add(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(!d.str);
}
Test(string_add, line_too_long_menu) {
char *str = NULL;
struct descriptor_data d = {
.character = NULL,
.str = &str,
.max_str = 20,
.connected = CON_EXDSCR,
};
char input_str[] = "Tell me what you want, what you really really want.@";
char expect_str[] = "Tell me what you wan";
string_add(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_str_eq(d.output.head->text, MENU);
cr_assert(!d.str);
}
Test(string_add, append) {
char *str = NULL;
struct descriptor_data d = {
.character = NULL,
.str = &str,
.max_str = 2048
};
str = malloc(128);
strcpy(str, "Tell me what you want,");
char input_str[] = " what you really really want.@";
char expect_str[] = "Tell me what you want, what you really really want.";
string_add(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(!d.str);
}
Test(string_add, append_menu) {
char *str = NULL;
struct descriptor_data d = {
.character = NULL,
.str = &str,
.max_str = 2048,
.connected = CON_EXDSCR,
};
str = malloc(128);
strcpy(str, "Tell me what you want,");
char input_str[] = " what you really really want.@";
char expect_str[] = "Tell me what you want, what you really really want.";
string_add(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_str_eq(d.output.head->text, MENU);
cr_assert(!d.str);
}
Test(string_add_static, simple_line) {
char str[2048] = {0};
struct descriptor_data d = {
.character = NULL,
.static_str = str,
.max_str = sizeof(str)
};
char input_str[] = "Tell me what you want, what you really really want.";
char expect_str[sizeof(input_str) + 3];
strcpy(expect_str, input_str);
strcat(expect_str, "\n\r");
string_add_static(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(d.static_str);
}
Test(string_add_static, simple_line_no_menu) {
char str[2048] = {0};
struct descriptor_data d = {
.character = NULL,
.static_str = str,
.max_str = sizeof(str),
.connected = CON_EXDSCR,
};
char input_str[] = "Tell me what you want, what you really really want.";
char expect_str[sizeof(input_str) + 3];
strcpy(expect_str, input_str);
strcat(expect_str, "\n\r");
string_add_static(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(d.static_str);
}
Test(string_add_static, line_with_terminator) {
char str[2048] = {0};
struct descriptor_data d = {
.character = NULL,
.static_str = str,
.max_str = sizeof(str),
};
char input_str[] = "Tell me what you want, what you really really want.@";
char expect_str[] = "Tell me what you want, what you really really want.";
string_add_static(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(!d.static_str);
}
Test(string_add_static, menu_output) {
char str[2048] = {0};
struct descriptor_data d = {
.character = NULL,
.static_str = str,
.max_str = sizeof(str),
.connected = CON_EXDSCR,
};
d.output.head = NULL;
char input_str[] = "Tell me what you want, what you really really want.@";
char expect_str[] = "Tell me what you want, what you really really want.";
string_add_static(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_str_eq(d.output.head->text, MENU);
cr_assert(!d.static_str);
}
Test(string_add_static, line_too_long) {
char str[20] = {0};
struct descriptor_data d = {
.character = NULL,
.static_str = str,
.max_str = sizeof(str),
};
char input_str[] = "Tell me what you want, what you really really want.@";
char expect_str[] = "Tell me what you ";
string_add_static(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(!d.static_str);
}
Test(string_add_static, line_too_long_menu) {
char str[20] = {0};
struct descriptor_data d = {
.character = NULL,
.static_str = str,
.max_str = sizeof(str),
.connected = CON_EXDSCR,
};
char input_str[] = "Tell me what you want, what you really really want.@";
char expect_str[] = "Tell me what you ";
string_add_static(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_str_eq(d.output.head->text, MENU);
cr_assert(!d.static_str);
}
Test(string_add_static, append) {
char str[2048] = {0};
struct descriptor_data d = {
.character = NULL,
.static_str = str,
.max_str = sizeof(str),
};
strcpy(str, "Tell me what you want,");
char input_str[] = " what you really really want.@";
char expect_str[] = "Tell me what you want, what you really really want.";
string_add_static(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_eq(d.output.head, NULL);
cr_assert(!d.static_str);
}
Test(string_add_static, append_menu) {
char str[2048] = {0};
struct descriptor_data d = {
.character = NULL,
.static_str = str,
.max_str = sizeof(str),
.connected = CON_EXDSCR,
};
strcpy(str, "Tell me what you want,");
char input_str[] = " what you really really want.@";
char expect_str[] = "Tell me what you want, what you really really want.";
string_add_static(&d, input_str);
cr_assert_str_eq(str, expect_str);
cr_assert_str_eq(d.output.head->text, MENU);
cr_assert(!d.static_str);
}
void
setup(void)
{
app_startup();
setlocale (LC_ALL, "C");
setenv("TZ", "CET-1", TRUE);
tzset();
configuration = cfg_new_snippet();
/* year heuristics depends on the current time */
/* Dec 30 2015 */
GTimeVal faked_time =
{
.tv_sec = 1451473200,
.tv_usec = 0
};
set_cached_time(&faked_time);
}
void
teardown(void)
{
app_shutdown();
}
TestSuite(date, .init = setup, .fini = teardown);
ParameterizedTestParameters(date, test_date_parser)
{
static struct date_params params[] =
{
{ "2015-01-26T16:14:49+03:00", NULL, NULL, LM_TS_RECVD, "2015-01-26T16:14:49+03:00" },
/* Various ISO8601 formats */
{ "2015-01-26T16:14:49+0300", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+03:00" },
{ "2015-01-26T16:14:49+0330", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+03:30" },
{ "2015-01-26T16:14:49+0200", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+02:00" },
{ "2015-01-26T16:14:49+03:00", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+03:00" },
{ "2015-01-26T16:14:49+03:30", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+03:30" },
{ "2015-01-26T16:14:49+02:00", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+02:00" },
{ "2015-01-26T16:14:49Z", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+00:00" },
{ "2015-01-26T16:14:49A", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49-01:00" },
{ "2015-01-26T16:14:49B", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49-02:00" },
{ "2015-01-26T16:14:49N", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+01:00" },
{ "2015-01-26T16:14:49O", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+02:00" },
{ "2015-01-26T16:14:49GMT", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49+00:00" },
{ "2015-01-26T16:14:49PDT", NULL, NULL, LM_TS_STAMP, "2015-01-26T16:14:49-07:00" },
/* RFC 2822 */
{ "Tue, 27 Jan 2015 11:48:46 +0200", NULL, "%a, %d %b %Y %T %z", LM_TS_STAMP, "2015-01-27T11:48:46+02:00" },
/* Apache-like */
{ "21/Jan/2015:14:40:07 +0500", NULL, "%d/%b/%Y:%T %z", LM_TS_STAMP, "2015-01-21T14:40:07+05:00" },
/* Dates without timezones. America/Phoenix has no DST */
{ "Tue, 27 Jan 2015 11:48:46", NULL, "%a, %d %b %Y %T", LM_TS_STAMP, "2015-01-27T11:48:46+01:00" },
{ "Tue, 27 Jan 2015 11:48:46", "America/Phoenix", "%a, %d %b %Y %T", LM_TS_STAMP, "2015-01-27T11:48:46-07:00" },
{ "Tue, 27 Jan 2015 11:48:46", "+05:00", "%a, %d %b %Y %T", LM_TS_STAMP, "2015-01-27T11:48:46+05:00" },
/* Try without the year. */
{ "01/Jan:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2016-01-01T00:40:07+05:00" },
{ "01/Aug:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2015-08-01T00:40:07+05:00" },
{ "01/Sep:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2015-09-01T00:40:07+05:00" },
{ "01/Oct:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2015-10-01T00:40:07+05:00" },
{ "01/Nov:00:40:07 +0500", NULL, "%d/%b:%T %z", LM_TS_STAMP, "2015-11-01T00:40:07+05:00" },
{ "1446128356 +01:00", NULL, "%s %z", LM_TS_STAMP, "2015-10-29T15:19:16+01:00" },
{ "1446128356", "Europe/Budapest", "%s", LM_TS_STAMP, "2015-10-29T15:19:16+01:00" },
};
return cr_make_param_array(struct date_params, params, sizeof(params) / sizeof(struct date_params));
}
ParameterizedTest(struct date_params *params, date, test_date_parser)
{
LogMessage *logmsg;
LogParser *parser = _construct_parser(params->timezone_, params->format, params->time_stamp);
gboolean success;
GString *res = g_string_sized_new(128);
logmsg = _construct_logmsg(params->msg);
success = log_parser_process(parser, &logmsg, NULL, log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), -1);
cr_assert(success, "unable to parse format=%s msg=%s", params->format, params->msg);
append_format_unix_time(&logmsg->timestamps[params->time_stamp], res, TS_FMT_ISO, -1, 0);
cr_assert_str_eq(res->str, params->expected,
"incorrect date parsed msg=%s format=%s, result=%s, expected=%s",
params->msg, params->format, res->str, params->expected);
g_string_free(res, TRUE);
log_pipe_unref(&parser->super);
log_msg_unref(logmsg);
}
static void
assert_stomp_body(stomp_frame *frame, char *body)
{
cr_assert_str_eq(frame->body, body, "Stomp body assertion failed");
}
