mirror of
https://github.com/systemd/systemd.git
synced 2024-10-28 03:25:31 +03:00
ASSERT_STREQ for simple cases
This commit is contained in:
Ivan Kruglov
Daan De Meyer
parent
9506269d12
commit
c79e88b37d
@ -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);
|
||||
}
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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));
|
||||
}
|
||||
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -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, ©2) > 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);
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -31,8 +31,8 @@ TEST(STRERROR) {
|
||||
assert_se(strstr(b, "201"));
|
||||
|
||||
/* Check with negative values */
|
||||
assert_se(streq(a, STRERROR(-200)));
|
||||
assert_se(streq(b, STRERROR(-201)));
|
||||
ASSERT_STREQ(a, STRERROR(-200));
|
||||
ASSERT_STREQ(b, STRERROR(-201));
|
||||
|
||||
const char *c = STRERROR(INT_MAX);
|
||||
char buf[DECIMAL_STR_MAX(int)];
|
||||
|
||||
@ -9,14 +9,14 @@ TEST(cescape) {
|
||||
_cleanup_free_ char *t = NULL;
|
||||
|
||||
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"));
|
||||
ASSERT_STREQ(t, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313");
|
||||
}
|
||||
|
||||
TEST(xescape) {
|
||||
_cleanup_free_ char *t = NULL;
|
||||
|
||||
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"));
|
||||
ASSERT_STREQ(t, "abc\\x5c\"\\x08\\x0c\\x0a\\x0d\\x09\\x0b\\x07\\x03\\x7f\\x9c\\xcb");
|
||||
}
|
||||
|
||||
static void test_xescape_full_one(bool eight_bits) {
|
||||
@ -36,7 +36,7 @@ static void test_xescape_full_one(bool eight_bits) {
|
||||
log_info("%02u: <%s>", i, t);
|
||||
|
||||
if (i >= full_fit)
|
||||
assert_se(streq(t, escaped));
|
||||
ASSERT_STREQ(t, escaped);
|
||||
else if (i >= 3) {
|
||||
/* We need up to four columns, so up to three columns may be wasted */
|
||||
assert_se(strlen(t) == i || strlen(t) == i - 1 || strlen(t) == i - 2 || strlen(t) == i - 3);
|
||||
@ -69,50 +69,50 @@ TEST(cunescape) {
|
||||
|
||||
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(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
|
||||
ASSERT_STREQ(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
/* incomplete sequences */
|
||||
assert_se(cunescape("\\x0", 0, &unescaped) < 0);
|
||||
assert_se(cunescape("\\x0", UNESCAPE_RELAX, &unescaped) >= 0);
|
||||
assert_se(streq_ptr(unescaped, "\\x0"));
|
||||
ASSERT_STREQ(unescaped, "\\x0");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
assert_se(cunescape("\\x", 0, &unescaped) < 0);
|
||||
assert_se(cunescape("\\x", UNESCAPE_RELAX, &unescaped) >= 0);
|
||||
assert_se(streq_ptr(unescaped, "\\x"));
|
||||
ASSERT_STREQ(unescaped, "\\x");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
assert_se(cunescape("\\", 0, &unescaped) < 0);
|
||||
assert_se(cunescape("\\", UNESCAPE_RELAX, &unescaped) >= 0);
|
||||
assert_se(streq_ptr(unescaped, "\\"));
|
||||
ASSERT_STREQ(unescaped, "\\");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
assert_se(cunescape("\\11", 0, &unescaped) < 0);
|
||||
assert_se(cunescape("\\11", UNESCAPE_RELAX, &unescaped) >= 0);
|
||||
assert_se(streq_ptr(unescaped, "\\11"));
|
||||
ASSERT_STREQ(unescaped, "\\11");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
assert_se(cunescape("\\1", 0, &unescaped) < 0);
|
||||
assert_se(cunescape("\\1", UNESCAPE_RELAX, &unescaped) >= 0);
|
||||
assert_se(streq_ptr(unescaped, "\\1"));
|
||||
ASSERT_STREQ(unescaped, "\\1");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
assert_se(cunescape("\\u0000", 0, &unescaped) < 0);
|
||||
assert_se(cunescape("\\u00DF\\U000000df\\u03a0\\U00000041", UNESCAPE_RELAX, &unescaped) >= 0);
|
||||
assert_se(streq_ptr(unescaped, "ßßΠA"));
|
||||
ASSERT_STREQ(unescaped, "ßßΠA");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
assert_se(cunescape("\\073", 0, &unescaped) >= 0);
|
||||
assert_se(streq_ptr(unescaped, ";"));
|
||||
ASSERT_STREQ(unescaped, ";");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
assert_se(cunescape("A=A\\\\x0aB", 0, &unescaped) >= 0);
|
||||
assert_se(streq_ptr(unescaped, "A=A\\x0aB"));
|
||||
ASSERT_STREQ(unescaped, "A=A\\x0aB");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
assert_se(cunescape("A=A\\\\x0aB", UNESCAPE_RELAX, &unescaped) >= 0);
|
||||
assert_se(streq_ptr(unescaped, "A=A\\x0aB"));
|
||||
ASSERT_STREQ(unescaped, "A=A\\x0aB");
|
||||
unescaped = mfree(unescaped);
|
||||
|
||||
assert_se(cunescape("\\x00\\x00\\x00", UNESCAPE_ACCEPT_NUL, &unescaped) == 3);
|
||||
@ -136,7 +136,7 @@ static void test_shell_escape_one(const char *s, const char *bad, const char *ex
|
||||
|
||||
assert_se(r = shell_escape(s, bad));
|
||||
log_debug("%s → %s (expected %s)", s, r, expected);
|
||||
assert_se(streq_ptr(r, expected));
|
||||
ASSERT_STREQ(r, expected);
|
||||
}
|
||||
|
||||
TEST(shell_escape) {
|
||||
@ -153,7 +153,7 @@ static void test_shell_maybe_quote_one(const char *s, ShellEscapeFlags flags, co
|
||||
|
||||
assert_se(ret = shell_maybe_quote(s, flags));
|
||||
log_debug("[%s] → [%s] (%s)", s, ret, expected);
|
||||
assert_se(streq(ret, expected));
|
||||
ASSERT_STREQ(ret, expected);
|
||||
}
|
||||
|
||||
TEST(shell_maybe_quote) {
|
||||
@ -207,7 +207,7 @@ static void test_quote_command_line_one(char **argv, const char *expected) {
|
||||
|
||||
assert_se(s = quote_command_line(argv, SHELL_ESCAPE_EMPTY));
|
||||
log_info("%s", s);
|
||||
assert_se(streq(s, expected));
|
||||
ASSERT_STREQ(s, expected);
|
||||
}
|
||||
|
||||
TEST(quote_command_line) {
|
||||
@ -228,7 +228,7 @@ static void test_octescape_one(const char *s, const char *expected) {
|
||||
|
||||
assert_se(ret = octescape(s, strlen_ptr(s)));
|
||||
log_debug("octescape(\"%s\") → \"%s\" (expected: \"%s\")", strnull(s), ret, expected);
|
||||
assert_se(streq(ret, expected));
|
||||
ASSERT_STREQ(ret, expected);
|
||||
}
|
||||
|
||||
TEST(octescape) {
|
||||
@ -244,7 +244,7 @@ static void test_decescape_one(const char *s, const char *bad, const char *expec
|
||||
|
||||
assert_se(ret = decescape(s, bad, strlen_ptr(s)));
|
||||
log_debug("decescape(\"%s\") → \"%s\" (expected: \"%s\")", strnull(s), ret, expected);
|
||||
assert_se(streq(ret, expected));
|
||||
ASSERT_STREQ(ret, expected);
|
||||
}
|
||||
|
||||
TEST(decescape) {
|
||||
|
||||
@ -72,7 +72,7 @@ static void test_parse_hw_addr_full_one(const char *in, size_t expected_len, con
|
||||
if (r >= 0) {
|
||||
if (!IN_SET(expected_len, 0, SIZE_MAX))
|
||||
assert_se(h.length == expected_len);
|
||||
assert_se(streq(HW_ADDR_TO_STR(&h), expected));
|
||||
ASSERT_STREQ(HW_ADDR_TO_STR(&h), expected);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -195,7 +195,7 @@ TEST(execution_order) {
|
||||
execute_directories(dirs, DEFAULT_TIMEOUT_USEC, ignore_stdout, ignore_stdout_args, NULL, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
|
||||
|
||||
assert_se(read_full_file(output, &contents, NULL) >= 0);
|
||||
assert_se(streq(contents, "30-override\n80-foo\n90-bar\nlast\n"));
|
||||
ASSERT_STREQ(contents, "30-override\n80-foo\n90-bar\nlast\n");
|
||||
}
|
||||
|
||||
static int gather_stdout_one(int fd, void *arg) {
|
||||
@ -279,7 +279,7 @@ TEST(stdout_gathering) {
|
||||
|
||||
log_info("got: %s", output);
|
||||
|
||||
assert_se(streq(output, "a\nb\nc\nd\n"));
|
||||
ASSERT_STREQ(output, "a\nb\nc\nd\n");
|
||||
}
|
||||
|
||||
TEST(environment_gathering) {
|
||||
@ -346,10 +346,10 @@ TEST(environment_gathering) {
|
||||
STRV_FOREACH(p, env)
|
||||
log_info("got env: \"%s\"", *p);
|
||||
|
||||
assert_se(streq(strv_env_get(env, "A"), "22:23:24"));
|
||||
assert_se(streq(strv_env_get(env, "B"), "12"));
|
||||
assert_se(streq(strv_env_get(env, "C"), "001"));
|
||||
assert_se(streq(strv_env_get(env, "PATH"), "no-sh-built-in-path:/no/such/file"));
|
||||
ASSERT_STREQ(strv_env_get(env, "A"), "22:23:24");
|
||||
ASSERT_STREQ(strv_env_get(env, "B"), "12");
|
||||
ASSERT_STREQ(strv_env_get(env, "C"), "001");
|
||||
ASSERT_STREQ(strv_env_get(env, "PATH"), "no-sh-built-in-path:/no/such/file");
|
||||
|
||||
/* now retest with "default" path passed in, as created by
|
||||
* manager_default_environment */
|
||||
@ -363,10 +363,10 @@ TEST(environment_gathering) {
|
||||
STRV_FOREACH(p, env)
|
||||
log_info("got env: \"%s\"", *p);
|
||||
|
||||
assert_se(streq(strv_env_get(env, "A"), "22:23:24"));
|
||||
assert_se(streq(strv_env_get(env, "B"), "12"));
|
||||
assert_se(streq(strv_env_get(env, "C"), "001"));
|
||||
assert_se(streq(strv_env_get(env, "PATH"), DEFAULT_PATH ":/no/such/file"));
|
||||
ASSERT_STREQ(strv_env_get(env, "A"), "22:23:24");
|
||||
ASSERT_STREQ(strv_env_get(env, "B"), "12");
|
||||
ASSERT_STREQ(strv_env_get(env, "C"), "001");
|
||||
ASSERT_STREQ(strv_env_get(env, "PATH"), DEFAULT_PATH ":/no/such/file");
|
||||
|
||||
/* reset environ PATH */
|
||||
assert_se(set_unset_env("PATH", old, true) == 0);
|
||||
|
||||
@ -29,8 +29,8 @@ TEST(exit_status_from_string) {
|
||||
}
|
||||
|
||||
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_STREQ(exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_FULL), "NUMA_POLICY");
|
||||
ASSERT_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));
|
||||
}
|
||||
|
||||
@ -14,12 +14,12 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "foobar waldo";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "foobar"));
|
||||
ASSERT_STREQ(t, "foobar");
|
||||
free(t);
|
||||
assert_se(p == original + 7);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "waldo"));
|
||||
ASSERT_STREQ(t, "waldo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -29,12 +29,12 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "\"foobar\" \'waldo\'";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "\"foobar\""));
|
||||
ASSERT_STREQ(t, "\"foobar\"");
|
||||
free(t);
|
||||
assert_se(p == original + 9);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "\'waldo\'"));
|
||||
ASSERT_STREQ(t, "\'waldo\'");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -44,12 +44,12 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "\"foobar\" \'waldo\'";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "foobar"));
|
||||
ASSERT_STREQ(t, "foobar");
|
||||
free(t);
|
||||
assert_se(p == original + 9);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "waldo"));
|
||||
ASSERT_STREQ(t, "waldo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -59,7 +59,7 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "\"";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) == 1);
|
||||
assert_se(streq(t, "\""));
|
||||
ASSERT_STREQ(t, "\"");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -69,7 +69,7 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "\'";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) == 1);
|
||||
assert_se(streq(t, "\'"));
|
||||
ASSERT_STREQ(t, "\'");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -79,31 +79,31 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "\'fooo";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) == 1);
|
||||
assert_se(streq(t, "\'fooo"));
|
||||
ASSERT_STREQ(t, "\'fooo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "KEY=val \"KEY2=val with space\" \"KEY3=val with \\\"quotation\\\"\"";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) == 1);
|
||||
assert_se(streq(t, "KEY=val"));
|
||||
ASSERT_STREQ(t, "KEY=val");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) == 1);
|
||||
assert_se(streq(t, "KEY2=val with space"));
|
||||
ASSERT_STREQ(t, "KEY2=val with space");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) == 1);
|
||||
assert_se(streq(t, "KEY3=val with \"quotation\""));
|
||||
ASSERT_STREQ(t, "KEY3=val with \"quotation\"");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "KEY=val \"KEY2=val space\" \"KEY3=val with \\\"quotation\\\"\"";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RETAIN_ESCAPE) == 1);
|
||||
assert_se(streq(t, "KEY=val"));
|
||||
ASSERT_STREQ(t, "KEY=val");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RETAIN_ESCAPE) == 1);
|
||||
assert_se(streq(t, "\"KEY2=val"));
|
||||
ASSERT_STREQ(t, "\"KEY2=val");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RETAIN_ESCAPE) == 1);
|
||||
assert_se(streq(t, "space\""));
|
||||
ASSERT_STREQ(t, "space\"");
|
||||
free(t);
|
||||
assert_se(startswith(p, "\"KEY3="));
|
||||
|
||||
@ -113,78 +113,78 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "\'fooo";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo"));
|
||||
ASSERT_STREQ(t, "fooo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "\"fooo";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo"));
|
||||
ASSERT_STREQ(t, "fooo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "yay\'foo\'bar";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "yay\'foo\'bar"));
|
||||
ASSERT_STREQ(t, "yay\'foo\'bar");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "yay\'foo\'bar";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "yayfoobar"));
|
||||
ASSERT_STREQ(t, "yayfoobar");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = " foobar ";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "foobar"));
|
||||
ASSERT_STREQ(t, "foobar");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = " foo\\ba\\x6ar ";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) > 0);
|
||||
assert_se(streq(t, "foo\ba\x6ar"));
|
||||
ASSERT_STREQ(t, "foo\ba\x6ar");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = " foo\\ba\\x6ar ";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "foobax6ar"));
|
||||
ASSERT_STREQ(t, "foobax6ar");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = " f\\u00f6o \"pi\\U0001F4A9le\" ";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) > 0);
|
||||
assert_se(streq(t, "föo"));
|
||||
ASSERT_STREQ(t, "föo");
|
||||
free(t);
|
||||
assert_se(p == original + 13);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE) > 0);
|
||||
assert_se(streq(t, "pi\360\237\222\251le"));
|
||||
ASSERT_STREQ(t, "pi\360\237\222\251le");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "fooo\\";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo"));
|
||||
ASSERT_STREQ(t, "fooo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "fooo\\";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNESCAPE_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo\\"));
|
||||
ASSERT_STREQ(t, "fooo\\");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "fooo\\";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNESCAPE_RELAX|EXTRACT_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo\\"));
|
||||
ASSERT_STREQ(t, "fooo\\");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "fooo\\";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo\\"));
|
||||
ASSERT_STREQ(t, "fooo\\");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -194,18 +194,18 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "\"foo\\";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX) > 0);
|
||||
assert_se(streq(t, "foo"));
|
||||
ASSERT_STREQ(t, "foo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "foo::bar";
|
||||
assert_se(extract_first_word(&p, &t, ":", 0) == 1);
|
||||
assert_se(streq(t, "foo"));
|
||||
ASSERT_STREQ(t, "foo");
|
||||
free(t);
|
||||
assert_se(p == original + 5);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, ":", 0) == 1);
|
||||
assert_se(streq(t, "bar"));
|
||||
ASSERT_STREQ(t, "bar");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -215,12 +215,12 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "foo\\:bar::waldo";
|
||||
assert_se(extract_first_word(&p, &t, ":", 0) == 1);
|
||||
assert_se(streq(t, "foo:bar"));
|
||||
ASSERT_STREQ(t, "foo:bar");
|
||||
free(t);
|
||||
assert_se(p == original + 10);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, ":", 0) == 1);
|
||||
assert_se(streq(t, "waldo"));
|
||||
ASSERT_STREQ(t, "waldo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -234,31 +234,31 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "\"foo\\";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_UNESCAPE_RELAX|EXTRACT_RELAX) > 0);
|
||||
assert_se(streq(t, "foo\\"));
|
||||
ASSERT_STREQ(t, "foo\\");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "\"foo\\";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX|EXTRACT_RELAX) > 0);
|
||||
assert_se(streq(t, "foo\\"));
|
||||
ASSERT_STREQ(t, "foo\\");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "fooo\\ bar quux";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo bar"));
|
||||
ASSERT_STREQ(t, "fooo bar");
|
||||
free(t);
|
||||
assert_se(p == original + 10);
|
||||
|
||||
p = original = "fooo\\ bar quux";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNESCAPE_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo bar"));
|
||||
ASSERT_STREQ(t, "fooo bar");
|
||||
free(t);
|
||||
assert_se(p == original + 10);
|
||||
|
||||
p = original = "fooo\\ bar quux";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNESCAPE_RELAX|EXTRACT_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo bar"));
|
||||
ASSERT_STREQ(t, "fooo bar");
|
||||
free(t);
|
||||
assert_se(p == original + 10);
|
||||
|
||||
@ -268,7 +268,7 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "fooo\\ bar quux";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX) > 0);
|
||||
assert_se(streq(t, "fooo\\ bar"));
|
||||
ASSERT_STREQ(t, "fooo\\ bar");
|
||||
free(t);
|
||||
assert_se(p == original + 10);
|
||||
|
||||
@ -278,52 +278,52 @@ TEST(extract_first_word) {
|
||||
|
||||
p = original = "\\w+@\\K[\\d.]+";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX) > 0);
|
||||
assert_se(streq(t, "\\w+@\\K[\\d.]+"));
|
||||
ASSERT_STREQ(t, "\\w+@\\K[\\d.]+");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "\\w+\\b";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX) > 0);
|
||||
assert_se(streq(t, "\\w+\b"));
|
||||
ASSERT_STREQ(t, "\\w+\b");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "-N ''";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "-N"));
|
||||
ASSERT_STREQ(t, "-N");
|
||||
free(t);
|
||||
assert_se(p == original + 3);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, ""));
|
||||
ASSERT_STREQ(t, "");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = ":foo\\:bar::waldo:";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
|
||||
assert_se(t);
|
||||
assert_se(streq(t, ""));
|
||||
ASSERT_STREQ(t, "");
|
||||
free(t);
|
||||
assert_se(p == original + 1);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "foo:bar"));
|
||||
ASSERT_STREQ(t, "foo:bar");
|
||||
free(t);
|
||||
assert_se(p == original + 10);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
|
||||
assert_se(t);
|
||||
assert_se(streq(t, ""));
|
||||
ASSERT_STREQ(t, "");
|
||||
free(t);
|
||||
assert_se(p == original + 11);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "waldo"));
|
||||
ASSERT_STREQ(t, "waldo");
|
||||
free(t);
|
||||
assert_se(p == original + 17);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, ""));
|
||||
ASSERT_STREQ(t, "");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
@ -333,34 +333,34 @@ TEST(extract_first_word) {
|
||||
|
||||
p = "foo\\xbar";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "fooxbar"));
|
||||
ASSERT_STREQ(t, "fooxbar");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
p = "foo\\xbar";
|
||||
assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RETAIN_ESCAPE) > 0);
|
||||
assert_se(streq(t, "foo\\xbar"));
|
||||
ASSERT_STREQ(t, "foo\\xbar");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
p = "\\:";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, ":"));
|
||||
ASSERT_STREQ(t, ":");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
p = "a\\:b";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a:b"));
|
||||
ASSERT_STREQ(t, "a:b");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
p = "a\\ b:c";
|
||||
assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a b"));
|
||||
ASSERT_STREQ(t, "a b");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "c"));
|
||||
ASSERT_STREQ(t, "c");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
@ -369,31 +369,31 @@ TEST(extract_first_word) {
|
||||
|
||||
p = "a\\\\ b:c\\\\x";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a\\ b"));
|
||||
ASSERT_STREQ(t, "a\\ b");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "c\\x"));
|
||||
ASSERT_STREQ(t, "c\\x");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
p = "\\:";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, ":"));
|
||||
ASSERT_STREQ(t, ":");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
p = "a\\:b";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a:b"));
|
||||
ASSERT_STREQ(t, "a:b");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
p = "a\\ b:c";
|
||||
assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a b"));
|
||||
ASSERT_STREQ(t, "a b");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "c"));
|
||||
ASSERT_STREQ(t, "c");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
@ -402,10 +402,10 @@ TEST(extract_first_word) {
|
||||
|
||||
p = "a\\\\ b:c\\\\x";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a\\ b"));
|
||||
ASSERT_STREQ(t, "a\\ b");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "c\\x"));
|
||||
ASSERT_STREQ(t, "c\\x");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
@ -415,136 +415,136 @@ TEST(extract_first_word) {
|
||||
p = "a\\:b";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE) == -EINVAL);
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE) == 1);
|
||||
assert_se(streq(t, "b"));
|
||||
ASSERT_STREQ(t, "b");
|
||||
free(t);
|
||||
|
||||
p = "a\\ b:c";
|
||||
assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE) == -EINVAL);
|
||||
assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE) == 1);
|
||||
assert_se(streq(t, "b"));
|
||||
ASSERT_STREQ(t, "b");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE) == 1);
|
||||
assert_se(streq(t, "c"));
|
||||
ASSERT_STREQ(t, "c");
|
||||
free(t);
|
||||
ASSERT_NULL(p);
|
||||
|
||||
p = original = "foobar=\"waldo\"maldo, baldo";
|
||||
assert_se(extract_first_word(&p, &t, "=\", ", 0) > 0);
|
||||
assert_se(streq(t, "foobar"));
|
||||
ASSERT_STREQ(t, "foobar");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, "=\", ", 0) > 0);
|
||||
assert_se(streq(t, "waldo"));
|
||||
ASSERT_STREQ(t, "waldo");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, "=\", ", 0) > 0);
|
||||
assert_se(streq(t, "maldo"));
|
||||
ASSERT_STREQ(t, "maldo");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, "=\", ", 0) > 0);
|
||||
assert_se(streq(t, "baldo"));
|
||||
ASSERT_STREQ(t, "baldo");
|
||||
free(t);
|
||||
|
||||
p = original = "mode=\"1777\",size=\"10%\",nr_inodes=\"400\"k,uid=\"496,,107\"520,gi\"\"'d=49610,'\"\"7520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\"";
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0);
|
||||
assert_se(streq(t, "mode=\"1777\""));
|
||||
ASSERT_STREQ(t, "mode=\"1777\"");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0);
|
||||
assert_se(streq(t, "size=\"10%\""));
|
||||
ASSERT_STREQ(t, "size=\"10%\"");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0);
|
||||
assert_se(streq(t, "nr_inodes=\"400\"k"));
|
||||
ASSERT_STREQ(t, "nr_inodes=\"400\"k");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0);
|
||||
assert_se(streq(t, "uid=\"496,,107\"520"));
|
||||
ASSERT_STREQ(t, "uid=\"496,,107\"520");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0);
|
||||
assert_se(streq(t, "gi\"\"'d=49610,'\"\"7520"));
|
||||
ASSERT_STREQ(t, "gi\"\"'d=49610,'\"\"7520");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0);
|
||||
assert_se(streq(t, "context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\""));
|
||||
ASSERT_STREQ(t, "context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\"");
|
||||
free(t);
|
||||
|
||||
p = original = "mode=\"1777\",size=\"10%\",nr_inodes=\"400\"k,uid=\"496,,107\"520,gi\"\"'d=49610,'\"\"7520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\"";
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "mode=1777"));
|
||||
ASSERT_STREQ(t, "mode=1777");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "size=10%"));
|
||||
ASSERT_STREQ(t, "size=10%");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "nr_inodes=400k"));
|
||||
ASSERT_STREQ(t, "nr_inodes=400k");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "uid=496,,107520"));
|
||||
ASSERT_STREQ(t, "uid=496,,107520");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "gid=49610,7520"));
|
||||
ASSERT_STREQ(t, "gid=49610,7520");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0);
|
||||
assert_se(streq(t, "context=system_u:object_r:svirt_sandbox_file_t:s0:c0,c1"));
|
||||
ASSERT_STREQ(t, "context=system_u:object_r:svirt_sandbox_file_t:s0:c0,c1");
|
||||
free(t);
|
||||
|
||||
p = "a:b";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a"));
|
||||
assert_se(streq(p, ":b"));
|
||||
ASSERT_STREQ(t, "a");
|
||||
ASSERT_STREQ(p, ":b");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "b"));
|
||||
ASSERT_STREQ(t, "b");
|
||||
free(t);
|
||||
|
||||
p = "a>:b";
|
||||
assert_se(extract_first_word(&p, &t, ">:", EXTRACT_RETAIN_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a"));
|
||||
assert_se(streq(p, ">:b"));
|
||||
ASSERT_STREQ(t, "a");
|
||||
ASSERT_STREQ(p, ">:b");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ">:", EXTRACT_RETAIN_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "b"));
|
||||
ASSERT_STREQ(t, "b");
|
||||
free(t);
|
||||
|
||||
p = "a>:b";
|
||||
assert_se(extract_first_word(&p, &t, ">:", EXTRACT_RETAIN_SEPARATORS|EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a"));
|
||||
assert_se(streq(p, ">:b"));
|
||||
ASSERT_STREQ(t, "a");
|
||||
ASSERT_STREQ(p, ">:b");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, ">:", EXTRACT_RETAIN_SEPARATORS|EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, ""));
|
||||
assert_se(streq(p, ">:b"));
|
||||
ASSERT_STREQ(t, "");
|
||||
ASSERT_STREQ(p, ">:b");
|
||||
free(t);
|
||||
|
||||
p = "a\\:b";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS|EXTRACT_RETAIN_ESCAPE) == 1);
|
||||
assert_se(streq(t, "a\\"));
|
||||
assert_se(streq(p, ":b"));
|
||||
ASSERT_STREQ(t, "a\\");
|
||||
ASSERT_STREQ(p, ":b");
|
||||
free(t);
|
||||
|
||||
p = "a\\:b";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a:b"));
|
||||
ASSERT_STREQ(t, "a:b");
|
||||
assert_se(!p);
|
||||
free(t);
|
||||
|
||||
p = "a\\:b";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS|EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a:b"));
|
||||
ASSERT_STREQ(t, "a:b");
|
||||
assert_se(!p);
|
||||
free(t);
|
||||
|
||||
p = "a\\:a:b";
|
||||
assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS|EXTRACT_UNESCAPE_SEPARATORS) == 1);
|
||||
assert_se(streq(t, "a:a"));
|
||||
assert_se(streq(p, ":b"));
|
||||
ASSERT_STREQ(t, "a:a");
|
||||
ASSERT_STREQ(p, ":b");
|
||||
free(t);
|
||||
|
||||
p = original = "zażółcić 👊🔪💐 가너도루";
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "zażółcić"));
|
||||
ASSERT_STREQ(t, "zażółcić");
|
||||
free(t);
|
||||
assert_se(p == original + 13);
|
||||
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "👊🔪💐"));
|
||||
ASSERT_STREQ(t, "👊🔪💐");
|
||||
free(t);
|
||||
assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
|
||||
assert_se(streq(t, "가너도루"));
|
||||
ASSERT_STREQ(t, "가너도루");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
}
|
||||
@ -555,12 +555,12 @@ TEST(extract_first_word_and_warn) {
|
||||
|
||||
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_STREQ(t, "foobar");
|
||||
free(t);
|
||||
assert_se(p == original + 7);
|
||||
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "waldo"));
|
||||
ASSERT_STREQ(t, "waldo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -570,12 +570,12 @@ TEST(extract_first_word_and_warn) {
|
||||
|
||||
p = original = "\"foobar\" \'waldo\'";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "foobar"));
|
||||
ASSERT_STREQ(t, "foobar");
|
||||
free(t);
|
||||
assert_se(p == original + 9);
|
||||
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "waldo"));
|
||||
ASSERT_STREQ(t, "waldo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -597,48 +597,48 @@ TEST(extract_first_word_and_warn) {
|
||||
|
||||
p = original = "\'fooo";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "fooo"));
|
||||
ASSERT_STREQ(t, "fooo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = " foo\\ba\\x6ar ";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "foo\ba\x6ar"));
|
||||
ASSERT_STREQ(t, "foo\ba\x6ar");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = " foo\\ba\\x6ar ";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "foobax6ar"));
|
||||
ASSERT_STREQ(t, "foobax6ar");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = " f\\u00f6o \"pi\\U0001F4A9le\" ";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "föo"));
|
||||
ASSERT_STREQ(t, "föo");
|
||||
free(t);
|
||||
assert_se(p == original + 13);
|
||||
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "pi\360\237\222\251le"));
|
||||
ASSERT_STREQ(t, "pi\360\237\222\251le");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "fooo\\";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "fooo"));
|
||||
ASSERT_STREQ(t, "fooo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "fooo\\";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "fooo\\"));
|
||||
ASSERT_STREQ(t, "fooo\\");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "fooo\\";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "fooo\\"));
|
||||
ASSERT_STREQ(t, "fooo\\");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -648,7 +648,7 @@ TEST(extract_first_word_and_warn) {
|
||||
|
||||
p = original = "\"foo\\";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "foo"));
|
||||
ASSERT_STREQ(t, "foo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
@ -658,37 +658,37 @@ TEST(extract_first_word_and_warn) {
|
||||
|
||||
p = original = "\"foo\\";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE|EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "foo"));
|
||||
ASSERT_STREQ(t, "foo");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "fooo\\ bar quux";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "fooo bar"));
|
||||
ASSERT_STREQ(t, "fooo bar");
|
||||
free(t);
|
||||
assert_se(p == original + 10);
|
||||
|
||||
p = original = "fooo\\ bar quux";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "fooo bar"));
|
||||
ASSERT_STREQ(t, "fooo bar");
|
||||
free(t);
|
||||
assert_se(p == original + 10);
|
||||
|
||||
p = original = "fooo\\ bar quux";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "fooo\\ bar"));
|
||||
ASSERT_STREQ(t, "fooo\\ bar");
|
||||
free(t);
|
||||
assert_se(p == original + 10);
|
||||
|
||||
p = original = "\\w+@\\K[\\d.]+";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "\\w+@\\K[\\d.]+"));
|
||||
ASSERT_STREQ(t, "\\w+@\\K[\\d.]+");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
|
||||
p = original = "\\w+\\b";
|
||||
assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
|
||||
assert_se(streq(t, "\\w+\b"));
|
||||
ASSERT_STREQ(t, "\\w+\b");
|
||||
free(t);
|
||||
assert_se(isempty(p));
|
||||
}
|
||||
@ -700,9 +700,9 @@ TEST(extract_many_words) {
|
||||
p = original = "foobar waldi piep";
|
||||
assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c) == 3);
|
||||
assert_se(isempty(p));
|
||||
assert_se(streq_ptr(a, "foobar"));
|
||||
assert_se(streq_ptr(b, "waldi"));
|
||||
assert_se(streq_ptr(c, "piep"));
|
||||
ASSERT_STREQ(a, "foobar");
|
||||
ASSERT_STREQ(b, "waldi");
|
||||
ASSERT_STREQ(c, "piep");
|
||||
free(a);
|
||||
free(b);
|
||||
free(c);
|
||||
@ -710,13 +710,13 @@ TEST(extract_many_words) {
|
||||
p = original = "foobar:waldi:piep ba1:ba2";
|
||||
assert_se(extract_many_words(&p, ":" WHITESPACE, 0, &a, &b, &c) == 3);
|
||||
assert_se(!isempty(p));
|
||||
assert_se(streq_ptr(a, "foobar"));
|
||||
assert_se(streq_ptr(b, "waldi"));
|
||||
assert_se(streq_ptr(c, "piep"));
|
||||
ASSERT_STREQ(a, "foobar");
|
||||
ASSERT_STREQ(b, "waldi");
|
||||
ASSERT_STREQ(c, "piep");
|
||||
assert_se(extract_many_words(&p, ":" WHITESPACE, 0, &d, &e, &f) == 2);
|
||||
assert_se(isempty(p));
|
||||
assert_se(streq_ptr(d, "ba1"));
|
||||
assert_se(streq_ptr(e, "ba2"));
|
||||
ASSERT_STREQ(d, "ba1");
|
||||
ASSERT_STREQ(e, "ba2");
|
||||
assert_se(isempty(f));
|
||||
free(a);
|
||||
free(b);
|
||||
@ -728,34 +728,34 @@ TEST(extract_many_words) {
|
||||
p = original = "'foobar' wa\"ld\"i ";
|
||||
assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c) == 2);
|
||||
assert_se(isempty(p));
|
||||
assert_se(streq_ptr(a, "'foobar'"));
|
||||
assert_se(streq_ptr(b, "wa\"ld\"i"));
|
||||
assert_se(streq_ptr(c, NULL));
|
||||
ASSERT_STREQ(a, "'foobar'");
|
||||
ASSERT_STREQ(b, "wa\"ld\"i");
|
||||
ASSERT_STREQ(c, NULL);
|
||||
free(a);
|
||||
free(b);
|
||||
|
||||
p = original = "'foobar' wa\"ld\"i ";
|
||||
assert_se(extract_many_words(&p, NULL, EXTRACT_UNQUOTE, &a, &b, &c) == 2);
|
||||
assert_se(isempty(p));
|
||||
assert_se(streq_ptr(a, "foobar"));
|
||||
assert_se(streq_ptr(b, "waldi"));
|
||||
assert_se(streq_ptr(c, NULL));
|
||||
ASSERT_STREQ(a, "foobar");
|
||||
ASSERT_STREQ(b, "waldi");
|
||||
ASSERT_STREQ(c, NULL);
|
||||
free(a);
|
||||
free(b);
|
||||
|
||||
p = original = "";
|
||||
assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c) == 0);
|
||||
assert_se(isempty(p));
|
||||
assert_se(streq_ptr(a, NULL));
|
||||
assert_se(streq_ptr(b, NULL));
|
||||
assert_se(streq_ptr(c, NULL));
|
||||
ASSERT_STREQ(a, NULL);
|
||||
ASSERT_STREQ(b, NULL);
|
||||
ASSERT_STREQ(c, NULL);
|
||||
|
||||
p = original = " ";
|
||||
assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c) == 0);
|
||||
assert_se(isempty(p));
|
||||
assert_se(streq_ptr(a, NULL));
|
||||
assert_se(streq_ptr(b, NULL));
|
||||
assert_se(streq_ptr(c, NULL));
|
||||
ASSERT_STREQ(a, NULL);
|
||||
ASSERT_STREQ(b, NULL);
|
||||
ASSERT_STREQ(c, NULL);
|
||||
|
||||
p = original = "foobar";
|
||||
assert_se(extract_many_words(&p, NULL, 0) == 0);
|
||||
@ -764,21 +764,21 @@ TEST(extract_many_words) {
|
||||
p = original = "foobar waldi";
|
||||
assert_se(extract_many_words(&p, NULL, 0, &a) == 1);
|
||||
assert_se(p == original+7);
|
||||
assert_se(streq_ptr(a, "foobar"));
|
||||
ASSERT_STREQ(a, "foobar");
|
||||
free(a);
|
||||
|
||||
p = original = " foobar ";
|
||||
assert_se(extract_many_words(&p, NULL, 0, &a) == 1);
|
||||
assert_se(isempty(p));
|
||||
assert_se(streq_ptr(a, "foobar"));
|
||||
ASSERT_STREQ(a, "foobar");
|
||||
free(a);
|
||||
|
||||
p = original = "gęślą:👊🔪💐 가너도루";
|
||||
assert_se(extract_many_words(&p, ":" WHITESPACE, 0, &a, &b, &c) == 3);
|
||||
assert_se(isempty(p));
|
||||
assert_se(streq(a, "gęślą"));
|
||||
assert_se(streq(b, "👊🔪💐"));
|
||||
assert_se(streq(c, "가너도루"));
|
||||
ASSERT_STREQ(a, "gęślą");
|
||||
ASSERT_STREQ(b, "👊🔪💐");
|
||||
ASSERT_STREQ(c, "가너도루");
|
||||
free(a);
|
||||
free(b);
|
||||
free(c);
|
||||
|
||||
@ -397,11 +397,11 @@ TEST(close_all_fds) {
|
||||
}
|
||||
|
||||
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(3), "/proc/self/fd/3"));
|
||||
assert_se(streq_ptr(FORMAT_PROC_FD_PATH(2147483647), "/proc/self/fd/2147483647"));
|
||||
ASSERT_STREQ(FORMAT_PROC_FD_PATH(0), "/proc/self/fd/0");
|
||||
ASSERT_STREQ(FORMAT_PROC_FD_PATH(1), "/proc/self/fd/1");
|
||||
ASSERT_STREQ(FORMAT_PROC_FD_PATH(2), "/proc/self/fd/2");
|
||||
ASSERT_STREQ(FORMAT_PROC_FD_PATH(3), "/proc/self/fd/3");
|
||||
ASSERT_STREQ(FORMAT_PROC_FD_PATH(2147483647), "/proc/self/fd/2147483647");
|
||||
}
|
||||
|
||||
TEST(fd_reopen) {
|
||||
@ -676,7 +676,7 @@ TEST(fd_get_path) {
|
||||
tfd = mkdtemp_open(NULL, O_PATH, &t);
|
||||
assert_se(tfd >= 0);
|
||||
assert_se(fd_get_path(tfd, &p) >= 0);
|
||||
assert_se(streq(p, t));
|
||||
ASSERT_STREQ(p, t);
|
||||
|
||||
p = mfree(p);
|
||||
|
||||
@ -684,7 +684,7 @@ TEST(fd_get_path) {
|
||||
assert_se(chdir(t) >= 0);
|
||||
|
||||
assert_se(fd_get_path(AT_FDCWD, &p) >= 0);
|
||||
assert_se(streq(p, t));
|
||||
ASSERT_STREQ(p, t);
|
||||
|
||||
p = mfree(p);
|
||||
|
||||
@ -697,7 +697,7 @@ TEST(fd_get_path) {
|
||||
fd = openat(tfd, "regular", O_CLOEXEC|O_PATH);
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
p = mfree(p);
|
||||
fd = safe_close(fd);
|
||||
@ -705,7 +705,7 @@ TEST(fd_get_path) {
|
||||
fd = openat(AT_FDCWD, "regular", O_CLOEXEC|O_PATH);
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
p = mfree(p);
|
||||
fd = safe_close(fd);
|
||||
@ -714,7 +714,7 @@ TEST(fd_get_path) {
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_verify_regular(fd) >= 0);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
p = mfree(p);
|
||||
fd = safe_close(fd);
|
||||
@ -723,7 +723,7 @@ TEST(fd_get_path) {
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_verify_regular(fd) >= 0);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
p = mfree(p);
|
||||
fd = safe_close(fd);
|
||||
@ -732,7 +732,7 @@ TEST(fd_get_path) {
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_verify_regular(fd) >= 0);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
p = mfree(p);
|
||||
fd = safe_close(fd);
|
||||
@ -741,7 +741,7 @@ TEST(fd_get_path) {
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_verify_regular(fd) >= 0);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
p = mfree(p);
|
||||
q = mfree(q);
|
||||
@ -752,7 +752,7 @@ TEST(fd_get_path) {
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_verify_regular(fd) == -ELOOP);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
p = mfree(p);
|
||||
fd = safe_close(fd);
|
||||
@ -761,7 +761,7 @@ TEST(fd_get_path) {
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_verify_regular(fd) == -ELOOP);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
p = mfree(p);
|
||||
fd = safe_close(fd);
|
||||
@ -770,7 +770,7 @@ TEST(fd_get_path) {
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_verify_regular(fd) == -ELOOP);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
p = mfree(p);
|
||||
fd = safe_close(fd);
|
||||
@ -779,7 +779,7 @@ TEST(fd_get_path) {
|
||||
assert_se(fd >= 0);
|
||||
assert_se(fd_verify_regular(fd) == -ELOOP);
|
||||
assert_se(fd_get_path(fd, &p) >= 0);
|
||||
assert_se(streq(p, q));
|
||||
ASSERT_STREQ(p, q);
|
||||
|
||||
assert_se(chdir(saved_cwd) >= 0);
|
||||
}
|
||||
|
||||
@ -71,19 +71,19 @@ TEST(parse_env_file) {
|
||||
STRV_FOREACH(i, a)
|
||||
log_info("Got: <%s>", *i);
|
||||
|
||||
assert_se(streq_ptr(a[0], "one=BAR"));
|
||||
assert_se(streq_ptr(a[1], "two=bar"));
|
||||
assert_se(streq_ptr(a[2], "three=333\nxxxx"));
|
||||
assert_se(streq_ptr(a[3], "four=44\\\"44"));
|
||||
assert_se(streq_ptr(a[4], "five=55\"55FIVEcinco"));
|
||||
assert_se(streq_ptr(a[5], "six=seis sechs sis"));
|
||||
assert_se(streq_ptr(a[6], "seven=sevenval#nocomment"));
|
||||
assert_se(streq_ptr(a[7], "eight=eightval #nocomment"));
|
||||
assert_se(streq_ptr(a[8], "export nine=nineval"));
|
||||
assert_se(streq_ptr(a[9], "ten="));
|
||||
assert_se(streq_ptr(a[10], "eleven=value"));
|
||||
assert_se(streq_ptr(a[11], "twelve=\\value"));
|
||||
assert_se(streq_ptr(a[12], "thirteen=\\value"));
|
||||
ASSERT_STREQ(a[0], "one=BAR");
|
||||
ASSERT_STREQ(a[1], "two=bar");
|
||||
ASSERT_STREQ(a[2], "three=333\nxxxx");
|
||||
ASSERT_STREQ(a[3], "four=44\\\"44");
|
||||
ASSERT_STREQ(a[4], "five=55\"55FIVEcinco");
|
||||
ASSERT_STREQ(a[5], "six=seis sechs sis");
|
||||
ASSERT_STREQ(a[6], "seven=sevenval#nocomment");
|
||||
ASSERT_STREQ(a[7], "eight=eightval #nocomment");
|
||||
ASSERT_STREQ(a[8], "export nine=nineval");
|
||||
ASSERT_STREQ(a[9], "ten=");
|
||||
ASSERT_STREQ(a[10], "eleven=value");
|
||||
ASSERT_STREQ(a[11], "twelve=\\value");
|
||||
ASSERT_STREQ(a[12], "thirteen=\\value");
|
||||
ASSERT_NULL(a[13]);
|
||||
|
||||
strv_env_clean(a);
|
||||
@ -91,7 +91,7 @@ TEST(parse_env_file) {
|
||||
k = 0;
|
||||
STRV_FOREACH(i, b) {
|
||||
log_info("Got2: <%s>", *i);
|
||||
assert_se(streq(*i, a[k++]));
|
||||
ASSERT_STREQ(*i, a[k++]);
|
||||
}
|
||||
|
||||
r = parse_env_file(
|
||||
@ -125,19 +125,19 @@ TEST(parse_env_file) {
|
||||
log_info("twelve=[%s]", strna(twelve));
|
||||
log_info("thirteen=[%s]", strna(thirteen));
|
||||
|
||||
assert_se(streq(one, "BAR"));
|
||||
assert_se(streq(two, "bar"));
|
||||
assert_se(streq(three, "333\nxxxx"));
|
||||
assert_se(streq(four, "44\\\"44"));
|
||||
assert_se(streq(five, "55\"55FIVEcinco"));
|
||||
assert_se(streq(six, "seis sechs sis"));
|
||||
assert_se(streq(seven, "sevenval#nocomment"));
|
||||
assert_se(streq(eight, "eightval #nocomment"));
|
||||
assert_se(streq(nine, "nineval"));
|
||||
ASSERT_STREQ(one, "BAR");
|
||||
ASSERT_STREQ(two, "bar");
|
||||
ASSERT_STREQ(three, "333\nxxxx");
|
||||
ASSERT_STREQ(four, "44\\\"44");
|
||||
ASSERT_STREQ(five, "55\"55FIVEcinco");
|
||||
ASSERT_STREQ(six, "seis sechs sis");
|
||||
ASSERT_STREQ(seven, "sevenval#nocomment");
|
||||
ASSERT_STREQ(eight, "eightval #nocomment");
|
||||
ASSERT_STREQ(nine, "nineval");
|
||||
ASSERT_NULL(ten);
|
||||
assert_se(streq(eleven, "value"));
|
||||
assert_se(streq(twelve, "\\value"));
|
||||
assert_se(streq(thirteen, "\\value"));
|
||||
ASSERT_STREQ(eleven, "value");
|
||||
ASSERT_STREQ(twelve, "\\value");
|
||||
ASSERT_STREQ(thirteen, "\\value");
|
||||
|
||||
{
|
||||
/* prepare a temporary file to write the environment to */
|
||||
@ -161,7 +161,7 @@ static void test_one_shell_var(const char *file, const char *variable, const cha
|
||||
assert_se(f = popen(cmd, "re"));
|
||||
assert_se(read_full_stream(f, &from_shell, &sz) >= 0);
|
||||
assert_se(sz == strlen(value));
|
||||
assert_se(streq(from_shell, value));
|
||||
ASSERT_STREQ(from_shell, value);
|
||||
}
|
||||
|
||||
TEST(parse_multiline_env_file) {
|
||||
@ -198,9 +198,9 @@ TEST(parse_multiline_env_file) {
|
||||
STRV_FOREACH(i, a)
|
||||
log_info("Got: <%s>", *i);
|
||||
|
||||
assert_se(streq_ptr(a[0], "one=BAR VAR\tGAR"));
|
||||
assert_se(streq_ptr(a[1], "two=bar var\tgar"));
|
||||
assert_se(streq_ptr(a[2], "tri=bar var \tgar "));
|
||||
ASSERT_STREQ(a[0], "one=BAR VAR\tGAR");
|
||||
ASSERT_STREQ(a[1], "two=bar var\tgar");
|
||||
ASSERT_STREQ(a[2], "tri=bar var \tgar ");
|
||||
ASSERT_NULL(a[3]);
|
||||
|
||||
{
|
||||
@ -246,16 +246,16 @@ TEST(merge_env_file) {
|
||||
STRV_FOREACH(i, a)
|
||||
log_info("Got: <%s>", *i);
|
||||
|
||||
assert_se(streq(a[0], "one=2"));
|
||||
assert_se(streq(a[1], "twelve=12"));
|
||||
assert_se(streq(a[2], "twentyone=21"));
|
||||
assert_se(streq(a[3], "twentytwo=22"));
|
||||
assert_se(streq(a[4], "xxx=0x222"));
|
||||
assert_se(streq(a[5], "xxx_minus_three= - 3"));
|
||||
assert_se(streq(a[6], "yyy=2"));
|
||||
assert_se(streq(a[7], "zzz=replacement"));
|
||||
assert_se(streq(a[8], "zzzz="));
|
||||
assert_se(streq(a[9], "zzzzz="));
|
||||
ASSERT_STREQ(a[0], "one=2");
|
||||
ASSERT_STREQ(a[1], "twelve=12");
|
||||
ASSERT_STREQ(a[2], "twentyone=21");
|
||||
ASSERT_STREQ(a[3], "twentytwo=22");
|
||||
ASSERT_STREQ(a[4], "xxx=0x222");
|
||||
ASSERT_STREQ(a[5], "xxx_minus_three= - 3");
|
||||
ASSERT_STREQ(a[6], "yyy=2");
|
||||
ASSERT_STREQ(a[7], "zzz=replacement");
|
||||
ASSERT_STREQ(a[8], "zzzz=");
|
||||
ASSERT_STREQ(a[9], "zzzzz=");
|
||||
ASSERT_NULL(a[10]);
|
||||
|
||||
r = merge_env_file(&a, NULL, t);
|
||||
@ -265,16 +265,16 @@ TEST(merge_env_file) {
|
||||
STRV_FOREACH(i, a)
|
||||
log_info("Got2: <%s>", *i);
|
||||
|
||||
assert_se(streq(a[0], "one=2"));
|
||||
assert_se(streq(a[1], "twelve=12"));
|
||||
assert_se(streq(a[2], "twentyone=21"));
|
||||
assert_se(streq(a[3], "twentytwo=22"));
|
||||
assert_se(streq(a[4], "xxx=0x222"));
|
||||
assert_se(streq(a[5], "xxx_minus_three=0x222 - 3"));
|
||||
assert_se(streq(a[6], "yyy=2"));
|
||||
assert_se(streq(a[7], "zzz=replacement"));
|
||||
assert_se(streq(a[8], "zzzz="));
|
||||
assert_se(streq(a[9], "zzzzz="));
|
||||
ASSERT_STREQ(a[0], "one=2");
|
||||
ASSERT_STREQ(a[1], "twelve=12");
|
||||
ASSERT_STREQ(a[2], "twentyone=21");
|
||||
ASSERT_STREQ(a[3], "twentytwo=22");
|
||||
ASSERT_STREQ(a[4], "xxx=0x222");
|
||||
ASSERT_STREQ(a[5], "xxx_minus_three=0x222 - 3");
|
||||
ASSERT_STREQ(a[6], "yyy=2");
|
||||
ASSERT_STREQ(a[7], "zzz=replacement");
|
||||
ASSERT_STREQ(a[8], "zzzz=");
|
||||
ASSERT_STREQ(a[9], "zzzzz=");
|
||||
ASSERT_NULL(a[10]);
|
||||
}
|
||||
|
||||
@ -323,7 +323,7 @@ TEST(executable_is_script) {
|
||||
|
||||
r = executable_is_script(t, &command);
|
||||
assert_se(r > 0);
|
||||
assert_se(streq(command, "/bin/script"));
|
||||
ASSERT_STREQ(command, "/bin/script");
|
||||
free(command);
|
||||
|
||||
r = executable_is_script("/bin/sh", &command);
|
||||
@ -398,27 +398,27 @@ TEST(read_one_line_file) {
|
||||
assert_se(f);
|
||||
|
||||
assert_se(read_one_line_file(fn, &buf) == 0);
|
||||
assert_se(streq_ptr(buf, ""));
|
||||
ASSERT_STREQ(buf, "");
|
||||
assert_se(read_one_line_file(fn, &buf2) == 0);
|
||||
assert_se(streq_ptr(buf2, ""));
|
||||
ASSERT_STREQ(buf2, "");
|
||||
|
||||
assert_se(write_string_stream(f, "x", WRITE_STRING_FILE_AVOID_NEWLINE) >= 0);
|
||||
fflush(f);
|
||||
|
||||
assert_se(read_one_line_file(fn, &buf3) == 1);
|
||||
assert_se(streq_ptr(buf3, "x"));
|
||||
ASSERT_STREQ(buf3, "x");
|
||||
|
||||
assert_se(write_string_stream(f, "\n", WRITE_STRING_FILE_AVOID_NEWLINE) >= 0);
|
||||
fflush(f);
|
||||
|
||||
assert_se(read_one_line_file(fn, &buf4) == 2);
|
||||
assert_se(streq_ptr(buf4, "x"));
|
||||
ASSERT_STREQ(buf4, "x");
|
||||
|
||||
assert_se(write_string_stream(f, "\n", WRITE_STRING_FILE_AVOID_NEWLINE) >= 0);
|
||||
fflush(f);
|
||||
|
||||
assert_se(read_one_line_file(fn, &buf5) == 2);
|
||||
assert_se(streq_ptr(buf5, "x"));
|
||||
ASSERT_STREQ(buf5, "x");
|
||||
}
|
||||
|
||||
TEST(write_string_stream) {
|
||||
@ -442,7 +442,7 @@ TEST(write_string_stream) {
|
||||
rewind(f);
|
||||
|
||||
assert_se(fgets(buf, sizeof(buf), f));
|
||||
assert_se(streq(buf, "boohoo\n"));
|
||||
ASSERT_STREQ(buf, "boohoo\n");
|
||||
f = safe_fclose(f);
|
||||
|
||||
f = fopen(fn, "w+");
|
||||
@ -453,7 +453,7 @@ TEST(write_string_stream) {
|
||||
|
||||
assert_se(fgets(buf, sizeof(buf), f));
|
||||
printf(">%s<", buf);
|
||||
assert_se(streq(buf, "boohoo"));
|
||||
ASSERT_STREQ(buf, "boohoo");
|
||||
}
|
||||
|
||||
TEST(write_string_file) {
|
||||
@ -467,7 +467,7 @@ TEST(write_string_file) {
|
||||
assert_se(write_string_file(fn, "boohoo", WRITE_STRING_FILE_CREATE) == 0);
|
||||
|
||||
assert_se(read(fd, buf, sizeof(buf)) == 7);
|
||||
assert_se(streq(buf, "boohoo\n"));
|
||||
ASSERT_STREQ(buf, "boohoo\n");
|
||||
}
|
||||
|
||||
TEST(write_string_file_no_create) {
|
||||
@ -482,7 +482,7 @@ TEST(write_string_file_no_create) {
|
||||
assert_se(write_string_file(fn, "boohoo", 0) == 0);
|
||||
|
||||
assert_se(read(fd, buf, sizeof buf) == (ssize_t) strlen("boohoo\n"));
|
||||
assert_se(streq(buf, "boohoo\n"));
|
||||
ASSERT_STREQ(buf, "boohoo\n");
|
||||
}
|
||||
|
||||
TEST(write_string_file_verify) {
|
||||
@ -578,14 +578,14 @@ TEST(search_and_fopen) {
|
||||
r = search_and_fopen(basename(name), "re", NULL, (const char**) dirs, &f, &p);
|
||||
assert_se(r >= 0);
|
||||
assert_se(e = path_startswith(p, "/tmp/"));
|
||||
assert_se(streq(basename(name), e));
|
||||
ASSERT_STREQ(basename(name), e);
|
||||
f = safe_fclose(f);
|
||||
p = mfree(p);
|
||||
|
||||
r = search_and_fopen(basename(name), NULL, NULL, (const char**) dirs, NULL, &p);
|
||||
assert_se(r >= 0);
|
||||
assert_se(e = path_startswith(p, "/tmp/"));
|
||||
assert_se(streq(basename(name), e));
|
||||
ASSERT_STREQ(basename(name), e);
|
||||
p = mfree(p);
|
||||
|
||||
r = search_and_fopen(name, "re", NULL, (const char**) dirs, &f, &p);
|
||||
@ -602,14 +602,14 @@ TEST(search_and_fopen) {
|
||||
r = search_and_fopen(basename(name), "re", "/", (const char**) dirs, &f, &p);
|
||||
assert_se(r >= 0);
|
||||
assert_se(e = path_startswith(p, "/tmp/"));
|
||||
assert_se(streq(basename(name), e));
|
||||
ASSERT_STREQ(basename(name), e);
|
||||
f = safe_fclose(f);
|
||||
p = mfree(p);
|
||||
|
||||
r = search_and_fopen(basename(name), NULL, "/", (const char**) dirs, NULL, &p);
|
||||
assert_se(r >= 0);
|
||||
assert_se(e = path_startswith(p, "/tmp/"));
|
||||
assert_se(streq(basename(name), e));
|
||||
ASSERT_STREQ(basename(name), e);
|
||||
p = mfree(p);
|
||||
|
||||
r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "re", NULL, (const char**) dirs, &f, &p);
|
||||
@ -649,7 +649,7 @@ TEST(search_and_fopen_nulstr) {
|
||||
r = search_and_fopen_nulstr(basename(name), "re", NULL, dirs, &f, &p);
|
||||
assert_se(r >= 0);
|
||||
assert_se(e = path_startswith(p, "/tmp/"));
|
||||
assert_se(streq(basename(name), e));
|
||||
ASSERT_STREQ(basename(name), e);
|
||||
f = safe_fclose(f);
|
||||
p = mfree(p);
|
||||
|
||||
@ -693,18 +693,18 @@ TEST(writing_tmpfile) {
|
||||
r = read_full_file(name, &contents, &size);
|
||||
assert_se(r == 0);
|
||||
printf("contents: %s", contents);
|
||||
assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
|
||||
ASSERT_STREQ(contents, "abc\n" ALPHANUMERICAL "\n");
|
||||
}
|
||||
|
||||
TEST(tempfn) {
|
||||
char *ret = NULL, *p;
|
||||
|
||||
assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
|
||||
assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
|
||||
ASSERT_STREQ(ret, "/foo/bar/.#waldoXXXXXX");
|
||||
free(ret);
|
||||
|
||||
assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
|
||||
assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX"));
|
||||
ASSERT_STREQ(ret, "/foo/bar/.#[miau]waldoXXXXXX");
|
||||
free(ret);
|
||||
|
||||
assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
|
||||
@ -900,7 +900,7 @@ TEST(read_line4) {
|
||||
|
||||
r = read_line(f, SIZE_MAX, &s);
|
||||
assert_se((size_t) r == eof_endings[i].length);
|
||||
assert_se(streq_ptr(s, "foo"));
|
||||
ASSERT_STREQ(s, "foo");
|
||||
|
||||
assert_se(read_line(f, SIZE_MAX, NULL) == 0); /* Ensure we hit EOF */
|
||||
}
|
||||
@ -985,7 +985,7 @@ TEST(read_full_file_socket) {
|
||||
assert_se(peer.un.sun_family == AF_UNIX);
|
||||
assert_se(peerlen > offsetof(struct sockaddr_un, sun_path));
|
||||
assert_se(peer.un.sun_path[0] == 0);
|
||||
assert_se(streq(peer.un.sun_path + 1, clientname + 1));
|
||||
ASSERT_STREQ(peer.un.sun_path + 1, clientname + 1);
|
||||
|
||||
#define TEST_STR "This is a test\nreally."
|
||||
|
||||
@ -996,7 +996,7 @@ TEST(read_full_file_socket) {
|
||||
assert_se(read_full_file_full(AT_FDCWD, jj, UINT64_MAX, SIZE_MAX, 0, NULL, &data, &size) == -ENXIO);
|
||||
assert_se(read_full_file_full(AT_FDCWD, jj, UINT64_MAX, SIZE_MAX, READ_FULL_FILE_CONNECT_SOCKET, clientname, &data, &size) >= 0);
|
||||
assert_se(size == strlen(TEST_STR));
|
||||
assert_se(streq(data, TEST_STR));
|
||||
ASSERT_STREQ(data, TEST_STR);
|
||||
|
||||
assert_se(wait_for_terminate_and_check("(server)", pid, WAIT_LOG) >= 0);
|
||||
#undef TEST_STR
|
||||
@ -1125,7 +1125,7 @@ TEST(fdopen_independent) {
|
||||
assert_se(fdopen_independent(fd, "re", &f) >= 0);
|
||||
zero(buf);
|
||||
assert_se(fread(buf, 1, sizeof(buf), f) == strlen(TEST_TEXT));
|
||||
assert_se(streq(buf, TEST_TEXT));
|
||||
ASSERT_STREQ(buf, TEST_TEXT);
|
||||
assert_se((fcntl(fileno(f), F_GETFL) & O_ACCMODE) == O_RDONLY);
|
||||
assert_se(FLAGS_SET(fcntl(fileno(f), F_GETFD), FD_CLOEXEC));
|
||||
f = safe_fclose(f);
|
||||
@ -1133,7 +1133,7 @@ TEST(fdopen_independent) {
|
||||
assert_se(fdopen_independent(fd, "r", &f) >= 0);
|
||||
zero(buf);
|
||||
assert_se(fread(buf, 1, sizeof(buf), f) == strlen(TEST_TEXT));
|
||||
assert_se(streq(buf, TEST_TEXT));
|
||||
ASSERT_STREQ(buf, TEST_TEXT);
|
||||
assert_se((fcntl(fileno(f), F_GETFL) & O_ACCMODE) == O_RDONLY);
|
||||
assert_se(!FLAGS_SET(fcntl(fileno(f), F_GETFD), FD_CLOEXEC));
|
||||
f = safe_fclose(f);
|
||||
@ -1141,7 +1141,7 @@ TEST(fdopen_independent) {
|
||||
assert_se(fdopen_independent(fd, "r+e", &f) >= 0);
|
||||
zero(buf);
|
||||
assert_se(fread(buf, 1, sizeof(buf), f) == strlen(TEST_TEXT));
|
||||
assert_se(streq(buf, TEST_TEXT));
|
||||
ASSERT_STREQ(buf, TEST_TEXT);
|
||||
assert_se((fcntl(fileno(f), F_GETFL) & O_ACCMODE) == O_RDWR);
|
||||
assert_se(FLAGS_SET(fcntl(fileno(f), F_GETFD), FD_CLOEXEC));
|
||||
f = safe_fclose(f);
|
||||
|
||||
@ -580,7 +580,7 @@ TEST(path_basename) {
|
||||
|
||||
assert_se(table_format(t, &formatted) >= 0);
|
||||
|
||||
assert_se(streq(formatted, "bar\nbar\nbaz\n"));
|
||||
ASSERT_STREQ(formatted, "bar\nbar\nbaz\n");
|
||||
}
|
||||
|
||||
TEST(dup_cell) {
|
||||
|
||||
@ -34,10 +34,10 @@ static void test_format_bytes_one(uint64_t val, bool trailing_B, const char *iec
|
||||
const char *si_with_p, const char *si_without_p) {
|
||||
char buf[FORMAT_BYTES_MAX];
|
||||
|
||||
assert_se(streq_ptr(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_USE_IEC | FORMAT_BYTES_BELOW_POINT | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), iec_with_p));
|
||||
assert_se(streq_ptr(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_USE_IEC | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), iec_without_p));
|
||||
assert_se(streq_ptr(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_BELOW_POINT | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), si_with_p));
|
||||
assert_se(streq_ptr(format_bytes_full(buf, sizeof buf, val, trailing_B ? FORMAT_BYTES_TRAILING_B : 0), si_without_p));
|
||||
ASSERT_STREQ(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_USE_IEC | FORMAT_BYTES_BELOW_POINT | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), iec_with_p);
|
||||
ASSERT_STREQ(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_USE_IEC | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), iec_without_p);
|
||||
ASSERT_STREQ(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_BELOW_POINT | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), si_with_p);
|
||||
ASSERT_STREQ(format_bytes_full(buf, sizeof buf, val, trailing_B ? FORMAT_BYTES_TRAILING_B : 0), si_without_p);
|
||||
}
|
||||
|
||||
TEST(format_bytes) {
|
||||
|
||||
@ -45,7 +45,7 @@ TEST(readlink_and_make_absolute) {
|
||||
log_tests_skipped_errno(errno, "symlink() not possible");
|
||||
} else {
|
||||
assert_se(readlink_and_make_absolute(name_alias, &r1) >= 0);
|
||||
assert_se(streq(r1, name));
|
||||
ASSERT_STREQ(r1, name);
|
||||
assert_se(unlink(name_alias) >= 0);
|
||||
|
||||
assert_se(safe_getcwd(&pwd) >= 0);
|
||||
@ -53,7 +53,7 @@ TEST(readlink_and_make_absolute) {
|
||||
assert_se(chdir(tempdir) >= 0);
|
||||
assert_se(symlink(name2, name_alias) >= 0);
|
||||
assert_se(readlink_and_make_absolute(name_alias, &r2) >= 0);
|
||||
assert_se(streq(r2, name));
|
||||
ASSERT_STREQ(r2, name);
|
||||
assert_se(unlink(name_alias) >= 0);
|
||||
|
||||
assert_se(chdir(pwd) >= 0);
|
||||
@ -97,33 +97,33 @@ TEST(var_tmp) {
|
||||
assert_se(unsetenv("TMP") >= 0);
|
||||
|
||||
assert_se(var_tmp_dir(&tmp_dir) >= 0);
|
||||
assert_se(streq(tmp_dir, "/var/tmp"));
|
||||
ASSERT_STREQ(tmp_dir, "/var/tmp");
|
||||
|
||||
assert_se(setenv("TMPDIR", "/tmp", true) >= 0);
|
||||
assert_se(streq(getenv("TMPDIR"), "/tmp"));
|
||||
ASSERT_STREQ(getenv("TMPDIR"), "/tmp");
|
||||
|
||||
assert_se(var_tmp_dir(&tmp_dir) >= 0);
|
||||
assert_se(streq(tmp_dir, "/tmp"));
|
||||
ASSERT_STREQ(tmp_dir, "/tmp");
|
||||
|
||||
assert_se(setenv("TMPDIR", "/88_does_not_exist_88", true) >= 0);
|
||||
assert_se(streq(getenv("TMPDIR"), "/88_does_not_exist_88"));
|
||||
ASSERT_STREQ(getenv("TMPDIR"), "/88_does_not_exist_88");
|
||||
|
||||
assert_se(var_tmp_dir(&tmp_dir) >= 0);
|
||||
assert_se(streq(tmp_dir, "/var/tmp"));
|
||||
ASSERT_STREQ(tmp_dir, "/var/tmp");
|
||||
|
||||
if (tmpdir_backup) {
|
||||
assert_se(setenv("TMPDIR", tmpdir_backup, true) >= 0);
|
||||
assert_se(streq(getenv("TMPDIR"), tmpdir_backup));
|
||||
ASSERT_STREQ(getenv("TMPDIR"), tmpdir_backup);
|
||||
}
|
||||
|
||||
if (temp_backup) {
|
||||
assert_se(setenv("TEMP", temp_backup, true) >= 0);
|
||||
assert_se(streq(getenv("TEMP"), temp_backup));
|
||||
ASSERT_STREQ(getenv("TEMP"), temp_backup);
|
||||
}
|
||||
|
||||
if (tmp_backup) {
|
||||
assert_se(setenv("TMP", tmp_backup, true) >= 0);
|
||||
assert_se(streq(getenv("TMP"), tmp_backup));
|
||||
ASSERT_STREQ(getenv("TMP"), tmp_backup);
|
||||
}
|
||||
}
|
||||
|
||||
@ -522,9 +522,9 @@ static void test_parse_cifs_service_one(const char *f, const char *h, const char
|
||||
_cleanup_free_ char *a = NULL, *b = NULL, *c = NULL;
|
||||
|
||||
assert_se(parse_cifs_service(f, &a, &b, &c) == ret);
|
||||
assert_se(streq_ptr(a, h));
|
||||
assert_se(streq_ptr(b, s));
|
||||
assert_se(streq_ptr(c, d));
|
||||
ASSERT_STREQ(a, h);
|
||||
ASSERT_STREQ(b, s);
|
||||
ASSERT_STREQ(c, d);
|
||||
}
|
||||
|
||||
TEST(parse_cifs_service) {
|
||||
@ -800,25 +800,25 @@ TEST(readlinkat_malloc) {
|
||||
assert_se(symlinkat(expect, tfd, "linkname") >= 0);
|
||||
|
||||
assert_se(readlinkat_malloc(tfd, "linkname", &p) >= 0);
|
||||
assert_se(streq(p, expect));
|
||||
ASSERT_STREQ(p, expect);
|
||||
p = mfree(p);
|
||||
|
||||
fd = openat(tfd, "linkname", O_PATH | O_NOFOLLOW | O_CLOEXEC);
|
||||
assert_se(fd >= 0);
|
||||
assert_se(readlinkat_malloc(fd, NULL, &p) >= 0);
|
||||
assert_se(streq(p, expect));
|
||||
ASSERT_STREQ(p, expect);
|
||||
p = mfree(p);
|
||||
assert_se(readlinkat_malloc(fd, "", &p) >= 0);
|
||||
assert_se(streq(p, expect));
|
||||
ASSERT_STREQ(p, expect);
|
||||
p = mfree(p);
|
||||
fd = safe_close(fd);
|
||||
|
||||
assert_se(q = path_join(t, "linkname"));
|
||||
assert_se(readlinkat_malloc(AT_FDCWD, q, &p) >= 0);
|
||||
assert_se(streq(p, expect));
|
||||
ASSERT_STREQ(p, expect);
|
||||
p = mfree(p);
|
||||
assert_se(readlinkat_malloc(INT_MAX, q, &p) >= 0);
|
||||
assert_se(streq(p, expect));
|
||||
ASSERT_STREQ(p, expect);
|
||||
p = mfree(p);
|
||||
q = mfree(q);
|
||||
}
|
||||
|
||||
@ -39,9 +39,9 @@ static void do_fstab_filter_options(const char *opts,
|
||||
opts, r, strnull(name), value, filtered,
|
||||
r_expected, strnull(name_expected), strnull(value_expected), filtered_expected ?: opts);
|
||||
assert_se(r == r_expected);
|
||||
assert_se(streq_ptr(name, name_expected));
|
||||
assert_se(streq_ptr(value, value_expected));
|
||||
assert_se(streq_ptr(filtered, filtered_expected ?: opts));
|
||||
ASSERT_STREQ(name, name_expected);
|
||||
ASSERT_STREQ(value, value_expected);
|
||||
ASSERT_STREQ(filtered, filtered_expected ?: opts);
|
||||
|
||||
/* test mode which returns all the values */
|
||||
|
||||
@ -51,8 +51,8 @@ static void do_fstab_filter_options(const char *opts,
|
||||
opts, r, strnull(name), joined,
|
||||
r_values_expected, strnull(name_expected), strnull(values_expected));
|
||||
assert_se(r == r_values_expected);
|
||||
assert_se(streq_ptr(name, r_values_expected > 0 ? name_expected : NULL));
|
||||
assert_se(streq_ptr(joined, values_expected));
|
||||
ASSERT_STREQ(name, r_values_expected > 0 ? name_expected : NULL);
|
||||
ASSERT_STREQ(joined, values_expected);
|
||||
|
||||
/* also test the malloc-less mode */
|
||||
r = fstab_filter_options(opts, remove, &name, NULL, NULL, NULL);
|
||||
@ -60,7 +60,7 @@ static void do_fstab_filter_options(const char *opts,
|
||||
opts, r, strnull(name),
|
||||
r_expected, strnull(name_expected));
|
||||
assert_se(r == r_expected);
|
||||
assert_se(streq_ptr(name, name_expected));
|
||||
ASSERT_STREQ(name, name_expected);
|
||||
}
|
||||
|
||||
TEST(fstab_filter_options) {
|
||||
@ -160,32 +160,32 @@ TEST(fstab_node_to_udev_node) {
|
||||
|
||||
n = fstab_node_to_udev_node("LABEL=applé/jack");
|
||||
puts(n);
|
||||
assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack"));
|
||||
ASSERT_STREQ(n, "/dev/disk/by-label/applé\\x2fjack");
|
||||
free(n);
|
||||
|
||||
n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
|
||||
puts(n);
|
||||
assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie"));
|
||||
ASSERT_STREQ(n, "/dev/disk/by-partlabel/pinkié\\x20pie");
|
||||
free(n);
|
||||
|
||||
n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
|
||||
puts(n);
|
||||
assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
|
||||
ASSERT_STREQ(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535");
|
||||
free(n);
|
||||
|
||||
n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
|
||||
puts(n);
|
||||
assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
|
||||
ASSERT_STREQ(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535");
|
||||
free(n);
|
||||
|
||||
n = fstab_node_to_udev_node("PONIES=awesome");
|
||||
puts(n);
|
||||
assert_se(streq(n, "PONIES=awesome"));
|
||||
ASSERT_STREQ(n, "PONIES=awesome");
|
||||
free(n);
|
||||
|
||||
n = fstab_node_to_udev_node("/dev/xda1");
|
||||
puts(n);
|
||||
assert_se(streq(n, "/dev/xda1"));
|
||||
ASSERT_STREQ(n, "/dev/xda1");
|
||||
free(n);
|
||||
}
|
||||
|
||||
|
||||
@ -24,7 +24,7 @@ TEST(glob_first) {
|
||||
|
||||
r = glob_first("/tmp/test-glob_first*", &first);
|
||||
assert_se(r == 1);
|
||||
assert_se(streq(name, first));
|
||||
ASSERT_STREQ(name, first);
|
||||
first = mfree(first);
|
||||
|
||||
r = unlink(name);
|
||||
@ -109,7 +109,7 @@ TEST(safe_glob) {
|
||||
r = safe_glob(fn2, GLOB_NOSORT|GLOB_BRACE, &g);
|
||||
assert_se(r == 0);
|
||||
assert_se(g.gl_pathc == 1);
|
||||
assert_se(streq(g.gl_pathv[0], fname));
|
||||
ASSERT_STREQ(g.gl_pathv[0], fname);
|
||||
ASSERT_NULL(g.gl_pathv[1]);
|
||||
|
||||
(void) rm_rf(template, REMOVE_ROOT|REMOVE_PHYSICAL);
|
||||
@ -119,7 +119,7 @@ static void test_glob_non_glob_prefix_one(const char *path, const char *expected
|
||||
_cleanup_free_ char *t;
|
||||
|
||||
assert_se(glob_non_glob_prefix(path, &t) == 0);
|
||||
assert_se(streq(t, expected));
|
||||
ASSERT_STREQ(t, expected);
|
||||
}
|
||||
|
||||
TEST(glob_non_glob) {
|
||||
|
||||
@ -94,7 +94,7 @@ TEST(override_architecture) {
|
||||
ASSERT_EQ(x.arch, y.arch);
|
||||
ASSERT_EQ(x.designator, y.designator);
|
||||
assert_se(sd_id128_equal(x.uuid, y.uuid));
|
||||
assert_se(streq(x.name, y.name));
|
||||
ASSERT_STREQ(x.name, y.name);
|
||||
|
||||
/* If the partition type does not have an architecture, nothing should change. */
|
||||
|
||||
@ -105,7 +105,7 @@ TEST(override_architecture) {
|
||||
ASSERT_EQ(x.arch, y.arch);
|
||||
ASSERT_EQ(x.designator, y.designator);
|
||||
assert_se(sd_id128_equal(x.uuid, y.uuid));
|
||||
assert_se(streq(x.name, y.name));
|
||||
ASSERT_STREQ(x.name, y.name);
|
||||
}
|
||||
|
||||
DEFINE_TEST_MAIN(LOG_INFO);
|
||||
|
||||
@ -42,11 +42,11 @@ TEST(hashmap_replace) {
|
||||
|
||||
hashmap_replace(m, "key 3", val1);
|
||||
r = hashmap_get(m, "key 3");
|
||||
assert_se(streq(r, "val1"));
|
||||
ASSERT_STREQ(r, "val1");
|
||||
|
||||
hashmap_replace(m, "key 5", val5);
|
||||
r = hashmap_get(m, "key 5");
|
||||
assert_se(streq(r, "val5"));
|
||||
ASSERT_STREQ(r, "val5");
|
||||
}
|
||||
|
||||
TEST(hashmap_copy) {
|
||||
@ -73,13 +73,13 @@ TEST(hashmap_copy) {
|
||||
copy = hashmap_copy(m);
|
||||
|
||||
r = hashmap_get(copy, "key 1");
|
||||
assert_se(streq(r, "val1"));
|
||||
ASSERT_STREQ(r, "val1");
|
||||
r = hashmap_get(copy, "key 2");
|
||||
assert_se(streq(r, "val2"));
|
||||
ASSERT_STREQ(r, "val2");
|
||||
r = hashmap_get(copy, "key 3");
|
||||
assert_se(streq(r, "val3"));
|
||||
ASSERT_STREQ(r, "val3");
|
||||
r = hashmap_get(copy, "key 4");
|
||||
assert_se(streq(r, "val4"));
|
||||
ASSERT_STREQ(r, "val4");
|
||||
}
|
||||
|
||||
TEST(hashmap_get_strv) {
|
||||
@ -109,10 +109,10 @@ TEST(hashmap_get_strv) {
|
||||
strv = strv_sort(strv);
|
||||
#endif
|
||||
|
||||
assert_se(streq(strv[0], "val1"));
|
||||
assert_se(streq(strv[1], "val2"));
|
||||
assert_se(streq(strv[2], "val3"));
|
||||
assert_se(streq(strv[3], "val4"));
|
||||
ASSERT_STREQ(strv[0], "val1");
|
||||
ASSERT_STREQ(strv[1], "val2");
|
||||
ASSERT_STREQ(strv[2], "val3");
|
||||
ASSERT_STREQ(strv[3], "val4");
|
||||
}
|
||||
|
||||
TEST(hashmap_move_one) {
|
||||
@ -203,15 +203,15 @@ TEST(hashmap_update) {
|
||||
|
||||
hashmap_put(m, "key 1", val1);
|
||||
r = hashmap_get(m, "key 1");
|
||||
assert_se(streq(r, "old_value"));
|
||||
ASSERT_STREQ(r, "old_value");
|
||||
|
||||
assert_se(hashmap_update(m, "key 2", val2) == -ENOENT);
|
||||
r = hashmap_get(m, "key 1");
|
||||
assert_se(streq(r, "old_value"));
|
||||
ASSERT_STREQ(r, "old_value");
|
||||
|
||||
assert_se(hashmap_update(m, "key 1", val2) == 0);
|
||||
r = hashmap_get(m, "key 1");
|
||||
assert_se(streq(r, "new_value"));
|
||||
ASSERT_STREQ(r, "new_value");
|
||||
}
|
||||
|
||||
TEST(hashmap_put) {
|
||||
@ -250,10 +250,10 @@ TEST(hashmap_remove1) {
|
||||
hashmap_put(m, "key 2", (void*) "val 2");
|
||||
|
||||
r = hashmap_remove(m, "key 1");
|
||||
assert_se(streq(r, "val 1"));
|
||||
ASSERT_STREQ(r, "val 1");
|
||||
|
||||
r = hashmap_get(m, "key 2");
|
||||
assert_se(streq(r, "val 2"));
|
||||
ASSERT_STREQ(r, "val 2");
|
||||
assert_se(!hashmap_get(m, "key 1"));
|
||||
}
|
||||
|
||||
@ -278,13 +278,13 @@ TEST(hashmap_remove2) {
|
||||
hashmap_put(m, strdup(key2), strdup(val2));
|
||||
|
||||
r = hashmap_remove2(m, key1, &r2);
|
||||
assert_se(streq(r, val1));
|
||||
assert_se(streq(r2, key1));
|
||||
ASSERT_STREQ(r, val1);
|
||||
ASSERT_STREQ(r2, key1);
|
||||
free(r);
|
||||
free(r2);
|
||||
|
||||
r = hashmap_get(m, key2);
|
||||
assert_se(streq(r, val2));
|
||||
ASSERT_STREQ(r, val2);
|
||||
assert_se(!hashmap_get(m, key1));
|
||||
}
|
||||
|
||||
@ -308,17 +308,17 @@ TEST(hashmap_remove_value) {
|
||||
hashmap_put(m, "key 2", val2);
|
||||
|
||||
r = hashmap_remove_value(m, "key 1", val1);
|
||||
assert_se(streq(r, "val 1"));
|
||||
ASSERT_STREQ(r, "val 1");
|
||||
|
||||
r = hashmap_get(m, "key 2");
|
||||
assert_se(streq(r, "val 2"));
|
||||
ASSERT_STREQ(r, "val 2");
|
||||
assert_se(!hashmap_get(m, "key 1"));
|
||||
|
||||
r = hashmap_remove_value(m, "key 2", val1);
|
||||
ASSERT_NULL(r);
|
||||
|
||||
r = hashmap_get(m, "key 2");
|
||||
assert_se(streq(r, "val 2"));
|
||||
ASSERT_STREQ(r, "val 2");
|
||||
assert_se(!hashmap_get(m, "key 1"));
|
||||
}
|
||||
|
||||
@ -343,7 +343,7 @@ TEST(hashmap_remove_and_put) {
|
||||
assert_se(valid == 0);
|
||||
|
||||
r = hashmap_get(m, "key 2");
|
||||
assert_se(streq(r, "val 2"));
|
||||
ASSERT_STREQ(r, "val 2");
|
||||
assert_se(!hashmap_get(m, "key 1"));
|
||||
|
||||
valid = hashmap_put(m, "key 3", (void*) (const char *) "val 3");
|
||||
@ -613,7 +613,7 @@ TEST(hashmap_get) {
|
||||
hashmap_put(m, "Key 1", val);
|
||||
|
||||
r = hashmap_get(m, "Key 1");
|
||||
assert_se(streq(r, val));
|
||||
ASSERT_STREQ(r, val);
|
||||
|
||||
r = hashmap_get(m, "no such key");
|
||||
ASSERT_NULL(r);
|
||||
@ -643,9 +643,9 @@ TEST(hashmap_get2) {
|
||||
key_copy = NULL;
|
||||
|
||||
r = hashmap_get2(m, key_orig, &key_copy);
|
||||
assert_se(streq(r, val));
|
||||
ASSERT_STREQ(r, val);
|
||||
assert_se(key_orig != key_copy);
|
||||
assert_se(streq(key_orig, key_copy));
|
||||
ASSERT_STREQ(key_orig, key_copy);
|
||||
|
||||
r = hashmap_get2(m, "no such key", NULL);
|
||||
ASSERT_NULL(r);
|
||||
@ -787,12 +787,12 @@ TEST(hashmap_first) {
|
||||
|
||||
assert_se(!hashmap_first(m));
|
||||
assert_se(hashmap_put(m, "key 1", (void*) "val 1") == 1);
|
||||
assert_se(streq(hashmap_first(m), "val 1"));
|
||||
ASSERT_STREQ(hashmap_first(m), "val 1");
|
||||
assert_se(hashmap_put(m, "key 2", (void*) "val 2") == 1);
|
||||
#ifdef ORDERED
|
||||
assert_se(streq(hashmap_first(m), "val 1"));
|
||||
ASSERT_STREQ(hashmap_first(m), "val 1");
|
||||
assert_se(hashmap_remove(m, "key 1"));
|
||||
assert_se(streq(hashmap_first(m), "val 2"));
|
||||
ASSERT_STREQ(hashmap_first(m), "val 2");
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -804,12 +804,12 @@ TEST(hashmap_first_key) {
|
||||
|
||||
assert_se(!hashmap_first_key(m));
|
||||
assert_se(hashmap_put(m, "key 1", NULL) == 1);
|
||||
assert_se(streq(hashmap_first_key(m), "key 1"));
|
||||
ASSERT_STREQ(hashmap_first_key(m), "key 1");
|
||||
assert_se(hashmap_put(m, "key 2", NULL) == 1);
|
||||
#ifdef ORDERED
|
||||
assert_se(streq(hashmap_first_key(m), "key 1"));
|
||||
ASSERT_STREQ(hashmap_first_key(m), "key 1");
|
||||
ASSERT_NULL(hashmap_remove(m, "key 1"));
|
||||
assert_se(streq(hashmap_first_key(m), "key 2"));
|
||||
ASSERT_STREQ(hashmap_first_key(m), "key 2");
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -821,7 +821,7 @@ TEST(hashmap_steal_first_key) {
|
||||
|
||||
assert_se(!hashmap_steal_first_key(m));
|
||||
assert_se(hashmap_put(m, "key 1", NULL) == 1);
|
||||
assert_se(streq(hashmap_steal_first_key(m), "key 1"));
|
||||
ASSERT_STREQ(hashmap_steal_first_key(m), "key 1");
|
||||
|
||||
assert_se(hashmap_isempty(m));
|
||||
}
|
||||
@ -997,7 +997,7 @@ TEST(hashmap_dump_sorted) {
|
||||
assert_se(hashmap_dump_keys_sorted(m, &vals, &n) >= 0);
|
||||
assert_se(n == ELEMENTSOF(expected_keys));
|
||||
for (size_t i = 0; i < n; i++)
|
||||
assert_se(streq(vals[i], expected_keys[i]));
|
||||
ASSERT_STREQ(vals[i], expected_keys[i]);
|
||||
|
||||
vals = mfree(vals);
|
||||
m = hashmap_free(m);
|
||||
|
||||
@ -116,7 +116,7 @@ TEST(hashmap_put_strdup) {
|
||||
assert_se(hashmap_contains(m, "foo"));
|
||||
|
||||
s = hashmap_get(m, "foo");
|
||||
assert_se(streq(s, "bar"));
|
||||
ASSERT_STREQ(s, "bar");
|
||||
|
||||
assert_se(hashmap_put_strdup(&m, "xxx", "bar") == 1);
|
||||
assert_se(hashmap_put_strdup(&m, "xxx", "bar") == 0);
|
||||
@ -125,7 +125,7 @@ TEST(hashmap_put_strdup) {
|
||||
assert_se(hashmap_contains(m, "xxx"));
|
||||
|
||||
s = hashmap_get(m, "xxx");
|
||||
assert_se(streq(s, "bar"));
|
||||
ASSERT_STREQ(s, "bar");
|
||||
}
|
||||
|
||||
TEST(hashmap_put_strdup_null) {
|
||||
@ -139,7 +139,7 @@ TEST(hashmap_put_strdup_null) {
|
||||
assert_se(hashmap_contains(m, "foo"));
|
||||
|
||||
s = hashmap_get(m, "foo");
|
||||
assert_se(streq(s, "bar"));
|
||||
ASSERT_STREQ(s, "bar");
|
||||
|
||||
assert_se(hashmap_put_strdup(&m, "xxx", NULL) == 1);
|
||||
assert_se(hashmap_put_strdup(&m, "xxx", "bar") == -EEXIST);
|
||||
|
||||
@ -80,7 +80,7 @@ static void test_hexmem_one(const char *in, const char *expected) {
|
||||
|
||||
assert_se(result = hexmem(in, strlen_ptr(in)));
|
||||
log_debug("hexmem(\"%s\") → \"%s\" (expected: \"%s\")", strnull(in), result, expected);
|
||||
assert_se(streq(result, expected));
|
||||
ASSERT_STREQ(result, expected);
|
||||
|
||||
assert_se(unhexmem(result, &mem, &len) >= 0);
|
||||
assert_se(memcmp_safe(mem, in, len) == 0);
|
||||
@ -106,7 +106,7 @@ static void test_unhexmem_one(const char *s, size_t l, int retval) {
|
||||
|
||||
assert_se(hex = hexmem(mem, len));
|
||||
answer = strndupa_safe(strempty(s), l);
|
||||
assert_se(streq(delete_chars(answer, WHITESPACE), hex));
|
||||
ASSERT_STREQ(delete_chars(answer, WHITESPACE), hex);
|
||||
}
|
||||
}
|
||||
|
||||
@ -134,72 +134,72 @@ TEST(base32hexmem) {
|
||||
|
||||
b32 = base32hexmem("", STRLEN(""), true);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, ""));
|
||||
ASSERT_STREQ(b32, "");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("f", STRLEN("f"), true);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CO======"));
|
||||
ASSERT_STREQ(b32, "CO======");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("fo", STRLEN("fo"), true);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNG===="));
|
||||
ASSERT_STREQ(b32, "CPNG====");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("foo", STRLEN("foo"), true);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNMU==="));
|
||||
ASSERT_STREQ(b32, "CPNMU===");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("foob", STRLEN("foob"), true);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNMUOG="));
|
||||
ASSERT_STREQ(b32, "CPNMUOG=");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("fooba", STRLEN("fooba"), true);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNMUOJ1"));
|
||||
ASSERT_STREQ(b32, "CPNMUOJ1");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("foobar", STRLEN("foobar"), true);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNMUOJ1E8======"));
|
||||
ASSERT_STREQ(b32, "CPNMUOJ1E8======");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("", STRLEN(""), false);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, ""));
|
||||
ASSERT_STREQ(b32, "");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("f", STRLEN("f"), false);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CO"));
|
||||
ASSERT_STREQ(b32, "CO");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("fo", STRLEN("fo"), false);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNG"));
|
||||
ASSERT_STREQ(b32, "CPNG");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("foo", STRLEN("foo"), false);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNMU"));
|
||||
ASSERT_STREQ(b32, "CPNMU");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("foob", STRLEN("foob"), false);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNMUOG"));
|
||||
ASSERT_STREQ(b32, "CPNMUOG");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("fooba", STRLEN("fooba"), false);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNMUOJ1"));
|
||||
ASSERT_STREQ(b32, "CPNMUOJ1");
|
||||
free(b32);
|
||||
|
||||
b32 = base32hexmem("foobar", STRLEN("foobar"), false);
|
||||
assert_se(b32);
|
||||
assert_se(streq(b32, "CPNMUOJ1E8"));
|
||||
ASSERT_STREQ(b32, "CPNMUOJ1E8");
|
||||
free(b32);
|
||||
}
|
||||
|
||||
@ -212,7 +212,7 @@ static void test_unbase32hexmem_one(const char *hex, bool padding, int retval, c
|
||||
char *str;
|
||||
|
||||
str = strndupa_safe(mem, len);
|
||||
assert_se(streq(str, ans));
|
||||
ASSERT_STREQ(str, ans);
|
||||
}
|
||||
}
|
||||
|
||||
@ -268,31 +268,31 @@ TEST(base64mem) {
|
||||
char *b64;
|
||||
|
||||
assert_se(base64mem("", STRLEN(""), &b64) == 0);
|
||||
assert_se(streq(b64, ""));
|
||||
ASSERT_STREQ(b64, "");
|
||||
free(b64);
|
||||
|
||||
assert_se(base64mem("f", STRLEN("f"), &b64) == 4);
|
||||
assert_se(streq(b64, "Zg=="));
|
||||
ASSERT_STREQ(b64, "Zg==");
|
||||
free(b64);
|
||||
|
||||
assert_se(base64mem("fo", STRLEN("fo"), &b64) == 4);
|
||||
assert_se(streq(b64, "Zm8="));
|
||||
ASSERT_STREQ(b64, "Zm8=");
|
||||
free(b64);
|
||||
|
||||
assert_se(base64mem("foo", STRLEN("foo"), &b64) == 4);
|
||||
assert_se(streq(b64, "Zm9v"));
|
||||
ASSERT_STREQ(b64, "Zm9v");
|
||||
free(b64);
|
||||
|
||||
assert_se(base64mem("foob", STRLEN("foob"), &b64) == 8);
|
||||
assert_se(streq(b64, "Zm9vYg=="));
|
||||
ASSERT_STREQ(b64, "Zm9vYg==");
|
||||
free(b64);
|
||||
|
||||
assert_se(base64mem("fooba", STRLEN("fooba"), &b64) == 8);
|
||||
assert_se(streq(b64, "Zm9vYmE="));
|
||||
ASSERT_STREQ(b64, "Zm9vYmE=");
|
||||
free(b64);
|
||||
|
||||
assert_se(base64mem("foobar", STRLEN("foobar"), &b64) == 8);
|
||||
assert_se(streq(b64, "Zm9vYmFy"));
|
||||
ASSERT_STREQ(b64, "Zm9vYmFy");
|
||||
free(b64);
|
||||
}
|
||||
|
||||
@ -341,7 +341,7 @@ static void test_base64_append_one(char **buf, size_t *len, const char *in, cons
|
||||
assert_se(new_len >= 0);
|
||||
log_debug("base64_append_one(\"%s\")\nresult:\n%s\nexpected:\n%s", in, strnull(*buf), strnull(expected));
|
||||
assert_se((size_t) new_len == strlen_ptr(*buf));
|
||||
assert_se(streq_ptr(*buf, expected));
|
||||
ASSERT_STREQ(*buf, expected);
|
||||
*len = new_len;
|
||||
}
|
||||
|
||||
|
||||
@ -26,42 +26,42 @@ TEST(hmac) {
|
||||
"baldohaldo",
|
||||
result);
|
||||
hex_result = hexmem(result, sizeof(result));
|
||||
assert_se(streq_ptr(hex_result, "c47ad5031ba21605e52c6ca68090d66a2dd5ccf84efa4bace15361a8cba63cda"));
|
||||
ASSERT_STREQ(hex_result, "c47ad5031ba21605e52c6ca68090d66a2dd5ccf84efa4bace15361a8cba63cda");
|
||||
hex_result = mfree(hex_result);
|
||||
|
||||
hmac_sha256_by_string("waldo",
|
||||
"baldo haldo",
|
||||
result);
|
||||
hex_result = hexmem(result, sizeof(result));
|
||||
assert_se(streq_ptr(hex_result, "4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69"));
|
||||
ASSERT_STREQ(hex_result, "4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69");
|
||||
hex_result = mfree(hex_result);
|
||||
|
||||
hmac_sha256_by_string("waldo",
|
||||
"baldo 4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69 haldo",
|
||||
result);
|
||||
hex_result = hexmem(result, sizeof(result));
|
||||
assert_se(streq_ptr(hex_result, "039f3df430b19753ffb493e5b90708f75c5210b63c6bcbef3374eb3f0a3f97f7"));
|
||||
ASSERT_STREQ(hex_result, "039f3df430b19753ffb493e5b90708f75c5210b63c6bcbef3374eb3f0a3f97f7");
|
||||
hex_result = mfree(hex_result);
|
||||
|
||||
hmac_sha256_by_string("4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69",
|
||||
"baldo haldo",
|
||||
result);
|
||||
hex_result = hexmem(result, sizeof(result));
|
||||
assert_se(streq_ptr(hex_result, "c4cfaf48077cbb0bbd177a09e59ec4c248f4ca771503410f5b54b98d88d2f47b"));
|
||||
ASSERT_STREQ(hex_result, "c4cfaf48077cbb0bbd177a09e59ec4c248f4ca771503410f5b54b98d88d2f47b");
|
||||
hex_result = mfree(hex_result);
|
||||
|
||||
hmac_sha256_by_string("4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69",
|
||||
"supercalifragilisticexpialidocious",
|
||||
result);
|
||||
hex_result = hexmem(result, sizeof(result));
|
||||
assert_se(streq_ptr(hex_result, "2c059e7a63c4c3b23f47966a65fd2f8a2f5d7161e2e90d78ff68866b5c375cb7"));
|
||||
ASSERT_STREQ(hex_result, "2c059e7a63c4c3b23f47966a65fd2f8a2f5d7161e2e90d78ff68866b5c375cb7");
|
||||
hex_result = mfree(hex_result);
|
||||
|
||||
hmac_sha256_by_string("4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69c47ad5031ba21605e52c6ca68090d66a2dd5ccf84efa4bace15361a8cba63cda",
|
||||
"supercalifragilisticexpialidocious",
|
||||
result);
|
||||
hex_result = hexmem(result, sizeof(result));
|
||||
assert_se(streq_ptr(hex_result, "1dd1d1d45b9d9f9673dc9983c968c46ff3168e03cfeb4156a219eba1af4cff5f"));
|
||||
ASSERT_STREQ(hex_result, "1dd1d1d45b9d9f9673dc9983c968c46ff3168e03cfeb4156a219eba1af4cff5f");
|
||||
hex_result = mfree(hex_result);
|
||||
}
|
||||
|
||||
|
||||
@ -22,28 +22,28 @@ TEST(read_etc_hostname) {
|
||||
/* simple hostname */
|
||||
assert_se(write_string_file(path, "foo", WRITE_STRING_FILE_CREATE) == 0);
|
||||
assert_se(read_etc_hostname(path, &hostname) == 0);
|
||||
assert_se(streq(hostname, "foo"));
|
||||
ASSERT_STREQ(hostname, "foo");
|
||||
hostname = mfree(hostname);
|
||||
|
||||
/* with comment */
|
||||
assert_se(write_string_file(path, "# comment\nfoo", WRITE_STRING_FILE_CREATE) == 0);
|
||||
assert_se(read_etc_hostname(path, &hostname) == 0);
|
||||
assert_se(hostname);
|
||||
assert_se(streq(hostname, "foo"));
|
||||
ASSERT_STREQ(hostname, "foo");
|
||||
hostname = mfree(hostname);
|
||||
|
||||
/* with comment and extra whitespace */
|
||||
assert_se(write_string_file(path, "# comment\n\n foo ", WRITE_STRING_FILE_CREATE) == 0);
|
||||
assert_se(read_etc_hostname(path, &hostname) == 0);
|
||||
assert_se(hostname);
|
||||
assert_se(streq(hostname, "foo"));
|
||||
ASSERT_STREQ(hostname, "foo");
|
||||
hostname = mfree(hostname);
|
||||
|
||||
/* cleans up name */
|
||||
assert_se(write_string_file(path, "!foo/bar.com", WRITE_STRING_FILE_CREATE) == 0);
|
||||
assert_se(read_etc_hostname(path, &hostname) == 0);
|
||||
assert_se(hostname);
|
||||
assert_se(streq(hostname, "foobar.com"));
|
||||
ASSERT_STREQ(hostname, "foobar.com");
|
||||
hostname = mfree(hostname);
|
||||
|
||||
/* no value set */
|
||||
|
||||
@ -50,27 +50,27 @@ TEST(hostname_cleanup) {
|
||||
char *s;
|
||||
|
||||
s = strdupa_safe("foobar");
|
||||
assert_se(streq(hostname_cleanup(s), "foobar"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foobar");
|
||||
s = strdupa_safe("foobar.com");
|
||||
assert_se(streq(hostname_cleanup(s), "foobar.com"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foobar.com");
|
||||
s = strdupa_safe("foobar.com.");
|
||||
assert_se(streq(hostname_cleanup(s), "foobar.com"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foobar.com");
|
||||
s = strdupa_safe("foo-bar.-com-.");
|
||||
assert_se(streq(hostname_cleanup(s), "foo-bar.com"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foo-bar.com");
|
||||
s = strdupa_safe("foo-bar-.-com-.");
|
||||
assert_se(streq(hostname_cleanup(s), "foo-bar--com"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foo-bar--com");
|
||||
s = strdupa_safe("--foo-bar.-com");
|
||||
assert_se(streq(hostname_cleanup(s), "foo-bar.com"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foo-bar.com");
|
||||
s = strdupa_safe("fooBAR");
|
||||
assert_se(streq(hostname_cleanup(s), "fooBAR"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "fooBAR");
|
||||
s = strdupa_safe("fooBAR.com");
|
||||
assert_se(streq(hostname_cleanup(s), "fooBAR.com"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "fooBAR.com");
|
||||
s = strdupa_safe("fooBAR.");
|
||||
assert_se(streq(hostname_cleanup(s), "fooBAR"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "fooBAR");
|
||||
s = strdupa_safe("fooBAR.com.");
|
||||
assert_se(streq(hostname_cleanup(s), "fooBAR.com"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "fooBAR.com");
|
||||
s = strdupa_safe("fööbar");
|
||||
assert_se(streq(hostname_cleanup(s), "fbar"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "fbar");
|
||||
s = strdupa_safe("");
|
||||
assert_se(isempty(hostname_cleanup(s)));
|
||||
s = strdupa_safe(".");
|
||||
@ -78,17 +78,17 @@ TEST(hostname_cleanup) {
|
||||
s = strdupa_safe("..");
|
||||
assert_se(isempty(hostname_cleanup(s)));
|
||||
s = strdupa_safe("foobar.");
|
||||
assert_se(streq(hostname_cleanup(s), "foobar"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foobar");
|
||||
s = strdupa_safe(".foobar");
|
||||
assert_se(streq(hostname_cleanup(s), "foobar"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foobar");
|
||||
s = strdupa_safe("foo..bar");
|
||||
assert_se(streq(hostname_cleanup(s), "foo.bar"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foo.bar");
|
||||
s = strdupa_safe("foo.bar..");
|
||||
assert_se(streq(hostname_cleanup(s), "foo.bar"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "foo.bar");
|
||||
s = strdupa_safe("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
|
||||
assert_se(streq(hostname_cleanup(s), "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
|
||||
s = strdupa_safe("xxxx........xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
|
||||
assert_se(streq(hostname_cleanup(s), "xxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
|
||||
ASSERT_STREQ(hostname_cleanup(s), "xxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
|
||||
}
|
||||
|
||||
TEST(hostname_malloc) {
|
||||
|
||||
@ -50,19 +50,19 @@ TEST(id128) {
|
||||
}
|
||||
|
||||
printf("waldi: %s\n", sd_id128_to_string(ID128_WALDI, t));
|
||||
assert_se(streq(t, STR_WALDI));
|
||||
ASSERT_STREQ(t, STR_WALDI);
|
||||
|
||||
assert_se(asprintf(&b, SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 32);
|
||||
printf("waldi2: %s\n", b);
|
||||
assert_se(streq(t, b));
|
||||
ASSERT_STREQ(t, b);
|
||||
|
||||
printf("waldi3: %s\n", sd_id128_to_uuid_string(ID128_WALDI, q));
|
||||
assert_se(streq(q, UUID_WALDI));
|
||||
ASSERT_STREQ(q, UUID_WALDI);
|
||||
|
||||
b = mfree(b);
|
||||
assert_se(asprintf(&b, SD_ID128_UUID_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 36);
|
||||
printf("waldi4: %s\n", b);
|
||||
assert_se(streq(q, b));
|
||||
ASSERT_STREQ(q, b);
|
||||
|
||||
assert_se(sd_id128_from_string(STR_WALDI, &id) >= 0);
|
||||
assert_se(sd_id128_equal(id, ID128_WALDI));
|
||||
|
||||
@ -10,7 +10,7 @@ static void test_import_url_last_component_one(const char *input, const char *ou
|
||||
_cleanup_free_ char *s = NULL;
|
||||
|
||||
assert_se(import_url_last_component(input, &s) == ret);
|
||||
assert_se(streq_ptr(output, s));
|
||||
ASSERT_STREQ(output, s);
|
||||
}
|
||||
|
||||
TEST(import_url_last_component) {
|
||||
@ -37,7 +37,7 @@ static void test_import_url_change_suffix_one(const char *input, size_t n, const
|
||||
_cleanup_free_ char *s = NULL;
|
||||
|
||||
assert_se(import_url_change_suffix(input, n, suffix, &s) == ret);
|
||||
assert_se(streq_ptr(output, s));
|
||||
ASSERT_STREQ(output, s);
|
||||
}
|
||||
|
||||
TEST(import_url_change_suffix) {
|
||||
|
||||
@ -12,8 +12,8 @@ static void test_in_addr_prefix_to_string_one(int f, const char *addr, unsigned
|
||||
printf("%s: %s/%u == %s\n", __func__, addr, prefixlen, r);
|
||||
assert_se(startswith(r, addr));
|
||||
|
||||
assert_se(streq(r, IN_ADDR_PREFIX_TO_STRING(f, &ua, prefixlen)));
|
||||
assert_se(streq(IN_ADDR_PREFIX_TO_STRING(f, &ua, prefixlen), r));
|
||||
ASSERT_STREQ(r, IN_ADDR_PREFIX_TO_STRING(f, &ua, prefixlen));
|
||||
ASSERT_STREQ(IN_ADDR_PREFIX_TO_STRING(f, &ua, prefixlen), r);
|
||||
}
|
||||
|
||||
TEST(in_addr_to_string_prefix) {
|
||||
@ -35,8 +35,8 @@ static void test_config_parse_in_addr_prefixes_one(int family, const union in_ad
|
||||
|
||||
assert_se(config_parse_in_addr_prefixes("unit", "filename", 1, "Service", 1, "IPAddressAllow", 0, str, prefixes, NULL) >= 0);
|
||||
|
||||
assert_se(streq(str, IN_ADDR_PREFIX_TO_STRING(family, addr, prefixlen)));
|
||||
assert_se(streq(IN_ADDR_PREFIX_TO_STRING(family, addr, prefixlen), str));
|
||||
ASSERT_STREQ(str, IN_ADDR_PREFIX_TO_STRING(family, addr, prefixlen));
|
||||
ASSERT_STREQ(IN_ADDR_PREFIX_TO_STRING(family, addr, prefixlen), str);
|
||||
}
|
||||
|
||||
static void test_config_parse_in_addr_prefixes(Set **ret) {
|
||||
|
||||
@ -81,7 +81,7 @@ static void test_in_addr_prefix_to_string_valid(int family, const char *p) {
|
||||
log_info("%s: %s", __func__, p);
|
||||
|
||||
assert_se(in_addr_prefix_from_string(p, family, &u, &l) >= 0);
|
||||
assert_se(streq(p, IN_ADDR_PREFIX_TO_STRING(family, &u, l)));
|
||||
ASSERT_STREQ(p, IN_ADDR_PREFIX_TO_STRING(family, &u, l));
|
||||
}
|
||||
|
||||
static void test_in_addr_prefix_to_string_unoptimized(int family, const char *p) {
|
||||
@ -97,7 +97,7 @@ static void test_in_addr_prefix_to_string_unoptimized(int family, const char *p)
|
||||
const char *str2 = IN_ADDR_PREFIX_TO_STRING(family, &u2, len2);
|
||||
assert_se(str2);
|
||||
|
||||
assert_se(streq(str1, str2));
|
||||
ASSERT_STREQ(str1, str2);
|
||||
assert_se(len1 == len2);
|
||||
assert_se(in_addr_equal(family, &u1, &u2) > 0);
|
||||
}
|
||||
@ -340,9 +340,9 @@ static void test_in_addr_to_string_one(int f, const char *addr) {
|
||||
assert_se(in_addr_from_string(f, addr, &ua) >= 0);
|
||||
assert_se(in_addr_to_string(f, &ua, &r) >= 0);
|
||||
printf("%s: %s == %s\n", __func__, addr, r);
|
||||
assert_se(streq(addr, r));
|
||||
ASSERT_STREQ(addr, r);
|
||||
|
||||
assert_se(streq(r, IN_ADDR_TO_STRING(f, &ua)));
|
||||
ASSERT_STREQ(r, IN_ADDR_TO_STRING(f, &ua));
|
||||
}
|
||||
|
||||
TEST(in_addr_to_string) {
|
||||
@ -391,7 +391,7 @@ TEST(in_addr_prefixlen_to_netmask) {
|
||||
assert_se(in_addr_prefixlen_to_netmask(AF_INET, &addr, prefixlen) >= 0);
|
||||
assert_se(in_addr_to_string(AF_INET, &addr, &result) >= 0);
|
||||
printf("test_in_addr_prefixlen_to_netmask: %s == %s\n", ipv4_netmasks[prefixlen], result);
|
||||
assert_se(streq(ipv4_netmasks[prefixlen], result));
|
||||
ASSERT_STREQ(ipv4_netmasks[prefixlen], result);
|
||||
}
|
||||
|
||||
for (unsigned char prefixlen = 0; prefixlen <= 128; prefixlen++) {
|
||||
@ -401,7 +401,7 @@ TEST(in_addr_prefixlen_to_netmask) {
|
||||
assert_se(in_addr_to_string(AF_INET6, &addr, &result) >= 0);
|
||||
printf("test_in_addr_prefixlen_to_netmask: %s\n", result);
|
||||
if (ipv6_netmasks[prefixlen])
|
||||
assert_se(streq(ipv6_netmasks[prefixlen], result));
|
||||
ASSERT_STREQ(ipv6_netmasks[prefixlen], result);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -60,9 +60,9 @@ TEST(basic_mask_and_enable) {
|
||||
assert_se(unit_file_mask(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("a.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/dev/null"));
|
||||
ASSERT_STREQ(changes[0].source, "/dev/null");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/a.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
@ -81,16 +81,16 @@ TEST(basic_mask_and_enable) {
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/a.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("a.service"), &changes, &n_changes) == 1);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/a.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/a.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/a.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -109,7 +109,7 @@ TEST(basic_mask_and_enable) {
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/a.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -128,9 +128,9 @@ TEST(basic_mask_and_enable) {
|
||||
assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("d.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/a.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/a.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/a.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -145,10 +145,10 @@ TEST(basic_mask_and_enable) {
|
||||
assert_se(n_changes == 2);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/a.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[1].source, "/usr/lib/systemd/system/a.service"));
|
||||
assert_se(streq(changes[1].path, p));
|
||||
ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/a.service");
|
||||
ASSERT_STREQ(changes[1].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -186,13 +186,13 @@ TEST(basic_mask_and_enable) {
|
||||
assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("f.service"), &changes, &n_changes) == 1);
|
||||
assert_se(n_changes == 2);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/f.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/f.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/x.target.wants/f.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
assert_se(changes[1].type == INSTALL_CHANGE_DESTINATION_NOT_PRESENT);
|
||||
p = strjoina(root, "/usr/lib/systemd/system/f.service");
|
||||
assert_se(streq(changes[1].source, p));
|
||||
assert_se(streq(changes[1].path, "x.target"));
|
||||
ASSERT_STREQ(changes[1].source, p);
|
||||
ASSERT_STREQ(changes[1].path, "x.target");
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -255,9 +255,9 @@ TEST(linked_units) {
|
||||
assert_se(unit_file_link(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("/opt/linked.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/opt/linked.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/opt/linked.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/linked.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -268,7 +268,7 @@ TEST(linked_units) {
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/linked.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -285,9 +285,9 @@ TEST(linked_units) {
|
||||
|
||||
if (s && streq(changes[i].path, s))
|
||||
/* The alias symlink should point within the search path. */
|
||||
assert_se(streq(changes[i].source, SYSTEM_CONFIG_UNIT_DIR"/linked.service"));
|
||||
ASSERT_STREQ(changes[i].source, SYSTEM_CONFIG_UNIT_DIR"/linked.service");
|
||||
else
|
||||
assert_se(streq(changes[i].source, "/opt/linked.service"));
|
||||
ASSERT_STREQ(changes[i].source, "/opt/linked.service");
|
||||
|
||||
if (p && streq(changes[i].path, p))
|
||||
p = NULL;
|
||||
@ -335,7 +335,7 @@ TEST(linked_units) {
|
||||
q = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/linked2.service");
|
||||
for (i = 0 ; i < n_changes; i++) {
|
||||
assert_se(changes[i].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[i].source, "/opt/linked2.service"));
|
||||
ASSERT_STREQ(changes[i].source, "/opt/linked2.service");
|
||||
|
||||
if (p && streq(changes[i].path, p))
|
||||
p = NULL;
|
||||
@ -353,7 +353,7 @@ TEST(linked_units) {
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(startswith(changes[0].path, root));
|
||||
assert_se(endswith(changes[0].path, "linked3.service"));
|
||||
assert_se(streq(changes[0].source, "/opt/linked3.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/opt/linked3.service");
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
}
|
||||
@ -375,7 +375,7 @@ TEST(default) {
|
||||
assert_se(unit_file_set_default(RUNTIME_SCOPE_SYSTEM, 0, root, "idontexist.target", &changes, &n_changes) == -ENOENT);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == -ENOENT);
|
||||
assert_se(streq_ptr(changes[0].path, "idontexist.target"));
|
||||
ASSERT_STREQ(changes[0].path, "idontexist.target");
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -384,14 +384,14 @@ TEST(default) {
|
||||
assert_se(unit_file_set_default(RUNTIME_SCOPE_SYSTEM, 0, root, "test-default.target", &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/test-default-real.target"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/test-default-real.target");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR "/" SPECIAL_DEFAULT_TARGET);
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
assert_se(unit_file_get_default(RUNTIME_SCOPE_SYSTEM, root, &def) >= 0);
|
||||
assert_se(streq_ptr(def, "test-default-real.target"));
|
||||
ASSERT_STREQ(def, "test-default-real.target");
|
||||
}
|
||||
|
||||
TEST(add_dependency) {
|
||||
@ -414,9 +414,9 @@ TEST(add_dependency) {
|
||||
assert_se(unit_file_add_dependency(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("add-dependency-test-service.service"), "add-dependency-test-target.target", UNIT_WANTS, &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/real-add-dependency-test-service.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/real-add-dependency-test-service.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/real-add-dependency-test-target.target.wants/real-add-dependency-test-service.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
}
|
||||
@ -455,9 +455,9 @@ TEST(template_enable) {
|
||||
assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template@.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/template@.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/template@.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/template@def.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -471,7 +471,7 @@ TEST(template_enable) {
|
||||
assert_se(unit_file_disable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template@.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -486,9 +486,9 @@ TEST(template_enable) {
|
||||
|
||||
assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template@foo.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/template@.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/template@.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/template@foo.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -502,7 +502,7 @@ TEST(template_enable) {
|
||||
assert_se(unit_file_disable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template@foo.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -519,9 +519,9 @@ TEST(template_enable) {
|
||||
|
||||
assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template-symlink@quux.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/template@.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/template@.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/template@quux.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -565,9 +565,9 @@ TEST(indirect) {
|
||||
assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("indirectc.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/indirectb.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/indirectb.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/indirectb.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -579,7 +579,7 @@ TEST(indirect) {
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/indirectb.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
}
|
||||
@ -627,9 +627,9 @@ TEST(preset_and_list) {
|
||||
assert_se(unit_file_preset(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("preset-yes.service"), UNIT_FILE_PRESET_FULL, &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/preset-yes.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/preset-yes.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/preset-yes.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -641,7 +641,7 @@ TEST(preset_and_list) {
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/preset-yes.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -667,8 +667,8 @@ TEST(preset_and_list) {
|
||||
for (i = 0; i < n_changes; i++) {
|
||||
|
||||
if (changes[i].type == INSTALL_CHANGE_SYMLINK) {
|
||||
assert_se(streq(changes[i].source, "/usr/lib/systemd/system/preset-yes.service"));
|
||||
assert_se(streq(changes[i].path, p));
|
||||
ASSERT_STREQ(changes[i].source, "/usr/lib/systemd/system/preset-yes.service");
|
||||
ASSERT_STREQ(changes[i].path, p);
|
||||
} else
|
||||
assert_se(changes[i].type == INSTALL_CHANGE_UNLINK);
|
||||
}
|
||||
@ -735,7 +735,7 @@ TEST(revert) {
|
||||
assert_se(unit_file_revert(RUNTIME_SCOPE_SYSTEM, root, STRV_MAKE("xx.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -746,11 +746,11 @@ TEST(revert) {
|
||||
assert_se(unit_file_revert(RUNTIME_SCOPE_SYSTEM, root, STRV_MAKE("xx.service"), &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 2);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/xx.service.d");
|
||||
assert_se(changes[1].type == INSTALL_CHANGE_UNLINK);
|
||||
assert_se(streq(changes[1].path, p));
|
||||
ASSERT_STREQ(changes[1].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
}
|
||||
@ -786,9 +786,9 @@ TEST(preset_order) {
|
||||
assert_se(unit_file_preset(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("prefix-1.service"), UNIT_FILE_PRESET_FULL, &changes, &n_changes) >= 0);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/prefix-1.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/prefix-1.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/prefix-1.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -895,12 +895,12 @@ TEST(with_dropin) {
|
||||
assert_se(n_changes == 2);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-1.service"));
|
||||
assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-1.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-1.service");
|
||||
ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-1.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-1.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-1.service");
|
||||
assert_se(streq(changes[1].path, p));
|
||||
ASSERT_STREQ(changes[1].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -909,12 +909,12 @@ TEST(with_dropin) {
|
||||
assert_se(n_changes == 2);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, SYSTEM_CONFIG_UNIT_DIR"/with-dropin-2.service"));
|
||||
assert_se(streq(changes[1].source, SYSTEM_CONFIG_UNIT_DIR"/with-dropin-2.service"));
|
||||
ASSERT_STREQ(changes[0].source, SYSTEM_CONFIG_UNIT_DIR"/with-dropin-2.service");
|
||||
ASSERT_STREQ(changes[1].source, SYSTEM_CONFIG_UNIT_DIR"/with-dropin-2.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-2.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-2.service");
|
||||
assert_se(streq(changes[1].path, p));
|
||||
ASSERT_STREQ(changes[1].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -923,12 +923,12 @@ TEST(with_dropin) {
|
||||
assert_se(n_changes == 2);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-3.service"));
|
||||
assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-3.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-3.service");
|
||||
ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-3.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-3.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-3.service");
|
||||
assert_se(streq(changes[1].path, p));
|
||||
ASSERT_STREQ(changes[1].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -937,12 +937,12 @@ TEST(with_dropin) {
|
||||
assert_se(n_changes == 2);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-4a.service"));
|
||||
assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-4b.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-4a.service");
|
||||
ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-4b.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-4a.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-4b.service");
|
||||
assert_se(streq(changes[1].path, p));
|
||||
ASSERT_STREQ(changes[1].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -1004,12 +1004,12 @@ TEST(with_dropin_template) {
|
||||
assert_se(n_changes == 2);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-1@.service"));
|
||||
assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-1@.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-1@.service");
|
||||
ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-1@.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-1@instance-1.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-1@instance-1.service");
|
||||
assert_se(streq(changes[1].path, p));
|
||||
ASSERT_STREQ(changes[1].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -1017,30 +1017,30 @@ TEST(with_dropin_template) {
|
||||
assert_se(n_changes == 2);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-2@.service"));
|
||||
assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-2@.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-2@.service");
|
||||
ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-2@.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-2@instance-1.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-2@instance-1.service");
|
||||
assert_se(streq(changes[1].path, p));
|
||||
ASSERT_STREQ(changes[1].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("with-dropin-2@instance-2.service"), &changes, &n_changes) == 1);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-2@.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-2@.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-2@instance-2.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("with-dropin-3@.service"), &changes, &n_changes) == 1);
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-3@.service"));
|
||||
ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-3@.service");
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-3@instance-2.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -1080,7 +1080,7 @@ TEST(preset_multiple_instances) {
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/foo@bar0.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -1088,7 +1088,7 @@ TEST(preset_multiple_instances) {
|
||||
assert_se(n_changes == 1);
|
||||
assert_se(changes[0].type == INSTALL_CHANGE_UNLINK);
|
||||
p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/foo@bar0.service");
|
||||
assert_se(streq(changes[0].path, p));
|
||||
ASSERT_STREQ(changes[0].path, p);
|
||||
install_changes_free(changes, n_changes);
|
||||
changes = NULL; n_changes = 0;
|
||||
|
||||
@ -1131,7 +1131,7 @@ static void verify_one(
|
||||
* RequiredBy= settings, and less so for Alias=. The only case where it should happen is when we have
|
||||
* an Alias=alias@.service an instantiated template template@instance. In that case the instance name
|
||||
* should be propagated into the alias as alias@instance. */
|
||||
assert_se(streq_ptr(alias2, updated_name));
|
||||
ASSERT_STREQ(alias2, updated_name);
|
||||
}
|
||||
|
||||
TEST(verify_alias) {
|
||||
|
||||
@ -27,8 +27,8 @@ static void test_int_fail(int i, int error) {
|
||||
}
|
||||
|
||||
static void test_str(const char *s) {
|
||||
assert_se(streq(ip_protocol_to_name(ip_protocol_from_name(s)), s));
|
||||
assert_se(streq(ip_protocol_to_name(parse_ip_protocol(s)), s));
|
||||
ASSERT_STREQ(ip_protocol_to_name(ip_protocol_from_name(s)), s);
|
||||
ASSERT_STREQ(ip_protocol_to_name(parse_ip_protocol(s)), s);
|
||||
}
|
||||
|
||||
static void test_str_fail(const char *s, int error) {
|
||||
|
||||
@ -44,7 +44,7 @@ static void test_tokenizer_one(const char *data, ...) {
|
||||
const char *nn;
|
||||
|
||||
nn = va_arg(ap, const char *);
|
||||
assert_se(streq_ptr(nn, str));
|
||||
ASSERT_STREQ(nn, str);
|
||||
|
||||
} else if (t == JSON_TOKEN_REAL) {
|
||||
double d;
|
||||
@ -109,7 +109,7 @@ static void test_variant_one(const char *data, Test test) {
|
||||
s = mfree(s);
|
||||
r = json_variant_format(w, JSON_FORMAT_CENSOR_SENSITIVE, &s);
|
||||
assert_se(s);
|
||||
assert_se(streq_ptr(s, "\"<sensitive data>\""));
|
||||
ASSERT_STREQ(s, "\"<sensitive data>\"");
|
||||
|
||||
s = mfree(s);
|
||||
r = json_variant_format(w, JSON_FORMAT_PRETTY, &s);
|
||||
@ -167,7 +167,7 @@ static void test_1(JsonVariant *v) {
|
||||
assert_se(p && json_variant_type(p) == JSON_VARIANT_STRING);
|
||||
|
||||
/* k equals v */
|
||||
assert_se(streq(json_variant_string(p), "v"));
|
||||
ASSERT_STREQ(json_variant_string(p), "v");
|
||||
|
||||
/* has foo */
|
||||
p = json_variant_by_key(v, "foo");
|
||||
@ -334,7 +334,7 @@ TEST(build) {
|
||||
assert_se(json_variant_format(b, 0, &t) >= 0);
|
||||
log_info("GOT: %s", t);
|
||||
|
||||
assert_se(streq(s, t));
|
||||
ASSERT_STREQ(s, t);
|
||||
|
||||
a = json_variant_unref(a);
|
||||
b = json_variant_unref(b);
|
||||
@ -462,7 +462,7 @@ TEST(normalize) {
|
||||
assert_se(!json_variant_is_normalized(v));
|
||||
|
||||
assert_se(json_variant_format(v, 0, &t) >= 0);
|
||||
assert_se(streq(t, "{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}"));
|
||||
ASSERT_STREQ(t, "{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}");
|
||||
t = mfree(t);
|
||||
|
||||
assert_se(json_build(&w, JSON_BUILD_OBJECT(
|
||||
@ -473,7 +473,7 @@ TEST(normalize) {
|
||||
assert_se(!json_variant_is_normalized(w));
|
||||
|
||||
assert_se(json_variant_format(w, 0, &t) >= 0);
|
||||
assert_se(streq(t, "{\"bar\":\"zzz\",\"foo\":{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}}"));
|
||||
ASSERT_STREQ(t, "{\"bar\":\"zzz\",\"foo\":{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}}");
|
||||
t = mfree(t);
|
||||
|
||||
assert_se(json_variant_sort(&v) >= 0);
|
||||
@ -481,7 +481,7 @@ TEST(normalize) {
|
||||
assert_se(json_variant_is_normalized(v));
|
||||
|
||||
assert_se(json_variant_format(v, 0, &t) >= 0);
|
||||
assert_se(streq(t, "{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}"));
|
||||
ASSERT_STREQ(t, "{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}");
|
||||
t = mfree(t);
|
||||
|
||||
assert_se(json_variant_normalize(&w) >= 0);
|
||||
@ -489,7 +489,7 @@ TEST(normalize) {
|
||||
assert_se(json_variant_is_normalized(w));
|
||||
|
||||
assert_se(json_variant_format(w, 0, &t) >= 0);
|
||||
assert_se(streq(t, "{\"bar\":\"zzz\",\"foo\":{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}}"));
|
||||
ASSERT_STREQ(t, "{\"bar\":\"zzz\",\"foo\":{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}}");
|
||||
t = mfree(t);
|
||||
}
|
||||
|
||||
@ -531,7 +531,7 @@ TEST(bisect) {
|
||||
assert_se(json_variant_is_string(k));
|
||||
|
||||
z = (char[5]){ '<', c, c, '>', 0};
|
||||
assert_se(streq(json_variant_string(k), z));
|
||||
ASSERT_STREQ(json_variant_string(k), z);
|
||||
}
|
||||
}
|
||||
|
||||
@ -698,8 +698,8 @@ static void json_array_append_with_source_one(bool source) {
|
||||
assert_se(json_variant_get_source(a, &s1, &line1, &col1) >= 0);
|
||||
assert_se(json_variant_get_source(b, &s2, &line2, &col2) >= 0);
|
||||
|
||||
assert_se(streq_ptr(s1, source ? "string 1" : NULL));
|
||||
assert_se(streq_ptr(s2, source ? "string 2" : NULL));
|
||||
ASSERT_STREQ(s1, source ? "string 1" : NULL);
|
||||
ASSERT_STREQ(s2, source ? "string 2" : NULL);
|
||||
assert_se(line1 == 1);
|
||||
assert_se(col1 == 2);
|
||||
assert_se(line2 == 3);
|
||||
@ -723,8 +723,8 @@ static void json_array_append_with_source_one(bool source) {
|
||||
assert_se(elem = json_variant_by_index(a, 1));
|
||||
assert_se(json_variant_get_source(elem, &s2, &line2, &col2) >= 0);
|
||||
|
||||
assert_se(streq_ptr(s1, source ? "string 2" : NULL));
|
||||
assert_se(streq_ptr(s2, source ? "string 2" : NULL));
|
||||
ASSERT_STREQ(s1, source ? "string 2" : NULL);
|
||||
ASSERT_STREQ(s2, source ? "string 2" : NULL);
|
||||
assert_se(line1 == 3);
|
||||
assert_se(col1 == 5);
|
||||
assert_se(line2 == 3);
|
||||
@ -887,7 +887,7 @@ TEST(json_sensitive) {
|
||||
json_variant_sensitive(a);
|
||||
|
||||
assert_se(json_variant_format(a, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
|
||||
assert_se(streq_ptr(s, "\"<sensitive data>\""));
|
||||
ASSERT_STREQ(s, "\"<sensitive data>\"");
|
||||
s = mfree(s);
|
||||
|
||||
r = json_variant_format(b, JSON_FORMAT_CENSOR_SENSITIVE, &s);
|
||||
@ -932,7 +932,7 @@ TEST(json_sensitive) {
|
||||
json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
|
||||
|
||||
assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
|
||||
assert_se(streq_ptr(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"a\":\"<sensitive data>\",\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{}}"));
|
||||
ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"a\":\"<sensitive data>\",\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{}}");
|
||||
s = mfree(s);
|
||||
v = json_variant_unref(v);
|
||||
|
||||
@ -945,7 +945,7 @@ TEST(json_sensitive) {
|
||||
json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
|
||||
|
||||
assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
|
||||
assert_se(streq_ptr(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"a\":\"<sensitive data>\",\"d\":\"-9223372036854775808\",\"e\":{}}"));
|
||||
ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"a\":\"<sensitive data>\",\"d\":\"-9223372036854775808\",\"e\":{}}");
|
||||
s = mfree(s);
|
||||
v = json_variant_unref(v);
|
||||
|
||||
@ -958,7 +958,7 @@ TEST(json_sensitive) {
|
||||
json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
|
||||
|
||||
assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
|
||||
assert_se(streq_ptr(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"a\":\"<sensitive data>\",\"e\":{}}"));
|
||||
ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"a\":\"<sensitive data>\",\"e\":{}}");
|
||||
s = mfree(s);
|
||||
v = json_variant_unref(v);
|
||||
|
||||
@ -971,7 +971,7 @@ TEST(json_sensitive) {
|
||||
json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
|
||||
|
||||
assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
|
||||
assert_se(streq_ptr(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{},\"a\":\"<sensitive data>\"}"));
|
||||
ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{},\"a\":\"<sensitive data>\"}");
|
||||
}
|
||||
|
||||
TEST(json_iovec) {
|
||||
|
||||
@ -79,12 +79,12 @@ static void check_execcommand(ExecCommand *c,
|
||||
n = strv_length(c->argv);
|
||||
log_info("actual: \"%s\" [\"%s\" \"%s\" \"%s\"]",
|
||||
c->path, c->argv[0], n > 0 ? c->argv[1] : "(null)", n > 1 ? c->argv[2] : "(null)");
|
||||
assert_se(streq(c->path, path));
|
||||
assert_se(streq(c->argv[0], argv0 ?: path));
|
||||
ASSERT_STREQ(c->path, path);
|
||||
ASSERT_STREQ(c->argv[0], argv0 ?: path);
|
||||
if (n > 0)
|
||||
assert_se(streq_ptr(c->argv[1], argv1));
|
||||
ASSERT_STREQ(c->argv[1], argv1);
|
||||
if (n > 1)
|
||||
assert_se(streq_ptr(c->argv[2], argv2));
|
||||
ASSERT_STREQ(c->argv[2], argv2);
|
||||
assert_se(!!(c->flags & EXEC_COMMAND_IGNORE_FAILURE) == ignore);
|
||||
}
|
||||
|
||||
@ -544,7 +544,7 @@ TEST(install_printf, .sd_booted = true) {
|
||||
memzero(i.path, strlen(i.path)); \
|
||||
if (result) { \
|
||||
printf("%s\n", t); \
|
||||
assert_se(streq(t, result)); \
|
||||
ASSERT_STREQ(t, result); \
|
||||
} else \
|
||||
assert_se(!t); \
|
||||
strcpy(i.name, d1); \
|
||||
@ -794,8 +794,8 @@ TEST(config_parse_pass_environ) {
|
||||
&passenv, NULL);
|
||||
assert_se(r >= 0);
|
||||
assert_se(strv_length(passenv) == 2);
|
||||
assert_se(streq(passenv[0], "A"));
|
||||
assert_se(streq(passenv[1], "B"));
|
||||
ASSERT_STREQ(passenv[0], "A");
|
||||
ASSERT_STREQ(passenv[1], "B");
|
||||
|
||||
r = config_parse_pass_environ(NULL, "fake", 1, "section", 1,
|
||||
"PassEnvironment", 0, "",
|
||||
@ -808,7 +808,7 @@ TEST(config_parse_pass_environ) {
|
||||
&passenv, NULL);
|
||||
assert_se(r >= 0);
|
||||
assert_se(strv_length(passenv) == 1);
|
||||
assert_se(streq(passenv[0], "normal_name"));
|
||||
ASSERT_STREQ(passenv[0], "normal_name");
|
||||
}
|
||||
|
||||
TEST(config_parse_unit_env_file) {
|
||||
@ -858,8 +858,8 @@ TEST(config_parse_unit_env_file) {
|
||||
&files, u);
|
||||
assert_se(r == 0);
|
||||
assert_se(strv_length(files) == 2);
|
||||
assert_se(streq(files[0], "/absolute1"));
|
||||
assert_se(streq(files[1], "/absolute2"));
|
||||
ASSERT_STREQ(files[0], "/absolute1");
|
||||
ASSERT_STREQ(files[1], "/absolute2");
|
||||
|
||||
r = config_parse_unit_env_file(u->id, "fake", 1, "section", 1,
|
||||
"EnvironmentFile", 0, "",
|
||||
@ -872,7 +872,7 @@ TEST(config_parse_unit_env_file) {
|
||||
&files, u);
|
||||
assert_se(r == 0);
|
||||
assert_se(strv_length(files) == 1);
|
||||
assert_se(streq(files[0], "/path/foobar.service.conf"));
|
||||
ASSERT_STREQ(files[0], "/path/foobar.service.conf");
|
||||
}
|
||||
|
||||
TEST(unit_dump_config_items) {
|
||||
@ -1073,8 +1073,8 @@ TEST(config_parse_open_file) {
|
||||
&of, u);
|
||||
assert_se(r >= 0);
|
||||
assert_se(of);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "host-mount-namespace"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "host-mount-namespace");
|
||||
assert_se(of->flags == OPENFILE_READ_ONLY);
|
||||
|
||||
of = open_file_free(of);
|
||||
@ -1083,8 +1083,8 @@ TEST(config_parse_open_file) {
|
||||
&of, u);
|
||||
assert_se(r >= 0);
|
||||
assert_se(of);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "mnt"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "mnt");
|
||||
assert_se(of->flags == OPENFILE_READ_ONLY);
|
||||
|
||||
r = config_parse_open_file(NULL, "fake", 1, "section", 1,
|
||||
|
||||
@ -49,10 +49,10 @@ static void verify_dissected_image(DissectedImage *dissected) {
|
||||
static void verify_dissected_image_harder(DissectedImage *dissected) {
|
||||
verify_dissected_image(dissected);
|
||||
|
||||
assert_se(streq(dissected->partitions[PARTITION_ESP].fstype, "vfat"));
|
||||
assert_se(streq(dissected->partitions[PARTITION_XBOOTLDR].fstype, "vfat"));
|
||||
assert_se(streq(dissected->partitions[PARTITION_ROOT].fstype, "ext4"));
|
||||
assert_se(streq(dissected->partitions[PARTITION_HOME].fstype, "ext4"));
|
||||
ASSERT_STREQ(dissected->partitions[PARTITION_ESP].fstype, "vfat");
|
||||
ASSERT_STREQ(dissected->partitions[PARTITION_XBOOTLDR].fstype, "vfat");
|
||||
ASSERT_STREQ(dissected->partitions[PARTITION_ROOT].fstype, "ext4");
|
||||
ASSERT_STREQ(dissected->partitions[PARTITION_HOME].fstype, "ext4");
|
||||
}
|
||||
|
||||
static void* thread_func(void *ptr) {
|
||||
|
||||
@ -40,7 +40,7 @@ static void *fake_pressure_thread(void *p) {
|
||||
assert_se(cfd >= 0);
|
||||
char buf[STRLEN("hello")+1] = {};
|
||||
assert_se(read(cfd, buf, sizeof(buf)-1) == sizeof(buf)-1);
|
||||
assert_se(streq(buf, "hello"));
|
||||
ASSERT_STREQ(buf, "hello");
|
||||
assert_se(write(cfd, &(const char) { 'z' }, 1) == 1);
|
||||
|
||||
return 0;
|
||||
|
||||
@ -17,7 +17,7 @@ TEST(memstream_empty) {
|
||||
|
||||
assert_se(memstream_init(&m));
|
||||
assert_se(memstream_finalize(&m, &buf, &sz) >= 0);
|
||||
assert_se(streq(buf, ""));
|
||||
ASSERT_STREQ(buf, "");
|
||||
assert_se(sz == 0);
|
||||
}
|
||||
|
||||
@ -32,7 +32,7 @@ TEST(memstream) {
|
||||
fputs("おはよう！", f);
|
||||
fputs(u8"😀😀😀", f);
|
||||
assert_se(memstream_finalize(&m, &buf, &sz) >= 0);
|
||||
assert_se(streq(buf, u8"hogeおはよう！😀😀😀"));
|
||||
ASSERT_STREQ(buf, u8"hogeおはよう！😀😀😀");
|
||||
assert_se(sz == strlen(u8"hogeおはよう！😀😀😀"));
|
||||
|
||||
buf = mfree(buf);
|
||||
@ -40,7 +40,7 @@ TEST(memstream) {
|
||||
assert_se(f = memstream_init(&m));
|
||||
fputs("second", f);
|
||||
assert_se(memstream_finalize(&m, &buf, &sz) >= 0);
|
||||
assert_se(streq(buf, "second"));
|
||||
ASSERT_STREQ(buf, "second");
|
||||
assert_se(sz == strlen("second"));
|
||||
}
|
||||
|
||||
|
||||
@ -43,44 +43,44 @@ TEST(mount_option_mangle) {
|
||||
|
||||
assert_se(mount_option_mangle("ro,nosuid,nodev,noexec,mode=0755", 0, &f, &opts) == 0);
|
||||
assert_se(f == (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC));
|
||||
assert_se(streq(opts, "mode=0755"));
|
||||
ASSERT_STREQ(opts, "mode=0755");
|
||||
opts = mfree(opts);
|
||||
|
||||
assert_se(mount_option_mangle("rw,nosuid,foo,hogehoge,nodev,mode=0755", 0, &f, &opts) == 0);
|
||||
assert_se(f == (MS_NOSUID|MS_NODEV));
|
||||
assert_se(streq(opts, "foo,hogehoge,mode=0755"));
|
||||
ASSERT_STREQ(opts, "foo,hogehoge,mode=0755");
|
||||
opts = mfree(opts);
|
||||
|
||||
assert_se(mount_option_mangle("rw,nosuid,nodev,noexec,relatime,net_cls,net_prio", MS_RDONLY, &f, &opts) == 0);
|
||||
assert_se(f == (MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_RELATIME));
|
||||
assert_se(streq(opts, "net_cls,net_prio"));
|
||||
ASSERT_STREQ(opts, "net_cls,net_prio");
|
||||
opts = mfree(opts);
|
||||
|
||||
assert_se(mount_option_mangle("rw,nosuid,nodev,relatime,size=1630748k,mode=0700,uid=1000,gid=1000", MS_RDONLY, &f, &opts) == 0);
|
||||
assert_se(f == (MS_NOSUID|MS_NODEV|MS_RELATIME));
|
||||
assert_se(streq(opts, "size=1630748k,mode=0700,uid=1000,gid=1000"));
|
||||
ASSERT_STREQ(opts, "size=1630748k,mode=0700,uid=1000,gid=1000");
|
||||
opts = mfree(opts);
|
||||
|
||||
assert_se(mount_option_mangle("size=1630748k,rw,gid=1000,,,nodev,relatime,,mode=0700,nosuid,uid=1000", MS_RDONLY, &f, &opts) == 0);
|
||||
assert_se(f == (MS_NOSUID|MS_NODEV|MS_RELATIME));
|
||||
assert_se(streq(opts, "size=1630748k,gid=1000,mode=0700,uid=1000"));
|
||||
ASSERT_STREQ(opts, "size=1630748k,gid=1000,mode=0700,uid=1000");
|
||||
opts = mfree(opts);
|
||||
|
||||
assert_se(mount_option_mangle("rw,exec,size=8143984k,nr_inodes=2035996,mode=0755", MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV, &f, &opts) == 0);
|
||||
assert_se(f == (MS_NOSUID|MS_NODEV));
|
||||
assert_se(streq(opts, "size=8143984k,nr_inodes=2035996,mode=0755"));
|
||||
ASSERT_STREQ(opts, "size=8143984k,nr_inodes=2035996,mode=0755");
|
||||
opts = mfree(opts);
|
||||
|
||||
assert_se(mount_option_mangle("rw,relatime,fmask=0022,,,dmask=0022", MS_RDONLY, &f, &opts) == 0);
|
||||
assert_se(f == MS_RELATIME);
|
||||
assert_se(streq(opts, "fmask=0022,dmask=0022"));
|
||||
ASSERT_STREQ(opts, "fmask=0022,dmask=0022");
|
||||
opts = mfree(opts);
|
||||
|
||||
assert_se(mount_option_mangle("rw,relatime,fmask=0022,dmask=0022,\"hogehoge", MS_RDONLY, &f, &opts) < 0);
|
||||
|
||||
assert_se(mount_option_mangle("mode=01777,size=10%,nr_inodes=400k,uid=496107520,gid=496107520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\"", 0, &f, &opts) == 0);
|
||||
assert_se(f == 0);
|
||||
assert_se(streq(opts, "mode=01777,size=10%,nr_inodes=400k,uid=496107520,gid=496107520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\""));
|
||||
ASSERT_STREQ(opts, "mode=01777,size=10%,nr_inodes=400k,uid=496107520,gid=496107520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\"");
|
||||
opts = mfree(opts);
|
||||
}
|
||||
|
||||
@ -91,7 +91,7 @@ static void test_mount_flags_to_string_one(unsigned long flags, const char *expe
|
||||
r = mount_flags_to_string(flags, &x);
|
||||
log_info("flags: %#lX → %d/\"%s\"", flags, r, strnull(x));
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(x, expected));
|
||||
ASSERT_STREQ(x, expected);
|
||||
}
|
||||
|
||||
TEST(mount_flags_to_string) {
|
||||
|
||||
@ -33,7 +33,7 @@ static void test_mount_propagation_flag_one(const char *name, int ret, unsigned
|
||||
if (isempty(name))
|
||||
assert_se(isempty(c));
|
||||
else
|
||||
assert_se(streq(c, name));
|
||||
ASSERT_STREQ(c, name);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -25,7 +25,7 @@ TEST(naming_scheme_conversions) {
|
||||
log_info("latest → %s", n->name);
|
||||
|
||||
assert_se(n = naming_scheme_from_name("v238"));
|
||||
assert_se(streq(n->name, "v238"));
|
||||
ASSERT_STREQ(n->name, "v238");
|
||||
}
|
||||
|
||||
DEFINE_TEST_MAIN(LOG_INFO);
|
||||
|
||||
@ -13,10 +13,10 @@ TEST(strv_split_nulstr) {
|
||||
l = strv_split_nulstr(nulstr);
|
||||
assert_se(l);
|
||||
|
||||
assert_se(streq(l[0], "str0"));
|
||||
assert_se(streq(l[1], "str1"));
|
||||
assert_se(streq(l[2], "str2"));
|
||||
assert_se(streq(l[3], "str3"));
|
||||
ASSERT_STREQ(l[0], "str0");
|
||||
ASSERT_STREQ(l[1], "str1");
|
||||
ASSERT_STREQ(l[2], "str2");
|
||||
ASSERT_STREQ(l[3], "str3");
|
||||
}
|
||||
|
||||
#define strv_parse_nulstr_full_one(s, n, e0, e1) \
|
||||
@ -97,7 +97,7 @@ static void test_strv_make_nulstr_one(char **l) {
|
||||
assert_se(memcmp_nn(b, n, c, m) == 0);
|
||||
|
||||
NULSTR_FOREACH(s, b)
|
||||
assert_se(streq(s, l[i++]));
|
||||
ASSERT_STREQ(s, l[i++]);
|
||||
assert_se(i == strv_length(l));
|
||||
}
|
||||
|
||||
|
||||
@ -11,32 +11,32 @@ TEST(open_file_parse) {
|
||||
r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:read-only", &of);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "host-mount-namespace"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "host-mount-namespace");
|
||||
assert_se(of->flags == OPENFILE_READ_ONLY);
|
||||
|
||||
of = open_file_free(of);
|
||||
r = open_file_parse("/proc/1/ns/mnt", &of);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "mnt"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "mnt");
|
||||
assert_se(of->flags == 0);
|
||||
|
||||
of = open_file_free(of);
|
||||
r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace", &of);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "host-mount-namespace"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "host-mount-namespace");
|
||||
assert_se(of->flags == 0);
|
||||
|
||||
of = open_file_free(of);
|
||||
r = open_file_parse("/proc/1/ns/mnt::read-only", &of);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "mnt"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "mnt");
|
||||
assert_se(of->flags == OPENFILE_READ_ONLY);
|
||||
|
||||
of = open_file_free(of);
|
||||
@ -53,16 +53,16 @@ TEST(open_file_parse) {
|
||||
r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:append", &of);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "host-mount-namespace"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "host-mount-namespace");
|
||||
assert_se(of->flags == OPENFILE_APPEND);
|
||||
|
||||
of = open_file_free(of);
|
||||
r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:truncate", &of);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "host-mount-namespace"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "host-mount-namespace");
|
||||
assert_se(of->flags == OPENFILE_TRUNCATE);
|
||||
|
||||
of = open_file_free(of);
|
||||
@ -89,16 +89,16 @@ TEST(open_file_parse) {
|
||||
r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:graceful", &of);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "host-mount-namespace"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "host-mount-namespace");
|
||||
assert_se(of->flags == OPENFILE_GRACEFUL);
|
||||
|
||||
of = open_file_free(of);
|
||||
r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:read-only,graceful", &of);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(of->path, "/proc/1/ns/mnt"));
|
||||
assert_se(streq(of->fdname, "host-mount-namespace"));
|
||||
ASSERT_STREQ(of->path, "/proc/1/ns/mnt");
|
||||
ASSERT_STREQ(of->fdname, "host-mount-namespace");
|
||||
assert_se(of->flags == (OPENFILE_READ_ONLY | OPENFILE_GRACEFUL));
|
||||
|
||||
of = open_file_free(of);
|
||||
@ -120,7 +120,7 @@ TEST(open_file_to_string) {
|
||||
r = open_file_to_string(of, &s);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:read-only"));
|
||||
ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:read-only");
|
||||
|
||||
s = mfree(s);
|
||||
of->flags = OPENFILE_APPEND;
|
||||
@ -128,7 +128,7 @@ TEST(open_file_to_string) {
|
||||
r = open_file_to_string(of, &s);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:append"));
|
||||
ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:append");
|
||||
|
||||
s = mfree(s);
|
||||
of->flags = OPENFILE_TRUNCATE;
|
||||
@ -136,7 +136,7 @@ TEST(open_file_to_string) {
|
||||
r = open_file_to_string(of, &s);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:truncate"));
|
||||
ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:truncate");
|
||||
|
||||
s = mfree(s);
|
||||
of->flags = OPENFILE_GRACEFUL;
|
||||
@ -144,7 +144,7 @@ TEST(open_file_to_string) {
|
||||
r = open_file_to_string(of, &s);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:graceful"));
|
||||
ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:graceful");
|
||||
|
||||
s = mfree(s);
|
||||
of->flags = OPENFILE_READ_ONLY | OPENFILE_GRACEFUL;
|
||||
@ -152,7 +152,7 @@ TEST(open_file_to_string) {
|
||||
r = open_file_to_string(of, &s);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:read-only,graceful"));
|
||||
ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:read-only,graceful");
|
||||
|
||||
s = mfree(s);
|
||||
of->flags = 0;
|
||||
@ -160,7 +160,7 @@ TEST(open_file_to_string) {
|
||||
r = open_file_to_string(of, &s);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace"));
|
||||
ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace");
|
||||
|
||||
s = mfree(s);
|
||||
assert_se(free_and_strdup(&of->fdname, "mnt"));
|
||||
@ -169,7 +169,7 @@ TEST(open_file_to_string) {
|
||||
r = open_file_to_string(of, &s);
|
||||
|
||||
assert_se(r >= 0);
|
||||
assert_se(streq(s, "/proc/1/ns/mnt::read-only"));
|
||||
ASSERT_STREQ(s, "/proc/1/ns/mnt::read-only");
|
||||
|
||||
s = mfree(s);
|
||||
ASSERT_OK(free_and_strdup(&of->path, "/path:with:colon"));
|
||||
|
||||
@ -81,9 +81,9 @@ TEST(set_put) {
|
||||
* non-trivial hash ops. */
|
||||
|
||||
assert_se(t = ordered_set_get_strv(m));
|
||||
assert_se(streq(t[0], "1"));
|
||||
assert_se(streq(t[1], "22"));
|
||||
assert_se(streq(t[2], "333"));
|
||||
ASSERT_STREQ(t[0], "1");
|
||||
ASSERT_STREQ(t[1], "22");
|
||||
ASSERT_STREQ(t[2], "333");
|
||||
assert_se(!t[3]);
|
||||
|
||||
ordered_set_print(stdout, "FOO=", m);
|
||||
|
||||
@ -39,8 +39,8 @@ TEST(parse_os_release) {
|
||||
ASSERT_EQ(setenv("SYSTEMD_OS_RELEASE", tmpfile, 1), 0);
|
||||
ASSERT_EQ(parse_os_release(NULL, "ID", &id, "NAME", &name), 0);
|
||||
log_info("ID: %s NAME: %s", id, name);
|
||||
assert_se(streq(id, "the-id"));
|
||||
assert_se(streq(name, "the-name"));
|
||||
ASSERT_STREQ(id, "the-id");
|
||||
ASSERT_STREQ(name, "the-name");
|
||||
|
||||
_cleanup_(unlink_tempfilep) char tmpfile2[] = "/tmp/test-os-util.XXXXXX";
|
||||
ASSERT_EQ(write_tmpfile(tmpfile2,
|
||||
@ -51,8 +51,8 @@ TEST(parse_os_release) {
|
||||
ASSERT_EQ(setenv("SYSTEMD_OS_RELEASE", tmpfile2, 1), 0);
|
||||
ASSERT_EQ(parse_os_release(NULL, "ID", &id, "NAME", &name), 0);
|
||||
log_info("ID: %s NAME: %s", id, name);
|
||||
assert_se(streq(id, "the-id"));
|
||||
assert_se(streq(name, "the-name"));
|
||||
ASSERT_STREQ(id, "the-id");
|
||||
ASSERT_STREQ(name, "the-name");
|
||||
|
||||
ASSERT_EQ(parse_os_release(NULL, "FOOBAR", &foobar), 0);
|
||||
log_info("FOOBAR: %s", strnull(foobar));
|
||||
@ -80,8 +80,8 @@ TEST(parse_extension_release) {
|
||||
|
||||
assert_se(parse_extension_release(tempdir, IMAGE_SYSEXT, "test", false, "ID", &id, "VERSION_ID", &version_id) == 0);
|
||||
log_info("ID: %s VERSION_ID: %s", id, version_id);
|
||||
assert_se(streq(id, "the-id"));
|
||||
assert_se(streq(version_id, "the-version-id"));
|
||||
ASSERT_STREQ(id, "the-id");
|
||||
ASSERT_STREQ(version_id, "the-version-id");
|
||||
|
||||
assert_se(b = path_join(tempdir, "/etc/extension-release.d/extension-release.tester"));
|
||||
assert_se(mkdir_parents(b, 0777) >= 0);
|
||||
@ -92,8 +92,8 @@ TEST(parse_extension_release) {
|
||||
|
||||
ASSERT_EQ(parse_extension_release(tempdir, IMAGE_CONFEXT, "tester", false, "ID", &id, "VERSION_ID", &version_id), 0);
|
||||
log_info("ID: %s VERSION_ID: %s", id, version_id);
|
||||
assert_se(streq(id, "the-id"));
|
||||
assert_se(streq(version_id, "the-version-id"));
|
||||
ASSERT_STREQ(id, "the-id");
|
||||
ASSERT_STREQ(version_id, "the-version-id");
|
||||
|
||||
assert_se(parse_extension_release(tempdir, IMAGE_CONFEXT, "tester", false, "FOOBAR", &foobar) == 0);
|
||||
log_info("FOOBAR: %s", strnull(foobar));
|
||||
|
||||
@ -20,10 +20,10 @@ TEST(parse_path_argument) {
|
||||
_cleanup_free_ char *path = NULL;
|
||||
|
||||
assert_se(parse_path_argument("help", false, &path) == 0);
|
||||
assert_se(streq(basename(path), "help"));
|
||||
ASSERT_STREQ(basename(path), "help");
|
||||
|
||||
assert_se(parse_path_argument("/", false, &path) == 0);
|
||||
assert_se(streq(path, "/"));
|
||||
ASSERT_STREQ(path, "/");
|
||||
|
||||
assert_se(parse_path_argument("/", true, &path) == 0);
|
||||
ASSERT_NULL(path);
|
||||
|
||||
@ -28,7 +28,7 @@ static void test_paths_one(RuntimeScope scope) {
|
||||
assert_se(setenv("SYSTEMD_UNIT_PATH", systemd_unit_path, 1) == 0);
|
||||
assert_se(lookup_paths_init(&lp_with_env, scope, 0, NULL) == 0);
|
||||
assert_se(strv_length(lp_with_env.search_path) == 1);
|
||||
assert_se(streq(lp_with_env.search_path[0], systemd_unit_path));
|
||||
ASSERT_STREQ(lp_with_env.search_path[0], systemd_unit_path);
|
||||
lookup_paths_log(&lp_with_env);
|
||||
assert_se(strv_equal(lp_with_env.search_path, STRV_MAKE(systemd_unit_path)));
|
||||
}
|
||||
|
||||
@ -26,10 +26,10 @@ TEST(path) {
|
||||
assert_se( path_is_absolute("/"));
|
||||
assert_se(!path_is_absolute("./"));
|
||||
|
||||
assert_se(streq(basename("./aa/bb/../file.da."), "file.da."));
|
||||
assert_se(streq(basename("/aa///.file"), ".file"));
|
||||
assert_se(streq(basename("/aa///file..."), "file..."));
|
||||
assert_se(streq(basename("file.../"), ""));
|
||||
ASSERT_STREQ(basename("./aa/bb/../file.da."), "file.da.");
|
||||
ASSERT_STREQ(basename("/aa///.file"), ".file");
|
||||
ASSERT_STREQ(basename("/aa///file..."), "file...");
|
||||
ASSERT_STREQ(basename("file.../"), "");
|
||||
|
||||
assert_se( PATH_IN_SET("/bin", "/", "/bin", "/foo"));
|
||||
assert_se( PATH_IN_SET("/bin", "/bin"));
|
||||
@ -146,7 +146,7 @@ static void test_path_simplify_one(const char *in, const char *out, PathSimplify
|
||||
p = strdupa_safe(in);
|
||||
path_simplify_full(p, flags);
|
||||
log_debug("/* test_path_simplify(%s) → %s (expected: %s) */", in, p, out);
|
||||
assert_se(streq(p, out));
|
||||
ASSERT_STREQ(p, out);
|
||||
}
|
||||
|
||||
TEST(path_simplify) {
|
||||
@ -379,12 +379,12 @@ TEST(find_executable_full) {
|
||||
|
||||
assert_se(find_executable_full("sh", NULL, NULL, true, &p, NULL) == 0);
|
||||
puts(p);
|
||||
assert_se(streq(basename(p), "sh"));
|
||||
ASSERT_STREQ(basename(p), "sh");
|
||||
free(p);
|
||||
|
||||
assert_se(find_executable_full("sh", NULL, NULL, false, &p, NULL) == 0);
|
||||
puts(p);
|
||||
assert_se(streq(basename(p), "sh"));
|
||||
ASSERT_STREQ(basename(p), "sh");
|
||||
free(p);
|
||||
|
||||
_cleanup_free_ char *oldpath = NULL;
|
||||
@ -396,12 +396,12 @@ TEST(find_executable_full) {
|
||||
|
||||
assert_se(find_executable_full("sh", NULL, NULL, true, &p, NULL) == 0);
|
||||
puts(p);
|
||||
assert_se(streq(basename(p), "sh"));
|
||||
ASSERT_STREQ(basename(p), "sh");
|
||||
free(p);
|
||||
|
||||
assert_se(find_executable_full("sh", NULL, NULL, false, &p, NULL) == 0);
|
||||
puts(p);
|
||||
assert_se(streq(basename(p), "sh"));
|
||||
ASSERT_STREQ(basename(p), "sh");
|
||||
free(p);
|
||||
|
||||
if (oldpath)
|
||||
@ -414,7 +414,7 @@ TEST(find_executable_full) {
|
||||
|
||||
assert_se(find_executable_full(test_file_name, NULL, STRV_MAKE("/doesnotexist", "/tmp", "/bin"), false, &p, NULL) == 0);
|
||||
puts(p);
|
||||
assert_se(streq(p, fn));
|
||||
ASSERT_STREQ(p, fn);
|
||||
free(p);
|
||||
|
||||
(void) unlink(fn);
|
||||
@ -442,12 +442,12 @@ TEST(find_executable) {
|
||||
free(p);
|
||||
|
||||
assert_se(find_executable("/bin/touch", &p) == 0);
|
||||
assert_se(streq(p, "/bin/touch"));
|
||||
ASSERT_STREQ(p, "/bin/touch");
|
||||
free(p);
|
||||
|
||||
assert_se(find_executable("touch", &p) == 0);
|
||||
assert_se(path_is_absolute(p));
|
||||
assert_se(streq(basename(p), "touch"));
|
||||
ASSERT_STREQ(basename(p), "touch");
|
||||
free(p);
|
||||
|
||||
assert_se(find_executable("xxxx-xxxx", &p) == -ENOENT);
|
||||
@ -468,7 +468,7 @@ static void test_find_executable_exec_one(const char *path) {
|
||||
assert_se(fd > STDERR_FILENO);
|
||||
assert_se(path_is_absolute(t));
|
||||
if (path_is_absolute(path))
|
||||
assert_se(streq(t, path));
|
||||
ASSERT_STREQ(t, path);
|
||||
|
||||
pid = fork();
|
||||
assert_se(pid >= 0);
|
||||
@ -506,25 +506,25 @@ TEST(prefixes) {
|
||||
i = 0;
|
||||
PATH_FOREACH_PREFIX_MORE(s, "/a/b/c/d") {
|
||||
log_error("---%s---", s);
|
||||
assert_se(streq(s, values[i++]));
|
||||
ASSERT_STREQ(s, values[i++]);
|
||||
}
|
||||
ASSERT_NULL(values[i]);
|
||||
|
||||
i = 1;
|
||||
PATH_FOREACH_PREFIX(s, "/a/b/c/d") {
|
||||
log_error("---%s---", s);
|
||||
assert_se(streq(s, values[i++]));
|
||||
ASSERT_STREQ(s, values[i++]);
|
||||
}
|
||||
ASSERT_NULL(values[i]);
|
||||
|
||||
i = 0;
|
||||
PATH_FOREACH_PREFIX_MORE(s, "////a////b////c///d///////")
|
||||
assert_se(streq(s, values[i++]));
|
||||
ASSERT_STREQ(s, values[i++]);
|
||||
ASSERT_NULL(values[i]);
|
||||
|
||||
i = 1;
|
||||
PATH_FOREACH_PREFIX(s, "////a////b////c///d///////")
|
||||
assert_se(streq(s, values[i++]));
|
||||
ASSERT_STREQ(s, values[i++]);
|
||||
ASSERT_NULL(values[i]);
|
||||
|
||||
PATH_FOREACH_PREFIX(s, "////")
|
||||
@ -533,7 +533,7 @@ TEST(prefixes) {
|
||||
b = false;
|
||||
PATH_FOREACH_PREFIX_MORE(s, "////") {
|
||||
assert_se(!b);
|
||||
assert_se(streq(s, ""));
|
||||
ASSERT_STREQ(s, "");
|
||||
b = true;
|
||||
}
|
||||
assert_se(b);
|
||||
@ -544,7 +544,7 @@ TEST(prefixes) {
|
||||
b = false;
|
||||
PATH_FOREACH_PREFIX_MORE(s, "") {
|
||||
assert_se(!b);
|
||||
assert_se(streq(s, ""));
|
||||
ASSERT_STREQ(s, "");
|
||||
b = true;
|
||||
}
|
||||
}
|
||||
@ -554,7 +554,7 @@ TEST(path_join) {
|
||||
_cleanup_free_ char *z = NULL; \
|
||||
z = path_join(__VA_ARGS__); \
|
||||
log_debug("got \"%s\", expected \"%s\"", z, expected); \
|
||||
assert_se(streq(z, expected)); \
|
||||
ASSERT_STREQ(z, expected); \
|
||||
}
|
||||
|
||||
test_join("/root/a/b/c", "/root", "/a/b", "/c");
|
||||
@ -597,25 +597,25 @@ TEST(path_extend) {
|
||||
_cleanup_free_ char *p = NULL;
|
||||
|
||||
assert_se(path_extend(&p, "foo", "bar", "baz") == p);
|
||||
assert_se(streq(p, "foo/bar/baz"));
|
||||
ASSERT_STREQ(p, "foo/bar/baz");
|
||||
|
||||
assert_se(path_extend(&p, "foo", "bar", "baz") == p);
|
||||
assert_se(streq(p, "foo/bar/baz/foo/bar/baz"));
|
||||
ASSERT_STREQ(p, "foo/bar/baz/foo/bar/baz");
|
||||
|
||||
p = mfree(p);
|
||||
assert_se(path_extend(&p, "foo") == p);
|
||||
assert_se(streq(p, "foo"));
|
||||
ASSERT_STREQ(p, "foo");
|
||||
|
||||
assert_se(path_extend(&p, "/foo") == p);
|
||||
assert_se(streq(p, "foo/foo"));
|
||||
ASSERT_STREQ(p, "foo/foo");
|
||||
assert_se(path_extend(&p, "/waaaah/wahhh//") == p);
|
||||
assert_se(streq(p, "foo/foo/waaaah/wahhh//")); /* path_extend() does not drop redundant slashes */
|
||||
ASSERT_STREQ(p, "foo/foo/waaaah/wahhh//"); /* path_extend() does not drop redundant slashes */
|
||||
assert_se(path_extend(&p, "/aaa/bbb/") == p);
|
||||
assert_se(streq(p, "foo/foo/waaaah/wahhh///aaa/bbb/")); /* but not add an extra slash */
|
||||
ASSERT_STREQ(p, "foo/foo/waaaah/wahhh///aaa/bbb/"); /* but not add an extra slash */
|
||||
|
||||
assert_se(free_and_strdup(&p, "/") >= 0);
|
||||
assert_se(path_extend(&p, "foo") == p);
|
||||
assert_se(streq(p, "/foo"));
|
||||
ASSERT_STREQ(p, "/foo");
|
||||
}
|
||||
|
||||
TEST(fsck_exists) {
|
||||
@ -637,7 +637,7 @@ static void test_path_make_relative_one(const char *from, const char *to, const
|
||||
|
||||
r = path_make_relative(from, to, &z);
|
||||
assert_se((r >= 0) == !!expected);
|
||||
assert_se(streq_ptr(z, expected));
|
||||
ASSERT_STREQ(z, expected);
|
||||
}
|
||||
|
||||
TEST(path_make_relative) {
|
||||
@ -663,7 +663,7 @@ static void test_path_make_relative_parent_one(const char *from, const char *to,
|
||||
|
||||
r = path_make_relative_parent(from, to, &z);
|
||||
assert_se((r >= 0) == !!expected);
|
||||
assert_se(streq_ptr(z, expected));
|
||||
ASSERT_STREQ(z, expected);
|
||||
}
|
||||
|
||||
TEST(path_make_relative_parent) {
|
||||
@ -702,9 +702,9 @@ TEST(path_strv_resolve) {
|
||||
assert_se(symlink("dir2", absolute_dirs[2]) == 0);
|
||||
|
||||
path_strv_resolve(search_dirs, tmp_dir);
|
||||
assert_se(streq(search_dirs[0], "/dir1"));
|
||||
assert_se(streq(search_dirs[1], "/dir2"));
|
||||
assert_se(streq(search_dirs[2], "/dir2"));
|
||||
ASSERT_STREQ(search_dirs[0], "/dir1");
|
||||
ASSERT_STREQ(search_dirs[1], "/dir2");
|
||||
ASSERT_STREQ(search_dirs[2], "/dir2");
|
||||
|
||||
assert_se(rm_rf(tmp_dir, REMOVE_ROOT|REMOVE_PHYSICAL) == 0);
|
||||
}
|
||||
@ -715,10 +715,10 @@ static void test_path_startswith_one(const char *path, const char *prefix, const
|
||||
log_debug("/* %s(%s, %s) */", __func__, path, prefix);
|
||||
|
||||
p = path_startswith(path, prefix);
|
||||
assert_se(streq_ptr(p, expected));
|
||||
ASSERT_STREQ(p, expected);
|
||||
if (p) {
|
||||
q = strjoina(skipped, p);
|
||||
assert_se(streq(q, path));
|
||||
ASSERT_STREQ(q, path);
|
||||
assert_se(p == path + strlen(skipped));
|
||||
}
|
||||
}
|
||||
@ -793,17 +793,17 @@ TEST(file_in_same_dir) {
|
||||
assert_se(file_in_same_dir("/", "a", &t) == -EADDRNOTAVAIL);
|
||||
|
||||
assert_se(file_in_same_dir("/", "/a", &t) >= 0);
|
||||
assert_se(streq(t, "/a"));
|
||||
ASSERT_STREQ(t, "/a");
|
||||
free(t);
|
||||
|
||||
assert_se(file_in_same_dir("", "a", &t) == -EINVAL);
|
||||
|
||||
assert_se(file_in_same_dir("a/", "x", &t) >= 0);
|
||||
assert_se(streq(t, "x"));
|
||||
ASSERT_STREQ(t, "x");
|
||||
free(t);
|
||||
|
||||
assert_se(file_in_same_dir("bar/foo", "bar", &t) >= 0);
|
||||
assert_se(streq(t, "bar/bar"));
|
||||
ASSERT_STREQ(t, "bar/bar");
|
||||
free(t);
|
||||
}
|
||||
|
||||
@ -987,22 +987,22 @@ TEST(path_find_last_component) {
|
||||
|
||||
TEST(last_path_component) {
|
||||
ASSERT_NULL(last_path_component(NULL));
|
||||
assert_se(streq(last_path_component("a/b/c"), "c"));
|
||||
assert_se(streq(last_path_component("a/b/c/"), "c/"));
|
||||
assert_se(streq(last_path_component("/"), "/"));
|
||||
assert_se(streq(last_path_component("//"), "/"));
|
||||
assert_se(streq(last_path_component("///"), "/"));
|
||||
assert_se(streq(last_path_component("."), "."));
|
||||
assert_se(streq(last_path_component("./."), "."));
|
||||
assert_se(streq(last_path_component("././"), "./"));
|
||||
assert_se(streq(last_path_component("././/"), ".//"));
|
||||
assert_se(streq(last_path_component("/foo/a"), "a"));
|
||||
assert_se(streq(last_path_component("/foo/a/"), "a/"));
|
||||
assert_se(streq(last_path_component(""), ""));
|
||||
assert_se(streq(last_path_component("a"), "a"));
|
||||
assert_se(streq(last_path_component("a/"), "a/"));
|
||||
assert_se(streq(last_path_component("/a"), "a"));
|
||||
assert_se(streq(last_path_component("/a/"), "a/"));
|
||||
ASSERT_STREQ(last_path_component("a/b/c"), "c");
|
||||
ASSERT_STREQ(last_path_component("a/b/c/"), "c/");
|
||||
ASSERT_STREQ(last_path_component("/"), "/");
|
||||
ASSERT_STREQ(last_path_component("//"), "/");
|
||||
ASSERT_STREQ(last_path_component("///"), "/");
|
||||
ASSERT_STREQ(last_path_component("."), ".");
|
||||
ASSERT_STREQ(last_path_component("./."), ".");
|
||||
ASSERT_STREQ(last_path_component("././"), "./");
|
||||
ASSERT_STREQ(last_path_component("././/"), ".//");
|
||||
ASSERT_STREQ(last_path_component("/foo/a"), "a");
|
||||
ASSERT_STREQ(last_path_component("/foo/a/"), "a/");
|
||||
ASSERT_STREQ(last_path_component(""), "");
|
||||
ASSERT_STREQ(last_path_component("a"), "a");
|
||||
ASSERT_STREQ(last_path_component("a/"), "a/");
|
||||
ASSERT_STREQ(last_path_component("/a"), "a");
|
||||
ASSERT_STREQ(last_path_component("/a/"), "a/");
|
||||
}
|
||||
|
||||
static void test_path_extract_filename_one(const char *input, const char *output, int ret) {
|
||||
@ -1014,7 +1014,7 @@ static void test_path_extract_filename_one(const char *input, const char *output
|
||||
strnull(input),
|
||||
strnull(k), r < 0 ? STRERROR(r) : "-",
|
||||
strnull(output), ret < 0 ? STRERROR(ret) : "-");
|
||||
assert_se(streq_ptr(k, output));
|
||||
ASSERT_STREQ(k, output);
|
||||
assert_se(r == ret);
|
||||
}
|
||||
|
||||
@ -1058,7 +1058,7 @@ static void test_path_extract_directory_one(const char *input, const char *outpu
|
||||
strnull(input),
|
||||
strnull(k), r < 0 ? STRERROR(r) : "-",
|
||||
strnull(output), STRERROR(ret));
|
||||
assert_se(streq_ptr(k, output));
|
||||
ASSERT_STREQ(k, output);
|
||||
assert_se(r == ret);
|
||||
|
||||
/* Extra safety check: let's make sure that if we split out the filename too (and it works) the
|
||||
@ -1192,17 +1192,17 @@ TEST(hidden_or_backup_file) {
|
||||
}
|
||||
|
||||
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("/dev/foo"), "foo"));
|
||||
assert_se(streq(skip_dev_prefix("/dev/foo/bar"), "foo/bar"));
|
||||
assert_se(streq(skip_dev_prefix("//dev"), ""));
|
||||
assert_se(streq(skip_dev_prefix("//dev//"), ""));
|
||||
assert_se(streq(skip_dev_prefix("/dev///foo"), "foo"));
|
||||
assert_se(streq(skip_dev_prefix("///dev///foo///bar"), "foo///bar"));
|
||||
assert_se(streq(skip_dev_prefix("//foo"), "//foo"));
|
||||
assert_se(streq(skip_dev_prefix("foo"), "foo"));
|
||||
ASSERT_STREQ(skip_dev_prefix("/"), "/");
|
||||
ASSERT_STREQ(skip_dev_prefix("/dev"), "");
|
||||
ASSERT_STREQ(skip_dev_prefix("/dev/"), "");
|
||||
ASSERT_STREQ(skip_dev_prefix("/dev/foo"), "foo");
|
||||
ASSERT_STREQ(skip_dev_prefix("/dev/foo/bar"), "foo/bar");
|
||||
ASSERT_STREQ(skip_dev_prefix("//dev"), "");
|
||||
ASSERT_STREQ(skip_dev_prefix("//dev//"), "");
|
||||
ASSERT_STREQ(skip_dev_prefix("/dev///foo"), "foo");
|
||||
ASSERT_STREQ(skip_dev_prefix("///dev///foo///bar"), "foo///bar");
|
||||
ASSERT_STREQ(skip_dev_prefix("//foo"), "//foo");
|
||||
ASSERT_STREQ(skip_dev_prefix("foo"), "foo");
|
||||
}
|
||||
|
||||
TEST(empty_or_root) {
|
||||
@ -1219,43 +1219,43 @@ TEST(empty_or_root) {
|
||||
}
|
||||
|
||||
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("/foo/bar", "/foo/quux", "/", "/zzz"), "foo/bar"));
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "", "/zzz"), NULL));
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/foo/bar", "/zzz"), "");
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/foo/", "/zzz"), "bar");
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/foo", "/zzz"), "bar");
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/", "/zzz"), "foo/bar");
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "", "/zzz"), NULL);
|
||||
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "/foo/bar", "/zzz"), NULL));
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "/foo/", "/zzz"), "bar2"));
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "/foo", "/zzz"), "bar2"));
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "/", "/zzz"), "foo/bar2"));
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "", "/zzz"), NULL));
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "/foo/bar", "/zzz"), NULL);
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "/foo/", "/zzz"), "bar2");
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "/foo", "/zzz"), "bar2");
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "/", "/zzz"), "foo/bar2");
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo/bar2", "/foo/quux", "", "/zzz"), NULL);
|
||||
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "/foo/bar", "/zzz"), NULL));
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "/foo/", "/zzz"), NULL));
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "/foo", "/zzz"), NULL));
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "/", "/zzz"), "foo2/bar"));
|
||||
assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "", "/zzz"), NULL));
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "/foo/bar", "/zzz"), NULL);
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "/foo/", "/zzz"), NULL);
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "/foo", "/zzz"), NULL);
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "/", "/zzz"), "foo2/bar");
|
||||
ASSERT_STREQ(PATH_STARTSWITH_SET("/foo2/bar", "/foo/quux", "", "/zzz"), NULL);
|
||||
}
|
||||
|
||||
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("/foo/bar", STRV_MAKE("/foo/quux", "/", "/zzz")), "foo/bar"));
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo/bar", STRV_MAKE("/foo/quux", "", "/zzz")), NULL));
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar", STRV_MAKE("/foo/quux", "/foo/bar", "/zzz")), "");
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar", STRV_MAKE("/foo/quux", "/foo/", "/zzz")), "bar");
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar", STRV_MAKE("/foo/quux", "/foo", "/zzz")), "bar");
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar", STRV_MAKE("/foo/quux", "/", "/zzz")), "foo/bar");
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar", STRV_MAKE("/foo/quux", "", "/zzz")), NULL);
|
||||
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "/foo/bar", "/zzz")), NULL));
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "/foo/", "/zzz")), "bar2"));
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "/foo", "/zzz")), "bar2"));
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "/", "/zzz")), "foo/bar2"));
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "", "/zzz")), NULL));
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "/foo/bar", "/zzz")), NULL);
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "/foo/", "/zzz")), "bar2");
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "/foo", "/zzz")), "bar2");
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "/", "/zzz")), "foo/bar2");
|
||||
ASSERT_STREQ(path_startswith_strv("/foo/bar2", STRV_MAKE("/foo/quux", "", "/zzz")), NULL);
|
||||
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "/foo/bar", "/zzz")), NULL));
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "/foo/", "/zzz")), NULL));
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "/foo", "/zzz")), NULL));
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "/", "/zzz")), "foo2/bar"));
|
||||
assert_se(streq_ptr(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "", "/zzz")), NULL));
|
||||
ASSERT_STREQ(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "/foo/bar", "/zzz")), NULL);
|
||||
ASSERT_STREQ(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "/foo/", "/zzz")), NULL);
|
||||
ASSERT_STREQ(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "/foo", "/zzz")), NULL);
|
||||
ASSERT_STREQ(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "/", "/zzz")), "foo2/bar");
|
||||
ASSERT_STREQ(path_startswith_strv("/foo2/bar", STRV_MAKE("/foo/quux", "", "/zzz")), NULL);
|
||||
}
|
||||
|
||||
static void test_path_glob_can_match_one(const char *pattern, const char *prefix, const char *expected) {
|
||||
@ -1264,7 +1264,7 @@ static void test_path_glob_can_match_one(const char *pattern, const char *prefix
|
||||
log_debug("%s(%s, %s, %s)", __func__, pattern, prefix, strnull(expected));
|
||||
|
||||
assert_se(path_glob_can_match(pattern, prefix, &result) == !!expected);
|
||||
assert_se(streq_ptr(result, expected));
|
||||
ASSERT_STREQ(result, expected);
|
||||
}
|
||||
|
||||
TEST(path_glob_can_match) {
|
||||
|
||||
@ -37,7 +37,7 @@ TEST(proc_cmdline_override) {
|
||||
|
||||
/* First test if the overrides for /proc/cmdline still work */
|
||||
assert_se(proc_cmdline(&line) >= 0);
|
||||
assert_se(streq(line, "foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\""));
|
||||
ASSERT_STREQ(line, "foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\"");
|
||||
line = mfree(line);
|
||||
assert_se(proc_cmdline_strv(&args) >= 0);
|
||||
assert_se(strv_equal(args, STRV_MAKE("foo_bar=quux", "wuff-piep=tuet", "zumm", "some_arg_with_space=foo bar", "and_one_more=zzz aaa")));
|
||||
@ -57,7 +57,7 @@ TEST(proc_cmdline_override) {
|
||||
assert_se(putenv((char*) "SYSTEMD_EFI_OPTIONS=foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\"") == 0);
|
||||
|
||||
assert_se(proc_cmdline(&line) >= 0);
|
||||
assert_se(streq(line, "hoge"));
|
||||
ASSERT_STREQ(line, "hoge");
|
||||
line = mfree(line);
|
||||
assert_se(proc_cmdline_strv(&args) >= 0);
|
||||
assert_se(strv_equal(args, STRV_MAKE("hoge")));
|
||||
@ -83,13 +83,13 @@ static int parse_item_given(const char *key, const char *value, void *data) {
|
||||
|
||||
log_info("%s: option <%s> = <%s>", __func__, key, strna(value));
|
||||
if (proc_cmdline_key_streq(key, "foo_bar"))
|
||||
assert_se(streq(value, "quux"));
|
||||
ASSERT_STREQ(value, "quux");
|
||||
else if (proc_cmdline_key_streq(key, "wuff-piep"))
|
||||
assert_se(streq(value, "tuet "));
|
||||
ASSERT_STREQ(value, "tuet ");
|
||||
else if (proc_cmdline_key_streq(key, "space"))
|
||||
assert_se(streq(value, "x y z"));
|
||||
ASSERT_STREQ(value, "x y z");
|
||||
else if (proc_cmdline_key_streq(key, "miepf"))
|
||||
assert_se(streq(value, "uuu"));
|
||||
ASSERT_STREQ(value, "uuu");
|
||||
else if (in_initrd() && *strip && proc_cmdline_key_streq(key, "zumm"))
|
||||
assert_se(!value);
|
||||
else if (in_initrd() && !*strip && proc_cmdline_key_streq(key, "rd.zumm"))
|
||||
@ -231,13 +231,13 @@ TEST(proc_cmdline_get_key_many) {
|
||||
"doubleticks", &value6,
|
||||
"zummm", &value7) == 5);
|
||||
|
||||
assert_se(streq_ptr(value1, "quux"));
|
||||
ASSERT_STREQ(value1, "quux");
|
||||
assert_se(!value2);
|
||||
assert_se(streq_ptr(value3, "tuet"));
|
||||
ASSERT_STREQ(value3, "tuet");
|
||||
assert_se(!value4);
|
||||
assert_se(streq_ptr(value5, "one two"));
|
||||
assert_se(streq_ptr(value6, " aaa aaa "));
|
||||
assert_se(streq_ptr(value7, "\n"));
|
||||
ASSERT_STREQ(value5, "one two");
|
||||
ASSERT_STREQ(value6, " aaa aaa ");
|
||||
ASSERT_STREQ(value7, "\n");
|
||||
}
|
||||
|
||||
TEST(proc_cmdline_key_streq) {
|
||||
|
||||
@ -176,7 +176,7 @@ static void test_pid_get_comm_escape_one(const char *input, const char *output)
|
||||
|
||||
log_debug("got: <%s>", n);
|
||||
|
||||
assert_se(streq_ptr(n, output));
|
||||
ASSERT_STREQ(n, output);
|
||||
}
|
||||
|
||||
TEST(pid_get_comm_escape) {
|
||||
@ -236,14 +236,14 @@ TEST(personality) {
|
||||
assert_se(personality_to_string(PER_LINUX));
|
||||
assert_se(!personality_to_string(PERSONALITY_INVALID));
|
||||
|
||||
assert_se(streq(personality_to_string(PER_LINUX), architecture_to_string(native_architecture())));
|
||||
ASSERT_STREQ(personality_to_string(PER_LINUX), architecture_to_string(native_architecture()));
|
||||
|
||||
assert_se(personality_from_string(personality_to_string(PER_LINUX)) == PER_LINUX);
|
||||
assert_se(personality_from_string(architecture_to_string(native_architecture())) == PER_LINUX);
|
||||
|
||||
#ifdef __x86_64__
|
||||
assert_se(streq_ptr(personality_to_string(PER_LINUX), "x86-64"));
|
||||
assert_se(streq_ptr(personality_to_string(PER_LINUX32), "x86"));
|
||||
ASSERT_STREQ(personality_to_string(PER_LINUX), "x86-64");
|
||||
ASSERT_STREQ(personality_to_string(PER_LINUX32), "x86");
|
||||
|
||||
assert_se(personality_from_string("x86-64") == PER_LINUX);
|
||||
assert_se(personality_from_string("x86") == PER_LINUX32);
|
||||
@ -328,49 +328,49 @@ TEST(pid_get_cmdline_harder) {
|
||||
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "[testa]"));
|
||||
ASSERT_STREQ(line, "[testa]");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK | PROCESS_CMDLINE_QUOTE, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "\"[testa]\"")); /* quoting is enabled here */
|
||||
ASSERT_STREQ(line, "\"[testa]\""); /* quoting is enabled here */
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 0, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, ""));
|
||||
ASSERT_STREQ(line, "");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 1, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
assert_se(streq(line, "…"));
|
||||
ASSERT_STREQ(line, "…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 2, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
assert_se(streq(line, "[…"));
|
||||
ASSERT_STREQ(line, "[…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 3, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
assert_se(streq(line, "[t…"));
|
||||
ASSERT_STREQ(line, "[t…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 4, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
assert_se(streq(line, "[te…"));
|
||||
ASSERT_STREQ(line, "[te…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 5, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
assert_se(streq(line, "[tes…"));
|
||||
ASSERT_STREQ(line, "[tes…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 6, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
assert_se(streq(line, "[test…"));
|
||||
ASSERT_STREQ(line, "[test…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 7, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
assert_se(streq(line, "[testa]"));
|
||||
ASSERT_STREQ(line, "[testa]");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 8, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
assert_se(streq(line, "[testa]"));
|
||||
ASSERT_STREQ(line, "[testa]");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline_strv(0, PROCESS_CMDLINE_COMM_FALLBACK, &args) >= 0);
|
||||
@ -383,11 +383,11 @@ TEST(pid_get_cmdline_harder) {
|
||||
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, 0, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar"));
|
||||
ASSERT_STREQ(line, "foo bar");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
assert_se(streq(line, "foo bar"));
|
||||
ASSERT_STREQ(line, "foo bar");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline_strv(0, PROCESS_CMDLINE_COMM_FALLBACK, &args) >= 0);
|
||||
@ -397,87 +397,87 @@ TEST(pid_get_cmdline_harder) {
|
||||
assert_se(write(fd, "quux", 4) == 4);
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, 0, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar quux"));
|
||||
ASSERT_STREQ(line, "foo bar quux");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar quux"));
|
||||
ASSERT_STREQ(line, "foo bar quux");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 1, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "…"));
|
||||
ASSERT_STREQ(line, "…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 2, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "f…"));
|
||||
ASSERT_STREQ(line, "f…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 3, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "fo…"));
|
||||
ASSERT_STREQ(line, "fo…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 4, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo…"));
|
||||
ASSERT_STREQ(line, "foo…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 5, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo …"));
|
||||
ASSERT_STREQ(line, "foo …");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 6, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo b…"));
|
||||
ASSERT_STREQ(line, "foo b…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 7, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo ba…"));
|
||||
ASSERT_STREQ(line, "foo ba…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 8, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar…"));
|
||||
ASSERT_STREQ(line, "foo bar…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 9, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar …"));
|
||||
ASSERT_STREQ(line, "foo bar …");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 10, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar q…"));
|
||||
ASSERT_STREQ(line, "foo bar q…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 11, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar qu…"));
|
||||
ASSERT_STREQ(line, "foo bar qu…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 12, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar quux"));
|
||||
ASSERT_STREQ(line, "foo bar quux");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 13, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar quux"));
|
||||
ASSERT_STREQ(line, "foo bar quux");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 14, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar quux"));
|
||||
ASSERT_STREQ(line, "foo bar quux");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 1000, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "foo bar quux"));
|
||||
ASSERT_STREQ(line, "foo bar quux");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline_strv(0, PROCESS_CMDLINE_COMM_FALLBACK, &args) >= 0);
|
||||
@ -491,22 +491,22 @@ TEST(pid_get_cmdline_harder) {
|
||||
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "[aaaa bbbb cccc]"));
|
||||
ASSERT_STREQ(line, "[aaaa bbbb cccc]");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 10, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "[aaaa bbb…"));
|
||||
ASSERT_STREQ(line, "[aaaa bbb…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 11, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "[aaaa bbbb…"));
|
||||
ASSERT_STREQ(line, "[aaaa bbbb…");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, 12, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0);
|
||||
log_debug("'%s'", line);
|
||||
assert_se(streq(line, "[aaaa bbbb …"));
|
||||
ASSERT_STREQ(line, "[aaaa bbbb …");
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline_strv(0, PROCESS_CMDLINE_COMM_FALLBACK, &args) >= 0);
|
||||
@ -527,13 +527,13 @@ TEST(pid_get_cmdline_harder) {
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_QUOTE, &line) >= 0);
|
||||
log_debug("got: ==%s==", line);
|
||||
log_debug("exp: ==%s==", EXPECT1);
|
||||
assert_se(streq(line, EXPECT1));
|
||||
ASSERT_STREQ(line, EXPECT1);
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_QUOTE_POSIX, &line) >= 0);
|
||||
log_debug("got: ==%s==", line);
|
||||
log_debug("exp: ==%s==", EXPECT1p);
|
||||
assert_se(streq(line, EXPECT1p));
|
||||
ASSERT_STREQ(line, EXPECT1p);
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline_strv(0, 0, &args) >= 0);
|
||||
@ -552,13 +552,13 @@ TEST(pid_get_cmdline_harder) {
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_QUOTE, &line) >= 0);
|
||||
log_debug("got: ==%s==", line);
|
||||
log_debug("exp: ==%s==", EXPECT2);
|
||||
assert_se(streq(line, EXPECT2));
|
||||
ASSERT_STREQ(line, EXPECT2);
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_QUOTE_POSIX, &line) >= 0);
|
||||
log_debug("got: ==%s==", line);
|
||||
log_debug("exp: ==%s==", EXPECT2p);
|
||||
assert_se(streq(line, EXPECT2p));
|
||||
ASSERT_STREQ(line, EXPECT2p);
|
||||
line = mfree(line);
|
||||
|
||||
assert_se(pid_get_cmdline_strv(0, 0, &args) >= 0);
|
||||
|
||||
@ -107,7 +107,7 @@ TEST(normalize_recovery_key) {
|
||||
r = normalize_recovery_key("cdefVhij-cDefghij-cdefkhij-cdufghij-cdefgdij-cidefIhj-cdefNijR-cdVfguij",
|
||||
&normalized_key2);
|
||||
assert_se(r == 0);
|
||||
assert_se(streq(normalized_key2, "cdefvhij-cdefghij-cdefkhij-cdufghij-cdefgdij-cidefihj-cdefnijr-cdvfguij"));
|
||||
ASSERT_STREQ(normalized_key2, "cdefvhij-cdefghij-cdefkhij-cdufghij-cdefgdij-cidefihj-cdefnijr-cdvfguij");
|
||||
|
||||
/* Case 3: Invalid password length */
|
||||
r = normalize_recovery_key("1234-5678-90AB-CDEF-1234-5678-90AB-CDEF", &normalized_key1);
|
||||
@ -122,7 +122,7 @@ TEST(normalize_recovery_key) {
|
||||
r = normalize_recovery_key("BFGHICEHHIUVLKJIHFHEDlntruvcdefjiTUVKLNIJVTUTKJIHDFBCBGHIJHHFDBC",
|
||||
&normalized_key3);
|
||||
assert(r == 0);
|
||||
assert_se(streq(normalized_key3, "bfghiceh-hiuvlkji-hfhedlnt-ruvcdefj-ituvklni-jvtutkji-hdfbcbgh-ijhhfdbc"));
|
||||
ASSERT_STREQ(normalized_key3, "bfghiceh-hiuvlkji-hfhedlnt-ruvcdefj-ituvklni-jvtutkji-hdfbcbgh-ijhhfdbc");
|
||||
|
||||
/* Case 6: Minimum password length */
|
||||
r = normalize_recovery_key("", &normalized_key1);
|
||||
|
||||
@ -16,7 +16,7 @@ TEST(replace_var) {
|
||||
|
||||
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>>>...@@@"));
|
||||
ASSERT_STREQ(r, "@@@foobar@xyz<<<HALLO>>>foobar@test@@testtest<<<TEST>>>...@@@");
|
||||
free(r);
|
||||
}
|
||||
|
||||
@ -25,7 +25,7 @@ TEST(strreplace) {
|
||||
|
||||
assert_se(r = strreplace("XYZFFFFXYZFFFFXYZ", "XYZ", "ABC"));
|
||||
puts(r);
|
||||
assert_se(streq(r, "ABCFFFFABCFFFFABC"));
|
||||
ASSERT_STREQ(r, "ABCFFFFABCFFFFABC");
|
||||
free(r);
|
||||
}
|
||||
|
||||
|
||||
@ -34,7 +34,7 @@ static void test_rlimit_parse_format_one(int resource, const char *string, rlim_
|
||||
assert_se(rl.rlim_max == hard);
|
||||
|
||||
assert_se(rlimit_format(&rl, &f) >= 0);
|
||||
assert_se(streq(formatted, f));
|
||||
ASSERT_STREQ(formatted, f);
|
||||
|
||||
assert_se(rlimit_parse(resource, formatted, &rl2) >= 0);
|
||||
assert_se(memcmp(&rl, &rl2, sizeof(struct rlimit)) == 0);
|
||||
@ -118,7 +118,7 @@ TEST(setrlimit) {
|
||||
new.rlim_max = old.rlim_max;
|
||||
assert_se(setrlimit(RLIMIT_NOFILE, &new) >= 0);
|
||||
|
||||
assert_se(streq_ptr(rlimit_to_string(RLIMIT_NOFILE), "NOFILE"));
|
||||
ASSERT_STREQ(rlimit_to_string(RLIMIT_NOFILE), "NOFILE");
|
||||
ASSERT_NULL(rlimit_to_string(-1));
|
||||
|
||||
assert_se(getrlimit(RLIMIT_NOFILE, &old) == 0);
|
||||
|
||||
@ -52,40 +52,40 @@ TEST(parse_syscall_and_errno) {
|
||||
int e;
|
||||
|
||||
assert_se(parse_syscall_and_errno("uname:EILSEQ", &n, &e) >= 0);
|
||||
assert_se(streq(n, "uname"));
|
||||
ASSERT_STREQ(n, "uname");
|
||||
assert_se(e == errno_from_name("EILSEQ") && e >= 0);
|
||||
n = mfree(n);
|
||||
|
||||
assert_se(parse_syscall_and_errno("uname:EINVAL", &n, &e) >= 0);
|
||||
assert_se(streq(n, "uname"));
|
||||
ASSERT_STREQ(n, "uname");
|
||||
assert_se(e == errno_from_name("EINVAL") && e >= 0);
|
||||
n = mfree(n);
|
||||
|
||||
assert_se(parse_syscall_and_errno("@sync:4095", &n, &e) >= 0);
|
||||
assert_se(streq(n, "@sync"));
|
||||
ASSERT_STREQ(n, "@sync");
|
||||
assert_se(e == 4095);
|
||||
n = mfree(n);
|
||||
|
||||
/* If errno is omitted, then e is set to -1 */
|
||||
assert_se(parse_syscall_and_errno("mount", &n, &e) >= 0);
|
||||
assert_se(streq(n, "mount"));
|
||||
ASSERT_STREQ(n, "mount");
|
||||
assert_se(e == -1);
|
||||
n = mfree(n);
|
||||
|
||||
/* parse_syscall_and_errno() does not check the syscall name is valid or not. */
|
||||
assert_se(parse_syscall_and_errno("hoge:255", &n, &e) >= 0);
|
||||
assert_se(streq(n, "hoge"));
|
||||
ASSERT_STREQ(n, "hoge");
|
||||
assert_se(e == 255);
|
||||
n = mfree(n);
|
||||
|
||||
/* 0 is also a valid errno. */
|
||||
assert_se(parse_syscall_and_errno("hoge:0", &n, &e) >= 0);
|
||||
assert_se(streq(n, "hoge"));
|
||||
ASSERT_STREQ(n, "hoge");
|
||||
assert_se(e == 0);
|
||||
n = mfree(n);
|
||||
|
||||
assert_se(parse_syscall_and_errno("hoge:kill", &n, &e) >= 0);
|
||||
assert_se(streq(n, "hoge"));
|
||||
ASSERT_STREQ(n, "hoge");
|
||||
assert_se(e == SECCOMP_ERROR_NUMBER_KILL);
|
||||
n = mfree(n);
|
||||
|
||||
@ -151,7 +151,7 @@ TEST(architecture_table) {
|
||||
assert_se(seccomp_arch_from_string(n, &c) >= 0);
|
||||
n2 = seccomp_arch_to_string(c);
|
||||
log_info("seccomp-arch: %s → 0x%"PRIx32" → %s", n, c, n2);
|
||||
assert_se(streq_ptr(n, n2));
|
||||
ASSERT_STREQ(n, n2);
|
||||
}
|
||||
}
|
||||
|
||||
@ -231,11 +231,11 @@ TEST(filter_sets) {
|
||||
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"));
|
||||
ASSERT_STREQ(syscall_filter_sets[0].name, "@default");
|
||||
|
||||
/* Ensure "@known" always remains at the end of the list */
|
||||
assert_se(SYSCALL_FILTER_SET_KNOWN == _SYSCALL_FILTER_SET_MAX - 1);
|
||||
assert_se(streq(syscall_filter_sets[SYSCALL_FILTER_SET_KNOWN].name, "@known"));
|
||||
ASSERT_STREQ(syscall_filter_sets[SYSCALL_FILTER_SET_KNOWN].name, "@known");
|
||||
|
||||
for (size_t i = 0; i < _SYSCALL_FILTER_SET_MAX; i++) {
|
||||
const char *p = NULL;
|
||||
@ -294,7 +294,7 @@ TEST(restrict_namespace) {
|
||||
s = mfree(s);
|
||||
|
||||
assert_se(namespace_flags_to_string(NAMESPACE_FLAGS_ALL, &s) == 0);
|
||||
assert_se(streq(s, "cgroup ipc net mnt pid user uts"));
|
||||
ASSERT_STREQ(s, "cgroup ipc net mnt pid user uts");
|
||||
assert_se(namespace_flags_from_string(s, &ul) == 0 && ul == NAMESPACE_FLAGS_ALL);
|
||||
s = mfree(s);
|
||||
|
||||
|
||||
@ -31,7 +31,7 @@ TEST(secure_bits_basic) {
|
||||
assert_se(secure_bits_is_valid(r));
|
||||
assert_se(secure_bits_to_string_alloc(r, &s) >= 0);
|
||||
printf("%s = 0x%x = %s\n", *bit, (unsigned)r, s);
|
||||
assert_se(streq(*bit, s));
|
||||
ASSERT_STREQ(*bit, s);
|
||||
}
|
||||
|
||||
/* Ditto, but with all bits at once */
|
||||
@ -42,7 +42,7 @@ TEST(secure_bits_basic) {
|
||||
assert_se(secure_bits_is_valid(r));
|
||||
assert_se(secure_bits_to_string_alloc(r, &str) >= 0);
|
||||
printf("%s = 0x%x = %s\n", joined, (unsigned)r, str);
|
||||
assert_se(streq(joined, str));
|
||||
ASSERT_STREQ(joined, str);
|
||||
|
||||
str = mfree(str);
|
||||
|
||||
@ -65,7 +65,7 @@ TEST(secure_bits_basic) {
|
||||
assert_se(secure_bits_to_string_alloc_with_check(
|
||||
(1 << SECURE_KEEP_CAPS) | (1 << SECURE_KEEP_CAPS_LOCKED),
|
||||
&str) >= 0);
|
||||
assert_se(streq(str, "keep-caps keep-caps-locked"));
|
||||
ASSERT_STREQ(str, "keep-caps keep-caps-locked");
|
||||
}
|
||||
|
||||
TEST(secure_bits_mix) {
|
||||
@ -90,7 +90,7 @@ TEST(secure_bits_mix) {
|
||||
assert_se(secure_bits_is_valid(r));
|
||||
assert_se(secure_bits_to_string_alloc(r, &str) >= 0);
|
||||
printf("%s = 0x%x = %s\n", s->input, (unsigned)r, str);
|
||||
assert_se(streq(s->expected, str));
|
||||
ASSERT_STREQ(s->expected, str);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -32,13 +32,13 @@ TEST(serialize_item) {
|
||||
|
||||
_cleanup_free_ char *line1 = NULL, *line2 = NULL, *line3 = NULL, *line4 = NULL;
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0);
|
||||
assert_se(streq(line1, "a=bbb"));
|
||||
ASSERT_STREQ(line1, "a=bbb");
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0);
|
||||
assert_se(streq(line2, "a=bbb"));
|
||||
ASSERT_STREQ(line2, "a=bbb");
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line3) > 0);
|
||||
assert_se(streq(line3, "c=yes"));
|
||||
ASSERT_STREQ(line3, "c=yes");
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line4) == 0);
|
||||
assert_se(streq(line4, ""));
|
||||
ASSERT_STREQ(line4, "");
|
||||
}
|
||||
|
||||
TEST(serialize_item_escaped) {
|
||||
@ -59,11 +59,11 @@ TEST(serialize_item_escaped) {
|
||||
|
||||
_cleanup_free_ char *line1 = NULL, *line2 = NULL, *line3 = NULL;
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0);
|
||||
assert_se(streq(line1, "a=bbb"));
|
||||
ASSERT_STREQ(line1, "a=bbb");
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0);
|
||||
assert_se(streq(line2, "a=bbb"));
|
||||
ASSERT_STREQ(line2, "a=bbb");
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line3) == 0);
|
||||
assert_se(streq(line3, ""));
|
||||
ASSERT_STREQ(line3, "");
|
||||
}
|
||||
|
||||
TEST(serialize_usec) {
|
||||
@ -83,7 +83,7 @@ TEST(serialize_usec) {
|
||||
usec_t x;
|
||||
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0);
|
||||
assert_se(streq(line1, "usec2=0"));
|
||||
ASSERT_STREQ(line1, "usec2=0");
|
||||
assert_se(deserialize_usec(line1 + 6, &x) == 0);
|
||||
assert_se(x == 0);
|
||||
|
||||
@ -204,7 +204,7 @@ TEST(serialize_item_hexmem) {
|
||||
|
||||
_cleanup_free_ char *line = NULL;
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line) > 0);
|
||||
assert_se(streq(line, "a=ffffff"));
|
||||
ASSERT_STREQ(line, "a=ffffff");
|
||||
|
||||
}
|
||||
|
||||
@ -222,7 +222,7 @@ TEST(serialize_item_base64mem) {
|
||||
|
||||
_cleanup_free_ char *line = NULL;
|
||||
assert_se(read_line(f, LONG_LINE_MAX, &line) > 0);
|
||||
assert_se(streq(line, "a=////"));
|
||||
ASSERT_STREQ(line, "a=////");
|
||||
}
|
||||
|
||||
TEST(serialize_string_set) {
|
||||
|
||||
@ -231,28 +231,28 @@ TEST(set_strjoin) {
|
||||
/* Single entry */
|
||||
assert_se(set_put_strdup(&m, "aaa") == 1);
|
||||
assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
|
||||
assert_se(streq(joined, "aaa"));
|
||||
ASSERT_STREQ(joined, "aaa");
|
||||
joined = mfree(joined);
|
||||
assert_se(set_strjoin(m, "", false, &joined) >= 0);
|
||||
assert_se(streq(joined, "aaa"));
|
||||
ASSERT_STREQ(joined, "aaa");
|
||||
joined = mfree(joined);
|
||||
assert_se(set_strjoin(m, " ", false, &joined) >= 0);
|
||||
assert_se(streq(joined, "aaa"));
|
||||
ASSERT_STREQ(joined, "aaa");
|
||||
joined = mfree(joined);
|
||||
assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
|
||||
assert_se(streq(joined, "aaa"));
|
||||
ASSERT_STREQ(joined, "aaa");
|
||||
joined = mfree(joined);
|
||||
assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
|
||||
assert_se(streq(joined, "aaa"));
|
||||
ASSERT_STREQ(joined, "aaa");
|
||||
joined = mfree(joined);
|
||||
assert_se(set_strjoin(m, "", true, &joined) >= 0);
|
||||
assert_se(streq(joined, "aaa"));
|
||||
ASSERT_STREQ(joined, "aaa");
|
||||
joined = mfree(joined);
|
||||
assert_se(set_strjoin(m, " ", true, &joined) >= 0);
|
||||
assert_se(streq(joined, " aaa "));
|
||||
ASSERT_STREQ(joined, " aaa ");
|
||||
joined = mfree(joined);
|
||||
assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
|
||||
assert_se(streq(joined, "xxxaaaxxx"));
|
||||
ASSERT_STREQ(joined, "xxxaaaxxx");
|
||||
|
||||
/* Two entries */
|
||||
assert_se(set_put_strdup(&m, "bbb") == 1);
|
||||
|
||||
@ -31,7 +31,7 @@ static void test_sha256_one(const char *key, const char *expect) {
|
||||
sha256_finish_ctx(&ctx, result + j);
|
||||
|
||||
hex_result = hexmem(result + j, SHA256_DIGEST_SIZE);
|
||||
assert_se(streq_ptr(hex_result, expect));
|
||||
ASSERT_STREQ(hex_result, expect);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -29,7 +29,7 @@ static void test_socket_address_parse_one(const char *in, int ret, int family, c
|
||||
assert_se(r == ret);
|
||||
if (r >= 0) {
|
||||
assert_se(a.sockaddr.sa.sa_family == family);
|
||||
assert_se(streq(out, expected ?: in));
|
||||
ASSERT_STREQ(out, expected ?: in);
|
||||
}
|
||||
}
|
||||
|
||||
@ -199,7 +199,7 @@ TEST(socket_address_get_path) {
|
||||
assert_se(!socket_address_get_path(&a));
|
||||
|
||||
assert_se(socket_address_parse(&a, "/foo/bar") >= 0);
|
||||
assert_se(streq(socket_address_get_path(&a), "/foo/bar"));
|
||||
ASSERT_STREQ(socket_address_get_path(&a), "/foo/bar");
|
||||
|
||||
assert_se(socket_address_parse(&a, "vsock:2:1234") >= 0);
|
||||
assert_se(!socket_address_get_path(&a));
|
||||
@ -235,7 +235,7 @@ static void test_in_addr_ifindex_to_string_one(int f, const char *a, int ifindex
|
||||
assert_se(in_addr_from_string(f, a, &ua) >= 0);
|
||||
assert_se(in_addr_ifindex_to_string(f, &ua, ifindex, &r) >= 0);
|
||||
printf("test_in_addr_ifindex_to_string_one: %s == %s\n", b, r);
|
||||
assert_se(streq(b, r));
|
||||
ASSERT_STREQ(b, r);
|
||||
|
||||
assert_se(in_addr_ifindex_from_string_auto(b, &ff, &uuaa, &ifindex2) >= 0);
|
||||
assert_se(ff == f);
|
||||
@ -282,7 +282,7 @@ static void test_in_addr_ifindex_name_from_string_auto_one(const char *a, const
|
||||
_cleanup_free_ char *server_name = NULL;
|
||||
|
||||
assert_se(in_addr_ifindex_name_from_string_auto(a, &family, &ua, &ifindex, &server_name) >= 0);
|
||||
assert_se(streq_ptr(server_name, expected));
|
||||
ASSERT_STREQ(server_name, expected);
|
||||
}
|
||||
|
||||
TEST(in_addr_ifindex_name_from_string_auto) {
|
||||
@ -307,9 +307,9 @@ static void test_in_addr_port_ifindex_name_from_string_auto_one(const char *str,
|
||||
assert_se(family == f);
|
||||
assert_se(port == p);
|
||||
assert_se(ifindex == i);
|
||||
assert_se(streq_ptr(server_name, name));
|
||||
ASSERT_STREQ(server_name, name);
|
||||
assert_se(in_addr_port_ifindex_name_to_string(f, &a, p, i, name, &x) >= 0);
|
||||
assert_se(streq(str_repr ?: str, x));
|
||||
ASSERT_STREQ(str_repr ?: str, x);
|
||||
}
|
||||
|
||||
if (port > 0)
|
||||
@ -319,9 +319,9 @@ static void test_in_addr_port_ifindex_name_from_string_auto_one(const char *str,
|
||||
assert_se(in_addr_port_ifindex_name_from_string_auto(str, &f, &a, NULL, &i, &name) == 0);
|
||||
assert_se(family == f);
|
||||
assert_se(ifindex == i);
|
||||
assert_se(streq_ptr(server_name, name));
|
||||
ASSERT_STREQ(server_name, name);
|
||||
assert_se(in_addr_port_ifindex_name_to_string(f, &a, 0, i, name, &x) >= 0);
|
||||
assert_se(streq(str_repr ?: str, x));
|
||||
ASSERT_STREQ(str_repr ?: str, x);
|
||||
}
|
||||
|
||||
if (ifindex > 0)
|
||||
@ -331,9 +331,9 @@ static void test_in_addr_port_ifindex_name_from_string_auto_one(const char *str,
|
||||
assert_se(in_addr_port_ifindex_name_from_string_auto(str, &f, &a, &p, NULL, &name) == 0);
|
||||
assert_se(family == f);
|
||||
assert_se(port == p);
|
||||
assert_se(streq_ptr(server_name, name));
|
||||
ASSERT_STREQ(server_name, name);
|
||||
assert_se(in_addr_port_ifindex_name_to_string(f, &a, p, 0, name, &x) >= 0);
|
||||
assert_se(streq(str_repr ?: str, x));
|
||||
ASSERT_STREQ(str_repr ?: str, x);
|
||||
}
|
||||
|
||||
if (server_name)
|
||||
@ -345,7 +345,7 @@ static void test_in_addr_port_ifindex_name_from_string_auto_one(const char *str,
|
||||
assert_se(port == p);
|
||||
assert_se(ifindex == i);
|
||||
assert_se(in_addr_port_ifindex_name_to_string(f, &a, p, i, NULL, &x) >= 0);
|
||||
assert_se(streq(str_repr ?: str, x));
|
||||
ASSERT_STREQ(str_repr ?: str, x);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -69,7 +69,7 @@ static void test_socket_print_unix_one(const char *in, size_t len_in, const char
|
||||
assert_se(socket_address_print(&a, &out) >= 0);
|
||||
assert_se(c = cescape(in));
|
||||
log_info("\"%s\" → \"%s\" (expect \"%s\")", in, out, expected);
|
||||
assert_se(streq(out, expected));
|
||||
ASSERT_STREQ(out, expected);
|
||||
}
|
||||
|
||||
TEST(socket_print_unix) {
|
||||
@ -256,7 +256,7 @@ TEST(passfd_read) {
|
||||
r = read(fd, buf, sizeof(buf)-1);
|
||||
assert_se(r >= 0);
|
||||
buf[r] = 0;
|
||||
assert_se(streq(buf, file_contents));
|
||||
ASSERT_STREQ(buf, file_contents);
|
||||
}
|
||||
|
||||
TEST(passfd_contents_read) {
|
||||
@ -298,13 +298,13 @@ TEST(passfd_contents_read) {
|
||||
k = receive_one_fd_iov(pair[0], &iov, 1, MSG_DONTWAIT, &fd);
|
||||
assert_se(k > 0);
|
||||
buf[k] = 0;
|
||||
assert_se(streq(buf, wire_contents));
|
||||
ASSERT_STREQ(buf, wire_contents);
|
||||
|
||||
assert_se(fd >= 0);
|
||||
r = read(fd, buf, sizeof(buf)-1);
|
||||
assert_se(r >= 0);
|
||||
buf[r] = 0;
|
||||
assert_se(streq(buf, file_contents));
|
||||
ASSERT_STREQ(buf, file_contents);
|
||||
}
|
||||
|
||||
TEST(pass_many_fds_contents_read) {
|
||||
@ -358,7 +358,7 @@ TEST(pass_many_fds_contents_read) {
|
||||
k = receive_many_fds_iov(pair[0], &iov, 1, &fds, &n_fds, MSG_DONTWAIT);
|
||||
assert_se(k > 0);
|
||||
buf[k] = 0;
|
||||
assert_se(streq(buf, wire_contents));
|
||||
ASSERT_STREQ(buf, wire_contents);
|
||||
|
||||
assert_se(n_fds == 3);
|
||||
|
||||
@ -367,7 +367,7 @@ TEST(pass_many_fds_contents_read) {
|
||||
r = read(fds[i], buf, sizeof(buf)-1);
|
||||
assert_se(r >= 0);
|
||||
buf[r] = 0;
|
||||
assert_se(streq(buf, file_contents[i]));
|
||||
ASSERT_STREQ(buf, file_contents[i]);
|
||||
safe_close(fds[i]);
|
||||
}
|
||||
}
|
||||
@ -403,7 +403,7 @@ TEST(receive_nopassfd) {
|
||||
k = receive_one_fd_iov(pair[0], &iov, 1, MSG_DONTWAIT, &fd);
|
||||
assert_se(k > 0);
|
||||
buf[k] = 0;
|
||||
assert_se(streq(buf, wire_contents));
|
||||
ASSERT_STREQ(buf, wire_contents);
|
||||
|
||||
/* no fd passed here, confirm it was reset */
|
||||
assert_se(fd == -EBADF);
|
||||
|
||||
@ -16,7 +16,7 @@ static void test_specifier_escape_one(const char *a, const char *b) {
|
||||
_cleanup_free_ char *x = NULL;
|
||||
|
||||
x = specifier_escape(a);
|
||||
assert_se(streq_ptr(x, b));
|
||||
ASSERT_STREQ(x, b);
|
||||
}
|
||||
|
||||
TEST(specifier_escape) {
|
||||
@ -73,7 +73,7 @@ TEST(specifier_printf) {
|
||||
assert_se(w);
|
||||
|
||||
puts(w);
|
||||
assert_se(streq(w, "xxx a=AAAA b=BBBB e= yyy"));
|
||||
ASSERT_STREQ(w, "xxx a=AAAA b=BBBB e= yyy");
|
||||
|
||||
free(w);
|
||||
r = specifier_printf("boot=%b, host=%H, pretty=%q, version=%v, arch=%a, empty=%e", SIZE_MAX, table, NULL, NULL, &w);
|
||||
@ -107,7 +107,7 @@ TEST(specifier_real_path) {
|
||||
|
||||
/* /dev/initctl should normally be a symlink to /run/initctl */
|
||||
if (inode_same("/dev/initctl", "/run/initctl", 0) > 0)
|
||||
assert_se(streq(w, "p=/dev/initctl y=/run/initctl Y=/run w=/dev/tty W=/dev"));
|
||||
ASSERT_STREQ(w, "p=/dev/initctl y=/run/initctl Y=/run w=/dev/tty W=/dev");
|
||||
}
|
||||
|
||||
TEST(specifier_real_path_missing_file) {
|
||||
@ -178,11 +178,11 @@ TEST(specifiers_missing_data_ok) {
|
||||
|
||||
assert_se(setenv("SYSTEMD_OS_RELEASE", "/dev/null", 1) == 0);
|
||||
assert_se(specifier_printf("%A-%B-%M-%o-%w-%W", SIZE_MAX, specifier_table, NULL, NULL, &resolved) >= 0);
|
||||
assert_se(streq(resolved, "-----"));
|
||||
ASSERT_STREQ(resolved, "-----");
|
||||
|
||||
assert_se(setenv("SYSTEMD_OS_RELEASE", "/nosuchfileordirectory", 1) == 0);
|
||||
assert_se(specifier_printf("%A-%B-%M-%o-%w-%W", SIZE_MAX, specifier_table, NULL, NULL, &resolved) == -EUNATCH);
|
||||
assert_se(streq(resolved, "-----"));
|
||||
ASSERT_STREQ(resolved, "-----");
|
||||
|
||||
assert_se(unsetenv("SYSTEMD_OS_RELEASE") == 0);
|
||||
}
|
||||
|
||||
@ -32,11 +32,11 @@ TEST(strbuf) {
|
||||
l = strv_parse_nulstr(sb->buf, sb->len);
|
||||
assert_se(l);
|
||||
|
||||
assert_se(streq(l[0], "")); /* root */
|
||||
assert_se(streq(l[1], "waldo"));
|
||||
assert_se(streq(l[2], "foo"));
|
||||
assert_se(streq(l[3], "bar"));
|
||||
assert_se(streq(l[4], "waldorf"));
|
||||
ASSERT_STREQ(l[0], ""); /* root */
|
||||
ASSERT_STREQ(l[1], "waldo");
|
||||
ASSERT_STREQ(l[2], "foo");
|
||||
ASSERT_STREQ(l[3], "bar");
|
||||
ASSERT_STREQ(l[4], "waldorf");
|
||||
ASSERT_NULL(l[5]);
|
||||
|
||||
assert_se(sb->nodes_count == 5); /* root + 4 non-duplicates */
|
||||
@ -57,14 +57,14 @@ TEST(strbuf) {
|
||||
assert_se(g == 15);
|
||||
assert_se(h == 0);
|
||||
|
||||
assert_se(streq(sb->buf + a, "waldo"));
|
||||
assert_se(streq(sb->buf + b, "foo"));
|
||||
assert_se(streq(sb->buf + c, "bar"));
|
||||
assert_se(streq(sb->buf + d, "waldo"));
|
||||
assert_se(streq(sb->buf + e, "aldo"));
|
||||
assert_se(streq(sb->buf + f, "do"));
|
||||
assert_se(streq(sb->buf + g, "waldorf"));
|
||||
assert_se(streq(sb->buf + h, ""));
|
||||
ASSERT_STREQ(sb->buf + a, "waldo");
|
||||
ASSERT_STREQ(sb->buf + b, "foo");
|
||||
ASSERT_STREQ(sb->buf + c, "bar");
|
||||
ASSERT_STREQ(sb->buf + d, "waldo");
|
||||
ASSERT_STREQ(sb->buf + e, "aldo");
|
||||
ASSERT_STREQ(sb->buf + f, "do");
|
||||
ASSERT_STREQ(sb->buf + g, "waldorf");
|
||||
ASSERT_STREQ(sb->buf + h, "");
|
||||
|
||||
strbuf_complete(sb);
|
||||
ASSERT_NULL(sb->root);
|
||||
|
||||
@ -13,13 +13,13 @@
|
||||
TEST(string_erase) {
|
||||
char *x;
|
||||
x = strdupa_safe("");
|
||||
assert_se(streq(string_erase(x), ""));
|
||||
ASSERT_STREQ(string_erase(x), "");
|
||||
|
||||
x = strdupa_safe("1");
|
||||
assert_se(streq(string_erase(x), ""));
|
||||
ASSERT_STREQ(string_erase(x), "");
|
||||
|
||||
x = strdupa_safe("123456789");
|
||||
assert_se(streq(string_erase(x), ""));
|
||||
ASSERT_STREQ(string_erase(x), "");
|
||||
|
||||
assert_se(x[1] == '\0');
|
||||
assert_se(x[2] == '\0');
|
||||
@ -37,7 +37,7 @@ static void test_free_and_strndup_one(char **t, const char *src, size_t l, const
|
||||
__func__, strnull(*t), strnull(src), l, strnull(expected), yes_no(change));
|
||||
|
||||
int r = free_and_strndup(t, src, l);
|
||||
assert_se(streq_ptr(*t, expected));
|
||||
ASSERT_STREQ(*t, expected);
|
||||
assert_se(r == change); /* check that change occurs only when necessary */
|
||||
}
|
||||
|
||||
@ -96,12 +96,12 @@ TEST(strdup_to_full) {
|
||||
|
||||
assert_se(strdup_to_full(NULL, "") == 1);
|
||||
assert_se(strdup_to_full(&dst, "") == 1);
|
||||
assert_se(streq_ptr(dst, ""));
|
||||
ASSERT_STREQ(dst, "");
|
||||
dst = mfree(dst);
|
||||
|
||||
assert_se(strdup_to_full(NULL, "x") == 1);
|
||||
assert_se(strdup_to_full(&dst, "x") == 1);
|
||||
assert_se(streq_ptr(dst, "x"));
|
||||
ASSERT_STREQ(dst, "x");
|
||||
}
|
||||
|
||||
TEST(strdup_to) {
|
||||
@ -110,11 +110,11 @@ TEST(strdup_to) {
|
||||
assert_se(strdup_to(&dst, NULL) == 0);
|
||||
|
||||
assert_se(strdup_to(&dst, "") == 0);
|
||||
assert_se(streq_ptr(dst, ""));
|
||||
ASSERT_STREQ(dst, "");
|
||||
dst = mfree(dst);
|
||||
|
||||
assert_se(strdup_to(&dst, "x") == 0);
|
||||
assert_se(streq_ptr(dst, "x"));
|
||||
ASSERT_STREQ(dst, "x");
|
||||
}
|
||||
|
||||
TEST(ascii_strcasecmp_n) {
|
||||
@ -163,82 +163,82 @@ TEST(ascii_strcasecmp_nn) {
|
||||
TEST(cellescape) {
|
||||
char buf[40];
|
||||
|
||||
assert_se(streq(cellescape(buf, 1, ""), ""));
|
||||
assert_se(streq(cellescape(buf, 1, "1"), ""));
|
||||
assert_se(streq(cellescape(buf, 1, "12"), ""));
|
||||
ASSERT_STREQ(cellescape(buf, 1, ""), "");
|
||||
ASSERT_STREQ(cellescape(buf, 1, "1"), "");
|
||||
ASSERT_STREQ(cellescape(buf, 1, "12"), "");
|
||||
|
||||
assert_se(streq(cellescape(buf, 2, ""), ""));
|
||||
assert_se(streq(cellescape(buf, 2, "1"), "1"));
|
||||
assert_se(streq(cellescape(buf, 2, "12"), "."));
|
||||
assert_se(streq(cellescape(buf, 2, "123"), "."));
|
||||
ASSERT_STREQ(cellescape(buf, 2, ""), "");
|
||||
ASSERT_STREQ(cellescape(buf, 2, "1"), "1");
|
||||
ASSERT_STREQ(cellescape(buf, 2, "12"), ".");
|
||||
ASSERT_STREQ(cellescape(buf, 2, "123"), ".");
|
||||
|
||||
assert_se(streq(cellescape(buf, 3, ""), ""));
|
||||
assert_se(streq(cellescape(buf, 3, "1"), "1"));
|
||||
assert_se(streq(cellescape(buf, 3, "12"), "12"));
|
||||
assert_se(streq(cellescape(buf, 3, "123"), ".."));
|
||||
assert_se(streq(cellescape(buf, 3, "1234"), ".."));
|
||||
ASSERT_STREQ(cellescape(buf, 3, ""), "");
|
||||
ASSERT_STREQ(cellescape(buf, 3, "1"), "1");
|
||||
ASSERT_STREQ(cellescape(buf, 3, "12"), "12");
|
||||
ASSERT_STREQ(cellescape(buf, 3, "123"), "..");
|
||||
ASSERT_STREQ(cellescape(buf, 3, "1234"), "..");
|
||||
|
||||
assert_se(streq(cellescape(buf, 4, ""), ""));
|
||||
assert_se(streq(cellescape(buf, 4, "1"), "1"));
|
||||
assert_se(streq(cellescape(buf, 4, "12"), "12"));
|
||||
assert_se(streq(cellescape(buf, 4, "123"), "123"));
|
||||
assert_se(streq(cellescape(buf, 4, "1234"), is_locale_utf8() ? "…" : "..."));
|
||||
assert_se(streq(cellescape(buf, 4, "12345"), is_locale_utf8() ? "…" : "..."));
|
||||
ASSERT_STREQ(cellescape(buf, 4, ""), "");
|
||||
ASSERT_STREQ(cellescape(buf, 4, "1"), "1");
|
||||
ASSERT_STREQ(cellescape(buf, 4, "12"), "12");
|
||||
ASSERT_STREQ(cellescape(buf, 4, "123"), "123");
|
||||
ASSERT_STREQ(cellescape(buf, 4, "1234"), is_locale_utf8() ? "…" : "...");
|
||||
ASSERT_STREQ(cellescape(buf, 4, "12345"), is_locale_utf8() ? "…" : "...");
|
||||
|
||||
assert_se(streq(cellescape(buf, 5, ""), ""));
|
||||
assert_se(streq(cellescape(buf, 5, "1"), "1"));
|
||||
assert_se(streq(cellescape(buf, 5, "12"), "12"));
|
||||
assert_se(streq(cellescape(buf, 5, "123"), "123"));
|
||||
assert_se(streq(cellescape(buf, 5, "1234"), "1234"));
|
||||
assert_se(streq(cellescape(buf, 5, "12345"), is_locale_utf8() ? "1…" : "1..."));
|
||||
assert_se(streq(cellescape(buf, 5, "123456"), is_locale_utf8() ? "1…" : "1..."));
|
||||
ASSERT_STREQ(cellescape(buf, 5, ""), "");
|
||||
ASSERT_STREQ(cellescape(buf, 5, "1"), "1");
|
||||
ASSERT_STREQ(cellescape(buf, 5, "12"), "12");
|
||||
ASSERT_STREQ(cellescape(buf, 5, "123"), "123");
|
||||
ASSERT_STREQ(cellescape(buf, 5, "1234"), "1234");
|
||||
ASSERT_STREQ(cellescape(buf, 5, "12345"), is_locale_utf8() ? "1…" : "1...");
|
||||
ASSERT_STREQ(cellescape(buf, 5, "123456"), is_locale_utf8() ? "1…" : "1...");
|
||||
|
||||
assert_se(streq(cellescape(buf, 1, "\020"), ""));
|
||||
assert_se(streq(cellescape(buf, 2, "\020"), "."));
|
||||
assert_se(streq(cellescape(buf, 3, "\020"), ".."));
|
||||
assert_se(streq(cellescape(buf, 4, "\020"), is_locale_utf8() ? "…" : "..."));
|
||||
assert_se(streq(cellescape(buf, 5, "\020"), "\\020"));
|
||||
ASSERT_STREQ(cellescape(buf, 1, "\020"), "");
|
||||
ASSERT_STREQ(cellescape(buf, 2, "\020"), ".");
|
||||
ASSERT_STREQ(cellescape(buf, 3, "\020"), "..");
|
||||
ASSERT_STREQ(cellescape(buf, 4, "\020"), is_locale_utf8() ? "…" : "...");
|
||||
ASSERT_STREQ(cellescape(buf, 5, "\020"), "\\020");
|
||||
|
||||
assert_se(streq(cellescape(buf, 5, "1234\020"), is_locale_utf8() ? "1…" : "1..."));
|
||||
assert_se(streq(cellescape(buf, 6, "1234\020"), is_locale_utf8() ? "12…" : "12..."));
|
||||
assert_se(streq(cellescape(buf, 7, "1234\020"), is_locale_utf8() ? "123…" : "123..."));
|
||||
assert_se(streq(cellescape(buf, 8, "1234\020"), is_locale_utf8() ? "1234…" : "1234..."));
|
||||
assert_se(streq(cellescape(buf, 9, "1234\020"), "1234\\020"));
|
||||
ASSERT_STREQ(cellescape(buf, 5, "1234\020"), is_locale_utf8() ? "1…" : "1...");
|
||||
ASSERT_STREQ(cellescape(buf, 6, "1234\020"), is_locale_utf8() ? "12…" : "12...");
|
||||
ASSERT_STREQ(cellescape(buf, 7, "1234\020"), is_locale_utf8() ? "123…" : "123...");
|
||||
ASSERT_STREQ(cellescape(buf, 8, "1234\020"), is_locale_utf8() ? "1234…" : "1234...");
|
||||
ASSERT_STREQ(cellescape(buf, 9, "1234\020"), "1234\\020");
|
||||
|
||||
assert_se(streq(cellescape(buf, 1, "\t\n"), ""));
|
||||
assert_se(streq(cellescape(buf, 2, "\t\n"), "."));
|
||||
assert_se(streq(cellescape(buf, 3, "\t\n"), ".."));
|
||||
assert_se(streq(cellescape(buf, 4, "\t\n"), is_locale_utf8() ? "…" : "..."));
|
||||
assert_se(streq(cellescape(buf, 5, "\t\n"), "\\t\\n"));
|
||||
ASSERT_STREQ(cellescape(buf, 1, "\t\n"), "");
|
||||
ASSERT_STREQ(cellescape(buf, 2, "\t\n"), ".");
|
||||
ASSERT_STREQ(cellescape(buf, 3, "\t\n"), "..");
|
||||
ASSERT_STREQ(cellescape(buf, 4, "\t\n"), is_locale_utf8() ? "…" : "...");
|
||||
ASSERT_STREQ(cellescape(buf, 5, "\t\n"), "\\t\\n");
|
||||
|
||||
assert_se(streq(cellescape(buf, 5, "1234\t\n"), is_locale_utf8() ? "1…" : "1..."));
|
||||
assert_se(streq(cellescape(buf, 6, "1234\t\n"), is_locale_utf8() ? "12…" : "12..."));
|
||||
assert_se(streq(cellescape(buf, 7, "1234\t\n"), is_locale_utf8() ? "123…" : "123..."));
|
||||
assert_se(streq(cellescape(buf, 8, "1234\t\n"), is_locale_utf8() ? "1234…" : "1234..."));
|
||||
assert_se(streq(cellescape(buf, 9, "1234\t\n"), "1234\\t\\n"));
|
||||
ASSERT_STREQ(cellescape(buf, 5, "1234\t\n"), is_locale_utf8() ? "1…" : "1...");
|
||||
ASSERT_STREQ(cellescape(buf, 6, "1234\t\n"), is_locale_utf8() ? "12…" : "12...");
|
||||
ASSERT_STREQ(cellescape(buf, 7, "1234\t\n"), is_locale_utf8() ? "123…" : "123...");
|
||||
ASSERT_STREQ(cellescape(buf, 8, "1234\t\n"), is_locale_utf8() ? "1234…" : "1234...");
|
||||
ASSERT_STREQ(cellescape(buf, 9, "1234\t\n"), "1234\\t\\n");
|
||||
|
||||
assert_se(streq(cellescape(buf, 4, "x\t\020\n"), is_locale_utf8() ? "…" : "..."));
|
||||
assert_se(streq(cellescape(buf, 5, "x\t\020\n"), is_locale_utf8() ? "x…" : "x..."));
|
||||
assert_se(streq(cellescape(buf, 6, "x\t\020\n"), is_locale_utf8() ? "x…" : "x..."));
|
||||
assert_se(streq(cellescape(buf, 7, "x\t\020\n"), is_locale_utf8() ? "x\\t…" : "x\\t..."));
|
||||
assert_se(streq(cellescape(buf, 8, "x\t\020\n"), is_locale_utf8() ? "x\\t…" : "x\\t..."));
|
||||
assert_se(streq(cellescape(buf, 9, "x\t\020\n"), is_locale_utf8() ? "x\\t…" : "x\\t..."));
|
||||
assert_se(streq(cellescape(buf, 10, "x\t\020\n"), "x\\t\\020\\n"));
|
||||
ASSERT_STREQ(cellescape(buf, 4, "x\t\020\n"), is_locale_utf8() ? "…" : "...");
|
||||
ASSERT_STREQ(cellescape(buf, 5, "x\t\020\n"), is_locale_utf8() ? "x…" : "x...");
|
||||
ASSERT_STREQ(cellescape(buf, 6, "x\t\020\n"), is_locale_utf8() ? "x…" : "x...");
|
||||
ASSERT_STREQ(cellescape(buf, 7, "x\t\020\n"), is_locale_utf8() ? "x\\t…" : "x\\t...");
|
||||
ASSERT_STREQ(cellescape(buf, 8, "x\t\020\n"), is_locale_utf8() ? "x\\t…" : "x\\t...");
|
||||
ASSERT_STREQ(cellescape(buf, 9, "x\t\020\n"), is_locale_utf8() ? "x\\t…" : "x\\t...");
|
||||
ASSERT_STREQ(cellescape(buf, 10, "x\t\020\n"), "x\\t\\020\\n");
|
||||
|
||||
assert_se(streq(cellescape(buf, 6, "1\011"), "1\\t"));
|
||||
assert_se(streq(cellescape(buf, 6, "1\020"), "1\\020"));
|
||||
assert_se(streq(cellescape(buf, 6, "1\020x"), is_locale_utf8() ? "1…" : "1..."));
|
||||
ASSERT_STREQ(cellescape(buf, 6, "1\011"), "1\\t");
|
||||
ASSERT_STREQ(cellescape(buf, 6, "1\020"), "1\\020");
|
||||
ASSERT_STREQ(cellescape(buf, 6, "1\020x"), is_locale_utf8() ? "1…" : "1...");
|
||||
|
||||
assert_se(streq(cellescape(buf, 40, "1\020"), "1\\020"));
|
||||
assert_se(streq(cellescape(buf, 40, "1\020x"), "1\\020x"));
|
||||
ASSERT_STREQ(cellescape(buf, 40, "1\020"), "1\\020");
|
||||
ASSERT_STREQ(cellescape(buf, 40, "1\020x"), "1\\020x");
|
||||
|
||||
assert_se(streq(cellescape(buf, 40, "\a\b\f\n\r\t\v\\\"'"), "\\a\\b\\f\\n\\r\\t\\v\\\\\\\"\\'"));
|
||||
assert_se(streq(cellescape(buf, 6, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a…" : "\\a..."));
|
||||
assert_se(streq(cellescape(buf, 7, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a…" : "\\a..."));
|
||||
assert_se(streq(cellescape(buf, 8, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a\\b…" : "\\a\\b..."));
|
||||
ASSERT_STREQ(cellescape(buf, 40, "\a\b\f\n\r\t\v\\\"'"), "\\a\\b\\f\\n\\r\\t\\v\\\\\\\"\\'");
|
||||
ASSERT_STREQ(cellescape(buf, 6, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a…" : "\\a...");
|
||||
ASSERT_STREQ(cellescape(buf, 7, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a…" : "\\a...");
|
||||
ASSERT_STREQ(cellescape(buf, 8, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a\\b…" : "\\a\\b...");
|
||||
|
||||
assert_se(streq(cellescape(buf, sizeof buf, "1\020"), "1\\020"));
|
||||
assert_se(streq(cellescape(buf, sizeof buf, "1\020x"), "1\\020x"));
|
||||
ASSERT_STREQ(cellescape(buf, sizeof buf, "1\020"), "1\\020");
|
||||
ASSERT_STREQ(cellescape(buf, sizeof buf, "1\020x"), "1\\020x");
|
||||
}
|
||||
|
||||
TEST(streq_ptr) {
|
||||
@ -250,41 +250,41 @@ TEST(strstrip) {
|
||||
char *ret, input[] = " hello, waldo. ";
|
||||
|
||||
ret = strstrip(input);
|
||||
assert_se(streq(ret, "hello, waldo."));
|
||||
ASSERT_STREQ(ret, "hello, waldo.");
|
||||
}
|
||||
|
||||
TEST(strextend) {
|
||||
_cleanup_free_ char *str = NULL;
|
||||
|
||||
assert_se(strextend(&str, NULL));
|
||||
assert_se(streq_ptr(str, ""));
|
||||
ASSERT_STREQ(str, "");
|
||||
assert_se(strextend(&str, "", "0", "", "", "123"));
|
||||
assert_se(streq_ptr(str, "0123"));
|
||||
ASSERT_STREQ(str, "0123");
|
||||
assert_se(strextend(&str, "456", "78", "9"));
|
||||
assert_se(streq_ptr(str, "0123456789"));
|
||||
ASSERT_STREQ(str, "0123456789");
|
||||
}
|
||||
|
||||
TEST(strextend_with_separator) {
|
||||
_cleanup_free_ char *str = NULL;
|
||||
|
||||
assert_se(strextend_with_separator(&str, NULL, NULL));
|
||||
assert_se(streq_ptr(str, ""));
|
||||
ASSERT_STREQ(str, "");
|
||||
str = mfree(str);
|
||||
|
||||
assert_se(strextend_with_separator(&str, "...", NULL));
|
||||
assert_se(streq_ptr(str, ""));
|
||||
ASSERT_STREQ(str, "");
|
||||
assert_se(strextend_with_separator(&str, "...", NULL));
|
||||
assert_se(streq_ptr(str, ""));
|
||||
ASSERT_STREQ(str, "");
|
||||
str = mfree(str);
|
||||
|
||||
assert_se(strextend_with_separator(&str, "xyz", "a", "bb", "ccc"));
|
||||
assert_se(streq_ptr(str, "axyzbbxyzccc"));
|
||||
ASSERT_STREQ(str, "axyzbbxyzccc");
|
||||
str = mfree(str);
|
||||
|
||||
assert_se(strextend_with_separator(&str, ",", "start", "", "1", "234"));
|
||||
assert_se(streq_ptr(str, "start,,1,234"));
|
||||
ASSERT_STREQ(str, "start,,1,234");
|
||||
assert_se(strextend_with_separator(&str, ";", "more", "5", "678"));
|
||||
assert_se(streq_ptr(str, "start,,1,234;more;5;678"));
|
||||
ASSERT_STREQ(str, "start,,1,234;more;5;678");
|
||||
}
|
||||
|
||||
TEST(strrep) {
|
||||
@ -295,15 +295,15 @@ TEST(strrep) {
|
||||
three = strrep("waldo", 3);
|
||||
zero = strrep("waldo", 0);
|
||||
|
||||
assert_se(streq(one, "waldo"));
|
||||
assert_se(streq(three, "waldowaldowaldo"));
|
||||
assert_se(streq(zero, ""));
|
||||
ASSERT_STREQ(one, "waldo");
|
||||
ASSERT_STREQ(three, "waldowaldowaldo");
|
||||
ASSERT_STREQ(zero, "");
|
||||
|
||||
onea = strrepa("waldo", 1);
|
||||
threea = strrepa("waldo", 3);
|
||||
|
||||
assert_se(streq(onea, "waldo"));
|
||||
assert_se(streq(threea, "waldowaldowaldo"));
|
||||
ASSERT_STREQ(onea, "waldo");
|
||||
ASSERT_STREQ(threea, "waldowaldowaldo");
|
||||
}
|
||||
|
||||
TEST(string_has_cc) {
|
||||
@ -322,7 +322,7 @@ TEST(string_has_cc) {
|
||||
|
||||
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"));
|
||||
ASSERT_STREQ(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk");
|
||||
}
|
||||
|
||||
TEST(strshorten) {
|
||||
@ -343,62 +343,62 @@ TEST(strjoina) {
|
||||
char *actual;
|
||||
|
||||
actual = strjoina("", "foo", "bar");
|
||||
assert_se(streq(actual, "foobar"));
|
||||
ASSERT_STREQ(actual, "foobar");
|
||||
|
||||
actual = strjoina("foo", "bar", "baz");
|
||||
assert_se(streq(actual, "foobarbaz"));
|
||||
ASSERT_STREQ(actual, "foobarbaz");
|
||||
|
||||
actual = strjoina("foo", "", "bar", "baz");
|
||||
assert_se(streq(actual, "foobarbaz"));
|
||||
ASSERT_STREQ(actual, "foobarbaz");
|
||||
|
||||
actual = strjoina("foo");
|
||||
assert_se(streq(actual, "foo"));
|
||||
ASSERT_STREQ(actual, "foo");
|
||||
|
||||
actual = strjoina(NULL);
|
||||
assert_se(streq(actual, ""));
|
||||
ASSERT_STREQ(actual, "");
|
||||
|
||||
actual = strjoina(NULL, "foo");
|
||||
assert_se(streq(actual, ""));
|
||||
ASSERT_STREQ(actual, "");
|
||||
|
||||
actual = strjoina("foo", NULL, "bar");
|
||||
assert_se(streq(actual, "foo"));
|
||||
ASSERT_STREQ(actual, "foo");
|
||||
|
||||
actual = strjoina("/sys/fs/cgroup/", "dn", "/a/b/c", "/cgroup.procs");
|
||||
assert_se(streq(actual, "/sys/fs/cgroup/dn/a/b/c/cgroup.procs"));
|
||||
ASSERT_STREQ(actual, "/sys/fs/cgroup/dn/a/b/c/cgroup.procs");
|
||||
|
||||
actual = strjoina("/sys/fs/cgroup/", "dn", NULL, NULL);
|
||||
assert_se(streq(actual, "/sys/fs/cgroup/dn"));
|
||||
ASSERT_STREQ(actual, "/sys/fs/cgroup/dn");
|
||||
}
|
||||
|
||||
TEST(strjoin) {
|
||||
char *actual;
|
||||
|
||||
actual = strjoin("", "foo", "bar");
|
||||
assert_se(streq(actual, "foobar"));
|
||||
ASSERT_STREQ(actual, "foobar");
|
||||
free(actual);
|
||||
|
||||
actual = strjoin("foo", "bar", "baz");
|
||||
assert_se(streq(actual, "foobarbaz"));
|
||||
ASSERT_STREQ(actual, "foobarbaz");
|
||||
free(actual);
|
||||
|
||||
actual = strjoin("foo", "", "bar", "baz");
|
||||
assert_se(streq(actual, "foobarbaz"));
|
||||
ASSERT_STREQ(actual, "foobarbaz");
|
||||
free(actual);
|
||||
|
||||
actual = strjoin("foo", NULL);
|
||||
assert_se(streq(actual, "foo"));
|
||||
ASSERT_STREQ(actual, "foo");
|
||||
free(actual);
|
||||
|
||||
actual = strjoin(NULL, NULL);
|
||||
assert_se(streq(actual, ""));
|
||||
ASSERT_STREQ(actual, "");
|
||||
free(actual);
|
||||
|
||||
actual = strjoin(NULL, "foo");
|
||||
assert_se(streq(actual, ""));
|
||||
ASSERT_STREQ(actual, "");
|
||||
free(actual);
|
||||
|
||||
actual = strjoin("foo", NULL, "bar");
|
||||
assert_se(streq(actual, "foo"));
|
||||
ASSERT_STREQ(actual, "foo");
|
||||
free(actual);
|
||||
}
|
||||
|
||||
@ -436,7 +436,7 @@ TEST(foreach_word) {
|
||||
}
|
||||
assert_se(r > 0);
|
||||
|
||||
assert_se(streq(expected[i++], word));
|
||||
ASSERT_STREQ(expected[i++], word);
|
||||
}
|
||||
}
|
||||
|
||||
@ -457,7 +457,7 @@ static void check(const char *test, char** expected, bool trailing) {
|
||||
break;
|
||||
}
|
||||
|
||||
assert_se(streq(word, expected[i++]));
|
||||
ASSERT_STREQ(word, expected[i++]);
|
||||
printf("<%s>\n", word);
|
||||
}
|
||||
ASSERT_NULL(expected[i]);
|
||||
@ -512,7 +512,7 @@ TEST(delete_chars) {
|
||||
char *s, input[] = " hello, waldo. abc";
|
||||
|
||||
s = delete_chars(input, WHITESPACE);
|
||||
assert_se(streq(s, "hello,waldo.abc"));
|
||||
ASSERT_STREQ(s, "hello,waldo.abc");
|
||||
assert_se(s == input);
|
||||
}
|
||||
|
||||
@ -523,19 +523,19 @@ TEST(delete_trailing_chars) {
|
||||
input3[] = "abcdef";
|
||||
|
||||
s = delete_trailing_chars(input1, WHITESPACE);
|
||||
assert_se(streq(s, " \n \r k"));
|
||||
ASSERT_STREQ(s, " \n \r k");
|
||||
assert_se(s == input1);
|
||||
|
||||
s = delete_trailing_chars(input2, "kt");
|
||||
assert_se(streq(s, "kkkkthiskkkiskkkaktes"));
|
||||
ASSERT_STREQ(s, "kkkkthiskkkiskkkaktes");
|
||||
assert_se(s == input2);
|
||||
|
||||
s = delete_trailing_chars(input3, WHITESPACE);
|
||||
assert_se(streq(s, "abcdef"));
|
||||
ASSERT_STREQ(s, "abcdef");
|
||||
assert_se(s == input3);
|
||||
|
||||
s = delete_trailing_chars(input3, "fe");
|
||||
assert_se(streq(s, "abcd"));
|
||||
ASSERT_STREQ(s, "abcd");
|
||||
assert_se(s == input3);
|
||||
}
|
||||
|
||||
@ -545,11 +545,11 @@ TEST(delete_trailing_slashes) {
|
||||
s3[] = "foobar",
|
||||
s4[] = "";
|
||||
|
||||
assert_se(streq(delete_trailing_chars(s1, "_"), "foobar//"));
|
||||
assert_se(streq(delete_trailing_chars(s1, "/"), "foobar"));
|
||||
assert_se(streq(delete_trailing_chars(s2, "/"), "foobar"));
|
||||
assert_se(streq(delete_trailing_chars(s3, "/"), "foobar"));
|
||||
assert_se(streq(delete_trailing_chars(s4, "/"), ""));
|
||||
ASSERT_STREQ(delete_trailing_chars(s1, "_"), "foobar//");
|
||||
ASSERT_STREQ(delete_trailing_chars(s1, "/"), "foobar");
|
||||
ASSERT_STREQ(delete_trailing_chars(s2, "/"), "foobar");
|
||||
ASSERT_STREQ(delete_trailing_chars(s3, "/"), "foobar");
|
||||
ASSERT_STREQ(delete_trailing_chars(s4, "/"), "");
|
||||
}
|
||||
|
||||
TEST(skip_leading_chars) {
|
||||
@ -557,11 +557,11 @@ TEST(skip_leading_chars) {
|
||||
input2[] = "kkkkthiskkkiskkkaktestkkk",
|
||||
input3[] = "abcdef";
|
||||
|
||||
assert_se(streq(skip_leading_chars(input1, WHITESPACE), "k \n \r "));
|
||||
assert_se(streq(skip_leading_chars(input2, "k"), "thiskkkiskkkaktestkkk"));
|
||||
assert_se(streq(skip_leading_chars(input2, "tk"), "hiskkkiskkkaktestkkk"));
|
||||
assert_se(streq(skip_leading_chars(input3, WHITESPACE), "abcdef"));
|
||||
assert_se(streq(skip_leading_chars(input3, "bcaef"), "def"));
|
||||
ASSERT_STREQ(skip_leading_chars(input1, WHITESPACE), "k \n \r ");
|
||||
ASSERT_STREQ(skip_leading_chars(input2, "k"), "thiskkkiskkkaktestkkk");
|
||||
ASSERT_STREQ(skip_leading_chars(input2, "tk"), "hiskkkiskkkaktestkkk");
|
||||
ASSERT_STREQ(skip_leading_chars(input3, WHITESPACE), "abcdef");
|
||||
ASSERT_STREQ(skip_leading_chars(input3, "bcaef"), "def");
|
||||
}
|
||||
|
||||
TEST(in_charset) {
|
||||
@ -576,19 +576,19 @@ TEST(split_pair) {
|
||||
assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
|
||||
assert_se(split_pair("", "=", &a, &b) == -EINVAL);
|
||||
assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
|
||||
assert_se(streq(a, "foo"));
|
||||
assert_se(streq(b, "bar"));
|
||||
ASSERT_STREQ(a, "foo");
|
||||
ASSERT_STREQ(b, "bar");
|
||||
free(a);
|
||||
free(b);
|
||||
assert_se(split_pair("==", "==", &a, &b) >= 0);
|
||||
assert_se(streq(a, ""));
|
||||
assert_se(streq(b, ""));
|
||||
ASSERT_STREQ(a, "");
|
||||
ASSERT_STREQ(b, "");
|
||||
free(a);
|
||||
free(b);
|
||||
|
||||
assert_se(split_pair("===", "==", &a, &b) >= 0);
|
||||
assert_se(streq(a, ""));
|
||||
assert_se(streq(b, "="));
|
||||
ASSERT_STREQ(a, "");
|
||||
ASSERT_STREQ(b, "=");
|
||||
}
|
||||
|
||||
TEST(first_word) {
|
||||
@ -612,33 +612,33 @@ TEST(strlen_ptr) {
|
||||
}
|
||||
|
||||
TEST(memory_startswith) {
|
||||
assert_se(streq(memory_startswith("", 0, ""), ""));
|
||||
assert_se(streq(memory_startswith("", 1, ""), ""));
|
||||
assert_se(streq(memory_startswith("x", 2, ""), "x"));
|
||||
ASSERT_STREQ(memory_startswith("", 0, ""), "");
|
||||
ASSERT_STREQ(memory_startswith("", 1, ""), "");
|
||||
ASSERT_STREQ(memory_startswith("x", 2, ""), "x");
|
||||
assert_se(!memory_startswith("", 1, "x"));
|
||||
assert_se(!memory_startswith("", 1, "xxxxxxxx"));
|
||||
assert_se(streq(memory_startswith("xxx", 4, "x"), "xx"));
|
||||
assert_se(streq(memory_startswith("xxx", 4, "xx"), "x"));
|
||||
assert_se(streq(memory_startswith("xxx", 4, "xxx"), ""));
|
||||
ASSERT_STREQ(memory_startswith("xxx", 4, "x"), "xx");
|
||||
ASSERT_STREQ(memory_startswith("xxx", 4, "xx"), "x");
|
||||
ASSERT_STREQ(memory_startswith("xxx", 4, "xxx"), "");
|
||||
assert_se(!memory_startswith("xxx", 4, "xxxx"));
|
||||
}
|
||||
|
||||
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(streq(memory_startswith_no_case("X", 2, ""), "X"));
|
||||
ASSERT_STREQ(memory_startswith_no_case("", 0, ""), "");
|
||||
ASSERT_STREQ(memory_startswith_no_case("", 1, ""), "");
|
||||
ASSERT_STREQ(memory_startswith_no_case("x", 2, ""), "x");
|
||||
ASSERT_STREQ(memory_startswith_no_case("X", 2, ""), "X");
|
||||
assert_se(!memory_startswith_no_case("", 1, "X"));
|
||||
assert_se(!memory_startswith_no_case("", 1, "xxxxXXXX"));
|
||||
assert_se(streq(memory_startswith_no_case("xxx", 4, "X"), "xx"));
|
||||
assert_se(streq(memory_startswith_no_case("XXX", 4, "x"), "XX"));
|
||||
assert_se(streq(memory_startswith_no_case("XXX", 4, "X"), "XX"));
|
||||
assert_se(streq(memory_startswith_no_case("xxx", 4, "XX"), "x"));
|
||||
assert_se(streq(memory_startswith_no_case("XXX", 4, "xx"), "X"));
|
||||
assert_se(streq(memory_startswith_no_case("XXX", 4, "XX"), "X"));
|
||||
assert_se(streq(memory_startswith_no_case("xxx", 4, "XXX"), ""));
|
||||
assert_se(streq(memory_startswith_no_case("XXX", 4, "xxx"), ""));
|
||||
assert_se(streq(memory_startswith_no_case("XXX", 4, "XXX"), ""));
|
||||
ASSERT_STREQ(memory_startswith_no_case("xxx", 4, "X"), "xx");
|
||||
ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "x"), "XX");
|
||||
ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "X"), "XX");
|
||||
ASSERT_STREQ(memory_startswith_no_case("xxx", 4, "XX"), "x");
|
||||
ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "xx"), "X");
|
||||
ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "XX"), "X");
|
||||
ASSERT_STREQ(memory_startswith_no_case("xxx", 4, "XXX"), "");
|
||||
ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "xxx"), "");
|
||||
ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "XXX"), "");
|
||||
|
||||
assert_se(memory_startswith_no_case((char[2]){'x', 'x'}, 2, "xx"));
|
||||
assert_se(memory_startswith_no_case((char[2]){'x', 'X'}, 2, "xX"));
|
||||
@ -651,7 +651,7 @@ static void test_string_truncate_lines_one(const char *input, size_t n_lines, co
|
||||
int k;
|
||||
|
||||
assert_se((k = string_truncate_lines(input, n_lines, &b)) >= 0);
|
||||
assert_se(streq(b, output));
|
||||
ASSERT_STREQ(b, output);
|
||||
assert_se(!!k == truncation);
|
||||
}
|
||||
|
||||
@ -722,7 +722,7 @@ static void test_string_extract_lines_one(const char *input, size_t i, const cha
|
||||
int k;
|
||||
|
||||
assert_se((k = string_extract_line(input, i, &b)) >= 0);
|
||||
assert_se(streq(b ?: input, output));
|
||||
ASSERT_STREQ(b ?: input, output);
|
||||
assert_se(!!k == more);
|
||||
}
|
||||
|
||||
@ -799,25 +799,25 @@ TEST(string_contains_word_strv) {
|
||||
assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("a", "b"), NULL));
|
||||
|
||||
assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("a", "b"), &w));
|
||||
assert_se(streq(w, "a"));
|
||||
ASSERT_STREQ(w, "a");
|
||||
|
||||
assert_se(!string_contains_word_strv("a b cc", NULL, STRV_MAKE("d"), &w));
|
||||
ASSERT_NULL(w);
|
||||
|
||||
assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("b", "a"), &w));
|
||||
assert_se(streq(w, "a"));
|
||||
ASSERT_STREQ(w, "a");
|
||||
|
||||
assert_se(string_contains_word_strv("b a b cc", NULL, STRV_MAKE("b", "a", "b"), &w));
|
||||
assert_se(streq(w, "b"));
|
||||
ASSERT_STREQ(w, "b");
|
||||
|
||||
assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("b", ""), &w));
|
||||
assert_se(streq(w, "b"));
|
||||
ASSERT_STREQ(w, "b");
|
||||
|
||||
assert_se(!string_contains_word_strv("a b cc", NULL, STRV_MAKE(""), &w));
|
||||
ASSERT_NULL(w);
|
||||
|
||||
assert_se(string_contains_word_strv("a b cc", " ", STRV_MAKE(""), &w));
|
||||
assert_se(streq(w, ""));
|
||||
ASSERT_STREQ(w, "");
|
||||
}
|
||||
|
||||
TEST(string_contains_word) {
|
||||
@ -1139,38 +1139,38 @@ TEST(strextendf) {
|
||||
_cleanup_free_ char *p = NULL;
|
||||
|
||||
assert_se(strextendf(&p, "<%i>", 77) >= 0);
|
||||
assert_se(streq(p, "<77>"));
|
||||
ASSERT_STREQ(p, "<77>");
|
||||
|
||||
assert_se(strextendf(&p, "<%i>", 99) >= 0);
|
||||
assert_se(streq(p, "<77><99>"));
|
||||
ASSERT_STREQ(p, "<77><99>");
|
||||
|
||||
assert_se(strextendf(&p, "<%80i>", 88) >= 0);
|
||||
assert_se(streq(p, "<77><99>< 88>"));
|
||||
ASSERT_STREQ(p, "<77><99>< 88>");
|
||||
|
||||
assert_se(strextendf(&p, "<%08x>", 0x1234u) >= 0);
|
||||
assert_se(streq(p, "<77><99>< 88><00001234>"));
|
||||
ASSERT_STREQ(p, "<77><99>< 88><00001234>");
|
||||
|
||||
p = mfree(p);
|
||||
|
||||
assert_se(strextendf_with_separator(&p, ",", "<%i>", 77) >= 0);
|
||||
assert_se(streq(p, "<77>"));
|
||||
ASSERT_STREQ(p, "<77>");
|
||||
|
||||
assert_se(strextendf_with_separator(&p, ",", "<%i>", 99) >= 0);
|
||||
assert_se(streq(p, "<77>,<99>"));
|
||||
ASSERT_STREQ(p, "<77>,<99>");
|
||||
|
||||
assert_se(strextendf_with_separator(&p, ",", "<%80i>", 88) >= 0);
|
||||
assert_se(streq(p, "<77>,<99>,< 88>"));
|
||||
ASSERT_STREQ(p, "<77>,<99>,< 88>");
|
||||
|
||||
assert_se(strextendf_with_separator(&p, ",", "<%08x>", 0x1234u) >= 0);
|
||||
assert_se(streq(p, "<77>,<99>,< 88>,<00001234>"));
|
||||
ASSERT_STREQ(p, "<77>,<99>,< 88>,<00001234>");
|
||||
}
|
||||
|
||||
TEST(string_replace_char) {
|
||||
assert_se(streq(string_replace_char(strdupa_safe(""), 'a', 'b'), ""));
|
||||
assert_se(streq(string_replace_char(strdupa_safe("abc"), 'a', 'b'), "bbc"));
|
||||
assert_se(streq(string_replace_char(strdupa_safe("hoge"), 'a', 'b'), "hoge"));
|
||||
assert_se(streq(string_replace_char(strdupa_safe("aaaa"), 'a', 'b'), "bbbb"));
|
||||
assert_se(streq(string_replace_char(strdupa_safe("aaaa"), 'a', '\t'), "\t\t\t\t"));
|
||||
ASSERT_STREQ(string_replace_char(strdupa_safe(""), 'a', 'b'), "");
|
||||
ASSERT_STREQ(string_replace_char(strdupa_safe("abc"), 'a', 'b'), "bbc");
|
||||
ASSERT_STREQ(string_replace_char(strdupa_safe("hoge"), 'a', 'b'), "hoge");
|
||||
ASSERT_STREQ(string_replace_char(strdupa_safe("aaaa"), 'a', 'b'), "bbbb");
|
||||
ASSERT_STREQ(string_replace_char(strdupa_safe("aaaa"), 'a', '\t'), "\t\t\t\t");
|
||||
}
|
||||
|
||||
TEST(strspn_from_end) {
|
||||
@ -1214,7 +1214,7 @@ TEST(streq_skip_trailing_chars) {
|
||||
do { \
|
||||
_cleanup_free_ char *b = NULL; \
|
||||
assert_se(make_cstring((x), ELEMENTSOF(x), (mode), &b) == (ret)); \
|
||||
assert_se(streq_ptr(b, (expect))); \
|
||||
ASSERT_STREQ(b, (expect)); \
|
||||
} while(false)
|
||||
|
||||
TEST(make_cstring) {
|
||||
@ -1295,7 +1295,7 @@ TEST(strstrafter) {
|
||||
assert_se(!strstrafter(NULL, NULL));
|
||||
assert_se(!strstrafter("", NULL));
|
||||
assert_se(!strstrafter(NULL, ""));
|
||||
assert_se(streq_ptr(strstrafter("", ""), ""));
|
||||
ASSERT_STREQ(strstrafter("", ""), "");
|
||||
|
||||
assert_se(strstrafter(buffer, "a") == buffer + 1);
|
||||
assert_se(strstrafter(buffer, "") == buffer);
|
||||
@ -1319,18 +1319,18 @@ TEST(version_is_valid) {
|
||||
TEST(strextendn) {
|
||||
_cleanup_free_ char *x = NULL;
|
||||
|
||||
assert_se(streq_ptr(strextendn(&x, NULL, 0), ""));
|
||||
ASSERT_STREQ(strextendn(&x, NULL, 0), "");
|
||||
x = mfree(x);
|
||||
|
||||
assert_se(streq_ptr(strextendn(&x, "", 0), ""));
|
||||
ASSERT_STREQ(strextendn(&x, "", 0), "");
|
||||
x = mfree(x);
|
||||
|
||||
assert_se(streq_ptr(strextendn(&x, "xxx", 3), "xxx"));
|
||||
assert_se(streq_ptr(strextendn(&x, "xxx", 3), "xxxxxx"));
|
||||
assert_se(streq_ptr(strextendn(&x, "...", 1), "xxxxxx."));
|
||||
assert_se(streq_ptr(strextendn(&x, "...", 2), "xxxxxx..."));
|
||||
assert_se(streq_ptr(strextendn(&x, "...", 3), "xxxxxx......"));
|
||||
assert_se(streq_ptr(strextendn(&x, "...", 4), "xxxxxx........."));
|
||||
ASSERT_STREQ(strextendn(&x, "xxx", 3), "xxx");
|
||||
ASSERT_STREQ(strextendn(&x, "xxx", 3), "xxxxxx");
|
||||
ASSERT_STREQ(strextendn(&x, "...", 1), "xxxxxx.");
|
||||
ASSERT_STREQ(strextendn(&x, "...", 2), "xxxxxx...");
|
||||
ASSERT_STREQ(strextendn(&x, "...", 3), "xxxxxx......");
|
||||
ASSERT_STREQ(strextendn(&x, "...", 4), "xxxxxx.........");
|
||||
x = mfree(x);
|
||||
}
|
||||
|
||||
|
||||
@ -15,38 +15,38 @@ TEST(strip_tab_ansi) {
|
||||
assert_se(p = strdup("\tFoobar\tbar\twaldo\t"));
|
||||
assert_se(strip_tab_ansi(&p, NULL, NULL));
|
||||
fprintf(stdout, "<%s>\n", p);
|
||||
assert_se(streq(p, " Foobar bar waldo "));
|
||||
ASSERT_STREQ(p, " Foobar bar waldo ");
|
||||
free(p);
|
||||
|
||||
assert_se(p = strdup(ANSI_HIGHLIGHT "Hello" ANSI_NORMAL ANSI_HIGHLIGHT_RED " world!" ANSI_NORMAL));
|
||||
assert_se(strip_tab_ansi(&p, NULL, NULL));
|
||||
fprintf(stdout, "<%s>\n", p);
|
||||
assert_se(streq(p, "Hello world!"));
|
||||
ASSERT_STREQ(p, "Hello world!");
|
||||
free(p);
|
||||
|
||||
assert_se(p = strdup("\x1B[\x1B[\t\x1B[" ANSI_HIGHLIGHT "\x1B[" "Hello" ANSI_NORMAL ANSI_HIGHLIGHT_RED " world!" ANSI_NORMAL));
|
||||
assert_se(strip_tab_ansi(&p, NULL, NULL));
|
||||
assert_se(streq(p, "\x1B[\x1B[ \x1B[\x1B[Hello world!"));
|
||||
ASSERT_STREQ(p, "\x1B[\x1B[ \x1B[\x1B[Hello world!");
|
||||
free(p);
|
||||
|
||||
assert_se(p = strdup("\x1B[waldo"));
|
||||
assert_se(strip_tab_ansi(&p, NULL, NULL));
|
||||
assert_se(streq(p, "\x1B[waldo"));
|
||||
ASSERT_STREQ(p, "\x1B[waldo");
|
||||
free(p);
|
||||
|
||||
assert_se(p = strdup("\r\rwaldo"));
|
||||
assert_se(strip_tab_ansi(&p, NULL, NULL));
|
||||
assert_se(streq(p, "\r\rwaldo"));
|
||||
ASSERT_STREQ(p, "\r\rwaldo");
|
||||
free(p);
|
||||
|
||||
assert_se(p = strdup("waldo\r\r"));
|
||||
assert_se(strip_tab_ansi(&p, NULL, NULL));
|
||||
assert_se(streq(p, "waldo"));
|
||||
ASSERT_STREQ(p, "waldo");
|
||||
free(p);
|
||||
|
||||
assert_se(p = strdup("waldo\r\r\n\r\n"));
|
||||
assert_se(strip_tab_ansi(&p, NULL, NULL));
|
||||
assert_se(streq(p, "waldo\n\n"));
|
||||
ASSERT_STREQ(p, "waldo\n\n");
|
||||
free(p);
|
||||
|
||||
assert_se(terminal_urlify_path("/etc/fstab", "i am a fabulous link", &urlified) >= 0);
|
||||
@ -55,7 +55,7 @@ TEST(strip_tab_ansi) {
|
||||
printf("<%s>\n", p);
|
||||
assert_se(strip_tab_ansi(&p, NULL, NULL));
|
||||
printf("<%s>\n", p);
|
||||
assert_se(streq(p, "something i am a fabulous link something-else"));
|
||||
ASSERT_STREQ(p, "something i am a fabulous link something-else");
|
||||
p = mfree(p);
|
||||
|
||||
/* Truncate the formatted string in the middle of an ANSI sequence (in which case we shouldn't touch the
|
||||
@ -65,7 +65,7 @@ TEST(strip_tab_ansi) {
|
||||
*z = 0;
|
||||
assert_se(qq = strdup(q));
|
||||
assert_se(strip_tab_ansi(&q, NULL, NULL));
|
||||
assert_se(streq(q, qq));
|
||||
ASSERT_STREQ(q, qq);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -34,9 +34,9 @@ TEST(startswith_set) {
|
||||
assert_se(STARTSWITH_SET("abc", "ax", "abx", "abc"));
|
||||
assert_se(!STARTSWITH_SET("abc", "ax", "abx", "abcx"));
|
||||
|
||||
assert_se(streq_ptr(STARTSWITH_SET("foobar", "hhh", "kkk", "foo", "zzz"), "bar"));
|
||||
assert_se(streq_ptr(STARTSWITH_SET("foobar", "hhh", "kkk", "", "zzz"), "foobar"));
|
||||
assert_se(streq_ptr(STARTSWITH_SET("", "hhh", "kkk", "zzz", ""), ""));
|
||||
ASSERT_STREQ(STARTSWITH_SET("foobar", "hhh", "kkk", "foo", "zzz"), "bar");
|
||||
ASSERT_STREQ(STARTSWITH_SET("foobar", "hhh", "kkk", "", "zzz"), "foobar");
|
||||
ASSERT_STREQ(STARTSWITH_SET("", "hhh", "kkk", "zzz", ""), "");
|
||||
}
|
||||
|
||||
static const char* const input_table_multiple[] = {
|
||||
@ -125,78 +125,78 @@ TEST(strv_find_startswith) {
|
||||
TEST(strv_join) {
|
||||
_cleanup_free_ char *p = strv_join((char **)input_table_multiple, ", ");
|
||||
assert_se(p);
|
||||
assert_se(streq(p, "one, two, three"));
|
||||
ASSERT_STREQ(p, "one, two, three");
|
||||
|
||||
_cleanup_free_ char *q = strv_join((char **)input_table_multiple, ";");
|
||||
assert_se(q);
|
||||
assert_se(streq(q, "one;two;three"));
|
||||
ASSERT_STREQ(q, "one;two;three");
|
||||
|
||||
_cleanup_free_ char *r = strv_join((char **)input_table_multiple, NULL);
|
||||
assert_se(r);
|
||||
assert_se(streq(r, "one two three"));
|
||||
ASSERT_STREQ(r, "one two three");
|
||||
|
||||
_cleanup_free_ char *s = strv_join(STRV_MAKE("1", "2", "3,3"), ",");
|
||||
assert_se(s);
|
||||
assert_se(streq(s, "1,2,3,3"));
|
||||
ASSERT_STREQ(s, "1,2,3,3");
|
||||
|
||||
_cleanup_free_ char *t = strv_join((char **)input_table_one, ", ");
|
||||
assert_se(t);
|
||||
assert_se(streq(t, "one"));
|
||||
ASSERT_STREQ(t, "one");
|
||||
|
||||
_cleanup_free_ char *u = strv_join((char **)input_table_none, ", ");
|
||||
assert_se(u);
|
||||
assert_se(streq(u, ""));
|
||||
ASSERT_STREQ(u, "");
|
||||
|
||||
_cleanup_free_ char *v = strv_join((char **)input_table_two_empties, ", ");
|
||||
assert_se(v);
|
||||
assert_se(streq(v, ", "));
|
||||
ASSERT_STREQ(v, ", ");
|
||||
|
||||
_cleanup_free_ char *w = strv_join((char **)input_table_one_empty, ", ");
|
||||
assert_se(w);
|
||||
assert_se(streq(w, ""));
|
||||
ASSERT_STREQ(w, "");
|
||||
}
|
||||
|
||||
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_STREQ(p, "fooone, footwo, foothree");
|
||||
|
||||
_cleanup_free_ char *q = strv_join_full((char **)input_table_multiple, ";", "foo", false);
|
||||
assert_se(q);
|
||||
assert_se(streq(q, "fooone;footwo;foothree"));
|
||||
ASSERT_STREQ(q, "fooone;footwo;foothree");
|
||||
|
||||
_cleanup_free_ char *r = strv_join_full(STRV_MAKE("a", "a;b", "a:c"), ";", NULL, true);
|
||||
assert_se(r);
|
||||
assert_se(streq(r, "a;a\\;b;a:c"));
|
||||
ASSERT_STREQ(r, "a;a\\;b;a:c");
|
||||
|
||||
_cleanup_free_ char *s = strv_join_full(STRV_MAKE("a", "a;b", "a;;c", ";", ";x"), ";", NULL, true);
|
||||
assert_se(s);
|
||||
assert_se(streq(s, "a;a\\;b;a\\;\\;c;\\;;\\;x"));
|
||||
ASSERT_STREQ(s, "a;a\\;b;a\\;\\;c;\\;;\\;x");
|
||||
|
||||
_cleanup_free_ char *t = strv_join_full(STRV_MAKE("a", "a;b", "a:c", ";"), ";", "=", true);
|
||||
assert_se(t);
|
||||
assert_se(streq(t, "=a;=a\\;b;=a:c;=\\;"));
|
||||
ASSERT_STREQ(t, "=a;=a\\;b;=a:c;=\\;");
|
||||
t = mfree(t);
|
||||
|
||||
_cleanup_free_ char *u = strv_join_full((char **)input_table_multiple, NULL, "foo", false);
|
||||
assert_se(u);
|
||||
assert_se(streq(u, "fooone footwo foothree"));
|
||||
ASSERT_STREQ(u, "fooone footwo foothree");
|
||||
|
||||
_cleanup_free_ char *v = strv_join_full((char **)input_table_one, ", ", "foo", false);
|
||||
assert_se(v);
|
||||
assert_se(streq(v, "fooone"));
|
||||
ASSERT_STREQ(v, "fooone");
|
||||
|
||||
_cleanup_free_ char *w = strv_join_full((char **)input_table_none, ", ", "foo", false);
|
||||
assert_se(w);
|
||||
assert_se(streq(w, ""));
|
||||
ASSERT_STREQ(w, "");
|
||||
|
||||
_cleanup_free_ char *x = strv_join_full((char **)input_table_two_empties, ", ", "foo", false);
|
||||
assert_se(x);
|
||||
assert_se(streq(x, "foo, foo"));
|
||||
ASSERT_STREQ(x, "foo, foo");
|
||||
|
||||
_cleanup_free_ char *y = strv_join_full((char **)input_table_one_empty, ", ", "foo", false);
|
||||
assert_se(y);
|
||||
assert_se(streq(y, "foo"));
|
||||
ASSERT_STREQ(y, "foo");
|
||||
}
|
||||
|
||||
static void test_strv_unquote_one(const char *quoted, char **list) {
|
||||
@ -215,7 +215,7 @@ static void test_strv_unquote_one(const char *quoted, char **list) {
|
||||
puts(j);
|
||||
|
||||
STRV_FOREACH(t, s)
|
||||
assert_se(streq(list[i++], *t));
|
||||
ASSERT_STREQ(list[i++], *t);
|
||||
|
||||
ASSERT_NULL(list[i]);
|
||||
}
|
||||
@ -402,12 +402,12 @@ TEST(strv_split_full) {
|
||||
|
||||
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[1], "foo:bar"));
|
||||
assert_se(streq_ptr(l[2], ""));
|
||||
assert_se(streq_ptr(l[3], "waldo"));
|
||||
assert_se(streq_ptr(l[4], ""));
|
||||
assert_se(streq_ptr(l[5], NULL));
|
||||
ASSERT_STREQ(l[0], "");
|
||||
ASSERT_STREQ(l[1], "foo:bar");
|
||||
ASSERT_STREQ(l[2], "");
|
||||
ASSERT_STREQ(l[3], "waldo");
|
||||
ASSERT_STREQ(l[4], "");
|
||||
ASSERT_STREQ(l[5], NULL);
|
||||
}
|
||||
|
||||
TEST(strv_split_and_extend_full) {
|
||||
@ -420,14 +420,14 @@ TEST(strv_split_and_extend_full) {
|
||||
assert_se(r == (int) strv_length(l));
|
||||
r = strv_split_and_extend_full(&l, str1, ":", false, EXTRACT_DONT_COALESCE_SEPARATORS);
|
||||
assert_se(r == (int) strv_length(l));
|
||||
assert_se(streq_ptr(l[0], ""));
|
||||
assert_se(streq_ptr(l[1], "foo:bar"));
|
||||
assert_se(streq_ptr(l[2], ""));
|
||||
ASSERT_STREQ(l[0], "");
|
||||
ASSERT_STREQ(l[1], "foo:bar");
|
||||
ASSERT_STREQ(l[2], "");
|
||||
r = strv_split_and_extend_full(&l, str2, ":", false, 0);
|
||||
assert_se(r == (int) strv_length(l));
|
||||
assert_se(streq_ptr(l[3], "waldo"));
|
||||
assert_se(streq_ptr(l[4], "baz"));
|
||||
assert_se(streq_ptr(l[5], NULL));
|
||||
ASSERT_STREQ(l[3], "waldo");
|
||||
ASSERT_STREQ(l[4], "baz");
|
||||
ASSERT_STREQ(l[5], NULL);
|
||||
}
|
||||
|
||||
TEST(strv_split_colon_pairs) {
|
||||
@ -439,19 +439,19 @@ TEST(strv_split_colon_pairs) {
|
||||
r = strv_split_colon_pairs(&l, str);
|
||||
assert_se(r == (int) strv_length(l));
|
||||
assert_se(r == 12);
|
||||
assert_se(streq_ptr(l[0], "one"));
|
||||
assert_se(streq_ptr(l[1], "two"));
|
||||
assert_se(streq_ptr(l[2], "three"));
|
||||
assert_se(streq_ptr(l[3], ""));
|
||||
assert_se(streq_ptr(l[4], "four"));
|
||||
assert_se(streq_ptr(l[5], "five"));
|
||||
assert_se(streq_ptr(l[6], "six"));
|
||||
assert_se(streq_ptr(l[7], ""));
|
||||
assert_se(streq_ptr(l[8], "seven"));
|
||||
assert_se(streq_ptr(l[9], "eight:nine"));
|
||||
assert_se(streq_ptr(l[10], "ten:eleven\\"));
|
||||
assert_se(streq_ptr(l[11], ""));
|
||||
assert_se(streq_ptr(l[12], NULL));
|
||||
ASSERT_STREQ(l[0], "one");
|
||||
ASSERT_STREQ(l[1], "two");
|
||||
ASSERT_STREQ(l[2], "three");
|
||||
ASSERT_STREQ(l[3], "");
|
||||
ASSERT_STREQ(l[4], "four");
|
||||
ASSERT_STREQ(l[5], "five");
|
||||
ASSERT_STREQ(l[6], "six");
|
||||
ASSERT_STREQ(l[7], "");
|
||||
ASSERT_STREQ(l[8], "seven");
|
||||
ASSERT_STREQ(l[9], "eight:nine");
|
||||
ASSERT_STREQ(l[10], "ten:eleven\\");
|
||||
ASSERT_STREQ(l[11], "");
|
||||
ASSERT_STREQ(l[12], NULL);
|
||||
|
||||
r = strv_split_colon_pairs(&l, str_inval);
|
||||
assert_se(r == -EINVAL);
|
||||
@ -466,7 +466,7 @@ TEST(strv_split_newlines) {
|
||||
assert_se(l);
|
||||
|
||||
STRV_FOREACH(s, l)
|
||||
assert_se(streq(*s, input_table_multiple[i++]));
|
||||
ASSERT_STREQ(*s, input_table_multiple[i++]);
|
||||
}
|
||||
|
||||
TEST(strv_split_newlines_full) {
|
||||
@ -520,11 +520,11 @@ TEST(strv_sort) {
|
||||
|
||||
strv_sort((char **)input_table);
|
||||
|
||||
assert_se(streq(input_table[0], "CAPITAL LETTERS FIRST"));
|
||||
assert_se(streq(input_table[1], "apple"));
|
||||
assert_se(streq(input_table[2], "banana"));
|
||||
assert_se(streq(input_table[3], "citrus"));
|
||||
assert_se(streq(input_table[4], "durian"));
|
||||
ASSERT_STREQ(input_table[0], "CAPITAL LETTERS FIRST");
|
||||
ASSERT_STREQ(input_table[1], "apple");
|
||||
ASSERT_STREQ(input_table[2], "banana");
|
||||
ASSERT_STREQ(input_table[3], "citrus");
|
||||
ASSERT_STREQ(input_table[4], "durian");
|
||||
}
|
||||
|
||||
TEST(strv_extend_strv_biconcat) {
|
||||
@ -537,10 +537,10 @@ TEST(strv_extend_strv_biconcat) {
|
||||
|
||||
assert_se(strv_extend_strv_biconcat(&a, "prefix_", (const char* const*) b, "_suffix") >= 0);
|
||||
|
||||
assert_se(streq(a[0], "without"));
|
||||
assert_se(streq(a[1], "suffix"));
|
||||
assert_se(streq(a[2], "prefix_with_suffix"));
|
||||
assert_se(streq(a[3], "prefix_suffix_suffix"));
|
||||
ASSERT_STREQ(a[0], "without");
|
||||
ASSERT_STREQ(a[1], "suffix");
|
||||
ASSERT_STREQ(a[2], "prefix_with_suffix");
|
||||
ASSERT_STREQ(a[3], "prefix_suffix_suffix");
|
||||
}
|
||||
|
||||
TEST(strv_extend_strv_concat) {
|
||||
@ -553,10 +553,10 @@ TEST(strv_extend_strv_concat) {
|
||||
|
||||
assert_se(strv_extend_strv_concat(&a, (const char* const*) b, "_suffix") >= 0);
|
||||
|
||||
assert_se(streq(a[0], "without"));
|
||||
assert_se(streq(a[1], "suffix"));
|
||||
assert_se(streq(a[2], "with_suffix"));
|
||||
assert_se(streq(a[3], "suffix_suffix"));
|
||||
ASSERT_STREQ(a[0], "without");
|
||||
ASSERT_STREQ(a[1], "suffix");
|
||||
ASSERT_STREQ(a[2], "with_suffix");
|
||||
ASSERT_STREQ(a[3], "suffix_suffix");
|
||||
}
|
||||
|
||||
TEST(strv_extend_strv) {
|
||||
@ -569,19 +569,19 @@ TEST(strv_extend_strv) {
|
||||
|
||||
assert_se(strv_extend_strv(&a, b, true) == 3);
|
||||
|
||||
assert_se(streq(a[0], "abc"));
|
||||
assert_se(streq(a[1], "def"));
|
||||
assert_se(streq(a[2], "ghi"));
|
||||
assert_se(streq(a[3], "jkl"));
|
||||
assert_se(streq(a[4], "mno"));
|
||||
assert_se(streq(a[5], "pqr"));
|
||||
ASSERT_STREQ(a[0], "abc");
|
||||
ASSERT_STREQ(a[1], "def");
|
||||
ASSERT_STREQ(a[2], "ghi");
|
||||
ASSERT_STREQ(a[3], "jkl");
|
||||
ASSERT_STREQ(a[4], "mno");
|
||||
ASSERT_STREQ(a[5], "pqr");
|
||||
assert_se(strv_length(a) == 6);
|
||||
|
||||
assert_se(strv_extend_strv(&n, b, false) >= 0);
|
||||
assert_se(streq(n[0], "jkl"));
|
||||
assert_se(streq(n[1], "mno"));
|
||||
assert_se(streq(n[2], "abc"));
|
||||
assert_se(streq(n[3], "pqr"));
|
||||
ASSERT_STREQ(n[0], "jkl");
|
||||
ASSERT_STREQ(n[1], "mno");
|
||||
ASSERT_STREQ(n[2], "abc");
|
||||
ASSERT_STREQ(n[3], "pqr");
|
||||
assert_se(strv_length(n) == 4);
|
||||
}
|
||||
|
||||
@ -597,10 +597,10 @@ TEST(strv_extend_with_size) {
|
||||
assert_se(strv_extend_with_size(&a, &n, "test3") >= 0);
|
||||
assert_se(n == 4);
|
||||
|
||||
assert_se(streq(a[0], "test"));
|
||||
assert_se(streq(a[1], "test1"));
|
||||
assert_se(streq(a[2], "test2"));
|
||||
assert_se(streq(a[3], "test3"));
|
||||
ASSERT_STREQ(a[0], "test");
|
||||
ASSERT_STREQ(a[1], "test1");
|
||||
ASSERT_STREQ(a[2], "test2");
|
||||
ASSERT_STREQ(a[3], "test3");
|
||||
ASSERT_NULL(a[4]);
|
||||
}
|
||||
|
||||
@ -612,10 +612,10 @@ TEST(strv_extend) {
|
||||
assert_se(strv_extend(&a, "test2") >= 0);
|
||||
assert_se(strv_extend(&b, "test3") >= 0);
|
||||
|
||||
assert_se(streq(a[0], "test"));
|
||||
assert_se(streq(a[1], "test1"));
|
||||
assert_se(streq(a[2], "test2"));
|
||||
assert_se(streq(b[0], "test3"));
|
||||
ASSERT_STREQ(a[0], "test");
|
||||
ASSERT_STREQ(a[1], "test1");
|
||||
ASSERT_STREQ(a[2], "test2");
|
||||
ASSERT_STREQ(b[0], "test3");
|
||||
}
|
||||
|
||||
TEST(strv_extendf) {
|
||||
@ -626,10 +626,10 @@ TEST(strv_extendf) {
|
||||
assert_se(strv_extendf(&a, "test2 %s %d %s", "foo", 128, "bar") >= 0);
|
||||
assert_se(strv_extendf(&b, "test3 %s %s %d", "bar", "foo", 128) >= 0);
|
||||
|
||||
assert_se(streq(a[0], "test"));
|
||||
assert_se(streq(a[1], "test1"));
|
||||
assert_se(streq(a[2], "test2 foo 128 bar"));
|
||||
assert_se(streq(b[0], "test3 bar foo 128"));
|
||||
ASSERT_STREQ(a[0], "test");
|
||||
ASSERT_STREQ(a[1], "test1");
|
||||
ASSERT_STREQ(a[2], "test2 foo 128 bar");
|
||||
ASSERT_STREQ(b[0], "test3 bar foo 128");
|
||||
}
|
||||
|
||||
TEST(strv_foreach) {
|
||||
@ -640,7 +640,7 @@ TEST(strv_foreach) {
|
||||
assert_se(a);
|
||||
|
||||
STRV_FOREACH(check, a)
|
||||
assert_se(streq(*check, input_table_multiple[i++]));
|
||||
ASSERT_STREQ(*check, input_table_multiple[i++]);
|
||||
}
|
||||
|
||||
TEST(strv_foreach_backwards) {
|
||||
@ -652,7 +652,7 @@ TEST(strv_foreach_backwards) {
|
||||
assert_se(a);
|
||||
|
||||
STRV_FOREACH_BACKWARDS(check, a)
|
||||
assert_se(streq_ptr(*check, input_table_multiple[i--]));
|
||||
ASSERT_STREQ(*check, input_table_multiple[i--]);
|
||||
|
||||
STRV_FOREACH_BACKWARDS(check, (char**) NULL)
|
||||
assert_not_reached();
|
||||
@ -673,7 +673,7 @@ TEST(strv_foreach_pair) {
|
||||
"pair_two", "pair_two",
|
||||
"pair_three", "pair_three");
|
||||
STRV_FOREACH_PAIR(x, y, a)
|
||||
assert_se(streq(*x, *y));
|
||||
ASSERT_STREQ(*x, *y);
|
||||
}
|
||||
|
||||
static void test_strv_from_stdarg_alloca_one(char **l, const char *first, ...) {
|
||||
@ -685,7 +685,7 @@ static void test_strv_from_stdarg_alloca_one(char **l, const char *first, ...) {
|
||||
j = strv_from_stdarg_alloca(first);
|
||||
|
||||
for (i = 0;; i++) {
|
||||
assert_se(streq_ptr(l[i], j[i]));
|
||||
ASSERT_STREQ(l[i], j[i]);
|
||||
|
||||
if (!l[i])
|
||||
break;
|
||||
@ -702,29 +702,29 @@ TEST(strv_insert) {
|
||||
_cleanup_strv_free_ char **a = NULL;
|
||||
|
||||
assert_se(strv_insert(&a, 0, strdup("first")) == 0);
|
||||
assert_se(streq(a[0], "first"));
|
||||
ASSERT_STREQ(a[0], "first");
|
||||
assert_se(!a[1]);
|
||||
|
||||
assert_se(strv_insert(&a, 0, NULL) == 0);
|
||||
assert_se(streq(a[0], "first"));
|
||||
ASSERT_STREQ(a[0], "first");
|
||||
assert_se(!a[1]);
|
||||
|
||||
assert_se(strv_insert(&a, 1, strdup("two")) == 0);
|
||||
assert_se(streq(a[0], "first"));
|
||||
assert_se(streq(a[1], "two"));
|
||||
ASSERT_STREQ(a[0], "first");
|
||||
ASSERT_STREQ(a[1], "two");
|
||||
assert_se(!a[2]);
|
||||
|
||||
assert_se(strv_insert(&a, 4, strdup("tri")) == 0);
|
||||
assert_se(streq(a[0], "first"));
|
||||
assert_se(streq(a[1], "two"));
|
||||
assert_se(streq(a[2], "tri"));
|
||||
ASSERT_STREQ(a[0], "first");
|
||||
ASSERT_STREQ(a[1], "two");
|
||||
ASSERT_STREQ(a[2], "tri");
|
||||
assert_se(!a[3]);
|
||||
|
||||
assert_se(strv_insert(&a, 1, strdup("duo")) == 0);
|
||||
assert_se(streq(a[0], "first"));
|
||||
assert_se(streq(a[1], "duo"));
|
||||
assert_se(streq(a[2], "two"));
|
||||
assert_se(streq(a[3], "tri"));
|
||||
ASSERT_STREQ(a[0], "first");
|
||||
ASSERT_STREQ(a[1], "duo");
|
||||
ASSERT_STREQ(a[2], "two");
|
||||
ASSERT_STREQ(a[3], "tri");
|
||||
assert_se(!a[4]);
|
||||
}
|
||||
|
||||
@ -734,18 +734,18 @@ TEST(strv_push_prepend) {
|
||||
assert_se(a = strv_new("foo", "bar", "three"));
|
||||
|
||||
assert_se(strv_push_prepend(&a, strdup("first")) >= 0);
|
||||
assert_se(streq(a[0], "first"));
|
||||
assert_se(streq(a[1], "foo"));
|
||||
assert_se(streq(a[2], "bar"));
|
||||
assert_se(streq(a[3], "three"));
|
||||
ASSERT_STREQ(a[0], "first");
|
||||
ASSERT_STREQ(a[1], "foo");
|
||||
ASSERT_STREQ(a[2], "bar");
|
||||
ASSERT_STREQ(a[3], "three");
|
||||
assert_se(!a[4]);
|
||||
|
||||
assert_se(strv_consume_prepend(&a, strdup("first2")) >= 0);
|
||||
assert_se(streq(a[0], "first2"));
|
||||
assert_se(streq(a[1], "first"));
|
||||
assert_se(streq(a[2], "foo"));
|
||||
assert_se(streq(a[3], "bar"));
|
||||
assert_se(streq(a[4], "three"));
|
||||
ASSERT_STREQ(a[0], "first2");
|
||||
ASSERT_STREQ(a[1], "first");
|
||||
ASSERT_STREQ(a[2], "foo");
|
||||
ASSERT_STREQ(a[3], "bar");
|
||||
ASSERT_STREQ(a[4], "three");
|
||||
assert_se(!a[5]);
|
||||
}
|
||||
|
||||
@ -765,10 +765,10 @@ TEST(strv_push_with_size) {
|
||||
assert_se(strv_push_with_size(&a, &n, j) >= 0);
|
||||
assert_se(n == 3);
|
||||
|
||||
assert_se(streq_ptr(a[0], "foo"));
|
||||
assert_se(streq_ptr(a[1], "a"));
|
||||
assert_se(streq_ptr(a[2], "b"));
|
||||
assert_se(streq_ptr(a[3], NULL));
|
||||
ASSERT_STREQ(a[0], "foo");
|
||||
ASSERT_STREQ(a[1], "a");
|
||||
ASSERT_STREQ(a[2], "b");
|
||||
ASSERT_STREQ(a[3], NULL);
|
||||
|
||||
assert_se(n = strv_length(a));
|
||||
}
|
||||
@ -784,10 +784,10 @@ TEST(strv_push) {
|
||||
assert_se(j = strdup("b"));
|
||||
assert_se(strv_push_pair(&a, i, j) >= 0);
|
||||
|
||||
assert_se(streq_ptr(a[0], "foo"));
|
||||
assert_se(streq_ptr(a[1], "a"));
|
||||
assert_se(streq_ptr(a[2], "b"));
|
||||
assert_se(streq_ptr(a[3], NULL));
|
||||
ASSERT_STREQ(a[0], "foo");
|
||||
ASSERT_STREQ(a[1], "a");
|
||||
ASSERT_STREQ(a[2], "b");
|
||||
ASSERT_STREQ(a[3], NULL);
|
||||
}
|
||||
|
||||
TEST(strv_compare) {
|
||||
@ -849,23 +849,23 @@ TEST(strv_reverse) {
|
||||
b = strv_new("foo");
|
||||
assert_se(b);
|
||||
strv_reverse(b);
|
||||
assert_se(streq_ptr(b[0], "foo"));
|
||||
assert_se(streq_ptr(b[1], NULL));
|
||||
ASSERT_STREQ(b[0], "foo");
|
||||
ASSERT_STREQ(b[1], NULL);
|
||||
|
||||
c = strv_new("foo", "bar");
|
||||
assert_se(c);
|
||||
strv_reverse(c);
|
||||
assert_se(streq_ptr(c[0], "bar"));
|
||||
assert_se(streq_ptr(c[1], "foo"));
|
||||
assert_se(streq_ptr(c[2], NULL));
|
||||
ASSERT_STREQ(c[0], "bar");
|
||||
ASSERT_STREQ(c[1], "foo");
|
||||
ASSERT_STREQ(c[2], NULL);
|
||||
|
||||
d = strv_new("foo", "bar", "waldo");
|
||||
assert_se(d);
|
||||
strv_reverse(d);
|
||||
assert_se(streq_ptr(d[0], "waldo"));
|
||||
assert_se(streq_ptr(d[1], "bar"));
|
||||
assert_se(streq_ptr(d[2], "foo"));
|
||||
assert_se(streq_ptr(d[3], NULL));
|
||||
ASSERT_STREQ(d[0], "waldo");
|
||||
ASSERT_STREQ(d[1], "bar");
|
||||
ASSERT_STREQ(d[2], "foo");
|
||||
ASSERT_STREQ(d[3], NULL);
|
||||
}
|
||||
|
||||
TEST(strv_shell_escape) {
|
||||
@ -874,10 +874,10 @@ TEST(strv_shell_escape) {
|
||||
v = strv_new("foo:bar", "bar,baz", "wal\\do");
|
||||
assert_se(v);
|
||||
assert_se(strv_shell_escape(v, ",:"));
|
||||
assert_se(streq_ptr(v[0], "foo\\:bar"));
|
||||
assert_se(streq_ptr(v[1], "bar\\,baz"));
|
||||
assert_se(streq_ptr(v[2], "wal\\\\do"));
|
||||
assert_se(streq_ptr(v[3], NULL));
|
||||
ASSERT_STREQ(v[0], "foo\\:bar");
|
||||
ASSERT_STREQ(v[1], "bar\\,baz");
|
||||
ASSERT_STREQ(v[2], "wal\\\\do");
|
||||
ASSERT_STREQ(v[3], NULL);
|
||||
}
|
||||
|
||||
static void test_strv_skip_one(char **a, size_t n, char **b) {
|
||||
@ -911,13 +911,13 @@ TEST(strv_extend_n) {
|
||||
assert_se(strv_extend_n(&v, "waldo", 3) >= 0);
|
||||
assert_se(strv_extend_n(&v, "piep", 2) >= 0);
|
||||
|
||||
assert_se(streq(v[0], "foo"));
|
||||
assert_se(streq(v[1], "bar"));
|
||||
assert_se(streq(v[2], "waldo"));
|
||||
assert_se(streq(v[3], "waldo"));
|
||||
assert_se(streq(v[4], "waldo"));
|
||||
assert_se(streq(v[5], "piep"));
|
||||
assert_se(streq(v[6], "piep"));
|
||||
ASSERT_STREQ(v[0], "foo");
|
||||
ASSERT_STREQ(v[1], "bar");
|
||||
ASSERT_STREQ(v[2], "waldo");
|
||||
ASSERT_STREQ(v[3], "waldo");
|
||||
ASSERT_STREQ(v[4], "waldo");
|
||||
ASSERT_STREQ(v[5], "piep");
|
||||
ASSERT_STREQ(v[6], "piep");
|
||||
ASSERT_NULL(v[7]);
|
||||
|
||||
v = strv_free(v);
|
||||
@ -925,7 +925,7 @@ TEST(strv_extend_n) {
|
||||
assert_se(strv_extend_n(&v, "foo", 1) >= 0);
|
||||
assert_se(strv_extend_n(&v, "bar", 0) >= 0);
|
||||
|
||||
assert_se(streq(v[0], "foo"));
|
||||
ASSERT_STREQ(v[0], "foo");
|
||||
ASSERT_NULL(v[1]);
|
||||
}
|
||||
|
||||
@ -939,11 +939,11 @@ TEST(foreach_string) {
|
||||
|
||||
unsigned i = 0;
|
||||
FOREACH_STRING(x, "foo", "bar", "waldo")
|
||||
assert_se(streq_ptr(t[i++], x));
|
||||
ASSERT_STREQ(t[i++], x);
|
||||
assert_se(i == 3);
|
||||
|
||||
FOREACH_STRING(x, "zzz")
|
||||
assert_se(streq(x, "zzz"));
|
||||
ASSERT_STREQ(x, "zzz");
|
||||
}
|
||||
|
||||
TEST(strv_fnmatch) {
|
||||
@ -966,8 +966,8 @@ TEST(strv_extend_join) {
|
||||
assert_se(strv_extend_assignment(&v, "MISSING", NULL) >= 0);
|
||||
|
||||
assert_se(strv_length(v) == 2);
|
||||
assert_se(streq(v[0], "MESSAGE=ABC"));
|
||||
assert_se(streq(v[1], "ABC=QER"));
|
||||
ASSERT_STREQ(v[0], "MESSAGE=ABC");
|
||||
ASSERT_STREQ(v[1], "ABC=QER");
|
||||
}
|
||||
|
||||
TEST(strv_copy_n) {
|
||||
@ -1017,17 +1017,17 @@ TEST(strv_find_first_field) {
|
||||
ASSERT_NULL(strv_find_first_field(NULL, haystack));
|
||||
ASSERT_NULL(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "b"), NULL));
|
||||
ASSERT_NULL(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "b"), haystack));
|
||||
assert_se(streq_ptr(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "a", "c"), haystack), "b"));
|
||||
assert_se(streq_ptr(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "c", "a"), haystack), "d"));
|
||||
assert_se(streq_ptr(strv_find_first_field(STRV_MAKE("i", "k", "l", "m", "d", "c", "a", "b"), haystack), "j"));
|
||||
ASSERT_STREQ(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "a", "c"), haystack), "b");
|
||||
ASSERT_STREQ(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "c", "a"), haystack), "d");
|
||||
ASSERT_STREQ(strv_find_first_field(STRV_MAKE("i", "k", "l", "m", "d", "c", "a", "b"), haystack), "j");
|
||||
}
|
||||
|
||||
TEST(endswith_strv) {
|
||||
assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("xxx", "yyy", "ldo", "zzz")), "ldo"));
|
||||
assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("xxx", "yyy", "zzz")), NULL));
|
||||
assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("waldo")), "waldo"));
|
||||
assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("w", "o", "ldo")), "o"));
|
||||
assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("knurz", "", "waldo")), ""));
|
||||
ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("xxx", "yyy", "ldo", "zzz")), "ldo");
|
||||
ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("xxx", "yyy", "zzz")), NULL);
|
||||
ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("waldo")), "waldo");
|
||||
ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("w", "o", "ldo")), "o");
|
||||
ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("knurz", "", "waldo")), "");
|
||||
}
|
||||
|
||||
TEST(strv_extend_many) {
|
||||
|
||||
@ -24,27 +24,27 @@ TEST(strpcpy) {
|
||||
space_left = strpcpy_full(&s, space_left, "r", &truncated);
|
||||
assert_se(!truncated);
|
||||
assert_se(space_left == 1);
|
||||
assert_se(streq(target, "12345hey hey heywaldobar"));
|
||||
ASSERT_STREQ(target, "12345hey hey heywaldobar");
|
||||
|
||||
space_left = strpcpy_full(&s, space_left, "", &truncated);
|
||||
assert_se(!truncated);
|
||||
assert_se(space_left == 1);
|
||||
assert_se(streq(target, "12345hey hey heywaldobar"));
|
||||
ASSERT_STREQ(target, "12345hey hey heywaldobar");
|
||||
|
||||
space_left = strpcpy_full(&s, space_left, "f", &truncated);
|
||||
assert_se(truncated);
|
||||
assert_se(space_left == 0);
|
||||
assert_se(streq(target, "12345hey hey heywaldobar"));
|
||||
ASSERT_STREQ(target, "12345hey hey heywaldobar");
|
||||
|
||||
space_left = strpcpy_full(&s, space_left, "", &truncated);
|
||||
assert_se(!truncated);
|
||||
assert_se(space_left == 0);
|
||||
assert_se(streq(target, "12345hey hey heywaldobar"));
|
||||
ASSERT_STREQ(target, "12345hey hey heywaldobar");
|
||||
|
||||
space_left = strpcpy_full(&s, space_left, "foo", &truncated);
|
||||
assert_se(truncated);
|
||||
assert_se(space_left == 0);
|
||||
assert_se(streq(target, "12345hey hey heywaldobar"));
|
||||
ASSERT_STREQ(target, "12345hey hey heywaldobar");
|
||||
}
|
||||
|
||||
TEST(strpcpyf) {
|
||||
@ -59,38 +59,38 @@ TEST(strpcpyf) {
|
||||
space_left = strpcpyf_full(&s, space_left, &truncated, "foo%s", "bar");
|
||||
assert_se(!truncated);
|
||||
assert_se(space_left == 3);
|
||||
assert_se(streq(target, "space left: 25. foobar"));
|
||||
ASSERT_STREQ(target, "space left: 25. foobar");
|
||||
|
||||
space_left = strpcpyf_full(&s, space_left, &truncated, "%i", 42);
|
||||
assert_se(!truncated);
|
||||
assert_se(space_left == 1);
|
||||
assert_se(streq(target, "space left: 25. foobar42"));
|
||||
ASSERT_STREQ(target, "space left: 25. foobar42");
|
||||
|
||||
space_left = strpcpyf_full(&s, space_left, &truncated, "%s", "");
|
||||
assert_se(!truncated);
|
||||
assert_se(space_left == 1);
|
||||
assert_se(streq(target, "space left: 25. foobar42"));
|
||||
ASSERT_STREQ(target, "space left: 25. foobar42");
|
||||
|
||||
space_left = strpcpyf_full(&s, space_left, &truncated, "%c", 'x');
|
||||
assert_se(truncated);
|
||||
assert_se(space_left == 0);
|
||||
assert_se(streq(target, "space left: 25. foobar42"));
|
||||
ASSERT_STREQ(target, "space left: 25. foobar42");
|
||||
|
||||
space_left = strpcpyf_full(&s, space_left, &truncated, "%s", "");
|
||||
assert_se(!truncated);
|
||||
assert_se(space_left == 0);
|
||||
assert_se(streq(target, "space left: 25. foobar42"));
|
||||
ASSERT_STREQ(target, "space left: 25. foobar42");
|
||||
|
||||
space_left = strpcpyf_full(&s, space_left, &truncated, "abc%s", "hoge");
|
||||
assert_se(truncated);
|
||||
assert_se(space_left == 0);
|
||||
assert_se(streq(target, "space left: 25. foobar42"));
|
||||
ASSERT_STREQ(target, "space left: 25. foobar42");
|
||||
|
||||
/* test overflow */
|
||||
s = target;
|
||||
space_left = strpcpyf_full(&s, 12, &truncated, "00 left: %i. ", 999);
|
||||
assert_se(truncated);
|
||||
assert_se(streq(target, "00 left: 99"));
|
||||
ASSERT_STREQ(target, "00 left: 99");
|
||||
assert_se(space_left == 0);
|
||||
assert_se(target[12] == '2');
|
||||
}
|
||||
@ -107,22 +107,22 @@ TEST(strpcpyl) {
|
||||
space_left = strpcpyl_full(&s, space_left, &truncated, "Banana", NULL);
|
||||
assert_se(!truncated);
|
||||
assert_se(space_left == 1);
|
||||
assert_se(streq(target, "waldo test waldo. Banana"));
|
||||
ASSERT_STREQ(target, "waldo test waldo. Banana");
|
||||
|
||||
space_left = strpcpyl_full(&s, space_left, &truncated, "", "", "", NULL);
|
||||
assert_se(!truncated);
|
||||
assert_se(space_left == 1);
|
||||
assert_se(streq(target, "waldo test waldo. Banana"));
|
||||
ASSERT_STREQ(target, "waldo test waldo. Banana");
|
||||
|
||||
space_left = strpcpyl_full(&s, space_left, &truncated, "", "x", "", NULL);
|
||||
assert_se(truncated);
|
||||
assert_se(space_left == 0);
|
||||
assert_se(streq(target, "waldo test waldo. Banana"));
|
||||
ASSERT_STREQ(target, "waldo test waldo. Banana");
|
||||
|
||||
space_left = strpcpyl_full(&s, space_left, &truncated, "hoge", NULL);
|
||||
assert_se(truncated);
|
||||
assert_se(space_left == 0);
|
||||
assert_se(streq(target, "waldo test waldo. Banana"));
|
||||
ASSERT_STREQ(target, "waldo test waldo. Banana");
|
||||
}
|
||||
|
||||
TEST(strscpy) {
|
||||
@ -134,7 +134,7 @@ TEST(strscpy) {
|
||||
space_left = strscpy_full(target, space_left, "12345", &truncated);
|
||||
assert_se(!truncated);
|
||||
|
||||
assert_se(streq(target, "12345"));
|
||||
ASSERT_STREQ(target, "12345");
|
||||
assert_se(space_left == 20);
|
||||
}
|
||||
|
||||
@ -147,7 +147,7 @@ TEST(strscpyl) {
|
||||
space_left = strscpyl_full(target, space_left, &truncated, "12345", "waldo", "waldo", NULL);
|
||||
assert_se(!truncated);
|
||||
|
||||
assert_se(streq(target, "12345waldowaldo"));
|
||||
ASSERT_STREQ(target, "12345waldowaldo");
|
||||
assert_se(space_left == 10);
|
||||
}
|
||||
|
||||
@ -169,7 +169,7 @@ TEST(sd_event_code_migration) {
|
||||
for (i = 0; i < 100; i++)
|
||||
l = strpcpyf(&p, l, "%u ", i);
|
||||
|
||||
assert_se(streq(b, c));
|
||||
ASSERT_STREQ(b, c);
|
||||
}
|
||||
|
||||
DEFINE_TEST_MAIN(LOG_INFO);
|
||||
|
||||
@ -34,7 +34,7 @@ TEST(sysctl_normalize) {
|
||||
assert_se(sysctl_normalize(t) == t);
|
||||
|
||||
log_info("\"%s\" → \"%s\", expected \"%s\"", *s, t, *expected);
|
||||
assert_se(streq(t, *expected));
|
||||
ASSERT_STREQ(t, *expected);
|
||||
}
|
||||
}
|
||||
|
||||
@ -66,7 +66,7 @@ TEST(sysctl_read) {
|
||||
|
||||
assert_se(sysctl_read("kernel/hostname", &s) >= 0);
|
||||
assert_se(uname(&u) >= 0);
|
||||
assert_se(streq_ptr(s, u.nodename));
|
||||
ASSERT_STREQ(s, u.nodename);
|
||||
|
||||
r = sysctl_write("kernel/hostname", s);
|
||||
assert_se(r >= 0 || ERRNO_IS_PRIVILEGE(r) || r == -EROFS);
|
||||
|
||||
@ -413,7 +413,7 @@ static void test_format_timestamp_impl(usec_t x) {
|
||||
override ? ", ignoring." : "");
|
||||
if (!override) {
|
||||
assert_se(x / USEC_PER_SEC == y / USEC_PER_SEC);
|
||||
assert_se(streq(xx, yy));
|
||||
ASSERT_STREQ(xx, yy);
|
||||
}
|
||||
}
|
||||
|
||||
@ -482,69 +482,69 @@ TEST(format_timestamp_relative_full) {
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_YEAR + 1*USEC_PER_MONTH);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 year 1 month ago"));
|
||||
ASSERT_STREQ(buf, "1 year 1 month ago");
|
||||
|
||||
x = now(CLOCK_MONOTONIC) + (1*USEC_PER_YEAR + 1.5*USEC_PER_MONTH);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_MONOTONIC, false));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 year 1 month left"));
|
||||
ASSERT_STREQ(buf, "1 year 1 month left");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_YEAR + 2*USEC_PER_MONTH);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 year 2 months ago"));
|
||||
ASSERT_STREQ(buf, "1 year 2 months ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_YEAR + 1*USEC_PER_MONTH);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 years 1 month ago"));
|
||||
ASSERT_STREQ(buf, "2 years 1 month ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_YEAR + 2*USEC_PER_MONTH);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 years 2 months ago"));
|
||||
ASSERT_STREQ(buf, "2 years 2 months ago");
|
||||
|
||||
/* Months and days */
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_MONTH + 1*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 month 1 day ago"));
|
||||
ASSERT_STREQ(buf, "1 month 1 day ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_MONTH + 2*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 month 2 days ago"));
|
||||
ASSERT_STREQ(buf, "1 month 2 days ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_MONTH + 1*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 months 1 day ago"));
|
||||
ASSERT_STREQ(buf, "2 months 1 day ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_MONTH + 2*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 months 2 days ago"));
|
||||
ASSERT_STREQ(buf, "2 months 2 days ago");
|
||||
|
||||
/* Weeks and days */
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_WEEK + 1*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 week 1 day ago"));
|
||||
ASSERT_STREQ(buf, "1 week 1 day ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_WEEK + 2*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 week 2 days ago"));
|
||||
ASSERT_STREQ(buf, "1 week 2 days ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_WEEK + 1*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 weeks 1 day ago"));
|
||||
ASSERT_STREQ(buf, "2 weeks 1 day ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_WEEK + 2*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 weeks 2 days ago"));
|
||||
ASSERT_STREQ(buf, "2 weeks 2 days ago");
|
||||
}
|
||||
|
||||
TEST(format_timestamp_relative) {
|
||||
@ -559,64 +559,64 @@ TEST(format_timestamp_relative) {
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_YEAR + 1*USEC_PER_MONTH);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 year 1 month ago"));
|
||||
ASSERT_STREQ(buf, "1 year 1 month ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_YEAR + 2*USEC_PER_MONTH);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 year 2 months ago"));
|
||||
ASSERT_STREQ(buf, "1 year 2 months ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_YEAR + 1*USEC_PER_MONTH);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 years 1 month ago"));
|
||||
ASSERT_STREQ(buf, "2 years 1 month ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_YEAR + 2*USEC_PER_MONTH);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 years 2 months ago"));
|
||||
ASSERT_STREQ(buf, "2 years 2 months ago");
|
||||
|
||||
/* Months and days */
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_MONTH + 1*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 month 1 day ago"));
|
||||
ASSERT_STREQ(buf, "1 month 1 day ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_MONTH + 2*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 month 2 days ago"));
|
||||
ASSERT_STREQ(buf, "1 month 2 days ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_MONTH + 1*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 months 1 day ago"));
|
||||
ASSERT_STREQ(buf, "2 months 1 day ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_MONTH + 2*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 months 2 days ago"));
|
||||
ASSERT_STREQ(buf, "2 months 2 days ago");
|
||||
|
||||
/* Weeks and days */
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_WEEK + 1*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 week 1 day ago"));
|
||||
ASSERT_STREQ(buf, "1 week 1 day ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (1*USEC_PER_WEEK + 2*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "1 week 2 days ago"));
|
||||
ASSERT_STREQ(buf, "1 week 2 days ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_WEEK + 1*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 weeks 1 day ago"));
|
||||
ASSERT_STREQ(buf, "2 weeks 1 day ago");
|
||||
|
||||
x = now(CLOCK_REALTIME) - (2*USEC_PER_WEEK + 2*USEC_PER_DAY);
|
||||
assert_se(format_timestamp_relative(buf, sizeof(buf), x));
|
||||
log_debug("%s", buf);
|
||||
assert_se(streq(buf, "2 weeks 2 days ago"));
|
||||
ASSERT_STREQ(buf, "2 weeks 2 days ago");
|
||||
}
|
||||
|
||||
static void test_format_timestamp_one(usec_t val, TimestampStyle style, const char *result) {
|
||||
@ -624,7 +624,7 @@ static void test_format_timestamp_one(usec_t val, TimestampStyle style, const ch
|
||||
const char *t;
|
||||
|
||||
t = format_timestamp_style(buf, sizeof(buf), val, style);
|
||||
assert_se(streq_ptr(t, result));
|
||||
ASSERT_STREQ(t, result);
|
||||
}
|
||||
|
||||
TEST(format_timestamp_range) {
|
||||
@ -1062,15 +1062,15 @@ TEST(in_utc_timezone) {
|
||||
|
||||
assert_se(setenv("TZ", ":UTC", 1) >= 0);
|
||||
assert_se(in_utc_timezone());
|
||||
assert_se(streq(tzname[0], "UTC"));
|
||||
assert_se(streq(tzname[1], "UTC"));
|
||||
ASSERT_STREQ(tzname[0], "UTC");
|
||||
ASSERT_STREQ(tzname[1], "UTC");
|
||||
assert_se(timezone == 0);
|
||||
assert_se(daylight == 0);
|
||||
|
||||
assert_se(setenv("TZ", ":Europe/Berlin", 1) >= 0);
|
||||
assert_se(!in_utc_timezone());
|
||||
assert_se(streq(tzname[0], "CET"));
|
||||
assert_se(streq(tzname[1], "CEST"));
|
||||
ASSERT_STREQ(tzname[0], "CET");
|
||||
ASSERT_STREQ(tzname[1], "CEST");
|
||||
|
||||
assert_se(set_unset_env("TZ", tz, true) == 0);
|
||||
tzset();
|
||||
@ -1114,14 +1114,14 @@ static void test_timezone_offset_change_one(const char *utc, const char *pretty)
|
||||
s = FORMAT_TIMESTAMP_STYLE(x, TIMESTAMP_UTC);
|
||||
assert_se(parse_timestamp(s, &y) >= 0);
|
||||
log_debug("%s -> " USEC_FMT " -> %s -> " USEC_FMT, utc, x, s, y);
|
||||
assert_se(streq(s, utc));
|
||||
ASSERT_STREQ(s, utc);
|
||||
assert_se(x == y);
|
||||
|
||||
assert_se(parse_timestamp(pretty, &y) >= 0);
|
||||
s = FORMAT_TIMESTAMP_STYLE(y, TIMESTAMP_PRETTY);
|
||||
assert_se(parse_timestamp(s, &z) >= 0);
|
||||
log_debug("%s -> " USEC_FMT " -> %s -> " USEC_FMT, pretty, y, s, z);
|
||||
assert_se(streq(s, pretty));
|
||||
ASSERT_STREQ(s, pretty);
|
||||
assert_se(x == y);
|
||||
assert_se(x == z);
|
||||
}
|
||||
|
||||
@ -105,7 +105,7 @@ static void test_tempfn_xxxxxx_one(const char *p, const char *extra, const char
|
||||
const char *suffix;
|
||||
|
||||
assert_se(suffix = startswith(s, expect));
|
||||
assert_se(streq(suffix, "XXXXXX"));
|
||||
ASSERT_STREQ(suffix, "XXXXXX");
|
||||
}
|
||||
assert_se(ret == r);
|
||||
}
|
||||
@ -283,7 +283,7 @@ TEST(link_tmpfile) {
|
||||
assert_se(link_tmpfile(fd, tmp, d, /* flags= */ 0) >= 0);
|
||||
|
||||
assert_se(read_one_line_file(d, &line) >= 0);
|
||||
assert_se(streq(line, "foobar"));
|
||||
ASSERT_STREQ(line, "foobar");
|
||||
|
||||
fd = safe_close(fd);
|
||||
tmp = mfree(tmp);
|
||||
@ -298,7 +298,7 @@ TEST(link_tmpfile) {
|
||||
|
||||
line = mfree(line);
|
||||
assert_se(read_one_line_file(d, &line) >= 0);
|
||||
assert_se(streq(line, "waumiau"));
|
||||
ASSERT_STREQ(line, "waumiau");
|
||||
|
||||
assert_se(unlink(d) >= 0);
|
||||
}
|
||||
|
||||
@ -199,7 +199,7 @@ static void _test_tpms_sw(
|
||||
tpm2_tpms_pcr_selection_from_mask(mask, hash, &s);
|
||||
|
||||
_cleanup_free_ char *tpms_str = tpm2_tpms_pcr_selection_to_string(&s);
|
||||
assert_se(streq(tpms_str, expected_str));
|
||||
ASSERT_STREQ(tpms_str, expected_str);
|
||||
|
||||
assert_se(tpm2_tpms_pcr_selection_weight(&s) == expected_weight);
|
||||
assert_se(tpm2_tpms_pcr_selection_is_empty(&s) == (expected_weight == 0));
|
||||
@ -242,7 +242,7 @@ static void _test_tpml_sw(
|
||||
assert_se(l.count == expected_count);
|
||||
|
||||
_cleanup_free_ char *tpml_str = tpm2_tpml_pcr_selection_to_string(&l);
|
||||
assert_se(streq(tpml_str, expected_str));
|
||||
ASSERT_STREQ(tpml_str, expected_str);
|
||||
|
||||
assert_se(tpm2_tpml_pcr_selection_weight(&l) == expected_weight);
|
||||
assert_se(tpm2_tpml_pcr_selection_is_empty(&l) == (expected_weight == 0));
|
||||
|
||||
@ -16,7 +16,7 @@ static void test_udev_replace_whitespace_one_len(const char *str, size_t len, co
|
||||
assert_se(result);
|
||||
r = udev_replace_whitespace(str, result, len);
|
||||
assert_se((size_t) r == strlen(expected));
|
||||
assert_se(streq(result, expected));
|
||||
ASSERT_STREQ(result, expected);
|
||||
}
|
||||
|
||||
static void test_udev_replace_whitespace_one(const char *str, const char *expected) {
|
||||
|
||||
@ -88,18 +88,18 @@ TEST(unit_file_build_name_map) {
|
||||
|
||||
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.unknown-runlevel"), NULL));
|
||||
assert_se(streq_ptr(runlevel_to_target("3"), SPECIAL_MULTI_USER_TARGET));
|
||||
assert_se(streq_ptr(runlevel_to_target("rd.rescue"), NULL));
|
||||
ASSERT_STREQ(runlevel_to_target(NULL), NULL);
|
||||
ASSERT_STREQ(runlevel_to_target("unknown-runlevel"), NULL);
|
||||
ASSERT_STREQ(runlevel_to_target("rd.unknown-runlevel"), NULL);
|
||||
ASSERT_STREQ(runlevel_to_target("3"), SPECIAL_MULTI_USER_TARGET);
|
||||
ASSERT_STREQ(runlevel_to_target("rd.rescue"), NULL);
|
||||
|
||||
in_initrd_force(true);
|
||||
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.unknown-runlevel"), NULL));
|
||||
assert_se(streq_ptr(runlevel_to_target("3"), NULL));
|
||||
assert_se(streq_ptr(runlevel_to_target("rd.rescue"), SPECIAL_RESCUE_TARGET));
|
||||
ASSERT_STREQ(runlevel_to_target(NULL), NULL);
|
||||
ASSERT_STREQ(runlevel_to_target("unknown-runlevel"), NULL);
|
||||
ASSERT_STREQ(runlevel_to_target("rd.unknown-runlevel"), NULL);
|
||||
ASSERT_STREQ(runlevel_to_target("3"), NULL);
|
||||
ASSERT_STREQ(runlevel_to_target("rd.rescue"), SPECIAL_RESCUE_TARGET);
|
||||
}
|
||||
|
||||
static int intro(void) {
|
||||
|
||||
@ -92,7 +92,7 @@ static void test_unit_name_replace_instance_one(const char *pattern, const char
|
||||
_cleanup_free_ char *t = NULL;
|
||||
assert_se(unit_name_replace_instance(pattern, repl, &t) == ret);
|
||||
puts(strna(t));
|
||||
assert_se(streq_ptr(t, expected));
|
||||
ASSERT_STREQ(t, expected);
|
||||
}
|
||||
|
||||
TEST(unit_name_replace_instance) {
|
||||
@ -112,7 +112,7 @@ static void test_unit_name_from_path_one(const char *path, const char *suffix, c
|
||||
|
||||
assert_se(unit_name_from_path(path, suffix, &t) == ret);
|
||||
puts(strna(t));
|
||||
assert_se(streq_ptr(t, expected));
|
||||
ASSERT_STREQ(t, expected);
|
||||
|
||||
if (t) {
|
||||
_cleanup_free_ char *k = NULL;
|
||||
@ -159,7 +159,7 @@ static void test_unit_name_from_path_instance_one(const char *pattern, const cha
|
||||
|
||||
assert_se(unit_name_from_path_instance(pattern, path, suffix, &t) == ret);
|
||||
puts(strna(t));
|
||||
assert_se(streq_ptr(t, expected));
|
||||
ASSERT_STREQ(t, expected);
|
||||
|
||||
if (t) {
|
||||
_cleanup_free_ char *k = NULL, *v = NULL;
|
||||
@ -185,7 +185,7 @@ static void test_unit_name_to_path_one(const char *unit, const char *path, int r
|
||||
_cleanup_free_ char *p = NULL;
|
||||
|
||||
assert_se(unit_name_to_path(unit, &p) == ret);
|
||||
assert_se(streq_ptr(path, p));
|
||||
ASSERT_STREQ(path, p);
|
||||
}
|
||||
|
||||
TEST(unit_name_to_path) {
|
||||
@ -208,7 +208,7 @@ static void test_unit_name_mangle_one(bool allow_globs, const char *pattern, con
|
||||
|
||||
assert_se(r == ret);
|
||||
puts(strna(t));
|
||||
assert_se(streq_ptr(t, expect));
|
||||
ASSERT_STREQ(t, expect);
|
||||
|
||||
if (t) {
|
||||
_cleanup_free_ char *k = NULL;
|
||||
@ -217,7 +217,7 @@ static void test_unit_name_mangle_one(bool allow_globs, const char *pattern, con
|
||||
(allow_globs && string_is_glob(t)));
|
||||
|
||||
assert_se(unit_name_mangle(t, (allow_globs * UNIT_NAME_MANGLE_GLOB) | UNIT_NAME_MANGLE_WARN, &k) == 0);
|
||||
assert_se(streq_ptr(t, k));
|
||||
ASSERT_STREQ(t, k);
|
||||
}
|
||||
}
|
||||
|
||||
@ -246,7 +246,7 @@ static void test_unit_name_mangle_with_suffix_one(const char *arg, int expected,
|
||||
log_debug("%s: %s -> %d, %s", __func__, arg, r, strnull(s));
|
||||
|
||||
assert_se(r == expected);
|
||||
assert_se(streq_ptr(s, expected_name));
|
||||
ASSERT_STREQ(s, expected_name);
|
||||
}
|
||||
|
||||
TEST(unit_name_mangle_with_suffix) {
|
||||
@ -499,11 +499,11 @@ TEST(unit_name_change_suffix) {
|
||||
char *t;
|
||||
|
||||
assert_se(unit_name_change_suffix("foo.mount", ".service", &t) == 0);
|
||||
assert_se(streq(t, "foo.service"));
|
||||
ASSERT_STREQ(t, "foo.service");
|
||||
free(t);
|
||||
|
||||
assert_se(unit_name_change_suffix("foo@stuff.service", ".socket", &t) == 0);
|
||||
assert_se(streq(t, "foo@stuff.socket"));
|
||||
ASSERT_STREQ(t, "foo@stuff.socket");
|
||||
free(t);
|
||||
}
|
||||
|
||||
@ -511,15 +511,15 @@ TEST(unit_name_build) {
|
||||
char *t;
|
||||
|
||||
assert_se(unit_name_build("foo", "bar", ".service", &t) == 0);
|
||||
assert_se(streq(t, "foo@bar.service"));
|
||||
ASSERT_STREQ(t, "foo@bar.service");
|
||||
free(t);
|
||||
|
||||
assert_se(unit_name_build("fo0-stUff_b", "bar", ".mount", &t) == 0);
|
||||
assert_se(streq(t, "fo0-stUff_b@bar.mount"));
|
||||
ASSERT_STREQ(t, "fo0-stUff_b@bar.mount");
|
||||
free(t);
|
||||
|
||||
assert_se(unit_name_build("foo", NULL, ".service", &t) == 0);
|
||||
assert_se(streq(t, "foo.service"));
|
||||
ASSERT_STREQ(t, "foo.service");
|
||||
free(t);
|
||||
}
|
||||
|
||||
@ -563,7 +563,7 @@ TEST(build_subslice) {
|
||||
free(b);
|
||||
assert_se(slice_build_subslice(a, "foobar", &b) >= 0);
|
||||
free(a);
|
||||
assert_se(streq(b, "foo-bar-barfoo-foobar.slice"));
|
||||
ASSERT_STREQ(b, "foo-bar-barfoo-foobar.slice");
|
||||
free(b);
|
||||
|
||||
assert_se(slice_build_subslice("foo.service", "bar", &a) < 0);
|
||||
@ -574,7 +574,7 @@ static void test_build_parent_slice_one(const char *name, const char *expect, in
|
||||
_cleanup_free_ char *s = NULL;
|
||||
|
||||
assert_se(slice_build_parent_slice(name, &s) == ret);
|
||||
assert_se(streq_ptr(s, expect));
|
||||
ASSERT_STREQ(s, expect);
|
||||
}
|
||||
|
||||
TEST(build_parent_slice) {
|
||||
@ -602,17 +602,17 @@ TEST(unit_name_to_instance) {
|
||||
|
||||
r = unit_name_to_instance("foo@bar.service", &instance);
|
||||
assert_se(r == UNIT_NAME_INSTANCE);
|
||||
assert_se(streq(instance, "bar"));
|
||||
ASSERT_STREQ(instance, "bar");
|
||||
free(instance);
|
||||
|
||||
r = unit_name_to_instance("foo@.service", &instance);
|
||||
assert_se(r == UNIT_NAME_TEMPLATE);
|
||||
assert_se(streq(instance, ""));
|
||||
ASSERT_STREQ(instance, "");
|
||||
free(instance);
|
||||
|
||||
r = unit_name_to_instance("fo0-stUff_b@b.service", &instance);
|
||||
assert_se(r == UNIT_NAME_INSTANCE);
|
||||
assert_se(streq(instance, "b"));
|
||||
ASSERT_STREQ(instance, "b");
|
||||
free(instance);
|
||||
|
||||
r = unit_name_to_instance("foo.service", &instance);
|
||||
@ -633,7 +633,7 @@ TEST(unit_name_escape) {
|
||||
|
||||
r = unit_name_escape("ab+-c.a/bc@foo.service");
|
||||
assert_se(r);
|
||||
assert_se(streq(r, "ab\\x2b\\x2dc.a-bc\\x40foo.service"));
|
||||
ASSERT_STREQ(r, "ab\\x2b\\x2dc.a-bc\\x40foo.service");
|
||||
}
|
||||
|
||||
static void test_u_n_t_one(const char *name, const char *expected, int ret) {
|
||||
@ -641,7 +641,7 @@ static void test_u_n_t_one(const char *name, const char *expected, int ret) {
|
||||
|
||||
assert_se(unit_name_template(name, &f) == ret);
|
||||
printf("got: %s, expected: %s\n", strna(f), strna(expected));
|
||||
assert_se(streq_ptr(f, expected));
|
||||
ASSERT_STREQ(f, expected);
|
||||
}
|
||||
|
||||
TEST(unit_name_template) {
|
||||
@ -653,7 +653,7 @@ static void test_unit_name_path_unescape_one(const char *name, const char *path,
|
||||
_cleanup_free_ char *p = NULL;
|
||||
|
||||
assert_se(unit_name_path_unescape(name, &p) == ret);
|
||||
assert_se(streq_ptr(path, p));
|
||||
ASSERT_STREQ(path, p);
|
||||
}
|
||||
|
||||
TEST(unit_name_path_unescape) {
|
||||
@ -675,7 +675,7 @@ static void test_unit_name_to_prefix_one(const char *input, int ret, const char
|
||||
_cleanup_free_ char *k = NULL;
|
||||
|
||||
assert_se(unit_name_to_prefix(input, &k) == ret);
|
||||
assert_se(streq_ptr(k, output));
|
||||
ASSERT_STREQ(k, output);
|
||||
}
|
||||
|
||||
TEST(unit_name_to_prefix) {
|
||||
@ -695,7 +695,7 @@ static void test_unit_name_from_dbus_path_one(const char *input, int ret, const
|
||||
_cleanup_free_ char *k = NULL;
|
||||
|
||||
assert_se(unit_name_from_dbus_path(input, &k) == ret);
|
||||
assert_se(streq_ptr(k, output));
|
||||
ASSERT_STREQ(k, output);
|
||||
}
|
||||
|
||||
TEST(unit_name_from_dbus_path) {
|
||||
|
||||
@ -21,7 +21,7 @@ static void test_uid_to_name_one(uid_t uid, const char *name) {
|
||||
log_info("(skipping detailed tests because nobody is not synthesized)");
|
||||
return;
|
||||
}
|
||||
assert_se(streq_ptr(t, name));
|
||||
ASSERT_STREQ(t, name);
|
||||
}
|
||||
|
||||
TEST(uid_to_name) {
|
||||
@ -41,7 +41,7 @@ static void test_gid_to_name_one(gid_t gid, const char *name) {
|
||||
log_info("(skipping detailed tests because nobody is not synthesized)");
|
||||
return;
|
||||
}
|
||||
assert_se(streq_ptr(t, name));
|
||||
ASSERT_STREQ(t, name);
|
||||
}
|
||||
|
||||
TEST(gid_to_name) {
|
||||
@ -338,7 +338,7 @@ static void test_get_user_creds_one(const char *id, const char *name, uid_t uid,
|
||||
return;
|
||||
}
|
||||
assert_se(r == 0);
|
||||
assert_se(streq_ptr(id, name));
|
||||
ASSERT_STREQ(id, name);
|
||||
assert_se(ruid == uid);
|
||||
assert_se(rgid == gid);
|
||||
assert_se(path_equal(rhome, home));
|
||||
@ -364,7 +364,7 @@ static void test_get_group_creds_one(const char *id, const char *name, gid_t gid
|
||||
return;
|
||||
}
|
||||
assert_se(r == 0);
|
||||
assert_se(streq_ptr(id, name));
|
||||
ASSERT_STREQ(id, name);
|
||||
assert_se(rgid == gid);
|
||||
}
|
||||
|
||||
@ -466,7 +466,7 @@ static void test_mangle_gecos_one(const char *input, const char *expected) {
|
||||
_cleanup_free_ char *p = NULL;
|
||||
|
||||
assert_se(p = mangle_gecos(input));
|
||||
assert_se(streq(p, expected));
|
||||
ASSERT_STREQ(p, expected);
|
||||
assert_se(valid_gecos(p));
|
||||
}
|
||||
|
||||
|
||||
@ -62,7 +62,7 @@ static void test_utf8_to_ascii_one(const char *s, int r_expected, const char *ex
|
||||
r = utf8_to_ascii(s, '*', &ans);
|
||||
log_debug("\"%s\" → %d/\"%s\" (expected %d/\"%s\")", s, r, strnull(ans), r_expected, strnull(expected));
|
||||
assert_se(r == r_expected);
|
||||
assert_se(streq_ptr(ans, expected));
|
||||
ASSERT_STREQ(ans, expected);
|
||||
}
|
||||
|
||||
TEST(utf8_to_ascii) {
|
||||
@ -223,7 +223,7 @@ TEST(utf8_to_utf16) {
|
||||
|
||||
b = utf16_to_utf8(a, SIZE_MAX);
|
||||
assert_se(b);
|
||||
assert_se(streq(p, b));
|
||||
ASSERT_STREQ(p, b);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -123,7 +123,7 @@ static void test_parse_format_one(const VarlinkInterface *iface) {
|
||||
assert_se(varlink_idl_parse(text, NULL, NULL, &parsed) >= 0);
|
||||
assert_se(varlink_idl_consistent(parsed, LOG_ERR) >= 0);
|
||||
assert_se(varlink_idl_format(parsed, &text2) >= 0);
|
||||
assert_se(streq(text, text2));
|
||||
ASSERT_STREQ(text, text2);
|
||||
}
|
||||
|
||||
TEST(parse_format) {
|
||||
@ -387,13 +387,13 @@ TEST(validate_method_call) {
|
||||
JSON_BUILD_PAIR_UNSIGNED("foo", 8),
|
||||
JSON_BUILD_PAIR_UNSIGNED("bar", 9),
|
||||
JSON_BUILD_PAIR_STRING("zzz", "pfft"))) >= 0);
|
||||
assert_se(streq_ptr(error_id, VARLINK_ERROR_INVALID_PARAMETER));
|
||||
ASSERT_STREQ(error_id, VARLINK_ERROR_INVALID_PARAMETER);
|
||||
|
||||
assert_se(varlink_callb(v, "xyz.TestMethod", &reply, &error_id,
|
||||
JSON_BUILD_OBJECT(
|
||||
JSON_BUILD_PAIR_BOOLEAN("foo", true),
|
||||
JSON_BUILD_PAIR_UNSIGNED("bar", 9))) >= 0);
|
||||
assert_se(streq_ptr(error_id, VARLINK_ERROR_INVALID_PARAMETER));
|
||||
ASSERT_STREQ(error_id, VARLINK_ERROR_INVALID_PARAMETER);
|
||||
|
||||
assert_se(varlink_send(v, "xyz.Done", NULL) >= 0);
|
||||
assert_se(varlink_flush(v) >= 0);
|
||||
|
||||
@ -107,7 +107,7 @@ static int method_passfd(Varlink *link, JsonVariant *parameters, VarlinkMethodFl
|
||||
if (!a)
|
||||
return varlink_error(link, "io.test.BadParameters", NULL);
|
||||
|
||||
assert_se(streq_ptr(json_variant_string(a), "whoop"));
|
||||
ASSERT_STREQ(json_variant_string(a), "whoop");
|
||||
|
||||
int xx = varlink_peek_fd(link, 0),
|
||||
yy = varlink_peek_fd(link, 1),
|
||||
@ -183,7 +183,7 @@ static int overload_reply(Varlink *link, JsonVariant *parameters, const char *er
|
||||
* be talking to an overloaded server */
|
||||
|
||||
log_debug("Over reply triggered with error: %s", strna(error_id));
|
||||
assert_se(streq(error_id, VARLINK_ERROR_DISCONNECTED));
|
||||
ASSERT_STREQ(error_id, VARLINK_ERROR_DISCONNECTED);
|
||||
sd_event_exit(varlink_get_event(link), 0);
|
||||
|
||||
return 0;
|
||||
@ -299,8 +299,8 @@ static void *thread(void *arg) {
|
||||
test_fd(fd5, "wuff", 4);
|
||||
|
||||
assert_se(varlink_callb(c, "io.test.IDontExist", &o, &e, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("x", JSON_BUILD_REAL(5.5)))) >= 0);
|
||||
assert_se(streq_ptr(json_variant_string(json_variant_by_key(o, "method")), "io.test.IDontExist"));
|
||||
assert_se(streq(e, VARLINK_ERROR_METHOD_NOT_FOUND));
|
||||
ASSERT_STREQ(json_variant_string(json_variant_by_key(o, "method")), "io.test.IDontExist");
|
||||
ASSERT_STREQ(e, VARLINK_ERROR_METHOD_NOT_FOUND);
|
||||
|
||||
flood_test(arg);
|
||||
|
||||
|
||||
@ -53,7 +53,7 @@ TEST(path_pick) {
|
||||
if (IN_SET(native_architecture(), ARCHITECTURE_X86, ARCHITECTURE_X86_64)) {
|
||||
assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0);
|
||||
assert_se(S_ISREG(result.st.st_mode));
|
||||
assert_se(streq_ptr(result.version, "99"));
|
||||
ASSERT_STREQ(result.version, "99");
|
||||
assert_se(result.architecture == ARCHITECTURE_X86);
|
||||
assert_se(endswith(result.path, "/foo_99_x86.raw"));
|
||||
|
||||
@ -63,7 +63,7 @@ TEST(path_pick) {
|
||||
filter.architecture = ARCHITECTURE_X86_64;
|
||||
assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0);
|
||||
assert_se(S_ISREG(result.st.st_mode));
|
||||
assert_se(streq_ptr(result.version, "55"));
|
||||
ASSERT_STREQ(result.version, "55");
|
||||
assert_se(result.architecture == ARCHITECTURE_X86_64);
|
||||
assert_se(endswith(result.path, "/foo_55_x86-64.raw"));
|
||||
pick_result_done(&result);
|
||||
@ -71,7 +71,7 @@ TEST(path_pick) {
|
||||
filter.architecture = ARCHITECTURE_IA64;
|
||||
assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0);
|
||||
assert_se(S_ISREG(result.st.st_mode));
|
||||
assert_se(streq_ptr(result.version, "5"));
|
||||
ASSERT_STREQ(result.version, "5");
|
||||
assert_se(result.architecture == ARCHITECTURE_IA64);
|
||||
assert_se(endswith(result.path, "/foo_5_ia64.raw"));
|
||||
pick_result_done(&result);
|
||||
@ -80,7 +80,7 @@ TEST(path_pick) {
|
||||
filter.version = "5";
|
||||
assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0);
|
||||
assert_se(S_ISREG(result.st.st_mode));
|
||||
assert_se(streq_ptr(result.version, "5"));
|
||||
ASSERT_STREQ(result.version, "5");
|
||||
if (native_architecture() != ARCHITECTURE_IA64) {
|
||||
assert_se(result.architecture == _ARCHITECTURE_INVALID);
|
||||
assert_se(endswith(result.path, "/foo_5.raw"));
|
||||
@ -90,7 +90,7 @@ TEST(path_pick) {
|
||||
filter.architecture = ARCHITECTURE_IA64;
|
||||
assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0);
|
||||
assert_se(S_ISREG(result.st.st_mode));
|
||||
assert_se(streq_ptr(result.version, "5"));
|
||||
ASSERT_STREQ(result.version, "5");
|
||||
assert_se(result.architecture == ARCHITECTURE_IA64);
|
||||
assert_se(endswith(result.path, "/foo_5_ia64.raw"));
|
||||
pick_result_done(&result);
|
||||
@ -109,7 +109,7 @@ TEST(path_pick) {
|
||||
if (IN_SET(native_architecture(), ARCHITECTURE_X86_64, ARCHITECTURE_X86)) {
|
||||
assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0);
|
||||
assert_se(S_ISREG(result.st.st_mode));
|
||||
assert_se(streq_ptr(result.version, "55"));
|
||||
ASSERT_STREQ(result.version, "55");
|
||||
|
||||
if (native_architecture() == ARCHITECTURE_X86_64) {
|
||||
assert_se(result.architecture == ARCHITECTURE_X86_64);
|
||||
@ -129,7 +129,7 @@ TEST(path_pick) {
|
||||
if (IN_SET(native_architecture(), ARCHITECTURE_X86, ARCHITECTURE_X86_64)) {
|
||||
assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0);
|
||||
assert_se(S_ISREG(result.st.st_mode));
|
||||
assert_se(streq_ptr(result.version, "55"));
|
||||
ASSERT_STREQ(result.version, "55");
|
||||
assert_se(result.architecture == native_architecture());
|
||||
assert_se(endswith(result.path, ".raw"));
|
||||
assert_se(strrstr(result.path, "/foo_55_x86"));
|
||||
@ -161,7 +161,7 @@ TEST(path_pick) {
|
||||
|
||||
assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0);
|
||||
assert_se(S_ISREG(result.st.st_mode));
|
||||
assert_se(streq_ptr(result.version, "2"));
|
||||
ASSERT_STREQ(result.version, "2");
|
||||
assert_se(result.tries_left == 4);
|
||||
assert_se(result.tries_done == 6);
|
||||
assert_se(endswith(result.path, "quux_2_s390+4-6.raw"));
|
||||
|
||||
@ -51,7 +51,7 @@ TEST(getxattr_at_malloc) {
|
||||
fd = open(x, O_PATH|O_CLOEXEC);
|
||||
assert_se(fd >= 0);
|
||||
assert_se(getxattr_at_malloc(fd, NULL, "user.foo", 0, &value) == 3);
|
||||
assert_se(streq(value, "bar"));
|
||||
ASSERT_STREQ(value, "bar");
|
||||
}
|
||||
|
||||
TEST(getcrtime) {
|
||||
@ -83,7 +83,7 @@ static void verify_xattr(int dfd, const char *expected) {
|
||||
_cleanup_free_ char *value = NULL;
|
||||
|
||||
assert_se(getxattr_at_malloc(dfd, "test", "user.foo", 0, &value) == (int) strlen(expected));
|
||||
assert_se(streq(value, expected));
|
||||
ASSERT_STREQ(value, expected);
|
||||
}
|
||||
|
||||
TEST(xsetxattr) {
|
||||
|
||||
@ -29,7 +29,7 @@ static void test_one(const char *data, ...) {
|
||||
break;
|
||||
|
||||
nn = va_arg(ap, const char *);
|
||||
assert_se(streq_ptr(nn, name));
|
||||
ASSERT_STREQ(nn, name);
|
||||
}
|
||||
|
||||
va_end(ap);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user