475 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * KUnit API to save and access test attributes4 *5 * Copyright (C) 2023, Google LLC.6 * Author: Rae Moar <rmoar@google.com>7 */8 9#include <kunit/test.h>10#include <kunit/attributes.h>11 12/* Options for printing attributes:13 * PRINT_ALWAYS - attribute is printed for every test case and suite if set14 * PRINT_SUITE - attribute is printed for every suite if set but not for test cases15 * PRINT_NEVER - attribute is never printed16 */17enum print_ops {18 PRINT_ALWAYS,19 PRINT_SUITE,20 PRINT_NEVER,21};22 23/**24 * struct kunit_attr - represents a test attribute and holds flexible25 * helper functions to interact with attribute.26 *27 * @name: name of test attribute, eg. speed28 * @get_attr: function to return attribute value given a test29 * @to_string: function to return string representation of given30 * attribute value31 * @filter: function to indicate whether a given attribute value passes a32 * filter33 * @attr_default: default attribute value used during filtering34 * @print: value of enum print_ops to indicate when to print attribute35 */36struct kunit_attr {37 const char *name;38 void *(*get_attr)(void *test_or_suite, bool is_test);39 const char *(*to_string)(void *attr, bool *to_free);40 int (*filter)(void *attr, const char *input, int *err);41 void *attr_default;42 enum print_ops print;43};44 45/* String Lists for enum Attributes */46 47static const char * const speed_str_list[] = {"unset", "very_slow", "slow", "normal"};48 49/* To String Methods */50 51static const char *attr_enum_to_string(void *attr, const char * const str_list[], bool *to_free)52{53 long val = (long)attr;54 55 *to_free = false;56 if (!val)57 return NULL;58 return str_list[val];59}60 61static const char *attr_bool_to_string(void *attr, bool *to_free)62{63 bool val = (bool)attr;64 65 *to_free = false;66 if (val)67 return "true";68 return "false";69}70 71static const char *attr_speed_to_string(void *attr, bool *to_free)72{73 return attr_enum_to_string(attr, speed_str_list, to_free);74}75 76static const char *attr_string_to_string(void *attr, bool *to_free)77{78 *to_free = false;79 return (char *) attr;80}81 82/* Filter Methods */83 84static const char op_list[] = "<>!=";85 86/*87 * Returns whether the inputted integer value matches the filter given88 * by the operation string and inputted integer.89 */90static int int_filter(long val, const char *op, int input, int *err)91{92 if (!strncmp(op, "<=", 2))93 return (val <= input);94 else if (!strncmp(op, ">=", 2))95 return (val >= input);96 else if (!strncmp(op, "!=", 2))97 return (val != input);98 else if (!strncmp(op, ">", 1))99 return (val > input);100 else if (!strncmp(op, "<", 1))101 return (val < input);102 else if (!strncmp(op, "=", 1))103 return (val == input);104 *err = -EINVAL;105 pr_err("kunit executor: invalid filter operation: %s\n", op);106 return false;107}108 109/*110 * Returns whether the inputted enum value "attr" matches the filter given111 * by the input string. Note: the str_list includes the corresponding string112 * list to the enum values.113 */114static int attr_enum_filter(void *attr, const char *input, int *err,115 const char * const str_list[], int max)116{117 int i, j, input_int = -1;118 long test_val = (long)attr;119 const char *input_val = NULL;120 121 for (i = 0; input[i]; i++) {122 if (!strchr(op_list, input[i])) {123 input_val = input + i;124 break;125 }126 }127 128 if (!input_val) {129 *err = -EINVAL;130 pr_err("kunit executor: filter value not found: %s\n", input);131 return false;132 }133 134 for (j = 0; j <= max; j++) {135 if (!strcmp(input_val, str_list[j]))136 input_int = j;137 }138 139 if (input_int < 0) {140 *err = -EINVAL;141 pr_err("kunit executor: invalid filter input: %s\n", input);142 return false;143 }144 145 return int_filter(test_val, input, input_int, err);146}147 148static int attr_speed_filter(void *attr, const char *input, int *err)149{150 return attr_enum_filter(attr, input, err, speed_str_list, KUNIT_SPEED_MAX);151}152 153/*154 * Returns whether the inputted string value (attr) matches the filter given155 * by the input string.156 */157static int attr_string_filter(void *attr, const char *input, int *err)158{159 char *str = attr;160 161 if (!strncmp(input, "<", 1)) {162 *err = -EINVAL;163 pr_err("kunit executor: invalid filter input: %s\n", input);164 return false;165 } else if (!strncmp(input, ">", 1)) {166 *err = -EINVAL;167 pr_err("kunit executor: invalid filter input: %s\n", input);168 return false;169 } else if (!strncmp(input, "!=", 2)) {170 return (strcmp(input + 2, str) != 0);171 } else if (!strncmp(input, "=", 1)) {172 return (strcmp(input + 1, str) == 0);173 }174 *err = -EINVAL;175 pr_err("kunit executor: invalid filter operation: %s\n", input);176 return false;177}178 179static int attr_bool_filter(void *attr, const char *input, int *err)180{181 int i, input_int = -1;182 long val = (long)attr;183 const char *input_str = NULL;184 185 for (i = 0; input[i]; i++) {186 if (!strchr(op_list, input[i])) {187 input_str = input + i;188 break;189 }190 }191 192 if (!input_str) {193 *err = -EINVAL;194 pr_err("kunit executor: filter value not found: %s\n", input);195 return false;196 }197 198 if (!strcmp(input_str, "true"))199 input_int = (int)true;200 else if (!strcmp(input_str, "false"))201 input_int = (int)false;202 else {203 *err = -EINVAL;204 pr_err("kunit executor: invalid filter input: %s\n", input);205 return false;206 }207 208 return int_filter(val, input, input_int, err);209}210 211/* Get Attribute Methods */212 213static void *attr_speed_get(void *test_or_suite, bool is_test)214{215 struct kunit_suite *suite = is_test ? NULL : test_or_suite;216 struct kunit_case *test = is_test ? test_or_suite : NULL;217 218 if (test)219 return ((void *) test->attr.speed);220 else221 return ((void *) suite->attr.speed);222}223 224static void *attr_module_get(void *test_or_suite, bool is_test)225{226 struct kunit_suite *suite = is_test ? NULL : test_or_suite;227 struct kunit_case *test = is_test ? test_or_suite : NULL;228 229 // Suites get their module attribute from their first test_case230 if (test)231 return ((void *) test->module_name);232 else if (kunit_suite_num_test_cases(suite) > 0)233 return ((void *) suite->test_cases[0].module_name);234 else235 return (void *) "";236}237 238static void *attr_is_init_get(void *test_or_suite, bool is_test)239{240 struct kunit_suite *suite = is_test ? NULL : test_or_suite;241 struct kunit_case *test = is_test ? test_or_suite : NULL;242 243 if (test)244 return ((void *) NULL);245 else246 return ((void *) suite->is_init);247}248 249/* List of all Test Attributes */250 251static struct kunit_attr kunit_attr_list[] = {252 {253 .name = "speed",254 .get_attr = attr_speed_get,255 .to_string = attr_speed_to_string,256 .filter = attr_speed_filter,257 .attr_default = (void *)KUNIT_SPEED_NORMAL,258 .print = PRINT_ALWAYS,259 },260 {261 .name = "module",262 .get_attr = attr_module_get,263 .to_string = attr_string_to_string,264 .filter = attr_string_filter,265 .attr_default = (void *)"",266 .print = PRINT_SUITE,267 },268 {269 .name = "is_init",270 .get_attr = attr_is_init_get,271 .to_string = attr_bool_to_string,272 .filter = attr_bool_filter,273 .attr_default = (void *)false,274 .print = PRINT_SUITE,275 }276};277 278/* Helper Functions to Access Attributes */279 280const char *kunit_attr_filter_name(struct kunit_attr_filter filter)281{282 return filter.attr->name;283}284 285void kunit_print_attr(void *test_or_suite, bool is_test, unsigned int test_level)286{287 int i;288 bool to_free = false;289 void *attr;290 const char *attr_name, *attr_str;291 struct kunit_suite *suite = is_test ? NULL : test_or_suite;292 struct kunit_case *test = is_test ? test_or_suite : NULL;293 294 for (i = 0; i < ARRAY_SIZE(kunit_attr_list); i++) {295 if (kunit_attr_list[i].print == PRINT_NEVER ||296 (test && kunit_attr_list[i].print == PRINT_SUITE))297 continue;298 attr = kunit_attr_list[i].get_attr(test_or_suite, is_test);299 if (attr) {300 attr_name = kunit_attr_list[i].name;301 attr_str = kunit_attr_list[i].to_string(attr, &to_free);302 if (test) {303 kunit_log(KERN_INFO, test, "%*s# %s.%s: %s",304 KUNIT_INDENT_LEN * test_level, "", test->name,305 attr_name, attr_str);306 } else {307 kunit_log(KERN_INFO, suite, "%*s# %s: %s",308 KUNIT_INDENT_LEN * test_level, "", attr_name, attr_str);309 }310 311 /* Free to_string of attribute if needed */312 if (to_free)313 kfree(attr_str);314 }315 }316}317 318/* Helper Functions to Filter Attributes */319 320int kunit_get_filter_count(char *input)321{322 int i, comma_index = 0, count = 0;323 324 for (i = 0; input[i]; i++) {325 if (input[i] == ',') {326 if ((i - comma_index) > 1)327 count++;328 comma_index = i;329 }330 }331 if ((i - comma_index) > 0)332 count++;333 return count;334}335 336struct kunit_attr_filter kunit_next_attr_filter(char **filters, int *err)337{338 struct kunit_attr_filter filter = {};339 int i, j, comma_index = 0, new_start_index = 0;340 int op_index = -1, attr_index = -1;341 char op;342 char *input = *filters;343 344 /* Parse input until operation */345 for (i = 0; input[i]; i++) {346 if (op_index < 0 && strchr(op_list, input[i])) {347 op_index = i;348 } else if (!comma_index && input[i] == ',') {349 comma_index = i;350 } else if (comma_index && input[i] != ' ') {351 new_start_index = i;352 break;353 }354 }355 356 if (op_index <= 0) {357 *err = -EINVAL;358 pr_err("kunit executor: filter operation not found: %s\n", input);359 return filter;360 }361 362 /* Temporarily set operator to \0 character. */363 op = input[op_index];364 input[op_index] = '\0';365 366 /* Find associated kunit_attr object */367 for (j = 0; j < ARRAY_SIZE(kunit_attr_list); j++) {368 if (!strcmp(input, kunit_attr_list[j].name)) {369 attr_index = j;370 break;371 }372 }373 374 input[op_index] = op;375 376 if (attr_index < 0) {377 *err = -EINVAL;378 pr_err("kunit executor: attribute not found: %s\n", input);379 } else {380 filter.attr = &kunit_attr_list[attr_index];381 }382 383 if (comma_index > 0) {384 input[comma_index] = '\0';385 filter.input = input + op_index;386 input = input + new_start_index;387 } else {388 filter.input = input + op_index;389 input = NULL;390 }391 392 *filters = input;393 394 return filter;395}396 397struct kunit_suite *kunit_filter_attr_tests(const struct kunit_suite *const suite,398 struct kunit_attr_filter filter, char *action, int *err)399{400 int n = 0;401 struct kunit_case *filtered, *test_case;402 struct kunit_suite *copy;403 void *suite_val, *test_val;404 bool suite_result, test_result, default_result, result;405 406 /* Allocate memory for new copy of suite and list of test cases */407 copy = kmemdup(suite, sizeof(*copy), GFP_KERNEL);408 if (!copy)409 return ERR_PTR(-ENOMEM);410 411 kunit_suite_for_each_test_case(suite, test_case) { n++; }412 413 filtered = kcalloc(n + 1, sizeof(*filtered), GFP_KERNEL);414 if (!filtered) {415 kfree(copy);416 return ERR_PTR(-ENOMEM);417 }418 419 n = 0;420 421 /* Save filtering result on default value */422 default_result = filter.attr->filter(filter.attr->attr_default, filter.input, err);423 if (*err)424 goto err;425 426 /* Save suite attribute value and filtering result on that value */427 suite_val = filter.attr->get_attr((void *)suite, false);428 suite_result = filter.attr->filter(suite_val, filter.input, err);429 if (*err)430 goto err;431 432 /* For each test case, save test case if passes filtering. */433 kunit_suite_for_each_test_case(suite, test_case) {434 test_val = filter.attr->get_attr((void *) test_case, true);435 test_result = filter.attr->filter(filter.attr->get_attr(test_case, true),436 filter.input, err);437 if (*err)438 goto err;439 440 /*441 * If attribute value of test case is set, filter on that value.442 * If not, filter on suite value if set. If not, filter on443 * default value.444 */445 result = false;446 if (test_val) {447 if (test_result)448 result = true;449 } else if (suite_val) {450 if (suite_result)451 result = true;452 } else if (default_result) {453 result = true;454 }455 456 if (result) {457 filtered[n++] = *test_case;458 } else if (action && strcmp(action, "skip") == 0) {459 test_case->status = KUNIT_SKIPPED;460 filtered[n++] = *test_case;461 }462 }463 464err:465 if (n == 0 || *err) {466 kfree(copy);467 kfree(filtered);468 return NULL;469 }470 471 copy->test_cases = filtered;472 473 return copy;474}475