| #!/usr/bin/env python3 | |
| # SPDX-License-Identifier: GPL-2.0 | |
| # | |
| # A thin wrapper on top of the KUnit Kernel | |
| # | |
| # Copyright (C) 2019, Google LLC. | |
| # Author: Felix Guo <felixguoxiuping@gmail.com> | |
| # Author: Brendan Higgins <brendanhiggins@google.com> | |
| import argparse | |
| import sys | |
| import os | |
| import time | |
| from collections import namedtuple | |
| from enum import Enum, auto | |
| import kunit_config | |
| import kunit_json | |
| import kunit_kernel | |
| import kunit_parser | |
| KunitResult = namedtuple('KunitResult', ['status','result','elapsed_time']) | |
| KunitConfigRequest = namedtuple('KunitConfigRequest', | |
| ['build_dir', 'make_options']) | |
| KunitBuildRequest = namedtuple('KunitBuildRequest', | |
| ['jobs', 'build_dir', 'alltests', | |
| 'make_options']) | |
| KunitExecRequest = namedtuple('KunitExecRequest', | |
| ['timeout', 'build_dir', 'alltests']) | |
| KunitParseRequest = namedtuple('KunitParseRequest', | |
| ['raw_output', 'input_data', 'build_dir', 'json']) | |
| KunitRequest = namedtuple('KunitRequest', ['raw_output','timeout', 'jobs', | |
| 'build_dir', 'alltests', 'json', | |
| 'make_options']) | |
| KernelDirectoryPath = sys.argv[0].split('tools/testing/kunit/')[0] | |
| class KunitStatus(Enum): | |
| SUCCESS = auto() | |
| CONFIG_FAILURE = auto() | |
| BUILD_FAILURE = auto() | |
| TEST_FAILURE = auto() | |
| def get_kernel_root_path(): | |
| parts = sys.argv[0] if not __file__ else __file__ | |
| parts = os.path.realpath(parts).split('tools/testing/kunit') | |
| if len(parts) != 2: | |
| sys.exit(1) | |
| return parts[0] | |
| def config_tests(linux: kunit_kernel.LinuxSourceTree, | |
| request: KunitConfigRequest) -> KunitResult: | |
| kunit_parser.print_with_timestamp('Configuring KUnit Kernel ...') | |
| config_start = time.time() | |
| success = linux.build_reconfig(request.build_dir, request.make_options) | |
| config_end = time.time() | |
| if not success: | |
| return KunitResult(KunitStatus.CONFIG_FAILURE, | |
| 'could not configure kernel', | |
| config_end - config_start) | |
| return KunitResult(KunitStatus.SUCCESS, | |
| 'configured kernel successfully', | |
| config_end - config_start) | |
| def build_tests(linux: kunit_kernel.LinuxSourceTree, | |
| request: KunitBuildRequest) -> KunitResult: | |
| kunit_parser.print_with_timestamp('Building KUnit Kernel ...') | |
| build_start = time.time() | |
| success = linux.build_um_kernel(request.alltests, | |
| request.jobs, | |
| request.build_dir, | |
| request.make_options) | |
| build_end = time.time() | |
| if not success: | |
| return KunitResult(KunitStatus.BUILD_FAILURE, | |
| 'could not build kernel', | |
| build_end - build_start) | |
| if not success: | |
| return KunitResult(KunitStatus.BUILD_FAILURE, | |
| 'could not build kernel', | |
| build_end - build_start) | |
| return KunitResult(KunitStatus.SUCCESS, | |
| 'built kernel successfully', | |
| build_end - build_start) | |
| def exec_tests(linux: kunit_kernel.LinuxSourceTree, | |
| request: KunitExecRequest) -> KunitResult: | |
| kunit_parser.print_with_timestamp('Starting KUnit Kernel ...') | |
| test_start = time.time() | |
| result = linux.run_kernel( | |
| timeout=None if request.alltests else request.timeout, | |
| build_dir=request.build_dir) | |
| test_end = time.time() | |
| return KunitResult(KunitStatus.SUCCESS, | |
| result, | |
| test_end - test_start) | |
| def parse_tests(request: KunitParseRequest) -> KunitResult: | |
| parse_start = time.time() | |
| test_result = kunit_parser.TestResult(kunit_parser.TestStatus.SUCCESS, | |
| [], | |
| 'Tests not Parsed.') | |
| if request.raw_output: | |
| kunit_parser.raw_output(request.input_data) | |
| else: | |
| test_result = kunit_parser.parse_run_tests(request.input_data) | |
| parse_end = time.time() | |
| if request.json: | |
| json_obj = kunit_json.get_json_result( | |
| test_result=test_result, | |
| def_config='kunit_defconfig', | |
| build_dir=request.build_dir, | |
| json_path=request.json) | |
| if request.json == 'stdout': | |
| print(json_obj) | |
| if test_result.status != kunit_parser.TestStatus.SUCCESS: | |
| return KunitResult(KunitStatus.TEST_FAILURE, test_result, | |
| parse_end - parse_start) | |
| return KunitResult(KunitStatus.SUCCESS, test_result, | |
| parse_end - parse_start) | |
| def run_tests(linux: kunit_kernel.LinuxSourceTree, | |
| request: KunitRequest) -> KunitResult: | |
| run_start = time.time() | |
| config_request = KunitConfigRequest(request.build_dir, | |
| request.make_options) | |
| config_result = config_tests(linux, config_request) | |
| if config_result.status != KunitStatus.SUCCESS: | |
| return config_result | |
| build_request = KunitBuildRequest(request.jobs, request.build_dir, | |
| request.alltests, | |
| request.make_options) | |
| build_result = build_tests(linux, build_request) | |
| if build_result.status != KunitStatus.SUCCESS: | |
| return build_result | |
| exec_request = KunitExecRequest(request.timeout, request.build_dir, | |
| request.alltests) | |
| exec_result = exec_tests(linux, exec_request) | |
| if exec_result.status != KunitStatus.SUCCESS: | |
| return exec_result | |
| parse_request = KunitParseRequest(request.raw_output, | |
| exec_result.result, | |
| request.build_dir, | |
| request.json) | |
| parse_result = parse_tests(parse_request) | |
| run_end = time.time() | |
| kunit_parser.print_with_timestamp(( | |
| 'Elapsed time: %.3fs total, %.3fs configuring, %.3fs ' + | |
| 'building, %.3fs running\n') % ( | |
| run_end - run_start, | |
| config_result.elapsed_time, | |
| build_result.elapsed_time, | |
| exec_result.elapsed_time)) | |
| return parse_result | |
| def add_common_opts(parser): | |
| parser.add_argument('--build_dir', | |
| help='As in the make command, it specifies the build ' | |
| 'directory.', | |
| type=str, default='.kunit', metavar='build_dir') | |
| parser.add_argument('--make_options', | |
| help='X=Y make option, can be repeated.', | |
| action='append') | |
| parser.add_argument('--alltests', | |
| help='Run all KUnit tests through allyesconfig', | |
| action='store_true') | |
| def add_build_opts(parser): | |
| parser.add_argument('--jobs', | |
| help='As in the make command, "Specifies the number of ' | |
| 'jobs (commands) to run simultaneously."', | |
| type=int, default=8, metavar='jobs') | |
| def add_exec_opts(parser): | |
| parser.add_argument('--timeout', | |
| help='maximum number of seconds to allow for all tests ' | |
| 'to run. This does not include time taken to build the ' | |
| 'tests.', | |
| type=int, | |
| default=300, | |
| metavar='timeout') | |
| def add_parse_opts(parser): | |
| parser.add_argument('--raw_output', help='don\'t format output from kernel', | |
| action='store_true') | |
| parser.add_argument('--json', | |
| nargs='?', | |
| help='Stores test results in a JSON, and either ' | |
| 'prints to stdout or saves to file if a ' | |
| 'filename is specified', | |
| type=str, const='stdout', default=None) | |
| def main(argv, linux=None): | |
| parser = argparse.ArgumentParser( | |
| description='Helps writing and running KUnit tests.') | |
| subparser = parser.add_subparsers(dest='subcommand') | |
| # The 'run' command will config, build, exec, and parse in one go. | |
| run_parser = subparser.add_parser('run', help='Runs KUnit tests.') | |
| add_common_opts(run_parser) | |
| add_build_opts(run_parser) | |
| add_exec_opts(run_parser) | |
| add_parse_opts(run_parser) | |
| config_parser = subparser.add_parser('config', | |
| help='Ensures that .config contains all of ' | |
| 'the options in .kunitconfig') | |
| add_common_opts(config_parser) | |
| build_parser = subparser.add_parser('build', help='Builds a kernel with KUnit tests') | |
| add_common_opts(build_parser) | |
| add_build_opts(build_parser) | |
| exec_parser = subparser.add_parser('exec', help='Run a kernel with KUnit tests') | |
| add_common_opts(exec_parser) | |
| add_exec_opts(exec_parser) | |
| add_parse_opts(exec_parser) | |
| # The 'parse' option is special, as it doesn't need the kernel source | |
| # (therefore there is no need for a build_dir, hence no add_common_opts) | |
| # and the '--file' argument is not relevant to 'run', so isn't in | |
| # add_parse_opts() | |
| parse_parser = subparser.add_parser('parse', | |
| help='Parses KUnit results from a file, ' | |
| 'and parses formatted results.') | |
| add_parse_opts(parse_parser) | |
| parse_parser.add_argument('file', | |
| help='Specifies the file to read results from.', | |
| type=str, nargs='?', metavar='input_file') | |
| cli_args = parser.parse_args(argv) | |
| if get_kernel_root_path(): | |
| os.chdir(get_kernel_root_path()) | |
| if cli_args.subcommand == 'run': | |
| if not os.path.exists(cli_args.build_dir): | |
| os.mkdir(cli_args.build_dir) | |
| if not linux: | |
| linux = kunit_kernel.LinuxSourceTree() | |
| linux.create_kunitconfig(cli_args.build_dir) | |
| linux.read_kunitconfig(cli_args.build_dir) | |
| request = KunitRequest(cli_args.raw_output, | |
| cli_args.timeout, | |
| cli_args.jobs, | |
| cli_args.build_dir, | |
| cli_args.alltests, | |
| cli_args.json, | |
| cli_args.make_options) | |
| result = run_tests(linux, request) | |
| if result.status != KunitStatus.SUCCESS: | |
| sys.exit(1) | |
| elif cli_args.subcommand == 'config': | |
| if cli_args.build_dir and ( | |
| not os.path.exists(cli_args.build_dir)): | |
| os.mkdir(cli_args.build_dir) | |
| if not linux: | |
| linux = kunit_kernel.LinuxSourceTree() | |
| linux.create_kunitconfig(cli_args.build_dir) | |
| linux.read_kunitconfig(cli_args.build_dir) | |
| request = KunitConfigRequest(cli_args.build_dir, | |
| cli_args.make_options) | |
| result = config_tests(linux, request) | |
| kunit_parser.print_with_timestamp(( | |
| 'Elapsed time: %.3fs\n') % ( | |
| result.elapsed_time)) | |
| if result.status != KunitStatus.SUCCESS: | |
| sys.exit(1) | |
| elif cli_args.subcommand == 'build': | |
| if not linux: | |
| linux = kunit_kernel.LinuxSourceTree() | |
| linux.create_kunitconfig(cli_args.build_dir) | |
| linux.read_kunitconfig(cli_args.build_dir) | |
| request = KunitBuildRequest(cli_args.jobs, | |
| cli_args.build_dir, | |
| cli_args.alltests, | |
| cli_args.make_options) | |
| result = build_tests(linux, request) | |
| kunit_parser.print_with_timestamp(( | |
| 'Elapsed time: %.3fs\n') % ( | |
| result.elapsed_time)) | |
| if result.status != KunitStatus.SUCCESS: | |
| sys.exit(1) | |
| elif cli_args.subcommand == 'exec': | |
| if not linux: | |
| linux = kunit_kernel.LinuxSourceTree() | |
| linux.create_kunitconfig(cli_args.build_dir) | |
| linux.read_kunitconfig(cli_args.build_dir) | |
| exec_request = KunitExecRequest(cli_args.timeout, | |
| cli_args.build_dir, | |
| cli_args.alltests) | |
| exec_result = exec_tests(linux, exec_request) | |
| parse_request = KunitParseRequest(cli_args.raw_output, | |
| exec_result.result, | |
| cli_args.build_dir, | |
| cli_args.json) | |
| result = parse_tests(parse_request) | |
| kunit_parser.print_with_timestamp(( | |
| 'Elapsed time: %.3fs\n') % ( | |
| exec_result.elapsed_time)) | |
| if result.status != KunitStatus.SUCCESS: | |
| sys.exit(1) | |
| elif cli_args.subcommand == 'parse': | |
| if cli_args.file == None: | |
| kunit_output = sys.stdin | |
| else: | |
| with open(cli_args.file, 'r') as f: | |
| kunit_output = f.read().splitlines() | |
| request = KunitParseRequest(cli_args.raw_output, | |
| kunit_output, | |
| None, | |
| cli_args.json) | |
| result = parse_tests(request) | |
| if result.status != KunitStatus.SUCCESS: | |
| sys.exit(1) | |
| else: | |
| parser.print_help() | |
| if __name__ == '__main__': | |
| main(sys.argv[1:]) |