ztest_test_new.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_TESTSUITE_ZTEST_TEST_H_
#define ZEPHYR_TESTSUITE_ZTEST_TEST_H_
 
#include <app_memory/app_memdomain.h>
#include <init.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct ztest_unit_test {
        const char *test_suite_name;
        const char *name;
        void (*test)(void *data);
        uint32_t thread_options;
};
 
extern struct ztest_unit_test _ztest_unit_test_list_start[];
extern struct ztest_unit_test _ztest_unit_test_list_end[];
 
struct ztest_suite_stats {
        uint32_t run_count;
        uint32_t skip_count;
        uint32_t fail_count;
};
 
struct ztest_suite_node {
        const char *name;
        void *(*setup)(void);
        void (*before)(void *data);
        void (*after)(void *data);
        void (*teardown)(void *data);
        bool (*predicate)(const void *state);
        struct ztest_suite_stats stats;
};
 
extern struct ztest_suite_node _ztest_suite_node_list_start[];
extern struct ztest_suite_node _ztest_suite_node_list_end[];
 
#define ZTEST_SUITE(SUITE_NAME, PREDICATE, setup_fn, before_fn, after_fn, teardown_fn)  \
        static STRUCT_SECTION_ITERABLE(ztest_suite_node,                                \
                                       UTIL_CAT(z_ztest_test_node_, SUITE_NAME)) = {    \
                .name = STRINGIFY(SUITE_NAME),                                          \
                .setup = (setup_fn),                                                    \
                .before = (before_fn),                                                  \
                .after = (after_fn),                                                    \
                .teardown = (teardown_fn),                                              \
                .predicate = PREDICATE,                                                 \
        }
 
int ztest_run_test_suites(const void *state);
 
void ztest_verify_all_test_suites_ran(void);
 
int z_ztest_run_test_suite(const char *name);
 
void ztest_test_fail(void);
 
void ztest_test_pass(void);
 
void ztest_test_skip(void);
 
static inline void unit_test_noop(void)
{
}
 
#define Z_TEST(suite, fn, t_options, use_fixture)                                                  \
        static void _##suite##_##fn##_wrapper(void *data);                                         \
        static void suite##_##fn(                                                                  \
                COND_CODE_1(use_fixture, (struct suite##_fixture *this), (void)));                 \
        static STRUCT_SECTION_ITERABLE(ztest_unit_test, z_ztest_unit_test_##suite##_##fn) = {      \
                .test_suite_name = STRINGIFY(suite),                                               \
                .name = STRINGIFY(fn),                                                             \
                .test = (_##suite##_##fn##_wrapper),                                               \
                .thread_options = t_options,                                                       \
        };                                                                                         \
        static void _##suite##_##fn##_wrapper(void *data)                                          \
        {                                                                                          \
                COND_CODE_1(use_fixture, (suite##_##fn((struct suite##_fixture *)data);),          \
                            (ARG_UNUSED(data); suite##_##fn();))                                   \
        }                                                                                          \
        static inline void suite##_##fn(                                                           \
                COND_CODE_1(use_fixture, (struct suite##_fixture *this), (void)))
 
#define Z_ZTEST(suite, fn, t_options) Z_TEST(suite, fn, t_options, 0)
#define Z_ZTEST_F(suite, fn, t_options) Z_TEST(suite, fn, t_options, 1)
 
#define ZTEST(suite, fn) Z_ZTEST(suite, fn, 0)
 
#define ZTEST_USER(suite, fn) Z_ZTEST(suite, fn, COND_CODE_1(CONFIG_USERSPACE, (K_USER), (0)))
 
#define ZTEST_F(suite, fn) Z_ZTEST_F(suite, fn, 0)
 
#define ZTEST_USER_F(suite, fn) Z_ZTEST_F(suite, fn, COND_CODE_1(CONFIG_USERSPACE, (K_USER), (0)))
 
typedef void (*ztest_rule_cb)(const struct ztest_unit_test *test, void *data);
 
struct ztest_test_rule {
        ztest_rule_cb before_each;
        ztest_rule_cb after_each;
};
 
#define ZTEST_RULE(name, before_each_fn, after_each_fn)                                            \
        static STRUCT_SECTION_ITERABLE(ztest_test_rule, z_ztest_test_rule_##name) = {              \
                .before_each = (before_each_fn),                                                   \
                .after_each = (after_each_fn),                                                     \
        }
 
extern struct ztest_test_rule _ztest_test_rule_list_start[];
extern struct ztest_test_rule _ztest_test_rule_list_end[];
 
void ztest_simple_1cpu_before(void *data);
 
void ztest_simple_1cpu_after(void *data);
 
/* definitions for use with testing application shared memory   */
#ifdef CONFIG_USERSPACE
#define ZTEST_DMEM K_APP_DMEM(ztest_mem_partition)
#define ZTEST_BMEM K_APP_BMEM(ztest_mem_partition)
#define ZTEST_SECTION K_APP_DMEM_SECTION(ztest_mem_partition)
extern struct k_mem_partition ztest_mem_partition;
#else
#define ZTEST_DMEM
#define ZTEST_BMEM
#define ZTEST_SECTION .data
#endif
 
#define ztest_run_test_suite(suite) z_ztest_run_test_suite(STRINGIFY(suite))
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_TESTSUITE_ZTEST_TEST_H_ */