include/test/test.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Copyright (c) 2013 Google, Inc.
   4  */
   5
   6 #ifndef __TEST_TEST_H
   7 #define __TEST_TEST_H
   8
   9 #include <malloc.h>
  10 #include <linux/bitops.h>
  11
  12 /*
  13  * struct unit_test_state - Entire state of test system
  14  *
  15  * @fail_count: Number of tests that failed
  16  * @skip_count: Number of tests that were skipped
  17  * @start: Store the starting mallinfo when doing leak test
  18  * @of_live: true to use livetree if available, false to use flattree
  19  * @of_root: Record of the livetree root node (used for setting up tests)
  20  * @root: Root device
  21  * @testdev: Test device
  22  * @force_fail_alloc: Force all memory allocs to fail
  23  * @skip_post_probe: Skip uclass post-probe processing
  24  * @fdt_chksum: crc8 of the device tree contents
  25  * @fdt_copy: Copy of the device tree
  26  * @fdt_size: Size of the device-tree copy
  27  * @other_fdt: Buffer for the other FDT (UT_TESTF_OTHER_FDT)
  28  * @other_fdt_size: Size of the other FDT (UT_TESTF_OTHER_FDT)
  29  * @of_other: Live tree for the other FDT
  30  * @runs_per_test: Number of times to run each test (typically 1)
  31  * @expect_str: Temporary string used to hold expected string value
  32  * @actual_str: Temporary string used to hold actual string value
  33  */
  34 struct unit_test_state {
  35         int fail_count;
  36         int skip_count;
  37         struct mallinfo start;
  38         struct device_node *of_root;
  39         bool of_live;
  40         struct udevice *root;
  41         struct udevice *testdev;
  42         int force_fail_alloc;
  43         int skip_post_probe;
  44         uint fdt_chksum;
  45         void *fdt_copy;
  46         uint fdt_size;
  47         void *other_fdt;
  48         int other_fdt_size;
  49         struct device_node *of_other;
  50         int runs_per_test;
  51         char expect_str[512];
  52         char actual_str[512];
  53 };
  54
  55 /* Test flags for each test */
  56 enum {
  57         UT_TESTF_SCAN_PDATA     = BIT(0),       /* test needs platform data */
  58         UT_TESTF_PROBE_TEST     = BIT(1),       /* probe test uclass */
  59         UT_TESTF_SCAN_FDT       = BIT(2),       /* scan device tree */
  60         UT_TESTF_FLAT_TREE      = BIT(3),       /* test needs flat DT */
  61         UT_TESTF_LIVE_TREE      = BIT(4),       /* needs live device tree */
  62         UT_TESTF_CONSOLE_REC    = BIT(5),       /* needs console recording */
  63         /* do extra driver model init and uninit */
  64         UT_TESTF_DM             = BIT(6),
  65         UT_TESTF_OTHER_FDT      = BIT(7),       /* read in other device tree */
  66 };
  67
  68 /**
  69  * struct unit_test - Information about a unit test
  70  *
  71  * @name: Name of test
  72  * @func: Function to call to perform test
  73  * @flags: Flags indicated pre-conditions for test
  74  */
  75 struct unit_test {
  76         const char *file;
  77         const char *name;
  78         int (*func)(struct unit_test_state *state);
  79         int flags;
  80 };
  81
  82 /**
  83  * UNIT_TEST() - create linker generated list entry for unit a unit test
  84  *
  85  * The macro UNIT_TEST() is used to create a linker generated list entry. These
  86  * list entries are enumerate tests that can be execute using the ut command.
  87  * The list entries are used both by the implementation of the ut command as
  88  * well as in a related Python test.
  89  *
  90  * For Python testing the subtests are collected in Python function
  91  * generate_ut_subtest() by applying a regular expression to the lines of file
  92  * u-boot.sym. The list entries have to follow strict naming conventions to be
  93  * matched by the expression.
  94  *
  95  * Use UNIT_TEST(foo_test_bar, _flags, foo_test) for a test bar in test suite
  96  * foo that can be executed via command 'ut foo bar' and is implemented in
  97  * function foo_test_bar().
  98  *
  99  * @_name:      concatenation of name of the test suite, "_test_", and the name
 100  *              of the test
 101  * @_flags:     an integer field that can be evaluated by the test suite
 102  *              implementation
 103  * @_suite:     name of the test suite concatenated with "_test"
 104  */
 105 #define UNIT_TEST(_name, _flags, _suite)                                \
 106         ll_entry_declare(struct unit_test, _name, ut_ ## _suite) = {    \
 107                 .file = __FILE__,                                       \
 108                 .name = #_name,                                         \
 109                 .flags = _flags,                                        \
 110                 .func = _name,                                          \
 111         }
 112
 113 /* Get the start of a list of unit tests for a particular suite */
 114 #define UNIT_TEST_SUITE_START(_suite) \
 115         ll_entry_start(struct unit_test, ut_ ## _suite)
 116 #define UNIT_TEST_SUITE_COUNT(_suite) \
 117         ll_entry_count(struct unit_test, ut_ ## _suite)
 118
 119 /* Use ! and ~ so that all tests will be sorted between these two values */
 120 #define UNIT_TEST_ALL_START()   ll_entry_start(struct unit_test, ut_!)
 121 #define UNIT_TEST_ALL_END()     ll_entry_start(struct unit_test, ut_~)
 122 #define UNIT_TEST_ALL_COUNT()   (UNIT_TEST_ALL_END() - UNIT_TEST_ALL_START())
 123
 124 /* Sizes for devres tests */
 125 enum {
 126         TEST_DEVRES_SIZE        = 100,
 127         TEST_DEVRES_COUNT       = 10,
 128         TEST_DEVRES_TOTAL       = TEST_DEVRES_SIZE * TEST_DEVRES_COUNT,
 129
 130         /* A few different sizes */
 131         TEST_DEVRES_SIZE2       = 15,
 132         TEST_DEVRES_SIZE3       = 37,
 133 };
 134
 135 /**
 136  * testbus_get_clear_removed() - Test function to obtain removed device
 137  *
 138  * This is used in testbus to find out which device was removed. Calling this
 139  * function returns a pointer to the device and then clears it back to NULL, so
 140  * that a future test can check it.
 141  */
 142 struct udevice *testbus_get_clear_removed(void);
 143
 144 #ifdef CONFIG_SANDBOX
 145 #include <asm/state.h>
 146 #include <asm/test.h>
 147 #endif
 148
 149 static inline void arch_reset_for_test(void)
 150 {
 151 #ifdef CONFIG_SANDBOX
 152         state_reset_for_test(state_get_current());
 153 #endif
 154 }
 155 static inline int test_load_other_fdt(struct unit_test_state *uts)
 156 {
 157         int ret = 0;
 158 #ifdef CONFIG_SANDBOX
 159         ret = sandbox_load_other_fdt(&uts->other_fdt, &uts->other_fdt_size);
 160 #endif
 161         return ret;
 162 }
 163
 164 #endif /* __TEST_TEST_H */