USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+#if defined(NDEBUG)
+# undef NDEBUG /* because test suite relies on assert(...) at the moment */
+#endif
+
#ifdef HAVE_EXPAT_CONFIG_H
-#include <expat_config.h>
+# include <expat_config.h>
#endif
#include <assert.h>
#include <stdint.h>
#include <stddef.h> /* ptrdiff_t */
#include <ctype.h>
-#ifndef __cplusplus
-# include <stdbool.h>
-#endif
#include <limits.h>
+#if ! defined(__cplusplus)
+# if defined(_MSC_VER) && (_MSC_VER <= 1700)
+ /* for vs2012/11.0/1700 and earlier Visual Studio compilers */
+# define bool int
+# define false 0
+# define true 1
+# else
+# include <stdbool.h>
+# endif
+#endif
+
+
#include "expat.h"
#include "chardata.h"
+#include "structdata.h"
#include "internal.h" /* for UNUSED_P only */
#include "minicheck.h"
#include "memcheck.h"
#include "ascii.h" /* for ASCII_xxx */
#ifdef XML_LARGE_SIZE
-#define XML_FMT_INT_MOD "ll"
+# define XML_FMT_INT_MOD "ll"
#else
-#define XML_FMT_INT_MOD "l"
+# define XML_FMT_INT_MOD "l"
#endif
-
-#if defined(NDEBUG)
-# error \
- The test suite relies on assert(...) at the moment. \
- You have NDEBUG defined which removes that code so that failures in the \
- test suite can go unnoticed. \
- \
- While we rely on assert(...), compiling the test suite with NDEBUG \
- defined is not supported.
-#endif
+#ifdef XML_UNICODE_WCHAR_T
+# define XML_FMT_CHAR "lc"
+# define XML_FMT_STR "ls"
+# include <wchar.h>
+# define xcstrlen(s) wcslen(s)
+# define xcstrcmp(s, t) wcscmp((s), (t))
+# define xcstrncmp(s, t, n) wcsncmp((s), (t), (n))
+# define XCS(s) _XCS(s)
+# define _XCS(s) L ## s
+#else
+# ifdef XML_UNICODE
+# error "No support for UTF-16 character without wchar_t in tests"
+# else
+# define XML_FMT_CHAR "c"
+# define XML_FMT_STR "s"
+# define xcstrlen(s) strlen(s)
+# define xcstrcmp(s, t) strcmp((s), (t))
+# define xcstrncmp(s, t, n) strncmp((s), (t), (n))
+# define XCS(s) s
+# endif /* XML_UNICODE */
+#endif /* XML_UNICODE_WCHAR_T */
static XML_Parser parser = NULL;
char buffer[1024];
enum XML_Error err = XML_GetErrorCode(parser);
sprintf(buffer,
- " %d: %s (line %" XML_FMT_INT_MOD "u, offset %"\
+ " %d: %" XML_FMT_STR " (line %"
+ XML_FMT_INT_MOD "u, offset %"
XML_FMT_INT_MOD "u)\n reported from %s, line %d\n",
err,
XML_ErrorString(err),
/* Useful external entity handler */
typedef struct ExtOption {
- const char *system_id;
+ const XML_Char *system_id;
const char *parse_text;
} ExtOption;
XML_Parser ext_parser;
while (options->parse_text != NULL) {
- if (!strcmp(systemId, options->system_id)) {
+ if (!xcstrcmp(systemId, options->system_id)) {
enum XML_Status rc;
ext_parser =
XML_ExternalEntityParserCreate(parser, context, NULL);
entity_value_to_match == NULL) {
return;
}
- if (!strcmp(entityName, entity_name_to_match)) {
+ if (!xcstrcmp(entityName, entity_name_to_match)) {
/* The cast here is safe because we control the horizontal and
* the vertical, and we therefore know our strings are never
* going to overflow an int.
*/
- if (value_length != (int)strlen(entity_value_to_match) ||
- strncmp(value, entity_value_to_match, value_length)) {
+ if (value_length != (int)xcstrlen(entity_value_to_match) ||
+ xcstrncmp(value, entity_value_to_match, value_length)) {
entity_match_flag = ENTITY_MATCH_FAIL;
} else {
entity_match_flag = ENTITY_MATCH_SUCCESS;
static void
-_run_character_check(const XML_Char *text, const XML_Char *expected,
+_run_character_check(const char *text, const XML_Char *expected,
const char *file, int line)
{
CharData storage;
_run_character_check(text, expected, __FILE__, __LINE__)
static void
-_run_attribute_check(const XML_Char *text, const XML_Char *expected,
+_run_attribute_check(const char *text, const XML_Char *expected,
const char *file, int line)
{
CharData storage;
typedef struct ExtTest {
const char *parse_text;
- const char *encoding;
- CharData *storage;
+ const XML_Char *encoding;
+ CharData *storage;
} ExtTest;
static void XMLCALL
}
static void
-_run_ext_character_check(const XML_Char *text,
+_run_ext_character_check(const char *text,
ExtTest *test_data,
const XML_Char *expected,
const char *file, int line)
const char *text =
"<?xml version='1.0' encoding='iso-8859-1'?>\n"
"<e>J\xF8rgen \xE6\xF8\xE5\xC6\xD8\xC5</e>";
- run_character_check(text,
- "J\xC3\xB8rgen \xC3\xA6\xC3\xB8\xC3\xA5\xC3\x86\xC3\x98\xC3\x85");
+#ifdef XML_UNICODE
+ const XML_Char *expected =
+ XCS("J\x00f8rgen \x00e6\x00f8\x00e5\x00c6\x00d8\x00c5");
+#else
+ const XML_Char *expected =
+ XCS("J\xC3\xB8rgen \xC3\xA6\xC3\xB8\xC3\xA5\xC3\x86\xC3\x98\xC3\x85");
+#endif
+ run_character_check(text, expected);
}
END_TEST
const char *text =
"<?xml version='1.0' encoding='iso-8859-1'?>\n"
"<doc>éèàçêÈ</doc>";
- run_character_check(text,
- "\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
+#ifdef XML_UNICODE
+ const XML_Char *expected =
+ XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
+#else
+ const XML_Char *expected =
+ XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
+#endif
+ run_character_check(text, expected);
}
END_TEST
const char *text =
"<?xml version='1.0' encoding='iso-8859-1'?>\n"
"<doc>éèàçêÈ</doc>";
- run_character_check(text,
- "\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
+#ifdef XML_UNICODE
+ const XML_Char *expected =
+ XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
+#else
+ const XML_Char *expected =
+ XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
+#endif
+ run_character_check(text, expected);
}
END_TEST
const char *text =
"<?xml version='1.0' encoding='iso-8859-1'?>\n"
"<doc>\xE9\xE8\xE0\xE7\xEa\xC8</doc>";
- run_character_check(text,
- "\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
+#ifdef XML_UNICODE
+ const XML_Char *expected =
+ XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
+#else
+ const XML_Char *expected =
+ XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
+#endif
+ run_character_check(text, expected);
}
END_TEST
const char *text =
"<?xml version='1.0' encoding='utf-8'?>\n"
"<doc>\xC3\xA9</doc>";
- run_character_check(text, "\xC3\xA9");
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00e9");
+#else
+ const XML_Char *expected = XCS("\xC3\xA9");
+#endif
+ run_character_check(text, expected);
}
END_TEST
START_TEST(test_utf8_false_rejection)
{
const char *text = "<doc>\xEF\xBA\xBF</doc>";
- run_character_check(text, "\xEF\xBA\xBF");
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\xfebf");
+#else
+ const XML_Char *expected = XCS("\xEF\xBA\xBF");
+#endif
+ run_character_check(text, expected);
}
END_TEST
const char * const fromLimInitially = fromLim;
ptrdiff_t actualMovementInChars;
- align_limit_to_full_utf8_characters(cases[i].input, &fromLim);
+ _INTERNAL_trim_to_complete_utf8_characters(cases[i].input, &fromLim);
actualMovementInChars = (fromLim - fromLimInitially);
if (actualMovementInChars != cases[i].expectedMovementInChars) {
"\000<\000d\000o\000c\000 \000a\000=\000'\0001\0002\0003\000'\000>"
"\000s\000o\000m\000e\000 \xff\x21\000 \000t\000e\000x\000t\000"
"<\000/\000d\000o\000c\000>";
- char expected[] = "some \357\274\241 text";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("some \xff21 text");
+#else
+ const XML_Char *expected = XCS("some \357\274\241 text");
+#endif
CharData storage;
CharData_Init(&storage);
{
const char *text = "<doc>Hi</doc>";
- if (!XML_SetEncoding(parser, "unknown-encoding"))
+ if (!XML_SetEncoding(parser, XCS("unknown-encoding")))
fail("XML_SetEncoding failed");
expect_failure(text,
XML_ERROR_UNKNOWN_ENCODING,
"<?xml version='1.0' encoding='iso-8859-1'?>\n"
"<e a='\xE4 \xF6 \xFC ä ö ü ä ö ü >'\n"
" >\xE4 \xF6 \xFC ä ö ü ä ö ü ></e>";
- const char *utf8 =
- "\xC3\xA4 \xC3\xB6 \xC3\xBC "
- "\xC3\xA4 \xC3\xB6 \xC3\xBC "
- "\xC3\xA4 \xC3\xB6 \xC3\xBC >";
- run_character_check(text, utf8);
+#ifdef XML_UNICODE
+ /* Expected results in UTF-16 */
+ const XML_Char *expected =
+ XCS("\x00e4 \x00f6 \x00fc ")
+ XCS("\x00e4 \x00f6 \x00fc ")
+ XCS("\x00e4 \x00f6 \x00fc >");
+#else
+ /* Expected results in UTF-8 */
+ const XML_Char *expected =
+ XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC ")
+ XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC ")
+ XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC >");
+#endif
+
+ run_character_check(text, expected);
XML_ParserReset(parser, NULL);
- run_attribute_check(text, utf8);
+ run_attribute_check(text, expected);
/* Repeat with a default handler */
XML_ParserReset(parser, NULL);
XML_SetDefaultHandler(parser, dummy_default_handler);
- run_character_check(text, utf8);
+ run_character_check(text, expected);
XML_ParserReset(parser, NULL);
XML_SetDefaultHandler(parser, dummy_default_handler);
- run_attribute_check(text, utf8);
+ run_attribute_check(text, expected);
}
END_TEST
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
/* Last character splits across a buffer boundary */
"\xe4'>\n</doc>";
- const char *expected =
+#ifdef XML_UNICODE
+ const XML_Char *expected =
/* 64 characters per line */
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
- "\xc3\xa4";
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO")
+ XCS("\x00e4");
+#else
+ const XML_Char *expected =
+ /* 64 characters per line */
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO")
+ XCS("\xc3\xa4");
+#endif
run_attribute_check(text, expected);
}
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"01234'>\n</doc>";
- const char *expected =
+ const XML_Char *expected =
/* 64 characters per line */
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "01234";
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("01234");
run_attribute_check(text, expected);
}
}
END_TEST
+#define STRUCT_START_TAG 0
+#define STRUCT_END_TAG 1
static void XMLCALL
start_element_event_handler2(void *userData, const XML_Char *name,
const XML_Char **UNUSED_P(attr))
{
- CharData *storage = (CharData *) userData;
- char buffer[100];
-
- sprintf(buffer,
- "<%s> at col:%" XML_FMT_INT_MOD "u line:%"\
- XML_FMT_INT_MOD "u\n", name,
- XML_GetCurrentColumnNumber(parser),
- XML_GetCurrentLineNumber(parser));
- CharData_AppendString(storage, buffer);
+ StructData *storage = (StructData *) userData;
+ StructData_AddItem(storage, name,
+ XML_GetCurrentColumnNumber(parser),
+ XML_GetCurrentLineNumber(parser),
+ STRUCT_START_TAG);
}
static void XMLCALL
end_element_event_handler2(void *userData, const XML_Char *name)
{
- CharData *storage = (CharData *) userData;
- char buffer[100];
-
- sprintf(buffer,
- "</%s> at col:%" XML_FMT_INT_MOD "u line:%"\
- XML_FMT_INT_MOD "u\n", name,
- XML_GetCurrentColumnNumber(parser),
- XML_GetCurrentLineNumber(parser));
- CharData_AppendString(storage, buffer);
+ StructData *storage = (StructData *) userData;
+ StructData_AddItem(storage, name,
+ XML_GetCurrentColumnNumber(parser),
+ XML_GetCurrentLineNumber(parser),
+ STRUCT_END_TAG);
}
/* Regression test #3 for SF bug #653180. */
" <f/>\n"
" </d>\n"
"</a>";
- const char *expected =
- "<a> at col:0 line:1\n"
- "<b> at col:2 line:2\n"
- "<c> at col:4 line:3\n"
- "</c> at col:8 line:3\n"
- "</b> at col:2 line:4\n"
- "<d> at col:2 line:5\n"
- "<f> at col:4 line:6\n"
- "</f> at col:8 line:6\n"
- "</d> at col:2 line:7\n"
- "</a> at col:0 line:8\n";
- CharData storage;
+ const StructDataEntry expected[] = {
+ { XCS("a"), 0, 1, STRUCT_START_TAG },
+ { XCS("b"), 2, 2, STRUCT_START_TAG },
+ { XCS("c"), 4, 3, STRUCT_START_TAG },
+ { XCS("c"), 8, 3, STRUCT_END_TAG },
+ { XCS("b"), 2, 4, STRUCT_END_TAG },
+ { XCS("d"), 2, 5, STRUCT_START_TAG },
+ { XCS("f"), 4, 6, STRUCT_START_TAG },
+ { XCS("f"), 8, 6, STRUCT_END_TAG },
+ { XCS("d"), 2, 7, STRUCT_END_TAG },
+ { XCS("a"), 0, 8, STRUCT_END_TAG }
+ };
+ const int expected_count = sizeof(expected) / sizeof(StructDataEntry);
+ StructData storage;
- CharData_Init(&storage);
+ StructData_Init(&storage);
XML_SetUserData(parser, &storage);
XML_SetStartElementHandler(parser, start_element_event_handler2);
XML_SetEndElementHandler(parser, end_element_event_handler2);
if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
- CharData_CheckString(&storage, expected);
+ StructData_CheckItems(&storage, expected, expected_count);
+ StructData_Dispose(&storage);
}
END_TEST
end_element_event_handler(void *userData, const XML_Char *name)
{
CharData *storage = (CharData *) userData;
- CharData_AppendString(storage, "/");
+ CharData_AppendXMLChars(storage, XCS("/"), 1);
CharData_AppendXMLChars(storage, name, -1);
}
START_TEST(test_end_element_events)
{
const char *text = "<a><b><c/></b><d><f/></d></a>";
- const char *expected = "/c/b/f/d/a";
+ const XML_Char *expected = XCS("/c/b/f/d/a");
CharData storage;
CharData_Init(&storage);
XML_SetEndElementHandler(parser, end_element_event_handler);
if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
- CharData_CheckString(&storage, expected);
+ CharData_CheckXMLChars(&storage, expected);
}
END_TEST
int blanks = 0;
int at_start = 1;
while (*s) {
- if (*s == ' ')
+ if (*s == XCS(' '))
++blanks;
- else if (*s == '\t' || *s == '\n' || *s == '\r')
+ else if (*s == XCS('\t') || *s == XCS('\n') || *s == XCS('\r'))
return 0;
else {
if (at_start) {
static void
testhelper_is_whitespace_normalized(void)
{
- assert(is_whitespace_normalized("abc", 0));
- assert(is_whitespace_normalized("abc", 1));
- assert(is_whitespace_normalized("abc def ghi", 0));
- assert(is_whitespace_normalized("abc def ghi", 1));
- assert(!is_whitespace_normalized(" abc def ghi", 0));
- assert(is_whitespace_normalized(" abc def ghi", 1));
- assert(!is_whitespace_normalized("abc def ghi", 0));
- assert(is_whitespace_normalized("abc def ghi", 1));
- assert(!is_whitespace_normalized("abc def ghi ", 0));
- assert(is_whitespace_normalized("abc def ghi ", 1));
- assert(!is_whitespace_normalized(" ", 0));
- assert(is_whitespace_normalized(" ", 1));
- assert(!is_whitespace_normalized("\t", 0));
- assert(!is_whitespace_normalized("\t", 1));
- assert(!is_whitespace_normalized("\n", 0));
- assert(!is_whitespace_normalized("\n", 1));
- assert(!is_whitespace_normalized("\r", 0));
- assert(!is_whitespace_normalized("\r", 1));
- assert(!is_whitespace_normalized("abc\t def", 1));
+ assert(is_whitespace_normalized(XCS("abc"), 0));
+ assert(is_whitespace_normalized(XCS("abc"), 1));
+ assert(is_whitespace_normalized(XCS("abc def ghi"), 0));
+ assert(is_whitespace_normalized(XCS("abc def ghi"), 1));
+ assert(!is_whitespace_normalized(XCS(" abc def ghi"), 0));
+ assert(is_whitespace_normalized(XCS(" abc def ghi"), 1));
+ assert(!is_whitespace_normalized(XCS("abc def ghi"), 0));
+ assert(is_whitespace_normalized(XCS("abc def ghi"), 1));
+ assert(!is_whitespace_normalized(XCS("abc def ghi "), 0));
+ assert(is_whitespace_normalized(XCS("abc def ghi "), 1));
+ assert(!is_whitespace_normalized(XCS(" "), 0));
+ assert(is_whitespace_normalized(XCS(" "), 1));
+ assert(!is_whitespace_normalized(XCS("\t"), 0));
+ assert(!is_whitespace_normalized(XCS("\t"), 1));
+ assert(!is_whitespace_normalized(XCS("\n"), 0));
+ assert(!is_whitespace_normalized(XCS("\n"), 1));
+ assert(!is_whitespace_normalized(XCS("\r"), 0));
+ assert(!is_whitespace_normalized(XCS("\r"), 1));
+ assert(!is_whitespace_normalized(XCS("abc\t def"), 1));
}
static void XMLCALL
for (i = 0; atts[i] != NULL; i += 2) {
const XML_Char *attrname = atts[i];
const XML_Char *value = atts[i + 1];
- if (strcmp("attr", attrname) == 0
- || strcmp("ents", attrname) == 0
- || strcmp("refs", attrname) == 0) {
+ if (xcstrcmp(XCS("attr"), attrname) == 0
+ || xcstrcmp(XCS("ents"), attrname) == 0
+ || xcstrcmp(XCS("refs"), attrname) == 0) {
if (!is_whitespace_normalized(value, 0)) {
char buffer[256];
- sprintf(buffer, "attribute value not normalized: %s='%s'",
+ sprintf(buffer, "attribute value not normalized: %"
+ XML_FMT_STR "='%" XML_FMT_STR "'",
attrname, value);
fail(buffer);
}
static int XMLCALL
UnknownEncodingHandler(void *UNUSED_P(data),const XML_Char *encoding,XML_Encoding *info)
{
- if (strcmp(encoding,"unsupported-encoding") == 0) {
+ if (xcstrcmp(encoding, XCS("unsupported-encoding")) == 0) {
int i;
for (i = 0; i < 256; ++i)
info->map[i] = i;
UTF-8, which we tell Expat using XML_SetEncoding().
*/
"<?xml encoding='iso-8859-3'?>\xC3\xA9",
- "utf-8",
+ XCS("utf-8"),
NULL
};
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00e9");
+#else
+ const XML_Char *expected = XCS("\xc3\xa9");
+#endif
XML_SetExternalEntityRefHandler(parser, external_entity_loader);
- run_ext_character_check(text, &test_data, "\xC3\xA9");
+ run_ext_character_check(text, &test_data, expected);
}
END_TEST
"<doc>&en;</doc>";
XML_SetDefaultHandler(parser, dummy_default_handler);
- run_character_check(text, "");
+ run_character_check(text, XCS(""));
}
END_TEST
"\xEF\xBB\xBF" /* BOM */
"<?xml encoding='iso-8859-3'?>"
"\xC3\xA9",
- "utf-8",
+ XCS("utf-8"),
NULL
};
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00e9");
+#else
+ const XML_Char *expected = XCS("\xc3\xa9");
+#endif
XML_SetExternalEntityRefHandler(parser, external_entity_loader);
- run_ext_character_check(text, &test_data, "\xC3\xA9");
+ run_ext_character_check(text, &test_data, expected);
}
END_TEST
{
const char *parse_text;
const char *fail_text;
- const char *encoding;
+ const XML_Char *encoding;
enum XML_Error error;
} ExtFaults;
ExtFaults fault = {
"<?xml encoding='iso-8859-3'?>u",
"Unsupported encoding not faulted",
- "unknown",
+ XCS("unknown"),
XML_ERROR_UNKNOWN_ENCODING
};
ExtFaults fault = {
"<!ELEMENT doc (#PCDATA)*>",
"Unknown encoding not faulted",
- "unknown-encoding",
+ XCS("unknown-encoding"),
XML_ERROR_UNKNOWN_ENCODING
};
XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
XML_SetExternalEntityRefHandler(parser, external_entity_loader);
- run_ext_character_check(text, &test_data, "");
+ run_ext_character_check(text, &test_data, XCS(""));
}
END_TEST
XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
XML_SetExternalEntityRefHandler(parser, external_entity_loader);
XML_SetNotStandaloneHandler(parser, accept_not_standalone_handler);
- run_ext_character_check(text, &test_data, "");
+ run_ext_character_check(text, &test_data, XCS(""));
/* Repeat wtihout the external entity handler */
XML_ParserReset(parser, NULL);
XML_SetNotStandaloneHandler(parser, accept_not_standalone_handler);
- run_character_check(text, "");
+ run_character_check(text, XCS(""));
}
END_TEST
XML_SetCommentHandler(parser, dummy_comment_handler);
XML_SetStartCdataSectionHandler(parser, dummy_start_cdata_handler);
XML_SetEndCdataSectionHandler(parser, dummy_end_cdata_handler);
- run_character_check(text, "\n\n\n\n\n\n\n<doc/>");
+ run_character_check(text, XCS("\n\n\n\n\n\n\n<doc/>"));
}
END_TEST
/* Test handling of attribute declarations */
typedef struct AttTest {
- const XML_Char *definition;
+ const char *definition;
const XML_Char *element_name;
const XML_Char *attr_name;
const XML_Char *attr_type;
{
AttTest *at = (AttTest *)userData;
- if (strcmp(element_name, at->element_name))
+ if (xcstrcmp(element_name, at->element_name))
fail("Unexpected element name in attribute declaration");
- if (strcmp(attr_name, at->attr_name))
+ if (xcstrcmp(attr_name, at->attr_name))
fail("Unexpected attribute name in attribute declaration");
- if (strcmp(attr_type, at->attr_type))
+ if (xcstrcmp(attr_type, at->attr_type))
fail("Unexpected attribute type in attribute declaration");
if ((default_value == NULL && at->default_value != NULL) ||
(default_value != NULL && at->default_value == NULL) ||
- (default_value != NULL && strcmp(default_value, at->default_value)))
+ (default_value != NULL && xcstrcmp(default_value, at->default_value)))
fail("Unexpected default value in attribute declaration");
if (is_required != at->is_required)
fail("Requirement mismatch in attribute declaration");
"<!ATTLIST doc a ( one | two | three ) #REQUIRED>\n"
"]>"
"<doc a='two'/>",
- "doc",
- "a",
- "(one|two|three)", /* Extraneous spaces will be removed */
+ XCS("doc"),
+ XCS("a"),
+ XCS("(one|two|three)"), /* Extraneous spaces will be removed */
NULL,
XML_TRUE
},
"<!ATTLIST doc a NOTATION (foo) #IMPLIED>\n"
"]>"
"<doc/>",
- "doc",
- "a",
- "NOTATION(foo)",
+ XCS("doc"),
+ XCS("a"),
+ XCS("NOTATION(foo)"),
NULL,
XML_FALSE
},
"<!ATTLIST doc a NOTATION (foo) 'bar'>\n"
"]>"
"<doc/>",
- "doc",
- "a",
- "NOTATION(foo)",
- "bar",
+ XCS("doc"),
+ XCS("a"),
+ XCS("NOTATION(foo)"),
+ XCS("bar"),
XML_FALSE
},
{
"<!ATTLIST doc a CDATA '\xdb\xb2'>\n"
"]>"
"<doc/>",
- "doc",
- "a",
- "CDATA",
- "\xdb\xb2",
+ XCS("doc"),
+ XCS("a"),
+ XCS("CDATA"),
+#ifdef XML_UNICODE
+ XCS("\x06f2"),
+#else
+ XCS("\xdb\xb2"),
+#endif
XML_FALSE
},
{ NULL, NULL, NULL, NULL, NULL, XML_FALSE }
START_TEST(test_good_cdata_ascii)
{
const char *text = "<a><![CDATA[<greeting>Hello, world!</greeting>]]></a>";
- const char *expected = "<greeting>Hello, world!</greeting>";
+ const XML_Char *expected = XCS("<greeting>Hello, world!</greeting>");
CharData storage;
CharData_Init(&storage);
" \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0""1\0""6\0'"
"\0?\0>\0\n"
"\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0[\0h\0e\0l\0l\0o\0]\0]\0>\0<\0/\0a\0>";
- const char *expected = "hello";
+ const XML_Char *expected = XCS("hello");
CharData storage;
CharData_Init(&storage);
" \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0""1\0""6\0'"
"\0?\0>\0\n"
"\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0[\0h\0e\0l\0l\0o\0]\0]\0>\0<\0/\0a\0>\0";
- const char *expected = "hello";
+ const XML_Char *expected = XCS("hello");
CharData storage;
CharData_Init(&storage);
A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16 A_TO_P_IN_UTF16
A_TO_P_IN_UTF16
"\0]\0]\0>\0<\0/\0a\0>";
- const char *expected =
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "ABCDEFGHIJKLMNOP";
+ const XML_Char *expected =
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
+ XCS("ABCDEFGHIJKLMNOP";)
CharData storage;
void *buffer;
* UTF-16: 0xd834 0xdd5e
* UTF-8: 0xf0 0x9d 0x85 0x9e
* and {CROTCHET} is U+1d15f (a crotchet or quarter-note)
- * UTF-16: 0xd834 0xdd5e
- * UTF-8: 0xf0 0x9d 0x85 0x9e
+ * UTF-16: 0xd834 0xdd5f
+ * UTF-8: 0xf0 0x9d 0x85 0x9f
*/
const char text[] =
"\0<\0?\0x\0m\0l\0"
"\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0["
"\xd8\x34\xdd\x5e\xd8\x34\xdd\x5f"
"\0]\0]\0>\0<\0/\0a\0>";
- const char *expected = "\xf0\x9d\x85\x9e\xf0\x9d\x85\x9f";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\xd834\xdd5e\xd834\xdd5f");
+#else
+ const XML_Char *expected = XCS("\xf0\x9d\x85\x9e\xf0\x9d\x85\x9f");
+#endif
CharData storage;
CharData_Init(&storage);
char message[1024];
sprintf(message,
- "Expected error %d (%s), got %d (%s) for case %lu\n",
+ "Expected error %d (%" XML_FMT_STR
+ "), got %d (%" XML_FMT_STR ") for case %lu\n",
cases[i].expected_error,
XML_ErrorString(cases[i].expected_error),
actual_error,
const XML_Char *UNUSED_P(s),
int UNUSED_P(len))
{
- CharData_AppendString((CharData *)userData, "D");
+ CharData_AppendXMLChars((CharData *)userData, XCS("D"), 1);
}
static void XMLCALL
const XML_Char *UNUSED_P(s),
int UNUSED_P(len))
{
- CharData_AppendString((CharData *)userData, "C");
+ CharData_AppendXMLChars((CharData *)userData, XCS("C"), 1);
XML_DefaultCurrent(parser);
}
const XML_Char *UNUSED_P(s),
int UNUSED_P(len))
{
- CharData_AppendString((CharData *)userData, "c");
+ CharData_AppendXMLChars((CharData *)userData, XCS("c"), 1);
}
static void XMLCALL
const XML_Char *UNUSED_P(entityName),
int is_parameter_entity)
{
- CharData_AppendString((CharData *)userData,
- is_parameter_entity ? "E" : "e");
+ CharData_AppendXMLChars((CharData *)userData,
+ is_parameter_entity ? XCS("E") : XCS("e"), 1);
}
/* Test XML_DefaultCurrent() passes handling on correctly */
if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
- CharData_CheckString(&storage, "DCDCDCDCDCDD");
+ CharData_CheckXMLChars(&storage, XCS("DCDCDCDCDCDD"));
/* Again, without the defaulting */
XML_ParserReset(parser, NULL);
if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
- CharData_CheckString(&storage, "DcccccD");
+ CharData_CheckXMLChars(&storage, XCS("DcccccD"));
/* Now with an internal entity to complicate matters */
XML_ParserReset(parser, NULL);
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
/* The default handler suppresses the entity */
- CharData_CheckString(&storage, "DDDDDDDDDDDDDDDDDDD");
+ CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDDD"));
/* Again, with a skip handler */
XML_ParserReset(parser, NULL);
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
/* The default handler suppresses the entity */
- CharData_CheckString(&storage, "DDDDDDDDDDDDDDDDDeD");
+ CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDeD"));
/* This time, allow the entity through */
XML_ParserReset(parser, NULL);
if (_XML_Parse_SINGLE_BYTES(parser, entity_text, strlen(entity_text),
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
- CharData_CheckString(&storage, "DDDDDDDDDDDDDDDDDCDD");
+ CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDCDD"));
/* Finally, without passing the cdata to the default handler */
XML_ParserReset(parser, NULL);
if (_XML_Parse_SINGLE_BYTES(parser, entity_text, strlen(entity_text),
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
- CharData_CheckString(&storage, "DDDDDDDDDDDDDDDDDcD");
+ CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDcD"));
}
END_TEST
START_TEST(test_set_base)
{
const XML_Char *old_base;
- const XML_Char *new_base = "/local/file/name.xml";
+ const XML_Char *new_base = XCS("/local/file/name.xml");
old_base = XML_GetBase(parser);
if (XML_SetBase(parser, new_base) != XML_STATUS_OK)
fail("Unable to set base");
- if (strcmp(XML_GetBase(parser), new_base) != 0)
+ if (xcstrcmp(XML_GetBase(parser), new_base) != 0)
fail("Base setting not correct");
if (XML_SetBase(parser, NULL) != XML_STATUS_OK)
fail("Unable to NULL base");
/* Test attribute counts, indexing, etc */
typedef struct attrInfo {
- const char *name;
- const char *value;
+ const XML_Char *name;
+ const XML_Char *value;
} AttrInfo;
typedef struct elementInfo {
- const char *name;
+ const XML_Char *name;
int attr_count;
- const char *id_name;
+ const XML_Char *id_name;
AttrInfo *attributes;
} ElementInfo;
int count, id, i;
while (info->name != NULL) {
- if (!strcmp(name, info->name))
+ if (!xcstrcmp(name, info->name))
break;
info++;
}
fail("ID not present");
return;
}
- if (id != -1 && strcmp(atts[id], info->id_name)) {
+ if (id != -1 && xcstrcmp(atts[id], info->id_name)) {
fail("ID does not have the correct name");
return;
}
for (i = 0; i < info->attr_count; i++) {
attr = info->attributes;
while (attr->name != NULL) {
- if (!strcmp(atts[0], attr->name))
+ if (!xcstrcmp(atts[0], attr->name))
break;
attr++;
}
fail("Attribute not recognised");
return;
}
- if (strcmp(atts[1], attr->value)) {
+ if (xcstrcmp(atts[1], attr->value)) {
fail("Attribute has wrong value");
return;
}
"<tag c='3'/>"
"</doc>";
AttrInfo doc_info[] = {
- { "a", "1" },
- { "b", "2" },
- { "id", "one" },
+ { XCS("a"), XCS("1") },
+ { XCS("b"), XCS("2") },
+ { XCS("id"), XCS("one") },
{ NULL, NULL }
};
AttrInfo tag_info[] = {
- { "c", "3" },
+ { XCS("c"), XCS("3") },
{ NULL, NULL }
};
ElementInfo info[] = {
- { "doc", 3, "id", NULL },
- { "tag", 1, NULL, NULL },
+ { XCS("doc"), 3, XCS("id"), NULL },
+ { XCS("tag"), 1, NULL, NULL },
{ NULL, 0, NULL, NULL }
};
info[0].attributes = doc_info;
START_TEST(test_cdata_default)
{
const char *text = "<doc><![CDATA[Hello\nworld]]></doc>";
+ const XML_Char *expected = XCS("<doc><![CDATA[Hello\nworld]]></doc>");
CharData storage;
CharData_Init(&storage);
if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
- CharData_CheckXMLChars(&storage, text);
+ CharData_CheckXMLChars(&storage, expected);
}
END_TEST
if (XML_SetEncoding(parser, NULL) != XML_STATUS_OK)
fail("Failed to initialise encoding to NULL");
/* Say we are UTF-8 */
- if (XML_SetEncoding(parser, "utf-8") != XML_STATUS_OK)
+ if (XML_SetEncoding(parser, XCS("utf-8")) != XML_STATUS_OK)
fail("Failed to set explicit encoding");
if (_XML_Parse_SINGLE_BYTES(parser, text1, strlen(text1),
XML_FALSE) == XML_STATUS_ERROR)
xml_failure(parser);
/* Try to switch encodings mid-parse */
- if (XML_SetEncoding(parser, "us-ascii") != XML_STATUS_ERROR)
+ if (XML_SetEncoding(parser, XCS("us-ascii")) != XML_STATUS_ERROR)
fail("Allowed encoding change");
if (_XML_Parse_SINGLE_BYTES(parser, text2, strlen(text2),
XML_TRUE) == XML_STATUS_ERROR)
/* Internal processing turns the CR into a newline for the
* character data handler, but not for the default handler
*/
- if (len == 1 && (*s == '\n' || *s == '\r'))
+ if (len == 1 && (*s == XCS('\n') || *s == XCS('\r')))
*pfound = 1;
}
{
int *pfound = (int *)userData;
- if (len == 1 && *s == ']')
+ if (len == 1 && *s == XCS(']'))
*pfound = 1;
}
{
const char *text =
"<a><![CDATA[<greeting>Hello, world!</greeting>]]></a>";
- const char *expected = "<greeting>Hello, world!</greeting>";
+ const XML_Char *expected = XCS("<greeting>Hello, world!</greeting>");
CharData storage;
XML_Parser ext_parser;
static void
byte_character_handler(void *userData,
- const XML_Char *s,
+ const XML_Char *UNUSED_P(s),
int len)
{
#ifdef XML_CONTEXT_BYTES
fail("Character byte index incorrect");
if (XML_GetCurrentByteCount(parser) != len)
fail("Character byte count incorrect");
- if (s != buffer + offset)
- fail("Buffer position incorrect");
#else
(void)userData;
- (void)s;
(void)len;
#endif
}
START_TEST(test_predefined_entities)
{
const char *text = "<doc><>&"'</doc>";
- const char *result = "<>&\"'";
+ const XML_Char *expected = XCS("<doc><>&"'</doc>");
+ const XML_Char *result = XCS("<>&\"'");
CharData storage;
XML_SetDefaultHandler(parser, accumulate_characters);
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
/* The default handler doesn't translate the entities */
- CharData_CheckXMLChars(&storage, text);
+ CharData_CheckXMLChars(&storage, expected);
/* Now try again and check the translation */
XML_ParserReset(parser, NULL);
if (ext_parser == NULL)
fail("Could not create external entity parser");
- if (!strcmp(systemId, "004-1.ent")) {
+ if (!xcstrcmp(systemId, XCS("004-1.ent"))) {
if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, strlen(text1),
XML_TRUE) != XML_STATUS_ERROR)
fail("Inner DTD with invalid tag not rejected");
if (XML_GetErrorCode(ext_parser) != XML_ERROR_EXTERNAL_ENTITY_HANDLING)
xml_failure(ext_parser);
}
- else if (!strcmp(systemId, "004-2.ent")) {
+ else if (!xcstrcmp(systemId, XCS("004-2.ent"))) {
if (_XML_Parse_SINGLE_BYTES(ext_parser, text2, strlen(text2),
XML_TRUE) != XML_STATUS_ERROR)
fail("Invalid tag in external param not rejected");
const char *text =
"<!DOCTYPE doc SYSTEM 'foo'>\n"
"<doc><e>&entity;</e></doc>";
- const char *expected =
- "<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&entity;";
+ const XML_Char *expected =
+ XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&entity;");
CharData storage;
CharData_Init(&storage);
/* <d><e>&en;</e></d> */
"<\0d\0>\0<\0e\0>\0&\0e\0n\0;\0<\0/\0e\0>\0<\0/\0d\0>\0";
const XML_Char *expected =
- "<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;";
+ XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;");
CharData storage;
CharData_Init(&storage);
/* <d><e>&en;</e></d> */
"\0<\0d\0>\0<\0e\0>\0&\0e\0n\0;\0<\0/\0e\0>\0<\0/\0d\0>";
const XML_Char *expected =
- "<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;";
+ XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;");
CharData storage;
CharData_Init(&storage);
ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
if (ext_parser == NULL)
fail("Could not create external entity parser");
- if (!strcmp(systemId, "004-1.ent")) {
+ if (!xcstrcmp(systemId, XCS("004-1.ent"))) {
if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, strlen(text1),
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(ext_parser);
}
- else if (!strcmp(systemId, "004-2.ent")) {
+ else if (!xcstrcmp(systemId, XCS("004-2.ent"))) {
ExtFaults *fault = (ExtFaults *)XML_GetUserData(parser);
enum XML_Status status;
enum XML_Error error;
ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
if (ext_parser == NULL)
fail("Could not create external entity parser");
- if (!strcmp(systemId, "foo")) {
+ if (!xcstrcmp(systemId, XCS("foo"))) {
XML_SetNotStandaloneHandler(ext_parser,
reject_not_standalone_handler);
if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, strlen(text1),
XML_ParserFree(ext_parser);
return XML_STATUS_ERROR;
}
- else if (!strcmp(systemId, "bar")) {
+ else if (!xcstrcmp(systemId, XCS("bar"))) {
if (_XML_Parse_SINGLE_BYTES(ext_parser, text2, strlen(text2),
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(ext_parser);
ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
if (ext_parser == NULL)
fail("Could not create external entity parser");
- if (!strcmp(systemId, "004-1.ent")) {
+ if (!xcstrcmp(systemId, XCS("004-1.ent"))) {
if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, strlen(text1),
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(ext_parser);
}
- if (!strcmp(systemId, "004-2.ent")) {
+ if (!xcstrcmp(systemId, XCS("004-2.ent"))) {
XML_SetXmlDeclHandler(ext_parser, entity_suspending_xdecl_handler);
XML_SetUserData(ext_parser, ext_parser);
if (_XML_Parse_SINGLE_BYTES(ext_parser, text2, strlen(text2),
NULL,
NULL
};
+ const XML_Char *expected = XCS("This is a \n \n\nyellow tiger");
XML_SetExternalEntityRefHandler(parser, external_entity_loader);
XML_SetUserData(parser, &dtd_data);
XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
/* An attribute list handler provokes a different code path */
XML_SetAttlistDeclHandler(parser, dummy_attlist_decl_handler);
- run_ext_character_check(text, &dtd_data,
- "This is a \n \n\nyellow tiger");
+ run_ext_character_check(text, &dtd_data, expected);
}
END_TEST
"<!ENTITY apos 'foo'>\n"
"]>\n"
"<doc>'</doc>";
- run_character_check(text, "'");
+ run_character_check(text, XCS("'"));
}
END_TEST
const XML_Char *name,
const XML_Char **UNUSED_P(atts))
{
- CharData_AppendString((CharData *)userData, name);
+ CharData_AppendXMLChars((CharData *)userData, name, xcstrlen(name));
}
START_TEST(test_nested_groups)
if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
- CharData_CheckString(&storage, "doce");
+ CharData_CheckXMLChars(&storage, XCS("doce"));
if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
fail("Element handler not fired");
}
ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
if (ext_parser == NULL)
return XML_STATUS_ERROR;
- if (systemId != NULL && !strcmp(systemId, "http://example.org/")) {
+ if (systemId != NULL && !xcstrcmp(systemId, XCS("http://example.org/"))) {
text = text1;
}
- else if (publicId != NULL && !strcmp(publicId, "foo")) {
+ else if (publicId != NULL && !xcstrcmp(publicId, XCS("foo"))) {
text = text2;
}
else
XML_Parser ext_parser;
int clear_handler = (intptr_t)XML_GetUserData(parser);
- if (systemId == NULL || !strcmp(systemId, "bar"))
+ if (systemId == NULL || !xcstrcmp(systemId, XCS("bar")))
return XML_STATUS_OK;
- if (strcmp(systemId, "foo"))
+ if (xcstrcmp(systemId, XCS("foo")))
fail("Unexpected system ID");
ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
if (ext_parser == NULL)
const XML_Char *s,
int len)
{
- const char *match = (const char *)userData;
+ const XML_Char *match = (const XML_Char *)userData;
if (match == NULL ||
- (strlen(match) == (unsigned)len &&
- !strncmp(match, s, len))) {
+ (xcstrlen(match) == (unsigned)len &&
+ !xcstrncmp(match, s, len))) {
XML_StopParser(parser, resumable);
XML_SetDefaultHandler(parser, NULL);
}
START_TEST(test_abort_epilog)
{
const char *text = "<doc></doc>\n\r\n";
- char match[] = "\r";
+ XML_Char match[] = XCS("\r");
XML_SetDefaultHandler(parser, selective_aborting_default_handler);
XML_SetUserData(parser, match);
START_TEST(test_abort_epilog_2)
{
const char *text = "<doc></doc>\n";
- char match[] = "\n";
+ XML_Char match[] = XCS("\n");
XML_SetDefaultHandler(parser, selective_aborting_default_handler);
XML_SetUserData(parser, match);
START_TEST(test_suspend_epilog)
{
const char *text = "<doc></doc>\n";
- char match[] = "\n";
+ XML_Char match[] = XCS("\n");
XML_SetDefaultHandler(parser, selective_aborting_default_handler);
XML_SetUserData(parser, match);
const XML_Char *name,
const XML_Char **UNUSED_P(atts))
{
- if (!strcmp(name, "suspend"))
+ if (!xcstrcmp(name, XCS("suspend")))
XML_StopParser(parser, XML_TRUE);
+ if (!xcstrcmp(name, XCS("abort")))
+ XML_StopParser(parser, XML_FALSE);
}
START_TEST(test_suspend_resume_internal_entity)
"<!ENTITY foo '<suspend>Hi<suspend>Ho</suspend></suspend>'>\n"
"]>\n"
"<doc>&foo;</doc>\n";
- const char *expected1 = "Hi";
- const char *expected2 = "HiHo";
+ const XML_Char *expected1 = XCS("Hi");
+ const XML_Char *expected2 = XCS("HiHo");
CharData storage;
CharData_Init(&storage);
if (XML_Parse(parser, text, strlen(text),
XML_TRUE) != XML_STATUS_SUSPENDED)
xml_failure(parser);
- CharData_CheckXMLChars(&storage, "");
+ CharData_CheckXMLChars(&storage, XCS(""));
if (XML_ResumeParser(parser) != XML_STATUS_SUSPENDED)
xml_failure(parser);
CharData_CheckXMLChars(&storage, expected1);
"%foo;\n"
"]>\n"
"<doc>Hello, world</doc>";
- const char *expected = "Hello, world";
+ const XML_Char *expected = XCS("Hello, world");
CharData storage;
CharData_Init(&storage);
if (XML_Parse(parser, text, strlen(text),
XML_TRUE) != XML_STATUS_SUSPENDED)
xml_failure(parser);
- CharData_CheckXMLChars(&storage, "");
+ CharData_CheckXMLChars(&storage, XCS(""));
if (XML_ResumeParser(parser) != XML_STATUS_OK)
xml_failure(parser);
CharData_CheckXMLChars(&storage, expected);
XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
XML_SetExternalEntityRefHandler(parser, external_entity_loader);
XML_SetEntityDeclHandler(parser, param_entity_match_handler);
- entity_name_to_match = PARAM_ENTITY_NAME;
- entity_value_to_match = PARAM_ENTITY_CORE_VALUE "\n";
+ entity_name_to_match = XCS(PARAM_ENTITY_NAME);
+ entity_value_to_match = XCS(PARAM_ENTITY_CORE_VALUE) XCS("\n");
entity_match_flag = ENTITY_MATCH_NOT_FOUND;
if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
XML_TRUE) == XML_STATUS_ERROR)
START_TEST(test_pi_handled_in_default)
{
const char *text = "<?test processing instruction?>\n<doc/>";
- const XML_Char *expected = "<?test processing instruction?>\n<doc/>";
+ const XML_Char *expected = XCS("<?test processing instruction?>\n<doc/>");
CharData storage;
CharData_Init(&storage);
START_TEST(test_comment_handled_in_default)
{
const char *text = "<!-- This is a comment -->\n<doc/>";
- const XML_Char *expected = "<!-- This is a comment -->\n<doc/>";
+ const XML_Char *expected = XCS("<!-- This is a comment -->\n<doc/>");
CharData storage;
CharData_Init(&storage);
CharData *storage = (CharData *)userData;
CharData_AppendXMLChars(storage, target, -1);
- CharData_AppendXMLChars(storage, ": ", 2);
+ CharData_AppendXMLChars(storage, XCS(": "), 2);
CharData_AppendXMLChars(storage, data, -1);
- CharData_AppendXMLChars(storage, "\n", 1);
+ CharData_AppendXMLChars(storage, XCS("\n"), 1);
}
START_TEST(test_pi_yml)
{
const char *text = "<?yml something like data?><doc/>";
- const XML_Char *expected = "yml: something like data\n";
+ const XML_Char *expected = XCS("yml: something like data\n");
CharData storage;
CharData_Init(&storage);
START_TEST(test_pi_xnl)
{
const char *text = "<?xnl nothing like data?><doc/>";
- const XML_Char *expected = "xnl: nothing like data\n";
+ const XML_Char *expected = XCS("xnl: nothing like data\n");
CharData storage;
CharData_Init(&storage);
START_TEST(test_pi_xmm)
{
const char *text = "<?xmm everything like data?><doc/>";
- const XML_Char *expected = "xmm: everything like data\n";
+ const XML_Char *expected = XCS("xmm: everything like data\n");
CharData storage;
CharData_Init(&storage);
"<\0?\0\x04\x0e\x08\x0e?\0>\0"
/* <q/> */
"<\0q\0/\0>\0";
- const XML_Char *expected = "\xe0\xb8\x84\xe0\xb8\x88: \n";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x0e04\x0e08: \n");
+#else
+ const XML_Char *expected = XCS("\xe0\xb8\x84\xe0\xb8\x88: \n");
+#endif
CharData storage;
CharData_Init(&storage);
"\0<\0?\x0e\x04\x0e\x08\0?\0>"
/* <q/> */
"\0<\0q\0/\0>";
- const XML_Char *expected = "\xe0\xb8\x84\xe0\xb8\x88: \n";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x0e04\x0e08: \n");
+#else
+ const XML_Char *expected = XCS("\xe0\xb8\x84\xe0\xb8\x88: \n");
+#endif
CharData storage;
CharData_Init(&storage);
"\0<\0!\0-\0-\0 \0C\0o\0m\0m\0e\0n\0t\0 \0A\0 \0-\0-\0>\0\n"
/* <doc/> */
"\0<\0d\0o\0c\0/\0>";
- const XML_Char *expected = " Comment A ";
+ const XML_Char *expected = XCS(" Comment A ");
CharData storage;
CharData_Init(&storage);
"<\0!\0-\0-\0 \0C\0o\0m\0m\0e\0n\0t\0 \0B\0 \0-\0-\0>\0\n\0"
/* <doc/> */
"<\0d\0o\0c\0/\0>\0";
- const XML_Char *expected = " Comment B ";
+ const XML_Char *expected = XCS(" Comment B ");
CharData storage;
CharData_Init(&storage);
int i;
int high_map = -2; /* Assume a 2-byte sequence */
- if (!strcmp(encoding, "invalid-9") ||
- !strcmp(encoding, "ascii-like") ||
- !strcmp(encoding, "invalid-len") ||
- !strcmp(encoding, "invalid-a") ||
- !strcmp(encoding, "invalid-surrogate") ||
- !strcmp(encoding, "invalid-high"))
+ if (!xcstrcmp(encoding, XCS("invalid-9")) ||
+ !xcstrcmp(encoding, XCS("ascii-like")) ||
+ !xcstrcmp(encoding, XCS("invalid-len")) ||
+ !xcstrcmp(encoding, XCS("invalid-a")) ||
+ !xcstrcmp(encoding, XCS("invalid-surrogate")) ||
+ !xcstrcmp(encoding, XCS("invalid-high")))
high_map = -1;
for (i = 0; i < 128; ++i)
info->map[i] = high_map;
/* If required, put an invalid value in the ASCII entries */
- if (!strcmp(encoding, "invalid-9"))
+ if (!xcstrcmp(encoding, XCS("invalid-9")))
info->map[9] = 5;
/* If required, have a top-bit set character starts a 5-byte sequence */
- if (!strcmp(encoding, "invalid-len"))
+ if (!xcstrcmp(encoding, XCS("invalid-len")))
info->map[0x81] = -5;
/* If required, make a top-bit set character a valid ASCII character */
- if (!strcmp(encoding, "invalid-a"))
+ if (!xcstrcmp(encoding, XCS("invalid-a")))
info->map[0x82] = 'a';
/* If required, give a top-bit set character a forbidden value,
* what would otherwise be the first of a surrogate pair.
*/
- if (!strcmp(encoding, "invalid-surrogate"))
+ if (!xcstrcmp(encoding, XCS("invalid-surrogate")))
info->map[0x83] = 0xd801;
/* If required, give a top-bit set character too high a value */
- if (!strcmp(encoding, "invalid-high"))
+ if (!xcstrcmp(encoding, XCS("invalid-high")))
info->map[0x84] = 0x010101;
info->data = data;
info->release = NULL;
- if (!strcmp(encoding, "failing-conv"))
+ if (!xcstrcmp(encoding, XCS("failing-conv")))
info->convert = failing_converter;
- else if (!strcmp(encoding, "prefix-conv"))
+ else if (!xcstrcmp(encoding, XCS("prefix-conv")))
info->convert = prefix_converter;
else
info->convert = NULL;
"<\x81\x64\x80oc>Hello, world</\x81\x64\x80oc>";
XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
- run_character_check(text, "Hello, world");
+ run_character_check(text, XCS("Hello, world"));
}
END_TEST
"<abcdefghabcdefghabcdefghijkl\x80m\x80n\x80o\x80p>"
"Hi"
"</abcdefghabcdefghabcdefghijkl\x80m\x80n\x80o\x80p>";
- const XML_Char *expected = "abcdefghabcdefghabcdefghijklmnop";
+ const XML_Char *expected = XCS("abcdefghabcdefghabcdefghijklmnop");
CharData storage;
CharData_Init(&storage);
"<abcdefghabcdefghabcdefghijklmnop>"
"Hi"
"</abcdefghabcdefghabcdefghijklmnop>";
- const XML_Char *expected = "abcdefghabcdefghabcdefghijklmnop";
+ const XML_Char *expected = XCS("abcdefghabcdefghabcdefghijklmnop");
CharData storage;
CharData_Init(&storage);
"<doc>Hello, world</doc>";
XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
- run_character_check(text, "Hello, world");
+ run_character_check(text, XCS("Hello, world"));
}
END_TEST
typedef struct ExtTest2 {
const char *parse_text;
int parse_len;
- const char *encoding;
+ const XML_Char *encoding;
CharData *storage;
enum ee_parse_flags flags;
} ExtTest2;
*/
"\xff\xfe\x4c\x20",
4,
- "iso-8859-1",
+ XCS("iso-8859-1"),
NULL,
EE_PARSE_NONE
};
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00ff\x00feL ");
+#else
/* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
- const XML_Char *expected = "\xc3\xbf\xc3\xbeL ";
+ const XML_Char *expected = XCS("\xc3\xbf\xc3\xbeL ");
+#endif
CharData storage;
*/
"\xfe\xff\x20\x4c",
4,
- "iso-8859-1",
+ XCS("iso-8859-1"),
NULL,
EE_PARSE_NONE
};
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00fe\x00ff L");
+#else
/* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
- const XML_Char *expected = "\xc3\xbe\xc3\xbf L";
+ const XML_Char *expected = XCS("\xc3\xbe\xc3\xbf L");
+#endif
CharData storage;
*/
"\xff\xfe\x4c\x20",
4,
- "iso-8859-1",
+ XCS("iso-8859-1"),
NULL,
EE_PARSE_FULL_BUFFER
};
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00ff\x00feL ");
+#else
/* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
- const XML_Char *expected = "\xc3\xbf\xc3\xbeL ";
+ const XML_Char *expected = XCS("\xc3\xbf\xc3\xbeL ");
+#endif
CharData storage;
*/
"\xfe\xff\x20\x4c",
4,
- "iso-8859-1",
+ XCS("iso-8859-1"),
NULL,
EE_PARSE_FULL_BUFFER
};
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00fe\x00ff L");
+#else
/* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
const XML_Char *expected = "\xc3\xbe\xc3\xbf L";
+#endif
CharData storage;
ExtTest2 test_data = {
"<\0e\0/\0>\0",
8,
- "utf-16be",
+ XCS("utf-16be"),
NULL,
EE_PARSE_NONE
};
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x3c00\x6500\x2f00\x3e00");
+#else
const XML_Char *expected =
- "\xe3\xb0\x80" /* U+3C00 */
- "\xe6\x94\x80" /* U+6A00 */
- "\xe2\xbc\x80" /* U+2F00 */
- "\xe3\xb8\x80"; /* U+3E00 */
+ XCS("\xe3\xb0\x80" /* U+3C00 */
+ "\xe6\x94\x80" /* U+6500 */
+ "\xe2\xbc\x80" /* U+2F00 */
+ "\xe3\xb8\x80"); /* U+3E00 */
+#endif
CharData storage;
CharData_Init(&storage);
ExtTest2 test_data = {
"\0<\0e\0/\0>",
8,
- "utf-16le",
+ XCS("utf-16le"),
NULL,
EE_PARSE_NONE
};
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x3c00\x6500\x2f00\x3e00");
+#else
const XML_Char *expected =
- "\xe3\xb0\x80" /* U+3C00 */
- "\xe6\x94\x80" /* U+6A00 */
- "\xe2\xbc\x80" /* U+2F00 */
- "\xe3\xb8\x80"; /* U+3E00 */
+ XCS("\xe3\xb0\x80" /* U+3C00 */
+ "\xe6\x94\x80" /* U+6500 */
+ "\xe2\xbc\x80" /* U+2F00 */
+ "\xe3\xb8\x80"); /* U+3E00 */
+#endif
CharData storage;
CharData_Init(&storage);
const char *parse_text;
int parse_len;
const char *fail_text;
- const char *encoding;
+ const XML_Char *encoding;
enum XML_Error error;
} ExtFaults2;
NULL,
EE_PARSE_NONE
};
- const XML_Char *expected = "\xef\xbb\x80";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\xfec0");
+#else
+ const XML_Char *expected = XCS("\xef\xbb\x80");
+#endif
CharData storage;
CharData_Init(&storage);
START_TEST(test_utf8_in_cdata_section)
{
const char *text = "<doc><![CDATA[one \xc3\xa9 two]]></doc>";
- const XML_Char *expected = "one \xc3\xa9 two";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("one \x00e9 two");
+#else
+ const XML_Char *expected = XCS("one \xc3\xa9 two");
+#endif
run_character_check(text, expected);
}
START_TEST(test_utf8_in_cdata_section_2)
{
const char *text = "<doc><![CDATA[\xc3\xa9]\xc3\xa9two]]></doc>";
- const XML_Char *expected = "\xc3\xa9]\xc3\xa9two";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00e9]\x00e9two");
+#else
+ const XML_Char *expected = XCS("\xc3\xa9]\xc3\xa9two");
+#endif
run_character_check(text, expected);
}
{
CharData *storage = (CharData *)userData;
- CharData_AppendXMLChars(storage, "/", 1);
+ CharData_AppendXMLChars(storage, XCS("/"), 1);
CharData_AppendXMLChars(storage, name, -1);
}
START_TEST(test_trailing_spaces_in_elements)
{
const char *text = "<doc >Hi</doc >";
- const XML_Char *expected = "doc/doc";
+ const XML_Char *expected = XCS("doc/doc");
CharData storage;
CharData_Init(&storage);
* and {CHO CHAN} = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
*/
"<\0d\0 \0\x04\x0e\x08\x0e=\0'\0a\0'\0/\0>\0";
- const XML_Char *expected = "a";
+ const XML_Char *expected = XCS("a");
CharData storage;
CharData_Init(&storage);
const char text[] =
"<\0d\0 \0a\0=\0'\0\x31\0'\0 \0"
"\x04\x0e\x08\x0e=\0'\0\x32\0'\0/\0>\0";
- const XML_Char *expected = "1";
+ const XML_Char *expected = XCS("1");
CharData storage;
CharData_Init(&storage);
CharData *storage = (CharData *)userData;
CharData_AppendXMLChars(storage, entityName, -1);
- CharData_AppendXMLChars(storage, "=", 1);
+ CharData_AppendXMLChars(storage, XCS("="), 1);
CharData_AppendXMLChars(storage, value, value_length);
- CharData_AppendXMLChars(storage, "\n", 1);
+ CharData_AppendXMLChars(storage, XCS("\n"), 1);
}
"\0%\x0e\x04\x0e\x08\0;\0\n"
"\0]\0>\0\n"
"\0<\0d\0o\0c\0>\0<\0/\0d\0o\0c\0>";
+#ifdef XML_UNICODE
const XML_Char *expected =
- "\xe0\xb8\x84\xe0\xb8\x88=<!ELEMENT doc (#PCDATA)>\n";
+ XCS("\x0e04\x0e08=<!ELEMENT doc (#PCDATA)>\n");
+#else
+ const XML_Char *expected =
+ XCS("\xe0\xb8\x84\xe0\xb8\x88=<!ELEMENT doc (#PCDATA)>\n");
+#endif
CharData storage;
CharData_Init(&storage);
ExtFaults fault = {
"<![IGNORE[<!ELEMENT \xffG (#PCDATA)*>]]>",
"Invalid character not faulted",
- "prefix-conv",
+ XCS("prefix-conv"),
XML_ERROR_INVALID_TOKEN
};
/* <e a='ä ä'></e> */
"\0<\0e\0 \0a\0=\0'\0&\0#\0\x32\0\x32\0\x38\0;\0 "
"\0&\0#\0x\0\x30\0\x30\0E\0\x34\0;\0'\0>\0<\0/\0e\0>";
- const XML_Char *expected = "\xc3\xa4 \xc3\xa4";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00e4 \x00e4");
+#else
+ const XML_Char *expected = XCS("\xc3\xa4 \xc3\xa4");
+#endif
CharData storage;
CharData_Init(&storage);
/* <e a='ä ä'></e> */
"<\0e\0 \0a\0=\0'\0&\0#\0\x32\0\x32\0\x38\0;\0 \0"
"&\0#\0x\0\x30\0\x30\0E\0\x34\0;\0'\0>\0<\0/\0e\0>\0";
- const XML_Char *expected = "\xc3\xa4 \xc3\xa4";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("\x00e4 \x00e4");
+#else
+ const XML_Char *expected = XCS("\xc3\xa4 \xc3\xa4");
+#endif
CharData storage;
CharData_Init(&storage);
NULL,
EE_PARSE_NONE
};
- const XML_Char *expected = "baz";
+ const XML_Char *expected = XCS("baz");
CharData storage;
CharData_Init(&storage);
NULL,
EE_PARSE_NONE
};
- const XML_Char *expected = "baz";
+ const XML_Char *expected = XCS("baz");
CharData storage;
CharData_Init(&storage);
}
END_TEST
+/* Test for issue #11, wrongly suppressed default handler */
+typedef struct default_check {
+ const XML_Char *expected;
+ const int expectedLen;
+ XML_Bool seen;
+} DefaultCheck;
+
+static void XMLCALL
+checking_default_handler(void *userData,
+ const XML_Char *s,
+ int len)
+{
+ DefaultCheck *data = (DefaultCheck *)userData;
+ int i;
+
+ for (i = 0; data[i].expected != NULL; i++) {
+ if (data[i].expectedLen == len &&
+ !memcmp(data[i].expected, s, len * sizeof(XML_Char))) {
+ data[i].seen = XML_TRUE;
+ break;
+ }
+ }
+}
+
+START_TEST(test_default_doctype_handler)
+{
+ const char *text =
+ "<!DOCTYPE doc PUBLIC 'pubname' 'test.dtd' [\n"
+ " <!ENTITY foo 'bar'>\n"
+ "]>\n"
+ "<doc>&foo;</doc>";
+ DefaultCheck test_data[] = {
+ {
+ XCS("'pubname'"),
+ 9,
+ XML_FALSE
+ },
+ {
+ XCS("'test.dtd'"),
+ 10,
+ XML_FALSE
+ },
+ { NULL, 0, XML_FALSE }
+ };
+ int i;
+
+ XML_SetUserData(parser, &test_data);
+ XML_SetDefaultHandler(parser, checking_default_handler);
+ XML_SetEntityDeclHandler(parser, dummy_entity_decl_handler);
+ if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
+ XML_TRUE) == XML_STATUS_ERROR)
+ xml_failure(parser);
+ for (i = 0; test_data[i].expected != NULL; i++)
+ if (!test_data[i].seen)
+ fail("Default handler not run for public !DOCTYPE");
+}
+END_TEST
+
+START_TEST(test_empty_element_abort)
+{
+ const char *text = "<abort/>";
+
+ XML_SetStartElementHandler(parser, start_element_suspender);
+ if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
+ XML_TRUE) != XML_STATUS_ERROR)
+ fail("Expected to error on abort");
+}
+END_TEST
+
/*
* Namespaces tests.
*/
static void
namespace_setup(void)
{
- parser = XML_ParserCreateNS(NULL, ' ');
+ parser = XML_ParserCreateNS(NULL, XCS(' '));
if (parser == NULL)
fail("Parser not created.");
}
triplet_start_checker(void *userData, const XML_Char *name,
const XML_Char **atts)
{
- char **elemstr = (char **)userData;
+ XML_Char **elemstr = (XML_Char **)userData;
char buffer[1024];
- if (strcmp(elemstr[0], name) != 0) {
- sprintf(buffer, "unexpected start string: '%s'", name);
+ if (xcstrcmp(elemstr[0], name) != 0) {
+ sprintf(buffer, "unexpected start string: '%" XML_FMT_STR "'", name);
fail(buffer);
}
- if (strcmp(elemstr[1], atts[0]) != 0) {
- sprintf(buffer, "unexpected attribute string: '%s'", atts[0]);
+ if (xcstrcmp(elemstr[1], atts[0]) != 0) {
+ sprintf(buffer, "unexpected attribute string: '%" XML_FMT_STR "'",
+ atts[0]);
fail(buffer);
}
triplet_start_flag = XML_TRUE;
static void XMLCALL
triplet_end_checker(void *userData, const XML_Char *name)
{
- char **elemstr = (char **)userData;
- if (strcmp(elemstr[0], name) != 0) {
+ XML_Char **elemstr = (XML_Char **)userData;
+ if (xcstrcmp(elemstr[0], name) != 0) {
char buffer[1024];
- sprintf(buffer, "unexpected end string: '%s'", name);
+ sprintf(buffer, "unexpected end string: '%" XML_FMT_STR "'", name);
fail(buffer);
}
triplet_end_flag = XML_TRUE;
"<foo:e xmlns:foo='http://example.org/' bar:a='12'\n"
" xmlns:bar='http://example.org/'>";
const char *epilog = "</foo:e>";
- const char *elemstr[] = {
- "http://example.org/ e foo",
- "http://example.org/ a bar"
+ const XML_Char *elemstr[] = {
+ XCS("http://example.org/ e foo"),
+ XCS("http://example.org/ a bar")
};
XML_SetReturnNSTriplet(parser, XML_TRUE);
XML_SetUserData(parser, elemstr);
const XML_Char **atts)
{
CharData *storage = (CharData *) userData;
- CharData_AppendString(storage, "start ");
+ CharData_AppendXMLChars(storage, XCS("start "), 6);
CharData_AppendXMLChars(storage, name, -1);
while (*atts != NULL) {
- CharData_AppendString(storage, "\nattribute ");
+ CharData_AppendXMLChars(storage, XCS("\nattribute "), 11);
CharData_AppendXMLChars(storage, *atts, -1);
atts += 2;
}
- CharData_AppendString(storage, "\n");
+ CharData_AppendXMLChars(storage, XCS("\n"), 1);
}
static void XMLCALL
overwrite_end_checker(void *userData, const XML_Char *name)
{
CharData *storage = (CharData *) userData;
- CharData_AppendString(storage, "end ");
+ CharData_AppendXMLChars(storage, XCS("end "), 4);
CharData_AppendXMLChars(storage, name, -1);
- CharData_AppendString(storage, "\n");
+ CharData_AppendXMLChars(storage, XCS("\n"), 1);
}
static void
-run_ns_tagname_overwrite_test(const char *text, const char *result)
+run_ns_tagname_overwrite_test(const char *text, const XML_Char *result)
{
CharData storage;
CharData_Init(&storage);
overwrite_start_checker, overwrite_end_checker);
if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
- CharData_CheckString(&storage, result);
+ CharData_CheckXMLChars(&storage, result);
}
/* Regression test for SF bug #566334. */
" <n:f n:attr='foo'/>\n"
" <n:g n:attr2='bar'/>\n"
"</n:e>";
- const char *result =
- "start http://example.org/ e\n"
- "start http://example.org/ f\n"
- "attribute http://example.org/ attr\n"
- "end http://example.org/ f\n"
- "start http://example.org/ g\n"
- "attribute http://example.org/ attr2\n"
- "end http://example.org/ g\n"
- "end http://example.org/ e\n";
+ const XML_Char *result =
+ XCS("start http://example.org/ e\n")
+ XCS("start http://example.org/ f\n")
+ XCS("attribute http://example.org/ attr\n")
+ XCS("end http://example.org/ f\n")
+ XCS("start http://example.org/ g\n")
+ XCS("attribute http://example.org/ attr2\n")
+ XCS("end http://example.org/ g\n")
+ XCS("end http://example.org/ e\n");
run_ns_tagname_overwrite_test(text, result);
}
END_TEST
" <n:f n:attr='foo'/>\n"
" <n:g n:attr2='bar'/>\n"
"</n:e>";
- const char *result =
- "start http://example.org/ e n\n"
- "start http://example.org/ f n\n"
- "attribute http://example.org/ attr n\n"
- "end http://example.org/ f n\n"
- "start http://example.org/ g n\n"
- "attribute http://example.org/ attr2 n\n"
- "end http://example.org/ g n\n"
- "end http://example.org/ e n\n";
+ const XML_Char *result =
+ XCS("start http://example.org/ e n\n")
+ XCS("start http://example.org/ f n\n")
+ XCS("attribute http://example.org/ attr n\n")
+ XCS("end http://example.org/ f n\n")
+ XCS("start http://example.org/ g n\n")
+ XCS("attribute http://example.org/ attr2 n\n")
+ XCS("end http://example.org/ g n\n")
+ XCS("end http://example.org/ e n\n");
XML_SetReturnNSTriplet(parser, XML_TRUE);
run_ns_tagname_overwrite_test(text, result);
}
/* Packaged info expected by the end element handler;
the weird structuring lets us re-use the triplet_end_checker()
function also used for another test. */
- const char *elemstr[] = {
- "http://example.org/ doc prefix"
+ const XML_Char *elemstr[] = {
+ XCS("http://example.org/ doc prefix")
};
XML_SetReturnNSTriplet(parser, XML_TRUE);
XML_SetUserData(parser, elemstr);
" xmlns:foo='http://example.org/' bar:a='12'\n"
" xmlns:bar='http://example.org/'>"
"</foo:thisisalongenoughelementnametotriggerareallocation>";
- const char *elemstr[] = {
- "http://example.org/"
- " thisisalongenoughelementnametotriggerareallocation foo",
- "http://example.org/ a bar"
+ const XML_Char *elemstr[] = {
+ XCS("http://example.org/")
+ XCS(" thisisalongenoughelementnametotriggerareallocation foo"),
+ XCS("http://example.org/ a bar")
};
XML_SetReturnNSTriplet(parser, XML_TRUE);
/* Exercises a particular string pool growth path */
START_TEST(test_ns_extremely_long_prefix)
{
- const char *text =
+ /* C99 compilers are only required to support 4095-character
+ * strings, so the following needs to be split in two to be safe
+ * for all compilers.
+ */
+ const char *text1 =
"<doc "
/* 64 character on each line */
/* ...gives a total length of 2048 */
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- ":a='12' xmlns:"
+ ":a='12'";
+ const char *text2 =
+ " xmlns:"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"='foo'\n>"
"</doc>";
- if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
+ if (_XML_Parse_SINGLE_BYTES(parser, text1, strlen(text1),
XML_FALSE) == XML_STATUS_ERROR)
xml_failure(parser);
+ if (_XML_Parse_SINGLE_BYTES(parser, text2, strlen(text2),
+ XML_TRUE) == XML_STATUS_ERROR)
+ xml_failure(parser);
}
END_TEST
"<foo:e xmlns:foo='http://example.org/'>Hi</foo:e>";
XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
- run_character_check(text, "Hi");
+ run_character_check(text, XCS("Hi"));
}
END_TEST
*/
"<\0n\0:\0e\0 \0x\0m\0l\0n\0s\0:\0n\0=\0'\0U\0R\0I\0'\0 \0"
"n\0:\0\x04\x0e=\0'\0a\0'\0 \0/\0>\0";
- const XML_Char *expected = "a";
+ const XML_Char *expected = XCS("a");
CharData storage;
CharData_Init(&storage);
* where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
*/
"\0<\0n\0:\x0e\x04\0 \0x\0m\0l\0n\0s\0:\0n\0=\0'\0U\0R\0I\0'\0/\0>";
- const XML_Char *expected = "URI \xe0\xb8\x84";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("URI \x0e04");
+#else
+ const XML_Char *expected = XCS("URI \xe0\xb8\x84");
+#endif
CharData storage;
CharData_Init(&storage);
"\0x\0m\0l\0n\0s\0:\0f\0o\0o\0=\0'\0U\0R\0I\0'\0>"
"\0&\0b\0a\0r\0;"
"\0<\0/\0f\0o\0o\0:\x0e\x04\0>";
- const XML_Char *expected = "URI \xe0\xb8\x84";
+#ifdef XML_UNICODE
+ const XML_Char *expected = XCS("URI \x0e04");
+#else
+ const XML_Char *expected = XCS("URI \xe0\xb8\x84");
+#endif
CharData storage;
CharData_Init(&storage);
/* Try several levels of allocation */
for (i = 0; i < max_alloc_count; i++) {
allocation_count = i;
- parser = XML_ParserCreate_MM("us-ascii", &memsuite, NULL);
+ parser = XML_ParserCreate_MM(XCS("us-ascii"), &memsuite, NULL);
if (parser != NULL)
break;
}
if (!versions_equal(&read_version, &parsed_version))
fail("Version mismatch");
-#if ! defined(XML_UNICODE)
- if (strcmp(version_text, "expat_2.2.4")) /* needs bump on releases */
+#if ! defined(XML_UNICODE) || defined(XML_UNICODE_WCHAR_T)
+ if (xcstrcmp(version_text, XCS("expat_2.2.5"))) /* needs bump on releases */
fail("XML_*_VERSION in expat.h out of sync?\n");
-#endif /* ! defined(XML_UNICODE) */
+#else
+ /* If we have XML_UNICODE defined but not XML_UNICODE_WCHAR_T
+ * then XML_LChar is defined as char, for some reason.
+ */
+ if (strcmp(version_text, "expat_2.2.5")) /* needs bump on releases */
+ fail("XML_*_VERSION in expat.h out of sync?\n");
+#endif /* ! defined(XML_UNICODE) || defined(XML_UNICODE_WCHAR_T) */
}
END_TEST
tracking_free
};
- parser = XML_ParserCreate_MM("UTF-8", &memsuite, "\n");
+ parser = XML_ParserCreate_MM(XCS("UTF-8"), &memsuite, XCS("\n"));
expect_failure(text, XML_ERROR_UNBOUND_PREFIX,
"Unbound prefixes not found");
XML_ParserFree(parser);
"<\0?\0x\0m\0l\0 \0"
"v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0?\0>\0"
"<\0q\0>\0H\0i\0<\0/\0q\0>\0";
- const XML_Char *expected = "Hi";
+ const XML_Char *expected = XCS("Hi");
CharData storage;
- parser = XML_ParserCreate("UTF-16LE");
+ parser = XML_ParserCreate(XCS("UTF-16LE"));
if (parser == NULL)
fail("Parser not created");
ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
if (ext_parser == NULL)
return XML_STATUS_ERROR;
- if (!XML_SetEncoding(ext_parser, "utf-8")) {
+ if (!XML_SetEncoding(ext_parser, XCS("utf-8"))) {
XML_ParserFree(ext_parser);
return XML_STATUS_ERROR;
}
const XML_Char *encoding,
XML_Encoding *info)
{
- if (!strcmp(encoding, "unsupported-encoding")) {
+ if (!xcstrcmp(encoding, XCS("unsupported-encoding"))) {
int i;
for (i = 0; i < 256; i++)
"<!--comment in dtd-->\n"
"]>\n"
"<doc><![CDATA[text in doc]]></doc>";
- const char *expected = "\n\n\n\n\n\n\n\n\n<doc>text in doc</doc>";
+ const XML_Char *expected = XCS("\n\n\n\n\n\n\n\n\n<doc>text in doc</doc>");
CharData storage;
int i;
const int max_alloc_count = 25;
for (i = 0; i < max_alloc_count; i++) {
allocation_count = i;
- if (XML_SetEncoding(parser, "us-ascii") == XML_STATUS_OK)
+ if (XML_SetEncoding(parser, XCS("us-ascii")) == XML_STATUS_OK)
break;
}
if (i == 0)
/* Test robustness of XML_SetBase against a failing allocator */
START_TEST(test_alloc_set_base)
{
- const XML_Char *new_base = "/local/file/name.xml";
+ const XML_Char *new_base = XCS("/local/file/name.xml");
int i;
const int max_alloc_count = 5;
fail("Parse succeeded despite failing reallocator");
if (i == max_alloc_count)
fail("Parse failed at maximum reallocation count");
- CharData_CheckString(&storage, "doce");
+ CharData_CheckXMLChars(&storage, XCS("doce"));
if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
fail("Element handler not fired");
}
fail("Parse succeeded despite failing reallocator");
if (i == max_realloc_count)
fail("Parse failed at maximum reallocation count");
- CharData_CheckString(&storage, "doce");
+ CharData_CheckXMLChars(&storage, XCS("doce"));
if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
fail("Element handler not fired");
}
"]>\n"
"<doc>&e;</doc>";
char entity_text[] = "Hello world";
- const char *base =
+ const XML_Char *base =
/* 64 characters per line */
- "LongBaseURI/that/will/overflow/an/internal/buffer/and/cause/it/t"
- "o/have/to/grow/PQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/";
+ XCS("LongBaseURI/that/will/overflow/an/internal/buffer/and/cause/it/t")
+ XCS("o/have/to/grow/PQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/");
int i;
const int max_alloc_count = 25;
"]>\n"
"<doc>&e2;</doc>";
ExtOption options[] = {
- { "foo", "Entity Foo" },
- { "bar", "Entity Bar" },
+ { XCS("foo"), "Entity Foo" },
+ { XCS("bar"), "Entity Bar" },
{ NULL, NULL }
};
int i;
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
"='http://example.org/'>"
"</foo:e>";
- const char *elemstr[] = {
- "http://example.org/ e foo",
- "http://example.org/ a "
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+ const XML_Char *elemstr[] = {
+ XCS("http://example.org/ e foo"),
+ XCS("http://example.org/ a ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
+ XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
};
int i;
const int max_alloc_count = 40;
" xmlns:foo='http://example.org/' bar:a='12'\n"
" xmlns:bar='http://example.org/'>"
"</foo:thisisalongenoughelementnametotriggerareallocation>";
- const char *elemstr[] = {
- "http://example.org/"
- " thisisalongenoughelementnametotriggerareallocation foo",
- "http://example.org/ a bar"
+ const XML_Char *elemstr[] = {
+ XCS("http://example.org/")
+ XCS(" thisisalongenoughelementnametotriggerareallocation foo"),
+ XCS("http://example.org/ a bar")
};
int i;
const int max_alloc_count = 30;
START_TEST(test_nsalloc_long_namespace)
{
- const char *text =
+ const char *text1 =
"<"
/* 64 characters per line */
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
- "='http://example.org/'>\n"
+ "='http://example.org/'>\n";
+ const char *text2 =
"<"
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
for (i = 0; i < max_alloc_count; i++) {
allocation_count = i;
- if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
+ if (_XML_Parse_SINGLE_BYTES(parser, text1, strlen(text1),
+ XML_FALSE) != XML_STATUS_ERROR &&
+ _XML_Parse_SINGLE_BYTES(parser, text2, strlen(text2),
XML_TRUE) != XML_STATUS_ERROR)
break;
/* See comment in test_nsalloc_xmlns() */
"&en;"
"</doc>";
ExtOption options[] = {
- { "foo", "<!ELEMENT e EMPTY>"},
- { "bar", "<e/>" },
+ { XCS("foo"), "<!ELEMENT e EMPTY>"},
+ { XCS("bar"), "<e/>" },
{ NULL, NULL }
};
int i;
context_realloc_test(const char *text)
{
ExtOption options[] = {
- { "foo", "<!ELEMENT e EMPTY>"},
- { "bar", "<e/>" },
+ { XCS("foo"), "<!ELEMENT e EMPTY>"},
+ { XCS("bar"), "<e/>" },
{ NULL, NULL }
};
int i;
- const int max_realloc_count = 5;
+ const int max_realloc_count = 6;
for (i = 0; i < max_realloc_count; i++) {
reallocation_count = i;
";"
"</doc>";
ExtOption options[] = {
- { "foo", "<!ELEMENT el EMPTY>" },
- { "bar", "<el/>" },
+ { XCS("foo"), "<!ELEMENT el EMPTY>" },
+ { XCS("bar"), "<el/>" },
{ NULL, NULL }
};
int i;
*/
START_TEST(test_nsalloc_realloc_long_context_in_dtd)
{
- const char *text =
+ const char *text1 =
"<!DOCTYPE "
/* 64 characters per line */
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
- "='foo/Second'>&First;</"
+ "='foo/Second'>&First;";
+ const char *text2 = "</"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
"ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
":doc>";
ExtOption options[] = {
- { "foo/First", "Hello world" },
+ { XCS("foo/First"), "Hello world" },
{ NULL, NULL }
};
int i;
XML_SetUserData(parser, options);
XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
XML_SetExternalEntityRefHandler(parser, external_entity_optioner);
- if (_XML_Parse_SINGLE_BYTES(parser, text, strlen(text),
+ if (_XML_Parse_SINGLE_BYTES(parser, text1, strlen(text1),
+ XML_FALSE) != XML_STATUS_ERROR &&
+ _XML_Parse_SINGLE_BYTES(parser, text2, strlen(text2),
XML_TRUE) != XML_STATUS_ERROR)
break;
/* See comment in test_nsalloc_xmlns() */
"]>\n"
"<doc>&x;</doc>";
ExtOption options[] = {
- { "foo", "<e/>"},
+ { XCS("foo"), "<e/>"},
{ NULL, NULL }
};
int i;
"]>\n"
"<doc>&en;</doc>";
ExtOption options[] = {
- { "foo", "<!ELEMENT e EMPTY>" },
+ { XCS("foo"), "<!ELEMENT e EMPTY>" },
{
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
- "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/",
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
+ XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"),
"<e/>"
},
{ NULL, NULL }
"&en;"
"</pfx:element>";
ExtOption options[] = {
- { "foo", "<!ELEMENT e EMPTY>" },
- { "bar", "<e/>" },
+ { XCS("foo"), "<!ELEMENT e EMPTY>" },
+ { XCS("bar"), "<e/>" },
{ NULL, NULL }
};
int i;
tcase_add_test(tc_basic, test_bad_entity_3);
tcase_add_test(tc_basic, test_bad_entity_4);
tcase_add_test(tc_basic, test_bad_notation);
+ tcase_add_test(tc_basic, test_default_doctype_handler);
+ tcase_add_test(tc_basic, test_empty_element_abort);
suite_add_tcase(s, tc_namespace);
tcase_add_checked_fixture(tc_namespace,
}
}
if (verbosity != CK_SILENT)
- printf("Expat version: %s\n", XML_ExpatVersion());
+ printf("Expat version: %" XML_FMT_STR "\n", XML_ExpatVersion());
srunner_run_all(sr, verbosity);
nf = srunner_ntests_failed(sr);
srunner_free(sr);