4 #include "xmlrpc_config.h"
8 #include "xmlrpc-c/base.h"
9 #include "xmlrpc-c/xmlparser.h"
13 #include "parse_xml.h"
17 static void test_expat (void)
20 xml_element *elem, *array, *data, *value1, *i4;
24 xmlrpc_env_init(&env);
26 /* Parse a moderately complex XML document. */
27 xml_parse(&env, expat_data, strlen(expat_data), &elem);
31 /* Verify our results. */
32 TEST(streq(xml_element_name(elem), "value"));
33 TEST(xml_element_children_size(elem) == 1);
34 array = xml_element_children(elem)[0];
35 TEST(streq(xml_element_name(array), "array"));
36 TEST(xml_element_children_size(array) == 1);
37 data = xml_element_children(array)[0];
38 TEST(streq(xml_element_name(data), "data"));
39 TEST(xml_element_children_size(data) > 1);
40 value1 = xml_element_children(data)[0];
41 TEST(streq(xml_element_name(value1), "value"));
42 TEST(xml_element_children_size(value1) == 1);
43 i4 = xml_element_children(value1)[0];
44 TEST(streq(xml_element_name(i4), "i4"));
45 TEST(xml_element_children_size(i4) == 0);
46 cdata = xml_element_cdata(i4);
47 size = xml_element_cdata_size(i4);
48 TEST(size == strlen("2147483647"));
49 TEST(memcmp(cdata, "2147483647", strlen("2147483647")) == 0);
51 /* Test cleanup code (w/memprof). */
52 xml_element_free(elem);
55 xml_parse(&env, expat_error_data, strlen(expat_error_data), &elem);
56 TEST(env.fault_occurred);
58 xmlrpc_env_clean(&env);
64 validateParseResponseResult(xmlrpc_value * const valueP) {
72 xmlrpc_bool bool_false;
73 xmlrpc_bool bool_true;
77 unsigned char * b64_data;
83 xmlrpc_env_init(&env);
85 xmlrpc_decompose_value(
86 &env, valueP, "((iibbs68())idddSs)",
88 &bool_false, &bool_true, &str_hello,
89 &b64_data, &b64_len, &datetime,
90 &int_one, &negone, &zero, &one, &s, &str_untagged);
93 TEST(int_max == INT_MAX);
94 TEST(int_min == INT_MIN);
97 TEST(strlen(str_hello) == strlen("Hello, world! <&>"));
98 TEST(streq(str_hello, "Hello, world! <&>"));
100 TEST(memcmp(b64_data, "base64 data", b64_len) == 0);
101 TEST(streq(datetime, "19980717T14:08:55"));
103 TEST(negone == -1.0);
106 TEST(streq(str_untagged, "Untagged string"));
113 /* Analyze the contents of our struct. */
119 size = xmlrpc_struct_size(&env, s);
122 sval = xmlrpc_struct_get_value(&env, s, "ten <&>");
124 xmlrpc_decompose_value(&env, sval, "i", &sval_int);
126 TEST(sval_int == 10);
127 sval = xmlrpc_struct_get_value(&env, s, "twenty");
129 xmlrpc_decompose_value(&env, sval, "i", &sval_int);
131 TEST(sval_int == 20);
135 xmlrpc_env_clean(&env);
141 testParseGoodResponse(void) {
144 xmlrpc_value * valueP;
146 const char * faultString;
148 xmlrpc_env_init(&env);
150 xmlrpc_parse_response2(&env, good_response_xml, strlen(good_response_xml),
151 &valueP, &faultCode, &faultString);
154 TEST(faultString == NULL);
156 validateParseResponseResult(valueP);
158 xmlrpc_DECREF(valueP);
160 /* Try it again with old interface */
162 valueP = xmlrpc_parse_response(&env,
164 strlen(good_response_xml));
166 TEST(valueP != NULL);
168 validateParseResponseResult(valueP);
170 xmlrpc_DECREF(valueP);
172 xmlrpc_env_clean(&env);
179 testParseBadResponse(void) {
180 /*----------------------------------------------------------------------------
181 Test parsing of data that is supposed to be a response, but is not
182 valid. Either not valid XML or not valid XML-RPC.
183 -----------------------------------------------------------------------------*/
188 xmlrpc_value * valueP;
190 const char * faultString;
192 /* First, test some poorly-formed XML data. */
193 xmlrpc_env_init(&env);
195 xmlrpc_parse_response2(&env,
196 unparseable_value, strlen(unparseable_value),
197 &valueP, &faultCode, &faultString);
199 TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
200 xmlrpc_env_clean(&env);
202 xmlrpc_env_init(&env);
204 /* And again with the old interface */
205 valueP = xmlrpc_parse_response(&env, unparseable_value,
206 strlen(unparseable_value));
207 TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
208 xmlrpc_env_clean(&env);
209 TEST(valueP == NULL);
212 /* Try with good XML, but bad XML-RPC. For this test, we test up to
213 but not including the <value> in a successful RPC response.
216 /* Next, check for bogus responses. These are all well-formed XML, but
217 ** they aren't legal XML-RPC. */
218 for (i = 15; bad_responses[i] != NULL; ++i) {
219 const char * const bad_resp = bad_responses[i];
224 xmlrpc_env_init(&env);
226 /* First, check to make sure that our test case is well-formed XML.
227 ** (It's easy to make mistakes when writing the test cases!) */
228 xml_parse(&env, bad_resp, strlen(bad_resp), &elem);
230 xml_element_free(elem);
232 /* Now, make sure the higher-level routine barfs appropriately. */
233 v = xmlrpc_parse_response(&env, bad_resp, strlen(bad_resp));
234 TEST(env.fault_occurred);
235 TEST(env.fault_code != 0); /* We use 0 as a code in our bad faults. */
237 xmlrpc_env_clean(&env);
240 /* Try with good XML, good XML-RPC response, except that the value
243 for (i = 0; bad_values[i] != NULL; ++i) {
244 const char * const bad_resp = bad_values[i];
246 xmlrpc_value * valueP;
249 const char * faultString;
251 xmlrpc_env_init(&env);
253 /* First, check to make sure that our test case is well-formed XML.
254 ** (It's easy to make mistakes when writing the test cases!) */
255 xml_parse(&env, bad_resp, strlen(bad_resp), &elem);
257 xml_element_free(elem);
259 /* Now, make sure the higher-level routine barfs appropriately. */
261 xmlrpc_parse_response2(&env, bad_resp, strlen(bad_resp),
262 &valueP, &faultCode, &faultString);
264 TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
265 xmlrpc_env_clean(&env);
267 xmlrpc_env_init(&env);
269 /* And again with the old interface */
271 valueP = xmlrpc_parse_response(&env, bad_resp, strlen(bad_resp));
272 TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
273 TEST(valueP == NULL);
274 xmlrpc_env_clean(&env);
281 testParseFaultResponse(void) {
282 /*----------------------------------------------------------------------------
283 Test parsing of a valid response that indicates the RPC failed.
284 -----------------------------------------------------------------------------*/
287 xmlrpc_env_init(&env);
290 xmlrpc_value * resultP;
292 const char * faultString;
294 xmlrpc_parse_response2(&env,
295 serialized_fault, strlen(serialized_fault),
296 &resultP, &faultCode, &faultString);
299 TEST(faultString != NULL);
300 TEST(faultCode == 6);
301 TEST(streq(faultString, "A fault occurred"));
302 strfree(faultString);
304 /* Now with the old interface */
306 xmlrpc_value * valueP;
309 /* Parse a valid fault. */
310 xmlrpc_env_init(&fault);
311 valueP = xmlrpc_parse_response(&fault, serialized_fault,
312 strlen(serialized_fault));
314 TEST(fault.fault_occurred);
315 TEST(fault.fault_code == 6);
316 TEST(streq(fault.fault_string, "A fault occurred"));
317 xmlrpc_env_clean(&fault);
320 xmlrpc_env_clean(&env);
326 test_parse_xml_call(void) {
329 const char *method_name;
330 xmlrpc_value *params;
332 const char **bad_call;
335 xmlrpc_env_init(&env);
337 /* Parse a valid call. */
338 xmlrpc_parse_call(&env, serialized_call, strlen(serialized_call),
339 &method_name, ¶ms);
341 TEST(params != NULL);
342 xmlrpc_decompose_value(&env, params, "(ii)", &i1, &i2);
343 xmlrpc_DECREF(params);
345 TEST(streq(method_name, "gloom&doom"));
346 TEST(i1 == 10 && i2 == 20);
347 strfree(method_name);
349 /* Test some poorly-formed XML data. */
350 xmlrpc_parse_call(&env, unparseable_value, strlen(unparseable_value),
351 &method_name, ¶ms);
352 TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
353 TEST(method_name == NULL && params == NULL);
355 /* Next, check for bogus values. These are all well-formed XML, but
356 they aren't legal XML-RPC.
358 for (bad_call = bad_calls; *bad_call != NULL; ++bad_call) {
360 /* First, check to make sure that our test case is well-formed XML.
361 ** (It's easy to make mistakes when writing the test cases!) */
362 xml_parse(&env, *bad_call, strlen(*bad_call), &elem);
364 xml_element_free(elem);
366 /* Now, make sure the higher-level routine barfs appropriately. */
367 xmlrpc_parse_call(&env, *bad_call, strlen(*bad_call),
368 &method_name, ¶ms);
369 TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
370 TEST(method_name == NULL && params == NULL);
372 xmlrpc_env_clean(&env);
378 test_parse_xml(void) {
380 printf("Running XML parsing tests.\n");
382 testParseGoodResponse();
383 testParseFaultResponse();
384 testParseBadResponse();
385 test_parse_xml_call();
387 printf("XML parsing tests done.\n");