kunit: eliminate KUNIT_INIT_*_ASSERT_STRUCT macros

These macros exist because passing an initializer list to other macros
is hard.

The goal of these macros is to generate a line like
  struct $ASSERT_TYPE __assertion = $APPROPRIATE_INITIALIZER;
e.g.
  struct kunit_unary_assertion __assertion = {
	  .condition = "foo()",
	  .expected_true = true
  };

But the challenge is you can't pass `{.condition=..., .expect_true=...}`
as a macro argument, since the comma means you're actually passing two
arguments, `{.condition=...` and `.expect_true=....}`.
So we'd made custom macros for each different initializer-list shape.

But we can work around this with the following generic macro
  #define KUNIT_INIT_ASSERT(initializers...) { initializers }

Note: this has the downside that we have to rename some macros arguments
to not conflict with the struct field names (e.g. `expected_true`).
It's a bit gross, but probably worth reducing the # of macros.

Signed-off-by: Daniel Latypov <dlatypov@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 e8a5948..43144cf 100644 (file)
--- a/include/kunit/assert.h
+++ b/include/kunit/assert.h
@@ -90,19 +90,6 @@ void kunit_unary_assert_format(const struct kunit_assert *assert,
                               const struct va_format *message,
                               struct string_stream *stream);
 
-/**
- * KUNIT_INIT_UNARY_ASSERT_STRUCT() - Initializes &struct kunit_unary_assert.
- * @cond: A string representation of the expression asserted true or false.
- * @expect_true: True if of type KUNIT_{EXPECT|ASSERT}_TRUE, false otherwise.
- *
- * Initializes a &struct kunit_unary_assert. Intended to be used in
- * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
- */
-#define KUNIT_INIT_UNARY_ASSERT_STRUCT(cond, expect_true) {                   \
-       .condition = cond,                                                     \
-       .expected_true = expect_true                                           \
-}
-
 /**
  * struct kunit_ptr_not_err_assert - An expectation/assertion that a pointer is
  *     not NULL and not a -errno.
@@ -123,20 +110,6 @@ void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
                                     const struct va_format *message,
                                     struct string_stream *stream);
 
-/**
- * KUNIT_INIT_PTR_NOT_ERR_ASSERT_STRUCT() - Initializes a
- *     &struct kunit_ptr_not_err_assert.
- * @txt: A string representation of the expression passed to the expectation.
- * @val: The actual evaluated pointer value of the expression.
- *
- * 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(txt, val) {                             \
-       .text = txt,                                                           \
-       .value = val                                                           \
-}
-
 /**
  * struct kunit_binary_assert_text - holds strings for &struct
  *     kunit_binary_assert and friends to try and make the structs smaller.
@@ -173,27 +146,6 @@ void kunit_binary_assert_format(const struct kunit_assert *assert,
                                const struct va_format *message,
                                struct string_stream *stream);
 
-/**
- * KUNIT_INIT_BINARY_ASSERT_STRUCT() - Initializes a binary assert like
- *     kunit_binary_assert, kunit_binary_ptr_assert, etc.
- *
- * @text_: Pointer to a kunit_binary_assert_text.
- * @left_val: The actual evaluated value of the expression in the left slot.
- * @right_val: The actual evaluated value of the expression in the right slot.
- *
- * Initializes a binary assert like kunit_binary_assert,
- * kunit_binary_ptr_assert, etc. This relies on these structs having the same
- * fields but with different types for left_val/right_val.
- * This is ultimately used by binary assertion macros like KUNIT_EXPECT_EQ, etc.
- */
-#define KUNIT_INIT_BINARY_ASSERT_STRUCT(text_,                                \
-                                       left_val,                              \
-                                       right_val) {                           \
-       .text = text_,                                                         \
-       .left_value = left_val,                                                \
-       .right_value = right_val                                               \
-}
-
 /**
  * struct kunit_binary_ptr_assert - An expectation/assertion that compares two
  *     pointer values (for example, KUNIT_EXPECT_PTR_EQ(test, foo, bar)).

diff --git a/include/kunit/test.h b/include/kunit/test.h
index cde97dc..d7f60e8 100644 (file)
--- a/include/kunit/test.h
+++ b/include/kunit/test.h
@@ -515,22 +515,25 @@ void kunit_do_failed_assertion(struct kunit *test,
                             fmt,                                              \
                             ##__VA_ARGS__)
 
+/* Helper to safely pass around an initializer list to other macros. */
+#define KUNIT_INIT_ASSERT(initializers...) { initializers }
+
 #define KUNIT_UNARY_ASSERTION(test,                                           \
                              assert_type,                                     \
-                             condition,                                       \
-                             expected_true,                                   \
+                             condition_,                                      \
+                             expected_true_,                                  \
                              fmt,                                             \
                              ...)                                             \
 do {                                                                          \
-       if (likely(!!(condition) == !!expected_true))                          \
+       if (likely(!!(condition_) == !!expected_true_))                        \
                break;                                                         \
                                                                               \
        _KUNIT_FAILED(test,                                                    \
                      assert_type,                                             \
                      kunit_unary_assert,                                      \
                      kunit_unary_assert_format,                               \
-                     KUNIT_INIT_UNARY_ASSERT_STRUCT(#condition,               \
-                                                    expected_true),           \
+                     KUNIT_INIT_ASSERT(.condition = #condition_,              \
+                                       .expected_true = expected_true_),      \
                      fmt,                                                     \
                      ##__VA_ARGS__);                                          \
 } while (0)
@@ -590,9 +593,9 @@ do {                                                                               \
                      assert_type,                                             \
                      assert_class,                                            \
                      format_func,                                             \
-                     KUNIT_INIT_BINARY_ASSERT_STRUCT(&__text,                 \
-                                                     __left,                  \
-                                                     __right),                \
+                     KUNIT_INIT_ASSERT(.text = &__text,                       \
+                                       .left_value = __left,                  \
+                                       .right_value = __right),               \
                      fmt,                                                     \
                      ##__VA_ARGS__);                                          \
 } while (0)
@@ -651,9 +654,9 @@ do {                                                                               \
                      assert_type,                                             \
                      kunit_binary_str_assert,                                 \
                      kunit_binary_str_assert_format,                          \
-                     KUNIT_INIT_BINARY_ASSERT_STRUCT(&__text,                 \
-                                                     __left,                  \
-                                                     __right),                \
+                     KUNIT_INIT_ASSERT(.text = &__text,                       \
+                                       .left_value = __left,                  \
+                                       .right_value = __right),               \
                      fmt,                                                     \
                      ##__VA_ARGS__);                                          \
 } while (0)
@@ -706,7 +709,7 @@ do {                                                                               \
                      assert_type,                                             \
                      kunit_ptr_not_err_assert,                                \
                      kunit_ptr_not_err_assert_format,                         \
-                     KUNIT_INIT_PTR_NOT_ERR_STRUCT(#ptr, __ptr),              \
+                     KUNIT_INIT_ASSERT(.text = #ptr, .value = __ptr),         \
                      fmt,                                                     \
                      ##__VA_ARGS__);                                          \
 } while (0)