diff options
| -rw-r--r-- | tests/unittests/libmtd_test.c | 491 |
1 files changed, 491 insertions, 0 deletions
diff --git a/tests/unittests/libmtd_test.c b/tests/unittests/libmtd_test.c new file mode 100644 index 0000000..fc28dc0 --- /dev/null +++ b/tests/unittests/libmtd_test.c @@ -0,0 +1,491 @@ +#include <stdarg.h> +#include <setjmp.h> +#include <stddef.h> +#include <stdint.h> +#include <unistd.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/ioctl.h> +#include <unistd.h> +#include <cmocka.h> + +#include "mtd/mtd-user.h" +#include "libmtd.h" +#include "libmtd_int.h" + +#include "test_lib.h" + +static libmtd_t mock_libmtd_open() +{ + /* create a mock object for libmtd, not using sysfs */ + expect_open(SYSFS_ROOT "/class/mtd/mtd0/name", O_RDONLY, 4); + expect_close(4,0); + libmtd_t lib = libmtd_open(); + assert_non_null(lib); + return lib; +} + +static void test_libmtd_open(void **state) +{ + expect_open(SYSFS_ROOT "/class/mtd/mtd0/name", O_RDONLY, 4); + expect_close(4,0); + struct libmtd *lib = libmtd_open(); + assert_non_null(lib); + assert_string_equal(lib->sysfs_mtd, SYSFS_ROOT "/class/mtd"); + assert_string_equal(lib->mtd, SYSFS_ROOT "/class/mtd/mtd%d"); + assert_string_equal(lib->mtd_name, SYSFS_ROOT "/class/mtd/mtd%d/name"); + assert_string_equal(lib->mtd_dev, SYSFS_ROOT "/class/mtd/mtd%d/dev"); + assert_string_equal(lib->mtd_type, SYSFS_ROOT "/class/mtd/mtd%d/type"); + assert_string_equal(lib->mtd_eb_size, SYSFS_ROOT "/class/mtd/mtd%d/erasesize"); + assert_string_equal(lib->mtd_size, SYSFS_ROOT "/class/mtd/mtd%d/size"); + assert_string_equal(lib->mtd_min_io_size, SYSFS_ROOT "/class/mtd/mtd%d/writesize"); + assert_string_equal(lib->mtd_subpage_size, SYSFS_ROOT "/class/mtd/mtd%d/subpagesize"); + assert_string_equal(lib->mtd_oob_size, SYSFS_ROOT "/class/mtd/mtd%d/oobsize"); + assert_string_equal(lib->mtd_region_cnt, SYSFS_ROOT "/class/mtd/mtd%d/numeraseregions"); + assert_string_equal(lib->mtd_flags, SYSFS_ROOT "/class/mtd/mtd%d/flags"); + + libmtd_close(lib); + (void) state; +} + +static void test_mtd_dev_present(void **state) +{ + int ret; + libmtd_t lib = mock_libmtd_open(); + expect_stat(SYSFS_ROOT "/class/mtd/mtd0", 0); + ret = mtd_dev_present(lib, 0); + assert_int_equal(ret, 1); + libmtd_close(lib); + (void) state; +} + +static void test_mtd_mark_bad(void **state) +{ + struct mtd_dev_info mtd; + loff_t seek; + int eb = 12; + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + seek = (loff_t)eb * mtd.eb_size; + expect_ioctl(MEMSETBADBLOCK, 0, &seek, sizeof(seek)); + int r = mtd_mark_bad(&mtd, 4, eb); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_mtd_is_bad(void **state) +{ + struct mtd_dev_info mtd; + loff_t seek; + int eb = 0x42; + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + seek = (loff_t)eb * mtd.eb_size; + expect_ioctl(MEMGETBADBLOCK, 0, &seek, sizeof(seek)); + int r = mtd_is_bad(&mtd, 4, eb); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_mtd_lock(void **state) +{ + int eb = 0xBA; + struct mtd_dev_info mtd; + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + struct erase_info_user ei; + memset(&ei, 0, sizeof(ei)); + ei.start = eb * mtd.eb_size; + ei.length = mtd.eb_size; + expect_ioctl(MEMLOCK, 0, &ei, sizeof(ei)); + int r = mtd_lock(&mtd, 4, eb); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_mtd_unlock(void **state) +{ + int eb = 0xBA; + struct mtd_dev_info mtd; + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + struct erase_info_user ei; + memset(&ei, 0, sizeof(ei)); + ei.start = eb * mtd.eb_size; + ei.length = mtd.eb_size; + expect_ioctl(MEMUNLOCK, 0, &ei, sizeof(ei)); + int r = mtd_unlock(&mtd, 4, eb); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_mtd_is_locked(void **state) +{ + int eb = 0xBA; + struct mtd_dev_info mtd; + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + struct erase_info_user ei; + memset(&ei, 0, sizeof(ei)); + ei.start = eb * mtd.eb_size; + ei.length = mtd.eb_size; + expect_ioctl(MEMISLOCKED, 0, &ei, sizeof(ei)); + int r = mtd_is_locked(&mtd, 4, eb); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_mtd_regioninfo(void **state) +{ + struct region_info_user req; + struct region_info_user rr; + memset(&req, 0, sizeof(req)); + memset(&rr, 0, sizeof(rr)); + int mock_fd = 4; + int regidx = 0xAA; + rr.regionindex = regidx; + expect_ioctl(MEMGETREGIONINFO, 0, &rr, sizeof(rr)); + int r = mtd_regioninfo(mock_fd, regidx, &req); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_mtd_erase_multi(void **state) +{ + struct libmtd *lib = mock_libmtd_open(); + struct mtd_dev_info mtd; + struct erase_info_user ei; + struct erase_info_user64 ei64; + int eb = 0x3C; + int blocks = 3; + memset(&ei, 0, sizeof(ei)); + memset(&ei64, 0, sizeof(ei64)); + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + ei64.start = (uint64_t)eb * mtd.eb_size; + ei64.length = (uint64_t)mtd.eb_size * blocks; + ei.start = ei64.start; + ei.length = ei64.length; + /* non offs64 first */ + lib->offs64_ioctls = OFFS64_IOCTLS_NOT_SUPPORTED; + expect_ioctl(MEMERASE, 0, &ei, sizeof(ei)); + int r = mtd_erase_multi(lib, &mtd, 4, eb, blocks); + assert_int_equal(r, 0); + + lib->offs64_ioctls = OFFS64_IOCTLS_SUPPORTED; + expect_ioctl(MEMERASE64, 0, &ei64, sizeof(ei64)); + r = mtd_erase_multi(lib, &mtd, 4, eb, blocks); + assert_int_equal(r, 0); + + libmtd_close(lib); + (void) state; +} + +/* this is the same as above but with blocks == 1 and a + * different function call. + * libmtd is mapping mtd_erase to mtd_erase_multi with 1 block + */ +static void test_mtd_erase(void **state) +{ + struct libmtd *lib = mock_libmtd_open(); + struct mtd_dev_info mtd; + struct erase_info_user ei; + struct erase_info_user64 ei64; + int eb = 0x3C; + int blocks = 1; + memset(&ei, 0, sizeof(ei)); + memset(&ei64, 0, sizeof(ei64)); + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + ei64.start = (uint64_t)eb * mtd.eb_size; + ei64.length = (uint64_t)mtd.eb_size * blocks; + ei.start = ei64.start; + ei.length = ei64.length; + /* non offs64 first */ + lib->offs64_ioctls = OFFS64_IOCTLS_NOT_SUPPORTED; + expect_ioctl(MEMERASE, 0, &ei, sizeof(ei)); + int r = mtd_erase(lib, &mtd, 4, eb); + assert_int_equal(r, 0); + + lib->offs64_ioctls = OFFS64_IOCTLS_SUPPORTED; + expect_ioctl(MEMERASE64, 0, &ei64, sizeof(ei64)); + r = mtd_erase(lib, &mtd, 4, eb); + assert_int_equal(r, 0); + + libmtd_close(lib); + (void) state; + +} + +static void test_mtd_read(void **state) +{ + int mock_fd = 4; + int eb = 0xE0; + int offs = 43; + int len = 28; + off_t seek; + char buf[28]; + struct mtd_dev_info mtd; + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + seek = (off_t)eb * mtd.eb_size + offs; + expect_lseek(seek, SEEK_SET, seek); + expect_read(len, len); + int r = mtd_read(&mtd, mock_fd, eb, offs, &buf, len); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_mtd_write_nooob(void **state) +{ + struct libmtd *lib = mock_libmtd_open(); + int mock_fd = 4; + int eb = 0xE0; + int offs = 64; + int len = 64; + off_t seek; + char buf[64]; + memset(buf, 0xAA, len); + struct mtd_dev_info mtd; + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + mtd.subpage_size = 64; + seek = (off_t)eb * mtd.eb_size + offs; + expect_lseek(seek, SEEK_SET, seek); + expect_write(buf, len, len); + int r = mtd_write(lib, &mtd, mock_fd, eb, offs, buf, len, NULL, 0, 0); + assert_int_equal(r, 0); + + libmtd_close(lib); + (void)state; +} + +static void test_mtd_write_withoob(void **state) +{ + struct libmtd *lib = mock_libmtd_open(); + int mock_fd = 4; + int eb = 0xE0; + int offs = 64; + int len = 64; + int oob_len = 64; + uint8_t mode = 3; + off_t seek; + char buf[64], oob_data[64]; + struct mtd_dev_info mtd; + struct mtd_write_req req; + memset(buf, 0xAA, len); + memset(oob_data, 0xBA, oob_len); + memset(&mtd, 0, sizeof(mtd)); + memset(&req, 0, sizeof(req)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + mtd.subpage_size = 64; + seek = (off_t)eb * mtd.eb_size + offs; + req.start = seek; + req.len = len; + req.ooblen = oob_len; + req.usr_data = (uint64_t)(unsigned long)buf; + req.usr_oob = (uint64_t)(unsigned long)oob_data; + req.mode = mode; + expect_ioctl(MEMWRITE, 0, &req, sizeof(req)); + int r = mtd_write(lib, &mtd, mock_fd, eb, offs, buf, len, oob_data, oob_len, mode); + assert_int_equal(r, 0); + + libmtd_close(lib); + (void) state; +} + +static void test_mtd_read_oob(void **state) +{ + struct libmtd *lib = mock_libmtd_open(); + struct mtd_dev_info mtd; + struct mtd_oob_buf64 oob64; + struct mtd_oob_buf oob; + int mock_fd = 4; + uint64_t start = 0, length = 64; + char buf[64]; + memset(buf, 0xCD, 64); + memset(&oob, 0, sizeof(oob)); + memset(&oob64, 0, sizeof(oob64)); + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + mtd.subpage_size = 64; + mtd.oob_size = 128; + oob64.start = start; + oob64.length = length; + oob64.usr_ptr = (uint64_t)(unsigned long)buf; + oob.start = oob64.start; + oob.length = oob64.length; + oob.ptr = buf; + + lib->offs64_ioctls = OFFS64_IOCTLS_NOT_SUPPORTED; + expect_ioctl(MEMREADOOB, 0, &oob, sizeof(oob)); + int r = mtd_read_oob(lib, &mtd, mock_fd, start, length, buf); + assert_int_equal(r, 0); + + lib->offs64_ioctls = OFFS64_IOCTLS_SUPPORTED; + expect_ioctl(MEMREADOOB64, 0, &oob64, sizeof(oob64)); + r = mtd_read_oob(lib, &mtd, mock_fd, start, length, buf); + assert_int_equal(r, 0); + + libmtd_close(lib); + (void) state; +} + +/* basically the same as above but write calls */ +static void test_mtd_write_oob(void **state) +{ + struct libmtd *lib = mock_libmtd_open(); + struct mtd_dev_info mtd; + struct mtd_oob_buf64 oob64; + struct mtd_oob_buf oob; + int mock_fd = 4; + uint64_t start = 0, length = 64; + char buf[64]; + memset(buf, 0xCD, 64); + memset(&oob, 0, sizeof(oob)); + memset(&oob64, 0, sizeof(oob64)); + memset(&mtd, 0, sizeof(mtd)); + mtd.bb_allowed = 1; + mtd.eb_cnt = 1024; + mtd.eb_size = 128; + mtd.subpage_size = 64; + mtd.oob_size = 128; + oob64.start = start; + oob64.length = length; + oob64.usr_ptr = (uint64_t)(unsigned long)buf; + oob.start = oob64.start; + oob.length = oob64.length; + oob.ptr = buf; + + lib->offs64_ioctls = OFFS64_IOCTLS_NOT_SUPPORTED; + expect_ioctl(MEMWRITEOOB, 0, &oob, sizeof(oob)); + int r = mtd_write_oob(lib, &mtd, mock_fd, start, length, buf); + assert_int_equal(r, 0); + + lib->offs64_ioctls = OFFS64_IOCTLS_SUPPORTED; + expect_ioctl(MEMWRITEOOB64, 0, &oob64, sizeof(oob64)); + r = mtd_write_oob(lib, &mtd, mock_fd, start, length, buf); + assert_int_equal(r, 0); + + libmtd_close(lib); + (void)state; +} + +static void test_mtd_get_info(void **state) +{ + struct libmtd *lib = mock_libmtd_open(); + struct mtd_info info; + memset(&info, 0, sizeof(info)); + int r = mtd_get_info(lib, &info); + assert_int_equal(info.sysfs_supported, 1); + assert_int_equal(info.highest_mtd_num, 0); + assert_int_equal(info.lowest_mtd_num, 0); + assert_int_equal(info.mtd_dev_cnt, 1); + assert_int_equal(r, 0); + + libmtd_close(lib); + (void)state; +} + +static void test_mtd_get_dev_info1(void **state) +{ + struct libmtd *lib = mock_libmtd_open(); + struct mtd_dev_info info; + int dev_num = 0; + memset(&info, 0, sizeof(info)); + expect_stat(SYSFS_ROOT "/class/mtd/mtd0", 0); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/dev", O_RDONLY, 0); + expect_read_real(50,0); + expect_read(1,0); + expect_close(3,1); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/name", O_RDONLY, 0); + expect_read_real(128,0); + expect_read(1,0); + expect_close(3,1); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/type", O_RDONLY, 4); + expect_read(65,0); + expect_read(1,0); + expect_close(4,0); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/erasesize", O_RDONLY, 0); + expect_read_real(50, 0); + expect_close(3,1); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/size", O_RDONLY, 0); + expect_read_real(50,0); + expect_close(3,1); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/writesize", O_RDONLY, 0); + expect_read_real(50,0); + expect_close(3,1); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/subpagesize", O_RDONLY, 0); + expect_read_real(50,0); + expect_close(3,1); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/oobsize", O_RDONLY, 0); + expect_read_real(50,0); + expect_close(3,1); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/numeraseregions", O_RDONLY, 0); + expect_read_real(50,0); + expect_close(3,1); + expect_open(SYSFS_ROOT "/class/mtd/mtd0/flags", O_RDONLY, 0); + expect_read_real(50,0); + expect_close(3,1); + int r = mtd_get_dev_info1(lib, dev_num, &info); + assert_int_equal(r, 0); + /* TODO check values */ + + libmtd_close(lib); + (void)state; +} + +int main(void) +{ + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_libmtd_open), + cmocka_unit_test(test_mtd_is_bad), + cmocka_unit_test(test_mtd_mark_bad), + cmocka_unit_test(test_mtd_lock), + cmocka_unit_test(test_mtd_unlock), + cmocka_unit_test(test_mtd_is_locked), + cmocka_unit_test(test_mtd_regioninfo), + cmocka_unit_test(test_mtd_erase_multi), + cmocka_unit_test(test_mtd_erase), + cmocka_unit_test(test_mtd_read), + cmocka_unit_test(test_mtd_write_nooob), + cmocka_unit_test(test_mtd_write_withoob), + cmocka_unit_test(test_mtd_read_oob), + cmocka_unit_test(test_mtd_write_oob), + cmocka_unit_test(test_mtd_dev_present), + cmocka_unit_test(test_mtd_get_info), + cmocka_unit_test(test_mtd_get_dev_info1), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +} |