| import re | |
| from datetime import datetime | |
| from collections import namedtuple | |
| TestResult = namedtuple('TestResult', ['status','modules','log']) | |
| TestModule = namedtuple('TestModule', ['status','name','cases']) | |
| TestCase = namedtuple('TestCase', ['status','name','log']) | |
| class TestStatus(object): | |
| SUCCESS = 'SUCCESS' | |
| FAILURE = 'FAILURE' | |
| TEST_CRASHED = 'TEST_CRASHED' | |
| TIMED_OUT = 'TIMED_OUT' | |
| KERNEL_CRASHED = 'KERNEL_CRASHED' | |
| kunit_start_re = re.compile('console .* enabled') | |
| kunit_end_re = re.compile('List of all partitions:') | |
| TIMED_OUT_LOG_ENTRY = 'Timeout Reached - Process Terminated' | |
| class KernelCrashException(Exception): | |
| pass | |
| def isolate_kunit_output(kernel_output): | |
| started = False | |
| for line in kernel_output: | |
| if kunit_start_re.match(line): | |
| started = True | |
| elif kunit_end_re.match(line): | |
| return | |
| elif started: | |
| yield line | |
| # Output ended without encountering end marker, kernel probably panicked | |
| # or crashed unexpectedly. | |
| raise KernelCrashException() | |
| def raw_output(kernel_output): | |
| for line in kernel_output: | |
| print(line) | |
| DIVIDER = "=" * 30 | |
| RESET = '\033[0;0m' | |
| def red(text): | |
| return '\033[1;31m' + text + RESET | |
| def yellow(text): | |
| return '\033[1;33m' + text + RESET | |
| def green(text): | |
| return '\033[1;32m' + text + RESET | |
| def timestamp(message): | |
| return '[%s] %s' % (datetime.now().strftime('%H:%M:%S'), message) | |
| def timestamp_log(log): | |
| for m in log: | |
| yield timestamp(m) | |
| def parse_run_tests(kernel_output): | |
| test_case_output = re.compile('^kunit .*?: (.*)$') | |
| test_module_success = re.compile('^kunit (.*): all tests passed') | |
| test_module_fail = re.compile('^kunit (.*): one or more tests failed') | |
| test_case_success = re.compile('^kunit (.*): (.*) passed') | |
| test_case_fail = re.compile('^kunit (.*): (.*) failed') | |
| test_case_crash = re.compile('^kunit (.*): (.*) crashed') | |
| total_tests = set() | |
| failed_tests = set() | |
| crashed_tests = set() | |
| test_status = TestStatus.SUCCESS | |
| modules = [] | |
| log_list = [] | |
| def get_test_module_name(match): | |
| return match.group(1) | |
| def get_test_case_name(match): | |
| return match.group(2) | |
| def get_test_name(match): | |
| return match.group(1) + ":" + match.group(2) | |
| current_case_log = [] | |
| current_module_cases = [] | |
| did_kernel_crash = False | |
| did_timeout = False | |
| def end_one_test(match, log): | |
| del log[:] | |
| total_tests.add(get_test_name(match)) | |
| print(timestamp(DIVIDER)) | |
| try: | |
| for line in kernel_output: | |
| log_list.append(line) | |
| # Ignore module output: | |
| module_success = test_module_success.match(line) | |
| if module_success: | |
| print(timestamp(DIVIDER)) | |
| modules.append( | |
| TestModule(TestStatus.SUCCESS, | |
| get_test_module_name(module_success), | |
| current_module_cases)) | |
| current_module_cases = [] | |
| continue | |
| module_fail = test_module_fail.match(line) | |
| if module_fail: | |
| print(timestamp(DIVIDER)) | |
| modules.append( | |
| TestModule(TestStatus.FAILURE, | |
| get_test_module_name(module_fail), | |
| current_module_cases)) | |
| current_module_cases = [] | |
| continue | |
| match = re.match(test_case_success, line) | |
| if match: | |
| print(timestamp(green("[PASSED] ") + get_test_name(match))) | |
| current_module_cases.append( | |
| TestCase(TestStatus.SUCCESS, | |
| get_test_case_name(match), | |
| '\n'.join(current_case_log))) | |
| end_one_test(match, current_case_log) | |
| continue | |
| match = re.match(test_case_fail, line) | |
| # Crashed tests will report as both failed and crashed. We only | |
| # want to show and count it once. | |
| if match and get_test_name(match) not in crashed_tests: | |
| failed_tests.add(get_test_name(match)) | |
| print(timestamp(red("[FAILED] " + get_test_name(match)))) | |
| for out in timestamp_log(map(yellow, current_case_log)): | |
| print(out) | |
| print(timestamp("")) | |
| current_module_cases.append( | |
| TestCase(TestStatus.FAILURE, | |
| get_test_case_name(match), | |
| '\n'.join(current_case_log))) | |
| if test_status != TestStatus.TEST_CRASHED: | |
| test_status = TestStatus.FAILURE | |
| end_one_test(match, current_case_log) | |
| continue | |
| match = re.match(test_case_crash, line) | |
| if match: | |
| crashed_tests.add(get_test_name(match)) | |
| print(timestamp(yellow("[CRASH] " + get_test_name(match)))) | |
| for out in timestamp_log(current_case_log): | |
| print(out) | |
| print(timestamp("")) | |
| current_module_cases.append( | |
| TestCase(TestStatus.TEST_CRASHED, | |
| get_test_case_name(match), | |
| '\n'.join(current_case_log))) | |
| test_status = TestStatus.TEST_CRASHED | |
| end_one_test(match, current_case_log) | |
| continue | |
| if line.strip() == TIMED_OUT_LOG_ENTRY: | |
| print(timestamp(red("[TIMED-OUT] Process Terminated"))) | |
| did_timeout = True | |
| test_status = TestStatus.TIMED_OUT | |
| break | |
| # Strip off the `kunit module-name:` prefix | |
| match = re.match(test_case_output, line) | |
| if match: | |
| current_case_log.append(match.group(1)) | |
| else: | |
| current_case_log.append(line) | |
| except KernelCrashException: | |
| did_kernel_crash = True | |
| test_status = TestStatus.KERNEL_CRASHED | |
| print(timestamp(red("The KUnit kernel crashed unexpectedly and was " + | |
| "unable to finish running tests!"))) | |
| print(timestamp(red("These are the logs from the most " + | |
| "recently running test:"))) | |
| print(timestamp(DIVIDER)) | |
| for out in timestamp_log(current_case_log): | |
| print(out) | |
| print(timestamp(DIVIDER)) | |
| fmt = green if (len(failed_tests) + len(crashed_tests) == 0 | |
| and not did_kernel_crash and not did_timeout) else red | |
| message = "Testing complete." | |
| if did_kernel_crash: | |
| message = "Before the crash:" | |
| elif did_timeout: | |
| message = "Before timing out:" | |
| print(timestamp(fmt(message + " %d tests run. %d failed. %d crashed." % | |
| (len(total_tests), len(failed_tests), len(crashed_tests))))) | |
| return TestResult(test_status, modules, '\n'.join(log_list)) |