Add unittests for libubi

Add unittests for most functions provided by
libubi

Signed-off-by: Daniel Walter <dwalter@sigma-star.at>

diff --git a/tests/unittests/libubi_test.c b/tests/unittests/libubi_test.c
new file mode 100644 (file)
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);
+}