dilim/systemd
1
0 Fork 0
mirror of https://github.com/systemd/systemd.git synced 2026-11-06 05:17:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: add ASSERT_MEMEQ() and friends, and convert assert_se() in tests/fuzzers (#44641)

Browse Source 
This adds a few typed assertion helpers to src/shared/tests.h that print
where things differ on failure, instead of just aborting:

- ASSERT_MEMEQ() / ASSERT_MEMEQ_NN() for memory regions
- ASSERT_MEMEQ_BYTE() / ASSERT_MEMEQ_ZERO()
- ASSERT_IOVEC_EQ() / ASSERT_IOVW_EQ()

On mismatch they show a hexdump-style, side-by-side diff of the
operands. To back this, hexdump() is moved from basic/hexdecoct to a new
shared/hexdump (the EFI hexdump() in src/boot is renamed to hexdump16()
to avoid the name clash), and the dump helpers live next to it.

The rest is mechanical: existing ASSERT_TRUE(memcmp(...) == 0) and
similar patterns are switched to the new macros, and assert_se() in the
fuzzers (plus a couple of test files) is converted to the typed ASSERT_*
family.

No functional change to non-test code.
This commit is contained in:
Yu Watanabe authored and GitHub committed 2026-11-05 12:11:05 +09:00
2 parents e762d33144 3f0c5c5687
commit efca02fa36
121 files changed
+1196 -931
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/basic/hexdecoct.c
-52
View File
@@ -1,8 +1,5 @@
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <ctype.h>
#include <stdio.h>
#include "alloc-util.h"
#include "hexdecoct.h"
#include "memory-util.h"
@@ -849,52 +846,3 @@ int unbase64mem_full(
return 0;
}
void hexdump(FILE *f, const void *p, size_t s) {
const uint8_t *b = p;
unsigned n = 0;
assert(b || s == 0);
if (s == SIZE_MAX)
s = strlen(p);
if (!f)
f = stdout;
while (s > 0) {
size_t i;
fprintf(f, "%04x ", n);
for (i = 0; i < 16; i++) {
if (i >= s)
fputs(" ", f);
else
fprintf(f, "%02x ", b[i]);
if (i == 7)
fputc(' ', f);
}
fputc(' ', f);
for (i = 0; i < 16; i++) {
if (i >= s)
fputc(' ', f);
else
fputc(isprint(b[i]) ? (char) b[i] : '.', f);
}
fputc('\n', f);
if (s < 16)
break;
n += 16;
b += 16;
s -= 16;
}
}
src/basic/hexdecoct.h
-2
View File
@@ -44,5 +44,3 @@ int unbase64mem_full(const char *p, size_t l, bool secure, void **ret_data, size
static inline int unbase64mem(const char *p, void **ret_data, size_t *ret_size) {
return unbase64mem_full(p, SIZE_MAX, /* secure= */ false, ret_data, ret_size);
}
void hexdump(FILE *f, const void *p, size_t s) _nonnull_if_nonzero_(2, 3);
src/boot/device-path-util.c
+1 -1
View File
@@ -108,7 +108,7 @@ static char16_t *device_path_to_str_internal(const EFI_DEVICE_PATH *dp) {
* provide the EFI_DEVICE_PATH_TO_TEXT_PROTOCOL after all. */
size_t size = node->Length - sizeof(EFI_DEVICE_PATH);
_cleanup_free_ char16_t *hex_data = hexdump((uint8_t *) node + sizeof(EFI_DEVICE_PATH), size);
_cleanup_free_ char16_t *hex_data = hexdump16((uint8_t *) node + sizeof(EFI_DEVICE_PATH), size);
str = xasprintf("%ls%sPath(%u,%u%s%ls)",
strempty(old),
old ? "/" : "",
src/boot/efi-log.h
+1 -1
View File
@@ -64,6 +64,6 @@ _gnu_printf_(3, 4) EFI_STATUS log_internal(EFI_STATUS status, LogLevel log_level
/* Debugging helper — please keep this around, even if not used */
#define log_hexdump(prefix, data, size) \
({ \
_cleanup_free_ char16_t *hex = hexdump(data, size); \
_cleanup_free_ char16_t *hex = hexdump16(data, size); \
log_debug("%ls[%zu]: %ls", prefix, size, hex); \
})
src/boot/efi-string.c
+1 -1
View File
@@ -511,7 +511,7 @@ char* line_get_key_value(char *s, const char *sep, size_t *pos, char **ret_key,
}
}
char16_t *hexdump(const void *data, size_t size) {
char16_t *hexdump16(const void *data, size_t size) {
const char *hex = LOWERCASE_HEXDIGITS;
const uint8_t *d = data;
src/boot/efi-string.h
+1 -1
View File
@@ -119,7 +119,7 @@ bool parse_boolean(const char *v, bool *ret);
char* line_get_key_value(char *s, const char *sep, size_t *pos, char **ret_key, char **ret_value);
char16_t *hexdump(const void *data, size_t size);
char16_t *hexdump16(const void *data, size_t size);
#ifdef __clang__
# define _gnu_printf_(a, b) _printf_(a, b)
src/boot/fuzz-bcd.c
+2 -1
View File
@@ -3,6 +3,7 @@
#include "alloc-util.h"
#include "bcd.h"
#include "fuzz.h"
#include "tests.h"
#include "utf8.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -15,7 +16,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
p = memdup(data, size);
assert_se(p);
ASSERT_NOT_NULL(p);
char16_t *title = get_bcd_title(p, size);
/* If we get something, it must be NUL-terminated, but an empty string is still valid! */
src/boot/fuzz-efi-osrel.c
+4 -3
View File
@@ -3,6 +3,7 @@
#include "alloc-util.h"
#include "efi-string.h"
#include "fuzz.h"
#include "tests.h"
#define SEP_LEN 4
@@ -15,13 +16,13 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
_cleanup_free_ char *p = memdup_suffix0(data + SEP_LEN + 1, size - SEP_LEN - 1);
assert_se(p);
ASSERT_NOT_NULL(p);
size_t pos = 0;
char *key, *value;
while (line_get_key_value(p, (const char *) data, &pos, &key, &value)) {
assert_se(key);
assert_se(value);
ASSERT_NOT_NULL(key);
ASSERT_NOT_NULL(value);
}
return 0;
src/boot/fuzz-efi-string.c
+2 -1
View File
@@ -3,10 +3,11 @@
#include "alloc-util.h"
#include "efi-string.h"
#include "fuzz.h"
#include "tests.h"
static char16_t *memdup_str16(const uint8_t *data, size_t size) {
char16_t *ret = memdup(data, size);
assert_se(ret);
ASSERT_NOT_NULL(ret);
ret[size / sizeof(char16_t) - 1] = '\0';
return ret;
}
src/boot/test-bcd.c
+1 -1
View File
@@ -35,7 +35,7 @@ static void test_get_bcd_title_one(
char16_t *title = get_bcd_title(bcd, len);
if (title_expect) {
ASSERT_NOT_NULL(title);
ASSERT_EQ(memcmp(title, title_expect, title_len_expect), 0);
ASSERT_MEMEQ(title, title_expect, title_len_expect);
} else
ASSERT_NULL(title);
}
src/boot/test-efi-string.c
+16 -16
View File
@@ -70,11 +70,11 @@ TEST(strtolower8) {
ASSERT_NULL(strtolower8(NULL));
ASSERT_PTR_EQ(strtolower8(s), s);
ASSERT_EQ(memcmp(s, "\0001234abcDEF!\0zZ", sizeof(s)), 0);
ASSERT_MEMEQ(s, "\0001234abcDEF!\0zZ", sizeof(s));
s[0] = '#';
ASSERT_PTR_EQ(strtolower8(s), s);
ASSERT_EQ(memcmp(s, "#1234abcdef!\0zZ", sizeof(s)), 0);
ASSERT_MEMEQ(s, "#1234abcdef!\0zZ", sizeof(s));
}
TEST(strtolower16) {
@@ -83,11 +83,11 @@ TEST(strtolower16) {
ASSERT_NULL(strtolower16(NULL));
ASSERT_PTR_EQ(strtolower16(s), s);
ASSERT_EQ(memcmp(s, u"\0001234abcDEF!\0zZ", sizeof(s)), 0);
ASSERT_MEMEQ(s, u"\0001234abcDEF!\0zZ", sizeof(s));
s[0] = '#';
ASSERT_PTR_EQ(strtolower16(s), s);
ASSERT_EQ(memcmp(s, u"#1234abcdef!\0zZ", sizeof(s)), 0);
ASSERT_MEMEQ(s, u"#1234abcdef!\0zZ", sizeof(s));
}
TEST(strncmp8) {
@@ -644,22 +644,22 @@ TEST(line_get_key_value) {
}
}
TEST(hexdump) {
TEST(hexdump16) {
char16_t *hex;
ASSERT_NOT_NULL(hex = hexdump(/* data= */ NULL, /* size= */ 0));
ASSERT_NOT_NULL(hex = hexdump16(/* data= */ NULL, /* size= */ 0));
ASSERT_TRUE(streq16(hex, u""));
free(hex);
ASSERT_NOT_NULL(hex = hexdump("1", 2));
ASSERT_NOT_NULL(hex = hexdump16("1", 2));
ASSERT_TRUE(streq16(hex, u"3100"));
free(hex);
ASSERT_NOT_NULL(hex = hexdump("abc", 4));
ASSERT_NOT_NULL(hex = hexdump16("abc", 4));
ASSERT_TRUE(streq16(hex, u"61626300"));
free(hex);
ASSERT_NOT_NULL(hex = hexdump((uint8_t[]){ 0x0, 0x42, 0xFF, 0xF1, 0x1F }, 5));
ASSERT_NOT_NULL(hex = hexdump16((uint8_t[]){ 0x0, 0x42, 0xFF, 0xF1, 0x1F }, 5));
ASSERT_TRUE(streq16(hex, u"0042fff11f"));
free(hex);
}
@@ -855,13 +855,13 @@ TEST(efi_memcpy) {
ASSERT_PTR_EQ(efi_memcpy(buf, "a", 0), buf);
ASSERT_PTR_EQ(efi_memcpy(buf, "", 1), buf);
ASSERT_EQ(memcmp(buf, "", 1), 0);
ASSERT_MEMEQ(buf, "", 1);
ASSERT_PTR_EQ(efi_memcpy(buf, "1", 1), buf);
ASSERT_EQ(memcmp(buf, "1", 1), 0);
ASSERT_MEMEQ(buf, "1", 1);
ASSERT_PTR_EQ(efi_memcpy(buf, "23", 3), buf);
ASSERT_EQ(memcmp(buf, "23", 3), 0);
ASSERT_MEMEQ(buf, "23", 3);
ASSERT_PTR_EQ(efi_memcpy(buf, "45\0ab\0\0\0c", 9), buf);
ASSERT_EQ(memcmp(buf, "45\0ab\0\0\0c", 9), 0);
ASSERT_MEMEQ(buf, "45\0ab\0\0\0c", 9);
}
TEST(efi_memset) {
@@ -872,11 +872,11 @@ TEST(efi_memset) {
ASSERT_PTR_EQ(efi_memset(buf, '1', 0), buf);
ASSERT_PTR_EQ(efi_memset(buf, '2', 1), buf);
ASSERT_EQ(memcmp(buf, "2", 1), 0);
ASSERT_MEMEQ(buf, "2", 1);
ASSERT_PTR_EQ(efi_memset(buf, '4', 4), buf);
ASSERT_EQ(memcmp(buf, "4444", 4), 0);
ASSERT_MEMEQ(buf, "4444", 4);
ASSERT_PTR_EQ(efi_memset(buf, 'a', 10), buf);
ASSERT_EQ(memcmp(buf, "aaaaaaaaaa", 10), 0);
ASSERT_MEMEQ(buf, "aaaaaaaaaa", 10);
}
TEST(efi_strspn) {
src/core/fuzz-execute-serialize.c
+3 -2
View File
@@ -27,6 +27,7 @@
#include "fd-util.h"
#include "fdset.h"
#include "fuzz.h"
#include "tests.h"
static void exec_fuzz_one(FILE *f, FDSet *fdset) {
_cleanup_(exec_params_deep_clear) ExecParameters params = EXEC_PARAMETERS_INIT(/* flags= */ 0);
@@ -86,8 +87,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(fdset = fdset_new());
assert_se(f = data_to_file(data, size));
fdset = ASSERT_NOT_NULL(fdset_new());
f = ASSERT_NOT_NULL(data_to_file(data, size));
exec_fuzz_one(f, fdset);
src/core/fuzz-manager-serialize.c
+5 -4
View File
@@ -7,6 +7,7 @@
#include "fuzz.h"
#include "manager.h"
#include "manager-serialize.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(manager_freep) Manager *m = NULL;
@@ -18,14 +19,14 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(manager_new(RUNTIME_SCOPE_SYSTEM, MANAGER_TEST_RUN_MINIMAL|MANAGER_TEST_DONT_OPEN_EXECUTOR, &m) >= 0);
ASSERT_OK(manager_new(RUNTIME_SCOPE_SYSTEM, MANAGER_TEST_RUN_MINIMAL|MANAGER_TEST_DONT_OPEN_EXECUTOR, &m));
/* Set log overrides as well to make it harder for a serialization file
* to switch log levels/targets during fuzzing */
manager_override_log_level(m, log_get_max_level());
manager_override_log_target(m, log_get_target());
assert_se(null = fopen("/dev/null", "we"));
assert_se(fdset = fdset_new());
assert_se(f = data_to_file(data, size));
null = ASSERT_NOT_NULL(fopen("/dev/null", "we"));
fdset = ASSERT_NOT_NULL(fdset_new());
f = ASSERT_NOT_NULL(data_to_file(data, size));
(void) manager_deserialize(m, f, fdset);
(void) manager_serialize(m, null, fdset, /* switching_root= */ true);
src/core/fuzz-unit-file.c
+7 -8
View File
@@ -8,6 +8,7 @@
#include "manager-dump.h"
#include "memstream-util.h"
#include "string-util.h"
#include "tests.h"
#include "unit-serialize.h"
#include "utf8.h"
@@ -23,9 +24,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
if (outside_size_range(size, /* lower= */ 0, 65536))
return 0;
f = data_to_file(data, size);
assert_se(f);
f = ASSERT_NOT_NULL(data_to_file(data, size));
if (read_line(f, LINE_MAX, &p) < 0)
return 0;
@@ -38,7 +37,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
return 0;
offset = ftell(f);
assert_se(offset >= 0);
ASSERT_OK(offset);
for (;;) {
_cleanup_free_ char *l = NULL;
@@ -58,14 +57,14 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
}
}
assert_se(fseek(f, offset, SEEK_SET) == 0);
ASSERT_EQ(fseek(f, offset, SEEK_SET), 0);
fuzz_setup_logging();
assert_se(manager_new(RUNTIME_SCOPE_SYSTEM, MANAGER_TEST_RUN_MINIMAL|MANAGER_TEST_DONT_OPEN_EXECUTOR, &m) >= 0);
ASSERT_OK(manager_new(RUNTIME_SCOPE_SYSTEM, MANAGER_TEST_RUN_MINIMAL|MANAGER_TEST_DONT_OPEN_EXECUTOR, &m));
name = strjoina("a.", unit_type_to_string(t));
assert_se(unit_new_for_name(m, unit_vtable[t]->object_size, name, &u) >= 0);
ASSERT_OK(unit_new_for_name(m, unit_vtable[t]->object_size, name, &u));
(void) config_parse(
name, name, f,
@@ -78,7 +77,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(memstream_done) MemStream ms = {};
FILE *g;
assert_se(g = memstream_init(&ms));
g = ASSERT_NOT_NULL(memstream_init(&ms));
unit_dump(u, g, "");
manager_dump(m, g, /* patterns= */ NULL, ">>>");
src/fuzz/fuzz-bootspec.c
+8 -7
View File
@@ -12,6 +12,7 @@
#include "fuzz.h"
#include "json-util.h"
#include "strv.h"
#include "tests.h"
static int json_dispatch_config(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
BootConfig *config = ASSERT_PTR(userdata);
@@ -21,7 +22,7 @@ static int json_dispatch_config(const char *name, sd_json_variant *variant, sd_j
return -EINVAL;
_cleanup_fclose_ FILE *f = NULL;
assert_se(f = data_to_file((const uint8_t*) s, strlen(s)));
f = ASSERT_NOT_NULL(data_to_file((const uint8_t*) s, strlen(s)));
(void) boot_loader_read_conf(config, f, "memstream");
return 0;
@@ -54,9 +55,9 @@ static int json_dispatch_entries(const char *name, sd_json_variant *variant, sd_
len = cunescape(raw, UNESCAPE_RELAX | UNESCAPE_ACCEPT_NUL, &data);
if (len >= 0) {
_cleanup_fclose_ FILE *f = NULL;
assert_se(f = data_to_file((const uint8_t*) data, len));
f = ASSERT_NOT_NULL(data_to_file((const uint8_t*) data, len));
assert_se(boot_config_load_type1(config, f, "/", BOOT_ENTRY_ESP, "/entries", id) != -ENOMEM);
ASSERT_NE(boot_config_load_type1(config, f, "/", BOOT_ENTRY_ESP, "/entries", id), -ENOMEM);
}
}
@@ -93,7 +94,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(datadup = memdup_suffix0(data, size));
datadup = ASSERT_NOT_NULL(memdup_suffix0(data, size));
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = sd_json_parse(datadup, /* flags= */ 0, &v, /* reterr_line= */ NULL, /* reterr_column= */ NULL);
@@ -104,7 +105,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
if (r < 0)
return 0;
assert_se(boot_config_finalize(&config) >= 0);
ASSERT_OK(boot_config_finalize(&config));
(void) boot_config_select_special_entries(&config, /* skip_efivars= */ false);
@@ -114,14 +115,14 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
if (orig_stdout_fd < 0)
log_warning_errno(errno, "Failed to duplicate fd 1, ignoring: %m");
else
assert_se(freopen("/dev/null", "w", stdout));
ASSERT_NOT_NULL(freopen("/dev/null", "w", stdout));
}
(void) show_boot_entries(&config, SD_JSON_FORMAT_OFF);
(void) show_boot_entries(&config, SD_JSON_FORMAT_PRETTY);
if (orig_stdout_fd >= 0)
assert_se(freopen(FORMAT_PROC_FD_PATH(orig_stdout_fd), "w", stdout));
ASSERT_NOT_NULL(freopen(FORMAT_PROC_FD_PATH(orig_stdout_fd), "w", stdout));
return 0;
}
src/fuzz/fuzz-bus-label.c
+3 -2
View File
@@ -3,6 +3,7 @@
#include "alloc-util.h"
#include "bus-label.h"
#include "fuzz.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_free_ char *unescaped = NULL, *escaped = NULL;
@@ -10,9 +11,9 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
unescaped = bus_label_unescape_n((const char*)data, size);
assert_se(unescaped != NULL);
ASSERT_NOT_NULL(unescaped);
escaped = bus_label_escape(unescaped);
assert_se(escaped != NULL);
ASSERT_NOT_NULL(escaped);
return 0;
}
src/fuzz/fuzz-calendarspec.c
+6 -5
View File
@@ -4,6 +4,7 @@
#include "calendarspec.h"
#include "fuzz.h"
#include "string-util.h"
#include "tests.h"
#include "time-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -13,7 +14,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(str = memdup_suffix0(data, size));
str = ASSERT_NOT_NULL(memdup_suffix0(data, size));
size_t l1 = strlen(str);
const char* usecs = l1 < size ? str + l1 + 1 : "";
@@ -25,15 +26,15 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
}
_cleanup_free_ char *p = NULL;
assert_se(calendar_spec_valid(cspec));
assert_se(calendar_spec_to_string(cspec, &p) == 0);
ASSERT_TRUE(calendar_spec_valid(cspec));
ASSERT_OK_ZERO(calendar_spec_to_string(cspec, &p));
assert(p);
log_debug("spec: %s → %s", str, p);
_cleanup_(calendar_spec_freep) CalendarSpec *cspec2 = NULL;
assert_se(calendar_spec_from_string(p, &cspec2) >= 0);
assert_se(calendar_spec_valid(cspec2));
ASSERT_OK(calendar_spec_from_string(p, &cspec2));
ASSERT_TRUE(calendar_spec_valid(cspec2));
usec_t usec = 0;
(void) parse_time(usecs, &usec, 1);
src/fuzz/fuzz-catalog.c
+3 -2
View File
@@ -6,6 +6,7 @@
#include "fd-util.h"
#include "fuzz.h"
#include "hashmap.h"
#include "tests.h"
#include "tmpfile-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -16,8 +17,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
fd = mkostemp_safe(name);
assert_se(fd >= 0);
assert_se(write(fd, data, size) == (ssize_t) size);
ASSERT_OK(fd);
ASSERT_EQ(write(fd, data, size), (ssize_t) size);
(void) catalog_import_file(&h, fd, name);
src/fuzz/fuzz-env-file.c
+3 -2
View File
@@ -6,6 +6,7 @@
#include "fd-util.h"
#include "fuzz.h"
#include "strv.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_fclose_ FILE *f = NULL;
@@ -15,12 +16,12 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
return 0;
f = data_to_file(data, size);
assert_se(f);
ASSERT_NOT_NULL(f);
fuzz_setup_logging();
(void) load_env_file(f, /* fname= */ NULL, &rl);
assert_se(fseek(f, 0, SEEK_SET) == 0);
ASSERT_EQ(fseek(f, 0, SEEK_SET), 0);
(void) load_env_file_pairs(f, /* fname= */ NULL, &rlp);
return 0;
src/fuzz/fuzz-hostname-setup.c
+2 -1
View File
@@ -4,13 +4,14 @@
#include "fd-util.h"
#include "fuzz.h"
#include "hostname-setup.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *ret = NULL;
f = data_to_file(data, size);
assert_se(f);
ASSERT_NOT_NULL(f);
fuzz_setup_logging();
src/fuzz/fuzz-json.c
+9 -8
View File
@@ -7,6 +7,7 @@
#include "fuzz.h"
#include "memstream-util.h"
#include "string-util.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(memstream_done) MemStream m = {};
@@ -18,7 +19,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
f = data_to_file(data, size);
assert_se(f);
ASSERT_NOT_NULL(f);
r = sd_json_parse_file(f, /* path= */ NULL, /* flags= */ 0, &v, /* reterr_line= */ NULL, /* reterr_column= */ NULL);
if (r < 0) {
@@ -27,7 +28,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
}
if (getenv_bool("SYSTEMD_FUZZ_OUTPUT") <= 0)
assert_se(g = memstream_init(&m));
g = ASSERT_NOT_NULL(memstream_init(&m));
sd_json_variant_dump(v, /* flags= */ 0, g ?: stdout, /* prefix= */ NULL);
sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_SOURCE, g ?: stdout, /* prefix= */ NULL);
@@ -40,7 +41,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
sorted = sd_json_variant_is_sorted(v);
log_debug("json_variant_is_sorted: %s", yes_no(sorted));
assert_se(r < 0 || sorted);
ASSERT_TRUE(r < 0 || sorted);
bool normalized = sd_json_variant_is_normalized(v);
log_debug("json_variant_is_normalized: %s", yes_no(normalized));
@@ -50,7 +51,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
normalized = sd_json_variant_is_normalized(v);
log_debug("json_variant_is_normalized: %s", yes_no(normalized));
assert_se(r < 0 || normalized);
ASSERT_TRUE(r < 0 || normalized);
double real = sd_json_variant_real(v);
log_debug("json_variant_real: %lf", real);
@@ -70,9 +71,9 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
for (size_t i = 0; i <= elements + 2; i++)
(void) sd_json_variant_by_index(v, i);
assert_se(sd_json_variant_equal(v, v));
assert_se(!sd_json_variant_equal(v, NULL));
assert_se(!sd_json_variant_equal(NULL, v));
ASSERT_TRUE(sd_json_variant_equal(v, v));
ASSERT_FALSE(sd_json_variant_equal(v, NULL));
ASSERT_FALSE(sd_json_variant_equal(NULL, v));
bool sensitive = sd_json_variant_is_sensitive(v);
log_debug("json_variant_is_sensitive: %s", yes_no(sensitive));
@@ -84,7 +85,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
const char *source;
unsigned line, column;
assert_se(sd_json_variant_get_source(v, &source, &line, &column) == 0);
ASSERT_OK_ZERO(sd_json_variant_get_source(v, &source, &line, &column));
log_debug("json_variant_get_source: %s:%u:%u", source ?: "-", line, column);
r = sd_json_variant_set_field_string(&v, "a", "string-a");
src/fuzz/fuzz-time-util.c
+2 -1
View File
@@ -2,6 +2,7 @@
#include "alloc-util.h"
#include "fuzz.h"
#include "tests.h"
#include "time-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -10,7 +11,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(str = memdup_suffix0(data, size));
str = ASSERT_NOT_NULL(memdup_suffix0(data, size));
(void) parse_timestamp(str, &usec);
(void) parse_sec(str, &usec);
src/fuzz/fuzz-udev-database.c
+4 -3
View File
@@ -4,6 +4,7 @@
#include "device-private.h"
#include "fd-util.h"
#include "fuzz.h"
#include "tests.h"
#include "tmpfile-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -13,12 +14,12 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(fmkostemp_safe(filename, "r+", &f) == 0);
ASSERT_OK_ZERO(fmkostemp_safe(filename, "r+", &f));
if (size != 0)
assert_se(fwrite(data, size, 1, f) == 1);
ASSERT_EQ(fwrite(data, size, 1, f), (size_t) 1);
fflush(f);
assert_se(device_new_aux(&dev) >= 0);
ASSERT_OK(device_new_aux(&dev));
(void) device_read_db_internal_filename(dev, filename);
return 0;
}
src/fuzz/fuzz-user-record.c
+3 -2
View File
@@ -4,6 +4,7 @@
#include "alloc-util.h"
#include "fuzz.h"
#include "tests.h"
#include "user-record.h"
#include "sd-json.h"
@@ -18,8 +19,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
if (outside_size_range(size, /* lower= */ 0, 65536))
return 0;
assert_se(str = memdup_suffix0(data, size));
assert_se(ur = user_record_new());
str = ASSERT_NOT_NULL(memdup_suffix0(data, size));
ur = ASSERT_NOT_NULL(user_record_new());
fuzz_setup_logging();
src/fuzz/fuzz-varlink-idl.c
+3 -2
View File
@@ -5,6 +5,7 @@
#include "alloc-util.h"
#include "fuzz.h"
#include "log.h"
#include "tests.h"
#include "varlink-idl-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -17,7 +18,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(str = memdup_suffix0(data, size));
str = ASSERT_NOT_NULL(memdup_suffix0(data, size));
r = sd_varlink_idl_parse(str, /* reterr_line= */ NULL, /* reterr_column= */ NULL, &vi);
if (r < 0) {
@@ -25,7 +26,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
return 0;
}
assert_se(sd_varlink_idl_format(vi, &dump) >= 0);
ASSERT_OK(sd_varlink_idl_format(vi, &dump));
(void) varlink_idl_consistent(vi, LOG_DEBUG);
return 0;
src/fuzz/fuzz-varlink.c
+26 -25
View File
@@ -7,8 +7,9 @@
#include "errno-util.h"
#include "fd-util.h"
#include "fuzz.h"
#include "hexdecoct.h"
#include "hexdump.h"
#include "iovec-util.h"
#include "tests.h"
static FILE *null = NULL;
@@ -39,7 +40,7 @@ static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userd
if (ERRNO_IS_DISCONNECT(errno))
write_eof = true;
else
assert_se(errno == EAGAIN);
ASSERT_EQ(errno, EAGAIN);
} else
iovec_inc(iov, n);
}
@@ -53,7 +54,7 @@ static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userd
if (ERRNO_IS_DISCONNECT(errno))
read_eof = true;
else
assert_se(errno == EAGAIN);
ASSERT_EQ(errno, EAGAIN);
} else if (n == 0)
read_eof = true;
else
@@ -65,9 +66,9 @@ static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userd
if (write_eof || iov->iov_len == 0) {
if (read_eof)
assert_se(sd_event_source_set_enabled(s, SD_EVENT_OFF) >= 0);
ASSERT_OK(sd_event_source_set_enabled(s, SD_EVENT_OFF));
else
assert_se(sd_event_source_set_io_events(s, EPOLLIN) >= 0);
ASSERT_OK(sd_event_source_set_io_events(s, EPOLLIN));
}
return 0;
@@ -94,35 +95,35 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(null = fopen("/dev/null", "we"));
null = ASSERT_NOT_NULL(fopen("/dev/null", "we"));
assert_se(sd_event_default(&e) >= 0);
ASSERT_OK(sd_event_default(&e));
/* Test one: write the data as method call to a server */
assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, server_pair) >= 0);
assert_se(sd_varlink_server_new(&s, /* flags= */ 0) >= 0);
assert_se(sd_varlink_server_set_info(s, "Vendor", "Product", "Version", "URL") >= 0);
assert_se(sd_varlink_server_set_description(s, "myserver") >= 0);
assert_se(sd_varlink_server_attach_event(s, e, /* priority= */ 0) >= 0);
assert_se(sd_varlink_server_add_connection(s, server_pair[0], /* ret= */ NULL) >= 0);
ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, server_pair));
ASSERT_OK(sd_varlink_server_new(&s, /* flags= */ 0));
ASSERT_OK(sd_varlink_server_set_info(s, "Vendor", "Product", "Version", "URL"));
ASSERT_OK(sd_varlink_server_set_description(s, "myserver"));
ASSERT_OK(sd_varlink_server_attach_event(s, e, /* priority= */ 0));
ASSERT_OK(sd_varlink_server_add_connection(s, server_pair[0], /* ret= */ NULL));
TAKE_FD(server_pair[0]);
assert_se(sd_varlink_server_bind_method(s, "io.test.DoSomething", method_something) >= 0);
assert_se(sd_event_add_io(e, &server_event_source, server_pair[1], EPOLLIN|EPOLLOUT, io_callback, &server_iov) >= 0);
ASSERT_OK(sd_varlink_server_bind_method(s, "io.test.DoSomething", method_something));
ASSERT_OK(sd_event_add_io(e, &server_event_source, server_pair[1], EPOLLIN|EPOLLOUT, io_callback, &server_iov));
/* Test two: write the data as method response to a client */
assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, client_pair) >= 0);
assert_se(sd_varlink_connect_fd(&c, client_pair[0]) >= 0);
ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, client_pair));
ASSERT_OK(sd_varlink_connect_fd(&c, client_pair[0]));
TAKE_FD(client_pair[0]);
assert_se(sd_varlink_set_description(c, "myclient") >= 0);
assert_se(sd_varlink_attach_event(c, e, /* priority= */ 0) >= 0);
assert_se(sd_varlink_bind_reply(c, reply_callback) >= 0);
assert_se(sd_varlink_invoke(c, "io.test.DoSomething", /* parameters= */ NULL) >= 0);
assert_se(sd_event_add_io(e, &client_event_source, client_pair[1], EPOLLIN|EPOLLOUT, io_callback, &client_iov) >= 0);
ASSERT_OK(sd_varlink_set_description(c, "myclient"));
ASSERT_OK(sd_varlink_attach_event(c, e, /* priority= */ 0));
ASSERT_OK(sd_varlink_bind_reply(c, reply_callback));
ASSERT_OK(sd_varlink_invoke(c, "io.test.DoSomething", /* parameters= */ NULL));
ASSERT_OK(sd_event_add_io(e, &client_event_source, client_pair[1], EPOLLIN|EPOLLOUT, io_callback, &client_iov));
assert_se(sd_event_add_defer(e, &idle_event_source, idle_callback, /* userdata= */ NULL) >= 0);
assert_se(sd_event_source_set_priority(idle_event_source, SD_EVENT_PRIORITY_IDLE) >= 0);
ASSERT_OK(sd_event_add_defer(e, &idle_event_source, idle_callback, /* userdata= */ NULL));
ASSERT_OK(sd_event_source_set_priority(idle_event_source, SD_EVENT_PRIORITY_IDLE));
assert_se(sd_event_loop(e) >= 0);
ASSERT_OK(sd_event_loop(e));
null = safe_fclose(null);
src/journal-remote/fuzz-journal-remote.c
+6 -6
View File
@@ -34,8 +34,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(mkdtemp_malloc("/tmp/fuzz-journal-remote-XXXXXX", &tmp) >= 0);
assert_se(name = path_join(tmp, "fuzz-journal-remote.XXXXXX.journal"));
ASSERT_OK(mkdtemp_malloc("/tmp/fuzz-journal-remote-XXXXXX", &tmp));
name = ASSERT_NOT_NULL(path_join(tmp, "fuzz-journal-remote.XXXXXX.journal"));
fdin = fdin_close = memfd_new_and_seal("fuzz-journal-remote", data, size);
if (fdin < 0)
@@ -49,7 +49,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
r = journal_remote_server_init(&s, name, JOURNAL_WRITE_SPLIT_NONE, /* file_flags= */ 0);
if (r < 0) {
assert_se(IN_SET(r, -ENOMEM, -EMFILE, -ENFILE));
ASSERT_TRUE(IN_SET(r, -ENOMEM, -EMFILE, -ENFILE));
return r;
}
@@ -57,19 +57,19 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
TAKE_FD(fdin_close);
if (size % 3 == 2)
assert_se(s.sources[fdin]->client_certificate_subject = strdup(REMOTE_CERTIFICATE_SUBJECT_FIELD "CN=fuzz"));
s.sources[fdin]->client_certificate_subject = ASSERT_NOT_NULL(strdup(REMOTE_CERTIFICATE_SUBJECT_FIELD "CN=fuzz"));
while (s.active)
ASSERT_OK(journal_remote_handle_raw_source(/* event= */ NULL, fdin, /* revents= */ 0, &s));
assert_se(close(fdin) < 0 && errno == EBADF); /* Check that the fd is closed already */
ASSERT_ERROR_ERRNO(close(fdin), EBADF); /* Check that the fd is closed already */
/* Out */
r = sd_journal_open_files(&j, (const char**) STRV_MAKE(name), SD_JOURNAL_ASSUME_IMMUTABLE);
if (r < 0) {
log_error_errno(r, "sd_journal_open_files([\"%s\"]) failed: %m", name);
assert_se(IN_SET(r, -ENOMEM, -EMFILE, -ENFILE, -ENODATA));
ASSERT_TRUE(IN_SET(r, -ENOMEM, -EMFILE, -ENFILE, -ENODATA));
return r;
}
src/journal/fuzz-journald-native-fd.c
+5 -4
View File
@@ -8,6 +8,7 @@
#include "journald-native.h"
#include "memfd-util.h"
#include "process-util.h"
#include "tests.h"
#include "tmpfile-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -22,7 +23,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
dummy_manager_new(&m, /* buffer= */ NULL, /* size= */ 0);
sealed_fd = memfd_new_and_seal(/* name= */ NULL, data, size);
assert_se(sealed_fd >= 0);
ASSERT_OK(sealed_fd);
ucred = (struct ucred) {
.pid = getpid_cached(),
.uid = geteuid(),
@@ -31,9 +32,9 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
(void) manager_process_native_file(m, sealed_fd, &ucred, tv, /* label= */ NULL);
unsealed_fd = mkostemp_safe(name);
assert_se(unsealed_fd >= 0);
assert_se(write(unsealed_fd, data, size) == (ssize_t) size);
assert_se(lseek(unsealed_fd, 0, SEEK_SET) == 0);
ASSERT_OK(unsealed_fd);
ASSERT_EQ(write(unsealed_fd, data, size), (ssize_t) size);
ASSERT_OK_ZERO_ERRNO(lseek(unsealed_fd, 0, SEEK_SET));
(void) manager_process_native_file(m, unsealed_fd, &ucred, tv, /* label= */ NULL);
return 0;
src/libsystemd-network/fuzz-dhcp-client.c
+1 -1
View File
@@ -73,7 +73,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(iovw_done_free) struct iovec_wrapper iovw2 = {};
ASSERT_OK(dhcp_message_build(lease2->message, &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
}
}
src/libsystemd-network/fuzz-dhcp6-client.c
+27 -26
View File
@@ -9,6 +9,7 @@
#include "dhcp6-internal.h"
#include "fd-util.h"
#include "fuzz.h"
#include "tests.h"
static int test_dhcp_fd[2] = EBADF_PAIR;
@@ -17,38 +18,38 @@ int dhcp6_network_send_udp_socket(int s, const struct in6_addr *server_address,
}
int dhcp6_network_bind_udp_socket(int index, const struct in6_addr *local_address) {
assert_se(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_dhcp_fd) >= 0);
ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_dhcp_fd));
return TAKE_FD(test_dhcp_fd[0]);
}
static void fuzz_client(sd_dhcp6_client *client, const uint8_t *data, size_t size, DHCP6State state) {
assert_se(sd_dhcp6_client_set_information_request(client, state == DHCP6_STATE_INFORMATION_REQUEST) >= 0);
assert_se(sd_dhcp6_client_start(client) >= 0);
ASSERT_OK(sd_dhcp6_client_set_information_request(client, state == DHCP6_STATE_INFORMATION_REQUEST));
ASSERT_OK(sd_dhcp6_client_start(client));
client->state = state;
if (size >= sizeof(DHCP6Message))
assert_se(dhcp6_client_set_transaction_id(client, ((const DHCP6Message *) data)->transaction_id) == 0);
ASSERT_OK_ZERO(dhcp6_client_set_transaction_id(client, ((const DHCP6Message *) data)->transaction_id));
/* These states does not require lease to send message. */
if (IN_SET(client->state, DHCP6_STATE_INFORMATION_REQUEST, DHCP6_STATE_SOLICITATION))
assert_se(dhcp6_client_send_message(client) >= 0);
ASSERT_OK(dhcp6_client_send_message(client));
assert_se(write(test_dhcp_fd[1], data, size) == (ssize_t) size);
ASSERT_EQ(write(test_dhcp_fd[1], data, size), (ssize_t) size);
assert_se(sd_event_run(sd_dhcp6_client_get_event(client), UINT64_MAX) > 0);
ASSERT_OK_POSITIVE(sd_event_run(sd_dhcp6_client_get_event(client), UINT64_MAX));
/* Check the state transition. */
if (client->state != state)
switch (state) {
case DHCP6_STATE_INFORMATION_REQUEST:
assert_se(client->state == DHCP6_STATE_STOPPED);
ASSERT_EQ(client->state, DHCP6_STATE_STOPPED);
break;
case DHCP6_STATE_SOLICITATION:
assert_se(IN_SET(client->state, DHCP6_STATE_REQUEST, DHCP6_STATE_BOUND));
ASSERT_TRUE(IN_SET(client->state, DHCP6_STATE_REQUEST, DHCP6_STATE_BOUND));
break;
case DHCP6_STATE_REQUEST:
assert_se(IN_SET(client->state, DHCP6_STATE_BOUND, DHCP6_STATE_SOLICITATION));
ASSERT_TRUE(IN_SET(client->state, DHCP6_STATE_BOUND, DHCP6_STATE_SOLICITATION));
break;
default:
assert_not_reached();
@@ -60,7 +61,7 @@ static void fuzz_client(sd_dhcp6_client *client, const uint8_t *data, size_t siz
dhcp6_client_send_message(client);
}
assert_se(sd_dhcp6_client_stop(client) >= 0);
ASSERT_OK(sd_dhcp6_client_stop(client));
test_dhcp_fd[1] = safe_close(test_dhcp_fd[1]);
}
@@ -73,29 +74,29 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
struct in6_addr hint = { { { 0x3f, 0xfe, 0x05, 0x01, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } };
static const char *v1_data = "hogehoge", *v2_data = "foobar";
assert_se(setenv("SYSTEMD_NETWORK_TEST_MODE", "1", 1) >= 0);
ASSERT_OK(setenv("SYSTEMD_NETWORK_TEST_MODE", "1", 1));
fuzz_setup_logging();
if (outside_size_range(size, /* lower= */ 0, 65536))
return 0;
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_dhcp6_client_new(&client) >= 0);
assert_se(sd_dhcp6_client_attach_event(client, e, /* priority= */ 0) >= 0);
assert_se(sd_dhcp6_client_set_ifindex(client, 42) >= 0);
assert_se(sd_dhcp6_client_set_local_address(client, &address) >= 0);
ASSERT_OK(sd_event_new(&e));
ASSERT_OK(sd_dhcp6_client_new(&client));
ASSERT_OK(sd_dhcp6_client_attach_event(client, e, /* priority= */ 0));
ASSERT_OK(sd_dhcp6_client_set_ifindex(client, 42));
ASSERT_OK(sd_dhcp6_client_set_local_address(client, &address));
/* Used when sending message. */
assert_se(sd_dhcp6_client_set_fqdn(client, "example.com") == 1);
assert_se(sd_dhcp6_client_set_request_mud_url(client, "https://www.example.com/mudfile.json") >= 0);
assert_se(sd_dhcp6_client_set_request_user_class(client, STRV_MAKE("u1", "u2", "u3")) >= 0);
assert_se(sd_dhcp6_client_set_request_vendor_class(client, STRV_MAKE("v1", "v2", "v3")) >= 0);
assert_se(sd_dhcp6_client_set_prefix_delegation_hint(client, 48, &hint) >= 0);
assert_se(sd_dhcp6_option_new(123, v1_data, strlen(v1_data), 12345, &v1) >= 0);
assert_se(sd_dhcp6_option_new(456, v2_data, strlen(v2_data), 45678, &v2) >= 0);
assert_se(sd_dhcp6_client_add_vendor_option(client, v1) >= 0);
assert_se(sd_dhcp6_client_add_vendor_option(client, v2) >= 0);
ASSERT_EQ(sd_dhcp6_client_set_fqdn(client, "example.com"), 1);
ASSERT_OK(sd_dhcp6_client_set_request_mud_url(client, "https://www.example.com/mudfile.json"));
ASSERT_OK(sd_dhcp6_client_set_request_user_class(client, STRV_MAKE("u1", "u2", "u3")));
ASSERT_OK(sd_dhcp6_client_set_request_vendor_class(client, STRV_MAKE("v1", "v2", "v3")));
ASSERT_OK(sd_dhcp6_client_set_prefix_delegation_hint(client, 48, &hint));
ASSERT_OK(sd_dhcp6_option_new(123, v1_data, strlen(v1_data), 12345, &v1));
ASSERT_OK(sd_dhcp6_option_new(456, v2_data, strlen(v2_data), 45678, &v2));
ASSERT_OK(sd_dhcp6_client_add_vendor_option(client, v1));
ASSERT_OK(sd_dhcp6_client_add_vendor_option(client, v2));
fuzz_client(client, data, size, DHCP6_STATE_INFORMATION_REQUEST);
fuzz_client(client, data, size, DHCP6_STATE_SOLICITATION);
src/libsystemd-network/fuzz-lldp-rx.c
+12 -11
View File
@@ -12,6 +12,7 @@
#include "lldp-network.h"
#include "lldp-rx-internal.h"
#include "memstream-util.h"
#include "tests.h"
static int test_fd[2] = EBADF_PAIR;
@@ -34,21 +35,21 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(sd_event_new(&e) == 0);
assert_se(sd_lldp_rx_new(&lldp_rx) >= 0);
assert_se(sd_lldp_rx_set_ifindex(lldp_rx, 42) >= 0);
assert_se(sd_lldp_rx_attach_event(lldp_rx, e, /* priority= */ 0) >= 0);
assert_se(sd_lldp_rx_start(lldp_rx) >= 0);
ASSERT_OK_ZERO(sd_event_new(&e));
ASSERT_OK(sd_lldp_rx_new(&lldp_rx));
ASSERT_OK(sd_lldp_rx_set_ifindex(lldp_rx, 42));
ASSERT_OK(sd_lldp_rx_attach_event(lldp_rx, e, /* priority= */ 0));
ASSERT_OK(sd_lldp_rx_start(lldp_rx));
assert_se(write(test_fd[1], data, size) == (ssize_t) size);
assert_se(sd_event_run(e, /* timeout= */ 0) >= 0);
ASSERT_EQ(write(test_fd[1], data, size), (ssize_t) size);
ASSERT_OK(sd_event_run(e, /* timeout= */ 0));
assert_se(lldp_rx_build_neighbors_json(lldp_rx, &v) >= 0);
assert_se(f = memstream_init(&m));
ASSERT_OK(lldp_rx_build_neighbors_json(lldp_rx, &v));
f = ASSERT_NOT_NULL(memstream_init(&m));
(void) sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR, f, /* prefix= */ NULL);
assert_se(sd_lldp_rx_stop(lldp_rx) >= 0);
assert_se(sd_lldp_rx_detach_event(lldp_rx) >= 0);
ASSERT_OK(sd_lldp_rx_stop(lldp_rx));
ASSERT_OK(sd_lldp_rx_detach_event(lldp_rx));
test_fd[1] = safe_close(test_fd[1]);
return 0;
src/libsystemd-network/fuzz-ndisc-rs.c
+21 -20
View File
@@ -13,6 +13,7 @@
#include "icmp6-util.h"
#include "ndisc-option.h"
#include "set.h"
#include "tests.h"
static void test_with_sd_ndisc(const uint8_t *data, size_t size) {
struct ether_addr mac_addr = {
@@ -21,15 +22,15 @@ static void test_with_sd_ndisc(const uint8_t *data, size_t size) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_ndisc_new(&nd) >= 0);
assert_se(sd_ndisc_attach_event(nd, e, /* priority= */ 0) >= 0);
assert_se(sd_ndisc_set_ifindex(nd, 42) >= 0);
assert_se(sd_ndisc_set_mac(nd, &mac_addr) >= 0);
assert_se(sd_ndisc_start(nd) >= 0);
assert_se(write(test_fd[1], data, size) == (ssize_t) size);
ASSERT_OK(sd_event_new(&e));
ASSERT_OK(sd_ndisc_new(&nd));
ASSERT_OK(sd_ndisc_attach_event(nd, e, /* priority= */ 0));
ASSERT_OK(sd_ndisc_set_ifindex(nd, 42));
ASSERT_OK(sd_ndisc_set_mac(nd, &mac_addr));
ASSERT_OK(sd_ndisc_start(nd));
ASSERT_EQ(write(test_fd[1], data, size), (ssize_t) size);
(void) sd_event_run(e, UINT64_MAX);
assert_se(sd_ndisc_stop(nd) >= 0);
ASSERT_OK(sd_ndisc_stop(nd));
test_fd[1] = safe_close(test_fd[1]);
TAKE_FD(test_fd[0]); /* It should be already closed by sd_ndisc_stop(). */
}
@@ -41,17 +42,17 @@ static void test_with_sd_radv(const uint8_t *data, size_t size) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_radv_unrefp) sd_radv *ra = NULL;
assert_se(socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) >= 0);
ASSERT_OK(socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd));
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_radv_new(&ra) >= 0);
assert_se(sd_radv_attach_event(ra, e, /* priority= */ 0) >= 0);
assert_se(sd_radv_set_ifindex(ra, 42) >= 0);
assert_se(sd_radv_set_mac(ra, &mac_addr) >= 0);
assert_se(sd_radv_start(ra) >= 0);
assert_se(write(test_fd[0], data, size) == (ssize_t) size);
ASSERT_OK(sd_event_new(&e));
ASSERT_OK(sd_radv_new(&ra));
ASSERT_OK(sd_radv_attach_event(ra, e, /* priority= */ 0));
ASSERT_OK(sd_radv_set_ifindex(ra, 42));
ASSERT_OK(sd_radv_set_mac(ra, &mac_addr));
ASSERT_OK(sd_radv_start(ra));
ASSERT_EQ(write(test_fd[0], data, size), (ssize_t) size);
(void) sd_event_run(e, UINT64_MAX);
assert_se(sd_radv_stop(ra) >= 0);
ASSERT_OK(sd_radv_stop(ra));
test_fd[0] = safe_close(test_fd[0]);
TAKE_FD(test_fd[1]); /* It should be already closed by sd_radv_stop(). */
}
@@ -61,8 +62,8 @@ static void test_with_icmp6_packet(const uint8_t *data, size_t size) {
_cleanup_(icmp6_packet_unrefp) ICMP6Packet *packet = NULL;
_cleanup_set_free_ Set *options = NULL;
assert_se(socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, fd_pair) >= 0);
assert_se(write(fd_pair[1], data, size) == (ssize_t) size);
ASSERT_OK(socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, fd_pair));
ASSERT_EQ(write(fd_pair[1], data, size), (ssize_t) size);
if (icmp6_packet_receive(fd_pair[0], &packet) < 0)
return;
@@ -80,7 +81,7 @@ static void test_with_icmp6_packet(const uint8_t *data, size_t size) {
if (icmp6_packet_receive(fd_pair[0], &packet) < 0)
return;
assert_se(ndisc_parse_options(packet, &options) >= 0);
ASSERT_OK(ndisc_parse_options(packet, &options));
}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
src/libsystemd-network/test-dhcp-client.c
+3 -3
View File
@@ -246,7 +246,7 @@ static void create_reply(sd_dhcp_client *client, sd_dhcp_message *request, uint8
static void verify_header(sd_dhcp_message *m) {
ASSERT_EQ(m->header.op, BOOTREQUEST);
ASSERT_EQ(m->header.htype, ARPHRD_ETHER);
ASSERT_EQ(memcmp_nn(m->header.chaddr, m->header.hlen, hw_addr.bytes, hw_addr.length), 0);
ASSERT_MEMEQ_NN(m->header.chaddr, m->header.hlen, hw_addr.bytes, hw_addr.length);
}
static void verify_basic_options(sd_dhcp_message *m, uint8_t type) {
@@ -296,7 +296,7 @@ static void verify_request(sd_dhcp_message *m, uint8_t type) {
STRV_FOREACH(s, vendor_specific_strv) {
struct iovec v;
ASSERT_OK(tlv_get(vendor_specific, ++c, &v));
ASSERT_EQ(memcmp_nn(v.iov_base, v.iov_len, *s, strlen(*s)), 0);
ASSERT_MEMEQ_NN(v.iov_base, v.iov_len, *s, strlen(*s));
}
_cleanup_(iovw_done) struct iovec_wrapper iovw = {};
@@ -304,7 +304,7 @@ static void verify_request(sd_dhcp_message *m, uint8_t type) {
ASSERT_OK(iovw_put(&iovw, (void*) *s, strlen(*s)));
_cleanup_(iovw_done_free) struct iovec_wrapper user_class = {};
ASSERT_OK(dhcp_message_get_option_length_prefixed_data(m, SD_DHCP_OPTION_USER_CLASS, /* length_size= */ 1, &user_class));
ASSERT_TRUE(iovw_equal(&user_class, &iovw));
ASSERT_IOVW_EQ(&user_class, &iovw);
str = mfree(str);
ASSERT_OK(dhcp_message_get_option_string(m, 163, &str));
src/libsystemd-network/test-dhcp-message.c
+10 -13
View File
@@ -88,16 +88,14 @@ static void verify_addresses(
size_t n;
_cleanup_free_ struct in_addr *addrs = NULL;
ASSERT_OK(dhcp_message_get_option_addresses(m, SD_DHCP_OPTION_NTP_SERVER, &n, &addrs));
ASSERT_EQ(n, n_ntp);
ASSERT_EQ(memcmp(addrs, ntp, sizeof(struct in_addr) * n), 0);
ASSERT_MEMEQ_NN(addrs, sizeof(struct in_addr) * n, ntp, sizeof(struct in_addr) * n_ntp);
ASSERT_ERROR(dhcp_message_get_option_be32(m, SD_DHCP_OPTION_SIP_SERVER, /* ret= */ NULL), ENODATA);
ASSERT_ERROR(dhcp_message_get_option_address(m, SD_DHCP_OPTION_SIP_SERVER, /* ret= */ NULL), ENODATA);
addrs = mfree(addrs);
ASSERT_OK(dhcp_message_get_option_addresses(m, SD_DHCP_OPTION_SIP_SERVER, &n, &addrs));
ASSERT_EQ(n, n_sip);
ASSERT_EQ(memcmp(addrs, sip, sizeof(struct in_addr) * n), 0);
ASSERT_MEMEQ_NN(addrs, sizeof(struct in_addr) * n, sip, sizeof(struct in_addr) * n_sip);
}
static void verify_string(sd_dhcp_message *m, const char *expected) {
@@ -150,8 +148,7 @@ static void verify_6rd(
ASSERT_EQ(ipv4masklen, expected_ipv4masklen);
ASSERT_EQ(prefixlen, expected_prefixlen);
ASSERT_TRUE(in6_addr_equal(&prefix, expected_prefix));
ASSERT_EQ(n_br_addresses, expected_n_br_addresses);
ASSERT_EQ(memcmp(br_addresses, expected_br_addresses, sizeof(struct in_addr) * n_br_addresses), 0);
ASSERT_MEMEQ_NN(br_addresses, sizeof(struct in_addr) * n_br_addresses, expected_br_addresses, sizeof(struct in_addr) * expected_n_br_addresses);
}
static void verify_client_id(sd_dhcp_message *m, const sd_dhcp_client_id *expected) {
@@ -183,13 +180,13 @@ static void verify_sub_tlv(sd_dhcp_message *m, TLV *expected) {
_cleanup_(iovec_done) struct iovec iov = {}, iov_expected = {};
ASSERT_OK(tlv_build(tlv, &iov));
ASSERT_OK(tlv_build(expected, &iov_expected));
ASSERT_TRUE(iovec_equal(&iov, &iov_expected));
ASSERT_IOVEC_EQ(&iov, &iov_expected);
}
static void verify_length_prefixed_data(sd_dhcp_message *m, const struct iovec_wrapper *expected) {
_cleanup_(iovw_done_free) struct iovec_wrapper iovw = {};
ASSERT_OK(dhcp_message_get_option_length_prefixed_data(m, SD_DHCP_OPTION_USER_CLASS, 1, &iovw));
ASSERT_TRUE(iovw_equal(&iovw, expected));
ASSERT_IOVW_EQ(&iovw, expected);
}
static void verify_send_udp(sd_dhcp_message *message, uint32_t xid, const struct hw_addr_data *hw_addr) {
@@ -226,7 +223,7 @@ static void verify_send_udp(sd_dhcp_message *message, uint32_t xid, const struct
_cleanup_(iovw_done_free) struct iovec_wrapper iovw = {}, iovw2 = {};
ASSERT_OK(dhcp_message_build(message, &iovw));
ASSERT_OK(dhcp_message_build(m, &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
}
static void verify_send_raw(sd_dhcp_message *message, uint32_t xid, const struct hw_addr_data *hw_addr) {
@@ -277,7 +274,7 @@ static void verify_send_raw(sd_dhcp_message *message, uint32_t xid, const struct
_cleanup_(iovw_done_free) struct iovec_wrapper iovw = {}, iovw2 = {};
ASSERT_OK(dhcp_message_build(message, &iovw));
ASSERT_OK(dhcp_message_build(m, &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
}
TEST(dhcp_message) {
@@ -510,7 +507,7 @@ TEST(dhcp_message) {
&hw_addr,
&m2));
ASSERT_EQ(memcmp(&m2->header, &m->header, sizeof(m->header)), 0);
ASSERT_MEMEQ(&m2->header, &m->header, sizeof(m->header));
/* verify parsed message */
verify_header(m2, xid, &hw_addr);
@@ -533,7 +530,7 @@ TEST(dhcp_message) {
/* build again, and verify the packet */
_cleanup_(iovw_done_free) struct iovec_wrapper iovw2 = {};
ASSERT_OK(dhcp_message_build(m2, &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
/* json */
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
@@ -544,7 +541,7 @@ TEST(dhcp_message) {
_cleanup_(iovw_done_free) struct iovec_wrapper iovw3 = {};
ASSERT_OK(dhcp_message_build(m3, &iovw3));
ASSERT_TRUE(iovw_equal(&iovw, &iovw3));
ASSERT_IOVW_EQ(&iovw, &iovw3);
/* send */
verify_send_udp(m, xid, &hw_addr);
src/libsystemd-network/test-dhcp-relay.c
+5 -5
View File
@@ -123,13 +123,13 @@ static int fake_server_handler(sd_event_source *s, int fd, uint32_t revents, voi
switch (tag) {
case SD_DHCP_RELAY_AGENT_CIRCUIT_ID:
ASSERT_TRUE(iovec_equal(&iov, &downstream->circuit_id));
ASSERT_IOVEC_EQ(&iov, &downstream->circuit_id);
break;
case SD_DHCP_RELAY_AGENT_REMOTE_ID:
ASSERT_TRUE(iovec_equal(&iov, &relay->remote_id));
ASSERT_IOVEC_EQ(&iov, &relay->remote_id);
break;
case SD_DHCP_RELAY_AGENT_LINK_SELECTION:
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE(&downstream->address, sizeof(struct in_addr))));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE(&downstream->address, sizeof(struct in_addr)));
break;
case SD_DHCP_RELAY_AGENT_FLAGS: {
ASSERT_TRUE(relay->server_identifier_override);
@@ -142,10 +142,10 @@ static int fake_server_handler(sd_event_source *s, int fd, uint32_t revents, voi
}
case SD_DHCP_RELAY_AGENT_SERVER_IDENTIFIER_OVERRIDE:
ASSERT_TRUE(relay->server_identifier_override);
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE(&downstream->address, sizeof(struct in_addr))));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE(&downstream->address, sizeof(struct in_addr)));
break;
case SD_DHCP_RELAY_AGENT_VIRTUAL_SUBNET_SELECTION:
ASSERT_TRUE(iovec_equal(&iov, &downstream->vss));
ASSERT_IOVEC_EQ(&iov, &downstream->vss);
break;
default:
assert_not_reached();
src/libsystemd-network/test-dhcp6-client.c
+10 -10
View File
@@ -257,7 +257,7 @@ TEST(option) {
ASSERT_OK(dhcp6_option_append(&buf, &pos, optcode, optlen, optval));
ASSERT_EQ(memcmp(packet, buf, sizeof(packet)), 0);
ASSERT_MEMEQ(packet, buf, sizeof(packet));
}
TEST(option_status) {
@@ -906,7 +906,7 @@ static void test_client_verify_information_request(const DHCP6Message *msg, size
ASSERT_EQ(len, sizeof(msg_information_request));
/* The elapsed time value is not deterministic. Skip it. */
ASSERT_EQ(memcmp(msg, msg_information_request, len - sizeof(be16_t)), 0);
ASSERT_MEMEQ(msg, msg_information_request, len - sizeof(be16_t));
}
static void test_client_verify_solicit(const DHCP6Message *msg, size_t len) {
@@ -914,7 +914,7 @@ static void test_client_verify_solicit(const DHCP6Message *msg, size_t len) {
ASSERT_EQ(len, sizeof(msg_solicit));
/* The elapsed time value is not deterministic. Skip it. */
ASSERT_EQ(memcmp(msg, msg_solicit, len - sizeof(be16_t)), 0);
ASSERT_MEMEQ(msg, msg_solicit, len - sizeof(be16_t));
}
/* The FQDN set while the client is running, in the wire format. */
@@ -939,7 +939,7 @@ static void test_client_verify_solicit_with_new_fqdn(const DHCP6Message *msg, si
ASSERT_EQ(len, sizeof(expected));
/* The elapsed time value is not deterministic. Skip it. */
ASSERT_EQ(memcmp(msg, expected, len - sizeof(be16_t)), 0);
ASSERT_MEMEQ(msg, expected, len - sizeof(be16_t));
}
static void test_client_verify_renew_with_new_fqdn(const DHCP6Message *msg, size_t len) {
@@ -960,8 +960,8 @@ static void test_client_verify_release(const DHCP6Message *msg, size_t len) {
ASSERT_EQ(len, sizeof(msg_release));
ASSERT_EQ(msg->type, DHCP6_MESSAGE_RELEASE);
/* The transaction ID and elapsed time value are not deterministic. Skip them. */
ASSERT_EQ(memcmp(msg->options, msg_release + offsetof(DHCP6Message, options),
len - offsetof(DHCP6Message, options) - sizeof(be16_t)), 0);
ASSERT_MEMEQ(msg->options, msg_release + offsetof(DHCP6Message, options),
len - offsetof(DHCP6Message, options) - sizeof(be16_t));
}
static void test_client_verify_request(const DHCP6Message *msg, size_t len) {
@@ -970,8 +970,8 @@ static void test_client_verify_request(const DHCP6Message *msg, size_t len) {
ASSERT_EQ(len, sizeof(msg_request));
ASSERT_EQ(msg->type, DHCP6_MESSAGE_REQUEST);
/* The transaction ID and elapsed time value are not deterministic. Skip them. */
ASSERT_EQ(memcmp(msg->options, msg_request + offsetof(DHCP6Message, options),
len - offsetof(DHCP6Message, options) - sizeof(be16_t)), 0);
ASSERT_MEMEQ(msg->options, msg_request + offsetof(DHCP6Message, options),
len - offsetof(DHCP6Message, options) - sizeof(be16_t));
}
static void test_lease_common(sd_dhcp6_client *client) {
@@ -986,7 +986,7 @@ static void test_lease_common(sd_dhcp6_client *client) {
ASSERT_OK(sd_dhcp6_client_get_lease(client, &lease));
ASSERT_OK(dhcp6_lease_get_clientid(lease, &id, &len));
ASSERT_EQ(memcmp_nn(id, len, client_id, sizeof(client_id)), 0);
ASSERT_MEMEQ_NN(id, len, client_id, sizeof(client_id));
ASSERT_OK_EQ(sd_dhcp6_lease_get_domains(lease, &strv), 1);
ASSERT_STREQ(strv[0], "lab.intra");
@@ -1038,7 +1038,7 @@ static void test_lease_managed(sd_dhcp6_client *client) {
ASSERT_OK(sd_dhcp6_client_get_lease(client, &lease));
ASSERT_OK(dhcp6_lease_get_serverid(lease, &id, &len));
ASSERT_EQ(memcmp_nn(id, len, server_id, sizeof(server_id)), 0);
ASSERT_MEMEQ_NN(id, len, server_id, sizeof(server_id));
ASSERT_TRUE(sd_dhcp6_lease_has_address(lease));
ASSERT_TRUE(sd_dhcp6_lease_has_pd_prefix(lease));
src/libsystemd-network/test-ip-util.c
+7 -7
View File
@@ -65,17 +65,17 @@ TEST(udp_packet_build_and_verify) {
&ip2,
&udp2));
ASSERT_EQ(memcmp(&ip, &ip2, sizeof(struct iphdr)), 0);
ASSERT_EQ(memcmp(&udp, &udp2, sizeof(struct udphdr)), 0);
ASSERT_MEMEQ(&ip, &ip2, sizeof(struct iphdr));
ASSERT_MEMEQ(&udp, &udp2, sizeof(struct udphdr));
_cleanup_(iovec_done) struct iovec packet = {};
create_packet(&ip, &udp, &payload, &packet);
struct iovec iov;
ASSERT_OK(udp_packet_verify(&packet, /* port= */ 43, /* checksum= */ false, &iov));
ASSERT_TRUE(iovec_equal(&iov, &joined));
ASSERT_IOVEC_EQ(&iov, &joined);
ASSERT_OK(udp_packet_verify(&packet, /* port= */ 43, /* checksum= */ true, &iov));
ASSERT_TRUE(iovec_equal(&iov, &joined));
ASSERT_IOVEC_EQ(&iov, &joined);
/* UDP port mismatch */
ASSERT_ERROR(udp_packet_verify(&packet, /* port= */ 42, /* checksum= */ false, /* ret_payload= */ NULL), EBADMSG);
@@ -156,7 +156,7 @@ TEST(udp_packet_build_and_verify) {
iovec_done(&packet);
create_packet(&ip, &badudp, &payload, &packet);
ASSERT_OK(udp_packet_verify(&packet, /* port= */ 43, /* checksum= */ false, &iov));
ASSERT_TRUE(iovec_equal(&iov, &joined));
ASSERT_IOVEC_EQ(&iov, &joined);
ASSERT_ERROR(udp_packet_verify(&packet, /* port= */ 43, /* checksum= */ true, /* ret_payload= */ NULL), EBADMSG);
/* missing UDP checksum */
@@ -165,9 +165,9 @@ TEST(udp_packet_build_and_verify) {
iovec_done(&packet);
create_packet(&ip, &badudp, &payload, &packet);
ASSERT_OK(udp_packet_verify(&packet, /* port= */ 43, /* checksum= */ false, &iov));
ASSERT_TRUE(iovec_equal(&iov, &joined));
ASSERT_IOVEC_EQ(&iov, &joined);
ASSERT_OK(udp_packet_verify(&packet, /* port= */ 43, /* checksum= */ true, &iov));
ASSERT_TRUE(iovec_equal(&iov, &joined));
ASSERT_IOVEC_EQ(&iov, &joined);
}
DEFINE_TEST_MAIN(LOG_DEBUG);
src/libsystemd-network/test-lldp-rx.c
+4 -8
View File
@@ -114,13 +114,11 @@ static void test_receive_basic_packet(sd_event *e) {
ASSERT_OK_ZERO(sd_lldp_neighbor_get_chassis_id(neighbors[0], &type, &data, &length));
ASSERT_EQ(type, SD_LLDP_CHASSIS_SUBTYPE_MAC_ADDRESS);
ASSERT_EQ(length, (size_t) ETH_ALEN);
ASSERT_EQ(memcmp(data, "\x00\x01\x02\x03\x04\x05", ETH_ALEN), 0);
ASSERT_MEMEQ_NN(data, length, "\x00\x01\x02\x03\x04\x05", ETH_ALEN);
ASSERT_OK_ZERO(sd_lldp_neighbor_get_port_id(neighbors[0], &type, &data, &length));
ASSERT_EQ(type, SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME);
ASSERT_EQ(length, 3U);
ASSERT_EQ(memcmp(data, "1/3", 3), 0);
ASSERT_MEMEQ_NN(data, length, "1/3", 3);
ASSERT_OK_ZERO(sd_lldp_neighbor_get_port_description(neighbors[0], &str));
ASSERT_STREQ(str, "Port");
@@ -342,14 +340,12 @@ static void test_multiple_neighbors_sorted(sd_event *e) {
ASSERT_OK_ZERO(sd_lldp_neighbor_get_chassis_id(neighbors[i], &type, &data, &length));
ASSERT_EQ(type, SD_LLDP_CHASSIS_SUBTYPE_CHASSIS_COMPONENT);
expected_length = strlen(expected[2 * i]);
ASSERT_EQ(length, expected_length);
ASSERT_EQ(memcmp(data, expected[2 * i], expected_length), 0);
ASSERT_MEMEQ_NN(data, length, expected[2 * i], expected_length);
ASSERT_OK_ZERO(sd_lldp_neighbor_get_port_id(neighbors[i], &type, &data, &length));
ASSERT_EQ(type, SD_LLDP_PORT_SUBTYPE_PORT_COMPONENT);
expected_length = strlen(expected[2 * i + 1]);
ASSERT_EQ(length, expected_length);
ASSERT_EQ(memcmp(data, expected[2 * i + 1], expected_length), 0);
ASSERT_MEMEQ_NN(data, length, expected[2 * i + 1], expected_length);
ASSERT_OK_ZERO(sd_lldp_neighbor_get_ttl(neighbors[i], &ttl));
ASSERT_EQ(ttl, 120U);
src/libsystemd-network/test-tlv-util.c
+31 -31
View File
@@ -66,22 +66,22 @@ TEST(tlv) {
iovw = ASSERT_NOT_NULL(tlv_get_all(&tlv, 10));
ASSERT_EQ(iovw->count, 1u);
ASSERT_TRUE(iovec_equal(&iovw->iovec[0], &data0));
ASSERT_IOVEC_EQ(&iovw->iovec[0], &data0);
iovw = ASSERT_NOT_NULL(tlv_get_all(&tlv, 11));
ASSERT_EQ(iovw->count, 1u);
ASSERT_TRUE(iovec_equal(&iovw->iovec[0], &data1));
ASSERT_IOVEC_EQ(&iovw->iovec[0], &data1);
iovw = ASSERT_NOT_NULL(tlv_get_all(&tlv, 22));
ASSERT_EQ(iovw->count, 3u);
ASSERT_TRUE(iovec_equal(&iovw->iovec[0], &data2a));
ASSERT_TRUE(iovec_equal(&iovw->iovec[1], &IOVEC_MAKE(data2b.iov_base, UINT8_MAX)));
ASSERT_TRUE(iovec_equal(&iovw->iovec[2], &IOVEC_SHIFT(&data2b, UINT8_MAX)));
ASSERT_IOVEC_EQ(&iovw->iovec[0], &data2a);
ASSERT_IOVEC_EQ(&iovw->iovec[1], &IOVEC_MAKE(data2b.iov_base, UINT8_MAX));
ASSERT_IOVEC_EQ(&iovw->iovec[2], &IOVEC_SHIFT(&data2b, UINT8_MAX));
iovw = ASSERT_NOT_NULL(tlv_get_all(&tlv, 33));
ASSERT_EQ(iovw->count, 2u);
ASSERT_TRUE(iovec_equal(&iovw->iovec[0], &IOVEC_MAKE(data3.iov_base, UINT8_MAX)));
ASSERT_TRUE(iovec_equal(&iovw->iovec[1], &IOVEC_SHIFT(&data3, UINT8_MAX)));
ASSERT_IOVEC_EQ(&iovw->iovec[0], &IOVEC_MAKE(data3.iov_base, UINT8_MAX));
ASSERT_IOVEC_EQ(&iovw->iovec[1], &IOVEC_SHIFT(&data3, UINT8_MAX));
ASSERT_NULL(tlv_get_all(&tlv, 44));
@@ -89,34 +89,34 @@ TEST(tlv) {
struct iovec iov;
ASSERT_OK(tlv_get(&tlv, 10, &iov));
ASSERT_TRUE(iovec_equal(&iov, &data0));
ASSERT_IOVEC_EQ(&iov, &data0);
ASSERT_OK(tlv_get_full(&tlv, 10, data0.iov_len, &iov));
ASSERT_TRUE(iovec_equal(&iov, &data0));
ASSERT_IOVEC_EQ(&iov, &data0);
ASSERT_ERROR(tlv_get_full(&tlv, 10, 123, &iov), ENODATA);
ASSERT_OK(tlv_get(&tlv, 11, &iov));
ASSERT_TRUE(iovec_equal(&iov, &data1));
ASSERT_IOVEC_EQ(&iov, &data1);
ASSERT_OK(tlv_get_full(&tlv, 11, data1.iov_len, &iov));
ASSERT_TRUE(iovec_equal(&iov, &data1));
ASSERT_IOVEC_EQ(&iov, &data1);
ASSERT_ERROR(tlv_get_full(&tlv, 11, 123, &iov), ENODATA);
ASSERT_OK(tlv_get(&tlv, 22, &iov));
ASSERT_TRUE(iovec_equal(&iov, &data2a));
ASSERT_IOVEC_EQ(&iov, &data2a);
ASSERT_OK(tlv_get_full(&tlv, 22, data2a.iov_len, &iov));
ASSERT_TRUE(iovec_equal(&iov, &data2a));
ASSERT_IOVEC_EQ(&iov, &data2a);
ASSERT_ERROR(tlv_get_full(&tlv, 22, data2b.iov_len, &iov), ENODATA);
ASSERT_OK(tlv_get_full(&tlv, 22, UINT8_MAX, &iov));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE(data2b.iov_base, UINT8_MAX)));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE(data2b.iov_base, UINT8_MAX));
ASSERT_OK(tlv_get_full(&tlv, 22, data2b.iov_len - UINT8_MAX, &iov));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_SHIFT(&data2b, UINT8_MAX)));
ASSERT_IOVEC_EQ(&iov, &IOVEC_SHIFT(&data2b, UINT8_MAX));
ASSERT_OK(tlv_get(&tlv, 33, &iov));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE(data3.iov_base, UINT8_MAX)));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE(data3.iov_base, UINT8_MAX));
ASSERT_ERROR(tlv_get_full(&tlv, 33, data3.iov_len, &iov), ENODATA);
ASSERT_OK(tlv_get_full(&tlv, 33, UINT8_MAX, &iov));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE(data3.iov_base, UINT8_MAX)));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE(data3.iov_base, UINT8_MAX));
ASSERT_OK(tlv_get_full(&tlv, 33, data3.iov_len - UINT8_MAX, &iov));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_SHIFT(&data3, UINT8_MAX)));
ASSERT_IOVEC_EQ(&iov, &IOVEC_SHIFT(&data3, UINT8_MAX));
ASSERT_ERROR(tlv_get(&tlv, 44, /* ret= */ NULL), ENODATA);
@@ -124,21 +124,21 @@ TEST(tlv) {
_cleanup_(iovec_done) struct iovec v = {};
ASSERT_OK(tlv_get_alloc(&tlv, 10, &v));
ASSERT_TRUE(iovec_equal(&v, &data0));
ASSERT_IOVEC_EQ(&v, &data0);
iovec_done(&v);
ASSERT_OK(tlv_get_alloc(&tlv, 11, &v));
ASSERT_TRUE(iovec_equal(&v, &data1));
ASSERT_IOVEC_EQ(&v, &data1);
iovec_done(&v);
ASSERT_OK(tlv_get_alloc(&tlv, 22, &v));
ASSERT_EQ(v.iov_len, data2a.iov_len + data2b.iov_len);
ASSERT_EQ(memcmp(v.iov_base, data2a.iov_base, data2a.iov_len), 0);
ASSERT_EQ(memcmp((uint8_t*) v.iov_base + data2a.iov_len, data2b.iov_base, data2b.iov_len), 0);
ASSERT_MEMEQ(v.iov_base, data2a.iov_base, data2a.iov_len);
ASSERT_MEMEQ((uint8_t*) v.iov_base + data2a.iov_len, data2b.iov_base, data2b.iov_len);
iovec_done(&v);
ASSERT_OK(tlv_get_alloc(&tlv, 33, &v));
ASSERT_TRUE(iovec_equal(&v, &data3));
ASSERT_IOVEC_EQ(&v, &data3);
iovec_done(&v);
ASSERT_ERROR(tlv_get_alloc(&tlv, 44, /* ret= */ NULL), ENODATA);
@@ -158,32 +158,32 @@ TEST(tlv) {
ASSERT_EQ(*p++, 11u);
ASSERT_EQ(*p++, data1.iov_len);
ASSERT_EQ(memcmp(p, data1.iov_base, data1.iov_len), 0);
ASSERT_MEMEQ(p, data1.iov_base, data1.iov_len);
p += data1.iov_len;
ASSERT_EQ(*p++, 22u);
ASSERT_EQ(*p++, data2a.iov_len);
ASSERT_EQ(memcmp(p, data2a.iov_base, data2a.iov_len), 0);
ASSERT_MEMEQ(p, data2a.iov_base, data2a.iov_len);
p += data2a.iov_len;
ASSERT_EQ(*p++, 22u);
ASSERT_EQ(*p++, UINT8_MAX);
ASSERT_EQ(memcmp(p, data2b.iov_base, UINT8_MAX), 0);
ASSERT_MEMEQ(p, data2b.iov_base, UINT8_MAX);
p += UINT8_MAX;
ASSERT_EQ(*p++, 22u);
ASSERT_EQ(*p++, data2b.iov_len - UINT8_MAX);
ASSERT_EQ(memcmp(p, (uint8_t*) data2b.iov_base + UINT8_MAX, data2b.iov_len - UINT8_MAX), 0);
ASSERT_MEMEQ(p, (uint8_t*) data2b.iov_base + UINT8_MAX, data2b.iov_len - UINT8_MAX);
p += data2b.iov_len - UINT8_MAX;
ASSERT_EQ(*p++, 33u);
ASSERT_EQ(*p++, UINT8_MAX);
ASSERT_EQ(memcmp(p, data3.iov_base, UINT8_MAX), 0);
ASSERT_MEMEQ(p, data3.iov_base, UINT8_MAX);
p += UINT8_MAX;
ASSERT_EQ(*p++, 33u);
ASSERT_EQ(*p++, data3.iov_len - UINT8_MAX);
ASSERT_EQ(memcmp(p, (uint8_t*) data3.iov_base + UINT8_MAX, data3.iov_len - UINT8_MAX), 0);
ASSERT_MEMEQ(p, (uint8_t*) data3.iov_base + UINT8_MAX, data3.iov_len - UINT8_MAX);
p += data3.iov_len - UINT8_MAX;
ASSERT_EQ(*p, 255u);
@@ -195,13 +195,13 @@ TEST(tlv) {
void *tagp;
HASHMAP_FOREACH_KEY(iovw, tagp, tlv.entries) {
struct iovec_wrapper *iovw2 = ASSERT_PTR(hashmap_get(tlv2->entries, tagp));
ASSERT_TRUE(iovw_equal(iovw, iovw2));
ASSERT_IOVW_EQ(iovw, iovw2);
}
/* tlv_build() again, and check the reproducibility. */
_cleanup_(iovec_done) struct iovec v2 = {};
ASSERT_OK(tlv_build(tlv2, &v2));
ASSERT_TRUE(iovec_equal(&v, &v2));
ASSERT_IOVEC_EQ(&v, &v2);
}
DEFINE_TEST_MAIN(LOG_DEBUG);
src/libsystemd/sd-bus/fuzz-bus-match.c
+4 -3
View File
@@ -8,6 +8,7 @@
#include "env-util.h"
#include "fuzz.h"
#include "memstream-util.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(memstream_done) MemStream m = {};
@@ -21,7 +22,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
r = sd_bus_new(&bus);
assert_se(r >= 0);
ASSERT_OK(r);
_cleanup_(bus_match_free) BusMatchNode root = {
.type = BUS_MATCH_ROOT,
@@ -35,7 +36,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
};
if (getenv_bool("SYSTEMD_FUZZ_OUTPUT") <= 0)
assert_se(g = memstream_init(&m));
g = ASSERT_NOT_NULL(memstream_init(&m));
for (size_t offset = 0; offset < size; ) {
_cleanup_free_ char *line = NULL;
@@ -57,7 +58,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
log_debug_errno(r, "Failed to parse line: %m");
continue;
}
assert_se(r >= 0); /* We only expect EINVAL and ENOMEM errors, or success. */
ASSERT_OK(r); /* We only expect EINVAL and ENOMEM errors, or success. */
CLEANUP_ARRAY(components, n_components, bus_match_parse_free);
src/libsystemd/sd-bus/fuzz-bus-message.c
+6 -5
View File
@@ -7,6 +7,7 @@
#include "env-util.h"
#include "fuzz.h"
#include "memstream-util.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(memstream_done) MemStream ms = {};
@@ -19,18 +20,18 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
r = sd_bus_new(&bus);
assert_se(r >= 0);
ASSERT_OK(r);
assert_se(buffer = memdup(data, size));
buffer = ASSERT_NOT_NULL(memdup(data, size));
r = bus_message_from_malloc(bus, buffer, size, /* fds= */ NULL, /* n_fds= */ 0, /* got_ctrunc= */ false, /* label= */ NULL, &m);
if (r == -EBADMSG)
return 0;
assert_se(r >= 0);
ASSERT_OK(r);
TAKE_PTR(buffer);
if (getenv_bool("SYSTEMD_FUZZ_OUTPUT") <= 0)
assert_se(g = memstream_init(&ms));
g = ASSERT_NOT_NULL(memstream_init(&ms));
(void) sd_bus_message_dump(m, g, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
@@ -39,7 +40,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
(void) sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY | SD_JSON_FORMAT_COLOR_AUTO, g, /* prefix= */ NULL);
r = sd_bus_message_rewind(m, /* complete= */ true);
assert_se(r >= 0);
ASSERT_OK(r);
return 0;
}
src/libsystemd/sd-bus/test-bus-marshal.c
+3 -6
View File
@@ -455,8 +455,7 @@ int main(int argc, char *argv[]) {
ASSERT_NOT_NULL(mf = memstream_init(&ms));
sd_bus_message_dump(m, mf, /* flags= */ 0);
ASSERT_OK(memstream_finalize(&ms, &second, &second_size));
ASSERT_EQ(first_size, second_size);
ASSERT_EQ(memcmp(first, second, first_size), 0);
ASSERT_MEMEQ_NN(first, first_size, second, second_size);
ASSERT_OK(sd_bus_message_rewind(m, /* complete= */ true));
@@ -516,8 +515,7 @@ int main(int argc, char *argv[]) {
ASSERT_STREQ(s, "hallo");
ASSERT_OK_POSITIVE(sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz));
ASSERT_EQ(sz, sizeof(integer_array));
ASSERT_EQ(memcmp(integer_array, return_array, sz), 0);
ASSERT_MEMEQ_NN(integer_array, sizeof(integer_array), return_array, sz);
ASSERT_OK_POSITIVE(sd_bus_message_read_array(m, 'u', (const void**) &return_array, &sz));
ASSERT_EQ(sz, 0U);
@@ -545,8 +543,7 @@ int main(int argc, char *argv[]) {
printf("<%.*s>\n", (int) first_size, first);
printf("<%.*s>\n", (int) third_size, third);
ASSERT_EQ(first_size, third_size);
ASSERT_EQ(memcmp(first, third, third_size), 0);
ASSERT_MEMEQ_NN(first, first_size, third, third_size);
ASSERT_OK(sd_bus_message_rewind(m, /* complete= */ true));
src/libsystemd/sd-future/test-fiber-io.c
+3 -3
View File
@@ -378,9 +378,9 @@ static int file_position_fiber(void *userdata) {
ASSERT_OK_ZERO_ERRNO(lseek(fd, 0, SEEK_SET));
ASSERT_OK_EQ(sd_fiber_read(fd, buf, sizeof(buf)), (ssize_t) sizeof(buf));
ASSERT_EQ(memcmp(buf, "abc", sizeof(buf)), 0);
ASSERT_MEMEQ(buf, "abc", sizeof(buf));
ASSERT_OK_EQ(sd_fiber_read(fd, buf, sizeof(buf)), (ssize_t) sizeof(buf));
ASSERT_EQ(memcmp(buf, "def", sizeof(buf)), 0);
ASSERT_MEMEQ(buf, "def", sizeof(buf));
ASSERT_OK_ZERO(sd_fiber_read(fd, buf, sizeof(buf)));
return 0;
@@ -414,7 +414,7 @@ static int pty_read_fiber(void *userdata) {
n += k;
}
ASSERT_EQ(memcmp(buf, "hello", sizeof(buf)), 0);
ASSERT_MEMEQ(buf, "hello", sizeof(buf));
return 0;
}
src/libsystemd/sd-future/test-fiber-ops.c
+1 -1
View File
@@ -566,7 +566,7 @@ TEST(loop_read_write_fallback) {
char buf[16];
ssize_t n = loop_read(pipefd[0], buf, STRLEN("fallback"), /* do_poll= */ true);
ASSERT_OK_EQ(n, (ssize_t) STRLEN("fallback"));
ASSERT_EQ(memcmp(buf, "fallback", STRLEN("fallback")), 0);
ASSERT_MEMEQ(buf, "fallback", STRLEN("fallback"));
}
DEFINE_TEST_MAIN(LOG_DEBUG);
src/libsystemd/sd-journal/fuzz-journal-file.c
+4 -3
View File
@@ -12,6 +12,7 @@
#include "journal-file.h"
#include "journal-verify.h"
#include "mmap-cache.h"
#include "tests.h"
#include "tmpfile-util.h"
#define ENTRIES_MAX 256U
@@ -21,8 +22,8 @@ static void make_file(char *name, const uint8_t *data, size_t size) {
/* sd_journal_open_files() refuses files without a name, so the input goes to a temporary file
* instead of a memfd. */
assert_se((fd = mkostemp_safe(name)) >= 0);
assert_se(loop_write(fd, data, size) >= 0);
fd = ASSERT_OK(mkostemp_safe(name));
ASSERT_OK(loop_write(fd, data, size));
}
static void read_journal(const char *name) {
@@ -134,7 +135,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(m = mmap_cache_new());
m = ASSERT_NOT_NULL(mmap_cache_new());
make_file(name, data, size);
read_journal(name);
src/libsystemd/sd-journal/test-journal-file.c
+1 -1
View File
@@ -227,7 +227,7 @@ static void test_sync_then_archive_one(bool sync_done) {
ASSERT_OK(journal_file_archive(f, /* ret_previous_path= */ NULL));
ASSERT_OK(journal_file_set_offline(f, /* wait= */ false));
ASSERT_EQ(memcmp(f->header->signature, HEADER_SIGNATURE, sizeof(f->header->signature)), 0);
ASSERT_MEMEQ(f->header->signature, HEADER_SIGNATURE, sizeof(f->header->signature));
ASSERT_OK(journal_file_set_offline(f, /* wait= */ true));
ASSERT_EQ(f->header->state, STATE_ARCHIVED);
model_assert_file(f, &model);
src/libsystemd/sd-journal/test-journal-interleaving.c
+10 -15
View File
@@ -742,8 +742,7 @@ TEST(cursor_and_data_lifetime) {
ASSERT_OK(sd_journal_get_data_threshold(j, &size));
ASSERT_EQ(size, 4U);
ASSERT_OK(sd_journal_get_data(j, "BINARY", &data, &size));
ASSERT_EQ(size, sizeof(binary));
ASSERT_EQ(memcmp(data, binary, size), 0);
ASSERT_MEMEQ_NN(data, size, binary, sizeof(binary));
ASSERT_OK(sd_journal_get_realtime_usec(j, &value));
ASSERT_EQ(value, ts.realtime);
@@ -751,34 +750,30 @@ TEST(cursor_and_data_lifetime) {
ASSERT_EQ(value, ts.monotonic);
ASSERT_EQ_ID128(id, boot_id);
ASSERT_OK_POSITIVE(sd_journal_test_cursor(j, cursor));
ASSERT_EQ(memcmp(data, binary, size), 0);
ASSERT_MEMEQ(data, binary, size);
ASSERT_ERROR(sd_journal_get_data(j, "MISSING", &data, &size), ENOENT);
ASSERT_OK(sd_journal_set_data_threshold(j, /* sz= */ 0));
sd_journal_restart_data(j);
ASSERT_OK_POSITIVE(sd_journal_enumerate_data(j, &data, &size));
ASSERT_EQ(size, strlen(small));
ASSERT_EQ(memcmp(data, small, size), 0);
ASSERT_MEMEQ_NN(data, size, small, strlen(small));
ASSERT_OK(sd_journal_get_seqnum(j, &value, &id));
ASSERT_EQ(value, seqnum);
ASSERT_EQ_ID128(id, seqnum_id);
ASSERT_EQ(memcmp(data, small, size), 0);
ASSERT_MEMEQ(data, small, size);
ASSERT_OK_POSITIVE(sd_journal_enumerate_data(j, &data, &size));
ASSERT_EQ(size, sizeof(binary));
ASSERT_EQ(memcmp(data, binary, size), 0);
ASSERT_MEMEQ_NN(data, size, binary, sizeof(binary));
ASSERT_OK_ZERO(sd_journal_enumerate_data(j, &data, &size));
ASSERT_OK(sd_journal_query_unique(j, "BINARY"));
ASSERT_OK_POSITIVE(sd_journal_enumerate_unique(j, &data, &size));
ASSERT_EQ(size, sizeof(binary));
ASSERT_EQ(memcmp(data, binary, size), 0);
ASSERT_MEMEQ_NN(data, size, binary, sizeof(binary));
ASSERT_OK(sd_journal_get_realtime_usec(j, &value));
ASSERT_EQ(memcmp(data, binary, size), 0);
ASSERT_MEMEQ(data, binary, size);
ASSERT_OK_ZERO(sd_journal_enumerate_unique(j, &data, &size));
sd_journal_restart_unique(j);
ASSERT_OK_POSITIVE(sd_journal_enumerate_unique(j, &data, &size));
ASSERT_EQ(size, sizeof(binary));
ASSERT_EQ(memcmp(data, binary, size), 0);
ASSERT_MEMEQ_NN(data, size, binary, sizeof(binary));
unsigned n_fields = 0;
sd_journal_restart_fields(j);
@@ -964,7 +959,7 @@ static void test_boot_id_one(void (*setup)(void), size_t n_ids_expected) {
&ids_limited, &n_ids_limited));
ASSERT_TRUE(ids_limited || i == 0);
ASSERT_EQ(n_ids_limited, MIN(i, n_ids_expected));
ASSERT_EQ(memcmp_safe(ids, ids_limited, n_ids_limited * sizeof(LogId)), 0);
ASSERT_MEMEQ(ids, ids_limited, n_ids_limited * sizeof(LogId));
}
for (size_t i = 0; i <= n_ids_expected + 1; i++) {
@@ -978,7 +973,7 @@ static void test_boot_id_one(void (*setup)(void), size_t n_ids_expected) {
ASSERT_TRUE(ids_limited || i == 0);
ASSERT_EQ(n_ids_limited, MIN(i, n_ids_expected));
for (size_t k = 0; k < n_ids_limited; k++)
ASSERT_EQ(memcmp(&ids[n_ids - k - 1], &ids_limited[k], sizeof(LogId)), 0);
ASSERT_MEMEQ(&ids[n_ids - k - 1], &ids_limited[k], sizeof(LogId));
}
}
src/libsystemd/sd-journal/test-journal.c
+2 -2
View File
@@ -307,7 +307,7 @@ static bool check_compressed(uint64_t compress_threshold, uint64_t data_size) {
struct iovec v;
ASSERT_OK_POSITIVE(journal_file_data_payload_full(f, o, p, field, field_length, flags,
-EBADF, (const void**) &v.iov_base, &v.iov_len));
ASSERT_TRUE(iovec_equal(&v, &IOVEC_SHIFT(&iovec, skip)));
ASSERT_IOVEC_EQ(&v, &IOVEC_SHIFT(&iovec, skip));
_cleanup_close_ int fd = ASSERT_OK(memfd_new("decompress-blob-to-fd-test"));
size_t sz;
@@ -323,7 +323,7 @@ static bool check_compressed(uint64_t compress_threshold, uint64_t data_size) {
ASSERT_OK(iovec_alloc(sz, &w));
ASSERT_OK_EQ_ERRNO(pread(fd, w.iov_base, w.iov_len, 0), (ssize_t) w.iov_len);
ASSERT_TRUE(iovec_equal(&w, &IOVEC_SHIFT(&iovec, skip)));
ASSERT_IOVEC_EQ(&w, &IOVEC_SHIFT(&iovec, skip));
}
(void) journal_file_offline_close(f);
src/libsystemd/sd-json/test-json.c
+5 -5
View File
@@ -1373,8 +1373,8 @@ TEST(json_iovec) {
ASSERT_OK(json_variant_unbase64_iovec(sd_json_variant_by_key(j, "nr1"), &a));
ASSERT_OK(json_variant_unhex_iovec(sd_json_variant_by_key(j, "nr2"), &b));
ASSERT_TRUE(iovec_equal(&iov1, &a));
ASSERT_TRUE(iovec_equal(&iov2, &b));
ASSERT_IOVEC_EQ(&iov1, &a);
ASSERT_IOVEC_EQ(&iov2, &b);
ASSERT_LT(iovec_memcmp(&iov2, &a), 0);
ASSERT_GT(iovec_memcmp(&iov1, &b), 0);
}
@@ -2380,7 +2380,7 @@ TEST(json_dispatch_unhex_iovec32) {
ASSERT_OK(sd_json_dispatch(j, table, /* flags= */ 0, &data));
ASSERT_EQ(data.digest.iov_len, 32U);
ASSERT_EQ(memcmp(data.digest.iov_base, buf, 32), 0);
ASSERT_MEMEQ(data.digest.iov_base, buf, 32);
ASSERT_FALSE(iovec_is_set(&data.null_digest));
/* Dispatching again replaces the old value */
@@ -2388,7 +2388,7 @@ TEST(json_dispatch_unhex_iovec32) {
ASSERT_OK(sd_json_buildo(&j, SD_JSON_BUILD_PAIR_HEX("digest", buf + 1, 32)));
ASSERT_OK(sd_json_dispatch(j, table, /* flags= */ 0, &data));
ASSERT_EQ(data.digest.iov_len, 32U);
ASSERT_EQ(memcmp(data.digest.iov_base, buf + 1, 32), 0);
ASSERT_MEMEQ(data.digest.iov_base, buf + 1, 32);
/* Wrong sizes are refused, and leave the old value in place */
size_t n;
@@ -2397,7 +2397,7 @@ TEST(json_dispatch_unhex_iovec32) {
ASSERT_OK(sd_json_buildo(&j, SD_JSON_BUILD_PAIR_HEX("digest", buf, n)));
ASSERT_ERROR(sd_json_dispatch(j, table, /* flags= */ 0, &data), EINVAL);
ASSERT_EQ(data.digest.iov_len, 32U);
ASSERT_EQ(memcmp(data.digest.iov_base, buf + 1, 32), 0);
ASSERT_MEMEQ(data.digest.iov_base, buf + 1, 32);
}
/* Invalid hex strings are refused too */
src/libsystemd/sd-varlink/test-varlink.c
+1 -1
View File
@@ -105,7 +105,7 @@ static void test_fd(int fd, const void *buf, size_t n) {
ssize_t m;
ASSERT_OK_ERRNO(m = read(fd, rbuf, n + 1));
ASSERT_OK_ZERO(memcmp_nn(buf, n, rbuf, m));
ASSERT_MEMEQ_NN(buf, n, rbuf, m);
}
static int method_passfd(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
src/network/fuzz-netdev-parser.c
+4 -3
View File
@@ -3,6 +3,7 @@
#include "fd-util.h"
#include "fuzz.h"
#include "networkd-manager.h"
#include "tests.h"
#include "tmpfile-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -16,12 +17,12 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(fmkostemp_safe(netdev_config, "r+", &f) == 0);
ASSERT_OK_ZERO(fmkostemp_safe(netdev_config, "r+", &f));
if (size != 0)
assert_se(fwrite(data, size, 1, f) == 1);
ASSERT_EQ(fwrite(data, size, 1, f), (size_t) 1);
fflush(f);
assert_se(manager_new(&manager, /* test_mode= */ true) >= 0);
ASSERT_OK(manager_new(&manager, /* test_mode= */ true));
(void) netdev_load_one(manager, netdev_config, &netdev);
return 0;
}
src/network/fuzz-network-parser.c
+4 -3
View File
@@ -3,6 +3,7 @@
#include "fd-util.h"
#include "fuzz.h"
#include "networkd-manager.h"
#include "tests.h"
#include "tmpfile-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -15,12 +16,12 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(fmkostemp_safe(network_config, "r+", &f) == 0);
ASSERT_OK_ZERO(fmkostemp_safe(network_config, "r+", &f));
if (size != 0)
assert_se(fwrite(data, size, 1, f) == 1);
ASSERT_EQ(fwrite(data, size, 1, f), (size_t) 1);
fflush(f);
assert_se(manager_new(&manager, /* test_mode= */ true) >= 0);
ASSERT_OK(manager_new(&manager, /* test_mode= */ true));
(void) network_load_one(manager, &manager->networks, network_config);
return 0;
}
src/network/test-networkd-conf.c
+2 -3
View File
@@ -300,8 +300,7 @@ static void test_config_parse_dhcp_static_lease_one(
ASSERT_EQ(hashmap_size(network->dhcp_static_leases_by_section), 1u);
ASSERT_NOT_NULL(lease = hashmap_first(network->dhcp_static_leases_by_section));
ASSERT_EQ(lease->client_id.size, expected_size);
ASSERT_EQ(memcmp(lease->client_id.raw, expected, expected_size), 0);
ASSERT_MEMEQ_NN(lease->client_id.raw, lease->client_id.size, expected, expected_size);
}
TEST(config_parse_dhcp_static_lease) {
@@ -416,7 +415,7 @@ static void test_config_parse_multipath_route_verify(
if (expected_gw) {
union in_addr_union gw;
ASSERT_OK(in_addr_from_string(expected_family, expected_gw, &gw));
ASSERT_EQ(memcmp(&nh->gw, &gw, FAMILY_ADDRESS_SIZE(expected_family)), 0);
ASSERT_MEMEQ(&nh->gw, &gw, FAMILY_ADDRESS_SIZE(expected_family));
} else
ASSERT_FALSE(in_addr_is_set(nh->family, &nh->gw));
src/nspawn/fuzz-nspawn-oci.c
+2 -1
View File
@@ -3,6 +3,7 @@
#include "fd-util.h"
#include "fuzz.h"
#include "nspawn-oci.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_fclose_ FILE *f = NULL;
@@ -12,7 +13,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
return 0;
f = data_to_file(data, size);
assert_se(f);
ASSERT_NOT_NULL(f);
fuzz_setup_logging();
src/nspawn/fuzz-nspawn-settings.c
+2 -1
View File
@@ -3,6 +3,7 @@
#include "fd-util.h"
#include "fuzz.h"
#include "nspawn-settings.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_fclose_ FILE *f = NULL;
@@ -12,7 +13,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
return 0;
f = data_to_file(data, size);
assert_se(f);
ASSERT_NOT_NULL(f);
fuzz_setup_logging();
src/resolve/fuzz-dns-packet.c
+4 -3
View File
@@ -2,6 +2,7 @@
#include "dns-packet.h"
#include "fuzz.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
@@ -11,12 +12,12 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(dns_packet_new(&p, DNS_PROTOCOL_DNS, /* min_alloc_dsize= */ 0, DNS_PACKET_SIZE_MAX) >= 0);
ASSERT_OK(dns_packet_new(&p, DNS_PROTOCOL_DNS, /* min_alloc_dsize= */ 0, DNS_PACKET_SIZE_MAX));
p->size = 0; /* by default append starts after the header, undo that */
assert_se(dns_packet_append_blob(p, data, size, /* start= */ NULL) >= 0);
ASSERT_OK(dns_packet_append_blob(p, data, size, /* start= */ NULL));
if (size < DNS_PACKET_HEADER_SIZE) {
/* make sure we pad the packet back up to the minimum header size */
assert_se(p->allocated >= DNS_PACKET_HEADER_SIZE);
ASSERT_GE(p->allocated, (size_t) DNS_PACKET_HEADER_SIZE);
memzero(DNS_PACKET_DATA(p) + size, DNS_PACKET_HEADER_SIZE - size);
p->size = DNS_PACKET_HEADER_SIZE;
}
src/resolve/fuzz-etc-hosts.c
+2 -1
View File
@@ -3,6 +3,7 @@
#include "fd-util.h"
#include "fuzz.h"
#include "resolved-etc-hosts.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_fclose_ FILE *f = NULL;
@@ -11,7 +12,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
f = data_to_file(data, size);
assert_se(f);
ASSERT_NOT_NULL(f);
(void) etc_hosts_parse(&h, f);
src/resolve/fuzz-resource-record.c
+8 -7
View File
@@ -7,6 +7,7 @@
#include "fuzz.h"
#include "memstream-util.h"
#include "string-util.h"
#include "tests.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL, *copy = NULL;
@@ -22,16 +23,16 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
fuzz_setup_logging();
assert_se(copy = dns_resource_record_copy(rr));
assert_se(dns_resource_record_equal(copy, rr) > 0);
copy = ASSERT_NOT_NULL(dns_resource_record_copy(rr));
ASSERT_OK_POSITIVE(dns_resource_record_equal(copy, rr));
assert_se(f = memstream_init(&m));
f = ASSERT_NOT_NULL(memstream_init(&m));
(void) fprintf(f, "%s", strna(dns_resource_record_to_string(rr)));
assert_se(dns_resource_record_to_json(rr, &v) >= 0);
assert_se(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_SOURCE, f, /* prefix= */ NULL) >= 0);
assert_se(dns_resource_record_to_wire_format(rr, /* canonical= */ false) >= 0);
assert_se(dns_resource_record_to_wire_format(rr, /* canonical= */ true) >= 0);
ASSERT_OK(dns_resource_record_to_json(rr, &v));
ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_SOURCE, f, /* prefix= */ NULL));
ASSERT_OK(dns_resource_record_to_wire_format(rr, /* canonical= */ false));
ASSERT_OK(dns_resource_record_to_wire_format(rr, /* canonical= */ true));
return 0;
}
src/resolve/test-dns-cache.c
+5 -10
View File
@@ -1341,8 +1341,7 @@ TEST(dns_cache_export_shared_to_packet) {
/* ip */ 0xc0, 0xa8, 0x01, 0x7f
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(dns_cache_export_shared_to_packet_multi) {
@@ -1410,17 +1409,13 @@ TEST(dns_cache_export_shared_to_packet_multi) {
/* cache key order is not deterministic; the packets could come out in either order */
if (memcmp(DNS_PACKET_DATA(packet), data1, size1) == 0) {
ASSERT_EQ(packet->size, size1);
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data1, size1), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data1, size1);
ASSERT_EQ(packet->more->size, size2);
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet->more), data2, size2), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet->more), packet->more->size, data2, size2);
} else {
ASSERT_EQ(packet->size, size2);
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data2, size2), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data2, size2);
ASSERT_EQ(packet->more->size, size1);
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet->more), data1, size1), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet->more), packet->more->size, data1, size1);
}
ASSERT_NULL(packet->more->more);
src/resolve/test-dns-packet-append.c
+29 -58
View File
@@ -178,8 +178,7 @@ TEST(packet_append_key_single_a) {
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_key_single_soa_any_class) {
@@ -210,8 +209,7 @@ TEST(packet_append_key_single_soa_any_class) {
/* ANY */ 0x00, 0xff
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_key_cache_flush_mdns) {
@@ -242,8 +240,7 @@ TEST(packet_append_key_cache_flush_mdns) {
0x80, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
/* The cache-flush bit is defined for mDNS only. RRs taken from our mDNS zone carry
@@ -276,8 +273,7 @@ TEST(packet_append_key_cache_flush_dns) {
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
/* mDNS probes carry the proposed RRs from our mDNS zone in the Authority Section. Those items carry
@@ -309,8 +305,7 @@ TEST(packet_append_key_cache_flush_mdns_query) {
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
/* ================================================================
@@ -371,8 +366,7 @@ TEST(packet_append_question_compression) {
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
/* ================================================================
@@ -403,8 +397,7 @@ TEST(packet_append_opt_basic) {
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_opt_change_max_udp) {
@@ -431,8 +424,7 @@ TEST(packet_append_opt_change_max_udp) {
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_opt_dnssec_ok) {
@@ -459,8 +451,7 @@ TEST(packet_append_opt_dnssec_ok) {
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_opt_rcode) {
@@ -487,8 +478,7 @@ TEST(packet_append_opt_rcode) {
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_opt_nsid) {
@@ -519,8 +509,7 @@ TEST(packet_append_opt_nsid) {
'm', 'p', 'l', 'e', '.', 'c', 'o', 'm'
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_key_and_opt) {
@@ -559,8 +548,7 @@ TEST(packet_append_key_and_opt) {
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_truncate_opt) {
@@ -593,8 +581,7 @@ TEST(packet_truncate_opt) {
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
/* ================================================================
@@ -627,8 +614,7 @@ TEST(packet_patch_max_udp_size) {
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_patch_max_udp_size_no_opt) {
@@ -647,8 +633,7 @@ TEST(packet_patch_max_udp_size_no_opt) {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
/* ================================================================
@@ -696,8 +681,7 @@ TEST(packet_dup) {
ASSERT_OK(dns_packet_dup(&p2, p1));
ASSERT_NOT_NULL(p2);
ASSERT_EQ(p2->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(p2), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(p2), p2->size, data, sizeof(data));
}
/* ================================================================
@@ -742,8 +726,7 @@ TEST(packet_append_answer_single_a) {
/* ip */ 0xc0, 0xa8, 0x01, 0x7f
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_single_ns) {
@@ -785,8 +768,7 @@ TEST(packet_append_answer_single_ns) {
0xc0, 0x0c
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_single_cname) {
@@ -828,8 +810,7 @@ TEST(packet_append_answer_single_cname) {
/* name */ 0xc0, 0x10
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_single_hinfo) {
@@ -872,8 +853,7 @@ TEST(packet_append_answer_single_hinfo) {
/* os */ 0x09, 'G', 'N', 'U', '/', 'L', 'i', 'n', 'u', 'x'
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_single_ptr) {
@@ -920,8 +900,7 @@ TEST(packet_append_answer_single_ptr) {
0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
/* Reverse lookups for link-local addresses are answered from resolved's own mDNS zone, whose answer
@@ -972,8 +951,7 @@ TEST(packet_append_answer_single_ptr_ip6_cache_flush) {
0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_single_mx) {
@@ -1017,8 +995,7 @@ TEST(packet_append_answer_single_mx) {
0xc0, 0x0c
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_single_txt) {
@@ -1072,8 +1049,7 @@ TEST(packet_append_answer_single_txt) {
0x05, 'w', 'o', 'r', 'l', 'd'
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_single_loc) {
@@ -1126,8 +1102,7 @@ TEST(packet_append_answer_single_loc) {
/* altitude */ 0x00, 0x98, 0x96, 0x80
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_single_srv) {
@@ -1179,8 +1154,7 @@ TEST(packet_append_answer_single_srv) {
0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_single_naptr) {
@@ -1243,8 +1217,7 @@ TEST(packet_append_answer_single_naptr) {
0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
TEST(packet_append_answer_rrsig_with_a) {
@@ -1325,8 +1298,7 @@ TEST(packet_append_answer_rrsig_with_a) {
/* signature */ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
static DnsSvcParam* add_svcb_param(DnsResourceRecord *rr, uint16_t key, const char *value, size_t len) {
@@ -1420,8 +1392,7 @@ TEST(packet_append_answer_single_svcb) {
0x2f, 0xd7, 0xdb, 0x7b, 0x28, 0x7e, 0x60, 0xbb
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
ASSERT_MEMEQ_NN(DNS_PACKET_DATA(packet), packet->size, data, sizeof(data));
}
static void dump_packet_data(DnsPacket *packet) {
src/resolve/test-dns-rr.c
+1 -1
View File
@@ -829,7 +829,7 @@ TEST(dns_resource_record_new_address_ipv6) {
ASSERT_EQ(rr->key->class, DNS_CLASS_IN);
ASSERT_EQ(rr->key->type, DNS_TYPE_AAAA);
ASSERT_STREQ(dns_resource_key_name(rr->key), "www.example.com");
ASSERT_EQ(memcmp(&rr->aaaa.in6_addr, &addr.in6, sizeof(struct in6_addr)), 0);
ASSERT_MEMEQ(&rr->aaaa.in6_addr, &addr.in6, sizeof(struct in6_addr));
test_to_json_from_json(rr);
}
src/resolve/test-dns-stub.c
+1 -2
View File
@@ -3,7 +3,6 @@
#include "dns-answer.h"
#include "dns-packet.h"
#include "dns-rr.h"
#include "memory-util.h"
#include "resolved-dns-stub.h"
#include "string-util.h"
#include "tests.h"
@@ -136,7 +135,7 @@ static void parse_reply(DnsPacket *reply, DnsPacket **ret_parsed, char **ret_lay
ASSERT_EQ(rr->key->type, DNS_TYPE_DNSKEY);
ASSERT_EQ(rr->dnskey.key_size, DNSKEY_KEY_SIZE);
fill = *(uint8_t*) rr->dnskey.key;
ASSERT_TRUE(memeqbyte(fill, rr->dnskey.key, rr->dnskey.key_size));
ASSERT_MEMEQ_BYTE(fill, rr->dnskey.key, rr->dnskey.key_size);
ASSERT_OK(strextendf(&layout, "%c", fill));
}
}
src/resolve/test-resolved-stream.c
+9 -9
View File
@@ -69,7 +69,7 @@ static void receive_and_check_question(int fd, const uint8_t *expected_question,
}
ASSERT_EQ(n_read, question_size);
ASSERT_EQ(memcmp(expected_question, actual_question, question_size), 0);
ASSERT_MEMEQ(expected_question, actual_question, question_size);
}
static void send_answer(int fd, const uint8_t *answer, size_t answer_size) {
@@ -278,8 +278,8 @@ static void test_dns_stream(bool tls) {
while (n_received_packets != 1)
ASSERT_OK_POSITIVE(sd_event_run(event, EVENT_TIMEOUT_USEC));
ASSERT_NOT_NULL(DNS_PACKET_DATA(received_packets[0]));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(received_packets[0]),
ANSWER_A + 2, sizeof(ANSWER_A) - 2), 0);
ASSERT_MEMEQ(DNS_PACKET_DATA(received_packets[0]),
ANSWER_A + 2, sizeof(ANSWER_A) - 2);
dns_packet_unref(TAKE_PTR(received_packets[0]));
n_received_packets = 0;
@@ -289,8 +289,8 @@ static void test_dns_stream(bool tls) {
while (n_received_packets != 1)
ASSERT_OK_POSITIVE(sd_event_run(event, EVENT_TIMEOUT_USEC));
ASSERT_NOT_NULL(DNS_PACKET_DATA(received_packets[0]));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(received_packets[0]),
ANSWER_AAAA + 2, sizeof(ANSWER_AAAA) - 2), 0);
ASSERT_MEMEQ(DNS_PACKET_DATA(received_packets[0]),
ANSWER_AAAA + 2, sizeof(ANSWER_AAAA) - 2);
dns_packet_unref(TAKE_PTR(received_packets[0]));
n_received_packets = 0;
@@ -305,10 +305,10 @@ static void test_dns_stream(bool tls) {
ASSERT_OK_POSITIVE(sd_event_run(event, EVENT_TIMEOUT_USEC));
ASSERT_NOT_NULL(DNS_PACKET_DATA(received_packets[0]));
ASSERT_NOT_NULL(DNS_PACKET_DATA(received_packets[1]));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(received_packets[0]),
ANSWER_A + 2, sizeof(ANSWER_A) - 2), 0);
ASSERT_EQ(memcmp(DNS_PACKET_DATA(received_packets[1]),
ANSWER_AAAA + 2, sizeof(ANSWER_AAAA) - 2), 0);
ASSERT_MEMEQ(DNS_PACKET_DATA(received_packets[0]),
ANSWER_A + 2, sizeof(ANSWER_A) - 2);
ASSERT_MEMEQ(DNS_PACKET_DATA(received_packets[1]),
ANSWER_AAAA + 2, sizeof(ANSWER_AAAA) - 2);
dns_packet_unref(TAKE_PTR(received_packets[0]));
dns_packet_unref(TAKE_PTR(received_packets[1]));
n_received_packets = 0;
src/shared/hexdump.c
+183
View File
@@ -0,0 +1,183 @@
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "alloc-util.h"
#include "hexdump.h"
#include "iovec-util.h"
#include "iovec-wrapper.h"
#include "memstream-util.h"
void hexdump(FILE *f, const void *p, size_t s) {
const uint8_t *b = p;
unsigned n = 0;
assert(b || s == 0);
if (s == SIZE_MAX)
s = strlen(p);
if (!f)
f = stdout;
while (s > 0) {
size_t i;
fprintf(f, "%04x ", n);
for (i = 0; i < 16; i++) {
if (i >= s)
fputs(" ", f);
else
fprintf(f, "%02x ", b[i]);
if (i == 7)
fputc(' ', f);
}
fputc(' ', f);
for (i = 0; i < 16; i++) {
if (i >= s)
fputc(' ', f);
else
fputc(isprint(b[i]) ? (char) b[i] : '.', f);
}
fputc('\n', f);
if (s < 16)
break;
n += 16;
b += 16;
s -= 16;
}
}
static void dump_hex_line(FILE *f, char tag, const uint8_t *p, size_t size, size_t off) {
assert(f);
fprintf(f, "%c %04zx ", tag, off);
for (size_t i = 0; i < 16; i++) {
if (off + i < size)
fprintf(f, "%02x ", p[off + i]);
else
fputs(" ", f);
if (i == 7)
fputc(' ', f);
}
fputs(" |", f);
for (size_t i = 0; i < 16; i++) {
if (off + i < size) {
uint8_t c = p[off + i];
fputc(isprint(c) ? (char) c : '.', f);
} else
fputc(' ', f);
}
fputs("|\n", f);
}
char* hexdump_memcmp(const void *m1, size_t l1, const void *m2, size_t l2) {
_cleanup_(memstream_done) MemStream m = {};
const uint8_t *a = m1, *b = m2;
size_t mx = MAX(l1, l2);
FILE *f;
/* Returns a hexdump(3)-like side-by-side representation of two memory regions. For each 16 byte
* chunk that differs a marker line pointing at the diverging bytes ('<' is the first region, '>' the
* second) is appended. */
f = memstream_init(&m);
if (!f)
return NULL;
for (size_t off = 0; off < mx; off += 16) {
dump_hex_line(f, '<', a, l1, off);
dump_hex_line(f, '>', b, l2, off);
/* Figure out whether this chunk differs at all, and only then emit the marker line. */
bool any = false;
for (size_t i = 0; i < 16 && off + i < mx; i++) {
bool pa = off + i < l1, pb = off + i < l2;
if (pa != pb || (pa && pb && a[off + i] != b[off + i])) {
any = true;
break;
}
}
if (!any)
continue;
fputs(" ", f); /* align with the 8-char "%c %04zx " prefix: tag + space + 4 hex + 2 spaces */
for (size_t i = 0; i < 16; i++) {
bool pa = off + i < l1, pb = off + i < l2;
bool diff = pa != pb || (pa && pb && a[off + i] != b[off + i]);
fputs(diff ? "^^ " : " ", f);
if (i == 7)
fputc(' ', f);
}
fputc('\n', f);
}
char *ret;
if (memstream_finalize(&m, &ret, NULL) < 0)
return NULL;
return ret;
}
char* hexdump_memcmp_byte(uint8_t byte, const void *data, size_t length) {
_cleanup_free_ uint8_t *expected = NULL;
/* Like hexdump_memcmp(), but compares the memory region against a region of the same length filled
* with 'byte'. Used by ASSERT_MEMEQ_BYTE() and ASSERT_MEMEQ_ZERO(). */
if (length > 0) {
expected = malloc(length);
if (!expected)
return NULL;
memset(expected, byte, length);
}
return hexdump_memcmp(data, length, expected, length);
}
char* hexdump_iovw_compare(const struct iovec_wrapper *a, const struct iovec_wrapper *b) {
_cleanup_(memstream_done) MemStream m = {};
size_t na = a ? a->count : 0, nb = b ? b->count : 0, mx = MAX(na, nb);
FILE *f;
/* Dumps the elements of two iovec wrappers that differ, element by element, reusing
* hexdump_memcmp(). Used by ASSERT_IOVW_EQ(). */
f = memstream_init(&m);
if (!f)
return NULL;
for (size_t i = 0; i < mx; i++) {
const struct iovec *ia = i < na ? a->iovec + i : NULL;
const struct iovec *ib = i < nb ? b->iovec + i : NULL;
if (ia && ib && iovec_memcmp(ia, ib) == 0)
continue;
_cleanup_free_ char *d = hexdump_memcmp(ia ? ia->iov_base : NULL, ia ? ia->iov_len : 0,
ib ? ib->iov_base : NULL, ib ? ib->iov_len : 0);
fprintf(f, "element %zu differs:\n%s", i, d ?: "");
}
char *ret;
if (memstream_finalize(&m, &ret, NULL) < 0)
return NULL;
return ret;
}
src/shared/hexdump.h
+16
View File
@@ -0,0 +1,16 @@
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "forward.h"
void hexdump(FILE *f, const void *p, size_t s) _nonnull_if_nonzero_(2, 3);
/* Returns a hexdump(3)-like side-by-side dump of two memory regions, marking the differing bytes. Returns
* NULL on OOM. Meant for assertion failure messages, see ASSERT_MEMEQ() and friends. */
char* hexdump_memcmp(const void *m1, size_t l1, const void *m2, size_t l2);
/* Like hexdump_memcmp(), but compares against a region of the same length filled with 'byte'. */
char* hexdump_memcmp_byte(uint8_t byte, const void *data, size_t length);
/* Dumps the differing elements of two iovec wrappers, element by element. Used by ASSERT_IOVW_EQ(). */
char* hexdump_iovw_compare(const struct iovec_wrapper *a, const struct iovec_wrapper *b);
src/shared/meson.build
+1
View File
@@ -95,6 +95,7 @@ shared_sources = files(
'gnutls-util.c',
'gpt.c',
'group-record.c',
'hexdump.c',
'hibernate-util.c',
'host-properties.c',
'hostname-setup.c',
src/shared/tests.h
+83
View File
@@ -5,8 +5,12 @@
#include "errno-list.h"
#include "forward.h"
#include "hexdump.h" /* IWYU pragma: keep */
#include "iovec-util.h" /* IWYU pragma: keep */
#include "iovec-wrapper.h" /* IWYU pragma: keep */
#include "log.h"
#include "log-assert-critical.h"
#include "memory-util.h" /* IWYU pragma: keep */
#include "path-util.h" /* IWYU pragma: keep */
#include "static-destruct.h" /* IWYU pragma: keep */
#include "signal-util.h" /* IWYU pragma: keep */
@@ -563,6 +567,85 @@ _noreturn_ void log_test_failed_internal(const char *file, int line, const char
})
#endif
#ifdef __COVERITY__
# define ASSERT_MEMEQ(p1, p2, n) __coverity_check__(memcmp_safe((p1), (p2), (n)) == 0)
#else
# define ASSERT_MEMEQ(p1, p2, n) \
({ \
const void *_p1 = (p1), *_p2 = (p2); \
size_t _n = (n); \
if (memcmp_safe(_p1, _p2, _n) != 0) { \
_cleanup_free_ char *_dump = hexdump_memcmp(_p1, _n, _p2, _n); \
log_test_failed("Expected \"%s\" and \"%s\" to have equal contents (%zu bytes):\n%s", \
#p1, #p2, _n, strnull(_dump)); \
} \
})
#endif
#ifdef __COVERITY__
# define ASSERT_MEMEQ_NN(p1, l1, p2, l2) __coverity_check__(memcmp_nn((p1), (l1), (p2), (l2)) == 0)
#else
# define ASSERT_MEMEQ_NN(p1, l1, p2, l2) \
({ \
const void *_p1 = (p1), *_p2 = (p2); \
size_t _l1 = (l1), _l2 = (l2); \
if (memcmp_nn(_p1, _l1, _p2, _l2) != 0) { \
_cleanup_free_ char *_dump = hexdump_memcmp(_p1, _l1, _p2, _l2); \
log_test_failed("Expected \"%s\" (%zu bytes) and \"%s\" (%zu bytes) to have equal contents:\n%s", \
#p1, _l1, #p2, _l2, strnull(_dump)); \
} \
})
#endif
#ifdef __COVERITY__
# define ASSERT_IOVEC_EQ(i1, i2) __coverity_check__(iovec_memcmp((i1), (i2)) == 0)
#else
# define ASSERT_IOVEC_EQ(i1, i2) \
({ \
const struct iovec *_i1 = (i1), *_i2 = (i2); \
if (iovec_memcmp(_i1, _i2) != 0) { \
_cleanup_free_ char *_dump = hexdump_memcmp(_i1 ? _i1->iov_base : NULL, \
_i1 ? _i1->iov_len : 0, \
_i2 ? _i2->iov_base : NULL, \
_i2 ? _i2->iov_len : 0); \
log_test_failed("Expected iovec \"%s\" (%zu bytes) and \"%s\" (%zu bytes) to have equal contents:\n%s", \
#i1, _i1 ? _i1->iov_len : 0, #i2, _i2 ? _i2->iov_len : 0, strnull(_dump)); \
} \
})
#endif
#ifdef __COVERITY__
# define ASSERT_MEMEQ_BYTE(byte, data, length) __coverity_check__(memeqbyte((byte), (data), (length)))
#else
# define ASSERT_MEMEQ_BYTE(byte, data, length) \
({ \
uint8_t _byte = (byte); \
const void *_data = (data); \
size_t _length = (length); \
if (!memeqbyte(_byte, _data, _length)) { \
_cleanup_free_ char *_dump = hexdump_memcmp_byte(_byte, _data, _length); \
log_test_failed("Expected all %zu bytes of \"%s\" to be 0x%02x:\n%s", \
_length, #data, _byte, strnull(_dump)); \
} \
})
#endif
#define ASSERT_MEMEQ_ZERO(data, length) ASSERT_MEMEQ_BYTE(0x00, data, length)
#ifdef __COVERITY__
# define ASSERT_IOVW_EQ(a, b) __coverity_check__(iovw_equal((a), (b)))
#else
# define ASSERT_IOVW_EQ(a, b) \
({ \
const struct iovec_wrapper *_a = (a), *_b = (b); \
if (!iovw_equal(_a, _b)) { \
_cleanup_free_ char *_dump = hexdump_iovw_compare(_a, _b); \
log_test_failed("Expected iovec wrappers \"%s\" (%zu elements) and \"%s\" (%zu elements) to be equal:\n%s", \
#a, _a ? _a->count : 0, #b, _b ? _b->count : 0, strnull(_dump)); \
} \
})
#endif
/* DECIMAL_STR_FMT() uses _Generic which cannot be used in string concatenation so we have to format the
* input into strings first and then format those into the final assertion message. */
src/systemctl/fuzz-systemctl-parse-argv.c
+3 -2
View File
@@ -13,6 +13,7 @@
#include "strv.h"
#include "systemctl.h"
#include "systemctl-util.h"
#include "tests.h"
static int verb_noop(int argc, char *argv[], uintptr_t _data, void *userdata) { return 0; }
_alias_(verb_noop)
@@ -87,7 +88,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
if (orig_stdout_fd < 0)
log_warning_errno(errno, "Failed to duplicate fd 1, ignoring: %m");
else
assert_se(freopen("/dev/null", "w", stdout));
ASSERT_NOT_NULL(freopen("/dev/null", "w", stdout));
}
/* We need to reset some global state manually here since libfuzzer feeds a single process with
@@ -104,7 +105,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
log_info(r == 0 ? "Done!" : "Action!");
if (orig_stdout_fd >= 0)
assert_se(freopen(FORMAT_PROC_FD_PATH(orig_stdout_fd), "w", stdout));
ASSERT_NOT_NULL(freopen(FORMAT_PROC_FD_PATH(orig_stdout_fd), "w", stdout));
release_busses(); /* We open the bus for communication with logind.
* It needs to be closed to avoid apparent leaks. */
src/test/meson.build
+1
View File
@@ -125,6 +125,7 @@ simple_tests += files(
'test-gunicode.c',
'test-hash-funcs.c',
'test-hexdecoct.c',
'test-hexdump.c',
'test-hmac.c',
'test-hostname-setup.c',
'test-hostname-util.c',
src/test/test-alloc-util.c
+6 -6
View File
@@ -17,7 +17,7 @@ TEST(alloca) {
t = alloca0_align(997, 1024);
ASSERT_FALSE((uintptr_t)t & 0x1ff);
ASSERT_EQ(memcmp(t, zero, 997), 0);
ASSERT_MEMEQ(t, zero, 997);
}
TEST(GREEDY_REALLOC) {
@@ -63,14 +63,14 @@ TEST(GREEDY_REALLOC) {
ASSERT_NOT_NULL(GREEDY_REALLOC_APPEND(before, n_before, c, n_c));
ASSERT_NOT_NULL(before);
ASSERT_EQ(n_before, n_c);
ASSERT_EQ(memcmp_safe(c, before, n_c), 0);
ASSERT_MEMEQ(c, before, n_c);
ASSERT_NOT_NULL(GREEDY_REALLOC_APPEND(c, n_c, from, n_from));
ASSERT_EQ(n_c, n_before + n_from);
ASSERT_GE(MALLOC_ELEMENTSOF(c), n_c);
ASSERT_GE(MALLOC_SIZEOF_SAFE(c), n_c * sizeof(int));
ASSERT_EQ(memcmp_safe(c, before, n_before), 0);
ASSERT_EQ(memcmp_safe(&c[n_before], from, n_from), 0);
ASSERT_MEMEQ(c, before, n_before);
ASSERT_MEMEQ(&c[n_before], from, n_from);
before = mfree(before);
ASSERT_NULL(before);
@@ -78,14 +78,14 @@ TEST(GREEDY_REALLOC) {
ASSERT_NOT_NULL(GREEDY_REALLOC_APPEND(before, n_before, c, n_c));
ASSERT_NOT_NULL(before);
ASSERT_EQ(n_before, n_c);
ASSERT_EQ(memcmp_safe(c, before, n_c), 0);
ASSERT_MEMEQ(c, before, n_c);
ASSERT_NOT_NULL(GREEDY_REALLOC_APPEND(c, n_c, NULL, 0));
ASSERT_NOT_NULL(c);
ASSERT_EQ(n_c, n_before);
ASSERT_GE(MALLOC_ELEMENTSOF(c), n_c);
ASSERT_GE(MALLOC_SIZEOF_SAFE(c), n_c * sizeof(int));
ASSERT_EQ(memcmp_safe(c, before, n_c), 0);
ASSERT_MEMEQ(c, before, n_c);
}
for (j = 0; j < i * n_from; j++)
src/test/test-compress-benchmark.c
+1 -2
View File
@@ -137,8 +137,7 @@ TEST(benchmark) {
log_error("%s \"compressed\" %zu -> %zu", label, size, j);
ASSERT_OK_ZERO(decompress_blob(c, buf, j, &buf2, &k, /* dst_max= */ 0));
ASSERT_EQ(k, size);
ASSERT_EQ(memcmp(text, buf2, size), 0);
ASSERT_MEMEQ_NN(text, size, buf2, k);
total += size;
compressed += j;
src/test/test-compress.c
+12 -17
View File
@@ -58,7 +58,7 @@ TEST(compress_decompress_blob) {
ASSERT_OK_ZERO(decompress_blob(c, compressed, csize, (void **) &decompressed, &csize, /* dst_max= */ 0));
ASSERT_NOT_NULL(decompressed);
ASSERT_EQ(memcmp(decompressed, input, input_len), 0);
ASSERT_MEMEQ(decompressed, input, input_len);
ASSERT_FAIL(decompress_blob(c, "garbage", 7, (void **) &decompressed, &csize, /* dst_max= */ 0));
}
@@ -74,7 +74,7 @@ static void verify_memfd(int fd, size_t sz, const void *expected, size_t expecte
_cleanup_free_ void *buf = ASSERT_NOT_NULL(malloc(expected_size));
ASSERT_OK_EQ_ERRNO(pread(fd, buf, expected_size, 0), (ssize_t) expected_size);
ASSERT_EQ(memcmp(buf, expected, expected_size), 0);
ASSERT_MEMEQ(buf, expected, expected_size);
}
TEST(decompress_blob_to_fd) {
@@ -215,8 +215,7 @@ TEST(decompress_blob_zstd_frame_at_buffer_boundary) {
_cleanup_free_ void *decompressed = NULL;
size_t dsize = 0;
ASSERT_OK_ZERO(decompress_blob(COMPRESSION_ZSTD, compressed, st.st_size - 4, &decompressed, &dsize, /* dst_max= */ 0));
ASSERT_EQ(dsize, input_size);
ASSERT_EQ(memcmp(decompressed, input, input_size), 0);
ASSERT_MEMEQ_NN(decompressed, dsize, input, input_size);
}
TEST(decompress_blob_zstd_unknown_size) {
@@ -261,15 +260,14 @@ TEST(decompress_blob_zstd_unknown_size) {
_cleanup_free_ void *decompressed = NULL;
size_t dsize = 0;
ASSERT_OK_ZERO(decompress_blob(COMPRESSION_ZSTD, compressed, st.st_size, &decompressed, &dsize, /* dst_max= */ 0));
ASSERT_EQ(dsize, input_size);
ASSERT_EQ(memcmp(decompressed, input, input_size), 0);
ASSERT_MEMEQ_NN(decompressed, dsize, input, input_size);
/* Decompression capped via dst_max must stop at the requested size. */
decompressed = mfree(decompressed);
dsize = 0;
ASSERT_OK_ZERO(decompress_blob(COMPRESSION_ZSTD, compressed, st.st_size, &decompressed, &dsize, 4096));
ASSERT_EQ(dsize, 4096u);
ASSERT_EQ(memcmp(decompressed, input, 4096), 0);
ASSERT_MEMEQ(decompressed, input, 4096);
/* decompress_startswith() must still find the prefix without a recorded content size. */
_cleanup_free_ void *buf = NULL;
@@ -288,8 +286,8 @@ TEST(decompress_blob_zstd_unknown_size) {
dsize = 0;
ASSERT_OK_ZERO(decompress_blob(COMPRESSION_ZSTD, multiframe, csize * 2, &decompressed, &dsize, /* dst_max= */ 0));
ASSERT_EQ(dsize, input_size * 2);
ASSERT_EQ(memcmp(decompressed, input, input_size), 0);
ASSERT_EQ(memcmp((uint8_t*) decompressed + input_size, input, input_size), 0);
ASSERT_MEMEQ(decompressed, input, input_size);
ASSERT_MEMEQ((uint8_t*) decompressed + input_size, input, input_size);
/* Kernel zboot payloads are usually compressed without a content checksum, which is the case that
* exercises the buffer-growth/buffered-flush logic without the checksum trailer masking
@@ -299,8 +297,7 @@ TEST(decompress_blob_zstd_unknown_size) {
decompressed = mfree(decompressed);
dsize = 0;
ASSERT_OK_ZERO(decompress_blob(COMPRESSION_ZSTD, compressed, csize - 4, &decompressed, &dsize, /* dst_max= */ 0));
ASSERT_EQ(dsize, input_size);
ASSERT_EQ(memcmp(decompressed, input, input_size), 0);
ASSERT_MEMEQ_NN(decompressed, dsize, input, input_size);
/* A valid but short unknown-size stream whose content is shorter than the requested prefix must
* report "too short" (0), not a corruption error. */
@@ -544,7 +541,7 @@ static void compare_fd(int fda, int fdb) {
ASSERT_OK(loop_read_exact(fda, bufa, to_read, /* do_poll= */ false));
ASSERT_OK(loop_read_exact(fdb, bufb, to_read, /* do_poll= */ false));
ASSERT_EQ(memcmp(bufa, bufb, to_read), 0);
ASSERT_MEMEQ(bufa, bufb, to_read);
offset += to_read;
}
}
@@ -791,7 +788,7 @@ TEST(compressor_decompressor_push_api) {
ASSERT_EQ(result.size, sizeof(text) * 4);
for (unsigned i = 0; i < 4; i++)
ASSERT_EQ(memcmp(result.buf + sizeof(text) * i, text, sizeof(text)), 0);
ASSERT_MEMEQ(result.buf + sizeof(text) * i, text, sizeof(text));
free(result.buf);
decompressor = compressor_free(decompressor);
@@ -852,8 +849,7 @@ TEST(decompressor_force) {
ASSERT_OK(decompressor_push(decompressor, full_compressed, total_compressed, test_decompressor_callback, &result));
ASSERT_OK(decompressor_push(decompressor, /* data= */ NULL, /* size= */ 0, test_decompressor_callback, &result));
ASSERT_EQ(result.size, sizeof(text));
ASSERT_EQ(memcmp(result.buf, text, sizeof(text)), 0);
ASSERT_MEMEQ_NN(result.buf, result.size, text, sizeof(text));
free(result.buf);
}
}
@@ -898,8 +894,7 @@ TEST(decompressor_push_output_buffer_boundary) {
ASSERT_OK(decompressor_push(decompressor, full + split, full_size - split, test_decompressor_callback, &result));
ASSERT_OK(decompressor_push(decompressor, /* data= */ NULL, /* size= */ 0, test_decompressor_callback, &result));
ASSERT_EQ(result.size, src_size);
ASSERT_EQ(memcmp(result.buf, src, src_size), 0);
ASSERT_MEMEQ_NN(result.buf, result.size, src, src_size);
free(result.buf);
}
}
src/test/test-copy.c
+15 -16
View File
@@ -20,7 +20,6 @@
#include "io-util.h"
#include "log.h"
#include "memfd-util.h"
#include "memory-util.h"
#include "mkdir.h"
#include "path-util.h"
#include "rm-rf.h"
@@ -429,7 +428,7 @@ TEST_RET(copy_bytes) {
ASSERT_OK_ZERO_ERRNO(lseek(infd, 0, SEEK_SET));
ASSERT_OK_EQ_ERRNO(read(infd, buf2, sizeof(buf2)), n);
ASSERT_EQ(memcmp(buf, buf2, n), 0);
ASSERT_MEMEQ(buf, buf2, n);
/* test copy_bytes with invalid descriptors */
ASSERT_ERROR(copy_bytes(pipefd[0], pipefd[0], 1, /* copy_flags= */ 0), EBADF);
@@ -520,7 +519,7 @@ TEST(copy_bytes_offset) {
ASSERT_EQ(foffset, 8U);
ASSERT_EQ(toffset, 10U);
ASSERT_OK_EQ_ERRNO(pread(dst, buf, sizeof(buf), 0), (ssize_t) sizeof(buf));
ASSERT_EQ(memcmp(buf, "XXXX234567XXXXXX", sizeof(buf)), 0);
ASSERT_MEMEQ(buf, "XXXX234567XXXXXX", sizeof(buf));
ASSERT_OK_EQ_ERRNO(lseek(src, 0, SEEK_CUR), (off_t) 1);
ASSERT_OK_EQ_ERRNO(lseek(dst, 0, SEEK_CUR), (off_t) 2);
@@ -536,7 +535,7 @@ TEST(copy_bytes_offset) {
toffset = 3;
ASSERT_OK_EQ(copy_bytes_offset(src, &foffset, dst, &toffset, /* max_bytes= */ 2, COPY_TRUNCATE), 1);
ASSERT_OK_EQ_ERRNO(pread(dst, buf, sizeof(buf), 0), (ssize_t) 5);
ASSERT_EQ(memcmp(buf, "XXX01", 5), 0);
ASSERT_MEMEQ(buf, "XXX01", 5);
ASSERT_OK_EQ_ERRNO(lseek(dst, 0, SEEK_CUR), (off_t) 2);
/* copy_file_range() refuses pipes. Copying into a pipe tests sendfile() with a source offset. */
@@ -551,7 +550,7 @@ TEST(copy_bytes_offset) {
/* copy_flags= */ 0));
ASSERT_EQ(foffset, 16U);
ASSERT_OK_EQ_ERRNO(read(pipe_fds[0], buf, sizeof(buf)), (ssize_t) 6);
ASSERT_EQ(memcmp(buf, "abcdef", 6), 0);
ASSERT_MEMEQ(buf, "abcdef", 6);
ASSERT_OK_EQ_ERRNO(lseek(src, 0, SEEK_CUR), (off_t) 1);
/* Copying from a pipe tests the fallback to read() and pwrite(). */
@@ -567,7 +566,7 @@ TEST(copy_bytes_offset) {
/* copy_flags= */ 0));
ASSERT_EQ(toffset, 6U);
ASSERT_OK_EQ_ERRNO(pread(dst, buf, sizeof(buf), 0), (ssize_t) 6);
ASSERT_EQ(memcmp(buf, "Xhello", 6), 0);
ASSERT_MEMEQ(buf, "Xhello", 6);
ASSERT_OK_EQ_ERRNO(lseek(dst, 0, SEEK_CUR), (off_t) 2);
}
@@ -610,9 +609,9 @@ TEST(copy_bytes_offset_reflink) {
ASSERT_EQ(toffset, 2 * bs);
ASSERT_OK_EQ_ERRNO(pread(dst, buf, 3 * bs, 0), (ssize_t) (3 * bs));
ASSERT_TRUE(memeqbyte('b', buf, bs));
ASSERT_TRUE(memeqbyte('c', buf + bs, bs));
ASSERT_TRUE(memeqbyte('b', buf + 2 * bs, bs));
ASSERT_MEMEQ_BYTE('b', buf, bs);
ASSERT_MEMEQ_BYTE('c', buf + bs, bs);
ASSERT_MEMEQ_BYTE('b', buf + 2 * bs, bs);
ASSERT_OK_EQ_ERRNO(lseek(src, 0, SEEK_CUR), (off_t) 5);
ASSERT_OK_EQ_ERRNO(lseek(dst, 0, SEEK_CUR), (off_t) 7);
}
@@ -652,11 +651,11 @@ TEST_RET(copy_bytes_offset_holes) {
ASSERT_EQ(toffset, 4 * bs + 1);
ASSERT_OK_EQ_ERRNO(pread(dst, buf, 5 * bs, 0), (ssize_t) (5 * bs));
ASSERT_TRUE(memeqbyte('X', buf, bs + 1));
ASSERT_TRUE(memeqzero(buf + bs + 1, bs));
ASSERT_TRUE(memeqbyte('D', buf + 2 * bs + 1, bs));
ASSERT_TRUE(memeqzero(buf + 3 * bs + 1, bs));
ASSERT_TRUE(memeqbyte('X', buf + 4 * bs + 1, bs - 1));
ASSERT_MEMEQ_BYTE('X', buf, bs + 1);
ASSERT_MEMEQ_ZERO(buf + bs + 1, bs);
ASSERT_MEMEQ_BYTE('D', buf + 2 * bs + 1, bs);
ASSERT_MEMEQ_ZERO(buf + 3 * bs + 1, bs);
ASSERT_MEMEQ_BYTE('X', buf + 4 * bs + 1, bs - 1);
ASSERT_OK_EQ_ERRNO(lseek(src, 0, SEEK_CUR), (off_t) 5);
ASSERT_OK_EQ_ERRNO(lseek(dst, 0, SEEK_CUR), (off_t) 7);
@@ -685,7 +684,7 @@ TEST_RET(copy_bytes_offset_overflow) {
ASSERT_EQ(foffset, 8U);
ASSERT_EQ(toffset, (uint64_t) INT64_MAX);
ASSERT_OK_EQ_ERRNO(pread(dst, buf, sizeof(buf), INT64_MAX - 8), (ssize_t) sizeof(buf));
ASSERT_EQ(memcmp(buf, "01234567", sizeof(buf)), 0);
ASSERT_MEMEQ(buf, "01234567", sizeof(buf));
return 0;
}
@@ -955,7 +954,7 @@ static void assert_fsverity_eq(int dirfd_a, int dirfd_b, const char *name) {
if (enabled_a) {
ASSERT_EQ(digest_a->digest_algorithm, digest_b->digest_algorithm);
ASSERT_EQ(digest_a->digest_size, digest_b->digest_size);
ASSERT_EQ(memcmp(digest_a->digest, digest_b->digest, digest_a->digest_size), 0);
ASSERT_MEMEQ(digest_a->digest, digest_b->digest, digest_a->digest_size);
}
}
src/test/test-cpu-set-util.c
+2 -2
View File
@@ -239,11 +239,11 @@ TEST(cpu_set_to_from_dbus) {
ASSERT_LE(allocated, sizeof expected);
ASSERT_GE(allocated, DIV_ROUND_UP(201u, 8u)); /* We need at least 201 bits for our mask */
ASSERT_EQ(memcmp(array, expected, allocated), 0);
ASSERT_MEMEQ(array, expected, allocated);
ASSERT_OK(cpu_set_from_dbus(array, allocated, &c2));
ASSERT_CPUSET_COUNT(c2, 104);
ASSERT_EQ(memcmp_nn(c.set, c.allocated, c2.set, c2.allocated), 0);
ASSERT_MEMEQ_NN(c.set, c.allocated, c2.set, c2.allocated);
}
TEST(cpus_in_affinity_mask) {
src/test/test-creds.c
+3 -3
View File
@@ -152,7 +152,7 @@ TEST(read_credential_with_decryption) {
_cleanup_(iovec_done_erase) struct iovec result = {};
ASSERT_OK_EQ(read_credential_with_decryption("foo", &result.iov_base, &result.iov_len), 1);
ASSERT_TRUE(iovec_equal(&binary, &result));
ASSERT_IOVEC_EQ(&binary, &result);
}
{
_cleanup_(erase_and_freep) char *text = NULL;
@@ -244,7 +244,7 @@ TEST(read_credential_with_decryption_encrypted) {
WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_TRUNCATE));
ASSERT_OK_EQ(read_credential_with_decryption("foo", &result.iov_base,
&result.iov_len), 1);
ASSERT_TRUE(iovec_equal(&input->data, &result));
ASSERT_IOVEC_EQ(&input->data, &result);
r = read_credential_with_decryption("foo", (void**) &text, /* ret_size= */ NULL);
if (input->contains_nul) {
@@ -384,7 +384,7 @@ static void test_encrypt_decrypt_with(sd_id128_t mode, uid_t uid) {
&decrypted);
ASSERT_OK(r);
ASSERT_TRUE(iovec_equal(&plaintext, &decrypted));
ASSERT_IOVEC_EQ(&plaintext, &decrypted);
}
static bool try_tpm2(void) {
src/test/test-crypto-util.c
+28 -28
View File
@@ -20,10 +20,10 @@ TEST(openssl_pkey_from_pem) {
ASSERT_EQ(curve_id, NID_X9_62_prime256v1);
DEFINE_HEX_PTR(expected_x, "ae39c4b812ec225f6b869870caf5cd3e18f88c19cf0d79f22742bd532acd81de");
ASSERT_EQ(memcmp_nn(x, x_len, expected_x, expected_x_len), 0);
ASSERT_MEMEQ_NN(x, x_len, expected_x, expected_x_len);
DEFINE_HEX_PTR(expected_y, "92e40e764fea12bed9028fa66b9788571b7c004145e9a01952fad1eab51a8be5");
ASSERT_EQ(memcmp_nn(y, y_len, expected_y, expected_y_len), 0);
ASSERT_MEMEQ_NN(y, y_len, expected_y, expected_y_len);
DEFINE_HEX_PTR(key_rsa, "2d2d2d2d2d424547494e205055424c4943204b45592d2d2d2d2d0a4d494942496a414e42676b71686b6947397730424151454641414f43415138414d49494243674b4341514541795639434950652f505852337a436f63787045300a6a575262546c3568585844436b472f584b79374b6d2f4439584942334b734f5a31436a5937375571372f674359363170697838697552756a73413464503165380a593445336c68556d374a332b6473766b626f4b64553243626d52494c2f6675627771694c4d587a41673342575278747234547545443533527a373634554650640a307a70304b68775231496230444c67772f344e67566f314146763378784b4d6478774d45683567676b73733038326332706c354a504e32587677426f744e6b4d0a5471526c745a4a35355244436170696e7153334577376675646c4e735851357746766c7432377a7637344b585165616d704c59433037584f6761304c676c536b0a79754774586b6a50542f735542544a705374615769674d5a6f714b7479563463515a58436b4a52684459614c47587673504233687a766d5671636e6b47654e540a65774944415141420a2d2d2d2d2d454e44205055424c4943204b45592d2d2d2d2d0a");
_cleanup_(EVP_PKEY_freep) EVP_PKEY *pkey_rsa = NULL;
@@ -34,10 +34,10 @@ TEST(openssl_pkey_from_pem) {
ASSERT_OK(rsa_pkey_to_n_e(pkey_rsa, &n, &n_len, &e, &e_len));
DEFINE_HEX_PTR(expected_n, "c95f4220f7bf3d7477cc2a1cc691348d645b4e5e615d70c2906fd72b2eca9bf0fd5c80772ac399d428d8efb52aeff80263ad698b1f22b91ba3b00e1d3f57bc638137961526ec9dfe76cbe46e829d53609b99120bfdfb9bc2a88b317cc0837056471b6be13b840f9dd1cfbeb85053ddd33a742a1c11d486f40cb830ff8360568d4016fdf1c4a31dc7030487982092cb34f36736a65e493cdd97bf0068b4d90c4ea465b59279e510c26a98a7a92dc4c3b7ee76536c5d0e7016f96ddbbcefef829741e6a6a4b602d3b5ce81ad0b8254a4cae1ad5e48cf4ffb140532694ad6968a0319a2a2adc95e1c4195c29094610d868b197bec3c1de1cef995a9c9e419e3537b");
ASSERT_EQ(memcmp_nn(n, n_len, expected_n, expected_n_len), 0);
ASSERT_MEMEQ_NN(n, n_len, expected_n, expected_n_len);
DEFINE_HEX_PTR(expected_e, "010001");
ASSERT_EQ(memcmp_nn(e, e_len, expected_e, expected_e_len), 0);
ASSERT_MEMEQ_NN(e, e_len, expected_e, expected_e_len);
}
TEST(rsa_pkey_n_e) {
@@ -61,9 +61,9 @@ TEST(rsa_pkey_n_e) {
_cleanup_free_ void *n2 = NULL, *e2 = NULL;
size_t n2_size, e2_size;
ASSERT_OK(rsa_pkey_to_n_e(pkey, &n2, &n2_size, &e2, &e2_size));
ASSERT_EQ(memcmp_nn(n, n_len, n2, n2_size), 0);
ASSERT_MEMEQ_NN(n, n_len, n2, n2_size);
ASSERT_LE(e2_size, sizeof(uint32_t));
ASSERT_EQ(memcmp(&((uint8_t*) &e)[sizeof(uint32_t) - e2_size], e2, e2_size), 0);
ASSERT_MEMEQ(&((uint8_t*) &e)[sizeof(uint32_t) - e2_size], e2, e2_size);
}
TEST(ecc_pkey_curve_x_y) {
@@ -90,8 +90,8 @@ TEST(ecc_pkey_curve_x_y) {
int curveid2;
ASSERT_OK(ecc_pkey_to_curve_x_y(pkey, &curveid2, &x2, &x2_size, &y2, &y2_size));
ASSERT_EQ(curveid, curveid2);
ASSERT_EQ(memcmp_nn(x, x_len, x2, x2_size), 0);
ASSERT_EQ(memcmp_nn(y, y_len, y2, y2_size), 0);
ASSERT_MEMEQ_NN(x, x_len, x2, x2_size);
ASSERT_MEMEQ_NN(y, y_len, y2, y2_size);
}
TEST(ecc_pkey_curve_x_y_leading_zero) {
@@ -109,10 +109,10 @@ TEST(ecc_pkey_curve_x_y_leading_zero) {
ASSERT_EQ(curve_id, NID_secp384r1);
DEFINE_HEX_PTR(expected_x, "0066d96e6276481d41247c9cd7180ecc976781782055b4e966f40fa50913546cbcb1bc2fc2c1eb7191ead3366fc7fd65");
ASSERT_EQ(memcmp_nn(x, x_size, expected_x, expected_x_len), 0);
ASSERT_MEMEQ_NN(x, x_size, expected_x, expected_x_len);
DEFINE_HEX_PTR(expected_y, "0bac7365d6951c2d46d3ce7195c949c290995a152a5a17ecfe3a77cc29a70e322e2723d6e42407208d1ef96646a5b708");
ASSERT_EQ(memcmp_nn(y, y_size, expected_y, expected_y_len), 0);
ASSERT_MEMEQ_NN(y, y_size, expected_y, expected_y_len);
}
TEST(ecc_pkey_curve_x_y_p521) {
@@ -130,10 +130,10 @@ TEST(ecc_pkey_curve_x_y_p521) {
ASSERT_EQ(curve_id, NID_secp521r1);
DEFINE_HEX_PTR(expected_x, "00a11cc63c5568cb90b318a97c498bb11f859de92b862df800e5b33e46b5c62f5c81b17283e38ea82f4beed1f36aab39dfcc49bd63d4c6709f4bf16ab127bb7655e4");
ASSERT_EQ(memcmp_nn(x, x_size, expected_x, expected_x_len), 0);
ASSERT_MEMEQ_NN(x, x_size, expected_x, expected_x_len);
DEFINE_HEX_PTR(expected_y, "015059c5923fc8d80edccc709b664932592c9f5699fd7e4a401011b57f92d214cac37f279f212d84b39d39dc9e9d0020dbc9d5d40985f9f4740e2c3d03c8ef10b0ca");
ASSERT_EQ(memcmp_nn(y, y_size, expected_y, expected_y_len), 0);
ASSERT_MEMEQ_NN(y, y_size, expected_y, expected_y_len);
}
TEST(invalid) {
@@ -209,7 +209,7 @@ static void verify_digest(const char *digest_alg, const struct iovec *data, size
ASSERT_OK(r);
DEFINE_HEX_PTR(e, expect);
ASSERT_EQ(memcmp_nn(e, e_len, digest, digest_size), 0);
ASSERT_MEMEQ_NN(e, e_len, digest, digest_size);
}
#define _DEFINE_DIGEST_TEST(uniq, alg, expect, ...) \
@@ -272,16 +272,16 @@ static void verify_hmac(
if (n_data == 0) {
ASSERT_OK_ZERO(openssl_hmac(digest_alg, k, k_len, /* buf= */ NULL, /* len= */ 0, &digest, &digest_size));
ASSERT_EQ(memcmp_nn(e, e_len, digest, digest_size), 0);
ASSERT_MEMEQ_NN(e, e_len, digest, digest_size);
digest = mfree(digest);
} else if(n_data == 1) {
ASSERT_OK_ZERO(openssl_hmac(digest_alg, k, k_len, data[0].iov_base, data[0].iov_len, &digest, &digest_size));
ASSERT_EQ(memcmp_nn(e, e_len, digest, digest_size), 0);
ASSERT_MEMEQ_NN(e, e_len, digest, digest_size);
digest = mfree(digest);
}
ASSERT_OK_ZERO(openssl_hmac_many(digest_alg, k, k_len, data, n_data, &digest, &digest_size));
ASSERT_EQ(memcmp_nn(e, e_len, digest, digest_size), 0);
ASSERT_MEMEQ_NN(e, e_len, digest, digest_size);
}
#define _DEFINE_HMAC_TEST(uniq, alg, key, expect, ...) \
@@ -354,7 +354,7 @@ TEST(kdf_kb_hmac_derive) {
DEFINE_HEX_PTR(expected_derived_key, "A9DA9CEEB9578DBE7DD2862F82898B086E85FF2D10C4E8EC5BD99D0D7F003A2DE1574EB4BD789C03EF5235259BCB3A009DA303EA4DB4CA6BF507DB7C5A063279");
ASSERT_OK(kdf_kb_hmac_derive("COUNTER", "SHA256", key, key_len, salt, strlen(salt), info, info_len, /* seed= */ NULL, /* seed_size= */ 0, 64, &derived_key));
ASSERT_EQ(memcmp_nn(derived_key, 64, expected_derived_key, expected_derived_key_len), 0);
ASSERT_MEMEQ_NN(derived_key, 64, expected_derived_key, expected_derived_key_len);
}
static void check_ss_derive(const char *hex_key, const char *hex_salt, const char *hex_info, const char *hex_expected) {
@@ -365,7 +365,7 @@ static void check_ss_derive(const char *hex_key, const char *hex_salt, const cha
_cleanup_free_ void *derived_key = NULL;
ASSERT_OK(kdf_ss_derive("SHA256", key, key_len, salt, salt_len, info, info_len, expected_len, &derived_key));
ASSERT_EQ(memcmp_nn(derived_key, expected_len, expected, expected_len), 0);
ASSERT_MEMEQ_NN(derived_key, expected_len, expected, expected_len);
}
TEST(kdf_ss_derive) {
@@ -408,7 +408,7 @@ static void check_hkdf_derive(
&IOVEC_MAKE(info, info_len),
expected_len,
&derived));
ASSERT_EQ(memcmp_nn(derived.iov_base, derived.iov_len, expected, expected_len), 0);
ASSERT_MEMEQ_NN(derived.iov_base, derived.iov_len, expected, expected_len);
}
TEST(kdf_hkdf_derive) {
@@ -484,7 +484,7 @@ TEST(kdf_hkdf_derive) {
/* salt= */ NULL,
&IOVEC_MAKE((void*) info, sizeof(info)),
expected_len, &derived));
ASSERT_EQ(memcmp_nn(derived.iov_base, derived.iov_len, expected, expected_len), 0);
ASSERT_MEMEQ_NN(derived.iov_base, derived.iov_len, expected, expected_len);
}
}
@@ -507,16 +507,16 @@ static void check_cipher(
if (n_data == 0) {
ASSERT_OK(openssl_cipher(alg, bits, mode, key, key_len, iv, iv_len, /* buf= */ NULL, /* len= */ 0, &enc_buf, &enc_buf_len));
ASSERT_EQ(memcmp_nn(enc_buf, enc_buf_len, expected, expected_len), 0);
ASSERT_MEMEQ_NN(enc_buf, enc_buf_len, expected, expected_len);
enc_buf = mfree(enc_buf);
} else if (n_data == 1) {
ASSERT_OK(openssl_cipher(alg, bits, mode, key, key_len, iv, iv_len, data[0].iov_base, data[0].iov_len, &enc_buf, &enc_buf_len));
ASSERT_EQ(memcmp_nn(enc_buf, enc_buf_len, expected, expected_len), 0);
ASSERT_MEMEQ_NN(enc_buf, enc_buf_len, expected, expected_len);
enc_buf = mfree(enc_buf);
}
ASSERT_OK(openssl_cipher_many(alg, bits, mode, key, key_len, iv, iv_len, data, n_data, &enc_buf, &enc_buf_len));
ASSERT_EQ(memcmp_nn(enc_buf, enc_buf_len, expected, expected_len), 0);
ASSERT_MEMEQ_NN(enc_buf, enc_buf_len, expected, expected_len);
}
TEST(openssl_cipher) {
@@ -614,8 +614,8 @@ TEST(ecc_ecdh) {
ASSERT_OK(ecc_ecdh(pkeyA, pkeyC, &secretAC, &secretAC_size));
ASSERT_OK(ecc_ecdh(pkeyC, pkeyA, &secretCA, &secretCA_size));
ASSERT_EQ(memcmp_nn(secretAB, secretAB_size, secretBA, secretBA_size), 0);
ASSERT_EQ(memcmp_nn(secretAC, secretAC_size, secretCA, secretCA_size), 0);
ASSERT_MEMEQ_NN(secretAB, secretAB_size, secretBA, secretBA_size);
ASSERT_MEMEQ_NN(secretAC, secretAC_size, secretCA, secretCA_size);
ASSERT_NE(memcmp_nn(secretAC, secretAC_size, secretAB, secretAB_size), 0);
}
@@ -680,7 +680,7 @@ TEST(openssl_load_x509_certificate_from_pem) {
ASSERT_OK(openssl_load_x509_certificate_from_pem(&IOVEC_MAKE_STRING(prefixed), &skipped, &more));
ASSERT_FALSE(more);
ASSERT_OK(x509_fingerprint(skipped, fp2));
ASSERT_EQ(memcmp(fp, fp2, sizeof(fp)), 0);
ASSERT_MEMEQ(fp, fp2, sizeof(fp));
/* The first certificate wins, the second is reported, and ret_more is optional */
_cleanup_free_ char *two = strjoin(pem, pem2);
@@ -688,11 +688,11 @@ TEST(openssl_load_x509_certificate_from_pem) {
ASSERT_OK(openssl_load_x509_certificate_from_pem(&IOVEC_MAKE_STRING(two), &first, &more));
ASSERT_TRUE(more);
ASSERT_OK(x509_fingerprint(first, fp2));
ASSERT_EQ(memcmp(fp, fp2, sizeof(fp)), 0);
ASSERT_MEMEQ(fp, fp2, sizeof(fp));
ASSERT_OK(openssl_load_x509_certificate_from_pem(&IOVEC_MAKE_STRING(two), &first_again,
/* ret_more= */ NULL));
ASSERT_OK(x509_fingerprint(first_again, fp2));
ASSERT_EQ(memcmp(fp, fp2, sizeof(fp)), 0);
ASSERT_MEMEQ(fp, fp2, sizeof(fp));
static const char garbage[] = "-----BEGIN CERTIFICATE-----\nAAAA\n-----END CERTIFICATE-----\n";
ASSERT_FAIL(openssl_load_x509_certificate_from_pem(&IOVEC_MAKE_STRING(garbage), &bad, &more));
src/test/test-data-fd-util.c
+3 -3
View File
@@ -33,7 +33,7 @@ static void assert_equal_fd(int fd1, int fd2) {
if (x == 0)
break;
ASSERT_EQ(memcmp(a, b, x), 0);
ASSERT_MEMEQ(a, b, x);
}
}
@@ -148,7 +148,7 @@ static void test_copy_data_fd_full_one(size_t size) {
copy_fd = ASSERT_OK(copy_data_fd_full(fd, *max_size));
ASSERT_EQ(loop_read(copy_fd, buf, size + 1, /* do_poll= */ false), (ssize_t) size);
ASSERT_EQ(memcmp(buf, data, size), 0);
ASSERT_MEMEQ(buf, data, size);
}
}
@@ -168,7 +168,7 @@ static void assert_fd_contents(int fd, const char *contents) {
ASSERT_TRUE(S_ISREG(st.st_mode));
ASSERT_EQ((size_t) st.st_size, strlen(contents));
ASSERT_EQ(pread(fd, buf, sizeof(buf), 0), (ssize_t) strlen(contents));
ASSERT_EQ(memcmp(buf, contents, strlen(contents)), 0);
ASSERT_MEMEQ(buf, contents, strlen(contents));
}
TEST(open_seekable_data_fd) {
src/test/test-dns-domain.c
+2 -2
View File
@@ -68,7 +68,7 @@ static void test_dns_name_to_wire_format_one(const char *what, const char *expec
if (r >= 0) {
assert(expect); /* for gcc */
ASSERT_EQ(memcmp(buffer, expect, r), 0);
ASSERT_MEMEQ(buffer, expect, r);
}
}
@@ -134,7 +134,7 @@ static void test_dns_name_from_wire_format_one(const char *expect, const uint8_t
if (r >= 0) {
assert(expect); /* for gcc */
ASSERT_EQ(memcmp(name, expect, r), 0);
ASSERT_MEMEQ(name, expect, r);
}
}
src/test/test-ellipsize.c
+1 -1
View File
@@ -183,7 +183,7 @@ TEST(ellipsize_esc_infinite_loop) {
_cleanup_free_ char *t = NULL;
t = ASSERT_NOT_NULL(ellipsize_mem(s, 5, 5, 50));
ASSERT_EQ(memcmp(t, s, 5), 0);
ASSERT_MEMEQ(t, s, 5);
}
DEFINE_TEST_MAIN(LOG_INFO);
src/test/test-escape.c
+4 -4
View File
@@ -139,19 +139,19 @@ TEST(cunescape) {
unescaped = mfree(unescaped);
ASSERT_OK_EQ(cunescape("\\x00\\x00\\x00", UNESCAPE_ACCEPT_NUL, &unescaped), 3);
ASSERT_EQ(memcmp(unescaped, "\0\0\0", 3), 0);
ASSERT_MEMEQ(unescaped, "\0\0\0", 3);
unescaped = mfree(unescaped);
ASSERT_OK_EQ(cunescape("\\u0000\\u0000\\u0000", UNESCAPE_ACCEPT_NUL, &unescaped), 3);
ASSERT_EQ(memcmp(unescaped, "\0\0\0", 3), 0);
ASSERT_MEMEQ(unescaped, "\0\0\0", 3);
unescaped = mfree(unescaped);
ASSERT_OK_EQ(cunescape("\\U00000000\\U00000000\\U00000000", UNESCAPE_ACCEPT_NUL, &unescaped), 3);
ASSERT_EQ(memcmp(unescaped, "\0\0\0", 3), 0);
ASSERT_MEMEQ(unescaped, "\0\0\0", 3);
unescaped = mfree(unescaped);
ASSERT_OK_EQ(cunescape("\\000\\000\\000", UNESCAPE_ACCEPT_NUL, &unescaped), 3);
ASSERT_EQ(memcmp(unescaped, "\0\0\0", 3), 0);
ASSERT_MEMEQ(unescaped, "\0\0\0", 3);
}
static void test_shell_escape_one(const char *s, const char *bad, const char *expected) {
src/test/test-fd-util.c
+1 -1
View File
@@ -255,7 +255,7 @@ TEST(rearrange_stdio) {
ASSERT_OK_EQ_ERRNO(read(pipe_read_fd, buffer, sizeof(buffer)), 1);
ASSERT_EQ(buffer[0], 'z');
ASSERT_OK_EQ_ERRNO(read(0, buffer, sizeof(buffer)), 6);
ASSERT_EQ(memcmp(buffer, "foobar", 6), 0);
ASSERT_MEMEQ(buffer, "foobar", 6);
ASSERT_OK(fd_cloexec(1, /* cloexec= */ true)); /* stays in place, but the flag must still be cleared */
ASSERT_OK(rearrange_stdio(-EBADF, 1, 2));
src/test/test-fileio.c
+14 -21
View File
@@ -561,47 +561,41 @@ TEST(read_full_file_full) {
ASSERT_OK(fflush_and_check(f));
ASSERT_OK(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, SIZE_MAX, /* flags= */ 0, /* bind_name= */ NULL, &rbuf, &rbuf_size));
ASSERT_EQ(rbuf_size, sizeof(buf));
ASSERT_EQ(memcmp(buf, rbuf, rbuf_size), 0);
ASSERT_MEMEQ_NN(buf, sizeof(buf), rbuf, rbuf_size);
rbuf = mfree(rbuf);
ASSERT_OK(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, 128, /* flags= */ 0, /* bind_name= */ NULL, &rbuf, &rbuf_size));
ASSERT_EQ(rbuf_size, 128U);
ASSERT_EQ(memcmp(buf, rbuf, rbuf_size), 0);
ASSERT_MEMEQ(buf, rbuf, rbuf_size);
rbuf = mfree(rbuf);
ASSERT_ERROR(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, 128, READ_FULL_FILE_FAIL_WHEN_LARGER, /* bind_name= */ NULL, &rbuf, &rbuf_size), E2BIG);
ASSERT_ERROR(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, sizeof(buf)-1, READ_FULL_FILE_FAIL_WHEN_LARGER, /* bind_name= */ NULL, &rbuf, &rbuf_size), E2BIG);
ASSERT_OK(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, sizeof(buf), READ_FULL_FILE_FAIL_WHEN_LARGER, /* bind_name= */ NULL, &rbuf, &rbuf_size));
ASSERT_EQ(rbuf_size, sizeof(buf));
ASSERT_EQ(memcmp(buf, rbuf, rbuf_size), 0);
ASSERT_MEMEQ_NN(buf, sizeof(buf), rbuf, rbuf_size);
rbuf = mfree(rbuf);
ASSERT_ERROR(read_full_file_full(AT_FDCWD, fn, 47, 128, READ_FULL_FILE_FAIL_WHEN_LARGER, /* bind_name= */ NULL, &rbuf, &rbuf_size), E2BIG);
ASSERT_ERROR(read_full_file_full(AT_FDCWD, fn, 47, sizeof(buf)-47-1, READ_FULL_FILE_FAIL_WHEN_LARGER, /* bind_name= */ NULL, &rbuf, &rbuf_size), E2BIG);
ASSERT_OK(read_full_file_full(AT_FDCWD, fn, 47, sizeof(buf)-47, READ_FULL_FILE_FAIL_WHEN_LARGER, /* bind_name= */ NULL, &rbuf, &rbuf_size));
ASSERT_EQ(rbuf_size, sizeof(buf)-47);
ASSERT_EQ(memcmp(buf+47, rbuf, rbuf_size), 0);
ASSERT_MEMEQ_NN(buf+47, sizeof(buf)-47, rbuf, rbuf_size);
rbuf = mfree(rbuf);
ASSERT_OK(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, sizeof(buf)+1, READ_FULL_FILE_FAIL_WHEN_LARGER, /* bind_name= */ NULL, &rbuf, &rbuf_size));
ASSERT_EQ(rbuf_size, sizeof(buf));
ASSERT_EQ(memcmp(buf, rbuf, rbuf_size), 0);
ASSERT_MEMEQ_NN(buf, sizeof(buf), rbuf, rbuf_size);
rbuf = mfree(rbuf);
ASSERT_OK(read_full_file_full(AT_FDCWD, fn, 1234, SIZE_MAX, /* flags= */ 0, /* bind_name= */ NULL, &rbuf, &rbuf_size));
ASSERT_EQ(rbuf_size, sizeof(buf) - 1234);
ASSERT_EQ(memcmp(buf + 1234, rbuf, rbuf_size), 0);
ASSERT_MEMEQ_NN(buf + 1234, sizeof(buf) - 1234, rbuf, rbuf_size);
rbuf = mfree(rbuf);
ASSERT_OK(read_full_file_full(AT_FDCWD, fn, 2345, 777, /* flags= */ 0, /* bind_name= */ NULL, &rbuf, &rbuf_size));
ASSERT_EQ(rbuf_size, 777U);
ASSERT_EQ(memcmp(buf + 2345, rbuf, rbuf_size), 0);
ASSERT_MEMEQ(buf + 2345, rbuf, rbuf_size);
rbuf = mfree(rbuf);
ASSERT_OK(read_full_file_full(AT_FDCWD, fn, 4700, 20, /* flags= */ 0, /* bind_name= */ NULL, &rbuf, &rbuf_size));
ASSERT_EQ(rbuf_size, 11U);
ASSERT_EQ(memcmp(buf + 4700, rbuf, rbuf_size), 0);
ASSERT_MEMEQ_NN(buf + 4700, 11U, rbuf, rbuf_size);
rbuf = mfree(rbuf);
ASSERT_OK(read_full_file_full(AT_FDCWD, fn, 10000, 99, /* flags= */ 0, /* bind_name= */ NULL, &rbuf, &rbuf_size));
@@ -612,8 +606,7 @@ TEST(read_full_file_full) {
_cleanup_close_ int fd = -EBADF;
ASSERT_OK(fd = xopenat(AT_FDCWD, fn, O_RDONLY));
ASSERT_OK(read_full_file_at(fd, /* filename= */ NULL, &rbuf, &rbuf_size));
ASSERT_EQ(rbuf_size, sizeof(buf));
ASSERT_EQ(memcmp(buf, rbuf, rbuf_size), 0);
ASSERT_MEMEQ_NN(buf, sizeof(buf), rbuf, rbuf_size);
}
TEST(xfopenat_empty_path) {
@@ -750,13 +743,13 @@ TEST(write_data_file_atomic_at) {
_cleanup_(iovec_done) struct iovec ra = {};
ASSERT_OK(read_full_file(abs_wdfa, (char**) &ra.iov_base, &ra.iov_len));
ASSERT_TRUE(iovec_equal(&a, &ra));
ASSERT_IOVEC_EQ(&a, &ra);
ASSERT_OK_ERRNO(unlink(abs_wdfa));
ASSERT_OK(write_data_file_atomic_at(XAT_FDROOT, rel_wdfa, &a, /* flags= */ 0));
iovec_done(&ra);
ASSERT_OK(read_full_file(abs_wdfa, (char**) &ra.iov_base, &ra.iov_len));
ASSERT_TRUE(iovec_equal(&a, &ra));
ASSERT_IOVEC_EQ(&a, &ra);
ASSERT_OK_ERRNO(unlink(abs_wdfa));
ASSERT_ERROR(write_data_file_atomic_at(AT_FDCWD, /* path= */ NULL, &a, /* flags= */ 0), EINVAL);
@@ -772,13 +765,13 @@ TEST(write_data_file_atomic_at) {
ASSERT_OK(write_data_file_atomic_at(AT_FDCWD, "wdfa", &a, /* flags= */ 0));
iovec_done(&ra);
ASSERT_OK(read_full_file(abs_wdfa, (char**) &ra.iov_base, &ra.iov_len));
ASSERT_TRUE(iovec_equal(&a, &ra));
ASSERT_IOVEC_EQ(&a, &ra);
ASSERT_OK_ERRNO(unlink(abs_wdfa));
ASSERT_OK(write_data_file_atomic_at(XAT_FDROOT, rel_wdfa, &a, /* flags= */ 0));
iovec_done(&ra);
ASSERT_OK(read_full_file(abs_wdfa, (char**) &ra.iov_base, &ra.iov_len));
ASSERT_TRUE(iovec_equal(&a, &ra));
ASSERT_IOVEC_EQ(&a, &ra);
ASSERT_OK_ERRNO(unlink(abs_wdfa));
ASSERT_OK_ERRNO(chdir(cwd));
@@ -787,7 +780,7 @@ TEST(write_data_file_atomic_at) {
ASSERT_OK(write_data_file_atomic_at(XAT_FDROOT, rel_zzz_wdfa, &a, WRITE_DATA_FILE_MKDIR_0755));
iovec_done(&ra);
ASSERT_OK(read_full_file(abs_zzz_wdfa, (char**) &ra.iov_base, &ra.iov_len));
ASSERT_TRUE(iovec_equal(&a, &ra));
ASSERT_IOVEC_EQ(&a, &ra);
ASSERT_OK_ERRNO(unlink(abs_zzz_wdfa));
r = write_data_file_atomic_at(AT_FDCWD, abs_zzz, &a, /* flags= */ 0);
src/test/test-fs-util.c
-2
View File
@@ -737,8 +737,6 @@ TEST(xopenat_full) {
/* Test that we can reopen an existing fd with xopenat_full() by specifying an empty path. */
assert_se((fd = xopenat_full(tfd, "def", O_PATH, /* xopen_flags= */ 0, /* mode= */ 0)) >= 0);
assert_se((fd2 = xopenat_full(fd, "", O_RDWR, XO_EMPTY_PATH, 0644)) >= 0);
fd = ASSERT_OK(xopenat_full(tfd, "def", O_PATH, /* xopen_flags= */ 0, /* mode= */ 0));
fd2 = ASSERT_OK(xopenat_full(fd, "", O_RDWR, XO_EMPTY_PATH, 0644));
}
src/test/test-fsprg.c
+12 -12
View File
@@ -318,12 +318,12 @@ TEST(fsprg) {
/* Verify state */
if (i < ELEMENTSOF(expected_state))
ASSERT_TRUE(iovec_equal(&state, &IOVEC_MAKE(expected_state[i], sizeof(expected_state[i]))));
ASSERT_IOVEC_EQ(&state, &IOVEC_MAKE(expected_state[i], sizeof(expected_state[i])));
/* Verify key */
ASSERT_OK(FSPRG_GetKey(state.iov_base, key.iov_base, key.iov_len, /* idx= */ 0));
if (i < ELEMENTSOF(expected_key))
ASSERT_TRUE(iovec_equal(&key, &IOVEC_MAKE(expected_key[i], sizeof(expected_key[i]))));
ASSERT_IOVEC_EQ(&key, &IOVEC_MAKE(expected_key[i], sizeof(expected_key[i])));
/* Verify epoch */
ASSERT_EQ(FSPRG_GetEpoch(state.iov_base), (uint64_t) i);
@@ -333,12 +333,12 @@ TEST(fsprg) {
/* Generate state by FSPRG_GetState0() */
ASSERT_OK(FSPRG_GenState0(state.iov_base, mpk.iov_base, seed.iov_base, seed.iov_len));
ASSERT_TRUE(iovec_equal(&state, &states[0]));
ASSERT_IOVEC_EQ(&state, &states[0]);
/* Generate states by FSPRG_Evolve() */
for (size_t i = 1; i < n_states; i++) {
ASSERT_OK(FSPRG_Evolve(state.iov_base));
ASSERT_TRUE(iovec_equal(&state, &states[i]));
ASSERT_IOVEC_EQ(&state, &states[i]);
}
}
@@ -355,12 +355,12 @@ TEST(fsprg) {
/* Verify state */
if (i < ELEMENTSOF(expected_state))
ASSERT_EQ(iovec_memcmp(&state, &IOVEC_MAKE(expected_state[i], sizeof(expected_state[i]))), 0);
ASSERT_IOVEC_EQ(&state, &IOVEC_MAKE(expected_state[i], sizeof(expected_state[i])));
/* Verify key */
ASSERT_OK(fsprg_get_key(&state, &key));
if (i < ELEMENTSOF(expected_key))
ASSERT_EQ(iovec_memcmp(&key, &IOVEC_MAKE(expected_key[i], sizeof(expected_key[i]))), 0);
ASSERT_IOVEC_EQ(&key, &IOVEC_MAKE(expected_key[i], sizeof(expected_key[i])));
/* Verify epoch */
uint64_t epoch;
@@ -368,19 +368,19 @@ TEST(fsprg) {
ASSERT_EQ(epoch, (uint64_t) i);
if (iovec_is_set(&states[i]))
ASSERT_EQ(iovec_memcmp(&state, &states[i]), 0);
ASSERT_IOVEC_EQ(&state, &states[i]);
else
ASSERT_NOT_NULL(iovec_memdup(&state, &states[i]));
}
/* Generate state by fsprg_generate_state(0) */
ASSERT_OK(fsprg_generate_state(FSPRG_RECOMMENDED_SECPAR, /* epoch= */ 0, &seed, &state));
ASSERT_EQ(iovec_memcmp(&state, &states[0]), 0);
ASSERT_IOVEC_EQ(&state, &states[0]);
/* Generate states by fsprg_evolve() */
for (unsigned i = 1; i < n_states; i++) {
ASSERT_OK(fsprg_evolve(&state));
ASSERT_EQ(iovec_memcmp(&state, &states[i]), 0);
ASSERT_IOVEC_EQ(&state, &states[i]);
}
}
}
@@ -440,7 +440,7 @@ TEST(hmac) {
/* Verify tag */
if (i < ELEMENTSOF(expected_tag))
ASSERT_TRUE(iovec_equal(&tag, &IOVEC_MAKE(expected_tag[i], sizeof(expected_tag[i]))));
ASSERT_IOVEC_EQ(&tag, &IOVEC_MAKE(expected_tag[i], sizeof(expected_tag[i])));
/* Save tag */
ASSERT_NOT_NULL(iovec_memdup(&tag, &tags[i]));
@@ -487,11 +487,11 @@ TEST(hmac) {
/* Verify tag */
if (i < ELEMENTSOF(expected_tag))
ASSERT_TRUE(iovec_equal(&tag, &IOVEC_MAKE(expected_tag[i], sizeof(expected_tag[i]))));
ASSERT_IOVEC_EQ(&tag, &IOVEC_MAKE(expected_tag[i], sizeof(expected_tag[i])));
/* Compare with the tag generated by gcrypt */
if (iovec_is_set(&tags[i]))
ASSERT_TRUE(iovec_equal(&tag, &tags[i]));
ASSERT_IOVEC_EQ(&tag, &tags[i]);
/* Increment epoch */
ASSERT_OK(fsprg_evolve(&state));
src/test/test-gpt.c
+3 -4
View File
@@ -7,7 +7,6 @@
#include "gpt.h"
#include "log.h"
#include "memfd-util.h"
#include "memory-util.h"
#include "pretty-print.h"
#include "strv.h"
#include "tests.h"
@@ -275,8 +274,8 @@ TEST(gpt_probe_sector_512) {
ASSERT_NOT_NULL(ret_entries);
GptPartitionEntry *e = ret_entries;
ASSERT_EQ(memcmp_nn(e[0].unique_partition_guid, sizeof(e[0].unique_partition_guid), entries[0].unique_partition_guid, sizeof(entries[0].unique_partition_guid)), 0);
ASSERT_EQ(memcmp_nn(e[1].unique_partition_guid, sizeof(e[1].unique_partition_guid), entries[1].unique_partition_guid, sizeof(entries[1].unique_partition_guid)), 0);
ASSERT_MEMEQ_NN(e[0].unique_partition_guid, sizeof(e[0].unique_partition_guid), entries[0].unique_partition_guid, sizeof(entries[0].unique_partition_guid));
ASSERT_MEMEQ_NN(e[1].unique_partition_guid, sizeof(e[1].unique_partition_guid), entries[1].unique_partition_guid, sizeof(entries[1].unique_partition_guid));
ASSERT_EQ(le64toh(e[0].starting_lba), UINT64_C(100));
ASSERT_EQ(le64toh(e[1].starting_lba), UINT64_C(300));
}
@@ -302,7 +301,7 @@ TEST(gpt_probe_sector_4096) {
ASSERT_EQ(n, 1u);
GptPartitionEntry *e = ret_entries;
ASSERT_EQ(memcmp_nn(e[0].unique_partition_guid, sizeof(e[0].unique_partition_guid), entry.unique_partition_guid, sizeof(entry.unique_partition_guid)), 0);
ASSERT_MEMEQ_NN(e[0].unique_partition_guid, sizeof(e[0].unique_partition_guid), entry.unique_partition_guid, sizeof(entry.unique_partition_guid));
ASSERT_EQ(le64toh(e[0].starting_lba), UINT64_C(50));
}
src/test/test-hashmap-plain.c
+3 -6
View File
@@ -935,8 +935,7 @@ TEST(hashmap_dump_sorted) {
ASSERT_OK_EQ(hashmap_put(m, "key 2", expected[2]), 1);
ASSERT_OK(hashmap_dump_sorted(m, &vals, &n));
ASSERT_EQ(n, ELEMENTSOF(expected));
ASSERT_EQ(memcmp(vals, expected, n * sizeof(void*)), 0);
ASSERT_MEMEQ_NN(vals, n * sizeof(void*), expected, ELEMENTSOF(expected) * sizeof(void*));
vals = mfree(vals);
@@ -959,14 +958,12 @@ TEST(hashmap_dump_sorted) {
ASSERT_OK_EQ(hashmap_put(m, UINT_TO_PTR(111U), expected[0]), 1);
ASSERT_OK(hashmap_dump_sorted(m, &vals, &n));
ASSERT_EQ(n, ELEMENTSOF(expected));
ASSERT_EQ(memcmp(vals, expected, n * sizeof(void*)), 0);
ASSERT_MEMEQ_NN(vals, n * sizeof(void*), expected, ELEMENTSOF(expected) * sizeof(void*));
vals = mfree(vals);
ASSERT_OK(hashmap_dump_keys_sorted(m, &vals, &n));
ASSERT_EQ(n, ELEMENTSOF(expected_keys2));
ASSERT_EQ(memcmp(vals, expected_keys2, n * sizeof(void*)), 0);
ASSERT_MEMEQ_NN(vals, n * sizeof(void*), expected_keys2, ELEMENTSOF(expected_keys2) * sizeof(void*));
}
/* Signal to test-hashmap.c that tests from this compilation unit were run. */
src/test/test-hexdecoct.c
+7 -34
View File
@@ -80,7 +80,7 @@ static void test_hexmem_one(const char *in, const char *expected) {
ASSERT_STREQ(result, expected);
ASSERT_OK(unhexmem(result, &mem, &len));
ASSERT_EQ(memcmp_safe(mem, in, len), 0);
ASSERT_MEMEQ(mem, in, len);
}
TEST(hexmem) {
@@ -301,15 +301,13 @@ TEST(base64mem_linebreak) {
ASSERT_EQ((size_t) l, strlen(encoded));
ASSERT_OK(unbase64mem(encoded, &decoded, &decoded_size));
ASSERT_EQ(decoded_size, n);
ASSERT_EQ(memcmp(data, decoded, n), 0);
ASSERT_MEMEQ_NN(data, n, decoded, decoded_size);
/* Also try in secure mode */
decoded = mfree(decoded);
decoded_size = 0;
ASSERT_OK(unbase64mem_full(encoded, SIZE_MAX, /* secure= */ true, &decoded, &decoded_size));
ASSERT_EQ(decoded_size, n);
ASSERT_EQ(memcmp(data, decoded, n), 0);
ASSERT_MEMEQ_NN(data, n, decoded, decoded_size);
for (size_t j = 0; j < (size_t) l; j++)
ASSERT_EQ(encoded[j] == '\n', j % (m + 1) == m);
@@ -435,8 +433,7 @@ static void test_unbase64mem_one(const char *input, const char *output, int ret)
ASSERT_EQ(unbase64mem(input, &buffer, &size), ret);
if (ret >= 0) {
ASSERT_EQ(size, strlen(output));
ASSERT_EQ(memcmp(buffer, output, size), 0);
ASSERT_MEMEQ_NN(buffer, size, output, strlen(output));
ASSERT_EQ(((char*) buffer)[size], 0);
}
@@ -446,8 +443,7 @@ static void test_unbase64mem_one(const char *input, const char *output, int ret)
ASSERT_EQ(unbase64mem_full(input, SIZE_MAX, /* secure= */ true, &buffer, &size), ret);
if (ret >= 0) {
ASSERT_EQ(size, strlen(output));
ASSERT_EQ(memcmp(buffer, output, size), 0);
ASSERT_MEMEQ_NN(buffer, size, output, strlen(output));
ASSERT_EQ(((char*) buffer)[size], 0);
}
}
@@ -478,29 +474,6 @@ TEST(unbase64mem) {
test_unbase64mem_one(" Z m 8 = q u u x ", /* output= */ NULL, -ENAMETOOLONG);
}
TEST(hexdump) {
uint8_t data[146];
unsigned i;
hexdump(stdout, NULL, 0);
hexdump(stdout, "", 0);
hexdump(stdout, "", SIZE_MAX);
hexdump(stdout, "", 1);
hexdump(stdout, "x", 1);
hexdump(stdout, "x", SIZE_MAX);
hexdump(stdout, "x", 2);
hexdump(stdout, "foobar", 7);
hexdump(stdout, "foobar", SIZE_MAX);
hexdump(stdout, "f\nobar", 7);
hexdump(stdout, "f\nobar", SIZE_MAX);
hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
for (i = 0; i < ELEMENTSOF(data); i++)
data[i] = i*2;
hexdump(stdout, data, sizeof(data));
}
TEST(base64withwithouturl) {
static const uint8_t plaintext[] = {
0xcc, 0xa1, 0x72, 0x22, 0xae, 0xda, 0x66, 0x7e, 0x04, 0xa6, 0xe0, 0x82,
@@ -519,12 +492,12 @@ TEST(base64withwithouturl) {
/* This is regular base64 */
ASSERT_OK(unbase64mem("zKFyIq7aZn4EpuCCmpcF9jPgD8JFE1g/xfT0Mas8X4M0WycyigRsQ4IH4yysufus0AORQsuk3oeGhRC7t1tLyKD0Ih0VcYedv5+p8e6itqrIwzecu98+rNyUVDhWBzS0PMwxEw==", &buffer, &size));
ASSERT_EQ(memcmp_nn(plaintext, sizeof(plaintext), buffer, size), 0);
ASSERT_MEMEQ_NN(plaintext, sizeof(plaintext), buffer, size);
buffer = mfree(buffer);
/* This is the same but in base64url */
ASSERT_OK(unbase64mem("zKFyIq7aZn4EpuCCmpcF9jPgD8JFE1g_xfT0Mas8X4M0WycyigRsQ4IH4yysufus0AORQsuk3oeGhRC7t1tLyKD0Ih0VcYedv5-p8e6itqrIwzecu98-rNyUVDhWBzS0PMwxEw==", &buffer, &size));
ASSERT_EQ(memcmp_nn(plaintext, sizeof(plaintext), buffer, size), 0);
ASSERT_MEMEQ_NN(plaintext, sizeof(plaintext), buffer, size);
/* Hint: use xxd -i to generate the static C array from some data, and basenc --base64 + basenc
* --base64url to generate the correctly encoded base64 strings */
src/test/test-hexdump.c
+95
View File
@@ -0,0 +1,95 @@
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "hexdump.h"
#include "iovec-util.h"
#include "iovec-wrapper.h"
#include "tests.h"
TEST(hexdump) {
uint8_t data[146];
unsigned i;
hexdump(stdout, NULL, 0);
hexdump(stdout, "", 0);
hexdump(stdout, "", SIZE_MAX);
hexdump(stdout, "", 1);
hexdump(stdout, "x", 1);
hexdump(stdout, "x", SIZE_MAX);
hexdump(stdout, "x", 2);
hexdump(stdout, "foobar", 7);
hexdump(stdout, "foobar", SIZE_MAX);
hexdump(stdout, "f\nobar", 7);
hexdump(stdout, "f\nobar", SIZE_MAX);
hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
for (i = 0; i < ELEMENTSOF(data); i++)
data[i] = i*2;
hexdump(stdout, data, sizeof(data));
}
TEST(hexdump_memcmp) {
static const uint8_t a[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11 };
static const uint8_t b[] = { 0x00, 0x01, 0xff, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10 };
/* Equal regions: no marker lines, just the two sides. */
_cleanup_free_ char *s = ASSERT_NOT_NULL(hexdump_memcmp(a, sizeof(a), a, sizeof(a)));
log_info("equal:\n%s", s);
/* Differing byte and differing length. */
free(s);
s = ASSERT_NOT_NULL(hexdump_memcmp(a, sizeof(a), b, sizeof(b)));
log_info("differ:\n%s", s);
/* Empty regions are fine. */
free(s);
s = ASSERT_NOT_NULL(hexdump_memcmp(NULL, 0, NULL, 0));
ASSERT_STREQ(s, "");
}
TEST(hexdump_memcmp_byte) {
static const uint8_t a[] = { 'x', 'x', 'x', 'y', 'x', 'x' };
/* All bytes match 'byte': no marker lines. */
_cleanup_free_ char *s = ASSERT_NOT_NULL(hexdump_memcmp_byte('x', (const uint8_t[]) { 'x', 'x' }, 2));
log_info("all equal:\n%s", s);
/* One byte differs from 'byte'. */
free(s);
s = ASSERT_NOT_NULL(hexdump_memcmp_byte('x', a, sizeof(a)));
log_info("differ:\n%s", s);
/* Empty region is fine. */
free(s);
s = ASSERT_NOT_NULL(hexdump_memcmp_byte(0x00, NULL, 0));
ASSERT_STREQ(s, "");
}
TEST(hexdump_iovw_compare) {
struct iovec iov_a[] = { IOVEC_MAKE_STRING("foo"), IOVEC_MAKE_STRING("bar") };
struct iovec iov_b[] = { IOVEC_MAKE_STRING("foo"), IOVEC_MAKE_STRING("baz") };
struct iovec_wrapper wa = { .iovec = iov_a, .count = ELEMENTSOF(iov_a) };
struct iovec_wrapper wb = { .iovec = iov_b, .count = ELEMENTSOF(iov_b) };
/* Equal wrappers: empty dump. */
_cleanup_free_ char *s = ASSERT_NOT_NULL(hexdump_iovw_compare(&wa, &wa));
ASSERT_STREQ(s, "");
/* One element differs. */
free(s);
s = ASSERT_NOT_NULL(hexdump_iovw_compare(&wa, &wb));
log_info("differ:\n%s", s);
/* Different element count. */
struct iovec_wrapper wc = { .iovec = iov_a, .count = 1 };
free(s);
s = ASSERT_NOT_NULL(hexdump_iovw_compare(&wa, &wc));
log_info("count differ:\n%s", s);
}
DEFINE_TEST_MAIN(LOG_INFO);
src/test/test-initrd-cpio.c
+2 -4
View File
@@ -75,16 +75,14 @@ TEST_RET(initrd_cpio_credentials_basic) {
ASSERT_TRUE(S_ISREG(st.st_mode));
ASSERT_EQ((mode_t) (st.st_mode & 07777), (mode_t) 0400);
ASSERT_OK(read_full_file(foo_path, &foo_content, &foo_size));
ASSERT_EQ(foo_size, 5U);
ASSERT_EQ(memcmp(foo_content, "hello", 5), 0);
ASSERT_MEMEQ_NN(foo_content, foo_size, "hello", 5);
ASSERT_NOT_NULL(bar_path = path_join(extract_dir, ".extra/system_credentials/bar.cred"));
ASSERT_OK_ERRNO(stat(bar_path, &st));
ASSERT_TRUE(S_ISREG(st.st_mode));
ASSERT_EQ((mode_t) (st.st_mode & 07777), (mode_t) 0400);
ASSERT_OK(read_full_file(bar_path, &bar_content, &bar_size));
ASSERT_EQ(bar_size, 7U);
ASSERT_EQ(memcmp(bar_content, "abc\0def", 7), 0);
ASSERT_MEMEQ_NN(bar_content, bar_size, "abc\0def", 7);
return 0;
}
src/test/test-io-util.c
+3 -3
View File
@@ -23,7 +23,7 @@ static void test_sparse_write_one(int fd, const char *buffer, size_t n) {
ASSERT_OK_EQ_ERRNO(lseek(fd, 0, SEEK_SET), 0);
ASSERT_OK_EQ_ERRNO(read(fd, check, n), (ssize_t) n);
ASSERT_EQ(memcmp(buffer, check, n), 0);
ASSERT_MEMEQ(buffer, check, n);
}
TEST(sparse_write) {
@@ -73,7 +73,7 @@ TEST(pwritev_full) {
ASSERT_OK(pwritev_full(fd, iovec, n, 7, &written));
ASSERT_EQ(written, sizeof(expected));
ASSERT_EQ(pread(fd, buf, sizeof(buf), 7), (ssize_t) sizeof(buf));
ASSERT_EQ(memcmp(buf, expected, sizeof(expected)), 0);
ASSERT_MEMEQ(buf, expected, sizeof(expected));
/* Written iovecs are advanced past the data */
FOREACH_ARRAY(i, iovec, n)
@@ -89,7 +89,7 @@ TEST(pwrite_full) {
ASSERT_OK(pwrite_full(fd, /* buf= */ NULL, /* nbytes= */ 0, /* offset= */ 0));
ASSERT_OK(pwrite_full(fd, "abc", 3, 5));
ASSERT_EQ(pread(fd, buf, sizeof(buf), 5), (ssize_t) sizeof(buf));
ASSERT_EQ(memcmp(buf, "abc", 3), 0);
ASSERT_MEMEQ(buf, "abc", 3);
}
DEFINE_TEST_MAIN(LOG_INFO);
src/test/test-iovec-util.c
+41 -41
View File
@@ -8,11 +8,11 @@
TEST(iovec_shift) {
const struct iovec iov = CONST_IOVEC_MAKE_STRING("54321");
ASSERT_EQ(iovec_memcmp(&IOVEC_SHIFT(&iov, 0), &CONST_IOVEC_MAKE_STRING("54321")), 0);
ASSERT_EQ(iovec_memcmp(&IOVEC_SHIFT(&iov, 1), &CONST_IOVEC_MAKE_STRING("4321")), 0);
ASSERT_EQ(iovec_memcmp(&IOVEC_SHIFT(&iov, 2), &CONST_IOVEC_MAKE_STRING("321")), 0);
ASSERT_EQ(iovec_memcmp(&IOVEC_SHIFT(&iov, 3), &CONST_IOVEC_MAKE_STRING("21")), 0);
ASSERT_EQ(iovec_memcmp(&IOVEC_SHIFT(&iov, 4), &CONST_IOVEC_MAKE_STRING("1")), 0);
ASSERT_IOVEC_EQ(&IOVEC_SHIFT(&iov, 0), &CONST_IOVEC_MAKE_STRING("54321"));
ASSERT_IOVEC_EQ(&IOVEC_SHIFT(&iov, 1), &CONST_IOVEC_MAKE_STRING("4321"));
ASSERT_IOVEC_EQ(&IOVEC_SHIFT(&iov, 2), &CONST_IOVEC_MAKE_STRING("321"));
ASSERT_IOVEC_EQ(&IOVEC_SHIFT(&iov, 3), &CONST_IOVEC_MAKE_STRING("21"));
ASSERT_IOVEC_EQ(&IOVEC_SHIFT(&iov, 4), &CONST_IOVEC_MAKE_STRING("1"));
ASSERT_FALSE(iovec_is_set(&IOVEC_SHIFT(&iov, 5)));
ASSERT_FALSE(iovec_is_set(&IOVEC_SHIFT(&iov, 6)));
ASSERT_FALSE(iovec_is_set(&IOVEC_SHIFT(&iov, 7)));
@@ -25,11 +25,11 @@ TEST(iovec_shift) {
TEST(iovec_inc) {
struct iovec iov = IOVEC_MAKE_STRING("54321");
ASSERT_EQ(iovec_memcmp(iovec_inc(&iov, /* shift= */ 0), &CONST_IOVEC_MAKE_STRING("54321")), 0);
ASSERT_EQ(iovec_memcmp(iovec_inc(&iov, 1), &CONST_IOVEC_MAKE_STRING("4321")), 0);
ASSERT_EQ(iovec_memcmp(iovec_inc(&iov, 1), &CONST_IOVEC_MAKE_STRING("321")), 0);
ASSERT_EQ(iovec_memcmp(iovec_inc(&iov, 1), &CONST_IOVEC_MAKE_STRING("21")), 0);
ASSERT_EQ(iovec_memcmp(iovec_inc(&iov, 1), &CONST_IOVEC_MAKE_STRING("1")), 0);
ASSERT_IOVEC_EQ(iovec_inc(&iov, /* shift= */ 0), &CONST_IOVEC_MAKE_STRING("54321"));
ASSERT_IOVEC_EQ(iovec_inc(&iov, 1), &CONST_IOVEC_MAKE_STRING("4321"));
ASSERT_IOVEC_EQ(iovec_inc(&iov, 1), &CONST_IOVEC_MAKE_STRING("321"));
ASSERT_IOVEC_EQ(iovec_inc(&iov, 1), &CONST_IOVEC_MAKE_STRING("21"));
ASSERT_IOVEC_EQ(iovec_inc(&iov, 1), &CONST_IOVEC_MAKE_STRING("1"));
ASSERT_FALSE(iovec_is_set(iovec_inc(&iov, 1)));
ASSERT_FALSE(iovec_is_set(iovec_inc(&iov, 1)));
ASSERT_FALSE(iovec_is_set(iovec_inc(&iov, 1)));
@@ -50,28 +50,28 @@ TEST(iovec_inc_many) {
ASSERT_OK(iovw_put_iov(&iovw, &IOVEC_MAKE_STRING("ccc")));
ASSERT_FALSE(iovec_inc_many(iovw.iovec, iovw.count, 0));
ASSERT_TRUE(iovec_equal(&iovw.iovec[0], &IOVEC_MAKE_STRING("aaa")));
ASSERT_TRUE(iovec_equal(&iovw.iovec[1], &IOVEC_MAKE_STRING("bbb")));
ASSERT_TRUE(iovec_equal(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc")));
ASSERT_IOVEC_EQ(&iovw.iovec[0], &IOVEC_MAKE_STRING("aaa"));
ASSERT_IOVEC_EQ(&iovw.iovec[1], &IOVEC_MAKE_STRING("bbb"));
ASSERT_IOVEC_EQ(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc"));
ASSERT_FALSE(iovec_inc_many(iovw.iovec, iovw.count, 1));
ASSERT_TRUE(iovec_equal(&iovw.iovec[0], &IOVEC_MAKE_STRING("aa")));
ASSERT_TRUE(iovec_equal(&iovw.iovec[1], &IOVEC_MAKE_STRING("bbb")));
ASSERT_TRUE(iovec_equal(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc")));
ASSERT_IOVEC_EQ(&iovw.iovec[0], &IOVEC_MAKE_STRING("aa"));
ASSERT_IOVEC_EQ(&iovw.iovec[1], &IOVEC_MAKE_STRING("bbb"));
ASSERT_IOVEC_EQ(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc"));
ASSERT_FALSE(iovec_inc_many(iovw.iovec, iovw.count, 3));
ASSERT_FALSE(iovec_is_set(&iovw.iovec[0]));
ASSERT_NULL(iovw.iovec[0].iov_base);
ASSERT_EQ(iovw.iovec[0].iov_len, 0u);
ASSERT_TRUE(iovec_equal(&iovw.iovec[1], &IOVEC_MAKE_STRING("bb")));
ASSERT_TRUE(iovec_equal(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc")));
ASSERT_IOVEC_EQ(&iovw.iovec[1], &IOVEC_MAKE_STRING("bb"));
ASSERT_IOVEC_EQ(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc"));
ASSERT_FALSE(iovec_inc_many(iovw.iovec, iovw.count, 4));
ASSERT_NULL(iovw.iovec[0].iov_base);
ASSERT_EQ(iovw.iovec[0].iov_len, 0u);
ASSERT_NULL(iovw.iovec[1].iov_base);
ASSERT_EQ(iovw.iovec[1].iov_len, 0u);
ASSERT_TRUE(iovec_equal(&iovw.iovec[2], &IOVEC_MAKE_STRING("c")));
ASSERT_IOVEC_EQ(&iovw.iovec[2], &IOVEC_MAKE_STRING("c"));
ASSERT_TRUE(iovec_inc_many(iovw.iovec, iovw.count, 1));
ASSERT_NULL(iovw.iovec[0].iov_base);
@@ -98,13 +98,13 @@ TEST(iovec_memcmp) {
struct iovec iov1_truncated = iov1;
iov1_truncated.iov_len /= 2;
ASSERT_EQ(iovec_memcmp(NULL, NULL), 0);
ASSERT_EQ(iovec_memcmp(&iov1, &iov1), 0);
ASSERT_EQ(iovec_memcmp(&iov2, &iov2), 0);
ASSERT_EQ(iovec_memcmp(&empty, &empty), 0);
ASSERT_EQ(iovec_memcmp(&iov1_truncated, &iov1_truncated), 0);
ASSERT_EQ(iovec_memcmp(&empty, NULL), 0);
ASSERT_EQ(iovec_memcmp(NULL, &empty), 0);
ASSERT_IOVEC_EQ(NULL, NULL);
ASSERT_IOVEC_EQ(&iov1, &iov1);
ASSERT_IOVEC_EQ(&iov2, &iov2);
ASSERT_IOVEC_EQ(&empty, &empty);
ASSERT_IOVEC_EQ(&iov1_truncated, &iov1_truncated);
ASSERT_IOVEC_EQ(&empty, NULL);
ASSERT_IOVEC_EQ(NULL, &empty);
ASSERT_LT(iovec_memcmp(&iov1, &iov2), 0);
ASSERT_GT(iovec_memcmp(&iov2, &iov1), 0);
ASSERT_GT(iovec_memcmp(&iov1, &empty), 0);
@@ -121,7 +121,7 @@ TEST(iovec_memcmp) {
_cleanup_(iovec_done) struct iovec copy = {};
ASSERT_NOT_NULL(iovec_memdup(&iov1, &copy));
ASSERT_EQ(iovec_memcmp(&iov1, &copy), 0);
ASSERT_IOVEC_EQ(&iov1, &copy);
}
TEST(iovec_set_and_valid) {
@@ -153,7 +153,7 @@ TEST(iovec_append) {
ASSERT_PTR_EQ(iovec_append(&iov, &IOVEC_MAKE_STRING("p")), &iov);
ASSERT_PTR_EQ(iovec_append(&iov, &IOVEC_MAKE_STRING("")), &iov);
ASSERT_EQ(iovec_memcmp(&iov, &IOVEC_MAKE_STRING("waldoquuxp")), 0);
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("waldoquuxp"));
}
TEST(iovec_consume) {
@@ -169,28 +169,28 @@ TEST(iovec_consume) {
/* Reducing by more than the length fails, and leaves the iovec unmodified */
ASSERT_NULL(iovec_consume(&iov, 12));
ASSERT_EQ(iovec_memcmp(&iov, &IOVEC_MAKE_STRING("foobarwaldo")), 0);
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("foobarwaldo"));
ASSERT_PTR_EQ(iovec_consume(&iov, 0), &iov);
ASSERT_EQ(iovec_memcmp(&iov, &IOVEC_MAKE_STRING("foobarwaldo")), 0);
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("foobarwaldo"));
ASSERT_PTR_EQ(iovec_consume(&iov, 3), &iov);
ASSERT_EQ(iovec_memcmp(&iov, &IOVEC_MAKE_STRING("barwaldo")), 0);
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("barwaldo"));
ASSERT_PTR_EQ(iovec_consume(&iov, 3), &iov);
ASSERT_EQ(iovec_memcmp(&iov, &IOVEC_MAKE_STRING("waldo")), 0);
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("waldo"));
/* Appending after reducing must continue right after the remaining data, i.e. the reduce must not
* confuse the length bookkeeping the append relies on. This is the read-then-consume cycle the
* users of this helper go through. */
ASSERT_PTR_EQ(iovec_append(&iov, &IOVEC_MAKE_STRING("quux")), &iov);
ASSERT_EQ(iovec_memcmp(&iov, &IOVEC_MAKE_STRING("waldoquux")), 0);
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("waldoquux"));
ASSERT_PTR_EQ(iovec_consume(&iov, 5), &iov);
ASSERT_EQ(iovec_memcmp(&iov, &IOVEC_MAKE_STRING("quux")), 0);
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("quux"));
ASSERT_PTR_EQ(iovec_append(&iov, &IOVEC_MAKE_STRING("piff")), &iov);
ASSERT_EQ(iovec_memcmp(&iov, &IOVEC_MAKE_STRING("quuxpiff")), 0);
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("quuxpiff"));
/* Reducing by the full remaining length empties the iovec, but keeps the buffer allocated */
ASSERT_PTR_EQ(iovec_consume(&iov, 8), &iov);
@@ -207,7 +207,7 @@ TEST(iovec_make_byte) {
struct iovec x = IOVEC_MAKE_BYTE('x');
ASSERT_EQ(x.iov_len, 1U);
ASSERT_EQ(memcmp_nn(x.iov_base, x.iov_len, "x", 1), 0);
ASSERT_MEMEQ_NN(x.iov_base, x.iov_len, "x", 1);
}
TEST(iovec_done_and_memdup) {
@@ -218,21 +218,21 @@ TEST(iovec_done_and_memdup) {
ASSERT_OK_ZERO(iovec_done_and_memdup(&iov, &(struct iovec) {}));
ASSERT_TRUE(!iovec_is_set(&iov));
ASSERT_OK_POSITIVE(iovec_done_and_memdup(&iov, &IOVEC_MAKE_STRING("aaa")));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE_STRING("aaa")));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("aaa"));
ASSERT_OK_POSITIVE(iovec_done_and_memdup(&iov, &IOVEC_MAKE_STRING("bbbbb")));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE_STRING("bbbbb")));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("bbbbb"));
ASSERT_OK_POSITIVE(iovec_done_and_memdup(&iov, /* source= */ NULL));
ASSERT_TRUE(!iovec_is_set(&iov));
ASSERT_OK_POSITIVE(iovec_done_and_memdup(&iov, &IOVEC_MAKE_STRING("ccc")));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE_STRING("ccc")));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("ccc"));
ASSERT_OK_POSITIVE(iovec_done_and_memdup(&iov, &(struct iovec) {}));
ASSERT_TRUE(!iovec_is_set(&iov));
ASSERT_OK_ZERO(iovec_done_and_memdup(&iov, &iov));
ASSERT_TRUE(!iovec_is_set(&iov));
ASSERT_OK_POSITIVE(iovec_done_and_memdup(&iov, &IOVEC_MAKE_STRING("ddd")));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE_STRING("ddd")));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("ddd"));
ASSERT_OK_ZERO(iovec_done_and_memdup(&iov, &iov));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE_STRING("ddd")));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE_STRING("ddd"));
}
DEFINE_TEST_MAIN(LOG_INFO);
src/test/test-iovec-wrapper.c
+90 -106
View File
@@ -44,24 +44,24 @@ TEST(iovw_compare) {
ASSERT_LT(iovw_compare(NULL, &a1), 0);
ASSERT_EQ(iovw_compare(NULL, NULL), 0);
ASSERT_TRUE(iovw_equal(&a1, &a1));
ASSERT_TRUE(iovw_equal(&a1, &a2));
ASSERT_TRUE(iovw_equal(&a2, &a1));
ASSERT_IOVW_EQ(&a1, &a1);
ASSERT_IOVW_EQ(&a1, &a2);
ASSERT_IOVW_EQ(&a2, &a1);
ASSERT_FALSE(iovw_equal(&a1, &b));
ASSERT_FALSE(iovw_equal(&b, &a1));
ASSERT_TRUE(iovw_equal(&b, &b));
ASSERT_IOVW_EQ(&b, &b);
ASSERT_FALSE(iovw_equal(&a1, &c));
ASSERT_FALSE(iovw_equal(&c, &a1));
ASSERT_TRUE(iovw_equal(&c, &c));
ASSERT_IOVW_EQ(&c, &c);
ASSERT_FALSE(iovw_equal(&a1, &d));
ASSERT_FALSE(iovw_equal(&d, &a1));
ASSERT_TRUE(iovw_equal(&d, &d));
ASSERT_IOVW_EQ(&d, &d);
ASSERT_FALSE(iovw_equal(&a1, &e));
ASSERT_FALSE(iovw_equal(&e, &a1));
ASSERT_TRUE(iovw_equal(&e, &e));
ASSERT_IOVW_EQ(&e, &e);
ASSERT_FALSE(iovw_equal(&a1, NULL));
ASSERT_FALSE(iovw_equal(NULL, &a1));
ASSERT_TRUE(iovw_equal(NULL, NULL));
ASSERT_IOVW_EQ(NULL, NULL);
}
TEST(iovw_put) {
@@ -77,18 +77,15 @@ TEST(iovw_put) {
ASSERT_OK(iovw_put(&iovw, (char*) "q", 1));
ASSERT_EQ(iovw.count, 3U);
ASSERT_EQ(iovw.iovec[0].iov_len, 3U);
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "foo", 3), 0);
ASSERT_EQ(iovw.iovec[1].iov_len, 6U);
ASSERT_EQ(memcmp(iovw.iovec[1].iov_base, "barbar", 6), 0);
ASSERT_EQ(iovw.iovec[2].iov_len, 1U);
ASSERT_EQ(memcmp(iovw.iovec[2].iov_base, "q", 1), 0);
ASSERT_MEMEQ_NN(iovw.iovec[0].iov_base, iovw.iovec[0].iov_len, "foo", 3);
ASSERT_MEMEQ_NN(iovw.iovec[1].iov_base, iovw.iovec[1].iov_len, "barbar", 6);
ASSERT_MEMEQ_NN(iovw.iovec[2].iov_base, iovw.iovec[2].iov_len, "q", 1);
ASSERT_OK(iovw_put_full(&iovw, /* accept_zero= */ false, /* data= */ NULL, /* len= */ 0));
ASSERT_EQ(iovw.count, 3U);
ASSERT_OK(iovw_put_full(&iovw, /* accept_zero= */ true, /* data= */ NULL, /* len= */ 0));
ASSERT_EQ(iovw.count, 4U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[3], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&iovw.iovec[3], &(struct iovec) {});
}
TEST(iovw_put_iov) {
@@ -104,15 +101,15 @@ TEST(iovw_put_iov) {
ASSERT_OK(iovw_put_iov(&iovw, &IOVEC_MAKE_STRING("bbb")));
ASSERT_OK(iovw_put_iov(&iovw, &IOVEC_MAKE_STRING("ccc")));
ASSERT_EQ(iovw.count, 3U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[0], &IOVEC_MAKE_STRING("aaa")));
ASSERT_TRUE(iovec_equal(&iovw.iovec[1], &IOVEC_MAKE_STRING("bbb")));
ASSERT_TRUE(iovec_equal(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc")));
ASSERT_IOVEC_EQ(&iovw.iovec[0], &IOVEC_MAKE_STRING("aaa"));
ASSERT_IOVEC_EQ(&iovw.iovec[1], &IOVEC_MAKE_STRING("bbb"));
ASSERT_IOVEC_EQ(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc"));
ASSERT_OK(iovw_put_iov_full(&iovw, /* accept_zero= */ false, &(struct iovec) {}));
ASSERT_EQ(iovw.count, 3U);
ASSERT_OK(iovw_put_iov_full(&iovw, /* accept_zero= */ true, &(struct iovec) {}));
ASSERT_EQ(iovw.count, 4U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[3], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&iovw.iovec[3], &(struct iovec) {});
}
TEST(iovw_put_iovw) {
@@ -137,12 +134,12 @@ TEST(iovw_put_iovw) {
ASSERT_OK(iovw_put_iovw(&target, &source));
ASSERT_EQ(target.count, 6U);
ASSERT_TRUE(iovec_equal(&target.iovec[0], &IOVEC_MAKE_STRING("xxx")));
ASSERT_TRUE(iovec_equal(&target.iovec[1], &IOVEC_MAKE_STRING("yyy")));
ASSERT_TRUE(iovec_equal(&target.iovec[2], &IOVEC_MAKE_STRING("zzz")));
ASSERT_TRUE(iovec_equal(&target.iovec[3], &IOVEC_MAKE_STRING("aaa")));
ASSERT_TRUE(iovec_equal(&target.iovec[4], &IOVEC_MAKE_STRING("bbb")));
ASSERT_TRUE(iovec_equal(&target.iovec[5], &IOVEC_MAKE_STRING("ccc")));
ASSERT_IOVEC_EQ(&target.iovec[0], &IOVEC_MAKE_STRING("xxx"));
ASSERT_IOVEC_EQ(&target.iovec[1], &IOVEC_MAKE_STRING("yyy"));
ASSERT_IOVEC_EQ(&target.iovec[2], &IOVEC_MAKE_STRING("zzz"));
ASSERT_IOVEC_EQ(&target.iovec[3], &IOVEC_MAKE_STRING("aaa"));
ASSERT_IOVEC_EQ(&target.iovec[4], &IOVEC_MAKE_STRING("bbb"));
ASSERT_IOVEC_EQ(&target.iovec[5], &IOVEC_MAKE_STRING("ccc"));
/* iovw_put_iovw() does not copy data, hence the pointers must be equal */
ASSERT_PTR_EQ(target.iovec[3].iov_base, source.iovec[0].iov_base);
@@ -151,23 +148,23 @@ TEST(iovw_put_iovw) {
/* Source is unchanged */
ASSERT_EQ(source.count, 4U);
ASSERT_TRUE(iovec_equal(&source.iovec[0], &IOVEC_MAKE_STRING("aaa")));
ASSERT_TRUE(iovec_equal(&source.iovec[1], &IOVEC_MAKE_STRING("bbb")));
ASSERT_TRUE(iovec_equal(&source.iovec[2], &IOVEC_MAKE_STRING("ccc")));
ASSERT_TRUE(iovec_equal(&source.iovec[3], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&source.iovec[0], &IOVEC_MAKE_STRING("aaa"));
ASSERT_IOVEC_EQ(&source.iovec[1], &IOVEC_MAKE_STRING("bbb"));
ASSERT_IOVEC_EQ(&source.iovec[2], &IOVEC_MAKE_STRING("ccc"));
ASSERT_IOVEC_EQ(&source.iovec[3], &(struct iovec) {});
ASSERT_OK(iovw_put_iovw_full(&target, /* accept_zero= */ true, &source));
ASSERT_EQ(target.count, 10U);
ASSERT_TRUE(iovec_equal(&target.iovec[0], &IOVEC_MAKE_STRING("xxx")));
ASSERT_TRUE(iovec_equal(&target.iovec[1], &IOVEC_MAKE_STRING("yyy")));
ASSERT_TRUE(iovec_equal(&target.iovec[2], &IOVEC_MAKE_STRING("zzz")));
ASSERT_TRUE(iovec_equal(&target.iovec[3], &IOVEC_MAKE_STRING("aaa")));
ASSERT_TRUE(iovec_equal(&target.iovec[4], &IOVEC_MAKE_STRING("bbb")));
ASSERT_TRUE(iovec_equal(&target.iovec[5], &IOVEC_MAKE_STRING("ccc")));
ASSERT_TRUE(iovec_equal(&target.iovec[6], &IOVEC_MAKE_STRING("aaa")));
ASSERT_TRUE(iovec_equal(&target.iovec[7], &IOVEC_MAKE_STRING("bbb")));
ASSERT_TRUE(iovec_equal(&target.iovec[8], &IOVEC_MAKE_STRING("ccc")));
ASSERT_TRUE(iovec_equal(&target.iovec[9], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&target.iovec[0], &IOVEC_MAKE_STRING("xxx"));
ASSERT_IOVEC_EQ(&target.iovec[1], &IOVEC_MAKE_STRING("yyy"));
ASSERT_IOVEC_EQ(&target.iovec[2], &IOVEC_MAKE_STRING("zzz"));
ASSERT_IOVEC_EQ(&target.iovec[3], &IOVEC_MAKE_STRING("aaa"));
ASSERT_IOVEC_EQ(&target.iovec[4], &IOVEC_MAKE_STRING("bbb"));
ASSERT_IOVEC_EQ(&target.iovec[5], &IOVEC_MAKE_STRING("ccc"));
ASSERT_IOVEC_EQ(&target.iovec[6], &IOVEC_MAKE_STRING("aaa"));
ASSERT_IOVEC_EQ(&target.iovec[7], &IOVEC_MAKE_STRING("bbb"));
ASSERT_IOVEC_EQ(&target.iovec[8], &IOVEC_MAKE_STRING("ccc"));
ASSERT_IOVEC_EQ(&target.iovec[9], &(struct iovec) {});
/* Cannot pass the same objects */
ASSERT_ERROR(iovw_put_iovw(&target, &target), EINVAL);
@@ -185,24 +182,22 @@ TEST(iovw_extend) {
char buf[4] = { 'o', 'n', 'e', '\0' };
ASSERT_OK(iovw_extend(&iovw, buf, 3));
ASSERT_EQ(iovw.count, 1U);
ASSERT_EQ(iovw.iovec[0].iov_len, 3U);
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "one", 3), 0);
ASSERT_MEMEQ_NN(iovw.iovec[0].iov_base, iovw.iovec[0].iov_len, "one", 3);
/* Insert with a NUL */
ASSERT_OK(iovw_extend(&iovw, buf, 4));
ASSERT_EQ(iovw.count, 2U);
ASSERT_EQ(iovw.iovec[1].iov_len, 4U);
ASSERT_EQ(memcmp(iovw.iovec[1].iov_base, "one\0", 4), 0);
ASSERT_MEMEQ_NN(iovw.iovec[1].iov_base, iovw.iovec[1].iov_len, "one\0", 4);
/* Mutating the caller's buffer does not affect what's stored */
memset(buf, 'X', sizeof buf);
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "one", 3), 0);
ASSERT_MEMEQ(iovw.iovec[0].iov_base, "one", 3);
ASSERT_OK(iovw_extend_full(&iovw, /* accept_zero= */ false, /* data= */ NULL, /* len= */ 0));
ASSERT_EQ(iovw.count, 2U);
ASSERT_OK(iovw_extend_full(&iovw, /* accept_zero= */ true, /* data= */ NULL, /* len= */ 0));
ASSERT_EQ(iovw.count, 3U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[2], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&iovw.iovec[2], &(struct iovec) {});
}
TEST(iovw_extend_iov) {
@@ -217,15 +212,15 @@ TEST(iovw_extend_iov) {
ASSERT_OK(iovw_extend_iov(&iovw, &IOVEC_MAKE_STRING("bbb")));
ASSERT_OK(iovw_extend_iov(&iovw, &IOVEC_MAKE_STRING("ccc")));
ASSERT_EQ(iovw.count, 3U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[0], &IOVEC_MAKE_STRING("aaa")));
ASSERT_TRUE(iovec_equal(&iovw.iovec[1], &IOVEC_MAKE_STRING("bbb")));
ASSERT_TRUE(iovec_equal(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc")));
ASSERT_IOVEC_EQ(&iovw.iovec[0], &IOVEC_MAKE_STRING("aaa"));
ASSERT_IOVEC_EQ(&iovw.iovec[1], &IOVEC_MAKE_STRING("bbb"));
ASSERT_IOVEC_EQ(&iovw.iovec[2], &IOVEC_MAKE_STRING("ccc"));
ASSERT_OK(iovw_extend_iov_full(&iovw, /* accept_zero= */ false, &(struct iovec) {}));
ASSERT_EQ(iovw.count, 3U);
ASSERT_OK(iovw_extend_iov_full(&iovw, /* accept_zero= */ true, &(struct iovec) {}));
ASSERT_EQ(iovw.count, 4U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[3], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&iovw.iovec[3], &(struct iovec) {});
}
TEST(iovw_extend_iovw) {
@@ -254,19 +249,17 @@ TEST(iovw_extend_iovw) {
ASSERT_TRUE(target.iovec[1].iov_base != source.iovec[0].iov_base);
ASSERT_TRUE(target.iovec[2].iov_base != source.iovec[1].iov_base);
ASSERT_EQ(target.iovec[1].iov_len, 3U);
ASSERT_EQ(memcmp(target.iovec[1].iov_base, "one", 3), 0);
ASSERT_EQ(target.iovec[2].iov_len, 6U);
ASSERT_EQ(memcmp(target.iovec[2].iov_base, "twotwo", 6), 0);
ASSERT_MEMEQ_NN(target.iovec[1].iov_base, target.iovec[1].iov_len, "one", 3);
ASSERT_MEMEQ_NN(target.iovec[2].iov_base, target.iovec[2].iov_len, "twotwo", 6);
ASSERT_OK(iovw_extend_iovw_full(&target, /* accept_zero= */ true, &source));
ASSERT_EQ(target.count, 6U);
ASSERT_TRUE(iovec_equal(&target.iovec[0], &IOVEC_MAKE_STRING("zero")));
ASSERT_TRUE(iovec_equal(&target.iovec[1], &IOVEC_MAKE_STRING("one")));
ASSERT_TRUE(iovec_equal(&target.iovec[2], &IOVEC_MAKE_STRING("twotwo")));
ASSERT_TRUE(iovec_equal(&target.iovec[3], &IOVEC_MAKE_STRING("one")));
ASSERT_TRUE(iovec_equal(&target.iovec[4], &IOVEC_MAKE_STRING("twotwo")));
ASSERT_TRUE(iovec_equal(&target.iovec[5], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&target.iovec[0], &IOVEC_MAKE_STRING("zero"));
ASSERT_IOVEC_EQ(&target.iovec[1], &IOVEC_MAKE_STRING("one"));
ASSERT_IOVEC_EQ(&target.iovec[2], &IOVEC_MAKE_STRING("twotwo"));
ASSERT_IOVEC_EQ(&target.iovec[3], &IOVEC_MAKE_STRING("one"));
ASSERT_IOVEC_EQ(&target.iovec[4], &IOVEC_MAKE_STRING("twotwo"));
ASSERT_IOVEC_EQ(&target.iovec[5], &(struct iovec) {});
/* Source is unchanged */
ASSERT_EQ(source.count, 3U);
@@ -295,11 +288,11 @@ TEST(iovw_consume) {
ASSERT_EQ(iovw.count, 1U);
ASSERT_OK(iovw_consume_full(&iovw, /* accept_zero= */ true, /* data= */ NULL, /* len= */ 0));
ASSERT_EQ(iovw.count, 2U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[1], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&iovw.iovec[1], &(struct iovec) {});
q = ASSERT_NOT_NULL(strdup(""));
ASSERT_OK(iovw_consume_full(&iovw, /* accept_zero= */ true, q, /* len= */ 0));
ASSERT_EQ(iovw.count, 3U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[2], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&iovw.iovec[2], &(struct iovec) {});
}
TEST(iovw_consume_iov) {
@@ -335,14 +328,14 @@ TEST(iovw_consume_iov) {
ASSERT_EQ(iovw.count, 1U);
ASSERT_OK(iovw_consume_iov_full(&iovw, /* accept_zero= */ true, &(struct iovec) {}));
ASSERT_EQ(iovw.count, 2U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[1], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&iovw.iovec[1], &(struct iovec) {});
iov = (struct iovec) {
.iov_base = ASSERT_NOT_NULL(strdup("")),
.iov_len = 0,
};
ASSERT_OK(iovw_consume_iov_full(&iovw, /* accept_zero= */ true, &iov));
ASSERT_EQ(iovw.count, 3U);
ASSERT_TRUE(iovec_equal(&iovw.iovec[2], &(struct iovec) {}));
ASSERT_IOVEC_EQ(&iovw.iovec[2], &(struct iovec) {});
}
TEST(iovw_isempty) {
@@ -362,18 +355,14 @@ TEST(iovw_put_string_field) {
ASSERT_OK(iovw_put_string_field(&iovw, "BAZ=", "quux"));
ASSERT_EQ(iovw.count, 2U);
ASSERT_EQ(iovw.iovec[0].iov_len, strlen("FOO=bar"));
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "FOO=bar", strlen("FOO=bar")), 0);
ASSERT_EQ(iovw.iovec[1].iov_len, strlen("BAZ=quux"));
ASSERT_EQ(memcmp(iovw.iovec[1].iov_base, "BAZ=quux", strlen("BAZ=quux")), 0);
ASSERT_MEMEQ_NN(iovw.iovec[0].iov_base, iovw.iovec[0].iov_len, "FOO=bar", strlen("FOO=bar"));
ASSERT_MEMEQ_NN(iovw.iovec[1].iov_base, iovw.iovec[1].iov_len, "BAZ=quux", strlen("BAZ=quux"));
/* Non-replacing put: a second FOO= just appends rather than replacing */
ASSERT_OK(iovw_put_string_field(&iovw, "FOO=", "second"));
ASSERT_EQ(iovw.count, 3U);
ASSERT_EQ(iovw.iovec[0].iov_len, strlen("FOO=bar"));
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "FOO=bar", strlen("FOO=bar")), 0);
ASSERT_EQ(iovw.iovec[2].iov_len, strlen("FOO=second"));
ASSERT_EQ(memcmp(iovw.iovec[2].iov_base, "FOO=second", strlen("FOO=second")), 0);
ASSERT_MEMEQ_NN(iovw.iovec[0].iov_base, iovw.iovec[0].iov_len, "FOO=bar", strlen("FOO=bar"));
ASSERT_MEMEQ_NN(iovw.iovec[2].iov_base, iovw.iovec[2].iov_len, "FOO=second", strlen("FOO=second"));
}
TEST(iovw_replace_string_field) {
@@ -382,14 +371,12 @@ TEST(iovw_replace_string_field) {
/* If the field does not exist yet, replace acts like put */
ASSERT_OK(iovw_replace_string_field(&iovw, "A=", "1"));
ASSERT_EQ(iovw.count, 1U);
ASSERT_EQ(iovw.iovec[0].iov_len, strlen("A=1"));
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "A=1", strlen("A=1")), 0);
ASSERT_MEMEQ_NN(iovw.iovec[0].iov_base, iovw.iovec[0].iov_len, "A=1", strlen("A=1"));
/* Replacing an existing field updates it in place */
ASSERT_OK(iovw_replace_string_field(&iovw, "A=", "twentytwo"));
ASSERT_EQ(iovw.count, 1U);
ASSERT_EQ(iovw.iovec[0].iov_len, strlen("A=twentytwo"));
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "A=twentytwo", strlen("A=twentytwo")), 0);
ASSERT_MEMEQ_NN(iovw.iovec[0].iov_base, iovw.iovec[0].iov_len, "A=twentytwo", strlen("A=twentytwo"));
/* Distinct field still appends */
ASSERT_OK(iovw_replace_string_field(&iovw, "B=", "x"));
@@ -401,14 +388,12 @@ TEST(iovw_put_string_fieldf) {
ASSERT_OK(iovw_put_string_fieldf(&iovw, "N=", "%d-%s", 42, "answer"));
ASSERT_EQ(iovw.count, 1U);
ASSERT_EQ(iovw.iovec[0].iov_len, strlen("N=42-answer"));
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "N=42-answer", strlen("N=42-answer")), 0);
ASSERT_MEMEQ_NN(iovw.iovec[0].iov_base, iovw.iovec[0].iov_len, "N=42-answer", strlen("N=42-answer"));
/* Replacing variant */
ASSERT_OK(iovw_replace_string_fieldf(&iovw, "N=", "%d", 7));
ASSERT_EQ(iovw.count, 1U);
ASSERT_EQ(iovw.iovec[0].iov_len, strlen("N=7"));
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "N=7", strlen("N=7")), 0);
ASSERT_MEMEQ_NN(iovw.iovec[0].iov_base, iovw.iovec[0].iov_len, "N=7", strlen("N=7"));
}
TEST(iovw_put_string_field_free) {
@@ -419,8 +404,7 @@ TEST(iovw_put_string_field_free) {
ASSERT_NOT_NULL(v);
ASSERT_OK(iovw_put_string_field_free(&iovw, "K=", v));
ASSERT_EQ(iovw.count, 1U);
ASSERT_EQ(iovw.iovec[0].iov_len, strlen("K=hello"));
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, "K=hello", strlen("K=hello")), 0);
ASSERT_MEMEQ_NN(iovw.iovec[0].iov_base, iovw.iovec[0].iov_len, "K=hello", strlen("K=hello"));
}
TEST(iovw_rebase) {
@@ -453,9 +437,9 @@ TEST(iovw_rebase) {
ASSERT_EQ(iovw.iovec[2].iov_len, 8U);
/* And the contents through the new base match what we staged there */
ASSERT_EQ(memcmp(iovw.iovec[0].iov_base, new_base + 0, 4), 0);
ASSERT_EQ(memcmp(iovw.iovec[1].iov_base, new_base + 10, 2), 0);
ASSERT_EQ(memcmp(iovw.iovec[2].iov_base, new_base + 30, 8), 0);
ASSERT_MEMEQ(iovw.iovec[0].iov_base, new_base + 0, 4);
ASSERT_MEMEQ(iovw.iovec[1].iov_base, new_base + 10, 2);
ASSERT_MEMEQ(iovw.iovec[2].iov_base, new_base + 30, 8);
}
TEST(iovw_size) {
@@ -485,7 +469,7 @@ TEST(iovw_concat) {
ASSERT_OK(iovw_put(&iovw, (char*) "bar", 4));
ASSERT_OK(iovw_concat(&iovw, &iov));
ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE("foo\0bar\0", 8)));
ASSERT_IOVEC_EQ(&iov, &IOVEC_MAKE("foo\0bar\0", 8));
}
TEST(iovw_to_cstring) {
@@ -524,10 +508,10 @@ TEST(iovw_merge_and_iovec_split) {
ASSERT_EQ(v.iov_len, 1 + a.iov_len);
p = ASSERT_NOT_NULL(v.iov_base);
ASSERT_EQ(*p++, a.iov_len);
ASSERT_EQ(memcmp(p, a.iov_base, a.iov_len), 0);
ASSERT_MEMEQ(p, a.iov_base, a.iov_len);
p += a.iov_len;
ASSERT_OK(iovec_split(&v, sizeof(uint8_t), &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
iovec_done(&v);
iovw_done_free(&iovw2);
@@ -537,10 +521,10 @@ TEST(iovw_merge_and_iovec_split) {
p = ASSERT_NOT_NULL(v.iov_base);
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, a.iov_len);
ASSERT_EQ(memcmp(p, a.iov_base, a.iov_len), 0);
ASSERT_MEMEQ(p, a.iov_base, a.iov_len);
p += a.iov_len;
ASSERT_OK(iovec_split(&v, sizeof(uint16_t), &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
iovec_done(&v);
iovw_done_free(&iovw2);
@@ -552,10 +536,10 @@ TEST(iovw_merge_and_iovec_split) {
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, a.iov_len);
ASSERT_EQ(memcmp(p, a.iov_base, a.iov_len), 0);
ASSERT_MEMEQ(p, a.iov_base, a.iov_len);
p += a.iov_len;
ASSERT_OK(iovec_split(&v, sizeof(uint32_t), &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
iovec_done(&v);
iovw_done_free(&iovw2);
@@ -568,15 +552,15 @@ TEST(iovw_merge_and_iovec_split) {
ASSERT_EQ(v.iov_len, 3 + a.iov_len + b.iov_len + c.iov_len);
p = ASSERT_NOT_NULL(v.iov_base);
ASSERT_EQ(*p++, a.iov_len);
ASSERT_EQ(memcmp(p, a.iov_base, a.iov_len), 0);
ASSERT_MEMEQ(p, a.iov_base, a.iov_len);
p += a.iov_len;
ASSERT_EQ(*p++, b.iov_len);
ASSERT_EQ(memcmp(p, b.iov_base, b.iov_len), 0);
ASSERT_MEMEQ(p, b.iov_base, b.iov_len);
p += b.iov_len;
ASSERT_EQ(*p++, c.iov_len);
ASSERT_EQ(memcmp(p, c.iov_base, c.iov_len), 0);
ASSERT_MEMEQ(p, c.iov_base, c.iov_len);
ASSERT_OK(iovec_split(&v, sizeof(uint8_t), &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
iovec_done(&v);
iovw_done_free(&iovw2);
@@ -586,17 +570,17 @@ TEST(iovw_merge_and_iovec_split) {
p = ASSERT_NOT_NULL(v.iov_base);
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, a.iov_len);
ASSERT_EQ(memcmp(p, a.iov_base, a.iov_len), 0);
ASSERT_MEMEQ(p, a.iov_base, a.iov_len);
p += a.iov_len;
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, b.iov_len);
ASSERT_EQ(memcmp(p, b.iov_base, b.iov_len), 0);
ASSERT_MEMEQ(p, b.iov_base, b.iov_len);
p += b.iov_len;
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, c.iov_len);
ASSERT_EQ(memcmp(p, c.iov_base, c.iov_len), 0);
ASSERT_MEMEQ(p, c.iov_base, c.iov_len);
ASSERT_OK(iovec_split(&v, sizeof(uint16_t), &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
iovec_done(&v);
iovw_done_free(&iovw2);
@@ -608,21 +592,21 @@ TEST(iovw_merge_and_iovec_split) {
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, a.iov_len);
ASSERT_EQ(memcmp(p, a.iov_base, a.iov_len), 0);
ASSERT_MEMEQ(p, a.iov_base, a.iov_len);
p += a.iov_len;
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, b.iov_len);
ASSERT_EQ(memcmp(p, b.iov_base, b.iov_len), 0);
ASSERT_MEMEQ(p, b.iov_base, b.iov_len);
p += b.iov_len;
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, 0);
ASSERT_EQ(*p++, c.iov_len);
ASSERT_EQ(memcmp(p, c.iov_base, c.iov_len), 0);
ASSERT_MEMEQ(p, c.iov_base, c.iov_len);
ASSERT_OK(iovec_split(&v, sizeof(uint32_t), &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
iovec_done(&v);
iovw_done_free(&iovw2);
@@ -637,7 +621,7 @@ TEST(iovw_merge_and_iovec_split) {
with_empty.iovec[4] = c;
ASSERT_OK(iovw_merge(&iovw, sizeof(uint8_t), &v));
ASSERT_OK(iovw_merge(&with_empty, sizeof(uint8_t), &v2));
ASSERT_TRUE(iovec_equal(&v, &v2));
ASSERT_IOVEC_EQ(&v, &v2);
iovec_done(&v);
iovec_done(&v2);
@@ -655,7 +639,7 @@ TEST(iovw_merge_and_iovec_split) {
p = mempcpy(p, c.iov_base, c.iov_len);
*p++ = 0;
ASSERT_OK(iovec_split(&IOVEC_MAKE(buf, sz), sizeof(uint8_t), &iovw2));
ASSERT_TRUE(iovw_equal(&iovw, &iovw2));
ASSERT_IOVW_EQ(&iovw, &iovw2);
iovw_done_free(&iovw2);
@@ -672,7 +656,7 @@ TEST(iovw_merge_and_iovec_split) {
ASSERT_OK(iovw_merge(&(struct iovec_wrapper) { .iovec = &large, .count = 1, }, sizeof(uint16_t), &v));
ASSERT_OK(iovec_split(&v, sizeof(uint16_t), &iovw2));
ASSERT_EQ(iovw2.count, 1u);
ASSERT_TRUE(iovec_equal(&iovw2.iovec[0], &large));
ASSERT_IOVEC_EQ(&iovw2.iovec[0], &large);
iovec_done(&v);
iovw_done_free(&iovw2);
src/test/test-journal-importer.c
+1 -2
View File
@@ -8,8 +8,7 @@
#include "tests.h"
static void assert_iovec_entry(const struct iovec *iovec, const char* content) {
ASSERT_EQ(strlen(content), iovec->iov_len);
ASSERT_EQ(memcmp(content, iovec->iov_base, iovec->iov_len), 0);
ASSERT_MEMEQ_NN(content, strlen(content), iovec->iov_base, iovec->iov_len);
}
#define COREDUMP_PROC_GROUP \
src/test/test-kernel-image.c
+1 -2
View File
@@ -33,8 +33,7 @@ static void assert_decompressed(int fd) {
ASSERT_OK_POSITIVE(kernel_decompress(fd, &decompressed_fd));
ASSERT_OK(read_full_file_full(decompressed_fd, /* filename= */ NULL, UINT64_MAX, SIZE_MAX, /* flags= */ 0, /* bind_name= */ NULL, &data, &size));
ASSERT_EQ(size, strlen(banner));
ASSERT_EQ(memcmp(data, banner, size), 0);
ASSERT_MEMEQ_NN(data, size, banner, strlen(banner));
}
static void assert_uname(int fd, const char *expected) {
src/test/test-kexec.c
+2 -2
View File
@@ -133,7 +133,7 @@ TEST(gzip_round_trip) {
/* Verify the decompressed content matches the original */
char result[4096];
ASSERT_OK_EQ_ERRNO(pread(kernel_fd, result, sizeof(result), 0), (ssize_t) sizeof(result));
ASSERT_EQ(memcmp(buf, result, sizeof(buf)), 0);
ASSERT_MEMEQ(buf, result, sizeof(buf));
}
TEST(zboot_synthetic) {
@@ -199,7 +199,7 @@ TEST(zboot_synthetic) {
/* Verify decompressed content matches original payload */
char result[512];
ASSERT_OK_EQ_ERRNO(pread(kernel_fd, result, sizeof(result), 0), (ssize_t) sizeof(result));
ASSERT_EQ(memcmp(payload, result, sizeof(payload)), 0);
ASSERT_MEMEQ(payload, result, sizeof(payload));
}
TEST(system_kernel) {
src/test/test-log.c
+5 -5
View File
@@ -102,9 +102,9 @@ static void test_log_format_iovec_sentinel(
for (size_t i = 0; i < n; i++)
if (i < m)
ASSERT_TRUE(iovec_equal(&iovec[i], &IOVEC_MAKE_STRING(v[i])));
ASSERT_IOVEC_EQ(&iovec[i], &IOVEC_MAKE_STRING(v[i]));
else {
ASSERT_TRUE(iovec_equal(&iovec[i], &IOVEC_MAKE_STRING(expected[i - m])));
ASSERT_IOVEC_EQ(&iovec[i], &IOVEC_MAKE_STRING(expected[i - m]));
free(iovec[i].iov_base);
}
@@ -120,12 +120,12 @@ static void test_log_format_iovec_sentinel(
for (size_t i = 0; i < n; i++)
if (i < m)
ASSERT_TRUE(iovec_equal(&iovec[i], &IOVEC_MAKE_STRING(v[i])));
ASSERT_IOVEC_EQ(&iovec[i], &IOVEC_MAKE_STRING(v[i]));
else if ((i - m) % 2 == 0) {
ASSERT_TRUE(iovec_equal(&iovec[i], &IOVEC_MAKE_STRING(expected[(i - m) / 2])));
ASSERT_IOVEC_EQ(&iovec[i], &IOVEC_MAKE_STRING(expected[(i - m) / 2]));
free(iovec[i].iov_base);
} else
ASSERT_TRUE(iovec_equal(&iovec[i], &IOVEC_MAKE_STRING("\n")));
ASSERT_IOVEC_EQ(&iovec[i], &IOVEC_MAKE_STRING("\n"));
}
#define test_log_format_iovec_one(...) \
src/test/test-manifest-util.c
+4 -4
View File
@@ -41,7 +41,7 @@ static void assert_digest(const struct iovec *digest, const char *hex) {
_cleanup_(iovec_done) struct iovec expected = {};
ASSERT_OK(unhexmem(hex, &expected.iov_base, &expected.iov_len));
ASSERT_EQ(iovec_memcmp(digest, &expected), 0);
ASSERT_IOVEC_EQ(digest, &expected);
}
TEST(manifest_parse_sums) {
@@ -871,13 +871,13 @@ TEST(uapi16_dispatch) {
ASSERT_TRUE(o.user_xattrs_set);
ASSERT_EQ(o.n_user_xattrs, 4U);
ASSERT_STREQ(o.user_xattrs[0].name, "a");
ASSERT_EQ(iovec_memcmp(&o.user_xattrs[0].value, &IOVEC_MAKE_STRING("hello")), 0);
ASSERT_IOVEC_EQ(&o.user_xattrs[0].value, &IOVEC_MAKE_STRING("hello"));
ASSERT_STREQ(o.user_xattrs[1].name, "b");
ASSERT_EQ(iovec_memcmp(&o.user_xattrs[1].value, &IOVEC_MAKE("\x00\x01\x02\x03", 4)), 0);
ASSERT_IOVEC_EQ(&o.user_xattrs[1].value, &IOVEC_MAKE("\x00\x01\x02\x03", 4));
ASSERT_STREQ(o.user_xattrs[2].name, "e");
ASSERT_EQ(o.user_xattrs[2].value.iov_len, 0U);
ASSERT_STREQ(o.user_xattrs[3].name, "u");
ASSERT_EQ(iovec_memcmp(&o.user_xattrs[3].value, &IOVEC_MAKE("\xfb\xff", 2)), 0);
ASSERT_IOVEC_EQ(&o.user_xattrs[3].value, &IOVEC_MAKE("\xfb\xff", 2));
/* … and they round-trip */
_cleanup_(sd_json_variant_unrefp) sd_json_variant *x = NULL;
src/test/test-memory-util.c
+3 -3
View File
@@ -36,18 +36,18 @@ TEST(cleanup_array) {
saved_n = n;
{
ASSERT_TRUE(memeqbyte('x', saved_iov, sizeof(struct iovec) * saved_n));
ASSERT_MEMEQ_BYTE('x', saved_iov, sizeof(struct iovec) * saved_n);
ASSERT_NOT_NULL(iov);
ASSERT_GT(n, 0U);
CLEANUP_ARRAY(iov, n, my_destructor);
ASSERT_TRUE(memeqbyte('x', saved_iov, sizeof(struct iovec) * saved_n));
ASSERT_MEMEQ_BYTE('x', saved_iov, sizeof(struct iovec) * saved_n);
ASSERT_NOT_NULL(iov);
ASSERT_GT(n, 0U);
}
ASSERT_TRUE(memeqbyte('y', saved_iov, sizeof(struct iovec) * saved_n));
ASSERT_MEMEQ_BYTE('y', saved_iov, sizeof(struct iovec) * saved_n);
ASSERT_NULL(iov);
ASSERT_EQ(n, 0U);
src/test/test-nss-hosts.c
+2 -3
View File
@@ -15,7 +15,6 @@
#include "local-addresses.h"
#include "log.h"
#include "main-func.h"
#include "memory-util.h"
#include "nss-test-util.h"
#include "nss-util.h"
#include "parse-util.h"
@@ -72,9 +71,9 @@ static void assert_myhostname_gaih_addrtuples(const struct gaih_addrtuple *tuple
for (const struct gaih_addrtuple *it = tuples; it; it = it->next)
if (it->family == AF_INET)
ASSERT_TRUE(memeqzero(
ASSERT_MEMEQ_ZERO(
(const uint8_t*) it->addr + sizeof(struct in_addr),
sizeof(it->addr) - sizeof(struct in_addr)));
sizeof(it->addr) - sizeof(struct in_addr));
}
static void print_struct_hostent(struct hostent *host, const char *canon) {
src/test/test-nulstr-util.c
+5 -5
View File
@@ -93,7 +93,7 @@ static void test_strv_make_nulstr_one(char **l) {
ASSERT_STRV_EQ(l, q);
ASSERT_OK(strv_make_nulstr(q, &c, &m));
ASSERT_EQ(memcmp_nn(b, n, c, m), 0);
ASSERT_MEMEQ_NN(b, n, c, m);
NULSTR_FOREACH(s, b)
ASSERT_STREQ(s, l[i++]);
@@ -119,7 +119,7 @@ TEST(set_make_nulstr) {
ASSERT_OK_ZERO(set_make_nulstr(set, &nulstr, &len));
ASSERT_EQ(len, 0U);
ASSERT_EQ(memcmp(expect, nulstr, len + 2), 0);
ASSERT_MEMEQ(expect, nulstr, len + 2);
}
{
@@ -131,7 +131,7 @@ TEST(set_make_nulstr) {
ASSERT_OK_ZERO(set_make_nulstr(set, &nulstr, &len));
ASSERT_EQ(len, 0U);
ASSERT_EQ(memcmp(expect, nulstr, len + 2), 0);
ASSERT_MEMEQ(expect, nulstr, len + 2);
}
{
@@ -143,7 +143,7 @@ TEST(set_make_nulstr) {
ASSERT_OK_ZERO(set_make_nulstr(set, &nulstr, &len));
ASSERT_EQ(len, 4U);
ASSERT_EQ(memcmp(expect, nulstr, len + 1), 0);
ASSERT_MEMEQ(expect, nulstr, len + 1);
}
}
@@ -153,7 +153,7 @@ static void test_strv_make_nulstr_binary_one(char **l, const char *b, size_t n)
size_t m;
ASSERT_OK(strv_make_nulstr(l, &a, &m));
ASSERT_EQ(memcmp_nn(a, m, b, n), 0);
ASSERT_MEMEQ_NN(a, m, b, n);
ASSERT_NOT_NULL(z = strv_parse_nulstr(a, m));
ASSERT_STRV_EQ(l, z);
}
Loaded 100 of 121 files, more files were not shown because too many files have changed in this diff. Show more