Re: [PATCH v2 1/2] kunit: Support for Parameterized Testing

[Marco Elver]

On Fri, Oct 23, 2020 at 08:35PM +0530, Arpitha Raghunandan wrote:
> Implementation of support for parameterized testing in KUnit.

Already looks much cleaner, thanks for using this approach!

I think the commit message needs a brief summary of the approach.

> Signed-off-by: Arpitha Raghunandan <98.arpi@xxxxxxxxx>
> ---
> Changes v1->v2:
> - Use of a generator method to access test case parameters
> 
>  include/kunit/test.h | 45 ++++++++++++++++++++++++++++++++++++++++++++
>  lib/kunit/test.c     | 20 +++++++++++++++++++-
>  2 files changed, 64 insertions(+), 1 deletion(-)
> 
> diff --git a/include/kunit/test.h b/include/kunit/test.h
> index a423fffefea0..c417ac140326 100644
> --- a/include/kunit/test.h
> +++ b/include/kunit/test.h
> @@ -141,6 +141,7 @@ struct kunit;
>  struct kunit_case {
>  	void (*run_case)(struct kunit *test);
>  	const char *name;
> +	void* (*generate_params)(struct kunit *test, void *prev);

Would adding documentation above this field be the right place, or
somewhere else? In any case, some explanation of the protocol would be
good.

>  	/* private: internal use only. */
>  	bool success;
> @@ -162,6 +163,9 @@ static inline char *kunit_status_to_string(bool status)
>   * &struct kunit_case for an example on how to use it.
>   */
>  #define KUNIT_CASE(test_name) { .run_case = test_name, .name = #test_name }
> +#define KUNIT_CASE_PARAM(test_name, gen_params)			\
> +		{ .run_case = test_name, .name = #test_name,	\
> +		  .generate_params = gen_params }
>  
>  /**
>   * struct kunit_suite - describes a related collection of &struct kunit_case
> @@ -208,6 +212,15 @@ struct kunit {
>  	const char *name; /* Read only after initialization! */
>  	char *log; /* Points at case log after initialization */
>  	struct kunit_try_catch try_catch;
> +	/* param_values points to test case parameters in parameterized tests */
> +	void *param_values;
> +	/*
> +	 * current_param stores the index of the parameter in
> +	 * the array of parameters in parameterized tests.
> +	 * current_param + 1 is printed to indicate the parameter
> +	 * that causes the test to fail in case of test failure.
> +	 */
> +	int current_param;
>  	/*
>  	 * success starts as true, and may only be set to false during a
>  	 * test case; thus, it is safe to update this across multiple
> @@ -1742,4 +1755,36 @@ do {									       \
>  						fmt,			       \
>  						##__VA_ARGS__)
>  
> +/**
> + * kunit_param_generator_helper() - Helper method for test parameter generators
> + * 				    required in parameterized tests.
> + * @test: The test context object.
> + * @prev_param: a pointer to the previous test parameter, NULL for first parameter.
> + * @param_array: a user-supplied pointer to an array of test parameters.
> + * @array_size: number of test parameters in the array.
> + * @type_size: size of one test parameter.
> + */
> +static inline void *kunit_param_generator_helper(struct kunit *test,

I don't think this needs to be inline, but see my other suggestion
below, which might make this function obsolete.

> +					void *prev_param,
> +					void *param_array,
> +					size_t array_size,
> +					size_t type_size)
> +{
> +	KUNIT_ASSERT_EQ(test, (prev_param - param_array) % type_size, 0);
> +
> +	if (!prev_param)
> +		return param_array;
> +
> +	KUNIT_ASSERT_GE(test, prev_param, param_array);
> +
> +	if (prev_param + type_size < param_array + (array_size * type_size))
> +		return prev_param + type_size;
> +	else
> +		return NULL;
> +}
> +
> +#define KUNIT_PARAM_GENERATOR_HELPER(test, prev_param, param_array, param_type) \
> +	kunit_param_generator_helper(test, prev_param, param_array,		\
> +				ARRAY_SIZE(param_array), sizeof(param_type))

You do not need param_type, you can use the same trick that ARRAY_SIZE
uses:

	#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))

So you could use sizeof((param_aray)[0]) instead of sizeof(param_type).
ARRAY_SIZE already checks for you that it's a real array via
__must_be_array().


The other question is, will kunit_param_generator_helper() find much use
without the KUNIT_PARAM_GENERATOR_HELPER() macro? If I have some
complicated generator protocol to generate params, then I'd just
directly write the generator function. If your intent is to simplify the
common-case array based generators, why not just have a macro generate
the generator function?

More specifically, have this macro here:

+#define KUNIT_ARRAY_PARAM(name, array)								\
+	static void *name##_gen_params(struct kunit *test, void *prev)				\
+	{											\
+		typeof((array)[0]) *__next = prev ? ((typeof(__next)) prev) + 1 : (array);	\
+		return __next - (array) < ARRAY_SIZE((array)) ? __next : NULL;			\
+	}

[ It is entirely untested, but if it works verbatim you'll probably need my

	Co-developed-by: Marco Elver <elver@xxxxxxxxxx>
	Signed-off-by: Marco Elver <elver@xxxxxxxxxx>
 
 just in case... ]

Then, it can be used as follows:

	static int num_cpus[] = {1, 2, 3, 4, 5};
	KUNIT_ARRAY_PARAM(num_cpus, num_cpus);

Then somewhere else:

	KUNIT_CASE_PARAM(some_test, num_cpus_gen_params);

>  #endif /* _KUNIT_TEST_H */
> diff --git a/lib/kunit/test.c b/lib/kunit/test.c
> index 750704abe89a..0e6ffe6384a7 100644
> --- a/lib/kunit/test.c
> +++ b/lib/kunit/test.c
> @@ -127,6 +127,11 @@ unsigned int kunit_test_case_num(struct kunit_suite *suite,
>  }
>  EXPORT_SYMBOL_GPL(kunit_test_case_num);
>  
> +static void kunit_print_failed_param(struct kunit *test)
> +{
> +	kunit_err(test, "\n\tTest failed at parameter: %d\n", test->current_param + 1);
> +}
> +
>  static void kunit_print_string_stream(struct kunit *test,
>  				      struct string_stream *stream)
>  {
> @@ -168,6 +173,8 @@ static void kunit_fail(struct kunit *test, struct kunit_assert *assert)
>  	assert->format(assert, stream);
>  
>  	kunit_print_string_stream(test, stream);
> +	if (test->param_values)
> +		kunit_print_failed_param(test);
>  
>  	WARN_ON(string_stream_destroy(stream));
>  }
> @@ -239,7 +246,18 @@ static void kunit_run_case_internal(struct kunit *test,
>  		}
>  	}
>  
> -	test_case->run_case(test);
> +	if (!test_case->generate_params) {
> +		test_case->run_case(test);
> +	} else {
> +		test->param_values = test_case->generate_params(test, NULL);
> +		test->current_param = 0;
> +
> +		while (test->param_values) {
> +			test_case->run_case(test);
> +			test->param_values = test_case->generate_params(test, test->param_values);
> +			test->current_param++;
> +		}
> +	}
>  }
>  
>  static void kunit_case_internal_cleanup(struct kunit *test)

Otherwise looks fine.

Thanks,
-- Marco