GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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>
This commit is contained in:
Jakub Czapiga 2022-01-10 13:36:47 +00:00 committed by Felix Held
parent 63ec2ac97a
commit c08b6a7037
31 changed files with 1225 additions and 1228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
tests/acpi/acpigen-test.c
View File

@ -203,14 +203,14 @@ static void test_acpigen_scope_with_contents(void **state)
int main(void) int main(void)
{ {
const struct CMUnitTest tests[] = { 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); return cb_run_group_tests(tests, NULL, NULL);

8
tests/commonlib/region-test.c
View File

@ -58,8 +58,8 @@ static int mock_unmap(const struct region_device *rdev, void *mapping)
return mock(); 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(rdev);
check_expected_ptr(buffer); check_expected_ptr(buffer);
@ -73,8 +73,8 @@ static ssize_t mock_readat(const struct region_device *rdev, void *buffer,
return ret; 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(rdev);
check_expected_ptr(buffer); check_expected_ptr(buffer);

3
tests/console/routing-test.c
View File

@ -61,8 +61,7 @@ static int teardown_console_log_level(void **state)
int main(void) int main(void)
{ {
const struct CMUnitTest tests[] = { 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), teardown_console_log_level),
}; };

4
tests/device/ddr4-test.c
View File

@ -33,9 +33,7 @@ static void ddr4_speed_mhz_to_mts_test(void **state)
int main(void) 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); return cb_run_group_tests(tests, NULL, NULL);
} }

72
tests/device/i2c-test.c
View File

@ -18,20 +18,27 @@ typedef struct {
} i2c_ex_devs_t; } i2c_ex_devs_t;
i2c_ex_devs_t i2c_ex_devs[] = { i2c_ex_devs_t i2c_ex_devs[] = {
{.bus = 0, .slave = 0xA, .regs = { {
.bus = 0,
.slave = 0xA,
.regs = {
{.reg = 0x0, .data = 0xB}, {.reg = 0x0, .data = 0xB},
{.reg = 0x1, .data = 0x6}, {.reg = 0x1, .data = 0x6},
{.reg = 0x2, .data = 0xF}, {.reg = 0x2, .data = 0xF},
} }, }
{.bus = 0, .slave = 0x3, .regs = { },
{
.bus = 0,
.slave = 0x3,
.regs = {
{.reg = 0x0, .data = 0xDE}, {.reg = 0x0, .data = 0xDE},
{.reg = 0x1, .data = 0xAD}, {.reg = 0x1, .data = 0xAD},
{.reg = 0x2, .data = 0xBE}, {.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 i;
int reg; 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) 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 */ /* 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 #define MASK 0x3
@ -101,21 +105,17 @@ static void i2c_read_field_test(void **state)
with expected value. */ with expected value. */
for (i = 0; i < ARRAY_SIZE(i2c_ex_devs); i++) for (i = 0; i < ARRAY_SIZE(i2c_ex_devs); i++)
for (j = 0; j < ARRAY_SIZE(i2c_ex_devs[0].regs); j++) { 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 */ /* Read whole registers */
for (i = 0; i < ARRAY_SIZE(i2c_ex_devs); i++) for (i = 0; i < ARRAY_SIZE(i2c_ex_devs); i++)
for (j = 0; j < ARRAY_SIZE(i2c_ex_devs[0].regs); j++) { 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); 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++) { for (j = 0; j < ARRAY_SIZE(i2c_ex_devs[0].regs); j++) {
buf = 0x0; buf = 0x0;
tmp = i2c_ex_devs[i].regs[j].data; 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, assert_int_equal(i2c_ex_devs[i].regs[j].data,
(tmp & ~(MASK << SHIFT)) | (buf << SHIFT)); (tmp & ~(MASK << SHIFT)) | (buf << SHIFT));
}; };
@ -145,24 +143,18 @@ static void i2c_write_field_test(void **state)
i2c_read_field() accessor. */ i2c_read_field() accessor. */
for (i = 0; i < ARRAY_SIZE(i2c_ex_devs); i++) for (i = 0; i < ARRAY_SIZE(i2c_ex_devs); i++)
for (j = 0; j < ARRAY_SIZE(i2c_ex_devs[0].regs); j++) { 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); assert_int_equal(buf, 0xFF);
}; };
} }
int main(void) 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); return cb_run_group_tests(tests, NULL, NULL);
} }

37
tests/include/tests/lib/edid.h
View File

@ -46,11 +46,16 @@ struct edid_raw {
uint8_t checksum; uint8_t checksum;
} __packed; } __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_ID 0xcb55
#define EDID_MANUFACTURER_NAME "UNK" #define EDID_MANUFACTURER_NAME "UNK"
@ -178,25 +183,15 @@ _Static_assert(sizeof(struct edid_raw) == 128,
#define EDID_PIXEL_CLOCK(v) (((v) / 10000) & 0xFFFF) #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, \ .manufacture_year = EDID_MANUFACTURE_YEAR, \
.color_characteristics = { \ .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 */ #endif /* TESTS_LIB_EDID_H */

20
tests/lib/cbfs-lookup-test.c
View File

@ -12,8 +12,8 @@
static struct cbfs_boot_device cbd; 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 u8 *unaligned_cbfs_buffer = &aligned_cbfs_buffer[3];
static uintptr_t unaligned_cbfs_buffer_size = sizeof(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; size_t size_out;
struct cbfs_test_state *s = *state; struct cbfs_test_state *s = *state;
const struct cbfs_test_file *cbfs_files[] = { 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], assert_int_equal(0, create_cbfs(cbfs_files, ARRAY_SIZE(cbfs_files), &s->cbfs_buf[5],
s->cbfs_size - 5)); s->cbfs_size - 5));
@ -663,8 +664,9 @@ static void test_cbfs_two_files_with_same_name(void **state)
size_out = 0; size_out = 0;
expect_lookup_result(CB_SUCCESS); expect_lookup_result(CB_SUCCESS);
mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); 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)); 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); assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0);
memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2)); memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2));
f = (struct cbfs_test_file *)s->cbfs_buf; 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)); + sizeof(struct cbfs_file_attr_compression));
f->header.offset = cpu_to_be32(sizeof(struct cbfs_file) + FILENAME_SIZE); 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( \ EMPTY_WRAP( \
CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST( \ CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST( \
("aligned, " name), (test_fn), setup_test_cbfs_aligned, (prestate)), \ ("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) #define CBFS_LOOKUP_TEST(test_fn) CBFS_LOOKUP_NAME_PRESTATE_TEST(#test_fn, test_fn, NULL)

21
tests/lib/cbmem_console-test.c
View File

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

16
tests/lib/cbmem_stage_cache-test.c
View File

@ -180,14 +180,14 @@ void test_stage_cache_load_stage(void **state)
int main(void) int main(void)
{ {
const struct CMUnitTest tests[] = { 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); return cb_run_group_tests(tests, NULL, NULL);

9
tests/lib/compute_ip_checksum-test.c
View File

@ -7,12 +7,9 @@
#include <ip_checksum.h> #include <ip_checksum.h>
static const uint8_t test_data_simple[] = { 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 size_t test_data_simple_sz = ARRAY_SIZE(test_data_simple);
static const unsigned long test_data_simple_checksum = 0x4267; static const unsigned long test_data_simple_checksum = 0x4267;

62
tests/lib/coreboot_table-test.c
View File

@ -44,10 +44,9 @@ static struct lb_record *lb_first_record(struct lb_header *header)
} }
#define LB_RECORD_FOR_EACH(record_ptr, index, 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) 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)]; + 2 * sizeof(struct lb_forward)];
struct lb_header *forward_header = struct lb_header *forward_header =
(struct lb_header *)ALIGN_UP((uintptr_t)forwarding_table_buffer, 16); (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(expected_forwarding_table_size, forwarding_table_size);
assert_int_equal(1, forward_header->table_entries); assert_int_equal(1, forward_header->table_entries);
@ -346,7 +343,8 @@ static void test_write_tables(void **state)
/* At least one entry should be present. */ /* At least one entry should be present. */
assert_int_not_equal(0, header->table_entries); 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) { switch (record->tag) {
case LB_TAG_MEMORY: case LB_TAG_MEMORY:
/* Should be the same as in bootmem_write_memory_table() */ /* 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: case LB_TAG_MAINBOARD:
/* Mainboard record contains its header followed /* Mainboard record contains its header followed
by two null-terminated strings */ 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; break;
case LB_TAG_VERSION: case LB_TAG_VERSION:
assert_int_equal(ALIGN_UP(sizeof(struct lb_string) assert_int_equal(ALIGN_UP(sizeof(struct lb_string)
+ ARRAY_SIZE(coreboot_version), 8), record->size); + ARRAY_SIZE(coreboot_version),
8),
record->size);
break; break;
case LB_TAG_EXTRA_VERSION: case LB_TAG_EXTRA_VERSION:
assert_int_equal(ALIGN_UP(sizeof(struct lb_string) assert_int_equal(ALIGN_UP(sizeof(struct lb_string)
+ ARRAY_SIZE(coreboot_extra_version), 8), + ARRAY_SIZE(coreboot_extra_version),
8),
record->size); record->size);
break; break;
case LB_TAG_BUILD: 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); record->size);
break; break;
case LB_TAG_COMPILE_TIME: case LB_TAG_COMPILE_TIME:
assert_int_equal(ALIGN_UP(sizeof(struct lb_string) assert_int_equal(ALIGN_UP(sizeof(struct lb_string)
+ ARRAY_SIZE(coreboot_compile_time), 8), + ARRAY_SIZE(coreboot_compile_time),
8),
record->size); record->size);
break; break;
case LB_TAG_SERIAL: case LB_TAG_SERIAL:
@ -442,12 +447,10 @@ static void test_write_tables(void **state)
const struct lb_cbmem_entry *cbmem_entry = const struct lb_cbmem_entry *cbmem_entry =
(struct lb_cbmem_entry *)record; (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; break;
case LB_TAG_TSC_INFO: case LB_TAG_TSC_INFO:
assert_int_equal(sizeof(struct lb_tsc_info), record->size); 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 = const struct lb_board_config *board_config =
(struct lb_board_config *)record; (struct lb_board_config *)record;
const struct lb_uint64 expected_fw_version = pack_lb64(fw_config_get()); 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(board_id(), board_config->board_id);
assert_int_equal(ram_code(), board_config->ram_code); assert_int_equal(ram_code(), board_config->ram_code);
assert_int_equal(sku_id(), board_config->sku_id); 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_lb_add_console, setup_test_header),
cmocka_unit_test_setup(test_multiple_entries, 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(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), teardown_write_tables_test),
}; };

54
tests/lib/crc_byte-test.c
View File

@ -4,38 +4,25 @@
#include <crc_byte.h> #include <crc_byte.h>
static const uint8_t test_data_bytes[] = { 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 size_t test_data_bytes_sz = ARRAY_SIZE(test_data_bytes);
static const uint8_t test_data_crc7_checksum = 0x30; 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 /* Calculating CRC of data with its CRC should yield zero if data
and/or checksum is correct */ 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)); test_data_crc16_checksum & 0xFF));
} }

52
tests/lib/dimm_info_util-test.c
View File

@ -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) static void test_smbios_bus_width_to_spd_width(void **state)
{ {
smbios_memory_type memory_type[] = { 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++) { 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) static void test_smbios_form_factor_to_spd_mod_type_ddr(smbios_memory_type memory_type)
{ {
const smbios_memory_form_factor undefined_factors[] = { 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, MEMORY_FORMFACTOR_DIE,
}; };
for (int i = 0; i < ARRAY_SIZE(undefined_factors); ++i) { 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( 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); 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), assert_in_set(smbios_form_factor_to_spd_mod_type(memory_type, MEMORY_FORMFACTOR_RIMM),
rdimm_allowed, MAX_ALLOWED_MODULE_TYPE); 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); 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); print_message("%s(%d)\n", __func__, memory_type);
/* Form factors defined in coreboot */ /* 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) static void test_smbios_form_factor_to_spd_mod_type(void **state)
@ -168,12 +154,10 @@ static void test_smbios_form_factor_to_spd_mod_type(void **state)
.rdimm_allowed = {DDR4_SPD_RDIMM, DDR4_SPD_MINI_RDIMM}, .rdimm_allowed = {DDR4_SPD_RDIMM, DDR4_SPD_MINI_RDIMM},
.expected_module_type = DDR4_SPD_SODIMM, .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 */ /* Test for DDRx DIMM Modules */

865
tests/lib/edid-test.c
View File

File diff suppressed because it is too large Load Diff

27
tests/lib/fmap-test.c
View File

@ -272,8 +272,8 @@ static void test_fmap_overwrite_area(void **state)
assert_memory_equal(buffer2 + (section_size / 2), zero_buffer, section_size / 2); assert_memory_equal(buffer2 + (section_size / 2), zero_buffer, section_size / 2);
/* Expect error when overwriting incorrect section */ /* 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)); assert_int_equal(-1, fmap_overwrite_area(NULL, new_data, section_size / 2));
/* Function fmap_overwrite_area is not tested with NULL /* Function fmap_overwrite_area is not tested with NULL
@ -288,18 +288,17 @@ static void test_fmap_overwrite_area(void **state)
int main(void) int main(void)
{ {
const struct CMUnitTest tests[] = { 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); return cb_run_group_tests(tests, NULL, NULL);

29
tests/lib/imd-test.c
View File

@ -12,8 +12,9 @@
/* Auxiliary functions and definitions. */ /* 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_ALIGN (2 * sizeof(int32_t))
#define LG_ENTRY_SIZE (2 * sizeof(int32_t)) #define LG_ENTRY_SIZE (2 * sizeof(int32_t))
#define LG_ENTRY_ID 0xA001 #define LG_ENTRY_ID 0xA001
@ -122,9 +123,8 @@ static void test_imd_create_empty(void **state)
imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base)); imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base));
/* Try incorrect sizes */ /* 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)); assert_int_equal(-1, imd_create_empty(&imd, LG_ROOT_SIZE, 2 * LG_ROOT_SIZE));
/* Working case */ /* Working case */
@ -174,12 +174,10 @@ static void test_imd_create_tiered_empty(void **state)
sizeof(int32_t), 2 * sizeof(int32_t))); sizeof(int32_t), 2 * sizeof(int32_t)));
/* Fail when large region doesn't have capacity for more than 1 entry */ /* 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, assert_int_equal(0, imd_create_tiered_empty(&imd, LG_ROOT_SIZE, LG_ENTRY_ALIGN,
SM_ROOT_SIZE, SM_ENTRY_ALIGN)); SM_ROOT_SIZE, SM_ENTRY_ALIGN));
@ -327,8 +325,8 @@ static void test_imd_limit_size(void **state)
struct imd imd = {0}; struct imd imd = {0};
size_t root_size, max_size; 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)); 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"); fail_msg("Cannot allocate enough memory - fail test");
imd_handle_init(&imd, (void *)(LIMIT_ALIGN + (uintptr_t)base)); 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.lg.r = (void *)imd.lg.limit - root_size;
imd_create_empty(&imd, root_size, LG_ENTRY_ALIGN); imd_create_empty(&imd, root_size, LG_ENTRY_ALIGN);
@ -761,4 +759,3 @@ int main(void)
return cb_run_group_tests(tests, NULL, NULL); return cb_run_group_tests(tests, NULL, NULL);
} }

3
tests/lib/imd_cbmem-test.c
View File

@ -447,8 +447,7 @@ static void test_cbmem_entry_start(void **state)
} }
/* Reimplementation for testing purposes */ /* 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(start);
check_expected(size); check_expected(size);

14
tests/lib/lzma-test.c
View File

@ -51,12 +51,12 @@ static int setup_ulzman_file(void **state)
if (!s) if (!s)
return 1; 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); 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); s->comp_filename = test_malloc(comp_filename_size);
if (!s->raw_filename || !s->comp_filename) { if (!s->raw_filename || !s->comp_filename) {
@ -150,10 +150,8 @@ static void test_ulzman_zero_buffer(void **state)
#define ULZMAN_CORRECT_FILE_TEST(_file_prefix) \ #define ULZMAN_CORRECT_FILE_TEST(_file_prefix) \
{ \ { \
.name = "test_ulzman_correct_file(" _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) int main(void)

52
tests/lib/memchr-test.c
View File

@ -8,39 +8,25 @@ static const char test_data1[] =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
static const size_t test_data1_sz = sizeof(test_data1); static const size_t test_data1_sz = sizeof(test_data1);
static const char test_data2[] = { 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 const size_t test_data2_sz = sizeof(test_data2);
static void test_memchr_existing_value(void **state) static void test_memchr_existing_value(void **state)

20
tests/lib/memcpy-test.c
View File

@ -178,16 +178,16 @@ static void test_memcpy_copy_part_of_itself_to_itself(void **state)
int main(void) int main(void)
{ {
const struct CMUnitTest tests[] = { 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, cmocka_unit_test_setup_teardown(test_memcpy_copy_part_of_itself_to_itself,
setup_test, teardown_test), setup_test, teardown_test),
}; };

29
tests/lib/memmove-test.c
View File

@ -225,26 +225,25 @@ static void test_memmove_self_lower_to_higher_unaligned(void **state)
int main(void) int main(void)
{ {
const struct CMUnitTest tests[] = { 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, cmocka_unit_test_setup_teardown(test_memmove_self_higher_to_lower_unaligned,
setup_test, teardown_test), 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, cmocka_unit_test_setup_teardown(test_memmove_self_lower_to_higher_unaligned,
setup_test, teardown_test), setup_test, teardown_test),
}; };
return cb_run_group_tests(tests, NULL, NULL); return cb_run_group_tests(tests, NULL, NULL);
} }

158
tests/lib/memrange-test.c
View File

@ -22,31 +22,49 @@ enum mem_types {
/* Indices of entries matters, since it must reflect mem_types enum */ /* Indices of entries matters, since it must reflect mem_types enum */
struct resource res_mock_1[] = { 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,
.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} .flags = IORESOURCE_READONLY | IORESOURCE_MEM}
}; };
/* Boundary 1 byte below 4GiB and 1 byte above 4GiB. */ /* Boundary 1 byte below 4GiB and 1 byte above 4GiB. */
struct resource res_mock_2[] = { 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} .flags = IORESOURCE_READONLY | IORESOURCE_MEM}
}; };
/* Boundary crossing 4GiB. */ /* Boundary crossing 4GiB. */
struct resource res_mock_3[] = { 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} .flags = IORESOURCE_READONLY | IORESOURCE_MEM}
}; };
@ -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 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); 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 /* There should be two entries, since cacheable and
reserved regions are not neighbors */ 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_in_range(range_entry_tag(ptr), CACHEABLE_TAG, RESERVED_TAG);
assert_int_equal(range_entry_base(ptr), get_aligned_base(res_mock, ptr)); 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 */ /* Remove initial memrange */
memranges_teardown(&test_memrange); memranges_teardown(&test_memrange);
memranges_each_entry(ptr, &test_memrange) memranges_each_entry(ptr, &test_memrange) counter++;
counter++;
assert_int_equal(counter, 0); assert_int_equal(counter, 0);
} }
@ -205,7 +222,8 @@ static void test_memrange_clone_insert(void **state)
memranges_teardown(&test_memrange); memranges_teardown(&test_memrange);
/* Verify that new one is really a clone */ /* 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_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)); 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); res_mock[CACHEABLE_TAG].size, INSERTED_TAG);
/* Three ranges should be there - CACHEABLE(shrunk), INSERTED and RESERVED */ /* 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; resource_t expected_end;
if (range_entry_tag(ptr) == CACHEABLE_TAG) { 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), assert_int_equal(range_entry_base(ptr),
res_mock[CACHEABLE_TAG].base + new_range_begin_offset); 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), assert_int_equal(range_entry_end(ptr),
ALIGN_UP(expected_end, MEMRANGE_ALIGN)); ALIGN_UP(expected_end, MEMRANGE_ALIGN));
} }
@ -248,7 +267,8 @@ static void test_memrange_clone_insert(void **state)
* Additionally verify API for updating tags */ * Additionally verify API for updating tags */
memranges_update_tag(&clone_memrange, INSERTED_TAG, READONLY_TAG); 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; resource_t expected_end;
assert_int_not_equal(range_entry_tag(ptr), INSERTED_TAG); 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), assert_int_equal(range_entry_base(ptr),
res_mock[CACHEABLE_TAG].base + new_range_begin_offset); 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), assert_int_equal(range_entry_end(ptr),
ALIGN_UP(expected_end, MEMRANGE_ALIGN)); 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, memranges_insert(&clone_memrange, res_mock[RESERVED_TAG].base + 0xAD,
res_mock[RESERVED_TAG].size, INSERTED_TAG); res_mock[RESERVED_TAG].size, INSERTED_TAG);
memranges_each_entry(ptr, &clone_memrange) { memranges_each_entry(ptr, &clone_memrange)
{
resource_t expected_end; resource_t expected_end;
assert_int_not_equal(range_entry_tag(ptr), RESERVED_TAG); assert_int_not_equal(range_entry_tag(ptr), RESERVED_TAG);
if (range_entry_tag(ptr) == INSERTED_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); expected_end = ALIGN_UP(expected_end, MEMRANGE_ALIGN);
assert_int_equal(range_entry_end(ptr), expected_end); 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); memranges_add_resources(&test_memrange, reserved, reserved, RESERVED_TAG);
/* Count holes in ranges */ /* Count holes in ranges */
memranges_each_entry(ptr, &test_memrange) { memranges_each_entry(ptr, &test_memrange)
{
if (!last_range_end) { if (!last_range_end) {
last_range_end = range_entry_end(ptr); last_range_end = range_entry_end(ptr);
continue; continue;
@ -349,11 +371,12 @@ static void test_memrange_holes(void **state)
(but with different tags) */ (but with different tags) */
memranges_fill_holes_up_to(&test_memrange, holes_fill_end, HOLE_TAG); 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) { if (range_entry_tag(ptr) == HOLE_TAG) {
assert_int_equal(range_entry_base(ptr), 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)); MEMRANGE_ALIGN));
assert_int_equal(range_entry_end(ptr), holes_fill_end); assert_int_equal(range_entry_end(ptr), holes_fill_end);
/* Store pointer to HOLE_TAG region for future use */ /* 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( const resource_t new_cacheable_end = ALIGN_DOWN(
res_mock[CACHEABLE_TAG].base + res_mock[CACHEABLE_TAG].size - 4 * KiB, res_mock[CACHEABLE_TAG].base + res_mock[CACHEABLE_TAG].size - 4 * KiB,
MEMRANGE_ALIGN); 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; const resource_t ranges_diff = new_hole_begin - new_cacheable_end;
memranges_create_hole(&test_memrange, new_cacheable_end, ranges_diff); 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)) { switch (range_entry_tag(ptr)) {
case CACHEABLE_TAG: case CACHEABLE_TAG:
assert_int_equal(range_entry_base(ptr), res_mock[CACHEABLE_TAG].base); assert_int_equal(range_entry_base(ptr), res_mock[CACHEABLE_TAG].base);
@ -388,8 +412,9 @@ static void test_memrange_holes(void **state)
break; break;
case RESERVED_TAG: case RESERVED_TAG:
assert_int_equal(range_entry_base(ptr), res_mock[RESERVED_TAG].base); 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; break;
case HOLE_TAG: case HOLE_TAG:
assert_int_equal(range_entry_base(ptr), new_hole_begin); 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, reserved, reserved, RESERVED_TAG);
memranges_add_resources(&test_memrange, readonly, readonly, READONLY_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); stolen_range_size, 12, READONLY_TAG, &stolen);
assert_true(status); 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) { if (range_entry_tag(ptr) == READONLY_TAG) {
assert_int_equal(range_entry_base(ptr), assert_int_equal(range_entry_base(ptr),
ALIGN_DOWN(res_mock[READONLY_TAG].base, MEMRANGE_ALIGN) 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. */ /* Check if inserting range in previously stolen area will merge it. */
memranges_insert(&test_memrange, res_mock[READONLY_TAG].base + 0xCC, stolen_range_size, memranges_insert(&test_memrange, res_mock[READONLY_TAG].base + 0xCC, stolen_range_size,
READONLY_TAG); READONLY_TAG);
memranges_each_entry(ptr, &test_memrange) { memranges_each_entry(ptr, &test_memrange)
{
if (range_entry_tag(ptr) == READONLY_TAG) { 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)); MEMRANGE_ALIGN));
} }
count++; count++;
@ -494,7 +521,8 @@ static void check_range_entries_count_and_alignment(struct memranges *ranges,
size_t count = 0; size_t count = 0;
struct range_entry *ptr; 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_base(ptr), alignment));
assert_true(IS_ALIGNED(range_entry_end(ptr), alignment)); assert_true(IS_ALIGNED(range_entry_end(ptr), alignment));
@ -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) */ /* 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, reserved, reserved, RESERVED_TAG);
memranges_add_resources(&test_memrange, readonly, readonly, READONLY_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); memrange_filter_mem_only);
/* Check if filter accepted desired range. */ /* 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_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_base(ptr), MEMRANGE_ALIGN));
assert_true(IS_ALIGNED(range_entry_end(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), 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);
} }

16
tests/lib/memset-test.c
View File

@ -106,14 +106,14 @@ static void test_memset_one_byte(void **state)
int main(void) int main(void)
{ {
const struct CMUnitTest tests[] = { 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); return cb_run_group_tests(tests, NULL, NULL);

19
tests/lib/region_file-test.c
View File

@ -243,12 +243,12 @@ static void test_region_file_update_data_arr(void **state)
for (int i = 0; i < dummy_data_size; ++i) for (int i = 0; i < dummy_data_size; ++i)
dummy_data[i] = 'A' + i % ('Z' - 'A'); 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); ret = region_file_init(&regf, rdev);
assert_int_equal(0, ret); 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); 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_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[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 */ /* Check if data is correctly shrunk down to smaller size and different content */
ret = region_file_update_data_arr(&regf, &update_entries[1], 2); ret = region_file_update_data_arr(&regf, &update_entries[1], 2);

16
tests/lib/rtc-test.c
View File

@ -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 */ /* Conversion from rtc_time to timestamp and back to rtc_time */
tm_in = (struct 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_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
assert_rtc_time_equal(&tm_in, &tm_out); assert_rtc_time_equal(&tm_in, &tm_out);
tm_in = (struct rtc_time){ 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_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
assert_rtc_time_equal(&tm_in, &tm_out); assert_rtc_time_equal(&tm_in, &tm_out);
tm_in = (struct rtc_time){ 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_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
assert_rtc_time_equal(&tm_in, &tm_out); assert_rtc_time_equal(&tm_in, &tm_out);
tm_in = (struct rtc_time){ 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_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
assert_rtc_time_equal(&tm_in, &tm_out); assert_rtc_time_equal(&tm_in, &tm_out);
tm_in = (struct rtc_time){ 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_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
assert_rtc_time_equal(&tm_in, &tm_out); assert_rtc_time_equal(&tm_in, &tm_out);
tm_in = (struct rtc_time){ 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_int_equal(0, rtc_to_tm(rtc_mktime(&tm_in), &tm_out));
assert_rtc_time_equal(&tm_in, &tm_out); assert_rtc_time_equal(&tm_in, &tm_out);
@ -247,11 +247,11 @@ static void test_leap_day_secday(void **state)
/* Non-leap year */ /* 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; 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_int_equal(0, rtc_to_tm(tim, &tm_out));
assert_rtc_time_equal(&tm_out, &tm_expected); assert_rtc_time_equal(&tm_out, &tm_expected);

32
tests/lib/spd_cache-test.c
View File

@ -62,12 +62,10 @@ static void test_load_spd_cache(void **state)
static void calc_spd_cache_crc(uint8_t *spd_cache) 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))); 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); 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, spd_data_ddr4_1_sz);
memcpy(spd_cache + spd_data_ddr4_1_sz, spd_data_ddr4_2, spd_data_ddr4_2_sz); memcpy(spd_cache + spd_data_ddr4_1_sz, spd_data_ddr4_2, spd_data_ddr4_2_sz);
@ -145,8 +142,7 @@ 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 */ /* 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; uint8_t *spd_cache;
size_t spd_cache_sz; size_t spd_cache_sz;
@ -162,8 +158,7 @@ static void test_check_if_dimm_changed_not_changed(void **state)
assert_false(check_if_dimm_changed(spd_cache, &blk)); 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; uint8_t *spd_cache;
size_t spd_cache_sz; size_t spd_cache_sz;
@ -178,8 +173,7 @@ static void test_check_if_dimm_changed_sn_error(void **state)
assert_true(check_if_dimm_changed(spd_cache, &blk)); 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; uint8_t *spd_cache;
size_t spd_cache_sz; size_t spd_cache_sz;
@ -196,8 +190,7 @@ static void test_check_if_dimm_changed_sodimm_lost(void **state)
assert_true(check_if_dimm_changed(spd_cache, &blk)); 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; uint8_t *spd_cache;
size_t spd_cache_sz; size_t spd_cache_sz;
@ -207,16 +200,15 @@ static void test_check_if_dimm_changed_new_sodimm(void **state)
fill_spd_cache_ddr4(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)); assert_int_equal(CB_SUCCESS, spd_fill_from_cache(spd_cache, &blk));
get_sn_from_spd_cache(spd_cache, get_spd_sn_ret_sn); 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; get_spd_sn_ret_sn_idx = 0;
will_return_always(get_spd_sn, CB_SUCCESS); will_return_always(get_spd_sn, CB_SUCCESS);
assert_true(check_if_dimm_changed(spd_cache, &blk)); 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; uint8_t *spd_cache;
size_t spd_cache_sz; size_t spd_cache_sz;

3
tests/lib/timestamp-test.c
View File

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