Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Rae Moar | 2201 | 96.03% | 7 | 31.82% |
Daniel Latypov | 46 | 2.01% | 7 | 31.82% |
David Gow | 18 | 0.79% | 4 | 18.18% |
Alan Maguire | 16 | 0.70% | 1 | 4.55% |
Brendan Higgins | 9 | 0.39% | 2 | 9.09% |
Uriel Guajardo | 2 | 0.09% | 1 | 4.55% |
Total | 2292 | 22 |
// 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; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1