]>
Commit | Line | Data |
---|---|---|
e500db3f | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
c99ee51a KC |
2 | /* |
3 | * Copyright (c) 2012 The Chromium OS Authors. All rights reserved. | |
c99ee51a | 4 | * |
dfa47d31 | 5 | * kselftest_harness.h: simple C unit test helper. |
c99ee51a | 6 | * |
7e6a32ab | 7 | * See documentation in Documentation/dev-tools/kselftest.rst |
c99ee51a KC |
8 | * |
9 | * API inspired by code.google.com/p/googletest | |
10 | */ | |
dfa47d31 | 11 | |
7e6a32ab MS |
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 | ||
dfa47d31 MS |
50 | #ifndef __KSELFTEST_HARNESS_H |
51 | #define __KSELFTEST_HARNESS_H | |
c99ee51a KC |
52 | |
53 | #define _GNU_SOURCE | |
369130b6 MS |
54 | #include <asm/types.h> |
55 | #include <errno.h> | |
56 | #include <stdbool.h> | |
b5bb6d30 | 57 | #include <stdint.h> |
c99ee51a KC |
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 | ||
d51f1f14 | 65 | #define TEST_TIMEOUT_DEFAULT 30 |
c99ee51a | 66 | |
1256a525 MS |
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 | ||
7e6a32ab MS |
76 | /** |
77 | * TH_LOG(fmt, ...) | |
78 | * | |
79 | * @fmt: format string | |
80 | * @...: optional arguments | |
81 | * | |
82 | * .. code-block:: c | |
83 | * | |
84 | * TH_LOG(format, ...) | |
85 | * | |
1256a525 MS |
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 | |
7e6a32ab | 89 | * |
1256a525 | 90 | * If no definition is provided, logging is enabled by default. |
369130b6 MS |
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. | |
c99ee51a | 99 | */ |
1256a525 MS |
100 | #define TH_LOG(fmt, ...) do { \ |
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__) | |
c99ee51a | 109 | |
6c3b6d50 KC |
110 | /** |
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 | ||
7e6a32ab MS |
131 | /** |
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 | * | |
c99ee51a KC |
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 | */ | |
1256a525 | 148 | #define TEST(test_name) __TEST_IMPL(test_name, -1) |
c99ee51a | 149 | |
7e6a32ab MS |
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 | * | |
c99ee51a KC |
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 | */ | |
1256a525 MS |
167 | #define TEST_SIGNAL(test_name, signal) __TEST_IMPL(test_name, signal) |
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 = \ | |
121e357a | 172 | { .name = "global." #test_name, \ |
d51f1f14 AB |
173 | .fn = &test_name, .termsig = _signal, \ |
174 | .timeout = TEST_TIMEOUT_DEFAULT, }; \ | |
1256a525 MS |
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 | ||
7e6a32ab MS |
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 | * | |
1256a525 MS |
192 | * This call may be used when the type of the fixture data |
193 | * is needed. In general, this should not be needed unless | |
7e6a32ab | 194 | * the *self* is being passed to a helper directly. |
1256a525 | 195 | */ |
1256a525 | 196 | #define FIXTURE_DATA(datatype_name) struct _test_data_##datatype_name |
c99ee51a | 197 | |
7e6a32ab MS |
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(). | |
c99ee51a | 213 | */ |
1256a525 MS |
214 | #define FIXTURE(fixture_name) \ |
215 | static void __attribute__((constructor)) \ | |
216 | _register_##fixture_name##_data(void) \ | |
217 | { \ | |
218 | __fixture_count++; \ | |
219 | } \ | |
220 | FIXTURE_DATA(fixture_name) | |
c99ee51a | 221 | |
7e6a32ab MS |
222 | /** |
223 | * FIXTURE_SETUP(fixture_name) - Prepares the setup function for the fixture. | |
6c3b6d50 | 224 | * *_metadata* is included so that EXPECT_* and ASSERT_* work correctly. |
7e6a32ab MS |
225 | * |
226 | * @fixture_name: fixture name | |
227 | * | |
228 | * .. code-block:: c | |
229 | * | |
230 | * FIXTURE_SETUP(fixture name) { implementation } | |
231 | * | |
c99ee51a | 232 | * Populates the required "setup" function for a fixture. An instance of the |
7e6a32ab | 233 | * datatype defined with FIXTURE_DATA() will be exposed as *self* for the |
c99ee51a KC |
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 | */ | |
1256a525 MS |
241 | #define FIXTURE_SETUP(fixture_name) \ |
242 | void fixture_name##_setup( \ | |
243 | struct __test_metadata __attribute__((unused)) *_metadata, \ | |
244 | FIXTURE_DATA(fixture_name) __attribute__((unused)) *self) | |
7e6a32ab MS |
245 | /** |
246 | * FIXTURE_TEARDOWN(fixture_name) | |
6c3b6d50 | 247 | * *_metadata* is included so that EXPECT_* and ASSERT_* work correctly. |
7e6a32ab MS |
248 | * |
249 | * @fixture_name: fixture name | |
250 | * | |
251 | * .. code-block:: c | |
252 | * | |
253 | * FIXTURE_TEARDOWN(fixture name) { implementation } | |
254 | * | |
c99ee51a | 255 | * Populates the required "teardown" function for a fixture. An instance of the |
7e6a32ab | 256 | * datatype defined with FIXTURE_DATA() will be exposed as *self* for the |
c99ee51a KC |
257 | * implementation to clean up. |
258 | * | |
259 | * A bare "return;" statement may be used to return early. | |
260 | */ | |
1256a525 MS |
261 | #define FIXTURE_TEARDOWN(fixture_name) \ |
262 | void fixture_name##_teardown( \ | |
263 | struct __test_metadata __attribute__((unused)) *_metadata, \ | |
264 | FIXTURE_DATA(fixture_name) __attribute__((unused)) *self) | |
c99ee51a | 265 | |
7e6a32ab MS |
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 | * | |
c99ee51a | 277 | * Defines a test that depends on a fixture (e.g., is part of a test case). |
7e6a32ab | 278 | * Very similar to TEST() except that *self* is the setup instance of fixture's |
c99ee51a | 279 | * datatype exposed for use by the implementation. |
6c3b6d50 KC |
280 | * |
281 | * Warning: use of ASSERT_* here will skip TEARDOWN. | |
c99ee51a | 282 | */ |
7e6a32ab | 283 | /* TODO(wad) register fixtures on dedicated test lists. */ |
1256a525 | 284 | #define TEST_F(fixture_name, test_name) \ |
d51f1f14 | 285 | __TEST_F_IMPL(fixture_name, test_name, -1, TEST_TIMEOUT_DEFAULT) |
c99ee51a | 286 | |
1256a525 | 287 | #define TEST_F_SIGNAL(fixture_name, test_name, signal) \ |
d51f1f14 | 288 | __TEST_F_IMPL(fixture_name, test_name, signal, TEST_TIMEOUT_DEFAULT) |
c99ee51a | 289 | |
d51f1f14 AB |
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) \ | |
c99ee51a KC |
294 | static void fixture_name##_##test_name( \ |
295 | struct __test_metadata *_metadata, \ | |
1256a525 | 296 | FIXTURE_DATA(fixture_name) *self); \ |
c99ee51a KC |
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. */ \ | |
1256a525 MS |
301 | FIXTURE_DATA(fixture_name) self; \ |
302 | memset(&self, 0, sizeof(FIXTURE_DATA(fixture_name))); \ | |
c99ee51a KC |
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 = { \ | |
121e357a KC |
312 | .name = #fixture_name "." #test_name, \ |
313 | .fn = &wrapper_##fixture_name##_##test_name, \ | |
314 | .termsig = signal, \ | |
d51f1f14 | 315 | .timeout = tmout, \ |
c99ee51a KC |
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, \ | |
1256a525 | 324 | FIXTURE_DATA(fixture_name) __attribute__((unused)) *self) |
c99ee51a | 325 | |
7e6a32ab MS |
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. | |
1256a525 | 334 | */ |
1256a525 | 335 | #define TEST_HARNESS_MAIN \ |
c99ee51a KC |
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 | ||
7e6a32ab MS |
346 | /** |
347 | * DOC: operators | |
348 | * | |
349 | * Operators for use in TEST() and TEST_F(). | |
1256a525 MS |
350 | * ASSERT_* calls will stop test execution immediately. |
351 | * EXPECT_* calls will emit a failure warning, note it, and continue. | |
352 | */ | |
7e6a32ab MS |
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 | */ | |
1256a525 | 362 | #define ASSERT_EQ(expected, seen) \ |
b708a3cc | 363 | __EXPECT(expected, #expected, seen, #seen, ==, 1) |
7e6a32ab MS |
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 | */ | |
1256a525 | 373 | #define ASSERT_NE(expected, seen) \ |
b708a3cc | 374 | __EXPECT(expected, #expected, seen, #seen, !=, 1) |
7e6a32ab MS |
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 | */ | |
1256a525 | 384 | #define ASSERT_LT(expected, seen) \ |
b708a3cc | 385 | __EXPECT(expected, #expected, seen, #seen, <, 1) |
7e6a32ab MS |
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 | */ | |
1256a525 | 395 | #define ASSERT_LE(expected, seen) \ |
b708a3cc | 396 | __EXPECT(expected, #expected, seen, #seen, <=, 1) |
7e6a32ab MS |
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 | */ | |
1256a525 | 406 | #define ASSERT_GT(expected, seen) \ |
b708a3cc | 407 | __EXPECT(expected, #expected, seen, #seen, >, 1) |
7e6a32ab MS |
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 | */ | |
1256a525 | 417 | #define ASSERT_GE(expected, seen) \ |
b708a3cc | 418 | __EXPECT(expected, #expected, seen, #seen, >=, 1) |
7e6a32ab MS |
419 | |
420 | /** | |
421 | * ASSERT_NULL(seen) | |
422 | * | |
423 | * @seen: measured value | |
424 | * | |
425 | * ASSERT_NULL(measured): NULL == measured | |
426 | */ | |
1256a525 | 427 | #define ASSERT_NULL(seen) \ |
b708a3cc | 428 | __EXPECT(NULL, "NULL", seen, #seen, ==, 1) |
c99ee51a | 429 | |
7e6a32ab MS |
430 | /** |
431 | * ASSERT_TRUE(seen) | |
432 | * | |
433 | * @seen: measured value | |
434 | * | |
435 | * ASSERT_TRUE(measured): measured != 0 | |
436 | */ | |
1256a525 | 437 | #define ASSERT_TRUE(seen) \ |
b708a3cc | 438 | __EXPECT(0, "0", seen, #seen, !=, 1) |
7e6a32ab MS |
439 | |
440 | /** | |
441 | * ASSERT_FALSE(seen) | |
442 | * | |
443 | * @seen: measured value | |
444 | * | |
445 | * ASSERT_FALSE(measured): measured == 0 | |
446 | */ | |
1256a525 | 447 | #define ASSERT_FALSE(seen) \ |
b708a3cc | 448 | __EXPECT(0, "0", seen, #seen, ==, 1) |
7e6a32ab MS |
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 | */ | |
1256a525 MS |
458 | #define ASSERT_STREQ(expected, seen) \ |
459 | __EXPECT_STR(expected, seen, ==, 1) | |
7e6a32ab MS |
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 | */ | |
1256a525 MS |
469 | #define ASSERT_STRNE(expected, seen) \ |
470 | __EXPECT_STR(expected, seen, !=, 1) | |
c99ee51a | 471 | |
7e6a32ab MS |
472 | /** |
473 | * EXPECT_EQ(expected, seen) | |
474 | * | |
475 | * @expected: expected value | |
476 | * @seen: measured value | |
477 | * | |
478 | * EXPECT_EQ(expected, measured): expected == measured | |
479 | */ | |
1256a525 | 480 | #define EXPECT_EQ(expected, seen) \ |
b708a3cc | 481 | __EXPECT(expected, #expected, seen, #seen, ==, 0) |
7e6a32ab MS |
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 | */ | |
1256a525 | 491 | #define EXPECT_NE(expected, seen) \ |
b708a3cc | 492 | __EXPECT(expected, #expected, seen, #seen, !=, 0) |
7e6a32ab MS |
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 | */ | |
1256a525 | 502 | #define EXPECT_LT(expected, seen) \ |
b708a3cc | 503 | __EXPECT(expected, #expected, seen, #seen, <, 0) |
7e6a32ab MS |
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 | */ | |
1256a525 | 513 | #define EXPECT_LE(expected, seen) \ |
b708a3cc | 514 | __EXPECT(expected, #expected, seen, #seen, <=, 0) |
7e6a32ab MS |
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 | */ | |
1256a525 | 524 | #define EXPECT_GT(expected, seen) \ |
b708a3cc | 525 | __EXPECT(expected, #expected, seen, #seen, >, 0) |
7e6a32ab MS |
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 | */ | |
1256a525 | 535 | #define EXPECT_GE(expected, seen) \ |
b708a3cc | 536 | __EXPECT(expected, #expected, seen, #seen, >=, 0) |
c99ee51a | 537 | |
7e6a32ab MS |
538 | /** |
539 | * EXPECT_NULL(seen) | |
540 | * | |
541 | * @seen: measured value | |
542 | * | |
543 | * EXPECT_NULL(measured): NULL == measured | |
544 | */ | |
1256a525 | 545 | #define EXPECT_NULL(seen) \ |
b708a3cc | 546 | __EXPECT(NULL, "NULL", seen, #seen, ==, 0) |
7e6a32ab MS |
547 | |
548 | /** | |
549 | * EXPECT_TRUE(seen) | |
550 | * | |
551 | * @seen: measured value | |
552 | * | |
553 | * EXPECT_TRUE(measured): 0 != measured | |
554 | */ | |
1256a525 | 555 | #define EXPECT_TRUE(seen) \ |
b708a3cc | 556 | __EXPECT(0, "0", seen, #seen, !=, 0) |
7e6a32ab MS |
557 | |
558 | /** | |
559 | * EXPECT_FALSE(seen) | |
560 | * | |
561 | * @seen: measured value | |
562 | * | |
563 | * EXPECT_FALSE(measured): 0 == measured | |
564 | */ | |
1256a525 | 565 | #define EXPECT_FALSE(seen) \ |
b708a3cc | 566 | __EXPECT(0, "0", seen, #seen, ==, 0) |
c99ee51a | 567 | |
7e6a32ab MS |
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 | */ | |
1256a525 MS |
576 | #define EXPECT_STREQ(expected, seen) \ |
577 | __EXPECT_STR(expected, seen, ==, 0) | |
7e6a32ab MS |
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 | */ | |
1256a525 MS |
587 | #define EXPECT_STRNE(expected, seen) \ |
588 | __EXPECT_STR(expected, seen, !=, 0) | |
c99ee51a KC |
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) \ | |
369130b6 MS |
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++; | |
c99ee51a | 605 | |
b708a3cc | 606 | #define __EXPECT(_expected, _expected_str, _seen, _seen_str, _t, _assert) do { \ |
c99ee51a KC |
607 | /* Avoid multiple evaluation of the cases */ \ |
608 | __typeof__(_expected) __exp = (_expected); \ | |
609 | __typeof__(_seen) __seen = (_seen); \ | |
369130b6 | 610 | if (_assert) __INC_STEP(_metadata); \ |
c99ee51a | 611 | if (!(__exp _t __seen)) { \ |
b5bb6d30 KC |
612 | unsigned long long __exp_print = (uintptr_t)__exp; \ |
613 | unsigned long long __seen_print = (uintptr_t)__seen; \ | |
c99ee51a | 614 | __TH_LOG("Expected %s (%llu) %s %s (%llu)", \ |
b708a3cc DL |
615 | _expected_str, __exp_print, #_t, \ |
616 | _seen_str, __seen_print); \ | |
c99ee51a KC |
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); \ | |
369130b6 | 626 | if (_assert) __INC_STEP(_metadata); \ |
c99ee51a KC |
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 */ | |
d51f1f14 | 641 | int timeout; |
369130b6 MS |
642 | __u8 step; |
643 | bool no_print; /* manual trigger when TH_LOG_STREAM is not available */ | |
c99ee51a KC |
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 | ||
369130b6 | 688 | static inline int __bail(int for_realz, bool no_print, __u8 step) |
c99ee51a | 689 | { |
369130b6 MS |
690 | if (for_realz) { |
691 | if (no_print) | |
692 | _exit(step); | |
c99ee51a | 693 | abort(); |
369130b6 | 694 | } |
c99ee51a KC |
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); | |
d51f1f14 | 706 | alarm(t->timeout); |
c99ee51a KC |
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); | |
369130b6 MS |
713 | /* return the step that failed or 0 */ |
714 | _exit(t->passed ? 0 : t->step); | |
c99ee51a KC |
715 | } else { |
716 | /* TODO(wad) add timeout support. */ | |
717 | waitpid(child_pid, &status, 0); | |
718 | if (WIFEXITED(status)) { | |
369130b6 | 719 | t->passed = t->termsig == -1 ? !WEXITSTATUS(status) : 0; |
c99ee51a KC |
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)); | |
369130b6 MS |
726 | } else if (!t->passed) { |
727 | fprintf(TH_LOG_STREAM, | |
728 | "%s: Test failed at step #%d\n", | |
729 | t->name, | |
730 | WEXITSTATUS(status)); | |
c99ee51a KC |
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); | |
a745f7af | 755 | alarm(0); |
c99ee51a KC |
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 | ||
dfa47d31 | 788 | #endif /* __KSELFTEST_HARNESS_H */ |