saxreader.c File Reference

#include <stdio.h>
#include <assert.h>
#include "windows.h"
#include "ole2.h"
#include "msxml2.h"
#include "msxml2did.h"
#include "ocidl.h"
#include "dispex.h"
#include "wine/heap.h"
#include "wine/test.h"

Include dependency graph for saxreader.c:

Go to the source code of this file.

Classes
struct	msxmlsupported_data_t
struct	attribute_entry
struct	call_entry
struct	call_sequence
struct	saxlexicalhandler
struct	saxdeclhandler
struct	mxwriter_write_test_t
struct	mxwriter_stream_test_t
struct	saxreader_props_test_t
struct	feature_ns_entry_t
struct	enc_test_entry_t
struct	mxwriter_props_t
struct	writer_startendelement_t
struct	writer_startendelement2_t
struct	writer_characters_t
struct	addattribute_test_t

Macros
#define	COBJMACROS
#define	CONST_VTABLE
#define	EXPECT_HR(hr, hr_exp)    ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
#define	EXPECT_REF(obj, ref)   _expect_ref((IUnknown*)obj, ref, __LINE__)
#define	CONTENT_HANDLER_INDEX   0
#define	NUM_CALL_SEQUENCES   1
#define	ok_sequence(seq, index, exp, contx, todo)    ok_sequence_(seq, index, (exp), (contx), (todo), __FILE__, __LINE__)

Typedefs
typedef enum _CH	CH
typedef struct mxwriter_write_test_t	mxwriter_write_test
typedef struct mxwriter_stream_test_t	mxwriter_stream_test

Enumerations
enum	_CH {   CH_ENDTEST , CH_PUTDOCUMENTLOCATOR , CH_STARTDOCUMENT , CH_ENDDOCUMENT ,   CH_STARTPREFIXMAPPING , CH_ENDPREFIXMAPPING , CH_STARTELEMENT , CH_ENDELEMENT ,   CH_CHARACTERS , CH_IGNORABLEWHITESPACE , CH_PROCESSINGINSTRUCTION , CH_SKIPPEDENTITY ,   LH_STARTCDATA , LH_ENDCDATA , EH_ERROR , EH_FATALERROR ,   EH_IGNORABLEWARNING , EVENT_LAST }
enum	startendtype { StartElement = 0x001 , EndElement = 0x010 , StartEndElement = 0x011 , DisableEscaping = 0x100 }

Functions
static void	_expect_ref (IUnknown *obj, ULONG ref, int line)
static LONG	get_refcount (void *iface)
static BOOL	is_clsid_supported (const GUID *clsid, const struct msxmlsupported_data_t *table)
static BSTR	alloc_str_from_narrow (const char *str)
static BSTR	_bstr_ (const char *str)
static void	free_bstrs (void)
static void	test_saxstr (const char *file, unsigned line, BSTR str, const char *expected, BOOL todo, int *failcount)
static void	init_call_entry (ISAXLocator *locator, struct call_entry *call)
static void	add_call (struct call_sequence **seq, int sequence_index, const struct call_entry *call)
static void	flush_sequence (struct call_sequence **seg, int sequence_index)
static const char *	get_event_name (CH event)
static void	compare_attributes (const struct call_entry *actual, const struct call_entry *expected, const char *context, BOOL todo, const char *file, int line, int *failcount)
static void	ok_sequence_ (struct call_sequence **seq, int sequence_index, const struct call_entry *expected, const char *context, BOOL todo, const char *file, int line)
static void	init_call_sequences (struct call_sequence **seq, int n)
static void	set_expected_seq (struct call_entry *expected)
static HRESULT	get_expected_ret (void)
static HRESULT WINAPI	contentHandler_QueryInterface (ISAXContentHandler *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	contentHandler_AddRef (ISAXContentHandler *iface)
static ULONG WINAPI	contentHandler_Release (ISAXContentHandler *iface)
static HRESULT WINAPI	contentHandler_putDocumentLocator (ISAXContentHandler *iface, ISAXLocator *pLocator)
static HRESULT WINAPI	contentHandler_startDocument (ISAXContentHandler *iface)
static HRESULT WINAPI	contentHandler_endDocument (ISAXContentHandler *iface)
static HRESULT WINAPI	contentHandler_startPrefixMapping (ISAXContentHandler *iface, const WCHAR *prefix, int prefix_len, const WCHAR *uri, int uri_len)
static HRESULT WINAPI	contentHandler_endPrefixMapping (ISAXContentHandler *iface, const WCHAR *prefix, int len)
static HRESULT WINAPI	contentHandler_startElement (ISAXContentHandler *iface, const WCHAR *uri, int uri_len, const WCHAR *localname, int local_len, const WCHAR *qname, int qname_len, ISAXAttributes *saxattr)
static HRESULT WINAPI	contentHandler_endElement (ISAXContentHandler *iface, const WCHAR *uri, int uri_len, const WCHAR *localname, int local_len, const WCHAR *qname, int qname_len)
static HRESULT WINAPI	contentHandler_characters (ISAXContentHandler *iface, const WCHAR *chars, int len)
static HRESULT WINAPI	contentHandler_ignorableWhitespace (ISAXContentHandler *iface, const WCHAR *chars, int len)
static HRESULT WINAPI	contentHandler_processingInstruction (ISAXContentHandler *iface, const WCHAR *target, int target_len, const WCHAR *data, int data_len)
static HRESULT WINAPI	contentHandler_skippedEntity (ISAXContentHandler *iface, const WCHAR *name, int len)
static HRESULT WINAPI	isaxerrorHandler_QueryInterface (ISAXErrorHandler *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	isaxerrorHandler_AddRef (ISAXErrorHandler *iface)
static ULONG WINAPI	isaxerrorHandler_Release (ISAXErrorHandler *iface)
static HRESULT WINAPI	isaxerrorHandler_error (ISAXErrorHandler *iface, ISAXLocator *pLocator, const WCHAR *pErrorMessage, HRESULT hrErrorCode)
static HRESULT WINAPI	isaxerrorHandler_fatalError (ISAXErrorHandler *iface, ISAXLocator *pLocator, const WCHAR *message, HRESULT hr)
static HRESULT WINAPI	isaxerrorHandler_ignorableWarning (ISAXErrorHandler *iface, ISAXLocator *pLocator, const WCHAR *pErrorMessage, HRESULT hrErrorCode)
static HRESULT WINAPI	isaxattributes_QueryInterface (ISAXAttributes *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	isaxattributes_AddRef (ISAXAttributes *iface)
static ULONG WINAPI	isaxattributes_Release (ISAXAttributes *iface)
static HRESULT WINAPI	isaxattributes_getLength (ISAXAttributes *iface, int *length)
static HRESULT WINAPI	isaxattributes_getURI (ISAXAttributes *iface, int nIndex, const WCHAR **pUrl, int *pUriSize)
static HRESULT WINAPI	isaxattributes_getLocalName (ISAXAttributes *iface, int nIndex, const WCHAR **pLocalName, int *pLocalNameLength)
static HRESULT WINAPI	isaxattributes_getQName (ISAXAttributes *iface, int index, const WCHAR **QName, int *QNameLength)
static HRESULT WINAPI	isaxattributes_getName (ISAXAttributes *iface, int nIndex, const WCHAR **pUri, int *pUriLength, const WCHAR **pLocalName, int *pLocalNameSize, const WCHAR **pQName, int *pQNameLength)
static HRESULT WINAPI	isaxattributes_getIndexFromName (ISAXAttributes *iface, const WCHAR *pUri, int cUriLength, const WCHAR *pLocalName, int cocalNameLength, int *index)
static HRESULT WINAPI	isaxattributes_getIndexFromQName (ISAXAttributes *iface, const WCHAR *pQName, int nQNameLength, int *index)
static HRESULT WINAPI	isaxattributes_getType (ISAXAttributes *iface, int nIndex, const WCHAR **pType, int *pTypeLength)
static HRESULT WINAPI	isaxattributes_getTypeFromName (ISAXAttributes *iface, const WCHAR *pUri, int nUri, const WCHAR *pLocalName, int nLocalName, const WCHAR **pType, int *nType)
static HRESULT WINAPI	isaxattributes_getTypeFromQName (ISAXAttributes *iface, const WCHAR *pQName, int nQName, const WCHAR **pType, int *nType)
static HRESULT WINAPI	isaxattributes_getValue (ISAXAttributes *iface, int index, const WCHAR **value, int *nValue)
static HRESULT WINAPI	isaxattributes_getValueFromName (ISAXAttributes *iface, const WCHAR *pUri, int nUri, const WCHAR *pLocalName, int nLocalName, const WCHAR **pValue, int *nValue)
static HRESULT WINAPI	isaxattributes_getValueFromQName (ISAXAttributes *iface, const WCHAR *pQName, int nQName, const WCHAR **pValue, int *nValue)
static struct saxlexicalhandler *	impl_from_ISAXLexicalHandler (ISAXLexicalHandler *iface)
static HRESULT WINAPI	isaxlexical_QueryInterface (ISAXLexicalHandler *iface, REFIID riid, void **out)
static ULONG WINAPI	isaxlexical_AddRef (ISAXLexicalHandler *iface)
static ULONG WINAPI	isaxlexical_Release (ISAXLexicalHandler *iface)
static HRESULT WINAPI	isaxlexical_startDTD (ISAXLexicalHandler *iface, const WCHAR *pName, int nName, const WCHAR *pPublicId, int nPublicId, const WCHAR *pSystemId, int nSystemId)
static HRESULT WINAPI	isaxlexical_endDTD (ISAXLexicalHandler *iface)
static HRESULT WINAPI	isaxlexical_startEntity (ISAXLexicalHandler *iface, const WCHAR *pName, int nName)
static HRESULT WINAPI	isaxlexical_endEntity (ISAXLexicalHandler *iface, const WCHAR *pName, int nName)
static HRESULT WINAPI	isaxlexical_startCDATA (ISAXLexicalHandler *iface)
static HRESULT WINAPI	isaxlexical_endCDATA (ISAXLexicalHandler *iface)
static HRESULT WINAPI	isaxlexical_comment (ISAXLexicalHandler *iface, const WCHAR *pChars, int nChars)
static void	init_saxlexicalhandler (struct saxlexicalhandler *handler, HRESULT hr)
static struct saxdeclhandler *	impl_from_ISAXDeclHandler (ISAXDeclHandler *iface)
static HRESULT WINAPI	isaxdecl_QueryInterface (ISAXDeclHandler *iface, REFIID riid, void **out)
static ULONG WINAPI	isaxdecl_AddRef (ISAXDeclHandler *iface)
static ULONG WINAPI	isaxdecl_Release (ISAXDeclHandler *iface)
static HRESULT WINAPI	isaxdecl_elementDecl (ISAXDeclHandler *iface, const WCHAR *pName, int nName, const WCHAR *pModel, int nModel)
static HRESULT WINAPI	isaxdecl_attributeDecl (ISAXDeclHandler *iface, const WCHAR *pElementName, int nElementName, const WCHAR *pAttributeName, int nAttributeName, const WCHAR *pType, int nType, const WCHAR *pValueDefault, int nValueDefault, const WCHAR *pValue, int nValue)
static HRESULT WINAPI	isaxdecl_internalEntityDecl (ISAXDeclHandler *iface, const WCHAR *pName, int nName, const WCHAR *pValue, int nValue)
static HRESULT WINAPI	isaxdecl_externalEntityDecl (ISAXDeclHandler *iface, const WCHAR *pName, int nName, const WCHAR *pPublicId, int nPublicId, const WCHAR *pSystemId, int nSystemId)
static void	init_saxdeclhandler (struct saxdeclhandler *handler, HRESULT hr)
static HRESULT WINAPI	istream_QueryInterface (IStream *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	istream_AddRef (IStream *iface)
static ULONG WINAPI	istream_Release (IStream *iface)
static HRESULT WINAPI	istream_Read (IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
static HRESULT WINAPI	istream_Write (IStream *iface, const void *pv, ULONG cb, ULONG *pcbWritten)
static HRESULT WINAPI	istream_Seek (IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
static HRESULT WINAPI	istream_SetSize (IStream *iface, ULARGE_INTEGER libNewSize)
static HRESULT WINAPI	istream_CopyTo (IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *plibWritten)
static HRESULT WINAPI	istream_Commit (IStream *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	istream_Revert (IStream *iface)
static HRESULT WINAPI	istream_LockRegion (IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	istream_UnlockRegion (IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT WINAPI	istream_Stat (IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
static HRESULT WINAPI	istream_Clone (IStream *iface, IStream **ppstm)
static HRESULT WINAPI	mxstream_Write (IStream *iface, const void *pv, ULONG cb, ULONG *pcbWritten)
static HRESULT WINAPI	instream_Read (IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
static IStream *	create_test_stream (const char *data, int len)
static void	test_saxreader (void)
static void	test_saxreader_properties (void)
static void	test_saxreader_features (void)
static void	test_saxreader_encoding (void)
static void	test_mxwriter_handlers (void)
static void	test_mxwriter_default_properties (const struct mxwriter_props_t *table)
static void	test_mxwriter_properties (void)
static void	test_mxwriter_flush (void)
static void	test_mxwriter_startenddocument (void)
static void	get_class_support_data (struct msxmlsupported_data_t *table, REFIID riid)
static void	test_mxwriter_startendelement_batch (const struct writer_startendelement_t *table)
static void	test_mxwriter_startendelement_batch2 (const struct writer_startendelement2_t *table)
static void	test_mxwriter_startendelement (void)
static void	test_mxwriter_characters (void)
static void	test_mxwriter_stream (void)
static void	test_mxwriter_encoding (void)
static void	test_obj_dispex (IUnknown *obj)
static void	test_saxreader_dispex (void)
static void	test_mxwriter_dispex (void)
static void	test_mxwriter_comment (void)
static void	test_mxwriter_cdata (void)
static void	test_mxwriter_pi (void)
static void	test_mxwriter_ignorablespaces (void)
static void	test_mxwriter_dtd (void)
static void	test_mxattr_addAttribute (void)
static void	test_mxattr_clear (void)
static void	test_mxattr_dispex (void)
static void	test_mxattr_qi (void)
static void	test_mxattr_localname (void)
static void	test_mxwriter_indent (void)
	START_TEST (saxreader)

Variables
static const WCHAR	emptyW [] = {0}
static BSTR	alloced_bstrs [512]
static int	alloced_bstrs_count
static const char *	event_names [EVENT_LAST]
static struct call_sequence *	sequences [NUM_CALL_SEQUENCES]
static const WCHAR	szSimpleXML []
static const WCHAR	carriage_ret_test []
static const WCHAR	szUtf16XML []
static const CHAR	szUtf16BOM [] = {0xff, 0xfe}
static const CHAR	szUtf8XML []
static const char	utf8xml2 []
static const char	testXML []
static const char	test_attributes []
static const char	test_cdata_xml []
static const char	test2_cdata_xml []
static const char	test3_cdata_xml []
static struct call_entry	content_handler_test1 []
static struct call_entry	content_handler_test1_alternate []
static struct call_entry	content_handler_test2 []
static struct call_entry	content_handler_test2_alternate []
static struct call_entry	content_handler_testerror []
static struct call_entry	content_handler_testerror_alternate []
static struct call_entry	content_handler_test_callback_rets []
static struct call_entry	content_handler_test_callback_rets_alt []
static struct attribute_entry	ch_attributes1 []
static struct attribute_entry	ch_attributes2 []
static struct call_entry	content_handler_test_attributes []
static struct attribute_entry	ch_attributes_alt_4 []
static struct call_entry	content_handler_test_attributes_alternate_4 []
static struct attribute_entry	ch_attributes_alt_no_ns []
static struct call_entry	content_handler_test_attributes_alt_no_ns []
static struct attribute_entry	ch_attributes_alt_6 []
static struct attribute_entry	ch_attributes2_6 []
static struct call_entry	content_handler_test_attributes_alternate_6 []
static struct attribute_entry	ch_attributes_no_prefix []
static struct call_entry	content_handler_test_attributes_alt_no_prefix []
static struct call_entry	content_handler_test_attributes_no_prefix []
static struct attribute_entry	xmlspace_attrs []
static struct call_entry	xmlspaceattr_test []
static struct call_entry	xmlspaceattr_test_alternate []
static const char	attribute_normalize []
static struct attribute_entry	attribute_norm_attrs []
static struct call_entry	attribute_norm []
static struct call_entry	attribute_norm_alt []
static struct call_entry	cdata_test []
static struct call_entry	cdata_test2 []
static struct call_entry	cdata_test3 []
static struct call_entry	cdata_test_alt []
static struct call_entry	cdata_test2_alt []
static struct call_entry	cdata_test3_alt []
static struct attribute_entry	read_test_attrs []
static struct call_entry	read_test_seq []
static const char	xmlspace_attr []
static struct call_entry *	expectCall
static ISAXLocator *	locator
static ISAXXMLReader *	g_reader
int	msxml_version
static ISAXAttributes *	test_attr_ptr
static const ISAXContentHandlerVtbl	contentHandlerVtbl
static ISAXContentHandler	contentHandler = { &contentHandlerVtbl }
static const ISAXErrorHandlerVtbl	errorHandlerVtbl
static ISAXErrorHandler	errorHandler = { &errorHandlerVtbl }
static const ISAXAttributesVtbl	SAXAttributesVtbl
static ISAXAttributes	saxattributes = { &SAXAttributesVtbl }
static const ISAXLexicalHandlerVtbl	SAXLexicalHandlerVtbl
static const ISAXDeclHandlerVtbl	SAXDeclHandlerVtbl
static const mxwriter_write_test *	current_write_test
static DWORD	current_stream_test_index
static const IStreamVtbl	mxstreamVtbl
static IStream	mxstream = { &mxstreamVtbl }
static int	read_cnt
static const IStreamVtbl	instreamVtbl
static IStream	instream = { &instreamVtbl }
static struct msxmlsupported_data_t	reader_support_data []
static struct saxlexicalhandler	lexicalhandler
static struct saxdeclhandler	declhandler
static const struct saxreader_props_test_t	props_test_data []
static const struct feature_ns_entry_t	feature_ns_entry_data []
static const char *	feature_names []
static const CHAR	UTF8BOMTest []
static const struct enc_test_entry_t	encoding_test_data []
static struct msxmlsupported_data_t	mxwriter_support_data []
static struct msxmlsupported_data_t	mxattributes_support_data []
static const struct mxwriter_props_t	mxwriter_default_props []
static const char	startelement_xml [] = "<uri:local a:attr1=\"a1\" attr2=\"a2\" attr3=\"&lt;&amp;&quot;&gt;\'\">"
static const char	startendelement_xml [] = "<uri:local a:attr1=\"a1\" attr2=\"a2\" attr3=\"&lt;&amp;&quot;&gt;\'\"/>"
static const char	startendelement_noescape_xml [] = "<uri:local a:attr1=\"a1\" attr2=\"a2\" attr3=\"<&\">\'\"/>"
static const struct writer_startendelement_t	writer_startendelement []
static const struct writer_startendelement2_t	writer_startendelement2 []
static const struct writer_characters_t	writer_characters []
static const mxwriter_stream_test	mxwriter_stream_tests []
static const char *	encoding_names []
static const addattribute_test_t	addattribute_data []
static struct msxmlsupported_data_t	saxattr_support_data []

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 23 of file saxreader.c.

CONST_VTABLE

#define CONST_VTABLE

Definition at line 24 of file saxreader.c.

CONTENT_HANDLER_INDEX

#define CONTENT_HANDLER_INDEX   0

Definition at line 242 of file saxreader.c.

EXPECT_HR

#define EXPECT_HR	(		hr,
			hr_exp
	)		ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)

Definition at line 41 of file saxreader.c.

EXPECT_REF

#define EXPECT_REF	(		obj,
			ref
	)		_expect_ref((IUnknown*)obj, ref, __LINE__)

Definition at line 44 of file saxreader.c.

NUM_CALL_SEQUENCES

#define NUM_CALL_SEQUENCES   1

Definition at line 243 of file saxreader.c.

ok_sequence

#define ok_sequence	(		seq,
			index,
			exp,
			contx,
			todo
	)		ok_sequence_(seq, index, (exp), (contx), (todo), __FILE__, __LINE__)

Definition at line 529 of file saxreader.c.

Typedef Documentation

CH

typedef enum _CH CH

mxwriter_stream_test

typedef struct mxwriter_stream_test_t mxwriter_stream_test

mxwriter_write_test

typedef struct mxwriter_write_test_t mxwriter_write_test

Enumeration Type Documentation

_CH

enum _CH

Enumerator
CH_ENDTEST
CH_PUTDOCUMENTLOCATOR
CH_STARTDOCUMENT
CH_ENDDOCUMENT
CH_STARTPREFIXMAPPING
CH_ENDPREFIXMAPPING
CH_STARTELEMENT
CH_ENDELEMENT
CH_CHARACTERS
CH_IGNORABLEWHITESPACE
CH_PROCESSINGINSTRUCTION
CH_SKIPPEDENTITY
LH_STARTCDATA
LH_ENDCDATA
EH_ERROR
EH_FATALERROR
EH_IGNORABLEWARNING
EVENT_LAST

Definition at line 162 of file saxreader.c.

                 {
    CH_ENDTEST,
    CH_PUTDOCUMENTLOCATOR,
    CH_STARTDOCUMENT,
    CH_ENDDOCUMENT,
    CH_STARTPREFIXMAPPING,
    CH_ENDPREFIXMAPPING,
    CH_STARTELEMENT,
    CH_ENDELEMENT,
    CH_CHARACTERS,
    CH_IGNORABLEWHITESPACE,
    CH_PROCESSINGINSTRUCTION,
    CH_SKIPPEDENTITY,
    LH_STARTCDATA,
    LH_ENDCDATA,
    EH_ERROR,
    EH_FATALERROR,
    EH_IGNORABLEWARNING,
    EVENT_LAST
} CH;

startendtype

enum startendtype

Enumerator
StartElement
EndElement
StartEndElement
DisableEscaping

Definition at line 3524 of file saxreader.c.

{
    StartElement    = 0x001,
    EndElement      = 0x010,
    StartEndElement = 0x011,
    DisableEscaping = 0x100
};

Function Documentation

_bstr_()

static BSTR _bstr_ ( const char *  str )

static

Definition at line 91 of file saxreader.c.

{
    assert(alloced_bstrs_count < ARRAY_SIZE(alloced_bstrs));
    alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
    return alloced_bstrs[alloced_bstrs_count++];
}

Referenced by contentHandler_startElement(), test_mxattr_addAttribute(), test_mxattr_clear(), test_mxattr_localname(), test_mxwriter_cdata(), test_mxwriter_characters(), test_mxwriter_comment(), test_mxwriter_default_properties(), test_mxwriter_dtd(), test_mxwriter_encoding(), test_mxwriter_flush(), test_mxwriter_ignorablespaces(), test_mxwriter_indent(), test_mxwriter_pi(), test_mxwriter_properties(), test_mxwriter_startenddocument(), test_mxwriter_startendelement(), test_mxwriter_startendelement_batch(), test_mxwriter_startendelement_batch2(), test_mxwriter_stream(), test_saxreader(), test_saxreader_encoding(), test_saxreader_features(), and test_saxreader_properties().

_expect_ref()

static void _expect_ref ( IUnknown *  obj, ULONG  ref, int  line  )

static

Definition at line 45 of file saxreader.c.

{
    ULONG rc;
    IUnknown_AddRef(obj);
    rc = IUnknown_Release(obj);
    ok_(__FILE__, line)(rc == ref, "expected refcount %d, got %d\n", ref, rc);
}

add_call()

static void add_call ( struct call_sequence **  seq, int  sequence_index, const struct call_entry *  call  )

static

Definition at line 253 of file saxreader.c.

{
    struct call_sequence *call_seq = seq[sequence_index];
 
    if (!call_seq->sequence)
    {
        call_seq->size = 10;
        call_seq->sequence = heap_alloc(call_seq->size * sizeof (struct call_entry));
    }
 
    if (call_seq->count == call_seq->size)
    {
        call_seq->size *= 2;
        call_seq->sequence = heap_realloc(call_seq->sequence, call_seq->size * sizeof (struct call_entry));
    }
 
    assert(call_seq->sequence);
 
    call_seq->sequence[call_seq->count].id     = call->id;
    call_seq->sequence[call_seq->count].line   = call->line;
    call_seq->sequence[call_seq->count].column = call->column;
    call_seq->sequence[call_seq->count].arg1W  = call->arg1W;
    call_seq->sequence[call_seq->count].arg2W  = call->arg2W;
    call_seq->sequence[call_seq->count].arg3W  = call->arg3W;
    call_seq->sequence[call_seq->count].ret    = call->ret;
    call_seq->sequence[call_seq->count].attr_count = call->attr_count;
    call_seq->sequence[call_seq->count].attributes = call->attributes;
 
    call_seq->count++;
}

Referenced by contentHandler_characters(), contentHandler_endDocument(), contentHandler_endElement(), contentHandler_endPrefixMapping(), contentHandler_ignorableWhitespace(), contentHandler_processingInstruction(), contentHandler_putDocumentLocator(), contentHandler_skippedEntity(), contentHandler_startDocument(), contentHandler_startElement(), contentHandler_startPrefixMapping(), isaxerrorHandler_fatalError(), isaxlexical_endCDATA(), isaxlexical_startCDATA(), and ok_sequence_().

alloc_str_from_narrow()

static BSTR alloc_str_from_narrow ( const char *  str )

static

Definition at line 80 of file saxreader.c.

{
    int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
    BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
    MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
    return ret;
}

Referenced by _bstr_().

compare_attributes()

static void compare_attributes ( const struct call_entry *  actual, const struct call_entry *  expected, const char *  context, BOOL  todo, const char *  file, int  line, int *  failcount  )

static

Definition at line 320 of file saxreader.c.

{
    int i, lenexp = 0;
 
    /* attribute count is not stored for expected data */
    if (expected->attributes)
    {
        struct attribute_entry *ptr = expected->attributes;
        while (ptr->uri) { lenexp++; ptr++; };
    }
 
    /* check count first and exit earlier */
    if (actual->attr_count != lenexp && todo)
    {
        (*failcount)++;
        todo_wine
            ok_(file, line) (FALSE, "%s: in event %s expecting attr count %d got %d\n",
                context, get_event_name(actual->id), lenexp, actual->attr_count);
    }
    else
        ok_(file, line) (actual->attr_count == lenexp, "%s: in event %s expecting attr count %d got %d\n",
            context, get_event_name(actual->id), lenexp, actual->attr_count);
 
    if (actual->attr_count != lenexp) return;
 
    /* now compare all attributes strings */
    for (i = 0; i < actual->attr_count; i++)
    {
        test_saxstr(file, line, actual->attributes[i].uriW,   expected->attributes[i].uri, todo, failcount);
        test_saxstr(file, line, actual->attributes[i].localW, expected->attributes[i].local, todo, failcount);
        test_saxstr(file, line, actual->attributes[i].qnameW, expected->attributes[i].qname, todo, failcount);
        test_saxstr(file, line, actual->attributes[i].valueW, expected->attributes[i].value, todo, failcount);
    }
}

Referenced by ok_sequence_().

contentHandler_AddRef()

static ULONG WINAPI contentHandler_AddRef ( ISAXContentHandler *  iface )

static

Definition at line 1073 of file saxreader.c.

{
    return 2;
}

contentHandler_characters()

static HRESULT WINAPI contentHandler_characters ( ISAXContentHandler *  iface, const WCHAR *  chars, int  len  )

static

Definition at line 1298 of file saxreader.c.

{
    struct call_entry call;
 
    ok(chars != NULL, "chars == NULL\n");
 
    init_call_entry(locator, &call);
    call.id = CH_CHARACTERS;
    call.arg1W = SysAllocStringLen(chars, len);
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

contentHandler_endDocument()

static HRESULT WINAPI contentHandler_endDocument ( ISAXContentHandler *  iface )

static

Definition at line 1146 of file saxreader.c.

{
    struct call_entry call;
 
    init_call_entry(locator, &call);
    call.id = CH_ENDDOCUMENT;
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

contentHandler_endElement()

static HRESULT WINAPI contentHandler_endElement ( ISAXContentHandler *  iface, const WCHAR *  uri, int  uri_len, const WCHAR *  localname, int  local_len, const WCHAR *  qname, int  qname_len  )

static

Definition at line 1276 of file saxreader.c.

{
    struct call_entry call;
 
    ok(uri != NULL, "uri == NULL\n");
    ok(localname != NULL, "localname == NULL\n");
    ok(qname != NULL, "qname == NULL\n");
 
    init_call_entry(locator, &call);
    call.id = CH_ENDELEMENT;
    call.arg1W = SysAllocStringLen(uri, uri_len);
    call.arg2W = SysAllocStringLen(localname, local_len);
    call.arg3W = SysAllocStringLen(qname, qname_len);
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

contentHandler_endPrefixMapping()

static HRESULT WINAPI contentHandler_endPrefixMapping ( ISAXContentHandler *  iface, const WCHAR *  prefix, int  len  )

static

Definition at line 1177 of file saxreader.c.

{
    struct call_entry call;
 
    ok(prefix != NULL, "prefix == NULL\n");
 
    init_call_entry(locator, &call);
    call.id = CH_ENDPREFIXMAPPING;
    call.arg1W = SysAllocStringLen(prefix, len);
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

contentHandler_ignorableWhitespace()

static HRESULT WINAPI contentHandler_ignorableWhitespace ( ISAXContentHandler *  iface, const WCHAR *  chars, int  len  )

static

Definition at line 1315 of file saxreader.c.

{
    struct call_entry call;
 
    ok(chars != NULL, "chars == NULL\n");
 
    init_call_entry(locator, &call);
    call.id = CH_IGNORABLEWHITESPACE;
    call.arg1W = SysAllocStringLen(chars, len);
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

contentHandler_processingInstruction()

static HRESULT WINAPI contentHandler_processingInstruction ( ISAXContentHandler *  iface, const WCHAR *  target, int  target_len, const WCHAR *  data, int  data_len  )

static

Definition at line 1331 of file saxreader.c.

{
    struct call_entry call;
 
    ok(target != NULL, "target == NULL\n");
    ok(data != NULL, "data == NULL\n");
 
    init_call_entry(locator, &call);
    call.id = CH_PROCESSINGINSTRUCTION;
    call.arg1W = SysAllocStringLen(target, target_len);
    call.arg2W = SysAllocStringLen(data, data_len);
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

contentHandler_putDocumentLocator()

static HRESULT WINAPI contentHandler_putDocumentLocator ( ISAXContentHandler *  iface, ISAXLocator *  pLocator  )

static

Definition at line 1085 of file saxreader.c.

{
    struct call_entry call;
    IUnknown *unk;
    HRESULT hr;
 
    locator = pLocator;
 
    init_call_entry(locator, &call);
    call.id = CH_PUTDOCUMENTLOCATOR;
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    hr = ISAXLocator_QueryInterface(pLocator, &IID_IVBSAXLocator, (void**)&unk);
    EXPECT_HR(hr, E_NOINTERFACE);
 
    if (msxml_version >= 6) {
        ISAXAttributes *attr, *attr1;
        IMXAttributes *mxattr;
 
        EXPECT_REF(pLocator, 1);
        hr = ISAXLocator_QueryInterface(pLocator, &IID_ISAXAttributes, (void**)&attr);
        EXPECT_HR(hr, S_OK);
        EXPECT_REF(pLocator, 2);
        hr = ISAXLocator_QueryInterface(pLocator, &IID_ISAXAttributes, (void**)&attr1);
        EXPECT_HR(hr, S_OK);
        EXPECT_REF(pLocator, 3);
        ok(attr == attr1, "got %p, %p\n", attr, attr1);
 
        hr = ISAXAttributes_QueryInterface(attr, &IID_IVBSAXAttributes, (void**)&unk);
        EXPECT_HR(hr, E_NOINTERFACE);
 
        hr = ISAXLocator_QueryInterface(pLocator, &IID_IVBSAXAttributes, (void**)&unk);
        EXPECT_HR(hr, E_NOINTERFACE);
 
        hr = ISAXAttributes_QueryInterface(attr, &IID_IMXAttributes, (void**)&mxattr);
        EXPECT_HR(hr, E_NOINTERFACE);
 
        ISAXAttributes_Release(attr);
        ISAXAttributes_Release(attr1);
    }
 
    return get_expected_ret();
}

contentHandler_QueryInterface()

static HRESULT WINAPI contentHandler_QueryInterface ( ISAXContentHandler *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1054 of file saxreader.c.

{
    *ppvObject = NULL;
 
    if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXContentHandler))
    {
        *ppvObject = iface;
    }
    else
    {
        return E_NOINTERFACE;
    }
 
    return S_OK;
}

contentHandler_Release()

static ULONG WINAPI contentHandler_Release ( ISAXContentHandler *  iface )

static

Definition at line 1079 of file saxreader.c.

{
    return 1;
}

contentHandler_skippedEntity()

static HRESULT WINAPI contentHandler_skippedEntity ( ISAXContentHandler *  iface, const WCHAR *  name, int  len  )

static

Definition at line 1350 of file saxreader.c.

{
    struct call_entry call;
 
    ok(name != NULL, "name == NULL\n");
 
    init_call_entry(locator, &call);
    call.id = CH_SKIPPEDENTITY;
    call.arg1W = SysAllocStringLen(name, len);
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

contentHandler_startDocument()

static HRESULT WINAPI contentHandler_startDocument ( ISAXContentHandler *  iface )

static

Definition at line 1132 of file saxreader.c.

{
    struct call_entry call;
 
    init_call_entry(locator, &call);
    call.id = CH_STARTDOCUMENT;
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    test_attr_ptr = NULL;
 
    return get_expected_ret();
}

contentHandler_startElement()

static HRESULT WINAPI contentHandler_startElement ( ISAXContentHandler *  iface, const WCHAR *  uri, int  uri_len, const WCHAR *  localname, int  local_len, const WCHAR *  qname, int  qname_len, ISAXAttributes *  saxattr  )

static

Definition at line 1193 of file saxreader.c.

{
    struct call_entry call;
    IMXAttributes *mxattr;
    HRESULT hr;
    int len;
 
    ok(uri != NULL, "uri == NULL\n");
    ok(localname != NULL, "localname == NULL\n");
    ok(qname != NULL, "qname == NULL\n");
 
    hr = ISAXAttributes_QueryInterface(saxattr, &IID_IMXAttributes, (void**)&mxattr);
    EXPECT_HR(hr, E_NOINTERFACE);
 
    init_call_entry(locator, &call);
    call.id = CH_STARTELEMENT;
    call.arg1W = SysAllocStringLen(uri, uri_len);
    call.arg2W = SysAllocStringLen(localname, local_len);
    call.arg3W = SysAllocStringLen(qname, qname_len);
 
    if(!test_attr_ptr)
        test_attr_ptr = saxattr;
    ok(test_attr_ptr == saxattr, "Multiple ISAXAttributes instances are used (%p %p)\n", test_attr_ptr, saxattr);
 
    /* store actual attributes */
    len = 0;
    hr = ISAXAttributes_getLength(saxattr, &len);
    EXPECT_HR(hr, S_OK);
 
    if (len)
    {
        VARIANT_BOOL v;
        int i;
 
        struct attribute_entry *attr;
        attr = heap_alloc_zero(len * sizeof(*attr));
 
        v = VARIANT_TRUE;
        hr = ISAXXMLReader_getFeature(g_reader, _bstr_("http://xml.org/sax/features/namespaces"), &v);
        EXPECT_HR(hr, S_OK);
 
        for (i = 0; i < len; i++)
        {
            const WCHAR *value;
            int value_len;
 
            hr = ISAXAttributes_getName(saxattr, i, &uri, &uri_len,
                &localname, &local_len, &qname, &qname_len);
            EXPECT_HR(hr, S_OK);
 
            hr = ISAXAttributes_getValue(saxattr, i, &value, &value_len);
            EXPECT_HR(hr, S_OK);
 
            /* if 'namespaces' switched off uri and local name contains garbage */
            if (v == VARIANT_FALSE && msxml_version > 0)
            {
                attr[i].uriW   = SysAllocStringLen(NULL, 0);
                attr[i].localW = SysAllocStringLen(NULL, 0);
            }
            else
            {
                attr[i].uriW   = SysAllocStringLen(uri, uri_len);
                attr[i].localW = SysAllocStringLen(localname, local_len);
            }
 
            attr[i].qnameW = SysAllocStringLen(qname, qname_len);
            attr[i].valueW = SysAllocStringLen(value, value_len);
        }
 
        call.attributes = attr;
        call.attr_count = len;
    }
 
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

contentHandler_startPrefixMapping()

static HRESULT WINAPI contentHandler_startPrefixMapping ( ISAXContentHandler *  iface, const WCHAR *  prefix, int  prefix_len, const WCHAR *  uri, int  uri_len  )

static

Definition at line 1158 of file saxreader.c.

{
    struct call_entry call;
 
    ok(prefix != NULL, "prefix == NULL\n");
    ok(uri != NULL, "uri == NULL\n");
 
    init_call_entry(locator, &call);
    call.id = CH_STARTPREFIXMAPPING;
    call.arg1W = SysAllocStringLen(prefix, prefix_len);
    call.arg2W = SysAllocStringLen(uri, uri_len);
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

create_test_stream()

static IStream * create_test_stream ( const char *  data, int  len  )

static

Definition at line 2120 of file saxreader.c.

{
     ULARGE_INTEGER size;
     LARGE_INTEGER pos;
     IStream *stream;
     ULONG written;
 
     if (len == -1) len = strlen(data);
     CreateStreamOnHGlobal(NULL, TRUE, &stream);
     size.QuadPart = len;
     IStream_SetSize(stream, size);
     IStream_Write(stream, data, len, &written);
     pos.QuadPart = 0;
     IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
 
     return stream;
}

flush_sequence()

static void flush_sequence ( struct call_sequence **  seg, int  sequence_index  )

inlinestatic

Definition at line 285 of file saxreader.c.

{
    int i;
 
    struct call_sequence *call_seq = seg[sequence_index];
 
    for (i = 0; i < call_seq->count; i++)
    {
        int j;
 
        for (j = 0; j < call_seq->sequence[i].attr_count; j++)
        {
            SysFreeString(call_seq->sequence[i].attributes[j].uriW);
            SysFreeString(call_seq->sequence[i].attributes[j].localW);
            SysFreeString(call_seq->sequence[i].attributes[j].qnameW);
            SysFreeString(call_seq->sequence[i].attributes[j].valueW);
        }
        heap_free(call_seq->sequence[i].attributes);
        call_seq->sequence[i].attr_count = 0;
 
        SysFreeString(call_seq->sequence[i].arg1W);
        SysFreeString(call_seq->sequence[i].arg2W);
        SysFreeString(call_seq->sequence[i].arg3W);
    }
 
    heap_free(call_seq->sequence);
    call_seq->sequence = NULL;
    call_seq->count = call_seq->size = 0;
}

free_bstrs()

static void free_bstrs ( void  )

static

Definition at line 98 of file saxreader.c.

{
    int i;
    for (i = 0; i < alloced_bstrs_count; i++)
        SysFreeString(alloced_bstrs[i]);
    alloced_bstrs_count = 0;
}

Referenced by test_mxattr_addAttribute(), test_mxattr_clear(), test_mxattr_localname(), test_mxwriter_cdata(), test_mxwriter_characters(), test_mxwriter_comment(), test_mxwriter_dtd(), test_mxwriter_encoding(), test_mxwriter_flush(), test_mxwriter_indent(), test_mxwriter_properties(), test_mxwriter_startenddocument(), test_mxwriter_startendelement(), test_mxwriter_startendelement_batch(), test_mxwriter_startendelement_batch2(), test_mxwriter_stream(), test_saxreader(), test_saxreader_encoding(), and test_saxreader_properties().

get_class_support_data()

static void get_class_support_data ( struct msxmlsupported_data_t *  table, REFIID  riid  )

static

Definition at line 3654 of file saxreader.c.

{
    while (table->clsid)
    {
        IUnknown *unk;
        HRESULT hr;
 
        hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, riid, (void**)&unk);
        if (hr == S_OK) IUnknown_Release(unk);
 
        table->supported = hr == S_OK;
        if (hr != S_OK) win_skip("class %s not supported\n", table->name);
 
        table++;
    }
}

Referenced by START_TEST().

get_event_name()

static const char * get_event_name ( CH  event )

static

Definition at line 315 of file saxreader.c.

{
    return event_names[event];
}

Referenced by compare_attributes(), and ok_sequence_().

get_expected_ret()

static HRESULT get_expected_ret ( void  )

static

Definition at line 1047 of file saxreader.c.

{
    HRESULT hr = expectCall->ret;
    if (expectCall->id != CH_ENDTEST) expectCall++;
    return hr;
}

Referenced by contentHandler_characters(), contentHandler_endDocument(), contentHandler_endElement(), contentHandler_endPrefixMapping(), contentHandler_ignorableWhitespace(), contentHandler_processingInstruction(), contentHandler_putDocumentLocator(), contentHandler_skippedEntity(), contentHandler_startDocument(), contentHandler_startElement(), contentHandler_startPrefixMapping(), isaxerrorHandler_fatalError(), isaxlexical_endCDATA(), and isaxlexical_startCDATA().

get_refcount()

static LONG get_refcount ( void *  iface )

static

Definition at line 53 of file saxreader.c.

{
    IUnknown *unk = iface;
    LONG ref;
 
    ref = IUnknown_AddRef(unk);
    IUnknown_Release(unk);
    return ref-1;
}

Referenced by test_mxwriter_flush(), and test_saxreader_properties().

impl_from_ISAXDeclHandler()

static struct saxdeclhandler * impl_from_ISAXDeclHandler ( ISAXDeclHandler *  iface )

inlinestatic

Definition at line 1819 of file saxreader.c.

{
    return CONTAINING_RECORD(iface, struct saxdeclhandler, ISAXDeclHandler_iface);
}

Referenced by isaxdecl_AddRef(), isaxdecl_QueryInterface(), and isaxdecl_Release().

impl_from_ISAXLexicalHandler()

static struct saxlexicalhandler * impl_from_ISAXLexicalHandler ( ISAXLexicalHandler *  iface )

inlinestatic

Definition at line 1691 of file saxreader.c.

{
    return CONTAINING_RECORD(iface, struct saxlexicalhandler, ISAXLexicalHandler_iface);
}

Referenced by isaxlexical_AddRef(), isaxlexical_QueryInterface(), and isaxlexical_Release().

init_call_entry()

static void init_call_entry ( ISAXLocator *  locator, struct call_entry *  call  )

static

Definition at line 246 of file saxreader.c.

{
    memset(call, 0, sizeof(*call));
    ISAXLocator_getLineNumber(locator, &call->line);
    ISAXLocator_getColumnNumber(locator, &call->column);
}

Referenced by contentHandler_characters(), contentHandler_endDocument(), contentHandler_endElement(), contentHandler_endPrefixMapping(), contentHandler_ignorableWhitespace(), contentHandler_processingInstruction(), contentHandler_putDocumentLocator(), contentHandler_skippedEntity(), contentHandler_startDocument(), contentHandler_startElement(), contentHandler_startPrefixMapping(), isaxerrorHandler_fatalError(), isaxlexical_endCDATA(), and isaxlexical_startCDATA().

init_call_sequences()

static void init_call_sequences ( struct call_sequence **  seq, int  n  )

static

Definition at line 532 of file saxreader.c.

{
    int i;
 
    for (i = 0; i < n; i++)
        seq[i] = heap_alloc_zero(sizeof(struct call_sequence));
}

Referenced by START_TEST().

init_saxdeclhandler()

static void init_saxdeclhandler ( struct saxdeclhandler *  handler, HRESULT  hr  )

static

Definition at line 1903 of file saxreader.c.

{
    handler->ISAXDeclHandler_iface.lpVtbl = &SAXDeclHandlerVtbl;
    handler->ref = 1;
    handler->qi_hr = hr;
}

Referenced by test_saxreader_properties().

init_saxlexicalhandler()

static void init_saxlexicalhandler ( struct saxlexicalhandler *  handler, HRESULT  hr  )

static

Definition at line 1804 of file saxreader.c.

{
    handler->ISAXLexicalHandler_iface.lpVtbl = &SAXLexicalHandlerVtbl;
    handler->ref = 1;
    handler->qi_hr = hr;
}

Referenced by test_saxreader(), and test_saxreader_properties().

instream_Read()

static HRESULT WINAPI instream_Read ( IStream *  iface, void *  pv, ULONG  cb, ULONG *  pcbRead  )

static

Definition at line 2070 of file saxreader.c.

{
    static const char *ret_str;
 
    if(!read_cnt)
        ret_str = "<?xml version=\"1.0\" ?>\n<rootelem>";
    else if(read_cnt < 5)
        ret_str = "<elem attr=\"val\">text</elem>";
    else if(read_cnt == 5)
        ret_str = "</rootelem>\n";
    else
        ret_str = "";
 
    read_cnt++;
    strcpy(pv, ret_str);
    *pcbRead = strlen(ret_str);
    return S_OK;
}

is_clsid_supported()

static BOOL is_clsid_supported ( const GUID *  clsid, const struct msxmlsupported_data_t *  table  )

static

Definition at line 70 of file saxreader.c.

{
    while (table->clsid)
    {
        if (table->clsid == clsid) return table->supported;
        table++;
    }
    return FALSE;
}

Referenced by START_TEST(), test_mxattr_addAttribute(), test_mxattr_localname(), test_mxwriter_characters(), test_mxwriter_default_properties(), test_mxwriter_dispex(), test_mxwriter_startendelement_batch(), test_mxwriter_startendelement_batch2(), test_saxreader(), test_saxreader_dispex(), and test_saxreader_properties().

isaxattributes_AddRef()

static ULONG WINAPI isaxattributes_AddRef ( ISAXAttributes *  iface )

static

Definition at line 1486 of file saxreader.c.

{
    return 2;
}

isaxattributes_getIndexFromName()

static HRESULT WINAPI isaxattributes_getIndexFromName ( ISAXAttributes *  iface, const WCHAR *  pUri, int  cUriLength, const WCHAR *  pLocalName, int  cocalNameLength, int *  index  )

static

Definition at line 1560 of file saxreader.c.

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

isaxattributes_getIndexFromQName()

static HRESULT WINAPI isaxattributes_getIndexFromQName ( ISAXAttributes *  iface, const WCHAR *  pQName, int  nQNameLength, int *  index  )

static

Definition at line 1572 of file saxreader.c.

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

isaxattributes_getLength()

static HRESULT WINAPI isaxattributes_getLength ( ISAXAttributes *  iface, int *  length  )

static

Definition at line 1496 of file saxreader.c.

{
    *length = 3;
    return S_OK;
}

isaxattributes_getLocalName()

static HRESULT WINAPI isaxattributes_getLocalName ( ISAXAttributes *  iface, int  nIndex, const WCHAR **  pLocalName, int *  pLocalNameLength  )

static

Definition at line 1512 of file saxreader.c.

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

isaxattributes_getName()

static HRESULT WINAPI isaxattributes_getName ( ISAXAttributes *  iface, int  nIndex, const WCHAR **  pUri, int *  pUriLength, const WCHAR **  pLocalName, int *  pLocalNameSize, const WCHAR **  pQName, int *  pQNameLength  )

static

Definition at line 1546 of file saxreader.c.

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

isaxattributes_getQName()

static HRESULT WINAPI isaxattributes_getQName ( ISAXAttributes *  iface, int  index, const WCHAR **  QName, int *  QNameLength  )

static

Definition at line 1522 of file saxreader.c.

{
    static const WCHAR attrqnamesW[][15] = {{'a',':','a','t','t','r','1','j','u','n','k',0},
                                            {'a','t','t','r','2','j','u','n','k',0},
                                            {'a','t','t','r','3',0}};
    static const int attrqnamelen[] = {7, 5, 5};
 
    ok(index >= 0 && index <= 2, "invalid index received %d\n", index);
 
    if (index >= 0 && index <= 2) {
        *QName = attrqnamesW[index];
        *QNameLength = attrqnamelen[index];
    } else {
        *QName = NULL;
        *QNameLength = 0;
    }
 
    return S_OK;
}

isaxattributes_getType()

static HRESULT WINAPI isaxattributes_getType ( ISAXAttributes *  iface, int  nIndex, const WCHAR **  pType, int *  pTypeLength  )

static

Definition at line 1582 of file saxreader.c.

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

isaxattributes_getTypeFromName()

static HRESULT WINAPI isaxattributes_getTypeFromName ( ISAXAttributes *  iface, const WCHAR *  pUri, int  nUri, const WCHAR *  pLocalName, int  nLocalName, const WCHAR **  pType, int *  nType  )

static

Definition at line 1592 of file saxreader.c.

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

isaxattributes_getTypeFromQName()

static HRESULT WINAPI isaxattributes_getTypeFromQName ( ISAXAttributes *  iface, const WCHAR *  pQName, int  nQName, const WCHAR **  pType, int *  nType  )

static

Definition at line 1605 of file saxreader.c.

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

isaxattributes_getURI()

static HRESULT WINAPI isaxattributes_getURI ( ISAXAttributes *  iface, int  nIndex, const WCHAR **  pUrl, int *  pUriSize  )

static

Definition at line 1502 of file saxreader.c.

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

isaxattributes_getValue()

static HRESULT WINAPI isaxattributes_getValue ( ISAXAttributes *  iface, int  index, const WCHAR **  value, int *  nValue  )

static

Definition at line 1616 of file saxreader.c.

{
    static const WCHAR attrvaluesW[][10] = {{'a','1','j','u','n','k',0},
                                            {'a','2','j','u','n','k',0},
                                            {'<','&','"','>','\'',0}};
    static const int attrvalueslen[] = {2, 2, 5};
 
    ok(index >= 0 && index <= 2, "invalid index received %d\n", index);
 
    if (index >= 0 && index <= 2) {
        *value = attrvaluesW[index];
        *nValue = attrvalueslen[index];
    } else {
        *value = NULL;
        *nValue = 0;
    }
 
    return S_OK;
}

isaxattributes_getValueFromName()

static HRESULT WINAPI isaxattributes_getValueFromName ( ISAXAttributes *  iface, const WCHAR *  pUri, int  nUri, const WCHAR *  pLocalName, int  nLocalName, const WCHAR **  pValue, int *  nValue  )

static

Definition at line 1637 of file saxreader.c.

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

isaxattributes_getValueFromQName()

static HRESULT WINAPI isaxattributes_getValueFromQName ( ISAXAttributes *  iface, const WCHAR *  pQName, int  nQName, const WCHAR **  pValue, int *  nValue  )

static

Definition at line 1650 of file saxreader.c.

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

isaxattributes_QueryInterface()

static HRESULT WINAPI isaxattributes_QueryInterface ( ISAXAttributes *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1467 of file saxreader.c.

{
    *ppvObject = NULL;
 
    if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXAttributes))
    {
        *ppvObject = iface;
    }
    else
    {
        return E_NOINTERFACE;
    }
 
    return S_OK;
}

isaxattributes_Release()

static ULONG WINAPI isaxattributes_Release ( ISAXAttributes *  iface )

static

Definition at line 1491 of file saxreader.c.

{
    return 1;
}

isaxdecl_AddRef()

static ULONG WINAPI isaxdecl_AddRef ( ISAXDeclHandler *  iface )

static

Definition at line 1849 of file saxreader.c.

{
    struct saxdeclhandler *handler = impl_from_ISAXDeclHandler(iface);
    return InterlockedIncrement(&handler->ref);
}

isaxdecl_attributeDecl()

static HRESULT WINAPI isaxdecl_attributeDecl ( ISAXDeclHandler *  iface, const WCHAR *  pElementName, int  nElementName, const WCHAR *  pAttributeName, int  nAttributeName, const WCHAR *  pType, int  nType, const WCHAR *  pValueDefault, int  nValueDefault, const WCHAR *  pValue, int  nValue  )

static

Definition at line 1868 of file saxreader.c.

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

isaxdecl_elementDecl()

static HRESULT WINAPI isaxdecl_elementDecl ( ISAXDeclHandler *  iface, const WCHAR *  pName, int  nName, const WCHAR *  pModel, int  nModel  )

static

Definition at line 1861 of file saxreader.c.

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

isaxdecl_externalEntityDecl()

static HRESULT WINAPI isaxdecl_externalEntityDecl ( ISAXDeclHandler *  iface, const WCHAR *  pName, int  nName, const WCHAR *  pPublicId, int  nPublicId, const WCHAR *  pSystemId, int  nSystemId  )

static

Definition at line 1884 of file saxreader.c.

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

isaxdecl_internalEntityDecl()

static HRESULT WINAPI isaxdecl_internalEntityDecl ( ISAXDeclHandler *  iface, const WCHAR *  pName, int  nName, const WCHAR *  pValue, int  nValue  )

static

Definition at line 1877 of file saxreader.c.

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

isaxdecl_QueryInterface()

static HRESULT WINAPI isaxdecl_QueryInterface ( ISAXDeclHandler *  iface, REFIID  riid, void **  out  )

static

Definition at line 1824 of file saxreader.c.

{
    struct saxdeclhandler *handler = impl_from_ISAXDeclHandler(iface);
 
    *out = NULL;
 
    if (IsEqualGUID(riid, &IID_IUnknown))
    {
        *out = iface;
        ok(0, "got unexpected IID_IUnknown query\n");
    }
    else if (IsEqualGUID(riid, &IID_ISAXDeclHandler))
    {
        if (handler->qi_hr == E_NOINTERFACE) return handler->qi_hr;
        *out = iface;
    }
 
    if (*out)
        ISAXDeclHandler_AddRef(iface);
    else
        return E_NOINTERFACE;
 
    return S_OK;
}

isaxdecl_Release()

static ULONG WINAPI isaxdecl_Release ( ISAXDeclHandler *  iface )

static

Definition at line 1855 of file saxreader.c.

{
    struct saxdeclhandler *handler = impl_from_ISAXDeclHandler(iface);
    return InterlockedDecrement(&handler->ref);
}

isaxerrorHandler_AddRef()

static ULONG WINAPI isaxerrorHandler_AddRef ( ISAXErrorHandler *  iface )

static

Definition at line 1405 of file saxreader.c.

{
    return 2;
}

isaxerrorHandler_error()

static HRESULT WINAPI isaxerrorHandler_error ( ISAXErrorHandler *  iface, ISAXLocator *  pLocator, const WCHAR *  pErrorMessage, HRESULT  hrErrorCode  )

static

Definition at line 1417 of file saxreader.c.

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

isaxerrorHandler_fatalError()

static HRESULT WINAPI isaxerrorHandler_fatalError ( ISAXErrorHandler *  iface, ISAXLocator *  pLocator, const WCHAR *  message, HRESULT  hr  )

static

Definition at line 1427 of file saxreader.c.

{
    struct call_entry call;
 
    init_call_entry(locator, &call);
    call.id  = EH_FATALERROR;
    call.ret = hr;
 
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    get_expected_ret();
    return S_OK;
}

isaxerrorHandler_ignorableWarning()

static HRESULT WINAPI isaxerrorHandler_ignorableWarning ( ISAXErrorHandler *  iface, ISAXLocator *  pLocator, const WCHAR *  pErrorMessage, HRESULT  hrErrorCode  )

static

Definition at line 1445 of file saxreader.c.

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

isaxerrorHandler_QueryInterface()

static HRESULT WINAPI isaxerrorHandler_QueryInterface ( ISAXErrorHandler *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1386 of file saxreader.c.

{
    *ppvObject = NULL;
 
    if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXErrorHandler))
    {
        *ppvObject = iface;
    }
    else
    {
        return E_NOINTERFACE;
    }
 
    return S_OK;
}

isaxerrorHandler_Release()

static ULONG WINAPI isaxerrorHandler_Release ( ISAXErrorHandler *  iface )

static

Definition at line 1411 of file saxreader.c.

{
    return 1;
}

isaxlexical_AddRef()

static ULONG WINAPI isaxlexical_AddRef ( ISAXLexicalHandler *  iface )

static

Definition at line 1721 of file saxreader.c.

{
    struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface);
    return InterlockedIncrement(&handler->ref);
}

isaxlexical_comment()

static HRESULT WINAPI isaxlexical_comment ( ISAXLexicalHandler *  iface, const WCHAR *  pChars, int  nChars  )

static

Definition at line 1783 of file saxreader.c.

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

isaxlexical_endCDATA()

static HRESULT WINAPI isaxlexical_endCDATA ( ISAXLexicalHandler *  iface )

static

Definition at line 1772 of file saxreader.c.

{
    struct call_entry call;
 
    init_call_entry(locator, &call);
    call.id = LH_ENDCDATA;
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

isaxlexical_endDTD()

static HRESULT WINAPI isaxlexical_endDTD ( ISAXLexicalHandler *  iface )

static

Definition at line 1741 of file saxreader.c.

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

isaxlexical_endEntity()

static HRESULT WINAPI isaxlexical_endEntity ( ISAXLexicalHandler *  iface, const WCHAR *  pName, int  nName  )

static

Definition at line 1754 of file saxreader.c.

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

isaxlexical_QueryInterface()

static HRESULT WINAPI isaxlexical_QueryInterface ( ISAXLexicalHandler *  iface, REFIID  riid, void **  out  )

static

Definition at line 1696 of file saxreader.c.

{
    struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface);
 
    *out = NULL;
 
    if (IsEqualGUID(riid, &IID_IUnknown))
    {
        *out = iface;
        ok(0, "got unexpected IID_IUnknown query\n");
    }
    else if (IsEqualGUID(riid, &IID_ISAXLexicalHandler))
    {
        if (handler->qi_hr == E_NOINTERFACE) return handler->qi_hr;
        *out = iface;
    }
 
    if (*out)
        ISAXLexicalHandler_AddRef(iface);
    else
        return E_NOINTERFACE;
 
    return S_OK;
}

isaxlexical_Release()

static ULONG WINAPI isaxlexical_Release ( ISAXLexicalHandler *  iface )

static

Definition at line 1727 of file saxreader.c.

{
    struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface);
    return InterlockedDecrement(&handler->ref);
}

isaxlexical_startCDATA()

static HRESULT WINAPI isaxlexical_startCDATA ( ISAXLexicalHandler *  iface )

static

Definition at line 1761 of file saxreader.c.

{
    struct call_entry call;
 
    init_call_entry(locator, &call);
    call.id = LH_STARTCDATA;
    add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 
    return get_expected_ret();
}

isaxlexical_startDTD()

static HRESULT WINAPI isaxlexical_startDTD ( ISAXLexicalHandler *  iface, const WCHAR *  pName, int  nName, const WCHAR *  pPublicId, int  nPublicId, const WCHAR *  pSystemId, int  nSystemId  )

static

Definition at line 1733 of file saxreader.c.

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

isaxlexical_startEntity()

static HRESULT WINAPI isaxlexical_startEntity ( ISAXLexicalHandler *  iface, const WCHAR *  pName, int  nName  )

static

Definition at line 1747 of file saxreader.c.

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

istream_AddRef()

static ULONG WINAPI istream_AddRef ( IStream *  iface )

static

Definition at line 1941 of file saxreader.c.

{
    return 2;
}

istream_Clone()

static HRESULT WINAPI istream_Clone ( IStream *  iface, IStream **  ppstm  )

static

Definition at line 2014 of file saxreader.c.

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

istream_Commit()

static HRESULT WINAPI istream_Commit ( IStream *  iface, DWORD  grfCommitFlags  )

static

Definition at line 1983 of file saxreader.c.

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

istream_CopyTo()

static HRESULT WINAPI istream_CopyTo ( IStream *  iface, IStream *  pstm, ULARGE_INTEGER  cb, ULARGE_INTEGER *  pcbRead, ULARGE_INTEGER *  plibWritten  )

static

Definition at line 1976 of file saxreader.c.

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

istream_LockRegion()

static HRESULT WINAPI istream_LockRegion ( IStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 1995 of file saxreader.c.

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

istream_QueryInterface()

static HRESULT WINAPI istream_QueryInterface ( IStream *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1927 of file saxreader.c.

{
    *ppvObject = NULL;
 
    ok(!IsEqualGUID(riid, &IID_IPersistStream), "Did not expect QI for IPersistStream\n");
 
    if(IsEqualGUID(riid, &IID_IStream) || IsEqualGUID(riid, &IID_IUnknown))
        *ppvObject = iface;
    else
        return E_NOINTERFACE;
 
    return S_OK;
}

istream_Read()

static HRESULT WINAPI istream_Read ( IStream *  iface, void *  pv, ULONG  cb, ULONG *  pcbRead  )

static

Definition at line 1951 of file saxreader.c.

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

istream_Release()

static ULONG WINAPI istream_Release ( IStream *  iface )

static

Definition at line 1946 of file saxreader.c.

{
    return 1;
}

istream_Revert()

static HRESULT WINAPI istream_Revert ( IStream *  iface )

static

Definition at line 1989 of file saxreader.c.

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

istream_Seek()

static HRESULT WINAPI istream_Seek ( IStream *  iface, LARGE_INTEGER  dlibMove, DWORD  dwOrigin, ULARGE_INTEGER *  plibNewPosition  )

static

Definition at line 1963 of file saxreader.c.

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

istream_SetSize()

static HRESULT WINAPI istream_SetSize ( IStream *  iface, ULARGE_INTEGER  libNewSize  )

static

Definition at line 1970 of file saxreader.c.

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

istream_Stat()

static HRESULT WINAPI istream_Stat ( IStream *  iface, STATSTG *  pstatstg, DWORD  grfStatFlag  )

static

Definition at line 2009 of file saxreader.c.

{
    return E_NOTIMPL;
}

istream_UnlockRegion()

static HRESULT WINAPI istream_UnlockRegion ( IStream *  iface, ULARGE_INTEGER  libOffset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 2002 of file saxreader.c.

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

istream_Write()

static HRESULT WINAPI istream_Write ( IStream *  iface, const void *  pv, ULONG  cb, ULONG *  pcbWritten  )

static

Definition at line 1957 of file saxreader.c.

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

mxstream_Write()

static HRESULT WINAPI mxstream_Write ( IStream *  iface, const void *  pv, ULONG  cb, ULONG *  pcbWritten  )

static

Definition at line 2020 of file saxreader.c.

{
    BOOL fail = FALSE;
 
    ok(pv != NULL, "pv == NULL\n");
 
    if(current_write_test->last) {
        ok(0, "Too many Write calls made on test %d\n", current_stream_test_index);
        return E_FAIL;
    }
 
    fail = current_write_test->fail_write;
 
    ok(current_write_test->cb == cb, "Expected %d, but got %d on test %d\n",
        current_write_test->cb, cb, current_stream_test_index);
 
    if(!pcbWritten)
        ok(current_write_test->null_written, "pcbWritten was NULL on test %d\n", current_stream_test_index);
    else
        ok(!memcmp(current_write_test->data, pv, cb), "Unexpected data on test %d\n", current_stream_test_index);
 
    ++current_write_test;
 
    if(pcbWritten)
        *pcbWritten = cb;
 
    return fail ? E_FAIL : S_OK;
}

ok_sequence_()

static void ok_sequence_ ( struct call_sequence **  seq, int  sequence_index, const struct call_entry *  expected, const char *  context, BOOL  todo, const char *  file, int  line  )

static

Definition at line 356 of file saxreader.c.

{
    struct call_sequence *call_seq = seq[sequence_index];
    static const struct call_entry end_of_sequence = { CH_ENDTEST };
    const struct call_entry *actual, *sequence;
    int failcount = 0;
 
    add_call(seq, sequence_index, &end_of_sequence);
 
    sequence = call_seq->sequence;
    actual = sequence;
 
    while (expected->id != CH_ENDTEST && actual->id != CH_ENDTEST)
    {
        if (expected->id == actual->id)
        {
            if (expected->line != -1)
            {
                /* always test position data */
                if (expected->line != actual->line && todo)
                {
                    todo_wine
                    {
                        failcount++;
                        ok_(file, line) (FALSE,
                            "%s: in event %s expecting line %d got %d\n",
                            context, get_event_name(actual->id), expected->line, actual->line);
                    }
                }
                else
                {
                    ok_(file, line) (expected->line == actual->line,
                        "%s: in event %s expecting line %d got %d\n",
                        context, get_event_name(actual->id), expected->line, actual->line);
                }
            }
 
 
            if (expected->column != -1)
            {
                if (expected->column != actual->column && todo)
                {
                    todo_wine
                    {
                        failcount++;
                        ok_(file, line) (FALSE,
                            "%s: in event %s expecting column %d got %d\n",
                            context, get_event_name(actual->id), expected->column, actual->column);
                    }
                }
                else
                {
                    ok_(file, line) (expected->column == actual->column,
                        "%s: in event %s expecting column %d got %d\n",
                        context, get_event_name(actual->id), expected->column, actual->column);
                }
            }
 
            switch (actual->id)
            {
            case CH_PUTDOCUMENTLOCATOR:
            case CH_STARTDOCUMENT:
            case CH_ENDDOCUMENT:
            case LH_STARTCDATA:
            case LH_ENDCDATA:
                break;
            case CH_STARTPREFIXMAPPING:
                /* prefix, uri */
                test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
                test_saxstr(file, line, actual->arg2W, expected->arg2, todo, &failcount);
                break;
            case CH_ENDPREFIXMAPPING:
                /* prefix */
                test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
                break;
            case CH_STARTELEMENT:
                /* compare attributes */
                compare_attributes(actual, expected, context, todo, file, line, &failcount);
                /* fallthrough */
            case CH_ENDELEMENT:
                /* uri, localname, qname */
                test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
                test_saxstr(file, line, actual->arg2W, expected->arg2, todo, &failcount);
                test_saxstr(file, line, actual->arg3W, expected->arg3, todo, &failcount);
                break;
            case CH_CHARACTERS:
            case CH_IGNORABLEWHITESPACE:
                /* char data */
                test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
                break;
            case CH_PROCESSINGINSTRUCTION:
                /* target, data */
                test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
                test_saxstr(file, line, actual->arg2W, expected->arg2, todo, &failcount);
                break;
            case CH_SKIPPEDENTITY:
                /* name */
                test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
                break;
            case EH_FATALERROR:
                /* test return value only */
                if (expected->ret != actual->ret && todo)
                {
                     failcount++;
                     ok_(file, line) (FALSE,
                         "%s: in event %s expecting ret 0x%08x got 0x%08x\n",
                         context, get_event_name(actual->id), expected->ret, actual->ret);
                }
                else
                     ok_(file, line) (expected->ret == actual->ret,
                         "%s: in event %s expecting ret 0x%08x got 0x%08x\n",
                         context, get_event_name(actual->id), expected->ret, actual->ret);
                break;
            case EH_ERROR:
            case EH_IGNORABLEWARNING:
            default:
                ok(0, "%s: callback not handled, %s\n", context, get_event_name(actual->id));
            }
            expected++;
            actual++;
        }
        else if (todo)
        {
            failcount++;
            todo_wine
            {
                ok_(file, line) (FALSE, "%s: call %s was expected, but got call %s instead\n",
                    context, get_event_name(expected->id), get_event_name(actual->id));
            }
 
            flush_sequence(seq, sequence_index);
            return;
        }
        else
        {
            ok_(file, line) (FALSE, "%s: call %s was expected, but got call %s instead\n",
                context, get_event_name(expected->id), get_event_name(actual->id));
            expected++;
            actual++;
        }
    }
 
    if (todo)
    {
        todo_wine
        {
            if (expected->id != CH_ENDTEST || actual->id != CH_ENDTEST)
            {
                failcount++;
                ok_(file, line) (FALSE, "%s: the call sequence is not complete: expected %s - actual %s\n",
                    context, get_event_name(expected->id), get_event_name(actual->id));
            }
        }
    }
    else if (expected->id != CH_ENDTEST || actual->id != CH_ENDTEST)
    {
        ok_(file, line) (FALSE, "%s: the call sequence is not complete: expected %s - actual %s\n",
            context, get_event_name(expected->id), get_event_name(actual->id));
    }
 
    if (todo && !failcount) /* succeeded yet marked todo */
    {
        todo_wine
        {
            ok_(file, line)(TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
        }
    }
 
    flush_sequence(seq, sequence_index);
}

set_expected_seq()

static void set_expected_seq ( struct call_entry *  expected )

static

Definition at line 1041 of file saxreader.c.

{
    expectCall = expected;
}

Referenced by test_saxreader().

START_TEST()

START_TEST

(

saxreader

)

Definition at line 5754 of file saxreader.c.

{
    ISAXXMLReader *reader;
    HRESULT hr;
 
    hr = CoInitialize(NULL);
    ok(hr == S_OK, "failed to init com\n");
 
    hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
            &IID_ISAXXMLReader, (void**)&reader);
 
    if(FAILED(hr))
    {
        win_skip("Failed to create SAXXMLReader instance\n");
        CoUninitialize();
        return;
    }
    ISAXXMLReader_Release(reader);
 
    init_call_sequences(sequences, NUM_CALL_SEQUENCES);
 
    get_class_support_data(reader_support_data, &IID_ISAXXMLReader);
 
    test_saxreader();
    test_saxreader_properties();
    test_saxreader_features();
    test_saxreader_encoding();
    test_saxreader_dispex();
 
    /* MXXMLWriter tests */
    get_class_support_data(mxwriter_support_data, &IID_IMXWriter);
    if (is_clsid_supported(&CLSID_MXXMLWriter, mxwriter_support_data))
    {
        test_mxwriter_handlers();
        test_mxwriter_startenddocument();
        test_mxwriter_startendelement();
        test_mxwriter_characters();
        test_mxwriter_comment();
        test_mxwriter_cdata();
        test_mxwriter_pi();
        test_mxwriter_ignorablespaces();
        test_mxwriter_dtd();
        test_mxwriter_properties();
        test_mxwriter_flush();
        test_mxwriter_stream();
        test_mxwriter_encoding();
        test_mxwriter_dispex();
        test_mxwriter_indent();
    }
    else
        win_skip("MXXMLWriter not supported\n");
 
    /* SAXAttributes tests */
    get_class_support_data(mxattributes_support_data, &IID_IMXAttributes);
    if (is_clsid_supported(&CLSID_SAXAttributes, mxattributes_support_data))
    {
        test_mxattr_qi();
        test_mxattr_addAttribute();
        test_mxattr_clear();
        test_mxattr_localname();
        test_mxattr_dispex();
    }
    else
        win_skip("SAXAttributes not supported\n");
 
    CoUninitialize();
}

test_mxattr_addAttribute()

static void test_mxattr_addAttribute ( void  )

static

Definition at line 5231 of file saxreader.c.

{
    const addattribute_test_t *table = addattribute_data;
    int i = 0;
 
    while (table->clsid)
    {
        ISAXAttributes *saxattr;
        IMXAttributes *mxattr;
        const WCHAR *value;
        int len, index;
        HRESULT hr;
 
        if (!is_clsid_supported(table->clsid, mxattributes_support_data))
        {
            table++;
            i++;
            continue;
        }
 
        hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXAttributes, (void**)&mxattr);
        EXPECT_HR(hr, S_OK);
 
        hr = IMXAttributes_QueryInterface(mxattr, &IID_ISAXAttributes, (void**)&saxattr);
        EXPECT_HR(hr, S_OK);
 
        /* SAXAttributes40 and SAXAttributes60 both crash on this test */
        if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes) ||
            IsEqualGUID(table->clsid, &CLSID_SAXAttributes30))
        {
            hr = ISAXAttributes_getLength(saxattr, NULL);
            EXPECT_HR(hr, E_POINTER);
        }
 
        len = -1;
        hr = ISAXAttributes_getLength(saxattr, &len);
        EXPECT_HR(hr, S_OK);
        ok(len == 0, "got %d\n", len);
 
        hr = ISAXAttributes_getValue(saxattr, 0, &value, &len);
        EXPECT_HR(hr, E_INVALIDARG);
 
        hr = ISAXAttributes_getValue(saxattr, 0, NULL, &len);
        ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
        hr = ISAXAttributes_getValue(saxattr, 0, &value, NULL);
        ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
        hr = ISAXAttributes_getValue(saxattr, 0, NULL, NULL);
        ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
        hr = ISAXAttributes_getType(saxattr, 0, &value, &len);
        EXPECT_HR(hr, E_INVALIDARG);
 
        hr = ISAXAttributes_getType(saxattr, 0, NULL, &len);
        ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
        hr = ISAXAttributes_getType(saxattr, 0, &value, NULL);
        ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
        hr = ISAXAttributes_getType(saxattr, 0, NULL, NULL);
        ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
        hr = IMXAttributes_addAttribute(mxattr, _bstr_(table->uri), _bstr_(table->local),
            _bstr_(table->qname), _bstr_(table->type), _bstr_(table->value));
        ok(hr == table->hr, "%d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
 
        if (hr == S_OK)
        {
            /* SAXAttributes40 and SAXAttributes60 both crash on this test */
            if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes) ||
                IsEqualGUID(table->clsid, &CLSID_SAXAttributes30))
            {
               hr = ISAXAttributes_getValue(saxattr, 0, NULL, &len);
               EXPECT_HR(hr, E_POINTER);
 
               hr = ISAXAttributes_getValue(saxattr, 0, &value, NULL);
               EXPECT_HR(hr, E_POINTER);
 
               hr = ISAXAttributes_getValue(saxattr, 0, NULL, NULL);
               EXPECT_HR(hr, E_POINTER);
 
               hr = ISAXAttributes_getType(saxattr, 0, NULL, &len);
               EXPECT_HR(hr, E_POINTER);
 
               hr = ISAXAttributes_getType(saxattr, 0, &value, NULL);
               EXPECT_HR(hr, E_POINTER);
 
               hr = ISAXAttributes_getType(saxattr, 0, NULL, NULL);
               EXPECT_HR(hr, E_POINTER);
            }
 
            len = -1;
            hr = ISAXAttributes_getValue(saxattr, 0, &value, &len);
            EXPECT_HR(hr, S_OK);
            ok(!lstrcmpW(_bstr_(table->value), value), "%d: got %s, expected %s\n", i, wine_dbgstr_w(value),
                table->value);
            ok(lstrlenW(value) == len, "%d: got wrong value length %d\n", i, len);
 
            len = -1;
            value = (void*)0xdeadbeef;
            hr = ISAXAttributes_getType(saxattr, 0, &value, &len);
            EXPECT_HR(hr, S_OK);
 
            if (table->type)
            {
                ok(!lstrcmpW(_bstr_(table->type), value), "%d: got %s, expected %s\n", i, wine_dbgstr_w(value),
                    table->type);
                ok(lstrlenW(value) == len, "%d: got wrong type value length %d\n", i, len);
            }
            else
            {
                ok(*value == 0, "%d: got type value %s\n", i, wine_dbgstr_w(value));
                ok(len == 0, "%d: got wrong type value length %d\n", i, len);
            }
 
            hr = ISAXAttributes_getIndexFromQName(saxattr, NULL, 0, NULL);
            if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes) ||
                IsEqualGUID(table->clsid, &CLSID_SAXAttributes30))
            {
                EXPECT_HR(hr, E_POINTER);
            }
            else
                EXPECT_HR(hr, E_INVALIDARG);
 
            hr = ISAXAttributes_getIndexFromQName(saxattr, NULL, 0, &index);
            EXPECT_HR(hr, E_INVALIDARG);
 
            index = -1;
            hr = ISAXAttributes_getIndexFromQName(saxattr, _bstr_("nonexistent"), 11, &index);
            EXPECT_HR(hr, E_INVALIDARG);
            ok(index == -1, "%d: got wrong index %d\n", i, index);
 
            index = -1;
            hr = ISAXAttributes_getIndexFromQName(saxattr, _bstr_(table->qname), 0, &index);
            EXPECT_HR(hr, E_INVALIDARG);
            ok(index == -1, "%d: got wrong index %d\n", i, index);
 
            index = -1;
            hr = ISAXAttributes_getIndexFromQName(saxattr, _bstr_(table->qname), strlen(table->qname), &index);
            EXPECT_HR(hr, S_OK);
            ok(index == 0, "%d: got wrong index %d\n", i, index);
 
            index = -1;
            hr = ISAXAttributes_getIndexFromQName(saxattr, _bstr_(table->qname), strlen(table->qname)-1, &index);
            EXPECT_HR(hr, E_INVALIDARG);
            ok(index == -1, "%d: got wrong index %d\n", i, index);
 
            if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes40) ||
                IsEqualGUID(table->clsid, &CLSID_SAXAttributes60))
            {
                hr = ISAXAttributes_getValueFromQName(saxattr, NULL, 0, NULL, NULL);
                ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
                hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, NULL, NULL);
                ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
                hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, &value, NULL);
                ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
                hr = ISAXAttributes_getValueFromName(saxattr, NULL, 0, NULL, 0, NULL, NULL);
                ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
                hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, NULL, 0, NULL, NULL);
                ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
 
                hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, NULL, 0, &value, NULL);
                ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
            }
            else
            {
                hr = ISAXAttributes_getValueFromQName(saxattr, NULL, 0, NULL, NULL);
                EXPECT_HR(hr, E_POINTER);
 
                hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, NULL, NULL);
                EXPECT_HR(hr, E_POINTER);
 
                hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, &value, NULL);
                EXPECT_HR(hr, E_POINTER);
 
                /* versions 4 and 6 crash */
                hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), strlen(table->qname), NULL, NULL);
                EXPECT_HR(hr, E_POINTER);
 
                hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), strlen(table->qname), NULL, &len);
                EXPECT_HR(hr, E_POINTER);
 
                hr = ISAXAttributes_getValueFromName(saxattr, NULL, 0, NULL, 0, NULL, NULL);
                EXPECT_HR(hr, E_POINTER);
 
                hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, NULL, 0, NULL, NULL);
                EXPECT_HR(hr, E_POINTER);
 
                hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, NULL, 0, &value, NULL);
                EXPECT_HR(hr, E_POINTER);
 
                hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, _bstr_(table->local), 0, &value, NULL);
                EXPECT_HR(hr, E_POINTER);
 
                hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, _bstr_(table->local), 0, NULL, &len);
                EXPECT_HR(hr, E_POINTER);
 
                hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), strlen(table->uri), _bstr_(table->local),
                    strlen(table->local), NULL, NULL);
                EXPECT_HR(hr, E_POINTER);
            }
 
            hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), strlen(table->qname), &value, &len);
            EXPECT_HR(hr, S_OK);
            ok(!lstrcmpW(_bstr_(table->value), value), "%d: got %s, expected %s\n", i, wine_dbgstr_w(value),
                table->value);
            ok(lstrlenW(value) == len, "%d: got wrong value length %d\n", i, len);
 
            if (table->uri) {
                hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), strlen(table->uri),
                    _bstr_(table->local), strlen(table->local), &value, &len);
                EXPECT_HR(hr, S_OK);
                ok(!lstrcmpW(_bstr_(table->value), value), "%d: got %s, expected %s\n", i, wine_dbgstr_w(value),
                    table->value);
                ok(lstrlenW(value) == len, "%d: got wrong value length %d\n", i, len);
            }
        }
 
        len = -1;
        hr = ISAXAttributes_getLength(saxattr, &len);
        EXPECT_HR(hr, S_OK);
        if (table->hr == S_OK)
            ok(len == 1, "%d: got %d length, expected 1\n", i, len);
        else
            ok(len == 0, "%d: got %d length, expected 0\n", i, len);
 
        ISAXAttributes_Release(saxattr);
        IMXAttributes_Release(mxattr);
 
        table++;
        i++;
    }
 
    free_bstrs();
}

Referenced by START_TEST().

test_mxattr_clear()

static void test_mxattr_clear ( void  )

static

Definition at line 5473 of file saxreader.c.

{
    ISAXAttributes *saxattr;
    IMXAttributes *mxattr;
    const WCHAR *ptr;
    HRESULT hr;
    int len;
 
    hr = CoCreateInstance(&CLSID_SAXAttributes, NULL, CLSCTX_INPROC_SERVER,
        &IID_IMXAttributes, (void**)&mxattr);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXAttributes_QueryInterface(mxattr, &IID_ISAXAttributes, (void**)&saxattr);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXAttributes_getQName(saxattr, 0, NULL, NULL);
    EXPECT_HR(hr, E_INVALIDARG);
 
    hr = ISAXAttributes_getQName(saxattr, 0, &ptr, &len);
    EXPECT_HR(hr, E_INVALIDARG);
 
    hr = IMXAttributes_clear(mxattr);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXAttributes_addAttribute(mxattr, _bstr_("uri"), _bstr_("local"),
        _bstr_("qname"), _bstr_("type"), _bstr_("value"));
    EXPECT_HR(hr, S_OK);
 
    len = -1;
    hr = ISAXAttributes_getLength(saxattr, &len);
    EXPECT_HR(hr, S_OK);
    ok(len == 1, "got %d\n", len);
 
    len = -1;
    hr = ISAXAttributes_getQName(saxattr, 0, NULL, &len);
    EXPECT_HR(hr, E_POINTER);
    ok(len == -1, "got %d\n", len);
 
    ptr = (void*)0xdeadbeef;
    hr = ISAXAttributes_getQName(saxattr, 0, &ptr, NULL);
    EXPECT_HR(hr, E_POINTER);
    ok(ptr == (void*)0xdeadbeef, "got %p\n", ptr);
 
    len = 0;
    hr = ISAXAttributes_getQName(saxattr, 0, &ptr, &len);
    EXPECT_HR(hr, S_OK);
    ok(len == 5, "got %d\n", len);
    ok(!lstrcmpW(ptr, _bstr_("qname")), "got %s\n", wine_dbgstr_w(ptr));
 
    hr = IMXAttributes_clear(mxattr);
    EXPECT_HR(hr, S_OK);
 
    len = -1;
    hr = ISAXAttributes_getLength(saxattr, &len);
    EXPECT_HR(hr, S_OK);
    ok(len == 0, "got %d\n", len);
 
    len = -1;
    ptr = (void*)0xdeadbeef;
    hr = ISAXAttributes_getQName(saxattr, 0, &ptr, &len);
    EXPECT_HR(hr, E_INVALIDARG);
    ok(len == -1, "got %d\n", len);
    ok(ptr == (void*)0xdeadbeef, "got %p\n", ptr);
 
    IMXAttributes_Release(mxattr);
    ISAXAttributes_Release(saxattr);
    free_bstrs();
}

Referenced by START_TEST().

test_mxattr_dispex()

static void test_mxattr_dispex ( void  )

static

Definition at line 5542 of file saxreader.c.

{
    IMXAttributes *mxattr;
    IDispatchEx *dispex;
    IUnknown *unk;
    HRESULT hr;
 
    hr = CoCreateInstance(&CLSID_SAXAttributes, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXAttributes, (void**)&mxattr);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXAttributes_QueryInterface(mxattr, &IID_IDispatchEx, (void**)&dispex);
    EXPECT_HR(hr, S_OK);
    hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
    test_obj_dispex(unk);
    IUnknown_Release(unk);
    IDispatchEx_Release(dispex);
 
    IMXAttributes_Release(mxattr);
}

Referenced by START_TEST().

test_mxattr_localname()

static void test_mxattr_localname ( void  )

static

Definition at line 5610 of file saxreader.c.

{
    static const WCHAR localname1W[] = {'l','o','c','a','l','n','a','m','e','1',0};
    static const WCHAR localnameW[] = {'l','o','c','a','l','n','a','m','e',0};
    static const WCHAR uri1W[] = {'u','r','i','1',0};
    static const WCHAR uriW[] = {'u','r','i',0};
 
    const struct msxmlsupported_data_t *table = saxattr_support_data;
 
    while (table->clsid)
    {
        ISAXAttributes *saxattr;
        IMXAttributes *mxattr;
        HRESULT hr;
        int index;
 
        if (!is_clsid_supported(table->clsid, mxattributes_support_data))
        {
            table++;
            continue;
        }
 
        hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXAttributes, (void**)&mxattr);
        EXPECT_HR(hr, S_OK);
 
        hr = IMXAttributes_QueryInterface(mxattr, &IID_ISAXAttributes, (void**)&saxattr);
        EXPECT_HR(hr, S_OK);
 
        hr = ISAXAttributes_getIndexFromName(saxattr, NULL, 0, NULL, 0, &index);
        EXPECT_HR(hr, E_INVALIDARG);
 
        /* add some ambiguos attribute names */
        hr = IMXAttributes_addAttribute(mxattr, _bstr_("uri"), _bstr_("localname"),
            _bstr_("a:localname"), _bstr_(""), _bstr_("value"));
        EXPECT_HR(hr, S_OK);
        hr = IMXAttributes_addAttribute(mxattr, _bstr_("uri"), _bstr_("localname"),
            _bstr_("b:localname"), _bstr_(""), _bstr_("value"));
        EXPECT_HR(hr, S_OK);
 
        index = -1;
        hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), localnameW, lstrlenW(localnameW), &index);
        EXPECT_HR(hr, S_OK);
        ok(index == 0, "%s: got index %d\n", table->name, index);
 
        index = -1;
        hr = ISAXAttributes_getIndexFromName(saxattr, uri1W, lstrlenW(uri1W), localnameW, lstrlenW(localnameW), &index);
        EXPECT_HR(hr, E_INVALIDARG);
        ok(index == -1, "%s: got index %d\n", table->name, index);
 
        index = -1;
        hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), localname1W, lstrlenW(localname1W), &index);
        EXPECT_HR(hr, E_INVALIDARG);
        ok(index == -1, "%s: got index %d\n", table->name, index);
 
        if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes) ||
            IsEqualGUID(table->clsid, &CLSID_SAXAttributes30))
        {
            hr = ISAXAttributes_getIndexFromName(saxattr, NULL, 0, NULL, 0, NULL);
            EXPECT_HR(hr, E_POINTER);
 
            hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), localname1W, lstrlenW(localname1W), NULL);
            EXPECT_HR(hr, E_POINTER);
        }
        else
        {
            hr = ISAXAttributes_getIndexFromName(saxattr, NULL, 0, NULL, 0, NULL);
            EXPECT_HR(hr, E_INVALIDARG);
 
            hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), localname1W, lstrlenW(localname1W), NULL);
            EXPECT_HR(hr, E_INVALIDARG);
        }
 
        hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), NULL, 0, &index);
        EXPECT_HR(hr, E_INVALIDARG);
 
        hr = ISAXAttributes_getIndexFromName(saxattr, NULL, 0, localname1W, lstrlenW(localname1W), &index);
        EXPECT_HR(hr, E_INVALIDARG);
 
        table++;
 
        ISAXAttributes_Release(saxattr);
        IMXAttributes_Release(mxattr);
        free_bstrs();
    }
}

Referenced by START_TEST().

test_mxattr_qi()

static void test_mxattr_qi ( void  )

static

Definition at line 5563 of file saxreader.c.

{
    IVBSAXAttributes *vbsaxattr, *vbsaxattr2;
    ISAXAttributes *saxattr;
    IMXAttributes *mxattr;
    HRESULT hr;
 
    hr = CoCreateInstance(&CLSID_SAXAttributes, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXAttributes, (void**)&mxattr);
    EXPECT_HR(hr, S_OK);
 
    EXPECT_REF(mxattr, 1);
    hr = IMXAttributes_QueryInterface(mxattr, &IID_ISAXAttributes, (void**)&saxattr);
    EXPECT_HR(hr, S_OK);
 
    EXPECT_REF(mxattr, 2);
    EXPECT_REF(saxattr, 2);
 
    hr = IMXAttributes_QueryInterface(mxattr, &IID_IVBSAXAttributes, (void**)&vbsaxattr);
    EXPECT_HR(hr, S_OK);
 
    EXPECT_REF(vbsaxattr, 3);
    EXPECT_REF(mxattr, 3);
    EXPECT_REF(saxattr, 3);
 
    hr = ISAXAttributes_QueryInterface(saxattr, &IID_IVBSAXAttributes, (void**)&vbsaxattr2);
    EXPECT_HR(hr, S_OK);
 
    EXPECT_REF(vbsaxattr, 4);
    EXPECT_REF(mxattr, 4);
    EXPECT_REF(saxattr, 4);
 
    IMXAttributes_Release(mxattr);
    ISAXAttributes_Release(saxattr);
    IVBSAXAttributes_Release(vbsaxattr);
    IVBSAXAttributes_Release(vbsaxattr2);
}

Referenced by START_TEST().

test_mxwriter_cdata()

static void test_mxwriter_cdata ( void  )

static

Definition at line 4752 of file saxreader.c.

{
    IVBSAXLexicalHandler *vblexical;
    ISAXContentHandler *content;
    ISAXLexicalHandler *lexical;
    IMXWriter *writer;
    VARIANT dest;
    HRESULT hr;
 
    hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXLexicalHandler, (void**)&lexical);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_IVBSAXLexicalHandler, (void**)&vblexical);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_startDocument(content);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXLexicalHandler_startCDATA(lexical);
    EXPECT_HR(hr, S_OK);
 
    V_VT(&dest) = VT_EMPTY;
    hr = IMXWriter_get_output(writer, &dest);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
    ok(!lstrcmpW(_bstr_("<![CDATA["), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
    VariantClear(&dest);
 
    hr = IVBSAXLexicalHandler_startCDATA(vblexical);
    EXPECT_HR(hr, S_OK);
 
    /* all these are escaped for text nodes */
    hr = ISAXContentHandler_characters(content, _bstr_("< > & \""), 7);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXLexicalHandler_endCDATA(lexical);
    EXPECT_HR(hr, S_OK);
 
    V_VT(&dest) = VT_EMPTY;
    hr = IMXWriter_get_output(writer, &dest);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
    ok(!lstrcmpW(_bstr_("<![CDATA[<![CDATA[< > & \"]]>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
    VariantClear(&dest);
 
    ISAXContentHandler_Release(content);
    ISAXLexicalHandler_Release(lexical);
    IVBSAXLexicalHandler_Release(vblexical);
    IMXWriter_Release(writer);
    free_bstrs();
}

Referenced by START_TEST().

test_mxwriter_characters()

static void test_mxwriter_characters ( void  )

static

Definition at line 3972 of file saxreader.c.

{
    static const WCHAR chardataW[] = {'T','E','S','T','C','H','A','R','D','A','T','A',' ','.',0};
    static const WCHAR embedded_nullbytes[] = {'a',0,'b',0,0,0,'c',0};
    const struct writer_characters_t *table = writer_characters;
    IVBSAXContentHandler *vb_content;
    ISAXContentHandler *content;
    IMXWriter *writer;
    VARIANT dest;
    BSTR str;
    HRESULT hr;
    int i = 0;
 
    hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_IVBSAXContentHandler, (void**)&vb_content);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_startDocument(content);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_characters(content, NULL, 0);
    EXPECT_HR(hr, E_INVALIDARG);
 
    hr = ISAXContentHandler_characters(content, chardataW, 0);
    EXPECT_HR(hr, S_OK);
 
    str = _bstr_("VbChars");
    hr = IVBSAXContentHandler_characters(vb_content, &str);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_characters(content, chardataW, ARRAY_SIZE(chardataW) - 1);
    EXPECT_HR(hr, S_OK);
 
    V_VT(&dest) = VT_EMPTY;
    hr = IMXWriter_get_output(writer, &dest);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
    ok(!lstrcmpW(_bstr_("VbCharsTESTCHARDATA ."), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
    VariantClear(&dest);
 
    hr = ISAXContentHandler_endDocument(content);
    EXPECT_HR(hr, S_OK);
 
    ISAXContentHandler_Release(content);
    IVBSAXContentHandler_Release(vb_content);
    IMXWriter_Release(writer);
 
    /* try empty characters data to see if element is closed */
    hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_startDocument(content);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), 1, NULL);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_characters(content, chardataW, 0);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), 1);
    EXPECT_HR(hr, S_OK);
 
    V_VT(&dest) = VT_EMPTY;
    hr = IMXWriter_get_output(writer, &dest);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
    ok(!lstrcmpW(_bstr_("<a></a>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
    VariantClear(&dest);
 
    ISAXContentHandler_Release(content);
    IMXWriter_Release(writer);
 
    /* test embedded null bytes */
    hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_startDocument(content);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_characters(content, embedded_nullbytes, ARRAY_SIZE(embedded_nullbytes));
    EXPECT_HR(hr, S_OK);
 
    V_VT(&dest) = VT_EMPTY;
    hr = IMXWriter_get_output(writer, &dest);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
    ok(SysStringLen(V_BSTR(&dest)) == ARRAY_SIZE(embedded_nullbytes), "unexpected len %d\n", SysStringLen(V_BSTR(&dest)));
    ok(!memcmp(V_BSTR(&dest), embedded_nullbytes, ARRAY_SIZE(embedded_nullbytes)),
       "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
    VariantClear(&dest);
 
    ISAXContentHandler_Release(content);
    IMXWriter_Release(writer);
 
    hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_IVBSAXContentHandler, (void**)&vb_content);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
    EXPECT_HR(hr, S_OK);
 
    hr = IVBSAXContentHandler_startDocument(vb_content);
    EXPECT_HR(hr, S_OK);
 
    str = SysAllocStringLen(embedded_nullbytes, ARRAY_SIZE(embedded_nullbytes));
    hr = IVBSAXContentHandler_characters(vb_content, &str);
    EXPECT_HR(hr, S_OK);
    SysFreeString(str);
 
    V_VT(&dest) = VT_EMPTY;
    hr = IMXWriter_get_output(writer, &dest);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
    ok(SysStringLen(V_BSTR(&dest)) == ARRAY_SIZE(embedded_nullbytes), "unexpected len %d\n", SysStringLen(V_BSTR(&dest)));
    ok(!memcmp(V_BSTR(&dest), embedded_nullbytes, ARRAY_SIZE(embedded_nullbytes)),
       "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
    VariantClear(&dest);
 
    IVBSAXContentHandler_Release(vb_content);
    IMXWriter_Release(writer);
 
    /* batch tests */
    while (table->clsid)
    {
        ISAXContentHandler *content;
        IMXWriter *writer;
        VARIANT dest;
        HRESULT hr;
 
        if (!is_clsid_supported(table->clsid, mxwriter_support_data))
        {
            table++;
            i++;
            continue;
        }
 
        hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
        EXPECT_HR(hr, S_OK);
 
        hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
        EXPECT_HR(hr, S_OK);
 
        hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
        EXPECT_HR(hr, S_OK);
 
        hr = ISAXContentHandler_startDocument(content);
        EXPECT_HR(hr, S_OK);
 
        hr = ISAXContentHandler_characters(content, _bstr_(table->data), strlen(table->data));
        EXPECT_HR(hr, S_OK);
 
        /* test output */
        if (hr == S_OK)
        {
            V_VT(&dest) = VT_EMPTY;
            hr = IMXWriter_get_output(writer, &dest);
            EXPECT_HR(hr, S_OK);
            ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
            ok(!lstrcmpW(_bstr_(table->output), V_BSTR(&dest)),
                "test %d: got wrong content %s, expected \"%s\"\n", i, wine_dbgstr_w(V_BSTR(&dest)), table->output);
            VariantClear(&dest);
        }
 
        /* with disabled escaping */
        V_VT(&dest) = VT_EMPTY;
        hr = IMXWriter_put_output(writer, dest);
        EXPECT_HR(hr, S_OK);
 
        hr = IMXWriter_put_disableOutputEscaping(writer, VARIANT_TRUE);
        EXPECT_HR(hr, S_OK);
 
        hr = ISAXContentHandler_characters(content, _bstr_(table->data), strlen(table->data));
        EXPECT_HR(hr, S_OK);
 
        /* test output */
        if (hr == S_OK)
        {
            V_VT(&dest) = VT_EMPTY;
            hr = IMXWriter_get_output(writer, &dest);
            EXPECT_HR(hr, S_OK);
            ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
            ok(!lstrcmpW(_bstr_(table->data), V_BSTR(&dest)),
                "test %d: got wrong content %s, expected \"%s\"\n", i, wine_dbgstr_w(V_BSTR(&dest)), table->data);
            VariantClear(&dest);
        }
 
        ISAXContentHandler_Release(content);
        IMXWriter_Release(writer);
 
        table++;
        i++;
    }
 
    free_bstrs();
}

Referenced by START_TEST().

test_mxwriter_comment()

static void test_mxwriter_comment ( void  )

static

Definition at line 4690 of file saxreader.c.

{
    static const WCHAR commentW[] = {'c','o','m','m','e','n','t',0};
    IVBSAXLexicalHandler *vblexical;
    ISAXContentHandler *content;
    ISAXLexicalHandler *lexical;
    IMXWriter *writer;
    VARIANT dest;
    HRESULT hr;
 
    hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXLexicalHandler, (void**)&lexical);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_IVBSAXLexicalHandler, (void**)&vblexical);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_startDocument(content);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXLexicalHandler_comment(lexical, NULL, 0);
    EXPECT_HR(hr, E_INVALIDARG);
 
    hr = IVBSAXLexicalHandler_comment(vblexical, NULL);
    EXPECT_HR(hr, E_POINTER);
 
    hr = ISAXLexicalHandler_comment(lexical, commentW, 0);
    EXPECT_HR(hr, S_OK);
 
    V_VT(&dest) = VT_EMPTY;
    hr = IMXWriter_get_output(writer, &dest);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
    ok(!lstrcmpW(_bstr_("<!---->\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
    VariantClear(&dest);
 
    hr = ISAXLexicalHandler_comment(lexical, commentW, ARRAY_SIZE(commentW) - 1);
    EXPECT_HR(hr, S_OK);
 
    V_VT(&dest) = VT_EMPTY;
    hr = IMXWriter_get_output(writer, &dest);
    EXPECT_HR(hr, S_OK);
    ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
    ok(!lstrcmpW(_bstr_("<!---->\r\n<!--comment-->\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
    VariantClear(&dest);
 
    ISAXContentHandler_Release(content);
    ISAXLexicalHandler_Release(lexical);
    IVBSAXLexicalHandler_Release(vblexical);
    IMXWriter_Release(writer);
    free_bstrs();
}

Referenced by START_TEST().

test_mxwriter_default_properties()

static void test_mxwriter_default_properties ( const struct mxwriter_props_t *  table )

static

Definition at line 3038 of file saxreader.c.

{
    int i = 0;
 
    while (table->clsid)
    {
        IMXWriter *writer;
        VARIANT_BOOL b;
        BSTR encoding;
        HRESULT hr;
 
        if (!is_clsid_supported(table->clsid, mxwriter_support_data))
        {
            table++;
            i++;
            continue;
        }
 
        hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
        EXPECT_HR(hr, S_OK);
 
        b = !table->bom;
        hr = IMXWriter_get_byteOrderMark(writer, &b);
        EXPECT_HR(hr, S_OK);
        ok(table->bom == b, "test %d: got BOM %d, expected %d\n", i, b, table->bom);
 
        b = !table->disable_escape;
        hr = IMXWriter_get_disableOutputEscaping(writer, &b);
        EXPECT_HR(hr, S_OK);
        ok(table->disable_escape == b, "test %d: got disable escape %d, expected %d\n", i, b,
           table->disable_escape);
 
        b = !table->indent;
        hr = IMXWriter_get_indent(writer, &b);
        EXPECT_HR(hr, S_OK);
        ok(table->indent == b, "test %d: got indent %d, expected %d\n", i, b, table->indent);
 
        b = !table->omitdecl;
        hr = IMXWriter_get_omitXMLDeclaration(writer, &b);
        EXPECT_HR(hr, S_OK);
        ok(table->omitdecl == b, "test %d: got omitdecl %d, expected %d\n", i, b, table->omitdecl);
 
        b = !table->standalone;
        hr = IMXWriter_get_standalone(writer, &b);
        EXPECT_HR(hr, S_OK);
        ok(table->standalone == b, "test %d: got standalone %d, expected %d\n", i, b, table->standalone);
 
        hr = IMXWriter_get_encoding(writer, &encoding);
        EXPECT_HR(hr, S_OK);
        ok(!lstrcmpW(encoding, _bstr_(table->encoding)), "test %d: got encoding %s, expected %s\n",
            i, wine_dbgstr_w(encoding), table->encoding);
        SysFreeString(encoding);
 
        IMXWriter_Release(writer);
 
        table++;
        i++;
    }
}

Referenced by test_mxwriter_properties().

test_mxwriter_dispex()

static void test_mxwriter_dispex ( void  )

static

Definition at line 4662 of file saxreader.c.

{
    IDispatchEx *dispex;
    IMXWriter *writer;
    IUnknown *unk;
    HRESULT hr;
 
    hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_IDispatchEx, (void**)&dispex);
    EXPECT_HR(hr, S_OK);
    hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
    test_obj_dispex(unk);
    IUnknown_Release(unk);
    IDispatchEx_Release(dispex);
    IMXWriter_Release(writer);
 
    if (is_clsid_supported(&CLSID_MXXMLWriter60, mxwriter_support_data))
    {
        hr = CoCreateInstance(&CLSID_MXXMLWriter60, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&unk);
        ok(hr == S_OK, "got 0x%08x\n", hr);
        test_obj_dispex(unk);
        IUnknown_Release(unk);
    }
}

Referenced by START_TEST().

test_mxwriter_dtd()

static void test_mxwriter_dtd ( void  )

static

Definition at line 4913 of file saxreader.c.

{
    static const WCHAR contentW[] = {'c','o','n','t','e','n','t'};
    static const WCHAR nameW[] = {'n','a','m','e'};
    static const WCHAR pubW[] = {'p','u','b'};
    static const WCHAR sysW[] = {'s','y','s'};
    IVBSAXLexicalHandler *vblexical;
    ISAXContentHandler *content;
    ISAXLexicalHandler *lexical;
    IVBSAXDeclHandler *vbdecl;
    ISAXDeclHandler *decl;
    ISAXDTDHandler *dtd;
    IMXWriter *writer;
    VARIANT dest;
    HRESULT hr;
 
    hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
            &IID_IMXWriter, (void**)&writer);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXLexicalHandler, (void**)&lexical);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_ISAXDeclHandler, (void**)&decl);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_IVBSAXDeclHandler, (void**)&vbdecl);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_QueryInterface(writer, &IID_IVBSAXLexicalHandler, (void**)&vblexical);
    EXPECT_HR(hr, S_OK);
 
    hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXContentHandler_startDocument(content);
    EXPECT_HR(hr, S_OK);
 
    hr = ISAXLexicalHandler_startDTD(lexical, NULL, 0, NULL, 0, NULL, 0);
    EXPECT_HR(hr, E_INVALIDARG);
 
    hr = IVBSAXLexicalHandler_startDTD(vblexical, NULL, NULL, NULL);
    EXPECT_HR(hr, E_POINTER);
 
    hr = ISAXLexicalHandler_startDTD(lexical, NULL, 0, pubW, ARRAY_SIZE(pubW), NULL, 0);
    EXPECT_HR(hr, E_INVALIDARG);
 
    hr = ISAXLexicalHandler_startDTD(lexical, NULL, 0, NULL, 0, sysW, ARRAY_SIZE(sysW));