~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/testing/selftests/seccomp/test_harness.h

Version: ~ [ linux-6.2-rc3 ] ~ [ linux-6.1.5 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.87 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.162 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.228 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.269 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.302 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
  3  * Use of this source code is governed by the GPLv2 license.
  4  *
  5  * test_harness.h: simple C unit test helper.
  6  *
  7  * Usage:
  8  *   #include "test_harness.h"
  9  *   TEST(standalone_test) {
 10  *     do_some_stuff;
 11  *     EXPECT_GT(10, stuff) {
 12  *        stuff_state_t state;
 13  *        enumerate_stuff_state(&state);
 14  *        TH_LOG("expectation failed with state: %s", state.msg);
 15  *     }
 16  *     more_stuff;
 17  *     ASSERT_NE(some_stuff, NULL) TH_LOG("how did it happen?!");
 18  *     last_stuff;
 19  *     EXPECT_EQ(0, last_stuff);
 20  *   }
 21  *
 22  *   FIXTURE(my_fixture) {
 23  *     mytype_t *data;
 24  *     int awesomeness_level;
 25  *   };
 26  *   FIXTURE_SETUP(my_fixture) {
 27  *     self->data = mytype_new();
 28  *     ASSERT_NE(NULL, self->data);
 29  *   }
 30  *   FIXTURE_TEARDOWN(my_fixture) {
 31  *     mytype_free(self->data);
 32  *   }
 33  *   TEST_F(my_fixture, data_is_good) {
 34  *     EXPECT_EQ(1, is_my_data_good(self->data));
 35  *   }
 36  *
 37  *   TEST_HARNESS_MAIN
 38  *
 39  * API inspired by code.google.com/p/googletest
 40  */
 41 #ifndef TEST_HARNESS_H_
 42 #define TEST_HARNESS_H_
 43 
 44 #define _GNU_SOURCE
 45 #include <stdint.h>
 46 #include <stdio.h>
 47 #include <stdlib.h>
 48 #include <string.h>
 49 #include <sys/types.h>
 50 #include <sys/wait.h>
 51 #include <unistd.h>
 52 
 53 /* All exported functionality should be declared through this macro. */
 54 #define TEST_API(x) _##x
 55 
 56 /*
 57  * Exported APIs
 58  */
 59 
 60 /* TEST(name) { implementation }
 61  * Defines a test by name.
 62  * Names must be unique and tests must not be run in parallel.  The
 63  * implementation containing block is a function and scoping should be treated
 64  * as such.  Returning early may be performed with a bare "return;" statement.
 65  *
 66  * EXPECT_* and ASSERT_* are valid in a TEST() { } context.
 67  */
 68 #define TEST TEST_API(TEST)
 69 
 70 /* TEST_SIGNAL(name, signal) { implementation }
 71  * Defines a test by name and the expected term signal.
 72  * Names must be unique and tests must not be run in parallel.  The
 73  * implementation containing block is a function and scoping should be treated
 74  * as such.  Returning early may be performed with a bare "return;" statement.
 75  *
 76  * EXPECT_* and ASSERT_* are valid in a TEST() { } context.
 77  */
 78 #define TEST_SIGNAL TEST_API(TEST_SIGNAL)
 79 
 80 /* FIXTURE(datatype name) {
 81  *   type property1;
 82  *   ...
 83  * };
 84  * Defines the data provided to TEST_F()-defined tests as |self|.  It should be
 85  * populated and cleaned up using FIXTURE_SETUP and FIXTURE_TEARDOWN.
 86  */
 87 #define FIXTURE TEST_API(FIXTURE)
 88 
 89 /* FIXTURE_DATA(datatype name)
 90  * This call may be used when the type of the fixture data
 91  * is needed.  In general, this should not be needed unless
 92  * the |self| is being passed to a helper directly.
 93  */
 94 #define FIXTURE_DATA TEST_API(FIXTURE_DATA)
 95 
 96 /* FIXTURE_SETUP(fixture name) { implementation }
 97  * Populates the required "setup" function for a fixture.  An instance of the
 98  * datatype defined with _FIXTURE_DATA will be exposed as |self| for the
 99  * implementation.
100  *
101  * ASSERT_* are valid for use in this context and will prempt the execution
102  * of any dependent fixture tests.
103  *
104  * A bare "return;" statement may be used to return early.
105  */
106 #define FIXTURE_SETUP TEST_API(FIXTURE_SETUP)
107 
108 /* FIXTURE_TEARDOWN(fixture name) { implementation }
109  * Populates the required "teardown" function for a fixture.  An instance of the
110  * datatype defined with _FIXTURE_DATA will be exposed as |self| for the
111  * implementation to clean up.
112  *
113  * A bare "return;" statement may be used to return early.
114  */
115 #define FIXTURE_TEARDOWN TEST_API(FIXTURE_TEARDOWN)
116 
117 /* TEST_F(fixture, name) { implementation }
118  * Defines a test that depends on a fixture (e.g., is part of a test case).
119  * Very similar to TEST() except that |self| is the setup instance of fixture's
120  * datatype exposed for use by the implementation.
121  */
122 #define TEST_F TEST_API(TEST_F)
123 
124 #define TEST_F_SIGNAL TEST_API(TEST_F_SIGNAL)
125 
126 /* Use once to append a main() to the test file. E.g.,
127  *   TEST_HARNESS_MAIN
128  */
129 #define TEST_HARNESS_MAIN TEST_API(TEST_HARNESS_MAIN)
130 
131 /*
132  * Operators for use in TEST and TEST_F.
133  * ASSERT_* calls will stop test execution immediately.
134  * EXPECT_* calls will emit a failure warning, note it, and continue.
135  */
136 
137 /* ASSERT_EQ(expected, measured): expected == measured */
138 #define ASSERT_EQ TEST_API(ASSERT_EQ)
139 /* ASSERT_NE(expected, measured): expected != measured */
140 #define ASSERT_NE TEST_API(ASSERT_NE)
141 /* ASSERT_LT(expected, measured): expected < measured */
142 #define ASSERT_LT TEST_API(ASSERT_LT)
143 /* ASSERT_LE(expected, measured): expected <= measured */
144 #define ASSERT_LE TEST_API(ASSERT_LE)
145 /* ASSERT_GT(expected, measured): expected > measured */
146 #define ASSERT_GT TEST_API(ASSERT_GT)
147 /* ASSERT_GE(expected, measured): expected >= measured */
148 #define ASSERT_GE TEST_API(ASSERT_GE)
149 /* ASSERT_NULL(measured): NULL == measured */
150 #define ASSERT_NULL TEST_API(ASSERT_NULL)
151 /* ASSERT_TRUE(measured): measured != 0 */
152 #define ASSERT_TRUE TEST_API(ASSERT_TRUE)
153 /* ASSERT_FALSE(measured): measured == 0 */
154 #define ASSERT_FALSE TEST_API(ASSERT_FALSE)
155 /* ASSERT_STREQ(expected, measured): !strcmp(expected, measured) */
156 #define ASSERT_STREQ TEST_API(ASSERT_STREQ)
157 /* ASSERT_STRNE(expected, measured): strcmp(expected, measured) */
158 #define ASSERT_STRNE TEST_API(ASSERT_STRNE)
159 /* EXPECT_EQ(expected, measured): expected == measured */
160 #define EXPECT_EQ TEST_API(EXPECT_EQ)
161 /* EXPECT_NE(expected, measured): expected != measured */
162 #define EXPECT_NE TEST_API(EXPECT_NE)
163 /* EXPECT_LT(expected, measured): expected < measured */
164 #define EXPECT_LT TEST_API(EXPECT_LT)
165 /* EXPECT_LE(expected, measured): expected <= measured */
166 #define EXPECT_LE TEST_API(EXPECT_LE)
167 /* EXPECT_GT(expected, measured): expected > measured */
168 #define EXPECT_GT TEST_API(EXPECT_GT)
169 /* EXPECT_GE(expected, measured): expected >= measured */
170 #define EXPECT_GE TEST_API(EXPECT_GE)
171 /* EXPECT_NULL(measured): NULL == measured */
172 #define EXPECT_NULL TEST_API(EXPECT_NULL)
173 /* EXPECT_TRUE(measured): 0 != measured */
174 #define EXPECT_TRUE TEST_API(EXPECT_TRUE)
175 /* EXPECT_FALSE(measured): 0 == measured */
176 #define EXPECT_FALSE TEST_API(EXPECT_FALSE)
177 /* EXPECT_STREQ(expected, measured): !strcmp(expected, measured) */
178 #define EXPECT_STREQ TEST_API(EXPECT_STREQ)
179 /* EXPECT_STRNE(expected, measured): strcmp(expected, measured) */
180 #define EXPECT_STRNE TEST_API(EXPECT_STRNE)
181 
182 /* TH_LOG(format, ...)
183  * Optional debug logging function available for use in tests.
184  * Logging may be enabled or disabled by defining TH_LOG_ENABLED.
185  * E.g., #define TH_LOG_ENABLED 1
186  * If no definition is provided, logging is enabled by default.
187  */
188 #define TH_LOG  TEST_API(TH_LOG)
189 
190 /*
191  * Internal implementation.
192  *
193  */
194 
195 /* Utilities exposed to the test definitions */
196 #ifndef TH_LOG_STREAM
197 #  define TH_LOG_STREAM stderr
198 #endif
199 
200 #ifndef TH_LOG_ENABLED
201 #  define TH_LOG_ENABLED 1
202 #endif
203 
204 #define _TH_LOG(fmt, ...) do { \
205         if (TH_LOG_ENABLED) \
206                 __TH_LOG(fmt, ##__VA_ARGS__); \
207 } while (0)
208 
209 /* Unconditional logger for internal use. */
210 #define __TH_LOG(fmt, ...) \
211                 fprintf(TH_LOG_STREAM, "%s:%d:%s:" fmt "\n", \
212                         __FILE__, __LINE__, _metadata->name, ##__VA_ARGS__)
213 
214 /* Defines the test function and creates the registration stub. */
215 #define _TEST(test_name) __TEST_IMPL(test_name, -1)
216 
217 #define _TEST_SIGNAL(test_name, signal) __TEST_IMPL(test_name, signal)
218 
219 #define __TEST_IMPL(test_name, _signal) \
220         static void test_name(struct __test_metadata *_metadata); \
221         static struct __test_metadata _##test_name##_object = \
222                 { name: "global." #test_name, \
223                   fn: &test_name, termsig: _signal }; \
224         static void __attribute__((constructor)) _register_##test_name(void) \
225         { \
226                 __register_test(&_##test_name##_object); \
227         } \
228         static void test_name( \
229                 struct __test_metadata __attribute__((unused)) *_metadata)
230 
231 /* Wraps the struct name so we have one less argument to pass around. */
232 #define _FIXTURE_DATA(fixture_name) struct _test_data_##fixture_name
233 
234 /* Called once per fixture to setup the data and register. */
235 #define _FIXTURE(fixture_name) \
236         static void __attribute__((constructor)) \
237         _register_##fixture_name##_data(void) \
238         { \
239                 __fixture_count++; \
240         } \
241         _FIXTURE_DATA(fixture_name)
242 
243 /* Prepares the setup function for the fixture.  |_metadata| is included
244  * so that ASSERT_* work as a convenience.
245  */
246 #define _FIXTURE_SETUP(fixture_name) \
247         void fixture_name##_setup( \
248                 struct __test_metadata __attribute__((unused)) *_metadata, \
249                 _FIXTURE_DATA(fixture_name) __attribute__((unused)) *self)
250 #define _FIXTURE_TEARDOWN(fixture_name) \
251         void fixture_name##_teardown( \
252                 struct __test_metadata __attribute__((unused)) *_metadata, \
253                 _FIXTURE_DATA(fixture_name) __attribute__((unused)) *self)
254 
255 /* Emits test registration and helpers for fixture-based test
256  * cases.
257  * TODO(wad) register fixtures on dedicated test lists.
258  */
259 #define _TEST_F(fixture_name, test_name) \
260         __TEST_F_IMPL(fixture_name, test_name, -1)
261 
262 #define _TEST_F_SIGNAL(fixture_name, test_name, signal) \
263         __TEST_F_IMPL(fixture_name, test_name, signal)
264 
265 #define __TEST_F_IMPL(fixture_name, test_name, signal) \
266         static void fixture_name##_##test_name( \
267                 struct __test_metadata *_metadata, \
268                 _FIXTURE_DATA(fixture_name) *self); \
269         static inline void wrapper_##fixture_name##_##test_name( \
270                 struct __test_metadata *_metadata) \
271         { \
272                 /* fixture data is alloced, setup, and torn down per call. */ \
273                 _FIXTURE_DATA(fixture_name) self; \
274                 memset(&self, 0, sizeof(_FIXTURE_DATA(fixture_name))); \
275                 fixture_name##_setup(_metadata, &self); \
276                 /* Let setup failure terminate early. */ \
277                 if (!_metadata->passed) \
278                         return; \
279                 fixture_name##_##test_name(_metadata, &self); \
280                 fixture_name##_teardown(_metadata, &self); \
281         } \
282         static struct __test_metadata \
283                       _##fixture_name##_##test_name##_object = { \
284                 name: #fixture_name "." #test_name, \
285                 fn: &wrapper_##fixture_name##_##test_name, \
286                 termsig: signal, \
287          }; \
288         static void __attribute__((constructor)) \
289                         _register_##fixture_name##_##test_name(void) \
290         { \
291                 __register_test(&_##fixture_name##_##test_name##_object); \
292         } \
293         static void fixture_name##_##test_name( \
294                 struct __test_metadata __attribute__((unused)) *_metadata, \
295                 _FIXTURE_DATA(fixture_name) __attribute__((unused)) *self)
296 
297 /* Exports a simple wrapper to run the test harness. */
298 #define _TEST_HARNESS_MAIN \
299         static void __attribute__((constructor)) \
300         __constructor_order_last(void) \
301         { \
302                 if (!__constructor_order) \
303                         __constructor_order = _CONSTRUCTOR_ORDER_BACKWARD; \
304         } \
305         int main(int argc, char **argv) { \
306                 return test_harness_run(argc, argv); \
307         }
308 
309 #define _ASSERT_EQ(_expected, _seen) \
310         __EXPECT(_expected, _seen, ==, 1)
311 #define _ASSERT_NE(_expected, _seen) \
312         __EXPECT(_expected, _seen, !=, 1)
313 #define _ASSERT_LT(_expected, _seen) \
314         __EXPECT(_expected, _seen, <, 1)
315 #define _ASSERT_LE(_expected, _seen) \
316         __EXPECT(_expected, _seen, <=, 1)
317 #define _ASSERT_GT(_expected, _seen) \
318         __EXPECT(_expected, _seen, >, 1)
319 #define _ASSERT_GE(_expected, _seen) \
320         __EXPECT(_expected, _seen, >=, 1)
321 #define _ASSERT_NULL(_seen) \
322         __EXPECT(NULL, _seen, ==, 1)
323 
324 #define _ASSERT_TRUE(_seen) \
325         _ASSERT_NE(0, _seen)
326 #define _ASSERT_FALSE(_seen) \
327         _ASSERT_EQ(0, _seen)
328 #define _ASSERT_STREQ(_expected, _seen) \
329         __EXPECT_STR(_expected, _seen, ==, 1)
330 #define _ASSERT_STRNE(_expected, _seen) \
331         __EXPECT_STR(_expected, _seen, !=, 1)
332 
333 #define _EXPECT_EQ(_expected, _seen) \
334         __EXPECT(_expected, _seen, ==, 0)
335 #define _EXPECT_NE(_expected, _seen) \
336         __EXPECT(_expected, _seen, !=, 0)
337 #define _EXPECT_LT(_expected, _seen) \
338         __EXPECT(_expected, _seen, <, 0)
339 #define _EXPECT_LE(_expected, _seen) \
340         __EXPECT(_expected, _seen, <=, 0)
341 #define _EXPECT_GT(_expected, _seen) \
342         __EXPECT(_expected, _seen, >, 0)
343 #define _EXPECT_GE(_expected, _seen) \
344         __EXPECT(_expected, _seen, >=, 0)
345 
346 #define _EXPECT_NULL(_seen) \
347         __EXPECT(NULL, _seen, ==, 0)
348 #define _EXPECT_TRUE(_seen) \
349         _EXPECT_NE(0, _seen)
350 #define _EXPECT_FALSE(_seen) \
351         _EXPECT_EQ(0, _seen)
352 
353 #define _EXPECT_STREQ(_expected, _seen) \
354         __EXPECT_STR(_expected, _seen, ==, 0)
355 #define _EXPECT_STRNE(_expected, _seen) \
356         __EXPECT_STR(_expected, _seen, !=, 0)
357 
358 #define ARRAY_SIZE(a)   (sizeof(a) / sizeof(a[0]))
359 
360 /* Support an optional handler after and ASSERT_* or EXPECT_*.  The approach is
361  * not thread-safe, but it should be fine in most sane test scenarios.
362  *
363  * Using __bail(), which optionally abort()s, is the easiest way to early
364  * return while still providing an optional block to the API consumer.
365  */
366 #define OPTIONAL_HANDLER(_assert) \
367         for (; _metadata->trigger;  _metadata->trigger = __bail(_assert))
368 
369 #define __EXPECT(_expected, _seen, _t, _assert) do { \
370         /* Avoid multiple evaluation of the cases */ \
371         __typeof__(_expected) __exp = (_expected); \
372         __typeof__(_seen) __seen = (_seen); \
373         if (!(__exp _t __seen)) { \
374                 unsigned long long __exp_print = (uintptr_t)__exp; \
375                 unsigned long long __seen_print = (uintptr_t)__seen; \
376                 __TH_LOG("Expected %s (%llu) %s %s (%llu)", \
377                          #_expected, __exp_print, #_t, \
378                          #_seen, __seen_print); \
379                 _metadata->passed = 0; \
380                 /* Ensure the optional handler is triggered */ \
381                 _metadata->trigger = 1; \
382         } \
383 } while (0); OPTIONAL_HANDLER(_assert)
384 
385 #define __EXPECT_STR(_expected, _seen, _t, _assert) do { \
386         const char *__exp = (_expected); \
387         const char *__seen = (_seen); \
388         if (!(strcmp(__exp, __seen) _t 0))  { \
389                 __TH_LOG("Expected '%s' %s '%s'.", __exp, #_t, __seen); \
390                 _metadata->passed = 0; \
391                 _metadata->trigger = 1; \
392         } \
393 } while (0); OPTIONAL_HANDLER(_assert)
394 
395 /* Contains all the information for test execution and status checking. */
396 struct __test_metadata {
397         const char *name;
398         void (*fn)(struct __test_metadata *);
399         int termsig;
400         int passed;
401         int trigger; /* extra handler after the evaluation */
402         struct __test_metadata *prev, *next;
403 };
404 
405 /* Storage for the (global) tests to be run. */
406 static struct __test_metadata *__test_list;
407 static unsigned int __test_count;
408 static unsigned int __fixture_count;
409 static int __constructor_order;
410 
411 #define _CONSTRUCTOR_ORDER_FORWARD   1
412 #define _CONSTRUCTOR_ORDER_BACKWARD -1
413 
414 /*
415  * Since constructors are called in reverse order, reverse the test
416  * list so tests are run in source declaration order.
417  * https://gcc.gnu.org/onlinedocs/gccint/Initialization.html
418  * However, it seems not all toolchains do this correctly, so use
419  * __constructor_order to detect which direction is called first
420  * and adjust list building logic to get things running in the right
421  * direction.
422  */
423 static inline void __register_test(struct __test_metadata *t)
424 {
425         __test_count++;
426         /* Circular linked list where only prev is circular. */
427         if (__test_list == NULL) {
428                 __test_list = t;
429                 t->next = NULL;
430                 t->prev = t;
431                 return;
432         }
433         if (__constructor_order == _CONSTRUCTOR_ORDER_FORWARD) {
434                 t->next = NULL;
435                 t->prev = __test_list->prev;
436                 t->prev->next = t;
437                 __test_list->prev = t;
438         } else {
439                 t->next = __test_list;
440                 t->next->prev = t;
441                 t->prev = t;
442                 __test_list = t;
443         }
444 }
445 
446 static inline int __bail(int for_realz)
447 {
448         if (for_realz)
449                 abort();
450         return 0;
451 }
452 
453 void __run_test(struct __test_metadata *t)
454 {
455         pid_t child_pid;
456         int status;
457 
458         t->passed = 1;
459         t->trigger = 0;
460         printf("[ RUN      ] %s\n", t->name);
461         child_pid = fork();
462         if (child_pid < 0) {
463                 printf("ERROR SPAWNING TEST CHILD\n");
464                 t->passed = 0;
465         } else if (child_pid == 0) {
466                 t->fn(t);
467                 _exit(t->passed);
468         } else {
469                 /* TODO(wad) add timeout support. */
470                 waitpid(child_pid, &status, 0);
471                 if (WIFEXITED(status)) {
472                         t->passed = t->termsig == -1 ? WEXITSTATUS(status) : 0;
473                         if (t->termsig != -1) {
474                                 fprintf(TH_LOG_STREAM,
475                                         "%s: Test exited normally "
476                                         "instead of by signal (code: %d)\n",
477                                         t->name,
478                                         WEXITSTATUS(status));
479                         }
480                 } else if (WIFSIGNALED(status)) {
481                         t->passed = 0;
482                         if (WTERMSIG(status) == SIGABRT) {
483                                 fprintf(TH_LOG_STREAM,
484                                         "%s: Test terminated by assertion\n",
485                                         t->name);
486                         } else if (WTERMSIG(status) == t->termsig) {
487                                 t->passed = 1;
488                         } else {
489                                 fprintf(TH_LOG_STREAM,
490                                         "%s: Test terminated unexpectedly "
491                                         "by signal %d\n",
492                                         t->name,
493                                         WTERMSIG(status));
494                         }
495                 } else {
496                         fprintf(TH_LOG_STREAM,
497                                 "%s: Test ended in some other way [%u]\n",
498                                 t->name,
499                                 status);
500                 }
501         }
502         printf("[     %4s ] %s\n", (t->passed ? "OK" : "FAIL"), t->name);
503 }
504 
505 static int test_harness_run(int __attribute__((unused)) argc,
506                             char __attribute__((unused)) **argv)
507 {
508         struct __test_metadata *t;
509         int ret = 0;
510         unsigned int count = 0;
511         unsigned int pass_count = 0;
512 
513         /* TODO(wad) add optional arguments similar to gtest. */
514         printf("[==========] Running %u tests from %u test cases.\n",
515                __test_count, __fixture_count + 1);
516         for (t = __test_list; t; t = t->next) {
517                 count++;
518                 __run_test(t);
519                 if (t->passed)
520                         pass_count++;
521                 else
522                         ret = 1;
523         }
524         printf("[==========] %u / %u tests passed.\n", pass_count, count);
525         printf("[  %s  ]\n", (ret ? "FAILED" : "PASSED"));
526         return ret;
527 }
528 
529 static void __attribute__((constructor)) __constructor_order_first(void)
530 {
531         if (!__constructor_order)
532                 __constructor_order = _CONSTRUCTOR_ORDER_FORWARD;
533 }
534 
535 #endif  /* TEST_HARNESS_H_ */
536 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp