This converts to TEST macro where it is trivial.
Some additional notable changes:
- simplify HAVE_LIBIDN #ifdef in test-dns-domain.c
- use saved_argc/saved_argv in test-copy.c, test-path-util.c,
test-tmpfiles.c and test-unit-file.c
test_hashmap_ordered_c],
[], [], [], '', 'timeout=180'],
- [['src/test/test-set.c'],
- [libbasic]],
+ [['src/test/test-set.c']],
[['src/test/test-ordered-set.c']],
#include "macro.h"
#include "string-util.h"
+#include "tests.h"
#include "util.h"
_unused_
#include "af-list.h"
#include "af-to-name.h"
-int main(int argc, const char *argv[]) {
-
- unsigned i;
-
- for (i = 0; i < ELEMENTSOF(af_names); i++) {
+TEST(af_list) {
+ for (unsigned i = 0; i < ELEMENTSOF(af_names); i++) {
if (af_names[i]) {
assert_se(streq(af_to_name(i), af_names[i]));
assert_se(af_from_name(af_names[i]) == (int) i);
assert_se(af_to_name(-1) == NULL);
assert_se(af_from_name("huddlduddl") == -EINVAL);
assert_se(af_from_name("") == -EINVAL);
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "random-util.h"
#include "tests.h"
-static void test_alloca(void) {
+TEST(alloca) {
static const uint8_t zero[997] = { };
char *t;
assert_se(!memcmp(t, zero, 997));
}
-static void test_GREEDY_REALLOC(void) {
+TEST(GREEDY_REALLOC) {
_cleanup_free_ int *a = NULL, *b = NULL;
size_t i, j;
assert_se(b[j] == (int) j);
}
-static void test_memdup_multiply_and_greedy_realloc(void) {
+TEST(memdup_multiply_and_greedy_realloc) {
static const int org[] = { 1, 2, 3 };
_cleanup_free_ int *dup;
size_t i;
assert_se(p[i] == 0);
}
-static void test_bool_assign(void) {
+TEST(bool_assign) {
bool b, c, *cp = &c, d, e, f, g, h;
b = 123;
assert_se(++cleanup_counter == *(int*) a);
}
-static void test_cleanup_order(void) {
+TEST(cleanup_order) {
_cleanup_(cleanup1) int x1 = 4, x2 = 3;
_cleanup_(cleanup3) int z = 2;
_cleanup_(cleanup2) int y = 1;
log_debug("z: %p", &z);
}
-static void test_auto_erase_memory(void) {
+TEST(auto_erase_memory) {
_cleanup_(erase_and_freep) uint8_t *p1, *p2;
/* print address of p2, else e.g. clang-11 will optimize it out */
assert_se(__builtin_object_size(f, 0) >= sizeof(*f) * n); \
} while(false)
-static void test_malloc_size_safe(void) {
+TEST(malloc_size_safe) {
_cleanup_free_ uint32_t *f = NULL;
size_t n = 4711;
}
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_alloca();
- test_GREEDY_REALLOC();
- test_memdup_multiply_and_greedy_realloc();
- test_bool_assign();
- test_cleanup_order();
- test_auto_erase_memory();
- test_malloc_size_safe();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "string-util.h"
#include "tests.h"
-int main(int argc, const char *argv[]) {
- test_setup_logging(LOG_INFO);
-
+TEST(arphrd) {
for (int i = 0; i <= ARPHRD_VOID + 1; i++) {
const char *name;
assert_se(arphrd_to_name(ARPHRD_VOID + 1) == NULL);
assert_se(arphrd_from_name("huddlduddl") == -EINVAL);
assert_se(arphrd_from_name("") == -EINVAL);
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "strv.h"
#include "tests.h"
-static void test_ask_password(void) {
+TEST(ask_password) {
int r;
_cleanup_strv_free_ char **ret = NULL;
}
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_DEBUG);
-
- test_ask_password();
- return EXIT_SUCCESS;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
assert_se(expect < 0 || ((r > 0) == (expect > 0)));
}
-static void test_path_is_encrypted(void) {
+TEST(path_is_encrypted) {
int booted = sd_booted(); /* If this is run in build environments such as koji, /dev might be a
* reguar fs. Don't assume too much if not running under systemd. */
test_path_is_encrypted_one("/dev", booted > 0 ? false : -1);
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_INFO);
-
- test_path_is_encrypted();
-}
+DEFINE_TEST_MAIN(LOG_INFO);
(*n_called) ++;
}
-static void test_destroy_callback(void) {
+TEST(destroy_callback) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
sd_bus_slot *slot = NULL;
sd_bus_destroy_t t;
int r, n_called = 0;
- log_info("/* %s */", __func__);
-
r = bus_open_system_watch_bind_with_description(&bus, "test-bus");
if (r < 0) {
log_error_errno(r, "Failed to connect to bus: %m");
assert_se(n_called == 1);
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_DEBUG);
-
- test_destroy_callback();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "env-util.h"
#include "errno-util.h"
#include "string-util.h"
+#include "tests.h"
static void _test_one(int line, const char *input, const char *output) {
CalendarSpec *c;
}
#define test_next(input, new_tz, after, expect) _test_next(__LINE__, input,new_tz,after,expect)
-static void test_timestamp(void) {
+TEST(timestamp) {
char buf[FORMAT_TIMESTAMP_MAX];
_cleanup_free_ char *t = NULL;
CalendarSpec *c;
assert_se(y == x);
}
-static void test_hourly_bug_4031(void) {
+TEST(hourly_bug_4031) {
CalendarSpec *c;
usec_t n, u, w;
int r;
calendar_spec_free(c);
}
-int main(int argc, char* argv[]) {
- CalendarSpec *c;
-
+TEST(calendar_spec_one) {
test_one("Sat,Thu,Mon-Wed,Sat-Sun", "Mon..Thu,Sat,Sun *-*-* 00:00:00");
test_one("Sat,Thu,Mon..Wed,Sat..Sun", "Mon..Thu,Sat,Sun *-*-* 00:00:00");
test_one("Mon,Sun 12-*-* 2,1:23", "Mon,Sun 2012-*-* 01,02:23:00");
test_one("@0 UTC", "1970-01-01 00:00:00 UTC");
test_one("*:05..05", "*-*-* *:05:00");
test_one("*:05..10/6", "*-*-* *:05:00");
+}
+TEST(calendar_spec_next) {
test_next("2016-03-27 03:17:00", "", 12345, 1459048620000000);
test_next("2016-03-27 03:17:00", "CET", 12345, 1459041420000000);
test_next("2016-03-27 03:17:00", "EET", 12345, -1);
/* Check that we don't start looping if mktime() moves us backwards */
test_next("Sun *-*-* 01:00:00 Europe/Dublin", "", 1616412478000000, 1617494400000000);
test_next("Sun *-*-* 01:00:00 Europe/Dublin", "IST", 1616412478000000, 1617494400000000);
+}
+
+TEST(calendar_spec_from_string) {
+ CalendarSpec *c;
assert_se(calendar_spec_from_string("test", &c) < 0);
assert_se(calendar_spec_from_string(" utc", &c) < 0);
assert_se(calendar_spec_from_string("00:00:2300", &c) < 0);
assert_se(calendar_spec_from_string("00:00:18446744073709551615", &c) < 0);
assert_se(calendar_spec_from_string("@88588582097858858", &c) == -ERANGE);
-
- test_timestamp();
- test_hourly_bug_4031();
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "capability-util.h"
#include "parse-util.h"
#include "string-util.h"
+#include "tests.h"
#include "util.h"
/* verify the capability parser */
-static void test_cap_list(void) {
+TEST(cap_list) {
assert_se(!capability_to_name(-1));
assert_se(!capability_to_name(capability_list_length()));
assert_se(c1 == c_masked);
}
-static void test_capability_set_from_string(void) {
+TEST(capability_set_from_string) {
uint64_t c;
assert_se(capability_set_from_string(NULL, &c) == 0);
assert_se(c == (UINT64_C(1) << 4) - 1);
}
-static void test_capability_set_to_string(uint64_t invalid_cap_set) {
+static void test_capability_set_to_string_invalid(uint64_t invalid_cap_set) {
uint64_t c;
test_capability_set_one(invalid_cap_set, "");
"cap_audit_control cap_mac_override cap_syslog"));
}
-int main(int argc, char *argv[]) {
- test_cap_list();
- test_capability_set_from_string();
- test_capability_set_to_string(0);
+TEST(capability_set_to_string) {
+ test_capability_set_to_string_invalid(0);
/* once the kernel supports 63 caps, there are no 'invalid' numbers
* for us to test with */
if (cap_last_cap() < 63)
- test_capability_set_to_string(all_capabilities() + 1);
-
- return 0;
+ test_capability_set_to_string_invalid(all_capabilities() + 1);
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "cgroup.h"
#include "log.h"
+#include "tests.h"
-static void test_cgroup_cpu_adjust_period(void) {
- log_info("/* %s */", __func__);
-
+TEST(group_cpu_adjust_period) {
/* Period 1ms, quota 40% -> Period 2.5ms */
assert_se(2500 == cgroup_cpu_adjust_period(USEC_PER_MSEC, 400 * USEC_PER_MSEC, USEC_PER_MSEC, USEC_PER_SEC));
/* Period 10ms, quota 10% -> keep. */
assert_se(2500 == cgroup_cpu_adjust_period(0, 400 * USEC_PER_MSEC, USEC_PER_MSEC, USEC_PER_SEC));
}
-int main(int argc, char *argv[]) {
- test_cgroup_cpu_adjust_period();
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "string-util.h"
#include "tests.h"
-static void test_cg_split_spec(void) {
+TEST(cg_split_spec) {
char *c, *p;
- log_info("/* %s */", __func__);
-
assert_se(cg_split_spec("foobar:/", &c, &p) == 0);
assert_se(streq(c, "foobar"));
assert_se(streq(p, "/"));
c = mfree(c);
}
-static void test_cg_create(void) {
- log_info("/* %s */", __func__);
+TEST(cg_create) {
int r;
r = cg_unified_cached(false);
assert_se(cg_rmdir(SYSTEMD_CGROUP_CONTROLLER, test_a) == 0);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_cg_split_spec();
- test_cg_create();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "fs-util.h"
#include "log.h"
#include "macro.h"
+#include "tests.h"
#include "tmpfile-util.h"
-static void test_clock_is_localtime(void) {
+TEST(clock_is_localtime) {
_cleanup_(unlink_tempfilep) char adjtime[] = "/tmp/test-adjtime.XXXXXX";
_cleanup_fclose_ FILE* f = NULL;
}
/* Test with the real /etc/adjtime */
-static void test_clock_is_localtime_system(void) {
+TEST(clock_is_localtime_system) {
int r;
r = clock_is_localtime(NULL);
assert_se(r == 0 || ERRNO_IS_PRIVILEGE(r));
}
-int main(int argc, char *argv[]) {
- test_clock_is_localtime();
- test_clock_is_localtime_system();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "user-util.h"
#include "virt.h"
-static void test_condition_test_path(void) {
+TEST(condition_test_path) {
Condition *condition;
condition = condition_new(CONDITION_PATH_EXISTS, "/bin/sh", false, false);
condition_free(condition);
}
-static void test_condition_test_control_group_hierarchy(void) {
+TEST(condition_test_control_group_hierarchy) {
Condition *condition;
int r;
condition_free(condition);
}
-static void test_condition_test_control_group_controller(void) {
+TEST(condition_test_control_group_controller) {
Condition *condition;
CGroupMask system_mask;
_cleanup_free_ char *controller_name = NULL;
condition_free(condition);
}
-static void test_condition_test_ac_power(void) {
+TEST(condition_test_ac_power) {
Condition *condition;
condition = condition_new(CONDITION_AC_POWER, "true", false, false);
condition_free(condition);
}
-static void test_condition_test_host(void) {
+TEST(condition_test_host) {
_cleanup_free_ char *hostname = NULL;
Condition *condition;
sd_id128_t id;
}
}
-static void test_condition_test_architecture(void) {
+TEST(condition_test_architecture) {
Condition *condition;
const char *sa;
int a;
condition_free(condition);
}
-static void test_condition_test_kernel_command_line(void) {
+TEST(condition_test_kernel_command_line) {
Condition *condition;
int r;
condition_free(condition);
}
-static void test_condition_test_kernel_version(void) {
+TEST(condition_test_kernel_version) {
Condition *condition;
struct utsname u;
const char *v;
}
#if defined(__i386__) || defined(__x86_64__)
-static void test_condition_test_cpufeature(void) {
+TEST(condition_test_cpufeature) {
Condition *condition;
condition = condition_new(CONDITION_CPU_FEATURE, "fpu", false, false);
}
#endif
-static void test_condition_test_security(void) {
+TEST(condition_test_security) {
Condition *condition;
condition = condition_new(CONDITION_SECURITY, "garbage oifdsjfoidsjoj", false, false);
condition_free(condition);
}
-static void print_securities(void) {
+TEST(print_securities) {
log_info("------ enabled security technologies ------");
log_info("SELinux: %s", yes_no(mac_selinux_use()));
log_info("AppArmor: %s", yes_no(mac_apparmor_use()));
log_info("-------------------------------------------");
}
-static void test_condition_test_virtualization(void) {
+TEST(condition_test_virtualization) {
Condition *condition;
const char *virt;
int r;
}
}
-static void test_condition_test_user(void) {
+TEST(condition_test_user) {
Condition *condition;
char* uid;
char* username;
condition_free(condition);
}
-static void test_condition_test_group(void) {
+TEST(condition_test_group) {
Condition *condition;
char* gid;
char* groupname;
condition_free(condition);
}
-static void test_condition_test_cpus(void) {
+TEST(condition_test_cpus) {
_cleanup_free_ char *t = NULL;
int cpus;
condition_free(condition);
}
-static void test_condition_test_memory(void) {
+TEST(condition_test_memory) {
_cleanup_free_ char *t = NULL;
uint64_t memory;
condition_free(condition);
}
-static void test_condition_test_environment(void) {
+TEST(condition_test_environment) {
assert_se(setenv("EXISTINGENVVAR", "foo", false) >= 0);
test_condition_test_environment_one("MISSINGENVVAR", false);
test_condition_test_environment_one("EXISTINGENVVAR=", false);
}
-static void test_condition_test_os_release(void) {
+TEST(condition_test_os_release) {
_cleanup_strv_free_ char **os_release_pairs = NULL;
_cleanup_free_ char *version_id = NULL;
const char *key_value_pair;
condition_free(condition);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_condition_test_path();
- test_condition_test_ac_power();
- test_condition_test_host();
- test_condition_test_architecture();
- test_condition_test_kernel_command_line();
- test_condition_test_kernel_version();
- test_condition_test_security();
- print_securities();
- test_condition_test_virtualization();
- test_condition_test_user();
- test_condition_test_group();
- test_condition_test_control_group_hierarchy();
- test_condition_test_control_group_controller();
- test_condition_test_cpus();
- test_condition_test_memory();
- test_condition_test_environment();
-#if defined(__i386__) || defined(__x86_64__)
- test_condition_test_cpufeature();
-#endif
- test_condition_test_os_release();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
va_end(ap);
}
-static void test_conf_files_list(bool use_root) {
+static void test_conf_files_list_one(bool use_root) {
char tmp_dir[] = "/tmp/test-conf-files-XXXXXX";
_cleanup_strv_free_ char **found_files = NULL, **found_files2 = NULL;
const char *root_dir, *search, *expect_a, *expect_b, *expect_c, *mask;
assert_se(rm_rf(tmp_dir, REMOVE_ROOT|REMOVE_PHYSICAL) == 0);
}
-static void test_conf_files_insert(const char *root) {
+TEST(conf_files_list) {
+ test_conf_files_list_one(false);
+ test_conf_files_list_one(true);
+}
+
+static void test_conf_files_insert_one(const char *root) {
_cleanup_strv_free_ char **s = NULL;
log_info("/* %s root=%s */", __func__, strempty(root));
assert_se(strv_equal(s, STRV_MAKE(bar2, foo1, whatever, zzz3)));
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_DEBUG);
-
- test_conf_files_list(false);
- test_conf_files_list(true);
- test_conf_files_insert(NULL);
- test_conf_files_insert("/root");
- test_conf_files_insert("/root/");
-
- return 0;
+TEST(conf_files_insert) {
+ test_conf_files_insert_one(NULL);
+ test_conf_files_insert_one("/root");
+ test_conf_files_insert_one("/root/");
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "macro.h"
#include "string-util.h"
#include "strv.h"
+#include "tests.h"
#include "tmpfile-util.h"
#include "util.h"
assert_se(expected == v);
}
-static void test_config_parse_path(void) {
+TEST(config_parse_path) {
test_config_parse_path_one("/path", "/path");
test_config_parse_path_one("/path//////////", "/path");
test_config_parse_path_one("///path/foo///bar////bar//", "/path/foo/bar/bar");
test_config_parse_path_one("/path/\xc3\x7f", NULL);
}
-static void test_config_parse_log_level(void) {
+TEST(config_parse_log_level) {
test_config_parse_log_level_one("debug", LOG_DEBUG);
test_config_parse_log_level_one("info", LOG_INFO);
test_config_parse_log_level_one("garbage", 0);
}
-static void test_config_parse_log_facility(void) {
+TEST(config_parse_log_facility) {
test_config_parse_log_facility_one("mail", LOG_MAIL);
test_config_parse_log_facility_one("user", LOG_USER);
test_config_parse_log_facility_one("garbage", 0);
}
-static void test_config_parse_iec_size(void) {
+TEST(config_parse_iec_size) {
test_config_parse_iec_size_one("1024", 1024);
test_config_parse_iec_size_one("2K", 2048);
test_config_parse_iec_size_one("10M", 10 * 1024 * 1024);
test_config_parse_iec_size_one("garbage", 0);
}
-static void test_config_parse_si_uint64(void) {
+TEST(config_parse_si_uint64) {
test_config_parse_si_uint64_one("1024", 1024);
test_config_parse_si_uint64_one("2K", 2000);
test_config_parse_si_uint64_one("10M", 10 * 1000 * 1000);
test_config_parse_si_uint64_one("garbage", 0);
}
-static void test_config_parse_int(void) {
+TEST(config_parse_int) {
test_config_parse_int_one("1024", 1024);
test_config_parse_int_one("-1024", -1024);
test_config_parse_int_one("0", 0);
test_config_parse_int_one("garbage", -1);
}
-static void test_config_parse_unsigned(void) {
+TEST(config_parse_unsigned) {
test_config_parse_unsigned_one("10241024", 10241024);
test_config_parse_unsigned_one("1024", 1024);
test_config_parse_unsigned_one("0", 0);
test_config_parse_unsigned_one("1000garbage", 0);
}
-static void test_config_parse_strv(void) {
+TEST(config_parse_strv) {
test_config_parse_strv_one("", STRV_MAKE_EMPTY);
test_config_parse_strv_one("foo", STRV_MAKE("foo"));
test_config_parse_strv_one("foo bar foo", STRV_MAKE("foo", "bar", "foo"));
test_config_parse_strv_one("\xc3\x7f", STRV_MAKE("\xc3\x7f"));
}
-static void test_config_parse_mode(void) {
+TEST(config_parse_mode) {
test_config_parse_mode_one("777", 0777);
test_config_parse_mode_one("644", 0644);
test_config_parse_mode_one("777 garbage", 0);
}
-static void test_config_parse_sec(void) {
+TEST(config_parse_sec) {
test_config_parse_sec_one("1", 1 * USEC_PER_SEC);
test_config_parse_sec_one("1s", 1 * USEC_PER_SEC);
test_config_parse_sec_one("100ms", 100 * USEC_PER_MSEC);
test_config_parse_sec_one("garbage", 0);
}
-static void test_config_parse_nsec(void) {
+TEST(config_parse_nsec) {
test_config_parse_nsec_one("1", 1);
test_config_parse_nsec_one("1s", 1 * NSEC_PER_SEC);
test_config_parse_nsec_one("100ms", 100 * NSEC_PER_MSEC);
test_config_parse_nsec_one("garbage", 0);
}
-static void test_config_parse_iec_uint64(void) {
+TEST(config_parse_iec_uint64) {
uint64_t offset = 0;
assert_se(config_parse_iec_uint64(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset, NULL) == 0);
assert_se(offset == 4 * 1024 * 1024);
"setting1=3\n",
};
-static void test_config_parse(unsigned i, const char *s) {
+static void test_config_parse_one(unsigned i, const char *s) {
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-conf-parser.XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *setting1 = NULL;
}
}
-int main(int argc, char **argv) {
- unsigned i;
-
- log_parse_environment();
- log_open();
-
- test_config_parse_path();
- test_config_parse_log_level();
- test_config_parse_log_facility();
- test_config_parse_iec_size();
- test_config_parse_si_uint64();
- test_config_parse_int();
- test_config_parse_unsigned();
- test_config_parse_strv();
- test_config_parse_mode();
- test_config_parse_sec();
- test_config_parse_nsec();
- test_config_parse_iec_uint64();
-
- for (i = 0; i < ELEMENTSOF(config_file); i++)
- test_config_parse(i, config_file[i]);
-
- return 0;
+TEST(config_parse) {
+ for (unsigned i = 0; i < ELEMENTSOF(config_file); i++)
+ test_config_parse_one(i, config_file[i]);
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "util.h"
#include "xattr-util.h"
-static void test_copy_file(void) {
+TEST(copy_file) {
_cleanup_free_ char *buf = NULL;
char fn[] = "/tmp/test-copy_file.XXXXXX";
char fn_copy[] = "/tmp/test-copy_file.XXXXXX";
size_t sz = 0;
int fd;
- log_info("%s", __func__);
-
fd = mkostemp_safe(fn);
assert_se(fd >= 0);
close(fd);
unlink(fn_copy);
}
-static void test_copy_file_fd(void) {
+TEST(copy_file_fd) {
char in_fn[] = "/tmp/test-copy-file-fd-XXXXXX";
char out_fn[] = "/tmp/test-copy-file-fd-XXXXXX";
_cleanup_close_ int in_fd = -1, out_fd = -1;
const char *text = "boohoo\nfoo\n\tbar\n";
char buf[64] = {};
- log_info("%s", __func__);
-
in_fd = mkostemp_safe(in_fn);
assert_se(in_fd >= 0);
out_fd = mkostemp_safe(out_fn);
unlink(out_fn);
}
-static void test_copy_tree(void) {
+TEST(copy_tree) {
char original_dir[] = "/tmp/test-copy_tree/";
char copy_dir[] = "/tmp/test-copy_tree-copy/";
char **files = STRV_MAKE("file", "dir1/file", "dir1/dir2/file", "dir1/dir2/dir3/dir4/dir5/file");
int xattr_worked = -1; /* xattr support is optional in temporary directories, hence use it if we can,
* but don't fail if we can't */
- log_info("%s", __func__);
-
(void) rm_rf(copy_dir, REMOVE_ROOT|REMOVE_PHYSICAL);
(void) rm_rf(original_dir, REMOVE_ROOT|REMOVE_PHYSICAL);
(void) rm_rf(original_dir, REMOVE_ROOT|REMOVE_PHYSICAL);
}
-static void test_copy_bytes(void) {
+TEST(copy_bytes) {
_cleanup_close_pair_ int pipefd[2] = {-1, -1};
_cleanup_close_ int infd = -1;
int r, r2;
assert_se(r == -EBADF);
}
-static void test_copy_bytes_regular_file(const char *src, bool try_reflink, uint64_t max_bytes) {
+static void test_copy_bytes_regular_file_one(const char *src, bool try_reflink, uint64_t max_bytes) {
char fn2[] = "/tmp/test-copy-file-XXXXXX";
char fn3[] = "/tmp/test-copy-file-XXXXXX";
_cleanup_close_ int fd = -1, fd2 = -1, fd3 = -1;
unlink(fn3);
}
-static void test_copy_atomic(void) {
+TEST(copy_bytes_regular_file) {
+ test_copy_bytes_regular_file_one(saved_argv[0], false, UINT64_MAX);
+ test_copy_bytes_regular_file_one(saved_argv[0], true, UINT64_MAX);
+ test_copy_bytes_regular_file_one(saved_argv[0], false, 1000); /* smaller than copy buffer size */
+ test_copy_bytes_regular_file_one(saved_argv[0], true, 1000);
+ test_copy_bytes_regular_file_one(saved_argv[0], false, 32000); /* larger than copy buffer size */
+ test_copy_bytes_regular_file_one(saved_argv[0], true, 32000);
+}
+
+TEST(copy_atomic) {
_cleanup_(rm_rf_physical_and_freep) char *p = NULL;
const char *q;
int r;
assert_se(copy_file_atomic("/etc/fstab", q, 0644, 0, 0, COPY_REPLACE) >= 0);
}
-static void test_copy_proc(void) {
+TEST(copy_proc) {
_cleanup_(rm_rf_physical_and_freep) char *p = NULL;
_cleanup_free_ char *f = NULL, *a = NULL, *b = NULL;
assert_se(!isempty(a));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_copy_file();
- test_copy_file_fd();
- test_copy_tree();
- test_copy_bytes();
- test_copy_bytes_regular_file(argv[0], false, UINT64_MAX);
- test_copy_bytes_regular_file(argv[0], true, UINT64_MAX);
- test_copy_bytes_regular_file(argv[0], false, 1000); /* smaller than copy buffer size */
- test_copy_bytes_regular_file(argv[0], true, 1000);
- test_copy_bytes_regular_file(argv[0], false, 32000); /* larger than copy buffer size */
- test_copy_bytes_regular_file(argv[0], true, 32000);
- test_copy_atomic();
- test_copy_proc();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "macro.h"
#include "tests.h"
-static void test_coredump_filter_to_from_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(coredump_filter_to_from_string) {
for (CoredumpFilter i = 0; i < _COREDUMP_FILTER_MAX; i++) {
const char *n;
}
}
-static void test_coredump_filter_mask_from_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(coredump_filter_mask_from_string) {
uint64_t f;
assert_se(coredump_filter_mask_from_string("default", &f) == 0);
assert_se(f == COREDUMP_FILTER_MASK_DEFAULT);
1 << COREDUMP_FILTER_SHARED_DAX)));
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_INFO);
-
- test_coredump_filter_to_from_string();
- test_coredump_filter_mask_from_string();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "alloc-util.h"
#include "cpu-set-util.h"
#include "string-util.h"
+#include "tests.h"
#include "macro.h"
-static void test_parse_cpu_set(void) {
+TEST(parse_cpu_set) {
CPUSet c = {};
_cleanup_free_ char *str = NULL;
int cpu;
- log_info("/* %s */", __func__);
-
/* Single value */
assert_se(parse_cpu_set_full("0", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.set);
cpu_set_reset(&c);
}
-static void test_parse_cpu_set_extend(void) {
+TEST(parse_cpu_set_extend) {
CPUSet c = {};
_cleanup_free_ char *s1 = NULL, *s2 = NULL;
- log_info("/* %s */", __func__);
-
assert_se(parse_cpu_set_extend("1 3", &c, true, NULL, "fake", 1, "CPUAffinity") == 1);
assert_se(CPU_COUNT_S(c.allocated, c.set) == 2);
assert_se(s1 = cpu_set_to_string(&c));
log_info("cpu_set_to_string: (null)");
}
-static void test_cpu_set_to_from_dbus(void) {
+TEST(cpu_set_to_from_dbus) {
_cleanup_(cpu_set_reset) CPUSet c = {}, c2 = {};
_cleanup_free_ char *s = NULL;
- log_info("/* %s */", __func__);
-
assert_se(parse_cpu_set_extend("1 3 8 100-200", &c, true, NULL, "fake", 1, "CPUAffinity") == 1);
assert_se(s = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", s);
assert_se(memcmp(c.set, c2.set, c.allocated) == 0);
}
-static void test_cpus_in_affinity_mask(void) {
+TEST(cpus_in_affinity_mask) {
int r;
r = cpus_in_affinity_mask();
log_info("cpus_in_affinity_mask: %d", r);
}
-int main(int argc, char *argv[]) {
+TEST(print_cpu_alloc_size) {
log_info("CPU_ALLOC_SIZE(1) = %zu", CPU_ALLOC_SIZE(1));
log_info("CPU_ALLOC_SIZE(9) = %zu", CPU_ALLOC_SIZE(9));
log_info("CPU_ALLOC_SIZE(64) = %zu", CPU_ALLOC_SIZE(64));
log_info("CPU_ALLOC_SIZE(1024) = %zu", CPU_ALLOC_SIZE(1024));
log_info("CPU_ALLOC_SIZE(1025) = %zu", CPU_ALLOC_SIZE(1025));
log_info("CPU_ALLOC_SIZE(8191) = %zu", CPU_ALLOC_SIZE(8191));
-
- test_parse_cpu_set();
- test_parse_cpu_set_extend();
- test_cpus_in_affinity_mask();
- test_cpu_set_to_from_dbus();
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
fd = safe_close(fd);
}
-static void test_acquire_data_fd(void) {
+TEST(acquire_data_fd) {
test_acquire_data_fd_one(0);
test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL);
test_acquire_data_fd_one(ACQUIRE_NO_MEMFD);
}
}
-static void test_copy_data_fd(void) {
+TEST(copy_data_fd) {
_cleanup_close_ int fd1 = -1, fd2 = -1;
_cleanup_(close_pairp) int sfd[2] = { -1, -1 };
_cleanup_(sigkill_waitp) pid_t pid = -1;
assert_se(read(fd2, &j, sizeof(j)) == 0);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_acquire_data_fd();
- test_copy_data_fd();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "alloc-util.h"
#include "device-nodes.h"
#include "string-util.h"
+#include "tests.h"
/* helpers for test_encode_devnode_name */
static char *do_encode_string(const char *in) {
return streq(encoded, expected);
}
-static void test_encode_devnode_name(void) {
+TEST(encode_devnode_name) {
assert_se(expect_encoded_as("systemd sucks", "systemd\\x20sucks"));
assert_se(expect_encoded_as("pinkiepie", "pinkiepie"));
assert_se(expect_encoded_as("valíd\\ųtf8", "valíd\\x5cųtf8"));
assert_se(expect_encoded_as("QEMU ", "QEMU\\x20\\x20\\x20\\x20"));
}
-int main(int argc, char *argv[]) {
- test_encode_devnode_name();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
assert_se(streq(buffer, expect));
}
-static void test_dns_label_unescape(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_label_unescape) {
test_dns_label_unescape_one("hallo", "hallo", 6, 5, 5);
test_dns_label_unescape_one("hallo", "hallo", 4, -ENOBUFS, -ENOBUFS);
test_dns_label_unescape_one("", "", 10, 0, 0);
assert_se(!memcmp(buffer, expect, r));
}
-static void test_dns_name_to_wire_format(void) {
+TEST(dns_name_to_wire_format) {
static const char out0[] = { 0 };
static const char out1[] = { 3, 'f', 'o', 'o', 0 };
static const char out2[] = { 5, 'h', 'a', 'l', 'l', 'o', 3, 'f', 'o', 'o', 3, 'b', 'a', 'r', 0 };
9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
3, 'a', '1', '2', 0 };
- log_info("/* %s */", __func__);
-
test_dns_name_to_wire_format_one("", out0, sizeof(out0), sizeof(out0));
test_dns_name_to_wire_format_one("foo", out1, sizeof(out1), sizeof(out1));
assert_se(streq(buffer, expect2));
}
-static void test_dns_label_unescape_suffix(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_label_unescape_suffix) {
test_dns_label_unescape_suffix_one("hallo", "hallo", "", 6, 5, 0);
test_dns_label_unescape_suffix_one("hallo", "hallo", "", 4, -ENOBUFS, -ENOBUFS);
test_dns_label_unescape_suffix_one("", "", "", 10, 0, 0);
assert_se(streq_ptr(expect, t));
}
-static void test_dns_label_escape(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_label_escape) {
test_dns_label_escape_one("", 0, NULL, -EINVAL);
test_dns_label_escape_one("hallo", 5, "hallo", 5);
test_dns_label_escape_one("hallo", 6, "hallo\\000", 9);
assert_se(streq_ptr(expect, t));
}
-static void test_dns_name_normalize(void) {
+TEST(dns_name_normalize) {
test_dns_name_normalize_one("", ".", 0);
test_dns_name_normalize_one("f", "f", 0);
test_dns_name_normalize_one("f.waldi", "f.waldi", 0);
assert_se(r == ret);
}
-static void test_dns_name_equal(void) {
+TEST(dns_name_equal) {
test_dns_name_equal_one("", "", true);
test_dns_name_equal_one("x", "x", true);
test_dns_name_equal_one("x", "x.", true);
assert_se(r == ret);
}
-static void test_dns_name_between(void) {
+TEST(dns_name_between) {
/* see https://tools.ietf.org/html/rfc4034#section-6.1
Note that we use "\033.z.example" in stead of "\001.z.example" as we
consider the latter invalid */
assert_se(dns_name_endswith(a, b) == ret);
}
-static void test_dns_name_endswith(void) {
+TEST(dns_name_endswith) {
test_dns_name_endswith_one("", "", true);
test_dns_name_endswith_one("", "xxx", false);
test_dns_name_endswith_one("xxx", "", true);
assert_se(dns_name_startswith(a, b) == ret);
}
-static void test_dns_name_startswith(void) {
+TEST(dns_name_startswith) {
test_dns_name_startswith_one("", "", true);
test_dns_name_startswith_one("", "xxx", false);
test_dns_name_startswith_one("xxx", "", true);
test_dns_name_startswith_one("x.y", "X", true);
}
-static void test_dns_name_is_root(void) {
+TEST(dns_name_is_root) {
assert_se(dns_name_is_root(""));
assert_se(dns_name_is_root("."));
assert_se(!dns_name_is_root("xxx"));
assert_se(!dns_name_is_root(".."));
}
-static void test_dns_name_is_single_label(void) {
+TEST(dns_name_is_single_label) {
assert_se(!dns_name_is_single_label(""));
assert_se(!dns_name_is_single_label("."));
assert_se(!dns_name_is_single_label(".."));
assert_se(in_addr_equal(familya, &a, &b));
}
-static void test_dns_name_reverse(void) {
+TEST(dns_name_reverse) {
test_dns_name_reverse_one("47.11.8.15", "15.8.11.47.in-addr.arpa");
test_dns_name_reverse_one("fe80::47", "7.4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.e.f.ip6.arpa");
test_dns_name_reverse_one("127.0.0.1", "1.0.0.127.in-addr.arpa");
assert_se(streq_ptr(p, result));
}
-static void test_dns_name_concat(void) {
+TEST(dns_name_concat) {
test_dns_name_concat_one("", "", 0, ".");
test_dns_name_concat_one(".", "", 0, ".");
test_dns_name_concat_one("", ".", 0, ".");
assert_se(dns_name_is_valid_ldh(s) == ret_ldh);
}
-static void test_dns_name_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_name_is_valid) {
test_dns_name_is_valid_one("foo", 1, 1);
test_dns_name_is_valid_one("foo.", 1, 1);
test_dns_name_is_valid_one("foo..", 0, 0);
test_dns_name_is_valid_one("a123456789a123456789a123456789a123456789a123456789a123456789a12", 1, 1);
}
-static void test_dns_service_name_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_service_name_is_valid) {
assert_se(dns_service_name_is_valid("Lennart's Compüter"));
assert_se(dns_service_name_is_valid("piff.paff"));
assert_se(!dns_service_name_is_valid("this is an overly long string that is certainly longer than 63 characters"));
}
-static void test_dns_srv_type_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_srv_type_is_valid) {
assert_se(dns_srv_type_is_valid("_http._tcp"));
assert_se(dns_srv_type_is_valid("_foo-bar._tcp"));
assert_se(dns_srv_type_is_valid("_w._udp"));
assert_se(!dns_srv_type_is_valid("_piep._foo._udp"));
}
-static void test_dnssd_srv_type_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(dnssd_srv_type_is_valid) {
assert_se(dnssd_srv_type_is_valid("_http._tcp"));
assert_se(dnssd_srv_type_is_valid("_foo-bar._tcp"));
assert_se(dnssd_srv_type_is_valid("_w._udp"));
assert_se(dns_name_equal(c, z) > 0);
}
-static void test_dns_service_join(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_service_join) {
test_dns_service_join_one("", "", "", -EINVAL, NULL);
test_dns_service_join_one("", "_http._tcp", "", -EINVAL, NULL);
test_dns_service_join_one("", "_http._tcp", "foo", -EINVAL, NULL);
assert_se(!x && dns_name_equal(z, joined) > 0);
}
-static void test_dns_service_split(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_service_split) {
test_dns_service_split_one("", NULL, NULL, ".", 0);
test_dns_service_split_one("foo", NULL, NULL, "foo", 0);
test_dns_service_split_one("foo.bar", NULL, NULL, "foo.bar", 0);
assert_se(streq_ptr(s, result));
}
-static void test_dns_name_change_suffix(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_name_change_suffix) {
test_dns_name_change_suffix_one("foo.bar", "bar", "waldo", 1, "foo.waldo");
test_dns_name_change_suffix_one("foo.bar.waldi.quux", "foo.bar.waldi.quux", "piff.paff", 1, "piff.paff");
test_dns_name_change_suffix_one("foo.bar.waldi.quux", "bar.waldi.quux", "piff.paff", 1, "foo.piff.paff");
assert_se(streq_ptr(p, result));
}
-static void test_dns_name_suffix(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_name_suffix) {
test_dns_name_suffix_one("foo.bar", 2, "foo.bar", 0);
test_dns_name_suffix_one("foo.bar", 1, "bar", 1);
test_dns_name_suffix_one("foo.bar", 0, "", 2);
assert_se(dns_name_count_labels(name) == n);
}
-static void test_dns_name_count_labels(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_name_count_labels) {
test_dns_name_count_labels_one("foo.bar.quux.", 3);
test_dns_name_count_labels_one("foo.bar.quux", 3);
test_dns_name_count_labels_one("foo.bar.", 2);
assert_se(dns_name_equal_skip(a, n_labels, b) == ret);
}
-static void test_dns_name_equal_skip(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_name_equal_skip) {
test_dns_name_equal_skip_one("foo", 0, "bar", 0);
test_dns_name_equal_skip_one("foo", 0, "foo", 1);
test_dns_name_equal_skip_one("foo", 1, "foo", 0);
test_dns_name_equal_skip_one("", 2, "foo", 0);
}
-static void test_dns_name_compare_func(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_name_compare_func) {
assert_se(dns_name_compare_func("", "") == 0);
assert_se(dns_name_compare_func("", ".") == 0);
assert_se(dns_name_compare_func(".", "") == 0);
assert_se(streq(c, result));
}
-static void test_dns_name_common_suffix(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_name_common_suffix) {
test_dns_name_common_suffix_one("", "", "");
test_dns_name_common_suffix_one("foo", "", "");
test_dns_name_common_suffix_one("", "foo", "");
assert_se(dns_name_equal(buf, result) == 1);
}
-static void test_dns_name_apply_idna(void) {
-#if HAVE_LIBIDN2 || HAVE_LIBIDN
- const int ret = 1;
-#else
- const int ret = 0;
-#endif
- log_info("/* %s */", __func__);
+TEST(dns_name_apply_idna) {
+ const int ret = HAVE_LIBIDN2 | HAVE_LIBIDN;
/* IDNA2008 forbids names with hyphens in third and fourth positions
* (https://tools.ietf.org/html/rfc5891#section-4.2.3.1).
* labels. If registrars follow IDNA2008 we'll just be performing a
* useless lookup.
*/
-#if HAVE_LIBIDN
- const int ret2 = 1;
-#else
- const int ret2 = 0;
-#endif
+ const int ret2 = HAVE_LIBIDN;
test_dns_name_apply_idna_one("", ret, "");
test_dns_name_apply_idna_one("foo", ret, "foo");
ret2 ? "r3---sn-ab5l6ne7.googlevideo.com" : "");
}
-static void test_dns_name_is_valid_or_address(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_name_is_valid_or_address) {
assert_se(dns_name_is_valid_or_address(NULL) == 0);
assert_se(dns_name_is_valid_or_address("") == 0);
assert_se(dns_name_is_valid_or_address("foobar") > 0);
assert_se(dns_name_is_valid_or_address("::1") > 0);
}
-static void test_dns_name_dot_suffixed(void) {
- log_info("/* %s */", __func__);
-
+TEST(dns_name_dot_suffixed) {
assert_se(dns_name_dot_suffixed("") == 0);
assert_se(dns_name_dot_suffixed(".") > 0);
assert_se(dns_name_dot_suffixed("foo") == 0);
assert_se(dns_name_dot_suffixed("foo.bar\\.\\.\\.\\.") == 0);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_dns_label_unescape();
- test_dns_label_unescape_suffix();
- test_dns_label_escape();
- test_dns_name_normalize();
- test_dns_name_equal();
- test_dns_name_endswith();
- test_dns_name_startswith();
- test_dns_name_between();
- test_dns_name_is_root();
- test_dns_name_is_single_label();
- test_dns_name_reverse();
- test_dns_name_concat();
- test_dns_name_is_valid();
- test_dns_name_to_wire_format();
- test_dns_service_name_is_valid();
- test_dns_srv_type_is_valid();
- test_dnssd_srv_type_is_valid();
- test_dns_service_join();
- test_dns_service_split();
- test_dns_name_change_suffix();
- test_dns_name_suffix();
- test_dns_name_count_labels();
- test_dns_name_equal_skip();
- test_dns_name_compare_func();
- test_dns_name_common_suffix();
- test_dns_name_apply_idna();
- test_dns_name_is_valid_or_address();
- test_dns_name_dot_suffixed();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "string-util.h"
#include "strv.h"
#include "terminal-util.h"
+#include "tests.h"
#include "util.h"
#include "utf8.h"
}
}
-static void test_ellipsize_mem(void) {
+TEST(ellipsize_mem) {
const char *s;
ssize_t l, k;
puts(t);
}
-static void test_ellipsize(void) {
+TEST(ellipsize) {
test_ellipsize_one(DIGITS LETTERS DIGITS LETTERS);
test_ellipsize_one("한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어");
test_ellipsize_one("-日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国");
test_ellipsize_one("shórt");
}
-int main(int argc, char *argv[]) {
- test_ellipsize_mem();
- test_ellipsize();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "emergency-action.h"
#include "tests.h"
-static void test_parse_emergency_action(void) {
+TEST(parse_emergency_action) {
EmergencyAction x;
- log_info("/* %s */", __func__);
-
assert_se(parse_emergency_action("none", false, &x) == 0);
assert_se(x == EMERGENCY_ACTION_NONE);
assert_se(parse_emergency_action("reboot", false, &x) == -EOPNOTSUPP);
assert_se(x == EMERGENCY_ACTION_EXIT_FORCE);
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_INFO);
-
- test_parse_emergency_action();
-
- return EXIT_SUCCESS;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
"a=\n" \
"b="
-static void test_load_env_file_1(void) {
+TEST(load_env_file_1) {
_cleanup_strv_free_ char **data = NULL;
int r;
assert_se(data[6] == NULL);
}
-static void test_load_env_file_2(void) {
+TEST(load_env_file_2) {
_cleanup_strv_free_ char **data = NULL;
int r;
assert_se(data[1] == NULL);
}
-static void test_load_env_file_3(void) {
+TEST(load_env_file_3) {
_cleanup_strv_free_ char **data = NULL;
int r;
assert_se(data == NULL);
}
-static void test_load_env_file_4(void) {
+TEST(load_env_file_4) {
_cleanup_strv_free_ char **data = NULL;
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-load-env-file.XXXXXX";
_cleanup_close_ int fd;
assert_se(data[3] == NULL);
}
-static void test_load_env_file_5(void) {
+TEST(load_env_file_5) {
_cleanup_strv_free_ char **data = NULL;
int r;
assert_se(data[2] == NULL);
}
-static void test_write_and_load_env_file(void) {
+TEST(write_and_load_env_file) {
const char *v;
/* Make sure that our writer, parser and the shell agree on what our env var files mean */
}
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- test_load_env_file_1();
- test_load_env_file_2();
- test_load_env_file_3();
- test_load_env_file_4();
- test_load_env_file_5();
-
- test_write_and_load_env_file();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "tests.h"
#include "util.h"
-static void test_strv_env_delete(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_env_delete) {
_cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
assert_se(strv_length(d) == 2);
}
-static void test_strv_env_get(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_env_get) {
char **l = STRV_MAKE("ONE_OR_TWO=1", "THREE=3", "ONE_OR_TWO=2", "FOUR=4");
assert_se(streq(strv_env_get(l, "ONE_OR_TWO"), "2"));
assert_se(streq(strv_env_get(l, "FOUR"), "4"));
}
-static void test_strv_env_pairs_get(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_env_pairs_get) {
char **l = STRV_MAKE("ONE_OR_TWO", "1", "THREE", "3", "ONE_OR_TWO", "2", "FOUR", "4", "FIVE", "5", "SIX", "FIVE", "SEVEN", "7");
assert_se(streq(strv_env_pairs_get(l, "ONE_OR_TWO"), "2"));
assert_se(streq(strv_env_pairs_get(l, "FIVE"), "5"));
}
-static void test_strv_env_unset(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_env_unset) {
_cleanup_strv_free_ char **l = NULL;
l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
assert_se(strv_length(l) == 2);
}
-static void test_strv_env_merge(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_env_merge) {
char **a = STRV_MAKE("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF", "EQ===");
char **b = STRV_MAKE("FOO=KKK", "FOO=", "PIEP=", "SCHLUMPF=SMURFF", "NANANANA=YES");
assert_se(strv_length(r) == 6);
}
-static void test_strv_env_replace_strdup(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_env_replace_strdup) {
_cleanup_strv_free_ char **a = NULL;
assert_se(strv_env_replace_strdup(&a, "a=a") == 1);
assert_se(streq(a[1], "b=b"));
}
-static void test_strv_env_replace_strdup_passthrough(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_env_replace_strdup_passthrough) {
_cleanup_strv_free_ char **a = NULL;
assert_se(putenv((char*) "a=a") == 0);
assert_se(streq(a[2], "c="));
}
-static void test_strv_env_assign(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_env_assign) {
_cleanup_strv_free_ char **a = NULL;
assert_se(strv_env_assign(&a, "a", "a") == 1);
assert_se(streq(a[0], "a=A"));
}
-static void test_env_strv_get_n(void) {
- log_info("/* %s */", __func__);
-
+TEST(env_strv_get_n) {
const char *_env[] = {
"FOO=NO NO NO",
"FOO=BAR BAR",
getenv("PATH")));
}
-static void test_replace_env(bool braceless) {
+static void test_replace_env1(bool braceless) {
log_info("/* %s(braceless=%s) */", __func__, yes_no(braceless));
const char *env[] = {
assert_se(streq(y, extended ? "FOO=foobetweenbar" : "FOO=foobetween${BAR:-baz}"));
}
-static void test_replace_env_argv(void) {
- log_info("/* %s */", __func__);
+TEST(replace_env) {
+ test_replace_env1(false);
+ test_replace_env1(true);
+ test_replace_env2(false);
+ test_replace_env2(true);
+}
+TEST(replace_env_argv) {
const char *env[] = {
"FOO=BAR BAR",
"BAR=waldo",
assert_se(strv_length(r) == 17);
}
-static void test_env_clean(void) {
- log_info("/* %s */", __func__);
-
+TEST(env_clean) {
_cleanup_strv_free_ char **e = strv_new("FOOBAR=WALDO",
"FOOBAR=WALDO",
"FOOBAR",
assert_se(e[8] == NULL);
}
-static void test_env_name_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(env_name_is_valid) {
assert_se(env_name_is_valid("test"));
assert_se(!env_name_is_valid(NULL));
assert_se(!env_name_is_valid("#¤%&?_only_numbers_letters_and_underscore_allowed"));
}
-static void test_env_value_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(env_value_is_valid) {
assert_se(env_value_is_valid(""));
assert_se(env_value_is_valid("głąb kapuściany"));
assert_se(env_value_is_valid("printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
* We currently disallow that. */
}
-static void test_env_assignment_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(env_assignment_is_valid) {
assert_se(env_assignment_is_valid("a="));
assert_se(env_assignment_is_valid("b=głąb kapuściany"));
assert_se(env_assignment_is_valid("c=\\007\\009\\011"));
assert_se(!env_assignment_is_valid("głąb=printf \"\x1b]0;<mock-chroot>\x07<mock-chroot>\""));
}
-static void test_putenv_dup(void) {
- log_info("/* %s */", __func__);
-
+TEST(putenv_dup) {
assert_se(putenv_dup("A=a1", true) == 0);
assert_se(streq_ptr(getenv("A"), "a1"));
assert_se(putenv_dup("A=a1", true) == 0);
assert_se(streq_ptr(getenv("A"), "a2"));
}
-static void test_setenv_systemd_exec_pid(void) {
+TEST(setenv_systemd_exec_pid) {
_cleanup_free_ char *saved = NULL;
const char *e;
pid_t p;
- log_info("/* %s */", __func__);
-
e = getenv("SYSTEMD_EXEC_PID");
if (e)
assert_se(saved = strdup(e));
assert_se(set_unset_env("SYSTEMD_EXEC_PID", saved, 1) >= 0);
}
-static void test_unsetenv_erase(void) {
+TEST(unsetenv_erase) {
int r;
- log_info("/* %s */", __func__);
-
r = safe_fork("(sd-unsetenverase)", FORK_DEATHSIG|FORK_LOG|FORK_WAIT, NULL);
if (r == 0) {
_cleanup_strv_free_ char **l = NULL;
assert_se(r > 0);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_strv_env_delete();
- test_strv_env_get();
- test_strv_env_pairs_get();
- test_strv_env_unset();
- test_strv_env_merge();
- test_strv_env_replace_strdup();
- test_strv_env_replace_strdup_passthrough();
- test_strv_env_assign();
- test_env_strv_get_n();
- test_replace_env(false);
- test_replace_env(true);
- test_replace_env2(false);
- test_replace_env2(true);
- test_replace_env_argv();
- test_env_clean();
- test_env_name_is_valid();
- test_env_value_is_valid();
- test_env_assignment_is_valid();
- test_putenv_dup();
- test_setenv_systemd_exec_pid();
- test_unsetenv_erase();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "macro.h"
#include "tests.h"
-static void test_cescape(void) {
+TEST(cescape) {
_cleanup_free_ char *t;
- log_info("/* %s */", __func__);
-
assert_se(t = cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
assert_se(streq(t, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
}
-static void test_xescape(void) {
+TEST(xescape) {
_cleanup_free_ char *t;
- log_info("/* %s */", __func__);
-
assert_se(t = xescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313", ""));
assert_se(streq(t, "abc\\x5c\"\\x08\\x0c\\x0a\\x0d\\x09\\x0b\\x07\\x03\\x7f\\x9c\\xcb"));
}
-static void test_xescape_full(bool eight_bits) {
+static void test_xescape_full_one(bool eight_bits) {
const char* escaped = !eight_bits ?
"a\\x62c\\x5c\"\\x08\\x0c\\x0a\\x0d\\x09\\x0b\\x07\\x03\\x7f\\x9c\\xcb" :
"a\\x62c\\x5c\"\\x08\\x0c\\x0a\\x0d\\x09\\x0b\\x07\\x03\177\234\313";
}
}
-static void test_cunescape(void) {
- _cleanup_free_ char *unescaped;
+TEST(test_xescape_full) {
+ test_xescape_full_one(false);
+ test_xescape_full_one(true);
+}
- log_info("/* %s */", __func__);
+TEST(cunescape) {
+ _cleanup_free_ char *unescaped;
assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped) < 0);
assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX, &unescaped) >= 0);
assert_se(streq_ptr(r, expected));
}
-static void test_shell_escape(void) {
- log_info("/* %s */", __func__);
-
+TEST(shell_escape) {
test_shell_escape_one("", "", "");
test_shell_escape_one("\\", "", "\\\\");
test_shell_escape_one("foobar", "", "foobar");
assert_se(streq(ret, expected));
}
-static void test_shell_maybe_quote(void) {
- log_info("/* %s */", __func__);
-
+TEST(shell_maybe_quote) {
test_shell_maybe_quote_one("", 0, "");
test_shell_maybe_quote_one("", SHELL_ESCAPE_EMPTY, "\"\"");
test_shell_maybe_quote_one("", SHELL_ESCAPE_POSIX, "");
assert_se(streq(s, expected));
}
-static void test_quote_command_line(void) {
- log_info("/* %s */", __func__);
-
+TEST(quote_command_line) {
test_quote_command_line_one(STRV_MAKE("true", "true"),
"true true");
test_quote_command_line_one(STRV_MAKE("true", "with a space"),
"true \"\\$dollar\"");
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_cescape();
- test_xescape();
- test_xescape_full(false);
- test_xescape_full(true);
- test_cunescape();
- test_shell_escape();
- test_shell_maybe_quote();
- test_quote_command_line();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "string-util.h"
#include "tests.h"
-static void test_ether_addr_helpers(void) {
+TEST(ether_addr_helpers) {
struct ether_addr a;
- log_info("/* %s */", __func__);
-
a = ETHER_ADDR_NULL;
assert_se(ether_addr_is_null(&a));
assert_se(!ether_addr_is_broadcast(&a));
#define INFINIBAD_ADDR_1 ((const struct hw_addr_data){ .length = 20, .infiniband = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20} })
-static void test_HW_ADDR_TO_STRING(void) {
- log_info("/* %s */", __func__);
-
+TEST(HW_ADDR_TO_STRING) {
const char *s = HW_ADDR_TO_STR(&(const struct hw_addr_data){6});
log_info("null: %s", s);
}
}
-static void test_parse_hw_addr(void) {
- log_info("/* %s */", __func__);
-
+TEST(parse_hw_addr) {
/* IPv4 */
test_parse_hw_addr_full_one("10.0.0.1", 0, "0a:00:00:01");
test_parse_hw_addr_full_one("10.0.0.1", 4, "0a:00:00:01");
test_parse_hw_addr_full_one("aa bb", SIZE_MAX, NULL);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- test_ether_addr_helpers();
- test_HW_ADDR_TO_STRING();
- test_parse_hw_addr();
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
ignore_stdout_func3,
};
-static void test_execute_directory(bool gather_stdout) {
+static void test_execute_directory_one(bool gather_stdout) {
char template_lo[] = "/tmp/test-exec-util.lo.XXXXXXX";
char template_hi[] = "/tmp/test-exec-util.hi.XXXXXXX";
const char * dirs[] = {template_hi, template_lo, NULL};
(void) rm_rf(template_hi, REMOVE_ROOT|REMOVE_PHYSICAL);
}
-static void test_execution_order(void) {
+TEST(execute_directory) {
+ test_execute_directory_one(true);
+ test_execute_directory_one(false);
+}
+
+TEST(execution_order) {
char template_lo[] = "/tmp/test-exec-util-lo.XXXXXXX";
char template_hi[] = "/tmp/test-exec-util-hi.XXXXXXX";
const char *dirs[] = {template_hi, template_lo, NULL};
gather_stdout_three,
};
-static void test_stdout_gathering(void) {
+TEST(stdout_gathering) {
char template[] = "/tmp/test-exec-util.XXXXXXX";
const char *dirs[] = {template, NULL};
const char *name, *name2, *name3;
assert_se(mkdtemp(template));
- log_info("/* %s */", __func__);
-
/* write files */
name = strjoina(template, "/10-foo");
name2 = strjoina(template, "/20-bar");
assert_se(streq(output, "a\nb\nc\nd\n"));
}
-static void test_environment_gathering(void) {
+TEST(environment_gathering) {
char template[] = "/tmp/test-exec-util.XXXXXXX", **p;
const char *dirs[] = {template, NULL};
const char *name, *name2, *name3, *old;
assert_se(mkdtemp(template));
- log_info("/* %s */", __func__);
-
/* write files */
name = strjoina(template, "/10-foo");
name2 = strjoina(template, "/20-bar");
assert_se(set_unset_env("PATH", old, true) == 0);
}
-static void test_error_catching(void) {
+TEST(error_catching) {
char template[] = "/tmp/test-exec-util.XXXXXXX";
const char *dirs[] = {template, NULL};
const char *name, *name2, *name3;
assert_se(mkdtemp(template));
- log_info("/* %s */", __func__);
-
/* write files */
name = strjoina(template, "/10-foo");
name2 = strjoina(template, "/20-bar");
assert_se(r == 42);
}
-static void test_exec_command_flags_from_strv(void) {
+TEST(exec_command_flags_from_strv) {
ExecCommandFlags flags = 0;
char **valid_strv = STRV_MAKE("no-env-expand", "no-setuid", "ignore-failure");
char **invalid_strv = STRV_MAKE("no-env-expand", "no-setuid", "nonexistent-option", "ignore-failure");
assert_se(r == -EINVAL);
}
-static void test_exec_command_flags_to_strv(void) {
+TEST(exec_command_flags_to_strv) {
_cleanup_strv_free_ char **opts = NULL, **empty_opts = NULL, **invalid_opts = NULL;
ExecCommandFlags flags = 0;
int r;
assert_se(r == -EINVAL);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_execute_directory(true);
- test_execute_directory(false);
- test_execution_order();
- test_stdout_gathering();
- test_environment_gathering();
- test_error_catching();
- test_exec_command_flags_from_strv();
- test_exec_command_flags_to_strv();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "string-util.h"
#include "tests.h"
-static void test_exit_status_to_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(exit_status_to_string) {
for (int i = -1; i <= 256; i++) {
const char *s, *class;
}
}
-static void test_exit_status_from_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(exit_status_from_string) {
assert_se(exit_status_from_string("11") == 11);
assert_se(exit_status_from_string("-1") == -ERANGE);
assert_se(exit_status_from_string("256") == -ERANGE);
assert_se(exit_status_from_string("FAILURE") == 1);
}
-static void test_exit_status_NUMA_POLICY(void) {
- log_info("/* %s */", __func__);
-
+TEST(exit_status_NUMA_POLICY) {
assert_se(streq(exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_FULL), "NUMA_POLICY"));
assert_se(streq(exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_SYSTEMD), "NUMA_POLICY"));
assert_se(!exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_BSD));
assert_se(!exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_LSB));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_exit_status_to_string();
- test_exit_status_from_string();
- test_exit_status_NUMA_POLICY();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "extract-word.h"
#include "log.h"
#include "string-util.h"
+#include "tests.h"
-static void test_extract_first_word(void) {
+TEST(extract_first_word) {
const char *p, *original;
char *t;
- log_info("/* %s */", __func__);
-
p = original = "foobar waldo";
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
assert_se(streq(t, "foobar"));
free(t);
}
-static void test_extract_first_word_and_warn(void) {
+TEST(extract_first_word_and_warn) {
const char *p, *original;
char *t;
- log_info("/* %s */", __func__);
-
p = original = "foobar waldo";
assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
assert_se(streq(t, "foobar"));
assert_se(isempty(p));
}
-static void test_extract_many_words(void) {
+TEST(extract_many_words) {
const char *p, *original;
char *a, *b, *c, *d, *e, *f;
- log_info("/* %s */", __func__);
-
p = original = "foobar waldi piep";
assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c, NULL) == 3);
assert_se(isempty(p));
free(a);
}
-int main(int argc, char *argv[]) {
- log_parse_environment();
- log_open();
-
- test_extract_first_word();
- test_extract_first_word_and_warn();
- test_extract_many_words();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "tests.h"
#include "tmpfile-util.h"
-static void test_close_many(void) {
+TEST(close_many) {
int fds[3];
char name0[] = "/tmp/test-close-many.XXXXXX";
char name1[] = "/tmp/test-close-many.XXXXXX";
unlink(name2);
}
-static void test_close_nointr(void) {
+TEST(close_nointr) {
char name[] = "/tmp/test-test-close_nointr.XXXXXX";
int fd;
unlink(name);
}
-static void test_same_fd(void) {
+TEST(same_fd) {
_cleanup_close_pair_ int p[2] = { -1, -1 };
_cleanup_close_ int a = -1, b = -1, c = -1;
assert_se(same_fd(b, a) == 0);
}
-static void test_open_serialization_fd(void) {
+TEST(open_serialization_fd) {
_cleanup_close_ int fd = -1;
fd = open_serialization_fd("test");
assert_se(write(fd, "test\n", 5) == 5);
}
-static void test_fd_move_above_stdio(void) {
+TEST(fd_move_above_stdio) {
int original_stdin, new_fd;
original_stdin = fcntl(0, F_DUPFD, 3);
assert_se(close_nointr(new_fd) != EBADF);
}
-static void test_rearrange_stdio(void) {
+TEST(rearrange_stdio) {
pid_t pid;
int r;
}
}
-static void test_read_nr_open(void) {
+TEST(read_nr_open) {
log_info("nr-open: %i", read_nr_open());
}
#endif
}
-static void test_close_all_fds(void) {
+TEST(close_all_fds) {
int r;
/* Runs the test four times. Once as is. Once with close_range() syscall blocked via seccomp, once
assert_se(r >= 0);
}
-static void test_format_proc_fd_path(void) {
+TEST(format_proc_fd_path) {
assert_se(streq_ptr(FORMAT_PROC_FD_PATH(0), "/proc/self/fd/0"));
assert_se(streq_ptr(FORMAT_PROC_FD_PATH(1), "/proc/self/fd/1"));
assert_se(streq_ptr(FORMAT_PROC_FD_PATH(2), "/proc/self/fd/2"));
assert_se(streq_ptr(FORMAT_PROC_FD_PATH(2147483647), "/proc/self/fd/2147483647"));
}
-static void test_fd_reopen(void) {
+TEST(fd_reopen) {
_cleanup_close_ int fd1 = -1, fd2 = -1;
struct stat st1, st2;
int fl;
fd1 = -1;
}
-static void test_take_fd(void) {
+TEST(take_fd) {
_cleanup_close_ int fd1 = -1, fd2 = -1;
int array[2] = { -1, -1 }, i = 0;
- log_info("/* %s */", __func__);
-
assert_se(fd1 == -1);
assert_se(fd2 == -1);
assert_se(array[1] == -1);
}
-int main(int argc, char *argv[]) {
-
- test_setup_logging(LOG_DEBUG);
-
- test_close_many();
- test_close_nointr();
- test_same_fd();
- test_open_serialization_fd();
- test_fd_move_above_stdio();
- test_rearrange_stdio();
- test_read_nr_open();
- test_close_all_fds();
- test_format_proc_fd_path();
- test_fd_reopen();
- test_take_fd();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "fd-util.h"
#include "fdset.h"
#include "macro.h"
+#include "tests.h"
#include "tmpfile-util.h"
#include "util.h"
-static void test_fdset_new_fill(void) {
+TEST(fdset_new_fill) {
int fd = -1;
_cleanup_fdset_free_ FDSet *fdset = NULL;
char name[] = "/tmp/test-fdset_new_fill.XXXXXX";
unlink(name);
}
-static void test_fdset_put_dup(void) {
+TEST(fdset_put_dup) {
_cleanup_close_ int fd = -1;
int copyfd = -1;
_cleanup_fdset_free_ FDSet *fdset = NULL;
unlink(name);
}
-static void test_fdset_cloexec(void) {
+TEST(fdset_cloexec) {
int fd = -1;
_cleanup_fdset_free_ FDSet *fdset = NULL;
int flags = -1;
unlink(name);
}
-static void test_fdset_close_others(void) {
+TEST(fdset_close_others) {
int fd = -1;
int copyfd = -1;
_cleanup_fdset_free_ FDSet *fdset = NULL;
unlink(name);
}
-static void test_fdset_remove(void) {
+TEST(fdset_remove) {
_cleanup_close_ int fd = -1;
FDSet *fdset = NULL;
char name[] = "/tmp/test-fdset_remove.XXXXXX";
unlink(name);
}
-static void test_fdset_iterate(void) {
+TEST(fdset_iterate) {
int fd = -1;
FDSet *fdset = NULL;
char name[] = "/tmp/test-fdset_iterate.XXXXXX";
unlink(name);
}
-static void test_fdset_isempty(void) {
+TEST(fdset_isempty) {
int fd;
_cleanup_fdset_free_ FDSet *fdset = NULL;
char name[] = "/tmp/test-fdset_isempty.XXXXXX";
unlink(name);
}
-static void test_fdset_steal_first(void) {
+TEST(fdset_steal_first) {
int fd;
_cleanup_fdset_free_ FDSet *fdset = NULL;
char name[] = "/tmp/test-fdset_steal_first.XXXXXX";
unlink(name);
}
-static void test_fdset_new_array(void) {
+TEST(fdset_new_array) {
int fds[] = {10, 11, 12, 13};
_cleanup_fdset_free_ FDSet *fdset = NULL;
assert_se(fdset_contains(fdset, 13));
}
-int main(int argc, char *argv[]) {
- test_fdset_new_fill();
- test_fdset_put_dup();
- test_fdset_cloexec();
- test_fdset_close_others();
- test_fdset_remove();
- test_fdset_iterate();
- test_fdset_isempty();
- test_fdset_steal_first();
- test_fdset_new_array();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "tmpfile-util.h"
#include "util.h"
-static void test_parse_env_file(void) {
+TEST(parse_env_file) {
_cleanup_(unlink_tempfilep) char
t[] = "/tmp/test-fileio-in-XXXXXX",
p[] = "/tmp/test-fileio-out-XXXXXX";
assert_se(streq(from_shell, value));
}
-static void test_parse_multiline_env_file(void) {
+TEST(parse_multiline_env_file) {
_cleanup_(unlink_tempfilep) char
t[] = "/tmp/test-fileio-in-XXXXXX",
p[] = "/tmp/test-fileio-out-XXXXXX";
assert_se(r >= 0);
}
-static void test_merge_env_file(void) {
+TEST(merge_env_file) {
_cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
_cleanup_strv_free_ char **a = NULL;
assert_se(a[10] == NULL);
}
-static void test_merge_env_file_invalid(void) {
+TEST(merge_env_file_invalid) {
_cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
_cleanup_strv_free_ char **a = NULL;
assert_se(strv_isempty(a));
}
-static void test_executable_is_script(void) {
+TEST(executable_is_script) {
_cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
char *command;
int r;
- log_info("/* %s */", __func__);
-
assert_se(fmkostemp_safe(t, "w", &f) == 0);
fputs("#! /bin/script -a -b \ngoo goo", f);
fflush(f);
}
}
-static void test_status_field(void) {
+TEST(status_field) {
_cleanup_free_ char *t = NULL, *p = NULL, *s = NULL, *z = NULL;
unsigned long long total = 0, buffers = 0;
int r;
- log_info("/* %s */", __func__);
-
assert_se(get_proc_field("/proc/self/status", "Threads", WHITESPACE, &t) == 0);
puts(t);
assert_se(streq(t, "1"));
}
}
-static void test_capeff(void) {
- log_info("/* %s */", __func__);
-
+TEST(capeff) {
for (int pid = 0; pid < 2; pid++) {
_cleanup_free_ char *capeff = NULL;
int r, p;
}
}
-static void test_write_string_stream(void) {
+TEST(write_string_stream) {
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_stream-XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
int fd;
char buf[64];
- log_info("/* %s */", __func__);
-
fd = mkostemp_safe(fn);
assert_se(fd >= 0);
assert_se(streq(buf, "boohoo"));
}
-static void test_write_string_file(void) {
+TEST(write_string_file) {
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file-XXXXXX";
char buf[64] = {};
_cleanup_close_ int fd;
- log_info("/* %s */", __func__);
-
fd = mkostemp_safe(fn);
assert_se(fd >= 0);
assert_se(streq(buf, "boohoo\n"));
}
-static void test_write_string_file_no_create(void) {
+TEST(write_string_file_no_create) {
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file_no_create-XXXXXX";
_cleanup_close_ int fd;
char buf[64] = {};
- log_info("/* %s */", __func__);
-
fd = mkostemp_safe(fn);
assert_se(fd >= 0);
assert_se(streq(buf, "boohoo\n"));
}
-static void test_write_string_file_verify(void) {
+TEST(write_string_file_verify) {
_cleanup_free_ char *buf = NULL, *buf2 = NULL;
int r;
- log_info("/* %s */", __func__);
-
r = read_one_line_file("/proc/version", &buf);
if (ERRNO_IS_PRIVILEGE(r))
return;
assert_se(write_string_file("/proc/version", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
}
-static void test_load_env_file_pairs(void) {
+TEST(load_env_file_pairs) {
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-load_env_file_pairs-XXXXXX";
int fd, r;
_cleanup_fclose_ FILE *f = NULL;
_cleanup_strv_free_ char **l = NULL;
char **k, **v;
- log_info("/* %s */", __func__);
-
fd = mkostemp_safe(fn);
assert_se(fd >= 0);
}
}
-static void test_search_and_fopen(void) {
+TEST(search_and_fopen) {
static const char* const dirs[] = {
"/tmp/foo/bar",
"/tmp",
const char *e;
int r;
- log_info("/* %s */", __func__);
-
fd = mkostemp_safe(name);
assert_se(fd >= 0);
fd = safe_close(fd);
assert_se(r == -ENOENT);
}
-static void test_search_and_fopen_nulstr(void) {
+TEST(search_and_fopen_nulstr) {
static const char dirs[] =
"/tmp/foo/bar\0"
"/tmp\0";
- log_info("/* %s */", __func__);
-
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-search_and_fopen.XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *p = NULL;
assert_se(r == -ENOENT);
}
-static void test_writing_tmpfile(void) {
+TEST(writing_tmpfile) {
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
_cleanup_free_ char *contents = NULL;
size_t size;
_cleanup_close_ int fd = -1;
int r;
- log_info("/* %s */", __func__);
-
struct iovec iov[] = {
IOVEC_MAKE_STRING("abc\n"),
IOVEC_MAKE_STRING(ALPHANUMERICAL "\n"),
assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
}
-static void test_tempfn(void) {
+TEST(tempfn) {
char *ret = NULL, *p;
- log_info("/* %s */", __func__);
-
assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
free(ret);
DISABLE_WARNING_TYPE_LIMITS;
-static void test_fgetc(void) {
+TEST(fgetc) {
_cleanup_fclose_ FILE *f = NULL;
char c;
assert_se(read_line(f, 1024, &line) == 0 && streq(line, ""));
}
-static void test_read_line(void) {
+TEST(read_line1) {
_cleanup_fclose_ FILE *f = NULL;
- log_info("/* %s */", __func__);
-
assert_se(f = fmemopen_unlocked((void*) buffer, sizeof(buffer), "re"));
test_read_line_one_file(f);
}
-static void test_read_line2(void) {
+TEST(read_line2) {
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-fileio.XXXXXX";
int fd;
_cleanup_fclose_ FILE *f = NULL;
- log_info("/* %s */", __func__);
-
fd = mkostemp_safe(name);
assert_se(fd >= 0);
assert_se((size_t) write(fd, buffer, sizeof(buffer)) == sizeof(buffer));
test_read_line_one_file(f);
}
-static void test_read_line3(void) {
+TEST(read_line3) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *line = NULL;
int r;
- log_info("/* %s */", __func__);
-
f = fopen("/proc/uptime", "re");
if (!f && IN_SET(errno, ENOENT, EPERM))
return;
assert_se(read_line(f, LINE_MAX, NULL) == 0);
}
-static void test_read_line4(void) {
+TEST(read_line4) {
static const struct {
size_t length;
const char *string;
}
}
-static void test_read_nul_string(void) {
+TEST(read_nul_string) {
static const char test[] = "string nr. 1\0"
"string nr. 2\n\0"
"\377empty string follows\0"
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *s = NULL;
- log_info("/* %s */", __func__);
-
assert_se(f = fmemopen_unlocked((void*) test, sizeof(test)-1, "r"));
assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 13 && streq_ptr(s, "string nr. 1"));
assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 0 && streq_ptr(s, ""));
}
-static void test_read_full_file_socket(void) {
+TEST(read_full_file_socket) {
_cleanup_(rm_rf_physical_and_freep) char *z = NULL;
_cleanup_close_ int listener = -1;
_cleanup_free_ char *data = NULL, *clientname = NULL;
pid_t pid;
int r;
- log_info("/* %s */", __func__);
-
listener = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
assert_se(listener >= 0);
#undef TEST_STR
}
-static void test_read_full_file_offset_size(void) {
+TEST(read_full_file_offset_size) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_(unlink_and_freep) char *fn = NULL;
_cleanup_free_ char *rbuf = NULL;
size_t rbuf_size;
uint8_t buf[4711];
- log_info("/* %s */", __func__);
-
random_bytes(buf, sizeof(buf));
assert_se(tempfn_random_child(NULL, NULL, &fn) >= 0);
rbuf = mfree(rbuf);
}
-static void test_read_virtual_file(size_t max_size) {
+static void test_read_virtual_file_one(size_t max_size) {
const char *filename;
int r;
}
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_parse_env_file();
- test_parse_multiline_env_file();
- test_merge_env_file();
- test_merge_env_file_invalid();
- test_executable_is_script();
- test_status_field();
- test_capeff();
- test_write_string_stream();
- test_write_string_file();
- test_write_string_file_no_create();
- test_write_string_file_verify();
- test_load_env_file_pairs();
- test_search_and_fopen();
- test_search_and_fopen_nulstr();
- test_writing_tmpfile();
- test_tempfn();
- test_fgetc();
- test_read_line();
- test_read_line2();
- test_read_line3();
- test_read_line4();
- test_read_nul_string();
- test_read_full_file_socket();
- test_read_full_file_offset_size();
- test_read_virtual_file(0);
- test_read_virtual_file(1);
- test_read_virtual_file(2);
- test_read_virtual_file(20);
- test_read_virtual_file(4096);
- test_read_virtual_file(4097);
- test_read_virtual_file(SIZE_MAX);
-
- return 0;
+TEST(test_read_virtual_file) {
+ test_read_virtual_file_one(0);
+ test_read_virtual_file_one(1);
+ test_read_virtual_file_one(2);
+ test_read_virtual_file_one(20);
+ test_read_virtual_file_one(4096);
+ test_read_virtual_file_one(4097);
+ test_read_virtual_file_one(SIZE_MAX);
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "format-util.h"
#include "macro.h"
#include "string-util.h"
+#include "tests.h"
/* Do some basic checks on STRLEN() and DECIMAL_STR_MAX() */
assert_cc(STRLEN("xxx") == 3);
assert_se(streq_ptr(format_bytes_full(buf, sizeof buf, val, trailing_B ? FORMAT_BYTES_TRAILING_B : 0), si_without_p));
}
-static void test_format_bytes(void) {
+TEST(format_bytes) {
test_format_bytes_one(900, true, "900B", "900B", "900B", "900B");
test_format_bytes_one(900, false, "900", "900", "900", "900");
test_format_bytes_one(1023, true, "1023B", "1023B", "1.0K", "1K");
test_format_bytes_one(UINT64_MAX, false, NULL, NULL, NULL, NULL);
}
-int main(void) {
- test_format_bytes();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
static const char *arg_test_dir = NULL;
-static void test_chase_symlinks(void) {
+TEST(chase_symlinks) {
_cleanup_free_ char *result = NULL;
char *temp;
const char *top, *p, *pslash, *q, *qslash;
struct stat st;
int r, pfd;
- log_info("/* %s */", __func__);
-
temp = strjoina(arg_test_dir ?: "/tmp", "/test-chase.XXXXXX");
assert_se(mkdtemp(temp));
assert_se(rm_rf(temp, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
}
-static void test_unlink_noerrno(void) {
+TEST(unlink_noerrno) {
char *name;
int fd;
- log_info("/* %s */", __func__);
-
name = strjoina(arg_test_dir ?: "/tmp", "/test-close_nointr.XXXXXX");
fd = mkostemp_safe(name);
assert_se(fd >= 0);
}
}
-static void test_readlink_and_make_absolute(void) {
+TEST(readlink_and_make_absolute) {
const char *tempdir, *name, *name2, *name_alias;
_cleanup_free_ char *r1 = NULL, *r2 = NULL, *pwd = NULL;
- log_info("/* %s */", __func__);
-
tempdir = strjoina(arg_test_dir ?: "/tmp", "/test-readlink_and_make_absolute");
name = strjoina(tempdir, "/original");
name2 = "test-readlink_and_make_absolute/original";
assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
}
-static void test_get_files_in_directory(void) {
+TEST(get_files_in_directory) {
_cleanup_strv_free_ char **l = NULL, **t = NULL;
assert_se(get_files_in_directory(arg_test_dir ?: "/tmp", &l) >= 0);
assert_se(get_files_in_directory(".", NULL) >= 0);
}
-static void test_var_tmp(void) {
+TEST(var_tmp) {
_cleanup_free_ char *tmpdir_backup = NULL, *temp_backup = NULL, *tmp_backup = NULL;
const char *tmp_dir = NULL, *t;
- log_info("/* %s */", __func__);
-
t = getenv("TMPDIR");
if (t) {
tmpdir_backup = strdup(t);
}
}
-static void test_dot_or_dot_dot(void) {
- log_info("/* %s */", __func__);
-
+TEST(dot_or_dot_dot) {
assert_se(!dot_or_dot_dot(NULL));
assert_se(!dot_or_dot_dot(""));
assert_se(!dot_or_dot_dot("xxx"));
assert_se(!dot_or_dot_dot("..foo"));
}
-static void test_access_fd(void) {
+TEST(access_fd) {
_cleanup_(rmdir_and_freep) char *p = NULL;
_cleanup_close_ int fd = -1;
const char *a;
- log_info("/* %s */", __func__);
-
a = strjoina(arg_test_dir ?: "/tmp", "/access-fd.XXXXXX");
assert_se(mkdtemp_malloc(a, &p) >= 0);
}
}
-static void test_touch_file(void) {
+TEST(touch_file) {
uid_t test_uid, test_gid;
_cleanup_(rm_rf_physical_and_freep) char *p = NULL;
struct stat st;
usec_t test_mtime;
int r;
- log_info("/* %s */", __func__);
-
test_uid = geteuid() == 0 ? 65534 : getuid();
test_gid = geteuid() == 0 ? 65534 : getgid();
assert_se(timespec_load(&st.st_mtim) == test_mtime);
}
-static void test_unlinkat_deallocate(void) {
+TEST(unlinkat_deallocate) {
_cleanup_free_ char *p = NULL;
_cleanup_close_ int fd = -1;
struct stat st;
- log_info("/* %s */", __func__);
-
assert_se(tempfn_random_child(arg_test_dir, "unlink-deallocation", &p) >= 0);
fd = open(p, O_WRONLY|O_CLOEXEC|O_CREAT|O_EXCL, 0600);
assert_se(st.st_nlink == 0);
}
-static void test_fsync_directory_of_file(void) {
+TEST(fsync_directory_of_file) {
_cleanup_close_ int fd = -1;
- log_info("/* %s */", __func__);
-
fd = open_tmpfile_unlinkable(arg_test_dir, O_RDWR);
assert_se(fd >= 0);
assert_se(fsync_directory_of_file(fd) >= 0);
}
-static void test_rename_noreplace(void) {
+TEST(rename_noreplace) {
static const char* const table[] = {
"/reg",
"/dir",
const char *j = NULL;
char **a, **b;
- log_info("/* %s */", __func__);
-
if (arg_test_dir)
j = strjoina(arg_test_dir, "/testXXXXXX");
assert_se(mkdtemp_malloc(j, &z) >= 0);
}
}
-static void test_chmod_and_chown(void) {
+TEST(chmod_and_chown) {
_cleanup_(rm_rf_physical_and_freep) char *d = NULL;
struct stat st;
const char *p;
if (geteuid() != 0)
return;
- log_info("/* %s */", __func__);
-
BLOCK_WITH_UMASK(0000);
assert_se(mkdtemp_malloc(NULL, &d) >= 0);
assert_se(write(fd, data, l) == (ssize_t) l);
}
-static void test_conservative_rename(void) {
+TEST(conservative_rename) {
_cleanup_(unlink_and_freep) char *p = NULL;
_cleanup_free_ char *q = NULL;
size_t l = 16*1024 + random_u64() % (32 * 1024); /* some randomly sized buffer 16k…48k */
}
}
-static void test_rmdir_parents(void) {
+TEST(rmdir_parents) {
char *temp;
- log_info("/* %s */", __func__);
-
temp = strjoina(arg_test_dir ?: "/tmp", "/test-rmdir.XXXXXX");
assert_se(mkdtemp(temp));
assert_se(streq_ptr(c, d));
}
-static void test_parse_cifs_service(void) {
- log_info("/* %s */", __func__);
-
+TEST(parse_cifs_service) {
test_parse_cifs_service_one("//foo/bar/baz", "foo", "bar", "baz", 0);
test_parse_cifs_service_one("\\\\foo\\bar\\baz", "foo", "bar", "baz", 0);
test_parse_cifs_service_one("//foo/bar", "foo", "bar", NULL, 0);
test_parse_cifs_service_one("//./a", NULL, NULL, NULL, -EINVAL);
}
-static void test_open_mkdir_at(void) {
+TEST(open_mkdir_at) {
_cleanup_close_ int fd = -1, subdir_fd = -1, subsubdir_fd = -1;
_cleanup_(rm_rf_physical_and_freep) char *t = NULL;
- log_info("/* %s */", __func__);
assert_se(open_mkdir_at(AT_FDCWD, "/proc", O_EXCL|O_CLOEXEC, 0) == -EEXIST);
assert_se(subsubdir_fd >= 0);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- arg_test_dir = argv[1];
-
- test_chase_symlinks();
- test_unlink_noerrno();
- test_readlink_and_make_absolute();
- test_get_files_in_directory();
- test_var_tmp();
- test_dot_or_dot_dot();
- test_access_fd();
- test_touch_file();
- test_unlinkat_deallocate();
- test_fsync_directory_of_file();
- test_rename_noreplace();
- test_chmod_and_chown();
- test_conservative_rename();
- test_rmdir_parents();
- test_parse_cifs_service();
- test_open_mkdir_at();
-
- return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(LOG_INFO, arg_test_dir = argv[1], /* no outro */);
#include "log.h"
#include "string-util.h"
#include "strv.h"
+#include "tests.h"
/*
int fstab_filter_options(
assert_se(streq_ptr(name, name_expected));
}
-static void test_fstab_filter_options(void) {
+TEST(fstab_filter_options) {
do_fstab_filter_options("opt=0", "opt\0x-opt\0", 1, 1, "opt", "0", "0", "");
do_fstab_filter_options("opt=0", "x-opt\0opt\0", 1, 1, "opt", "0", "0", "");
do_fstab_filter_options("opt", "opt\0x-opt\0", 1, 0, "opt", NULL, "", "");
do_fstab_filter_options("opt1=\\\\,opt2=\\xff", "opt2\0", 1, 1, "opt2", "\\xff", "\\xff", "opt1=\\");
}
-static void test_fstab_find_pri(void) {
+TEST(fstab_find_pri) {
int pri = -1;
assert_se(fstab_find_pri("pri", &pri) == 0);
assert_se(pri == 13);
}
-static void test_fstab_yes_no_option(void) {
+TEST(fstab_yes_no_option) {
assert_se(fstab_test_yes_no_option("nofail,fail,nofail", "nofail\0fail\0") == true);
assert_se(fstab_test_yes_no_option("nofail,nofail,fail", "nofail\0fail\0") == false);
assert_se(fstab_test_yes_no_option("abc,cde,afail", "nofail\0fail\0") == false);
assert_se(fstab_test_yes_no_option("nofail,nofail=0,fail=0", "nofail\0fail\0") == false);
}
-static void test_fstab_node_to_udev_node(void) {
+TEST(fstab_node_to_udev_node) {
char *n;
n = fstab_node_to_udev_node("LABEL=applé/jack");
free(n);
}
-int main(void) {
- test_fstab_filter_options();
- test_fstab_find_pri();
- test_fstab_yes_no_option();
- test_fstab_node_to_udev_node();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "gcrypt-util.h"
#include "macro.h"
#include "string-util.h"
+#include "tests.h"
-static void test_string_hashsum(void) {
+TEST(string_hashsum) {
_cleanup_free_ char *out1 = NULL, *out2 = NULL, *out3 = NULL, *out4 = NULL;
assert_se(string_hashsum("asdf", 4, GCRY_MD_SHA224, &out1) == 0);
assert_se(streq(out4, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"));
}
-int main(int argc, char **argv) {
- test_string_hashsum();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "glob-util.h"
#include "macro.h"
#include "rm-rf.h"
+#include "tests.h"
#include "tmpfile-util.h"
-static void test_glob_exists(void) {
- log_info("/* %s */", __func__);
-
+TEST(glob_exists) {
char name[] = "/tmp/test-glob_exists.XXXXXX";
int fd = -1;
int r;
(void) closedir(v);
}
-static void test_glob_no_dot(void) {
+TEST(glob_no_dot) {
char template[] = "/tmp/test-glob-util.XXXXXXX";
const char *fn;
int r;
- log_info("/* %s */", __func__);
-
assert_se(mkdtemp(template));
fn = strjoina(template, "/*");
(void) rm_rf(template, REMOVE_ROOT|REMOVE_PHYSICAL);
}
-static void test_safe_glob(void) {
+TEST(safe_glob) {
char template[] = "/tmp/test-glob-util.XXXXXXX";
const char *fn, *fn2, *fname;
_cleanup_globfree_ glob_t g = {};
int r;
- log_info("/* %s */", __func__);
-
assert_se(mkdtemp(template));
fn = strjoina(template, "/*");
assert_se(streq(t, expected));
}
-static void test_glob_non_glob(void) {
- log_info("/* %s */", __func__);
-
+TEST(glob_non_glob) {
test_glob_non_glob_prefix_one("/tmp/.X11-*", "/tmp/");
test_glob_non_glob_prefix_one("/tmp/*", "/tmp/");
test_glob_non_glob_prefix_one("/tmp*", "/");
assert_se(glob_non_glob_prefix("?", &x) == -ENOENT);
}
-int main(void) {
- test_glob_exists();
- test_glob_no_dot();
- test_safe_glob();
- test_glob_non_glob();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "tests.h"
#include "util.h"
-static void test_gpt_types_against_architectures(void) {
+TEST(gpt_types_against_architectures) {
const char *prefix;
int r;
- log_info("/* %s */", __func__);
-
/* Dumps a table indicating for which architectures we know we have matching GPT partition
* types. Also validates whether we can properly categorize the entries. */
}
}
-int main(int argc, char *argv[]) {
-
- test_setup_logging(LOG_INFO);
-
- test_gpt_types_against_architectures();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "hash-funcs.h"
#include "set.h"
-static void test_path_hash_set(void) {
+TEST(path_hash_set) {
/* The goal is to make sure that non-simplified path are hashed as expected,
* and that we don't need to simplify them beforehand. */
- log_info("/* %s */", __func__);
-
/* No freeing of keys, we operate on static strings here… */
_cleanup_set_free_ Set *set = NULL;
assert_se(!set_contains(set, "/////../bar/./"));
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_INFO);
-
- test_path_hash_set();
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "macro.h"
#include "random-util.h"
#include "string-util.h"
+#include "tests.h"
-static void test_hexchar(void) {
+TEST(hexchar) {
assert_se(hexchar(0xa) == 'a');
assert_se(hexchar(0x0) == '0');
}
-static void test_unhexchar(void) {
+TEST(unhexchar) {
assert_se(unhexchar('a') == 0xA);
assert_se(unhexchar('A') == 0xA);
assert_se(unhexchar('0') == 0x0);
}
-static void test_base32hexchar(void) {
+TEST(base32hexchar) {
assert_se(base32hexchar(0) == '0');
assert_se(base32hexchar(9) == '9');
assert_se(base32hexchar(10) == 'A');
assert_se(base32hexchar(31) == 'V');
}
-static void test_unbase32hexchar(void) {
+TEST(unbase32hexchar) {
assert_se(unbase32hexchar('0') == 0);
assert_se(unbase32hexchar('9') == 9);
assert_se(unbase32hexchar('A') == 10);
assert_se(unbase32hexchar('=') == -EINVAL);
}
-static void test_base64char(void) {
+TEST(base64char) {
assert_se(base64char(0) == 'A');
assert_se(base64char(26) == 'a');
assert_se(base64char(63) == '/');
}
-static void test_unbase64char(void) {
+TEST(unbase64char) {
assert_se(unbase64char('A') == 0);
assert_se(unbase64char('Z') == 25);
assert_se(unbase64char('a') == 26);
assert_se(unbase64char('=') == -EINVAL);
}
-static void test_octchar(void) {
+TEST(octchar) {
assert_se(octchar(00) == '0');
assert_se(octchar(07) == '7');
}
-static void test_unoctchar(void) {
+TEST(unoctchar) {
assert_se(unoctchar('0') == 00);
assert_se(unoctchar('7') == 07);
}
-static void test_decchar(void) {
+TEST(decchar) {
assert_se(decchar(0) == '0');
assert_se(decchar(9) == '9');
}
-static void test_undecchar(void) {
+TEST(undecchar) {
assert_se(undecchar('0') == 0);
assert_se(undecchar('9') == 9);
}
}
}
-static void test_unhexmem(void) {
+TEST(unhexmem) {
const char *hex = "efa2149213";
const char *hex_space = " e f a\n 2\r 14\n\r\t9\t2 \n1\r3 \r\r\t";
const char *hex_invalid = "efa214921o";
}
/* https://tools.ietf.org/html/rfc4648#section-10 */
-static void test_base32hexmem(void) {
+TEST(base32hexmem) {
char *b32;
b32 = base32hexmem("", STRLEN(""), true);
}
}
-static void test_unbase32hexmem(void) {
+TEST(unbase32hexmem) {
test_unbase32hexmem_one("", true, 0, "");
test_unbase32hexmem_one("CO======", true, 0, "f");
}
/* https://tools.ietf.org/html/rfc4648#section-10 */
-static void test_base64mem(void) {
+TEST(base64mem) {
char *b64;
assert_se(base64mem("", STRLEN(""), &b64) == 0);
free(b64);
}
-static void test_base64mem_linebreak(void) {
+TEST(base64mem_linebreak) {
uint8_t data[4096];
for (size_t i = 0; i < 20; i++) {
}
}
-static void test_unbase64mem(void) {
+TEST(unbase64mem) {
test_unbase64mem_one("", "", 0);
test_unbase64mem_one("Zg==", "f", 0);
test_unbase64mem_one(" Z m 8 = q u u x ", NULL, -ENAMETOOLONG);
}
-static void test_hexdump(void) {
+TEST(hexdump) {
uint8_t data[146];
unsigned i;
hexdump(stdout, data, sizeof(data));
}
-int main(int argc, char *argv[]) {
- test_hexchar();
- test_unhexchar();
- test_base32hexchar();
- test_unbase32hexchar();
- test_base64char();
- test_unbase64char();
- test_octchar();
- test_unoctchar();
- test_decchar();
- test_undecchar();
- test_unhexmem();
- test_base32hexmem();
- test_unbase32hexmem();
- test_base64mem();
- test_base64mem_linebreak();
- test_unbase64mem();
- test_hexdump();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
hmac_sha256(key, strlen(key), value, strlen(value), res);
}
-static void test_hmac(void) {
+TEST(hmac) {
uint8_t result[SHA256_DIGEST_SIZE];
char *hex_result = NULL;
- log_info("/* %s */", __func__);
-
/* Results compared with output of 'echo -n "<input>" | openssl dgst -sha256 -hmac "<key>"' */
hmac_sha256_by_string("waldo",
hex_result = mfree(hex_result);
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_INFO);
-
- test_hmac();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "tests.h"
#include "tmpfile-util.h"
-static void test_read_etc_hostname(void) {
+TEST(read_etc_hostname) {
char path[] = "/tmp/hostname.XXXXXX";
char *hostname;
int fd;
unlink(path);
}
-static void test_hostname_setup(void) {
+TEST(hostname_setup) {
hostname_setup(false);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_read_etc_hostname();
- test_hostname_setup();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "tests.h"
#include "tmpfile-util.h"
-static void test_hostname_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(hostname_is_valid) {
assert_se(hostname_is_valid("foobar", 0));
assert_se(hostname_is_valid("foobar.com", 0));
assert_se(!hostname_is_valid("foobar.com.", 0));
assert_se(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", VALID_HOSTNAME_TRAILING_DOT));
}
-static void test_hostname_cleanup(void) {
+TEST(hostname_cleanup) {
char *s;
- log_info("/* %s */", __func__);
-
s = strdupa_safe("foobar");
assert_se(streq(hostname_cleanup(s), "foobar"));
s = strdupa_safe("foobar.com");
assert_se(streq(hostname_cleanup(s), "xxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
}
-static void test_hostname_malloc(void) {
+TEST(hostname_malloc) {
_cleanup_free_ char *h = NULL, *l = NULL;
- log_info("/* %s */", __func__);
-
assert_se(h = gethostname_malloc());
log_info("hostname_malloc: \"%s\"", h);
log_info("hostname_short_malloc: \"%s\"", l);
}
-static void test_default_hostname(void) {
- log_info("/* %s */", __func__);
-
+TEST(default_hostname) {
if (!hostname_is_valid(FALLBACK_HOSTNAME, 0)) {
log_error("Configured fallback hostname \"%s\" is not valid.", FALLBACK_HOSTNAME);
exit(EXIT_FAILURE);
assert_se(hostname_is_valid(n, 0));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_hostname_is_valid();
- test_hostname_cleanup();
- test_hostname_malloc();
- test_default_hostname();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#define STR_WALDI "0102030405060708090a0b0c0d0e0f10"
#define UUID_WALDI "01020304-0506-0708-090a-0b0c0d0e0f10"
-static void test_id128(void) {
+TEST(id128) {
sd_id128_t id, id2;
char t[SD_ID128_STRING_MAX], q[ID128_UUID_STRING_MAX];
_cleanup_free_ char *b = NULL;
_cleanup_close_ int fd = -1;
- log_info("/* %s */", __func__);
-
assert_se(sd_id128_randomize(&id) == 0);
printf("random: %s\n", sd_id128_to_string(id, t));
assert_se(!sd_id128_equal(id, id2));
}
-static void test_sd_id128_get_invocation(void) {
+TEST(sd_id128_get_invocation) {
sd_id128_t id;
int r;
- log_info("/* %s */", __func__);
-
/* Query the invocation ID */
r = sd_id128_get_invocation(&id);
if (r < 0)
log_info("Invocation ID: " SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(id));
}
-static void benchmark_sd_id128_get_machine_app_specific(void) {
+TEST(benchmark_sd_id128_get_machine_app_specific) {
unsigned iterations = slow_tests_enabled() ? 1000000 : 1000;
usec_t t, q;
log_info("%lf µs each\n", (double) q / iterations);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- test_id128();
- test_sd_id128_get_invocation();
- benchmark_sd_id128_get_machine_app_specific();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
assert_se(streq_ptr(output, s));
}
-static void test_import_url_last_component(void) {
+TEST(import_url_last_component) {
test_import_url_last_component_one("https://foobar/waldo/quux", "quux", 0);
test_import_url_last_component_one("https://foobar/waldo/quux/", "quux", 0);
test_import_url_last_component_one("https://foobar/waldo/", "waldo", 0);
assert_se(streq_ptr(output, s));
}
-static void test_import_url_change_suffix(void) {
+TEST(import_url_change_suffix) {
test_import_url_change_suffix_one("https://foobar/waldo/quux", 1, "wuff", "https://foobar/waldo/wuff", 0);
test_import_url_change_suffix_one("https://foobar/waldo/quux/", 1, "wuff", "https://foobar/waldo/wuff", 0);
test_import_url_change_suffix_one("https://foobar/waldo/quux///?mief", 1, "wuff", "https://foobar/waldo/wuff", 0);
test_import_url_change_suffix_one("x:y/z/", 2, "wuff", "x:y/wuff", 0);
}
-int main(int argc, char *argv[]) {
-
- test_setup_logging(LOG_INFO);
-
- test_import_url_last_component();
- test_import_url_change_suffix();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
assert_se(in_addr_prefixes_is_any(prefixes));
}
-int main(int argc, char *argv[]) {
+TEST(in_addr_prefixes) {
_cleanup_set_free_ Set *prefixes = NULL;
- test_setup_logging(LOG_DEBUG);
-
test_config_parse_in_addr_prefixes(&prefixes);
test_in_addr_prefixes_reduce(prefixes);
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
}
}
-static void test_in_addr_prefix_from_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_prefix_from_string) {
test_in_addr_prefix_from_string_one("", AF_INET, -EINVAL, NULL, 0, -EINVAL, 0, -EINVAL, 0);
test_in_addr_prefix_from_string_one("/", AF_INET, -EINVAL, NULL, 0, -EINVAL, 0, -EINVAL, 0);
test_in_addr_prefix_from_string_one("/8", AF_INET, -EINVAL, NULL, 0, -EINVAL, 0, -EINVAL, 0);
assert_se(in_addr_equal(family, &u1, &u2) > 0);
}
-static void test_in_addr_prefix_to_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_prefix_to_string) {
test_in_addr_prefix_to_string_valid(AF_INET, "0.0.0.0/32");
test_in_addr_prefix_to_string_valid(AF_INET, "1.2.3.4/0");
test_in_addr_prefix_to_string_valid(AF_INET, "1.2.3.4/24");
test_in_addr_prefix_to_string_unoptimized(AF_INET6, "fd00:1111::0000:2222:3333:4444:0001/64");
}
-static void test_in_addr_random_prefix(void) {
+TEST(in_addr_random_prefix) {
_cleanup_free_ char *str = NULL;
union in_addr_union a;
- log_info("/* %s */", __func__);
-
assert_se(in_addr_from_string(AF_INET, "192.168.10.1", &a) >= 0);
assert_se(in_addr_random_prefix(AF_INET, &a, 31, 32) >= 0);
str = mfree(str);
}
-static void test_in_addr_is_null(void) {
+TEST(in_addr_is_null) {
union in_addr_union i = {};
- log_info("/* %s */", __func__);
-
assert_se(in_addr_is_null(AF_INET, &i) == true);
assert_se(in_addr_is_null(AF_INET6, &i) == true);
assert_se(in_addr_prefix_intersect(f, &ua, apl, &ub, bpl) == result);
}
-static void test_in_addr_prefix_intersect(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_prefix_intersect) {
test_in_addr_prefix_intersect_one(AF_INET, "255.255.255.255", 32, "255.255.255.254", 32, 0);
test_in_addr_prefix_intersect_one(AF_INET, "255.255.255.255", 0, "255.255.255.255", 32, 1);
test_in_addr_prefix_intersect_one(AF_INET, "0.0.0.0", 0, "47.11.8.15", 32, 1);
}
}
-static void test_in_addr_prefix_next(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_prefix_next) {
test_in_addr_prefix_next_one(AF_INET, "192.168.0.0", 24, "192.168.1.0");
test_in_addr_prefix_next_one(AF_INET, "192.168.0.0", 16, "192.169.0.0");
test_in_addr_prefix_next_one(AF_INET, "192.168.0.0", 20, "192.168.16.0");
}
}
-static void test_in_addr_prefix_nth(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_prefix_nth) {
test_in_addr_prefix_nth_one(AF_INET, "192.168.0.0", 24, 0, "192.168.0.0");
test_in_addr_prefix_nth_one(AF_INET, "192.168.0.123", 24, 0, "192.168.0.0");
test_in_addr_prefix_nth_one(AF_INET, "192.168.0.123", 24, 1, "192.168.1.0");
}
}
-static void test_in_addr_prefix_range(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_prefix_range) {
test_in_addr_prefix_range_one(AF_INET, "192.168.123.123", 24, "192.168.123.0", "192.168.124.0");
test_in_addr_prefix_range_one(AF_INET, "192.168.123.123", 16, "192.168.0.0", "192.169.0.0");
assert_se(streq(addr, r));
}
-static void test_in_addr_to_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_to_string) {
test_in_addr_to_string_one(AF_INET, "192.168.0.1");
test_in_addr_to_string_one(AF_INET, "10.11.12.13");
test_in_addr_to_string_one(AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
test_in_addr_to_string_one(AF_INET6, "fe80::");
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_in_addr_prefix_from_string();
- test_in_addr_random_prefix();
- test_in_addr_prefix_to_string();
- test_in_addr_is_null();
- test_in_addr_prefix_intersect();
- test_in_addr_prefix_next();
- test_in_addr_prefix_nth();
- test_in_addr_prefix_range();
- test_in_addr_to_string();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "tmpfile-util.h"
#include "umask-util.h"
-static void test_install_file(void) {
+TEST(install_file) {
_cleanup_(rm_rf_physical_and_freep) char *p = NULL;
_cleanup_free_ char *a = NULL, *b = NULL, *c = NULL;
struct stat stat1, stat2;
- log_info("/* %s */", __func__);
-
assert_se(mkdtemp_malloc(NULL, &p) >= 0);
assert_se(a = path_join(p, "foo"));
assert_se(b = path_join(p, "bar"));
assert_se(install_file(AT_FDCWD, b, AT_FDCWD, a, INSTALL_FSYNC_FULL|INSTALL_REPLACE) == 0);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- test_install_file();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "fd-util.h"
#include "io-util.h"
#include "macro.h"
+#include "tests.h"
static void test_sparse_write_one(int fd, const char *buffer, size_t n) {
char check[n];
assert_se(memcmp(buffer, check, n) == 0);
}
-static void test_sparse_write(void) {
+TEST(sparse_write) {
const char test_a[] = "test";
const char test_b[] = "\0\0\0\0test\0\0\0\0";
const char test_c[] = "\0\0test\0\0\0\0";
test_sparse_write_one(fd, test_e, sizeof(test_e));
}
-int main(void) {
- test_sparse_write();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "ip-protocol-list.h"
#include "stdio-util.h"
#include "string-util.h"
+#include "tests.h"
static void test_int(int i) {
char str[DECIMAL_STR_MAX(int)];
assert_se(parse_ip_protocol(s) == -EINVAL);
}
-static void test_parse_ip_protocol(const char *s, int expected) {
+static void test_parse_ip_protocol_one(const char *s, int expected) {
assert_se(parse_ip_protocol(s) == expected);
}
-int main(int argc, const char *argv[]) {
+TEST(integer) {
test_int(IPPROTO_TCP);
test_int(IPPROTO_DCCP);
test_int_fail(-1);
test_int_fail(1024 * 1024);
+}
+TEST(string) {
test_str("sctp");
test_str("udp");
test_str_fail("hoge");
test_str_fail("-1");
test_str_fail("1000000000");
+}
- test_parse_ip_protocol("sctp", IPPROTO_SCTP);
- test_parse_ip_protocol("ScTp", IPPROTO_SCTP);
- test_parse_ip_protocol("ip", IPPROTO_IP);
- test_parse_ip_protocol("", IPPROTO_IP);
- test_parse_ip_protocol("1", 1);
- test_parse_ip_protocol("0", 0);
- test_parse_ip_protocol("-10", -EINVAL);
- test_parse_ip_protocol("100000000", -EINVAL);
-
- return 0;
+TEST(parse_ip_protocol) {
+ test_parse_ip_protocol_one("sctp", IPPROTO_SCTP);
+ test_parse_ip_protocol_one("ScTp", IPPROTO_SCTP);
+ test_parse_ip_protocol_one("ip", IPPROTO_IP);
+ test_parse_ip_protocol_one("", IPPROTO_IP);
+ test_parse_ip_protocol_one("1", 1);
+ test_parse_ip_protocol_one("0", 0);
+ test_parse_ip_protocol_one("-10", -EINVAL);
+ test_parse_ip_protocol_one("100000000", -EINVAL);
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
"COREDUMP_PROC_CGROUP=1:name=systemd:/\n" \
"0::/user.slice/user-1002.slice/user@1002.service/gnome-terminal-server.service\n"
-static void test_basic_parsing(void) {
+TEST(basic_parsing) {
_cleanup_(journal_importer_cleanup) JournalImporter imp = JOURNAL_IMPORTER_INIT(-1);
_cleanup_free_ char *journal_data_path = NULL;
int r;
assert_se(journal_importer_eof(&imp));
}
-static void test_bad_input(void) {
+TEST(bad_input) {
_cleanup_(journal_importer_cleanup) JournalImporter imp = JOURNAL_IMPORTER_INIT(-1);
_cleanup_free_ char *journal_data_path = NULL;
int r;
assert_se(journal_importer_eof(&imp));
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_DEBUG);
-
- test_basic_parsing();
- test_bad_input();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "tests.h"
#include "util.h"
-static void test_tokenizer(const char *data, ...) {
+static void test_tokenizer_one(const char *data, ...) {
unsigned line = 0, column = 0;
void *state = NULL;
va_list ap;
typedef void (*Test)(JsonVariant *);
-static void test_variant(const char *data, Test test) {
+static void test_variant_one(const char *data, Test test) {
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
_cleanup_free_ char *s = NULL;
int r;
}
}
-static void test_build(void) {
- log_info("/* %s */", __func__);
-
+TEST(build) {
_cleanup_(json_variant_unrefp) JsonVariant *a = NULL, *b = NULL;
_cleanup_free_ char *s = NULL, *t = NULL;
assert_se(json_variant_equal(a, b));
}
-static void test_source(void) {
+TEST(source) {
static const char data[] =
"\n"
"\n"
"false, 7.5, {} ]\n"
"}\n";
- log_info("/* %s */", __func__);
-
_cleanup_fclose_ FILE *f = NULL;
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
printf("--- pretty end ---\n");
}
-static void test_depth(void) {
- log_info("/* %s */", __func__);
-
+TEST(depth) {
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
int r;
fputs("\n", stdout);
}
-static void test_normalize(void) {
- log_info("/* %s */", __func__);
-
+TEST(normalize) {
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
_cleanup_free_ char *t = NULL;
t = mfree(t);
}
-static void test_bisect(void) {
- log_info("/* %s */", __func__);
-
+TEST(bisect) {
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
/* Tests the bisection logic in json_variant_by_key() */
json_variant_integer(json_variant_by_index(v, 8)) == -10);
}
-static void test_float(void) {
+TEST(float) {
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
_cleanup_free_ char *text = NULL;
- log_info("/* %s */", __func__);
-
assert_se(json_build(&v, JSON_BUILD_ARRAY(
JSON_BUILD_REAL(DBL_MIN),
JSON_BUILD_REAL(DBL_MAX),
assert_se(json_variant_equal(v, w) || (!v && json_variant_is_null(w)));
}
-static void test_set_field(void) {
+TEST(set_field) {
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- log_info("/* %s */", __func__);
-
test_equal_text(v, "null");
assert_se(json_variant_set_field(&v, "foo", NULL) >= 0);
test_equal_text(v, "{\"foo\" : null}");
test_equal_text(v, "{\"foo\" : \"quux2\", \"bar\" : null}");
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_tokenizer("x", -EINVAL);
- test_tokenizer("", JSON_TOKEN_END);
- test_tokenizer(" ", JSON_TOKEN_END);
- test_tokenizer("0", JSON_TOKEN_UNSIGNED, (uint64_t) 0, JSON_TOKEN_END);
- test_tokenizer("-0", JSON_TOKEN_INTEGER, (int64_t) 0, JSON_TOKEN_END);
- test_tokenizer("1234", JSON_TOKEN_UNSIGNED, (uint64_t) 1234, JSON_TOKEN_END);
- test_tokenizer("-1234", JSON_TOKEN_INTEGER, (int64_t) -1234, JSON_TOKEN_END);
- test_tokenizer("18446744073709551615", JSON_TOKEN_UNSIGNED, (uint64_t) UINT64_MAX, JSON_TOKEN_END);
- test_tokenizer("-9223372036854775808", JSON_TOKEN_INTEGER, (int64_t) INT64_MIN, JSON_TOKEN_END);
- test_tokenizer("18446744073709551616", JSON_TOKEN_REAL, (double) 18446744073709551616.0L, JSON_TOKEN_END);
- test_tokenizer("-9223372036854775809", JSON_TOKEN_REAL, (double) -9223372036854775809.0L, JSON_TOKEN_END);
- test_tokenizer("-1234", JSON_TOKEN_INTEGER, (int64_t) -1234, JSON_TOKEN_END);
- test_tokenizer("3.141", JSON_TOKEN_REAL, (double) 3.141, JSON_TOKEN_END);
- test_tokenizer("0.0", JSON_TOKEN_REAL, (double) 0.0, JSON_TOKEN_END);
- test_tokenizer("7e3", JSON_TOKEN_REAL, (double) 7e3, JSON_TOKEN_END);
- test_tokenizer("-7e-3", JSON_TOKEN_REAL, (double) -7e-3, JSON_TOKEN_END);
- test_tokenizer("true", JSON_TOKEN_BOOLEAN, true, JSON_TOKEN_END);
- test_tokenizer("false", JSON_TOKEN_BOOLEAN, false, JSON_TOKEN_END);
- test_tokenizer("null", JSON_TOKEN_NULL, JSON_TOKEN_END);
- test_tokenizer("{}", JSON_TOKEN_OBJECT_OPEN, JSON_TOKEN_OBJECT_CLOSE, JSON_TOKEN_END);
- test_tokenizer("\t {\n} \n", JSON_TOKEN_OBJECT_OPEN, JSON_TOKEN_OBJECT_CLOSE, JSON_TOKEN_END);
- test_tokenizer("[]", JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_END);
- test_tokenizer("\t [] \n\n", JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_END);
- test_tokenizer("\"\"", JSON_TOKEN_STRING, "", JSON_TOKEN_END);
- test_tokenizer("\"foo\"", JSON_TOKEN_STRING, "foo", JSON_TOKEN_END);
- test_tokenizer("\"foo\\nfoo\"", JSON_TOKEN_STRING, "foo\nfoo", JSON_TOKEN_END);
- test_tokenizer("{\"foo\" : \"bar\"}", JSON_TOKEN_OBJECT_OPEN, JSON_TOKEN_STRING, "foo", JSON_TOKEN_COLON, JSON_TOKEN_STRING, "bar", JSON_TOKEN_OBJECT_CLOSE, JSON_TOKEN_END);
- test_tokenizer("{\"foo\" : [true, false]}", JSON_TOKEN_OBJECT_OPEN, JSON_TOKEN_STRING, "foo", JSON_TOKEN_COLON, JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_BOOLEAN, true, JSON_TOKEN_COMMA, JSON_TOKEN_BOOLEAN, false, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_OBJECT_CLOSE, JSON_TOKEN_END);
- test_tokenizer("\"\xef\xbf\xbd\"", JSON_TOKEN_STRING, "\xef\xbf\xbd", JSON_TOKEN_END);
- test_tokenizer("\"\\ufffd\"", JSON_TOKEN_STRING, "\xef\xbf\xbd", JSON_TOKEN_END);
- test_tokenizer("\"\\uf\"", -EINVAL);
- test_tokenizer("\"\\ud800a\"", -EINVAL);
- test_tokenizer("\"\\udc00\\udc00\"", -EINVAL);
- test_tokenizer("\"\\ud801\\udc37\"", JSON_TOKEN_STRING, "\xf0\x90\x90\xb7", JSON_TOKEN_END);
-
- test_tokenizer("[1, 2, -3]", JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_UNSIGNED, (uint64_t) 1, JSON_TOKEN_COMMA, JSON_TOKEN_UNSIGNED, (uint64_t) 2, JSON_TOKEN_COMMA, JSON_TOKEN_INTEGER, (int64_t) -3, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_END);
-
- test_variant("{\"k\": \"v\", \"foo\": [1, 2, 3], \"bar\": {\"zap\": null}}", test_1);
- test_variant("{\"mutant\": [1, null, \"1\", {\"1\": [1, \"1\"]}], \"thisisaverylongproperty\": 1.27}", test_2);
- test_variant("{\"foo\" : \"\\u0935\\u093f\\u0935\\u0947\\u0915\\u0916\\u094d\\u092f\\u093e\\u0924\\u093f\\u0930\\u0935\\u093f\\u092a\\u094d\\u0932\\u0935\\u093e\\u0020\\u0939\\u093e\\u0928\\u094b\\u092a\\u093e\\u092f\\u0903\\u0964\"}", NULL);
-
- test_variant("[ 0, -0, 0.0, -0.0, 0.000, -0.000, 0e0, -0e0, 0e+0, -0e-0, 0e-0, -0e000, 0e+000 ]", test_zeroes);
-
- test_build();
- test_source();
- test_depth();
-
- test_normalize();
- test_bisect();
- test_float();
- test_set_field();
-
- return 0;
+TEST(tokenizer) {
+ test_tokenizer_one("x", -EINVAL);
+ test_tokenizer_one("", JSON_TOKEN_END);
+ test_tokenizer_one(" ", JSON_TOKEN_END);
+ test_tokenizer_one("0", JSON_TOKEN_UNSIGNED, (uint64_t) 0, JSON_TOKEN_END);
+ test_tokenizer_one("-0", JSON_TOKEN_INTEGER, (int64_t) 0, JSON_TOKEN_END);
+ test_tokenizer_one("1234", JSON_TOKEN_UNSIGNED, (uint64_t) 1234, JSON_TOKEN_END);
+ test_tokenizer_one("-1234", JSON_TOKEN_INTEGER, (int64_t) -1234, JSON_TOKEN_END);
+ test_tokenizer_one("18446744073709551615", JSON_TOKEN_UNSIGNED, (uint64_t) UINT64_MAX, JSON_TOKEN_END);
+ test_tokenizer_one("-9223372036854775808", JSON_TOKEN_INTEGER, (int64_t) INT64_MIN, JSON_TOKEN_END);
+ test_tokenizer_one("18446744073709551616", JSON_TOKEN_REAL, (double) 18446744073709551616.0L, JSON_TOKEN_END);
+ test_tokenizer_one("-9223372036854775809", JSON_TOKEN_REAL, (double) -9223372036854775809.0L, JSON_TOKEN_END);
+ test_tokenizer_one("-1234", JSON_TOKEN_INTEGER, (int64_t) -1234, JSON_TOKEN_END);
+ test_tokenizer_one("3.141", JSON_TOKEN_REAL, (double) 3.141, JSON_TOKEN_END);
+ test_tokenizer_one("0.0", JSON_TOKEN_REAL, (double) 0.0, JSON_TOKEN_END);
+ test_tokenizer_one("7e3", JSON_TOKEN_REAL, (double) 7e3, JSON_TOKEN_END);
+ test_tokenizer_one("-7e-3", JSON_TOKEN_REAL, (double) -7e-3, JSON_TOKEN_END);
+ test_tokenizer_one("true", JSON_TOKEN_BOOLEAN, true, JSON_TOKEN_END);
+ test_tokenizer_one("false", JSON_TOKEN_BOOLEAN, false, JSON_TOKEN_END);
+ test_tokenizer_one("null", JSON_TOKEN_NULL, JSON_TOKEN_END);
+ test_tokenizer_one("{}", JSON_TOKEN_OBJECT_OPEN, JSON_TOKEN_OBJECT_CLOSE, JSON_TOKEN_END);
+ test_tokenizer_one("\t {\n} \n", JSON_TOKEN_OBJECT_OPEN, JSON_TOKEN_OBJECT_CLOSE, JSON_TOKEN_END);
+ test_tokenizer_one("[]", JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_END);
+ test_tokenizer_one("\t [] \n\n", JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_END);
+ test_tokenizer_one("\"\"", JSON_TOKEN_STRING, "", JSON_TOKEN_END);
+ test_tokenizer_one("\"foo\"", JSON_TOKEN_STRING, "foo", JSON_TOKEN_END);
+ test_tokenizer_one("\"foo\\nfoo\"", JSON_TOKEN_STRING, "foo\nfoo", JSON_TOKEN_END);
+ test_tokenizer_one("{\"foo\" : \"bar\"}", JSON_TOKEN_OBJECT_OPEN, JSON_TOKEN_STRING, "foo", JSON_TOKEN_COLON, JSON_TOKEN_STRING, "bar", JSON_TOKEN_OBJECT_CLOSE, JSON_TOKEN_END);
+ test_tokenizer_one("{\"foo\" : [true, false]}", JSON_TOKEN_OBJECT_OPEN, JSON_TOKEN_STRING, "foo", JSON_TOKEN_COLON, JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_BOOLEAN, true, JSON_TOKEN_COMMA, JSON_TOKEN_BOOLEAN, false, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_OBJECT_CLOSE, JSON_TOKEN_END);
+ test_tokenizer_one("\"\xef\xbf\xbd\"", JSON_TOKEN_STRING, "\xef\xbf\xbd", JSON_TOKEN_END);
+ test_tokenizer_one("\"\\ufffd\"", JSON_TOKEN_STRING, "\xef\xbf\xbd", JSON_TOKEN_END);
+ test_tokenizer_one("\"\\uf\"", -EINVAL);
+ test_tokenizer_one("\"\\ud800a\"", -EINVAL);
+ test_tokenizer_one("\"\\udc00\\udc00\"", -EINVAL);
+ test_tokenizer_one("\"\\ud801\\udc37\"", JSON_TOKEN_STRING, "\xf0\x90\x90\xb7", JSON_TOKEN_END);
+
+ test_tokenizer_one("[1, 2, -3]", JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_UNSIGNED, (uint64_t) 1, JSON_TOKEN_COMMA, JSON_TOKEN_UNSIGNED, (uint64_t) 2, JSON_TOKEN_COMMA, JSON_TOKEN_INTEGER, (int64_t) -3, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_END);
}
+
+TEST(variant) {
+ test_variant_one("{\"k\": \"v\", \"foo\": [1, 2, 3], \"bar\": {\"zap\": null}}", test_1);
+ test_variant_one("{\"mutant\": [1, null, \"1\", {\"1\": [1, \"1\"]}], \"thisisaverylongproperty\": 1.27}", test_2);
+ test_variant_one("{\"foo\" : \"\\u0935\\u093f\\u0935\\u0947\\u0915\\u0916\\u094d\\u092f\\u093e\\u0924\\u093f\\u0930\\u0935\\u093f\\u092a\\u094d\\u0932\\u0935\\u093e\\u0020\\u0939\\u093e\\u0928\\u094b\\u092a\\u093e\\u092f\\u0903\\u0964\"}", NULL);
+
+ test_variant_one("[ 0, -0, 0.0, -0.0, 0.000, -0.000, 0e0, -0e0, 0e+0, -0e-0, 0e-0, -0e000, 0e+000 ]", test_zeroes);
+}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
assert_se(mnt_table_next_fs(table, iter, &fs) == 1);
}
-static void test_libmount_unescaping(void) {
+TEST(libmount_unescaping) {
test_libmount_unescaping_one(
"escaped space + utf8",
"729 38 0:59 / /tmp/„zupa\\040zębowa” rw,relatime shared:395 - tmpfs die\\040Brühe rw,seclabel",
);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_libmount_unescaping();
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
}
}
-int main(int argc, char *argv[]) {
+TEST(local_addresses) {
struct local_address *a = NULL;
int n, n_ipv4, n_ipv6;
- test_setup_logging(LOG_DEBUG);
-
n = local_addresses(NULL, 0, AF_INET, &a);
assert_se(n >= 0);
log_debug("/* Local Addresses(ifindex:0, AF_INET) */");
log_debug("/* Local Outbounds */");
print_local_addresses(a, (unsigned) n);
free(a);
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "locale-util.h"
#include "macro.h"
#include "strv.h"
+#include "tests.h"
#include "util.h"
-static void test_get_locales(void) {
+TEST(get_locales) {
_cleanup_strv_free_ char **locales = NULL;
char **p;
int r;
}
}
-static void test_locale_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(locale_is_valid) {
assert_se(locale_is_valid("en_EN.utf8"));
assert_se(locale_is_valid("fr_FR.utf8"));
assert_se(locale_is_valid("fr_FR@euro"));
assert_se(!locale_is_valid("\x01gar\x02 bage\x03"));
}
-static void test_locale_is_installed(void) {
- log_info("/* %s */", __func__);
-
+TEST(locale_is_installed) {
/* Always available */
assert_se(locale_is_installed("POSIX") > 0);
assert_se(locale_is_installed("C") > 0);
assert_se(locale_is_installed("zz_ZZ") == 0);
}
-static void test_keymaps(void) {
+TEST(keymaps) {
_cleanup_strv_free_ char **kmaps = NULL;
char **p;
int r;
- log_info("/* %s */", __func__);
-
assert_se(!keymap_is_valid(""));
assert_se(!keymap_is_valid("/usr/bin/foo"));
assert_se(!keymap_is_valid("\x01gar\x02 bage\x03"));
}
#define dump_glyph(x) log_info(STRINGIFY(x) ": %s", special_glyph(x))
-static void dump_special_glyphs(void) {
+TEST(dump_special_glyphs) {
assert_cc(SPECIAL_GLYPH_SPARKLES + 1 == _SPECIAL_GLYPH_MAX);
- log_info("/* %s */", __func__);
-
log_info("is_locale_utf8: %s", yes_no(is_locale_utf8()));
dump_glyph(SPECIAL_GLYPH_TREE_VERTICAL);
dump_glyph(SPECIAL_GLYPH_SPARKLES);
}
-int main(int argc, char *argv[]) {
- test_get_locales();
- test_locale_is_valid();
- test_locale_is_installed();
- test_keymaps();
-
- dump_special_glyphs();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "recovery-key.h"
#include "alloc-util.h"
#include "string-util.h"
+#include "tests.h"
static void test_normalize_recovery_key(const char *t, const char *expected) {
_cleanup_free_ char *z = NULL;
(r == -EINVAL && z == NULL));
}
-int main(int argc, char *arv[]) {
-
+TEST(normalize_recovery_key_all) {
test_normalize_recovery_key("iefgcelh-biduvkjv-cjvuncnk-vlfchdid-jhtuhhde-urkllkeg-ilkjgbrt-hjkbgktj",
"iefgcelh-biduvkjv-cjvuncnk-vlfchdid-jhtuhhde-urkllkeg-ilkjgbrt-hjkbgktj");
test_normalize_recovery_key("iefgcelhebiduvkjv-cjvuncnk-vlfchdid-jhtuhhde-urkllkeg-ilkjgbrt-hjkbgktj", NULL);
test_normalize_recovery_key("", NULL);
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "tests.h"
#include "tmpfile-util.h"
-static void test_mount_option_mangle(void) {
+TEST(mount_option_mangle) {
char *opts = NULL;
unsigned long f;
- log_info("/* %s */", __func__);
-
assert_se(mount_option_mangle(NULL, MS_RDONLY|MS_NOSUID, &f, &opts) == 0);
assert_se(f == (MS_RDONLY|MS_NOSUID));
assert_se(opts == NULL);
assert_se(streq(x, expected));
}
-static void test_mount_flags_to_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(mount_flags_to_string) {
test_mount_flags_to_string_one(0, "0");
test_mount_flags_to_string_one(MS_RDONLY, "MS_RDONLY");
test_mount_flags_to_string_one(MS_NOSUID, "MS_NOSUID");
"MS_I_VERSION|MS_STRICTATIME|MS_LAZYTIME|fc000200");
}
-static void test_bind_remount_recursive(void) {
+TEST(bind_remount_recursive) {
_cleanup_(rm_rf_physical_and_freep) char *tmp = NULL;
_cleanup_free_ char *subdir = NULL;
const char *p;
- log_info("/* %s */", __func__);
-
if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) {
(void) log_tests_skipped("not running privileged");
return;
}
}
-static void test_bind_remount_one(void) {
+TEST(bind_remount_one) {
pid_t pid;
- log_info("/* %s */", __func__);
-
if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) {
(void) log_tests_skipped("not running privileged");
return;
assert_se(wait_for_terminate_and_check("test-remount-one", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_make_mount_point_inode(void) {
+TEST(make_mount_point_inode) {
_cleanup_(rm_rf_physical_and_freep) char *d = NULL;
const char *src_file, *src_dir, *dst_file, *dst_dir;
struct stat st;
- log_info("/* %s */", __func__);
-
assert_se(mkdtemp_malloc(NULL, &d) >= 0);
src_file = strjoina(d, "/src/file");
assert_se(!(S_IXOTH & st.st_mode));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_mount_option_mangle();
- test_mount_flags_to_string();
- test_bind_remount_recursive();
- test_bind_remount_one();
- test_make_mount_point_inode();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "string-util.h"
#include "tests.h"
-static void test_default_net_naming_scheme(void) {
- log_info("/* %s */", __func__);
-
+TEST(default_net_naming_scheme) {
const NamingScheme *n;
assert_se(n = naming_scheme_from_name(DEFAULT_NET_NAMING_SCHEME));
log_info("default → %s", n->name);
}
-static void test_naming_scheme_conversions(void) {
- log_info("/* %s */", __func__);
-
+TEST(naming_scheme_conversions) {
const NamingScheme *n;
assert_se(n = naming_scheme_from_name("latest"));
log_info("latest → %s", n->name);
assert_se(streq(n->name, "v238"));
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_INFO);
-
- test_default_net_naming_scheme();
- test_naming_scheme_conversions();
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "ordered-set.h"
#include "string-util.h"
#include "strv.h"
+#include "tests.h"
-static void test_set_steal_first(void) {
- log_info("/* %s */", __func__);
-
+TEST(set_steal_first) {
_cleanup_ordered_set_free_ OrderedSet *m = NULL;
int seen[3] = {};
char *val;
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(item_hash_ops, void, trivial_hash_func, trivial_compare_func, Item, item_seen);
-static void test_set_free_with_hash_ops(void) {
+TEST(set_free_with_hash_ops) {
OrderedSet *m;
struct Item items[4] = {};
- log_info("/* %s */", __func__);
-
assert_se(m = ordered_set_new(&item_hash_ops));
for (size_t i = 0; i < ELEMENTSOF(items) - 1; i++)
assert_se(items[3].seen == 0);
}
-static void test_set_put(void) {
+TEST(set_put) {
_cleanup_ordered_set_free_ OrderedSet *m = NULL;
_cleanup_free_ char **t = NULL, *str = NULL;
- log_info("/* %s */", __func__);
-
m = ordered_set_new(&string_hash_ops);
assert_se(m);
ordered_set_print(stdout, "FOO=", m);
}
-static void test_set_put_string_set(void) {
+TEST(set_put_string_set) {
_cleanup_ordered_set_free_ OrderedSet *m = NULL, *q = NULL;
_cleanup_free_ char **final = NULL; /* "just free" because the strings are in the set */
- log_info("/* %s */", __func__);
-
assert_se(ordered_set_put_strdup(&m, "1") == 1);
assert_se(ordered_set_put_strdup(&m, "22") == 1);
assert_se(ordered_set_put_strdup(&m, "333") == 1);
ordered_set_print(stdout, "BAR=", m);
}
-int main(int argc, const char *argv[]) {
- test_set_steal_first();
- test_set_free_with_hash_ops();
- test_set_put();
- test_set_put_string_set();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "os-util.h"
#include "tests.h"
-static void test_path_is_os_tree(void) {
+TEST(path_is_os_tree) {
assert_se(path_is_os_tree("/") > 0);
assert_se(path_is_os_tree("/etc") == 0);
assert_se(path_is_os_tree("/idontexist") == -ENOENT);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_path_is_os_tree();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "stdio-util.h"
#include "tests.h"
-static void test_parse_json_argument(void) {
- log_info("/* %s */", __func__);
-
+TEST(parse_json_argument) {
JsonFormatFlags flags = JSON_FORMAT_PRETTY;
assert_se(parse_json_argument("help", &flags) == 0);
assert_se(flags == JSON_FORMAT_OFF);
}
-static void test_parse_path_argument(void) {
- log_info("/* %s */", __func__);
-
+TEST(parse_path_argument) {
_cleanup_free_ char *path = NULL;
assert_se(parse_path_argument("help", false, &path) == 0);
assert_se(path == NULL);
}
-static void test_parse_signal_argument(void) {
- log_info("/* %s */", __func__);
-
+TEST(parse_signal_argument) {
int signal = -1;
assert_se(parse_signal_argument("help", &signal) == 0);
assert_se(signal == SIGABRT);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- test_parse_json_argument();
- test_parse_path_argument();
- test_parse_signal_argument();
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "macro.h"
#include "parse-socket-bind-item.h"
+#include "tests.h"
static void test_valid_item(
const char *str,
log_info("%s: \"%s\" ok", __func__, str);
}
-int main(int argc, char *argv[]) {
+TEST(valid_items) {
test_valid_item("any", AF_UNSPEC, 0, 0, 0);
test_valid_item("ipv4", AF_INET, 0, 0, 0);
test_valid_item("ipv6", AF_INET6, 0, 0, 0);
test_valid_item("ipv6:tcp:6666", AF_INET6, IPPROTO_TCP, 1, 6666);
test_valid_item("ipv6:udp:6666-6667", AF_INET6, IPPROTO_UDP, 2, 6666);
test_valid_item("ipv6:tcp:any", AF_INET6, IPPROTO_TCP, 0, 0);
+}
+TEST(invalid_items) {
test_invalid_item("");
test_invalid_item(":");
test_invalid_item("::");
test_invalid_item("ipv6:tcp:6666 zupa");
test_invalid_item("ipv6:tcp:6666: zupa");
test_invalid_item("ipv6:tcp:6666\n zupa");
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "log.h"
#include "parse-util.h"
#include "string-util.h"
+#include "tests.h"
-static void test_parse_boolean(void) {
+TEST(parse_boolean) {
assert_se(parse_boolean("1") == 1);
assert_se(parse_boolean("y") == 1);
assert_se(parse_boolean("Y") == 1);
assert_se(parse_boolean("full") < 0);
}
-static void test_parse_pid(void) {
+TEST(parse_pid) {
int r;
pid_t pid;
assert_se(r == -EINVAL);
}
-static void test_parse_mode(void) {
+TEST(parse_mode) {
mode_t m;
assert_se(parse_mode("-1", &m) < 0);
assert_se(parse_mode(" 1", &m) >= 0 && m == 1);
}
-static void test_parse_size(void) {
+TEST(parse_size) {
uint64_t bytes;
assert_se(parse_size("", 1024, &bytes) == -EINVAL);
assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
}
-static void test_parse_range(void) {
+TEST(parse_range) {
unsigned lower, upper;
/* Successful cases */
assert_se(upper == 9999);
}
-static void test_safe_atolli(void) {
+TEST(safe_atolli) {
int r;
long long l;
assert_se(r == -EINVAL);
}
-static void test_safe_atou16(void) {
+TEST(safe_atou16) {
int r;
uint16_t l;
assert_se(r == -EINVAL);
}
-static void test_safe_atoi16(void) {
+TEST(safe_atoi16) {
int r;
int16_t l;
assert_se(r == -EINVAL);
}
-static void test_safe_atoux16(void) {
+TEST(safe_atoux16) {
int r;
uint16_t l;
assert_se(r == -EINVAL);
}
-static void test_safe_atou64(void) {
+TEST(safe_atou64) {
int r;
uint64_t l;
assert_se(r == -EINVAL);
}
-static void test_safe_atoi64(void) {
+TEST(safe_atoi64) {
int r;
int64_t l;
assert_se(r == -EINVAL);
}
-static void test_safe_atoux64(void) {
+TEST(safe_atoux64) {
int r;
uint64_t l;
assert_se(r == -EINVAL);
}
-static void test_safe_atod(void) {
+TEST(safe_atod) {
int r;
double d;
char *e;
assert_se(r == -EINVAL);
}
-static void test_parse_nice(void) {
+TEST(parse_nice) {
int n;
assert_se(parse_nice("0", &n) >= 0 && n == 0);
assert_se(parse_nice("+20", &n) == -ERANGE);
}
-static void test_parse_dev(void) {
+TEST(parse_dev) {
dev_t dev;
assert_se(parse_dev("", &dev) == -EINVAL);
assert_se(parse_dev("0:0", &dev) >= 0 && major(dev) == 0 && minor(dev) == 0);
}
-static void test_parse_errno(void) {
+TEST(parse_errno) {
assert_se(parse_errno("EILSEQ") == EILSEQ);
assert_se(parse_errno("EINVAL") == EINVAL);
assert_se(parse_errno("0") == 0);
assert_se(parse_errno("EINVALaaa") == -EINVAL);
}
-static void test_parse_mtu(void) {
+TEST(parse_mtu) {
uint32_t mtu = 0;
assert_se(parse_mtu(AF_UNSPEC, "1500", &mtu) >= 0 && mtu == 1500);
assert_se(parse_mtu(AF_UNSPEC, "", &mtu) == -EINVAL);
}
-static void test_parse_loadavg_fixed_point(void) {
+TEST(parse_loadavg_fixed_point) {
loadavg_t fp;
assert_se(parse_loadavg_fixed_point("1.23", &fp) == 0);
assert_se(parse_loadavg_fixed_point("", &fp) == -EINVAL);
}
-int main(int argc, char *argv[]) {
- log_parse_environment();
- log_open();
-
- test_parse_boolean();
- test_parse_pid();
- test_parse_mode();
- test_parse_size();
- test_parse_range();
- test_safe_atolli();
- test_safe_atou16();
- test_safe_atoi16();
- test_safe_atoux16();
- test_safe_atou64();
- test_safe_atoi64();
- test_safe_atoux64();
- test_safe_atod();
- test_parse_nice();
- test_parse_dev();
- test_parse_errno();
- test_parse_mtu();
- test_parse_loadavg_fixed_point();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "strv.h"
#include "tests.h"
-static void test_paths(UnitFileScope scope) {
+static void test_paths_one(UnitFileScope scope) {
char template[] = "/tmp/test-path-lookup.XXXXXXX";
_cleanup_(lookup_paths_free) LookupPaths lp_without_env = {};
assert_se(rm_rf(template, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
}
-static void test_user_and_global_paths(void) {
+TEST(paths) {
+ test_paths_one(UNIT_FILE_SYSTEM);
+ test_paths_one(UNIT_FILE_USER);
+ test_paths_one(UNIT_FILE_GLOBAL);
+}
+
+TEST(user_and_global_paths) {
_cleanup_(lookup_paths_free) LookupPaths lp_global = {}, lp_user = {};
char **u, **g, **p;
unsigned k = 0;
* that they also exist in the user search path. Skip any
* entries in user search path which don't exist in the global
* one, but not vice versa. */
- log_info("/* %s */", __func__);
STRV_FOREACH(p, g) {
while (u[k] && !streq(*p, u[k])) {
log_info("+ %s", u[k]);
log_info("+ %s", *p);
}
-static void test_generator_binary_paths(UnitFileScope scope) {
+static void test_generator_binary_paths_one(UnitFileScope scope) {
char template[] = "/tmp/test-path-lookup.XXXXXXX";
_cleanup_strv_free_ char **gp_without_env = NULL;
assert_se(strv_equal(env_gp_with_env, STRV_MAKE(systemd_env_generator_path)));
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_DEBUG);
-
- test_paths(UNIT_FILE_SYSTEM);
- test_paths(UNIT_FILE_USER);
- test_paths(UNIT_FILE_GLOBAL);
-
- test_user_and_global_paths();
-
- test_generator_binary_paths(UNIT_FILE_SYSTEM);
- test_generator_binary_paths(UNIT_FILE_USER);
-
- return EXIT_SUCCESS;
+TEST(generator_binary_paths) {
+ test_generator_binary_paths_one(UNIT_FILE_SYSTEM);
+ test_generator_binary_paths_one(UNIT_FILE_USER);
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "tmpfile-util.h"
#include "util.h"
-static void test_print_paths(void) {
+TEST(print_paths) {
log_info("DEFAULT_PATH=%s", DEFAULT_PATH);
log_info("DEFAULT_USER_PATH=%s", DEFAULT_USER_PATH);
}
-static void test_path(void) {
- log_info("/* %s */", __func__);
-
+TEST(path) {
assert_se(path_is_absolute("/"));
assert_se(!path_is_absolute("./"));
assert_se(streq(p, out));
}
-static void test_path_simplify(void) {
+TEST(path_simplify) {
_cleanup_free_ char *hoge = NULL, *hoge_out = NULL;
char foo[NAME_MAX * 2];
- log_info("/* %s */", __func__);
-
test_path_simplify_one("", "");
test_path_simplify_one("aaa/bbb////ccc", "aaa/bbb/ccc");
test_path_simplify_one("//aaa/.////ccc", "/aaa/ccc");
assert_se(path_equal(b, a) == (expected == 0));
}
-static void test_path_compare(void) {
- log_info("/* %s */", __func__);
-
+TEST(path_compare) {
test_path_compare_one("/goo", "/goo", 0);
test_path_compare_one("/goo", "/goo", 0);
test_path_compare_one("//goo", "/goo", 0);
test_path_compare_one("/foo/a/b", "/foo/aaa", -1);
}
-static void test_path_equal_root(void) {
+TEST(path_equal_root) {
/* Nail down the details of how path_equal("/", ...) works. */
- log_info("/* %s */", __func__);
-
assert_se(path_equal("/", "/"));
assert_se(path_equal("/", "//"));
assert_se(!path_equal_or_files_same("/", "/.../", AT_SYMLINK_NOFOLLOW));
}
-static void test_find_executable_full(void) {
+TEST(find_executable_full) {
char *p;
char* test_file_name;
_cleanup_close_ int fd = -1;
char fn[] = "/tmp/test-XXXXXX";
- log_info("/* %s */", __func__);
-
assert_se(find_executable_full("sh", NULL, NULL, true, &p, NULL) == 0);
puts(p);
assert_se(streq(basename(p), "sh"));
assert_se(find_executable_full(test_file_name, NULL, STRV_MAKE("/doesnotexist", "/tmp", "/bin"), false, &p, NULL) == -ENOENT);
}
-static void test_find_executable(const char *self) {
+TEST(find_executable) {
char *p;
- log_info("/* %s */", __func__);
-
assert_se(find_executable("/bin/sh", &p) == 0);
puts(p);
assert_se(path_equal(p, "/bin/sh"));
free(p);
- assert_se(find_executable(self, &p) == 0);
+ assert_se(find_executable(saved_argv[0], &p) == 0);
puts(p);
assert_se(endswith(p, "/test-path-util"));
assert_se(path_is_absolute(p));
assert_se(wait_for_terminate_and_check(t, pid, WAIT_LOG) == 0);
}
-static void test_find_executable_exec(void) {
- log_info("/* %s */", __func__);
-
+TEST(find_executable_exec) {
test_find_executable_exec_one("touch");
test_find_executable_exec_one("/bin/touch");
test_find_executable_exec_one(script);
}
-static void test_prefixes(void) {
+TEST(prefixes) {
static const char* const values[] = {
"/a/b/c/d",
"/a/b/c",
char s[PATH_MAX];
bool b;
- log_info("/* %s */", __func__);
-
i = 0;
PATH_FOREACH_PREFIX_MORE(s, "/a/b/c/d") {
log_error("---%s---", s);
}
}
-static void test_path_join(void) {
- log_info("/* %s */", __func__);
-
+TEST(path_join) {
#define test_join(expected, ...) { \
_cleanup_free_ char *z = NULL; \
z = path_join(__VA_ARGS__); \
test_join("//foo////bar////baz//", "//foo/", "///bar/", "///baz//");
}
-static void test_path_extend(void) {
+TEST(path_extend) {
_cleanup_free_ char *p = NULL;
- log_info("/* %s */", __func__);
-
assert_se(path_extend(&p, "foo", "bar", "baz") == p);
assert_se(streq(p, "foo/bar/baz"));
assert_se(streq(p, "/foo"));
}
-static void test_fsck_exists(void) {
- log_info("/* %s */", __func__);
-
+TEST(fsck_exists) {
/* Ensure we use a sane default for PATH. */
assert_se(unsetenv("PATH") == 0);
assert_se(streq_ptr(z, expected));
}
-static void test_make_relative(void) {
- log_info("/* %s */", __func__);
-
+TEST(path_make_relative) {
test_path_make_relative_one("some/relative/path", "/some/path", NULL);
test_path_make_relative_one("/some/path", "some/relative/path", NULL);
test_path_make_relative_one("/some/dotdot/../path", "/some/path", NULL);
test_path_make_relative_one("//extra.//.//./.slashes//./won't////fo.ol///anybody//", "/././/extra././/.slashes////ar.e/.just/././.fine///", "../../../ar.e/.just/.fine");
}
-static void test_strv_resolve(void) {
+TEST(path_strv_resolve) {
char tmp_dir[] = "/tmp/test-path-util-XXXXXX";
_cleanup_strv_free_ char **search_dirs = NULL;
_cleanup_strv_free_ char **absolute_dirs = NULL;
}
}
-static void test_path_startswith(void) {
- log_info("/* %s */", __func__);
-
+TEST(path_startswith) {
test_path_startswith_one("/foo/bar/barfoo/", "/foo", "/foo/", "bar/barfoo/");
test_path_startswith_one("/foo/bar/barfoo/", "/foo/", "/foo/", "bar/barfoo/");
test_path_startswith_one("/foo/bar/barfoo/", "/", "/", "foo/bar/barfoo/");
assert_se(path_equal_ptr(t, expected));
}
-static void test_prefix_root(void) {
- log_info("/* %s */", __func__);
-
+TEST(prefix_root) {
test_prefix_root_one("/", "/foo", "/foo");
test_prefix_root_one(NULL, "/foo", "/foo");
test_prefix_root_one("", "/foo", "/foo");
test_prefix_root_one("/foo///", "//bar", "/foo/bar");
}
-static void test_file_in_same_dir(void) {
+TEST(file_in_same_dir) {
char *t;
- log_info("/* %s */", __func__);
-
t = file_in_same_dir("/", "a");
assert_se(streq(t, "/a"));
free(t);
}
}
-static void test_path_find_first_component(void) {
+TEST(path_find_first_component) {
_cleanup_free_ char *hoge = NULL;
char foo[NAME_MAX * 2];
- log_info("/* %s */", __func__);
-
test_path_find_first_component_one(NULL, false, NULL, 0);
test_path_find_first_component_one("", false, NULL, 0);
test_path_find_first_component_one("/", false, NULL, 0);
}
}
-static void test_path_find_last_component(void) {
+TEST(path_find_last_component) {
_cleanup_free_ char *hoge = NULL;
char foo[NAME_MAX * 2];
- log_info("/* %s */", __func__);
-
test_path_find_last_component_one(NULL, false, NULL, 0);
test_path_find_last_component_one("", false, NULL, 0);
test_path_find_last_component_one("/", false, NULL, 0);
test_path_find_last_component_one(hoge, true, STRV_MAKE("c", "b", "a"), -EINVAL);
}
-static void test_last_path_component(void) {
+TEST(last_path_component) {
assert_se(last_path_component(NULL) == NULL);
assert_se(streq(last_path_component("a/b/c"), "c"));
assert_se(streq(last_path_component("a/b/c/"), "c/"));
assert_se(r == ret);
}
-static void test_path_extract_filename(void) {
- log_info("/* %s */", __func__);
-
+TEST(path_extract_filename) {
test_path_extract_filename_one(NULL, NULL, -EINVAL);
test_path_extract_filename_one("a/b/c", "c", 0);
test_path_extract_filename_one("a/b/c/", "c", O_DIRECTORY);
}
}
-static void test_path_extract_directory(void) {
- log_info("/* %s */", __func__);
-
+TEST(path_extract_directory) {
test_path_extract_directory_one(NULL, NULL, -EINVAL);
test_path_extract_directory_one("a/b/c", "a/b", 0);
test_path_extract_directory_one("a/b/c/", "a/b", 0);
test_path_extract_directory_one("../", NULL, -EINVAL);
}
-static void test_filename_is_valid(void) {
+TEST(filename_is_valid) {
char foo[NAME_MAX+2];
- log_info("/* %s */", __func__);
-
assert_se(!filename_is_valid(""));
assert_se(!filename_is_valid("/bar/foo"));
assert_se(!filename_is_valid("/"));
assert_se(path_is_safe(p) == ret);
}
-static void test_path_is_valid_and_safe(void) {
+TEST(path_is_valid_and_safe) {
char foo[PATH_MAX+2];
const char *c;
- log_info("/* %s */", __func__);
-
test_path_is_valid_and_safe_one("", false);
test_path_is_valid_and_safe_one("/bar/foo", true);
test_path_is_valid_and_safe_one("/bar/foo/", true);
test_path_is_valid_and_safe_one("o.o", true);
}
-static void test_hidden_or_backup_file(void) {
- log_info("/* %s */", __func__);
-
+TEST(hidden_or_backup_file) {
assert_se(hidden_or_backup_file(".hidden"));
assert_se(hidden_or_backup_file("..hidden"));
assert_se(!hidden_or_backup_file("hidden."));
assert_se(!hidden_or_backup_file("test.dpkg-old.foo"));
}
-static void test_systemd_installation_has_version(const char *path) {
+TEST(systemd_installation_has_version) {
int r;
const unsigned versions[] = {0, 231, PROJECT_VERSION, 999};
unsigned i;
log_info("/* %s */", __func__);
for (i = 0; i < ELEMENTSOF(versions); i++) {
- r = systemd_installation_has_version(path, versions[i]);
+ r = systemd_installation_has_version(saved_argv[1], versions[i]);
assert_se(r >= 0);
log_info("%s has systemd >= %u: %s",
- path ?: "Current installation", versions[i], yes_no(r));
+ saved_argv[1] ?: "Current installation", versions[i], yes_no(r));
}
}
-static void test_skip_dev_prefix(void) {
- log_info("/* %s */", __func__);
-
+TEST(skip_dev_prefix) {
assert_se(streq(skip_dev_prefix("/"), "/"));
assert_se(streq(skip_dev_prefix("/dev"), ""));
assert_se(streq(skip_dev_prefix("/dev/"), ""));
assert_se(streq(skip_dev_prefix("foo"), "foo"));
}
-static void test_empty_or_root(void) {
- log_info("/* %s */", __func__);
-
+TEST(empty_or_root) {
assert_se(empty_or_root(NULL));
assert_se(empty_or_root(""));
assert_se(empty_or_root("/"));
assert_se(!empty_or_root("//yy//"));
}
-static void test_path_startswith_set(void) {
- log_info("/* %s */", __func__);
-
+TEST(path_startswith_set) {
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/foo/bar", "/zzz"), ""));
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/foo/", "/zzz"), "bar"));
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/foo", "/zzz"), "bar"));
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "", "/zzz"), NULL));
}
-static void test_path_startswith_strv(void) {
- log_info("/* %s */", __func__);
-
+TEST(path_startswith_strv) {
assert_se(streq_ptr(path_startswith_strv("/foo/bar", STRV_MAKE("/foo/quux", "/foo/bar", "/zzz")), ""));
assert_se(streq_ptr(path_startswith_strv("/foo/bar", STRV_MAKE("/foo/quux", "/foo/", "/zzz")), "bar"));
assert_se(streq_ptr(path_startswith_strv("/foo/bar", STRV_MAKE("/foo/quux", "/foo", "/zzz")), "bar"));
assert_se(streq_ptr(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "", "/zzz")), NULL));
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_DEBUG);
-
+TEST(print_MAX) {
log_info("PATH_MAX=%zu\n"
"FILENAME_MAX=%zu\n"
"NAME_MAX=%zu",
(size_t) NAME_MAX);
assert_cc(FILENAME_MAX == PATH_MAX);
-
- test_print_paths();
- test_path();
- test_path_simplify();
- test_path_compare();
- test_path_equal_root();
- test_find_executable_full();
- test_find_executable(argv[0]);
- test_find_executable_exec();
- test_prefixes();
- test_path_join();
- test_path_extend();
- test_fsck_exists();
- test_make_relative();
- test_strv_resolve();
- test_path_startswith();
- test_prefix_root();
- test_file_in_same_dir();
- test_path_find_first_component();
- test_path_find_last_component();
- test_last_path_component();
- test_path_extract_filename();
- test_path_extract_directory();
- test_filename_is_valid();
- test_path_is_valid_and_safe();
- test_hidden_or_backup_file();
- test_skip_dev_prefix();
- test_empty_or_root();
- test_path_startswith_set();
- test_path_startswith_strv();
-
- test_systemd_installation_has_version(argv[1]); /* NULL is OK */
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "tests.h"
#include "time-util.h"
-static void test_parse_percent(void) {
+TEST(parse_percent) {
assert_se(parse_percent("") == -EINVAL);
assert_se(parse_percent("foo") == -EINVAL);
assert_se(parse_percent("0") == -EINVAL);
assert_se(parse_percent("3.2%") == -EINVAL);
}
-static void test_parse_percent_unbounded(void) {
+TEST(parse_percent_unbounded) {
assert_se(parse_percent_unbounded("101%") == 101);
assert_se(parse_percent_unbounded("400%") == 400);
}
-static void test_parse_permille(void) {
+TEST(parse_permille) {
assert_se(parse_permille("") == -EINVAL);
assert_se(parse_permille("foo") == -EINVAL);
assert_se(parse_permille("0") == -EINVAL);
assert_se(parse_permille("0.1%") == 1);
}
-static void test_parse_permille_unbounded(void) {
+TEST(parse_permille_unbounded) {
assert_se(parse_permille_unbounded("1001‰") == 1001);
assert_se(parse_permille_unbounded("4000‰") == 4000);
assert_se(parse_permille_unbounded("2147483647‰") == 2147483647);
assert_se(parse_permille_unbounded("429496729.6%") == -ERANGE);
}
-static void test_parse_permyriad(void) {
+TEST(parse_permyriad) {
assert_se(parse_permyriad("") == -EINVAL);
assert_se(parse_permyriad("foo") == -EINVAL);
assert_se(parse_permyriad("0") == -EINVAL);
assert_se(parse_permyriad("3.212%") == -EINVAL);
}
-static void test_parse_permyriad_unbounded(void) {
+TEST(parse_permyriad_unbounded) {
assert_se(parse_permyriad_unbounded("1001‱") == 1001);
assert_se(parse_permyriad_unbounded("4000‱") == 4000);
assert_se(parse_permyriad_unbounded("2147483647‱") == 2147483647);
assert_se(parse_permyriad_unbounded("42949672.96%") == -ERANGE);
}
-static void test_scale(void) {
+TEST(scale) {
/* Check some fixed values */
assert_se(UINT32_SCALE_FROM_PERCENT(0) == 0);
assert_se(UINT32_SCALE_FROM_PERCENT(50) == UINT32_MAX/2+1);
}
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_parse_percent();
- test_parse_percent_unbounded();
- test_parse_permille();
- test_parse_permille_unbounded();
- test_parse_permyriad();
- test_parse_permyriad_unbounded();
- test_scale();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "strv.h"
#include "tests.h"
-static void test_terminal_urlify(void) {
+TEST(terminal_urlify) {
_cleanup_free_ char *formatted = NULL;
assert_se(terminal_urlify("https://www.freedesktop.org/wiki/Software/systemd/", "systemd homepage", &formatted) >= 0);
printf("Or click on %s to have a look at it!\n", formatted);
}
-static void test_cat_files(void) {
+TEST(cat_files) {
assert_se(cat_files("/no/such/file", NULL, 0) == -ENOENT);
assert_se(cat_files("/no/such/file", NULL, CAT_FLAGS_MAIN_FILE_OPTIONAL) == 0);
assert_se(cat_files("/etc/fstab", STRV_MAKE("/etc/fstab", "/etc/fstab"), 0) == 0);
}
-static void test_red_green_cross_check_mark(void) {
+TEST(red_green_cross_check_mark) {
bool b = false;
printf("yea: <%s>\n", GREEN_CHECK_MARK());
COLOR_MARK_BOOL(!!!b));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- test_terminal_urlify();
- test_cat_files();
- test_red_green_cross_check_mark();
-
+TEST(print_separator) {
print_separator();
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "set.h"
#include "siphash24.h"
#include "sort-util.h"
+#include "tests.h"
#define SET_SIZE 1024*4
return CMP(*a, *b);
}
-static void test_unsigned(void) {
+TEST(unsigned) {
_cleanup_(prioq_freep) Prioq *q = NULL;
unsigned buffer[SET_SIZE], i, u, n;
DEFINE_PRIVATE_HASH_OPS(test_hash_ops, struct test, test_hash, test_compare);
-static void test_struct(void) {
+TEST(struct) {
_cleanup_(prioq_freep) Prioq *q = NULL;
_cleanup_set_free_ Set *s = NULL;
unsigned previous = 0, i;
assert_se(set_isempty(s));
}
-int main(int argc, char* argv[]) {
-
- test_unsigned();
- test_struct();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "psi-util.h"
#include "tests.h"
-static void test_read_mem_pressure(void) {
+TEST(read_mem_pressure) {
_cleanup_(unlink_tempfilep) char path[] = "/tmp/pressurereadtestXXXXXX";
ResourcePressure rp;
assert_se(rp.total == 58464525);
}
-int main(void) {
- test_setup_logging(LOG_DEBUG);
- test_read_mem_pressure();
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "terminal-util.h"
#include "tests.h"
-static void test_genuine_random_bytes(RandomFlags flags) {
+static void test_genuine_random_bytes_one(RandomFlags flags) {
uint8_t buf[16] = {};
- log_info("/* %s */", __func__);
+ log_info("/* %s(%d) */", __func__, flags);
for (size_t i = 1; i < sizeof buf; i++) {
assert_se(genuine_random_bytes(buf, i, flags) == 0);
}
}
-static void test_pseudo_random_bytes(void) {
- uint8_t buf[16] = {};
+TEST(genuine_random_bytes) {
+ test_genuine_random_bytes_one(RANDOM_EXTEND_WITH_PSEUDO);
+ test_genuine_random_bytes_one(0);
+ test_genuine_random_bytes_one(RANDOM_BLOCK);
+ test_genuine_random_bytes_one(RANDOM_ALLOW_RDRAND);
+ test_genuine_random_bytes_one(RANDOM_ALLOW_INSECURE);
+}
- log_info("/* %s */", __func__);
+TEST(pseudo_random_bytes) {
+ uint8_t buf[16] = {};
for (size_t i = 1; i < sizeof buf; i++) {
pseudo_random_bytes(buf, i);
}
}
-static void test_rdrand(void) {
+TEST(rdrand) {
int r;
- log_info("/* %s */", __func__);
-
for (unsigned i = 0; i < 10; i++) {
unsigned long x = 0;
}
}
-static void test_random_u64_range(void) {
+TEST(random_u64_range) {
for (unsigned mod = 1; mod < 29; mod++)
test_random_u64_range_one(mod);
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_DEBUG);
-
- test_genuine_random_bytes(RANDOM_EXTEND_WITH_PSEUDO);
- test_genuine_random_bytes(0);
- test_genuine_random_bytes(RANDOM_BLOCK);
- test_genuine_random_bytes(RANDOM_ALLOW_RDRAND);
- test_genuine_random_bytes(RANDOM_ALLOW_INSECURE);
-
- test_pseudo_random_bytes();
- test_rdrand();
- test_random_u64_range();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "macro.h"
#include "ratelimit.h"
+#include "tests.h"
#include "time-util.h"
-static void test_ratelimit_below(void) {
+TEST(ratelimit_below) {
int i;
RateLimit ratelimit = { 1 * USEC_PER_SEC, 10 };
assert_se(ratelimit_below(&ratelimit));
}
-int main(int argc, char *argv[]) {
- test_ratelimit_below();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "macro.h"
#include "replace-var.h"
#include "string-util.h"
+#include "tests.h"
static char *lookup(const char *variable, void *userdata) {
return strjoin("<<<", variable, ">>>");
}
-int main(int argc, char *argv[]) {
+TEST(replace_var) {
char *r;
assert_se(r = replace_var("@@@foobar@xyz@HALLO@foobar@test@@testtest@TEST@...@@@", lookup, NULL));
puts(r);
assert_se(streq(r, "@@@foobar@xyz<<<HALLO>>>foobar@test@@testtest<<<TEST>>>...@@@"));
free(r);
+}
+
+TEST(strreplace) {
+ char *r;
assert_se(r = strreplace("XYZFFFFXYZFFFFXYZ", "XYZ", "ABC"));
puts(r);
assert_se(streq(r, "ABCFFFFABCFFFFABC"));
free(r);
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
assert_se(access(d, F_OK) < 0 && errno == ENOENT);
}
-static void test_rm_rf_chmod(void) {
+TEST(rm_rf_chmod) {
int r;
- log_info("/* %s */", __func__);
-
if (getuid() == 0) {
/* This test only works unpriv (as only then the access mask for the owning user matters),
* hence drop privs here */
test_rm_rf_chmod_inner();
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_DEBUG);
-
- test_rm_rf_chmod();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "strv.h"
#include "tests.h"
-static void test_sd_path_lookup(void) {
- log_info("/* %s */", __func__);
-
+TEST(sd_path_lookup) {
for (uint64_t i = 0; i < _SD_PATH_MAX; i++) {
_cleanup_free_ char *t = NULL, *s = NULL;
int r;
assert_se(sd_path_lookup(_SD_PATH_MAX, NULL, &tt) == -EOPNOTSUPP);
}
-static void test_sd_path_lookup_strv(void) {
- log_info("/* %s */", __func__);
-
+TEST(sd_path_lookup_strv) {
for (uint64_t i = 0; i < _SD_PATH_MAX; i++) {
_cleanup_strv_free_ char **t = NULL, **s = NULL;
char **item;
assert_se(sd_path_lookup(_SD_PATH_MAX, NULL, &tt) == -EOPNOTSUPP);
}
-int main(void) {
- test_setup_logging(LOG_DEBUG);
-
- test_sd_path_lookup();
- test_sd_path_lookup_strv();
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
return geteuid() == 0 && have_effective_cap(CAP_SYS_ADMIN) > 0; /* If we are root but CAP_SYS_ADMIN we can't do caps (unless we also do NNP) */
}
-static void test_parse_syscall_and_errno(void) {
+TEST(parse_syscall_and_errno) {
_cleanup_free_ char *n = NULL;
int e;
assert_se(parse_syscall_and_errno("hoge:", &n, &e) == -EINVAL);
}
-static void test_seccomp_arch_to_string(void) {
+TEST(seccomp_arch_to_string) {
uint32_t a, b;
const char *name;
- log_info("/* %s */", __func__);
-
a = seccomp_arch_native();
assert_se(a > 0);
name = seccomp_arch_to_string(a);
assert_se(a == b);
}
-static void test_architecture_table(void) {
+TEST(architecture_table) {
const char *n, *n2;
- log_info("/* %s */", __func__);
-
NULSTR_FOREACH(n,
"native\0"
"x86\0"
}
}
-static void test_syscall_filter_set_find(void) {
- log_info("/* %s */", __func__);
-
+TEST(syscall_filter_set_find) {
assert_se(!syscall_filter_set_find(NULL));
assert_se(!syscall_filter_set_find(""));
assert_se(!syscall_filter_set_find("quux"));
assert_se(syscall_filter_set_find("@raw-io") == syscall_filter_sets + SYSCALL_FILTER_SET_RAW_IO);
}
-static void test_filter_sets(void) {
- log_info("/* %s */", __func__);
-
+TEST(filter_sets) {
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
}
}
-static void test_filter_sets_ordered(void) {
- log_info("/* %s */", __func__);
-
+TEST(filter_sets_ordered) {
/* Ensure "@default" always remains at the beginning of the list */
assert_se(SYSCALL_FILTER_SET_DEFAULT == 0);
assert_se(streq(syscall_filter_sets[0].name, "@default"));
}
}
-static void test_restrict_namespace(void) {
+TEST(restrict_namespace) {
char *s = NULL;
unsigned long ul;
pid_t pid;
return;
}
- log_info("/* %s */", __func__);
-
assert_se(namespace_flags_to_string(0, &s) == 0 && isempty(s));
s = mfree(s);
assert_se(namespace_flags_to_string(CLONE_NEWNS, &s) == 0 && streq(s, "mnt"));
assert_se(wait_for_terminate_and_check("nsseccomp", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_protect_sysctl(void) {
+TEST(protect_sysctl) {
pid_t pid;
_cleanup_free_ char *seccomp = NULL;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
assert_se(wait_for_terminate_and_check("sysctlseccomp", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_protect_syslog(void) {
+TEST(protect_syslog) {
pid_t pid;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
assert_se(wait_for_terminate_and_check("syslogseccomp", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_restrict_address_families(void) {
+TEST(restrict_address_families) {
pid_t pid;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
assert_se(wait_for_terminate_and_check("socketseccomp", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_restrict_realtime(void) {
+TEST(restrict_realtime) {
pid_t pid;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
assert_se(wait_for_terminate_and_check("realtimeseccomp", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_memory_deny_write_execute_mmap(void) {
+TEST(memory_deny_write_execute_mmap) {
pid_t pid;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
assert_se(wait_for_terminate_and_check("memoryseccomp-mmap", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_memory_deny_write_execute_shmat(void) {
+TEST(memory_deny_write_execute_shmat) {
int shmid;
pid_t pid;
uint32_t arch;
- log_info("/* %s */", __func__);
-
SECCOMP_FOREACH_LOCAL_ARCH(arch) {
log_debug("arch %s: SCMP_SYS(mmap) = %d", seccomp_arch_to_string(arch), SCMP_SYS(mmap));
log_debug("arch %s: SCMP_SYS(mmap2) = %d", seccomp_arch_to_string(arch), SCMP_SYS(mmap2));
assert_se(wait_for_terminate_and_check("memoryseccomp-shmat", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_restrict_archs(void) {
+TEST(restrict_archs) {
pid_t pid;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
assert_se(wait_for_terminate_and_check("archseccomp", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_load_syscall_filter_set_raw(void) {
+TEST(load_syscall_filter_set_raw) {
pid_t pid;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
assert_se(wait_for_terminate_and_check("syscallrawseccomp", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_native_syscalls_filtered(void) {
+TEST(native_syscalls_filtered) {
pid_t pid;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
assert_se(wait_for_terminate_and_check("nativeseccomp", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-static void test_lock_personality(void) {
+TEST(lock_personality) {
unsigned long current;
pid_t pid;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
#endif
}
-static void test_restrict_suid_sgid(void) {
+TEST(restrict_suid_sgid) {
pid_t pid;
- log_info("/* %s */", __func__);
-
if (!is_seccomp_available()) {
log_notice("Seccomp not available, skipping %s", __func__);
return;
assert_se(wait_for_terminate_and_check("suidsgidseccomp", pid, WAIT_LOG) == EXIT_SUCCESS);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_parse_syscall_and_errno();
- test_seccomp_arch_to_string();
- test_architecture_table();
- test_syscall_filter_set_find();
- test_filter_sets();
- test_filter_sets_ordered();
- test_restrict_namespace();
- test_protect_sysctl();
- test_protect_syslog();
- test_restrict_address_families();
- test_restrict_realtime();
- test_memory_deny_write_execute_mmap();
- test_memory_deny_write_execute_shmat();
- test_restrict_archs();
- test_load_syscall_filter_set_raw();
- test_native_syscalls_filtered();
- test_lock_personality();
- test_restrict_suid_sgid();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
assert_se(!s);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
+TEST(disable_mempool) {
test_one("0");
/* The value $SYSTEMD_MEMPOOL= is cached. So the following
* test should also succeed. */
test_one("1");
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "random-util.h"
#include "set.h"
#include "strv.h"
+#include "tests.h"
const bool mempool_use_allowed = VALGRIND;
-static void test_set_steal_first(void) {
+TEST(set_steal_first) {
_cleanup_set_free_ Set *m = NULL;
int seen[3] = {};
char *val;
item->seen++;
}
-static void test_set_free_with_destructor(void) {
+TEST(set_free_with_destructor) {
Set *m;
struct Item items[4] = {};
unsigned i;
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(item_hash_ops, void, trivial_hash_func, trivial_compare_func, Item, item_seen);
-static void test_set_free_with_hash_ops(void) {
+TEST(set_free_with_hash_ops) {
Set *m;
struct Item items[4] = {};
unsigned i;
assert_se(items[3].seen == 0);
}
-static void test_set_put(void) {
+TEST(set_put) {
_cleanup_set_free_ Set *m = NULL;
m = set_new(&string_hash_ops);
assert_se(strv_length(t) == 3);
}
-static void test_set_put_strdup(void) {
+TEST(set_put_strdup) {
_cleanup_set_free_ Set *m = NULL;
assert_se(set_put_strdup(&m, "aaa") == 1);
assert_se(set_size(m) == 2);
}
-static void test_set_put_strdupv(void) {
+TEST(set_put_strdupv) {
_cleanup_set_free_ Set *m = NULL;
assert_se(set_put_strdupv(&m, STRV_MAKE("aaa", "aaa", "bbb", "bbb", "aaa")) == 2);
assert_se(set_size(m) == 3);
}
-static void test_set_ensure_allocated(void) {
+TEST(set_ensure_allocated) {
_cleanup_set_free_ Set *m = NULL;
assert_se(set_ensure_allocated(&m, &string_hash_ops) == 1);
assert_se(set_size(m) == 0);
}
-static void test_set_copy(void) {
+TEST(set_copy) {
Set *s, *copy;
char *key1, *key2, *key3, *key4;
- log_info("/* %s */", __func__);
-
key1 = strdup("key1");
assert_se(key1);
key2 = strdup("key2");
set_free_free(copy);
}
-static void test_set_ensure_put(void) {
+TEST(set_ensure_put) {
_cleanup_set_free_ Set *m = NULL;
assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 1);
assert_se(set_size(m) == 2);
}
-static void test_set_ensure_consume(void) {
+TEST(set_ensure_consume) {
_cleanup_set_free_ Set *m = NULL;
char *s, *t;
assert_se(set_size(m) == 2);
}
-static void test_set_strjoin(void) {
+TEST(set_strjoin) {
_cleanup_set_free_ Set *m = NULL;
_cleanup_free_ char *joined = NULL;
assert_se(STR_IN_SET(joined, "xxxaaaxxxbbbxxx", "xxxbbbxxxaaaxxx"));
}
-static void test_set_equal(void) {
+TEST(set_equal) {
_cleanup_set_free_ Set *a = NULL, *b = NULL;
void *p;
int r;
assert_se(set_equal(b, a));
}
-int main(int argc, const char *argv[]) {
- test_set_steal_first();
- test_set_free_with_destructor();
- test_set_free_with_hash_ops();
- test_set_put();
- test_set_put_strdup();
- test_set_put_strdupv();
- test_set_ensure_allocated();
- test_set_ensure_put();
- test_set_ensure_consume();
- test_set_strjoin();
- test_set_equal();
- test_set_copy();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "signal-util.h"
#include "stdio-util.h"
#include "string-util.h"
+#include "tests.h"
#include "process-util.h"
#define info(sig) log_info(#sig " = " STRINGIFY(sig) " = %d", sig)
-static void test_rt_signals(void) {
+TEST(rt_signals) {
info(SIGRTMIN);
info(SIGRTMAX);
assert_se(signal_from_string(p) == -EINVAL);
}
-static void test_signal_from_string(void) {
+TEST(signal_from_string) {
char buf[STRLEN("RTMIN+") + DECIMAL_STR_MAX(int) + 1];
test_signal_to_string_one(SIGHUP);
test_signal_from_string_number("-2", -ERANGE);
}
-static void test_block_signals(void) {
+TEST(block_signals) {
assert_se(signal_is_blocked(SIGUSR1) == 0);
assert_se(signal_is_blocked(SIGALRM) == 0);
assert_se(signal_is_blocked(SIGVTALRM) == 0);
assert_se(signal_is_blocked(SIGVTALRM) == 0);
}
-static void test_ignore_signals(void) {
+TEST(ignore_signals) {
assert_se(ignore_signals(SIGINT) >= 0);
assert_se(kill(getpid_cached(), SIGINT) >= 0);
assert_se(ignore_signals(SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE) >= 0);
assert_se(default_signals(SIGINT, SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE) >= 0);
}
-static void test_pop_pending_signal(void) {
+TEST(pop_pending_signal) {
assert_se(signal_is_blocked(SIGUSR1) == 0);
assert_se(signal_is_blocked(SIGUSR2) == 0);
assert_se(pop_pending_signal(SIGUSR2) == 0);
}
-int main(int argc, char *argv[]) {
- test_rt_signals();
- test_signal_from_string();
- test_block_signals();
- test_ignore_signals();
- test_pop_pending_signal();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "memory-util.h"
#include "siphash24.h"
+#include "tests.h"
#define ITERATIONS 10000000ULL
-static void do_test(const uint8_t *in, size_t len, const uint8_t *key) {
+static void test_alignment_one(const uint8_t *in, size_t len, const uint8_t *key) {
struct siphash state = {};
uint64_t out;
unsigned i, j;
}
}
-static void test_short_hashes(void) {
+TEST(alignment) {
+ const uint8_t in[15] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e };
+ const uint8_t key[16] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
+ uint8_t in_buf[20];
+
+ /* Test with same input but different alignments. */
+ memcpy(in_buf, in, sizeof(in));
+ test_alignment_one(in_buf, sizeof(in), key);
+ memcpy(in_buf + 1, in, sizeof(in));
+ test_alignment_one(in_buf + 1, sizeof(in), key);
+ memcpy(in_buf + 2, in, sizeof(in));
+ test_alignment_one(in_buf + 2, sizeof(in), key);
+ memcpy(in_buf + 4, in, sizeof(in));
+ test_alignment_one(in_buf + 4, sizeof(in), key);
+}
+
+TEST(short_hashes) {
const uint8_t one[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
const uint8_t key[16] = { 0x22, 0x24, 0x41, 0x22, 0x55, 0x77, 0x88, 0x07,
}
/* see https://131002.net/siphash/siphash.pdf, Appendix A */
-int main(int argc, char *argv[]) {
- const uint8_t in[15] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e };
- const uint8_t key[16] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
- uint8_t in_buf[20];
-
- /* Test with same input but different alignments. */
- memcpy(in_buf, in, sizeof(in));
- do_test(in_buf, sizeof(in), key);
- memcpy(in_buf + 1, in, sizeof(in));
- do_test(in_buf + 1, sizeof(in), key);
- memcpy(in_buf + 2, in, sizeof(in));
- do_test(in_buf + 2, sizeof(in), key);
- memcpy(in_buf + 4, in, sizeof(in));
- do_test(in_buf + 4, sizeof(in), key);
-
- test_short_hashes();
-}
+DEFINE_TEST_MAIN(LOG_INFO);
}
}
-static void test_socket_address_parse(void) {
- log_info("/* %s */", __func__);
-
+TEST(socket_address_parse) {
test_socket_address_parse_one("junk", -EINVAL, 0, NULL);
test_socket_address_parse_one("192.168.1.1", -EINVAL, 0, NULL);
test_socket_address_parse_one(".168.1.1", -EINVAL, 0, NULL);
test_socket_address_parse_one("vsock:2", -EINVAL, 0, NULL);
}
-static void test_socket_address_parse_netlink(void) {
+TEST(socket_address_parse_netlink) {
SocketAddress a;
- log_info("/* %s */", __func__);
-
assert_se(socket_address_parse_netlink(&a, "junk") < 0);
assert_se(socket_address_parse_netlink(&a, "") < 0);
assert_se(socket_address_parse_netlink(&a, "\xff") < 0);
}
-static void test_socket_address_equal(void) {
+TEST(socket_address_equal) {
SocketAddress a, b;
- log_info("/* %s */", __func__);
-
assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
assert_se(socket_address_parse(&b, "192.168.1.1:888") >= 0);
assert_se(!socket_address_equal(&a, &b));
assert_se(!socket_address_equal(&a, &b));
}
-static void test_socket_address_get_path(void) {
+TEST(socket_address_get_path) {
SocketAddress a;
- log_info("/* %s */", __func__);
-
assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
assert_se(!socket_address_get_path(&a));
assert_se(!socket_address_get_path(&a));
}
-static void test_socket_address_is(void) {
+TEST(socket_address_is) {
SocketAddress a;
- log_info("/* %s */", __func__);
-
assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
assert_se( socket_address_is(&a, "192.168.1.1:8888", 0 /* unspecified yet */));
assert_se(!socket_address_is(&a, "route", 0));
assert_se( socket_address_is(&a, "192.168.1.1:8888", SOCK_STREAM));
}
-static void test_socket_address_is_netlink(void) {
+TEST(socket_address_is_netlink) {
SocketAddress a;
- log_info("/* %s */", __func__);
-
assert_se(socket_address_parse_netlink(&a, "route 10") >= 0);
assert_se( socket_address_is_netlink(&a, "route 10"));
assert_se(!socket_address_is_netlink(&a, "192.168.1.1:8888"));
assert_se(ifindex2 == ifindex || ifindex2 == 0);
}
-static void test_in_addr_ifindex_to_string(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_ifindex_to_string) {
test_in_addr_ifindex_to_string_one(AF_INET, "192.168.0.1", 7, "192.168.0.1");
test_in_addr_ifindex_to_string_one(AF_INET, "10.11.12.13", 9, "10.11.12.13");
test_in_addr_ifindex_to_string_one(AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 10, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
test_in_addr_ifindex_to_string_one(AF_INET6, "fe80::16", LOOPBACK_IFINDEX, "fe80::16%1");
}
-static void test_in_addr_ifindex_from_string_auto(void) {
+TEST(in_addr_ifindex_from_string_auto) {
int family, ifindex;
union in_addr_union ua;
- log_info("/* %s */", __func__);
/* Most in_addr_ifindex_from_string_auto() invocations have already been tested above, but let's test some more */
assert_se(in_addr_ifindex_from_string_auto("fe80::17", &family, &ua, &ifindex) >= 0);
assert_se(streq_ptr(server_name, expected));
}
-static void test_in_addr_ifindex_name_from_string_auto(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_ifindex_name_from_string_auto) {
test_in_addr_ifindex_name_from_string_auto_one("192.168.0.1", NULL);
test_in_addr_ifindex_name_from_string_auto_one("192.168.0.1#test.com", "test.com");
test_in_addr_ifindex_name_from_string_auto_one("fe80::18%19", NULL);
}
}
-static void test_in_addr_port_ifindex_name_from_string_auto(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_addr_port_ifindex_name_from_string_auto) {
test_in_addr_port_ifindex_name_from_string_auto_one("192.168.0.1", AF_INET, 0, 0, NULL, NULL);
test_in_addr_port_ifindex_name_from_string_auto_one("192.168.0.1#test.com", AF_INET, 0, 0, "test.com", NULL);
test_in_addr_port_ifindex_name_from_string_auto_one("192.168.0.1:53", AF_INET, 53, 0, NULL, NULL);
test_in_addr_port_ifindex_name_from_string_auto_one("[fe80::18]:53%lo#hoge.com", AF_INET6, 53, 1, "hoge.com", "[fe80::18]:53%1#hoge.com");
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_socket_address_parse();
- test_socket_address_parse_netlink();
- test_socket_address_equal();
- test_socket_address_get_path();
- test_socket_address_is();
- test_socket_address_is_netlink();
-
- test_in_addr_ifindex_to_string();
- test_in_addr_ifindex_from_string_auto();
- test_in_addr_ifindex_name_from_string_auto();
- test_in_addr_port_ifindex_name_from_string_auto();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
assert_cc(SUN_PATH_LEN == 108);
-static void test_ifname_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(ifname_valid) {
assert_se( ifname_valid("foo"));
assert_se( ifname_valid("eth0"));
assert_se(streq(out, expected));
}
-static void test_socket_print_unix(void) {
- log_info("/* %s */", __func__);
-
+TEST(socket_print_unix) {
/* Some additional tests for abstract addresses which we don't parse */
test_socket_print_unix_one("\0\0\0\0", 4, "@\\000\\000\\000");
test_socket_print_unix_one("\0\a\b\n\255", 6, "@\\a\\b\\n\\255\\000");
}
-static void test_sockaddr_equal(void) {
+TEST(sockaddr_equal) {
union sockaddr_union a = {
.in.sin_family = AF_INET,
.in.sin_port = 0,
.vm.svm_cid = VMADDR_CID_ANY,
};
- log_info("/* %s */", __func__);
-
assert_se(sockaddr_equal(&a, &a));
assert_se(sockaddr_equal(&a, &b));
assert_se(sockaddr_equal(&d, &d));
assert_se(!sockaddr_equal(&a, &e));
}
-static void test_sockaddr_un_len(void) {
- log_info("/* %s */", __func__);
-
+TEST(sockaddr_un_len) {
static const struct sockaddr_un fs = {
.sun_family = AF_UNIX,
.sun_path = "/foo/bar/waldo",
assert_se(SOCKADDR_UN_LEN(abstract) == offsetof(struct sockaddr_un, sun_path) + 1 + strlen(abstract.sun_path + 1));
}
-static void test_in_addr_is_multicast(void) {
+TEST(in_addr_is_multicast) {
union in_addr_union a, b;
int f;
- log_info("/* %s */", __func__);
-
assert_se(in_addr_from_string_auto("192.168.3.11", &f, &a) >= 0);
assert_se(in_addr_is_multicast(f, &a) == 0);
assert_se(in_addr_is_multicast(f, &b) == 0);
}
-static void test_getpeercred_getpeergroups(void) {
+TEST(getpeercred_getpeergroups) {
int r;
- log_info("/* %s */", __func__);
-
r = safe_fork("(getpeercred)", FORK_DEATHSIG|FORK_LOG|FORK_WAIT, NULL);
assert_se(r >= 0);
}
}
-static void test_passfd_read(void) {
+TEST(passfd_read) {
static const char file_contents[] = "test contents for passfd";
_cleanup_close_pair_ int pair[2] = { -1, -1 };
int r;
- log_info("/* %s */", __func__);
-
assert_se(socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) >= 0);
r = safe_fork("(passfd_read)", FORK_DEATHSIG|FORK_LOG|FORK_WAIT, NULL);
assert_se(streq(buf, file_contents));
}
-static void test_passfd_contents_read(void) {
+TEST(passfd_contents_read) {
_cleanup_close_pair_ int pair[2] = { -1, -1 };
static const char file_contents[] = "test contents in the file";
static const char wire_contents[] = "test contents on the wire";
int r;
- log_info("/* %s */", __func__);
-
assert_se(socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) >= 0);
r = safe_fork("(passfd_contents_read)", FORK_DEATHSIG|FORK_LOG|FORK_WAIT, NULL);
assert_se(streq(buf, file_contents));
}
-static void test_receive_nopassfd(void) {
+TEST(receive_nopassfd) {
_cleanup_close_pair_ int pair[2] = { -1, -1 };
static const char wire_contents[] = "no fd passed here";
int r;
- log_info("/* %s */", __func__);
-
assert_se(socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) >= 0);
r = safe_fork("(receive_nopassfd)", FORK_DEATHSIG|FORK_LOG|FORK_WAIT, NULL);
assert_se(fd == -1);
}
-static void test_send_nodata_nofd(void) {
+TEST(send_nodata_nofd) {
_cleanup_close_pair_ int pair[2] = { -1, -1 };
int r;
- log_info("/* %s */", __func__);
-
assert_se(socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) >= 0);
r = safe_fork("(send_nodata_nofd)", FORK_DEATHSIG|FORK_LOG|FORK_WAIT, NULL);
assert_se(fd == -999);
}
-static void test_send_emptydata(void) {
+TEST(send_emptydata) {
_cleanup_close_pair_ int pair[2] = { -1, -1 };
int r;
- log_info("/* %s */", __func__);
-
assert_se(socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) >= 0);
r = safe_fork("(send_emptydata)", FORK_DEATHSIG|FORK_LOG|FORK_WAIT, NULL);
assert_se(fd == -999);
}
-static void test_flush_accept(void) {
+TEST(flush_accept) {
_cleanup_close_ int listen_stream = -1, listen_dgram = -1, listen_seqpacket = 1, connect_stream = -1, connect_dgram = -1, connect_seqpacket = -1;
static const union sockaddr_union sa = { .un.sun_family = AF_UNIX };
union sockaddr_union lsa;
assert_se(flush_accept(listen_seqpacket) >= 0);
}
-static void test_ipv6_enabled(void) {
+TEST(ipv6_enabled) {
log_info("IPv6 supported: %s", yes_no(socket_ipv6_is_supported()));
log_info("IPv6 enabled: %s", yes_no(socket_ipv6_is_enabled()));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_ifname_valid();
- test_socket_print_unix();
- test_sockaddr_equal();
- test_sockaddr_un_len();
- test_in_addr_is_multicast();
- test_getpeercred_getpeergroups();
- test_passfd_read();
- test_passfd_contents_read();
- test_receive_nopassfd();
- test_send_nodata_nofd();
- test_send_emptydata();
- test_flush_accept();
- test_ipv6_enabled();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
assert_se(streq_ptr(x, b));
}
-static void test_specifier_escape(void) {
- log_info("/* %s */", __func__);
-
+TEST(specifier_escape) {
test_specifier_escape_one(NULL, NULL);
test_specifier_escape_one("", "");
test_specifier_escape_one("%", "%%");
assert_se(strv_equal(x, b));
}
-static void test_specifier_escape_strv(void) {
- log_info("/* %s */", __func__);
-
+TEST(specifier_escape_strv) {
test_specifier_escape_strv_one(NULL, NULL);
test_specifier_escape_strv_one(STRV_MAKE(NULL), STRV_MAKE(NULL));
test_specifier_escape_strv_one(STRV_MAKE(""), STRV_MAKE(""));
{}
};
-static void test_specifier_printf(void) {
+TEST(specifier_printf) {
static const Specifier table[] = {
{ 'X', specifier_string, (char*) "AAAA" },
{ 'Y', specifier_string, (char*) "BBBB" },
_cleanup_free_ char *w = NULL;
int r;
- log_info("/* %s */", __func__);
-
r = specifier_printf("xxx a=%X b=%Y yyy", SIZE_MAX, table, NULL, NULL, &w);
assert_se(r >= 0);
assert_se(w);
puts(w);
}
-static void test_specifiers(void) {
- log_info("/* %s */", __func__);
-
+TEST(specifiers) {
for (const Specifier *s = specifier_table; s->specifier; s++) {
char spec[3];
_cleanup_free_ char *resolved = NULL;
}
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_specifier_escape();
- test_specifier_escape_strv();
- test_specifier_printf();
- test_specifiers();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "tests.h"
#include "tmpfile-util.h"
-static void test_files_same(void) {
+TEST(files_same) {
_cleanup_close_ int fd = -1;
char name[] = "/tmp/test-files_same.XXXXXX";
char name_alias[] = "/tmp/test-files_same.alias";
- log_info("/* %s */", __func__);
-
fd = mkostemp_safe(name);
assert_se(fd >= 0);
assert_se(symlink(name, name_alias) >= 0);
unlink(name_alias);
}
-static void test_is_symlink(void) {
+TEST(is_symlink) {
char name[] = "/tmp/test-is_symlink.XXXXXX";
char name_link[] = "/tmp/test-is_symlink.link";
_cleanup_close_ int fd = -1;
- log_info("/* %s */", __func__);
-
fd = mkostemp_safe(name);
assert_se(fd >= 0);
assert_se(symlink(name, name_link) >= 0);
unlink(name_link);
}
-static void test_path_is_fs_type(void) {
- log_info("/* %s */", __func__);
-
+TEST(path_is_fs_type) {
/* run might not be a mount point in build chroots */
if (path_is_mount_point("/run", NULL, AT_SYMLINK_FOLLOW) > 0) {
assert_se(path_is_fs_type("/run", TMPFS_MAGIC) > 0);
assert_se(path_is_fs_type("/i-dont-exist", BTRFS_SUPER_MAGIC) == -ENOENT);
}
-static void test_path_is_temporary_fs(void) {
+TEST(path_is_temporary_fs) {
const char *s;
int r;
- log_info("/* %s */", __func__);
-
FOREACH_STRING(s, "/", "/run", "/sys", "/sys/", "/proc", "/i-dont-exist", "/var", "/var/lib") {
r = path_is_temporary_fs(s);
assert_se(path_is_temporary_fs("/i-dont-exist") == -ENOENT);
}
-static void test_path_is_read_only_fs(void) {
+TEST(path_is_read_only_fs) {
const char *s;
int r;
- log_info("/* %s */", __func__);
-
FOREACH_STRING(s, "/", "/run", "/sys", "/sys/", "/proc", "/i-dont-exist", "/var", "/var/lib") {
r = path_is_read_only_fs(s);
assert_se(path_is_read_only_fs("/i-dont-exist") == -ENOENT);
}
-static void test_fd_is_ns(void) {
+TEST(fd_is_ns) {
_cleanup_close_ int fd = -1;
- log_info("/* %s */", __func__);
-
assert_se(fd_is_ns(STDIN_FILENO, CLONE_NEWNET) == 0);
assert_se(fd_is_ns(STDERR_FILENO, CLONE_NEWNET) == 0);
assert_se(fd_is_ns(STDOUT_FILENO, CLONE_NEWNET) == 0);
assert_se(IN_SET(fd_is_ns(fd, CLONE_NEWNET), 1, -EUCLEAN));
}
-static void test_device_major_minor_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(device_major_minor_valid) {
/* on glibc dev_t is 64bit, even though in the kernel it is only 32bit */
assert_cc(sizeof(dev_t) == sizeof(uint64_t));
assert_se((st.st_mode & S_IFMT) == (mode & S_IFMT));
}
-static void test_device_path_make_canonical(void) {
- log_info("/* %s */", __func__);
-
+TEST(device_path_make_canonical) {
test_device_path_make_canonical_one("/dev/null");
test_device_path_make_canonical_one("/dev/zero");
test_device_path_make_canonical_one("/dev/full");
}
}
-static void test_dir_is_empty(void) {
+TEST(dir_is_empty) {
_cleanup_(rm_rf_physical_and_freep) char *empty_dir = NULL;
_cleanup_free_ char *j = NULL, *jj = NULL;
- log_info("/* %s */", __func__);
-
assert_se(dir_is_empty_at(AT_FDCWD, "/proc") == 0);
assert_se(dir_is_empty_at(AT_FDCWD, "/icertainlydontexistdoi") == -ENOENT);
assert_se(dir_is_empty_at(AT_FDCWD, empty_dir) > 0);
}
-int main(int argc, char *argv[]) {
- log_show_color(true);
- test_setup_logging(LOG_INFO);
-
- test_files_same();
- test_is_symlink();
- test_path_is_fs_type();
- test_path_is_temporary_fs();
- test_path_is_read_only_fs();
- test_fd_is_ns();
- test_device_major_minor_valid();
- test_device_path_make_canonical();
- test_dir_is_empty();
-
- return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(LOG_INFO, log_show_color(true), /* no outro */);
STATIC_DESTRUCTOR_REGISTER(baz, test_destroy);
STATIC_DESTRUCTOR_REGISTER(memory, freep);
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
+TEST(static_destruct) {
assert_se(memory = strdup("hallo"));
assert_se(foo == 0 && bar == 0 && baz == 0);
static_destruct();
assert_se(foo == 1 && bar == 2 && baz == 3);
- return EXIT_SUCCESS;
+ assert_se(memory == NULL);
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "strbuf.h"
#include "string-util.h"
#include "strv.h"
+#include "tests.h"
#include "util.h"
static ssize_t add_string(struct strbuf *sb, const char *s) {
return strbuf_add_string(sb, s, strlen(s));
}
-static void test_strbuf(void) {
+TEST(strbuf) {
_cleanup_(strbuf_freep) struct strbuf *sb;
_cleanup_strv_free_ char **l;
ssize_t a, b, c, d, e, f, g, h;
assert_se(sb->root == NULL);
}
-int main(int argc, const char *argv[]) {
- test_strbuf();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "utf8.h"
#include "util.h"
-static void test_string_erase(void) {
- log_info("/* %s */", __func__);
-
+TEST(string_erase) {
char *x;
x = strdupa_safe("");
assert_se(streq(string_erase(x), ""));
assert_se(r == change); /* check that change occurs only when necessary */
}
-static void test_free_and_strndup(void) {
- log_info("/* %s */", __func__);
-
+TEST(free_and_strndup) {
static const struct test_case {
const char *src;
size_t len;
}
}
-static void test_ascii_strcasecmp_n(void) {
- log_info("/* %s */", __func__);
-
+TEST(ascii_strcasecmp_n) {
assert_se(ascii_strcasecmp_n("", "", 0) == 0);
assert_se(ascii_strcasecmp_n("", "", 1) == 0);
assert_se(ascii_strcasecmp_n("", "a", 1) < 0);
assert_se(ascii_strcasecmp_n("xxxxYxxxx", "xxxxXxxxx", 9) > 0);
}
-static void test_ascii_strcasecmp_nn(void) {
- log_info("/* %s */", __func__);
-
+TEST(ascii_strcasecmp_nn) {
assert_se(ascii_strcasecmp_nn("", 0, "", 0) == 0);
assert_se(ascii_strcasecmp_nn("", 0, "", 1) < 0);
assert_se(ascii_strcasecmp_nn("", 1, "", 0) > 0);
assert_se(ascii_strcasecmp_nn("BBbb", 4, "aaaa", 4) > 0);
}
-static void test_cellescape(void) {
+TEST(cellescape) {
char buf[40];
- log_info("/* %s */", __func__);
-
assert_se(streq(cellescape(buf, 1, ""), ""));
assert_se(streq(cellescape(buf, 1, "1"), ""));
assert_se(streq(cellescape(buf, 1, "12"), ""));
assert_se(streq(cellescape(buf, sizeof buf, "1\020x"), "1\\020x"));
}
-static void test_streq_ptr(void) {
- log_info("/* %s */", __func__);
-
+TEST(streq_ptr) {
assert_se(streq_ptr(NULL, NULL));
assert_se(!streq_ptr("abc", "cdef"));
}
-static void test_strstrip(void) {
- log_info("/* %s */", __func__);
-
+TEST(strstrip) {
char *ret, input[] = " hello, waldo. ";
ret = strstrip(input);
assert_se(streq(ret, "hello, waldo."));
}
-static void test_strextend(void) {
- log_info("/* %s */", __func__);
-
+TEST(strextend) {
_cleanup_free_ char *str = NULL;
assert_se(strextend(&str, NULL));
assert_se(streq_ptr(str, "0123456789"));
}
-static void test_strextend_with_separator(void) {
- log_info("/* %s */", __func__);
-
+TEST(strextend_with_separator) {
_cleanup_free_ char *str = NULL;
assert_se(strextend_with_separator(&str, NULL, NULL));
assert_se(streq_ptr(str, "start,,1,234;more;5;678"));
}
-static void test_strrep(void) {
- log_info("/* %s */", __func__);
-
+TEST(strrep) {
_cleanup_free_ char *one, *three, *zero;
one = strrep("waldo", 1);
three = strrep("waldo", 3);
assert_se(streq(zero, ""));
}
-static void test_string_has_cc(void) {
+TEST(string_has_cc) {
assert_se(string_has_cc("abc\1", NULL));
assert_se(string_has_cc("abc\x7f", NULL));
assert_se(string_has_cc("abc\x7f", NULL));
assert_se(!string_has_cc("a\ab\tc", "\t\a"));
}
-static void test_ascii_strlower(void) {
- log_info("/* %s */", __func__);
-
+TEST(ascii_strlower) {
char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
assert_se(streq(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk"));
}
-static void test_strshorten(void) {
- log_info("/* %s */", __func__);
-
+TEST(strshorten) {
char s[] = "foobar";
assert_se(strlen(strshorten(s, 6)) == 6);
assert_se(strlen(strshorten(s, 0)) == 0);
}
-static void test_strjoina(void) {
- log_info("/* %s */", __func__);
-
+TEST(strjoina) {
char *actual;
actual = strjoina("", "foo", "bar");
assert_se(streq(actual, "/sys/fs/cgroup/dn"));
}
-static void test_strjoin(void) {
+TEST(strjoin) {
char *actual;
actual = strjoin("", "foo", "bar");
mfree(actual);
}
-static void test_strcmp_ptr(void) {
- log_info("/* %s */", __func__);
-
+TEST(strcmp_ptr) {
assert_se(strcmp_ptr(NULL, NULL) == 0);
assert_se(strcmp_ptr("", NULL) > 0);
assert_se(strcmp_ptr("foo", NULL) > 0);
assert_se(strcmp_ptr("", "") == 0);
}
-static void test_foreach_word(void) {
- log_info("/* %s */", __func__);
-
+TEST(foreach_word) {
const char *test = "test abc d\te f ";
const char * const expected[] = {
"test",
assert_se(expected[i] == NULL);
}
-static void test_foreach_word_quoted(void) {
- log_info("/* %s */", __func__);
-
+TEST(foreach_word_quoted) {
check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
STRV_MAKE("test",
"a",
true);
}
-static void test_endswith(void) {
- log_info("/* %s */", __func__);
-
+TEST(endswith) {
assert_se(endswith("foobar", "bar"));
assert_se(endswith("foobar", ""));
assert_se(endswith("foobar", "foobar"));
assert_se(!endswith("foobar", "foobarfoofoo"));
}
-static void test_endswith_no_case(void) {
- log_info("/* %s */", __func__);
-
+TEST(endswith_no_case) {
assert_se(endswith_no_case("fooBAR", "bar"));
assert_se(endswith_no_case("foobar", ""));
assert_se(endswith_no_case("foobar", "FOOBAR"));
assert_se(!endswith_no_case("foobar", "FOOBARFOOFOO"));
}
-static void test_delete_chars(void) {
- log_info("/* %s */", __func__);
-
+TEST(delete_chars) {
char *s, input[] = " hello, waldo. abc";
s = delete_chars(input, WHITESPACE);
assert_se(s == input);
}
-static void test_delete_trailing_chars(void) {
- log_info("/* %s */", __func__);
-
+TEST(delete_trailing_chars) {
char *s,
input1[] = " \n \r k \n \r ",
input2[] = "kkkkthiskkkiskkkaktestkkk",
assert_se(s == input3);
}
-static void test_delete_trailing_slashes(void) {
- log_info("/* %s */", __func__);
-
+TEST(delete_trailing_slashes) {
char s1[] = "foobar//",
s2[] = "foobar/",
s3[] = "foobar",
assert_se(streq(delete_trailing_chars(s4, "/"), ""));
}
-static void test_skip_leading_chars(void) {
- log_info("/* %s */", __func__);
-
+TEST(skip_leading_chars) {
char input1[] = " \n \r k \n \r ",
input2[] = "kkkkthiskkkiskkkaktestkkk",
input3[] = "abcdef";
assert_se(streq(skip_leading_chars(input3, "bcaef"), "def"));
}
-static void test_in_charset(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_charset) {
assert_se(in_charset("dddaaabbbcccc", "abcd"));
assert_se(!in_charset("dddaaabbbcccc", "abc f"));
}
-static void test_split_pair(void) {
- log_info("/* %s */", __func__);
-
+TEST(split_pair) {
_cleanup_free_ char *a = NULL, *b = NULL;
assert_se(split_pair("", "", &a, &b) == -EINVAL);
assert_se(streq(b, "="));
}
-static void test_first_word(void) {
- log_info("/* %s */", __func__);
-
+TEST(first_word) {
assert_se(first_word("Hello", ""));
assert_se(first_word("Hello", "Hello"));
assert_se(first_word("Hello world", "Hello"));
assert_se(!first_word("Hellooo", "Hello"));
}
-static void test_strlen_ptr(void) {
- log_info("/* %s */", __func__);
-
+TEST(strlen_ptr) {
assert_se(strlen_ptr("foo") == 3);
assert_se(strlen_ptr("") == 0);
assert_se(strlen_ptr(NULL) == 0);
}
-static void test_memory_startswith(void) {
- log_info("/* %s */", __func__);
-
+TEST(memory_startswith) {
assert_se(streq(memory_startswith("", 0, ""), ""));
assert_se(streq(memory_startswith("", 1, ""), ""));
assert_se(streq(memory_startswith("x", 2, ""), "x"));
assert_se(!memory_startswith("xxx", 4, "xxxx"));
}
-static void test_memory_startswith_no_case(void) {
- log_info("/* %s */", __func__);
-
+TEST(memory_startswith_no_case) {
assert_se(streq(memory_startswith_no_case("", 0, ""), ""));
assert_se(streq(memory_startswith_no_case("", 1, ""), ""));
assert_se(streq(memory_startswith_no_case("x", 2, ""), "x"));
assert_se(!!k == truncation);
}
-static void test_string_truncate_lines(void) {
- log_info("/* %s */", __func__);
-
+TEST(string_truncate_lines) {
test_string_truncate_lines_one("", 0, "", false);
test_string_truncate_lines_one("", 1, "", false);
test_string_truncate_lines_one("", 2, "", false);
assert_se(!!k == more);
}
-static void test_string_extract_line(void) {
- log_info("/* %s */", __func__);
-
+TEST(string_extract_line) {
test_string_extract_lines_one("", 0, "", false);
test_string_extract_lines_one("", 1, "", false);
test_string_extract_lines_one("", 2, "", false);
test_string_extract_lines_one("\n\n\nx\n", 3, "x", false);
}
-static void test_string_contains_word_strv(void) {
- log_info("/* %s */", __func__);
-
+TEST(string_contains_word_strv) {
const char *w;
assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("a", "b"), NULL));
assert_se(streq(w, ""));
}
-static void test_string_contains_word(void) {
- log_info("/* %s */", __func__);
-
+TEST(string_contains_word) {
assert_se( string_contains_word("a b cc", NULL, "a"));
assert_se( string_contains_word("a b cc", NULL, "b"));
assert_se(!string_contains_word("a b cc", NULL, "c"));
assert_se(strverscmp_improved(older, older) == 0);
}
-static void test_strverscmp_improved(void) {
+TEST(strverscmp_improved) {
static const char * const versions[] = {
"",
"~1",
assert_se(strverscmp_improved("123_aa2-67.89", "123aa+2-67.89") == 0);
}
-static void test_strextendf(void) {
+TEST(strextendf) {
_cleanup_free_ char *p = NULL;
assert_se(strextendf(&p, "<%i>", 77) >= 0);
assert_se(streq(p, "<77>,<99>,< 88>,<00001234>"));
}
-static void test_streq_skip_trailing_chars(void) {
- log_info("/* %s */", __func__);
-
+TEST(streq_skip_trailing_chars) {
/* NULL is WHITESPACE by default*/
assert_se(streq_skip_trailing_chars("foo bar", "foo bar", NULL));
assert_se(streq_skip_trailing_chars("foo", "foo", NULL));
assert_se(!streq_skip_trailing_chars("", "f", NULL));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_string_erase();
- test_free_and_strndup();
- test_ascii_strcasecmp_n();
- test_ascii_strcasecmp_nn();
- test_cellescape();
- test_streq_ptr();
- test_strstrip();
- test_strextend();
- test_strextend_with_separator();
- test_strrep();
- test_string_has_cc();
- test_ascii_strlower();
- test_strshorten();
- test_strjoina();
- test_strjoin();
- test_strcmp_ptr();
- test_foreach_word();
- test_foreach_word_quoted();
- test_endswith();
- test_endswith_no_case();
- test_delete_chars();
- test_delete_trailing_chars();
- test_delete_trailing_slashes();
- test_skip_leading_chars();
- test_in_charset();
- test_split_pair();
- test_first_word();
- test_strlen_ptr();
- test_memory_startswith();
- test_memory_startswith_no_case();
- test_string_truncate_lines();
- test_string_extract_line();
- test_string_contains_word_strv();
- test_string_contains_word();
- test_strverscmp_improved();
- test_strextendf();
- test_streq_skip_trailing_chars();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "pretty-print.h"
#include "string-util.h"
#include "terminal-util.h"
+#include "tests.h"
#include "util.h"
-int main(int argc, char *argv[]) {
+TEST(strip_tab_ansi) {
_cleanup_free_ char *urlified = NULL, *q = NULL, *qq = NULL;
char *p, *z;
assert_se(strip_tab_ansi(&q, NULL, NULL));
assert_se(streq(q, qq));
}
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_INFO);
#include "nulstr-util.h"
#include "string-util.h"
#include "strv.h"
+#include "tests.h"
-static void test_str_in_set(void) {
- log_info("/* %s */", __func__);
-
+TEST(str_in_set) {
assert_se(STR_IN_SET("x", "x", "y", "z"));
assert_se(!STR_IN_SET("X", "x", "y", "z"));
assert_se(!STR_IN_SET("", "x", "y", "z"));
assert_se(STR_IN_SET("x", "w", "x"));
}
-static void test_strptr_in_set(void) {
- log_info("/* %s */", __func__);
-
+TEST(strptr_in_set) {
assert_se(STRPTR_IN_SET("x", "x", "y", "z"));
assert_se(!STRPTR_IN_SET("X", "x", "y", "z"));
assert_se(!STRPTR_IN_SET("", "x", "y", "z"));
assert_se(!STRPTR_IN_SET(NULL, NULL));
}
-static void test_startswith_set(void) {
- log_info("/* %s */", __func__);
-
+TEST(startswith_set) {
assert_se(!STARTSWITH_SET("foo", "bar", "baz", "waldo"));
assert_se(!STARTSWITH_SET("foo", "bar"));
NULL,
};
-static void test_strv_find(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_find) {
assert_se(strv_find((char **)input_table_multiple, "three"));
assert_se(!strv_find((char **)input_table_multiple, "four"));
}
-static void test_strv_find_prefix(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_find_prefix) {
assert_se(strv_find_prefix((char **)input_table_multiple, "o"));
assert_se(strv_find_prefix((char **)input_table_multiple, "one"));
assert_se(strv_find_prefix((char **)input_table_multiple, ""));
assert_se(!strv_find_prefix((char **)input_table_multiple, "onee"));
}
-static void test_strv_find_startswith(void) {
+TEST(strv_find_startswith) {
char *r;
- log_info("/* %s */", __func__);
-
r = strv_find_startswith((char **)input_table_multiple, "o");
assert_se(r && streq(r, "ne"));
assert_se(!strv_find_startswith((char **)input_table_multiple, "onee"));
}
-static void test_strv_join(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_join) {
_cleanup_free_ char *p = strv_join((char **)input_table_multiple, ", ");
assert_se(p);
assert_se(streq(p, "one, two, three"));
assert_se(streq(w, ""));
}
-static void test_strv_join_full(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_join_full) {
_cleanup_free_ char *p = strv_join_full((char **)input_table_multiple, ", ", "foo", false);
assert_se(p);
assert_se(streq(p, "fooone, footwo, foothree"));
assert_se(streq(y, "foo"));
}
-static void test_strv_unquote(const char *quoted, char **list) {
+static void test_strv_unquote_one(const char *quoted, char **list) {
_cleanup_strv_free_ char **s;
_cleanup_free_ char *j;
unsigned i = 0;
assert_se(list[i] == NULL);
}
-static void test_invalid_unquote(const char *quoted) {
+TEST(strv_unquote) {
+ test_strv_unquote_one(" foo=bar \"waldo\" zzz ", STRV_MAKE("foo=bar", "waldo", "zzz"));
+ test_strv_unquote_one("", STRV_MAKE_EMPTY);
+ test_strv_unquote_one(" ", STRV_MAKE_EMPTY);
+ test_strv_unquote_one(" ", STRV_MAKE_EMPTY);
+ test_strv_unquote_one(" x", STRV_MAKE("x"));
+ test_strv_unquote_one("x ", STRV_MAKE("x"));
+ test_strv_unquote_one(" x ", STRV_MAKE("x"));
+ test_strv_unquote_one(" \"x\" ", STRV_MAKE("x"));
+ test_strv_unquote_one(" 'x' ", STRV_MAKE("x"));
+ test_strv_unquote_one(" 'x\"' ", STRV_MAKE("x\""));
+ test_strv_unquote_one(" \"x'\" ", STRV_MAKE("x'"));
+ test_strv_unquote_one("a '--b=c \"d e\"'", STRV_MAKE("a", "--b=c \"d e\""));
+
+ /* trailing backslashes */
+ test_strv_unquote_one(" x\\\\", STRV_MAKE("x\\"));
+}
+
+static void test_invalid_unquote_one(const char *quoted) {
char **s = NULL;
int r;
assert_se(r == -EINVAL);
}
-static void test_strv_split(void) {
+TEST(invalid_unquote) {
+ test_invalid_unquote_one(" x\\");
+ test_invalid_unquote_one("a --b='c \"d e\"''");
+ test_invalid_unquote_one("a --b='c \"d e\" '\"");
+ test_invalid_unquote_one("a --b='c \"d e\"garbage");
+ test_invalid_unquote_one("'");
+ test_invalid_unquote_one("\"");
+ test_invalid_unquote_one("'x'y'g");
+}
+
+TEST(strv_split) {
_cleanup_(strv_free_erasep) char **l = NULL;
const char str[] = "one,two,three";
- log_info("/* %s */", __func__);
-
l = strv_split(str, ",");
assert_se(l);
assert_se(strv_equal(l, (char**) input_table_multiple));
assert_se(strv_equal(l, STRV_MAKE("\\")));
}
-static void test_strv_split_empty(void) {
+TEST(strv_split_empty) {
_cleanup_strv_free_ char **l = NULL;
- log_info("/* %s */", __func__);
-
l = strv_split("", WHITESPACE);
assert_se(l);
assert_se(strv_isempty(l));
assert_se(strv_isempty(l));
}
-static void test_strv_split_full(void) {
+TEST(strv_split_full) {
_cleanup_strv_free_ char **l = NULL;
const char *str = ":foo\\:bar::waldo:";
int r;
- log_info("/* %s */", __func__);
-
r = strv_split_full(&l, str, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
assert_se(r == (int) strv_length(l));
assert_se(streq_ptr(l[0], ""));
assert_se(streq_ptr(l[5], NULL));
}
-static void test_strv_split_and_extend_full(void) {
+TEST(strv_split_and_extend_full) {
_cleanup_strv_free_ char **l = NULL;
const char *str1 = ":foo\\:bar:";
const char *str2 = "waldo::::::baz";
int r;
- log_info("/* %s */", __func__);
-
r = strv_split_and_extend(&l, "", ":", false);
assert_se(r == (int) strv_length(l));
r = strv_split_and_extend_full(&l, str1, ":", false, EXTRACT_DONT_COALESCE_SEPARATORS);
assert_se(streq_ptr(l[5], NULL));
}
-static void test_strv_split_colon_pairs(void) {
+TEST(strv_split_colon_pairs) {
_cleanup_strv_free_ char **l = NULL;
const char *str = "one:two three four:five six seven:eight\\:nine ten\\:eleven\\\\",
*str_inval="one:two three:four:five";
int r;
- log_info("/* %s */", __func__);
-
r = strv_split_colon_pairs(&l, str);
assert_se(r == (int) strv_length(l));
assert_se(r == 12);
assert_se(r == -EINVAL);
}
-static void test_strv_split_newlines(void) {
+TEST(strv_split_newlines) {
unsigned i = 0;
char **s;
_cleanup_strv_free_ char **l = NULL;
const char str[] = "one\ntwo\nthree";
- log_info("/* %s */", __func__);
-
l = strv_split_newlines(str);
assert_se(l);
assert_se(streq(*s, input_table_multiple[i++]));
}
-static void test_strv_split_newlines_full(void) {
+TEST(strv_split_newlines_full) {
const char str[] =
"ID_VENDOR=QEMU\n"
"ID_VENDOR_ENC=QEMU\\x20\\x20\\x20\\x20\n"
"\n\n\n";
_cleanup_strv_free_ char **l = NULL;
- log_info("/* %s */", __func__);
-
assert_se(strv_split_newlines_full(&l, str, 0) == 3);
assert_se(strv_equal(l, (char**) input_table_unescape));
assert_se(strv_equal(l, (char**) input_table_retain_escape));
}
-static void test_strv_split_nulstr(void) {
+TEST(strv_split_nulstr) {
_cleanup_strv_free_ char **l = NULL;
const char nulstr[] = "str0\0str1\0str2\0str3\0";
- log_info("/* %s */", __func__);
-
l = strv_split_nulstr (nulstr);
assert_se(l);
assert_se(streq(l[3], "str3"));
}
-static void test_strv_parse_nulstr(void) {
+TEST(strv_parse_nulstr) {
_cleanup_strv_free_ char **l = NULL;
const char nulstr[] = "hoge\0hoge2\0hoge3\0\0hoge5\0\0xxx";
- log_info("/* %s */", __func__);
-
l = strv_parse_nulstr(nulstr, sizeof(nulstr)-1);
assert_se(l);
puts("Parse nulstr:");
assert_se(streq(l[6], "xxx"));
}
-static void test_strv_overlap(void) {
+TEST(strv_overlap) {
const char * const input_table[] = {
"one",
"two",
NULL
};
- log_info("/* %s */", __func__);
-
assert_se(strv_overlap((char **)input_table, (char**)input_table_overlap));
assert_se(!strv_overlap((char **)input_table, (char**)input_table_unique));
}
-static void test_strv_sort(void) {
+TEST(strv_sort) {
const char* input_table[] = {
"durian",
"apple",
NULL
};
- log_info("/* %s */", __func__);
-
strv_sort((char **)input_table);
assert_se(streq(input_table[0], "CAPITAL LETTERS FIRST"));
assert_se(streq(input_table[4], "durian"));
}
-static void test_strv_extend_strv_concat(void) {
+TEST(strv_extend_strv_concat) {
_cleanup_strv_free_ char **a = NULL, **b = NULL;
- log_info("/* %s */", __func__);
-
a = strv_new("without", "suffix");
b = strv_new("with", "suffix");
assert_se(a);
assert_se(streq(a[3], "suffix_suffix"));
}
-static void test_strv_extend_strv(void) {
+TEST(strv_extend_strv) {
_cleanup_strv_free_ char **a = NULL, **b = NULL, **n = NULL;
- log_info("/* %s */", __func__);
-
a = strv_new("abc", "def", "ghi");
b = strv_new("jkl", "mno", "abc", "pqr");
assert_se(a);
assert_se(strv_length(n) == 4);
}
-static void test_strv_extend(void) {
+TEST(strv_extend) {
_cleanup_strv_free_ char **a = NULL, **b = NULL;
- log_info("/* %s */", __func__);
-
a = strv_new("test", "test1");
assert_se(a);
assert_se(strv_extend(&a, "test2") >= 0);
assert_se(streq(b[0], "test3"));
}
-static void test_strv_extendf(void) {
+TEST(strv_extendf) {
_cleanup_strv_free_ char **a = NULL, **b = NULL;
- log_info("/* %s */", __func__);
-
a = strv_new("test", "test1");
assert_se(a);
assert_se(strv_extendf(&a, "test2 %s %d %s", "foo", 128, "bar") >= 0);
assert_se(streq(b[0], "test3 bar foo 128"));
}
-static void test_strv_foreach(void) {
+TEST(strv_foreach) {
_cleanup_strv_free_ char **a;
unsigned i = 0;
char **check;
- log_info("/* %s */", __func__);
-
a = strv_new("one", "two", "three");
assert_se(a);
assert_se(streq(*check, input_table_multiple[i++]));
}
-static void test_strv_foreach_backwards(void) {
+TEST(strv_foreach_backwards) {
_cleanup_strv_free_ char **a;
unsigned i = 2;
char **check;
- log_info("/* %s */", __func__);
-
a = strv_new("one", "two", "three");
assert_se(a);
assert_not_reached();
}
-static void test_strv_foreach_pair(void) {
+TEST(strv_foreach_pair) {
_cleanup_strv_free_ char **a = NULL;
char **x, **y;
- log_info("/* %s */", __func__);
-
a = strv_new("pair_one", "pair_one",
"pair_two", "pair_two",
"pair_three", "pair_three");
}
}
-static void test_strv_from_stdarg_alloca(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_from_stdarg_alloca) {
test_strv_from_stdarg_alloca_one(STRV_MAKE("foo", "bar"), "foo", "bar", NULL);
test_strv_from_stdarg_alloca_one(STRV_MAKE("foo"), "foo", NULL);
test_strv_from_stdarg_alloca_one(STRV_MAKE_EMPTY, NULL);
}
-static void test_strv_insert(void) {
+TEST(strv_insert) {
_cleanup_strv_free_ char **a = NULL;
- log_info("/* %s */", __func__);
-
assert_se(strv_insert(&a, 0, strdup("first")) == 0);
assert_se(streq(a[0], "first"));
assert_se(!a[1]);
assert_se(!a[4]);
}
-static void test_strv_push_prepend(void) {
+TEST(strv_push_prepend) {
_cleanup_strv_free_ char **a = NULL;
- log_info("/* %s */", __func__);
-
assert_se(a = strv_new("foo", "bar", "three"));
assert_se(strv_push_prepend(&a, strdup("first")) >= 0);
assert_se(!a[5]);
}
-static void test_strv_push(void) {
+TEST(strv_push) {
_cleanup_strv_free_ char **a = NULL;
char *i, *j;
- log_info("/* %s */", __func__);
-
assert_se(i = strdup("foo"));
assert_se(strv_push(&a, i) >= 0);
assert_se(streq_ptr(a[3], NULL));
}
-static void test_strv_compare(void) {
+TEST(strv_compare) {
_cleanup_strv_free_ char **a = NULL;
_cleanup_strv_free_ char **b = NULL;
_cleanup_strv_free_ char **c = NULL;
_cleanup_strv_free_ char **d = NULL;
- log_info("/* %s */", __func__);
-
a = strv_new("one", "two", "three");
assert_se(a);
b = strv_new("one", "two", "three");
assert_se(strv_compare(b, NULL) == 1);
}
-static void test_strv_is_uniq(void) {
+TEST(strv_is_uniq) {
_cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
- log_info("/* %s */", __func__);
-
a = strv_new(NULL);
assert_se(a);
assert_se(strv_is_uniq(a));
assert_se(!strv_is_uniq(d));
}
-static void test_strv_reverse(void) {
+TEST(strv_reverse) {
_cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
- log_info("/* %s */", __func__);
-
a = strv_new(NULL);
assert_se(a);
assert_se(streq_ptr(d[3], NULL));
}
-static void test_strv_shell_escape(void) {
+TEST(strv_shell_escape) {
_cleanup_strv_free_ char **v = NULL;
- log_info("/* %s */", __func__);
-
v = strv_new("foo:bar", "bar,baz", "wal\\do");
assert_se(v);
assert_se(strv_shell_escape(v, ",:"));
assert_se(strv_equal(a, b));
}
-static void test_strv_skip(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_skip) {
test_strv_skip_one(STRV_MAKE("foo", "bar", "baz"), 0, STRV_MAKE("foo", "bar", "baz"));
test_strv_skip_one(STRV_MAKE("foo", "bar", "baz"), 1, STRV_MAKE("bar", "baz"));
test_strv_skip_one(STRV_MAKE("foo", "bar", "baz"), 2, STRV_MAKE("baz"));
test_strv_skip_one(STRV_MAKE(NULL), 55, STRV_MAKE(NULL));
}
-static void test_strv_extend_n(void) {
+TEST(strv_extend_n) {
_cleanup_strv_free_ char **v = NULL;
- log_info("/* %s */", __func__);
-
v = strv_new("foo", "bar");
assert_se(v);
assert_se(i == strv_length(l));
}
-static void test_strv_make_nulstr(void) {
- log_info("/* %s */", __func__);
-
+TEST(strv_make_nulstr) {
test_strv_make_nulstr_one(NULL);
test_strv_make_nulstr_one(STRV_MAKE(NULL));
test_strv_make_nulstr_one(STRV_MAKE("foo"));
test_strv_make_nulstr_one(STRV_MAKE("foo", "bar", "quuux"));
}
-static void test_strv_free_free(void) {
+TEST(strv_free_free) {
char ***t;
- log_info("/* %s */", __func__);
-
assert_se(t = new(char**, 3));
assert_se(t[0] = strv_new("a", "b"));
assert_se(t[1] = strv_new("c", "d", "e"));
t = strv_free_free(t);
}
-static void test_foreach_string(void) {
+TEST(foreach_string) {
const char * const t[] = {
"foo",
"bar",
const char *x;
unsigned i = 0;
- log_info("/* %s */", __func__);
-
FOREACH_STRING(x, "foo", "bar", "waldo")
assert_se(streq_ptr(t[i++], x));
assert_se(streq(x, "zzz"));
}
-static void test_strv_fnmatch(void) {
+TEST(strv_fnmatch) {
_cleanup_strv_free_ char **v = NULL;
size_t pos;
- log_info("/* %s */", __func__);
-
assert_se(!strv_fnmatch(STRV_MAKE_EMPTY, "a"));
v = strv_new("xxx", "*\\*", "yyy");
assert_se(pos == 1);
}
-int main(int argc, char *argv[]) {
- test_str_in_set();
- test_strptr_in_set();
- test_startswith_set();
- test_strv_foreach();
- test_strv_foreach_backwards();
- test_strv_foreach_pair();
- test_strv_find();
- test_strv_find_prefix();
- test_strv_find_startswith();
- test_strv_join();
- test_strv_join_full();
-
- test_strv_unquote(" foo=bar \"waldo\" zzz ", STRV_MAKE("foo=bar", "waldo", "zzz"));
- test_strv_unquote("", STRV_MAKE_EMPTY);
- test_strv_unquote(" ", STRV_MAKE_EMPTY);
- test_strv_unquote(" ", STRV_MAKE_EMPTY);
- test_strv_unquote(" x", STRV_MAKE("x"));
- test_strv_unquote("x ", STRV_MAKE("x"));
- test_strv_unquote(" x ", STRV_MAKE("x"));
- test_strv_unquote(" \"x\" ", STRV_MAKE("x"));
- test_strv_unquote(" 'x' ", STRV_MAKE("x"));
- test_strv_unquote(" 'x\"' ", STRV_MAKE("x\""));
- test_strv_unquote(" \"x'\" ", STRV_MAKE("x'"));
- test_strv_unquote("a '--b=c \"d e\"'", STRV_MAKE("a", "--b=c \"d e\""));
-
- /* trailing backslashes */
- test_strv_unquote(" x\\\\", STRV_MAKE("x\\"));
- test_invalid_unquote(" x\\");
-
- test_invalid_unquote("a --b='c \"d e\"''");
- test_invalid_unquote("a --b='c \"d e\" '\"");
- test_invalid_unquote("a --b='c \"d e\"garbage");
- test_invalid_unquote("'");
- test_invalid_unquote("\"");
- test_invalid_unquote("'x'y'g");
-
- test_strv_split();
- test_strv_split_empty();
- test_strv_split_full();
- test_strv_split_and_extend_full();
- test_strv_split_colon_pairs();
- test_strv_split_newlines();
- test_strv_split_newlines_full();
- test_strv_split_nulstr();
- test_strv_parse_nulstr();
- test_strv_overlap();
- test_strv_sort();
- test_strv_extend_strv();
- test_strv_extend_strv_concat();
- test_strv_extend();
- test_strv_extendf();
- test_strv_from_stdarg_alloca();
- test_strv_insert();
- test_strv_push_prepend();
- test_strv_push();
- test_strv_compare();
- test_strv_is_uniq();
- test_strv_reverse();
- test_strv_shell_escape();
- test_strv_skip();
- test_strv_extend_n();
- test_strv_make_nulstr();
- test_strv_free_free();
-
- test_foreach_string();
- test_strv_fnmatch();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "string-util.h"
#include "strxcpyx.h"
+#include "tests.h"
#include "util.h"
-static void test_strpcpy(void) {
+TEST(strpcpy) {
char target[25];
char *s = target;
size_t space_left;
assert_se(space_left == 0);
}
-static void test_strpcpyf(void) {
+TEST(strpcpyf) {
char target[25];
char *s = target;
size_t space_left;
assert_se(target[12] == '2');
}
-static void test_strpcpyl(void) {
+TEST(strpcpyl) {
char target[25];
char *s = target;
size_t space_left;
assert_se(space_left == 1);
}
-static void test_strscpy(void) {
+TEST(strscpy) {
char target[25];
size_t space_left;
assert_se(space_left == 20);
}
-static void test_strscpyl(void) {
+TEST(strscpyl) {
char target[25];
size_t space_left;
assert_se(space_left == 10);
}
-static void test_sd_event_code_migration(void) {
+TEST(sd_event_code_migration) {
char b[100 * DECIMAL_STR_MAX(unsigned) + 1];
char c[100 * DECIMAL_STR_MAX(unsigned) + 1], *p;
unsigned i;
assert_se(streq(b, c));
}
-int main(int argc, char *argv[]) {
- test_strpcpy();
- test_strpcpyf();
- test_strpcpyl();
- test_strscpy();
- test_strscpyl();
-
- test_sd_event_code_migration();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
NULL,
};
-static void test_sysctl_normalize(void) {
- log_info("/* %s */", __func__);
-
+TEST(sysctl_normalize) {
const char **s, **expected;
STRV_FOREACH_PAIR(s, expected, (const char**) cases) {
_cleanup_free_ char *t;
}
}
-static void test_sysctl_read(void) {
+TEST(sysctl_read) {
_cleanup_free_ char *s = NULL, *h = NULL;
sd_id128_t a, b;
int r;
assert_se(r >= 0 || ERRNO_IS_PRIVILEGE(r) || r == -EROFS);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- test_sysctl_normalize();
- test_sysctl_read();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
"in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat " \
"non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
-static void test_default_term_for_tty(void) {
- log_info("/* %s */", __func__);
-
+TEST(default_term_for_tty) {
puts(default_term_for_tty("/dev/tty23"));
puts(default_term_for_tty("/dev/ttyS23"));
puts(default_term_for_tty("/dev/tty0"));
puts(default_term_for_tty("console"));
}
-static void test_read_one_char(void) {
+TEST(read_one_char) {
_cleanup_fclose_ FILE *file = NULL;
char r;
bool need_nl;
char name[] = "/tmp/test-read_one_char.XXXXXX";
- log_info("/* %s */", __func__);
-
assert_se(fmkostemp_safe(name, "r+", &file) == 0);
assert_se(fputs("c\n", file) >= 0);
assert_se(unlink(name) >= 0);
}
-static void test_getttyname_malloc(void) {
+TEST(getttyname_malloc) {
_cleanup_free_ char *ttyname = NULL;
_cleanup_close_ int master = -1;
- log_info("/* %s */", __func__);
-
assert_se((master = posix_openpt(O_RDWR|O_NOCTTY)) >= 0);
assert_se(getttyname_malloc(master, &ttyname) >= 0);
log_info("ttyname = %s", ttyname);
{ "highlight-grey-underline", ansi_highlight_grey_underline },
};
-static void test_colors(void) {
- log_info("/* %s */", __func__);
-
+TEST(colors) {
for (size_t i = 0; i < ELEMENTSOF(colors); i++)
printf("<%s%s%s>\n", colors[i].func(), colors[i].name, ansi_normal());
}
-static void test_text(void) {
- log_info("/* %s */", __func__);
-
+TEST(text) {
for (size_t i = 0; !streq(colors[i].name, "underline"); i++) {
bool blwh = strstr(colors[i].name, "black")
|| strstr(colors[i].name, "white");
}
}
-static void test_get_ctty(void) {
+TEST(get_ctty) {
_cleanup_free_ char *ctty = NULL;
struct stat st;
dev_t devnr;
log_notice("Not invoked with stdin == ctty, cutting get_ctty() test short");
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- test_default_term_for_tty();
- test_read_one_char();
- test_getttyname_malloc();
- test_colors();
- test_text();
- test_get_ctty();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "tests.h"
#include "time-util.h"
-static void test_parse_sec(void) {
+TEST(parse_sec) {
usec_t u;
- log_info("/* %s */", __func__);
-
assert_se(parse_sec("5s", &u) >= 0);
assert_se(u == 5 * USEC_PER_SEC);
assert_se(parse_sec("5s500ms", &u) >= 0);
assert_se(parse_sec("1234..", &u) < 0);
}
-static void test_parse_sec_fix_0(void) {
+TEST(parse_sec_fix_0) {
usec_t u;
- log_info("/* %s */", __func__);
-
assert_se(parse_sec_fix_0("5s", &u) >= 0);
assert_se(u == 5 * USEC_PER_SEC);
assert_se(parse_sec_fix_0("0s", &u) >= 0);
assert_se(u == USEC_INFINITY);
}
-static void test_parse_sec_def_infinity(void) {
+TEST(parse_sec_def_infinity) {
usec_t u;
- log_info("/* %s */", __func__);
-
assert_se(parse_sec_def_infinity("5s", &u) >= 0);
assert_se(u == 5 * USEC_PER_SEC);
assert_se(parse_sec_def_infinity("", &u) >= 0);
assert_se(parse_sec_def_infinity("-5s", &u) < 0);
}
-static void test_parse_time(void) {
+TEST(parse_time) {
usec_t u;
- log_info("/* %s */", __func__);
-
assert_se(parse_time("5", &u, 1) >= 0);
assert_se(u == 5);
assert_se(parse_time("1.1111111111111y", &u, 1) >= 0);
}
-static void test_parse_nsec(void) {
+TEST(parse_nsec) {
nsec_t u;
- log_info("/* %s */", __func__);
-
assert_se(parse_nsec("5s", &u) >= 0);
assert_se(u == 5 * NSEC_PER_SEC);
assert_se(parse_nsec("5s500ms", &u) >= 0);
assert_se(x / accuracy == y / accuracy);
}
-static void test_format_timespan(usec_t accuracy) {
+static void test_format_timespan_accuracy(usec_t accuracy) {
log_info("/* %s accuracy="USEC_FMT" */", __func__, accuracy);
test_format_timespan_one(0, accuracy);
test_format_timespan_one(USEC_INFINITY, accuracy);
}
-static void test_verify_timezone(void) {
- log_info("/* %s */", __func__);
+TEST(format_timespan) {
+ test_format_timespan_accuracy(1);
+ test_format_timespan_accuracy(USEC_PER_MSEC);
+ test_format_timespan_accuracy(USEC_PER_SEC);
+}
+TEST(verify_timezone) {
assert_se(verify_timezone("Europe/Berlin", LOG_DEBUG) == 0);
assert_se(verify_timezone("Australia/Sydney", LOG_DEBUG) == 0);
assert_se(verify_timezone("Europe/Do not exist", LOG_DEBUG) == -EINVAL);
assert_se(verify_timezone("DoNotExist/", LOG_DEBUG) == -EINVAL);
}
-static void test_timezone_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(timezone_is_valid) {
assert_se(timezone_is_valid("Europe/Berlin", LOG_ERR));
assert_se(timezone_is_valid("Australia/Sydney", LOG_ERR));
assert_se(!timezone_is_valid("Europe/Do not exist", LOG_ERR));
}
-static void test_get_timezones(void) {
+TEST(get_timezones) {
_cleanup_strv_free_ char **zones = NULL;
int r;
char **zone;
- log_info("/* %s */", __func__);
-
r = get_timezones(&zones);
assert_se(r == 0);
}
}
-static void test_usec_add(void) {
- log_info("/* %s */", __func__);
-
+TEST(usec_add) {
assert_se(usec_add(0, 0) == 0);
assert_se(usec_add(1, 4) == 5);
assert_se(usec_add(USEC_INFINITY, 5) == USEC_INFINITY);
assert_se(usec_add(USEC_INFINITY, 2) == USEC_INFINITY);
}
-static void test_usec_sub_unsigned(void) {
- log_info("/* %s */", __func__);
-
+TEST(usec_sub_unsigned) {
assert_se(usec_sub_unsigned(0, 0) == 0);
assert_se(usec_sub_unsigned(0, 2) == 0);
assert_se(usec_sub_unsigned(0, USEC_INFINITY) == 0);
assert_se(usec_sub_unsigned(USEC_INFINITY, USEC_INFINITY) == USEC_INFINITY);
}
-static void test_usec_sub_signed(void) {
- log_info("/* %s */", __func__);
-
+TEST(usec_sub_signed) {
assert_se(usec_sub_signed(0, 0) == 0);
assert_se(usec_sub_signed(4, 1) == 3);
assert_se(usec_sub_signed(4, 4) == 0);
assert_se(usec_sub_signed(USEC_INFINITY, 5) == USEC_INFINITY);
}
-static void test_format_timestamp(void) {
- log_info("/* %s */", __func__);
-
+TEST(format_timestamp) {
for (unsigned i = 0; i < 100; i++) {
char buf[MAX(FORMAT_TIMESTAMP_MAX, FORMAT_TIMESPAN_MAX)];
usec_t x, y;
}
}
-static void test_FORMAT_TIMESTAMP(void) {
- log_info("/* %s */", __func__);
-
+TEST(FORMAT_TIMESTAMP) {
for (unsigned i = 0; i < 100; i++) {
_cleanup_free_ char *buf;
usec_t x, y;
}
}
-static void test_format_timestamp_relative(void) {
- log_info("/* %s */", __func__);
-
+TEST(format_timestamp_relative) {
char buf[MAX(FORMAT_TIMESTAMP_MAX, FORMAT_TIMESPAN_MAX)];
usec_t x;
assert_se(streq_ptr(t, result));
}
-static void test_format_timestamp_utc(void) {
- log_info("/* %s */", __func__);
-
+TEST(format_timestamp_utc) {
test_format_timestamp_utc_one(0, NULL);
test_format_timestamp_utc_one(1, "Thu 1970-01-01 00:00:00 UTC");
test_format_timestamp_utc_one(USEC_PER_SEC, "Thu 1970-01-01 00:00:01 UTC");
test_format_timestamp_utc_one(USEC_INFINITY, NULL);
}
-static void test_deserialize_dual_timestamp(void) {
+TEST(deserialize_dual_timestamp) {
int r;
dual_timestamp t;
- log_info("/* %s */", __func__);
-
r = deserialize_dual_timestamp("1234 5678", &t);
assert_se(r == 0);
assert_se(t.realtime == 1234);
assert_se(d < 10*USEC_PER_SEC);
}
-static void test_usec_shift_clock(void) {
+TEST(usec_shift_clock) {
usec_t rt, mn, bt;
- log_info("/* %s */", __func__);
-
rt = now(CLOCK_REALTIME);
mn = now(CLOCK_MONOTONIC);
bt = now(clock_boottime_or_monotonic());
}
}
-static void test_in_utc_timezone(void) {
- log_info("/* %s */", __func__);
-
+TEST(in_utc_timezone) {
const char *tz = getenv("TZ");
assert_se(setenv("TZ", ":UTC", 1) >= 0);
tzset();
}
-static void test_map_clock_usec(void) {
+TEST(map_clock_usec) {
usec_t nowr, x, y, z;
- log_info("/* %s */", __func__);
- nowr = now(CLOCK_REALTIME);
-
- x = nowr; /* right now */
+ x = nowr = now(CLOCK_REALTIME); /* right now */
y = map_clock_usec(x, CLOCK_REALTIME, CLOCK_MONOTONIC);
z = map_clock_usec(y, CLOCK_MONOTONIC, CLOCK_REALTIME);
/* Converting forth and back will introduce inaccuracies, since we cannot query both clocks atomically, but it should be small. Even on the slowest CI smaller than 1h */
}
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
+static void setup_test(void) {
log_info("realtime=" USEC_FMT "\n"
"monotonic=" USEC_FMT "\n"
"boottime=" USEC_FMT "\n",
now(CLOCK_MONOTONIC),
now(clock_boottime_or_monotonic()));
- test_parse_sec();
- test_parse_sec_fix_0();
- test_parse_sec_def_infinity();
- test_parse_time();
- test_parse_nsec();
- test_format_timespan(1);
- test_format_timespan(USEC_PER_MSEC);
- test_format_timespan(USEC_PER_SEC);
- test_verify_timezone();
- test_timezone_is_valid();
- test_get_timezones();
- test_usec_add();
- test_usec_sub_signed();
- test_usec_sub_unsigned();
- test_format_timestamp();
- test_FORMAT_TIMESTAMP();
- test_format_timestamp_relative();
- test_format_timestamp_utc();
- test_deserialize_dual_timestamp();
- test_usec_shift_clock();
- test_in_utc_timezone();
- test_map_clock_usec();
-
/* Ensure time_t is signed */
assert_cc((time_t) -1 < (time_t) 1);
uintmax_t x = TIME_T_MAX;
x++;
assert_se((time_t) x < 0);
-
- return 0;
}
+
+DEFINE_CUSTOM_TEST_MAIN(LOG_INFO, setup_test(), /* no outro */);
assert_se(ret == r);
}
-static void test_tempfn_random(void) {
- log_info("/* %s */", __func__);
-
+TEST(tempfn_random) {
test_tempfn_random_one("", NULL, NULL, -EINVAL);
test_tempfn_random_one(".", NULL, NULL, -EADDRNOTAVAIL);
test_tempfn_random_one("..", NULL, NULL, -EINVAL);
assert_se(ret == r);
}
-static void test_tempfn_xxxxxx(void) {
- log_info("/* %s */", __func__);
-
+TEST(tempfn_xxxxxx) {
test_tempfn_xxxxxx_one("", NULL, NULL, -EINVAL);
test_tempfn_xxxxxx_one(".", NULL, NULL, -EADDRNOTAVAIL);
test_tempfn_xxxxxx_one("..", NULL, NULL, -EINVAL);
test_tempfn_xxxxxx_one("../foo/", "bar", "../.#barfoo", 0);
}
-int main(int argc, char **argv) {
- test_setup_logging(LOG_DEBUG);
-
- test_tempfn_random();
- test_tempfn_xxxxxx();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "tmpfile-util.h"
#include "util.h"
-int main(int argc, char** argv) {
+TEST(tmpfiles) {
_cleanup_free_ char *cmd = NULL, *cmd2 = NULL, *ans = NULL, *ans2 = NULL, *d = NULL, *tmp = NULL, *line = NULL;
_cleanup_close_ int fd = -1, fd2 = -1;
- const char *p = argv[1] ?: "/tmp";
+ const char *p = saved_argv[1] ?: "/tmp";
char *pattern;
- test_setup_logging(LOG_DEBUG);
-
pattern = strjoina(p, "/systemd-test-XXXXXX");
fd = open_tmpfile_unlinkable(p, O_RDWR|O_CLOEXEC);
assert_se(read_one_line_file(d, &line) >= 0);
assert_se(streq(line, "foobar"));
assert_se(unlink(d) >= 0);
-
- return 0;
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "tpm2-util.h"
#include "tests.h"
-static void test_tpm2_parse_pcrs(const char *s, uint32_t mask, int ret) {
+static void test_tpm2_parse_pcrs_one(const char *s, uint32_t mask, int ret) {
uint32_t m;
assert_se(tpm2_parse_pcrs(s, &m) == ret);
assert_se(m == mask);
}
-int main(int argc, char *argv[]) {
-
- test_setup_logging(LOG_DEBUG);
-
- test_tpm2_parse_pcrs("", 0, 0);
- test_tpm2_parse_pcrs("0", 1, 0);
- test_tpm2_parse_pcrs("1", 2, 0);
- test_tpm2_parse_pcrs("0,1", 3, 0);
- test_tpm2_parse_pcrs("0+1", 3, 0);
- test_tpm2_parse_pcrs("0-1", 0, -EINVAL);
- test_tpm2_parse_pcrs("0,1,2", 7, 0);
- test_tpm2_parse_pcrs("0+1+2", 7, 0);
- test_tpm2_parse_pcrs("0+1,2", 7, 0);
- test_tpm2_parse_pcrs("0,1+2", 7, 0);
- test_tpm2_parse_pcrs("0,2", 5, 0);
- test_tpm2_parse_pcrs("0+2", 5, 0);
- test_tpm2_parse_pcrs("foo", 0, -EINVAL);
-
- return 0;
+TEST(tpm2_parse_pcrs) {
+ test_tpm2_parse_pcrs_one("", 0, 0);
+ test_tpm2_parse_pcrs_one("0", 1, 0);
+ test_tpm2_parse_pcrs_one("1", 2, 0);
+ test_tpm2_parse_pcrs_one("0,1", 3, 0);
+ test_tpm2_parse_pcrs_one("0+1", 3, 0);
+ test_tpm2_parse_pcrs_one("0-1", 0, -EINVAL);
+ test_tpm2_parse_pcrs_one("0,1,2", 7, 0);
+ test_tpm2_parse_pcrs_one("0+1+2", 7, 0);
+ test_tpm2_parse_pcrs_one("0+1,2", 7, 0);
+ test_tpm2_parse_pcrs_one("0,1+2", 7, 0);
+ test_tpm2_parse_pcrs_one("0,2", 5, 0);
+ test_tpm2_parse_pcrs_one("0+2", 5, 0);
+ test_tpm2_parse_pcrs_one("foo", 0, -EINVAL);
}
+
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "tmpfile-util.h"
#include "uid-alloc-range.h"
-static void test_read_login_defs(const char *path) {
+static void test_read_login_defs_one(const char *path) {
log_info("/* %s(\"%s\") */", __func__, path ?: "<custom>");
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-user-record.XXXXXX";
}
}
-static void test_acquire_ugid_allocation_range(void) {
- log_info("/* %s */", __func__);
+TEST(read_login_defs) {
+ test_read_login_defs_one("/dev/null");
+ test_read_login_defs_one("/etc/login.defs");
+ test_read_login_defs_one(NULL);
+}
+TEST(acquire_ugid_allocation_range) {
const UGIDAllocationRange *defs;
assert_se(defs = acquire_ugid_allocation_range());
log_info("system_gid_max="GID_FMT, defs->system_gid_max);
}
-static void test_uid_is_system(void) {
- log_info("/* %s */", __func__);
-
+TEST(uid_is_system) {
uid_t uid = 0;
log_info("uid_is_system("UID_FMT") = %s", uid, yes_no(uid_is_system(uid)));
log_info("uid_is_system("UID_FMT") = %s", uid, yes_no(uid_is_system(uid)));
}
-static void test_gid_is_system(void) {
- log_info("/* %s */", __func__);
-
+TEST(gid_is_system) {
gid_t gid = 0;
log_info("gid_is_system("GID_FMT") = %s", gid, yes_no(gid_is_system(gid)));
log_info("gid_is_system("GID_FMT") = %s", gid, yes_no(gid_is_system(gid)));
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_DEBUG);
-
- test_read_login_defs("/dev/null");
- test_read_login_defs("/etc/login.defs");
- test_read_login_defs(NULL);
- test_acquire_ugid_allocation_range();
- test_uid_is_system();
- test_gid_is_system();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
#include "memory-util.h"
#include "sparse-endian.h"
+#include "tests.h"
#include "unaligned.h"
static uint8_t data[] = {
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
};
-static void test_be(void) {
+TEST(be) {
uint8_t scratch[16];
assert_se(unaligned_read_be16(&data[0]) == 0x0001);
assert_se(memcmp(&scratch[7], &data[7], sizeof(uint64_t)) == 0);
}
-static void test_le(void) {
+TEST(le) {
uint8_t scratch[16];
assert_se(unaligned_read_le16(&data[0]) == 0x0100);
assert_se(memcmp(&scratch[7], &data[7], sizeof(uint64_t)) == 0);
}
-static void test_ne(void) {
+TEST(ne) {
uint16_t x = 4711;
uint32_t y = 123456;
uint64_t z = 9876543210;
assert_se(z == 3);
}
-int main(int argc, const char *argv[]) {
- test_be();
- test_le();
- test_ne();
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "tests.h"
#include "unit-file.h"
-static void test_unit_validate_alias_symlink_and_warn(void) {
- log_info("/* %s */", __func__);
-
+TEST(unit_validate_alias_symlink_and_warn) {
assert_se(unit_validate_alias_symlink_and_warn("/path/a.service", "/other/b.service") == 0);
assert_se(unit_validate_alias_symlink_and_warn("/path/a.service", "/other/b.socket") == -EXDEV);
assert_se(unit_validate_alias_symlink_and_warn("/path/a.service", "/other/b.foobar") == -EXDEV);
assert_se(unit_validate_alias_symlink_and_warn("/path/a.slice", "/other/b.slice") == -EINVAL);
}
-static void test_unit_file_build_name_map(char **ids) {
+TEST(unit_file_build_name_map) {
_cleanup_(lookup_paths_free) LookupPaths lp = {};
_cleanup_hashmap_free_ Hashmap *unit_ids = NULL;
_cleanup_hashmap_free_ Hashmap *unit_names = NULL;
const char *k, *dst;
- char **v;
+ char **v, **ids;
usec_t mtime = 0;
int r;
+ ids = strv_skip(saved_argv, 1);
+
assert_se(lookup_paths_init(&lp, UNIT_FILE_SYSTEM, 0, NULL) >= 0);
assert_se(unit_file_build_name_map(&lp, &mtime, &unit_ids, &unit_names, NULL) == 1);
}
}
-static void test_runlevel_to_target(void) {
- log_info("/* %s */", __func__);
-
+TEST(runlevel_to_target) {
in_initrd_force(false);
assert_se(streq_ptr(runlevel_to_target(NULL), NULL));
assert_se(streq_ptr(runlevel_to_target("unknown-runlevel"), NULL));
assert_se(streq_ptr(runlevel_to_target("rd.rescue"), SPECIAL_RESCUE_TARGET));
}
-int main(int argc, char **argv) {
- log_show_color(true);
- test_setup_logging(LOG_DEBUG);
-
- test_unit_validate_alias_symlink_and_warn();
- test_unit_file_build_name_map(strv_skip(argv, 1));
- test_runlevel_to_target();
-
- return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(LOG_DEBUG, log_show_color(true), /* no outro */);
#include "memory-util.h"
#include "path-util.h"
#include "string-util.h"
+#include "tests.h"
#include "user-util.h"
static void test_uid_to_name_one(uid_t uid, const char *name) {
assert_se(streq_ptr(t, name));
}
+TEST(uid_to_name) {
+ test_uid_to_name_one(0, "root");
+ test_uid_to_name_one(UID_NOBODY, NOBODY_USER_NAME);
+ test_uid_to_name_one(0xFFFF, "65535");
+ test_uid_to_name_one(0xFFFFFFFF, "4294967295");
+}
+
static void test_gid_to_name_one(gid_t gid, const char *name) {
_cleanup_free_ char *t = NULL;
assert_se(streq_ptr(t, name));
}
-static void test_parse_uid(void) {
+TEST(gid_to_name) {
+ test_gid_to_name_one(0, "root");
+ test_gid_to_name_one(GID_NOBODY, NOBODY_GROUP_NAME);
+ test_gid_to_name_one(TTY_GID, "tty");
+ test_gid_to_name_one(0xFFFF, "65535");
+ test_gid_to_name_one(0xFFFFFFFF, "4294967295");
+}
+
+TEST(parse_uid) {
int r;
uid_t uid;
- log_info("/* %s */", __func__);
-
r = parse_uid("0", &uid);
assert_se(r == 0);
assert_se(uid == 0);
assert_se(uid == 100);
}
-static void test_uid_ptr(void) {
- log_info("/* %s */", __func__);
-
+TEST(uid_ptr) {
assert_se(UID_TO_PTR(0) != NULL);
assert_se(UID_TO_PTR(1000) != NULL);
assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
}
-static void test_valid_user_group_name_relaxed(void) {
- log_info("/* %s */", __func__);
-
+TEST(valid_user_group_name_relaxed) {
assert_se(!valid_user_group_name(NULL, VALID_USER_RELAX));
assert_se(!valid_user_group_name("", VALID_USER_RELAX));
assert_se(!valid_user_group_name("1", VALID_USER_RELAX));
assert_se(valid_user_group_name("Dāvis", VALID_USER_RELAX));
}
-static void test_valid_user_group_name(void) {
- log_info("/* %s */", __func__);
-
+TEST(valid_user_group_name) {
assert_se(!valid_user_group_name(NULL, 0));
assert_se(!valid_user_group_name("", 0));
assert_se(!valid_user_group_name("1", 0));
assert_se(!valid_user_group_name("Dāvis", 0));
}
-static void test_valid_user_group_name_or_numeric_relaxed(void) {
- log_info("/* %s */", __func__);
-
+TEST(valid_user_group_name_or_numeric_relaxed) {
assert_se(!valid_user_group_name(NULL, VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
assert_se(!valid_user_group_name("", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
assert_se(valid_user_group_name("0", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
assert_se(valid_user_group_name("Dāvis", VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX));
}
-static void test_valid_user_group_name_or_numeric(void) {
- log_info("/* %s */", __func__);
-
+TEST(valid_user_group_name_or_numeric) {
assert_se(!valid_user_group_name(NULL, VALID_USER_ALLOW_NUMERIC));
assert_se(!valid_user_group_name("", VALID_USER_ALLOW_NUMERIC));
assert_se(valid_user_group_name("0", VALID_USER_ALLOW_NUMERIC));
assert_se(!valid_user_group_name("Dāvis", VALID_USER_ALLOW_NUMERIC));
}
-static void test_valid_gecos(void) {
- log_info("/* %s */", __func__);
-
+TEST(valid_gecos) {
assert_se(!valid_gecos(NULL));
assert_se(valid_gecos(""));
assert_se(valid_gecos("test"));
assert_se(!valid_gecos("In:valid"));
}
-static void test_valid_home(void) {
- log_info("/* %s */", __func__);
-
+TEST(valid_home) {
assert_se(!valid_home(NULL));
assert_se(!valid_home(""));
assert_se(!valid_home("."));
assert_se(path_equal(rshell, shell));
}
+TEST(get_user_creds) {
+ test_get_user_creds_one("root", "root", 0, 0, "/root", "/bin/sh");
+ test_get_user_creds_one("0", "root", 0, 0, "/root", "/bin/sh");
+ test_get_user_creds_one(NOBODY_USER_NAME, NOBODY_USER_NAME, UID_NOBODY, GID_NOBODY, "/", NOLOGIN);
+ test_get_user_creds_one("65534", NOBODY_USER_NAME, UID_NOBODY, GID_NOBODY, "/", NOLOGIN);
+}
+
static void test_get_group_creds_one(const char *id, const char *name, gid_t gid) {
gid_t rgid = GID_INVALID;
int r;
assert_se(rgid == gid);
}
-static void test_make_salt(void) {
- log_info("/* %s */", __func__);
+TEST(get_group_creds) {
+ test_get_group_creds_one("root", "root", 0);
+ test_get_group_creds_one("0", "root", 0);
+ test_get_group_creds_one(NOBODY_GROUP_NAME, NOBODY_GROUP_NAME, GID_NOBODY);
+ test_get_group_creds_one("65534", NOBODY_GROUP_NAME, GID_NOBODY);
+}
+TEST(make_salt) {
_cleanup_free_ char *s, *t;
assert_se(make_salt(&s) == 0);
assert_se(!streq(s, t));
}
-static void test_in_gid(void) {
+TEST(in_gid) {
assert_se(in_gid(getgid()) >= 0);
assert_se(in_gid(getegid()) >= 0);
assert_se(in_gid(GID_INVALID) < 0);
assert_se(in_gid(TTY_GID) == 0); /* The TTY gid is for owning ttys, it would be really really weird if we were in it. */
}
-static void test_gid_lists_ops(void) {
+TEST(gid_lists_ops) {
static const gid_t l1[] = { 5, 10, 15, 20, 25};
static const gid_t l2[] = { 1, 2, 3, 15, 20, 25};
static const gid_t l3[] = { 5, 10, 15, 20, 25, 26, 27};
assert_se(gids);
}
-static void test_parse_uid_range(void) {
+TEST(parse_uid_range) {
uid_t a = 4711, b = 4711;
- log_info("/* %s */", __func__);
-
assert_se(parse_uid_range("", &a, &b) == -EINVAL && a == 4711 && b == 4711);
assert_se(parse_uid_range(" ", &a, &b) == -EINVAL && a == 4711 && b == 4711);
assert_se(parse_uid_range("x", &a, &b) == -EINVAL && a == 4711 && b == 4711);
assert_se(valid_gecos(p));
}
-static void test_mangle_gecos(void) {
+TEST(mangle_gecos) {
test_mangle_gecos_one("", "");
test_mangle_gecos_one("root", "root");
test_mangle_gecos_one("wuff\nwuff", "wuff wuff");
test_mangle_gecos_one("\xe2\x28\xa1", " ( ");
}
-int main(int argc, char *argv[]) {
- test_uid_to_name_one(0, "root");
- test_uid_to_name_one(UID_NOBODY, NOBODY_USER_NAME);
- test_uid_to_name_one(0xFFFF, "65535");
- test_uid_to_name_one(0xFFFFFFFF, "4294967295");
-
- test_gid_to_name_one(0, "root");
- test_gid_to_name_one(GID_NOBODY, NOBODY_GROUP_NAME);
- test_gid_to_name_one(TTY_GID, "tty");
- test_gid_to_name_one(0xFFFF, "65535");
- test_gid_to_name_one(0xFFFFFFFF, "4294967295");
-
- test_get_user_creds_one("root", "root", 0, 0, "/root", "/bin/sh");
- test_get_user_creds_one("0", "root", 0, 0, "/root", "/bin/sh");
- test_get_user_creds_one(NOBODY_USER_NAME, NOBODY_USER_NAME, UID_NOBODY, GID_NOBODY, "/", NOLOGIN);
- test_get_user_creds_one("65534", NOBODY_USER_NAME, UID_NOBODY, GID_NOBODY, "/", NOLOGIN);
-
- test_get_group_creds_one("root", "root", 0);
- test_get_group_creds_one("0", "root", 0);
- test_get_group_creds_one(NOBODY_GROUP_NAME, NOBODY_GROUP_NAME, GID_NOBODY);
- test_get_group_creds_one("65534", NOBODY_GROUP_NAME, GID_NOBODY);
-
- test_parse_uid();
- test_uid_ptr();
-
- test_valid_user_group_name_relaxed();
- test_valid_user_group_name();
- test_valid_user_group_name_or_numeric_relaxed();
- test_valid_user_group_name_or_numeric();
- test_valid_gecos();
- test_mangle_gecos();
- test_valid_home();
-
- test_make_salt();
-
- test_in_gid();
- test_gid_lists_ops();
-
- test_parse_uid_range();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "utf8.h"
#include "util.h"
-static void test_utf8_is_printable(void) {
- log_info("/* %s */", __func__);
-
+TEST(utf8_is_printable) {
assert_se(utf8_is_printable("ascii is valid\tunicode", 22));
assert_se(utf8_is_printable("\342\204\242", 3));
assert_se(!utf8_is_printable("\341\204", 2));
assert_se(utf8_is_printable("\t", 1));
}
-static void test_utf8_n_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(utf8_n_is_valid) {
assert_se( utf8_is_valid_n("ascii is valid unicode", 21));
assert_se( utf8_is_valid_n("ascii is valid unicode", 22));
assert_se(!utf8_is_valid_n("ascii is valid unicode", 23));
assert_se(!utf8_is_valid_n("<ZZ>", 5));
}
-static void test_utf8_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(utf8_is_valid) {
assert_se(utf8_is_valid("ascii is valid unicode"));
assert_se(utf8_is_valid("\342\204\242"));
assert_se(!utf8_is_valid("\341\204"));
}
-static void test_ascii_is_valid(void) {
- log_info("/* %s */", __func__);
-
+TEST(ascii_is_valid) {
assert_se( ascii_is_valid("alsdjf\t\vbarr\nba z"));
assert_se(!ascii_is_valid("\342\204\242"));
assert_se(!ascii_is_valid("\341\204"));
}
-static void test_ascii_is_valid_n(void) {
- log_info("/* %s */", __func__);
-
+TEST(ascii_is_valid_n) {
assert_se( ascii_is_valid_n("alsdjf\t\vbarr\nba z", 17));
assert_se( ascii_is_valid_n("alsdjf\t\vbarr\nba z", 16));
assert_se(!ascii_is_valid_n("alsdjf\t\vbarr\nba z", 18));
assert_se(streq_ptr(ans, expected));
}
-static void test_utf8_to_ascii(void) {
- log_info("/* %s */", __func__);
-
+TEST(utf8_to_ascii) {
test_utf8_to_ascii_one("asdf", 0, "asdf");
test_utf8_to_ascii_one("dąb", 0, "d*b");
test_utf8_to_ascii_one("żęśłą óźń", 0, "***** ***");
test_utf8_to_ascii_one("…👊🔪💐…", 0, "*****");
}
-static void test_utf8_encoded_valid_unichar(void) {
- log_info("/* %s */", __func__);
-
+TEST(utf8_encoded_valid_unichar) {
assert_se(utf8_encoded_valid_unichar("\342\204\242", 1) == -EINVAL); /* truncated */
assert_se(utf8_encoded_valid_unichar("\342\204\242", 2) == -EINVAL); /* truncated */
assert_se(utf8_encoded_valid_unichar("\342\204\242", 3) == 3);
assert_se(utf8_encoded_valid_unichar("\341\204\341\204", 5) == -EINVAL);
}
-static void test_utf8_escape_invalid(void) {
+TEST(utf8_escape_invalid) {
_cleanup_free_ char *p1, *p2, *p3;
- log_info("/* %s */", __func__);
-
p1 = utf8_escape_invalid("goo goo goo");
log_debug("\"%s\"", p1);
assert_se(utf8_is_valid(p1));
assert_se(utf8_is_valid(p3));
}
-static void test_utf8_escape_non_printable(void) {
+TEST(utf8_escape_non_printable) {
_cleanup_free_ char *p1, *p2, *p3, *p4, *p5, *p6;
- log_info("/* %s */", __func__);
-
p1 = utf8_escape_non_printable("goo goo goo");
log_debug("\"%s\"", p1);
assert_se(utf8_is_valid(p1));
assert_se(utf8_is_valid(p6));
}
-static void test_utf8_escape_non_printable_full(void) {
- log_info("/* %s */", __func__);
-
+TEST(utf8_escape_non_printable_full) {
const char *s;
FOREACH_STRING(s,
"goo goo goo", /* ASCII */
}
}
-static void test_utf16_to_utf8(void) {
+TEST(utf16_to_utf8) {
const char16_t utf16[] = { htole16('a'), htole16(0xd800), htole16('b'), htole16(0xdc00), htole16('c'), htole16(0xd801), htole16(0xdc37) };
static const char utf8[] = { 'a', 'b', 'c', 0xf0, 0x90, 0x90, 0xb7 };
_cleanup_free_ char16_t *b = NULL;
_cleanup_free_ char *a = NULL;
- log_info("/* %s */", __func__);
-
/* Convert UTF-16 to UTF-8, filtering embedded bad chars */
a = utf16_to_utf8(utf16, sizeof(utf16));
assert_se(a);
assert_se(memcmp(a, utf8, sizeof(utf8)) == 0);
}
-static void test_utf8_n_codepoints(void) {
- log_info("/* %s */", __func__);
-
+TEST(utf8_n_codepoints) {
assert_se(utf8_n_codepoints("abc") == 3);
assert_se(utf8_n_codepoints("zażółcić gęślą jaźń") == 19);
assert_se(utf8_n_codepoints("串") == 1);
assert_se(utf8_n_codepoints("\xF1") == SIZE_MAX);
}
-static void test_utf8_console_width(void) {
- log_info("/* %s */", __func__);
-
+TEST(utf8_console_width) {
assert_se(utf8_console_width("abc") == 3);
assert_se(utf8_console_width("zażółcić gęślą jaźń") == 19);
assert_se(utf8_console_width("串") == 2);
assert_se(utf8_console_width("\xF1") == SIZE_MAX);
}
-static void test_utf8_to_utf16(void) {
+TEST(utf8_to_utf16) {
const char *p;
- log_info("/* %s */", __func__);
-
FOREACH_STRING(p,
"abc",
"zażółcić gęślą jaźń",
}
}
-int main(int argc, char *argv[]) {
- log_show_color(true);
- test_setup_logging(LOG_INFO);
-
- test_utf8_n_is_valid();
- test_utf8_is_valid();
- test_utf8_is_printable();
- test_ascii_is_valid();
- test_ascii_is_valid_n();
- test_utf8_to_ascii();
- test_utf8_encoded_valid_unichar();
- test_utf8_escape_invalid();
- test_utf8_escape_non_printable();
- test_utf8_escape_non_printable_full();
- test_utf16_to_utf8();
- test_utf8_n_codepoints();
- test_utf8_console_width();
- test_utf8_to_utf16();
-
- return 0;
-}
+DEFINE_CUSTOM_TEST_MAIN(LOG_INFO, log_show_color(true), /* no outro */);
#include "tests.h"
#include "util.h"
-static void test_u64log2(void) {
- log_info("/* %s */", __func__);
-
+TEST(u64log2) {
assert_se(u64log2(0) == 0);
assert_se(u64log2(8) == 3);
assert_se(u64log2(9) == 3);
assert_se(u64log2(1024*1024+5) == 20);
}
-static void test_protect_errno(void) {
- log_info("/* %s */", __func__);
-
+TEST(protect_errno) {
errno = 12;
{
PROTECT_ERRNO;
errno = 2222;
}
-static void test_unprotect_errno(void) {
- log_info("/* %s */", __func__);
-
+TEST(unprotect_errno) {
errno = 4711;
PROTECT_ERRNO;
assert_se(errno == 4711);
}
-static void test_log2i(void) {
- log_info("/* %s */", __func__);
-
+TEST(log2i) {
assert_se(log2i(1) == 0);
assert_se(log2i(2) == 1);
assert_se(log2i(3) == 1);
assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
}
-static void test_eqzero(void) {
+TEST(eqzero) {
const uint32_t zeros[] = {0, 0, 0};
const uint32_t ones[] = {1, 1};
const uint32_t mixed[] = {0, 1, 0, 0, 0};
const uint8_t longer[] = {[55] = 255};
- log_info("/* %s */", __func__);
-
assert_se(eqzero(zeros));
assert_se(!eqzero(ones));
assert_se(!eqzero(mixed));
assert_se(!eqzero(longer));
}
-static void test_raw_clone(void) {
+TEST(raw_clone) {
pid_t parent, pid, pid2;
- log_info("/* %s */", __func__);
-
parent = getpid();
log_info("before clone: getpid()→"PID_FMT, parent);
assert_se(raw_getpid() == parent);
assert_se(errno == EINVAL || ERRNO_IS_PRIVILEGE(errno)); /* Certain container environments prohibit namespaces to us, don't fail in that case */
}
-static void test_physical_memory(void) {
+TEST(physical_memory) {
uint64_t p;
- log_info("/* %s */", __func__);
-
p = physical_memory();
assert_se(p > 0);
assert_se(p < UINT64_MAX);
log_info("Memory: %s (%" PRIu64 ")", FORMAT_BYTES(p), p);
}
-static void test_physical_memory_scale(void) {
+TEST(physical_memory_scale) {
uint64_t p;
- log_info("/* %s */", __func__);
-
p = physical_memory();
assert_se(physical_memory_scale(0, 100) == 0);
assert_se(physical_memory_scale(UINT64_MAX/4, UINT64_MAX) == UINT64_MAX);
}
-static void test_system_tasks_max(void) {
+TEST(system_tasks_max) {
uint64_t t;
- log_info("/* %s */", __func__);
-
t = system_tasks_max();
assert_se(t > 0);
assert_se(t < UINT64_MAX);
log_info("Max tasks: %" PRIu64, t);
}
-static void test_system_tasks_max_scale(void) {
+TEST(system_tasks_max_scale) {
uint64_t t;
- log_info("/* %s */", __func__);
-
t = system_tasks_max();
assert_se(system_tasks_max_scale(0, 100) == 0);
assert_se(system_tasks_max_scale(UINT64_MAX/4, UINT64_MAX) == UINT64_MAX);
}
-int main(int argc, char *argv[]) {
- test_setup_logging(LOG_INFO);
-
- test_u64log2();
- test_protect_errno();
- test_unprotect_errno();
- test_log2i();
- test_eqzero();
- test_raw_clone();
- test_physical_memory();
- test_physical_memory_scale();
- test_system_tasks_max();
- test_system_tasks_max_scale();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "macro.h"
#include "strv.h"
+#include "tests.h"
#include "verbs.h"
static int noop_dispatcher(int argc, char *argv[], void *userdata) {
optind = 0; \
assert_se(dispatch_verb(strv_length(argv), argv, verbs, NULL) == expected);
-static void test_verbs(void) {
+TEST(verbs) {
static const Verb verbs[] = {
{ "help", VERB_ANY, VERB_ANY, 0, noop_dispatcher },
{ "list-images", VERB_ANY, 1, 0, noop_dispatcher },
test_dispatch_one(STRV_MAKE_EMPTY, verbs, 0);
}
-static void test_verbs_no_default(void) {
+TEST(verbs_no_default) {
static const Verb verbs[] = {
{ "help", VERB_ANY, VERB_ANY, 0, noop_dispatcher },
{},
test_dispatch_one(STRV_MAKE(NULL), verbs, -EINVAL);
}
-int main(int argc, char *argv[]) {
- test_verbs();
- test_verbs_no_default();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "macro.h"
+#include "tests.h"
#include "web-util.h"
-static void test_is_valid_documentation_url(void) {
+TEST(is_valid_documentation_url) {
assert_se(documentation_url_is_valid("http://www.freedesktop.org/wiki/Software/systemd"));
assert_se(documentation_url_is_valid("https://www.kernel.org/doc/Documentation/binfmt_misc.txt")); /* dead */
assert_se(documentation_url_is_valid("https://www.kernel.org/doc/Documentation/admin-guide/binfmt-misc.rst"));
assert_se(!documentation_url_is_valid(""));
}
-int main(int argc, char *argv[]) {
- test_is_valid_documentation_url();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_INFO);
#include "tmpfile-util.h"
#include "xattr-util.h"
-static void test_getxattr_at_malloc(void) {
+TEST(getxattr_at_malloc) {
char t[] = "/var/tmp/xattrtestXXXXXX";
_cleanup_free_ char *value = NULL;
_cleanup_close_ int fd = -1;
const char *x;
int r;
- log_info("/* %s */", __func__);
-
assert_se(mkdtemp(t));
x = strjoina(t, "/test");
assert_se(touch(x) >= 0);
assert_se(rmdir(t) >= 0);
}
-static void test_getcrtime(void) {
+TEST(getcrtime) {
_cleanup_close_ int fd = -1;
const char *vt;
usec_t usec, k;
int r;
- log_info("/* %s */", __func__);
-
assert_se(var_tmp_dir(&vt) >= 0);
fd = open_tmpfile_unlinkable(vt, O_RDWR);
}
}
-int main(void) {
- test_setup_logging(LOG_DEBUG);
-
- test_getxattr_at_malloc();
- test_getcrtime();
-
- return 0;
-}
+DEFINE_TEST_MAIN(LOG_DEBUG);
projects / thirdparty / systemd.git / commitdiff
