So we can, hopefully, debug issues like #40551 more easily.
if (size < 0)
size = strlen(contents);
- fd = mkostemp_safe(name);
- assert_se(fd >= 0);
- assert_se(write(fd, contents, size) == size);
+ ASSERT_OK(fd = mkostemp_safe(name));
+ ASSERT_EQ(write(fd, contents, size), size);
- assert_se(catalog_import_file(&h, fd, name) == code);
+ ASSERT_EQ(catalog_import_file(&h, fd, name), code);
return h;
}
_cleanup_ordered_hashmap_free_ OrderedHashmap *h = NULL;
h = test_import("xxx", -1, -EINVAL);
- assert_se(ordered_hashmap_isempty(h));
+ ASSERT_TRUE(ordered_hashmap_isempty(h));
}
static void test_catalog_import_badid(void) {
"payload\n";
h = test_import(input, -1, 0);
- assert_se(ordered_hashmap_size(h) == 1);
+ ASSERT_EQ(ordered_hashmap_size(h), 1u);
ORDERED_HASHMAP_FOREACH(payload, h) {
printf("expect: %s\n", expect);
printf("actual: %s\n", payload);
- assert_se(streq(expect, payload));
+ ASSERT_STREQ(expect, payload);
}
}
"override payload\n";
h = test_import(input, -1, 0);
- assert_se(ordered_hashmap_size(h) == 1);
+ ASSERT_EQ(ordered_hashmap_size(h), 1u);
ORDERED_HASHMAP_FOREACH(payload, h)
- assert_se(streq(combined, payload));
+ ASSERT_STREQ(combined, payload);
}
static void test_catalog_import_merge_no_body(void) {
"payload\n";
h = test_import(input, -1, 0);
- assert_se(ordered_hashmap_size(h) == 1);
+ ASSERT_EQ(ordered_hashmap_size(h), 1u);
ORDERED_HASHMAP_FOREACH(payload, h)
- assert_se(streq(combined, payload));
+ ASSERT_STREQ(combined, payload);
}
static void test_catalog_update(const char *database) {
- int r;
-
/* Test what happens if there are no files. */
- r = catalog_update(database, NULL, NULL);
- assert_se(r == 0);
+ ASSERT_OK_ZERO(catalog_update(database, NULL, NULL));
/* Test what happens if there are no files in the directory. */
- r = catalog_update(database, NULL, no_catalog_dirs);
- assert_se(r == 0);
+ ASSERT_OK_ZERO(catalog_update(database, NULL, no_catalog_dirs));
/* Make sure that we at least have some files loaded or the
* catalog_list below will fail. */
- r = catalog_update(database, NULL, (const char * const *) catalog_dirs);
- assert_se(r == 0);
+ ASSERT_OK_ZERO(catalog_update(database, NULL, (const char * const *) catalog_dirs));
}
static void test_catalog_file_lang(void) {
_cleanup_free_ char *lang = NULL, *lang2 = NULL, *lang3 = NULL, *lang4 = NULL;
- assert_se(catalog_file_lang("systemd.de_DE.catalog", &lang) == 1);
- assert_se(streq(lang, "de_DE"));
+ ASSERT_EQ(catalog_file_lang("systemd.de_DE.catalog", &lang), 1);
+ ASSERT_STREQ(lang, "de_DE");
- assert_se(catalog_file_lang("systemd..catalog", &lang2) == 0);
- assert_se(lang2 == NULL);
+ ASSERT_OK_ZERO(catalog_file_lang("systemd..catalog", &lang2));
+ ASSERT_NULL(lang2);
- assert_se(catalog_file_lang("systemd.fr.catalog", &lang2) == 1);
- assert_se(streq(lang2, "fr"));
+ ASSERT_EQ(catalog_file_lang("systemd.fr.catalog", &lang2), 1);
+ ASSERT_STREQ(lang2, "fr");
- assert_se(catalog_file_lang("systemd.fr.catalog.gz", &lang3) == 0);
- assert_se(lang3 == NULL);
+ ASSERT_OK_ZERO(catalog_file_lang("systemd.fr.catalog.gz", &lang3));
+ ASSERT_NULL(lang3);
- assert_se(catalog_file_lang("systemd.01234567890123456789012345678901.catalog", &lang3) == 0);
- assert_se(lang3 == NULL);
+ ASSERT_OK_ZERO(catalog_file_lang("systemd.01234567890123456789012345678901.catalog", &lang3));
+ ASSERT_NULL(lang3);
- assert_se(catalog_file_lang("systemd.0123456789012345678901234567890.catalog", &lang3) == 1);
- assert_se(streq(lang3, "0123456789012345678901234567890"));
+ ASSERT_EQ(catalog_file_lang("systemd.0123456789012345678901234567890.catalog", &lang3), 1);
+ ASSERT_STREQ(lang3, "0123456789012345678901234567890");
- assert_se(catalog_file_lang("/x/y/systemd.catalog", &lang4) == 0);
- assert_se(lang4 == NULL);
+ ASSERT_OK_ZERO(catalog_file_lang("/x/y/systemd.catalog", &lang4));
+ ASSERT_NULL(lang4);
- assert_se(catalog_file_lang("/x/y/systemd.ru_RU.catalog", &lang4) == 1);
- assert_se(streq(lang4, "ru_RU"));
+ ASSERT_EQ(catalog_file_lang("/x/y/systemd.ru_RU.catalog", &lang4), 1);
+ ASSERT_STREQ(lang4, "ru_RU");
}
int main(int argc, char *argv[]) {
_cleanup_(unlink_tempfilep) char database[] = "/tmp/test-catalog.XXXXXX";
_cleanup_close_ int fd = -EBADF;
_cleanup_free_ char *text = NULL;
- int r;
setlocale(LC_ALL, "de_DE.UTF-8");
* If it is not, e.g. installed by systemd-tests package, then use installed catalogs. */
catalog_dirs = STRV_MAKE(get_catalog_dir());
- assert_se(access(catalog_dirs[0], F_OK) >= 0);
+ ASSERT_OK_ERRNO(access(catalog_dirs[0], F_OK));
log_notice("Using catalog directory '%s'", catalog_dirs[0]);
test_catalog_file_lang();
test_catalog_import_merge();
test_catalog_import_merge_no_body();
- assert_se((fd = mkostemp_safe(database)) >= 0);
+ ASSERT_OK(fd = mkostemp_safe(database));
test_catalog_update(database);
- r = catalog_list(NULL, database, true);
- assert_se(r >= 0);
+ ASSERT_OK(catalog_list(NULL, database, true));
- r = catalog_list(NULL, database, false);
- assert_se(r >= 0);
+ ASSERT_OK(catalog_list(NULL, database, false));
- assert_se(catalog_get(database, SD_MESSAGE_COREDUMP, &text) >= 0);
+ ASSERT_OK(catalog_get(database, SD_MESSAGE_COREDUMP, &text));
printf(">>>%s<<<\n", text);
return 0;
uint64_t start, end;
int r;
- mmap_cache = mmap_cache_new();
- assert_se(mmap_cache);
+ ASSERT_NOT_NULL(mmap_cache = mmap_cache_new());
/* journal_file_open() requires a valid machine id */
if (sd_id128_get_machine(NULL) < 0)
return log_tests_skipped("No valid machine ID found");
- assert_se(mkdtemp_malloc("/tmp/journal-append-XXXXXX", &tempdir) >= 0);
- assert_se(chdir(tempdir) >= 0);
+ ASSERT_OK(mkdtemp_malloc("/tmp/journal-append-XXXXXX", &tempdir));
+ ASSERT_OK_ERRNO(chdir(tempdir));
(void) chattr_path(tempdir, FS_NOCOW_FL, FS_NOCOW_FL);
log_debug("Opening journal %s/system.journal", tempdir);
if (r < 0)
return log_error_errno(r, "Failed to open the journal: %m");
- assert_se(mj);
+ ASSERT_NOT_NULL(mj);
/* Add a couple of initial messages */
for (int i = 0; i < 10; i++) {
_cleanup_free_ char *message = NULL;
- assert_se(asprintf(&message, "MESSAGE=Initial message %d", i) >= 0);
+ ASSERT_OK_ERRNO(asprintf(&message, "MESSAGE=Initial message %d", i));
r = journal_append_message(mj, message);
if (r < 0)
return log_error_errno(r, "Failed to write to the journal: %m");
uint8_t b;
/* Flip a bit in the journal file */
- r = pread(mj->fd, &b, 1, offset);
- assert_se(r == 1);
+ ASSERT_EQ(pread(mj->fd, &b, 1, offset), 1);
b |= 0x1;
- r = pwrite(mj->fd, &b, 1, offset);
- assert_se(r == 1);
+ ASSERT_EQ(pwrite(mj->fd, &b, 1, offset), 1);
/* Close and reopen the journal to flush all caches and remap
* the corrupted journal */
}
/* Try to write something to the (possibly corrupted) journal */
- assert_se(asprintf(&message, "MESSAGE=Hello world %" PRIu64, offset) >= 0);
+ ASSERT_OK_ERRNO(asprintf(&message, "MESSAGE=Hello world %" PRIu64, offset));
r = journal_append_message(mj, message);
if (r < 0) {
/* We care only about crashes or sanitizer errors,
{}
};
- assert_se(argc >= 0);
- assert_se(argv);
+ ASSERT_GE(argc, 0);
+ ASSERT_NOT_NULL(argv);
while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
switch (c) {
test_setup_logging(LOG_DEBUG);
- assert_se(sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY | SD_JOURNAL_ASSUME_IMMUTABLE) >= 0);
+ ASSERT_OK(sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY | SD_JOURNAL_ASSUME_IMMUTABLE));
- assert_se(sd_journal_add_match(j, "_TRANSPORT=syslog", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "_UID=0", SIZE_MAX) >= 0);
+ ASSERT_OK(sd_journal_add_match(j, "_TRANSPORT=syslog", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "_UID=0", SIZE_MAX));
SD_JOURNAL_FOREACH_BACKWARDS(j) {
const void *d;
size_t l;
- assert_se(sd_journal_get_data(j, "MESSAGE", &d, &l) >= 0);
+ ASSERT_OK(sd_journal_get_data(j, "MESSAGE", &d, &l));
printf("%.*s\n", (int) l, (char*) d);
log_info("testing %s", path);
r = journal_file_parse_uid_from_filename(path, &uid);
- assert_se(r == expected_error);
+ ASSERT_EQ(r, expected_error);
if (r < 0)
- assert_se(uid == UID_INVALID);
+ ASSERT_EQ(uid, UID_INVALID);
else
- assert_se(uid == expected_uid);
+ ASSERT_EQ(uid, expected_uid);
}
TEST(journal_file_parse_uid_from_filename) {
unsigned n, limit;
int r;
- assert_se(m = mmap_cache_new());
- assert_se(mkdtemp_malloc("/var/tmp/test-journal-flush.XXXXXX", &dn) >= 0);
+ ASSERT_NOT_NULL(m = mmap_cache_new());
+ ASSERT_OK(mkdtemp_malloc("/var/tmp/test-journal-flush.XXXXXX", &dn));
(void) chattr_path(dn, FS_NOCOW_FL, FS_NOCOW_FL);
- assert_se(fn = path_join(dn, "test.journal"));
+ ASSERT_NOT_NULL(fn = path_join(dn, "test.journal"));
- r = journal_file_open(-EBADF, fn, O_CREAT|O_RDWR, 0, 0644, 0, NULL, m, NULL, &new_journal);
- assert_se(r >= 0);
+ ASSERT_OK(journal_file_open(-EBADF, fn, O_CREAT|O_RDWR, 0, 0644, 0, NULL, m, NULL, &new_journal));
if (argc > 1)
r = sd_journal_open_files(&j, (const char **) strv_skip(argv, 1), SD_JOURNAL_ASSUME_IMMUTABLE);
if (r < 0)
r = sd_journal_open(&j, SD_JOURNAL_ASSUME_IMMUTABLE);
}
- assert_se(r == 0);
+ ASSERT_OK_ZERO(r);
sd_journal_set_data_threshold(j, 0);
JournalFile *f;
f = j->current_file;
- assert_se(f && f->current_offset > 0);
+ ASSERT_TRUE(f && f->current_offset > 0);
r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
if (r < 0)
log_error_errno(r, "journal_file_move_to_object failed: %m");
- assert_se(r >= 0);
+ ASSERT_OK(r);
r = journal_file_copy_entry(f, new_journal, o, f->current_offset, NULL, NULL);
if (r < 0)
log_warning_errno(r, "journal_file_copy_entry failed: %m");
- assert_se(r >= 0 ||
- IN_SET(r, -EBADMSG, /* corrupted file */
- -EPROTONOSUPPORT, /* unsupported compression */
- -EIO, /* file rotated */
- -EREMCHG)); /* clock rollback */
+ ASSERT_TRUE(r >= 0 ||
+ IN_SET(r, -EBADMSG, /* corrupted file */
+ -EPROTONOSUPPORT, /* unsupported compression */
+ -EIO, /* file rotated */
+ -EREMCHG)); /* clock rollback */
if (++n >= limit)
break;
/* Open the new journal before archiving and offlining the file. */
sd_journal_close(j);
- assert_se(sd_journal_open_directory(&j, dn, SD_JOURNAL_ASSUME_IMMUTABLE) >= 0);
+ ASSERT_OK(sd_journal_open_directory(&j, dn, SD_JOURNAL_ASSUME_IMMUTABLE));
/* Read the online journal. */
- assert_se(sd_journal_seek_tail(j) >= 0);
- assert_se(sd_journal_step_one(j, 0) > 0);
+ ASSERT_OK(sd_journal_seek_tail(j));
+ ASSERT_OK_POSITIVE(sd_journal_step_one(j, 0));
printf("current_journal: %s (%i)\n", j->current_file->path, j->current_file->fd);
- assert_se(show_journal_entry(stdout, j, OUTPUT_EXPORT, 0, 0, NULL, NULL, NULL, &(dual_timestamp) {}, &(sd_id128_t) {}) >= 0);
+ ASSERT_OK(show_journal_entry(stdout, j, OUTPUT_EXPORT, 0, 0, NULL, NULL, NULL, &(dual_timestamp) {}, &(sd_id128_t) {}));
uint64_t p;
- assert_se(journal_file_tail_end_by_mmap(j->current_file, &p) >= 0);
+ ASSERT_OK(journal_file_tail_end_by_mmap(j->current_file, &p));
for (uint64_t q = ALIGN64(p + 1); q < (uint64_t) j->current_file->last_stat.st_size; q = ALIGN64(q + 1)) {
Object *o;
r = journal_file_move_to_object(j->current_file, OBJECT_UNUSED, q, &o);
- assert_se(IN_SET(r, -EBADMSG, -EADDRNOTAVAIL));
+ ASSERT_TRUE(IN_SET(r, -EBADMSG, -EADDRNOTAVAIL));
}
/* Archive and offline file. */
- assert_se(journal_file_archive(new_journal, NULL) >= 0);
- assert_se(journal_file_set_offline(new_journal, /* wait= */ true) >= 0);
+ ASSERT_OK(journal_file_archive(new_journal, NULL));
+ ASSERT_OK(journal_file_set_offline(new_journal, /* wait= */ true));
/* Read the archived and offline journal. */
for (uint64_t q = ALIGN64(p + 1); q < (uint64_t) j->current_file->last_stat.st_size; q = ALIGN64(q + 1)) {
Object *o;
r = journal_file_move_to_object(j->current_file, OBJECT_UNUSED, q, &o);
- assert_se(IN_SET(r, -EBADMSG, -EADDRNOTAVAIL, -EIDRM));
+ ASSERT_TRUE(IN_SET(r, -EBADMSG, -EADDRNOTAVAIL, -EIDRM));
}
}
TEST(journal_flush) {
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
test_journal_flush_one(saved_argc, saved_argv);
}
TEST(journal_flush_compact) {
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
test_journal_flush_one(saved_argc, saved_argv);
}
log_info("Running %d loops", I);
- assert_se(mkdtemp(t));
+ ASSERT_NOT_NULL(mkdtemp(t));
(void) chattr_path(t, FS_NOCOW_FL, FS_NOCOW_FL);
for (i = 0; i < I; i++) {
- r = sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY | SD_JOURNAL_ASSUME_IMMUTABLE);
- assert_se(r == 0);
+ ASSERT_OK_ZERO(sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY | SD_JOURNAL_ASSUME_IMMUTABLE));
sd_journal_close(j);
- r = sd_journal_open_directory(&j, t, SD_JOURNAL_ASSUME_IMMUTABLE);
- assert_se(r == 0);
+ ASSERT_OK_ZERO(sd_journal_open_directory(&j, t, SD_JOURNAL_ASSUME_IMMUTABLE));
- assert_se(sd_journal_seek_head(j) == 0);
- assert_se(j->current_location.type == LOCATION_HEAD);
+ ASSERT_OK_ZERO(sd_journal_seek_head(j));
+ ASSERT_EQ(j->current_location.type, (LocationType) LOCATION_HEAD);
r = pidref_safe_fork("(journal-fork-test)", FORK_WAIT|FORK_LOG, NULL);
if (r == 0) {
- assert_se(j);
+ ASSERT_NOT_NULL(j);
ASSERT_RETURN_EXPECTED_SE(sd_journal_get_realtime_usec(j, NULL) == -ECHILD);
ASSERT_RETURN_EXPECTED_SE(sd_journal_seek_tail(j) == -ECHILD);
- assert_se(j->current_location.type == LOCATION_HEAD);
+ ASSERT_EQ(j->current_location.type, (LocationType) LOCATION_HEAD);
sd_journal_close(j);
_exit(EXIT_SUCCESS);
}
- assert_se(r >= 0);
+ ASSERT_OK(r);
sd_journal_close(j);
j = NULL;
- ASSERT_RETURN_EXPECTED(assert_se(sd_journal_open_directory(&j, t, SD_JOURNAL_LOCAL_ONLY) == -EINVAL));
- assert_se(j == NULL);
+ ASSERT_RETURN_EXPECTED(ASSERT_ERROR(sd_journal_open_directory(&j, t, SD_JOURNAL_LOCAL_ONLY), EINVAL));
+ ASSERT_NULL(j);
}
- assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
+ ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
return 0;
}
test_setup_logging(LOG_DEBUG);
- assert_se(sd_journal_open(&j, SD_JOURNAL_ASSUME_IMMUTABLE) >= 0);
+ ASSERT_OK(sd_journal_open(&j, SD_JOURNAL_ASSUME_IMMUTABLE));
- assert_se(sd_journal_add_match(j, "foobar", SIZE_MAX) < 0);
- assert_se(sd_journal_add_match(j, "foobar=waldo", SIZE_MAX) < 0);
- assert_se(sd_journal_add_match(j, "", SIZE_MAX) < 0);
- assert_se(sd_journal_add_match(j, "=", SIZE_MAX) < 0);
- assert_se(sd_journal_add_match(j, "=xxxxx", SIZE_MAX) < 0);
- assert_se(sd_journal_add_match(j, (uint8_t[4]){'A', '=', '\1', '\2'}, 4) >= 0);
- assert_se(sd_journal_add_match(j, (uint8_t[5]){'B', '=', 'C', '\0', 'D'}, 5) >= 0);
- assert_se(sd_journal_add_match(j, "HALLO=WALDO", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "QUUX=mmmm", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "QUUX=xxxxx", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "HALLO=", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "QUUX=xxxxx", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "QUUX=yyyyy", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "PIFF=paff", SIZE_MAX) >= 0);
+ ASSERT_FAIL(sd_journal_add_match(j, "foobar", SIZE_MAX));
+ ASSERT_FAIL(sd_journal_add_match(j, "foobar=waldo", SIZE_MAX));
+ ASSERT_FAIL(sd_journal_add_match(j, "", SIZE_MAX));
+ ASSERT_FAIL(sd_journal_add_match(j, "=", SIZE_MAX));
+ ASSERT_FAIL(sd_journal_add_match(j, "=xxxxx", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, (uint8_t[4]){'A', '=', '\1', '\2'}, 4));
+ ASSERT_OK(sd_journal_add_match(j, (uint8_t[5]){'B', '=', 'C', '\0', 'D'}, 5));
+ ASSERT_OK(sd_journal_add_match(j, "HALLO=WALDO", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "QUUX=mmmm", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "QUUX=xxxxx", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "HALLO=", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "QUUX=xxxxx", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "QUUX=yyyyy", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "PIFF=paff", SIZE_MAX));
- assert_se(sd_journal_add_disjunction(j) >= 0);
+ ASSERT_OK(sd_journal_add_disjunction(j));
- assert_se(sd_journal_add_match(j, "ONE=one", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "ONE=two", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "TWO=two", SIZE_MAX) >= 0);
+ ASSERT_OK(sd_journal_add_match(j, "ONE=one", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "ONE=two", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "TWO=two", SIZE_MAX));
- assert_se(sd_journal_add_conjunction(j) >= 0);
+ ASSERT_OK(sd_journal_add_conjunction(j));
- assert_se(sd_journal_add_match(j, "L4_1=yes", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "L4_1=ok", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "L4_2=yes", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "L4_2=ok", SIZE_MAX) >= 0);
+ ASSERT_OK(sd_journal_add_match(j, "L4_1=yes", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "L4_1=ok", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "L4_2=yes", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "L4_2=ok", SIZE_MAX));
- assert_se(sd_journal_add_disjunction(j) >= 0);
+ ASSERT_OK(sd_journal_add_disjunction(j));
- assert_se(sd_journal_add_match(j, "L3=yes", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "L3=ok", SIZE_MAX) >= 0);
+ ASSERT_OK(sd_journal_add_match(j, "L3=yes", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "L3=ok", SIZE_MAX));
- assert_se(t = journal_make_match_string(j));
+ ASSERT_NOT_NULL(t = journal_make_match_string(j));
printf("resulting match expression is: %s\n", t);
- assert_se(streq(t, "(((L3=ok OR L3=yes) OR ((L4_2=ok OR L4_2=yes) AND (L4_1=ok OR L4_1=yes))) AND ((TWO=two AND (ONE=two OR ONE=one)) OR (PIFF=paff AND (QUUX=yyyyy OR QUUX=xxxxx OR QUUX=mmmm) AND (HALLO= OR HALLO=WALDO) AND B=C\\000D AND A=\\001\\002)))"));
+ ASSERT_STREQ(t, "(((L3=ok OR L3=yes) OR ((L4_2=ok OR L4_2=yes) AND (L4_1=ok OR L4_1=yes))) AND ((TWO=two AND (ONE=two OR ONE=one)) OR (PIFF=paff AND (QUUX=yyyyy OR QUUX=xxxxx OR QUUX=mmmm) AND (HALLO= OR HALLO=WALDO) AND B=C\\000D AND A=\\001\\002)))");
return 0;
}
#include "tests.h"
TEST(journal_print) {
- assert_se(sd_journal_print(LOG_INFO, "XXX") == 0);
- assert_se(sd_journal_print(LOG_INFO, "%s", "YYY") == 0);
- assert_se(sd_journal_print(LOG_INFO, "X%4094sY", "ZZZ") == 0);
- assert_se(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 3, "ZZZ") == 0);
- assert_se(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 2, "ZZZ") == -ENOBUFS);
+ ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "XXX"));
+ ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "%s", "YYY"));
+ ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "X%4094sY", "ZZZ"));
+ ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 3, "ZZZ"));
+ ASSERT_ERROR(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 2, "ZZZ"), ENOBUFS);
}
TEST(journal_send) {
_cleanup_free_ char *huge = NULL;
#define HUGE_SIZE (4096*1024)
- assert_se(huge = malloc(HUGE_SIZE));
+ ASSERT_NOT_NULL(huge = malloc(HUGE_SIZE));
/* utf-8 and non-utf-8, message-less and message-ful iovecs */
struct iovec graph1[] = {
{(char*) "MESSAGE=graph\n", STRLEN("MESSAGE=graph\n")}
};
- assert_se(sd_journal_print(LOG_INFO, "piepapo") == 0);
+ ASSERT_OK_ZERO(sd_journal_print(LOG_INFO, "piepapo"));
- assert_se(sd_journal_send("MESSAGE=foobar",
- "VALUE=%i", 7,
- NULL) == 0);
+ ASSERT_OK_ZERO(sd_journal_send("MESSAGE=foobar",
+ "VALUE=%i", 7,
+ NULL));
errno = ENOENT;
- assert_se(sd_journal_perror("Foobar") == 0);
+ ASSERT_OK_ZERO(sd_journal_perror("Foobar"));
- assert_se(sd_journal_perror("") == 0);
+ ASSERT_OK_ZERO(sd_journal_perror(""));
memcpy(huge, "HUGE=", STRLEN("HUGE="));
memset(&huge[STRLEN("HUGE=")], 'x', HUGE_SIZE - STRLEN("HUGE=") - 1);
huge[HUGE_SIZE - 1] = '\0';
- assert_se(sd_journal_send("MESSAGE=Huge field attached",
- huge,
- NULL) == 0);
+ ASSERT_OK_ZERO(sd_journal_send("MESSAGE=Huge field attached",
+ huge,
+ NULL));
- assert_se(sd_journal_send("MESSAGE=uiui",
- "VALUE=A",
- "VALUE=B",
- "VALUE=C",
- "SINGLETON=1",
- "OTHERVALUE=X",
- "OTHERVALUE=Y",
- "WITH_BINARY=this is a binary value \a",
- NULL) == 0);
+ ASSERT_OK_ZERO(sd_journal_send("MESSAGE=uiui",
+ "VALUE=A",
+ "VALUE=B",
+ "VALUE=C",
+ "SINGLETON=1",
+ "OTHERVALUE=X",
+ "OTHERVALUE=Y",
+ "WITH_BINARY=this is a binary value \a",
+ NULL));
syslog(LOG_NOTICE, "Hello World!");
- assert_se(sd_journal_print(LOG_NOTICE, "Hello World") == 0);
+ ASSERT_OK_ZERO(sd_journal_print(LOG_NOTICE, "Hello World"));
- assert_se(sd_journal_send("MESSAGE=Hello World!",
- "MESSAGE_ID=52fb62f99e2c49d89cfbf9d6de5e3555",
- "PRIORITY=5",
- "HOME=%s", getenv("HOME"),
- "TERM=%s", getenv("TERM"),
- "PAGE_SIZE=%li", sysconf(_SC_PAGESIZE),
- "N_CPUS=%li", sysconf(_SC_NPROCESSORS_ONLN),
- NULL) == 0);
+ ASSERT_OK_ZERO(sd_journal_send("MESSAGE=Hello World!",
+ "MESSAGE_ID=52fb62f99e2c49d89cfbf9d6de5e3555",
+ "PRIORITY=5",
+ "HOME=%s", getenv("HOME"),
+ "TERM=%s", getenv("TERM"),
+ "PAGE_SIZE=%li", sysconf(_SC_PAGESIZE),
+ "N_CPUS=%li", sysconf(_SC_NPROCESSORS_ONLN),
+ NULL));
- assert_se(sd_journal_sendv(graph1, 1) == 0);
- assert_se(sd_journal_sendv(graph2, 1) == 0);
- assert_se(sd_journal_sendv(message1, 1) == 0);
- assert_se(sd_journal_sendv(message2, 1) == 0);
+ ASSERT_OK_ZERO(sd_journal_sendv(graph1, 1));
+ ASSERT_OK_ZERO(sd_journal_sendv(graph2, 1));
+ ASSERT_OK_ZERO(sd_journal_sendv(message1, 1));
+ ASSERT_OK_ZERO(sd_journal_sendv(message2, 1));
/* test without location fields */
#undef sd_journal_sendv
- assert_se(sd_journal_sendv(graph1, 1) == 0);
- assert_se(sd_journal_sendv(graph2, 1) == 0);
- assert_se(sd_journal_sendv(message1, 1) == 0);
- assert_se(sd_journal_sendv(message2, 1) == 0);
+ ASSERT_OK_ZERO(sd_journal_sendv(graph1, 1));
+ ASSERT_OK_ZERO(sd_journal_sendv(graph2, 1));
+ ASSERT_OK_ZERO(sd_journal_sendv(message1, 1));
+ ASSERT_OK_ZERO(sd_journal_sendv(message2, 1));
/* The above syslog() opens a fd which is stored in libc, and the valgrind reports the fd is
* leaked when we do not call closelog(). */
#include "tests.h"
#include "time-util.h"
-#define N_ENTRIES 200
+#define N_ENTRIES 200u
static void verify_contents(sd_journal *j, unsigned skip) {
unsigned i;
- assert_se(j);
+ ASSERT_NOT_NULL(j);
i = 0;
SD_JOURNAL_FOREACH(j) {
size_t l;
unsigned u = 0;
- assert_se(sd_journal_get_cursor(j, &k) >= 0);
+ ASSERT_OK(sd_journal_get_cursor(j, &k));
printf("cursor: %s\n", k);
free(k);
- assert_se(sd_journal_get_data(j, "MAGIC", &d, &l) >= 0);
+ ASSERT_OK(sd_journal_get_data(j, "MAGIC", &d, &l));
printf("\t%.*s\n", (int) l, (const char*) d);
- assert_se(sd_journal_get_data(j, "NUMBER", &d, &l) >= 0);
- assert_se(k = strndup(d, l));
+ ASSERT_OK(sd_journal_get_data(j, "NUMBER", &d, &l));
+ ASSERT_NOT_NULL(k = strndup(d, l));
printf("\t%s\n", k);
if (skip > 0) {
- assert_se(safe_atou(k + 7, &u) >= 0);
- assert_se(i == u);
+ ASSERT_OK(safe_atou(k + 7, &u));
+ ASSERT_EQ(i, u);
i += skip;
}
free(k);
- assert_se(sd_journal_get_cursor(j, &c) >= 0);
- assert_se(sd_journal_test_cursor(j, c) > 0);
+ ASSERT_OK(sd_journal_get_cursor(j, &c));
+ ASSERT_OK_POSITIVE(sd_journal_test_cursor(j, c));
free(c);
}
if (skip > 0)
- assert_se(i == N_ENTRIES);
+ ASSERT_EQ(i, N_ENTRIES);
}
static void run_test(void) {
size_t l;
dual_timestamp previous_ts = DUAL_TIMESTAMP_NULL;
- m = mmap_cache_new();
- assert_se(m != NULL);
+ ASSERT_NOT_NULL(m = mmap_cache_new());
- assert_se(mkdtemp(t));
- assert_se(chdir(t) >= 0);
+ ASSERT_NOT_NULL(mkdtemp(t));
+ ASSERT_OK_ERRNO(chdir(t));
(void) chattr_path(t, FS_NOCOW_FL, FS_NOCOW_FL);
- assert_se(journal_file_open(-EBADF, "one.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &one) == 0);
- assert_se(journal_file_open(-EBADF, "two.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &two) == 0);
- assert_se(journal_file_open(-EBADF, "three.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &three) == 0);
+ ASSERT_OK_ZERO(journal_file_open(-EBADF, "one.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &one));
+ ASSERT_OK_ZERO(journal_file_open(-EBADF, "two.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &two));
+ ASSERT_OK_ZERO(journal_file_open(-EBADF, "three.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &three));
for (i = 0; i < N_ENTRIES; i++) {
char *p, *q;
previous_ts = ts;
- assert_se(asprintf(&p, "NUMBER=%u", i) >= 0);
+ ASSERT_OK_ERRNO(asprintf(&p, "NUMBER=%u", i));
iovec[0] = IOVEC_MAKE(p, strlen(p));
- assert_se(asprintf(&q, "MAGIC=%s", i % 5 == 0 ? "quux" : "waldo") >= 0);
+ ASSERT_OK_ERRNO(asprintf(&q, "MAGIC=%s", i % 5 == 0 ? "quux" : "waldo"));
iovec[1] = IOVEC_MAKE(q, strlen(q));
if (i % 10 == 0)
- assert_se(journal_file_append_entry(three, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL) == 0);
+ ASSERT_OK_ZERO(journal_file_append_entry(three, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL));
else {
if (i % 3 == 0)
- assert_se(journal_file_append_entry(two, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL) == 0);
+ ASSERT_OK_ZERO(journal_file_append_entry(two, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL));
- assert_se(journal_file_append_entry(one, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL) == 0);
+ ASSERT_OK_ZERO(journal_file_append_entry(one, &ts, NULL, iovec, 2, NULL, NULL, NULL, NULL));
}
free(p);
(void) journal_file_offline_close(two);
(void) journal_file_offline_close(three);
- assert_se(sd_journal_open_directory(&j, t, SD_JOURNAL_ASSUME_IMMUTABLE) >= 0);
+ ASSERT_OK(sd_journal_open_directory(&j, t, SD_JOURNAL_ASSUME_IMMUTABLE));
- assert_se(sd_journal_add_match(j, "MAGIC=quux", SIZE_MAX) >= 0);
+ ASSERT_OK(sd_journal_add_match(j, "MAGIC=quux", SIZE_MAX));
SD_JOURNAL_FOREACH_BACKWARDS(j) {
_cleanup_free_ char *c;
- assert_se(sd_journal_get_data(j, "NUMBER", &data, &l) >= 0);
+ ASSERT_OK(sd_journal_get_data(j, "NUMBER", &data, &l));
printf("\t%.*s\n", (int) l, (const char*) data);
- assert_se(sd_journal_get_cursor(j, &c) >= 0);
- assert_se(sd_journal_test_cursor(j, c) > 0);
+ ASSERT_OK(sd_journal_get_cursor(j, &c));
+ ASSERT_OK_POSITIVE(sd_journal_test_cursor(j, c));
}
SD_JOURNAL_FOREACH(j) {
_cleanup_free_ char *c;
- assert_se(sd_journal_get_data(j, "NUMBER", &data, &l) >= 0);
+ ASSERT_OK(sd_journal_get_data(j, "NUMBER", &data, &l));
printf("\t%.*s\n", (int) l, (const char*) data);
- assert_se(sd_journal_get_cursor(j, &c) >= 0);
- assert_se(sd_journal_test_cursor(j, c) > 0);
+ ASSERT_OK(sd_journal_get_cursor(j, &c));
+ ASSERT_OK_POSITIVE(sd_journal_test_cursor(j, c));
}
sd_journal_flush_matches(j);
verify_contents(j, 1);
printf("NEXT TEST\n");
- assert_se(sd_journal_add_match(j, "MAGIC=quux", SIZE_MAX) >= 0);
+ ASSERT_OK(sd_journal_add_match(j, "MAGIC=quux", SIZE_MAX));
- assert_se(z = journal_make_match_string(j));
+ ASSERT_NOT_NULL(z = journal_make_match_string(j));
printf("resulting match expression is: %s\n", z);
free(z);
printf("NEXT TEST\n");
sd_journal_flush_matches(j);
- assert_se(sd_journal_add_match(j, "MAGIC=waldo", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "NUMBER=10", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "NUMBER=11", SIZE_MAX) >= 0);
- assert_se(sd_journal_add_match(j, "NUMBER=12", SIZE_MAX) >= 0);
+ ASSERT_OK(sd_journal_add_match(j, "MAGIC=waldo", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "NUMBER=10", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "NUMBER=11", SIZE_MAX));
+ ASSERT_OK(sd_journal_add_match(j, "NUMBER=12", SIZE_MAX));
- assert_se(z = journal_make_match_string(j));
+ ASSERT_NOT_NULL(z = journal_make_match_string(j));
printf("resulting match expression is: %s\n", z);
free(z);
verify_contents(j, 0);
- assert_se(sd_journal_query_unique(j, "NUMBER") >= 0);
+ ASSERT_OK(sd_journal_query_unique(j, "NUMBER"));
SD_JOURNAL_FOREACH_UNIQUE(j, data, l)
printf("%.*s\n", (int) l, (const char*) data);
- assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
+ ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
}
int main(int argc, char *argv[]) {
/* Run this test multiple times with different configurations of features. */
- assert_se(setenv("SYSTEMD_JOURNAL_KEYED_HASH", "0", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_KEYED_HASH", "0", 1));
run_test();
- assert_se(setenv("SYSTEMD_JOURNAL_KEYED_HASH", "1", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_KEYED_HASH", "1", 1));
run_test();
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
run_test();
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
run_test();
return 0;
static void bit_toggle(const char *fn, uint64_t p) {
uint8_t b;
- ssize_t r;
int fd;
- fd = open(fn, O_RDWR|O_CLOEXEC);
- assert_se(fd >= 0);
+ ASSERT_OK_ERRNO(fd = open(fn, O_RDWR|O_CLOEXEC));
- r = pread(fd, &b, 1, p/8);
- assert_se(r == 1);
+ ASSERT_EQ(pread(fd, &b, 1, p/8), 1);
b ^= 1 << (p % 8);
- r = pwrite(fd, &b, 1, p/8);
- assert_se(r == 1);
+ ASSERT_EQ(pwrite(fd, &b, 1, p/8), 1);
safe_close(fd);
}
JournalFile *f;
int r;
- m = mmap_cache_new();
- assert_se(m != NULL);
+ ASSERT_NOT_NULL(m = mmap_cache_new());
r = journal_file_open(
/* fd= */ -EBADF,
uint64_t start, end;
int r;
- m = mmap_cache_new();
- assert_se(m != NULL);
+ ASSERT_NOT_NULL(m = mmap_cache_new());
/* journal_file_open() requires a valid machine id */
if (sd_id128_get_machine(NULL) < 0)
test_setup_logging(LOG_DEBUG);
- assert_se(mkdtemp(t));
- assert_se(chdir(t) >= 0);
+ ASSERT_NOT_NULL(mkdtemp(t));
+ ASSERT_OK_ERRNO(chdir(t));
(void) chattr_path(t, FS_NOCOW_FL, FS_NOCOW_FL);
log_info("Generating a test journal");
- assert_se(journal_file_open(
+ ASSERT_OK_ZERO(journal_file_open(
/* fd= */ -EBADF,
"test.journal",
O_RDWR|O_CREAT,
/* metrics= */ NULL,
m,
/* template= */ NULL,
- &df) == 0);
+ &df));
for (size_t n = 0; n < N_ENTRIES; n++) {
_cleanup_free_ char *test = NULL;
struct dual_timestamp ts;
dual_timestamp_now(&ts);
- assert_se(asprintf(&test, "RANDOM=%li", random() % RANDOM_RANGE));
+ ASSERT_OK_ERRNO(asprintf(&test, "RANDOM=%li", random() % RANDOM_RANGE));
iovec = IOVEC_MAKE_STRING(test);
- assert_se(journal_file_append_entry(
+ ASSERT_OK_ZERO(journal_file_append_entry(
df,
&ts,
/* boot_id= */ NULL,
/* seqnum= */ NULL,
/* seqnum_id= */ NULL,
/* ret_object= */ NULL,
- /* ret_offset= */ NULL) == 0);
+ /* ret_offset= */ NULL));
}
(void) journal_file_offline_close(df);
log_info("Verifying with key: %s", strna(verification_key));
- assert_se(journal_file_open(
+ ASSERT_OK_ZERO(journal_file_open(
/* fd= */ -EBADF,
"test.journal",
O_RDONLY,
/* metrics= */ NULL,
m,
/* template= */ NULL,
- &f) == 0);
+ &f));
journal_file_print_header(f);
journal_file_dump(f);
- assert_se(journal_file_verify(f, verification_key, &from, &to, &total, true) >= 0);
+ ASSERT_OK(journal_file_verify(f, verification_key, &from, &to, &total, true));
if (verification_key && JOURNAL_HEADER_SEALED(f->header))
log_info("=> Validated from %s to %s, %s missing",
FORMAT_TIMESPAN(total > to ? total - to : 0, 0));
(void) journal_file_close(f);
- assert_se(stat("test.journal", &st) >= 0);
+ ASSERT_OK_ERRNO(stat("test.journal", &st));
start = 38448 * 8 + 0;
end = max_iterations < 0 ? (uint64_t)st.st_size * 8 : start + max_iterations;
bit_toggle("test.journal", p);
}
- assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
+ ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
return 0;
}
max_iterations = -1;
}
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
run_test(verification_key, max_iterations);
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
run_test(verification_key, max_iterations);
#if HAVE_GCRYPT
if (argc <= 1) {
verification_key = "c262bd-85187f-0b1b04-877cc5/1c7af8-35a4e900";
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
run_test(verification_key, max_iterations);
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
run_test(verification_key, max_iterations);
}
#endif
static bool arg_keep = false;
static void mkdtemp_chdir_chattr(char *path) {
- assert_se(mkdtemp(path));
- assert_se(chdir(path) >= 0);
+ ASSERT_NOT_NULL(mkdtemp(path));
+ ASSERT_OK_ERRNO(chdir(path));
/* Speed up things a bit on btrfs, ensuring that CoW is turned off for all files created in our
* directory during the test run */
sd_id128_t fake_boot_id;
char t[] = "/var/tmp/journal-XXXXXX";
- m = mmap_cache_new();
- assert_se(m != NULL);
+ ASSERT_NOT_NULL(m = mmap_cache_new());
mkdtemp_chdir_chattr(t);
- assert_se(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f) == 0);
+ ASSERT_OK_ZERO(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f));
- assert_se(dual_timestamp_now(&ts));
- assert_se(sd_id128_randomize(&fake_boot_id) == 0);
+ ASSERT_NOT_NULL(dual_timestamp_now(&ts));
+ ASSERT_OK_ZERO(sd_id128_randomize(&fake_boot_id));
iovec = IOVEC_MAKE_STRING(test);
- assert_se(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL) == 0);
+ ASSERT_OK_ZERO(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL));
iovec = IOVEC_MAKE_STRING(test2);
- assert_se(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL) == 0);
+ ASSERT_OK_ZERO(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL));
iovec = IOVEC_MAKE_STRING(test);
- assert_se(journal_file_append_entry(f, &ts, &fake_boot_id, &iovec, 1, NULL, NULL, NULL, NULL) == 0);
+ ASSERT_OK_ZERO(journal_file_append_entry(f, &ts, &fake_boot_id, &iovec, 1, NULL, NULL, NULL, NULL));
#if HAVE_GCRYPT
journal_file_append_tag(f);
#endif
journal_file_dump(f);
- assert_se(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p) == 1);
- assert_se(le64toh(o->entry.seqnum) == 1);
+ ASSERT_EQ(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(1));
- assert_se(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p) == 1);
- assert_se(le64toh(o->entry.seqnum) == 2);
+ ASSERT_EQ(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(2));
- assert_se(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p) == 1);
- assert_se(le64toh(o->entry.seqnum) == 3);
- assert_se(sd_id128_equal(o->entry.boot_id, fake_boot_id));
+ ASSERT_EQ(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(3));
+ ASSERT_EQ_ID128(o->entry.boot_id, fake_boot_id);
- assert_se(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p) == 0);
+ ASSERT_OK_ZERO(journal_file_next_entry(f, p, DIRECTION_DOWN, &o, &p));
- assert_se(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p) == 1);
- assert_se(le64toh(o->entry.seqnum) == 1);
+ ASSERT_EQ(journal_file_next_entry(f, 0, DIRECTION_DOWN, &o, &p), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(1));
- assert_se(journal_file_find_data_object(f, test, strlen(test), &d, NULL) == 1);
- assert_se(journal_file_move_to_entry_for_data(f, d, DIRECTION_DOWN, &o, NULL) == 1);
- assert_se(le64toh(o->entry.seqnum) == 1);
+ ASSERT_EQ(journal_file_find_data_object(f, test, strlen(test), &d, NULL), 1);
+ ASSERT_EQ(journal_file_move_to_entry_for_data(f, d, DIRECTION_DOWN, &o, NULL), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(1));
- assert_se(journal_file_move_to_entry_for_data(f, d, DIRECTION_UP, &o, NULL) == 1);
- assert_se(le64toh(o->entry.seqnum) == 3);
+ ASSERT_EQ(journal_file_move_to_entry_for_data(f, d, DIRECTION_UP, &o, NULL), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(3));
- assert_se(journal_file_find_data_object(f, test2, strlen(test2), &d, NULL) == 1);
- assert_se(journal_file_move_to_entry_for_data(f, d, DIRECTION_UP, &o, NULL) == 1);
- assert_se(le64toh(o->entry.seqnum) == 2);
+ ASSERT_EQ(journal_file_find_data_object(f, test2, strlen(test2), &d, NULL), 1);
+ ASSERT_EQ(journal_file_move_to_entry_for_data(f, d, DIRECTION_UP, &o, NULL), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(2));
- assert_se(journal_file_move_to_entry_for_data(f, d, DIRECTION_DOWN, &o, NULL) == 1);
- assert_se(le64toh(o->entry.seqnum) == 2);
+ ASSERT_EQ(journal_file_move_to_entry_for_data(f, d, DIRECTION_DOWN, &o, NULL), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(2));
- assert_se(journal_file_find_data_object(f, "quux", 4, &d, NULL) == 0);
+ ASSERT_OK_ZERO(journal_file_find_data_object(f, "quux", 4, &d, NULL));
- assert_se(journal_file_move_to_entry_by_seqnum(f, 1, DIRECTION_DOWN, &o, NULL) == 1);
- assert_se(le64toh(o->entry.seqnum) == 1);
+ ASSERT_EQ(journal_file_move_to_entry_by_seqnum(f, 1, DIRECTION_DOWN, &o, NULL), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(1));
- assert_se(journal_file_move_to_entry_by_seqnum(f, 3, DIRECTION_DOWN, &o, NULL) == 1);
- assert_se(le64toh(o->entry.seqnum) == 3);
+ ASSERT_EQ(journal_file_move_to_entry_by_seqnum(f, 3, DIRECTION_DOWN, &o, NULL), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(3));
- assert_se(journal_file_move_to_entry_by_seqnum(f, 2, DIRECTION_DOWN, &o, NULL) == 1);
- assert_se(le64toh(o->entry.seqnum) == 2);
+ ASSERT_EQ(journal_file_move_to_entry_by_seqnum(f, 2, DIRECTION_DOWN, &o, NULL), 1);
+ ASSERT_EQ(le64toh(o->entry.seqnum), UINT64_C(2));
- assert_se(journal_file_move_to_entry_by_seqnum(f, 10, DIRECTION_DOWN, &o, NULL) == 0);
+ ASSERT_OK_ZERO(journal_file_move_to_entry_by_seqnum(f, 10, DIRECTION_DOWN, &o, NULL));
journal_file_rotate(&f, m, JOURNAL_SEAL|JOURNAL_COMPRESS, UINT64_MAX, NULL);
journal_file_rotate(&f, m, JOURNAL_SEAL|JOURNAL_COMPRESS, UINT64_MAX, NULL);
else {
journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);
- assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
+ ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
}
puts("------------------------------------------------------------");
}
TEST(non_empty) {
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
test_non_empty_one();
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
test_non_empty_one();
}
JournalFile *f1, *f2, *f3, *f4;
char t[] = "/var/tmp/journal-XXXXXX";
- m = mmap_cache_new();
- assert_se(m != NULL);
+ ASSERT_NOT_NULL(m = mmap_cache_new());
mkdtemp_chdir_chattr(t);
- assert_se(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, 0, 0666, UINT64_MAX, NULL, m, NULL, &f1) == 0);
- assert_se(journal_file_open(-EBADF, "test-compress.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &f2) == 0);
- assert_se(journal_file_open(-EBADF, "test-seal.journal", O_RDWR|O_CREAT, JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f3) == 0);
- assert_se(journal_file_open(-EBADF, "test-seal-compress.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f4) == 0);
+ ASSERT_OK_ZERO(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, 0, 0666, UINT64_MAX, NULL, m, NULL, &f1));
+ ASSERT_OK_ZERO(journal_file_open(-EBADF, "test-compress.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS, 0666, UINT64_MAX, NULL, m, NULL, &f2));
+ ASSERT_OK_ZERO(journal_file_open(-EBADF, "test-seal.journal", O_RDWR|O_CREAT, JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f3));
+ ASSERT_OK_ZERO(journal_file_open(-EBADF, "test-seal-compress.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, UINT64_MAX, NULL, m, NULL, &f4));
journal_file_print_header(f1);
puts("");
else {
journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);
- assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
+ ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
}
(void) journal_file_offline_close(f1);
}
TEST(empty) {
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
test_empty_one();
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
test_empty_one();
}
char t[] = "/var/tmp/journal-XXXXXX";
char data[2048] = "FIELD=";
bool is_compressed;
- int r;
- assert_se(data_size <= sizeof(data));
+ ASSERT_LE(data_size, sizeof(data));
- m = mmap_cache_new();
- assert_se(m != NULL);
+ ASSERT_NOT_NULL(m = mmap_cache_new());
mkdtemp_chdir_chattr(t);
- assert_se(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, compress_threshold, NULL, m, NULL, &f) == 0);
+ ASSERT_OK_ZERO(journal_file_open(-EBADF, "test.journal", O_RDWR|O_CREAT, JOURNAL_COMPRESS|JOURNAL_SEAL, 0666, compress_threshold, NULL, m, NULL, &f));
dual_timestamp_now(&ts);
iovec = IOVEC_MAKE(data, data_size);
- assert_se(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL) == 0);
+ ASSERT_OK_ZERO(journal_file_append_entry(f, &ts, NULL, &iovec, 1, NULL, NULL, NULL, NULL));
#if HAVE_GCRYPT
journal_file_append_tag(f);
* decompression for us. */
p = le64toh(f->header->header_size);
for (;;) {
- r = journal_file_move_to_object(f, OBJECT_UNUSED, p, &o);
- assert_se(r == 0);
+ ASSERT_OK_ZERO(journal_file_move_to_object(f, OBJECT_UNUSED, p, &o));
if (o->object.type == OBJECT_DATA)
break;
- assert_se(p < le64toh(f->header->tail_object_offset));
+ ASSERT_LT(p, le64toh(f->header->tail_object_offset));
p = p + ALIGN64(le64toh(o->object.size));
}
else {
journal_directory_vacuum(".", 3000000, 0, 0, NULL, true);
- assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
+ ASSERT_OK(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL));
}
puts("------------------------------------------------------------");
* carefully */
/* DEFAULT_MIN_COMPRESS_SIZE is 512 */
- assert_se(!check_compressed(UINT64_MAX, 255));
- assert_se(check_compressed(UINT64_MAX, 513));
+ ASSERT_FALSE(check_compressed(UINT64_MAX, 255));
+ ASSERT_TRUE(check_compressed(UINT64_MAX, 513));
/* compress everything */
- assert_se(check_compressed(0, 96));
- assert_se(check_compressed(8, 96));
+ ASSERT_TRUE(check_compressed(0, 96));
+ ASSERT_TRUE(check_compressed(8, 96));
/* Ensure we don't try to compress less than 8 bytes */
- assert_se(!check_compressed(0, 7));
+ ASSERT_FALSE(check_compressed(0, 7));
/* check boundary conditions */
- assert_se(check_compressed(256, 256));
- assert_se(!check_compressed(256, 255));
+ ASSERT_TRUE(check_compressed(256, 256));
+ ASSERT_FALSE(check_compressed(256, 255));
}
TEST(min_compress_size) {
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "0", 1));
test_min_compress_size_one();
- assert_se(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1) >= 0);
+ ASSERT_OK_ERRNO(setenv("SYSTEMD_JOURNAL_COMPACT", "1", 1));
test_min_compress_size_one();
}
#endif
int main(int argc, char *argv[]) {
MMapFileDescriptor *fx;
- int x, y, z, r;
+ int x, y, z;
char px[] = "/tmp/testmmapXXXXXXX", py[] = "/tmp/testmmapYXXXXXX", pz[] = "/tmp/testmmapZXXXXXX";
MMapCache *m;
void *p, *q;
test_setup_logging(LOG_DEBUG);
- assert_se(m = mmap_cache_new());
+ ASSERT_NOT_NULL(m = mmap_cache_new());
- x = mkostemp_safe(px);
- assert_se(x >= 0);
+ ASSERT_OK(x = mkostemp_safe(px));
(void) unlink(px);
- assert_se(mmap_cache_add_fd(m, x, PROT_READ, &fx) > 0);
+ ASSERT_OK_POSITIVE(mmap_cache_add_fd(m, x, PROT_READ, &fx));
- y = mkostemp_safe(py);
- assert_se(y >= 0);
+ ASSERT_OK(y = mkostemp_safe(py));
(void) unlink(py);
- z = mkostemp_safe(pz);
- assert_se(z >= 0);
+ ASSERT_OK(z = mkostemp_safe(pz));
(void) unlink(pz);
- r = mmap_cache_fd_get(fx, 0, false, 1, 2, NULL, &p);
- assert_se(r >= 0);
+ ASSERT_OK(mmap_cache_fd_get(fx, 0, false, 1, 2, NULL, &p));
- r = mmap_cache_fd_get(fx, 0, false, 2, 2, NULL, &q);
- assert_se(r >= 0);
+ ASSERT_OK(mmap_cache_fd_get(fx, 0, false, 2, 2, NULL, &q));
- assert_se((uint8_t*) p + 1 == (uint8_t*) q);
+ ASSERT_PTR_EQ((uint8_t*) p + 1, (uint8_t*) q);
- r = mmap_cache_fd_get(fx, 1, false, 3, 2, NULL, &q);
- assert_se(r >= 0);
+ ASSERT_OK(mmap_cache_fd_get(fx, 1, false, 3, 2, NULL, &q));
- assert_se((uint8_t*) p + 2 == (uint8_t*) q);
+ ASSERT_PTR_EQ((uint8_t*) p + 2, (uint8_t*) q);
- r = mmap_cache_fd_get(fx, 0, false, 16ULL*1024ULL*1024ULL, 2, NULL, &p);
- assert_se(r >= 0);
+ ASSERT_OK(mmap_cache_fd_get(fx, 0, false, 16ULL*1024ULL*1024ULL, 2, NULL, &p));
- r = mmap_cache_fd_get(fx, 1, false, 16ULL*1024ULL*1024ULL+1, 2, NULL, &q);
- assert_se(r >= 0);
+ ASSERT_OK(mmap_cache_fd_get(fx, 1, false, 16ULL*1024ULL*1024ULL+1, 2, NULL, &q));
- assert_se((uint8_t*) p + 1 == (uint8_t*) q);
+ ASSERT_PTR_EQ((uint8_t*) p + 1, (uint8_t*) q);
mmap_cache_fd_free(fx);
mmap_cache_unref(m);
projects / thirdparty / systemd.git / commitdiff
