summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorDaniel Walter <dwalter@sigma-star.at>2016-08-31 10:09:15 +0200
committerDavid Oberhollenzer <david.oberhollenzer@sigma-star.at>2016-11-17 11:36:56 +0100
commit005cef532697be0746c72632f94cfeae67a2a187 (patch)
treef6eb6fa15410e56b56de23fd2d0bd43aaed8419c
parent0033921084e9b06db3655b002b961616d9df1571 (diff)
Add unittests for libubi
Add unittests for most functions provided by libubi Signed-off-by: Daniel Walter <dwalter@sigma-star.at>
-rw-r--r--tests/unittests/libubi_test.c311
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);
+}