| Message ID | 20230707210947.1208717-3-rmoar@google.com (mailing list archive) |
|---|---|
| State | New |
| Delegated to: | Brendan Higgins |
| Headers | show |
| Series | kunit: Add test attributes API | expand |
On Sat, 8 Jul 2023 at 05:09, Rae Moar <rmoar@google.com> wrote: > > Add speed attribute to the test attribute API. This attribute will allow > users to mark tests with a category of speed. > > Currently the categories of speed proposed are: normal, slow, and very_slow > (outlined in enum kunit_speed). These are outlined in the enum kunit_speed. > > The assumed default speed for tests is "normal". This indicates that the > test takes a relatively trivial amount of time (less than 1 second), > regardless of the machine it is running on. Any test slower than this could > be marked as "slow" or "very_slow". > > Add the macro KUNIT_CASE_SLOW to set a test as slow, as this is likely a > common use of the attributes API. > > Add an example of marking a slow test to kunit-example-test.c. > > Signed-off-by: Rae Moar <rmoar@google.com> > --- Looks good. Reviewed-by: David Gow <davidgow@google.com> > > Changes since v1: > - Remove the "fast" category of speed. > > include/kunit/test.h | 30 +++++++++++++++++++++- > lib/kunit/attributes.c | 46 +++++++++++++++++++++++++++++++++- > lib/kunit/kunit-example-test.c | 9 +++++++ > 3 files changed, 83 insertions(+), 2 deletions(-) > > diff --git a/include/kunit/test.h b/include/kunit/test.h > index 1fc9155988e9..c255c98a58f7 100644 > --- a/include/kunit/test.h > +++ b/include/kunit/test.h > @@ -63,8 +63,25 @@ enum kunit_status { > KUNIT_SKIPPED, > }; > > +/* Attribute struct/enum definitions */ > + > +/* > + * Speed Attribute is stored as an enum and separated into categories of > + * speed: very_slowm, slow, normal, and fast. These speeds are relative Nit: we only have very_slow, slow & normal now. > + * to other KUnit tests. > + */ > +enum kunit_speed { > + KUNIT_SPEED_UNSET, > + KUNIT_SPEED_VERY_SLOW, > + KUNIT_SPEED_SLOW, > + KUNIT_SPEED_NORMAL, > + KUNIT_SPEED_MAX = KUNIT_SPEED_NORMAL, > +}; A part of me feels that we could get away with reversing the order of this and having KUNIT_SPEED_NORMAL == 0. (Possibly reversing the comparisons in the filtering, too.) That's probably not worth the added complexity though. Either way, maybe add a note that "UNSET" == "NORMAL". > + > /* Holds attributes for each test case and suite */ > -struct kunit_attributes {}; > +struct kunit_attributes { > + enum kunit_speed speed; > +}; > > /** > * struct kunit_case - represents an individual test case. > @@ -150,6 +167,17 @@ static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) > { .run_case = test_name, .name = #test_name, \ > .attr = attributes } > > +/** > + * KUNIT_CASE_SLOW - A helper for creating a &struct kunit_case > + * with the slow attribute > + * > + * @test_name: a reference to a test case function. > + */ > + > +#define KUNIT_CASE_SLOW(test_name) \ > + { .run_case = test_name, .name = #test_name, \ > + .attr.speed = KUNIT_SPEED_SLOW } > + > /** > * KUNIT_CASE_PARAM - A helper for creation a parameterized &struct kunit_case > * > diff --git a/lib/kunit/attributes.c b/lib/kunit/attributes.c > index 9bda5a5f4030..e97096dbb3b1 100644 > --- a/lib/kunit/attributes.c > +++ b/lib/kunit/attributes.c > @@ -40,9 +40,53 @@ struct kunit_attr { > enum print_ops print; > }; > > +/* String Lists for enum Attributes */ > + > +static const char * const speed_str_list[] = {"unset", "very_slow", "slow", "normal"}; > + > +/* To String Methods */ > + > +static const char *attr_enum_to_string(void *attr, const char * const str_list[], bool *to_free) > +{ > + long val = (long)attr; > + > + *to_free = false; > + if (!val) > + return NULL; > + return str_list[val]; > +} > + > +static const char *attr_speed_to_string(void *attr, bool *to_free) > +{ > + return attr_enum_to_string(attr, speed_str_list, to_free); > +} > + > +/* Get Attribute Methods */ > + > +static void *attr_speed_get(void *test_or_suite, bool is_test) > +{ > + struct kunit_suite *suite = is_test ? NULL : test_or_suite; > + struct kunit_case *test = is_test ? test_or_suite : NULL; > + > + if (test) > + return ((void *) test->attr.speed); > + else > + return ((void *) suite->attr.speed); > +} > + > +/* Attribute Struct Definitions */ > + > +static const struct kunit_attr speed_attr = { > + .name = "speed", > + .get_attr = attr_speed_get, > + .to_string = attr_speed_to_string, > + .attr_default = (void *)KUNIT_SPEED_NORMAL, > + .print = PRINT_ALWAYS, > +}; > + > /* List of all Test Attributes */ > > -static struct kunit_attr kunit_attr_list[] = {}; > +static struct kunit_attr kunit_attr_list[] = {speed_attr}; > > /* Helper Functions to Access Attributes */ > > diff --git a/lib/kunit/kunit-example-test.c b/lib/kunit/kunit-example-test.c > index b69b689ea850..01a769f35e1d 100644 > --- a/lib/kunit/kunit-example-test.c > +++ b/lib/kunit/kunit-example-test.c > @@ -220,6 +220,14 @@ static void example_params_test(struct kunit *test) > KUNIT_EXPECT_EQ(test, param->value % param->value, 0); > } > > +/* > + * This test should always pass. Can be used to practice filtering attributes. > + */ > +static void example_slow_test(struct kunit *test) > +{ > + KUNIT_EXPECT_EQ(test, 1 + 1, 2); > +} > + > /* > * Here we make a list of all the test cases we want to add to the test suite > * below. > @@ -237,6 +245,7 @@ static struct kunit_case example_test_cases[] = { > KUNIT_CASE(example_all_expect_macros_test), > KUNIT_CASE(example_static_stub_test), > KUNIT_CASE_PARAM(example_params_test, example_gen_params), > + KUNIT_CASE_SLOW(example_slow_test), > {} > }; > > -- > 2.41.0.255.g8b1d071c50-goog >
On Tue, Jul 18, 2023 at 3:39 AM David Gow <davidgow@google.com> wrote: > > On Sat, 8 Jul 2023 at 05:09, Rae Moar <rmoar@google.com> wrote: > > > > Add speed attribute to the test attribute API. This attribute will allow > > users to mark tests with a category of speed. > > > > Currently the categories of speed proposed are: normal, slow, and very_slow > > (outlined in enum kunit_speed). These are outlined in the enum kunit_speed. > > > > The assumed default speed for tests is "normal". This indicates that the > > test takes a relatively trivial amount of time (less than 1 second), > > regardless of the machine it is running on. Any test slower than this could > > be marked as "slow" or "very_slow". > > > > Add the macro KUNIT_CASE_SLOW to set a test as slow, as this is likely a > > common use of the attributes API. > > > > Add an example of marking a slow test to kunit-example-test.c. > > > > Signed-off-by: Rae Moar <rmoar@google.com> > > --- > > Looks good. > > Reviewed-by: David Gow <davidgow@google.com> > Thanks! > > > > Changes since v1: > > - Remove the "fast" category of speed. > > > > include/kunit/test.h | 30 +++++++++++++++++++++- > > lib/kunit/attributes.c | 46 +++++++++++++++++++++++++++++++++- > > lib/kunit/kunit-example-test.c | 9 +++++++ > > 3 files changed, 83 insertions(+), 2 deletions(-) > > > > diff --git a/include/kunit/test.h b/include/kunit/test.h > > index 1fc9155988e9..c255c98a58f7 100644 > > --- a/include/kunit/test.h > > +++ b/include/kunit/test.h > > @@ -63,8 +63,25 @@ enum kunit_status { > > KUNIT_SKIPPED, > > }; > > > > +/* Attribute struct/enum definitions */ > > + > > +/* > > + * Speed Attribute is stored as an enum and separated into categories of > > + * speed: very_slowm, slow, normal, and fast. These speeds are relative > > Nit: we only have very_slow, slow & normal now. > Oops thanks for catching this. Will fix this before I send out the official patch set. > > + * to other KUnit tests. > > + */ > > +enum kunit_speed { > > + KUNIT_SPEED_UNSET, > > + KUNIT_SPEED_VERY_SLOW, > > + KUNIT_SPEED_SLOW, > > + KUNIT_SPEED_NORMAL, > > + KUNIT_SPEED_MAX = KUNIT_SPEED_NORMAL, > > +}; > > A part of me feels that we could get away with reversing the order of > this and having KUNIT_SPEED_NORMAL == 0. (Possibly reversing the > comparisons in the filtering, too.) > > That's probably not worth the added complexity though. Either way, > maybe add a note that "UNSET" == "NORMAL". > > Yes, I definitely have been debating this order myself as well. This order makes slightly more sense to me so I will likely keep this for the next version but I will add that note. If there are more comments on this, I am definitely open to reversing the order. > > + > > /* Holds attributes for each test case and suite */ > > -struct kunit_attributes {}; > > +struct kunit_attributes { > > + enum kunit_speed speed; > > +}; > > > > /** > > * struct kunit_case - represents an individual test case. > > @@ -150,6 +167,17 @@ static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) > > { .run_case = test_name, .name = #test_name, \ > > .attr = attributes } > > > > +/** > > + * KUNIT_CASE_SLOW - A helper for creating a &struct kunit_case > > + * with the slow attribute > > + * > > + * @test_name: a reference to a test case function. > > + */ > > + > > +#define KUNIT_CASE_SLOW(test_name) \ > > + { .run_case = test_name, .name = #test_name, \ > > + .attr.speed = KUNIT_SPEED_SLOW } > > + > > /** > > * KUNIT_CASE_PARAM - A helper for creation a parameterized &struct kunit_case > > * > > diff --git a/lib/kunit/attributes.c b/lib/kunit/attributes.c > > index 9bda5a5f4030..e97096dbb3b1 100644 > > --- a/lib/kunit/attributes.c > > +++ b/lib/kunit/attributes.c > > @@ -40,9 +40,53 @@ struct kunit_attr { > > enum print_ops print; > > }; > > > > +/* String Lists for enum Attributes */ > > + > > +static const char * const speed_str_list[] = {"unset", "very_slow", "slow", "normal"}; > > + > > +/* To String Methods */ > > + > > +static const char *attr_enum_to_string(void *attr, const char * const str_list[], bool *to_free) > > +{ > > + long val = (long)attr; > > + > > + *to_free = false; > > + if (!val) > > + return NULL; > > + return str_list[val]; > > +} > > + > > +static const char *attr_speed_to_string(void *attr, bool *to_free) > > +{ > > + return attr_enum_to_string(attr, speed_str_list, to_free); > > +} > > + > > +/* Get Attribute Methods */ > > + > > +static void *attr_speed_get(void *test_or_suite, bool is_test) > > +{ > > + struct kunit_suite *suite = is_test ? NULL : test_or_suite; > > + struct kunit_case *test = is_test ? test_or_suite : NULL; > > + > > + if (test) > > + return ((void *) test->attr.speed); > > + else > > + return ((void *) suite->attr.speed); > > +} > > + > > +/* Attribute Struct Definitions */ > > + > > +static const struct kunit_attr speed_attr = { > > + .name = "speed", > > + .get_attr = attr_speed_get, > > + .to_string = attr_speed_to_string, > > + .attr_default = (void *)KUNIT_SPEED_NORMAL, > > + .print = PRINT_ALWAYS, > > +}; > > + > > /* List of all Test Attributes */ > > > > -static struct kunit_attr kunit_attr_list[] = {}; > > +static struct kunit_attr kunit_attr_list[] = {speed_attr}; > > > > /* Helper Functions to Access Attributes */ > > > > diff --git a/lib/kunit/kunit-example-test.c b/lib/kunit/kunit-example-test.c > > index b69b689ea850..01a769f35e1d 100644 > > --- a/lib/kunit/kunit-example-test.c > > +++ b/lib/kunit/kunit-example-test.c > > @@ -220,6 +220,14 @@ static void example_params_test(struct kunit *test) > > KUNIT_EXPECT_EQ(test, param->value % param->value, 0); > > } > > > > +/* > > + * This test should always pass. Can be used to practice filtering attributes. > > + */ > > +static void example_slow_test(struct kunit *test) > > +{ > > + KUNIT_EXPECT_EQ(test, 1 + 1, 2); > > +} > > + > > /* > > * Here we make a list of all the test cases we want to add to the test suite > > * below. > > @@ -237,6 +245,7 @@ static struct kunit_case example_test_cases[] = { > > KUNIT_CASE(example_all_expect_macros_test), > > KUNIT_CASE(example_static_stub_test), > > KUNIT_CASE_PARAM(example_params_test, example_gen_params), > > + KUNIT_CASE_SLOW(example_slow_test), > > {} > > }; > > > > -- > > 2.41.0.255.g8b1d071c50-goog > >
diff --git a/include/kunit/test.h b/include/kunit/test.h index 1fc9155988e9..c255c98a58f7 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -63,8 +63,25 @@ enum kunit_status { KUNIT_SKIPPED, }; +/* Attribute struct/enum definitions */ + +/* + * Speed Attribute is stored as an enum and separated into categories of + * speed: very_slowm, slow, normal, and fast. These speeds are relative + * to other KUnit tests. + */ +enum kunit_speed { + KUNIT_SPEED_UNSET, + KUNIT_SPEED_VERY_SLOW, + KUNIT_SPEED_SLOW, + KUNIT_SPEED_NORMAL, + KUNIT_SPEED_MAX = KUNIT_SPEED_NORMAL, +}; + /* Holds attributes for each test case and suite */ -struct kunit_attributes {}; +struct kunit_attributes { + enum kunit_speed speed; +}; /** * struct kunit_case - represents an individual test case. @@ -150,6 +167,17 @@ static inline char *kunit_status_to_ok_not_ok(enum kunit_status status) { .run_case = test_name, .name = #test_name, \ .attr = attributes } +/** + * KUNIT_CASE_SLOW - A helper for creating a &struct kunit_case + * with the slow attribute + * + * @test_name: a reference to a test case function. + */ + +#define KUNIT_CASE_SLOW(test_name) \ + { .run_case = test_name, .name = #test_name, \ + .attr.speed = KUNIT_SPEED_SLOW } + /** * KUNIT_CASE_PARAM - A helper for creation a parameterized &struct kunit_case * diff --git a/lib/kunit/attributes.c b/lib/kunit/attributes.c index 9bda5a5f4030..e97096dbb3b1 100644 --- a/lib/kunit/attributes.c +++ b/lib/kunit/attributes.c @@ -40,9 +40,53 @@ struct kunit_attr { enum print_ops print; }; +/* String Lists for enum Attributes */ + +static const char * const speed_str_list[] = {"unset", "very_slow", "slow", "normal"}; + +/* To String Methods */ + +static const char *attr_enum_to_string(void *attr, const char * const str_list[], bool *to_free) +{ + long val = (long)attr; + + *to_free = false; + if (!val) + return NULL; + return str_list[val]; +} + +static const char *attr_speed_to_string(void *attr, bool *to_free) +{ + return attr_enum_to_string(attr, speed_str_list, to_free); +} + +/* Get Attribute Methods */ + +static void *attr_speed_get(void *test_or_suite, bool is_test) +{ + struct kunit_suite *suite = is_test ? NULL : test_or_suite; + struct kunit_case *test = is_test ? test_or_suite : NULL; + + if (test) + return ((void *) test->attr.speed); + else + return ((void *) suite->attr.speed); +} + +/* Attribute Struct Definitions */ + +static const struct kunit_attr speed_attr = { + .name = "speed", + .get_attr = attr_speed_get, + .to_string = attr_speed_to_string, + .attr_default = (void *)KUNIT_SPEED_NORMAL, + .print = PRINT_ALWAYS, +}; + /* List of all Test Attributes */ -static struct kunit_attr kunit_attr_list[] = {}; +static struct kunit_attr kunit_attr_list[] = {speed_attr}; /* Helper Functions to Access Attributes */ diff --git a/lib/kunit/kunit-example-test.c b/lib/kunit/kunit-example-test.c index b69b689ea850..01a769f35e1d 100644 --- a/lib/kunit/kunit-example-test.c +++ b/lib/kunit/kunit-example-test.c @@ -220,6 +220,14 @@ static void example_params_test(struct kunit *test) KUNIT_EXPECT_EQ(test, param->value % param->value, 0); } +/* + * This test should always pass. Can be used to practice filtering attributes. + */ +static void example_slow_test(struct kunit *test) +{ + KUNIT_EXPECT_EQ(test, 1 + 1, 2); +} + /* * Here we make a list of all the test cases we want to add to the test suite * below. @@ -237,6 +245,7 @@ static struct kunit_case example_test_cases[] = { KUNIT_CASE(example_all_expect_macros_test), KUNIT_CASE(example_static_stub_test), KUNIT_CASE_PARAM(example_params_test, example_gen_params), + KUNIT_CASE_SLOW(example_slow_test), {} };
Add speed attribute to the test attribute API. This attribute will allow users to mark tests with a category of speed. Currently the categories of speed proposed are: normal, slow, and very_slow (outlined in enum kunit_speed). These are outlined in the enum kunit_speed. The assumed default speed for tests is "normal". This indicates that the test takes a relatively trivial amount of time (less than 1 second), regardless of the machine it is running on. Any test slower than this could be marked as "slow" or "very_slow". Add the macro KUNIT_CASE_SLOW to set a test as slow, as this is likely a common use of the attributes API. Add an example of marking a slow test to kunit-example-test.c. Signed-off-by: Rae Moar <rmoar@google.com> --- Changes since v1: - Remove the "fast" category of speed. include/kunit/test.h | 30 +++++++++++++++++++++- lib/kunit/attributes.c | 46 +++++++++++++++++++++++++++++++++- lib/kunit/kunit-example-test.c | 9 +++++++ 3 files changed, 83 insertions(+), 2 deletions(-)