[mirror_ubuntu-jammy-kernel.git] / lib / kunit / assert.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Assertion and expectation serialization API.
 *
 * Copyright (C) 2019, Google LLC.
 * Author: Brendan Higgins <brendanhiggins@google.com>
 */
#include <kunit/assert.h>
#include <kunit/test.h>

#include "string-stream.h"

void kunit_base_assert_format(const struct kunit_assert *assert,
			      struct string_stream *stream)
{
	const char *expect_or_assert = NULL;

	switch (assert->type) {
	case KUNIT_EXPECTATION:
		expect_or_assert = "EXPECTATION";
		break;
	case KUNIT_ASSERTION:
		expect_or_assert = "ASSERTION";
		break;
	}

	string_stream_add(stream, "%s FAILED at %s:%d\n",
			  expect_or_assert, assert->file, assert->line);
}
EXPORT_SYMBOL_GPL(kunit_base_assert_format);

void kunit_assert_print_msg(const struct kunit_assert *assert,
			    struct string_stream *stream)
{
	if (assert->message.fmt)
		string_stream_add(stream, "\n%pV", &assert->message);
}
EXPORT_SYMBOL_GPL(kunit_assert_print_msg);

void kunit_fail_assert_format(const struct kunit_assert *assert,
			      struct string_stream *stream)
{
	kunit_base_assert_format(assert, stream);
	string_stream_add(stream, "%pV", &assert->message);
}
EXPORT_SYMBOL_GPL(kunit_fail_assert_format);

void kunit_unary_assert_format(const struct kunit_assert *assert,
			       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",
				  unary_assert->condition);
	else
		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);
}
EXPORT_SYMBOL_GPL(kunit_unary_assert_format);

void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
				     struct string_stream *stream)
{
	struct kunit_ptr_not_err_assert *ptr_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",
				  ptr_assert->text);
	} else if (IS_ERR(ptr_assert->value)) {
		string_stream_add(stream,
				  KUNIT_SUBTEST_INDENT "Expected %s is not error, but is: %ld\n",
				  ptr_assert->text,
				  PTR_ERR(ptr_assert->value));
	}
	kunit_assert_print_msg(assert, stream);
}
EXPORT_SYMBOL_GPL(kunit_ptr_not_err_assert_format);

/* Checks if `text` is a literal representing `value`, e.g. "5" and 5 */
static bool is_literal(struct kunit *test, const char *text, long long value,
		       gfp_t gfp)
{
	char *buffer;
	int len;
	bool ret;

	len = snprintf(NULL, 0, "%lld", value);
	if (strlen(text) != len)
		return false;

	buffer = kunit_kmalloc(test, len+1, gfp);
	if (!buffer)
		return false;

	snprintf(buffer, len+1, "%lld", value);
	ret = strncmp(buffer, text, len) == 0;

	kunit_kfree(test, buffer);
	return ret;
}

void kunit_binary_assert_format(const struct kunit_assert *assert,
				struct string_stream *stream)
{
	struct kunit_binary_assert *binary_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->left_value, stream->gfp))
		string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld\n",
				  binary_assert->left_text,
				  binary_assert->left_value);
	if (!is_literal(stream->test, binary_assert->right_text,
			binary_assert->right_value, stream->gfp))
		string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld",
				  binary_assert->right_text,
				  binary_assert->right_value);
	kunit_assert_print_msg(assert, stream);
}
EXPORT_SYMBOL_GPL(kunit_binary_assert_format);

void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,
				    struct string_stream *stream)
{
	struct kunit_binary_ptr_assert *binary_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);
	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px\n",
			  binary_assert->left_text,
			  binary_assert->left_value);
	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px",
			  binary_assert->right_text,
			  binary_assert->right_value);
	kunit_assert_print_msg(assert, stream);
}
EXPORT_SYMBOL_GPL(kunit_binary_ptr_assert_format);

/* Checks if KUNIT_EXPECT_STREQ() args were string literals.
 * Note: `text` will have ""s where as `value` will not.
 */
static bool is_str_literal(const char *text, const char *value)
{
	int len;

	len = strlen(text);
	if (len < 2)
		return false;
	if (text[0] != '\"' || text[len - 1] != '\"')
		return false;

	return strncmp(text + 1, value, len - 2) == 0;
}

void kunit_binary_str_assert_format(const struct kunit_assert *assert,
				    struct string_stream *stream)
{
	struct kunit_binary_str_assert *binary_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))
		string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"\n",
				  binary_assert->left_text,
				  binary_assert->left_value);
	if (!is_str_literal(binary_assert->right_text, binary_assert->right_value))
		string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"",
				  binary_assert->right_text,
				  binary_assert->right_value);
	kunit_assert_print_msg(assert, stream);
}
EXPORT_SYMBOL_GPL(kunit_binary_str_assert_format);
Commit	Line	Data
6b229e59 BH	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Assertion and expectation serialization API.
	4	*
	5	* Copyright (C) 2019, Google LLC.
	6	* Author: Brendan Higgins <brendanhiggins@google.com>
	7	*/
	8	#include <kunit/assert.h>
c3bba690	9	#include <kunit/test.h>
6b229e59	10
109fb06f AM	11	#include "string-stream.h"
109fb06f AM	12
6b229e59 BH	13	void kunit_base_assert_format(const struct kunit_assert *assert,
	14	struct string_stream *stream)
	15	{
	16	const char *expect_or_assert = NULL;
	17
	18	switch (assert->type) {
	19	case KUNIT_EXPECTATION:
	20	expect_or_assert = "EXPECTATION";
	21	break;
	22	case KUNIT_ASSERTION:
	23	expect_or_assert = "ASSERTION";
	24	break;
	25	}
	26
	27	string_stream_add(stream, "%s FAILED at %s:%d\n",
2f9f21cd	28	expect_or_assert, assert->file, assert->line);
6b229e59	29	}
c475c77d	30	EXPORT_SYMBOL_GPL(kunit_base_assert_format);
6b229e59 BH	31
	32	void kunit_assert_print_msg(const struct kunit_assert *assert,
	33	struct string_stream *stream)
	34	{
	35	if (assert->message.fmt)
	36	string_stream_add(stream, "\n%pV", &assert->message);
	37	}
c475c77d	38	EXPORT_SYMBOL_GPL(kunit_assert_print_msg);
6b229e59 BH	39
	40	void kunit_fail_assert_format(const struct kunit_assert *assert,
	41	struct string_stream *stream)
	42	{
	43	kunit_base_assert_format(assert, stream);
	44	string_stream_add(stream, "%pV", &assert->message);
	45	}
c475c77d	46	EXPORT_SYMBOL_GPL(kunit_fail_assert_format);
6b229e59 BH	47
	48	void kunit_unary_assert_format(const struct kunit_assert *assert,
	49	struct string_stream *stream)
	50	{
2f9f21cd LS	51	struct kunit_unary_assert *unary_assert;
	52
	53	unary_assert = container_of(assert, struct kunit_unary_assert, assert);
6b229e59 BH	54
	55	kunit_base_assert_format(assert, stream);
	56	if (unary_assert->expected_true)
	57	string_stream_add(stream,
c3bba690 AM	58	KUNIT_SUBTEST_INDENT "Expected %s to be true, but is false\n",
c3bba690 AM	59	unary_assert->condition);
6b229e59 BH	60	else
6b229e59 BH	61	string_stream_add(stream,
c3bba690 AM	62	KUNIT_SUBTEST_INDENT "Expected %s to be false, but is true\n",
c3bba690 AM	63	unary_assert->condition);
6b229e59 BH	64	kunit_assert_print_msg(assert, stream);
6b229e59 BH	65	}
c475c77d	66	EXPORT_SYMBOL_GPL(kunit_unary_assert_format);
6b229e59 BH	67
	68	void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
	69	struct string_stream *stream)
	70	{
2f9f21cd LS	71	struct kunit_ptr_not_err_assert *ptr_assert;
	72
	73	ptr_assert = container_of(assert, struct kunit_ptr_not_err_assert,
	74	assert);
6b229e59 BH	75
	76	kunit_base_assert_format(assert, stream);
	77	if (!ptr_assert->value) {
	78	string_stream_add(stream,
c3bba690 AM	79	KUNIT_SUBTEST_INDENT "Expected %s is not null, but is\n",
c3bba690 AM	80	ptr_assert->text);
6b229e59 BH	81	} else if (IS_ERR(ptr_assert->value)) {
6b229e59 BH	82	string_stream_add(stream,
c3bba690 AM	83	KUNIT_SUBTEST_INDENT "Expected %s is not error, but is: %ld\n",
	84	ptr_assert->text,
	85	PTR_ERR(ptr_assert->value));
6b229e59 BH	86	}
	87	kunit_assert_print_msg(assert, stream);
	88	}
c475c77d	89	EXPORT_SYMBOL_GPL(kunit_ptr_not_err_assert_format);
6b229e59	90
65af9b96 DL	91	/* Checks if `text` is a literal representing `value`, e.g. "5" and 5 */
	92	static bool is_literal(struct kunit test, const char text, long long value,
	93	gfp_t gfp)
	94	{
	95	char *buffer;
	96	int len;
	97	bool ret;
	98
	99	len = snprintf(NULL, 0, "%lld", value);
	100	if (strlen(text) != len)
	101	return false;
	102
	103	buffer = kunit_kmalloc(test, len+1, gfp);
	104	if (!buffer)
	105	return false;
	106
	107	snprintf(buffer, len+1, "%lld", value);
	108	ret = strncmp(buffer, text, len) == 0;
	109
	110	kunit_kfree(test, buffer);
	111	return ret;
	112	}
	113
6b229e59 BH	114	void kunit_binary_assert_format(const struct kunit_assert *assert,
	115	struct string_stream *stream)
	116	{
2f9f21cd LS	117	struct kunit_binary_assert *binary_assert;
	118
	119	binary_assert = container_of(assert, struct kunit_binary_assert,
	120	assert);
6b229e59 BH	121
	122	kunit_base_assert_format(assert, stream);
	123	string_stream_add(stream,
c3bba690 AM	124	KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
	125	binary_assert->left_text,
	126	binary_assert->operation,
	127	binary_assert->right_text);
65af9b96 DL	128	if (!is_literal(stream->test, binary_assert->left_text,
	129	binary_assert->left_value, stream->gfp))
	130	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld\n",
	131	binary_assert->left_text,
	132	binary_assert->left_value);
	133	if (!is_literal(stream->test, binary_assert->right_text,
	134	binary_assert->right_value, stream->gfp))
	135	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld",
	136	binary_assert->right_text,
	137	binary_assert->right_value);
6b229e59 BH	138	kunit_assert_print_msg(assert, stream);
6b229e59 BH	139	}
c475c77d	140	EXPORT_SYMBOL_GPL(kunit_binary_assert_format);
6b229e59 BH	141
	142	void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,
	143	struct string_stream *stream)
	144	{
2f9f21cd LS	145	struct kunit_binary_ptr_assert *binary_assert;
	146
	147	binary_assert = container_of(assert, struct kunit_binary_ptr_assert,
	148	assert);
6b229e59 BH	149
	150	kunit_base_assert_format(assert, stream);
	151	string_stream_add(stream,
c3bba690 AM	152	KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
	153	binary_assert->left_text,
	154	binary_assert->operation,
	155	binary_assert->right_text);
	156	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px\n",
	157	binary_assert->left_text,
	158	binary_assert->left_value);
	159	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px",
	160	binary_assert->right_text,
	161	binary_assert->right_value);
6b229e59 BH	162	kunit_assert_print_msg(assert, stream);
6b229e59 BH	163	}
c475c77d	164	EXPORT_SYMBOL_GPL(kunit_binary_ptr_assert_format);
6b229e59	165
acd97625 DL	166	/* Checks if KUNIT_EXPECT_STREQ() args were string literals.
	167	* Note: `text` will have ""s where as `value` will not.
	168	*/
	169	static bool is_str_literal(const char text, const char value)
	170	{
	171	int len;
	172
	173	len = strlen(text);
	174	if (len < 2)
	175	return false;
	176	if (text[0] != '\"' \|\| text[len - 1] != '\"')
	177	return false;
	178
	179	return strncmp(text + 1, value, len - 2) == 0;
	180	}
	181
6b229e59 BH	182	void kunit_binary_str_assert_format(const struct kunit_assert *assert,
	183	struct string_stream *stream)
	184	{
2f9f21cd LS	185	struct kunit_binary_str_assert *binary_assert;
	186
	187	binary_assert = container_of(assert, struct kunit_binary_str_assert,
	188	assert);
6b229e59 BH	189
	190	kunit_base_assert_format(assert, stream);
	191	string_stream_add(stream,
c3bba690 AM	192	KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
	193	binary_assert->left_text,
	194	binary_assert->operation,
	195	binary_assert->right_text);
acd97625 DL	196	if (!is_str_literal(binary_assert->left_text, binary_assert->left_value))
	197	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"\n",
	198	binary_assert->left_text,
	199	binary_assert->left_value);
	200	if (!is_str_literal(binary_assert->right_text, binary_assert->right_value))
	201	string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"",
	202	binary_assert->right_text,
	203	binary_assert->right_value);
6b229e59 BH	204	kunit_assert_print_msg(assert, stream);
6b229e59 BH	205	}
c475c77d	206	EXPORT_SYMBOL_GPL(kunit_binary_str_assert_format);