tests: Add lib/region_file-test test case
Signed-off-by: Jakub Czapiga <jacz@semihalf.com> Change-Id: Ic48e52a97b18d55fd983315f25dc972f472cc473 Reviewed-on: https://review.coreboot.org/c/coreboot/+/49669 Tested-by: build bot (Jenkins) <no-reply@coreboot.org> Reviewed-by: Patrick Georgi <pgeorgi@google.com>
This commit is contained in:
Jakub Czapiga
Patrick Georgi
parent
5ff17ed393
commit
eb6f80d049
File diff suppressed because it is too large
Load Diff
|
|
@ -12,6 +12,7 @@ tests-y += list-test
|
|||
tests-y += fmap-test
|
||||
tests-y += imd_cbmem-romstage-test
|
||||
tests-y += imd_cbmem-ramstage-test
|
||||
tests-y += region_file-test
|
||||
|
||||
string-test-srcs += tests/lib/string-test.c
|
||||
string-test-srcs += src/lib/string.c
|
||||
|
|
@ -67,3 +68,6 @@ imd_cbmem-romstage-test-srcs += tests/stubs/console.c
|
|||
imd_cbmem-romstage-test-srcs += src/lib/imd.c
|
||||
imd_cbmem-romstage-test-mocks += cbmem_top_chipset
|
||||
|
||||
region_file-test-srcs += tests/lib/region_file-test.c
|
||||
region_file-test-srcs += src/commonlib/region.c
|
||||
region_file-test-srcs += tests/stubs/console.c
|
||||
|
|
|
|||
|
|
@ -0,0 +1,342 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
|
||||
#include "../lib/region_file.c"
|
||||
|
||||
#include <tests/test.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <commonlib/region.h>
|
||||
#include <tests/lib/region_file_data.h>
|
||||
|
||||
static void clear_region_file(struct mem_region_device *mrdev)
|
||||
{
|
||||
uint8_t *mem_buffer = (uint8_t *)mrdev->base;
|
||||
|
||||
memset(mem_buffer, 0xff, REGION_FILE_BUFFER_SIZE);
|
||||
}
|
||||
|
||||
static int setup_region_file_test_group(void **state)
|
||||
{
|
||||
void *mem_buffer = malloc(REGION_FILE_BUFFER_SIZE);
|
||||
struct mem_region_device *dev = malloc(sizeof(struct mem_region_device));
|
||||
|
||||
if (mem_buffer == NULL || dev == NULL) {
|
||||
free(mem_buffer);
|
||||
free(dev);
|
||||
return -1;
|
||||
}
|
||||
|
||||
*dev = (struct mem_region_device)
|
||||
MEM_REGION_DEV_RW_INIT(mem_buffer, REGION_FILE_BUFFER_SIZE);
|
||||
*state = dev;
|
||||
|
||||
clear_region_file(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int teardown_region_file_test_group(void **state)
|
||||
{
|
||||
struct mem_region_device *dev = *state;
|
||||
void *mem_buffer = dev->base;
|
||||
|
||||
free(mem_buffer);
|
||||
free(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* This function clears buffer associated with used region_device, so tests will be in clear
|
||||
state at the beginning and leave no trace after successful execution. The cost of memsetting
|
||||
everything twice is known, but acceptable as it grants safety and makes tests independent. */
|
||||
static int setup_teardown_region_file_test(void **state)
|
||||
{
|
||||
struct mem_region_device *dev = *state;
|
||||
|
||||
clear_region_file(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_region_file_init_empty(void **state)
|
||||
{
|
||||
struct mem_region_device *mdev = *state;
|
||||
struct region_device *mrdev = &mdev->rdev;
|
||||
struct region_file regf;
|
||||
|
||||
/* Test general approach using valid mem_region_device with buffer filled with 0xff.
|
||||
Parameters cannot be NULL. */
|
||||
assert_int_equal(0, region_file_init(®f, mrdev));
|
||||
assert_int_equal(RF_EMPTY, regf.slot);
|
||||
}
|
||||
|
||||
static void test_region_file_init_invalid_metadata(void **state)
|
||||
{
|
||||
struct mem_region_device *mdev = *state;
|
||||
struct region_device *mrdev = &mdev->rdev;
|
||||
uint16_t *mem_buffer16 = (uint16_t *)mdev->base;
|
||||
struct region_file regf;
|
||||
|
||||
/* Set number of metadata blocks to 0 */
|
||||
mem_buffer16[0] = 0;
|
||||
assert_int_equal(0, region_file_init(®f, mrdev));
|
||||
assert_int_equal(RF_NEED_TO_EMPTY, regf.slot);
|
||||
}
|
||||
|
||||
static void test_region_file_init_valid_no_data(void **state)
|
||||
{
|
||||
struct mem_region_device *mdev = *state;
|
||||
struct region_device *mrdev = &mdev->rdev;
|
||||
uint16_t *mem_buffer16 = (uint16_t *)mdev->base;
|
||||
struct region_file regf;
|
||||
|
||||
/* Manually allocate 4 metadata blocks and no data. */
|
||||
mem_buffer16[0] = 4;
|
||||
assert_int_equal(0, region_file_init(®f, mrdev));
|
||||
assert_int_equal(0, regf.slot);
|
||||
}
|
||||
|
||||
static void test_region_file_init_invalid_data_offset(void **state)
|
||||
{
|
||||
struct mem_region_device *mdev = *state;
|
||||
struct region_device *mrdev = &mdev->rdev;
|
||||
uint16_t *mem_buffer16 = (uint16_t *)mdev->base;
|
||||
struct region_file regf;
|
||||
|
||||
/* Manually allocate 4 metadata blocks and no data. */
|
||||
mem_buffer16[0] = 4;
|
||||
mem_buffer16[1] = 4;
|
||||
assert_int_equal(0, region_file_init(®f, mrdev));
|
||||
assert_int_equal(RF_NEED_TO_EMPTY, regf.slot);
|
||||
|
||||
/* Set data size to be larger than region */
|
||||
mem_buffer16[0] = 4;
|
||||
mem_buffer16[1] = 4 + 4096;
|
||||
assert_int_equal(0, region_file_init(®f, mrdev));
|
||||
assert_int_equal(RF_NEED_TO_EMPTY, regf.slot);
|
||||
}
|
||||
|
||||
static void test_region_file_init_correct_data_offset(void **state)
|
||||
{
|
||||
struct mem_region_device *mdev = *state;
|
||||
struct region_device *mrdev = &mdev->rdev;
|
||||
uint16_t *mem_buffer16 = (uint16_t *)mdev->base;
|
||||
struct region_file regf;
|
||||
|
||||
/* Set data size to 8 blocks which is correct value. */
|
||||
mem_buffer16[0] = 4;
|
||||
mem_buffer16[1] = 4 + 8;
|
||||
assert_int_equal(0, region_file_init(®f, mrdev));
|
||||
assert_int_equal(1, regf.slot);
|
||||
}
|
||||
|
||||
static void test_region_file_init_real_data(void **state)
|
||||
{
|
||||
struct mem_region_device dev = MEM_REGION_DEV_RW_INIT(region_file_data_buffer1,
|
||||
REGION_FILE_BUFFER_SIZE);
|
||||
struct region_device *rdev = &dev.rdev;
|
||||
struct region_file regf;
|
||||
|
||||
/* Check on real example with one update */
|
||||
assert_int_equal(0, region_file_init(®f, rdev));
|
||||
/* There is one update available */
|
||||
assert_int_equal(1, regf.slot);
|
||||
|
||||
|
||||
/* Check on real example with multiple updates */
|
||||
dev = (struct mem_region_device) MEM_REGION_DEV_RW_INIT(region_file_data_buffer2,
|
||||
REGION_FILE_BUFFER_SIZE);
|
||||
rdev = &dev.rdev;
|
||||
assert_int_equal(0, region_file_init(®f, rdev));
|
||||
/* There are three update available */
|
||||
assert_int_equal(3, regf.slot);
|
||||
}
|
||||
|
||||
static void test_region_file_init_invalid_region_device(void **state)
|
||||
{
|
||||
struct mem_region_device bad_dev = MEM_REGION_DEV_RW_INIT(NULL, 0);
|
||||
struct region_file regf;
|
||||
|
||||
/* Expect fail when passing invalid region_device. */
|
||||
assert_int_equal(-1, region_file_init(®f, &bad_dev.rdev));
|
||||
}
|
||||
|
||||
static void test_region_file_data(void **state)
|
||||
{
|
||||
/* region_device with empty data buffer */
|
||||
struct mem_region_device *mdev = *state;
|
||||
struct region_device *mrdev = &mdev->rdev;
|
||||
/* region_device with prepared data buffer */
|
||||
struct mem_region_device dev = MEM_REGION_DEV_RW_INIT(region_file_data_buffer1,
|
||||
REGION_FILE_BUFFER_SIZE);
|
||||
struct region_device *rdev = &dev.rdev;
|
||||
struct region_file regf;
|
||||
struct region_device read_rdev;
|
||||
int ret;
|
||||
|
||||
/* Check if region_file_data() fails to return region_device for empty region_file */
|
||||
ret = region_file_init(®f, mrdev);
|
||||
assert_int_equal(0, ret);
|
||||
ret = region_file_data(®f, &read_rdev);
|
||||
assert_int_equal(-1, ret);
|
||||
|
||||
/* Check if region_file_data() correctly returns region_device for hardcoded
|
||||
region_file data with update of 256 bytes */
|
||||
ret = region_file_init(®f, rdev);
|
||||
assert_int_equal(0, ret);
|
||||
ret = region_file_data(®f, &read_rdev);
|
||||
assert_int_equal(0, ret);
|
||||
assert_int_equal(region_device_sz(&read_rdev),
|
||||
ALIGN_UP(region_file_data_buffer1_update_sz, 16));
|
||||
}
|
||||
|
||||
static void test_region_file_update_data(void **state)
|
||||
{
|
||||
struct mem_region_device *dev = *state;
|
||||
struct region_device *rdev = &dev->rdev;
|
||||
struct region_file regf;
|
||||
struct region_device read_rdev;
|
||||
const size_t dummy_data_size = 256;
|
||||
uint8_t dummy_data[dummy_data_size];
|
||||
uint8_t output_buffer[dummy_data_size];
|
||||
int ret;
|
||||
|
||||
for (int i = 0; i < dummy_data_size; ++i)
|
||||
dummy_data[i] = 'A' + i % ('Z' - 'A');
|
||||
|
||||
ret = region_file_init(®f, rdev);
|
||||
assert_int_equal(0, ret);
|
||||
|
||||
/* Write half of buffer, read it and check, if it is the same.
|
||||
region_file_update_data() should be able to deal with empty region_file. */
|
||||
ret = region_file_update_data(®f, dummy_data, dummy_data_size / 2);
|
||||
assert_int_equal(0, ret);
|
||||
region_file_data(®f, &read_rdev);
|
||||
assert_int_equal(ALIGN_UP(dummy_data_size / 2, 16), region_device_sz(&read_rdev));
|
||||
rdev_readat(&read_rdev, output_buffer, 0, dummy_data_size / 2);
|
||||
assert_memory_equal(dummy_data, output_buffer, dummy_data_size / 2);
|
||||
|
||||
/* Update data to a bigger size */
|
||||
ret = region_file_update_data(®f, dummy_data, dummy_data_size);
|
||||
assert_int_equal(0, ret);
|
||||
region_file_data(®f, &read_rdev);
|
||||
assert_int_equal(ALIGN_UP(dummy_data_size, 16), region_device_sz(&read_rdev));
|
||||
rdev_readat(&read_rdev, output_buffer, 0, dummy_data_size);
|
||||
assert_memory_equal(dummy_data, output_buffer, dummy_data_size);
|
||||
|
||||
/* Update data to smaller size and check if it was properly stored */
|
||||
ret = region_file_update_data(®f, dummy_data, dummy_data_size / 2 + 3);
|
||||
assert_int_equal(0, ret);
|
||||
region_file_data(®f, &read_rdev);
|
||||
assert_int_equal(ALIGN_UP(dummy_data_size / 2 + 3, 16), region_device_sz(&read_rdev));
|
||||
rdev_readat(&read_rdev, output_buffer, 0, dummy_data_size / 2 + 3);
|
||||
assert_memory_equal(dummy_data, output_buffer, dummy_data_size / 2 + 3);
|
||||
}
|
||||
|
||||
static void test_region_file_update_data_arr(void **state)
|
||||
{
|
||||
struct mem_region_device *dev = *state;
|
||||
struct region_device *rdev = &dev->rdev;
|
||||
struct region_file regf;
|
||||
struct region_device read_rdev;
|
||||
const size_t dummy_data_size = 256;
|
||||
uint8_t dummy_data[dummy_data_size];
|
||||
uint8_t output_buffer[dummy_data_size * 4];
|
||||
struct update_region_file_entry update_entries[3];
|
||||
const size_t data1_size = dummy_data_size;
|
||||
const size_t data2_size = dummy_data_size / 2;
|
||||
const size_t data3_size = dummy_data_size / 4 + 3;
|
||||
const size_t data1_offset = 0;
|
||||
const size_t data2_offset = dummy_data_size / 4 + 2;
|
||||
const size_t data3_offset = dummy_data_size / 8 + 5;
|
||||
int ret;
|
||||
|
||||
for (int i = 0; i < dummy_data_size; ++i)
|
||||
dummy_data[i] = 'A' + i % ('Z' - 'A');
|
||||
|
||||
update_entries[0] = (struct update_region_file_entry)
|
||||
{ .size = data1_size, .data = &dummy_data[data1_offset] };
|
||||
update_entries[1] = (struct update_region_file_entry)
|
||||
{ .size = data2_size, .data = &dummy_data[data2_offset] };
|
||||
update_entries[2] = (struct update_region_file_entry)
|
||||
{ .size = data3_size, .data = &dummy_data[data3_offset] };
|
||||
|
||||
ret = region_file_init(®f, rdev);
|
||||
assert_int_equal(0, ret);
|
||||
|
||||
/* Write two update blocks as first data state. region_file_update_data_arr() should
|
||||
be able to deal with empty region_file. */
|
||||
ret = region_file_update_data_arr(®f, update_entries, 2);
|
||||
assert_int_equal(0, ret);
|
||||
region_file_data(®f, &read_rdev);
|
||||
assert_int_equal(ALIGN_UP(data1_size + data2_size, 16), region_device_sz(&read_rdev));
|
||||
ret = rdev_readat(&read_rdev, output_buffer, 0, data1_size + data2_size);
|
||||
assert_int_equal(data1_size + data2_size, ret);
|
||||
assert_memory_equal(&dummy_data[data1_offset], output_buffer, data1_size);
|
||||
assert_memory_equal(&dummy_data[data1_offset + data2_offset],
|
||||
&output_buffer[data1_size], data2_size);
|
||||
|
||||
/* Check if new block of data is added correctly */
|
||||
ret = region_file_update_data_arr(®f, update_entries, 3);
|
||||
assert_int_equal(0, ret);
|
||||
region_file_data(®f, &read_rdev);
|
||||
assert_int_equal(ALIGN_UP(data1_size + data2_size + data3_size, 16),
|
||||
region_device_sz(&read_rdev));
|
||||
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],
|
||||
&output_buffer[data1_size], data2_size);
|
||||
assert_memory_equal(&dummy_data[data3_offset],
|
||||
&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(®f, &update_entries[1], 2);
|
||||
assert_int_equal(0, ret);
|
||||
region_file_data(®f, &read_rdev);
|
||||
assert_int_equal(ALIGN_UP(data2_size + data3_size, 16), region_device_sz(&read_rdev));
|
||||
ret = rdev_readat(&read_rdev, output_buffer, 0, data2_size + data3_size);
|
||||
assert_int_equal(data2_size + data3_size, ret);
|
||||
assert_memory_equal(&dummy_data[data2_offset], &output_buffer[0], data2_size);
|
||||
assert_memory_equal(&dummy_data[data3_offset], &output_buffer[data2_size], data3_size);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
const struct CMUnitTest tests[] = {
|
||||
cmocka_unit_test_setup_teardown(test_region_file_init_empty,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
cmocka_unit_test_setup_teardown(test_region_file_init_invalid_metadata,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
cmocka_unit_test_setup_teardown(test_region_file_init_valid_no_data,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
cmocka_unit_test_setup_teardown(test_region_file_init_invalid_data_offset,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
cmocka_unit_test_setup_teardown(test_region_file_init_correct_data_offset,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
cmocka_unit_test_setup_teardown(test_region_file_init_real_data,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
cmocka_unit_test_setup_teardown(test_region_file_init_invalid_region_device,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
cmocka_unit_test_setup_teardown(test_region_file_data,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
cmocka_unit_test_setup_teardown(test_region_file_update_data,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
cmocka_unit_test_setup_teardown(test_region_file_update_data_arr,
|
||||
setup_teardown_region_file_test,
|
||||
setup_teardown_region_file_test),
|
||||
};
|
||||
|
||||
return cmocka_run_group_tests(tests,
|
||||
setup_region_file_test_group,
|
||||
teardown_region_file_test_group);
|
||||
}
|
||||
Loading…
Reference in New Issue