TBM
/
tbm-mcu
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

test: reorganise code

Browse Source
tags/0.1.0
S.J.R. van Schaik 7 years ago
parent 18d2adcb85
commit e84226657c
4 changed files with 263 additions and 212 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      source/tests/Makefile
  2. 70
      source/tests/ftl/find_block_div.c
  3. 184
      source/tests/ftl/read_page_desc.c
  4. 219
      source/tests/main.c

2
source/tests/Makefile
Unescape View File

@ -1 +1,3 @@
test-obj-y += source/tests/main.o
test-obj-y += source/tests/ftl/find_block_div.o
test-obj-y += source/tests/ftl/read_page_desc.o

70
source/tests/ftl/find_block_div.c
Unescape View File

@ -0,0 +1,70 @@
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
#include <cmocka.h>
#include <bitops.h>
#include <flash.h>
#include <ftl.h>
#include <macros.h>
int find_block_div(struct ftl_map *map);
static void test_find_block_div1(void **state)
{
struct ftl_map map;
(void)state;
map.log2_block_size = ilog2(64 * KIB);
map.log2_page_size = ilog2(4 * KIB);
find_block_div(&map);
assert_int_equal(1 << map.log2_pages_per_group, 16);
assert_int_equal(1 << map.log2_groups_per_block, 1);
}
static void test_find_block_div2(void **state)
{
struct ftl_map map;
(void)state;
map.log2_block_size = ilog2(16 * KIB);
map.log2_page_size = ilog2(4 * KIB);
find_block_div(&map);
assert_int_equal(1 << map.log2_pages_per_group, 4);
assert_int_equal(1 << map.log2_groups_per_block, 1);
}
static void test_find_block_div3(void **state)
{
struct ftl_map map;
(void)state;
map.log2_block_size = ilog2(64 * KIB);
map.log2_page_size = ilog2(1 * KIB);
find_block_div(&map);
assert_int_equal(1 << map.log2_pages_per_group, 8);
assert_int_equal(1 << map.log2_groups_per_block, 8);
}
int test_find_block_div(void)
{
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_find_block_div1),
cmocka_unit_test(test_find_block_div2),
cmocka_unit_test(test_find_block_div3),
};
return cmocka_run_group_tests_name("find_block_div", tests, NULL, NULL);
}

184
source/tests/ftl/read_page_desc.c
Unescape View File

@ -0,0 +1,184 @@
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
#include <cmocka.h>
#include <bitops.h>
#include <flash.h>
#include <ftl.h>
#include <macros.h>
size_t __wrap_flash_read(struct flash_dev *dev, uint32_t addr,
void *data, size_t len) __attribute__((used));
int read_page_desc(struct ftl_map *map,
struct ftl_page_desc *page_desc, uint32_t upage);
static void test_read_page_desc1(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (16 - 1) * 4 * KIB +
sizeof(struct ftl_page_group));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 0);
assert_int_equal(ret, 0);
}
static void test_read_page_desc2(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (16 - 1) * 4 * KIB +
sizeof(struct ftl_page_group) + 14 * sizeof(struct ftl_page_desc));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 14);
assert_int_equal(ret, 0);
}
static void test_read_page_desc3(void **state)
{
struct ftl_map map;
struct ftl_page_desc ret_page_desc;
size_t ret;
(void)state;
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 15);
assert_int_equal(ret, -1);
}
static void test_read_page_desc4(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (32 - 1) * 4 * KIB +
sizeof(struct ftl_page_group));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 16);
assert_int_equal(ret, 0);
}
static void test_read_page_desc5(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (32 - 1) * 4 * KIB +
sizeof(struct ftl_page_group) + 14 * sizeof(struct ftl_page_desc));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 30);
assert_int_equal(ret, 0);
}
static void test_read_page_desc6(void **state)
{
struct ftl_map map;
struct ftl_page_desc ret_page_desc;
size_t ret;
(void)state;
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 31);
assert_int_equal(ret, -1);
}
static void test_read_page_desc7(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (48 - 1) * 4 * KIB +
sizeof(struct ftl_page_group));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 32);
assert_int_equal(ret, 0);
}
int test_read_page_desc(void)
{
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_read_page_desc1),
cmocka_unit_test(test_read_page_desc2),
cmocka_unit_test(test_read_page_desc3),
cmocka_unit_test(test_read_page_desc4),
cmocka_unit_test(test_read_page_desc5),
cmocka_unit_test(test_read_page_desc6),
cmocka_unit_test(test_read_page_desc7),
};
return cmocka_run_group_tests_name("read_page_desc", tests, NULL, NULL);
}

219
source/tests/main.c
Unescape View File

@ -13,9 +13,6 @@
size_t __wrap_flash_read(struct flash_dev *dev, uint32_t addr,
void *data, size_t len) __attribute__((used));
int find_block_div(struct ftl_map *map);
int read_page_desc(struct ftl_map *map,
struct ftl_page_desc *page_desc, uint32_t upage);
size_t __wrap_flash_read(struct flash_dev *dev, uint32_t addr,
void *data, size_t len)
@ -30,217 +27,15 @@ size_t __wrap_flash_read(struct flash_dev *dev, uint32_t addr,
return mock_type(size_t);
}
static void test_find_block_div1(void **state)
{
struct ftl_map map;
(void)state;
map.log2_block_size = ilog2(64 * KIB);
map.log2_page_size = ilog2(4 * KIB);
find_block_div(&map);
assert_int_equal(1 << map.log2_pages_per_group, 16);
assert_int_equal(1 << map.log2_groups_per_block, 1);
}
static void test_find_block_div2(void **state)
{
struct ftl_map map;
(void)state;
map.log2_block_size = ilog2(16 * KIB);
map.log2_page_size = ilog2(4 * KIB);
find_block_div(&map);
assert_int_equal(1 << map.log2_pages_per_group, 4);
assert_int_equal(1 << map.log2_groups_per_block, 1);
}
static void test_find_block_div3(void **state)
{
struct ftl_map map;
(void)state;
map.log2_block_size = ilog2(64 * KIB);
map.log2_page_size = ilog2(1 * KIB);
find_block_div(&map);
assert_int_equal(1 << map.log2_pages_per_group, 8);
assert_int_equal(1 << map.log2_groups_per_block, 8);
}
static void test_read_page_desc1(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (16 - 1) * 4 * KIB +
sizeof(struct ftl_page_group));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 0);
assert_int_equal(ret, 0);
}
static void test_read_page_desc2(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (16 - 1) * 4 * KIB +
sizeof(struct ftl_page_group) + 14 * sizeof(struct ftl_page_desc));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 14);
assert_int_equal(ret, 0);
}
static void test_read_page_desc3(void **state)
{
struct ftl_map map;
struct ftl_page_desc ret_page_desc;
size_t ret;
(void)state;
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 15);
assert_int_equal(ret, -1);
}
static void test_read_page_desc4(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (32 - 1) * 4 * KIB +
sizeof(struct ftl_page_group));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 16);
assert_int_equal(ret, 0);
}
static void test_read_page_desc5(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (32 - 1) * 4 * KIB +
sizeof(struct ftl_page_group) + 14 * sizeof(struct ftl_page_desc));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 30);
assert_int_equal(ret, 0);
}
static void test_read_page_desc6(void **state)
{
struct ftl_map map;
struct ftl_page_desc ret_page_desc;
size_t ret;
(void)state;
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 31);
assert_int_equal(ret, -1);
}
static void test_read_page_desc7(void **state)
{
struct ftl_map map;
struct ftl_page_desc page_desc, ret_page_desc;
size_t ret;
(void)state;
memcpy(&page_desc.magic, "page", 4);
expect_value(__wrap_flash_read, addr, (48 - 1) * 4 * KIB +
sizeof(struct ftl_page_group));
expect_value(__wrap_flash_read, len, sizeof page_desc);
will_return(__wrap_flash_read, &page_desc);
will_return(__wrap_flash_read, sizeof page_desc);
map.log2_pages_per_group = ilog2(16);
map.log2_page_size = ilog2(4 * KIB);
ret = read_page_desc(&map, &ret_page_desc, 32);
assert_int_equal(ret, 0);
}
int test_find_block_div(void);
int test_read_page_desc(void);
int main(void)
{
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_find_block_div1),
cmocka_unit_test(test_find_block_div2),
cmocka_unit_test(test_find_block_div3),
cmocka_unit_test(test_read_page_desc1),
cmocka_unit_test(test_read_page_desc2),
cmocka_unit_test(test_read_page_desc3),
cmocka_unit_test(test_read_page_desc4),
cmocka_unit_test(test_read_page_desc5),
cmocka_unit_test(test_read_page_desc6),
cmocka_unit_test(test_read_page_desc7),
};
int count = 0;
count += test_find_block_div();
count += test_read_page_desc();
return cmocka_run_group_tests(tests, NULL, NULL);
return count;
}

Write Preview
Loading…
Cancel
Save