#include "tests.h"
#include "version.h"
-static void test_is_wanted_print(bool header) {
+static void test_is_wanted_print_one(bool header) {
_cleanup_free_ char *cmdline = NULL;
log_info("-- %s --", __func__);
log_info(" ");
}
-static void test_is_wanted(void) {
+TEST(is_wanted_print) {
+ test_is_wanted_print_one(true);
+ test_is_wanted_print_one(false); /* run twice to test caching */
+}
+
+TEST(is_wanted) {
assert_se(setenv("SYSTEMD_PROC_CMDLINE",
"systemd.unified_cgroup_hierarchy", 1) >= 0);
- test_is_wanted_print(false);
+ test_is_wanted_print_one(false);
assert_se(setenv("SYSTEMD_PROC_CMDLINE",
"systemd.unified_cgroup_hierarchy=0", 1) >= 0);
- test_is_wanted_print(false);
+ test_is_wanted_print_one(false);
assert_se(setenv("SYSTEMD_PROC_CMDLINE",
"systemd.unified_cgroup_hierarchy=0 "
"systemd.legacy_systemd_cgroup_controller", 1) >= 0);
- test_is_wanted_print(false);
+ test_is_wanted_print_one(false);
assert_se(setenv("SYSTEMD_PROC_CMDLINE",
"systemd.unified_cgroup_hierarchy=0 "
"systemd.legacy_systemd_cgroup_controller=0", 1) >= 0);
- test_is_wanted_print(false);
+ test_is_wanted_print_one(false);
/* cgroup_no_v1=all implies unified cgroup hierarchy, unless otherwise
* explicitly specified. */
assert_se(setenv("SYSTEMD_PROC_CMDLINE",
"cgroup_no_v1=all", 1) >= 0);
- test_is_wanted_print(false);
+ test_is_wanted_print_one(false);
assert_se(setenv("SYSTEMD_PROC_CMDLINE",
"cgroup_no_v1=all "
"systemd.unified_cgroup_hierarchy=0", 1) >= 0);
- test_is_wanted_print(false);
+ test_is_wanted_print_one(false);
}
-int main(void) {
- test_setup_logging(LOG_DEBUG);
-
- if (access("/proc/cmdline", R_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
- return log_tests_skipped("can't read /proc/cmdline");
-
- test_is_wanted_print(true);
- test_is_wanted_print(false); /* run twice to test caching */
- test_is_wanted();
-
- return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+ LOG_DEBUG,
+ ({
+ if (access("/proc/cmdline", R_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
+ return log_tests_skipped("can't read /proc/cmdline");
+ }),
+ /* no outro */);
return true;
}
-static void test_chown_recursive(void) {
+TEST(chown_recursive) {
_cleanup_(rm_rf_physical_and_freep) char *t = NULL;
struct stat st;
const char *p;
assert_se(!has_xattr(p));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- if (geteuid() != 0)
- return log_tests_skipped("not running as root");
-
- test_chown_recursive();
-
- return EXIT_SUCCESS;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+ LOG_DEBUG,
+ ({
+ if (geteuid() != 0)
+ return log_tests_skipped("not running as root");
+ }),
+ /* no outro */);
#include "format-table.h"
#include "string-util.h"
#include "strv.h"
+#include "tests.h"
#include "time-util.h"
-static void test_issue_9549(void) {
+TEST(issue_9549) {
_cleanup_(table_unrefp) Table *table = NULL;
_cleanup_free_ char *formatted = NULL;
- log_info("/* %s */", __func__);
-
assert_se(table = table_new("name", "type", "ro", "usage", "created", "modified"));
assert_se(table_set_align_percent(table, TABLE_HEADER_CELL(3), 100) >= 0);
assert_se(table_add_many(table,
));
}
-static void test_multiline(void) {
+TEST(multiline) {
_cleanup_(table_unrefp) Table *table = NULL;
_cleanup_free_ char *formatted = NULL;
- log_info("/* %s */", __func__);
-
assert_se(table = table_new("foo", "bar"));
assert_se(table_set_align_percent(table, TABLE_HEADER_CELL(1), 100) >= 0);
formatted = mfree(formatted);
}
-static void test_strv(void) {
+TEST(strv) {
_cleanup_(table_unrefp) Table *table = NULL;
_cleanup_free_ char *formatted = NULL;
- log_info("/* %s */", __func__);
-
assert_se(table = table_new("foo", "bar"));
assert_se(table_set_align_percent(table, TABLE_HEADER_CELL(1), 100) >= 0);
formatted = mfree(formatted);
}
-static void test_strv_wrapped(void) {
+TEST(strv_wrapped) {
_cleanup_(table_unrefp) Table *table = NULL;
_cleanup_free_ char *formatted = NULL;
- log_info("/* %s */", __func__);
-
assert_se(table = table_new("foo", "bar"));
assert_se(table_set_align_percent(table, TABLE_HEADER_CELL(1), 100) >= 0);
formatted = mfree(formatted);
}
-static void test_json(void) {
+TEST(json) {
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
_cleanup_(table_unrefp) Table *t = NULL;
- log_info("/* %s */", __func__);
-
assert_se(t = table_new("foo bar", "quux", "piep miau"));
assert_se(table_set_json_field_name(t, 2, "zzz") >= 0);
assert_se(json_variant_equal(v, w));
}
-int main(int argc, char *argv[]) {
+TEST(table) {
_cleanup_(table_unrefp) Table *t = NULL;
_cleanup_free_ char *formatted = NULL;
- assert_se(setenv("SYSTEMD_COLORS", "0", 1) >= 0);
- assert_se(setenv("COLUMNS", "40", 1) >= 0);
-
assert_se(t = table_new("one", "two", "three"));
assert_se(table_set_align_percent(t, TABLE_HEADER_CELL(2), 100) >= 0);
" yes fäää yes fäää fäää\n"
" yes xxx yes xxx xxx\n"
"5min 5min \n"));
-
- test_issue_9549();
- test_multiline();
- test_strv();
- test_strv_wrapped();
- test_json();
-
- return 0;
}
+
+DEFINE_CUSTOM_TEST_MAIN(
+ LOG_INFO,
+ ({
+ assert_se(setenv("SYSTEMD_COLORS", "0", 1) >= 0);
+ assert_se(setenv("COLUMNS", "40", 1) >= 0);
+ }),
+ /* no outro */);
#include "time-util.h"
#include "tests.h"
-void test_hashmap_funcs(void);
-
-static void test_hashmap_replace(void) {
+TEST(hashmap_replace) {
Hashmap *m;
char *val1, *val2, *val3, *val4, *val5, *r;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
val1 = strdup("val1");
hashmap_free(m);
}
-static void test_hashmap_copy(void) {
+TEST(hashmap_copy) {
Hashmap *m, *copy;
char *val1, *val2, *val3, *val4, *r;
- log_info("/* %s */", __func__);
-
val1 = strdup("val1");
assert_se(val1);
val2 = strdup("val2");
hashmap_free(m);
}
-static void test_hashmap_get_strv(void) {
+TEST(hashmap_get_strv) {
Hashmap *m;
char **strv;
char *val1, *val2, *val3, *val4;
- log_info("/* %s */", __func__);
-
val1 = strdup("val1");
assert_se(val1);
val2 = strdup("val2");
hashmap_free(m);
}
-static void test_hashmap_move_one(void) {
+TEST(hashmap_move_one) {
Hashmap *m, *n;
char *val1, *val2, *val3, *val4, *r;
- log_info("/* %s */", __func__);
-
val1 = strdup("val1");
assert_se(val1);
val2 = strdup("val2");
hashmap_free_free(n);
}
-static void test_hashmap_move(void) {
+TEST(hashmap_move) {
Hashmap *m, *n;
char *val1, *val2, *val3, *val4, *r;
- log_info("/* %s */", __func__);
-
val1 = strdup("val1");
assert_se(val1);
val2 = strdup("val2");
hashmap_free_free(n);
}
-static void test_hashmap_update(void) {
+TEST(hashmap_update) {
Hashmap *m;
char *val1, *val2, *r;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
val1 = strdup("old_value");
assert_se(val1);
hashmap_free(m);
}
-static void test_hashmap_put(void) {
+TEST(hashmap_put) {
Hashmap *m = NULL;
int valid_hashmap_put;
void *val1 = (void*) "val 1";
void *val2 = (void*) "val 2";
_cleanup_free_ char* key1 = NULL;
- log_info("/* %s */", __func__);
-
assert_se(hashmap_ensure_allocated(&m, &string_hash_ops) == 1);
assert_se(m);
hashmap_free(m);
}
-static void test_hashmap_remove(void) {
+TEST(hashmap_remove1) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
char *r;
- log_info("/* %s */", __func__);
-
r = hashmap_remove(NULL, "key 1");
assert_se(r == NULL);
assert_se(!hashmap_get(m, "key 1"));
}
-static void test_hashmap_remove2(void) {
+TEST(hashmap_remove2) {
_cleanup_hashmap_free_free_free_ Hashmap *m = NULL;
char key1[] = "key 1";
char key2[] = "key 2";
char val2[] = "val 2";
void *r, *r2;
- log_info("/* %s */", __func__);
-
r = hashmap_remove2(NULL, "key 1", &r2);
assert_se(r == NULL);
assert_se(!hashmap_get(m, key1));
}
-static void test_hashmap_remove_value(void) {
+TEST(hashmap_remove_value) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
char *r;
char val1[] = "val 1";
char val2[] = "val 2";
- log_info("/* %s */", __func__);
-
r = hashmap_remove_value(NULL, "key 1", val1);
assert_se(r == NULL);
assert_se(!hashmap_get(m, "key 1"));
}
-static void test_hashmap_remove_and_put(void) {
+TEST(hashmap_remove_and_put) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
int valid;
char *r;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
assert_se(m);
assert_se(valid == -EEXIST);
}
-static void test_hashmap_remove_and_replace(void) {
+TEST(hashmap_remove_and_replace) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
int valid;
void *key1 = UINT_TO_PTR(1);
void *r;
int i, j;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&trivial_hash_ops);
assert_se(m);
}
}
-static void test_hashmap_ensure_allocated(void) {
+TEST(hashmap_ensure_allocated) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
int r;
- log_info("/* %s */", __func__);
-
r = hashmap_ensure_allocated(&m, &string_hash_ops);
assert_se(r == 1);
assert_se(r == 0);
}
-static void test_hashmap_foreach_key(void) {
+TEST(hashmap_foreach_key) {
Hashmap *m;
bool key_found[] = { false, false, false, false };
const char *s;
"key 3\0"
"key 4\0";
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
NULSTR_FOREACH(key, key_table)
hashmap_free(m);
}
-static void test_hashmap_foreach(void) {
+TEST(hashmap_foreach) {
Hashmap *m;
bool value_found[] = { false, false, false, false };
char *val1, *val2, *val3, *val4, *s;
unsigned count;
- log_info("/* %s */", __func__);
-
val1 = strdup("my val1");
assert_se(val1);
val2 = strdup("my val2");
hashmap_free_free(m);
}
-static void test_hashmap_merge(void) {
+TEST(hashmap_merge) {
Hashmap *m, *n;
char *val1, *val2, *val3, *val4, *r;
- log_info("/* %s */", __func__);
-
val1 = strdup("my val1");
assert_se(val1);
val2 = strdup("my val2");
hashmap_free_free(m);
}
-static void test_hashmap_contains(void) {
+TEST(hashmap_contains) {
Hashmap *m;
char *val1;
- log_info("/* %s */", __func__);
-
val1 = strdup("my val");
assert_se(val1);
hashmap_free_free(m);
}
-static void test_hashmap_isempty(void) {
+TEST(hashmap_isempty) {
Hashmap *m;
char *val1;
- log_info("/* %s */", __func__);
-
val1 = strdup("my val");
assert_se(val1);
hashmap_free_free(m);
}
-static void test_hashmap_size(void) {
+TEST(hashmap_size) {
Hashmap *m;
char *val1, *val2, *val3, *val4;
- log_info("/* %s */", __func__);
-
val1 = strdup("my val");
assert_se(val1);
val2 = strdup("my val");
hashmap_free_free(m);
}
-static void test_hashmap_get(void) {
+TEST(hashmap_get) {
Hashmap *m;
char *r;
char *val;
- log_info("/* %s */", __func__);
-
val = strdup("my val");
assert_se(val);
hashmap_free_free(m);
}
-static void test_hashmap_get2(void) {
+TEST(hashmap_get2) {
Hashmap *m;
char *r;
char *val;
char key_orig[] = "Key 1";
void *key_copy;
- log_info("/* %s */", __func__);
-
val = strdup("my val");
assert_se(val);
.compare = trivial_compare_func,
};
-static void test_hashmap_many(void) {
+TEST(hashmap_many) {
Hashmap *h;
unsigned i, j;
void *v, *k;
extern unsigned custom_counter;
extern const struct hash_ops boring_hash_ops, custom_hash_ops;
-static void test_hashmap_free(void) {
+TEST(hashmap_free) {
Hashmap *h;
bool slow = slow_tests_enabled();
usec_t ts, n;
item->seen++;
}
-static void test_hashmap_free_with_destructor(void) {
+TEST(hashmap_free_with_destructor) {
Hashmap *m;
struct Item items[4] = {};
unsigned i;
- log_info("/* %s */", __func__);
-
assert_se(m = hashmap_new(NULL));
for (i = 0; i < ELEMENTSOF(items) - 1; i++)
assert_se(hashmap_put(m, INT_TO_PTR(i), items + i) == 1);
assert_se(items[3].seen == 0);
}
-static void test_hashmap_first(void) {
+TEST(hashmap_first) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
assert_se(m);
#endif
}
-static void test_hashmap_first_key(void) {
+TEST(hashmap_first_key) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
assert_se(m);
#endif
}
-static void test_hashmap_steal_first_key(void) {
+TEST(hashmap_steal_first_key) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
assert_se(m);
assert_se(hashmap_isempty(m));
}
-static void test_hashmap_steal_first(void) {
+TEST(hashmap_steal_first) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
int seen[3] = {};
char *val;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
assert_se(m);
assert_se(hashmap_isempty(m));
}
-static void test_hashmap_clear_free_free(void) {
+TEST(hashmap_clear_free_free) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
assert_se(m);
DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(test_hash_ops_key, char, string_hash_func, string_compare_func, free);
DEFINE_PRIVATE_HASH_OPS_FULL(test_hash_ops_full, char, string_hash_func, string_compare_func, free, char, free);
-static void test_hashmap_clear_free_with_destructor(void) {
+TEST(hashmap_clear_free_with_destructor) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&test_hash_ops_key);
assert_se(m);
assert_se(hashmap_isempty(m));
}
-static void test_hashmap_reserve(void) {
+TEST(hashmap_reserve) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
- log_info("/* %s */", __func__);
-
m = hashmap_new(&string_hash_ops);
assert_se(hashmap_reserve(m, 1) == 0);
assert_se(hashmap_reserve(m, UINT_MAX - 1) == -ENOMEM);
}
-static void test_path_hashmap(void) {
+TEST(path_hashmap) {
_cleanup_hashmap_free_ Hashmap *h = NULL;
- log_info("/* %s */", __func__);
-
assert_se(h = hashmap_new(&path_hash_ops));
assert_se(hashmap_put(h, "foo", INT_TO_PTR(1)) >= 0);
assert_se(hashmap_get(h, "foo././//ba.r////.quux///.//.") == INT_TO_PTR(9));
}
-static void test_string_strv_hashmap(void) {
+TEST(string_strv_hashmap) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
char **s;
- log_info("/* %s */", __func__);
-
assert_se(string_strv_hashmap_put(&m, "foo", "bar") == 1);
assert_se(string_strv_hashmap_put(&m, "foo", "bar") == 0);
assert_se(string_strv_hashmap_put(&m, "foo", "BAR") == 1);
assert_se(strv_equal(s, STRV_MAKE("bar", "BAR")));
}
-void test_hashmap_funcs(void) {
- log_info("/************ %s ************/", __func__);
-
- test_hashmap_copy();
- test_hashmap_get_strv();
- test_hashmap_move_one();
- test_hashmap_move();
- test_hashmap_replace();
- test_hashmap_update();
- test_hashmap_put();
- test_hashmap_remove();
- test_hashmap_remove2();
- test_hashmap_remove_value();
- test_hashmap_remove_and_put();
- test_hashmap_remove_and_replace();
- test_hashmap_ensure_allocated();
- test_hashmap_foreach();
- test_hashmap_foreach_key();
- test_hashmap_contains();
- test_hashmap_merge();
- test_hashmap_isempty();
- test_hashmap_get();
- test_hashmap_get2();
- test_hashmap_size();
- test_hashmap_many();
- test_hashmap_free();
- test_hashmap_free_with_destructor();
- test_hashmap_first();
- test_hashmap_first_key();
- test_hashmap_steal_first_key();
- test_hashmap_steal_first();
- test_hashmap_clear_free_free();
- test_hashmap_clear_free_with_destructor();
- test_hashmap_reserve();
- test_path_hashmap();
- test_string_strv_hashmap();
+/* Signal to test-hashmap.c that tests from this compilation unit were run. */
+extern int n_extern_tests_run;
+TEST(ensure_extern_hashmap_tests) {
+ n_extern_tests_run++;
}
#include "hashmap.h"
#include "string-util.h"
+#include "tests.h"
#include "util.h"
unsigned custom_counter = 0;
DEFINE_HASH_OPS_FULL(boring_hash_ops, char, string_hash_func, string_compare_func, free, char, free);
DEFINE_HASH_OPS_FULL(custom_hash_ops, char, string_hash_func, string_compare_func, custom_destruct, char, custom_destruct);
-void test_hashmap_funcs(void);
-void test_ordered_hashmap_funcs(void);
-
-static void test_ordered_hashmap_next(void) {
+TEST(ordered_hashmap_next) {
_cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
int i;
- log_info("/* %s */", __func__);
-
assert_se(m = ordered_hashmap_new(NULL));
for (i = -2; i <= 2; i++)
assert_se(ordered_hashmap_put(m, INT_TO_PTR(i), INT_TO_PTR(i+10)) == 1);
assert_se(!ordered_hashmap_next(m, INT_TO_PTR(3)));
}
-static void test_uint64_compare_func(void) {
+TEST(uint64_compare_func) {
const uint64_t a = 0x100, b = 0x101;
assert_se(uint64_compare_func(&a, &a) == 0);
assert_se(uint64_compare_func(&b, &a) == 1);
}
-static void test_trivial_compare_func(void) {
+TEST(trivial_compare_func) {
assert_se(trivial_compare_func(INT_TO_PTR('a'), INT_TO_PTR('a')) == 0);
assert_se(trivial_compare_func(INT_TO_PTR('a'), INT_TO_PTR('b')) == -1);
assert_se(trivial_compare_func(INT_TO_PTR('b'), INT_TO_PTR('a')) == 1);
}
-static void test_string_compare_func(void) {
+TEST(string_compare_func) {
assert_se(string_compare_func("fred", "wilma") != 0);
assert_se(string_compare_func("fred", "fred") == 0);
}
assert_se(idx == num);
}
-static void test_iterated_cache(void) {
+TEST(iterated_cache) {
Hashmap *m;
IteratedCache *c;
- log_info("/* %s */", __func__);
-
assert_se(m = hashmap_new(NULL));
assert_se(c = hashmap_iterated_cache_new(m));
compare_cache(m, c);
assert_se(iterated_cache_free(c) == NULL);
}
-static void test_hashmap_put_strdup(void) {
+TEST(hashmap_put_strdup) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
char *s;
/* We don't have ordered_hashmap_put_strdup() yet. If it is added,
* these tests should be moved to test-hashmap-plain.c. */
- log_info("/* %s */", __func__);
-
assert_se(hashmap_put_strdup(&m, "foo", "bar") == 1);
assert_se(hashmap_put_strdup(&m, "foo", "bar") == 0);
assert_se(hashmap_put_strdup(&m, "foo", "BAR") == -EEXIST);
assert_se(streq(s, "bar"));
}
-static void test_hashmap_put_strdup_null(void) {
+TEST(hashmap_put_strdup_null) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
char *s;
- log_info("/* %s */", __func__);
-
assert_se(hashmap_put_strdup(&m, "foo", "bar") == 1);
assert_se(hashmap_put_strdup(&m, "foo", "bar") == 0);
assert_se(hashmap_put_strdup(&m, "foo", NULL) == -EEXIST);
assert_se(s == NULL);
}
-int main(int argc, const char *argv[]) {
- /* This file tests in test-hashmap-plain.c, and tests in test-hashmap-ordered.c, which is generated
- * from test-hashmap-plain.c. Hashmap tests should be added to test-hashmap-plain.c, and here only if
- * they don't apply to ordered hashmaps. */
+/* This file tests in test-hashmap-plain.c, and tests in test-hashmap-ordered.c, which is generated
+ * from test-hashmap-plain.c. Hashmap tests should be added to test-hashmap-plain.c, and here only if
+ * they don't apply to ordered hashmaps. */
- log_parse_environment();
- log_open();
+/* This variable allows us to assert that the tests from different compilation units were actually run. */
+int n_extern_tests_run = 0;
- test_hashmap_funcs();
- test_ordered_hashmap_funcs();
-
- log_info("/************ non-shared tests ************/");
-
- test_ordered_hashmap_next();
- test_uint64_compare_func();
- test_trivial_compare_func();
- test_string_compare_func();
- test_iterated_cache();
- test_hashmap_put_strdup();
- test_hashmap_put_strdup_null();
-
- return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+ LOG_INFO,
+ assert_se(n_extern_tests_run == 0),
+ assert_se(n_extern_tests_run == 2)); /* Ensure hashmap and ordered_hashmap were tested. */
#include "string-util.h"
#include "tests.h"
-static void test_basic_mask_and_enable(const char *root) {
+static char root[] = "/tmp/rootXXXXXX";
+
+TEST(basic_mask_and_enable) {
const char *p;
UnitFileState state;
UnitFileChange *changes = NULL;
size_t n_changes = 0;
- test_setup_logging(LOG_DEBUG);
-
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "a.service", NULL) == -ENOENT);
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "b.service", NULL) == -ENOENT);
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "c.service", NULL) == -ENOENT);
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "f.service", &state) >= 0 && state == UNIT_FILE_ENABLED);
}
-static void test_linked_units(const char *root) {
+TEST(linked_units) {
const char *p, *q;
UnitFileState state;
UnitFileChange *changes = NULL;
changes = NULL; n_changes = 0;
}
-static void test_default(const char *root) {
+TEST(default) {
_cleanup_free_ char *def = NULL;
UnitFileChange *changes = NULL;
size_t n_changes = 0;
assert_se(streq_ptr(def, "test-default-real.target"));
}
-static void test_add_dependency(const char *root) {
+TEST(add_dependency) {
UnitFileChange *changes = NULL;
size_t n_changes = 0;
const char *p;
changes = NULL; n_changes = 0;
}
-static void test_template_enable(const char *root) {
+TEST(template_enable) {
UnitFileChange *changes = NULL;
size_t n_changes = 0;
UnitFileState state;
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "template-symlink@quux.service", &state) >= 0 && state == UNIT_FILE_ENABLED);
}
-static void test_indirect(const char *root) {
+TEST(indirect) {
UnitFileChange *changes = NULL;
size_t n_changes = 0;
UnitFileState state;
changes = NULL; n_changes = 0;
}
-static void test_preset_and_list(const char *root) {
+TEST(preset_and_list) {
UnitFileChange *changes = NULL;
size_t n_changes = 0, i;
const char *p, *q;
assert_se(got_yes && got_no);
}
-static void test_revert(const char *root) {
+TEST(revert) {
const char *p;
UnitFileState state;
UnitFileChange *changes = NULL;
size_t n_changes = 0;
- assert_se(root);
-
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "xx.service", NULL) == -ENOENT);
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "yy.service", NULL) == -ENOENT);
changes = NULL; n_changes = 0;
}
-static void test_preset_order(const char *root) {
+TEST(preset_order) {
UnitFileChange *changes = NULL;
size_t n_changes = 0;
const char *p;
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "prefix-2.service", &state) >= 0 && state == UNIT_FILE_DISABLED);
}
-static void test_static_instance(const char *root) {
+TEST(static_instance) {
UnitFileState state;
const char *p;
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "static-instance@foo.service", &state) >= 0 && state == UNIT_FILE_STATIC);
}
-static void test_with_dropin(const char *root) {
+TEST(with_dropin) {
const char *p;
UnitFileState state;
UnitFileChange *changes = NULL;
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "with-dropin-4b.service", &state) >= 0 && state == UNIT_FILE_ENABLED);
}
-static void test_with_dropin_template(const char *root) {
+TEST(with_dropin_template) {
const char *p;
UnitFileState state;
UnitFileChange *changes = NULL;
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, "with-dropin-3@instance-2.service", &state) >= 0 && state == UNIT_FILE_ENABLED);
}
-static void test_preset_multiple_instances(const char *root) {
+TEST(preset_multiple_instances) {
UnitFileChange *changes = NULL;
size_t n_changes = 0;
const char *p;
assert_se(streq_ptr(alias2, updated_name));
}
-static void test_verify_alias(void) {
+TEST(verify_alias) {
const UnitFileInstallInfo
plain_service = { .name = (char*) "plain.service" },
bare_template = { .name = (char*) "template1@.service" },
verify_one(&di_inst_template, "goo.target.conf/plain.service", -EXDEV, NULL);
}
-int main(int argc, char *argv[]) {
- char root[] = "/tmp/rootXXXXXX";
+static void setup_root(void) {
const char *p;
assert_se(mkdtemp(root));
p = strjoina(root, "/usr/lib/systemd/system/graphical.target");
assert_se(write_string_file(p, "# pretty much empty", WRITE_STRING_FILE_CREATE) >= 0);
-
- test_basic_mask_and_enable(root);
- test_linked_units(root);
- test_default(root);
- test_add_dependency(root);
- test_template_enable(root);
- test_indirect(root);
- test_preset_and_list(root);
- test_preset_order(root);
- test_preset_multiple_instances(root);
- test_revert(root);
- test_static_instance(root);
- test_with_dropin(root);
- test_with_dropin_template(root);
-
- assert_se(rm_rf(root, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
-
- test_verify_alias();
-
- return 0;
}
+
+DEFINE_CUSTOM_TEST_MAIN(LOG_INFO, setup_root(), assert_se(rm_rf(root, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0));
#include "tests.h"
#include "tmpfile-util.h"
-static void test_mount_propagation_flags(const char *name, int ret, unsigned long expected) {
+static void test_mount_propagation_flags_one(const char *name, int ret, unsigned long expected) {
long unsigned flags;
log_info("/* %s(%s) */", __func__, name);
}
}
-static void test_mnt_id(void) {
+TEST(mount_propagation_flags) {
+ test_mount_propagation_flags_one("shared", 0, MS_SHARED);
+ test_mount_propagation_flags_one("slave", 0, MS_SLAVE);
+ test_mount_propagation_flags_one("private", 0, MS_PRIVATE);
+ test_mount_propagation_flags_one(NULL, 0, 0);
+ test_mount_propagation_flags_one("", 0, 0);
+ test_mount_propagation_flags_one("xxxx", -EINVAL, 0);
+ test_mount_propagation_flags_one(" ", -EINVAL, 0);
+}
+
+TEST(mnt_id) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_hashmap_free_free_ Hashmap *h = NULL;
char *p;
}
}
-static void test_path_is_mount_point(void) {
+TEST(path_is_mount_point) {
int fd;
char tmp_dir[] = "/tmp/test-path-is-mount-point-XXXXXX";
_cleanup_free_ char *file1 = NULL, *file2 = NULL, *link1 = NULL, *link2 = NULL;
_cleanup_free_ char *dir1 = NULL, *dir1file = NULL, *dirlink1 = NULL, *dirlink1file = NULL;
_cleanup_free_ char *dir2 = NULL, *dir2file = NULL;
- log_info("/* %s */", __func__);
-
assert_se(path_is_mount_point("/", NULL, AT_SYMLINK_FOLLOW) > 0);
assert_se(path_is_mount_point("/", NULL, 0) > 0);
assert_se(path_is_mount_point("//", NULL, AT_SYMLINK_FOLLOW) > 0);
assert_se(rm_rf(tmp_dir, REMOVE_ROOT|REMOVE_PHYSICAL) == 0);
}
-static void test_fd_is_mount_point(void) {
+TEST(fd_is_mount_point) {
_cleanup_close_ int fd = -1;
- log_info("/* %s */", __func__);
-
fd = open("/", O_RDONLY|O_CLOEXEC|O_DIRECTORY|O_NOCTTY);
assert_se(fd >= 0);
assert_se(IN_SET(fd_is_mount_point(fd, "root/", 0), -ENOENT, 0));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- /* let's move into our own mount namespace with all propagation from the host turned off, so that
- * /proc/self/mountinfo is static and constant for the whole time our test runs. */
- if (unshare(CLONE_NEWNS) < 0) {
- if (!ERRNO_IS_PRIVILEGE(errno))
- return log_error_errno(errno, "Failed to detach mount namespace: %m");
+DEFINE_CUSTOM_TEST_MAIN(
+ LOG_DEBUG,
+ ({
+ /* let's move into our own mount namespace with all propagation from the host turned off, so
+ * that /proc/self/mountinfo is static and constant for the whole time our test runs. */
+ if (unshare(CLONE_NEWNS) < 0) {
+ if (!ERRNO_IS_PRIVILEGE(errno))
+ return log_error_errno(errno, "Failed to detach mount namespace: %m");
- log_notice("Lacking privilege to create separate mount namespace, proceeding in originating mount namespace.");
- } else
- assert_se(mount(NULL, "/", NULL, MS_PRIVATE | MS_REC, NULL) >= 0);
-
- test_mount_propagation_flags("shared", 0, MS_SHARED);
- test_mount_propagation_flags("slave", 0, MS_SLAVE);
- test_mount_propagation_flags("private", 0, MS_PRIVATE);
- test_mount_propagation_flags(NULL, 0, 0);
- test_mount_propagation_flags("", 0, 0);
- test_mount_propagation_flags("xxxx", -EINVAL, 0);
- test_mount_propagation_flags(" ", -EINVAL, 0);
-
- test_mnt_id();
- test_path_is_mount_point();
- test_fd_is_mount_point();
-
- return 0;
-}
+ log_notice("Lacking privilege to create separate mount namespace, proceeding in originating mount namespace.");
+ } else
+ assert_se(mount(NULL, "/", NULL, MS_PRIVATE | MS_REC, NULL) >= 0);
+ }),
+ /* no outro */);
return 0;
}
-static void test_proc_cmdline_parse(void) {
- log_info("/* %s */", __func__);
-
+TEST(proc_cmdline_parse) {
assert_se(proc_cmdline_parse(parse_item, &obj, PROC_CMDLINE_STRIP_RD_PREFIX) >= 0);
}
-static void test_proc_cmdline_override(void) {
- log_info("/* %s */", __func__);
-
+TEST(proc_cmdline_override) {
assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\"") == 0);
assert_se(putenv((char*) "SYSTEMD_EFI_OPTIONS=different") == 0);
return 0;
}
-static void test_proc_cmdline_given(bool flip_initrd) {
+static void test_proc_cmdline_given_one(bool flip_initrd) {
log_info("/* %s (flip: %s) */", __func__, yes_no(flip_initrd));
if (flip_initrd)
in_initrd_force(!in_initrd());
}
-static void test_proc_cmdline_get_key(void) {
+TEST(test_proc_cmdline_given) {
+ test_proc_cmdline_given_one(false);
+ /* Repeat the same thing, but now flip our ininitrdness */
+ test_proc_cmdline_given_one(true);
+}
+
+TEST(proc_cmdline_get_key) {
_cleanup_free_ char *value = NULL;
- log_info("/* %s */", __func__);
assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm spaaace='ö ü ß' ticks=\"''\"\n\nkkk=uuu\n\n\n") == 0);
assert_se(proc_cmdline_get_key("", 0, &value) == -EINVAL);
assert_se(proc_cmdline_get_key("kkk", 0, &value) > 0 && streq_ptr(value, "uuu"));
}
-static void test_proc_cmdline_get_bool(void) {
+TEST(proc_cmdline_get_bool) {
bool value = false;
- log_info("/* %s */", __func__);
assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar bar-waldo=1 x_y-z=0 quux=miep\nda=yes\nthe=1") == 0);
assert_se(putenv((char*) "SYSTEMD_EFI_OPTIONS=") == 0);
assert_se(proc_cmdline_get_bool("quux", &value) == -EINVAL && value == false);
assert_se(proc_cmdline_get_bool("da", &value) > 0 && value == true);
assert_se(proc_cmdline_get_bool("the", &value) > 0 && value == true);
+}
+
+#if ENABLE_EFI
+TEST(proc_cmdline_get_bool_efi) {
+ bool value = false;
assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=") == 0);
assert_se(putenv((char*) "SYSTEMD_EFI_OPTIONS=foo_bar bar-waldo=1 x_y-z=0 quux=miep\nda=yes\nthe=1") == 0);
-#if ENABLE_EFI
assert_se(proc_cmdline_get_bool("", &value) == -EINVAL);
assert_se(proc_cmdline_get_bool("abc", &value) == 0 && value == false);
assert_se(proc_cmdline_get_bool("foo_bar", &value) > 0 && value == true);
assert_se(proc_cmdline_get_bool("quux", &value) == -EINVAL && value == false);
assert_se(proc_cmdline_get_bool("da", &value) > 0 && value == true);
assert_se(proc_cmdline_get_bool("the", &value) > 0 && value == true);
-#endif
}
+#endif
-static void test_proc_cmdline_get_key_many(void) {
+TEST(proc_cmdline_get_key_many) {
_cleanup_free_ char *value1 = NULL, *value2 = NULL, *value3 = NULL, *value4 = NULL, *value5 = NULL, *value6 = NULL, *value7 = NULL;
- log_info("/* %s */", __func__);
assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm SPACE='one two' doubleticks=\" aaa aaa \"\n\nzummm='\n'\n") == 0);
assert_se(proc_cmdline_get_key_many(0,
assert_se(streq_ptr(value7, "\n"));
}
-static void test_proc_cmdline_key_streq(void) {
- log_info("/* %s */", __func__);
-
+TEST(proc_cmdline_key_streq) {
assert_se(proc_cmdline_key_streq("", ""));
assert_se(proc_cmdline_key_streq("a", "a"));
assert_se(!proc_cmdline_key_streq("", "a"));
assert_se(!proc_cmdline_key_streq("x_y-z", "x-z_z"));
}
-static void test_proc_cmdline_key_startswith(void) {
- log_info("/* %s */", __func__);
-
+TEST(proc_cmdline_key_startswith) {
assert_se(proc_cmdline_key_startswith("", ""));
assert_se(proc_cmdline_key_startswith("x", ""));
assert_se(!proc_cmdline_key_startswith("", "x"));
assert_se(!proc_cmdline_key_startswith("foo-bar", "foo_xx"));
}
-int main(void) {
- test_setup_logging(LOG_INFO);
-
- if (access("/proc/cmdline", R_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
- return log_tests_skipped("can't read /proc/cmdline");
-
- test_proc_cmdline_parse();
- test_proc_cmdline_override();
- test_proc_cmdline_given(false);
- /* Repeat the same thing, but now flip our ininitrdness */
- test_proc_cmdline_given(true);
- test_proc_cmdline_key_streq();
- test_proc_cmdline_key_startswith();
- test_proc_cmdline_get_key();
- test_proc_cmdline_get_bool();
- test_proc_cmdline_get_key_many();
-
- return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+ LOG_INFO,
+ ({
+ if (access("/proc/cmdline", R_OK) < 0 && ERRNO_IS_PRIVILEGE(errno))
+ return log_tests_skipped("can't read /proc/cmdline");
+ }),
+ /* no outro */);
#include "util.h"
#include "virt.h"
-static void test_get_process_comm(pid_t pid) {
+static void test_get_process_comm_one(pid_t pid) {
struct stat st;
_cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;
_cleanup_free_ char *env = NULL;
log_info("PID"PID_FMT" $PATH: '%s'", pid, strna(i));
}
+TEST(get_process_comm) {
+ if (saved_argc > 1) {
+ pid_t pid = 0;
+
+ (void) parse_pid(saved_argv[1], &pid);
+ test_get_process_comm_one(pid);
+ } else {
+ TEST_REQ_RUNNING_SYSTEMD(test_get_process_comm_one(1));
+ test_get_process_comm_one(getpid());
+ }
+}
+
static void test_get_process_cmdline_one(pid_t pid) {
_cleanup_free_ char *c = NULL, *d = NULL, *e = NULL, *f = NULL, *g = NULL, *h = NULL;
int r;
log_info(" %s", r >= 0 ? h : errno_to_name(r));
}
-static void test_get_process_cmdline(void) {
+TEST(get_process_cmdline) {
_cleanup_closedir_ DIR *d = NULL;
struct dirent *de;
- log_info("/* %s */", __func__);
-
assert_se(d = opendir("/proc"));
FOREACH_DIRENT(de, d, return) {
assert_se(streq_ptr(n, output));
}
-static void test_get_process_comm_escape(void) {
+TEST(get_process_comm_escape) {
_cleanup_free_ char *saved = NULL;
- log_info("/* %s */", __func__);
-
assert_se(get_process_comm(0, &saved) >= 0);
test_get_process_comm_escape_one("", "");
assert_se(prctl(PR_SET_NAME, saved) >= 0);
}
-static void test_pid_is_unwaited(void) {
+TEST(pid_is_unwaited) {
pid_t pid;
pid = fork();
assert_se(!pid_is_unwaited(-1));
}
-static void test_pid_is_alive(void) {
+TEST(pid_is_alive) {
pid_t pid;
- log_info("/* %s */", __func__);
-
pid = fork();
assert_se(pid >= 0);
if (pid == 0) {
assert_se(!pid_is_alive(-1));
}
-static void test_personality(void) {
- log_info("/* %s */", __func__);
-
+TEST(personality) {
assert_se(personality_to_string(PER_LINUX));
assert_se(!personality_to_string(PERSONALITY_INVALID));
#endif
}
-static void test_get_process_cmdline_harder(void) {
+TEST(get_process_cmdline_harder) {
char path[] = "/tmp/test-cmdlineXXXXXX";
_cleanup_close_ int fd = -1;
_cleanup_free_ char *line = NULL;
pid_t pid;
- log_info("/* %s */", __func__);
-
if (geteuid() != 0) {
log_info("Skipping %s: not root", __func__);
return;
assert_se(si.si_status == EXIT_SUCCESS);
}
-static void test_rename_process_multi(void) {
+TEST(rename_process_multi) {
pid_t pid;
pid = fork();
_exit(EXIT_SUCCESS);
}
-static void test_rename_process(void) {
+TEST(rename_process) {
test_rename_process_one(NULL, -EINVAL);
test_rename_process_one("", -EINVAL);
test_rename_process_one("foo", 1); /* should always fit */
test_rename_process_one("this is a really really long process name, followed by some more words", 0); /* unlikely to fit */
test_rename_process_one("1234567", 1); /* should always fit */
- test_rename_process_multi(); /* multiple invocations and dropped privileges */
}
-static void test_getpid_cached(void) {
+TEST(getpid_cached) {
siginfo_t si;
pid_t a, b, c, d, e, f, child;
- log_info("/* %s */", __func__);
-
a = raw_getpid();
b = getpid_cached();
c = getpid();
assert_se(si.si_code == CLD_EXITED);
}
-static void test_getpid_measure(void) {
+TEST(getpid_measure) {
usec_t t, q;
unsigned long long iterations = slow_tests_enabled() ? 1000000 : 1000;
log_info("getpid_cached(): %lf µs each\n", (double) q / iterations);
}
-static void test_safe_fork(void) {
+TEST(safe_fork) {
siginfo_t status;
pid_t pid;
int r;
- log_info("/* %s */", __func__);
-
BLOCK_SIGNALS(SIGCHLD);
r = safe_fork("(test-child)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG|FORK_NULL_STDIO|FORK_REOPEN_LOG, &pid);
assert_se(status.si_status == 88);
}
-static void test_pid_to_ptr(void) {
-
+TEST(pid_to_ptr) {
assert_se(PTR_TO_PID(NULL) == 0);
assert_se(PID_TO_PTR(0) == NULL);
}
}
-static void test_ioprio_class_from_to_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(ioprio_class_from_to_string) {
test_ioprio_class_from_to_string_one("none", IOPRIO_CLASS_NONE, IOPRIO_CLASS_BE);
test_ioprio_class_from_to_string_one("realtime", IOPRIO_CLASS_RT, IOPRIO_CLASS_RT);
test_ioprio_class_from_to_string_one("best-effort", IOPRIO_CLASS_BE, IOPRIO_CLASS_BE);
test_ioprio_class_from_to_string_one("-1", -EINVAL, -EINVAL);
}
-static void test_setpriority_closest(void) {
+TEST(setpriority_closest) {
int r;
- log_info("/* %s */", __func__);
-
r = safe_fork("(test-setprio)",
FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG|FORK_WAIT|FORK_LOG, NULL);
assert_se(r >= 0);
}
}
-static void test_get_process_ppid(void) {
+TEST(get_process_ppid) {
uint64_t limit;
int r;
- log_info("/* %s */", __func__);
-
assert_se(get_process_ppid(1, NULL) == -EADDRNOTAVAIL);
/* the process with the PID above the global limit definitely doesn't exist. Verify that */
}
}
-static void test_set_oom_score_adjust(void) {
+TEST(set_oom_score_adjust) {
int a, b, r;
assert_se(get_oom_score_adjust(&a) >= 0);
assert_se(b == a);
}
-int main(int argc, char *argv[]) {
- log_show_color(true);
- test_setup_logging(LOG_INFO);
-
- save_argc_argv(argc, argv);
-
- if (argc > 1) {
- pid_t pid = 0;
-
- (void) parse_pid(argv[1], &pid);
- test_get_process_comm(pid);
- } else {
- TEST_REQ_RUNNING_SYSTEMD(test_get_process_comm(1));
- test_get_process_comm(getpid());
- }
-
- test_get_process_comm_escape();
- test_get_process_cmdline();
- test_pid_is_unwaited();
- test_pid_is_alive();
- test_personality();
- test_get_process_cmdline_harder();
- test_rename_process();
- test_getpid_cached();
- test_getpid_measure();
- test_safe_fork();
- test_pid_to_ptr();
- test_ioprio_class_from_to_string();
- test_setpriority_closest();
- test_get_process_ppid();
- test_set_oom_score_adjust();
-
- return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(LOG_INFO, log_show_color(true), /* no outro */);
#include "missing_resource.h"
#include "rlimit-util.h"
#include "string-util.h"
+#include "tests.h"
#include "time-util.h"
-static void test_rlimit_parse_format(int resource, const char *string, rlim_t soft, rlim_t hard, int ret, const char *formatted) {
+static void test_rlimit_parse_format_one(int resource, const char *string, rlim_t soft, rlim_t hard, int ret, const char *formatted) {
_cleanup_free_ char *f = NULL;
struct rlimit rl = {
.rlim_cur = 4711,
assert_se(memcmp(&rl, &rl2, sizeof(struct rlimit)) == 0);
}
-int main(int argc, char *argv[]) {
- struct rlimit old, new, high;
- struct rlimit err = {
- .rlim_cur = 10,
- .rlim_max = 5,
- };
- int i;
-
- log_parse_environment();
- log_open();
-
- assert_se(drop_capability(CAP_SYS_RESOURCE) == 0);
-
- assert_se(getrlimit(RLIMIT_NOFILE, &old) == 0);
- new.rlim_cur = MIN(5U, old.rlim_max);
- new.rlim_max = old.rlim_max;
- assert_se(setrlimit(RLIMIT_NOFILE, &new) >= 0);
+TEST(rlimit_parse_format) {
+ test_rlimit_parse_format_one(RLIMIT_NOFILE, "4:5", 4, 5, 0, "4:5");
+ test_rlimit_parse_format_one(RLIMIT_NOFILE, "6", 6, 6, 0, "6");
+ test_rlimit_parse_format_one(RLIMIT_NOFILE, "infinity", RLIM_INFINITY, RLIM_INFINITY, 0, "infinity");
+ test_rlimit_parse_format_one(RLIMIT_NOFILE, "infinity:infinity", RLIM_INFINITY, RLIM_INFINITY, 0, "infinity");
+ test_rlimit_parse_format_one(RLIMIT_NOFILE, "8:infinity", 8, RLIM_INFINITY, 0, "8:infinity");
+ test_rlimit_parse_format_one(RLIMIT_CPU, "25min:13h", (25*USEC_PER_MINUTE) / USEC_PER_SEC, (13*USEC_PER_HOUR) / USEC_PER_SEC, 0, "1500:46800");
+ test_rlimit_parse_format_one(RLIMIT_NOFILE, "", 0, 0, -EINVAL, NULL);
+ test_rlimit_parse_format_one(RLIMIT_NOFILE, "5:4", 0, 0, -EILSEQ, NULL);
+ test_rlimit_parse_format_one(RLIMIT_NOFILE, "5:4:3", 0, 0, -EINVAL, NULL);
+ test_rlimit_parse_format_one(RLIMIT_NICE, "20", 20, 20, 0, "20");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "40", 40, 40, 0, "40");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "41", 41, 41, -ERANGE, "41");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "0", 0, 0, 0, "0");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "-7", 27, 27, 0, "27");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "-20", 40, 40, 0, "40");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "-21", 41, 41, -ERANGE, "41");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "-0", 20, 20, 0, "20");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "+7", 13, 13, 0, "13");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "+19", 1, 1, 0, "1");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "+20", 0, 0, -ERANGE, "0");
+ test_rlimit_parse_format_one(RLIMIT_NICE, "+0", 20, 20, 0, "20");
+}
+TEST(rlimit_from_string) {
assert_se(rlimit_from_string("NOFILE") == RLIMIT_NOFILE);
assert_se(rlimit_from_string("LimitNOFILE") == -EINVAL);
assert_se(rlimit_from_string("RLIMIT_NOFILE") == -EINVAL);
assert_se(rlimit_from_string("xxxNOFILE") == -EINVAL);
assert_se(rlimit_from_string("DefaultLimitNOFILE") == -EINVAL);
+}
+TEST(rlimit_from_string_harder) {
assert_se(rlimit_from_string_harder("NOFILE") == RLIMIT_NOFILE);
assert_se(rlimit_from_string_harder("LimitNOFILE") == RLIMIT_NOFILE);
assert_se(rlimit_from_string_harder("RLIMIT_NOFILE") == RLIMIT_NOFILE);
assert_se(rlimit_from_string_harder("xxxNOFILE") == -EINVAL);
assert_se(rlimit_from_string_harder("DefaultLimitNOFILE") == -EINVAL);
+}
- for (i = 0; i < _RLIMIT_MAX; i++) {
+TEST(rlimit_to_string_all) {
+ for (int i = 0; i < _RLIMIT_MAX; i++) {
_cleanup_free_ char *prefixed = NULL;
const char *p;
assert_se(rlimit_from_string(prefixed) < 0);
assert_se(rlimit_from_string_harder(prefixed) == i);
}
+}
+
+TEST(setrlimit) {
+ struct rlimit old, new, high;
+ struct rlimit err = {
+ .rlim_cur = 10,
+ .rlim_max = 5,
+ };
+
+ assert_se(drop_capability(CAP_SYS_RESOURCE) == 0);
+
+ assert_se(getrlimit(RLIMIT_NOFILE, &old) == 0);
+ new.rlim_cur = MIN(5U, old.rlim_max);
+ new.rlim_max = old.rlim_max;
+ assert_se(setrlimit(RLIMIT_NOFILE, &new) >= 0);
assert_se(streq_ptr(rlimit_to_string(RLIMIT_NOFILE), "NOFILE"));
assert_se(rlimit_to_string(-1) == NULL);
assert_se(getrlimit(RLIMIT_NOFILE, &new) == 0);
assert_se(old.rlim_cur == new.rlim_cur);
assert_se(old.rlim_max == new.rlim_max);
-
- test_rlimit_parse_format(RLIMIT_NOFILE, "4:5", 4, 5, 0, "4:5");
- test_rlimit_parse_format(RLIMIT_NOFILE, "6", 6, 6, 0, "6");
- test_rlimit_parse_format(RLIMIT_NOFILE, "infinity", RLIM_INFINITY, RLIM_INFINITY, 0, "infinity");
- test_rlimit_parse_format(RLIMIT_NOFILE, "infinity:infinity", RLIM_INFINITY, RLIM_INFINITY, 0, "infinity");
- test_rlimit_parse_format(RLIMIT_NOFILE, "8:infinity", 8, RLIM_INFINITY, 0, "8:infinity");
- test_rlimit_parse_format(RLIMIT_CPU, "25min:13h", (25*USEC_PER_MINUTE) / USEC_PER_SEC, (13*USEC_PER_HOUR) / USEC_PER_SEC, 0, "1500:46800");
- test_rlimit_parse_format(RLIMIT_NOFILE, "", 0, 0, -EINVAL, NULL);
- test_rlimit_parse_format(RLIMIT_NOFILE, "5:4", 0, 0, -EILSEQ, NULL);
- test_rlimit_parse_format(RLIMIT_NOFILE, "5:4:3", 0, 0, -EINVAL, NULL);
- test_rlimit_parse_format(RLIMIT_NICE, "20", 20, 20, 0, "20");
- test_rlimit_parse_format(RLIMIT_NICE, "40", 40, 40, 0, "40");
- test_rlimit_parse_format(RLIMIT_NICE, "41", 41, 41, -ERANGE, "41");
- test_rlimit_parse_format(RLIMIT_NICE, "0", 0, 0, 0, "0");
- test_rlimit_parse_format(RLIMIT_NICE, "-7", 27, 27, 0, "27");
- test_rlimit_parse_format(RLIMIT_NICE, "-20", 40, 40, 0, "40");
- test_rlimit_parse_format(RLIMIT_NICE, "-21", 41, 41, -ERANGE, "41");
- test_rlimit_parse_format(RLIMIT_NICE, "-0", 20, 20, 0, "20");
- test_rlimit_parse_format(RLIMIT_NICE, "+7", 13, 13, 0, "13");
- test_rlimit_parse_format(RLIMIT_NICE, "+19", 1, 1, 0, "1");
- test_rlimit_parse_format(RLIMIT_NICE, "+20", 0, 0, -ERANGE, "0");
- test_rlimit_parse_format(RLIMIT_NICE, "+0", 20, 20, 0, "20");
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "errno.h"
#include "tests.h"
-static int test_failed_enumerate(void) {
+TEST(failed_enumerate) {
_cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
const char *key, *value;
- int r;
-
- log_info("/* %s */", __func__);
- r = sd_hwdb_new(&hwdb);
- if (r == -ENOENT || ERRNO_IS_PRIVILEGE(r))
- return r;
- assert_se(r == 0);
+ assert_se(sd_hwdb_new(&hwdb) == 0);
assert_se(sd_hwdb_seek(hwdb, "no-such-modalias-should-exist") == 0);
assert_se(sd_hwdb_enumerate(hwdb, &key, &value) == 0);
assert_se(sd_hwdb_enumerate(hwdb, &key, NULL) == -EINVAL);
assert_se(sd_hwdb_enumerate(hwdb, NULL, &value) == -EINVAL);
-
- return 0;
}
#define DELL_MODALIAS \
"evdev:atkbd:dmi:bvnXXX:bvrYYY:bdZZZ:svnDellXXX:pnYYY"
-static void test_basic_enumerate(void) {
+TEST(basic_enumerate) {
_cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
const char *key, *value;
size_t len1 = 0, len2 = 0;
int r;
- log_info("/* %s */", __func__);
-
assert_se(sd_hwdb_new(&hwdb) == 0);
assert_se(sd_hwdb_seek(hwdb, DELL_MODALIAS) == 0);
assert_se(len1 == len2);
}
-int main(int argc, char *argv[]) {
- int r;
-
- test_setup_logging(LOG_DEBUG);
-
- r = test_failed_enumerate();
- if (r < 0)
- return log_tests_skipped_errno(r, "cannot open hwdb");
-
- test_basic_enumerate();
-
- return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+ LOG_DEBUG,
+ ({
+ _cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
+ int r = sd_hwdb_new(&hwdb);
+ if (r == -ENOENT || ERRNO_IS_PRIVILEGE(r))
+ return log_tests_skipped_errno(r, "cannot open hwdb");
+ }),
+ /* no outro */);
char long_string[LONG_LINE_MAX+1];
-static void test_serialize_item(void) {
+TEST(serialize_item) {
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
assert_se(streq(line3, ""));
}
-static void test_serialize_item_escaped(void) {
+TEST(serialize_item_escaped) {
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
assert_se(streq(line3, ""));
}
-static void test_serialize_usec(void) {
+TEST(serialize_usec) {
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
assert_se(x == USEC_INFINITY-1);
}
-static void test_serialize_strv(void) {
+TEST(serialize_strv) {
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
assert_se(strv_equal(strv, strv2));
}
-static void test_deserialize_environment(void) {
+TEST(deserialize_environment) {
_cleanup_strv_free_ char **env;
- log_info("/* %s */", __func__);
-
assert_se(env = strv_new("A=1"));
assert_se(deserialize_environment("B=2", &env) >= 0);
assert_se(deserialize_environment("bar\\_baz", &env) < 0);
}
-static void test_serialize_environment(void) {
+TEST(serialize_environment) {
_cleanup_strv_free_ char **env = NULL, **env2 = NULL;
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-env-util.XXXXXXX";
_cleanup_fclose_ FILE *f = NULL;
assert_se(strv_equal(env, env2));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- memset(long_string, 'x', sizeof(long_string)-1);
- char_array_0(long_string);
-
- test_serialize_item();
- test_serialize_item_escaped();
- test_serialize_usec();
- test_serialize_strv();
- test_deserialize_environment();
- test_serialize_environment();
-
- return EXIT_SUCCESS;
-}
+DEFINE_CUSTOM_TEST_MAIN(
+ LOG_INFO,
+ ({
+ memset(long_string, 'x', sizeof(long_string)-1);
+ char_array_0(long_string);
+ }),
+ /* no outro */);
#include "macro.h"
#include "string-util.h"
+#include "tests.h"
#include "udev-util.h"
static void test_udev_rule_parse_value_one(const char *in, const char *expected_value, int expected_retval) {
char *value = UINT_TO_PTR(0x12345678U);
char *endpos = UINT_TO_PTR(0x87654321U);
+ log_info("/* %s (%s, %s, %d) */", __func__, in, expected_value, expected_retval);
+
assert_se(str = strdup(in));
assert_se(udev_rule_parse_value(str, &value, &endpos) == expected_retval);
if (expected_retval < 0) {
}
}
-static void test_parse_value(void) {
+TEST(udev_rule_parse_value) {
/* input: "valid operand"
* parsed: valid operand
* use the following command to help generate textual C strings:
* python3 -c 'import json; print(json.dumps(input()))' */
- test_udev_rule_parse_value_one(
- "\"valid operand\"",
- "valid operand",
- 0
- );
-}
-
-static void test_parse_value_with_backslashes(void) {
+ test_udev_rule_parse_value_one("\"valid operand\"", "valid operand", 0);
/* input: "va'l\'id\"op\"erand"
* parsed: va'l\'id"op"erand */
- test_udev_rule_parse_value_one(
- "\"va'l\\'id\\\"op\\\"erand\"",
- "va'l\\'id\"op\"erand",
- 0
- );
-}
-
-static void test_parse_value_no_quotes(void) {
- test_udev_rule_parse_value_one(
- "no quotes",
- 0,
- -EINVAL
- );
-}
-
-static void test_parse_value_noescape(void) {
- test_udev_rule_parse_value_one(
- "\"\\\\a\\b\\x\\y\"",
- "\\\\a\\b\\x\\y",
- 0
- );
-}
-
-static void test_parse_value_nul(void) {
- test_udev_rule_parse_value_one(
- "\"reject\0nul\"",
- 0,
- -EINVAL
- );
-}
-
-static void test_parse_value_escape_nothing(void) {
+ test_udev_rule_parse_value_one("\"va'l\\'id\\\"op\\\"erand\"", "va'l\\'id\"op\"erand", 0);
+ test_udev_rule_parse_value_one("no quotes", 0, -EINVAL);
+ test_udev_rule_parse_value_one("\"\\\\a\\b\\x\\y\"", "\\\\a\\b\\x\\y", 0);
+ test_udev_rule_parse_value_one("\"reject\0nul\"", 0, -EINVAL);
/* input: e"" */
- test_udev_rule_parse_value_one(
- "e\"\"",
- "",
- 0
- );
-}
-
-static void test_parse_value_escape_nothing2(void) {
+ test_udev_rule_parse_value_one("e\"\"", "", 0);
/* input: e"1234" */
- test_udev_rule_parse_value_one(
- "e\"1234\"",
- "1234",
- 0
- );
-}
-
-static void test_parse_value_escape_double_quote(void) {
+ test_udev_rule_parse_value_one("e\"1234\"", "1234", 0);
/* input: e"\"" */
- test_udev_rule_parse_value_one(
- "e\"\\\"\"",
- "\"",
- 0
- );
-}
-
-static void test_parse_value_escape_backslash(void) {
+ test_udev_rule_parse_value_one("e\"\\\"\"", "\"", 0);
/* input: e"\ */
- test_udev_rule_parse_value_one(
- "e\"\\",
- 0,
- -EINVAL
- );
+ test_udev_rule_parse_value_one("e\"\\", 0, -EINVAL);
/* input: e"\" */
- test_udev_rule_parse_value_one(
- "e\"\\\"",
- 0,
- -EINVAL
- );
+ test_udev_rule_parse_value_one("e\"\\\"", 0, -EINVAL);
/* input: e"\\" */
- test_udev_rule_parse_value_one(
- "e\"\\\\\"",
- "\\",
- 0
- );
+ test_udev_rule_parse_value_one("e\"\\\\\"", "\\", 0);
/* input: e"\\\" */
- test_udev_rule_parse_value_one(
- "e\"\\\\\\\"",
- 0,
- -EINVAL
- );
+ test_udev_rule_parse_value_one("e\"\\\\\\\"", 0, -EINVAL);
/* input: e"\\\"" */
- test_udev_rule_parse_value_one(
- "e\"\\\\\\\"\"",
- "\\\"",
- 0
- );
+ test_udev_rule_parse_value_one("e\"\\\\\\\"\"", "\\\"", 0);
/* input: e"\\\\" */
- test_udev_rule_parse_value_one(
- "e\"\\\\\\\\\"",
- "\\\\",
- 0
- );
-}
-
-static void test_parse_value_newline(void) {
+ test_udev_rule_parse_value_one("e\"\\\\\\\\\"", "\\\\", 0);
/* input: e"operand with newline\n" */
- test_udev_rule_parse_value_one(
- "e\"operand with newline\\n\"",
- "operand with newline\n",
- 0
- );
-}
-
-static void test_parse_value_escaped(void) {
+ test_udev_rule_parse_value_one("e\"operand with newline\\n\"", "operand with newline\n", 0);
/* input: e"single\rcharacter\t\aescape\bsequence" */
test_udev_rule_parse_value_one(
- "e\"single\\rcharacter\\t\\aescape\\bsequence\"",
- "single\rcharacter\t\aescape\bsequence",
- 0
- );
-}
-
-static void test_parse_value_invalid_escape(void) {
+ "e\"single\\rcharacter\\t\\aescape\\bsequence\"", "single\rcharacter\t\aescape\bsequence", 0);
/* input: e"reject\invalid escape sequence" */
- test_udev_rule_parse_value_one(
- "e\"reject\\invalid escape sequence",
- 0,
- -EINVAL
- );
-}
-
-static void test_parse_value_invalid_termination(void) {
+ test_udev_rule_parse_value_one("e\"reject\\invalid escape sequence", 0, -EINVAL);
/* input: e"\ */
- test_udev_rule_parse_value_one(
- "e\"\\",
- 0,
- -EINVAL
- );
-}
-
-static void test_parse_value_unicode(void) {
+ test_udev_rule_parse_value_one("e\"\\", 0, -EINVAL);
/* input: "s\u1d1c\u1d04\u029c \u1d1c\u0274\u026a\u1d04\u1d0f\u1d05\u1d07 \U0001d568\U0001d560\U0001d568" */
test_udev_rule_parse_value_one(
"e\"s\\u1d1c\\u1d04\\u029c \\u1d1c\\u0274\\u026a\\u1d04\\u1d0f\\u1d05\\u1d07 \\U0001d568\\U0001d560\\U0001d568\"",
"s\xe1\xb4\x9c\xe1\xb4\x84\xca\x9c \xe1\xb4\x9c\xc9\xb4\xc9\xaa\xe1\xb4\x84\xe1\xb4\x8f\xe1\xb4\x85\xe1\xb4\x87 \xf0\x9d\x95\xa8\xf0\x9d\x95\xa0\xf0\x9d\x95\xa8",
- 0
- );
+ 0);
}
static void test_udev_replace_whitespace_one_len(const char *str, size_t len, const char *expected) {
test_udev_replace_whitespace_one_len(str, strlen(str), expected);
}
-static void test_udev_replace_whitespace(void) {
- log_info("/* %s */", __func__);
-
+TEST(udev_replace_whitespace) {
test_udev_replace_whitespace_one("hogehoge", "hogehoge");
test_udev_replace_whitespace_one("hoge hoge", "hoge_hoge");
test_udev_replace_whitespace_one(" hoge hoge ", "hoge_hoge");
assert_se(streq(result, expected));
}
-static void test_udev_resolve_subsys_kernel(void) {
- log_info("/* %s */", __func__);
-
+TEST(udev_resolve_subsys_kernel) {
test_udev_resolve_subsys_kernel_one("hoge", false, -EINVAL, NULL);
test_udev_resolve_subsys_kernel_one("[hoge", false, -EINVAL, NULL);
test_udev_resolve_subsys_kernel_one("[hoge/foo", false, -EINVAL, NULL);
test_udev_resolve_subsys_kernel_one("[net/lo]/address", true, 0, "00:00:00:00:00:00");
}
-int main(int argc, char **argv) {
- test_parse_value();
- test_parse_value_with_backslashes();
- test_parse_value_no_quotes();
- test_parse_value_nul();
- test_parse_value_noescape();
-
- test_parse_value_escape_nothing();
- test_parse_value_escape_nothing2();
- test_parse_value_escape_double_quote();
- test_parse_value_escape_backslash();
- test_parse_value_newline();
- test_parse_value_escaped();
- test_parse_value_invalid_escape();
- test_parse_value_invalid_termination();
- test_parse_value_unicode();
-
- test_udev_replace_whitespace();
- test_udev_resolve_subsys_kernel();
-
- return EXIT_SUCCESS;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
projects / thirdparty / systemd.git / commitdiff
