[J-u-boot.git] / test / bloblist.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2018, Google Inc. All rights reserved.
 */

#include <common.h>
#include <bloblist.h>
#include <log.h>
#include <mapmem.h>
#include <test/suites.h>
#include <test/test.h>
#include <test/ut.h>

DECLARE_GLOBAL_DATA_PTR;

/* Declare a new compression test */
#define BLOBLIST_TEST(_name, _flags) \
		UNIT_TEST(_name, _flags, bloblist_test)

enum {
	TEST_TAG		= 1,
	TEST_TAG2		= 2,
	TEST_TAG_MISSING	= 3,

	TEST_SIZE		= 10,
	TEST_SIZE2		= 20,

	TEST_ADDR		= CONFIG_BLOBLIST_ADDR,
	TEST_BLOBLIST_SIZE	= 0x100,
};

static struct bloblist_hdr *clear_bloblist(void)
{
	struct bloblist_hdr *hdr;

	/* Clear out any existing bloblist so we have a clean slate */
	hdr = map_sysmem(CONFIG_BLOBLIST_ADDR, TEST_BLOBLIST_SIZE);
	memset(hdr, '\0', TEST_BLOBLIST_SIZE);

	return hdr;
}

static int bloblist_test_init(struct unit_test_state *uts)
{
	struct bloblist_hdr *hdr;

	hdr = clear_bloblist();
	ut_asserteq(-ENOENT, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	hdr->version++;
	ut_asserteq(-EPROTONOSUPPORT, bloblist_check(TEST_ADDR,
						     TEST_BLOBLIST_SIZE));

	ut_asserteq(-ENOSPC, bloblist_new(TEST_ADDR, 0x10, 0));
	ut_asserteq(-EFAULT, bloblist_new(1, TEST_BLOBLIST_SIZE, 0));
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));

	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	ut_assertok(bloblist_finish());
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->flags++;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

	return 1;
}
BLOBLIST_TEST(bloblist_test_init, 0);

static int bloblist_test_blob(struct unit_test_state *uts)
{
	struct bloblist_hdr *hdr;
	struct bloblist_rec *rec, *rec2;
	char *data;

	/* At the start there should be no records */
	hdr = clear_bloblist();
	ut_assertnull(bloblist_find(TEST_TAG, TEST_BLOBLIST_SIZE));
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));

	/* Add a record and check that we can find it */
	data = bloblist_add(TEST_TAG, TEST_SIZE);
	rec = (void *)(hdr + 1);
	ut_asserteq_ptr(rec + 1, data);
	data = bloblist_find(TEST_TAG, TEST_SIZE);
	ut_asserteq_ptr(rec + 1, data);

	/* Check the 'ensure' method */
	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	ut_assertnull(bloblist_ensure(TEST_TAG, TEST_SIZE2));
	rec2 = (struct bloblist_rec *)(data + ALIGN(TEST_SIZE, BLOBLIST_ALIGN));

	/* Check for a non-existent record */
	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	ut_asserteq_ptr(rec2 + 1, bloblist_ensure(TEST_TAG2, TEST_SIZE2));
	ut_assertnull(bloblist_find(TEST_TAG_MISSING, 0));

	return 0;
}
BLOBLIST_TEST(bloblist_test_blob, 0);

static int bloblist_test_bad_blob(struct unit_test_state *uts)
{
	struct bloblist_hdr *hdr;
	void *data;

	hdr = clear_bloblist();
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	data = hdr + 1;
	data += sizeof(struct bloblist_rec);
	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));

	return 0;
}
BLOBLIST_TEST(bloblist_test_bad_blob, 0);

static int bloblist_test_checksum(struct unit_test_state *uts)
{
	struct bloblist_hdr *hdr;
	char *data, *data2;

	hdr = clear_bloblist();
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	ut_assertok(bloblist_finish());
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

	/*
	 * Now change things amd make sure that the checksum notices. We cannot
	 * change the size or alloced fields, since that will crash the code.
	 * It has to rely on these being correct.
	 */
	hdr->flags--;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->flags++;

	hdr->size--;
	ut_asserteq(-EFBIG, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->size++;

	hdr->spare++;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->spare--;

	hdr->chksum++;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->chksum--;

	/* Make sure the checksum changes when we add blobs */
	data = bloblist_add(TEST_TAG, TEST_SIZE);
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

	data2 = bloblist_add(TEST_TAG2, TEST_SIZE2);
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	ut_assertok(bloblist_finish());

	/* It should also change if we change the data */
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	*data += 1;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	*data -= 1;

	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	*data2 += 1;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	*data2 -= 1;

	/*
	 * Changing data outside the range of valid data should not affect
	 * the checksum.
	 */
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	data[TEST_SIZE]++;
	data2[TEST_SIZE2]++;
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

	return 0;
}

BLOBLIST_TEST(bloblist_test_checksum, 0);

int do_ut_bloblist(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
	struct unit_test *tests = ll_entry_start(struct unit_test,
						 bloblist_test);
	const int n_ents = ll_entry_count(struct unit_test, bloblist_test);

	return cmd_ut_category("bloblist", tests, n_ents, argc, argv);
}
Commit	Line	Data
919e7a8f SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (c) 2018, Google Inc. All rights reserved.
	4	*/
	5
	6	#include <common.h>
	7	#include <bloblist.h>
	8	#include <log.h>
	9	#include <mapmem.h>
	10	#include <test/suites.h>
	11	#include <test/test.h>
	12	#include <test/ut.h>
	13
	14	DECLARE_GLOBAL_DATA_PTR;
	15
	16	/* Declare a new compression test */
	17	#define BLOBLIST_TEST(_name, _flags) \
	18	UNIT_TEST(_name, _flags, bloblist_test)
	19
	20	enum {
	21	TEST_TAG = 1,
	22	TEST_TAG2 = 2,
	23	TEST_TAG_MISSING = 3,
	24
	25	TEST_SIZE = 10,
	26	TEST_SIZE2 = 20,
	27
	28	TEST_ADDR = CONFIG_BLOBLIST_ADDR,
	29	TEST_BLOBLIST_SIZE = 0x100,
	30	};
	31
	32	static struct bloblist_hdr *clear_bloblist(void)
	33	{
	34	struct bloblist_hdr *hdr;
	35
	36	/* Clear out any existing bloblist so we have a clean slate */
	37	hdr = map_sysmem(CONFIG_BLOBLIST_ADDR, TEST_BLOBLIST_SIZE);
	38	memset(hdr, '\0', TEST_BLOBLIST_SIZE);
	39
	40	return hdr;
	41	}
	42
	43	static int bloblist_test_init(struct unit_test_state *uts)
	44	{
	45	struct bloblist_hdr *hdr;
	46
	47	hdr = clear_bloblist();
	48	ut_asserteq(-ENOENT, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	49	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	50	hdr->version++;
	51	ut_asserteq(-EPROTONOSUPPORT, bloblist_check(TEST_ADDR,
	52	TEST_BLOBLIST_SIZE));
	53
	54	ut_asserteq(-ENOSPC, bloblist_new(TEST_ADDR, 0x10, 0));
	55	ut_asserteq(-EFAULT, bloblist_new(1, TEST_BLOBLIST_SIZE, 0));
	56	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	57
	58	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	59	ut_assertok(bloblist_finish());
	60	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	61	hdr->flags++;
	62	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	63
	64	return 1;
65	}
66	BLOBLIST_TEST(bloblist_test_init, 0);
67
68	static int bloblist_test_blob(struct unit_test_state *uts)
69	{
70	struct bloblist_hdr *hdr;
71	struct bloblist_rec rec, rec2;
72	char *data;
73
74	/* At the start there should be no records */
75	hdr = clear_bloblist();
76	ut_assertnull(bloblist_find(TEST_TAG, TEST_BLOBLIST_SIZE));
77	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
78
79	/* Add a record and check that we can find it */
80	data = bloblist_add(TEST_TAG, TEST_SIZE);
81	rec = (void *)(hdr + 1);
82	ut_asserteq_ptr(rec + 1, data);
83	data = bloblist_find(TEST_TAG, TEST_SIZE);
84	ut_asserteq_ptr(rec + 1, data);
85
86	/* Check the 'ensure' method */
87	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
88	ut_assertnull(bloblist_ensure(TEST_TAG, TEST_SIZE2));
89	rec2 = (struct bloblist_rec *)(data + ALIGN(TEST_SIZE, BLOBLIST_ALIGN));
90
91	/* Check for a non-existent record */
92	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
93	ut_asserteq_ptr(rec2 + 1, bloblist_ensure(TEST_TAG2, TEST_SIZE2));
94	ut_assertnull(bloblist_find(TEST_TAG_MISSING, 0));
95
96	return 0;
97	}
98	BLOBLIST_TEST(bloblist_test_blob, 0);
99
100	static int bloblist_test_bad_blob(struct unit_test_state *uts)
101	{
102	struct bloblist_hdr *hdr;
103	void *data;
104
105	hdr = clear_bloblist();
106	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
107	data = hdr + 1;
108	data += sizeof(struct bloblist_rec);
109	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
110	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
111
112	return 0;
113	}
114	BLOBLIST_TEST(bloblist_test_bad_blob, 0);
115
116	static int bloblist_test_checksum(struct unit_test_state *uts)
117	{
118	struct bloblist_hdr *hdr;
119	char data, data2;
120
121	hdr = clear_bloblist();
122	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
123	ut_assertok(bloblist_finish());
124	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
125
126	/*
127	* Now change things amd make sure that the checksum notices. We cannot
128	* change the size or alloced fields, since that will crash the code.
129	* It has to rely on these being correct.
130	*/
131	hdr->flags--;
132	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
133	hdr->flags++;
134
135	hdr->size--;
136	ut_asserteq(-EFBIG, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
137	hdr->size++;
138
139	hdr->spare++;
140	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
141	hdr->spare--;
142
143	hdr->chksum++;
144	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
145	hdr->chksum--;
146
147	/* Make sure the checksum changes when we add blobs */
148	data = bloblist_add(TEST_TAG, TEST_SIZE);
149	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
150
151	data2 = bloblist_add(TEST_TAG2, TEST_SIZE2);
152	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
153	ut_assertok(bloblist_finish());
154
155	/* It should also change if we change the data */
156	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
157	*data += 1;
158	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
159	*data -= 1;
160
161	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
162	*data2 += 1;
163	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
164	*data2 -= 1;
165
166	/*
167	* Changing data outside the range of valid data should not affect
168	* the checksum.
169	*/
170	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
171	data[TEST_SIZE]++;
172	data2[TEST_SIZE2]++;
173	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
174
175	return 0;
176	}
177
178	BLOBLIST_TEST(bloblist_test_checksum, 0);
179
180	int do_ut_bloblist(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
181	{
182	struct unit_test *tests = ll_entry_start(struct unit_test,
183	bloblist_test);
184	const int n_ents = ll_entry_count(struct unit_test, bloblist_test);
185
186	return cmd_ut_category("bloblist", tests, n_ents, argc, argv);
187	}