diff options
Diffstat (limited to 'tests/lib/region_file-test.c')
| -rw-r--r-- | tests/lib/region_file-test.c | 342 |
1 files changed, 342 insertions, 0 deletions
diff --git a/tests/lib/region_file-test.c b/tests/lib/region_file-test.c new file mode 100644 index 0000000000..6bd1382ad9 --- /dev/null +++ b/tests/lib/region_file-test.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); +} |