]> git.saurik.com Git - wxWidgets.git/blob - src/expat/tests/runtests.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add wxActivateEvent::GetActivationReason().
[wxWidgets.git] / src / expat / tests / runtests.c
1 /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
2 See the file COPYING for copying permission.
3
4 runtest.c : run the Expat test suite
5 */
6
7 #ifdef HAVE_EXPAT_CONFIG_H
8 #include <expat_config.h>
9 #endif
10
11 #include <assert.h>
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <string.h>
15 #include <stdint.h>
16
17 #include "expat.h"
18 #include "chardata.h"
19 #include "minicheck.h"
20
21 #if defined(__amigaos__) && defined(__USE_INLINE__)
22 #include <proto/expat.h>
23 #endif
24
25 #ifdef XML_LARGE_SIZE
26 #define XML_FMT_INT_MOD "ll"
27 #else
28 #define XML_FMT_INT_MOD "l"
29 #endif
30
31 static XML_Parser parser;
32
33
34 static void
35 basic_setup(void)
36 {
37 parser = XML_ParserCreate(NULL);
38 if (parser == NULL)
39 fail("Parser not created.");
40 }
41
42 static void
43 basic_teardown(void)
44 {
45 if (parser != NULL)
46 XML_ParserFree(parser);
47 }
48
49 /* Generate a failure using the parser state to create an error message;
50 this should be used when the parser reports an error we weren't
51 expecting.
52 */
53 static void
54 _xml_failure(XML_Parser parser, const char *file, int line)
55 {
56 char buffer[1024];
57 enum XML_Error err = XML_GetErrorCode(parser);
58 sprintf(buffer,
59 " %d: %s (line %" XML_FMT_INT_MOD "u, offset %"\
60 XML_FMT_INT_MOD "u)\n reported from %s, line %d\n",
61 err,
62 XML_ErrorString(err),
63 XML_GetCurrentLineNumber(parser),
64 XML_GetCurrentColumnNumber(parser),
65 file, line);
66 _fail_unless(0, file, line, buffer);
67 }
68
69 #define xml_failure(parser) _xml_failure((parser), __FILE__, __LINE__)
70
71 static void
72 _expect_failure(char *text, enum XML_Error errorCode, char *errorMessage,
73 char *file, int lineno)
74 {
75 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_OK)
76 /* Hackish use of _fail_unless() macro, but let's us report
77 the right filename and line number. */
78 _fail_unless(0, file, lineno, errorMessage);
79 if (XML_GetErrorCode(parser) != errorCode)
80 _xml_failure(parser, file, lineno);
81 }
82
83 #define expect_failure(text, errorCode, errorMessage) \
84 _expect_failure((text), (errorCode), (errorMessage), \
85 __FILE__, __LINE__)
86
87 /* Dummy handlers for when we need to set a handler to tickle a bug,
88 but it doesn't need to do anything.
89 */
90
91 static void XMLCALL
92 dummy_start_doctype_handler(void *userData,
93 const XML_Char *doctypeName,
94 const XML_Char *sysid,
95 const XML_Char *pubid,
96 int has_internal_subset)
97 {}
98
99 static void XMLCALL
100 dummy_end_doctype_handler(void *userData)
101 {}
102
103 static void XMLCALL
104 dummy_entity_decl_handler(void *userData,
105 const XML_Char *entityName,
106 int is_parameter_entity,
107 const XML_Char *value,
108 int value_length,
109 const XML_Char *base,
110 const XML_Char *systemId,
111 const XML_Char *publicId,
112 const XML_Char *notationName)
113 {}
114
115 static void XMLCALL
116 dummy_notation_decl_handler(void *userData,
117 const XML_Char *notationName,
118 const XML_Char *base,
119 const XML_Char *systemId,
120 const XML_Char *publicId)
121 {}
122
123 static void XMLCALL
124 dummy_element_decl_handler(void *userData,
125 const XML_Char *name,
126 XML_Content *model)
127 {}
128
129 static void XMLCALL
130 dummy_attlist_decl_handler(void *userData,
131 const XML_Char *elname,
132 const XML_Char *attname,
133 const XML_Char *att_type,
134 const XML_Char *dflt,
135 int isrequired)
136 {}
137
138 static void XMLCALL
139 dummy_comment_handler(void *userData, const XML_Char *data)
140 {}
141
142 static void XMLCALL
143 dummy_pi_handler(void *userData, const XML_Char *target, const XML_Char *data)
144 {}
145
146 static void XMLCALL
147 dummy_start_element(void *userData,
148 const XML_Char *name, const XML_Char **atts)
149 {}
150
151
152 /*
153 * Character & encoding tests.
154 */
155
156 START_TEST(test_nul_byte)
157 {
158 char text[] = "<doc>\0</doc>";
159
160 /* test that a NUL byte (in US-ASCII data) is an error */
161 if (XML_Parse(parser, text, sizeof(text) - 1, XML_TRUE) == XML_STATUS_OK)
162 fail("Parser did not report error on NUL-byte.");
163 if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
164 xml_failure(parser);
165 }
166 END_TEST
167
168
169 START_TEST(test_u0000_char)
170 {
171 /* test that a NUL byte (in US-ASCII data) is an error */
172 expect_failure("<doc>&#0;</doc>",
173 XML_ERROR_BAD_CHAR_REF,
174 "Parser did not report error on NUL-byte.");
175 }
176 END_TEST
177
178 START_TEST(test_bom_utf8)
179 {
180 /* This test is really just making sure we don't core on a UTF-8 BOM. */
181 char *text = "\357\273\277<e/>";
182
183 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
184 xml_failure(parser);
185 }
186 END_TEST
187
188 START_TEST(test_bom_utf16_be)
189 {
190 char text[] = "\376\377\0<\0e\0/\0>";
191
192 if (XML_Parse(parser, text, sizeof(text)-1, XML_TRUE) == XML_STATUS_ERROR)
193 xml_failure(parser);
194 }
195 END_TEST
196
197 START_TEST(test_bom_utf16_le)
198 {
199 char text[] = "\377\376<\0e\0/\0>\0";
200
201 if (XML_Parse(parser, text, sizeof(text)-1, XML_TRUE) == XML_STATUS_ERROR)
202 xml_failure(parser);
203 }
204 END_TEST
205
206 static void XMLCALL
207 accumulate_characters(void *userData, const XML_Char *s, int len)
208 {
209 CharData_AppendXMLChars((CharData *)userData, s, len);
210 }
211
212 static void XMLCALL
213 accumulate_attribute(void *userData, const XML_Char *name,
214 const XML_Char **atts)
215 {
216 CharData *storage = (CharData *)userData;
217 if (storage->count < 0 && atts != NULL && atts[0] != NULL) {
218 /* "accumulate" the value of the first attribute we see */
219 CharData_AppendXMLChars(storage, atts[1], -1);
220 }
221 }
222
223
224 static void
225 _run_character_check(XML_Char *text, XML_Char *expected,
226 const char *file, int line)
227 {
228 CharData storage;
229
230 CharData_Init(&storage);
231 XML_SetUserData(parser, &storage);
232 XML_SetCharacterDataHandler(parser, accumulate_characters);
233 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
234 _xml_failure(parser, file, line);
235 CharData_CheckXMLChars(&storage, expected);
236 }
237
238 #define run_character_check(text, expected) \
239 _run_character_check(text, expected, __FILE__, __LINE__)
240
241 static void
242 _run_attribute_check(XML_Char *text, XML_Char *expected,
243 const char *file, int line)
244 {
245 CharData storage;
246
247 CharData_Init(&storage);
248 XML_SetUserData(parser, &storage);
249 XML_SetStartElementHandler(parser, accumulate_attribute);
250 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
251 _xml_failure(parser, file, line);
252 CharData_CheckXMLChars(&storage, expected);
253 }
254
255 #define run_attribute_check(text, expected) \
256 _run_attribute_check(text, expected, __FILE__, __LINE__)
257
258 /* Regression test for SF bug #491986. */
259 START_TEST(test_danish_latin1)
260 {
261 char *text =
262 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
263 "<e>J\xF8rgen \xE6\xF8\xE5\xC6\xD8\xC5</e>";
264 run_character_check(text,
265 "J\xC3\xB8rgen \xC3\xA6\xC3\xB8\xC3\xA5\xC3\x86\xC3\x98\xC3\x85");
266 }
267 END_TEST
268
269
270 /* Regression test for SF bug #514281. */
271 START_TEST(test_french_charref_hexidecimal)
272 {
273 char *text =
274 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
275 "<doc>&#xE9;&#xE8;&#xE0;&#xE7;&#xEA;&#xC8;</doc>";
276 run_character_check(text,
277 "\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
278 }
279 END_TEST
280
281 START_TEST(test_french_charref_decimal)
282 {
283 char *text =
284 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
285 "<doc>&#233;&#232;&#224;&#231;&#234;&#200;</doc>";
286 run_character_check(text,
287 "\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
288 }
289 END_TEST
290
291 START_TEST(test_french_latin1)
292 {
293 char *text =
294 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
295 "<doc>\xE9\xE8\xE0\xE7\xEa\xC8</doc>";
296 run_character_check(text,
297 "\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
298 }
299 END_TEST
300
301 START_TEST(test_french_utf8)
302 {
303 char *text =
304 "<?xml version='1.0' encoding='utf-8'?>\n"
305 "<doc>\xC3\xA9</doc>";
306 run_character_check(text, "\xC3\xA9");
307 }
308 END_TEST
309
310 /* Regression test for SF bug #600479.
311 XXX There should be a test that exercises all legal XML Unicode
312 characters as PCDATA and attribute value content, and XML Name
313 characters as part of element and attribute names.
314 */
315 START_TEST(test_utf8_false_rejection)
316 {
317 char *text = "<doc>\xEF\xBA\xBF</doc>";
318 run_character_check(text, "\xEF\xBA\xBF");
319 }
320 END_TEST
321
322 /* Regression test for SF bug #477667.
323 This test assures that any 8-bit character followed by a 7-bit
324 character will not be mistakenly interpreted as a valid UTF-8
325 sequence.
326 */
327 START_TEST(test_illegal_utf8)
328 {
329 char text[100];
330 int i;
331
332 for (i = 128; i <= 255; ++i) {
333 sprintf(text, "<e>%ccd</e>", i);
334 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_OK) {
335 sprintf(text,
336 "expected token error for '%c' (ordinal %d) in UTF-8 text",
337 i, i);
338 fail(text);
339 }
340 else if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
341 xml_failure(parser);
342 /* Reset the parser since we use the same parser repeatedly. */
343 XML_ParserReset(parser, NULL);
344 }
345 }
346 END_TEST
347
348 START_TEST(test_utf16)
349 {
350 /* <?xml version="1.0" encoding="UTF-16"?>
351 <doc a='123'>some text</doc>
352 */
353 char text[] =
354 "\000<\000?\000x\000m\000\154\000 \000v\000e\000r\000s\000i\000o"
355 "\000n\000=\000'\0001\000.\000\060\000'\000 \000e\000n\000c\000o"
356 "\000d\000i\000n\000g\000=\000'\000U\000T\000F\000-\0001\000\066"
357 "\000'\000?\000>\000\n"
358 "\000<\000d\000o\000c\000 \000a\000=\000'\0001\0002\0003\000'"
359 "\000>\000s\000o\000m\000e\000 \000t\000e\000x\000t\000<\000/"
360 "\000d\000o\000c\000>";
361 if (XML_Parse(parser, text, sizeof(text)-1, XML_TRUE) == XML_STATUS_ERROR)
362 xml_failure(parser);
363 }
364 END_TEST
365
366 START_TEST(test_utf16_le_epilog_newline)
367 {
368 unsigned int first_chunk_bytes = 17;
369 char text[] =
370 "\xFF\xFE" /* BOM */
371 "<\000e\000/\000>\000" /* document element */
372 "\r\000\n\000\r\000\n\000"; /* epilog */
373
374 if (first_chunk_bytes >= sizeof(text) - 1)
375 fail("bad value of first_chunk_bytes");
376 if ( XML_Parse(parser, text, first_chunk_bytes, XML_FALSE)
377 == XML_STATUS_ERROR)
378 xml_failure(parser);
379 else {
380 enum XML_Status rc;
381 rc = XML_Parse(parser, text + first_chunk_bytes,
382 sizeof(text) - first_chunk_bytes - 1, XML_TRUE);
383 if (rc == XML_STATUS_ERROR)
384 xml_failure(parser);
385 }
386 }
387 END_TEST
388
389 /* Regression test for SF bug #481609, #774028. */
390 START_TEST(test_latin1_umlauts)
391 {
392 char *text =
393 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
394 "<e a='\xE4 \xF6 \xFC &#228; &#246; &#252; &#x00E4; &#x0F6; &#xFC; >'\n"
395 " >\xE4 \xF6 \xFC &#228; &#246; &#252; &#x00E4; &#x0F6; &#xFC; ></e>";
396 char *utf8 =
397 "\xC3\xA4 \xC3\xB6 \xC3\xBC "
398 "\xC3\xA4 \xC3\xB6 \xC3\xBC "
399 "\xC3\xA4 \xC3\xB6 \xC3\xBC >";
400 run_character_check(text, utf8);
401 XML_ParserReset(parser, NULL);
402 run_attribute_check(text, utf8);
403 }
404 END_TEST
405
406 /* Regression test #1 for SF bug #653180. */
407 START_TEST(test_line_number_after_parse)
408 {
409 char *text =
410 "<tag>\n"
411 "\n"
412 "\n</tag>";
413 XML_Size lineno;
414
415 if (XML_Parse(parser, text, strlen(text), XML_FALSE) == XML_STATUS_ERROR)
416 xml_failure(parser);
417 lineno = XML_GetCurrentLineNumber(parser);
418 if (lineno != 4) {
419 char buffer[100];
420 sprintf(buffer,
421 "expected 4 lines, saw %" XML_FMT_INT_MOD "u", lineno);
422 fail(buffer);
423 }
424 }
425 END_TEST
426
427 /* Regression test #2 for SF bug #653180. */
428 START_TEST(test_column_number_after_parse)
429 {
430 char *text = "<tag></tag>";
431 XML_Size colno;
432
433 if (XML_Parse(parser, text, strlen(text), XML_FALSE) == XML_STATUS_ERROR)
434 xml_failure(parser);
435 colno = XML_GetCurrentColumnNumber(parser);
436 if (colno != 11) {
437 char buffer[100];
438 sprintf(buffer,
439 "expected 11 columns, saw %" XML_FMT_INT_MOD "u", colno);
440 fail(buffer);
441 }
442 }
443 END_TEST
444
445 static void XMLCALL
446 start_element_event_handler2(void *userData, const XML_Char *name,
447 const XML_Char **attr)
448 {
449 CharData *storage = (CharData *) userData;
450 char buffer[100];
451
452 sprintf(buffer,
453 "<%s> at col:%" XML_FMT_INT_MOD "u line:%"\
454 XML_FMT_INT_MOD "u\n", name,
455 XML_GetCurrentColumnNumber(parser),
456 XML_GetCurrentLineNumber(parser));
457 CharData_AppendString(storage, buffer);
458 }
459
460 static void XMLCALL
461 end_element_event_handler2(void *userData, const XML_Char *name)
462 {
463 CharData *storage = (CharData *) userData;
464 char buffer[100];
465
466 sprintf(buffer,
467 "</%s> at col:%" XML_FMT_INT_MOD "u line:%"\
468 XML_FMT_INT_MOD "u\n", name,
469 XML_GetCurrentColumnNumber(parser),
470 XML_GetCurrentLineNumber(parser));
471 CharData_AppendString(storage, buffer);
472 }
473
474 /* Regression test #3 for SF bug #653180. */
475 START_TEST(test_line_and_column_numbers_inside_handlers)
476 {
477 char *text =
478 "<a>\n" /* Unix end-of-line */
479 " <b>\r\n" /* Windows end-of-line */
480 " <c/>\r" /* Mac OS end-of-line */
481 " </b>\n"
482 " <d>\n"
483 " <f/>\n"
484 " </d>\n"
485 "</a>";
486 char *expected =
487 "<a> at col:0 line:1\n"
488 "<b> at col:2 line:2\n"
489 "<c> at col:4 line:3\n"
490 "</c> at col:8 line:3\n"
491 "</b> at col:2 line:4\n"
492 "<d> at col:2 line:5\n"
493 "<f> at col:4 line:6\n"
494 "</f> at col:8 line:6\n"
495 "</d> at col:2 line:7\n"
496 "</a> at col:0 line:8\n";
497 CharData storage;
498
499 CharData_Init(&storage);
500 XML_SetUserData(parser, &storage);
501 XML_SetStartElementHandler(parser, start_element_event_handler2);
502 XML_SetEndElementHandler(parser, end_element_event_handler2);
503 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
504 xml_failure(parser);
505
506 CharData_CheckString(&storage, expected);
507 }
508 END_TEST
509
510 /* Regression test #4 for SF bug #653180. */
511 START_TEST(test_line_number_after_error)
512 {
513 char *text =
514 "<a>\n"
515 " <b>\n"
516 " </a>"; /* missing </b> */
517 XML_Size lineno;
518 if (XML_Parse(parser, text, strlen(text), XML_FALSE) != XML_STATUS_ERROR)
519 fail("Expected a parse error");
520
521 lineno = XML_GetCurrentLineNumber(parser);
522 if (lineno != 3) {
523 char buffer[100];
524 sprintf(buffer, "expected 3 lines, saw %" XML_FMT_INT_MOD "u", lineno);
525 fail(buffer);
526 }
527 }
528 END_TEST
529
530 /* Regression test #5 for SF bug #653180. */
531 START_TEST(test_column_number_after_error)
532 {
533 char *text =
534 "<a>\n"
535 " <b>\n"
536 " </a>"; /* missing </b> */
537 XML_Size colno;
538 if (XML_Parse(parser, text, strlen(text), XML_FALSE) != XML_STATUS_ERROR)
539 fail("Expected a parse error");
540
541 colno = XML_GetCurrentColumnNumber(parser);
542 if (colno != 4) {
543 char buffer[100];
544 sprintf(buffer,
545 "expected 4 columns, saw %" XML_FMT_INT_MOD "u", colno);
546 fail(buffer);
547 }
548 }
549 END_TEST
550
551 /* Regression test for SF bug #478332. */
552 START_TEST(test_really_long_lines)
553 {
554 /* This parses an input line longer than INIT_DATA_BUF_SIZE
555 characters long (defined to be 1024 in xmlparse.c). We take a
556 really cheesy approach to building the input buffer, because
557 this avoids writing bugs in buffer-filling code.
558 */
559 char *text =
560 "<e>"
561 /* 64 chars */
562 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
563 /* until we have at least 1024 characters on the line: */
564 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
565 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
566 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
567 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
568 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
569 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
570 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
571 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
572 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
573 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
574 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
575 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
576 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
577 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
578 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
579 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
580 "</e>";
581 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
582 xml_failure(parser);
583 }
584 END_TEST
585
586
587 /*
588 * Element event tests.
589 */
590
591 static void XMLCALL
592 end_element_event_handler(void *userData, const XML_Char *name)
593 {
594 CharData *storage = (CharData *) userData;
595 CharData_AppendString(storage, "/");
596 CharData_AppendXMLChars(storage, name, -1);
597 }
598
599 START_TEST(test_end_element_events)
600 {
601 char *text = "<a><b><c/></b><d><f/></d></a>";
602 char *expected = "/c/b/f/d/a";
603 CharData storage;
604
605 CharData_Init(&storage);
606 XML_SetUserData(parser, &storage);
607 XML_SetEndElementHandler(parser, end_element_event_handler);
608 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
609 xml_failure(parser);
610 CharData_CheckString(&storage, expected);
611 }
612 END_TEST
613
614
615 /*
616 * Attribute tests.
617 */
618
619 /* Helpers used by the following test; this checks any "attr" and "refs"
620 attributes to make sure whitespace has been normalized.
621
622 Return true if whitespace has been normalized in a string, using
623 the rules for attribute value normalization. The 'is_cdata' flag
624 is needed since CDATA attributes don't need to have multiple
625 whitespace characters collapsed to a single space, while other
626 attribute data types do. (Section 3.3.3 of the recommendation.)
627 */
628 static int
629 is_whitespace_normalized(const XML_Char *s, int is_cdata)
630 {
631 int blanks = 0;
632 int at_start = 1;
633 while (*s) {
634 if (*s == ' ')
635 ++blanks;
636 else if (*s == '\t' || *s == '\n' || *s == '\r')
637 return 0;
638 else {
639 if (at_start) {
640 at_start = 0;
641 if (blanks && !is_cdata)
642 /* illegal leading blanks */
643 return 0;
644 }
645 else if (blanks > 1 && !is_cdata)
646 return 0;
647 blanks = 0;
648 }
649 ++s;
650 }
651 if (blanks && !is_cdata)
652 return 0;
653 return 1;
654 }
655
656 /* Check the attribute whitespace checker: */
657 static void
658 testhelper_is_whitespace_normalized(void)
659 {
660 assert(is_whitespace_normalized("abc", 0));
661 assert(is_whitespace_normalized("abc", 1));
662 assert(is_whitespace_normalized("abc def ghi", 0));
663 assert(is_whitespace_normalized("abc def ghi", 1));
664 assert(!is_whitespace_normalized(" abc def ghi", 0));
665 assert(is_whitespace_normalized(" abc def ghi", 1));
666 assert(!is_whitespace_normalized("abc def ghi", 0));
667 assert(is_whitespace_normalized("abc def ghi", 1));
668 assert(!is_whitespace_normalized("abc def ghi ", 0));
669 assert(is_whitespace_normalized("abc def ghi ", 1));
670 assert(!is_whitespace_normalized(" ", 0));
671 assert(is_whitespace_normalized(" ", 1));
672 assert(!is_whitespace_normalized("\t", 0));
673 assert(!is_whitespace_normalized("\t", 1));
674 assert(!is_whitespace_normalized("\n", 0));
675 assert(!is_whitespace_normalized("\n", 1));
676 assert(!is_whitespace_normalized("\r", 0));
677 assert(!is_whitespace_normalized("\r", 1));
678 assert(!is_whitespace_normalized("abc\t def", 1));
679 }
680
681 static void XMLCALL
682 check_attr_contains_normalized_whitespace(void *userData,
683 const XML_Char *name,
684 const XML_Char **atts)
685 {
686 int i;
687 for (i = 0; atts[i] != NULL; i += 2) {
688 const XML_Char *attrname = atts[i];
689 const XML_Char *value = atts[i + 1];
690 if (strcmp("attr", attrname) == 0
691 || strcmp("ents", attrname) == 0
692 || strcmp("refs", attrname) == 0) {
693 if (!is_whitespace_normalized(value, 0)) {
694 char buffer[256];
695 sprintf(buffer, "attribute value not normalized: %s='%s'",
696 attrname, value);
697 fail(buffer);
698 }
699 }
700 }
701 }
702
703 START_TEST(test_attr_whitespace_normalization)
704 {
705 char *text =
706 "<!DOCTYPE doc [\n"
707 " <!ATTLIST doc\n"
708 " attr NMTOKENS #REQUIRED\n"
709 " ents ENTITIES #REQUIRED\n"
710 " refs IDREFS #REQUIRED>\n"
711 "]>\n"
712 "<doc attr=' a b c\t\td\te\t' refs=' id-1 \t id-2\t\t' \n"
713 " ents=' ent-1 \t\r\n"
714 " ent-2 ' >\n"
715 " <e id='id-1'/>\n"
716 " <e id='id-2'/>\n"
717 "</doc>";
718
719 XML_SetStartElementHandler(parser,
720 check_attr_contains_normalized_whitespace);
721 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
722 xml_failure(parser);
723 }
724 END_TEST
725
726
727 /*
728 * XML declaration tests.
729 */
730
731 START_TEST(test_xmldecl_misplaced)
732 {
733 expect_failure("\n"
734 "<?xml version='1.0'?>\n"
735 "<a/>",
736 XML_ERROR_MISPLACED_XML_PI,
737 "failed to report misplaced XML declaration");
738 }
739 END_TEST
740
741 /* Regression test for SF bug #584832. */
742 static int XMLCALL
743 UnknownEncodingHandler(void *data,const XML_Char *encoding,XML_Encoding *info)
744 {
745 if (strcmp(encoding,"unsupported-encoding") == 0) {
746 int i;
747 for (i = 0; i < 256; ++i)
748 info->map[i] = i;
749 info->data = NULL;
750 info->convert = NULL;
751 info->release = NULL;
752 return XML_STATUS_OK;
753 }
754 return XML_STATUS_ERROR;
755 }
756
757 START_TEST(test_unknown_encoding_internal_entity)
758 {
759 char *text =
760 "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
761 "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
762 "<test a='&foo;'/>";
763
764 XML_SetUnknownEncodingHandler(parser, UnknownEncodingHandler, NULL);
765 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
766 xml_failure(parser);
767 }
768 END_TEST
769
770 /* Regression test for SF bug #620106. */
771 static int XMLCALL
772 external_entity_loader_set_encoding(XML_Parser parser,
773 const XML_Char *context,
774 const XML_Char *base,
775 const XML_Char *systemId,
776 const XML_Char *publicId)
777 {
778 /* This text says it's an unsupported encoding, but it's really
779 UTF-8, which we tell Expat using XML_SetEncoding().
780 */
781 char *text =
782 "<?xml encoding='iso-8859-3'?>"
783 "\xC3\xA9";
784 XML_Parser extparser;
785
786 extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
787 if (extparser == NULL)
788 fail("Could not create external entity parser.");
789 if (!XML_SetEncoding(extparser, "utf-8"))
790 fail("XML_SetEncoding() ignored for external entity");
791 if ( XML_Parse(extparser, text, strlen(text), XML_TRUE)
792 == XML_STATUS_ERROR) {
793 xml_failure(parser);
794 return 0;
795 }
796 return 1;
797 }
798
799 START_TEST(test_ext_entity_set_encoding)
800 {
801 char *text =
802 "<!DOCTYPE doc [\n"
803 " <!ENTITY en SYSTEM 'http://xml.libexpat.org/dummy.ent'>\n"
804 "]>\n"
805 "<doc>&en;</doc>";
806
807 XML_SetExternalEntityRefHandler(parser,
808 external_entity_loader_set_encoding);
809 run_character_check(text, "\xC3\xA9");
810 }
811 END_TEST
812
813 /* Test that no error is reported for unknown entities if we don't
814 read an external subset. This was fixed in Expat 1.95.5.
815 */
816 START_TEST(test_wfc_undeclared_entity_unread_external_subset) {
817 char *text =
818 "<!DOCTYPE doc SYSTEM 'foo'>\n"
819 "<doc>&entity;</doc>";
820
821 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
822 xml_failure(parser);
823 }
824 END_TEST
825
826 /* Test that an error is reported for unknown entities if we don't
827 have an external subset.
828 */
829 START_TEST(test_wfc_undeclared_entity_no_external_subset) {
830 expect_failure("<doc>&entity;</doc>",
831 XML_ERROR_UNDEFINED_ENTITY,
832 "Parser did not report undefined entity w/out a DTD.");
833 }
834 END_TEST
835
836 /* Test that an error is reported for unknown entities if we don't
837 read an external subset, but have been declared standalone.
838 */
839 START_TEST(test_wfc_undeclared_entity_standalone) {
840 char *text =
841 "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
842 "<!DOCTYPE doc SYSTEM 'foo'>\n"
843 "<doc>&entity;</doc>";
844
845 expect_failure(text,
846 XML_ERROR_UNDEFINED_ENTITY,
847 "Parser did not report undefined entity (standalone).");
848 }
849 END_TEST
850
851 static int XMLCALL
852 external_entity_loader(XML_Parser parser,
853 const XML_Char *context,
854 const XML_Char *base,
855 const XML_Char *systemId,
856 const XML_Char *publicId)
857 {
858 char *text = (char *)XML_GetUserData(parser);
859 XML_Parser extparser;
860
861 extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
862 if (extparser == NULL)
863 fail("Could not create external entity parser.");
864 if ( XML_Parse(extparser, text, strlen(text), XML_TRUE)
865 == XML_STATUS_ERROR) {
866 xml_failure(parser);
867 return XML_STATUS_ERROR;
868 }
869 return XML_STATUS_OK;
870 }
871
872 /* Test that an error is reported for unknown entities if we have read
873 an external subset, and standalone is true.
874 */
875 START_TEST(test_wfc_undeclared_entity_with_external_subset_standalone) {
876 char *text =
877 "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
878 "<!DOCTYPE doc SYSTEM 'foo'>\n"
879 "<doc>&entity;</doc>";
880 char *foo_text =
881 "<!ELEMENT doc (#PCDATA)*>";
882
883 XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
884 XML_SetUserData(parser, foo_text);
885 XML_SetExternalEntityRefHandler(parser, external_entity_loader);
886 expect_failure(text,
887 XML_ERROR_UNDEFINED_ENTITY,
888 "Parser did not report undefined entity (external DTD).");
889 }
890 END_TEST
891
892 /* Test that no error is reported for unknown entities if we have read
893 an external subset, and standalone is false.
894 */
895 START_TEST(test_wfc_undeclared_entity_with_external_subset) {
896 char *text =
897 "<?xml version='1.0' encoding='us-ascii'?>\n"
898 "<!DOCTYPE doc SYSTEM 'foo'>\n"
899 "<doc>&entity;</doc>";
900 char *foo_text =
901 "<!ELEMENT doc (#PCDATA)*>";
902
903 XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
904 XML_SetUserData(parser, foo_text);
905 XML_SetExternalEntityRefHandler(parser, external_entity_loader);
906 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
907 xml_failure(parser);
908 }
909 END_TEST
910
911 START_TEST(test_wfc_no_recursive_entity_refs)
912 {
913 char *text =
914 "<!DOCTYPE doc [\n"
915 " <!ENTITY entity '&#38;entity;'>\n"
916 "]>\n"
917 "<doc>&entity;</doc>";
918
919 expect_failure(text,
920 XML_ERROR_RECURSIVE_ENTITY_REF,
921 "Parser did not report recursive entity reference.");
922 }
923 END_TEST
924
925 /* Regression test for SF bug #483514. */
926 START_TEST(test_dtd_default_handling)
927 {
928 char *text =
929 "<!DOCTYPE doc [\n"
930 "<!ENTITY e SYSTEM 'http://xml.libexpat.org/e'>\n"
931 "<!NOTATION n SYSTEM 'http://xml.libexpat.org/n'>\n"
932 "<!ELEMENT doc EMPTY>\n"
933 "<!ATTLIST doc a CDATA #IMPLIED>\n"
934 "<?pi in dtd?>\n"
935 "<!--comment in dtd-->\n"
936 "]><doc/>";
937
938 XML_SetDefaultHandler(parser, accumulate_characters);
939 XML_SetDoctypeDeclHandler(parser,
940 dummy_start_doctype_handler,
941 dummy_end_doctype_handler);
942 XML_SetEntityDeclHandler(parser, dummy_entity_decl_handler);
943 XML_SetNotationDeclHandler(parser, dummy_notation_decl_handler);
944 XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
945 XML_SetAttlistDeclHandler(parser, dummy_attlist_decl_handler);
946 XML_SetProcessingInstructionHandler(parser, dummy_pi_handler);
947 XML_SetCommentHandler(parser, dummy_comment_handler);
948 run_character_check(text, "\n\n\n\n\n\n\n<doc/>");
949 }
950 END_TEST
951
952 /* See related SF bug #673791.
953 When namespace processing is enabled, setting the namespace URI for
954 a prefix is not allowed; this test ensures that it *is* allowed
955 when namespace processing is not enabled.
956 (See Namespaces in XML, section 2.)
957 */
958 START_TEST(test_empty_ns_without_namespaces)
959 {
960 char *text =
961 "<doc xmlns:prefix='http://www.example.com/'>\n"
962 " <e xmlns:prefix=''/>\n"
963 "</doc>";
964
965 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
966 xml_failure(parser);
967 }
968 END_TEST
969
970 /* Regression test for SF bug #824420.
971 Checks that an xmlns:prefix attribute set in an attribute's default
972 value isn't misinterpreted.
973 */
974 START_TEST(test_ns_in_attribute_default_without_namespaces)
975 {
976 char *text =
977 "<!DOCTYPE e:element [\n"
978 " <!ATTLIST e:element\n"
979 " xmlns:e CDATA 'http://example.com/'>\n"
980 " ]>\n"
981 "<e:element/>";
982
983 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
984 xml_failure(parser);
985 }
986 END_TEST
987
988 static char *long_character_data_text =
989 "<?xml version='1.0' encoding='iso-8859-1'?><s>"
990 "012345678901234567890123456789012345678901234567890123456789"
991 "012345678901234567890123456789012345678901234567890123456789"
992 "012345678901234567890123456789012345678901234567890123456789"
993 "012345678901234567890123456789012345678901234567890123456789"
994 "012345678901234567890123456789012345678901234567890123456789"
995 "012345678901234567890123456789012345678901234567890123456789"
996 "012345678901234567890123456789012345678901234567890123456789"
997 "012345678901234567890123456789012345678901234567890123456789"
998 "012345678901234567890123456789012345678901234567890123456789"
999 "012345678901234567890123456789012345678901234567890123456789"
1000 "012345678901234567890123456789012345678901234567890123456789"
1001 "012345678901234567890123456789012345678901234567890123456789"
1002 "012345678901234567890123456789012345678901234567890123456789"
1003 "012345678901234567890123456789012345678901234567890123456789"
1004 "012345678901234567890123456789012345678901234567890123456789"
1005 "012345678901234567890123456789012345678901234567890123456789"
1006 "012345678901234567890123456789012345678901234567890123456789"
1007 "012345678901234567890123456789012345678901234567890123456789"
1008 "012345678901234567890123456789012345678901234567890123456789"
1009 "012345678901234567890123456789012345678901234567890123456789"
1010 "</s>";
1011
1012 static XML_Bool resumable = XML_FALSE;
1013
1014 static void
1015 clearing_aborting_character_handler(void *userData,
1016 const XML_Char *s, int len)
1017 {
1018 XML_StopParser(parser, resumable);
1019 XML_SetCharacterDataHandler(parser, NULL);
1020 }
1021
1022 /* Regression test for SF bug #1515266: missing check of stopped
1023 parser in doContext() 'for' loop. */
1024 START_TEST(test_stop_parser_between_char_data_calls)
1025 {
1026 /* The sample data must be big enough that there are two calls to
1027 the character data handler from within the inner "for" loop of
1028 the XML_TOK_DATA_CHARS case in doContent(), and the character
1029 handler must stop the parser and clear the character data
1030 handler.
1031 */
1032 char *text = long_character_data_text;
1033
1034 XML_SetCharacterDataHandler(parser, clearing_aborting_character_handler);
1035 resumable = XML_FALSE;
1036 if (XML_Parse(parser, text, strlen(text), XML_TRUE) != XML_STATUS_ERROR)
1037 xml_failure(parser);
1038 if (XML_GetErrorCode(parser) != XML_ERROR_ABORTED)
1039 xml_failure(parser);
1040 }
1041 END_TEST
1042
1043 /* Regression test for SF bug #1515266: missing check of stopped
1044 parser in doContext() 'for' loop. */
1045 START_TEST(test_suspend_parser_between_char_data_calls)
1046 {
1047 /* The sample data must be big enough that there are two calls to
1048 the character data handler from within the inner "for" loop of
1049 the XML_TOK_DATA_CHARS case in doContent(), and the character
1050 handler must stop the parser and clear the character data
1051 handler.
1052 */
1053 char *text = long_character_data_text;
1054
1055 XML_SetCharacterDataHandler(parser, clearing_aborting_character_handler);
1056 resumable = XML_TRUE;
1057 if (XML_Parse(parser, text, strlen(text), XML_TRUE) != XML_STATUS_SUSPENDED)
1058 xml_failure(parser);
1059 if (XML_GetErrorCode(parser) != XML_ERROR_NONE)
1060 xml_failure(parser);
1061 }
1062 END_TEST
1063
1064
1065 /*
1066 * Namespaces tests.
1067 */
1068
1069 static void
1070 namespace_setup(void)
1071 {
1072 parser = XML_ParserCreateNS(NULL, ' ');
1073 if (parser == NULL)
1074 fail("Parser not created.");
1075 }
1076
1077 static void
1078 namespace_teardown(void)
1079 {
1080 basic_teardown();
1081 }
1082
1083 /* Check that an element name and attribute name match the expected values.
1084 The expected values are passed as an array reference of string pointers
1085 provided as the userData argument; the first is the expected
1086 element name, and the second is the expected attribute name.
1087 */
1088 static void XMLCALL
1089 triplet_start_checker(void *userData, const XML_Char *name,
1090 const XML_Char **atts)
1091 {
1092 char **elemstr = (char **)userData;
1093 char buffer[1024];
1094 if (strcmp(elemstr[0], name) != 0) {
1095 sprintf(buffer, "unexpected start string: '%s'", name);
1096 fail(buffer);
1097 }
1098 if (strcmp(elemstr[1], atts[0]) != 0) {
1099 sprintf(buffer, "unexpected attribute string: '%s'", atts[0]);
1100 fail(buffer);
1101 }
1102 }
1103
1104 /* Check that the element name passed to the end-element handler matches
1105 the expected value. The expected value is passed as the first element
1106 in an array of strings passed as the userData argument.
1107 */
1108 static void XMLCALL
1109 triplet_end_checker(void *userData, const XML_Char *name)
1110 {
1111 char **elemstr = (char **)userData;
1112 if (strcmp(elemstr[0], name) != 0) {
1113 char buffer[1024];
1114 sprintf(buffer, "unexpected end string: '%s'", name);
1115 fail(buffer);
1116 }
1117 }
1118
1119 START_TEST(test_return_ns_triplet)
1120 {
1121 char *text =
1122 "<foo:e xmlns:foo='http://expat.sf.net/' bar:a='12'\n"
1123 " xmlns:bar='http://expat.sf.net/'></foo:e>";
1124 char *elemstr[] = {
1125 "http://expat.sf.net/ e foo",
1126 "http://expat.sf.net/ a bar"
1127 };
1128 XML_SetReturnNSTriplet(parser, XML_TRUE);
1129 XML_SetUserData(parser, elemstr);
1130 XML_SetElementHandler(parser, triplet_start_checker, triplet_end_checker);
1131 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
1132 xml_failure(parser);
1133 }
1134 END_TEST
1135
1136 static void XMLCALL
1137 overwrite_start_checker(void *userData, const XML_Char *name,
1138 const XML_Char **atts)
1139 {
1140 CharData *storage = (CharData *) userData;
1141 CharData_AppendString(storage, "start ");
1142 CharData_AppendXMLChars(storage, name, -1);
1143 while (*atts != NULL) {
1144 CharData_AppendString(storage, "\nattribute ");
1145 CharData_AppendXMLChars(storage, *atts, -1);
1146 atts += 2;
1147 }
1148 CharData_AppendString(storage, "\n");
1149 }
1150
1151 static void XMLCALL
1152 overwrite_end_checker(void *userData, const XML_Char *name)
1153 {
1154 CharData *storage = (CharData *) userData;
1155 CharData_AppendString(storage, "end ");
1156 CharData_AppendXMLChars(storage, name, -1);
1157 CharData_AppendString(storage, "\n");
1158 }
1159
1160 static void
1161 run_ns_tagname_overwrite_test(char *text, char *result)
1162 {
1163 CharData storage;
1164 CharData_Init(&storage);
1165 XML_SetUserData(parser, &storage);
1166 XML_SetElementHandler(parser,
1167 overwrite_start_checker, overwrite_end_checker);
1168 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
1169 xml_failure(parser);
1170 CharData_CheckString(&storage, result);
1171 }
1172
1173 /* Regression test for SF bug #566334. */
1174 START_TEST(test_ns_tagname_overwrite)
1175 {
1176 char *text =
1177 "<n:e xmlns:n='http://xml.libexpat.org/'>\n"
1178 " <n:f n:attr='foo'/>\n"
1179 " <n:g n:attr2='bar'/>\n"
1180 "</n:e>";
1181 char *result =
1182 "start http://xml.libexpat.org/ e\n"
1183 "start http://xml.libexpat.org/ f\n"
1184 "attribute http://xml.libexpat.org/ attr\n"
1185 "end http://xml.libexpat.org/ f\n"
1186 "start http://xml.libexpat.org/ g\n"
1187 "attribute http://xml.libexpat.org/ attr2\n"
1188 "end http://xml.libexpat.org/ g\n"
1189 "end http://xml.libexpat.org/ e\n";
1190 run_ns_tagname_overwrite_test(text, result);
1191 }
1192 END_TEST
1193
1194 /* Regression test for SF bug #566334. */
1195 START_TEST(test_ns_tagname_overwrite_triplet)
1196 {
1197 char *text =
1198 "<n:e xmlns:n='http://xml.libexpat.org/'>\n"
1199 " <n:f n:attr='foo'/>\n"
1200 " <n:g n:attr2='bar'/>\n"
1201 "</n:e>";
1202 char *result =
1203 "start http://xml.libexpat.org/ e n\n"
1204 "start http://xml.libexpat.org/ f n\n"
1205 "attribute http://xml.libexpat.org/ attr n\n"
1206 "end http://xml.libexpat.org/ f n\n"
1207 "start http://xml.libexpat.org/ g n\n"
1208 "attribute http://xml.libexpat.org/ attr2 n\n"
1209 "end http://xml.libexpat.org/ g n\n"
1210 "end http://xml.libexpat.org/ e n\n";
1211 XML_SetReturnNSTriplet(parser, XML_TRUE);
1212 run_ns_tagname_overwrite_test(text, result);
1213 }
1214 END_TEST
1215
1216
1217 /* Regression test for SF bug #620343. */
1218 static void XMLCALL
1219 start_element_fail(void *userData,
1220 const XML_Char *name, const XML_Char **atts)
1221 {
1222 /* We should never get here. */
1223 fail("should never reach start_element_fail()");
1224 }
1225
1226 static void XMLCALL
1227 start_ns_clearing_start_element(void *userData,
1228 const XML_Char *prefix,
1229 const XML_Char *uri)
1230 {
1231 XML_SetStartElementHandler((XML_Parser) userData, NULL);
1232 }
1233
1234 START_TEST(test_start_ns_clears_start_element)
1235 {
1236 /* This needs to use separate start/end tags; using the empty tag
1237 syntax doesn't cause the problematic path through Expat to be
1238 taken.
1239 */
1240 char *text = "<e xmlns='http://xml.libexpat.org/'></e>";
1241
1242 XML_SetStartElementHandler(parser, start_element_fail);
1243 XML_SetStartNamespaceDeclHandler(parser, start_ns_clearing_start_element);
1244 XML_UseParserAsHandlerArg(parser);
1245 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
1246 xml_failure(parser);
1247 }
1248 END_TEST
1249
1250 /* Regression test for SF bug #616863. */
1251 static int XMLCALL
1252 external_entity_handler(XML_Parser parser,
1253 const XML_Char *context,
1254 const XML_Char *base,
1255 const XML_Char *systemId,
1256 const XML_Char *publicId)
1257 {
1258 intptr_t callno = 1 + (intptr_t)XML_GetUserData(parser);
1259 char *text;
1260 XML_Parser p2;
1261
1262 if (callno == 1)
1263 text = ("<!ELEMENT doc (e+)>\n"
1264 "<!ATTLIST doc xmlns CDATA #IMPLIED>\n"
1265 "<!ELEMENT e EMPTY>\n");
1266 else
1267 text = ("<?xml version='1.0' encoding='us-ascii'?>"
1268 "<e/>");
1269
1270 XML_SetUserData(parser, (void *) callno);
1271 p2 = XML_ExternalEntityParserCreate(parser, context, NULL);
1272 if (XML_Parse(p2, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR) {
1273 xml_failure(p2);
1274 return 0;
1275 }
1276 XML_ParserFree(p2);
1277 return 1;
1278 }
1279
1280 START_TEST(test_default_ns_from_ext_subset_and_ext_ge)
1281 {
1282 char *text =
1283 "<?xml version='1.0'?>\n"
1284 "<!DOCTYPE doc SYSTEM 'http://xml.libexpat.org/doc.dtd' [\n"
1285 " <!ENTITY en SYSTEM 'http://xml.libexpat.org/entity.ent'>\n"
1286 "]>\n"
1287 "<doc xmlns='http://xml.libexpat.org/ns1'>\n"
1288 "&en;\n"
1289 "</doc>";
1290
1291 XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
1292 XML_SetExternalEntityRefHandler(parser, external_entity_handler);
1293 /* We actually need to set this handler to tickle this bug. */
1294 XML_SetStartElementHandler(parser, dummy_start_element);
1295 XML_SetUserData(parser, NULL);
1296 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
1297 xml_failure(parser);
1298 }
1299 END_TEST
1300
1301 /* Regression test #1 for SF bug #673791. */
1302 START_TEST(test_ns_prefix_with_empty_uri_1)
1303 {
1304 char *text =
1305 "<doc xmlns:prefix='http://xml.libexpat.org/'>\n"
1306 " <e xmlns:prefix=''/>\n"
1307 "</doc>";
1308
1309 expect_failure(text,
1310 XML_ERROR_UNDECLARING_PREFIX,
1311 "Did not report re-setting namespace"
1312 " URI with prefix to ''.");
1313 }
1314 END_TEST
1315
1316 /* Regression test #2 for SF bug #673791. */
1317 START_TEST(test_ns_prefix_with_empty_uri_2)
1318 {
1319 char *text =
1320 "<?xml version='1.0'?>\n"
1321 "<docelem xmlns:pre=''/>";
1322
1323 expect_failure(text,
1324 XML_ERROR_UNDECLARING_PREFIX,
1325 "Did not report setting namespace URI with prefix to ''.");
1326 }
1327 END_TEST
1328
1329 /* Regression test #3 for SF bug #673791. */
1330 START_TEST(test_ns_prefix_with_empty_uri_3)
1331 {
1332 char *text =
1333 "<!DOCTYPE doc [\n"
1334 " <!ELEMENT doc EMPTY>\n"
1335 " <!ATTLIST doc\n"
1336 " xmlns:prefix CDATA ''>\n"
1337 "]>\n"
1338 "<doc/>";
1339
1340 expect_failure(text,
1341 XML_ERROR_UNDECLARING_PREFIX,
1342 "Didn't report attr default setting NS w/ prefix to ''.");
1343 }
1344 END_TEST
1345
1346 /* Regression test #4 for SF bug #673791. */
1347 START_TEST(test_ns_prefix_with_empty_uri_4)
1348 {
1349 char *text =
1350 "<!DOCTYPE doc [\n"
1351 " <!ELEMENT prefix:doc EMPTY>\n"
1352 " <!ATTLIST prefix:doc\n"
1353 " xmlns:prefix CDATA 'http://xml.libexpat.org/'>\n"
1354 "]>\n"
1355 "<prefix:doc/>";
1356 /* Packaged info expected by the end element handler;
1357 the weird structuring lets us re-use the triplet_end_checker()
1358 function also used for another test. */
1359 char *elemstr[] = {
1360 "http://xml.libexpat.org/ doc prefix"
1361 };
1362 XML_SetReturnNSTriplet(parser, XML_TRUE);
1363 XML_SetUserData(parser, elemstr);
1364 XML_SetEndElementHandler(parser, triplet_end_checker);
1365 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
1366 xml_failure(parser);
1367 }
1368 END_TEST
1369
1370 START_TEST(test_ns_default_with_empty_uri)
1371 {
1372 char *text =
1373 "<doc xmlns='http://xml.libexpat.org/'>\n"
1374 " <e xmlns=''/>\n"
1375 "</doc>";
1376 if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
1377 xml_failure(parser);
1378 }
1379 END_TEST
1380
1381 /* Regression test for SF bug #692964: two prefixes for one namespace. */
1382 START_TEST(test_ns_duplicate_attrs_diff_prefixes)
1383 {
1384 char *text =
1385 "<doc xmlns:a='http://xml.libexpat.org/a'\n"
1386 " xmlns:b='http://xml.libexpat.org/a'\n"
1387 " a:a='v' b:a='v' />";
1388 expect_failure(text,
1389 XML_ERROR_DUPLICATE_ATTRIBUTE,
1390 "did not report multiple attributes with same URI+name");
1391 }
1392 END_TEST
1393
1394 /* Regression test for SF bug #695401: unbound prefix. */
1395 START_TEST(test_ns_unbound_prefix_on_attribute)
1396 {
1397 char *text = "<doc a:attr=''/>";
1398 expect_failure(text,
1399 XML_ERROR_UNBOUND_PREFIX,
1400 "did not report unbound prefix on attribute");
1401 }
1402 END_TEST
1403
1404 /* Regression test for SF bug #695401: unbound prefix. */
1405 START_TEST(test_ns_unbound_prefix_on_element)
1406 {
1407 char *text = "<a:doc/>";
1408 expect_failure(text,
1409 XML_ERROR_UNBOUND_PREFIX,
1410 "did not report unbound prefix on element");
1411 }
1412 END_TEST
1413
1414 static Suite *
1415 make_suite(void)
1416 {
1417 Suite *s = suite_create("basic");
1418 TCase *tc_basic = tcase_create("basic tests");
1419 TCase *tc_namespace = tcase_create("XML namespaces");
1420
1421 suite_add_tcase(s, tc_basic);
1422 tcase_add_checked_fixture(tc_basic, basic_setup, basic_teardown);
1423 tcase_add_test(tc_basic, test_nul_byte);
1424 tcase_add_test(tc_basic, test_u0000_char);
1425 tcase_add_test(tc_basic, test_bom_utf8);
1426 tcase_add_test(tc_basic, test_bom_utf16_be);
1427 tcase_add_test(tc_basic, test_bom_utf16_le);
1428 tcase_add_test(tc_basic, test_illegal_utf8);
1429 tcase_add_test(tc_basic, test_utf16);
1430 tcase_add_test(tc_basic, test_utf16_le_epilog_newline);
1431 tcase_add_test(tc_basic, test_latin1_umlauts);
1432 /* Regression test for SF bug #491986. */
1433 tcase_add_test(tc_basic, test_danish_latin1);
1434 /* Regression test for SF bug #514281. */
1435 tcase_add_test(tc_basic, test_french_charref_hexidecimal);
1436 tcase_add_test(tc_basic, test_french_charref_decimal);
1437 tcase_add_test(tc_basic, test_french_latin1);
1438 tcase_add_test(tc_basic, test_french_utf8);
1439 tcase_add_test(tc_basic, test_utf8_false_rejection);
1440 tcase_add_test(tc_basic, test_line_number_after_parse);
1441 tcase_add_test(tc_basic, test_column_number_after_parse);
1442 tcase_add_test(tc_basic, test_line_and_column_numbers_inside_handlers);
1443 tcase_add_test(tc_basic, test_line_number_after_error);
1444 tcase_add_test(tc_basic, test_column_number_after_error);
1445 tcase_add_test(tc_basic, test_really_long_lines);
1446 tcase_add_test(tc_basic, test_end_element_events);
1447 tcase_add_test(tc_basic, test_attr_whitespace_normalization);
1448 tcase_add_test(tc_basic, test_xmldecl_misplaced);
1449 tcase_add_test(tc_basic, test_unknown_encoding_internal_entity);
1450 tcase_add_test(tc_basic,
1451 test_wfc_undeclared_entity_unread_external_subset);
1452 tcase_add_test(tc_basic, test_wfc_undeclared_entity_no_external_subset);
1453 tcase_add_test(tc_basic, test_wfc_undeclared_entity_standalone);
1454 tcase_add_test(tc_basic, test_wfc_undeclared_entity_with_external_subset);
1455 tcase_add_test(tc_basic,
1456 test_wfc_undeclared_entity_with_external_subset_standalone);
1457 tcase_add_test(tc_basic, test_wfc_no_recursive_entity_refs);
1458 tcase_add_test(tc_basic, test_ext_entity_set_encoding);
1459 tcase_add_test(tc_basic, test_dtd_default_handling);
1460 tcase_add_test(tc_basic, test_empty_ns_without_namespaces);
1461 tcase_add_test(tc_basic, test_ns_in_attribute_default_without_namespaces);
1462 tcase_add_test(tc_basic, test_stop_parser_between_char_data_calls);
1463 tcase_add_test(tc_basic, test_suspend_parser_between_char_data_calls);
1464
1465 suite_add_tcase(s, tc_namespace);
1466 tcase_add_checked_fixture(tc_namespace,
1467 namespace_setup, namespace_teardown);
1468 tcase_add_test(tc_namespace, test_return_ns_triplet);
1469 tcase_add_test(tc_namespace, test_ns_tagname_overwrite);
1470 tcase_add_test(tc_namespace, test_ns_tagname_overwrite_triplet);
1471 tcase_add_test(tc_namespace, test_start_ns_clears_start_element);
1472 tcase_add_test(tc_namespace, test_default_ns_from_ext_subset_and_ext_ge);
1473 tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_1);
1474 tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_2);
1475 tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_3);
1476 tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_4);
1477 tcase_add_test(tc_namespace, test_ns_default_with_empty_uri);
1478 tcase_add_test(tc_namespace, test_ns_duplicate_attrs_diff_prefixes);
1479 tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_attribute);
1480 tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_element);
1481
1482 return s;
1483 }
1484
1485
1486 int
1487 main(int argc, char *argv[])
1488 {
1489 int i, nf;
1490 int verbosity = CK_NORMAL;
1491 Suite *s = make_suite();
1492 SRunner *sr = srunner_create(s);
1493
1494 /* run the tests for internal helper functions */
1495 testhelper_is_whitespace_normalized();
1496
1497 for (i = 1; i < argc; ++i) {
1498 char *opt = argv[i];
1499 if (strcmp(opt, "-v") == 0 || strcmp(opt, "--verbose") == 0)
1500 verbosity = CK_VERBOSE;
1501 else if (strcmp(opt, "-q") == 0 || strcmp(opt, "--quiet") == 0)
1502 verbosity = CK_SILENT;
1503 else {
1504 fprintf(stderr, "runtests: unknown option '%s'\n", opt);
1505 return 2;
1506 }
1507 }
1508 if (verbosity != CK_SILENT)
1509 printf("Expat version: %s\n", XML_ExpatVersion());
1510 srunner_run_all(sr, verbosity);
1511 nf = srunner_ntests_failed(sr);
1512 srunner_free(sr);
1513
1514 return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
1515 }
wxWidgets (Impactor)