lkml.org 
[lkml]   [2019]   [Jul]   [9]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    Subject[PATCH v7 04/18] kunit: test: add kunit_stream a std::stream like logger
    From
    A lot of the expectation and assertion infrastructure prints out fairly
    complicated test failure messages, so add a C++ style log library for
    for logging test results.

    Signed-off-by: Brendan Higgins <brendanhiggins@google.com>
    Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    Reviewed-by: Logan Gunthorpe <logang@deltatee.com>
    ---
    include/kunit/kunit-stream.h | 81 +++++++++++++++++++++++
    include/kunit/test.h | 3 +
    kunit/Makefile | 3 +-
    kunit/kunit-stream.c | 123 +++++++++++++++++++++++++++++++++++
    kunit/test.c | 6 ++
    5 files changed, 215 insertions(+), 1 deletion(-)
    create mode 100644 include/kunit/kunit-stream.h
    create mode 100644 kunit/kunit-stream.c

    diff --git a/include/kunit/kunit-stream.h b/include/kunit/kunit-stream.h
    new file mode 100644
    index 0000000000000..a7b53eabf6be4
    --- /dev/null
    +++ b/include/kunit/kunit-stream.h
    @@ -0,0 +1,81 @@
    +/* SPDX-License-Identifier: GPL-2.0 */
    +/*
    + * C++ stream style string formatter and printer used in KUnit for outputting
    + * KUnit messages.
    + *
    + * Copyright (C) 2019, Google LLC.
    + * Author: Brendan Higgins <brendanhiggins@google.com>
    + */
    +
    +#ifndef _KUNIT_KUNIT_STREAM_H
    +#define _KUNIT_KUNIT_STREAM_H
    +
    +#include <linux/types.h>
    +#include <kunit/string-stream.h>
    +
    +struct kunit;
    +
    +/**
    + * struct kunit_stream - a std::stream style string builder.
    + *
    + * A std::stream style string builder. Allows messages to be built up and
    + * printed all at once.
    + */
    +struct kunit_stream {
    + /* private: internal use only. */
    + struct kunit *test;
    + const char *level;
    + struct string_stream *internal_stream;
    +};
    +
    +/**
    + * alloc_kunit_stream() - constructs a new &struct kunit_stream.
    + * @test: The test context object.
    + * @level: The log level at which to print out the message.
    + *
    + * Constructs a new test managed &struct kunit_stream.
    + */
    +struct kunit_stream *alloc_kunit_stream(struct kunit *test, const char *level);
    +
    +/**
    + * kunit_stream_add(): adds the formatted input to the internal buffer.
    + * @kstream: the stream being operated on.
    + * @fmt: printf style format string to append to stream.
    + *
    + * Appends the formatted string, @fmt, to the internal buffer.
    + */
    +void __printf(2, 3) kunit_stream_add(struct kunit_stream *kstream,
    + const char *fmt, ...);
    +
    +/**
    + * kunit_stream_append(): appends the contents of @other to @kstream.
    + * @kstream: the stream to which @other is appended.
    + * @other: the stream whose contents are appended to @kstream.
    + *
    + * Appends the contents of @other to @kstream.
    + */
    +void kunit_stream_append(struct kunit_stream *kstream,
    + struct kunit_stream *other);
    +
    +/**
    + * kunit_stream_commit(): prints out the internal buffer to the user.
    + * @kstream: the stream being operated on.
    + *
    + * Outputs the contents of the internal buffer as a kunit_printk formatted
    + * output. KUNIT_STREAM ONLY OUTPUTS ITS BUFFER TO THE USER IF COMMIT IS
    + * CALLED!!! The reason for this is that it allows us to construct a message
    + * before we know whether we want to print it out; this can be extremely handy
    + * if there is information you might need for a failure message that is easiest
    + * to collect in the steps leading up to the actual check.
    + */
    +void kunit_stream_commit(struct kunit_stream *kstream);
    +
    +/**
    + * kunit_stream_clear(): clears the internal buffer.
    + * @kstream: the stream being operated on.
    + *
    + * Clears the contents of the internal buffer.
    + */
    +void kunit_stream_clear(struct kunit_stream *kstream);
    +
    +#endif /* _KUNIT_KUNIT_STREAM_H */
    diff --git a/include/kunit/test.h b/include/kunit/test.h
    index bdf41d31c343c..bc7dbdcf8abab 100644
    --- a/include/kunit/test.h
    +++ b/include/kunit/test.h
    @@ -11,6 +11,7 @@

    #include <linux/types.h>
    #include <linux/slab.h>
    +#include <kunit/kunit-stream.h>

    struct kunit_resource;

    @@ -184,6 +185,8 @@ struct kunit {

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

    +void kunit_fail(struct kunit *test, struct kunit_stream *stream);
    +
    int kunit_run_tests(struct kunit_suite *suite);

    /**
    diff --git a/kunit/Makefile b/kunit/Makefile
    index 275b565a0e81f..6ddc622ee6b1c 100644
    --- a/kunit/Makefile
    +++ b/kunit/Makefile
    @@ -1,2 +1,3 @@
    obj-$(CONFIG_KUNIT) += test.o \
    - string-stream.o
    + string-stream.o \
    + kunit-stream.o
    diff --git a/kunit/kunit-stream.c b/kunit/kunit-stream.c
    new file mode 100644
    index 0000000000000..8bea1f22eafb5
    --- /dev/null
    +++ b/kunit/kunit-stream.c
    @@ -0,0 +1,123 @@
    +// SPDX-License-Identifier: GPL-2.0
    +/*
    + * C++ stream style string formatter and printer used in KUnit for outputting
    + * KUnit messages.
    + *
    + * Copyright (C) 2019, Google LLC.
    + * Author: Brendan Higgins <brendanhiggins@google.com>
    + */
    +
    +#include <kunit/test.h>
    +#include <kunit/kunit-stream.h>
    +#include <kunit/string-stream.h>
    +
    +void kunit_stream_add(struct kunit_stream *kstream, const char *fmt, ...)
    +{
    + va_list args;
    + struct string_stream *stream = kstream->internal_stream;
    +
    + va_start(args, fmt);
    +
    + if (string_stream_vadd(stream, fmt, args) < 0)
    + kunit_err(kstream->test,
    + "Failed to allocate fragment: %s\n",
    + fmt);
    +
    + va_end(args);
    +}
    +
    +void kunit_stream_append(struct kunit_stream *kstream,
    + struct kunit_stream *other)
    +{
    + struct string_stream *other_stream = other->internal_stream;
    + const char *other_content;
    +
    + other_content = string_stream_get_string(other_stream);
    +
    + if (!other_content) {
    + kunit_err(kstream->test,
    + "Failed to get string from second argument for appending\n");
    + return;
    + }
    +
    + kunit_stream_add(kstream, other_content);
    +}
    +
    +void kunit_stream_clear(struct kunit_stream *kstream)
    +{
    + string_stream_clear(kstream->internal_stream);
    +}
    +
    +void kunit_stream_commit(struct kunit_stream *kstream)
    +{
    + struct string_stream *stream = kstream->internal_stream;
    + struct string_stream_fragment *fragment;
    + struct kunit *test = kstream->test;
    + char *buf;
    +
    + buf = string_stream_get_string(stream);
    + if (!buf) {
    + kunit_err(test,
    + "Could not allocate buffer, dumping stream:\n");
    + list_for_each_entry(fragment, &stream->fragments, node) {
    + kunit_err(test, fragment->fragment);
    + }
    + kunit_err(test, "\n");
    + goto cleanup;
    + }
    +
    + kunit_printk(kstream->level, test, buf);
    + kfree(buf);
    +
    +cleanup:
    + kunit_stream_clear(kstream);
    +}
    +
    +static int kunit_stream_init(struct kunit_resource *res, void *context)
    +{
    + struct kunit *test = context;
    + struct kunit_stream *stream;
    +
    + stream = kzalloc(sizeof(*stream), GFP_KERNEL);
    + if (!stream)
    + return -ENOMEM;
    +
    + res->allocation = stream;
    + stream->test = test;
    + stream->internal_stream = alloc_string_stream(test);
    +
    + if (!stream->internal_stream)
    + return -ENOMEM;
    +
    + return 0;
    +}
    +
    +static void kunit_stream_free(struct kunit_resource *res)
    +{
    + struct kunit_stream *stream = res->allocation;
    +
    + if (!string_stream_is_empty(stream->internal_stream)) {
    + kunit_err(stream->test,
    + "End of test case reached with uncommitted stream entries\n");
    + kunit_stream_commit(stream);
    + }
    +}
    +
    +struct kunit_stream *alloc_kunit_stream(struct kunit *test, const char *level)
    +{
    + struct kunit_stream *kstream;
    + struct kunit_resource *res;
    +
    + res = kunit_alloc_resource(test,
    + kunit_stream_init,
    + kunit_stream_free,
    + test);
    +
    + if (!res)
    + return NULL;
    +
    + kstream = res->allocation;
    + kstream->level = level;
    +
    + return kstream;
    +}
    diff --git a/kunit/test.c b/kunit/test.c
    index f165c9d8e10b0..29edf34a89a37 100644
    --- a/kunit/test.c
    +++ b/kunit/test.c
    @@ -120,6 +120,12 @@ static void kunit_print_test_case_ok_not_ok(struct kunit_case *test_case,
    test_case->name);
    }

    +void kunit_fail(struct kunit *test, struct kunit_stream *stream)
    +{
    + kunit_set_failure(test);
    + kunit_stream_commit(stream);
    +}
    +
    void kunit_init_test(struct kunit *test, const char *name)
    {
    mutex_init(&test->lock);
    --
    2.22.0.410.gd8fdbe21b5-goog
    \
     
     \ /
      Last update: 2019-07-09 08:34    [W:4.165 / U:0.536 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site