show-only_json-v1_check.py 6.04 KB
Newer Older
1
from show_only_json_check import *
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

def check_kind(k):
    assert is_string(k)
    assert k == "ctestInfo"

def check_version(v):
    assert is_dict(v)
    assert sorted(v.keys()) == ["major", "minor"]
    assert is_int(v["major"])
    assert is_int(v["minor"])
    assert v["major"] == 1
    assert v["minor"] == 0

def check_backtracegraph(b):
    assert is_dict(b)
    assert sorted(b.keys()) == ["commands", "files", "nodes"]
    check_backtracegraph_commands(b["commands"])
    check_backtracegraph_files(b["files"])
    check_backtracegraph_nodes(b["nodes"])

def check_backtracegraph_commands(c):
    assert is_list(c)
    assert len(c) == 1
    assert is_string(c[0])
    assert c[0] == "add_test"

def check_backtracegraph_files(f):
    assert is_list(f)
    assert len(f) == 2
    assert is_string(f[0])
    assert is_string(f[1])
    assert f[0] == "file1"
    assert f[1] == "file0"

def check_backtracegraph_nodes(n):
    assert is_list(n)
    assert len(n) == 2
    node = n[0]
    assert is_dict(node)
    assert sorted(node.keys()) == ["file"]
    assert is_int(node["file"])
    assert node["file"] == 1
    node = n[1]
    assert is_dict(node)
    assert sorted(node.keys()) == ["command", "file", "line", "parent"]
    assert is_int(node["command"])
    assert is_int(node["file"])
    assert is_int(node["line"])
    assert is_int(node["parent"])
    assert node["command"] == 0
    assert node["file"] == 0
    assert node["line"] == 1
    assert node["parent"] == 0

def check_command(c):
    assert is_list(c)
    assert len(c) == 3
    assert is_string(c[0])
    check_re(c[0], "/cmake(\.exe)?$")
    assert is_string(c[1])
    assert c[1] == "-E"
    assert is_string(c[2])
    assert c[2] == "echo"

66 67 68 69 70 71 72 73 74
def check_reqfiles_property(p):
    assert is_dict(p)
    assert sorted(p.keys()) == ["name", "value"]
    assert is_string(p["name"])
    assert is_list(p["value"])
    assert p["name"] == "REQUIRED_FILES"
    assert len(p["value"]) == 1
    assert p["value"][0] == "RequiredFileDoesNotExist"

75 76 77 78 79 80 81 82
def check_willfail_property(p):
    assert is_dict(p)
    assert sorted(p.keys()) == ["name", "value"]
    assert is_string(p["name"])
    assert is_bool(p["value"])
    assert p["name"] == "WILL_FAIL"
    assert p["value"] == True

83
def check_resource_groups_property(p):
84 85 86 87
    assert is_dict(p)
    assert sorted(p.keys()) == ["name", "value"]
    assert is_string(p["name"])
    assert is_list(p["value"])
88
    assert p["name"] == "RESOURCE_GROUPS"
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
    assert len(p["value"]) == 3

    assert is_dict(p["value"][0])
    assert sorted(p["value"][0].keys()) == ["requirements"]
    assert is_list(p["value"][0]["requirements"])
    assert len(p["value"][0]["requirements"]) == 2
    assert is_dict(p["value"][0]["requirements"][0])
    assert sorted(p["value"][0]["requirements"][0].keys()) == \
        [".type", "slots"]
    assert is_string(p["value"][0]["requirements"][0][".type"])
    assert p["value"][0]["requirements"][0][".type"] == "threads"
    assert is_int(p["value"][0]["requirements"][0]["slots"])
    assert p["value"][0]["requirements"][0]["slots"] == 2
    assert is_string(p["value"][0]["requirements"][1][".type"])
    assert p["value"][0]["requirements"][1][".type"] == "gpus"
    assert is_int(p["value"][0]["requirements"][1]["slots"])
    assert p["value"][0]["requirements"][1]["slots"] == 4

    assert is_dict(p["value"][1])
    assert sorted(p["value"][1].keys()) == ["requirements"]
    assert is_list(p["value"][1]["requirements"])
    assert len(p["value"][1]["requirements"]) == 2
    assert is_dict(p["value"][1]["requirements"][0])
    assert sorted(p["value"][1]["requirements"][0].keys()) == \
        [".type", "slots"]
    assert is_string(p["value"][1]["requirements"][0][".type"])
    assert p["value"][1]["requirements"][0][".type"] == "threads"
    assert is_int(p["value"][1]["requirements"][0]["slots"])
    assert p["value"][1]["requirements"][0]["slots"] == 2
    assert is_string(p["value"][1]["requirements"][1][".type"])
    assert p["value"][1]["requirements"][1][".type"] == "gpus"
    assert is_int(p["value"][1]["requirements"][1]["slots"])
    assert p["value"][1]["requirements"][1]["slots"] == 4

    assert is_dict(p["value"][2])
    assert sorted(p["value"][2].keys()) == ["requirements"]
    assert is_list(p["value"][2]["requirements"])
    assert len(p["value"][2]["requirements"]) == 2
    assert is_dict(p["value"][2]["requirements"][0])
    assert sorted(p["value"][2]["requirements"][0].keys()) == \
        [".type", "slots"]
    assert is_string(p["value"][2]["requirements"][0][".type"])
    assert p["value"][2]["requirements"][0][".type"] == "gpus"
    assert is_int(p["value"][2]["requirements"][0]["slots"])
    assert p["value"][2]["requirements"][0]["slots"] == 2
    assert is_string(p["value"][2]["requirements"][1][".type"])
    assert p["value"][2]["requirements"][1][".type"] == "threads"
    assert is_int(p["value"][2]["requirements"][1]["slots"])
    assert p["value"][2]["requirements"][1]["slots"] == 4

139 140 141 142 143 144
def check_workingdir_property(p):
    assert is_dict(p)
    assert sorted(p.keys()) == ["name", "value"]
    assert is_string(p["name"])
    assert is_string(p["value"])
    assert p["name"] == "WORKING_DIRECTORY"
145
    assert p["value"].endswith("Tests/RunCMake/CTestCommandLine/ShowOnly")
146 147 148

def check_properties(p):
    assert is_list(p)
149
    assert len(p) == 4
150
    check_resource_groups_property(p[0])
151 152 153
    check_reqfiles_property(p[1])
    check_willfail_property(p[2])
    check_workingdir_property(p[3])
154 155 156 157 158 159 160 161 162 163 164

def check_tests(t):
    assert is_list(t)
    assert len(t) == 1
    test = t[0]
    assert is_dict(test)
    assert sorted(test.keys()) == ["backtrace", "command", "name", "properties"]
    assert is_int(test["backtrace"])
    assert test["backtrace"] == 1
    check_command(test["command"])
    assert is_string(test["name"])
165
    assert test["name"] == "ShowOnly"
166 167 168 169 170 171 172 173
    check_properties(test["properties"])

assert is_dict(ctest_json)
assert sorted(ctest_json.keys()) == ["backtraceGraph", "kind", "tests", "version"]
check_backtracegraph(ctest_json["backtraceGraph"])
check_kind(ctest_json["kind"])
check_version(ctest_json["version"])
check_tests(ctest_json["tests"])