Thomas Gleixner | e500db3 | 2019-06-04 10:11:14 +0200 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 4 | * |
Mickaël Salaün | dfa47d3 | 2017-05-26 20:43:57 +0200 | [diff] [blame] | 5 | * kselftest_harness.h: simple C unit test helper. |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 6 | * |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 7 | * See documentation in Documentation/dev-tools/kselftest.rst |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 8 | * |
| 9 | * API inspired by code.google.com/p/googletest |
| 10 | */ |
Mickaël Salaün | dfa47d3 | 2017-05-26 20:43:57 +0200 | [diff] [blame] | 11 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 12 | /** |
| 13 | * DOC: example |
| 14 | * |
| 15 | * .. code-block:: c |
| 16 | * |
| 17 | * #include "../kselftest_harness.h" |
| 18 | * |
| 19 | * TEST(standalone_test) { |
| 20 | * do_some_stuff; |
| 21 | * EXPECT_GT(10, stuff) { |
| 22 | * stuff_state_t state; |
| 23 | * enumerate_stuff_state(&state); |
| 24 | * TH_LOG("expectation failed with state: %s", state.msg); |
| 25 | * } |
| 26 | * more_stuff; |
| 27 | * ASSERT_NE(some_stuff, NULL) TH_LOG("how did it happen?!"); |
| 28 | * last_stuff; |
| 29 | * EXPECT_EQ(0, last_stuff); |
| 30 | * } |
| 31 | * |
| 32 | * FIXTURE(my_fixture) { |
| 33 | * mytype_t *data; |
| 34 | * int awesomeness_level; |
| 35 | * }; |
| 36 | * FIXTURE_SETUP(my_fixture) { |
| 37 | * self->data = mytype_new(); |
| 38 | * ASSERT_NE(NULL, self->data); |
| 39 | * } |
| 40 | * FIXTURE_TEARDOWN(my_fixture) { |
| 41 | * mytype_free(self->data); |
| 42 | * } |
| 43 | * TEST_F(my_fixture, data_is_good) { |
| 44 | * EXPECT_EQ(1, is_my_data_good(self->data)); |
| 45 | * } |
| 46 | * |
| 47 | * TEST_HARNESS_MAIN |
| 48 | */ |
| 49 | |
Mickaël Salaün | dfa47d3 | 2017-05-26 20:43:57 +0200 | [diff] [blame] | 50 | #ifndef __KSELFTEST_HARNESS_H |
| 51 | #define __KSELFTEST_HARNESS_H |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 52 | |
| 53 | #define _GNU_SOURCE |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 54 | #include <asm/types.h> |
| 55 | #include <errno.h> |
| 56 | #include <stdbool.h> |
Kees Cook | b5bb6d3 | 2015-12-10 14:50:25 -0800 | [diff] [blame] | 57 | #include <stdint.h> |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 58 | #include <stdio.h> |
| 59 | #include <stdlib.h> |
| 60 | #include <string.h> |
| 61 | #include <sys/types.h> |
| 62 | #include <sys/wait.h> |
| 63 | #include <unistd.h> |
| 64 | |
Alexandre Belloni | d51f1f1 | 2019-05-24 00:42:22 +0200 | [diff] [blame] | 65 | #define TEST_TIMEOUT_DEFAULT 30 |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 66 | |
| 67 | /* Utilities exposed to the test definitions */ |
| 68 | #ifndef TH_LOG_STREAM |
| 69 | # define TH_LOG_STREAM stderr |
| 70 | #endif |
| 71 | |
| 72 | #ifndef TH_LOG_ENABLED |
| 73 | # define TH_LOG_ENABLED 1 |
| 74 | #endif |
| 75 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 76 | /** |
| 77 | * TH_LOG(fmt, ...) |
| 78 | * |
| 79 | * @fmt: format string |
| 80 | * @...: optional arguments |
| 81 | * |
| 82 | * .. code-block:: c |
| 83 | * |
| 84 | * TH_LOG(format, ...) |
| 85 | * |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 86 | * Optional debug logging function available for use in tests. |
| 87 | * Logging may be enabled or disabled by defining TH_LOG_ENABLED. |
| 88 | * E.g., #define TH_LOG_ENABLED 1 |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 89 | * |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 90 | * If no definition is provided, logging is enabled by default. |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 91 | * |
| 92 | * If there is no way to print an error message for the process running the |
| 93 | * test (e.g. not allowed to write to stderr), it is still possible to get the |
| 94 | * ASSERT_* number for which the test failed. This behavior can be enabled by |
| 95 | * writing `_metadata->no_print = true;` before the check sequence that is |
| 96 | * unable to print. When an error occur, instead of printing an error message |
| 97 | * and calling `abort(3)`, the test process call `_exit(2)` with the assert |
| 98 | * number as argument, which is then printed by the parent process. |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 99 | */ |
| 100 | #define TH_LOG(fmt, ...) do { \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 101 | if (TH_LOG_ENABLED) \ |
| 102 | __TH_LOG(fmt, ##__VA_ARGS__); \ |
| 103 | } while (0) |
| 104 | |
| 105 | /* Unconditional logger for internal use. */ |
| 106 | #define __TH_LOG(fmt, ...) \ |
| 107 | fprintf(TH_LOG_STREAM, "%s:%d:%s:" fmt "\n", \ |
| 108 | __FILE__, __LINE__, _metadata->name, ##__VA_ARGS__) |
| 109 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 110 | /** |
Kees Cook | 6c3b6d5 | 2018-03-15 09:59:16 -0700 | [diff] [blame] | 111 | * XFAIL(statement, fmt, ...) |
| 112 | * |
| 113 | * @statement: statement to run after reporting XFAIL |
| 114 | * @fmt: format string |
| 115 | * @...: optional arguments |
| 116 | * |
| 117 | * This forces a "pass" after reporting a failure with an XFAIL prefix, |
| 118 | * and runs "statement", which is usually "return" or "goto skip". |
| 119 | */ |
| 120 | #define XFAIL(statement, fmt, ...) do { \ |
| 121 | if (TH_LOG_ENABLED) { \ |
| 122 | fprintf(TH_LOG_STREAM, "[ XFAIL! ] " fmt "\n", \ |
| 123 | ##__VA_ARGS__); \ |
| 124 | } \ |
| 125 | /* TODO: find a way to pass xfail to test runner process. */ \ |
| 126 | _metadata->passed = 1; \ |
| 127 | _metadata->trigger = 0; \ |
| 128 | statement; \ |
| 129 | } while (0) |
| 130 | |
| 131 | /** |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 132 | * TEST(test_name) - Defines the test function and creates the registration |
| 133 | * stub |
| 134 | * |
| 135 | * @test_name: test name |
| 136 | * |
| 137 | * .. code-block:: c |
| 138 | * |
| 139 | * TEST(name) { implementation } |
| 140 | * |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 141 | * Defines a test by name. |
| 142 | * Names must be unique and tests must not be run in parallel. The |
| 143 | * implementation containing block is a function and scoping should be treated |
| 144 | * as such. Returning early may be performed with a bare "return;" statement. |
| 145 | * |
| 146 | * EXPECT_* and ASSERT_* are valid in a TEST() { } context. |
| 147 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 148 | #define TEST(test_name) __TEST_IMPL(test_name, -1) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 149 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 150 | /** |
| 151 | * TEST_SIGNAL(test_name, signal) |
| 152 | * |
| 153 | * @test_name: test name |
| 154 | * @signal: signal number |
| 155 | * |
| 156 | * .. code-block:: c |
| 157 | * |
| 158 | * TEST_SIGNAL(name, signal) { implementation } |
| 159 | * |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 160 | * Defines a test by name and the expected term signal. |
| 161 | * Names must be unique and tests must not be run in parallel. The |
| 162 | * implementation containing block is a function and scoping should be treated |
| 163 | * as such. Returning early may be performed with a bare "return;" statement. |
| 164 | * |
| 165 | * EXPECT_* and ASSERT_* are valid in a TEST() { } context. |
| 166 | */ |
| 167 | #define TEST_SIGNAL(test_name, signal) __TEST_IMPL(test_name, signal) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 168 | |
| 169 | #define __TEST_IMPL(test_name, _signal) \ |
| 170 | static void test_name(struct __test_metadata *_metadata); \ |
| 171 | static struct __test_metadata _##test_name##_object = \ |
Kees Cook | 121e357 | 2019-01-27 01:42:51 -0800 | [diff] [blame] | 172 | { .name = "global." #test_name, \ |
Alexandre Belloni | d51f1f1 | 2019-05-24 00:42:22 +0200 | [diff] [blame] | 173 | .fn = &test_name, .termsig = _signal, \ |
| 174 | .timeout = TEST_TIMEOUT_DEFAULT, }; \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 175 | static void __attribute__((constructor)) _register_##test_name(void) \ |
| 176 | { \ |
| 177 | __register_test(&_##test_name##_object); \ |
| 178 | } \ |
| 179 | static void test_name( \ |
| 180 | struct __test_metadata __attribute__((unused)) *_metadata) |
| 181 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 182 | /** |
| 183 | * FIXTURE_DATA(datatype_name) - Wraps the struct name so we have one less |
| 184 | * argument to pass around |
| 185 | * |
| 186 | * @datatype_name: datatype name |
| 187 | * |
| 188 | * .. code-block:: c |
| 189 | * |
| 190 | * FIXTURE_DATA(datatype name) |
| 191 | * |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 192 | * This call may be used when the type of the fixture data |
| 193 | * is needed. In general, this should not be needed unless |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 194 | * the *self* is being passed to a helper directly. |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 195 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 196 | #define FIXTURE_DATA(datatype_name) struct _test_data_##datatype_name |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 197 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 198 | /** |
| 199 | * FIXTURE(fixture_name) - Called once per fixture to setup the data and |
| 200 | * register |
| 201 | * |
| 202 | * @fixture_name: fixture name |
| 203 | * |
| 204 | * .. code-block:: c |
| 205 | * |
| 206 | * FIXTURE(datatype name) { |
| 207 | * type property1; |
| 208 | * ... |
| 209 | * }; |
| 210 | * |
| 211 | * Defines the data provided to TEST_F()-defined tests as *self*. It should be |
| 212 | * populated and cleaned up using FIXTURE_SETUP() and FIXTURE_TEARDOWN(). |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 213 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 214 | #define FIXTURE(fixture_name) \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 215 | static void __attribute__((constructor)) \ |
| 216 | _register_##fixture_name##_data(void) \ |
| 217 | { \ |
| 218 | __fixture_count++; \ |
| 219 | } \ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 220 | FIXTURE_DATA(fixture_name) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 221 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 222 | /** |
| 223 | * FIXTURE_SETUP(fixture_name) - Prepares the setup function for the fixture. |
Kees Cook | 6c3b6d5 | 2018-03-15 09:59:16 -0700 | [diff] [blame] | 224 | * *_metadata* is included so that EXPECT_* and ASSERT_* work correctly. |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 225 | * |
| 226 | * @fixture_name: fixture name |
| 227 | * |
| 228 | * .. code-block:: c |
| 229 | * |
| 230 | * FIXTURE_SETUP(fixture name) { implementation } |
| 231 | * |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 232 | * Populates the required "setup" function for a fixture. An instance of the |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 233 | * datatype defined with FIXTURE_DATA() will be exposed as *self* for the |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 234 | * implementation. |
| 235 | * |
| 236 | * ASSERT_* are valid for use in this context and will prempt the execution |
| 237 | * of any dependent fixture tests. |
| 238 | * |
| 239 | * A bare "return;" statement may be used to return early. |
| 240 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 241 | #define FIXTURE_SETUP(fixture_name) \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 242 | void fixture_name##_setup( \ |
| 243 | struct __test_metadata __attribute__((unused)) *_metadata, \ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 244 | FIXTURE_DATA(fixture_name) __attribute__((unused)) *self) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 245 | /** |
| 246 | * FIXTURE_TEARDOWN(fixture_name) |
Kees Cook | 6c3b6d5 | 2018-03-15 09:59:16 -0700 | [diff] [blame] | 247 | * *_metadata* is included so that EXPECT_* and ASSERT_* work correctly. |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 248 | * |
| 249 | * @fixture_name: fixture name |
| 250 | * |
| 251 | * .. code-block:: c |
| 252 | * |
| 253 | * FIXTURE_TEARDOWN(fixture name) { implementation } |
| 254 | * |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 255 | * Populates the required "teardown" function for a fixture. An instance of the |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 256 | * datatype defined with FIXTURE_DATA() will be exposed as *self* for the |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 257 | * implementation to clean up. |
| 258 | * |
| 259 | * A bare "return;" statement may be used to return early. |
| 260 | */ |
| 261 | #define FIXTURE_TEARDOWN(fixture_name) \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 262 | void fixture_name##_teardown( \ |
| 263 | struct __test_metadata __attribute__((unused)) *_metadata, \ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 264 | FIXTURE_DATA(fixture_name) __attribute__((unused)) *self) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 265 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 266 | /** |
| 267 | * TEST_F(fixture_name, test_name) - Emits test registration and helpers for |
| 268 | * fixture-based test cases |
| 269 | * |
| 270 | * @fixture_name: fixture name |
| 271 | * @test_name: test name |
| 272 | * |
| 273 | * .. code-block:: c |
| 274 | * |
| 275 | * TEST_F(fixture, name) { implementation } |
| 276 | * |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 277 | * Defines a test that depends on a fixture (e.g., is part of a test case). |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 278 | * Very similar to TEST() except that *self* is the setup instance of fixture's |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 279 | * datatype exposed for use by the implementation. |
Kees Cook | 6c3b6d5 | 2018-03-15 09:59:16 -0700 | [diff] [blame] | 280 | * |
| 281 | * Warning: use of ASSERT_* here will skip TEARDOWN. |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 282 | */ |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 283 | /* TODO(wad) register fixtures on dedicated test lists. */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 284 | #define TEST_F(fixture_name, test_name) \ |
Alexandre Belloni | d51f1f1 | 2019-05-24 00:42:22 +0200 | [diff] [blame] | 285 | __TEST_F_IMPL(fixture_name, test_name, -1, TEST_TIMEOUT_DEFAULT) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 286 | |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 287 | #define TEST_F_SIGNAL(fixture_name, test_name, signal) \ |
Alexandre Belloni | d51f1f1 | 2019-05-24 00:42:22 +0200 | [diff] [blame] | 288 | __TEST_F_IMPL(fixture_name, test_name, signal, TEST_TIMEOUT_DEFAULT) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 289 | |
Alexandre Belloni | d51f1f1 | 2019-05-24 00:42:22 +0200 | [diff] [blame] | 290 | #define TEST_F_TIMEOUT(fixture_name, test_name, timeout) \ |
| 291 | __TEST_F_IMPL(fixture_name, test_name, -1, timeout) |
| 292 | |
| 293 | #define __TEST_F_IMPL(fixture_name, test_name, signal, tmout) \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 294 | static void fixture_name##_##test_name( \ |
| 295 | struct __test_metadata *_metadata, \ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 296 | FIXTURE_DATA(fixture_name) *self); \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 297 | static inline void wrapper_##fixture_name##_##test_name( \ |
| 298 | struct __test_metadata *_metadata) \ |
| 299 | { \ |
| 300 | /* fixture data is alloced, setup, and torn down per call. */ \ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 301 | FIXTURE_DATA(fixture_name) self; \ |
| 302 | memset(&self, 0, sizeof(FIXTURE_DATA(fixture_name))); \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 303 | fixture_name##_setup(_metadata, &self); \ |
| 304 | /* Let setup failure terminate early. */ \ |
| 305 | if (!_metadata->passed) \ |
| 306 | return; \ |
| 307 | fixture_name##_##test_name(_metadata, &self); \ |
| 308 | fixture_name##_teardown(_metadata, &self); \ |
| 309 | } \ |
| 310 | static struct __test_metadata \ |
| 311 | _##fixture_name##_##test_name##_object = { \ |
Kees Cook | 121e357 | 2019-01-27 01:42:51 -0800 | [diff] [blame] | 312 | .name = #fixture_name "." #test_name, \ |
| 313 | .fn = &wrapper_##fixture_name##_##test_name, \ |
| 314 | .termsig = signal, \ |
Alexandre Belloni | d51f1f1 | 2019-05-24 00:42:22 +0200 | [diff] [blame] | 315 | .timeout = tmout, \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 316 | }; \ |
| 317 | static void __attribute__((constructor)) \ |
| 318 | _register_##fixture_name##_##test_name(void) \ |
| 319 | { \ |
| 320 | __register_test(&_##fixture_name##_##test_name##_object); \ |
| 321 | } \ |
| 322 | static void fixture_name##_##test_name( \ |
| 323 | struct __test_metadata __attribute__((unused)) *_metadata, \ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 324 | FIXTURE_DATA(fixture_name) __attribute__((unused)) *self) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 325 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 326 | /** |
| 327 | * TEST_HARNESS_MAIN - Simple wrapper to run the test harness |
| 328 | * |
| 329 | * .. code-block:: c |
| 330 | * |
| 331 | * TEST_HARNESS_MAIN |
| 332 | * |
| 333 | * Use once to append a main() to the test file. |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 334 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 335 | #define TEST_HARNESS_MAIN \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 336 | static void __attribute__((constructor)) \ |
| 337 | __constructor_order_last(void) \ |
| 338 | { \ |
| 339 | if (!__constructor_order) \ |
| 340 | __constructor_order = _CONSTRUCTOR_ORDER_BACKWARD; \ |
| 341 | } \ |
| 342 | int main(int argc, char **argv) { \ |
| 343 | return test_harness_run(argc, argv); \ |
| 344 | } |
| 345 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 346 | /** |
| 347 | * DOC: operators |
| 348 | * |
| 349 | * Operators for use in TEST() and TEST_F(). |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 350 | * ASSERT_* calls will stop test execution immediately. |
| 351 | * EXPECT_* calls will emit a failure warning, note it, and continue. |
| 352 | */ |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 353 | |
| 354 | /** |
| 355 | * ASSERT_EQ(expected, seen) |
| 356 | * |
| 357 | * @expected: expected value |
| 358 | * @seen: measured value |
| 359 | * |
| 360 | * ASSERT_EQ(expected, measured): expected == measured |
| 361 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 362 | #define ASSERT_EQ(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 363 | __EXPECT(expected, #expected, seen, #seen, ==, 1) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 364 | |
| 365 | /** |
| 366 | * ASSERT_NE(expected, seen) |
| 367 | * |
| 368 | * @expected: expected value |
| 369 | * @seen: measured value |
| 370 | * |
| 371 | * ASSERT_NE(expected, measured): expected != measured |
| 372 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 373 | #define ASSERT_NE(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 374 | __EXPECT(expected, #expected, seen, #seen, !=, 1) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 375 | |
| 376 | /** |
| 377 | * ASSERT_LT(expected, seen) |
| 378 | * |
| 379 | * @expected: expected value |
| 380 | * @seen: measured value |
| 381 | * |
| 382 | * ASSERT_LT(expected, measured): expected < measured |
| 383 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 384 | #define ASSERT_LT(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 385 | __EXPECT(expected, #expected, seen, #seen, <, 1) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 386 | |
| 387 | /** |
| 388 | * ASSERT_LE(expected, seen) |
| 389 | * |
| 390 | * @expected: expected value |
| 391 | * @seen: measured value |
| 392 | * |
| 393 | * ASSERT_LE(expected, measured): expected <= measured |
| 394 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 395 | #define ASSERT_LE(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 396 | __EXPECT(expected, #expected, seen, #seen, <=, 1) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 397 | |
| 398 | /** |
| 399 | * ASSERT_GT(expected, seen) |
| 400 | * |
| 401 | * @expected: expected value |
| 402 | * @seen: measured value |
| 403 | * |
| 404 | * ASSERT_GT(expected, measured): expected > measured |
| 405 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 406 | #define ASSERT_GT(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 407 | __EXPECT(expected, #expected, seen, #seen, >, 1) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 408 | |
| 409 | /** |
| 410 | * ASSERT_GE(expected, seen) |
| 411 | * |
| 412 | * @expected: expected value |
| 413 | * @seen: measured value |
| 414 | * |
| 415 | * ASSERT_GE(expected, measured): expected >= measured |
| 416 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 417 | #define ASSERT_GE(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 418 | __EXPECT(expected, #expected, seen, #seen, >=, 1) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 419 | |
| 420 | /** |
| 421 | * ASSERT_NULL(seen) |
| 422 | * |
| 423 | * @seen: measured value |
| 424 | * |
| 425 | * ASSERT_NULL(measured): NULL == measured |
| 426 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 427 | #define ASSERT_NULL(seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 428 | __EXPECT(NULL, "NULL", seen, #seen, ==, 1) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 429 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 430 | /** |
| 431 | * ASSERT_TRUE(seen) |
| 432 | * |
| 433 | * @seen: measured value |
| 434 | * |
| 435 | * ASSERT_TRUE(measured): measured != 0 |
| 436 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 437 | #define ASSERT_TRUE(seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 438 | __EXPECT(0, "0", seen, #seen, !=, 1) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 439 | |
| 440 | /** |
| 441 | * ASSERT_FALSE(seen) |
| 442 | * |
| 443 | * @seen: measured value |
| 444 | * |
| 445 | * ASSERT_FALSE(measured): measured == 0 |
| 446 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 447 | #define ASSERT_FALSE(seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 448 | __EXPECT(0, "0", seen, #seen, ==, 1) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 449 | |
| 450 | /** |
| 451 | * ASSERT_STREQ(expected, seen) |
| 452 | * |
| 453 | * @expected: expected value |
| 454 | * @seen: measured value |
| 455 | * |
| 456 | * ASSERT_STREQ(expected, measured): !strcmp(expected, measured) |
| 457 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 458 | #define ASSERT_STREQ(expected, seen) \ |
| 459 | __EXPECT_STR(expected, seen, ==, 1) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 460 | |
| 461 | /** |
| 462 | * ASSERT_STRNE(expected, seen) |
| 463 | * |
| 464 | * @expected: expected value |
| 465 | * @seen: measured value |
| 466 | * |
| 467 | * ASSERT_STRNE(expected, measured): strcmp(expected, measured) |
| 468 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 469 | #define ASSERT_STRNE(expected, seen) \ |
| 470 | __EXPECT_STR(expected, seen, !=, 1) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 471 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 472 | /** |
| 473 | * EXPECT_EQ(expected, seen) |
| 474 | * |
| 475 | * @expected: expected value |
| 476 | * @seen: measured value |
| 477 | * |
| 478 | * EXPECT_EQ(expected, measured): expected == measured |
| 479 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 480 | #define EXPECT_EQ(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 481 | __EXPECT(expected, #expected, seen, #seen, ==, 0) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 482 | |
| 483 | /** |
| 484 | * EXPECT_NE(expected, seen) |
| 485 | * |
| 486 | * @expected: expected value |
| 487 | * @seen: measured value |
| 488 | * |
| 489 | * EXPECT_NE(expected, measured): expected != measured |
| 490 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 491 | #define EXPECT_NE(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 492 | __EXPECT(expected, #expected, seen, #seen, !=, 0) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 493 | |
| 494 | /** |
| 495 | * EXPECT_LT(expected, seen) |
| 496 | * |
| 497 | * @expected: expected value |
| 498 | * @seen: measured value |
| 499 | * |
| 500 | * EXPECT_LT(expected, measured): expected < measured |
| 501 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 502 | #define EXPECT_LT(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 503 | __EXPECT(expected, #expected, seen, #seen, <, 0) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 504 | |
| 505 | /** |
| 506 | * EXPECT_LE(expected, seen) |
| 507 | * |
| 508 | * @expected: expected value |
| 509 | * @seen: measured value |
| 510 | * |
| 511 | * EXPECT_LE(expected, measured): expected <= measured |
| 512 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 513 | #define EXPECT_LE(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 514 | __EXPECT(expected, #expected, seen, #seen, <=, 0) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 515 | |
| 516 | /** |
| 517 | * EXPECT_GT(expected, seen) |
| 518 | * |
| 519 | * @expected: expected value |
| 520 | * @seen: measured value |
| 521 | * |
| 522 | * EXPECT_GT(expected, measured): expected > measured |
| 523 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 524 | #define EXPECT_GT(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 525 | __EXPECT(expected, #expected, seen, #seen, >, 0) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 526 | |
| 527 | /** |
| 528 | * EXPECT_GE(expected, seen) |
| 529 | * |
| 530 | * @expected: expected value |
| 531 | * @seen: measured value |
| 532 | * |
| 533 | * EXPECT_GE(expected, measured): expected >= measured |
| 534 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 535 | #define EXPECT_GE(expected, seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 536 | __EXPECT(expected, #expected, seen, #seen, >=, 0) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 537 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 538 | /** |
| 539 | * EXPECT_NULL(seen) |
| 540 | * |
| 541 | * @seen: measured value |
| 542 | * |
| 543 | * EXPECT_NULL(measured): NULL == measured |
| 544 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 545 | #define EXPECT_NULL(seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 546 | __EXPECT(NULL, "NULL", seen, #seen, ==, 0) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 547 | |
| 548 | /** |
| 549 | * EXPECT_TRUE(seen) |
| 550 | * |
| 551 | * @seen: measured value |
| 552 | * |
| 553 | * EXPECT_TRUE(measured): 0 != measured |
| 554 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 555 | #define EXPECT_TRUE(seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 556 | __EXPECT(0, "0", seen, #seen, !=, 0) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 557 | |
| 558 | /** |
| 559 | * EXPECT_FALSE(seen) |
| 560 | * |
| 561 | * @seen: measured value |
| 562 | * |
| 563 | * EXPECT_FALSE(measured): 0 == measured |
| 564 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 565 | #define EXPECT_FALSE(seen) \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 566 | __EXPECT(0, "0", seen, #seen, ==, 0) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 567 | |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 568 | /** |
| 569 | * EXPECT_STREQ(expected, seen) |
| 570 | * |
| 571 | * @expected: expected value |
| 572 | * @seen: measured value |
| 573 | * |
| 574 | * EXPECT_STREQ(expected, measured): !strcmp(expected, measured) |
| 575 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 576 | #define EXPECT_STREQ(expected, seen) \ |
| 577 | __EXPECT_STR(expected, seen, ==, 0) |
Mickaël Salaün | 7e6a32a | 2017-06-05 20:37:17 +0200 | [diff] [blame] | 578 | |
| 579 | /** |
| 580 | * EXPECT_STRNE(expected, seen) |
| 581 | * |
| 582 | * @expected: expected value |
| 583 | * @seen: measured value |
| 584 | * |
| 585 | * EXPECT_STRNE(expected, measured): strcmp(expected, measured) |
| 586 | */ |
Mickaël Salaün | 1256a52 | 2017-05-26 20:44:01 +0200 | [diff] [blame] | 587 | #define EXPECT_STRNE(expected, seen) \ |
| 588 | __EXPECT_STR(expected, seen, !=, 0) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 589 | |
| 590 | #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) |
| 591 | |
| 592 | /* Support an optional handler after and ASSERT_* or EXPECT_*. The approach is |
| 593 | * not thread-safe, but it should be fine in most sane test scenarios. |
| 594 | * |
| 595 | * Using __bail(), which optionally abort()s, is the easiest way to early |
| 596 | * return while still providing an optional block to the API consumer. |
| 597 | */ |
| 598 | #define OPTIONAL_HANDLER(_assert) \ |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 599 | for (; _metadata->trigger; _metadata->trigger = \ |
| 600 | __bail(_assert, _metadata->no_print, _metadata->step)) |
| 601 | |
| 602 | #define __INC_STEP(_metadata) \ |
| 603 | if (_metadata->passed && _metadata->step < 255) \ |
| 604 | _metadata->step++; |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 605 | |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 606 | #define __EXPECT(_expected, _expected_str, _seen, _seen_str, _t, _assert) do { \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 607 | /* Avoid multiple evaluation of the cases */ \ |
| 608 | __typeof__(_expected) __exp = (_expected); \ |
| 609 | __typeof__(_seen) __seen = (_seen); \ |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 610 | if (_assert) __INC_STEP(_metadata); \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 611 | if (!(__exp _t __seen)) { \ |
Kees Cook | b5bb6d3 | 2015-12-10 14:50:25 -0800 | [diff] [blame] | 612 | unsigned long long __exp_print = (uintptr_t)__exp; \ |
| 613 | unsigned long long __seen_print = (uintptr_t)__seen; \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 614 | __TH_LOG("Expected %s (%llu) %s %s (%llu)", \ |
Dmitry V. Levin | b708a3cc | 2018-12-10 02:00:47 +0300 | [diff] [blame] | 615 | _expected_str, __exp_print, #_t, \ |
| 616 | _seen_str, __seen_print); \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 617 | _metadata->passed = 0; \ |
| 618 | /* Ensure the optional handler is triggered */ \ |
| 619 | _metadata->trigger = 1; \ |
| 620 | } \ |
| 621 | } while (0); OPTIONAL_HANDLER(_assert) |
| 622 | |
| 623 | #define __EXPECT_STR(_expected, _seen, _t, _assert) do { \ |
| 624 | const char *__exp = (_expected); \ |
| 625 | const char *__seen = (_seen); \ |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 626 | if (_assert) __INC_STEP(_metadata); \ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 627 | if (!(strcmp(__exp, __seen) _t 0)) { \ |
| 628 | __TH_LOG("Expected '%s' %s '%s'.", __exp, #_t, __seen); \ |
| 629 | _metadata->passed = 0; \ |
| 630 | _metadata->trigger = 1; \ |
| 631 | } \ |
| 632 | } while (0); OPTIONAL_HANDLER(_assert) |
| 633 | |
| 634 | /* Contains all the information for test execution and status checking. */ |
| 635 | struct __test_metadata { |
| 636 | const char *name; |
| 637 | void (*fn)(struct __test_metadata *); |
| 638 | int termsig; |
| 639 | int passed; |
| 640 | int trigger; /* extra handler after the evaluation */ |
Alexandre Belloni | d51f1f1 | 2019-05-24 00:42:22 +0200 | [diff] [blame] | 641 | int timeout; |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 642 | __u8 step; |
| 643 | bool no_print; /* manual trigger when TH_LOG_STREAM is not available */ |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 644 | struct __test_metadata *prev, *next; |
| 645 | }; |
| 646 | |
| 647 | /* Storage for the (global) tests to be run. */ |
| 648 | static struct __test_metadata *__test_list; |
| 649 | static unsigned int __test_count; |
| 650 | static unsigned int __fixture_count; |
| 651 | static int __constructor_order; |
| 652 | |
| 653 | #define _CONSTRUCTOR_ORDER_FORWARD 1 |
| 654 | #define _CONSTRUCTOR_ORDER_BACKWARD -1 |
| 655 | |
| 656 | /* |
| 657 | * Since constructors are called in reverse order, reverse the test |
| 658 | * list so tests are run in source declaration order. |
| 659 | * https://gcc.gnu.org/onlinedocs/gccint/Initialization.html |
| 660 | * However, it seems not all toolchains do this correctly, so use |
| 661 | * __constructor_order to detect which direction is called first |
| 662 | * and adjust list building logic to get things running in the right |
| 663 | * direction. |
| 664 | */ |
| 665 | static inline void __register_test(struct __test_metadata *t) |
| 666 | { |
| 667 | __test_count++; |
| 668 | /* Circular linked list where only prev is circular. */ |
| 669 | if (__test_list == NULL) { |
| 670 | __test_list = t; |
| 671 | t->next = NULL; |
| 672 | t->prev = t; |
| 673 | return; |
| 674 | } |
| 675 | if (__constructor_order == _CONSTRUCTOR_ORDER_FORWARD) { |
| 676 | t->next = NULL; |
| 677 | t->prev = __test_list->prev; |
| 678 | t->prev->next = t; |
| 679 | __test_list->prev = t; |
| 680 | } else { |
| 681 | t->next = __test_list; |
| 682 | t->next->prev = t; |
| 683 | t->prev = t; |
| 684 | __test_list = t; |
| 685 | } |
| 686 | } |
| 687 | |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 688 | static inline int __bail(int for_realz, bool no_print, __u8 step) |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 689 | { |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 690 | if (for_realz) { |
| 691 | if (no_print) |
| 692 | _exit(step); |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 693 | abort(); |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 694 | } |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 695 | return 0; |
| 696 | } |
| 697 | |
| 698 | void __run_test(struct __test_metadata *t) |
| 699 | { |
| 700 | pid_t child_pid; |
| 701 | int status; |
| 702 | |
| 703 | t->passed = 1; |
| 704 | t->trigger = 0; |
| 705 | printf("[ RUN ] %s\n", t->name); |
Alexandre Belloni | d51f1f1 | 2019-05-24 00:42:22 +0200 | [diff] [blame] | 706 | alarm(t->timeout); |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 707 | child_pid = fork(); |
| 708 | if (child_pid < 0) { |
| 709 | printf("ERROR SPAWNING TEST CHILD\n"); |
| 710 | t->passed = 0; |
| 711 | } else if (child_pid == 0) { |
| 712 | t->fn(t); |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 713 | /* return the step that failed or 0 */ |
| 714 | _exit(t->passed ? 0 : t->step); |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 715 | } else { |
| 716 | /* TODO(wad) add timeout support. */ |
| 717 | waitpid(child_pid, &status, 0); |
| 718 | if (WIFEXITED(status)) { |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 719 | t->passed = t->termsig == -1 ? !WEXITSTATUS(status) : 0; |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 720 | if (t->termsig != -1) { |
| 721 | fprintf(TH_LOG_STREAM, |
| 722 | "%s: Test exited normally " |
| 723 | "instead of by signal (code: %d)\n", |
| 724 | t->name, |
| 725 | WEXITSTATUS(status)); |
Mickaël Salaün | 369130b | 2017-08-07 01:23:37 +0200 | [diff] [blame] | 726 | } else if (!t->passed) { |
| 727 | fprintf(TH_LOG_STREAM, |
| 728 | "%s: Test failed at step #%d\n", |
| 729 | t->name, |
| 730 | WEXITSTATUS(status)); |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 731 | } |
| 732 | } else if (WIFSIGNALED(status)) { |
| 733 | t->passed = 0; |
| 734 | if (WTERMSIG(status) == SIGABRT) { |
| 735 | fprintf(TH_LOG_STREAM, |
| 736 | "%s: Test terminated by assertion\n", |
| 737 | t->name); |
| 738 | } else if (WTERMSIG(status) == t->termsig) { |
| 739 | t->passed = 1; |
| 740 | } else { |
| 741 | fprintf(TH_LOG_STREAM, |
| 742 | "%s: Test terminated unexpectedly " |
| 743 | "by signal %d\n", |
| 744 | t->name, |
| 745 | WTERMSIG(status)); |
| 746 | } |
| 747 | } else { |
| 748 | fprintf(TH_LOG_STREAM, |
| 749 | "%s: Test ended in some other way [%u]\n", |
| 750 | t->name, |
| 751 | status); |
| 752 | } |
| 753 | } |
| 754 | printf("[ %4s ] %s\n", (t->passed ? "OK" : "FAIL"), t->name); |
Kees Cook | a745f7a | 2019-04-11 17:11:08 -0700 | [diff] [blame] | 755 | alarm(0); |
Kees Cook | c99ee51 | 2015-06-16 10:54:14 -0700 | [diff] [blame] | 756 | } |
| 757 | |
| 758 | static int test_harness_run(int __attribute__((unused)) argc, |
| 759 | char __attribute__((unused)) **argv) |
| 760 | { |
| 761 | struct __test_metadata *t; |
| 762 | int ret = 0; |
| 763 | unsigned int count = 0; |
| 764 | unsigned int pass_count = 0; |
| 765 | |
| 766 | /* TODO(wad) add optional arguments similar to gtest. */ |
| 767 | printf("[==========] Running %u tests from %u test cases.\n", |
| 768 | __test_count, __fixture_count + 1); |
| 769 | for (t = __test_list; t; t = t->next) { |
| 770 | count++; |
| 771 | __run_test(t); |
| 772 | if (t->passed) |
| 773 | pass_count++; |
| 774 | else |
| 775 | ret = 1; |
| 776 | } |
| 777 | printf("[==========] %u / %u tests passed.\n", pass_count, count); |
| 778 | printf("[ %s ]\n", (ret ? "FAILED" : "PASSED")); |
| 779 | return ret; |
| 780 | } |
| 781 | |
| 782 | static void __attribute__((constructor)) __constructor_order_first(void) |
| 783 | { |
| 784 | if (!__constructor_order) |
| 785 | __constructor_order = _CONSTRUCTOR_ORDER_FORWARD; |
| 786 | } |
| 787 | |
Mickaël Salaün | dfa47d3 | 2017-05-26 20:43:57 +0200 | [diff] [blame] | 788 | #endif /* __KSELFTEST_HARNESS_H */ |