test: compression: Convert to unit test framework

Adjust this test to use the unit test framework. Drop the two existing
commands for running the tests and replace them with a single
'ut compression' command, with sub-commands.

Signed-off-by: Simon Glass <sjg@chromium.org>
[trini: Continue to have ret = run_test_internal(...) in run_test so ret
is always initialized]
Signed-off-by: Tom Rini <trini@konsulko.com>

diff --git a/include/test/compression.h b/include/test/compression.h
new file mode 100644 (file)
index 0000000..646f117
--- /dev/null
+++ b/include/test/compression.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2017 Google, Inc
+ * Written by Simon Glass <sjg@chromium.org>
+ *
+ * SPDX-License-Identifier:     GPL-2.0+
+ */
+
+#ifndef __TEST_COMPRESSION_H__
+#define __TEST_COMPRESSION_H__
+
+#include <test/test.h>
+
+/* Declare a new compression test */
+#define COMPRESSION_TEST(_name, _flags) \
+               UNIT_TEST(_name, _flags, compression_test)
+
+#endif /* __TEST_ENV_H__ */

diff --git a/include/test/suites.h b/include/test/suites.h
index 6b900a8f5947818bdc3fea15b10d71c4e79ac8a0..5f2e519084f2f3e6c92d9214f253217e24884d4b 100644 (file)
--- a/include/test/suites.h
+++ b/include/test/suites.h
@@ -28,5 +28,6 @@ int do_ut_dm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
 int do_ut_env(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
 int do_ut_overlay(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
 int do_ut_time(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+int do_ut_compression(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
 
 #endif /* __TEST_SUITES_H__ */

diff --git a/test/cmd_ut.c b/test/cmd_ut.c
index d860dd72f0b001817a99ebb565af060376433004..6b24f463f3329d2eb300e1999e94a636cfb89ab0 100644 (file)
--- a/test/cmd_ut.c
+++ b/test/cmd_ut.c
@@ -50,6 +50,10 @@ static cmd_tbl_t cmd_ut_sub[] = {
 #ifdef CONFIG_UT_TIME
        U_BOOT_CMD_MKENT(time, CONFIG_SYS_MAXARGS, 1, do_ut_time, "", ""),
 #endif
+#ifdef CONFIG_SANDBOX
+       U_BOOT_CMD_MKENT(compression, CONFIG_SYS_MAXARGS, 1, do_ut_compression,
+                        "", ""),
+#endif
 };
 
 static int do_ut_all(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
@@ -101,6 +105,9 @@ static char ut_help_text[] =
 #endif
 #ifdef CONFIG_UT_TIME
        "ut time - Very basic test of time functions\n"
+#endif
+#ifdef CONFIG_SANDBOX
+       "ut compression - Test compressors and bootm decompression\n"
 #endif
        ;
 #endif

diff --git a/test/compression.c b/test/compression.c
index 82eed846a9486e5de7be04f113915dc9de6ee30f..fe27ad66ea44f27167643feac988daa67c68ce2a 100644 (file)
--- a/test/compression.c
+++ b/test/compression.c
@@ -4,8 +4,6 @@
  * SPDX-License-Identifier:    GPL-2.0+
  */
 
-#define DEBUG
-
 #include <common.h>
 #include <bootm.h>
 #include <command.h>
@@ -21,6 +19,9 @@
 #include <lzma/LzmaTools.h>
 
 #include <linux/lzo.h>
+#include <test/compression.h>
+#include <test/suites.h>
+#include <test/ut.h>
 
 static const char plain[] =
        "I am a highly compressable bit of text.\n"
@@ -120,10 +121,11 @@ static const unsigned long lz4_compressed_size = 276;
 
 #define TEST_BUFFER_SIZE       512
 
-typedef int (*mutate_func)(void *, unsigned long, void *, unsigned long,
-                          unsigned long *);
+typedef int (*mutate_func)(struct unit_test_state *uts, void *, unsigned long,
+                          void *, unsigned long, unsigned long *);
 
-static int compress_using_gzip(void *in, unsigned long in_size,
+static int compress_using_gzip(struct unit_test_state *uts,
+                              void *in, unsigned long in_size,
                               void *out, unsigned long out_max,
                               unsigned long *out_size)
 {
@@ -137,7 +139,8 @@ static int compress_using_gzip(void *in, unsigned long in_size,
        return ret;
 }
 
-static int uncompress_using_gzip(void *in, unsigned long in_size,
+static int uncompress_using_gzip(struct unit_test_state *uts,
+                                void *in, unsigned long in_size,
                                 void *out, unsigned long out_max,
                                 unsigned long *out_size)
 {
@@ -151,13 +154,14 @@ static int uncompress_using_gzip(void *in, unsigned long in_size,
        return ret;
 }
 
-static int compress_using_bzip2(void *in, unsigned long in_size,
+static int compress_using_bzip2(struct unit_test_state *uts,
+                               void *in, unsigned long in_size,
                                void *out, unsigned long out_max,
                                unsigned long *out_size)
 {
        /* There is no bzip2 compression in u-boot, so fake it. */
-       assert(in_size == strlen(plain));
-       assert(memcmp(plain, in, in_size) == 0);
+       ut_asserteq(in_size, strlen(plain));
+       ut_asserteq(0, memcmp(plain, in, in_size));
 
        if (bzip2_compressed_size > out_max)
                return -1;
@@ -169,7 +173,8 @@ static int compress_using_bzip2(void *in, unsigned long in_size,
        return 0;
 }
 
-static int uncompress_using_bzip2(void *in, unsigned long in_size,
+static int uncompress_using_bzip2(struct unit_test_state *uts,
+                                 void *in, unsigned long in_size,
                                  void *out, unsigned long out_max,
                                  unsigned long *out_size)
 {
@@ -184,13 +189,14 @@ static int uncompress_using_bzip2(void *in, unsigned long in_size,
        return (ret != BZ_OK);
 }
 
-static int compress_using_lzma(void *in, unsigned long in_size,
+static int compress_using_lzma(struct unit_test_state *uts,
+                              void *in, unsigned long in_size,
                               void *out, unsigned long out_max,
                               unsigned long *out_size)
 {
        /* There is no lzma compression in u-boot, so fake it. */
-       assert(in_size == strlen(plain));
-       assert(memcmp(plain, in, in_size) == 0);
+       ut_asserteq(in_size,  strlen(plain));
+       ut_asserteq(0, memcmp(plain, in, in_size));
 
        if (lzma_compressed_size > out_max)
                return -1;
@@ -202,7 +208,8 @@ static int compress_using_lzma(void *in, unsigned long in_size,
        return 0;
 }
 
-static int uncompress_using_lzma(void *in, unsigned long in_size,
+static int uncompress_using_lzma(struct unit_test_state *uts,
+                                void *in, unsigned long in_size,
                                 void *out, unsigned long out_max,
                                 unsigned long *out_size)
 {
@@ -216,13 +223,14 @@ static int uncompress_using_lzma(void *in, unsigned long in_size,
        return (ret != SZ_OK);
 }
 
-static int compress_using_lzo(void *in, unsigned long in_size,
+static int compress_using_lzo(struct unit_test_state *uts,
+                             void *in, unsigned long in_size,
                              void *out, unsigned long out_max,
                              unsigned long *out_size)
 {
        /* There is no lzo compression in u-boot, so fake it. */
-       assert(in_size == strlen(plain));
-       assert(memcmp(plain, in, in_size) == 0);
+       ut_asserteq(in_size,  strlen(plain));
+       ut_asserteq(0, memcmp(plain, in, in_size));
 
        if (lzo_compressed_size > out_max)
                return -1;
@@ -234,7 +242,8 @@ static int compress_using_lzo(void *in, unsigned long in_size,
        return 0;
 }
 
-static int uncompress_using_lzo(void *in, unsigned long in_size,
+static int uncompress_using_lzo(struct unit_test_state *uts,
+                               void *in, unsigned long in_size,
                                void *out, unsigned long out_max,
                                unsigned long *out_size)
 {
@@ -249,13 +258,14 @@ static int uncompress_using_lzo(void *in, unsigned long in_size,
        return (ret != LZO_E_OK);
 }
 
-static int compress_using_lz4(void *in, unsigned long in_size,
+static int compress_using_lz4(struct unit_test_state *uts,
+                             void *in, unsigned long in_size,
                              void *out, unsigned long out_max,
                              unsigned long *out_size)
 {
        /* There is no lz4 compression in u-boot, so fake it. */
-       assert(in_size == strlen(plain));
-       assert(memcmp(plain, in, in_size) == 0);
+       ut_asserteq(in_size,  strlen(plain));
+       ut_asserteq(0, memcmp(plain, in, in_size));
 
        if (lz4_compressed_size > out_max)
                return -1;
@@ -267,7 +277,8 @@ static int compress_using_lz4(void *in, unsigned long in_size,
        return 0;
 }
 
-static int uncompress_using_lz4(void *in, unsigned long in_size,
+static int uncompress_using_lz4(struct unit_test_state *uts,
+                               void *in, unsigned long in_size,
                                void *out, unsigned long out_max,
                                unsigned long *out_size)
 {
@@ -298,7 +309,7 @@ struct buf_state {
        void *compare_buf;
 };
 
-static int run_test_internal(char *name,
+static int run_test_internal(struct unit_test_state *uts, char *name,
                             mutate_func compress, mutate_func uncompress,
                             struct buf_state *buf)
 {
@@ -307,8 +318,9 @@ static int run_test_internal(char *name,
        /* Compress works as expected. */
        printf("\torig_size:%lu\n", buf->orig_size);
        memset(buf->compressed_buf, 'A', TEST_BUFFER_SIZE);
-       errcheck(compress(buf->orig_buf, buf->orig_size, buf->compressed_buf,
-                         buf->compressed_size, &buf->compressed_size) == 0);
+       errcheck(compress(uts, buf->orig_buf, buf->orig_size,
+                         buf->compressed_buf, buf->compressed_size,
+                         &buf->compressed_size) == 0);
        printf("\tcompressed_size:%lu\n", buf->compressed_size);
        errcheck(buf->compressed_size > 0);
        errcheck(buf->compressed_size < buf->orig_size);
@@ -317,7 +329,7 @@ static int run_test_internal(char *name,
        errcheck(((char *)buf->compressed_buf)[buf->compressed_size] == 'A');
 
        /* Uncompresses with space remaining. */
-       errcheck(uncompress(buf->compressed_buf, buf->compressed_size,
+       errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size,
                            buf->uncompressed_buf, buf->uncompressed_size,
                            &buf->uncompressed_size) == 0);
        printf("\tuncompressed_size:%lu\n", buf->uncompressed_size);
@@ -327,7 +339,7 @@ static int run_test_internal(char *name,
 
        /* Uncompresses with exactly the right size output buffer. */
        memset(buf->uncompressed_buf, 'A', TEST_BUFFER_SIZE);
-       errcheck(uncompress(buf->compressed_buf, buf->compressed_size,
+       errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size,
                            buf->uncompressed_buf, buf->orig_size,
                            &buf->uncompressed_size) == 0);
        errcheck(buf->uncompressed_size == buf->orig_size);
@@ -337,7 +349,7 @@ static int run_test_internal(char *name,
 
        /* Make sure compression does not over-run. */
        memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE);
-       ret = compress(buf->orig_buf, buf->orig_size,
+       ret = compress(uts, buf->orig_buf, buf->orig_size,
                       buf->compare_buf, buf->compressed_size - 1,
                       NULL);
        errcheck(((char *)buf->compare_buf)[buf->compressed_size] == 'A');
@@ -346,7 +358,7 @@ static int run_test_internal(char *name,
 
        /* Make sure decompression does not over-run. */
        memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE);
-       ret = uncompress(buf->compressed_buf, buf->compressed_size,
+       ret = uncompress(uts, buf->compressed_buf, buf->compressed_size,
                         buf->compare_buf, buf->uncompressed_size - 1,
                         NULL);
        errcheck(((char *)buf->compare_buf)[buf->uncompressed_size - 1] == 'A');
@@ -360,7 +372,8 @@ out:
        return ret;
 }
 
-static int run_test(char *name, mutate_func compress, mutate_func uncompress)
+static int run_test(struct unit_test_state *uts, char *name,
+                   mutate_func compress, mutate_func uncompress)
 {
        struct buf_state sbuf, *buf = &sbuf;
        int ret;
@@ -380,7 +393,7 @@ static int run_test(char *name, mutate_func compress, mutate_func uncompress)
        buf->compare_buf = malloc(buf->uncompressed_size);
        errcheck(buf->compare_buf);
 
-       ret = run_test_internal(name, compress, uncompress, buf);
+       ret = run_test_internal(uts, name, compress, uncompress, buf);
 out:
        printf(" %s: %s\n", name, ret == 0 ? "ok" : "FAILED");
 
@@ -391,23 +404,41 @@ out:
        return ret;
 }
 
-static int do_ut_compression(cmd_tbl_t *cmdtp, int flag, int argc,
-                            char *const argv[])
+static int compression_test_gzip(struct unit_test_state *uts)
 {
-       int err = 0;
+       return run_test(uts, "gzip", compress_using_gzip,
+                       uncompress_using_gzip);
+}
+COMPRESSION_TEST(compression_test_gzip, 0);
 
-       err += run_test("gzip", compress_using_gzip, uncompress_using_gzip);
-       err += run_test("bzip2", compress_using_bzip2, uncompress_using_bzip2);
-       err += run_test("lzma", compress_using_lzma, uncompress_using_lzma);
-       err += run_test("lzo", compress_using_lzo, uncompress_using_lzo);
-       err += run_test("lz4", compress_using_lz4, uncompress_using_lz4);
+static int compression_test_bzip2(struct unit_test_state *uts)
+{
+       return run_test(uts, "bzip2", compress_using_bzip2,
+                       uncompress_using_bzip2);
+}
+COMPRESSION_TEST(compression_test_bzip2, 0);
+
+static int compression_test_lzma(struct unit_test_state *uts)
+{
+       return run_test(uts, "lzma", compress_using_lzma,
+                       uncompress_using_lzma);
+}
+COMPRESSION_TEST(compression_test_lzma, 0);
 
-       printf("ut_compression %s\n", err == 0 ? "ok" : "FAILED");
+static int compression_test_lzo(struct unit_test_state *uts)
+{
+       return run_test(uts, "lzo", compress_using_lzo, uncompress_using_lzo);
+}
+COMPRESSION_TEST(compression_test_lzo, 0);
 
-       return err;
+static int compression_test_lz4(struct unit_test_state *uts)
+{
+       return run_test(uts, "lz4", compress_using_lz4, uncompress_using_lz4);
 }
+COMPRESSION_TEST(compression_test_lz4, 0);
 
-static int compress_using_none(void *in, unsigned long in_size,
+static int compress_using_none(struct unit_test_state *uts,
+                              void *in, unsigned long in_size,
                               void *out, unsigned long out_max,
                               unsigned long *out_size)
 {
@@ -425,7 +456,8 @@ static int compress_using_none(void *in, unsigned long in_size,
  * @compress:  Our function to compress data
  * @return 0 if OK, non-zero on failure
  */
-static int run_bootm_test(int comp_type, mutate_func compress)
+static int run_bootm_test(struct unit_test_state *uts, int comp_type,
+                         mutate_func compress)
 {
        ulong compress_size = 1024;
        void *compress_buff;
@@ -438,20 +470,18 @@ static int run_bootm_test(int comp_type, mutate_func compress)
        printf("Testing: %s\n", genimg_get_comp_name(comp_type));
        compress_buff = map_sysmem(image_start, 0);
        unc_len = strlen(plain);
-       compress((void *)plain, unc_len, compress_buff, compress_size,
+       compress(uts, (void *)plain, unc_len, compress_buff, compress_size,
                 &compress_size);
        err = bootm_decomp_image(comp_type, load_addr, image_start,
                                 IH_TYPE_KERNEL, map_sysmem(load_addr, 0),
                                 compress_buff, compress_size, unc_len,
                                 &load_end);
-       if (err)
-               return err;
+       ut_assertok(err);
        err = bootm_decomp_image(comp_type, load_addr, image_start,
                                 IH_TYPE_KERNEL, map_sysmem(load_addr, 0),
                                 compress_buff, compress_size, unc_len - 1,
                                 &load_end);
-       if (!err)
-               return -EINVAL;
+       ut_assert(err);
 
        /* We can't detect corruption when not decompressing */
        if (comp_type == IH_COMP_NONE)
@@ -462,35 +492,52 @@ static int run_bootm_test(int comp_type, mutate_func compress)
                                 IH_TYPE_KERNEL, map_sysmem(load_addr, 0),
                                 compress_buff, compress_size, 0x10000,
                                 &load_end);
-       if (!err)
-               return -EINVAL;
+       ut_assert(err);
 
        return 0;
 }
 
-static int do_ut_image_decomp(cmd_tbl_t *cmdtp, int flag, int argc,
-                             char *const argv[])
+static int compression_test_bootm_gzip(struct unit_test_state *uts)
 {
-       int err = 0;
+       return run_bootm_test(uts, IH_COMP_GZIP, compress_using_gzip);
+}
+COMPRESSION_TEST(compression_test_bootm_gzip, 0);
 
-       err = run_bootm_test(IH_COMP_GZIP, compress_using_gzip);
-       err |= run_bootm_test(IH_COMP_BZIP2, compress_using_bzip2);
-       err |= run_bootm_test(IH_COMP_LZMA, compress_using_lzma);
-       err |= run_bootm_test(IH_COMP_LZO, compress_using_lzo);
-       err |= run_bootm_test(IH_COMP_LZ4, compress_using_lz4);
-       err |= run_bootm_test(IH_COMP_NONE, compress_using_none);
+static int compression_test_bootm_bzip2(struct unit_test_state *uts)
+{
+       return run_bootm_test(uts, IH_COMP_BZIP2, compress_using_bzip2);
+}
+COMPRESSION_TEST(compression_test_bootm_bzip2, 0);
 
-       printf("ut_image_decomp %s\n", err == 0 ? "ok" : "FAILED");
+static int compression_test_bootm_lzma(struct unit_test_state *uts)
+{
+       return run_bootm_test(uts, IH_COMP_LZMA, compress_using_lzma);
+}
+COMPRESSION_TEST(compression_test_bootm_lzma, 0);
 
-       return 0;
+static int compression_test_bootm_lzo(struct unit_test_state *uts)
+{
+       return run_bootm_test(uts, IH_COMP_LZO, compress_using_lzo);
 }
+COMPRESSION_TEST(compression_test_bootm_lzo, 0);
 
-U_BOOT_CMD(
-       ut_compression, 5,      1,      do_ut_compression,
-       "Basic test of compressors: gzip bzip2 lzma lzo", ""
-);
+static int compression_test_bootm_lz4(struct unit_test_state *uts)
+{
+       return run_bootm_test(uts, IH_COMP_LZ4, compress_using_lz4);
+}
+COMPRESSION_TEST(compression_test_bootm_lz4, 0);
 
-U_BOOT_CMD(
-       ut_image_decomp,        5,      1, do_ut_image_decomp,
-       "Basic test of bootm decompression", ""
-);
+static int compression_test_bootm_none(struct unit_test_state *uts)
+{
+       return run_bootm_test(uts, IH_COMP_NONE, compress_using_none);
+}
+COMPRESSION_TEST(compression_test_bootm_none, 0);
+
+int do_ut_compression(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+       struct unit_test *tests = ll_entry_start(struct unit_test,
+                                                compression_test);
+       const int n_ents = ll_entry_count(struct unit_test, compression_test);
+
+       return cmd_ut_category("compression", tests, n_ents, argc, argv);
+}