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;
}
if (ret < 0)
return;
- assert_se(streq_ptr(p, stripped));
+ ASSERT_STREQ(p, stripped);
assert_se(l == tries_left);
assert_se(d == tries_done);
}
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++) {
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);
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);
_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) {
}
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) {
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) {
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) {
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) {
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) {
_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) {
_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) {
_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) {
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] == '_');
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) {
const char *s = NULL;
ASSERT_OK(cg_shift_path(raw, root, &s));
- assert_se(streq(s, shifted));
+ ASSERT_STREQ(s, shifted);
}
TEST(shift_path) {
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);
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);
}
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);
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));
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);
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) {
_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) {
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:
case 17:
assert_se(r == 1);
- assert_se(streq(setting1, "2"));
+ ASSERT_STREQ(setting1, "2");
break;
}
}
/* 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);
/* 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);
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);
}
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) {
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));
_cleanup_free_ char *d = NULL;
assert_se(base64mem(*p, strlen(*p), &d) >= 0);
- assert_se(streq(d, c));
+ ASSERT_STREQ(d, c);
}
}
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);
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);
}
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));
}
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) {
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) {
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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 */
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);
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"));
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);
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);
zero(rbuffer);
assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 3);
- assert_se(streq(rbuffer, "foo"));
+ ASSERT_STREQ(rbuffer, "foo");
fd = safe_close(fd);
zero(rbuffer);
assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 0);
- assert_se(streq(rbuffer, ""));
+ ASSERT_STREQ(rbuffer, "");
fd = safe_close(fd);
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);
}
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) {
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) {
if (r < 0)
return;
- assert_se(streq_ptr(expect, t));
+ ASSERT_STREQ(expect, t);
}
TEST(dns_label_escape) {
if (r < 0)
return;
- assert_se(streq_ptr(expect, t));
+ ASSERT_STREQ(expect, t);
}
TEST(dns_name_normalize) {
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));
_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) {
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);
}
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;
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) {
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) {
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) {
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);
}
}
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);
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);
_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]);
}
_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]);
}
_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]);
}
_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]);
}
_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]);
}
_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]);
}
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);
}
}
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) {
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);
}
_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);
}
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) {
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) {
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) {
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) {
};
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 */
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) {
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) {
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);
}
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]);
}
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) {
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);
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));
}
/* 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);
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);
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)];
_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) {
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);
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);
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) {
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) {
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) {
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) {
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) {
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);
}
}
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) {
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) {
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 */
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);
}
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));
}
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));
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));
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));
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));
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));
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="));
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));
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));
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));
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);
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);
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);
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);
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);
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);
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));
}
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));
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));
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));
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));
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));
}
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);
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);
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);
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);
}
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) {
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
}
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);
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(
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 */
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) {
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]);
{
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);
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]);
}
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);
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) {
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+");
assert_se(fgets(buf, sizeof(buf), f));
printf(">%s<", buf);
- assert_se(streq(buf, "boohoo"));
+ ASSERT_STREQ(buf, "boohoo");
}
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) {
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) {
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);
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);
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);
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);
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 */
}
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."
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
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);
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);
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);
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) {
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) {
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);
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);
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);
}
}
_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) {
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);
}
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 */
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);
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) {
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);
}
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);
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);
_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) {
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. */
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);
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) {
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) {
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) {
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) {
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"));
}
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));
}
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"));
}
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");
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);
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);
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
}
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
}
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));
}
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);
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);
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) {
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);
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);
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);
}
}
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);
}
char *str;
str = strndupa_safe(mem, len);
- assert_se(streq(str, ans));
+ ASSERT_STREQ(str, ans);
}
}
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);
}
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;
}
"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);
}
/* 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 */
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(".");
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) {
}
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));
_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) {
_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) {
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) {
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) {
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) {
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);
}
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) {
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++) {
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);
}
}
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
}
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;
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) {
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;
}
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;
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;
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;
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;
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;
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;
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;
}
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;
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;
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);
}
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;
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;
}
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;
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;
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;
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;
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;
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;
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;
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;
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;
* 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) {
}
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) {
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;
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);
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");
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);
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(
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);
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);
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);
}
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);
}
}
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);
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);
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);
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);
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);
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);
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) {
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);
}
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); \
&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, "",
&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) {
&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, "",
&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) {
&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);
&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,
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) {
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;
assert_se(memstream_init(&m));
assert_se(memstream_finalize(&m, &buf, &sz) >= 0);
- assert_se(streq(buf, ""));
+ ASSERT_STREQ(buf, "");
assert_se(sz == 0);
}
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);
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"));
}
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);
}
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) {
if (isempty(name))
assert_se(isempty(c));
else
- assert_se(streq(c, name));
+ ASSERT_STREQ(c, name);
}
}
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);
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) \
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));
}
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);
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);
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);
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;
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;
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;
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;
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;
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"));
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"));
* 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);
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,
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));
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);
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));
_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);
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)));
}
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"));
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) {
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;
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)
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);
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);
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);
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, "////")
b = false;
PATH_FOREACH_PREFIX_MORE(s, "////") {
assert_se(!b);
- assert_se(streq(s, ""));
+ ASSERT_STREQ(s, "");
b = true;
}
assert_se(b);
b = false;
PATH_FOREACH_PREFIX_MORE(s, "") {
assert_se(!b);
- assert_se(streq(s, ""));
+ ASSERT_STREQ(s, "");
b = true;
}
}
_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");
_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) {
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) {
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) {
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);
}
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));
}
}
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);
}
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) {
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);
}
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
}
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) {
}
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_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_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("/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_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_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_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_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("/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_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_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) {
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) {
/* 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")));
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")));
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"))
"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) {
log_debug("got: <%s>", n);
- assert_se(streq_ptr(n, output));
+ ASSERT_STREQ(n, output);
}
TEST(pid_get_comm_escape) {
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
}
assert_se(r = strreplace("XYZFFFFXYZFFFFXYZ", "XYZ", "ABC"));
puts(r);
- assert_se(streq(r, "ABCFFFFABCFFFFABC"));
+ ASSERT_STREQ(r, "ABCFFFFABCFFFFABC");
free(r);
}
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);
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);
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);
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);
}
}
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;
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);
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 */
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);
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) {
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);
}
}
_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) {
_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) {
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);
_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");
}
_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) {
/* 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);
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);
}
}
}
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);
}
}
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));
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);
_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) {
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)
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)
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)
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);
}
}
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) {
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) {
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) {
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);
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]);
}
}
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);
_cleanup_free_ char *x = NULL;
x = specifier_escape(a);
- assert_se(streq_ptr(x, b));
+ ASSERT_STREQ(x, b);
}
TEST(specifier_escape) {
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);
/* /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) {
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);
}
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 */
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);
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');
__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 */
}
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) {
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) {
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_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_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_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_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_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_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_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_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_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_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_se(streq(cellescape(buf, 40, "1\020"), "1\\020"));
- assert_se(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_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, 1, ""), "");
+ ASSERT_STREQ(cellescape(buf, 1, "1"), "");
+ ASSERT_STREQ(cellescape(buf, 1, "12"), "");
+
+ 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_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_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_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_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_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_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_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_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_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_STREQ(cellescape(buf, 40, "1\020"), "1\\020");
+ ASSERT_STREQ(cellescape(buf, 40, "1\020x"), "1\\020x");
+
+ 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_STREQ(cellescape(buf, sizeof buf, "1\020"), "1\\020");
+ ASSERT_STREQ(cellescape(buf, sizeof buf, "1\020x"), "1\\020x");
}
TEST(streq_ptr) {
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) {
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) {
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) {
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);
}
}
assert_se(r > 0);
- assert_se(streq(expected[i++], word));
+ ASSERT_STREQ(expected[i++], word);
}
}
break;
}
- assert_se(streq(word, expected[i++]));
+ ASSERT_STREQ(word, expected[i++]);
printf("<%s>\n", word);
}
ASSERT_NULL(expected[i]);
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);
}
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);
}
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) {
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) {
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) {
}
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"));
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);
}
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);
}
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) {
_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) {
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) {
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);
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);
}
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);
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
*z = 0;
assert_se(qq = strdup(q));
assert_se(strip_tab_ansi(&q, NULL, NULL));
- assert_se(streq(q, qq));
+ ASSERT_STREQ(q, qq);
}
}
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[] = {
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) {
puts(j);
STRV_FOREACH(t, s)
- assert_se(streq(list[i++], *t));
+ ASSERT_STREQ(list[i++], *t);
ASSERT_NULL(list[i]);
}
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) {
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) {
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);
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) {
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) {
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) {
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) {
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);
}
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]);
}
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) {
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) {
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) {
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();
"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, ...) {
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;
_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]);
}
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]);
}
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));
}
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) {
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) {
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) {
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);
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]);
}
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) {
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) {
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) {
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) {
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');
}
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) {
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);
}
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);
}
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);
assert_se(sysctl_normalize(t) == t);
log_info("\"%s\" → \"%s\", expected \"%s\"", *s, t, *expected);
- assert_se(streq(t, *expected));
+ ASSERT_STREQ(t, *expected);
}
}
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);
override ? ", ignoring." : "");
if (!override) {
assert_se(x / USEC_PER_SEC == y / USEC_PER_SEC);
- assert_se(streq(xx, yy));
+ ASSERT_STREQ(xx, yy);
}
}
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) {
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) {
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) {
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();
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);
}
const char *suffix;
assert_se(suffix = startswith(s, expect));
- assert_se(streq(suffix, "XXXXXX"));
+ ASSERT_STREQ(suffix, "XXXXXX");
}
assert_se(ret == r);
}
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);
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);
}
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));
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));
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) {
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) {
_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) {
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;
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;
_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) {
assert_se(r == ret);
puts(strna(t));
- assert_se(streq_ptr(t, expect));
+ ASSERT_STREQ(t, expect);
if (t) {
_cleanup_free_ char *k = NULL;
(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);
}
}
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) {
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);
}
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);
}
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);
_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) {
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);
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) {
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) {
_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) {
_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) {
_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) {
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) {
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) {
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));
return;
}
assert_se(r == 0);
- assert_se(streq_ptr(id, name));
+ ASSERT_STREQ(id, name);
assert_se(rgid == gid);
}
_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));
}
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) {
b = utf16_to_utf8(a, SIZE_MAX);
assert_se(b);
- assert_se(streq(p, b));
+ ASSERT_STREQ(p, b);
}
}
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) {
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);
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),
* 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;
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);
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"));
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);
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);
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"));
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);
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);
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"));
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"));
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) {
_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) {
break;
nn = va_arg(ap, const char *);
- assert_se(streq_ptr(nn, name));
+ ASSERT_STREQ(nn, name);
}
va_end(ap);
projects / thirdparty / systemd.git / commitdiff
