Imported Upstream version 3.25.0
[platform/upstream/cmake.git] / Tests / RunCMake / FileAPI / ClientStateful-check.py
1 from check_index import *
2
3 def check_reply(q):
4     assert is_dict(q)
5     assert sorted(q.keys()) == [
6         "client-client-member",
7         "client-empty-array",
8         "client-empty-object",
9         "client-json-bad-root",
10         "client-json-empty",
11         "client-json-extra",
12         "client-not-file",
13         "client-request-array-negative-major-version",
14         "client-request-array-negative-minor-version",
15         "client-request-array-negative-version",
16         "client-request-array-no-major-version",
17         "client-request-array-no-supported-version",
18         "client-request-array-no-supported-version-among",
19         "client-request-array-version-1",
20         "client-request-array-version-1-1",
21         "client-request-array-version-2",
22         "client-request-negative-major-version",
23         "client-request-negative-minor-version",
24         "client-request-negative-version",
25         "client-request-no-major-version",
26         "client-request-no-version",
27         "client-request-version-1",
28         "client-request-version-1-1",
29         "client-request-version-2",
30         "client-requests-bad",
31         "client-requests-empty",
32         "client-requests-not-kinded",
33         "client-requests-not-objects",
34         "client-requests-unknown",
35     ]
36     expected = [
37         (check_query_client_member, "client-client-member"),
38         (check_query_empty_array, "client-empty-array"),
39         (check_query_empty_object, "client-empty-object"),
40         (check_query_json_bad_root, "client-json-bad-root"),
41         (check_query_json_empty, "client-json-empty"),
42         (check_query_json_extra, "client-json-extra"),
43         (check_query_not_file, "client-not-file"),
44         (check_query_requests_bad, "client-requests-bad"),
45         (check_query_requests_empty, "client-requests-empty"),
46         (check_query_requests_not_kinded, "client-requests-not-kinded"),
47         (check_query_requests_not_objects, "client-requests-not-objects"),
48         (check_query_requests_unknown, "client-requests-unknown"),
49     ]
50     for (f, k) in expected:
51         assert is_dict(q[k])
52         assert sorted(q[k].keys()) == ["query.json"]
53         f(q[k]["query.json"])
54     expected = [
55         (check_query_response_array_negative_major_version,     "client-request-array-negative-major-version"),
56         (check_query_response_array_negative_minor_version,     "client-request-array-negative-minor-version"),
57         (check_query_response_array_negative_version,           "client-request-array-negative-version"),
58         (check_query_response_array_no_major_version,           "client-request-array-no-major-version"),
59         (check_query_response_array_no_supported_version,       "client-request-array-no-supported-version"),
60         (check_query_response_array_no_supported_version_among, "client-request-array-no-supported-version-among"),
61         (check_query_response_array_version_1,                  "client-request-array-version-1"),
62         (check_query_response_array_version_1_1,                "client-request-array-version-1-1"),
63         (check_query_response_array_version_2,                  "client-request-array-version-2"),
64         (check_query_response_negative_major_version,           "client-request-negative-major-version"),
65         (check_query_response_negative_minor_version,           "client-request-negative-minor-version"),
66         (check_query_response_negative_version,                 "client-request-negative-version"),
67         (check_query_response_no_major_version,                 "client-request-no-major-version"),
68         (check_query_response_no_version,                       "client-request-no-version"),
69         (check_query_response_version_1,                        "client-request-version-1"),
70         (check_query_response_version_1_1,                      "client-request-version-1-1"),
71         (check_query_response_version_2,                        "client-request-version-2"),
72     ]
73     for (f, k) in expected:
74         assert is_dict(q[k])
75         assert sorted(q[k].keys()) == ["query.json"]
76         assert is_dict(q[k]["query.json"])
77         assert sorted(q[k]["query.json"].keys()) == ["requests", "responses"]
78         r = q[k]["query.json"]["requests"]
79         assert is_list(r)
80         assert len(r) == 1
81         assert is_dict(r[0])
82         assert r[0]["kind"] == "__test"
83         r = q[k]["query.json"]["responses"]
84         assert is_list(r)
85         assert len(r) == 1
86         assert is_dict(r[0])
87         f(r[0])
88
89 def check_query_client_member(q):
90     assert is_dict(q)
91     assert sorted(q.keys()) == ["client", "responses"]
92     assert is_dict(q["client"])
93     assert sorted(q["client"].keys()) == []
94     check_error(q["responses"], "'requests' member missing")
95
96 def check_query_empty_array(q):
97     check_error(q, "query root is not an object")
98
99 def check_query_empty_object(q):
100     assert is_dict(q)
101     assert sorted(q.keys()) == ["responses"]
102     check_error(q["responses"], "'requests' member missing")
103
104 def check_query_json_bad_root(q):
105     check_error_re(q, "A valid JSON document must be either an array or an object value")
106
107 def check_query_json_empty(q):
108     check_error_re(q, "value, object or array expected")
109
110 def check_query_json_extra(q):
111     if bool(os.environ.get("CMake_JSONCPP_PRE_1_7_5", "")) and is_dict(q) and sorted(q.keys()) == ["responses"]:
112         # jsoncpp < 1.7.5 did not diagnose extra non-whitespace characters
113         check_error(q["responses"], "'requests' member missing")
114     else:
115         check_error_re(q, "Extra non-whitespace after JSON value")
116
117 def check_query_not_file(q):
118     check_error_re(q, "failed to read from file")
119
120 def check_query_requests_bad(q):
121     assert is_dict(q)
122     assert sorted(q.keys()) == ["requests", "responses"]
123     r = q["requests"]
124     assert is_dict(r)
125     assert sorted(r.keys()) == []
126     check_error(q["responses"], "'requests' member is not an array")
127
128 def check_query_requests_empty(q):
129     assert is_dict(q)
130     assert sorted(q.keys()) == ["requests", "responses"]
131     r = q["requests"]
132     assert is_list(r)
133     assert len(r) == 0
134     r = q["responses"]
135     assert is_list(r)
136     assert len(r) == 0
137
138 def check_query_requests_not_kinded(q):
139     assert is_dict(q)
140     assert sorted(q.keys()) == ["requests", "responses"]
141     r = q["requests"]
142     assert is_list(r)
143     assert len(r) == 4
144     assert is_dict(r[0])
145     assert sorted(r[0].keys()) == []
146     assert is_dict(r[1])
147     assert sorted(r[1].keys()) == ["kind"]
148     assert is_dict(r[1]["kind"])
149     assert is_dict(r[2])
150     assert sorted(r[2].keys()) == ["kind"]
151     assert is_list(r[2]["kind"])
152     assert is_dict(r[3])
153     assert sorted(r[3].keys()) == ["kind"]
154     assert is_int(r[3]["kind"])
155     r = q["responses"]
156     assert is_list(r)
157     assert len(r) == 4
158     check_error(r[0], "'kind' member missing")
159     check_error(r[1], "'kind' member is not a string")
160     check_error(r[2], "'kind' member is not a string")
161     check_error(r[3], "'kind' member is not a string")
162
163 def check_query_requests_not_objects(q):
164     assert is_dict(q)
165     assert sorted(q.keys()) == ["requests", "responses"]
166     r = q["requests"]
167     assert is_list(r)
168     assert len(r) == 3
169     assert is_int(r[0])
170     assert is_string(r[1])
171     assert is_list(r[2])
172     r = q["responses"]
173     assert is_list(r)
174     assert len(r) == 3
175     check_error(r[0], "request is not an object")
176     check_error(r[1], "request is not an object")
177     check_error(r[2], "request is not an object")
178
179 def check_query_requests_unknown(q):
180     assert is_dict(q)
181     assert sorted(q.keys()) == ["requests", "responses"]
182     r = q["requests"]
183     assert is_list(r)
184     assert len(r) == 3
185     assert is_dict(r[0])
186     assert sorted(r[0].keys()) == ["kind"]
187     assert r[0]["kind"] == "unknownC"
188     assert is_dict(r[1])
189     assert sorted(r[1].keys()) == ["kind"]
190     assert r[1]["kind"] == "unknownB"
191     assert is_dict(r[2])
192     assert sorted(r[2].keys()) == ["kind"]
193     assert r[2]["kind"] == "unknownA"
194     r = q["responses"]
195     assert is_list(r)
196     assert len(r) == 3
197     check_error(r[0], "unknown request kind 'unknownC'")
198     check_error(r[1], "unknown request kind 'unknownB'")
199     check_error(r[2], "unknown request kind 'unknownA'")
200
201 def check_query_response_array_negative_major_version(r):
202     check_error(r, "'version' object 'major' member is not a non-negative integer")
203
204 def check_query_response_array_negative_minor_version(r):
205     check_error(r, "'version' object 'minor' member is not a non-negative integer")
206
207 def check_query_response_array_negative_version(r):
208     check_error(r, "'version' array entry is not a non-negative integer or object")
209
210 def check_query_response_array_no_major_version(r):
211     check_error(r, "'version' object 'major' member missing")
212
213 def check_query_response_array_no_supported_version(r):
214     check_error(r, "no supported version specified")
215
216 def check_query_response_array_no_supported_version_among(r):
217     check_error(r, "no supported version specified among: 4.0 3.0")
218
219 def check_query_response_array_version_1(r):
220     check_index__test(r, 1, 3)
221
222 def check_query_response_array_version_1_1(r):
223     check_index__test(r, 1, 3) # always uses latest minor version
224
225 def check_query_response_array_version_2(r):
226     check_index__test(r, 2, 0)
227
228 def check_query_response_negative_major_version(r):
229     check_error(r, "'version' object 'major' member is not a non-negative integer")
230
231 def check_query_response_negative_minor_version(r):
232     check_error(r, "'version' object 'minor' member is not a non-negative integer")
233
234 def check_query_response_negative_version(r):
235     check_error(r, "'version' member is not a non-negative integer, object, or array")
236
237 def check_query_response_no_major_version(r):
238     check_error(r, "'version' object 'major' member missing")
239
240 def check_query_response_no_version(r):
241     check_error(r, "'version' member missing")
242
243 def check_query_response_version_1(r):
244     check_index__test(r, 1, 3)
245
246 def check_query_response_version_1_1(r):
247     check_index__test(r, 1, 3) # always uses latest minor version
248
249 def check_query_response_version_2(r):
250     check_index__test(r, 2, 0)
251
252 def check_objects(o):
253     assert is_list(o)
254     assert len(o) == 2
255     check_index__test(o[0], 1, 3)
256     check_index__test(o[1], 2, 0)
257
258 assert is_dict(index)
259 assert sorted(index.keys()) == ["cmake", "objects", "reply"]
260 check_cmake(index["cmake"])
261 check_reply(index["reply"])
262 check_objects(index["objects"])