lkml.org 
[lkml]   [2019]   [May]   [1]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    Subject[PATCH v2 07/17] kunit: test: add initial tests
    From
    Add a test for string stream along with a simpler example.

    Signed-off-by: Brendan Higgins <brendanhiggins@google.com>
    ---
    kunit/Kconfig | 12 ++++++
    kunit/Makefile | 4 ++
    kunit/example-test.c | 88 ++++++++++++++++++++++++++++++++++++++
    kunit/string-stream-test.c | 61 ++++++++++++++++++++++++++
    4 files changed, 165 insertions(+)
    create mode 100644 kunit/example-test.c
    create mode 100644 kunit/string-stream-test.c

    diff --git a/kunit/Kconfig b/kunit/Kconfig
    index 64480092b2c24..5cb500355c873 100644
    --- a/kunit/Kconfig
    +++ b/kunit/Kconfig
    @@ -13,4 +13,16 @@ config KUNIT
    special hardware. For more information, please see
    Documentation/kunit/

    +config KUNIT_TEST
    + bool "KUnit test for KUnit"
    + depends on KUNIT
    + help
    + Enables KUnit test to test KUnit.
    +
    +config KUNIT_EXAMPLE_TEST
    + bool "Example test for KUnit"
    + depends on KUNIT
    + help
    + Enables example KUnit test to demo features of KUnit.
    +
    endmenu
    diff --git a/kunit/Makefile b/kunit/Makefile
    index 6ddc622ee6b1c..60a9ea6cb4697 100644
    --- a/kunit/Makefile
    +++ b/kunit/Makefile
    @@ -1,3 +1,7 @@
    obj-$(CONFIG_KUNIT) += test.o \
    string-stream.o \
    kunit-stream.o
    +
    +obj-$(CONFIG_KUNIT_TEST) += string-stream-test.o
    +
    +obj-$(CONFIG_KUNIT_EXAMPLE_TEST) += example-test.o
    diff --git a/kunit/example-test.c b/kunit/example-test.c
    new file mode 100644
    index 0000000000000..3947dd7c8f922
    --- /dev/null
    +++ b/kunit/example-test.c
    @@ -0,0 +1,88 @@
    +// SPDX-License-Identifier: GPL-2.0
    +/*
    + * Example KUnit test to show how to use KUnit.
    + *
    + * Copyright (C) 2019, Google LLC.
    + * Author: Brendan Higgins <brendanhiggins@google.com>
    + */
    +
    +#include <kunit/test.h>
    +
    +/*
    + * This is the most fundamental element of KUnit, the test case. A test case
    + * makes a set EXPECTATIONs and ASSERTIONs about the behavior of some code; if
    + * any expectations or assertions are not met, the test fails; otherwise, the
    + * test passes.
    + *
    + * In KUnit, a test case is just a function with the signature
    + * `void (*)(struct kunit *)`. `struct kunit` is a context object that stores
    + * information about the current test.
    + */
    +static void example_simple_test(struct kunit *test)
    +{
    + /*
    + * This is an EXPECTATION; it is how KUnit tests things. When you want
    + * to test a piece of code, you set some expectations about what the
    + * code should do. KUnit then runs the test and verifies that the code's
    + * behavior matched what was expected.
    + */
    + KUNIT_EXPECT_EQ(test, 1 + 1, 2);
    +}
    +
    +/*
    + * This is run once before each test case, see the comment on
    + * example_test_module for more information.
    + */
    +static int example_test_init(struct kunit *test)
    +{
    + kunit_info(test, "initializing\n");
    +
    + return 0;
    +}
    +
    +/*
    + * Here we make a list of all the test cases we want to add to the test module
    + * below.
    + */
    +static struct kunit_case example_test_cases[] = {
    + /*
    + * This is a helper to create a test case object from a test case
    + * function; its exact function is not important to understand how to
    + * use KUnit, just know that this is how you associate test cases with a
    + * test module.
    + */
    + KUNIT_CASE(example_simple_test),
    + {},
    +};
    +
    +/*
    + * This defines a suite or grouping of tests.
    + *
    + * Test cases are defined as belonging to the suite by adding them to
    + * `kunit_cases`.
    + *
    + * Often it is desirable to run some function which will set up things which
    + * will be used by every test; this is accomplished with an `init` function
    + * which runs before each test case is invoked. Similarly, an `exit` function
    + * may be specified which runs after every test case and can be used to for
    + * cleanup. For clarity, running tests in a test module would behave as follows:
    + *
    + * module.init(test);
    + * module.test_case[0](test);
    + * module.exit(test);
    + * module.init(test);
    + * module.test_case[1](test);
    + * module.exit(test);
    + * ...;
    + */
    +static struct kunit_module example_test_module = {
    + .name = "example",
    + .init = example_test_init,
    + .test_cases = example_test_cases,
    +};
    +
    +/*
    + * This registers the above test module telling KUnit that this is a suite of
    + * tests that need to be run.
    + */
    +module_test(example_test_module);
    diff --git a/kunit/string-stream-test.c b/kunit/string-stream-test.c
    new file mode 100644
    index 0000000000000..b2a98576797c9
    --- /dev/null
    +++ b/kunit/string-stream-test.c
    @@ -0,0 +1,61 @@
    +// SPDX-License-Identifier: GPL-2.0
    +/*
    + * KUnit test for struct string_stream.
    + *
    + * Copyright (C) 2019, Google LLC.
    + * Author: Brendan Higgins <brendanhiggins@google.com>
    + */
    +
    +#include <linux/slab.h>
    +#include <kunit/test.h>
    +#include <kunit/string-stream.h>
    +
    +static void string_stream_test_get_string(struct kunit *test)
    +{
    + struct string_stream *stream = new_string_stream();
    + char *output;
    +
    + string_stream_add(stream, "Foo");
    + string_stream_add(stream, " %s", "bar");
    +
    + output = string_stream_get_string(stream);
    + KUNIT_EXPECT_STREQ(test, output, "Foo bar");
    + kfree(output);
    + destroy_string_stream(stream);
    +}
    +
    +static void string_stream_test_add_and_clear(struct kunit *test)
    +{
    + struct string_stream *stream = new_string_stream();
    + char *output;
    + int i;
    +
    + for (i = 0; i < 10; i++)
    + string_stream_add(stream, "A");
    +
    + output = string_stream_get_string(stream);
    + KUNIT_EXPECT_STREQ(test, output, "AAAAAAAAAA");
    + KUNIT_EXPECT_EQ(test, stream->length, 10);
    + KUNIT_EXPECT_FALSE(test, string_stream_is_empty(stream));
    + kfree(output);
    +
    + string_stream_clear(stream);
    +
    + output = string_stream_get_string(stream);
    + KUNIT_EXPECT_STREQ(test, output, "");
    + KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream));
    + destroy_string_stream(stream);
    +}
    +
    +static struct kunit_case string_stream_test_cases[] = {
    + KUNIT_CASE(string_stream_test_get_string),
    + KUNIT_CASE(string_stream_test_add_and_clear),
    + {}
    +};
    +
    +static struct kunit_module string_stream_test_module = {
    + .name = "string-stream-test",
    + .test_cases = string_stream_test_cases
    +};
    +module_test(string_stream_test_module);
    +
    --
    2.21.0.593.g511ec345e18-goog
    \
     
     \ /
      Last update: 2019-05-02 01:04    [W:3.320 / U:1.440 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site