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