/*
- * XMLLite IXmlReader tests
+ * IXmlReader tests
*
- * Copyright 2010 (C) Nikolay Sivov
+ * Copyright 2010, 2012-2013 Nikolay Sivov
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
+#define WIN32_NO_STATUS
+#define _INC_WINDOWS
+#define COM_NO_WINDOWS_H
+
#define COBJMACROS
#define CONST_VTABLE
-#include <stdarg.h>
+//#include <stdarg.h>
#include <stdio.h>
-#include "windef.h"
-#include "winbase.h"
-#include "initguid.h"
-#include "ole2.h"
-#include "xmllite.h"
-#include "wine/test.h"
+#include <windef.h>
+#include <winbase.h>
+#include <winnls.h>
+#include <initguid.h>
+#include <ole2.h>
+#include <xmllite.h>
+#include <wine/test.h>
DEFINE_GUID(IID_IXmlReaderInput, 0x0b3ccc9b, 0x9214, 0x428b, 0xa2, 0xae, 0xef, 0x3a, 0xa8, 0x71, 0xaf, 0xda);
-static HRESULT (WINAPI *pCreateXmlReader)(REFIID riid, void **ppvObject, IMalloc *pMalloc);
-static HRESULT (WINAPI *pCreateXmlReaderInputWithEncodingName)(IUnknown *stream,
- IMalloc *pMalloc,
- LPCWSTR encoding,
- BOOL hint,
- LPCWSTR base_uri,
- IXmlReaderInput **ppInput);
-static const char *debugstr_guid(REFIID riid)
+static WCHAR *a2w(const char *str)
{
- static char buf[50];
-
- sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
- riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
- riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
- riid->Data4[5], riid->Data4[6], riid->Data4[7]);
+ int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
+ WCHAR *ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
+ MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
+ return ret;
+}
- return buf;
+static void free_str(WCHAR *str)
+{
+ HeapFree(GetProcessHeap(), 0, str);
}
static const char xmldecl_full[] = "\xef\xbb\xbf<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n";
+static const char xmldecl_short[] = "<?xml version=\"1.0\"?><RegistrationInfo/>";
static IStream *create_stream_on_data(const char *data, int size)
{
}
static void ok_pos_(IXmlReader *reader, int line, int pos, int line_broken,
- int pos_broken, int todo, int _line_)
+ int pos_broken, BOOL todo, int _line_)
{
UINT l, p;
HRESULT hr;
- int broken_state;
+ BOOL broken_state;
hr = IXmlReader_GetLineNumber(reader, &l);
ok_(__FILE__, _line_)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok_(__FILE__, _line_)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
if (line_broken == -1 && pos_broken == -1)
- broken_state = 0;
+ broken_state = FALSE;
else
broken_state = broken((line_broken == -1 ? line : line_broken) == l &&
(pos_broken == -1 ? pos : pos_broken) == p);
- if (todo)
- todo_wine
- ok_(__FILE__, _line_)((l == line && pos == p) || broken_state,
- "Expected (%d,%d), got (%d,%d)\n", line, pos, l, p);
- else
- {
+ todo_wine_if (todo)
ok_(__FILE__, _line_)((l == line && pos == p) || broken_state,
"Expected (%d,%d), got (%d,%d)\n", line, pos, l, p);
- }
}
#define ok_pos(reader, l, p, l_brk, p_brk, todo) ok_pos_(reader, l, p, l_brk, p_brk, todo, __LINE__)
static input_iids_t input_iids;
-static void ok_iids_(const input_iids_t *iids, const IID **expected, const IID **exp_broken, int todo, int line)
+static void ok_iids_(const input_iids_t *iids, const IID **expected, const IID **exp_broken, BOOL todo, int line)
{
int i = 0, size = 0;
while (expected[i++]) size++;
- if (todo) {
- todo_wine
- ok_(__FILE__, line)(iids->count == size, "Sequence size mismatch (%d), got (%d)\n", size, iids->count);
- }
- else
- ok_(__FILE__, line)(iids->count == size, "Sequence size mismatch (%d), got (%d)\n", size, iids->count);
+ todo_wine_if (todo)
+ ok_(__FILE__, line)(iids->count == size, "Sequence size mismatch (%d), got (%d)\n", size, iids->count);
if (iids->count != size) return;
for (i = 0; i < size; i++) {
ok_(__FILE__, line)(IsEqualGUID(&iids->iids[i], expected[i]) ||
(exp_broken ? broken(IsEqualGUID(&iids->iids[i], exp_broken[i])) : FALSE),
- "Wrong IID(%d), got (%s)\n", i, debugstr_guid(&iids->iids[i]));
+ "Wrong IID(%d), got %s\n", i, wine_dbgstr_guid(&iids->iids[i]));
}
}
#define ok_iids(got, exp, brk, todo) ok_iids_(got, exp, brk, todo, __LINE__)
}
static void test_read_state_(IXmlReader *reader, XmlReadState expected,
- XmlReadState exp_broken, int todo, int line)
+ XmlReadState exp_broken, BOOL todo, int line)
{
- XmlReadState state;
+ LONG_PTR state;
HRESULT hr;
- int broken_state;
+ BOOL broken_state;
state = -1; /* invalid value */
- hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, (LONG_PTR*)&state);
+ hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, &state);
ok_(__FILE__, line)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
if (exp_broken == -1)
- broken_state = 0;
+ broken_state = FALSE;
else
broken_state = broken(exp_broken == state);
- if (todo)
- {
- todo_wine
- ok_(__FILE__, line)(state == expected || broken_state, "Expected (%s), got (%s)\n",
- state_to_str(expected), state_to_str(state));
- }
- else
+ todo_wine_if (todo)
ok_(__FILE__, line)(state == expected || broken_state, "Expected (%s), got (%s)\n",
state_to_str(expected), state_to_str(state));
}
return S_OK;
}
-static BOOL init_pointers(void)
+static HRESULT WINAPI teststream_QueryInterface(ISequentialStream *iface, REFIID riid, void **obj)
+{
+ if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_ISequentialStream))
+ {
+ *obj = iface;
+ return S_OK;
+ }
+
+ *obj = NULL;
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI teststream_AddRef(ISequentialStream *iface)
+{
+ return 2;
+}
+
+static ULONG WINAPI teststream_Release(ISequentialStream *iface)
+{
+ return 1;
+}
+
+static int stream_readcall;
+
+static HRESULT WINAPI teststream_Read(ISequentialStream *iface, void *pv, ULONG cb, ULONG *pread)
{
- /* don't free module here, it's to be unloaded on exit */
- HMODULE mod = LoadLibraryA("xmllite.dll");
+ static const char xml[] = "<!-- comment -->";
- if (!mod)
+ if (stream_readcall++)
{
- win_skip("xmllite library not available\n");
- return FALSE;
+ *pread = 0;
+ return E_PENDING;
}
-#define MAKEFUNC(f) if (!(p##f = (void*)GetProcAddress(mod, #f))) return FALSE;
- MAKEFUNC(CreateXmlReader);
- MAKEFUNC(CreateXmlReaderInputWithEncodingName);
-#undef MAKEFUNC
+ *pread = sizeof(xml) / 2;
+ memcpy(pv, xml, *pread);
+ return S_OK;
+}
+
+static HRESULT WINAPI teststream_Write(ISequentialStream *iface, const void *pv, ULONG cb, ULONG *written)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static const ISequentialStreamVtbl teststreamvtbl =
+{
+ teststream_QueryInterface,
+ teststream_AddRef,
+ teststream_Release,
+ teststream_Read,
+ teststream_Write
+};
+
+static HRESULT WINAPI resolver_QI(IXmlResolver *iface, REFIID riid, void **obj)
+{
+ ok(0, "unexpected call, riid %s\n", wine_dbgstr_guid(riid));
+
+ if (IsEqualIID(riid, &IID_IXmlResolver) || IsEqualIID(riid, &IID_IUnknown))
+ {
+ *obj = iface;
+ IXmlResolver_AddRef(iface);
+ return S_OK;
+ }
+
+ *obj = NULL;
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI resolver_AddRef(IXmlResolver *iface)
+{
+ return 2;
+}
- return TRUE;
+static ULONG WINAPI resolver_Release(IXmlResolver *iface)
+{
+ return 1;
}
+static HRESULT WINAPI resolver_ResolveUri(IXmlResolver *iface, const WCHAR *base_uri,
+ const WCHAR *public_id, const WCHAR *system_id, IUnknown **input)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static const IXmlResolverVtbl resolvervtbl =
+{
+ resolver_QI,
+ resolver_AddRef,
+ resolver_Release,
+ resolver_ResolveUri
+};
+
+static IXmlResolver testresolver = { &resolvervtbl };
+
static void test_reader_create(void)
{
+ IXmlResolver *resolver;
HRESULT hr;
IXmlReader *reader;
IUnknown *input;
/* crashes native */
if (0)
{
- pCreateXmlReader(&IID_IXmlReader, NULL, NULL);
- pCreateXmlReader(NULL, (void**)&reader, NULL);
+ CreateXmlReader(&IID_IXmlReader, NULL, NULL);
+ CreateXmlReader(NULL, (void**)&reader, NULL);
}
- hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
test_read_state(reader, XmlReadState_Closed, -1, FALSE);
ok(hr == S_FALSE, "got %08x\n", hr);
ok(nodetype == XmlNodeType_None, "got %d\n", nodetype);
+ /* crashes on XP, 2k3, works on newer versions */
+ if (0)
+ {
+ hr = IXmlReader_GetNodeType(reader, NULL);
+ ok(hr == E_INVALIDARG, "got %08x\n", hr);
+ }
+
+ resolver = (void*)0xdeadbeef;
+ hr = IXmlReader_GetProperty(reader, XmlReaderProperty_XmlResolver, (LONG_PTR*)&resolver);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(resolver == NULL, "got %p\n", resolver);
+
+ hr = IXmlReader_SetProperty(reader, XmlReaderProperty_XmlResolver, 0);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ hr = IXmlReader_SetProperty(reader, XmlReaderProperty_XmlResolver, (LONG_PTR)&testresolver);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ resolver = NULL;
+ hr = IXmlReader_GetProperty(reader, XmlReaderProperty_XmlResolver, (LONG_PTR*)&resolver);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(resolver == &testresolver, "got %p\n", resolver);
+ IXmlResolver_Release(resolver);
+
+ hr = IXmlReader_SetProperty(reader, XmlReaderProperty_XmlResolver, 0);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
dtd = 2;
hr = IXmlReader_GetProperty(reader, XmlReaderProperty_DtdProcessing, (LONG_PTR*)&dtd);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
HRESULT hr;
LONG ref;
- hr = pCreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, NULL);
+ hr = CreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
- hr = pCreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, &reader_input);
+ hr = CreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, &reader_input);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ref = IStream_AddRef(stream);
ok(ref == 2, "Expected 2, got %d\n", ref);
IStream_Release(stream);
- hr = pCreateXmlReaderInputWithEncodingName((IUnknown*)stream, NULL, NULL, FALSE, NULL, &reader_input);
+ hr = CreateXmlReaderInputWithEncodingName((IUnknown*)stream, NULL, NULL, FALSE, NULL, &reader_input);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IUnknown_QueryInterface(reader_input, &IID_IStream, (void**)&stream2);
IStream_Release(stream);
/* try ::SetInput() with valid IXmlReaderInput */
- hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ref = IUnknown_AddRef(reader_input);
IStream_Release(stream);
/* test input interface selection sequence */
+ input = NULL;
hr = testinput_createinstance((void**)&input);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ref = IUnknown_AddRef(input);
ok(ref == 2, "Expected 2, got %d\n", ref);
IUnknown_Release(input);
- hr = pCreateXmlReaderInputWithEncodingName(input, NULL, NULL, FALSE, NULL, &reader_input);
+ hr = CreateXmlReaderInputWithEncodingName(input, NULL, NULL, FALSE, NULL, &reader_input);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok_iids(&input_iids, empty_seq, NULL, FALSE);
/* IXmlReaderInput stores stream interface as IUnknown */
ok(ref == 3, "Expected 3, got %d\n", ref);
IUnknown_Release(input);
- hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
+ hr = CreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
input_iids.count = 0;
ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
/* another reader */
- hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader2, NULL);
+ hr = CreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader2, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
/* resolving from IXmlReaderInput to IStream/ISequentialStream is done at
XmlNodeType nodetype;
HRESULT hr;
- hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
/* invalid arguments */
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
/* attempt to read on closed reader */
- test_read_state(reader, XmlReadState_Closed, -1, 0);
+ test_read_state(reader, XmlReadState_Closed, -1, FALSE);
if (0)
{
/* newer versions crash here, probably cause no input was set */
static void test_read_xmldeclaration(void)
{
+ static const WCHAR xmlW[] = {'x','m','l',0};
+ static const WCHAR RegistrationInfoW[] = {'R','e','g','i','s','t','r','a','t','i','o','n','I','n','f','o',0};
+ static const struct
+ {
+ WCHAR name[12];
+ WCHAR val[12];
+ } name_val[] =
+ {
+ { {'v','e','r','s','i','o','n',0}, {'1','.','0',0} },
+ { {'e','n','c','o','d','i','n','g',0}, {'U','T','F','-','8',0} },
+ { {'s','t','a','n','d','a','l','o','n','e',0}, {'y','e','s',0} }
+ };
IXmlReader *reader;
IStream *stream;
HRESULT hr;
XmlNodeType type;
- UINT count = 0;
+ UINT count = 0, len, i;
+ BOOL ret;
const WCHAR *val;
- hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
+ hr = CreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
/* position methods with Null args */
"Expected XmlNodeType_XmlDeclaration, got %s\n", type_to_str(type));
/* new version 1.2.x and 1.3.x properly update position for <?xml ?> */
ok_pos(reader, 1, 3, -1, 55, TRUE);
- test_read_state(reader, XmlReadState_Interactive, -1, 0);
+ test_read_state(reader, XmlReadState_Interactive, -1, FALSE);
hr = IXmlReader_GetValue(reader, &val, NULL);
-todo_wine
ok(hr == S_OK, "got %08x\n", hr);
- if (hr == S_OK)
- ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
+ ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
/* check attributes */
hr = IXmlReader_MoveToNextAttribute(reader);
ok(hr == S_OK, "got %08x\n", hr);
ok(count == 3, "Expected 3, got %d\n", count);
+ for (i = 0; i < count; i++)
+ {
+ len = 0;
+ hr = IXmlReader_GetLocalName(reader, &val, &len);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(len == lstrlenW(name_val[i].name), "expected %u, got %u\n", lstrlenW(name_val[i].name), len);
+ ok(!lstrcmpW(name_val[i].name, val), "expected %s, got %s\n", wine_dbgstr_w(name_val[i].name), wine_dbgstr_w(val));
+
+ len = 0;
+ hr = IXmlReader_GetValue(reader, &val, &len);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(len == lstrlenW(name_val[i].val), "expected %u, got %u\n", lstrlenW(name_val[i].val), len);
+ ok(!lstrcmpW(name_val[i].val, val), "expected %s, got %s\n", wine_dbgstr_w(name_val[i].val), wine_dbgstr_w(val));
+
+ hr = IXmlReader_MoveToNextAttribute(reader);
+ ok(hr == ((i < count - 1) ? S_OK : S_FALSE), "got %08x\n", hr);
+ }
+
hr = IXmlReader_GetDepth(reader, &count);
-todo_wine {
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(count == 1, "Expected 1, got %d\n", count);
-}
hr = IXmlReader_MoveToElement(reader);
ok(hr == S_OK, "got %08x\n", hr);
ok(hr == S_OK, "got %08x\n", hr);
ok(type == XmlNodeType_XmlDeclaration, "got %d\n", type);
+ type = XmlNodeType_XmlDeclaration;
+ hr = IXmlReader_Read(reader, &type);
+ /* newer versions return syntax error here cause document is incomplete,
+ it makes more sense than invalid char error */
+todo_wine {
+ ok(hr == WC_E_SYNTAX || broken(hr == WC_E_XMLCHARACTER), "got 0x%08x\n", hr);
+ ok(type == XmlNodeType_None, "got %d\n", type);
+}
+ IStream_Release(stream);
+
+ /* test short variant */
+ stream = create_stream_on_data(xmldecl_short, sizeof(xmldecl_short));
+
+ hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+
+ type = -1;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+ ok(type == XmlNodeType_XmlDeclaration, "expected XmlDeclaration, got %s\n", type_to_str(type));
+ ok_pos(reader, 1, 3, 1, 21, TRUE);
+ test_read_state(reader, XmlReadState_Interactive, -1, TRUE);
+
+ hr = IXmlReader_GetAttributeCount(reader, &count);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+ ok(count == 1, "expected 1, got %d\n", count);
+
+ ret = IXmlReader_IsEmptyElement(reader);
+ ok(!ret, "element should not be empty\n");
+
+ hr = IXmlReader_GetValue(reader, &val, NULL);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+ ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
+
+ hr = IXmlReader_GetLocalName(reader, &val, NULL);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+todo_wine
+ ok(!lstrcmpW(val, xmlW), "got %s\n", wine_dbgstr_w(val));
+
+ /* check attributes */
+ hr = IXmlReader_MoveToNextAttribute(reader);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+
+ type = -1;
+ hr = IXmlReader_GetNodeType(reader, &type);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+ ok(type == XmlNodeType_Attribute, "got %d\n", type);
+ ok_pos(reader, 1, 7, 1, 21, TRUE);
+
+ /* try to move from last attribute */
+ hr = IXmlReader_MoveToNextAttribute(reader);
+ ok(hr == S_FALSE, "expected S_FALSE, got %08x\n", hr);
+
+ type = -1;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+ ok(type == XmlNodeType_Element, "expected Element, got %s\n", type_to_str(type));
+ ok_pos(reader, 1, 23, 1, 40, TRUE);
+ test_read_state(reader, XmlReadState_Interactive, -1, TRUE);
+
+ hr = IXmlReader_GetAttributeCount(reader, &count);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+ ok(count == 0, "expected 0, got %d\n", count);
+
+ ret = IXmlReader_IsEmptyElement(reader);
+ ok(ret, "element should be empty\n");
+
+ hr = IXmlReader_GetValue(reader, &val, NULL);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+todo_wine
+ ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
+
+ hr = IXmlReader_GetLocalName(reader, &val, NULL);
+ ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
+ ok(!lstrcmpW(val, RegistrationInfoW), "got %s\n", wine_dbgstr_w(val));
+
+ type = -1;
+ hr = IXmlReader_Read(reader, &type);
+todo_wine
+ ok(hr == WC_E_SYNTAX || hr == WC_E_XMLCHARACTER /* XP */, "expected WC_E_SYNTAX, got %08x\n", hr);
+todo_wine
+ ok(type == XmlNodeType_None, "expected None, got %s\n", type_to_str(type));
+ ok_pos(reader, 1, 41, -1, -1, TRUE);
+ test_read_state(reader, XmlReadState_Error, -1, TRUE);
+
IStream_Release(stream);
IXmlReader_Release(reader);
}
-START_TEST(reader)
+struct test_entry {
+ const char *xml;
+ const char *name;
+ const char *value;
+ HRESULT hr;
+ HRESULT hr_broken; /* this is set to older version results */
+ BOOL todo;
+};
+
+static struct test_entry comment_tests[] = {
+ { "<!-- comment -->", "", " comment ", S_OK },
+ { "<!-- - comment-->", "", " - comment", S_OK },
+ { "<!-- -- comment-->", NULL, NULL, WC_E_COMMENT, WC_E_GREATERTHAN },
+ { "<!-- -- comment--->", NULL, NULL, WC_E_COMMENT, WC_E_GREATERTHAN },
+ { NULL }
+};
+
+static void test_read_comment(void)
{
- HRESULT r;
+ struct test_entry *test = comment_tests;
+ IXmlReader *reader;
+ HRESULT hr;
- r = CoInitialize( NULL );
- ok( r == S_OK, "failed to init com\n");
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
- if (!init_pointers())
+ while (test->xml)
{
- CoUninitialize();
- return;
+ XmlNodeType type;
+ IStream *stream;
+
+ stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ if (test->hr_broken)
+ ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
+ else
+ ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
+ if (hr == S_OK)
+ {
+ const WCHAR *str;
+ WCHAR *str_exp;
+ UINT len;
+
+ ok(type == XmlNodeType_Comment, "got %d for %s\n", type, test->xml);
+
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ str_exp = a2w(test->name);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetQualifiedName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ str_exp = a2w(test->name);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+
+ /* value */
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetValue(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->value), "got %u\n", len);
+ str_exp = a2w(test->value);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+ }
+
+ IStream_Release(stream);
+ test++;
}
+ IXmlReader_Release(reader);
+}
+
+static struct test_entry pi_tests[] = {
+ { "<?pi?>", "pi", "", S_OK },
+ { "<?pi ?>", "pi", "", S_OK },
+ { "<?pi ?>", "pi", "", S_OK },
+ { "<?pi pi data?>", "pi", "pi data", S_OK },
+ { "<?pi pi data ?>", "pi", "pi data ", S_OK },
+ { "<?pi data ?>", "pi", "data ", S_OK },
+ { "<?pi:pi?>", NULL, NULL, NC_E_NAMECOLON, WC_E_NAMECHARACTER },
+ { "<?:pi ?>", NULL, NULL, WC_E_PI, WC_E_NAMECHARACTER },
+ { "<?-pi ?>", NULL, NULL, WC_E_PI, WC_E_NAMECHARACTER },
+ { "<?xml-stylesheet ?>", "xml-stylesheet", "", S_OK },
+ { NULL }
+};
+
+static void test_read_pi(void)
+{
+ struct test_entry *test = pi_tests;
+ IXmlReader *reader;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ while (test->xml)
+ {
+ XmlNodeType type;
+ IStream *stream;
+
+ stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ if (test->hr_broken)
+ ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
+ else
+ ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
+ if (hr == S_OK)
+ {
+ const WCHAR *str;
+ WCHAR *str_exp;
+ UINT len;
+
+ ok(type == XmlNodeType_ProcessingInstruction, "got %d for %s\n", type, test->xml);
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ str_exp = a2w(test->name);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetQualifiedName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ str_exp = a2w(test->name);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+
+ /* value */
+ len = !strlen(test->value);
+ str = NULL;
+ hr = IXmlReader_GetValue(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->value), "got %u\n", len);
+ str_exp = a2w(test->value);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+ }
+
+ IStream_Release(stream);
+ test++;
+ }
+
+ IXmlReader_Release(reader);
+}
+
+struct nodes_test {
+ const char *xml;
+ XmlNodeType types[20];
+};
+
+static const char misc_test_xml[] =
+ "<!-- comment1 -->"
+ "<!-- comment2 -->"
+ "<?pi1 pi1body ?>"
+ "<!-- comment3 -->"
+ " \t \r \n"
+ "<!-- comment4 -->"
+ "<a>"
+ "\r\n\t"
+ "<b/>"
+ "text"
+ "<!-- comment -->"
+ "text2"
+ "<?pi pibody ?>"
+ "\r\n"
+ "</a>"
+;
+
+static struct nodes_test misc_test = {
+ misc_test_xml,
+ {
+ XmlNodeType_Comment,
+ XmlNodeType_Comment,
+ XmlNodeType_ProcessingInstruction,
+ XmlNodeType_Comment,
+ XmlNodeType_Whitespace,
+ XmlNodeType_Comment,
+ XmlNodeType_Element,
+ XmlNodeType_Whitespace,
+ XmlNodeType_Element,
+ XmlNodeType_Text,
+ XmlNodeType_Comment,
+ XmlNodeType_Text,
+ XmlNodeType_ProcessingInstruction,
+ XmlNodeType_Whitespace,
+ XmlNodeType_EndElement,
+ XmlNodeType_None
+ }
+};
+
+static void test_read_full(void)
+{
+ struct nodes_test *test = &misc_test;
+ IXmlReader *reader;
+ XmlNodeType type;
+ IStream *stream;
+ HRESULT hr;
+ int i;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ i = 0;
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ while (hr == S_OK)
+ {
+ ok(test->types[i] != XmlNodeType_None, "%d: unexpected end of test data\n", i);
+ if (test->types[i] == XmlNodeType_None) break;
+ ok(type == test->types[i], "%d: got wrong type %d, expected %d\n", i, type, test->types[i]);
+ if (type == XmlNodeType_Whitespace)
+ {
+ const WCHAR *ptr;
+ UINT len = 0;
+
+ hr = IXmlReader_GetValue(reader, &ptr, &len);
+ ok(hr == S_OK, "%d: GetValue failed 0x%08x\n", i, hr);
+ ok(len > 0, "%d: wrong value length %d\n", i, len);
+ }
+ hr = IXmlReader_Read(reader, &type);
+ i++;
+ }
+ ok(test->types[i] == XmlNodeType_None, "incomplete sequence, got %d\n", test->types[i]);
+
+ IStream_Release(stream);
+ IXmlReader_Release(reader);
+}
+
+static const char test_public_dtd[] =
+ "<!DOCTYPE testdtd PUBLIC \"pubid\" \"externalid uri\" >";
+
+static void test_read_public_dtd(void)
+{
+ static const WCHAR sysvalW[] = {'e','x','t','e','r','n','a','l','i','d',' ','u','r','i',0};
+ static const WCHAR pubvalW[] = {'p','u','b','i','d',0};
+ static const WCHAR dtdnameW[] = {'t','e','s','t','d','t','d',0};
+ static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};
+ static const WCHAR pubW[] = {'P','U','B','L','I','C',0};
+ IXmlReader *reader;
+ const WCHAR *str;
+ XmlNodeType type;
+ IStream *stream;
+ UINT len, count;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, DtdProcessing_Parse);
+ ok(hr == S_OK, "got 0x%8x\n", hr);
+
+ stream = create_stream_on_data(test_public_dtd, sizeof(test_public_dtd));
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got 0x%8x\n", hr);
+ ok(type == XmlNodeType_DocumentType, "got type %d\n", type);
+
+ count = 0;
+ hr = IXmlReader_GetAttributeCount(reader, &count);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(count == 2, "got %d\n", count);
+
+ hr = IXmlReader_MoveToFirstAttribute(reader);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_GetNodeType(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_Attribute, "got %d\n", type);
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == lstrlenW(pubW), "got %u\n", len);
+ ok(!lstrcmpW(str, pubW), "got %s\n", wine_dbgstr_w(str));
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetValue(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == lstrlenW(pubvalW), "got %u\n", len);
+ ok(!lstrcmpW(str, pubvalW), "got %s\n", wine_dbgstr_w(str));
+
+ hr = IXmlReader_MoveToNextAttribute(reader);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_GetNodeType(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_Attribute, "got %d\n", type);
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == lstrlenW(sysW), "got %u\n", len);
+ ok(!lstrcmpW(str, sysW), "got %s\n", wine_dbgstr_w(str));
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetValue(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == lstrlenW(sysvalW), "got %u\n", len);
+ ok(!lstrcmpW(str, sysvalW), "got %s\n", wine_dbgstr_w(str));
+
+ hr = IXmlReader_MoveToElement(reader);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+todo_wine {
+ ok(len == lstrlenW(dtdnameW), "got %u\n", len);
+ ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
+}
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetQualifiedName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == lstrlenW(dtdnameW), "got %u\n", len);
+ ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
+
+ IStream_Release(stream);
+ IXmlReader_Release(reader);
+}
+
+static const char test_system_dtd[] =
+ "<!DOCTYPE testdtd SYSTEM \"externalid uri\" >"
+ "<!-- comment -->";
+
+static void test_read_system_dtd(void)
+{
+ static const WCHAR sysvalW[] = {'e','x','t','e','r','n','a','l','i','d',' ','u','r','i',0};
+ static const WCHAR dtdnameW[] = {'t','e','s','t','d','t','d',0};
+ static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};
+ IXmlReader *reader;
+ const WCHAR *str;
+ XmlNodeType type;
+ IStream *stream;
+ UINT len, count;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, DtdProcessing_Parse);
+ ok(hr == S_OK, "got 0x%8x\n", hr);
+
+ stream = create_stream_on_data(test_system_dtd, sizeof(test_system_dtd));
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got 0x%8x\n", hr);
+ ok(type == XmlNodeType_DocumentType, "got type %d\n", type);
+
+ count = 0;
+ hr = IXmlReader_GetAttributeCount(reader, &count);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(count == 1, "got %d\n", count);
+
+ hr = IXmlReader_MoveToFirstAttribute(reader);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_GetNodeType(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_Attribute, "got %d\n", type);
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == lstrlenW(sysW), "got %u\n", len);
+ ok(!lstrcmpW(str, sysW), "got %s\n", wine_dbgstr_w(str));
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetValue(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == lstrlenW(sysvalW), "got %u\n", len);
+ ok(!lstrcmpW(str, sysvalW), "got %s\n", wine_dbgstr_w(str));
+
+ hr = IXmlReader_MoveToElement(reader);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+todo_wine {
+ ok(len == lstrlenW(dtdnameW), "got %u\n", len);
+ ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
+}
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetQualifiedName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == lstrlenW(dtdnameW), "got %u\n", len);
+ ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got 0x%8x\n", hr);
+ ok(type == XmlNodeType_Comment, "got type %d\n", type);
+
+ IStream_Release(stream);
+ IXmlReader_Release(reader);
+}
+
+static struct test_entry element_tests[] = {
+ { "<a/>", "a", "", S_OK },
+ { "<a />", "a", "", S_OK },
+ { "<a:b/>", "a:b", "", NC_E_UNDECLAREDPREFIX },
+ { "<:a/>", NULL, NULL, NC_E_QNAMECHARACTER },
+ { "< a/>", NULL, NULL, NC_E_QNAMECHARACTER },
+ { "<a>", "a", "", S_OK },
+ { "<a >", "a", "", S_OK },
+ { "<a \r \t\n>", "a", "", S_OK },
+ { "</a>", NULL, NULL, NC_E_QNAMECHARACTER },
+ { NULL }
+};
+
+static void test_read_element(void)
+{
+ struct test_entry *test = element_tests;
+ static const char stag[] = "<a><b></b></a>";
+ static const char mismatch[] = "<a></b>";
+ IXmlReader *reader;
+ XmlNodeType type;
+ IStream *stream;
+ UINT depth;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ while (test->xml)
+ {
+ stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ if (test->hr_broken)
+ ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
+ else
+ todo_wine_if(test->hr == NC_E_UNDECLAREDPREFIX)
+ ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
+ if (hr == S_OK)
+ {
+ const WCHAR *str;
+ WCHAR *str_exp;
+ UINT len;
+
+ ok(type == XmlNodeType_Element, "got %d for %s\n", type, test->xml);
+
+ len = 0;
+ str = NULL;
+ hr = IXmlReader_GetQualifiedName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ str_exp = a2w(test->name);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+
+ /* value */
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetValue(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == 0, "got %u\n", len);
+ ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
+ }
+
+ IStream_Release(stream);
+ test++;
+ }
+
+ /* test reader depth increment */
+ stream = create_stream_on_data(stag, sizeof(stag));
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ depth = 1;
+ hr = IXmlReader_GetDepth(reader, &depth);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(depth == 0, "got %d\n", depth);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_Element, "got %d\n", type);
+
+ depth = 1;
+ hr = IXmlReader_GetDepth(reader, &depth);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(depth == 0, "got %d\n", depth);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_Element, "got %d\n", type);
+
+ depth = 0;
+ hr = IXmlReader_GetDepth(reader, &depth);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(depth == 1, "got %d\n", depth);
+
+ /* read end tag for inner element */
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_EndElement, "got %d\n", type);
+
+ depth = 0;
+ hr = IXmlReader_GetDepth(reader, &depth);
+ ok(hr == S_OK, "got %08x\n", hr);
+todo_wine
+ ok(depth == 2, "got %d\n", depth);
+
+ /* read end tag for container element */
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_EndElement, "got %d\n", type);
+
+ depth = 0;
+ hr = IXmlReader_GetDepth(reader, &depth);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(depth == 1, "got %d\n", depth);
+
+ IStream_Release(stream);
+
+ /* start/end tag mismatch */
+ stream = create_stream_on_data(mismatch, sizeof(mismatch));
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_Element, "got %d\n", type);
+
+ type = XmlNodeType_Element;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == WC_E_ELEMENTMATCH, "got %08x\n", hr);
+todo_wine
+ ok(type == XmlNodeType_None, "got %d\n", type);
+
+ IStream_Release(stream);
+
+ IXmlReader_Release(reader);
+}
+
+static ISequentialStream teststream = { &teststreamvtbl };
+
+static void test_read_pending(void)
+{
+ IXmlReader *reader;
+ const WCHAR *value;
+ XmlNodeType type;
+ HRESULT hr;
+ int c;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got 0x%08x\n", hr);
+
+ hr = IXmlReader_SetInput(reader, (IUnknown*)&teststream);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ /* first read call returns incomplete node, second attempt fails with E_PENDING */
+ stream_readcall = 0;
+ type = XmlNodeType_Element;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK || broken(hr == E_PENDING), "got 0x%08x\n", hr);
+ /* newer versions are happy when it's enough data to detect node type,
+ older versions keep reading until it fails to read more */
+ ok(stream_readcall == 1 || broken(stream_readcall > 1), "got %d\n", stream_readcall);
+ ok(type == XmlNodeType_Comment || broken(type == XmlNodeType_None), "got %d\n", type);
+
+ /* newer versions' GetValue() makes an attempt to read more */
+ c = stream_readcall;
+ value = (void*)0xdeadbeef;
+ hr = IXmlReader_GetValue(reader, &value, NULL);
+ ok(hr == E_PENDING, "got 0x%08x\n", hr);
+ ok(value == NULL || broken(value == (void*)0xdeadbeef) /* Win8 sets it to NULL */, "got %p\n", value);
+ ok(c < stream_readcall || broken(c == stream_readcall), "got %d, expected %d\n", stream_readcall, c+1);
+
+ IXmlReader_Release(reader);
+}
+
+static void test_readvaluechunk(void)
+{
+ static const char testA[] = "<!-- comment1 -->";
+ IXmlReader *reader;
+ XmlNodeType type;
+ IStream *stream;
+ const WCHAR *value;
+ WCHAR b;
+ HRESULT hr;
+ UINT c;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ stream = create_stream_on_data(testA, sizeof(testA));
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ c = 0;
+ b = 0;
+ hr = IXmlReader_ReadValueChunk(reader, &b, 1, &c);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(c == 1, "got %u\n", c);
+ ok(b == ' ', "got %x\n", b);
+
+ /* portion read as chunk is skipped from resulting node value */
+ value = NULL;
+ hr = IXmlReader_GetValue(reader, &value, NULL);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(value[0] == 'c', "got %s\n", wine_dbgstr_w(value));
+
+ /* once value is returned/allocated it's not possible to read by chunk */
+ c = 0;
+ b = 0;
+ hr = IXmlReader_ReadValueChunk(reader, &b, 1, &c);
+ ok(hr == S_FALSE, "got %08x\n", hr);
+ ok(c == 0, "got %u\n", c);
+ ok(b == 0, "got %x\n", b);
+
+ value = NULL;
+ hr = IXmlReader_GetValue(reader, &value, NULL);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(value[0] == 'c', "got %s\n", wine_dbgstr_w(value));
+
+ IXmlReader_Release(reader);
+ IStream_Release(stream);
+}
+
+static struct test_entry cdata_tests[] = {
+ { "<a><![CDATA[ ]]data ]]></a>", "", " ]]data ", S_OK },
+ { "<a><![CDATA[<![CDATA[ data ]]]]></a>", "", "<![CDATA[ data ]]", S_OK },
+ { "<a><![CDATA[\n \r\n \n\n ]]></a>", "", "\n \n \n\n ", S_OK, S_OK, TRUE },
+ { "<a><![CDATA[\r \r\r\n \n\n ]]></a>", "", "\n \n\n \n\n ", S_OK, S_OK, TRUE },
+ { "<a><![CDATA[\r\r \n\r \r \n\n ]]></a>", "", "\n\n \n\n \n \n\n ", S_OK },
+ { NULL }
+};
+
+static void test_read_cdata(void)
+{
+ struct test_entry *test = cdata_tests;
+ IXmlReader *reader;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ while (test->xml)
+ {
+ XmlNodeType type;
+ IStream *stream;
+
+ stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+
+ /* read one more to get to CDATA */
+ if (type == XmlNodeType_Element)
+ {
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ }
+
+ if (test->hr_broken)
+ ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
+ else
+ ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
+ if (hr == S_OK)
+ {
+ const WCHAR *str;
+ WCHAR *str_exp;
+ UINT len;
+
+ ok(type == XmlNodeType_CDATA, "got %d for %s\n", type, test->xml);
+
+ str_exp = a2w(test->name);
+
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, NULL);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+
+ free_str(str_exp);
+
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetQualifiedName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ str_exp = a2w(test->name);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+
+ /* value */
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetValue(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ str_exp = a2w(test->value);
+ todo_wine_if (test->todo)
+ {
+ ok(len == strlen(test->value), "got %u\n", len);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ }
+ free_str(str_exp);
+ }
+
+ IStream_Release(stream);
+ test++;
+ }
+
+ IXmlReader_Release(reader);
+}
+
+static struct test_entry text_tests[] = {
+ { "<a>simple text</a>", "", "simple text", S_OK },
+ { "<a>text ]]> text</a>", "", "", WC_E_CDSECTEND },
+ { NULL }
+};
+
+static void test_read_text(void)
+{
+ struct test_entry *test = text_tests;
+ IXmlReader *reader;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ while (test->xml)
+ {
+ XmlNodeType type;
+ IStream *stream;
+
+ stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+
+ /* read one more to get to CDATA */
+ if (type == XmlNodeType_Element)
+ {
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ }
+
+ if (test->hr_broken)
+ ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
+ else
+ ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
+ if (hr == S_OK)
+ {
+ const WCHAR *str;
+ WCHAR *str_exp;
+ UINT len;
+
+ ok(type == XmlNodeType_Text, "got %d for %s\n", type, test->xml);
+
+ str_exp = a2w(test->name);
+
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, NULL);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+
+ free_str(str_exp);
+
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetQualifiedName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ str_exp = a2w(test->name);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+
+ /* value */
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetValue(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ str_exp = a2w(test->value);
+ todo_wine_if (test->todo)
+ {
+ ok(len == strlen(test->value), "got %u\n", len);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ }
+ free_str(str_exp);
+ }
+
+ IStream_Release(stream);
+ test++;
+ }
+
+ IXmlReader_Release(reader);
+}
+
+struct test_entry_empty {
+ const char *xml;
+ BOOL empty;
+};
+
+static struct test_entry_empty empty_element_tests[] = {
+ { "<a></a>", FALSE },
+ { "<a/>", TRUE },
+ { NULL }
+};
+
+static void test_isemptyelement(void)
+{
+ struct test_entry_empty *test = empty_element_tests;
+ IXmlReader *reader;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ while (test->xml)
+ {
+ XmlNodeType type;
+ IStream *stream;
+ BOOL ret;
+
+ stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(type == XmlNodeType_Element, "got %d\n", type);
+
+ ret = IXmlReader_IsEmptyElement(reader);
+ ok(ret == test->empty, "got %d, expected %d. xml=%s\n", ret, test->empty, test->xml);
+
+ IStream_Release(stream);
+ test++;
+ }
+
+ IXmlReader_Release(reader);
+}
+
+static struct test_entry attributes_tests[] = {
+ { "<a attr1=\"attrvalue\"/>", "attr1", "attrvalue", S_OK },
+ { "<a attr1=\"a\'\'ttrvalue\"/>", "attr1", "a\'\'ttrvalue", S_OK },
+ { "<a attr1=\'a\"ttrvalue\'/>", "attr1", "a\"ttrvalue", S_OK },
+ { "<a attr1=\' \'/>", "attr1", " ", S_OK },
+ { "<a attr1=\" \"/>", "attr1", " ", S_OK },
+ { "<a attr1=\"\r\n \r \n \t\n\r\"/>", "attr1", " ", S_OK },
+ { "<a attr1=\" val \"/>", "attr1", " val ", S_OK },
+ { "<a attr1=\"\r\n\tval\n\"/>", "attr1", " val ", S_OK },
+ { "<a attr1=\"val \"/>", "attr1", "val ", S_OK },
+ { "<a attr1=\"val \"/>", "attr1", "val ", S_OK },
+ { "<a attr1=\"<>&'"\"/>", "attr1", "<>&\'\"", S_OK },
+ { "<a attr1=\"&entname;\"/>", NULL, NULL, WC_E_UNDECLAREDENTITY },
+ { "<a attr1=\"val\"/>", NULL, NULL, WC_E_XMLCHARACTER },
+ { "<a attr1=\"val &#a;\"/>", NULL, NULL, WC_E_DIGIT, WC_E_SEMICOLON },
+ { "<a attr1=\"val a;\"/>", NULL, NULL, WC_E_SEMICOLON },
+ { "<a attr1=\"val g;\"/>", NULL, NULL, WC_E_SEMICOLON },
+ { "<a attr1=\"val &#xg;\"/>", NULL, NULL, WC_E_HEXDIGIT, WC_E_SEMICOLON },
+ { "<a attr1=attrvalue/>", NULL, NULL, WC_E_QUOTE },
+ { "<a attr1=\"attr<value\"/>", NULL, NULL, WC_E_LESSTHAN },
+ { "<a attr1=\"&entname\"/>", NULL, NULL, WC_E_SEMICOLON },
+ { NULL }
+};
+
+static void test_read_attribute(void)
+{
+ struct test_entry *test = attributes_tests;
+ IXmlReader *reader;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ while (test->xml)
+ {
+ XmlNodeType type;
+ IStream *stream;
+
+ stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
+ hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = IXmlReader_Read(reader, NULL);
+
+ if (test->hr_broken)
+ ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
+ else
+ ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
+ if (hr == S_OK)
+ {
+ const WCHAR *str;
+ WCHAR *str_exp;
+ UINT len;
+
+ type = XmlNodeType_None;
+ hr = IXmlReader_GetNodeType(reader, &type);
+ ok(hr == S_OK, "Failed to get node type, %#x\n", hr);
+
+ ok(type == XmlNodeType_Element, "got %d for %s\n", type, test->xml);
+
+ hr = IXmlReader_MoveToFirstAttribute(reader);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetLocalName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->name), "got %u\n", len);
+ str_exp = a2w(test->name);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetQualifiedName(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ todo_wine {
+ ok(len == strlen(test->name), "got %u\n", len);
+ str_exp = a2w(test->name);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+ }
+ /* value */
+ len = 1;
+ str = NULL;
+ hr = IXmlReader_GetValue(reader, &str, &len);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(len == strlen(test->value), "got %u\n", len);
+ str_exp = a2w(test->value);
+ ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
+ free_str(str_exp);
+ }
+
+ IStream_Release(stream);
+ test++;
+ }
+
+ IXmlReader_Release(reader);
+}
+
+static void test_reader_properties(void)
+{
+ IXmlReader *reader;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MultiLanguage, 0);
+ ok(hr == S_OK, "SetProperty failed: %08x\n", hr);
+
+ hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MaxElementDepth, 0);
+ ok(hr == S_OK, "SetProperty failed: %08x\n", hr);
+
+ IXmlReader_Release(reader);
+}
+
+static void test_prefix(void)
+{
+ static const struct
+ {
+ const char *xml;
+ const char *prefix1;
+ const char *prefix2;
+ const char *prefix3;
+ } prefix_tests[] =
+ {
+ { "<b xmlns=\"defns\" xml:a=\"a ns\"/>", "", "", "xml" },
+ };
+ IXmlReader *reader;
+ unsigned int i;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ for (i = 0; i < sizeof(prefix_tests)/sizeof(prefix_tests[0]); i++) {
+ const WCHAR *prefix;
+ XmlNodeType type;
+ WCHAR *expected;
+ IStream *stream;
+
+ stream = create_stream_on_data(prefix_tests[i].xml, strlen(prefix_tests[i].xml) + 1);
+ hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "Read() failed, %#x\n", hr);
+ ok(type == XmlNodeType_Element, "Unexpected node type %d.\n", type);
+
+ expected = a2w(prefix_tests[i].prefix1);
+ hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
+ ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
+ ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
+ wine_dbgstr_w(expected));
+ free_str(expected);
+
+ hr = IXmlReader_MoveToFirstAttribute(reader);
+ ok(hr == S_OK, "MoveToFirstAttribute() failed, %#x.\n", hr);
+
+ hr = IXmlReader_GetNodeType(reader, &type);
+ ok(hr == S_OK, "GetNodeType() failed, %#x.\n", hr);
+ ok(type == XmlNodeType_Attribute, "Unexpected node type %d.\n", type);
+
+ expected = a2w(prefix_tests[i].prefix2);
+ hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
+ ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
+ ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
+ wine_dbgstr_w(expected));
+ free_str(expected);
+
+ hr = IXmlReader_MoveToNextAttribute(reader);
+ ok(hr == S_OK, "MoveToNextAttribute() failed, %#x.\n", hr);
+
+ hr = IXmlReader_GetNodeType(reader, &type);
+ ok(hr == S_OK, "GetNodeType() failed, %#x.\n", hr);
+ ok(type == XmlNodeType_Attribute, "Unexpected node type %d.\n", type);
+
+ expected = a2w(prefix_tests[i].prefix3);
+ hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
+ ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
+ ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
+ wine_dbgstr_w(expected));
+ free_str(expected);
+
+ IStream_Release(stream);
+ }
+
+ IXmlReader_Release(reader);
+}
+
+static void test_namespaceuri(void)
+{
+ struct uri_test
+ {
+ const char *xml;
+ const char *uri[5];
+ } uri_tests[] =
+ {
+ { "<a xmlns=\"defns a\"><b xmlns=\"defns b\"><c xmlns=\"defns c\"/></b></a>",
+ { "defns a", "defns b", "defns c", "defns b", "defns a" }},
+ { "<r:a xmlns=\"defns a\" xmlns:r=\"ns r\"/>",
+ { "ns r" }},
+ { "<r:a xmlns=\"defns a\" xmlns:r=\"ns r\"><b/></r:a>",
+ { "ns r", "defns a", "ns r" }},
+ { "<a xmlns=\"defns a\" xmlns:r=\"ns r\"><r:b/></a>",
+ { "defns a", "ns r", "defns a" }},
+ { "<a><b><c/></b></a>",
+ { "", "", "", "", "" }},
+ };
+ IXmlReader *reader;
+ XmlNodeType type;
+ unsigned int i;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ for (i = 0; i < sizeof(uri_tests)/sizeof(uri_tests[0]); i++) {
+ IStream *stream = create_stream_on_data(uri_tests[i].xml, strlen(uri_tests[i].xml) + 1);
+ unsigned int j = 0;
+
+ hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ while (IXmlReader_Read(reader, &type) == S_OK) {
+ const WCHAR *uri, *local;
+ WCHAR *uriW;
+
+ ok(type == XmlNodeType_Element || type == XmlNodeType_EndElement, "Unexpected node type %d.\n", type);
+
+ hr = IXmlReader_GetLocalName(reader, &local, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ hr = IXmlReader_GetNamespaceUri(reader, &uri, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ uriW = a2w(uri_tests[i].uri[j]);
+ ok(!lstrcmpW(uriW, uri), "%s: uri %s\n", wine_dbgstr_w(local), wine_dbgstr_w(uri));
+ free_str(uriW);
+
+ j++;
+ }
+
+ IStream_Release(stream);
+ }
+
+ IXmlReader_Release(reader);
+}
+
+static void test_read_charref(void)
+{
+ static const char testA[] = "<a b=\"c\">dză</a>";
+ static const WCHAR chardataW[] = {0x01f3,0x0103,0};
+ const WCHAR *value;
+ IXmlReader *reader;
+ XmlNodeType type;
+ IStream *stream;
+ HRESULT hr;
+
+ hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
+ ok(hr == S_OK, "S_OK, got %08x\n", hr);
+
+ stream = create_stream_on_data(testA, sizeof(testA));
+ hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
+ ok(hr == S_OK, "got %08x\n", hr);
+
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_Element, "Unexpected node type %d\n", type);
+
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_Text, "Unexpected node type %d\n", type);
+
+ hr = IXmlReader_GetValue(reader, &value, NULL);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(!lstrcmpW(value, chardataW), "Text value : %s\n", wine_dbgstr_w(value));
+
+ hr = IXmlReader_Read(reader, &type);
+ ok(hr == S_OK, "got %08x\n", hr);
+ ok(type == XmlNodeType_EndElement, "Unexpected node type %d\n", type);
+
+ IXmlReader_Release(reader);
+ IStream_Release(stream);
+}
+
+START_TEST(reader)
+{
test_reader_create();
test_readerinput();
test_reader_state();
+ test_read_attribute();
+ test_read_cdata();
+ test_read_comment();
+ test_read_pi();
+ test_read_system_dtd();
+ test_read_public_dtd();
+ test_read_element();
+ test_isemptyelement();
+ test_read_text();
+ test_read_full();
+ test_read_pending();
+ test_readvaluechunk();
test_read_xmldeclaration();
-
- CoUninitialize();
+ test_reader_properties();
+ test_prefix();
+ test_namespaceuri();
+ test_read_charref();
}
projects / reactos.git / blobdiff