diff options
Diffstat (limited to 'tests/unittests')
| -rw-r--r-- | tests/unittests/libubi_test.c | 311 |
1 files changed, 311 insertions, 0 deletions
diff --git a/tests/unittests/libubi_test.c b/tests/unittests/libubi_test.c new file mode 100644 index 0000000..3e08e42 --- /dev/null +++ b/tests/unittests/libubi_test.c @@ -0,0 +1,311 @@ +#include <stdarg.h> +#include <setjmp.h> +#include <stddef.h> +#include <stdint.h> +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <sys/ioctl.h> +#include <cmocka.h> + +#include "libubi.h" +#include "test_lib.h" + + +static void test_libubi_open(void **state) +{ + libubi_t lib = NULL; + expect_open(SYSFS_ROOT "/class/ubi", O_RDONLY, 4); + expect_close(4,0); + expect_open(SYSFS_ROOT "/class/ubi/version", O_RDONLY, 0); + expect_read_real(50,0); + expect_close(3,1); + + lib = libubi_open(); + assert_non_null(lib); + libubi_close(lib); + (void) state; +} + +static void test_ubi_vol_block_create(void **state) +{ + int mock_fd = 1; + expect_ioctl_short(UBI_IOCVOLCRBLK, 0); + int r = ubi_vol_block_create(mock_fd); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_ubi_vol_block_remove(void **state) +{ + int mock_fd = 1; + expect_ioctl_short(UBI_IOCVOLRMBLK, 0); + int r = ubi_vol_block_remove(mock_fd); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_ubi_leb_unmap(void **state) +{ + int mock_fd = 1; + int lnum = 12; + expect_ioctl(UBI_IOCEBUNMAP, 0, &lnum, sizeof(lnum)); + int r = ubi_leb_unmap(mock_fd, lnum); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_ubi_is_mapped(void **state) +{ + int mock_fd = 1; + int lnum = 1; + expect_ioctl(UBI_IOCEBISMAP, 0, &lnum, sizeof(lnum)); + int r = ubi_is_mapped(mock_fd, lnum); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_ubi_update_start(void **state) +{ + int mock_fd = 1; + long long bytes = 0x1234; + + expect_ioctl(UBI_IOCVOLUP, 0, &bytes, sizeof(bytes)); + int r = ubi_update_start(NULL, mock_fd, bytes); + assert_int_equal(r, 0); + (void) state; +} + +static libubi_t mock_libubi_open() +{ + expect_open(SYSFS_ROOT "/class/ubi", O_RDONLY, 4); + expect_close(4,0); + expect_open(SYSFS_ROOT "/class/ubi/version", O_RDONLY, 0); + expect_read_real(50,0); + expect_close(3,1); + libubi_t lib = libubi_open(); + assert_non_null(lib); + return lib; +} + +static void test_ubi_dev_present(void **state) +{ + libubi_t lib = mock_libubi_open(); + expect_stat(SYSFS_ROOT "/class/ubi/ubi0", 0); + int r = ubi_dev_present(lib, 0); + assert_int_equal(r, 1); + + libubi_close(lib); + (void) state; +} + +static void test_ubi_rsvol(void **state) +{ + const char *node = "/foo"; + int vol_id = 0; + long long bytes = 0xadadaf; + struct ubi_rsvol_req req; + memset(&req, 0, sizeof(req)); + req.bytes = bytes; + req.vol_id = vol_id; + expect_open(node, O_RDONLY, 4); + expect_ioctl(UBI_IOCRSVOL, 0, &req, sizeof(req)); + expect_close(4, 0); + int r = ubi_rsvol(NULL, node, vol_id, bytes); + assert_int_equal(r, 0); + + (void) state; +} + +static void test_ubi_rnvols(void **state) +{ + libubi_t lib = mock_libubi_open(); + const char *node = "/foo"; + struct ubi_rnvol_req req; + memset(&req, 0xaf, sizeof(req)); + expect_open(node, O_RDONLY, 4); + expect_ioctl(UBI_IOCRNVOL, 0, &req, sizeof(req)); + expect_close(4, 0); + int r = ubi_rnvols(lib, node, &req); + assert_int_equal(r, 0); + + libubi_close(lib); + (void) state; +} + +static void test_ubi_rmvol(void **state) +{ + libubi_t lib = mock_libubi_open(); + const char *node = "/foo"; + int vol_id = 12; + expect_open(node, O_RDONLY, 4); + expect_ioctl(UBI_IOCRMVOL, 0, &vol_id, sizeof(vol_id)); + expect_close(4, 0); + int r = ubi_rmvol(lib, node, vol_id); + assert_int_equal(r, 0); + + libubi_close(lib); + (void) state; +} + +static void test_ubi_leb_change_start(void **state) +{ + libubi_t lib = mock_libubi_open(); + int mock_fd = 1; + int lnum = 12; + int bytes = 48; + struct ubi_leb_change_req req; + memset(&req, 0, sizeof(req)); + req.lnum = lnum; + req.bytes = bytes; + req.dtype = 3; + expect_ioctl(UBI_IOCEBCH, 0, &req, sizeof(req)); + int r = ubi_leb_change_start(lib, mock_fd, lnum, bytes); + assert_int_equal(r, 0); + + libubi_close(lib); + (void) state; +} + +static void test_ubi_get_info(void **state) +{ + libubi_t lib = mock_libubi_open(); + struct ubi_info info; + expect_open(SYSFS_ROOT "/class/misc/ubi_ctrl/dev", O_RDONLY, 0); + expect_read_real(50,0); + expect_read(1,0); + expect_close(3,1); + expect_open(SYSFS_ROOT "/class/ubi/version", O_RDONLY, 0); + expect_read_real(50,0); + expect_close(3,1); + int r = ubi_get_info(lib, &info); + assert_int_equal(r, 0); + assert_int_equal(info.dev_count, 1); + + libubi_close(lib); + (void) state; +} + +static void test_ubi_mkvol(void **state) +{ + libubi_t lib = mock_libubi_open(); + const char *node = "/foo"; + const char *vol_name = "testvol"; + int vol_id = 12; + struct ubi_mkvol_request req; + struct ubi_mkvol_req rr; + memset(&rr, 0, sizeof(rr)); + memset(&req, 0, sizeof(req)); + req.vol_id = vol_id; + req.name = vol_name; + rr.vol_id = vol_id; + rr.name_len = strlen(vol_name); + strncpy(rr.name, vol_name, UBI_MAX_VOLUME_NAME + 1); + expect_open(node, O_RDONLY, 3); + expect_ioctl(UBI_IOCMKVOL, 0, &rr, sizeof(rr)); + expect_close(3,0); + int r = ubi_mkvol(lib, node, &req); + assert_int_equal(r, 0); + assert_int_equal(req.vol_id, vol_id); + + libubi_close(lib); + (void) state; +} + +void test_ubi_remove_dev(void **state) +{ + const char *node = "/foo"; + libubi_t lib = mock_libubi_open(); + int ubi_dev = 0xAA; + expect_open(node, O_RDONLY, 4); + expect_ioctl(UBI_IOCDET, 0, &ubi_dev, sizeof(ubi_dev)); + expect_close(4,0); + int r = ubi_remove_dev(lib, node, ubi_dev); + assert_int_equal(r, 0); + + libubi_close(lib); + (void) state; +} + +void test_ubi_attach(void **state) +{ + const char *node = "/foo"; + struct ubi_attach_request req; + struct ubi_attach_req rr; + memset(&req, 0, sizeof(req)); + memset(&rr, 0, sizeof(rr)); + libubi_t lib = mock_libubi_open(); + req.dev_num = 1; + req.mtd_num = 1; + rr.ubi_num = 1; + rr.mtd_num = 1; + expect_open(node, O_RDONLY, 4); + expect_ioctl(UBI_IOCATT, 0, &rr, sizeof(rr)); + expect_close(4,0); + + int r = ubi_attach(lib, node, &req); + assert_int_equal(r, 0); + + libubi_close(lib); + (void) state; +} + +void test_ubi_set_property(void **state) +{ + int mock_fd = 1; + uint8_t prop = 0xad; + uint64_t val = 0xaabbccdd; + struct ubi_set_vol_prop_req req; + memset(&req, 0, sizeof(req)); + req.property = prop; + req.value = val; + expect_ioctl(UBI_IOCSETVOLPROP, 0, &req, sizeof(req)); + int r = ubi_set_property(mock_fd, prop, val); + assert_int_equal(r,0); + + (void)state; +} + +/* functions to test + * ubi_get_vol_info + * ubi_get_vol_info1 + * ubi_get_vol_info1_nm + * ubi_get_dev_info1 + * ubi_get_dev_info + * ubi_probe_node + * ubi_detach_mtd + * ubi_detach + * mtd_num2ubi_dev + */ + + +int main(void) +{ + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_libubi_open), + cmocka_unit_test(test_ubi_vol_block_create), + cmocka_unit_test(test_ubi_vol_block_remove), + cmocka_unit_test(test_ubi_update_start), + cmocka_unit_test(test_ubi_dev_present), + cmocka_unit_test(test_ubi_rsvol), + cmocka_unit_test(test_ubi_rmvol), + cmocka_unit_test(test_ubi_rnvols), + cmocka_unit_test(test_ubi_leb_change_start), + cmocka_unit_test(test_ubi_get_info), + cmocka_unit_test(test_ubi_mkvol), + cmocka_unit_test(test_ubi_leb_unmap), + cmocka_unit_test(test_ubi_is_mapped), + cmocka_unit_test(test_ubi_remove_dev), + cmocka_unit_test(test_ubi_attach), + cmocka_unit_test(test_ubi_set_property), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +} |