// SPDX-License-Identifier: GPL-2.0
/*
 * KUnit test for parameter list parsing macros.
 *
 * Copyright (C) 2018, Google LLC.
 * Author: Brendan Higgins <brendanhiggins@google.com>
 */

#include <kunit/test.h>
#include <kunit/params.h>
#include <kunit/mock.h>

struct test_struct {
	int (*one_param)(struct test_struct *test_struct);
	int (*two_param)(struct test_struct *test_struct, int num);
	int (*non_first_slot_param)(int num, struct test_struct *test_struct);
	void *(*void_ptr_return)(struct test_struct *test_struct);
};

DECLARE_STRUCT_CLASS_MOCK_PREREQS(test_struct);

DEFINE_STRUCT_CLASS_MOCK(METHOD(one_param), CLASS(test_struct),
			 RETURNS(int),
			 PARAMS(struct test_struct *));

DEFINE_STRUCT_CLASS_MOCK(METHOD(two_param), CLASS(test_struct),
			 RETURNS(int),
			 PARAMS(struct test_struct *, int));

DEFINE_STRUCT_CLASS_MOCK_HANDLE_INDEX(METHOD(non_first_slot_param),
			 CLASS(test_struct), HANDLE_INDEX(1),
			 RETURNS(int),
			 PARAMS(int, struct test_struct *));

DEFINE_STRUCT_CLASS_MOCK(METHOD(void_ptr_return), CLASS(test_struct),
			 RETURNS(void *),
			 PARAMS(struct test_struct *));

static int test_struct_init(struct MOCK(test_struct) *mock_test_struct)
{
	struct test_struct *test_struct = mock_get_trgt(mock_test_struct);

	test_struct->one_param = one_param;
	test_struct->two_param = two_param;
	test_struct->non_first_slot_param = non_first_slot_param;
	return 0;
}

DEFINE_STRUCT_CLASS_MOCK_INIT(test_struct, test_struct_init);

DECLARE_VOID_CLASS_MOCK_HANDLE_INDEX(METHOD(test_void_ptr_func),
				     HANDLE_INDEX(0),
				     RETURNS(int),
				     PARAMS(void*, int));

DEFINE_VOID_CLASS_MOCK_HANDLE_INDEX(METHOD(test_void_ptr_func),
				    HANDLE_INDEX(0),
				    RETURNS(int),
				    PARAMS(void*, int));

DEFINE_FUNCTION_MOCK(add, RETURNS(int), PARAMS(int, int));

struct mock_macro_context {
	struct MOCK(test_struct) *mock_test_struct;
	struct MOCK(void) *mock_void_ptr;
};

#define TO_STR_INTERNAL(...) #__VA_ARGS__
#define TO_STR(...) TO_STR_INTERNAL(__VA_ARGS__)

static void mock_macro_is_equal(struct test *test)
{
	TEST_EXPECT_STREQ(test, "dropped, 1", TO_STR(EQUAL(1, 1)));
	TEST_EXPECT_EQ(test, 1, DROP_FIRST_ARG(dropped, 1, 0));
	TEST_EXPECT_EQ(test, 0, DROP_FIRST_ARG(1, 0));
	TEST_EXPECT_EQ(test, 0, DROP_FIRST_ARG(EQUAL(1, 0), 0));
	TEST_EXPECT_EQ(test, 1, IS_EQUAL(1, 1));
	TEST_EXPECT_EQ(test, 0, IS_EQUAL(1, 0));
}

static void mock_macro_if(struct test *test)
{
	TEST_EXPECT_STREQ(test, "body", ""IF(1)("body"));
	TEST_EXPECT_STREQ(test, "", ""IF(0)("body"));
	TEST_EXPECT_STREQ(test, "body", ""IF(IS_EQUAL(1, 1))("body"));
	TEST_EXPECT_STREQ(test, "", ""IF(IS_EQUAL(0, 1))("body"));
}

static void mock_macro_apply_tokens(struct test *test)
{
	TEST_EXPECT_STREQ(test, "type", TO_STR(APPLY_TOKENS(type, 1, 0)));
	TEST_EXPECT_STREQ(test, ", type", TO_STR(APPLY_TOKENS(type, 1, 1)));
	TEST_EXPECT_STREQ(test, "", TO_STR(APPLY_TOKENS(type, 0, 1)));
}

#define IDENTITY(context, type, index) type

static void mock_macro_param_list_recurse(struct test *test)
{
	TEST_EXPECT_STREQ(test, "", TO_STR(PARAM_LIST_RECURSE(0,
							      0,
							      IDENTITY,
							      FILTER_NONE,
							      not_used)));
	TEST_EXPECT_STREQ(test,
			  "type",
			  TO_STR(EXPAND(PARAM_LIST_RECURSE(0,
							   1,
							   IDENTITY,
							   FILTER_NONE,
							   not_used,
							   type))));
	TEST_EXPECT_STREQ(test,
			  "type0 , type1 , type2 , type3 , type4 , type5 , "
			  "type6 , type7 , type8 , type9 , type10 , type11 , "
			  "type12 , type13 , type14 , type15",
			  TO_STR(EXPAND(PARAM_LIST_RECURSE(0, 16,
							   IDENTITY,
							   FILTER_NONE,
							   not_used,
							   type0, type1, type2,
							   type3, type4, type5,
							   type6, type7, type8,
							   type9, type10,
							   type11, type12,
							   type13, type14,
							   type15))));
}

static void mock_macro_for_each_param(struct test *test)
{
	TEST_EXPECT_STREQ(test,
			  "type0 , type1",
			  TO_STR(FOR_EACH_PARAM(IDENTITY,
						FILTER_NONE,
						not_used,
						type0,
						type1)));
	TEST_EXPECT_STREQ(test,
			  "type1",
			  TO_STR(FOR_EACH_PARAM(IDENTITY,
						FILTER_INDEX,
						0,
						type0,
						type1)));
}

static void mock_macro_param_list_from_types_basic(struct test *test)
{
	TEST_EXPECT_STREQ(test, "", TO_STR(PARAM_LIST_FROM_TYPES()));
	TEST_EXPECT_STREQ(test, "int arg0", TO_STR(PARAM_LIST_FROM_TYPES(int)));
	TEST_EXPECT_STREQ(test, "struct test_struct * arg0 , int arg1",
			  TO_STR(PARAM_LIST_FROM_TYPES(struct test_struct *,
						       int)));
	TEST_EXPECT_STREQ(test,
			  "type0 arg0 , type1 arg1 , type2 arg2 , type3 arg3 , "
			  "type4 arg4 , type5 arg5 , type6 arg6 , type7 arg7 , "
			  "type8 arg8 , type9 arg9 , type10 arg10 , "
			  "type11 arg11 , type12 arg12 , type13 arg13 , "
			  "type14 arg14 , type15 arg15",
			  TO_STR(PARAM_LIST_FROM_TYPES(type0, type1, type2,
						       type3, type4, type5,
						       type6, type7, type8,
						       type9, type10, type11,
						       type12, type13, type14,
						       type15)));
}

static void mock_macro_arg_names_from_types(struct test *test)
{
	TEST_EXPECT_STREQ(test, "", TO_STR(ARG_NAMES_FROM_TYPES(0)));
	TEST_EXPECT_STREQ(test, "", TO_STR(ARG_NAMES_FROM_TYPES(0, int)));
	TEST_EXPECT_STREQ(test,
			  "arg1",
			  TO_STR(ARG_NAMES_FROM_TYPES(0,
						      struct test_struct *,
						      int)));
	TEST_EXPECT_STREQ(test,
			  "arg0 , arg1 , arg3 , arg4 , arg5 , arg6 , arg7 , "
			  "arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , "
			  "arg14 , arg15",
			  TO_STR(ARG_NAMES_FROM_TYPES(2, type0, type1, type2,
						      type3, type4, type5,
						      type6, type7, type8,
						      type9, type10, type11,
						      type12, type13, type14,
						      type15)));
}

static void mock_macro_test_generated_method_code_works(struct test *test)
{
	struct mock_macro_context *ctx = test->priv;
	struct MOCK(test_struct) *mock_test_struct = ctx->mock_test_struct;
	struct test_struct *test_struct = mock_get_trgt(mock_test_struct);
	struct mock_expectation *handle;

	handle = TEST_EXPECT_CALL(one_param(mock_get_ctrl(mock_test_struct)));
	handle->action = test_int_return(test, 0);
	handle = TEST_EXPECT_CALL(two_param(mock_get_ctrl(mock_test_struct),
					    test_int_eq(test, 5)));
	handle->action = test_int_return(test, 1);
	handle = TEST_EXPECT_CALL(non_first_slot_param(
			test_int_eq(test, 5), mock_get_ctrl(mock_test_struct)));
	handle->action = test_int_return(test, 1);

	test_struct->one_param(test_struct);
	test_struct->two_param(test_struct, 5);
	test_struct->non_first_slot_param(5, test_struct);
}

static void mock_macro_test_generated_method_void_code_works(struct test *test)
{
	struct mock_macro_context *ctx = test->priv;
	struct MOCK(void) *mock_void_ptr = ctx->mock_void_ptr;
	struct mock_expectation *handle;

	handle = TEST_EXPECT_CALL(test_void_ptr_func(
			mock_get_ctrl(mock_void_ptr),
			test_int_eq(test, 3)));
	handle->action = test_int_return(test, 0);

	test_void_ptr_func(mock_void_ptr, 3);
}

static void mock_macro_test_generated_function_code_works(struct test *test)
{
	struct mock_expectation *handle;

	handle = TEST_EXPECT_CALL(add(test_int_eq(test, 4),
				      test_int_eq(test, 3)));
	handle->action = test_int_return(test, 7);

	TEST_EXPECT_EQ(test, 7, add(4, 3));
}

static int mock_macro_test_init(struct test *test)
{
	struct mock_macro_context *ctx;

	ctx = test_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
	if (!ctx)
		return -ENOMEM;
	test->priv = ctx;

	ctx->mock_test_struct = CONSTRUCT_MOCK(test_struct, test);
	if (!ctx->mock_test_struct)
		return -EINVAL;

	ctx->mock_void_ptr = CONSTRUCT_MOCK(void, test);
	if (!ctx->mock_void_ptr)
		return -EINVAL;

	return 0;
}

static struct test_case mock_macro_test_cases[] = {
	TEST_CASE(mock_macro_is_equal),
	TEST_CASE(mock_macro_if),
	TEST_CASE(mock_macro_apply_tokens),
	TEST_CASE(mock_macro_param_list_recurse),
	TEST_CASE(mock_macro_for_each_param),
	TEST_CASE(mock_macro_param_list_from_types_basic),
	TEST_CASE(mock_macro_arg_names_from_types),
	TEST_CASE(mock_macro_test_generated_method_code_works),
	TEST_CASE(mock_macro_test_generated_method_void_code_works),
	TEST_CASE(mock_macro_test_generated_function_code_works),
	{},
};

static struct test_module mock_macro_test_module = {
	.name = "mock-macro-test",
	.init = mock_macro_test_init,
	.test_cases = mock_macro_test_cases,
};
module_test(mock_macro_test_module);