]> git.ipfire.org Git - thirdparty/kmod.git/blobdiff - testsuite/testsuite.h
ci: add clang-format action
[thirdparty/kmod.git] / testsuite / testsuite.h
index e4f3ecfac8492ac1558be8495fa4288a6104d38b..59d29c132882283bb3daf47d8586f7bf621a4590 100644 (file)
@@ -1,25 +1,15 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
 /*
  * Copyright (C) 2012-2013  ProFUSION embedded systems
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #pragma once
 
 #include <stdbool.h>
 #include <stdarg.h>
+#include <stdio.h>
+
+#include <shared/macro.h>
 
 struct test;
 typedef int (*testfunc)(const struct test *t);
@@ -86,6 +76,12 @@ struct test {
                /* File with correct stderr */
                const char *err;
 
+               /*
+                * whether to treat the correct files as regex to the real
+                * output
+                */
+               bool regex;
+
                /*
                 * Vector with pair of files
                 * key = correct file
@@ -93,63 +89,82 @@ struct test {
                 */
                const struct keyval *files;
        } output;
+       /* comma-separated list of loaded modules at the end of the test */
+       const char *modules_loaded;
+       const char *modules_not_loaded;
        testfunc func;
        const char *config[_TC_LAST];
        const char *path;
        const struct keyval *env_vars;
        bool need_spawn;
        bool expected_fail;
-};
-
-
-const struct test *test_find(const struct test *tests[], const char *name);
-int test_init(int argc, char *const argv[], const struct test *tests[]);
+       /* allow to skip tests that don't meet compile-time dependencies */
+       bool skip;
+       bool print_outputs;
+} __attribute__((aligned(8)));
+
+int test_init(const struct test *start, const struct test *stop, int argc,
+             char *const argv[]);
+const struct test *test_find(const struct test *start, const struct test *stop,
+                            const char *name);
 int test_spawn_prog(const char *prog, const char *const args[]);
-
 int test_run(const struct test *t);
 
-#define TS_EXPORT __attribute__ ((visibility("default")))
+#define TS_EXPORT __attribute__((visibility("default")))
 
-#define _LOG(prefix, fmt, ...) printf("TESTSUITE: " prefix fmt, ## __VA_ARGS__)
-#define LOG(fmt, ...) _LOG("", fmt, ## __VA_ARGS__)
-#define WARN(fmt, ...) _LOG("WARN: ", fmt, ## __VA_ARGS__)
-#define ERR(fmt, ...) _LOG("ERR: ", fmt, ## __VA_ARGS__)
+#define _LOG(prefix, fmt, ...) printf("TESTSUITE: " prefix fmt, ##__VA_ARGS__)
+#define LOG(fmt, ...) _LOG("", fmt, ##__VA_ARGS__)
+#define WARN(fmt, ...) _LOG("WARN: ", fmt, ##__VA_ARGS__)
+#define ERR(fmt, ...) _LOG("ERR: ", fmt, ##__VA_ARGS__)
+
+#define assert_return(expr, r)                                                  \
+       do {                                                                    \
+               if ((!(expr))) {                                                \
+                       ERR("Failed assertion: " #expr " %s:%d %s\n", __FILE__, \
+                           __LINE__, __PRETTY_FUNCTION__);                     \
+                       return (r);                                             \
+               }                                                               \
+       } while (false)
 
 /* Test definitions */
-#define DEFINE_TEST(_name, ...) \
-       const struct test s##_name = { \
-               .name = #_name, \
-               .func = _name, \
-               ## __VA_ARGS__ \
+#define DEFINE_TEST_WITH_FUNC(_name, _func, ...)                             \
+       static const struct test UNIQ(s##_name)                              \
+               __attribute__((used, section("kmod_tests"), aligned(8))) = { \
+                       .name = #_name, .func = _func, ##__VA_ARGS__         \
+               };
+
+#define DEFINE_TEST(_name, ...) DEFINE_TEST_WITH_FUNC(_name, _name, __VA_ARGS__)
+
+#define TESTSUITE_MAIN()                                                                 \
+       extern struct test __start_kmod_tests[]                                          \
+               __attribute__((weak, visibility("hidden")));                             \
+       extern struct test __stop_kmod_tests[]                                           \
+               __attribute__((weak, visibility("hidden")));                             \
+       int main(int argc, char *argv[])                                                 \
+       {                                                                                \
+               const struct test *t;                                                    \
+               int arg;                                                                 \
+                                                                                         \
+               arg = test_init(__start_kmod_tests, __stop_kmod_tests, argc, argv);      \
+               if (arg == 0)                                                            \
+                       return 0;                                                        \
+               if (arg < 0)                                                             \
+                       return EXIT_FAILURE;                                             \
+                                                                                         \
+               if (arg < argc) {                                                        \
+                       t = test_find(__start_kmod_tests, __stop_kmod_tests, argv[arg]); \
+                       if (t == NULL) {                                                 \
+                               fprintf(stderr, "could not find test %s\n", argv[arg]);  \
+                               exit(EXIT_FAILURE);                                      \
+                       }                                                                \
+                                                                                         \
+                       return test_run(t);                                              \
+               }                                                                        \
+                                                                                         \
+               for (t = __start_kmod_tests; t < __stop_kmod_tests; t++) {               \
+                       if (test_run(t) != 0)                                            \
+                               exit(EXIT_FAILURE);                                      \
+               }                                                                        \
+                                                                                         \
+               exit(EXIT_SUCCESS);                                                      \
        }
-
-#define TESTSUITE_MAIN(_tests) \
-       int main(int argc, char *argv[])                        \
-       {                                                       \
-               const struct test *t;                           \
-               int arg;                                        \
-               size_t i;                                       \
-                                                               \
-               arg = test_init(argc, argv, tests);             \
-               if (arg == 0)                                   \
-                       return 0;                               \
-                                                               \
-               if (arg < argc) {                               \
-                       t = test_find(tests, argv[arg]);        \
-                       if (t == NULL) {                        \
-                               fprintf(stderr, "could not find test %s\n", argv[arg]);\
-                               exit(EXIT_FAILURE);             \
-                       }                                       \
-                                                               \
-                       return test_run(t);                     \
-               }                                               \
-                                                               \
-               for (i = 0; tests[i] != NULL; i++) {            \
-                       if (test_run(tests[i]) != 0)            \
-                               exit(EXIT_FAILURE);             \
-               }                                               \
-                                                               \
-               exit(EXIT_SUCCESS);                             \
-       }                                                       \
-
-#define __noreturn __attribute__((noreturn))