#!/usr/bin/env vpython3 # Copyright 2023 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. import argparse from collections import Counter import http.server import json import os import subprocess import sys import threading import yaml def repo_path(*paths): RootDirectory = os.path.dirname( os.path.dirname( os.path.dirname(os.path.dirname(os.path.realpath(__file__))))) def make_absolute(path): if not path.startswith('//'): return path return os.path.join(RootDirectory, path[2:]) return os.path.join(os.getcwd(), *(make_absolute(path) for path in paths)) def make_dir(*paths): path = repo_path(*paths) try: os.makedirs(path) except FileExistsError: pass return path def create_symlink(src, dst): src = repo_path(src) dst = repo_path(dst) if os.path.islink(dst): os.remove(dst) if os.path.exists(dst): raise FileExistsError(dst) make_dir(os.path.dirname(dst)) os.symlink(src, dst) def get_artifact_dir(project, *paths): dirs = { 'devtools-frontend': 'devtools-frontend', 'test_suite': 'extensions/cxx_debugging/e2e', 'cxx_debugging': 'DevTools_CXX_Debugging.stage2' } base = dirs.get(project, None) if not base: return base return os.path.join(base, *paths) def ninja(build_root, artifact, verbose): ninja_dir = repo_path(build_root, get_artifact_dir(artifact)) if not os.path.exists(repo_path(ninja_dir, 'build.ninja')): sys.stderr.write( f'build.ninja not found for build artifact {artifact}. Did you run `compile` first?' ) raise FileNotFoundError(repo_path(ninja_dir, 'build.ninja')) run_process('ninja', cwd=ninja_dir, verbose=verbose) def run_process(*args, verbose=False, cwd=None, env=None): stdout = None if verbose else subprocess.PIPE stderr = None if verbose else subprocess.PIPE if verbose: env_spec = (' '.join(f"{a}='{b}'" for (a, b) in env.items()) + ' ') if env else '' sys.stderr.write( f'RUN: {env_spec}{" ".join(args)} (wd: {cwd or "."})\n') if env: full_env = os.environ.copy() full_env.update(env) else: full_env = None process = subprocess.Popen(args, cwd=cwd, env=full_env, stdout=stdout, stderr=stderr) out, err = process.communicate() if process.returncode != 0: sys.stderr.write( f'FAILED: {args[0]} returned non-zero exit status {process.returncode}\n' ) if not verbose: sys.stderr.write(f'{out.decode()}{err.decode()}') raise subprocess.CalledProcessError(process.returncode, args[0]) def list_tests(path): base_path = repo_path(path) for dirpath, _, files in os.walk(path): yield from (repo_path(base_path, dirpath, f) for f in files if f.endswith('.yaml')) NODE = repo_path('//third_party/node/node.py') class Test(object): def __init__(self, build_root, path): output_directory = repo_path(build_root, get_artifact_dir('test_suite')) with open(path) as test_file: test_data = yaml.load(test_file, Loader=yaml.SafeLoader) self.name = test_data['name'] self.source_file = repo_path(os.path.dirname(path), test_data['source_file']) self.output_directory = output_directory self.test_script = test_data.get('script', []) self.extension_parameters = test_data.get('extension_parameters', '') self.use_dwo = 'use_dwo' in test_data self.test_file = test_data.get('file', '') extra_flag = [ f'-fdebug-prefix-map={os.path.dirname(self.source_file)}/=' ] self.flags = [f + extra_flag for f in test_data['flags']] input_basename, _ = os.path.splitext(self.source_file) output_file_name = input_basename + '__' + Test.__replace_special_characters( self.name) output_file = os.path.relpath(output_file_name, repo_path('//')) # Create one output file per flag config self.output_files = [ f'{output_file}_{i}.html' for i in range(0, len(self.flags)) ] @classmethod def __replace_special_characters(cls, name): return name.replace('/', '_').replace(' ', '_').replace(':', '_') @classmethod def load_tests(cls, build_root): test_dir = repo_path('//extensions/cxx_debugging/e2e/tests') tests = [Test(build_root, t) for t in list_tests(test_dir)] names = Counter(t.name for t in tests) if len(names) != len(tests): duplicates = [k for k, v in names.items() if v > 1] raise Exception( f'Found {len(duplicates)} test{"s" if len(duplicates) > 1 else ""} with a non-unique name: {", ".join(duplicates)}' ) return tests def compile(self): _, ext = os.path.splitext(self.source_file) test_directory = os.path.join(self.output_directory, os.path.dirname(self.output_files[0])) make_dir(test_directory) compiler = repo_path( '//third_party/emscripten-releases/install/emscripten/', 'em++' if ext == '.cc' else 'emcc') source_file_name = os.path.basename(self.source_file) output_source_file = os.path.join( os.path.dirname(self.output_files[0]), source_file_name) # Create build ninja rules for each output_file for idx, output_file in enumerate(self.output_files): flags = self.flags[idx] output_test_name, _ = os.path.splitext(output_file) html_rule_name = os.path.basename(output_file) object_file = output_test_name + '.o' object_rule_name = os.path.basename(object_file) flags = ' '.join(flags) # Build the html output file from the object file yield f'rule build_{html_rule_name}\n command = cd {test_directory} && {compiler} {flags} {object_rule_name} -o {html_rule_name}\n description = Compiling test {self.name} to object file with flags: "{flags}"\n' yield f'build {output_file}: build_{html_rule_name} {object_file}\n' flags += ' -c' # Build the object file from the source file yield f'rule build_{object_rule_name}\n command = cd {test_directory} && {compiler} {flags} {source_file_name} -o {object_rule_name}\n description = Linking test {self.name} to binary with flags: "{flags}"\n' #.format( if '-gsplit-dwarf' in flags: # Generate the dwarf package file if necessary dwp_file = output_test_name + '.wasm.dwp' dwo_file = output_test_name + '.dwo' yield f'build {object_file} | {dwo_file}: build_{object_rule_name} {output_source_file}\n' if not self.use_dwo: yield f'build {dwp_file}: build_dwp {dwo_file}\n' else: yield f'build {object_file}: build_{object_rule_name} {output_source_file}\n' yield f'build {output_source_file}: cp {self.source_file}\n' class RunnerCommand(object): Command = None Help = None def _register_options(self, parser): pass @classmethod def create(cls, subparsers): if not cls.Command: raise RuntimeError(f'Class {cls} must override Command') parser = subparsers.add_parser(cls.Command, help=cls.Help) command = cls() command._register_options(parser) parser.add_argument('--build-root', dest='build_root', default='//out/Default') parser.add_argument('--verbose', '-v', action='store_true') parser.add_argument('--release', action='store_true', help='Build a release instead of a debug version.') parser.add_argument( '--release-version', type=int, default=None, help= 'Provide a version number for building a release, instead of building a debug version.' ) parser.add_argument( '--patch-level', type=int, default=0, help= 'Provide a version patch level for building a release, instead of building a debug version.' ) return cls.Command, command class Compile(RunnerCommand): Command = 'compile' Help = 'Compile the tests and the dependencies' def __call__(self, options): self.build_extension(options) self.build_devtools(options.build_root, options.verbose) self.build_tests(options.build_root, options.verbose) self.build_driver(options.build_root, options.verbose) def configure_tests(self, build_root): tests = Test.load_tests(build_root) test_suite_dir = repo_path(build_root, get_artifact_dir('test_suite')) make_dir(test_suite_dir) with open(repo_path(test_suite_dir, 'build.ninja'), 'w') as ninja_file: ninja_file.write( 'rule cp\n command = cp $in $out\n description = Installing $in\n\n' ) llvm_dwp = repo_path( '//third_party/emscripten-releases/install/bin/', 'llvm-dwp') ninja_file.write( 'rule build_dwp\n command = {llvm_dwp} $in -o $out\n description = Generating dwp file, creating $out\n\n' .format(llvm_dwp=llvm_dwp)) rules = set() for test in tests: for rule in test.compile(): if rule in rules: continue ninja_file.write('{}\n'.format(rule)) rules.add(rule) def build_tests(self, build_root, verbose): self.configure_tests(build_root) ninja(build_root, 'test_suite', verbose) def build_driver(self, build_root, verbose): tsc = repo_path('//node_modules/typescript/bin/tsc') run_process(sys.executable, NODE, '--output', tsc, '-p', repo_path('//extensions/cxx_debugging/e2e'), '--outDir', repo_path(build_root), verbose=verbose) def build_extension(self, options): args = [] if options.release or options.release_version: args.append('-release-version') args.append(options.release_version or 0) args.append('-patch-level') args.append(options.patch_level or 0) run_process(sys.executable, repo_path('//extensions/cxx_debugging/tools/bootstrap.py'), '-infra', *[str(a) for a in args], repo_path(options.build_root), verbose=options.verbose, cwd=repo_path('//')) return options.build_root def build_devtools(self, build_root, verbose): platforms = {'linux': 'linux64', 'win32': 'win', 'darwin': 'mac'} gn = repo_path('//buildtools/{}/'.format(platforms[sys.platform]), 'gn') gn_args_path = repo_path('//build/config/gclient_args.gni') devtools_build_root = repo_path(build_root, get_artifact_dir('devtools-frontend')) make_dir(devtools_build_root) run_process(gn, 'gen', devtools_build_root, cwd=repo_path('//'), verbose=verbose) ninja(build_root, 'devtools-frontend', verbose) class Init(RunnerCommand): Command = 'init' Help = 'Initialize the test suite' @classmethod def generate_tests(cls, test, test_suite_dir): return [{ "name": test.name, "test": os.path.relpath(os.path.join(test.output_directory, output_file), test_suite_dir), "script": test.test_script, "extension_parameters": test.extension_parameters, "file": test.test_file } for output_file in test.output_files] def _register_options(self, parser): parser.add_argument('--debug', '-d', action='store_true') parser.add_argument('tests', nargs='*') def __call__(self, options): tests = Test.load_tests(options.build_root) if options.debug: sys.stdout.write('Tests:\n') for test in tests: sys.stdout.write('- {}\n'.format(test.name)) if options.tests: test_names = set(options.tests) tests = [t for t in tests if t.name in test_names] unresolved_tests = test_names - {t.name for t in tests} if unresolved_tests: sys.stderr.write( 'The following tests could not be resolved:\n{}\n'.format( '\n'.join(unresolved_tests))) return 1 test_suite_dir = repo_path(options.build_root, get_artifact_dir('test_suite')) make_dir(test_suite_dir) mocha_spec = { 'require': [ repo_path(options.build_root, 'extensions/cxx_debugging/e2e/MochaRootHooks.js'), 'source-map-support/register' ], 'ui': repo_path(options.build_root, get_artifact_dir('devtools-frontend'), 'gen/test/conductor/mocha-interface.js'), 'spec': [ repo_path( options.build_root, 'extensions/cxx_debugging/e2e/StandaloneTestDriver.js'), repo_path(options.build_root, 'extensions/cxx_debugging/e2e/OptionsPageTests.js'), repo_path(options.build_root, 'extensions/cxx_debugging/e2e/TestDriver.js') ], 'slow': 15000, 'timeout': 0 if options.debug else 120000 } with open(repo_path(test_suite_dir, '.mocharc.js'), 'w') as mocharc: mocharc.write('module.exports = {};'.format( json.dumps(mocha_spec, indent=2))) with open(repo_path(test_suite_dir, 'tests.json'), 'w') as tests_file: tests = [Init.generate_tests(t, test_suite_dir) for t in tests] json.dump([test for sublist in tests for test in sublist], tests_file, indent=2) Compile().configure_tests(options.build_root) create_symlink( repo_path(options.build_root, get_artifact_dir('test_suite')), repo_path(options.build_root, get_artifact_dir('devtools-frontend'), 'gen', 'extension_test_suite')) create_symlink( repo_path(options.build_root, get_artifact_dir('cxx_debugging')), repo_path(options.build_root, get_artifact_dir('devtools-frontend'), 'gen', 'cxx_debugging')) class Inspect(Init): Command = 'inspect' Help = 'Interactively run the test programs' class RequestHandlerFactory(object): def __init__(self, build_root): self.build_root = build_root def __call__(self, request, client_address, server): return http.server.SimpleHTTPRequestHandler( request, client_address, server, directory=repo_path(self.build_root, get_artifact_dir('test_suite'))) def _register_options(self, parser): super()._register_options(parser) parser.add_argument('--port', '-p', default=8000) def __call__(self, options): init = super().__call__(options) if init: return init ninja(options.build_root, 'devtools-frontend', options.verbose) ninja(options.build_root, 'cxx_debugging', options.verbose) ninja(options.build_root, 'test_suite', options.verbose) httpd = http.server.HTTPServer( ('127.0.0.1', options.port), Inspect.RequestHandlerFactory(options.build_root)) httpd_thread = threading.Thread(target=httpd.serve_forever, daemon=True) httpd_thread.start() chrome_binaries = { 'linux': '//third_party/chrome/chrome-linux/chrome', 'darwin': '//third_party/chrome/chrome-mac/Chromium.app/Contents/MacOS/Chromium', 'win32': '//third_party/chrome/chrome-win/chrome.exe' } chrome_binary = repo_path(chrome_binaries[sys.platform]) if options.tests: tests = [ t for t in Test.load_tests(options.build_root) if t.name in options.tests ] pages = [ f'http://localhost:{options.port}/{os.path.relpath(test.output_file, test.output_directory)}' for test in tests ] else: pages = [f'http://localhost:{options.port}/'] run_process( chrome_binary, f'--auto-open-devtools-for-tabs', f'--load-extension={repo_path(options.build_root, get_artifact_dir("cxx_debugging"), "src")}', f'--custom-devtools-frontend=file://{repo_path(options.build_root, get_artifact_dir("devtools-frontend"), "gen", "front_end")}', f'--enable-features=WebAssemblySimd', f'--enable-features=SharedArrayBuffer', f'--js-flags=--no-compilation-cache', *pages, verbose=options.verbose) class Run(Init): Command = 'run' Help = 'Run tests' def _register_options(self, parser): super()._register_options(parser) parser.add_argument('--compile', '-C', action='store_true') def __call__(self, options): init = super().__call__(options) if init: return init if options.compile: Compile()(options) else: ninja(options.build_root, 'test_suite', options.verbose) ninja(options.build_root, 'devtools-frontend', options.verbose) ninja(options.build_root, 'cxx_debugging', options.verbose) Compile().build_driver(options.build_root, options.verbose) env = { 'NODE_PATH': ':'.join((repo_path('//node_modules'), repo_path(options.build_root, get_artifact_dir('devtools-frontend'), 'gen'))), } args = ['--'] if options.debug: args.append('--debug') run_process(sys.executable, NODE, '--output', repo_path('//node_modules/mocha/bin/mocha'), '--config', repo_path(options.build_root, get_artifact_dir('test_suite'), '.mocharc.js'), *args, env=env, verbose=options.verbose or options.debug) def runner_main(args): parser = argparse.ArgumentParser() subparsers = parser.add_subparsers(required=True, dest='command') commands = dict([ Init.create(subparsers), Run.create(subparsers), Compile.create(subparsers), Inspect.create(subparsers) ]) options = parser.parse_args(args) command = commands[options.command] return command(options) if __name__ == '__main__': sys.exit(runner_main(sys.argv[1:]))