| #!/usr/bin/env python3 |
| # |
| #===- gen_tests.py - clang-doc test generator ----------------*- python -*--===# |
| # |
| # The LLVM Compiler Infrastructure |
| # |
| # This file is distributed under the University of Illinois Open Source |
| # License. See LICENSE.TXT for details. |
| # |
| #===------------------------------------------------------------------------===# |
| """ |
| clang-doc test generator |
| ========================== |
| |
| Generates tests for clang-doc given a certain set of flags, a prefix for the |
| test file, and a given clang-doc binary. Please check emitted tests for |
| accuracy before using. |
| |
| To generate all current tests: |
| - Generate mapper tests: |
| gen_tests.py -flag='--dump-mapper' -flag='--doxygen' -prefix mapper |
| |
| - Generate reducer tests: |
| gen_tests.py -flag='--dump-intermediate' -flag='--doxygen' -prefix bc |
| |
| - Generate yaml tests: |
| gen_tests.py -flag='--format=yaml' -flag='--doxygen' -prefix yaml |
| |
| This script was written on/for Linux, and has not been tested on any other |
| platform and so it may not work. |
| |
| """ |
| |
| import argparse |
| import glob |
| import os |
| import shutil |
| import subprocess |
| |
| RUN_CLANG_DOC = """ |
| // RUN: clang-doc {0} -p %t %t/test.cpp -output=%t/docs |
| """ |
| RUN = """ |
| // RUN: {0} %t/{1} | FileCheck %s --check-prefix CHECK-{2} |
| """ |
| |
| CHECK = '// CHECK-{0}: ' |
| |
| CHECK_NEXT = '// CHECK-{0}-NEXT: ' |
| |
| |
| def clear_test_prefix_files(prefix, tests_path): |
| if os.path.isdir(tests_path): |
| for root, dirs, files in os.walk(tests_path): |
| for filename in files: |
| if filename.startswith(prefix): |
| os.remove(os.path.join(root, filename)) |
| |
| |
| def copy_to_test_file(test_case_path, test_cases_path): |
| # Copy file to 'test.cpp' to preserve file-dependent USRs |
| test_file = os.path.join(test_cases_path, 'test.cpp') |
| shutil.copyfile(test_case_path, test_file) |
| return test_file |
| |
| |
| def run_clang_doc(args, out_dir, test_file): |
| # Run clang-doc. |
| current_cmd = [args.clangdoc] |
| current_cmd.extend(args.flags) |
| current_cmd.append('--output=' + out_dir) |
| current_cmd.append(test_file) |
| print('Running ' + ' '.join(current_cmd)) |
| return_code = subprocess.call(current_cmd) |
| if return_code: |
| return 1 |
| return 0 |
| |
| |
| def get_test_case_code(test_case_path, flags): |
| # Get the test case code |
| code = '' |
| with open(test_case_path, 'r') as code_file: |
| code = code_file.read() |
| |
| code += RUN_CLANG_DOC.format(flags) |
| return code |
| |
| |
| def get_output(root, out_file, case_out_path, flags, checkname, bcanalyzer): |
| output = '' |
| run_cmd = '' |
| if '--dump-mapper' in flags or '--dump-intermediate' in flags: |
| # Run llvm-bcanalyzer |
| output = subprocess.check_output( |
| [bcanalyzer, '--dump', |
| os.path.join(root, out_file)]) |
| output = output[:output.find('Summary of ')].rstrip() |
| run_cmd = RUN.format('llvm-bcanalyzer --dump', |
| os.path.join('docs', 'bc', out_file), checkname) |
| else: |
| # Run cat |
| output = subprocess.check_output(['cat', os.path.join(root, out_file)]) |
| run_cmd = RUN.format( |
| 'cat', |
| os.path.join('docs', os.path.relpath(root, case_out_path), |
| out_file), checkname) |
| |
| # Format output. |
| output = output.replace('blob data = \'test\'', 'blob data = \'{{.*}}\'') |
| output = CHECK.format(checkname) + output.rstrip() |
| output = run_cmd + output.replace('\n', |
| '\n' + CHECK_NEXT.format(checkname)) |
| |
| return output + '\n' |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser(description='Generate clang-doc tests.') |
| parser.add_argument( |
| '-flag', |
| action='append', |
| default=[], |
| dest='flags', |
| help='Flags to pass to clang-doc.') |
| parser.add_argument( |
| '-prefix', |
| type=str, |
| default='', |
| dest='prefix', |
| help='Prefix for this test group.') |
| parser.add_argument( |
| '-clang-doc-binary', |
| dest='clangdoc', |
| metavar="PATH", |
| default='clang-doc', |
| help='path to clang-doc binary') |
| parser.add_argument( |
| '-llvm-bcanalyzer-binary', |
| dest='bcanalyzer', |
| metavar="PATH", |
| default='llvm-bcanalyzer', |
| help='path to llvm-bcanalyzer binary') |
| args = parser.parse_args() |
| |
| flags = ' '.join(args.flags) |
| |
| clang_doc_path = os.path.dirname(__file__) |
| tests_path = os.path.join(clang_doc_path, '..', 'test', 'clang-doc') |
| test_cases_path = os.path.join(tests_path, 'test_cases') |
| |
| clear_test_prefix_files(args.prefix, tests_path) |
| |
| for test_case_path in glob.glob(os.path.join(test_cases_path, '*')): |
| if test_case_path.endswith( |
| 'compile_flags.txt') or test_case_path.endswith( |
| 'compile_commands.json'): |
| continue |
| |
| # Name of this test case |
| case_name = os.path.basename(test_case_path).split('.')[0] |
| |
| test_file = copy_to_test_file(test_case_path, test_cases_path) |
| out_dir = os.path.join(test_cases_path, case_name) |
| |
| if run_clang_doc(args, out_dir, test_file): |
| return 1 |
| |
| # Retrieve output and format as FileCheck tests |
| all_output = '' |
| num_outputs = 0 |
| for root, dirs, files in os.walk(out_dir): |
| for out_file in files: |
| # Make the file check the first 3 letters (there's a very small chance |
| # that this will collide, but the fix is to simply change the decl name) |
| usr = os.path.basename(out_file).split('.') |
| # If the usr is less than 2, this isn't one of the test files. |
| if len(usr) < 2: |
| continue |
| all_output += get_output(root, out_file, out_dir, args.flags, |
| num_outputs, args.bcanalyzer) |
| num_outputs += 1 |
| |
| # Add test case code to test |
| all_output = get_test_case_code(test_case_path, |
| flags) + '\n' + all_output |
| |
| # Write to test case file in /test. |
| test_out_path = os.path.join( |
| tests_path, args.prefix + '-' + os.path.basename(test_case_path)) |
| with open(test_out_path, 'w+') as o: |
| o.write(all_output) |
| |
| # Clean up |
| shutil.rmtree(out_dir) |
| os.remove(test_file) |
| |
| |
| if __name__ == '__main__': |
| main() |
