Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389// SPDX-License-Identifier: GPL-2.0-or-later/* * KUnit test for the assertion formatting functions. * Author: Ivan Orlov <ivan.orlov0322@gmail.com> */#include <kunit/test.h>#include "string-stream.h"
#define TEST_PTR_EXPECTED_BUF_SIZE 32#define HEXDUMP_TEST_BUF_LEN 5#define ASSERT_TEST_EXPECT_CONTAIN(test, str, substr) KUNIT_EXPECT_TRUE(test, strstr(str, substr))#define ASSERT_TEST_EXPECT_NCONTAIN(test, str, substr) KUNIT_EXPECT_FALSE(test, strstr(str, substr))
static void kunit_test_is_literal(struct kunit *test){ KUNIT_EXPECT_TRUE(test, is_literal("5", 5)); KUNIT_EXPECT_TRUE(test, is_literal("0", 0)); KUNIT_EXPECT_TRUE(test, is_literal("1234567890", 1234567890)); KUNIT_EXPECT_TRUE(test, is_literal("-1234567890", -1234567890)); KUNIT_EXPECT_FALSE(test, is_literal("05", 5)); KUNIT_EXPECT_FALSE(test, is_literal("", 0)); KUNIT_EXPECT_FALSE(test, is_literal("-0", 0)); KUNIT_EXPECT_FALSE(test, is_literal("12#45", 1245));}
static void kunit_test_is_str_literal(struct kunit *test){ KUNIT_EXPECT_TRUE(test, is_str_literal("\"Hello, World!\"", "Hello, World!")); KUNIT_EXPECT_TRUE(test, is_str_literal("\"\"", "")); KUNIT_EXPECT_TRUE(test, is_str_literal("\"\"\"", "\"")); KUNIT_EXPECT_FALSE(test, is_str_literal("", "")); KUNIT_EXPECT_FALSE(test, is_str_literal("\"", "\"")); KUNIT_EXPECT_FALSE(test, is_str_literal("\"Abacaba", "Abacaba")); KUNIT_EXPECT_FALSE(test, is_str_literal("Abacaba\"", "Abacaba")); KUNIT_EXPECT_FALSE(test, is_str_literal("\"Abacaba\"", "\"Abacaba\""));}
KUNIT_DEFINE_ACTION_WRAPPER(kfree_wrapper, kfree, const void *);
/* this function is used to get a "char *" string from the string stream and defer its cleanup */static char *get_str_from_stream(struct kunit *test, struct string_stream *stream){ char *str = string_stream_get_string(stream);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, str); kunit_add_action(test, kfree_wrapper, (void *)str);
return str;}
static void kunit_test_assert_prologue(struct kunit *test){ struct string_stream *stream; char *str; const struct kunit_loc location = { .file = "testfile.c", .line = 1337, };
stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream);
/* Test an expectation fail prologue */ kunit_assert_prologue(&location, KUNIT_EXPECTATION, stream); str = get_str_from_stream(test, stream); ASSERT_TEST_EXPECT_CONTAIN(test, str, "EXPECTATION"); ASSERT_TEST_EXPECT_CONTAIN(test, str, "testfile.c"); ASSERT_TEST_EXPECT_CONTAIN(test, str, "1337");
/* Test an assertion fail prologue */ string_stream_clear(stream); kunit_assert_prologue(&location, KUNIT_ASSERTION, stream); str = get_str_from_stream(test, stream); ASSERT_TEST_EXPECT_CONTAIN(test, str, "ASSERTION"); ASSERT_TEST_EXPECT_CONTAIN(test, str, "testfile.c"); ASSERT_TEST_EXPECT_CONTAIN(test, str, "1337");}
/* * This function accepts an arbitrary count of parameters and generates a va_format struct, * which can be used to validate kunit_assert_print_msg function */static void verify_assert_print_msg(struct kunit *test, struct string_stream *stream, char *expected, const char *format, ...){ va_list list; const struct va_format vformat = { .fmt = format, .va = &list, };
va_start(list, format); string_stream_clear(stream); kunit_assert_print_msg(&vformat, stream); KUNIT_EXPECT_STREQ(test, get_str_from_stream(test, stream), expected);}
static void kunit_test_assert_print_msg(struct kunit *test){ struct string_stream *stream;
stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream);
verify_assert_print_msg(test, stream, "\nTest", "Test"); verify_assert_print_msg(test, stream, "\nAbacaba -123 234", "%s %d %u", "Abacaba", -123, 234U); verify_assert_print_msg(test, stream, "", NULL);}
/* * Further code contains the tests for different assert format functions. * This helper function accepts the assert format function, executes it and * validates the result string from the stream by checking that all of the * substrings exist in the output. */static void validate_assert(assert_format_t format_func, struct kunit *test, const struct kunit_assert *assert, struct string_stream *stream, int num_checks, ...){ size_t i; va_list checks; char *cur_substr_exp; struct va_format message = { NULL, NULL };
va_start(checks, num_checks); string_stream_clear(stream); format_func(assert, &message, stream);
for (i = 0; i < num_checks; i++) { cur_substr_exp = va_arg(checks, char *); ASSERT_TEST_EXPECT_CONTAIN(test, get_str_from_stream(test, stream), cur_substr_exp); }}
static void kunit_test_unary_assert_format(struct kunit *test){ struct string_stream *stream; struct kunit_assert assert = {}; struct kunit_unary_assert un_assert = { .assert = assert, .condition = "expr", .expected_true = true, };
stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream);
validate_assert(kunit_unary_assert_format, test, &un_assert.assert, stream, 2, "true", "is false");
un_assert.expected_true = false; validate_assert(kunit_unary_assert_format, test, &un_assert.assert, stream, 2, "false", "is true");}
static void kunit_test_ptr_not_err_assert_format(struct kunit *test){ struct string_stream *stream; struct kunit_assert assert = {}; struct kunit_ptr_not_err_assert not_err_assert = { .assert = assert, .text = "expr", .value = NULL, };
stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream);
/* Value is NULL. The corresponding message should be printed out */ validate_assert(kunit_ptr_not_err_assert_format, test, ¬_err_assert.assert, stream, 1, "null");
/* Value is not NULL, but looks like an error pointer. Error should be printed out */ not_err_assert.value = (void *)-12; validate_assert(kunit_ptr_not_err_assert_format, test, ¬_err_assert.assert, stream, 2, "error", "-12");}
static void kunit_test_binary_assert_format(struct kunit *test){ struct string_stream *stream; struct kunit_assert assert = {}; struct kunit_binary_assert_text text = { .left_text = "1 + 2", .operation = "==", .right_text = "2", }; const struct kunit_binary_assert binary_assert = { .assert = assert, .text = &text, .left_value = 3, .right_value = 2, };
stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream);
/* * Printed values should depend on the input we provide: the left text, right text, left * value and the right value. */ validate_assert(kunit_binary_assert_format, test, &binary_assert.assert, stream, 4, "1 + 2", "2", "3", "==");
text.right_text = "4 - 2"; validate_assert(kunit_binary_assert_format, test, &binary_assert.assert, stream, 3, "==", "1 + 2", "4 - 2");
text.left_text = "3"; validate_assert(kunit_binary_assert_format, test, &binary_assert.assert, stream, 4, "3", "4 - 2", "2", "==");
text.right_text = "2"; validate_assert(kunit_binary_assert_format, test, &binary_assert.assert, stream, 3, "3", "2", "==");}
static void kunit_test_binary_ptr_assert_format(struct kunit *test){ struct string_stream *stream; struct kunit_assert assert = {}; char *addr_var_a, *addr_var_b; static const void *var_a = (void *)0xDEADBEEF; static const void *var_b = (void *)0xBADDCAFE; struct kunit_binary_assert_text text = { .left_text = "var_a", .operation = "==", .right_text = "var_b", }; struct kunit_binary_ptr_assert binary_ptr_assert = { .assert = assert, .text = &text, .left_value = var_a, .right_value = var_b, };
addr_var_a = kunit_kzalloc(test, TEST_PTR_EXPECTED_BUF_SIZE, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, addr_var_a); addr_var_b = kunit_kzalloc(test, TEST_PTR_EXPECTED_BUF_SIZE, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, addr_var_b); /* * Print the addresses to the buffers first. * This is necessary as we may have different count of leading zeros in the pointer * on different architectures. */ snprintf(addr_var_a, TEST_PTR_EXPECTED_BUF_SIZE, "%px", var_a); snprintf(addr_var_b, TEST_PTR_EXPECTED_BUF_SIZE, "%px", var_b);
stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); validate_assert(kunit_binary_ptr_assert_format, test, &binary_ptr_assert.assert, stream, 3, addr_var_a, addr_var_b, "==");}
static void kunit_test_binary_str_assert_format(struct kunit *test){ struct string_stream *stream; struct kunit_assert assert = {}; static const char *var_a = "abacaba"; static const char *var_b = "kernel"; struct kunit_binary_assert_text text = { .left_text = "var_a", .operation = "==", .right_text = "var_b", }; struct kunit_binary_str_assert binary_str_assert = { .assert = assert, .text = &text, .left_value = var_a, .right_value = var_b, };
stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream);
validate_assert(kunit_binary_str_assert_format, test, &binary_str_assert.assert, stream, 5, "var_a", "var_b", "\"abacaba\"", "\"kernel\"", "==");
text.left_text = "\"abacaba\""; validate_assert(kunit_binary_str_assert_format, test, &binary_str_assert.assert, stream, 4, "\"abacaba\"", "var_b", "\"kernel\"", "==");
text.right_text = "\"kernel\""; validate_assert(kunit_binary_str_assert_format, test, &binary_str_assert.assert, stream, 3, "\"abacaba\"", "\"kernel\"", "==");}
static const u8 hex_testbuf1[] = { 0x26, 0x74, 0x6b, 0x9c, 0x55, 0x45, 0x9d, 0x47, 0xd6, 0x47, 0x2, 0x89, 0x8c, 0x81, 0x94, 0x12, 0xfe, 0x01 };static const u8 hex_testbuf2[] = { 0x26, 0x74, 0x6b, 0x9c, 0x55, 0x45, 0x9d, 0x47, 0x21, 0x47, 0xcd, 0x89, 0x24, 0x50, 0x94, 0x12, 0xba, 0x01 };static void kunit_test_assert_hexdump(struct kunit *test){ struct string_stream *stream; char *str; size_t i; char buf[HEXDUMP_TEST_BUF_LEN];
stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); /* Check that we are getting output like <xx> for non-matching numbers. */ kunit_assert_hexdump(stream, hex_testbuf1, hex_testbuf2, sizeof(hex_testbuf1)); str = get_str_from_stream(test, stream); for (i = 0; i < sizeof(hex_testbuf1); i++) { snprintf(buf, HEXDUMP_TEST_BUF_LEN, "<%02x>", hex_testbuf1[i]); if (hex_testbuf1[i] != hex_testbuf2[i]) ASSERT_TEST_EXPECT_CONTAIN(test, str, buf); } /* We shouldn't get any <xx> numbers when comparing the buffer with itself. */ string_stream_clear(stream); kunit_assert_hexdump(stream, hex_testbuf1, hex_testbuf1, sizeof(hex_testbuf1)); str = get_str_from_stream(test, stream); ASSERT_TEST_EXPECT_NCONTAIN(test, str, "<"); ASSERT_TEST_EXPECT_NCONTAIN(test, str, ">");}
static void kunit_test_mem_assert_format(struct kunit *test){ struct string_stream *stream; struct string_stream *expected_stream; struct kunit_assert assert = {}; static const struct kunit_binary_assert_text text = { .left_text = "hex_testbuf1", .operation = "==", .right_text = "hex_testbuf2", }; struct kunit_mem_assert mem_assert = { .assert = assert, .text = &text, .left_value = NULL, .right_value = hex_testbuf2, .size = sizeof(hex_testbuf1), };
expected_stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected_stream); stream = kunit_alloc_string_stream(test, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream);
/* The left value is NULL */ validate_assert(kunit_mem_assert_format, test, &mem_assert.assert, stream, 2, "hex_testbuf1", "is not null");
/* The right value is NULL, the left value is not NULL */ mem_assert.left_value = hex_testbuf1; mem_assert.right_value = NULL; validate_assert(kunit_mem_assert_format, test, &mem_assert.assert, stream, 2, "hex_testbuf2", "is not null");
/* Both arguments are not null */ mem_assert.left_value = hex_testbuf1; mem_assert.right_value = hex_testbuf2;
validate_assert(kunit_mem_assert_format, test, &mem_assert.assert, stream, 3, "hex_testbuf1", "hex_testbuf2", "==");}
static struct kunit_case assert_test_cases[] = { KUNIT_CASE(kunit_test_is_literal), KUNIT_CASE(kunit_test_is_str_literal), KUNIT_CASE(kunit_test_assert_prologue), KUNIT_CASE(kunit_test_assert_print_msg), KUNIT_CASE(kunit_test_unary_assert_format), KUNIT_CASE(kunit_test_ptr_not_err_assert_format), KUNIT_CASE(kunit_test_binary_assert_format), KUNIT_CASE(kunit_test_binary_ptr_assert_format), KUNIT_CASE(kunit_test_binary_str_assert_format), KUNIT_CASE(kunit_test_assert_hexdump), KUNIT_CASE(kunit_test_mem_assert_format), {}};
static struct kunit_suite assert_test_suite = { .name = "kunit-assert", .test_cases = assert_test_cases,};
kunit_test_suites(&assert_test_suite);