From c79e88b37d3f8b94cdd2aeba1edbe09d06c08f7a Mon Sep 17 00:00:00 2001 From: Ivan Kruglov Date: Wed, 10 Apr 2024 13:19:39 +0200 Subject: [PATCH] ASSERT_STREQ for simple cases --- src/test/test-bootspec.c | 14 +- src/test/test-cap-list.c | 6 +- src/test/test-cgroup-mask.c | 4 +- src/test/test-cgroup-util.c | 22 +- src/test/test-cgroup.c | 10 +- src/test/test-chase.c | 6 +- src/test/test-conf-parser.c | 38 +-- src/test/test-copy.c | 18 +- src/test/test-core-unit.c | 14 +- src/test/test-cpu-set-util.c | 42 ++-- src/test/test-creds.c | 12 +- src/test/test-cryptolib.c | 8 +- src/test/test-data-fd-util.c | 4 +- src/test/test-devnum-util.c | 2 +- src/test/test-dns-domain.c | 36 +-- src/test/test-ellipsize.c | 14 +- src/test/test-engine.c | 2 +- src/test/test-env-file.c | 40 +-- src/test/test-env-util.c | 176 ++++++------- src/test/test-errno-list.c | 10 +- src/test/test-errno-util.c | 4 +- src/test/test-escape.c | 36 +-- src/test/test-ether-addr-util.c | 2 +- src/test/test-exec-util.c | 20 +- src/test/test-exit-status.c | 4 +- src/test/test-extract-word.c | 288 ++++++++++----------- src/test/test-fd-util.c | 34 +-- src/test/test-fileio.c | 148 +++++------ src/test/test-format-table.c | 2 +- src/test/test-format-util.c | 8 +- src/test/test-fs-util.c | 36 +-- src/test/test-fstab-util.c | 24 +- src/test/test-glob-util.c | 6 +- src/test/test-gpt.c | 4 +- src/test/test-hashmap-plain.c | 66 ++--- src/test/test-hashmap.c | 6 +- src/test/test-hexdecoct.c | 50 ++-- src/test/test-hmac.c | 12 +- src/test/test-hostname-setup.c | 8 +- src/test/test-hostname-util.c | 34 +-- src/test/test-id128.c | 8 +- src/test/test-import-util.c | 4 +- src/test/test-in-addr-prefix-util.c | 8 +- src/test/test-in-addr-util.c | 12 +- src/test/test-install-root.c | 160 ++++++------ src/test/test-ip-protocol-list.c | 4 +- src/test/test-json.c | 36 +-- src/test/test-load-fragment.c | 30 +-- src/test/test-loop-block.c | 8 +- src/test/test-mempress.c | 2 +- src/test/test-memstream-util.c | 6 +- src/test/test-mount-util.c | 18 +- src/test/test-mountpoint-util.c | 2 +- src/test/test-net-naming-scheme.c | 2 +- src/test/test-nulstr-util.c | 10 +- src/test/test-open-file.c | 46 ++-- src/test/test-ordered-set.c | 6 +- src/test/test-os-util.c | 16 +- src/test/test-parse-argument.c | 4 +- src/test/test-path-lookup.c | 2 +- src/test/test-path-util.c | 202 +++++++-------- src/test/test-proc-cmdline.c | 22 +- src/test/test-process-util.c | 84 +++---- src/test/test-recovery-key.c | 4 +- src/test/test-replace-var.c | 4 +- src/test/test-rlimit-util.c | 4 +- src/test/test-seccomp.c | 22 +- src/test/test-secure-bits.c | 8 +- src/test/test-serialize.c | 20 +- src/test/test-set.c | 16 +- src/test/test-sha256.c | 2 +- src/test/test-socket-netlink.c | 22 +- src/test/test-socket-util.c | 14 +- src/test/test-specifier.c | 10 +- src/test/test-strbuf.c | 26 +- src/test/test-string-util.c | 376 ++++++++++++++-------------- src/test/test-strip-tab-ansi.c | 18 +- src/test/test-strv.c | 296 +++++++++++----------- src/test/test-strxcpyx.c | 38 +-- src/test/test-sysctl-util.c | 4 +- src/test/test-time-util.c | 66 ++--- src/test/test-tmpfile-util.c | 6 +- src/test/test-tpm2.c | 4 +- src/test/test-udev-util.c | 2 +- src/test/test-unit-file.c | 20 +- src/test/test-unit-name.c | 44 ++-- src/test/test-user-util.c | 10 +- src/test/test-utf8.c | 4 +- src/test/test-varlink-idl.c | 6 +- src/test/test-varlink.c | 8 +- src/test/test-vpick.c | 16 +- src/test/test-xattr-util.c | 4 +- src/test/test-xml.c | 2 +- 93 files changed, 1519 insertions(+), 1519 deletions(-) diff --git a/src/test/test-bootspec.c b/src/test/test-bootspec.c index 2b4a81351fa..88faa1efb2b 100644 --- a/src/test/test-bootspec.c +++ b/src/test/test-bootspec.c @@ -79,16 +79,16 @@ TEST_RET(bootspec_sort) { assert_se(config.n_entries == 6); /* First, because has sort key, and its the lowest one */ - assert_se(streq(config.entries[0].id, "d.conf")); + ASSERT_STREQ(config.entries[0].id, "d.conf"); /* These two have a sort key, and newest must be first */ - assert_se(streq(config.entries[1].id, "cx.conf")); - assert_se(streq(config.entries[2].id, "c.conf")); + ASSERT_STREQ(config.entries[1].id, "cx.conf"); + ASSERT_STREQ(config.entries[2].id, "c.conf"); /* The following ones have no sort key, hence order by version compared ids, lowest first */ - assert_se(streq(config.entries[3].id, "b.conf")); - assert_se(streq(config.entries[4].id, "a-10.conf")); - assert_se(streq(config.entries[5].id, "a-5.conf")); + ASSERT_STREQ(config.entries[3].id, "b.conf"); + ASSERT_STREQ(config.entries[4].id, "a-10.conf"); + ASSERT_STREQ(config.entries[5].id, "a-5.conf"); return 0; } @@ -101,7 +101,7 @@ static void test_extract_tries_one(const char *fname, int ret, const char *strip if (ret < 0) return; - assert_se(streq_ptr(p, stripped)); + ASSERT_STREQ(p, stripped); assert_se(l == tries_left); assert_se(d == tries_done); } diff --git a/src/test/test-cap-list.c b/src/test/test-cap-list.c index 0ef6ff1e405..49be4a2d272 100644 --- a/src/test/test-cap-list.c +++ b/src/test/test-cap-list.c @@ -21,7 +21,7 @@ TEST(cap_list) { assert_se(!CAPABILITY_TO_STRING(-1)); if (capability_list_length() <= 62) - assert_se(streq(CAPABILITY_TO_STRING(62), "0x3e")); + ASSERT_STREQ(CAPABILITY_TO_STRING(62), "0x3e"); assert_se(!CAPABILITY_TO_STRING(64)); for (int i = 0; i < capability_list_length(); i++) { @@ -31,7 +31,7 @@ TEST(cap_list) { assert_se(capability_from_name(n) == i); printf("%s = %i\n", n, i); - assert_se(streq(CAPABILITY_TO_STRING(i), n)); + ASSERT_STREQ(CAPABILITY_TO_STRING(i), n); } assert_se(capability_from_name("asdfbsd") == -EINVAL); @@ -70,7 +70,7 @@ static void test_capability_set_one(uint64_t c, const char *t) { uint64_t c1, c_masked = c & all_capabilities(); assert_se(capability_set_to_string(c, &t1) == 0); - assert_se(streq(t1, t)); + ASSERT_STREQ(t1, t); assert_se(capability_set_from_string(t1, &c1) > 0); assert_se(c1 == c_masked); diff --git a/src/test/test-cgroup-mask.c b/src/test/test-cgroup-mask.c index 1359ec94899..857102f8a0a 100644 --- a/src/test/test-cgroup-mask.c +++ b/src/test/test-cgroup-mask.c @@ -135,7 +135,7 @@ static void test_cg_mask_to_string_one(CGroupMask mask, const char *t) { _cleanup_free_ char *b = NULL; assert_se(cg_mask_to_string(mask, &b) >= 0); - assert_se(streq_ptr(b, t)); + ASSERT_STREQ(b, t); } TEST(cg_mask_to_string) { @@ -157,7 +157,7 @@ TEST(cg_mask_to_string) { } static void cgroup_device_permissions_test_normalize(const char *a, const char *b) { - assert_se(streq_ptr(cgroup_device_permissions_to_string(cgroup_device_permissions_from_string(a)), b)); + ASSERT_STREQ(cgroup_device_permissions_to_string(cgroup_device_permissions_from_string(a)), b); } TEST(cgroup_device_permissions) { diff --git a/src/test/test-cgroup-util.c b/src/test/test-cgroup-util.c index 1e09b9e1856..1d8f99cc6e5 100644 --- a/src/test/test-cgroup-util.c +++ b/src/test/test-cgroup-util.c @@ -23,7 +23,7 @@ static void check_p_d_u(const char *path, int code, const char *result) { r = cg_path_decode_unit(path, &unit); printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit, r, strnull(result), code); assert_se(r == code); - assert_se(streq_ptr(unit, result)); + ASSERT_STREQ(unit, result); } TEST(path_decode_unit) { @@ -45,7 +45,7 @@ static void check_p_g_u(const char *path, int code, const char *result) { r = cg_path_get_unit(path, &unit); printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit, r, strnull(result), code); assert_se(r == code); - assert_se(streq_ptr(unit, result)); + ASSERT_STREQ(unit, result); } TEST(path_get_unit) { @@ -69,7 +69,7 @@ static void check_p_g_u_p(const char *path, int code, const char *result) { r = cg_path_get_unit_path(path, &unit_path); printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit_path, r, strnull(result), code); assert_se(r == code); - assert_se(streq_ptr(unit_path, result)); + ASSERT_STREQ(unit_path, result); } TEST(path_get_unit_path) { @@ -96,7 +96,7 @@ static void check_p_g_u_u(const char *path, int code, const char *result) { r = cg_path_get_user_unit(path, &unit); printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit, r, strnull(result), code); assert_se(r == code); - assert_se(streq_ptr(unit, result)); + ASSERT_STREQ(unit, result); } TEST(path_get_user_unit) { @@ -119,7 +119,7 @@ static void check_p_g_s(const char *path, int code, const char *result) { _cleanup_free_ char *s = NULL; assert_se(cg_path_get_session(path, &s) == code); - assert_se(streq_ptr(s, result)); + ASSERT_STREQ(s, result); } TEST(path_get_session) { @@ -146,7 +146,7 @@ static void check_p_g_slice(const char *path, int code, const char *result) { _cleanup_free_ char *s = NULL; assert_se(cg_path_get_slice(path, &s) == code); - assert_se(streq_ptr(s, result)); + ASSERT_STREQ(s, result); } TEST(path_get_slice) { @@ -163,7 +163,7 @@ static void check_p_g_u_slice(const char *path, int code, const char *result) { _cleanup_free_ char *s = NULL; assert_se(cg_path_get_user_slice(path, &s) == code); - assert_se(streq_ptr(s, result)); + ASSERT_STREQ(s, result); } TEST(path_get_user_slice) { @@ -239,9 +239,9 @@ static void test_escape_one(const char *s, const char *expected) { assert_se(expected); ASSERT_OK(cg_escape(s, &b)); - assert_se(streq(b, expected)); + ASSERT_STREQ(b, expected); - assert_se(streq(cg_unescape(b), s)); + ASSERT_STREQ(cg_unescape(b), s); assert_se(filename_is_valid(b)); assert_se(!cg_needs_escape(s) || b[0] == '_'); @@ -284,7 +284,7 @@ static void test_slice_to_path_one(const char *unit, const char *path, int error log_info("actual: %s / %d", strnull(ret), r); log_info("expect: %s / %d", strnull(path), error); assert_se(r == error); - assert_se(streq_ptr(ret, path)); + ASSERT_STREQ(ret, path); } TEST(slice_to_path) { @@ -316,7 +316,7 @@ static void test_shift_path_one(const char *raw, const char *root, const char *s const char *s = NULL; ASSERT_OK(cg_shift_path(raw, root, &s)); - assert_se(streq(s, shifted)); + ASSERT_STREQ(s, shifted); } TEST(shift_path) { diff --git a/src/test/test-cgroup.c b/src/test/test-cgroup.c index 703c8f6c036..8bd4af94e4e 100644 --- a/src/test/test-cgroup.c +++ b/src/test/test-cgroup.c @@ -15,8 +15,8 @@ TEST(cg_split_spec) { char *c, *p; assert_se(cg_split_spec("foobar:/", &c, &p) == 0); - assert_se(streq(c, "foobar")); - assert_se(streq(p, "/")); + ASSERT_STREQ(c, "foobar"); + ASSERT_STREQ(p, "/"); c = mfree(c); p = mfree(p); @@ -32,11 +32,11 @@ TEST(cg_split_spec) { assert_se(cg_split_spec("/", &c, &p) >= 0); ASSERT_NULL(c); - assert_se(streq(p, "/")); + ASSERT_STREQ(p, "/"); p = mfree(p); assert_se(cg_split_spec("foo", &c, &p) >= 0); - assert_se(streq(c, "foo")); + ASSERT_STREQ(c, "foo"); ASSERT_NULL(p); c = mfree(c); } @@ -79,7 +79,7 @@ TEST(cg_create) { assert_se(cg_create_and_attach(SYSTEMD_CGROUP_CONTROLLER, test_b, 0) == 0); assert_se(cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, getpid_cached(), &path) == 0); - assert_se(streq(path, test_b)); + ASSERT_STREQ(path, test_b); free(path); assert_se(cg_attach(SYSTEMD_CGROUP_CONTROLLER, test_a, 0) == 0); diff --git a/src/test/test-chase.c b/src/test/test-chase.c index 10d8a02e7fa..5d3ee7aceec 100644 --- a/src/test/test-chase.c +++ b/src/test/test-chase.c @@ -23,7 +23,7 @@ static void test_chase_extract_filename_one(const char *path, const char *root, log_debug("/* %s(path=%s, root=%s) */", __func__, path, strnull(root)); assert_se(chase(path, root, CHASE_EXTRACT_FILENAME, &ret1, NULL) > 0); - assert_se(streq(ret1, expected)); + ASSERT_STREQ(ret1, expected); assert_se(chase(path, root, 0, &ret2, NULL) > 0); ASSERT_OK(chase_extract_filename(ret2, root, &fname)); @@ -173,7 +173,7 @@ TEST(chase) { r = chase(p, NULL, 0, &result, NULL); assert_se(r > 0); assert_se(path_equal(result, "/usr")); - assert_se(streq(result, "/usr")); /* we guarantee that we drop redundant slashes */ + ASSERT_STREQ(result, "/usr"); /* we guarantee that we drop redundant slashes */ result = mfree(result); r = chase(p, temp, 0, &result, NULL); @@ -718,7 +718,7 @@ TEST(chaseat_prefix_root) { assert_se(chaseat_prefix_root("./hoge/aaa/../././b", "a/b//./c///", &ret) >= 0); assert_se(expected = path_join(cwd, "a/b/c/hoge/aaa/../././b")); - assert_se(streq(ret, expected)); + ASSERT_STREQ(ret, expected); } TEST(trailing_dot_dot) { diff --git a/src/test/test-conf-parser.c b/src/test/test-conf-parser.c index ab54107655a..280abb53774 100644 --- a/src/test/test-conf-parser.c +++ b/src/test/test-conf-parser.c @@ -16,7 +16,7 @@ static void test_config_parse_path_one(const char *rvalue, const char *expected) _cleanup_free_ char *path = NULL; assert_se(config_parse_path("unit", "filename", 1, "section", 1, "lvalue", 0, rvalue, &path, NULL) >= 0); - assert_se(streq_ptr(expected, path)); + ASSERT_STREQ(expected, path); } static void test_config_parse_log_level_one(const char *rvalue, int expected) { @@ -352,27 +352,27 @@ static void test_config_parse_one(unsigned i, const char *s) { switch (i) { case 0 ... 4: assert_se(r == 1); - assert_se(streq(setting1, "1")); + ASSERT_STREQ(setting1, "1"); break; case 5 ... 10: assert_se(r == 1); - assert_se(streq(setting1, "1 2 3")); + ASSERT_STREQ(setting1, "1 2 3"); break; case 11: assert_se(r == 1); - assert_se(streq(setting1, "1\\\\ \\\\2")); + ASSERT_STREQ(setting1, "1\\\\ \\\\2"); break; case 12: assert_se(r == 1); - assert_se(streq(setting1, x1000("ABCD"))); + ASSERT_STREQ(setting1, x1000("ABCD")); break; case 13 ... 14: assert_se(r == 1); - assert_se(streq(setting1, x1000("ABCD") " foobar")); + ASSERT_STREQ(setting1, x1000("ABCD") " foobar"); break; case 15 ... 16: @@ -382,7 +382,7 @@ static void test_config_parse_one(unsigned i, const char *s) { case 17: assert_se(r == 1); - assert_se(streq(setting1, "2")); + ASSERT_STREQ(setting1, "2"); break; } } @@ -443,12 +443,12 @@ TEST(config_parse_standard_file_with_dropins_full) { /* ret_stats_by_path= */ NULL, /* ret_dropin_files= */ &dropins); assert_se(r >= 0); - assert_se(streq_ptr(A, "aaa")); - assert_se(streq_ptr(B, "bbb")); - assert_se(streq_ptr(C, "c1")); - assert_se(streq_ptr(D, "ddd")); - assert_se(streq_ptr(E, "eee")); - assert_se(streq_ptr(F, NULL)); + ASSERT_STREQ(A, "aaa"); + ASSERT_STREQ(B, "bbb"); + ASSERT_STREQ(C, "c1"); + ASSERT_STREQ(D, "ddd"); + ASSERT_STREQ(E, "eee"); + ASSERT_STREQ(F, NULL); A = mfree(A); B = mfree(B); @@ -482,12 +482,12 @@ TEST(config_parse_standard_file_with_dropins_full) { /* ret_stats_by_path= */ NULL, /* ret_dropin_files= */ NULL); assert_se(r >= 0); - assert_se(streq_ptr(A, "aaa")); - assert_se(streq_ptr(B, "bbb")); - assert_se(streq_ptr(C, "c1")); - assert_se(streq_ptr(D, "ddd")); - assert_se(streq_ptr(E, "eee")); - assert_se(streq_ptr(F, NULL)); + ASSERT_STREQ(A, "aaa"); + ASSERT_STREQ(B, "bbb"); + ASSERT_STREQ(C, "c1"); + ASSERT_STREQ(D, "ddd"); + ASSERT_STREQ(E, "eee"); + ASSERT_STREQ(F, NULL); } DEFINE_TEST_MAIN(LOG_INFO); diff --git a/src/test/test-copy.c b/src/test/test-copy.c index 46519fdc018..7b16cf2258b 100644 --- a/src/test/test-copy.c +++ b/src/test/test-copy.c @@ -45,7 +45,7 @@ TEST(copy_file) { assert_se(copy_file(fn, fn_copy, 0, 0644, COPY_REFLINK) == 0); assert_se(read_full_file(fn_copy, &buf, &sz) == 0); - assert_se(streq(buf, "foo bar bar bar foo\n")); + ASSERT_STREQ(buf, "foo bar bar bar foo\n"); assert_se(sz == 20); } @@ -125,7 +125,7 @@ TEST(copy_file_fd) { assert_se(lseek(out_fd, SEEK_SET, 0) == 0); assert_se(read(out_fd, buf, sizeof buf) == (ssize_t) strlen(text)); - assert_se(streq(buf, text)); + ASSERT_STREQ(buf, text); } TEST(copy_tree) { @@ -202,7 +202,7 @@ TEST(copy_tree) { assert_se(access(f, F_OK) == 0); assert_se(read_full_file(f, &buf, &sz) == 0); - assert_se(streq(buf, "file\n")); + ASSERT_STREQ(buf, "file\n"); k = lgetxattr_malloc(f, "user.testxattr", &c); assert_se(xattr_worked < 0 || ((k >= 0) == !!xattr_worked)); @@ -211,7 +211,7 @@ TEST(copy_tree) { _cleanup_free_ char *d = NULL; assert_se(base64mem(*p, strlen(*p), &d) >= 0); - assert_se(streq(d, c)); + ASSERT_STREQ(d, c); } } @@ -266,13 +266,13 @@ TEST(copy_tree_at_symlink) { assert_se(copy_tree_at(tfd, "from", tfd, "to_1", UID_INVALID, GID_INVALID, 0, NULL, NULL) >= 0); assert_se(readlinkat_malloc(tfd, "to_1", &p) >= 0); - assert_se(streq(p, expect)); + ASSERT_STREQ(p, expect); p = mfree(p); assert_se(q = path_join(t, "from")); assert_se(copy_tree_at(AT_FDCWD, q, tfd, "to_2", UID_INVALID, GID_INVALID, 0, NULL, NULL) >= 0); assert_se(readlinkat_malloc(tfd, "to_2", &p) >= 0); - assert_se(streq(p, expect)); + ASSERT_STREQ(p, expect); p = mfree(p); q = mfree(q); @@ -280,12 +280,12 @@ TEST(copy_tree_at_symlink) { assert_se(fd >= 0); assert_se(copy_tree_at(fd, NULL, tfd, "to_3", UID_INVALID, GID_INVALID, 0, NULL, NULL) >= 0); assert_se(readlinkat_malloc(tfd, "to_3", &p) >= 0); - assert_se(streq(p, expect)); + ASSERT_STREQ(p, expect); p = mfree(p); assert_se(copy_tree_at(fd, "", tfd, "to_4", UID_INVALID, GID_INVALID, 0, NULL, NULL) >= 0); assert_se(readlinkat_malloc(tfd, "to_4", &p) >= 0); - assert_se(streq(p, expect)); + ASSERT_STREQ(p, expect); p = mfree(p); fd = safe_close(fd); } @@ -421,7 +421,7 @@ TEST(copy_proc) { assert_se(read_one_line_file("/proc/version", &a) >= 0); assert_se(read_one_line_file(f, &b) >= 0); - assert_se(streq(a, b)); + ASSERT_STREQ(a, b); assert_se(!isempty(a)); } diff --git a/src/test/test-core-unit.c b/src/test/test-core-unit.c index f72a67c60c8..83c8674c6f0 100644 --- a/src/test/test-core-unit.c +++ b/src/test/test-core-unit.c @@ -33,19 +33,19 @@ static void test_unit_escape_setting_one( assert_se(b_esc = cescape(t)); log_debug("%s: [%s] → [%s]", __func__, s_esc, b_esc); assert_se(b == NULL || streq(b, t)); - assert_se(streq(t, expected_exec_env)); + ASSERT_STREQ(t, expected_exec_env); assert_se(t = unit_escape_setting(s, UNIT_ESCAPE_EXEC_SYNTAX, &c)); assert_se(c_esc = cescape(t)); log_debug("%s: [%s] → [%s]", __func__, s_esc, c_esc); assert_se(c == NULL || streq(c, t)); - assert_se(streq(t, expected_exec)); + ASSERT_STREQ(t, expected_exec); assert_se(t = unit_escape_setting(s, UNIT_ESCAPE_C, &d)); assert_se(d_esc = cescape(t)); log_debug("%s: [%s] → [%s]", __func__, s_esc, d_esc); assert_se(d == NULL || streq(d, t)); - assert_se(streq(t, expected_c)); + ASSERT_STREQ(t, expected_c); } TEST(unit_escape_setting) { @@ -81,22 +81,22 @@ static void test_unit_concat_strv_one( assert_se(a = unit_concat_strv(s, 0)); assert_se(a_esc = cescape(a)); log_debug("%s: [%s] → [%s]", __func__, s_esc, a_esc); - assert_se(streq(a, expected_none)); + ASSERT_STREQ(a, expected_none); assert_se(b = unit_concat_strv(s, UNIT_ESCAPE_EXEC_SYNTAX_ENV)); assert_se(b_esc = cescape(b)); log_debug("%s: [%s] → [%s]", __func__, s_esc, b_esc); - assert_se(streq(b, expected_exec_env)); + ASSERT_STREQ(b, expected_exec_env); assert_se(c = unit_concat_strv(s, UNIT_ESCAPE_EXEC_SYNTAX)); assert_se(c_esc = cescape(c)); log_debug("%s: [%s] → [%s]", __func__, s_esc, c_esc); - assert_se(streq(c, expected_exec)); + ASSERT_STREQ(c, expected_exec); assert_se(d = unit_concat_strv(s, UNIT_ESCAPE_C)); assert_se(d_esc = cescape(d)); log_debug("%s: [%s] → [%s]", __func__, s_esc, d_esc); - assert_se(streq(d, expected_c)); + ASSERT_STREQ(d, expected_c); } TEST(unit_concat_strv) { diff --git a/src/test/test-cpu-set-util.c b/src/test/test-cpu-set-util.c index 0c2304e2c09..ccb52c96d4d 100644 --- a/src/test/test-cpu-set-util.c +++ b/src/test/test-cpu-set-util.c @@ -23,11 +23,11 @@ TEST(parse_cpu_set) { str = mfree(str); assert_se(str = cpu_set_to_range_string(&c)); log_info("cpu_set_to_range_string: %s", str); - assert_se(streq(str, "0")); + ASSERT_STREQ(str, "0"); str = mfree(str); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "1")); + ASSERT_STREQ(str, "1"); str = mfree(str); cpu_set_reset(&c); @@ -45,11 +45,11 @@ TEST(parse_cpu_set) { str = mfree(str); assert_se(str = cpu_set_to_range_string(&c)); log_info("cpu_set_to_range_string: %s", str); - assert_se(streq(str, "1-2 4")); + ASSERT_STREQ(str, "1-2 4"); str = mfree(str); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "16")); + ASSERT_STREQ(str, "16"); str = mfree(str); cpu_set_reset(&c); @@ -67,11 +67,11 @@ TEST(parse_cpu_set) { str = mfree(str); assert_se(str = cpu_set_to_range_string(&c)); log_info("cpu_set_to_range_string: %s", str); - assert_se(streq(str, "0-3 8-11")); + ASSERT_STREQ(str, "0-3 8-11"); str = mfree(str); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "f0f")); + ASSERT_STREQ(str, "f0f"); str = mfree(str); cpu_set_reset(&c); @@ -86,11 +86,11 @@ TEST(parse_cpu_set) { str = mfree(str); assert_se(str = cpu_set_to_range_string(&c)); log_info("cpu_set_to_range_string: %s", str); - assert_se(streq(str, "8-11")); + ASSERT_STREQ(str, "8-11"); str = mfree(str); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "f00")); + ASSERT_STREQ(str, "f00"); str = mfree(str); cpu_set_reset(&c); @@ -120,11 +120,11 @@ TEST(parse_cpu_set) { str = mfree(str); assert_se(str = cpu_set_to_range_string(&c)); log_info("cpu_set_to_range_string: %s", str); - assert_se(streq(str, "0-7 63")); + ASSERT_STREQ(str, "0-7 63"); str = mfree(str); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "80000000,000000ff")); + ASSERT_STREQ(str, "80000000,000000ff"); str = mfree(str); cpu_set_reset(&c); @@ -149,7 +149,7 @@ TEST(parse_cpu_set) { assert_se(CPU_ISSET_S(cpu, c.allocated, c.set)); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "f0f0,00000000")); + ASSERT_STREQ(str, "f0f0,00000000"); str = mfree(str); cpu_set_reset(&c); assert_se(parse_cpu_set_full("64-71", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0); @@ -159,7 +159,7 @@ TEST(parse_cpu_set) { assert_se(CPU_ISSET_S(cpu, c.allocated, c.set)); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "ff,00000000,00000000")); + ASSERT_STREQ(str, "ff,00000000,00000000"); str = mfree(str); cpu_set_reset(&c); @@ -176,11 +176,11 @@ TEST(parse_cpu_set) { str = mfree(str); assert_se(str = cpu_set_to_range_string(&c)); log_info("cpu_set_to_range_string: %s", str); - assert_se(streq(str, "0-3 8-11")); + ASSERT_STREQ(str, "0-3 8-11"); str = mfree(str); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "f0f")); + ASSERT_STREQ(str, "f0f"); str = mfree(str); cpu_set_reset(&c); @@ -190,7 +190,7 @@ TEST(parse_cpu_set) { assert_se(CPU_COUNT_S(c.allocated, c.set) == 0); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "0")); + ASSERT_STREQ(str, "0"); str = mfree(str); cpu_set_reset(&c); @@ -205,11 +205,11 @@ TEST(parse_cpu_set) { str = mfree(str); assert_se(str = cpu_set_to_range_string(&c)); log_info("cpu_set_to_range_string: %s", str); - assert_se(streq(str, "0-11")); + ASSERT_STREQ(str, "0-11"); str = mfree(str); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "fff")); + ASSERT_STREQ(str, "fff"); str = mfree(str); cpu_set_reset(&c); @@ -226,11 +226,11 @@ TEST(parse_cpu_set) { str = mfree(str); assert_se(str = cpu_set_to_range_string(&c)); log_info("cpu_set_to_range_string: %s", str); - assert_se(streq(str, "0 2 4-11")); + ASSERT_STREQ(str, "0 2 4-11"); str = mfree(str); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "ff5")); + ASSERT_STREQ(str, "ff5"); str = mfree(str); cpu_set_reset(&c); @@ -250,7 +250,7 @@ TEST(parse_cpu_set) { assert_se(c.allocated == 0); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); - assert_se(streq(str, "0")); + ASSERT_STREQ(str, "0"); str = mfree(str); /* Runaway quoted string */ @@ -266,7 +266,7 @@ TEST(parse_cpu_set) { str = mfree(str); assert_se(str = cpu_set_to_range_string(&c)); log_info("cpu_set_to_range_string: %s", str); - assert_se(streq(str, "8000-8191")); + ASSERT_STREQ(str, "8000-8191"); str = mfree(str); assert_se(str = cpu_set_to_mask_string(&c)); log_info("cpu_set_to_mask_string: %s", str); diff --git a/src/test/test-creds.c b/src/test/test-creds.c index 128788c4371..84619c91de9 100644 --- a/src/test/test-creds.c +++ b/src/test/test-creds.c @@ -39,21 +39,21 @@ TEST(read_credential_strings) { assert_se(read_credential_strings_many("foo", &x, "bar", &y) == 0); ASSERT_NULL(x); - assert_se(streq(y, "piff")); + ASSERT_STREQ(y, "piff"); assert_se(write_string_file(p, "paff", WRITE_STRING_FILE_TRUNCATE|WRITE_STRING_FILE_AVOID_NEWLINE) >= 0); assert_se(read_credential_strings_many("foo", &x, "bar", &y) == 0); ASSERT_NULL(x); - assert_se(streq(y, "paff")); + ASSERT_STREQ(y, "paff"); p = mfree(p); assert_se(p = path_join(tmp, "foo")); assert_se(write_string_file(p, "knurz", WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_AVOID_NEWLINE) >= 0); assert_se(read_credential_strings_many("foo", &x, "bar", &y) >= 0); - assert_se(streq(x, "knurz")); - assert_se(streq(y, "paff")); + ASSERT_STREQ(x, "knurz"); + ASSERT_STREQ(y, "paff"); p = mfree(p); assert_se(p = path_join(tmp, "bazz")); @@ -64,8 +64,8 @@ TEST(read_credential_strings) { y = mfree(y); assert_se(read_credential_strings_many("bazz", &x, "bar", &y) == -EBADMSG); - assert_se(streq(x, "knurz")); - assert_se(streq(y, "paff")); + ASSERT_STREQ(x, "knurz"); + ASSERT_STREQ(y, "paff"); if (saved) assert_se(setenv("CREDENTIALS_DIRECTORY", saved, /* override= */ 1) >= 0); diff --git a/src/test/test-cryptolib.c b/src/test/test-cryptolib.c index 6202a5d6d4d..9f9be4d3727 100644 --- a/src/test/test-cryptolib.c +++ b/src/test/test-cryptolib.c @@ -14,25 +14,25 @@ TEST(string_hashsum) { OPENSSL_OR_GCRYPT("SHA224", GCRY_MD_SHA224), &out1) == 0); /* echo -n 'asdf' | sha224sum - */ - assert_se(streq(out1, "7872a74bcbf298a1e77d507cd95d4f8d96131cbbd4cdfc571e776c8a")); + ASSERT_STREQ(out1, "7872a74bcbf298a1e77d507cd95d4f8d96131cbbd4cdfc571e776c8a"); assert_se(string_hashsum("asdf", 4, OPENSSL_OR_GCRYPT("SHA256", GCRY_MD_SHA256), &out2) == 0); /* echo -n 'asdf' | sha256sum - */ - assert_se(streq(out2, "f0e4c2f76c58916ec258f246851bea091d14d4247a2fc3e18694461b1816e13b")); + ASSERT_STREQ(out2, "f0e4c2f76c58916ec258f246851bea091d14d4247a2fc3e18694461b1816e13b"); assert_se(string_hashsum("", 0, OPENSSL_OR_GCRYPT("SHA224", GCRY_MD_SHA224), &out3) == 0); /* echo -n '' | sha224sum - */ - assert_se(streq(out3, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f")); + ASSERT_STREQ(out3, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"); assert_se(string_hashsum("", 0, OPENSSL_OR_GCRYPT("SHA256", GCRY_MD_SHA256), &out4) == 0); /* echo -n '' | sha256sum - */ - assert_se(streq(out4, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")); + ASSERT_STREQ(out4, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); } DEFINE_TEST_MAIN(LOG_INFO); diff --git a/src/test/test-data-fd-util.c b/src/test/test-data-fd-util.c index 6d1cfe62899..4abd7a65190 100644 --- a/src/test/test-data-fd-util.c +++ b/src/test/test-data-fd-util.c @@ -22,7 +22,7 @@ static void test_acquire_data_fd_one(unsigned flags) { zero(rbuffer); assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 3); - assert_se(streq(rbuffer, "foo")); + ASSERT_STREQ(rbuffer, "foo"); fd = safe_close(fd); @@ -31,7 +31,7 @@ static void test_acquire_data_fd_one(unsigned flags) { zero(rbuffer); assert_se(read(fd, rbuffer, sizeof(rbuffer)) == 0); - assert_se(streq(rbuffer, "")); + ASSERT_STREQ(rbuffer, ""); fd = safe_close(fd); diff --git a/src/test/test-devnum-util.c b/src/test/test-devnum-util.c index 2068e351b9f..ebef794001b 100644 --- a/src/test/test-devnum-util.c +++ b/src/test/test-devnum-util.c @@ -109,7 +109,7 @@ TEST(device_path_make_canonical) { static void test_devnum_format_str_one(dev_t devnum, const char *s) { dev_t x; - assert_se(streq(FORMAT_DEVNUM(devnum), s)); + ASSERT_STREQ(FORMAT_DEVNUM(devnum), s); assert_se(parse_devnum(s, &x) >= 0); assert_se(x == devnum); } diff --git a/src/test/test-dns-domain.c b/src/test/test-dns-domain.c index 6c107e2f65a..d775601dae8 100644 --- a/src/test/test-dns-domain.c +++ b/src/test/test-dns-domain.c @@ -16,20 +16,20 @@ static void test_dns_label_unescape_one(const char *what, const char *expect, si r = dns_label_unescape(&w, buffer, buffer_sz, 0); assert_se(r == ret); if (r >= 0) - assert_se(streq(buffer, expect)); + ASSERT_STREQ(buffer, expect); w = what; r = dns_label_unescape(&w, buffer, buffer_sz, DNS_LABEL_LDH); assert_se(r == ret_ldh); if (r >= 0) - assert_se(streq(buffer, expect)); + ASSERT_STREQ(buffer, expect); w = what; r = dns_label_unescape(&w, buffer, buffer_sz, DNS_LABEL_NO_ESCAPES); const int ret_noe = strchr(what, '\\') ? -EINVAL : ret; assert_se(r == ret_noe); if (r >= 0) - assert_se(streq(buffer, expect)); + ASSERT_STREQ(buffer, expect); } TEST(dns_label_unescape) { @@ -131,12 +131,12 @@ static void test_dns_label_unescape_suffix_one(const char *what, const char *exp r = dns_label_unescape_suffix(what, &label, buffer, buffer_sz); assert_se(r == ret1); if (r >= 0) - assert_se(streq(buffer, expect1)); + ASSERT_STREQ(buffer, expect1); r = dns_label_unescape_suffix(what, &label, buffer, buffer_sz); assert_se(r == ret2); if (r >= 0) - assert_se(streq(buffer, expect2)); + ASSERT_STREQ(buffer, expect2); } TEST(dns_label_unescape_suffix) { @@ -173,7 +173,7 @@ static void test_dns_label_escape_one(const char *what, size_t l, const char *ex if (r < 0) return; - assert_se(streq_ptr(expect, t)); + ASSERT_STREQ(expect, t); } TEST(dns_label_escape) { @@ -193,7 +193,7 @@ static void test_dns_name_normalize_one(const char *what, const char *expect, in if (r < 0) return; - assert_se(streq_ptr(expect, t)); + ASSERT_STREQ(expect, t); } TEST(dns_name_normalize) { @@ -332,7 +332,7 @@ static void test_dns_name_reverse_one(const char *address, const char *name) { assert_se(in_addr_from_string_auto(address, &familya, &a) >= 0); assert_se(dns_name_reverse(familya, &a, &p) >= 0); - assert_se(streq(p, name)); + ASSERT_STREQ(p, name); assert_se(dns_name_address(p, &familyb, &b) > 0); assert_se(familya == familyb); assert_se(in_addr_equal(familya, &a, &b)); @@ -349,7 +349,7 @@ static void test_dns_name_concat_one(const char *a, const char *b, int r, const _cleanup_free_ char *p = NULL; assert_se(dns_name_concat(a, b, 0, &p) == r); - assert_se(streq_ptr(p, result)); + ASSERT_STREQ(p, result); } TEST(dns_name_concat) { @@ -486,14 +486,14 @@ static void test_dns_service_join_one(const char *a, const char *b, const char * log_info("%s, %s, %s, →%d, %s", strnull(a), strnull(b), strnull(c), r, strnull(d)); assert_se(dns_service_join(a, b, c, &t) == r); - assert_se(streq_ptr(t, d)); + ASSERT_STREQ(t, d); if (r < 0) return; assert_se(dns_service_split(t, &x, &y, &z) >= 0); - assert_se(streq_ptr(a, x)); - assert_se(streq_ptr(b, y)); + ASSERT_STREQ(a, x); + ASSERT_STREQ(b, y); assert_se(dns_name_equal(c, z) > 0); } @@ -518,9 +518,9 @@ static void test_dns_service_split_one(const char *joined, const char *a, const log_info("%s, %s, %s, %s, →%d", joined, strnull(a), strnull(b), strnull(c), r); assert_se(dns_service_split(joined, &x, &y, &z) == r); - assert_se(streq_ptr(x, a)); - assert_se(streq_ptr(y, b)); - assert_se(streq_ptr(z, c)); + ASSERT_STREQ(x, a); + ASSERT_STREQ(y, b); + ASSERT_STREQ(z, c); if (r < 0) return; @@ -549,7 +549,7 @@ static void test_dns_name_change_suffix_one(const char *name, const char *old_su log_info("%s, %s, %s, →%s", name, old_suffix, new_suffix, strnull(result)); assert_se(dns_name_change_suffix(name, old_suffix, new_suffix, &s) == r); - assert_se(streq_ptr(s, result)); + ASSERT_STREQ(s, result); } TEST(dns_name_change_suffix) { @@ -570,7 +570,7 @@ static void test_dns_name_suffix_one(const char *name, unsigned n_labels, const log_info("%s, %u, → %s, %d", name, n_labels, strnull(result), ret); assert_se(ret == dns_name_suffix(name, n_labels, &p)); - assert_se(streq_ptr(p, result)); + ASSERT_STREQ(p, result); } TEST(dns_name_suffix) { @@ -660,7 +660,7 @@ static void test_dns_name_common_suffix_one(const char *a, const char *b, const log_info("%s, %s, →%s", a, b, result); assert_se(dns_name_common_suffix(a, b, &c) >= 0); - assert_se(streq(c, result)); + ASSERT_STREQ(c, result); } TEST(dns_name_common_suffix) { diff --git a/src/test/test-ellipsize.c b/src/test/test-ellipsize.c index c272c561d29..f1814768fd6 100644 --- a/src/test/test-ellipsize.c +++ b/src/test/test-ellipsize.c @@ -57,9 +57,9 @@ static void test_ellipsize_mem_one(const char *s, size_t old_length, size_t new_ assert_se(utf8_console_width(t3) <= max_width); if (new_length >= old_length) { - assert_se(streq(t1, n)); - assert_se(streq(t2, n)); - assert_se(streq(t3, n)); + ASSERT_STREQ(t1, n); + ASSERT_STREQ(t2, n); + ASSERT_STREQ(t3, n); } } @@ -143,17 +143,17 @@ TEST(ellipsize_ansi_cats) { e = ellipsize("01" ANSI_NORMAL "23", 4, 0); puts(e); - assert_se(streq(e, "01" ANSI_NORMAL "23")); + ASSERT_STREQ(e, "01" ANSI_NORMAL "23"); f = ellipsize("ab" ANSI_NORMAL "cd", 4, 90); puts(f); - assert_se(streq(f, "ab" ANSI_NORMAL "cd")); + ASSERT_STREQ(f, "ab" ANSI_NORMAL "cd"); g = ellipsize("🐱🐱" ANSI_NORMAL "🐱🐱" ANSI_NORMAL, 5, 0); puts(g); - assert_se(streq(g, "…" ANSI_NORMAL "🐱🐱" ANSI_NORMAL)); + ASSERT_STREQ(g, "…" ANSI_NORMAL "🐱🐱" ANSI_NORMAL); h = ellipsize("🐱🐱" ANSI_NORMAL "🐱🐱" ANSI_NORMAL, 5, 90); puts(h); - assert_se(streq(h, "🐱…" ANSI_NORMAL "🐱" ANSI_NORMAL)); + ASSERT_STREQ(h, "🐱…" ANSI_NORMAL "🐱" ANSI_NORMAL); } DEFINE_TEST_MAIN(LOG_INFO); diff --git a/src/test/test-engine.c b/src/test/test-engine.c index e03d179d4e6..fa64fbefaba 100644 --- a/src/test/test-engine.c +++ b/src/test/test-engine.c @@ -214,7 +214,7 @@ int main(int argc, char *argv[]) { assert_se(manager_load_unit(m, "unit-with-multiple-dashes.service", NULL, NULL, &unit_with_multiple_dashes) >= 0); assert_se(strv_equal(unit_with_multiple_dashes->documentation, STRV_MAKE("man:test", "man:override2", "man:override3"))); - assert_se(streq_ptr(unit_with_multiple_dashes->description, "override4")); + ASSERT_STREQ(unit_with_multiple_dashes->description, "override4"); /* Now merge a synthetic unit into the existing one */ assert_se(unit_new_for_name(m, sizeof(Service), "merged.service", &stub) >= 0); diff --git a/src/test/test-env-file.c b/src/test/test-env-file.c index e2fce7f53d1..f34b2aac723 100644 --- a/src/test/test-env-file.c +++ b/src/test/test-env-file.c @@ -65,12 +65,12 @@ TEST(load_env_file_1) { _cleanup_strv_free_ char **data = NULL; assert_se(load_env_file(NULL, name, &data) == 0); - assert_se(streq(data[0], "a=a")); - assert_se(streq(data[1], "b=bc")); - assert_se(streq(data[2], "d=de f")); - assert_se(streq(data[3], "g=g ")); - assert_se(streq(data[4], "h=ąęół śćńźżμ")); - assert_se(streq(data[5], "i=i")); + ASSERT_STREQ(data[0], "a=a"); + ASSERT_STREQ(data[1], "b=bc"); + ASSERT_STREQ(data[2], "d=de f"); + ASSERT_STREQ(data[3], "g=g "); + ASSERT_STREQ(data[4], "h=ąęół śćńźżμ"); + ASSERT_STREQ(data[5], "i=i"); ASSERT_NULL(data[6]); } @@ -80,7 +80,7 @@ TEST(load_env_file_2) { _cleanup_strv_free_ char **data = NULL; assert_se(load_env_file(NULL, name, &data) == 0); - assert_se(streq(data[0], "a=a")); + ASSERT_STREQ(data[0], "a=a"); ASSERT_NULL(data[1]); } @@ -90,8 +90,8 @@ TEST(load_env_file_3) { _cleanup_strv_free_ char **data = NULL; assert_se(load_env_file(NULL, name, &data) == 0); - assert_se(streq(data[0], "normal1=line111")); - assert_se(streq(data[1], "normal2=line222")); + ASSERT_STREQ(data[0], "normal1=line111"); + ASSERT_STREQ(data[1], "normal2=line222"); ASSERT_NULL(data[2]); } @@ -101,9 +101,9 @@ TEST(load_env_file_4) { _cleanup_strv_free_ char **data = NULL; assert_se(load_env_file(NULL, name, &data) == 0); - assert_se(streq(data[0], "HWMON_MODULES=coretemp f71882fg")); - assert_se(streq(data[1], "MODULE_0=coretemp")); - assert_se(streq(data[2], "MODULE_1=f71882fg")); + ASSERT_STREQ(data[0], "HWMON_MODULES=coretemp f71882fg"); + ASSERT_STREQ(data[1], "MODULE_0=coretemp"); + ASSERT_STREQ(data[2], "MODULE_1=f71882fg"); ASSERT_NULL(data[3]); } @@ -113,8 +113,8 @@ TEST(load_env_file_5) { _cleanup_strv_free_ char **data = NULL; assert_se(load_env_file(NULL, name, &data) == 0); - assert_se(streq(data[0], "a=")); - assert_se(streq(data[1], "b=")); + ASSERT_STREQ(data[0], "a="); + ASSERT_STREQ(data[1], "b="); ASSERT_NULL(data[2]); } @@ -124,10 +124,10 @@ TEST(load_env_file_6) { _cleanup_strv_free_ char **data = NULL; assert_se(load_env_file(NULL, name, &data) == 0); - assert_se(streq(data[0], "a= n t x y '")); - assert_se(streq(data[1], "b=$'")); - assert_se(streq(data[2], "c= \\n\\t\\$\\`\\\\\n")); - assert_se(streq(data[3], "d= \\n\\t$`\\\n")); + ASSERT_STREQ(data[0], "a= n t x y '"); + ASSERT_STREQ(data[1], "b=$'"); + ASSERT_STREQ(data[2], "c= \\n\\t\\$\\`\\\\\n"); + ASSERT_STREQ(data[3], "d= \\n\\t$`\\\n"); ASSERT_NULL(data[4]); } @@ -178,13 +178,13 @@ TEST(write_and_load_env_file) { assert_se(f = popen(cmd, "re")); assert_se(read_full_stream(f, &from_shell, &sz) >= 0); assert_se(sz == strlen(v)); - assert_se(streq(from_shell, v)); + ASSERT_STREQ(from_shell, v); assert_se(load_env_file(NULL, p, &l) >= 0); assert_se(strv_equal(l, STRV_MAKE(j))); assert_se(parse_env_file(NULL, p, "TEST", &w) >= 0); - assert_se(streq_ptr(w, v)); + ASSERT_STREQ(w, v); } } diff --git a/src/test/test-env-util.c b/src/test/test-env-util.c index 6b7520bfb0b..e2c009dc9c5 100644 --- a/src/test/test-env-util.c +++ b/src/test/test-env-util.c @@ -26,26 +26,26 @@ TEST(strv_env_delete) { d = strv_env_delete(a, 2, b, c); assert_se(d); - assert_se(streq(d[0], "WALDO=WALDO")); - assert_se(streq(d[1], "WALDO=")); + ASSERT_STREQ(d[0], "WALDO=WALDO"); + ASSERT_STREQ(d[1], "WALDO="); assert_se(strv_length(d) == 2); } TEST(strv_env_get) { char **l = STRV_MAKE("ONE_OR_TWO=1", "THREE=3", "ONE_OR_TWO=2", "FOUR=4"); - assert_se(streq(strv_env_get(l, "ONE_OR_TWO"), "2")); - assert_se(streq(strv_env_get(l, "THREE"), "3")); - assert_se(streq(strv_env_get(l, "FOUR"), "4")); + ASSERT_STREQ(strv_env_get(l, "ONE_OR_TWO"), "2"); + ASSERT_STREQ(strv_env_get(l, "THREE"), "3"); + ASSERT_STREQ(strv_env_get(l, "FOUR"), "4"); } TEST(strv_env_pairs_get) { char **l = STRV_MAKE("ONE_OR_TWO", "1", "THREE", "3", "ONE_OR_TWO", "2", "FOUR", "4", "FIVE", "5", "SIX", "FIVE", "SEVEN", "7"); - assert_se(streq(strv_env_pairs_get(l, "ONE_OR_TWO"), "2")); - assert_se(streq(strv_env_pairs_get(l, "THREE"), "3")); - assert_se(streq(strv_env_pairs_get(l, "FOUR"), "4")); - assert_se(streq(strv_env_pairs_get(l, "FIVE"), "5")); + ASSERT_STREQ(strv_env_pairs_get(l, "ONE_OR_TWO"), "2"); + ASSERT_STREQ(strv_env_pairs_get(l, "THREE"), "3"); + ASSERT_STREQ(strv_env_pairs_get(l, "FOUR"), "4"); + ASSERT_STREQ(strv_env_pairs_get(l, "FIVE"), "5"); } TEST(strv_env_unset) { @@ -56,8 +56,8 @@ TEST(strv_env_unset) { assert_se(strv_env_unset(l, "SCHLUMPF") == l); - assert_se(streq(l[0], "PIEP")); - assert_se(streq(l[1], "NANANANA=YES")); + ASSERT_STREQ(l[0], "PIEP"); + ASSERT_STREQ(l[1], "NANANANA=YES"); assert_se(strv_length(l) == 2); } @@ -67,22 +67,22 @@ TEST(strv_env_merge) { _cleanup_strv_free_ char **r = strv_env_merge(NULL, a, NULL, b, NULL, a, b, b, NULL); assert_se(r); - assert_se(streq(r[0], "FOO=")); - assert_se(streq(r[1], "WALDO=")); - assert_se(streq(r[2], "PIEP")); - assert_se(streq(r[3], "SCHLUMPF=SMURFF")); - assert_se(streq(r[4], "EQ===")); - assert_se(streq(r[5], "PIEP=")); - assert_se(streq(r[6], "NANANANA=YES")); + ASSERT_STREQ(r[0], "FOO="); + ASSERT_STREQ(r[1], "WALDO="); + ASSERT_STREQ(r[2], "PIEP"); + ASSERT_STREQ(r[3], "SCHLUMPF=SMURFF"); + ASSERT_STREQ(r[4], "EQ==="); + ASSERT_STREQ(r[5], "PIEP="); + ASSERT_STREQ(r[6], "NANANANA=YES"); assert_se(strv_length(r) == 7); assert_se(strv_env_clean(r) == r); - assert_se(streq(r[0], "FOO=")); - assert_se(streq(r[1], "WALDO=")); - assert_se(streq(r[2], "SCHLUMPF=SMURFF")); - assert_se(streq(r[3], "EQ===")); - assert_se(streq(r[4], "PIEP=")); - assert_se(streq(r[5], "NANANANA=YES")); + ASSERT_STREQ(r[0], "FOO="); + ASSERT_STREQ(r[1], "WALDO="); + ASSERT_STREQ(r[2], "SCHLUMPF=SMURFF"); + ASSERT_STREQ(r[3], "EQ==="); + ASSERT_STREQ(r[4], "PIEP="); + ASSERT_STREQ(r[5], "NANANANA=YES"); assert_se(strv_length(r) == 6); } @@ -96,8 +96,8 @@ TEST(strv_env_replace_strdup) { assert_se(strv_length(a) == 2); strv_sort(a); - assert_se(streq(a[0], "a=A")); - assert_se(streq(a[1], "b=b")); + ASSERT_STREQ(a[0], "a=A"); + ASSERT_STREQ(a[1], "b=b"); } TEST(strv_env_replace_strdup_passthrough) { @@ -114,9 +114,9 @@ TEST(strv_env_replace_strdup_passthrough) { assert_se(strv_env_replace_strdup_passthrough(&a, "$a") == -EINVAL); assert_se(strv_length(a) == 3); - assert_se(streq(a[0], "a=a")); - assert_se(streq(a[1], "b=")); - assert_se(streq(a[2], "c=")); + ASSERT_STREQ(a[0], "a=a"); + ASSERT_STREQ(a[1], "b="); + ASSERT_STREQ(a[2], "c="); } TEST(strv_env_assign) { @@ -130,7 +130,7 @@ TEST(strv_env_assign) { assert_se(strv_env_assign(&a, "a=", "B") == -EINVAL); assert_se(strv_length(a) == 1); - assert_se(streq(a[0], "a=A")); + ASSERT_STREQ(a[0], "a=A"); } TEST(strv_env_assignf) { @@ -151,7 +151,7 @@ TEST(strv_env_assignf) { assert_se(strv_env_assignf(&a, "a=", "B") == -EINVAL); assert_se(strv_length(a) == 1); - assert_se(streq(a[0], "a=A")); + ASSERT_STREQ(a[0], "a=A"); } TEST(strv_env_assign_many) { @@ -190,15 +190,15 @@ TEST(env_strv_get_n) { }; char **env = (char**) _env; - assert_se(streq(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR")); - assert_se(streq(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR")); - assert_se(streq(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR")); - assert_se(streq(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR")); + ASSERT_STREQ(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR"); + ASSERT_STREQ(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"); + ASSERT_STREQ(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR"); + ASSERT_STREQ(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"); - assert_se(streq(strv_env_get_n(env, "PATH__", 4, 0), "unset")); - assert_se(streq(strv_env_get_n(env, "PATH", 4, 0), "unset")); - assert_se(streq(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset")); - assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset")); + ASSERT_STREQ(strv_env_get_n(env, "PATH__", 4, 0), "unset"); + ASSERT_STREQ(strv_env_get_n(env, "PATH", 4, 0), "unset"); + ASSERT_STREQ(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"); + ASSERT_STREQ(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"); env[3] = NULL; /* kill our $PATH */ @@ -222,19 +222,19 @@ static void test_replace_env1(bool braceless) { unsigned flags = REPLACE_ENV_ALLOW_BRACELESS*braceless; assert_se(replace_env("FOO=$FOO=${FOO}", (char**) env, flags, &t) >= 0); - assert_se(streq(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR")); + ASSERT_STREQ(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR"); assert_se(replace_env("BAR=$BAR=${BAR}", (char**) env, flags, &s) >= 0); - assert_se(streq(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo")); + ASSERT_STREQ(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo"); assert_se(replace_env("BARBAR=$BARBAR=${BARBAR}", (char**) env, flags, &q) >= 0); - assert_se(streq(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR=")); + ASSERT_STREQ(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR="); assert_se(replace_env("BAR=$BAR$BAR${BAR}${BAR}", (char**) env, flags, &r) >= 0); - assert_se(streq(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo")); + ASSERT_STREQ(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo"); assert_se(replace_env("${BAR}$BAR$BAR", (char**) env, flags, &p) >= 0); - assert_se(streq(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR")); + ASSERT_STREQ(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR"); } static void test_replace_env2(bool extended) { @@ -249,25 +249,25 @@ static void test_replace_env2(bool extended) { unsigned flags = REPLACE_ENV_ALLOW_EXTENDED*extended; assert_se(replace_env("FOO=${FOO:-${BAR}}", (char**) env, flags, &t) >= 0); - assert_se(streq(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}")); + ASSERT_STREQ(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}"); assert_se(replace_env("BAR=${XXX:-${BAR}}", (char**) env, flags, &s) >= 0); - assert_se(streq(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}")); + ASSERT_STREQ(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}"); assert_se(replace_env("XXX=${XXX:+${BAR}}", (char**) env, flags, &q) >= 0); - assert_se(streq(q, extended ? "XXX=" : "XXX=${XXX:+bar}")); + ASSERT_STREQ(q, extended ? "XXX=" : "XXX=${XXX:+bar}"); assert_se(replace_env("FOO=${FOO:+${BAR}}", (char**) env, flags, &r) >= 0); - assert_se(streq(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}")); + ASSERT_STREQ(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}"); assert_se(replace_env("FOO=${FOO:-${BAR}post}", (char**) env, flags, &p) >= 0); - assert_se(streq(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}")); + ASSERT_STREQ(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}"); assert_se(replace_env("XXX=${XXX:+${BAR}post}", (char**) env, flags, &x) >= 0); - assert_se(streq(x, extended ? "XXX=" : "XXX=${XXX:+barpost}")); + ASSERT_STREQ(x, extended ? "XXX=" : "XXX=${XXX:+barpost}"); assert_se(replace_env("FOO=${FOO}between${BAR:-baz}", (char**) env, flags, &y) >= 0); - assert_se(streq(y, extended ? "FOO=foobetweenbar" : "FOO=foobetween${BAR:-baz}")); + ASSERT_STREQ(y, extended ? "FOO=foobetweenbar" : "FOO=foobetween${BAR:-baz}"); } TEST(replace_env) { @@ -307,23 +307,23 @@ TEST(replace_env_argv) { assert_se(replace_env_argv((char**) line, (char**) env, &r, NULL, NULL) >= 0); assert_se(r); - assert_se(streq(r[0], "FOO$FOO")); - assert_se(streq(r[1], "FOO$FOOFOO")); - assert_se(streq(r[2], "FOOBAR BAR$FOO")); - assert_se(streq(r[3], "FOOBAR BAR")); - assert_se(streq(r[4], "BAR BAR")); - assert_se(streq(r[5], "BAR")); - assert_se(streq(r[6], "BAR")); - assert_se(streq(r[7], "BAR BARwaldo")); - assert_se(streq(r[8], "${FOO")); - assert_se(streq(r[9], "FOO$BAR BAR")); - assert_se(streq(r[10], "$FOOBAR BAR")); - assert_se(streq(r[11], "${FOO:-waldo}")); - assert_se(streq(r[12], "${QUUX:-BAR BAR}")); - assert_se(streq(r[13], "${FOO:+waldo}")); - assert_se(streq(r[14], "${QUUX:+waldo}")); - assert_se(streq(r[15], "${FOO:+|waldo|}}")); - assert_se(streq(r[16], "${FOO:+|waldo{|}")); + ASSERT_STREQ(r[0], "FOO$FOO"); + ASSERT_STREQ(r[1], "FOO$FOOFOO"); + ASSERT_STREQ(r[2], "FOOBAR BAR$FOO"); + ASSERT_STREQ(r[3], "FOOBAR BAR"); + ASSERT_STREQ(r[4], "BAR BAR"); + ASSERT_STREQ(r[5], "BAR"); + ASSERT_STREQ(r[6], "BAR"); + ASSERT_STREQ(r[7], "BAR BARwaldo"); + ASSERT_STREQ(r[8], "${FOO"); + ASSERT_STREQ(r[9], "FOO$BAR BAR"); + ASSERT_STREQ(r[10], "$FOOBAR BAR"); + ASSERT_STREQ(r[11], "${FOO:-waldo}"); + ASSERT_STREQ(r[12], "${QUUX:-BAR BAR}"); + ASSERT_STREQ(r[13], "${FOO:+waldo}"); + ASSERT_STREQ(r[14], "${QUUX:+waldo}"); + ASSERT_STREQ(r[15], "${FOO:+|waldo|}}"); + ASSERT_STREQ(r[16], "${FOO:+|waldo{|}"); assert_se(strv_length(r) == 17); } @@ -393,14 +393,14 @@ TEST(env_clean) { assert_se(strv_env_clean(e) == e); assert_se(strv_env_is_valid(e)); - assert_se(streq(e[0], "FOOBAR=WALDO")); - assert_se(streq(e[1], "X=")); - assert_se(streq(e[2], "F=F")); - assert_se(streq(e[3], "abcd=äöüß")); - assert_se(streq(e[4], "xyz=xyz\n")); - assert_se(streq(e[5], "another=final one")); - assert_se(streq(e[6], "CRLF=\r\n")); - assert_se(streq(e[7], "LESS_TERMCAP_mb=\x1b[01;31m")); + ASSERT_STREQ(e[0], "FOOBAR=WALDO"); + ASSERT_STREQ(e[1], "X="); + ASSERT_STREQ(e[2], "F=F"); + ASSERT_STREQ(e[3], "abcd=äöüß"); + ASSERT_STREQ(e[4], "xyz=xyz\n"); + ASSERT_STREQ(e[5], "another=final one"); + ASSERT_STREQ(e[6], "CRLF=\r\n"); + ASSERT_STREQ(e[7], "LESS_TERMCAP_mb=\x1b[01;31m"); ASSERT_NULL(e[8]); } @@ -451,13 +451,13 @@ TEST(env_assignment_is_valid) { TEST(putenv_dup) { assert_se(putenv_dup("A=a1", true) == 0); - assert_se(streq_ptr(getenv("A"), "a1")); + ASSERT_STREQ(getenv("A"), "a1"); assert_se(putenv_dup("A=a1", true) == 0); - assert_se(streq_ptr(getenv("A"), "a1")); + ASSERT_STREQ(getenv("A"), "a1"); assert_se(putenv_dup("A=a2", false) == 0); - assert_se(streq_ptr(getenv("A"), "a1")); + ASSERT_STREQ(getenv("A"), "a1"); assert_se(putenv_dup("A=a2", true) == 0); - assert_se(streq_ptr(getenv("A"), "a2")); + ASSERT_STREQ(getenv("A"), "a2"); } TEST(setenv_systemd_exec_pid) { @@ -476,7 +476,7 @@ TEST(setenv_systemd_exec_pid) { assert_se(setenv("SYSTEMD_EXEC_PID", "*", 1) >= 0); assert_se(setenv_systemd_exec_pid(true) == 0); assert_se(e = getenv("SYSTEMD_EXEC_PID")); - assert_se(streq(e, "*")); + ASSERT_STREQ(e, "*"); assert_se(setenv("SYSTEMD_EXEC_PID", "123abc", 1) >= 0); assert_se(setenv_systemd_exec_pid(true) == 1); @@ -523,10 +523,10 @@ TEST(getenv_steal_erase) { copy1 = strdup(eq + 1); assert_se(copy1); - assert_se(streq_ptr(getenv(n), copy1)); + ASSERT_STREQ(getenv(n), copy1); assert_se(getenv(n) == eq + 1); assert_se(getenv_steal_erase(n, ©2) > 0); - assert_se(streq_ptr(copy1, copy2)); + ASSERT_STREQ(copy1, copy2); assert_se(isempty(eq + 1)); assert_se(!getenv(n)); } @@ -571,11 +571,11 @@ TEST(getenv_path_list) { /* Finally some valid paths */ assert_se(setenv("TEST_GETENV_PATH_LIST", "/foo:/bar/baz:/hello/world:/path with spaces:/final", 1) >= 0); assert_se(getenv_path_list("TEST_GETENV_PATH_LIST", &path_list) >= 0); - assert_se(streq(path_list[0], "/foo")); - assert_se(streq(path_list[1], "/bar/baz")); - assert_se(streq(path_list[2], "/hello/world")); - assert_se(streq(path_list[3], "/path with spaces")); - assert_se(streq(path_list[4], "/final")); + ASSERT_STREQ(path_list[0], "/foo"); + ASSERT_STREQ(path_list[1], "/bar/baz"); + ASSERT_STREQ(path_list[2], "/hello/world"); + ASSERT_STREQ(path_list[3], "/path with spaces"); + ASSERT_STREQ(path_list[4], "/final"); ASSERT_NULL(path_list[5]); assert_se(unsetenv("TEST_GETENV_PATH_LIST") >= 0); diff --git a/src/test/test-errno-list.c b/src/test/test-errno-list.c index f91a1f770f0..77f418750cd 100644 --- a/src/test/test-errno-list.c +++ b/src/test/test-errno-list.c @@ -11,22 +11,22 @@ TEST(errno_list) { for (size_t i = 0; i < ELEMENTSOF(errno_names); i++) { if (errno_names[i]) { - assert_se(streq(errno_to_name(i), errno_names[i])); + ASSERT_STREQ(errno_to_name(i), errno_names[i]); assert_se(errno_from_name(errno_names[i]) == (int) i); } } #ifdef ECANCELLED /* ECANCELLED is an alias of ECANCELED. */ - assert_se(streq(errno_to_name(ECANCELLED), "ECANCELED")); + ASSERT_STREQ(errno_to_name(ECANCELLED), "ECANCELED"); #endif - assert_se(streq(errno_to_name(ECANCELED), "ECANCELED")); + ASSERT_STREQ(errno_to_name(ECANCELED), "ECANCELED"); #ifdef EREFUSED /* EREFUSED is an alias of ECONNREFUSED. */ - assert_se(streq(errno_to_name(EREFUSED), "ECONNREFUSED")); + ASSERT_STREQ(errno_to_name(EREFUSED), "ECONNREFUSED"); #endif - assert_se(streq(errno_to_name(ECONNREFUSED), "ECONNREFUSED")); + ASSERT_STREQ(errno_to_name(ECONNREFUSED), "ECONNREFUSED"); } DEFINE_TEST_MAIN(LOG_INFO); diff --git a/src/test/test-errno-util.c b/src/test/test-errno-util.c index 376d532281a..ab463bd1b39 100644 --- a/src/test/test-errno-util.c +++ b/src/test/test-errno-util.c @@ -31,8 +31,8 @@ TEST(STRERROR) { assert_se(strstr(b, "201")); /* Check with negative values */ - assert_se(streq(a, STRERROR(-200))); - assert_se(streq(b, STRERROR(-201))); + ASSERT_STREQ(a, STRERROR(-200)); + ASSERT_STREQ(b, STRERROR(-201)); const char *c = STRERROR(INT_MAX); char buf[DECIMAL_STR_MAX(int)]; diff --git a/src/test/test-escape.c b/src/test/test-escape.c index 364e0f39564..89a25febb43 100644 --- a/src/test/test-escape.c +++ b/src/test/test-escape.c @@ -9,14 +9,14 @@ TEST(cescape) { _cleanup_free_ char *t = NULL; assert_se(t = cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313")); - assert_se(streq(t, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313")); + ASSERT_STREQ(t, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"); } TEST(xescape) { _cleanup_free_ char *t = NULL; assert_se(t = xescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313", "")); - assert_se(streq(t, "abc\\x5c\"\\x08\\x0c\\x0a\\x0d\\x09\\x0b\\x07\\x03\\x7f\\x9c\\xcb")); + ASSERT_STREQ(t, "abc\\x5c\"\\x08\\x0c\\x0a\\x0d\\x09\\x0b\\x07\\x03\\x7f\\x9c\\xcb"); } static void test_xescape_full_one(bool eight_bits) { @@ -36,7 +36,7 @@ static void test_xescape_full_one(bool eight_bits) { log_info("%02u: <%s>", i, t); if (i >= full_fit) - assert_se(streq(t, escaped)); + ASSERT_STREQ(t, escaped); else if (i >= 3) { /* We need up to four columns, so up to three columns may be wasted */ assert_se(strlen(t) == i || strlen(t) == i - 1 || strlen(t) == i - 2 || strlen(t) == i - 3); @@ -69,50 +69,50 @@ TEST(cunescape) { assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped) < 0); assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00")); + ASSERT_STREQ(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"); unescaped = mfree(unescaped); /* incomplete sequences */ assert_se(cunescape("\\x0", 0, &unescaped) < 0); assert_se(cunescape("\\x0", UNESCAPE_RELAX, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, "\\x0")); + ASSERT_STREQ(unescaped, "\\x0"); unescaped = mfree(unescaped); assert_se(cunescape("\\x", 0, &unescaped) < 0); assert_se(cunescape("\\x", UNESCAPE_RELAX, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, "\\x")); + ASSERT_STREQ(unescaped, "\\x"); unescaped = mfree(unescaped); assert_se(cunescape("\\", 0, &unescaped) < 0); assert_se(cunescape("\\", UNESCAPE_RELAX, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, "\\")); + ASSERT_STREQ(unescaped, "\\"); unescaped = mfree(unescaped); assert_se(cunescape("\\11", 0, &unescaped) < 0); assert_se(cunescape("\\11", UNESCAPE_RELAX, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, "\\11")); + ASSERT_STREQ(unescaped, "\\11"); unescaped = mfree(unescaped); assert_se(cunescape("\\1", 0, &unescaped) < 0); assert_se(cunescape("\\1", UNESCAPE_RELAX, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, "\\1")); + ASSERT_STREQ(unescaped, "\\1"); unescaped = mfree(unescaped); assert_se(cunescape("\\u0000", 0, &unescaped) < 0); assert_se(cunescape("\\u00DF\\U000000df\\u03a0\\U00000041", UNESCAPE_RELAX, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, "ßßΠA")); + ASSERT_STREQ(unescaped, "ßßΠA"); unescaped = mfree(unescaped); assert_se(cunescape("\\073", 0, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, ";")); + ASSERT_STREQ(unescaped, ";"); unescaped = mfree(unescaped); assert_se(cunescape("A=A\\\\x0aB", 0, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, "A=A\\x0aB")); + ASSERT_STREQ(unescaped, "A=A\\x0aB"); unescaped = mfree(unescaped); assert_se(cunescape("A=A\\\\x0aB", UNESCAPE_RELAX, &unescaped) >= 0); - assert_se(streq_ptr(unescaped, "A=A\\x0aB")); + ASSERT_STREQ(unescaped, "A=A\\x0aB"); unescaped = mfree(unescaped); assert_se(cunescape("\\x00\\x00\\x00", UNESCAPE_ACCEPT_NUL, &unescaped) == 3); @@ -136,7 +136,7 @@ static void test_shell_escape_one(const char *s, const char *bad, const char *ex assert_se(r = shell_escape(s, bad)); log_debug("%s → %s (expected %s)", s, r, expected); - assert_se(streq_ptr(r, expected)); + ASSERT_STREQ(r, expected); } TEST(shell_escape) { @@ -153,7 +153,7 @@ static void test_shell_maybe_quote_one(const char *s, ShellEscapeFlags flags, co assert_se(ret = shell_maybe_quote(s, flags)); log_debug("[%s] → [%s] (%s)", s, ret, expected); - assert_se(streq(ret, expected)); + ASSERT_STREQ(ret, expected); } TEST(shell_maybe_quote) { @@ -207,7 +207,7 @@ static void test_quote_command_line_one(char **argv, const char *expected) { assert_se(s = quote_command_line(argv, SHELL_ESCAPE_EMPTY)); log_info("%s", s); - assert_se(streq(s, expected)); + ASSERT_STREQ(s, expected); } TEST(quote_command_line) { @@ -228,7 +228,7 @@ static void test_octescape_one(const char *s, const char *expected) { assert_se(ret = octescape(s, strlen_ptr(s))); log_debug("octescape(\"%s\") → \"%s\" (expected: \"%s\")", strnull(s), ret, expected); - assert_se(streq(ret, expected)); + ASSERT_STREQ(ret, expected); } TEST(octescape) { @@ -244,7 +244,7 @@ static void test_decescape_one(const char *s, const char *bad, const char *expec assert_se(ret = decescape(s, bad, strlen_ptr(s))); log_debug("decescape(\"%s\") → \"%s\" (expected: \"%s\")", strnull(s), ret, expected); - assert_se(streq(ret, expected)); + ASSERT_STREQ(ret, expected); } TEST(decescape) { diff --git a/src/test/test-ether-addr-util.c b/src/test/test-ether-addr-util.c index d680f80a700..4826a6f13b0 100644 --- a/src/test/test-ether-addr-util.c +++ b/src/test/test-ether-addr-util.c @@ -72,7 +72,7 @@ static void test_parse_hw_addr_full_one(const char *in, size_t expected_len, con if (r >= 0) { if (!IN_SET(expected_len, 0, SIZE_MAX)) assert_se(h.length == expected_len); - assert_se(streq(HW_ADDR_TO_STR(&h), expected)); + ASSERT_STREQ(HW_ADDR_TO_STR(&h), expected); } } diff --git a/src/test/test-exec-util.c b/src/test/test-exec-util.c index 2304f6a8b67..a57786037bc 100644 --- a/src/test/test-exec-util.c +++ b/src/test/test-exec-util.c @@ -195,7 +195,7 @@ TEST(execution_order) { execute_directories(dirs, DEFAULT_TIMEOUT_USEC, ignore_stdout, ignore_stdout_args, NULL, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS); assert_se(read_full_file(output, &contents, NULL) >= 0); - assert_se(streq(contents, "30-override\n80-foo\n90-bar\nlast\n")); + ASSERT_STREQ(contents, "30-override\n80-foo\n90-bar\nlast\n"); } static int gather_stdout_one(int fd, void *arg) { @@ -279,7 +279,7 @@ TEST(stdout_gathering) { log_info("got: %s", output); - assert_se(streq(output, "a\nb\nc\nd\n")); + ASSERT_STREQ(output, "a\nb\nc\nd\n"); } TEST(environment_gathering) { @@ -346,10 +346,10 @@ TEST(environment_gathering) { STRV_FOREACH(p, env) log_info("got env: \"%s\"", *p); - assert_se(streq(strv_env_get(env, "A"), "22:23:24")); - assert_se(streq(strv_env_get(env, "B"), "12")); - assert_se(streq(strv_env_get(env, "C"), "001")); - assert_se(streq(strv_env_get(env, "PATH"), "no-sh-built-in-path:/no/such/file")); + ASSERT_STREQ(strv_env_get(env, "A"), "22:23:24"); + ASSERT_STREQ(strv_env_get(env, "B"), "12"); + ASSERT_STREQ(strv_env_get(env, "C"), "001"); + ASSERT_STREQ(strv_env_get(env, "PATH"), "no-sh-built-in-path:/no/such/file"); /* now retest with "default" path passed in, as created by * manager_default_environment */ @@ -363,10 +363,10 @@ TEST(environment_gathering) { STRV_FOREACH(p, env) log_info("got env: \"%s\"", *p); - assert_se(streq(strv_env_get(env, "A"), "22:23:24")); - assert_se(streq(strv_env_get(env, "B"), "12")); - assert_se(streq(strv_env_get(env, "C"), "001")); - assert_se(streq(strv_env_get(env, "PATH"), DEFAULT_PATH ":/no/such/file")); + ASSERT_STREQ(strv_env_get(env, "A"), "22:23:24"); + ASSERT_STREQ(strv_env_get(env, "B"), "12"); + ASSERT_STREQ(strv_env_get(env, "C"), "001"); + ASSERT_STREQ(strv_env_get(env, "PATH"), DEFAULT_PATH ":/no/such/file"); /* reset environ PATH */ assert_se(set_unset_env("PATH", old, true) == 0); diff --git a/src/test/test-exit-status.c b/src/test/test-exit-status.c index 86d39767d49..aab81935192 100644 --- a/src/test/test-exit-status.c +++ b/src/test/test-exit-status.c @@ -29,8 +29,8 @@ TEST(exit_status_from_string) { } TEST(exit_status_NUMA_POLICY) { - assert_se(streq(exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_FULL), "NUMA_POLICY")); - assert_se(streq(exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_SYSTEMD), "NUMA_POLICY")); + ASSERT_STREQ(exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_FULL), "NUMA_POLICY"); + ASSERT_STREQ(exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_SYSTEMD), "NUMA_POLICY"); assert_se(!exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_BSD)); assert_se(!exit_status_to_string(EXIT_NUMA_POLICY, EXIT_STATUS_LSB)); } diff --git a/src/test/test-extract-word.c b/src/test/test-extract-word.c index beb8f5db220..1bc4088fb42 100644 --- a/src/test/test-extract-word.c +++ b/src/test/test-extract-word.c @@ -14,12 +14,12 @@ TEST(extract_first_word) { p = original = "foobar waldo"; assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "foobar")); + ASSERT_STREQ(t, "foobar"); free(t); assert_se(p == original + 7); assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "waldo")); + ASSERT_STREQ(t, "waldo"); free(t); assert_se(isempty(p)); @@ -29,12 +29,12 @@ TEST(extract_first_word) { p = original = "\"foobar\" \'waldo\'"; assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "\"foobar\"")); + ASSERT_STREQ(t, "\"foobar\""); free(t); assert_se(p == original + 9); assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "\'waldo\'")); + ASSERT_STREQ(t, "\'waldo\'"); free(t); assert_se(isempty(p)); @@ -44,12 +44,12 @@ TEST(extract_first_word) { p = original = "\"foobar\" \'waldo\'"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "foobar")); + ASSERT_STREQ(t, "foobar"); free(t); assert_se(p == original + 9); assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "waldo")); + ASSERT_STREQ(t, "waldo"); free(t); assert_se(isempty(p)); @@ -59,7 +59,7 @@ TEST(extract_first_word) { p = original = "\""; assert_se(extract_first_word(&p, &t, NULL, 0) == 1); - assert_se(streq(t, "\"")); + ASSERT_STREQ(t, "\""); free(t); assert_se(isempty(p)); @@ -69,7 +69,7 @@ TEST(extract_first_word) { p = original = "\'"; assert_se(extract_first_word(&p, &t, NULL, 0) == 1); - assert_se(streq(t, "\'")); + ASSERT_STREQ(t, "\'"); free(t); assert_se(isempty(p)); @@ -79,31 +79,31 @@ TEST(extract_first_word) { p = original = "\'fooo"; assert_se(extract_first_word(&p, &t, NULL, 0) == 1); - assert_se(streq(t, "\'fooo")); + ASSERT_STREQ(t, "\'fooo"); free(t); assert_se(isempty(p)); p = original = "KEY=val \"KEY2=val with space\" \"KEY3=val with \\\"quotation\\\"\""; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) == 1); - assert_se(streq(t, "KEY=val")); + ASSERT_STREQ(t, "KEY=val"); free(t); assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) == 1); - assert_se(streq(t, "KEY2=val with space")); + ASSERT_STREQ(t, "KEY2=val with space"); free(t); assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) == 1); - assert_se(streq(t, "KEY3=val with \"quotation\"")); + ASSERT_STREQ(t, "KEY3=val with \"quotation\""); free(t); assert_se(isempty(p)); p = original = "KEY=val \"KEY2=val space\" \"KEY3=val with \\\"quotation\\\"\""; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RETAIN_ESCAPE) == 1); - assert_se(streq(t, "KEY=val")); + ASSERT_STREQ(t, "KEY=val"); free(t); assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RETAIN_ESCAPE) == 1); - assert_se(streq(t, "\"KEY2=val")); + ASSERT_STREQ(t, "\"KEY2=val"); free(t); assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RETAIN_ESCAPE) == 1); - assert_se(streq(t, "space\"")); + ASSERT_STREQ(t, "space\""); free(t); assert_se(startswith(p, "\"KEY3=")); @@ -113,78 +113,78 @@ TEST(extract_first_word) { p = original = "\'fooo"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX) > 0); - assert_se(streq(t, "fooo")); + ASSERT_STREQ(t, "fooo"); free(t); assert_se(isempty(p)); p = original = "\"fooo"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX) > 0); - assert_se(streq(t, "fooo")); + ASSERT_STREQ(t, "fooo"); free(t); assert_se(isempty(p)); p = original = "yay\'foo\'bar"; assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "yay\'foo\'bar")); + ASSERT_STREQ(t, "yay\'foo\'bar"); free(t); assert_se(isempty(p)); p = original = "yay\'foo\'bar"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "yayfoobar")); + ASSERT_STREQ(t, "yayfoobar"); free(t); assert_se(isempty(p)); p = original = " foobar "; assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "foobar")); + ASSERT_STREQ(t, "foobar"); free(t); assert_se(isempty(p)); p = original = " foo\\ba\\x6ar "; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) > 0); - assert_se(streq(t, "foo\ba\x6ar")); + ASSERT_STREQ(t, "foo\ba\x6ar"); free(t); assert_se(isempty(p)); p = original = " foo\\ba\\x6ar "; assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "foobax6ar")); + ASSERT_STREQ(t, "foobax6ar"); free(t); assert_se(isempty(p)); p = original = " f\\u00f6o \"pi\\U0001F4A9le\" "; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) > 0); - assert_se(streq(t, "föo")); + ASSERT_STREQ(t, "föo"); free(t); assert_se(p == original + 13); assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE) > 0); - assert_se(streq(t, "pi\360\237\222\251le")); + ASSERT_STREQ(t, "pi\360\237\222\251le"); free(t); assert_se(isempty(p)); p = original = "fooo\\"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RELAX) > 0); - assert_se(streq(t, "fooo")); + ASSERT_STREQ(t, "fooo"); free(t); assert_se(isempty(p)); p = original = "fooo\\"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNESCAPE_RELAX) > 0); - assert_se(streq(t, "fooo\\")); + ASSERT_STREQ(t, "fooo\\"); free(t); assert_se(isempty(p)); p = original = "fooo\\"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNESCAPE_RELAX|EXTRACT_RELAX) > 0); - assert_se(streq(t, "fooo\\")); + ASSERT_STREQ(t, "fooo\\"); free(t); assert_se(isempty(p)); p = original = "fooo\\"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX) > 0); - assert_se(streq(t, "fooo\\")); + ASSERT_STREQ(t, "fooo\\"); free(t); assert_se(isempty(p)); @@ -194,18 +194,18 @@ TEST(extract_first_word) { p = original = "\"foo\\"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX) > 0); - assert_se(streq(t, "foo")); + ASSERT_STREQ(t, "foo"); free(t); assert_se(isempty(p)); p = original = "foo::bar"; assert_se(extract_first_word(&p, &t, ":", 0) == 1); - assert_se(streq(t, "foo")); + ASSERT_STREQ(t, "foo"); free(t); assert_se(p == original + 5); assert_se(extract_first_word(&p, &t, ":", 0) == 1); - assert_se(streq(t, "bar")); + ASSERT_STREQ(t, "bar"); free(t); assert_se(isempty(p)); @@ -215,12 +215,12 @@ TEST(extract_first_word) { p = original = "foo\\:bar::waldo"; assert_se(extract_first_word(&p, &t, ":", 0) == 1); - assert_se(streq(t, "foo:bar")); + ASSERT_STREQ(t, "foo:bar"); free(t); assert_se(p == original + 10); assert_se(extract_first_word(&p, &t, ":", 0) == 1); - assert_se(streq(t, "waldo")); + ASSERT_STREQ(t, "waldo"); free(t); assert_se(isempty(p)); @@ -234,31 +234,31 @@ TEST(extract_first_word) { p = original = "\"foo\\"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_UNESCAPE_RELAX|EXTRACT_RELAX) > 0); - assert_se(streq(t, "foo\\")); + ASSERT_STREQ(t, "foo\\"); free(t); assert_se(isempty(p)); p = original = "\"foo\\"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX|EXTRACT_RELAX) > 0); - assert_se(streq(t, "foo\\")); + ASSERT_STREQ(t, "foo\\"); free(t); assert_se(isempty(p)); p = original = "fooo\\ bar quux"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RELAX) > 0); - assert_se(streq(t, "fooo bar")); + ASSERT_STREQ(t, "fooo bar"); free(t); assert_se(p == original + 10); p = original = "fooo\\ bar quux"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNESCAPE_RELAX) > 0); - assert_se(streq(t, "fooo bar")); + ASSERT_STREQ(t, "fooo bar"); free(t); assert_se(p == original + 10); p = original = "fooo\\ bar quux"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNESCAPE_RELAX|EXTRACT_RELAX) > 0); - assert_se(streq(t, "fooo bar")); + ASSERT_STREQ(t, "fooo bar"); free(t); assert_se(p == original + 10); @@ -268,7 +268,7 @@ TEST(extract_first_word) { p = original = "fooo\\ bar quux"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX) > 0); - assert_se(streq(t, "fooo\\ bar")); + ASSERT_STREQ(t, "fooo\\ bar"); free(t); assert_se(p == original + 10); @@ -278,52 +278,52 @@ TEST(extract_first_word) { p = original = "\\w+@\\K[\\d.]+"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX) > 0); - assert_se(streq(t, "\\w+@\\K[\\d.]+")); + ASSERT_STREQ(t, "\\w+@\\K[\\d.]+"); free(t); assert_se(isempty(p)); p = original = "\\w+\\b"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_RELAX) > 0); - assert_se(streq(t, "\\w+\b")); + ASSERT_STREQ(t, "\\w+\b"); free(t); assert_se(isempty(p)); p = original = "-N ''"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "-N")); + ASSERT_STREQ(t, "-N"); free(t); assert_se(p == original + 3); assert_se(extract_first_word(&p, &t, NULL, EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "")); + ASSERT_STREQ(t, ""); free(t); assert_se(isempty(p)); p = original = ":foo\\:bar::waldo:"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1); assert_se(t); - assert_se(streq(t, "")); + ASSERT_STREQ(t, ""); free(t); assert_se(p == original + 1); assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1); - assert_se(streq(t, "foo:bar")); + ASSERT_STREQ(t, "foo:bar"); free(t); assert_se(p == original + 10); assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1); assert_se(t); - assert_se(streq(t, "")); + ASSERT_STREQ(t, ""); free(t); assert_se(p == original + 11); assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1); - assert_se(streq(t, "waldo")); + ASSERT_STREQ(t, "waldo"); free(t); assert_se(p == original + 17); assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1); - assert_se(streq(t, "")); + ASSERT_STREQ(t, ""); free(t); ASSERT_NULL(p); @@ -333,34 +333,34 @@ TEST(extract_first_word) { p = "foo\\xbar"; assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "fooxbar")); + ASSERT_STREQ(t, "fooxbar"); free(t); ASSERT_NULL(p); p = "foo\\xbar"; assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RETAIN_ESCAPE) > 0); - assert_se(streq(t, "foo\\xbar")); + ASSERT_STREQ(t, "foo\\xbar"); free(t); ASSERT_NULL(p); p = "\\:"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, ":")); + ASSERT_STREQ(t, ":"); free(t); ASSERT_NULL(p); p = "a\\:b"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "a:b")); + ASSERT_STREQ(t, "a:b"); free(t); ASSERT_NULL(p); p = "a\\ b:c"; assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "a b")); + ASSERT_STREQ(t, "a b"); free(t); assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "c")); + ASSERT_STREQ(t, "c"); free(t); ASSERT_NULL(p); @@ -369,31 +369,31 @@ TEST(extract_first_word) { p = "a\\\\ b:c\\\\x"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "a\\ b")); + ASSERT_STREQ(t, "a\\ b"); free(t); assert_se(extract_first_word(&p, &t, ":", EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "c\\x")); + ASSERT_STREQ(t, "c\\x"); free(t); ASSERT_NULL(p); p = "\\:"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, ":")); + ASSERT_STREQ(t, ":"); free(t); ASSERT_NULL(p); p = "a\\:b"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "a:b")); + ASSERT_STREQ(t, "a:b"); free(t); ASSERT_NULL(p); p = "a\\ b:c"; assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "a b")); + ASSERT_STREQ(t, "a b"); free(t); assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "c")); + ASSERT_STREQ(t, "c"); free(t); ASSERT_NULL(p); @@ -402,10 +402,10 @@ TEST(extract_first_word) { p = "a\\\\ b:c\\\\x"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "a\\ b")); + ASSERT_STREQ(t, "a\\ b"); free(t); assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "c\\x")); + ASSERT_STREQ(t, "c\\x"); free(t); ASSERT_NULL(p); @@ -415,136 +415,136 @@ TEST(extract_first_word) { p = "a\\:b"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE) == -EINVAL); assert_se(extract_first_word(&p, &t, ":", EXTRACT_CUNESCAPE) == 1); - assert_se(streq(t, "b")); + ASSERT_STREQ(t, "b"); free(t); p = "a\\ b:c"; assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE) == -EINVAL); assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE) == 1); - assert_se(streq(t, "b")); + ASSERT_STREQ(t, "b"); free(t); assert_se(extract_first_word(&p, &t, WHITESPACE ":", EXTRACT_CUNESCAPE) == 1); - assert_se(streq(t, "c")); + ASSERT_STREQ(t, "c"); free(t); ASSERT_NULL(p); p = original = "foobar=\"waldo\"maldo, baldo"; assert_se(extract_first_word(&p, &t, "=\", ", 0) > 0); - assert_se(streq(t, "foobar")); + ASSERT_STREQ(t, "foobar"); free(t); assert_se(extract_first_word(&p, &t, "=\", ", 0) > 0); - assert_se(streq(t, "waldo")); + ASSERT_STREQ(t, "waldo"); free(t); assert_se(extract_first_word(&p, &t, "=\", ", 0) > 0); - assert_se(streq(t, "maldo")); + ASSERT_STREQ(t, "maldo"); free(t); assert_se(extract_first_word(&p, &t, "=\", ", 0) > 0); - assert_se(streq(t, "baldo")); + ASSERT_STREQ(t, "baldo"); free(t); p = original = "mode=\"1777\",size=\"10%\",nr_inodes=\"400\"k,uid=\"496,,107\"520,gi\"\"'d=49610,'\"\"7520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\""; assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0); - assert_se(streq(t, "mode=\"1777\"")); + ASSERT_STREQ(t, "mode=\"1777\""); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0); - assert_se(streq(t, "size=\"10%\"")); + ASSERT_STREQ(t, "size=\"10%\""); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0); - assert_se(streq(t, "nr_inodes=\"400\"k")); + ASSERT_STREQ(t, "nr_inodes=\"400\"k"); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0); - assert_se(streq(t, "uid=\"496,,107\"520")); + ASSERT_STREQ(t, "uid=\"496,,107\"520"); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0); - assert_se(streq(t, "gi\"\"'d=49610,'\"\"7520")); + ASSERT_STREQ(t, "gi\"\"'d=49610,'\"\"7520"); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_KEEP_QUOTE) > 0); - assert_se(streq(t, "context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\"")); + ASSERT_STREQ(t, "context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\""); free(t); p = original = "mode=\"1777\",size=\"10%\",nr_inodes=\"400\"k,uid=\"496,,107\"520,gi\"\"'d=49610,'\"\"7520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\""; assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "mode=1777")); + ASSERT_STREQ(t, "mode=1777"); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "size=10%")); + ASSERT_STREQ(t, "size=10%"); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "nr_inodes=400k")); + ASSERT_STREQ(t, "nr_inodes=400k"); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "uid=496,,107520")); + ASSERT_STREQ(t, "uid=496,,107520"); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "gid=49610,7520")); + ASSERT_STREQ(t, "gid=49610,7520"); free(t); assert_se(extract_first_word(&p, &t, ",", EXTRACT_UNQUOTE) > 0); - assert_se(streq(t, "context=system_u:object_r:svirt_sandbox_file_t:s0:c0,c1")); + ASSERT_STREQ(t, "context=system_u:object_r:svirt_sandbox_file_t:s0:c0,c1"); free(t); p = "a:b"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS) == 1); - assert_se(streq(t, "a")); - assert_se(streq(p, ":b")); + ASSERT_STREQ(t, "a"); + ASSERT_STREQ(p, ":b"); free(t); assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS) == 1); - assert_se(streq(t, "b")); + ASSERT_STREQ(t, "b"); free(t); p = "a>:b"; assert_se(extract_first_word(&p, &t, ">:", EXTRACT_RETAIN_SEPARATORS) == 1); - assert_se(streq(t, "a")); - assert_se(streq(p, ">:b")); + ASSERT_STREQ(t, "a"); + ASSERT_STREQ(p, ">:b"); free(t); assert_se(extract_first_word(&p, &t, ">:", EXTRACT_RETAIN_SEPARATORS) == 1); - assert_se(streq(t, "b")); + ASSERT_STREQ(t, "b"); free(t); p = "a>:b"; assert_se(extract_first_word(&p, &t, ">:", EXTRACT_RETAIN_SEPARATORS|EXTRACT_DONT_COALESCE_SEPARATORS) == 1); - assert_se(streq(t, "a")); - assert_se(streq(p, ">:b")); + ASSERT_STREQ(t, "a"); + ASSERT_STREQ(p, ">:b"); free(t); assert_se(extract_first_word(&p, &t, ">:", EXTRACT_RETAIN_SEPARATORS|EXTRACT_DONT_COALESCE_SEPARATORS) == 1); - assert_se(streq(t, "")); - assert_se(streq(p, ">:b")); + ASSERT_STREQ(t, ""); + ASSERT_STREQ(p, ">:b"); free(t); p = "a\\:b"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS|EXTRACT_RETAIN_ESCAPE) == 1); - assert_se(streq(t, "a\\")); - assert_se(streq(p, ":b")); + ASSERT_STREQ(t, "a\\"); + ASSERT_STREQ(p, ":b"); free(t); p = "a\\:b"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS) == 1); - assert_se(streq(t, "a:b")); + ASSERT_STREQ(t, "a:b"); assert_se(!p); free(t); p = "a\\:b"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS|EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "a:b")); + ASSERT_STREQ(t, "a:b"); assert_se(!p); free(t); p = "a\\:a:b"; assert_se(extract_first_word(&p, &t, ":", EXTRACT_RETAIN_SEPARATORS|EXTRACT_UNESCAPE_SEPARATORS) == 1); - assert_se(streq(t, "a:a")); - assert_se(streq(p, ":b")); + ASSERT_STREQ(t, "a:a"); + ASSERT_STREQ(p, ":b"); free(t); p = original = "zażółcić 👊🔪💐 가너도루"; assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "zażółcić")); + ASSERT_STREQ(t, "zażółcić"); free(t); assert_se(p == original + 13); assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "👊🔪💐")); + ASSERT_STREQ(t, "👊🔪💐"); free(t); assert_se(extract_first_word(&p, &t, NULL, 0) > 0); - assert_se(streq(t, "가너도루")); + ASSERT_STREQ(t, "가너도루"); free(t); assert_se(isempty(p)); } @@ -555,12 +555,12 @@ TEST(extract_first_word_and_warn) { p = original = "foobar waldo"; assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "foobar")); + ASSERT_STREQ(t, "foobar"); free(t); assert_se(p == original + 7); assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "waldo")); + ASSERT_STREQ(t, "waldo"); free(t); assert_se(isempty(p)); @@ -570,12 +570,12 @@ TEST(extract_first_word_and_warn) { p = original = "\"foobar\" \'waldo\'"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "foobar")); + ASSERT_STREQ(t, "foobar"); free(t); assert_se(p == original + 9); assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "waldo")); + ASSERT_STREQ(t, "waldo"); free(t); assert_se(isempty(p)); @@ -597,48 +597,48 @@ TEST(extract_first_word_and_warn) { p = original = "\'fooo"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "fooo")); + ASSERT_STREQ(t, "fooo"); free(t); assert_se(isempty(p)); p = original = " foo\\ba\\x6ar "; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "foo\ba\x6ar")); + ASSERT_STREQ(t, "foo\ba\x6ar"); free(t); assert_se(isempty(p)); p = original = " foo\\ba\\x6ar "; assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "foobax6ar")); + ASSERT_STREQ(t, "foobax6ar"); free(t); assert_se(isempty(p)); p = original = " f\\u00f6o \"pi\\U0001F4A9le\" "; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "föo")); + ASSERT_STREQ(t, "föo"); free(t); assert_se(p == original + 13); assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "pi\360\237\222\251le")); + ASSERT_STREQ(t, "pi\360\237\222\251le"); free(t); assert_se(isempty(p)); p = original = "fooo\\"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_RELAX, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "fooo")); + ASSERT_STREQ(t, "fooo"); free(t); assert_se(isempty(p)); p = original = "fooo\\"; assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "fooo\\")); + ASSERT_STREQ(t, "fooo\\"); free(t); assert_se(isempty(p)); p = original = "fooo\\"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "fooo\\")); + ASSERT_STREQ(t, "fooo\\"); free(t); assert_se(isempty(p)); @@ -648,7 +648,7 @@ TEST(extract_first_word_and_warn) { p = original = "\"foo\\"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_RELAX, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "foo")); + ASSERT_STREQ(t, "foo"); free(t); assert_se(isempty(p)); @@ -658,37 +658,37 @@ TEST(extract_first_word_and_warn) { p = original = "\"foo\\"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE|EXTRACT_RELAX, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "foo")); + ASSERT_STREQ(t, "foo"); free(t); assert_se(isempty(p)); p = original = "fooo\\ bar quux"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_RELAX, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "fooo bar")); + ASSERT_STREQ(t, "fooo bar"); free(t); assert_se(p == original + 10); p = original = "fooo\\ bar quux"; assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "fooo bar")); + ASSERT_STREQ(t, "fooo bar"); free(t); assert_se(p == original + 10); p = original = "fooo\\ bar quux"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "fooo\\ bar")); + ASSERT_STREQ(t, "fooo\\ bar"); free(t); assert_se(p == original + 10); p = original = "\\w+@\\K[\\d.]+"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "\\w+@\\K[\\d.]+")); + ASSERT_STREQ(t, "\\w+@\\K[\\d.]+"); free(t); assert_se(isempty(p)); p = original = "\\w+\\b"; assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0); - assert_se(streq(t, "\\w+\b")); + ASSERT_STREQ(t, "\\w+\b"); free(t); assert_se(isempty(p)); } @@ -700,9 +700,9 @@ TEST(extract_many_words) { p = original = "foobar waldi piep"; assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c) == 3); assert_se(isempty(p)); - assert_se(streq_ptr(a, "foobar")); - assert_se(streq_ptr(b, "waldi")); - assert_se(streq_ptr(c, "piep")); + ASSERT_STREQ(a, "foobar"); + ASSERT_STREQ(b, "waldi"); + ASSERT_STREQ(c, "piep"); free(a); free(b); free(c); @@ -710,13 +710,13 @@ TEST(extract_many_words) { p = original = "foobar:waldi:piep ba1:ba2"; assert_se(extract_many_words(&p, ":" WHITESPACE, 0, &a, &b, &c) == 3); assert_se(!isempty(p)); - assert_se(streq_ptr(a, "foobar")); - assert_se(streq_ptr(b, "waldi")); - assert_se(streq_ptr(c, "piep")); + ASSERT_STREQ(a, "foobar"); + ASSERT_STREQ(b, "waldi"); + ASSERT_STREQ(c, "piep"); assert_se(extract_many_words(&p, ":" WHITESPACE, 0, &d, &e, &f) == 2); assert_se(isempty(p)); - assert_se(streq_ptr(d, "ba1")); - assert_se(streq_ptr(e, "ba2")); + ASSERT_STREQ(d, "ba1"); + ASSERT_STREQ(e, "ba2"); assert_se(isempty(f)); free(a); free(b); @@ -728,34 +728,34 @@ TEST(extract_many_words) { p = original = "'foobar' wa\"ld\"i "; assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c) == 2); assert_se(isempty(p)); - assert_se(streq_ptr(a, "'foobar'")); - assert_se(streq_ptr(b, "wa\"ld\"i")); - assert_se(streq_ptr(c, NULL)); + ASSERT_STREQ(a, "'foobar'"); + ASSERT_STREQ(b, "wa\"ld\"i"); + ASSERT_STREQ(c, NULL); free(a); free(b); p = original = "'foobar' wa\"ld\"i "; assert_se(extract_many_words(&p, NULL, EXTRACT_UNQUOTE, &a, &b, &c) == 2); assert_se(isempty(p)); - assert_se(streq_ptr(a, "foobar")); - assert_se(streq_ptr(b, "waldi")); - assert_se(streq_ptr(c, NULL)); + ASSERT_STREQ(a, "foobar"); + ASSERT_STREQ(b, "waldi"); + ASSERT_STREQ(c, NULL); free(a); free(b); p = original = ""; assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c) == 0); assert_se(isempty(p)); - assert_se(streq_ptr(a, NULL)); - assert_se(streq_ptr(b, NULL)); - assert_se(streq_ptr(c, NULL)); + ASSERT_STREQ(a, NULL); + ASSERT_STREQ(b, NULL); + ASSERT_STREQ(c, NULL); p = original = " "; assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c) == 0); assert_se(isempty(p)); - assert_se(streq_ptr(a, NULL)); - assert_se(streq_ptr(b, NULL)); - assert_se(streq_ptr(c, NULL)); + ASSERT_STREQ(a, NULL); + ASSERT_STREQ(b, NULL); + ASSERT_STREQ(c, NULL); p = original = "foobar"; assert_se(extract_many_words(&p, NULL, 0) == 0); @@ -764,21 +764,21 @@ TEST(extract_many_words) { p = original = "foobar waldi"; assert_se(extract_many_words(&p, NULL, 0, &a) == 1); assert_se(p == original+7); - assert_se(streq_ptr(a, "foobar")); + ASSERT_STREQ(a, "foobar"); free(a); p = original = " foobar "; assert_se(extract_many_words(&p, NULL, 0, &a) == 1); assert_se(isempty(p)); - assert_se(streq_ptr(a, "foobar")); + ASSERT_STREQ(a, "foobar"); free(a); p = original = "gęślą:👊🔪💐 가너도루"; assert_se(extract_many_words(&p, ":" WHITESPACE, 0, &a, &b, &c) == 3); assert_se(isempty(p)); - assert_se(streq(a, "gęślą")); - assert_se(streq(b, "👊🔪💐")); - assert_se(streq(c, "가너도루")); + ASSERT_STREQ(a, "gęślą"); + ASSERT_STREQ(b, "👊🔪💐"); + ASSERT_STREQ(c, "가너도루"); free(a); free(b); free(c); diff --git a/src/test/test-fd-util.c b/src/test/test-fd-util.c index b10dfa8ed2d..2796fe88823 100644 --- a/src/test/test-fd-util.c +++ b/src/test/test-fd-util.c @@ -397,11 +397,11 @@ TEST(close_all_fds) { } TEST(format_proc_fd_path) { - assert_se(streq_ptr(FORMAT_PROC_FD_PATH(0), "/proc/self/fd/0")); - assert_se(streq_ptr(FORMAT_PROC_FD_PATH(1), "/proc/self/fd/1")); - assert_se(streq_ptr(FORMAT_PROC_FD_PATH(2), "/proc/self/fd/2")); - assert_se(streq_ptr(FORMAT_PROC_FD_PATH(3), "/proc/self/fd/3")); - assert_se(streq_ptr(FORMAT_PROC_FD_PATH(2147483647), "/proc/self/fd/2147483647")); + ASSERT_STREQ(FORMAT_PROC_FD_PATH(0), "/proc/self/fd/0"); + ASSERT_STREQ(FORMAT_PROC_FD_PATH(1), "/proc/self/fd/1"); + ASSERT_STREQ(FORMAT_PROC_FD_PATH(2), "/proc/self/fd/2"); + ASSERT_STREQ(FORMAT_PROC_FD_PATH(3), "/proc/self/fd/3"); + ASSERT_STREQ(FORMAT_PROC_FD_PATH(2147483647), "/proc/self/fd/2147483647"); } TEST(fd_reopen) { @@ -676,7 +676,7 @@ TEST(fd_get_path) { tfd = mkdtemp_open(NULL, O_PATH, &t); assert_se(tfd >= 0); assert_se(fd_get_path(tfd, &p) >= 0); - assert_se(streq(p, t)); + ASSERT_STREQ(p, t); p = mfree(p); @@ -684,7 +684,7 @@ TEST(fd_get_path) { assert_se(chdir(t) >= 0); assert_se(fd_get_path(AT_FDCWD, &p) >= 0); - assert_se(streq(p, t)); + ASSERT_STREQ(p, t); p = mfree(p); @@ -697,7 +697,7 @@ TEST(fd_get_path) { fd = openat(tfd, "regular", O_CLOEXEC|O_PATH); assert_se(fd >= 0); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); p = mfree(p); fd = safe_close(fd); @@ -705,7 +705,7 @@ TEST(fd_get_path) { fd = openat(AT_FDCWD, "regular", O_CLOEXEC|O_PATH); assert_se(fd >= 0); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); p = mfree(p); fd = safe_close(fd); @@ -714,7 +714,7 @@ TEST(fd_get_path) { assert_se(fd >= 0); assert_se(fd_verify_regular(fd) >= 0); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); p = mfree(p); fd = safe_close(fd); @@ -723,7 +723,7 @@ TEST(fd_get_path) { assert_se(fd >= 0); assert_se(fd_verify_regular(fd) >= 0); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); p = mfree(p); fd = safe_close(fd); @@ -732,7 +732,7 @@ TEST(fd_get_path) { assert_se(fd >= 0); assert_se(fd_verify_regular(fd) >= 0); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); p = mfree(p); fd = safe_close(fd); @@ -741,7 +741,7 @@ TEST(fd_get_path) { assert_se(fd >= 0); assert_se(fd_verify_regular(fd) >= 0); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); p = mfree(p); q = mfree(q); @@ -752,7 +752,7 @@ TEST(fd_get_path) { assert_se(fd >= 0); assert_se(fd_verify_regular(fd) == -ELOOP); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); p = mfree(p); fd = safe_close(fd); @@ -761,7 +761,7 @@ TEST(fd_get_path) { assert_se(fd >= 0); assert_se(fd_verify_regular(fd) == -ELOOP); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); p = mfree(p); fd = safe_close(fd); @@ -770,7 +770,7 @@ TEST(fd_get_path) { assert_se(fd >= 0); assert_se(fd_verify_regular(fd) == -ELOOP); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); p = mfree(p); fd = safe_close(fd); @@ -779,7 +779,7 @@ TEST(fd_get_path) { assert_se(fd >= 0); assert_se(fd_verify_regular(fd) == -ELOOP); assert_se(fd_get_path(fd, &p) >= 0); - assert_se(streq(p, q)); + ASSERT_STREQ(p, q); assert_se(chdir(saved_cwd) >= 0); } diff --git a/src/test/test-fileio.c b/src/test/test-fileio.c index 67437ea9d9f..474eacaf046 100644 --- a/src/test/test-fileio.c +++ b/src/test/test-fileio.c @@ -71,19 +71,19 @@ TEST(parse_env_file) { STRV_FOREACH(i, a) log_info("Got: <%s>", *i); - assert_se(streq_ptr(a[0], "one=BAR")); - assert_se(streq_ptr(a[1], "two=bar")); - assert_se(streq_ptr(a[2], "three=333\nxxxx")); - assert_se(streq_ptr(a[3], "four=44\\\"44")); - assert_se(streq_ptr(a[4], "five=55\"55FIVEcinco")); - assert_se(streq_ptr(a[5], "six=seis sechs sis")); - assert_se(streq_ptr(a[6], "seven=sevenval#nocomment")); - assert_se(streq_ptr(a[7], "eight=eightval #nocomment")); - assert_se(streq_ptr(a[8], "export nine=nineval")); - assert_se(streq_ptr(a[9], "ten=")); - assert_se(streq_ptr(a[10], "eleven=value")); - assert_se(streq_ptr(a[11], "twelve=\\value")); - assert_se(streq_ptr(a[12], "thirteen=\\value")); + ASSERT_STREQ(a[0], "one=BAR"); + ASSERT_STREQ(a[1], "two=bar"); + ASSERT_STREQ(a[2], "three=333\nxxxx"); + ASSERT_STREQ(a[3], "four=44\\\"44"); + ASSERT_STREQ(a[4], "five=55\"55FIVEcinco"); + ASSERT_STREQ(a[5], "six=seis sechs sis"); + ASSERT_STREQ(a[6], "seven=sevenval#nocomment"); + ASSERT_STREQ(a[7], "eight=eightval #nocomment"); + ASSERT_STREQ(a[8], "export nine=nineval"); + ASSERT_STREQ(a[9], "ten="); + ASSERT_STREQ(a[10], "eleven=value"); + ASSERT_STREQ(a[11], "twelve=\\value"); + ASSERT_STREQ(a[12], "thirteen=\\value"); ASSERT_NULL(a[13]); strv_env_clean(a); @@ -91,7 +91,7 @@ TEST(parse_env_file) { k = 0; STRV_FOREACH(i, b) { log_info("Got2: <%s>", *i); - assert_se(streq(*i, a[k++])); + ASSERT_STREQ(*i, a[k++]); } r = parse_env_file( @@ -125,19 +125,19 @@ TEST(parse_env_file) { log_info("twelve=[%s]", strna(twelve)); log_info("thirteen=[%s]", strna(thirteen)); - assert_se(streq(one, "BAR")); - assert_se(streq(two, "bar")); - assert_se(streq(three, "333\nxxxx")); - assert_se(streq(four, "44\\\"44")); - assert_se(streq(five, "55\"55FIVEcinco")); - assert_se(streq(six, "seis sechs sis")); - assert_se(streq(seven, "sevenval#nocomment")); - assert_se(streq(eight, "eightval #nocomment")); - assert_se(streq(nine, "nineval")); + ASSERT_STREQ(one, "BAR"); + ASSERT_STREQ(two, "bar"); + ASSERT_STREQ(three, "333\nxxxx"); + ASSERT_STREQ(four, "44\\\"44"); + ASSERT_STREQ(five, "55\"55FIVEcinco"); + ASSERT_STREQ(six, "seis sechs sis"); + ASSERT_STREQ(seven, "sevenval#nocomment"); + ASSERT_STREQ(eight, "eightval #nocomment"); + ASSERT_STREQ(nine, "nineval"); ASSERT_NULL(ten); - assert_se(streq(eleven, "value")); - assert_se(streq(twelve, "\\value")); - assert_se(streq(thirteen, "\\value")); + ASSERT_STREQ(eleven, "value"); + ASSERT_STREQ(twelve, "\\value"); + ASSERT_STREQ(thirteen, "\\value"); { /* prepare a temporary file to write the environment to */ @@ -161,7 +161,7 @@ static void test_one_shell_var(const char *file, const char *variable, const cha assert_se(f = popen(cmd, "re")); assert_se(read_full_stream(f, &from_shell, &sz) >= 0); assert_se(sz == strlen(value)); - assert_se(streq(from_shell, value)); + ASSERT_STREQ(from_shell, value); } TEST(parse_multiline_env_file) { @@ -198,9 +198,9 @@ TEST(parse_multiline_env_file) { STRV_FOREACH(i, a) log_info("Got: <%s>", *i); - assert_se(streq_ptr(a[0], "one=BAR VAR\tGAR")); - assert_se(streq_ptr(a[1], "two=bar var\tgar")); - assert_se(streq_ptr(a[2], "tri=bar var \tgar ")); + ASSERT_STREQ(a[0], "one=BAR VAR\tGAR"); + ASSERT_STREQ(a[1], "two=bar var\tgar"); + ASSERT_STREQ(a[2], "tri=bar var \tgar "); ASSERT_NULL(a[3]); { @@ -246,16 +246,16 @@ TEST(merge_env_file) { STRV_FOREACH(i, a) log_info("Got: <%s>", *i); - assert_se(streq(a[0], "one=2")); - assert_se(streq(a[1], "twelve=12")); - assert_se(streq(a[2], "twentyone=21")); - assert_se(streq(a[3], "twentytwo=22")); - assert_se(streq(a[4], "xxx=0x222")); - assert_se(streq(a[5], "xxx_minus_three= - 3")); - assert_se(streq(a[6], "yyy=2")); - assert_se(streq(a[7], "zzz=replacement")); - assert_se(streq(a[8], "zzzz=")); - assert_se(streq(a[9], "zzzzz=")); + ASSERT_STREQ(a[0], "one=2"); + ASSERT_STREQ(a[1], "twelve=12"); + ASSERT_STREQ(a[2], "twentyone=21"); + ASSERT_STREQ(a[3], "twentytwo=22"); + ASSERT_STREQ(a[4], "xxx=0x222"); + ASSERT_STREQ(a[5], "xxx_minus_three= - 3"); + ASSERT_STREQ(a[6], "yyy=2"); + ASSERT_STREQ(a[7], "zzz=replacement"); + ASSERT_STREQ(a[8], "zzzz="); + ASSERT_STREQ(a[9], "zzzzz="); ASSERT_NULL(a[10]); r = merge_env_file(&a, NULL, t); @@ -265,16 +265,16 @@ TEST(merge_env_file) { STRV_FOREACH(i, a) log_info("Got2: <%s>", *i); - assert_se(streq(a[0], "one=2")); - assert_se(streq(a[1], "twelve=12")); - assert_se(streq(a[2], "twentyone=21")); - assert_se(streq(a[3], "twentytwo=22")); - assert_se(streq(a[4], "xxx=0x222")); - assert_se(streq(a[5], "xxx_minus_three=0x222 - 3")); - assert_se(streq(a[6], "yyy=2")); - assert_se(streq(a[7], "zzz=replacement")); - assert_se(streq(a[8], "zzzz=")); - assert_se(streq(a[9], "zzzzz=")); + ASSERT_STREQ(a[0], "one=2"); + ASSERT_STREQ(a[1], "twelve=12"); + ASSERT_STREQ(a[2], "twentyone=21"); + ASSERT_STREQ(a[3], "twentytwo=22"); + ASSERT_STREQ(a[4], "xxx=0x222"); + ASSERT_STREQ(a[5], "xxx_minus_three=0x222 - 3"); + ASSERT_STREQ(a[6], "yyy=2"); + ASSERT_STREQ(a[7], "zzz=replacement"); + ASSERT_STREQ(a[8], "zzzz="); + ASSERT_STREQ(a[9], "zzzzz="); ASSERT_NULL(a[10]); } @@ -323,7 +323,7 @@ TEST(executable_is_script) { r = executable_is_script(t, &command); assert_se(r > 0); - assert_se(streq(command, "/bin/script")); + ASSERT_STREQ(command, "/bin/script"); free(command); r = executable_is_script("/bin/sh", &command); @@ -398,27 +398,27 @@ TEST(read_one_line_file) { assert_se(f); assert_se(read_one_line_file(fn, &buf) == 0); - assert_se(streq_ptr(buf, "")); + ASSERT_STREQ(buf, ""); assert_se(read_one_line_file(fn, &buf2) == 0); - assert_se(streq_ptr(buf2, "")); + ASSERT_STREQ(buf2, ""); assert_se(write_string_stream(f, "x", WRITE_STRING_FILE_AVOID_NEWLINE) >= 0); fflush(f); assert_se(read_one_line_file(fn, &buf3) == 1); - assert_se(streq_ptr(buf3, "x")); + ASSERT_STREQ(buf3, "x"); assert_se(write_string_stream(f, "\n", WRITE_STRING_FILE_AVOID_NEWLINE) >= 0); fflush(f); assert_se(read_one_line_file(fn, &buf4) == 2); - assert_se(streq_ptr(buf4, "x")); + ASSERT_STREQ(buf4, "x"); assert_se(write_string_stream(f, "\n", WRITE_STRING_FILE_AVOID_NEWLINE) >= 0); fflush(f); assert_se(read_one_line_file(fn, &buf5) == 2); - assert_se(streq_ptr(buf5, "x")); + ASSERT_STREQ(buf5, "x"); } TEST(write_string_stream) { @@ -442,7 +442,7 @@ TEST(write_string_stream) { rewind(f); assert_se(fgets(buf, sizeof(buf), f)); - assert_se(streq(buf, "boohoo\n")); + ASSERT_STREQ(buf, "boohoo\n"); f = safe_fclose(f); f = fopen(fn, "w+"); @@ -453,7 +453,7 @@ TEST(write_string_stream) { assert_se(fgets(buf, sizeof(buf), f)); printf(">%s<", buf); - assert_se(streq(buf, "boohoo")); + ASSERT_STREQ(buf, "boohoo"); } TEST(write_string_file) { @@ -467,7 +467,7 @@ TEST(write_string_file) { assert_se(write_string_file(fn, "boohoo", WRITE_STRING_FILE_CREATE) == 0); assert_se(read(fd, buf, sizeof(buf)) == 7); - assert_se(streq(buf, "boohoo\n")); + ASSERT_STREQ(buf, "boohoo\n"); } TEST(write_string_file_no_create) { @@ -482,7 +482,7 @@ TEST(write_string_file_no_create) { assert_se(write_string_file(fn, "boohoo", 0) == 0); assert_se(read(fd, buf, sizeof buf) == (ssize_t) strlen("boohoo\n")); - assert_se(streq(buf, "boohoo\n")); + ASSERT_STREQ(buf, "boohoo\n"); } TEST(write_string_file_verify) { @@ -578,14 +578,14 @@ TEST(search_and_fopen) { r = search_and_fopen(basename(name), "re", NULL, (const char**) dirs, &f, &p); assert_se(r >= 0); assert_se(e = path_startswith(p, "/tmp/")); - assert_se(streq(basename(name), e)); + ASSERT_STREQ(basename(name), e); f = safe_fclose(f); p = mfree(p); r = search_and_fopen(basename(name), NULL, NULL, (const char**) dirs, NULL, &p); assert_se(r >= 0); assert_se(e = path_startswith(p, "/tmp/")); - assert_se(streq(basename(name), e)); + ASSERT_STREQ(basename(name), e); p = mfree(p); r = search_and_fopen(name, "re", NULL, (const char**) dirs, &f, &p); @@ -602,14 +602,14 @@ TEST(search_and_fopen) { r = search_and_fopen(basename(name), "re", "/", (const char**) dirs, &f, &p); assert_se(r >= 0); assert_se(e = path_startswith(p, "/tmp/")); - assert_se(streq(basename(name), e)); + ASSERT_STREQ(basename(name), e); f = safe_fclose(f); p = mfree(p); r = search_and_fopen(basename(name), NULL, "/", (const char**) dirs, NULL, &p); assert_se(r >= 0); assert_se(e = path_startswith(p, "/tmp/")); - assert_se(streq(basename(name), e)); + ASSERT_STREQ(basename(name), e); p = mfree(p); r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "re", NULL, (const char**) dirs, &f, &p); @@ -649,7 +649,7 @@ TEST(search_and_fopen_nulstr) { r = search_and_fopen_nulstr(basename(name), "re", NULL, dirs, &f, &p); assert_se(r >= 0); assert_se(e = path_startswith(p, "/tmp/")); - assert_se(streq(basename(name), e)); + ASSERT_STREQ(basename(name), e); f = safe_fclose(f); p = mfree(p); @@ -693,18 +693,18 @@ TEST(writing_tmpfile) { r = read_full_file(name, &contents, &size); assert_se(r == 0); printf("contents: %s", contents); - assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n")); + ASSERT_STREQ(contents, "abc\n" ALPHANUMERICAL "\n"); } TEST(tempfn) { char *ret = NULL, *p; assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0); - assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX")); + ASSERT_STREQ(ret, "/foo/bar/.#waldoXXXXXX"); free(ret); assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0); - assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX")); + ASSERT_STREQ(ret, "/foo/bar/.#[miau]waldoXXXXXX"); free(ret); assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0); @@ -900,7 +900,7 @@ TEST(read_line4) { r = read_line(f, SIZE_MAX, &s); assert_se((size_t) r == eof_endings[i].length); - assert_se(streq_ptr(s, "foo")); + ASSERT_STREQ(s, "foo"); assert_se(read_line(f, SIZE_MAX, NULL) == 0); /* Ensure we hit EOF */ } @@ -985,7 +985,7 @@ TEST(read_full_file_socket) { assert_se(peer.un.sun_family == AF_UNIX); assert_se(peerlen > offsetof(struct sockaddr_un, sun_path)); assert_se(peer.un.sun_path[0] == 0); - assert_se(streq(peer.un.sun_path + 1, clientname + 1)); + ASSERT_STREQ(peer.un.sun_path + 1, clientname + 1); #define TEST_STR "This is a test\nreally." @@ -996,7 +996,7 @@ TEST(read_full_file_socket) { assert_se(read_full_file_full(AT_FDCWD, jj, UINT64_MAX, SIZE_MAX, 0, NULL, &data, &size) == -ENXIO); assert_se(read_full_file_full(AT_FDCWD, jj, UINT64_MAX, SIZE_MAX, READ_FULL_FILE_CONNECT_SOCKET, clientname, &data, &size) >= 0); assert_se(size == strlen(TEST_STR)); - assert_se(streq(data, TEST_STR)); + ASSERT_STREQ(data, TEST_STR); assert_se(wait_for_terminate_and_check("(server)", pid, WAIT_LOG) >= 0); #undef TEST_STR @@ -1125,7 +1125,7 @@ TEST(fdopen_independent) { assert_se(fdopen_independent(fd, "re", &f) >= 0); zero(buf); assert_se(fread(buf, 1, sizeof(buf), f) == strlen(TEST_TEXT)); - assert_se(streq(buf, TEST_TEXT)); + ASSERT_STREQ(buf, TEST_TEXT); assert_se((fcntl(fileno(f), F_GETFL) & O_ACCMODE) == O_RDONLY); assert_se(FLAGS_SET(fcntl(fileno(f), F_GETFD), FD_CLOEXEC)); f = safe_fclose(f); @@ -1133,7 +1133,7 @@ TEST(fdopen_independent) { assert_se(fdopen_independent(fd, "r", &f) >= 0); zero(buf); assert_se(fread(buf, 1, sizeof(buf), f) == strlen(TEST_TEXT)); - assert_se(streq(buf, TEST_TEXT)); + ASSERT_STREQ(buf, TEST_TEXT); assert_se((fcntl(fileno(f), F_GETFL) & O_ACCMODE) == O_RDONLY); assert_se(!FLAGS_SET(fcntl(fileno(f), F_GETFD), FD_CLOEXEC)); f = safe_fclose(f); @@ -1141,7 +1141,7 @@ TEST(fdopen_independent) { assert_se(fdopen_independent(fd, "r+e", &f) >= 0); zero(buf); assert_se(fread(buf, 1, sizeof(buf), f) == strlen(TEST_TEXT)); - assert_se(streq(buf, TEST_TEXT)); + ASSERT_STREQ(buf, TEST_TEXT); assert_se((fcntl(fileno(f), F_GETFL) & O_ACCMODE) == O_RDWR); assert_se(FLAGS_SET(fcntl(fileno(f), F_GETFD), FD_CLOEXEC)); f = safe_fclose(f); diff --git a/src/test/test-format-table.c b/src/test/test-format-table.c index 7d544b18fdd..c16a5b793b8 100644 --- a/src/test/test-format-table.c +++ b/src/test/test-format-table.c @@ -580,7 +580,7 @@ TEST(path_basename) { assert_se(table_format(t, &formatted) >= 0); - assert_se(streq(formatted, "bar\nbar\nbaz\n")); + ASSERT_STREQ(formatted, "bar\nbar\nbaz\n"); } TEST(dup_cell) { diff --git a/src/test/test-format-util.c b/src/test/test-format-util.c index 306350937a7..94feb6cafc0 100644 --- a/src/test/test-format-util.c +++ b/src/test/test-format-util.c @@ -34,10 +34,10 @@ static void test_format_bytes_one(uint64_t val, bool trailing_B, const char *iec const char *si_with_p, const char *si_without_p) { char buf[FORMAT_BYTES_MAX]; - assert_se(streq_ptr(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_USE_IEC | FORMAT_BYTES_BELOW_POINT | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), iec_with_p)); - assert_se(streq_ptr(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_USE_IEC | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), iec_without_p)); - assert_se(streq_ptr(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_BELOW_POINT | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), si_with_p)); - assert_se(streq_ptr(format_bytes_full(buf, sizeof buf, val, trailing_B ? FORMAT_BYTES_TRAILING_B : 0), si_without_p)); + ASSERT_STREQ(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_USE_IEC | FORMAT_BYTES_BELOW_POINT | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), iec_with_p); + ASSERT_STREQ(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_USE_IEC | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), iec_without_p); + ASSERT_STREQ(format_bytes_full(buf, sizeof buf, val, FORMAT_BYTES_BELOW_POINT | (trailing_B ? FORMAT_BYTES_TRAILING_B : 0)), si_with_p); + ASSERT_STREQ(format_bytes_full(buf, sizeof buf, val, trailing_B ? FORMAT_BYTES_TRAILING_B : 0), si_without_p); } TEST(format_bytes) { diff --git a/src/test/test-fs-util.c b/src/test/test-fs-util.c index d1f555fafef..d44e0437f5f 100644 --- a/src/test/test-fs-util.c +++ b/src/test/test-fs-util.c @@ -45,7 +45,7 @@ TEST(readlink_and_make_absolute) { log_tests_skipped_errno(errno, "symlink() not possible"); } else { assert_se(readlink_and_make_absolute(name_alias, &r1) >= 0); - assert_se(streq(r1, name)); + ASSERT_STREQ(r1, name); assert_se(unlink(name_alias) >= 0); assert_se(safe_getcwd(&pwd) >= 0); @@ -53,7 +53,7 @@ TEST(readlink_and_make_absolute) { assert_se(chdir(tempdir) >= 0); assert_se(symlink(name2, name_alias) >= 0); assert_se(readlink_and_make_absolute(name_alias, &r2) >= 0); - assert_se(streq(r2, name)); + ASSERT_STREQ(r2, name); assert_se(unlink(name_alias) >= 0); assert_se(chdir(pwd) >= 0); @@ -97,33 +97,33 @@ TEST(var_tmp) { assert_se(unsetenv("TMP") >= 0); assert_se(var_tmp_dir(&tmp_dir) >= 0); - assert_se(streq(tmp_dir, "/var/tmp")); + ASSERT_STREQ(tmp_dir, "/var/tmp"); assert_se(setenv("TMPDIR", "/tmp", true) >= 0); - assert_se(streq(getenv("TMPDIR"), "/tmp")); + ASSERT_STREQ(getenv("TMPDIR"), "/tmp"); assert_se(var_tmp_dir(&tmp_dir) >= 0); - assert_se(streq(tmp_dir, "/tmp")); + ASSERT_STREQ(tmp_dir, "/tmp"); assert_se(setenv("TMPDIR", "/88_does_not_exist_88", true) >= 0); - assert_se(streq(getenv("TMPDIR"), "/88_does_not_exist_88")); + ASSERT_STREQ(getenv("TMPDIR"), "/88_does_not_exist_88"); assert_se(var_tmp_dir(&tmp_dir) >= 0); - assert_se(streq(tmp_dir, "/var/tmp")); + ASSERT_STREQ(tmp_dir, "/var/tmp"); if (tmpdir_backup) { assert_se(setenv("TMPDIR", tmpdir_backup, true) >= 0); - assert_se(streq(getenv("TMPDIR"), tmpdir_backup)); + ASSERT_STREQ(getenv("TMPDIR"), tmpdir_backup); } if (temp_backup) { assert_se(setenv("TEMP", temp_backup, true) >= 0); - assert_se(streq(getenv("TEMP"), temp_backup)); + ASSERT_STREQ(getenv("TEMP"), temp_backup); } if (tmp_backup) { assert_se(setenv("TMP", tmp_backup, true) >= 0); - assert_se(streq(getenv("TMP"), tmp_backup)); + ASSERT_STREQ(getenv("TMP"), tmp_backup); } } @@ -522,9 +522,9 @@ static void test_parse_cifs_service_one(const char *f, const char *h, const char _cleanup_free_ char *a = NULL, *b = NULL, *c = NULL; assert_se(parse_cifs_service(f, &a, &b, &c) == ret); - assert_se(streq_ptr(a, h)); - assert_se(streq_ptr(b, s)); - assert_se(streq_ptr(c, d)); + ASSERT_STREQ(a, h); + ASSERT_STREQ(b, s); + ASSERT_STREQ(c, d); } TEST(parse_cifs_service) { @@ -800,25 +800,25 @@ TEST(readlinkat_malloc) { assert_se(symlinkat(expect, tfd, "linkname") >= 0); assert_se(readlinkat_malloc(tfd, "linkname", &p) >= 0); - assert_se(streq(p, expect)); + ASSERT_STREQ(p, expect); p = mfree(p); fd = openat(tfd, "linkname", O_PATH | O_NOFOLLOW | O_CLOEXEC); assert_se(fd >= 0); assert_se(readlinkat_malloc(fd, NULL, &p) >= 0); - assert_se(streq(p, expect)); + ASSERT_STREQ(p, expect); p = mfree(p); assert_se(readlinkat_malloc(fd, "", &p) >= 0); - assert_se(streq(p, expect)); + ASSERT_STREQ(p, expect); p = mfree(p); fd = safe_close(fd); assert_se(q = path_join(t, "linkname")); assert_se(readlinkat_malloc(AT_FDCWD, q, &p) >= 0); - assert_se(streq(p, expect)); + ASSERT_STREQ(p, expect); p = mfree(p); assert_se(readlinkat_malloc(INT_MAX, q, &p) >= 0); - assert_se(streq(p, expect)); + ASSERT_STREQ(p, expect); p = mfree(p); q = mfree(q); } diff --git a/src/test/test-fstab-util.c b/src/test/test-fstab-util.c index 49561a21d70..773b1f9799f 100644 --- a/src/test/test-fstab-util.c +++ b/src/test/test-fstab-util.c @@ -39,9 +39,9 @@ static void do_fstab_filter_options(const char *opts, opts, r, strnull(name), value, filtered, r_expected, strnull(name_expected), strnull(value_expected), filtered_expected ?: opts); assert_se(r == r_expected); - assert_se(streq_ptr(name, name_expected)); - assert_se(streq_ptr(value, value_expected)); - assert_se(streq_ptr(filtered, filtered_expected ?: opts)); + ASSERT_STREQ(name, name_expected); + ASSERT_STREQ(value, value_expected); + ASSERT_STREQ(filtered, filtered_expected ?: opts); /* test mode which returns all the values */ @@ -51,8 +51,8 @@ static void do_fstab_filter_options(const char *opts, opts, r, strnull(name), joined, r_values_expected, strnull(name_expected), strnull(values_expected)); assert_se(r == r_values_expected); - assert_se(streq_ptr(name, r_values_expected > 0 ? name_expected : NULL)); - assert_se(streq_ptr(joined, values_expected)); + ASSERT_STREQ(name, r_values_expected > 0 ? name_expected : NULL); + ASSERT_STREQ(joined, values_expected); /* also test the malloc-less mode */ r = fstab_filter_options(opts, remove, &name, NULL, NULL, NULL); @@ -60,7 +60,7 @@ static void do_fstab_filter_options(const char *opts, opts, r, strnull(name), r_expected, strnull(name_expected)); assert_se(r == r_expected); - assert_se(streq_ptr(name, name_expected)); + ASSERT_STREQ(name, name_expected); } TEST(fstab_filter_options) { @@ -160,32 +160,32 @@ TEST(fstab_node_to_udev_node) { n = fstab_node_to_udev_node("LABEL=applé/jack"); puts(n); - assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack")); + ASSERT_STREQ(n, "/dev/disk/by-label/applé\\x2fjack"); free(n); n = fstab_node_to_udev_node("PARTLABEL=pinkié pie"); puts(n); - assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie")); + ASSERT_STREQ(n, "/dev/disk/by-partlabel/pinkié\\x20pie"); free(n); n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535"); puts(n); - assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535")); + ASSERT_STREQ(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"); free(n); n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535"); puts(n); - assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535")); + ASSERT_STREQ(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"); free(n); n = fstab_node_to_udev_node("PONIES=awesome"); puts(n); - assert_se(streq(n, "PONIES=awesome")); + ASSERT_STREQ(n, "PONIES=awesome"); free(n); n = fstab_node_to_udev_node("/dev/xda1"); puts(n); - assert_se(streq(n, "/dev/xda1")); + ASSERT_STREQ(n, "/dev/xda1"); free(n); } diff --git a/src/test/test-glob-util.c b/src/test/test-glob-util.c index 4fa47498c3a..49d71f15c71 100644 --- a/src/test/test-glob-util.c +++ b/src/test/test-glob-util.c @@ -24,7 +24,7 @@ TEST(glob_first) { r = glob_first("/tmp/test-glob_first*", &first); assert_se(r == 1); - assert_se(streq(name, first)); + ASSERT_STREQ(name, first); first = mfree(first); r = unlink(name); @@ -109,7 +109,7 @@ TEST(safe_glob) { r = safe_glob(fn2, GLOB_NOSORT|GLOB_BRACE, &g); assert_se(r == 0); assert_se(g.gl_pathc == 1); - assert_se(streq(g.gl_pathv[0], fname)); + ASSERT_STREQ(g.gl_pathv[0], fname); ASSERT_NULL(g.gl_pathv[1]); (void) rm_rf(template, REMOVE_ROOT|REMOVE_PHYSICAL); @@ -119,7 +119,7 @@ static void test_glob_non_glob_prefix_one(const char *path, const char *expected _cleanup_free_ char *t; assert_se(glob_non_glob_prefix(path, &t) == 0); - assert_se(streq(t, expected)); + ASSERT_STREQ(t, expected); } TEST(glob_non_glob) { diff --git a/src/test/test-gpt.c b/src/test/test-gpt.c index 825aac65080..28b53d479a0 100644 --- a/src/test/test-gpt.c +++ b/src/test/test-gpt.c @@ -94,7 +94,7 @@ TEST(override_architecture) { ASSERT_EQ(x.arch, y.arch); ASSERT_EQ(x.designator, y.designator); assert_se(sd_id128_equal(x.uuid, y.uuid)); - assert_se(streq(x.name, y.name)); + ASSERT_STREQ(x.name, y.name); /* If the partition type does not have an architecture, nothing should change. */ @@ -105,7 +105,7 @@ TEST(override_architecture) { ASSERT_EQ(x.arch, y.arch); ASSERT_EQ(x.designator, y.designator); assert_se(sd_id128_equal(x.uuid, y.uuid)); - assert_se(streq(x.name, y.name)); + ASSERT_STREQ(x.name, y.name); } DEFINE_TEST_MAIN(LOG_INFO); diff --git a/src/test/test-hashmap-plain.c b/src/test/test-hashmap-plain.c index c343acb8a46..f2d2d4f75da 100644 --- a/src/test/test-hashmap-plain.c +++ b/src/test/test-hashmap-plain.c @@ -42,11 +42,11 @@ TEST(hashmap_replace) { hashmap_replace(m, "key 3", val1); r = hashmap_get(m, "key 3"); - assert_se(streq(r, "val1")); + ASSERT_STREQ(r, "val1"); hashmap_replace(m, "key 5", val5); r = hashmap_get(m, "key 5"); - assert_se(streq(r, "val5")); + ASSERT_STREQ(r, "val5"); } TEST(hashmap_copy) { @@ -73,13 +73,13 @@ TEST(hashmap_copy) { copy = hashmap_copy(m); r = hashmap_get(copy, "key 1"); - assert_se(streq(r, "val1")); + ASSERT_STREQ(r, "val1"); r = hashmap_get(copy, "key 2"); - assert_se(streq(r, "val2")); + ASSERT_STREQ(r, "val2"); r = hashmap_get(copy, "key 3"); - assert_se(streq(r, "val3")); + ASSERT_STREQ(r, "val3"); r = hashmap_get(copy, "key 4"); - assert_se(streq(r, "val4")); + ASSERT_STREQ(r, "val4"); } TEST(hashmap_get_strv) { @@ -109,10 +109,10 @@ TEST(hashmap_get_strv) { strv = strv_sort(strv); #endif - assert_se(streq(strv[0], "val1")); - assert_se(streq(strv[1], "val2")); - assert_se(streq(strv[2], "val3")); - assert_se(streq(strv[3], "val4")); + ASSERT_STREQ(strv[0], "val1"); + ASSERT_STREQ(strv[1], "val2"); + ASSERT_STREQ(strv[2], "val3"); + ASSERT_STREQ(strv[3], "val4"); } TEST(hashmap_move_one) { @@ -203,15 +203,15 @@ TEST(hashmap_update) { hashmap_put(m, "key 1", val1); r = hashmap_get(m, "key 1"); - assert_se(streq(r, "old_value")); + ASSERT_STREQ(r, "old_value"); assert_se(hashmap_update(m, "key 2", val2) == -ENOENT); r = hashmap_get(m, "key 1"); - assert_se(streq(r, "old_value")); + ASSERT_STREQ(r, "old_value"); assert_se(hashmap_update(m, "key 1", val2) == 0); r = hashmap_get(m, "key 1"); - assert_se(streq(r, "new_value")); + ASSERT_STREQ(r, "new_value"); } TEST(hashmap_put) { @@ -250,10 +250,10 @@ TEST(hashmap_remove1) { hashmap_put(m, "key 2", (void*) "val 2"); r = hashmap_remove(m, "key 1"); - assert_se(streq(r, "val 1")); + ASSERT_STREQ(r, "val 1"); r = hashmap_get(m, "key 2"); - assert_se(streq(r, "val 2")); + ASSERT_STREQ(r, "val 2"); assert_se(!hashmap_get(m, "key 1")); } @@ -278,13 +278,13 @@ TEST(hashmap_remove2) { hashmap_put(m, strdup(key2), strdup(val2)); r = hashmap_remove2(m, key1, &r2); - assert_se(streq(r, val1)); - assert_se(streq(r2, key1)); + ASSERT_STREQ(r, val1); + ASSERT_STREQ(r2, key1); free(r); free(r2); r = hashmap_get(m, key2); - assert_se(streq(r, val2)); + ASSERT_STREQ(r, val2); assert_se(!hashmap_get(m, key1)); } @@ -308,17 +308,17 @@ TEST(hashmap_remove_value) { hashmap_put(m, "key 2", val2); r = hashmap_remove_value(m, "key 1", val1); - assert_se(streq(r, "val 1")); + ASSERT_STREQ(r, "val 1"); r = hashmap_get(m, "key 2"); - assert_se(streq(r, "val 2")); + ASSERT_STREQ(r, "val 2"); assert_se(!hashmap_get(m, "key 1")); r = hashmap_remove_value(m, "key 2", val1); ASSERT_NULL(r); r = hashmap_get(m, "key 2"); - assert_se(streq(r, "val 2")); + ASSERT_STREQ(r, "val 2"); assert_se(!hashmap_get(m, "key 1")); } @@ -343,7 +343,7 @@ TEST(hashmap_remove_and_put) { assert_se(valid == 0); r = hashmap_get(m, "key 2"); - assert_se(streq(r, "val 2")); + ASSERT_STREQ(r, "val 2"); assert_se(!hashmap_get(m, "key 1")); valid = hashmap_put(m, "key 3", (void*) (const char *) "val 3"); @@ -613,7 +613,7 @@ TEST(hashmap_get) { hashmap_put(m, "Key 1", val); r = hashmap_get(m, "Key 1"); - assert_se(streq(r, val)); + ASSERT_STREQ(r, val); r = hashmap_get(m, "no such key"); ASSERT_NULL(r); @@ -643,9 +643,9 @@ TEST(hashmap_get2) { key_copy = NULL; r = hashmap_get2(m, key_orig, &key_copy); - assert_se(streq(r, val)); + ASSERT_STREQ(r, val); assert_se(key_orig != key_copy); - assert_se(streq(key_orig, key_copy)); + ASSERT_STREQ(key_orig, key_copy); r = hashmap_get2(m, "no such key", NULL); ASSERT_NULL(r); @@ -787,12 +787,12 @@ TEST(hashmap_first) { assert_se(!hashmap_first(m)); assert_se(hashmap_put(m, "key 1", (void*) "val 1") == 1); - assert_se(streq(hashmap_first(m), "val 1")); + ASSERT_STREQ(hashmap_first(m), "val 1"); assert_se(hashmap_put(m, "key 2", (void*) "val 2") == 1); #ifdef ORDERED - assert_se(streq(hashmap_first(m), "val 1")); + ASSERT_STREQ(hashmap_first(m), "val 1"); assert_se(hashmap_remove(m, "key 1")); - assert_se(streq(hashmap_first(m), "val 2")); + ASSERT_STREQ(hashmap_first(m), "val 2"); #endif } @@ -804,12 +804,12 @@ TEST(hashmap_first_key) { assert_se(!hashmap_first_key(m)); assert_se(hashmap_put(m, "key 1", NULL) == 1); - assert_se(streq(hashmap_first_key(m), "key 1")); + ASSERT_STREQ(hashmap_first_key(m), "key 1"); assert_se(hashmap_put(m, "key 2", NULL) == 1); #ifdef ORDERED - assert_se(streq(hashmap_first_key(m), "key 1")); + ASSERT_STREQ(hashmap_first_key(m), "key 1"); ASSERT_NULL(hashmap_remove(m, "key 1")); - assert_se(streq(hashmap_first_key(m), "key 2")); + ASSERT_STREQ(hashmap_first_key(m), "key 2"); #endif } @@ -821,7 +821,7 @@ TEST(hashmap_steal_first_key) { assert_se(!hashmap_steal_first_key(m)); assert_se(hashmap_put(m, "key 1", NULL) == 1); - assert_se(streq(hashmap_steal_first_key(m), "key 1")); + ASSERT_STREQ(hashmap_steal_first_key(m), "key 1"); assert_se(hashmap_isempty(m)); } @@ -997,7 +997,7 @@ TEST(hashmap_dump_sorted) { assert_se(hashmap_dump_keys_sorted(m, &vals, &n) >= 0); assert_se(n == ELEMENTSOF(expected_keys)); for (size_t i = 0; i < n; i++) - assert_se(streq(vals[i], expected_keys[i])); + ASSERT_STREQ(vals[i], expected_keys[i]); vals = mfree(vals); m = hashmap_free(m); diff --git a/src/test/test-hashmap.c b/src/test/test-hashmap.c index 7ff270c3e08..74e68a473d9 100644 --- a/src/test/test-hashmap.c +++ b/src/test/test-hashmap.c @@ -116,7 +116,7 @@ TEST(hashmap_put_strdup) { assert_se(hashmap_contains(m, "foo")); s = hashmap_get(m, "foo"); - assert_se(streq(s, "bar")); + ASSERT_STREQ(s, "bar"); assert_se(hashmap_put_strdup(&m, "xxx", "bar") == 1); assert_se(hashmap_put_strdup(&m, "xxx", "bar") == 0); @@ -125,7 +125,7 @@ TEST(hashmap_put_strdup) { assert_se(hashmap_contains(m, "xxx")); s = hashmap_get(m, "xxx"); - assert_se(streq(s, "bar")); + ASSERT_STREQ(s, "bar"); } TEST(hashmap_put_strdup_null) { @@ -139,7 +139,7 @@ TEST(hashmap_put_strdup_null) { assert_se(hashmap_contains(m, "foo")); s = hashmap_get(m, "foo"); - assert_se(streq(s, "bar")); + ASSERT_STREQ(s, "bar"); assert_se(hashmap_put_strdup(&m, "xxx", NULL) == 1); assert_se(hashmap_put_strdup(&m, "xxx", "bar") == -EEXIST); diff --git a/src/test/test-hexdecoct.c b/src/test/test-hexdecoct.c index c5abf54513a..5c39fc7cc22 100644 --- a/src/test/test-hexdecoct.c +++ b/src/test/test-hexdecoct.c @@ -80,7 +80,7 @@ static void test_hexmem_one(const char *in, const char *expected) { assert_se(result = hexmem(in, strlen_ptr(in))); log_debug("hexmem(\"%s\") → \"%s\" (expected: \"%s\")", strnull(in), result, expected); - assert_se(streq(result, expected)); + ASSERT_STREQ(result, expected); assert_se(unhexmem(result, &mem, &len) >= 0); assert_se(memcmp_safe(mem, in, len) == 0); @@ -106,7 +106,7 @@ static void test_unhexmem_one(const char *s, size_t l, int retval) { assert_se(hex = hexmem(mem, len)); answer = strndupa_safe(strempty(s), l); - assert_se(streq(delete_chars(answer, WHITESPACE), hex)); + ASSERT_STREQ(delete_chars(answer, WHITESPACE), hex); } } @@ -134,72 +134,72 @@ TEST(base32hexmem) { b32 = base32hexmem("", STRLEN(""), true); assert_se(b32); - assert_se(streq(b32, "")); + ASSERT_STREQ(b32, ""); free(b32); b32 = base32hexmem("f", STRLEN("f"), true); assert_se(b32); - assert_se(streq(b32, "CO======")); + ASSERT_STREQ(b32, "CO======"); free(b32); b32 = base32hexmem("fo", STRLEN("fo"), true); assert_se(b32); - assert_se(streq(b32, "CPNG====")); + ASSERT_STREQ(b32, "CPNG===="); free(b32); b32 = base32hexmem("foo", STRLEN("foo"), true); assert_se(b32); - assert_se(streq(b32, "CPNMU===")); + ASSERT_STREQ(b32, "CPNMU==="); free(b32); b32 = base32hexmem("foob", STRLEN("foob"), true); assert_se(b32); - assert_se(streq(b32, "CPNMUOG=")); + ASSERT_STREQ(b32, "CPNMUOG="); free(b32); b32 = base32hexmem("fooba", STRLEN("fooba"), true); assert_se(b32); - assert_se(streq(b32, "CPNMUOJ1")); + ASSERT_STREQ(b32, "CPNMUOJ1"); free(b32); b32 = base32hexmem("foobar", STRLEN("foobar"), true); assert_se(b32); - assert_se(streq(b32, "CPNMUOJ1E8======")); + ASSERT_STREQ(b32, "CPNMUOJ1E8======"); free(b32); b32 = base32hexmem("", STRLEN(""), false); assert_se(b32); - assert_se(streq(b32, "")); + ASSERT_STREQ(b32, ""); free(b32); b32 = base32hexmem("f", STRLEN("f"), false); assert_se(b32); - assert_se(streq(b32, "CO")); + ASSERT_STREQ(b32, "CO"); free(b32); b32 = base32hexmem("fo", STRLEN("fo"), false); assert_se(b32); - assert_se(streq(b32, "CPNG")); + ASSERT_STREQ(b32, "CPNG"); free(b32); b32 = base32hexmem("foo", STRLEN("foo"), false); assert_se(b32); - assert_se(streq(b32, "CPNMU")); + ASSERT_STREQ(b32, "CPNMU"); free(b32); b32 = base32hexmem("foob", STRLEN("foob"), false); assert_se(b32); - assert_se(streq(b32, "CPNMUOG")); + ASSERT_STREQ(b32, "CPNMUOG"); free(b32); b32 = base32hexmem("fooba", STRLEN("fooba"), false); assert_se(b32); - assert_se(streq(b32, "CPNMUOJ1")); + ASSERT_STREQ(b32, "CPNMUOJ1"); free(b32); b32 = base32hexmem("foobar", STRLEN("foobar"), false); assert_se(b32); - assert_se(streq(b32, "CPNMUOJ1E8")); + ASSERT_STREQ(b32, "CPNMUOJ1E8"); free(b32); } @@ -212,7 +212,7 @@ static void test_unbase32hexmem_one(const char *hex, bool padding, int retval, c char *str; str = strndupa_safe(mem, len); - assert_se(streq(str, ans)); + ASSERT_STREQ(str, ans); } } @@ -268,31 +268,31 @@ TEST(base64mem) { char *b64; assert_se(base64mem("", STRLEN(""), &b64) == 0); - assert_se(streq(b64, "")); + ASSERT_STREQ(b64, ""); free(b64); assert_se(base64mem("f", STRLEN("f"), &b64) == 4); - assert_se(streq(b64, "Zg==")); + ASSERT_STREQ(b64, "Zg=="); free(b64); assert_se(base64mem("fo", STRLEN("fo"), &b64) == 4); - assert_se(streq(b64, "Zm8=")); + ASSERT_STREQ(b64, "Zm8="); free(b64); assert_se(base64mem("foo", STRLEN("foo"), &b64) == 4); - assert_se(streq(b64, "Zm9v")); + ASSERT_STREQ(b64, "Zm9v"); free(b64); assert_se(base64mem("foob", STRLEN("foob"), &b64) == 8); - assert_se(streq(b64, "Zm9vYg==")); + ASSERT_STREQ(b64, "Zm9vYg=="); free(b64); assert_se(base64mem("fooba", STRLEN("fooba"), &b64) == 8); - assert_se(streq(b64, "Zm9vYmE=")); + ASSERT_STREQ(b64, "Zm9vYmE="); free(b64); assert_se(base64mem("foobar", STRLEN("foobar"), &b64) == 8); - assert_se(streq(b64, "Zm9vYmFy")); + ASSERT_STREQ(b64, "Zm9vYmFy"); free(b64); } @@ -341,7 +341,7 @@ static void test_base64_append_one(char **buf, size_t *len, const char *in, cons assert_se(new_len >= 0); log_debug("base64_append_one(\"%s\")\nresult:\n%s\nexpected:\n%s", in, strnull(*buf), strnull(expected)); assert_se((size_t) new_len == strlen_ptr(*buf)); - assert_se(streq_ptr(*buf, expected)); + ASSERT_STREQ(*buf, expected); *len = new_len; } diff --git a/src/test/test-hmac.c b/src/test/test-hmac.c index 18c81adbcdb..28f7ab9460e 100644 --- a/src/test/test-hmac.c +++ b/src/test/test-hmac.c @@ -26,42 +26,42 @@ TEST(hmac) { "baldohaldo", result); hex_result = hexmem(result, sizeof(result)); - assert_se(streq_ptr(hex_result, "c47ad5031ba21605e52c6ca68090d66a2dd5ccf84efa4bace15361a8cba63cda")); + ASSERT_STREQ(hex_result, "c47ad5031ba21605e52c6ca68090d66a2dd5ccf84efa4bace15361a8cba63cda"); hex_result = mfree(hex_result); hmac_sha256_by_string("waldo", "baldo haldo", result); hex_result = hexmem(result, sizeof(result)); - assert_se(streq_ptr(hex_result, "4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69")); + ASSERT_STREQ(hex_result, "4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69"); hex_result = mfree(hex_result); hmac_sha256_by_string("waldo", "baldo 4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69 haldo", result); hex_result = hexmem(result, sizeof(result)); - assert_se(streq_ptr(hex_result, "039f3df430b19753ffb493e5b90708f75c5210b63c6bcbef3374eb3f0a3f97f7")); + ASSERT_STREQ(hex_result, "039f3df430b19753ffb493e5b90708f75c5210b63c6bcbef3374eb3f0a3f97f7"); hex_result = mfree(hex_result); hmac_sha256_by_string("4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69", "baldo haldo", result); hex_result = hexmem(result, sizeof(result)); - assert_se(streq_ptr(hex_result, "c4cfaf48077cbb0bbd177a09e59ec4c248f4ca771503410f5b54b98d88d2f47b")); + ASSERT_STREQ(hex_result, "c4cfaf48077cbb0bbd177a09e59ec4c248f4ca771503410f5b54b98d88d2f47b"); hex_result = mfree(hex_result); hmac_sha256_by_string("4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69", "supercalifragilisticexpialidocious", result); hex_result = hexmem(result, sizeof(result)); - assert_se(streq_ptr(hex_result, "2c059e7a63c4c3b23f47966a65fd2f8a2f5d7161e2e90d78ff68866b5c375cb7")); + ASSERT_STREQ(hex_result, "2c059e7a63c4c3b23f47966a65fd2f8a2f5d7161e2e90d78ff68866b5c375cb7"); hex_result = mfree(hex_result); hmac_sha256_by_string("4e8974ad6c08b98cc2519cd1e27aa7195769fcf86db1dd7ceaab4d44c490ad69c47ad5031ba21605e52c6ca68090d66a2dd5ccf84efa4bace15361a8cba63cda", "supercalifragilisticexpialidocious", result); hex_result = hexmem(result, sizeof(result)); - assert_se(streq_ptr(hex_result, "1dd1d1d45b9d9f9673dc9983c968c46ff3168e03cfeb4156a219eba1af4cff5f")); + ASSERT_STREQ(hex_result, "1dd1d1d45b9d9f9673dc9983c968c46ff3168e03cfeb4156a219eba1af4cff5f"); hex_result = mfree(hex_result); } diff --git a/src/test/test-hostname-setup.c b/src/test/test-hostname-setup.c index 94e5ece5602..2365a5edc11 100644 --- a/src/test/test-hostname-setup.c +++ b/src/test/test-hostname-setup.c @@ -22,28 +22,28 @@ TEST(read_etc_hostname) { /* simple hostname */ assert_se(write_string_file(path, "foo", WRITE_STRING_FILE_CREATE) == 0); assert_se(read_etc_hostname(path, &hostname) == 0); - assert_se(streq(hostname, "foo")); + ASSERT_STREQ(hostname, "foo"); hostname = mfree(hostname); /* with comment */ assert_se(write_string_file(path, "# comment\nfoo", WRITE_STRING_FILE_CREATE) == 0); assert_se(read_etc_hostname(path, &hostname) == 0); assert_se(hostname); - assert_se(streq(hostname, "foo")); + ASSERT_STREQ(hostname, "foo"); hostname = mfree(hostname); /* with comment and extra whitespace */ assert_se(write_string_file(path, "# comment\n\n foo ", WRITE_STRING_FILE_CREATE) == 0); assert_se(read_etc_hostname(path, &hostname) == 0); assert_se(hostname); - assert_se(streq(hostname, "foo")); + ASSERT_STREQ(hostname, "foo"); hostname = mfree(hostname); /* cleans up name */ assert_se(write_string_file(path, "!foo/bar.com", WRITE_STRING_FILE_CREATE) == 0); assert_se(read_etc_hostname(path, &hostname) == 0); assert_se(hostname); - assert_se(streq(hostname, "foobar.com")); + ASSERT_STREQ(hostname, "foobar.com"); hostname = mfree(hostname); /* no value set */ diff --git a/src/test/test-hostname-util.c b/src/test/test-hostname-util.c index 77e9a1992f2..a7eccf8b35b 100644 --- a/src/test/test-hostname-util.c +++ b/src/test/test-hostname-util.c @@ -50,27 +50,27 @@ TEST(hostname_cleanup) { char *s; s = strdupa_safe("foobar"); - assert_se(streq(hostname_cleanup(s), "foobar")); + ASSERT_STREQ(hostname_cleanup(s), "foobar"); s = strdupa_safe("foobar.com"); - assert_se(streq(hostname_cleanup(s), "foobar.com")); + ASSERT_STREQ(hostname_cleanup(s), "foobar.com"); s = strdupa_safe("foobar.com."); - assert_se(streq(hostname_cleanup(s), "foobar.com")); + ASSERT_STREQ(hostname_cleanup(s), "foobar.com"); s = strdupa_safe("foo-bar.-com-."); - assert_se(streq(hostname_cleanup(s), "foo-bar.com")); + ASSERT_STREQ(hostname_cleanup(s), "foo-bar.com"); s = strdupa_safe("foo-bar-.-com-."); - assert_se(streq(hostname_cleanup(s), "foo-bar--com")); + ASSERT_STREQ(hostname_cleanup(s), "foo-bar--com"); s = strdupa_safe("--foo-bar.-com"); - assert_se(streq(hostname_cleanup(s), "foo-bar.com")); + ASSERT_STREQ(hostname_cleanup(s), "foo-bar.com"); s = strdupa_safe("fooBAR"); - assert_se(streq(hostname_cleanup(s), "fooBAR")); + ASSERT_STREQ(hostname_cleanup(s), "fooBAR"); s = strdupa_safe("fooBAR.com"); - assert_se(streq(hostname_cleanup(s), "fooBAR.com")); + ASSERT_STREQ(hostname_cleanup(s), "fooBAR.com"); s = strdupa_safe("fooBAR."); - assert_se(streq(hostname_cleanup(s), "fooBAR")); + ASSERT_STREQ(hostname_cleanup(s), "fooBAR"); s = strdupa_safe("fooBAR.com."); - assert_se(streq(hostname_cleanup(s), "fooBAR.com")); + ASSERT_STREQ(hostname_cleanup(s), "fooBAR.com"); s = strdupa_safe("fööbar"); - assert_se(streq(hostname_cleanup(s), "fbar")); + ASSERT_STREQ(hostname_cleanup(s), "fbar"); s = strdupa_safe(""); assert_se(isempty(hostname_cleanup(s))); s = strdupa_safe("."); @@ -78,17 +78,17 @@ TEST(hostname_cleanup) { s = strdupa_safe(".."); assert_se(isempty(hostname_cleanup(s))); s = strdupa_safe("foobar."); - assert_se(streq(hostname_cleanup(s), "foobar")); + ASSERT_STREQ(hostname_cleanup(s), "foobar"); s = strdupa_safe(".foobar"); - assert_se(streq(hostname_cleanup(s), "foobar")); + ASSERT_STREQ(hostname_cleanup(s), "foobar"); s = strdupa_safe("foo..bar"); - assert_se(streq(hostname_cleanup(s), "foo.bar")); + ASSERT_STREQ(hostname_cleanup(s), "foo.bar"); s = strdupa_safe("foo.bar.."); - assert_se(streq(hostname_cleanup(s), "foo.bar")); + ASSERT_STREQ(hostname_cleanup(s), "foo.bar"); s = strdupa_safe("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); - assert_se(streq(hostname_cleanup(s), "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")); + ASSERT_STREQ(hostname_cleanup(s), "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); s = strdupa_safe("xxxx........xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); - assert_se(streq(hostname_cleanup(s), "xxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")); + ASSERT_STREQ(hostname_cleanup(s), "xxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); } TEST(hostname_malloc) { diff --git a/src/test/test-id128.c b/src/test/test-id128.c index f1159ecb15e..3ddbeec0fc7 100644 --- a/src/test/test-id128.c +++ b/src/test/test-id128.c @@ -50,19 +50,19 @@ TEST(id128) { } printf("waldi: %s\n", sd_id128_to_string(ID128_WALDI, t)); - assert_se(streq(t, STR_WALDI)); + ASSERT_STREQ(t, STR_WALDI); assert_se(asprintf(&b, SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 32); printf("waldi2: %s\n", b); - assert_se(streq(t, b)); + ASSERT_STREQ(t, b); printf("waldi3: %s\n", sd_id128_to_uuid_string(ID128_WALDI, q)); - assert_se(streq(q, UUID_WALDI)); + ASSERT_STREQ(q, UUID_WALDI); b = mfree(b); assert_se(asprintf(&b, SD_ID128_UUID_FORMAT_STR, SD_ID128_FORMAT_VAL(ID128_WALDI)) == 36); printf("waldi4: %s\n", b); - assert_se(streq(q, b)); + ASSERT_STREQ(q, b); assert_se(sd_id128_from_string(STR_WALDI, &id) >= 0); assert_se(sd_id128_equal(id, ID128_WALDI)); diff --git a/src/test/test-import-util.c b/src/test/test-import-util.c index 7930fe508d9..cc7b1396555 100644 --- a/src/test/test-import-util.c +++ b/src/test/test-import-util.c @@ -10,7 +10,7 @@ static void test_import_url_last_component_one(const char *input, const char *ou _cleanup_free_ char *s = NULL; assert_se(import_url_last_component(input, &s) == ret); - assert_se(streq_ptr(output, s)); + ASSERT_STREQ(output, s); } TEST(import_url_last_component) { @@ -37,7 +37,7 @@ static void test_import_url_change_suffix_one(const char *input, size_t n, const _cleanup_free_ char *s = NULL; assert_se(import_url_change_suffix(input, n, suffix, &s) == ret); - assert_se(streq_ptr(output, s)); + ASSERT_STREQ(output, s); } TEST(import_url_change_suffix) { diff --git a/src/test/test-in-addr-prefix-util.c b/src/test/test-in-addr-prefix-util.c index 661ca8fc813..2b44babf8dd 100644 --- a/src/test/test-in-addr-prefix-util.c +++ b/src/test/test-in-addr-prefix-util.c @@ -12,8 +12,8 @@ static void test_in_addr_prefix_to_string_one(int f, const char *addr, unsigned printf("%s: %s/%u == %s\n", __func__, addr, prefixlen, r); assert_se(startswith(r, addr)); - assert_se(streq(r, IN_ADDR_PREFIX_TO_STRING(f, &ua, prefixlen))); - assert_se(streq(IN_ADDR_PREFIX_TO_STRING(f, &ua, prefixlen), r)); + ASSERT_STREQ(r, IN_ADDR_PREFIX_TO_STRING(f, &ua, prefixlen)); + ASSERT_STREQ(IN_ADDR_PREFIX_TO_STRING(f, &ua, prefixlen), r); } TEST(in_addr_to_string_prefix) { @@ -35,8 +35,8 @@ static void test_config_parse_in_addr_prefixes_one(int family, const union in_ad assert_se(config_parse_in_addr_prefixes("unit", "filename", 1, "Service", 1, "IPAddressAllow", 0, str, prefixes, NULL) >= 0); - assert_se(streq(str, IN_ADDR_PREFIX_TO_STRING(family, addr, prefixlen))); - assert_se(streq(IN_ADDR_PREFIX_TO_STRING(family, addr, prefixlen), str)); + ASSERT_STREQ(str, IN_ADDR_PREFIX_TO_STRING(family, addr, prefixlen)); + ASSERT_STREQ(IN_ADDR_PREFIX_TO_STRING(family, addr, prefixlen), str); } static void test_config_parse_in_addr_prefixes(Set **ret) { diff --git a/src/test/test-in-addr-util.c b/src/test/test-in-addr-util.c index 93ab1c5d48f..0d159669402 100644 --- a/src/test/test-in-addr-util.c +++ b/src/test/test-in-addr-util.c @@ -81,7 +81,7 @@ static void test_in_addr_prefix_to_string_valid(int family, const char *p) { log_info("%s: %s", __func__, p); assert_se(in_addr_prefix_from_string(p, family, &u, &l) >= 0); - assert_se(streq(p, IN_ADDR_PREFIX_TO_STRING(family, &u, l))); + ASSERT_STREQ(p, IN_ADDR_PREFIX_TO_STRING(family, &u, l)); } static void test_in_addr_prefix_to_string_unoptimized(int family, const char *p) { @@ -97,7 +97,7 @@ static void test_in_addr_prefix_to_string_unoptimized(int family, const char *p) const char *str2 = IN_ADDR_PREFIX_TO_STRING(family, &u2, len2); assert_se(str2); - assert_se(streq(str1, str2)); + ASSERT_STREQ(str1, str2); assert_se(len1 == len2); assert_se(in_addr_equal(family, &u1, &u2) > 0); } @@ -340,9 +340,9 @@ static void test_in_addr_to_string_one(int f, const char *addr) { assert_se(in_addr_from_string(f, addr, &ua) >= 0); assert_se(in_addr_to_string(f, &ua, &r) >= 0); printf("%s: %s == %s\n", __func__, addr, r); - assert_se(streq(addr, r)); + ASSERT_STREQ(addr, r); - assert_se(streq(r, IN_ADDR_TO_STRING(f, &ua))); + ASSERT_STREQ(r, IN_ADDR_TO_STRING(f, &ua)); } TEST(in_addr_to_string) { @@ -391,7 +391,7 @@ TEST(in_addr_prefixlen_to_netmask) { assert_se(in_addr_prefixlen_to_netmask(AF_INET, &addr, prefixlen) >= 0); assert_se(in_addr_to_string(AF_INET, &addr, &result) >= 0); printf("test_in_addr_prefixlen_to_netmask: %s == %s\n", ipv4_netmasks[prefixlen], result); - assert_se(streq(ipv4_netmasks[prefixlen], result)); + ASSERT_STREQ(ipv4_netmasks[prefixlen], result); } for (unsigned char prefixlen = 0; prefixlen <= 128; prefixlen++) { @@ -401,7 +401,7 @@ TEST(in_addr_prefixlen_to_netmask) { assert_se(in_addr_to_string(AF_INET6, &addr, &result) >= 0); printf("test_in_addr_prefixlen_to_netmask: %s\n", result); if (ipv6_netmasks[prefixlen]) - assert_se(streq(ipv6_netmasks[prefixlen], result)); + ASSERT_STREQ(ipv6_netmasks[prefixlen], result); } } diff --git a/src/test/test-install-root.c b/src/test/test-install-root.c index c55445079c6..1e7ed27f63b 100644 --- a/src/test/test-install-root.c +++ b/src/test/test-install-root.c @@ -60,9 +60,9 @@ TEST(basic_mask_and_enable) { assert_se(unit_file_mask(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("a.service"), &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/dev/null")); + ASSERT_STREQ(changes[0].source, "/dev/null"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/a.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -81,16 +81,16 @@ TEST(basic_mask_and_enable) { assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/a.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("a.service"), &changes, &n_changes) == 1); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/a.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/a.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/a.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -109,7 +109,7 @@ TEST(basic_mask_and_enable) { assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/a.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -128,9 +128,9 @@ TEST(basic_mask_and_enable) { assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("d.service"), &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/a.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/a.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/a.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -145,10 +145,10 @@ TEST(basic_mask_and_enable) { assert_se(n_changes == 2); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/a.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[1].source, "/usr/lib/systemd/system/a.service")); - assert_se(streq(changes[1].path, p)); + ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/a.service"); + ASSERT_STREQ(changes[1].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -186,13 +186,13 @@ TEST(basic_mask_and_enable) { assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("f.service"), &changes, &n_changes) == 1); assert_se(n_changes == 2); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/f.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/f.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/x.target.wants/f.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); assert_se(changes[1].type == INSTALL_CHANGE_DESTINATION_NOT_PRESENT); p = strjoina(root, "/usr/lib/systemd/system/f.service"); - assert_se(streq(changes[1].source, p)); - assert_se(streq(changes[1].path, "x.target")); + ASSERT_STREQ(changes[1].source, p); + ASSERT_STREQ(changes[1].path, "x.target"); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -255,9 +255,9 @@ TEST(linked_units) { assert_se(unit_file_link(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("/opt/linked.service"), &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/opt/linked.service")); + ASSERT_STREQ(changes[0].source, "/opt/linked.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/linked.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -268,7 +268,7 @@ TEST(linked_units) { assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/linked.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -285,9 +285,9 @@ TEST(linked_units) { if (s && streq(changes[i].path, s)) /* The alias symlink should point within the search path. */ - assert_se(streq(changes[i].source, SYSTEM_CONFIG_UNIT_DIR"/linked.service")); + ASSERT_STREQ(changes[i].source, SYSTEM_CONFIG_UNIT_DIR"/linked.service"); else - assert_se(streq(changes[i].source, "/opt/linked.service")); + ASSERT_STREQ(changes[i].source, "/opt/linked.service"); if (p && streq(changes[i].path, p)) p = NULL; @@ -335,7 +335,7 @@ TEST(linked_units) { q = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/linked2.service"); for (i = 0 ; i < n_changes; i++) { assert_se(changes[i].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[i].source, "/opt/linked2.service")); + ASSERT_STREQ(changes[i].source, "/opt/linked2.service"); if (p && streq(changes[i].path, p)) p = NULL; @@ -353,7 +353,7 @@ TEST(linked_units) { assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); assert_se(startswith(changes[0].path, root)); assert_se(endswith(changes[0].path, "linked3.service")); - assert_se(streq(changes[0].source, "/opt/linked3.service")); + ASSERT_STREQ(changes[0].source, "/opt/linked3.service"); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; } @@ -375,7 +375,7 @@ TEST(default) { assert_se(unit_file_set_default(RUNTIME_SCOPE_SYSTEM, 0, root, "idontexist.target", &changes, &n_changes) == -ENOENT); assert_se(n_changes == 1); assert_se(changes[0].type == -ENOENT); - assert_se(streq_ptr(changes[0].path, "idontexist.target")); + ASSERT_STREQ(changes[0].path, "idontexist.target"); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -384,14 +384,14 @@ TEST(default) { assert_se(unit_file_set_default(RUNTIME_SCOPE_SYSTEM, 0, root, "test-default.target", &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/test-default-real.target")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/test-default-real.target"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR "/" SPECIAL_DEFAULT_TARGET); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; assert_se(unit_file_get_default(RUNTIME_SCOPE_SYSTEM, root, &def) >= 0); - assert_se(streq_ptr(def, "test-default-real.target")); + ASSERT_STREQ(def, "test-default-real.target"); } TEST(add_dependency) { @@ -414,9 +414,9 @@ TEST(add_dependency) { assert_se(unit_file_add_dependency(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("add-dependency-test-service.service"), "add-dependency-test-target.target", UNIT_WANTS, &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/real-add-dependency-test-service.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/real-add-dependency-test-service.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/real-add-dependency-test-target.target.wants/real-add-dependency-test-service.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; } @@ -455,9 +455,9 @@ TEST(template_enable) { assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template@.service"), &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/template@.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/template@.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/template@def.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -471,7 +471,7 @@ TEST(template_enable) { assert_se(unit_file_disable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template@.service"), &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -486,9 +486,9 @@ TEST(template_enable) { assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template@foo.service"), &changes, &n_changes) >= 0); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/template@.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/template@.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/template@foo.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -502,7 +502,7 @@ TEST(template_enable) { assert_se(unit_file_disable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template@foo.service"), &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -519,9 +519,9 @@ TEST(template_enable) { assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("template-symlink@quux.service"), &changes, &n_changes) >= 0); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/template@.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/template@.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/template@quux.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -565,9 +565,9 @@ TEST(indirect) { assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("indirectc.service"), &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/indirectb.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/indirectb.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/indirectb.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -579,7 +579,7 @@ TEST(indirect) { assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/indirectb.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; } @@ -627,9 +627,9 @@ TEST(preset_and_list) { assert_se(unit_file_preset(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("preset-yes.service"), UNIT_FILE_PRESET_FULL, &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/preset-yes.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/preset-yes.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/preset-yes.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -641,7 +641,7 @@ TEST(preset_and_list) { assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/preset-yes.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -667,8 +667,8 @@ TEST(preset_and_list) { for (i = 0; i < n_changes; i++) { if (changes[i].type == INSTALL_CHANGE_SYMLINK) { - assert_se(streq(changes[i].source, "/usr/lib/systemd/system/preset-yes.service")); - assert_se(streq(changes[i].path, p)); + ASSERT_STREQ(changes[i].source, "/usr/lib/systemd/system/preset-yes.service"); + ASSERT_STREQ(changes[i].path, p); } else assert_se(changes[i].type == INSTALL_CHANGE_UNLINK); } @@ -735,7 +735,7 @@ TEST(revert) { assert_se(unit_file_revert(RUNTIME_SCOPE_SYSTEM, root, STRV_MAKE("xx.service"), &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -746,11 +746,11 @@ TEST(revert) { assert_se(unit_file_revert(RUNTIME_SCOPE_SYSTEM, root, STRV_MAKE("xx.service"), &changes, &n_changes) >= 0); assert_se(n_changes == 2); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/xx.service.d"); assert_se(changes[1].type == INSTALL_CHANGE_UNLINK); - assert_se(streq(changes[1].path, p)); + ASSERT_STREQ(changes[1].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; } @@ -786,9 +786,9 @@ TEST(preset_order) { assert_se(unit_file_preset(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("prefix-1.service"), UNIT_FILE_PRESET_FULL, &changes, &n_changes) >= 0); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/prefix-1.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/prefix-1.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/prefix-1.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -895,12 +895,12 @@ TEST(with_dropin) { assert_se(n_changes == 2); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-1.service")); - assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-1.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-1.service"); + ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-1.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-1.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-1.service"); - assert_se(streq(changes[1].path, p)); + ASSERT_STREQ(changes[1].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -909,12 +909,12 @@ TEST(with_dropin) { assert_se(n_changes == 2); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, SYSTEM_CONFIG_UNIT_DIR"/with-dropin-2.service")); - assert_se(streq(changes[1].source, SYSTEM_CONFIG_UNIT_DIR"/with-dropin-2.service")); + ASSERT_STREQ(changes[0].source, SYSTEM_CONFIG_UNIT_DIR"/with-dropin-2.service"); + ASSERT_STREQ(changes[1].source, SYSTEM_CONFIG_UNIT_DIR"/with-dropin-2.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-2.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-2.service"); - assert_se(streq(changes[1].path, p)); + ASSERT_STREQ(changes[1].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -923,12 +923,12 @@ TEST(with_dropin) { assert_se(n_changes == 2); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-3.service")); - assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-3.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-3.service"); + ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-3.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-3.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-3.service"); - assert_se(streq(changes[1].path, p)); + ASSERT_STREQ(changes[1].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -937,12 +937,12 @@ TEST(with_dropin) { assert_se(n_changes == 2); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-4a.service")); - assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-4b.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-4a.service"); + ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-4b.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-4a.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-4b.service"); - assert_se(streq(changes[1].path, p)); + ASSERT_STREQ(changes[1].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -1004,12 +1004,12 @@ TEST(with_dropin_template) { assert_se(n_changes == 2); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-1@.service")); - assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-1@.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-1@.service"); + ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-1@.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-1@instance-1.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-1@instance-1.service"); - assert_se(streq(changes[1].path, p)); + ASSERT_STREQ(changes[1].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -1017,30 +1017,30 @@ TEST(with_dropin_template) { assert_se(n_changes == 2); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); assert_se(changes[1].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-2@.service")); - assert_se(streq(changes[1].source, "/usr/lib/systemd/system/with-dropin-2@.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-2@.service"); + ASSERT_STREQ(changes[1].source, "/usr/lib/systemd/system/with-dropin-2@.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-2@instance-1.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/graphical.target.wants/with-dropin-2@instance-1.service"); - assert_se(streq(changes[1].path, p)); + ASSERT_STREQ(changes[1].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("with-dropin-2@instance-2.service"), &changes, &n_changes) == 1); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-2@.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-2@.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-2@instance-2.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; assert_se(unit_file_enable(RUNTIME_SCOPE_SYSTEM, 0, root, STRV_MAKE("with-dropin-3@.service"), &changes, &n_changes) == 1); assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); - assert_se(streq(changes[0].source, "/usr/lib/systemd/system/with-dropin-3@.service")); + ASSERT_STREQ(changes[0].source, "/usr/lib/systemd/system/with-dropin-3@.service"); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/with-dropin-3@instance-2.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -1080,7 +1080,7 @@ TEST(preset_multiple_instances) { assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_SYMLINK); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/foo@bar0.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -1088,7 +1088,7 @@ TEST(preset_multiple_instances) { assert_se(n_changes == 1); assert_se(changes[0].type == INSTALL_CHANGE_UNLINK); p = strjoina(root, SYSTEM_CONFIG_UNIT_DIR"/multi-user.target.wants/foo@bar0.service"); - assert_se(streq(changes[0].path, p)); + ASSERT_STREQ(changes[0].path, p); install_changes_free(changes, n_changes); changes = NULL; n_changes = 0; @@ -1131,7 +1131,7 @@ static void verify_one( * RequiredBy= settings, and less so for Alias=. The only case where it should happen is when we have * an Alias=alias@.service an instantiated template template@instance. In that case the instance name * should be propagated into the alias as alias@instance. */ - assert_se(streq_ptr(alias2, updated_name)); + ASSERT_STREQ(alias2, updated_name); } TEST(verify_alias) { diff --git a/src/test/test-ip-protocol-list.c b/src/test/test-ip-protocol-list.c index dfff015f53e..9d0403c2f9d 100644 --- a/src/test/test-ip-protocol-list.c +++ b/src/test/test-ip-protocol-list.c @@ -27,8 +27,8 @@ static void test_int_fail(int i, int error) { } static void test_str(const char *s) { - assert_se(streq(ip_protocol_to_name(ip_protocol_from_name(s)), s)); - assert_se(streq(ip_protocol_to_name(parse_ip_protocol(s)), s)); + ASSERT_STREQ(ip_protocol_to_name(ip_protocol_from_name(s)), s); + ASSERT_STREQ(ip_protocol_to_name(parse_ip_protocol(s)), s); } static void test_str_fail(const char *s, int error) { diff --git a/src/test/test-json.c b/src/test/test-json.c index 2762ca64a5c..7d9a7852f0e 100644 --- a/src/test/test-json.c +++ b/src/test/test-json.c @@ -44,7 +44,7 @@ static void test_tokenizer_one(const char *data, ...) { const char *nn; nn = va_arg(ap, const char *); - assert_se(streq_ptr(nn, str)); + ASSERT_STREQ(nn, str); } else if (t == JSON_TOKEN_REAL) { double d; @@ -109,7 +109,7 @@ static void test_variant_one(const char *data, Test test) { s = mfree(s); r = json_variant_format(w, JSON_FORMAT_CENSOR_SENSITIVE, &s); assert_se(s); - assert_se(streq_ptr(s, "\"\"")); + ASSERT_STREQ(s, "\"\""); s = mfree(s); r = json_variant_format(w, JSON_FORMAT_PRETTY, &s); @@ -167,7 +167,7 @@ static void test_1(JsonVariant *v) { assert_se(p && json_variant_type(p) == JSON_VARIANT_STRING); /* k equals v */ - assert_se(streq(json_variant_string(p), "v")); + ASSERT_STREQ(json_variant_string(p), "v"); /* has foo */ p = json_variant_by_key(v, "foo"); @@ -334,7 +334,7 @@ TEST(build) { assert_se(json_variant_format(b, 0, &t) >= 0); log_info("GOT: %s", t); - assert_se(streq(s, t)); + ASSERT_STREQ(s, t); a = json_variant_unref(a); b = json_variant_unref(b); @@ -462,7 +462,7 @@ TEST(normalize) { assert_se(!json_variant_is_normalized(v)); assert_se(json_variant_format(v, 0, &t) >= 0); - assert_se(streq(t, "{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}")); + ASSERT_STREQ(t, "{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}"); t = mfree(t); assert_se(json_build(&w, JSON_BUILD_OBJECT( @@ -473,7 +473,7 @@ TEST(normalize) { assert_se(!json_variant_is_normalized(w)); assert_se(json_variant_format(w, 0, &t) >= 0); - assert_se(streq(t, "{\"bar\":\"zzz\",\"foo\":{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}}")); + ASSERT_STREQ(t, "{\"bar\":\"zzz\",\"foo\":{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}}"); t = mfree(t); assert_se(json_variant_sort(&v) >= 0); @@ -481,7 +481,7 @@ TEST(normalize) { assert_se(json_variant_is_normalized(v)); assert_se(json_variant_format(v, 0, &t) >= 0); - assert_se(streq(t, "{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}")); + ASSERT_STREQ(t, "{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}"); t = mfree(t); assert_se(json_variant_normalize(&w) >= 0); @@ -489,7 +489,7 @@ TEST(normalize) { assert_se(json_variant_is_normalized(w)); assert_se(json_variant_format(w, 0, &t) >= 0); - assert_se(streq(t, "{\"bar\":\"zzz\",\"foo\":{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}}")); + ASSERT_STREQ(t, "{\"bar\":\"zzz\",\"foo\":{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}}"); t = mfree(t); } @@ -531,7 +531,7 @@ TEST(bisect) { assert_se(json_variant_is_string(k)); z = (char[5]){ '<', c, c, '>', 0}; - assert_se(streq(json_variant_string(k), z)); + ASSERT_STREQ(json_variant_string(k), z); } } @@ -698,8 +698,8 @@ static void json_array_append_with_source_one(bool source) { assert_se(json_variant_get_source(a, &s1, &line1, &col1) >= 0); assert_se(json_variant_get_source(b, &s2, &line2, &col2) >= 0); - assert_se(streq_ptr(s1, source ? "string 1" : NULL)); - assert_se(streq_ptr(s2, source ? "string 2" : NULL)); + ASSERT_STREQ(s1, source ? "string 1" : NULL); + ASSERT_STREQ(s2, source ? "string 2" : NULL); assert_se(line1 == 1); assert_se(col1 == 2); assert_se(line2 == 3); @@ -723,8 +723,8 @@ static void json_array_append_with_source_one(bool source) { assert_se(elem = json_variant_by_index(a, 1)); assert_se(json_variant_get_source(elem, &s2, &line2, &col2) >= 0); - assert_se(streq_ptr(s1, source ? "string 2" : NULL)); - assert_se(streq_ptr(s2, source ? "string 2" : NULL)); + ASSERT_STREQ(s1, source ? "string 2" : NULL); + ASSERT_STREQ(s2, source ? "string 2" : NULL); assert_se(line1 == 3); assert_se(col1 == 5); assert_se(line2 == 3); @@ -887,7 +887,7 @@ TEST(json_sensitive) { json_variant_sensitive(a); assert_se(json_variant_format(a, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0); - assert_se(streq_ptr(s, "\"\"")); + ASSERT_STREQ(s, "\"\""); s = mfree(s); r = json_variant_format(b, JSON_FORMAT_CENSOR_SENSITIVE, &s); @@ -932,7 +932,7 @@ TEST(json_sensitive) { json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL); assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0); - assert_se(streq_ptr(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"a\":\"\",\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{}}")); + ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"a\":\"\",\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{}}"); s = mfree(s); v = json_variant_unref(v); @@ -945,7 +945,7 @@ TEST(json_sensitive) { json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL); assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0); - assert_se(streq_ptr(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"a\":\"\",\"d\":\"-9223372036854775808\",\"e\":{}}")); + ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"a\":\"\",\"d\":\"-9223372036854775808\",\"e\":{}}"); s = mfree(s); v = json_variant_unref(v); @@ -958,7 +958,7 @@ TEST(json_sensitive) { json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL); assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0); - assert_se(streq_ptr(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"a\":\"\",\"e\":{}}")); + ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"a\":\"\",\"e\":{}}"); s = mfree(s); v = json_variant_unref(v); @@ -971,7 +971,7 @@ TEST(json_sensitive) { json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL); assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0); - assert_se(streq_ptr(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{},\"a\":\"\"}")); + ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{},\"a\":\"\"}"); } TEST(json_iovec) { diff --git a/src/test/test-load-fragment.c b/src/test/test-load-fragment.c index 658aa8878ee..94904e531e7 100644 --- a/src/test/test-load-fragment.c +++ b/src/test/test-load-fragment.c @@ -79,12 +79,12 @@ static void check_execcommand(ExecCommand *c, n = strv_length(c->argv); log_info("actual: \"%s\" [\"%s\" \"%s\" \"%s\"]", c->path, c->argv[0], n > 0 ? c->argv[1] : "(null)", n > 1 ? c->argv[2] : "(null)"); - assert_se(streq(c->path, path)); - assert_se(streq(c->argv[0], argv0 ?: path)); + ASSERT_STREQ(c->path, path); + ASSERT_STREQ(c->argv[0], argv0 ?: path); if (n > 0) - assert_se(streq_ptr(c->argv[1], argv1)); + ASSERT_STREQ(c->argv[1], argv1); if (n > 1) - assert_se(streq_ptr(c->argv[2], argv2)); + ASSERT_STREQ(c->argv[2], argv2); assert_se(!!(c->flags & EXEC_COMMAND_IGNORE_FAILURE) == ignore); } @@ -544,7 +544,7 @@ TEST(install_printf, .sd_booted = true) { memzero(i.path, strlen(i.path)); \ if (result) { \ printf("%s\n", t); \ - assert_se(streq(t, result)); \ + ASSERT_STREQ(t, result); \ } else \ assert_se(!t); \ strcpy(i.name, d1); \ @@ -794,8 +794,8 @@ TEST(config_parse_pass_environ) { &passenv, NULL); assert_se(r >= 0); assert_se(strv_length(passenv) == 2); - assert_se(streq(passenv[0], "A")); - assert_se(streq(passenv[1], "B")); + ASSERT_STREQ(passenv[0], "A"); + ASSERT_STREQ(passenv[1], "B"); r = config_parse_pass_environ(NULL, "fake", 1, "section", 1, "PassEnvironment", 0, "", @@ -808,7 +808,7 @@ TEST(config_parse_pass_environ) { &passenv, NULL); assert_se(r >= 0); assert_se(strv_length(passenv) == 1); - assert_se(streq(passenv[0], "normal_name")); + ASSERT_STREQ(passenv[0], "normal_name"); } TEST(config_parse_unit_env_file) { @@ -858,8 +858,8 @@ TEST(config_parse_unit_env_file) { &files, u); assert_se(r == 0); assert_se(strv_length(files) == 2); - assert_se(streq(files[0], "/absolute1")); - assert_se(streq(files[1], "/absolute2")); + ASSERT_STREQ(files[0], "/absolute1"); + ASSERT_STREQ(files[1], "/absolute2"); r = config_parse_unit_env_file(u->id, "fake", 1, "section", 1, "EnvironmentFile", 0, "", @@ -872,7 +872,7 @@ TEST(config_parse_unit_env_file) { &files, u); assert_se(r == 0); assert_se(strv_length(files) == 1); - assert_se(streq(files[0], "/path/foobar.service.conf")); + ASSERT_STREQ(files[0], "/path/foobar.service.conf"); } TEST(unit_dump_config_items) { @@ -1073,8 +1073,8 @@ TEST(config_parse_open_file) { &of, u); assert_se(r >= 0); assert_se(of); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "host-mount-namespace")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "host-mount-namespace"); assert_se(of->flags == OPENFILE_READ_ONLY); of = open_file_free(of); @@ -1083,8 +1083,8 @@ TEST(config_parse_open_file) { &of, u); assert_se(r >= 0); assert_se(of); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "mnt")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "mnt"); assert_se(of->flags == OPENFILE_READ_ONLY); r = config_parse_open_file(NULL, "fake", 1, "section", 1, diff --git a/src/test/test-loop-block.c b/src/test/test-loop-block.c index 27a41e863d2..15c635781b3 100644 --- a/src/test/test-loop-block.c +++ b/src/test/test-loop-block.c @@ -49,10 +49,10 @@ static void verify_dissected_image(DissectedImage *dissected) { static void verify_dissected_image_harder(DissectedImage *dissected) { verify_dissected_image(dissected); - assert_se(streq(dissected->partitions[PARTITION_ESP].fstype, "vfat")); - assert_se(streq(dissected->partitions[PARTITION_XBOOTLDR].fstype, "vfat")); - assert_se(streq(dissected->partitions[PARTITION_ROOT].fstype, "ext4")); - assert_se(streq(dissected->partitions[PARTITION_HOME].fstype, "ext4")); + ASSERT_STREQ(dissected->partitions[PARTITION_ESP].fstype, "vfat"); + ASSERT_STREQ(dissected->partitions[PARTITION_XBOOTLDR].fstype, "vfat"); + ASSERT_STREQ(dissected->partitions[PARTITION_ROOT].fstype, "ext4"); + ASSERT_STREQ(dissected->partitions[PARTITION_HOME].fstype, "ext4"); } static void* thread_func(void *ptr) { diff --git a/src/test/test-mempress.c b/src/test/test-mempress.c index 1c3f6463b2d..44f1f4cf5f0 100644 --- a/src/test/test-mempress.c +++ b/src/test/test-mempress.c @@ -40,7 +40,7 @@ static void *fake_pressure_thread(void *p) { assert_se(cfd >= 0); char buf[STRLEN("hello")+1] = {}; assert_se(read(cfd, buf, sizeof(buf)-1) == sizeof(buf)-1); - assert_se(streq(buf, "hello")); + ASSERT_STREQ(buf, "hello"); assert_se(write(cfd, &(const char) { 'z' }, 1) == 1); return 0; diff --git a/src/test/test-memstream-util.c b/src/test/test-memstream-util.c index 254bdcaa15d..b8cc8568f04 100644 --- a/src/test/test-memstream-util.c +++ b/src/test/test-memstream-util.c @@ -17,7 +17,7 @@ TEST(memstream_empty) { assert_se(memstream_init(&m)); assert_se(memstream_finalize(&m, &buf, &sz) >= 0); - assert_se(streq(buf, "")); + ASSERT_STREQ(buf, ""); assert_se(sz == 0); } @@ -32,7 +32,7 @@ TEST(memstream) { fputs("おはよう！", f); fputs(u8"😀😀😀", f); assert_se(memstream_finalize(&m, &buf, &sz) >= 0); - assert_se(streq(buf, u8"hogeおはよう！😀😀😀")); + ASSERT_STREQ(buf, u8"hogeおはよう！😀😀😀"); assert_se(sz == strlen(u8"hogeおはよう！😀😀😀")); buf = mfree(buf); @@ -40,7 +40,7 @@ TEST(memstream) { assert_se(f = memstream_init(&m)); fputs("second", f); assert_se(memstream_finalize(&m, &buf, &sz) >= 0); - assert_se(streq(buf, "second")); + ASSERT_STREQ(buf, "second"); assert_se(sz == strlen("second")); } diff --git a/src/test/test-mount-util.c b/src/test/test-mount-util.c index 9bacc7b5112..a2711f059e3 100644 --- a/src/test/test-mount-util.c +++ b/src/test/test-mount-util.c @@ -43,44 +43,44 @@ TEST(mount_option_mangle) { assert_se(mount_option_mangle("ro,nosuid,nodev,noexec,mode=0755", 0, &f, &opts) == 0); assert_se(f == (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC)); - assert_se(streq(opts, "mode=0755")); + ASSERT_STREQ(opts, "mode=0755"); opts = mfree(opts); assert_se(mount_option_mangle("rw,nosuid,foo,hogehoge,nodev,mode=0755", 0, &f, &opts) == 0); assert_se(f == (MS_NOSUID|MS_NODEV)); - assert_se(streq(opts, "foo,hogehoge,mode=0755")); + ASSERT_STREQ(opts, "foo,hogehoge,mode=0755"); opts = mfree(opts); assert_se(mount_option_mangle("rw,nosuid,nodev,noexec,relatime,net_cls,net_prio", MS_RDONLY, &f, &opts) == 0); assert_se(f == (MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_RELATIME)); - assert_se(streq(opts, "net_cls,net_prio")); + ASSERT_STREQ(opts, "net_cls,net_prio"); opts = mfree(opts); assert_se(mount_option_mangle("rw,nosuid,nodev,relatime,size=1630748k,mode=0700,uid=1000,gid=1000", MS_RDONLY, &f, &opts) == 0); assert_se(f == (MS_NOSUID|MS_NODEV|MS_RELATIME)); - assert_se(streq(opts, "size=1630748k,mode=0700,uid=1000,gid=1000")); + ASSERT_STREQ(opts, "size=1630748k,mode=0700,uid=1000,gid=1000"); opts = mfree(opts); assert_se(mount_option_mangle("size=1630748k,rw,gid=1000,,,nodev,relatime,,mode=0700,nosuid,uid=1000", MS_RDONLY, &f, &opts) == 0); assert_se(f == (MS_NOSUID|MS_NODEV|MS_RELATIME)); - assert_se(streq(opts, "size=1630748k,gid=1000,mode=0700,uid=1000")); + ASSERT_STREQ(opts, "size=1630748k,gid=1000,mode=0700,uid=1000"); opts = mfree(opts); assert_se(mount_option_mangle("rw,exec,size=8143984k,nr_inodes=2035996,mode=0755", MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV, &f, &opts) == 0); assert_se(f == (MS_NOSUID|MS_NODEV)); - assert_se(streq(opts, "size=8143984k,nr_inodes=2035996,mode=0755")); + ASSERT_STREQ(opts, "size=8143984k,nr_inodes=2035996,mode=0755"); opts = mfree(opts); assert_se(mount_option_mangle("rw,relatime,fmask=0022,,,dmask=0022", MS_RDONLY, &f, &opts) == 0); assert_se(f == MS_RELATIME); - assert_se(streq(opts, "fmask=0022,dmask=0022")); + ASSERT_STREQ(opts, "fmask=0022,dmask=0022"); opts = mfree(opts); assert_se(mount_option_mangle("rw,relatime,fmask=0022,dmask=0022,\"hogehoge", MS_RDONLY, &f, &opts) < 0); assert_se(mount_option_mangle("mode=01777,size=10%,nr_inodes=400k,uid=496107520,gid=496107520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\"", 0, &f, &opts) == 0); assert_se(f == 0); - assert_se(streq(opts, "mode=01777,size=10%,nr_inodes=400k,uid=496107520,gid=496107520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\"")); + ASSERT_STREQ(opts, "mode=01777,size=10%,nr_inodes=400k,uid=496107520,gid=496107520,context=\"system_u:object_r:svirt_sandbox_file_t:s0:c0,c1\""); opts = mfree(opts); } @@ -91,7 +91,7 @@ static void test_mount_flags_to_string_one(unsigned long flags, const char *expe r = mount_flags_to_string(flags, &x); log_info("flags: %#lX → %d/\"%s\"", flags, r, strnull(x)); assert_se(r >= 0); - assert_se(streq(x, expected)); + ASSERT_STREQ(x, expected); } TEST(mount_flags_to_string) { diff --git a/src/test/test-mountpoint-util.c b/src/test/test-mountpoint-util.c index affcaccc007..6060ec2fc80 100644 --- a/src/test/test-mountpoint-util.c +++ b/src/test/test-mountpoint-util.c @@ -33,7 +33,7 @@ static void test_mount_propagation_flag_one(const char *name, int ret, unsigned if (isempty(name)) assert_se(isempty(c)); else - assert_se(streq(c, name)); + ASSERT_STREQ(c, name); } } diff --git a/src/test/test-net-naming-scheme.c b/src/test/test-net-naming-scheme.c index f7ec5a6d72f..a339020857a 100644 --- a/src/test/test-net-naming-scheme.c +++ b/src/test/test-net-naming-scheme.c @@ -25,7 +25,7 @@ TEST(naming_scheme_conversions) { log_info("latest → %s", n->name); assert_se(n = naming_scheme_from_name("v238")); - assert_se(streq(n->name, "v238")); + ASSERT_STREQ(n->name, "v238"); } DEFINE_TEST_MAIN(LOG_INFO); diff --git a/src/test/test-nulstr-util.c b/src/test/test-nulstr-util.c index 95c25f1540c..9b13d3c339a 100644 --- a/src/test/test-nulstr-util.c +++ b/src/test/test-nulstr-util.c @@ -13,10 +13,10 @@ TEST(strv_split_nulstr) { l = strv_split_nulstr(nulstr); assert_se(l); - assert_se(streq(l[0], "str0")); - assert_se(streq(l[1], "str1")); - assert_se(streq(l[2], "str2")); - assert_se(streq(l[3], "str3")); + ASSERT_STREQ(l[0], "str0"); + ASSERT_STREQ(l[1], "str1"); + ASSERT_STREQ(l[2], "str2"); + ASSERT_STREQ(l[3], "str3"); } #define strv_parse_nulstr_full_one(s, n, e0, e1) \ @@ -97,7 +97,7 @@ static void test_strv_make_nulstr_one(char **l) { assert_se(memcmp_nn(b, n, c, m) == 0); NULSTR_FOREACH(s, b) - assert_se(streq(s, l[i++])); + ASSERT_STREQ(s, l[i++]); assert_se(i == strv_length(l)); } diff --git a/src/test/test-open-file.c b/src/test/test-open-file.c index 4c3ba57bc8c..22f58affccc 100644 --- a/src/test/test-open-file.c +++ b/src/test/test-open-file.c @@ -11,32 +11,32 @@ TEST(open_file_parse) { r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:read-only", &of); assert_se(r >= 0); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "host-mount-namespace")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "host-mount-namespace"); assert_se(of->flags == OPENFILE_READ_ONLY); of = open_file_free(of); r = open_file_parse("/proc/1/ns/mnt", &of); assert_se(r >= 0); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "mnt")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "mnt"); assert_se(of->flags == 0); of = open_file_free(of); r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace", &of); assert_se(r >= 0); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "host-mount-namespace")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "host-mount-namespace"); assert_se(of->flags == 0); of = open_file_free(of); r = open_file_parse("/proc/1/ns/mnt::read-only", &of); assert_se(r >= 0); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "mnt")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "mnt"); assert_se(of->flags == OPENFILE_READ_ONLY); of = open_file_free(of); @@ -53,16 +53,16 @@ TEST(open_file_parse) { r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:append", &of); assert_se(r >= 0); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "host-mount-namespace")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "host-mount-namespace"); assert_se(of->flags == OPENFILE_APPEND); of = open_file_free(of); r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:truncate", &of); assert_se(r >= 0); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "host-mount-namespace")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "host-mount-namespace"); assert_se(of->flags == OPENFILE_TRUNCATE); of = open_file_free(of); @@ -89,16 +89,16 @@ TEST(open_file_parse) { r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:graceful", &of); assert_se(r >= 0); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "host-mount-namespace")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "host-mount-namespace"); assert_se(of->flags == OPENFILE_GRACEFUL); of = open_file_free(of); r = open_file_parse("/proc/1/ns/mnt:host-mount-namespace:read-only,graceful", &of); assert_se(r >= 0); - assert_se(streq(of->path, "/proc/1/ns/mnt")); - assert_se(streq(of->fdname, "host-mount-namespace")); + ASSERT_STREQ(of->path, "/proc/1/ns/mnt"); + ASSERT_STREQ(of->fdname, "host-mount-namespace"); assert_se(of->flags == (OPENFILE_READ_ONLY | OPENFILE_GRACEFUL)); of = open_file_free(of); @@ -120,7 +120,7 @@ TEST(open_file_to_string) { r = open_file_to_string(of, &s); assert_se(r >= 0); - assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:read-only")); + ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:read-only"); s = mfree(s); of->flags = OPENFILE_APPEND; @@ -128,7 +128,7 @@ TEST(open_file_to_string) { r = open_file_to_string(of, &s); assert_se(r >= 0); - assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:append")); + ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:append"); s = mfree(s); of->flags = OPENFILE_TRUNCATE; @@ -136,7 +136,7 @@ TEST(open_file_to_string) { r = open_file_to_string(of, &s); assert_se(r >= 0); - assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:truncate")); + ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:truncate"); s = mfree(s); of->flags = OPENFILE_GRACEFUL; @@ -144,7 +144,7 @@ TEST(open_file_to_string) { r = open_file_to_string(of, &s); assert_se(r >= 0); - assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:graceful")); + ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:graceful"); s = mfree(s); of->flags = OPENFILE_READ_ONLY | OPENFILE_GRACEFUL; @@ -152,7 +152,7 @@ TEST(open_file_to_string) { r = open_file_to_string(of, &s); assert_se(r >= 0); - assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace:read-only,graceful")); + ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace:read-only,graceful"); s = mfree(s); of->flags = 0; @@ -160,7 +160,7 @@ TEST(open_file_to_string) { r = open_file_to_string(of, &s); assert_se(r >= 0); - assert_se(streq(s, "/proc/1/ns/mnt:host-mount-namespace")); + ASSERT_STREQ(s, "/proc/1/ns/mnt:host-mount-namespace"); s = mfree(s); assert_se(free_and_strdup(&of->fdname, "mnt")); @@ -169,7 +169,7 @@ TEST(open_file_to_string) { r = open_file_to_string(of, &s); assert_se(r >= 0); - assert_se(streq(s, "/proc/1/ns/mnt::read-only")); + ASSERT_STREQ(s, "/proc/1/ns/mnt::read-only"); s = mfree(s); ASSERT_OK(free_and_strdup(&of->path, "/path:with:colon")); diff --git a/src/test/test-ordered-set.c b/src/test/test-ordered-set.c index c055411b798..bb1eefb0838 100644 --- a/src/test/test-ordered-set.c +++ b/src/test/test-ordered-set.c @@ -81,9 +81,9 @@ TEST(set_put) { * non-trivial hash ops. */ assert_se(t = ordered_set_get_strv(m)); - assert_se(streq(t[0], "1")); - assert_se(streq(t[1], "22")); - assert_se(streq(t[2], "333")); + ASSERT_STREQ(t[0], "1"); + ASSERT_STREQ(t[1], "22"); + ASSERT_STREQ(t[2], "333"); assert_se(!t[3]); ordered_set_print(stdout, "FOO=", m); diff --git a/src/test/test-os-util.c b/src/test/test-os-util.c index e6838421709..55475a56ae9 100644 --- a/src/test/test-os-util.c +++ b/src/test/test-os-util.c @@ -39,8 +39,8 @@ TEST(parse_os_release) { ASSERT_EQ(setenv("SYSTEMD_OS_RELEASE", tmpfile, 1), 0); ASSERT_EQ(parse_os_release(NULL, "ID", &id, "NAME", &name), 0); log_info("ID: %s NAME: %s", id, name); - assert_se(streq(id, "the-id")); - assert_se(streq(name, "the-name")); + ASSERT_STREQ(id, "the-id"); + ASSERT_STREQ(name, "the-name"); _cleanup_(unlink_tempfilep) char tmpfile2[] = "/tmp/test-os-util.XXXXXX"; ASSERT_EQ(write_tmpfile(tmpfile2, @@ -51,8 +51,8 @@ TEST(parse_os_release) { ASSERT_EQ(setenv("SYSTEMD_OS_RELEASE", tmpfile2, 1), 0); ASSERT_EQ(parse_os_release(NULL, "ID", &id, "NAME", &name), 0); log_info("ID: %s NAME: %s", id, name); - assert_se(streq(id, "the-id")); - assert_se(streq(name, "the-name")); + ASSERT_STREQ(id, "the-id"); + ASSERT_STREQ(name, "the-name"); ASSERT_EQ(parse_os_release(NULL, "FOOBAR", &foobar), 0); log_info("FOOBAR: %s", strnull(foobar)); @@ -80,8 +80,8 @@ TEST(parse_extension_release) { assert_se(parse_extension_release(tempdir, IMAGE_SYSEXT, "test", false, "ID", &id, "VERSION_ID", &version_id) == 0); log_info("ID: %s VERSION_ID: %s", id, version_id); - assert_se(streq(id, "the-id")); - assert_se(streq(version_id, "the-version-id")); + ASSERT_STREQ(id, "the-id"); + ASSERT_STREQ(version_id, "the-version-id"); assert_se(b = path_join(tempdir, "/etc/extension-release.d/extension-release.tester")); assert_se(mkdir_parents(b, 0777) >= 0); @@ -92,8 +92,8 @@ TEST(parse_extension_release) { ASSERT_EQ(parse_extension_release(tempdir, IMAGE_CONFEXT, "tester", false, "ID", &id, "VERSION_ID", &version_id), 0); log_info("ID: %s VERSION_ID: %s", id, version_id); - assert_se(streq(id, "the-id")); - assert_se(streq(version_id, "the-version-id")); + ASSERT_STREQ(id, "the-id"); + ASSERT_STREQ(version_id, "the-version-id"); assert_se(parse_extension_release(tempdir, IMAGE_CONFEXT, "tester", false, "FOOBAR", &foobar) == 0); log_info("FOOBAR: %s", strnull(foobar)); diff --git a/src/test/test-parse-argument.c b/src/test/test-parse-argument.c index 3772a874360..c07b2d9afe7 100644 --- a/src/test/test-parse-argument.c +++ b/src/test/test-parse-argument.c @@ -20,10 +20,10 @@ TEST(parse_path_argument) { _cleanup_free_ char *path = NULL; assert_se(parse_path_argument("help", false, &path) == 0); - assert_se(streq(basename(path), "help")); + ASSERT_STREQ(basename(path), "help"); assert_se(parse_path_argument("/", false, &path) == 0); - assert_se(streq(path, "/")); + ASSERT_STREQ(path, "/"); assert_se(parse_path_argument("/", true, &path) == 0); ASSERT_NULL(path); diff --git a/src/test/test-path-lookup.c b/src/test/test-path-lookup.c index cb13fad7c51..cff27749317 100644 --- a/src/test/test-path-lookup.c +++ b/src/test/test-path-lookup.c @@ -28,7 +28,7 @@ static void test_paths_one(RuntimeScope scope) { assert_se(setenv("SYSTEMD_UNIT_PATH", systemd_unit_path, 1) == 0); assert_se(lookup_paths_init(&lp_with_env, scope, 0, NULL) == 0); assert_se(strv_length(lp_with_env.search_path) == 1); - assert_se(streq(lp_with_env.search_path[0], systemd_unit_path)); + ASSERT_STREQ(lp_with_env.search_path[0], systemd_unit_path); lookup_paths_log(&lp_with_env); assert_se(strv_equal(lp_with_env.search_path, STRV_MAKE(systemd_unit_path))); } diff --git a/src/test/test-path-util.c b/src/test/test-path-util.c index 139bed76c4d..72b92b7a9aa 100644 --- a/src/test/test-path-util.c +++ b/src/test/test-path-util.c @@ -26,10 +26,10 @@ TEST(path) { assert_se( path_is_absolute("/")); assert_se(!path_is_absolute("./")); - assert_se(streq(basename("./aa/bb/../file.da."), "file.da.")); - assert_se(streq(basename("/aa///.file"), ".file")); - assert_se(streq(basename("/aa///file..."), "file...")); - assert_se(streq(basename("file.../"), "")); + ASSERT_STREQ(basename("./aa/bb/../file.da."), "file.da."); + ASSERT_STREQ(basename("/aa///.file"), ".file"); + ASSERT_STREQ(basename("/aa///file..."), "file..."); + ASSERT_STREQ(basename("file.../"), ""); assert_se( PATH_IN_SET("/bin", "/", "/bin", "/foo")); assert_se( PATH_IN_SET("/bin", "/bin")); @@ -146,7 +146,7 @@ static void test_path_simplify_one(const char *in, const char *out, PathSimplify p = strdupa_safe(in); path_simplify_full(p, flags); log_debug("/* test_path_simplify(%s) → %s (expected: %s) */", in, p, out); - assert_se(streq(p, out)); + ASSERT_STREQ(p, out); } TEST(path_simplify) { @@ -379,12 +379,12 @@ TEST(find_executable_full) { assert_se(find_executable_full("sh", NULL, NULL, true, &p, NULL) == 0); puts(p); - assert_se(streq(basename(p), "sh")); + ASSERT_STREQ(basename(p), "sh"); free(p); assert_se(find_executable_full("sh", NULL, NULL, false, &p, NULL) == 0); puts(p); - assert_se(streq(basename(p), "sh")); + ASSERT_STREQ(basename(p), "sh"); free(p); _cleanup_free_ char *oldpath = NULL; @@ -396,12 +396,12 @@ TEST(find_executable_full) { assert_se(find_executable_full("sh", NULL, NULL, true, &p, NULL) == 0); puts(p); - assert_se(streq(basename(p), "sh")); + ASSERT_STREQ(basename(p), "sh"); free(p); assert_se(find_executable_full("sh", NULL, NULL, false, &p, NULL) == 0); puts(p); - assert_se(streq(basename(p), "sh")); + ASSERT_STREQ(basename(p), "sh"); free(p); if (oldpath) @@ -414,7 +414,7 @@ TEST(find_executable_full) { assert_se(find_executable_full(test_file_name, NULL, STRV_MAKE("/doesnotexist", "/tmp", "/bin"), false, &p, NULL) == 0); puts(p); - assert_se(streq(p, fn)); + ASSERT_STREQ(p, fn); free(p); (void) unlink(fn); @@ -442,12 +442,12 @@ TEST(find_executable) { free(p); assert_se(find_executable("/bin/touch", &p) == 0); - assert_se(streq(p, "/bin/touch")); + ASSERT_STREQ(p, "/bin/touch"); free(p); assert_se(find_executable("touch", &p) == 0); assert_se(path_is_absolute(p)); - assert_se(streq(basename(p), "touch")); + ASSERT_STREQ(basename(p), "touch"); free(p); assert_se(find_executable("xxxx-xxxx", &p) == -ENOENT); @@ -468,7 +468,7 @@ static void test_find_executable_exec_one(const char *path) { assert_se(fd > STDERR_FILENO); assert_se(path_is_absolute(t)); if (path_is_absolute(path)) - assert_se(streq(t, path)); + ASSERT_STREQ(t, path); pid = fork(); assert_se(pid >= 0); @@ -506,25 +506,25 @@ TEST(prefixes) { i = 0; PATH_FOREACH_PREFIX_MORE(s, "/a/b/c/d") { log_error("---%s---", s); - assert_se(streq(s, values[i++])); + ASSERT_STREQ(s, values[i++]); } ASSERT_NULL(values[i]); i = 1; PATH_FOREACH_PREFIX(s, "/a/b/c/d") { log_error("---%s---", s); - assert_se(streq(s, values[i++])); + ASSERT_STREQ(s, values[i++]); } ASSERT_NULL(values[i]); i = 0; PATH_FOREACH_PREFIX_MORE(s, "////a////b////c///d///////") - assert_se(streq(s, values[i++])); + ASSERT_STREQ(s, values[i++]); ASSERT_NULL(values[i]); i = 1; PATH_FOREACH_PREFIX(s, "////a////b////c///d///////") - assert_se(streq(s, values[i++])); + ASSERT_STREQ(s, values[i++]); ASSERT_NULL(values[i]); PATH_FOREACH_PREFIX(s, "////") @@ -533,7 +533,7 @@ TEST(prefixes) { b = false; PATH_FOREACH_PREFIX_MORE(s, "////") { assert_se(!b); - assert_se(streq(s, "")); + ASSERT_STREQ(s, ""); b = true; } assert_se(b); @@ -544,7 +544,7 @@ TEST(prefixes) { b = false; PATH_FOREACH_PREFIX_MORE(s, "") { assert_se(!b); - assert_se(streq(s, "")); + ASSERT_STREQ(s, ""); b = true; } } @@ -554,7 +554,7 @@ TEST(path_join) { _cleanup_free_ char *z = NULL; \ z = path_join(__VA_ARGS__); \ log_debug("got \"%s\", expected \"%s\"", z, expected); \ - assert_se(streq(z, expected)); \ + ASSERT_STREQ(z, expected); \ } test_join("/root/a/b/c", "/root", "/a/b", "/c"); @@ -597,25 +597,25 @@ TEST(path_extend) { _cleanup_free_ char *p = NULL; assert_se(path_extend(&p, "foo", "bar", "baz") == p); - assert_se(streq(p, "foo/bar/baz")); + ASSERT_STREQ(p, "foo/bar/baz"); assert_se(path_extend(&p, "foo", "bar", "baz") == p); - assert_se(streq(p, "foo/bar/baz/foo/bar/baz")); + ASSERT_STREQ(p, "foo/bar/baz/foo/bar/baz"); p = mfree(p); assert_se(path_extend(&p, "foo") == p); - assert_se(streq(p, "foo")); + ASSERT_STREQ(p, "foo"); assert_se(path_extend(&p, "/foo") == p); - assert_se(streq(p, "foo/foo")); + ASSERT_STREQ(p, "foo/foo"); assert_se(path_extend(&p, "/waaaah/wahhh//") == p); - assert_se(streq(p, "foo/foo/waaaah/wahhh//")); /* path_extend() does not drop redundant slashes */ + ASSERT_STREQ(p, "foo/foo/waaaah/wahhh//"); /* path_extend() does not drop redundant slashes */ assert_se(path_extend(&p, "/aaa/bbb/") == p); - assert_se(streq(p, "foo/foo/waaaah/wahhh///aaa/bbb/")); /* but not add an extra slash */ + ASSERT_STREQ(p, "foo/foo/waaaah/wahhh///aaa/bbb/"); /* but not add an extra slash */ assert_se(free_and_strdup(&p, "/") >= 0); assert_se(path_extend(&p, "foo") == p); - assert_se(streq(p, "/foo")); + ASSERT_STREQ(p, "/foo"); } TEST(fsck_exists) { @@ -637,7 +637,7 @@ static void test_path_make_relative_one(const char *from, const char *to, const r = path_make_relative(from, to, &z); assert_se((r >= 0) == !!expected); - assert_se(streq_ptr(z, expected)); + ASSERT_STREQ(z, expected); } TEST(path_make_relative) { @@ -663,7 +663,7 @@ static void test_path_make_relative_parent_one(const char *from, const char *to, r = path_make_relative_parent(from, to, &z); assert_se((r >= 0) == !!expected); - assert_se(streq_ptr(z, expected)); + ASSERT_STREQ(z, expected); } TEST(path_make_relative_parent) { @@ -702,9 +702,9 @@ TEST(path_strv_resolve) { assert_se(symlink("dir2", absolute_dirs[2]) == 0); path_strv_resolve(search_dirs, tmp_dir); - assert_se(streq(search_dirs[0], "/dir1")); - assert_se(streq(search_dirs[1], "/dir2")); - assert_se(streq(search_dirs[2], "/dir2")); + ASSERT_STREQ(search_dirs[0], "/dir1"); + ASSERT_STREQ(search_dirs[1], "/dir2"); + ASSERT_STREQ(search_dirs[2], "/dir2"); assert_se(rm_rf(tmp_dir, REMOVE_ROOT|REMOVE_PHYSICAL) == 0); } @@ -715,10 +715,10 @@ static void test_path_startswith_one(const char *path, const char *prefix, const log_debug("/* %s(%s, %s) */", __func__, path, prefix); p = path_startswith(path, prefix); - assert_se(streq_ptr(p, expected)); + ASSERT_STREQ(p, expected); if (p) { q = strjoina(skipped, p); - assert_se(streq(q, path)); + ASSERT_STREQ(q, path); assert_se(p == path + strlen(skipped)); } } @@ -793,17 +793,17 @@ TEST(file_in_same_dir) { assert_se(file_in_same_dir("/", "a", &t) == -EADDRNOTAVAIL); assert_se(file_in_same_dir("/", "/a", &t) >= 0); - assert_se(streq(t, "/a")); + ASSERT_STREQ(t, "/a"); free(t); assert_se(file_in_same_dir("", "a", &t) == -EINVAL); assert_se(file_in_same_dir("a/", "x", &t) >= 0); - assert_se(streq(t, "x")); + ASSERT_STREQ(t, "x"); free(t); assert_se(file_in_same_dir("bar/foo", "bar", &t) >= 0); - assert_se(streq(t, "bar/bar")); + ASSERT_STREQ(t, "bar/bar"); free(t); } @@ -987,22 +987,22 @@ TEST(path_find_last_component) { TEST(last_path_component) { ASSERT_NULL(last_path_component(NULL)); - assert_se(streq(last_path_component("a/b/c"), "c")); - assert_se(streq(last_path_component("a/b/c/"), "c/")); - assert_se(streq(last_path_component("/"), "/")); - assert_se(streq(last_path_component("//"), "/")); - assert_se(streq(last_path_component("///"), "/")); - assert_se(streq(last_path_component("."), ".")); - assert_se(streq(last_path_component("./."), ".")); - assert_se(streq(last_path_component("././"), "./")); - assert_se(streq(last_path_component("././/"), ".//")); - assert_se(streq(last_path_component("/foo/a"), "a")); - assert_se(streq(last_path_component("/foo/a/"), "a/")); - assert_se(streq(last_path_component(""), "")); - assert_se(streq(last_path_component("a"), "a")); - assert_se(streq(last_path_component("a/"), "a/")); - assert_se(streq(last_path_component("/a"), "a")); - assert_se(streq(last_path_component("/a/"), "a/")); + ASSERT_STREQ(last_path_component("a/b/c"), "c"); + ASSERT_STREQ(last_path_component("a/b/c/"), "c/"); + ASSERT_STREQ(last_path_component("/"), "/"); + ASSERT_STREQ(last_path_component("//"), "/"); + ASSERT_STREQ(last_path_component("///"), "/"); + ASSERT_STREQ(last_path_component("."), "."); + ASSERT_STREQ(last_path_component("./."), "."); + ASSERT_STREQ(last_path_component("././"), "./"); + ASSERT_STREQ(last_path_component("././/"), ".//"); + ASSERT_STREQ(last_path_component("/foo/a"), "a"); + ASSERT_STREQ(last_path_component("/foo/a/"), "a/"); + ASSERT_STREQ(last_path_component(""), ""); + ASSERT_STREQ(last_path_component("a"), "a"); + ASSERT_STREQ(last_path_component("a/"), "a/"); + ASSERT_STREQ(last_path_component("/a"), "a"); + ASSERT_STREQ(last_path_component("/a/"), "a/"); } static void test_path_extract_filename_one(const char *input, const char *output, int ret) { @@ -1014,7 +1014,7 @@ static void test_path_extract_filename_one(const char *input, const char *output strnull(input), strnull(k), r < 0 ? STRERROR(r) : "-", strnull(output), ret < 0 ? STRERROR(ret) : "-"); - assert_se(streq_ptr(k, output)); + ASSERT_STREQ(k, output); assert_se(r == ret); } @@ -1058,7 +1058,7 @@ static void test_path_extract_directory_one(const char *input, const char *outpu strnull(input), strnull(k), r < 0 ? STRERROR(r) : "-", strnull(output), STRERROR(ret)); - assert_se(streq_ptr(k, output)); + ASSERT_STREQ(k, output); assert_se(r == ret); /* Extra safety check: let's make sure that if we split out the filename too (and it works) the @@ -1192,17 +1192,17 @@ TEST(hidden_or_backup_file) { } TEST(skip_dev_prefix) { - assert_se(streq(skip_dev_prefix("/"), "/")); - assert_se(streq(skip_dev_prefix("/dev"), "")); - assert_se(streq(skip_dev_prefix("/dev/"), "")); - assert_se(streq(skip_dev_prefix("/dev/foo"), "foo")); - assert_se(streq(skip_dev_prefix("/dev/foo/bar"), "foo/bar")); - assert_se(streq(skip_dev_prefix("//dev"), "")); - assert_se(streq(skip_dev_prefix("//dev//"), "")); - assert_se(streq(skip_dev_prefix("/dev///foo"), "foo")); - assert_se(streq(skip_dev_prefix("///dev///foo///bar"), "foo///bar")); - assert_se(streq(skip_dev_prefix("//foo"), "//foo")); - assert_se(streq(skip_dev_prefix("foo"), "foo")); + ASSERT_STREQ(skip_dev_prefix("/"), "/"); + ASSERT_STREQ(skip_dev_prefix("/dev"), ""); + ASSERT_STREQ(skip_dev_prefix("/dev/"), ""); + ASSERT_STREQ(skip_dev_prefix("/dev/foo"), "foo"); + ASSERT_STREQ(skip_dev_prefix("/dev/foo/bar"), "foo/bar"); + ASSERT_STREQ(skip_dev_prefix("//dev"), ""); + ASSERT_STREQ(skip_dev_prefix("//dev//"), ""); + ASSERT_STREQ(skip_dev_prefix("/dev///foo"), "foo"); + ASSERT_STREQ(skip_dev_prefix("///dev///foo///bar"), "foo///bar"); + ASSERT_STREQ(skip_dev_prefix("//foo"), "//foo"); + ASSERT_STREQ(skip_dev_prefix("foo"), "foo"); } TEST(empty_or_root) { @@ -1219,43 +1219,43 @@ TEST(empty_or_root) { } TEST(path_startswith_set) { - assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/foo/bar", "/zzz"), "")); - assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/foo/", "/zzz"), "bar")); - assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/foo", "/zzz"), "bar")); - assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "/", "/zzz"), "foo/bar")); - assert_se(streq_ptr(PATH_STARTSWITH_SET("/foo/bar", "/foo/quux", "", "/zzz"), NULL)); - - assert_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) { @@ -1264,7 +1264,7 @@ static void test_path_glob_can_match_one(const char *pattern, const char *prefix log_debug("%s(%s, %s, %s)", __func__, pattern, prefix, strnull(expected)); assert_se(path_glob_can_match(pattern, prefix, &result) == !!expected); - assert_se(streq_ptr(result, expected)); + ASSERT_STREQ(result, expected); } TEST(path_glob_can_match) { diff --git a/src/test/test-proc-cmdline.c b/src/test/test-proc-cmdline.c index 8b5bbb079ea..420f3126363 100644 --- a/src/test/test-proc-cmdline.c +++ b/src/test/test-proc-cmdline.c @@ -37,7 +37,7 @@ TEST(proc_cmdline_override) { /* First test if the overrides for /proc/cmdline still work */ assert_se(proc_cmdline(&line) >= 0); - assert_se(streq(line, "foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\"")); + ASSERT_STREQ(line, "foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\""); line = mfree(line); assert_se(proc_cmdline_strv(&args) >= 0); assert_se(strv_equal(args, STRV_MAKE("foo_bar=quux", "wuff-piep=tuet", "zumm", "some_arg_with_space=foo bar", "and_one_more=zzz aaa"))); @@ -57,7 +57,7 @@ TEST(proc_cmdline_override) { assert_se(putenv((char*) "SYSTEMD_EFI_OPTIONS=foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\"") == 0); assert_se(proc_cmdline(&line) >= 0); - assert_se(streq(line, "hoge")); + ASSERT_STREQ(line, "hoge"); line = mfree(line); assert_se(proc_cmdline_strv(&args) >= 0); assert_se(strv_equal(args, STRV_MAKE("hoge"))); @@ -83,13 +83,13 @@ static int parse_item_given(const char *key, const char *value, void *data) { log_info("%s: option <%s> = <%s>", __func__, key, strna(value)); if (proc_cmdline_key_streq(key, "foo_bar")) - assert_se(streq(value, "quux")); + ASSERT_STREQ(value, "quux"); else if (proc_cmdline_key_streq(key, "wuff-piep")) - assert_se(streq(value, "tuet ")); + ASSERT_STREQ(value, "tuet "); else if (proc_cmdline_key_streq(key, "space")) - assert_se(streq(value, "x y z")); + ASSERT_STREQ(value, "x y z"); else if (proc_cmdline_key_streq(key, "miepf")) - assert_se(streq(value, "uuu")); + ASSERT_STREQ(value, "uuu"); else if (in_initrd() && *strip && proc_cmdline_key_streq(key, "zumm")) assert_se(!value); else if (in_initrd() && !*strip && proc_cmdline_key_streq(key, "rd.zumm")) @@ -231,13 +231,13 @@ TEST(proc_cmdline_get_key_many) { "doubleticks", &value6, "zummm", &value7) == 5); - assert_se(streq_ptr(value1, "quux")); + ASSERT_STREQ(value1, "quux"); assert_se(!value2); - assert_se(streq_ptr(value3, "tuet")); + ASSERT_STREQ(value3, "tuet"); assert_se(!value4); - assert_se(streq_ptr(value5, "one two")); - assert_se(streq_ptr(value6, " aaa aaa ")); - assert_se(streq_ptr(value7, "\n")); + ASSERT_STREQ(value5, "one two"); + ASSERT_STREQ(value6, " aaa aaa "); + ASSERT_STREQ(value7, "\n"); } TEST(proc_cmdline_key_streq) { diff --git a/src/test/test-process-util.c b/src/test/test-process-util.c index 3b3fa9d1243..c96bd4341bc 100644 --- a/src/test/test-process-util.c +++ b/src/test/test-process-util.c @@ -176,7 +176,7 @@ static void test_pid_get_comm_escape_one(const char *input, const char *output) log_debug("got: <%s>", n); - assert_se(streq_ptr(n, output)); + ASSERT_STREQ(n, output); } TEST(pid_get_comm_escape) { @@ -236,14 +236,14 @@ TEST(personality) { assert_se(personality_to_string(PER_LINUX)); assert_se(!personality_to_string(PERSONALITY_INVALID)); - assert_se(streq(personality_to_string(PER_LINUX), architecture_to_string(native_architecture()))); + ASSERT_STREQ(personality_to_string(PER_LINUX), architecture_to_string(native_architecture())); assert_se(personality_from_string(personality_to_string(PER_LINUX)) == PER_LINUX); assert_se(personality_from_string(architecture_to_string(native_architecture())) == PER_LINUX); #ifdef __x86_64__ - assert_se(streq_ptr(personality_to_string(PER_LINUX), "x86-64")); - assert_se(streq_ptr(personality_to_string(PER_LINUX32), "x86")); + ASSERT_STREQ(personality_to_string(PER_LINUX), "x86-64"); + ASSERT_STREQ(personality_to_string(PER_LINUX32), "x86"); assert_se(personality_from_string("x86-64") == PER_LINUX); assert_se(personality_from_string("x86") == PER_LINUX32); @@ -328,49 +328,49 @@ TEST(pid_get_cmdline_harder) { assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "[testa]")); + ASSERT_STREQ(line, "[testa]"); line = mfree(line); assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK | PROCESS_CMDLINE_QUOTE, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "\"[testa]\"")); /* quoting is enabled here */ + ASSERT_STREQ(line, "\"[testa]\""); /* quoting is enabled here */ line = mfree(line); assert_se(pid_get_cmdline(0, 0, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "")); + ASSERT_STREQ(line, ""); line = mfree(line); assert_se(pid_get_cmdline(0, 1, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); - assert_se(streq(line, "…")); + ASSERT_STREQ(line, "…"); line = mfree(line); assert_se(pid_get_cmdline(0, 2, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); - assert_se(streq(line, "[…")); + ASSERT_STREQ(line, "[…"); line = mfree(line); assert_se(pid_get_cmdline(0, 3, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); - assert_se(streq(line, "[t…")); + ASSERT_STREQ(line, "[t…"); line = mfree(line); assert_se(pid_get_cmdline(0, 4, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); - assert_se(streq(line, "[te…")); + ASSERT_STREQ(line, "[te…"); line = mfree(line); assert_se(pid_get_cmdline(0, 5, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); - assert_se(streq(line, "[tes…")); + ASSERT_STREQ(line, "[tes…"); line = mfree(line); assert_se(pid_get_cmdline(0, 6, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); - assert_se(streq(line, "[test…")); + ASSERT_STREQ(line, "[test…"); line = mfree(line); assert_se(pid_get_cmdline(0, 7, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); - assert_se(streq(line, "[testa]")); + ASSERT_STREQ(line, "[testa]"); line = mfree(line); assert_se(pid_get_cmdline(0, 8, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); - assert_se(streq(line, "[testa]")); + ASSERT_STREQ(line, "[testa]"); line = mfree(line); assert_se(pid_get_cmdline_strv(0, PROCESS_CMDLINE_COMM_FALLBACK, &args) >= 0); @@ -383,11 +383,11 @@ TEST(pid_get_cmdline_harder) { assert_se(pid_get_cmdline(0, SIZE_MAX, 0, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar")); + ASSERT_STREQ(line, "foo bar"); line = mfree(line); assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); - assert_se(streq(line, "foo bar")); + ASSERT_STREQ(line, "foo bar"); line = mfree(line); assert_se(pid_get_cmdline_strv(0, PROCESS_CMDLINE_COMM_FALLBACK, &args) >= 0); @@ -397,87 +397,87 @@ TEST(pid_get_cmdline_harder) { assert_se(write(fd, "quux", 4) == 4); assert_se(pid_get_cmdline(0, SIZE_MAX, 0, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar quux")); + ASSERT_STREQ(line, "foo bar quux"); line = mfree(line); assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar quux")); + ASSERT_STREQ(line, "foo bar quux"); line = mfree(line); assert_se(pid_get_cmdline(0, 1, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "…")); + ASSERT_STREQ(line, "…"); line = mfree(line); assert_se(pid_get_cmdline(0, 2, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "f…")); + ASSERT_STREQ(line, "f…"); line = mfree(line); assert_se(pid_get_cmdline(0, 3, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "fo…")); + ASSERT_STREQ(line, "fo…"); line = mfree(line); assert_se(pid_get_cmdline(0, 4, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo…")); + ASSERT_STREQ(line, "foo…"); line = mfree(line); assert_se(pid_get_cmdline(0, 5, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo …")); + ASSERT_STREQ(line, "foo …"); line = mfree(line); assert_se(pid_get_cmdline(0, 6, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo b…")); + ASSERT_STREQ(line, "foo b…"); line = mfree(line); assert_se(pid_get_cmdline(0, 7, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo ba…")); + ASSERT_STREQ(line, "foo ba…"); line = mfree(line); assert_se(pid_get_cmdline(0, 8, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar…")); + ASSERT_STREQ(line, "foo bar…"); line = mfree(line); assert_se(pid_get_cmdline(0, 9, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar …")); + ASSERT_STREQ(line, "foo bar …"); line = mfree(line); assert_se(pid_get_cmdline(0, 10, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar q…")); + ASSERT_STREQ(line, "foo bar q…"); line = mfree(line); assert_se(pid_get_cmdline(0, 11, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar qu…")); + ASSERT_STREQ(line, "foo bar qu…"); line = mfree(line); assert_se(pid_get_cmdline(0, 12, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar quux")); + ASSERT_STREQ(line, "foo bar quux"); line = mfree(line); assert_se(pid_get_cmdline(0, 13, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar quux")); + ASSERT_STREQ(line, "foo bar quux"); line = mfree(line); assert_se(pid_get_cmdline(0, 14, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar quux")); + ASSERT_STREQ(line, "foo bar quux"); line = mfree(line); assert_se(pid_get_cmdline(0, 1000, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "foo bar quux")); + ASSERT_STREQ(line, "foo bar quux"); line = mfree(line); assert_se(pid_get_cmdline_strv(0, PROCESS_CMDLINE_COMM_FALLBACK, &args) >= 0); @@ -491,22 +491,22 @@ TEST(pid_get_cmdline_harder) { assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "[aaaa bbbb cccc]")); + ASSERT_STREQ(line, "[aaaa bbbb cccc]"); line = mfree(line); assert_se(pid_get_cmdline(0, 10, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "[aaaa bbb…")); + ASSERT_STREQ(line, "[aaaa bbb…"); line = mfree(line); assert_se(pid_get_cmdline(0, 11, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "[aaaa bbbb…")); + ASSERT_STREQ(line, "[aaaa bbbb…"); line = mfree(line); assert_se(pid_get_cmdline(0, 12, PROCESS_CMDLINE_COMM_FALLBACK, &line) >= 0); log_debug("'%s'", line); - assert_se(streq(line, "[aaaa bbbb …")); + ASSERT_STREQ(line, "[aaaa bbbb …"); line = mfree(line); assert_se(pid_get_cmdline_strv(0, PROCESS_CMDLINE_COMM_FALLBACK, &args) >= 0); @@ -527,13 +527,13 @@ TEST(pid_get_cmdline_harder) { assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_QUOTE, &line) >= 0); log_debug("got: ==%s==", line); log_debug("exp: ==%s==", EXPECT1); - assert_se(streq(line, EXPECT1)); + ASSERT_STREQ(line, EXPECT1); line = mfree(line); assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_QUOTE_POSIX, &line) >= 0); log_debug("got: ==%s==", line); log_debug("exp: ==%s==", EXPECT1p); - assert_se(streq(line, EXPECT1p)); + ASSERT_STREQ(line, EXPECT1p); line = mfree(line); assert_se(pid_get_cmdline_strv(0, 0, &args) >= 0); @@ -552,13 +552,13 @@ TEST(pid_get_cmdline_harder) { assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_QUOTE, &line) >= 0); log_debug("got: ==%s==", line); log_debug("exp: ==%s==", EXPECT2); - assert_se(streq(line, EXPECT2)); + ASSERT_STREQ(line, EXPECT2); line = mfree(line); assert_se(pid_get_cmdline(0, SIZE_MAX, PROCESS_CMDLINE_QUOTE_POSIX, &line) >= 0); log_debug("got: ==%s==", line); log_debug("exp: ==%s==", EXPECT2p); - assert_se(streq(line, EXPECT2p)); + ASSERT_STREQ(line, EXPECT2p); line = mfree(line); assert_se(pid_get_cmdline_strv(0, 0, &args) >= 0); diff --git a/src/test/test-recovery-key.c b/src/test/test-recovery-key.c index 2e901dc9bcf..8d5ed717d97 100644 --- a/src/test/test-recovery-key.c +++ b/src/test/test-recovery-key.c @@ -107,7 +107,7 @@ TEST(normalize_recovery_key) { r = normalize_recovery_key("cdefVhij-cDefghij-cdefkhij-cdufghij-cdefgdij-cidefIhj-cdefNijR-cdVfguij", &normalized_key2); assert_se(r == 0); - assert_se(streq(normalized_key2, "cdefvhij-cdefghij-cdefkhij-cdufghij-cdefgdij-cidefihj-cdefnijr-cdvfguij")); + ASSERT_STREQ(normalized_key2, "cdefvhij-cdefghij-cdefkhij-cdufghij-cdefgdij-cidefihj-cdefnijr-cdvfguij"); /* Case 3: Invalid password length */ r = normalize_recovery_key("1234-5678-90AB-CDEF-1234-5678-90AB-CDEF", &normalized_key1); @@ -122,7 +122,7 @@ TEST(normalize_recovery_key) { r = normalize_recovery_key("BFGHICEHHIUVLKJIHFHEDlntruvcdefjiTUVKLNIJVTUTKJIHDFBCBGHIJHHFDBC", &normalized_key3); assert(r == 0); - assert_se(streq(normalized_key3, "bfghiceh-hiuvlkji-hfhedlnt-ruvcdefj-ituvklni-jvtutkji-hdfbcbgh-ijhhfdbc")); + ASSERT_STREQ(normalized_key3, "bfghiceh-hiuvlkji-hfhedlnt-ruvcdefj-ituvklni-jvtutkji-hdfbcbgh-ijhhfdbc"); /* Case 6: Minimum password length */ r = normalize_recovery_key("", &normalized_key1); diff --git a/src/test/test-replace-var.c b/src/test/test-replace-var.c index f861b27c12a..56634a854a7 100644 --- a/src/test/test-replace-var.c +++ b/src/test/test-replace-var.c @@ -16,7 +16,7 @@ TEST(replace_var) { assert_se(r = replace_var("@@@foobar@xyz@HALLO@foobar@test@@testtest@TEST@...@@@", lookup, NULL)); puts(r); - assert_se(streq(r, "@@@foobar@xyz<<>>foobar@test@@testtest<<>>...@@@")); + ASSERT_STREQ(r, "@@@foobar@xyz<<>>foobar@test@@testtest<<>>...@@@"); free(r); } @@ -25,7 +25,7 @@ TEST(strreplace) { assert_se(r = strreplace("XYZFFFFXYZFFFFXYZ", "XYZ", "ABC")); puts(r); - assert_se(streq(r, "ABCFFFFABCFFFFABC")); + ASSERT_STREQ(r, "ABCFFFFABCFFFFABC"); free(r); } diff --git a/src/test/test-rlimit-util.c b/src/test/test-rlimit-util.c index 6a68d28090a..fc9e89c4667 100644 --- a/src/test/test-rlimit-util.c +++ b/src/test/test-rlimit-util.c @@ -34,7 +34,7 @@ static void test_rlimit_parse_format_one(int resource, const char *string, rlim_ assert_se(rl.rlim_max == hard); assert_se(rlimit_format(&rl, &f) >= 0); - assert_se(streq(formatted, f)); + ASSERT_STREQ(formatted, f); assert_se(rlimit_parse(resource, formatted, &rl2) >= 0); assert_se(memcmp(&rl, &rl2, sizeof(struct rlimit)) == 0); @@ -118,7 +118,7 @@ TEST(setrlimit) { new.rlim_max = old.rlim_max; assert_se(setrlimit(RLIMIT_NOFILE, &new) >= 0); - assert_se(streq_ptr(rlimit_to_string(RLIMIT_NOFILE), "NOFILE")); + ASSERT_STREQ(rlimit_to_string(RLIMIT_NOFILE), "NOFILE"); ASSERT_NULL(rlimit_to_string(-1)); assert_se(getrlimit(RLIMIT_NOFILE, &old) == 0); diff --git a/src/test/test-seccomp.c b/src/test/test-seccomp.c index 55e91343eb7..74d950ad1c0 100644 --- a/src/test/test-seccomp.c +++ b/src/test/test-seccomp.c @@ -52,40 +52,40 @@ TEST(parse_syscall_and_errno) { int e; assert_se(parse_syscall_and_errno("uname:EILSEQ", &n, &e) >= 0); - assert_se(streq(n, "uname")); + ASSERT_STREQ(n, "uname"); assert_se(e == errno_from_name("EILSEQ") && e >= 0); n = mfree(n); assert_se(parse_syscall_and_errno("uname:EINVAL", &n, &e) >= 0); - assert_se(streq(n, "uname")); + ASSERT_STREQ(n, "uname"); assert_se(e == errno_from_name("EINVAL") && e >= 0); n = mfree(n); assert_se(parse_syscall_and_errno("@sync:4095", &n, &e) >= 0); - assert_se(streq(n, "@sync")); + ASSERT_STREQ(n, "@sync"); assert_se(e == 4095); n = mfree(n); /* If errno is omitted, then e is set to -1 */ assert_se(parse_syscall_and_errno("mount", &n, &e) >= 0); - assert_se(streq(n, "mount")); + ASSERT_STREQ(n, "mount"); assert_se(e == -1); n = mfree(n); /* parse_syscall_and_errno() does not check the syscall name is valid or not. */ assert_se(parse_syscall_and_errno("hoge:255", &n, &e) >= 0); - assert_se(streq(n, "hoge")); + ASSERT_STREQ(n, "hoge"); assert_se(e == 255); n = mfree(n); /* 0 is also a valid errno. */ assert_se(parse_syscall_and_errno("hoge:0", &n, &e) >= 0); - assert_se(streq(n, "hoge")); + ASSERT_STREQ(n, "hoge"); assert_se(e == 0); n = mfree(n); assert_se(parse_syscall_and_errno("hoge:kill", &n, &e) >= 0); - assert_se(streq(n, "hoge")); + ASSERT_STREQ(n, "hoge"); assert_se(e == SECCOMP_ERROR_NUMBER_KILL); n = mfree(n); @@ -151,7 +151,7 @@ TEST(architecture_table) { assert_se(seccomp_arch_from_string(n, &c) >= 0); n2 = seccomp_arch_to_string(c); log_info("seccomp-arch: %s → 0x%"PRIx32" → %s", n, c, n2); - assert_se(streq_ptr(n, n2)); + ASSERT_STREQ(n, n2); } } @@ -231,11 +231,11 @@ TEST(filter_sets) { TEST(filter_sets_ordered) { /* Ensure "@default" always remains at the beginning of the list */ assert_se(SYSCALL_FILTER_SET_DEFAULT == 0); - assert_se(streq(syscall_filter_sets[0].name, "@default")); + ASSERT_STREQ(syscall_filter_sets[0].name, "@default"); /* Ensure "@known" always remains at the end of the list */ assert_se(SYSCALL_FILTER_SET_KNOWN == _SYSCALL_FILTER_SET_MAX - 1); - assert_se(streq(syscall_filter_sets[SYSCALL_FILTER_SET_KNOWN].name, "@known")); + ASSERT_STREQ(syscall_filter_sets[SYSCALL_FILTER_SET_KNOWN].name, "@known"); for (size_t i = 0; i < _SYSCALL_FILTER_SET_MAX; i++) { const char *p = NULL; @@ -294,7 +294,7 @@ TEST(restrict_namespace) { s = mfree(s); assert_se(namespace_flags_to_string(NAMESPACE_FLAGS_ALL, &s) == 0); - assert_se(streq(s, "cgroup ipc net mnt pid user uts")); + ASSERT_STREQ(s, "cgroup ipc net mnt pid user uts"); assert_se(namespace_flags_from_string(s, &ul) == 0 && ul == NAMESPACE_FLAGS_ALL); s = mfree(s); diff --git a/src/test/test-secure-bits.c b/src/test/test-secure-bits.c index 21cfe701570..3d353aecda0 100644 --- a/src/test/test-secure-bits.c +++ b/src/test/test-secure-bits.c @@ -31,7 +31,7 @@ TEST(secure_bits_basic) { assert_se(secure_bits_is_valid(r)); assert_se(secure_bits_to_string_alloc(r, &s) >= 0); printf("%s = 0x%x = %s\n", *bit, (unsigned)r, s); - assert_se(streq(*bit, s)); + ASSERT_STREQ(*bit, s); } /* Ditto, but with all bits at once */ @@ -42,7 +42,7 @@ TEST(secure_bits_basic) { assert_se(secure_bits_is_valid(r)); assert_se(secure_bits_to_string_alloc(r, &str) >= 0); printf("%s = 0x%x = %s\n", joined, (unsigned)r, str); - assert_se(streq(joined, str)); + ASSERT_STREQ(joined, str); str = mfree(str); @@ -65,7 +65,7 @@ TEST(secure_bits_basic) { assert_se(secure_bits_to_string_alloc_with_check( (1 << SECURE_KEEP_CAPS) | (1 << SECURE_KEEP_CAPS_LOCKED), &str) >= 0); - assert_se(streq(str, "keep-caps keep-caps-locked")); + ASSERT_STREQ(str, "keep-caps keep-caps-locked"); } TEST(secure_bits_mix) { @@ -90,7 +90,7 @@ TEST(secure_bits_mix) { assert_se(secure_bits_is_valid(r)); assert_se(secure_bits_to_string_alloc(r, &str) >= 0); printf("%s = 0x%x = %s\n", s->input, (unsigned)r, str); - assert_se(streq(s->expected, str)); + ASSERT_STREQ(s->expected, str); } } diff --git a/src/test/test-serialize.c b/src/test/test-serialize.c index 8f744727c67..40abf6cdcf6 100644 --- a/src/test/test-serialize.c +++ b/src/test/test-serialize.c @@ -32,13 +32,13 @@ TEST(serialize_item) { _cleanup_free_ char *line1 = NULL, *line2 = NULL, *line3 = NULL, *line4 = NULL; assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0); - assert_se(streq(line1, "a=bbb")); + ASSERT_STREQ(line1, "a=bbb"); assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0); - assert_se(streq(line2, "a=bbb")); + ASSERT_STREQ(line2, "a=bbb"); assert_se(read_line(f, LONG_LINE_MAX, &line3) > 0); - assert_se(streq(line3, "c=yes")); + ASSERT_STREQ(line3, "c=yes"); assert_se(read_line(f, LONG_LINE_MAX, &line4) == 0); - assert_se(streq(line4, "")); + ASSERT_STREQ(line4, ""); } TEST(serialize_item_escaped) { @@ -59,11 +59,11 @@ TEST(serialize_item_escaped) { _cleanup_free_ char *line1 = NULL, *line2 = NULL, *line3 = NULL; assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0); - assert_se(streq(line1, "a=bbb")); + ASSERT_STREQ(line1, "a=bbb"); assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0); - assert_se(streq(line2, "a=bbb")); + ASSERT_STREQ(line2, "a=bbb"); assert_se(read_line(f, LONG_LINE_MAX, &line3) == 0); - assert_se(streq(line3, "")); + ASSERT_STREQ(line3, ""); } TEST(serialize_usec) { @@ -83,7 +83,7 @@ TEST(serialize_usec) { usec_t x; assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0); - assert_se(streq(line1, "usec2=0")); + ASSERT_STREQ(line1, "usec2=0"); assert_se(deserialize_usec(line1 + 6, &x) == 0); assert_se(x == 0); @@ -204,7 +204,7 @@ TEST(serialize_item_hexmem) { _cleanup_free_ char *line = NULL; assert_se(read_line(f, LONG_LINE_MAX, &line) > 0); - assert_se(streq(line, "a=ffffff")); + ASSERT_STREQ(line, "a=ffffff"); } @@ -222,7 +222,7 @@ TEST(serialize_item_base64mem) { _cleanup_free_ char *line = NULL; assert_se(read_line(f, LONG_LINE_MAX, &line) > 0); - assert_se(streq(line, "a=////")); + ASSERT_STREQ(line, "a=////"); } TEST(serialize_string_set) { diff --git a/src/test/test-set.c b/src/test/test-set.c index af5b5553e06..23bac0255a8 100644 --- a/src/test/test-set.c +++ b/src/test/test-set.c @@ -231,28 +231,28 @@ TEST(set_strjoin) { /* Single entry */ assert_se(set_put_strdup(&m, "aaa") == 1); assert_se(set_strjoin(m, NULL, false, &joined) >= 0); - assert_se(streq(joined, "aaa")); + ASSERT_STREQ(joined, "aaa"); joined = mfree(joined); assert_se(set_strjoin(m, "", false, &joined) >= 0); - assert_se(streq(joined, "aaa")); + ASSERT_STREQ(joined, "aaa"); joined = mfree(joined); assert_se(set_strjoin(m, " ", false, &joined) >= 0); - assert_se(streq(joined, "aaa")); + ASSERT_STREQ(joined, "aaa"); joined = mfree(joined); assert_se(set_strjoin(m, "xxx", false, &joined) >= 0); - assert_se(streq(joined, "aaa")); + ASSERT_STREQ(joined, "aaa"); joined = mfree(joined); assert_se(set_strjoin(m, NULL, true, &joined) >= 0); - assert_se(streq(joined, "aaa")); + ASSERT_STREQ(joined, "aaa"); joined = mfree(joined); assert_se(set_strjoin(m, "", true, &joined) >= 0); - assert_se(streq(joined, "aaa")); + ASSERT_STREQ(joined, "aaa"); joined = mfree(joined); assert_se(set_strjoin(m, " ", true, &joined) >= 0); - assert_se(streq(joined, " aaa ")); + ASSERT_STREQ(joined, " aaa "); joined = mfree(joined); assert_se(set_strjoin(m, "xxx", true, &joined) >= 0); - assert_se(streq(joined, "xxxaaaxxx")); + ASSERT_STREQ(joined, "xxxaaaxxx"); /* Two entries */ assert_se(set_put_strdup(&m, "bbb") == 1); diff --git a/src/test/test-sha256.c b/src/test/test-sha256.c index f168e4c355b..1acc893c744 100644 --- a/src/test/test-sha256.c +++ b/src/test/test-sha256.c @@ -31,7 +31,7 @@ static void test_sha256_one(const char *key, const char *expect) { sha256_finish_ctx(&ctx, result + j); hex_result = hexmem(result + j, SHA256_DIGEST_SIZE); - assert_se(streq_ptr(hex_result, expect)); + ASSERT_STREQ(hex_result, expect); } } } diff --git a/src/test/test-socket-netlink.c b/src/test/test-socket-netlink.c index 1cbfe6d66bd..1849585cc82 100644 --- a/src/test/test-socket-netlink.c +++ b/src/test/test-socket-netlink.c @@ -29,7 +29,7 @@ static void test_socket_address_parse_one(const char *in, int ret, int family, c assert_se(r == ret); if (r >= 0) { assert_se(a.sockaddr.sa.sa_family == family); - assert_se(streq(out, expected ?: in)); + ASSERT_STREQ(out, expected ?: in); } } @@ -199,7 +199,7 @@ TEST(socket_address_get_path) { assert_se(!socket_address_get_path(&a)); assert_se(socket_address_parse(&a, "/foo/bar") >= 0); - assert_se(streq(socket_address_get_path(&a), "/foo/bar")); + ASSERT_STREQ(socket_address_get_path(&a), "/foo/bar"); assert_se(socket_address_parse(&a, "vsock:2:1234") >= 0); assert_se(!socket_address_get_path(&a)); @@ -235,7 +235,7 @@ static void test_in_addr_ifindex_to_string_one(int f, const char *a, int ifindex assert_se(in_addr_from_string(f, a, &ua) >= 0); assert_se(in_addr_ifindex_to_string(f, &ua, ifindex, &r) >= 0); printf("test_in_addr_ifindex_to_string_one: %s == %s\n", b, r); - assert_se(streq(b, r)); + ASSERT_STREQ(b, r); assert_se(in_addr_ifindex_from_string_auto(b, &ff, &uuaa, &ifindex2) >= 0); assert_se(ff == f); @@ -282,7 +282,7 @@ static void test_in_addr_ifindex_name_from_string_auto_one(const char *a, const _cleanup_free_ char *server_name = NULL; assert_se(in_addr_ifindex_name_from_string_auto(a, &family, &ua, &ifindex, &server_name) >= 0); - assert_se(streq_ptr(server_name, expected)); + ASSERT_STREQ(server_name, expected); } TEST(in_addr_ifindex_name_from_string_auto) { @@ -307,9 +307,9 @@ static void test_in_addr_port_ifindex_name_from_string_auto_one(const char *str, assert_se(family == f); assert_se(port == p); assert_se(ifindex == i); - assert_se(streq_ptr(server_name, name)); + ASSERT_STREQ(server_name, name); assert_se(in_addr_port_ifindex_name_to_string(f, &a, p, i, name, &x) >= 0); - assert_se(streq(str_repr ?: str, x)); + ASSERT_STREQ(str_repr ?: str, x); } if (port > 0) @@ -319,9 +319,9 @@ static void test_in_addr_port_ifindex_name_from_string_auto_one(const char *str, assert_se(in_addr_port_ifindex_name_from_string_auto(str, &f, &a, NULL, &i, &name) == 0); assert_se(family == f); assert_se(ifindex == i); - assert_se(streq_ptr(server_name, name)); + ASSERT_STREQ(server_name, name); assert_se(in_addr_port_ifindex_name_to_string(f, &a, 0, i, name, &x) >= 0); - assert_se(streq(str_repr ?: str, x)); + ASSERT_STREQ(str_repr ?: str, x); } if (ifindex > 0) @@ -331,9 +331,9 @@ static void test_in_addr_port_ifindex_name_from_string_auto_one(const char *str, assert_se(in_addr_port_ifindex_name_from_string_auto(str, &f, &a, &p, NULL, &name) == 0); assert_se(family == f); assert_se(port == p); - assert_se(streq_ptr(server_name, name)); + ASSERT_STREQ(server_name, name); assert_se(in_addr_port_ifindex_name_to_string(f, &a, p, 0, name, &x) >= 0); - assert_se(streq(str_repr ?: str, x)); + ASSERT_STREQ(str_repr ?: str, x); } if (server_name) @@ -345,7 +345,7 @@ static void test_in_addr_port_ifindex_name_from_string_auto_one(const char *str, assert_se(port == p); assert_se(ifindex == i); assert_se(in_addr_port_ifindex_name_to_string(f, &a, p, i, NULL, &x) >= 0); - assert_se(streq(str_repr ?: str, x)); + ASSERT_STREQ(str_repr ?: str, x); } } diff --git a/src/test/test-socket-util.c b/src/test/test-socket-util.c index 4233ca65279..2368634c0e0 100644 --- a/src/test/test-socket-util.c +++ b/src/test/test-socket-util.c @@ -69,7 +69,7 @@ static void test_socket_print_unix_one(const char *in, size_t len_in, const char assert_se(socket_address_print(&a, &out) >= 0); assert_se(c = cescape(in)); log_info("\"%s\" → \"%s\" (expect \"%s\")", in, out, expected); - assert_se(streq(out, expected)); + ASSERT_STREQ(out, expected); } TEST(socket_print_unix) { @@ -256,7 +256,7 @@ TEST(passfd_read) { r = read(fd, buf, sizeof(buf)-1); assert_se(r >= 0); buf[r] = 0; - assert_se(streq(buf, file_contents)); + ASSERT_STREQ(buf, file_contents); } TEST(passfd_contents_read) { @@ -298,13 +298,13 @@ TEST(passfd_contents_read) { k = receive_one_fd_iov(pair[0], &iov, 1, MSG_DONTWAIT, &fd); assert_se(k > 0); buf[k] = 0; - assert_se(streq(buf, wire_contents)); + ASSERT_STREQ(buf, wire_contents); assert_se(fd >= 0); r = read(fd, buf, sizeof(buf)-1); assert_se(r >= 0); buf[r] = 0; - assert_se(streq(buf, file_contents)); + ASSERT_STREQ(buf, file_contents); } TEST(pass_many_fds_contents_read) { @@ -358,7 +358,7 @@ TEST(pass_many_fds_contents_read) { k = receive_many_fds_iov(pair[0], &iov, 1, &fds, &n_fds, MSG_DONTWAIT); assert_se(k > 0); buf[k] = 0; - assert_se(streq(buf, wire_contents)); + ASSERT_STREQ(buf, wire_contents); assert_se(n_fds == 3); @@ -367,7 +367,7 @@ TEST(pass_many_fds_contents_read) { r = read(fds[i], buf, sizeof(buf)-1); assert_se(r >= 0); buf[r] = 0; - assert_se(streq(buf, file_contents[i])); + ASSERT_STREQ(buf, file_contents[i]); safe_close(fds[i]); } } @@ -403,7 +403,7 @@ TEST(receive_nopassfd) { k = receive_one_fd_iov(pair[0], &iov, 1, MSG_DONTWAIT, &fd); assert_se(k > 0); buf[k] = 0; - assert_se(streq(buf, wire_contents)); + ASSERT_STREQ(buf, wire_contents); /* no fd passed here, confirm it was reset */ assert_se(fd == -EBADF); diff --git a/src/test/test-specifier.c b/src/test/test-specifier.c index e50d4504360..7d25969bb07 100644 --- a/src/test/test-specifier.c +++ b/src/test/test-specifier.c @@ -16,7 +16,7 @@ static void test_specifier_escape_one(const char *a, const char *b) { _cleanup_free_ char *x = NULL; x = specifier_escape(a); - assert_se(streq_ptr(x, b)); + ASSERT_STREQ(x, b); } TEST(specifier_escape) { @@ -73,7 +73,7 @@ TEST(specifier_printf) { assert_se(w); puts(w); - assert_se(streq(w, "xxx a=AAAA b=BBBB e= yyy")); + ASSERT_STREQ(w, "xxx a=AAAA b=BBBB e= yyy"); free(w); r = specifier_printf("boot=%b, host=%H, pretty=%q, version=%v, arch=%a, empty=%e", SIZE_MAX, table, NULL, NULL, &w); @@ -107,7 +107,7 @@ TEST(specifier_real_path) { /* /dev/initctl should normally be a symlink to /run/initctl */ if (inode_same("/dev/initctl", "/run/initctl", 0) > 0) - assert_se(streq(w, "p=/dev/initctl y=/run/initctl Y=/run w=/dev/tty W=/dev")); + ASSERT_STREQ(w, "p=/dev/initctl y=/run/initctl Y=/run w=/dev/tty W=/dev"); } TEST(specifier_real_path_missing_file) { @@ -178,11 +178,11 @@ TEST(specifiers_missing_data_ok) { assert_se(setenv("SYSTEMD_OS_RELEASE", "/dev/null", 1) == 0); assert_se(specifier_printf("%A-%B-%M-%o-%w-%W", SIZE_MAX, specifier_table, NULL, NULL, &resolved) >= 0); - assert_se(streq(resolved, "-----")); + ASSERT_STREQ(resolved, "-----"); assert_se(setenv("SYSTEMD_OS_RELEASE", "/nosuchfileordirectory", 1) == 0); assert_se(specifier_printf("%A-%B-%M-%o-%w-%W", SIZE_MAX, specifier_table, NULL, NULL, &resolved) == -EUNATCH); - assert_se(streq(resolved, "-----")); + ASSERT_STREQ(resolved, "-----"); assert_se(unsetenv("SYSTEMD_OS_RELEASE") == 0); } diff --git a/src/test/test-strbuf.c b/src/test/test-strbuf.c index 7198c673468..c0a4d1167ed 100644 --- a/src/test/test-strbuf.c +++ b/src/test/test-strbuf.c @@ -32,11 +32,11 @@ TEST(strbuf) { l = strv_parse_nulstr(sb->buf, sb->len); assert_se(l); - assert_se(streq(l[0], "")); /* root */ - assert_se(streq(l[1], "waldo")); - assert_se(streq(l[2], "foo")); - assert_se(streq(l[3], "bar")); - assert_se(streq(l[4], "waldorf")); + ASSERT_STREQ(l[0], ""); /* root */ + ASSERT_STREQ(l[1], "waldo"); + ASSERT_STREQ(l[2], "foo"); + ASSERT_STREQ(l[3], "bar"); + ASSERT_STREQ(l[4], "waldorf"); ASSERT_NULL(l[5]); assert_se(sb->nodes_count == 5); /* root + 4 non-duplicates */ @@ -57,14 +57,14 @@ TEST(strbuf) { assert_se(g == 15); assert_se(h == 0); - assert_se(streq(sb->buf + a, "waldo")); - assert_se(streq(sb->buf + b, "foo")); - assert_se(streq(sb->buf + c, "bar")); - assert_se(streq(sb->buf + d, "waldo")); - assert_se(streq(sb->buf + e, "aldo")); - assert_se(streq(sb->buf + f, "do")); - assert_se(streq(sb->buf + g, "waldorf")); - assert_se(streq(sb->buf + h, "")); + ASSERT_STREQ(sb->buf + a, "waldo"); + ASSERT_STREQ(sb->buf + b, "foo"); + ASSERT_STREQ(sb->buf + c, "bar"); + ASSERT_STREQ(sb->buf + d, "waldo"); + ASSERT_STREQ(sb->buf + e, "aldo"); + ASSERT_STREQ(sb->buf + f, "do"); + ASSERT_STREQ(sb->buf + g, "waldorf"); + ASSERT_STREQ(sb->buf + h, ""); strbuf_complete(sb); ASSERT_NULL(sb->root); diff --git a/src/test/test-string-util.c b/src/test/test-string-util.c index a84125d7228..4bf7548ac15 100644 --- a/src/test/test-string-util.c +++ b/src/test/test-string-util.c @@ -13,13 +13,13 @@ TEST(string_erase) { char *x; x = strdupa_safe(""); - assert_se(streq(string_erase(x), "")); + ASSERT_STREQ(string_erase(x), ""); x = strdupa_safe("1"); - assert_se(streq(string_erase(x), "")); + ASSERT_STREQ(string_erase(x), ""); x = strdupa_safe("123456789"); - assert_se(streq(string_erase(x), "")); + ASSERT_STREQ(string_erase(x), ""); assert_se(x[1] == '\0'); assert_se(x[2] == '\0'); @@ -37,7 +37,7 @@ static void test_free_and_strndup_one(char **t, const char *src, size_t l, const __func__, strnull(*t), strnull(src), l, strnull(expected), yes_no(change)); int r = free_and_strndup(t, src, l); - assert_se(streq_ptr(*t, expected)); + ASSERT_STREQ(*t, expected); assert_se(r == change); /* check that change occurs only when necessary */ } @@ -96,12 +96,12 @@ TEST(strdup_to_full) { assert_se(strdup_to_full(NULL, "") == 1); assert_se(strdup_to_full(&dst, "") == 1); - assert_se(streq_ptr(dst, "")); + ASSERT_STREQ(dst, ""); dst = mfree(dst); assert_se(strdup_to_full(NULL, "x") == 1); assert_se(strdup_to_full(&dst, "x") == 1); - assert_se(streq_ptr(dst, "x")); + ASSERT_STREQ(dst, "x"); } TEST(strdup_to) { @@ -110,11 +110,11 @@ TEST(strdup_to) { assert_se(strdup_to(&dst, NULL) == 0); assert_se(strdup_to(&dst, "") == 0); - assert_se(streq_ptr(dst, "")); + ASSERT_STREQ(dst, ""); dst = mfree(dst); assert_se(strdup_to(&dst, "x") == 0); - assert_se(streq_ptr(dst, "x")); + ASSERT_STREQ(dst, "x"); } TEST(ascii_strcasecmp_n) { @@ -163,82 +163,82 @@ TEST(ascii_strcasecmp_nn) { TEST(cellescape) { char buf[40]; - assert_se(streq(cellescape(buf, 1, ""), "")); - assert_se(streq(cellescape(buf, 1, "1"), "")); - assert_se(streq(cellescape(buf, 1, "12"), "")); - - assert_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) { @@ -250,41 +250,41 @@ TEST(strstrip) { char *ret, input[] = " hello, waldo. "; ret = strstrip(input); - assert_se(streq(ret, "hello, waldo.")); + ASSERT_STREQ(ret, "hello, waldo."); } TEST(strextend) { _cleanup_free_ char *str = NULL; assert_se(strextend(&str, NULL)); - assert_se(streq_ptr(str, "")); + ASSERT_STREQ(str, ""); assert_se(strextend(&str, "", "0", "", "", "123")); - assert_se(streq_ptr(str, "0123")); + ASSERT_STREQ(str, "0123"); assert_se(strextend(&str, "456", "78", "9")); - assert_se(streq_ptr(str, "0123456789")); + ASSERT_STREQ(str, "0123456789"); } TEST(strextend_with_separator) { _cleanup_free_ char *str = NULL; assert_se(strextend_with_separator(&str, NULL, NULL)); - assert_se(streq_ptr(str, "")); + ASSERT_STREQ(str, ""); str = mfree(str); assert_se(strextend_with_separator(&str, "...", NULL)); - assert_se(streq_ptr(str, "")); + ASSERT_STREQ(str, ""); assert_se(strextend_with_separator(&str, "...", NULL)); - assert_se(streq_ptr(str, "")); + ASSERT_STREQ(str, ""); str = mfree(str); assert_se(strextend_with_separator(&str, "xyz", "a", "bb", "ccc")); - assert_se(streq_ptr(str, "axyzbbxyzccc")); + ASSERT_STREQ(str, "axyzbbxyzccc"); str = mfree(str); assert_se(strextend_with_separator(&str, ",", "start", "", "1", "234")); - assert_se(streq_ptr(str, "start,,1,234")); + ASSERT_STREQ(str, "start,,1,234"); assert_se(strextend_with_separator(&str, ";", "more", "5", "678")); - assert_se(streq_ptr(str, "start,,1,234;more;5;678")); + ASSERT_STREQ(str, "start,,1,234;more;5;678"); } TEST(strrep) { @@ -295,15 +295,15 @@ TEST(strrep) { three = strrep("waldo", 3); zero = strrep("waldo", 0); - assert_se(streq(one, "waldo")); - assert_se(streq(three, "waldowaldowaldo")); - assert_se(streq(zero, "")); + ASSERT_STREQ(one, "waldo"); + ASSERT_STREQ(three, "waldowaldowaldo"); + ASSERT_STREQ(zero, ""); onea = strrepa("waldo", 1); threea = strrepa("waldo", 3); - assert_se(streq(onea, "waldo")); - assert_se(streq(threea, "waldowaldowaldo")); + ASSERT_STREQ(onea, "waldo"); + ASSERT_STREQ(threea, "waldowaldowaldo"); } TEST(string_has_cc) { @@ -322,7 +322,7 @@ TEST(string_has_cc) { TEST(ascii_strlower) { char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK"; - assert_se(streq(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk")); + ASSERT_STREQ(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk"); } TEST(strshorten) { @@ -343,62 +343,62 @@ TEST(strjoina) { char *actual; actual = strjoina("", "foo", "bar"); - assert_se(streq(actual, "foobar")); + ASSERT_STREQ(actual, "foobar"); actual = strjoina("foo", "bar", "baz"); - assert_se(streq(actual, "foobarbaz")); + ASSERT_STREQ(actual, "foobarbaz"); actual = strjoina("foo", "", "bar", "baz"); - assert_se(streq(actual, "foobarbaz")); + ASSERT_STREQ(actual, "foobarbaz"); actual = strjoina("foo"); - assert_se(streq(actual, "foo")); + ASSERT_STREQ(actual, "foo"); actual = strjoina(NULL); - assert_se(streq(actual, "")); + ASSERT_STREQ(actual, ""); actual = strjoina(NULL, "foo"); - assert_se(streq(actual, "")); + ASSERT_STREQ(actual, ""); actual = strjoina("foo", NULL, "bar"); - assert_se(streq(actual, "foo")); + ASSERT_STREQ(actual, "foo"); actual = strjoina("/sys/fs/cgroup/", "dn", "/a/b/c", "/cgroup.procs"); - assert_se(streq(actual, "/sys/fs/cgroup/dn/a/b/c/cgroup.procs")); + ASSERT_STREQ(actual, "/sys/fs/cgroup/dn/a/b/c/cgroup.procs"); actual = strjoina("/sys/fs/cgroup/", "dn", NULL, NULL); - assert_se(streq(actual, "/sys/fs/cgroup/dn")); + ASSERT_STREQ(actual, "/sys/fs/cgroup/dn"); } TEST(strjoin) { char *actual; actual = strjoin("", "foo", "bar"); - assert_se(streq(actual, "foobar")); + ASSERT_STREQ(actual, "foobar"); free(actual); actual = strjoin("foo", "bar", "baz"); - assert_se(streq(actual, "foobarbaz")); + ASSERT_STREQ(actual, "foobarbaz"); free(actual); actual = strjoin("foo", "", "bar", "baz"); - assert_se(streq(actual, "foobarbaz")); + ASSERT_STREQ(actual, "foobarbaz"); free(actual); actual = strjoin("foo", NULL); - assert_se(streq(actual, "foo")); + ASSERT_STREQ(actual, "foo"); free(actual); actual = strjoin(NULL, NULL); - assert_se(streq(actual, "")); + ASSERT_STREQ(actual, ""); free(actual); actual = strjoin(NULL, "foo"); - assert_se(streq(actual, "")); + ASSERT_STREQ(actual, ""); free(actual); actual = strjoin("foo", NULL, "bar"); - assert_se(streq(actual, "foo")); + ASSERT_STREQ(actual, "foo"); free(actual); } @@ -436,7 +436,7 @@ TEST(foreach_word) { } assert_se(r > 0); - assert_se(streq(expected[i++], word)); + ASSERT_STREQ(expected[i++], word); } } @@ -457,7 +457,7 @@ static void check(const char *test, char** expected, bool trailing) { break; } - assert_se(streq(word, expected[i++])); + ASSERT_STREQ(word, expected[i++]); printf("<%s>\n", word); } ASSERT_NULL(expected[i]); @@ -512,7 +512,7 @@ TEST(delete_chars) { char *s, input[] = " hello, waldo. abc"; s = delete_chars(input, WHITESPACE); - assert_se(streq(s, "hello,waldo.abc")); + ASSERT_STREQ(s, "hello,waldo.abc"); assert_se(s == input); } @@ -523,19 +523,19 @@ TEST(delete_trailing_chars) { input3[] = "abcdef"; s = delete_trailing_chars(input1, WHITESPACE); - assert_se(streq(s, " \n \r k")); + ASSERT_STREQ(s, " \n \r k"); assert_se(s == input1); s = delete_trailing_chars(input2, "kt"); - assert_se(streq(s, "kkkkthiskkkiskkkaktes")); + ASSERT_STREQ(s, "kkkkthiskkkiskkkaktes"); assert_se(s == input2); s = delete_trailing_chars(input3, WHITESPACE); - assert_se(streq(s, "abcdef")); + ASSERT_STREQ(s, "abcdef"); assert_se(s == input3); s = delete_trailing_chars(input3, "fe"); - assert_se(streq(s, "abcd")); + ASSERT_STREQ(s, "abcd"); assert_se(s == input3); } @@ -545,11 +545,11 @@ TEST(delete_trailing_slashes) { s3[] = "foobar", s4[] = ""; - assert_se(streq(delete_trailing_chars(s1, "_"), "foobar//")); - assert_se(streq(delete_trailing_chars(s1, "/"), "foobar")); - assert_se(streq(delete_trailing_chars(s2, "/"), "foobar")); - assert_se(streq(delete_trailing_chars(s3, "/"), "foobar")); - assert_se(streq(delete_trailing_chars(s4, "/"), "")); + ASSERT_STREQ(delete_trailing_chars(s1, "_"), "foobar//"); + ASSERT_STREQ(delete_trailing_chars(s1, "/"), "foobar"); + ASSERT_STREQ(delete_trailing_chars(s2, "/"), "foobar"); + ASSERT_STREQ(delete_trailing_chars(s3, "/"), "foobar"); + ASSERT_STREQ(delete_trailing_chars(s4, "/"), ""); } TEST(skip_leading_chars) { @@ -557,11 +557,11 @@ TEST(skip_leading_chars) { input2[] = "kkkkthiskkkiskkkaktestkkk", input3[] = "abcdef"; - assert_se(streq(skip_leading_chars(input1, WHITESPACE), "k \n \r ")); - assert_se(streq(skip_leading_chars(input2, "k"), "thiskkkiskkkaktestkkk")); - assert_se(streq(skip_leading_chars(input2, "tk"), "hiskkkiskkkaktestkkk")); - assert_se(streq(skip_leading_chars(input3, WHITESPACE), "abcdef")); - assert_se(streq(skip_leading_chars(input3, "bcaef"), "def")); + ASSERT_STREQ(skip_leading_chars(input1, WHITESPACE), "k \n \r "); + ASSERT_STREQ(skip_leading_chars(input2, "k"), "thiskkkiskkkaktestkkk"); + ASSERT_STREQ(skip_leading_chars(input2, "tk"), "hiskkkiskkkaktestkkk"); + ASSERT_STREQ(skip_leading_chars(input3, WHITESPACE), "abcdef"); + ASSERT_STREQ(skip_leading_chars(input3, "bcaef"), "def"); } TEST(in_charset) { @@ -576,19 +576,19 @@ TEST(split_pair) { assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL); assert_se(split_pair("", "=", &a, &b) == -EINVAL); assert_se(split_pair("foo=bar", "=", &a, &b) >= 0); - assert_se(streq(a, "foo")); - assert_se(streq(b, "bar")); + ASSERT_STREQ(a, "foo"); + ASSERT_STREQ(b, "bar"); free(a); free(b); assert_se(split_pair("==", "==", &a, &b) >= 0); - assert_se(streq(a, "")); - assert_se(streq(b, "")); + ASSERT_STREQ(a, ""); + ASSERT_STREQ(b, ""); free(a); free(b); assert_se(split_pair("===", "==", &a, &b) >= 0); - assert_se(streq(a, "")); - assert_se(streq(b, "=")); + ASSERT_STREQ(a, ""); + ASSERT_STREQ(b, "="); } TEST(first_word) { @@ -612,33 +612,33 @@ TEST(strlen_ptr) { } TEST(memory_startswith) { - assert_se(streq(memory_startswith("", 0, ""), "")); - assert_se(streq(memory_startswith("", 1, ""), "")); - assert_se(streq(memory_startswith("x", 2, ""), "x")); + ASSERT_STREQ(memory_startswith("", 0, ""), ""); + ASSERT_STREQ(memory_startswith("", 1, ""), ""); + ASSERT_STREQ(memory_startswith("x", 2, ""), "x"); assert_se(!memory_startswith("", 1, "x")); assert_se(!memory_startswith("", 1, "xxxxxxxx")); - assert_se(streq(memory_startswith("xxx", 4, "x"), "xx")); - assert_se(streq(memory_startswith("xxx", 4, "xx"), "x")); - assert_se(streq(memory_startswith("xxx", 4, "xxx"), "")); + ASSERT_STREQ(memory_startswith("xxx", 4, "x"), "xx"); + ASSERT_STREQ(memory_startswith("xxx", 4, "xx"), "x"); + ASSERT_STREQ(memory_startswith("xxx", 4, "xxx"), ""); assert_se(!memory_startswith("xxx", 4, "xxxx")); } TEST(memory_startswith_no_case) { - assert_se(streq(memory_startswith_no_case("", 0, ""), "")); - assert_se(streq(memory_startswith_no_case("", 1, ""), "")); - assert_se(streq(memory_startswith_no_case("x", 2, ""), "x")); - assert_se(streq(memory_startswith_no_case("X", 2, ""), "X")); + ASSERT_STREQ(memory_startswith_no_case("", 0, ""), ""); + ASSERT_STREQ(memory_startswith_no_case("", 1, ""), ""); + ASSERT_STREQ(memory_startswith_no_case("x", 2, ""), "x"); + ASSERT_STREQ(memory_startswith_no_case("X", 2, ""), "X"); assert_se(!memory_startswith_no_case("", 1, "X")); assert_se(!memory_startswith_no_case("", 1, "xxxxXXXX")); - assert_se(streq(memory_startswith_no_case("xxx", 4, "X"), "xx")); - assert_se(streq(memory_startswith_no_case("XXX", 4, "x"), "XX")); - assert_se(streq(memory_startswith_no_case("XXX", 4, "X"), "XX")); - assert_se(streq(memory_startswith_no_case("xxx", 4, "XX"), "x")); - assert_se(streq(memory_startswith_no_case("XXX", 4, "xx"), "X")); - assert_se(streq(memory_startswith_no_case("XXX", 4, "XX"), "X")); - assert_se(streq(memory_startswith_no_case("xxx", 4, "XXX"), "")); - assert_se(streq(memory_startswith_no_case("XXX", 4, "xxx"), "")); - assert_se(streq(memory_startswith_no_case("XXX", 4, "XXX"), "")); + ASSERT_STREQ(memory_startswith_no_case("xxx", 4, "X"), "xx"); + ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "x"), "XX"); + ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "X"), "XX"); + ASSERT_STREQ(memory_startswith_no_case("xxx", 4, "XX"), "x"); + ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "xx"), "X"); + ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "XX"), "X"); + ASSERT_STREQ(memory_startswith_no_case("xxx", 4, "XXX"), ""); + ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "xxx"), ""); + ASSERT_STREQ(memory_startswith_no_case("XXX", 4, "XXX"), ""); assert_se(memory_startswith_no_case((char[2]){'x', 'x'}, 2, "xx")); assert_se(memory_startswith_no_case((char[2]){'x', 'X'}, 2, "xX")); @@ -651,7 +651,7 @@ static void test_string_truncate_lines_one(const char *input, size_t n_lines, co int k; assert_se((k = string_truncate_lines(input, n_lines, &b)) >= 0); - assert_se(streq(b, output)); + ASSERT_STREQ(b, output); assert_se(!!k == truncation); } @@ -722,7 +722,7 @@ static void test_string_extract_lines_one(const char *input, size_t i, const cha int k; assert_se((k = string_extract_line(input, i, &b)) >= 0); - assert_se(streq(b ?: input, output)); + ASSERT_STREQ(b ?: input, output); assert_se(!!k == more); } @@ -799,25 +799,25 @@ TEST(string_contains_word_strv) { assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("a", "b"), NULL)); assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("a", "b"), &w)); - assert_se(streq(w, "a")); + ASSERT_STREQ(w, "a"); assert_se(!string_contains_word_strv("a b cc", NULL, STRV_MAKE("d"), &w)); ASSERT_NULL(w); assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("b", "a"), &w)); - assert_se(streq(w, "a")); + ASSERT_STREQ(w, "a"); assert_se(string_contains_word_strv("b a b cc", NULL, STRV_MAKE("b", "a", "b"), &w)); - assert_se(streq(w, "b")); + ASSERT_STREQ(w, "b"); assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("b", ""), &w)); - assert_se(streq(w, "b")); + ASSERT_STREQ(w, "b"); assert_se(!string_contains_word_strv("a b cc", NULL, STRV_MAKE(""), &w)); ASSERT_NULL(w); assert_se(string_contains_word_strv("a b cc", " ", STRV_MAKE(""), &w)); - assert_se(streq(w, "")); + ASSERT_STREQ(w, ""); } TEST(string_contains_word) { @@ -1139,38 +1139,38 @@ TEST(strextendf) { _cleanup_free_ char *p = NULL; assert_se(strextendf(&p, "<%i>", 77) >= 0); - assert_se(streq(p, "<77>")); + ASSERT_STREQ(p, "<77>"); assert_se(strextendf(&p, "<%i>", 99) >= 0); - assert_se(streq(p, "<77><99>")); + ASSERT_STREQ(p, "<77><99>"); assert_se(strextendf(&p, "<%80i>", 88) >= 0); - assert_se(streq(p, "<77><99>< 88>")); + ASSERT_STREQ(p, "<77><99>< 88>"); assert_se(strextendf(&p, "<%08x>", 0x1234u) >= 0); - assert_se(streq(p, "<77><99>< 88><00001234>")); + ASSERT_STREQ(p, "<77><99>< 88><00001234>"); p = mfree(p); assert_se(strextendf_with_separator(&p, ",", "<%i>", 77) >= 0); - assert_se(streq(p, "<77>")); + ASSERT_STREQ(p, "<77>"); assert_se(strextendf_with_separator(&p, ",", "<%i>", 99) >= 0); - assert_se(streq(p, "<77>,<99>")); + ASSERT_STREQ(p, "<77>,<99>"); assert_se(strextendf_with_separator(&p, ",", "<%80i>", 88) >= 0); - assert_se(streq(p, "<77>,<99>,< 88>")); + ASSERT_STREQ(p, "<77>,<99>,< 88>"); assert_se(strextendf_with_separator(&p, ",", "<%08x>", 0x1234u) >= 0); - assert_se(streq(p, "<77>,<99>,< 88>,<00001234>")); + ASSERT_STREQ(p, "<77>,<99>,< 88>,<00001234>"); } TEST(string_replace_char) { - assert_se(streq(string_replace_char(strdupa_safe(""), 'a', 'b'), "")); - assert_se(streq(string_replace_char(strdupa_safe("abc"), 'a', 'b'), "bbc")); - assert_se(streq(string_replace_char(strdupa_safe("hoge"), 'a', 'b'), "hoge")); - assert_se(streq(string_replace_char(strdupa_safe("aaaa"), 'a', 'b'), "bbbb")); - assert_se(streq(string_replace_char(strdupa_safe("aaaa"), 'a', '\t'), "\t\t\t\t")); + ASSERT_STREQ(string_replace_char(strdupa_safe(""), 'a', 'b'), ""); + ASSERT_STREQ(string_replace_char(strdupa_safe("abc"), 'a', 'b'), "bbc"); + ASSERT_STREQ(string_replace_char(strdupa_safe("hoge"), 'a', 'b'), "hoge"); + ASSERT_STREQ(string_replace_char(strdupa_safe("aaaa"), 'a', 'b'), "bbbb"); + ASSERT_STREQ(string_replace_char(strdupa_safe("aaaa"), 'a', '\t'), "\t\t\t\t"); } TEST(strspn_from_end) { @@ -1214,7 +1214,7 @@ TEST(streq_skip_trailing_chars) { do { \ _cleanup_free_ char *b = NULL; \ assert_se(make_cstring((x), ELEMENTSOF(x), (mode), &b) == (ret)); \ - assert_se(streq_ptr(b, (expect))); \ + ASSERT_STREQ(b, (expect)); \ } while(false) TEST(make_cstring) { @@ -1295,7 +1295,7 @@ TEST(strstrafter) { assert_se(!strstrafter(NULL, NULL)); assert_se(!strstrafter("", NULL)); assert_se(!strstrafter(NULL, "")); - assert_se(streq_ptr(strstrafter("", ""), "")); + ASSERT_STREQ(strstrafter("", ""), ""); assert_se(strstrafter(buffer, "a") == buffer + 1); assert_se(strstrafter(buffer, "") == buffer); @@ -1319,18 +1319,18 @@ TEST(version_is_valid) { TEST(strextendn) { _cleanup_free_ char *x = NULL; - assert_se(streq_ptr(strextendn(&x, NULL, 0), "")); + ASSERT_STREQ(strextendn(&x, NULL, 0), ""); x = mfree(x); - assert_se(streq_ptr(strextendn(&x, "", 0), "")); + ASSERT_STREQ(strextendn(&x, "", 0), ""); x = mfree(x); - assert_se(streq_ptr(strextendn(&x, "xxx", 3), "xxx")); - assert_se(streq_ptr(strextendn(&x, "xxx", 3), "xxxxxx")); - assert_se(streq_ptr(strextendn(&x, "...", 1), "xxxxxx.")); - assert_se(streq_ptr(strextendn(&x, "...", 2), "xxxxxx...")); - assert_se(streq_ptr(strextendn(&x, "...", 3), "xxxxxx......")); - assert_se(streq_ptr(strextendn(&x, "...", 4), "xxxxxx.........")); + ASSERT_STREQ(strextendn(&x, "xxx", 3), "xxx"); + ASSERT_STREQ(strextendn(&x, "xxx", 3), "xxxxxx"); + ASSERT_STREQ(strextendn(&x, "...", 1), "xxxxxx."); + ASSERT_STREQ(strextendn(&x, "...", 2), "xxxxxx..."); + ASSERT_STREQ(strextendn(&x, "...", 3), "xxxxxx......"); + ASSERT_STREQ(strextendn(&x, "...", 4), "xxxxxx........."); x = mfree(x); } diff --git a/src/test/test-strip-tab-ansi.c b/src/test/test-strip-tab-ansi.c index 6f73d2686de..3ad0fcd90e6 100644 --- a/src/test/test-strip-tab-ansi.c +++ b/src/test/test-strip-tab-ansi.c @@ -15,38 +15,38 @@ TEST(strip_tab_ansi) { assert_se(p = strdup("\tFoobar\tbar\twaldo\t")); assert_se(strip_tab_ansi(&p, NULL, NULL)); fprintf(stdout, "<%s>\n", p); - assert_se(streq(p, " Foobar bar waldo ")); + ASSERT_STREQ(p, " Foobar bar waldo "); free(p); assert_se(p = strdup(ANSI_HIGHLIGHT "Hello" ANSI_NORMAL ANSI_HIGHLIGHT_RED " world!" ANSI_NORMAL)); assert_se(strip_tab_ansi(&p, NULL, NULL)); fprintf(stdout, "<%s>\n", p); - assert_se(streq(p, "Hello world!")); + ASSERT_STREQ(p, "Hello world!"); free(p); assert_se(p = strdup("\x1B[\x1B[\t\x1B[" ANSI_HIGHLIGHT "\x1B[" "Hello" ANSI_NORMAL ANSI_HIGHLIGHT_RED " world!" ANSI_NORMAL)); assert_se(strip_tab_ansi(&p, NULL, NULL)); - assert_se(streq(p, "\x1B[\x1B[ \x1B[\x1B[Hello world!")); + ASSERT_STREQ(p, "\x1B[\x1B[ \x1B[\x1B[Hello world!"); free(p); assert_se(p = strdup("\x1B[waldo")); assert_se(strip_tab_ansi(&p, NULL, NULL)); - assert_se(streq(p, "\x1B[waldo")); + ASSERT_STREQ(p, "\x1B[waldo"); free(p); assert_se(p = strdup("\r\rwaldo")); assert_se(strip_tab_ansi(&p, NULL, NULL)); - assert_se(streq(p, "\r\rwaldo")); + ASSERT_STREQ(p, "\r\rwaldo"); free(p); assert_se(p = strdup("waldo\r\r")); assert_se(strip_tab_ansi(&p, NULL, NULL)); - assert_se(streq(p, "waldo")); + ASSERT_STREQ(p, "waldo"); free(p); assert_se(p = strdup("waldo\r\r\n\r\n")); assert_se(strip_tab_ansi(&p, NULL, NULL)); - assert_se(streq(p, "waldo\n\n")); + ASSERT_STREQ(p, "waldo\n\n"); free(p); assert_se(terminal_urlify_path("/etc/fstab", "i am a fabulous link", &urlified) >= 0); @@ -55,7 +55,7 @@ TEST(strip_tab_ansi) { printf("<%s>\n", p); assert_se(strip_tab_ansi(&p, NULL, NULL)); printf("<%s>\n", p); - assert_se(streq(p, "something i am a fabulous link something-else")); + ASSERT_STREQ(p, "something i am a fabulous link something-else"); p = mfree(p); /* Truncate the formatted string in the middle of an ANSI sequence (in which case we shouldn't touch the @@ -65,7 +65,7 @@ TEST(strip_tab_ansi) { *z = 0; assert_se(qq = strdup(q)); assert_se(strip_tab_ansi(&q, NULL, NULL)); - assert_se(streq(q, qq)); + ASSERT_STREQ(q, qq); } } diff --git a/src/test/test-strv.c b/src/test/test-strv.c index 63a88c23013..28b8b2270c0 100644 --- a/src/test/test-strv.c +++ b/src/test/test-strv.c @@ -34,9 +34,9 @@ TEST(startswith_set) { assert_se(STARTSWITH_SET("abc", "ax", "abx", "abc")); assert_se(!STARTSWITH_SET("abc", "ax", "abx", "abcx")); - assert_se(streq_ptr(STARTSWITH_SET("foobar", "hhh", "kkk", "foo", "zzz"), "bar")); - assert_se(streq_ptr(STARTSWITH_SET("foobar", "hhh", "kkk", "", "zzz"), "foobar")); - assert_se(streq_ptr(STARTSWITH_SET("", "hhh", "kkk", "zzz", ""), "")); + ASSERT_STREQ(STARTSWITH_SET("foobar", "hhh", "kkk", "foo", "zzz"), "bar"); + ASSERT_STREQ(STARTSWITH_SET("foobar", "hhh", "kkk", "", "zzz"), "foobar"); + ASSERT_STREQ(STARTSWITH_SET("", "hhh", "kkk", "zzz", ""), ""); } static const char* const input_table_multiple[] = { @@ -125,78 +125,78 @@ TEST(strv_find_startswith) { TEST(strv_join) { _cleanup_free_ char *p = strv_join((char **)input_table_multiple, ", "); assert_se(p); - assert_se(streq(p, "one, two, three")); + ASSERT_STREQ(p, "one, two, three"); _cleanup_free_ char *q = strv_join((char **)input_table_multiple, ";"); assert_se(q); - assert_se(streq(q, "one;two;three")); + ASSERT_STREQ(q, "one;two;three"); _cleanup_free_ char *r = strv_join((char **)input_table_multiple, NULL); assert_se(r); - assert_se(streq(r, "one two three")); + ASSERT_STREQ(r, "one two three"); _cleanup_free_ char *s = strv_join(STRV_MAKE("1", "2", "3,3"), ","); assert_se(s); - assert_se(streq(s, "1,2,3,3")); + ASSERT_STREQ(s, "1,2,3,3"); _cleanup_free_ char *t = strv_join((char **)input_table_one, ", "); assert_se(t); - assert_se(streq(t, "one")); + ASSERT_STREQ(t, "one"); _cleanup_free_ char *u = strv_join((char **)input_table_none, ", "); assert_se(u); - assert_se(streq(u, "")); + ASSERT_STREQ(u, ""); _cleanup_free_ char *v = strv_join((char **)input_table_two_empties, ", "); assert_se(v); - assert_se(streq(v, ", ")); + ASSERT_STREQ(v, ", "); _cleanup_free_ char *w = strv_join((char **)input_table_one_empty, ", "); assert_se(w); - assert_se(streq(w, "")); + ASSERT_STREQ(w, ""); } TEST(strv_join_full) { _cleanup_free_ char *p = strv_join_full((char **)input_table_multiple, ", ", "foo", false); assert_se(p); - assert_se(streq(p, "fooone, footwo, foothree")); + ASSERT_STREQ(p, "fooone, footwo, foothree"); _cleanup_free_ char *q = strv_join_full((char **)input_table_multiple, ";", "foo", false); assert_se(q); - assert_se(streq(q, "fooone;footwo;foothree")); + ASSERT_STREQ(q, "fooone;footwo;foothree"); _cleanup_free_ char *r = strv_join_full(STRV_MAKE("a", "a;b", "a:c"), ";", NULL, true); assert_se(r); - assert_se(streq(r, "a;a\\;b;a:c")); + ASSERT_STREQ(r, "a;a\\;b;a:c"); _cleanup_free_ char *s = strv_join_full(STRV_MAKE("a", "a;b", "a;;c", ";", ";x"), ";", NULL, true); assert_se(s); - assert_se(streq(s, "a;a\\;b;a\\;\\;c;\\;;\\;x")); + ASSERT_STREQ(s, "a;a\\;b;a\\;\\;c;\\;;\\;x"); _cleanup_free_ char *t = strv_join_full(STRV_MAKE("a", "a;b", "a:c", ";"), ";", "=", true); assert_se(t); - assert_se(streq(t, "=a;=a\\;b;=a:c;=\\;")); + ASSERT_STREQ(t, "=a;=a\\;b;=a:c;=\\;"); t = mfree(t); _cleanup_free_ char *u = strv_join_full((char **)input_table_multiple, NULL, "foo", false); assert_se(u); - assert_se(streq(u, "fooone footwo foothree")); + ASSERT_STREQ(u, "fooone footwo foothree"); _cleanup_free_ char *v = strv_join_full((char **)input_table_one, ", ", "foo", false); assert_se(v); - assert_se(streq(v, "fooone")); + ASSERT_STREQ(v, "fooone"); _cleanup_free_ char *w = strv_join_full((char **)input_table_none, ", ", "foo", false); assert_se(w); - assert_se(streq(w, "")); + ASSERT_STREQ(w, ""); _cleanup_free_ char *x = strv_join_full((char **)input_table_two_empties, ", ", "foo", false); assert_se(x); - assert_se(streq(x, "foo, foo")); + ASSERT_STREQ(x, "foo, foo"); _cleanup_free_ char *y = strv_join_full((char **)input_table_one_empty, ", ", "foo", false); assert_se(y); - assert_se(streq(y, "foo")); + ASSERT_STREQ(y, "foo"); } static void test_strv_unquote_one(const char *quoted, char **list) { @@ -215,7 +215,7 @@ static void test_strv_unquote_one(const char *quoted, char **list) { puts(j); STRV_FOREACH(t, s) - assert_se(streq(list[i++], *t)); + ASSERT_STREQ(list[i++], *t); ASSERT_NULL(list[i]); } @@ -402,12 +402,12 @@ TEST(strv_split_full) { r = strv_split_full(&l, str, ":", EXTRACT_DONT_COALESCE_SEPARATORS); assert_se(r == (int) strv_length(l)); - assert_se(streq_ptr(l[0], "")); - assert_se(streq_ptr(l[1], "foo:bar")); - assert_se(streq_ptr(l[2], "")); - assert_se(streq_ptr(l[3], "waldo")); - assert_se(streq_ptr(l[4], "")); - assert_se(streq_ptr(l[5], NULL)); + ASSERT_STREQ(l[0], ""); + ASSERT_STREQ(l[1], "foo:bar"); + ASSERT_STREQ(l[2], ""); + ASSERT_STREQ(l[3], "waldo"); + ASSERT_STREQ(l[4], ""); + ASSERT_STREQ(l[5], NULL); } TEST(strv_split_and_extend_full) { @@ -420,14 +420,14 @@ TEST(strv_split_and_extend_full) { assert_se(r == (int) strv_length(l)); r = strv_split_and_extend_full(&l, str1, ":", false, EXTRACT_DONT_COALESCE_SEPARATORS); assert_se(r == (int) strv_length(l)); - assert_se(streq_ptr(l[0], "")); - assert_se(streq_ptr(l[1], "foo:bar")); - assert_se(streq_ptr(l[2], "")); + ASSERT_STREQ(l[0], ""); + ASSERT_STREQ(l[1], "foo:bar"); + ASSERT_STREQ(l[2], ""); r = strv_split_and_extend_full(&l, str2, ":", false, 0); assert_se(r == (int) strv_length(l)); - assert_se(streq_ptr(l[3], "waldo")); - assert_se(streq_ptr(l[4], "baz")); - assert_se(streq_ptr(l[5], NULL)); + ASSERT_STREQ(l[3], "waldo"); + ASSERT_STREQ(l[4], "baz"); + ASSERT_STREQ(l[5], NULL); } TEST(strv_split_colon_pairs) { @@ -439,19 +439,19 @@ TEST(strv_split_colon_pairs) { r = strv_split_colon_pairs(&l, str); assert_se(r == (int) strv_length(l)); assert_se(r == 12); - assert_se(streq_ptr(l[0], "one")); - assert_se(streq_ptr(l[1], "two")); - assert_se(streq_ptr(l[2], "three")); - assert_se(streq_ptr(l[3], "")); - assert_se(streq_ptr(l[4], "four")); - assert_se(streq_ptr(l[5], "five")); - assert_se(streq_ptr(l[6], "six")); - assert_se(streq_ptr(l[7], "")); - assert_se(streq_ptr(l[8], "seven")); - assert_se(streq_ptr(l[9], "eight:nine")); - assert_se(streq_ptr(l[10], "ten:eleven\\")); - assert_se(streq_ptr(l[11], "")); - assert_se(streq_ptr(l[12], NULL)); + ASSERT_STREQ(l[0], "one"); + ASSERT_STREQ(l[1], "two"); + ASSERT_STREQ(l[2], "three"); + ASSERT_STREQ(l[3], ""); + ASSERT_STREQ(l[4], "four"); + ASSERT_STREQ(l[5], "five"); + ASSERT_STREQ(l[6], "six"); + ASSERT_STREQ(l[7], ""); + ASSERT_STREQ(l[8], "seven"); + ASSERT_STREQ(l[9], "eight:nine"); + ASSERT_STREQ(l[10], "ten:eleven\\"); + ASSERT_STREQ(l[11], ""); + ASSERT_STREQ(l[12], NULL); r = strv_split_colon_pairs(&l, str_inval); assert_se(r == -EINVAL); @@ -466,7 +466,7 @@ TEST(strv_split_newlines) { assert_se(l); STRV_FOREACH(s, l) - assert_se(streq(*s, input_table_multiple[i++])); + ASSERT_STREQ(*s, input_table_multiple[i++]); } TEST(strv_split_newlines_full) { @@ -520,11 +520,11 @@ TEST(strv_sort) { strv_sort((char **)input_table); - assert_se(streq(input_table[0], "CAPITAL LETTERS FIRST")); - assert_se(streq(input_table[1], "apple")); - assert_se(streq(input_table[2], "banana")); - assert_se(streq(input_table[3], "citrus")); - assert_se(streq(input_table[4], "durian")); + ASSERT_STREQ(input_table[0], "CAPITAL LETTERS FIRST"); + ASSERT_STREQ(input_table[1], "apple"); + ASSERT_STREQ(input_table[2], "banana"); + ASSERT_STREQ(input_table[3], "citrus"); + ASSERT_STREQ(input_table[4], "durian"); } TEST(strv_extend_strv_biconcat) { @@ -537,10 +537,10 @@ TEST(strv_extend_strv_biconcat) { assert_se(strv_extend_strv_biconcat(&a, "prefix_", (const char* const*) b, "_suffix") >= 0); - assert_se(streq(a[0], "without")); - assert_se(streq(a[1], "suffix")); - assert_se(streq(a[2], "prefix_with_suffix")); - assert_se(streq(a[3], "prefix_suffix_suffix")); + ASSERT_STREQ(a[0], "without"); + ASSERT_STREQ(a[1], "suffix"); + ASSERT_STREQ(a[2], "prefix_with_suffix"); + ASSERT_STREQ(a[3], "prefix_suffix_suffix"); } TEST(strv_extend_strv_concat) { @@ -553,10 +553,10 @@ TEST(strv_extend_strv_concat) { assert_se(strv_extend_strv_concat(&a, (const char* const*) b, "_suffix") >= 0); - assert_se(streq(a[0], "without")); - assert_se(streq(a[1], "suffix")); - assert_se(streq(a[2], "with_suffix")); - assert_se(streq(a[3], "suffix_suffix")); + ASSERT_STREQ(a[0], "without"); + ASSERT_STREQ(a[1], "suffix"); + ASSERT_STREQ(a[2], "with_suffix"); + ASSERT_STREQ(a[3], "suffix_suffix"); } TEST(strv_extend_strv) { @@ -569,19 +569,19 @@ TEST(strv_extend_strv) { assert_se(strv_extend_strv(&a, b, true) == 3); - assert_se(streq(a[0], "abc")); - assert_se(streq(a[1], "def")); - assert_se(streq(a[2], "ghi")); - assert_se(streq(a[3], "jkl")); - assert_se(streq(a[4], "mno")); - assert_se(streq(a[5], "pqr")); + ASSERT_STREQ(a[0], "abc"); + ASSERT_STREQ(a[1], "def"); + ASSERT_STREQ(a[2], "ghi"); + ASSERT_STREQ(a[3], "jkl"); + ASSERT_STREQ(a[4], "mno"); + ASSERT_STREQ(a[5], "pqr"); assert_se(strv_length(a) == 6); assert_se(strv_extend_strv(&n, b, false) >= 0); - assert_se(streq(n[0], "jkl")); - assert_se(streq(n[1], "mno")); - assert_se(streq(n[2], "abc")); - assert_se(streq(n[3], "pqr")); + ASSERT_STREQ(n[0], "jkl"); + ASSERT_STREQ(n[1], "mno"); + ASSERT_STREQ(n[2], "abc"); + ASSERT_STREQ(n[3], "pqr"); assert_se(strv_length(n) == 4); } @@ -597,10 +597,10 @@ TEST(strv_extend_with_size) { assert_se(strv_extend_with_size(&a, &n, "test3") >= 0); assert_se(n == 4); - assert_se(streq(a[0], "test")); - assert_se(streq(a[1], "test1")); - assert_se(streq(a[2], "test2")); - assert_se(streq(a[3], "test3")); + ASSERT_STREQ(a[0], "test"); + ASSERT_STREQ(a[1], "test1"); + ASSERT_STREQ(a[2], "test2"); + ASSERT_STREQ(a[3], "test3"); ASSERT_NULL(a[4]); } @@ -612,10 +612,10 @@ TEST(strv_extend) { assert_se(strv_extend(&a, "test2") >= 0); assert_se(strv_extend(&b, "test3") >= 0); - assert_se(streq(a[0], "test")); - assert_se(streq(a[1], "test1")); - assert_se(streq(a[2], "test2")); - assert_se(streq(b[0], "test3")); + ASSERT_STREQ(a[0], "test"); + ASSERT_STREQ(a[1], "test1"); + ASSERT_STREQ(a[2], "test2"); + ASSERT_STREQ(b[0], "test3"); } TEST(strv_extendf) { @@ -626,10 +626,10 @@ TEST(strv_extendf) { assert_se(strv_extendf(&a, "test2 %s %d %s", "foo", 128, "bar") >= 0); assert_se(strv_extendf(&b, "test3 %s %s %d", "bar", "foo", 128) >= 0); - assert_se(streq(a[0], "test")); - assert_se(streq(a[1], "test1")); - assert_se(streq(a[2], "test2 foo 128 bar")); - assert_se(streq(b[0], "test3 bar foo 128")); + ASSERT_STREQ(a[0], "test"); + ASSERT_STREQ(a[1], "test1"); + ASSERT_STREQ(a[2], "test2 foo 128 bar"); + ASSERT_STREQ(b[0], "test3 bar foo 128"); } TEST(strv_foreach) { @@ -640,7 +640,7 @@ TEST(strv_foreach) { assert_se(a); STRV_FOREACH(check, a) - assert_se(streq(*check, input_table_multiple[i++])); + ASSERT_STREQ(*check, input_table_multiple[i++]); } TEST(strv_foreach_backwards) { @@ -652,7 +652,7 @@ TEST(strv_foreach_backwards) { assert_se(a); STRV_FOREACH_BACKWARDS(check, a) - assert_se(streq_ptr(*check, input_table_multiple[i--])); + ASSERT_STREQ(*check, input_table_multiple[i--]); STRV_FOREACH_BACKWARDS(check, (char**) NULL) assert_not_reached(); @@ -673,7 +673,7 @@ TEST(strv_foreach_pair) { "pair_two", "pair_two", "pair_three", "pair_three"); STRV_FOREACH_PAIR(x, y, a) - assert_se(streq(*x, *y)); + ASSERT_STREQ(*x, *y); } static void test_strv_from_stdarg_alloca_one(char **l, const char *first, ...) { @@ -685,7 +685,7 @@ static void test_strv_from_stdarg_alloca_one(char **l, const char *first, ...) { j = strv_from_stdarg_alloca(first); for (i = 0;; i++) { - assert_se(streq_ptr(l[i], j[i])); + ASSERT_STREQ(l[i], j[i]); if (!l[i]) break; @@ -702,29 +702,29 @@ TEST(strv_insert) { _cleanup_strv_free_ char **a = NULL; assert_se(strv_insert(&a, 0, strdup("first")) == 0); - assert_se(streq(a[0], "first")); + ASSERT_STREQ(a[0], "first"); assert_se(!a[1]); assert_se(strv_insert(&a, 0, NULL) == 0); - assert_se(streq(a[0], "first")); + ASSERT_STREQ(a[0], "first"); assert_se(!a[1]); assert_se(strv_insert(&a, 1, strdup("two")) == 0); - assert_se(streq(a[0], "first")); - assert_se(streq(a[1], "two")); + ASSERT_STREQ(a[0], "first"); + ASSERT_STREQ(a[1], "two"); assert_se(!a[2]); assert_se(strv_insert(&a, 4, strdup("tri")) == 0); - assert_se(streq(a[0], "first")); - assert_se(streq(a[1], "two")); - assert_se(streq(a[2], "tri")); + ASSERT_STREQ(a[0], "first"); + ASSERT_STREQ(a[1], "two"); + ASSERT_STREQ(a[2], "tri"); assert_se(!a[3]); assert_se(strv_insert(&a, 1, strdup("duo")) == 0); - assert_se(streq(a[0], "first")); - assert_se(streq(a[1], "duo")); - assert_se(streq(a[2], "two")); - assert_se(streq(a[3], "tri")); + ASSERT_STREQ(a[0], "first"); + ASSERT_STREQ(a[1], "duo"); + ASSERT_STREQ(a[2], "two"); + ASSERT_STREQ(a[3], "tri"); assert_se(!a[4]); } @@ -734,18 +734,18 @@ TEST(strv_push_prepend) { assert_se(a = strv_new("foo", "bar", "three")); assert_se(strv_push_prepend(&a, strdup("first")) >= 0); - assert_se(streq(a[0], "first")); - assert_se(streq(a[1], "foo")); - assert_se(streq(a[2], "bar")); - assert_se(streq(a[3], "three")); + ASSERT_STREQ(a[0], "first"); + ASSERT_STREQ(a[1], "foo"); + ASSERT_STREQ(a[2], "bar"); + ASSERT_STREQ(a[3], "three"); assert_se(!a[4]); assert_se(strv_consume_prepend(&a, strdup("first2")) >= 0); - assert_se(streq(a[0], "first2")); - assert_se(streq(a[1], "first")); - assert_se(streq(a[2], "foo")); - assert_se(streq(a[3], "bar")); - assert_se(streq(a[4], "three")); + ASSERT_STREQ(a[0], "first2"); + ASSERT_STREQ(a[1], "first"); + ASSERT_STREQ(a[2], "foo"); + ASSERT_STREQ(a[3], "bar"); + ASSERT_STREQ(a[4], "three"); assert_se(!a[5]); } @@ -765,10 +765,10 @@ TEST(strv_push_with_size) { assert_se(strv_push_with_size(&a, &n, j) >= 0); assert_se(n == 3); - assert_se(streq_ptr(a[0], "foo")); - assert_se(streq_ptr(a[1], "a")); - assert_se(streq_ptr(a[2], "b")); - assert_se(streq_ptr(a[3], NULL)); + ASSERT_STREQ(a[0], "foo"); + ASSERT_STREQ(a[1], "a"); + ASSERT_STREQ(a[2], "b"); + ASSERT_STREQ(a[3], NULL); assert_se(n = strv_length(a)); } @@ -784,10 +784,10 @@ TEST(strv_push) { assert_se(j = strdup("b")); assert_se(strv_push_pair(&a, i, j) >= 0); - assert_se(streq_ptr(a[0], "foo")); - assert_se(streq_ptr(a[1], "a")); - assert_se(streq_ptr(a[2], "b")); - assert_se(streq_ptr(a[3], NULL)); + ASSERT_STREQ(a[0], "foo"); + ASSERT_STREQ(a[1], "a"); + ASSERT_STREQ(a[2], "b"); + ASSERT_STREQ(a[3], NULL); } TEST(strv_compare) { @@ -849,23 +849,23 @@ TEST(strv_reverse) { b = strv_new("foo"); assert_se(b); strv_reverse(b); - assert_se(streq_ptr(b[0], "foo")); - assert_se(streq_ptr(b[1], NULL)); + ASSERT_STREQ(b[0], "foo"); + ASSERT_STREQ(b[1], NULL); c = strv_new("foo", "bar"); assert_se(c); strv_reverse(c); - assert_se(streq_ptr(c[0], "bar")); - assert_se(streq_ptr(c[1], "foo")); - assert_se(streq_ptr(c[2], NULL)); + ASSERT_STREQ(c[0], "bar"); + ASSERT_STREQ(c[1], "foo"); + ASSERT_STREQ(c[2], NULL); d = strv_new("foo", "bar", "waldo"); assert_se(d); strv_reverse(d); - assert_se(streq_ptr(d[0], "waldo")); - assert_se(streq_ptr(d[1], "bar")); - assert_se(streq_ptr(d[2], "foo")); - assert_se(streq_ptr(d[3], NULL)); + ASSERT_STREQ(d[0], "waldo"); + ASSERT_STREQ(d[1], "bar"); + ASSERT_STREQ(d[2], "foo"); + ASSERT_STREQ(d[3], NULL); } TEST(strv_shell_escape) { @@ -874,10 +874,10 @@ TEST(strv_shell_escape) { v = strv_new("foo:bar", "bar,baz", "wal\\do"); assert_se(v); assert_se(strv_shell_escape(v, ",:")); - assert_se(streq_ptr(v[0], "foo\\:bar")); - assert_se(streq_ptr(v[1], "bar\\,baz")); - assert_se(streq_ptr(v[2], "wal\\\\do")); - assert_se(streq_ptr(v[3], NULL)); + ASSERT_STREQ(v[0], "foo\\:bar"); + ASSERT_STREQ(v[1], "bar\\,baz"); + ASSERT_STREQ(v[2], "wal\\\\do"); + ASSERT_STREQ(v[3], NULL); } static void test_strv_skip_one(char **a, size_t n, char **b) { @@ -911,13 +911,13 @@ TEST(strv_extend_n) { assert_se(strv_extend_n(&v, "waldo", 3) >= 0); assert_se(strv_extend_n(&v, "piep", 2) >= 0); - assert_se(streq(v[0], "foo")); - assert_se(streq(v[1], "bar")); - assert_se(streq(v[2], "waldo")); - assert_se(streq(v[3], "waldo")); - assert_se(streq(v[4], "waldo")); - assert_se(streq(v[5], "piep")); - assert_se(streq(v[6], "piep")); + ASSERT_STREQ(v[0], "foo"); + ASSERT_STREQ(v[1], "bar"); + ASSERT_STREQ(v[2], "waldo"); + ASSERT_STREQ(v[3], "waldo"); + ASSERT_STREQ(v[4], "waldo"); + ASSERT_STREQ(v[5], "piep"); + ASSERT_STREQ(v[6], "piep"); ASSERT_NULL(v[7]); v = strv_free(v); @@ -925,7 +925,7 @@ TEST(strv_extend_n) { assert_se(strv_extend_n(&v, "foo", 1) >= 0); assert_se(strv_extend_n(&v, "bar", 0) >= 0); - assert_se(streq(v[0], "foo")); + ASSERT_STREQ(v[0], "foo"); ASSERT_NULL(v[1]); } @@ -939,11 +939,11 @@ TEST(foreach_string) { unsigned i = 0; FOREACH_STRING(x, "foo", "bar", "waldo") - assert_se(streq_ptr(t[i++], x)); + ASSERT_STREQ(t[i++], x); assert_se(i == 3); FOREACH_STRING(x, "zzz") - assert_se(streq(x, "zzz")); + ASSERT_STREQ(x, "zzz"); } TEST(strv_fnmatch) { @@ -966,8 +966,8 @@ TEST(strv_extend_join) { assert_se(strv_extend_assignment(&v, "MISSING", NULL) >= 0); assert_se(strv_length(v) == 2); - assert_se(streq(v[0], "MESSAGE=ABC")); - assert_se(streq(v[1], "ABC=QER")); + ASSERT_STREQ(v[0], "MESSAGE=ABC"); + ASSERT_STREQ(v[1], "ABC=QER"); } TEST(strv_copy_n) { @@ -1017,17 +1017,17 @@ TEST(strv_find_first_field) { ASSERT_NULL(strv_find_first_field(NULL, haystack)); ASSERT_NULL(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "b"), NULL)); ASSERT_NULL(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "b"), haystack)); - assert_se(streq_ptr(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "a", "c"), haystack), "b")); - assert_se(streq_ptr(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "c", "a"), haystack), "d")); - assert_se(streq_ptr(strv_find_first_field(STRV_MAKE("i", "k", "l", "m", "d", "c", "a", "b"), haystack), "j")); + ASSERT_STREQ(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "a", "c"), haystack), "b"); + ASSERT_STREQ(strv_find_first_field(STRV_MAKE("k", "l", "m", "d", "c", "a"), haystack), "d"); + ASSERT_STREQ(strv_find_first_field(STRV_MAKE("i", "k", "l", "m", "d", "c", "a", "b"), haystack), "j"); } TEST(endswith_strv) { - assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("xxx", "yyy", "ldo", "zzz")), "ldo")); - assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("xxx", "yyy", "zzz")), NULL)); - assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("waldo")), "waldo")); - assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("w", "o", "ldo")), "o")); - assert_se(streq_ptr(endswith_strv("waldo", STRV_MAKE("knurz", "", "waldo")), "")); + ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("xxx", "yyy", "ldo", "zzz")), "ldo"); + ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("xxx", "yyy", "zzz")), NULL); + ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("waldo")), "waldo"); + ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("w", "o", "ldo")), "o"); + ASSERT_STREQ(endswith_strv("waldo", STRV_MAKE("knurz", "", "waldo")), ""); } TEST(strv_extend_many) { diff --git a/src/test/test-strxcpyx.c b/src/test/test-strxcpyx.c index b679522fc62..00f595c4bb9 100644 --- a/src/test/test-strxcpyx.c +++ b/src/test/test-strxcpyx.c @@ -24,27 +24,27 @@ TEST(strpcpy) { space_left = strpcpy_full(&s, space_left, "r", &truncated); assert_se(!truncated); assert_se(space_left == 1); - assert_se(streq(target, "12345hey hey heywaldobar")); + ASSERT_STREQ(target, "12345hey hey heywaldobar"); space_left = strpcpy_full(&s, space_left, "", &truncated); assert_se(!truncated); assert_se(space_left == 1); - assert_se(streq(target, "12345hey hey heywaldobar")); + ASSERT_STREQ(target, "12345hey hey heywaldobar"); space_left = strpcpy_full(&s, space_left, "f", &truncated); assert_se(truncated); assert_se(space_left == 0); - assert_se(streq(target, "12345hey hey heywaldobar")); + ASSERT_STREQ(target, "12345hey hey heywaldobar"); space_left = strpcpy_full(&s, space_left, "", &truncated); assert_se(!truncated); assert_se(space_left == 0); - assert_se(streq(target, "12345hey hey heywaldobar")); + ASSERT_STREQ(target, "12345hey hey heywaldobar"); space_left = strpcpy_full(&s, space_left, "foo", &truncated); assert_se(truncated); assert_se(space_left == 0); - assert_se(streq(target, "12345hey hey heywaldobar")); + ASSERT_STREQ(target, "12345hey hey heywaldobar"); } TEST(strpcpyf) { @@ -59,38 +59,38 @@ TEST(strpcpyf) { space_left = strpcpyf_full(&s, space_left, &truncated, "foo%s", "bar"); assert_se(!truncated); assert_se(space_left == 3); - assert_se(streq(target, "space left: 25. foobar")); + ASSERT_STREQ(target, "space left: 25. foobar"); space_left = strpcpyf_full(&s, space_left, &truncated, "%i", 42); assert_se(!truncated); assert_se(space_left == 1); - assert_se(streq(target, "space left: 25. foobar42")); + ASSERT_STREQ(target, "space left: 25. foobar42"); space_left = strpcpyf_full(&s, space_left, &truncated, "%s", ""); assert_se(!truncated); assert_se(space_left == 1); - assert_se(streq(target, "space left: 25. foobar42")); + ASSERT_STREQ(target, "space left: 25. foobar42"); space_left = strpcpyf_full(&s, space_left, &truncated, "%c", 'x'); assert_se(truncated); assert_se(space_left == 0); - assert_se(streq(target, "space left: 25. foobar42")); + ASSERT_STREQ(target, "space left: 25. foobar42"); space_left = strpcpyf_full(&s, space_left, &truncated, "%s", ""); assert_se(!truncated); assert_se(space_left == 0); - assert_se(streq(target, "space left: 25. foobar42")); + ASSERT_STREQ(target, "space left: 25. foobar42"); space_left = strpcpyf_full(&s, space_left, &truncated, "abc%s", "hoge"); assert_se(truncated); assert_se(space_left == 0); - assert_se(streq(target, "space left: 25. foobar42")); + ASSERT_STREQ(target, "space left: 25. foobar42"); /* test overflow */ s = target; space_left = strpcpyf_full(&s, 12, &truncated, "00 left: %i. ", 999); assert_se(truncated); - assert_se(streq(target, "00 left: 99")); + ASSERT_STREQ(target, "00 left: 99"); assert_se(space_left == 0); assert_se(target[12] == '2'); } @@ -107,22 +107,22 @@ TEST(strpcpyl) { space_left = strpcpyl_full(&s, space_left, &truncated, "Banana", NULL); assert_se(!truncated); assert_se(space_left == 1); - assert_se(streq(target, "waldo test waldo. Banana")); + ASSERT_STREQ(target, "waldo test waldo. Banana"); space_left = strpcpyl_full(&s, space_left, &truncated, "", "", "", NULL); assert_se(!truncated); assert_se(space_left == 1); - assert_se(streq(target, "waldo test waldo. Banana")); + ASSERT_STREQ(target, "waldo test waldo. Banana"); space_left = strpcpyl_full(&s, space_left, &truncated, "", "x", "", NULL); assert_se(truncated); assert_se(space_left == 0); - assert_se(streq(target, "waldo test waldo. Banana")); + ASSERT_STREQ(target, "waldo test waldo. Banana"); space_left = strpcpyl_full(&s, space_left, &truncated, "hoge", NULL); assert_se(truncated); assert_se(space_left == 0); - assert_se(streq(target, "waldo test waldo. Banana")); + ASSERT_STREQ(target, "waldo test waldo. Banana"); } TEST(strscpy) { @@ -134,7 +134,7 @@ TEST(strscpy) { space_left = strscpy_full(target, space_left, "12345", &truncated); assert_se(!truncated); - assert_se(streq(target, "12345")); + ASSERT_STREQ(target, "12345"); assert_se(space_left == 20); } @@ -147,7 +147,7 @@ TEST(strscpyl) { space_left = strscpyl_full(target, space_left, &truncated, "12345", "waldo", "waldo", NULL); assert_se(!truncated); - assert_se(streq(target, "12345waldowaldo")); + ASSERT_STREQ(target, "12345waldowaldo"); assert_se(space_left == 10); } @@ -169,7 +169,7 @@ TEST(sd_event_code_migration) { for (i = 0; i < 100; i++) l = strpcpyf(&p, l, "%u ", i); - assert_se(streq(b, c)); + ASSERT_STREQ(b, c); } DEFINE_TEST_MAIN(LOG_INFO); diff --git a/src/test/test-sysctl-util.c b/src/test/test-sysctl-util.c index 81207f5cfd3..e94099605ca 100644 --- a/src/test/test-sysctl-util.c +++ b/src/test/test-sysctl-util.c @@ -34,7 +34,7 @@ TEST(sysctl_normalize) { assert_se(sysctl_normalize(t) == t); log_info("\"%s\" → \"%s\", expected \"%s\"", *s, t, *expected); - assert_se(streq(t, *expected)); + ASSERT_STREQ(t, *expected); } } @@ -66,7 +66,7 @@ TEST(sysctl_read) { assert_se(sysctl_read("kernel/hostname", &s) >= 0); assert_se(uname(&u) >= 0); - assert_se(streq_ptr(s, u.nodename)); + ASSERT_STREQ(s, u.nodename); r = sysctl_write("kernel/hostname", s); assert_se(r >= 0 || ERRNO_IS_PRIVILEGE(r) || r == -EROFS); diff --git a/src/test/test-time-util.c b/src/test/test-time-util.c index 9ce014dc9e3..9943923be30 100644 --- a/src/test/test-time-util.c +++ b/src/test/test-time-util.c @@ -413,7 +413,7 @@ static void test_format_timestamp_impl(usec_t x) { override ? ", ignoring." : ""); if (!override) { assert_se(x / USEC_PER_SEC == y / USEC_PER_SEC); - assert_se(streq(xx, yy)); + ASSERT_STREQ(xx, yy); } } @@ -482,69 +482,69 @@ TEST(format_timestamp_relative_full) { x = now(CLOCK_REALTIME) - (1*USEC_PER_YEAR + 1*USEC_PER_MONTH); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "1 year 1 month ago")); + ASSERT_STREQ(buf, "1 year 1 month ago"); x = now(CLOCK_MONOTONIC) + (1*USEC_PER_YEAR + 1.5*USEC_PER_MONTH); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_MONOTONIC, false)); log_debug("%s", buf); - assert_se(streq(buf, "1 year 1 month left")); + ASSERT_STREQ(buf, "1 year 1 month left"); x = now(CLOCK_REALTIME) - (1*USEC_PER_YEAR + 2*USEC_PER_MONTH); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "1 year 2 months ago")); + ASSERT_STREQ(buf, "1 year 2 months ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_YEAR + 1*USEC_PER_MONTH); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "2 years 1 month ago")); + ASSERT_STREQ(buf, "2 years 1 month ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_YEAR + 2*USEC_PER_MONTH); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "2 years 2 months ago")); + ASSERT_STREQ(buf, "2 years 2 months ago"); /* Months and days */ x = now(CLOCK_REALTIME) - (1*USEC_PER_MONTH + 1*USEC_PER_DAY); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "1 month 1 day ago")); + ASSERT_STREQ(buf, "1 month 1 day ago"); x = now(CLOCK_REALTIME) - (1*USEC_PER_MONTH + 2*USEC_PER_DAY); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "1 month 2 days ago")); + ASSERT_STREQ(buf, "1 month 2 days ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_MONTH + 1*USEC_PER_DAY); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "2 months 1 day ago")); + ASSERT_STREQ(buf, "2 months 1 day ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_MONTH + 2*USEC_PER_DAY); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "2 months 2 days ago")); + ASSERT_STREQ(buf, "2 months 2 days ago"); /* Weeks and days */ x = now(CLOCK_REALTIME) - (1*USEC_PER_WEEK + 1*USEC_PER_DAY); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "1 week 1 day ago")); + ASSERT_STREQ(buf, "1 week 1 day ago"); x = now(CLOCK_REALTIME) - (1*USEC_PER_WEEK + 2*USEC_PER_DAY); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "1 week 2 days ago")); + ASSERT_STREQ(buf, "1 week 2 days ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_WEEK + 1*USEC_PER_DAY); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "2 weeks 1 day ago")); + ASSERT_STREQ(buf, "2 weeks 1 day ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_WEEK + 2*USEC_PER_DAY); assert_se(format_timestamp_relative_full(buf, sizeof(buf), x, CLOCK_REALTIME, true)); log_debug("%s", buf); - assert_se(streq(buf, "2 weeks 2 days ago")); + ASSERT_STREQ(buf, "2 weeks 2 days ago"); } TEST(format_timestamp_relative) { @@ -559,64 +559,64 @@ TEST(format_timestamp_relative) { x = now(CLOCK_REALTIME) - (1*USEC_PER_YEAR + 1*USEC_PER_MONTH); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "1 year 1 month ago")); + ASSERT_STREQ(buf, "1 year 1 month ago"); x = now(CLOCK_REALTIME) - (1*USEC_PER_YEAR + 2*USEC_PER_MONTH); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "1 year 2 months ago")); + ASSERT_STREQ(buf, "1 year 2 months ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_YEAR + 1*USEC_PER_MONTH); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "2 years 1 month ago")); + ASSERT_STREQ(buf, "2 years 1 month ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_YEAR + 2*USEC_PER_MONTH); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "2 years 2 months ago")); + ASSERT_STREQ(buf, "2 years 2 months ago"); /* Months and days */ x = now(CLOCK_REALTIME) - (1*USEC_PER_MONTH + 1*USEC_PER_DAY); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "1 month 1 day ago")); + ASSERT_STREQ(buf, "1 month 1 day ago"); x = now(CLOCK_REALTIME) - (1*USEC_PER_MONTH + 2*USEC_PER_DAY); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "1 month 2 days ago")); + ASSERT_STREQ(buf, "1 month 2 days ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_MONTH + 1*USEC_PER_DAY); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "2 months 1 day ago")); + ASSERT_STREQ(buf, "2 months 1 day ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_MONTH + 2*USEC_PER_DAY); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "2 months 2 days ago")); + ASSERT_STREQ(buf, "2 months 2 days ago"); /* Weeks and days */ x = now(CLOCK_REALTIME) - (1*USEC_PER_WEEK + 1*USEC_PER_DAY); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "1 week 1 day ago")); + ASSERT_STREQ(buf, "1 week 1 day ago"); x = now(CLOCK_REALTIME) - (1*USEC_PER_WEEK + 2*USEC_PER_DAY); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "1 week 2 days ago")); + ASSERT_STREQ(buf, "1 week 2 days ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_WEEK + 1*USEC_PER_DAY); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "2 weeks 1 day ago")); + ASSERT_STREQ(buf, "2 weeks 1 day ago"); x = now(CLOCK_REALTIME) - (2*USEC_PER_WEEK + 2*USEC_PER_DAY); assert_se(format_timestamp_relative(buf, sizeof(buf), x)); log_debug("%s", buf); - assert_se(streq(buf, "2 weeks 2 days ago")); + ASSERT_STREQ(buf, "2 weeks 2 days ago"); } static void test_format_timestamp_one(usec_t val, TimestampStyle style, const char *result) { @@ -624,7 +624,7 @@ static void test_format_timestamp_one(usec_t val, TimestampStyle style, const ch const char *t; t = format_timestamp_style(buf, sizeof(buf), val, style); - assert_se(streq_ptr(t, result)); + ASSERT_STREQ(t, result); } TEST(format_timestamp_range) { @@ -1062,15 +1062,15 @@ TEST(in_utc_timezone) { assert_se(setenv("TZ", ":UTC", 1) >= 0); assert_se(in_utc_timezone()); - assert_se(streq(tzname[0], "UTC")); - assert_se(streq(tzname[1], "UTC")); + ASSERT_STREQ(tzname[0], "UTC"); + ASSERT_STREQ(tzname[1], "UTC"); assert_se(timezone == 0); assert_se(daylight == 0); assert_se(setenv("TZ", ":Europe/Berlin", 1) >= 0); assert_se(!in_utc_timezone()); - assert_se(streq(tzname[0], "CET")); - assert_se(streq(tzname[1], "CEST")); + ASSERT_STREQ(tzname[0], "CET"); + ASSERT_STREQ(tzname[1], "CEST"); assert_se(set_unset_env("TZ", tz, true) == 0); tzset(); @@ -1114,14 +1114,14 @@ static void test_timezone_offset_change_one(const char *utc, const char *pretty) s = FORMAT_TIMESTAMP_STYLE(x, TIMESTAMP_UTC); assert_se(parse_timestamp(s, &y) >= 0); log_debug("%s -> " USEC_FMT " -> %s -> " USEC_FMT, utc, x, s, y); - assert_se(streq(s, utc)); + ASSERT_STREQ(s, utc); assert_se(x == y); assert_se(parse_timestamp(pretty, &y) >= 0); s = FORMAT_TIMESTAMP_STYLE(y, TIMESTAMP_PRETTY); assert_se(parse_timestamp(s, &z) >= 0); log_debug("%s -> " USEC_FMT " -> %s -> " USEC_FMT, pretty, y, s, z); - assert_se(streq(s, pretty)); + ASSERT_STREQ(s, pretty); assert_se(x == y); assert_se(x == z); } diff --git a/src/test/test-tmpfile-util.c b/src/test/test-tmpfile-util.c index 4859f62da84..bef503bf3ef 100644 --- a/src/test/test-tmpfile-util.c +++ b/src/test/test-tmpfile-util.c @@ -105,7 +105,7 @@ static void test_tempfn_xxxxxx_one(const char *p, const char *extra, const char const char *suffix; assert_se(suffix = startswith(s, expect)); - assert_se(streq(suffix, "XXXXXX")); + ASSERT_STREQ(suffix, "XXXXXX"); } assert_se(ret == r); } @@ -283,7 +283,7 @@ TEST(link_tmpfile) { assert_se(link_tmpfile(fd, tmp, d, /* flags= */ 0) >= 0); assert_se(read_one_line_file(d, &line) >= 0); - assert_se(streq(line, "foobar")); + ASSERT_STREQ(line, "foobar"); fd = safe_close(fd); tmp = mfree(tmp); @@ -298,7 +298,7 @@ TEST(link_tmpfile) { line = mfree(line); assert_se(read_one_line_file(d, &line) >= 0); - assert_se(streq(line, "waumiau")); + ASSERT_STREQ(line, "waumiau"); assert_se(unlink(d) >= 0); } diff --git a/src/test/test-tpm2.c b/src/test/test-tpm2.c index 0d42df9d9fc..1a9c9988188 100644 --- a/src/test/test-tpm2.c +++ b/src/test/test-tpm2.c @@ -199,7 +199,7 @@ static void _test_tpms_sw( tpm2_tpms_pcr_selection_from_mask(mask, hash, &s); _cleanup_free_ char *tpms_str = tpm2_tpms_pcr_selection_to_string(&s); - assert_se(streq(tpms_str, expected_str)); + ASSERT_STREQ(tpms_str, expected_str); assert_se(tpm2_tpms_pcr_selection_weight(&s) == expected_weight); assert_se(tpm2_tpms_pcr_selection_is_empty(&s) == (expected_weight == 0)); @@ -242,7 +242,7 @@ static void _test_tpml_sw( assert_se(l.count == expected_count); _cleanup_free_ char *tpml_str = tpm2_tpml_pcr_selection_to_string(&l); - assert_se(streq(tpml_str, expected_str)); + ASSERT_STREQ(tpml_str, expected_str); assert_se(tpm2_tpml_pcr_selection_weight(&l) == expected_weight); assert_se(tpm2_tpml_pcr_selection_is_empty(&l) == (expected_weight == 0)); diff --git a/src/test/test-udev-util.c b/src/test/test-udev-util.c index cb80c69c968..07f4e018ac4 100644 --- a/src/test/test-udev-util.c +++ b/src/test/test-udev-util.c @@ -16,7 +16,7 @@ static void test_udev_replace_whitespace_one_len(const char *str, size_t len, co assert_se(result); r = udev_replace_whitespace(str, result, len); assert_se((size_t) r == strlen(expected)); - assert_se(streq(result, expected)); + ASSERT_STREQ(result, expected); } static void test_udev_replace_whitespace_one(const char *str, const char *expected) { diff --git a/src/test/test-unit-file.c b/src/test/test-unit-file.c index 220802e350b..63e500003c5 100644 --- a/src/test/test-unit-file.c +++ b/src/test/test-unit-file.c @@ -88,18 +88,18 @@ TEST(unit_file_build_name_map) { TEST(runlevel_to_target) { in_initrd_force(false); - assert_se(streq_ptr(runlevel_to_target(NULL), NULL)); - assert_se(streq_ptr(runlevel_to_target("unknown-runlevel"), NULL)); - assert_se(streq_ptr(runlevel_to_target("rd.unknown-runlevel"), NULL)); - assert_se(streq_ptr(runlevel_to_target("3"), SPECIAL_MULTI_USER_TARGET)); - assert_se(streq_ptr(runlevel_to_target("rd.rescue"), NULL)); + ASSERT_STREQ(runlevel_to_target(NULL), NULL); + ASSERT_STREQ(runlevel_to_target("unknown-runlevel"), NULL); + ASSERT_STREQ(runlevel_to_target("rd.unknown-runlevel"), NULL); + ASSERT_STREQ(runlevel_to_target("3"), SPECIAL_MULTI_USER_TARGET); + ASSERT_STREQ(runlevel_to_target("rd.rescue"), NULL); in_initrd_force(true); - assert_se(streq_ptr(runlevel_to_target(NULL), NULL)); - assert_se(streq_ptr(runlevel_to_target("unknown-runlevel"), NULL)); - assert_se(streq_ptr(runlevel_to_target("rd.unknown-runlevel"), NULL)); - assert_se(streq_ptr(runlevel_to_target("3"), NULL)); - assert_se(streq_ptr(runlevel_to_target("rd.rescue"), SPECIAL_RESCUE_TARGET)); + ASSERT_STREQ(runlevel_to_target(NULL), NULL); + ASSERT_STREQ(runlevel_to_target("unknown-runlevel"), NULL); + ASSERT_STREQ(runlevel_to_target("rd.unknown-runlevel"), NULL); + ASSERT_STREQ(runlevel_to_target("3"), NULL); + ASSERT_STREQ(runlevel_to_target("rd.rescue"), SPECIAL_RESCUE_TARGET); } static int intro(void) { diff --git a/src/test/test-unit-name.c b/src/test/test-unit-name.c index 8e9332c33e5..b4821047693 100644 --- a/src/test/test-unit-name.c +++ b/src/test/test-unit-name.c @@ -92,7 +92,7 @@ static void test_unit_name_replace_instance_one(const char *pattern, const char _cleanup_free_ char *t = NULL; assert_se(unit_name_replace_instance(pattern, repl, &t) == ret); puts(strna(t)); - assert_se(streq_ptr(t, expected)); + ASSERT_STREQ(t, expected); } TEST(unit_name_replace_instance) { @@ -112,7 +112,7 @@ static void test_unit_name_from_path_one(const char *path, const char *suffix, c assert_se(unit_name_from_path(path, suffix, &t) == ret); puts(strna(t)); - assert_se(streq_ptr(t, expected)); + ASSERT_STREQ(t, expected); if (t) { _cleanup_free_ char *k = NULL; @@ -159,7 +159,7 @@ static void test_unit_name_from_path_instance_one(const char *pattern, const cha assert_se(unit_name_from_path_instance(pattern, path, suffix, &t) == ret); puts(strna(t)); - assert_se(streq_ptr(t, expected)); + ASSERT_STREQ(t, expected); if (t) { _cleanup_free_ char *k = NULL, *v = NULL; @@ -185,7 +185,7 @@ static void test_unit_name_to_path_one(const char *unit, const char *path, int r _cleanup_free_ char *p = NULL; assert_se(unit_name_to_path(unit, &p) == ret); - assert_se(streq_ptr(path, p)); + ASSERT_STREQ(path, p); } TEST(unit_name_to_path) { @@ -208,7 +208,7 @@ static void test_unit_name_mangle_one(bool allow_globs, const char *pattern, con assert_se(r == ret); puts(strna(t)); - assert_se(streq_ptr(t, expect)); + ASSERT_STREQ(t, expect); if (t) { _cleanup_free_ char *k = NULL; @@ -217,7 +217,7 @@ static void test_unit_name_mangle_one(bool allow_globs, const char *pattern, con (allow_globs && string_is_glob(t))); assert_se(unit_name_mangle(t, (allow_globs * UNIT_NAME_MANGLE_GLOB) | UNIT_NAME_MANGLE_WARN, &k) == 0); - assert_se(streq_ptr(t, k)); + ASSERT_STREQ(t, k); } } @@ -246,7 +246,7 @@ static void test_unit_name_mangle_with_suffix_one(const char *arg, int expected, log_debug("%s: %s -> %d, %s", __func__, arg, r, strnull(s)); assert_se(r == expected); - assert_se(streq_ptr(s, expected_name)); + ASSERT_STREQ(s, expected_name); } TEST(unit_name_mangle_with_suffix) { @@ -499,11 +499,11 @@ TEST(unit_name_change_suffix) { char *t; assert_se(unit_name_change_suffix("foo.mount", ".service", &t) == 0); - assert_se(streq(t, "foo.service")); + ASSERT_STREQ(t, "foo.service"); free(t); assert_se(unit_name_change_suffix("foo@stuff.service", ".socket", &t) == 0); - assert_se(streq(t, "foo@stuff.socket")); + ASSERT_STREQ(t, "foo@stuff.socket"); free(t); } @@ -511,15 +511,15 @@ TEST(unit_name_build) { char *t; assert_se(unit_name_build("foo", "bar", ".service", &t) == 0); - assert_se(streq(t, "foo@bar.service")); + ASSERT_STREQ(t, "foo@bar.service"); free(t); assert_se(unit_name_build("fo0-stUff_b", "bar", ".mount", &t) == 0); - assert_se(streq(t, "fo0-stUff_b@bar.mount")); + ASSERT_STREQ(t, "fo0-stUff_b@bar.mount"); free(t); assert_se(unit_name_build("foo", NULL, ".service", &t) == 0); - assert_se(streq(t, "foo.service")); + ASSERT_STREQ(t, "foo.service"); free(t); } @@ -563,7 +563,7 @@ TEST(build_subslice) { free(b); assert_se(slice_build_subslice(a, "foobar", &b) >= 0); free(a); - assert_se(streq(b, "foo-bar-barfoo-foobar.slice")); + ASSERT_STREQ(b, "foo-bar-barfoo-foobar.slice"); free(b); assert_se(slice_build_subslice("foo.service", "bar", &a) < 0); @@ -574,7 +574,7 @@ static void test_build_parent_slice_one(const char *name, const char *expect, in _cleanup_free_ char *s = NULL; assert_se(slice_build_parent_slice(name, &s) == ret); - assert_se(streq_ptr(s, expect)); + ASSERT_STREQ(s, expect); } TEST(build_parent_slice) { @@ -602,17 +602,17 @@ TEST(unit_name_to_instance) { r = unit_name_to_instance("foo@bar.service", &instance); assert_se(r == UNIT_NAME_INSTANCE); - assert_se(streq(instance, "bar")); + ASSERT_STREQ(instance, "bar"); free(instance); r = unit_name_to_instance("foo@.service", &instance); assert_se(r == UNIT_NAME_TEMPLATE); - assert_se(streq(instance, "")); + ASSERT_STREQ(instance, ""); free(instance); r = unit_name_to_instance("fo0-stUff_b@b.service", &instance); assert_se(r == UNIT_NAME_INSTANCE); - assert_se(streq(instance, "b")); + ASSERT_STREQ(instance, "b"); free(instance); r = unit_name_to_instance("foo.service", &instance); @@ -633,7 +633,7 @@ TEST(unit_name_escape) { r = unit_name_escape("ab+-c.a/bc@foo.service"); assert_se(r); - assert_se(streq(r, "ab\\x2b\\x2dc.a-bc\\x40foo.service")); + ASSERT_STREQ(r, "ab\\x2b\\x2dc.a-bc\\x40foo.service"); } static void test_u_n_t_one(const char *name, const char *expected, int ret) { @@ -641,7 +641,7 @@ static void test_u_n_t_one(const char *name, const char *expected, int ret) { assert_se(unit_name_template(name, &f) == ret); printf("got: %s, expected: %s\n", strna(f), strna(expected)); - assert_se(streq_ptr(f, expected)); + ASSERT_STREQ(f, expected); } TEST(unit_name_template) { @@ -653,7 +653,7 @@ static void test_unit_name_path_unescape_one(const char *name, const char *path, _cleanup_free_ char *p = NULL; assert_se(unit_name_path_unescape(name, &p) == ret); - assert_se(streq_ptr(path, p)); + ASSERT_STREQ(path, p); } TEST(unit_name_path_unescape) { @@ -675,7 +675,7 @@ static void test_unit_name_to_prefix_one(const char *input, int ret, const char _cleanup_free_ char *k = NULL; assert_se(unit_name_to_prefix(input, &k) == ret); - assert_se(streq_ptr(k, output)); + ASSERT_STREQ(k, output); } TEST(unit_name_to_prefix) { @@ -695,7 +695,7 @@ static void test_unit_name_from_dbus_path_one(const char *input, int ret, const _cleanup_free_ char *k = NULL; assert_se(unit_name_from_dbus_path(input, &k) == ret); - assert_se(streq_ptr(k, output)); + ASSERT_STREQ(k, output); } TEST(unit_name_from_dbus_path) { diff --git a/src/test/test-user-util.c b/src/test/test-user-util.c index f115a477738..e21d8da478a 100644 --- a/src/test/test-user-util.c +++ b/src/test/test-user-util.c @@ -21,7 +21,7 @@ static void test_uid_to_name_one(uid_t uid, const char *name) { log_info("(skipping detailed tests because nobody is not synthesized)"); return; } - assert_se(streq_ptr(t, name)); + ASSERT_STREQ(t, name); } TEST(uid_to_name) { @@ -41,7 +41,7 @@ static void test_gid_to_name_one(gid_t gid, const char *name) { log_info("(skipping detailed tests because nobody is not synthesized)"); return; } - assert_se(streq_ptr(t, name)); + ASSERT_STREQ(t, name); } TEST(gid_to_name) { @@ -338,7 +338,7 @@ static void test_get_user_creds_one(const char *id, const char *name, uid_t uid, return; } assert_se(r == 0); - assert_se(streq_ptr(id, name)); + ASSERT_STREQ(id, name); assert_se(ruid == uid); assert_se(rgid == gid); assert_se(path_equal(rhome, home)); @@ -364,7 +364,7 @@ static void test_get_group_creds_one(const char *id, const char *name, gid_t gid return; } assert_se(r == 0); - assert_se(streq_ptr(id, name)); + ASSERT_STREQ(id, name); assert_se(rgid == gid); } @@ -466,7 +466,7 @@ static void test_mangle_gecos_one(const char *input, const char *expected) { _cleanup_free_ char *p = NULL; assert_se(p = mangle_gecos(input)); - assert_se(streq(p, expected)); + ASSERT_STREQ(p, expected); assert_se(valid_gecos(p)); } diff --git a/src/test/test-utf8.c b/src/test/test-utf8.c index a0d7dc14ef1..d60cf00bf32 100644 --- a/src/test/test-utf8.c +++ b/src/test/test-utf8.c @@ -62,7 +62,7 @@ static void test_utf8_to_ascii_one(const char *s, int r_expected, const char *ex r = utf8_to_ascii(s, '*', &ans); log_debug("\"%s\" → %d/\"%s\" (expected %d/\"%s\")", s, r, strnull(ans), r_expected, strnull(expected)); assert_se(r == r_expected); - assert_se(streq_ptr(ans, expected)); + ASSERT_STREQ(ans, expected); } TEST(utf8_to_ascii) { @@ -223,7 +223,7 @@ TEST(utf8_to_utf16) { b = utf16_to_utf8(a, SIZE_MAX); assert_se(b); - assert_se(streq(p, b)); + ASSERT_STREQ(p, b); } } diff --git a/src/test/test-varlink-idl.c b/src/test/test-varlink-idl.c index 33238103682..86dbcc963cd 100644 --- a/src/test/test-varlink-idl.c +++ b/src/test/test-varlink-idl.c @@ -123,7 +123,7 @@ static void test_parse_format_one(const VarlinkInterface *iface) { assert_se(varlink_idl_parse(text, NULL, NULL, &parsed) >= 0); assert_se(varlink_idl_consistent(parsed, LOG_ERR) >= 0); assert_se(varlink_idl_format(parsed, &text2) >= 0); - assert_se(streq(text, text2)); + ASSERT_STREQ(text, text2); } TEST(parse_format) { @@ -387,13 +387,13 @@ TEST(validate_method_call) { JSON_BUILD_PAIR_UNSIGNED("foo", 8), JSON_BUILD_PAIR_UNSIGNED("bar", 9), JSON_BUILD_PAIR_STRING("zzz", "pfft"))) >= 0); - assert_se(streq_ptr(error_id, VARLINK_ERROR_INVALID_PARAMETER)); + ASSERT_STREQ(error_id, VARLINK_ERROR_INVALID_PARAMETER); assert_se(varlink_callb(v, "xyz.TestMethod", &reply, &error_id, JSON_BUILD_OBJECT( JSON_BUILD_PAIR_BOOLEAN("foo", true), JSON_BUILD_PAIR_UNSIGNED("bar", 9))) >= 0); - assert_se(streq_ptr(error_id, VARLINK_ERROR_INVALID_PARAMETER)); + ASSERT_STREQ(error_id, VARLINK_ERROR_INVALID_PARAMETER); assert_se(varlink_send(v, "xyz.Done", NULL) >= 0); assert_se(varlink_flush(v) >= 0); diff --git a/src/test/test-varlink.c b/src/test/test-varlink.c index cd9c5936130..8ad5757b9d3 100644 --- a/src/test/test-varlink.c +++ b/src/test/test-varlink.c @@ -107,7 +107,7 @@ static int method_passfd(Varlink *link, JsonVariant *parameters, VarlinkMethodFl if (!a) return varlink_error(link, "io.test.BadParameters", NULL); - assert_se(streq_ptr(json_variant_string(a), "whoop")); + ASSERT_STREQ(json_variant_string(a), "whoop"); int xx = varlink_peek_fd(link, 0), yy = varlink_peek_fd(link, 1), @@ -183,7 +183,7 @@ static int overload_reply(Varlink *link, JsonVariant *parameters, const char *er * be talking to an overloaded server */ log_debug("Over reply triggered with error: %s", strna(error_id)); - assert_se(streq(error_id, VARLINK_ERROR_DISCONNECTED)); + ASSERT_STREQ(error_id, VARLINK_ERROR_DISCONNECTED); sd_event_exit(varlink_get_event(link), 0); return 0; @@ -299,8 +299,8 @@ static void *thread(void *arg) { test_fd(fd5, "wuff", 4); assert_se(varlink_callb(c, "io.test.IDontExist", &o, &e, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("x", JSON_BUILD_REAL(5.5)))) >= 0); - assert_se(streq_ptr(json_variant_string(json_variant_by_key(o, "method")), "io.test.IDontExist")); - assert_se(streq(e, VARLINK_ERROR_METHOD_NOT_FOUND)); + ASSERT_STREQ(json_variant_string(json_variant_by_key(o, "method")), "io.test.IDontExist"); + ASSERT_STREQ(e, VARLINK_ERROR_METHOD_NOT_FOUND); flood_test(arg); diff --git a/src/test/test-vpick.c b/src/test/test-vpick.c index 1a288e8ba12..feb16b61a46 100644 --- a/src/test/test-vpick.c +++ b/src/test/test-vpick.c @@ -53,7 +53,7 @@ TEST(path_pick) { if (IN_SET(native_architecture(), ARCHITECTURE_X86, ARCHITECTURE_X86_64)) { assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0); assert_se(S_ISREG(result.st.st_mode)); - assert_se(streq_ptr(result.version, "99")); + ASSERT_STREQ(result.version, "99"); assert_se(result.architecture == ARCHITECTURE_X86); assert_se(endswith(result.path, "/foo_99_x86.raw")); @@ -63,7 +63,7 @@ TEST(path_pick) { filter.architecture = ARCHITECTURE_X86_64; assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0); assert_se(S_ISREG(result.st.st_mode)); - assert_se(streq_ptr(result.version, "55")); + ASSERT_STREQ(result.version, "55"); assert_se(result.architecture == ARCHITECTURE_X86_64); assert_se(endswith(result.path, "/foo_55_x86-64.raw")); pick_result_done(&result); @@ -71,7 +71,7 @@ TEST(path_pick) { filter.architecture = ARCHITECTURE_IA64; assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0); assert_se(S_ISREG(result.st.st_mode)); - assert_se(streq_ptr(result.version, "5")); + ASSERT_STREQ(result.version, "5"); assert_se(result.architecture == ARCHITECTURE_IA64); assert_se(endswith(result.path, "/foo_5_ia64.raw")); pick_result_done(&result); @@ -80,7 +80,7 @@ TEST(path_pick) { filter.version = "5"; assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0); assert_se(S_ISREG(result.st.st_mode)); - assert_se(streq_ptr(result.version, "5")); + ASSERT_STREQ(result.version, "5"); if (native_architecture() != ARCHITECTURE_IA64) { assert_se(result.architecture == _ARCHITECTURE_INVALID); assert_se(endswith(result.path, "/foo_5.raw")); @@ -90,7 +90,7 @@ TEST(path_pick) { filter.architecture = ARCHITECTURE_IA64; assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0); assert_se(S_ISREG(result.st.st_mode)); - assert_se(streq_ptr(result.version, "5")); + ASSERT_STREQ(result.version, "5"); assert_se(result.architecture == ARCHITECTURE_IA64); assert_se(endswith(result.path, "/foo_5_ia64.raw")); pick_result_done(&result); @@ -109,7 +109,7 @@ TEST(path_pick) { if (IN_SET(native_architecture(), ARCHITECTURE_X86_64, ARCHITECTURE_X86)) { assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0); assert_se(S_ISREG(result.st.st_mode)); - assert_se(streq_ptr(result.version, "55")); + ASSERT_STREQ(result.version, "55"); if (native_architecture() == ARCHITECTURE_X86_64) { assert_se(result.architecture == ARCHITECTURE_X86_64); @@ -129,7 +129,7 @@ TEST(path_pick) { if (IN_SET(native_architecture(), ARCHITECTURE_X86, ARCHITECTURE_X86_64)) { assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0); assert_se(S_ISREG(result.st.st_mode)); - assert_se(streq_ptr(result.version, "55")); + ASSERT_STREQ(result.version, "55"); assert_se(result.architecture == native_architecture()); assert_se(endswith(result.path, ".raw")); assert_se(strrstr(result.path, "/foo_55_x86")); @@ -161,7 +161,7 @@ TEST(path_pick) { assert_se(path_pick(NULL, AT_FDCWD, pp, &filter, PICK_ARCHITECTURE|PICK_TRIES, &result) > 0); assert_se(S_ISREG(result.st.st_mode)); - assert_se(streq_ptr(result.version, "2")); + ASSERT_STREQ(result.version, "2"); assert_se(result.tries_left == 4); assert_se(result.tries_done == 6); assert_se(endswith(result.path, "quux_2_s390+4-6.raw")); diff --git a/src/test/test-xattr-util.c b/src/test/test-xattr-util.c index b473165a3e0..c754ac526e8 100644 --- a/src/test/test-xattr-util.c +++ b/src/test/test-xattr-util.c @@ -51,7 +51,7 @@ TEST(getxattr_at_malloc) { fd = open(x, O_PATH|O_CLOEXEC); assert_se(fd >= 0); assert_se(getxattr_at_malloc(fd, NULL, "user.foo", 0, &value) == 3); - assert_se(streq(value, "bar")); + ASSERT_STREQ(value, "bar"); } TEST(getcrtime) { @@ -83,7 +83,7 @@ static void verify_xattr(int dfd, const char *expected) { _cleanup_free_ char *value = NULL; assert_se(getxattr_at_malloc(dfd, "test", "user.foo", 0, &value) == (int) strlen(expected)); - assert_se(streq(value, expected)); + ASSERT_STREQ(value, expected); } TEST(xsetxattr) { diff --git a/src/test/test-xml.c b/src/test/test-xml.c index a8cb635aa31..6367f272637 100644 --- a/src/test/test-xml.c +++ b/src/test/test-xml.c @@ -29,7 +29,7 @@ static void test_one(const char *data, ...) { break; nn = va_arg(ap, const char *); - assert_se(streq_ptr(nn, name)); + ASSERT_STREQ(nn, name); } va_end(ap); -- 2.39.2