kunit: drop unused kunit* field in kunit_assert

The `struct kunit* test` field in kunit_assert is unused.
Note: string_stream needs it, but it has its own `test` field. I assume
`test` in `kunit_assert` predates this and was leftover after some
refactoring.

This patch removes the field and cleans up the macros to avoid
needlessly passing around `test`.

Signed-off-by: Daniel Latypov <dlatypov@google.com>
Reviewed-by: Brendan Higgins <brendanhiggins@google.com>
Reviewed-by: David Gow <davidgow@google.com>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>

diff --git a/include/kunit/assert.h b/include/kunit/assert.h
index ccbc36c0b02f7acef8bdea525a4b1833722a7baf..f568166ef034c20119d9e97d7413296cf5658c95 100644 (file)
--- a/include/kunit/assert.h
+++ b/include/kunit/assert.h
@@ -30,7 +30,6 @@ enum kunit_assert_type {
 
 /**
  * struct kunit_assert - Data for printing a failed assertion or expectation.
- * @test: the test case this expectation/assertion is associated with.
  * @type: the type (either an expectation or an assertion) of this kunit_assert.
  * @line: the source code line number that the expectation/assertion is at.
  * @file: the file path of the source file that the expectation/assertion is in.
@@ -41,7 +40,6 @@ enum kunit_assert_type {
  * format a string to a user reporting the failure.
  */
 struct kunit_assert {
-       struct kunit *test;
        enum kunit_assert_type type;
        int line;
        const char *file;
@@ -60,14 +58,12 @@ struct kunit_assert {
 
 /**
  * KUNIT_INIT_ASSERT_STRUCT() - Initializer for a &struct kunit_assert.
- * @kunit: The test case that this expectation/assertion is associated with.
  * @assert_type: The type (assertion or expectation) of this kunit_assert.
  * @fmt: The formatting function which builds a string out of this kunit_assert.
  *
  * The base initializer for a &struct kunit_assert.
  */
-#define KUNIT_INIT_ASSERT_STRUCT(kunit, assert_type, fmt) {                   \
-       .test = kunit,                                                         \
+#define KUNIT_INIT_ASSERT_STRUCT(assert_type, fmt) {                          \
        .type = assert_type,                                                   \
        .file = __FILE__,                                                      \
        .line = __LINE__,                                                      \
@@ -96,15 +92,13 @@ void kunit_fail_assert_format(const struct kunit_assert *assert,
 
 /**
  * KUNIT_INIT_FAIL_ASSERT_STRUCT() - Initializer for &struct kunit_fail_assert.
- * @test: The test case that this expectation/assertion is associated with.
  * @type: The type (assertion or expectation) of this kunit_assert.
  *
  * Initializes a &struct kunit_fail_assert. Intended to be used in
  * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
  */
-#define KUNIT_INIT_FAIL_ASSERT_STRUCT(test, type) {                           \
-       .assert = KUNIT_INIT_ASSERT_STRUCT(test,                               \
-                                          type,                               \
+#define KUNIT_INIT_FAIL_ASSERT_STRUCT(type) {                         \
+       .assert = KUNIT_INIT_ASSERT_STRUCT(type,                               \
                                           kunit_fail_assert_format)           \
 }
 
@@ -129,7 +123,6 @@ void kunit_unary_assert_format(const struct kunit_assert *assert,
 
 /**
  * KUNIT_INIT_UNARY_ASSERT_STRUCT() - Initializes &struct kunit_unary_assert.
- * @test: The test case that this expectation/assertion is associated with.
  * @type: The type (assertion or expectation) of this kunit_assert.
  * @cond: A string representation of the expression asserted true or false.
  * @expect_true: True if of type KUNIT_{EXPECT|ASSERT}_TRUE, false otherwise.
@@ -137,9 +130,8 @@ void kunit_unary_assert_format(const struct kunit_assert *assert,
  * Initializes a &struct kunit_unary_assert. Intended to be used in
  * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
  */
-#define KUNIT_INIT_UNARY_ASSERT_STRUCT(test, type, cond, expect_true) {               \
-       .assert = KUNIT_INIT_ASSERT_STRUCT(test,                               \
-                                          type,                               \
+#define KUNIT_INIT_UNARY_ASSERT_STRUCT(type, cond, expect_true) {             \
+       .assert = KUNIT_INIT_ASSERT_STRUCT(type,                               \
                                           kunit_unary_assert_format),         \
        .condition = cond,                                                     \
        .expected_true = expect_true                                           \
@@ -167,7 +159,6 @@ void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
 /**
  * KUNIT_INIT_PTR_NOT_ERR_ASSERT_STRUCT() - Initializes a
  *     &struct kunit_ptr_not_err_assert.
- * @test: The test case that this expectation/assertion is associated with.
  * @type: The type (assertion or expectation) of this kunit_assert.
  * @txt: A string representation of the expression passed to the expectation.
  * @val: The actual evaluated pointer value of the expression.
@@ -175,9 +166,8 @@ void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
  * Initializes a &struct kunit_ptr_not_err_assert. Intended to be used in
  * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
  */
-#define KUNIT_INIT_PTR_NOT_ERR_STRUCT(test, type, txt, val) {                 \
-       .assert = KUNIT_INIT_ASSERT_STRUCT(test,                               \
-                                          type,                               \
+#define KUNIT_INIT_PTR_NOT_ERR_STRUCT(type, txt, val) {                               \
+       .assert = KUNIT_INIT_ASSERT_STRUCT(type,                               \
                                           kunit_ptr_not_err_assert_format),   \
        .text = txt,                                                           \
        .value = val                                                           \
@@ -212,7 +202,6 @@ void kunit_binary_assert_format(const struct kunit_assert *assert,
 /**
  * KUNIT_INIT_BINARY_ASSERT_STRUCT() - Initializes a
  *     &struct kunit_binary_assert.
- * @test: The test case that this expectation/assertion is associated with.
  * @type: The type (assertion or expectation) of this kunit_assert.
  * @op_str: A string representation of the comparison operator (e.g. "==").
  * @left_str: A string representation of the expression in the left slot.
@@ -223,15 +212,13 @@ void kunit_binary_assert_format(const struct kunit_assert *assert,
  * Initializes a &struct kunit_binary_assert. Intended to be used in
  * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
  */
-#define KUNIT_INIT_BINARY_ASSERT_STRUCT(test,                                 \
-                                       type,                                  \
+#define KUNIT_INIT_BINARY_ASSERT_STRUCT(type,                                 \
                                        op_str,                                \
                                        left_str,                              \
                                        left_val,                              \
                                        right_str,                             \
                                        right_val) {                           \
-       .assert = KUNIT_INIT_ASSERT_STRUCT(test,                               \
-                                          type,                               \
+       .assert = KUNIT_INIT_ASSERT_STRUCT(type,                               \
                                           kunit_binary_assert_format),        \
        .operation = op_str,                                                   \
        .left_text = left_str,                                                 \
@@ -269,7 +256,6 @@ void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,
 /**
  * KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT() - Initializes a
  *     &struct kunit_binary_ptr_assert.
- * @test: The test case that this expectation/assertion is associated with.
  * @type: The type (assertion or expectation) of this kunit_assert.
  * @op_str: A string representation of the comparison operator (e.g. "==").
  * @left_str: A string representation of the expression in the left slot.
@@ -280,15 +266,13 @@ void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,
  * Initializes a &struct kunit_binary_ptr_assert. Intended to be used in
  * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
  */
-#define KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT(test,                             \
-                                           type,                              \
+#define KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT(type,                             \
                                            op_str,                            \
                                            left_str,                          \
                                            left_val,                          \
                                            right_str,                         \
                                            right_val) {                       \
-       .assert = KUNIT_INIT_ASSERT_STRUCT(test,                               \
-                                          type,                               \
+       .assert = KUNIT_INIT_ASSERT_STRUCT(type,                               \
                                           kunit_binary_ptr_assert_format),    \
        .operation = op_str,                                                   \
        .left_text = left_str,                                                 \
@@ -326,7 +310,6 @@ void kunit_binary_str_assert_format(const struct kunit_assert *assert,
 /**
  * KUNIT_INIT_BINARY_STR_ASSERT_STRUCT() - Initializes a
  *     &struct kunit_binary_str_assert.
- * @test: The test case that this expectation/assertion is associated with.
  * @type: The type (assertion or expectation) of this kunit_assert.
  * @op_str: A string representation of the comparison operator (e.g. "==").
  * @left_str: A string representation of the expression in the left slot.
@@ -337,15 +320,13 @@ void kunit_binary_str_assert_format(const struct kunit_assert *assert,
  * Initializes a &struct kunit_binary_str_assert. Intended to be used in
  * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
  */
-#define KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(test,                             \
-                                           type,                              \
+#define KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(type,                             \
                                            op_str,                            \
                                            left_str,                          \
                                            left_val,                          \
                                            right_str,                         \
                                            right_val) {                       \
-       .assert = KUNIT_INIT_ASSERT_STRUCT(test,                               \
-                                          type,                               \
+       .assert = KUNIT_INIT_ASSERT_STRUCT(type,                               \
                                           kunit_binary_str_assert_format),    \
        .operation = op_str,                                                   \
        .left_text = left_str,                                                 \

diff --git a/include/kunit/test.h b/include/kunit/test.h
index 12cabd15449a4a8d365de88090f6371495c4dc79..25ea3bce6663bf978e6e0bbfc0368b13ceda7257 100644 (file)
--- a/include/kunit/test.h
+++ b/include/kunit/test.h
@@ -790,7 +790,7 @@ void kunit_do_failed_assertion(struct kunit *test,
        KUNIT_ASSERTION(test,                                                  \
                        false,                                                 \
                        kunit_fail_assert,                                     \
-                       KUNIT_INIT_FAIL_ASSERT_STRUCT(test, assert_type),      \
+                       KUNIT_INIT_FAIL_ASSERT_STRUCT(assert_type),      \
                        fmt,                                                   \
                        ##__VA_ARGS__)
 
@@ -820,8 +820,7 @@ void kunit_do_failed_assertion(struct kunit *test,
        KUNIT_ASSERTION(test,                                                  \
                        !!(condition) == !!expected_true,                      \
                        kunit_unary_assert,                                    \
-                       KUNIT_INIT_UNARY_ASSERT_STRUCT(test,                   \
-                                                      assert_type,            \
+                       KUNIT_INIT_UNARY_ASSERT_STRUCT(assert_type,            \
                                                       #condition,             \
                                                       expected_true),         \
                        fmt,                                                   \
@@ -879,8 +878,7 @@ do {                                                                               \
        KUNIT_ASSERTION(test,                                                  \
                        __left op __right,                                     \
                        assert_class,                                          \
-                       ASSERT_CLASS_INIT(test,                                \
-                                         assert_type,                         \
+                       ASSERT_CLASS_INIT(assert_type,                         \
                                          #op,                                 \
                                          #left,                               \
                                          __left,                              \
@@ -1234,8 +1232,7 @@ do {                                                                             \
        KUNIT_ASSERTION(test,                                                  \
                        strcmp(__left, __right) op 0,                          \
                        kunit_binary_str_assert,                               \
-                       KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(test,              \
-                                                       assert_type,           \
+                       KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(assert_type,       \
                                                        #op,                   \
                                                        #left,                 \
                                                        __left,                \
@@ -1294,8 +1291,7 @@ do {                                                                             \
        KUNIT_ASSERTION(test,                                                  \
                        !IS_ERR_OR_NULL(__ptr),                                \
                        kunit_ptr_not_err_assert,                              \
-                       KUNIT_INIT_PTR_NOT_ERR_STRUCT(test,                    \
-                                                     assert_type,             \
+                       KUNIT_INIT_PTR_NOT_ERR_STRUCT(assert_type,             \
                                                      #ptr,                    \
                                                      __ptr),                  \
                        fmt,                                                   \