// SPDX-License-Identifier: GPL-2.0/* * KUnit API to save and access test attributes * * Copyright (C) 2023, Google LLC. * Author: Rae Moar <rmoar@google.com> */ #include <kunit/test.h>#include <kunit/attributes.h> /* Options for printing attributes: * PRINT_ALWAYS - attribute is printed for every test case and suite if set * PRINT_SUITE - attribute is printed for every suite if set but not for test cases * PRINT_NEVER - attribute is never printed */enum print_ops {	PRINT_ALWAYS,	PRINT_SUITE,	PRINT_NEVER,}; /** * struct kunit_attr - represents a test attribute and holds flexible * helper functions to interact with attribute. * * @name: name of test attribute, eg. speed * @get_attr: function to return attribute value given a test * @to_string: function to return string representation of given * attribute value * @filter: function to indicate whether a given attribute value passes a * filter * @attr_default: default attribute value used during filtering * @print: value of enum print_ops to indicate when to print attribute */struct kunit_attr {	const char *name;	void *(*get_attr)(void *test_or_suite, bool is_test);	const char *(*to_string)(void *attr, bool *to_free);	int (*filter)(void *attr, const char *input, int *err);	void *attr_default;	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_bool_to_string(void *attr, bool *to_free){	bool val = (bool)attr; 	*to_free = false;	if (val)		return "true";	return "false";} static const char *attr_speed_to_string(void *attr, bool *to_free){	return attr_enum_to_string(attr, speed_str_list, to_free);} static const char *attr_string_to_string(void *attr, bool *to_free){	*to_free = false;	return (char *) attr;} /* Filter Methods */ static const char op_list[] = "<>!="; /* * Returns whether the inputted integer value matches the filter given * by the operation string and inputted integer. */static int int_filter(long val, const char *op, int input, int *err){	if (!strncmp(op, "<=", 2))		return (val <= input);	else if (!strncmp(op, ">=", 2))		return (val >= input);	else if (!strncmp(op, "!=", 2))		return (val != input);	else if (!strncmp(op, ">", 1))		return (val > input);	else if (!strncmp(op, "<", 1))		return (val < input);	else if (!strncmp(op, "=", 1))		return (val == input);	*err = -EINVAL;	pr_err("kunit executor: invalid filter operation: %s\n", op);	return false;} /* * Returns whether the inputted enum value "attr" matches the filter given * by the input string. Note: the str_list includes the corresponding string * list to the enum values. */static int attr_enum_filter(void *attr, const char *input, int *err,		const char * const str_list[], int max){	int i, j, input_int = -1;	long test_val = (long)attr;	const char *input_val = NULL; 	for (i = 0; input[i]; i++) {		if (!strchr(op_list, input[i])) {			input_val = input + i;			break;		}	} 	if (!input_val) {		*err = -EINVAL;		pr_err("kunit executor: filter value not found: %s\n", input);		return false;	} 	for (j = 0; j <= max; j++) {		if (!strcmp(input_val, str_list[j]))			input_int = j;	} 	if (input_int < 0) {		*err = -EINVAL;		pr_err("kunit executor: invalid filter input: %s\n", input);		return false;	} 	return int_filter(test_val, input, input_int, err);} static int attr_speed_filter(void *attr, const char *input, int *err){	return attr_enum_filter(attr, input, err, speed_str_list, KUNIT_SPEED_MAX);} /* * Returns whether the inputted string value (attr) matches the filter given * by the input string. */static int attr_string_filter(void *attr, const char *input, int *err){	char *str = attr; 	if (!strncmp(input, "<", 1)) {		*err = -EINVAL;		pr_err("kunit executor: invalid filter input: %s\n", input);		return false;	} else if (!strncmp(input, ">", 1)) {		*err = -EINVAL;		pr_err("kunit executor: invalid filter input: %s\n", input);		return false;	} else if (!strncmp(input, "!=", 2)) {		return (strcmp(input + 2, str) != 0);	} else if (!strncmp(input, "=", 1)) {		return (strcmp(input + 1, str) == 0);	}	*err = -EINVAL;	pr_err("kunit executor: invalid filter operation: %s\n", input);	return false;} static int attr_bool_filter(void *attr, const char *input, int *err){	int i, input_int = -1;	long val = (long)attr;	const char *input_str = NULL; 	for (i = 0; input[i]; i++) {		if (!strchr(op_list, input[i])) {			input_str = input + i;			break;		}	} 	if (!input_str) {		*err = -EINVAL;		pr_err("kunit executor: filter value not found: %s\n", input);		return false;	} 	if (!strcmp(input_str, "true"))		input_int = (int)true;	else if (!strcmp(input_str, "false"))		input_int = (int)false;	else {		*err = -EINVAL;		pr_err("kunit executor: invalid filter input: %s\n", input);		return false;	} 	return int_filter(val, input, input_int, err);} /* 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);} static void *attr_module_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; 	// Suites get their module attribute from their first test_case	if (test)		return ((void *) test->module_name);	else if (kunit_suite_num_test_cases(suite) > 0)		return ((void *) suite->test_cases[0].module_name);	else		return (void *) "";} static void *attr_is_init_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 *) NULL);	else		return ((void *) suite->is_init);} /* List of all Test Attributes */ static struct kunit_attr kunit_attr_list[] = {	{		.name = "speed",		.get_attr = attr_speed_get,		.to_string = attr_speed_to_string,		.filter = attr_speed_filter,		.attr_default = (void *)KUNIT_SPEED_NORMAL,		.print = PRINT_ALWAYS,	},	{		.name = "module",		.get_attr = attr_module_get,		.to_string = attr_string_to_string,		.filter = attr_string_filter,		.attr_default = (void *)"",		.print = PRINT_SUITE,	},	{		.name = "is_init",		.get_attr = attr_is_init_get,		.to_string = attr_bool_to_string,		.filter = attr_bool_filter,		.attr_default = (void *)false,		.print = PRINT_SUITE,	}}; /* Helper Functions to Access Attributes */ const char *kunit_attr_filter_name(struct kunit_attr_filter filter){	return filter.attr->name;} void kunit_print_attr(void *test_or_suite, bool is_test, unsigned int test_level){	int i;	bool to_free = false;	void *attr;	const char *attr_name, *attr_str;	struct kunit_suite *suite = is_test ? NULL : test_or_suite;	struct kunit_case *test = is_test ? test_or_suite : NULL; 	for (i = 0; i < ARRAY_SIZE(kunit_attr_list); i++) {		if (kunit_attr_list[i].print == PRINT_NEVER ||				(test && kunit_attr_list[i].print == PRINT_SUITE))			continue;		attr = kunit_attr_list[i].get_attr(test_or_suite, is_test);		if (attr) {			attr_name = kunit_attr_list[i].name;			attr_str = kunit_attr_list[i].to_string(attr, &to_free);			if (test) {				kunit_log(KERN_INFO, test, "%*s# %s.%s: %s",					KUNIT_INDENT_LEN * test_level, "", test->name,					attr_name, attr_str);			} else {				kunit_log(KERN_INFO, suite, "%*s# %s: %s",					KUNIT_INDENT_LEN * test_level, "", attr_name, attr_str);			} 			/* Free to_string of attribute if needed */			if (to_free)				kfree(attr_str);		}	}} /* Helper Functions to Filter Attributes */ int kunit_get_filter_count(char *input){	int i, comma_index = 0, count = 0; 	for (i = 0; input[i]; i++) {		if (input[i] == ',') {			if ((i - comma_index) > 1)				count++;			comma_index = i;		}	}	if ((i - comma_index) > 0)		count++;	return count;} struct kunit_attr_filter kunit_next_attr_filter(char **filters, int *err){	struct kunit_attr_filter filter = {};	int i, j, comma_index = 0, new_start_index = 0;	int op_index = -1, attr_index = -1;	char op;	char *input = *filters; 	/* Parse input until operation */	for (i = 0; input[i]; i++) {		if (op_index < 0 && strchr(op_list, input[i])) {			op_index = i;		} else if (!comma_index && input[i] == ',') {			comma_index = i;		} else if (comma_index && input[i] != ' ') {			new_start_index = i;			break;		}	} 	if (op_index <= 0) {		*err = -EINVAL;		pr_err("kunit executor: filter operation not found: %s\n", input);		return filter;	} 	/* Temporarily set operator to \0 character. */	op = input[op_index];	input[op_index] = '\0'; 	/* Find associated kunit_attr object */	for (j = 0; j < ARRAY_SIZE(kunit_attr_list); j++) {		if (!strcmp(input, kunit_attr_list[j].name)) {			attr_index = j;			break;		}	} 	input[op_index] = op; 	if (attr_index < 0) {		*err = -EINVAL;		pr_err("kunit executor: attribute not found: %s\n", input);	} else {		filter.attr = &kunit_attr_list[attr_index];	} 	if (comma_index > 0) {		input[comma_index] = '\0';		filter.input = input + op_index;		input = input + new_start_index;	} else {		filter.input = input + op_index;		input = NULL;	} 	*filters = input; 	return filter;} struct kunit_suite *kunit_filter_attr_tests(const struct kunit_suite *const suite,		struct kunit_attr_filter filter, char *action, int *err){	int n = 0;	struct kunit_case *filtered, *test_case;	struct kunit_suite *copy;	void *suite_val, *test_val;	bool suite_result, test_result, default_result, result; 	/* Allocate memory for new copy of suite and list of test cases */	copy = kmemdup(suite, sizeof(*copy), GFP_KERNEL);	if (!copy)		return ERR_PTR(-ENOMEM); 	kunit_suite_for_each_test_case(suite, test_case) { n++; } 	filtered = kcalloc(n + 1, sizeof(*filtered), GFP_KERNEL);	if (!filtered) {		kfree(copy);		return ERR_PTR(-ENOMEM);	} 	n = 0; 	/* Save filtering result on default value */	default_result = filter.attr->filter(filter.attr->attr_default, filter.input, err);	if (*err)		goto err; 	/* Save suite attribute value and filtering result on that value */	suite_val = filter.attr->get_attr((void *)suite, false);	suite_result = filter.attr->filter(suite_val, filter.input, err);	if (*err)		goto err; 	/* For each test case, save test case if passes filtering. */	kunit_suite_for_each_test_case(suite, test_case) {		test_val = filter.attr->get_attr((void *) test_case, true);		test_result = filter.attr->filter(filter.attr->get_attr(test_case, true),				filter.input, err);		if (*err)			goto err; 		/*		 * If attribute value of test case is set, filter on that value.		 * If not, filter on suite value if set. If not, filter on		 * default value.		 */		result = false;		if (test_val) {			if (test_result)				result = true;		} else if (suite_val) {			if (suite_result)				result = true;		} else if (default_result) {			result = true;		} 		if (result) {			filtered[n++] = *test_case;		} else if (action && strcmp(action, "skip") == 0) {			test_case->status = KUNIT_SKIPPED;			filtered[n++] = *test_case;		}	} err:	if (n == 0 || *err) {		kfree(copy);		kfree(filtered);		return NULL;	} 	copy->test_cases = filtered; 	return copy;}