| /* SPDX-License-Identifier: GPL-2.0-only */ |
| |
| #include <assert.h> |
| #include <cbfs.h> |
| #include <commonlib/bsd/cbfs_mdata.h> |
| #include <commonlib/bsd/cbfs_private.h> |
| #include <commonlib/region.h> |
| #include <string.h> |
| #include <tests/lib/cbfs_util.h> |
| #include <tests/test.h> |
| |
| |
| static struct cbfs_boot_device cbd; |
| |
| static u8 aligned_cbfs_buffer[(sizeof(struct cbfs_test_file) + CBFS_ALIGNMENT) * 10] __aligned( |
| CBFS_ALIGNMENT); |
| |
| static u8 *unaligned_cbfs_buffer = &aligned_cbfs_buffer[3]; |
| static uintptr_t unaligned_cbfs_buffer_size = sizeof(aligned_cbfs_buffer) - 3; |
| |
| static u8 cbfs_mcache[TEST_MCACHE_SIZE] __aligned(CBFS_MCACHE_ALIGNMENT); |
| |
| /* Add files to CBFS buffer. NULL in files list equals to one CBFS_ALIGNMENT of spacing. */ |
| static int create_cbfs(const struct cbfs_test_file *files[], const size_t nfiles, u8 *buffer, |
| const size_t buffer_size) |
| { |
| u8 *data_ptr = buffer; |
| size_t file_size = 0; |
| memset(buffer, 0, buffer_size); |
| |
| for (size_t i = 0; i < nfiles; ++i) { |
| if (files[i] == NULL) { |
| file_size = CBFS_ALIGNMENT; |
| assert_true(&data_ptr[file_size] < &buffer[buffer_size]); |
| } else { |
| file_size = be32_to_cpu(files[i]->header.len) |
| + be32_to_cpu(files[i]->header.offset); |
| assert_true(&data_ptr[file_size] < &buffer[buffer_size]); |
| memcpy(data_ptr, files[i], file_size); |
| } |
| |
| data_ptr = &data_ptr[file_size]; |
| const uintptr_t offset = (uintptr_t)data_ptr - (uintptr_t)buffer; |
| data_ptr = &buffer[ALIGN_UP(offset, CBFS_ALIGNMENT)]; |
| } |
| |
| return 0; |
| } |
| |
| /* Mocks */ |
| |
| const struct cbfs_boot_device *cbfs_get_boot_device(bool force_ro) |
| { |
| return &cbd; |
| } |
| |
| size_t ulzman(const void *src, size_t srcn, void *dst, size_t dstn) |
| { |
| check_expected(srcn); |
| check_expected(dstn); |
| memcpy(dst, src, dstn); |
| return dstn; |
| } |
| |
| size_t ulz4fn(const void *src, size_t srcn, void *dst, size_t dstn) |
| { |
| check_expected(srcn); |
| check_expected(dstn); |
| memcpy(dst, src, dstn); |
| return dstn; |
| } |
| |
| extern enum cb_err __real_cbfs_lookup(cbfs_dev_t dev, const char *name, |
| union cbfs_mdata *mdata_out, size_t *data_offset_out, |
| struct vb2_hash *metadata_hash); |
| |
| enum cb_err cbfs_lookup(cbfs_dev_t dev, const char *name, union cbfs_mdata *mdata_out, |
| size_t *data_offset_out, struct vb2_hash *metadata_hash) |
| { |
| const enum cb_err err = |
| __real_cbfs_lookup(dev, name, mdata_out, data_offset_out, metadata_hash); |
| assert_int_equal(err, mock_type(enum cb_err)); |
| return err; |
| } |
| |
| extern enum cb_err __real_cbfs_mcache_lookup(const void *mcache, size_t mcache_size, |
| const char *name, union cbfs_mdata *mdata_out, |
| size_t *data_offset_out); |
| |
| enum cb_err cbfs_mcache_lookup(const void *mcache, size_t mcache_size, const char *name, |
| union cbfs_mdata *mdata_out, size_t *data_offset_out) |
| { |
| const enum cb_err err = __real_cbfs_mcache_lookup(mcache, mcache_size, name, mdata_out, |
| data_offset_out); |
| assert_int_equal(err, mock_type(enum cb_err)); |
| return err; |
| } |
| |
| extern void *__real_mem_pool_alloc(struct mem_pool *mp, size_t sz); |
| |
| void *mem_pool_alloc(struct mem_pool *mp, size_t sz) |
| { |
| check_expected(sz); |
| assert_ptr_equal(mp, &cbfs_cache); |
| return __real_mem_pool_alloc(mp, sz); |
| } |
| |
| extern void __real_mem_pool_free(struct mem_pool *mp, void *p); |
| |
| void mem_pool_free(struct mem_pool *mp, void *p) |
| { |
| check_expected(p); |
| assert_ptr_equal(mp, &cbfs_cache); |
| return __real_mem_pool_free(mp, p); |
| } |
| |
| static u8 cbmem_test_buf[2 * MiB]; |
| |
| void *cbmem_add(u32 id, u64 size) |
| { |
| check_expected(id); |
| check_expected(size); |
| return cbmem_test_buf; |
| } |
| |
| /* Setup, teardown and utils */ |
| |
| struct cbfs_test_state_ex { |
| u32 file_type; |
| u32 file_length; |
| enum cb_err lookup_result; |
| }; |
| |
| struct cbfs_test_state { |
| u8 *cbfs_buf; |
| size_t cbfs_size; |
| |
| /* Optionals */ |
| struct cbfs_test_state_ex ex; |
| }; |
| |
| static int setup_test_cbfs_aligned(void **state) |
| { |
| struct cbfs_test_state *s = malloc(sizeof(struct cbfs_test_state)); |
| |
| if (!s) |
| return 1; |
| s->cbfs_buf = aligned_cbfs_buffer; |
| s->cbfs_size = sizeof(aligned_cbfs_buffer); |
| memset(&s->ex, 0, sizeof(s->ex)); |
| |
| /* Prestate */ |
| if (*state != NULL) |
| s->ex = *((struct cbfs_test_state_ex *)*state); |
| |
| *state = s; |
| |
| rdev_chain_mem(&cbd.rdev, aligned_cbfs_buffer, sizeof(aligned_cbfs_buffer)); |
| memset(aligned_cbfs_buffer, 0, sizeof(aligned_cbfs_buffer)); |
| |
| cbd.mcache = cbfs_mcache; |
| cbd.mcache_size = TEST_MCACHE_SIZE; |
| |
| return 0; |
| } |
| |
| static int setup_test_cbfs_unaligned(void **state) |
| { |
| struct cbfs_test_state *s = malloc(sizeof(struct cbfs_test_state)); |
| |
| if (!s) |
| return 1; |
| s->cbfs_buf = unaligned_cbfs_buffer; |
| s->cbfs_size = unaligned_cbfs_buffer_size; |
| memset(&s->ex, 0, sizeof(s->ex)); |
| |
| /* Prestate */ |
| if (*state != NULL) |
| s->ex = *((struct cbfs_test_state_ex *)*state); |
| |
| *state = s; |
| |
| rdev_chain_mem(&cbd.rdev, unaligned_cbfs_buffer, unaligned_cbfs_buffer_size); |
| memset(unaligned_cbfs_buffer, 0, unaligned_cbfs_buffer_size); |
| |
| cbd.mcache = cbfs_mcache; |
| cbd.mcache_size = TEST_MCACHE_SIZE; |
| |
| return 0; |
| } |
| |
| static int teardown_test_cbfs(void **state) |
| { |
| free(*state); |
| memset(&cbd, 0, sizeof(cbd)); |
| return 0; |
| } |
| |
| /* Utils */ |
| |
| static void expect_lookup_result(enum cb_err res) |
| { |
| if (CONFIG(NO_CBFS_MCACHE)) |
| will_return(cbfs_lookup, (res)); |
| else |
| will_return(cbfs_mcache_lookup, (res)); |
| } |
| |
| /* Tests */ |
| |
| /* Test case for cbfs_map() function. Validate file searching in the correct CBFS */ |
| static void test_cbfs_map(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| const struct cbfs_test_file *cbfs_files[] = { |
| &test_file_int_1, &test_file_2, NULL, &test_file_int_2, |
| &test_file_1, NULL, NULL, &test_file_int_3, |
| }; |
| assert_int_equal( |
| 0, create_cbfs(cbfs_files, ARRAY_SIZE(cbfs_files), s->cbfs_buf, s->cbfs_size)); |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| /* Existing files */ |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_non_null(mapping); |
| assert_int_equal(TEST_DATA_1_SIZE, size_out); |
| assert_memory_equal(mapping, test_data_1, TEST_DATA_1_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| size_out = 0; |
| expect_value(ulzman, srcn, TEST_DATA_2_SIZE); |
| expect_value(ulzman, dstn, TEST_DATA_2_SIZE); |
| expect_value(mem_pool_alloc, sz, TEST_DATA_2_SIZE); |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out); |
| assert_non_null(mapping); |
| assert_int_equal(TEST_DATA_2_SIZE, size_out); |
| assert_memory_equal(mapping, test_data_2, TEST_DATA_2_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); |
| assert_non_null(mapping); |
| assert_int_equal(TEST_DATA_INT_1_SIZE, size_out); |
| assert_memory_equal(mapping, test_data_int_1, TEST_DATA_INT_1_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| /* Do not pass output pointer to size. It should work correctly. */ |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, NULL); |
| assert_non_null(mapping); |
| assert_memory_equal(mapping, test_data_int_2, TEST_DATA_INT_2_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| size_out = 0; |
| expect_value(ulz4fn, srcn, TEST_DATA_INT_3_SIZE); |
| expect_value(ulz4fn, dstn, TEST_DATA_INT_3_SIZE); |
| expect_value(mem_pool_alloc, sz, TEST_DATA_INT_3_SIZE); |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_3_FILENAME, &size_out); |
| assert_non_null(mapping); |
| assert_int_equal(TEST_DATA_INT_3_SIZE, size_out); |
| assert_memory_equal(mapping, test_data_int_3, TEST_DATA_INT_3_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| /* Nonexistent files */ |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map("unknown_fname", &size_out); |
| assert_ptr_equal(NULL, mapping); |
| assert_int_equal(0, size_out); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map("", &size_out); |
| assert_ptr_equal(NULL, mapping); |
| assert_int_equal(0, size_out); |
| } |
| |
| static void test_cbfs_cbmem_alloc(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| const struct cbfs_test_file *cbfs_files[] = { |
| NULL, &test_file_1, &test_file_2, &test_file_int_1, |
| NULL, &test_file_int_2, &test_file_int_3, NULL, |
| }; |
| assert_int_equal( |
| 0, create_cbfs(cbfs_files, ARRAY_SIZE(cbfs_files), s->cbfs_buf, s->cbfs_size)); |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| /* Existing files */ |
| expect_lookup_result(CB_SUCCESS); |
| expect_value(cbmem_add, id, 0x0101); |
| expect_value(cbmem_add, size, TEST_DATA_1_SIZE); |
| mapping = cbfs_cbmem_alloc(TEST_DATA_1_FILENAME, 0x0101, &size_out); |
| assert_non_null(mapping); |
| assert_int_equal(TEST_DATA_1_SIZE, size_out); |
| assert_memory_equal(mapping, test_data_1, TEST_DATA_1_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| /* Do not pass output pointer to size. It should work correctly. */ |
| expect_value(ulzman, srcn, TEST_DATA_2_SIZE); |
| expect_value(ulzman, dstn, TEST_DATA_2_SIZE); |
| expect_lookup_result(CB_SUCCESS); |
| expect_value(cbmem_add, id, 0x0102); |
| expect_value(cbmem_add, size, TEST_DATA_2_SIZE); |
| mapping = cbfs_cbmem_alloc(TEST_DATA_2_FILENAME, 0x0102, NULL); |
| assert_non_null(mapping); |
| assert_memory_equal(mapping, test_data_2, TEST_DATA_2_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| expect_value(cbmem_add, id, 0x0201); |
| expect_value(cbmem_add, size, TEST_DATA_INT_1_SIZE); |
| mapping = cbfs_cbmem_alloc(TEST_DATA_INT_1_FILENAME, 0x0201, &size_out); |
| assert_non_null(mapping); |
| assert_int_equal(TEST_DATA_INT_1_SIZE, size_out); |
| assert_memory_equal(mapping, test_data_int_1, TEST_DATA_INT_1_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| expect_value(cbmem_add, id, 0x0202); |
| expect_value(cbmem_add, size, TEST_DATA_INT_2_SIZE); |
| mapping = cbfs_cbmem_alloc(TEST_DATA_INT_2_FILENAME, 0x0202, &size_out); |
| assert_non_null(mapping); |
| assert_int_equal(TEST_DATA_INT_2_SIZE, size_out); |
| assert_memory_equal(mapping, test_data_int_2, TEST_DATA_INT_2_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| size_out = 0; |
| expect_value(ulz4fn, srcn, TEST_DATA_INT_3_SIZE); |
| expect_value(ulz4fn, dstn, TEST_DATA_INT_3_SIZE); |
| expect_lookup_result(CB_SUCCESS); |
| expect_value(cbmem_add, id, 0x0203); |
| expect_value(cbmem_add, size, TEST_DATA_INT_2_SIZE); |
| mapping = cbfs_cbmem_alloc(TEST_DATA_INT_3_FILENAME, 0x0203, &size_out); |
| assert_non_null(mapping); |
| assert_int_equal(TEST_DATA_INT_3_SIZE, size_out); |
| assert_memory_equal(mapping, test_data_int_3, TEST_DATA_INT_3_SIZE); |
| |
| expect_value(mem_pool_free, p, mapping); |
| cbfs_unmap(mapping); |
| |
| /* Nonexistent files */ |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_cbmem_alloc("nothing-file", 0x0301, &size_out); |
| assert_null(mapping); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_cbmem_alloc("", 0x0302, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_image_not_aligned(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| const struct cbfs_test_file *cbfs_files[] = { |
| &test_file_int_1, |
| &test_file_2, |
| }; |
| assert_int_equal(0, create_cbfs(cbfs_files, ARRAY_SIZE(cbfs_files), &s->cbfs_buf[5], |
| s->cbfs_size - 5)); |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); |
| assert_null(mapping); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_file_not_aligned(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| |
| memcpy(s->cbfs_buf, &test_file_int_2, sizeof(test_file_int_2)); |
| memcpy(&s->cbfs_buf[ALIGN_UP(sizeof(test_file_int_2), CBFS_ALIGNMENT) + 5], |
| &test_file_1, sizeof(test_file_1)); |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out); |
| assert_ptr_equal(mapping, |
| &s->cbfs_buf[offsetof(struct cbfs_test_file, attrs_and_data)]); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_garbage_data_before_aligned_file(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| const char garbage[] = |
| "NOT so USEFUL DaTa BYTES that should have at least CBFS_ALIGNMENT bytes"; |
| const size_t garbage_sz = CBFS_ALIGNMENT; |
| struct cbfs_test_state *s = *state; |
| |
| /* Garbage data size has to be aligned to CBFS_ALIGNMENT */ |
| memcpy(s->cbfs_buf, garbage, garbage_sz); |
| memcpy(&s->cbfs_buf[garbage_sz], &test_file_int_2, sizeof(test_file_int_2)); |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out); |
| assert_ptr_equal( |
| mapping, |
| &s->cbfs_buf[garbage_sz + offsetof(struct cbfs_test_file, attrs_and_data)]); |
| } |
| |
| static void test_cbfs_garbage_data_before_unaligned_file(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| const char garbage[] = |
| "NOT so USEFUL DaTa BYTES that should have at least CBFS_ALIGNMENT + 3 bytes"; |
| const size_t garbage_sz = CBFS_ALIGNMENT + 3; |
| struct cbfs_test_state *s = *state; |
| |
| assert_true(garbage_sz == (CBFS_ALIGNMENT + 3)); |
| memcpy(s->cbfs_buf, garbage, garbage_sz); |
| memcpy(&s->cbfs_buf[garbage_sz], &test_file_int_2, sizeof(test_file_int_2)); |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_file_bigger_than_rdev(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| /* File with length equal to region_device size will go beyond it */ |
| f->header.len = cpu_to_be32(s->cbfs_size); |
| |
| /* Initialization and mcache building will succeed, because it only does access file |
| headers, and not actual data */ |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| /* Lookup should not succeed, because data is too long, so reading it later would cause |
| memory access issues */ |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_fail_beyond_rdev(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT); |
| |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| memcpy(&s->cbfs_buf[second_file_start], &test_file_2, s->ex.file_length); |
| assert_true((second_file_start + s->ex.file_length) <= region_sz(&cbd.rdev.region)); |
| /* Adjust size of region device to cut everything after selected offset */ |
| cbd.rdev.region.size = second_file_start + s->ex.file_length; |
| |
| /* CBFS initialization should not fail if last file is not valid */ |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]); |
| assert_int_equal(size_out, TEST_DATA_1_SIZE); |
| |
| size_out = 0; |
| if (s->ex.lookup_result == CB_SUCCESS) { |
| expect_value(ulzman, srcn, TEST_DATA_2_SIZE); |
| expect_value(ulzman, dstn, TEST_DATA_2_SIZE); |
| expect_value(mem_pool_alloc, sz, TEST_DATA_2_SIZE); |
| } |
| expect_lookup_result(s->ex.lookup_result); |
| cbfs_map(TEST_DATA_2_FILENAME, &size_out); |
| } |
| |
| static void test_cbfs_unaligned_file_in_the_middle(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT) + 5; |
| size_t third_file_start = |
| ALIGN_UP(sizeof(test_file_int_1) + second_file_start, CBFS_ALIGNMENT); |
| |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| memcpy(&s->cbfs_buf[second_file_start], &test_file_int_1, sizeof(test_file_int_1)); |
| memcpy(&s->cbfs_buf[third_file_start], &test_file_int_2, sizeof(test_file_int_2)); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]); |
| assert_int_equal(size_out, be32_to_cpu(test_file_1.header.len)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); |
| assert_null(mapping); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out); |
| assert_ptr_equal( |
| mapping, |
| &s->cbfs_buf[third_file_start + be32_to_cpu(test_file_int_2.header.offset)]); |
| assert_int_equal(size_out, be32_to_cpu(test_file_int_2.header.len)); |
| } |
| |
| static void test_cbfs_overlapping_files(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT); |
| size_t third_file_start = |
| ALIGN_UP(sizeof(test_file_int_1) + second_file_start, CBFS_ALIGNMENT); |
| size_t second_file_size = |
| third_file_start + sizeof(test_file_int_2) - second_file_start; |
| struct cbfs_test_file *f; |
| |
| /* Third file is inside second file, thus it should not be found */ |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| memcpy(&s->cbfs_buf[second_file_start], &test_file_int_1, sizeof(test_file_int_1)); |
| memcpy(&s->cbfs_buf[third_file_start], &test_file_int_2, sizeof(test_file_int_2)); |
| f = (struct cbfs_test_file *)&s->cbfs_buf[second_file_start]; |
| f->header.len = cpu_to_be32(second_file_size); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]); |
| assert_int_equal(size_out, be32_to_cpu(test_file_1.header.len)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); |
| assert_ptr_equal( |
| mapping, |
| &s->cbfs_buf[second_file_start + be32_to_cpu(test_file_int_1.header.offset)]); |
| assert_int_equal(size_out, second_file_size); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_incorrect_file_in_the_middle(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT); |
| size_t third_file_start = |
| ALIGN_UP(sizeof(test_file_int_1) + second_file_start, CBFS_ALIGNMENT); |
| struct cbfs_test_file *f; |
| |
| /* Zero offset is illegal. File is not correct */ |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| memcpy(&s->cbfs_buf[second_file_start], &test_file_int_1, sizeof(test_file_int_1)); |
| memcpy(&s->cbfs_buf[third_file_start], &test_file_int_2, sizeof(test_file_int_2)); |
| f = (struct cbfs_test_file *)&s->cbfs_buf[second_file_start]; |
| f->header.offset = cpu_to_be32(0); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]); |
| assert_int_equal(size_out, be32_to_cpu(test_file_1.header.len)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); |
| assert_null(mapping); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_2_FILENAME, &size_out); |
| assert_ptr_equal( |
| mapping, |
| &s->cbfs_buf[third_file_start + be32_to_cpu(test_file_int_2.header.offset)]); |
| assert_int_equal(size_out, be32_to_cpu(test_file_int_2.header.len)); |
| } |
| |
| static void test_cbfs_two_files_with_same_name(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| size_t second_file_start = ALIGN_UP(sizeof(test_file_1), CBFS_ALIGNMENT); |
| size_t third_file_start = |
| ALIGN_UP(sizeof(test_file_1) + second_file_start, CBFS_ALIGNMENT); |
| |
| /* Only first occurrence of file will be found */ |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| memcpy(&s->cbfs_buf[second_file_start], &test_file_1, sizeof(test_file_1)); |
| memcpy(&s->cbfs_buf[third_file_start], &test_file_int_1, sizeof(test_file_int_1)); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_1.header.offset)]); |
| assert_int_equal(size_out, be32_to_cpu(test_file_1.header.len)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); |
| assert_ptr_equal( |
| mapping, |
| &s->cbfs_buf[third_file_start + be32_to_cpu(test_file_int_1.header.offset)]); |
| assert_int_equal(size_out, be32_to_cpu(test_file_int_1.header.len)); |
| } |
| |
| static void test_cbfs_filename_not_terminated(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| const char fname[] = "abcdefghijklmnop"; |
| |
| assert_true(sizeof(test_file_1.filename) == strlen(fname)); |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| memcpy(f->filename, fname, strlen(fname)); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| /* Filename is too long and does not include NULL-terminator. */ |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(fname, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_filename_terminated_but_too_long(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| /* Filename length in header offset field is too short by one to include |
| NULL-terminator of filename */ |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| f->header.offset = cpu_to_be32(offsetof(struct cbfs_test_file, filename) |
| + strlen(TEST_DATA_1_FILENAME)); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_attributes_offset_larger_than_offset(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| /* Require attributes for this test */ |
| assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0); |
| memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| f->header.attributes_offset = cpu_to_be32(sizeof(struct cbfs_file) + FILENAME_SIZE |
| + sizeof(struct cbfs_file_attr_compression)); |
| f->header.offset = cpu_to_be32(sizeof(struct cbfs_file) + FILENAME_SIZE); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_attributes_offset_cut_off_at_len(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| /* Require attributes for this test */ |
| assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0); |
| memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| f->header.attributes_offset = |
| cpu_to_be32(offsetof(struct cbfs_test_file, attrs_and_data) |
| + offsetof(struct cbfs_file_attribute, len)); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| /* No attributes will be found, because attributes_offset value is too big to cover |
| cbfs_file_attribute tag. Compression attribute of ths file will not be found, and |
| that is why there is no need to call expect_value(ulzma). |
| However, file will be found, because the offset is correct. */ |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out); |
| assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(f->header.offset)]); |
| assert_int_equal(size_out, TEST_DATA_2_SIZE); |
| } |
| |
| static void test_cbfs_attributes_offset_cut_off_at_data(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| /* Require attributes for this test */ |
| assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0); |
| memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| f->header.attributes_offset = cpu_to_be32(sizeof(struct cbfs_file) + FILENAME_SIZE |
| + offsetof(struct cbfs_file_attribute, data)); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| /* No attributes will be found, because attributes_offset value is too big to cover |
| cbfs_file_attribute tag and length. Compression attribute of ths file will not be |
| found, and that is why there is no need to call expect_value(ulzma). |
| However, file will be found, because the offset is correct. */ |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out); |
| assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(f->header.offset)]); |
| assert_int_equal(size_out, TEST_DATA_2_SIZE); |
| } |
| |
| static void test_cbfs_attributes_offset_smaller_than_file_struct(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0); |
| memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| f->header.attributes_offset = cpu_to_be32(sizeof(struct cbfs_file) / 2); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_offset_smaller_than_header_size(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| assert_true(be32_to_cpu(test_file_int_1.header.attributes_offset) == 0); |
| memcpy(s->cbfs_buf, &test_file_int_1, sizeof(test_file_int_1)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| f->header.offset = cpu_to_be32(sizeof(struct cbfs_file) / 2); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_attributes_offset_is_zero(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| |
| assert_true(be32_to_cpu(test_file_int_1.header.attributes_offset) == 0); |
| memcpy(s->cbfs_buf, &test_file_int_1, sizeof(test_file_int_1)); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_SUCCESS); |
| mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); |
| assert_int_equal(TEST_DATA_INT_1_SIZE, size_out); |
| assert_ptr_equal(mapping, &s->cbfs_buf[be32_to_cpu(test_file_int_1.header.offset)]); |
| } |
| |
| static void test_cbfs_offset_is_zero(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| assert_true(be32_to_cpu(test_file_int_1.header.attributes_offset) == 0); |
| memcpy(s->cbfs_buf, &test_file_int_1, sizeof(test_file_int_1)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| f->header.offset = cpu_to_be32(0); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_INT_1_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_attributes_too_large(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| assert_true(be32_to_cpu(test_file_2.header.attributes_offset) != 0); |
| memcpy(s->cbfs_buf, &test_file_2, sizeof(test_file_2)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| /* Offset determines size of header and attributes. CBFS module uses cbfs_mdata union to |
| store it, so offset (thus attributes) bigger than it should cause an error in the |
| lookup code. */ |
| f->header.offset = |
| cpu_to_be32(be32_to_cpu(f->header.offset) + sizeof(union cbfs_mdata)); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_2_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| /* Requires cbfs_test_state.ex.file_length to be set */ |
| static void test_cbfs_file_length(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| assert_true(be32_to_cpu(test_file_1.header.attributes_offset) == 0); |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| f->header.len = cpu_to_be32(s->ex.file_length); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| static void test_cbfs_attributes_offset_uint32_max(void **state) |
| { |
| void *mapping; |
| size_t size_out; |
| struct cbfs_test_state *s = *state; |
| struct cbfs_test_file *f; |
| |
| assert_true(be32_to_cpu(test_file_1.header.attributes_offset) == 0); |
| memcpy(s->cbfs_buf, &test_file_1, sizeof(test_file_1)); |
| f = (struct cbfs_test_file *)s->cbfs_buf; |
| f->header.attributes_offset = cpu_to_be32(UINT32_MAX); |
| |
| assert_int_equal(CB_SUCCESS, cbfs_init_boot_device(&cbd, NULL)); |
| |
| size_out = 0; |
| expect_lookup_result(CB_CBFS_NOT_FOUND); |
| mapping = cbfs_map(TEST_DATA_1_FILENAME, &size_out); |
| assert_null(mapping); |
| } |
| |
| #define CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST(name, test_fn, setup_fn, prestate) \ |
| { \ |
| (name), (test_fn), (setup_fn), teardown_test_cbfs, (prestate), \ |
| } |
| |
| #define CBFS_LOOKUP_NAME_PRESTATE_TEST(name, test_fn, prestate) \ |
| EMPTY_WRAP( \ |
| CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST( \ |
| ("aligned, " name), (test_fn), setup_test_cbfs_aligned, (prestate)), \ |
| CBFS_LOOKUP_NAME_SETUP_PRESTATE_COMMON_TEST(("unaligned, " name), (test_fn), \ |
| 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_FAIL_BEYOND_RDEV(name, file_len, lookup_res) \ |
| EMPTY_WRAP(CBFS_LOOKUP_NAME_PRESTATE_TEST(name ", CBFS_TYPE_RAW", \ |
| test_cbfs_fail_beyond_rdev, \ |
| (&(struct cbfs_test_state_ex){ \ |
| .file_type = CBFS_TYPE_RAW, \ |
| .file_length = (file_len), \ |
| .lookup_result = (lookup_res), \ |
| })), \ |
| CBFS_LOOKUP_NAME_PRESTATE_TEST(name ", CBFS_TYPE_NULL", \ |
| test_cbfs_fail_beyond_rdev, \ |
| (&(struct cbfs_test_state_ex){ \ |
| .file_type = CBFS_TYPE_NULL, \ |
| .file_length = (file_len), \ |
| .lookup_result = (lookup_res), \ |
| }))) |
| |
| #define CBFS_LOOKUP_TEST_FILE_LENGTH(file_len) \ |
| CBFS_LOOKUP_NAME_PRESTATE_TEST("test_cbfs_file_length, " #file_len, \ |
| test_cbfs_file_length, \ |
| (&(struct cbfs_test_state_ex){ \ |
| .file_length = (file_len), \ |
| })) |
| |
| int main(void) |
| { |
| const struct CMUnitTest cbfs_lookup_aligned_and_unaligned_tests[] = { |
| CBFS_LOOKUP_TEST(test_cbfs_map), |
| CBFS_LOOKUP_TEST(test_cbfs_cbmem_alloc), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_image_not_aligned), |
| CBFS_LOOKUP_TEST(test_cbfs_file_not_aligned), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_garbage_data_before_aligned_file), |
| CBFS_LOOKUP_TEST(test_cbfs_garbage_data_before_unaligned_file), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_file_bigger_than_rdev), |
| |
| /* Correct file */ |
| CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV("File fitting in rdev", |
| sizeof(struct cbfs_test_file), CB_SUCCESS), |
| |
| /* Attributes beyond rdev */ |
| CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV( |
| "Attributes and data beyond rdev", |
| offsetof(struct cbfs_test_file, attrs_and_data), CB_CBFS_NOT_FOUND), |
| |
| /* Attributes except tag beyond rdev */ |
| CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV( |
| "Attributes except tag beyond rdev", |
| offsetof(struct cbfs_test_file, attrs_and_data) |
| - offsetof(struct cbfs_file_attribute, len), |
| CB_CBFS_NOT_FOUND), |
| |
| /* Attributes except tag and len beyond rdev */ |
| CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV( |
| "Attributes except tag and len beyond rdev", |
| offsetof(struct cbfs_test_file, attrs_and_data) |
| - offsetof(struct cbfs_file_attribute, data), |
| CB_CBFS_NOT_FOUND), |
| |
| /* Filename beyond rdev */ |
| CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV("Filename beyond rdev", |
| offsetof(struct cbfs_test_file, filename), |
| CB_CBFS_NOT_FOUND), |
| |
| /* Part of filename beyond rdev */ |
| CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV("Part of filename beyond rdev", |
| offsetof(struct cbfs_test_file, filename) |
| + FILENAME_SIZE / 2, |
| CB_CBFS_NOT_FOUND), |
| |
| /* Part of cbfs_file struct beyond rdev */ |
| CBFS_LOOKUP_TEST_FAIL_BEYOND_RDEV("Part of cbfs_file struct beyond rdev", |
| offsetof(struct cbfs_test_file, filename) / 2, |
| CB_CBFS_NOT_FOUND), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_unaligned_file_in_the_middle), |
| CBFS_LOOKUP_TEST(test_cbfs_overlapping_files), |
| CBFS_LOOKUP_TEST(test_cbfs_incorrect_file_in_the_middle), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_two_files_with_same_name), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_filename_not_terminated), |
| CBFS_LOOKUP_TEST(test_cbfs_filename_terminated_but_too_long), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_larger_than_offset), |
| CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_cut_off_at_len), |
| CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_cut_off_at_data), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_smaller_than_file_struct), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_offset_smaller_than_header_size), |
| CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_is_zero), |
| CBFS_LOOKUP_TEST(test_cbfs_offset_is_zero), |
| CBFS_LOOKUP_TEST(test_cbfs_attributes_too_large), |
| |
| CBFS_LOOKUP_TEST_FILE_LENGTH(UINT32_MAX), |
| CBFS_LOOKUP_TEST_FILE_LENGTH(UINT32_MAX |
| - offsetof(struct cbfs_test_file, attrs_and_data)), |
| CBFS_LOOKUP_TEST_FILE_LENGTH( |
| UINT32_MAX - offsetof(struct cbfs_test_file, attrs_and_data) / 2), |
| CBFS_LOOKUP_TEST_FILE_LENGTH( |
| UINT32_MAX - offsetof(struct cbfs_test_file, attrs_and_data) * 2), |
| CBFS_LOOKUP_TEST_FILE_LENGTH( |
| UINT32_MAX - offsetof(struct cbfs_test_file, attrs_and_data) - 1), |
| CBFS_LOOKUP_TEST_FILE_LENGTH( |
| UINT32_MAX - offsetof(struct cbfs_test_file, attrs_and_data) + 1), |
| |
| CBFS_LOOKUP_TEST(test_cbfs_attributes_offset_uint32_max), |
| }; |
| |
| return cb_run_group_tests(cbfs_lookup_aligned_and_unaligned_tests, NULL, NULL); |
| } |