git.sur5r.net Git - u-boot/blob - include/test/ut.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Simple unit test library
   4  *
   5  * Copyright (c) 2013 Google, Inc
   6  */
   7
   8 #ifndef __TEST_UT_H
   9 #define __TEST_UT_H
  10
  11 #include <linux/err.h>
  12
  13 struct unit_test_state;
  14
  15 /**
  16  * ut_fail() - Record failure of a unit test
  17  *
  18  * @uts: Test state
  19  * @fname: Filename where the error occurred
  20  * @line: Line number where the error occurred
  21  * @func: Function name where the error occurred
  22  * @cond: The condition that failed
  23  */
  24 void ut_fail(struct unit_test_state *uts, const char *fname, int line,
  25              const char *func, const char *cond);
  26
  27 /**
  28  * ut_failf() - Record failure of a unit test
  29  *
  30  * @uts: Test state
  31  * @fname: Filename where the error occurred
  32  * @line: Line number where the error occurred
  33  * @func: Function name where the error occurred
  34  * @cond: The condition that failed
  35  * @fmt: printf() format string for the error, followed by args
  36  */
  37 void ut_failf(struct unit_test_state *uts, const char *fname, int line,
  38               const char *func, const char *cond, const char *fmt, ...)
  39                         __attribute__ ((format (__printf__, 6, 7)));
  40
  41
  42 /* Assert that a condition is non-zero */
  43 #define ut_assert(cond)                                                 \
  44         if (!(cond)) {                                                  \
  45                 ut_fail(uts, __FILE__, __LINE__, __func__, #cond);      \
  46                 return CMD_RET_FAILURE;                                 \
  47         }
  48
  49 /* Assert that a condition is non-zero, with printf() string */
  50 #define ut_assertf(cond, fmt, args...)                                  \
  51         if (!(cond)) {                                                  \
  52                 ut_failf(uts, __FILE__, __LINE__, __func__, #cond,      \
  53                          fmt, ##args);                                  \
  54                 return CMD_RET_FAILURE;                                 \
  55         }
  56
  57 /* Assert that two int expressions are equal */
  58 #define ut_asserteq(expr1, expr2) {                                     \
  59         unsigned int val1 = (expr1), val2 = (expr2);                    \
  60                                                                         \
  61         if (val1 != val2) {                                             \
  62                 ut_failf(uts, __FILE__, __LINE__, __func__,             \
  63                          #expr1 " == " #expr2,                          \
  64                          "Expected %d, got %d", val1, val2);            \
  65                 return CMD_RET_FAILURE;                                 \
  66         }                                                               \
  67 }
  68
  69 /* Assert that two string expressions are equal */
  70 #define ut_asserteq_str(expr1, expr2) {                                 \
  71         const char *val1 = (expr1), *val2 = (expr2);                    \
  72                                                                         \
  73         if (strcmp(val1, val2)) {                                       \
  74                 ut_failf(uts, __FILE__, __LINE__, __func__,             \
  75                          #expr1 " = " #expr2,                           \
  76                          "Expected \"%s\", got \"%s\"", val1, val2);    \
  77                 return CMD_RET_FAILURE;                                 \
  78         }                                                               \
  79 }
  80
  81 /* Assert that two pointers are equal */
  82 #define ut_asserteq_ptr(expr1, expr2) {                                 \
  83         const void *val1 = (expr1), *val2 = (expr2);                    \
  84                                                                         \
  85         if (val1 != val2) {                                             \
  86                 ut_failf(uts, __FILE__, __LINE__, __func__,             \
  87                          #expr1 " = " #expr2,                           \
  88                          "Expected %p, got %p", val1, val2);            \
  89                 return CMD_RET_FAILURE;                                 \
  90         }                                                               \
  91 }
  92
  93 /* Assert that a pointer is not NULL */
  94 #define ut_assertnonnull(expr) {                                        \
  95         const void *val = (expr);                                       \
  96                                                                         \
  97         if (val == NULL) {                                              \
  98                 ut_failf(uts, __FILE__, __LINE__, __func__,             \
  99                          #expr " = NULL",                               \
 100                          "Expected non-null, got NULL");                \
 101                 return CMD_RET_FAILURE;                                 \
 102         }                                                               \
 103 }
 104
 105 /* Assert that a pointer is not an error pointer */
 106 #define ut_assertok_ptr(expr) {                                         \
 107         const void *val = (expr);                                       \
 108                                                                         \
 109         if (IS_ERR(val)) {                                              \
 110                 ut_failf(uts, __FILE__, __LINE__, __func__,             \
 111                          #expr " = NULL",                               \
 112                          "Expected pointer, got error %ld",             \
 113                          PTR_ERR(val));                                 \
 114                 return CMD_RET_FAILURE;                                 \
 115         }                                                               \
 116 }
 117
 118 /* Assert that an operation succeeds (returns 0) */
 119 #define ut_assertok(cond)       ut_asserteq(0, cond)
 120
 121 #endif