from check_index import * import json import sys import os def read_codemodel_json_data(filename): abs_filename = os.path.join(os.path.dirname(os.path.realpath(__file__)), "codemodel-v2-data", filename) with open(abs_filename, "r") as f: return json.load(f) def check_objects(o, g): assert is_list(o) assert len(o) == 1 major = 2 minor = 9 check_index_object(o[0], "codemodel", major, minor, check_object_codemodel(g, major, minor)) def check_backtrace(t, b, backtrace): btg = t["backtraceGraph"] for expected in backtrace: assert is_int(b) node = btg["nodes"][b] expected_keys = ["file"] assert matches(btg["files"][node["file"]], expected["file"]) if expected["line"] is not None: expected_keys.append("line") assert is_int(node["line"], expected["line"]), repr(node["line"]) + " != " + repr(expected["line"]) if expected["command"] is not None: expected_keys.append("command") assert is_int(node["command"]) assert is_string(btg["commands"][node["command"]], expected["command"]) if expected["hasParent"]: expected_keys.append("parent") assert is_int(node["parent"]) b = node["parent"] else: b = None assert sorted(node.keys()) == sorted(expected_keys) assert b is None def check_backtraces(t, actual, expected): assert is_list(actual) assert is_list(expected) assert len(actual) == len(expected) i = 0 while i < len(actual): check_backtrace(t, actual[i], expected[i]) i += 1 def check_directory(c, major, minor): def _check(actual, expected): assert is_dict(actual) expected_keys = ["build", "jsonFile", "source", "projectIndex"] assert matches(actual["build"], expected["build"]) assert is_int(actual["projectIndex"]) assert is_string(c["projects"][actual["projectIndex"]]["name"], expected["projectName"]) if expected["parentSource"] is not None: expected_keys.append("parentIndex") assert is_int(actual["parentIndex"]) assert matches(c["directories"][actual["parentIndex"]]["source"], expected["parentSource"]) if expected["childSources"] is not None: expected_keys.append("childIndexes") check_list_match(lambda a, e: matches(c["directories"][a]["source"], e), actual["childIndexes"], expected["childSources"], missing_exception=lambda e: "Child source: %s" % e, extra_exception=lambda a: "Child source: %s" % a["source"]) if expected["targetIds"] is not None: expected_keys.append("targetIndexes") check_list_match(lambda a, e: matches(c["targets"][a]["id"], e), actual["targetIndexes"], expected["targetIds"], missing_exception=lambda e: "Target ID: %s" % e, extra_exception=lambda a: "Target ID: %s" % c["targets"][a]["id"]) if expected["abstractTargetIds"] is not None: expected_keys.append("abstractTargetIndexes") check_list_match(lambda a, e: matches(c["abstractTargets"][a]["id"], e), actual["abstractTargetIndexes"], expected["abstractTargetIds"], missing_exception=lambda e: "Abstract target ID: %s" % e, extra_exception=lambda a: "Abstract target ID: %s" % c["abstractTargets"][a]["id"]) if expected["minimumCMakeVersion"] is not None: expected_keys.append("minimumCMakeVersion") assert is_dict(actual["minimumCMakeVersion"]) assert sorted(actual["minimumCMakeVersion"].keys()) == ["string"] assert is_string(actual["minimumCMakeVersion"]["string"], expected["minimumCMakeVersion"]) if expected["hasInstallRule"] is not None: expected_keys.append("hasInstallRule") assert is_bool(actual["hasInstallRule"], expected["hasInstallRule"]) assert sorted(actual.keys()) == sorted(expected_keys) assert is_string(actual["jsonFile"]) filepath = os.path.join(reply_dir, actual["jsonFile"]) maximum_filename_length = 140 assert len(actual["jsonFile"]) <= maximum_filename_length with open(filepath) as f: d = json.load(f) assert is_dict(d) assert sorted(d.keys()) == ["backtraceGraph", "codemodelVersion", "installers", "paths"] # We get the values for major and minor directly rather than from the "expected" data. # This avoids having to update every data file any time the major or minor version changes. assert is_int(d["codemodelVersion"]["major"], major) assert is_int(d["codemodelVersion"]["minor"], minor) assert is_string(d["paths"]["source"], actual["source"]) assert is_string(d["paths"]["build"], actual["build"]) check_backtrace_graph(d["backtraceGraph"]) assert is_list(d["installers"]) assert len(d["installers"]) == len(expected["installers"]) for a, e in zip(d["installers"], expected["installers"]): assert is_dict(a) expected_keys = ["component", "type"] assert is_string(a["component"], e["component"]) assert is_string(a["type"], e["type"]) if e["destination"] is not None: expected_keys.append("destination") assert is_string(a["destination"], e["destination"]) if e["paths"] is not None: expected_keys.append("paths") assert is_list(a["paths"]) assert len(a["paths"]) == len(e["paths"]) for ap, ep in zip(a["paths"], e["paths"]): if is_string(ep): assert matches(ap, ep) else: assert is_dict(ap) assert sorted(ap.keys()) == ["from", "to"] assert matches(ap["from"], ep["from"]) assert matches(ap["to"], ep["to"]) if e["isExcludeFromAll"] is not None: expected_keys.append("isExcludeFromAll") assert is_bool(a["isExcludeFromAll"], e["isExcludeFromAll"]) if e["isForAllComponents"] is not None: expected_keys.append("isForAllComponents") assert is_bool(a["isForAllComponents"], e["isForAllComponents"]) if e["isOptional"] is not None: expected_keys.append("isOptional") assert is_bool(a["isOptional"], e["isOptional"]) if e["targetId"] is not None: expected_keys.append("targetId") assert matches(a["targetId"], e["targetId"]) if e["targetIndex"] is not None: expected_keys.append("targetIndex") assert is_int(a["targetIndex"]) assert c["targets"][a["targetIndex"]]["name"] == e["targetIndex"] if e["targetIsImportLibrary"] is not None: expected_keys.append("targetIsImportLibrary") assert is_bool(a["targetIsImportLibrary"], e["targetIsImportLibrary"]) if e["targetInstallNamelink"] is not None: expected_keys.append("targetInstallNamelink") assert is_string(a["targetInstallNamelink"], e["targetInstallNamelink"]) if e["exportName"] is not None: expected_keys.append("exportName") assert is_string(a["exportName"], e["exportName"]) if e["exportTargets"] is not None: expected_keys.append("exportTargets") assert is_list(a["exportTargets"]) assert len(a["exportTargets"]) == len(e["exportTargets"]) for at, et in zip(a["exportTargets"], e["exportTargets"]): assert is_dict(at) assert sorted(at.keys()) == ["id", "index"] assert matches(at["id"], et["id"]) assert is_int(at["index"]) assert c["targets"][at["index"]]["name"] == et["index"] if e["scriptFile"] is not None: expected_keys.append("scriptFile") assert is_string(a["scriptFile"], e["scriptFile"]) if e.get("runtimeDependencySetName", None) is not None: expected_keys.append("runtimeDependencySetName") assert is_string(a["runtimeDependencySetName"], e["runtimeDependencySetName"]) if e.get("runtimeDependencySetType", None) is not None: expected_keys.append("runtimeDependencySetType") assert is_string(a["runtimeDependencySetType"], e["runtimeDependencySetType"]) if e.get("fileSetName", None) is not None: expected_keys.append("fileSetName") assert is_string(a["fileSetName"], e["fileSetName"]) if e.get("fileSetType", None) is not None: expected_keys.append("fileSetType") assert is_string(a["fileSetType"], e["fileSetType"]) if e.get("fileSetDirectories", None) is not None: expected_keys.append("fileSetDirectories") assert is_list(a["fileSetDirectories"]) assert len(a["fileSetDirectories"]) == len(e["fileSetDirectories"]) for ad, ed in zip(a["fileSetDirectories"], e["fileSetDirectories"]): assert matches(ad, ed) if e.get("fileSetTarget", None) is not None: expected_keys.append("fileSetTarget") et = e["fileSetTarget"] at = a["fileSetTarget"] assert is_dict(at) assert sorted(at.keys()) == ["id", "index"] assert matches(at["id"], et["id"]) assert is_int(at["index"]) assert c["targets"][at["index"]]["name"] == et["index"] if e.get("cxxModuleBmiTarget", None) is not None: expected_keys.append("cxxModuleBmiTarget") et = e["cxxModuleBmiTarget"] at = a["cxxModuleBmiTarget"] assert is_dict(at) assert sorted(at.keys()) == ["id", "index"] assert matches(at["id"], et["id"]) assert is_int(at["index"]) assert c["targets"][at["index"]]["name"] == et["index"] if e["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(d, a["backtrace"], e["backtrace"]) assert sorted(a.keys()) == sorted(expected_keys) return _check def check_backtrace_graph(btg): assert is_dict(btg) assert sorted(btg.keys()) == ["commands", "files", "nodes"] assert is_list(btg["commands"]) for c in btg["commands"]: assert is_string(c) for f in btg["files"]: assert is_string(f) for n in btg["nodes"]: expected_keys = ["file"] assert is_dict(n) assert is_int(n["file"]) assert 0 <= n["file"] < len(btg["files"]) if "line" in n: expected_keys.append("line") assert is_int(n["line"]) if "command" in n: expected_keys.append("command") assert is_int(n["command"]) assert 0 <= n["command"] < len(btg["commands"]) if "parent" in n: expected_keys.append("parent") assert is_int(n["parent"]) assert 0 <= n["parent"] < len(btg["nodes"]) assert sorted(n.keys()) == sorted(expected_keys) def check_target(c, major, minor): def _check(actual, expected): assert is_dict(actual) assert sorted(actual.keys()) == ["directoryIndex", "id", "jsonFile", "name", "projectIndex"] assert is_int(actual["directoryIndex"]) assert matches(c["directories"][actual["directoryIndex"]]["source"], expected["directorySource"]) assert is_string(actual["name"], expected["name"]) assert is_string(actual["jsonFile"]) assert is_int(actual["projectIndex"]) assert is_string(c["projects"][actual["projectIndex"]]["name"], expected["projectName"]) filepath = os.path.join(reply_dir, actual["jsonFile"]) with open(filepath) as f: obj = json.load(f) expected_keys = ["codemodelVersion", "name", "id", "type", "backtraceGraph", "paths", "sources"] assert is_dict(obj) assert is_string(obj["name"], expected["name"]) assert matches(obj["id"], expected["id"]) assert is_string(obj["type"], expected["type"]) check_backtrace_graph(obj["backtraceGraph"]) if expected["imported"] is not None: expected_keys.append("imported") assert is_bool(obj["imported"], expected["imported"]) if expected["local"] is not None: expected_keys.append("local") assert is_bool(obj["local"], expected["local"]) if expected["abstract"] is not None: expected_keys.append("abstract") assert is_bool(obj["abstract"], expected["abstract"]) if expected["symbolic"] is not None: expected_keys.append("symbolic") assert is_bool(obj["symbolic"], expected["symbolic"]) assert is_dict(obj["paths"]) assert sorted(obj["paths"].keys()) == ["build", "source"] assert matches(obj["paths"]["build"], expected["build"]) assert matches(obj["paths"]["source"], expected["source"]) # We get the values for major and minor directly rather than from the "expected" data. # This avoids having to update every data file any time the major or minor version changes. assert is_dict(obj["codemodelVersion"]) assert sorted(obj["codemodelVersion"].keys()) == ["major", "minor"] assert is_int(obj["codemodelVersion"]["major"], major) assert is_int(obj["codemodelVersion"]["minor"], minor) def check_file_set(actual, expected): assert is_dict(actual) expected_keys = ["name", "type", "visibility", "baseDirectories"] assert is_string(actual["name"], expected["name"]) assert is_string(actual["type"], expected["type"]) assert is_string(actual["visibility"], expected["visibility"]) check_list_match(lambda a, e: matches(a, e), actual["baseDirectories"], expected["baseDirectories"], check_exception=lambda a, e: "File set base directory (check): %s" % a, missing_exception=lambda e: "File set base directory (missing): %s" % e, extra_exception=lambda a: "File set base directory (extra): %s" % a) assert sorted(actual.keys()) == sorted(expected_keys) def check_source(actual, expected): assert is_dict(actual) expected_keys = ["path"] if expected["fileSetName"] is not None: expected_keys.append("fileSetIndex") assert is_string(obj["fileSets"][actual["fileSetIndex"]]["name"], expected["fileSetName"]) if expected["compileGroupLanguage"] is not None: expected_keys.append("compileGroupIndex") assert is_string(obj["compileGroups"][actual["compileGroupIndex"]]["language"], expected["compileGroupLanguage"]) if expected["sourceGroupName"] is not None: expected_keys.append("sourceGroupIndex") assert is_string(obj["sourceGroups"][actual["sourceGroupIndex"]]["name"], expected["sourceGroupName"]) if expected["isGenerated"] is not None: expected_keys.append("isGenerated") assert is_bool(actual["isGenerated"], expected["isGenerated"]) if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) if expected["fileSets"] is not None: expected_keys.append("fileSets") check_list_match(lambda a, e: matches(a["name"], e["name"]), obj["fileSets"], expected["fileSets"], check=check_file_set, check_exception=lambda a, e: "File set: %s" % a["name"], missing_exception=lambda e: "File set: %s" % e["name"], extra_exception=lambda a: "File set: %s" % a["name"]) check_list_match(lambda a, e: matches(a["path"], e["path"]), obj["sources"], expected["sources"], check=check_source, check_exception=lambda a, e: "Source file: %s" % a["path"], missing_exception=lambda e: "Source file: %s" % e["path"], extra_exception=lambda a: "Source file: %s" % a["path"]) if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, obj["backtrace"], expected["backtrace"]) if expected["folder"] is not None: expected_keys.append("folder") assert is_dict(obj["folder"]) assert sorted(obj["folder"].keys()) == ["name"] assert is_string(obj["folder"]["name"], expected["folder"]) if expected["nameOnDisk"] is not None: expected_keys.append("nameOnDisk") assert matches(obj["nameOnDisk"], expected["nameOnDisk"]) if expected["artifacts"] is not None: expected_keys.append("artifacts") def check_artifact(actual, expected): assert is_dict(actual) assert sorted(actual.keys()) == ["path"] check_list_match(lambda a, e: matches(a["path"], e["path"]), obj["artifacts"], expected["artifacts"], check=check_artifact, check_exception=lambda a, e: "Artifact: %s" % a["path"], missing_exception=lambda e: "Artifact: %s" % e["path"], extra_exception=lambda a: "Artifact: %s" % a["path"]) if expected["isGeneratorProvided"] is not None: expected_keys.append("isGeneratorProvided") assert is_bool(obj["isGeneratorProvided"], expected["isGeneratorProvided"]) if expected["install"] is not None: expected_keys.append("install") assert is_dict(obj["install"]) assert sorted(obj["install"].keys()) == ["destinations", "prefix"] assert is_dict(obj["install"]["prefix"]) assert sorted(obj["install"]["prefix"].keys()) == ["path"] assert matches(obj["install"]["prefix"]["path"], expected["install"]["prefix"]) def check_install_destination(actual, expected): assert is_dict(actual) expected_keys = ["path"] if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: matches(a["path"], e["path"]), obj["install"]["destinations"], expected["install"]["destinations"], check=check_install_destination, check_exception=lambda a, e: "Install path: %s" % a["path"], missing_exception=lambda e: "Install path: %s" % e["path"], extra_exception=lambda a: "Install path: %s" % a["path"]) if "launchers" in expected: if expected["launchers"] is not None: expected_keys.append("launchers") def check_launcher(actual, expected): assert is_dict(actual) launcher_keys = ["command", "type"] if "arguments" in expected: launcher_keys.append("arguments") assert sorted(actual.keys()) == sorted(launcher_keys) assert matches(actual["command"], expected["command"]) assert matches(actual["type"], expected["type"]) if "arguments" in expected: if expected["arguments"] is not None: check_list_match(lambda a, e: matches(a, e), actual["arguments"], expected["arguments"], missing_exception=lambda e: "argument: %s" % e, extra_exception=lambda a: "argument: %s" % actual["arguments"]) check_list_match(lambda a, e: matches(a["type"], e["type"]), obj["launchers"], expected["launchers"], check=check_launcher, check_exception=lambda a, e: "launchers: %s" % a, missing_exception=lambda e: "launchers: %s" % e, extra_exception=lambda a: "launchers: %s" % a) if "debugger" in expected: if expected["debugger"] is not None: expected_keys.append("debugger") assert is_dict(obj["debugger"]) debugger_keys = ["workingDirectory"] assert sorted(obj["debugger"].keys()) == sorted(debugger_keys) assert matches(obj["debugger"]["workingDirectory"], expected["debugger"]["workingDirectory"]) if expected["link"] is not None: expected_keys.append("link") assert is_dict(obj["link"]) link_keys = ["language"] assert is_string(obj["link"]["language"], expected["link"]["language"]) if "commandFragments" in obj["link"]: link_keys.append("commandFragments") assert is_list(obj["link"]["commandFragments"]) for f in obj["link"]["commandFragments"]: assert is_dict(f) assert sorted(f.keys()) == ["fragment", "role"] or sorted(f.keys()) == ["backtrace", "fragment", "role"] assert is_string(f["fragment"]) assert is_string(f["role"]) assert f["role"] in ("flags", "libraries", "libraryPath", "frameworkPath") if expected["link"]["commandFragments"] is not None: def check_link_command_fragments(actual, expected): assert is_dict(actual) expected_keys = ["fragment", "role"] if expected["backtrace"] is not None: expected_keys.append("backtrace") assert matches(actual["fragment"], expected["fragment"]) assert actual["role"] == expected["role"] check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: matches(a["fragment"], e["fragment"]), obj["link"]["commandFragments"], expected["link"]["commandFragments"], check=check_link_command_fragments, check_exception=lambda a, e: "Link fragment: %s" % a["fragment"], missing_exception=lambda e: "Link fragment: %s" % e["fragment"], extra_exception=lambda a: "Link fragment: %s" % a["fragment"], allow_extra=True) if expected["link"]["lto"] is not None: link_keys.append("lto") assert is_bool(obj["link"]["lto"], expected["link"]["lto"]) # FIXME: Properly test sysroot if "sysroot" in obj["link"]: link_keys.append("sysroot") assert is_string(obj["link"]["sysroot"]) assert sorted(obj["link"].keys()) == sorted(link_keys) if expected["archive"] is not None: expected_keys.append("archive") assert is_dict(obj["archive"]) archive_keys = [] # FIXME: Properly test commandFragments if "commandFragments" in obj["archive"]: archive_keys.append("commandFragments") assert is_list(obj["archive"]["commandFragments"]) for f in obj["archive"]["commandFragments"]: assert is_dict(f) assert sorted(f.keys()) == ["fragment", "role"] assert is_string(f["fragment"]) assert is_string(f["role"]) assert f["role"] in ("flags") if expected["archive"]["lto"] is not None: archive_keys.append("lto") assert is_bool(obj["archive"]["lto"], expected["archive"]["lto"]) assert sorted(obj["archive"].keys()) == sorted(archive_keys) if expected["dependencies"] is not None: expected_keys.append("dependencies") def check_dependency(actual, expected): assert is_dict(actual) expected_keys = ["id"] if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: matches(a["id"], e["id"]), obj["dependencies"], expected["dependencies"], check=check_dependency, check_exception=lambda a, e: "Dependency ID: %s" % a["id"], missing_exception=lambda e: "Dependency ID: %s" % e["id"], extra_exception=lambda a: "Dependency ID: %s" % a["id"]) def is_same_link_library(actual, expected): if "id" in actual: return expected["id"] is not None and matches(actual["id"], expected["id"]) if "fragment" in actual: return expected["fragment"] is not None and is_string(actual["fragment"], expected["fragment"]) assert False # actual must have one of id or fragment if expected["linkLibraries"] is not None: expected_keys.append("linkLibraries") def check_link_library(actual, expected): assert is_dict(actual) expected_keys = [] # We always require exactly one of id or fragment if expected["id"] is not None: expected_keys.append("id") assert matches(actual["id"], expected["id"]) assert "fragment" not in actual else: expected_keys.append("fragment") assert is_string(actual["fragment"], expected["fragment"]) assert "id" not in actual if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) if expected["fromDependency"] is not None: expected_keys.append("fromDependency") assert is_dict(actual["fromDependency"]) assert matches(actual["fromDependency"]["id"], expected["fromDependency"]) assert sorted(actual["fromDependency"].keys()) == ["id"] assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(is_same_link_library, obj["linkLibraries"], expected["linkLibraries"], check=check_link_library, check_exception=lambda a, e: "Mismatched link library: %s" % (a["id"] if "id" in a else a["fragment"]), missing_exception=lambda e: "Missing link library: %s" % (e["id"] if e["id"] is not None else e["fragment"]), extra_exception=lambda a: "Extra link library: %s" % (a["id"] if "id" in a else a["fragment"])) if expected["interfaceLinkLibraries"] is not None: expected_keys.append("interfaceLinkLibraries") def check_interface_link_library(actual, expected): assert is_dict(actual) expected_keys = [] # We always require exactly one of id or fragment if expected["id"] is not None: expected_keys.append("id") assert matches(actual["id"], expected["id"]) assert "fragment" not in actual else: expected_keys.append("fragment") assert is_string(actual["fragment"], expected["fragment"]) assert "id" not in actual if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(is_same_link_library, obj["interfaceLinkLibraries"], expected["interfaceLinkLibraries"], check=check_interface_link_library, check_exception=lambda a, e: "Mismatched interface link library: %s" % (a["id"] if "id" in a else a["fragment"]), missing_exception=lambda e: "Missing interface link library: %s" % (e["id"] if e["id"] is not None else e["fragment"]), extra_exception=lambda a: "Extra interface link library: %s" % (a["id"] if "id" in a else a["fragment"])) if expected["compileDependencies"] is not None: expected_keys.append("compileDependencies") def check_usage_dependency(actual, expected): assert is_dict(actual) assert matches(actual["id"], expected["id"]) expected_keys = ["id"] if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) if expected["fromDependency"] is not None: expected_keys.append("fromDependency") assert is_dict(actual["fromDependency"]) assert matches(actual["fromDependency"]["id"], expected["fromDependency"]) assert sorted(actual["fromDependency"].keys()) == ["id"] assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: matches(a["id"], e["id"]), obj["compileDependencies"], expected["compileDependencies"], check=check_usage_dependency, check_exception=lambda a, e: "Mismatched compile dependency: %s" % a["id"], missing_exception=lambda e: "Missing compile dependency: %s" % e["id"], extra_exception=lambda a: "Extra compile dependency: %s" % a["id"]) def check_only_target_dependency(actual, expected): assert is_dict(actual) assert matches(actual["id"], expected["id"]) expected_keys = ["id"] if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) if expected["interfaceCompileDependencies"] is not None: expected_keys.append("interfaceCompileDependencies") check_list_match(lambda a, e: matches(a["id"], e["id"]), obj["interfaceCompileDependencies"], expected["interfaceCompileDependencies"], check=check_only_target_dependency, check_exception=lambda a, e: "Mismatched interface compile dependency: %s" % a["id"], missing_exception=lambda e: "Missing interface compile dependency: %s" % e["id"], extra_exception=lambda a: "Extra interface compile dependency: %s" % a["id"]) if expected["objectDependencies"] is not None: expected_keys.append("objectDependencies") check_list_match(lambda a, e: matches(a["id"], e["id"]), obj["objectDependencies"], expected["objectDependencies"], check=check_only_target_dependency, check_exception=lambda a, e: "Mismatched object dependency: %s" % a["id"], missing_exception=lambda e: "Missing object dependency: %s" % e["id"], extra_exception=lambda a: "Extra object dependency: %s" % a["id"]) if expected["orderDependencies"] is not None: expected_keys.append("orderDependencies") check_list_match(lambda a, e: matches(a["id"], e["id"]), obj["orderDependencies"], expected["orderDependencies"], check=check_only_target_dependency, check_exception=lambda a, e: "Mismatched order dependency: %s" % a["id"], missing_exception=lambda e: "Missing order dependency: %s" % e["id"], extra_exception=lambda a: "Extra order dependency: %s" % a["id"]) if expected["sourceGroups"] is not None: expected_keys.append("sourceGroups") def check_source_group(actual, expected): assert is_dict(actual) assert sorted(actual.keys()) == ["name", "sourceIndexes"] check_list_match(lambda a, e: matches(obj["sources"][a]["path"], e), actual["sourceIndexes"], expected["sourcePaths"], missing_exception=lambda e: "Source path: %s" % e, extra_exception=lambda a: "Source path: %s" % obj["sources"][a]["path"]) check_list_match(lambda a, e: is_string(a["name"], e["name"]), obj["sourceGroups"], expected["sourceGroups"], check=check_source_group, check_exception=lambda a, e: "Source group: %s" % a["name"], missing_exception=lambda e: "Source group: %s" % e["name"], extra_exception=lambda a: "Source group: %s" % a["name"]) if expected["compileGroups"] is not None: expected_keys.append("compileGroups") def check_compile_group(actual, expected): assert is_dict(actual) expected_keys = ["sourceIndexes", "language"] check_list_match(lambda a, e: matches(obj["sources"][a]["path"], e), actual["sourceIndexes"], expected["sourcePaths"], missing_exception=lambda e: "Source path: %s" % e, extra_exception=lambda a: "Source path: %s" % obj["sources"][a]["path"]) if "compileCommandFragments" in actual: expected_keys.append("compileCommandFragments") assert is_list(actual["compileCommandFragments"]) for f in actual["compileCommandFragments"]: assert is_dict(f) assert is_string(f["fragment"]) if expected["compileCommandFragments"] is not None: def check_compile_command_fragments(actual, expected): assert is_dict(actual) expected_keys = ["fragment"] if expected["backtrace"] is not None: expected_keys.append("backtrace") assert actual["fragment"] == expected["fragment"] check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: is_string(a["fragment"], e["fragment"]), actual["compileCommandFragments"], expected["compileCommandFragments"], check=check_compile_command_fragments, check_exception=lambda a, e: "Compile fragment: %s" % a["fragment"], missing_exception=lambda e: "Compile fragment: %s" % e["fragment"], extra_exception=lambda a: "Compile fragment: %s" % a["fragment"], allow_extra=True) if expected["includes"] is not None: expected_keys.append("includes") def check_include(actual, expected): assert is_dict(actual) expected_keys = ["path"] if expected["isSystem"] is not None: expected_keys.append("isSystem") assert is_bool(actual["isSystem"], expected["isSystem"]) if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: matches(a["path"], e["path"]), actual["includes"], expected["includes"], check=check_include, check_exception=lambda a, e: "Include path: %s" % a["path"], missing_exception=lambda e: "Include path: %s" % e["path"], extra_exception=lambda a: "Include path: %s" % a["path"]) if expected["frameworks"] is not None: expected_keys.append("frameworks") def check_include(actual, expected): assert is_dict(actual) expected_keys = ["path"] if expected["isSystem"] is not None: expected_keys.append("isSystem") assert is_bool(actual["isSystem"], expected["isSystem"]) if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: matches(a["path"], e["path"]), actual["frameworks"], expected["frameworks"], check=check_include, check_exception=lambda a, e: "Framework path: %s" % a["path"], missing_exception=lambda e: "Framework path: %s" % e["path"], extra_exception=lambda a: "Framework path: %s" % a["path"]) if "precompileHeaders" in expected: expected_keys.append("precompileHeaders") def check_precompile_header(actual, expected): assert is_dict(actual) expected_keys = ["backtrace", "header"] check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: matches(a["header"], e["header"]), actual["precompileHeaders"], expected["precompileHeaders"], check=check_precompile_header, check_exception=lambda a, e: "Precompile header: %s" % a["header"], missing_exception=lambda e: "Precompile header: %s" % e["header"], extra_exception=lambda a: "Precompile header: %s" % a["header"]) if "languageStandard" in expected: expected_keys.append("languageStandard") def check_language_standard(actual, expected): assert is_dict(actual) expected_keys = ["backtraces", "standard"] assert actual["standard"] == expected["standard"] check_backtraces(obj, actual["backtraces"], expected["backtraces"]) assert sorted(actual.keys()) == sorted(expected_keys) check_language_standard(actual["languageStandard"], expected["languageStandard"]) if expected["defines"] is not None: expected_keys.append("defines") def check_define(actual, expected): assert is_dict(actual) expected_keys = ["define"] if expected["backtrace"] is not None: expected_keys.append("backtrace") check_backtrace(obj, actual["backtrace"], expected["backtrace"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: is_string(a["define"], e["define"]), actual["defines"], expected["defines"], check=check_define, check_exception=lambda a, e: "Define: %s" % a["define"], missing_exception=lambda e: "Define: %s" % e["define"], extra_exception=lambda a: "Define: %s" % a["define"]) # FIXME: Properly test sysroot if "sysroot" in actual: expected_keys.append("sysroot") assert is_string(actual["sysroot"]) assert sorted(actual.keys()) == sorted(expected_keys) check_list_match(lambda a, e: is_string(a["language"], e["language"]), obj["compileGroups"], expected["compileGroups"], check=check_compile_group, check_exception=lambda a, e: "Compile group: %s" % a["language"], missing_exception=lambda e: "Compile group: %s" % e["language"], extra_exception=lambda a: "Compile group: %s" % a["language"]) assert sorted(obj.keys()) == sorted(expected_keys) return _check def check_project(c): def _check(actual, expected): assert is_dict(actual) expected_keys = ["name", "directoryIndexes"] check_list_match(lambda a, e: matches(c["directories"][a]["source"], e), actual["directoryIndexes"], expected["directorySources"], missing_exception=lambda e: "Directory source: %s" % e, extra_exception=lambda a: "Directory source: %s" % c["directories"][a]["source"]) if expected["parentName"] is not None: expected_keys.append("parentIndex") assert is_int(actual["parentIndex"]) assert is_string(c["projects"][actual["parentIndex"]]["name"], expected["parentName"]) if expected["childNames"] is not None: expected_keys.append("childIndexes") check_list_match(lambda a, e: is_string(c["projects"][a]["name"], e), actual["childIndexes"], expected["childNames"], missing_exception=lambda e: "Child name: %s" % e, extra_exception=lambda a: "Child name: %s" % c["projects"][a]["name"]) if expected["targetIds"] is not None: expected_keys.append("targetIndexes") check_list_match(lambda a, e: matches(c["targets"][a]["id"], e), actual["targetIndexes"], expected["targetIds"], missing_exception=lambda e: "Target ID: %s" % e, extra_exception=lambda a: "Target ID: %s" % c["targets"][a]["id"]) if expected["abstractTargetIds"] is not None: expected_keys.append("abstractTargetIndexes") check_list_match(lambda a, e: matches(c["abstractTargets"][a]["id"], e), actual["abstractTargetIndexes"], expected["abstractTargetIds"], missing_exception=lambda e: "Abstract target ID: %s" % e, extra_exception=lambda a: "Abstract target ID: %s" % c["abstractTargets"][a]["id"]) assert sorted(actual.keys()) == sorted(expected_keys) return _check def gen_check_directories(c, g): expected = [ read_codemodel_json_data("directories/top.json"), read_codemodel_json_data("directories/alias.json"), read_codemodel_json_data("directories/custom.json"), read_codemodel_json_data("directories/cxx.json"), read_codemodel_json_data("directories/cxx.cross.json"), read_codemodel_json_data("directories/imported.json"), read_codemodel_json_data("directories/interface.json"), read_codemodel_json_data("directories/object.json"), read_codemodel_json_data("directories/dir.json"), read_codemodel_json_data("directories/dir_dir.json"), read_codemodel_json_data("directories/dir_very-long.json"), read_codemodel_json_data("directories/external.json"), read_codemodel_json_data("directories/fileset.json"), read_codemodel_json_data("directories/subdir.json"), read_codemodel_json_data("directories/framework.json"), read_codemodel_json_data("directories/direct.json"), ] if matches(g["name"], "^Visual Studio "): for e in expected: if e["parentSource"] is not None: e["targetIds"] = filter_list(lambda t: not matches(t, "^\\^ZERO_CHECK"), e["targetIds"]) elif g["name"] == "Xcode": if ';' in os.environ.get("CMAKE_OSX_ARCHITECTURES", ""): for e in expected: e["targetIds"] = filter_list(lambda t: not matches(t, "^\\^(link_imported_object_exe)"), e["targetIds"]) e["abstractTargetIds"] = filter_list(lambda t: not matches(t, "^\\^(imported_object_lib)"), e["abstractTargetIds"]) else: for e in expected: e["targetIds"] = filter_list(lambda t: not matches(t, "^\\^(ALL_BUILD|ZERO_CHECK)"), e["targetIds"]) if sys.platform in ("win32", "cygwin", "msys") or "aix" in sys.platform: for e in expected: e["installers"] = list(filter(lambda i: i["targetInstallNamelink"] is None or i["targetInstallNamelink"] == "skip", e["installers"])) for i in e["installers"]: i["targetInstallNamelink"] = None if sys.platform not in ("win32", "cygwin", "msys"): for e in expected: e["installers"] = list(filter(lambda i: not i.get("_dllExtra", False), e["installers"])) if "aix" not in sys.platform: for i in e["installers"]: if "pathsNamelink" in i: i["paths"] = i["pathsNamelink"] if sys.platform not in ("win32", "darwin") and "linux" not in sys.platform: for e in expected: e["installers"] = list(filter(lambda i: i["type"] != "runtimeDependencySet", e["installers"])) if sys.platform != "darwin": for e in expected: e["installers"] = list(filter(lambda i: i.get("runtimeDependencySetType", None) != "framework", e["installers"])) return expected def check_directories(c, g, major, minor): check_list_match(lambda a, e: matches(a["source"], e["source"]), c["directories"], gen_check_directories(c, g), check=check_directory(c, major, minor), check_exception=lambda a, e: "Directory source: %s" % a["source"], missing_exception=lambda e: "Directory source: %s" % e["source"], extra_exception=lambda a: "Directory source: %s" % a["source"]) def gen_check_build_system_targets(c, g, inSource): expected = [ read_codemodel_json_data("targets/all_build_top.json"), read_codemodel_json_data("targets/zero_check_top.json"), read_codemodel_json_data("targets/interface_exe.json"), read_codemodel_json_data("targets/c_lib.json"), read_codemodel_json_data("targets/c_exe.json"), read_codemodel_json_data("targets/c_shared_lib.json"), read_codemodel_json_data("targets/c_shared_exe.json"), read_codemodel_json_data("targets/c_static_lib.json"), read_codemodel_json_data("targets/c_static_exe.json"), read_codemodel_json_data("targets/c_subdir.json"), read_codemodel_json_data("targets/all_build_cxx.json"), read_codemodel_json_data("targets/zero_check_cxx.json"), read_codemodel_json_data("targets/cxx_lib.json"), read_codemodel_json_data("targets/cxx_exe.json"), read_codemodel_json_data("targets/cxx_exe_cross_emulator.json"), read_codemodel_json_data("targets/cxx_exe_cross_emulator_args.json"), read_codemodel_json_data("targets/cxx_exe_test_launcher_and_cross_emulator.json"), read_codemodel_json_data("targets/cxx_exe_test_launcher.json"), read_codemodel_json_data("targets/cxx_standard_compile_feature_exe.json"), read_codemodel_json_data("targets/cxx_standard_exe.json"), read_codemodel_json_data("targets/cxx_shared_lib.json"), read_codemodel_json_data("targets/cxx_shared_exe.json"), read_codemodel_json_data("targets/cxx_static_lib.json"), read_codemodel_json_data("targets/cxx_static_exe.json"), read_codemodel_json_data("targets/all_build_alias.json"), read_codemodel_json_data("targets/zero_check_alias.json"), read_codemodel_json_data("targets/c_alias_exe.json"), read_codemodel_json_data("targets/cxx_alias_exe.json"), read_codemodel_json_data("targets/all_build_object.json"), read_codemodel_json_data("targets/zero_check_object.json"), read_codemodel_json_data("targets/c_object_lib.json"), read_codemodel_json_data("targets/c_object_exe.json"), read_codemodel_json_data("targets/cxx_object_lib.json"), read_codemodel_json_data("targets/cxx_object_exe.json"), read_codemodel_json_data("targets/all_build_framework.json"), read_codemodel_json_data("targets/zero_check_framework.json"), read_codemodel_json_data("targets/static_framework.json"), read_codemodel_json_data("targets/shared_framework.json"), read_codemodel_json_data("targets/exe_framework.json"), read_codemodel_json_data("targets/all_build_imported.json"), read_codemodel_json_data("targets/zero_check_imported.json"), read_codemodel_json_data("targets/link_imported_exe.json"), read_codemodel_json_data("targets/link_imported_shared_exe.json"), read_codemodel_json_data("targets/link_imported_static_exe.json"), read_codemodel_json_data("targets/link_imported_object_exe.json"), read_codemodel_json_data("targets/link_imported_interface_exe.json"), read_codemodel_json_data("targets/link_imported_interface_symbolic_exe.json"), read_codemodel_json_data("targets/all_build_interface.json"), read_codemodel_json_data("targets/zero_check_interface.json"), read_codemodel_json_data("targets/iface_srcs.json"), read_codemodel_json_data("targets/all_build_direct.json"), read_codemodel_json_data("targets/zero_check_direct.json"), read_codemodel_json_data("targets/link_transitive_direct_exe.json"), read_codemodel_json_data("targets/transitive_direct_lib.json"), read_codemodel_json_data("targets/inject_direct_lib_impl.json"), read_codemodel_json_data("targets/usage_lib.json"), read_codemodel_json_data("targets/link_usage_exe.json"), read_codemodel_json_data("targets/compile_usage_exe.json"), read_codemodel_json_data("targets/all_build_custom.json"), read_codemodel_json_data("targets/zero_check_custom.json"), read_codemodel_json_data("targets/custom_tgt.json"), read_codemodel_json_data("targets/custom_exe.json"), read_codemodel_json_data("targets/all_build_external.json"), read_codemodel_json_data("targets/zero_check_external.json"), # Must be the last zero_check_... because matches all ZERO_CHECK::@XXX target ids read_codemodel_json_data("targets/generated_exe.json"), read_codemodel_json_data("targets/c_headers_1.json"), read_codemodel_json_data("targets/c_headers_2.json"), ] if sys.platform == "darwin": for e in expected: if e["name"] == "static_framework": apple_static_framework = read_codemodel_json_data("targets/apple_static_framework.json") e["artifacts"] = apple_static_framework["artifacts"] e["nameOnDisk"] = apple_static_framework["nameOnDisk"] elif e["name"] == "shared_framework": apple_shared_framework = read_codemodel_json_data("targets/apple_shared_framework.json") e["artifacts"] = apple_shared_framework["artifacts"] e["nameOnDisk"] = apple_shared_framework["nameOnDisk"] elif e["name"] == "exe_framework": apple_exe_framework = read_codemodel_json_data("targets/apple_exe_framework.json") e["compileGroups"] = apple_exe_framework["compileGroups"] e["link"] = apple_exe_framework["link"] if args.cxx_compiler_id in ['Clang', 'AppleClang', 'LCC', 'GNU', 'Intel', 'IntelLLVM', 'MSVC', 'Embarcadero', 'CrayClang', 'IBMClang'] and g["name"] != "Xcode": for e in expected: if e["name"] == "cxx_exe": if matches(g["name"], "^(Visual Studio |Ninja Multi-Config)"): precompile_header_data = read_codemodel_json_data("targets/cxx_exe_precompileheader_multigen.json") else: if ';' in os.environ.get("CMAKE_OSX_ARCHITECTURES", ""): precompile_header_data = read_codemodel_json_data("targets/cxx_exe_precompileheader_2arch.json") else: precompile_header_data = read_codemodel_json_data("targets/cxx_exe_precompileheader.json") e["compileGroups"] = precompile_header_data["compileGroups"] e["sources"] = precompile_header_data["sources"] e["sourceGroups"] = precompile_header_data["sourceGroups"] if args.cxx_compiler_id != 'MSVC' and args.cxx_simulate_id != 'MSVC': for e in expected: if not e["compileGroups"]: continue for group in e["compileGroups"]: if not group["defines"]: continue # _WINDLL is expected for compilers targeting the MSVC ABI, but not for others. # And _MBCS too group["defines"] = [d for d in group["defines"] if d and d["define"] != "_WINDLL" and d["define"] != "_MBCS"] if len(group["defines"]) == 0: group["defines"] = None if os.path.exists(os.path.join(reply_dir, "..", "..", "..", "..", "cxx", "cxx_std_11.txt")): for e in expected: if e["name"] == "cxx_standard_compile_feature_exe": language_standard_data = read_codemodel_json_data("targets/cxx_standard_compile_feature_exe_languagestandard.json") e["compileGroups"][0]["languageStandard"] = language_standard_data["languageStandard"] if not os.path.exists(os.path.join(reply_dir, "..", "..", "..", "..", "ipo_enabled.txt")): for e in expected: try: e["link"]["lto"] = None except TypeError: # "link" is not a dict, no problem. pass try: e["archive"]["lto"] = None except TypeError: # "archive" is not a dict, no problem. pass if inSource: for e in expected: if e["sources"] is not None: for s in e["sources"]: s["path"] = s["path"].replace("^.*/Tests/RunCMake/FileAPI/", "^", 1) if e["sourceGroups"] is not None: for group in e["sourceGroups"]: group["sourcePaths"] = [p.replace("^.*/Tests/RunCMake/FileAPI/", "^", 1) for p in group["sourcePaths"]] if e["compileGroups"] is not None: for group in e["compileGroups"]: group["sourcePaths"] = [p.replace("^.*/Tests/RunCMake/FileAPI/", "^", 1) for p in group["sourcePaths"]] if matches(g["name"], "^Visual Studio "): expected = filter_list(lambda e: e["name"] not in ("ZERO_CHECK") or e["id"] == "^ZERO_CHECK::@6890427a1f51a3e7e1df$", expected) for e in expected: if e["type"] == "UTILITY": if e["id"] == "^ZERO_CHECK::@6890427a1f51a3e7e1df$": # The json files have data for Xcode. Substitute data for VS. e["sources"] = [ { "path": "^.*/Tests/RunCMake/FileAPI/codemodel-v2-build/CMakeFiles/([0-9a-f]+/)?generate\\.stamp\\.rule$", "isGenerated": True, "fileSetName": None, "sourceGroupName": "CMake Rules", "compileGroupLanguage": None, "backtrace": [ { "file": "^CMakeLists\\.txt$", "line": None, "command": None, "hasParent": False, }, ], }, ] e["sourceGroups"] = [ { "name": "CMake Rules", "sourcePaths": [ "^.*/Tests/RunCMake/FileAPI/codemodel-v2-build/CMakeFiles/([0-9a-f]+/)?generate\\.stamp\\.rule$", ], }, ] elif e["name"] in ("ALL_BUILD"): e["sources"] = [] e["sourceGroups"] = None if e["dependencies"] is not None: for d in e["dependencies"]: if matches(d["id"], "^\\^ZERO_CHECK::@"): d["id"] = "^ZERO_CHECK::@6890427a1f51a3e7e1df$" if e["name"] == "cxx_exe": e["debugger"]["workingDirectory"] = "^/test/debugger/workingDirectoryVS$" elif g["name"] == "Xcode": if ';' in os.environ.get("CMAKE_OSX_ARCHITECTURES", ""): expected = filter_list(lambda e: e["name"] not in ("link_imported_object_exe"), expected) for e in expected: e["dependencies"] = filter_list(lambda d: not matches(d["id"], "^\\^link_imported_object_exe::@"), e["dependencies"]) e["orderDependencies"] = filter_list(lambda d: not matches(d["id"], "^\\^link_imported_object_exe::@"), e["orderDependencies"]) if e["name"] in ("c_object_lib", "cxx_object_lib", "inject_direct_lib_impl"): e["artifacts"] = None else: for e in expected: e["dependencies"] = filter_list(lambda d: not matches(d["id"], "^\\^ZERO_CHECK::@"), e["dependencies"]) expected = filter_list(lambda t: t["name"] not in ("ALL_BUILD", "ZERO_CHECK"), expected) if sys.platform not in ("win32", "cygwin", "msys"): for e in expected: e["artifacts"] = filter_list(lambda a: not a["_dllExtra"], e["artifacts"]) if e["install"] is not None: e["install"]["destinations"] = filter_list(lambda d: "_dllExtra" not in d or not d["_dllExtra"], e["install"]["destinations"]) else: for e in expected: if e["install"] is not None: e["install"]["destinations"] = filter_list(lambda d: "_namelink" not in d or not d["_namelink"], e["install"]["destinations"]) if "aix" not in sys.platform: for e in expected: e["artifacts"] = filter_list(lambda a: not a.get("_aixExtra", False), e["artifacts"]) return expected def gen_check_abstract_targets(c, g, inSource): expected = [ read_codemodel_json_data("targets/interface_lib.json"), read_codemodel_json_data("targets/import_framework.json"), read_codemodel_json_data("targets/imported_exe.json"), read_codemodel_json_data("targets/imported_lib.json"), read_codemodel_json_data("targets/imported_interface_lib.json"), read_codemodel_json_data("targets/imported_interface_symbolic_lib.json"), read_codemodel_json_data("targets/imported_object_lib.json"), read_codemodel_json_data("targets/imported_shared_lib.json"), read_codemodel_json_data("targets/imported_static_lib.json"), read_codemodel_json_data("targets/iface_none.json"), read_codemodel_json_data("targets/iface_symbolic.json"), read_codemodel_json_data("targets/inject_direct_lib.json"), ] if sys.platform == "darwin": for e in expected: if e["name"] == "import_framework": apple_import_framework = read_codemodel_json_data("targets/apple_import_framework.json") e["artifacts"] = apple_import_framework["artifacts"] e["nameOnDisk"] = apple_import_framework["nameOnDisk"] if g["name"] == "Xcode": if ';' in os.environ.get("CMAKE_OSX_ARCHITECTURES", ""): expected = filter_list(lambda e: e["name"] not in ("imported_object_lib"), expected) if sys.platform not in ("win32", "cygwin", "msys"): for e in expected: e["artifacts"] = filter_list(lambda a: not a["_dllExtra"], e["artifacts"]) return expected def check_build_system_targets(c, g, major, minor, inSource): check_list_match(lambda a, e: matches(a["id"], e["id"]), c["targets"], gen_check_build_system_targets(c, g, inSource), check=check_target(c, major, minor), check_exception=lambda a, e: "Target ID: %s" % a["id"], missing_exception=lambda e: "Target ID: %s" % e["id"], extra_exception=lambda a: "Target ID: %s" % a["id"]) def check_abstract_targets(c, g, major, minor, inSource): check_list_match(lambda a, e: matches(a["id"], e["id"]), c["abstractTargets"], gen_check_abstract_targets(c, g, inSource), check=check_target(c, major, minor), check_exception=lambda a, e: "Abstract target ID: %s" % a["id"], missing_exception=lambda e: "Abstract target ID: %s" % e["id"], extra_exception=lambda a: "Abstract target ID: %s" % a["id"]) def gen_check_projects(c, g): expected = [ read_codemodel_json_data("projects/codemodel-v2.json"), read_codemodel_json_data("projects/cxx.json"), read_codemodel_json_data("projects/alias.json"), read_codemodel_json_data("projects/object.json"), read_codemodel_json_data("projects/imported.json"), read_codemodel_json_data("projects/interface.json"), read_codemodel_json_data("projects/custom.json"), read_codemodel_json_data("projects/external.json"), read_codemodel_json_data("projects/framework.json"), read_codemodel_json_data("projects/direct.json"), ] if matches(g["name"], "^Visual Studio "): for e in expected: if e["parentName"] is not None: e["targetIds"] = filter_list(lambda t: not matches(t, "^\\^ZERO_CHECK"), e["targetIds"]) elif g["name"] == "Xcode": if ';' in os.environ.get("CMAKE_OSX_ARCHITECTURES", ""): for e in expected: e["targetIds"] = filter_list(lambda t: not matches(t, "^\\^(link_imported_object_exe)"), e["targetIds"]) e["abstractTargetIds"] = filter_list(lambda t: not matches(t, "^\\^(imported_object_lib)"), e["abstractTargetIds"]) else: for e in expected: e["targetIds"] = filter_list(lambda t: not matches(t, "^\\^(ALL_BUILD|ZERO_CHECK)"), e["targetIds"]) return expected def check_projects(c, g): check_list_match(lambda a, e: is_string(a["name"], e["name"]), c["projects"], gen_check_projects(c, g), check=check_project(c), check_exception=lambda a, e: "Project name: %s" % a["name"], missing_exception=lambda e: "Project name: %s" % e["name"], extra_exception=lambda a: "Project name: %s" % a["name"]) def check_object_codemodel_configuration(c, g, major, minor, inSource): assert sorted(c.keys()) == ["abstractTargets", "directories", "name", "projects", "targets"] assert is_string(c["name"]) check_directories(c, g, major, minor) check_build_system_targets(c, g, major, minor, inSource) check_abstract_targets(c, g, major, minor, inSource) check_projects(c, g) def check_object_codemodel(g, major, minor): def _check(o): assert sorted(o.keys()) == ["configurations", "kind", "paths", "version"] # The "kind" and "version" members are handled by check_index_object. assert is_dict(o["paths"]) assert sorted(o["paths"].keys()) == ["build", "source"] assert matches(o["paths"]["build"], "^.*/Tests/RunCMake/FileAPI/codemodel-v2-build$") assert matches(o["paths"]["source"], "^.*/Tests/RunCMake/FileAPI$") inSource = os.path.dirname(o["paths"]["build"]) == o["paths"]["source"] if g["multiConfig"]: assert sorted([c["name"] for c in o["configurations"]]) == ["Debug", "MinSizeRel", "RelWithDebInfo", "Release"] else: assert len(o["configurations"]) == 1 assert o["configurations"][0]["name"] in ("", "Debug", "Release", "RelWithDebInfo", "MinSizeRel") for c in o["configurations"]: check_object_codemodel_configuration(c, g, major, minor, inSource) return _check assert is_dict(index) assert sorted(index.keys()) == ["cmake", "objects", "reply"] check_objects(index["objects"], index["cmake"]["generator"])