15199265962

Committed 22 May 2025 09:40PM UTC coverage: 72.061% (-0.02%) from 72.079%

Build # 15199265962

Build Type

push

github

Committed by

bluca

Commit Message

tests: fix TEST-74-AUX-UTILS.varlinkctl.sh (#37562)

per Daan's explanation:
other subtests running as testuser apparently use systemd-run --user
--machine testuser@.host which turns user tracking in logind into "by
pin" mode. when the last pinning session exits it terminates the user.

Coverage Stats

299156 of 415145 relevant lines covered (72.06%)

703915.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.18

/src/boot/test-bcd.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "alloc-util.h"
#include "argv-util.h"
#include "bcd.h"
#include "compress.h"
#include "fileio.h"
#include "tests.h"
#include "utf8.h"

/* Include the implementation directly, so we can poke at some internals. */
#include "bcd.c"

static void load_bcd(const char *path, void **ret_bcd, size_t *ret_bcd_len) {
        size_t len;
        _cleanup_free_ char *fn = NULL, *compressed = NULL;

        assert_se(get_testdata_dir(path, &fn) >= 0);
        assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, SIZE_MAX, 0, NULL, &compressed, &len) >= 0);
        assert_se(decompress_blob_zstd(compressed, len, ret_bcd, ret_bcd_len, SIZE_MAX) >= 0);
}

static void test_get_bcd_title_one(
                const char *path,
                const char16_t *title_expect,
                size_t title_len_expect) {

        size_t len;
        _cleanup_free_ void *bcd = NULL;

        log_info("/* %s(%s) */", __func__, path);

        load_bcd(path, &bcd, &len);

        char16_t *title = get_bcd_title(bcd, len);
        if (title_expect) {
                assert_se(title);
                assert_se(memcmp(title, title_expect, title_len_expect) == 0);
        } else
                assert_se(!title);
}

TEST(get_bcd_title) {
        test_get_bcd_title_one("test-bcd/win10.bcd.zst", u"Windows 10", sizeof(u"Windows 10"));

        test_get_bcd_title_one("test-bcd/description-bad-type.bcd.zst", NULL, 0);
        test_get_bcd_title_one("test-bcd/description-empty.bcd.zst", NULL, 0);
        test_get_bcd_title_one("test-bcd/description-missing.bcd.zst", NULL, 0);
        test_get_bcd_title_one("test-bcd/description-too-small.bcd.zst", NULL, 0);
        test_get_bcd_title_one("test-bcd/displayorder-bad-name.bcd.zst", NULL, 0);
        test_get_bcd_title_one("test-bcd/displayorder-bad-size.bcd.zst", NULL, 0);
        test_get_bcd_title_one("test-bcd/displayorder-bad-type.bcd.zst", NULL, 0);
        test_get_bcd_title_one("test-bcd/empty.bcd.zst", NULL, 0);
}

TEST(base_block) {
        size_t len;
        BaseBlock backup;
        uint8_t *bcd_base;
        _cleanup_free_ BaseBlock *bcd = NULL;

        load_bcd("test-bcd/win10.bcd.zst", (void **) &bcd, &len);
        backup = *bcd;
        bcd_base = (uint8_t *) bcd;

        assert_se(get_bcd_title(bcd_base, len));

        /* Try various "corruptions" of the base block. */

        assert_se(!get_bcd_title(bcd_base, sizeof(BaseBlock) - 1));

        bcd->sig = 0;
        assert_se(!get_bcd_title(bcd_base, len));
        *bcd = backup;

        bcd->version_minor = 2;
        assert_se(!get_bcd_title(bcd_base, len));
        *bcd = backup;

        bcd->version_major = 4;
        assert_se(!get_bcd_title(bcd_base, len));
        *bcd = backup;

        bcd->type = 1;
        assert_se(!get_bcd_title(bcd_base, len));
        *bcd = backup;

        bcd->primary_seqnum++;
        assert_se(!get_bcd_title(bcd_base, len));
        *bcd = backup;
}

TEST(bad_bcd) {
        size_t len;
        uint8_t *hbins;
        uint32_t offset;
        _cleanup_free_ void *bcd = NULL;

        /* This BCD hive has been manipulated to have bad offsets/sizes at various places. */
        load_bcd("test-bcd/corrupt.bcd.zst", &bcd, &len);

        assert_se(len >= HIVE_CELL_OFFSET);
        hbins = (uint8_t *) bcd + HIVE_CELL_OFFSET;
        len -= HIVE_CELL_OFFSET;
        offset = ((BaseBlock *) bcd)->root_cell_offset;

        const Key *root = get_key(hbins, len, offset, "\0");
        assert_se(root);
        assert_se(!get_key(hbins, sizeof(Key) - 1, offset, "\0"));

        assert_se(!get_key(hbins, len, offset, "\0BadOffset\0"));
        assert_se(!get_key(hbins, len, offset, "\0BadSig\0"));
        assert_se(!get_key(hbins, len, offset, "\0BadKeyNameLen\0"));
        assert_se(!get_key(hbins, len, offset, "\0SubkeyBadOffset\0Dummy\0"));
        assert_se(!get_key(hbins, len, offset, "\0SubkeyBadSig\0Dummy\0"));
        assert_se(!get_key(hbins, len, offset, "\0SubkeyBadNEntries\0Dummy\0"));

        assert_se(!get_key_value(hbins, len, root, "Dummy"));

        const Key *kv_bad_offset = get_key(hbins, len, offset, "\0KeyValuesBadOffset\0");
        assert_se(kv_bad_offset);
        assert_se(!get_key_value(hbins, len, kv_bad_offset, "Dummy"));

        const Key *kv_bad_n_key_values = get_key(hbins, len, offset, "\0KeyValuesBadNKeyValues\0");
        assert_se(kv_bad_n_key_values);
        assert_se(!get_key_value(hbins, len, kv_bad_n_key_values, "Dummy"));

        const Key *kv = get_key(hbins, len, offset, "\0KeyValues\0");
        assert_se(kv);

        assert_se(!get_key_value(hbins, len, kv, "BadOffset"));
        assert_se(!get_key_value(hbins, len, kv, "BadSig"));
        assert_se(!get_key_value(hbins, len, kv, "BadNameLen"));
        assert_se(!get_key_value(hbins, len, kv, "InlineData"));
        assert_se(!get_key_value(hbins, len, kv, "BadDataOffset"));
        assert_se(!get_key_value(hbins, len, kv, "BadDataSize"));
}

TEST(argv_bcds) {
        for (int i = 1; i < saved_argc; i++) {
                size_t len;
                _cleanup_free_ void *bcd = NULL;

                assert_se(read_full_file_full(
                        AT_FDCWD,
                        saved_argv[i],
                        UINT64_MAX,
                        SIZE_MAX,
                        0,
                        NULL,
                        (char **) &bcd,
                        &len) >= 0);

                char16_t *title = get_bcd_title(bcd, len);
                if (title) {
                        _cleanup_free_ char *title_utf8 = utf16_to_utf8(title, SIZE_MAX);
                        log_info("%s: \"%s\"", saved_argv[i], title_utf8);
                } else
                        log_info("%s: Bad BCD", saved_argv[i]);
        }
}

DEFINE_TEST_MAIN(LOG_INFO);

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include "alloc-util.h"
4	#include "argv-util.h"
5	#include "bcd.h"
6	#include "compress.h"
7	#include "fileio.h"
8	#include "tests.h"
9	#include "utf8.h"
10
11	/* Include the implementation directly, so we can poke at some internals. */
12	#include "bcd.c"
13
14	static void load_bcd(const char path, void ret_bcd, size_t ret_bcd_len) {	11✔
15	size_t len;	11✔
16	_cleanup_free_ char fn = NULL, compressed = NULL;	×
17
18	assert_se(get_testdata_dir(path, &fn) >= 0);	11✔
19	assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, SIZE_MAX, 0, NULL, &compressed, &len) >= 0);	11✔
20	assert_se(decompress_blob_zstd(compressed, len, ret_bcd, ret_bcd_len, SIZE_MAX) >= 0);	11✔
21	}	11✔
22
23	static void test_get_bcd_title_one(	9✔
24	const char *path,
25	const char16_t *title_expect,
26	size_t title_len_expect) {
27
28	size_t len;	9✔
29	_cleanup_free_ void *bcd = NULL;	18✔
30
31	log_info("/* %s(%s) */", __func__, path);	9✔
32
33	load_bcd(path, &bcd, &len);	9✔
34
35	char16_t *title = get_bcd_title(bcd, len);	9✔
36	if (title_expect) {	9✔
37	assert_se(title);	1✔
38	assert_se(memcmp(title, title_expect, title_len_expect) == 0);	1✔
39	} else
40	assert_se(!title);	9✔
41	}	9✔
42
43	TEST(get_bcd_title) {	1✔
44	test_get_bcd_title_one("test-bcd/win10.bcd.zst", u"Windows 10", sizeof(u"Windows 10"));	1✔
45
46	test_get_bcd_title_one("test-bcd/description-bad-type.bcd.zst", NULL, 0);	1✔
47	test_get_bcd_title_one("test-bcd/description-empty.bcd.zst", NULL, 0);	1✔
48	test_get_bcd_title_one("test-bcd/description-missing.bcd.zst", NULL, 0);	1✔
49	test_get_bcd_title_one("test-bcd/description-too-small.bcd.zst", NULL, 0);	1✔
50	test_get_bcd_title_one("test-bcd/displayorder-bad-name.bcd.zst", NULL, 0);	1✔
51	test_get_bcd_title_one("test-bcd/displayorder-bad-size.bcd.zst", NULL, 0);	1✔
52	test_get_bcd_title_one("test-bcd/displayorder-bad-type.bcd.zst", NULL, 0);	1✔
53	test_get_bcd_title_one("test-bcd/empty.bcd.zst", NULL, 0);	1✔
54	}	1✔
55
56	TEST(base_block) {	1✔
57	size_t len;	1✔
58	BaseBlock backup;	1✔
59	uint8_t *bcd_base;	1✔
60	_cleanup_free_ BaseBlock *bcd = NULL;	2✔
61
62	load_bcd("test-bcd/win10.bcd.zst", (void **) &bcd, &len);	1✔
63	backup = *bcd;	1✔
64	bcd_base = (uint8_t *) bcd;	1✔
65
66	assert_se(get_bcd_title(bcd_base, len));	1✔
67
68	/* Try various "corruptions" of the base block. */
69
70	assert_se(!get_bcd_title(bcd_base, sizeof(BaseBlock) - 1));	1✔
71
72	bcd->sig = 0;	1✔
73	assert_se(!get_bcd_title(bcd_base, len));	1✔
74	*bcd = backup;	1✔
75
76	bcd->version_minor = 2;	1✔
77	assert_se(!get_bcd_title(bcd_base, len));	1✔
78	*bcd = backup;	1✔
79
80	bcd->version_major = 4;	1✔
81	assert_se(!get_bcd_title(bcd_base, len));	1✔
82	*bcd = backup;	1✔
83
84	bcd->type = 1;	1✔
85	assert_se(!get_bcd_title(bcd_base, len));	1✔
86	*bcd = backup;	1✔
87
88	bcd->primary_seqnum++;	1✔
89	assert_se(!get_bcd_title(bcd_base, len));	1✔
90	*bcd = backup;	1✔
91	}	1✔
92
93	TEST(bad_bcd) {	1✔
94	size_t len;	1✔
95	uint8_t *hbins;	1✔
96	uint32_t offset;	1✔
97	_cleanup_free_ void *bcd = NULL;	2✔
98
99	/* This BCD hive has been manipulated to have bad offsets/sizes at various places. */
100	load_bcd("test-bcd/corrupt.bcd.zst", &bcd, &len);	1✔
101
102	assert_se(len >= HIVE_CELL_OFFSET);	1✔
103	hbins = (uint8_t *) bcd + HIVE_CELL_OFFSET;	1✔
104	len -= HIVE_CELL_OFFSET;	1✔
105	offset = ((BaseBlock *) bcd)->root_cell_offset;	1✔
106
107	const Key *root = get_key(hbins, len, offset, "\0");	1✔
108	assert_se(root);	1✔
109	assert_se(!get_key(hbins, sizeof(Key) - 1, offset, "\0"));	1✔
110
111	assert_se(!get_key(hbins, len, offset, "\0BadOffset\0"));	1✔
112	assert_se(!get_key(hbins, len, offset, "\0BadSig\0"));	1✔
113	assert_se(!get_key(hbins, len, offset, "\0BadKeyNameLen\0"));	1✔
114	assert_se(!get_key(hbins, len, offset, "\0SubkeyBadOffset\0Dummy\0"));	1✔
115	assert_se(!get_key(hbins, len, offset, "\0SubkeyBadSig\0Dummy\0"));	1✔
116	assert_se(!get_key(hbins, len, offset, "\0SubkeyBadNEntries\0Dummy\0"));	1✔
117
118	assert_se(!get_key_value(hbins, len, root, "Dummy"));	1✔
119
120	const Key *kv_bad_offset = get_key(hbins, len, offset, "\0KeyValuesBadOffset\0");	1✔
121	assert_se(kv_bad_offset);	1✔
122	assert_se(!get_key_value(hbins, len, kv_bad_offset, "Dummy"));	1✔
123
124	const Key *kv_bad_n_key_values = get_key(hbins, len, offset, "\0KeyValuesBadNKeyValues\0");	1✔
125	assert_se(kv_bad_n_key_values);	1✔
126	assert_se(!get_key_value(hbins, len, kv_bad_n_key_values, "Dummy"));	1✔
127
128	const Key *kv = get_key(hbins, len, offset, "\0KeyValues\0");	1✔
129	assert_se(kv);	1✔
130
131	assert_se(!get_key_value(hbins, len, kv, "BadOffset"));	1✔
132	assert_se(!get_key_value(hbins, len, kv, "BadSig"));	1✔
133	assert_se(!get_key_value(hbins, len, kv, "BadNameLen"));	1✔
134	assert_se(!get_key_value(hbins, len, kv, "InlineData"));	1✔
135	assert_se(!get_key_value(hbins, len, kv, "BadDataOffset"));	1✔
136	assert_se(!get_key_value(hbins, len, kv, "BadDataSize"));	1✔
137	}	1✔
138
139	TEST(argv_bcds) {	1✔
140	for (int i = 1; i < saved_argc; i++) {	1✔
141	size_t len;	×
142	_cleanup_free_ void *bcd = NULL;	×
143
144	assert_se(read_full_file_full(	×
145	AT_FDCWD,
146	saved_argv[i],
147	UINT64_MAX,
148	SIZE_MAX,
149	0,
150	NULL,
151	(char **) &bcd,
152	&len) >= 0);
153
154	char16_t *title = get_bcd_title(bcd, len);	×
155	if (title) {	×
156	_cleanup_free_ char *title_utf8 = utf16_to_utf8(title, SIZE_MAX);	×
157	log_info("%s: \"%s\"", saved_argv[i], title_utf8);	×
158	} else
159	log_info("%s: Bad BCD", saved_argv[i]);	×
160	}
161	}	1✔
162
163	DEFINE_TEST_MAIN(LOG_INFO);	1✔

systemd / systemd / 15199265962

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous