Imported Upstream version 6.10.0.49

Former-commit-id: 1d6753294b2993e1fbf92de9366bb9544db4189b

external/llvm-project/clang/tools/scan-build-py/tests/functional/cases/__init__.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+
+import re
+import os.path
+import subprocess
+
+
+def load_tests(loader, suite, pattern):
+    from . import test_from_cdb
+    suite.addTests(loader.loadTestsFromModule(test_from_cdb))
+    from . import test_from_cmd
+    suite.addTests(loader.loadTestsFromModule(test_from_cmd))
+    from . import test_create_cdb
+    suite.addTests(loader.loadTestsFromModule(test_create_cdb))
+    from . import test_exec_anatomy
+    suite.addTests(loader.loadTestsFromModule(test_exec_anatomy))
+    return suite
+
+
+def make_args(target):
+    this_dir, _ = os.path.split(__file__)
+    path = os.path.normpath(os.path.join(this_dir, '..', 'src'))
+    return ['make', 'SRCDIR={}'.format(path), 'OBJDIR={}'.format(target), '-f',
+            os.path.join(path, 'build', 'Makefile')]
+
+
+def silent_call(cmd, *args, **kwargs):
+    kwargs.update({'stdout': subprocess.PIPE, 'stderr': subprocess.STDOUT})
+    return subprocess.call(cmd, *args, **kwargs)
+
+
+def silent_check_call(cmd, *args, **kwargs):
+    kwargs.update({'stdout': subprocess.PIPE, 'stderr': subprocess.STDOUT})
+    return subprocess.check_call(cmd, *args, **kwargs)
+
+
+def call_and_report(analyzer_cmd, build_cmd):
+    child = subprocess.Popen(analyzer_cmd + ['-v'] + build_cmd,
+                             universal_newlines=True,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.STDOUT)
+
+    pattern = re.compile('Report directory created: (.+)')
+    directory = None
+    for line in child.stdout.readlines():
+        match = pattern.search(line)
+        if match and match.lastindex == 1:
+            directory = match.group(1)
+            break
+    child.stdout.close()
+    child.wait()
+
+    return (child.returncode, directory)
+
+
+def check_call_and_report(analyzer_cmd, build_cmd):
+    exit_code, result = call_and_report(analyzer_cmd, build_cmd)
+    if exit_code != 0:
+        raise subprocess.CalledProcessError(
+            exit_code, analyzer_cmd + build_cmd, None)
+    else:
+        return result
+
+
+def create_empty_file(filename):
+    with open(filename, 'a') as handle:
+        pass

external/llvm-project/clang/tools/scan-build-py/tests/functional/cases/test_create_cdb.py

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+
+import libear
+from . import make_args, silent_check_call, silent_call, create_empty_file
+import unittest
+
+import os.path
+import json
+
+
+class CompilationDatabaseTest(unittest.TestCase):
+    @staticmethod
+    def run_intercept(tmpdir, args):
+        result = os.path.join(tmpdir, 'cdb.json')
+        make = make_args(tmpdir) + args
+        silent_check_call(
+            ['intercept-build', '--cdb', result] + make)
+        return result
+
+    @staticmethod
+    def count_entries(filename):
+        with open(filename, 'r') as handler:
+            content = json.load(handler)
+            return len(content)
+
+    def test_successful_build(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            result = self.run_intercept(tmpdir, ['build_regular'])
+            self.assertTrue(os.path.isfile(result))
+            self.assertEqual(5, self.count_entries(result))
+
+    def test_successful_build_with_wrapper(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            result = os.path.join(tmpdir, 'cdb.json')
+            make = make_args(tmpdir) + ['build_regular']
+            silent_check_call(['intercept-build', '--cdb', result,
+                               '--override-compiler'] + make)
+            self.assertTrue(os.path.isfile(result))
+            self.assertEqual(5, self.count_entries(result))
+
+    @unittest.skipIf(os.getenv('TRAVIS'), 'ubuntu make return -11')
+    def test_successful_build_parallel(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            result = self.run_intercept(tmpdir, ['-j', '4', 'build_regular'])
+            self.assertTrue(os.path.isfile(result))
+            self.assertEqual(5, self.count_entries(result))
+
+    @unittest.skipIf(os.getenv('TRAVIS'), 'ubuntu env remove clang from path')
+    def test_successful_build_on_empty_env(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            result = os.path.join(tmpdir, 'cdb.json')
+            make = make_args(tmpdir) + ['CC=clang', 'build_regular']
+            silent_check_call(['intercept-build', '--cdb', result,
+                               'env', '-'] + make)
+            self.assertTrue(os.path.isfile(result))
+            self.assertEqual(5, self.count_entries(result))
+
+    def test_successful_build_all_in_one(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            result = self.run_intercept(tmpdir, ['build_all_in_one'])
+            self.assertTrue(os.path.isfile(result))
+            self.assertEqual(5, self.count_entries(result))
+
+    def test_not_successful_build(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            result = os.path.join(tmpdir, 'cdb.json')
+            make = make_args(tmpdir) + ['build_broken']
+            silent_call(
+                ['intercept-build', '--cdb', result] + make)
+            self.assertTrue(os.path.isfile(result))
+            self.assertEqual(2, self.count_entries(result))
+
+
+class ExitCodeTest(unittest.TestCase):
+    @staticmethod
+    def run_intercept(tmpdir, target):
+        result = os.path.join(tmpdir, 'cdb.json')
+        make = make_args(tmpdir) + [target]
+        return silent_call(
+            ['intercept-build', '--cdb', result] + make)
+
+    def test_successful_build(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            exitcode = self.run_intercept(tmpdir, 'build_clean')
+            self.assertFalse(exitcode)
+
+    def test_not_successful_build(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            exitcode = self.run_intercept(tmpdir, 'build_broken')
+            self.assertTrue(exitcode)
+
+
+class ResumeFeatureTest(unittest.TestCase):
+    @staticmethod
+    def run_intercept(tmpdir, target, args):
+        result = os.path.join(tmpdir, 'cdb.json')
+        make = make_args(tmpdir) + [target]
+        silent_check_call(
+            ['intercept-build', '--cdb', result] + args + make)
+        return result
+
+    @staticmethod
+    def count_entries(filename):
+        with open(filename, 'r') as handler:
+            content = json.load(handler)
+            return len(content)
+
+    def test_overwrite_existing_cdb(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            result = self.run_intercept(tmpdir, 'build_clean', [])
+            self.assertTrue(os.path.isfile(result))
+            result = self.run_intercept(tmpdir, 'build_regular', [])
+            self.assertTrue(os.path.isfile(result))
+            self.assertEqual(2, self.count_entries(result))
+
+    def test_append_to_existing_cdb(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            result = self.run_intercept(tmpdir, 'build_clean', [])
+            self.assertTrue(os.path.isfile(result))
+            result = self.run_intercept(tmpdir, 'build_regular', ['--append'])
+            self.assertTrue(os.path.isfile(result))
+            self.assertEqual(5, self.count_entries(result))
+
+
+class ResultFormatingTest(unittest.TestCase):
+    @staticmethod
+    def run_intercept(tmpdir, command):
+        result = os.path.join(tmpdir, 'cdb.json')
+        silent_check_call(
+            ['intercept-build', '--cdb', result] + command,
+            cwd=tmpdir)
+        with open(result, 'r') as handler:
+            content = json.load(handler)
+            return content
+
+    def assert_creates_number_of_entries(self, command, count):
+        with libear.TemporaryDirectory() as tmpdir:
+            filename = os.path.join(tmpdir, 'test.c')
+            create_empty_file(filename)
+            command.append(filename)
+            cmd = ['sh', '-c', ' '.join(command)]
+            cdb = self.run_intercept(tmpdir, cmd)
+            self.assertEqual(count, len(cdb))
+
+    def test_filter_preprocessor_only_calls(self):
+        self.assert_creates_number_of_entries(['cc', '-c'], 1)
+        self.assert_creates_number_of_entries(['cc', '-c', '-E'], 0)
+        self.assert_creates_number_of_entries(['cc', '-c', '-M'], 0)
+        self.assert_creates_number_of_entries(['cc', '-c', '-MM'], 0)
+
+    def assert_command_creates_entry(self, command, expected):
+        with libear.TemporaryDirectory() as tmpdir:
+            filename = os.path.join(tmpdir, command[-1])
+            create_empty_file(filename)
+            cmd = ['sh', '-c', ' '.join(command)]
+            cdb = self.run_intercept(tmpdir, cmd)
+            self.assertEqual(' '.join(expected), cdb[0]['command'])
+
+    def test_filter_preprocessor_flags(self):
+        self.assert_command_creates_entry(
+            ['cc', '-c', '-MD', 'test.c'],
+            ['cc', '-c', 'test.c'])
+        self.assert_command_creates_entry(
+            ['cc', '-c', '-MMD', 'test.c'],
+            ['cc', '-c', 'test.c'])
+        self.assert_command_creates_entry(
+            ['cc', '-c', '-MD', '-MF', 'test.d', 'test.c'],
+            ['cc', '-c', 'test.c'])
+
+    def test_pass_language_flag(self):
+        self.assert_command_creates_entry(
+            ['cc', '-c', '-x', 'c', 'test.c'],
+            ['cc', '-c', '-x', 'c', 'test.c'])
+        self.assert_command_creates_entry(
+            ['cc', '-c', 'test.c'],
+            ['cc', '-c', 'test.c'])
+
+    def test_pass_arch_flags(self):
+        self.assert_command_creates_entry(
+            ['clang', '-c', 'test.c'],
+            ['cc', '-c', 'test.c'])
+        self.assert_command_creates_entry(
+            ['clang', '-c', '-arch', 'i386', 'test.c'],
+            ['cc', '-c', '-arch', 'i386', 'test.c'])
+        self.assert_command_creates_entry(
+            ['clang', '-c', '-arch', 'i386', '-arch', 'armv7l', 'test.c'],
+            ['cc', '-c', '-arch', 'i386', '-arch', 'armv7l', 'test.c'])

external/llvm-project/clang/tools/scan-build-py/tests/functional/cases/test_exec_anatomy.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+
+import libear
+import unittest
+
+import os.path
+import subprocess
+import json
+
+
+def run(source_dir, target_dir):
+    def execute(cmd):
+        return subprocess.check_call(cmd,
+                                     cwd=target_dir,
+                                     stdout=subprocess.PIPE,
+                                     stderr=subprocess.STDOUT)
+
+    execute(['cmake', source_dir])
+    execute(['make'])
+
+    result_file = os.path.join(target_dir, 'result.json')
+    expected_file = os.path.join(target_dir, 'expected.json')
+    execute(['intercept-build', '--cdb', result_file, './exec',
+             expected_file])
+    return (expected_file, result_file)
+
+
+class ExecAnatomyTest(unittest.TestCase):
+    def assertEqualJson(self, expected, result):
+        def read_json(filename):
+            with open(filename) as handler:
+                return json.load(handler)
+
+        lhs = read_json(expected)
+        rhs = read_json(result)
+        for item in lhs:
+            self.assertTrue(rhs.count(item))
+        for item in rhs:
+            self.assertTrue(lhs.count(item))
+
+    def test_all_exec_calls(self):
+        this_dir, _ = os.path.split(__file__)
+        source_dir = os.path.normpath(os.path.join(this_dir, '..', 'exec'))
+        with libear.TemporaryDirectory() as tmp_dir:
+            expected, result = run(source_dir, tmp_dir)
+            self.assertEqualJson(expected, result)

external/llvm-project/clang/tools/scan-build-py/tests/functional/cases/test_from_cdb.py

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+
+import libear
+from . import call_and_report
+import unittest
+
+import os.path
+import string
+import glob
+
+
+def prepare_cdb(name, target_dir):
+    target_file = 'build_{0}.json'.format(name)
+    this_dir, _ = os.path.split(__file__)
+    path = os.path.normpath(os.path.join(this_dir, '..', 'src'))
+    source_dir = os.path.join(path, 'compilation_database')
+    source_file = os.path.join(source_dir, target_file + '.in')
+    target_file = os.path.join(target_dir, 'compile_commands.json')
+    with open(source_file, 'r') as in_handle:
+        with open(target_file, 'w') as out_handle:
+            for line in in_handle:
+                temp = string.Template(line)
+                out_handle.write(temp.substitute(path=path))
+    return target_file
+
+
+def run_analyzer(directory, cdb, args):
+    cmd = ['analyze-build', '--cdb', cdb, '--output', directory] \
+        + args
+    return call_and_report(cmd, [])
+
+
+class OutputDirectoryTest(unittest.TestCase):
+    def test_regular_keeps_report_dir(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('regular', tmpdir)
+            exit_code, reportdir = run_analyzer(tmpdir, cdb, [])
+            self.assertTrue(os.path.isdir(reportdir))
+
+    def test_clear_deletes_report_dir(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('clean', tmpdir)
+            exit_code, reportdir = run_analyzer(tmpdir, cdb, [])
+            self.assertFalse(os.path.isdir(reportdir))
+
+    def test_clear_keeps_report_dir_when_asked(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('clean', tmpdir)
+            exit_code, reportdir = run_analyzer(tmpdir, cdb, ['--keep-empty'])
+            self.assertTrue(os.path.isdir(reportdir))
+
+
+class ExitCodeTest(unittest.TestCase):
+    def test_regular_does_not_set_exit_code(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('regular', tmpdir)
+            exit_code, __ = run_analyzer(tmpdir, cdb, [])
+            self.assertFalse(exit_code)
+
+    def test_clear_does_not_set_exit_code(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('clean', tmpdir)
+            exit_code, __ = run_analyzer(tmpdir, cdb, [])
+            self.assertFalse(exit_code)
+
+    def test_regular_sets_exit_code_if_asked(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('regular', tmpdir)
+            exit_code, __ = run_analyzer(tmpdir, cdb, ['--status-bugs'])
+            self.assertTrue(exit_code)
+
+    def test_clear_does_not_set_exit_code_if_asked(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('clean', tmpdir)
+            exit_code, __ = run_analyzer(tmpdir, cdb, ['--status-bugs'])
+            self.assertFalse(exit_code)
+
+    def test_regular_sets_exit_code_if_asked_from_plist(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('regular', tmpdir)
+            exit_code, __ = run_analyzer(
+                tmpdir, cdb, ['--status-bugs', '--plist'])
+            self.assertTrue(exit_code)
+
+    def test_clear_does_not_set_exit_code_if_asked_from_plist(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('clean', tmpdir)
+            exit_code, __ = run_analyzer(
+                tmpdir, cdb, ['--status-bugs', '--plist'])
+            self.assertFalse(exit_code)
+
+
+class OutputFormatTest(unittest.TestCase):
+    @staticmethod
+    def get_html_count(directory):
+        return len(glob.glob(os.path.join(directory, 'report-*.html')))
+
+    @staticmethod
+    def get_plist_count(directory):
+        return len(glob.glob(os.path.join(directory, 'report-*.plist')))
+
+    def test_default_creates_html_report(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('regular', tmpdir)
+            exit_code, reportdir = run_analyzer(tmpdir, cdb, [])
+            self.assertTrue(
+                os.path.exists(os.path.join(reportdir, 'index.html')))
+            self.assertEqual(self.get_html_count(reportdir), 2)
+            self.assertEqual(self.get_plist_count(reportdir), 0)
+
+    def test_plist_and_html_creates_html_report(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('regular', tmpdir)
+            exit_code, reportdir = run_analyzer(tmpdir, cdb, ['--plist-html'])
+            self.assertTrue(
+                os.path.exists(os.path.join(reportdir, 'index.html')))
+            self.assertEqual(self.get_html_count(reportdir), 2)
+            self.assertEqual(self.get_plist_count(reportdir), 5)
+
+    def test_plist_does_not_creates_html_report(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('regular', tmpdir)
+            exit_code, reportdir = run_analyzer(tmpdir, cdb, ['--plist'])
+            self.assertFalse(
+                os.path.exists(os.path.join(reportdir, 'index.html')))
+            self.assertEqual(self.get_html_count(reportdir), 0)
+            self.assertEqual(self.get_plist_count(reportdir), 5)
+
+
+class FailureReportTest(unittest.TestCase):
+    def test_broken_creates_failure_reports(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('broken', tmpdir)
+            exit_code, reportdir = run_analyzer(tmpdir, cdb, [])
+            self.assertTrue(
+                os.path.isdir(os.path.join(reportdir, 'failures')))
+
+    def test_broken_does_not_creates_failure_reports(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('broken', tmpdir)
+            exit_code, reportdir = run_analyzer(
+                tmpdir, cdb, ['--no-failure-reports'])
+            self.assertFalse(
+                os.path.isdir(os.path.join(reportdir, 'failures')))
+
+
+class TitleTest(unittest.TestCase):
+    def assertTitleEqual(self, directory, expected):
+        import re
+        patterns = [
+            re.compile(r'<title>(?P<page>.*)</title>'),
+            re.compile(r'<h1>(?P<head>.*)</h1>')
+        ]
+        result = dict()
+
+        index = os.path.join(directory, 'index.html')
+        with open(index, 'r') as handler:
+            for line in handler.readlines():
+                for regex in patterns:
+                    match = regex.match(line.strip())
+                    if match:
+                        result.update(match.groupdict())
+                        break
+        self.assertEqual(result['page'], result['head'])
+        self.assertEqual(result['page'], expected)
+
+    def test_default_title_in_report(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('broken', tmpdir)
+            exit_code, reportdir = run_analyzer(tmpdir, cdb, [])
+            self.assertTitleEqual(reportdir, 'src - analyzer results')
+
+    def test_given_title_in_report(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            cdb = prepare_cdb('broken', tmpdir)
+            exit_code, reportdir = run_analyzer(
+                tmpdir, cdb, ['--html-title', 'this is the title'])
+            self.assertTitleEqual(reportdir, 'this is the title')

external/llvm-project/clang/tools/scan-build-py/tests/functional/cases/test_from_cmd.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+
+import libear
+from . import make_args, check_call_and_report, create_empty_file
+import unittest
+
+import os
+import os.path
+import glob
+
+
+class OutputDirectoryTest(unittest.TestCase):
+
+    @staticmethod
+    def run_analyzer(outdir, args, cmd):
+        return check_call_and_report(
+            ['scan-build', '--intercept-first', '-o', outdir] + args,
+            cmd)
+
+    def test_regular_keeps_report_dir(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            make = make_args(tmpdir) + ['build_regular']
+            outdir = self.run_analyzer(tmpdir, [], make)
+            self.assertTrue(os.path.isdir(outdir))
+
+    def test_clear_deletes_report_dir(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            make = make_args(tmpdir) + ['build_clean']
+            outdir = self.run_analyzer(tmpdir, [], make)
+            self.assertFalse(os.path.isdir(outdir))
+
+    def test_clear_keeps_report_dir_when_asked(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            make = make_args(tmpdir) + ['build_clean']
+            outdir = self.run_analyzer(tmpdir, ['--keep-empty'], make)
+            self.assertTrue(os.path.isdir(outdir))
+
+
+class RunAnalyzerTest(unittest.TestCase):
+
+    @staticmethod
+    def get_plist_count(directory):
+        return len(glob.glob(os.path.join(directory, 'report-*.plist')))
+
+    def test_interposition_works(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            make = make_args(tmpdir) + ['build_regular']
+            outdir = check_call_and_report(
+                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler'],
+                make)
+
+            self.assertTrue(os.path.isdir(outdir))
+            self.assertEqual(self.get_plist_count(outdir), 5)
+
+    def test_intercept_wrapper_works(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            make = make_args(tmpdir) + ['build_regular']
+            outdir = check_call_and_report(
+                ['scan-build', '--plist', '-o', tmpdir, '--intercept-first',
+                 '--override-compiler'],
+                make)
+
+            self.assertTrue(os.path.isdir(outdir))
+            self.assertEqual(self.get_plist_count(outdir), 5)
+
+    def test_intercept_library_works(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            make = make_args(tmpdir) + ['build_regular']
+            outdir = check_call_and_report(
+                ['scan-build', '--plist', '-o', tmpdir, '--intercept-first'],
+                make)
+
+            self.assertTrue(os.path.isdir(outdir))
+            self.assertEqual(self.get_plist_count(outdir), 5)
+
+    @staticmethod
+    def compile_empty_source_file(target_dir, is_cxx):
+        compiler = '$CXX' if is_cxx else '$CC'
+        src_file_name = 'test.cxx' if is_cxx else 'test.c'
+        src_file = os.path.join(target_dir, src_file_name)
+        obj_file = os.path.join(target_dir, 'test.o')
+        create_empty_file(src_file)
+        command = ' '.join([compiler, '-c', src_file, '-o', obj_file])
+        return ['sh', '-c', command]
+
+    def test_interposition_cc_works(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            outdir = check_call_and_report(
+                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler'],
+                self.compile_empty_source_file(tmpdir, False))
+            self.assertEqual(self.get_plist_count(outdir), 1)
+
+    def test_interposition_cxx_works(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            outdir = check_call_and_report(
+                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler'],
+                self.compile_empty_source_file(tmpdir, True))
+            self.assertEqual(self.get_plist_count(outdir), 1)
+
+    def test_intercept_cc_works(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            outdir = check_call_and_report(
+                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler',
+                 '--intercept-first'],
+                self.compile_empty_source_file(tmpdir, False))
+            self.assertEqual(self.get_plist_count(outdir), 1)
+
+    def test_intercept_cxx_works(self):
+        with libear.TemporaryDirectory() as tmpdir:
+            outdir = check_call_and_report(
+                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler',
+                 '--intercept-first'],
+                self.compile_empty_source_file(tmpdir, True))
+            self.assertEqual(self.get_plist_count(outdir), 1)