Skip to content

kunit: decrease layers of assertion macros

Daniel Latypov linux-kselftest lkml 1 version In review

Get series with b4
b4 am [email protected]

Versions newest first

  1. v1 Latest5 patches 11 repliesIn review

Patches in v1 No applies recorded yet

#Subject and filesSizeRepliesApplied
1/5kunit: make KUNIT_EXPECT_EQ() use KUNIT_EXPECT_EQ_MSG(), etc.include/kunit/test.h+26 -1422 replies
2/5kunit: drop unused intermediate macros for ptr inequality checksinclude/kunit/test.h+0 -602 replies
3/5kunit: reduce layering in string assertion macrosinclude/kunit/test.h+20 -482 replies
4/5kunit: decrease macro layering for integer assertsinclude/kunit/test.h+51 -1482 replies
5/5kunit: decrease macro layering for EQ/NE assertsinclude/kunit/test.h+49 -1243 replies

Reviews trailers per patch

All 5 patches have a Reviewed-by or Acked-by.

PatchDavid GowBrendan Higgins
1/5R-b R-b
2/5R-b R-b
3/5R-b R-b
4/5R-b R-b
5/5R-b R-b

Trailers given in replies are filled; those carried in the patches from earlier versions are outlined with dashes.

Read the v1 thread

Cover letter [PATCH 0/5] kunit: decrease layers of assertion macros

Note: this series applies on top of the series reducing stack usage,
https://lore.kernel.org/linux-kselftest/[email protected]/
There's no real smenatic dependency between these, just potential for merge conflicts.

The current layout of the assertion macros is confusing.

Here's the call chain for KUNIT_EXPECT_EQ() and KUNIT_EXPECT_EQ_MSG()
KUNIT_EXPECT_EQ =>
KUNIT_BINARY_EQ_ASSERTION => # note: not shared with the _MSG variant KUNIT_BINARY_EQ_MSG_ASSERTION => KUNIT_BASE_EQ_MSG_ASSERTION =>
KUNIT_BASE_BINARY_ASSERTION

KUNIT_EXPECT_EQ_MSG =>
KUNIT_BINARY_EQ_MSG_ASSERTION =>
KUNIT_BASE_EQ_MSG_ASSERTION =>
KUNIT_BASE_BINARY_ASSERTION

After this series
KUNIT_EXPECT_EQ =>
KUNIT_EXPECT_EQ_MSG =>
KUNIT_BINARY_INT_ASSERTION =>
KUNIT_BASE_BINARY_ASSERTION

The current macro layout tries hard to reduce duplication, but comes at the cost of a lot of intermediates that can simply vanish.

The same call-chain again, but annotated with the info we add:
KUNIT_EXPECT_EQ => specify we're an EXPECT, not an ASSERT KUNIT_BINARY_EQ_ASSERTION => specify we have a NULL msg KUNIT_BINARY_EQ_MSG_ASSERTION => specify we work with ints, not ptrs KUNIT_BASE_EQ_MSG_ASSERTION => specify that the op is '==' KUNIT_BASE_BINARY_ASSERTION

We can see that each level of the chain only specifes one parameter at a time. We've taken the concept of DRY too far.

The following is a full snippet of all the macros needed for KUNIT_EXPECT_EQ, showing that a bit of repetition is just fine:

  #define KUNIT_BINARY_INT_ASSERTION(test,				       \
				     assert_type,			       \
				     left,				       \
				     op,				       \
				     right,				       \
				     fmt,				       \
				      ...)				       \
	  KUNIT_BASE_BINARY_ASSERTION(test,				       \
				      kunit_binary_assert,		       \
				      KUNIT_INIT_BINARY_ASSERT_STRUCT,	       \
				      assert_type,			       \
				      left, op, right,			       \
				      fmt,				       \
				      ##__VA_ARGS__)

#define KUNIT_EXPECT_EQ(test, left, right) \
KUNIT_EXPECT_EQ_MSG(test, left, right, NULL)

  #define KUNIT_EXPECT_EQ_MSG(test, left, right, fmt, ...)		       \
	  KUNIT_BINARY_INT_ASSERTION(test,				       \
				     KUNIT_EXPECTATION,			       \
				     left, ==, right,			       \
				     fmt,				       \
				      ##__VA_ARGS__)

as opposed to our current DRYer version

  #define KUNIT_BASE_EQ_MSG_ASSERTION(test,                                      \
				      assert_class,                              \
				      ASSERT_CLASS_INIT,                         \
				      assert_type,                               \
				      left,                                      \
				      right,                                     \
				      fmt,                                       \
				      ...)                                       \
	  KUNIT_BASE_BINARY_ASSERTION(test,                                      \
				      assert_class,                              \
				      ASSERT_CLASS_INIT,                         \
				      assert_type,                               \
				      left, ==, right,                           \
				      fmt,                                       \
				      ##__VA_ARGS__)
  #define KUNIT_BINARY_EQ_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\
	  KUNIT_BASE_EQ_MSG_ASSERTION(test,                                      \
				      kunit_binary_assert,                       \
				      KUNIT_INIT_BINARY_ASSERT_STRUCT,           \
				      assert_type,                               \
				      left,                                      \
				      right,                                     \
				      fmt,                                       \
				      ##__VA_ARGS__)
  #define KUNIT_BINARY_EQ_ASSERTION(test, assert_type, left, right)              \
	  KUNIT_BINARY_EQ_MSG_ASSERTION(test,                                    \
					assert_type,                             \
					left,                                    \
					right,                                   \
					NULL)

#define KUNIT_EXPECT_EQ(test, left, right) \
KUNIT_BINARY_EQ_ASSERTION(test, KUNIT_EXPECTATION, left, right)

  #define KUNIT_EXPECT_EQ_MSG(test, left, right, fmt, ...)                       \
	  KUNIT_BINARY_EQ_MSG_ASSERTION(test,                                    \
					KUNIT_EXPECTATION,                       \
					left,                                    \
					right,                                   \
					fmt,                                     \
					##__VA_ARGS__)

Daniel Latypov (5):
kunit: make KUNIT_EXPECT_EQ() use KUNIT_EXPECT_EQ_MSG(), etc.
kunit: drop unused intermediate macros for ptr inequality checks
kunit: reduce layering in string assertion macros
kunit: decrease macro layering for integer asserts
kunit: decrease macro layering for EQ/NE asserts

 include/kunit/test.h | 660 ++++++++++---------------------------------
 1 file changed, 142 insertions(+), 518 deletions(-)
Signature · 1 line
2.34.1.703.g22d0c6ccf7-goog