tests: Fix tests code and comments style

This patch applies clang-format settings to most of tests files. Some
files were fixed "by-hand" to exclude some lines, which whould be less
readable after automatic style fixing.
Moreover, some comments (mostly in tests/lib/edid-test.c) were adjusted
to match coreboot coding style guidelines.

Change-Id: I69f25a7b6d8265800c731754e2fbb2255f482134
Signed-off-by: Jakub Czapiga <jacz@semihalf.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/60970
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Paul Fagerburg <pfagerburg@chromium.org>

tests/acpi/acpigen-test.c

@@ -203,14 +203,14 @@ static void test_acpigen_scope_with_contents(void **state)
 int main(void)
 {
 	const struct CMUnitTest tests[] = {
-		cmocka_unit_test_setup_teardown(test_acpigen_single_if,
+		cmocka_unit_test_setup_teardown(test_acpigen_single_if, setup_acpigen,
-						setup_acpigen, teardown_acpigen),
+						teardown_acpigen),
-		cmocka_unit_test_setup_teardown(test_acpigen_nested_ifs,
+		cmocka_unit_test_setup_teardown(test_acpigen_nested_ifs, setup_acpigen,
-						setup_acpigen, teardown_acpigen),
+						teardown_acpigen),
-		cmocka_unit_test_setup_teardown(test_acpigen_write_package,
+		cmocka_unit_test_setup_teardown(test_acpigen_write_package, setup_acpigen,
-						setup_acpigen, teardown_acpigen),
+						teardown_acpigen),
-		cmocka_unit_test_setup_teardown(test_acpigen_scope_with_contents,
+		cmocka_unit_test_setup_teardown(test_acpigen_scope_with_contents, setup_acpigen,
-						setup_acpigen, teardown_acpigen),
+						teardown_acpigen),
 	};
 
 	return cb_run_group_tests(tests, NULL, NULL);

tests/commonlib/region-test.c

@@ -14,30 +14,30 @@ static void test_region(void **state)
 	assert_true(VAL(5) + VAL(10) > VAL(10));
 	assert_true(VAL(7) + VAL(10) < VAL(10));
 
-	struct region outer = { .offset = VAL(2), .size = VAL(4) };
+	struct region outer = {.offset = VAL(2), .size = VAL(4)};
 	assert_int_equal(region_offset(&outer), VAL(2));
 	assert_int_equal(region_sz(&outer), VAL(4));
 	assert_int_equal(region_end(&outer), VAL(6));
 
-	struct region inner = { .offset = VAL(3), .size = VAL(2) };
+	struct region inner = {.offset = VAL(3), .size = VAL(2)};
 	assert_true(region_is_subregion(&outer, &inner));
 
-	struct region touching_bottom = { .offset = VAL(2), .size = VAL(1) };
+	struct region touching_bottom = {.offset = VAL(2), .size = VAL(1)};
 	assert_true(region_is_subregion(&outer, &touching_bottom));
 
-	struct region touching_top = { .offset = VAL(5), .size = VAL(1) };
+	struct region touching_top = {.offset = VAL(5), .size = VAL(1)};
 	assert_true(region_is_subregion(&outer, &touching_top));
 
-	struct region overlap_bottom = { .offset = VAL(1), .size = VAL(2) };
+	struct region overlap_bottom = {.offset = VAL(1), .size = VAL(2)};
 	assert_false(region_is_subregion(&outer, &overlap_bottom));
 
-	struct region overlap_top = { .offset = VAL(5), .size = VAL(2) };
+	struct region overlap_top = {.offset = VAL(5), .size = VAL(2)};
 	assert_false(region_is_subregion(&outer, &overlap_top));
 
-	struct region below = { .offset = 0, .size = VAL(1) };
+	struct region below = {.offset = 0, .size = VAL(1)};
 	assert_false(region_is_subregion(&outer, &below));
 
-	struct region above = { .offset = VAL(0xf), .size = VAL(1) };
+	struct region above = {.offset = VAL(0xf), .size = VAL(1)};
 	assert_false(region_is_subregion(&outer, &above));
 }
 
@@ -58,8 +58,8 @@ static int mock_unmap(const struct region_device *rdev, void *mapping)
 	return mock();
 }
 
-static ssize_t mock_readat(const struct region_device *rdev, void *buffer,
+static ssize_t mock_readat(const struct region_device *rdev, void *buffer, size_t offset,
-			   size_t offset, size_t size)
+			   size_t size)
 {
 	check_expected_ptr(rdev);
 	check_expected_ptr(buffer);
@@ -73,8 +73,8 @@ static ssize_t mock_readat(const struct region_device *rdev, void *buffer,
 		return ret;
 }
 
-static ssize_t mock_writeat(const struct region_device *rdev, const void *buffer,
+static ssize_t mock_writeat(const struct region_device *rdev, const void *buffer, size_t offset,
-			    size_t offset, size_t size)
+			    size_t size)
 {
 	check_expected_ptr(rdev);
 	check_expected_ptr(buffer);

tests/console/routing-test.c

@@ -61,8 +61,7 @@ static int teardown_console_log_level(void **state)
 int main(void)
 {
 	const struct CMUnitTest tests[] = {
-		cmocka_unit_test_setup_teardown(test_console_log_level,
+		cmocka_unit_test_setup_teardown(test_console_log_level, setup_console_log_level,
-						setup_console_log_level,
 						teardown_console_log_level),
 	};
 

tests/device/ddr4-test.c

@@ -33,9 +33,7 @@ static void ddr4_speed_mhz_to_mts_test(void **state)
 
 int main(void)
 {
-	const struct CMUnitTest tests[] = {
+	const struct CMUnitTest tests[] = {cmocka_unit_test(ddr4_speed_mhz_to_mts_test)};
-		cmocka_unit_test(ddr4_speed_mhz_to_mts_test)
-	};
 
 	return cb_run_group_tests(tests, NULL, NULL);
 }

tests/device/i2c-test.c

@@ -18,20 +18,27 @@ typedef struct {
 } i2c_ex_devs_t;
 
 i2c_ex_devs_t i2c_ex_devs[] = {
-	{.bus = 0, .slave = 0xA, .regs = {
+	{
+		.bus = 0,
+		.slave = 0xA,
+		.regs = {
 			{.reg = 0x0, .data = 0xB},
 			{.reg = 0x1, .data = 0x6},
 			{.reg = 0x2, .data = 0xF},
-	} },
+		}
-	{.bus = 0, .slave = 0x3, .regs = {
+	},
+	{
+		.bus = 0,
+		.slave = 0x3,
+		.regs = {
 			{.reg = 0x0, .data = 0xDE},
 			{.reg = 0x1, .data = 0xAD},
 			{.reg = 0x2, .data = 0xBE},
-	} },
+		}
+	},
 };
 
-int platform_i2c_transfer(unsigned int bus, struct i2c_msg *segments,
+int platform_i2c_transfer(unsigned int bus, struct i2c_msg *segments, int count)
-	int count)
 {
 	int i;
 	int reg;
@@ -73,18 +80,15 @@ int platform_i2c_transfer(unsigned int bus, struct i2c_msg *segments,
 
 static void mock_expect_params_platform_i2c_transfer(void)
 {
-	unsigned long int expected_flags[] = {0, I2C_M_RD, I2C_M_TEN,
+	unsigned long int expected_flags[] = {0, I2C_M_RD, I2C_M_TEN, I2C_M_RECV_LEN,
-		I2C_M_RECV_LEN, I2C_M_NOSTART};
+					      I2C_M_NOSTART};
 
 	/* Flags should always be only within supported range */
-	expect_in_set_count(platform_i2c_transfer, segments->flags,
+	expect_in_set_count(platform_i2c_transfer, segments->flags, expected_flags, -1);
-		expected_flags, -1);
 
-	expect_not_value_count(platform_i2c_transfer, segments->buf,
+	expect_not_value_count(platform_i2c_transfer, segments->buf, NULL, -1);
-		NULL, -1);
 
-	expect_in_range_count(platform_i2c_transfer, count, 1, INT_MAX,
+	expect_in_range_count(platform_i2c_transfer, count, 1, INT_MAX, -1);
-		-1);
 }
 
 #define MASK 0x3
@@ -101,21 +105,17 @@ static void i2c_read_field_test(void **state)
 	   with expected value. */
 	for (i = 0; i < ARRAY_SIZE(i2c_ex_devs); i++)
 		for (j = 0; j < ARRAY_SIZE(i2c_ex_devs[0].regs); j++) {
-			i2c_read_field(i2c_ex_devs[i].bus,
+			i2c_read_field(i2c_ex_devs[i].bus, i2c_ex_devs[i].slave,
-				i2c_ex_devs[i].slave,
+				       i2c_ex_devs[i].regs[j].reg, &buf, MASK, SHIFT);
-				i2c_ex_devs[i].regs[j].reg,
+			assert_int_equal(
-				&buf, MASK, SHIFT);
+				(i2c_ex_devs[i].regs[j].data & (MASK << SHIFT)) >> SHIFT, buf);
-			assert_int_equal((i2c_ex_devs[i].regs[j].data &
-				(MASK << SHIFT)) >> SHIFT, buf);
 		};
 
 	/* Read whole registers */
 	for (i = 0; i < ARRAY_SIZE(i2c_ex_devs); i++)
 		for (j = 0; j < ARRAY_SIZE(i2c_ex_devs[0].regs); j++) {
-			i2c_read_field(i2c_ex_devs[i].bus,
+			i2c_read_field(i2c_ex_devs[i].bus, i2c_ex_devs[i].slave,
-				i2c_ex_devs[i].slave,
+				       i2c_ex_devs[i].regs[j].reg, &buf, 0xFF, 0);
-				i2c_ex_devs[i].regs[j].reg,
-				&buf, 0xFF, 0);
 			assert_int_equal(i2c_ex_devs[i].regs[j].data, buf);
 		};
 }
@@ -133,10 +133,8 @@ static void i2c_write_field_test(void **state)
 		for (j = 0; j < ARRAY_SIZE(i2c_ex_devs[0].regs); j++) {
 			buf = 0x0;
 			tmp = i2c_ex_devs[i].regs[j].data;
-			i2c_write_field(i2c_ex_devs[i].bus,
+			i2c_write_field(i2c_ex_devs[i].bus, i2c_ex_devs[i].slave,
-				i2c_ex_devs[i].slave,
+					i2c_ex_devs[i].regs[j].reg, buf, MASK, SHIFT);
-				i2c_ex_devs[i].regs[j].reg,
-				buf, MASK, SHIFT);
 			assert_int_equal(i2c_ex_devs[i].regs[j].data,
 					 (tmp & ~(MASK << SHIFT)) | (buf << SHIFT));
 		};
@@ -145,24 +143,18 @@ static void i2c_write_field_test(void **state)
 	   i2c_read_field() accessor. */
 	for (i = 0; i < ARRAY_SIZE(i2c_ex_devs); i++)
 		for (j = 0; j < ARRAY_SIZE(i2c_ex_devs[0].regs); j++) {
-			i2c_write_field(i2c_ex_devs[i].bus,
+			i2c_write_field(i2c_ex_devs[i].bus, i2c_ex_devs[i].slave,
-				i2c_ex_devs[i].slave,
+					i2c_ex_devs[i].regs[j].reg, 0xFF, 0xFF, 0);
-				i2c_ex_devs[i].regs[j].reg,
+			i2c_read_field(i2c_ex_devs[i].bus, i2c_ex_devs[i].slave,
-				0xFF, 0xFF, 0);
+				       i2c_ex_devs[i].regs[j].reg, &buf, 0xFF, 0);
-			i2c_read_field(i2c_ex_devs[i].bus,
-				i2c_ex_devs[i].slave,
-				i2c_ex_devs[i].regs[j].reg,
-				&buf, 0xFF, 0);
 			assert_int_equal(buf, 0xFF);
 		};
 }
 
 int main(void)
 {
-	const struct CMUnitTest tests[] = {
+	const struct CMUnitTest tests[] = {cmocka_unit_test(i2c_read_field_test),
-		cmocka_unit_test(i2c_read_field_test),
+					   cmocka_unit_test(i2c_write_field_test)};
-		cmocka_unit_test(i2c_write_field_test)
-	};
 
 	return cb_run_group_tests(tests, NULL, NULL);
 }

tests/include/tests/lib/edid.h

@@ -46,11 +46,16 @@ struct edid_raw {
 	uint8_t checksum;
 } __packed;
 
-_Static_assert(sizeof(struct edid_raw) == 128,
+_Static_assert(sizeof(struct edid_raw) == 128, "assert failed: edid_raw size mismatch");
-	       "assert failed: edid_raw size mismatch");
 
-#define EDID_HEADER_RAW		{ 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00 }
+#define EDID_HEADER_RAW                                                                        \
-#define EDID_HEADER_INVALID_RAW	{ 0, 0, 0, 0, 0, 0, 0, 0 }
+	{                                                                                      \
+		0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00                                 \
+	}
+#define EDID_HEADER_INVALID_RAW                                                                \
+	{                                                                                      \
+		0, 0, 0, 0, 0, 0, 0, 0                                                         \
+	}
 
 #define EDID_MANUFACTURER_ID 0xcb55
 #define EDID_MANUFACTURER_NAME "UNK"
@@ -174,29 +179,19 @@ _Static_assert(sizeof(struct edid_raw) == 128,
 #define EDID_ASPECT_RATIO_4_3 (1u << 6)
 #define EDID_ASPECT_RATIO_5_4 (2u << 6)
 #define EDID_ASPECT_RATIO_16_9 (3u << 6)
-#define EDID_FIELD_REFRESH_RATE(hz)		(((hz) - 60) & 0x1f)
+#define EDID_FIELD_REFRESH_RATE(hz) (((hz)-60) & 0x1f)
 
 #define EDID_PIXEL_CLOCK(v) (((v) / 10000) & 0xFFFF)
 
-#define EDID_RAW_DEFAULT_PARAMS .header = EDID_HEADER_RAW, \
+#define EDID_RAW_DEFAULT_PARAMS                                                                \
-				.edid_version = 1, \
+	.header = EDID_HEADER_RAW, .edid_version = 1, .edid_revision = 4,                      \
-				.edid_revision = 4, \
+	.manufacturer_id = EDID_MANUFACTURER_ID, .product_code = EDID_PRODUCT_CODE,            \
-				.manufacturer_id = EDID_MANUFACTURER_ID, \
+	.serial_number = EDID_SERIAL_NUMBER, .manufacture_week = EDID_MANUFACTURE_NO_WEEK,     \
-				.product_code = EDID_PRODUCT_CODE, \
-				.serial_number = EDID_SERIAL_NUMBER, \
-				.manufacture_week = EDID_MANUFACTURE_NO_WEEK, \
 	.manufacture_year = EDID_MANUFACTURE_YEAR,                                             \
 	.color_characteristics = {                                                             \
-					EDID_COLOR_RG_XY, \
+		EDID_COLOR_RG_XY, EDID_COLOR_BW_XY, EDID_COLOR_R_X92, EDID_COLOR_R_Y92,        \
-					EDID_COLOR_BW_XY, \
+		EDID_COLOR_G_X92, EDID_COLOR_G_Y92, EDID_COLOR_B_X92, EDID_COLOR_B_Y92,        \
-					EDID_COLOR_R_X92, \
+		EDID_COLOR_W_X92, EDID_COLOR_W_Y92,                                            \
-					EDID_COLOR_R_Y92, \
-					EDID_COLOR_G_X92, \
-					EDID_COLOR_G_Y92, \
-					EDID_COLOR_B_X92, \
-					EDID_COLOR_B_Y92, \
-					EDID_COLOR_W_X92, \
-					EDID_COLOR_W_Y92, \
 	}
 
 #endif /* TESTS_LIB_EDID_H */

tests/lib/cbfs-lookup-test.c

@@ -12,8 +12,8 @@
 
 static struct cbfs_boot_device cbd;
 
-static u8 aligned_cbfs_buffer[(sizeof(struct cbfs_test_file) + CBFS_ALIGNMENT) * 10]
+static u8 aligned_cbfs_buffer[(sizeof(struct cbfs_test_file) + CBFS_ALIGNMENT) * 10] __aligned(
-	__aligned(CBFS_ALIGNMENT);
+	CBFS_ALIGNMENT);
 
 static u8 *unaligned_cbfs_buffer = &aligned_cbfs_buffer[3];
 static uintptr_t unaligned_cbfs_buffer_size = sizeof(aligned_cbfs_buffer) - 3;
@@ -386,7 +386,8 @@ static void test_cbfs_image_not_aligned(void **state)
 	size_t size_out;
 	struct cbfs_test_state *s = *state;
 	const struct cbfs_test_file *cbfs_files[] = {
-		&test_file_int_1, &test_file_2,
+		&test_file_int_1,
+		&test_file_2,
 	};
 	assert_int_equal(0, create_cbfs(cbfs_files, ARRAY_SIZE(cbfs_files), &s->cbfs_buf[5],
 					s->cbfs_size - 5));
@@ -663,8 +664,9 @@ static void test_cbfs_two_files_with_same_name(void **state)
 	size_out = 0;
 	expect_lookup_result(CB_SUCCESS);
 	mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out);
-	assert_ptr_equal(mapping, &s->cbfs_buf[third_file_start
+	assert_ptr_equal(
-					       + be32_to_cpu(test_file_int_1.header.offset)]);
+		mapping,
+		&s->cbfs_buf[third_file_start + be32_to_cpu(test_file_int_1.header.offset)]);
 	assert_int_equal(size_out, be32_to_cpu(test_file_int_1.header.len));
 }
 
@@ -723,8 +725,7 @@ static void test_cbfs_attributes_offset_larger_than_offset(void **state)
 	assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0);
 	memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2));
 	f = (struct cbfs_test_file *)s->cbfs_buf;
-	f->header.attributes_offset = cpu_to_be32(
+	f->header.attributes_offset = cpu_to_be32(sizeof(struct cbfs_file) + FILENAME_SIZE
-				sizeof(struct cbfs_file) + FILENAME_SIZE
 						  + sizeof(struct cbfs_file_attr_compression));
 	f->header.offset = cpu_to_be32(sizeof(struct cbfs_file) + FILENAME_SIZE);
 
@@ -943,8 +944,9 @@ static void test_cbfs_attributes_offset_uint32_max(void **state)
 	EMPTY_WRAP(                                                                            \
 		CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST(                                   \
 			("aligned, " name), (test_fn), setup_test_cbfs_aligned, (prestate)),   \
-		CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST(                                   \
+		CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST(("unaligned, " name), (test_fn),   \
-			("unaligned, " name), (test_fn), setup_test_cbfs_unaligned, (prestate)))
+							    setup_test_cbfs_unaligned,         \
+							    (prestate)))
 
 #define CBFS_LOOKUP_TEST(test_fn) CBFS_LOOKUP_NAME_PRESTATE_TEST(#test_fn, test_fn, NULL)
 

tests/lib/cbmem_console-test.c

@@ -47,7 +47,8 @@ void test_cbmemc_tx_byte(void **state)
 {
 	int i;
 	u32 cursor;
-	const unsigned char data[] = "Random testing string\n"
+	const unsigned char data[] =
+		"Random testing string\n"
 		"`1234567890-=~!@#$%^&*()_+\n"
 		"abcdefghijklmnopqrstuvwxyz\n"
 		"ABCDEFGHIJKLMNOPQRSTUVWXYZ\n";
@@ -69,7 +70,8 @@ void test_cbmemc_tx_byte_overflow(void **state)
 	u32 cursor;
 	u32 flags;
 	const uint32_t console_size = current_console->size;
-	const unsigned char data[] = "Another random string\n"
+	const unsigned char data[] =
+		"Another random string\n"
 		"abcdefghijklmnopqrstuvwxyz\n"
 		"ABCDEFGHIJKLMNOPQRSTUVWXYZ\n"
 		"`1234567890-=~!@#$%^&*()_+\n";
@@ -102,16 +104,13 @@ void test_cbmemc_tx_byte_overflow(void **state)
 	assert_int_equal(data_size, cursor);
 
 	/* Check if overflow buffer was overwritten */
-	assert_memory_not_equal(current_console->body,
+	assert_memory_not_equal(current_console->body, data, overflow_bytes);
-			data,
-			overflow_bytes);
 
 	/* Check if rest of the buffer contents, that should not be overridden,
 	 * is the same.
 	 */
 	assert_memory_equal(&current_console->body[overflow_bytes],
-			check_buffer + overflow_bytes,
+			    check_buffer + overflow_bytes, console_size - overflow_bytes);
-			console_size - overflow_bytes);
 
 	free(check_buffer);
 }
@@ -120,10 +119,10 @@ int main(void)
 {
 	const struct CMUnitTest tests[] = {
 		cmocka_unit_test_teardown(test_cbmemc_init, teardown_cbmemc),
-		cmocka_unit_test_setup_teardown(test_cbmemc_tx_byte,
+		cmocka_unit_test_setup_teardown(test_cbmemc_tx_byte, setup_cbmemc,
-						setup_cbmemc, teardown_cbmemc),
+						teardown_cbmemc),
-		cmocka_unit_test_setup_teardown(test_cbmemc_tx_byte_overflow,
+		cmocka_unit_test_setup_teardown(test_cbmemc_tx_byte_overflow, setup_cbmemc,
-						setup_cbmemc, teardown_cbmemc),
+						teardown_cbmemc),
 	};
 
 	return cb_run_group_tests(tests, NULL, NULL);

tests/lib/cbmem_stage_cache-test.c

@@ -180,14 +180,14 @@ void test_stage_cache_load_stage(void **state)
 int main(void)
 {
 	const struct CMUnitTest tests[] = {
-		cmocka_unit_test_setup_teardown(test_stage_cache_add,
+		cmocka_unit_test_setup_teardown(test_stage_cache_add, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_stage_cache_add_raw,
+		cmocka_unit_test_setup_teardown(test_stage_cache_add_raw, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_stage_cache_get_raw,
+		cmocka_unit_test_setup_teardown(test_stage_cache_get_raw, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_stage_cache_load_stage,
+		cmocka_unit_test_setup_teardown(test_stage_cache_load_stage, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
 	};
 
 	return cb_run_group_tests(tests, NULL, NULL);

tests/lib/compute_ip_checksum-test.c

@@ -7,12 +7,9 @@
 #include <ip_checksum.h>
 
 static const uint8_t test_data_simple[] = {
-	0x64, 0x3b, 0x33, 0x17, 0x34, 0x74, 0x62, 0x30,
+	0x64, 0x3b, 0x33, 0x17, 0x34, 0x74, 0x62, 0x30, 0x75, 0x73, 0xf3, 0x11, 0x30, 0x2c,
-	0x75, 0x73, 0xf3, 0x11, 0x30, 0x2c, 0x34, 0x35,
+	0x34, 0x35, 0x6d, 0x39, 0x69, 0x32, 0x23, 0x24, 0x76, 0x71, 0x77, 0x30, 0x39, 0x75,
-	0x6d, 0x39, 0x69, 0x32, 0x23, 0x24, 0x76, 0x71,
+	0x76, 0x35, 0x71, 0x32, 0x40, 0x46, 0x34, 0x34, 0xBB, 0x03, 0x66, 0x52};
-	0x77, 0x30, 0x39, 0x75, 0x76, 0x35, 0x71, 0x32,
-	0x40, 0x46, 0x34, 0x34, 0xBB, 0x03, 0x66, 0x52
-};
 static const size_t test_data_simple_sz = ARRAY_SIZE(test_data_simple);
 static const unsigned long test_data_simple_checksum = 0x4267;
 

tests/lib/coreboot_table-test.c

@@ -44,10 +44,9 @@ static struct lb_record *lb_first_record(struct lb_header *header)
 }
 
 #define LB_RECORD_FOR_EACH(record_ptr, index, header)                                          \
-	for (index = 0, record_ptr = lb_first_record(header);				\
+	for (index = 0, record_ptr = lb_first_record(header); index < header->table_entries;   \
-		index < header->table_entries;						\
+	     record_ptr = (struct lb_record *)((uintptr_t)record_ptr + record_ptr->size),      \
-		record_ptr = (struct lb_record *)((uintptr_t)record_ptr			\
+	    index++)
-							+ record_ptr->size), index++)
 
 static void test_lb_add_gpios(void **state)
 {
@@ -170,13 +169,11 @@ static void test_write_coreboot_forwarding_table(void **state)
 					+ 2 * sizeof(struct lb_forward)];
 	struct lb_header *forward_header =
 		(struct lb_header *)ALIGN_UP((uintptr_t)forwarding_table_buffer, 16);
-	size_t forwarding_table_size =
+	size_t forwarding_table_size = write_coreboot_forwarding_table(
-			write_coreboot_forwarding_table((uintptr_t)forwarding_table_buffer,
+		(uintptr_t)forwarding_table_buffer, (uintptr_t)header);
-							(uintptr_t)header);
+	size_t expected_forwarding_table_size =
-	size_t expected_forwarding_table_size = ALIGN_UP((uintptr_t)forwarding_table_buffer, 16)
+		ALIGN_UP((uintptr_t)forwarding_table_buffer, 16) + sizeof(struct lb_header)
-						+ sizeof(struct lb_header)
+		+ sizeof(struct lb_forward) - (uintptr_t)forwarding_table_buffer;
-						+ sizeof(struct lb_forward)
-						- (uintptr_t)forwarding_table_buffer;
 	assert_int_equal(expected_forwarding_table_size, forwarding_table_size);
 
 	assert_int_equal(1, forward_header->table_entries);
@@ -214,8 +211,8 @@ void arch_write_tables(uintptr_t coreboot_table)
 }
 
 struct resource mock_bootmem_ranges[] = {
-	{ .base = 0x1000, .size = 0x2000, .flags = LB_MEM_RAM },
+	{.base = 0x1000, .size = 0x2000, .flags = LB_MEM_RAM},
-	{ .base = 0x0000, .size = 0x4000, .flags = LB_MEM_RAM },
+	{.base = 0x0000, .size = 0x4000, .flags = LB_MEM_RAM},
 };
 
 void bootmem_write_memory_table(struct lb_memory *mem)
@@ -346,7 +343,8 @@ static void test_write_tables(void **state)
 	/* At least one entry should be present. */
 	assert_int_not_equal(0, header->table_entries);
 
-	LB_RECORD_FOR_EACH(record, i, header) {
+	LB_RECORD_FOR_EACH(record, i, header)
+	{
 		switch (record->tag) {
 		case LB_TAG_MEMORY:
 			/* Should be the same as in bootmem_write_memory_table() */
@@ -376,27 +374,34 @@ static void test_write_tables(void **state)
 		case LB_TAG_MAINBOARD:
 			/* Mainboard record contains its header followed
 			   by two null-terminated strings */
-			assert_int_equal(ALIGN_UP(sizeof(struct lb_mainboard) +
+			assert_int_equal(ALIGN_UP(sizeof(struct lb_mainboard)
-					ARRAY_SIZE(mainboard_vendor) +
+							  + ARRAY_SIZE(mainboard_vendor)
-					ARRAY_SIZE(mainboard_part_number), 8), record->size);
+							  + ARRAY_SIZE(mainboard_part_number),
+						  8),
+					 record->size);
 			break;
 		case LB_TAG_VERSION:
 			assert_int_equal(ALIGN_UP(sizeof(struct lb_string)
-					+ ARRAY_SIZE(coreboot_version), 8), record->size);
+							  + ARRAY_SIZE(coreboot_version),
+						  8),
+					 record->size);
 			break;
 		case LB_TAG_EXTRA_VERSION:
 			assert_int_equal(ALIGN_UP(sizeof(struct lb_string)
-					+ ARRAY_SIZE(coreboot_extra_version), 8),
+							  + ARRAY_SIZE(coreboot_extra_version),
+						  8),
 					 record->size);
 			break;
 		case LB_TAG_BUILD:
-			assert_int_equal(ALIGN_UP(sizeof(struct lb_string)
+			assert_int_equal(
-					+ ARRAY_SIZE(coreboot_build), 8),
+				ALIGN_UP(sizeof(struct lb_string) + ARRAY_SIZE(coreboot_build),
+					 8),
 				record->size);
 			break;
 		case LB_TAG_COMPILE_TIME:
 			assert_int_equal(ALIGN_UP(sizeof(struct lb_string)
-					+ ARRAY_SIZE(coreboot_compile_time), 8),
+							  + ARRAY_SIZE(coreboot_compile_time),
+						  8),
 					 record->size);
 			break;
 		case LB_TAG_SERIAL:
@@ -442,12 +447,10 @@ static void test_write_tables(void **state)
 
 			const struct lb_cbmem_entry *cbmem_entry =
 				(struct lb_cbmem_entry *)record;
-			const LargestIntegralType expected_tags[] = {
+			const LargestIntegralType expected_tags[] = {CBMEM_ID_CBTABLE,
-				CBMEM_ID_CBTABLE,
+								     CBMEM_ID_MMC_STATUS};
-				CBMEM_ID_MMC_STATUS
+			assert_in_set(cbmem_entry->id, expected_tags,
-			};
+				      ARRAY_SIZE(expected_tags));
-			assert_in_set(cbmem_entry->id,
-					expected_tags, ARRAY_SIZE(expected_tags));
 			break;
 		case LB_TAG_TSC_INFO:
 			assert_int_equal(sizeof(struct lb_tsc_info), record->size);
@@ -467,8 +470,8 @@ static void test_write_tables(void **state)
 			const struct lb_board_config *board_config =
 				(struct lb_board_config *)record;
 			const struct lb_uint64 expected_fw_version = pack_lb64(fw_config_get());
-			assert_memory_equal(&expected_fw_version,
+			assert_memory_equal(&expected_fw_version, &board_config->fw_config,
-					&board_config->fw_config, sizeof(struct lb_uint64));
+					    sizeof(struct lb_uint64));
 			assert_int_equal(board_id(), board_config->board_id);
 			assert_int_equal(ram_code(), board_config->ram_code);
 			assert_int_equal(sku_id(), board_config->sku_id);
@@ -488,8 +491,7 @@ int main(void)
 		cmocka_unit_test_setup(test_lb_add_console, setup_test_header),
 		cmocka_unit_test_setup(test_multiple_entries, setup_test_header),
 		cmocka_unit_test_setup(test_write_coreboot_forwarding_table, setup_test_header),
-		cmocka_unit_test_setup_teardown(test_write_tables,
+		cmocka_unit_test_setup_teardown(test_write_tables, setup_write_tables_test,
-						setup_write_tables_test,
 						teardown_write_tables_test),
 	};
 

tests/lib/crc_byte-test.c

@@ -4,38 +4,25 @@
 #include <crc_byte.h>
 
 static const uint8_t test_data_bytes[] = {
-	0x2f, 0x8f, 0x2d, 0x06, 0xc2, 0x11, 0x0c, 0xaf,
+	0x2f, 0x8f, 0x2d, 0x06, 0xc2, 0x11, 0x0c, 0xaf, 0xd7, 0x4b, 0x48, 0x71, 0xce, 0x3c,
-	0xd7, 0x4b, 0x48, 0x71, 0xce, 0x3c, 0xfe, 0x29,
+	0xfe, 0x29, 0x90, 0xf6, 0x33, 0x6d, 0x79, 0x23, 0x9d, 0x84, 0x58, 0x5c, 0xcc, 0xf1,
-	0x90, 0xf6, 0x33, 0x6d, 0x79, 0x23, 0x9d, 0x84,
+	0xa1, 0xf2, 0x39, 0x22, 0xdc, 0x63, 0xe0, 0x44, 0x0a, 0x95, 0x36, 0xee, 0x53, 0xb3,
-	0x58, 0x5c, 0xcc, 0xf1, 0xa1, 0xf2, 0x39, 0x22,
+	0x61, 0x2c, 0x4a, 0xf4, 0x8b, 0x32, 0xeb, 0x94, 0x86, 0x55, 0x41, 0x27, 0xa4, 0xbd,
-	0xdc, 0x63, 0xe0, 0x44, 0x0a, 0x95, 0x36, 0xee,
+	0x0f, 0xc1, 0x4f, 0xfb, 0xb6, 0xa3, 0xc5, 0x38, 0x99, 0xfc, 0xca, 0xf8, 0x8e, 0x72,
-	0x53, 0xb3, 0x61, 0x2c, 0x4a, 0xf4, 0x8b, 0x32,
+	0xaa, 0xed, 0x6b, 0xb2, 0xd3, 0xd4, 0xd6, 0x81, 0x7d, 0x24, 0x56, 0x9f, 0x7a, 0x21,
-	0xeb, 0x94, 0x86, 0x55, 0x41, 0x27, 0xa4, 0xbd,
+	0x67, 0xac, 0x6a, 0x98, 0xf7, 0xd1, 0xad, 0x01, 0xdb, 0xc6, 0x80, 0x34, 0x8d, 0x51,
-	0x0f, 0xc1, 0x4f, 0xfb, 0xb6, 0xa3, 0xc5, 0x38,
+	0x60, 0x3e, 0xd2, 0x52, 0x0e, 0x26, 0x12, 0xb1, 0x13, 0xa2, 0x88, 0x04, 0x66, 0xb0,
-	0x99, 0xfc, 0xca, 0xf8, 0x8e, 0x72, 0xaa, 0xed,
+	0x3b, 0xc8, 0x1b, 0x7f, 0x92, 0x4e, 0xb8, 0xe9, 0x70, 0xe3, 0xfa, 0x76, 0x3a, 0xa7,
-	0x6b, 0xb2, 0xd3, 0xd4, 0xd6, 0x81, 0x7d, 0x24,
+	0x4c, 0x25, 0x91, 0x54, 0x19, 0xea, 0x50, 0x37, 0xd8, 0xb4, 0x47, 0x49, 0xbf, 0xc4,
-	0x56, 0x9f, 0x7a, 0x21, 0x67, 0xac, 0x6a, 0x98,
+	0xb7, 0xd0, 0x93, 0xda, 0x6c, 0x03, 0x9b, 0x15, 0xbb, 0xfd, 0xe7, 0xdd, 0x2e, 0x31,
-	0xf7, 0xd1, 0xad, 0x01, 0xdb, 0xc6, 0x80, 0x34,
+	0x68, 0x46, 0xa0, 0x43, 0xcd, 0x08, 0x8c, 0xff, 0x40, 0xcf, 0x1a, 0x7c, 0x69, 0x59,
-	0x8d, 0x51, 0x60, 0x3e, 0xd2, 0x52, 0x0e, 0x26,
+	0xc0, 0x5b, 0x83, 0x17, 0x10, 0x14, 0x9e, 0x1d, 0xc3, 0xa6, 0x5f, 0x4d, 0x9c, 0xa5,
-	0x12, 0xb1, 0x13, 0xa2, 0x88, 0x04, 0x66, 0xb0,
+	0x73, 0x77, 0x87, 0x96, 0x65, 0x0b, 0xec, 0xc7, 0xd9, 0x85, 0x1c, 0xae, 0x18, 0x5e,
-	0x3b, 0xc8, 0x1b, 0x7f, 0x92, 0x4e, 0xb8, 0xe9,
+	0x09, 0x78, 0x2b, 0x82, 0x1f, 0xe6, 0xc9, 0x64, 0x6f, 0x20, 0x16, 0x57, 0x9a, 0xbe,
-	0x70, 0xe3, 0xfa, 0x76, 0x3a, 0xa7, 0x4c, 0x25,
+	0xd5, 0xe2, 0x89, 0x3f, 0xdf, 0xe4, 0x7e, 0xde, 0x30, 0xa9, 0x74, 0xe5, 0xab, 0x07,
-	0x91, 0x54, 0x19, 0xea, 0x50, 0x37, 0xd8, 0xb4,
+	0x35, 0x5d, 0x2a, 0x28, 0xcb, 0xf0, 0x8a, 0xef, 0x5a, 0xe1, 0x75, 0x42, 0xf9, 0xba,
-	0x47, 0x49, 0xbf, 0xc4, 0xb7, 0xd0, 0x93, 0xda,
+	0x02, 0xbc, 0xf5, 0x45, 0x05, 0x0d, 0x3d, 0x62, 0xb9, 0x00, 0x7b, 0x1e, 0xe8, 0xb5,
-	0x6c, 0x03, 0x9b, 0x15, 0xbb, 0xfd, 0xe7, 0xdd,
+	0x97, 0x6e, 0xa8, 0xf3,
-	0x2e, 0x31, 0x68, 0x46, 0xa0, 0x43, 0xcd, 0x08,
-	0x8c, 0xff, 0x40, 0xcf, 0x1a, 0x7c, 0x69, 0x59,
-	0xc0, 0x5b, 0x83, 0x17, 0x10, 0x14, 0x9e, 0x1d,
-	0xc3, 0xa6, 0x5f, 0x4d, 0x9c, 0xa5, 0x73, 0x77,
-	0x87, 0x96, 0x65, 0x0b, 0xec, 0xc7, 0xd9, 0x85,
-	0x1c, 0xae, 0x18, 0x5e, 0x09, 0x78, 0x2b, 0x82,
-	0x1f, 0xe6, 0xc9, 0x64, 0x6f, 0x20, 0x16, 0x57,
-	0x9a, 0xbe, 0xd5, 0xe2, 0x89, 0x3f, 0xdf, 0xe4,
-	0x7e, 0xde, 0x30, 0xa9, 0x74, 0xe5, 0xab, 0x07,
-	0x35, 0x5d, 0x2a, 0x28, 0xcb, 0xf0, 0x8a, 0xef,
-	0x5a, 0xe1, 0x75, 0x42, 0xf9, 0xba, 0x02, 0xbc,
-	0xf5, 0x45, 0x05, 0x0d, 0x3d, 0x62, 0xb9, 0x00,
-	0x7b, 0x1e, 0xe8, 0xb5, 0x97, 0x6e, 0xa8, 0xf3,
 };
 static const size_t test_data_bytes_sz = ARRAY_SIZE(test_data_bytes);
 static const uint8_t test_data_crc7_checksum = 0x30;
@@ -191,8 +178,7 @@ static void test_crc16_byte_static_data(void **state)
 
 	/* Calculating CRC of data with its CRC should yield zero if data
 	   and/or checksum is correct */
-	assert_int_equal(0,
+	assert_int_equal(0, crc16_byte(crc16_byte(crc_value, test_data_crc16_checksum >> 8),
-			crc16_byte(crc16_byte(crc_value, test_data_crc16_checksum >> 8),
 				       test_data_crc16_checksum & 0xFF));
 }
 

tests/lib/dimm_info_util-test.c

@@ -37,13 +37,8 @@ static void test_smbios_bus_width_to_spd_width_parametrized(smbios_memory_type d
 static void test_smbios_bus_width_to_spd_width(void **state)
 {
 	smbios_memory_type memory_type[] = {
-		MEMORY_TYPE_DDR2,
+		MEMORY_TYPE_DDR2,   MEMORY_TYPE_DDR3,	MEMORY_TYPE_DDR4,   MEMORY_TYPE_DDR5,
-		MEMORY_TYPE_DDR3,
+		MEMORY_TYPE_LPDDR3, MEMORY_TYPE_LPDDR4, MEMORY_TYPE_LPDDR5,
-		MEMORY_TYPE_DDR4,
-		MEMORY_TYPE_DDR5,
-		MEMORY_TYPE_LPDDR3,
-		MEMORY_TYPE_LPDDR4,
-		MEMORY_TYPE_LPDDR5,
 	};
 
 	for (int i = 0; i < ARRAY_SIZE(memory_type); i++) {
@@ -91,32 +86,23 @@ static void test_smbios_memory_size_to_mib(void **state)
 static void test_smbios_form_factor_to_spd_mod_type_ddr(smbios_memory_type memory_type)
 {
 	const smbios_memory_form_factor undefined_factors[] = {
-		MEMORY_FORMFACTOR_OTHER,
+		MEMORY_FORMFACTOR_OTHER, MEMORY_FORMFACTOR_UNKNOWN,
-		MEMORY_FORMFACTOR_UNKNOWN,
+		MEMORY_FORMFACTOR_SIMM,	 MEMORY_FORMFACTOR_SIP,
-		MEMORY_FORMFACTOR_SIMM,
+		MEMORY_FORMFACTOR_CHIP,	 MEMORY_FORMFACTOR_DIP,
-		MEMORY_FORMFACTOR_SIP,
+		MEMORY_FORMFACTOR_ZIP,	 MEMORY_FORMFACTOR_PROPRIETARY_CARD,
-		MEMORY_FORMFACTOR_CHIP,
+		MEMORY_FORMFACTOR_TSOP,	 MEMORY_FORMFACTOR_ROC,
-		MEMORY_FORMFACTOR_DIP,
+		MEMORY_FORMFACTOR_SRIMM, MEMORY_FORMFACTOR_FBDIMM,
-		MEMORY_FORMFACTOR_ZIP,
-		MEMORY_FORMFACTOR_PROPRIETARY_CARD,
-		MEMORY_FORMFACTOR_TSOP,
-		MEMORY_FORMFACTOR_ROC,
-		MEMORY_FORMFACTOR_SRIMM,
-		MEMORY_FORMFACTOR_FBDIMM,
 		MEMORY_FORMFACTOR_DIE,
 	};
 	for (int i = 0; i < ARRAY_SIZE(undefined_factors); ++i) {
-		assert_int_equal(SPD_UNDEFINED,
+		assert_int_equal(SPD_UNDEFINED, smbios_form_factor_to_spd_mod_type(
-				smbios_form_factor_to_spd_mod_type(memory_type,
+							memory_type, undefined_factors[i]));
-						undefined_factors[i]));
 	}
 }
 
 static void test_smbios_form_factor_to_spd_mod_type_ddrx_parametrized(
-		smbios_memory_type memory_type,
+	smbios_memory_type memory_type, const LargestIntegralType udimm_allowed[],
-		const LargestIntegralType udimm_allowed[],
+	const LargestIntegralType rdimm_allowed[], LargestIntegralType expected_module_type)
-		const LargestIntegralType rdimm_allowed[],
-		LargestIntegralType expected_module_type)
 {
 	print_message("%s(%d)\n", __func__, memory_type);
 
@@ -126,8 +112,8 @@ static void test_smbios_form_factor_to_spd_mod_type_ddrx_parametrized(
 	assert_in_set(smbios_form_factor_to_spd_mod_type(memory_type, MEMORY_FORMFACTOR_RIMM),
 		      rdimm_allowed, MAX_ALLOWED_MODULE_TYPE);
 
-	assert_int_equal(expected_module_type, smbios_form_factor_to_spd_mod_type(memory_type,
+	assert_int_equal(expected_module_type, smbios_form_factor_to_spd_mod_type(
-					MEMORY_FORMFACTOR_SODIMM));
+						       memory_type, MEMORY_FORMFACTOR_SODIMM));
 
 	test_smbios_form_factor_to_spd_mod_type_ddr(memory_type);
 }
@@ -136,8 +122,8 @@ static void test_smbios_form_factor_to_spd_mod_type_lpddrx(smbios_memory_type me
 {
 	print_message("%s(%d)\n", __func__, memory_type);
 	/* Form factors defined in coreboot */
-	assert_int_equal(LPX_SPD_NONDIMM, smbios_form_factor_to_spd_mod_type(memory_type,
+	assert_int_equal(LPX_SPD_NONDIMM, smbios_form_factor_to_spd_mod_type(
-					MEMORY_FORMFACTOR_ROC));
+						  memory_type, MEMORY_FORMFACTOR_ROC));
 }
 
 static void test_smbios_form_factor_to_spd_mod_type(void **state)
@@ -150,30 +136,28 @@ static void test_smbios_form_factor_to_spd_mod_type(void **state)
 	} ddrx_info[] = {
 		{
 			.memory_type = MEMORY_TYPE_DDR2,
-			.udimm_allowed = { DDR2_SPD_UDIMM, DDR2_SPD_MICRO_DIMM,
+			.udimm_allowed = {DDR2_SPD_UDIMM, DDR2_SPD_MICRO_DIMM,
-						DDR2_SPD_MINI_UDIMM },
+					  DDR2_SPD_MINI_UDIMM},
-			.rdimm_allowed = { DDR2_SPD_RDIMM, DDR2_SPD_MINI_RDIMM },
+			.rdimm_allowed = {DDR2_SPD_RDIMM, DDR2_SPD_MINI_RDIMM},
 			.expected_module_type = DDR2_SPD_SODIMM,
 		},
 		{
 			.memory_type = MEMORY_TYPE_DDR3,
-			.udimm_allowed = { DDR3_SPD_UDIMM, DDR3_SPD_MICRO_DIMM,
+			.udimm_allowed = {DDR3_SPD_UDIMM, DDR3_SPD_MICRO_DIMM,
-						DDR3_SPD_MINI_UDIMM },
+					  DDR3_SPD_MINI_UDIMM},
-			.rdimm_allowed = { DDR3_SPD_RDIMM, DDR3_SPD_MINI_RDIMM },
+			.rdimm_allowed = {DDR3_SPD_RDIMM, DDR3_SPD_MINI_RDIMM},
 			.expected_module_type = DDR3_SPD_SODIMM,
 		},
 		{
 			.memory_type = MEMORY_TYPE_DDR4,
-			.udimm_allowed = { DDR4_SPD_UDIMM, DDR4_SPD_MINI_UDIMM },
+			.udimm_allowed = {DDR4_SPD_UDIMM, DDR4_SPD_MINI_UDIMM},
-			.rdimm_allowed = { DDR4_SPD_RDIMM, DDR4_SPD_MINI_RDIMM },
+			.rdimm_allowed = {DDR4_SPD_RDIMM, DDR4_SPD_MINI_RDIMM},
 			.expected_module_type = DDR4_SPD_SODIMM,
 		},
-		{
+		{.memory_type = MEMORY_TYPE_DDR5,
-			.memory_type = MEMORY_TYPE_DDR5,
+		 .udimm_allowed = {DDR5_SPD_UDIMM, DDR5_SPD_MINI_UDIMM},
-			.udimm_allowed = { DDR5_SPD_UDIMM, DDR5_SPD_MINI_UDIMM },
+		 .rdimm_allowed = {DDR5_SPD_RDIMM, DDR5_SPD_MINI_RDIMM},
-			.rdimm_allowed = { DDR5_SPD_RDIMM, DDR5_SPD_MINI_RDIMM },
+		 .expected_module_type = DDR5_SPD_SODIMM},
-			.expected_module_type = DDR5_SPD_SODIMM
-		},
 	};
 
 	/* Test for DDRx DIMM Modules */

tests/lib/fmap-test.c

@@ -272,8 +272,8 @@ static void test_fmap_overwrite_area(void **state)
 	assert_memory_equal(buffer2 + (section_size / 2), zero_buffer, section_size / 2);
 
 	/* Expect error when overwriting incorrect section */
-	assert_int_equal(-1, fmap_overwrite_area("NONEXISTENT_SECTION",
+	assert_int_equal(
-							new_data, section_size / 2));
+		-1, fmap_overwrite_area("NONEXISTENT_SECTION", new_data, section_size / 2));
 	assert_int_equal(-1, fmap_overwrite_area(NULL, new_data, section_size / 2));
 
 	/* Function fmap_overwrite_area is not tested with NULL
@@ -288,18 +288,17 @@ static void test_fmap_overwrite_area(void **state)
 int main(void)
 {
 	const struct CMUnitTest tests[] = {
-		cmocka_unit_test_setup_teardown(test_fmap_locate_area_as_rdev,
+		cmocka_unit_test_setup_teardown(test_fmap_locate_area_as_rdev, setup_fmap,
-						setup_fmap, teardown_fmap),
+						teardown_fmap),
-		cmocka_unit_test_setup_teardown(test_fmap_locate_area_as_rdev_rw,
+		cmocka_unit_test_setup_teardown(test_fmap_locate_area_as_rdev_rw, setup_fmap,
-						setup_fmap, teardown_fmap),
+						teardown_fmap),
-		cmocka_unit_test_setup_teardown(test_fmap_locate_area,
+		cmocka_unit_test_setup_teardown(test_fmap_locate_area, setup_fmap,
-						setup_fmap, teardown_fmap),
+						teardown_fmap),
-		cmocka_unit_test_setup_teardown(test_fmap_find_region_name,
+		cmocka_unit_test_setup_teardown(test_fmap_find_region_name, setup_fmap,
-						setup_fmap, teardown_fmap),
+						teardown_fmap),
-		cmocka_unit_test_setup_teardown(test_fmap_read_area,
+		cmocka_unit_test_setup_teardown(test_fmap_read_area, setup_fmap, teardown_fmap),
-						setup_fmap, teardown_fmap),
+		cmocka_unit_test_setup_teardown(test_fmap_overwrite_area, setup_fmap,
-		cmocka_unit_test_setup_teardown(test_fmap_overwrite_area,
+						teardown_fmap),
-						setup_fmap, teardown_fmap),
 	};
 
 	return cb_run_group_tests(tests, NULL, NULL);

tests/lib/hexstrtobin-test.c

@@ -12,11 +12,11 @@ struct hexstr_t {
 	size_t res;
 } hexstr[] = {
 	{.str = "A", .res = 0},
-	{.str = "AB", .val = (int[]) {171}, .res = 1},
+	{.str = "AB", .val = (int[]){171}, .res = 1},
-	{.str = "277a", .val = (int[]) {39, 122}, .res = 2},
+	{.str = "277a", .val = (int[]){39, 122}, .res = 2},
-	{.str = "277ab", .val = (int[]) {39, 122}, .res = 2},
+	{.str = "277ab", .val = (int[]){39, 122}, .res = 2},
-	{.str = "\n\rx1234567ijkl", .val = (int[]) {18, 52, 86}, .res = 3},
+	{.str = "\n\rx1234567ijkl", .val = (int[]){18, 52, 86}, .res = 3},
-	{.str = "\nB*e/ef-", .val = (int[]) {190, 239}, .res = 2},
+	{.str = "\nB*e/ef-", .val = (int[]){190, 239}, .res = 2},
 };
 
 static void test_hexstrtobin(void **state)

tests/lib/imd-test.c

@@ -12,8 +12,9 @@
 
 /* Auxiliary functions and definitions. */
 
-#define LG_ROOT_SIZE align_up_pow2(sizeof(struct imd_root_pointer) +\
+#define LG_ROOT_SIZE                                                                           \
-	 sizeof(struct imd_root) + 3 * sizeof(struct imd_entry))
+	align_up_pow2(sizeof(struct imd_root_pointer) + sizeof(struct imd_root)                \
+		      + 3 * sizeof(struct imd_entry))
 #define LG_ENTRY_ALIGN (2 * sizeof(int32_t))
 #define LG_ENTRY_SIZE (2 * sizeof(int32_t))
 #define LG_ENTRY_ID 0xA001
@@ -122,16 +123,15 @@ static void test_imd_create_empty(void **state)
 	imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
 
 	/* Try incorrect sizes */
-	assert_int_equal(-1, imd_create_empty(&imd,
+	assert_int_equal(
-					sizeof(struct imd_root_pointer),
+		-1, imd_create_empty(&imd, sizeof(struct imd_root_pointer), LG_ENTRY_ALIGN));
-					LG_ENTRY_ALIGN));
 	assert_int_equal(-1, imd_create_empty(&imd, LG_ROOT_SIZE, 2 * LG_ROOT_SIZE));
 
 	/* Working case */
 	assert_int_equal(0, imd_create_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN));
 
 	/* Only large allocation initialized with one entry for the root region */
-	r = (struct imd_root *) (imd.lg.r);
+	r = (struct imd_root *)(imd.lg.r);
 	assert_non_null(r);
 
 	e = &r->entries[r->num_entries - 1];
@@ -174,12 +174,10 @@ static void test_imd_create_tiered_empty(void **state)
 						     sizeof(int32_t), 2 * sizeof(int32_t)));
 
 	/* Fail when large region doesn't have capacity for more than 1 entry */
-	lg_region_wrong_size = sizeof(struct imd_root_pointer) + sizeof(struct imd_root) +
+	lg_region_wrong_size = sizeof(struct imd_root_pointer) + sizeof(struct imd_root)
-			       sizeof(struct imd_entry);
+			       + sizeof(struct imd_entry);
-	expect_assert_failure(
+	expect_assert_failure(imd_create_tiered_empty(
-		imd_create_tiered_empty(&imd, lg_region_wrong_size, LG_ENTRY_ALIGN,
+		&imd, lg_region_wrong_size, LG_ENTRY_ALIGN, SM_ROOT_SIZE, SM_ENTRY_ALIGN));
-					SM_ROOT_SIZE, SM_ENTRY_ALIGN)
-	);
 
 	assert_int_equal(0, imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN,
 						    SM_ROOT_SIZE, SM_ENTRY_ALIGN));
@@ -234,7 +232,7 @@ static void test_imd_recover(void **state)
 	const struct imd_entry *lg_entry;
 
 	/* Fail when the limit for lg was not set. */
-	imd.lg.limit = (uintptr_t) NULL;
+	imd.lg.limit = (uintptr_t)NULL;
 	assert_int_equal(-1, imd_recover(&imd));
 
 	/* Set the limit for lg. */
@@ -327,8 +325,8 @@ static void test_imd_limit_size(void **state)
 	struct imd imd = {0};
 	size_t root_size, max_size;
 
-	max_size = align_up_pow2(sizeof(struct imd_root_pointer)
+	max_size = align_up_pow2(sizeof(struct imd_root_pointer) + sizeof(struct imd_root)
-			+ sizeof(struct imd_root) + 3 * sizeof(struct imd_entry));
+				 + 3 * sizeof(struct imd_entry));
 
 	assert_int_equal(-1, imd_limit_size(&imd, max_size));
 
@@ -337,8 +335,8 @@ static void test_imd_limit_size(void **state)
 		fail_msg("Cannot allocate enough memory - fail test");
 	imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
 
-	root_size = align_up_pow2(sizeof(struct imd_root_pointer)
+	root_size = align_up_pow2(sizeof(struct imd_root_pointer) + sizeof(struct imd_root)
-			+ sizeof(struct imd_root) + 2 * sizeof(struct imd_entry));
+				  + 2 * sizeof(struct imd_entry));
 	imd.lg.r = (void *)imd.lg.limit - root_size;
 
 	imd_create_empty(&imd, root_size, LG_ENTRY_ALIGN);
@@ -362,7 +360,7 @@ static void test_imd_lockdown(void **state)
 	if (imd.lg.r == NULL)
 		fail_msg("Cannot allocate enough memory - fail test");
 
-	r_lg = (struct imd_root *) (imd.lg.r);
+	r_lg = (struct imd_root *)(imd.lg.r);
 
 	assert_int_equal(0, imd_lockdown(&imd));
 	assert_true(r_lg->flags & IMD_FLAG_LOCKED);
@@ -370,7 +368,7 @@ static void test_imd_lockdown(void **state)
 	imd.sm.r = malloc(sizeof(struct imd_root));
 	if (imd.sm.r == NULL)
 		fail_msg("Cannot allocate enough memory - fail test");
-	r_sm = (struct imd_root *) (imd.sm.r);
+	r_sm = (struct imd_root *)(imd.sm.r);
 
 	assert_int_equal(0, imd_lockdown(&imd));
 	assert_true(r_sm->flags & IMD_FLAG_LOCKED);
@@ -492,7 +490,7 @@ static void test_imd_entry_add(void **state)
 	/* All five new entries should be added to small allocations */
 	for (i = 0; i < 5; i++) {
 		assert_non_null(imd_entry_add(&imd, SM_ENTRY_ID, SM_ENTRY_SIZE));
-		assert_int_equal(i+2, sm_r->num_entries);
+		assert_int_equal(i + 2, sm_r->num_entries);
 		assert_int_equal(2, lg_r->num_entries);
 	}
 
@@ -579,7 +577,7 @@ static void test_imd_entry_find_or_add(void **state)
 
 static void test_imd_entry_size(void **state)
 {
-	struct imd_entry entry = { .size =  LG_ENTRY_SIZE };
+	struct imd_entry entry = {.size = LG_ENTRY_SIZE};
 
 	assert_int_equal(LG_ENTRY_SIZE, imd_entry_size(&entry));
 
@@ -616,7 +614,7 @@ static void test_imd_entry_at(void **state)
 
 static void test_imd_entry_id(void **state)
 {
-	struct imd_entry entry = { .id =  LG_ENTRY_ID };
+	struct imd_entry entry = {.id = LG_ENTRY_ID};
 
 	assert_int_equal(LG_ENTRY_ID, imd_entry_id(&entry));
 }
@@ -761,4 +759,3 @@ int main(void)
 
 	return cb_run_group_tests(tests, NULL, NULL);
 }
-

tests/lib/imd_cbmem-test.c

@@ -447,8 +447,7 @@ static void test_cbmem_entry_start(void **state)
 }
 
 /* Reimplementation for testing purposes */
-void bootmem_add_range(uint64_t start, uint64_t size,
+void bootmem_add_range(uint64_t start, uint64_t size, const enum bootmem_type tag)
-		       const enum bootmem_type tag)
 {
 	check_expected(start);
 	check_expected(size);

tests/lib/libgcc-test.c

@@ -12,108 +12,108 @@ struct {
 } test_data[] = {
 	/* GCC documentation says, __clzsi2() has undefined result for zero as an input value,
 	   but coreboot implementation can handle this. */
-	{ .value = 0, .expected_output = 32 },
+	{.value = 0, .expected_output = 32},
 
-	{ .value = 1, .expected_output = 31 },
+	{.value = 1, .expected_output = 31},
-	{ .value = 2, .expected_output = 30 },
+	{.value = 2, .expected_output = 30},
-	{ .value = 3, .expected_output = 30 },
+	{.value = 3, .expected_output = 30},
-	{ .value = 4, .expected_output = 29 },
+	{.value = 4, .expected_output = 29},
-	{ .value = 5, .expected_output = 29 },
+	{.value = 5, .expected_output = 29},
-	{ .value = 6, .expected_output = 29 },
+	{.value = 6, .expected_output = 29},
-	{ .value = 7, .expected_output = 29 },
+	{.value = 7, .expected_output = 29},
 
-	{ .value = 0xF, .expected_output = 28 },
+	{.value = 0xF, .expected_output = 28},
-	{ .value = 0x10, .expected_output = 27 },
+	{.value = 0x10, .expected_output = 27},
-	{ .value = 0x25, .expected_output = 26 },
+	{.value = 0x25, .expected_output = 26},
-	{ .value = 0x5D, .expected_output = 25 },
+	{.value = 0x5D, .expected_output = 25},
-	{ .value = 0xB7, .expected_output = 24 },
+	{.value = 0xB7, .expected_output = 24},
 
-	{ .value = 0x133, .expected_output = 23 },
+	{.value = 0x133, .expected_output = 23},
-	{ .value = 0x3DC, .expected_output = 22 },
+	{.value = 0x3DC, .expected_output = 22},
-	{ .value = 0x6F1, .expected_output = 21 },
+	{.value = 0x6F1, .expected_output = 21},
-	{ .value = 0x897, .expected_output = 20 },
+	{.value = 0x897, .expected_output = 20},
 
-	{ .value = 0x1FFF, .expected_output = 19 },
+	{.value = 0x1FFF, .expected_output = 19},
-	{ .value = 0x2222, .expected_output = 18 },
+	{.value = 0x2222, .expected_output = 18},
-	{ .value = 0x7BAD, .expected_output = 17 },
+	{.value = 0x7BAD, .expected_output = 17},
-	{ .value = 0xE708, .expected_output = 16 },
+	{.value = 0xE708, .expected_output = 16},
 
-	{ .value = 0x1DABD, .expected_output = 15 },
+	{.value = 0x1DABD, .expected_output = 15},
-	{ .value = 0x29876, .expected_output = 14 },
+	{.value = 0x29876, .expected_output = 14},
-	{ .value = 0x56665, .expected_output = 13 },
+	{.value = 0x56665, .expected_output = 13},
-	{ .value = 0xABCDE, .expected_output = 12 },
+	{.value = 0xABCDE, .expected_output = 12},
 
-	{ .value = 0x18365F, .expected_output = 11 },
+	{.value = 0x18365F, .expected_output = 11},
-	{ .value = 0x3D0115, .expected_output = 10 },
+	{.value = 0x3D0115, .expected_output = 10},
-	{ .value = 0x4B07EB, .expected_output = 9 },
+	{.value = 0x4B07EB, .expected_output = 9},
-	{ .value = 0xCCC74D, .expected_output = 8 },
+	{.value = 0xCCC74D, .expected_output = 8},
 
-	{ .value = 0x17933ED, .expected_output = 7 },
+	{.value = 0x17933ED, .expected_output = 7},
-	{ .value = 0x2B00071, .expected_output = 6 },
+	{.value = 0x2B00071, .expected_output = 6},
-	{ .value = 0x4D4C1A5, .expected_output = 5 },
+	{.value = 0x4D4C1A5, .expected_output = 5},
-	{ .value = 0xAD01FFF, .expected_output = 4 },
+	{.value = 0xAD01FFF, .expected_output = 4},
 
-	{ .value = 0x1C5A8057, .expected_output = 3 },
+	{.value = 0x1C5A8057, .expected_output = 3},
-	{ .value = 0x35AB23C3, .expected_output = 2 },
+	{.value = 0x35AB23C3, .expected_output = 2},
-	{ .value = 0x7017013B, .expected_output = 1 },
+	{.value = 0x7017013B, .expected_output = 1},
-	{ .value = 0xAD01EB15, .expected_output = 0 },
+	{.value = 0xAD01EB15, .expected_output = 0},
 
-	{ .value = 0xFFFFFFFF, .expected_output = 0 },
+	{.value = 0xFFFFFFFF, .expected_output = 0},
-	{ .value = 0x80000000, .expected_output = 0 },
+	{.value = 0x80000000, .expected_output = 0},
-	{ .value = 0x7FFFFFFF, .expected_output = 1 },
+	{.value = 0x7FFFFFFF, .expected_output = 1},
-	{ .value = 0x30000000, .expected_output = 2 },
+	{.value = 0x30000000, .expected_output = 2},
-	{ .value = 0x10000000, .expected_output = 3 },
+	{.value = 0x10000000, .expected_output = 3},
-	{ .value = 0x0FFFFFFF, .expected_output = 4 },
+	{.value = 0x0FFFFFFF, .expected_output = 4},
 
-	{ .value = 0xFF000000, .expected_output = 0 },
+	{.value = 0xFF000000, .expected_output = 0},
-	{ .value = 0x00FF0000, .expected_output = 8 },
+	{.value = 0x00FF0000, .expected_output = 8},
-	{ .value = 0x0000FF00, .expected_output = 16 },
+	{.value = 0x0000FF00, .expected_output = 16},
-	{ .value = 0x000000FF, .expected_output = 24 },
+	{.value = 0x000000FF, .expected_output = 24},
 
-	{ .value = 0x8F000000, .expected_output = 0 },
+	{.value = 0x8F000000, .expected_output = 0},
-	{ .value = 0x008F0000, .expected_output = 8 },
+	{.value = 0x008F0000, .expected_output = 8},
-	{ .value = 0x00008F00, .expected_output = 16 },
+	{.value = 0x00008F00, .expected_output = 16},
-	{ .value = 0x0000008F, .expected_output = 24 },
+	{.value = 0x0000008F, .expected_output = 24},
 
-	{ .value = 0x7F000000, .expected_output = 1 },
+	{.value = 0x7F000000, .expected_output = 1},
-	{ .value = 0x007F0000, .expected_output = 9 },
+	{.value = 0x007F0000, .expected_output = 9},
-	{ .value = 0x00007F00, .expected_output = 17 },
+	{.value = 0x00007F00, .expected_output = 17},
-	{ .value = 0x0000007F, .expected_output = 25 },
+	{.value = 0x0000007F, .expected_output = 25},
 
-	{ .value = 0x3F000000, .expected_output = 2 },
+	{.value = 0x3F000000, .expected_output = 2},
-	{ .value = 0x003F0000, .expected_output = 10 },
+	{.value = 0x003F0000, .expected_output = 10},
-	{ .value = 0x00003F00, .expected_output = 18 },
+	{.value = 0x00003F00, .expected_output = 18},
-	{ .value = 0x0000003F, .expected_output = 26 },
+	{.value = 0x0000003F, .expected_output = 26},
 
-	{ .value = 0x1F000000, .expected_output = 3 },
+	{.value = 0x1F000000, .expected_output = 3},
-	{ .value = 0x001F0000, .expected_output = 11 },
+	{.value = 0x001F0000, .expected_output = 11},
-	{ .value = 0x00001F00, .expected_output = 19 },
+	{.value = 0x00001F00, .expected_output = 19},
-	{ .value = 0x0000001F, .expected_output = 27 },
+	{.value = 0x0000001F, .expected_output = 27},
 
-	{ .value = 0x0F000000, .expected_output = 4 },
+	{.value = 0x0F000000, .expected_output = 4},
-	{ .value = 0x000F0000, .expected_output = 12 },
+	{.value = 0x000F0000, .expected_output = 12},
-	{ .value = 0x00000F00, .expected_output = 20 },
+	{.value = 0x00000F00, .expected_output = 20},
-	{ .value = 0x0000000F, .expected_output = 28 },
+	{.value = 0x0000000F, .expected_output = 28},
 
-	{ .value = 0x08000000, .expected_output = 4 },
+	{.value = 0x08000000, .expected_output = 4},
-	{ .value = 0x00080000, .expected_output = 12 },
+	{.value = 0x00080000, .expected_output = 12},
-	{ .value = 0x00000800, .expected_output = 20 },
+	{.value = 0x00000800, .expected_output = 20},
-	{ .value = 0x00000008, .expected_output = 28 },
+	{.value = 0x00000008, .expected_output = 28},
 
-	{ .value = 0x07000000, .expected_output = 5 },
+	{.value = 0x07000000, .expected_output = 5},
-	{ .value = 0x00070000, .expected_output = 13 },
+	{.value = 0x00070000, .expected_output = 13},
-	{ .value = 0x00000700, .expected_output = 21 },
+	{.value = 0x00000700, .expected_output = 21},
-	{ .value = 0x00000007, .expected_output = 29 },
+	{.value = 0x00000007, .expected_output = 29},
 
-	{ .value = 0x03000000, .expected_output = 6 },
+	{.value = 0x03000000, .expected_output = 6},
-	{ .value = 0x00030000, .expected_output = 14 },
+	{.value = 0x00030000, .expected_output = 14},
-	{ .value = 0x00000300, .expected_output = 22 },
+	{.value = 0x00000300, .expected_output = 22},
-	{ .value = 0x00000003, .expected_output = 30 },
+	{.value = 0x00000003, .expected_output = 30},
 
-	{ .value = 0x01000000, .expected_output = 7 },
+	{.value = 0x01000000, .expected_output = 7},
-	{ .value = 0x00010000, .expected_output = 15 },
+	{.value = 0x00010000, .expected_output = 15},
-	{ .value = 0x00000100, .expected_output = 23 },
+	{.value = 0x00000100, .expected_output = 23},
-	{ .value = 0x00000001, .expected_output = 31 },
+	{.value = 0x00000001, .expected_output = 31},
 };
 
 void test_clzsi2_with_data(void **state)

tests/lib/lzma-test.c

@@ -51,12 +51,12 @@ static int setup_ulzman_file(void **state)
 	if (!s)
 		return 1;
 
-	const size_t raw_filename_size = strlen(path_prefix) + strlen(fname_base)
+	const size_t raw_filename_size =
-		+ ARRAY_SIZE(raw_file_suffix);
+		strlen(path_prefix) + strlen(fname_base) + ARRAY_SIZE(raw_file_suffix);
 	s->raw_filename = test_malloc(raw_filename_size);
 
-	const size_t comp_filename_size = strlen(path_prefix) + strlen(fname_base)
+	const size_t comp_filename_size =
-		+ ARRAY_SIZE(comp_file_suffix);
+		strlen(path_prefix) + strlen(fname_base) + ARRAY_SIZE(comp_file_suffix);
 	s->comp_filename = test_malloc(comp_filename_size);
 
 	if (!s->raw_filename || !s->comp_filename) {
@@ -148,13 +148,11 @@ static void test_ulzman_zero_buffer(void **state)
 }
 
 #define ULZMAN_CORRECT_FILE_TEST(_file_prefix)                                                 \
-{                                                                                      \
+	{                                                                                      \
 		.name = "test_ulzman_correct_file(" _file_prefix ")",                          \
-	.test_func = test_ulzman_correct_file,                                         \
+		.test_func = test_ulzman_correct_file, .setup_func = setup_ulzman_file,        \
-	.setup_func = setup_ulzman_file,                                               \
+		.teardown_func = teardown_ulzman_file, .initial_state = (_file_prefix)         \
-	.teardown_func = teardown_ulzman_file,                                         \
+	}
-	.initial_state = (_file_prefix)                                                \
-}
 
 int main(void)
 {

tests/lib/memchr-test.c

@@ -8,39 +8,25 @@ static const char test_data1[] =
 	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 static const size_t test_data1_sz = sizeof(test_data1);
 static const char test_data2[] = {
-		0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
-		0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+	0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
-		0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+	0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
-		0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+	0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
-		0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+	0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
-		0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+	0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53,
-		0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+	0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61,
-		0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+	0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
-		0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d,
-		0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+	0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
-		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+	0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
-		0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+	0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-		0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+	0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5,
-		0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+	0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3,
-		0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+	0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1,
-		0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+	0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
-		0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed,
-		0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+	0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
-		0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+	0xfc, 0xfd, 0xfe, 0xff};
-		0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
-		0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-		0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
-		0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
-		0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
-		0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
-		0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
-		0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
-		0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
-		0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
-		0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
-		0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
-		0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
-	};
 static const size_t test_data2_sz = sizeof(test_data2);
 
 static void test_memchr_existing_value(void **state)

tests/lib/memcpy-test.c

@@ -178,16 +178,16 @@ static void test_memcpy_copy_part_of_itself_to_itself(void **state)
 int main(void)
 {
 	const struct CMUnitTest tests[] = {
-		cmocka_unit_test_setup_teardown(test_memcpy_full_buffer_copy,
+		cmocka_unit_test_setup_teardown(test_memcpy_full_buffer_copy, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memcpy_zero_size,
+		cmocka_unit_test_setup_teardown(test_memcpy_zero_size, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memcpy_buffer_part,
+		cmocka_unit_test_setup_teardown(test_memcpy_buffer_part, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memcpy_buffer_part_unaligned,
+		cmocka_unit_test_setup_teardown(test_memcpy_buffer_part_unaligned, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memcpy_copy_to_itself,
+		cmocka_unit_test_setup_teardown(test_memcpy_copy_to_itself, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
 		cmocka_unit_test_setup_teardown(test_memcpy_copy_part_of_itself_to_itself,
 						setup_test, teardown_test),
 	};

tests/lib/memmove-test.c

@@ -225,26 +225,25 @@ static void test_memmove_self_lower_to_higher_unaligned(void **state)
 int main(void)
 {
 	const struct CMUnitTest tests[] = {
-		cmocka_unit_test_setup_teardown(test_memmove_full_buffer_copy,
+		cmocka_unit_test_setup_teardown(test_memmove_full_buffer_copy, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memmove_zero_size,
+		cmocka_unit_test_setup_teardown(test_memmove_zero_size, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memmove_buffer_part,
+		cmocka_unit_test_setup_teardown(test_memmove_buffer_part, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memmove_buffer_part_unaligned,
+		cmocka_unit_test_setup_teardown(test_memmove_buffer_part_unaligned, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memmove_copy_to_itself,
+		cmocka_unit_test_setup_teardown(test_memmove_copy_to_itself, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memmove_self_higher_to_lower,
+		cmocka_unit_test_setup_teardown(test_memmove_self_higher_to_lower, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
 		cmocka_unit_test_setup_teardown(test_memmove_self_higher_to_lower_unaligned,
 						setup_test, teardown_test),
-		cmocka_unit_test_setup_teardown(test_memmove_self_lower_to_higher,
+		cmocka_unit_test_setup_teardown(test_memmove_self_lower_to_higher, setup_test,
-						setup_test, teardown_test),
+						teardown_test),
 		cmocka_unit_test_setup_teardown(test_memmove_self_lower_to_higher_unaligned,
 						setup_test, teardown_test),
 	};
 
 	return cb_run_group_tests(tests, NULL, NULL);
 }
-

tests/lib/memrange-test.c

@@ -22,36 +22,54 @@ enum mem_types {
 
 /* Indices of entries matters, since it must reflect mem_types enum */
 struct resource res_mock_1[] = {
-	[CACHEABLE_TAG] = { .base = 0xE000, .size = 0xF2000,
+	[CACHEABLE_TAG] = {.base = 0xE000,
-	  .next = &res_mock_1[RESERVED_TAG], .flags = IORESOURCE_CACHEABLE | IORESOURCE_MEM },
+			   .size = 0xF2000,
-	[RESERVED_TAG] = { .base = 4ULL * GiB, .size = 4ULL * KiB,
+			   .next = &res_mock_1[RESERVED_TAG],
-	  .next = &res_mock_1[READONLY_TAG], .flags = IORESOURCE_RESERVE | IORESOURCE_MEM },
+			   .flags = IORESOURCE_CACHEABLE | IORESOURCE_MEM},
-	[READONLY_TAG] = { .base = 0xFF0000, .size = 0x10000, .next = NULL,
+	[RESERVED_TAG] = {.base = 4ULL * GiB,
-	  .flags = IORESOURCE_READONLY | IORESOURCE_MEM }
+			  .size = 4ULL * KiB,
+			  .next = &res_mock_1[READONLY_TAG],
+			  .flags = IORESOURCE_RESERVE | IORESOURCE_MEM},
+	[READONLY_TAG] = {.base = 0xFF0000,
+			  .size = 0x10000,
+			  .next = NULL,
+			  .flags = IORESOURCE_READONLY | IORESOURCE_MEM}
 };
 
 /* Boundary 1 byte below 4GiB and 1 byte above 4GiB. */
 struct resource res_mock_2[] = {
-	[CACHEABLE_TAG] = { .base = 0x1000000, .size = 4ULL * GiB - 0x1000001ULL,
+	[CACHEABLE_TAG] = {.base = 0x1000000,
-	  .next = &res_mock_2[RESERVED_TAG], .flags = IORESOURCE_CACHEABLE | IORESOURCE_MEM },
+			   .size = 4ULL * GiB - 0x1000001ULL,
-	[RESERVED_TAG] = { .base = 4ULL * GiB + 1ULL, .size = 4ULL * GiB,
+			   .next = &res_mock_2[RESERVED_TAG],
-	  .next = &res_mock_2[READONLY_TAG], .flags = IORESOURCE_RESERVE | IORESOURCE_MEM },
+			   .flags = IORESOURCE_CACHEABLE | IORESOURCE_MEM},
-	[READONLY_TAG] = { .base = 0, .size = 0x10000, .next = NULL,
+	[RESERVED_TAG] = {.base = 4ULL * GiB + 1ULL,
+			  .size = 4ULL * GiB,
+			  .next = &res_mock_2[READONLY_TAG],
+			  .flags = IORESOURCE_RESERVE | IORESOURCE_MEM},
+	[READONLY_TAG] = {.base = 0,
+			  .size = 0x10000,
+			  .next = NULL,
 			  .flags = IORESOURCE_READONLY | IORESOURCE_MEM}
 };
 
 /* Boundary crossing 4GiB. */
 struct resource res_mock_3[] = {
-	[CACHEABLE_TAG] = { .base = 0xD000, .size = 0xF3000,
+	[CACHEABLE_TAG] = {.base = 0xD000,
-	  .next = &res_mock_3[RESERVED_TAG], .flags = IORESOURCE_CACHEABLE | IORESOURCE_MEM },
+			   .size = 0xF3000,
-	[RESERVED_TAG] = { .base = 1ULL * GiB, .size = 4ULL * GiB,
+			   .next = &res_mock_3[RESERVED_TAG],
-	  .next = &res_mock_3[READONLY_TAG], .flags = IORESOURCE_RESERVE | IORESOURCE_MEM },
+			   .flags = IORESOURCE_CACHEABLE | IORESOURCE_MEM},
-	[READONLY_TAG] = { .base = 0xFF0000, .size = 0x10000, .next = NULL,
+	[RESERVED_TAG] = {.base = 1ULL * GiB,
+			  .size = 4ULL * GiB,
+			  .next = &res_mock_3[READONLY_TAG],
+			  .flags = IORESOURCE_RESERVE | IORESOURCE_MEM},
+	[READONLY_TAG] = {.base = 0xFF0000,
+			  .size = 0x10000,
+			  .next = NULL,
 			  .flags = IORESOURCE_READONLY | IORESOURCE_MEM}
 };
 
 
-struct device mock_device = { .enabled = 1 };
+struct device mock_device = {.enabled = 1};
 
 /* Fake memory devices handle */
 struct device *all_devices = &mock_device;
@@ -87,9 +105,8 @@ resource_t get_aligned_base(struct resource *res, struct range_entry *entry)
 
 resource_t get_aligned_end(struct resource *res, struct range_entry *entry)
 {
-	resource_t end = res[range_entry_tag(entry)].base +
+	resource_t end = res[range_entry_tag(entry)].base + res[range_entry_tag(entry)].size
-			 res[range_entry_tag(entry)].size +
+			 + (res[range_entry_tag(entry)].base - range_entry_base(entry));
-			 (res[range_entry_tag(entry)].base - range_entry_base(entry));
 	return ALIGN_UP(end, MEMRANGE_ALIGN);
 }
 
@@ -136,7 +153,8 @@ static void test_memrange_basic(void **state)
 
 	/* There should be two entries, since cacheable and
 	   reserved regions are not neighbors */
-	memranges_each_entry(ptr, &test_memrange) {
+	memranges_each_entry(ptr, &test_memrange)
+	{
 		assert_in_range(range_entry_tag(ptr), CACHEABLE_TAG, RESERVED_TAG);
 		assert_int_equal(range_entry_base(ptr), get_aligned_base(res_mock, ptr));
 
@@ -153,8 +171,7 @@ static void test_memrange_basic(void **state)
 
 	/* Remove initial memrange */
 	memranges_teardown(&test_memrange);
-	memranges_each_entry(ptr, &test_memrange)
+	memranges_each_entry(ptr, &test_memrange) counter++;
-		counter++;
 	assert_int_equal(counter, 0);
 }
 
@@ -205,7 +222,8 @@ static void test_memrange_clone_insert(void **state)
 	memranges_teardown(&test_memrange);
 
 	/* Verify that new one is really a clone */
-	memranges_each_entry(ptr, &clone_memrange) {
+	memranges_each_entry(ptr, &clone_memrange)
+	{
 		assert_in_range(range_entry_tag(ptr), CACHEABLE_TAG, END_OF_RESOURCES - 1);
 		assert_int_equal(range_entry_base(ptr), get_aligned_base(res_mock, ptr));
 
@@ -221,7 +239,8 @@ static void test_memrange_clone_insert(void **state)
 			 res_mock[CACHEABLE_TAG].size, INSERTED_TAG);
 
 	/* Three ranges should be there - CACHEABLE(shrunk), INSERTED and RESERVED */
-	memranges_each_entry(ptr, &clone_memrange) {
+	memranges_each_entry(ptr, &clone_memrange)
+	{
 		resource_t expected_end;
 
 		if (range_entry_tag(ptr) == CACHEABLE_TAG) {
@@ -234,8 +253,8 @@ static void test_memrange_clone_insert(void **state)
 			assert_int_equal(range_entry_base(ptr),
 					 res_mock[CACHEABLE_TAG].base + new_range_begin_offset);
 
-			expected_end = res_mock[CACHEABLE_TAG].base + new_range_begin_offset +
+			expected_end = res_mock[CACHEABLE_TAG].base + new_range_begin_offset
-				       res_mock[CACHEABLE_TAG].size;
+				       + res_mock[CACHEABLE_TAG].size;
 			assert_int_equal(range_entry_end(ptr),
 					 ALIGN_UP(expected_end, MEMRANGE_ALIGN));
 		}
@@ -248,7 +267,8 @@ static void test_memrange_clone_insert(void **state)
 	 * Additionally verify API for updating tags */
 	memranges_update_tag(&clone_memrange, INSERTED_TAG, READONLY_TAG);
 
-	memranges_each_entry(ptr, &clone_memrange) {
+	memranges_each_entry(ptr, &clone_memrange)
+	{
 		resource_t expected_end;
 
 		assert_int_not_equal(range_entry_tag(ptr), INSERTED_TAG);
@@ -256,8 +276,8 @@ static void test_memrange_clone_insert(void **state)
 			assert_int_equal(range_entry_base(ptr),
 					 res_mock[CACHEABLE_TAG].base + new_range_begin_offset);
 
-			expected_end = res_mock[CACHEABLE_TAG].base + new_range_begin_offset +
+			expected_end = res_mock[CACHEABLE_TAG].base + new_range_begin_offset
-				       res_mock[CACHEABLE_TAG].size;
+				       + res_mock[CACHEABLE_TAG].size;
 			assert_int_equal(range_entry_end(ptr),
 					 ALIGN_UP(expected_end, MEMRANGE_ALIGN));
 		}
@@ -267,17 +287,18 @@ static void test_memrange_clone_insert(void **state)
 	memranges_insert(&clone_memrange, res_mock[RESERVED_TAG].base + 0xAD,
 			 res_mock[RESERVED_TAG].size, INSERTED_TAG);
 
-	memranges_each_entry(ptr, &clone_memrange) {
+	memranges_each_entry(ptr, &clone_memrange)
+	{
 		resource_t expected_end;
 
 		assert_int_not_equal(range_entry_tag(ptr), RESERVED_TAG);
 		if (range_entry_tag(ptr) == INSERTED_TAG) {
-			assert_int_equal(range_entry_base(ptr),
+			assert_int_equal(
-					ALIGN_DOWN(res_mock[RESERVED_TAG].base,
+				range_entry_base(ptr),
-							MEMRANGE_ALIGN));
+				ALIGN_DOWN(res_mock[RESERVED_TAG].base, MEMRANGE_ALIGN));
 
-			expected_end = ALIGN_DOWN(res_mock[RESERVED_TAG].base, MEMRANGE_ALIGN) +
+			expected_end = ALIGN_DOWN(res_mock[RESERVED_TAG].base, MEMRANGE_ALIGN)
-					new_range_begin_offset + res_mock[RESERVED_TAG].size;
+				       + new_range_begin_offset + res_mock[RESERVED_TAG].size;
 			expected_end = ALIGN_UP(expected_end, MEMRANGE_ALIGN);
 
 			assert_int_equal(range_entry_end(ptr), expected_end);
@@ -329,7 +350,8 @@ static void test_memrange_holes(void **state)
 	memranges_add_resources(&test_memrange, reserved, reserved, RESERVED_TAG);
 
 	/* Count holes in ranges */
-	memranges_each_entry(ptr, &test_memrange) {
+	memranges_each_entry(ptr, &test_memrange)
+	{
 		if (!last_range_end) {
 			last_range_end = range_entry_end(ptr);
 			continue;
@@ -349,11 +371,12 @@ static void test_memrange_holes(void **state)
 	   (but with different tags) */
 	memranges_fill_holes_up_to(&test_memrange, holes_fill_end, HOLE_TAG);
 
-	memranges_each_entry(ptr, &test_memrange) {
+	memranges_each_entry(ptr, &test_memrange)
+	{
 		if (range_entry_tag(ptr) == HOLE_TAG) {
 			assert_int_equal(range_entry_base(ptr),
-					ALIGN_UP(res_mock[CACHEABLE_TAG].base +
+					 ALIGN_UP(res_mock[CACHEABLE_TAG].base
-						res_mock[CACHEABLE_TAG].size,
+							  + res_mock[CACHEABLE_TAG].size,
 						  MEMRANGE_ALIGN));
 			assert_int_equal(range_entry_end(ptr), holes_fill_end);
 			/* Store pointer to HOLE_TAG region for future use */
@@ -374,13 +397,14 @@ static void test_memrange_holes(void **state)
 	const resource_t new_cacheable_end = ALIGN_DOWN(
 		res_mock[CACHEABLE_TAG].base + res_mock[CACHEABLE_TAG].size - 4 * KiB,
 		MEMRANGE_ALIGN);
-	const resource_t new_hole_begin = ALIGN_UP(range_entry_base(hole_ptr) + 4 * KiB,
+	const resource_t new_hole_begin =
-							MEMRANGE_ALIGN);
+		ALIGN_UP(range_entry_base(hole_ptr) + 4 * KiB, MEMRANGE_ALIGN);
 	const resource_t ranges_diff = new_hole_begin - new_cacheable_end;
 
 	memranges_create_hole(&test_memrange, new_cacheable_end, ranges_diff);
 
-	memranges_each_entry(ptr, &test_memrange) {
+	memranges_each_entry(ptr, &test_memrange)
+	{
 		switch (range_entry_tag(ptr)) {
 		case CACHEABLE_TAG:
 			assert_int_equal(range_entry_base(ptr), res_mock[CACHEABLE_TAG].base);
@@ -388,8 +412,9 @@ static void test_memrange_holes(void **state)
 			break;
 		case RESERVED_TAG:
 			assert_int_equal(range_entry_base(ptr), res_mock[RESERVED_TAG].base);
-			assert_int_equal(range_entry_end(ptr), res_mock[RESERVED_TAG].base +
+			assert_int_equal(range_entry_end(ptr),
-								res_mock[RESERVED_TAG].size);
+					 res_mock[RESERVED_TAG].base
+						 + res_mock[RESERVED_TAG].size);
 			break;
 		case HOLE_TAG:
 			assert_int_equal(range_entry_base(ptr), new_hole_begin);
@@ -448,14 +473,15 @@ static void test_memrange_steal(void **state)
 	memranges_add_resources(&test_memrange, reserved, reserved, RESERVED_TAG);
 	memranges_add_resources(&test_memrange, readonly, readonly, READONLY_TAG);
 
-	status = memranges_steal(&test_memrange, res_mock[RESERVED_TAG].base +
+	status = memranges_steal(&test_memrange,
-				 res_mock[RESERVED_TAG].size,
+				 res_mock[RESERVED_TAG].base + res_mock[RESERVED_TAG].size,
 				 stolen_range_size, 12, READONLY_TAG, &stolen);
 	assert_true(status);
-	assert_in_range(stolen, res_mock[READONLY_TAG].base, res_mock[READONLY_TAG].base +
+	assert_in_range(stolen, res_mock[READONLY_TAG].base,
-			res_mock[READONLY_TAG].size);
+			res_mock[READONLY_TAG].base + res_mock[READONLY_TAG].size);
 
-	memranges_each_entry(ptr, &test_memrange) {
+	memranges_each_entry(ptr, &test_memrange)
+	{
 		if (range_entry_tag(ptr) == READONLY_TAG) {
 			assert_int_equal(range_entry_base(ptr),
 					 ALIGN_DOWN(res_mock[READONLY_TAG].base, MEMRANGE_ALIGN)
@@ -469,14 +495,15 @@ static void test_memrange_steal(void **state)
 	/* Check if inserting range in previously stolen area will merge it. */
 	memranges_insert(&test_memrange, res_mock[READONLY_TAG].base + 0xCC, stolen_range_size,
 			 READONLY_TAG);
-	memranges_each_entry(ptr, &test_memrange) {
+	memranges_each_entry(ptr, &test_memrange)
+	{
 		if (range_entry_tag(ptr) == READONLY_TAG) {
-			assert_int_equal(range_entry_base(ptr),
+			assert_int_equal(
-					ALIGN_DOWN(res_mock[READONLY_TAG].base,
+				range_entry_base(ptr),
-						MEMRANGE_ALIGN));
+				ALIGN_DOWN(res_mock[READONLY_TAG].base, MEMRANGE_ALIGN));
-			assert_int_equal(range_entry_end(ptr),
+			assert_int_equal(
-					ALIGN_UP(range_entry_base(ptr) +
+				range_entry_end(ptr),
-						res_mock[READONLY_TAG].size,
+				ALIGN_UP(range_entry_base(ptr) + res_mock[READONLY_TAG].size,
 					 MEMRANGE_ALIGN));
 		}
 		count++;
@@ -494,7 +521,8 @@ static void check_range_entries_count_and_alignment(struct memranges *ranges,
 	size_t count = 0;
 	struct range_entry *ptr;
 
-	memranges_each_entry(ptr, ranges) {
+	memranges_each_entry(ptr, ranges)
+	{
 		assert_true(IS_ALIGNED(range_entry_base(ptr), alignment));
 		assert_true(IS_ALIGNED(range_entry_end(ptr), alignment));
 
@@ -511,7 +539,7 @@ static void test_memrange_init_and_teardown(void **state)
 	const unsigned long reserved = IORESOURCE_RESERVE;
 	const unsigned long readonly = IORESOURCE_READONLY;
 	struct memranges test_memrange;
-	struct range_entry range_entries[4] = { 0 };
+	struct range_entry range_entries[4] = {0};
 
 	/* Test memranges_init() correctness */
 	memranges_init(&test_memrange, cacheable, cacheable, CACHEABLE_TAG);
@@ -527,8 +555,7 @@ static void test_memrange_init_and_teardown(void **state)
 
 
 	/* Test memranges_init_with_alignment() correctness with alignment of 1KiB (2^10) */
-	memranges_init_with_alignment(&test_memrange, cacheable, cacheable,
+	memranges_init_with_alignment(&test_memrange, cacheable, cacheable, CACHEABLE_TAG, 10);
-					CACHEABLE_TAG, 10);
 	memranges_add_resources(&test_memrange, reserved, reserved, RESERVED_TAG);
 	memranges_add_resources(&test_memrange, readonly, readonly, READONLY_TAG);
 
@@ -598,7 +625,8 @@ static void test_memrange_add_resources_filter(void **state)
 				       memrange_filter_mem_only);
 
 	/* Check if filter accepted desired range. */
-	memranges_each_entry(ptr, &test_memrange) {
+	memranges_each_entry(ptr, &test_memrange)
+	{
 		assert_in_set(range_entry_tag(ptr), accepted_tags, ARRAY_SIZE(accepted_tags));
 		assert_true(IS_ALIGNED(range_entry_base(ptr), MEMRANGE_ALIGN));
 		assert_true(IS_ALIGNED(range_entry_end(ptr), MEMRANGE_ALIGN));
@@ -629,10 +657,10 @@ int main(void)
 		cmocka_unit_test(test_memrange_add_resources_filter),
 	};
 
-	return cmocka_run_group_tests_name(__TEST_NAME__"(Boundary on 4GiB)",
+	return cmocka_run_group_tests_name(__TEST_NAME__ "(Boundary on 4GiB)", tests,
-						tests, setup_test_1, NULL) +
+					   setup_test_1, NULL)
-		cmocka_run_group_tests_name(__TEST_NAME__"(Boundaries 1 byte from 4GiB)",
+	       + cmocka_run_group_tests_name(__TEST_NAME__ "(Boundaries 1 byte from 4GiB)",
-						tests, setup_test_2, NULL) +
+					     tests, setup_test_2, NULL)
-		cmocka_run_group_tests_name(__TEST_NAME__"(Range over 4GiB boundary)",
+	       + cmocka_run_group_tests_name(__TEST_NAME__ "(Range over 4GiB boundary)", tests,
-						tests, setup_test_3, NULL);
+					     setup_test_3, NULL);
 }

tests/lib/memset-test.c

@@ -106,14 +106,14 @@ static void test_memset_one_byte(void **state)
 int main(void)
 {
 	const struct CMUnitTest tests[] = {
-		cmocka_unit_test_setup_teardown(test_memset_full_range,
+		cmocka_unit_test_setup_teardown(test_memset_full_range, setup_test,
-				setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memset_subrange,
+		cmocka_unit_test_setup_teardown(test_memset_subrange, setup_test,
-				setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memset_zero_size,
+		cmocka_unit_test_setup_teardown(test_memset_zero_size, setup_test,
-				setup_test, teardown_test),
+						teardown_test),
-		cmocka_unit_test_setup_teardown(test_memset_one_byte,
+		cmocka_unit_test_setup_teardown(test_memset_one_byte, setup_test,
-				setup_test, teardown_test),
+						teardown_test),
 	};
 
 	return cb_run_group_tests(tests, NULL, NULL);

tests/lib/region_file-test.c

@@ -243,12 +243,12 @@ static void test_region_file_update_data_arr(void **state)
 	for (int i = 0; i < dummy_data_size; ++i)
 		dummy_data[i] = 'A' + i % ('Z' - 'A');
 
-	update_entries[0] = (struct update_region_file_entry)
+	update_entries[0] = (struct update_region_file_entry){
-				{ .size = data1_size, .data = &dummy_data[data1_offset] };
+		.size = data1_size, .data = &dummy_data[data1_offset]};
-	update_entries[1] = (struct update_region_file_entry)
+	update_entries[1] = (struct update_region_file_entry){
-				{ .size = data2_size, .data = &dummy_data[data2_offset] };
+		.size = data2_size, .data = &dummy_data[data2_offset]};
-	update_entries[2] = (struct update_region_file_entry)
+	update_entries[2] = (struct update_region_file_entry){
-				{ .size = data3_size, .data = &dummy_data[data3_offset] };
+		.size = data3_size, .data = &dummy_data[data3_offset]};
 
 	ret = region_file_init(&regf, rdev);
 	assert_int_equal(0, ret);
@@ -274,10 +274,9 @@ static void test_region_file_update_data_arr(void **state)
 	ret = rdev_readat(&read_rdev, output_buffer, 0, data1_size + data2_size + data3_size);
 	assert_int_equal(data1_size + data2_size + data3_size, ret);
 	assert_memory_equal(&dummy_data[data1_offset], output_buffer, data1_size);
-	assert_memory_equal(&dummy_data[data2_offset],
+	assert_memory_equal(&dummy_data[data2_offset], &output_buffer[data1_size], data2_size);
-			    &output_buffer[data1_size], data2_size);
+	assert_memory_equal(&dummy_data[data3_offset], &output_buffer[data1_size + data2_size],
-	assert_memory_equal(&dummy_data[data3_offset],
+			    data3_size);
-			    &output_buffer[data1_size + data2_size], data3_size);
 
 	/* Check if data is correctly shrunk down to smaller size and different content */
 	ret = region_file_update_data_arr(&regf, &update_entries[1], 2);

tests/lib/rtc-test.c

@@ -163,37 +163,37 @@ static void test_rtc_mktime_with_rtc_to_tm(void **state)
 
 	/* Conversion from rtc_time to timestamp and back to rtc_time */
 	tm_in = (struct rtc_time){
-		.year = 1970, .mon = 1, .mday = 1, .hour = 0, .min = 0, .sec = 0, .wday = 4
+		.year = 1970, .mon = 1, .mday = 1, .hour = 0, .min = 0, .sec = 0, .wday = 4,
 	};
 	assert_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
 	assert_rtc_time_equal(&tm_in, &tm_out);
 
 	tm_in = (struct rtc_time){
-		.year = 2000, .mon = 2, .mday = 29, .hour = 13, .min = 4, .sec = 15, .wday = 2
+		.year = 2000, .mon = 2, .mday = 29, .hour = 13, .min = 4, .sec = 15, .wday = 2,
 	};
 	assert_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
 	assert_rtc_time_equal(&tm_in, &tm_out);
 
 	tm_in = (struct rtc_time){
-		.year = 2000, .mon = 3, .mday = 1, .hour = 13, .min = 8, .sec = 37, .wday = 3
+		.year = 2000, .mon = 3, .mday = 1, .hour = 13, .min = 8, .sec = 37, .wday = 3,
 	};
 	assert_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
 	assert_rtc_time_equal(&tm_in, &tm_out);
 
 	tm_in = (struct rtc_time){
-		.year = 2017, .mon = 12, .mday = 7, .hour = 8, .min = 18, .sec = 9, .wday = 4
+		.year = 2017, .mon = 12, .mday = 7, .hour = 8, .min = 18, .sec = 9, .wday = 4,
 	};
 	assert_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
 	assert_rtc_time_equal(&tm_in, &tm_out);
 
 	tm_in = (struct rtc_time){
-		.year = 2020, .mon = 2, .mday = 29, .hour = 18, .min = 50, .sec = 0, .wday = 6
+		.year = 2020, .mon = 2, .mday = 29, .hour = 18, .min = 50, .sec = 0, .wday = 6,
 	};
 	assert_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
 	assert_rtc_time_equal(&tm_in, &tm_out);
 
 	tm_in = (struct rtc_time){
-		.year = 2020, .mon = 3, .mday = 1, .hour = 1, .min = 20, .sec = 23, .wday = 0
+		.year = 2020, .mon = 3, .mday = 1, .hour = 1, .min = 20, .sec = 23, .wday = 0,
 	};
 	assert_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
 	assert_rtc_time_equal(&tm_in, &tm_out);
@@ -246,53 +246,53 @@ static void test_leap_day_secday(void **state)
 	memset(&tm_out, 0, sizeof(tm_out));
 
 	/* Non-leap year */
-	tm_in = (struct rtc_time) {
+	tm_in = (struct rtc_time){
-		.year = 1999, .mon = 2, .mday = 28, .hour = 5, .min = 37, .sec = 15, .wday = 0
+		.year = 1999, .mon = 2, .mday = 28, .hour = 5, .min = 37, .sec = 15, .wday = 0,
 	};
 	tim = rtc_mktime(&tm_in) + secday;
-	tm_expected = (struct rtc_time) {
+	tm_expected = (struct rtc_time){
-		.year = 1999, .mon = 3, .mday = 1, .hour = 5, .min = 37, .sec = 15, .wday = 1
+		.year = 1999, .mon = 3, .mday = 1, .hour = 5, .min = 37, .sec = 15, .wday = 1,
 	};
 	assert_int_equal(0, rtc_to_tm(tim, &tm_out));
 	assert_rtc_time_equal(&tm_out, &tm_expected);
 
 	/* Leap-year February 28 to February 29 */
-	tm_in = (struct rtc_time) {
+	tm_in = (struct rtc_time){
 		.year = 2000, .mon = 2, .mday = 28, .hour = 0, .min = 33, .sec = 11, .wday = 1,
 	};
 	tim = rtc_mktime(&tm_in) + secday;
-	tm_expected = (struct rtc_time) {
+	tm_expected = (struct rtc_time){
 		.year = 2000, .mon = 2, .mday = 29, .hour = 0, .min = 33, .sec = 11, .wday = 2,
 	};
 	assert_int_equal(0, rtc_to_tm(tim, &tm_out));
 	assert_rtc_time_equal(&tm_out, &tm_expected);
 
-	tm_in = (struct rtc_time) {
+	tm_in = (struct rtc_time){
 		.year = 2004, .mon = 2, .mday = 28, .hour = 9, .min = 13, .sec = 45, .wday = 6,
 	};
 	tim = rtc_mktime(&tm_in) + secday;
-	tm_expected = (struct rtc_time) {
+	tm_expected = (struct rtc_time){
 		.year = 2004, .mon = 2, .mday = 29, .hour = 9, .min = 13, .sec = 45, .wday = 0,
 	};
 	assert_int_equal(0, rtc_to_tm(tim, &tm_out));
 	assert_rtc_time_equal(&tm_out, &tm_expected);
 
 	/* Leap-year February 29 to March 1 */
-	tm_in = (struct rtc_time) {
+	tm_in = (struct rtc_time){
 		.year = 2000, .mon = 2, .mday = 29, .hour = 22, .min = 50, .sec = 25, .wday = 2,
 	};
 	tim = rtc_mktime(&tm_in) + secday;
-	tm_expected = (struct rtc_time) {
+	tm_expected = (struct rtc_time){
 		.year = 2000, .mon = 3, .mday = 1, .hour = 22, .min = 50, .sec = 25, .wday = 3,
 	};
 	assert_int_equal(0, rtc_to_tm(tim, &tm_out));
 	assert_rtc_time_equal(&tm_out, &tm_expected);
 
-	tm_in = (struct rtc_time) {
+	tm_in = (struct rtc_time){
 		.year = 2004, .mon = 2, .mday = 29, .hour = 17, .min = 56, .sec = 27, .wday = 0,
 	};
 	tim = rtc_mktime(&tm_in) + secday;
-	tm_expected = (struct rtc_time) {
+	tm_expected = (struct rtc_time){
 		.year = 2004, .mon = 3, .mday = 1, .hour = 17, .min = 56, .sec = 27, .wday = 1,
 	};
 	assert_int_equal(0, rtc_to_tm(tim, &tm_out));

tests/lib/spd_cache-test.c

@@ -62,12 +62,10 @@ static void test_load_spd_cache(void **state)
 
 static void calc_spd_cache_crc(uint8_t *spd_cache)
 {
-	*(uint16_t *)(spd_cache + SC_CRC_OFFSET) =
+	*(uint16_t *)(spd_cache + SC_CRC_OFFSET) = CRC(spd_cache, SC_SPD_TOTAL_LEN, crc16_byte);
-			CRC(spd_cache, SC_SPD_TOTAL_LEN, crc16_byte);
 }
 
-__attribute__((unused))
+__attribute__((unused)) static void fill_spd_cache_ddr3(uint8_t *spd_cache, size_t spd_cache_sz)
-static void fill_spd_cache_ddr3(uint8_t *spd_cache, size_t spd_cache_sz)
 {
 	assert_true(spd_cache_sz >= (spd_data_ddr3_1_sz + sizeof(uint16_t)));
 
@@ -76,11 +74,10 @@ static void fill_spd_cache_ddr3(uint8_t *spd_cache, size_t spd_cache_sz)
 	calc_spd_cache_crc(spd_cache);
 }
 
-__attribute__((unused))
+__attribute__((unused)) static void fill_spd_cache_ddr4(uint8_t *spd_cache, size_t spd_cache_sz)
-static void fill_spd_cache_ddr4(uint8_t *spd_cache, size_t spd_cache_sz)
 {
-	assert_true(spd_cache_sz >=
+	assert_true(spd_cache_sz
-			(spd_data_ddr4_1_sz + spd_data_ddr4_2_sz + sizeof(uint16_t)));
+		    >= (spd_data_ddr4_1_sz + spd_data_ddr4_2_sz + sizeof(uint16_t)));
 
 	memcpy(spd_cache, spd_data_ddr4_1, spd_data_ddr4_1_sz);
 	memcpy(spd_cache + spd_data_ddr4_1_sz, spd_data_ddr4_2, spd_data_ddr4_2_sz);
@@ -127,7 +124,7 @@ static void test_spd_cache_is_valid(void **state)
 
 
 /* Used for setting `sn` parameter value */
-static u32 get_spd_sn_ret_sn[SC_SPD_NUMS] = { 0 };
+static u32 get_spd_sn_ret_sn[SC_SPD_NUMS] = {0};
 static size_t get_spd_sn_ret_sn_idx = 0;
 /* Implementation for testing purposes.  */
 enum cb_err get_spd_sn(u8 addr, u32 *sn)
@@ -145,12 +142,11 @@ static void get_sn_from_spd_cache(uint8_t *spd_cache, u32 arr[])
 }
 
 /* check_if_dimm_changed() has is used only with DDR4, so there tests are not used for DDR3 */
-__attribute__((unused))
+__attribute__((unused)) static void test_check_if_dimm_changed_not_changed(void **state)
-static void test_check_if_dimm_changed_not_changed(void **state)
 {
 	uint8_t *spd_cache;
 	size_t spd_cache_sz;
-	struct spd_block blk = { .addr_map = {0}, .spd_array = {0}, .len = 0 };
+	struct spd_block blk = {.addr_map = {0}, .spd_array = {0}, .len = 0};
 
 	assert_int_equal(CB_SUCCESS, load_spd_cache(&spd_cache, &spd_cache_sz));
 	fill_spd_cache_ddr4(spd_cache, spd_cache_sz);
@@ -162,12 +158,11 @@ static void test_check_if_dimm_changed_not_changed(void **state)
 	assert_false(check_if_dimm_changed(spd_cache, &blk));
 }
 
-__attribute__((unused))
+__attribute__((unused)) static void test_check_if_dimm_changed_sn_error(void **state)
-static void test_check_if_dimm_changed_sn_error(void **state)
 {
 	uint8_t *spd_cache;
 	size_t spd_cache_sz;
-	struct spd_block blk = { .addr_map = {0}, .spd_array = {0}, .len = 0 };
+	struct spd_block blk = {.addr_map = {0}, .spd_array = {0}, .len = 0};
 
 	assert_int_equal(CB_SUCCESS, load_spd_cache(&spd_cache, &spd_cache_sz));
 	fill_spd_cache_ddr4(spd_cache, spd_cache_sz);
@@ -178,12 +173,11 @@ static void test_check_if_dimm_changed_sn_error(void **state)
 	assert_true(check_if_dimm_changed(spd_cache, &blk));
 }
 
-__attribute__((unused))
+__attribute__((unused)) static void test_check_if_dimm_changed_sodimm_lost(void **state)
-static void test_check_if_dimm_changed_sodimm_lost(void **state)
 {
 	uint8_t *spd_cache;
 	size_t spd_cache_sz;
-	struct spd_block blk = { .addr_map = {0}, .spd_array = {0}, .len = 0 };
+	struct spd_block blk = {.addr_map = {0}, .spd_array = {0}, .len = 0};
 
 	assert_int_equal(CB_SUCCESS, load_spd_cache(&spd_cache, &spd_cache_sz));
 	fill_spd_cache_ddr4(spd_cache, spd_cache_sz);
@@ -196,31 +190,29 @@ static void test_check_if_dimm_changed_sodimm_lost(void **state)
 	assert_true(check_if_dimm_changed(spd_cache, &blk));
 }
 
-__attribute__((unused))
+__attribute__((unused)) static void test_check_if_dimm_changed_new_sodimm(void **state)
-static void test_check_if_dimm_changed_new_sodimm(void **state)
 {
 	uint8_t *spd_cache;
 	size_t spd_cache_sz;
-	struct spd_block blk = { .addr_map = {0}, .spd_array = {0}, .len = 0 };
+	struct spd_block blk = {.addr_map = {0}, .spd_array = {0}, .len = 0};
 
 	assert_int_equal(CB_SUCCESS, load_spd_cache(&spd_cache, &spd_cache_sz));
 	fill_spd_cache_ddr4(spd_cache, spd_cache_sz);
 	assert_int_equal(CB_SUCCESS, spd_fill_from_cache(spd_cache, &blk));
 	get_sn_from_spd_cache(spd_cache, get_spd_sn_ret_sn);
-	memcpy(spd_cache + spd_data_ddr4_1_sz + spd_data_ddr4_2_sz,
+	memcpy(spd_cache + spd_data_ddr4_1_sz + spd_data_ddr4_2_sz, spd_data_ddr4_2,
-			spd_data_ddr4_2, spd_data_ddr4_2_sz);
+	       spd_data_ddr4_2_sz);
 
 	get_spd_sn_ret_sn_idx = 0;
 	will_return_always(get_spd_sn, CB_SUCCESS);
 	assert_true(check_if_dimm_changed(spd_cache, &blk));
 }
 
-__attribute__((unused))
+__attribute__((unused)) static void test_check_if_dimm_changed_sn_changed(void **state)
-static void test_check_if_dimm_changed_sn_changed(void **state)
 {
 	uint8_t *spd_cache;
 	size_t spd_cache_sz;
-	struct spd_block blk = { .addr_map = {0}, .spd_array = {0}, .len = 0 };
+	struct spd_block blk = {.addr_map = {0}, .spd_array = {0}, .len = 0};
 
 	assert_int_equal(CB_SUCCESS, load_spd_cache(&spd_cache, &spd_cache_sz));
 	fill_spd_cache_ddr4(spd_cache, spd_cache_sz);

tests/lib/stack-test.c

@@ -6,9 +6,9 @@
 
 
 #if CONFIG_STACK_SIZE == 0
-# define STACK_SIZE 0x1000
+#define STACK_SIZE 0x1000
 #else
-# define STACK_SIZE CONFIG_STACK_SIZE
+#define STACK_SIZE CONFIG_STACK_SIZE
 #endif
 
 /* Value used for stack initialization. Change if implementation changes. */

tests/lib/timestamp-test.c

@@ -43,8 +43,7 @@ void test_timestamp_add(void **state)
 	for (i = 0; i < 10; ++i) {
 		entry = &glob_ts_table->entries[i];
 		assert_int_equal(i + 1, entry->entry_id);
-		assert_int_equal(base_multipler * (i + 1) - timestamp_base,
+		assert_int_equal(base_multipler * (i + 1) - timestamp_base, entry->entry_stamp);
-				 entry->entry_stamp);
 	}
 }
 

tests/mock/cbfs_file_mock.c

@@ -4,14 +4,14 @@
 
 TEST_REGION(cbfs_cache, TEST_CBFS_CACHE_SIZE);
 
-const u8 test_data_1[TEST_DATA_1_SIZE] = { TEST_DATA_1 };
+const u8 test_data_1[TEST_DATA_1_SIZE] = {TEST_DATA_1};
-const u8 test_data_2[TEST_DATA_2_SIZE] = { TEST_DATA_2 };
+const u8 test_data_2[TEST_DATA_2_SIZE] = {TEST_DATA_2};
-const u8 test_data_int_1[TEST_DATA_INT_1_SIZE] = { LE64(TEST_DATA_INT_1) };
+const u8 test_data_int_1[TEST_DATA_INT_1_SIZE] = {LE64(TEST_DATA_INT_1)};
-const u8 test_data_int_2[TEST_DATA_INT_2_SIZE] = { LE64(TEST_DATA_INT_2) };
+const u8 test_data_int_2[TEST_DATA_INT_2_SIZE] = {LE64(TEST_DATA_INT_2)};
-const u8 test_data_int_3[TEST_DATA_INT_3_SIZE] = { LE64(TEST_DATA_INT_3) };
+const u8 test_data_int_3[TEST_DATA_INT_3_SIZE] = {LE64(TEST_DATA_INT_3)};
 
-const u8 good_hash[VB2_SHA256_DIGEST_SIZE] = { TEST_SHA256 };
+const u8 good_hash[VB2_SHA256_DIGEST_SIZE] = {TEST_SHA256};
-const u8 bad_hash[VB2_SHA256_DIGEST_SIZE] = { INVALID_SHA256 };
+const u8 bad_hash[VB2_SHA256_DIGEST_SIZE] = {INVALID_SHA256};
 
 const struct cbfs_test_file file_no_hash = {
 	.header = HEADER_INITIALIZER(CBFS_TYPE_RAW, 0, TEST_DATA_1_SIZE),