From: Brendan Higgins <brendanhiggins@google.com>
To: gregkh@linuxfoundation.org, keescook@google.com,
mcgrof@kernel.org, shuah@kernel.org
Cc: joel@jms.id.au, mpe@ellerman.id.au, joe@perches.com,
brakmo@fb.com, rostedt@goodmis.org, Tim.Bird@sony.com,
khilman@baylibre.com, julia.lawall@lip6.fr,
linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com,
linux-kernel@vger.kernel.org, jdike@addtoit.com, richard@nod.at,
linux-um@lists.infradead.org,
Brendan Higgins <brendanhiggins@google.com>
Subject: [RFC v1 18/31] kunit: mock: added parameter formatters
Date: Tue, 16 Oct 2018 16:51:07 -0700 [thread overview]
Message-ID: <20181016235120.138227-19-brendanhiggins@google.com> (raw)
In-Reply-To: <20181016235120.138227-1-brendanhiggins@google.com>
Added parameter formatters which provide string formatting for
parameters that have no matchers to be matched against.
Signed-off-by: Brendan Higgins <brendanhiggins@google.com>
---
include/kunit/mock.h | 49 +++++++++++++++
kunit/common-mocks.c | 132 +++++++++++++++++++++++++++++++++++++++
kunit/mock.c | 48 ++++++++++++--
kunit/test-stream-test.c | 28 +++++++++
4 files changed, 252 insertions(+), 5 deletions(-)
diff --git a/include/kunit/mock.h b/include/kunit/mock.h
index daf965cf954e6..4f85b39d628d0 100644
--- a/include/kunit/mock.h
+++ b/include/kunit/mock.h
@@ -123,6 +123,18 @@ struct mock_expectation *mock_add_matcher(struct mock *mock,
struct mock_param_matcher *matchers[],
int len);
+struct mock_param_formatter {
+ struct list_head node;
+ const char *type_name;
+ void (*format)(struct mock_param_formatter *formatter,
+ struct test_stream *stream,
+ const void *param);
+};
+
+void mock_register_formatter(struct mock_param_formatter *formatter);
+
+void mock_unregister_formatter(struct mock_param_formatter *formatter);
+
#define MOCK(name) name##_mock
/**
@@ -834,4 +846,41 @@ struct mock_param_matcher *test_struct_cmp(
const char *struct_name,
struct mock_struct_matcher_entry *entries);
+struct mock_struct_formatter_entry {
+ size_t member_offset;
+ struct mock_param_formatter *formatter;
+};
+
+static inline void init_mock_struct_formatter_entry_internal(
+ struct mock_struct_formatter_entry *entry,
+ size_t offset,
+ struct mock_param_formatter *formatter)
+{
+ entry->member_offset = offset;
+ entry->formatter = formatter;
+}
+
+#define INIT_MOCK_STRUCT_FORMATTER_ENTRY(entry, type, member, formatter) \
+ init_mock_struct_formatter_entry_internal(entry, \
+ offsetof(type, \
+ member), \
+ formatter)
+
+static inline void INIT_MOCK_STRUCT_FORMATTER_ENTRY_LAST(
+ struct mock_struct_formatter_entry *entry)
+{
+ entry->formatter = NULL;
+}
+
+struct mock_param_formatter *mock_struct_formatter(
+ struct test *test,
+ const char *struct_name,
+ struct mock_struct_formatter_entry *entries);
+
+struct mock_param_formatter *mock_find_formatter(const char *type_name);
+
+#define FORMATTER_FROM_TYPE(type) mock_find_formatter(#type)
+
+extern struct mock_param_formatter unknown_formatter[];
+
#endif /* _KUNIT_MOCK_H */
diff --git a/kunit/common-mocks.c b/kunit/common-mocks.c
index ef88f8b8acda3..1c52522808cab 100644
--- a/kunit/common-mocks.c
+++ b/kunit/common-mocks.c
@@ -386,3 +386,135 @@ DEFINE_RETURN_ACTION_WITH_TYPENAME(longlong, long long);
DEFINE_RETURN_ACTION_WITH_TYPENAME(ulonglong, unsigned long long);
DEFINE_RETURN_ACTION_WITH_TYPENAME(ptr, void *);
+struct mock_param_integer_formatter {
+ struct mock_param_formatter formatter;
+ const char *fmt_str;
+};
+
+static void mock_format_integer(struct mock_param_formatter *pformatter,
+ struct test_stream *stream,
+ const void *pparam)
+{
+ struct mock_param_integer_formatter *formatter =
+ container_of(pformatter,
+ struct mock_param_integer_formatter,
+ formatter);
+ long long param = CONVERT_TO_ACTUAL_TYPE(long long, pparam);
+
+ stream->add(stream, formatter->fmt_str, param);
+}
+
+#define INTEGER_FORMATTER_INIT(type, fmt) { \
+ .formatter = { \
+ .type_name = #type, \
+ .format = mock_format_integer, \
+ }, \
+ .fmt_str = fmt, \
+}
+
+static struct mock_param_integer_formatter integer_formatters[] = {
+ INTEGER_FORMATTER_INIT(u8, "%PRIu8"),
+ INTEGER_FORMATTER_INIT(u16, "%PRIu16"),
+ INTEGER_FORMATTER_INIT(u32, "%PRIu32"),
+ INTEGER_FORMATTER_INIT(u64, "%PRIu64"),
+ INTEGER_FORMATTER_INIT(char, "%c"),
+ INTEGER_FORMATTER_INIT(unsigned char, "%hhu"),
+ INTEGER_FORMATTER_INIT(signed char, "%hhd"),
+ INTEGER_FORMATTER_INIT(short, "%hd"),
+ INTEGER_FORMATTER_INIT(unsigned short, "%hu"),
+ INTEGER_FORMATTER_INIT(int, "%d"),
+ INTEGER_FORMATTER_INIT(unsigned int, "%u"),
+ INTEGER_FORMATTER_INIT(long, "%ld"),
+ INTEGER_FORMATTER_INIT(unsigned long, "%lu"),
+ INTEGER_FORMATTER_INIT(long long, "%lld"),
+ INTEGER_FORMATTER_INIT(unsigned long long, "%llu"),
+ INTEGER_FORMATTER_INIT(void *, "%px"),
+};
+
+static void mock_format_string(struct mock_param_formatter *formatter,
+ struct test_stream *stream,
+ const void *pparam)
+{
+ const char *param = CONVERT_TO_ACTUAL_TYPE(const char *, pparam);
+
+ stream->add(stream, "%s", param);
+}
+
+static struct mock_param_formatter string_formatter = {
+ .type_name = "const char *",
+ .format = mock_format_string,
+};
+
+static void mock_format_unknown(struct mock_param_formatter *formatter,
+ struct test_stream *stream,
+ const void *param)
+{
+ stream->add(stream, "%pS", param);
+}
+
+struct mock_param_formatter unknown_formatter[] = {
+ {
+ .type_name = "<unknown>",
+ .format = mock_format_unknown,
+ },
+ {},
+};
+
+static int mock_register_all_formatters(void)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(integer_formatters); i++)
+ mock_register_formatter(&integer_formatters[i].formatter);
+
+ mock_register_formatter(&string_formatter);
+
+ return 0;
+}
+test_pure_initcall(mock_register_all_formatters);
+
+struct mock_struct_formatter {
+ struct mock_param_formatter formatter;
+ const char *type_name;
+ struct mock_struct_formatter_entry *entries;
+};
+
+static void mock_format_struct(struct mock_param_formatter *pformatter,
+ struct test_stream *stream,
+ const void *pparam)
+{
+ struct mock_struct_formatter *formatter =
+ container_of(pformatter,
+ struct mock_struct_formatter,
+ formatter);
+ struct mock_struct_formatter_entry *entry;
+ const char *param = CONVERT_TO_ACTUAL_TYPE(const char *, pparam);
+ const char *member_ptr;
+
+ stream->add(stream, "%s {", formatter->type_name);
+ for (entry = formatter->entries; entry->formatter; entry++) {
+ member_ptr = param + entry->member_offset;
+ entry->formatter->format(entry->formatter, stream, member_ptr);
+ stream->add(stream, ", ");
+ }
+ stream->add(stream, "}");
+}
+
+struct mock_param_formatter *mock_struct_formatter(
+ struct test *test,
+ const char *type_name,
+ struct mock_struct_formatter_entry *entries)
+{
+ struct mock_struct_formatter *formatter;
+
+ formatter = test_kzalloc(test, sizeof(*formatter), GFP_KERNEL);
+ if (!formatter)
+ return NULL;
+
+ formatter->formatter.type_name = type_name;
+ formatter->formatter.format = mock_format_struct;
+ formatter->type_name = type_name;
+ formatter->entries = entries;
+
+ return &formatter->formatter;
+}
diff --git a/kunit/mock.c b/kunit/mock.c
index 424c612de553b..9be6b2d3621c4 100644
--- a/kunit/mock.c
+++ b/kunit/mock.c
@@ -186,15 +186,53 @@ int mock_set_default_action(struct mock *mock,
return 0;
}
+struct mock_param_formatter_repo {
+ struct list_head formatters;
+};
+
+static struct mock_param_formatter_repo mock_param_formatter_repo = {
+ .formatters = LIST_HEAD_INIT(mock_param_formatter_repo.formatters),
+};
+
+void mock_register_formatter(struct mock_param_formatter *formatter)
+{
+ list_add_tail(&formatter->node, &mock_param_formatter_repo.formatters);
+}
+
+void mock_unregister_formatter(struct mock_param_formatter *formatter)
+{
+ list_del(&formatter->node);
+}
+
+struct mock_param_formatter *mock_find_formatter(const char *type_name)
+{
+ struct mock_param_formatter *formatter;
+
+ list_for_each_entry(formatter,
+ &mock_param_formatter_repo.formatters,
+ node) {
+ if (!strcmp(type_name, formatter->type_name))
+ return formatter;
+ }
+
+ return NULL;
+}
+
static void mock_format_param(struct test_stream *stream,
const char *type_name,
const void *param)
{
- /*
- * Cannot find formatter, so just print the pointer of the
- * symbol.
- */
- stream->add(stream, "<%pS>", param);
+ struct mock_param_formatter *formatter;
+
+ formatter = mock_find_formatter(type_name);
+ if (formatter)
+ formatter->format(formatter, stream, param);
+ else
+ /*
+ * Cannot find formatter, so just print the pointer of the
+ * symbol.
+ */
+ stream->add(stream, "<%pS>", param);
}
static void mock_add_method_declaration_to_stream(
diff --git a/kunit/test-stream-test.c b/kunit/test-stream-test.c
index 875b0db15878d..b335e09805a0f 100644
--- a/kunit/test-stream-test.c
+++ b/kunit/test-stream-test.c
@@ -116,6 +116,7 @@ static void test_stream_test_commits_any_uncommitted_when_cleanup(
static int test_stream_test_init(struct test *test)
{
+ struct mock_struct_formatter_entry *entries;
struct test_stream_test_context *ctx;
ctx = test_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
@@ -131,9 +132,35 @@ static int test_stream_test_init(struct test *test)
if (!ctx->stream)
return -ENOMEM;
+ entries = test_kzalloc(test, sizeof(*entries) * 3, GFP_KERNEL);
+ if (!entries) {
+ test_warn(test,
+ "Could not allocate arg formatter for struct va_format");
+ return 0;
+ }
+
+ INIT_MOCK_STRUCT_FORMATTER_ENTRY(&entries[0],
+ struct va_format,
+ fmt,
+ FORMATTER_FROM_TYPE(const char *));
+ INIT_MOCK_STRUCT_FORMATTER_ENTRY(&entries[1],
+ struct va_format,
+ va,
+ unknown_formatter);
+ INIT_MOCK_STRUCT_FORMATTER_ENTRY_LAST(&entries[2]);
+
+ mock_register_formatter(mock_struct_formatter(test,
+ "struct va_format *",
+ entries));
+
return 0;
}
+static void test_stream_test_exit(struct test *test)
+{
+ mock_unregister_formatter(mock_find_formatter("struct va_format *"));
+}
+
static struct test_case test_stream_test_cases[] = {
TEST_CASE(test_stream_test_add),
TEST_CASE(test_stream_test_append),
@@ -145,6 +172,7 @@ static struct test_case test_stream_test_cases[] = {
static struct test_module test_stream_test_module = {
.name = "test-stream-test",
.init = test_stream_test_init,
+ .exit = test_stream_test_exit,
.test_cases = test_stream_test_cases,
};
module_test(test_stream_test_module);
--
2.19.1.331.ge82ca0e54c-goog
next prev parent reply other threads:[~2018-10-16 23:54 UTC|newest]
Thread overview: 52+ messages / expand[flat|nested] mbox.gz Atom feed top
2018-10-16 23:50 [RFC v1 00/31] kunit: Introducing KUnit, the Linux kernel unit testing framework Brendan Higgins
2018-10-16 23:50 ` [RFC v1 01/31] kunit: test: added string_stream a std::stream like string builder Brendan Higgins
2018-10-16 23:50 ` [RFC v1 02/31] kunit: test: adds KUnit test runner core Brendan Higgins
2018-10-16 23:50 ` [RFC v1 03/31] kunit: test: added test resource management API Brendan Higgins
2018-10-16 23:50 ` [RFC v1 04/31] kunit: test: added test_stream a std::stream like logger Brendan Higgins
2018-10-16 23:50 ` [RFC v1 05/31] kunit: test: added the concept of expectations Brendan Higgins
2018-10-16 23:50 ` [RFC v1 06/31] arch: um: enabled running kunit from User Mode Linux Brendan Higgins
2018-10-17 15:29 ` Kieran Bingham
2018-10-17 17:43 ` Brendan Higgins
2018-10-17 17:52 ` Tim.Bird
2018-10-17 21:09 ` Brendan Higgins
2018-10-17 21:18 ` Tim.Bird
2018-10-17 22:45 ` Brendan Higgins
2018-10-16 23:50 ` [RFC v1 07/31] kunit: test: added initial tests Brendan Higgins
2018-10-16 23:50 ` [RFC v1 08/31] arch: um: added shim to trap to allow installing a fault catcher for tests Brendan Higgins
2018-10-16 23:50 ` [RFC v1 09/31] kunit: test: added the concept of assertions Brendan Higgins
2018-10-16 23:50 ` [RFC v1 10/31] kunit: test: added concept of initcalls Brendan Higgins
2018-10-16 23:51 ` [RFC v1 11/31] kunit: test: added concept of post conditions Brendan Higgins
2018-10-16 23:51 ` [RFC v1 12/31] checkpatch: added support for struct MOCK(foo) syntax Brendan Higgins
2018-10-16 23:59 ` Joe Perches
2018-10-17 0:03 ` Brendan Higgins
2018-10-16 23:51 ` [RFC v1 13/31] kunit: mock: added parameter list minipulation macros Brendan Higgins
2018-10-16 23:51 ` [RFC v1 14/31] kunit: mock: added internal mock infrastructure Brendan Higgins
2018-10-16 23:51 ` [RFC v1 15/31] kunit: mock: added basic matchers and actions Brendan Higgins
2018-10-16 23:51 ` [RFC v1 16/31] kunit: mock: added class mocking support Brendan Higgins
2018-10-16 23:51 ` [RFC v1 17/31] kunit: mock: added struct param matcher Brendan Higgins
2018-10-16 23:51 ` Brendan Higgins [this message]
2018-10-16 23:51 ` [RFC v1 19/31] kunit: mock: implemented nice, strict and naggy mock distinctions Brendan Higgins
2018-10-16 23:51 ` [RFC v1 20/31] kunit: mock: add ability to mock functions with void context Brendan Higgins
2018-10-16 23:51 ` [RFC v1 21/31] kunit: mock: added support for arbitrary function mocking Brendan Higgins
2018-10-16 23:51 ` [RFC v1 22/31] kunit: mock: add the concept of spyable functions Brendan Higgins
2018-10-17 22:46 ` Rob Herring
2018-10-18 1:32 ` Brendan Higgins
2018-10-16 23:51 ` [RFC v1 23/31] kunit: mock: add parameter capturers Brendan Higgins
2018-10-16 23:51 ` [RFC v1 24/31] kunit: improved sigsegv stack trace printing Brendan Higgins
2018-10-16 23:51 ` [RFC v1 25/31] kunit: added concept of platform mocking Brendan Higgins
2018-10-16 23:51 ` [RFC v1 26/31] arch: um: added stubs for mock iomem for KUnit Brendan Higgins
2018-10-17 22:28 ` Rob Herring
2018-10-18 1:14 ` Brendan Higgins
2018-10-16 23:51 ` [RFC v1 27/31] Documentation: kunit: adds complete documentation " Brendan Higgins
2018-10-16 23:51 ` [RFC v1 28/31] kunit: added Python libraries for handing KUnit config and kernel Brendan Higgins
2018-10-16 23:51 ` [RFC v1 29/31] kunit: added KUnit wrapper script and simple output parser Brendan Higgins
2018-10-16 23:51 ` [RFC v1 30/31] kunit.py: improved output from python wrapper Brendan Higgins
2018-10-16 23:51 ` [RFC v1 31/31] MAINTAINERS: add entry for KUnit the unit testing framework Brendan Higgins
2018-10-17 9:08 ` [RFC v1 00/31] kunit: Introducing KUnit, the Linux kernel " Daniel Vetter
2018-10-17 17:49 ` Tim.Bird
2018-10-17 22:22 ` Brendan Higgins
2018-10-17 20:43 ` Rob Herring
2018-10-17 23:12 ` Randy Dunlap
2018-10-18 2:05 ` Brendan Higgins
2018-10-18 3:55 ` Dan Williams
2018-10-19 6:27 ` Brendan Higgins
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20181016235120.138227-19-brendanhiggins@google.com \
--to=brendanhiggins@google.com \
--cc=Tim.Bird@sony.com \
--cc=brakmo@fb.com \
--cc=gregkh@linuxfoundation.org \
--cc=jdike@addtoit.com \
--cc=joe@perches.com \
--cc=joel@jms.id.au \
--cc=julia.lawall@lip6.fr \
--cc=keescook@google.com \
--cc=khilman@baylibre.com \
--cc=kunit-dev@googlegroups.com \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-kselftest@vger.kernel.org \
--cc=linux-um@lists.infradead.org \
--cc=mcgrof@kernel.org \
--cc=mpe@ellerman.id.au \
--cc=richard@nod.at \
--cc=rostedt@goodmis.org \
--cc=shuah@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).