Commit d51b1b33 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'linux-kselftest-kunit-5.18-rc1' of... 

Merge tag 'linux-kselftest-kunit-5.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest

Pull KUnit updates from Shuah Khan:

 - changes to decrease macro layering string, integer, EQ/NE asserts

 - remove unused macros

 - several cleanups and fixes

 - new list tests for list_del_init_careful(), list_is_head() and
   list_entry_is_head()

* tag 'linux-kselftest-kunit-5.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest:
  list: test: Add a test for list_entry_is_head()
  list: test: Add a test for list_is_head()
  list: test: Add test for list_del_init_careful()
  kunit: cleanup assertion macro internal variables
  kunit: factor out str constants from binary assertion structs
  kunit: consolidate KUNIT_INIT_BINARY_ASSERT_STRUCT macros
  kunit: remove va_format from kunit_assert
  kunit: tool: drop mostly unused KunitResult.result field
  kunit: decrease macro layering for EQ/NE asserts
  kunit: decrease macro layering for integer asserts
  kunit: reduce layering in string assertion macros
  kunit: drop unused intermediate macros for ptr inequality checks
  kunit: make KUNIT_EXPECT_EQ() use KUNIT_EXPECT_EQ_MSG(), etc.
  kunit: drop unused assert_type from kunit_assert and clean up macros
  kunit: split out part of kunit_assert into a static const
  kunit: factor out kunit_base_assert_format() call into kunit_fail()
  kunit: drop unused kunit* field in kunit_assert
  kunit: move check if assertion passed into the macros
  kunit: add example test case showing off all the expect macros
parents 23d1dea5 5debe5bf

include/kunit/assert.h

+61 −159
Original line number Diff line number Diff line
@@ -29,56 +29,32 @@ 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.

 * @message: an optional message to provide additional context.

 * @format: a function which formats the data in this kunit_assert to a string.

 *

 * Represents a failed expectation/assertion. Contains all the data necessary to

 * format a string to a user reporting the failure.

 * struct kunit_loc - Identifies the source location of a line of code.

 * @line: the line number in the file.

 * @file: the file name.

 */

struct kunit_assert {

	struct kunit *test;

	enum kunit_assert_type type;

struct kunit_loc {

	int line;

	const char *file;

	struct va_format message;

	void (*format)(const struct kunit_assert *assert,

		       struct string_stream *stream);

};



/**

 * KUNIT_INIT_VA_FMT_NULL - Default initializer for struct va_format.

 *

 * Used inside a struct initialization block to initialize struct va_format to

 * default values where fmt and va are null.

 */

#define KUNIT_INIT_VA_FMT_NULL { .fmt = NULL, .va = NULL }

#define KUNIT_CURRENT_LOC { .file = __FILE__, .line = __LINE__ }



/**

 * 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.

 * struct kunit_assert - Data for printing a failed assertion or expectation.

 * @format: a function which formats the data in this kunit_assert to a string.

 *

 * The base initializer for a &struct kunit_assert.

 * Represents a failed expectation/assertion. Contains all the data necessary to

 * format a string to a user reporting the failure.

 */

#define KUNIT_INIT_ASSERT_STRUCT(kunit, assert_type, fmt) {		       \

	.test = kunit,							       \

	.type = assert_type,						       \

	.file = __FILE__,						       \

	.line = __LINE__,						       \

	.message = KUNIT_INIT_VA_FMT_NULL,				       \

	.format = fmt							       \

}



void kunit_base_assert_format(const struct kunit_assert *assert,

struct kunit_assert {

	void (*format)(const struct kunit_assert *assert,

		       const struct va_format *message,

		       struct string_stream *stream);

};



void kunit_assert_print_msg(const struct kunit_assert *assert,

void kunit_assert_prologue(const struct kunit_loc *loc,

			   enum kunit_assert_type type,

			   struct string_stream *stream);



/**
@@ -92,20 +68,17 @@ struct kunit_fail_assert { 
};



void kunit_fail_assert_format(const struct kunit_assert *assert,

			      const struct va_format *message,

			      struct string_stream *stream);



/**

 * 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.

 * KUNIT_INIT_FAIL_ASSERT_STRUCT - Initializer for &struct kunit_fail_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,			       \

					   kunit_fail_assert_format)	       \

#define KUNIT_INIT_FAIL_ASSERT_STRUCT {					\

	.assert = { .format = kunit_fail_assert_format },		\

}



/**
@@ -125,22 +98,19 @@ struct kunit_unary_assert { 
};



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.

 * @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.

 *

 * 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,			       \

					   kunit_unary_assert_format),	       \

#define KUNIT_INIT_UNARY_ASSERT_STRUCT(cond, expect_true) {		       \

	.assert = { .format = kunit_unary_assert_format },		       \

	.condition = cond,						       \

	.expected_true = expect_true					       \

}
@@ -162,35 +132,43 @@ struct kunit_ptr_not_err_assert { 
};



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.

 * @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.

 *

 * 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,			       \

					   kunit_ptr_not_err_assert_format),   \

#define KUNIT_INIT_PTR_NOT_ERR_STRUCT(txt, val) {			       \

	.assert = { .format = kunit_ptr_not_err_assert_format },	       \

	.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.

 * @operation: A string representation of the comparison operator (e.g. "==").

 * @left_text: A string representation of the left expression (e.g. "2+2").

 * @right_text: A string representation of the right expression (e.g. "2+2").

 */

struct kunit_binary_assert_text {

	const char *operation;

	const char *left_text;

	const char *right_text;

};



/**

 * struct kunit_binary_assert - An expectation/assertion that compares two

 *	non-pointer values (for example, KUNIT_EXPECT_EQ(test, 1 + 1, 2)).

 * @assert: The parent of this type.

 * @operation: A string representation of the comparison operator (e.g. "==").

 * @left_text: A string representation of the expression in the left slot.

 * @text: Holds the textual representations of the operands and op (e.g.  "==").

 * @left_value: The actual evaluated value of the expression in the left slot.

 * @right_text: A string representation of the expression in the right slot.

 * @right_value: The actual evaluated value of the expression in the right slot.

 *

 * Represents an expectation/assertion that compares two non-pointer values. For
@@ -199,44 +177,36 @@ void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert, 
 */

struct kunit_binary_assert {

	struct kunit_assert assert;

	const char *operation;

	const char *left_text;

	const struct kunit_binary_assert_text *text;

	long long left_value;

	const char *right_text;

	long long right_value;

};



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

 *	&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.

 * KUNIT_INIT_BINARY_ASSERT_STRUCT() - Initializes a binary assert like

 *	kunit_binary_assert, kunit_binary_ptr_assert, etc.

 *

 * @format_func: a function which formats the assert to a string.

 * @text_: Pointer to a kunit_binary_assert_text.

 * @left_val: The actual evaluated value of the expression in the left slot.

 * @right_str: A string representation of the expression in the right slot.

 * @right_val: The actual evaluated value of the expression in the right slot.

 *

 * Initializes a &struct kunit_binary_assert. Intended to be used in

 * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.

 * 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(test,				       \

					type,				       \

					op_str,				       \

					left_str,			       \

#define KUNIT_INIT_BINARY_ASSERT_STRUCT(format_func,			       \

					text_,				       \

					left_val,			       \

					right_str,			       \

					right_val) {			       \

	.assert = KUNIT_INIT_ASSERT_STRUCT(test,			       \

					   type,			       \

					   kunit_binary_assert_format),	       \

	.operation = op_str,						       \

	.left_text = left_str,						       \

	.assert = { .format = format_func },				       \

	.text = text_,							       \

	.left_value = left_val,						       \

	.right_text = right_str,					       \

	.right_value = right_val					       \

}
@@ -244,10 +214,8 @@ void kunit_binary_assert_format(const struct kunit_assert *assert, 
 * struct kunit_binary_ptr_assert - An expectation/assertion that compares two

 *	pointer values (for example, KUNIT_EXPECT_PTR_EQ(test, foo, bar)).

 * @assert: The parent of this type.

 * @operation: A string representation of the comparison operator (e.g. "==").

 * @left_text: A string representation of the expression in the left slot.

 * @text: Holds the textual representations of the operands and op (e.g.  "==").

 * @left_value: The actual evaluated value of the expression in the left slot.

 * @right_text: A string representation of the expression in the right slot.

 * @right_value: The actual evaluated value of the expression in the right slot.

 *

 * Represents an expectation/assertion that compares two pointer values. For
@@ -256,55 +224,21 @@ void kunit_binary_assert_format(const struct kunit_assert *assert, 
 */

struct kunit_binary_ptr_assert {

	struct kunit_assert assert;

	const char *operation;

	const char *left_text;

	const struct kunit_binary_assert_text *text;

	const void *left_value;

	const char *right_text;

	const void *right_value;

};



void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,

				    const struct va_format *message,

				    struct string_stream *stream);



/**

 * 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.

 * @left_val: The actual evaluated value of the expression in the left slot.

 * @right_str: A string representation of the expression in the right slot.

 * @right_val: The actual evaluated value of the expression in the right slot.

 *

 * 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,			       \

					    op_str,			       \

					    left_str,			       \

					    left_val,			       \

					    right_str,			       \

					    right_val) {		       \

	.assert = KUNIT_INIT_ASSERT_STRUCT(test,			       \

					   type,			       \

					   kunit_binary_ptr_assert_format),    \

	.operation = op_str,						       \

	.left_text = left_str,						       \

	.left_value = left_val,						       \

	.right_text = right_str,					       \

	.right_value = right_val					       \

}



/**

 * struct kunit_binary_str_assert - An expectation/assertion that compares two

 *	string values (for example, KUNIT_EXPECT_STREQ(test, foo, "bar")).

 * @assert: The parent of this type.

 * @operation: A string representation of the comparison operator (e.g. "==").

 * @left_text: A string representation of the expression in the left slot.

 * @text: Holds the textual representations of the operands and comparator.

 * @left_value: The actual evaluated value of the expression in the left slot.

 * @right_text: A string representation of the expression in the right slot.

 * @right_value: The actual evaluated value of the expression in the right slot.

 *

 * Represents an expectation/assertion that compares two string values. For
@@ -313,45 +247,13 @@ void kunit_binary_ptr_assert_format(const struct kunit_assert *assert, 
 */

struct kunit_binary_str_assert {

	struct kunit_assert assert;

	const char *operation;

	const char *left_text;

	const struct kunit_binary_assert_text *text;

	const char *left_value;

	const char *right_text;

	const char *right_value;

};



void kunit_binary_str_assert_format(const struct kunit_assert *assert,

				    const struct va_format *message,

				    struct string_stream *stream);



/**

 * 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.

 * @left_val: The actual evaluated value of the expression in the left slot.

 * @right_str: A string representation of the expression in the right slot.

 * @right_val: The actual evaluated value of the expression in the right slot.

 *

 * 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,			       \

					    op_str,			       \

					    left_str,			       \

					    left_val,			       \

					    right_str,			       \

					    right_val) {		       \

	.assert = KUNIT_INIT_ASSERT_STRUCT(test,			       \

					   type,			       \

					   kunit_binary_str_assert_format),    \

	.operation = op_str,						       \

	.left_text = left_str,						       \

	.left_value = left_val,						       \

	.right_text = right_str,					       \

	.right_value = right_val					       \

}



#endif /*  _KUNIT_ASSERT_H */

include/kunit/test.h

+190 −555

File changed.

Preview size limit exceeded, changes collapsed.

lib/kunit/assert.c

+40 −40
Original line number Diff line number Diff line
@@ -10,12 +10,13 @@ 


#include "string-stream.h"



void kunit_base_assert_format(const struct kunit_assert *assert,

void kunit_assert_prologue(const struct kunit_loc *loc,

			   enum kunit_assert_type type,

			      struct string_stream *stream)

{

	const char *expect_or_assert = NULL;



	switch (assert->type) {

	switch (type) {

	case KUNIT_EXPECTATION:

		expect_or_assert = "EXPECTATION";

		break;
@@ -25,34 +26,33 @@ void kunit_base_assert_format(const struct kunit_assert *assert, 
	}



	string_stream_add(stream, "%s FAILED at %s:%d\n",

			  expect_or_assert, assert->file, assert->line);

			  expect_or_assert, loc->file, loc->line);

}

EXPORT_SYMBOL_GPL(kunit_base_assert_format);

EXPORT_SYMBOL_GPL(kunit_assert_prologue);



void kunit_assert_print_msg(const struct kunit_assert *assert,

static void kunit_assert_print_msg(const struct va_format *message,

				   struct string_stream *stream)

{

	if (assert->message.fmt)

		string_stream_add(stream, "\n%pV", &assert->message);

	if (message->fmt)

		string_stream_add(stream, "\n%pV", message);

}

EXPORT_SYMBOL_GPL(kunit_assert_print_msg);



void kunit_fail_assert_format(const struct kunit_assert *assert,

			      const struct va_format *message,

			      struct string_stream *stream)

{

	kunit_base_assert_format(assert, stream);

	string_stream_add(stream, "%pV", &assert->message);

	string_stream_add(stream, "%pV", message);

}

EXPORT_SYMBOL_GPL(kunit_fail_assert_format);



void kunit_unary_assert_format(const struct kunit_assert *assert,

			       const struct va_format *message,

			       struct string_stream *stream)

{

	struct kunit_unary_assert *unary_assert;



	unary_assert = container_of(assert, struct kunit_unary_assert, assert);



	kunit_base_assert_format(assert, stream);

	if (unary_assert->expected_true)

		string_stream_add(stream,

				  KUNIT_SUBTEST_INDENT "Expected %s to be true, but is false\n",
@@ -61,11 +61,12 @@ void kunit_unary_assert_format(const struct kunit_assert *assert, 
		string_stream_add(stream,

				  KUNIT_SUBTEST_INDENT "Expected %s to be false, but is true\n",

				  unary_assert->condition);

	kunit_assert_print_msg(assert, stream);

	kunit_assert_print_msg(message, stream);

}

EXPORT_SYMBOL_GPL(kunit_unary_assert_format);



void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,

				     const struct va_format *message,

				     struct string_stream *stream)

{

	struct kunit_ptr_not_err_assert *ptr_assert;
@@ -73,7 +74,6 @@ void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert, 
	ptr_assert = container_of(assert, struct kunit_ptr_not_err_assert,

				  assert);



	kunit_base_assert_format(assert, stream);

	if (!ptr_assert->value) {

		string_stream_add(stream,

				  KUNIT_SUBTEST_INDENT "Expected %s is not null, but is\n",
@@ -84,7 +84,7 @@ void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert, 
				  ptr_assert->text,

				  PTR_ERR(ptr_assert->value));

	}

	kunit_assert_print_msg(assert, stream);

	kunit_assert_print_msg(message, stream);

}

EXPORT_SYMBOL_GPL(kunit_ptr_not_err_assert_format);
@@ -112,6 +112,7 @@ static bool is_literal(struct kunit *test, const char *text, long long value, 
}



void kunit_binary_assert_format(const struct kunit_assert *assert,

				const struct va_format *message,

				struct string_stream *stream)

{

	struct kunit_binary_assert *binary_assert;
@@ -119,27 +120,27 @@ void kunit_binary_assert_format(const struct kunit_assert *assert, 
	binary_assert = container_of(assert, struct kunit_binary_assert,

				     assert);



	kunit_base_assert_format(assert, stream);

	string_stream_add(stream,

			  KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",

			  binary_assert->left_text,

			  binary_assert->operation,

			  binary_assert->right_text);

	if (!is_literal(stream->test, binary_assert->left_text,

			  binary_assert->text->left_text,

			  binary_assert->text->operation,

			  binary_assert->text->right_text);

	if (!is_literal(stream->test, binary_assert->text->left_text,

			binary_assert->left_value, stream->gfp))

		string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld\n",

				  binary_assert->left_text,

				  binary_assert->text->left_text,

				  binary_assert->left_value);

	if (!is_literal(stream->test, binary_assert->right_text,

	if (!is_literal(stream->test, binary_assert->text->right_text,

			binary_assert->right_value, stream->gfp))

		string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld",

				  binary_assert->right_text,

				  binary_assert->text->right_text,

				  binary_assert->right_value);

	kunit_assert_print_msg(assert, stream);

	kunit_assert_print_msg(message, stream);

}

EXPORT_SYMBOL_GPL(kunit_binary_assert_format);



void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,

				    const struct va_format *message,

				    struct string_stream *stream)

{

	struct kunit_binary_ptr_assert *binary_assert;
@@ -147,19 +148,18 @@ void kunit_binary_ptr_assert_format(const struct kunit_assert *assert, 
	binary_assert = container_of(assert, struct kunit_binary_ptr_assert,

				     assert);



	kunit_base_assert_format(assert, stream);

	string_stream_add(stream,

			  KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",

			  binary_assert->left_text,

			  binary_assert->operation,

			  binary_assert->right_text);

			  binary_assert->text->left_text,

			  binary_assert->text->operation,

			  binary_assert->text->right_text);

	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px\n",

			  binary_assert->left_text,

			  binary_assert->text->left_text,

			  binary_assert->left_value);

	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px",

			  binary_assert->right_text,

			  binary_assert->text->right_text,

			  binary_assert->right_value);

	kunit_assert_print_msg(assert, stream);

	kunit_assert_print_msg(message, stream);

}

EXPORT_SYMBOL_GPL(kunit_binary_ptr_assert_format);
@@ -180,6 +180,7 @@ static bool is_str_literal(const char *text, const char *value) 
}



void kunit_binary_str_assert_format(const struct kunit_assert *assert,

				    const struct va_format *message,

				    struct string_stream *stream)

{

	struct kunit_binary_str_assert *binary_assert;
@@ -187,20 +188,19 @@ void kunit_binary_str_assert_format(const struct kunit_assert *assert, 
	binary_assert = container_of(assert, struct kunit_binary_str_assert,

				     assert);



	kunit_base_assert_format(assert, stream);

	string_stream_add(stream,

			  KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",

			  binary_assert->left_text,

			  binary_assert->operation,

			  binary_assert->right_text);

	if (!is_str_literal(binary_assert->left_text, binary_assert->left_value))

			  binary_assert->text->left_text,

			  binary_assert->text->operation,

			  binary_assert->text->right_text);

	if (!is_str_literal(binary_assert->text->left_text, binary_assert->left_value))

		string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"\n",

				  binary_assert->left_text,

				  binary_assert->text->left_text,

				  binary_assert->left_value);

	if (!is_str_literal(binary_assert->right_text, binary_assert->right_value))

	if (!is_str_literal(binary_assert->text->right_text, binary_assert->right_value))

		string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"",

				  binary_assert->right_text,

				  binary_assert->text->right_text,

				  binary_assert->right_value);

	kunit_assert_print_msg(assert, stream);

	kunit_assert_print_msg(message, stream);

}

EXPORT_SYMBOL_GPL(kunit_binary_str_assert_format);

lib/kunit/kunit-example-test.c

+42 −0
Original line number Diff line number Diff line
@@ -69,6 +69,47 @@ static void example_mark_skipped_test(struct kunit *test) 
	/* This line should run */

	kunit_info(test, "You should see this line.");

}



/*

 * This test shows off all the types of KUNIT_EXPECT macros.

 */

static void example_all_expect_macros_test(struct kunit *test)

{

	/* Boolean assertions */

	KUNIT_EXPECT_TRUE(test, true);

	KUNIT_EXPECT_FALSE(test, false);



	/* Integer assertions */

	KUNIT_EXPECT_EQ(test, 1, 1); /* check == */

	KUNIT_EXPECT_GE(test, 1, 1); /* check >= */

	KUNIT_EXPECT_LE(test, 1, 1); /* check <= */

	KUNIT_EXPECT_NE(test, 1, 0); /* check != */

	KUNIT_EXPECT_GT(test, 1, 0); /* check >  */

	KUNIT_EXPECT_LT(test, 0, 1); /* check <  */



	/* Pointer assertions */

	KUNIT_EXPECT_NOT_ERR_OR_NULL(test, test);

	KUNIT_EXPECT_PTR_EQ(test, NULL, NULL);

	KUNIT_EXPECT_PTR_NE(test, test, NULL);



	/* String assertions */

	KUNIT_EXPECT_STREQ(test, "hi", "hi");

	KUNIT_EXPECT_STRNEQ(test, "hi", "bye");



	/*

	 * There are also ASSERT variants of all of the above that abort test

	 * execution if they fail. Useful for memory allocations, etc.

	 */

	KUNIT_ASSERT_GT(test, sizeof(char), 0);



	/*

	 * There are also _MSG variants of all of the above that let you include

	 * additional text on failure.

	 */

	KUNIT_EXPECT_GT_MSG(test, sizeof(int), 0, "Your ints are 0-bit?!");

	KUNIT_ASSERT_GT_MSG(test, sizeof(int), 0, "Your ints are 0-bit?!");

}



/*

 * Here we make a list of all the test cases we want to add to the test suite

 * below.
@@ -83,6 +124,7 @@ static struct kunit_case example_test_cases[] = { 
	KUNIT_CASE(example_simple_test),

	KUNIT_CASE(example_skip_test),

	KUNIT_CASE(example_mark_skipped_test),

	KUNIT_CASE(example_all_expect_macros_test),

	{}

};

lib/kunit/test.c

+18 −17
Original line number Diff line number Diff line
@@ -240,7 +240,9 @@ static void kunit_print_string_stream(struct kunit *test, 
	}

}



static void kunit_fail(struct kunit *test, struct kunit_assert *assert)

static void kunit_fail(struct kunit *test, const struct kunit_loc *loc,

		       enum kunit_assert_type type, struct kunit_assert *assert,

		       const struct va_format *message)

{

	struct string_stream *stream;
@@ -250,12 +252,13 @@ static void kunit_fail(struct kunit *test, struct kunit_assert *assert) 
	if (!stream) {

		WARN(true,

		     "Could not allocate stream to print failed assertion in %s:%d\n",

		     assert->file,

		     assert->line);

		     loc->file,

		     loc->line);

		return;

	}



	assert->format(assert, stream);

	kunit_assert_prologue(loc, type, stream);

	assert->format(assert, message, stream);



	kunit_print_string_stream(test, stream);
@@ -275,29 +278,27 @@ static void __noreturn kunit_abort(struct kunit *test) 
	WARN_ONCE(true, "Throw could not abort from test!\n");

}



void kunit_do_assertion(struct kunit *test,

void kunit_do_failed_assertion(struct kunit *test,

			       const struct kunit_loc *loc,

			       enum kunit_assert_type type,

			       struct kunit_assert *assert,

			bool pass,

			       const char *fmt, ...)

{

	va_list args;



	if (pass)

		return;



	struct va_format message;

	va_start(args, fmt);



	assert->message.fmt = fmt;

	assert->message.va = &args;

	message.fmt = fmt;

	message.va = &args;



	kunit_fail(test, assert);

	kunit_fail(test, loc, type, assert, &message);



	va_end(args);



	if (assert->type == KUNIT_ASSERTION)

	if (type == KUNIT_ASSERTION)

		kunit_abort(test);

}

EXPORT_SYMBOL_GPL(kunit_do_assertion);

EXPORT_SYMBOL_GPL(kunit_do_failed_assertion);



void kunit_init_test(struct kunit *test, const char *name, char *log)

{