#include <winnls.h>
#include <ole2.h>
+#include <msxml.h>
#include <msxml2.h>
#include <msxml2did.h>
#include <dispex.h>
DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
-static const char *debugstr_guid(REFIID riid)
+static int g_unexpectedcall, g_expectedcall;
+
+struct msxmlsupported_data_t
+{
+ const GUID *clsid;
+ const char *name;
+ const IID *ifaces[3];
+ BOOL supported[3];
+};
+
+static struct msxmlsupported_data_t domdoc_support_data[] =
{
- static char buf[50];
+ { &CLSID_DOMDocument, "DOMDocument", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
+ { &CLSID_DOMDocument2, "DOMDocument2", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
+ { &CLSID_DOMDocument30, "DOMDocument30", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
+ { &CLSID_DOMDocument40, "DOMDocument40", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
+ { &CLSID_DOMDocument60, "DOMDocument60", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3} },
+ { &CLSID_FreeThreadedDOMDocument, "FreeThreadedDOMDocument", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
+ { &CLSID_XMLSchemaCache, "XMLSchemaCache", {&IID_IXMLDOMSchemaCollection} },
+ { &CLSID_XSLTemplate, "XSLTemplate", {&IID_IXSLTemplate} },
+ { &CLSID_MXNamespaceManager40, "MXNamespaceManager40", {&IID_IMXNamespaceManager} },
+ { NULL }
+};
+static const char *debugstr_msxml_guid(REFIID riid)
+{
if(!riid)
return "(null)";
- sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
- riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
- riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
- riid->Data4[5], riid->Data4[6], riid->Data4[7]);
+ if (IsEqualIID(&IID_IXMLDOMDocument, riid))
+ return "IXMLDOMDocument";
+ else if (IsEqualIID(&IID_IXMLDOMDocument2, riid))
+ return "IXMLDOMDocument2";
+ else if (IsEqualIID(&IID_IXMLDOMDocument3, riid))
+ return "IXMLDOMDocument3";
+ else if (IsEqualIID(&IID_IXMLDOMSchemaCollection, riid))
+ return "IXMLDOMSchemaCollection";
+ else if (IsEqualIID(&IID_IXSLTemplate, riid))
+ return "IXSLTemplate";
+ else if (IsEqualIID(&IID_IMXNamespaceManager, riid))
+ return "IMXNamespaceManager";
+ else
+ return wine_dbgstr_guid(riid);
+}
- return buf;
+static void get_class_support_data(struct msxmlsupported_data_t *table)
+{
+ while (table->clsid)
+ {
+ IUnknown *unk;
+ HRESULT hr;
+ int i;
+
+ for (i = 0; i < sizeof(table->ifaces)/sizeof(table->ifaces[0]) && table->ifaces[i] != NULL; i++)
+ {
+ hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, table->ifaces[i], (void**)&unk);
+ if (hr == S_OK) IUnknown_Release(unk);
+
+ table->supported[i] = hr == S_OK;
+ if (hr != S_OK) win_skip("class %s, iface %s not supported\n", table->name, debugstr_msxml_guid(table->ifaces[i]));
+ }
+
+ table++;
+ }
}
-static int g_unexpectedcall, g_expectedcall;
+static BOOL is_clsid_supported(const GUID *clsid, REFIID riid)
+{
+ const struct msxmlsupported_data_t *table = domdoc_support_data;
+ while (table->clsid)
+ {
+ if (table->clsid == clsid)
+ {
+ int i;
+
+ for (i = 0; i < sizeof(table->ifaces)/sizeof(table->ifaces[0]) && table->ifaces[i] != NULL; i++)
+ if (table->ifaces[i] == riid) return table->supported[i];
+ }
+
+ table++;
+ }
+ return FALSE;
+}
typedef struct
{
#define EXPECT_REF(node,ref) _expect_ref((IUnknown*)node, ref, __LINE__)
static void _expect_ref(IUnknown* obj, ULONG ref, int line)
{
- ULONG rc = IUnknown_AddRef(obj);
- IUnknown_Release(obj);
- ok_(__FILE__,line)(rc-1 == ref, "expected refcount %d, got %d\n", ref, rc-1);
+ ULONG rc;
+ IUnknown_AddRef(obj);
+ rc = IUnknown_Release(obj);
+ ok_(__FILE__,line)(rc == ref, "expected refcount %d, got %d\n", ref, rc);
}
#define EXPECT_LIST_LEN(list,len) _expect_list_len(list, len, __LINE__)
DECL_WIN_1252
;
+static const char nocontent[] = "no xml content here";
+
static const char szExampleXML[] =
"<?xml version='1.0' encoding='utf-8'?>\n"
"<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' a=\"attr a\" foo:b=\"attr b\" >\n"
};
static const WCHAR szOpen[] = { 'o','p','e','n',0 };
-static WCHAR szdl[] = { 'd','l',0 };
+static const WCHAR szdl[] = { 'd','l',0 };
static const WCHAR szvr[] = { 'v','r',0 };
static const WCHAR szlc[] = { 'l','c',0 };
-static WCHAR szbs[] = { 'b','s',0 };
+static const WCHAR szbs[] = { 'b','s',0 };
static const WCHAR szstr1[] = { 's','t','r','1',0 };
static const WCHAR szstr2[] = { 's','t','r','2',0 };
static const WCHAR szstar[] = { '*',0 };
static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
-static WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
-static WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
-static WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
+static const WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
+static const WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
+static const WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
-static WCHAR szElementXML[] = {'<','E','l','e','T','e','s','t','/','>',0 };
-static WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
-static WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
- 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
-static WCHAR szElementXML4[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
- '&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 };
-
-static WCHAR szAttribute[] = {'A','t','t','r',0 };
-static WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
-
-static WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
- ' ','n','o','t',' ','r','i','g','h','t','!', 0};
-static WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
- 'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
- '!',']',']','>',0};
-static WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
-static WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
-
-static WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
-static WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
-static WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0};
+static const WCHAR szElementXML[] = {'<','E','l','e','T','e','s','t','/','>',0 };
+static const WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
+static const WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
+ 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
+static const WCHAR szElementXML4[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
+ '&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 };
+
+static const WCHAR szAttribute[] = {'A','t','t','r',0 };
+static const WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
+
+static const WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
+ ' ','n','o','t',' ','r','i','g','h','t','!', 0};
+static const WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
+ 'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
+ '!',']',']','>',0};
+static const WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
+static const WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
+
+static const WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
+static const WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
+static const WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0};
#define expect_bstr_eq_and_free(bstr, expect) { \
BSTR bstrExp = alloc_str_from_narrow(expect); \
HRESULT hr;
hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
- if (hr != S_OK)
- win_skip_(__FILE__,line)("failed to create %s instance: 0x%08x\n", name, hr);
+ ok(hr == S_OK, "failed to create %s instance: 0x%08x\n", name, hr);
return obj;
}
#define create_document(iid) _create_object(&_create(CLSID_DOMDocument2), iid, __LINE__)
#define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
#define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
-#define create_cache_version(v, iid) _create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)
#define create_xsltemplate(iid) _create_object(&_create(CLSID_XSLTemplate), iid, __LINE__)
static BSTR alloc_str_from_narrow(const char *str)
else
{
r = IXMLDOMNode_get_parentNode(node, &new_node);
- wsprintf(buf, "%d", get_node_position(node));
+ sprintf(buf, "%d", get_node_position(node));
buf += strlen(buf);
}
HRESULT hr;
int i;
- hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
- &IID_IXMLDOMDocument, (void**)&doc);
- if (hr != S_OK) {
- win_skip("%d: failed to create class instance for %s\n", index, class_ptr->name);
+ if (is_clsid_supported(class_ptr->clsid, &IID_IXMLDOMDocument))
+ {
+ hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
+ }
+ else
+ {
class_ptr++;
index++;
continue;
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = _bstr_(path);
hr = IXMLDOMDocument_load(doc, var, &b);
- todo_wine {
EXPECT_HR(hr, class_ptr->ret[0].hr);
ok(b == class_ptr->ret[0].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[0].b);
- }
+
DeleteFileA(path);
b = 0xc;
ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
SysFreeString( str );
+ str = (BSTR)0x1;
+ hr = IXMLDOMDocument_get_url(doc, &str);
+ ok(hr == S_FALSE, "got 0x%08x\n", hr);
+ ok(str == NULL, "got %p\n", str);
+
/* try load an empty document */
b = VARIANT_TRUE;
str = SysAllocString( szEmpty );
SysFreeString( str );
/* test put_text */
- r = IXMLDOMDocument_put_text( doc, _bstr_("Should Fail") );
+ r = IXMLDOMDocument_put_text( doc, _bstr_("Should fail") );
ok( r == E_FAIL, "ret %08x\n", r );
/* check that there's a document element */
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&streaminit);
ok(hr == S_OK, "got 0x%08x\n", hr);
LONG count;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
b = FALSE;
r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
LONG ref;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
ptr = refcount_test;
while (ptr->type != NODE_INVALID)
IUnknown_Release(unk);
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
EXPECT_REF(doc, 1);
hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
EXPECT_REF(elem2, 2);
todo_wine ok(unk == unk2, "got %p and %p\n", unk, unk2);
-
IUnknown_Release(unk);
- IUnknown_Release(unk2);
/* IUnknown refcount is not affected by node refcount */
- todo_wine EXPECT_REF(unk2, 3);
+ todo_wine EXPECT_REF(unk2, 4);
IXMLDOMElement_AddRef(elem2);
- todo_wine EXPECT_REF(unk2, 3);
+ todo_wine EXPECT_REF(unk2, 4);
IXMLDOMElement_Release(elem2);
IXMLDOMElement_Release(elem2);
- todo_wine EXPECT_REF(unk2, 2);
+ todo_wine EXPECT_REF(unk2, 3);
+
+ IUnknown_Release(unk2);
hr = IXMLDOMElement_get_childNodes( element, &node_list );
EXPECT_HR(hr, S_OK);
LONG num;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
EXPECT_REF(doc, 1);
BSTR str;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
ok( r == S_OK, "loadXML failed\n");
LONG len;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
ok( r == S_OK, "loadXML failed\n");
free_bstrs();
}
+#ifdef __REACTOS__
/*
* This function is to display that xmlnodelist_QueryInterface
* generates SEGV for these conditions, and once fixed make sure
hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IXMLDOMNodeList, NULL);
EXPECT_NOT_HR(hr, S_OK);
}
+#endif
static void test_get_childNodes(void)
{
LONG len;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
EXPECT_HR(hr, S_OK);
hr = IXMLDOMElement_get_childNodes( element, &node_list );
EXPECT_HR(hr, S_OK);
+#ifdef __REACTOS__
verify_nodelist_query_interface(node_list);
+#endif
hr = IXMLDOMNodeList_get_length( node_list, &len );
EXPECT_HR(hr, S_OK);
static void test_get_firstChild(void)
{
- static WCHAR xmlW[] = {'x','m','l',0};
+ static const WCHAR xmlW[] = {'x','m','l',0};
IXMLDOMDocument *doc;
IXMLDOMNode *node;
VARIANT_BOOL b;
BSTR str;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
ok( r == S_OK, "loadXML failed\n");
static void test_get_lastChild(void)
{
- static WCHAR lcW[] = {'l','c',0};
- static WCHAR foW[] = {'f','o',0};
+ static const WCHAR lcW[] = {'l','c',0};
+ static const WCHAR foW[] = {'f','o',0};
IXMLDOMDocument *doc;
IXMLDOMNode *node, *child;
VARIANT_BOOL b;
BSTR str;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
ok( r == S_OK, "loadXML failed\n");
IXMLDOMNodeList *root_list, *fo_list;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
ok( r == S_OK, "loadXML failed\n");
LONG len;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
ok( r == S_OK, "loadXML failed\n");
HRESULT r;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
ok( r == S_OK, "loadXML failed\n");
HRESULT r;
LONG res;
- doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
+ if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
+ doc = create_document(&IID_IXMLDOMDocument);
dtddoc2 = create_document(&IID_IXMLDOMDocument2);
- if (!dtddoc2)
- {
- IXMLDOMDocument_Release(doc);
- return;
- }
r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
ok( r == S_OK, "ret %08x\n", r );
HRESULT hr;
LONG len;
+ if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
doc1 = create_document(&IID_IXMLDOMDocument2);
doc2 = create_document(&IID_IXMLDOMDocument2);
- if (!doc1 || !doc2) return;
ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_TRUE));
ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
LONG len;
BSTR str;
+ if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
doc = create_document(&IID_IXMLDOMDocument2);
- if (!doc) return;
hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
EXPECT_HR(hr, S_OK);
while (ptr->clsid)
{
- hr = CoCreateInstance(ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
- if (hr != S_OK)
+ if (is_clsid_supported(ptr->clsid, &IID_IXMLDOMDocument2))
+ {
+ hr = CoCreateInstance(ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ }
+ else
{
- win_skip("can't create instance of %s\n", ptr->name);
ptr++;
continue;
}
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b));
ok(b == VARIANT_TRUE, "failed to load XML string\n");
LONG len = 0;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
pNextChild = (void*)0xdeadbeef;
hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), NULL);
EXPECT_HR(hr, E_INVALIDARG);
char *ptr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
-
doc2 = create_document(&IID_IXMLDOMDocument);
- if (!doc2)
- {
- IXMLDOMDocument_Release(doc);
- return;
- }
/* save to IXMLDOMDocument */
hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
CloseHandle(hfile);
- DeleteFile("test.xml");
+ DeleteFileA("test.xml");
/* save to path VT_BSTR | VT_BYREF */
filename = _bstr_("test.xml");
ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
CloseHandle(hfile);
- DeleteFile("test.xml");
+ DeleteFileA("test.xml");
}
/* save to stream */
hr = IXMLDOMDocument_loadXML(doc, _bstr_("<a/>"), &b);
EXPECT_HR(hr, S_OK);
- CreateStreamOnHGlobal(NULL, TRUE, &stream);
+ hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
V_VT(&dest) = VT_UNKNOWN;
V_UNKNOWN(&dest) = (IUnknown*)stream;
hr = IXMLDOMDocument_save(doc, dest);
IXMLDOMDocument *doc, *docSS;
IXMLDOMNode *pNode;
VARIANT_BOOL bSucc;
-
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
-
docSS = create_document(&IID_IXMLDOMDocument);
- if (!docSS)
- {
- IXMLDOMDocument_Release(doc);
- return;
- }
hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
ok(hr == S_OK, "ret %08x\n", hr );
ok(hr == S_OK, "ret %08x\n", hr );
if(hr == S_OK)
{
- ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "Stylesheet output not correct\n");
+ ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "got output %s\n", wine_dbgstr_w(bOut));
SysFreeString(bOut);
}
HRESULT hr;
BSTR str;
- hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
- &IID_IXMLDOMDocument, (void**)&doc);
- if (hr != S_OK)
+ if (!is_clsid_supported(class_ptr->clsid, &IID_IXMLDOMDocument))
{
- win_skip("failed to create class instance for %s\n", class_ptr->name);
class_ptr++;
continue;
}
+ hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
+ &IID_IXMLDOMDocument, (void**)&doc);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
V_VT(&var) = VT_I2;
V_I2(&var) = NODE_ELEMENT;
BSTR str;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_loadXML(doc, _bstr_(namespaces_xmlA), &b);
EXPECT_HR(hr, S_OK);
static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
ok(hr == S_OK, "ret %08x\n", hr );
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
b = VARIANT_FALSE;
hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &b);
WriteFile(file, szBasicTransformXML, strlen(szBasicTransformXML), &dwWritten, NULL);
CloseHandle(file);
- /* Correct path to not include a escape character. */
+ /* Correct path to not include an escape character. */
for(i=0; i < strlen(lpPathBuffer); i++)
{
if(lpPathBuffer[i] == '\\')
}
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
-
xsl = create_document(&IID_IXMLDOMDocument);
- if (!xsl)
- {
- IXMLDOMDocument_Release(doc);
- return;
- }
hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
ok(hr == S_OK, "ret %08x\n", hr );
IXMLDOMDocument_Release(doc);
IXMLDOMDocument_Release(xsl);
- DeleteFile(lpPathBuffer);
+ DeleteFileA(lpPathBuffer);
free_bstrs();
}
VARIANT data, type;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
/* test for unsupported types */
/* NODE_DOCUMENT */
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_QueryInterface(doc, &IID_IObjectSafety, (void**)&safety);
ok(hr == S_OK, "ret %08x\n", hr );
VARIANT var;
HRESULT hr;
- hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
- if (hr != S_OK)
+ if (!is_clsid_supported(entry->guid, &IID_IXMLDOMDocument2))
{
- win_skip("can't create %s instance\n", entry->clsid);
entry++;
continue;
}
+ hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
hr = IXMLDOMDocument2_getProperty(doc, _bstr_(entry->property), &var);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(lstrcmpW(V_BSTR(&var), _bstr_(entry->value)) == 0, "expected %s, for %s\n",
LONG len;
doc = create_document(&IID_IXMLDOMDocument2);
- if (!doc) return;
b = VARIANT_FALSE;
hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
IXMLDOMDocument2_Release(doc);
doc = create_document(&IID_IXMLDOMDocument2);
- if (!doc) return;
hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNodeTypesXML), &b);
EXPECT_HR(hr, S_OK);
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_loadXML(doc, _bstr_("<root></root>"), &success);
ok(hr == S_OK, "got 0x%08x\n", hr);
LONG len;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
EXPECT_HR(hr, S_OK);
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
ok( hr == S_OK, "loadXML failed\n");
VARIANT_BOOL b;
VARIANT var;
+ if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
+ if (!is_clsid_supported(&CLSID_XMLSchemaCache, &IID_IXMLDOMSchemaCollection)) return;
+
doc = create_document(&IID_IXMLDOMDocument2);
cache = create_cache(&IID_IXMLDOMSchemaCollection);
- if (!doc || !cache)
- {
- if (doc) IXMLDOMDocument2_Release(doc);
- if (cache) IXMLDOMSchemaCollection_Release(cache);
- return;
- }
VariantInit(&var);
ULONG ref1, ref2;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
ok( hr == S_OK, "loadXML failed\n");
ULONG ref;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
EXPECT_REF(doc, 1);
BSTR str;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
/* nodes that can't support prefix */
/* 1. document */
LONG len;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
IDispatch *event;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&conn);
ok(hr == S_OK, "got 0x%08x\n", hr);
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
/* test for BSTR handling, pass broken BSTR */
memcpy(&buff[2], bodyW, sizeof(bodyW));
BSTR str;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_createElement(doc, _bstr_("Element"), &elem);
EXPECT_HR(hr, S_OK);
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
b = VARIANT_TRUE;
hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
ULONG ref1, ref2;
VARIANT v;
+ if (!is_clsid_supported(&CLSID_XSLTemplate, &IID_IXSLTemplate)) return;
template = create_xsltemplate(&IID_IXSLTemplate);
- if (!template) return;
/* works as reset */
hr = IXSLTemplate_putref_stylesheet(template, NULL);
IXMLDOMDocument_Release(doc);
- hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
- if (hr != S_OK)
+ if (!is_clsid_supported(&CLSID_FreeThreadedDOMDocument, &IID_IXMLDOMDocument))
{
- win_skip("failed to create free threaded document instance: 0x%08x\n", hr);
IXSLTemplate_Release(template);
return;
}
+ hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
b = VARIANT_TRUE;
hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXSLProcessor_put_output(processor, v);
ok(hr == S_OK, "got 0x%08x\n", hr);
- CreateStreamOnHGlobal(NULL, TRUE, &stream);
+ hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
EXPECT_REF(stream, 1);
V_VT(&v) = VT_UNKNOWN;
hr = IXSLProcessor_get_output(processor, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
- ok(lstrcmpW(V_BSTR(&v), _bstr_("")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
+ ok(*V_BSTR(&v) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
IXMLDOMDocument_Release(doc2);
VariantClear(&v);
EXPECT_NO_CHILDREN(doc);
EXPECT_NO_CHILDREN(doc2);
+ hr = IXMLDOMDocument_appendChild(doc2, NULL, NULL);
+ ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
+
+ hr = IXMLDOMElement_appendChild(elem, NULL, NULL);
+ ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
+
/* append from another document */
hr = IXMLDOMDocument_appendChild(doc2, (IXMLDOMNode*)elem, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
free_bstrs();
}
+static void write_to_file(const char *name, const char *data)
+{
+ DWORD written;
+ HANDLE hfile;
+ BOOL ret;
+
+ hfile = CreateFileA(name, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
+ ok(hfile != INVALID_HANDLE_VALUE, "failed to create test file: %s\n", name);
+
+ ret = WriteFile(hfile, data, strlen(data), &written, NULL);
+ ok(ret, "WriteFile failed: %s, %d\n", name, GetLastError());
+
+ CloseHandle(hfile);
+}
+
static void test_load(void)
{
- IXMLDOMDocument *doc;
+ IXMLDOMDocument *doc, *doc2;
IXMLDOMNodeList *list;
+ IXMLDOMElement *elem;
VARIANT_BOOL b;
- HANDLE hfile;
VARIANT src;
HRESULT hr;
- BOOL ret;
BSTR path, bstr1, bstr2;
- DWORD written;
void* ptr;
/* prepare a file */
- hfile = CreateFileA("test.xml", GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
- ok(hfile != INVALID_HANDLE_VALUE, "failed to create test file\n");
- if(hfile == INVALID_HANDLE_VALUE) return;
-
- ret = WriteFile(hfile, win1252xml, strlen(win1252xml), &written, NULL);
- ok(ret, "WriteFile failed\n");
-
- CloseHandle(hfile);
+ write_to_file("test.xml", win1252xml);
doc = create_document(&IID_IXMLDOMDocument);
EXPECT_HR(hr, S_OK);
ok(b == VARIANT_TRUE, "got %d\n", b);
+ bstr1 = NULL;
+ hr = IXMLDOMDocument_get_url(doc, &bstr1);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ SysFreeString(bstr1);
+
/* load from a path: VT_BSTR|VT_BYREF */
V_VT(&src) = VT_BSTR | VT_BYREF;
V_BSTRREF(&src) = &path;
EXPECT_HR(hr, S_OK);
ok(b == VARIANT_TRUE, "got %d\n", b);
+ bstr1 = NULL;
+ hr = IXMLDOMDocument_get_url(doc, &bstr1);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ hr = IXMLDOMDocument_get_documentElement(doc, &elem);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ /* create another instance for the same document, check url */
+ hr = IXMLDOMElement_get_ownerDocument(elem, &doc2);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ hr = IXMLDOMDocument_get_url(doc, &bstr2);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(!lstrcmpW(bstr1, bstr2), "got %s\n", wine_dbgstr_w(bstr2));
+
+ IXMLDOMDocument_Release(doc2);
+ IXMLDOMElement_Release(elem);
+
+ SysFreeString(bstr1);
+ SysFreeString(bstr2);
+
/* load from a path: VT_BSTR|VT_BYREF, null ptr */
V_VT(&src) = VT_BSTR | VT_BYREF;
V_BSTRREF(&src) = NULL;
EXPECT_HR(hr, E_INVALIDARG);
ok(b == VARIANT_FALSE, "got %d\n", b);
- IXMLDOMDocument_Release(doc);
+ bstr1 = NULL;
+ hr = IXMLDOMDocument_get_url(doc, &bstr1);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ SysFreeString(bstr1);
+
+ DeleteFileA("test.xml");
+
+ /* load from existing path, no xml content */
+ write_to_file("test.xml", nocontent);
+
+ V_VT(&src) = VT_BSTR;
+ V_BSTR(&src) = path;
+ b = VARIANT_TRUE;
+ hr = IXMLDOMDocument_load(doc, src, &b);
+ ok(hr == S_FALSE, "got 0x%08x\n", hr);
+ ok(b == VARIANT_FALSE, "got %d\n", b);
+
+ bstr1 = (BSTR)0x1;
+ hr = IXMLDOMDocument_get_url(doc, &bstr1);
+ ok(hr == S_FALSE, "got 0x%08x\n", hr);
+ ok(bstr1 == NULL, "got %p\n", bstr1);
DeleteFileA("test.xml");
+ IXMLDOMDocument_Release(doc);
doc = create_document(&IID_IXMLDOMDocument);
static void test_domobj_dispex(IUnknown *obj)
{
+ static const WCHAR testW[] = {'t','e','s','t','p','r','o','p',0};
DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
IDispatchEx *dispex;
IUnknown *unk;
hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
EXPECT_HR(hr, E_NOTIMPL);
+ unk = (IUnknown*)0xdeadbeef;
hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
EXPECT_HR(hr, E_NOTIMPL);
- if (hr == S_OK && unk) IUnknown_Release(unk);
+ ok(unk == (IUnknown*)0xdeadbeef, "got %p\n", unk);
+
+ name = SysAllocString(testW);
+ hr = IDispatchEx_GetDispID(dispex, name, fdexNameEnsure, &dispid);
+ ok(hr == DISP_E_UNKNOWNNAME, "got 0x%08x\n", hr);
+ SysFreeString(name);
IDispatchEx_Release(dispex);
}
EXPECT_REF(mgr2, 2);
prefixes = NULL;
hr = IVBMXNamespaceManager_getDeclaredPrefixes(mgr2, &prefixes);
+todo_wine
+ ok(hr == S_OK, "got 0x%08x\n", hr);
if (hr == S_OK)
{
IDispatchEx *dispex;
V_DISPATCH(&ret) = (void*)0x1;
hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
- ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
- ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
+ ok(V_VT(&ret) == VT_BSTR, "got %d\n", V_VT(&ret));
+ ok(V_BSTR(&ret) != NULL, "got %p\n", V_BSTR(&ret));
+ VariantClear(&ret);
IDispatchEx_Release(dispex);
IMXNamespacePrefixes_Release(prefixes);
doc = create_document(&IID_IXMLDOMDocument);
- IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
+ hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
test_domobj_dispex(unk);
IUnknown_Release(unk);
/* IXMLDOMNodeList for children list */
hr = IXMLDOMDocument_get_childNodes(doc, &node_list);
EXPECT_HR(hr, S_OK);
- IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
+ hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
test_domobj_dispex(unk);
IUnknown_Release(unk);
hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
- ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
+todo_wine
+ ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
V_VT(&arg) = VT_I4;
V_I4(&arg) = 0;
hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
- ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
+todo_wine
+ ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
V_VT(&arg) = VT_I4;
V_I4(&arg) = 0;
hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
- ok(V_I4(&ret) == 1, "got %d\n", V_I4(&ret));
+todo_wine
+ ok(broken(V_I4(&ret) == 1) || (V_I4(&ret) == 0), "got %d\n", V_I4(&ret));
IXMLDOMNodeList_Release(node_list);
hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
- ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
+todo_wine
+ ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
IDispatchEx_Release(dispex);
todo_wine {
ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
- ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
}
+ ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
+
V_VT(&arg) = VT_I4;
V_I4(&arg) = 0;
dispparams.cArgs = 2;
todo_wine {
ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
- ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
}
+ ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
+
V_VT(&arg) = VT_I4;
V_I4(&arg) = 0;
dispparams.cArgs = 1;
V_I4(&ret) = 1;
hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
-todo_wine {
+todo_wine
ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
- ok(V_I4(&ret) == 1, "got %d\n", V_I4(&ret));
-}
+ ok(broken(V_I4(&ret) == 1) || (V_I4(&ret) == 0), "got %d\n", V_I4(&ret));
+
IXMLDOMNamedNodeMap_Release(map);
IXMLDOMElement_Release(elem);
IXSLProcessor_Release(processor);
IXSLTemplate_Release(template);
+ if (is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument))
+ {
+ doc = create_document_version(60, &IID_IXMLDOMDocument);
+ test_domobj_dispex((IUnknown*)doc);
+ IXMLDOMDocument_Release(doc);
+ }
+
free_bstrs();
}
IXMLDOMParseError_Release(error);
IXMLDOMDocument_Release(doc);
+ if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument)) return;
doc = create_document_version(60, &IID_IXMLDOMDocument);
- if (!doc) return;
+
hr = IXMLDOMDocument_get_parseError(doc, &error);
EXPECT_HR(hr, S_OK);
hr = IXMLDOMParseError_QueryInterface(error, &IID_IXMLDOMParseError2, (void**)&error2);
&IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3 };
const supporterror_t *ptr = supporterror_test;
ISupportErrorInfo *errorinfo, *info2;
+ IXMLDOMSchemaCollection *schemacache;
IXMLDOMNamedNodeMap *map, *map2;
IXMLDOMDocument *doc;
IXMLDOMElement *elem;
void *dummy;
HRESULT hr;
+ if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument3)) return;
doc = create_document_version(60, &IID_IXMLDOMDocument3);
- if (!doc) return;
EXPECT_REF(doc, 1);
hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&errorinfo);
if (hr == S_OK)
{
hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
- ok(hr == S_OK, "got 0x%08x for %s\n", hr, debugstr_guid(*iid));
+ ok(hr == S_OK, "got 0x%08x for %s\n", hr, wine_dbgstr_guid(*iid));
IUnknown_Release(unk);
}
if (hr == S_OK)
{
hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
- ok(hr == S_OK, "%d: got 0x%08x for %s\n", ptr->type, hr, debugstr_guid(*iid));
+ ok(hr == S_OK, "%d: got 0x%08x for %s\n", ptr->type, hr, wine_dbgstr_guid(*iid));
IUnknown_Release(unk);
}
IXMLDOMElement_Release(elem);
IXMLDOMDocument_Release(doc);
+
+ /* IXMLDOMSchemaCollection */
+ hr = CoCreateInstance(&CLSID_XMLSchemaCache, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMSchemaCollection, (void**)&schemacache);
+ ok(hr == S_OK, "failed to create schema collection, 0x%08x\n", hr);
+
+ hr = IXMLDOMSchemaCollection_QueryInterface(schemacache, &IID_ISupportErrorInfo, (void**)&errorinfo);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMSchemaCollection);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ ISupportErrorInfo_Release(errorinfo);
+ IXMLDOMSchemaCollection_Release(schemacache);
+
free_bstrs();
}
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
while (ptr->type != NODE_INVALID)
{
IXMLDOMAttribute *pAttribute;
IXMLDOMElement *elem;
HRESULT hr;
+ VARIANT v;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
EXPECT_HR(hr, S_OK);
str = SysAllocString(szAttribute);
hr = IXMLDOMDocument_createAttribute(doc, _bstr_("xmlns:dt"), &pAttribute);
ok( hr == S_OK, "returns %08x\n", hr );
- if(hr == S_OK)
- {
- VARIANT v;
- V_VT(&v) = VT_BSTR;
- V_BSTR(&v) = _bstr_("urn:schemas-microsoft-com:datatypes");
- hr = IXMLDOMAttribute_put_nodeValue(pAttribute, v);
+ V_VT(&v) = VT_BSTR;
+ V_BSTR(&v) = _bstr_("urn:schemas-microsoft-com:datatypes");
+ hr = IXMLDOMAttribute_put_nodeValue(pAttribute, v);
- hr = IXMLDOMElement_setAttributeNode(root, pAttribute, NULL);
- ok(hr == S_OK, "ret %08x\n", hr );
+ hr = IXMLDOMElement_setAttributeNode(root, pAttribute, NULL);
+ ok(hr == S_OK, "ret %08x\n", hr );
- hr = IXMLDOMNode_put_dataType((IXMLDOMNode*)root, _bstr_("bin.base64"));
- ok(hr == S_OK, "ret %08x\n", hr );
+ hr = IXMLDOMNode_put_dataType((IXMLDOMNode*)root, _bstr_("bin.base64"));
+ ok(hr == S_OK, "ret %08x\n", hr );
- hr = IXMLDOMDocument_get_documentElement(doc, &elem);
- EXPECT_HR(hr, S_OK);
+ hr = IXMLDOMDocument_get_documentElement(doc, &elem);
+ EXPECT_HR(hr, S_OK);
- hr = IXMLDOMElement_get_xml(elem, &str);
- ok( hr == S_OK, "got 0x%08x\n", hr);
- todo_wine ok( lstrcmpW(str, _bstr_("<Testing xmlns:dt=\"urn:schemas-microsoft-com:datatypes\" dt:dt=\"bin.base64\"/>")) == 0,
- "got %s\n", wine_dbgstr_w(str));
- SysFreeString(str);
+ hr = IXMLDOMElement_get_xml(elem, &str);
+ ok( hr == S_OK, "got 0x%08x\n", hr);
+ todo_wine ok( lstrcmpW(str, _bstr_("<Testing xmlns:dt=\"urn:schemas-microsoft-com:datatypes\" dt:dt=\"bin.base64\"/>")) == 0,
+ "got %s\n", wine_dbgstr_w(str));
- IXMLDOMElement_Release(elem);
- IXMLDOMAttribute_Release( pAttribute);
- }
+ IXMLDOMElement_Release(elem);
+ IXMLDOMAttribute_Release( pAttribute);
SysFreeString(str);
LONG len;
BSTR s;
+ if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
doc = create_document(&IID_IXMLDOMDocument2);
- if (!doc) return;
/* null pointer */
hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
IXMLDOMDocument2_Release(doc);
/* now with CLSID_DOMDocument60 */
+ if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument2)) return;
doc = create_document_version(60, &IID_IXMLDOMDocument2);
- if (!doc) return;
/* null pointer */
hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
node = (void*)0xdeadbeef;
hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
EXPECT_HR(hr, E_NOTIMPL);
- ok(node == (void*)0xdeadbeef, "got %p\n", node);
+ ok(broken(node == (void*)0xdeadbeef) || (node == NULL), "got %p\n", node);
/* load schema and try to add it */
doc2 = create_document(&IID_IXMLDOMDocument2);
s = (void*)0xdeadbeef;
hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
EXPECT_HR(hr, E_FAIL);
- ok(s == (void*)0xdeadbeef, "got %p\n", s);
+ ok(broken(s == (void*)0xdeadbeef) || (s == NULL), "got %p\n", s);
/* enumerate */
enumv = (void*)0xdeadbeef;
HRESULT hr;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
memcpy(&buff[2], test_data, sizeof(test_data));
/* just a big length */
VARIANT schema;
HRESULT hr;
+ if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
+ if (!is_clsid_supported(&CLSID_XMLSchemaCache, &IID_IXMLDOMSchemaCollection)) return;
+
doc = create_document(&IID_IXMLDOMDocument2);
- if (!doc) return;
cache = create_cache(&IID_IXMLDOMSchemaCollection);
/* set to NULL iface when no schema is set */
"</xsl:template>"
"</xsl:stylesheet>";
+static const char omitxmldecl_xsl[] =
+"<?xml version=\"1.0\"?>"
+"<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
+"<xsl:output method=\"xml\" omit-xml-declaration=\"yes\"/>"
+"<xsl:template match=\"/\">"
+" <xsl:for-each select=\"/a/item\">"
+" <xsl:element name=\"node\">"
+" <xsl:value-of select=\"@name\"/>"
+" </xsl:element>"
+" </xsl:for-each>"
+"</xsl:template>"
+"</xsl:stylesheet>";
+
+static const char omitxmldecl_doc[] =
+"<?xml version=\"1.0\"?>"
+"<a>"
+" <item name=\"item1\"/>"
+" <item name=\"item2\"/>"
+"</a>";
+
static void test_xsltext(void)
{
IXMLDOMDocument *doc, *doc2;
BSTR ret;
doc = create_document(&IID_IXMLDOMDocument);
- if (!doc) return;
-
doc2 = create_document(&IID_IXMLDOMDocument);
hr = IXMLDOMDocument_loadXML(doc, _bstr_(xsltext_xsl), &b);
ok(!lstrcmpW(ret, _bstr_("testdata")), "transform result %s\n", wine_dbgstr_w(ret));
SysFreeString(ret);
+ /* omit-xml-declaration */
+ hr = IXMLDOMDocument_loadXML(doc, _bstr_(omitxmldecl_xsl), &b);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ hr = IXMLDOMDocument_loadXML(doc2, _bstr_(omitxmldecl_doc), &b);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ hr = IXMLDOMDocument_transformNode(doc2, (IXMLDOMNode*)doc, &ret);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ ok(!lstrcmpW(ret, _bstr_("<node>item1</node><node>item2</node>")), "transform result %s\n", wine_dbgstr_w(ret));
+ SysFreeString(ret);
+
IXMLDOMDocument_Release(doc2);
IXMLDOMDocument_Release(doc);
free_bstrs();
free_bstrs();
}
-START_TEST(domdoc)
+static void test_url(void)
{
IXMLDOMDocument *doc;
- IUnknown *unk;
+ HRESULT hr;
+ BSTR s;
+
+ doc = create_document(&IID_IXMLDOMDocument);
+
+ hr = IXMLDOMDocument_get_url(doc, NULL);
+ ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
+
+ s = (BSTR)0x1;
+ hr = IXMLDOMDocument_get_url(doc, &s);
+ ok(hr == S_FALSE, "got 0x%08x\n", hr);
+ ok(s == NULL, "got %s\n", wine_dbgstr_w(s));
+
+ IXMLDOMDocument_Release(doc);
+}
+
+START_TEST(domdoc)
+{
HRESULT hr;
hr = CoInitialize( NULL );
ok( hr == S_OK, "failed to init com\n");
if (hr != S_OK) return;
- hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc );
- if (hr != S_OK)
+ get_class_support_data(domdoc_support_data);
+ if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument))
{
- win_skip("IXMLDOMDocument is not available (0x%08x)\n", hr);
+ win_skip("DOMDocument2 is not supported. Skipping all tests.\n");
+ CoUninitialize();
return;
}
- IXMLDOMDocument_Release(doc);
-
test_domdoc();
test_persiststreaminit();
test_domnode();
test_putref_schemas();
test_namedmap_newenum();
test_xmlns_attribute();
+ test_url();
test_xsltemplate();
test_xsltext();
- hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
- &IID_IMXNamespaceManager, (void**)&unk);
- if (hr == S_OK)
+ if (is_clsid_supported(&CLSID_MXNamespaceManager40, &IID_IMXNamespaceManager))
{
test_mxnamespacemanager();
test_mxnamespacemanager_override();
-
- IUnknown_Release(unk);
}
- else
- win_skip("MXNamespaceManager is not available\n");
CoUninitialize();
}
#define COBJMACROS
#define CONST_VTABLE
-//#include <stdio.h>
+#include <stdio.h>
#include <assert.h>
#include <wine/test.h>
alloced_bstrs_count = 0;
}
-static void test_saxstr(const char *file, unsigned line, BSTR str, const char *expected, int todo, int *failcount)
+static void test_saxstr(const char *file, unsigned line, BSTR str, const char *expected, BOOL todo, int *failcount)
{
int len, lenexp, cmp;
WCHAR buf[1024];
}
static void compare_attributes(const struct call_entry *actual, const struct call_entry *expected, const char *context,
- int todo, const char *file, int line, int *failcount)
+ BOOL todo, const char *file, int line, int *failcount)
{
int i, lenexp = 0;
}
static void ok_sequence_(struct call_sequence **seq, int sequence_index,
- const struct call_entry *expected, const char *context, int todo,
+ const struct call_entry *expected, const char *context, BOOL todo,
const char *file, int line)
{
struct call_sequence *call_seq = seq[sequence_index];
{
if (expected->id == actual->id)
{
- /* always test position data */
- if (expected->line != actual->line && todo)
+ if (expected->line != -1)
{
- todo_wine
+ /* always test position data */
+ if (expected->line != actual->line && todo)
{
- failcount++;
- ok_(file, line) (FALSE,
+ 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);
}
}
- 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 != actual->column && todo)
+
+ if (expected->column != -1)
{
- todo_wine
+ if (expected->column != actual->column && todo)
{
- failcount++;
- ok_(file, line) (FALSE,
+ 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);
}
}
- 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)
{
{ CH_ENDTEST }
};
+static struct attribute_entry read_test_attrs[] = {
+ { "", "attr", "attr", "val" },
+ { NULL }
+};
+
+static struct call_entry read_test_seq[] = {
+ { CH_PUTDOCUMENTLOCATOR, -1, 0, S_OK },
+ { CH_STARTDOCUMENT, -1, -1, S_OK },
+ { CH_STARTELEMENT, -1, -1, S_OK, "", "rootelem", "rootelem" },
+ { CH_STARTELEMENT, -1, -1, S_OK, "", "elem", "elem", read_test_attrs },
+ { CH_CHARACTERS, -1, -1, S_OK, "text" },
+ { CH_ENDELEMENT, -1, -1, S_OK, "", "elem", "elem" },
+ { CH_STARTELEMENT, -1, -1, S_OK, "", "elem", "elem", read_test_attrs },
+ { CH_CHARACTERS, -1, -1, S_OK, "text" },
+ { CH_ENDELEMENT, -1, -1, S_OK, "", "elem", "elem" },
+ { CH_STARTELEMENT, -1, -1, S_OK, "", "elem", "elem", read_test_attrs },
+ { CH_CHARACTERS, -1, -1, S_OK, "text" },
+ { CH_ENDELEMENT, -1, -1, S_OK, "", "elem", "elem" },
+ { CH_STARTELEMENT, -1, -1, S_OK, "", "elem", "elem", read_test_attrs },
+ { CH_CHARACTERS, -1, -1, S_OK, "text" },
+ { CH_ENDELEMENT, -1, -1, S_OK, "", "elem", "elem" },
+ { CH_ENDELEMENT, -1, -1, S_OK, "", "rootelem", "rootelem" },
+ { CH_ENDDOCUMENT, -1, -1, S_OK},
+ { CH_ENDTEST }
+};
+
static const char xmlspace_attr[] =
"<?xml version=\"1.0\" encoding=\"UTF-16\"?>"
"<a xml:space=\"preserve\"> Some text data </a>";
ISAXLocator *pLocator)
{
struct call_entry call;
+ IUnknown *unk;
HRESULT hr;
locator = pLocator;
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, 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);
ok(index >= 0 && index <= 2, "invalid index received %d\n", index);
- *QName = attrqnamesW[index];
- *QNameLength = attrqnamelen[index];
+ if (index >= 0 && index <= 2) {
+ *QName = attrqnamesW[index];
+ *QNameLength = attrqnamelen[index];
+ } else {
+ *QName = NULL;
+ *QNameLength = 0;
+ }
return S_OK;
}
ok(index >= 0 && index <= 2, "invalid index received %d\n", index);
- *value = attrvaluesW[index];
- *nValue = attrvalueslen[index];
+ if (index >= 0 && index <= 2) {
+ *value = attrvaluesW[index];
+ *nValue = attrvalueslen[index];
+ } else {
+ *value = NULL;
+ *nValue = 0;
+ }
return S_OK;
}
static HRESULT WINAPI istream_Write(IStream *iface, const void *pv, ULONG cb, ULONG *pcbWritten)
{
- 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(0, "unexpected call\n");
+ return E_NOTIMPL;
}
static HRESULT WINAPI istream_Seek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin,
return E_NOTIMPL;
}
-static const IStreamVtbl StreamVtbl = {
+static HRESULT WINAPI mxstream_Write(IStream *iface, const void *pv, ULONG cb, ULONG *pcbWritten)
+{
+ 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;
+}
+
+static const IStreamVtbl mxstreamVtbl = {
istream_QueryInterface,
istream_AddRef,
istream_Release,
istream_Read,
+ mxstream_Write,
+ istream_Seek,
+ istream_SetSize,
+ istream_CopyTo,
+ istream_Commit,
+ istream_Revert,
+ istream_LockRegion,
+ istream_UnlockRegion,
+ istream_Stat,
+ istream_Clone
+};
+
+static IStream mxstream = { &mxstreamVtbl };
+
+static int read_cnt;
+
+static HRESULT WINAPI instream_Read(IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
+{
+ 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;
+}
+
+static const IStreamVtbl instreamVtbl = {
+ istream_QueryInterface,
+ istream_AddRef,
+ istream_Release,
+ instream_Read,
istream_Write,
istream_Seek,
istream_SetSize,
istream_Clone
};
-static IStream mxstream = { &StreamVtbl };
+static IStream instream = { &instreamVtbl };
static struct msxmlsupported_data_t reader_support_data[] =
{
static const CHAR testXmlA[] = "test.xml";
static const WCHAR testXmlW[] = {'t','e','s','t','.','x','m','l',0};
IXMLDOMDocument *doc;
+ char seqname[50];
VARIANT_BOOL v;
while (table->clsid)
IStream_Release(stream);
+ V_VT(&var) = VT_UNKNOWN;
+ V_UNKNOWN(&var) = (IUnknown*)&instream;
+
+ 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);
+
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = SysAllocString(carriage_ret_test);
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)stream;
- if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
+ if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60) ||
+ IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40))
test_seq = cdata_test_alt;
else
test_seq = cdata_test;
set_expected_seq(test_seq);
hr = ISAXXMLReader_parse(reader, var);
ok(hr == S_OK, "got 0x%08x\n", hr);
- ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "cdata test", TRUE);
+ 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;
- if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
+ if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60) ||
+ IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40))
test_seq = cdata_test2_alt;
else
test_seq = cdata_test2;
set_expected_seq(test_seq);
hr = ISAXXMLReader_parse(reader, var);
ok(hr == S_OK, "got 0x%08x\n", hr);
- ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "cdata test 2", TRUE);
+ sprintf(seqname, "%s: cdata test 2", table->name);
+ ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, seqname, TRUE);
IStream_Release(stream);
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)stream;
- if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
+ if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60) ||
+ IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40))
test_seq = cdata_test3_alt;
else
test_seq = cdata_test3;
set_expected_seq(test_seq);
hr = ISAXXMLReader_parse(reader, var);
ok(hr == S_OK, "got 0x%08x\n", hr);
- ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "cdata test 3", TRUE);
+ sprintf(seqname, "%s: cdata test 3", table->name);
+ ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, seqname, TRUE);
IStream_Release(stream);
ISAXXMLReader *reader;
HRESULT hr;
VARIANT v;
+ BSTR str;
hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
&IID_ISAXXMLReader, (void**)&reader);
while (ptr->prop_name)
{
+ VARIANT varref;
LONG ref;
init_saxlexicalhandler(&lexicalhandler, S_OK);
ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
ok(V_UNKNOWN(&v) == NULL, "got %p\n", V_UNKNOWN(&v));
+ /* VT_UNKNOWN */
V_VT(&v) = VT_UNKNOWN;
V_UNKNOWN(&v) = ptr->iface;
ref = get_refcount(ptr->iface);
EXPECT_HR(hr, S_OK);
ok(ref < get_refcount(ptr->iface), "expected inreased refcount\n");
+ /* VT_DISPATCH */
+ V_VT(&v) = VT_DISPATCH;
+ V_UNKNOWN(&v) = ptr->iface;
+ ref = get_refcount(ptr->iface);
+ hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
+ EXPECT_HR(hr, S_OK);
+ ok(ref == get_refcount(ptr->iface), "got wrong refcount %d, expected %d\n", get_refcount(ptr->iface), ref);
+
+ /* VT_VARIANT|VT_BYREF with VT_UNKNOWN in referenced variant */
+ V_VT(&varref) = VT_UNKNOWN;
+ V_UNKNOWN(&varref) = ptr->iface;
+
+ V_VT(&v) = VT_VARIANT|VT_BYREF;
+ V_VARIANTREF(&v) = &varref;
+ ref = get_refcount(ptr->iface);
+ hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
+ EXPECT_HR(hr, S_OK);
+ ok(ref == get_refcount(ptr->iface), "got wrong refcount %d, expected %d\n", get_refcount(ptr->iface), ref);
+
+ /* VT_VARIANT|VT_BYREF with VT_DISPATCH in referenced variant */
+ V_VT(&varref) = VT_DISPATCH;
+ V_UNKNOWN(&varref) = ptr->iface;
+
+ V_VT(&v) = VT_VARIANT|VT_BYREF;
+ V_VARIANTREF(&v) = &varref;
+ ref = get_refcount(ptr->iface);
+ hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
+ EXPECT_HR(hr, S_OK);
+ ok(ref == get_refcount(ptr->iface), "got wrong refcount %d, expected %d\n", get_refcount(ptr->iface), ref);
+
V_VT(&v) = VT_EMPTY;
V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
hr = ISAXXMLReader_parse(reader, v);
EXPECT_HR(hr, S_OK);
+ /* VT_BSTR|VT_BYREF input type */
+ str = _bstr_("<?xml version=\"1.0\"?><element></element>");
+ V_VT(&v) = VT_BSTR|VT_BYREF;
+ V_BSTRREF(&v) = &str;
+ hr = ISAXXMLReader_parse(reader, v);
+ EXPECT_HR(hr, S_OK);
+
V_VT(&v) = VT_EMPTY;
V_BSTR(&v) = (void*)0xdeadbeef;
hr = ISAXXMLReader_getProperty(reader, _bstr_("xmldecl-version"), &v);
const char *clsid;
const char *data;
HRESULT hr;
- int todo;
+ BOOL todo;
};
static const struct enc_test_entry_t encoding_test_data[] = {
- { &CLSID_SAXXMLReader, "CLSID_SAXXMLReader", UTF8BOMTest, 0xc00ce56f, 1 },
- { &CLSID_SAXXMLReader30, "CLSID_SAXXMLReader30", UTF8BOMTest, 0xc00ce56f, 1 },
- { &CLSID_SAXXMLReader40, "CLSID_SAXXMLReader40", UTF8BOMTest, S_OK, 0 },
- { &CLSID_SAXXMLReader60, "CLSID_SAXXMLReader60", UTF8BOMTest, S_OK, 0 },
+ { &CLSID_SAXXMLReader, "CLSID_SAXXMLReader", UTF8BOMTest, 0xc00ce56f, TRUE },
+ { &CLSID_SAXXMLReader30, "CLSID_SAXXMLReader30", UTF8BOMTest, 0xc00ce56f, TRUE },
+ { &CLSID_SAXXMLReader40, "CLSID_SAXXMLReader40", UTF8BOMTest, S_OK, FALSE },
+ { &CLSID_SAXXMLReader60, "CLSID_SAXXMLReader60", UTF8BOMTest, S_OK, FALSE },
{ 0 }
};
static void test_mxwriter_handlers(void)
{
- ISAXContentHandler *handler;
- IMXWriter *writer, *writer2;
- ISAXDeclHandler *decl;
- ISAXLexicalHandler *lh;
+ IMXWriter *writer;
HRESULT hr;
+ int i;
+
+ static const REFIID riids[] =
+ {
+ &IID_ISAXContentHandler,
+ &IID_ISAXLexicalHandler,
+ &IID_ISAXDeclHandler,
+ &IID_ISAXDTDHandler,
+ &IID_ISAXErrorHandler,
+ &IID_IVBSAXDeclHandler,
+ &IID_IVBSAXLexicalHandler,
+ &IID_IVBSAXContentHandler,
+ &IID_IVBSAXDTDHandler,
+ &IID_IVBSAXErrorHandler
+ };
hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
&IID_IMXWriter, (void**)&writer);
EXPECT_REF(writer, 1);
- /* ISAXContentHandler */
- hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&handler);
- ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
- EXPECT_REF(writer, 2);
- EXPECT_REF(handler, 2);
-
- hr = ISAXContentHandler_QueryInterface(handler, &IID_IMXWriter, (void**)&writer2);
- ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
- ok(writer2 == writer, "got %p, expected %p\n", writer2, writer);
- EXPECT_REF(writer, 3);
- EXPECT_REF(writer2, 3);
- IMXWriter_Release(writer2);
- ISAXContentHandler_Release(handler);
-
- /* ISAXLexicalHandler */
- hr = IMXWriter_QueryInterface(writer, &IID_ISAXLexicalHandler, (void**)&lh);
- ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
- EXPECT_REF(writer, 2);
- EXPECT_REF(lh, 2);
-
- hr = ISAXLexicalHandler_QueryInterface(lh, &IID_IMXWriter, (void**)&writer2);
- ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
- ok(writer2 == writer, "got %p, expected %p\n", writer2, writer);
- EXPECT_REF(writer, 3);
- EXPECT_REF(writer2, 3);
- IMXWriter_Release(writer2);
- ISAXLexicalHandler_Release(lh);
-
- /* ISAXDeclHandler */
- hr = IMXWriter_QueryInterface(writer, &IID_ISAXDeclHandler, (void**)&decl);
- ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
- EXPECT_REF(writer, 2);
- EXPECT_REF(lh, 2);
-
- hr = ISAXDeclHandler_QueryInterface(decl, &IID_IMXWriter, (void**)&writer2);
- ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
- ok(writer2 == writer, "got %p, expected %p\n", writer2, writer);
- EXPECT_REF(writer, 3);
- EXPECT_REF(writer2, 3);
- IMXWriter_Release(writer2);
- ISAXDeclHandler_Release(decl);
+ for (i = 0; i < sizeof(riids)/sizeof(REFIID); i++)
+ {
+ IUnknown *handler;
+ IMXWriter *writer2;
+
+ /* handler from IMXWriter */
+ hr = IMXWriter_QueryInterface(writer, riids[i], (void**)&handler);
+ ok(hr == S_OK, "%s, expected S_OK, got %08x\n", wine_dbgstr_guid(riids[i]), hr);
+ EXPECT_REF(writer, 2);
+ EXPECT_REF(handler, 2);
+
+ /* IMXWriter from a handler */
+ hr = IUnknown_QueryInterface(handler, &IID_IMXWriter, (void**)&writer2);
+ ok(hr == S_OK, "%s, expected S_OK, got %08x\n", wine_dbgstr_guid(riids[i]), hr);
+ ok(writer2 == writer, "got %p, expected %p\n", writer2, writer);
+ EXPECT_REF(writer, 3);
+ EXPECT_REF(writer2, 3);
+ IMXWriter_Release(writer2);
+ IUnknown_Release(handler);
+ }
IMXWriter_Release(writer);
}
-
static struct msxmlsupported_data_t mxwriter_support_data[] =
{
{ &CLSID_MXXMLWriter, "MXXMLWriter" },
if (table->type & StartElement)
{
- hr = ISAXContentHandler_startElement(content, _bstr_(table->uri), lstrlen(table->uri),
- _bstr_(table->local_name), lstrlen(table->local_name), _bstr_(table->qname), lstrlen(table->qname), table->attr);
+ hr = ISAXContentHandler_startElement(content, _bstr_(table->uri), table->uri ? strlen(table->uri) : 0,
+ _bstr_(table->local_name), table->local_name ? strlen(table->local_name) : 0, _bstr_(table->qname),
+ table->qname ? strlen(table->qname) : 0, table->attr);
ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
}
if (table->type & EndElement)
{
- hr = ISAXContentHandler_endElement(content, _bstr_(table->uri), lstrlen(table->uri),
- _bstr_(table->local_name), lstrlen(table->local_name), _bstr_(table->qname), lstrlen(table->qname));
+ hr = ISAXContentHandler_endElement(content, _bstr_(table->uri), table->uri ? strlen(table->uri) : 0,
+ _bstr_(table->local_name), table->local_name ? strlen(table->local_name) : 0, _bstr_(table->qname),
+ table->qname ? strlen(table->qname) : 0);
ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
}
static void test_obj_dispex(IUnknown *obj)
{
+ static const WCHAR testW[] = {'t','e','s','t','p','r','o','p',0};
static const WCHAR starW[] = {'*',0};
DISPID dispid = DISPID_SAX_XMLREADER_GETFEATURE;
IDispatchEx *dispex;
UINT ticnt;
HRESULT hr;
BSTR name;
+ DISPID did;
hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
EXPECT_HR(hr, S_OK);
hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_SAX_XMLREADER_GETFEATURE, &dispid);
EXPECT_HR(hr, E_NOTIMPL);
+ unk = (IUnknown*)0xdeadbeef;
hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
EXPECT_HR(hr, E_NOTIMPL);
- if (hr == S_OK && unk) IUnknown_Release(unk);
+ ok(unk == (IUnknown*)0xdeadbeef, "got %p\n", unk);
+
+ name = SysAllocString(testW);
+ hr = IDispatchEx_GetDispID(dispex, name, fdexNameEnsure, &did);
+ ok(hr == DISP_E_UNKNOWNNAME, "got 0x%08x\n", hr);
+ SysFreeString(name);
IDispatchEx_Release(dispex);
}
-static void test_dispex(void)
+static void test_saxreader_dispex(void)
{
- IVBSAXXMLReader *vbreader;
- ISAXXMLReader *reader;
- IUnknown *unk;
- HRESULT hr;
+ IVBSAXXMLReader *vbreader;
+ ISAXXMLReader *reader;
+ DISPPARAMS dispparams;
+ DISPID dispid;
+ IUnknown *unk;
+ VARIANT arg;
+ HRESULT hr;
- hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
+ hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
&IID_ISAXXMLReader, (void**)&reader);
- EXPECT_HR(hr, S_OK);
-
- hr = ISAXXMLReader_QueryInterface(reader, &IID_IUnknown, (void**)&unk);
- EXPECT_HR(hr, S_OK);
- test_obj_dispex(unk);
- IUnknown_Release(unk);
-
- hr = ISAXXMLReader_QueryInterface(reader, &IID_IVBSAXXMLReader, (void**)&vbreader);
- EXPECT_HR(hr, S_OK);
- hr = IVBSAXXMLReader_QueryInterface(vbreader, &IID_IUnknown, (void**)&unk);
- EXPECT_HR(hr, S_OK);
- test_obj_dispex(unk);
- IUnknown_Release(unk);
- IVBSAXXMLReader_Release(vbreader);
-
- ISAXXMLReader_Release(reader);
+ EXPECT_HR(hr, S_OK);
+
+ hr = ISAXXMLReader_QueryInterface(reader, &IID_IUnknown, (void**)&unk);
+ EXPECT_HR(hr, S_OK);
+ test_obj_dispex(unk);
+ IUnknown_Release(unk);
+
+ hr = ISAXXMLReader_QueryInterface(reader, &IID_IVBSAXXMLReader, (void**)&vbreader);
+ EXPECT_HR(hr, S_OK);
+ hr = IVBSAXXMLReader_QueryInterface(vbreader, &IID_IUnknown, (void**)&unk);
+ EXPECT_HR(hr, S_OK);
+ test_obj_dispex(unk);
+ IUnknown_Release(unk);
+
+ dispid = DISPID_PROPERTYPUT;
+ dispparams.cArgs = 1;
+ dispparams.cNamedArgs = 1;
+ dispparams.rgdispidNamedArgs = &dispid;
+ dispparams.rgvarg = &arg;
+
+ V_VT(&arg) = VT_DISPATCH;
+ V_DISPATCH(&arg) = NULL;
+
+ /* propputref is callable as PROPERTYPUT and PROPERTYPUTREF */
+ hr = IVBSAXXMLReader_Invoke(vbreader,
+ DISPID_SAX_XMLREADER_CONTENTHANDLER,
+ &IID_NULL,
+ 0,
+ DISPATCH_PROPERTYPUT,
+ &dispparams,
+ NULL,
+ NULL,
+ NULL);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ hr = IVBSAXXMLReader_Invoke(vbreader,
+ DISPID_SAX_XMLREADER_CONTENTHANDLER,
+ &IID_NULL,
+ 0,
+ DISPATCH_PROPERTYPUTREF,
+ &dispparams,
+ NULL,
+ NULL,
+ NULL);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ IVBSAXXMLReader_Release(vbreader);
+ ISAXXMLReader_Release(reader);
+
+ if (is_clsid_supported(&CLSID_SAXXMLReader60, reader_support_data))
+ {
+ hr = CoCreateInstance(&CLSID_SAXXMLReader60, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&unk);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ test_obj_dispex(unk);
+ IUnknown_Release(unk);
+ }
}
static void test_mxwriter_dispex(void)
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);
+ }
}
static void test_mxwriter_comment(void)
{
static const WCHAR commentW[] = {'c','o','m','m','e','n','t',0};
+ IVBSAXLexicalHandler *vblexical;
ISAXContentHandler *content;
ISAXLexicalHandler *lexical;
IMXWriter *writer;
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 = 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);
ISAXContentHandler_Release(content);
ISAXLexicalHandler_Release(lexical);
+ IVBSAXLexicalHandler_Release(vblexical);
IMXWriter_Release(writer);
free_bstrs();
}
static void test_mxwriter_cdata(void)
{
+ IVBSAXLexicalHandler *vblexical;
ISAXContentHandler *content;
ISAXLexicalHandler *lexical;
IMXWriter *writer;
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);
ok(!lstrcmpW(_bstr_("<![CDATA["), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
VariantClear(&dest);
- hr = ISAXLexicalHandler_startCDATA(lexical);
+ hr = IVBSAXLexicalHandler_startCDATA(vblexical);
EXPECT_HR(hr, S_OK);
/* all these are escaped for text nodes */
ISAXContentHandler_Release(content);
ISAXLexicalHandler_Release(lexical);
+ IVBSAXLexicalHandler_Release(vblexical);
IMXWriter_Release(writer);
free_bstrs();
}
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;
IMXWriter *writer;
VARIANT dest;
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 = 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, sizeof(pubW)/sizeof(WCHAR), NULL, 0);
EXPECT_HR(hr, E_INVALIDARG);
hr = ISAXLexicalHandler_endDTD(lexical);
EXPECT_HR(hr, S_OK);
- hr = ISAXLexicalHandler_endDTD(lexical);
+ hr = IVBSAXLexicalHandler_endDTD(vblexical);
EXPECT_HR(hr, S_OK);
V_VT(&dest) = VT_EMPTY;
hr = ISAXDeclHandler_elementDecl(decl, NULL, 0, NULL, 0);
EXPECT_HR(hr, E_INVALIDARG);
+ hr = IVBSAXDeclHandler_elementDecl(vbdecl, NULL, NULL);
+ EXPECT_HR(hr, E_POINTER);
+
hr = ISAXDeclHandler_elementDecl(decl, nameW, sizeof(nameW)/sizeof(WCHAR), NULL, 0);
EXPECT_HR(hr, E_INVALIDARG);
hr = ISAXDeclHandler_internalEntityDecl(decl, NULL, 0, NULL, 0);
EXPECT_HR(hr, E_INVALIDARG);
+ hr = IVBSAXDeclHandler_internalEntityDecl(vbdecl, NULL, NULL);
+ EXPECT_HR(hr, E_POINTER);
+
hr = ISAXDeclHandler_internalEntityDecl(decl, _bstr_("name"), -1, NULL, 0);
EXPECT_HR(hr, E_INVALIDARG);
hr = ISAXDeclHandler_externalEntityDecl(decl, NULL, 0, NULL, 0, NULL, 0);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
+ hr = IVBSAXDeclHandler_externalEntityDecl(vbdecl, NULL, NULL, NULL);
+ ok(hr == E_POINTER, "got 0x%08x\n", hr);
+
hr = ISAXDeclHandler_externalEntityDecl(decl, _bstr_("name"), -1, NULL, 0, NULL, 0);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
ISAXContentHandler_Release(content);
ISAXLexicalHandler_Release(lexical);
+ IVBSAXLexicalHandler_Release(vblexical);
+ IVBSAXDeclHandler_Release(vbdecl);
ISAXDeclHandler_Release(decl);
IMXWriter_Release(writer);
free_bstrs();
EXPECT_HR(hr, E_INVALIDARG);
hr = ISAXAttributes_getValue(saxattr, 0, NULL, &len);
- EXPECT_HR(hr, E_INVALIDARG);
+ ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = ISAXAttributes_getValue(saxattr, 0, &value, NULL);
- EXPECT_HR(hr, E_INVALIDARG);
+ ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = ISAXAttributes_getValue(saxattr, 0, NULL, NULL);
- EXPECT_HR(hr, E_INVALIDARG);
+ 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);
- EXPECT_HR(hr, E_INVALIDARG);
+ ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = ISAXAttributes_getType(saxattr, 0, &value, NULL);
- EXPECT_HR(hr, E_INVALIDARG);
+ ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = ISAXAttributes_getType(saxattr, 0, NULL, NULL);
- EXPECT_HR(hr, E_INVALIDARG);
+ 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));
IsEqualGUID(table->clsid, &CLSID_SAXAttributes60))
{
hr = ISAXAttributes_getValueFromQName(saxattr, NULL, 0, NULL, NULL);
- EXPECT_HR(hr, E_INVALIDARG);
+ ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, NULL, NULL);
- EXPECT_HR(hr, E_INVALIDARG);
+ ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, &value, NULL);
- EXPECT_HR(hr, E_INVALIDARG);
+ ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = ISAXAttributes_getValueFromName(saxattr, NULL, 0, NULL, 0, NULL, NULL);
- EXPECT_HR(hr, E_INVALIDARG);
+ 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);
- EXPECT_HR(hr, E_INVALIDARG);
+ 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);
- EXPECT_HR(hr, E_INVALIDARG);
+ ok(hr == E_POINTER /* win8 */ || hr == E_INVALIDARG, "got 0x%08x\n", hr);
}
else
{
test_saxreader_properties();
test_saxreader_features();
test_saxreader_encoding();
- test_dispex();
+ test_saxreader_dispex();
/* MXXMLWriter tests */
get_class_support_data(mxwriter_support_data, &IID_IMXWriter);