Test(data, types_identical_with_single_types) {
struct type type1 = init_type(),
type2 = init_type();
type1.single = tid_integral;
type2.single = tid_integral;
cr_assert(types_identical(&type1, &type2));
type1.single = tid_integral;
type2.single = tid_real;
cr_assert_not(types_identical(&type1, &type2));
type1.single = tid_integral;
cr_assert(types_identical(NULL, NULL));
cr_assert_not(types_identical(&type1, NULL));
cr_assert_not(types_identical(NULL, &type1));
type1.single = tid_alpha;
type2.single = tid_tuple;
cr_assert(types_identical(&type1, &type2));
type2.single = tid_real;
cr_assert(types_identical(&type1, &type2));
type2.single = tid_integral;
cr_assert(types_identical(&type2, &type1));
type2.single = tid_alpha;
cr_assert(types_identical(&type1, &type2));
}
Test(test_pathutils, test_is_regular)
{
int fd = open("test2.file", O_CREAT | O_RDWR, 0644);
int error = close(fd);
cr_assert_not(error, "close error");
cr_assert(is_file_regular("test2.file"), "this is a regular file");
cr_assert_not(is_file_regular("./"), "this is not a regular file");
error = unlink("test2.file");
cr_assert_not(error, "unlink error");
}
Test(test_pathutils, test_is_file_directory)
{
int fd = open("test.file", O_CREAT | O_RDWR, 0644);
cr_assert_not(fd < 0, "open error");
ssize_t done = write(fd, "a", 1);
cr_assert_eq(done, 1, "write error");
int error = close(fd);
cr_assert_not(error, "close error");
cr_assert_not(is_file_directory("test.file"), "File is not a directory!");
cr_assert(is_file_directory("./"), "File is a directory!");
error = unlink("test.file");
cr_assert_not(error, "unlink error");
}
void
assert_forget_negative(DNSCache *cache, gint cache_size)
{
gint i;
const gchar *hn = NULL;
gsize hn_len;
gboolean positive;
gint positive_limit = cache_size / 2;
for (i = 0; i < cache_size; i++)
{
guint32 ni = htonl(i);
hn = NULL;
positive = FALSE;
if (i < positive_limit)
{
cr_assert(dns_cache_lookup(cache, AF_INET, (void *) &ni, &hn, &hn_len, &positive) || !positive,
"hmmm cache forgot positive entries too early, i=%d\n",
i);
}
else
{
cr_assert_not(dns_cache_lookup(cache, AF_INET, (void *) &ni, &hn, &hn_len, &positive) || positive,
"hmmm cache didn't forget negative entries in time, i=%d\n",
i);
}
}
}
static void
_test_empty_db(ContextInfoDB *context_info_db)
{
cr_assert_not(context_info_db_is_loaded(context_info_db) == TRUE,
"Empty ContextInfoDB should be in unloaded state.");
cr_assert_not(context_info_db_is_indexed(context_info_db) == TRUE,
"Empty ContextInfoDB should be in un-indexed state.");
cr_assert_not(context_info_db_contains(context_info_db, "selector") == TRUE,
"Method context_info_db_contains should work with empty ContextInfoDB.");
cr_assert_eq(context_info_db_number_of_records(context_info_db, "selector"), 0,
"Method context_info_db_number should work with empty ContextInfoDB.");
int ctr = 0;
context_info_db_foreach_record(context_info_db, "selector", _count_records,
(gpointer) & ctr);
cr_assert_eq(ctr, 0,
"Method context_info_db_foreach_record should work for with empty ContextInfoDB.");
}
void
handle_new_entry(gpointer user_data)
{
Journald *journald = user_data;
journald_process(journald);
cr_assert_not(poll_triggered, "%s", "Should called only once");
poll_triggered = TRUE;
}
static void
assert_log_message_dropped(const gchar *input)
{
LogParser *parser = create_parser(NULL);
LogMessage *msg = copy_str_into_log_message(input);
cr_assert_not(_process_log_message(parser, msg));
log_msg_unref(msg);
destroy_parser(parser);
}
Test(date, test_date_with_additional_text_at_the_end)
{
const gchar *msg = "2015-01-26T16:14:49+0300 Disappointing log file";
LogParser *parser = _construct_parser(NULL, NULL, LM_TS_STAMP);
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_not(success, "successfully parsed but expected failure, msg=%s", msg);
log_pipe_unref(&parser->super);
log_msg_unref(logmsg);
}
Test(msg_ack, clone_ack)
{
AckRecord *t = ack_record_new();
t->init(t);
LogMessage *cloned = create_clone(t->original, &t->path_options);
log_msg_drop(cloned, &t->path_options, AT_PROCESSED);
cr_assert_not(t->acked);
t->deinit(t);
cr_assert(t->acked);
ack_record_free(t);
}
Test(test_run_id, is_same_run__differs_when_not_same_run)
{
PersistState *state;
state = create_persist_state("test_run_id__is_same_run__differs_when_not_same_run");
run_id_init(state);
int prev_run_id = run_id_get();
state = restart_persist_state(state);
run_id_init(state);
cr_assert_not(run_id_is_same_run(prev_run_id), "Run_id_is_same_run returned true when the run differs");
destroy_persist_state(state);
};
void
assert_forget_all(DNSCache *cache, gint cache_size)
{
gint i;
const gchar *hn = NULL;
gsize hn_len;
gboolean positive;
for (i = 0; i < cache_size; i++)
{
guint32 ni = htonl(i);
hn = NULL;
positive = FALSE;
cr_assert_not(dns_cache_lookup(cache, AF_INET, (void *) &ni, &hn, &hn_len, &positive),
"hmmm cache did not forget an expired entry, i=%d\n",
i);
}
}
