From 7c830b8da92328401b3f85012f53319188f55d69 Mon Sep 17 00:00:00 2001 From: Jefferson Carpenter Date: Fri, 8 Oct 2021 08:50:07 +0000 Subject: [PATCH] msxml3/tests: Test VBSAXXMLReader. Signed-off-by: Jefferson Carpenter --- dlls/msxml3/tests/saxreader.c | 2022 ++++++++++++++++++++++++--------- 1 file changed, 1488 insertions(+), 534 deletions(-) diff --git a/dlls/msxml3/tests/saxreader.c b/dlls/msxml3/tests/saxreader.c index e401aafc87d..b7d64db2222 100644 --- a/dlls/msxml3/tests/saxreader.c +++ b/dlls/msxml3/tests/saxreader.c @@ -157,6 +157,32 @@ static void test_saxstr(const char *file, unsigned line, BSTR str, const char *e wine_dbgstr_wn(str, len), expected); } +enum sax_union_type { + SAXObjectType, + VB_SAXObjectType +}; +struct any_reader { + enum sax_union_type type; + union { + ISAXXMLReader *reader; + IVBSAXXMLReader *vb_reader; + } pointer; +}; +struct any_locator { + enum sax_union_type type; + union { + ISAXLocator *locator; + IVBSAXLocator *vb_locator; + } pointer; +}; +struct any_attributes { + enum sax_union_type type; + union { + ISAXAttributes *attributes; + IVBSAXAttributes *vb_attributes; + } pointer; +}; + typedef enum _CH { CH_ENDTEST, CH_PUTDOCUMENTLOCATOR, @@ -241,11 +267,19 @@ struct call_sequence #define NUM_CALL_SEQUENCES 1 static struct call_sequence *sequences[NUM_CALL_SEQUENCES]; -static void init_call_entry(ISAXLocator *locator, struct call_entry *call) +static void init_call_entry(struct any_locator locator, struct call_entry *call) { memset(call, 0, sizeof(*call)); - ISAXLocator_getLineNumber(locator, &call->line); - ISAXLocator_getColumnNumber(locator, &call->column); + switch (locator.type) { + case SAXObjectType: + ISAXLocator_getLineNumber(locator.pointer.locator, &call->line); + ISAXLocator_getColumnNumber(locator.pointer.locator, &call->column); + break; + case VB_SAXObjectType: + IVBSAXLocator_get_lineNumber(locator.pointer.vb_locator, &call->line); + IVBSAXLocator_get_columnNumber(locator.pointer.vb_locator, &call->column); + break; + } } static void add_call(struct call_sequence **seq, int sequence_index, @@ -1027,8 +1061,8 @@ static const char xmlspace_attr[] = " Some text data "; static struct call_entry *expectCall; -static ISAXLocator *locator; -static ISAXXMLReader *g_reader; +static struct any_locator locator; +static struct any_reader g_reader; int msxml_version; static void set_expected_seq(struct call_entry *expected) @@ -1044,40 +1078,18 @@ static HRESULT get_expected_ret(void) return hr; } -static HRESULT WINAPI contentHandler_QueryInterface( - ISAXContentHandler* iface, - REFIID riid, - void **ppvObject) -{ - *ppvObject = NULL; - - if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXContentHandler)) - { - *ppvObject = iface; - } - else - { - return E_NOINTERFACE; - } - - return S_OK; -} - -static ULONG WINAPI contentHandler_AddRef( - ISAXContentHandler* iface) +static ULONG contentHandler_AddRef(void) { return 2; } -static ULONG WINAPI contentHandler_Release( - ISAXContentHandler* iface) +static ULONG contentHandler_Release(void) { return 1; } -static HRESULT WINAPI contentHandler_putDocumentLocator( - ISAXContentHandler* iface, - ISAXLocator *pLocator) +static HRESULT contentHandler_putDocumentLocator( + struct any_locator pLocator) { struct call_entry call; IUnknown *unk; @@ -1089,41 +1101,92 @@ static HRESULT WINAPI contentHandler_putDocumentLocator( call.id = CH_PUTDOCUMENTLOCATOR; add_call(sequences, CONTENT_HANDLER_INDEX, &call); - hr = ISAXLocator_QueryInterface(pLocator, &IID_IVBSAXLocator, (void**)&unk); - EXPECT_HR(hr, E_NOINTERFACE); + switch (pLocator.type) { + case SAXObjectType: + hr = ISAXLocator_QueryInterface(pLocator.pointer.locator, &IID_IVBSAXLocator, (void**)&unk); + EXPECT_HR(hr, E_NOINTERFACE); + break; + case VB_SAXObjectType: + if (msxml_version < 4) { + hr = IVBSAXLocator_QueryInterface(pLocator.pointer.vb_locator, &IID_ISAXLocator, (void**)&unk); + EXPECT_HR(hr, E_NOINTERFACE); + } + else { + hr = IVBSAXLocator_QueryInterface(pLocator.pointer.vb_locator, &IID_ISAXLocator, (void**)&unk); + todo_wine EXPECT_HR(hr, S_OK); + if (unk) IUnknown_Release(unk); + } + break; + } 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); + switch (pLocator.type) { + case SAXObjectType: + EXPECT_REF(pLocator.pointer.locator, 1); + hr = ISAXLocator_QueryInterface(pLocator.pointer.locator, &IID_ISAXAttributes, (void**)&attr); + EXPECT_HR(hr, S_OK); + EXPECT_REF(pLocator.pointer.locator, 2); + hr = ISAXLocator_QueryInterface(pLocator.pointer.locator, &IID_ISAXAttributes, (void**)&attr1); + EXPECT_HR(hr, S_OK); + EXPECT_REF(pLocator.pointer.locator, 3); + ok(attr == attr1, "got %p, %p\n", attr, attr1); - hr = ISAXAttributes_QueryInterface(attr, &IID_IVBSAXAttributes, (void**)&unk); - EXPECT_HR(hr, E_NOINTERFACE); + 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 = ISAXLocator_QueryInterface(pLocator.pointer.locator, &IID_IVBSAXAttributes, (void**)&unk); + EXPECT_HR(hr, E_NOINTERFACE); - hr = ISAXAttributes_QueryInterface(attr, &IID_IMXAttributes, (void**)&mxattr); - EXPECT_HR(hr, E_NOINTERFACE); + hr = ISAXAttributes_QueryInterface(attr, &IID_IMXAttributes, (void**)&mxattr); + EXPECT_HR(hr, E_NOINTERFACE); + + ISAXAttributes_Release(attr); + ISAXAttributes_Release(attr1); + break; + case VB_SAXObjectType: + EXPECT_REF(pLocator.pointer.vb_locator, 1); + + if (msxml_version < 6) { + hr = IVBSAXLocator_QueryInterface(pLocator.pointer.vb_locator, &IID_ISAXAttributes, (void**)&unk); + EXPECT_HR(hr, E_NOINTERFACE); + } + else { + hr = ISAXLocator_QueryInterface(pLocator.pointer.locator, &IID_ISAXAttributes, (void**)&attr); + todo_wine EXPECT_HR(hr, S_OK); + EXPECT_REF(pLocator.pointer.locator, 1); + + hr = ISAXLocator_QueryInterface(pLocator.pointer.locator, &IID_ISAXAttributes, (void**)&attr1); + todo_wine EXPECT_HR(hr, S_OK); + + ok(attr == attr1, "got %p, %p\n", attr, attr1); + + if (attr) { + hr = ISAXAttributes_QueryInterface(attr, &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); + if (attr) ISAXAttributes_Release(attr); + if (attr1) ISAXAttributes_Release(attr1); + } + + hr = IVBSAXLocator_QueryInterface(pLocator.pointer.vb_locator, &IID_IVBSAXAttributes, (void**)&unk); + todo_wine EXPECT_HR(hr, E_NOINTERFACE); + break; + } } return get_expected_ret(); } static ISAXAttributes *test_attr_ptr; -static HRESULT WINAPI contentHandler_startDocument( - ISAXContentHandler* iface) +static IVBSAXAttributes *test_vb_attr_ptr; +static HRESULT contentHandler_startDocument(void) { struct call_entry call; @@ -1132,12 +1195,12 @@ static HRESULT WINAPI contentHandler_startDocument( add_call(sequences, CONTENT_HANDLER_INDEX, &call); test_attr_ptr = NULL; + test_vb_attr_ptr = NULL; return get_expected_ret(); } -static HRESULT WINAPI contentHandler_endDocument( - ISAXContentHandler* iface) +static HRESULT contentHandler_endDocument(void) { struct call_entry call; @@ -1148,8 +1211,7 @@ static HRESULT WINAPI contentHandler_endDocument( return get_expected_ret(); } -static HRESULT WINAPI contentHandler_startPrefixMapping( - ISAXContentHandler* iface, +static HRESULT contentHandler_startPrefixMapping( const WCHAR *prefix, int prefix_len, const WCHAR *uri, int uri_len) { @@ -1167,8 +1229,7 @@ static HRESULT WINAPI contentHandler_startPrefixMapping( return get_expected_ret(); } -static HRESULT WINAPI contentHandler_endPrefixMapping( - ISAXContentHandler* iface, +static HRESULT contentHandler_endPrefixMapping( const WCHAR *prefix, int len) { struct call_entry call; @@ -1183,24 +1244,27 @@ static HRESULT WINAPI contentHandler_endPrefixMapping( return get_expected_ret(); } -static HRESULT WINAPI contentHandler_startElement( - ISAXContentHandler* iface, +static HRESULT contentHandler_startElement( const WCHAR *uri, int uri_len, const WCHAR *localname, int local_len, const WCHAR *qname, int qname_len, - ISAXAttributes *saxattr) + struct any_attributes saxattr) { 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); + switch (saxattr.type) { + case SAXObjectType: + hr = ISAXAttributes_QueryInterface(saxattr.pointer.attributes, &IID_IMXAttributes, (void**)&mxattr); + EXPECT_HR(hr, E_NOINTERFACE); + break; + case VB_SAXObjectType: + hr = IVBSAXAttributes_QueryInterface(saxattr.pointer.vb_attributes, &IID_IMXAttributes, (void**)&mxattr); + EXPECT_HR(hr, E_NOINTERFACE); + break; + } init_call_entry(locator, &call); call.id = CH_STARTELEMENT; @@ -1208,38 +1272,92 @@ static HRESULT WINAPI contentHandler_startElement( 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); + switch (saxattr.type) { + case SAXObjectType: + if(!test_attr_ptr) + test_attr_ptr = saxattr.pointer.attributes; + ok(test_attr_ptr == saxattr.pointer.attributes, "Multiple ISAXAttributes instances are used (%p %p)\n", test_attr_ptr, saxattr.pointer.attributes); + break; + case VB_SAXObjectType: + if(!test_vb_attr_ptr) + test_vb_attr_ptr = saxattr.pointer.vb_attributes; + ok(test_vb_attr_ptr == saxattr.pointer.vb_attributes, "Multiple ISAXAttributes instances are used (%p %p)\n", test_vb_attr_ptr, saxattr.pointer.vb_attributes); + break; + } /* store actual attributes */ len = 0; - hr = ISAXAttributes_getLength(saxattr, &len); - EXPECT_HR(hr, S_OK); + switch (saxattr.type) { + case SAXObjectType: + hr = ISAXAttributes_getLength(saxattr.pointer.attributes, &len); + EXPECT_HR(hr, S_OK); + break; + case VB_SAXObjectType: + hr = IVBSAXAttributes_get_length(saxattr.pointer.vb_attributes, &len); + EXPECT_HR(hr, S_OK); + break; + } if (len) { VARIANT_BOOL v; int i; + BSTR uri_bstr = NULL; + BSTR localname_bstr = NULL; + BSTR qname_bstr = NULL; + BSTR value_bstr = NULL; 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); + switch (g_reader.type) { + case SAXObjectType: + hr = ISAXXMLReader_getFeature(g_reader.pointer.reader, _bstr_("http://xml.org/sax/features/namespaces"), &v); + EXPECT_HR(hr, S_OK); + break; + case VB_SAXObjectType: + hr = IVBSAXXMLReader_getFeature(g_reader.pointer.vb_reader, _bstr_("http://xml.org/sax/features/namespaces"), &v); + EXPECT_HR(hr, S_OK); + break; + } 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); + switch (saxattr.type) { + case SAXObjectType: + hr = ISAXAttributes_getName(saxattr.pointer.attributes, 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); + hr = ISAXAttributes_getValue(saxattr.pointer.attributes, i, &value, &value_len); + EXPECT_HR(hr, S_OK); + break; + case VB_SAXObjectType: + hr = IVBSAXAttributes_getURI(saxattr.pointer.vb_attributes, i, &uri_bstr); + EXPECT_HR(hr, S_OK); + uri = uri_bstr; + uri_len = SysStringLen(uri_bstr); + + hr = IVBSAXAttributes_getLocalName(saxattr.pointer.vb_attributes, i, &localname_bstr); + EXPECT_HR(hr, S_OK); + localname = localname_bstr; + local_len = SysStringLen(localname_bstr); + + hr = IVBSAXAttributes_getQName(saxattr.pointer.vb_attributes, i, &qname_bstr); + EXPECT_HR(hr, S_OK); + qname = qname_bstr; + qname_len = SysStringLen(qname_bstr); + + hr = IVBSAXAttributes_getValue(saxattr.pointer.vb_attributes, i, &value_bstr); + EXPECT_HR(hr, S_OK); + value = value_bstr; + value_len = SysStringLen(value_bstr); + break; + } /* if 'namespaces' switched off uri and local name contains garbage */ if (v == VARIANT_FALSE && msxml_version > 0) @@ -1255,6 +1373,11 @@ static HRESULT WINAPI contentHandler_startElement( attr[i].qnameW = SysAllocStringLen(qname, qname_len); attr[i].valueW = SysAllocStringLen(value, value_len); + + SysFreeString(uri_bstr); + SysFreeString(localname_bstr); + SysFreeString(qname_bstr); + SysFreeString(value_bstr); } call.attributes = attr; @@ -1266,18 +1389,13 @@ static HRESULT WINAPI contentHandler_startElement( return get_expected_ret(); } -static HRESULT WINAPI contentHandler_endElement( - ISAXContentHandler* iface, +static HRESULT contentHandler_endElement( const WCHAR *uri, int uri_len, const WCHAR *localname, int local_len, const WCHAR *qname, int qname_len) { 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); @@ -1288,8 +1406,7 @@ static HRESULT WINAPI contentHandler_endElement( return get_expected_ret(); } -static HRESULT WINAPI contentHandler_characters( - ISAXContentHandler* iface, +static HRESULT contentHandler_characters( const WCHAR *chars, int len) { @@ -1305,8 +1422,7 @@ static HRESULT WINAPI contentHandler_characters( return get_expected_ret(); } -static HRESULT WINAPI contentHandler_ignorableWhitespace( - ISAXContentHandler* iface, +static HRESULT contentHandler_ignorableWhitespace( const WCHAR *chars, int len) { struct call_entry call; @@ -1321,8 +1437,7 @@ static HRESULT WINAPI contentHandler_ignorableWhitespace( return get_expected_ret(); } -static HRESULT WINAPI contentHandler_processingInstruction( - ISAXContentHandler* iface, +static HRESULT contentHandler_processingInstruction( const WCHAR *target, int target_len, const WCHAR *data, int data_len) { @@ -1340,8 +1455,7 @@ static HRESULT WINAPI contentHandler_processingInstruction( return get_expected_ret(); } -static HRESULT WINAPI contentHandler_skippedEntity( - ISAXContentHandler* iface, +static HRESULT contentHandler_skippedEntity( const WCHAR *name, int len) { struct call_entry call; @@ -1356,34 +1470,14 @@ static HRESULT WINAPI contentHandler_skippedEntity( return get_expected_ret(); } -static const ISAXContentHandlerVtbl contentHandlerVtbl = -{ - contentHandler_QueryInterface, - contentHandler_AddRef, - contentHandler_Release, - contentHandler_putDocumentLocator, - contentHandler_startDocument, - contentHandler_endDocument, - contentHandler_startPrefixMapping, - contentHandler_endPrefixMapping, - contentHandler_startElement, - contentHandler_endElement, - contentHandler_characters, - contentHandler_ignorableWhitespace, - contentHandler_processingInstruction, - contentHandler_skippedEntity -}; - -static ISAXContentHandler contentHandler = { &contentHandlerVtbl }; - -static HRESULT WINAPI isaxerrorHandler_QueryInterface( - ISAXErrorHandler* iface, +static HRESULT WINAPI saxContentHandler_QueryInterface( + ISAXContentHandler* iface, REFIID riid, void **ppvObject) { *ppvObject = NULL; - if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXErrorHandler)) + if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXContentHandler)) { *ppvObject = iface; } @@ -1395,76 +1489,149 @@ static HRESULT WINAPI isaxerrorHandler_QueryInterface( return S_OK; } -static ULONG WINAPI isaxerrorHandler_AddRef( - ISAXErrorHandler* iface) +static ULONG WINAPI saxContentHandler_AddRef( + ISAXContentHandler* iface) { - return 2; + return contentHandler_AddRef(); } -static ULONG WINAPI isaxerrorHandler_Release( - ISAXErrorHandler* iface) +static ULONG WINAPI saxContentHandler_Release( + ISAXContentHandler* iface) { - return 1; + return contentHandler_Release(); } -static HRESULT WINAPI isaxerrorHandler_error( - ISAXErrorHandler* iface, - ISAXLocator *pLocator, - const WCHAR *pErrorMessage, - HRESULT hrErrorCode) +static HRESULT WINAPI saxContentHandler_putDocumentLocator( + ISAXContentHandler* iface, + ISAXLocator *pLocator) { - ok(0, "unexpected call\n"); - return S_OK; + struct any_locator put_locator; + put_locator.type = SAXObjectType; + put_locator.pointer.locator = pLocator; + + return contentHandler_putDocumentLocator(put_locator); } -static HRESULT WINAPI isaxerrorHandler_fatalError( - ISAXErrorHandler* iface, - ISAXLocator *pLocator, - const WCHAR *message, - HRESULT hr) +static HRESULT WINAPI saxContentHandler_startDocument( + ISAXContentHandler* iface) { - struct call_entry call; + return contentHandler_startDocument(); +} - init_call_entry(locator, &call); - call.id = EH_FATALERROR; - call.ret = hr; +static HRESULT WINAPI saxContentHandler_endDocument( + ISAXContentHandler* iface) +{ + return contentHandler_endDocument(); +} - add_call(sequences, CONTENT_HANDLER_INDEX, &call); +static HRESULT WINAPI saxContentHandler_startPrefixMapping( + ISAXContentHandler* iface, + const WCHAR *prefix, int prefix_len, + const WCHAR *uri, int uri_len) +{ + return contentHandler_startPrefixMapping(prefix, prefix_len, uri, uri_len); +} - get_expected_ret(); - return S_OK; +static HRESULT WINAPI saxContentHandler_endPrefixMapping( + ISAXContentHandler* iface, + const WCHAR *prefix, int len) +{ + return contentHandler_endPrefixMapping(prefix, len); } -static HRESULT WINAPI isaxerrorHandler_ignorableWarning( - ISAXErrorHandler* iface, - ISAXLocator *pLocator, - const WCHAR *pErrorMessage, - HRESULT hrErrorCode) +static HRESULT WINAPI saxContentHandler_startElement( + ISAXContentHandler* iface, + const WCHAR *uri, int uri_len, + const WCHAR *localname, int local_len, + const WCHAR *qname, int qname_len, + ISAXAttributes *saxattr) { - ok(0, "unexpected call\n"); - return S_OK; + struct any_attributes attributes; + attributes.type = SAXObjectType; + attributes.pointer.attributes = saxattr; + + ok(uri != NULL, "uri == NULL\n"); + ok(localname != NULL, "localname == NULL\n"); + ok(qname != NULL, "qname == NULL\n"); + + return contentHandler_startElement( + uri, uri_len, localname, local_len, qname, qname_len, + attributes); } -static const ISAXErrorHandlerVtbl errorHandlerVtbl = +static HRESULT WINAPI saxContentHandler_endElement( + ISAXContentHandler* iface, + const WCHAR *uri, int uri_len, + const WCHAR *localname, int local_len, + const WCHAR *qname, int qname_len) { - isaxerrorHandler_QueryInterface, - isaxerrorHandler_AddRef, - isaxerrorHandler_Release, - isaxerrorHandler_error, - isaxerrorHandler_fatalError, - isaxerrorHandler_ignorableWarning + ok(uri != NULL, "uri == NULL\n"); + ok(localname != NULL, "localname == NULL\n"); + ok(qname != NULL, "qname == NULL\n"); + + return contentHandler_endElement( + uri, uri_len, localname, local_len, qname, qname_len); +} + +static HRESULT WINAPI saxContentHandler_characters( + ISAXContentHandler* iface, + const WCHAR *chars, + int len) +{ + return contentHandler_characters(chars, len); +} + +static HRESULT WINAPI saxContentHandler_ignorableWhitespace( + ISAXContentHandler* iface, + const WCHAR *chars, int len) +{ + return contentHandler_ignorableWhitespace(chars, len); +} + +static HRESULT WINAPI saxContentHandler_processingInstruction( + ISAXContentHandler* iface, + const WCHAR *target, int target_len, + const WCHAR *data, int data_len) +{ + return contentHandler_processingInstruction(target, target_len, data, data_len); +} + +static HRESULT WINAPI saxContentHandler_skippedEntity( + ISAXContentHandler* iface, + const WCHAR *name, int len) +{ + return contentHandler_skippedEntity(name, len); +} + +static const ISAXContentHandlerVtbl contentHandlerVtbl = +{ + saxContentHandler_QueryInterface, + saxContentHandler_AddRef, + saxContentHandler_Release, + saxContentHandler_putDocumentLocator, + saxContentHandler_startDocument, + saxContentHandler_endDocument, + saxContentHandler_startPrefixMapping, + saxContentHandler_endPrefixMapping, + saxContentHandler_startElement, + saxContentHandler_endElement, + saxContentHandler_characters, + saxContentHandler_ignorableWhitespace, + saxContentHandler_processingInstruction, + saxContentHandler_skippedEntity }; -static ISAXErrorHandler errorHandler = { &errorHandlerVtbl }; +static ISAXContentHandler contentHandler = { &contentHandlerVtbl }; -static HRESULT WINAPI isaxattributes_QueryInterface( - ISAXAttributes* iface, + +static HRESULT WINAPI vbSaxContentHandler_QueryInterface( + IVBSAXContentHandler* iface, REFIID riid, void **ppvObject) { *ppvObject = NULL; - if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXAttributes)) + if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IVBSAXContentHandler)) { *ppvObject = iface; } @@ -1476,62 +1643,485 @@ static HRESULT WINAPI isaxattributes_QueryInterface( return S_OK; } -static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface) +static ULONG WINAPI vbSaxContentHandler_AddRef( + IVBSAXContentHandler* iface) { - return 2; + return contentHandler_AddRef(); } -static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface) +static ULONG WINAPI vbSaxContentHandler_Release( + IVBSAXContentHandler* iface) { - return 1; + return contentHandler_Release(); } -static HRESULT WINAPI isaxattributes_getLength(ISAXAttributes* iface, int *length) +static HRESULT WINAPI vbSaxContentHandler_GetTypeInfoCount( IVBSAXContentHandler* iface, UINT* pctinfo ) { - *length = 3; - return S_OK; + return E_NOTIMPL; } -static HRESULT WINAPI isaxattributes_getURI( - ISAXAttributes* iface, - int nIndex, - const WCHAR **pUrl, - int *pUriSize) +static HRESULT WINAPI vbSaxContentHandler_GetTypeInfo( + IVBSAXContentHandler* iface, + UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo ) { - ok(0, "unexpected call\n"); return E_NOTIMPL; } -static HRESULT WINAPI isaxattributes_getLocalName( - ISAXAttributes* iface, - int nIndex, - const WCHAR **pLocalName, - int *pLocalNameLength) +static HRESULT WINAPI vbSaxContentHandler_GetIDsOfNames( + IVBSAXContentHandler* iface, + REFIID riid, LPOLESTR* rgszNames, UINT cNames, + LCID lcid, DISPID* rgDispId) { - ok(0, "unexpected call\n"); return E_NOTIMPL; } -static HRESULT WINAPI isaxattributes_getQName( - ISAXAttributes* iface, - int index, - const WCHAR **QName, - int *QNameLength) +static HRESULT WINAPI vbSaxContentHandler_Invoke( + IVBSAXContentHandler* iface, + DISPID dispIdMember, REFIID riid, LCID lcid, + WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, UINT* puArgErr) { - static const WCHAR attrqnamesW[][15] = {L"a:attr1junk", - L"attr2junk", - L"attr3"}; - static const int attrqnamelen[] = {7, 5, 5}; + return E_NOTIMPL; +} - 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; - } +static HRESULT WINAPI vbSaxContentHandler_putDocumentLocator( + IVBSAXContentHandler* iface, + IVBSAXLocator *oLocator) +{ + struct any_locator put_locator; + put_locator.type = VB_SAXObjectType; + put_locator.pointer.vb_locator = oLocator; + + return contentHandler_putDocumentLocator(put_locator); +} + +static HRESULT WINAPI vbSaxContentHandler_startDocument( + IVBSAXContentHandler* iface) +{ + return contentHandler_startDocument(); +} + +static HRESULT WINAPI vbSaxContentHandler_endDocument( + IVBSAXContentHandler* iface) +{ + return contentHandler_endDocument(); +} + +static HRESULT WINAPI vbSaxContentHandler_startPrefixMapping( + IVBSAXContentHandler* iface, + BSTR *prefix, BSTR *uri) +{ + return contentHandler_startPrefixMapping(*prefix, SysStringLen(*prefix), + *uri, SysStringLen(*uri)); +} + +static HRESULT WINAPI vbSaxContentHandler_endPrefixMapping( + IVBSAXContentHandler* iface, + BSTR *prefix) +{ + return contentHandler_endPrefixMapping(*prefix, SysStringLen(*prefix)); +} + +static HRESULT WINAPI vbSaxContentHandler_startElement( + IVBSAXContentHandler* iface, + BSTR *uri, BSTR *localname, BSTR *qname, + IVBSAXAttributes *saxattr) +{ + struct any_attributes attributes; + attributes.type = VB_SAXObjectType; + attributes.pointer.vb_attributes = saxattr; + + if (*uri) ok(*uri != NULL, "*uri == NULL\n"); + else todo_wine ok(*uri != NULL, "*uri == NULL\n"); + if (*localname) ok(*localname != NULL, "*localname == NULL\n"); + else todo_wine ok(*localname != NULL, "*localname == NULL\n"); + ok(*qname != NULL, "*qname == NULL\n"); + + return contentHandler_startElement( + *uri, SysStringLen(*uri), *localname, SysStringLen(*localname), + *qname, SysStringLen(*qname), attributes); +} + +static HRESULT WINAPI vbSaxContentHandler_endElement( + IVBSAXContentHandler* iface, + BSTR *uri, BSTR *localname, BSTR *qname) +{ + if (*uri) ok(*uri != NULL, "*uri == NULL\n"); + else todo_wine ok(*uri != NULL, "*uri == NULL\n"); + if (*localname) ok(*localname != NULL, "*localname == NULL\n"); + else todo_wine ok(*localname != NULL, "*localname == NULL\n"); + ok(*qname != NULL, "*qname == NULL\n"); + + return contentHandler_endElement( + *uri, SysStringLen(*uri), *localname, SysStringLen(*localname), + *qname, SysStringLen(*qname)); +} + +static HRESULT WINAPI vbSaxContentHandler_characters( + IVBSAXContentHandler* iface, + BSTR *chars) +{ + return contentHandler_characters(*chars, SysStringLen(*chars)); +} + +static HRESULT WINAPI vbSaxContentHandler_ignorableWhitespace( + IVBSAXContentHandler* iface, + BSTR *chars) +{ + return contentHandler_ignorableWhitespace(*chars, SysStringLen(*chars)); +} + +static HRESULT WINAPI vbSaxContentHandler_processingInstruction( + IVBSAXContentHandler* iface, + BSTR *target, BSTR *data) +{ + return contentHandler_processingInstruction( + *target, SysStringLen(*target), *data, SysStringLen(*data)); +} + +static HRESULT WINAPI vbSaxContentHandler_skippedEntity( + IVBSAXContentHandler* iface, + BSTR *name) +{ + return contentHandler_skippedEntity(*name, SysStringLen(*name)); +} + +static const IVBSAXContentHandlerVtbl vbContentHandlerVtbl = +{ + vbSaxContentHandler_QueryInterface, + vbSaxContentHandler_AddRef, + vbSaxContentHandler_Release, + vbSaxContentHandler_GetTypeInfoCount, + vbSaxContentHandler_GetTypeInfo, + vbSaxContentHandler_GetIDsOfNames, + vbSaxContentHandler_Invoke, + vbSaxContentHandler_putDocumentLocator, + vbSaxContentHandler_startDocument, + vbSaxContentHandler_endDocument, + vbSaxContentHandler_startPrefixMapping, + vbSaxContentHandler_endPrefixMapping, + vbSaxContentHandler_startElement, + vbSaxContentHandler_endElement, + vbSaxContentHandler_characters, + vbSaxContentHandler_ignorableWhitespace, + vbSaxContentHandler_processingInstruction, + vbSaxContentHandler_skippedEntity +}; + +static IVBSAXContentHandler vbContentHandler = { &vbContentHandlerVtbl }; + +static ULONG errorHandler_AddRef(void) +{ + return 2; +} + +static ULONG errorHandler_Release(void) +{ + return 1; +} + +static HRESULT errorHandler_error( + struct any_locator pLocator, + const WCHAR *pErrorMessage, + HRESULT hrErrorCode) +{ + ok(0, "unexpected call\n"); + return S_OK; +} + +static HRESULT errorHandler_fatalError( + struct any_locator pLocator, + const WCHAR *message, + HRESULT hr) +{ + 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; +} + +static HRESULT errorHandler_ignorableWarning( + struct any_locator pLocator, + const WCHAR *pErrorMessage, + HRESULT hrErrorCode) +{ + ok(0, "unexpected call\n"); + return S_OK; +} + +static HRESULT WINAPI isaxerrorHandler_QueryInterface( + ISAXErrorHandler* iface, + REFIID riid, + void **ppvObject) +{ + *ppvObject = NULL; + + if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXErrorHandler)) + { + *ppvObject = iface; + } + else + { + return E_NOINTERFACE; + } + + return S_OK; +} + +static ULONG WINAPI isaxerrorHandler_AddRef( + ISAXErrorHandler* iface) +{ + return errorHandler_AddRef(); +} + +static ULONG WINAPI isaxerrorHandler_Release( + ISAXErrorHandler* iface) +{ + return errorHandler_Release(); +} + +static HRESULT WINAPI isaxerrorHandler_error( + ISAXErrorHandler* iface, + ISAXLocator *pLocator, + const WCHAR *pErrorMessage, + HRESULT hrErrorCode) +{ + struct any_locator loc; + loc.type = SAXObjectType; + loc.pointer.locator = pLocator; + return errorHandler_error(loc, pErrorMessage, hrErrorCode); +} + +static HRESULT WINAPI isaxerrorHandler_fatalError( + ISAXErrorHandler* iface, + ISAXLocator *pLocator, + const WCHAR *message, + HRESULT hr) +{ + struct any_locator loc; + loc.type = SAXObjectType; + loc.pointer.locator = pLocator; + return errorHandler_fatalError(loc, message, hr); +} + +static HRESULT WINAPI isaxerrorHandler_ignorableWarning( + ISAXErrorHandler* iface, + ISAXLocator *pLocator, + const WCHAR *pErrorMessage, + HRESULT hrErrorCode) +{ + struct any_locator loc; + loc.type = SAXObjectType; + loc.pointer.locator = pLocator; + return errorHandler_ignorableWarning(loc, pErrorMessage, hrErrorCode); +} + +static const ISAXErrorHandlerVtbl errorHandlerVtbl = +{ + isaxerrorHandler_QueryInterface, + isaxerrorHandler_AddRef, + isaxerrorHandler_Release, + isaxerrorHandler_error, + isaxerrorHandler_fatalError, + isaxerrorHandler_ignorableWarning +}; + +static ISAXErrorHandler errorHandler = { &errorHandlerVtbl }; + +static HRESULT WINAPI ivbsaxerrorHandler_QueryInterface( + IVBSAXErrorHandler* iface, + REFIID riid, + void **ppvObject) +{ + *ppvObject = NULL; + + if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IVBSAXErrorHandler)) + { + *ppvObject = iface; + } + else + { + return E_NOINTERFACE; + } + + return S_OK; +} + +static ULONG WINAPI ivbsaxerrorHandler_AddRef( + IVBSAXErrorHandler* iface) +{ + return errorHandler_AddRef(); +} + +static ULONG WINAPI ivbsaxerrorHandler_Release( + IVBSAXErrorHandler* iface) +{ + return errorHandler_Release(); +} + +static HRESULT WINAPI ivbsaxerrorHandler_GetTypeInfoCount( IVBSAXErrorHandler* iface, UINT* pctinfo ) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI ivbsaxerrorHandler_GetTypeInfo( + IVBSAXErrorHandler* iface, + UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo ) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI ivbsaxerrorHandler_GetIDsOfNames( + IVBSAXErrorHandler* iface, + REFIID riid, LPOLESTR* rgszNames, UINT cNames, + LCID lcid, DISPID* rgDispId) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI ivbsaxerrorHandler_Invoke( + IVBSAXErrorHandler* iface, + DISPID dispIdMember, REFIID riid, LCID lcid, + WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, UINT* puArgErr) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI ivbsaxerrorHandler_error( + IVBSAXErrorHandler* iface, + IVBSAXLocator *pLocator, + BSTR *pErrorMessage, + HRESULT hrErrorCode) +{ + struct any_locator loc; + loc.type = VB_SAXObjectType; + loc.pointer.vb_locator = pLocator; + return errorHandler_error(loc, *pErrorMessage, hrErrorCode); +} + +static HRESULT WINAPI ivbsaxerrorHandler_fatalError( + IVBSAXErrorHandler* iface, + IVBSAXLocator *pLocator, + BSTR *message, + HRESULT hr) +{ + struct any_locator loc; + loc.type = VB_SAXObjectType; + loc.pointer.vb_locator = pLocator; + return errorHandler_fatalError(loc, *message, hr); +} + +static HRESULT WINAPI ivbsaxerrorHandler_ignorableWarning( + IVBSAXErrorHandler* iface, + IVBSAXLocator *pLocator, + BSTR *pErrorMessage, + HRESULT hrErrorCode) +{ + struct any_locator loc; + loc.type = VB_SAXObjectType; + loc.pointer.vb_locator = pLocator; + return errorHandler_ignorableWarning(loc, *pErrorMessage, hrErrorCode); +} + +static const IVBSAXErrorHandlerVtbl vbErrorHandlerVtbl = +{ + ivbsaxerrorHandler_QueryInterface, + ivbsaxerrorHandler_AddRef, + ivbsaxerrorHandler_Release, + ivbsaxerrorHandler_GetTypeInfoCount, + ivbsaxerrorHandler_GetTypeInfo, + ivbsaxerrorHandler_GetIDsOfNames, + ivbsaxerrorHandler_Invoke, + ivbsaxerrorHandler_error, + ivbsaxerrorHandler_fatalError, + ivbsaxerrorHandler_ignorableWarning +}; + +static IVBSAXErrorHandler vbErrorHandler = { &vbErrorHandlerVtbl }; + +static HRESULT WINAPI isaxattributes_QueryInterface( + ISAXAttributes* iface, + REFIID riid, + void **ppvObject) +{ + *ppvObject = NULL; + + if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXAttributes)) + { + *ppvObject = iface; + } + else + { + return E_NOINTERFACE; + } + + return S_OK; +} + +static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface) +{ + return 2; +} + +static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface) +{ + return 1; +} + +static HRESULT WINAPI isaxattributes_getLength(ISAXAttributes* iface, int *length) +{ + *length = 3; + return S_OK; +} + +static HRESULT WINAPI isaxattributes_getURI( + ISAXAttributes* iface, + int nIndex, + const WCHAR **pUrl, + int *pUriSize) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI isaxattributes_getLocalName( + ISAXAttributes* iface, + int nIndex, + const WCHAR **pLocalName, + int *pLocalNameLength) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI isaxattributes_getQName( + ISAXAttributes* iface, + int index, + const WCHAR **QName, + int *QNameLength) +{ + static const WCHAR attrqnamesW[][15] = {L"a:attr1junk", + L"attr2junk", + L"attr3"}; + 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; } @@ -1676,6 +2266,7 @@ static ISAXAttributes saxattributes = { &SAXAttributesVtbl }; struct saxlexicalhandler { ISAXLexicalHandler ISAXLexicalHandler_iface; + IVBSAXLexicalHandler IVBSAXLexicalHandler_iface; LONG ref; HRESULT qi_hr; /* ret value for QueryInterface for handler riid */ @@ -1686,44 +2277,50 @@ static inline struct saxlexicalhandler *impl_from_ISAXLexicalHandler( ISAXLexica return CONTAINING_RECORD(iface, struct saxlexicalhandler, ISAXLexicalHandler_iface); } -static HRESULT WINAPI isaxlexical_QueryInterface(ISAXLexicalHandler* iface, REFIID riid, void **out) +static inline struct saxlexicalhandler *impl_from_IVBSAXLexicalHandler( IVBSAXLexicalHandler *iface ) { - struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface); + return CONTAINING_RECORD(iface, struct saxlexicalhandler, IVBSAXLexicalHandler_iface); +} +static HRESULT saxlexical_QueryInterface(struct saxlexicalhandler *handler, REFIID riid, void **out) +{ *out = NULL; if (IsEqualGUID(riid, &IID_IUnknown)) { - *out = iface; + *out = &handler->ISAXLexicalHandler_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; + *out = &handler->ISAXLexicalHandler_iface; + } + else if (IsEqualGUID(riid, &IID_IVBSAXLexicalHandler)) + { + if (handler->qi_hr == E_NOINTERFACE) return handler->qi_hr; + *out = &handler->IVBSAXLexicalHandler_iface; } if (*out) - ISAXLexicalHandler_AddRef(iface); + ISAXLexicalHandler_AddRef(&handler->ISAXLexicalHandler_iface); else return E_NOINTERFACE; return S_OK; } -static ULONG WINAPI isaxlexical_AddRef(ISAXLexicalHandler* iface) +static ULONG saxlexical_AddRef(struct saxlexicalhandler *handler) { - struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface); return InterlockedIncrement(&handler->ref); } -static ULONG WINAPI isaxlexical_Release(ISAXLexicalHandler* iface) +static ULONG saxlexical_Release(struct saxlexicalhandler *handler) { - struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface); return InterlockedDecrement(&handler->ref); } -static HRESULT WINAPI isaxlexical_startDTD(ISAXLexicalHandler* iface, +static HRESULT saxlexical_startDTD( const WCHAR * pName, int nName, const WCHAR * pPublicId, int nPublicId, const WCHAR * pSystemId, int nSystemId) { @@ -1731,27 +2328,25 @@ static HRESULT WINAPI isaxlexical_startDTD(ISAXLexicalHandler* iface, return E_NOTIMPL; } -static HRESULT WINAPI isaxlexical_endDTD(ISAXLexicalHandler* iface) +static HRESULT saxlexical_endDTD(void) { ok(0, "call not expected\n"); return E_NOTIMPL; } -static HRESULT WINAPI isaxlexical_startEntity(ISAXLexicalHandler *iface, - const WCHAR * pName, int nName) +static HRESULT saxlexical_startEntity(const WCHAR * pName, int nName) { ok(0, "call not expected\n"); return E_NOTIMPL; } -static HRESULT WINAPI isaxlexical_endEntity(ISAXLexicalHandler *iface, - const WCHAR * pName, int nName) +static HRESULT saxlexical_endEntity(const WCHAR * pName, int nName) { ok(0, "call not expected\n"); return E_NOTIMPL; } -static HRESULT WINAPI isaxlexical_startCDATA(ISAXLexicalHandler *iface) +static HRESULT saxlexical_startCDATA(void) { struct call_entry call; @@ -1762,7 +2357,7 @@ static HRESULT WINAPI isaxlexical_startCDATA(ISAXLexicalHandler *iface) return get_expected_ret(); } -static HRESULT WINAPI isaxlexical_endCDATA(ISAXLexicalHandler *iface) +static HRESULT saxlexical_endCDATA(void) { struct call_entry call; @@ -1773,13 +2368,70 @@ static HRESULT WINAPI isaxlexical_endCDATA(ISAXLexicalHandler *iface) return get_expected_ret(); } -static HRESULT WINAPI isaxlexical_comment(ISAXLexicalHandler *iface, - const WCHAR * pChars, int nChars) +static HRESULT saxlexical_comment(const WCHAR * pChars, int nChars) { ok(0, "call not expected\n"); return E_NOTIMPL; } +static HRESULT WINAPI isaxlexical_QueryInterface(ISAXLexicalHandler* iface, REFIID riid, void **out) +{ + struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface); + return saxlexical_QueryInterface(handler, riid, out); +} + +static ULONG WINAPI isaxlexical_AddRef(ISAXLexicalHandler* iface) +{ + struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface); + return saxlexical_AddRef(handler); +} + +static ULONG WINAPI isaxlexical_Release(ISAXLexicalHandler* iface) +{ + struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface); + return saxlexical_Release(handler); +} + +static HRESULT WINAPI isaxlexical_startDTD(ISAXLexicalHandler* iface, + const WCHAR * pName, int nName, const WCHAR * pPublicId, + int nPublicId, const WCHAR * pSystemId, int nSystemId) +{ + return saxlexical_startDTD(pName, nName, pPublicId, nPublicId, pSystemId, nSystemId); +} + +static HRESULT WINAPI isaxlexical_endDTD(ISAXLexicalHandler* iface) +{ + return saxlexical_endDTD(); +} + +static HRESULT WINAPI isaxlexical_startEntity(ISAXLexicalHandler *iface, + const WCHAR * pName, int nName) +{ + return saxlexical_startEntity(pName, nName); +} + +static HRESULT WINAPI isaxlexical_endEntity(ISAXLexicalHandler *iface, + const WCHAR * pName, int nName) +{ + return saxlexical_endEntity(pName, nName); +} + +static HRESULT WINAPI isaxlexical_startCDATA(ISAXLexicalHandler *iface) +{ + return saxlexical_startCDATA(); +} + +static HRESULT WINAPI isaxlexical_endCDATA(ISAXLexicalHandler *iface) +{ + return saxlexical_endCDATA(); +} + +static HRESULT WINAPI isaxlexical_comment(ISAXLexicalHandler *iface, + const WCHAR * pChars, int nChars) +{ + return saxlexical_comment(pChars, nChars); +} + static const ISAXLexicalHandlerVtbl SAXLexicalHandlerVtbl = { isaxlexical_QueryInterface, @@ -1794,9 +2446,115 @@ static const ISAXLexicalHandlerVtbl SAXLexicalHandlerVtbl = isaxlexical_comment }; +static HRESULT WINAPI ivbsaxlexical_QueryInterface(IVBSAXLexicalHandler* iface, REFIID riid, void **out) +{ + struct saxlexicalhandler *handler = impl_from_IVBSAXLexicalHandler(iface); + return saxlexical_QueryInterface(handler, riid, out); +} + +static ULONG WINAPI ivbsaxlexical_AddRef(IVBSAXLexicalHandler* iface) +{ + struct saxlexicalhandler *handler = impl_from_IVBSAXLexicalHandler(iface); + return saxlexical_AddRef(handler); +} + +static ULONG WINAPI ivbsaxlexical_Release(IVBSAXLexicalHandler* iface) +{ + struct saxlexicalhandler *handler = impl_from_IVBSAXLexicalHandler(iface); + return saxlexical_Release(handler); +} + +static HRESULT WINAPI ivbsaxlexical_GetTypeInfoCount( IVBSAXLexicalHandler* iface, UINT* pctinfo ) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI ivbsaxlexical_GetTypeInfo( + IVBSAXLexicalHandler* iface, + UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo ) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI ivbsaxlexical_GetIDsOfNames( + IVBSAXLexicalHandler* iface, + REFIID riid, LPOLESTR* rgszNames, UINT cNames, + LCID lcid, DISPID* rgDispId) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI ivbsaxlexical_Invoke( + IVBSAXLexicalHandler* iface, + DISPID dispIdMember, REFIID riid, LCID lcid, + WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, UINT* puArgErr) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI ivbsaxlexical_startDTD(IVBSAXLexicalHandler* iface, + BSTR *pName, BSTR *pPublicId, BSTR *pSystemId) +{ + return saxlexical_startDTD(*pName, SysStringLen(*pName), + *pPublicId, SysStringLen(*pPublicId), *pSystemId, SysStringLen(*pSystemId)); +} + +static HRESULT WINAPI ivbsaxlexical_endDTD(IVBSAXLexicalHandler* iface) +{ + return saxlexical_endDTD(); +} + +static HRESULT WINAPI ivbsaxlexical_startEntity(IVBSAXLexicalHandler *iface, + BSTR *pName) +{ + return saxlexical_startEntity(*pName, SysStringLen(*pName)); +} + +static HRESULT WINAPI ivbsaxlexical_endEntity(IVBSAXLexicalHandler *iface, + BSTR *pName) +{ + return saxlexical_endEntity(*pName, SysStringLen(*pName)); +} + +static HRESULT WINAPI ivbsaxlexical_startCDATA(IVBSAXLexicalHandler *iface) +{ + return saxlexical_startCDATA(); +} + +static HRESULT WINAPI ivbsaxlexical_endCDATA(IVBSAXLexicalHandler *iface) +{ + return saxlexical_endCDATA(); +} + +static HRESULT WINAPI ivbsaxlexical_comment(IVBSAXLexicalHandler *iface, + BSTR *pChars) +{ + return saxlexical_comment(*pChars, SysStringLen(*pChars)); +} + +static const IVBSAXLexicalHandlerVtbl VBSAXLexicalHandlerVtbl = +{ + ivbsaxlexical_QueryInterface, + ivbsaxlexical_AddRef, + ivbsaxlexical_Release, + ivbsaxlexical_GetTypeInfoCount, + ivbsaxlexical_GetTypeInfo, + ivbsaxlexical_GetIDsOfNames, + ivbsaxlexical_Invoke, + ivbsaxlexical_startDTD, + ivbsaxlexical_endDTD, + ivbsaxlexical_startEntity, + ivbsaxlexical_endEntity, + ivbsaxlexical_startCDATA, + ivbsaxlexical_endCDATA, + ivbsaxlexical_comment +}; + static void init_saxlexicalhandler(struct saxlexicalhandler *handler, HRESULT hr) { handler->ISAXLexicalHandler_iface.lpVtbl = &SAXLexicalHandlerVtbl; + handler->IVBSAXLexicalHandler_iface.lpVtbl = &VBSAXLexicalHandlerVtbl; handler->ref = 1; handler->qi_hr = hr; } @@ -2098,7 +2856,16 @@ static const IStreamVtbl instreamVtbl = { static IStream instream = { &instreamVtbl }; -static struct msxmlsupported_data_t reader_support_data[] = +static struct msxmlsupported_data_t reader_support_data[] = +{ + { &CLSID_SAXXMLReader, "SAXReader" }, + { &CLSID_SAXXMLReader30, "SAXReader30" }, + { &CLSID_SAXXMLReader40, "SAXReader40" }, + { &CLSID_SAXXMLReader60, "SAXReader60" }, + { NULL } +}; + +static struct msxmlsupported_data_t vb_reader_support_data[] = { { &CLSID_SAXXMLReader, "SAXReader" }, { &CLSID_SAXXMLReader30, "SAXReader30" }, @@ -2107,6 +2874,27 @@ static struct msxmlsupported_data_t reader_support_data[] = { NULL } }; +struct typed_msxmlsupported_data_t { + enum sax_union_type type; + const struct msxmlsupported_data_t* table; +}; + +static struct typed_msxmlsupported_data_t typed_reader_support_data[] = +{ + { + SAXObjectType, + reader_support_data, + }, + { + VB_SAXObjectType, + vb_reader_support_data, + }, + { + 0, + NULL, + }, +}; + static struct saxlexicalhandler lexicalhandler; static struct saxdeclhandler declhandler; @@ -2128,14 +2916,133 @@ static IStream *create_test_stream(const char *data, int len) return stream; } +static ULONG any_reader_Release(struct any_reader reader) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_Release(reader.pointer.reader); + case VB_SAXObjectType: + return IVBSAXXMLReader_Release(reader.pointer.vb_reader); + } + return 0; +} + +static HRESULT any_reader_getContentHandler(struct any_reader reader, + ISAXContentHandler **pContentHandler, IVBSAXContentHandler **pVBContentHandler) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_getContentHandler(reader.pointer.reader, pContentHandler); + case VB_SAXObjectType: + return IVBSAXXMLReader_get_contentHandler(reader.pointer.vb_reader, pVBContentHandler); + } + return E_NOTIMPL; +} + +static HRESULT any_reader_putContentHandler(struct any_reader reader, + ISAXContentHandler *pContentHandler, IVBSAXContentHandler *pVBContentHandler) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_putContentHandler(reader.pointer.reader, pContentHandler); + case VB_SAXObjectType: + return IVBSAXXMLReader_putref_contentHandler(reader.pointer.vb_reader, pVBContentHandler); + } + return E_NOTIMPL; +} + +static HRESULT any_reader_getErrorHandler(struct any_reader reader, + ISAXErrorHandler **pErrorHandler, IVBSAXErrorHandler **pVBErrorHandler) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_getErrorHandler(reader.pointer.reader, pErrorHandler); + case VB_SAXObjectType: + return IVBSAXXMLReader_get_errorHandler(reader.pointer.vb_reader, pVBErrorHandler); + } + return E_NOTIMPL; +} + +static HRESULT any_reader_putErrorHandler(struct any_reader reader, + ISAXErrorHandler *pErrorHandler, IVBSAXErrorHandler *pVBErrorHandler) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_putErrorHandler(reader.pointer.reader, pErrorHandler); + case VB_SAXObjectType: + return IVBSAXXMLReader_putref_errorHandler(reader.pointer.vb_reader, pVBErrorHandler); + } + return E_NOTIMPL; +} + +static HRESULT any_reader_getEntityResolver(struct any_reader reader, + ISAXEntityResolver **pEntityResolver, IVBSAXEntityResolver **pVBEntityResolver) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_getEntityResolver(reader.pointer.reader, pEntityResolver); + case VB_SAXObjectType: + return IVBSAXXMLReader_get_entityResolver(reader.pointer.vb_reader, pVBEntityResolver); + } + return E_NOTIMPL; +} + +static HRESULT any_reader_putEntityResolver(struct any_reader reader, + ISAXEntityResolver *pEntityResolver, IVBSAXEntityResolver *pVBEntityResolver) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_putEntityResolver(reader.pointer.reader, pEntityResolver); + case VB_SAXObjectType: + return IVBSAXXMLReader_putref_entityResolver(reader.pointer.vb_reader, pVBEntityResolver); + } + return E_NOTIMPL; +} + +static HRESULT any_reader_putProperty(struct any_reader reader, BSTR pProp, VARIANT value) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_putProperty(reader.pointer.reader, pProp, value); + case VB_SAXObjectType: + return IVBSAXXMLReader_putProperty(reader.pointer.vb_reader, pProp, value); + } + return E_NOTIMPL; +} + +static HRESULT any_reader_parse(struct any_reader reader, VARIANT varInput) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_parse(reader.pointer.reader, varInput); + case VB_SAXObjectType: + return IVBSAXXMLReader_parse(reader.pointer.vb_reader, varInput); + } + return E_NOTIMPL; +} + +static HRESULT any_reader_parseURL(struct any_reader reader, const WCHAR *url, BSTR vb_url) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_parseURL(reader.pointer.reader, url); + case VB_SAXObjectType: + return IVBSAXXMLReader_parseURL(reader.pointer.vb_reader, vb_url); + } + return E_NOTIMPL; +} + +static HRESULT any_reader_putFeature(struct any_reader reader, BSTR pFeature, VARIANT_BOOL vfValue) { + switch (reader.type) { + case SAXObjectType: + return ISAXXMLReader_putFeature(reader.pointer.reader, pFeature, vfValue); + case VB_SAXObjectType: + return IVBSAXXMLReader_putFeature(reader.pointer.vb_reader, pFeature, vfValue); + } + return E_NOTIMPL; +} + static void test_saxreader(void) { - const struct msxmlsupported_data_t *table = reader_support_data; + const struct typed_msxmlsupported_data_t *tables = typed_reader_support_data; + const struct msxmlsupported_data_t *table; HRESULT hr; - ISAXXMLReader *reader = NULL; + struct any_reader reader; VARIANT var; ISAXContentHandler *content; - ISAXErrorHandler *lpErrorHandler; + IVBSAXContentHandler *vb_content; + ISAXErrorHandler *error; + IVBSAXErrorHandler *vb_error; SAFEARRAY *sa; SAFEARRAYBOUND SADim[1]; char *ptr = NULL; @@ -2143,404 +3050,450 @@ static void test_saxreader(void) ULONG written; HANDLE file; static const CHAR testXmlA[] = "test.xml"; + static const WCHAR testXmlW[] = L"test.xml"; + BSTR testXmlBstr = _bstr_(testXmlA); IXMLDOMDocument *doc; char seqname[50]; VARIANT_BOOL v; - while (table->clsid) - { - struct call_entry *test_seq; - ISAXEntityResolver *resolver; - BSTR str; - - if (!is_clsid_supported(table->clsid, reader_support_data)) + while (tables->table) { + table = tables->table; + while (table->clsid) { - table++; - continue; - } - - hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_ISAXXMLReader, (void**)&reader); - EXPECT_HR(hr, S_OK); - g_reader = reader; + struct call_entry *test_seq; + ISAXEntityResolver *resolver; + IVBSAXEntityResolver *vb_resolver; + BSTR str; - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) - msxml_version = 4; - else if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - msxml_version = 6; - else - msxml_version = 0; + if (!is_clsid_supported(table->clsid, tables->table)) + { + table++; + continue; + } - /* crashes on old versions */ - if (!IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) && - !IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - { - hr = ISAXXMLReader_getContentHandler(reader, NULL); - EXPECT_HR(hr, E_POINTER); + switch (tables->type) { + case SAXObjectType: + reader.type = tables->type; + hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_ISAXXMLReader, (void**)&reader.pointer.reader); + EXPECT_HR(hr, S_OK); + break; + case VB_SAXObjectType: + reader.type = tables->type; + hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IVBSAXXMLReader, (void**)&reader.pointer.vb_reader); + EXPECT_HR(hr, S_OK); + break; + } + g_reader = reader; - hr = ISAXXMLReader_getErrorHandler(reader, NULL); - EXPECT_HR(hr, E_POINTER); - } + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) + msxml_version = 4; + else if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + msxml_version = 6; + else + msxml_version = 0; - hr = ISAXXMLReader_getContentHandler(reader, &content); - EXPECT_HR(hr, S_OK); - ok(content == NULL, "Expected %p, got %p\n", NULL, content); + /* crashes on old versions */ + if (!IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) && + !IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + { + hr = any_reader_getContentHandler(reader, NULL, NULL); + EXPECT_HR(hr, E_POINTER); - hr = ISAXXMLReader_getErrorHandler(reader, &lpErrorHandler); - EXPECT_HR(hr, S_OK); - ok(lpErrorHandler == NULL, "Expected %p, got %p\n", NULL, lpErrorHandler); + hr = any_reader_getErrorHandler(reader, NULL, NULL); + EXPECT_HR(hr, E_POINTER); + } - hr = ISAXXMLReader_putContentHandler(reader, NULL); - EXPECT_HR(hr, S_OK); + hr = any_reader_getContentHandler(reader, &content, &vb_content); + EXPECT_HR(hr, S_OK); + switch (reader.type) { + case SAXObjectType: + ok(content == NULL, "Expected %p, got %p\n", NULL, content); + break; + case VB_SAXObjectType: + ok(vb_content == NULL, "Expected %p, got %p\n", NULL, vb_content); + break; + } - hr = ISAXXMLReader_putContentHandler(reader, &contentHandler); - EXPECT_HR(hr, S_OK); + hr = any_reader_getErrorHandler(reader, &error, &vb_error); + EXPECT_HR(hr, S_OK); + switch (reader.type) { + case SAXObjectType: + ok(error == NULL, "Expected %p, got %p\n", NULL, error); + break; + case VB_SAXObjectType: + ok(vb_error == NULL, "Expected %p, got %p\n", NULL, vb_error); + break; + } - hr = ISAXXMLReader_putErrorHandler(reader, &errorHandler); - EXPECT_HR(hr, S_OK); + hr = any_reader_putContentHandler(reader, NULL, NULL); + EXPECT_HR(hr, S_OK); - hr = ISAXXMLReader_getContentHandler(reader, &content); - EXPECT_HR(hr, S_OK); - ok(content == &contentHandler, "Expected %p, got %p\n", &contentHandler, content); + hr = any_reader_putContentHandler(reader, &contentHandler, &vbContentHandler); + EXPECT_HR(hr, S_OK); - V_VT(&var) = VT_BSTR; - V_BSTR(&var) = SysAllocString(szSimpleXML); + hr = any_reader_putErrorHandler(reader, &errorHandler, &vbErrorHandler); + EXPECT_HR(hr, S_OK); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - test_seq = content_handler_test1_alternate; - else - test_seq = content_handler_test1; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1", FALSE); + hr = any_reader_getContentHandler(reader, &content, &vb_content); + EXPECT_HR(hr, S_OK); + switch (reader.type) { + case SAXObjectType: + ok(content == &contentHandler, "Expected %p, got %p\n", &contentHandler, content); + break; + case VB_SAXObjectType: + ok(vb_content == &vbContentHandler, "Expected %p, got %p\n", &vbContentHandler, vb_content); + break; + } - VariantClear(&var); + V_VT(&var) = VT_BSTR; + V_BSTR(&var) = SysAllocString(szSimpleXML); - SADim[0].lLbound = 0; - SADim[0].cElements = sizeof(testXML)-1; - sa = SafeArrayCreate(VT_UI1, 1, SADim); - SafeArrayAccessData(sa, (void**)&ptr); - memcpy(ptr, testXML, sizeof(testXML)-1); - SafeArrayUnaccessData(sa); - V_VT(&var) = VT_ARRAY|VT_UI1; - V_ARRAY(&var) = sa; + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + test_seq = content_handler_test1_alternate; + else + test_seq = content_handler_test1; + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1", FALSE); - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1: from safe array", FALSE); + VariantClear(&var); - SafeArrayDestroy(sa); + SADim[0].lLbound = 0; + SADim[0].cElements = sizeof(testXML)-1; + sa = SafeArrayCreate(VT_UI1, 1, SADim); + SafeArrayAccessData(sa, (void**)&ptr); + memcpy(ptr, testXML, sizeof(testXML)-1); + SafeArrayUnaccessData(sa); + V_VT(&var) = VT_ARRAY|VT_UI1; + V_ARRAY(&var) = sa; - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = NULL; - hr = ISAXXMLReader_parse(reader, var); - ok(hr == E_INVALIDARG, "got %#x\n", hr); + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1: from safe array", FALSE); - V_VT(&var) = VT_DISPATCH; - V_DISPATCH(&var) = NULL; - hr = ISAXXMLReader_parse(reader, var); - ok(hr == E_INVALIDARG, "got %#x\n", hr); + SafeArrayDestroy(sa); - stream = create_test_stream(testXML, -1); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)stream; + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = NULL; + hr = any_reader_parse(reader, var); + ok(hr == E_INVALIDARG, "got %#x\n", hr); - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1: from stream", FALSE); + V_VT(&var) = VT_DISPATCH; + V_DISPATCH(&var) = NULL; + hr = any_reader_parse(reader, var); + ok(hr == E_INVALIDARG, "got %#x\n", hr); - IStream_Release(stream); + stream = create_test_stream(testXML, -1); + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)stream; - stream = create_test_stream(test_attributes, -1); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)stream; + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1: from stream", FALSE); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) - test_seq = content_handler_test_attributes_alternate_4; - else if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - test_seq = content_handler_test_attributes_alternate_6; - else - test_seq = content_handler_test_attributes; + IStream_Release(stream); - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); + stream = create_test_stream(test_attributes, -1); + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)stream; - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", FALSE); - else - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", TRUE); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) + test_seq = content_handler_test_attributes_alternate_4; + else if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + test_seq = content_handler_test_attributes_alternate_6; + else + test_seq = content_handler_test_attributes; - IStream_Release(stream); + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)&instream; + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", FALSE); + else + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", TRUE); - test_seq = read_test_seq; - read_cnt = 0; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); - ok(read_cnt == 7, "read_cnt = %d\n", read_cnt); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "Read call test", FALSE); + IStream_Release(stream); - V_VT(&var) = VT_BSTR; - V_BSTR(&var) = SysAllocString(carriage_ret_test); + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)&instream; - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - test_seq = content_handler_test2_alternate; - else - test_seq = content_handler_test2; + test_seq = read_test_seq; + read_cnt = 0; + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); + ok(read_cnt == 7, "read_cnt = %d\n", read_cnt); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "Read call test", FALSE); - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 2", FALSE); + V_VT(&var) = VT_BSTR; + V_BSTR(&var) = SysAllocString(carriage_ret_test); - VariantClear(&var); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + test_seq = content_handler_test2_alternate; + else + test_seq = content_handler_test2; - /* from file url */ - file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); - ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError()); - WriteFile(file, testXML, sizeof(testXML)-1, &written, NULL); - CloseHandle(file); + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 2", FALSE); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - test_seq = content_handler_test1_alternate; - else - test_seq = content_handler_test1; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parseURL(reader, L"test.xml"); - EXPECT_HR(hr, S_OK); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1: from file url", FALSE); + VariantClear(&var); - /* error handler */ - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - test_seq = content_handler_testerror_alternate; - else - test_seq = content_handler_testerror; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parseURL(reader, L"test.xml"); - EXPECT_HR(hr, E_FAIL); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test error", FALSE); + /* from file url */ + file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError()); + WriteFile(file, testXML, sizeof(testXML)-1, &written, NULL); + CloseHandle(file); - /* callback ret values */ - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - { - test_seq = content_handler_test_callback_rets_alt; + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + test_seq = content_handler_test1_alternate; + else + test_seq = content_handler_test1; set_expected_seq(test_seq); - hr = ISAXXMLReader_parseURL(reader, L"test.xml"); + hr = any_reader_parseURL(reader, testXmlW, testXmlBstr); EXPECT_HR(hr, S_OK); - } - else - { - test_seq = content_handler_test_callback_rets; + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1: from file url", FALSE); + + /* error handler */ + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + test_seq = content_handler_testerror_alternate; + else + test_seq = content_handler_testerror; set_expected_seq(test_seq); - hr = ISAXXMLReader_parseURL(reader, L"test.xml"); - EXPECT_HR(hr, S_FALSE); - } - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content callback ret values", FALSE); + hr = any_reader_parseURL(reader, testXmlW, testXmlBstr); + EXPECT_HR(hr, E_FAIL); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test error", FALSE); - DeleteFileA(testXmlA); + /* callback ret values */ + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + { + test_seq = content_handler_test_callback_rets_alt; + set_expected_seq(test_seq); + hr = any_reader_parseURL(reader, testXmlW, testXmlBstr); + EXPECT_HR(hr, S_OK); + } + else + { + test_seq = content_handler_test_callback_rets; + set_expected_seq(test_seq); + hr = any_reader_parseURL(reader, testXmlW, testXmlBstr); + EXPECT_HR(hr, S_FALSE); + } + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content callback ret values", FALSE); - /* parse from IXMLDOMDocument */ - hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, - &IID_IXMLDOMDocument, (void**)&doc); - EXPECT_HR(hr, S_OK); + DeleteFileA(testXmlA); - str = SysAllocString(szSimpleXML); - hr = IXMLDOMDocument_loadXML(doc, str, &v); - EXPECT_HR(hr, S_OK); - SysFreeString(str); + /* parse from IXMLDOMDocument */ + hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, + &IID_IXMLDOMDocument, (void**)&doc); + EXPECT_HR(hr, S_OK); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)doc; + str = SysAllocString(szSimpleXML); + hr = IXMLDOMDocument_loadXML(doc, str, &v); + EXPECT_HR(hr, S_OK); + SysFreeString(str); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - test_seq = content_handler_test2_alternate; - else - test_seq = content_handler_test2; + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)doc; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "parse from IXMLDOMDocument", FALSE); - IXMLDOMDocument_Release(doc); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + test_seq = content_handler_test2_alternate; + else + test_seq = content_handler_test2; - /* xml:space test */ - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - { - test_seq = xmlspaceattr_test_alternate; - } - else - test_seq = xmlspaceattr_test; + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "parse from IXMLDOMDocument", FALSE); + IXMLDOMDocument_Release(doc); - set_expected_seq(test_seq); - V_VT(&var) = VT_BSTR; - V_BSTR(&var) = _bstr_(xmlspace_attr); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); + /* xml:space test */ + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + { + test_seq = xmlspaceattr_test_alternate; + } + else + test_seq = xmlspaceattr_test; - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - { - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "xml:space handling", TRUE); - } - else - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "xml:space handling", FALSE); + set_expected_seq(test_seq); + V_VT(&var) = VT_BSTR; + V_BSTR(&var) = _bstr_(xmlspace_attr); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); - /* switch off 'namespaces' feature */ - hr = ISAXXMLReader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespaces"), VARIANT_FALSE); - EXPECT_HR(hr, S_OK); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + { + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "xml:space handling", TRUE); + } + else + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "xml:space handling", FALSE); - stream = create_test_stream(test_attributes, -1); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)stream; + /* switch off 'namespaces' feature */ + hr = any_reader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespaces"), VARIANT_FALSE); + EXPECT_HR(hr, S_OK); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - { - test_seq = content_handler_test_attributes_alt_no_ns; - } - else - test_seq = content_handler_test_attributes; + stream = create_test_stream(test_attributes, -1); + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)stream; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", TRUE); - IStream_Release(stream); - hr = ISAXXMLReader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespaces"), VARIANT_TRUE); - EXPECT_HR(hr, S_OK); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + { + test_seq = content_handler_test_attributes_alt_no_ns; + } + else + test_seq = content_handler_test_attributes; - /* switch off 'namespace-prefixes' feature */ - hr = ISAXXMLReader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespace-prefixes"), VARIANT_FALSE); - EXPECT_HR(hr, S_OK); + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", TRUE); + IStream_Release(stream); + hr = any_reader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespaces"), VARIANT_TRUE); + EXPECT_HR(hr, S_OK); - stream = create_test_stream(test_attributes, -1); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)stream; + /* switch off 'namespace-prefixes' feature */ + hr = any_reader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespace-prefixes"), VARIANT_FALSE); + EXPECT_HR(hr, S_OK); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - { - test_seq = content_handler_test_attributes_alt_no_prefix; - } - else - test_seq = content_handler_test_attributes_no_prefix; + stream = create_test_stream(test_attributes, -1); + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)stream; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", FALSE); - IStream_Release(stream); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + { + test_seq = content_handler_test_attributes_alt_no_prefix; + } + else + test_seq = content_handler_test_attributes_no_prefix; - hr = ISAXXMLReader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespace-prefixes"), VARIANT_TRUE); - EXPECT_HR(hr, S_OK); + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", FALSE); + IStream_Release(stream); - /* attribute normalization */ - stream = create_test_stream(attribute_normalize, -1); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)stream; + hr = any_reader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespace-prefixes"), VARIANT_TRUE); + EXPECT_HR(hr, S_OK); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) - { - test_seq = attribute_norm_alt; - } - else - test_seq = attribute_norm; + /* attribute normalization */ + stream = create_test_stream(attribute_normalize, -1); + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)stream; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - EXPECT_HR(hr, S_OK); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "attribute value normalization", TRUE); - IStream_Release(stream); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60)) + { + test_seq = attribute_norm_alt; + } + else + test_seq = attribute_norm; - resolver = (void*)0xdeadbeef; - hr = ISAXXMLReader_getEntityResolver(reader, &resolver); - ok(hr == S_OK, "got 0x%08x\n", hr); - ok(resolver == NULL, "got %p\n", resolver); + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + EXPECT_HR(hr, S_OK); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "attribute value normalization", TRUE); + IStream_Release(stream); - hr = ISAXXMLReader_putEntityResolver(reader, NULL); - ok(hr == S_OK || broken(hr == E_FAIL), "got 0x%08x\n", hr); + resolver = (void*)0xdeadbeef; + vb_resolver = (void*)0xdeadbeef; + hr = any_reader_getEntityResolver(reader, &resolver, &vb_resolver); + ok(hr == S_OK, "got 0x%08x\n", hr); + switch (reader.type) { + case SAXObjectType: + ok(resolver == NULL, "got %p\n", resolver); + break; + case VB_SAXObjectType: + ok(vb_resolver == NULL, "got %p\n", vb_resolver); + break; + } - /* CDATA sections */ - init_saxlexicalhandler(&lexicalhandler, S_OK); + hr = any_reader_putEntityResolver(reader, NULL, NULL); + ok(hr == S_OK || broken(hr == E_FAIL), "got 0x%08x\n", hr); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)&lexicalhandler.ISAXLexicalHandler_iface; - hr = ISAXXMLReader_putProperty(reader, _bstr_("http://xml.org/sax/properties/lexical-handler"), var); - ok(hr == S_OK, "got 0x%08x\n", hr); + /* CDATA sections */ + init_saxlexicalhandler(&lexicalhandler, S_OK); - stream = create_test_stream(test_cdata_xml, -1); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)stream; + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)&lexicalhandler.ISAXLexicalHandler_iface; + hr = any_reader_putProperty(reader, _bstr_("http://xml.org/sax/properties/lexical-handler"), var); + ok(hr == S_OK, "got 0x%08x\n", hr); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) - test_seq = cdata_test_alt; - else - test_seq = cdata_test; + stream = create_test_stream(test_cdata_xml, -1); + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)stream; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - ok(hr == S_OK, "got 0x%08x\n", hr); - sprintf(seqname, "%s: cdata test", table->name); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, seqname, TRUE); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) + test_seq = cdata_test_alt; + else + test_seq = cdata_test; - IStream_Release(stream); + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + ok(hr == S_OK, "got 0x%08x\n", hr); + sprintf(seqname, "%s: cdata test", table->name); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, seqname, TRUE); - /* 2. CDATA sections */ - stream = create_test_stream(test2_cdata_xml, -1); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)stream; + IStream_Release(stream); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) - test_seq = cdata_test2_alt; - else - test_seq = cdata_test2; + /* 2. CDATA sections */ + stream = create_test_stream(test2_cdata_xml, -1); + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)stream; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - ok(hr == S_OK, "got 0x%08x\n", hr); - sprintf(seqname, "%s: cdata test 2", table->name); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, seqname, TRUE); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) + test_seq = cdata_test2_alt; + else + test_seq = cdata_test2; - IStream_Release(stream); + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + ok(hr == S_OK, "got 0x%08x\n", hr); + sprintf(seqname, "%s: cdata test 2", table->name); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, seqname, TRUE); - /* 3. CDATA sections */ - stream = create_test_stream(test3_cdata_xml, -1); - V_VT(&var) = VT_UNKNOWN; - V_UNKNOWN(&var) = (IUnknown*)stream; + IStream_Release(stream); - if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60) || - IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) - test_seq = cdata_test3_alt; - else - test_seq = cdata_test3; + /* 3. CDATA sections */ + stream = create_test_stream(test3_cdata_xml, -1); + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)stream; - set_expected_seq(test_seq); - hr = ISAXXMLReader_parse(reader, var); - ok(hr == S_OK, "got 0x%08x\n", hr); - sprintf(seqname, "%s: cdata test 3", table->name); - ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, seqname, TRUE); + if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60) || + IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40)) + test_seq = cdata_test3_alt; + else + test_seq = cdata_test3; - IStream_Release(stream); + set_expected_seq(test_seq); + hr = any_reader_parse(reader, var); + ok(hr == S_OK, "got 0x%08x\n", hr); + sprintf(seqname, "%s: cdata test 3", table->name); + ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, seqname, TRUE); - ISAXXMLReader_Release(reader); - table++; + IStream_Release(stream); + + any_reader_Release(reader); + table++; + } + tables++; } free_bstrs(); @@ -6017,6 +6970,7 @@ START_TEST(saxreader) init_call_sequences(sequences, NUM_CALL_SEQUENCES); get_class_support_data(reader_support_data, &IID_ISAXXMLReader); + get_class_support_data(vb_reader_support_data, &IID_IVBSAXXMLReader); test_saxreader(); test_saxreader_properties(); -- 2.26.2