428 lines
16 KiB
Python
428 lines
16 KiB
Python
|
# -*- coding: utf-8 -*-
|
||
|
|
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||
|
|
# See https://llvm.org/LICENSE.txt for license information.
|
||
|
|
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||
|
|
|
||
|
|
import unittest
|
||
|
|
import re
|
||
|
|
import os
|
||
|
|
import os.path
|
||
|
|
import libear
|
||
|
|
import libscanbuild.analyze as sut
|
||
|
|
|
||
|
|
|
||
|
|
class ReportDirectoryTest(unittest.TestCase):
|
||
|
|
|
||
|
|
# Test that successive report directory names ascend in lexicographic
|
||
|
|
# order. This is required so that report directories from two runs of
|
||
|
|
# scan-build can be easily matched up to compare results.
|
||
|
|
def test_directory_name_comparison(self):
|
||
|
|
with libear.TemporaryDirectory() as tmpdir, sut.report_directory(
|
||
|
|
tmpdir, False, "html"
|
||
|
|
) as report_dir1, sut.report_directory(
|
||
|
|
tmpdir, False, "html"
|
||
|
|
) as report_dir2, sut.report_directory(
|
||
|
|
tmpdir, False, "html"
|
||
|
|
) as report_dir3:
|
||
|
|
self.assertLess(report_dir1, report_dir2)
|
||
|
|
self.assertLess(report_dir2, report_dir3)
|
||
|
|
|
||
|
|
|
||
|
|
class FilteringFlagsTest(unittest.TestCase):
|
||
|
|
def test_language_captured(self):
|
||
|
|
def test(flags):
|
||
|
|
cmd = ["clang", "-c", "source.c"] + flags
|
||
|
|
opts = sut.classify_parameters(cmd)
|
||
|
|
return opts["language"]
|
||
|
|
|
||
|
|
self.assertEqual(None, test([]))
|
||
|
|
self.assertEqual("c", test(["-x", "c"]))
|
||
|
|
self.assertEqual("cpp", test(["-x", "cpp"]))
|
||
|
|
|
||
|
|
def test_arch(self):
|
||
|
|
def test(flags):
|
||
|
|
cmd = ["clang", "-c", "source.c"] + flags
|
||
|
|
opts = sut.classify_parameters(cmd)
|
||
|
|
return opts["arch_list"]
|
||
|
|
|
||
|
|
self.assertEqual([], test([]))
|
||
|
|
self.assertEqual(["mips"], test(["-arch", "mips"]))
|
||
|
|
self.assertEqual(["mips", "i386"], test(["-arch", "mips", "-arch", "i386"]))
|
||
|
|
|
||
|
|
def assertFlagsChanged(self, expected, flags):
|
||
|
|
cmd = ["clang", "-c", "source.c"] + flags
|
||
|
|
opts = sut.classify_parameters(cmd)
|
||
|
|
self.assertEqual(expected, opts["flags"])
|
||
|
|
|
||
|
|
def assertFlagsUnchanged(self, flags):
|
||
|
|
self.assertFlagsChanged(flags, flags)
|
||
|
|
|
||
|
|
def assertFlagsFiltered(self, flags):
|
||
|
|
self.assertFlagsChanged([], flags)
|
||
|
|
|
||
|
|
def test_optimalizations_pass(self):
|
||
|
|
self.assertFlagsUnchanged(["-O"])
|
||
|
|
self.assertFlagsUnchanged(["-O1"])
|
||
|
|
self.assertFlagsUnchanged(["-Os"])
|
||
|
|
self.assertFlagsUnchanged(["-O2"])
|
||
|
|
self.assertFlagsUnchanged(["-O3"])
|
||
|
|
|
||
|
|
def test_include_pass(self):
|
||
|
|
self.assertFlagsUnchanged([])
|
||
|
|
self.assertFlagsUnchanged(["-include", "/usr/local/include"])
|
||
|
|
self.assertFlagsUnchanged(["-I."])
|
||
|
|
self.assertFlagsUnchanged(["-I", "."])
|
||
|
|
self.assertFlagsUnchanged(["-I/usr/local/include"])
|
||
|
|
self.assertFlagsUnchanged(["-I", "/usr/local/include"])
|
||
|
|
self.assertFlagsUnchanged(["-I/opt", "-I", "/opt/otp/include"])
|
||
|
|
self.assertFlagsUnchanged(["-isystem", "/path"])
|
||
|
|
self.assertFlagsUnchanged(["-isystem=/path"])
|
||
|
|
|
||
|
|
def test_define_pass(self):
|
||
|
|
self.assertFlagsUnchanged(["-DNDEBUG"])
|
||
|
|
self.assertFlagsUnchanged(["-UNDEBUG"])
|
||
|
|
self.assertFlagsUnchanged(["-Dvar1=val1", "-Dvar2=val2"])
|
||
|
|
self.assertFlagsUnchanged(['-Dvar="val ues"'])
|
||
|
|
|
||
|
|
def test_output_filtered(self):
|
||
|
|
self.assertFlagsFiltered(["-o", "source.o"])
|
||
|
|
|
||
|
|
def test_some_warning_filtered(self):
|
||
|
|
self.assertFlagsFiltered(["-Wall"])
|
||
|
|
self.assertFlagsFiltered(["-Wnoexcept"])
|
||
|
|
self.assertFlagsFiltered(["-Wreorder", "-Wunused", "-Wundef"])
|
||
|
|
self.assertFlagsUnchanged(["-Wno-reorder", "-Wno-unused"])
|
||
|
|
|
||
|
|
def test_compile_only_flags_pass(self):
|
||
|
|
self.assertFlagsUnchanged(["-std=C99"])
|
||
|
|
self.assertFlagsUnchanged(["-nostdinc"])
|
||
|
|
self.assertFlagsUnchanged(["-isystem", "/image/debian"])
|
||
|
|
self.assertFlagsUnchanged(["-iprefix", "/usr/local"])
|
||
|
|
self.assertFlagsUnchanged(["-iquote=me"])
|
||
|
|
self.assertFlagsUnchanged(["-iquote", "me"])
|
||
|
|
|
||
|
|
def test_compile_and_link_flags_pass(self):
|
||
|
|
self.assertFlagsUnchanged(["-fsinged-char"])
|
||
|
|
self.assertFlagsUnchanged(["-fPIC"])
|
||
|
|
self.assertFlagsUnchanged(["-stdlib=libc++"])
|
||
|
|
self.assertFlagsUnchanged(["--sysroot", "/"])
|
||
|
|
self.assertFlagsUnchanged(["-isysroot", "/"])
|
||
|
|
|
||
|
|
def test_some_flags_filtered(self):
|
||
|
|
self.assertFlagsFiltered(["-g"])
|
||
|
|
self.assertFlagsFiltered(["-fsyntax-only"])
|
||
|
|
self.assertFlagsFiltered(["-save-temps"])
|
||
|
|
self.assertFlagsFiltered(["-init", "my_init"])
|
||
|
|
self.assertFlagsFiltered(["-sectorder", "a", "b", "c"])
|
||
|
|
|
||
|
|
|
||
|
|
class Spy(object):
|
||
|
|
def __init__(self):
|
||
|
|
self.arg = None
|
||
|
|
self.success = 0
|
||
|
|
|
||
|
|
def call(self, params):
|
||
|
|
self.arg = params
|
||
|
|
return self.success
|
||
|
|
|
||
|
|
|
||
|
|
class RunAnalyzerTest(unittest.TestCase):
|
||
|
|
@staticmethod
|
||
|
|
def run_analyzer(content, failures_report, output_format="plist"):
|
||
|
|
with libear.TemporaryDirectory() as tmpdir:
|
||
|
|
filename = os.path.join(tmpdir, "test.cpp")
|
||
|
|
with open(filename, "w") as handle:
|
||
|
|
handle.write(content)
|
||
|
|
|
||
|
|
opts = {
|
||
|
|
"clang": "clang",
|
||
|
|
"directory": os.getcwd(),
|
||
|
|
"flags": [],
|
||
|
|
"direct_args": [],
|
||
|
|
"file": filename,
|
||
|
|
"output_dir": tmpdir,
|
||
|
|
"output_format": output_format,
|
||
|
|
"output_failures": failures_report,
|
||
|
|
}
|
||
|
|
spy = Spy()
|
||
|
|
result = sut.run_analyzer(opts, spy.call)
|
||
|
|
output_files = []
|
||
|
|
for entry in os.listdir(tmpdir):
|
||
|
|
output_files.append(entry)
|
||
|
|
return (result, spy.arg, output_files)
|
||
|
|
|
||
|
|
def test_run_analyzer(self):
|
||
|
|
content = "int div(int n, int d) { return n / d; }"
|
||
|
|
(result, fwds, _) = RunAnalyzerTest.run_analyzer(content, False)
|
||
|
|
self.assertEqual(None, fwds)
|
||
|
|
self.assertEqual(0, result["exit_code"])
|
||
|
|
|
||
|
|
def test_run_analyzer_crash(self):
|
||
|
|
content = "int div(int n, int d) { return n / d }"
|
||
|
|
(result, fwds, _) = RunAnalyzerTest.run_analyzer(content, False)
|
||
|
|
self.assertEqual(None, fwds)
|
||
|
|
self.assertEqual(1, result["exit_code"])
|
||
|
|
|
||
|
|
def test_run_analyzer_crash_and_forwarded(self):
|
||
|
|
content = "int div(int n, int d) { return n / d }"
|
||
|
|
(_, fwds, _) = RunAnalyzerTest.run_analyzer(content, True)
|
||
|
|
self.assertEqual(1, fwds["exit_code"])
|
||
|
|
self.assertTrue(len(fwds["error_output"]) > 0)
|
||
|
|
|
||
|
|
def test_run_analyzer_with_sarif(self):
|
||
|
|
content = "int div(int n, int d) { return n / d; }"
|
||
|
|
(result, fwds, output_files) = RunAnalyzerTest.run_analyzer(
|
||
|
|
content, False, output_format="sarif"
|
||
|
|
)
|
||
|
|
self.assertEqual(None, fwds)
|
||
|
|
self.assertEqual(0, result["exit_code"])
|
||
|
|
|
||
|
|
pattern = re.compile(r"^result-.+\.sarif$")
|
||
|
|
for f in output_files:
|
||
|
|
if re.match(pattern, f):
|
||
|
|
return
|
||
|
|
self.fail("no result sarif files found in output")
|
||
|
|
|
||
|
|
|
||
|
|
class ReportFailureTest(unittest.TestCase):
|
||
|
|
def assertUnderFailures(self, path):
|
||
|
|
self.assertEqual("failures", os.path.basename(os.path.dirname(path)))
|
||
|
|
|
||
|
|
def test_report_failure_create_files(self):
|
||
|
|
with libear.TemporaryDirectory() as tmpdir:
|
||
|
|
# create input file
|
||
|
|
filename = os.path.join(tmpdir, "test.c")
|
||
|
|
with open(filename, "w") as handle:
|
||
|
|
handle.write("int main() { return 0")
|
||
|
|
uname_msg = " ".join(os.uname()) + os.linesep
|
||
|
|
error_msg = "this is my error output"
|
||
|
|
# execute test
|
||
|
|
opts = {
|
||
|
|
"clang": "clang",
|
||
|
|
"directory": os.getcwd(),
|
||
|
|
"flags": [],
|
||
|
|
"file": filename,
|
||
|
|
"output_dir": tmpdir,
|
||
|
|
"language": "c",
|
||
|
|
"error_type": "other_error",
|
||
|
|
"error_output": error_msg,
|
||
|
|
"exit_code": 13,
|
||
|
|
}
|
||
|
|
sut.report_failure(opts)
|
||
|
|
# verify the result
|
||
|
|
result = dict()
|
||
|
|
pp_file = None
|
||
|
|
for root, _, files in os.walk(tmpdir):
|
||
|
|
keys = [os.path.join(root, name) for name in files]
|
||
|
|
for key in keys:
|
||
|
|
with open(key, "r") as handle:
|
||
|
|
result[key] = handle.readlines()
|
||
|
|
if re.match(r"^(.*/)+clang(.*)\.i$", key):
|
||
|
|
pp_file = key
|
||
|
|
|
||
|
|
# prepocessor file generated
|
||
|
|
self.assertUnderFailures(pp_file)
|
||
|
|
# info file generated and content dumped
|
||
|
|
info_file = pp_file + ".info.txt"
|
||
|
|
self.assertTrue(info_file in result)
|
||
|
|
self.assertEqual("Other Error\n", result[info_file][1])
|
||
|
|
self.assertEqual(uname_msg, result[info_file][3])
|
||
|
|
# error file generated and content dumped
|
||
|
|
error_file = pp_file + ".stderr.txt"
|
||
|
|
self.assertTrue(error_file in result)
|
||
|
|
self.assertEqual([error_msg], result[error_file])
|
||
|
|
|
||
|
|
|
||
|
|
class AnalyzerTest(unittest.TestCase):
|
||
|
|
def test_nodebug_macros_appended(self):
|
||
|
|
def test(flags):
|
||
|
|
spy = Spy()
|
||
|
|
opts = {"flags": flags, "force_debug": True}
|
||
|
|
self.assertEqual(spy.success, sut.filter_debug_flags(opts, spy.call))
|
||
|
|
return spy.arg["flags"]
|
||
|
|
|
||
|
|
self.assertEqual(["-UNDEBUG"], test([]))
|
||
|
|
self.assertEqual(["-DNDEBUG", "-UNDEBUG"], test(["-DNDEBUG"]))
|
||
|
|
self.assertEqual(["-DSomething", "-UNDEBUG"], test(["-DSomething"]))
|
||
|
|
|
||
|
|
def test_set_language_fall_through(self):
|
||
|
|
def language(expected, input):
|
||
|
|
spy = Spy()
|
||
|
|
input.update({"compiler": "c", "file": "test.c"})
|
||
|
|
self.assertEqual(spy.success, sut.language_check(input, spy.call))
|
||
|
|
self.assertEqual(expected, spy.arg["language"])
|
||
|
|
|
||
|
|
language("c", {"language": "c", "flags": []})
|
||
|
|
language("c++", {"language": "c++", "flags": []})
|
||
|
|
|
||
|
|
def test_set_language_stops_on_not_supported(self):
|
||
|
|
spy = Spy()
|
||
|
|
input = {"compiler": "c", "flags": [], "file": "test.java", "language": "java"}
|
||
|
|
self.assertIsNone(sut.language_check(input, spy.call))
|
||
|
|
self.assertIsNone(spy.arg)
|
||
|
|
|
||
|
|
def test_set_language_sets_flags(self):
|
||
|
|
def flags(expected, input):
|
||
|
|
spy = Spy()
|
||
|
|
input.update({"compiler": "c", "file": "test.c"})
|
||
|
|
self.assertEqual(spy.success, sut.language_check(input, spy.call))
|
||
|
|
self.assertEqual(expected, spy.arg["flags"])
|
||
|
|
|
||
|
|
flags(["-x", "c"], {"language": "c", "flags": []})
|
||
|
|
flags(["-x", "c++"], {"language": "c++", "flags": []})
|
||
|
|
|
||
|
|
def test_set_language_from_filename(self):
|
||
|
|
def language(expected, input):
|
||
|
|
spy = Spy()
|
||
|
|
input.update({"language": None, "flags": []})
|
||
|
|
self.assertEqual(spy.success, sut.language_check(input, spy.call))
|
||
|
|
self.assertEqual(expected, spy.arg["language"])
|
||
|
|
|
||
|
|
language("c", {"file": "file.c", "compiler": "c"})
|
||
|
|
language("c++", {"file": "file.c", "compiler": "c++"})
|
||
|
|
language("c++", {"file": "file.cxx", "compiler": "c"})
|
||
|
|
language("c++", {"file": "file.cxx", "compiler": "c++"})
|
||
|
|
language("c++", {"file": "file.cpp", "compiler": "c++"})
|
||
|
|
language("c-cpp-output", {"file": "file.i", "compiler": "c"})
|
||
|
|
language("c++-cpp-output", {"file": "file.i", "compiler": "c++"})
|
||
|
|
|
||
|
|
def test_arch_loop_sets_flags(self):
|
||
|
|
def flags(archs):
|
||
|
|
spy = Spy()
|
||
|
|
input = {"flags": [], "arch_list": archs}
|
||
|
|
sut.arch_check(input, spy.call)
|
||
|
|
return spy.arg["flags"]
|
||
|
|
|
||
|
|
self.assertEqual([], flags([]))
|
||
|
|
self.assertEqual(["-arch", "i386"], flags(["i386"]))
|
||
|
|
self.assertEqual(["-arch", "i386"], flags(["i386", "ppc"]))
|
||
|
|
self.assertEqual(["-arch", "sparc"], flags(["i386", "sparc"]))
|
||
|
|
|
||
|
|
def test_arch_loop_stops_on_not_supported(self):
|
||
|
|
def stop(archs):
|
||
|
|
spy = Spy()
|
||
|
|
input = {"flags": [], "arch_list": archs}
|
||
|
|
self.assertIsNone(sut.arch_check(input, spy.call))
|
||
|
|
self.assertIsNone(spy.arg)
|
||
|
|
|
||
|
|
stop(["ppc"])
|
||
|
|
stop(["ppc64"])
|
||
|
|
|
||
|
|
|
||
|
|
@sut.require([])
|
||
|
|
def method_without_expecteds(opts):
|
||
|
|
return 0
|
||
|
|
|
||
|
|
|
||
|
|
@sut.require(["this", "that"])
|
||
|
|
def method_with_expecteds(opts):
|
||
|
|
return 0
|
||
|
|
|
||
|
|
|
||
|
|
@sut.require([])
|
||
|
|
def method_exception_from_inside(opts):
|
||
|
|
raise Exception("here is one")
|
||
|
|
|
||
|
|
|
||
|
|
class RequireDecoratorTest(unittest.TestCase):
|
||
|
|
def test_method_without_expecteds(self):
|
||
|
|
self.assertEqual(method_without_expecteds(dict()), 0)
|
||
|
|
self.assertEqual(method_without_expecteds({}), 0)
|
||
|
|
self.assertEqual(method_without_expecteds({"this": 2}), 0)
|
||
|
|
self.assertEqual(method_without_expecteds({"that": 3}), 0)
|
||
|
|
|
||
|
|
def test_method_with_expecteds(self):
|
||
|
|
self.assertRaises(KeyError, method_with_expecteds, dict())
|
||
|
|
self.assertRaises(KeyError, method_with_expecteds, {})
|
||
|
|
self.assertRaises(KeyError, method_with_expecteds, {"this": 2})
|
||
|
|
self.assertRaises(KeyError, method_with_expecteds, {"that": 3})
|
||
|
|
self.assertEqual(method_with_expecteds({"this": 0, "that": 3}), 0)
|
||
|
|
|
||
|
|
def test_method_exception_not_caught(self):
|
||
|
|
self.assertRaises(Exception, method_exception_from_inside, dict())
|
||
|
|
|
||
|
|
|
||
|
|
class PrefixWithTest(unittest.TestCase):
|
||
|
|
def test_gives_empty_on_empty(self):
|
||
|
|
res = sut.prefix_with(0, [])
|
||
|
|
self.assertFalse(res)
|
||
|
|
|
||
|
|
def test_interleaves_prefix(self):
|
||
|
|
res = sut.prefix_with(0, [1, 2, 3])
|
||
|
|
self.assertListEqual([0, 1, 0, 2, 0, 3], res)
|
||
|
|
|
||
|
|
|
||
|
|
class MergeCtuMapTest(unittest.TestCase):
|
||
|
|
def test_no_map_gives_empty(self):
|
||
|
|
pairs = sut.create_global_ctu_extdef_map([])
|
||
|
|
self.assertFalse(pairs)
|
||
|
|
|
||
|
|
def test_multiple_maps_merged(self):
|
||
|
|
concat_map = [
|
||
|
|
"c:@F@fun1#I# ast/fun1.c.ast",
|
||
|
|
"c:@F@fun2#I# ast/fun2.c.ast",
|
||
|
|
"c:@F@fun3#I# ast/fun3.c.ast",
|
||
|
|
]
|
||
|
|
pairs = sut.create_global_ctu_extdef_map(concat_map)
|
||
|
|
self.assertTrue(("c:@F@fun1#I#", "ast/fun1.c.ast") in pairs)
|
||
|
|
self.assertTrue(("c:@F@fun2#I#", "ast/fun2.c.ast") in pairs)
|
||
|
|
self.assertTrue(("c:@F@fun3#I#", "ast/fun3.c.ast") in pairs)
|
||
|
|
self.assertEqual(3, len(pairs))
|
||
|
|
|
||
|
|
def test_not_unique_func_left_out(self):
|
||
|
|
concat_map = [
|
||
|
|
"c:@F@fun1#I# ast/fun1.c.ast",
|
||
|
|
"c:@F@fun2#I# ast/fun2.c.ast",
|
||
|
|
"c:@F@fun1#I# ast/fun7.c.ast",
|
||
|
|
]
|
||
|
|
pairs = sut.create_global_ctu_extdef_map(concat_map)
|
||
|
|
self.assertFalse(("c:@F@fun1#I#", "ast/fun1.c.ast") in pairs)
|
||
|
|
self.assertFalse(("c:@F@fun1#I#", "ast/fun7.c.ast") in pairs)
|
||
|
|
self.assertTrue(("c:@F@fun2#I#", "ast/fun2.c.ast") in pairs)
|
||
|
|
self.assertEqual(1, len(pairs))
|
||
|
|
|
||
|
|
def test_duplicates_are_kept(self):
|
||
|
|
concat_map = [
|
||
|
|
"c:@F@fun1#I# ast/fun1.c.ast",
|
||
|
|
"c:@F@fun2#I# ast/fun2.c.ast",
|
||
|
|
"c:@F@fun1#I# ast/fun1.c.ast",
|
||
|
|
]
|
||
|
|
pairs = sut.create_global_ctu_extdef_map(concat_map)
|
||
|
|
self.assertTrue(("c:@F@fun1#I#", "ast/fun1.c.ast") in pairs)
|
||
|
|
self.assertTrue(("c:@F@fun2#I#", "ast/fun2.c.ast") in pairs)
|
||
|
|
self.assertEqual(2, len(pairs))
|
||
|
|
|
||
|
|
def test_space_handled_in_source(self):
|
||
|
|
concat_map = ["c:@F@fun1#I# ast/f un.c.ast"]
|
||
|
|
pairs = sut.create_global_ctu_extdef_map(concat_map)
|
||
|
|
self.assertTrue(("c:@F@fun1#I#", "ast/f un.c.ast") in pairs)
|
||
|
|
self.assertEqual(1, len(pairs))
|
||
|
|
|
||
|
|
|
||
|
|
class ExtdefMapSrcToAstTest(unittest.TestCase):
|
||
|
|
def test_empty_gives_empty(self):
|
||
|
|
fun_ast_lst = sut.extdef_map_list_src_to_ast([])
|
||
|
|
self.assertFalse(fun_ast_lst)
|
||
|
|
|
||
|
|
def test_sources_to_asts(self):
|
||
|
|
fun_src_lst = [
|
||
|
|
"c:@F@f1#I# " + os.path.join(os.sep + "path", "f1.c"),
|
||
|
|
"c:@F@f2#I# " + os.path.join(os.sep + "path", "f2.c"),
|
||
|
|
]
|
||
|
|
fun_ast_lst = sut.extdef_map_list_src_to_ast(fun_src_lst)
|
||
|
|
self.assertTrue(
|
||
|
|
"c:@F@f1#I# " + os.path.join("ast", "path", "f1.c.ast") in fun_ast_lst
|
||
|
|
)
|
||
|
|
self.assertTrue(
|
||
|
|
"c:@F@f2#I# " + os.path.join("ast", "path", "f2.c.ast") in fun_ast_lst
|
||
|
|
)
|
||
|
|
self.assertEqual(2, len(fun_ast_lst))
|
||
|
|
|
||
|
|
def test_spaces_handled(self):
|
||
|
|
fun_src_lst = ["c:@F@f1#I# " + os.path.join(os.sep + "path", "f 1.c")]
|
||
|
|
fun_ast_lst = sut.extdef_map_list_src_to_ast(fun_src_lst)
|
||
|
|
self.assertTrue(
|
||
|
|
"c:@F@f1#I# " + os.path.join("ast", "path", "f 1.c.ast") in fun_ast_lst
|
||
|
|
)
|
||
|
|
self.assertEqual(1, len(fun_ast_lst))
|