| #ifndef _TEST_TEST_H |
| #define _TEST_TEST_H |
| |
| #include <linux/types.h> |
| #include <linux/slab.h> |
| #include <test/test-stream.h> |
| |
| /** |
| * struct test_resource - represents a *test managed resource* |
| * @allocation: for the user to store arbitrary data. |
| * @free: a user supplied function to free the resource. Populated by |
| * test_alloc_resource(). |
| * |
| * Represents a *test managed resource*, a resource which will automatically be |
| * cleaned up at the end of a test case. |
| * |
| * Example: |
| * |
| * .. code-block:: c |
| * |
| * struct test_kmalloc_params { |
| * size_t size; |
| * gfp_t gfp; |
| * }; |
| * |
| * static int test_kmalloc_init(struct test_resource *res, void *context) |
| * { |
| * struct test_kmalloc_params *params = context; |
| * res->allocation = kmalloc(params->size, params->gfp); |
| * |
| * if (!res->allocation) |
| * return -ENOMEM; |
| * |
| * return 0; |
| * } |
| * |
| * static void test_kmalloc_free(struct test_resource *res) |
| * { |
| * kfree(res->allocation); |
| * } |
| * |
| * void *test_kmalloc(struct test *test, size_t size, gfp_t gfp) |
| * { |
| * struct test_kmalloc_params params; |
| * struct test_resource *res; |
| * |
| * params.size = size; |
| * params.gfp = gfp; |
| * |
| * // TODO(felixguo@google.com): The & gets interpreted via |
| * // Kerneldoc but we don't want that. |
| * res = test_alloc_resource(test, test_kmalloc_init, |
| * test_kmalloc_free, & params); |
| * if (res) |
| * return res->allocation; |
| * else |
| * return NULL; |
| * } |
| */ |
| struct test_resource { |
| void *allocation; |
| void (*free)(struct test_resource *res); |
| /* private: internal use only. */ |
| struct list_head node; |
| }; |
| |
| struct test; |
| |
| /** |
| * struct test_case - represents an individual test case. |
| * @run_case: the function representing the actual test case. |
| * @name: the name of the test case. |
| * |
| * A test case is a function with the signature, ``void (*)(struct test *)`` |
| * that makes expectations and assertions (see EXPECT_TRUE() and ASSERT_TRUE()) |
| * about code under test. Each test case is associated with a |
| * &struct test_module and will be run after the module's init function and |
| * followed by the module's exit function. |
| * |
| * A test case should be static and should only be created with the TEST_CASE() |
| * macro; additionally, every array of test cases should be terminated with an |
| * empty test case. |
| * |
| * Example: |
| * |
| * .. code-block:: c |
| * |
| * void add_test_basic(struct test *test) |
| * { |
| * EXPECT_EQ(test, 1, add(1, 0)); |
| * EXPECT_EQ(test, 2, add(1, 1)); |
| * EXPECT_EQ(test, 0, add(-1, 1)); |
| * EXPECT_EQ(test, INT_MAX, add(0, INT_MAX)); |
| * EXPECT_EQ(test, -1, add(INT_MAX, INT_MIN)); |
| * } |
| * |
| * static struct test_case example_test_cases[] = { |
| * TEST_CASE(add_test_basic), |
| * {}, |
| * }; |
| * |
| */ |
| struct test_case { |
| void (*run_case)(struct test *test); |
| const char name[256]; |
| /* private: internal use only. */ |
| bool success; |
| }; |
| |
| /** |
| * TEST_CASE - A helper for creating a &struct test_case |
| * @test_name: a reference to a test case function. |
| * |
| * Takes a symbol for a function representing a test case and creates a &struct |
| * test_case object from it. See the documentation for &struct test_case for an |
| * example on how to use it. |
| */ |
| #define TEST_CASE(test_name) { .run_case = test_name, .name = #test_name } |
| |
| /** |
| * struct test_module - describes a related collection of &struct test_case s. |
| * @name: the name of the test. Purely informational. |
| * @init: called before every test case. |
| * @exit: called after every test case. |
| * @test_cases: a null terminated array of test cases. |
| * |
| * A test_module is a collection of related &struct test_case s, such that |
| * @init is called before every test case and @exit is called after every test |
| * case, similar to the notion of a *test fixture* or a *test class* in other |
| * unit testing frameworks like JUnit or Googletest. |
| * |
| * Every &struct test_case must be associated with a test_module for KUnit to |
| * run it. |
| */ |
| struct test_module { |
| const char name[256]; |
| int (*init)(struct test *test); |
| void (*exit)(struct test *test); |
| struct test_case *test_cases; |
| }; |
| |
| struct test_initcall { |
| struct list_head node; |
| int (*init)(struct test_initcall *this, struct test *test); |
| void (*exit)(struct test_initcall *this); |
| }; |
| |
| struct test_post_condition { |
| struct list_head node; |
| void (*validate)(struct test_post_condition *condition); |
| }; |
| |
| /** |
| * struct test - represents a running instance of a test. |
| * @priv: for user to store arbitrary data. Commonly used to pass data created |
| * in the init function (see &struct test_module). |
| * |
| * Used to store information about the current context under which the test is |
| * running. Most of this data is private and should only be accessed indirectly |
| * via public functions; the one exception is @priv which can be used by the |
| * test writer to store arbitrary data. |
| */ |
| struct test { |
| void *priv; |
| /* private: internal use only. */ |
| struct list_head resources; |
| struct list_head post_conditions; |
| const char *name; |
| bool death_test; |
| bool success; |
| void (*vprintk)(const struct test *test, |
| const char *level, |
| struct va_format *vaf); |
| void (*fail)(struct test *test, struct test_stream *stream); |
| void (*abort)(struct test *test); |
| }; |
| |
| int test_init_test(struct test *test, const char *name); |
| |
| int test_run_tests(struct test_module *module); |
| |
| void test_install_initcall(struct test_initcall *initcall); |
| |
| #define test_pure_initcall(fn) postcore_initcall(fn) |
| |
| #define test_register_initcall(initcall) \ |
| static int register_test_initcall_##initcall(void) \ |
| { \ |
| test_install_initcall(&initcall); \ |
| \ |
| return 0; \ |
| } \ |
| test_pure_initcall(register_test_initcall_##initcall) |
| |
| /** |
| * module_test() - used to register a &struct test_module with KUnit. |
| * @module: a statically allocated &struct test_module. |
| * |
| * Registers @module with the test framework. See &struct test_module for more |
| * information. |
| */ |
| #define module_test(module) \ |
| static int module_test_init##module(void) \ |
| { \ |
| return test_run_tests(&module); \ |
| } \ |
| late_initcall(module_test_init##module) |
| |
| /** |
| * test_alloc_resource() - Allocates a *test managed resource*. |
| * @test: The test context object. |
| * @init: a user supplied function to initialize the resource. |
| * @free: a user supplied function to free the resource. |
| * @context: for the user to pass in arbitrary data. |
| * |
| * Allocates a *test managed resource*, a resource which will automatically be |
| * cleaned up at the end of a test case. See &struct test_resource for an |
| * example. |
| */ |
| struct test_resource *test_alloc_resource(struct test *test, |
| int (*init)(struct test_resource *, |
| void *), |
| void (*free)(struct test_resource *), |
| void *context); |
| |
| void test_free_resource(struct test *test, struct test_resource *res); |
| |
| /** |
| * test_kmalloc() - Just like kmalloc() except the allocation is *test managed*. |
| * @test: The test context object. |
| * @size: The size in bytes of the desired memory. |
| * @gfp: flags passed to underlying kmalloc(). |
| * |
| * Just like `kmalloc(...)`, except the allocation is managed by the test case |
| * and is automatically cleaned up after the test case concludes. See &struct |
| * test_resource for more information. |
| */ |
| void *test_kmalloc(struct test *test, size_t size, gfp_t gfp); |
| |
| /** |
| * test_kzalloc() - Just like test_kmalloc(), but zeroes the allocation. |
| * @test: The test context object. |
| * @size: The size in bytes of the desired memory. |
| * @gfp: flags passed to underlying kmalloc(). |
| * |
| * See kzalloc() and test_kmalloc() for more information. |
| */ |
| static inline void *test_kzalloc(struct test *test, size_t size, gfp_t gfp) |
| { |
| return test_kmalloc(test, size, gfp | __GFP_ZERO); |
| } |
| |
| void test_cleanup(struct test *test); |
| |
| void test_printk(const char *level, |
| const struct test *test, |
| const char *fmt, ...); |
| |
| /** |
| * test_info() - Prints an INFO level message associated with the current test. |
| * @test: The test context object. |
| * @fmt: A printk() style format string. |
| * |
| * Prints an info level message associated with the test module being run. Takes |
| * a variable number of format parameters just like printk(). |
| */ |
| #define test_info(test, fmt, ...) \ |
| test_printk(KERN_INFO, test, fmt, ##__VA_ARGS__) |
| |
| /** |
| * test_warn() - Prints a WARN level message associated with the current test. |
| * @test: The test context object. |
| * @fmt: A printk() style format string. |
| * |
| * See test_info(). |
| */ |
| #define test_warn(test, fmt, ...) \ |
| test_printk(KERN_WARNING, test, fmt, ##__VA_ARGS__) |
| |
| /** |
| * test_err() - Prints an ERROR level message associated with the current test. |
| * @test: The test context object. |
| * @fmt: A printk() style format string. |
| * |
| * See test_info(). |
| */ |
| #define test_err(test, fmt, ...) \ |
| test_printk(KERN_ERR, test, fmt, ##__VA_ARGS__) |
| |
| static inline struct test_stream *test_expect_start(struct test *test, |
| const char *file, |
| const char *line) |
| { |
| struct test_stream *stream = test_new_stream(test); |
| |
| stream->add(stream, "EXPECTATION FAILED at %s:%s\n\t", file, line); |
| |
| return stream; |
| } |
| |
| static inline void test_expect_end(struct test *test, |
| bool success, |
| struct test_stream *stream) |
| { |
| if (!success) |
| test->fail(test, stream); |
| else |
| stream->clear(stream); |
| } |
| |
| #define EXPECT_START(test) \ |
| test_expect_start(test, __FILE__, __stringify(__LINE__)) |
| |
| #define EXPECT_END(test, success, stream) test_expect_end(test, success, stream) |
| |
| #define EXPECT(test, success, message) do {\ |
| struct test_stream *__stream = EXPECT_START(test); \ |
| \ |
| __stream->add(__stream, message); \ |
| EXPECT_END(test, success, __stream); \ |
| } while (0) |
| |
| /** |
| * SUCCEED() - A no-op expectation. Only exists for code clarity. |
| * @test: The test context object. |
| * |
| * The opposite of FAIL(), it is an expectation that cannot fail. In other |
| * words, it does nothing and only exists for code clarity. See EXPECT_TRUE() |
| * for more information. |
| */ |
| #define SUCCEED(test) do {} while (0) |
| |
| /** |
| * FAIL() - Always causes a test to fail when evaluated. |
| * @test: The test context object. |
| * @message: an informational message to be printed when the assertion is made. |
| * |
| * The opposite of SUCCEED(), it is an expectation that always fails. In other |
| * words, it always results in a failed expectation, and consequently always |
| * causes the test case to fail when evaluated. See EXPECT_TRUE() for more |
| * information. |
| */ |
| #define FAIL(test, message) EXPECT(test, false, message) |
| |
| /** |
| * EXPECT_TRUE() - Causes a test failure when the given expression is not true. |
| * @test: The test context object. |
| * @condition: an arbitrary boolean expression. The test fails when this does |
| * not evaluate to true. |
| * |
| * This and expectations of the form `EXPECT_*` will cause the test case to fail |
| * when the specified condition is not met; however, it will not prevent the |
| * test case from continuing to run; this is otherwise known as an *expectation |
| * failure*. |
| */ |
| #define EXPECT_TRUE(test, condition) \ |
| EXPECT(test, (condition), \ |
| "Expected " #condition " is true, but is false.") |
| |
| /** |
| * EXPECT_FALSE() - Causes a test failure when the expression is not false. |
| * @test: The test context object. |
| * @condition: an arbitrary boolean expression. The test fails when this does |
| * not evaluate to false. |
| * |
| * Sets an expectation that @condition evaluates to false. See EXPECT_TRUE() for |
| * more information. |
| */ |
| #define EXPECT_FALSE(test, condition) \ |
| EXPECT(test, !(condition), \ |
| "Expected " #condition " is false, but is true.") |
| |
| static inline void test_expect_binary(struct test *test, |
| long long left, const char *left_name, |
| long long right, const char *right_name, |
| bool compare_result, |
| const char *compare_name, |
| const char *file, |
| const char *line) |
| { |
| struct test_stream *stream = test_expect_start(test, file, line); |
| |
| stream->add(stream, |
| "Expected %s %s %s, but\n", |
| left_name, compare_name, right_name); |
| stream->add(stream, "\t\t%s == %lld\n", left_name, left); |
| stream->add(stream, "\t\t%s == %lld", right_name, right); |
| |
| test_expect_end(test, compare_result, stream); |
| } |
| |
| /* |
| * A factory macro for defining the expectations for the basic comparisons |
| * defined for the built in types. |
| * |
| * Unfortunately, there is no common type that all types can be promoted to for |
| * which all the binary operators behave the same way as for the actual types |
| * (for example, there is no type that long long and unsigned long long can |
| * both be cast to where the comparison result is preserved for all values). So |
| * the best we can do is do the comparison in the original types and then coerce |
| * everything to long long for printing; this way, the comparison behaves |
| * correctly and the printed out value usually makes sense without |
| * interpretation, but can always be interpretted to figure out the actual |
| * value. |
| */ |
| #define EXPECT_BINARY(test, left, condition, right) do { \ |
| typeof(left) __left = (left); \ |
| typeof(right) __right = (right); \ |
| test_expect_binary(test, \ |
| (long long) __left, #left, \ |
| (long long) __right, #right, \ |
| __left condition __right, #condition, \ |
| __FILE__, __stringify(__LINE__)); \ |
| } while (0) |
| |
| /** |
| * EXPECT_EQ() - Sets an expectation that @left and @right are equal. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an expectation that the values that @left and @right evaluate to are |
| * equal. This is semantically equivalent to EXPECT_TRUE(@test, (@left) == |
| * (@right)). See EXPECT_TRUE() for more information. |
| */ |
| #define EXPECT_EQ(test, left, right) EXPECT_BINARY(test, left, ==, right) |
| |
| /** |
| * EXPECT_NE() - An expectation that @left and @right are not equal. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an expectation that the values that @left and @right evaluate to are not |
| * equal. This is semantically equivalent to EXPECT_TRUE(@test, (@left) != |
| * (@right)). See EXPECT_TRUE() for more information. |
| */ |
| #define EXPECT_NE(test, left, right) EXPECT_BINARY(test, left, !=, right) |
| |
| /** |
| * EXPECT_LT() - An expectation that @left is less than @right. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an expectation that the value that @left evaluates to is less than the |
| * value that @right evaluates to. This is semantically equivalent to |
| * EXPECT_TRUE(@test, (@left) < (@right)). See EXPECT_TRUE() for more |
| * information. |
| */ |
| #define EXPECT_LT(test, left, right) EXPECT_BINARY(test, left, <, right) |
| |
| /** |
| * EXPECT_LE() - An expectation that @left is less than or equal to @right. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an expectation that the value that @left evaluates to is less than or |
| * equal to the value that @right evaluates to. Semantically this is equivalent |
| * to EXPECT_TRUE(@test, (@left) <= (@right)). See EXPECT_TRUE() for more |
| * information. |
| */ |
| #define EXPECT_LE(test, left, right) EXPECT_BINARY(test, left, <=, right) |
| |
| /** |
| * EXPECT_GT() - An expectation that @left is greater than @right. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an expectation that the value that @left evaluates to is greater than |
| * the value that @right evaluates to. This is semantically equivalent to |
| * EXPECT_TRUE(@test, (@left) > (@right)). See EXPECT_TRUE() for more |
| * information. |
| */ |
| #define EXPECT_GT(test, left, right) EXPECT_BINARY(test, left, >, right) |
| |
| /** |
| * EXPECT_GE() - An expectation that @left is greater than or equal to @right. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an expectation that the value that @left evaluates to is greater than |
| * the value that @right evaluates to. This is semantically equivalent to |
| * EXPECT_TRUE(@test, (@left) >= (@right)). See EXPECT_TRUE() for more |
| * information. |
| */ |
| #define EXPECT_GE(test, left, right) EXPECT_BINARY(test, left, >=, right) |
| |
| /** |
| * EXPECT_STREQ() - An expectation that strings @left and @right are equal. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a null terminated string. |
| * @right: an arbitrary expression that evaluates to a null terminated string. |
| * |
| * Sets an expectation that the values that @left and @right evaluate to are |
| * equal. This is semantically equivalent to |
| * EXPECT_TRUE(@test, !strcmp((@left), (@right))). See EXPECT_TRUE() for more |
| * information. |
| */ |
| #define EXPECT_STREQ(test, left, right) do { \ |
| struct test_stream *__stream = EXPECT_START(test); \ |
| typeof(left) __left = (left); \ |
| typeof(right) __right = (right); \ |
| \ |
| __stream->add(__stream, "Expected " #left " == " #right ", but\n"); \ |
| __stream->add(__stream, "\t\t%s == %s\n", #left, __left); \ |
| __stream->add(__stream, "\t\t%s == %s\n", #right, __right); \ |
| \ |
| EXPECT_END(test, !strcmp(left, right), __stream); \ |
| } while (0) |
| |
| /** |
| * EXPECT_NOT_ERR_OR_NULL() - An expectation that @ptr is not null and not err. |
| * @test: The test context object. |
| * @ptr: an arbitrary pointer. |
| * |
| * Sets an expectation that the value that @ptr evaluates to is not null and not |
| * an errno stored in a pointer. This is semantically equivalent to |
| * EXPECT_TRUE(@test, !IS_ERR_OR_NULL(@ptr)). See EXPECT_TRUE() for more |
| * information. |
| */ |
| #define EXPECT_NOT_ERR_OR_NULL(test, ptr) do { \ |
| struct test_stream *__stream = EXPECT_START(test); \ |
| typeof(ptr) __ptr = (ptr); \ |
| \ |
| if (!__ptr) \ |
| __stream->add(__stream, \ |
| "Expected " #ptr " is not null, but is."); \ |
| if (IS_ERR(__ptr)) \ |
| __stream->add(__stream, \ |
| "Expected " #ptr " is not error, but is: %ld", \ |
| PTR_ERR(__ptr)); \ |
| \ |
| EXPECT_END(test, !IS_ERR_OR_NULL(__ptr), __stream); \ |
| } while (0) |
| |
| static inline struct test_stream *test_assert_start(struct test *test, |
| const char *file, |
| const char *line) |
| { |
| struct test_stream *stream = test_new_stream(test); |
| |
| stream->add(stream, "ASSERTION FAILED at %s:%s\n\t", file, line); |
| |
| return stream; |
| } |
| |
| static inline void test_assert_end(struct test *test, |
| bool success, |
| struct test_stream *stream) |
| { |
| if (!success) { |
| test->fail(test, stream); |
| test->abort(test); |
| } else { |
| stream->clear(stream); |
| } |
| } |
| |
| #define ASSERT_START(test) \ |
| test_assert_start(test, __FILE__, __stringify(__LINE__)) |
| |
| #define ASSERT_END(test, success, stream) test_assert_end(test, success, stream) |
| |
| #define ASSERT(test, success, message) do { \ |
| struct test_stream *__stream = ASSERT_START(test); \ |
| \ |
| __stream->add(__stream, message); \ |
| ASSERT_END(test, success, __stream); \ |
| } while (0) |
| |
| #define ASSERT_FAILURE(test, message) ASSERT(test, false, message) |
| |
| /** |
| * ASSERT_TRUE() - Causes an assertion failure when the expression is not true. |
| * @test: The test context object. |
| * @condition: an arbitrary boolean expression. The test fails and aborts when |
| * this does not evaluate to true. |
| * |
| * This and assertions of the form `ASSERT_*` will cause the test case to fail |
| * *and immediately abort* when the specified condition is not met. Unlike an |
| * expectation failure, it will prevent the test case from continuing to run; |
| * this is otherwise known as an *assertion failure*. |
| */ |
| #define ASSERT_TRUE(test, condition) \ |
| ASSERT(test, (condition), \ |
| "Asserted " #condition " is true, but is false.") |
| |
| /** |
| * ASSERT_FALSE() - Sets an assertion that @condition is false. |
| * @test: The test context object. |
| * @condition: an arbitrary boolean expression. |
| * |
| * Sets an assertion that the value that @condition evaluates to is false. This |
| * is the same as EXPECT_FALSE(), except it causes an assertion failure (see |
| * ASSERT_TRUE()) when the assertion is not met. |
| */ |
| #define ASSERT_FALSE(test, condition) \ |
| ASSERT(test, !(condition), \ |
| "Asserted " #condition " is false, but is true.") |
| |
| static inline void test_assert_binary(struct test *test, |
| long long left, const char *left_name, |
| long long right, const char *right_name, |
| bool compare_result, |
| const char *compare_name, |
| const char *file, |
| const char *line) |
| { |
| struct test_stream *stream = test_assert_start(test, file, line); |
| |
| stream->add(stream, |
| "Asserted %s %s %s, but\n", |
| left_name, compare_name, right_name); |
| stream->add(stream, "\t\t%s == %lld\n", left_name, left); |
| stream->add(stream, "\t\t%s == %lld", right_name, right); |
| |
| test_assert_end(test, compare_result, stream); |
| } |
| |
| /* |
| * A factory macro for defining the expectations for the basic comparisons |
| * defined for the built in types. |
| * |
| * Unfortunately, there is no common type that all types can be promoted to for |
| * which all the binary operators behave the same way as for the actual types |
| * (for example, there is no type that long long and unsigned long long can |
| * both be cast to where the comparison result is preserved for all values). So |
| * the best we can do is do the comparison in the original types and then coerce |
| * everything to long long for printing; this way, the comparison behaves |
| * correctly and the printed out value usually makes sense without |
| * interpretation, but can always be interpretted to figure out the actual |
| * value. |
| */ |
| #define ASSERT_BINARY(test, left, condition, right) do { \ |
| typeof(left) __left = (left); \ |
| typeof(right) __right = (right); \ |
| test_assert_binary(test, \ |
| (long long) __left, #left, \ |
| (long long) __right, #right, \ |
| __left condition __right, #condition, \ |
| __FILE__, __stringify(__LINE__)); \ |
| } while (0) |
| |
| /** |
| * ASSERT_EQ() - Sets an assertion that @left and @right are equal. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an assertion that the values that @left and @right evaluate to are |
| * equal. This is the same as EXPECT_EQ(), except it causes an assertion failure |
| * (see ASSERT_TRUE()) when the assertion is not met. |
| */ |
| #define ASSERT_EQ(test, left, right) ASSERT_BINARY(test, left, ==, right) |
| |
| /** |
| * ASSERT_NE() - An assertion that @left and @right are not equal. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an assertion that the values that @left and @right evaluate to are not |
| * equal. This is the same as EXPECT_NE(), except it causes an assertion failure |
| * (see ASSERT_TRUE()) when the assertion is not met. |
| */ |
| #define ASSERT_NE(test, left, right) ASSERT_BINARY(test, left, !=, right) |
| |
| /** |
| * ASSERT_LT() - An assertion that @left is less than @right. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an assertion that the value that @left evaluates to is less than the |
| * value that @right evaluates to. This is the same as EXPECT_LT(), except it |
| * causes an assertion failure (see ASSERT_TRUE()) when the assertion is not |
| * met. |
| */ |
| #define ASSERT_LT(test, left, right) ASSERT_BINARY(test, left, <, right) |
| |
| /** |
| * ASSERT_LE() - An assertion that @left is less than or equal to @right. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an assertion that the value that @left evaluates to is less than or |
| * equal to the value that @right evaluates to. This is the same as |
| * EXPECT_LE(), except it causes an assertion failure (see ASSERT_TRUE()) when |
| * the assertion is not met. |
| */ |
| #define ASSERT_LE(test, left, right) ASSERT_BINARY(test, left, <=, right) |
| |
| /** |
| * ASSERT_GT() - An assertion that @left is greater than @right. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an assertion that the value that @left evaluates to is greater than the |
| * value that @right evaluates to. This is the same as EXPECT_GT(), except it |
| * causes an assertion failure (see ASSERT_TRUE()) when the assertion is not |
| * met. |
| */ |
| #define ASSERT_GT(test, left, right) ASSERT_BINARY(test, left, >, right) |
| |
| /** |
| * ASSERT_GE() - An assertion that @left is greater than or equal to @right. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a primitive C type. |
| * @right: an arbitrary expression that evaluates to a primitive C type. |
| * |
| * Sets an assertion that the value that @left evaluates to is greater than the |
| * value that @right evaluates to. This is the same as EXPECT_GE(), except it |
| * causes an assertion failure (see ASSERT_TRUE()) when the assertion is not |
| * met. |
| */ |
| #define ASSERT_GE(test, left, right) ASSERT_BINARY(test, left, >=, right) |
| |
| /** |
| * ASSERT_STREQ() - An assertion that strings @left and @right are equal. |
| * @test: The test context object. |
| * @left: an arbitrary expression that evaluates to a null terminated string. |
| * @right: an arbitrary expression that evaluates to a null terminated string. |
| * |
| * Sets an assertion that the values that @left and @right evaluate to are |
| * equal. This is the same as EXPECT_STREQ(), except it causes an assertion |
| * failure (see ASSERT_TRUE()) when the assertion is not met. |
| */ |
| #define ASSERT_STREQ(test, left, right) do { \ |
| struct test_stream *__stream = ASSERT_START(test); \ |
| typeof(left) __left = (left); \ |
| typeof(right) __right = (right); \ |
| \ |
| __stream->add(__stream, "Asserted " #left " == " #right ", but\n"); \ |
| __stream->add(__stream, "\t\t%s == %s\n", #left, __left); \ |
| __stream->add(__stream, "\t\t%s == %s\n", #right, __right); \ |
| \ |
| ASSERT_END(test, !strcmp(left, right), __stream); \ |
| } while (0) |
| |
| /** |
| * ASSERT_NOT_ERR_OR_NULL() - An assertion that @ptr is not null and not err. |
| * @test: The test context object. |
| * @ptr: an arbitrary pointer. |
| * |
| * Sets an assertion that the value that @ptr evaluates to is not null and not |
| * an errno stored in a pointer. This is the same as EXPECT_NOT_ERR_OR_NULL(), |
| * except it causes an assertion failure (see ASSERT_TRUE()) when the assertion |
| * is not met. |
| */ |
| #define ASSERT_NOT_ERR_OR_NULL(test, ptr) do { \ |
| struct test_stream *__stream = ASSERT_START(test); \ |
| typeof(ptr) __ptr = (ptr); \ |
| \ |
| if (!__ptr) \ |
| __stream->add(__stream, \ |
| "Asserted " #ptr " is not null, but is."); \ |
| if (IS_ERR(__ptr)) \ |
| __stream->add(__stream, \ |
| "Asserted " #ptr " is not error, but is: %ld", \ |
| PTR_ERR(__ptr)); \ |
| \ |
| ASSERT_END(test, !IS_ERR_OR_NULL(__ptr), __stream); \ |
| } while (0) |
| |
| /** |
| * ASSERT_SIGSEGV() - An assertion that @expr will cause a segfault. |
| * @test: The test context object. |
| * @expr: an arbitrary block of code. |
| * |
| * Sets an assertion that @expr, when evaluated, will cause a segfault. |
| * Currently this assertion is only really useful for testing the KUnit |
| * framework, as a segmentation fault in normal kernel code is always incorrect. |
| * However, the plan is to replace this assertion with an arbitrary death |
| * assertion similar to |
| * https://github.com/google/googletest/blob/master/googletest/docs/advanced.md#death-tests |
| * which will probably be massaged to make sense in the context of the kernel |
| * (maybe assert that a panic occurred, or that BUG() was called). |
| * |
| * NOTE: no code after this assertion will ever be executed. |
| */ |
| #define ASSERT_SIGSEGV(test, expr) do { \ |
| test->death_test = true; \ |
| expr; \ |
| test->death_test = false; \ |
| ASSERT_FAILURE(test, \ |
| "Asserted that " #expr " would cause death, but did not.");\ |
| } while (0) |
| |
| #endif /* _TEST_TEST_H */ |