Add unittests for libubi

Add unittests for most functions provided by
libubi

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

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);
+}