11 static XML_Parser parser;
17 parser = XML_ParserCreate(NULL);
19 fail("Parser not created.");
26 XML_ParserFree(parser);
29 /* Generate a failure using the parser state to create an error message;
30 this should be used when the parser reports an error we weren't
34 _xml_failure(XML_Parser parser, const char *file, int line)
38 "\n %s (line %d, offset %d)\n reported from %s, line %d",
39 XML_ErrorString(XML_GetErrorCode(parser)),
40 XML_GetCurrentLineNumber(parser),
41 XML_GetCurrentColumnNumber(parser),
46 #define xml_failure(parser) _xml_failure((parser), __FILE__, __LINE__)
49 _expect_failure(char *text, enum XML_Error errorCode, char *errorMessage,
50 char *file, int lineno)
52 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_OK)
54 if (XML_GetErrorCode(parser) != errorCode)
55 _xml_failure(parser, file, lineno);
58 #define expect_failure(text, errorCode, errorMessage) \
59 _expect_failure((text), (errorCode), (errorMessage), \
64 * Character & encoding tests.
67 START_TEST(test_nul_byte)
69 char text[] = "<doc>\0</doc>";
71 /* test that a NUL byte (in US-ASCII data) is an error */
72 if (XML_Parse(parser, text, sizeof(text) - 1, 1) == XML_STATUS_OK)
73 fail("Parser did not report error on NUL-byte.");
74 if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
80 START_TEST(test_u0000_char)
82 /* test that a NUL byte (in US-ASCII data) is an error */
83 expect_failure("<doc>�</doc>",
84 XML_ERROR_BAD_CHAR_REF,
85 "Parser did not report error on NUL-byte.");
89 START_TEST(test_bom_utf8)
91 /* This test is really just making sure we don't core on a UTF-8 BOM. */
92 char *text = "\357\273\277<e/>";
94 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
99 START_TEST(test_bom_utf16_be)
101 char text[] = "\376\377\0<\0e\0/\0>";
103 if (XML_Parse(parser, text, sizeof(text) - 1, 1) == XML_STATUS_ERROR)
108 START_TEST(test_bom_utf16_le)
110 char text[] = "\377\376<\0e\0/\0>\0";
112 if (XML_Parse(parser, text, sizeof(text) - 1, 1) == XML_STATUS_ERROR)
118 accumulate_characters(void *userData, const XML_Char *s, int len)
120 CharData_AppendXMLChars((CharData *)userData, s, len);
124 accumulate_attribute(void *userData, const XML_Char *name,
125 const XML_Char **atts)
127 CharData *storage = (CharData *)userData;
128 if (storage->count < 0 && atts != NULL && atts[0] != NULL) {
129 /* "accumulate" the value of the first attribute we see */
130 CharData_AppendXMLChars(storage, atts[1], -1);
136 run_character_check(XML_Char *text, XML_Char *expected)
140 CharData_Init(&storage);
141 XML_SetUserData(parser, &storage);
142 XML_SetCharacterDataHandler(parser, accumulate_characters);
143 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
145 CharData_CheckXMLChars(&storage, expected);
149 run_attribute_check(XML_Char *text, XML_Char *expected)
153 CharData_Init(&storage);
154 XML_SetUserData(parser, &storage);
155 XML_SetStartElementHandler(parser, accumulate_attribute);
156 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
158 CharData_CheckXMLChars(&storage, expected);
161 /* Regression test for SF bug #491986. */
162 START_TEST(test_danish_latin1)
165 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
166 "<e>Jørgen æøåÆØÅ</e>";
167 run_character_check(text,
168 "J\xC3\xB8rgen \xC3\xA6\xC3\xB8\xC3\xA5\xC3\x86\xC3\x98\xC3\x85");
173 /* Regression test for SF bug #514281. */
174 START_TEST(test_french_charref_hexidecimal)
177 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
178 "<doc>éèàçêÈ</doc>";
179 run_character_check(text,
180 "\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
184 START_TEST(test_french_charref_decimal)
187 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
188 "<doc>éèàçêÈ</doc>";
189 run_character_check(text,
190 "\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
194 START_TEST(test_french_latin1)
197 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
198 "<doc>\xE9\xE8\xE0\xE7\xEa\xC8</doc>";
199 run_character_check(text,
200 "\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
204 START_TEST(test_french_utf8)
207 "<?xml version='1.0' encoding='utf-8'?>\n"
208 "<doc>\xC3\xA9</doc>";
209 run_character_check(text, "\xC3\xA9");
213 /* Regression test for SF bug #600479.
214 XXX There should be a test that exercises all legal XML Unicode
215 characters as PCDATA and attribute value content, and XML Name
216 characters as part of element and attribute names.
218 START_TEST(test_utf8_false_rejection)
220 char *text = "<doc>\xEF\xBA\xBF</doc>";
221 run_character_check(text, "\xEF\xBA\xBF");
225 /* Regression test for SF bug #477667.
226 This test assures that any 8-bit character followed by a 7-bit
227 character will not be mistakenly interpreted as a valid UTF-8
230 START_TEST(test_illegal_utf8)
235 for (i = 128; i <= 255; ++i) {
236 sprintf(text, "<e>%ccd</e>", i);
237 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_OK) {
239 "expected token error for '%c' (ordinal %d) in UTF-8 text",
243 else if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
245 /* Reset the parser since we use the same parser repeatedly. */
246 XML_ParserReset(parser, NULL);
251 START_TEST(test_utf16)
253 /* <?xml version="1.0" encoding="UTF-16"?>
254 <doc a='123'>some text</doc>
257 "\000<\000?\000x\000m\000\154\000 \000v\000e\000r\000s\000i\000o"
258 "\000n\000=\000'\0001\000.\000\060\000'\000 \000e\000n\000c\000o"
259 "\000d\000i\000n\000g\000=\000'\000U\000T\000F\000-\0001\000\066"
260 "\000'\000?\000>\000\n"
261 "\000<\000d\000o\000c\000 \000a\000=\000'\0001\0002\0003\000'"
262 "\000>\000s\000o\000m\000e\000 \000t\000e\000x\000t\000<\000/"
263 "\000d\000o\000c\000>";
264 if (XML_Parse(parser, text, sizeof(text) - 1, 1) == XML_STATUS_ERROR)
269 START_TEST(test_utf16_le_epilog_newline)
271 int first_chunk_bytes = 17;
274 "<\000e\000/\000>\000" /* document element */
275 "\r\000\n\000\r\000\n\000"; /* epilog */
277 if (first_chunk_bytes >= sizeof(text) - 1)
278 fail("bad value of first_chunk_bytes");
279 if (XML_Parse(parser, text, first_chunk_bytes, 0) == XML_STATUS_ERROR)
283 rc = XML_Parse(parser, text + first_chunk_bytes,
284 sizeof(text) - first_chunk_bytes - 1, 1);
285 if (rc == XML_STATUS_ERROR)
291 /* Regression test for SF bug #481609. */
292 START_TEST(test_latin1_umlauts)
295 "<?xml version='1.0' encoding='iso-8859-1'?>\n"
296 "<e a='ä ö ü ä ö ü ä ö ü'\n"
297 " >ä ö ü ä ö ü ä ö ü</e>";
299 "\xC3\xA4 \xC3\xB6 \xC3\xBC "
300 "\xC3\xA4 \xC3\xB6 \xC3\xBC "
301 "\xC3\xA4 \xC3\xB6 \xC3\xBC";
302 run_character_check(text, utf8);
303 XML_ParserReset(parser, NULL);
304 run_attribute_check(text, utf8);
308 /* Regression test for SF bug #422239 (maybe).
309 It's not clear that this reproduces enough of the context
312 START_TEST(test_line_count)
319 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
321 lineno = XML_GetCurrentLineNumber(parser);
324 sprintf(buffer, "expected 3 lines, saw %d", lineno);
330 /* Regression test for SF bug #478332. */
331 START_TEST(test_really_long_lines)
333 /* This parses an input line longer than INIT_DATA_BUF_SIZE
334 characters long (defined to be 1024 in xmlparse.c). We take a
335 really cheesy approach to building the input buffer, because
336 this avoids writing bugs in buffer-filling code.
341 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
342 /* until we have at least 1024 characters on the line: */
343 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
344 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
345 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
346 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
347 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
348 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
349 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
350 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
351 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
352 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
353 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
354 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
355 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
356 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
357 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
358 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
360 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
367 * Element event tests.
371 end_element_event_handler(void *userData, const XML_Char *name)
373 CharData *storage = (CharData *) userData;
374 CharData_AppendString(storage, "/");
375 CharData_AppendXMLChars(storage, name, -1);
378 START_TEST(test_end_element_events)
380 char *text = "<a><b><c/></b><d><f/></d></a>";
381 char *expected = "/c/b/f/d/a";
384 CharData_Init(&storage);
385 XML_SetUserData(parser, &storage);
386 XML_SetEndElementHandler(parser, end_element_event_handler);
387 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
389 CharData_CheckString(&storage, expected);
398 /* Helpers used by the following test; this checks any "attr" and "refs"
399 attributes to make sure whitespace has been normalized.
401 Return true if whitespace has been normalized in a string, using
402 the rules for attribute value normalization. The 'is_cdata' flag
403 is needed since CDATA attributes don't need to have multiple
404 whitespace characters collapsed to a single space, while other
405 attribute data types do. (Section 3.3.3 of the recommendation.)
408 is_whitespace_normalized(const XML_Char *s, int is_cdata)
415 else if (*s == '\t' || *s == '\n' || *s == '\r')
420 if (blanks && !is_cdata)
421 /* illegal leading blanks */
424 else if (blanks > 1 && !is_cdata)
430 if (blanks && !is_cdata)
435 /* Check the attribute whitespace checker: */
437 testhelper_is_whitespace_normalized(void)
439 assert(is_whitespace_normalized("abc", 0));
440 assert(is_whitespace_normalized("abc", 1));
441 assert(is_whitespace_normalized("abc def ghi", 0));
442 assert(is_whitespace_normalized("abc def ghi", 1));
443 assert(!is_whitespace_normalized(" abc def ghi", 0));
444 assert(is_whitespace_normalized(" abc def ghi", 1));
445 assert(!is_whitespace_normalized("abc def ghi", 0));
446 assert(is_whitespace_normalized("abc def ghi", 1));
447 assert(!is_whitespace_normalized("abc def ghi ", 0));
448 assert(is_whitespace_normalized("abc def ghi ", 1));
449 assert(!is_whitespace_normalized(" ", 0));
450 assert(is_whitespace_normalized(" ", 1));
451 assert(!is_whitespace_normalized("\t", 0));
452 assert(!is_whitespace_normalized("\t", 1));
453 assert(!is_whitespace_normalized("\n", 0));
454 assert(!is_whitespace_normalized("\n", 1));
455 assert(!is_whitespace_normalized("\r", 0));
456 assert(!is_whitespace_normalized("\r", 1));
457 assert(!is_whitespace_normalized("abc\t def", 1));
461 check_attr_contains_normalized_whitespace(void *userData,
462 const XML_Char *name,
463 const XML_Char **atts)
466 for (i = 0; atts[i] != NULL; i += 2) {
467 const XML_Char *attrname = atts[i];
468 const XML_Char *value = atts[i + 1];
469 if (strcmp("attr", attrname) == 0
470 || strcmp("ents", attrname) == 0
471 || strcmp("refs", attrname) == 0) {
472 if (!is_whitespace_normalized(value, 0)) {
474 sprintf(buffer, "attribute value not normalized: %s='%s'",
482 START_TEST(test_attr_whitespace_normalization)
487 " attr NMTOKENS #REQUIRED\n"
488 " ents ENTITIES #REQUIRED\n"
489 " refs IDREFS #REQUIRED>\n"
491 "<doc attr=' a b c\t\td\te\t' refs=' id-1 \t id-2\t\t' \n"
492 " ents=' ent-1 \t\r\n"
498 XML_SetStartElementHandler(parser,
499 check_attr_contains_normalized_whitespace);
500 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
507 * XML declaration tests.
510 START_TEST(test_xmldecl_misplaced)
513 "<?xml version='1.0'?>\n"
515 XML_ERROR_MISPLACED_XML_PI,
516 "failed to report misplaced XML declaration");
520 /* Regression test for SF bug #584832. */
522 UnknownEncodingHandler(void *data,const XML_Char *encoding,XML_Encoding *info)
524 if (strcmp(encoding,"unsupported-encoding") == 0) {
526 for (i = 0; i < 256; ++i)
536 START_TEST(test_unknown_encoding_internal_entity)
539 "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
540 "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
543 XML_SetUnknownEncodingHandler(parser, UnknownEncodingHandler, NULL);
544 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
549 /* Test that no error is reported for unknown entities if we don't
550 read an external subset. This was fixed in Expat 1.95.5.
552 START_TEST(test_wfc_undeclared_entity_unread_external_subset) {
554 "<!DOCTYPE doc SYSTEM 'foo'>\n"
555 "<doc>&entity;</doc>";
557 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
562 /* Test that an error is reported for unknown entities if we don't
563 have an external subset.
565 START_TEST(test_wfc_undeclared_entity_no_external_subset) {
566 expect_failure("<doc>&entity;</doc>",
567 XML_ERROR_UNDEFINED_ENTITY,
568 "Parser did not report undefined entity w/out a DTD.");
572 /* Test that an error is reported for unknown entities if we don't
573 read an external subset, but have been declared standalone.
575 START_TEST(test_wfc_undeclared_entity_standalone) {
577 "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
578 "<!DOCTYPE doc SYSTEM 'foo'>\n"
579 "<doc>&entity;</doc>";
582 XML_ERROR_UNDEFINED_ENTITY,
583 "Parser did not report undefined entity (standalone).");
588 external_entity_loader(XML_Parser parser,
589 const XML_Char *context,
590 const XML_Char *base,
591 const XML_Char *systemId,
592 const XML_Char *publicId)
594 char *text = (char *)XML_GetUserData(parser);
595 XML_Parser extparser;
597 extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
598 if (extparser == NULL)
599 fail("Could not create external entity parser.");
600 if (XML_Parse(extparser, text, strlen(text), 1) == XML_STATUS_ERROR) {
607 /* Test that an error is reported for unknown entities if we have read
610 START_TEST(test_wfc_undeclared_entity_with_external_subset) {
612 "<?xml version='1.0' encoding='us-ascii'?>\n"
613 "<!DOCTYPE doc SYSTEM 'foo'>\n"
614 "<doc>&entity;</doc>";
616 "<!ELEMENT doc (#PCDATA)*>";
618 XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
619 XML_SetUserData(parser, foo_text);
620 XML_SetExternalEntityRefHandler(parser, external_entity_loader);
622 XML_ERROR_UNDEFINED_ENTITY,
623 "Parser did not report undefined entity with DTD.");
627 START_TEST(test_wfc_no_recursive_entity_refs)
631 " <!ENTITY entity '&entity;'>\n"
633 "<doc>&entity;</doc>";
636 XML_ERROR_RECURSIVE_ENTITY_REF,
637 "Parser did not report recursive entity reference.");
647 namespace_setup(void)
649 parser = XML_ParserCreateNS(NULL, ' ');
651 fail("Parser not created.");
655 namespace_teardown(void)
660 /* Check that an element name and attribute name match the expected values.
661 The expected values are passed as an array reference of string pointers
662 provided as the userData argument; the first is the expected
663 element name, and the second is the expected attribute name.
666 triplet_start_checker(void *userData, const XML_Char *name,
667 const XML_Char **atts)
669 char **elemstr = (char **)userData;
671 if (strcmp(elemstr[0], name) != 0) {
672 sprintf(buffer, "unexpected start string: '%s'", name);
675 if (strcmp(elemstr[1], atts[0]) != 0) {
676 sprintf(buffer, "unexpected attribute string: '%s'", atts[0]);
681 /* Check that the element name passed to the end-element handler matches
682 the expected value. The expected value is passed as the first element
683 in an array of strings passed as the userData argument.
686 triplet_end_checker(void *userData, const XML_Char *name)
688 char **elemstr = (char **)userData;
689 if (strcmp(elemstr[0], name) != 0) {
691 sprintf(buffer, "unexpected end string: '%s'", name);
696 START_TEST(test_return_ns_triplet)
699 "<foo:e xmlns:foo='http://expat.sf.net/' bar:a='12'\n"
700 " xmlns:bar='http://expat.sf.net/'></foo:e>";
702 "http://expat.sf.net/ e foo",
703 "http://expat.sf.net/ a bar"
705 XML_SetReturnNSTriplet(parser, 1);
706 XML_SetUserData(parser, elemstr);
707 XML_SetElementHandler(parser, triplet_start_checker, triplet_end_checker);
708 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
714 overwrite_start_checker(void *userData, const XML_Char *name,
715 const XML_Char **atts)
717 CharData *storage = (CharData *) userData;
718 CharData_AppendString(storage, "start ");
719 CharData_AppendXMLChars(storage, name, -1);
720 while (*atts != NULL) {
721 CharData_AppendString(storage, "\nattribute ");
722 CharData_AppendXMLChars(storage, *atts, -1);
725 CharData_AppendString(storage, "\n");
729 overwrite_end_checker(void *userData, const XML_Char *name)
731 CharData *storage = (CharData *) userData;
732 CharData_AppendString(storage, "end ");
733 CharData_AppendXMLChars(storage, name, -1);
734 CharData_AppendString(storage, "\n");
738 run_ns_tagname_overwrite_test(char *text, char *result)
741 CharData_Init(&storage);
742 XML_SetUserData(parser, &storage);
743 XML_SetElementHandler(parser,
744 overwrite_start_checker, overwrite_end_checker);
745 if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
747 CharData_CheckString(&storage, result);
750 /* Regression test for SF bug #566334. */
751 START_TEST(test_ns_tagname_overwrite)
754 "<n:e xmlns:n='http://xml.libexpat.org/'>\n"
755 " <n:f n:attr='foo'/>\n"
756 " <n:g n:attr2='bar'/>\n"
759 "start http://xml.libexpat.org/ e\n"
760 "start http://xml.libexpat.org/ f\n"
761 "attribute http://xml.libexpat.org/ attr\n"
762 "end http://xml.libexpat.org/ f\n"
763 "start http://xml.libexpat.org/ g\n"
764 "attribute http://xml.libexpat.org/ attr2\n"
765 "end http://xml.libexpat.org/ g\n"
766 "end http://xml.libexpat.org/ e\n";
767 run_ns_tagname_overwrite_test(text, result);
771 /* Regression test for SF bug #566334. */
772 START_TEST(test_ns_tagname_overwrite_triplet)
775 "<n:e xmlns:n='http://xml.libexpat.org/'>\n"
776 " <n:f n:attr='foo'/>\n"
777 " <n:g n:attr2='bar'/>\n"
780 "start http://xml.libexpat.org/ e n\n"
781 "start http://xml.libexpat.org/ f n\n"
782 "attribute http://xml.libexpat.org/ attr n\n"
783 "end http://xml.libexpat.org/ f n\n"
784 "start http://xml.libexpat.org/ g n\n"
785 "attribute http://xml.libexpat.org/ attr2 n\n"
786 "end http://xml.libexpat.org/ g n\n"
787 "end http://xml.libexpat.org/ e n\n";
788 XML_SetReturnNSTriplet(parser, 1);
789 run_ns_tagname_overwrite_test(text, result);
794 make_basic_suite(void)
796 Suite *s = suite_create("basic");
797 TCase *tc_basic = tcase_create("basic tests");
798 TCase *tc_namespace = tcase_create("XML namespaces");
800 suite_add_tcase(s, tc_basic);
801 tcase_add_checked_fixture(tc_basic, basic_setup, basic_teardown);
802 tcase_add_test(tc_basic, test_nul_byte);
803 tcase_add_test(tc_basic, test_u0000_char);
804 tcase_add_test(tc_basic, test_bom_utf8);
805 tcase_add_test(tc_basic, test_bom_utf16_be);
806 tcase_add_test(tc_basic, test_bom_utf16_le);
807 tcase_add_test(tc_basic, test_illegal_utf8);
808 tcase_add_test(tc_basic, test_utf16);
809 tcase_add_test(tc_basic, test_utf16_le_epilog_newline);
810 tcase_add_test(tc_basic, test_latin1_umlauts);
811 /* Regression test for SF bug #491986. */
812 tcase_add_test(tc_basic, test_danish_latin1);
813 /* Regression test for SF bug #514281. */
814 tcase_add_test(tc_basic, test_french_charref_hexidecimal);
815 tcase_add_test(tc_basic, test_french_charref_decimal);
816 tcase_add_test(tc_basic, test_french_latin1);
817 tcase_add_test(tc_basic, test_french_utf8);
818 tcase_add_test(tc_basic, test_utf8_false_rejection);
819 tcase_add_test(tc_basic, test_line_count);
820 tcase_add_test(tc_basic, test_really_long_lines);
821 tcase_add_test(tc_basic, test_end_element_events);
822 tcase_add_test(tc_basic, test_attr_whitespace_normalization);
823 tcase_add_test(tc_basic, test_xmldecl_misplaced);
824 tcase_add_test(tc_basic, test_unknown_encoding_internal_entity);
825 tcase_add_test(tc_basic,
826 test_wfc_undeclared_entity_unread_external_subset);
827 tcase_add_test(tc_basic, test_wfc_undeclared_entity_no_external_subset);
828 tcase_add_test(tc_basic, test_wfc_undeclared_entity_standalone);
829 tcase_add_test(tc_basic, test_wfc_undeclared_entity_with_external_subset);
830 tcase_add_test(tc_basic, test_wfc_no_recursive_entity_refs);
832 suite_add_tcase(s, tc_namespace);
833 tcase_add_checked_fixture(tc_namespace,
834 namespace_setup, namespace_teardown);
835 tcase_add_test(tc_namespace, test_return_ns_triplet);
836 tcase_add_test(tc_namespace, test_ns_tagname_overwrite);
837 tcase_add_test(tc_namespace, test_ns_tagname_overwrite_triplet);
844 main(int argc, char *argv[])
847 int forking = 0, forking_set = 0;
848 int verbosity = CK_NORMAL;
849 Suite *s = make_basic_suite();
850 SRunner *sr = srunner_create(s);
852 /* run the tests for internal helper functions */
853 testhelper_is_whitespace_normalized();
855 for (i = 1; i < argc; ++i) {
857 if (strcmp(opt, "-v") == 0 || strcmp(opt, "--verbose") == 0)
858 verbosity = CK_VERBOSE;
859 else if (strcmp(opt, "-q") == 0 || strcmp(opt, "--quiet") == 0)
860 verbosity = CK_SILENT;
861 else if (strcmp(opt, "-f") == 0 || strcmp(opt, "--fork") == 0) {
865 else if (strcmp(opt, "-n") == 0 || strcmp(opt, "--no-fork") == 0) {
870 fprintf(stderr, "runtests: unknown option '%s'\n", opt);
875 srunner_set_fork_status(sr, forking ? CK_FORK : CK_NOFORK);
876 srunner_run_all(sr, verbosity);
877 nf = srunner_ntests_failed(sr);
881 return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;