reader.c File Reference

#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 "wine/heap.h"

Include dependency graph for reader.c:

Go to the source code of this file.

Classes
struct	input_iids_t
struct	_testinput
struct	test_entry
struct	nodes_test
struct	test_entry_empty

Macros
#define	COBJMACROS
#define	CONST_VTABLE
#define	TEST_READER_POSITION(reader, line, pos)    test_reader_pos(reader, line, pos, ~0u, ~0u, __LINE__)
#define	TEST_READER_POSITION2(reader, line, pos, line_broken, pos_broken)    test_reader_pos(reader, line, pos, line_broken, pos_broken, __LINE__)
#define	ok_iids(got, exp, brk, todo)   ok_iids_(got, exp, brk, todo, __LINE__)
#define	set_input_string(a, b)   _set_input_string(__LINE__,a,b);
#define	read_node(a, b)   _read_node(__LINE__,a,b)
#define	next_attribute(a)   _next_attribute(__LINE__,a)
#define	move_to_element(a)   _move_to_element(__LINE__,a)
#define	TEST_READER_STATE(reader, state)   test_read_state(reader, state, state, __LINE__)
#define	TEST_READER_STATE2(reader, state, brk)   test_read_state(reader, state, brk, __LINE__)
#define	reader_value(a, b)   _reader_value(__LINE__,a,b)
#define	reader_name(a, b)   _reader_name(__LINE__,a,b)
#define	reader_prefix(a, b)   _reader_prefix(__LINE__,a,b)
#define	reader_namespace(a, b)   _reader_namespace(__LINE__,a,b)
#define	reader_qname(a, b)   _reader_qname(a,b,__LINE__)
#define	read_value_char(a, b)   _read_value_char(a,b,__LINE__)
#define	TEST_DEPTH(reader, depth)   test_reader_depth(reader, depth, ~0u, __LINE__)
#define	TEST_DEPTH2(reader, depth, brk)   test_reader_depth(reader, depth, brk, __LINE__)

Typedefs
typedef struct input_iids_t	input_iids_t
typedef struct _testinput	testinput

Functions
	DEFINE_GUID (IID_IXmlReaderInput, 0x0b3ccc9b, 0x9214, 0x428b, 0xa2, 0xae, 0xef, 0x3a, 0xa8, 0x71, 0xaf, 0xda)
static WCHAR *	a2w (const char *str)
static void	free_str (WCHAR *str)
static int	strcmp_wa (const WCHAR *str1, const char *stra)
static IStream *	create_stream_on_data (const void *data, unsigned int size)
static void	test_reader_pos (IXmlReader *reader, UINT line, UINT pos, UINT line_broken, UINT pos_broken, int _line_)
static void	ok_iids_ (const input_iids_t *iids, const IID **expected, const IID **exp_broken, BOOL todo, int line)
static const char *	state_to_str (XmlReadState state)
static const char *	type_to_str (XmlNodeType type)
static void	_set_input_string (unsigned line, IXmlReader *reader, const char *xml)
static void	_read_node (unsigned line, IXmlReader *reader, XmlNodeType expected_type)
static void	_next_attribute (unsigned line, IXmlReader *reader)
static void	_move_to_element (unsigned line, IXmlReader *reader)
static void	test_read_state (IXmlReader *reader, XmlReadState expected, XmlReadState exp_broken, int line)
static const WCHAR *	_reader_value (unsigned line, IXmlReader *reader, const char *expect)
static const WCHAR *	_reader_name (unsigned line, IXmlReader *reader, const char *expect)
static const WCHAR *	_reader_prefix (unsigned line, IXmlReader *reader, const char *expect)
static const WCHAR *	_reader_namespace (unsigned line, IXmlReader *reader, const char *expect)
static const WCHAR *	_reader_qname (IXmlReader *reader, const char *expect, unsigned line)
static void	_read_value_char (IXmlReader *reader, WCHAR expected_char, unsigned line)
static testinput *	impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	testinput_QueryInterface (IUnknown *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	testinput_AddRef (IUnknown *iface)
static ULONG WINAPI	testinput_Release (IUnknown *iface)
static HRESULT	testinput_createinstance (void **ppObj)
static HRESULT WINAPI	teststream_QueryInterface (ISequentialStream *iface, REFIID riid, void **obj)
static ULONG WINAPI	teststream_AddRef (ISequentialStream *iface)
static ULONG WINAPI	teststream_Release (ISequentialStream *iface)
static HRESULT WINAPI	teststream_Read (ISequentialStream *iface, void *pv, ULONG cb, ULONG *pread)
static HRESULT WINAPI	teststream_Write (ISequentialStream *iface, const void *pv, ULONG cb, ULONG *written)
static HRESULT WINAPI	resolver_QI (IXmlResolver *iface, REFIID riid, void **obj)
static ULONG WINAPI	resolver_AddRef (IXmlResolver *iface)
static ULONG WINAPI	resolver_Release (IXmlResolver *iface)
static HRESULT WINAPI	resolver_ResolveUri (IXmlResolver *iface, const WCHAR *base_uri, const WCHAR *public_id, const WCHAR *system_id, IUnknown **input)
static void	test_reader_create (void)
static void	test_readerinput (void)
static void	test_reader_state (void)
static void	test_reader_depth (IXmlReader *reader, UINT depth, UINT brk, int line)
static void	test_read_xmldeclaration (void)
static void	test_read_comment (void)
static void	test_read_pi (void)
static void	test_read_full (void)
static void	test_read_public_dtd (void)
static void	test_read_system_dtd (void)
static void	test_read_element (void)
static void	test_read_pending (void)
static void	test_readvaluechunk (void)
static void	test_read_cdata (void)
static void	test_read_text (void)
static void	test_isemptyelement (void)
static void	test_read_attribute (void)
static void	test_reader_properties (void)
static void	test_prefix (void)
static void	test_namespaceuri (void)
static void	test_read_charref (void)
static void	test_encoding_detection (void)
static void	test_eof_state (IXmlReader *reader, BOOL eof)
static void	test_endoffile (void)
static void	test_max_element_depth (void)
static void	test_reader_position (void)
static void	test_string_pointers (void)
static void	test_attribute_by_name (void)
	START_TEST (reader)

Variables
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 const IID *	setinput_full []
static const IID *	setinput_full_old []
static const IID *	setinput_readerinput []
static const IID *	empty_seq []
static input_iids_t	input_iids
static const struct IUnknownVtbl	testinput_vtbl
static int	stream_readcall
static const ISequentialStreamVtbl	teststreamvtbl
static const IXmlResolverVtbl	resolvervtbl
static IXmlResolver	testresolver = { &resolvervtbl }
static struct test_entry	comment_tests []
static struct test_entry	pi_tests []
static const char	misc_test_xml []
static struct nodes_test	misc_test
static const char	test_public_dtd []
static const char	test_system_dtd []
static struct test_entry	element_tests []
static ISequentialStream	teststream = { &teststreamvtbl }
static struct test_entry	cdata_tests []
static struct test_entry	text_tests []
static struct test_entry_empty	empty_element_tests []
static struct test_entry	attributes_tests []

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file reader.c.

CONST_VTABLE

#define CONST_VTABLE

Definition at line 22 of file reader.c.

move_to_element

#define move_to_element

(

a

)

_move_to_element(__LINE__,a)

Definition at line 260 of file reader.c.

next_attribute

#define next_attribute

(

a

)

_next_attribute(__LINE__,a)

Definition at line 252 of file reader.c.

ok_iids

#define ok_iids	(		got,
			exp,
			brk,
			todo
	)		ok_iids_(got, exp, brk, todo, __LINE__)

Definition at line 155 of file reader.c.

read_node

#define read_node	(		a,
			b
	)		_read_node(__LINE__,a,b)

Definition at line 238 of file reader.c.

read_value_char

#define read_value_char	(		a,
			b
	)		_read_value_char(a,b,__LINE__)

Definition at line 359 of file reader.c.

reader_name

#define reader_name	(		a,
			b
	)		_reader_name(__LINE__,a,b)

Definition at line 303 of file reader.c.

reader_namespace

#define reader_namespace	(		a,
			b
	)		_reader_namespace(__LINE__,a,b)

Definition at line 331 of file reader.c.

reader_prefix

#define reader_prefix	(		a,
			b
	)		_reader_prefix(__LINE__,a,b)

Definition at line 317 of file reader.c.

reader_qname

#define reader_qname	(		a,
			b
	)		_reader_qname(a,b,__LINE__)

Definition at line 345 of file reader.c.

reader_value

#define reader_value	(		a,
			b
	)		_reader_value(__LINE__,a,b)

Definition at line 289 of file reader.c.

set_input_string

#define set_input_string	(		a,
			b
	)		_set_input_string(__LINE__,a,b);

Definition at line 224 of file reader.c.

TEST_DEPTH

#define TEST_DEPTH	(		reader,
			depth
	)		test_reader_depth(reader, depth, ~0u, __LINE__)

Definition at line 854 of file reader.c.

TEST_DEPTH2

#define TEST_DEPTH2	(		reader,
			depth,
			brk
	)		test_reader_depth(reader, depth, brk, __LINE__)

Definition at line 855 of file reader.c.

TEST_READER_POSITION

#define TEST_READER_POSITION	(		reader,
			line,
			pos
	)		test_reader_pos(reader, line, pos, ~0u, ~0u, __LINE__)

Definition at line 100 of file reader.c.

TEST_READER_POSITION2

#define TEST_READER_POSITION2	(		reader,
			line,
			pos,
			line_broken,
			pos_broken
	)		test_reader_pos(reader, line, pos, line_broken, pos_broken, __LINE__)

Definition at line 102 of file reader.c.

TEST_READER_STATE

#define TEST_READER_STATE	(		reader,
			state
	)		test_read_state(reader, state, state, __LINE__)

Definition at line 286 of file reader.c.

TEST_READER_STATE2

#define TEST_READER_STATE2	(		reader,
			state,
			brk
	)		test_read_state(reader, state, brk, __LINE__)

Definition at line 287 of file reader.c.

Typedef Documentation

input_iids_t

typedef struct input_iids_t input_iids_t

testinput

typedef struct _testinput testinput

Function Documentation

_move_to_element()

static void _move_to_element ( unsigned  line, IXmlReader *  reader  )

static

Definition at line 261 of file reader.c.

{
    HRESULT hr;
    hr = IXmlReader_MoveToElement(reader);
    ok_(__FILE__,line)(hr == S_OK, "MoveToElement failed: %08x\n", hr);
}

_next_attribute()

static void _next_attribute ( unsigned  line, IXmlReader *  reader  )

static

Definition at line 253 of file reader.c.

{
    HRESULT hr;
    hr = IXmlReader_MoveToNextAttribute(reader);
    ok_(__FILE__,line)(hr == S_OK, "MoveToNextAttribute returned %08x\n", hr);
}

_read_node()

static void _read_node ( unsigned  line, IXmlReader *  reader, XmlNodeType  expected_type  )

static

Definition at line 239 of file reader.c.

{
    XmlNodeType type;
    HRESULT hr;
 
    hr = IXmlReader_Read(reader, &type);
    if (expected_type == XmlNodeType_None)
        ok_(__FILE__,line)(hr == S_FALSE, "Read returned %08x, expected S_FALSE\n", hr);
    else
        ok_(__FILE__,line)(hr == S_OK, "Read returned %08x\n", hr);
    ok_(__FILE__,line)(type == expected_type, "read type %d, expected %d\n", type, expected_type);
}

_read_value_char()

static void _read_value_char ( IXmlReader *  reader, WCHAR  expected_char, unsigned  line  )

static

Definition at line 360 of file reader.c.

{
    WCHAR c = 0xffff;
    UINT count = 0;
    HRESULT hr;
 
    hr = IXmlReader_ReadValueChunk(reader, &c, 1, &count);
    ok_(__FILE__,line)(hr == S_OK, "got %08x\n", hr);
    ok_(__FILE__,line)(count == 1, "got %u\n", c);
    ok_(__FILE__,line)(c == expected_char, "got %x\n", c);
}

_reader_name()

static const WCHAR * _reader_name ( unsigned  line, IXmlReader *  reader, const char *  expect  )

static

Definition at line 304 of file reader.c.

{
    const WCHAR *str = (void*)0xdeadbeef;
    ULONG len = 0xdeadbeef;
    HRESULT hr;
 
    hr = IXmlReader_GetLocalName(reader, &str, &len);
    ok_(__FILE__,line)(hr == S_OK, "GetLocalName returned %08x\n", hr);
    ok_(__FILE__,line)(len == lstrlenW(str), "len = %u\n", len);
    ok_(__FILE__,line)(!strcmp_wa(str, expect), "name = %s\n", wine_dbgstr_w(str));
    return str;
}

_reader_namespace()

static const WCHAR * _reader_namespace ( unsigned  line, IXmlReader *  reader, const char *  expect  )

static

Definition at line 332 of file reader.c.

{
    const WCHAR *str = (void*)0xdeadbeef;
    ULONG len = 0xdeadbeef;
    HRESULT hr;
 
    hr = IXmlReader_GetNamespaceUri(reader, &str, &len);
    ok_(__FILE__,line)(hr == S_OK, "GetNamespaceUri returned %08x\n", hr);
    ok_(__FILE__,line)(len == lstrlenW(str), "len = %u\n", len);
    ok_(__FILE__,line)(!strcmp_wa(str, expect), "namespace = %s\n", wine_dbgstr_w(str));
    return str;
}

_reader_prefix()

static const WCHAR * _reader_prefix ( unsigned  line, IXmlReader *  reader, const char *  expect  )

static

Definition at line 318 of file reader.c.

{
    const WCHAR *str = (void*)0xdeadbeef;
    ULONG len = 0xdeadbeef;
    HRESULT hr;
 
    hr = IXmlReader_GetPrefix(reader, &str, &len);
    ok_(__FILE__,line)(hr == S_OK, "GetPrefix returned %08x\n", hr);
    ok_(__FILE__,line)(len == lstrlenW(str), "len = %u\n", len);
    ok_(__FILE__,line)(!strcmp_wa(str, expect), "prefix = %s\n", wine_dbgstr_w(str));
    return str;
}

_reader_qname()

static const WCHAR * _reader_qname ( IXmlReader *  reader, const char *  expect, unsigned  line  )

static

Definition at line 346 of file reader.c.

{
    const WCHAR *str = (void*)0xdeadbeef;
    ULONG len = 0xdeadbeef;
    HRESULT hr;
 
    hr = IXmlReader_GetQualifiedName(reader, &str, &len);
    ok_(__FILE__,line)(hr == S_OK, "GetQualifiedName returned %08x\n", hr);
    ok_(__FILE__,line)(len == lstrlenW(str), "len = %u\n", len);
    ok_(__FILE__,line)(!strcmp_wa(str, expect), "name = %s\n", wine_dbgstr_w(str));
    return str;
}

_reader_value()

static const WCHAR * _reader_value ( unsigned  line, IXmlReader *  reader, const char *  expect  )

static

Definition at line 290 of file reader.c.

{
    const WCHAR *str = (void*)0xdeadbeef;
    ULONG len = 0xdeadbeef;
    HRESULT hr;
 
    hr = IXmlReader_GetValue(reader, &str, &len);
    ok_(__FILE__,line)(hr == S_OK, "GetValue returned %08x\n", hr);
    ok_(__FILE__,line)(len == lstrlenW(str), "len = %u\n", len);
    ok_(__FILE__,line)(!strcmp_wa(str, expect), "value = %s\n", wine_dbgstr_w(str));
    return str;
}

_set_input_string()

static void _set_input_string ( unsigned  line, IXmlReader *  reader, const char *  xml  )

static

Definition at line 225 of file reader.c.

{
    IStream *stream;
    HRESULT hr;
 
    stream = create_stream_on_data(xml, strlen(xml));
 
    hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
    ok_(__FILE__,line)(hr == S_OK, "got %08x\n", hr);
 
    IStream_Release(stream);
}

a2w()

static WCHAR * a2w ( const char *  str )

static

Definition at line 37 of file reader.c.

{
    int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
    WCHAR *ret = heap_alloc(len * sizeof(WCHAR));
    MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
    return ret;
}

Referenced by strcmp_wa(), test_read_attribute(), test_read_element(), and test_read_pi().

create_stream_on_data()

static IStream * create_stream_on_data ( const void *  data, unsigned int  size  )

static

Definition at line 61 of file reader.c.

{
    IStream *stream = NULL;
    HGLOBAL hglobal;
    void *ptr;
    HRESULT hr;
 
    hglobal = GlobalAlloc(GHND, size);
    ptr = GlobalLock(hglobal);
 
    memcpy(ptr, data, size);
 
    hr = CreateStreamOnHGlobal(hglobal, TRUE, &stream);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(stream != NULL, "Expected non-NULL stream\n");
 
    GlobalUnlock(hglobal);
 
    return stream;
}

Referenced by _set_input_string(), test_encoding_detection(), and test_read_xmldeclaration().

DEFINE_GUID()

DEFINE_GUID	(	IID_IXmlReaderInput	,
		0x0b3ccc9b	,
		0x9214	,
		0x428b	,
		0xa2	,
		0xae	,
		0xef	,
		0x3a	,
		0xa8	,
		0x71	,
		0xaf	,
		0xda
	)

free_str()

static void free_str ( WCHAR *  str )

static

Definition at line 45 of file reader.c.

{
    heap_free(str);
}

Referenced by strcmp_wa(), test_read_attribute(), test_read_element(), and test_read_pi().

impl_from_IUnknown()

static testinput * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 378 of file reader.c.

{
    return CONTAINING_RECORD(iface, testinput, IUnknown_iface);
}

Referenced by testinput_AddRef(), and testinput_Release().

ok_iids_()

static void ok_iids_ ( const input_iids_t *  iids, const IID **  expected, const IID **  exp_broken, BOOL  todo, int  line  )

static

Definition at line 138 of file reader.c.

{
    int i = 0, size = 0;
 
    while (expected[i++]) size++;
 
    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, wine_dbgstr_guid(&iids->iids[i]));
    }
}

resolver_AddRef()

static ULONG WINAPI resolver_AddRef ( IXmlResolver *  iface )

static

Definition at line 508 of file reader.c.

{
    return 2;
}

resolver_QI()

static HRESULT WINAPI resolver_QI ( IXmlResolver *  iface, REFIID  riid, void **  obj  )

static

Definition at line 493 of file reader.c.

{
    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;
}

resolver_Release()

static ULONG WINAPI resolver_Release ( IXmlResolver *  iface )

static

Definition at line 513 of file reader.c.

{
    return 1;
}

resolver_ResolveUri()

static HRESULT WINAPI resolver_ResolveUri ( IXmlResolver *  iface, const WCHAR *  base_uri, const WCHAR *  public_id, const WCHAR *  system_id, IUnknown **  input  )

static

Definition at line 518 of file reader.c.

{
    ok(0, "unexpected call\n");
    return E_NOTIMPL;
}

START_TEST()

START_TEST

(

reader

)

Definition at line 2661 of file reader.c.

{
    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();
    test_reader_properties();
    test_prefix();
    test_namespaceuri();
    test_read_charref();
    test_encoding_detection();
    test_endoffile();
    test_max_element_depth();
    test_reader_position();
    test_string_pointers();
    test_attribute_by_name();
}

state_to_str()

static const char * state_to_str ( XmlReadState  state )

static

Definition at line 157 of file reader.c.

{
    static const char* state_names[] = {
        "XmlReadState_Initial",
        "XmlReadState_Interactive",
        "XmlReadState_Error",
        "XmlReadState_EndOfFile",
        "XmlReadState_Closed"
    };
 
    static const char unknown[] = "unknown";
 
    switch (state)
    {
    case XmlReadState_Initial:
    case XmlReadState_Interactive:
    case XmlReadState_Error:
    case XmlReadState_EndOfFile:
    case XmlReadState_Closed:
        return state_names[state];
    default:
        return unknown;
    }
}

Referenced by test_read_state().

strcmp_wa()

static int strcmp_wa ( const WCHAR *  str1, const char *  stra  )

static

Definition at line 50 of file reader.c.

{
    WCHAR *str2 = a2w(stra);
    int r = lstrcmpW(str1, str2);
    free_str(str2);
    return r;
}

Referenced by _reader_name(), _reader_namespace(), _reader_prefix(), _reader_qname(), _reader_value(), and test_readvaluechunk().

test_attribute_by_name()

static void test_attribute_by_name ( void  )

static

Definition at line 2577 of file reader.c.

{
    static const char *xml = "<a><elem xmlns=\"myns\" a=\"value a\" b=\"value b\" xmlns:ns=\"ns uri\" "
        "ns:c=\"value c\" c=\"value c2\"/></a>";
    static const WCHAR xmlns_uriW[] = {'h','t','t','p',':','/','/','w','w','w','.','w','3','.','o','r','g','/',
        '2','0','0','0','/','x','m','l','n','s','/',0};
    static const WCHAR nsuriW[] = {'n','s',' ','u','r','i',0};
    static const WCHAR xmlnsW[] = {'x','m','l','n','s',0};
    static const WCHAR mynsW[] = {'m','y','n','s',0};
    static const WCHAR nsW[] = {'n','s',0};
    static const WCHAR emptyW[] = {0};
    static const WCHAR aW[] = {'a',0};
    static const WCHAR bW[] = {'b',0};
    static const WCHAR cW[] = {'c',0};
    IXmlReader *reader;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
    ok(hr == S_OK, "Failed to create reader, hr %#x.\n", hr);
 
    set_input_string(reader, xml);
 
    hr = IXmlReader_MoveToAttributeByName(reader, NULL, NULL);
    ok(hr == E_INVALIDARG || broken(hr == S_FALSE) /* WinXP */, "Unexpected hr %#x.\n", hr);
 
    hr = IXmlReader_MoveToAttributeByName(reader, emptyW, NULL);
    ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
 
    read_node(reader, XmlNodeType_Element);
 
    hr = IXmlReader_MoveToAttributeByName(reader, emptyW, NULL);
    ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
 
    read_node(reader, XmlNodeType_Element);
 
    hr = IXmlReader_MoveToAttributeByName(reader, NULL, NULL);
    ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
 
    hr = IXmlReader_MoveToAttributeByName(reader, NULL, xmlns_uriW);
    ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
 
    hr = IXmlReader_MoveToAttributeByName(reader, emptyW, xmlns_uriW);
    ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
 
    hr = IXmlReader_MoveToAttributeByName(reader, xmlnsW, NULL);
    ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
 
    hr = IXmlReader_MoveToAttributeByName(reader, xmlnsW, xmlns_uriW);
    ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
    reader_value(reader, "myns");
 
    hr = IXmlReader_MoveToAttributeByName(reader, aW, NULL);
    ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
    reader_value(reader, "value a");
 
    hr = IXmlReader_MoveToAttributeByName(reader, bW, NULL);
    ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
    reader_value(reader, "value b");
 
    hr = IXmlReader_MoveToAttributeByName(reader, aW, mynsW);
    ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
 
    hr = IXmlReader_MoveToAttributeByName(reader, nsW, NULL);
    ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
 
    hr = IXmlReader_MoveToAttributeByName(reader, nsW, xmlns_uriW);
    ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
    reader_value(reader, "ns uri");
 
    hr = IXmlReader_MoveToAttributeByName(reader, bW, emptyW);
    ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
    reader_value(reader, "value b");
 
    hr = IXmlReader_MoveToAttributeByName(reader, cW, NULL);
    ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
    reader_value(reader, "value c2");
 
    hr = IXmlReader_MoveToAttributeByName(reader, cW, nsuriW);
    ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
    reader_value(reader, "value c");
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_encoding_detection()

static void test_encoding_detection ( void  )

static

Definition at line 2157 of file reader.c.

{
    static const struct encoding_testW
    {
        WCHAR text[16];
    }
    encoding_testsW[] =
    {
        { { '<','?','p','i',' ','?','>',0 } },
        { { '<','!','-','-',' ','c','-','-','>',0 } },
        { { 0xfeff,'<','a','/','>',0 } },
        { { '<','a','/','>',0 } },
    };
    static const char *encoding_testsA[] =
    {
        "<?pi ?>",
        "<!-- comment -->",
        "\xef\xbb\xbf<a/>", /* UTF-8 BOM */
        "<a/>",
    };
    IXmlReader *reader;
    XmlNodeType type;
    IStream *stream;
    unsigned int i;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    /* there's no way to query detected encoding back, so just verify that document is browsable */
 
    for (i = 0; i < ARRAY_SIZE(encoding_testsA); i++)
    {
        set_input_string(reader, encoding_testsA[i]);
 
        type = XmlNodeType_None;
        hr = IXmlReader_Read(reader, &type);
        ok(hr == S_OK, "got %08x\n", hr);
        ok(type != XmlNodeType_None, "Unexpected node type %d\n", type);
    }
 
    for (i = 0; i < ARRAY_SIZE(encoding_testsW); i++)
    {
        stream = create_stream_on_data(encoding_testsW[i].text, lstrlenW(encoding_testsW[i].text) * sizeof(WCHAR));
 
        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, "%u: got %08x\n", i, hr);
        ok(type != XmlNodeType_None, "%u: unexpected node type %d\n", i, type);
 
        IStream_Release(stream);
    }
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_endoffile()

static void test_endoffile ( void  )

static

Definition at line 2227 of file reader.c.

{
    IXmlReader *reader;
    XmlNodeType type;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    test_eof_state(reader, FALSE);
 
    set_input_string(reader, "<a/>");
 
    test_eof_state(reader, FALSE);
 
    type = XmlNodeType_None;
    hr = IXmlReader_Read(reader, &type);
    ok(hr == S_OK, "got %#x\n", hr);
    ok(type == XmlNodeType_Element, "Unexpected type %d\n", type);
 
    test_eof_state(reader, FALSE);
 
    type = XmlNodeType_Element;
    hr = IXmlReader_Read(reader, &type);
    ok(hr == S_FALSE, "got %#x\n", hr);
    ok(type == XmlNodeType_None, "Unexpected type %d\n", type);
 
    test_eof_state(reader, TRUE);
 
    hr = IXmlReader_SetInput(reader, NULL);
    ok(hr == S_OK, "got %08x\n", hr);
 
    test_eof_state(reader, FALSE);
 
    IXmlReader_Release(reader);
 
    hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    set_input_string(reader, "<a/>text");
 
    type = XmlNodeType_None;
    hr = IXmlReader_Read(reader, &type);
    ok(hr == S_OK, "got %#x\n", hr);
    ok(type == XmlNodeType_Element, "Unexpected type %d\n", type);
 
    test_eof_state(reader, FALSE);
 
    type = XmlNodeType_Element;
    hr = IXmlReader_Read(reader, &type);
    ok(hr == WC_E_SYNTAX, "got %#x\n", hr);
    ok(type == XmlNodeType_None, "Unexpected type %d\n", type);
 
    test_eof_state(reader, FALSE);
 
    hr = IXmlReader_SetInput(reader, NULL);
    ok(hr == S_OK, "got %08x\n", hr);
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_eof_state()

static void test_eof_state ( IXmlReader *  reader, BOOL  eof  )

static

Definition at line 2216 of file reader.c.

{
    LONG_PTR state;
    HRESULT hr;
 
    ok(IXmlReader_IsEOF(reader) == eof, "Unexpected IsEOF() result\n");
    hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, &state);
    ok(hr == S_OK, "GetProperty() failed, %#x\n", hr);
    ok((state == XmlReadState_EndOfFile) == eof, "Unexpected EndOfFile state %ld\n", state);
}

Referenced by test_endoffile().

test_isemptyelement()

static void test_isemptyelement ( void  )

static

Definition at line 1833 of file reader.c.

{
    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;
        BOOL ret;
 
        set_input_string(reader, test->xml);
 
        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);
 
        test++;
    }
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_max_element_depth()

static void test_max_element_depth ( void  )

static

Definition at line 2288 of file reader.c.

{
    static const char *xml =
        "<a>"
            "<b attrb=\"_b\">"
                "<c>"
                   "<d></d>"
                "</c>"
            "</b>"
        "</a>";
    XmlNodeType nodetype;
    unsigned int count;
    IXmlReader *reader;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    set_input_string(reader, xml);
 
    hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MaxElementDepth, 2);
    ok(hr == S_OK, "got %08x\n", hr);
 
    TEST_DEPTH(reader, 0);
 
    hr = IXmlReader_Read(reader, NULL);
    ok(hr == S_OK, "got %08x\n", hr);
 
    TEST_DEPTH(reader, 0);
 
    hr = IXmlReader_Read(reader, NULL);
    ok(hr == S_OK, "got %08x\n", hr);
 
    TEST_DEPTH(reader, 1);
    TEST_READER_STATE(reader, XmlReadState_Interactive);
 
    hr = IXmlReader_Read(reader, NULL);
    ok(hr == SC_E_MAXELEMENTDEPTH, "got %08x\n", hr);
 
    TEST_DEPTH2(reader, 0, 2);
    TEST_READER_STATE(reader, XmlReadState_Error);
 
    hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MaxElementDepth, 10);
    ok(hr == S_OK, "got %08x\n", hr);
 
    hr = IXmlReader_Read(reader, NULL);
    ok(hr == SC_E_MAXELEMENTDEPTH, "got %08x\n", hr);
 
    TEST_DEPTH2(reader, 0, 2);
    TEST_READER_STATE(reader, XmlReadState_Error);
 
    /* test if stepping into attributes enforces depth limit too */
    set_input_string(reader, xml);
 
    hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MaxElementDepth, 2);
    ok(hr == S_OK, "got %08x\n", hr);
 
    TEST_DEPTH(reader, 0);
 
    hr = IXmlReader_Read(reader, NULL);
    ok(hr == S_OK, "got %08x\n", hr);
 
    TEST_DEPTH(reader, 0);
 
    hr = IXmlReader_Read(reader, NULL);
    ok(hr == S_OK, "got %08x\n", hr);
 
    TEST_DEPTH(reader, 1);
 
    hr = IXmlReader_MoveToFirstAttribute(reader);
    ok(hr == S_OK, "got %08x\n", hr);
 
    TEST_DEPTH(reader, 2);
    TEST_READER_STATE(reader, XmlReadState_Interactive);
 
    nodetype = 123;
    hr = IXmlReader_Read(reader, &nodetype);
    ok(hr == SC_E_MAXELEMENTDEPTH, "got %08x\n", hr);
    ok(nodetype == XmlNodeType_None, "got node type %d\n", nodetype);
 
    nodetype = 123;
    hr = IXmlReader_Read(reader, &nodetype);
    ok(hr == SC_E_MAXELEMENTDEPTH, "got %08x\n", hr);
    ok(nodetype == XmlNodeType_None, "got node type %d\n", nodetype);
 
    TEST_DEPTH2(reader, 0, 2);
    TEST_READER_STATE(reader, XmlReadState_Error);
 
    /* set max depth to 0, this disables depth limit */
    set_input_string(reader, xml);
 
    hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MaxElementDepth, 0);
    ok(hr == S_OK, "got %08x\n", hr);
 
    count = 0;
    while (IXmlReader_Read(reader, NULL) == S_OK)
        count++;
    ok(count == 8, "Unexpected node number %u\n", count);
    TEST_READER_STATE(reader, XmlReadState_EndOfFile);
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_namespaceuri()

static void test_namespaceuri ( void  )

static

Definition at line 2028 of file reader.c.

{
    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>",
                { "", "", "", "", "" }},
        { "<a>text</a>",
                { "", "", "" }},
        { "<a>\r\n</a>",
                { "", "", "" }},
        { "<a><![CDATA[data]]></a>",
                { "", "", "" }},
        { "<?xml version=\"1.0\" ?><a/>",
                { "", "" }},
        { "<a><?pi ?></a>",
                { "", "", "" }},
        { "<a><!-- comment --></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 < ARRAY_SIZE(uri_tests); i++) {
        unsigned int j = 0;
 
        set_input_string(reader, uri_tests[i].xml);
 
        type = ~0u;
        while (IXmlReader_Read(reader, &type) == S_OK) {
            const WCHAR *local, *qname;
            UINT length, length2;
 
            ok(type == XmlNodeType_Element ||
                    type == XmlNodeType_Text ||
                    type == XmlNodeType_CDATA ||
                    type == XmlNodeType_ProcessingInstruction ||
                    type == XmlNodeType_Comment ||
                    type == XmlNodeType_Whitespace ||
                    type == XmlNodeType_EndElement ||
                    type == XmlNodeType_XmlDeclaration, "Unexpected node type %d.\n", type);
 
            local = NULL;
            length = 0;
            hr = IXmlReader_GetLocalName(reader, &local, &length);
            ok(hr == S_OK, "S_OK, got %08x\n", hr);
            ok(local != NULL, "Unexpected NULL local name pointer\n");
 
            qname = NULL;
            length2 = 0;
            hr = IXmlReader_GetQualifiedName(reader, &qname, &length2);
            ok(hr == S_OK, "S_OK, got %08x\n", hr);
            ok(qname != NULL, "Unexpected NULL qualified name pointer\n");
 
            if (type == XmlNodeType_Element ||
                    type == XmlNodeType_EndElement ||
                    type == XmlNodeType_ProcessingInstruction ||
                    type == XmlNodeType_XmlDeclaration)
            {
                ok(*local != 0, "Unexpected empty local name\n");
                ok(length > 0, "Unexpected local name length\n");
 
                ok(*qname != 0, "Unexpected empty qualified name\n");
                ok(length2 > 0, "Unexpected qualified name length\n");
            }
 
            reader_namespace(reader, uri_tests[i].uri[j]);
 
            j++;
        }
        ok(type == XmlNodeType_None, "Unexpected node type %d\n", type);
    }
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_prefix()

static void test_prefix ( void  )

static

Definition at line 1972 of file reader.c.

{
    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" },
        { "<c:b xmlns:c=\"c ns\" xml:a=\"a ns\"/>", "c", "xmlns", "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 < ARRAY_SIZE(prefix_tests); i++) {
        XmlNodeType type;
 
        set_input_string(reader, prefix_tests[i].xml);
 
        hr = IXmlReader_Read(reader, &type);
        ok(hr == S_OK, "Read() failed, %#x\n", hr);
        ok(type == XmlNodeType_Element, "Unexpected node type %d.\n", type);
 
        reader_prefix(reader, prefix_tests[i].prefix1);
 
        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);
 
        reader_prefix(reader, prefix_tests[i].prefix2);
 
        next_attribute(reader);
 
        hr = IXmlReader_GetNodeType(reader, &type);
        ok(hr == S_OK, "GetNodeType() failed, %#x.\n", hr);
        ok(type == XmlNodeType_Attribute, "Unexpected node type %d.\n", type);
 
        reader_prefix(reader, prefix_tests[i].prefix3);
 
        /* back to the element, check prefix */
        move_to_element(reader);
        reader_prefix(reader, prefix_tests[i].prefix1);
    }
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_attribute()

static void test_read_attribute ( void  )

static

Definition at line 1887 of file reader.c.

{
    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;
 
        set_input_string(reader, test->xml);
 
        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);
 
            reader_name(reader, test->name);
 
            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 */
            reader_value(reader, test->value);
        }
 
        test++;
    }
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_cdata()

static void test_read_cdata ( void  )

static

Definition at line 1688 of file reader.c.

{
    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;
 
        set_input_string(reader, test->xml);
 
        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;
            UINT len;
 
            ok(type == XmlNodeType_CDATA, "got %d for %s\n", type, test->xml);
 
            reader_name(reader, "");
 
            str = NULL;
            hr = IXmlReader_GetLocalName(reader, &str, NULL);
            ok(hr == S_OK, "got 0x%08x\n", hr);
            ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
 
            len = 1;
            str = NULL;
            hr = IXmlReader_GetQualifiedName(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));
 
            str = NULL;
            hr = IXmlReader_GetQualifiedName(reader, &str, NULL);
            ok(hr == S_OK, "got 0x%08x\n", hr);
            ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
 
            /* value */
            reader_value(reader, test->value);
        }
 
        test++;
    }
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_charref()

static void test_read_charref ( void  )

static

Definition at line 2120 of file reader.c.

{
    static const char testA[] = "<a b=\"c\">&#x1f3;&#x103;&gt;</a>";
    static const WCHAR chardataW[] = {0x01f3,0x0103,'>',0};
    const WCHAR *value;
    IXmlReader *reader;
    XmlNodeType type;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    set_input_string(reader, testA);
 
    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);
 
    hr = IXmlReader_Read(reader, &type);
    ok(hr == S_FALSE, "got %08x\n", hr);
    ok(type == XmlNodeType_None, "Unexpected node type %d\n", type);
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_comment()

static void test_read_comment ( void  )

static

Definition at line 1062 of file reader.c.

{
    static const char *teststr = "<a>text<!-- comment --></a>";
    struct test_entry *test = comment_tests;
    static const XmlNodeType types[] =
    {
        XmlNodeType_Element,
        XmlNodeType_Text,
        XmlNodeType_Comment,
        XmlNodeType_EndElement,
    };
    unsigned int i = 0;
    IXmlReader *reader;
    XmlNodeType type;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    set_input_string(reader, teststr);
 
    while (IXmlReader_Read(reader, &type) == S_OK)
    {
        const WCHAR *value;
 
        ok(type == types[i], "%d: unexpected node type %d\n", i, type);
 
        if (type == XmlNodeType_Text || type == XmlNodeType_Comment)
        {
            hr = IXmlReader_GetValue(reader, &value, NULL);
            ok(hr == S_OK, "got %08x\n", hr);
            ok(*value != 0, "Expected node value\n");
        }
        i++;
    }
 
    while (test->xml)
    {
        set_input_string(reader, test->xml);
 
        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;
 
            ok(type == XmlNodeType_Comment, "got %d for %s\n", type, test->xml);
 
            reader_name(reader, "");
 
            str = NULL;
            hr = IXmlReader_GetLocalName(reader, &str, NULL);
            ok(hr == S_OK, "got 0x%08x\n", hr);
            ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
 
            reader_qname(reader, "");
 
            str = NULL;
            hr = IXmlReader_GetQualifiedName(reader, &str, NULL);
            ok(hr == S_OK, "got 0x%08x\n", hr);
            ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
 
            /* value */
            reader_value(reader, test->value);
        }
 
        test++;
    }
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_element()

static void test_read_element ( void  )

static

Definition at line 1405 of file reader.c.

{
    struct test_entry *test = element_tests;
    static const char stag[] =
         "<a attr1=\"_a\">"
             "<b attr2=\"_b\">"
                 "text"
                 "<c attr3=\"_c\"/>"
                 "<d attr4=\"_d\"></d>"
             "</b>"
         "</a>";
    static const UINT depths[] = { 0, 1, 2, 2, 2, 3, 2, 1 };
    IXmlReader *reader;
    XmlNodeType type;
    unsigned int i;
    UINT depth;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    while (test->xml)
    {
        set_input_string(reader, test->xml);
 
        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 */
            reader_value(reader, "");
        }
 
        test++;
    }
 
    /* test reader depth increment */
    set_input_string(reader, stag);
 
    i = 0;
    while (IXmlReader_Read(reader, &type) == S_OK)
    {
        UINT count;
 
        ok(type == XmlNodeType_Element || type == XmlNodeType_EndElement ||
                type == XmlNodeType_Text, "Unexpected node type %d\n", type);
 
        depth = 123;
        hr = IXmlReader_GetDepth(reader, &depth);
        ok(hr == S_OK, "got %08x\n", hr);
        ok(depth == depths[i], "%u: got depth %u, expected %u\n", i, depth, depths[i]);
 
        if (type == XmlNodeType_Element || type == XmlNodeType_EndElement)
        {
            const WCHAR *prefix;
 
            prefix = NULL;
            hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
            ok(hr == S_OK, "got %08x\n", hr);
            ok(prefix != NULL, "got %p\n", prefix);
 
            if (!*prefix)
            {
                const WCHAR *local, *qname;
 
                local = NULL;
                hr = IXmlReader_GetLocalName(reader, &local, NULL);
                ok(hr == S_OK, "got %08x\n", hr);
                ok(local != NULL, "got %p\n", local);
 
                qname = NULL;
                hr = IXmlReader_GetQualifiedName(reader, &qname, NULL);
                ok(hr == S_OK, "got %08x\n", hr);
                ok(qname != NULL, "got %p\n", qname);
 
                ok(local == qname, "expected same pointer\n");
            }
        }
 
        if (type == XmlNodeType_EndElement)
        {
            count = 1;
            hr = IXmlReader_GetAttributeCount(reader, &count);
            ok(hr == S_OK, "got %08x\n", hr);
            ok(count == 0, "got %u\n", count);
        }
 
        if (type == XmlNodeType_Element)
        {
            count = 0;
            hr = IXmlReader_GetAttributeCount(reader, &count);
            ok(hr == S_OK, "got %08x\n", hr);
 
            /* moving to attributes increases depth */
            if (count)
            {
                const WCHAR *value;
 
                reader_value(reader, "");
 
                hr = IXmlReader_MoveToFirstAttribute(reader);
                ok(hr == S_OK, "got %08x\n", hr);
 
                hr = IXmlReader_GetValue(reader, &value, NULL);
                ok(*value != 0, "Unexpected value %s\n", wine_dbgstr_w(value));
 
                depth = 123;
                hr = IXmlReader_GetDepth(reader, &depth);
                ok(hr == S_OK, "got %08x\n", hr);
                ok(depth == depths[i] + 1, "%u: got depth %u, expected %u\n", i, depth, depths[i] + 1);
 
                move_to_element(reader);
                reader_value(reader, "");
 
                depth = 123;
                hr = IXmlReader_GetDepth(reader, &depth);
                ok(hr == S_OK, "got %08x\n", hr);
                ok(depth == depths[i], "%u: got depth %u, expected %u\n", i, depth, depths[i]);
            }
        }
 
        i++;
    }
 
    /* start/end tag mismatch */
    set_input_string(reader, "<a></b>");
 
    read_node(reader, XmlNodeType_Element);
 
    type = XmlNodeType_Element;
    hr = IXmlReader_Read(reader, &type);
    ok(hr == WC_E_ELEMENTMATCH, "got %08x\n", hr);
    ok(type == XmlNodeType_None, "got %d\n", type);
    TEST_READER_STATE(reader, XmlReadState_Error);
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_full()

static void test_read_full ( void  )

static

Definition at line 1250 of file reader.c.

{
    struct nodes_test *test = &misc_test;
    IXmlReader *reader;
    HRESULT hr;
    int i;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    set_input_string(reader, test->xml);
 
    i = 0;
    do
    {
        read_node(reader, test->nodes[i].type);
        reader_value(reader, test->nodes[i].value);
    } while(test->nodes[i++].type != XmlNodeType_None);
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_pending()

static void test_read_pending ( void  )

static

Definition at line 1565 of file reader.c.

{
    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 */
todo_wine
    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);
}

Referenced by START_TEST().

test_read_pi()

static void test_read_pi ( void  )

static

Definition at line 1152 of file reader.c.

{
    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;
 
        set_input_string(reader, test->xml);
 
        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);
 
            reader_name(reader, test->name);
 
            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 */
            reader_value(reader, test->value);
        }
 
        test++;
    }
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_public_dtd()

static void test_read_public_dtd ( void  )

static

Definition at line 1275 of file reader.c.

{
    static const WCHAR dtdnameW[] = {'t','e','s','t','d','t','d',0};
    IXmlReader *reader;
    const WCHAR *str;
    XmlNodeType type;
    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);
 
    set_input_string(reader, test_public_dtd);
 
    read_node(reader, XmlNodeType_DocumentType);
 
    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);
 
    reader_name(reader, "PUBLIC");
    reader_value(reader, "pubid");
 
    next_attribute(reader);
 
    type = XmlNodeType_None;
    hr = IXmlReader_GetNodeType(reader, &type);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(type == XmlNodeType_Attribute, "got %d\n", type);
 
    reader_name(reader, "SYSTEM");
    reader_value(reader, "externalid uri");
 
    move_to_element(reader);
    reader_name(reader, "testdtd");
 
    len = 0;
    str = NULL;
    hr = IXmlReader_GetQualifiedName(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));
}
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_state()

static void test_read_state ( IXmlReader *  reader, XmlReadState  expected, XmlReadState  exp_broken, int  line  )

static

Definition at line 268 of file reader.c.

{
    BOOL broken_state;
    LONG_PTR state;
 
    state = -1; /* invalid state value */
    IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, &state);
 
    if (exp_broken == expected)
        broken_state = FALSE;
    else
        broken_state = broken(exp_broken == state);
 
    ok_(__FILE__, line)(state == expected || broken_state, "Expected (%s), got (%s)\n",
            state_to_str(expected), state_to_str(state));
}

test_read_system_dtd()

static void test_read_system_dtd ( void  )

static

Definition at line 1338 of file reader.c.

{
    static const WCHAR dtdnameW[] = {'t','e','s','t','d','t','d',0};
    IXmlReader *reader;
    const WCHAR *str;
    XmlNodeType type;
    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);
 
    set_input_string(reader, test_system_dtd);
 
    read_node(reader, XmlNodeType_DocumentType);
 
    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);
 
    reader_name(reader, "SYSTEM");
    reader_value(reader, "externalid uri");
 
    move_to_element(reader);
    reader_name(reader, "testdtd");
 
    len = 0;
    str = NULL;
    hr = IXmlReader_GetQualifiedName(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));
}
 
    read_node(reader, XmlNodeType_Comment);
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_text()

static void test_read_text ( void  )

static

Definition at line 1761 of file reader.c.

{
    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;
 
        set_input_string(reader, test->xml);
 
        type = XmlNodeType_None;
        hr = IXmlReader_Read(reader, &type);
 
        /* read one more to get to text node */
        if (type == XmlNodeType_Element)
        {
            type = XmlNodeType_None;
            hr = IXmlReader_Read(reader, &type);
        }
        ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
        if (hr == S_OK)
        {
            const WCHAR *str;
            UINT len;
 
            ok(type == XmlNodeType_Text, "got %d for %s\n", type, test->xml);
 
            reader_name(reader, "");
 
            str = NULL;
            hr = IXmlReader_GetLocalName(reader, &str, NULL);
            ok(hr == S_OK, "got 0x%08x\n", hr);
            ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
 
            len = 1;
            str = NULL;
            hr = IXmlReader_GetQualifiedName(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));
 
            str = NULL;
            hr = IXmlReader_GetQualifiedName(reader, &str, NULL);
            ok(hr == S_OK, "got 0x%08x\n", hr);
            ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
 
            /* value */
            reader_value(reader, test->value);
        }
 
        test++;
    }
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_read_xmldeclaration()

static void test_read_xmldeclaration ( void  )

static

Definition at line 857 of file reader.c.

{
    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, len, i;
    BOOL ret;
    const WCHAR *val;
 
    hr = CreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    stream = create_stream_on_data(xmldecl_full, sizeof(xmldecl_full));
 
    hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    hr = IXmlReader_GetAttributeCount(reader, &count);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(count == 0, "got %d\n", count);
 
    /* try to move without attributes */
    hr = IXmlReader_MoveToElement(reader);
    ok(hr == S_FALSE, "got %08x\n", hr);
 
    hr = IXmlReader_MoveToNextAttribute(reader);
    ok(hr == S_FALSE, "got %08x\n", hr);
 
    hr = IXmlReader_MoveToFirstAttribute(reader);
    ok(hr == S_FALSE, "got %08x\n", hr);
 
    TEST_READER_POSITION(reader, 0, 0);
 
    read_node(reader, XmlNodeType_XmlDeclaration);
 
    /* new version 1.2.x and 1.3.x properly update position for <?xml ?> */
    TEST_READER_POSITION2(reader, 1, 3, ~0u, 55);
 
    TEST_DEPTH(reader, 0);
    TEST_READER_STATE(reader, XmlReadState_Interactive);
 
    reader_value(reader, "");
 
    /* check attributes */
    next_attribute(reader);
 
    TEST_DEPTH(reader, 1);
 
    type = XmlNodeType_None;
    hr = IXmlReader_GetNodeType(reader, &type);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(type == XmlNodeType_Attribute, "got %d\n", type);
 
    TEST_READER_POSITION2(reader, 1, 7, ~0u, 55);
 
    /* try to move from last attribute */
    next_attribute(reader);
    next_attribute(reader);
    hr = IXmlReader_MoveToNextAttribute(reader);
    ok(hr == S_FALSE, "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);
 
    hr = IXmlReader_MoveToFirstAttribute(reader);
    ok(hr == S_OK, "got %08x\n", hr);
    TEST_READER_POSITION2(reader, 1, 7, ~0u, 55);
 
    hr = IXmlReader_GetAttributeCount(reader, NULL);
    ok(hr == E_INVALIDARG, "got %08x\n", hr);
 
    hr = IXmlReader_GetAttributeCount(reader, &count);
    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);
    }
 
    TEST_DEPTH(reader, 1);
 
    move_to_element(reader);
    TEST_READER_POSITION2(reader, 1, 3, ~0u, 55);
 
    type = XmlNodeType_None;
    hr = IXmlReader_GetNodeType(reader, &type);
    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);
 
    read_node(reader, XmlNodeType_XmlDeclaration);
    TEST_READER_POSITION2(reader, 1, 3, ~0u, 21);
    TEST_READER_STATE(reader, XmlReadState_Interactive);
 
    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");
 
    reader_value(reader, "");
    reader_name(reader, "xml");
 
    reader_qname(reader, "xml");
 
    /* check attributes */
    next_attribute(reader);
 
    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);
    TEST_READER_POSITION2(reader, 1, 7, ~0u, 21);
 
    /* try to move from last attribute */
    hr = IXmlReader_MoveToNextAttribute(reader);
    ok(hr == S_FALSE, "expected S_FALSE, got %08x\n", hr);
 
    read_node(reader, XmlNodeType_Element);
    TEST_READER_POSITION2(reader, 1, 23, ~0u, 40);
    TEST_READER_STATE(reader, XmlReadState_Interactive);
 
    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");
 
    reader_value(reader, "");
    reader_name(reader, "RegistrationInfo");
 
    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);
    ok(type == XmlNodeType_None, "expected XmlNodeType_None, got %s\n", type_to_str(type));
    TEST_READER_POSITION(reader, 1, 41);
todo_wine
    TEST_READER_STATE(reader, XmlReadState_Error);
 
    IStream_Release(stream);
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_reader_create()

static void test_reader_create ( void  )

static

Definition at line 535 of file reader.c.

{
    IXmlResolver *resolver;
    IUnknown *input, *unk;
    IXmlReader *reader;
#ifdef __REACTOS__
    ULONG_PTR dtd;
#else
    DtdProcessing dtd;
#endif
    XmlNodeType nodetype;
    HRESULT hr;
 
    /* crashes native */
    if (0)
    {
        CreateXmlReader(&IID_IXmlReader, NULL, NULL);
        CreateXmlReader(NULL, (void**)&reader, NULL);
    }
 
    hr = CreateXmlReader(&IID_IStream, (void **)&unk, NULL);
    ok(hr == E_NOINTERFACE, "got %08x\n", hr);
 
    hr = CreateXmlReader(&IID_IUnknown, (void **)&unk, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    hr = IUnknown_QueryInterface(unk, &IID_IXmlReader, (void **)&reader);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(unk == (IUnknown *)reader, "unexpected interface\n");
    IXmlReader_Release(reader);
    IUnknown_Release(unk);
 
    hr = CreateXmlReader(&IID_IUnknown, (void **)&reader, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    IXmlReader_Release(reader);
 
    hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    TEST_READER_STATE(reader, XmlReadState_Closed);
 
    nodetype = XmlNodeType_Element;
    hr = IXmlReader_GetNodeType(reader, &nodetype);
    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);
    ok(dtd == DtdProcessing_Prohibit, "got %Id\n", dtd);
 
    dtd = 2;
    hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, dtd);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 
    hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, -1);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 
    /* Null input pointer, releases previous input */
    hr = IXmlReader_SetInput(reader, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    TEST_READER_STATE2(reader, XmlReadState_Initial, XmlReadState_Closed);
 
    /* test input interface selection sequence */
    hr = testinput_createinstance((void**)&input);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    if (hr == S_OK)
    {
        input_iids.count = 0;
        hr = IXmlReader_SetInput(reader, input);
        ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
        ok_iids(&input_iids, setinput_full, setinput_full_old, FALSE);
        IUnknown_Release(input);
    }
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_reader_depth()

static void test_reader_depth ( IXmlReader *  reader, UINT  depth, UINT  brk, int  line  )

static

Definition at line 841 of file reader.c.

{
    BOOL condition;
    UINT d = ~0u;
 
    IXmlReader_GetDepth(reader, &d);
 
    condition = d == depth;
    if (brk != ~0u)
        condition |= broken(d == brk);
    ok_(__FILE__, line)(condition, "Unexpected nesting depth %u, expected %u\n", d, depth);
}

test_reader_pos()

static void test_reader_pos ( IXmlReader *  reader, UINT  line, UINT  pos, UINT  line_broken, UINT  pos_broken, int  _line_  )

static

Definition at line 82 of file reader.c.

{
    UINT l = ~0u, p = ~0u;
    BOOL broken_state;
 
    IXmlReader_GetLineNumber(reader, &l);
    IXmlReader_GetLinePosition(reader, &p);
 
    if (line_broken == ~0u && pos_broken == ~0u)
        broken_state = FALSE;
    else
        broken_state = broken((line_broken == ~0u ? line : line_broken) == l &&
                              (pos_broken == ~0u ? pos : pos_broken) == p);
 
    ok_(__FILE__, _line_)((l == line && pos == p) || broken_state,
            "Expected (%d,%d), got (%d,%d)\n", line, pos, l, p);
}

test_reader_position()

static void test_reader_position ( void  )

static

Definition at line 2391 of file reader.c.

{
    static const char *xml = "<c:a xmlns:c=\"nsdef c\" b=\"attr b\">\n</c:a>";
    IXmlReader *reader;
    XmlNodeType type;
    UINT position;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    TEST_READER_STATE(reader, XmlReadState_Closed);
 
    /* position methods with Null args */
    hr = IXmlReader_GetLineNumber(reader, NULL);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 
    hr = IXmlReader_GetLinePosition(reader, NULL);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 
    position = 123;
    hr = IXmlReader_GetLinePosition(reader, &position);
    ok(hr == S_FALSE, "got %#x\n", hr);
    ok(position == 0, "got %u\n", position);
 
    position = 123;
    hr = IXmlReader_GetLineNumber(reader, &position);
    ok(hr == S_FALSE, "got %#x\n", hr);
    ok(position == 0, "got %u\n", position);
 
    set_input_string(reader, xml);
 
    TEST_READER_STATE(reader, XmlReadState_Initial);
    TEST_READER_POSITION(reader, 0, 0);
    hr = IXmlReader_Read(reader, &type);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(type == XmlNodeType_Element, "got type %d\n", type);
    TEST_READER_POSITION2(reader, 1, 2, ~0u, 34);
 
    next_attribute(reader);
    TEST_READER_POSITION2(reader, 1, 6, ~0u, 34);
 
    next_attribute(reader);
    TEST_READER_POSITION2(reader, 1, 24, ~0u, 34);
 
    move_to_element(reader);
    TEST_READER_POSITION2(reader, 1, 2, ~0u, 34);
 
    hr = IXmlReader_Read(reader, &type);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(type == XmlNodeType_Whitespace, "got type %d\n", type);
    TEST_READER_POSITION2(reader, 1, 35, 2, 6);
 
    hr = IXmlReader_Read(reader, &type);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(type == XmlNodeType_EndElement, "got type %d\n", type);
    TEST_READER_POSITION2(reader, 2, 3, 2, 6);
 
    hr = IXmlReader_SetInput(reader, NULL);
    ok(hr == S_OK, "got %08x\n", hr);
    TEST_READER_STATE2(reader, XmlReadState_Initial, XmlReadState_Closed);
    TEST_READER_POSITION(reader, 0, 0);
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_reader_properties()

static void test_reader_properties ( void  )

static

Definition at line 1944 of file reader.c.

{
    IXmlReader *reader;
    LONG_PTR value;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    value = 0;
    hr = IXmlReader_GetProperty(reader, XmlReaderProperty_MaxElementDepth, &value);
    ok(hr == S_OK, "GetProperty failed: %08x\n", hr);
    ok(value == 256, "Unexpected default max depth value %ld\n", value);
 
    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);
 
    value = 256;
    hr = IXmlReader_GetProperty(reader, XmlReaderProperty_MaxElementDepth, &value);
    ok(hr == S_OK, "GetProperty failed: %08x\n", hr);
    ok(value == 0, "Unexpected max depth value %ld\n", value);
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_reader_state()

static void test_reader_state ( void  )

static

Definition at line 798 of file reader.c.

{
    XmlNodeType nodetype;
    IXmlReader *reader;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    /* invalid arguments */
    hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, NULL);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 
    /* attempt to read on closed reader */
    TEST_READER_STATE(reader, XmlReadState_Closed);
 
if (0)
{
    /* newer versions crash here, probably because no input was set */
    hr = IXmlReader_Read(reader, &nodetype);
    ok(hr == S_FALSE, "got %08x\n", hr);
}
    set_input_string(reader, "xml");
    TEST_READER_STATE(reader, XmlReadState_Initial);
 
    nodetype = XmlNodeType_Element;
    hr = IXmlReader_Read(reader, &nodetype);
todo_wine
    ok(FAILED(hr), "got %08x\n", hr);
    ok(nodetype == XmlNodeType_None, "Unexpected node type %d\n", nodetype);
 
todo_wine
    TEST_READER_STATE(reader, XmlReadState_Error);
 
    nodetype = XmlNodeType_Element;
    hr = IXmlReader_Read(reader, &nodetype);
todo_wine
    ok(FAILED(hr), "got %08x\n", hr);
    ok(nodetype == XmlNodeType_None, "Unexpected node type %d\n", nodetype);
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_readerinput()

static void test_readerinput ( void  )

static

Definition at line 640 of file reader.c.

{
    IXmlReaderInput *reader_input;
    IXmlReader *reader, *reader2;
    IUnknown *obj, *input;
    IStream *stream, *stream2;
    XmlNodeType nodetype;
    HRESULT hr;
    LONG ref;
 
    hr = CreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, NULL);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
    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);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    ref = IStream_AddRef(stream);
    ok(ref == 2, "Expected 2, got %d\n", ref);
    IStream_Release(stream);
    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);
    ok(hr == E_NOINTERFACE, "Expected S_OK, got %08x\n", hr);
 
    hr = IUnknown_QueryInterface(reader_input, &IID_ISequentialStream, (void**)&stream2);
    ok(hr == E_NOINTERFACE, "Expected S_OK, got %08x\n", hr);
 
    /* IXmlReaderInput grabs a stream reference */
    ref = IStream_AddRef(stream);
    ok(ref == 3, "Expected 3, got %d\n", ref);
    IStream_Release(stream);
 
    /* try ::SetInput() with valid IXmlReaderInput */
    hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    ref = IUnknown_AddRef(reader_input);
    ok(ref == 2, "Expected 2, got %d\n", ref);
    IUnknown_Release(reader_input);
 
    hr = IXmlReader_SetInput(reader, reader_input);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    TEST_READER_STATE(reader, XmlReadState_Initial);
 
    nodetype = XmlNodeType_Element;
    hr = IXmlReader_GetNodeType(reader, &nodetype);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(nodetype == XmlNodeType_None, "got %d\n", nodetype);
 
    /* IXmlReader grabs a IXmlReaderInput reference */
    ref = IUnknown_AddRef(reader_input);
    ok(ref == 3, "Expected 3, got %d\n", ref);
    IUnknown_Release(reader_input);
 
    ref = IStream_AddRef(stream);
    ok(ref == 4, "Expected 4, got %d\n", ref);
    IStream_Release(stream);
 
    /* reset input and check state */
    hr = IXmlReader_SetInput(reader, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    TEST_READER_STATE2(reader, XmlReadState_Initial, XmlReadState_Closed);
 
    IXmlReader_Release(reader);
 
    ref = IStream_AddRef(stream);
    ok(ref == 3, "Expected 3, got %d\n", ref);
    IStream_Release(stream);
 
    ref = IUnknown_AddRef(reader_input);
    ok(ref == 2, "Expected 2, got %d\n", ref);
    IUnknown_Release(reader_input);
 
    /* IID_IXmlReaderInput */
    /* it returns a kind of private undocumented vtable incompatible with IUnknown,
       so it's not a COM interface actually.
       Such query will be used only to check if input is really IXmlReaderInput */
    obj = (IUnknown*)0xdeadbeef;
    hr = IUnknown_QueryInterface(reader_input, &IID_IXmlReaderInput, (void**)&obj);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ref = IUnknown_AddRef(reader_input);
    ok(ref == 3, "Expected 3, got %d\n", ref);
    IUnknown_Release(reader_input);
 
    IUnknown_Release(reader_input);
    IUnknown_Release(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);
 
    input_iids.count = 0;
    ref = IUnknown_AddRef(input);
    ok(ref == 2, "Expected 2, got %d\n", ref);
    IUnknown_Release(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 */
    ref = IUnknown_AddRef(input);
    ok(ref == 3, "Expected 3, got %d\n", ref);
    IUnknown_Release(input);
 
    hr = CreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    input_iids.count = 0;
    ref = IUnknown_AddRef(reader_input);
    ok(ref == 2, "Expected 2, got %d\n", ref);
    IUnknown_Release(reader_input);
    ref = IUnknown_AddRef(input);
    ok(ref == 3, "Expected 3, got %d\n", ref);
    IUnknown_Release(input);
    hr = IXmlReader_SetInput(reader, reader_input);
    ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
    ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
 
    TEST_READER_STATE(reader, XmlReadState_Closed);
 
    ref = IUnknown_AddRef(input);
    ok(ref == 3, "Expected 3, got %d\n", ref);
    IUnknown_Release(input);
 
    ref = IUnknown_AddRef(reader_input);
    ok(ref == 3 || broken(ref == 2) /* versions 1.0.x and 1.1.x - XP, Vista */,
          "Expected 3, got %d\n", ref);
    IUnknown_Release(reader_input);
    /* repeat another time, no check or caching here */
    input_iids.count = 0;
    hr = IXmlReader_SetInput(reader, reader_input);
    ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
    ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
 
    /* another reader */
    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
       ::SetInput() level, each time it's called */
    input_iids.count = 0;
    hr = IXmlReader_SetInput(reader2, reader_input);
    ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
    ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
 
    IXmlReader_Release(reader2);
    IXmlReader_Release(reader);
 
    IUnknown_Release(reader_input);
    IUnknown_Release(input);
}

Referenced by START_TEST().

test_readvaluechunk()

static void test_readvaluechunk ( void  )

static

Definition at line 1601 of file reader.c.

{
    IXmlReader *reader;
    XmlNodeType type;
    WCHAR buf[64];
    WCHAR b;
    HRESULT hr;
    UINT c;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    set_input_string(reader, "<!-- comment1 --><!-- comment2 -->");
 
    hr = IXmlReader_Read(reader, &type);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(type == XmlNodeType_Comment, "type = %u\n", type);
 
    read_value_char(reader, ' ');
    read_value_char(reader, 'c');
 
    /* portion read as chunk is skipped from resulting node value */
    reader_value(reader, "omment1 ");
 
    /* 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);
 
    c = 0xdeadbeef;
    hr = IXmlReader_ReadValueChunk(reader, buf, 0, &c);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(!c, "c = %u\n", c);
 
    reader_value(reader, "omment1 ");
 
    /* read comment2 */
    read_node(reader, XmlNodeType_Comment);
 
    c = 0xdeadbeef;
    hr = IXmlReader_ReadValueChunk(reader, buf, 0, &c);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(!c, "c = %u\n", c);
 
    c = 0xdeadbeef;
    memset(buf, 0xcc, sizeof(buf));
    hr = IXmlReader_ReadValueChunk(reader, buf, ARRAY_SIZE(buf), &c);
    ok(hr == S_OK, "got %08x\n", hr);
    ok(c == 10, "got %u\n", c);
    ok(buf[c] == 0xcccc, "buffer overflow\n");
    buf[c] = 0;
    ok(!strcmp_wa(buf, " comment2 "), "buf = %s\n", wine_dbgstr_w(buf));
 
    c = 0xdeadbeef;
    memset(buf, 0xcc, sizeof(buf));
    hr = IXmlReader_ReadValueChunk(reader, buf, ARRAY_SIZE(buf), &c);
    ok(hr == S_FALSE, "got %08x\n", hr);
    ok(!c, "got %u\n", c);
 
    /* portion read as chunk is skipped from resulting node value */
    reader_value(reader, "");
 
    /* once value is returned/allocated it's not possible to read by chunk */
    c = 0xdeadbeef;
    b = 0xffff;
    hr = IXmlReader_ReadValueChunk(reader, &b, 1, &c);
    ok(hr == S_FALSE, "got %08x\n", hr);
    ok(c == 0, "got %u\n", c);
    ok(b == 0xffff, "got %x\n", b);
 
    reader_value(reader, "");
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

test_string_pointers()

static void test_string_pointers ( void  )

static

Definition at line 2457 of file reader.c.

{
    const WCHAR *ns, *nsq, *empty, *xmlns_ns, *xmlns_name, *name, *p, *q, *xml, *ptr, *value;
    IXmlReader *reader;
    HRESULT hr;
 
    hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
    ok(hr == S_OK, "S_OK, got %08x\n", hr);
 
    set_input_string(reader, "<elem xmlns=\"myns\">myns<elem2 /></elem>");
 
    read_node(reader, XmlNodeType_Element);
    empty = reader_value(reader, "");
    ok(empty == reader_prefix(reader, ""), "empty != prefix\n");
    name = reader_name(reader, "elem");
    ok(name == reader_qname(reader, "elem"), "name != qname\n");
    ns = reader_namespace(reader, "myns");
 
    next_attribute(reader);
    ptr = reader_value(reader, "myns");
    if (ns != ptr)
    {
        win_skip("attr value is different than namespace pointer, assuming old xmllite\n");
        IXmlReader_Release(reader);
        return;
    }
    ok(ns == ptr, "ns != value\n");
    ok(empty == reader_prefix(reader, ""), "empty != prefix\n");
    xmlns_ns = reader_namespace(reader, "http://www.w3.org/2000/xmlns/");
    xmlns_name = reader_name(reader, "xmlns");
    ok(xmlns_name == reader_qname(reader, "xmlns"), "xmlns_name != qname\n");
 
    read_node(reader, XmlNodeType_Text);
    ok(ns != reader_value(reader, "myns"), "ns == value\n");
    ok(empty == reader_prefix(reader, ""), "empty != prefix\n");
    ok(empty == reader_namespace(reader, ""), "empty != namespace\n");
    ok(empty == reader_name(reader, ""), "empty != name\n");
    ok(empty == reader_qname(reader, ""), "empty != qname\n");
 
    read_node(reader, XmlNodeType_Element);
    ok(empty == reader_prefix(reader, ""), "empty != prefix\n");
    ok(ns == reader_namespace(reader, "myns"), "empty != namespace\n");
 
    read_node(reader, XmlNodeType_EndElement);
    ok(empty == reader_prefix(reader, ""), "empty != prefix\n");
    ok(name == reader_name(reader, "elem"), "empty != name\n");
    ok(name == reader_qname(reader, "elem"), "empty != qname\n");
    ok(ns == reader_namespace(reader, "myns"), "empty != namespace\n");
 
    set_input_string(reader, "<elem xmlns:p=\"myns\" xmlns:q=\"mynsq\"><p:elem2 q:attr=\"\"></p:elem2></elem>");
 
    read_node(reader, XmlNodeType_Element);
    ok(empty == reader_prefix(reader, ""), "empty != prefix\n");
    name = reader_name(reader, "elem");
    ok(empty == reader_namespace(reader, ""), "empty != namespace\n");
 
    next_attribute(reader);
    ns = reader_value(reader, "myns");
    ok(xmlns_name == reader_prefix(reader, "xmlns"), "xmlns_name != prefix\n");
    p = reader_name(reader, "p");
    ok(xmlns_ns == reader_namespace(reader, "http://www.w3.org/2000/xmlns/"), "xmlns_ns != namespace\n");
 
    next_attribute(reader);
    nsq = reader_value(reader, "mynsq");
    ok(xmlns_name == reader_prefix(reader, "xmlns"), "xmlns_name != prefix\n");
    q = reader_name(reader, "q");
    ok(xmlns_ns == reader_namespace(reader, "http://www.w3.org/2000/xmlns/"), "xmlns_ns != namespace\n");
 
    read_node(reader, XmlNodeType_Element);
    ok(p == reader_prefix(reader, "p"), "p != prefix\n");
    ok(ns == reader_namespace(reader, "myns"), "empty != namespace\n");
    name = reader_qname(reader, "p:elem2");
 
    next_attribute(reader);
    ok(empty != reader_value(reader, ""), "empty == value\n");
    ok(q == reader_prefix(reader, "q"), "q != prefix\n");
    ok(nsq == reader_namespace(reader, "mynsq"), "nsq != namespace\n");
 
    read_node(reader, XmlNodeType_EndElement);
    ptr = reader_qname(reader, "p:elem2"); todo_wine ok(name != ptr, "q == qname\n");
 
    set_input_string(reader, "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n");
 
    read_node(reader, XmlNodeType_XmlDeclaration);
    ok(empty == reader_value(reader, ""), "empty != value\n");
    ok(empty == reader_prefix(reader, ""), "empty != prefix\n");
    xml = reader_name(reader, "xml");
    ptr = reader_qname(reader, "xml"); todo_wine ok(xml == ptr, "xml != qname\n");
    ok(empty == reader_namespace(reader, ""), "empty != namespace\n");
 
    next_attribute(reader);
    ok(empty == reader_prefix(reader, ""), "empty != prefix\n");
    ok(empty == reader_namespace(reader, ""), "empty != namespace\n");
 
    set_input_string(reader, "<elem xmlns:p=\"myns\"><p:elem2 attr=\"\" /></elem>");
 
    read_node(reader, XmlNodeType_Element);
    next_attribute(reader);
    read_value_char(reader, 'm');
    p = reader_value(reader, "yns");
 
    read_node(reader, XmlNodeType_Element);
    ns = reader_namespace(reader, "myns");
    ok(ns+1 == p, "ns+1 != p\n");
 
    set_input_string(reader, "<elem attr=\"value\"></elem>");
 
    read_node(reader, XmlNodeType_Element);
    next_attribute(reader);
    name = reader_name(reader, "attr");
    value = reader_value(reader, "value");
 
    move_to_element(reader);
    next_attribute(reader);
    ok(name == reader_name(reader, "attr"), "attr pointer changed\n");
    ok(value == reader_value(reader, "value"), "value pointer changed\n");
 
    IXmlReader_Release(reader);
}

Referenced by START_TEST().

testinput_AddRef()

static ULONG WINAPI testinput_AddRef ( IUnknown *  iface )

static

Definition at line 399 of file reader.c.

{
    testinput *This = impl_from_IUnknown(iface);
    return InterlockedIncrement(&This->ref);
}

testinput_createinstance()

static HRESULT testinput_createinstance ( void **  ppObj )

static

Definition at line 424 of file reader.c.

{
    testinput *input;
 
    input = heap_alloc(sizeof(*input));
    if(!input) return E_OUTOFMEMORY;
 
    input->IUnknown_iface.lpVtbl = &testinput_vtbl;
    input->ref = 1;
 
    *ppObj = &input->IUnknown_iface;
 
    return S_OK;
}

Referenced by test_reader_create(), and test_readerinput().

testinput_QueryInterface()

static HRESULT WINAPI testinput_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  ppvObj  )

static

Definition at line 383 of file reader.c.

{
    if (IsEqualGUID( riid, &IID_IUnknown ))
    {
        *ppvObj = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
 
    input_iids.iids[input_iids.count++] = *riid;
 
    *ppvObj = NULL;
 
    return E_NOINTERFACE;
}

testinput_Release()

static ULONG WINAPI testinput_Release ( IUnknown *  iface )

static

Definition at line 405 of file reader.c.

{
    testinput *This = impl_from_IUnknown(iface);
    LONG ref;
 
    ref = InterlockedDecrement(&This->ref);
    if (ref == 0)
        heap_free(This);
 
    return ref;
}

teststream_AddRef()

static ULONG WINAPI teststream_AddRef ( ISequentialStream *  iface )

static

Definition at line 451 of file reader.c.

{
    return 2;
}

teststream_QueryInterface()

static HRESULT WINAPI teststream_QueryInterface ( ISequentialStream *  iface, REFIID  riid, void **  obj  )

static

Definition at line 439 of file reader.c.

{
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_ISequentialStream))
    {
        *obj = iface;
        return S_OK;
    }
 
    *obj = NULL;
    return E_NOINTERFACE;
}

teststream_Read()

static HRESULT WINAPI teststream_Read ( ISequentialStream *  iface, void *  pv, ULONG  cb, ULONG *  pread  )

static

Definition at line 463 of file reader.c.

{
    static const char xml[] = "<!-- comment -->";
 
    if (stream_readcall++)
    {
        *pread = 0;
        return E_PENDING;
    }
 
    *pread = sizeof(xml) / 2;
    memcpy(pv, xml, *pread);
    return S_OK;
}

teststream_Release()

static ULONG WINAPI teststream_Release ( ISequentialStream *  iface )

static

Definition at line 456 of file reader.c.

{
    return 1;
}

teststream_Write()

static HRESULT WINAPI teststream_Write ( ISequentialStream *  iface, const void *  pv, ULONG  cb, ULONG *  written  )

static

Definition at line 478 of file reader.c.

{
    ok(0, "unexpected call\n");
    return E_NOTIMPL;
}

type_to_str()

static const char * type_to_str ( XmlNodeType  type )

static

Definition at line 182 of file reader.c.

{
    static const char* type_names[] = {
        "XmlNodeType_None",
        "XmlNodeType_Element",
        "XmlNodeType_Attribute",
        "XmlNodeType_Text",
        "XmlNodeType_CDATA",
        "", "",
        "XmlNodeType_ProcessingInstruction",
        "XmlNodeType_Comment",
        "",
        "XmlNodeType_DocumentType",
        "", "",
        "XmlNodeType_Whitespace",
        "",
        "XmlNodeType_EndElement",
        "",
        "XmlNodeType_XmlDeclaration"
    };
 
    static const char unknown[] = "unknown";
 
    switch (type)
    {
    case XmlNodeType_None:
    case XmlNodeType_Element:
    case XmlNodeType_Attribute:
    case XmlNodeType_Text:
    case XmlNodeType_CDATA:
    case XmlNodeType_ProcessingInstruction:
    case XmlNodeType_Comment:
    case XmlNodeType_DocumentType:
    case XmlNodeType_Whitespace:
    case XmlNodeType_EndElement:
    case XmlNodeType_XmlDeclaration:
        return type_names[type];
    default:
        return unknown;
    }
}

Referenced by test_read_xmldeclaration().

Variable Documentation

attributes_tests

struct test_entry attributes_tests[]

static

Initial value:

= {
    { "<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&#32;\"/>", "attr1", "val ", S_OK },
    { "<a attr1=\"val&#x20;\"/>", "attr1", "val ", S_OK },
    { "<a attr1=\"&lt;&gt;&amp;&apos;&quot;\"/>", "attr1", "<>&\'\"", S_OK },
    { "<a attr1=\"&entname;\"/>", NULL, NULL, WC_E_UNDECLAREDENTITY },
    { "<a attr1=\"val&#xfffe;\"/>", NULL, NULL, WC_E_XMLCHARACTER },
    { "<a attr1=\"val &#a;\"/>", NULL, NULL, WC_E_DIGIT, WC_E_SEMICOLON },
    { "<a attr1=\"val &#12a;\"/>", NULL, NULL, WC_E_SEMICOLON },
    { "<a attr1=\"val &#x12g;\"/>", 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 }
}

Definition at line 1863 of file reader.c.

Referenced by test_read_attribute().

cdata_tests

struct test_entry cdata_tests[]

static

Initial value:

= {
    { "<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 },
    { "<a><![CDATA[\r \r\r\n \n\n ]]></a>", "", "\n \n\n \n\n ", S_OK, S_OK },
    { "<a><![CDATA[\r\r \n\r \r \n\n ]]></a>", "", "\n\n \n\n \n \n\n ", S_OK },
    { NULL }
}

Definition at line 1679 of file reader.c.

Referenced by test_read_cdata().

comment_tests

struct test_entry comment_tests[]

static

Initial value:

= {
    { "<!-- 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 }
}

Definition at line 1054 of file reader.c.

Referenced by test_read_comment().

element_tests

struct test_entry element_tests[]

static

Initial value:

= {
    { "<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 },
    { "<a:b:c />", NULL, NULL, NC_E_QNAMECOLON },
    { "<:b:c />", NULL, NULL, NC_E_QNAMECHARACTER },
    { NULL }
}

Definition at line 1390 of file reader.c.

Referenced by test_read_element().

empty_element_tests

struct test_entry_empty empty_element_tests[]

static

Initial value:

= {
    { "<a></a>", FALSE },
    { "<a/>", TRUE },
    { NULL }
}

Definition at line 1827 of file reader.c.

Referenced by test_isemptyelement().

empty_seq

const IID* empty_seq[]

static

Initial value:

= {
    NULL
}

Definition at line 132 of file reader.c.

Referenced by test_readerinput().

input_iids

input_iids_t input_iids

static

Definition at line 136 of file reader.c.

Referenced by test_reader_create(), test_readerinput(), and testinput_QueryInterface().

misc_test

struct nodes_test misc_test

static

Initial value:

= {
    misc_test_xml,
    {
        {XmlNodeType_Comment, " comment1 "},
        {XmlNodeType_Comment, " comment2 "},
        {XmlNodeType_ProcessingInstruction, "pi1body "},
        {XmlNodeType_Comment, " comment3 "},
        {XmlNodeType_Whitespace, " \t \n \n"},
        {XmlNodeType_Comment, " comment4 "},
        {XmlNodeType_Element, ""},
        {XmlNodeType_Whitespace, "\n\t"},
        {XmlNodeType_Element, ""},
        {XmlNodeType_Text, "text"},
        {XmlNodeType_Comment, " comment "},
        {XmlNodeType_Text, "text2"},
        {XmlNodeType_ProcessingInstruction, "pibody "},
        {XmlNodeType_Whitespace, "\n"},
        {XmlNodeType_EndElement, ""},
        {XmlNodeType_None, ""}
    }
}

Definition at line 1228 of file reader.c.

Referenced by test_read_full().

misc_test_xml

const char misc_test_xml[]

static

Initial value:

=
    "<!-- comment1 -->"
    "<!-- comment2 -->"
    "<?pi1 pi1body ?>"
    "<!-- comment3 -->"
    " \t \r \n"
    "<!-- comment4 -->"
    "<a>"
    "\r\n\t"
    "<b/>"
    "text"
    "<!-- comment -->"
    "text2"
    "<?pi pibody ?>"
    "\r\n"
    "</a>"

Definition at line 1210 of file reader.c.

pi_tests

struct test_entry pi_tests[]

static

Initial value:

= {
    { "<?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 }
}

Definition at line 1138 of file reader.c.

Referenced by test_read_pi().

resolvervtbl

const IXmlResolverVtbl resolvervtbl

static

Initial value:

=
{
    resolver_QI,
    resolver_AddRef,
    resolver_Release,
    resolver_ResolveUri
}

Definition at line 525 of file reader.c.

setinput_full

const IID* setinput_full[]

static

Initial value:

= {
    &IID_IXmlReaderInput,
    &IID_IStream,
    &IID_ISequentialStream,
    NULL
}

Definition at line 110 of file reader.c.

Referenced by test_reader_create().

setinput_full_old

const IID* setinput_full_old[]

static

Initial value:

= {
    &IID_IXmlReaderInput,
    &IID_ISequentialStream,
    &IID_IStream,
    NULL
}

Definition at line 118 of file reader.c.

Referenced by test_reader_create().

setinput_readerinput

const IID* setinput_readerinput[]

static

Initial value:

= {
    &IID_IStream,
    &IID_ISequentialStream,
    NULL
}

Definition at line 126 of file reader.c.

Referenced by test_readerinput().

stream_readcall

int stream_readcall

static

Definition at line 461 of file reader.c.

Referenced by test_read_pending(), and teststream_Read().

test_public_dtd

const char test_public_dtd[]

static

Initial value:

=
    "<!DOCTYPE testdtd PUBLIC \"pubid\" \"externalid uri\" >"

Definition at line 1272 of file reader.c.

Referenced by test_read_public_dtd().

test_system_dtd

const char test_system_dtd[]

static

Initial value:

=
    "<!DOCTYPE testdtd SYSTEM \"externalid uri\" >"
    "<!-- comment -->"

Definition at line 1334 of file reader.c.

Referenced by test_read_system_dtd().

testinput_vtbl

const struct IUnknownVtbl testinput_vtbl

static

Initial value:

=
{
    testinput_QueryInterface,
    testinput_AddRef,
    testinput_Release
}

Definition at line 417 of file reader.c.

Referenced by testinput_createinstance().

testresolver

IXmlResolver testresolver = { &resolvervtbl }

static

Definition at line 533 of file reader.c.

Referenced by test_reader_create().

teststream

ISequentialStream teststream = { &teststreamvtbl }

static

Definition at line 1563 of file reader.c.

Referenced by test_read_pending().

teststreamvtbl

const ISequentialStreamVtbl teststreamvtbl

static

Initial value:

=
{
    teststream_QueryInterface,
    teststream_AddRef,
    teststream_Release,
    teststream_Read,
    teststream_Write
}

Definition at line 484 of file reader.c.

text_tests

struct test_entry text_tests[]

static

Initial value:

= {
    { "<a>simple text</a>", "", "simple text", S_OK },
    { "<a>text ]]> text</a>", "", "", WC_E_CDSECTEND },
    { "<a>\n \r\n \n\n text</a>", "", "\n \n \n\n text", S_OK, S_OK },
    { "<a>\r \r\r\n \n\n text</a>", "", "\n \n\n \n\n text", S_OK, S_OK },
    { NULL }
}

Definition at line 1753 of file reader.c.

Referenced by test_read_text().

xmldecl_full

const char xmldecl_full[] = "\xef\xbb\xbf<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n"

static

Definition at line 58 of file reader.c.

Referenced by test_read_xmldeclaration().

xmldecl_short

const char xmldecl_short[] = "<?xml version=\"1.0\"?><RegistrationInfo/>"

static

Definition at line 59 of file reader.c.

Referenced by test_read_xmldeclaration().