dasharo/systemd
0
0
Fork 0
mirror of https://github.com/Dasharo/systemd.git synced 2026-03-06 15:02:31 -08:00
Code Issues Packages Projects Releases Wiki Activity

ASSERT_STREQ for simple cases

Browse Source
This commit is contained in:
Ivan Kruglov
2024-04-10 13:19:39 +02:00
committed by Daan De Meyer
parent 9506269d12
commit c79e88b37d
93 changed files with 1502 additions and 1502 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/test/test-bootspec.c
View File

@@ -79,16 +79,16 @@ TEST_RET(bootspec_sort) {
assert_se(config.n_entries == 6);
/* First, because has sort key, and its the lowest one */
assert_se(streq(config.entries[0].id, "d.conf"));
ASSERT_STREQ(config.entries[0].id, "d.conf");
/* These two have a sort key, and newest must be first */
assert_se(streq(config.entries[1].id, "cx.conf"));
assert_se(streq(config.entries[2].id, "c.conf"));
ASSERT_STREQ(config.entries[1].id, "cx.conf");
ASSERT_STREQ(config.entries[2].id, "c.conf");
/* The following ones have no sort key, hence order by version compared ids, lowest first */
assert_se(streq(config.entries[3].id, "b.conf"));
assert_se(streq(config.entries[4].id, "a-10.conf"));
assert_se(streq(config.entries[5].id, "a-5.conf"));
ASSERT_STREQ(config.entries[3].id, "b.conf");
ASSERT_STREQ(config.entries[4].id, "a-10.conf");
ASSERT_STREQ(config.entries[5].id, "a-5.conf");
return 0;
}
@@ -101,7 +101,7 @@ static void test_extract_tries_one(const char *fname, int ret, const char *strip
if (ret < 0)
return;
assert_se(streq_ptr(p, stripped));
ASSERT_STREQ(p, stripped);
assert_se(l == tries_left);
assert_se(d == tries_done);
}

6
src/test/test-cap-list.c
View File

@@ -21,7 +21,7 @@ TEST(cap_list) {
assert_se(!CAPABILITY_TO_STRING(-1));
if (capability_list_length() <= 62)
assert_se(streq(CAPABILITY_TO_STRING(62), "0x3e"));
ASSERT_STREQ(CAPABILITY_TO_STRING(62), "0x3e");
assert_se(!CAPABILITY_TO_STRING(64));
for (int i = 0; i < capability_list_length(); i++) {
@@ -31,7 +31,7 @@ TEST(cap_list) {
assert_se(capability_from_name(n) == i);
printf("%s = %i\n", n, i);
assert_se(streq(CAPABILITY_TO_STRING(i), n));
ASSERT_STREQ(CAPABILITY_TO_STRING(i), n);
}
assert_se(capability_from_name("asdfbsd") == -EINVAL);
@@ -70,7 +70,7 @@ static void test_capability_set_one(uint64_t c, const char *t) {
uint64_t c1, c_masked = c & all_capabilities();
assert_se(capability_set_to_string(c, &t1) == 0);
assert_se(streq(t1, t));
ASSERT_STREQ(t1, t);
assert_se(capability_set_from_string(t1, &c1) > 0);
assert_se(c1 == c_masked);

4
src/test/test-cgroup-mask.c
View File

@@ -135,7 +135,7 @@ static void test_cg_mask_to_string_one(CGroupMask mask, const char *t) {
_cleanup_free_ char *b = NULL;
assert_se(cg_mask_to_string(mask, &b) >= 0);
assert_se(streq_ptr(b, t));
ASSERT_STREQ(b, t);
}
TEST(cg_mask_to_string) {
@@ -157,7 +157,7 @@ TEST(cg_mask_to_string) {
}
static void cgroup_device_permissions_test_normalize(const char *a, const char *b) {
assert_se(streq_ptr(cgroup_device_permissions_to_string(cgroup_device_permissions_from_string(a)), b));
ASSERT_STREQ(cgroup_device_permissions_to_string(cgroup_device_permissions_from_string(a)), b);
}
TEST(cgroup_device_permissions) {

22
src/test/test-cgroup-util.c
View File

@@ -23,7 +23,7 @@ static void check_p_d_u(const char *path, int code, const char *result) {
r = cg_path_decode_unit(path, &unit);
printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit, r, strnull(result), code);
assert_se(r == code);
assert_se(streq_ptr(unit, result));
ASSERT_STREQ(unit, result);
}
TEST(path_decode_unit) {
@@ -45,7 +45,7 @@ static void check_p_g_u(const char *path, int code, const char *result) {
r = cg_path_get_unit(path, &unit);
printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit, r, strnull(result), code);
assert_se(r == code);
assert_se(streq_ptr(unit, result));
ASSERT_STREQ(unit, result);
}
TEST(path_get_unit) {
@@ -69,7 +69,7 @@ static void check_p_g_u_p(const char *path, int code, const char *result) {
r = cg_path_get_unit_path(path, &unit_path);
printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit_path, r, strnull(result), code);
assert_se(r == code);
assert_se(streq_ptr(unit_path, result));
ASSERT_STREQ(unit_path, result);
}
TEST(path_get_unit_path) {
@@ -96,7 +96,7 @@ static void check_p_g_u_u(const char *path, int code, const char *result) {
r = cg_path_get_user_unit(path, &unit);
printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit, r, strnull(result), code);
assert_se(r == code);
assert_se(streq_ptr(unit, result));
ASSERT_STREQ(unit, result);
}
TEST(path_get_user_unit) {
@@ -119,7 +119,7 @@ static void check_p_g_s(const char *path, int code, const char *result) {
_cleanup_free_ char *s = NULL;
assert_se(cg_path_get_session(path, &s) == code);
assert_se(streq_ptr(s, result));
ASSERT_STREQ(s, result);
}
TEST(path_get_session) {
@@ -146,7 +146,7 @@ static void check_p_g_slice(const char *path, int code, const char *result) {
_cleanup_free_ char *s = NULL;
assert_se(cg_path_get_slice(path, &s) == code);
assert_se(streq_ptr(s, result));
ASSERT_STREQ(s, result);
}
TEST(path_get_slice) {
@@ -163,7 +163,7 @@ static void check_p_g_u_slice(const char *path, int code, const char *result) {
_cleanup_free_ char *s = NULL;
assert_se(cg_path_get_user_slice(path, &s) == code);
assert_se(streq_ptr(s, result));
ASSERT_STREQ(s, result);
}
TEST(path_get_user_slice) {
@@ -239,9 +239,9 @@ static void test_escape_one(const char *s, const char *expected) {
assert_se(expected);
ASSERT_OK(cg_escape(s, &b));
assert_se(streq(b, expected));
ASSERT_STREQ(b, expected);
assert_se(streq(cg_unescape(b), s));
ASSERT_STREQ(cg_unescape(b), s);
assert_se(filename_is_valid(b));
assert_se(!cg_needs_escape(s) || b[0] == '_');
@@ -284,7 +284,7 @@ static void test_slice_to_path_one(const char *unit, const char *path, int error
log_info("actual: %s / %d", strnull(ret), r);
log_info("expect: %s / %d", strnull(path), error);
assert_se(r == error);
assert_se(streq_ptr(ret, path));
ASSERT_STREQ(ret, path);
}
TEST(slice_to_path) {
@@ -316,7 +316,7 @@ static void test_shift_path_one(const char *raw, const char *root, const char *s
const char *s = NULL;
ASSERT_OK(cg_shift_path(raw, root, &s));
assert_se(streq(s, shifted));
ASSERT_STREQ(s, shifted);
}
TEST(shift_path) {

10
src/test/test-cgroup.c
View File

@@ -15,8 +15,8 @@ TEST(cg_split_spec) {
char *c, *p;
assert_se(cg_split_spec("foobar:/", &c, &p) == 0);
assert_se(streq(c, "foobar"));
assert_se(streq(p, "/"));
ASSERT_STREQ(c, "foobar");
ASSERT_STREQ(p, "/");
c = mfree(c);
p = mfree(p);
@@ -32,11 +32,11 @@ TEST(cg_split_spec) {
assert_se(cg_split_spec("/", &c, &p) >= 0);
ASSERT_NULL(c);
assert_se(streq(p, "/"));
ASSERT_STREQ(p, "/");
p = mfree(p);
assert_se(cg_split_spec("foo", &c, &p) >= 0);
assert_se(streq(c, "foo"));
ASSERT_STREQ(c, "foo");
ASSERT_NULL(p);
c = mfree(c);
}
@@ -79,7 +79,7 @@ TEST(cg_create) {
assert_se(cg_create_and_attach(SYSTEMD_CGROUP_CONTROLLER, test_b, 0) == 0);
assert_se(cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, getpid_cached(), &path) == 0);
assert_se(streq(path, test_b));
ASSERT_STREQ(path, test_b);
free(path);
assert_se(cg_attach(SYSTEMD_CGROUP_CONTROLLER, test_a, 0) == 0);

6
src/test/test-chase.c
View File

@@ -23,7 +23,7 @@ static void test_chase_extract_filename_one(const char *path, const char *root,
log_debug("/* %s(path=%s, root=%s) */", __func__, path, strnull(root));
assert_se(chase(path, root, CHASE_EXTRACT_FILENAME, &ret1, NULL) > 0);
assert_se(streq(ret1, expected));
ASSERT_STREQ(ret1, expected);
assert_se(chase(path, root, 0, &ret2, NULL) > 0);
ASSERT_OK(chase_extract_filename(ret2, root, &fname));
@@ -173,7 +173,7 @@ TEST(chase) {
r = chase(p, NULL, 0, &result, NULL);
assert_se(r > 0);
assert_se(path_equal(result, "/usr"));
assert_se(streq(result, "/usr")); /* we guarantee that we drop redundant slashes */
ASSERT_STREQ(result, "/usr"); /* we guarantee that we drop redundant slashes */
result = mfree(result);
r = chase(p, temp, 0, &result, NULL);
@@ -718,7 +718,7 @@ TEST(chaseat_prefix_root) {
assert_se(chaseat_prefix_root("./hoge/aaa/../././b", "a/b//./c///", &ret) >= 0);
assert_se(expected = path_join(cwd, "a/b/c/hoge/aaa/../././b"));
assert_se(streq(ret, expected));
ASSERT_STREQ(ret, expected);
}
TEST(trailing_dot_dot) {

38
src/test/test-conf-parser.c
View File

@@ -16,7 +16,7 @@ static void test_config_parse_path_one(const char *rvalue, const char *expected)
_cleanup_free_ char *path = NULL;
assert_se(config_parse_path("unit", "filename", 1, "section", 1, "lvalue", 0, rvalue, &path, NULL) >= 0);
assert_se(streq_ptr(expected, path));
ASSERT_STREQ(expected, path);
}
static void test_config_parse_log_level_one(const char *rvalue, int expected) {
@@ -352,27 +352,27 @@ static void test_config_parse_one(unsigned i, const char *s) {
switch (i) {
case 0 ... 4:
assert_se(r == 1);
assert_se(streq(setting1, "1"));
ASSERT_STREQ(setting1, "1");
break;
case 5 ... 10:
assert_se(r == 1);
assert_se(streq(setting1, "1 2 3"));
ASSERT_STREQ(setting1, "1 2 3");
break;
case 11:
assert_se(r == 1);
assert_se(streq(setting1, "1\\\\ \\\\2"));
ASSERT_STREQ(setting1, "1\\\\ \\\\2");
break;
case 12:
assert_se(r == 1);
assert_se(streq(setting1, x1000("ABCD")));
ASSERT_STREQ(setting1, x1000("ABCD"));
break;
case 13 ... 14:
assert_se(r == 1);
assert_se(streq(setting1, x1000("ABCD") " foobar"));
ASSERT_STREQ(setting1, x1000("ABCD") " foobar");
break;
case 15 ... 16:
@@ -382,7 +382,7 @@ static void test_config_parse_one(unsigned i, const char *s) {
case 17:
assert_se(r == 1);
assert_se(streq(setting1, "2"));
ASSERT_STREQ(setting1, "2");
break;
}
}
@@ -443,12 +443,12 @@ TEST(config_parse_standard_file_with_dropins_full) {
/* ret_stats_by_path= */ NULL,
/* ret_dropin_files= */ &dropins);
assert_se(r >= 0);
assert_se(streq_ptr(A, "aaa"));
assert_se(streq_ptr(B, "bbb"));
assert_se(streq_ptr(C, "c1"));
assert_se(streq_ptr(D, "ddd"));
assert_se(streq_ptr(E, "eee"));
assert_se(streq_ptr(F, NULL));
ASSERT_STREQ(A, "aaa");
ASSERT_STREQ(B, "bbb");
ASSERT_STREQ(C, "c1");
ASSERT_STREQ(D, "ddd");
ASSERT_STREQ(E, "eee");
ASSERT_STREQ(F, NULL);
A = mfree(A);
B = mfree(B);
@@ -482,12 +482,12 @@ TEST(config_parse_standard_file_with_dropins_full) {
/* ret_stats_by_path= */ NULL,
/* ret_dropin_files= */ NULL);
assert_se(r >= 0);
assert_se(streq_ptr(A, "aaa"));
assert_se(streq_ptr(B, "bbb"));
assert_se(streq_ptr(C, "c1"));
assert_se(streq_ptr(D, "ddd"));
assert_se(streq_ptr(E, "eee"));
assert_se(streq_ptr(F, NULL));
ASSERT_STREQ(A, "aaa");
ASSERT_STREQ(B, "bbb");
ASSERT_STREQ(C, "c1");
ASSERT_STREQ(D, "ddd");
ASSERT_STREQ(E, "eee");
ASSERT_STREQ(F, NULL);
}
DEFINE_TEST_MAIN(LOG_INFO);

18
src/test/test-copy.c
View File

@@ -45,7 +45,7 @@ TEST(copy_file) {
assert_se(copy_file(fn, fn_copy, 0, 0644, COPY_REFLINK) == 0);
assert_se(read_full_file(fn_copy, &buf, &sz) == 0);
assert_se(streq(buf, "foo bar bar bar foo\n"));
ASSERT_STREQ(buf, "foo bar bar bar foo\n");
assert_se(sz == 20);
}
@@ -125,7 +125,7 @@ TEST(copy_file_fd) {
assert_se(lseek(out_fd, SEEK_SET, 0) == 0);
assert_se(read(out_fd, buf, sizeof buf) == (ssize_t) strlen(text));
assert_se(streq(buf, text));
ASSERT_STREQ(buf, text);
}
TEST(copy_tree) {
@@ -202,7 +202,7 @@ TEST(copy_tree) {
assert_se(access(f, F_OK) == 0);
assert_se(read_full_file(f, &buf, &sz) == 0);
assert_se(streq(buf, "file\n"));
ASSERT_STREQ(buf, "file\n");
k = lgetxattr_malloc(f, "user.testxattr", &c);
assert_se(xattr_worked < 0 || ((k >= 0) == !!xattr_worked));
@@ -211,7 +211,7 @@ TEST(copy_tree) {
_cleanup_free_ char *d = NULL;
assert_se(base64mem(*p, strlen(*p), &d) >= 0);
assert_se(streq(d, c));
ASSERT_STREQ(d, c);
}
}
@@ -266,13 +266,13 @@ TEST(copy_tree_at_symlink) {
assert_se(copy_tree_at(tfd, "from", tfd, "to_1", UID_INVALID, GID_INVALID, 0, NULL, NULL) >= 0);
assert_se(readlinkat_malloc(tfd, "to_1", &p) >= 0);
assert_se(streq(p, expect));
ASSERT_STREQ(p, expect);
p = mfree(p);
assert_se(q = path_join(t, "from"));
assert_se(copy_tree_at(AT_FDCWD, q, tfd, "to_2", UID_INVALID, GID_INVALID, 0, NULL, NULL) >= 0);
assert_se(readlinkat_malloc(tfd, "to_2", &p) >= 0);
assert_se(streq(p, expect));
ASSERT_STREQ(p, expect);
p = mfree(p);
q = mfree(q);
@@ -280,12 +280,12 @@ TEST(copy_tree_at_symlink) {
assert_se(fd >= 0);
assert_se(copy_tree_at(fd, NULL, tfd, "to_3", UID_INVALID, GID_INVALID, 0, NULL, NULL) >= 0);
assert_se(readlinkat_malloc(tfd, "to_3", &p) >= 0);
assert_se(streq(p, expect));
ASSERT_STREQ(p, expect);
p = mfree(p);
assert_se(copy_tree_at(fd, "", tfd, "to_4", UID_INVALID, GID_INVALID, 0, NULL, NULL) >= 0);
assert_se(readlinkat_malloc(tfd, "to_4", &p) >= 0);
assert_se(streq(p, expect));
ASSERT_STREQ(p, expect);
p = mfree(p);
fd = safe_close(fd);
}
@@ -421,7 +421,7 @@ TEST(copy_proc) {
assert_se(read_one_line_file("/proc/version", &a) >= 0);
assert_se(read_one_line_file(f, &b) >= 0);
assert_se(streq(a, b));
ASSERT_STREQ(a, b);
assert_se(!isempty(a));
}

14
src/test/test-core-unit.c
View File

@@ -33,19 +33,19 @@ static void test_unit_escape_setting_one(
assert_se(b_esc = cescape(t));
log_debug("%s: [%s] → [%s]", __func__, s_esc, b_esc);
assert_se(b == NULL || streq(b, t));
assert_se(streq(t, expected_exec_env));
ASSERT_STREQ(t, expected_exec_env);
assert_se(t = unit_escape_setting(s, UNIT_ESCAPE_EXEC_SYNTAX, &c));
assert_se(c_esc = cescape(t));
log_debug("%s: [%s] → [%s]", __func__, s_esc, c_esc);
assert_se(c == NULL || streq(c, t));
assert_se(streq(t, expected_exec));
ASSERT_STREQ(t, expected_exec);
assert_se(t = unit_escape_setting(s, UNIT_ESCAPE_C, &d));
assert_se(d_esc = cescape(t));
log_debug("%s: [%s] → [%s]", __func__, s_esc, d_esc);
assert_se(d == NULL || streq(d, t));
assert_se(streq(t, expected_c));
ASSERT_STREQ(t, expected_c);
}
TEST(unit_escape_setting) {
@@ -81,22 +81,22 @@ static void test_unit_concat_strv_one(
assert_se(a = unit_concat_strv(s, 0));
assert_se(a_esc = cescape(a));
log_debug("%s: [%s] → [%s]", __func__, s_esc, a_esc);
assert_se(streq(a, expected_none));
ASSERT_STREQ(a, expected_none);
assert_se(b = unit_concat_strv(s, UNIT_ESCAPE_EXEC_SYNTAX_ENV));
assert_se(b_esc = cescape(b));
log_debug("%s: [%s] → [%s]", __func__, s_esc, b_esc);
assert_se(streq(b, expected_exec_env));
ASSERT_STREQ(b, expected_exec_env);
assert_se(c = unit_concat_strv(s, UNIT_ESCAPE_EXEC_SYNTAX));
assert_se(c_esc = cescape(c));
log_debug("%s: [%s] → [%s]", __func__, s_esc, c_esc);
assert_se(streq(c, expected_exec));
ASSERT_STREQ(c, expected_exec);
assert_se(d = unit_concat_strv(s, UNIT_ESCAPE_C));
assert_se(d_esc = cescape(d));
log_debug("%s: [%s] → [%s]", __func__, s_esc, d_esc);
assert_se(streq(d, expected_c));
ASSERT_STREQ(d, expected_c);
}
TEST(unit_concat_strv) {

42
src/test/test-cpu-set-util.c
View File

@@ -23,11 +23,11 @@ TEST(parse_cpu_set) {
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
assert_se(streq(str, "0"));
ASSERT_STREQ(str, "0");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "1"));
ASSERT_STREQ(str, "1");
str = mfree(str);
cpu_set_reset(&c);
@@ -45,11 +45,11 @@ TEST(parse_cpu_set) {
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
assert_se(streq(str, "1-2 4"));
ASSERT_STREQ(str, "1-2 4");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "16"));
ASSERT_STREQ(str, "16");
str = mfree(str);
cpu_set_reset(&c);
@@ -67,11 +67,11 @@ TEST(parse_cpu_set) {
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
assert_se(streq(str, "0-3 8-11"));
ASSERT_STREQ(str, "0-3 8-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "f0f"));
ASSERT_STREQ(str, "f0f");
str = mfree(str);
cpu_set_reset(&c);
@@ -86,11 +86,11 @@ TEST(parse_cpu_set) {
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
assert_se(streq(str, "8-11"));
ASSERT_STREQ(str, "8-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "f00"));
ASSERT_STREQ(str, "f00");
str = mfree(str);
cpu_set_reset(&c);
@@ -120,11 +120,11 @@ TEST(parse_cpu_set) {
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
assert_se(streq(str, "0-7 63"));
ASSERT_STREQ(str, "0-7 63");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "80000000,000000ff"));
ASSERT_STREQ(str, "80000000,000000ff");
str = mfree(str);
cpu_set_reset(&c);
@@ -149,7 +149,7 @@ TEST(parse_cpu_set) {
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "f0f0,00000000"));
ASSERT_STREQ(str, "f0f0,00000000");
str = mfree(str);
cpu_set_reset(&c);
assert_se(parse_cpu_set_full("64-71", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
@@ -159,7 +159,7 @@ TEST(parse_cpu_set) {
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "ff,00000000,00000000"));
ASSERT_STREQ(str, "ff,00000000,00000000");
str = mfree(str);
cpu_set_reset(&c);
@@ -176,11 +176,11 @@ TEST(parse_cpu_set) {
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
assert_se(streq(str, "0-3 8-11"));
ASSERT_STREQ(str, "0-3 8-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "f0f"));
ASSERT_STREQ(str, "f0f");
str = mfree(str);
cpu_set_reset(&c);
@@ -190,7 +190,7 @@ TEST(parse_cpu_set) {
assert_se(CPU_COUNT_S(c.allocated, c.set) == 0);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "0"));
ASSERT_STREQ(str, "0");
str = mfree(str);
cpu_set_reset(&c);
@@ -205,11 +205,11 @@ TEST(parse_cpu_set) {
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
assert_se(streq(str, "0-11"));
ASSERT_STREQ(str, "0-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "fff"));
ASSERT_STREQ(str, "fff");
str = mfree(str);
cpu_set_reset(&c);
@@ -226,11 +226,11 @@ TEST(parse_cpu_set) {
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
assert_se(streq(str, "0 2 4-11"));
ASSERT_STREQ(str, "0 2 4-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "ff5"));
ASSERT_STREQ(str, "ff5");
str = mfree(str);
cpu_set_reset(&c);
@@ -250,7 +250,7 @@ TEST(parse_cpu_set) {
assert_se(c.allocated == 0);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
assert_se(streq(str, "0"));
ASSERT_STREQ(str, "0");
str = mfree(str);
/* Runaway quoted string */
@@ -266,7 +266,7 @@ TEST(parse_cpu_set) {
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
assert_se(streq(str, "8000-8191"));
ASSERT_STREQ(str, "8000-8191");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);

12
src/test/test-creds.c
View File

@@ -39,21 +39,21 @@ TEST(read_credential_strings) {
assert_se(read_credential_strings_many("foo", &x, "bar", &y) == 0);
ASSERT_NULL(x);
assert_se(streq(y, "piff"));
ASSERT_STREQ(y, "piff");
assert_se(write_string_file(p, "paff", WRITE_STRING_FILE_TRUNCATE|WRITE_STRING_FILE_AVOID_NEWLINE) >= 0);
assert_se(read_credential_strings_many("foo", &x, "bar", &y) == 0);
ASSERT_NULL(x);
assert_se(streq(y, "paff"));
ASSERT_STREQ(y, "paff");
p = mfree(p);
assert_se(p = path_join(tmp, "foo"));
assert_se(write_string_file(p, "knurz", WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_AVOID_NEWLINE) >= 0);
assert_se(read_credential_strings_many("foo", &x, "bar", &y) >= 0);
assert_se(streq(x, "knurz"));
assert_se(streq(y, "paff"));
ASSERT_STREQ(x, "knurz");
ASSERT_STREQ(y, "paff");
p = mfree(p);
assert_se(p = path_join(tmp, "bazz"));
@@ -64,8 +64,8 @@ TEST(read_credential_strings) {
y = mfree(y);
assert_se(read_credential_strings_many("bazz", &x, "bar", &y) == -EBADMSG);
assert_se(streq(x, "knurz"));
assert_se(streq(y, "paff"));
ASSERT_STREQ(x, "knurz");
ASSERT_STREQ(y, "paff");
if (saved)
assert_se(setenv("CREDENTIALS_DIRECTORY", saved, /* override= */ 1) >= 0);

8
src/test/test-cryptolib.c
View File

@@ -14,25 +14,25 @@ TEST(string_hashsum) {
OPENSSL_OR_GCRYPT("SHA224", GCRY_MD_SHA224),
&out1) == 0);
/* echo -n 'asdf' | sha224sum - */
assert_se(streq(out1, "7872a74bcbf298a1e77d507cd95d4f8d96131cbbd4cdfc571e776c8a"));
ASSERT_STREQ(out1, "7872a74bcbf298a1e77d507cd95d4f8d96131cbbd4cdfc571e776c8a");
assert_se(string_hashsum("asdf", 4,
OPENSSL_OR_GCRYPT("SHA256", GCRY_MD_SHA256),
&out2) == 0);
/* echo -n 'asdf' | sha256sum - */
assert_se(streq(out2, "f0e4c2f76c58916ec258f246851bea091d14d4247a2fc3e18694461b1816e13b"));
ASSERT_STREQ(out2, "f0e4c2f76c58916ec258f246851bea091d14d4247a2fc3e18694461b1816e13b");
assert_se(string_hashsum("", 0,
OPENSSL_OR_GCRYPT("SHA224", GCRY_MD_SHA224),
&out3) == 0);
/* echo -n '' | sha224sum - */
assert_se(streq(out3, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"));
ASSERT_STREQ(out3, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f");
assert_se(string_hashsum("", 0,
OPENSSL_OR_GCRYPT("SHA256", GCRY_MD_SHA256),
&out4) == 0);
/* echo -n '' | sha256sum - */
assert_se(streq(out4, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"));
ASSERT_STREQ(out4, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
}
DEFINE_TEST_MAIN(LOG_INFO);

4
src/test/test-data-fd-util.c
View File

@@ -22,7 +22,7 @@ static void test_acquire_data_fd_one(unsigned flags) {
zero(rbuffer);
assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 3);
assert_se(streq(rbuffer, "foo"));
ASSERT_STREQ(rbuffer, "foo");
fd = safe_close(fd);
@@ -31,7 +31,7 @@ static void test_acquire_data_fd_one(unsigned flags) {
zero(rbuffer);
assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 0);
assert_se(streq(rbuffer, ""));
ASSERT_STREQ(rbuffer, "");
fd = safe_close(fd);

2
src/test/test-devnum-util.c
View File

@@ -109,7 +109,7 @@ TEST(device_path_make_canonical) {
static void test_devnum_format_str_one(dev_t devnum, const char *s) {
dev_t x;
assert_se(streq(FORMAT_DEVNUM(devnum), s));
ASSERT_STREQ(FORMAT_DEVNUM(devnum), s);
assert_se(parse_devnum(s, &x) >= 0);
assert_se(x == devnum);
}

36
src/test/test-dns-domain.c
View File

@@ -16,20 +16,20 @@ static void test_dns_label_unescape_one(const char *what, const char *expect, si
r = dns_label_unescape(&w, buffer, buffer_sz, 0);
assert_se(r == ret);
if (r >= 0)
assert_se(streq(buffer, expect));
ASSERT_STREQ(buffer, expect);
w = what;
r = dns_label_unescape(&w, buffer, buffer_sz, DNS_LABEL_LDH);
assert_se(r == ret_ldh);
if (r >= 0)
assert_se(streq(buffer, expect));
ASSERT_STREQ(buffer, expect);
w = what;
r = dns_label_unescape(&w, buffer, buffer_sz, DNS_LABEL_NO_ESCAPES);
const int ret_noe = strchr(what, '\\') ? -EINVAL : ret;
assert_se(r == ret_noe);
if (r >= 0)
assert_se(streq(buffer, expect));
ASSERT_STREQ(buffer, expect);
}
TEST(dns_label_unescape) {
@@ -131,12 +131,12 @@ static void test_dns_label_unescape_suffix_one(const char *what, const char *exp
r = dns_label_unescape_suffix(what, &label, buffer, buffer_sz);
assert_se(r == ret1);
if (r >= 0)
assert_se(streq(buffer, expect1));
ASSERT_STREQ(buffer, expect1);
r = dns_label_unescape_suffix(what, &label, buffer, buffer_sz);
assert_se(r == ret2);
if (r >= 0)
assert_se(streq(buffer, expect2));
ASSERT_STREQ(buffer, expect2);
}
TEST(dns_label_unescape_suffix) {
@@ -173,7 +173,7 @@ static void test_dns_label_escape_one(const char *what, size_t l, const char *ex
if (r < 0)
return;
assert_se(streq_ptr(expect, t));
ASSERT_STREQ(expect, t);
}
TEST(dns_label_escape) {
@@ -193,7 +193,7 @@ static void test_dns_name_normalize_one(const char *what, const char *expect, in
if (r < 0)
return;
assert_se(streq_ptr(expect, t));
ASSERT_STREQ(expect, t);
}
TEST(dns_name_normalize) {
@@ -332,7 +332,7 @@ static void test_dns_name_reverse_one(const char *address, const char *name) {
assert_se(in_addr_from_string_auto(address, &familya, &a) >= 0);
assert_se(dns_name_reverse(familya, &a, &p) >= 0);
assert_se(streq(p, name));
ASSERT_STREQ(p, name);
assert_se(dns_name_address(p, &familyb, &b) > 0);
assert_se(familya == familyb);
assert_se(in_addr_equal(familya, &a, &b));
@@ -349,7 +349,7 @@ static void test_dns_name_concat_one(const char *a, const char *b, int r, const
_cleanup_free_ char *p = NULL;
assert_se(dns_name_concat(a, b, 0, &p) == r);
assert_se(streq_ptr(p, result));
ASSERT_STREQ(p, result);
}
TEST(dns_name_concat) {
@@ -486,14 +486,14 @@ static void test_dns_service_join_one(const char *a, const char *b, const char *
log_info("%s, %s, %s, →%d, %s", strnull(a), strnull(b), strnull(c), r, strnull(d));
assert_se(dns_service_join(a, b, c, &t) == r);
assert_se(streq_ptr(t, d));
ASSERT_STREQ(t, d);
if (r < 0)
return;
assert_se(dns_service_split(t, &x, &y, &z) >= 0);
assert_se(streq_ptr(a, x));
assert_se(streq_ptr(b, y));
ASSERT_STREQ(a, x);
ASSERT_STREQ(b, y);
assert_se(dns_name_equal(c, z) > 0);
}
@@ -518,9 +518,9 @@ static void test_dns_service_split_one(const char *joined, const char *a, const
log_info("%s, %s, %s, %s, →%d", joined, strnull(a), strnull(b), strnull(c), r);
assert_se(dns_service_split(joined, &x, &y, &z) == r);
assert_se(streq_ptr(x, a));
assert_se(streq_ptr(y, b));
assert_se(streq_ptr(z, c));
ASSERT_STREQ(x, a);
ASSERT_STREQ(y, b);
ASSERT_STREQ(z, c);
if (r < 0)
return;
@@ -549,7 +549,7 @@ static void test_dns_name_change_suffix_one(const char *name, const char *old_su
log_info("%s, %s, %s, →%s", name, old_suffix, new_suffix, strnull(result));
assert_se(dns_name_change_suffix(name, old_suffix, new_suffix, &s) == r);
assert_se(streq_ptr(s, result));
ASSERT_STREQ(s, result);
}
TEST(dns_name_change_suffix) {
@@ -570,7 +570,7 @@ static void test_dns_name_suffix_one(const char *name, unsigned n_labels, const
log_info("%s, %u, → %s, %d", name, n_labels, strnull(result), ret);
assert_se(ret == dns_name_suffix(name, n_labels, &p));
assert_se(streq_ptr(p, result));
ASSERT_STREQ(p, result);
}
TEST(dns_name_suffix) {
@@ -660,7 +660,7 @@ static void test_dns_name_common_suffix_one(const char *a, const char *b, const
log_info("%s, %s, →%s", a, b, result);
assert_se(dns_name_common_suffix(a, b, &c) >= 0);
assert_se(streq(c, result));
ASSERT_STREQ(c, result);
}
TEST(dns_name_common_suffix) {

14
src/test/test-ellipsize.c
View File

@@ -57,9 +57,9 @@ static void test_ellipsize_mem_one(const char *s, size_t old_length, size_t new_
assert_se(utf8_console_width(t3) <= max_width);
if (new_length >= old_length) {
assert_se(streq(t1, n));
assert_se(streq(t2, n));
assert_se(streq(t3, n));
ASSERT_STREQ(t1, n);
ASSERT_STREQ(t2, n);
ASSERT_STREQ(t3, n);
}
}
@@ -143,17 +143,17 @@ TEST(ellipsize_ansi_cats) {
e = ellipsize("01" ANSI_NORMAL "23", 4, 0);
puts(e);
assert_se(streq(e, "01" ANSI_NORMAL "23"));
ASSERT_STREQ(e, "01" ANSI_NORMAL "23");
f = ellipsize("ab" ANSI_NORMAL "cd", 4, 90);
puts(f);
assert_se(streq(f, "ab" ANSI_NORMAL "cd"));
ASSERT_STREQ(f, "ab" ANSI_NORMAL "cd");
g = ellipsize("🐱🐱" ANSI_NORMAL "🐱🐱" ANSI_NORMAL, 5, 0);
puts(g);
assert_se(streq(g, "…" ANSI_NORMAL "🐱🐱" ANSI_NORMAL));
ASSERT_STREQ(g, "…" ANSI_NORMAL "🐱🐱" ANSI_NORMAL);
h = ellipsize("🐱🐱" ANSI_NORMAL "🐱🐱" ANSI_NORMAL, 5, 90);
puts(h);
assert_se(streq(h, "🐱…" ANSI_NORMAL "🐱" ANSI_NORMAL));
ASSERT_STREQ(h, "🐱…" ANSI_NORMAL "🐱" ANSI_NORMAL);
}
DEFINE_TEST_MAIN(LOG_INFO);

2
src/test/test-engine.c
View File

@@ -214,7 +214,7 @@ int main(int argc, char *argv[]) {
assert_se(manager_load_unit(m, "unit-with-multiple-dashes.service", NULL, NULL, &unit_with_multiple_dashes) >= 0);
assert_se(strv_equal(unit_with_multiple_dashes->documentation, STRV_MAKE("man:test", "man:override2", "man:override3")));
assert_se(streq_ptr(unit_with_multiple_dashes->description, "override4"));
ASSERT_STREQ(unit_with_multiple_dashes->description, "override4");
/* Now merge a synthetic unit into the existing one */
assert_se(unit_new_for_name(m, sizeof(Service), "merged.service", &stub) >= 0);

40
src/test/test-env-file.c
View File

@@ -65,12 +65,12 @@ TEST(load_env_file_1) {
_cleanup_strv_free_ char **data = NULL;
assert_se(load_env_file(NULL, name, &data) == 0);
assert_se(streq(data[0], "a=a"));
assert_se(streq(data[1], "b=bc"));
assert_se(streq(data[2], "d=de f"));
assert_se(streq(data[3], "g=g "));
assert_se(streq(data[4], "h=ąęół śćńźżμ"));
assert_se(streq(data[5], "i=i"));
ASSERT_STREQ(data[0], "a=a");
ASSERT_STREQ(data[1], "b=bc");
ASSERT_STREQ(data[2], "d=de f");
ASSERT_STREQ(data[3], "g=g ");
ASSERT_STREQ(data[4], "h=ąęół śćńźżμ");
ASSERT_STREQ(data[5], "i=i");
ASSERT_NULL(data[6]);
}
@@ -80,7 +80,7 @@ TEST(load_env_file_2) {
_cleanup_strv_free_ char **data = NULL;
assert_se(load_env_file(NULL, name, &data) == 0);
assert_se(streq(data[0], "a=a"));
ASSERT_STREQ(data[0], "a=a");
ASSERT_NULL(data[1]);
}
@@ -90,8 +90,8 @@ TEST(load_env_file_3) {
_cleanup_strv_free_ char **data = NULL;
assert_se(load_env_file(NULL, name, &data) == 0);
assert_se(streq(data[0], "normal1=line111"));
assert_se(streq(data[1], "normal2=line222"));
ASSERT_STREQ(data[0], "normal1=line111");
ASSERT_STREQ(data[1], "normal2=line222");
ASSERT_NULL(data[2]);
}
@@ -101,9 +101,9 @@ TEST(load_env_file_4) {
_cleanup_strv_free_ char **data = NULL;
assert_se(load_env_file(NULL, name, &data) == 0);
assert_se(streq(data[0], "HWMON_MODULES=coretemp f71882fg"));
assert_se(streq(data[1], "MODULE_0=coretemp"));
assert_se(streq(data[2], "MODULE_1=f71882fg"));
ASSERT_STREQ(data[0], "HWMON_MODULES=coretemp f71882fg");
ASSERT_STREQ(data[1], "MODULE_0=coretemp");
ASSERT_STREQ(data[2], "MODULE_1=f71882fg");
ASSERT_NULL(data[3]);
}
@@ -113,8 +113,8 @@ TEST(load_env_file_5) {
_cleanup_strv_free_ char **data = NULL;
assert_se(load_env_file(NULL, name, &data) == 0);
assert_se(streq(data[0], "a="));
assert_se(streq(data[1], "b="));
ASSERT_STREQ(data[0], "a=");
ASSERT_STREQ(data[1], "b=");
ASSERT_NULL(data[2]);
}
@@ -124,10 +124,10 @@ TEST(load_env_file_6) {
_cleanup_strv_free_ char **data = NULL;
assert_se(load_env_file(NULL, name, &data) == 0);
assert_se(streq(data[0], "a= n t x y '"));
assert_se(streq(data[1], "b=$'"));
assert_se(streq(data[2], "c= \\n\\t\\$\\`\\\\\n"));
assert_se(streq(data[3], "d= \\n\\t$`\\\n"));
ASSERT_STREQ(data[0], "a= n t x y '");
ASSERT_STREQ(data[1], "b=$'");
ASSERT_STREQ(data[2], "c= \\n\\t\\$\\`\\\\\n");
ASSERT_STREQ(data[3], "d= \\n\\t$`\\\n");
ASSERT_NULL(data[4]);
}
@@ -178,13 +178,13 @@ TEST(write_and_load_env_file) {
assert_se(f = popen(cmd, "re"));
assert_se(read_full_stream(f, &from_shell, &sz) >= 0);
assert_se(sz == strlen(v));
assert_se(streq(from_shell, v));
ASSERT_STREQ(from_shell, v);
assert_se(load_env_file(NULL, p, &l) >= 0);
assert_se(strv_equal(l, STRV_MAKE(j)));
assert_se(parse_env_file(NULL, p, "TEST", &w) >= 0);
assert_se(streq_ptr(w, v));
ASSERT_STREQ(w, v);
}
}

176
src/test/test-env-util.c
View File

@@ -26,26 +26,26 @@ TEST(strv_env_delete) {
d = strv_env_delete(a, 2, b, c);
assert_se(d);
assert_se(streq(d[0], "WALDO=WALDO"));
assert_se(streq(d[1], "WALDO="));
ASSERT_STREQ(d[0], "WALDO=WALDO");
ASSERT_STREQ(d[1], "WALDO=");
assert_se(strv_length(d) == 2);
}
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, "THREE"), "3"));
assert_se(streq(strv_env_get(l, "FOUR"), "4"));
ASSERT_STREQ(strv_env_get(l, "ONE_OR_TWO"), "2");
ASSERT_STREQ(strv_env_get(l, "THREE"), "3");
ASSERT_STREQ(strv_env_get(l, "FOUR"), "4");
}
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, "THREE"), "3"));
assert_se(streq(strv_env_pairs_get(l, "FOUR"), "4"));
assert_se(streq(strv_env_pairs_get(l, "FIVE"), "5"));
ASSERT_STREQ(strv_env_pairs_get(l, "ONE_OR_TWO"), "2");
ASSERT_STREQ(strv_env_pairs_get(l, "THREE"), "3");
ASSERT_STREQ(strv_env_pairs_get(l, "FOUR"), "4");
ASSERT_STREQ(strv_env_pairs_get(l, "FIVE"), "5");
}
TEST(strv_env_unset) {
@@ -56,8 +56,8 @@ TEST(strv_env_unset) {
assert_se(strv_env_unset(l, "SCHLUMPF") == l);
assert_se(streq(l[0], "PIEP"));
assert_se(streq(l[1], "NANANANA=YES"));
ASSERT_STREQ(l[0], "PIEP");
ASSERT_STREQ(l[1], "NANANANA=YES");
assert_se(strv_length(l) == 2);
}
@@ -67,22 +67,22 @@ TEST(strv_env_merge) {
_cleanup_strv_free_ char **r = strv_env_merge(NULL, a, NULL, b, NULL, a, b, b, NULL);
assert_se(r);
assert_se(streq(r[0], "FOO="));
assert_se(streq(r[1], "WALDO="));
assert_se(streq(r[2], "PIEP"));
assert_se(streq(r[3], "SCHLUMPF=SMURFF"));
assert_se(streq(r[4], "EQ==="));
assert_se(streq(r[5], "PIEP="));
assert_se(streq(r[6], "NANANANA=YES"));
ASSERT_STREQ(r[0], "FOO=");
ASSERT_STREQ(r[1], "WALDO=");
ASSERT_STREQ(r[2], "PIEP");
ASSERT_STREQ(r[3], "SCHLUMPF=SMURFF");
ASSERT_STREQ(r[4], "EQ===");
ASSERT_STREQ(r[5], "PIEP=");
ASSERT_STREQ(r[6], "NANANANA=YES");
assert_se(strv_length(r) == 7);
assert_se(strv_env_clean(r) == r);
assert_se(streq(r[0], "FOO="));
assert_se(streq(r[1], "WALDO="));
assert_se(streq(r[2], "SCHLUMPF=SMURFF"));
assert_se(streq(r[3], "EQ==="));
assert_se(streq(r[4], "PIEP="));
assert_se(streq(r[5], "NANANANA=YES"));
ASSERT_STREQ(r[0], "FOO=");
ASSERT_STREQ(r[1], "WALDO=");
ASSERT_STREQ(r[2], "SCHLUMPF=SMURFF");
ASSERT_STREQ(r[3], "EQ===");
ASSERT_STREQ(r[4], "PIEP=");
ASSERT_STREQ(r[5], "NANANANA=YES");
assert_se(strv_length(r) == 6);
}
@@ -96,8 +96,8 @@ TEST(strv_env_replace_strdup) {
assert_se(strv_length(a) == 2);
strv_sort(a);
assert_se(streq(a[0], "a=A"));
assert_se(streq(a[1], "b=b"));
ASSERT_STREQ(a[0], "a=A");
ASSERT_STREQ(a[1], "b=b");
}
TEST(strv_env_replace_strdup_passthrough) {
@@ -114,9 +114,9 @@ TEST(strv_env_replace_strdup_passthrough) {
assert_se(strv_env_replace_strdup_passthrough(&a, "$a") == -EINVAL);
assert_se(strv_length(a) == 3);
assert_se(streq(a[0], "a=a"));
assert_se(streq(a[1], "b="));
assert_se(streq(a[2], "c="));
ASSERT_STREQ(a[0], "a=a");
ASSERT_STREQ(a[1], "b=");
ASSERT_STREQ(a[2], "c=");
}
TEST(strv_env_assign) {
@@ -130,7 +130,7 @@ TEST(strv_env_assign) {
assert_se(strv_env_assign(&a, "a=", "B") == -EINVAL);
assert_se(strv_length(a) == 1);
assert_se(streq(a[0], "a=A"));
ASSERT_STREQ(a[0], "a=A");
}
TEST(strv_env_assignf) {
@@ -151,7 +151,7 @@ TEST(strv_env_assignf) {
assert_se(strv_env_assignf(&a, "a=", "B") == -EINVAL);
assert_se(strv_length(a) == 1);
assert_se(streq(a[0], "a=A"));
ASSERT_STREQ(a[0], "a=A");
}
TEST(strv_env_assign_many) {
@@ -190,15 +190,15 @@ TEST(env_strv_get_n) {
};
char **env = (char**) _env;
assert_se(streq(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR"));
assert_se(streq(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
assert_se(streq(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR"));
assert_se(streq(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
ASSERT_STREQ(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR");
ASSERT_STREQ(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR");
ASSERT_STREQ(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR");
ASSERT_STREQ(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR");
assert_se(streq(strv_env_get_n(env, "PATH__", 4, 0), "unset"));
assert_se(streq(strv_env_get_n(env, "PATH", 4, 0), "unset"));
assert_se(streq(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
ASSERT_STREQ(strv_env_get_n(env, "PATH__", 4, 0), "unset");
ASSERT_STREQ(strv_env_get_n(env, "PATH", 4, 0), "unset");
ASSERT_STREQ(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset");
ASSERT_STREQ(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset");
env[3] = NULL; /* kill our $PATH */
@@ -222,19 +222,19 @@ static void test_replace_env1(bool braceless) {
unsigned flags = REPLACE_ENV_ALLOW_BRACELESS*braceless;
assert_se(replace_env("FOO=$FOO=${FOO}", (char**) env, flags, &t) >= 0);
assert_se(streq(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR"));
ASSERT_STREQ(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR");
assert_se(replace_env("BAR=$BAR=${BAR}", (char**) env, flags, &s) >= 0);
assert_se(streq(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo"));
ASSERT_STREQ(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo");
assert_se(replace_env("BARBAR=$BARBAR=${BARBAR}", (char**) env, flags, &q) >= 0);
assert_se(streq(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR="));
ASSERT_STREQ(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR=");
assert_se(replace_env("BAR=$BAR$BAR${BAR}${BAR}", (char**) env, flags, &r) >= 0);
assert_se(streq(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo"));
ASSERT_STREQ(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo");
assert_se(replace_env("${BAR}$BAR$BAR", (char**) env, flags, &p) >= 0);
assert_se(streq(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR"));
ASSERT_STREQ(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR");
}
static void test_replace_env2(bool extended) {
@@ -249,25 +249,25 @@ static void test_replace_env2(bool extended) {
unsigned flags = REPLACE_ENV_ALLOW_EXTENDED*extended;
assert_se(replace_env("FOO=${FOO:-${BAR}}", (char**) env, flags, &t) >= 0);
assert_se(streq(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}"));
ASSERT_STREQ(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}");
assert_se(replace_env("BAR=${XXX:-${BAR}}", (char**) env, flags, &s) >= 0);
assert_se(streq(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}"));
ASSERT_STREQ(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}");
assert_se(replace_env("XXX=${XXX:+${BAR}}", (char**) env, flags, &q) >= 0);
assert_se(streq(q, extended ? "XXX=" : "XXX=${XXX:+bar}"));
ASSERT_STREQ(q, extended ? "XXX=" : "XXX=${XXX:+bar}");
assert_se(replace_env("FOO=${FOO:+${BAR}}", (char**) env, flags, &r) >= 0);
assert_se(streq(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}"));
ASSERT_STREQ(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}");
assert_se(replace_env("FOO=${FOO:-${BAR}post}", (char**) env, flags, &p) >= 0);
assert_se(streq(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}"));
ASSERT_STREQ(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}");
assert_se(replace_env("XXX=${XXX:+${BAR}post}", (char**) env, flags, &x) >= 0);
assert_se(streq(x, extended ? "XXX=" : "XXX=${XXX:+barpost}"));
ASSERT_STREQ(x, extended ? "XXX=" : "XXX=${XXX:+barpost}");
assert_se(replace_env("FOO=${FOO}between${BAR:-baz}", (char**) env, flags, &y) >= 0);
assert_se(streq(y, extended ? "FOO=foobetweenbar" : "FOO=foobetween${BAR:-baz}"));
ASSERT_STREQ(y, extended ? "FOO=foobetweenbar" : "FOO=foobetween${BAR:-baz}");
}
TEST(replace_env) {
@@ -307,23 +307,23 @@ TEST(replace_env_argv) {
assert_se(replace_env_argv((char**) line, (char**) env, &r, NULL, NULL) >= 0);
assert_se(r);
assert_se(streq(r[0], "FOO$FOO"));
assert_se(streq(r[1], "FOO$FOOFOO"));
assert_se(streq(r[2], "FOOBAR BAR$FOO"));
assert_se(streq(r[3], "FOOBAR BAR"));
assert_se(streq(r[4], "BAR BAR"));
assert_se(streq(r[5], "BAR"));
assert_se(streq(r[6], "BAR"));
assert_se(streq(r[7], "BAR BARwaldo"));
assert_se(streq(r[8], "${FOO"));
assert_se(streq(r[9], "FOO$BAR BAR"));
assert_se(streq(r[10], "$FOOBAR BAR"));
assert_se(streq(r[11], "${FOO:-waldo}"));
assert_se(streq(r[12], "${QUUX:-BAR BAR}"));
assert_se(streq(r[13], "${FOO:+waldo}"));
assert_se(streq(r[14], "${QUUX:+waldo}"));
assert_se(streq(r[15], "${FOO:+|waldo|}}"));
assert_se(streq(r[16], "${FOO:+|waldo{|}"));
ASSERT_STREQ(r[0], "FOO$FOO");
ASSERT_STREQ(r[1], "FOO$FOOFOO");
ASSERT_STREQ(r[2], "FOOBAR BAR$FOO");
ASSERT_STREQ(r[3], "FOOBAR BAR");
ASSERT_STREQ(r[4], "BAR BAR");
ASSERT_STREQ(r[5], "BAR");
ASSERT_STREQ(r[6], "BAR");
ASSERT_STREQ(r[7], "BAR BARwaldo");
ASSERT_STREQ(r[8], "${FOO");
ASSERT_STREQ(r[9], "FOO$BAR BAR");
ASSERT_STREQ(r[10], "$FOOBAR BAR");
ASSERT_STREQ(r[11], "${FOO:-waldo}");
ASSERT_STREQ(r[12], "${QUUX:-BAR BAR}");
ASSERT_STREQ(r[13], "${FOO:+waldo}");
ASSERT_STREQ(r[14], "${QUUX:+waldo}");
ASSERT_STREQ(r[15], "${FOO:+|waldo|}}");
ASSERT_STREQ(r[16], "${FOO:+|waldo{|}");
assert_se(strv_length(r) == 17);
}
@@ -393,14 +393,14 @@ TEST(env_clean) {
assert_se(strv_env_clean(e) == e);
assert_se(strv_env_is_valid(e));
assert_se(streq(e[0], "FOOBAR=WALDO"));
assert_se(streq(e[1], "X="));
assert_se(streq(e[2], "F=F"));
assert_se(streq(e[3], "abcd=äöüß"));
assert_se(streq(e[4], "xyz=xyz\n"));
assert_se(streq(e[5], "another=final one"));
assert_se(streq(e[6], "CRLF=\r\n"));
assert_se(streq(e[7], "LESS_TERMCAP_mb=\x1b[01;31m"));
ASSERT_STREQ(e[0], "FOOBAR=WALDO");
ASSERT_STREQ(e[1], "X=");
ASSERT_STREQ(e[2], "F=F");
ASSERT_STREQ(e[3], "abcd=äöüß");
ASSERT_STREQ(e[4], "xyz=xyz\n");
ASSERT_STREQ(e[5], "another=final one");
ASSERT_STREQ(e[6], "CRLF=\r\n");
ASSERT_STREQ(e[7], "LESS_TERMCAP_mb=\x1b[01;31m");
ASSERT_NULL(e[8]);
}
@@ -451,13 +451,13 @@ TEST(env_assignment_is_valid) {
TEST(putenv_dup) {
assert_se(putenv_dup("A=a1", true) == 0);
assert_se(streq_ptr(getenv("A"), "a1"));
ASSERT_STREQ(getenv("A"), "a1");
assert_se(putenv_dup("A=a1", true) == 0);
assert_se(streq_ptr(getenv("A"), "a1"));
ASSERT_STREQ(getenv("A"), "a1");
assert_se(putenv_dup("A=a2", false) == 0);
assert_se(streq_ptr(getenv("A"), "a1"));
ASSERT_STREQ(getenv("A"), "a1");
assert_se(putenv_dup("A=a2", true) == 0);
assert_se(streq_ptr(getenv("A"), "a2"));
ASSERT_STREQ(getenv("A"), "a2");
}
TEST(setenv_systemd_exec_pid) {
@@ -476,7 +476,7 @@ TEST(setenv_systemd_exec_pid) {
assert_se(setenv("SYSTEMD_EXEC_PID", "*", 1) >= 0);
assert_se(setenv_systemd_exec_pid(true) == 0);
assert_se(e = getenv("SYSTEMD_EXEC_PID"));
assert_se(streq(e, "*"));
ASSERT_STREQ(e, "*");
assert_se(setenv("SYSTEMD_EXEC_PID", "123abc", 1) >= 0);
assert_se(setenv_systemd_exec_pid(true) == 1);
@@ -523,10 +523,10 @@ TEST(getenv_steal_erase) {
copy1 = strdup(eq + 1);
assert_se(copy1);
assert_se(streq_ptr(getenv(n), copy1));
ASSERT_STREQ(getenv(n), copy1);
assert_se(getenv(n) == eq + 1);
assert_se(getenv_steal_erase(n, &copy2) > 0);
assert_se(streq_ptr(copy1, copy2));
ASSERT_STREQ(copy1, copy2);
assert_se(isempty(eq + 1));
assert_se(!getenv(n));
}
@@ -571,11 +571,11 @@ TEST(getenv_path_list) {
/* Finally some valid paths */
assert_se(setenv("TEST_GETENV_PATH_LIST", "/foo:/bar/baz:/hello/world:/path with spaces:/final", 1) >= 0);
assert_se(getenv_path_list("TEST_GETENV_PATH_LIST", &path_list) >= 0);
assert_se(streq(path_list[0], "/foo"));
assert_se(streq(path_list[1], "/bar/baz"));
assert_se(streq(path_list[2], "/hello/world"));
assert_se(streq(path_list[3], "/path with spaces"));
assert_se(streq(path_list[4], "/final"));
ASSERT_STREQ(path_list[0], "/foo");
ASSERT_STREQ(path_list[1], "/bar/baz");
ASSERT_STREQ(path_list[2], "/hello/world");
ASSERT_STREQ(path_list[3], "/path with spaces");
ASSERT_STREQ(path_list[4], "/final");
ASSERT_NULL(path_list[5]);
assert_se(unsetenv("TEST_GETENV_PATH_LIST") >= 0);

10
src/test/test-errno-list.c
View File

@@ -11,22 +11,22 @@
TEST(errno_list) {
for (size_t i = 0; i < ELEMENTSOF(errno_names); i++) {
if (errno_names[i]) {
assert_se(streq(errno_to_name(i), errno_names[i]));
ASSERT_STREQ(errno_to_name(i), errno_names[i]);
assert_se(errno_from_name(errno_names[i]) == (int) i);
}
}
#ifdef ECANCELLED
/* ECANCELLED is an alias of ECANCELED. */
assert_se(streq(errno_to_name(ECANCELLED), "ECANCELED"));
ASSERT_STREQ(errno_to_name(ECANCELLED), "ECANCELED");
#endif
assert_se(streq(errno_to_name(ECANCELED), "ECANCELED"));
ASSERT_STREQ(errno_to_name(ECANCELED), "ECANCELED");
#ifdef EREFUSED
/* EREFUSED is an alias of ECONNREFUSED. */
assert_se(streq(errno_to_name(EREFUSED), "ECONNREFUSED"));
ASSERT_STREQ(errno_to_name(EREFUSED), "ECONNREFUSED");
#endif
assert_se(streq(errno_to_name(ECONNREFUSED), "ECONNREFUSED"));
ASSERT_STREQ(errno_to_name(ECONNREFUSED), "ECONNREFUSED");
}
DEFINE_TEST_MAIN(LOG_INFO);

Some files were not shown because too many files have changed in this diff Show More