ReactOS 0.4.16-dev-1007-g2e85425
Classes | Macros | Typedefs | Functions | Variables
domdoc.c File Reference
#include <stdio.h>
#include <assert.h>
#include "windows.h"
#include "msxml.h"
#include "msxml2.h"
#include "msxml2did.h"
#include "ole2.h"
#include "dispex.h"
#include "objsafe.h"
#include "mshtml.h"
#include "initguid.h"
#include "asptlb.h"
#include "wine/heap.h"
#include "wine/test.h"
Include dependency graph for domdoc.c:

Go to the source code of this file.

Classes

struct  msxmlsupported_data_t
 
struct  dispevent
 
struct  docload_ret_t
 
struct  leading_spaces_t
 
struct  refcount_test_t
 
struct  queryresult_t
 
struct  whitespace_t
 
struct  selection_ns_t
 
struct  xpath_test_t
 
struct  put_datatype_t
 
struct  put_datatype_notype_t
 
struct  namespaces_change_t
 
struct  _nodetypedvalue_t
 
struct  _property_test_t
 
struct  xslpattern_test_t
 
struct  ns_item_t
 
struct  node_type_t
 
struct  _get_node_typestring_t
 
struct  _get_attributes_t
 
struct  supporterror_t
 
struct  node_value_t
 
struct  attrtest_t
 
struct  _namespace_as_attribute_t
 

Macros

#define COBJMACROS
 
#define CONST_VTABLE
 
#define EXPECT_CHILDREN(node)   _expect_children((IXMLDOMNode*)node, __LINE__)
 
#define EXPECT_NO_CHILDREN(node)   _expect_no_children((IXMLDOMNode*)node, __LINE__)
 
#define EXPECT_REF(node, ref)   _expect_ref((IUnknown*)node, ref, __LINE__)
 
#define EXPECT_LIST_LEN(list, len)   _expect_list_len(list, len, __LINE__)
 
#define EXPECT_HR(hr, hr_exp)    ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
 
#define DECL_WIN_1252   "<?xml version=\"1.0\" encoding=\"Windows-1252\"?>"
 
#define SZ_EMAIL_DTD
 
#define expect_bstr_eq_and_free(bstr, expect)
 
#define expect_eq(expr, value, type, format)   { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
 
#define ole_check(expr)
 
#define ole_expect(expr, expect)
 
#define double_eq(x, y)   ok((x)-(y)<=1e-14*(x) && (x)-(y)>=-1e-14*(x), "expected %.16g, got %.16g\n", x, y)
 
#define _create(cls)   cls, #cls
 
#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_xsltemplate(iid)   _create_object(&_create(CLSID_XSLTemplate), iid, __LINE__)
 
#define expect_node(node, expstr)   { char str[4096]; node_to_string(node, str); ok(strcmp(str, expstr)==0, "Invalid node: %s, expected %s\n", str, expstr); }
 
#define expect_list_and_release(list, expstr)   { char *str = list_to_string(list); ok(strcmp(str, expstr)==0, "Invalid node list: %s, expected %s\n", str, expstr); if (list) IXMLDOMNodeList_Release(list); }
 
#define test_IObjectSafety_set(p, r, r2, s, m, e, e2)   _test_IObjectSafety_set(__LINE__,p, r, r2, s, m, e, e2)
 
#define test_IObjectSafety_common(s)   _test_IObjectSafety_common(__LINE__,s)
 
#define helper_ole_check(expr)
 
#define helper_ole_check_ver(expr)
 
#define helper_expect_list_and_release(list, expstr)
 
#define helper_expect_bstr_and_release(bstr, str)
 
#define check_ws_ignored(ver, doc, str)   _check_ws_ignored(__LINE__, ver, doc, str)
 
#define check_ws_preserved(ver, doc, str)   _check_ws_preserved(__LINE__, ver, doc, str)
 
#define check_default_props(doc)   _check_default_props(__LINE__, doc)
 
#define check_set_props(doc)   _check_set_props(__LINE__, doc)
 
#define set_props(doc, cache)   _set_props(__LINE__, doc, cache)
 
#define unset_props(doc)   _unset_props(__LINE__, doc)
 

Typedefs

typedef struct _nodetypedvalue_t nodetypedvalue_t
 
typedef struct _property_test_t property_test_t
 
typedef struct _get_node_typestring_t get_node_typestring_t
 
typedef struct _get_attributes_t get_attributes_t
 
typedef struct _namespace_as_attribute_t namespace_as_attribute_t
 

Functions

 DEFINE_GUID (GUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 
 DEFINE_GUID (IID_transformdest_unknown, 0xf5078f3a, 0xc551, 0x11d3, 0x89, 0xb9, 0x00, 0x00, 0xf8, 0x1f, 0xe2, 0x21)
 
static const char * debugstr_msxml_guid (REFIID riid)
 
static void get_class_support_data (struct msxmlsupported_data_t *table)
 
static BOOL is_clsid_supported (const GUID *clsid, REFIID riid)
 
static dispevent * impl_from_IDispatch (IDispatch *iface)
 
static HRESULT WINAPI dispevent_QueryInterface (IDispatch *iface, REFIID riid, void **ppvObject)
 
static ULONG WINAPI dispevent_AddRef (IDispatch *iface)
 
static ULONG WINAPI dispevent_Release (IDispatch *iface)
 
static HRESULT WINAPI dispevent_GetTypeInfoCount (IDispatch *iface, UINT *pctinfo)
 
static HRESULT WINAPI dispevent_GetTypeInfo (IDispatch *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 
static HRESULT WINAPI dispevent_GetIDsOfNames (IDispatch *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 
static HRESULT WINAPI dispevent_Invoke (IDispatch *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepInfo, UINT *argErr)
 
static IDispatch * create_dispevent (void)
 
static HRESULT WINAPI istream_QueryInterface (IStream *iface, REFIID riid, void **ppvObject)
 
static ULONG WINAPI istream_AddRef (IStream *iface)
 
static ULONG WINAPI istream_Release (IStream *iface)
 
static HRESULT WINAPI istream_Read (IStream *iface, void *ptr, ULONG len, ULONG *pread)
 
static HRESULT WINAPI istream_Write (IStream *iface, const void *ptr, ULONG len, ULONG *written)
 
static HRESULT WINAPI istream_Seek (IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
 
static HRESULT WINAPI istream_SetSize (IStream *iface, ULARGE_INTEGER size)
 
static HRESULT WINAPI istream_CopyTo (IStream *iface, IStream *stream, ULARGE_INTEGER len, ULARGE_INTEGER *pread, ULARGE_INTEGER *written)
 
static HRESULT WINAPI istream_Commit (IStream *iface, DWORD flags)
 
static HRESULT WINAPI istream_Revert (IStream *iface)
 
static HRESULT WINAPI istream_LockRegion (IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER len, DWORD locktype)
 
static HRESULT WINAPI istream_UnlockRegion (IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER len, DWORD locktype)
 
static HRESULT WINAPI istream_Stat (IStream *iface, STATSTG *pstatstg, DWORD flag)
 
static HRESULT WINAPI istream_Clone (IStream *iface, IStream **stream)
 
static HRESULT WINAPI response_QI (IResponse *iface, REFIID riid, void **obj)
 
static ULONG WINAPI response_AddRef (IResponse *iface)
 
static ULONG WINAPI response_Release (IResponse *iface)
 
static HRESULT WINAPI response_GetTypeInfoCount (IResponse *iface, UINT *count)
 
static HRESULT WINAPI response_GetTypeInfo (IResponse *iface, UINT ti, LCID lcid, ITypeInfo **tinfo)
 
static HRESULT WINAPI response_GetIDsOfNames (IResponse *iface, REFIID riid, LPOLESTR *names, UINT cnames, LCID lcid, DISPID *rgDispId)
 
static HRESULT WINAPI response_Invoke (IResponse *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *ei, UINT *argerr)
 
static HRESULT WINAPI response_get_Buffer (IResponse *iface, VARIANT_BOOL *fIsBuffering)
 
static HRESULT WINAPI response_put_Buffer (IResponse *iface, VARIANT_BOOL fIsBuffering)
 
static HRESULT WINAPI response_get_ContentType (IResponse *iface, BSTR *pbstrContentTypeRet)
 
static HRESULT WINAPI response_put_ContentType (IResponse *iface, BSTR bstrContentType)
 
static HRESULT WINAPI response_get_Expires (IResponse *iface, VARIANT *pvarExpiresMinutesRet)
 
static HRESULT WINAPI response_put_Expires (IResponse *iface, LONG lExpiresMinutes)
 
static HRESULT WINAPI response_get_ExpiresAbsolute (IResponse *iface, VARIANT *pvarExpiresRet)
 
static HRESULT WINAPI response_put_ExpiresAbsolute (IResponse *iface, DATE dtExpires)
 
static HRESULT WINAPI response_get_Cookies (IResponse *iface, IRequestDictionary **ppCookies)
 
static HRESULT WINAPI response_get_Status (IResponse *iface, BSTR *pbstrStatusRet)
 
static HRESULT WINAPI response_put_Status (IResponse *iface, BSTR bstrStatus)
 
static HRESULT WINAPI response_Add (IResponse *iface, BSTR bstrHeaderValue, BSTR bstrHeaderName)
 
static HRESULT WINAPI response_AddHeader (IResponse *iface, BSTR bstrHeaderName, BSTR bstrHeaderValue)
 
static HRESULT WINAPI response_AppendToLog (IResponse *iface, BSTR bstrLogEntry)
 
static HRESULT WINAPI response_BinaryWrite (IResponse *iface, VARIANT input)
 
static HRESULT WINAPI response_Clear (IResponse *iface)
 
static HRESULT WINAPI response_End (IResponse *iface)
 
static HRESULT WINAPI response_Flush (IResponse *iface)
 
static HRESULT WINAPI response_Redirect (IResponse *iface, BSTR bstrURL)
 
static HRESULT WINAPI response_Write (IResponse *iface, VARIANT varText)
 
static HRESULT WINAPI response_WriteBlock (IResponse *iface, short iBlockNumber)
 
static HRESULT WINAPI response_IsClientConnected (IResponse *iface, VARIANT_BOOL *pfIsClientConnected)
 
static HRESULT WINAPI response_get_CharSet (IResponse *iface, BSTR *pbstrCharSetRet)
 
static HRESULT WINAPI response_put_CharSet (IResponse *iface, BSTR bstrCharSet)
 
static HRESULT WINAPI response_Pics (IResponse *iface, BSTR bstrHeaderValue)
 
static HRESULT WINAPI response_get_CacheControl (IResponse *iface, BSTR *pbstrCacheControl)
 
static HRESULT WINAPI response_put_CacheControl (IResponse *iface, BSTR bstrCacheControl)
 
static HRESULT WINAPI response_get_CodePage (IResponse *iface, LONG *plvar)
 
static HRESULT WINAPI response_put_CodePage (IResponse *iface, LONG codepage)
 
static HRESULT WINAPI response_get_LCID (IResponse *iface, LONG *lcid)
 
static HRESULT WINAPI response_put_LCID (IResponse *iface, LONG lcid)
 
static void _expect_children (IXMLDOMNode *node, int line)
 
static void _expect_no_children (IXMLDOMNode *node, int line)
 
static void _expect_ref (IUnknown *obj, ULONG ref, int line)
 
static void _expect_list_len (IXMLDOMNodeList *list, LONG len, int line)
 
static void * _create_object (const GUID *clsid, const char *name, const IID *iid, int line)
 
static BSTR alloc_str_from_narrow (const char *str)
 
static BSTR _bstr_ (const char *str)
 
static void free_bstrs (void)
 
static VARIANT _variantbstr_ (const char *str)
 
static BOOL compareIgnoreReturns (BSTR sLeft, BSTR sRight)
 
static void get_str_for_type (DOMNodeType type, char *buf)
 
static int get_node_position (IXMLDOMNode *node)
 
static void node_to_string (IXMLDOMNode *node, char *buf)
 
static char * list_to_string (IXMLDOMNodeList *list)
 
static void test_domdoc (void)
 
static void test_persiststream (void)
 
static void test_domnode (void)
 
static void test_refs (void)
 
static void test_create (void)
 
static void test_getElementsByTagName (void)
 
static void test_get_text (void)
 
static void test_get_childNodes (void)
 
static void test_get_firstChild (void)
 
static void test_get_lastChild (void)
 
static void test_removeChild (void)
 
static void test_replaceChild (void)
 
static void test_removeNamedItem (void)
 
static void _test_IObjectSafety_set (unsigned line, IObjectSafety *safety, HRESULT result, HRESULT result2, DWORD set, DWORD mask, DWORD expected, DWORD expected2)
 
static void _test_IObjectSafety_common (unsigned line, IObjectSafety *safety)
 
static void test_IXMLDOMDocument2 (void)
 
static void _check_ws_ignored (int line, const char *ver, IXMLDOMDocument2 *doc, char const *str)
 
static void _check_ws_preserved (int line, const char *ver, IXMLDOMDocument2 *doc, char const *str)
 
static void test_preserve_charref (IXMLDOMDocument2 *doc, VARIANT_BOOL preserve)
 
static void test_whitespace (void)
 
static void test_XPath (void)
 
static void test_cloneNode (void)
 
static void test_xmlTypes (void)
 
static void test_put_dataType (void)
 
static void test_save (void)
 
static void test_testTransforms (void)
 
static void test_namespaces_change (void)
 
static void test_namespaces_basic (void)
 
static void test_FormattingXML (void)
 
static void test_nodeTypedValue (void)
 
static void test_TransformWithLoadingLocalFile (void)
 
static void test_put_nodeValue (void)
 
static void test_IObjectSafety (void)
 
static void test_default_properties (void)
 
static void test_XSLPattern (void)
 
static void test_splitText (void)
 
static void test_getQualifiedItem (void)
 
static void test_removeQualifiedItem (void)
 
static void _check_default_props (int line, IXMLDOMDocument2 *doc)
 
static void _check_set_props (int line, IXMLDOMDocument2 *doc)
 
static void _set_props (int line, IXMLDOMDocument2 *doc, IXMLDOMSchemaCollection *cache)
 
static void _unset_props (int line, IXMLDOMDocument2 *doc)
 
static void test_get_ownerDocument (void)
 
static void test_setAttributeNode (void)
 
static void test_createNode (void)
 
static void test_get_prefix (void)
 
static void test_selectSingleNode (void)
 
static void test_events (void)
 
static void test_createProcessingInstruction (void)
 
static void test_put_nodeTypedValue (void)
 
static void test_get_xml (void)
 
static void test_xsltemplate (void)
 
static void test_insertBefore (void)
 
static void test_appendChild (void)
 
static void test_get_doctype (void)
 
static void test_get_tagName (void)
 
static void test_get_dataType (void)
 
static void test_get_nodeTypeString (void)
 
static void test_get_attributes (void)
 
static void test_selection (void)
 
static void write_to_file (const char *name, const char *data)
 
static void test_doc_load_from_path (IXMLDOMDocument *doc, const char *path)
 
static void url_forward_slash (char *url)
 
static void test_load (void)
 
static void test_domobj_dispex (IUnknown *obj)
 
static void test_mxnamespacemanager (void)
 
static void test_mxnamespacemanager_override (void)
 
static void test_dispex (void)
 
static void test_parseerror (void)
 
static void test_getAttributeNode (void)
 
static void test_getAttribute (void)
 
static void test_supporterrorinfo (void)
 
static void test_nodeValue (void)
 
static void test_xmlns_attribute (void)
 
static void test_get_namespaces (void)
 
static void test_put_data (void)
 
static void test_newline_normalization (void)
 
static void test_putref_schemas (void)
 
static void test_namedmap_newenum (void)
 
static void test_xsltext (void)
 
static void test_create_attribute (void)
 
static void test_url (void)
 
static void test_merging_text (void)
 
static HRESULT WINAPI transformdest_QueryInterface (IUnknown *iface, REFIID riid, void **obj)
 
static ULONG WINAPI transformdest_AddRef (IUnknown *iface)
 
static ULONG WINAPI transformdest_Release (IUnknown *iface)
 
static void test_transformNodeToObject (void)
 
static void test_normalize_attribute_values (void)
 
static void test_namespaces_as_attributes (void)
 
 START_TEST (domdoc)
 

Variables

static int g_unexpectedcall
 
static int g_expectedcall
 
static struct msxmlsupported_data_t domdoc_support_data []
 
static const IDispatchVtbl dispeventVtbl
 
static const IStreamVtbl StreamVtbl
 
static IStream savestream = { &StreamVtbl }
 
static const IResponseVtbl testresponsevtbl
 
static IResponse testresponse = { &testresponsevtbl }
 
static const WCHAR szEmpty [] = { 0 }
 
static const WCHAR szIncomplete []
 
static const WCHAR szComplete1 []
 
static const WCHAR szComplete2 []
 
static const char complete4A []
 
static const WCHAR szComplete5 []
 
static const WCHAR szComplete6 []
 
static const char complete7 []
 
static const char win1252xml []
 
static const char win1252decl []
 
static const char nocontent [] = "no xml content here"
 
static const char szExampleXML []
 
static const char charrefsxml []
 
static const CHAR szNodeTypesXML []
 
static const CHAR szTransformXML []
 
static const CHAR szTransformSSXML []
 
static const CHAR szTransformOutput []
 
static const CHAR szTypeValueXML []
 
static const CHAR szBasicTransformSSXMLPart1 []
 
static const CHAR szBasicTransformSSXMLPart2 []
 
static const CHAR szBasicTransformXML []
 
static const CHAR szBasicTransformOutput []
 
static const CHAR szEmailXML []
 
static const CHAR szEmailXML_0D []
 
static const CHAR szEmailXML_0E []
 
static const CHAR szEmailXML_11 []
 
static const CHAR szEmailXML_13 []
 
static const CHAR szEmailXML_14 []
 
static const CHAR szEmailXML_15 []
 
static const CHAR szEmailXML_16 []
 
static const CHAR szEmailXML_17 []
 
static const CHAR szEmailXML_18 []
 
static const CHAR szEmailXML_20 []
 
static const char xpath_simple_list []
 
static const char default_ns_doc []
 
static const char attributes_map []
 
static const WCHAR nonexistent_fileW []
 
static const WCHAR nonexistent_attrW []
 
static const WCHAR szDocument []
 
static const WCHAR szOpen [] = { 'o','p','e','n',0 }
 
static const WCHAR szdl [] = { 'd','l',0 }
 
static const WCHAR szvr [] = { 'v','r',0 }
 
static const WCHAR szlc [] = { 'l','c',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 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 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 []
 
static const WCHAR szElementXML4 []
 
static const WCHAR szAttribute [] = {'A','t','t','r',0 }
 
static const WCHAR szAttributeXML [] = {'A','t','t','r','=','"','"',0 }
 
static const WCHAR szCData []
 
static const WCHAR szCDataXML []
 
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}
 
static BSTR alloced_bstrs [256]
 
static int alloced_bstrs_count
 
static const struct leading_spaces_t leading_spaces_classdata []
 
static const char * leading_spaces_xmldata []
 
static const refcount_test_t refcount_test []
 
static const struct queryresult_t elementsbytagname []
 
static const struct whitespace_t whitespace_test_data []
 
static const selection_ns_t selection_ns_data []
 
static const xpath_test_t xpath_test []
 
static put_datatype_t put_datatype_data []
 
static put_datatype_notype_t put_dt_notype []
 
static const struct namespaces_change_t namespaces_change_test_data []
 
static const nodetypedvalue_t get_nodetypedvalue []
 
static const property_test_t properties_test_data []
 
static const xslpattern_test_t xslpattern_test []
 
static const xslpattern_test_t xslpattern_test_no_ns []
 
static const xslpattern_test_t xslpattern_test_func []
 
static const ns_item_t qualified_item_tests []
 
static const ns_item_t named_item_tests []
 
static const char get_prefix_doc []
 
static const node_type_t get_datatype []
 
static const get_node_typestring_t get_node_typestring []
 
static const get_attributes_t get_attributes []
 
static const DOMNodeType nodetypes_test []
 
static const supporterror_t supporterror_test []
 
static const node_value_t nodevalue_test []
 
static const char namespacesA []
 
static const char xsd_schema1_uri [] = "x-schema:test1.xsd"
 
static const char xsd_schema1_xml []
 
static const DOMNodeType put_data_types []
 
static const char xsltext_xsl []
 
static const char omitxmldecl_xsl []
 
static const char omitxmldecl_doc []
 
static struct attrtest_t attrtests []
 
static const IUnknownVtbl transformdestvtbl
 
static const namespace_as_attribute_t namespace_as_attribute_test_data []
 

Macro Definition Documentation

◆ _create

#define _create (   cls)    cls, #cls

Definition at line 1226 of file domdoc.c.

◆ check_default_props

#define check_default_props (   doc)    _check_default_props(__LINE__, doc)

Definition at line 7833 of file domdoc.c.

◆ check_set_props

#define check_set_props (   doc)    _check_set_props(__LINE__, doc)

Definition at line 7857 of file domdoc.c.

◆ check_ws_ignored

#define check_ws_ignored (   ver,
  doc,
  str 
)    _check_ws_ignored(__LINE__, ver, doc, str)

Definition at line 4517 of file domdoc.c.

◆ check_ws_preserved

#define check_ws_preserved (   ver,
  doc,
  str 
)    _check_ws_preserved(__LINE__, ver, doc, str)

Definition at line 4555 of file domdoc.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 25 of file domdoc.c.

◆ CONST_VTABLE

#define CONST_VTABLE

Definition at line 26 of file domdoc.c.

◆ create_cache

#define create_cache (   iid)    _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)

Definition at line 1230 of file domdoc.c.

◆ create_document

#define create_document (   iid)    _create_object(&_create(CLSID_DOMDocument2), iid, __LINE__)

Definition at line 1228 of file domdoc.c.

◆ create_document_version

#define create_document_version (   v,
  iid 
)    _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)

Definition at line 1229 of file domdoc.c.

◆ create_xsltemplate

#define create_xsltemplate (   iid)    _create_object(&_create(CLSID_XSLTemplate), iid, __LINE__)

Definition at line 1231 of file domdoc.c.

◆ DECL_WIN_1252

#define DECL_WIN_1252   "<?xml version=\"1.0\" encoding=\"Windows-1252\"?>"

Definition at line 769 of file domdoc.c.

◆ double_eq

#define double_eq (   x,
  y 
)    ok((x)-(y)<=1e-14*(x) && (x)-(y)>=-1e-14*(x), "expected %.16g, got %.16g\n", x, y)

Definition at line 1213 of file domdoc.c.

◆ expect_bstr_eq_and_free

#define expect_bstr_eq_and_free (   bstr,
  expect 
)
Value:
{ \
BSTR bstrExp = alloc_str_from_narrow(expect); \
ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
SysFreeString(bstr); \
SysFreeString(bstrExp); \
}
expect
#define expect(EXPECTED, GOT)
Definition: SystemMenu.c:483
BSTR
OLECHAR * BSTR
Definition: compat.h:2293
lstrcmpW
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4243
alloc_str_from_narrow
static BSTR alloc_str_from_narrow(const char *str)
Definition: domdoc.c:1233

Definition at line 1194 of file domdoc.c.

◆ EXPECT_CHILDREN

#define EXPECT_CHILDREN (   node)    _expect_children((IXMLDOMNode*)node, __LINE__)

Definition at line 655 of file domdoc.c.

◆ expect_eq

#define expect_eq (   expr,
  value,
  type,
  format 
)    { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }

Definition at line 1201 of file domdoc.c.

◆ EXPECT_HR

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

Definition at line 700 of file domdoc.c.

◆ expect_list_and_release

#define expect_list_and_release (   list,
  expstr 
)    { char *str = list_to_string(list); ok(strcmp(str, expstr)==0, "Invalid node list: %s, expected %s\n", str, expstr); if (list) IXMLDOMNodeList_Release(list); }

Definition at line 1405 of file domdoc.c.

◆ EXPECT_LIST_LEN

#define EXPECT_LIST_LEN (   list,
  len 
)    _expect_list_len(list, len, __LINE__)

Definition at line 688 of file domdoc.c.

◆ EXPECT_NO_CHILDREN

#define EXPECT_NO_CHILDREN (   node)    _expect_no_children((IXMLDOMNode*)node, __LINE__)

Definition at line 667 of file domdoc.c.

◆ expect_node

#define expect_node (   node,
  expstr 
)    { char str[4096]; node_to_string(node, str); ok(strcmp(str, expstr)==0, "Invalid node: %s, expected %s\n", str, expstr); }

Definition at line 1404 of file domdoc.c.

◆ EXPECT_REF

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

Definition at line 679 of file domdoc.c.

◆ helper_expect_bstr_and_release

#define helper_expect_bstr_and_release (   bstr,
  str 
)
Value:
{ \
ok_(__FILE__, line)(lstrcmpW(bstr, _bstr_(str)) == 0, \
"=> %i (%s): got %s\n", __LINE__, ver, wine_dbgstr_w(bstr)); \
SysFreeString(bstr); \
}
wine_dbgstr_w
#define wine_dbgstr_w
Definition: kernel32.h:34
_bstr_
static BSTR _bstr_(const char *str)
Definition: domdoc.c:1244
str
const WCHAR * str
Definition: rpc_transport.c:2724
line
Definition: parser.c:49

Definition at line 4511 of file domdoc.c.

◆ helper_expect_list_and_release

#define helper_expect_list_and_release (   list,
  expstr 
)
Value:
{ \
char *str = list_to_string(list); \
ok_(__FILE__, line)(strcmp(str, expstr)==0, "=> %i (%s): Invalid node list: %s, expected %s\n", __LINE__, ver, str, expstr); \
if (list) IXMLDOMNodeList_Release(list); \
}
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
list
Definition: list.h:37
list_to_string
static char * list_to_string(IXMLDOMNodeList *list)
Definition: domdoc.c:1375

Definition at line 4505 of file domdoc.c.

◆ helper_ole_check

#define helper_ole_check (   expr)
Value:
{ \
HRESULT r = expr; \
ok_(__FILE__, line)(r == S_OK, "=> %i: " #expr " returned %08x\n", __LINE__, r); \
}
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
S_OK
#define S_OK
Definition: intsafe.h:52
expr
Definition: query.h:86

Definition at line 4495 of file domdoc.c.

◆ helper_ole_check_ver

#define helper_ole_check_ver (   expr)
Value:
{ \
HRESULT r = expr; \
ok_(__FILE__, line)(r == S_OK, "-> %i (%s): " #expr " returned %08x\n", __LINE__, ver, r); \
}

Definition at line 4500 of file domdoc.c.

◆ ole_check

#define ole_check (   expr)
Value:
{ \
HRESULT r = expr; \
ok(r == S_OK, #expr " returned %x\n", r); \
}

Definition at line 1203 of file domdoc.c.

◆ ole_expect

#define ole_expect (   expr,
  expect 
)
Value:
{ \
HRESULT r = expr; \
ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
}

Definition at line 1208 of file domdoc.c.

◆ set_props

#define set_props (   doc,
  cache 
)    _set_props(__LINE__, doc, cache)

Definition at line 7880 of file domdoc.c.

◆ SZ_EMAIL_DTD

#define SZ_EMAIL_DTD
Value:
"<!DOCTYPE email ["\
" <!ELEMENT email (recipients,from,reply-to?,subject,body,attachment*)>"\
" <!ATTLIST email attachments IDREFS #REQUIRED>"\
" <!ATTLIST email sent (yes|no) \"no\">"\
" <!ELEMENT recipients (to+,cc*)>"\
" <!ELEMENT to (#PCDATA)>"\
" <!ATTLIST to name CDATA #IMPLIED>"\
" <!ELEMENT cc (#PCDATA)>"\
" <!ATTLIST cc name CDATA #IMPLIED>"\
" <!ELEMENT from (#PCDATA)>"\
" <!ATTLIST from name CDATA #IMPLIED>"\
" <!ELEMENT reply-to (#PCDATA)>"\
" <!ATTLIST reply-to name CDATA #IMPLIED>"\
" <!ELEMENT subject ANY>"\
" <!ELEMENT body ANY>"\
" <!ATTLIST body enc CDATA #FIXED \"UTF-8\">"\
" <!ELEMENT attachment (#PCDATA)>"\
" <!ATTLIST attachment id ID #REQUIRED>"\
"]>"

Definition at line 942 of file domdoc.c.

◆ test_IObjectSafety_common

#define test_IObjectSafety_common (   s)    _test_IObjectSafety_common(__LINE__,s)

Definition at line 4127 of file domdoc.c.

◆ test_IObjectSafety_set

#define test_IObjectSafety_set (   p,
  r,
  r2,
  s,
  m,
  e,
  e2 
)    _test_IObjectSafety_set(__LINE__,p, r, r2, s, m, e, e2)

Definition at line 4091 of file domdoc.c.

◆ unset_props

#define unset_props (   doc)    _unset_props(__LINE__, doc)

Definition at line 7897 of file domdoc.c.

Typedef Documentation

◆ get_attributes_t

typedef struct _get_attributes_t get_attributes_t

◆ get_node_typestring_t

typedef struct _get_node_typestring_t get_node_typestring_t

◆ namespace_as_attribute_t

typedef struct _namespace_as_attribute_t namespace_as_attribute_t

◆ nodetypedvalue_t

typedef struct _nodetypedvalue_t nodetypedvalue_t

◆ property_test_t

typedef struct _property_test_t property_test_t

Function Documentation

◆ _bstr_()

static BSTR _bstr_ ( const char *  str)
static

Definition at line 1244 of file domdoc.c.

1245{
1246 assert(alloced_bstrs_count < ARRAY_SIZE(alloced_bstrs));
1247 alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
1248 return alloced_bstrs[alloced_bstrs_count++];
1249}
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
assert
#define assert(x)
Definition: debug.h:53
alloced_bstrs
static BSTR alloced_bstrs[256]
Definition: domdoc.c:1241
alloced_bstrs_count
static int alloced_bstrs_count
Definition: domdoc.c:1242

Referenced by _check_default_props(), _check_set_props(), _check_ws_ignored(), _check_ws_preserved(), _set_props(), _unset_props(), _variantbstr_(), node_to_string(), test_appendChild(), test_cloneNode(), test_create(), test_create_attribute(), test_createNode(), test_createProcessingInstruction(), test_default_properties(), test_dispex(), test_doc_load_from_path(), test_domdoc(), test_domnode(), test_FormattingXML(), test_get_attributes(), test_get_childNodes(), test_get_dataType(), test_get_doctype(), test_get_firstChild(), test_get_lastChild(), test_get_namespaces(), test_get_nodeTypeString(), test_get_ownerDocument(), test_get_prefix(), test_get_tagName(), test_get_text(), test_get_xml(), test_getAttribute(), test_getAttributeNode(), test_getElementsByTagName(), test_getQualifiedItem(), test_insertBefore(), test_IXMLDOMDocument2(), test_load(), test_merging_text(), test_mxnamespacemanager(), test_mxnamespacemanager_override(), test_namedmap_newenum(), test_namespaces_as_attributes(), test_namespaces_basic(), test_namespaces_change(), test_newline_normalization(), test_nodeTypedValue(), test_nodeValue(), test_normalize_attribute_values(), test_preserve_charref(), test_put_data(), test_put_dataType(), test_put_nodeTypedValue(), test_put_nodeValue(), test_refs(), test_removeChild(), test_removeNamedItem(), test_removeQualifiedItem(), test_replaceChild(), test_save(), test_selection(), test_selectSingleNode(), test_setAttributeNode(), test_splitText(), test_supporterrorinfo(), test_testTransforms(), test_transformNodeToObject(), test_TransformWithLoadingLocalFile(), test_whitespace(), test_xmlns_attribute(), test_xmlTypes(), test_XPath(), test_XSLPattern(), test_xsltemplate(), and test_xsltext().

◆ _check_default_props()

static void _check_default_props ( int  line,
IXMLDOMDocument2 *  doc 
)
inlinestatic

Definition at line 7834 of file domdoc.c.

7835{
7836 VARIANT_BOOL b;
7837 VARIANT var;
7838 HRESULT hr;
7839
7840 VariantInit(&var);
7841 helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
7842 ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XSLPattern")) == 0, "expected XSLPattern\n");
7843 VariantClear(&var);
7844
7845 helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
7846 ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("")) == 0, "expected empty string\n");
7847 VariantClear(&var);
7848
7849 helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
7850 ok_(__FILE__, line)(b == VARIANT_FALSE, "expected FALSE\n");
7851
7852 hr = IXMLDOMDocument2_get_schemas(doc, &var);
7853 ok_(__FILE__, line)(hr == S_FALSE, "got %08x\n", hr);
7854 VariantClear(&var);
7855}
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
VARIANT_BOOL
short VARIANT_BOOL
Definition: compat.h:2290
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
b
#define b
Definition: ke_i.h:79
var
const char * var
Definition: shader.c:5666
helper_ole_check
#define helper_ole_check(expr)
Definition: domdoc.c:4495
V_BSTR
#define V_BSTR(A)
Definition: oleauto.h:226
hr
HRESULT hr
Definition: shlfolder.c:183
VariantClear
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648
VariantInit
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:568
S_FALSE
#define S_FALSE
Definition: winerror.h:2357

◆ _check_set_props()

static void _check_set_props ( int  line,
IXMLDOMDocument2 *  doc 
)
inlinestatic

Definition at line 7858 of file domdoc.c.

7859{
7860 VARIANT_BOOL b;
7861 VARIANT var;
7862
7863 VariantInit(&var);
7864 helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
7865 ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XPath")) == 0, "expected XPath\n");
7866 VariantClear(&var);
7867
7868 helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
7869 ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("xmlns:wi=\'www.winehq.org\'")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&var)));
7870 VariantClear(&var);
7871
7872 helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
7873 ok_(__FILE__, line)(b == VARIANT_TRUE, "expected TRUE\n");
7874
7875 helper_ole_check(IXMLDOMDocument2_get_schemas(doc, &var));
7876 ok_(__FILE__, line)(V_VT(&var) != VT_NULL, "expected pointer\n");
7877 VariantClear(&var);
7878}
VT_NULL
@ VT_NULL
Definition: compat.h:2296
V_VT
#define V_VT(A)
Definition: oleauto.h:211

◆ _check_ws_ignored()

static void _check_ws_ignored ( int  line,
const char *  ver,
IXMLDOMDocument2 *  doc,
char const *  str 
)
inlinestatic

Definition at line 4518 of file domdoc.c.

4519{
4520 IXMLDOMNode *node1, *node2;
4521 IXMLDOMNodeList *list;
4522 BSTR bstr;
4523
4524 helper_ole_check_ver(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4525 helper_ole_check_ver(IXMLDOMNodeList_get_item(list, 0, &node1));
4526 helper_ole_check_ver(IXMLDOMNodeList_get_item(list, 1, &node2));
4527 helper_ole_check_ver(IXMLDOMNodeList_reset(list));
4528 helper_expect_list_and_release(list, "E1.E5.E1.E2.D1 E2.E5.E1.E2.D1");
4529
4530 helper_ole_check_ver(IXMLDOMNode_get_childNodes(node1, &list));
4531 helper_expect_list_and_release(list,
4532 "[4]1.E1.E5.E1.E2.D1 T2.E1.E5.E1.E2.D1 E3.E1.E5.E1.E2.D1 "
4533 "E4.E1.E5.E1.E2.D1 E5.E1.E5.E1.E2.D1 E6.E1.E5.E1.E2.D1");
4534 helper_ole_check_ver(IXMLDOMNode_get_text(node1, &bstr));
4535 if (str)
4536 {
4537 helper_expect_bstr_and_release(bstr, str);
4538 }
4539 else
4540 {
4541 helper_expect_bstr_and_release(bstr, " This is a description.");
4542 }
4543 IXMLDOMNode_Release(node1);
4544
4545 helper_ole_check_ver(IXMLDOMNode_get_childNodes(node2, &list));
4546 helper_expect_list_and_release(list,
4547 "T1.E2.E5.E1.E2.D1 E2.E2.E5.E1.E2.D1 T3.E2.E5.E1.E2.D1 "
4548 "E4.E2.E5.E1.E2.D1 T5.E2.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1 T7.E2.E5.E1.E2.D1");
4549 helper_ole_check_ver(IXMLDOMNode_get_text(node2, &bstr));
4550 helper_expect_bstr_and_release(bstr,
4551 "\n This is a description with preserved whitespace. \n ");
4552 IXMLDOMNode_Release(node2);
4553}
helper_expect_list_and_release
#define helper_expect_list_and_release(list, expstr)
Definition: domdoc.c:4505
helper_ole_check_ver
#define helper_ole_check_ver(expr)
Definition: domdoc.c:4500
helper_expect_bstr_and_release
#define helper_expect_bstr_and_release(bstr, str)
Definition: domdoc.c:4511
list
#define list
Definition: rosglue.h:35

◆ _check_ws_preserved()

static void _check_ws_preserved ( int  line,
const char *  ver,
IXMLDOMDocument2 *  doc,
char const *  str 
)
inlinestatic

Definition at line 4556 of file domdoc.c.

4557{
4558 IXMLDOMNode *node1, *node2;
4559 IXMLDOMNodeList *list;
4560 BSTR bstr;
4561
4562 helper_ole_check_ver(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4563 helper_ole_check_ver(IXMLDOMNodeList_get_item(list, 0, &node1));
4564 helper_ole_check_ver(IXMLDOMNodeList_get_item(list, 1, &node2));
4565 helper_ole_check_ver(IXMLDOMNodeList_reset(list));
4566 helper_expect_list_and_release(list, "E2.E10.E2.E2.D1 E4.E10.E2.E2.D1");
4567
4568 helper_ole_check_ver(IXMLDOMNode_get_childNodes(node1, &list));
4569 helper_expect_list_and_release(list,
4570 "T1.E2.E10.E2.E2.D1 [4]2.E2.E10.E2.E2.D1 T3.E2.E10.E2.E2.D1 "
4571 "E4.E2.E10.E2.E2.D1 T5.E2.E10.E2.E2.D1 E6.E2.E10.E2.E2.D1 "
4572 "E7.E2.E10.E2.E2.D1 E8.E2.E10.E2.E2.D1 T9.E2.E10.E2.E2.D1");
4573 helper_ole_check_ver(IXMLDOMNode_get_text(node1, &bstr));
4574 if (str)
4575 {
4576 helper_expect_bstr_and_release(bstr, str);
4577 }
4578 else
4579 {
4580 helper_expect_bstr_and_release(bstr, "\n This is a description. \n ");
4581 }
4582 IXMLDOMNode_Release(node1);
4583
4584 helper_ole_check_ver(IXMLDOMNode_get_childNodes(node2, &list));
4585 helper_expect_list_and_release(list,
4586 "T1.E4.E10.E2.E2.D1 E2.E4.E10.E2.E2.D1 T3.E4.E10.E2.E2.D1 "
4587 "E4.E4.E10.E2.E2.D1 T5.E4.E10.E2.E2.D1 E6.E4.E10.E2.E2.D1 T7.E4.E10.E2.E2.D1");
4588 helper_ole_check_ver(IXMLDOMNode_get_text(node2, &bstr));
4589 helper_expect_bstr_and_release(bstr,
4590 "\n This is a description with preserved whitespace. \n ");
4591 IXMLDOMNode_Release(node2);
4592}

◆ _create_object()

static void * _create_object ( const GUID *  clsid,
const char *  name,
const IID *  iid,
int  line 
)
static

Definition at line 1215 of file domdoc.c.

1216{
1217 void *obj = NULL;
1218 HRESULT hr;
1219
1220 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
1221 ok(hr == S_OK, "failed to create %s instance: 0x%08x\n", name, hr);
1222
1223 return obj;
1224}
ok
#define ok(value,...)
Definition: atltest.h:57
NULL
#define NULL
Definition: types.h:112
CoCreateInstance
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
clsid
REFCLSID clsid
Definition: msctf.c:82
name
Definition: name.c:39

◆ _expect_children()

static void _expect_children ( IXMLDOMNode *  node,
int  line 
)
static

Definition at line 656 of file domdoc.c.

657{
658 VARIANT_BOOL b;
659 HRESULT hr;
660
661 b = VARIANT_FALSE;
662 hr = IXMLDOMNode_hasChildNodes(node, &b);
663 ok_(__FILE__,line)(hr == S_OK, "hasChildNodes() failed, 0x%08x\n", hr);
664 ok_(__FILE__,line)(b == VARIANT_TRUE, "no children, %d\n", b);
665}
node
Definition: dlist.c:348

◆ _expect_list_len()

static void _expect_list_len ( IXMLDOMNodeList *  list,
LONG  len,
int  line 
)
static

Definition at line 689 of file domdoc.c.

690{
691 LONG length;
692 HRESULT hr;
693
694 length = 0;
695 hr = IXMLDOMNodeList_get_length(list, &length);
696 ok_(__FILE__,line)(hr == S_OK, "got 0x%08x\n", hr);
697 ok_(__FILE__,line)(length == len, "got %d, expected %d\n", length, len);
698}
length
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
len
GLenum GLsizei len
Definition: glext.h:6722
LONG
long LONG
Definition: pedump.c:60

◆ _expect_no_children()

static void _expect_no_children ( IXMLDOMNode *  node,
int  line 
)
static

Definition at line 668 of file domdoc.c.

669{
670 VARIANT_BOOL b;
671 HRESULT hr;
672
673 b = VARIANT_TRUE;
674 hr = IXMLDOMNode_hasChildNodes(node, &b);
675 ok_(__FILE__,line)(hr == S_FALSE, "hasChildNodes() failed, 0x%08x\n", hr);
676 ok_(__FILE__,line)(b == VARIANT_FALSE, "no children, %d\n", b);
677}

◆ _expect_ref()

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

Definition at line 680 of file domdoc.c.

681{
682 ULONG rc;
683 IUnknown_AddRef(obj);
684 rc = IUnknown_Release(obj);
685 ok_(__FILE__,line)(rc == ref, "expected refcount %d, got %d\n", ref, rc);
686}
ref
Definition: send.c:48
ULONG
uint32_t ULONG
Definition: typedefs.h:59

◆ _set_props()

static void _set_props ( int  line,
IXMLDOMDocument2 *  doc,
IXMLDOMSchemaCollection *  cache 
)
inlinestatic

Definition at line 7881 of file domdoc.c.

7882{
7883 VARIANT var;
7884
7885 VariantInit(&var);
7886 helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
7887 helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:wi=\'www.winehq.org\'")));
7888 helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_TRUE));
7889 V_VT(&var) = VT_DISPATCH;
7890 V_DISPATCH(&var) = NULL;
7891 helper_ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&var)));
7892 ok_(__FILE__, line)(V_DISPATCH(&var) != NULL, "expected pointer\n");
7893 helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
7894 VariantClear(&var);
7895}
VT_DISPATCH
@ VT_DISPATCH
Definition: compat.h:2304
_variantbstr_
static VARIANT _variantbstr_(const char *str)
Definition: domdoc.c:1259
V_DISPATCH
#define V_DISPATCH(A)
Definition: oleauto.h:239
IID_IDispatch
const GUID IID_IDispatch
cache
Definition: cache.c:49

◆ _test_IObjectSafety_common()

static void _test_IObjectSafety_common ( unsigned  line,
IObjectSafety *  safety 
)
static

Definition at line 4128 of file domdoc.c.

4129{
4130 DWORD enabled = 0, supported = 0;
4131 HRESULT hr;
4132
4133 /* get */
4134 hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, NULL, &enabled);
4135 ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
4136 hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, NULL);
4137 ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
4138
4139 hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4140 ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4141 ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4142 supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4143 "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4144 "got %08x\n", supported);
4145 ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
4146
4147 /* set -- individual flags */
4148
4149 test_IObjectSafety_set(safety, S_OK, S_OK,
4150 INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4151 INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4152
4153 test_IObjectSafety_set(safety, S_OK, S_OK,
4154 INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA,
4155 INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA);
4156
4157 test_IObjectSafety_set(safety, S_OK, S_OK,
4158 INTERFACE_USES_SECURITY_MANAGER, INTERFACE_USES_SECURITY_MANAGER,
4159 0, INTERFACE_USES_SECURITY_MANAGER /* msxml3 SP8+ */);
4160
4161 /* set INTERFACE_USES_DISPEX */
4162
4163 test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
4164 INTERFACE_USES_DISPEX, INTERFACE_USES_DISPEX,
4165 0, 0);
4166
4167 test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
4168 INTERFACE_USES_DISPEX, 0,
4169 0, 0);
4170
4171 test_IObjectSafety_set(safety, S_OK, S_OK /* msxml3 SP8+ */,
4172 0, INTERFACE_USES_DISPEX,
4173 0, 0);
4174
4175 /* set option masking */
4176
4177 test_IObjectSafety_set(safety, S_OK, S_OK,
4178 INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4179 INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4180 INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4181 INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4182
4183 test_IObjectSafety_set(safety, S_OK, S_OK,
4184 INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4185 INTERFACESAFE_FOR_UNTRUSTED_DATA,
4186 INTERFACESAFE_FOR_UNTRUSTED_DATA,
4187 INTERFACESAFE_FOR_UNTRUSTED_DATA);
4188
4189 test_IObjectSafety_set(safety, S_OK, S_OK,
4190 INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4191 INTERFACE_USES_SECURITY_MANAGER,
4192 0,
4193 0);
4194
4195 /* set -- inheriting previous settings */
4196
4197 hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4198 INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4199 INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4200 ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4201 hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4202 ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4203 ok_(__FILE__,line)(enabled == INTERFACESAFE_FOR_UNTRUSTED_CALLER, "Expected INTERFACESAFE_FOR_UNTRUSTED_CALLER got %08x\n", enabled);
4204 ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4205 supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4206 "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4207 "got %08x\n", supported);
4208
4209 hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4210 INTERFACESAFE_FOR_UNTRUSTED_DATA,
4211 INTERFACESAFE_FOR_UNTRUSTED_DATA);
4212 ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4213 hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4214 ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4215 ok_(__FILE__,line)(broken(enabled == INTERFACESAFE_FOR_UNTRUSTED_DATA) ||
4216 enabled == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA),
4217 "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA) got %08x\n", enabled);
4218 ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4219 supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4220 "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4221 "got %08x\n", supported);
4222}
broken
#define broken(x)
Definition: atltest.h:178
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
enabled
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glext.h:7750
test_IObjectSafety_set
#define test_IObjectSafety_set(p, r, r2, s, m, e, e2)
Definition: domdoc.c:4091
E_POINTER
#define E_POINTER
Definition: winerror.h:2365

◆ _test_IObjectSafety_set()

static void _test_IObjectSafety_set ( unsigned  line,
IObjectSafety *  safety,
HRESULT  result,
HRESULT  result2,
DWORD  set,
DWORD  mask,
DWORD  expected,
DWORD  expected2 
)
static

Definition at line 4092 of file domdoc.c.

4095{
4096 DWORD enabled, supported;
4097 HRESULT hr;
4098
4099 hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL, set, mask);
4100 if (result == result2)
4101 ok_(__FILE__,line)(hr == result, "SetInterfaceSafetyOptions: expected %08x, returned %08x\n", result, hr );
4102 else
4103 ok_(__FILE__,line)(broken(hr == result) || hr == result2,
4104 "SetInterfaceSafetyOptions: expected %08x, got %08x\n", result2, hr );
4105
4106 supported = enabled = 0xCAFECAFE;
4107 hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4108 ok(hr == S_OK, "ret %08x\n", hr );
4109 if (expected == expected2)
4110 ok_(__FILE__,line)(enabled == expected, "Expected %08x, got %08x\n", expected, enabled);
4111 else
4112 ok_(__FILE__,line)(broken(enabled == expected) || enabled == expected2,
4113 "Expected %08x, got %08x\n", expected2, enabled);
4114
4115 /* reset the safety options */
4116
4117 hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4118 INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER,
4119 0);
4120 ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4121
4122 hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4123 ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4124 ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
4125}
set
Definition: _set.h:50
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
result
GLuint64EXT * result
Definition: glext.h:11304
expected
BOOL expected
Definition: store.c:2063

◆ _unset_props()

static void _unset_props ( int  line,
IXMLDOMDocument2 *  doc 
)
inlinestatic

Definition at line 7898 of file domdoc.c.

7899{
7900 VARIANT var;
7901
7902 VariantInit(&var);
7903 helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
7904 helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("")));
7905 helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_FALSE));
7906 V_VT(&var) = VT_NULL;
7907 helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
7908 VariantClear(&var);
7909}

◆ _variantbstr_()

static VARIANT _variantbstr_ ( const char *  str)
static

Definition at line 1259 of file domdoc.c.

1260{
1261 VARIANT v;
1262 V_VT(&v) = VT_BSTR;
1263 V_BSTR(&v) = _bstr_(str);
1264 return v;
1265}
VT_BSTR
@ VT_BSTR
Definition: compat.h:2303
v
const GLdouble * v
Definition: gl.h:2040

Referenced by _set_props(), _unset_props(), test_IXMLDOMDocument2(), test_whitespace(), test_XPath(), and test_XSLPattern().

◆ alloc_str_from_narrow()

static BSTR alloc_str_from_narrow ( const char *  str)
static

Definition at line 1233 of file domdoc.c.

1234{
1235 int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
1236 BSTR ret = SysAllocStringLen(NULL, len - 1); /* NUL character added automatically */
1237 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
1238 return ret;
1239}
CP_ACP
#define CP_ACP
Definition: compat.h:109
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
SysAllocStringLen
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:339
ret
int ret
Definition: wcstombs-tests.c:31

Referenced by _bstr_().

◆ compareIgnoreReturns()

static BOOL compareIgnoreReturns ( BSTR  sLeft,
BSTR  sRight 
)
static

Definition at line 1267 of file domdoc.c.

1268{
1269 for (;;)
1270 {
1271 while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
1272 while (*sRight == '\r' || *sRight == '\n') sRight++;
1273 if (*sLeft != *sRight) return FALSE;
1274 if (!*sLeft) return TRUE;
1275 sLeft++;
1276 sRight++;
1277 }
1278}
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117

Referenced by test_testTransforms(), and test_TransformWithLoadingLocalFile().

◆ create_dispevent()

static IDispatch * create_dispevent ( void  )
static

Definition at line 234 of file domdoc.c.

235{
236 dispevent *event = heap_alloc(sizeof(*event));
237
238 event->IDispatch_iface.lpVtbl = &dispeventVtbl;
239 event->ref = 1;
240
241 return (IDispatch*)&event->IDispatch_iface;
242}
heap_alloc
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
event
struct _cl_event * event
Definition: glext.h:7739
dispeventVtbl
static const IDispatchVtbl dispeventVtbl
Definition: domdoc.c:223

Referenced by test_events().

◆ debugstr_msxml_guid()

static const char * debugstr_msxml_guid ( REFIID  riid)
static

Definition at line 76 of file domdoc.c.

77{
78 if(!riid)
79 return "(null)";
80
81 if (IsEqualIID(&IID_IXMLDOMDocument, riid))
82 return "IXMLDOMDocument";
83 else if (IsEqualIID(&IID_IXMLDOMDocument2, riid))
84 return "IXMLDOMDocument2";
85 else if (IsEqualIID(&IID_IXMLDOMDocument3, riid))
86 return "IXMLDOMDocument3";
87 else if (IsEqualIID(&IID_IXMLDOMSchemaCollection, riid))
88 return "IXMLDOMSchemaCollection";
89 else if (IsEqualIID(&IID_IXSLTemplate, riid))
90 return "IXSLTemplate";
91 else if (IsEqualIID(&IID_IMXNamespaceManager, riid))
92 return "IMXNamespaceManager";
93 else
94 return wine_dbgstr_guid(riid);
95}
riid
REFIID riid
Definition: atlbase.h:39
IsEqualIID
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
wine_dbgstr_guid
static __inline const char * wine_dbgstr_guid(const GUID *id)
Definition: debug.h:197

Referenced by get_class_support_data().

◆ DEFINE_GUID() [1/2]

DEFINE_GUID ( GUID_NULL  ,
0  ,
0  ,
0  ,
0  ,
0  ,
0  ,
0  ,
0  ,
0  ,
0  ,
0   
)

◆ DEFINE_GUID() [2/2]

DEFINE_GUID ( IID_transformdest_unknown  ,
0xf5078f3a  ,
0xc551  ,
0x11d3  ,
0x89  ,
0xb9  ,
0x00  ,
0x00  ,
0xf8  ,
0x1f  ,
0xe2  ,
0x21   
)

◆ dispevent_AddRef()

static ULONG WINAPI dispevent_AddRef ( IDispatch *  iface)
static

Definition at line 164 of file domdoc.c.

165{
166 dispevent *This = impl_from_IDispatch( iface );
167 return InterlockedIncrement( &This->ref );
168}
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
impl_from_IDispatch
static dispevent * impl_from_IDispatch(IDispatch *iface)
Definition: domdoc.c:142

◆ dispevent_GetIDsOfNames()

static HRESULT WINAPI dispevent_GetIDsOfNames ( IDispatch *  iface,
REFIID  riid,
LPOLESTR *  rgszNames,
UINT  cNames,
LCID  lcid,
DISPID *  rgDispId 
)
static

Definition at line 195 of file domdoc.c.

197{
198 g_unexpectedcall++;
199 return S_OK;
200}
g_unexpectedcall
static int g_unexpectedcall
Definition: domdoc.c:52

◆ dispevent_GetTypeInfo()

static HRESULT WINAPI dispevent_GetTypeInfo ( IDispatch *  iface,
UINT  iTInfo,
LCID  lcid,
ITypeInfo **  ppTInfo 
)
static

Definition at line 188 of file domdoc.c.

190{
191 g_unexpectedcall++;
192 return S_OK;
193}

◆ dispevent_GetTypeInfoCount()

static HRESULT WINAPI dispevent_GetTypeInfoCount ( IDispatch *  iface,
UINT *  pctinfo 
)
static

Definition at line 181 of file domdoc.c.

182{
183 g_unexpectedcall++;
184 *pctinfo = 0;
185 return S_OK;
186}

◆ dispevent_Invoke()

static HRESULT WINAPI dispevent_Invoke ( IDispatch *  iface,
DISPID  member,
REFIID  riid,
LCID  lcid,
WORD  flags,
DISPPARAMS *  params,
VARIANT *  result,
EXCEPINFO *  excepInfo,
UINT *  argErr 
)
static

Definition at line 202 of file domdoc.c.

205{
206 ok(member == 0, "expected 0 member, got %d\n", member);
207 ok(lcid == LOCALE_SYSTEM_DEFAULT, "expected LOCALE_SYSTEM_DEFAULT, got lcid %x\n", lcid);
208 ok(flags == DISPATCH_METHOD, "expected DISPATCH_METHOD, got %d\n", flags);
209
210 ok(params->cArgs == 0, "got %d\n", params->cArgs);
211 ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
212 ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
213 ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
214
215 ok(result == NULL, "got %p\n", result);
216 ok(excepInfo == NULL, "got %p\n", excepInfo);
217 ok(argErr == NULL, "got %p\n", argErr);
218
219 g_expectedcall++;
220 return E_FAIL;
221}
params
GLenum const GLfloat * params
Definition: glext.h:5645
flags
GLbitfield flags
Definition: glext.h:7161
g_expectedcall
static int g_expectedcall
Definition: domdoc.c:52
LOCALE_SYSTEM_DEFAULT
#define LOCALE_SYSTEM_DEFAULT
DISPATCH_METHOD
#define DISPATCH_METHOD
Definition: oleauto.h:1006

◆ dispevent_QueryInterface()

static HRESULT WINAPI dispevent_QueryInterface ( IDispatch *  iface,
REFIID  riid,
void **  ppvObject 
)
static

Definition at line 147 of file domdoc.c.

148{
149 *ppvObject = NULL;
150
151 if ( IsEqualGUID( riid, &IID_IDispatch) ||
152 IsEqualGUID( riid, &IID_IUnknown) )
153 {
154 *ppvObject = iface;
155 }
156 else
157 return E_NOINTERFACE;
158
159 IDispatch_AddRef( iface );
160
161 return S_OK;
162}
IID_IUnknown
const GUID IID_IUnknown
Definition: classfactory.cpp:11
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
ppvObject
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082
E_NOINTERFACE
#define E_NOINTERFACE
Definition: winerror.h:2364

◆ dispevent_Release()

static ULONG WINAPI dispevent_Release ( IDispatch *  iface)
static

Definition at line 170 of file domdoc.c.

171{
172 dispevent *This = impl_from_IDispatch( iface );
173 ULONG ref = InterlockedDecrement( &This->ref );
174
175 if (ref == 0)
176 heap_free(This);
177
178 return ref;
179}
heap_free
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
InterlockedDecrement
#define InterlockedDecrement
Definition: armddk.h:52

◆ free_bstrs()

static void free_bstrs ( void  )
static

Definition at line 1251 of file domdoc.c.

1252{
1253 int i;
1254 for (i = 0; i < alloced_bstrs_count; i++)
1255 SysFreeString(alloced_bstrs[i]);
1256 alloced_bstrs_count = 0;
1257}
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
SysFreeString
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271

Referenced by test_cloneNode(), test_create_attribute(), test_createNode(), test_dispex(), test_domdoc(), test_domnode(), test_FormattingXML(), test_get_attributes(), test_get_childNodes(), test_get_dataType(), test_get_firstChild(), test_get_lastChild(), test_get_namespaces(), test_get_nodeTypeString(), test_get_ownerDocument(), test_get_prefix(), test_get_tagName(), test_get_text(), test_get_xml(), test_getAttribute(), test_getAttributeNode(), test_getElementsByTagName(), test_getQualifiedItem(), test_IXMLDOMDocument2(), test_load(), test_merging_text(), test_mxnamespacemanager(), test_mxnamespacemanager_override(), test_namespaces_as_attributes(), test_namespaces_basic(), test_namespaces_change(), test_newline_normalization(), test_nodeTypedValue(), test_put_data(), test_put_dataType(), test_put_nodeTypedValue(), test_put_nodeValue(), test_refs(), test_removeChild(), test_removeNamedItem(), test_removeQualifiedItem(), test_replaceChild(), test_save(), test_selection(), test_selectSingleNode(), test_setAttributeNode(), test_splitText(), test_supporterrorinfo(), test_testTransforms(), test_transformNodeToObject(), test_TransformWithLoadingLocalFile(), test_whitespace(), test_xmlns_attribute(), test_xmlTypes(), test_XPath(), test_XSLPattern(), test_xsltemplate(), and test_xsltext().

◆ get_class_support_data()

static void get_class_support_data ( struct msxmlsupported_data_t *  table)
static

Definition at line 97 of file domdoc.c.

98{
99 while (table->clsid)
100 {
101 IUnknown *unk;
102 HRESULT hr;
103 int i;
104
105 for (i = 0; i < ARRAY_SIZE(table->ifaces) && table->ifaces[i] != NULL; i++)
106 {
107 hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, table->ifaces[i], (void**)&unk);
108 if (hr == S_OK) IUnknown_Release(unk);
109
110 table->supported[i] = hr == S_OK;
111 if (hr != S_OK) win_skip("class %s, iface %s not supported\n", table->name, debugstr_msxml_guid(table->ifaces[i]));
112 }
113
114 table++;
115 }
116}
debugstr_msxml_guid
static const char * debugstr_msxml_guid(REFIID riid)
Definition: domdoc.c:76
win_skip
#define win_skip
Definition: test.h:164
table::name
const WCHAR * name
Definition: wbemprox_private.h:110

Referenced by START_TEST().

◆ get_node_position()

static int get_node_position ( IXMLDOMNode *  node)
static

Definition at line 1307 of file domdoc.c.

1308{
1309 HRESULT r;
1310 int pos = 0;
1311
1312 IXMLDOMNode_AddRef(node);
1313 do
1314 {
1315 IXMLDOMNode *new_node;
1316
1317 pos++;
1318 r = IXMLDOMNode_get_previousSibling(node, &new_node);
1319 ok(SUCCEEDED(r), "get_previousSibling failed\n");
1320 IXMLDOMNode_Release(node);
1321 node = new_node;
1322 } while (r == S_OK);
1323 return pos;
1324}
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50

Referenced by node_to_string().

◆ get_str_for_type()

static void get_str_for_type ( DOMNodeType  type,
char *  buf 
)
static

Definition at line 1280 of file domdoc.c.

1281{
1282 switch (type)
1283 {
1284 case NODE_ATTRIBUTE:
1285 strcpy(buf, "A");
1286 break;
1287 case NODE_ELEMENT:
1288 strcpy(buf, "E");
1289 break;
1290 case NODE_DOCUMENT:
1291 strcpy(buf, "D");
1292 break;
1293 case NODE_TEXT:
1294 strcpy(buf, "T");
1295 break;
1296 case NODE_COMMENT:
1297 strcpy(buf, "C");
1298 break;
1299 case NODE_PROCESSING_INSTRUCTION:
1300 strcpy(buf, "P");
1301 break;
1302 default:
1303 wsprintfA(buf, "[%d]", type);
1304 }
1305}
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
strcpy
strcpy
Definition: string.h:131
wsprintfA
int WINAPIV wsprintfA(_Out_ LPSTR, _In_ _Printf_format_string_ LPCSTR,...)
NODE_TEXT
@ NODE_TEXT
Definition: xmldom.idl:55
NODE_PROCESSING_INSTRUCTION
@ NODE_PROCESSING_INSTRUCTION
Definition: xmldom.idl:59
NODE_ATTRIBUTE
@ NODE_ATTRIBUTE
Definition: xmldom.idl:54
NODE_DOCUMENT
@ NODE_DOCUMENT
Definition: xmldom.idl:61
NODE_COMMENT
@ NODE_COMMENT
Definition: xmldom.idl:60
NODE_ELEMENT
@ NODE_ELEMENT
Definition: xmldom.idl:53

Referenced by node_to_string().

◆ impl_from_IDispatch()

static dispevent * impl_from_IDispatch ( IDispatch *  iface)
inlinestatic

Definition at line 142 of file domdoc.c.

143{
144 return CONTAINING_RECORD(iface, dispevent, IDispatch_iface);
145}
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by dispevent_AddRef(), and dispevent_Release().

◆ is_clsid_supported()

static BOOL is_clsid_supported ( const GUID *  clsid,
REFIID  riid 
)
static

Definition at line 118 of file domdoc.c.

119{
120 const struct msxmlsupported_data_t *table = domdoc_support_data;
121 while (table->clsid)
122 {
123 if (table->clsid == clsid)
124 {
125 int i;
126
127 for (i = 0; i < ARRAY_SIZE(table->ifaces) && table->ifaces[i] != NULL; i++)
128 if (table->ifaces[i] == riid) return table->supported[i];
129 }
130
131 table++;
132 }
133 return FALSE;
134}
domdoc_support_data
static struct msxmlsupported_data_t domdoc_support_data[]
Definition: domdoc.c:62
msxmlsupported_data_t
Definition: domdoc.c:55

Referenced by START_TEST(), test_default_properties(), test_dispex(), test_domdoc(), test_get_namespaces(), test_get_ownerDocument(), test_IXMLDOMDocument2(), test_namespaces_as_attributes(), test_namespaces_change(), test_newline_normalization(), test_normalize_attribute_values(), test_parseerror(), test_putref_schemas(), test_supporterrorinfo(), test_whitespace(), test_XPath(), and test_xsltemplate().

◆ istream_AddRef()

static ULONG WINAPI istream_AddRef ( IStream *  iface)
static

Definition at line 258 of file domdoc.c.

259{
260 return 2;
261}

◆ istream_Clone()

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

Definition at line 331 of file domdoc.c.

332{
333 ok(0, "unexpected call\n");
334 return E_NOTIMPL;
335}
E_NOTIMPL
#define E_NOTIMPL
Definition: ddrawi.h:99

◆ istream_Commit()

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

Definition at line 299 of file domdoc.c.

300{
301 ok(0, "unexpected call\n");
302 return E_NOTIMPL;
303}

◆ istream_CopyTo()

static HRESULT WINAPI istream_CopyTo ( IStream *  iface,
IStream *  stream,
ULARGE_INTEGER  len,
ULARGE_INTEGER *  pread,
ULARGE_INTEGER *  written 
)
static

Definition at line 292 of file domdoc.c.

294{
295 ok(0, "unexpected call\n");
296 return E_NOTIMPL;
297}

◆ istream_LockRegion()

static HRESULT WINAPI istream_LockRegion ( IStream *  iface,
ULARGE_INTEGER  offset,
ULARGE_INTEGER  len,
DWORD  locktype 
)
static

Definition at line 311 of file domdoc.c.

313{
314 ok(0, "unexpected call\n");
315 return E_NOTIMPL;
316}

◆ istream_QueryInterface()

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

Definition at line 245 of file domdoc.c.

246{
247 *ppvObject = NULL;
248
249 if (IsEqualGUID(riid, &IID_IStream) ||
250 IsEqualGUID(riid, &IID_IUnknown))
251 *ppvObject = iface;
252 else
253 return E_NOINTERFACE;
254
255 return S_OK;
256}

◆ istream_Read()

static HRESULT WINAPI istream_Read ( IStream *  iface,
void *  ptr,
ULONG  len,
ULONG *  pread 
)
static

Definition at line 268 of file domdoc.c.

269{
270 ok(0, "unexpected call\n");
271 return E_NOTIMPL;
272}

◆ istream_Release()

static ULONG WINAPI istream_Release ( IStream *  iface)
static

Definition at line 263 of file domdoc.c.

264{
265 return 1;
266}

◆ istream_Revert()

static HRESULT WINAPI istream_Revert ( IStream *  iface)
static

Definition at line 305 of file domdoc.c.

306{
307 ok(0, "unexpected call\n");
308 return E_NOTIMPL;
309}

◆ istream_Seek()

static HRESULT WINAPI istream_Seek ( IStream *  iface,
LARGE_INTEGER  move,
DWORD  origin,
ULARGE_INTEGER *  new_pos 
)
static

Definition at line 280 of file domdoc.c.

281{
282 ok(0, "unexpected call\n");
283 return E_NOTIMPL;
284}

◆ istream_SetSize()

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

Definition at line 286 of file domdoc.c.

287{
288 ok(0, "unexpected call\n");
289 return E_NOTIMPL;
290}

◆ istream_Stat()

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

Definition at line 325 of file domdoc.c.

326{
327 ok(0, "unexpected call\n");
328 return E_NOTIMPL;
329}

◆ istream_UnlockRegion()

static HRESULT WINAPI istream_UnlockRegion ( IStream *  iface,
ULARGE_INTEGER  offset,
ULARGE_INTEGER  len,
DWORD  locktype 
)
static

Definition at line 318 of file domdoc.c.

320{
321 ok(0, "unexpected call\n");
322 return E_NOTIMPL;
323}

◆ istream_Write()

static HRESULT WINAPI istream_Write ( IStream *  iface,
const void *  ptr,
ULONG  len,
ULONG *  written 
)
static

Definition at line 274 of file domdoc.c.

275{
276 *written = len/2;
277 return S_OK;
278}

◆ list_to_string()

static char * list_to_string ( IXMLDOMNodeList *  list)
static

Definition at line 1375 of file domdoc.c.

1376{
1377 static char buf[4096];
1378 char *pos = buf;
1379 LONG len = 0;
1380 HRESULT hr;
1381 int i;
1382
1383 if (list == NULL)
1384 {
1385 strcpy(buf, "(null)");
1386 return buf;
1387 }
1388 hr = IXMLDOMNodeList_get_length(list, &len);
1389 ok(hr == S_OK, "got 0x%08x\n", hr);
1390 for (i = 0; i < len; i++)
1391 {
1392 IXMLDOMNode *node;
1393 if (i > 0)
1394 *(pos++) = ' ';
1395 ole_check(IXMLDOMNodeList_nextNode(list, &node));
1396 node_to_string(node, pos);
1397 pos += strlen(pos);
1398 IXMLDOMNode_Release(node);
1399 }
1400 *pos = 0;
1401 return buf;
1402}
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
node_to_string
static void node_to_string(IXMLDOMNode *node, char *buf)
Definition: domdoc.c:1326
ole_check
#define ole_check(expr)
Definition: domdoc.c:1203

Referenced by test_load(), test_XPath(), and test_XSLPattern().

◆ node_to_string()

static void node_to_string ( IXMLDOMNode *  node,
char *  buf 
)
static

Definition at line 1326 of file domdoc.c.

1327{
1328 HRESULT r = S_OK;
1329 DOMNodeType type;
1330
1331 if (node == NULL)
1332 {
1333 lstrcpyA(buf, "(null)");
1334 return;
1335 }
1336
1337 IXMLDOMNode_AddRef(node);
1338 while (r == S_OK)
1339 {
1340 IXMLDOMNode *new_node;
1341
1342 ole_check(IXMLDOMNode_get_nodeType(node, &type));
1343 get_str_for_type(type, buf);
1344 buf+=strlen(buf);
1345
1346 if (type == NODE_ATTRIBUTE)
1347 {
1348 BSTR bstr;
1349 ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
1350 *(buf++) = '\'';
1351 wsprintfA(buf, "%ws", bstr);
1352 buf += strlen(buf);
1353 *(buf++) = '\'';
1354 SysFreeString(bstr);
1355
1356 r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
1357 }
1358 else
1359 {
1360 r = IXMLDOMNode_get_parentNode(node, &new_node);
1361 sprintf(buf, "%d", get_node_position(node));
1362 buf += strlen(buf);
1363 }
1364
1365 ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
1366 IXMLDOMNode_Release(node);
1367 node = new_node;
1368 if (r == S_OK)
1369 *(buf++) = '.';
1370 }
1371
1372 *buf = 0;
1373}
lstrcpyA
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100
sprintf
#define sprintf(buf, format,...)
Definition: sprintf.c:55
get_str_for_type
static void get_str_for_type(DOMNodeType type, char *buf)
Definition: domdoc.c:1280
get_node_position
static int get_node_position(IXMLDOMNode *node)
Definition: domdoc.c:1307
DOMNodeType
enum tagDOMNodeType DOMNodeType

Referenced by list_to_string().

◆ response_Add()

static HRESULT WINAPI response_Add ( IResponse *  iface,
BSTR  bstrHeaderValue,
BSTR  bstrHeaderName 
)
static

Definition at line 473 of file domdoc.c.

474{
475 ok(0, "unexpected call\n");
476 return E_NOTIMPL;
477}

◆ response_AddHeader()

static HRESULT WINAPI response_AddHeader ( IResponse *  iface,
BSTR  bstrHeaderName,
BSTR  bstrHeaderValue 
)
static

Definition at line 479 of file domdoc.c.

480{
481 ok(0, "unexpected call\n");
482 return E_NOTIMPL;
483}

◆ response_AddRef()

static ULONG WINAPI response_AddRef ( IResponse *  iface)
static

Definition at line 371 of file domdoc.c.

372{
373 return 2;
374}

◆ response_AppendToLog()

static HRESULT WINAPI response_AppendToLog ( IResponse *  iface,
BSTR  bstrLogEntry 
)
static

Definition at line 485 of file domdoc.c.

486{
487 ok(0, "unexpected call\n");
488 return E_NOTIMPL;
489}

◆ response_BinaryWrite()

static HRESULT WINAPI response_BinaryWrite ( IResponse *  iface,
VARIANT  input 
)
static

Definition at line 491 of file domdoc.c.

492{
493 HRESULT hr;
494 LONG bound;
495 UINT dim;
496
497 ok(V_VT(&input) == (VT_ARRAY | VT_UI1), "got wrong input type %x\n", V_VT(&input));
498
499 dim = SafeArrayGetDim(V_ARRAY(&input));
500 ok(dim == 1, "got wrong array dimensions %u\n", dim);
501
502 bound = 1;
503 hr = SafeArrayGetLBound(V_ARRAY(&input), 1, &bound);
504 ok(hr == S_OK, "got %#x\n", hr);
505 ok(bound == 0, "wrong array low bound %d\n", bound);
506
507 bound = 0;
508 hr = SafeArrayGetUBound(V_ARRAY(&input), 1, &bound);
509 ok(hr == S_OK, "got %#x\n", hr);
510 ok(bound > 0, "wrong array high bound %d\n", bound);
511
512 return E_NOTIMPL;
513}
VT_ARRAY
@ VT_ARRAY
Definition: compat.h:2341
VT_UI1
@ VT_UI1
Definition: compat.h:2311
SafeArrayGetUBound
HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY *psa, UINT nDim, LONG *plUbound)
Definition: safearray.c:1033
SafeArrayGetDim
UINT WINAPI SafeArrayGetDim(SAFEARRAY *psa)
Definition: safearray.c:1094
SafeArrayGetLBound
HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY *psa, UINT nDim, LONG *plLbound)
Definition: safearray.c:1066
input
GLenum GLenum GLenum input
Definition: glext.h:9031
UINT
unsigned int UINT
Definition: ndis.h:50
V_ARRAY
#define V_ARRAY(A)
Definition: oleauto.h:222

◆ response_Clear()

static HRESULT WINAPI response_Clear ( IResponse *  iface)
static

Definition at line 515 of file domdoc.c.

516{
517 ok(0, "unexpected call\n");
518 return E_NOTIMPL;
519}

◆ response_End()

static HRESULT WINAPI response_End ( IResponse *  iface)
static

Definition at line 521 of file domdoc.c.

522{
523 ok(0, "unexpected call\n");
524 return E_NOTIMPL;
525}

◆ response_Flush()

static HRESULT WINAPI response_Flush ( IResponse *  iface)
static

Definition at line 527 of file domdoc.c.

528{
529 ok(0, "unexpected call\n");
530 return E_NOTIMPL;
531}

◆ response_get_Buffer()

static HRESULT WINAPI response_get_Buffer ( IResponse *  iface,
VARIANT_BOOL *  fIsBuffering 
)
static

Definition at line 407 of file domdoc.c.

408{
409 ok(0, "unexpected call\n");
410 return E_NOTIMPL;
411}

◆ response_get_CacheControl()

static HRESULT WINAPI response_get_CacheControl ( IResponse *  iface,
BSTR *  pbstrCacheControl 
)
static

Definition at line 575 of file domdoc.c.

576{
577 ok(0, "unexpected call\n");
578 return E_NOTIMPL;
579}

◆ response_get_CharSet()

static HRESULT WINAPI response_get_CharSet ( IResponse *  iface,
BSTR *  pbstrCharSetRet 
)
static

Definition at line 557 of file domdoc.c.

558{
559 ok(0, "unexpected call\n");
560 return E_NOTIMPL;
561}

◆ response_get_CodePage()

static HRESULT WINAPI response_get_CodePage ( IResponse *  iface,
LONG *  plvar 
)
static

Definition at line 587 of file domdoc.c.

588{
589 ok(0, "unexpected call\n");
590 return E_NOTIMPL;
591}

◆ response_get_ContentType()

static HRESULT WINAPI response_get_ContentType ( IResponse *  iface,
BSTR *  pbstrContentTypeRet 
)
static

Definition at line 419 of file domdoc.c.

420{
421 ok(0, "unexpected call\n");
422 return E_NOTIMPL;
423}

◆ response_get_Cookies()

static HRESULT WINAPI response_get_Cookies ( IResponse *  iface,
IRequestDictionary **  ppCookies 
)
static

Definition at line 455 of file domdoc.c.

456{
457 ok(0, "unexpected call\n");
458 return E_NOTIMPL;
459}

◆ response_get_Expires()

static HRESULT WINAPI response_get_Expires ( IResponse *  iface,
VARIANT *  pvarExpiresMinutesRet 
)
static

Definition at line 431 of file domdoc.c.

432{
433 ok(0, "unexpected call\n");
434 return E_NOTIMPL;
435}

◆ response_get_ExpiresAbsolute()

static HRESULT WINAPI response_get_ExpiresAbsolute ( IResponse *  iface,
VARIANT *  pvarExpiresRet 
)
static

Definition at line 443 of file domdoc.c.

444{
445 ok(0, "unexpected call\n");
446 return E_NOTIMPL;
447}

◆ response_get_LCID()

static HRESULT WINAPI response_get_LCID ( IResponse *  iface,
LONG *  lcid 
)
static

Definition at line 599 of file domdoc.c.

600{
601 ok(0, "unexpected call\n");
602 return E_NOTIMPL;
603}

◆ response_get_Status()

static HRESULT WINAPI response_get_Status ( IResponse *  iface,
BSTR *  pbstrStatusRet 
)
static

Definition at line 461 of file domdoc.c.

462{
463 ok(0, "unexpected call\n");
464 return E_NOTIMPL;
465}

◆ response_GetIDsOfNames()

static HRESULT WINAPI response_GetIDsOfNames ( IResponse *  iface,
REFIID  riid,
LPOLESTR *  names,
UINT  cnames,
LCID  lcid,
DISPID *  rgDispId 
)
static

Definition at line 393 of file domdoc.c.

395{
396 ok(0, "unexpected call\n");
397 return E_NOTIMPL;
398}

◆ response_GetTypeInfo()

static HRESULT WINAPI response_GetTypeInfo ( IResponse *  iface,
UINT  ti,
LCID  lcid,
ITypeInfo **  tinfo 
)
static

Definition at line 387 of file domdoc.c.

388{
389 ok(0, "unexpected call\n");
390 return E_NOTIMPL;
391}

◆ response_GetTypeInfoCount()

static HRESULT WINAPI response_GetTypeInfoCount ( IResponse *  iface,
UINT *  count 
)
static

Definition at line 381 of file domdoc.c.

382{
383 ok(0, "unexpected call\n");
384 return E_NOTIMPL;
385}

◆ response_Invoke()

static HRESULT WINAPI response_Invoke ( IResponse *  iface,
DISPID  dispid,
REFIID  riid,
LCID  lcid,
WORD  flags,
DISPPARAMS *  params,
VARIANT *  result,
EXCEPINFO *  ei,
UINT *  argerr 
)
static

Definition at line 400 of file domdoc.c.

402{
403 ok(0, "unexpected call\n");
404 return E_NOTIMPL;
405}

◆ response_IsClientConnected()

static HRESULT WINAPI response_IsClientConnected ( IResponse *  iface,
VARIANT_BOOL *  pfIsClientConnected 
)
static

Definition at line 551 of file domdoc.c.

552{
553 ok(0, "unexpected call\n");
554 return E_NOTIMPL;
555}

◆ response_Pics()

static HRESULT WINAPI response_Pics ( IResponse *  iface,
BSTR  bstrHeaderValue 
)
static

Definition at line 569 of file domdoc.c.

570{
571 ok(0, "unexpected call\n");
572 return E_NOTIMPL;
573}

◆ response_put_Buffer()

static HRESULT WINAPI response_put_Buffer ( IResponse *  iface,
VARIANT_BOOL  fIsBuffering 
)
static

Definition at line 413 of file domdoc.c.

414{
415 ok(0, "unexpected call\n");
416 return E_NOTIMPL;
417}

◆ response_put_CacheControl()

static HRESULT WINAPI response_put_CacheControl ( IResponse *  iface,
BSTR  bstrCacheControl 
)
static

Definition at line 581 of file domdoc.c.

582{
583 ok(0, "unexpected call\n");
584 return E_NOTIMPL;
585}

◆ response_put_CharSet()

static HRESULT WINAPI response_put_CharSet ( IResponse *  iface,
BSTR  bstrCharSet 
)
static

Definition at line 563 of file domdoc.c.

564{
565 ok(0, "unexpected call\n");
566 return E_NOTIMPL;
567}

◆ response_put_CodePage()

static HRESULT WINAPI response_put_CodePage ( IResponse *  iface,
LONG  codepage 
)
static

Definition at line 593 of file domdoc.c.

594{
595 ok(0, "unexpected call\n");
596 return E_NOTIMPL;
597}

◆ response_put_ContentType()

static HRESULT WINAPI response_put_ContentType ( IResponse *  iface,
BSTR  bstrContentType 
)
static

Definition at line 425 of file domdoc.c.

426{
427 ok(0, "unexpected call\n");
428 return E_NOTIMPL;
429}

◆ response_put_Expires()

static HRESULT WINAPI response_put_Expires ( IResponse *  iface,
LONG  lExpiresMinutes 
)
static

Definition at line 437 of file domdoc.c.

438{
439 ok(0, "unexpected call\n");
440 return E_NOTIMPL;
441}

◆ response_put_ExpiresAbsolute()

static HRESULT WINAPI response_put_ExpiresAbsolute ( IResponse *  iface,
DATE  dtExpires 
)
static

Definition at line 449 of file domdoc.c.

450{
451 ok(0, "unexpected call\n");
452 return E_NOTIMPL;
453}

◆ response_put_LCID()

static HRESULT WINAPI response_put_LCID ( IResponse *  iface,
LONG  lcid 
)
static

Definition at line 605 of file domdoc.c.

606{
607 ok(0, "unexpected call\n");
608 return E_NOTIMPL;
609}

◆ response_put_Status()

static HRESULT WINAPI response_put_Status ( IResponse *  iface,
BSTR  bstrStatus 
)
static

Definition at line 467 of file domdoc.c.

468{
469 ok(0, "unexpected call\n");
470 return E_NOTIMPL;
471}

◆ response_QI()

static HRESULT WINAPI response_QI ( IResponse *  iface,
REFIID  riid,
void **  obj 
)
static

Definition at line 356 of file domdoc.c.

357{
358 if (IsEqualIID(&IID_IResponse, riid) ||
359 IsEqualIID(&IID_IDispatch, riid) ||
360 IsEqualIID(&IID_IUnknown, riid))
361 {
362 *obj = iface;
363 return S_OK;
364 }
365
366 if (!IsEqualIID(&IID_IStream, riid) && !IsEqualIID(&IID_ISequentialStream, riid))
367 ok(0, "unexpected call\n");
368 return E_NOINTERFACE;
369}

◆ response_Redirect()

static HRESULT WINAPI response_Redirect ( IResponse *  iface,
BSTR  bstrURL 
)
static

Definition at line 533 of file domdoc.c.

534{
535 ok(0, "unexpected call\n");
536 return E_NOTIMPL;
537}

◆ response_Release()

static ULONG WINAPI response_Release ( IResponse *  iface)
static

Definition at line 376 of file domdoc.c.

377{
378 return 1;
379}

◆ response_Write()

static HRESULT WINAPI response_Write ( IResponse *  iface,
VARIANT  varText 
)
static

Definition at line 539 of file domdoc.c.

540{
541 ok(0, "unexpected call\n");
542 return E_NOTIMPL;
543}

◆ response_WriteBlock()

static HRESULT WINAPI response_WriteBlock ( IResponse *  iface,
short  iBlockNumber 
)
static

Definition at line 545 of file domdoc.c.

546{
547 ok(0, "unexpected call\n");
548 return E_NOTIMPL;
549}

◆ START_TEST()

START_TEST ( domdoc  )

Definition at line 13036 of file domdoc.c.

13037{
13038 HRESULT hr;
13039
13040 hr = CoInitialize( NULL );
13041 ok( hr == S_OK, "failed to init com\n");
13042 if (hr != S_OK) return;
13043
13044 get_class_support_data(domdoc_support_data);
13045 if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument))
13046 {
13047 win_skip("DOMDocument2 is not supported. Skipping all tests.\n");
13048 CoUninitialize();
13049 return;
13050 }
13051
13052 test_domdoc();
13053 test_persiststream();
13054 test_domnode();
13055 test_refs();
13056 test_create();
13057 test_getElementsByTagName();
13058 test_get_text();
13059 test_get_childNodes();
13060 test_get_firstChild();
13061 test_get_lastChild();
13062 test_removeChild();
13063 test_replaceChild();
13064 test_removeNamedItem();
13065 test_IXMLDOMDocument2();
13066 test_whitespace();
13067 test_XPath();
13068 test_XSLPattern();
13069 test_cloneNode();
13070 test_xmlTypes();
13071 test_save();
13072 test_testTransforms();
13073 test_namespaces_basic();
13074 test_namespaces_change();
13075 test_FormattingXML();
13076 test_nodeTypedValue();
13077 test_TransformWithLoadingLocalFile();
13078 test_put_nodeValue();
13079 test_IObjectSafety();
13080 test_splitText();
13081 test_getQualifiedItem();
13082 test_removeQualifiedItem();
13083 test_get_ownerDocument();
13084 test_setAttributeNode();
13085 test_put_dataType();
13086 test_createNode();
13087 test_create_attribute();
13088 test_get_prefix();
13089 test_default_properties();
13090 test_selectSingleNode();
13091 test_events();
13092 test_createProcessingInstruction();
13093 test_put_nodeTypedValue();
13094 test_get_xml();
13095 test_insertBefore();
13096 test_appendChild();
13097 test_get_doctype();
13098 test_get_tagName();
13099 test_get_dataType();
13100 test_get_nodeTypeString();
13101 test_get_attributes();
13102 test_selection();
13103 test_load();
13104 test_dispex();
13105 test_parseerror();
13106 test_getAttributeNode();
13107 test_getAttribute();
13108 test_supporterrorinfo();
13109 test_nodeValue();
13110 test_get_namespaces();
13111 test_put_data();
13112 test_newline_normalization();
13113 test_putref_schemas();
13114 test_namedmap_newenum();
13115 test_xmlns_attribute();
13116 test_url();
13117 test_merging_text();
13118 test_transformNodeToObject();
13119 test_normalize_attribute_values();
13120 test_namespaces_as_attributes();
13121
13122 test_xsltemplate();
13123 test_xsltext();
13124
13125 if (is_clsid_supported(&CLSID_MXNamespaceManager40, &IID_IMXNamespaceManager))
13126 {
13127 test_mxnamespacemanager();
13128 test_mxnamespacemanager_override();
13129 }
13130
13131 CoUninitialize();
13132}
CoInitialize
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1964
CoUninitialize
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
test_put_data
static void test_put_data(void)
Definition: domdoc.c:12078
test_xmlns_attribute
static void test_xmlns_attribute(void)
Definition: domdoc.c:11754
test_get_xml
static void test_get_xml(void)
Definition: domdoc.c:8721
test_put_nodeValue
static void test_put_nodeValue(void)
Definition: domdoc.c:7110
test_getQualifiedItem
static void test_getQualifiedItem(void)
Definition: domdoc.c:7671
test_whitespace
static void test_whitespace(void)
Definition: domdoc.c:4657
test_get_lastChild
static void test_get_lastChild(void)
Definition: domdoc.c:3757
test_get_prefix
static void test_get_prefix(void)
Definition: domdoc.c:8268
test_get_childNodes
static void test_get_childNodes(void)
Definition: domdoc.c:3560
test_get_doctype
static void test_get_doctype(void)
Definition: domdoc.c:9472
test_appendChild
static void test_appendChild(void)
Definition: domdoc.c:9427
test_removeNamedItem
static void test_removeNamedItem(void)
Definition: domdoc.c:4009
test_getAttribute
static void test_getAttribute(void)
Definition: domdoc.c:11472
test_get_dataType
static void test_get_dataType(void)
Definition: domdoc.c:9572
test_save
static void test_save(void)
Definition: domdoc.c:6403
test_get_namespaces
static void test_get_namespaces(void)
Definition: domdoc.c:11828
test_get_ownerDocument
static void test_get_ownerDocument(void)
Definition: domdoc.c:7911
test_setAttributeNode
static void test_setAttributeNode(void)
Definition: domdoc.c:8034
test_refs
static void test_refs(void)
Definition: domdoc.c:2594
get_class_support_data
static void get_class_support_data(struct msxmlsupported_data_t *table)
Definition: domdoc.c:97
test_get_text
static void test_get_text(void)
Definition: domdoc.c:3442
test_nodeValue
static void test_nodeValue(void)
Definition: domdoc.c:11710
test_selectSingleNode
static void test_selectSingleNode(void)
Definition: domdoc.c:8381
test_put_dataType
static void test_put_dataType(void)
Definition: domdoc.c:6311
test_transformNodeToObject
static void test_transformNodeToObject(void)
Definition: domdoc.c:12787
test_mxnamespacemanager
static void test_mxnamespacemanager(void)
Definition: domdoc.c:10471
test_get_attributes
static void test_get_attributes(void)
Definition: domdoc.c:9684
test_testTransforms
static void test_testTransforms(void)
Definition: domdoc.c:6535
test_create
static void test_create(void)
Definition: domdoc.c:2892
test_domdoc
static void test_domdoc(void)
Definition: domdoc.c:1439
test_domnode
static void test_domnode(void)
Definition: domdoc.c:2194
test_nodeTypedValue
static void test_nodeTypedValue(void)
Definition: domdoc.c:6818
test_get_firstChild
static void test_get_firstChild(void)
Definition: domdoc.c:3727
test_getAttributeNode
static void test_getAttributeNode(void)
Definition: domdoc.c:11419
test_normalize_attribute_values
static void test_normalize_attribute_values(void)
Definition: domdoc.c:12830
test_namespaces_change
static void test_namespaces_change(void)
Definition: domdoc.c:6589
test_getElementsByTagName
static void test_getElementsByTagName(void)
Definition: domdoc.c:3356
test_IObjectSafety
static void test_IObjectSafety(void)
Definition: domdoc.c:7200
test_namespaces_as_attributes
static void test_namespaces_as_attributes(void)
Definition: domdoc.c:12884
test_cloneNode
static void test_cloneNode(void)
Definition: domdoc.c:5183
test_insertBefore
static void test_insertBefore(void)
Definition: domdoc.c:9060
test_supporterrorinfo
static void test_supporterrorinfo(void)
Definition: domdoc.c:11539
test_newline_normalization
static void test_newline_normalization(void)
Definition: domdoc.c:12185
test_persiststream
static void test_persiststream(void)
Definition: domdoc.c:2150
test_parseerror
static void test_parseerror(void)
Definition: domdoc.c:11383
test_createNode
static void test_createNode(void)
Definition: domdoc.c:8180
test_createProcessingInstruction
static void test_createProcessingInstruction(void)
Definition: domdoc.c:8514
test_replaceChild
static void test_replaceChild(void)
Definition: domdoc.c:3897
test_url
static void test_url(void)
Definition: domdoc.c:12671
test_xmlTypes
static void test_xmlTypes(void)
Definition: domdoc.c:5332
test_removeChild
static void test_removeChild(void)
Definition: domdoc.c:3798
test_XPath
static void test_XPath(void)
Definition: domdoc.c:4857
test_xsltext
static void test_xsltext(void)
Definition: domdoc.c:12540
test_putref_schemas
static void test_putref_schemas(void)
Definition: domdoc.c:12325
test_mxnamespacemanager_override
static void test_mxnamespacemanager_override(void)
Definition: domdoc.c:10860
test_namedmap_newenum
static void test_namedmap_newenum(void)
Definition: domdoc.c:12399
test_xsltemplate
static void test_xsltemplate(void)
Definition: domdoc.c:8837
test_merging_text
static void test_merging_text(void)
Definition: domdoc.c:12690
test_load
static void test_load(void)
Definition: domdoc.c:10247
test_default_properties
static void test_default_properties(void)
Definition: domdoc.c:7242
test_create_attribute
static void test_create_attribute(void)
Definition: domdoc.c:12595
test_get_nodeTypeString
static void test_get_nodeTypeString(void)
Definition: domdoc.c:9627
test_IXMLDOMDocument2
static void test_IXMLDOMDocument2(void)
Definition: domdoc.c:4224
test_events
static void test_events(void)
Definition: domdoc.c:8445
test_put_nodeTypedValue
static void test_put_nodeTypedValue(void)
Definition: domdoc.c:8535
is_clsid_supported
static BOOL is_clsid_supported(const GUID *clsid, REFIID riid)
Definition: domdoc.c:118
test_removeQualifiedItem
static void test_removeQualifiedItem(void)
Definition: domdoc.c:7772
test_selection
static void test_selection(void)
Definition: domdoc.c:9927
test_get_tagName
static void test_get_tagName(void)
Definition: domdoc.c:9517
test_FormattingXML
static void test_FormattingXML(void)
Definition: domdoc.c:6747
test_namespaces_basic
static void test_namespaces_basic(void)
Definition: domdoc.c:6654
test_splitText
static void test_splitText(void)
Definition: domdoc.c:7527
test_dispex
static void test_dispex(void)
Definition: domdoc.c:10979
test_XSLPattern
static void test_XSLPattern(void)
Definition: domdoc.c:7378
test_TransformWithLoadingLocalFile
static void test_TransformWithLoadingLocalFile(void)
Definition: domdoc.c:7026

◆ test_appendChild()

static void test_appendChild ( void  )
static

Definition at line 9427 of file domdoc.c.

9428{
9429 IXMLDOMDocument *doc, *doc2;
9430 IXMLDOMElement *elem, *elem2;
9431 HRESULT hr;
9432
9433 doc = create_document(&IID_IXMLDOMDocument);
9434 doc2 = create_document(&IID_IXMLDOMDocument);
9435
9436 hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
9437 ok(hr == S_OK, "got 0x%08x\n", hr);
9438
9439 hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem2"), &elem2);
9440 ok(hr == S_OK, "got 0x%08x\n", hr);
9441
9442 EXPECT_REF(doc, 1);
9443 todo_wine EXPECT_REF(elem, 2);
9444 EXPECT_REF(doc2, 1);
9445 todo_wine EXPECT_REF(elem2, 2);
9446 EXPECT_NO_CHILDREN(doc);
9447 EXPECT_NO_CHILDREN(doc2);
9448
9449 hr = IXMLDOMDocument_appendChild(doc2, NULL, NULL);
9450 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9451
9452 hr = IXMLDOMElement_appendChild(elem, NULL, NULL);
9453 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9454
9455 /* append from another document */
9456 hr = IXMLDOMDocument_appendChild(doc2, (IXMLDOMNode*)elem, NULL);
9457 ok(hr == S_OK, "got 0x%08x\n", hr);
9458
9459 EXPECT_REF(doc, 1);
9460 todo_wine EXPECT_REF(elem, 2);
9461 EXPECT_REF(doc2, 1);
9462 todo_wine EXPECT_REF(elem2, 2);
9463 EXPECT_NO_CHILDREN(doc);
9464 EXPECT_CHILDREN(doc2);
9465
9466 IXMLDOMElement_Release(elem);
9467 IXMLDOMElement_Release(elem2);
9468 IXMLDOMDocument_Release(doc);
9469 IXMLDOMDocument_Release(doc2);
9470}
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101
todo_wine
#define todo_wine
Definition: custom.c:89
elem
static size_t elem
Definition: string.c:69
EXPECT_CHILDREN
#define EXPECT_CHILDREN(node)
Definition: domdoc.c:655
EXPECT_REF
#define EXPECT_REF(node, ref)
Definition: domdoc.c:679
create_document
#define create_document(iid)
Definition: domdoc.c:1228
EXPECT_NO_CHILDREN
#define EXPECT_NO_CHILDREN(node)
Definition: domdoc.c:667

Referenced by START_TEST().

◆ test_cloneNode()

static void test_cloneNode ( void  )
static

Definition at line 5183 of file domdoc.c.

5184{
5185 IXMLDOMDocument2 *doc, *doc_clone;
5186 IXMLDOMDocument *doc2;
5187 VARIANT_BOOL b;
5188 IXMLDOMNodeList *pList;
5189 IXMLDOMNamedNodeMap *mapAttr;
5190 LONG length, length1;
5191 LONG attr_cnt, attr_cnt1;
5192 IXMLDOMNode *node, *attr;
5193 IXMLDOMNode *node_clone;
5194 IXMLDOMNode *node_first;
5195 VARIANT v;
5196 HRESULT hr;
5197
5198 doc = create_document(&IID_IXMLDOMDocument2);
5199
5200 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b);
5201 ok(hr == S_OK, "got 0x%08x\n", hr);
5202 ok(b == VARIANT_TRUE, "failed to load XML string\n");
5203
5204 hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &v);
5205 ok(hr == S_OK, "got 0x%08x\n", hr);
5206 ok(!lstrcmpW(V_BSTR(&v), _bstr_("XSLPattern")), "got prop value %s\n", wine_dbgstr_w(V_BSTR(&v)));
5207 VariantClear(&v);
5208
5209 V_BSTR(&v) = _bstr_("XPath");
5210 V_VT(&v) = VT_BSTR;
5211 hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), v);
5212 ok(hr == S_OK, "got 0x%08x\n", hr);
5213 VariantClear(&v);
5214
5215 /* clone document node */
5216 hr = IXMLDOMDocument2_cloneNode(doc, VARIANT_TRUE, &node);
5217 ok( hr == S_OK, "ret %08x\n", hr );
5218 ok( node != NULL, "node %p\n", node );
5219
5220 hr = IXMLDOMNode_get_childNodes(node, &pList);
5221 ok( hr == S_OK, "ret %08x\n", hr );
5222 length = 0;
5223 hr = IXMLDOMNodeList_get_length(pList, &length);
5224 ok( hr == S_OK, "ret %08x\n", hr );
5225 ok(length == 2, "got %d\n", length);
5226 IXMLDOMNodeList_Release(pList);
5227
5228 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMDocument2, (void**)&doc_clone);
5229 ok(hr == S_OK, "got 0x%08x\n", hr);
5230
5231 /* cloned document inherits properties */
5232 hr = IXMLDOMDocument2_getProperty(doc_clone, _bstr_("SelectionLanguage"), &v);
5233 ok(hr == S_OK, "got 0x%08x\n", hr);
5234 ok(!lstrcmpW(V_BSTR(&v), _bstr_("XPath")), "got prop value %s\n", wine_dbgstr_w(V_BSTR(&v)));
5235 VariantClear(&v);
5236
5237 IXMLDOMDocument2_Release(doc_clone);
5238 IXMLDOMNode_Release(node);
5239
5240 hr = IXMLDOMDocument2_selectSingleNode(doc, _bstr_("lc/pr"), &node);
5241 ok( hr == S_OK, "ret %08x\n", hr );
5242 ok( node != NULL, "node %p\n", node );
5243
5244 /* Check invalid parameter */
5245 hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
5246 ok( hr == E_INVALIDARG, "ret %08x\n", hr );
5247
5248 /* All Children */
5249 hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
5250 ok( hr == S_OK, "ret %08x\n", hr );
5251 ok( node_clone != NULL, "node %p\n", node );
5252
5253 hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
5254 ok( hr == S_OK, "ret %08x\n", hr );
5255 hr = IXMLDOMNode_get_ownerDocument(node_clone, &doc2);
5256 ok( hr == S_OK, "ret %08x\n", hr );
5257 IXMLDOMDocument_Release(doc2);
5258 IXMLDOMNode_Release(node_first);
5259
5260 hr = IXMLDOMNode_get_childNodes(node, &pList);
5261 ok( hr == S_OK, "ret %08x\n", hr );
5262 length = 0;
5263 hr = IXMLDOMNodeList_get_length(pList, &length);
5264 ok( hr == S_OK, "ret %08x\n", hr );
5265 ok(length == 1, "got %d\n", length);
5266 IXMLDOMNodeList_Release(pList);
5267
5268 hr = IXMLDOMNode_get_attributes(node, &mapAttr);
5269 ok( hr == S_OK, "ret %08x\n", hr );
5270 attr_cnt = 0;
5271 hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt);
5272 ok( hr == S_OK, "ret %08x\n", hr );
5273 ok(attr_cnt == 3, "got %d\n", attr_cnt);
5274 IXMLDOMNamedNodeMap_Release(mapAttr);
5275
5276 hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
5277 ok( hr == S_OK, "ret %08x\n", hr );
5278 length1 = 0;
5279 hr = IXMLDOMNodeList_get_length(pList, &length1);
5280 ok(length1 == 1, "got %d\n", length1);
5281 ok( hr == S_OK, "ret %08x\n", hr );
5282 IXMLDOMNodeList_Release(pList);
5283
5284 hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
5285 ok( hr == S_OK, "ret %08x\n", hr );
5286 attr_cnt1 = 0;
5287 hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
5288 ok( hr == S_OK, "ret %08x\n", hr );
5289 ok(attr_cnt1 == 3, "got %d\n", attr_cnt1);
5290 /* now really get some attributes from cloned element */
5291 attr = NULL;
5292 hr = IXMLDOMNamedNodeMap_getNamedItem(mapAttr, _bstr_("id"), &attr);
5293 ok(hr == S_OK, "ret %08x\n", hr);
5294 IXMLDOMNode_Release(attr);
5295 IXMLDOMNamedNodeMap_Release(mapAttr);
5296
5297 ok(length == length1, "wrong Child count (%d, %d)\n", length, length1);
5298 ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
5299 IXMLDOMNode_Release(node_clone);
5300
5301 /* No Children */
5302 hr = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
5303 ok( hr == S_OK, "ret %08x\n", hr );
5304 ok( node_clone != NULL, "node %p\n", node );
5305
5306 hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
5307 ok(hr == S_FALSE, "ret %08x\n", hr );
5308
5309 hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
5310 ok(hr == S_OK, "ret %08x\n", hr );
5311 hr = IXMLDOMNodeList_get_length(pList, &length1);
5312 ok(hr == S_OK, "ret %08x\n", hr );
5313 ok( length1 == 0, "Length should be 0 (%d)\n", length1);
5314 IXMLDOMNodeList_Release(pList);
5315
5316 hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
5317 ok(hr == S_OK, "ret %08x\n", hr );
5318 hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
5319 ok(hr == S_OK, "ret %08x\n", hr );
5320 ok(attr_cnt1 == 3, "Attribute count should be 3 (%d)\n", attr_cnt1);
5321 IXMLDOMNamedNodeMap_Release(mapAttr);
5322
5323 ok(length != length1, "wrong Child count (%d, %d)\n", length, length1);
5324 ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
5325 IXMLDOMNode_Release(node_clone);
5326
5327 IXMLDOMNode_Release(node);
5328 IXMLDOMDocument2_Release(doc);
5329 free_bstrs();
5330}
pList
FxChildList * pList
Definition: fxchildlistapi.cpp:55
free_bstrs
static void free_bstrs(void)
Definition: domdoc.c:1251
complete4A
static const char complete4A[]
Definition: domdoc.c:723
attr
Definition: cookie.c:202

Referenced by START_TEST().

◆ test_create()

static void test_create ( void  )
static

Definition at line 2892 of file domdoc.c.

2893{
2894 static const WCHAR szOne[] = {'1',0};
2895 static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
2896 HRESULT r;
2897 VARIANT var;
2898 BSTR str, name;
2899 IXMLDOMDocument *doc;
2900 IXMLDOMElement *element;
2901 IXMLDOMComment *comment;
2902 IXMLDOMText *text;
2903 IXMLDOMCDATASection *cdata;
2904 IXMLDOMNode *root, *node, *child;
2905 IXMLDOMNamedNodeMap *attr_map;
2906 IUnknown *unk;
2907 LONG ref;
2908 LONG num;
2909
2910 doc = create_document(&IID_IXMLDOMDocument);
2911
2912 EXPECT_REF(doc, 1);
2913
2914 /* types not supported for creation */
2915 V_VT(&var) = VT_I1;
2916 V_I1(&var) = NODE_DOCUMENT;
2917 node = (IXMLDOMNode*)0x1;
2918 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2919 ok( r == E_INVALIDARG, "returns %08x\n", r );
2920 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2921
2922 V_VT(&var) = VT_I1;
2923 V_I1(&var) = NODE_DOCUMENT_TYPE;
2924 node = (IXMLDOMNode*)0x1;
2925 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2926 ok( r == E_INVALIDARG, "returns %08x\n", r );
2927 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2928
2929 V_VT(&var) = VT_I1;
2930 V_I1(&var) = NODE_ENTITY;
2931 node = (IXMLDOMNode*)0x1;
2932 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2933 ok( r == E_INVALIDARG, "returns %08x\n", r );
2934 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2935
2936 V_VT(&var) = VT_I1;
2937 V_I1(&var) = NODE_NOTATION;
2938 node = (IXMLDOMNode*)0x1;
2939 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2940 ok( r == E_INVALIDARG, "returns %08x\n", r );
2941 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2942
2943 /* NODE_COMMENT */
2944 V_VT(&var) = VT_I1;
2945 V_I1(&var) = NODE_COMMENT;
2946 node = NULL;
2947 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2948 ok( r == S_OK, "returns %08x\n", r );
2949 ok( node != NULL, "\n");
2950
2951 r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2952 ok( r == S_OK, "returns %08x\n", r );
2953 IXMLDOMNode_Release(node);
2954
2955 str = NULL;
2956 r = IXMLDOMComment_get_data(comment, &str);
2957 ok( r == S_OK, "returns %08x\n", r );
2958 ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2959 IXMLDOMComment_Release(comment);
2960 SysFreeString(str);
2961
2962 node = (IXMLDOMNode*)0x1;
2963 r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2964 ok( r == S_OK, "returns %08x\n", r );
2965
2966 r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2967 ok( r == S_OK, "returns %08x\n", r );
2968 IXMLDOMNode_Release(node);
2969
2970 str = NULL;
2971 r = IXMLDOMComment_get_data(comment, &str);
2972 ok( r == S_OK, "returns %08x\n", r );
2973 ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2974 IXMLDOMComment_Release(comment);
2975 SysFreeString(str);
2976
2977 node = (IXMLDOMNode*)0x1;
2978 r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2979 ok( r == S_OK, "returns %08x\n", r );
2980
2981 r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2982 ok( r == S_OK, "returns %08x\n", r );
2983 IXMLDOMNode_Release(node);
2984
2985 str = NULL;
2986 r = IXMLDOMComment_get_data(comment, &str);
2987 ok( r == S_OK, "returns %08x\n", r );
2988 ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2989 IXMLDOMComment_Release(comment);
2990 SysFreeString(str);
2991
2992 /* NODE_TEXT */
2993 V_VT(&var) = VT_I1;
2994 V_I1(&var) = NODE_TEXT;
2995 node = NULL;
2996 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2997 ok( r == S_OK, "returns %08x\n", r );
2998 ok( node != NULL, "\n");
2999
3000 r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3001 ok( r == S_OK, "returns %08x\n", r );
3002 IXMLDOMNode_Release(node);
3003
3004 str = NULL;
3005 r = IXMLDOMText_get_data(text, &str);
3006 ok( r == S_OK, "returns %08x\n", r );
3007 ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3008 IXMLDOMText_Release(text);
3009 SysFreeString(str);
3010
3011 node = (IXMLDOMNode*)0x1;
3012 r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3013 ok( r == S_OK, "returns %08x\n", r );
3014
3015 r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3016 ok( r == S_OK, "returns %08x\n", r );
3017 IXMLDOMNode_Release(node);
3018
3019 str = NULL;
3020 r = IXMLDOMText_get_data(text, &str);
3021 ok( r == S_OK, "returns %08x\n", r );
3022 ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3023 IXMLDOMText_Release(text);
3024 SysFreeString(str);
3025
3026 node = (IXMLDOMNode*)0x1;
3027 r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3028 ok( r == S_OK, "returns %08x\n", r );
3029
3030 r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3031 ok( r == S_OK, "returns %08x\n", r );
3032 IXMLDOMNode_Release(node);
3033
3034 str = NULL;
3035 r = IXMLDOMText_get_data(text, &str);
3036 ok( r == S_OK, "returns %08x\n", r );
3037 ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3038 IXMLDOMText_Release(text);
3039 SysFreeString(str);
3040
3041 /* NODE_CDATA_SECTION */
3042 V_VT(&var) = VT_I1;
3043 V_I1(&var) = NODE_CDATA_SECTION;
3044 node = NULL;
3045 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3046 ok( r == S_OK, "returns %08x\n", r );
3047 ok( node != NULL, "\n");
3048
3049 r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3050 ok( r == S_OK, "returns %08x\n", r );
3051 IXMLDOMNode_Release(node);
3052
3053 str = NULL;
3054 r = IXMLDOMCDATASection_get_data(cdata, &str);
3055 ok( r == S_OK, "returns %08x\n", r );
3056 ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3057 IXMLDOMCDATASection_Release(cdata);
3058 SysFreeString(str);
3059
3060 node = (IXMLDOMNode*)0x1;
3061 r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3062 ok( r == S_OK, "returns %08x\n", r );
3063
3064 r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3065 ok( r == S_OK, "returns %08x\n", r );
3066 IXMLDOMNode_Release(node);
3067
3068 str = NULL;
3069 r = IXMLDOMCDATASection_get_data(cdata, &str);
3070 ok( r == S_OK, "returns %08x\n", r );
3071 ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3072 IXMLDOMCDATASection_Release(cdata);
3073 SysFreeString(str);
3074
3075 node = (IXMLDOMNode*)0x1;
3076 r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3077 ok( r == S_OK, "returns %08x\n", r );
3078
3079 r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3080 ok( r == S_OK, "returns %08x\n", r );
3081 IXMLDOMNode_Release(node);
3082
3083 str = NULL;
3084 r = IXMLDOMCDATASection_get_data(cdata, &str);
3085 ok( r == S_OK, "returns %08x\n", r );
3086 ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3087 IXMLDOMCDATASection_Release(cdata);
3088 SysFreeString(str);
3089
3090 /* NODE_ATTRIBUTE */
3091 V_VT(&var) = VT_I1;
3092 V_I1(&var) = NODE_ATTRIBUTE;
3093 node = (IXMLDOMNode*)0x1;
3094 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3095 ok( r == E_FAIL, "returns %08x\n", r );
3096 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3097
3098 V_VT(&var) = VT_I1;
3099 V_I1(&var) = NODE_ATTRIBUTE;
3100 node = (IXMLDOMNode*)0x1;
3101 r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3102 ok( r == E_FAIL, "returns %08x\n", r );
3103 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3104
3105 V_VT(&var) = VT_I1;
3106 V_I1(&var) = NODE_ATTRIBUTE;
3107 str = SysAllocString( szlc );
3108 r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3109 ok( r == S_OK, "returns %08x\n", r );
3110 if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3111 SysFreeString(str);
3112
3113 /* a name is required for attribute, try a BSTR with first null wchar */
3114 V_VT(&var) = VT_I1;
3115 V_I1(&var) = NODE_ATTRIBUTE;
3116 str = SysAllocString( szstr1 );
3117 str[0] = 0;
3118 node = (IXMLDOMNode*)0x1;
3119 r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3120 ok( r == E_FAIL, "returns %08x\n", r );
3121 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3122 SysFreeString(str);
3123
3124 /* NODE_PROCESSING_INSTRUCTION */
3125 V_VT(&var) = VT_I1;
3126 V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3127 node = (IXMLDOMNode*)0x1;
3128 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3129 ok( r == E_FAIL, "returns %08x\n", r );
3130 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3131
3132 V_VT(&var) = VT_I1;
3133 V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3134 node = (IXMLDOMNode*)0x1;
3135 r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3136 ok( r == E_FAIL, "returns %08x\n", r );
3137 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3138
3139 V_VT(&var) = VT_I1;
3140 V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3141 r = IXMLDOMDocument_createNode( doc, var, _bstr_("pi"), NULL, NULL );
3142 ok( r == E_INVALIDARG, "returns %08x\n", r );
3143
3144 /* NODE_ENTITY_REFERENCE */
3145 V_VT(&var) = VT_I1;
3146 V_I1(&var) = NODE_ENTITY_REFERENCE;
3147 node = (IXMLDOMNode*)0x1;
3148 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3149 ok( r == E_FAIL, "returns %08x\n", r );
3150 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3151
3152 V_VT(&var) = VT_I1;
3153 V_I1(&var) = NODE_ENTITY_REFERENCE;
3154 node = (IXMLDOMNode*)0x1;
3155 r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3156 ok( r == E_FAIL, "returns %08x\n", r );
3157 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3158
3159 /* NODE_ELEMENT */
3160 V_VT(&var) = VT_I1;
3161 V_I1(&var) = NODE_ELEMENT;
3162 node = (IXMLDOMNode*)0x1;
3163 r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3164 ok( r == E_FAIL, "returns %08x\n", r );
3165 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3166
3167 V_VT(&var) = VT_I1;
3168 V_I1(&var) = NODE_ELEMENT;
3169 node = (IXMLDOMNode*)0x1;
3170 r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3171 ok( r == E_FAIL, "returns %08x\n", r );
3172 ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3173
3174 V_VT(&var) = VT_I1;
3175 V_I1(&var) = NODE_ELEMENT;
3176 str = SysAllocString( szlc );
3177 r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3178 ok( r == S_OK, "returns %08x\n", r );
3179 if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3180
3181 V_VT(&var) = VT_I1;
3182 V_I1(&var) = NODE_ELEMENT;
3183 r = IXMLDOMDocument_createNode( doc, var, str, NULL, NULL );
3184 ok( r == E_INVALIDARG, "returns %08x\n", r );
3185
3186 V_VT(&var) = VT_R4;
3187 V_R4(&var) = NODE_ELEMENT;
3188 r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3189 ok( r == S_OK, "returns %08x\n", r );
3190 if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3191
3192 V_VT(&var) = VT_BSTR;
3193 V_BSTR(&var) = SysAllocString( szOne );
3194 r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3195 ok( r == S_OK, "returns %08x\n", r );
3196 if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3197 VariantClear(&var);
3198
3199 V_VT(&var) = VT_BSTR;
3200 V_BSTR(&var) = SysAllocString( szOneGarbage );
3201 r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3202 ok( r == E_INVALIDARG, "returns %08x\n", r );
3203 if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3204 VariantClear(&var);
3205
3206 V_VT(&var) = VT_I4;
3207 V_I4(&var) = NODE_ELEMENT;
3208 r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3209 ok( r == S_OK, "returns %08x\n", r );
3210
3211 EXPECT_REF(doc, 1);
3212 r = IXMLDOMDocument_appendChild( doc, node, &root );
3213 ok( r == S_OK, "returns %08x\n", r );
3214 ok( node == root, "%p %p\n", node, root );
3215 EXPECT_REF(doc, 1);
3216
3217 EXPECT_REF(node, 2);
3218
3219 ref = IXMLDOMNode_Release( node );
3220 ok(ref == 1, "ref %d\n", ref);
3221 SysFreeString( str );
3222
3223 V_VT(&var) = VT_I4;
3224 V_I4(&var) = NODE_ELEMENT;
3225 str = SysAllocString( szbs );
3226 r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3227 ok( r == S_OK, "returns %08x\n", r );
3228 SysFreeString( str );
3229
3230 EXPECT_REF(node, 1);
3231
3232 r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk );
3233 ok( r == S_OK, "returns %08x\n", r );
3234
3235 EXPECT_REF(unk, 2);
3236
3237 V_VT(&var) = VT_EMPTY;
3238 child = NULL;
3239 r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
3240 ok( r == S_OK, "returns %08x\n", r );
3241 ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
3242
3243 todo_wine EXPECT_REF(unk, 4);
3244
3245 IXMLDOMNode_Release( child );
3246 IUnknown_Release( unk );
3247
3248 V_VT(&var) = VT_NULL;
3249 V_DISPATCH(&var) = (IDispatch*)node;
3250 r = IXMLDOMNode_insertBefore( root, node, var, &child );
3251 ok( r == S_OK, "returns %08x\n", r );
3252 ok( node == child, "%p %p\n", node, child );
3253 IXMLDOMNode_Release( child );
3254
3255 V_VT(&var) = VT_NULL;
3256 V_DISPATCH(&var) = (IDispatch*)node;
3257 r = IXMLDOMNode_insertBefore( root, node, var, NULL );
3258 ok( r == S_OK, "returns %08x\n", r );
3259 IXMLDOMNode_Release( node );
3260
3261 r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (void**)&element );
3262 ok( r == S_OK, "returns %08x\n", r );
3263
3264 r = IXMLDOMElement_get_attributes( element, &attr_map );
3265 ok( r == S_OK, "returns %08x\n", r );
3266 r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3267 ok( r == S_OK, "returns %08x\n", r );
3268 ok( num == 0, "num %d\n", num );
3269 IXMLDOMNamedNodeMap_Release( attr_map );
3270
3271 V_VT(&var) = VT_BSTR;
3272 V_BSTR(&var) = SysAllocString( szstr1 );
3273 name = SysAllocString( szdl );
3274 r = IXMLDOMElement_setAttribute( element, name, var );
3275 ok( r == S_OK, "returns %08x\n", r );
3276 r = IXMLDOMElement_get_attributes( element, &attr_map );
3277 ok( r == S_OK, "returns %08x\n", r );
3278 r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3279 ok( r == S_OK, "returns %08x\n", r );
3280 ok( num == 1, "num %d\n", num );
3281 IXMLDOMNamedNodeMap_Release( attr_map );
3282 VariantClear(&var);
3283
3284 V_VT(&var) = VT_BSTR;
3285 V_BSTR(&var) = SysAllocString( szstr2 );
3286 r = IXMLDOMElement_setAttribute( element, name, var );
3287 ok( r == S_OK, "returns %08x\n", r );
3288 r = IXMLDOMElement_get_attributes( element, &attr_map );
3289 ok( r == S_OK, "returns %08x\n", r );
3290 r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3291 ok( r == S_OK, "returns %08x\n", r );
3292 ok( num == 1, "num %d\n", num );
3293 IXMLDOMNamedNodeMap_Release( attr_map );
3294 VariantClear(&var);
3295 r = IXMLDOMElement_getAttribute( element, name, &var );
3296 ok( r == S_OK, "returns %08x\n", r );
3297 ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
3298 VariantClear(&var);
3299 SysFreeString(name);
3300
3301 V_VT(&var) = VT_BSTR;
3302 V_BSTR(&var) = SysAllocString( szstr1 );
3303 name = SysAllocString( szlc );
3304 r = IXMLDOMElement_setAttribute( element, name, var );
3305 ok( r == S_OK, "returns %08x\n", r );
3306 r = IXMLDOMElement_get_attributes( element, &attr_map );
3307 ok( r == S_OK, "returns %08x\n", r );
3308 r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3309 ok( r == S_OK, "returns %08x\n", r );
3310 ok( num == 2, "num %d\n", num );
3311 IXMLDOMNamedNodeMap_Release( attr_map );
3312 VariantClear(&var);
3313 SysFreeString(name);
3314
3315 V_VT(&var) = VT_I4;
3316 V_I4(&var) = 10;
3317 name = SysAllocString( szbs );
3318 r = IXMLDOMElement_setAttribute( element, name, var );
3319 ok( r == S_OK, "returns %08x\n", r );
3320 VariantClear(&var);
3321 r = IXMLDOMElement_getAttribute( element, name, &var );
3322 ok( r == S_OK, "returns %08x\n", r );
3323 ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
3324 VariantClear(&var);
3325 SysFreeString(name);
3326
3327 /* Create an Attribute */
3328 V_VT(&var) = VT_I4;
3329 V_I4(&var) = NODE_ATTRIBUTE;
3330 str = SysAllocString( szAttribute );
3331 r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3332 ok( r == S_OK, "returns %08x\n", r );
3333 ok( node != NULL, "node was null\n");
3334 SysFreeString(str);
3335
3336 IXMLDOMElement_Release( element );
3337 IXMLDOMNode_Release( root );
3338 IXMLDOMDocument_Release( doc );
3339}
root
struct _root root
VT_R4
@ VT_R4
Definition: compat.h:2299
VT_I1
@ VT_I1
Definition: compat.h:2310
VT_I4
@ VT_I4
Definition: compat.h:2298
VT_EMPTY
@ VT_EMPTY
Definition: compat.h:2295
text
const WCHAR * text
Definition: package.c:1794
num
GLuint GLuint num
Definition: glext.h:9618
comment
#define comment(fmt, arg1)
Definition: rebar.c:847
szAttribute
static const WCHAR szAttribute[]
Definition: domdoc.c:1179
szbs
static const WCHAR szbs[]
Definition: domdoc.c:1161
szlc
static const WCHAR szlc[]
Definition: domdoc.c:1160
szstr1
static const WCHAR szstr1[]
Definition: domdoc.c:1162
szdl
static const WCHAR szdl[]
Definition: domdoc.c:1158
szstr2
static const WCHAR szstr2[]
Definition: domdoc.c:1163
child
static HWND child
Definition: cursoricon.c:298
SysAllocString
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
SysStringLen
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196
V_I1
#define V_I1(A)
Definition: oleauto.h:243
V_I4
#define V_I4(A)
Definition: oleauto.h:247
V_R4
#define V_R4(A)
Definition: oleauto.h:260
_root
Definition: btrfs_drv.h:450
NODE_ENTITY_REFERENCE
@ NODE_ENTITY_REFERENCE
Definition: xmldom.idl:57
NODE_DOCUMENT_TYPE
@ NODE_DOCUMENT_TYPE
Definition: xmldom.idl:62
NODE_ENTITY
@ NODE_ENTITY
Definition: xmldom.idl:58
NODE_CDATA_SECTION
@ NODE_CDATA_SECTION
Definition: xmldom.idl:56
NODE_NOTATION
@ NODE_NOTATION
Definition: xmldom.idl:64
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by START_TEST().

◆ test_create_attribute()

static void test_create_attribute ( void  )
static

Definition at line 12595 of file domdoc.c.

12596{
12597 struct attrtest_t *ptr = attrtests;
12598 IXMLDOMElement *el;
12599 IXMLDOMDocument *doc;
12600 IXMLDOMNode *node, *node2;
12601 VARIANT var;
12602 HRESULT hr;
12603 int i = 0;
12604 BSTR str;
12605
12606 doc = create_document(&IID_IXMLDOMDocument);
12607
12608 while (ptr->name)
12609 {
12610 V_VT(&var) = VT_I1;
12611 V_I1(&var) = NODE_ATTRIBUTE;
12612 hr = IXMLDOMDocument_createNode(doc, var, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
12613 ok(hr == S_OK, "got 0x%08x\n", hr);
12614
12615 str = NULL;
12616 hr = IXMLDOMNode_get_prefix(node, &str);
12617 if (ptr->prefix)
12618 {
12619 ok(hr == S_OK, "%d: got 0x%08x\n", i, hr);
12620 ok(!lstrcmpW(str, _bstr_(ptr->prefix)), "%d: got prefix %s, expected %s\n", i, wine_dbgstr_w(str), ptr->prefix);
12621 }
12622 else
12623 {
12624 ok(hr == S_FALSE, "%d: got 0x%08x\n", i, hr);
12625 ok(str == NULL, "%d: got prefix %s\n", i, wine_dbgstr_w(str));
12626 }
12627 SysFreeString(str);
12628
12629 str = NULL;
12630 hr = IXMLDOMNode_get_namespaceURI(node, &str);
12631 ok(hr == S_OK, "%d: got 0x%08x\n", i, hr);
12632 ok(!lstrcmpW(str, _bstr_(ptr->href)), "%d: got uri %s, expected %s\n", i, wine_dbgstr_w(str), ptr->href);
12633 SysFreeString(str);
12634
12635 IXMLDOMNode_Release(node);
12636 free_bstrs();
12637
12638 i++;
12639 ptr++;
12640 }
12641
12642 V_VT(&var) = VT_I1;
12643 V_I1(&var) = NODE_ELEMENT;
12644 hr = IXMLDOMDocument_createNode(doc, var, _bstr_("e"), NULL, &node2);
12645 ok(hr == S_OK, "got 0x%08x\n", hr);
12646
12647 hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&el);
12648 ok(hr == S_OK, "got 0x%08x\n", hr);
12649 IXMLDOMNode_Release(node2);
12650
12651 V_VT(&var) = VT_I1;
12652 V_I1(&var) = NODE_ATTRIBUTE;
12653 hr = IXMLDOMDocument_createNode(doc, var, _bstr_("xmlns:a"), _bstr_("http://www.w3.org/2000/xmlns/"), &node);
12654 ok(hr == S_OK, "got 0x%08x\n", hr);
12655
12656 hr = IXMLDOMElement_setAttributeNode(el, (IXMLDOMAttribute*)node, NULL);
12657 ok(hr == S_OK, "got 0x%08x\n", hr);
12658
12659 /* for some reason default namespace uri is not reported */
12660 hr = IXMLDOMNode_get_namespaceURI(node, &str);
12661 ok(hr == S_OK, "got 0x%08x\n", hr);
12662 ok(!lstrcmpW(str, _bstr_("")), "got uri %s\n", wine_dbgstr_w(str));
12663 SysFreeString(str);
12664
12665 IXMLDOMNode_Release(node);
12666 IXMLDOMElement_Release(el);
12667 IXMLDOMDocument_Release(doc);
12668 free_bstrs();
12669}
ptr
static PVOID ptr
Definition: dispmode.c:27
attrtests
static struct attrtest_t attrtests[]
Definition: domdoc.c:12584
attrtest_t
Definition: domdoc.c:12577

Referenced by START_TEST().

◆ test_createNode()

static void test_createNode ( void  )
static

Definition at line 8180 of file domdoc.c.

8181{
8182 IXMLDOMDocument *doc;
8183 IXMLDOMElement *elem;
8184 IXMLDOMNode *node;
8185 VARIANT v, var;
8186 BSTR prefix, str;
8187 HRESULT hr;
8188 ULONG ref;
8189
8190 doc = create_document(&IID_IXMLDOMDocument);
8191
8192 EXPECT_REF(doc, 1);
8193
8194 /* reference count tests */
8195 hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
8196 ok( hr == S_OK, "got 0x%08x\n", hr);
8197
8198 /* initial reference is 2 */
8199todo_wine {
8200 EXPECT_REF(elem, 2);
8201 ref = IXMLDOMElement_Release(elem);
8202 ok(ref == 1, "got %d\n", ref);
8203 /* it's released already, attempt to release now will crash it */
8204}
8205
8206 hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
8207 ok( hr == S_OK, "got 0x%08x\n", hr);
8208 todo_wine EXPECT_REF(elem, 2);
8209 IXMLDOMDocument_Release(doc);
8210 todo_wine EXPECT_REF(elem, 2);
8211 IXMLDOMElement_Release(elem);
8212
8213 doc = create_document(&IID_IXMLDOMDocument);
8214
8215 /* NODE_ELEMENT nodes */
8216 /* 1. specified namespace */
8217 V_VT(&v) = VT_I4;
8218 V_I4(&v) = NODE_ELEMENT;
8219
8220 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("ns1:test"), _bstr_("http://winehq.org"), &node);
8221 ok( hr == S_OK, "got 0x%08x\n", hr);
8222 prefix = NULL;
8223 hr = IXMLDOMNode_get_prefix(node, &prefix);
8224 ok( hr == S_OK, "got 0x%08x\n", hr);
8225 ok(lstrcmpW(prefix, _bstr_("ns1")) == 0, "wrong prefix\n");
8226 SysFreeString(prefix);
8227 IXMLDOMNode_Release(node);
8228
8229 /* 2. default namespace */
8230 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("test"), _bstr_("http://winehq.org/default"), &node);
8231 ok( hr == S_OK, "got 0x%08x\n", hr);
8232 prefix = (void*)0xdeadbeef;
8233 hr = IXMLDOMNode_get_prefix(node, &prefix);
8234 ok( hr == S_FALSE, "got 0x%08x\n", hr);
8235 ok(prefix == 0, "expected empty prefix, got %p\n", prefix);
8236 /* check dump */
8237 hr = IXMLDOMNode_get_xml(node, &str);
8238 ok( hr == S_OK, "got 0x%08x\n", hr);
8239 ok( lstrcmpW(str, _bstr_("<test xmlns=\"http://winehq.org/default\"/>")) == 0,
8240 "got %s\n", wine_dbgstr_w(str));
8241 SysFreeString(str);
8242
8243 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
8244 ok( hr == S_OK, "got 0x%08x\n", hr);
8245
8246 V_VT(&var) = VT_BSTR;
8247 hr = IXMLDOMElement_getAttribute(elem, _bstr_("xmlns"), &var);
8248 ok( hr == S_FALSE, "got 0x%08x\n", hr);
8249 ok( V_VT(&var) == VT_NULL, "got %d\n", V_VT(&var));
8250
8251 str = NULL;
8252 hr = IXMLDOMElement_get_namespaceURI(elem, &str);
8253 ok( hr == S_OK, "got 0x%08x\n", hr);
8254 ok( lstrcmpW(str, _bstr_("http://winehq.org/default")) == 0, "expected default namespace\n");
8255 SysFreeString(str);
8256
8257 IXMLDOMElement_Release(elem);
8258 IXMLDOMNode_Release(node);
8259
8260 IXMLDOMDocument_Release(doc);
8261 free_bstrs();
8262}
prefix
Character const *const prefix
Definition: tempnam.cpp:195

Referenced by START_TEST().

◆ test_createProcessingInstruction()

static void test_createProcessingInstruction ( void  )
static

Definition at line 8514 of file domdoc.c.

8515{
8516 static const WCHAR bodyW[] = {'t','e','s','t',0};
8517 IXMLDOMProcessingInstruction *pi;
8518 IXMLDOMDocument *doc;
8519 WCHAR buff[10];
8520 HRESULT hr;
8521
8522 doc = create_document(&IID_IXMLDOMDocument);
8523
8524 /* test for BSTR handling, pass broken BSTR */
8525 memcpy(&buff[2], bodyW, sizeof(bodyW));
8526 /* just a big length */
8527 *(DWORD*)buff = 0xf0f0;
8528 hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("test"), &buff[2], &pi);
8529 ok(hr == S_OK, "got 0x%08x\n", hr);
8530
8531 IXMLDOMProcessingInstruction_Release(pi);
8532 IXMLDOMDocument_Release(doc);
8533}
buff
static unsigned char buff[32768]
Definition: fatten.c:17
bodyW
static const WCHAR bodyW[]
Definition: htmlelem.c:23
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
pi
static refpint_t pi[]
Definition: server.c:96

Referenced by START_TEST().

◆ test_default_properties()

static void test_default_properties ( void  )
static

Definition at line 7242 of file domdoc.c.

7243{
7244 const property_test_t *entry = properties_test_data;
7245
7246 while (entry->guid)
7247 {
7248 IXMLDOMDocument2 *doc;
7249 VARIANT var;
7250 HRESULT hr;
7251
7252 if (!is_clsid_supported(entry->guid, &IID_IXMLDOMDocument2))
7253 {
7254 entry++;
7255 continue;
7256 }
7257
7258 hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
7259 ok(hr == S_OK, "got 0x%08x\n", hr);
7260
7261 hr = IXMLDOMDocument2_getProperty(doc, _bstr_(entry->property), &var);
7262 ok(hr == S_OK, "got 0x%08x\n", hr);
7263 ok(lstrcmpW(V_BSTR(&var), _bstr_(entry->value)) == 0, "expected %s, for %s\n",
7264 entry->value, entry->clsid);
7265 VariantClear(&var);
7266
7267 IXMLDOMDocument2_Release(doc);
7268
7269 entry++;
7270 }
7271}
entry
uint32_t entry
Definition: isohybrid.c:63
properties_test_data
static const property_test_t properties_test_data[]
Definition: domdoc.c:7233
_property_test_t
Definition: domdoc.c:7226

Referenced by START_TEST().

◆ test_dispex()

static void test_dispex ( void  )
static

Definition at line 10979 of file domdoc.c.

10980{
10981 const DOMNodeType *type = nodetypes_test;
10982 IXMLDOMImplementation *impl;
10983 IXMLDOMNodeList *node_list;
10984 IXMLDOMParseError *error;
10985 IXMLDOMNamedNodeMap *map;
10986 IXSLProcessor *processor;
10987 IXSLTemplate *template;
10988 IXMLDOMDocument *doc;
10989 IXMLHTTPRequest *req;
10990 IXMLDOMElement *elem;
10991 IDispatchEx *dispex;
10992 DISPPARAMS dispparams;
10993 IXMLDOMNode *node;
10994 VARIANT arg, ret;
10995 VARIANT_BOOL b;
10996 IUnknown *unk;
10997 HRESULT hr;
10998 DISPID did;
10999
11000 doc = create_document(&IID_IXMLDOMDocument);
11001
11002 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
11003 ok(hr == S_OK, "got 0x%08x\n", hr);
11004 test_domobj_dispex(unk);
11005 IUnknown_Release(unk);
11006
11007 for(; *type != NODE_INVALID; type++)
11008 {
11009 IXMLDOMNode *node;
11010 VARIANT v;
11011
11012 V_VT(&v) = VT_I2;
11013 V_I2(&v) = *type;
11014
11015 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
11016 ok(hr == S_OK, "failed to create node type %d\n", *type);
11017
11018 IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
11019
11020 test_domobj_dispex(unk);
11021 IUnknown_Release(unk);
11022 IXMLDOMNode_Release(node);
11023 }
11024
11025 /* IXMLDOMNodeList */
11026 hr = IXMLDOMDocument_getElementsByTagName(doc, _bstr_("*"), &node_list);
11027 EXPECT_HR(hr, S_OK);
11028 hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
11029 ok(hr == S_OK, "got 0x%08x\n", hr);
11030 test_domobj_dispex(unk);
11031 IUnknown_Release(unk);
11032 IXMLDOMNodeList_Release(node_list);
11033
11034 /* IXMLDOMNodeList for children list */
11035 hr = IXMLDOMDocument_get_childNodes(doc, &node_list);
11036 EXPECT_HR(hr, S_OK);
11037 hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
11038 ok(hr == S_OK, "got 0x%08x\n", hr);
11039 test_domobj_dispex(unk);
11040 IUnknown_Release(unk);
11041
11042 /* collection dispex test, empty collection */
11043 hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatchEx, (void**)&dispex);
11044 EXPECT_HR(hr, S_OK);
11045 did = 0;
11046 hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
11047 EXPECT_HR(hr, S_OK);
11048 ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
11049 hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
11050 EXPECT_HR(hr, S_OK);
11051 ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
11052 IDispatchEx_Release(dispex);
11053
11054 did = -1;
11055 hr = IDispatchEx_GetDispID(dispex, _bstr_("item"), 0, &did);
11056 ok(hr == S_OK, "got 0x%08x\n", hr);
11057 ok(did == DISPID_VALUE, "got %d\n", did);
11058
11059 V_VT(&arg) = VT_I4;
11060 V_I4(&arg) = 0;
11061 dispparams.cArgs = 0;
11062 dispparams.cNamedArgs = 0;
11063 dispparams.rgdispidNamedArgs = NULL;
11064 dispparams.rgvarg = &arg;
11065
11066 V_VT(&ret) = VT_EMPTY;
11067 V_DISPATCH(&ret) = (void*)0x1;
11068 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11069 ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
11070 ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
11071todo_wine
11072 ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
11073
11074 V_VT(&arg) = VT_I4;
11075 V_I4(&arg) = 0;
11076 dispparams.cArgs = 2;
11077 dispparams.cNamedArgs = 0;
11078 dispparams.rgdispidNamedArgs = NULL;
11079 dispparams.rgvarg = &arg;
11080
11081 V_VT(&ret) = VT_EMPTY;
11082 V_DISPATCH(&ret) = (void*)0x1;
11083 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11084 ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
11085 ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
11086todo_wine
11087 ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
11088
11089 V_VT(&arg) = VT_I4;
11090 V_I4(&arg) = 0;
11091 dispparams.cArgs = 1;
11092 dispparams.cNamedArgs = 0;
11093 dispparams.rgdispidNamedArgs = NULL;
11094 dispparams.rgvarg = &arg;
11095
11096 V_VT(&ret) = VT_EMPTY;
11097 V_DISPATCH(&ret) = (void*)0x1;
11098 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11099 ok(hr == S_OK, "got 0x%08x\n", hr);
11100 ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
11101 ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
11102
11103 V_VT(&ret) = VT_EMPTY;
11104 V_DISPATCH(&ret) = (void*)0x1;
11105 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
11106 ok(hr == S_OK, "got 0x%08x\n", hr);
11107 ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
11108 ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
11109
11110 V_VT(&ret) = VT_EMPTY;
11111 V_DISPATCH(&ret) = (void*)0x1;
11112 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11113 ok(hr == S_OK, "got 0x%08x\n", hr);
11114 ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
11115 ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
11116
11117 dispparams.cArgs = 0;
11118 dispparams.cNamedArgs = 0;
11119 dispparams.rgdispidNamedArgs = NULL;
11120 dispparams.rgvarg = NULL;
11121
11122 V_VT(&ret) = VT_EMPTY;
11123 V_I4(&ret) = 1;
11124 hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
11125 ok(hr == S_OK, "got 0x%08x\n", hr);
11126 ok(V_VT(&ret) == VT_I4, "got %d\n", V_VT(&ret));
11127 ok(V_I4(&ret) == 0, "got %d\n", V_I4(&ret));
11128
11129 dispparams.cArgs = 0;
11130 dispparams.cNamedArgs = 0;
11131 dispparams.rgdispidNamedArgs = NULL;
11132 dispparams.rgvarg = NULL;
11133
11134 V_VT(&ret) = VT_EMPTY;
11135 V_I4(&ret) = 1;
11136 hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11137 ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
11138 ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
11139todo_wine
11140 ok(broken(V_I4(&ret) == 1) || (V_I4(&ret) == 0), "got %d\n", V_I4(&ret));
11141
11142 IXMLDOMNodeList_Release(node_list);
11143
11144 /* IXMLDOMParseError */
11145 hr = IXMLDOMDocument_get_parseError(doc, &error);
11146 EXPECT_HR(hr, S_OK);
11147 IXMLDOMParseError_QueryInterface(error, &IID_IUnknown, (void**)&unk);
11148 test_domobj_dispex(unk);
11149
11150 hr = IXMLDOMParseError_QueryInterface(error, &IID_IDispatchEx, (void**)&dispex);
11151 ok(hr == S_OK, "got 0x%08x\n", hr);
11152
11153 V_VT(&arg) = VT_I4;
11154 V_I4(&arg) = 0;
11155 dispparams.cArgs = 1;
11156 dispparams.cNamedArgs = 0;
11157 dispparams.rgdispidNamedArgs = NULL;
11158 dispparams.rgvarg = &arg;
11159
11160 V_VT(&ret) = VT_EMPTY;
11161 V_DISPATCH(&ret) = (void*)0x1;
11162 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11163 ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
11164 ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
11165todo_wine
11166 ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
11167
11168 IDispatchEx_Release(dispex);
11169
11170 IUnknown_Release(unk);
11171 IXMLDOMParseError_Release(error);
11172
11173 /* IXMLDOMNamedNodeMap */
11174 hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
11175 EXPECT_HR(hr, S_OK);
11176
11177 hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/a"), &node_list);
11178 EXPECT_HR(hr, S_OK);
11179 hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
11180 EXPECT_HR(hr, S_OK);
11181 IXMLDOMNodeList_Release(node_list);
11182
11183 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
11184 EXPECT_HR(hr, S_OK);
11185 IXMLDOMNode_Release(node);
11186 hr = IXMLDOMElement_get_attributes(elem, &map);
11187 EXPECT_HR(hr, S_OK);
11188 IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk);
11189 test_domobj_dispex(unk);
11190 IUnknown_Release(unk);
11191 /* collection dispex test */
11192 hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
11193 EXPECT_HR(hr, S_OK);
11194 did = 0;
11195 hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
11196 EXPECT_HR(hr, S_OK);
11197 ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
11198 IDispatchEx_Release(dispex);
11199 IXMLDOMNamedNodeMap_Release(map);
11200
11201 hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/b"), &node_list);
11202 EXPECT_HR(hr, S_OK);
11203 hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
11204 EXPECT_HR(hr, S_OK);
11205 IXMLDOMNodeList_Release(node_list);
11206 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
11207 EXPECT_HR(hr, S_OK);
11208 IXMLDOMNode_Release(node);
11209 hr = IXMLDOMElement_get_attributes(elem, &map);
11210 EXPECT_HR(hr, S_OK);
11211 /* collection dispex test, empty collection */
11212 hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
11213 EXPECT_HR(hr, S_OK);
11214 did = 0;
11215 hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
11216 EXPECT_HR(hr, S_OK);
11217 ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
11218 hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
11219 EXPECT_HR(hr, S_OK);
11220 ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
11221 IXMLDOMNamedNodeMap_Release(map);
11222
11223 did = -1;
11224 hr = IDispatchEx_GetDispID(dispex, _bstr_("item"), 0, &did);
11225 ok(hr == S_OK, "got 0x%08x\n", hr);
11226 ok(did == DISPID_VALUE, "got %d\n", did);
11227
11228 V_VT(&arg) = VT_I4;
11229 V_I4(&arg) = 0;
11230 dispparams.cArgs = 0;
11231 dispparams.cNamedArgs = 0;
11232 dispparams.rgdispidNamedArgs = NULL;
11233 dispparams.rgvarg = &arg;
11234
11235 V_VT(&ret) = VT_EMPTY;
11236 V_DISPATCH(&ret) = (void*)0x1;
11237 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11238todo_wine {
11239 ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
11240 ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
11241}
11242 ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
11243
11244 V_VT(&arg) = VT_I4;
11245 V_I4(&arg) = 0;
11246 dispparams.cArgs = 2;
11247 dispparams.cNamedArgs = 0;
11248 dispparams.rgdispidNamedArgs = NULL;
11249 dispparams.rgvarg = &arg;
11250
11251 V_VT(&ret) = VT_EMPTY;
11252 V_DISPATCH(&ret) = (void*)0x1;
11253 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11254todo_wine {
11255 ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
11256 ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
11257}
11258 ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
11259
11260 V_VT(&arg) = VT_I4;
11261 V_I4(&arg) = 0;
11262 dispparams.cArgs = 1;
11263 dispparams.cNamedArgs = 0;
11264 dispparams.rgdispidNamedArgs = NULL;
11265 dispparams.rgvarg = &arg;
11266
11267 V_VT(&ret) = VT_EMPTY;
11268 V_DISPATCH(&ret) = (void*)0x1;
11269 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11270todo_wine
11271 ok(hr == S_OK, "got 0x%08x\n", hr);
11272 ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
11273 ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
11274
11275 V_VT(&ret) = VT_EMPTY;
11276 V_DISPATCH(&ret) = (void*)0x1;
11277 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
11278 ok(hr == S_OK, "got 0x%08x\n", hr);
11279 ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
11280 ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
11281
11282 V_VT(&ret) = VT_EMPTY;
11283 V_DISPATCH(&ret) = (void*)0x1;
11284 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11285 ok(hr == S_OK, "got 0x%08x\n", hr);
11286 ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
11287 ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
11288
11289 dispparams.cArgs = 0;
11290 dispparams.cNamedArgs = 0;
11291 dispparams.rgdispidNamedArgs = NULL;
11292 dispparams.rgvarg = NULL;
11293
11294 V_VT(&ret) = VT_EMPTY;
11295 V_I4(&ret) = 1;
11296 hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
11297 ok(hr == S_OK, "got 0x%08x\n", hr);
11298 ok(V_VT(&ret) == VT_I4, "got %d\n", V_VT(&ret));
11299 ok(V_I4(&ret) == 0, "got %d\n", V_I4(&ret));
11300
11301 dispparams.cArgs = 0;
11302 dispparams.cNamedArgs = 0;
11303 dispparams.rgdispidNamedArgs = NULL;
11304 dispparams.rgvarg = NULL;
11305
11306 V_VT(&ret) = VT_EMPTY;
11307 V_I4(&ret) = 1;
11308 hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
11309 ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
11310todo_wine
11311 ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
11312 ok(broken(V_I4(&ret) == 1) || (V_I4(&ret) == 0), "got %d\n", V_I4(&ret));
11313
11314 IDispatchEx_Release(dispex);
11315 IXMLDOMElement_Release(elem);
11316
11317 /* IXMLDOMImplementation */
11318 hr = IXMLDOMDocument_get_implementation(doc, &impl);
11319 EXPECT_HR(hr, S_OK);
11320
11321 hr = IXMLDOMImplementation_QueryInterface(impl, &IID_IDispatchEx, (void**)&dispex);
11322 EXPECT_HR(hr, S_OK);
11323 IDispatchEx_Release(dispex);
11324 IXMLDOMImplementation_Release(impl);
11325
11326 IXMLDOMDocument_Release(doc);
11327
11328 /* IXMLHTTPRequest */
11329 hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
11330 &IID_IXMLHttpRequest, (void**)&req);
11331 if (hr == S_OK)
11332 {
11333 hr = IXMLHTTPRequest_QueryInterface(req, &IID_IDispatchEx, (void**)&dispex);
11334 EXPECT_HR(hr, E_NOINTERFACE);
11335 IXMLHTTPRequest_Release(req);
11336 }
11337
11338 /* IXSLTemplate */
11339 template = create_xsltemplate(&IID_IXSLTemplate);
11340 hr = IXSLTemplate_QueryInterface(template, &IID_IDispatchEx, (void**)&dispex);
11341 EXPECT_HR(hr, S_OK);
11342 hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
11343 EXPECT_HR(hr, S_OK);
11344 test_domobj_dispex(unk);
11345 IUnknown_Release(unk);
11346 IDispatchEx_Release(dispex);
11347
11348 /* IXSLProcessor */
11349 hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
11350 EXPECT_HR(hr, S_OK);
11351 b = VARIANT_FALSE;
11352 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformSSXML), &b);
11353 EXPECT_HR(hr, S_OK);
11354 ok(b == VARIANT_TRUE, "got %d\n", b);
11355
11356 hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
11357 EXPECT_HR(hr, S_OK);
11358 IXMLDOMDocument_Release(doc);
11359
11360 hr = IXSLTemplate_createProcessor(template, &processor);
11361 EXPECT_HR(hr, S_OK);
11362 hr = IXSLProcessor_QueryInterface(processor, &IID_IDispatchEx, (void**)&dispex);
11363 EXPECT_HR(hr, S_OK);
11364 hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
11365 EXPECT_HR(hr, S_OK);
11366 test_domobj_dispex(unk);
11367 IUnknown_Release(unk);
11368 IDispatchEx_Release(dispex);
11369
11370 IXSLProcessor_Release(processor);
11371 IXSLTemplate_Release(template);
11372
11373 if (is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument))
11374 {
11375 doc = create_document_version(60, &IID_IXMLDOMDocument);
11376 test_domobj_dispex((IUnknown*)doc);
11377 IXMLDOMDocument_Release(doc);
11378 }
11379
11380 free_bstrs();
11381}
map
Definition: _map.h:48
VT_I2
@ VT_I2
Definition: compat.h:2297
NODE_INVALID
@ NODE_INVALID
Definition: shared.h:244
error
#define error(str)
Definition: mkdosfs.c:1605
EXPECT_HR
#define EXPECT_HR(hr, hr_exp)
Definition: domdoc.c:700
create_document_version
#define create_document_version(v, iid)
Definition: domdoc.c:1229
szTransformSSXML
static const CHAR szTransformSSXML[]
Definition: domdoc.c:858
test_domobj_dispex
static void test_domobj_dispex(IUnknown *obj)
Definition: domdoc.c:10418
nodetypes_test
static const DOMNodeType nodetypes_test[]
Definition: domdoc.c:10966
xpath_simple_list
static const char xpath_simple_list[]
Definition: domdoc.c:1127
create_xsltemplate
#define create_xsltemplate(iid)
Definition: domdoc.c:1231
DISPID
static VARIANTARG static DISPID
Definition: ordinal.c:52
DISPID_DOM_COLLECTION_BASE
#define DISPID_DOM_COLLECTION_BASE
Definition: msxml2did.h:70
DISPID_DOM_NODELIST_LENGTH
#define DISPID_DOM_NODELIST_LENGTH
Definition: msxml2did.h:150
CLSID_XMLHTTPRequest
const struct _GUID CLSID_XMLHTTPRequest
stdole::DISPPARAMS
struct stdole::DISPPARAMS DISPPARAMS
DISPATCH_PROPERTYGET
#define DISPATCH_PROPERTYGET
Definition: oleauto.h:1007
V_I2
#define V_I2(A)
Definition: oleauto.h:245
IID_NULL
#define IID_NULL
Definition: guiddef.h:98
arg
void * arg
Definition: msvc.h:10
DISP_E_BADPARAMCOUNT
#define DISP_E_BADPARAMCOUNT
Definition: winerror.h:2523
DISP_E_MEMBERNOTFOUND
#define DISP_E_MEMBERNOTFOUND
Definition: winerror.h:2512

Referenced by START_TEST().

◆ test_doc_load_from_path()

static void test_doc_load_from_path ( IXMLDOMDocument *  doc,
const char *  path 
)
static

Definition at line 10191 of file domdoc.c.

10192{
10193 IXMLDOMDocument *doc2;
10194 IXMLDOMElement *elem;
10195 BSTR url, url2;
10196 VARIANT_BOOL b;
10197 VARIANT src;
10198 HRESULT hr;
10199
10200 url = _bstr_(path);
10201
10202 V_VT(&src) = VT_BSTR;
10203 V_BSTR(&src) = url;
10204 hr = IXMLDOMDocument_load(doc, src, &b);
10205 ok(hr == S_OK, "Failed to load document, %#x.\n", hr);
10206 ok(b == VARIANT_TRUE, "got %d\n", b);
10207
10208 V_VT(&src) = VT_BSTR | VT_BYREF;
10209 V_BSTRREF(&src) = &url;
10210 hr = IXMLDOMDocument_load(doc, src, &b);
10211 ok(hr == S_OK, "Failed to load document, %#x.\n", hr);
10212 ok(b == VARIANT_TRUE, "got %d\n", b);
10213
10214 url = NULL;
10215 hr = IXMLDOMDocument_get_url(doc, &url);
10216 ok(hr == S_OK, "Failed to get document url, hr %#x.\n", hr);
10217
10218 hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10219 ok(hr == S_OK, "got 0x%08x\n", hr);
10220
10221 /* Create another instance for the same document, check url */
10222 hr = IXMLDOMElement_get_ownerDocument(elem, &doc2);
10223 ok(hr == S_OK, "Failed to get owner document, hr %#x.\n", hr);
10224
10225 hr = IXMLDOMDocument_get_url(doc2, &url2);
10226 ok(hr == S_OK, "Failed to get document url, hr %#x.\n", hr);
10227 ok(!lstrcmpW(url, url2), "Unexpected url %s.\n", wine_dbgstr_w(url2));
10228
10229 IXMLDOMDocument_Release(doc2);
10230 IXMLDOMElement_Release(elem);
10231 SysFreeString(url2);
10232 SysFreeString(url);
10233}
VT_BYREF
@ VT_BYREF
Definition: compat.h:2342
src
GLenum src
Definition: glext.h:6340
url
static const WCHAR url[]
Definition: encode.c:1432
url2
static const WCHAR url2[]
Definition: misc.c:302
V_BSTRREF
#define V_BSTRREF(A)
Definition: oleauto.h:227

Referenced by test_load().

◆ test_domdoc()

static void test_domdoc ( void  )
static

Definition at line 1439 of file domdoc.c.

1440{
1441 HRESULT r, hr;
1442 IXMLDOMDocument *doc;
1443 IXMLDOMParseError *error;
1444 IXMLDOMElement *element = NULL;
1445 IXMLDOMNode *node;
1446 IXMLDOMText *nodetext = NULL;
1447 IXMLDOMComment *node_comment = NULL;
1448 IXMLDOMAttribute *node_attr = NULL;
1449 IXMLDOMNode *nodeChild = NULL;
1450 IXMLDOMProcessingInstruction *nodePI = NULL;
1451 const struct leading_spaces_t *class_ptr;
1452 const char **data_ptr;
1453 VARIANT_BOOL b;
1454 VARIANT var;
1455 BSTR str;
1456 LONG code, ref;
1457 LONG nLength = 0;
1458 WCHAR buff[100];
1459 char path[MAX_PATH];
1460 int index;
1461
1462 GetTempPathA(MAX_PATH, path);
1463 strcat(path, "leading_spaces.xml");
1464
1465 /* Load document with leading spaces
1466 *
1467 * Test all CLSIDs with all test data XML strings
1468 */
1469 class_ptr = leading_spaces_classdata;
1470 index = 0;
1471 while (class_ptr->clsid)
1472 {
1473 HRESULT hr;
1474 int i;
1475
1476 if (is_clsid_supported(class_ptr->clsid, &IID_IXMLDOMDocument))
1477 {
1478 hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
1479 }
1480 else
1481 {
1482 class_ptr++;
1483 index++;
1484 continue;
1485 }
1486
1487 data_ptr = leading_spaces_xmldata;
1488 i = 0;
1489 while (*data_ptr) {
1490 BSTR data = _bstr_(*data_ptr);
1491 DWORD written;
1492 HANDLE file;
1493
1494 file = CreateFileA(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
1495 ok(file != INVALID_HANDLE_VALUE, "can't create file %s: %u\n", path, GetLastError());
1496
1497 WriteFile(file, data, lstrlenW(data)*sizeof(WCHAR), &written, NULL);
1498 CloseHandle(file);
1499
1500 b = 0xc;
1501 V_VT(&var) = VT_BSTR;
1502 V_BSTR(&var) = _bstr_(path);
1503 hr = IXMLDOMDocument_load(doc, var, &b);
1504 EXPECT_HR(hr, class_ptr->ret[0].hr);
1505 ok(b == class_ptr->ret[0].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[0].b);
1506
1507 DeleteFileA(path);
1508
1509 b = 0xc;
1510 hr = IXMLDOMDocument_loadXML(doc, data, &b);
1511 EXPECT_HR(hr, class_ptr->ret[1].hr);
1512 ok(b == class_ptr->ret[1].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[1].b);
1513
1514 data_ptr++;
1515 i++;
1516 }
1517
1518 class_ptr++;
1519 index++;
1520 free_bstrs();
1521 }
1522
1523 doc = create_document(&IID_IXMLDOMDocument);
1524 if (!doc) return;
1525
1526if (0)
1527{
1528 /* crashes on native */
1529 IXMLDOMDocument_loadXML( doc, (BSTR)0x1, NULL );
1530}
1531
1532 /* try some stupid things */
1533 hr = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1534 EXPECT_HR(hr, S_FALSE);
1535
1536 b = VARIANT_TRUE;
1537 hr = IXMLDOMDocument_loadXML( doc, NULL, &b );
1538 EXPECT_HR(hr, S_FALSE);
1539 ok( b == VARIANT_FALSE, "failed to load XML string\n");
1540
1541 /* try to load a document from a nonexistent file */
1542 b = VARIANT_TRUE;
1543 str = SysAllocString( nonexistent_fileW );
1544 VariantInit(&var);
1545 V_VT(&var) = VT_BSTR;
1546 V_BSTR(&var) = str;
1547
1548 r = IXMLDOMDocument_load( doc, var, &b);
1549 ok( r == S_FALSE, "loadXML succeeded\n");
1550 ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1551 SysFreeString( str );
1552
1553 str = (void *)0xdeadbeef;
1554 hr = IXMLDOMDocument_get_url(doc, &str);
1555 ok(hr == S_FALSE, "got 0x%08x\n", hr);
1556 ok(str == NULL, "got %p\n", str);
1557
1558 /* try load an empty document */
1559 b = VARIANT_TRUE;
1560 str = SysAllocString( szEmpty );
1561 r = IXMLDOMDocument_loadXML( doc, str, &b );
1562 ok( r == S_FALSE, "loadXML succeeded\n");
1563 ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1564 SysFreeString( str );
1565
1566 r = IXMLDOMDocument_get_async( doc, &b );
1567 ok( r == S_OK, "get_async failed (%08x)\n", r);
1568 ok( b == VARIANT_TRUE, "Wrong default value\n");
1569
1570 /* check that there's no document element */
1571 element = NULL;
1572 r = IXMLDOMDocument_get_documentElement( doc, &element );
1573 ok( r == S_FALSE, "should be no document element\n");
1574
1575 /* try finding a node */
1576 node = NULL;
1577 str = SysAllocString( szstr1 );
1578 r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
1579 ok( r == S_FALSE, "ret %08x\n", r );
1580 SysFreeString( str );
1581
1582 b = VARIANT_TRUE;
1583 str = SysAllocString( szIncomplete );
1584 r = IXMLDOMDocument_loadXML( doc, str, &b );
1585 ok( r == S_FALSE, "loadXML succeeded\n");
1586 ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1587 SysFreeString( str );
1588
1589 /* check that there's no document element */
1590 element = (IXMLDOMElement*)1;
1591 r = IXMLDOMDocument_get_documentElement( doc, &element );
1592 ok( r == S_FALSE, "should be no document element\n");
1593 ok( element == NULL, "Element should be NULL\n");
1594
1595 /* test for BSTR handling, pass broken BSTR */
1596 memcpy(&buff[2], szComplete1, sizeof(szComplete1));
1597 /* just a big length */
1598 *(DWORD*)buff = 0xf0f0;
1599 b = VARIANT_FALSE;
1600 r = IXMLDOMDocument_loadXML( doc, &buff[2], &b );
1601 ok( r == S_OK, "loadXML failed\n");
1602 ok( b == VARIANT_TRUE, "failed to load XML string\n");
1603
1604 /* loadXML ignores the encoding attribute and always expects Unicode */
1605 b = VARIANT_FALSE;
1606 str = SysAllocString( szComplete6 );
1607 r = IXMLDOMDocument_loadXML( doc, str, &b );
1608 ok( r == S_OK, "loadXML failed\n");
1609 ok( b == VARIANT_TRUE, "failed to load XML string\n");
1610 SysFreeString( str );
1611
1612 /* try a BSTR containing a Windows-1252 document */
1613 b = VARIANT_TRUE;
1614 str = SysAllocStringByteLen( win1252xml, strlen(win1252xml) );
1615 r = IXMLDOMDocument_loadXML( doc, str, &b );
1616 ok( r == S_FALSE, "loadXML succeeded\n");
1617 ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1618 SysFreeString( str );
1619
1620 /* try to load something valid */
1621 b = VARIANT_FALSE;
1622 str = SysAllocString( szComplete1 );
1623 r = IXMLDOMDocument_loadXML( doc, str, &b );
1624 ok( r == S_OK, "loadXML failed\n");
1625 ok( b == VARIANT_TRUE, "failed to load XML string\n");
1626 SysFreeString( str );
1627
1628 /* check if nodename is correct */
1629 r = IXMLDOMDocument_get_nodeName( doc, NULL );
1630 ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1631
1632 str = (void *)0xdeadbeef;
1633 r = IXMLDOMDocument_get_baseName( doc, &str );
1634 ok ( r == S_FALSE, "got 0x%08x\n", r);
1635 ok (str == NULL, "got %p\n", str);
1636
1637 /* content doesn't matter here */
1638 str = NULL;
1639 r = IXMLDOMDocument_get_nodeName( doc, &str );
1640 ok ( r == S_OK, "get_nodeName wrong code\n");
1641 ok ( str != NULL, "str is null\n");
1642 ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
1643 SysFreeString( str );
1644
1645 /* test put_text */
1646 r = IXMLDOMDocument_put_text( doc, _bstr_("Should fail") );
1647 ok( r == E_FAIL, "ret %08x\n", r );
1648
1649 /* check that there's a document element */
1650 element = NULL;
1651 r = IXMLDOMDocument_get_documentElement( doc, &element );
1652 ok( r == S_OK, "should be a document element\n");
1653 if( element )
1654 {
1655 IObjectIdentity *ident;
1656
1657 r = IXMLDOMElement_QueryInterface( element, &IID_IObjectIdentity, (void**)&ident );
1658 ok( r == E_NOINTERFACE, "ret %08x\n", r);
1659
1660 IXMLDOMElement_Release( element );
1661 element = NULL;
1662 }
1663
1664 /* as soon as we call loadXML again, the document element will disappear */
1665 b = 2;
1666 r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1667 ok( r == S_FALSE, "loadXML failed\n");
1668 ok( b == 2, "variant modified\n");
1669 r = IXMLDOMDocument_get_documentElement( doc, &element );
1670 ok( r == S_FALSE, "should be no document element\n");
1671
1672 /* try to load something else simple and valid */
1673 b = VARIANT_FALSE;
1674 str = SysAllocString( szComplete2 );
1675 r = IXMLDOMDocument_loadXML( doc, str, &b );
1676 ok( r == S_OK, "loadXML failed\n");
1677 ok( b == VARIANT_TRUE, "failed to load XML string\n");
1678 SysFreeString( str );
1679
1680 /* try something a little more complicated */
1681 b = FALSE;
1682 r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
1683 ok( r == S_OK, "loadXML failed\n");
1684 ok( b == VARIANT_TRUE, "failed to load XML string\n");
1685
1686 r = IXMLDOMDocument_get_parseError( doc, &error );
1687 ok( r == S_OK, "returns %08x\n", r );
1688
1689 r = IXMLDOMParseError_get_errorCode( error, &code );
1690 ok( r == S_FALSE, "returns %08x\n", r );
1691 ok( code == 0, "code %d\n", code );
1692 IXMLDOMParseError_Release( error );
1693
1694 /* test createTextNode */
1695 r = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &nodetext);
1696 ok( r == S_OK, "returns %08x\n", r );
1697 IXMLDOMText_Release(nodetext);
1698
1699 str = SysAllocString( szOpen );
1700 r = IXMLDOMDocument_createTextNode(doc, str, NULL);
1701 ok( r == E_INVALIDARG, "returns %08x\n", r );
1702 r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
1703 ok( r == S_OK, "returns %08x\n", r );
1704 SysFreeString( str );
1705 if(nodetext)
1706 {
1707 r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (void**)&element);
1708 ok(r == E_NOINTERFACE, "ret %08x\n", r );
1709
1710 /* Text Last Child Checks */
1711 r = IXMLDOMText_get_lastChild(nodetext, NULL);
1712 ok(r == E_INVALIDARG, "ret %08x\n", r );
1713
1714 nodeChild = (IXMLDOMNode*)0x1;
1715 r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
1716 ok(r == S_FALSE, "ret %08x\n", r );
1717 ok(nodeChild == NULL, "nodeChild not NULL\n");
1718
1719 /* test length property */
1720 r = IXMLDOMText_get_length(nodetext, NULL);
1721 ok(r == E_INVALIDARG, "ret %08x\n", r );
1722
1723 r = IXMLDOMText_get_length(nodetext, &nLength);
1724 ok(r == S_OK, "ret %08x\n", r );
1725 ok(nLength == 4, "expected 4 got %d\n", nLength);
1726
1727 /* put data Tests */
1728 r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
1729 ok(r == S_OK, "ret %08x\n", r );
1730
1731 /* get data Tests */
1732 r = IXMLDOMText_get_data(nodetext, &str);
1733 ok(r == S_OK, "ret %08x\n", r );
1734 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
1735 SysFreeString(str);
1736
1737 /* Confirm XML text is good */
1738 r = IXMLDOMText_get_xml(nodetext, &str);
1739 ok(r == S_OK, "ret %08x\n", r );
1740 ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
1741 SysFreeString(str);
1742
1743 /* Confirm we get the put_data Text back */
1744 r = IXMLDOMText_get_text(nodetext, &str);
1745 ok(r == S_OK, "ret %08x\n", r );
1746 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
1747 SysFreeString(str);
1748
1749 /* test substringData */
1750 r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
1751 ok(r == E_INVALIDARG, "ret %08x\n", r );
1752
1753 /* test substringData - Invalid offset */
1754 str = (void *)0xdeadbeef;
1755 r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
1756 ok(r == E_INVALIDARG, "ret %08x\n", r );
1757 ok( str == NULL, "incorrect string\n");
1758
1759 /* test substringData - Invalid offset */
1760 str = (void *)0xdeadbeef;
1761 r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
1762 ok(r == S_FALSE, "ret %08x\n", r );
1763 ok( str == NULL, "incorrect string\n");
1764
1765 /* test substringData - Invalid size */
1766 str = (void *)0xdeadbeef;
1767 r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
1768 ok(r == E_INVALIDARG, "ret %08x\n", r );
1769 ok( str == NULL, "incorrect string\n");
1770
1771 /* test substringData - Invalid size */
1772 str = (void *)0xdeadbeef;
1773 r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
1774 ok(r == S_FALSE, "ret %08x\n", r );
1775 ok( str == NULL, "incorrect string\n");
1776
1777 /* test substringData - Start of string */
1778 r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
1779 ok(r == S_OK, "ret %08x\n", r );
1780 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
1781 SysFreeString(str);
1782
1783 /* test substringData - Middle of string */
1784 r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
1785 ok(r == S_OK, "ret %08x\n", r );
1786 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
1787 SysFreeString(str);
1788
1789 /* test substringData - End of string */
1790 r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
1791 ok(r == S_OK, "ret %08x\n", r );
1792 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
1793 SysFreeString(str);
1794
1795 /* test appendData */
1796 r = IXMLDOMText_appendData(nodetext, NULL);
1797 ok(r == S_OK, "ret %08x\n", r );
1798
1799 r = IXMLDOMText_appendData(nodetext, _bstr_(""));
1800 ok(r == S_OK, "ret %08x\n", r );
1801
1802 r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
1803 ok(r == S_OK, "ret %08x\n", r );
1804
1805 r = IXMLDOMText_get_text(nodetext, &str);
1806 ok(r == S_OK, "ret %08x\n", r );
1807 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1808 SysFreeString(str);
1809
1810 /* test insertData */
1811 str = SysAllocStringLen(NULL, 0);
1812 r = IXMLDOMText_insertData(nodetext, -1, str);
1813 ok(r == S_OK, "ret %08x\n", r );
1814
1815 r = IXMLDOMText_insertData(nodetext, -1, NULL);
1816 ok(r == S_OK, "ret %08x\n", r );
1817
1818 r = IXMLDOMText_insertData(nodetext, 1000, str);
1819 ok(r == S_OK, "ret %08x\n", r );
1820
1821 r = IXMLDOMText_insertData(nodetext, 1000, NULL);
1822 ok(r == S_OK, "ret %08x\n", r );
1823
1824 r = IXMLDOMText_insertData(nodetext, 0, NULL);
1825 ok(r == S_OK, "ret %08x\n", r );
1826
1827 r = IXMLDOMText_insertData(nodetext, 0, str);
1828 ok(r == S_OK, "ret %08x\n", r );
1829 SysFreeString(str);
1830
1831 r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
1832 ok(r == E_INVALIDARG, "ret %08x\n", r );
1833
1834 r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
1835 ok(r == E_INVALIDARG, "ret %08x\n", r );
1836
1837 r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
1838 ok(r == S_OK, "ret %08x\n", r );
1839
1840 r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
1841 ok(r == S_OK, "ret %08x\n", r );
1842
1843 r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
1844 ok(r == S_OK, "ret %08x\n", r );
1845
1846 r = IXMLDOMText_get_text(nodetext, &str);
1847 ok(r == S_OK, "ret %08x\n", r );
1848 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1849 SysFreeString(str);
1850
1851 /* delete data */
1852 /* invalid arguments */
1853 r = IXMLDOMText_deleteData(nodetext, -1, 1);
1854 ok(r == E_INVALIDARG, "ret %08x\n", r );
1855
1856 r = IXMLDOMText_deleteData(nodetext, 0, 0);
1857 ok(r == S_OK, "ret %08x\n", r );
1858
1859 r = IXMLDOMText_deleteData(nodetext, 0, -1);
1860 ok(r == E_INVALIDARG, "ret %08x\n", r );
1861
1862 r = IXMLDOMText_get_length(nodetext, &nLength);
1863 ok(r == S_OK, "ret %08x\n", r );
1864 ok(nLength == 43, "expected 43 got %d\n", nLength);
1865
1866 r = IXMLDOMText_deleteData(nodetext, nLength, 1);
1867 ok(r == S_OK, "ret %08x\n", r );
1868
1869 r = IXMLDOMText_deleteData(nodetext, nLength+1, 1);
1870 ok(r == E_INVALIDARG, "ret %08x\n", r );
1871
1872 /* delete from start */
1873 r = IXMLDOMText_deleteData(nodetext, 0, 5);
1874 ok(r == S_OK, "ret %08x\n", r );
1875
1876 r = IXMLDOMText_get_length(nodetext, &nLength);
1877 ok(r == S_OK, "ret %08x\n", r );
1878 ok(nLength == 38, "expected 38 got %d\n", nLength);
1879
1880 r = IXMLDOMText_get_text(nodetext, &str);
1881 ok(r == S_OK, "ret %08x\n", r );
1882 ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1883 SysFreeString(str);
1884
1885 /* delete from end */
1886 r = IXMLDOMText_deleteData(nodetext, 35, 3);
1887 ok(r == S_OK, "ret %08x\n", r );
1888
1889 r = IXMLDOMText_get_length(nodetext, &nLength);
1890 ok(r == S_OK, "ret %08x\n", r );
1891 ok(nLength == 35, "expected 35 got %d\n", nLength);
1892
1893 r = IXMLDOMText_get_text(nodetext, &str);
1894 ok(r == S_OK, "ret %08x\n", r );
1895 ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1896 SysFreeString(str);
1897
1898 /* delete from inside */
1899 r = IXMLDOMText_deleteData(nodetext, 1, 33);
1900 ok(r == S_OK, "ret %08x\n", r );
1901
1902 r = IXMLDOMText_get_length(nodetext, &nLength);
1903 ok(r == S_OK, "ret %08x\n", r );
1904 ok(nLength == 2, "expected 2 got %d\n", nLength);
1905
1906 r = IXMLDOMText_get_text(nodetext, &str);
1907 ok(r == S_OK, "ret %08x\n", r );
1908 ok( !lstrcmpW( str, _bstr_("") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1909 SysFreeString(str);
1910
1911 /* delete whole data ... */
1912 r = IXMLDOMText_get_length(nodetext, &nLength);
1913 ok(r == S_OK, "ret %08x\n", r );
1914
1915 r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1916 ok(r == S_OK, "ret %08x\n", r );
1917 /* ... and try again with empty string */
1918 r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1919 ok(r == S_OK, "ret %08x\n", r );
1920
1921 /* test put_data */
1922 V_VT(&var) = VT_BSTR;
1923 V_BSTR(&var) = SysAllocString(szstr1);
1924 r = IXMLDOMText_put_nodeValue(nodetext, var);
1925 ok(r == S_OK, "ret %08x\n", r );
1926 VariantClear(&var);
1927
1928 r = IXMLDOMText_get_text(nodetext, &str);
1929 ok(r == S_OK, "ret %08x\n", r );
1930 ok( !lstrcmpW( str, szstr1 ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1931 SysFreeString(str);
1932
1933 /* test put_data */
1934 V_VT(&var) = VT_I4;
1935 V_I4(&var) = 99;
1936 r = IXMLDOMText_put_nodeValue(nodetext, var);
1937 ok(r == S_OK, "ret %08x\n", r );
1938 VariantClear(&var);
1939
1940 r = IXMLDOMText_get_text(nodetext, &str);
1941 ok(r == S_OK, "ret %08x\n", r );
1942 ok( !lstrcmpW( str, _bstr_("99") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1943 SysFreeString(str);
1944
1945 /* ::replaceData() */
1946 V_VT(&var) = VT_BSTR;
1947 V_BSTR(&var) = SysAllocString(szstr1);
1948 r = IXMLDOMText_put_nodeValue(nodetext, var);
1949 ok(r == S_OK, "ret %08x\n", r );
1950 VariantClear(&var);
1951
1952 r = IXMLDOMText_replaceData(nodetext, 6, 0, NULL);
1953 ok(r == E_INVALIDARG, "ret %08x\n", r );
1954 r = IXMLDOMText_get_text(nodetext, &str);
1955 ok(r == S_OK, "ret %08x\n", r );
1956 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1957 SysFreeString(str);
1958
1959 r = IXMLDOMText_replaceData(nodetext, 0, 0, NULL);
1960 ok(r == S_OK, "ret %08x\n", r );
1961 r = IXMLDOMText_get_text(nodetext, &str);
1962 ok(r == S_OK, "ret %08x\n", r );
1963 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1964 SysFreeString(str);
1965
1966 /* NULL pointer means delete */
1967 r = IXMLDOMText_replaceData(nodetext, 0, 1, NULL);
1968 ok(r == S_OK, "ret %08x\n", r );
1969 r = IXMLDOMText_get_text(nodetext, &str);
1970 ok(r == S_OK, "ret %08x\n", r );
1971 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1972 SysFreeString(str);
1973
1974 /* empty string means delete */
1975 r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_(""));
1976 ok(r == S_OK, "ret %08x\n", r );
1977 r = IXMLDOMText_get_text(nodetext, &str);
1978 ok(r == S_OK, "ret %08x\n", r );
1979 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1980 SysFreeString(str);
1981
1982 /* zero count means insert */
1983 r = IXMLDOMText_replaceData(nodetext, 0, 0, _bstr_("a"));
1984 ok(r == S_OK, "ret %08x\n", r );
1985 r = IXMLDOMText_get_text(nodetext, &str);
1986 ok(r == S_OK, "ret %08x\n", r );
1987 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1988 SysFreeString(str);
1989
1990 r = IXMLDOMText_replaceData(nodetext, 0, 2, NULL);
1991 ok(r == S_OK, "ret %08x\n", r );
1992
1993 r = IXMLDOMText_insertData(nodetext, 0, _bstr_("m"));
1994 ok(r == S_OK, "ret %08x\n", r );
1995 r = IXMLDOMText_get_text(nodetext, &str);
1996 ok(r == S_OK, "ret %08x\n", r );
1997 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1998 SysFreeString(str);
1999
2000 /* nonempty string, count greater than its length */
2001 r = IXMLDOMText_replaceData(nodetext, 0, 2, _bstr_("a1.2"));
2002 ok(r == S_OK, "ret %08x\n", r );
2003 r = IXMLDOMText_get_text(nodetext, &str);
2004 ok(r == S_OK, "ret %08x\n", r );
2005 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2006 SysFreeString(str);
2007
2008 /* nonempty string, count less than its length */
2009 r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_("wine"));
2010 ok(r == S_OK, "ret %08x\n", r );
2011 r = IXMLDOMText_get_text(nodetext, &str);
2012 ok(r == S_OK, "ret %08x\n", r );
2013 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2014 SysFreeString(str);
2015
2016 IXMLDOMText_Release( nodetext );
2017 }
2018
2019 /* test Create Comment */
2020 r = IXMLDOMDocument_createComment(doc, NULL, NULL);
2021 ok( r == E_INVALIDARG, "returns %08x\n", r );
2022 node_comment = (IXMLDOMComment*)0x1;
2023
2024 /* empty comment */
2025 r = IXMLDOMDocument_createComment(doc, _bstr_(""), &node_comment);
2026 ok( r == S_OK, "returns %08x\n", r );
2027 str = NULL;
2028 r = IXMLDOMComment_get_data(node_comment, &str);
2029 ok( r == S_OK, "returns %08x\n", r );
2030 ok( str && SysStringLen(str) == 0, "expected empty string data\n");
2031 IXMLDOMComment_Release(node_comment);
2032 SysFreeString(str);
2033
2034 r = IXMLDOMDocument_createComment(doc, NULL, &node_comment);
2035 ok( r == S_OK, "returns %08x\n", r );
2036 str = NULL;
2037 r = IXMLDOMComment_get_data(node_comment, &str);
2038 ok( r == S_OK, "returns %08x\n", r );
2039 ok( str && (SysStringLen(str) == 0), "expected empty string data\n");
2040 IXMLDOMComment_Release(node_comment);
2041 SysFreeString(str);
2042
2043 str = SysAllocString(szComment);
2044 r = IXMLDOMDocument_createComment(doc, str, &node_comment);
2045 SysFreeString(str);
2046 ok( r == S_OK, "returns %08x\n", r );
2047 if(node_comment)
2048 {
2049 /* Last Child Checks */
2050 r = IXMLDOMComment_get_lastChild(node_comment, NULL);
2051 ok(r == E_INVALIDARG, "ret %08x\n", r );
2052
2053 nodeChild = (IXMLDOMNode*)0x1;
2054 r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
2055 ok(r == S_FALSE, "ret %08x\n", r );
2056 ok(nodeChild == NULL, "pLastChild not NULL\n");
2057
2058 /* baseName */
2059 str = (void *)0xdeadbeef;
2060 r = IXMLDOMComment_get_baseName(node_comment, &str);
2061 ok(r == S_FALSE, "ret %08x\n", r );
2062 ok(str == NULL, "Expected NULL\n");
2063
2064 IXMLDOMComment_Release( node_comment );
2065 }
2066
2067 /* test Create Attribute */
2068 str = SysAllocString(szAttribute);
2069 r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
2070 ok( r == E_INVALIDARG, "returns %08x\n", r );
2071 r = IXMLDOMDocument_createAttribute(doc, str, &node_attr);
2072 ok( r == S_OK, "returns %08x\n", r );
2073 IXMLDOMAttribute_Release( node_attr);
2074 SysFreeString(str);
2075
2076 /* test Processing Instruction */
2077 str = SysAllocStringLen(NULL, 0);
2078 r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
2079 ok( r == E_INVALIDARG, "returns %08x\n", r );
2080 r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
2081 ok( r == E_FAIL, "returns %08x\n", r );
2082 r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
2083 ok( r == E_FAIL, "returns %08x\n", r );
2084 SysFreeString(str);
2085
2086 r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
2087 ok( r == S_OK, "returns %08x\n", r );
2088 if(nodePI)
2089 {
2090 /* Last Child Checks */
2091 r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
2092 ok(r == E_INVALIDARG, "ret %08x\n", r );
2093
2094 nodeChild = (IXMLDOMNode*)0x1;
2095 r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
2096 ok(r == S_FALSE, "ret %08x\n", r );
2097 ok(nodeChild == NULL, "nodeChild not NULL\n");
2098
2099 /* test nodeName */
2100 r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
2101 ok(r == S_OK, "ret %08x\n", r );
2102 ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2103 SysFreeString(str);
2104
2105 /* test baseName */
2106 str = NULL;
2107 r = IXMLDOMProcessingInstruction_get_baseName(nodePI, &str);
2108 ok(r == S_OK, "ret %08x\n", r );
2109 ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2110 SysFreeString(str);
2111
2112 /* test Target */
2113 r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
2114 ok(r == S_OK, "ret %08x\n", r );
2115 ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
2116 SysFreeString(str);
2117
2118 /* test get_data */
2119 r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
2120 ok(r == S_OK, "ret %08x\n", r );
2121 ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
2122 SysFreeString(str);
2123
2124 /* test put_data */
2125 r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
2126 ok(r == E_FAIL, "ret %08x\n", r );
2127
2128 /* test put_data */
2129 V_VT(&var) = VT_BSTR;
2130 V_BSTR(&var) = SysAllocString(szOpen); /* Doesn't matter what the string is, cannot set an xml node. */
2131 r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
2132 ok(r == E_FAIL, "ret %08x\n", r );
2133 VariantClear(&var);
2134
2135 /* test get nodeName */
2136 r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
2137 ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2138 ok(r == S_OK, "ret %08x\n", r );
2139 SysFreeString(str);
2140
2141 IXMLDOMProcessingInstruction_Release(nodePI);
2142 }
2143
2144 ref = IXMLDOMDocument_Release( doc );
2145 ok( ref == 0, "got %d\n", ref);
2146
2147 free_bstrs();
2148}
index
#define index(s, c)
Definition: various.h:29
CloseHandle
#define CloseHandle
Definition: compat.h:739
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
CreateFileA
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:740
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
FILE_ATTRIBUTE_NORMAL
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
lstrlenW
#define lstrlenW
Definition: compat.h:750
DeleteFileA
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
WriteFile
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
GetTempPathA
DWORD WINAPI GetTempPathA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2054
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
index
GLuint index
Definition: glext.h:6031
CREATE_ALWAYS
#define CREATE_ALWAYS
Definition: disk.h:72
szOpen
static const WCHAR szOpen[]
Definition: domdoc.c:1157
leading_spaces_xmldata
static const char * leading_spaces_xmldata[]
Definition: domdoc.c:1428
szIncomplete
static const WCHAR szIncomplete[]
Definition: domdoc.c:709
szComment
static const WCHAR szComment[]
Definition: domdoc.c:1167
szComplete2
static const WCHAR szComplete2[]
Definition: domdoc.c:718
win1252xml
static const char win1252xml[]
Definition: domdoc.c:772
nonexistent_fileW
static const WCHAR nonexistent_fileW[]
Definition: domdoc.c:1147
szComplete6
static const WCHAR szComplete6[]
Definition: domdoc.c:754
leading_spaces_classdata
static const struct leading_spaces_t leading_spaces_classdata[]
Definition: domdoc.c:1418
szComplete1
static const WCHAR szComplete1[]
Definition: domdoc.c:713
szEmpty
static const WCHAR szEmpty[]
Definition: domdoc.c:708
szDocument
static const WCHAR szDocument[]
Definition: domdoc.c:1153
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
SysAllocStringByteLen
BSTR WINAPI DECLSPEC_HOTPATCH SysAllocStringByteLen(LPCSTR str, UINT len)
Definition: oleaut.c:428
strcat
strcat
Definition: string.h:92
code
Definition: inflate.c:139
file
Definition: fci.c:127
leading_spaces_t
Definition: domdoc.c:1412
leading_spaces_t::clsid
const CLSID * clsid
Definition: domdoc.c:1413
leading_spaces_t::ret
struct docload_ret_t ret[2]
Definition: domdoc.c:1415
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
nLength
_In_ DWORD nLength
Definition: wincon.h:473
ident
_In_ ULONG _In_ ULONG_PTR ident
Definition: winddi.h:3994

Referenced by START_TEST().

◆ test_domnode()

static void test_domnode ( void  )
static

Definition at line 2194 of file domdoc.c.

2195{
2196 HRESULT r;
2197 IXMLDOMDocument *doc, *owner = NULL;
2198 IXMLDOMElement *element = NULL;
2199 IXMLDOMNamedNodeMap *map = NULL;
2200 IXMLDOMNode *node = NULL, *next = NULL;
2201 IXMLDOMNodeList *list = NULL;
2202 IXMLDOMAttribute *attr = NULL;
2203 DOMNodeType type = NODE_INVALID;
2204 VARIANT_BOOL b;
2205 BSTR str;
2206 VARIANT var;
2207 LONG count;
2208
2209 doc = create_document(&IID_IXMLDOMDocument);
2210
2211 b = FALSE;
2212 r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2213 ok( r == S_OK, "loadXML failed\n");
2214 ok( b == VARIANT_TRUE, "failed to load XML string\n");
2215
2216 EXPECT_CHILDREN(doc);
2217
2218 r = IXMLDOMDocument_get_documentElement( doc, &element );
2219 ok( r == S_OK, "should be a document element\n");
2220 ok( element != NULL, "should be an element\n");
2221
2222 VariantInit(&var);
2223 ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
2224
2225 r = IXMLDOMDocument_get_nodeValue( doc, NULL );
2226 ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
2227
2228 r = IXMLDOMDocument_get_nodeValue( doc, &var );
2229 ok( r == S_FALSE, "nextNode returned wrong code\n");
2230 ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
2231 ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
2232
2233 if (element)
2234 {
2235 owner = NULL;
2236 r = IXMLDOMElement_get_ownerDocument( element, &owner );
2237 ok( r == S_OK, "get_ownerDocument return code\n");
2238 ok( owner != doc, "get_ownerDocument return\n");
2239 IXMLDOMDocument_Release(owner);
2240
2241 type = NODE_INVALID;
2242 r = IXMLDOMElement_get_nodeType( element, &type);
2243 ok( r == S_OK, "got %08x\n", r);
2244 ok( type == NODE_ELEMENT, "node not an element\n");
2245
2246 str = NULL;
2247 r = IXMLDOMElement_get_baseName( element, &str );
2248 ok( r == S_OK, "get_baseName returned wrong code\n");
2249 ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
2250 SysFreeString(str);
2251
2252 /* check if nodename is correct */
2253 r = IXMLDOMElement_get_nodeName( element, NULL );
2254 ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2255
2256 /* content doesn't matter here */
2257 str = NULL;
2258 r = IXMLDOMElement_get_nodeName( element, &str );
2259 ok ( r == S_OK, "get_nodeName wrong code\n");
2260 ok ( str != NULL, "str is null\n");
2261 ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
2262 SysFreeString( str );
2263
2264 str = SysAllocString( nonexistent_fileW );
2265 V_VT(&var) = VT_I4;
2266 V_I4(&var) = 0x1234;
2267 r = IXMLDOMElement_getAttribute( element, str, &var );
2268 ok( r == E_FAIL, "getAttribute ret %08x\n", r );
2269 ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
2270 VariantClear(&var);
2271 SysFreeString(str);
2272
2273 str = SysAllocString( szdl );
2274 V_VT(&var) = VT_I4;
2275 V_I4(&var) = 0x1234;
2276 r = IXMLDOMElement_getAttribute( element, str, &var );
2277 ok( r == S_OK, "getAttribute ret %08x\n", r );
2278 ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
2279 ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
2280 VariantClear( &var );
2281
2282 r = IXMLDOMElement_getAttribute( element, NULL, &var );
2283 ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
2284
2285 r = IXMLDOMElement_getAttribute( element, str, NULL );
2286 ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
2287
2288 attr = NULL;
2289 r = IXMLDOMElement_getAttributeNode( element, str, &attr);
2290 ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
2291 ok( attr != NULL, "getAttributeNode returned NULL\n" );
2292 if (attr)
2293 {
2294 r = IXMLDOMAttribute_get_parentNode( attr, NULL );
2295 ok( r == E_INVALIDARG, "Expected E_INVALIDARG, ret %08x\n", r );
2296
2297 /* attribute doesn't have a parent in msxml interpretation */
2298 node = (IXMLDOMNode*)0xdeadbeef;
2299 r = IXMLDOMAttribute_get_parentNode( attr, &node );
2300 ok( r == S_FALSE, "Expected S_FALSE, ret %08x\n", r );
2301 ok( node == NULL, "Expected NULL, got %p\n", node );
2302
2303 IXMLDOMAttribute_Release(attr);
2304 }
2305
2306 SysFreeString( str );
2307
2308 r = IXMLDOMElement_get_attributes( element, &map );
2309 ok( r == S_OK, "get_attributes returned wrong code\n");
2310 ok( map != NULL, "should be attributes\n");
2311
2312 EXPECT_CHILDREN(element);
2313 }
2314 else
2315 ok( FALSE, "no element\n");
2316
2317 if (map)
2318 {
2319 str = SysAllocString( szdl );
2320 r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
2321 ok( r == S_OK, "getNamedItem returned wrong code\n");
2322 ok( node != NULL, "should be attributes\n");
2323 IXMLDOMNode_Release(node);
2324 SysFreeString( str );
2325
2326 str = SysAllocString( szdl );
2327 r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
2328 ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
2329 SysFreeString( str );
2330
2331 /* something that isn't in complete4A */
2332 str = SysAllocString( szOpen );
2333 node = (IXMLDOMNode *) 1;
2334 r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
2335 ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
2336 ok( node == NULL, "getNamedItem should have returned NULL\n");
2337 SysFreeString( str );
2338
2339 /* test indexed access of attributes */
2340 r = IXMLDOMNamedNodeMap_get_length( map, NULL );
2341 ok ( r == E_INVALIDARG, "get_length should return E_INVALIDARG\n");
2342
2343 r = IXMLDOMNamedNodeMap_get_length( map, &count );
2344 ok ( r == S_OK, "get_length wrong code\n");
2345 ok ( count == 1, "get_length != 1\n");
2346
2347 node = NULL;
2348 r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
2349 ok ( r == S_FALSE, "get_item (-1) wrong code\n");
2350 ok ( node == NULL, "there is no node\n");
2351
2352 node = NULL;
2353 r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
2354 ok ( r == S_FALSE, "get_item (1) wrong code\n");
2355 ok ( node == NULL, "there is no attribute\n");
2356
2357 node = NULL;
2358 r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
2359 ok ( r == S_OK, "get_item (0) wrong code\n");
2360 ok ( node != NULL, "should be attribute\n");
2361
2362 r = IXMLDOMNode_get_nodeName( node, NULL );
2363 ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2364
2365 /* content doesn't matter here */
2366 str = NULL;
2367 r = IXMLDOMNode_get_nodeName( node, &str );
2368 ok ( r == S_OK, "get_nodeName wrong code\n");
2369 ok ( str != NULL, "str is null\n");
2370 ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
2371 SysFreeString( str );
2372 IXMLDOMNode_Release( node );
2373
2374 /* test sequential access of attributes */
2375 node = NULL;
2376 r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2377 ok ( r == S_OK, "nextNode (first time) wrong code\n");
2378 ok ( node != NULL, "nextNode, should be attribute\n");
2379 IXMLDOMNode_Release( node );
2380
2381 r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2382 ok ( r != S_OK, "nextNode (second time) wrong code\n");
2383 ok ( node == NULL, "nextNode, there is no attribute\n");
2384
2385 r = IXMLDOMNamedNodeMap_reset( map );
2386 ok ( r == S_OK, "reset should return S_OK\n");
2387
2388 r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2389 ok ( r == S_OK, "nextNode (third time) wrong code\n");
2390 ok ( node != NULL, "nextNode, should be attribute\n");
2391 }
2392 else
2393 ok( FALSE, "no map\n");
2394
2395 if (node)
2396 {
2397 type = NODE_INVALID;
2398 r = IXMLDOMNode_get_nodeType( node, &type);
2399 ok( r == S_OK, "getNamedItem returned wrong code\n");
2400 ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
2401
2402 str = NULL;
2403 r = IXMLDOMNode_get_baseName( node, NULL );
2404 ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
2405
2406 str = NULL;
2407 r = IXMLDOMNode_get_baseName( node, &str );
2408 ok( r == S_OK, "get_baseName returned wrong code\n");
2409 ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
2410 SysFreeString( str );
2411
2412 r = IXMLDOMNode_get_childNodes( node, NULL );
2413 ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
2414
2415 r = IXMLDOMNode_get_childNodes( node, &list );
2416 ok( r == S_OK, "get_childNodes returned wrong code\n");
2417
2418 if (list)
2419 {
2420 r = IXMLDOMNodeList_nextNode( list, &next );
2421 ok( r == S_OK, "nextNode returned wrong code\n");
2422 }
2423 else
2424 ok( FALSE, "no childlist\n");
2425
2426 if (next)
2427 {
2428 EXPECT_NO_CHILDREN(next);
2429
2430 type = NODE_INVALID;
2431 r = IXMLDOMNode_get_nodeType( next, &type);
2432 ok( r == S_OK, "getNamedItem returned wrong code\n");
2433 ok( type == NODE_TEXT, "node not text\n");
2434
2435 str = (void *)0xdeadbeef;
2436 r = IXMLDOMNode_get_baseName( next, &str );
2437 ok( r == S_FALSE, "get_baseName returned wrong code\n");
2438 ok( str == NULL, "basename was wrong\n");
2439 SysFreeString(str);
2440 }
2441 else
2442 ok( FALSE, "no next\n");
2443
2444 if (next)
2445 IXMLDOMNode_Release( next );
2446 next = NULL;
2447 if (list)
2448 IXMLDOMNodeList_Release( list );
2449 list = NULL;
2450 if (node)
2451 IXMLDOMNode_Release( node );
2452 }
2453 else
2454 ok( FALSE, "no node\n");
2455 node = NULL;
2456
2457 if (map)
2458 IXMLDOMNamedNodeMap_Release( map );
2459
2460 /* now traverse the tree from the root element */
2461 if (element)
2462 {
2463 r = IXMLDOMElement_get_childNodes( element, &list );
2464 ok( r == S_OK, "get_childNodes returned wrong code\n");
2465
2466 /* using get_item for child list doesn't advance the position */
2467 ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
2468 expect_node(node, "E2.E2.D1");
2469 IXMLDOMNode_Release(node);
2470 ole_check(IXMLDOMNodeList_nextNode(list, &node));
2471 expect_node(node, "E1.E2.D1");
2472 IXMLDOMNode_Release(node);
2473 ole_check(IXMLDOMNodeList_reset(list));
2474
2475 IXMLDOMNodeList_AddRef(list);
2476 expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
2477 ole_check(IXMLDOMNodeList_reset(list));
2478
2479 node = (void*)0xdeadbeef;
2480 str = SysAllocString(szdl);
2481 r = IXMLDOMElement_selectSingleNode( element, str, &node );
2482 SysFreeString(str);
2483 ok( r == S_FALSE, "ret %08x\n", r );
2484 ok( node == NULL, "node %p\n", node );
2485
2486 str = SysAllocString(szbs);
2487 r = IXMLDOMElement_selectSingleNode( element, str, &node );
2488 SysFreeString(str);
2489 ok( r == S_OK, "ret %08x\n", r );
2490 r = IXMLDOMNode_Release( node );
2491 ok( r == 0, "ret %08x\n", r );
2492 }
2493 else
2494 ok( FALSE, "no element\n");
2495
2496 if (list)
2497 {
2498 r = IXMLDOMNodeList_get_item(list, 0, NULL);
2499 ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2500
2501 r = IXMLDOMNodeList_get_length(list, NULL);
2502 ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2503
2504 r = IXMLDOMNodeList_get_length( list, &count );
2505 ok( r == S_OK, "get_length returns %08x\n", r );
2506 ok( count == 4, "get_length got %d\n", count );
2507
2508 r = IXMLDOMNodeList_nextNode(list, NULL);
2509 ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2510
2511 r = IXMLDOMNodeList_nextNode( list, &node );
2512 ok( r == S_OK, "nextNode returned wrong code\n");
2513 }
2514 else
2515 ok( FALSE, "no list\n");
2516
2517 if (node)
2518 {
2519 type = NODE_INVALID;
2520 r = IXMLDOMNode_get_nodeType( node, &type);
2521 ok( r == S_OK, "getNamedItem returned wrong code\n");
2522 ok( type == NODE_ELEMENT, "node not text\n");
2523
2524 r = IXMLDOMNode_hasChildNodes( node, NULL );
2525 ok( r == E_INVALIDARG, "hasChildNodes bad return\n");
2526
2527 EXPECT_CHILDREN(node);
2528
2529 str = NULL;
2530 r = IXMLDOMNode_get_baseName( node, &str );
2531 ok( r == S_OK, "get_baseName returned wrong code\n");
2532 ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
2533 SysFreeString(str);
2534 }
2535 else
2536 ok( FALSE, "no node\n");
2537
2538 if (node)
2539 IXMLDOMNode_Release( node );
2540 if (list)
2541 IXMLDOMNodeList_Release( list );
2542 if (element)
2543 IXMLDOMElement_Release( element );
2544
2545 b = FALSE;
2546 str = SysAllocString( szComplete5 );
2547 r = IXMLDOMDocument_loadXML( doc, str, &b );
2548 ok( r == S_OK, "loadXML failed\n");
2549 ok( b == VARIANT_TRUE, "failed to load XML string\n");
2550 SysFreeString( str );
2551
2552 EXPECT_CHILDREN(doc);
2553
2554 r = IXMLDOMDocument_get_documentElement( doc, &element );
2555 ok( r == S_OK, "should be a document element\n");
2556 ok( element != NULL, "should be an element\n");
2557
2558 if (element)
2559 {
2560 static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
2561 BSTR tag = NULL;
2562
2563 /* check if the tag is correct */
2564 r = IXMLDOMElement_get_tagName( element, &tag );
2565 ok( r == S_OK, "couldn't get tag name\n");
2566 ok( tag != NULL, "tag was null\n");
2567 ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
2568 SysFreeString( tag );
2569
2570 IXMLDOMElement_Release( element );
2571 }
2572 ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
2573
2574 free_bstrs();
2575}
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
expect_node
#define expect_node(node, expstr)
Definition: domdoc.c:1404
szComplete5
static const WCHAR szComplete5[]
Definition: domdoc.c:740
expect_list_and_release
#define expect_list_and_release(list, expstr)
Definition: domdoc.c:1405
next
static unsigned __int64 next
Definition: rand_nt.c:6
tag
Definition: ecma_167.h:138

Referenced by START_TEST().

◆ test_domobj_dispex()

static void test_domobj_dispex ( IUnknown *  obj)
static

Definition at line 10418 of file domdoc.c.

10419{
10420 static const WCHAR testW[] = {'t','e','s','t','p','r','o','p',0};
10421 DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
10422 IDispatchEx *dispex;
10423 IUnknown *unk;
10424 DWORD props;
10425 UINT ticnt;
10426 HRESULT hr;
10427 BSTR name;
10428
10429 hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
10430 EXPECT_HR(hr, S_OK);
10431 if (FAILED(hr)) return;
10432
10433 ticnt = 0;
10434 hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
10435 EXPECT_HR(hr, S_OK);
10436 ok(ticnt == 1, "ticnt=%u\n", ticnt);
10437
10438 name = SysAllocString(szstar);
10439 hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
10440 EXPECT_HR(hr, E_NOTIMPL);
10441 SysFreeString(name);
10442
10443 hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
10444 EXPECT_HR(hr, E_NOTIMPL);
10445
10446 props = 0;
10447 hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
10448 EXPECT_HR(hr, E_NOTIMPL);
10449 ok(props == 0, "expected 0 got %d\n", props);
10450
10451 hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
10452 EXPECT_HR(hr, E_NOTIMPL);
10453 if (SUCCEEDED(hr)) SysFreeString(name);
10454
10455 hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
10456 EXPECT_HR(hr, E_NOTIMPL);
10457
10458 unk = (IUnknown*)0xdeadbeef;
10459 hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
10460 EXPECT_HR(hr, E_NOTIMPL);
10461 ok(unk == (IUnknown*)0xdeadbeef, "got %p\n", unk);
10462
10463 name = SysAllocString(testW);
10464 hr = IDispatchEx_GetDispID(dispex, name, fdexNameEnsure, &dispid);
10465 ok(hr == DISP_E_UNKNOWNNAME, "got 0x%08x\n", hr);
10466 SysFreeString(name);
10467
10468 IDispatchEx_Release(dispex);
10469}
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
testW
static const WCHAR testW[]
Definition: jsregexp.c:44
szstar
static const WCHAR szstar[]
Definition: domdoc.c:1164
DISPID_XMLDOM_NODELIST_RESET
#define DISPID_XMLDOM_NODELIST_RESET
Definition: msxml2did.h:153
props
static const WCHAR props[]
Definition: wbemdisp.c:288
DISP_E_UNKNOWNNAME
#define DISP_E_UNKNOWNNAME
Definition: winerror.h:2515

Referenced by test_dispex(), and test_mxnamespacemanager().

◆ test_events()

static void test_events ( void  )
static

Definition at line 8445 of file domdoc.c.

8446{
8447 IConnectionPointContainer *conn;
8448 IConnectionPoint *point;
8449 IXMLDOMDocument *doc;
8450 HRESULT hr;
8451 VARIANT v;
8452 IDispatch *event;
8453
8454 doc = create_document(&IID_IXMLDOMDocument);
8455
8456 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&conn);
8457 ok(hr == S_OK, "got 0x%08x\n", hr);
8458
8459 hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IDispatch, &point);
8460 ok(hr == S_OK, "got 0x%08x\n", hr);
8461 IConnectionPoint_Release(point);
8462 hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IPropertyNotifySink, &point);
8463 ok(hr == S_OK, "got 0x%08x\n", hr);
8464 IConnectionPoint_Release(point);
8465 hr = IConnectionPointContainer_FindConnectionPoint(conn, &DIID_XMLDOMDocumentEvents, &point);
8466 ok(hr == S_OK, "got 0x%08x\n", hr);
8467 IConnectionPoint_Release(point);
8468
8469 IConnectionPointContainer_Release(conn);
8470
8471 /* ready state callback */
8472 VariantInit(&v);
8473 hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8474 ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
8475
8476 event = create_dispevent();
8477 V_VT(&v) = VT_UNKNOWN;
8478 V_UNKNOWN(&v) = (IUnknown*)event;
8479
8480 hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8481 ok(hr == S_OK, "got 0x%08x\n", hr);
8482 EXPECT_REF(event, 2);
8483
8484 V_VT(&v) = VT_DISPATCH;
8485 V_DISPATCH(&v) = event;
8486
8487 hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8488 ok(hr == S_OK, "got 0x%08x\n", hr);
8489 EXPECT_REF(event, 2);
8490
8491 /* VT_NULL doesn't reset event handler */
8492 V_VT(&v) = VT_NULL;
8493 hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8494 ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
8495 EXPECT_REF(event, 2);
8496
8497 V_VT(&v) = VT_DISPATCH;
8498 V_DISPATCH(&v) = NULL;
8499
8500 hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8501 ok(hr == S_OK, "got 0x%08x\n", hr);
8502 EXPECT_REF(event, 1);
8503
8504 V_VT(&v) = VT_UNKNOWN;
8505 V_DISPATCH(&v) = NULL;
8506 hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8507 ok(hr == S_OK, "got 0x%08x\n", hr);
8508
8509 IDispatch_Release(event);
8510
8511 IXMLDOMDocument_Release(doc);
8512}
VT_UNKNOWN
@ VT_UNKNOWN
Definition: compat.h:2308
point
POINTL point
Definition: edittest.c:50
create_dispevent
static IDispatch * create_dispevent(void)
Definition: domdoc.c:234
V_UNKNOWN
#define V_UNKNOWN(A)
Definition: oleauto.h:281
IID_IConnectionPointContainer
const GUID IID_IConnectionPointContainer
IID_IPropertyNotifySink
const GUID IID_IPropertyNotifySink
DISP_E_TYPEMISMATCH
#define DISP_E_TYPEMISMATCH
Definition: winerror.h:2514

Referenced by START_TEST().

◆ test_FormattingXML()

static void test_FormattingXML ( void  )
static

Definition at line 6747 of file domdoc.c.

6748{
6749 IXMLDOMDocument *doc;
6750 IXMLDOMElement *pElement;
6751 VARIANT_BOOL bSucc;
6752 HRESULT hr;
6753 BSTR str;
6754 static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
6755 static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
6756
6757 doc = create_document(&IID_IXMLDOMDocument);
6758
6759 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
6760 ok(hr == S_OK, "ret %08x\n", hr );
6761 ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6762
6763 if(bSucc == VARIANT_TRUE)
6764 {
6765 hr = IXMLDOMDocument_get_documentElement(doc, &pElement);
6766 ok(hr == S_OK, "ret %08x\n", hr );
6767 if(hr == S_OK)
6768 {
6769 hr = IXMLDOMElement_get_xml(pElement, &str);
6770 ok(hr == S_OK, "ret %08x\n", hr );
6771 ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
6772 SysFreeString(str);
6773
6774 IXMLDOMElement_Release(pElement);
6775 }
6776 }
6777
6778 IXMLDOMDocument_Release(doc);
6779
6780 free_bstrs();
6781}
CHAR
char CHAR
Definition: xmlstorage.h:175

Referenced by START_TEST().

◆ test_get_attributes()

static void test_get_attributes ( void  )
static

Definition at line 9684 of file domdoc.c.

9685{
9686 const get_attributes_t *entry = get_attributes;
9687 IXMLDOMNamedNodeMap *map;
9688 IXMLDOMDocument *doc, *doc2;
9689 IXMLDOMNode *node, *node2;
9690 IXMLDOMElement *elem;
9691 VARIANT_BOOL b;
9692 HRESULT hr;
9693 VARIANT v;
9694 BSTR str;
9695 LONG length;
9696
9697 doc = create_document(&IID_IXMLDOMDocument);
9698
9699 hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
9700 ok(hr == S_OK, "got %08x\n", hr);
9701
9702 hr = IXMLDOMDocument_get_attributes(doc, NULL);
9703 ok(hr == E_INVALIDARG, "got %08x\n", hr);
9704
9705 map = (void*)0xdeadbeef;
9706 hr = IXMLDOMDocument_get_attributes(doc, &map);
9707 ok(hr == S_FALSE, "got %08x\n", hr);
9708 ok(map == NULL, "got %p\n", map);
9709
9710 /* first child is <?xml ?> */
9711 hr = IXMLDOMDocument_get_firstChild(doc, &node);
9712 ok(hr == S_OK, "got %08x\n", hr);
9713
9714 hr = IXMLDOMNode_get_attributes(node, &map);
9715 ok(hr == S_OK, "got %08x\n", hr);
9716
9717 node2 = (void*)0xdeadbeef;
9718 hr = IXMLDOMNamedNodeMap_getNamedItem(map, _bstr_("attr"), &node2);
9719 ok(hr == S_FALSE, "got %08x\n", hr);
9720 ok(node2 == NULL, "got %p\n", node2);
9721
9722 length = -1;
9723 hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9724 EXPECT_HR(hr, S_OK);
9725 todo_wine ok(length == 1, "got %d\n", length);
9726
9727 if (hr == S_OK && length == 1)
9728 {
9729 IXMLDOMAttribute *attr;
9730 DOMNodeType type;
9731 VARIANT v;
9732
9733 node2 = NULL;
9734 hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9735 EXPECT_HR(hr, S_OK);
9736 ok(node != NULL, "got %p\n", node2);
9737
9738 hr = IXMLDOMNode_get_nodeName(node2, &str);
9739 EXPECT_HR(hr, S_OK);
9740 ok(!lstrcmpW(str, _bstr_("version")), "got %s\n", wine_dbgstr_w(str));
9741 SysFreeString(str);
9742
9743 length = -1;
9744 hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9745 EXPECT_HR(hr, S_OK);
9746 ok(length == 1, "got %d\n", length);
9747
9748 type = -1;
9749 hr = IXMLDOMNode_get_nodeType(node2, &type);
9750 EXPECT_HR(hr, S_OK);
9751 ok(type == NODE_ATTRIBUTE, "got %d\n", type);
9752
9753 hr = IXMLDOMNode_get_xml(node, &str);
9754 EXPECT_HR(hr, S_OK);
9755 ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9756 SysFreeString(str);
9757
9758 hr = IXMLDOMNode_get_text(node, &str);
9759 EXPECT_HR(hr, S_OK);
9760 ok(!lstrcmpW(str, _bstr_("version=\"1.0\"")), "got %s\n", wine_dbgstr_w(str));
9761 SysFreeString(str);
9762
9763 hr = IXMLDOMNamedNodeMap_removeNamedItem(map, _bstr_("version"), NULL);
9764 EXPECT_HR(hr, S_OK);
9765
9766 length = -1;
9767 hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9768 EXPECT_HR(hr, S_OK);
9769 ok(length == 0, "got %d\n", length);
9770
9771 hr = IXMLDOMNode_get_xml(node, &str);
9772 EXPECT_HR(hr, S_OK);
9773 ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9774 SysFreeString(str);
9775
9776 hr = IXMLDOMNode_get_text(node, &str);
9777 EXPECT_HR(hr, S_OK);
9778 ok(!lstrcmpW(str, _bstr_("")), "got %s\n", wine_dbgstr_w(str));
9779 SysFreeString(str);
9780
9781 IXMLDOMNamedNodeMap_Release(map);
9782
9783 hr = IXMLDOMNode_get_attributes(node, &map);
9784 ok(hr == S_OK, "got %08x\n", hr);
9785
9786 length = -1;
9787 hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9788 EXPECT_HR(hr, S_OK);
9789 ok(length == 0, "got %d\n", length);
9790
9791 hr = IXMLDOMDocument_createAttribute(doc, _bstr_("encoding"), &attr);
9792 EXPECT_HR(hr, S_OK);
9793
9794 V_VT(&v) = VT_BSTR;
9795 V_BSTR(&v) = _bstr_("UTF-8");
9796 hr = IXMLDOMAttribute_put_nodeValue(attr, v);
9797 EXPECT_HR(hr, S_OK);
9798
9799 EXPECT_REF(attr, 2);
9800 hr = IXMLDOMNamedNodeMap_setNamedItem(map, (IXMLDOMNode*)attr, NULL);
9801 EXPECT_HR(hr, S_OK);
9802 EXPECT_REF(attr, 2);
9803
9804 hr = IXMLDOMNode_get_attributes(node, &map);
9805 ok(hr == S_OK, "got %08x\n", hr);
9806
9807 length = -1;
9808 hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9809 EXPECT_HR(hr, S_OK);
9810 ok(length == 1, "got %d\n", length);
9811
9812 hr = IXMLDOMNode_get_xml(node, &str);
9813 EXPECT_HR(hr, S_OK);
9814 ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9815 SysFreeString(str);
9816
9817 hr = IXMLDOMNode_get_text(node, &str);
9818 EXPECT_HR(hr, S_OK);
9819 ok(!lstrcmpW(str, _bstr_("encoding=\"UTF-8\"")), "got %s\n", wine_dbgstr_w(str));
9820 SysFreeString(str);
9821
9822 IXMLDOMNamedNodeMap_Release(map);
9823 IXMLDOMNode_Release(node2);
9824 }
9825
9826 IXMLDOMNode_Release(node);
9827
9828 /* last child is element */
9829 EXPECT_REF(doc, 1);
9830 hr = IXMLDOMDocument_get_lastChild(doc, &node);
9831 ok(hr == S_OK, "got %08x\n", hr);
9832 EXPECT_REF(doc, 1);
9833
9834 EXPECT_REF(node, 1);
9835 hr = IXMLDOMNode_get_attributes(node, &map);
9836 ok(hr == S_OK, "got %08x\n", hr);
9837 EXPECT_REF(node, 1);
9838 EXPECT_REF(doc, 1);
9839
9840 EXPECT_REF(map, 1);
9841 hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9842 ok(hr == S_OK, "got %08x\n", hr);
9843 EXPECT_REF(node, 1);
9844 EXPECT_REF(node2, 1);
9845 EXPECT_REF(map, 1);
9846 EXPECT_REF(doc, 1);
9847 IXMLDOMNode_Release(node2);
9848
9849 /* release node before map release, map still works */
9850 IXMLDOMNode_Release(node);
9851
9852 length = 0;
9853 hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9854 ok(hr == S_OK, "got %08x\n", hr);
9855 ok(length == 1, "got %d\n", length);
9856
9857 node2 = NULL;
9858 hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9859 ok(hr == S_OK, "got %08x\n", hr);
9860 EXPECT_REF(node2, 1);
9861 IXMLDOMNode_Release(node2);
9862
9863 IXMLDOMNamedNodeMap_Release(map);
9864
9865 /* append created element a different document, map still works */
9866 hr = IXMLDOMDocument_createElement(doc, _bstr_("test"), &elem);
9867 ok(hr == S_OK, "createElement failed: %08x\n", hr);
9868
9869 V_VT(&v) = VT_I4;
9870 V_I4(&v) = 1;
9871 hr = IXMLDOMElement_setAttribute(elem, _bstr_("testattr"), v);
9872 ok(hr == S_OK, "setAttribute failed: %08x\n", hr);
9873
9874 hr = IXMLDOMElement_get_attributes(elem, &map);
9875 ok(hr == S_OK, "get_attributes failed: %08x\n", hr);
9876
9877 length = 0;
9878 hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9879 ok(hr == S_OK, "got %08x\n", hr);
9880 ok(length == 1, "got %d\n", length);
9881
9882 doc2 = create_document(&IID_IXMLDOMDocument);
9883
9884 hr = IXMLDOMDocument_appendChild(doc2, (IXMLDOMNode*)elem, &node);
9885 ok(hr == S_OK, "appendChild failed: %08x\n", hr);
9886 ok(node == (IXMLDOMNode*)elem, "node != elem\n");
9887 IXMLDOMNode_Release(node);
9888 IXMLDOMElement_Release(elem);
9889 IXMLDOMDocument_Release(doc2);
9890
9891 length = 0;
9892 hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9893 ok(hr == S_OK, "got %08x\n", hr);
9894 ok(length == 1, "got %d\n", length);
9895
9896 IXMLDOMNamedNodeMap_Release(map);
9897
9898 while (entry->type)
9899 {
9900 VARIANT var;
9901
9902 node = NULL;
9903
9904 V_VT(&var) = VT_I4;
9905 V_I4(&var) = entry->type;
9906 hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
9907 ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9908
9909 hr = IXMLDOMNode_get_attributes(node, NULL);
9910 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9911
9912 map = (void*)0xdeadbeef;
9913 hr = IXMLDOMNode_get_attributes(node, &map);
9914 ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
9915 hr, entry->hr, entry->type);
9916 ok(map == NULL, "got %p\n", map);
9917
9918 IXMLDOMNode_Release(node);
9919
9920 entry++;
9921 }
9922
9923 IXMLDOMDocument_Release(doc);
9924 free_bstrs();
9925}
get_attributes
static const get_attributes_t get_attributes[]
Definition: domdoc.c:9673
_get_attributes_t
Definition: domdoc.c:9668

Referenced by START_TEST().

◆ test_get_childNodes()

static void test_get_childNodes ( void  )
static

Definition at line 3560 of file domdoc.c.

3561{
3562 IXMLDOMNodeList *node_list, *node_list2;
3563 IEnumVARIANT *enum1, *enum2, *enum3;
3564 VARIANT_BOOL b;
3565 IXMLDOMDocument *doc;
3566 IXMLDOMNode *node, *node2;
3567 IXMLDOMElement *element;
3568 IUnknown *unk1, *unk2;
3569 HRESULT hr;
3570 VARIANT v;
3571 BSTR str;
3572 LONG len;
3573
3574 doc = create_document(&IID_IXMLDOMDocument);
3575
3576 hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3577 EXPECT_HR(hr, S_OK);
3578 ok( b == VARIANT_TRUE, "failed to load XML string\n");
3579
3580 hr = IXMLDOMDocument_get_documentElement( doc, &element );
3581 EXPECT_HR(hr, S_OK);
3582
3583 hr = IXMLDOMElement_get_childNodes( element, &node_list );
3584 EXPECT_HR(hr, S_OK);
3585
3586#ifdef __REACTOS__
3587 verify_nodelist_query_interface(node_list);
3588#endif
3589
3590 hr = IXMLDOMNodeList_get_length( node_list, &len );
3591 EXPECT_HR(hr, S_OK);
3592 ok( len == 4, "len %d\n", len);
3593
3594 /* refcount tests for IEnumVARIANT support */
3595 EXPECT_REF(node_list, 1);
3596 hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum1);
3597 EXPECT_HR(hr, S_OK);
3598 EXPECT_REF(node_list, 1);
3599 EXPECT_REF(enum1, 2);
3600
3601 EXPECT_REF(node_list, 1);
3602 hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum2);
3603 EXPECT_HR(hr, S_OK);
3604 EXPECT_REF(node_list, 1);
3605 ok(enum2 == enum1, "got %p, %p\n", enum2, enum1);
3606 IEnumVARIANT_Release(enum2);
3607
3608 hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
3609 EXPECT_HR(hr, S_OK);
3610 hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
3611 EXPECT_HR(hr, S_OK);
3612 EXPECT_REF(node_list, 3);
3613 EXPECT_REF(enum1, 2);
3614 ok(unk1 == unk2, "got %p, %p\n", unk1, unk2);
3615 IUnknown_Release(unk1);
3616 IUnknown_Release(unk2);
3617
3618 EXPECT_REF(node_list, 1);
3619 hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum2);
3620 EXPECT_HR(hr, S_OK);
3621 EXPECT_REF(node_list, 2);
3622 EXPECT_REF(enum2, 1);
3623 ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
3624
3625 /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
3626 hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
3627 EXPECT_HR(hr, S_OK);
3628 hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
3629 EXPECT_HR(hr, S_OK);
3630 EXPECT_REF(node_list, 3);
3631 EXPECT_REF(enum2, 2);
3632 ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
3633 IUnknown_Release(unk1);
3634 IUnknown_Release(unk2);
3635
3636 hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum3);
3637 EXPECT_HR(hr, S_OK);
3638 ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
3639 IEnumVARIANT_Release(enum3);
3640 IEnumVARIANT_Release(enum2);
3641
3642 /* iteration tests */
3643 hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
3644 EXPECT_HR(hr, S_OK);
3645 hr = IXMLDOMNode_get_nodeName(node, &str);
3646 EXPECT_HR(hr, S_OK);
3647 ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
3648 SysFreeString(str);
3649 IXMLDOMNode_Release(node);
3650
3651 hr = IXMLDOMNodeList_nextNode(node_list, &node);
3652 EXPECT_HR(hr, S_OK);
3653 hr = IXMLDOMNode_get_nodeName(node, &str);
3654 EXPECT_HR(hr, S_OK);
3655 ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
3656 SysFreeString(str);
3657 IXMLDOMNode_Release(node);
3658
3659 V_VT(&v) = VT_EMPTY;
3660 hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
3661 EXPECT_HR(hr, S_OK);
3662 ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
3663 hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
3664 EXPECT_HR(hr, S_OK);
3665 hr = IXMLDOMNode_get_nodeName(node, &str);
3666 EXPECT_HR(hr, S_OK);
3667 ok(!lstrcmpW(str, _bstr_("bs")), "got node name %s\n", wine_dbgstr_w(str));
3668 SysFreeString(str);
3669 IXMLDOMNode_Release(node);
3670 VariantClear(&v);
3671
3672 hr = IXMLDOMNodeList_nextNode(node_list, &node);
3673 EXPECT_HR(hr, S_OK);
3674 hr = IXMLDOMNode_get_nodeName(node, &str);
3675 EXPECT_HR(hr, S_OK);
3676 ok(!lstrcmpW(str, _bstr_("pr")), "got %s\n", wine_dbgstr_w(str));
3677 SysFreeString(str);
3678 IXMLDOMNode_Release(node);
3679
3680 IEnumVARIANT_Release(enum1);
3681
3682 hr = IXMLDOMNodeList_get_item( node_list, 2, &node );
3683 EXPECT_HR(hr, S_OK);
3684
3685 hr = IXMLDOMNode_get_childNodes( node, &node_list2 );
3686 EXPECT_HR(hr, S_OK);
3687
3688 hr = IXMLDOMNodeList_get_length( node_list2, &len );
3689 EXPECT_HR(hr, S_OK);
3690 ok( len == 0, "len %d\n", len);
3691
3692 hr = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
3693 EXPECT_HR(hr, S_FALSE);
3694
3695 IXMLDOMNodeList_Release( node_list2 );
3696 IXMLDOMNode_Release( node );
3697 IXMLDOMNodeList_Release( node_list );
3698 IXMLDOMElement_Release( element );
3699
3700 /* test for children of <?xml ..?> node */
3701 hr = IXMLDOMDocument_get_firstChild(doc, &node);
3702 EXPECT_HR(hr, S_OK);
3703
3704 str = NULL;
3705 hr = IXMLDOMNode_get_nodeName(node, &str);
3706 EXPECT_HR(hr, S_OK);
3707 ok(!lstrcmpW(str, _bstr_("xml")), "got %s\n", wine_dbgstr_w(str));
3708 SysFreeString(str);
3709
3710 /* it returns empty but valid node list */
3711 node_list = (void*)0xdeadbeef;
3712 hr = IXMLDOMNode_get_childNodes(node, &node_list);
3713 EXPECT_HR(hr, S_OK);
3714
3715 len = -1;
3716 hr = IXMLDOMNodeList_get_length(node_list, &len);
3717 EXPECT_HR(hr, S_OK);
3718 ok(len == 0, "got %d\n", len);
3719
3720 IXMLDOMNodeList_Release( node_list );
3721 IXMLDOMNode_Release(node);
3722
3723 IXMLDOMDocument_Release( doc );
3724 free_bstrs();
3725}
unk1
static DWORD unk1
Definition: cursoricon.c:1638

Referenced by START_TEST().

◆ test_get_dataType()

static void test_get_dataType ( void  )
static

Definition at line 9572 of file domdoc.c.

9573{
9574 const node_type_t *entry = get_datatype;
9575 IXMLDOMDocument *doc;
9576
9577 doc = create_document(&IID_IXMLDOMDocument);
9578
9579 while (entry->type)
9580 {
9581 IXMLDOMNode *node = NULL;
9582 VARIANT var, type;
9583 HRESULT hr;
9584
9585 V_VT(&var) = VT_I4;
9586 V_I4(&var) = entry->type;
9587 hr = IXMLDOMDocument_createNode(doc, var, _bstr_(entry->name), NULL, &node);
9588 ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9589
9590 hr = IXMLDOMNode_get_dataType(node, NULL);
9591 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9592
9593 VariantInit(&type);
9594 hr = IXMLDOMNode_get_dataType(node, &type);
9595 ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
9596 hr, entry->hr, entry->type);
9597 ok(V_VT(&type) == entry->vt, "got %d, expected %d. node type %d\n",
9598 V_VT(&type), entry->vt, entry->type);
9599 VariantClear(&type);
9600
9601 IXMLDOMNode_Release(node);
9602
9603 entry++;
9604 }
9605
9606 IXMLDOMDocument_Release(doc);
9607 free_bstrs();
9608}
get_datatype
static const node_type_t get_datatype[]
Definition: domdoc.c:9560
node_type_t
Definition: domdoc.c:9553

Referenced by START_TEST().

◆ test_get_doctype()

static void test_get_doctype ( void  )
static

Definition at line 9472 of file domdoc.c.

9473{
9474 static const WCHAR emailW[] = {'e','m','a','i','l',0};
9475 IXMLDOMDocumentType *doctype;
9476 IXMLDOMDocument *doc;
9477 VARIANT_BOOL b;
9478 HRESULT hr;
9479 BSTR s;
9480
9481 doc = create_document(&IID_IXMLDOMDocument);
9482
9483 hr = IXMLDOMDocument_get_doctype(doc, NULL);
9484 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9485
9486 doctype = (void*)0xdeadbeef;
9487 hr = IXMLDOMDocument_get_doctype(doc, &doctype);
9488 ok(hr == S_FALSE, "got 0x%08x\n", hr);
9489 ok(doctype == NULL, "got %p\n", doctype);
9490
9491 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szEmailXML), &b);
9492 ok(hr == S_OK, "got 0x%08x\n", hr);
9493 ok(b == VARIANT_TRUE, "failed to load XML string\n");
9494
9495 doctype = NULL;
9496 hr = IXMLDOMDocument_get_doctype(doc, &doctype);
9497 ok(hr == S_OK, "got 0x%08x\n", hr);
9498 ok(doctype != NULL, "got %p\n", doctype);
9499
9500 hr = IXMLDOMDocumentType_get_name(doctype, NULL);
9501 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9502
9503 hr = IXMLDOMDocumentType_get_name(doctype, &s);
9504 ok(hr == S_OK, "got 0x%08x\n", hr);
9505 ok(!lstrcmpW(emailW, s), "got name %s\n", wine_dbgstr_w(s));
9506 SysFreeString(s);
9507
9508 hr = IXMLDOMDocumentType_get_nodeName(doctype, &s);
9509 ok(hr == S_OK, "got 0x%08x\n", hr);
9510 ok(!lstrcmpW(emailW, s), "got name %s\n", wine_dbgstr_w(s));
9511 SysFreeString(s);
9512
9513 IXMLDOMDocumentType_Release(doctype);
9514 IXMLDOMDocument_Release(doc);
9515}
s
GLdouble s
Definition: gl.h:2039
szEmailXML
static const CHAR szEmailXML[]
Definition: domdoc.c:963

Referenced by START_TEST().

◆ test_get_firstChild()

static void test_get_firstChild ( void  )
static

Definition at line 3727 of file domdoc.c.

3728{
3729 static const WCHAR xmlW[] = {'x','m','l',0};
3730 IXMLDOMDocument *doc;
3731 IXMLDOMNode *node;
3732 VARIANT_BOOL b;
3733 HRESULT r;
3734 BSTR str;
3735
3736 doc = create_document(&IID_IXMLDOMDocument);
3737
3738 r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3739 ok( r == S_OK, "loadXML failed\n");
3740 ok( b == VARIANT_TRUE, "failed to load XML string\n");
3741
3742 r = IXMLDOMDocument_get_firstChild( doc, &node );
3743 ok( r == S_OK, "ret %08x\n", r);
3744
3745 r = IXMLDOMNode_get_nodeName( node, &str );
3746 ok( r == S_OK, "ret %08x\n", r);
3747
3748 ok(!lstrcmpW(str, xmlW), "expected \"xml\" node name, got %s\n", wine_dbgstr_w(str));
3749
3750 SysFreeString(str);
3751 IXMLDOMNode_Release( node );
3752 IXMLDOMDocument_Release( doc );
3753
3754 free_bstrs();
3755}
xmlW
static const WCHAR xmlW[]
Definition: mxnamespace.c:61

Referenced by START_TEST().

◆ test_get_lastChild()

static void test_get_lastChild ( void  )
static

Definition at line 3757 of file domdoc.c.

3758{
3759 static const WCHAR lcW[] = {'l','c',0};
3760 static const WCHAR foW[] = {'f','o',0};
3761 IXMLDOMDocument *doc;
3762 IXMLDOMNode *node, *child;
3763 VARIANT_BOOL b;
3764 HRESULT r;
3765 BSTR str;
3766
3767 doc = create_document(&IID_IXMLDOMDocument);
3768
3769 r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3770 ok( r == S_OK, "loadXML failed\n");
3771 ok( b == VARIANT_TRUE, "failed to load XML string\n");
3772
3773 r = IXMLDOMDocument_get_lastChild( doc, &node );
3774 ok( r == S_OK, "ret %08x\n", r);
3775
3776 r = IXMLDOMNode_get_nodeName( node, &str );
3777 ok( r == S_OK, "ret %08x\n", r);
3778
3779 ok(memcmp(str, lcW, sizeof(lcW)) == 0, "expected \"lc\" node name\n");
3780 SysFreeString(str);
3781
3782 r = IXMLDOMNode_get_lastChild( node, &child );
3783 ok( r == S_OK, "ret %08x\n", r);
3784
3785 r = IXMLDOMNode_get_nodeName( child, &str );
3786 ok( r == S_OK, "ret %08x\n", r);
3787
3788 ok(memcmp(str, foW, sizeof(foW)) == 0, "expected \"fo\" node name\n");
3789 SysFreeString(str);
3790
3791 IXMLDOMNode_Release( child );
3792 IXMLDOMNode_Release( node );
3793 IXMLDOMDocument_Release( doc );
3794
3795 free_bstrs();
3796}
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112

Referenced by START_TEST().

◆ test_get_namespaces()

static void test_get_namespaces ( void  )
static

Definition at line 11828 of file domdoc.c.

11829{
11830 IXMLDOMSchemaCollection *collection, *collection2;
11831 IXMLDOMDocument2 *doc, *doc2;
11832 IEnumVARIANT *enumv, *enum2;
11833 IUnknown *unk1, *unk2;
11834 IXMLDOMNode *node;
11835 VARIANT_BOOL b;
11836 HRESULT hr;
11837 VARIANT v;
11838 LONG len;
11839 BSTR s;
11840
11841 if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
11842 doc = create_document(&IID_IXMLDOMDocument2);
11843
11844 /* null pointer */
11845 hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
11846 EXPECT_HR(hr, E_POINTER);
11847
11848 /* no document loaded */
11849 collection = (void*)0xdeadbeef;
11850 hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11851 EXPECT_HR(hr, S_OK);
11852 if (hr != S_OK)
11853 {
11854 IXMLDOMDocument2_Release(doc);
11855 return;
11856 }
11857 EXPECT_REF(collection, 2);
11858
11859 collection2 = (void*)0xdeadbeef;
11860 hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
11861 EXPECT_HR(hr, S_OK);
11862 ok(collection == collection2, "got %p\n", collection2);
11863 EXPECT_REF(collection, 3);
11864 IXMLDOMSchemaCollection_Release(collection);
11865
11866 len = -1;
11867 hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11868 EXPECT_HR(hr, S_OK);
11869 ok(len == 0, "got %d\n", len);
11870 IXMLDOMSchemaCollection_Release(collection);
11871
11872 /* now with document */
11873 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
11874 EXPECT_HR(hr, S_OK);
11875
11876 hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11877 EXPECT_HR(hr, S_OK);
11878
11879 len = -1;
11880 hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11881 EXPECT_HR(hr, S_OK);
11882 ok(len == 2, "got %d\n", len);
11883
11884 /* try to lookup some uris */
11885 node = (void*)0xdeadbeef;
11886 hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
11887 EXPECT_HR(hr, S_OK);
11888 ok(node == NULL, "got %p\n", node);
11889
11890 node = (void*)0xdeadbeef;
11891 hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah1.org"), &node);
11892 EXPECT_HR(hr, S_OK);
11893 ok(node == NULL, "got %p\n", node);
11894
11895 /* load schema and try to add it */
11896 doc2 = create_document(&IID_IXMLDOMDocument2);
11897 hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
11898 EXPECT_HR(hr, S_OK);
11899
11900 V_VT(&v) = VT_DISPATCH;
11901 V_DISPATCH(&v) = (IDispatch*)doc2;
11902 hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
11903 EXPECT_HR(hr, E_FAIL);
11904
11905 hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
11906 EXPECT_HR(hr, S_OK);
11907 ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
11908 SysFreeString(s);
11909
11910 hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
11911 EXPECT_HR(hr, S_OK);
11912 ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
11913 SysFreeString(s);
11914
11915 s = (void*)0xdeadbeef;
11916 hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
11917 EXPECT_HR(hr, E_FAIL);
11918 ok(s == (void*)0xdeadbeef, "got %p\n", s);
11919
11920 /* enumerate */
11921 enumv = (void*)0xdeadbeef;
11922 EXPECT_REF(collection, 2);
11923 hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
11924 EXPECT_HR(hr, S_OK);
11925 EXPECT_REF(collection, 3);
11926 ok(enumv != NULL, "got %p\n", enumv);
11927
11928 hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IUnknown, (void**)&unk1);
11929 EXPECT_HR(hr, S_OK);
11930 hr = IEnumVARIANT_QueryInterface(enumv, &IID_IUnknown, (void**)&unk2);
11931 EXPECT_HR(hr, S_OK);
11932 ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
11933 IUnknown_Release(unk1);
11934 IUnknown_Release(unk2);
11935
11936 hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IEnumVARIANT, (void**)&enum2);
11937 EXPECT_HR(hr, E_NOINTERFACE);
11938
11939 V_VT(&v) = VT_EMPTY;
11940 hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11941 EXPECT_HR(hr, S_OK);
11942 ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11943 ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11944 VariantClear(&v);
11945
11946 V_VT(&v) = VT_EMPTY;
11947 hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11948 EXPECT_HR(hr, S_OK);
11949 ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11950 ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11951 VariantClear(&v);
11952
11953 V_VT(&v) = VT_NULL;
11954 hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11955 EXPECT_HR(hr, S_FALSE);
11956 ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
11957
11958 IEnumVARIANT_Release(enumv);
11959 IXMLDOMSchemaCollection_Release(collection);
11960
11961 IXMLDOMDocument2_Release(doc);
11962
11963 /* now with CLSID_DOMDocument60 */
11964 if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument2)) return;
11965 doc = create_document_version(60, &IID_IXMLDOMDocument2);
11966
11967 /* null pointer */
11968 hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
11969 EXPECT_HR(hr, E_POINTER);
11970
11971 /* no document loaded */
11972 collection = (void*)0xdeadbeef;
11973 hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11974 EXPECT_HR(hr, S_OK);
11975 if (hr != S_OK)
11976 {
11977 IXMLDOMDocument2_Release(doc);
11978 return;
11979 }
11980 EXPECT_REF(collection, 2);
11981
11982 collection2 = (void*)0xdeadbeef;
11983 hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
11984 EXPECT_HR(hr, S_OK);
11985 ok(collection == collection2, "got %p\n", collection2);
11986 EXPECT_REF(collection, 3);
11987 IXMLDOMSchemaCollection_Release(collection);
11988
11989 len = -1;
11990 hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11991 EXPECT_HR(hr, S_OK);
11992 ok(len == 0, "got %d\n", len);
11993 IXMLDOMSchemaCollection_Release(collection);
11994
11995 /* now with document */
11996 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
11997 EXPECT_HR(hr, S_OK);
11998
11999 hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
12000 EXPECT_HR(hr, S_OK);
12001
12002 len = -1;
12003 hr = IXMLDOMSchemaCollection_get_length(collection, &len);
12004 EXPECT_HR(hr, S_OK);
12005 ok(len == 2, "got %d\n", len);
12006
12007 /* try to lookup some uris */
12008 node = (void*)0xdeadbeef;
12009 hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
12010 EXPECT_HR(hr, E_NOTIMPL);
12011 ok(broken(node == (void*)0xdeadbeef) || (node == NULL), "got %p\n", node);
12012
12013 /* load schema and try to add it */
12014 doc2 = create_document(&IID_IXMLDOMDocument2);
12015 hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
12016 EXPECT_HR(hr, S_OK);
12017
12018 V_VT(&v) = VT_DISPATCH;
12019 V_DISPATCH(&v) = (IDispatch*)doc2;
12020 hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
12021 EXPECT_HR(hr, E_FAIL);
12022 IXMLDOMDocument2_Release(doc2);
12023
12024 hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
12025 EXPECT_HR(hr, S_OK);
12026 ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
12027 SysFreeString(s);
12028
12029 hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
12030 EXPECT_HR(hr, S_OK);
12031 ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
12032 SysFreeString(s);
12033
12034 s = (void*)0xdeadbeef;
12035 hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
12036 EXPECT_HR(hr, E_FAIL);
12037 ok(broken(s == (void*)0xdeadbeef) || (s == NULL), "got %p\n", s);
12038
12039 /* enumerate */
12040 enumv = (void*)0xdeadbeef;
12041 hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
12042 EXPECT_HR(hr, S_OK);
12043 ok(enumv != NULL, "got %p\n", enumv);
12044
12045 V_VT(&v) = VT_EMPTY;
12046 hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12047 EXPECT_HR(hr, S_OK);
12048 ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12049 ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12050 VariantClear(&v);
12051
12052 V_VT(&v) = VT_EMPTY;
12053 hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12054 EXPECT_HR(hr, S_OK);
12055 ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12056 ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12057 VariantClear(&v);
12058
12059 V_VT(&v) = VT_NULL;
12060 hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12061 EXPECT_HR(hr, S_FALSE);
12062 ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
12063
12064 IEnumVARIANT_Release(enumv);
12065 IXMLDOMSchemaCollection_Release(collection);
12066 IXMLDOMDocument2_Release(doc);
12067 free_bstrs();
12068}
namespacesA
static const char namespacesA[]
Definition: domdoc.c:11804
xsd_schema1_uri
static const char xsd_schema1_uri[]
Definition: domdoc.c:11814
xsd_schema1_xml
static const char xsd_schema1_xml[]
Definition: domdoc.c:11815
collection
static ICollection collection
Definition: typelib.c:184

Referenced by START_TEST().

◆ test_get_nodeTypeString()

static void test_get_nodeTypeString ( void  )
static

Definition at line 9627 of file domdoc.c.

9628{
9629 const get_node_typestring_t *entry = get_node_typestring;
9630 IXMLDOMDocument *doc;
9631 HRESULT hr;
9632 BSTR str;
9633
9634 doc = create_document(&IID_IXMLDOMDocument);
9635
9636 hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
9637 ok(hr == S_OK, "got 0x%08x\n", hr);
9638 ok(!lstrcmpW(str, _bstr_("document")), "got string %s\n", wine_dbgstr_w(str));
9639 SysFreeString(str);
9640
9641 while (entry->type)
9642 {
9643 IXMLDOMNode *node = NULL;
9644 VARIANT var;
9645
9646 V_VT(&var) = VT_I4;
9647 V_I4(&var) = entry->type;
9648 hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
9649 ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9650
9651 hr = IXMLDOMNode_get_nodeTypeString(node, NULL);
9652 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9653
9654 hr = IXMLDOMNode_get_nodeTypeString(node, &str);
9655 ok(hr == S_OK, "got 0x%08x\n", hr);
9656 ok(!lstrcmpW(str, _bstr_(entry->string)), "got string %s, expected %s. node type %d\n",
9657 wine_dbgstr_w(str), entry->string, entry->type);
9658 SysFreeString(str);
9659 IXMLDOMNode_Release(node);
9660
9661 entry++;
9662 }
9663
9664 IXMLDOMDocument_Release(doc);
9665 free_bstrs();
9666}
get_node_typestring
static const get_node_typestring_t get_node_typestring[]
Definition: domdoc.c:9615
_get_node_typestring_t
Definition: domdoc.c:9610

Referenced by START_TEST().

◆ test_get_ownerDocument()

static void test_get_ownerDocument ( void  )
static

Definition at line 7911 of file domdoc.c.

7912{
7913 IXMLDOMDocument *doc1, *doc2, *doc3;
7914 IXMLDOMDocument2 *doc, *doc_owner;
7915 IXMLDOMNode *node;
7916 IXMLDOMSchemaCollection *cache;
7917 VARIANT_BOOL b;
7918 VARIANT var;
7919 IXMLDOMElement *element;
7920 IXMLDOMNodeList *node_list;
7921 IXMLDOMAttribute *attr;
7922 LONG i, len;
7923 HRESULT hr;
7924 const CHAR nodeXML[] =
7925 "<root id='0'>"
7926 " <!-- comment node 0 -->"
7927 " text node 0"
7928 " <x attr='val'></x>"
7929 " <?foo value='PI for x'?>"
7930 " <![CDATA[ cdata ]]>"
7931 "</root>";
7932
7933 if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
7934 if (!is_clsid_supported(&CLSID_XMLSchemaCache, &IID_IXMLDOMSchemaCollection)) return;
7935
7936 doc = create_document(&IID_IXMLDOMDocument2);
7937 cache = create_cache(&IID_IXMLDOMSchemaCollection);
7938
7939 VariantInit(&var);
7940
7941 ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
7942 ok(b == VARIANT_TRUE, "failed to load XML string\n");
7943
7944 check_default_props(doc);
7945
7946 /* set properties and check that new instances use them */
7947 set_props(doc, cache);
7948 check_set_props(doc);
7949
7950 ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
7951 ole_check(IXMLDOMNode_get_ownerDocument(node, &doc1));
7952
7953 /* new interface keeps props */
7954 ole_check(IXMLDOMDocument_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**)&doc_owner));
7955 ok( doc_owner != doc, "got %p, doc %p\n", doc_owner, doc);
7956 check_set_props(doc_owner);
7957 IXMLDOMDocument2_Release(doc_owner);
7958
7959 ole_check(IXMLDOMNode_get_ownerDocument(node, &doc2));
7960 IXMLDOMNode_Release(node);
7961
7962 ok(doc1 != doc2, "got %p, expected %p. original %p\n", doc2, doc1, doc);
7963
7964 /* reload */
7965 ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
7966 ok(b == VARIANT_TRUE, "failed to load XML string\n");
7967
7968 /* properties retained even after reload */
7969 check_set_props(doc);
7970
7971 ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
7972 ole_check(IXMLDOMNode_get_ownerDocument(node, &doc3));
7973 IXMLDOMNode_Release(node);
7974
7975 ole_check(IXMLDOMDocument_QueryInterface(doc3, &IID_IXMLDOMDocument2, (void**)&doc_owner));
7976 ok(doc3 != doc1 && doc3 != doc2 && doc_owner != doc, "got %p, (%p, %p, %p)\n", doc3, doc, doc1, doc2);
7977 check_set_props(doc_owner);
7978
7979 /* changing properties for one instance changes them for all */
7980 unset_props(doc_owner);
7981 check_default_props(doc_owner);
7982 check_default_props(doc);
7983
7984 /* NULL check */
7985 hr = IXMLDOMDocument_loadXML(doc1, _bstr_(nodeXML), &b);
7986 EXPECT_HR(hr, S_OK);
7987 ok(b == VARIANT_TRUE, "failed to load XML string\n");
7988
7989 hr = IXMLDOMDocument_get_documentElement(doc1, &element);
7990 EXPECT_HR(hr, S_OK);
7991
7992 hr = IXMLDOMElement_get_childNodes(element, &node_list);
7993 EXPECT_HR(hr, S_OK);
7994
7995 hr = IXMLDOMNodeList_get_length(node_list, &len);
7996 EXPECT_HR(hr, S_OK);
7997
7998 for(i = 0; i < len; i++) {
7999 hr = IXMLDOMNodeList_get_item(node_list, i, &node);
8000 EXPECT_HR(hr, S_OK);
8001
8002 hr = IXMLDOMNode_get_ownerDocument(node, NULL);
8003 EXPECT_HR(hr, E_INVALIDARG);
8004
8005 IXMLDOMNode_Release(node);
8006 }
8007 IXMLDOMElement_Release(element);
8008
8009 /* Test Attribute Node */
8010 hr = IXMLDOMNodeList_get_item(node_list, 2, &node);
8011 EXPECT_HR(hr, S_OK);
8012 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&element);
8013 EXPECT_HR(hr, S_OK);
8014 IXMLDOMNode_Release(node);
8015
8016 hr = IXMLDOMElement_getAttributeNode(element, _bstr_("attr"), &attr);
8017 EXPECT_HR(hr, S_OK);
8018 ok(attr != NULL, "attr == NULL\n");
8019 IXMLDOMElement_Release(element);
8020 hr = IXMLDOMAttribute_get_ownerDocument(attr, NULL);
8021 EXPECT_HR(hr, E_INVALIDARG);
8022 IXMLDOMAttribute_Release(attr);
8023 IXMLDOMNodeList_Release(node_list);
8024
8025 IXMLDOMSchemaCollection_Release(cache);
8026 IXMLDOMDocument_Release(doc1);
8027 IXMLDOMDocument_Release(doc2);
8028 IXMLDOMDocument_Release(doc3);
8029 IXMLDOMDocument2_Release(doc);
8030 //IXMLDOMDocument2_Release(doc_owner); FIXME: double-free!
8031 free_bstrs();
8032}
create_cache
#define create_cache(iid)
Definition: domdoc.c:1230
check_set_props
#define check_set_props(doc)
Definition: domdoc.c:7857
set_props
#define set_props(doc, cache)
Definition: domdoc.c:7880
unset_props
#define unset_props(doc)
Definition: domdoc.c:7897
check_default_props
#define check_default_props(doc)
Definition: domdoc.c:7833

Referenced by START_TEST().

◆ test_get_prefix()

static void test_get_prefix ( void  )
static

Definition at line 8268 of file domdoc.c.

8269{
8270 IXMLDOMDocumentFragment *fragment;
8271 IXMLDOMCDATASection *cdata;
8272 IXMLDOMElement *element;
8273 IXMLDOMComment *comment;
8274 IXMLDOMDocument *doc;
8275 VARIANT_BOOL b;
8276 HRESULT hr;
8277 BSTR str;
8278
8279 doc = create_document(&IID_IXMLDOMDocument);
8280
8281 /* nodes that can't support prefix */
8282 /* 1. document */
8283 str = (void*)0xdeadbeef;
8284 hr = IXMLDOMDocument_get_prefix(doc, &str);
8285 EXPECT_HR(hr, S_FALSE);
8286 ok(str == NULL, "got %p\n", str);
8287
8288 hr = IXMLDOMDocument_get_prefix(doc, NULL);
8289 EXPECT_HR(hr, E_INVALIDARG);
8290
8291 /* 2. cdata */
8292 hr = IXMLDOMDocument_createCDATASection(doc, NULL, &cdata);
8293 ok(hr == S_OK, "got %08x\n", hr );
8294
8295 str = (void*)0xdeadbeef;
8296 hr = IXMLDOMCDATASection_get_prefix(cdata, &str);
8297 ok(hr == S_FALSE, "got %08x\n", hr);
8298 ok( str == 0, "got %p\n", str);
8299
8300 hr = IXMLDOMCDATASection_get_prefix(cdata, NULL);
8301 ok(hr == E_INVALIDARG, "got %08x\n", hr);
8302 IXMLDOMCDATASection_Release(cdata);
8303
8304 /* 3. comment */
8305 hr = IXMLDOMDocument_createComment(doc, NULL, &comment);
8306 ok(hr == S_OK, "got %08x\n", hr );
8307
8308 str = (void*)0xdeadbeef;
8309 hr = IXMLDOMComment_get_prefix(comment, &str);
8310 ok(hr == S_FALSE, "got %08x\n", hr);
8311 ok( str == 0, "got %p\n", str);
8312
8313 hr = IXMLDOMComment_get_prefix(comment, NULL);
8314 ok(hr == E_INVALIDARG, "got %08x\n", hr);
8315 IXMLDOMComment_Release(comment);
8316
8317 /* 4. fragment */
8318 hr = IXMLDOMDocument_createDocumentFragment(doc, &fragment);
8319 ok(hr == S_OK, "got %08x\n", hr );
8320
8321 str = (void*)0xdeadbeef;
8322 hr = IXMLDOMDocumentFragment_get_prefix(fragment, &str);
8323 ok(hr == S_FALSE, "got %08x\n", hr);
8324 ok( str == 0, "got %p\n", str);
8325
8326 hr = IXMLDOMDocumentFragment_get_prefix(fragment, NULL);
8327 ok(hr == E_INVALIDARG, "got %08x\n", hr);
8328 IXMLDOMDocumentFragment_Release(fragment);
8329
8330 /* no prefix */
8331 hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &element);
8332 ok( hr == S_OK, "got 0x%08x\n", hr);
8333
8334 hr = IXMLDOMElement_get_prefix(element, NULL);
8335 ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
8336
8337 str = (void*)0xdeadbeef;
8338 hr = IXMLDOMElement_get_prefix(element, &str);
8339 ok( hr == S_FALSE, "got 0x%08x\n", hr);
8340 ok( str == 0, "got %p\n", str);
8341
8342 IXMLDOMElement_Release(element);
8343
8344 /* with prefix */
8345 hr = IXMLDOMDocument_createElement(doc, _bstr_("a:elem"), &element);
8346 ok( hr == S_OK, "got 0x%08x\n", hr);
8347
8348 str = (void*)0xdeadbeef;
8349 hr = IXMLDOMElement_get_prefix(element, &str);
8350 ok( hr == S_OK, "got 0x%08x\n", hr);
8351 ok( lstrcmpW(str, _bstr_("a")) == 0, "expected prefix \"a\"\n");
8352 SysFreeString(str);
8353
8354 str = (void*)0xdeadbeef;
8355 hr = IXMLDOMElement_get_namespaceURI(element, &str);
8356 ok( hr == S_FALSE, "got 0x%08x\n", hr);
8357 ok( str == 0, "got %p\n", str);
8358
8359 IXMLDOMElement_Release(element);
8360
8361 hr = IXMLDOMDocument_loadXML(doc, _bstr_(get_prefix_doc), &b);
8362 EXPECT_HR(hr, S_OK);
8363
8364 hr = IXMLDOMDocument_get_documentElement(doc, &element);
8365 EXPECT_HR(hr, S_OK);
8366
8367 str = (void*)0xdeadbeef;
8368 hr = IXMLDOMElement_get_prefix(element, &str);
8369 EXPECT_HR(hr, S_FALSE);
8370 ok(str == NULL, "got %p\n", str);
8371
8372 str = (void*)0xdeadbeef;
8373 hr = IXMLDOMElement_get_namespaceURI(element, &str);
8374 EXPECT_HR(hr, S_FALSE);
8375 ok(str == NULL, "got %s\n", wine_dbgstr_w(str));
8376
8377 IXMLDOMDocument_Release(doc);
8378 free_bstrs();
8379}
get_prefix_doc
static const char get_prefix_doc[]
Definition: domdoc.c:8264

Referenced by START_TEST().

◆ test_get_tagName()

static void test_get_tagName ( void  )
static

Definition at line 9517 of file domdoc.c.

9518{
9519 IXMLDOMDocument *doc;
9520 IXMLDOMElement *elem, *elem2;
9521 HRESULT hr;
9522 BSTR str;
9523
9524 doc = create_document(&IID_IXMLDOMDocument);
9525
9526 hr = IXMLDOMDocument_createElement(doc, _bstr_("element"), &elem);
9527 ok(hr == S_OK, "got 0x%08x\n", hr);
9528
9529 hr = IXMLDOMElement_get_tagName(elem, NULL);
9530 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9531
9532 str = NULL;
9533 hr = IXMLDOMElement_get_tagName(elem, &str);
9534 ok(hr == S_OK, "got 0x%08x\n", hr);
9535 ok(!lstrcmpW(str, _bstr_("element")), "got %s\n", wine_dbgstr_w(str));
9536 SysFreeString(str);
9537
9538 hr = IXMLDOMDocument_createElement(doc, _bstr_("s:element"), &elem2);
9539 ok(hr == S_OK, "got 0x%08x\n", hr);
9540
9541 str = NULL;
9542 hr = IXMLDOMElement_get_tagName(elem2, &str);
9543 ok(hr == S_OK, "got 0x%08x\n", hr);
9544 ok(!lstrcmpW(str, _bstr_("s:element")), "got %s\n", wine_dbgstr_w(str));
9545 SysFreeString(str);
9546
9547 IXMLDOMElement_Release(elem);
9548 IXMLDOMElement_Release(elem2);
9549 IXMLDOMDocument_Release(doc);
9550 free_bstrs();
9551}

Referenced by START_TEST().

◆ test_get_text()

static void test_get_text ( void  )
static

Definition at line 3442 of file domdoc.c.

3443{
3444 HRESULT r;
3445 BSTR str;
3446 VARIANT_BOOL b;
3447 IXMLDOMDocument *doc;
3448 IXMLDOMNode *node, *node2, *node3;
3449 IXMLDOMNode *nodeRoot;
3450 IXMLDOMNodeList *node_list;
3451 IXMLDOMNamedNodeMap *node_map;
3452 LONG len;
3453
3454 doc = create_document(&IID_IXMLDOMDocument);
3455
3456 r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3457 ok( r == S_OK, "loadXML failed\n");
3458 ok( b == VARIANT_TRUE, "failed to load XML string\n");
3459
3460 str = SysAllocString( szbs );
3461 r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
3462 ok( r == S_OK, "ret %08x\n", r );
3463 SysFreeString(str);
3464
3465 /* Test to get all child node text. */
3466 r = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&nodeRoot);
3467 ok( r == S_OK, "ret %08x\n", r );
3468 if(r == S_OK)
3469 {
3470 r = IXMLDOMNode_get_text( nodeRoot, &str );
3471 ok( r == S_OK, "ret %08x\n", r );
3472 expect_bstr_eq_and_free(str, "fn1.txt\n \nfn2.txt\n \nf1");
3473
3474 IXMLDOMNode_Release(nodeRoot);
3475 }
3476
3477 r = IXMLDOMNodeList_get_length( node_list, NULL );
3478 ok( r == E_INVALIDARG, "ret %08x\n", r );
3479
3480 r = IXMLDOMNodeList_get_length( node_list, &len );
3481 ok( r == S_OK, "ret %08x\n", r );
3482 ok( len == 1, "expect 1 got %d\n", len );
3483
3484 r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
3485 ok( r == E_INVALIDARG, "ret %08x\n", r );
3486
3487 r = IXMLDOMNodeList_nextNode( node_list, NULL );
3488 ok( r == E_INVALIDARG, "ret %08x\n", r );
3489
3490 r = IXMLDOMNodeList_get_item( node_list, 0, &node );
3491 ok( r == S_OK, "ret %08x\n", r );
3492 IXMLDOMNodeList_Release( node_list );
3493
3494 /* Invalid output parameter*/
3495 r = IXMLDOMNode_get_text( node, NULL );
3496 ok( r == E_INVALIDARG, "ret %08x\n", r );
3497
3498 r = IXMLDOMNode_get_text( node, &str );
3499 ok( r == S_OK, "ret %08x\n", r );
3500 ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
3501 SysFreeString(str);
3502
3503 r = IXMLDOMNode_get_attributes( node, &node_map );
3504 ok( r == S_OK, "ret %08x\n", r );
3505
3506 str = SysAllocString( szvr );
3507 r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
3508 ok( r == S_OK, "ret %08x\n", r );
3509 SysFreeString(str);
3510
3511 r = IXMLDOMNode_get_text( node2, &str );
3512 ok( r == S_OK, "ret %08x\n", r );
3513 ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3514 SysFreeString(str);
3515
3516 r = IXMLDOMNode_get_firstChild( node2, &node3 );
3517 ok( r == S_OK, "ret %08x\n", r );
3518
3519 r = IXMLDOMNode_get_text( node3, &str );
3520 ok( r == S_OK, "ret %08x\n", r );
3521 ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3522 SysFreeString(str);
3523
3524
3525 IXMLDOMNode_Release( node3 );
3526 IXMLDOMNode_Release( node2 );
3527 IXMLDOMNamedNodeMap_Release( node_map );
3528 IXMLDOMNode_Release( node );
3529 IXMLDOMDocument_Release( doc );
3530
3531 free_bstrs();
3532}
szvr
static const WCHAR szvr[]
Definition: domdoc.c:1159
szfn1_txt
static const WCHAR szfn1_txt[]
Definition: domdoc.c:1165
expect_bstr_eq_and_free
#define expect_bstr_eq_and_free(bstr, expect)
Definition: domdoc.c:1194

Referenced by START_TEST().

◆ test_get_xml()

static void test_get_xml ( void  )
static

Definition at line 8721 of file domdoc.c.

8722{
8723 static const char xmlA[] = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\r\n<a>test</a>\r\n";
8724 static const char attrA[] = "attr=\"&quot;a &amp; b&quot;\"";
8725 static const char attr2A[] = "\"a & b\"";
8726 static const char attr3A[] = "attr=\"&amp;quot;a\"";
8727 static const char attr4A[] = "&quot;a";
8728 static const char fooA[] = "<foo/>";
8729 IXMLDOMProcessingInstruction *pi;
8730 IXMLDOMNode *first;
8731 IXMLDOMElement *elem = NULL;
8732 IXMLDOMAttribute *attr;
8733 IXMLDOMDocument *doc;
8734 VARIANT_BOOL b;
8735 VARIANT v;
8736 BSTR xml;
8737 HRESULT hr;
8738
8739 doc = create_document(&IID_IXMLDOMDocument);
8740
8741 b = VARIANT_TRUE;
8742 hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8743 ok(hr == S_OK, "got 0x%08x\n", hr);
8744 ok( b == VARIANT_TRUE, "got %d\n", b);
8745
8746 hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"),
8747 _bstr_("version=\"1.0\" encoding=\"UTF-16\""), &pi);
8748 ok(hr == S_OK, "got 0x%08x\n", hr);
8749
8750 hr = IXMLDOMDocument_get_firstChild(doc, &first);
8751 ok(hr == S_OK, "got 0x%08x\n", hr);
8752
8753 V_UNKNOWN(&v) = (IUnknown*)first;
8754 V_VT(&v) = VT_UNKNOWN;
8755
8756 hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)pi, v, NULL);
8757 ok(hr == S_OK, "got 0x%08x\n", hr);
8758
8759 IXMLDOMProcessingInstruction_Release(pi);
8760 IXMLDOMNode_Release(first);
8761
8762 hr = IXMLDOMDocument_get_xml(doc, &xml);
8763 ok(hr == S_OK, "got 0x%08x\n", hr);
8764
8765 ok(memcmp(xml, _bstr_(xmlA), sizeof(xmlA)*sizeof(WCHAR)) == 0,
8766 "got %s, expected %s\n", wine_dbgstr_w(xml), xmlA);
8767 SysFreeString(xml);
8768
8769 IXMLDOMDocument_Release(doc);
8770
8771 doc = create_document(&IID_IXMLDOMDocument);
8772
8773 hr = IXMLDOMDocument_createElement(doc, _bstr_("foo"), &elem);
8774 ok(hr == S_OK, "got 0x%08x\n", hr);
8775
8776 hr = IXMLDOMDocument_putref_documentElement(doc, elem);
8777 ok(hr == S_OK, "got 0x%08x\n", hr);
8778
8779 hr = IXMLDOMDocument_get_xml(doc, &xml);
8780 ok(hr == S_OK, "got 0x%08x\n", hr);
8781
8782 ok(memcmp(xml, _bstr_(fooA), (sizeof(fooA)-1)*sizeof(WCHAR)) == 0,
8783 "got %s, expected %s\n", wine_dbgstr_w(xml), fooA);
8784 SysFreeString(xml);
8785
8786 IXMLDOMElement_Release(elem);
8787
8788 /* attribute node */
8789 hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8790 ok(hr == S_OK, "got 0x%08x\n", hr);
8791
8792 V_VT(&v) = VT_BSTR;
8793 V_BSTR(&v) = _bstr_("\"a & b\"");
8794 hr = IXMLDOMAttribute_put_value(attr, v);
8795 ok(hr == S_OK, "got 0x%08x\n", hr);
8796
8797 xml = NULL;
8798 hr = IXMLDOMAttribute_get_xml(attr, &xml);
8799 ok(hr == S_OK, "got 0x%08x\n", hr);
8800 ok(!memcmp(xml, _bstr_(attrA), (sizeof(attrA)-1)*sizeof(WCHAR)), "got %s\n", wine_dbgstr_w(xml));
8801 SysFreeString(xml);
8802
8803 VariantInit(&v);
8804 hr = IXMLDOMAttribute_get_value(attr, &v);
8805 ok(hr == S_OK, "got 0x%08x\n", hr);
8806 ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8807 ok(!memcmp(V_BSTR(&v), _bstr_(attr2A), (sizeof(attr2A)-1)*sizeof(WCHAR)),
8808 "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8809 VariantClear(&v);
8810
8811 V_VT(&v) = VT_BSTR;
8812 V_BSTR(&v) = _bstr_("&quot;a");
8813 hr = IXMLDOMAttribute_put_value(attr, v);
8814 ok(hr == S_OK, "got 0x%08x\n", hr);
8815
8816 xml = NULL;
8817 hr = IXMLDOMAttribute_get_xml(attr, &xml);
8818 ok(hr == S_OK, "got 0x%08x\n", hr);
8819 ok(!memcmp(xml, _bstr_(attr3A), (sizeof(attr3A)-1)*sizeof(WCHAR)), "got %s\n", wine_dbgstr_w(xml));
8820 SysFreeString(xml);
8821
8822 VariantInit(&v);
8823 hr = IXMLDOMAttribute_get_value(attr, &v);
8824 ok(hr == S_OK, "got 0x%08x\n", hr);
8825 ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8826 ok(!memcmp(V_BSTR(&v), _bstr_(attr4A), (sizeof(attr4A)-1)*sizeof(WCHAR)),
8827 "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8828 VariantClear(&v);
8829
8830 IXMLDOMAttribute_Release(attr);
8831
8832 IXMLDOMDocument_Release(doc);
8833
8834 free_bstrs();
8835}
first
const GLint * first
Definition: glext.h:5794

Referenced by START_TEST().

◆ test_getAttribute()

static void test_getAttribute ( void  )
static

Definition at line 11472 of file domdoc.c.

11473{
11474 IXMLDOMDocument *doc;
11475 IXMLDOMElement *elem;
11476 VARIANT_BOOL v;
11477 VARIANT var;
11478 HRESULT hr;
11479
11480 doc = create_document(&IID_IXMLDOMDocument);
11481
11482 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &v);
11483 EXPECT_HR(hr, S_OK);
11484
11485 hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11486 EXPECT_HR(hr, S_OK);
11487
11488 VariantInit(&var);
11489 hr = IXMLDOMElement_getAttribute( elem, _bstr_("xmlns:foo"), &var );
11490 EXPECT_HR(hr, S_OK);
11491 ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
11492 ok( !lstrcmpW(V_BSTR(&var), _bstr_("urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29")), "wrong attr value: %s\n", wine_dbgstr_w(V_BSTR(&var)));
11493 VariantClear(&var);
11494
11495 hr = IXMLDOMElement_getAttribute( elem, _bstr_("a"), &var );
11496 EXPECT_HR(hr, S_OK);
11497 ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
11498 ok( !lstrcmpW(V_BSTR(&var), _bstr_("attr a")), "wrong attr value: %s\n", wine_dbgstr_w(V_BSTR(&var)));
11499 VariantClear(&var);
11500
11501 hr = IXMLDOMElement_getAttribute( elem, _bstr_("foo:b"), &var );
11502 EXPECT_HR(hr, S_OK);
11503 ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
11504 ok( !lstrcmpW(V_BSTR(&var), _bstr_("attr b")), "wrong attr value: %s\n", wine_dbgstr_w(V_BSTR(&var)));
11505 VariantClear(&var);
11506
11507 hr = IXMLDOMElement_getAttribute( elem, _bstr_("b"), &var );
11508 EXPECT_HR(hr, S_FALSE);
11509 ok( V_VT(&var) == VT_NULL, "vt = %x\n", V_VT(&var));
11510 VariantClear(&var);
11511
11512 hr = IXMLDOMElement_getAttribute( elem, _bstr_("non-existent"), &var );
11513 EXPECT_HR(hr, S_FALSE);
11514 ok( V_VT(&var) == VT_NULL, "vt = %x\n", V_VT(&var));
11515 VariantClear(&var);
11516
11517 IXMLDOMElement_Release(elem);
11518 IXMLDOMDocument_Release(doc);
11519 free_bstrs();
11520}
szExampleXML
static const char szExampleXML[]
Definition: domdoc.c:782

Referenced by START_TEST().

◆ test_getAttributeNode()

static void test_getAttributeNode ( void  )
static

Definition at line 11419 of file domdoc.c.

11420{
11421 IXMLDOMAttribute *attr;
11422 IXMLDOMDocument *doc;
11423 IXMLDOMElement *elem;
11424 VARIANT_BOOL v;
11425 HRESULT hr;
11426 BSTR str;
11427
11428 doc = create_document(&IID_IXMLDOMDocument);
11429
11430 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &v);
11431 EXPECT_HR(hr, S_OK);
11432
11433 hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11434 EXPECT_HR(hr, S_OK);
11435
11436 str = SysAllocString(nonexistent_fileW);
11437 hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
11438 EXPECT_HR(hr, E_FAIL);
11439
11440 attr = (IXMLDOMAttribute*)0xdeadbeef;
11441 hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
11442 EXPECT_HR(hr, E_FAIL);
11443 ok(attr == NULL, "got %p\n", attr);
11444 SysFreeString(str);
11445
11446 str = SysAllocString(nonexistent_attrW);
11447 hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
11448 EXPECT_HR(hr, S_FALSE);
11449
11450 attr = (IXMLDOMAttribute*)0xdeadbeef;
11451 hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
11452 EXPECT_HR(hr, S_FALSE);
11453 ok(attr == NULL, "got %p\n", attr);
11454 SysFreeString(str);
11455
11456 hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("foo:b"), &attr);
11457 EXPECT_HR(hr, S_OK);
11458 IXMLDOMAttribute_Release(attr);
11459
11460 hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("b"), &attr);
11461 EXPECT_HR(hr, S_FALSE);
11462
11463 hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("a"), &attr);
11464 EXPECT_HR(hr, S_OK);
11465 IXMLDOMAttribute_Release(attr);
11466
11467 IXMLDOMElement_Release(elem);
11468 IXMLDOMDocument_Release(doc);
11469 free_bstrs();
11470}
nonexistent_attrW
static const WCHAR nonexistent_attrW[]
Definition: domdoc.c:1150

Referenced by START_TEST().

◆ test_getElementsByTagName()

static void test_getElementsByTagName ( void  )
static

Definition at line 3356 of file domdoc.c.

3357{
3358 const struct queryresult_t *ptr = elementsbytagname;
3359 IXMLDOMNodeList *node_list;
3360 IXMLDOMDocument *doc;
3361 IXMLDOMElement *elem;
3362 WCHAR buff[100];
3363 VARIANT_BOOL b;
3364 HRESULT r;
3365 LONG len;
3366 BSTR str;
3367
3368 doc = create_document(&IID_IXMLDOMDocument);
3369
3370 r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3371 ok( r == S_OK, "loadXML failed\n");
3372 ok( b == VARIANT_TRUE, "failed to load XML string\n");
3373
3374 /* null arguments cases */
3375 r = IXMLDOMDocument_getElementsByTagName(doc, NULL, &node_list);
3376 ok( r == E_INVALIDARG, "ret %08x\n", r );
3377 r = IXMLDOMDocument_getElementsByTagName(doc, _bstr_("*"), NULL);
3378 ok( r == E_INVALIDARG, "ret %08x\n", r );
3379
3380 while (ptr->query)
3381 {
3382 r = IXMLDOMDocument_getElementsByTagName(doc, _bstr_(ptr->query), &node_list);
3383 ok(r == S_OK, "ret %08x\n", r);
3384 r = IXMLDOMNodeList_get_length(node_list, &len);
3385 ok(r == S_OK, "ret %08x\n", r);
3386 ok(len == ptr->len, "%s: got len %d, expected %d\n", ptr->query, len, ptr->len);
3387 expect_list_and_release(node_list, ptr->result);
3388
3389 free_bstrs();
3390 ptr++;
3391 }
3392
3393 /* broken query BSTR */
3394 memcpy(&buff[2], szstar, sizeof(szstar));
3395 /* just a big length */
3396 *(DWORD*)buff = 0xf0f0;
3397 r = IXMLDOMDocument_getElementsByTagName(doc, &buff[2], &node_list);
3398 ok( r == S_OK, "ret %08x\n", r );
3399 r = IXMLDOMNodeList_get_length( node_list, &len );
3400 ok( r == S_OK, "ret %08x\n", r );
3401 ok( len == 6, "len %d\n", len );
3402 IXMLDOMNodeList_Release( node_list );
3403
3404 /* test for element */
3405 r = IXMLDOMDocument_get_documentElement(doc, &elem);
3406 ok( r == S_OK, "ret %08x\n", r );
3407
3408 str = SysAllocString( szstar );
3409
3410 /* null arguments cases */
3411 r = IXMLDOMElement_getElementsByTagName(elem, NULL, &node_list);
3412 ok( r == E_INVALIDARG, "ret %08x\n", r );
3413 r = IXMLDOMElement_getElementsByTagName(elem, str, NULL);
3414 ok( r == E_INVALIDARG, "ret %08x\n", r );
3415
3416 r = IXMLDOMElement_getElementsByTagName(elem, str, &node_list);
3417 ok( r == S_OK, "ret %08x\n", r );
3418 r = IXMLDOMNodeList_get_length( node_list, &len );
3419 ok( r == S_OK, "ret %08x\n", r );
3420 ok( len == 5, "len %d\n", len );
3421 expect_list_and_release(node_list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1");
3422 SysFreeString( str );
3423
3424 /* broken query BSTR */
3425 memcpy(&buff[2], szstar, sizeof(szstar));
3426 /* just a big length */
3427 *(DWORD*)buff = 0xf0f0;
3428 r = IXMLDOMElement_getElementsByTagName(elem, &buff[2], &node_list);
3429 ok( r == S_OK, "ret %08x\n", r );
3430 r = IXMLDOMNodeList_get_length( node_list, &len );
3431 ok( r == S_OK, "ret %08x\n", r );
3432 ok( len == 5, "len %d\n", len );
3433 IXMLDOMNodeList_Release( node_list );
3434
3435 IXMLDOMElement_Release(elem);
3436
3437 IXMLDOMDocument_Release( doc );
3438
3439 free_bstrs();
3440}
elementsbytagname
static const struct queryresult_t elementsbytagname[]
Definition: domdoc.c:3347
queryresult_t
Definition: domdoc.c:3341

Referenced by START_TEST().

◆ test_getQualifiedItem()

static void test_getQualifiedItem ( void  )
static

Definition at line 7671 of file domdoc.c.

7672{
7673 IXMLDOMNode *pr_node, *node;
7674 IXMLDOMNodeList *root_list;
7675 IXMLDOMNamedNodeMap *map;
7676 IXMLDOMElement *element;
7677 const ns_item_t* ptr;
7678 IXMLDOMDocument *doc;
7679 VARIANT_BOOL b;
7680 HRESULT hr;
7681 LONG len;
7682
7683 doc = create_document(&IID_IXMLDOMDocument);
7684
7685 hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7686 EXPECT_HR(hr, S_OK);
7687 ok( b == VARIANT_TRUE, "failed to load XML string\n");
7688
7689 hr = IXMLDOMDocument_get_documentElement(doc, &element);
7690 EXPECT_HR(hr, S_OK);
7691
7692 hr = IXMLDOMElement_get_childNodes(element, &root_list);
7693 EXPECT_HR(hr, S_OK);
7694
7695 hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7696 EXPECT_HR(hr, S_OK);
7697 IXMLDOMNodeList_Release(root_list);
7698
7699 hr = IXMLDOMNode_get_attributes(pr_node, &map);
7700 EXPECT_HR(hr, S_OK);
7701 IXMLDOMNode_Release(pr_node);
7702
7703 len = 0;
7704 hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7705 EXPECT_HR(hr, S_OK);
7706 ok( len == 3, "length %d\n", len);
7707
7708 hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, NULL);
7709 EXPECT_HR(hr, E_INVALIDARG);
7710
7711 node = (void*)0xdeadbeef;
7712 hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, &node);
7713 EXPECT_HR(hr, E_INVALIDARG);
7714 ok( node == (void*)0xdeadbeef, "got %p\n", node);
7715
7716 hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, NULL);
7717 EXPECT_HR(hr, E_INVALIDARG);
7718
7719 hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, &node);
7720 EXPECT_HR(hr, S_OK);
7721
7722 IXMLDOMNode_Release(node);
7723 IXMLDOMNamedNodeMap_Release(map);
7724 IXMLDOMElement_Release(element);
7725
7726 hr = IXMLDOMDocument_loadXML(doc, _bstr_(default_ns_doc), &b);
7727 EXPECT_HR(hr, S_OK);
7728
7729 hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("a"), &node);
7730 EXPECT_HR(hr, S_OK);
7731
7732 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&element);
7733 EXPECT_HR(hr, S_OK);
7734 IXMLDOMNode_Release(node);
7735
7736 hr = IXMLDOMElement_get_attributes(element, &map);
7737 EXPECT_HR(hr, S_OK);
7738
7739 ptr = qualified_item_tests;
7740 while (ptr->name)
7741 {
7742 node = (void*)0xdeadbeef;
7743 hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
7744 ok(hr == ptr->hr, "%s, %s: got 0x%08x, expected 0x%08x\n", ptr->name, ptr->uri, hr, ptr->hr);
7745 if (hr == S_OK)
7746 IXMLDOMNode_Release(node);
7747 else
7748 ok(node == NULL, "%s, %s: got %p\n", ptr->name, ptr->uri, node);
7749 ptr++;
7750 }
7751
7752 ptr = named_item_tests;
7753 while (ptr->name)
7754 {
7755 node = (void*)0xdeadbeef;
7756 hr = IXMLDOMNamedNodeMap_getNamedItem(map, _bstr_(ptr->name), &node);
7757 ok(hr == ptr->hr, "%s: got 0x%08x, expected 0x%08x\n", ptr->name, hr, ptr->hr);
7758 if (hr == S_OK)
7759 IXMLDOMNode_Release(node);
7760 else
7761 ok(node == NULL, "%s: got %p\n", ptr->name, node);
7762 ptr++;
7763 }
7764
7765 IXMLDOMNamedNodeMap_Release(map);
7766
7767 IXMLDOMElement_Release(element);
7768 IXMLDOMDocument_Release(doc);
7769 free_bstrs();
7770}
qualified_item_tests
static const ns_item_t qualified_item_tests[]
Definition: domdoc.c:7651
named_item_tests
static const ns_item_t named_item_tests[]
Definition: domdoc.c:7662
default_ns_doc
static const char default_ns_doc[]
Definition: domdoc.c:1136
ns_item_t
Definition: domdoc.c:7644

Referenced by START_TEST().

◆ test_insertBefore()

static void test_insertBefore ( void  )
static

Definition at line 9060 of file domdoc.c.

9061{
9062 IXMLDOMDocument *doc, *doc2, *doc3;
9063 IXMLDOMAttribute *attr;
9064 IXMLDOMElement *elem1, *elem2, *elem3, *elem4, *elem5;
9065 IXMLDOMNode *node, *newnode, *cdata;
9066 HRESULT hr;
9067 VARIANT v;
9068 BSTR p;
9069
9070 doc = create_document(&IID_IXMLDOMDocument);
9071 doc3 = create_document(&IID_IXMLDOMDocument);
9072
9073 /* document to document */
9074 V_VT(&v) = VT_NULL;
9075 node = (void*)0xdeadbeef;
9076 hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)doc3, v, &node);
9077 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9078 ok(node == NULL, "got %p\n", node);
9079
9080 /* document to itself */
9081 V_VT(&v) = VT_NULL;
9082 node = (void*)0xdeadbeef;
9083 hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)doc, v, &node);
9084 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9085 ok(node == NULL, "got %p\n", node);
9086
9087 /* insertBefore behaviour for attribute node */
9088 V_VT(&v) = VT_I4;
9089 V_I4(&v) = NODE_ATTRIBUTE;
9090
9091 attr = NULL;
9092 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr"), NULL, (IXMLDOMNode**)&attr);
9093 ok(hr == S_OK, "got 0x%08x\n", hr);
9094 ok(attr != NULL, "got %p\n", attr);
9095
9096 /* attribute to document */
9097 V_VT(&v) = VT_NULL;
9098 node = (void*)0xdeadbeef;
9099 hr = IXMLDOMDocument_insertBefore(doc3, (IXMLDOMNode*)attr, v, &node);
9100 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9101 ok(node == NULL, "got %p\n", node);
9102
9103 /* cdata to document */
9104 V_VT(&v) = VT_I4;
9105 V_I4(&v) = NODE_CDATA_SECTION;
9106
9107 cdata = NULL;
9108 hr = IXMLDOMDocument_createNode(doc3, v, _bstr_("cdata"), NULL, &cdata);
9109 ok(hr == S_OK, "got 0x%08x\n", hr);
9110 ok(cdata != NULL, "got %p\n", cdata);
9111
9112 EXPECT_NO_CHILDREN(cdata);
9113
9114 /* attribute to cdata */
9115 V_VT(&v) = VT_NULL;
9116 node = (void*)0xdeadbeef;
9117 hr = IXMLDOMNode_insertBefore(cdata, (IXMLDOMNode*)attr, v, &node);
9118 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9119 ok(node == NULL, "got %p\n", node);
9120
9121 /* document to cdata */
9122 V_VT(&v) = VT_NULL;
9123 node = (void*)0xdeadbeef;
9124 hr = IXMLDOMNode_insertBefore(cdata, (IXMLDOMNode*)doc, v, &node);
9125 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9126 ok(node == NULL, "got %p\n", node);
9127
9128 V_VT(&v) = VT_NULL;
9129 node = (void*)0xdeadbeef;
9130 hr = IXMLDOMDocument_insertBefore(doc3, cdata, v, &node);
9131 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9132 ok(node == NULL, "got %p\n", node);
9133
9134 IXMLDOMNode_Release(cdata);
9135 IXMLDOMDocument_Release(doc3);
9136
9137 /* attribute to attribute */
9138 V_VT(&v) = VT_I4;
9139 V_I4(&v) = NODE_ATTRIBUTE;
9140 newnode = NULL;
9141 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr2"), NULL, &newnode);
9142 ok(hr == S_OK, "got 0x%08x\n", hr);
9143 ok(newnode != NULL, "got %p\n", newnode);
9144
9145 V_VT(&v) = VT_NULL;
9146 node = (void*)0xdeadbeef;
9147 hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9148 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9149 ok(node == NULL, "got %p\n", node);
9150
9151 V_VT(&v) = VT_UNKNOWN;
9152 V_UNKNOWN(&v) = (IUnknown*)attr;
9153 node = (void*)0xdeadbeef;
9154 hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9155 todo_wine ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9156 ok(node == NULL, "got %p\n", node);
9157 IXMLDOMNode_Release(newnode);
9158
9159 /* cdata to attribute */
9160 V_VT(&v) = VT_I4;
9161 V_I4(&v) = NODE_CDATA_SECTION;
9162 newnode = NULL;
9163 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9164 ok(hr == S_OK, "got 0x%08x\n", hr);
9165 ok(newnode != NULL, "got %p\n", newnode);
9166
9167 V_VT(&v) = VT_NULL;
9168 node = (void*)0xdeadbeef;
9169 hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9170 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9171 ok(node == NULL, "got %p\n", node);
9172 IXMLDOMNode_Release(newnode);
9173
9174 /* comment to attribute */
9175 V_VT(&v) = VT_I4;
9176 V_I4(&v) = NODE_COMMENT;
9177 newnode = NULL;
9178 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9179 ok(hr == S_OK, "got 0x%08x\n", hr);
9180 ok(newnode != NULL, "got %p\n", newnode);
9181
9182 V_VT(&v) = VT_NULL;
9183 node = (void*)0xdeadbeef;
9184 hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9185 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9186 ok(node == NULL, "got %p\n", node);
9187 IXMLDOMNode_Release(newnode);
9188
9189 /* element to attribute */
9190 V_VT(&v) = VT_I4;
9191 V_I4(&v) = NODE_ELEMENT;
9192 newnode = NULL;
9193 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9194 ok(hr == S_OK, "got 0x%08x\n", hr);
9195 ok(newnode != NULL, "got %p\n", newnode);
9196
9197 V_VT(&v) = VT_NULL;
9198 node = (void*)0xdeadbeef;
9199 hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9200 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9201 ok(node == NULL, "got %p\n", node);
9202 IXMLDOMNode_Release(newnode);
9203
9204 /* pi to attribute */
9205 V_VT(&v) = VT_I4;
9206 V_I4(&v) = NODE_PROCESSING_INSTRUCTION;
9207 newnode = NULL;
9208 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9209 ok(hr == S_OK, "got 0x%08x\n", hr);
9210 ok(newnode != NULL, "got %p\n", newnode);
9211
9212 V_VT(&v) = VT_NULL;
9213 node = (void*)0xdeadbeef;
9214 hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9215 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9216 ok(node == NULL, "got %p\n", node);
9217 IXMLDOMNode_Release(newnode);
9218 IXMLDOMAttribute_Release(attr);
9219
9220 /* insertBefore for elements */
9221 hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem1);
9222 ok(hr == S_OK, "got 0x%08x\n", hr);
9223
9224 hr = IXMLDOMDocument_createElement(doc, _bstr_("elem2"), &elem2);
9225 ok(hr == S_OK, "got 0x%08x\n", hr);
9226
9227 hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
9228 ok(hr == S_OK, "got 0x%08x\n", hr);
9229
9230 hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
9231 ok(hr == S_OK, "got 0x%08x\n", hr);
9232
9233 hr = IXMLDOMDocument_createElement(doc, _bstr_("elem4"), &elem4);
9234 ok(hr == S_OK, "got 0x%08x\n", hr);
9235
9236 EXPECT_NO_CHILDREN(elem1);
9237 EXPECT_NO_CHILDREN(elem2);
9238 EXPECT_NO_CHILDREN(elem3);
9239
9240 todo_wine EXPECT_REF(elem2, 2);
9241
9242 /* document to element */
9243 V_VT(&v) = VT_DISPATCH;
9244 V_DISPATCH(&v) = NULL;
9245 hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)doc, v, NULL);
9246 ok(hr == E_FAIL, "got 0x%08x\n", hr);
9247
9248 V_VT(&v) = VT_DISPATCH;
9249 V_DISPATCH(&v) = NULL;
9250 node = NULL;
9251 hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem4, v, &node);
9252 ok(hr == S_OK, "got 0x%08x\n", hr);
9253 ok(node == (void*)elem4, "got %p\n", node);
9254
9255 EXPECT_CHILDREN(elem1);
9256 hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem4, NULL);
9257 EXPECT_HR(hr, S_OK);
9258 IXMLDOMElement_Release(elem4);
9259
9260 EXPECT_NO_CHILDREN(elem1);
9261
9262 V_VT(&v) = VT_NULL;
9263 node = NULL;
9264 hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
9265 ok(hr == S_OK, "got 0x%08x\n", hr);
9266 ok(node == (void*)elem2, "got %p\n", node);
9267
9268 EXPECT_CHILDREN(elem1);
9269 todo_wine EXPECT_REF(elem2, 3);
9270 IXMLDOMNode_Release(node);
9271
9272 /* again for already linked node */
9273 V_VT(&v) = VT_NULL;
9274 node = NULL;
9275 hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
9276 ok(hr == S_OK, "got 0x%08x\n", hr);
9277 ok(node == (void*)elem2, "got %p\n", node);
9278
9279 EXPECT_CHILDREN(elem1);
9280
9281 /* increments each time */
9282 todo_wine EXPECT_REF(elem2, 3);
9283 IXMLDOMNode_Release(node);
9284
9285 /* try to add to another element */
9286 V_VT(&v) = VT_NULL;
9287 node = (void*)0xdeadbeef;
9288 hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem2, v, &node);
9289 ok(hr == S_OK, "got 0x%08x\n", hr);
9290 ok(node == (void*)elem2, "got %p\n", node);
9291
9292 EXPECT_CHILDREN(elem3);
9293 EXPECT_NO_CHILDREN(elem1);
9294
9295 IXMLDOMNode_Release(node);
9296
9297 /* cross document case - try to add as child to a node created with other doc */
9298 doc2 = create_document(&IID_IXMLDOMDocument);
9299
9300 hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem4);
9301 ok(hr == S_OK, "got 0x%08x\n", hr);
9302 todo_wine EXPECT_REF(elem4, 2);
9303
9304 /* same name, another instance */
9305 hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem5);
9306 ok(hr == S_OK, "got 0x%08x\n", hr);
9307 todo_wine EXPECT_REF(elem5, 2);
9308
9309 todo_wine EXPECT_REF(elem3, 2);
9310 V_VT(&v) = VT_NULL;
9311 node = NULL;
9312 hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem4, v, &node);
9313 ok(hr == S_OK, "got 0x%08x\n", hr);
9314 ok(node == (void*)elem4, "got %p\n", node);
9315 todo_wine EXPECT_REF(elem4, 3);
9316 todo_wine EXPECT_REF(elem3, 2);
9317 IXMLDOMNode_Release(node);
9318
9319 V_VT(&v) = VT_NULL;
9320 node = NULL;
9321 hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem5, v, &node);
9322 ok(hr == S_OK, "got 0x%08x\n", hr);
9323 ok(node == (void*)elem5, "got %p\n", node);
9324 todo_wine EXPECT_REF(elem4, 2);
9325 todo_wine EXPECT_REF(elem5, 3);
9326 IXMLDOMNode_Release(node);
9327
9328 IXMLDOMDocument_Release(doc2);
9329
9330 IXMLDOMElement_Release(elem1);
9331 IXMLDOMElement_Release(elem2);
9332 IXMLDOMElement_Release(elem3);
9333 IXMLDOMElement_Release(elem4);
9334 IXMLDOMElement_Release(elem5);
9335
9336 /* elements with same default namespace */
9337 V_VT(&v) = VT_I4;
9338 V_I4(&v) = NODE_ELEMENT;
9339 elem1 = NULL;
9340 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
9341 ok(hr == S_OK, "got 0x%08x\n", hr);
9342 ok(elem1 != NULL, "got %p\n", elem1);
9343
9344 V_VT(&v) = VT_I4;
9345 V_I4(&v) = NODE_ELEMENT;
9346 elem2 = NULL;
9347 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem2);
9348 ok(hr == S_OK, "got 0x%08x\n", hr);
9349 ok(elem2 != NULL, "got %p\n", elem2);
9350
9351 /* check contents so far */
9352 p = NULL;
9353 hr = IXMLDOMElement_get_xml(elem1, &p);
9354 ok(hr == S_OK, "got 0x%08x\n", hr);
9355 ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9356 SysFreeString(p);
9357
9358 p = NULL;
9359 hr = IXMLDOMElement_get_xml(elem2, &p);
9360 ok(hr == S_OK, "got 0x%08x\n", hr);
9361 ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9362 SysFreeString(p);
9363
9364 V_VT(&v) = VT_NULL;
9365 hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
9366 ok(hr == S_OK, "got 0x%08x\n", hr);
9367
9368 /* get_xml depends on context, for top node it omits child namespace attribute,
9369 but at child level it's still returned */
9370 p = NULL;
9371 hr = IXMLDOMElement_get_xml(elem1, &p);
9372 ok(hr == S_OK, "got 0x%08x\n", hr);
9373 todo_wine ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"><elem2/></elem1>")),
9374 "got %s\n", wine_dbgstr_w(p));
9375 SysFreeString(p);
9376
9377 p = NULL;
9378 hr = IXMLDOMElement_get_xml(elem2, &p);
9379 ok(hr == S_OK, "got 0x%08x\n", hr);
9380 ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9381 SysFreeString(p);
9382
9383 IXMLDOMElement_Release(elem1);
9384 IXMLDOMElement_Release(elem2);
9385
9386 /* child without default namespace added to node with default namespace */
9387 V_VT(&v) = VT_I4;
9388 V_I4(&v) = NODE_ELEMENT;
9389 elem1 = NULL;
9390 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
9391 ok(hr == S_OK, "got 0x%08x\n", hr);
9392 ok(elem1 != NULL, "got %p\n", elem1);
9393
9394 V_VT(&v) = VT_I4;
9395 V_I4(&v) = NODE_ELEMENT;
9396 elem2 = NULL;
9397 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), NULL, (IXMLDOMNode**)&elem2);
9398 ok(hr == S_OK, "got 0x%08x\n", hr);
9399 ok(elem2 != NULL, "got %p\n", elem2);
9400
9401 EXPECT_REF(elem2, 1);
9402 V_VT(&v) = VT_NULL;
9403 hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
9404 ok(hr == S_OK, "got 0x%08x\n", hr);
9405 EXPECT_REF(elem2, 1);
9406
9407 p = NULL;
9408 hr = IXMLDOMElement_get_xml(elem2, &p);
9409 ok(hr == S_OK, "got 0x%08x\n", hr);
9410 ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
9411 SysFreeString(p);
9412
9413 hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem2, NULL);
9414 ok(hr == S_OK, "got 0x%08x\n", hr);
9415
9416 p = NULL;
9417 hr = IXMLDOMElement_get_xml(elem2, &p);
9418 ok(hr == S_OK, "got 0x%08x\n", hr);
9419 ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
9420 SysFreeString(p);
9421
9422 IXMLDOMElement_Release(elem1);
9423 IXMLDOMElement_Release(elem2);
9424 IXMLDOMDocument_Release(doc);
9425}
p
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by START_TEST().

◆ test_IObjectSafety()

static void test_IObjectSafety ( void  )
static

Definition at line 7200 of file domdoc.c.

7201{
7202 IXMLDOMDocument *doc;
7203 IObjectSafety *safety;
7204 HRESULT hr;
7205
7206 doc = create_document(&IID_IXMLDOMDocument);
7207
7208 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IObjectSafety, (void**)&safety);
7209 ok(hr == S_OK, "ret %08x\n", hr );
7210
7211 test_IObjectSafety_common(safety);
7212
7213 IObjectSafety_Release(safety);
7214 IXMLDOMDocument_Release(doc);
7215
7216 hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
7217 &IID_IObjectSafety, (void**)&safety);
7218 ok(hr == S_OK, "Could not create XMLHTTPRequest instance: %08x\n", hr);
7219
7220 test_IObjectSafety_common(safety);
7221
7222 IObjectSafety_Release(safety);
7223
7224}
test_IObjectSafety_common
#define test_IObjectSafety_common(s)
Definition: domdoc.c:4127

Referenced by START_TEST().

◆ test_IXMLDOMDocument2()

static void test_IXMLDOMDocument2 ( void  )
static

Definition at line 4224 of file domdoc.c.

4225{
4226 static const WCHAR emptyW[] = {0};
4227 IXMLDOMDocument2 *doc2, *dtddoc2;
4228 IXMLDOMDocument *doc;
4229 IXMLDOMParseError* err;
4230 IDispatchEx *dispex;
4231 VARIANT_BOOL b;
4232 VARIANT var;
4233 HRESULT r;
4234 LONG res;
4235
4236 if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
4237
4238 doc = create_document(&IID_IXMLDOMDocument);
4239 dtddoc2 = create_document(&IID_IXMLDOMDocument2);
4240
4241 r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
4242 ok( r == S_OK, "ret %08x\n", r );
4243 ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
4244
4245 ole_expect(IXMLDOMDocument2_get_readyState(doc2, NULL), E_INVALIDARG);
4246 ole_check(IXMLDOMDocument2_get_readyState(doc2, &res));
4247 ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
4248
4249 err = NULL;
4250 ole_expect(IXMLDOMDocument2_validate(doc2, NULL), S_FALSE);
4251 ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
4252 ok(err != NULL, "expected a pointer\n");
4253 if (err)
4254 {
4255 res = 0;
4256 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4257 /* XML_E_NOTWF */
4258 ok(res == E_XML_NOTWF, "got %08x\n", res);
4259 IXMLDOMParseError_Release(err);
4260 }
4261
4262 r = IXMLDOMDocument2_loadXML( doc2, _bstr_(complete4A), &b );
4263 ok( r == S_OK, "loadXML failed\n");
4264 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4265
4266 ole_check(IXMLDOMDocument_get_readyState(doc, &res));
4267 ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
4268
4269 err = NULL;
4270 ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
4271 ok(err != NULL, "expected a pointer\n");
4272 if (err)
4273 {
4274 res = 0;
4275 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4276 /* XML_E_NODTD */
4277 ok(res == E_XML_NODTD, "got %08x\n", res);
4278 IXMLDOMParseError_Release(err);
4279 }
4280
4281 r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
4282 ok( r == S_OK, "ret %08x\n", r );
4283 if(r == S_OK)
4284 {
4285 IDispatchEx_Release(dispex);
4286 }
4287
4288 /* we will check if the variant got cleared */
4289 IXMLDOMDocument2_AddRef(doc2);
4290 EXPECT_REF(doc2, 3); /* doc, doc2, AddRef*/
4291
4292 V_VT(&var) = VT_UNKNOWN;
4293 V_UNKNOWN(&var) = (IUnknown *)doc2;
4294
4295 /* invalid calls */
4296 ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
4297 expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
4298 ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
4299
4300 /* valid call */
4301 ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
4302 expect_eq(V_VT(&var), VT_BSTR, int, "%x");
4303 expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
4304 V_VT(&var) = VT_R4;
4305
4306 /* the variant didn't get cleared*/
4307 expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
4308
4309 /* setProperty tests */
4310 ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
4311 ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
4312 ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
4313 ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
4314 ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4315 ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
4316
4317 V_VT(&var) = VT_BSTR;
4318 V_BSTR(&var) = SysAllocString(emptyW);
4319 r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
4320 ok(r == S_OK, "got 0x%08x\n", r);
4321 VariantClear(&var);
4322
4323 V_VT(&var) = VT_I2;
4324 V_I2(&var) = 0;
4325 r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
4326 ok(r == E_FAIL, "got 0x%08x\n", r);
4327
4328 /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
4329 ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
4330 expect_eq(V_VT(&var), VT_BSTR, int, "%x");
4331 expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
4332
4333 IXMLDOMDocument2_Release( doc2 );
4334 IXMLDOMDocument_Release( doc );
4335
4336 /* DTD validation */
4337 ole_check(IXMLDOMDocument2_put_validateOnParse(dtddoc2, VARIANT_FALSE));
4338 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML), &b));
4339 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4340 err = NULL;
4341 ole_check(IXMLDOMDocument2_validate(dtddoc2, &err));
4342 ok(err != NULL, "expected pointer\n");
4343 if (err)
4344 {
4345 res = 0;
4346 ole_expect(IXMLDOMParseError_get_errorCode(err, &res), S_FALSE);
4347 ok(res == 0, "got %08x\n", res);
4348 IXMLDOMParseError_Release(err);
4349 }
4350
4351 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0D), &b));
4352 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4353 err = NULL;
4354 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4355 ok(err != NULL, "expected pointer\n");
4356 if (err)
4357 {
4358 res = 0;
4359 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4360 /* XML_ELEMENT_UNDECLARED */
4361 todo_wine ok(res == 0xC00CE00D, "got %08x\n", res);
4362 IXMLDOMParseError_Release(err);
4363 }
4364
4365 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0E), &b));
4366 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4367 err = NULL;
4368 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4369 ok(err != NULL, "expected pointer\n");
4370 if (err)
4371 {
4372 res = 0;
4373 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4374 /* XML_ELEMENT_ID_NOT_FOUND */
4375 todo_wine ok(res == 0xC00CE00E, "got %08x\n", res);
4376 IXMLDOMParseError_Release(err);
4377 }
4378
4379 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_11), &b));
4380 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4381 err = NULL;
4382 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4383 ok(err != NULL, "expected pointer\n");
4384 if (err)
4385 {
4386 res = 0;
4387 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4388 /* XML_EMPTY_NOT_ALLOWED */
4389 todo_wine ok(res == 0xC00CE011, "got %08x\n", res);
4390 IXMLDOMParseError_Release(err);
4391 }
4392
4393 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_13), &b));
4394 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4395 err = NULL;
4396 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4397 ok(err != NULL, "expected pointer\n");
4398 if (err)
4399 {
4400 res = 0;
4401 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4402 /* XML_ROOT_NAME_MISMATCH */
4403 todo_wine ok(res == 0xC00CE013, "got %08x\n", res);
4404 IXMLDOMParseError_Release(err);
4405 }
4406
4407 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_14), &b));
4408 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4409 err = NULL;
4410 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4411 ok(err != NULL, "expected pointer\n");
4412 if (err)
4413 {
4414 res = 0;
4415 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4416 /* XML_INVALID_CONTENT */
4417 todo_wine ok(res == 0xC00CE014, "got %08x\n", res);
4418 IXMLDOMParseError_Release(err);
4419 }
4420
4421 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_15), &b));
4422 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4423 err = NULL;
4424 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4425 ok(err != NULL, "expected pointer\n");
4426 if (err)
4427 {
4428 res = 0;
4429 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4430 /* XML_ATTRIBUTE_NOT_DEFINED */
4431 todo_wine ok(res == 0xC00CE015, "got %08x\n", res);
4432 IXMLDOMParseError_Release(err);
4433 }
4434
4435 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_16), &b));
4436 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4437 err = NULL;
4438 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4439 ok(err != NULL, "expected pointer\n");
4440 if (err)
4441 {
4442 res = 0;
4443 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4444 /* XML_ATTRIBUTE_FIXED */
4445 todo_wine ok(res == 0xC00CE016, "got %08x\n", res);
4446 IXMLDOMParseError_Release(err);
4447 }
4448
4449 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_17), &b));
4450 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4451 err = NULL;
4452 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4453 ok(err != NULL, "expected pointer\n");
4454 if (err)
4455 {
4456 res = 0;
4457 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4458 /* XML_ATTRIBUTE_VALUE */
4459 todo_wine ok(res == 0xC00CE017, "got %08x\n", res);
4460 IXMLDOMParseError_Release(err);
4461 }
4462
4463 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_18), &b));
4464 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4465 err = NULL;
4466 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4467 ok(err != NULL, "expected pointer\n");
4468 if (err)
4469 {
4470 res = 0;
4471 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4472 /* XML_ILLEGAL_TEXT */
4473 todo_wine ok(res == 0xC00CE018, "got %08x\n", res);
4474 IXMLDOMParseError_Release(err);
4475 }
4476
4477 ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_20), &b));
4478 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4479 err = NULL;
4480 ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4481 ok(err != NULL, "expected pointer\n");
4482 if (err)
4483 {
4484 res = 0;
4485 ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4486 /* XML_REQUIRED_ATTRIBUTE_MISSING */
4487 todo_wine ok(res == 0xC00CE020, "got %08x\n", res);
4488 IXMLDOMParseError_Release(err);
4489 }
4490
4491 IXMLDOMDocument2_Release( dtddoc2 );
4492 free_bstrs();
4493}
res
GLuint res
Definition: glext.h:9613
emptyW
static const WCHAR emptyW[]
Definition: navigate.c:40
szEmailXML_15
static const CHAR szEmailXML_15[]
Definition: domdoc.c:1051
szEmailXML_0D
static const CHAR szEmailXML_0D[]
Definition: domdoc.c:978
szEmailXML_11
static const CHAR szEmailXML_11[]
Definition: domdoc.c:1009
szEmailXML_20
static const CHAR szEmailXML_20[]
Definition: domdoc.c:1112
szEmailXML_18
static const CHAR szEmailXML_18[]
Definition: domdoc.c:1096
szEmailXML_0E
static const CHAR szEmailXML_0E[]
Definition: domdoc.c:994
expect_eq
#define expect_eq(expr, value, type, format)
Definition: domdoc.c:1201
szEmailXML_17
static const CHAR szEmailXML_17[]
Definition: domdoc.c:1081
szEmailXML_14
static const CHAR szEmailXML_14[]
Definition: domdoc.c:1038
szEmailXML_13
static const CHAR szEmailXML_13[]
Definition: domdoc.c:1023
ole_expect
#define ole_expect(expr, expect)
Definition: domdoc.c:1208
szEmailXML_16
static const CHAR szEmailXML_16[]
Definition: domdoc.c:1066
err
#define err(...)
Definition: reactos_support_code.h:30

Referenced by START_TEST().

◆ test_load()

static void test_load ( void  )
static

Definition at line 10247 of file domdoc.c.

10248{
10249 char path[MAX_PATH], path2[MAX_PATH];
10250 IXMLDOMNodeList *list;
10251 IXMLDOMDocument *doc;
10252 BSTR bstr1, bstr2;
10253 VARIANT_BOOL b;
10254 VARIANT src;
10255 HRESULT hr;
10256 void* ptr;
10257
10258 GetTempPathA(MAX_PATH, path);
10259 strcat(path, "winetest.xml");
10260
10261 /* prepare a file */
10262 write_to_file(path, win1252xml);
10263
10264 doc = create_document(&IID_IXMLDOMDocument);
10265
10266 /* null pointer as input */
10267 V_VT(&src) = VT_UNKNOWN;
10268 V_UNKNOWN(&src) = NULL;
10269 hr = IXMLDOMDocument_load(doc, src, &b);
10270 EXPECT_HR(hr, E_INVALIDARG);
10271 ok(b == VARIANT_FALSE, "got %d\n", b);
10272
10273 /* "file://" url */
10274 strcpy(path2, "file://");
10275 strcat(path2, path);
10276 test_doc_load_from_path(doc, path2);
10277
10278 /* file:// url, forward slashes */
10279 url_forward_slash(path2);
10280 test_doc_load_from_path(doc, path2);
10281
10282 /* "file:/" url */
10283 strcpy(path2, "file:/");
10284 strcat(path2, path);
10285 test_doc_load_from_path(doc, path);
10286
10287 /* file:/ with forward slashes. */
10288 url_forward_slash(path2);
10289 test_doc_load_from_path(doc, path2);
10290
10291 /* Regular local path. */
10292 test_doc_load_from_path(doc, path);
10293
10294 /* load from a path: VT_BSTR|VT_BYREF, null ptr */
10295 V_VT(&src) = VT_BSTR | VT_BYREF;
10296 V_BSTRREF(&src) = NULL;
10297 hr = IXMLDOMDocument_load(doc, src, &b);
10298 EXPECT_HR(hr, E_INVALIDARG);
10299 ok(b == VARIANT_FALSE, "got %d\n", b);
10300
10301 bstr1 = NULL;
10302 hr = IXMLDOMDocument_get_url(doc, &bstr1);
10303 ok(hr == S_OK, "got 0x%08x\n", hr);
10304 SysFreeString(bstr1);
10305
10306 DeleteFileA(path);
10307
10308 /* load from existing path, no xml content */
10309 write_to_file(path, nocontent);
10310
10311 V_VT(&src) = VT_BSTR;
10312 V_BSTR(&src) = _bstr_(path);
10313 b = VARIANT_TRUE;
10314 hr = IXMLDOMDocument_load(doc, src, &b);
10315 ok(hr == S_FALSE, "got 0x%08x\n", hr);
10316 ok(b == VARIANT_FALSE, "got %d\n", b);
10317
10318 bstr1 = (void *)0xdeadbeef;
10319 hr = IXMLDOMDocument_get_url(doc, &bstr1);
10320 ok(hr == S_FALSE, "got 0x%08x\n", hr);
10321 ok(bstr1 == NULL, "got %p\n", bstr1);
10322
10323 DeleteFileA(path);
10324 IXMLDOMDocument_Release(doc);
10325
10326 doc = create_document(&IID_IXMLDOMDocument);
10327
10328 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
10329 EXPECT_HR(hr, S_OK);
10330 ok(b == VARIANT_TRUE, "got %d\n", b);
10331
10332 hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
10333 EXPECT_HR(hr, S_OK);
10334 bstr1 = _bstr_(list_to_string(list));
10335
10336 hr = IXMLDOMNodeList_reset(list);
10337 EXPECT_HR(hr, S_OK);
10338
10339 IXMLDOMDocument_Release(doc);
10340
10341 doc = create_document(&IID_IXMLDOMDocument);
10342
10343 VariantInit(&src);
10344 V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenA(szExampleXML));
10345 V_VT(&src) = VT_ARRAY|VT_UI1;
10346 ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10347 ptr = NULL;
10348 hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10349 EXPECT_HR(hr, S_OK);
10350 ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10351
10352 memcpy(ptr, szExampleXML, lstrlenA(szExampleXML));
10353 hr = SafeArrayUnlock(V_ARRAY(&src));
10354 EXPECT_HR(hr, S_OK);
10355
10356 hr = IXMLDOMDocument_load(doc, src, &b);
10357 EXPECT_HR(hr, S_OK);
10358 ok(b == VARIANT_TRUE, "got %d\n", b);
10359
10360 hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
10361 EXPECT_HR(hr, S_OK);
10362 bstr2 = _bstr_(list_to_string(list));
10363
10364 hr = IXMLDOMNodeList_reset(list);
10365 EXPECT_HR(hr, S_OK);
10366
10367 ok(lstrcmpW(bstr1, bstr2) == 0, "strings not equal: %s : %s\n",
10368 wine_dbgstr_w(bstr1), wine_dbgstr_w(bstr2));
10369
10370 IXMLDOMDocument_Release(doc);
10371 IXMLDOMNodeList_Release(list);
10372 VariantClear(&src);
10373
10374 /* UTF-16 isn't accepted */
10375 doc = create_document(&IID_IXMLDOMDocument);
10376
10377 V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenW(szComplete1) * sizeof(WCHAR));
10378 V_VT(&src) = VT_ARRAY|VT_UI1;
10379 ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10380 ptr = NULL;
10381 hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10382 EXPECT_HR(hr, S_OK);
10383 ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10384
10385 memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
10386 hr = SafeArrayUnlock(V_ARRAY(&src));
10387 EXPECT_HR(hr, S_OK);
10388
10389 hr = IXMLDOMDocument_load(doc, src, &b);
10390 todo_wine EXPECT_HR(hr, S_FALSE);
10391 todo_wine ok(b == VARIANT_FALSE, "got %d\n", b);
10392
10393 VariantClear(&src);
10394
10395 /* it doesn't like it as a VT_ARRAY|VT_UI2 either */
10396 V_ARRAY(&src) = SafeArrayCreateVector(VT_UI2, 0, lstrlenW(szComplete1));
10397 V_VT(&src) = VT_ARRAY|VT_UI2;
10398 ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10399 ptr = NULL;
10400 hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10401 EXPECT_HR(hr, S_OK);
10402 ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10403
10404 memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
10405 hr = SafeArrayUnlock(V_ARRAY(&src));
10406 EXPECT_HR(hr, S_OK);
10407
10408 hr = IXMLDOMDocument_load(doc, src, &b);
10409 todo_wine EXPECT_HR(hr, E_INVALIDARG);
10410 ok(b == VARIANT_FALSE, "got %d\n", b);
10411
10412 VariantClear(&src);
10413 IXMLDOMDocument_Release(doc);
10414
10415 free_bstrs();
10416}
VT_UI2
@ VT_UI2
Definition: compat.h:2312
SafeArrayAccessData
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
Definition: safearray.c:1137
SafeArrayUnlock
HRESULT WINAPI SafeArrayUnlock(SAFEARRAY *psa)
Definition: safearray.c:831
SafeArrayCreateVector
SAFEARRAY *WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
Definition: safearray.c:677
lstrlenA
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
nocontent
static const char nocontent[]
Definition: domdoc.c:780
write_to_file
static void write_to_file(const char *name, const char *data)
Definition: domdoc.c:10176
test_doc_load_from_path
static void test_doc_load_from_path(IXMLDOMDocument *doc, const char *path)
Definition: domdoc.c:10191
url_forward_slash
static void url_forward_slash(char *url)
Definition: domdoc.c:10235
path2
static const WCHAR path2[]
Definition: path.c:29

Referenced by START_TEST().

◆ test_merging_text()

static void test_merging_text ( void  )
static

Definition at line 12690 of file domdoc.c.

12691{
12692 IXMLDOMText *nodetext;
12693 IXMLDOMText *newtext;
12694 IXMLDOMElement *root;
12695 IXMLDOMDocument *doc;
12696 IXMLDOMNode *first;
12697 HRESULT hr;
12698 VARIANT v;
12699 BSTR str;
12700 int i;
12701
12702 doc = create_document(&IID_IXMLDOMDocument);
12703
12704 hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
12705 EXPECT_HR(hr, S_OK);
12706
12707 hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
12708 EXPECT_HR(hr, S_OK);
12709
12710 /* test xmlAddChild */
12711 for (i = 0; i < 10; i++)
12712 {
12713 str = SysAllocString(szstr1);
12714 hr = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
12715 SysFreeString(str);
12716 EXPECT_HR(hr, S_OK);
12717
12718 newtext = NULL;
12719 hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)nodetext, (IXMLDOMNode**)&newtext);
12720 EXPECT_HR(hr, S_OK);
12721 ok(nodetext == newtext, "expected %p, got %p\n", nodetext, newtext);
12722
12723 IXMLDOMText_Release(newtext);
12724 IXMLDOMText_Release(nodetext);
12725 }
12726
12727 /* test xmlAddPrevSibling */
12728 hr = IXMLDOMElement_get_firstChild(root, &first);
12729 EXPECT_HR(hr, S_OK);
12730 V_VT(&v) = VT_UNKNOWN;
12731 V_UNKNOWN(&v) = (IUnknown*)first;
12732 for (i = 0; i < 10; i++)
12733 {
12734 str = SysAllocString(szstr2);
12735 hr = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
12736 SysFreeString(str);
12737 EXPECT_HR(hr, S_OK);
12738
12739 newtext = NULL;
12740 hr = IXMLDOMElement_insertBefore(root, (IXMLDOMNode*)nodetext, v, (IXMLDOMNode**)&newtext);
12741 EXPECT_HR(hr, S_OK);
12742 ok(nodetext == newtext, "expected %p, got %p\n", nodetext, newtext);
12743
12744 IXMLDOMText_Release(newtext);
12745 IXMLDOMText_Release(nodetext);
12746 }
12747
12748 IXMLDOMNode_Release(first);
12749 IXMLDOMElement_Release(root);
12750 IXMLDOMDocument_Release(doc);
12751
12752 free_bstrs();
12753}

Referenced by START_TEST().

◆ test_mxnamespacemanager()

static void test_mxnamespacemanager ( void  )
static

Definition at line 10471 of file domdoc.c.

10472{
10473 static const char xmluriA[] = "http://www.w3.org/XML/1998/namespace";
10474 IMXNamespacePrefixes *prefixes;
10475 IVBMXNamespaceManager *mgr2;
10476 IMXNamespaceManager *nsmgr;
10477 IUnknown *unk1, *unk2;
10478 WCHAR buffW[250];
10479 IDispatch *disp;
10480 IUnknown *unk;
10481 HRESULT hr;
10482 INT len;
10483
10484 hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10485 &IID_IMXNamespaceManager, (void**)&nsmgr);
10486 EXPECT_HR(hr, S_OK);
10487
10488 /* IMXNamespaceManager inherits from IUnknown */
10489 hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IDispatch, (void**)&disp);
10490 EXPECT_HR(hr, S_OK);
10491 IDispatch_Release(disp);
10492
10493 hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IVBMXNamespaceManager, (void**)&mgr2);
10494 EXPECT_HR(hr, S_OK);
10495
10496 EXPECT_REF(nsmgr, 2);
10497 EXPECT_REF(mgr2, 2);
10498 prefixes = NULL;
10499 hr = IVBMXNamespaceManager_getDeclaredPrefixes(mgr2, &prefixes);
10500todo_wine
10501 ok(hr == S_OK, "got 0x%08x\n", hr);
10502 if (hr == S_OK)
10503 {
10504 IDispatchEx *dispex;
10505 VARIANT arg, ret;
10506 DISPPARAMS dispparams;
10507
10508 ok(prefixes != NULL, "got %p\n", prefixes);
10509 EXPECT_REF(nsmgr, 2);
10510 EXPECT_REF(mgr2, 2);
10511 EXPECT_REF(prefixes, 1);
10512
10513 IVBMXNamespaceManager_QueryInterface(mgr2, &IID_IUnknown, (void**)&unk1);
10514 IMXNamespacePrefixes_QueryInterface(prefixes, &IID_IUnknown, (void**)&unk2);
10515
10516 EXPECT_REF(mgr2, 3);
10517 EXPECT_REF(prefixes, 2);
10518
10519 IUnknown_Release(unk1);
10520 IUnknown_Release(unk2);
10521
10522 hr = IMXNamespacePrefixes_QueryInterface(prefixes, &IID_IDispatchEx, (void**)&dispex);
10523 ok(hr == S_OK, "got 0x%08x\n", hr);
10524
10525 V_VT(&arg) = VT_I4;
10526 V_I4(&arg) = 0;
10527 dispparams.cArgs = 1;
10528 dispparams.cNamedArgs = 0;
10529 dispparams.rgdispidNamedArgs = NULL;
10530 dispparams.rgvarg = &arg;
10531
10532 V_VT(&ret) = VT_EMPTY;
10533 V_DISPATCH(&ret) = (void*)0x1;
10534 hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10535 ok(hr == S_OK, "got 0x%08x\n", hr);
10536 ok(V_VT(&ret) == VT_BSTR, "got %d\n", V_VT(&ret));
10537 ok(V_BSTR(&ret) != NULL, "got %p\n", V_BSTR(&ret));
10538 VariantClear(&ret);
10539
10540 IDispatchEx_Release(dispex);
10541 IMXNamespacePrefixes_Release(prefixes);
10542 }
10543 IVBMXNamespaceManager_Release(mgr2);
10544
10545 hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
10546 EXPECT_HR(hr, S_OK);
10547
10548 /* prefix already added */
10549 hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10550 EXPECT_HR(hr, S_FALSE);
10551
10552 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), NULL);
10553 EXPECT_HR(hr, E_INVALIDARG);
10554
10555 /* "xml" and "xmlns" are not allowed here */
10556 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xml"), _bstr_("uri1"));
10557 EXPECT_HR(hr, E_INVALIDARG);
10558
10559 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xmlns"), _bstr_("uri1"));
10560 EXPECT_HR(hr, E_INVALIDARG);
10561todo_wine {
10562 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, -1, NULL, NULL);
10563 EXPECT_HR(hr, E_FAIL);
10564}
10565 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, NULL);
10566 EXPECT_HR(hr, E_POINTER);
10567
10568 len = -1;
10569 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, &len);
10570 EXPECT_HR(hr, S_OK);
10571 ok(len == 3, "got %d\n", len);
10572
10573 len = -1;
10574 buffW[0] = 0x1;
10575 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10576 EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
10577 ok(len == -1, "got %d\n", len);
10578 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10579
10580 len = 10;
10581 buffW[0] = 0x1;
10582 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10583 EXPECT_HR(hr, S_OK);
10584 ok(len == 3, "got %d\n", len);
10585 ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10586
10587 /* getURI */
10588 hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, NULL);
10589 EXPECT_HR(hr, E_INVALIDARG);
10590
10591 len = -1;
10592 hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, &len);
10593 EXPECT_HR(hr, E_INVALIDARG);
10594 ok(len == -1, "got %d\n", len);
10595
10596 hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, NULL);
10597 EXPECT_HR(hr, E_POINTER);
10598
10599 len = -1;
10600 hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, &len);
10601 EXPECT_HR(hr, S_OK);
10602 /* length of "xml" uri is constant */
10603 ok(len == strlen(xmluriA), "got %d\n", len);
10604
10605 len = 100;
10606 hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
10607 EXPECT_HR(hr, S_OK);
10608 ok(len == strlen(xmluriA), "got %d\n", len);
10609 ok(!lstrcmpW(buffW, _bstr_(xmluriA)), "got prefix %s\n", wine_dbgstr_w(buffW));
10610
10611 len = strlen(xmluriA)-1;
10612 buffW[0] = 0x1;
10613 hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
10614 EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
10615 ok(len == strlen(xmluriA)-1, "got %d\n", len);
10616 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10617
10618 /* prefix xml1 not defined */
10619 len = -1;
10620 hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, NULL, &len);
10621 EXPECT_HR(hr, S_FALSE);
10622 ok(len == 0, "got %d\n", len);
10623
10624 len = 100;
10625 buffW[0] = 0x1;
10626 hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, buffW, &len);
10627 EXPECT_HR(hr, S_FALSE);
10628 ok(buffW[0] == 0, "got %x\n", buffW[0]);
10629 ok(len == 0, "got %d\n", len);
10630
10631 /* IDispatchEx tests */
10632 hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IUnknown, (void**)&unk);
10633 EXPECT_HR(hr, S_OK);
10634 test_domobj_dispex(unk);
10635 IUnknown_Release(unk);
10636
10637 IMXNamespaceManager_Release(nsmgr);
10638
10639 /* ::getPrefix() */
10640 hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10641 &IID_IMXNamespaceManager, (void**)&nsmgr);
10642 EXPECT_HR(hr, S_OK);
10643
10644 hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, NULL);
10645 EXPECT_HR(hr, E_INVALIDARG);
10646
10647 len = -1;
10648 hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, &len);
10649 EXPECT_HR(hr, E_INVALIDARG);
10650 ok(len == -1, "got %d\n", len);
10651
10652 len = 100;
10653 buffW[0] = 0x1;
10654 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
10655 EXPECT_HR(hr, E_FAIL);
10656 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10657 ok(len == 100, "got %d\n", len);
10658
10659 len = 0;
10660 buffW[0] = 0x1;
10661 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
10662 EXPECT_HR(hr, E_FAIL);
10663 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10664 ok(len == 0, "got %d\n", len);
10665
10666 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
10667 EXPECT_HR(hr, S_OK);
10668
10669 len = 100;
10670 buffW[0] = 0x1;
10671 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10672 EXPECT_HR(hr, S_OK);
10673 ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10674 ok(len == 3, "got %d\n", len);
10675
10676 len = 100;
10677 buffW[0] = 0x1;
10678 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, buffW, &len);
10679 EXPECT_HR(hr, S_OK);
10680 ok(!lstrcmpW(buffW, _bstr_("xml")), "got %s\n", wine_dbgstr_w(buffW));
10681 ok(len == 3, "got %d\n", len);
10682
10683 /* with null buffer it's possible to get required length */
10684 len = 100;
10685 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
10686 EXPECT_HR(hr, S_OK);
10687 ok(len == 3, "got %d\n", len);
10688
10689 len = 0;
10690 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
10691 EXPECT_HR(hr, S_OK);
10692 ok(len == 3, "got %d\n", len);
10693
10694 len = 100;
10695 buffW[0] = 0x1;
10696 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 1, buffW, &len);
10697 EXPECT_HR(hr, E_FAIL);
10698 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10699 ok(len == 100, "got %d\n", len);
10700
10701 len = 100;
10702 buffW[0] = 0x1;
10703 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 2, buffW, &len);
10704 EXPECT_HR(hr, E_FAIL);
10705 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10706 ok(len == 100, "got %d\n", len);
10707
10708 len = 100;
10709 buffW[0] = 0x1;
10710 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 0, buffW, &len);
10711 EXPECT_HR(hr, E_INVALIDARG);
10712 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10713 ok(len == 100, "got %d\n", len);
10714
10715 len = 100;
10716 buffW[0] = 0x1;
10717 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
10718 EXPECT_HR(hr, E_INVALIDARG);
10719 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10720 ok(len == 100, "got %d\n", len);
10721
10722 len = 100;
10723 buffW[0] = 0x1;
10724 hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, buffW, &len);
10725 EXPECT_HR(hr, E_INVALIDARG);
10726 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10727 ok(len == 100, "got %d\n", len);
10728
10729 len = 100;
10730 buffW[0] = 0x1;
10731 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 1, buffW, &len);
10732 EXPECT_HR(hr, E_FAIL);
10733 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10734 ok(len == 100, "got %d\n", len);
10735
10736 len = 100;
10737 buffW[0] = 0x1;
10738 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
10739 EXPECT_HR(hr, E_INVALIDARG);
10740 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10741 ok(len == 100, "got %d\n", len);
10742
10743 /* declare another one, indices are shifted */
10744 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
10745 EXPECT_HR(hr, S_OK);
10746
10747 len = 100;
10748 buffW[0] = 0x1;
10749 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10750 EXPECT_HR(hr, S_OK);
10751 ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10752 ok(len == 3, "got %d\n", len);
10753
10754 len = 100;
10755 buffW[0] = 0x1;
10756 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10757 EXPECT_HR(hr, S_OK);
10758 ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
10759 ok(len == 3, "got %d\n", len);
10760
10761 len = 100;
10762 buffW[0] = 0x1;
10763 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 1, buffW, &len);
10764 EXPECT_HR(hr, E_FAIL);
10765 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10766 ok(len == 100, "got %d\n", len);
10767
10768 len = 100;
10769 buffW[0] = 0x1;
10770 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
10771 EXPECT_HR(hr, E_INVALIDARG);
10772 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10773 ok(len == 100, "got %d\n", len);
10774
10775 IMXNamespaceManager_Release(nsmgr);
10776
10777 /* push/pop tests */
10778 hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10779 &IID_IMXNamespaceManager, (void**)&nsmgr);
10780 EXPECT_HR(hr, S_OK);
10781
10782 /* pop with empty stack */
10783 hr = IMXNamespaceManager_popContext(nsmgr);
10784 EXPECT_HR(hr, E_FAIL);
10785
10786 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
10787 EXPECT_HR(hr, S_OK);
10788
10789 len = 100;
10790 buffW[0] = 0x1;
10791 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10792 EXPECT_HR(hr, S_OK);
10793 ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10794 ok(len == 3, "got %d\n", len);
10795
10796 hr = IMXNamespaceManager_pushContext(nsmgr);
10797 EXPECT_HR(hr, S_OK);
10798
10799 len = 100;
10800 buffW[0] = 0x1;
10801 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10802 EXPECT_HR(hr, S_OK);
10803 ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10804 ok(len == 3, "got %d\n", len);
10805
10806 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
10807 EXPECT_HR(hr, S_OK);
10808
10809 len = 100;
10810 buffW[0] = 0x1;
10811 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10812 EXPECT_HR(hr, S_OK);
10813 ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
10814 ok(len == 3, "got %d\n", len);
10815
10816 hr = IMXNamespaceManager_pushContext(nsmgr);
10817 EXPECT_HR(hr, S_OK);
10818 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns3"), _bstr_("ns3 uri"));
10819 EXPECT_HR(hr, S_OK);
10820
10821 len = 100;
10822 buffW[0] = 0x1;
10823 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10824 EXPECT_HR(hr, S_OK);
10825 ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
10826 ok(len == 3, "got %d\n", len);
10827
10828 len = 100;
10829 buffW[0] = 0x1;
10830 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10831 EXPECT_HR(hr, S_OK);
10832 ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10833 ok(len == 3, "got %d\n", len);
10834
10835 hr = IMXNamespaceManager_popContext(nsmgr);
10836 EXPECT_HR(hr, S_OK);
10837
10838 hr = IMXNamespaceManager_popContext(nsmgr);
10839 EXPECT_HR(hr, S_OK);
10840
10841 len = 100;
10842 buffW[0] = 0x1;
10843 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10844 EXPECT_HR(hr, E_FAIL);
10845 ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10846 ok(len == 100, "got %d\n", len);
10847
10848 len = 100;
10849 buffW[0] = 0x1;
10850 hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10851 EXPECT_HR(hr, S_OK);
10852 ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10853 ok(len == 3, "got %d\n", len);
10854
10855 IMXNamespaceManager_Release(nsmgr);
10856
10857 free_bstrs();
10858}
prefixes
static int prefixes
Definition: i386-dis.c:276
INT
int32_t INT
Definition: typedefs.h:58

Referenced by START_TEST().

◆ test_mxnamespacemanager_override()

static void test_mxnamespacemanager_override ( void  )
static

Definition at line 10860 of file domdoc.c.

10861{
10862 IMXNamespaceManager *nsmgr;
10863 WCHAR buffW[250];
10864 VARIANT_BOOL b;
10865 HRESULT hr;
10866 INT len;
10867
10868 hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10869 &IID_IMXNamespaceManager, (void**)&nsmgr);
10870 EXPECT_HR(hr, S_OK);
10871
10872 len = ARRAY_SIZE(buffW);
10873 buffW[0] = 0;
10874 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10875 EXPECT_HR(hr, S_OK);
10876 ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10877
10878 len = ARRAY_SIZE(buffW);
10879 buffW[0] = 0;
10880 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10881 EXPECT_HR(hr, E_FAIL);
10882
10883 hr = IMXNamespaceManager_getAllowOverride(nsmgr, NULL);
10884 EXPECT_HR(hr, E_POINTER);
10885
10886 b = VARIANT_FALSE;
10887 hr = IMXNamespaceManager_getAllowOverride(nsmgr, &b);
10888 EXPECT_HR(hr, S_OK);
10889 ok(b == VARIANT_TRUE, "got %d\n", b);
10890
10891 hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_FALSE);
10892 EXPECT_HR(hr, S_OK);
10893
10894 hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10895 EXPECT_HR(hr, S_OK);
10896
10897 len = ARRAY_SIZE(buffW);
10898 buffW[0] = 0;
10899 hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
10900 EXPECT_HR(hr, S_OK);
10901 ok(!lstrcmpW(buffW, _bstr_("ns0 uri")), "got uri %s\n", wine_dbgstr_w(buffW));
10902
10903 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), _bstr_("ns0 uri"));
10904 EXPECT_HR(hr, S_OK);
10905
10906 len = ARRAY_SIZE(buffW);
10907 buffW[0] = 0;
10908 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10909 EXPECT_HR(hr, S_OK);
10910 ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10911
10912 len = ARRAY_SIZE(buffW);
10913 buffW[0] = 0;
10914 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10915 EXPECT_HR(hr, S_OK);
10916 ok(!lstrcmpW(buffW, _bstr_("ns0")), "got prefix %s\n", wine_dbgstr_w(buffW));
10917
10918 len = ARRAY_SIZE(buffW);
10919 buffW[0] = 0;
10920 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 2, buffW, &len);
10921 EXPECT_HR(hr, S_OK);
10922 ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
10923
10924 /* new prefix placed at index 1 always */
10925 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
10926 EXPECT_HR(hr, S_OK);
10927
10928 len = ARRAY_SIZE(buffW);
10929 buffW[0] = 0;
10930 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10931 EXPECT_HR(hr, S_OK);
10932 ok(!lstrcmpW(buffW, _bstr_("ns1")), "got prefix %s\n", wine_dbgstr_w(buffW));
10933
10934 hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_(""), NULL);
10935 todo_wine EXPECT_HR(hr, E_FAIL);
10936
10937 hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
10938 EXPECT_HR(hr, E_FAIL);
10939
10940 hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10941 EXPECT_HR(hr, E_FAIL);
10942
10943 hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_TRUE);
10944 EXPECT_HR(hr, S_OK);
10945
10946 hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri override"));
10947 EXPECT_HR(hr, S_FALSE);
10948
10949 len = ARRAY_SIZE(buffW);
10950 buffW[0] = 0;
10951 hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
10952 EXPECT_HR(hr, S_OK);
10953 ok(!lstrcmpW(buffW, _bstr_("ns0 uri override")), "got uri %s\n", wine_dbgstr_w(buffW));
10954
10955 len = ARRAY_SIZE(buffW);
10956 buffW[0] = 0;
10957 hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 3, buffW, &len);
10958 EXPECT_HR(hr, S_OK);
10959 ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
10960
10961 IMXNamespaceManager_Release(nsmgr);
10962
10963 free_bstrs();
10964}

Referenced by START_TEST().

◆ test_namedmap_newenum()

static void test_namedmap_newenum ( void  )
static

Definition at line 12399 of file domdoc.c.

12400{
12401 IEnumVARIANT *enum1, *enum2, *enum3;
12402 IXMLDOMNamedNodeMap *map;
12403 IUnknown *unk1, *unk2;
12404 IXMLDOMDocument *doc;
12405 IXMLDOMElement *elem;
12406 IXMLDOMNode *node;
12407 VARIANT_BOOL b;
12408 HRESULT hr;
12409 VARIANT v;
12410 BSTR str;
12411
12412 doc = create_document(&IID_IXMLDOMDocument);
12413
12414 hr = IXMLDOMDocument_loadXML(doc, _bstr_(attributes_map), &b);
12415 EXPECT_HR(hr, S_OK);
12416
12417 hr = IXMLDOMDocument_get_documentElement(doc, &elem);
12418 EXPECT_HR(hr, S_OK);
12419
12420 hr = IXMLDOMElement_get_attributes(elem, &map);
12421 EXPECT_HR(hr, S_OK);
12422 IXMLDOMElement_Release(elem);
12423
12424 enum1 = NULL;
12425 EXPECT_REF(map, 1);
12426 hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum1);
12427 EXPECT_HR(hr, S_OK);
12428 ok(enum1 != NULL, "got %p\n", enum1);
12429 EXPECT_REF(map, 1);
12430 EXPECT_REF(enum1, 2);
12431
12432 enum2 = NULL;
12433 hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum2);
12434 EXPECT_HR(hr, S_OK);
12435 ok(enum2 == enum1, "got %p\n", enum2);
12436
12437 IEnumVARIANT_Release(enum2);
12438
12439 EXPECT_REF(map, 1);
12440 hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum2);
12441 EXPECT_HR(hr, S_OK);
12442 EXPECT_REF(map, 2);
12443 EXPECT_REF(enum2, 1);
12444 ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
12445
12446 IEnumVARIANT_Release(enum1);
12447
12448 /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
12449 hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk1);
12450 EXPECT_HR(hr, S_OK);
12451 hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
12452 EXPECT_HR(hr, S_OK);
12453 EXPECT_REF(map, 3);
12454 EXPECT_REF(enum2, 2);
12455 ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
12456 IUnknown_Release(unk1);
12457 IUnknown_Release(unk2);
12458
12459 hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum3);
12460 EXPECT_HR(hr, S_OK);
12461 ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
12462 IEnumVARIANT_Release(enum3);
12463
12464 /* iteration tests */
12465 hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node);
12466 EXPECT_HR(hr, S_OK);
12467 hr = IXMLDOMNode_get_nodeName(node, &str);
12468 EXPECT_HR(hr, S_OK);
12469 ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
12470 SysFreeString(str);
12471 IXMLDOMNode_Release(node);
12472
12473 hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
12474 EXPECT_HR(hr, S_OK);
12475 hr = IXMLDOMNode_get_nodeName(node, &str);
12476 EXPECT_HR(hr, S_OK);
12477 ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
12478 SysFreeString(str);
12479 IXMLDOMNode_Release(node);
12480
12481 V_VT(&v) = VT_EMPTY;
12482 hr = IEnumVARIANT_Next(enum2, 1, &v, NULL);
12483 EXPECT_HR(hr, S_OK);
12484 ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
12485 hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
12486 EXPECT_HR(hr, S_OK);
12487 hr = IXMLDOMNode_get_nodeName(node, &str);
12488 EXPECT_HR(hr, S_OK);
12489 ok(!lstrcmpW(str, _bstr_("attr1")), "got node name %s\n", wine_dbgstr_w(str));
12490 SysFreeString(str);
12491 IXMLDOMNode_Release(node);
12492 VariantClear(&v);
12493
12494 hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
12495 EXPECT_HR(hr, S_OK);
12496 hr = IXMLDOMNode_get_nodeName(node, &str);
12497 EXPECT_HR(hr, S_OK);
12498 ok(!lstrcmpW(str, _bstr_("attr2")), "got %s\n", wine_dbgstr_w(str));
12499 SysFreeString(str);
12500 IXMLDOMNode_Release(node);
12501
12502 IEnumVARIANT_Release(enum2);
12503 IXMLDOMNamedNodeMap_Release(map);
12504 IXMLDOMDocument_Release(doc);
12505}
attributes_map
static const char attributes_map[]
Definition: domdoc.c:1142

Referenced by START_TEST().

◆ test_namespaces_as_attributes()

static void test_namespaces_as_attributes ( void  )
static

Definition at line 12884 of file domdoc.c.

12885{
12886 const namespace_as_attribute_t *entry = namespace_as_attribute_test_data;
12887 struct test {
12888 const char *xml;
12889 int explen;
12890 const char *names[3];
12891 const char *prefixes[3];
12892 const char *basenames[3];
12893 const char *uris[3];
12894 const char *texts[3];
12895 };
12896 static const struct test tests[] = {
12897 {
12898 "<a ns:b=\"b attr\" d=\"d attr\" xmlns:ns=\"nshref\" />", 3,
12899 { "ns:b", "d", "xmlns:ns" }, /* nodeName */
12900 { "ns", NULL, "xmlns" }, /* prefix */
12901 { "b", "d", "ns" }, /* baseName */
12902 { "nshref", NULL, "" }, /* namespaceURI */
12903 { "b attr", "d attr", "nshref" }, /* text */
12904 },
12905 /* property only */
12906 {
12907 "<a d=\"d attr\" />", 1,
12908 { "d" }, /* nodeName */
12909 { NULL }, /* prefix */
12910 { "d" }, /* baseName */
12911 { NULL }, /* namespaceURI */
12912 { "d attr" }, /* text */
12913 },
12914 /* namespace only */
12915 {
12916 "<a xmlns:ns=\"nshref\" />", 1,
12917 { "xmlns:ns" }, /* nodeName */
12918 { "xmlns" }, /* prefix */
12919 { "ns" }, /* baseName */
12920 { "" }, /* namespaceURI */
12921 { "nshref" }, /* text */
12922 },
12923 /* no properties or namespaces */
12924 {
12925 "<a />", 0,
12926 },
12927
12928 { NULL }
12929 };
12930 const struct test *test;
12931 IXMLDOMNamedNodeMap *map;
12932 IXMLDOMNode *node, *item;
12933 IXMLDOMDocument *doc;
12934 VARIANT_BOOL b;
12935 LONG len, i;
12936 HRESULT hr;
12937 BSTR str;
12938
12939 while (entry->guid)
12940 {
12941 if (!is_clsid_supported(entry->guid, &IID_IXMLDOMDocument2))
12942 {
12943 entry++;
12944 continue;
12945 }
12946
12947 test = tests;
12948 while (test->xml) {
12949 hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void **)&doc);
12950 ok(SUCCEEDED(hr), "Failed to create document %s, hr %#x.\n", wine_dbgstr_guid(entry->guid), hr);
12951
12952 hr = IXMLDOMDocument_loadXML(doc, _bstr_(test->xml), &b);
12953 ok(hr == S_OK, "Failed to load xml, hr %#x.\n", hr);
12954
12955 node = NULL;
12956 hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("a"), &node);
12957 ok(SUCCEEDED(hr), "Failed to select a node, hr %#x.\n", hr);
12958
12959 hr = IXMLDOMNode_get_attributes(node, &map);
12960 ok(SUCCEEDED(hr), "Failed to get attributes, hr %#x.\n", hr);
12961
12962 len = -1;
12963 hr = IXMLDOMNamedNodeMap_get_length(map, &len);
12964 ok(SUCCEEDED(hr), "Failed to get map length, hr %#x.\n", hr);
12965 ok(len == test->explen, "got %d\n", len);
12966
12967 item = NULL;
12968 hr = IXMLDOMNamedNodeMap_get_item(map, test->explen+1, &item);
12969 ok(hr == S_FALSE, "Failed to get item, hr %#x.\n", hr);
12970 ok(!item, "Item should be NULL\n");
12971
12972 for (i = 0; i < len; i++)
12973 {
12974 item = NULL;
12975 hr = IXMLDOMNamedNodeMap_get_item(map, i, &item);
12976 ok(SUCCEEDED(hr), "Failed to get item, hr %#x.\n", hr);
12977
12978 str = NULL;
12979 hr = IXMLDOMNode_get_nodeName(item, &str);
12980 ok(SUCCEEDED(hr), "Failed to get node name, hr %#x.\n", hr);
12981 ok(!lstrcmpW(str, _bstr_(test->names[i])), "got %s\n", wine_dbgstr_w(str));
12982 SysFreeString(str);
12983
12984 str = NULL;
12985 hr = IXMLDOMNode_get_prefix(item, &str);
12986 if (test->prefixes[i])
12987 {
12988 ok(hr == S_OK, "Failed to get node name, hr %#x.\n", hr);
12989 ok(!lstrcmpW(str, _bstr_(test->prefixes[i])), "got %s\n", wine_dbgstr_w(str));
12990 SysFreeString(str);
12991 }
12992 else
12993 ok(hr == S_FALSE, "Failed to get node name, hr %#x.\n", hr);
12994
12995 str = NULL;
12996 hr = IXMLDOMNode_get_baseName(item, &str);
12997 ok(SUCCEEDED(hr), "Failed to get base name, hr %#x.\n", hr);
12998 ok(!lstrcmpW(str, _bstr_(test->basenames[i])), "got %s\n", wine_dbgstr_w(str));
12999 SysFreeString(str);
13000
13001 str = NULL;
13002 hr = IXMLDOMNode_get_namespaceURI(item, &str);
13003 if (test->uris[i])
13004 {
13005 ok(hr == S_OK, "Failed to get node name, hr %#x.\n", hr);
13006 if (test->prefixes[i] && !strcmp(test->prefixes[i], "xmlns"))
13007 ok(!lstrcmpW(str, _bstr_(entry->xmlns_uri)), "got %s\n", wine_dbgstr_w(str));
13008 else
13009 ok(!lstrcmpW(str, _bstr_(test->uris[i])), "got %s\n", wine_dbgstr_w(str));
13010 SysFreeString(str);
13011 }
13012 else
13013 ok(hr == S_FALSE, "Failed to get node name, hr %#x.\n", hr);
13014
13015 str = NULL;
13016 hr = IXMLDOMNode_get_text(item, &str);
13017 ok(SUCCEEDED(hr), "Failed to get node text, hr %#x.\n", hr);
13018 ok(!lstrcmpW(str, _bstr_(test->texts[i])), "got %s\n", wine_dbgstr_w(str));
13019 SysFreeString(str);
13020
13021 IXMLDOMNode_Release(item);
13022 }
13023
13024 IXMLDOMNamedNodeMap_Release(map);
13025 IXMLDOMNode_Release(node);
13026 IXMLDOMDocument_Release(doc);
13027
13028 test++;
13029 }
13030
13031 entry++;
13032 }
13033 free_bstrs();
13034}
names
GLuint GLuint * names
Definition: glext.h:11545
tests
static struct test_info tests[]
namespace_as_attribute_test_data
static const namespace_as_attribute_t namespace_as_attribute_test_data[]
Definition: domdoc.c:12874
item
static ATOM item
Definition: dde.c:856
test
#define test
Definition: rosglue.h:37
_namespace_as_attribute_t
Definition: domdoc.c:12868

Referenced by START_TEST().

◆ test_namespaces_basic()

static void test_namespaces_basic ( void  )
static

Definition at line 6654 of file domdoc.c.

6655{
6656 static const CHAR namespaces_xmlA[] =
6657 "<?xml version=\"1.0\"?>\n"
6658 "<XMI xmi.version=\"1.1\" xmlns:Model=\"http://omg.org/mof.Model/1.3\">"
6659 " <XMI.content>"
6660 " <Model:Package name=\"WinePackage\" Model:name2=\"name2 attr\" />"
6661 " </XMI.content>"
6662 "</XMI>";
6663
6664 IXMLDOMDocument *doc;
6665 IXMLDOMElement *elem;
6666 IXMLDOMNode *node;
6667
6668 VARIANT_BOOL b;
6669 HRESULT hr;
6670 BSTR str;
6671
6672 doc = create_document(&IID_IXMLDOMDocument);
6673
6674 hr = IXMLDOMDocument_loadXML(doc, _bstr_(namespaces_xmlA), &b);
6675 EXPECT_HR(hr, S_OK);
6676 ok(b == VARIANT_TRUE, "got %d\n", b);
6677
6678 str = (void *)0xdeadbeef;
6679 hr = IXMLDOMDocument_get_namespaceURI(doc, &str);
6680 EXPECT_HR(hr, S_FALSE);
6681 ok(str == NULL, "got %p\n", str);
6682
6683 hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("//XMI.content"), &node );
6684 EXPECT_HR(hr, S_OK);
6685 if(hr == S_OK)
6686 {
6687 IXMLDOMAttribute *attr;
6688 IXMLDOMNode *node2;
6689
6690 hr = IXMLDOMNode_get_firstChild(node, &node2);
6691 EXPECT_HR(hr, S_OK);
6692 ok(node2 != NULL, "got %p\n", node2);
6693
6694 /* Test get_prefix */
6695 hr = IXMLDOMNode_get_prefix(node2, NULL);
6696 EXPECT_HR(hr, E_INVALIDARG);
6697 /* NOTE: Need to test that arg2 gets cleared on Error. */
6698
6699 hr = IXMLDOMNode_get_prefix(node2, &str);
6700 EXPECT_HR(hr, S_OK);
6701 ok( !lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
6702 SysFreeString(str);
6703
6704 hr = IXMLDOMNode_get_nodeName(node2, &str);
6705 EXPECT_HR(hr, S_OK);
6706 ok(!lstrcmpW( str, _bstr_("Model:Package")), "got %s\n", wine_dbgstr_w(str));
6707 SysFreeString(str);
6708
6709 /* Test get_namespaceURI */
6710 hr = IXMLDOMNode_get_namespaceURI(node2, NULL);
6711 EXPECT_HR(hr, E_INVALIDARG);
6712 /* NOTE: Need to test that arg2 gets cleared on Error. */
6713
6714 hr = IXMLDOMNode_get_namespaceURI(node2, &str);
6715 EXPECT_HR(hr, S_OK);
6716 ok(!lstrcmpW( str, _bstr_("http://omg.org/mof.Model/1.3")), "got %s\n", wine_dbgstr_w(str));
6717 SysFreeString(str);
6718
6719 hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&elem);
6720 EXPECT_HR(hr, S_OK);
6721
6722 hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("Model:name2"), &attr);
6723 EXPECT_HR(hr, S_OK);
6724
6725 hr = IXMLDOMAttribute_get_nodeName(attr, &str);
6726 EXPECT_HR(hr, S_OK);
6727 ok(!lstrcmpW( str, _bstr_("Model:name2")), "got %s\n", wine_dbgstr_w(str));
6728 SysFreeString(str);
6729
6730 hr = IXMLDOMAttribute_get_prefix(attr, &str);
6731 EXPECT_HR(hr, S_OK);
6732 ok(!lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
6733 SysFreeString(str);
6734
6735 IXMLDOMAttribute_Release(attr);
6736 IXMLDOMElement_Release(elem);
6737
6738 IXMLDOMNode_Release(node2);
6739 IXMLDOMNode_Release(node);
6740 }
6741
6742 IXMLDOMDocument_Release(doc);
6743
6744 free_bstrs();
6745}

Referenced by START_TEST().

◆ test_namespaces_change()

static void test_namespaces_change ( void  )
static

Definition at line 6589 of file domdoc.c.

6590{
6591 const struct namespaces_change_t *class_ptr = namespaces_change_test_data;
6592
6593 while (class_ptr->clsid)
6594 {
6595 IXMLDOMDocument *doc = NULL;
6596 IXMLDOMElement *elem = NULL;
6597 IXMLDOMNode *node = NULL;
6598
6599 VARIANT var;
6600 HRESULT hr;
6601 BSTR str;
6602
6603 if (!is_clsid_supported(class_ptr->clsid, &IID_IXMLDOMDocument))
6604 {
6605 class_ptr++;
6606 continue;
6607 }
6608
6609 hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
6610 &IID_IXMLDOMDocument, (void**)&doc);
6611 ok(hr == S_OK, "got 0x%08x\n", hr);
6612
6613 V_VT(&var) = VT_I2;
6614 V_I2(&var) = NODE_ELEMENT;
6615
6616 hr = IXMLDOMDocument_createNode(doc, var, _bstr_("ns:elem"), _bstr_("ns/uri"), &node);
6617 EXPECT_HR(hr, S_OK);
6618
6619 hr = IXMLDOMDocument_appendChild(doc, node, NULL);
6620 EXPECT_HR(hr, S_OK);
6621
6622 hr = IXMLDOMDocument_get_documentElement(doc, &elem);
6623 EXPECT_HR(hr, S_OK);
6624
6625 /* try same prefix, different uri */
6626 V_VT(&var) = VT_BSTR;
6627 V_BSTR(&var) = _bstr_("ns/uri2");
6628
6629 hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
6630 EXPECT_HR(hr, E_INVALIDARG);
6631
6632 /* try same prefix and uri */
6633 V_VT(&var) = VT_BSTR;
6634 V_BSTR(&var) = _bstr_("ns/uri");
6635
6636 hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
6637 EXPECT_HR(hr, S_OK);
6638
6639 hr = IXMLDOMElement_get_xml(elem, &str);
6640 EXPECT_HR(hr, S_OK);
6641 ok(!lstrcmpW(str, _bstr_("<ns:elem xmlns:ns=\"ns/uri\"/>")), "got element %s for %s\n",
6642 wine_dbgstr_w(str), class_ptr->name);
6643 SysFreeString(str);
6644
6645 IXMLDOMElement_Release(elem);
6646 IXMLDOMDocument_Release(doc);
6647
6648 free_bstrs();
6649
6650 class_ptr++;
6651 }
6652}
namespaces_change_test_data
static const struct namespaces_change_t namespaces_change_test_data[]
Definition: domdoc.c:6579
namespaces_change_t
Definition: domdoc.c:6574
namespaces_change_t::clsid
const CLSID * clsid
Definition: domdoc.c:6575
namespaces_change_t::name
const char * name
Definition: domdoc.c:6576

Referenced by START_TEST().

◆ test_newline_normalization()

static void test_newline_normalization ( void  )
static

Definition at line 12185 of file domdoc.c.

12186{
12187 const struct msxmlsupported_data_t *table = domdoc_support_data;
12188 IXMLDOMDocument *doc;
12189 IXMLDOMText *text;
12190 IXMLDOMNode *node;
12191 VARIANT v;
12192 VARIANT_BOOL b;
12193 BSTR s;
12194 HRESULT hr;
12195 LONG length;
12196
12197 V_VT(&v) = VT_I2;
12198 V_I2(&v) = NODE_TEXT;
12199
12200 while (table->clsid)
12201 {
12202 if (!is_clsid_supported(table->clsid, &IID_IXMLDOMDocument))
12203 {
12204 table++;
12205 continue;
12206 }
12207
12208 hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
12209 ok(hr == S_OK, "got 0x%08x\n", hr);
12210
12211 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
12212 ok(hr == S_OK, "got 0x%08x\n", hr);
12213
12214 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
12215
12216 /* \r\n is normalized to \n and back to \r\n */
12217
12218 hr = IXMLDOMText_put_data(text, _bstr_("\r\n"));
12219 ok(hr == S_OK, "got 0x%08x\n", hr);
12220
12221 hr = IXMLDOMText_get_data(text, &s);
12222 ok(hr == S_OK, "got 0x%08x\n", hr);
12223 ok(!lstrcmpW(s, _bstr_("\n")), "got %s\n", wine_dbgstr_w(s));
12224 SysFreeString(s);
12225
12226 hr = IXMLDOMText_get_length(text, &length);
12227 ok(hr == S_OK, "got 0x%08x\n", hr);
12228 ok(length == 1, "got %d, expected 1\n", length);
12229
12230 hr = IXMLDOMText_get_xml(text, &s);
12231 ok(hr == S_OK, "got 0x%08x\n", hr);
12232 ok(!lstrcmpW(s, _bstr_("\r\n")), "got %s\n", wine_dbgstr_w(s));
12233 SysFreeString(s);
12234
12235 /* \r\r\n is normalized to \n\n and back to \r\n\r\n */
12236
12237 hr = IXMLDOMText_put_data(text, _bstr_("\r\r\n"));
12238 ok(hr == S_OK, "got 0x%08x\n", hr);
12239
12240 hr = IXMLDOMText_get_data(text, &s);
12241 ok(hr == S_OK, "got 0x%08x\n", hr);
12242 ok(!lstrcmpW(s, _bstr_("\n\n")), "got %s\n", wine_dbgstr_w(s));
12243 SysFreeString(s);
12244
12245 hr = IXMLDOMText_get_length(text, &length);
12246 ok(hr == S_OK, "got 0x%08x\n", hr);
12247 ok(length == 2, "got %d, expected 2\n", length);
12248
12249 hr = IXMLDOMText_get_xml(text, &s);
12250 ok(hr == S_OK, "got 0x%08x\n", hr);
12251 ok(!lstrcmpW(s, _bstr_("\r\n\r\n")), "got %s\n", wine_dbgstr_w(s));
12252 SysFreeString(s);
12253
12254 /* the same normalizations are applied when loading a document as a whole */
12255
12256 hr = IXMLDOMDocument_loadXML(doc, _bstr_("<?xml version=\"1.0\"?><root>foo\n\r\n\r\r\nbar</root>"), &b);
12257 ok(hr == S_OK, "got 0x%08x\n", hr);
12258
12259 hr = IXMLDOMDocument_get_text(doc, &s);
12260 ok(hr == S_OK, "got 0x%08x\n", hr);
12261 ok(!lstrcmpW(s, _bstr_("foo\n\n\n\nbar")), "got %s\n", wine_dbgstr_w(s));
12262 SysFreeString(s);
12263
12264 hr = IXMLDOMDocument_get_xml(doc, &s);
12265 ok(hr == S_OK, "got 0x%08x\n", hr);
12266 ok(!lstrcmpW(s, _bstr_("<?xml version=\"1.0\"?>\r\n<root>foo\r\n\r\n\r\n\r\nbar</root>\r\n")),
12267 "got %s\n", wine_dbgstr_w(s));
12268 SysFreeString(s);
12269
12270 /* even if xml:space="preserve" */
12271
12272 hr = IXMLDOMDocument_loadXML(doc, _bstr_("<?xml version=\"1.0\"?>"
12273 "<root xml:space=\"preserve\">foo\n\r\n\r\r\nbar</root>"), &b);
12274 ok(hr == S_OK, "got 0x%08x\n", hr);
12275
12276 hr = IXMLDOMDocument_get_text(doc, &s);
12277 ok(hr == S_OK, "got 0x%08x\n", hr);
12278 ok(!lstrcmpW(s, _bstr_("foo\n\n\n\nbar")), "got %s\n", wine_dbgstr_w(s));
12279 SysFreeString(s);
12280
12281 hr = IXMLDOMDocument_get_xml(doc, &s);
12282 ok(hr == S_OK, "got 0x%08x\n", hr);
12283 ok(!lstrcmpW(s, _bstr_("<?xml version=\"1.0\"?>\r\n"
12284 "<root xml:space=\"preserve\">foo\r\n\r\n\r\n\r\nbar</root>\r\n")),
12285 "got %s\n", wine_dbgstr_w(s));
12286 SysFreeString(s);
12287
12288 /* or preserveWhiteSpace is set */
12289
12290 hr = IXMLDOMDocument_put_preserveWhiteSpace(doc, VARIANT_TRUE);
12291 ok(hr == S_OK, "got 0x%08x\n", hr);
12292
12293 hr = IXMLDOMDocument_loadXML(doc, _bstr_("<?xml version=\"1.0\"?><root>foo\n\r\n\r\r\nbar</root>"), &b);
12294 ok(hr == S_OK, "got 0x%08x\n", hr);
12295
12296 hr = IXMLDOMDocument_get_text(doc, &s);
12297 ok(hr == S_OK, "got 0x%08x\n", hr);
12298 ok(!lstrcmpW(s, _bstr_("foo\n\n\n\nbar")), "got %s\n", wine_dbgstr_w(s));
12299 SysFreeString(s);
12300
12301 hr = IXMLDOMDocument_get_xml(doc, &s);
12302 ok(hr == S_OK, "got 0x%08x\n", hr);
12303 if (IsEqualGUID(table->clsid, &CLSID_DOMDocument60))
12304 {
12305 /* DOMDocument60 does the newline normalization but does not insert line breaks around the root node */
12306todo_wine
12307 ok(!lstrcmpW(s, _bstr_("<?xml version=\"1.0\"?><root>foo\r\n\r\n\r\n\r\nbar</root>")),
12308 "got %s\n", wine_dbgstr_w(s));
12309 }
12310 else
12311 {
12312 ok(!lstrcmpW(s, _bstr_("<?xml version=\"1.0\"?>\r\n<root>foo\r\n\r\n\r\n\r\nbar</root>\r\n")),
12313 "got %s\n", wine_dbgstr_w(s));
12314 }
12315 SysFreeString(s);
12316
12317 IXMLDOMText_Release(text);
12318 IXMLDOMNode_Release(node);
12319 IXMLDOMDocument_Release(doc);
12320 free_bstrs();
12321 table++;
12322 }
12323}

Referenced by START_TEST().

◆ test_nodeTypedValue()

static void test_nodeTypedValue ( void  )
static

Definition at line 6818 of file domdoc.c.

6819{
6820 const nodetypedvalue_t *entry = get_nodetypedvalue;
6821 IXMLDOMDocumentType *doctype, *doctype2;
6822 IXMLDOMProcessingInstruction *pi;
6823 IXMLDOMDocumentFragment *frag;
6824 IXMLDOMDocument *doc, *doc2;
6825 IXMLDOMCDATASection *cdata;
6826 IXMLDOMComment *comment;
6827 IXMLDOMNode *node;
6828 VARIANT_BOOL b;
6829 VARIANT value;
6830 HRESULT hr;
6831
6832 doc = create_document(&IID_IXMLDOMDocument);
6833
6834 b = VARIANT_FALSE;
6835 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &b);
6836 ok(hr == S_OK, "ret %08x\n", hr );
6837 ok(b == VARIANT_TRUE, "got %d\n", b);
6838
6839 hr = IXMLDOMDocument_get_nodeValue(doc, NULL);
6840 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6841
6842 V_VT(&value) = VT_BSTR;
6843 V_BSTR(&value) = NULL;
6844 hr = IXMLDOMDocument_get_nodeValue(doc, &value);
6845 ok(hr == S_FALSE, "ret %08x\n", hr );
6846 ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6847
6848 hr = IXMLDOMDocument_get_nodeTypedValue(doc, NULL);
6849 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6850
6851 V_VT(&value) = VT_EMPTY;
6852 hr = IXMLDOMDocument_get_nodeTypedValue(doc, &value);
6853 ok(hr == S_FALSE, "ret %08x\n", hr );
6854 ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6855
6856 hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/string"), &node);
6857 ok(hr == S_OK, "ret %08x\n", hr );
6858
6859 V_VT(&value) = VT_BSTR;
6860 V_BSTR(&value) = NULL;
6861 hr = IXMLDOMNode_get_nodeValue(node, &value);
6862 ok(hr == S_FALSE, "ret %08x\n", hr );
6863 ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6864
6865 hr = IXMLDOMNode_get_nodeTypedValue(node, NULL);
6866 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6867
6868 IXMLDOMNode_Release(node);
6869
6870 hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/binhex"), &node);
6871 ok(hr == S_OK, "ret %08x\n", hr );
6872 {
6873 BYTE bytes[] = {0xff,0xfc,0xa0,0x12,0x00,0x3c};
6874
6875 hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6876 ok(hr == S_OK, "ret %08x\n", hr );
6877 ok(V_VT(&value) == (VT_ARRAY|VT_UI1), "incorrect type\n");
6878 ok(V_ARRAY(&value)->rgsabound[0].cElements == 6, "incorrect array size\n");
6879 if(V_ARRAY(&value)->rgsabound[0].cElements == 6)
6880 ok(!memcmp(bytes, V_ARRAY(&value)->pvData, sizeof(bytes)), "incorrect value\n");
6881 VariantClear(&value);
6882 IXMLDOMNode_Release(node);
6883 }
6884
6885 hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("foo"), _bstr_("value"), &pi);
6886 ok(hr == S_OK, "ret %08x\n", hr );
6887 {
6888 V_VT(&value) = VT_NULL;
6889 V_BSTR(&value) = (void*)0xdeadbeef;
6890 hr = IXMLDOMProcessingInstruction_get_nodeTypedValue(pi, &value);
6891 ok(hr == S_OK, "ret %08x\n", hr );
6892 ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6893 ok(!lstrcmpW(V_BSTR(&value), _bstr_("value")), "got wrong value\n");
6894 IXMLDOMProcessingInstruction_Release(pi);
6895 VariantClear(&value);
6896 }
6897
6898 hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("[1]*2=3; &gee that's not right!"), &cdata);
6899 ok(hr == S_OK, "ret %08x\n", hr );
6900 {
6901 V_VT(&value) = VT_NULL;
6902 V_BSTR(&value) = (void*)0xdeadbeef;
6903 hr = IXMLDOMCDATASection_get_nodeTypedValue(cdata, &value);
6904 ok(hr == S_OK, "ret %08x\n", hr );
6905 ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6906 ok(!lstrcmpW(V_BSTR(&value), _bstr_("[1]*2=3; &gee that's not right!")), "got wrong value\n");
6907 IXMLDOMCDATASection_Release(cdata);
6908 VariantClear(&value);
6909 }
6910
6911 hr = IXMLDOMDocument_createComment(doc, _bstr_("comment"), &comment);
6912 ok(hr == S_OK, "ret %08x\n", hr );
6913 {
6914 V_VT(&value) = VT_NULL;
6915 V_BSTR(&value) = (void*)0xdeadbeef;
6916 hr = IXMLDOMComment_get_nodeTypedValue(comment, &value);
6917 ok(hr == S_OK, "ret %08x\n", hr );
6918 ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6919 ok(!lstrcmpW(V_BSTR(&value), _bstr_("comment")), "got wrong value\n");
6920 IXMLDOMComment_Release(comment);
6921 VariantClear(&value);
6922 }
6923
6924 hr = IXMLDOMDocument_createDocumentFragment(doc, &frag);
6925 ok(hr == S_OK, "ret %08x\n", hr );
6926 {
6927 V_VT(&value) = VT_EMPTY;
6928 hr = IXMLDOMDocumentFragment_get_nodeTypedValue(frag, &value);
6929 ok(hr == S_FALSE, "ret %08x\n", hr );
6930 ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6931 IXMLDOMDocumentFragment_Release(frag);
6932 }
6933
6934 doc2 = create_document(&IID_IXMLDOMDocument);
6935
6936 b = VARIANT_FALSE;
6937 hr = IXMLDOMDocument_loadXML(doc2, _bstr_(szEmailXML), &b);
6938 ok(hr == S_OK, "ret %08x\n", hr );
6939 ok(b == VARIANT_TRUE, "got %d\n", b);
6940
6941 EXPECT_REF(doc2, 1);
6942
6943 hr = IXMLDOMDocument_get_doctype(doc2, &doctype);
6944 ok(hr == S_OK, "ret %08x\n", hr );
6945
6946 EXPECT_REF(doc2, 1);
6947 todo_wine EXPECT_REF(doctype, 2);
6948
6949 {
6950 V_VT(&value) = VT_EMPTY;
6951 hr = IXMLDOMDocumentType_get_nodeTypedValue(doctype, &value);
6952 ok(hr == S_FALSE, "ret %08x\n", hr );
6953 ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6954 }
6955
6956 hr = IXMLDOMDocument_get_doctype(doc2, &doctype2);
6957 ok(hr == S_OK, "ret %08x\n", hr );
6958 ok(doctype != doctype2, "got %p, was %p\n", doctype2, doctype);
6959
6960 IXMLDOMDocumentType_Release(doctype2);
6961 IXMLDOMDocumentType_Release(doctype);
6962
6963 IXMLDOMDocument_Release(doc2);
6964
6965 while (entry->name)
6966 {
6967 hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_(entry->name), &node);
6968 ok(hr == S_OK, "ret %08x\n", hr );
6969
6970 hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6971 ok(hr == S_OK, "ret %08x\n", hr );
6972 ok(V_VT(&value) == entry->type, "incorrect type, expected %d, got %d\n", entry->type, V_VT(&value));
6973
6974 if (entry->type == (VT_ARRAY|VT_UI1))
6975 {
6976 ok(V_ARRAY(&value)->rgsabound[0].cElements == strlen(entry->value),
6977 "incorrect array size %d\n", V_ARRAY(&value)->rgsabound[0].cElements);
6978 }
6979
6980 if (entry->type != VT_BSTR)
6981 {
6982 if (entry->type == VT_DATE ||
6983 entry->type == VT_R8 ||
6984 entry->type == VT_CY)
6985 {
6986 if (entry->type == VT_DATE)
6987 {
6988 hr = VariantChangeType(&value, &value, 0, VT_R4);
6989 ok(hr == S_OK, "ret %08x\n", hr );
6990 }
6991 hr = VariantChangeTypeEx(&value, &value,
6992 MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT),
6993 VARIANT_NOUSEROVERRIDE, VT_BSTR);
6994 ok(hr == S_OK, "ret %08x\n", hr );
6995 }
6996 else
6997 {
6998 hr = VariantChangeType(&value, &value, 0, VT_BSTR);
6999 ok(hr == S_OK, "ret %08x\n", hr );
7000 }
7001
7002 /* for byte array from VT_ARRAY|VT_UI1 it's not a WCHAR buffer */
7003 if (entry->type == (VT_ARRAY|VT_UI1))
7004 {
7005 ok(!memcmp( V_BSTR(&value), entry->value, strlen(entry->value)),
7006 "expected %s\n", entry->value);
7007 }
7008 else
7009 ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
7010 "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
7011 }
7012 else
7013 ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
7014 "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
7015
7016 VariantClear( &value );
7017 IXMLDOMNode_Release(node);
7018
7019 entry++;
7020 }
7021
7022 IXMLDOMDocument_Release(doc);
7023 free_bstrs();
7024}
bytes
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
VT_R8
@ VT_R8
Definition: compat.h:2300
VT_CY
@ VT_CY
Definition: compat.h:2301
VT_DATE
@ VT_DATE
Definition: compat.h:2302
szTypeValueXML
static const CHAR szTypeValueXML[]
Definition: domdoc.c:880
get_nodetypedvalue
static const nodetypedvalue_t get_nodetypedvalue[]
Definition: domdoc.c:6789
SORT_DEFAULT
#define SORT_DEFAULT
MAKELCID
#define MAKELCID(lgid, srtid)
VARIANT_NOUSEROVERRIDE
#define VARIANT_NOUSEROVERRIDE
Definition: oleauto.h:312
MAKELANGID
#define MAKELANGID(p, s)
Definition: nls.h:15
LANG_ENGLISH
#define LANG_ENGLISH
Definition: nls.h:52
SUBLANG_DEFAULT
#define SUBLANG_DEFAULT
Definition: nls.h:168
_nodetypedvalue_t
Definition: domdoc.c:6783
value
Definition: pdh_main.c:96
VariantChangeTypeEx
HRESULT WINAPI VariantChangeTypeEx(VARIANTARG *pvargDest, VARIANTARG *pvargSrc, LCID lcid, USHORT wFlags, VARTYPE vt)
Definition: variant.c:988
VariantChangeType
HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG *pvargDest, VARIANTARG *pvargSrc, USHORT wFlags, VARTYPE vt)
Definition: variant.c:962
pvData
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3749
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Referenced by START_TEST().

◆ test_nodeValue()

static void test_nodeValue ( void  )
static

Definition at line 11710 of file domdoc.c.

11711{
11712 const node_value_t *ptr = nodevalue_test;
11713 IXMLDOMDocument *doc;
11714 HRESULT hr;
11715
11716 doc = create_document(&IID_IXMLDOMDocument);
11717
11718 while (ptr->type != NODE_INVALID)
11719 {
11720 IXMLDOMNode *node;
11721 VARIANT v;
11722
11723 V_VT(&v) = VT_I2;
11724 V_I2(&v) = ptr->type;
11725
11726 hr = IXMLDOMDocument_createNode(doc, v, _bstr_(ptr->name), NULL, &node);
11727 ok(hr == S_OK, "failed to create node type %d\n", ptr->type);
11728
11729 hr = IXMLDOMNode_get_nodeValue(node, NULL);
11730 ok(hr == E_INVALIDARG, "%d: got 0x%08x\n", ptr->type, hr);
11731
11732 V_VT(&v) = VT_BSTR;
11733 V_BSTR(&v) = _bstr_(ptr->put_content);
11734 hr = IXMLDOMNode_put_nodeValue(node, v);
11735 ok(hr == ptr->put_hr, "%d: got 0x%08x\n", ptr->type, hr);
11736
11737 V_VT(&v) = VT_EMPTY;
11738 hr = IXMLDOMNode_get_nodeValue(node, &v);
11739 ok(hr == ptr->get_hr, "%d: got 0x%08x, expected 0x%08x\n", ptr->type, hr, ptr->get_hr);
11740 ok(V_VT(&v) == ptr->get_vt, "%d: got %d, expected %d\n", ptr->type, V_VT(&v), ptr->get_vt);
11741 if (hr == S_OK)
11742 ok(!lstrcmpW(V_BSTR(&v), _bstr_(ptr->put_content)), "%d: got %s\n", ptr->type,
11743 wine_dbgstr_w(V_BSTR(&v)));
11744 VariantClear(&v);
11745
11746 IXMLDOMNode_Release(node);
11747
11748 ptr++;
11749 }
11750
11751 IXMLDOMDocument_Release(doc);
11752}
nodevalue_test
static const node_value_t nodevalue_test[]
Definition: domdoc.c:11698
node_value_t
Definition: domdoc.c:11689

Referenced by START_TEST().

◆ test_normalize_attribute_values()

static void test_normalize_attribute_values ( void  )
static

Definition at line 12830 of file domdoc.c.

12831{
12832 IXMLDOMDocument2 *doc;
12833 VARIANT var;
12834 HRESULT hr;
12835
12836 if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument2))
12837 {
12838 win_skip("NormalizeAttributeValues is not supported.\n");
12839 return;
12840 }
12841
12842 doc = create_document_version(60, &IID_IXMLDOMDocument2);
12843
12844 V_VT(&var) = VT_I2;
12845 V_I2(&var) = 10;
12846 hr = IXMLDOMDocument2_getProperty(doc, _bstr_("NormalizeAttributeValues"), &var);
12847todo_wine {
12848 ok(hr == S_OK, "Failed to get property value, hr %#x.\n", hr);
12849 ok(V_VT(&var) == VT_BOOL, "Unexpected property value type, vt %d.\n", V_VT(&var));
12850 ok(V_BOOL(&var) == VARIANT_FALSE, "Unexpected property value.\n");
12851}
12852 V_VT(&var) = VT_BOOL;
12853 V_BOOL(&var) = VARIANT_TRUE;
12854 hr = IXMLDOMDocument2_setProperty(doc, _bstr_("NormalizeAttributeValues"), var);
12855 ok(hr == S_OK, "Failed to set property, hr %#x.\n", hr);
12856
12857 V_VT(&var) = VT_I2;
12858 V_I2(&var) = 10;
12859 hr = IXMLDOMDocument2_getProperty(doc, _bstr_("NormalizeAttributeValues"), &var);
12860todo_wine {
12861 ok(hr == S_OK, "Failed to get property value, hr %#x.\n", hr);
12862 ok(V_VT(&var) == VT_BOOL, "Unexpected property value type, vt %d.\n", V_VT(&var));
12863 ok(V_BOOL(&var) == VARIANT_TRUE, "Unexpected property value.\n");
12864}
12865 IXMLDOMDocument2_Release(doc);
12866}
VT_BOOL
@ VT_BOOL
Definition: compat.h:2306
V_BOOL
#define V_BOOL(A)
Definition: oleauto.h:224

Referenced by START_TEST().

◆ test_parseerror()

static void test_parseerror ( void  )
static

Definition at line 11383 of file domdoc.c.

11384{
11385 IXMLDOMParseError2 *error2;
11386 IXMLDOMParseError *error;
11387 IXMLDOMDocument *doc;
11388 HRESULT hr;
11389
11390 doc = create_document(&IID_IXMLDOMDocument);
11391
11392 hr = IXMLDOMDocument_get_parseError(doc, &error);
11393 EXPECT_HR(hr, S_OK);
11394
11395 hr = IXMLDOMParseError_get_line(error, NULL);
11396 EXPECT_HR(hr, E_INVALIDARG);
11397
11398 hr = IXMLDOMParseError_get_srcText(error, NULL);
11399 EXPECT_HR(hr, E_INVALIDARG);
11400
11401 hr = IXMLDOMParseError_get_linepos(error, NULL);
11402 EXPECT_HR(hr, E_INVALIDARG);
11403
11404 IXMLDOMParseError_Release(error);
11405 IXMLDOMDocument_Release(doc);
11406
11407 if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument)) return;
11408 doc = create_document_version(60, &IID_IXMLDOMDocument);
11409
11410 hr = IXMLDOMDocument_get_parseError(doc, &error);
11411 EXPECT_HR(hr, S_OK);
11412 hr = IXMLDOMParseError_QueryInterface(error, &IID_IXMLDOMParseError2, (void**)&error2);
11413 EXPECT_HR(hr, S_OK);
11414 IXMLDOMParseError2_Release(error2);
11415 IXMLDOMParseError_Release(error);
11416 IXMLDOMDocument_Release(doc);
11417}
error2
#define error2(s, a, b)
Definition: debug.h:126

Referenced by START_TEST().

◆ test_persiststream()

static void test_persiststream ( void  )
static

Definition at line 2150 of file domdoc.c.

2151{
2152 IPersistStreamInit *streaminit;
2153 IPersistStream *stream;
2154 IXMLDOMDocument *doc;
2155 ULARGE_INTEGER size;
2156 IPersist *persist;
2157 HRESULT hr;
2158 CLSID clsid;
2159
2160 doc = create_document(&IID_IXMLDOMDocument);
2161
2162 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&streaminit);
2163 ok(hr == S_OK, "got 0x%08x\n", hr);
2164
2165 hr = IPersistStreamInit_InitNew(streaminit);
2166 ok(hr == S_OK, "got 0x%08x\n", hr);
2167
2168 hr = IPersistStreamInit_GetSizeMax(streaminit, &size);
2169 ok(hr == E_NOTIMPL, "got 0x%08x\n", hr);
2170
2171 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStream, (void **)&stream);
2172 ok(hr == S_OK, "got 0x%08x\n", hr);
2173 ok((IUnknown *)stream == (IUnknown *)streaminit, "got %p, %p\n", stream, streaminit);
2174
2175 hr = IPersistStream_QueryInterface(stream, &IID_IPersist, (void **)&persist);
2176 ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);
2177
2178 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersist, (void **)&persist);
2179 ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);
2180
2181 hr = IPersistStreamInit_GetClassID(streaminit, NULL);
2182 ok(hr == E_POINTER, "got 0x%08x\n", hr);
2183
2184 memset(&clsid, 0, sizeof(clsid));
2185 hr = IPersistStreamInit_GetClassID(streaminit, &clsid);
2186 ok(hr == S_OK, "got 0x%08x\n", hr);
2187 ok(IsEqualGUID(&clsid, &CLSID_DOMDocument2), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
2188
2189 IPersistStream_Release(stream);
2190 IPersistStreamInit_Release(streaminit);
2191 IXMLDOMDocument_Release(doc);
2192}
size
GLsizeiptr size
Definition: glext.h:5919
IID_IPersistStreamInit
const GUID IID_IPersistStreamInit
IID_IPersist
const GUID IID_IPersist
Definition: proxy.cpp:14
IID_IPersistStream
const GUID IID_IPersistStream
Definition: proxy.cpp:13
memset
#define memset(x, y, z)
Definition: compat.h:39
_IID
Definition: mstsclib_i.c:51
_ULARGE_INTEGER
Definition: ms-dtyp.idl:184
stream
Definition: parse.h:23

Referenced by START_TEST().

◆ test_preserve_charref()

static void test_preserve_charref ( IXMLDOMDocument2 *  doc,
VARIANT_BOOL  preserve 
)
static

Definition at line 4594 of file domdoc.c.

4595{
4596 static const WCHAR b1_p[] = {' ','T','e','x','t',' ','A',' ','e','n','d',' ',0};
4597 static const WCHAR b1_i[] = {'T','e','x','t',' ','A',' ','e','n','d',0};
4598 static const WCHAR b2_p[] = {'A','B',' ','C',' ',0};
4599 static const WCHAR b2_i[] = {'A','B',' ','C',0};
4600 IXMLDOMNodeList *list;
4601 IXMLDOMElement *root;
4602 IXMLDOMNode *node;
4603 const WCHAR *text;
4604 VARIANT_BOOL b;
4605 HRESULT hr;
4606 BSTR s;
4607
4608 hr = IXMLDOMDocument2_put_preserveWhiteSpace(doc, preserve);
4609 ok(hr == S_OK, "got 0x%08x\n", hr);
4610
4611 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(charrefsxml), &b);
4612 ok(hr == S_OK, "got 0x%08x\n", hr);
4613
4614 hr = IXMLDOMDocument2_get_documentElement(doc, &root);
4615 ok(hr == S_OK, "got 0x%08x\n", hr);
4616
4617 hr = IXMLDOMElement_get_childNodes(root, &list);
4618 ok(hr == S_OK, "got 0x%08x\n", hr);
4619 IXMLDOMElement_Release(root);
4620
4621 text = preserve == VARIANT_TRUE ? b1_p : b1_i;
4622 hr = IXMLDOMNodeList_get_item(list, 0, &node);
4623 ok(hr == S_OK, "got 0x%08x\n", hr);
4624 hr = IXMLDOMNode_get_text(node, &s);
4625 ok(hr == S_OK, "got 0x%08x\n", hr);
4626 ok(!lstrcmpW(s, text), "0x%x, got %s\n", preserve, wine_dbgstr_w(s));
4627 SysFreeString(s);
4628 IXMLDOMNode_Release(node);
4629
4630 text = preserve == VARIANT_TRUE ? b2_p : b2_i;
4631 hr = IXMLDOMNodeList_get_item(list, 1, &node);
4632 ok(hr == S_OK, "got 0x%08x\n", hr);
4633 hr = IXMLDOMNode_get_text(node, &s);
4634 ok(hr == S_OK, "got 0x%08x\n", hr);
4635 ok(!lstrcmpW(s, text), "0x%x, got %s\n", preserve, wine_dbgstr_w(s));
4636 SysFreeString(s);
4637 IXMLDOMNode_Release(node);
4638
4639 IXMLDOMNodeList_Release(list);
4640}
preserve
GLuint GLsizei const GLvoid GLenum preserve
Definition: glext.h:9550
charrefsxml
static const char charrefsxml[]
Definition: domdoc.c:821

Referenced by test_whitespace().

◆ test_put_data()

static void test_put_data ( void  )
static

Definition at line 12078 of file domdoc.c.

12079{
12080 static const WCHAR test_data[] = {'t','e','s','t',' ','n','o','d','e',' ','d','a','t','a',0};
12081 WCHAR buff[100], *data;
12082 IXMLDOMDocument *doc;
12083 const DOMNodeType *type;
12084 IXMLDOMText *text;
12085 IXMLDOMNode *node;
12086 VARIANT v;
12087 BSTR get_data;
12088 HRESULT hr;
12089
12090 doc = create_document(&IID_IXMLDOMDocument);
12091
12092 memcpy(&buff[2], test_data, sizeof(test_data));
12093 /* just a big length */
12094 *(DWORD*)buff = 0xf0f0;
12095 data = &buff[2];
12096
12097 type = put_data_types;
12098 while (*type != NODE_INVALID)
12099 {
12100 V_VT(&v) = VT_I2;
12101 V_I2(&v) = *type;
12102
12103 hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
12104 EXPECT_HR(hr, S_OK);
12105
12106 /* put_data() is interface-specific */
12107 switch (*type)
12108 {
12109 case NODE_TEXT:
12110 {
12111 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
12112 EXPECT_HR(hr, S_OK);
12113 hr = IXMLDOMText_put_data(text, data);
12114 EXPECT_HR(hr, S_OK);
12115
12116 hr = IXMLDOMText_get_data(text, &get_data);
12117 EXPECT_HR(hr, S_OK);
12118
12119 IXMLDOMText_Release(text);
12120 break;
12121 }
12122 case NODE_CDATA_SECTION:
12123 {
12124 IXMLDOMCDATASection *cdata;
12125
12126 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
12127 EXPECT_HR(hr, S_OK);
12128 hr = IXMLDOMCDATASection_put_data(cdata, data);
12129 EXPECT_HR(hr, S_OK);
12130
12131 hr = IXMLDOMCDATASection_get_data(cdata, &get_data);
12132 EXPECT_HR(hr, S_OK);
12133
12134 IXMLDOMCDATASection_Release(cdata);
12135 break;
12136 }
12137 case NODE_PROCESSING_INSTRUCTION:
12138 {
12139 IXMLDOMProcessingInstruction *pi;
12140
12141 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)&pi);
12142 EXPECT_HR(hr, S_OK);
12143 hr = IXMLDOMProcessingInstruction_put_data(pi, data);
12144 EXPECT_HR(hr, S_OK);
12145
12146 hr = IXMLDOMProcessingInstruction_get_data(pi, &get_data);
12147 EXPECT_HR(hr, S_OK);
12148
12149 IXMLDOMProcessingInstruction_Release(pi);
12150 break;
12151 }
12152 case NODE_COMMENT:
12153 {
12154 IXMLDOMComment *comment;
12155
12156 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
12157 EXPECT_HR(hr, S_OK);
12158 hr = IXMLDOMComment_put_data(comment, data);
12159 EXPECT_HR(hr, S_OK);
12160
12161 hr = IXMLDOMComment_get_data(comment, &get_data);
12162 EXPECT_HR(hr, S_OK);
12163
12164 IXMLDOMComment_Release(comment);
12165 break;
12166 }
12167 default:
12168 get_data = NULL;
12169 break;
12170 }
12171
12172 /* compare */
12173 ok(!lstrcmpW(data, get_data), "%d: got wrong data %s, expected %s\n", *type, wine_dbgstr_w(get_data),
12174 wine_dbgstr_w(data));
12175 SysFreeString(get_data);
12176
12177 IXMLDOMNode_Release(node);
12178 type++;
12179 }
12180
12181 IXMLDOMDocument_Release(doc);
12182 free_bstrs();
12183}
put_data_types
static const DOMNodeType put_data_types[]
Definition: domdoc.c:12070
test_data
Definition: RtlDosApplyFileIsolationRedirection_Ustr.c:15

Referenced by START_TEST().

◆ test_put_dataType()

static void test_put_dataType ( void  )
static

Definition at line 6311 of file domdoc.c.

6312{
6313 const put_datatype_notype_t *ptr2 = put_dt_notype;
6314 const put_datatype_t *ptr = put_datatype_data;
6315 IXMLDOMElement *root, *element;
6316 BSTR nameW, type1W, type2W;
6317 IXMLDOMDocument *doc;
6318 HRESULT hr;
6319
6320 doc = create_document(&IID_IXMLDOMDocument);
6321
6322 hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), NULL);
6323 EXPECT_HR(hr, E_INVALIDARG);
6324
6325 hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
6326 EXPECT_HR(hr, S_OK);
6327
6328 hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
6329 EXPECT_HR(hr, S_OK);
6330
6331 hr = IXMLDOMElement_put_dataType(root, NULL);
6332 EXPECT_HR(hr, E_INVALIDARG);
6333
6334 while (ptr->name)
6335 {
6336 hr = IXMLDOMDocument_createElement(doc, _bstr_(ptr->name), &element);
6337 EXPECT_HR(hr, S_OK);
6338 if(hr == S_OK)
6339 {
6340 hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
6341 EXPECT_HR(hr, S_OK);
6342
6343 hr = IXMLDOMElement_put_dataType(element, _bstr_(ptr->type));
6344 ok(hr == ptr->hr, "failed for %s:%s, 0x%08x\n", ptr->name, ptr->type, ptr->hr);
6345
6346 IXMLDOMElement_Release(element);
6347 }
6348 ptr++;
6349 }
6350
6351 /* check changing types */
6352 hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &element);
6353 EXPECT_HR(hr, S_OK);
6354
6355 hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
6356 EXPECT_HR(hr, S_OK);
6357
6358 hr = IXMLDOMElement_put_dataType(element, _bstr_("DateTime.tz"));
6359 EXPECT_HR(hr, S_OK);
6360
6361 hr = IXMLDOMElement_put_dataType(element, _bstr_("string"));
6362 EXPECT_HR(hr, S_OK);
6363
6364 IXMLDOMElement_Release(element);
6365
6366 /* try to set type for node without a type */
6367 nameW = _bstr_("testname");
6368 type1W = _bstr_("string");
6369 type2W = _bstr_("number");
6370 while (ptr2->type != NODE_INVALID)
6371 {
6372 IXMLDOMNode *node;
6373 VARIANT type;
6374
6375 V_VT(&type) = VT_I2;
6376 V_I2(&type) = ptr2->type;
6377
6378 hr = IXMLDOMDocument_createNode(doc, type, nameW, NULL, &node);
6379 EXPECT_HR(hr, S_OK);
6380 if(hr == S_OK)
6381 {
6382 hr = IXMLDOMElement_appendChild(root, node, NULL);
6383 EXPECT_HR(hr, S_OK);
6384
6385 hr = IXMLDOMNode_put_dataType(node, NULL);
6386 EXPECT_HR(hr, E_INVALIDARG);
6387
6388 hr = IXMLDOMNode_put_dataType(node, type1W);
6389 ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
6390 hr = IXMLDOMNode_put_dataType(node, type2W);
6391 ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
6392
6393 IXMLDOMNode_Release(node);
6394 }
6395 ptr2++;
6396 }
6397
6398 IXMLDOMElement_Release(root);
6399 IXMLDOMDocument_Release(doc);
6400 free_bstrs();
6401}
nameW
static const WCHAR nameW[]
Definition: main.c:49
put_datatype_data
static put_datatype_t put_datatype_data[]
Definition: domdoc.c:6270
put_dt_notype
static put_datatype_notype_t put_dt_notype[]
Definition: domdoc.c:6302
put_datatype_notype_t
Definition: domdoc.c:6297
put_datatype_notype_t::type
DOMNodeType type
Definition: domdoc.c:6298
put_datatype_notype_t::hr
HRESULT hr
Definition: domdoc.c:6299
put_datatype_t
Definition: domdoc.c:6262

Referenced by START_TEST().

◆ test_put_nodeTypedValue()

static void test_put_nodeTypedValue ( void  )
static

Definition at line 8535 of file domdoc.c.

8536{
8537 static const BYTE binhexdata[16] =
8538 {0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf};
8539 IXMLDOMDocument *doc;
8540 IXMLDOMElement *elem;
8541 VARIANT type, value;
8542 LONG ubound, lbound;
8543 IXMLDOMNode *node;
8544 SAFEARRAY *array;
8545 HRESULT hr;
8546 BYTE *ptr;
8547 BSTR str;
8548
8549 doc = create_document(&IID_IXMLDOMDocument);
8550
8551 hr = IXMLDOMDocument_createElement(doc, _bstr_("Element"), &elem);
8552 EXPECT_HR(hr, S_OK);
8553
8554 V_VT(&type) = VT_EMPTY;
8555 hr = IXMLDOMElement_get_dataType(elem, &type);
8556 EXPECT_HR(hr, S_FALSE);
8557 ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8558
8559 /* set typed value for untyped node */
8560 V_VT(&type) = VT_I1;
8561 V_I1(&type) = 1;
8562 hr = IXMLDOMElement_put_nodeTypedValue(elem, type);
8563 EXPECT_HR(hr, S_OK);
8564
8565 V_VT(&type) = VT_EMPTY;
8566 hr = IXMLDOMElement_get_dataType(elem, &type);
8567 EXPECT_HR(hr, S_FALSE);
8568 ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8569
8570 /* no type info stored */
8571 V_VT(&type) = VT_EMPTY;
8572 hr = IXMLDOMElement_get_nodeTypedValue(elem, &type);
8573 EXPECT_HR(hr, S_OK);
8574 ok(V_VT(&type) == VT_BSTR, "got %d, expected VT_BSTR\n", V_VT(&type));
8575 ok(memcmp(V_BSTR(&type), _bstr_("1"), 2*sizeof(WCHAR)) == 0,
8576 "got %s, expected \"1\"\n", wine_dbgstr_w(V_BSTR(&type)));
8577 VariantClear(&type);
8578
8579 hr = IXMLDOMElement_get_firstChild(elem, &node);
8580 EXPECT_HR(hr, S_OK);
8581 hr = IXMLDOMElement_removeChild(elem, node, NULL);
8582 EXPECT_HR(hr, S_OK);
8583 IXMLDOMNode_Release(node);
8584
8585 hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)elem, NULL);
8586 EXPECT_HR(hr, S_OK);
8587
8588 /* bin.base64 */
8589 hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.base64"));
8590 EXPECT_HR(hr, S_OK);
8591
8592 V_VT(&value) = VT_BSTR;
8593 V_BSTR(&value) = _bstr_("ABCD");
8594 hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8595 EXPECT_HR(hr, S_OK);
8596
8597 V_VT(&value) = VT_EMPTY;
8598 hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8599 EXPECT_HR(hr, S_OK);
8600 ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8601 ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8602 ubound = 0;
8603 hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8604 EXPECT_HR(hr, S_OK);
8605 ok(ubound == 2, "got %d\n", ubound);
8606 lbound = 0;
8607 hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8608 EXPECT_HR(hr, S_OK);
8609 ok(lbound == 0, "got %d\n", lbound);
8610 hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8611 EXPECT_HR(hr, S_OK);
8612 ok(ptr[0] == 0, "got %x\n", ptr[0]);
8613 ok(ptr[1] == 0x10, "got %x\n", ptr[1]);
8614 ok(ptr[2] == 0x83, "got %x\n", ptr[2]);
8615 SafeArrayUnaccessData(V_ARRAY(&value));
8616 VariantClear(&value);
8617
8618 /* when set as VT_BSTR it's stored as is */
8619 hr = IXMLDOMElement_get_firstChild(elem, &node);
8620 EXPECT_HR(hr, S_OK);
8621 hr = IXMLDOMNode_get_text(node, &str);
8622 EXPECT_HR(hr, S_OK);
8623 ok(!lstrcmpW(str, _bstr_("ABCD")), "%s\n", wine_dbgstr_w(str));
8624 IXMLDOMNode_Release(node);
8625 SysFreeString(str);
8626
8627 array = SafeArrayCreateVector(VT_UI1, 0, 7);
8628 hr = SafeArrayAccessData(array, (void*)&ptr);
8629 EXPECT_HR(hr, S_OK);
8630 memcpy(ptr, "dGVzdA=", strlen("dGVzdA="));
8631 SafeArrayUnaccessData(array);
8632
8633 V_VT(&value) = VT_UI1|VT_ARRAY;
8634 V_ARRAY(&value) = array;
8635 hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8636 EXPECT_HR(hr, S_OK);
8637
8638 V_VT(&value) = VT_EMPTY;
8639 hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8640 EXPECT_HR(hr, S_OK);
8641 ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8642 ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8643 ubound = 0;
8644 hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8645 EXPECT_HR(hr, S_OK);
8646 ok(ubound == 6, "got %d\n", ubound);
8647 lbound = 0;
8648 hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8649 EXPECT_HR(hr, S_OK);
8650 ok(lbound == 0, "got %d\n", lbound);
8651 hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8652 EXPECT_HR(hr, S_OK);
8653 ok(!memcmp(ptr, "dGVzdA=", strlen("dGVzdA=")), "got wrong data, %s\n", ptr);
8654 SafeArrayUnaccessData(V_ARRAY(&value));
8655 VariantClear(&value);
8656
8657 /* if set with VT_UI1|VT_ARRAY it's encoded */
8658 hr = IXMLDOMElement_get_firstChild(elem, &node);
8659 EXPECT_HR(hr, S_OK);
8660 hr = IXMLDOMNode_get_text(node, &str);
8661 EXPECT_HR(hr, S_OK);
8662 ok(!lstrcmpW(str, _bstr_("ZEdWemRBPQ==")), "%s\n", wine_dbgstr_w(str));
8663 IXMLDOMNode_Release(node);
8664 SafeArrayDestroyData(array);
8665 SysFreeString(str);
8666
8667 /* bin.hex */
8668 V_VT(&value) = VT_BSTR;
8669 V_BSTR(&value) = _bstr_("");
8670 hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8671 EXPECT_HR(hr, S_OK);
8672
8673 hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.hex"));
8674 EXPECT_HR(hr, S_OK);
8675
8676 array = SafeArrayCreateVector(VT_UI1, 0, 16);
8677 hr = SafeArrayAccessData(array, (void*)&ptr);
8678 EXPECT_HR(hr, S_OK);
8679 memcpy(ptr, binhexdata, sizeof(binhexdata));
8680 SafeArrayUnaccessData(array);
8681
8682 V_VT(&value) = VT_UI1|VT_ARRAY;
8683 V_ARRAY(&value) = array;
8684 hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8685 EXPECT_HR(hr, S_OK);
8686
8687 V_VT(&value) = VT_EMPTY;
8688 hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8689 EXPECT_HR(hr, S_OK);
8690 ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8691 ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8692 ubound = 0;
8693 hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8694 EXPECT_HR(hr, S_OK);
8695 ok(ubound == 15, "got %d\n", ubound);
8696 lbound = 0;
8697 hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8698 EXPECT_HR(hr, S_OK);
8699 ok(lbound == 0, "got %d\n", lbound);
8700 hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8701 EXPECT_HR(hr, S_OK);
8702 ok(!memcmp(ptr, binhexdata, sizeof(binhexdata)), "got wrong data\n");
8703 SafeArrayUnaccessData(V_ARRAY(&value));
8704 VariantClear(&value);
8705
8706 /* if set with VT_UI1|VT_ARRAY it's encoded */
8707 hr = IXMLDOMElement_get_firstChild(elem, &node);
8708 EXPECT_HR(hr, S_OK);
8709 hr = IXMLDOMNode_get_text(node, &str);
8710 EXPECT_HR(hr, S_OK);
8711 ok(!lstrcmpW(str, _bstr_("000102030405060708090a0b0c0d0e0f")), "%s\n", wine_dbgstr_w(str));
8712 IXMLDOMNode_Release(node);
8713 SafeArrayDestroyData(array);
8714 SysFreeString(str);
8715
8716 IXMLDOMElement_Release(elem);
8717 IXMLDOMDocument_Release(doc);
8718 free_bstrs();
8719}
SafeArrayUnaccessData
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
Definition: safearray.c:1168
SafeArrayDestroyData
HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY *psa)
Definition: safearray.c:1256

Referenced by START_TEST().

◆ test_put_nodeValue()

static void test_put_nodeValue ( void  )
static

Definition at line 7110 of file domdoc.c.

7111{
7112 static const WCHAR jeevesW[] = {'J','e','e','v','e','s',' ','&',' ','W','o','o','s','t','e','r',0};
7113 IXMLDOMDocument *doc;
7114 IXMLDOMText *text;
7115 IXMLDOMEntityReference *entityref;
7116 IXMLDOMAttribute *attr;
7117 IXMLDOMNode *node;
7118 HRESULT hr;
7119 VARIANT data, type;
7120
7121 doc = create_document(&IID_IXMLDOMDocument);
7122
7123 /* test for unsupported types */
7124 /* NODE_DOCUMENT */
7125 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&node);
7126 ok(hr == S_OK, "ret %08x\n", hr );
7127 V_VT(&data) = VT_BSTR;
7128 V_BSTR(&data) = _bstr_("one two three");
7129 hr = IXMLDOMNode_put_nodeValue(node, data);
7130 ok(hr == E_FAIL, "ret %08x\n", hr );
7131 IXMLDOMNode_Release(node);
7132
7133 /* NODE_DOCUMENT_FRAGMENT */
7134 V_VT(&type) = VT_I1;
7135 V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
7136 hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
7137 ok(hr == S_OK, "ret %08x\n", hr );
7138 V_VT(&data) = VT_BSTR;
7139 V_BSTR(&data) = _bstr_("one two three");
7140 hr = IXMLDOMNode_put_nodeValue(node, data);
7141 ok(hr == E_FAIL, "ret %08x\n", hr );
7142 IXMLDOMNode_Release(node);
7143
7144 /* NODE_ELEMENT */
7145 V_VT(&type) = VT_I1;
7146 V_I1(&type) = NODE_ELEMENT;
7147 hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
7148 ok(hr == S_OK, "ret %08x\n", hr );
7149 V_VT(&data) = VT_BSTR;
7150 V_BSTR(&data) = _bstr_("one two three");
7151 hr = IXMLDOMNode_put_nodeValue(node, data);
7152 ok(hr == E_FAIL, "ret %08x\n", hr );
7153 IXMLDOMNode_Release(node);
7154
7155 /* NODE_ENTITY_REFERENCE */
7156 hr = IXMLDOMDocument_createEntityReference(doc, _bstr_("ref"), &entityref);
7157 ok(hr == S_OK, "ret %08x\n", hr );
7158
7159 V_VT(&data) = VT_BSTR;
7160 V_BSTR(&data) = _bstr_("one two three");
7161 hr = IXMLDOMEntityReference_put_nodeValue(entityref, data);
7162 ok(hr == E_FAIL, "ret %08x\n", hr );
7163
7164 hr = IXMLDOMEntityReference_QueryInterface(entityref, &IID_IXMLDOMNode, (void**)&node);
7165 ok(hr == S_OK, "ret %08x\n", hr );
7166 V_VT(&data) = VT_BSTR;
7167 V_BSTR(&data) = _bstr_("one two three");
7168 hr = IXMLDOMNode_put_nodeValue(node, data);
7169 ok(hr == E_FAIL, "ret %08x\n", hr );
7170 IXMLDOMNode_Release(node);
7171 IXMLDOMEntityReference_Release(entityref);
7172
7173 /* supported types */
7174 hr = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &text);
7175 ok(hr == S_OK, "ret %08x\n", hr );
7176 V_VT(&data) = VT_BSTR;
7177 V_BSTR(&data) = _bstr_("Jeeves & Wooster");
7178 hr = IXMLDOMText_put_nodeValue(text, data);
7179 ok(hr == S_OK, "ret %08x\n", hr );
7180 IXMLDOMText_Release(text);
7181
7182 hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
7183 ok(hr == S_OK, "ret %08x\n", hr );
7184 V_VT(&data) = VT_BSTR;
7185 V_BSTR(&data) = _bstr_("Jeeves & Wooster");
7186 hr = IXMLDOMAttribute_put_nodeValue(attr, data);
7187 ok(hr == S_OK, "ret %08x\n", hr );
7188 hr = IXMLDOMAttribute_get_nodeValue(attr, &data);
7189 ok(hr == S_OK, "ret %08x\n", hr );
7190 ok(memcmp(V_BSTR(&data), jeevesW, sizeof(jeevesW)) == 0, "got %s\n",
7191 wine_dbgstr_w(V_BSTR(&data)));
7192 VariantClear(&data);
7193 IXMLDOMAttribute_Release(attr);
7194
7195 free_bstrs();
7196
7197 IXMLDOMDocument_Release(doc);
7198}
NODE_DOCUMENT_FRAGMENT
@ NODE_DOCUMENT_FRAGMENT
Definition: xmldom.idl:63

Referenced by START_TEST().

◆ test_putref_schemas()

static void test_putref_schemas ( void  )
static

Definition at line 12325 of file domdoc.c.

12326{
12327 IXMLDOMSchemaCollection *cache;
12328 IXMLDOMDocument2 *doc;
12329 VARIANT schema;
12330 HRESULT hr;
12331
12332 if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
12333 if (!is_clsid_supported(&CLSID_XMLSchemaCache, &IID_IXMLDOMSchemaCollection)) return;
12334
12335 doc = create_document(&IID_IXMLDOMDocument2);
12336 cache = create_cache(&IID_IXMLDOMSchemaCollection);
12337
12338 /* set to NULL iface when no schema is set */
12339 V_VT(&schema) = VT_DISPATCH;
12340 V_DISPATCH(&schema) = NULL;
12341 hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12342 EXPECT_HR(hr, S_OK);
12343
12344 V_VT(&schema) = VT_UNKNOWN;
12345 V_UNKNOWN(&schema) = NULL;
12346 hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12347 EXPECT_HR(hr, S_OK);
12348
12349 /* set as VT_DISPATCH, reset with it */
12350 V_VT(&schema) = VT_DISPATCH;
12351 V_DISPATCH(&schema) = (IDispatch*)cache;
12352 hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12353 EXPECT_HR(hr, S_OK);
12354
12355 V_DISPATCH(&schema) = NULL;
12356 hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12357 EXPECT_HR(hr, S_OK);
12358 ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
12359
12360 V_VT(&schema) = VT_DISPATCH;
12361 V_DISPATCH(&schema) = NULL;
12362 hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12363 EXPECT_HR(hr, S_OK);
12364
12365 V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
12366 V_VT(&schema) = VT_I2;
12367 hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12368 EXPECT_HR(hr, S_FALSE);
12369 ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
12370 ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
12371
12372 /* set as VT_UNKNOWN, reset with it */
12373 V_VT(&schema) = VT_UNKNOWN;
12374 V_UNKNOWN(&schema) = (IUnknown*)cache;
12375 hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12376 EXPECT_HR(hr, S_OK);
12377
12378 V_DISPATCH(&schema) = NULL;
12379 hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12380 EXPECT_HR(hr, S_OK);
12381 ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
12382
12383 V_VT(&schema) = VT_UNKNOWN;
12384 V_UNKNOWN(&schema) = NULL;
12385 hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12386 EXPECT_HR(hr, S_OK);
12387
12388 V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
12389 V_VT(&schema) = VT_I2;
12390 hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12391 EXPECT_HR(hr, S_FALSE);
12392 ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
12393 ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
12394
12395 IXMLDOMSchemaCollection_Release(cache);
12396 IXMLDOMDocument2_Release(doc);
12397}
schema
const WCHAR * schema
Definition: metadataquery.c:994

Referenced by START_TEST().

◆ test_refs()

static void test_refs ( void  )
static

Definition at line 2594 of file domdoc.c.

2595{
2596 IXMLDOMImplementation *impl, *impl2;
2597 IXMLDOMElement *element, *elem2;
2598 IXMLDOMNodeList *node_list = NULL;
2599 IXMLDOMNode *node, *node2, *node3;
2600 const refcount_test_t *ptr;
2601 IXMLDOMDocument *doc;
2602 IUnknown *unk, *unk2;
2603 VARIANT_BOOL b;
2604 HRESULT hr;
2605 LONG ref;
2606
2607 doc = create_document(&IID_IXMLDOMDocument);
2608
2609 ptr = refcount_test;
2610 while (ptr->type != NODE_INVALID)
2611 {
2612 IUnknown *node_typed, *node_typed2;
2613 IDispatchEx *dispex, *dispex2;
2614 IDispatch *disp, *disp2;
2615 VARIANT type;
2616
2617 V_VT(&type) = VT_I1;
2618 V_I1(&type) = ptr->type;
2619
2620 EXPECT_REF(doc, 1);
2621 hr = IXMLDOMDocument_createNode(doc, type, _bstr_("name"), NULL, &node);
2622 EXPECT_HR(hr, S_OK);
2623 EXPECT_REF(doc, 1);
2624 EXPECT_REF(node, 1);
2625
2626 /* try IDispatch and IUnknown from IXMLDOMNode */
2627 hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
2628 EXPECT_HR(hr, S_OK);
2629 EXPECT_REF(unk, 2);
2630todo_wine {
2631 EXPECT_REF(node, 1);
2632 ok(unk != (IUnknown*)node, "%d: got %p and %p\n", ptr->type, unk, node);
2633}
2634 EXPECT_REF(unk, 2);
2635 hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
2636 EXPECT_HR(hr, S_OK);
2637 todo_wine ok(unk != (IUnknown*)disp, "%d: got %p and %p\n", ptr->type, unk, disp);
2638 EXPECT_REF(unk, 3);
2639 todo_wine EXPECT_REF(disp, 1);
2640
2641 EXPECT_REF(unk, 3);
2642 hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp2);
2643 EXPECT_HR(hr, S_OK);
2644 todo_wine ok(disp != disp2, "%d: got %p and %p\n", ptr->type, disp, disp2);
2645 EXPECT_REF(unk, 4);
2646 todo_wine EXPECT_REF(disp2, 1);
2647
2648 IDispatch_Release(disp);
2649 IDispatch_Release(disp2);
2650
2651 /* get IXMLDOMNode from this IUnknown */
2652 EXPECT_REF(unk, 2);
2653 hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node2);
2654 EXPECT_HR(hr, S_OK);
2655 todo_wine ok(unk != (IUnknown*)node2, "%d: got %p and %p\n", ptr->type, unk, node2);
2656 EXPECT_REF(unk, 3);
2657 todo_wine EXPECT_REF(node2, 1);
2658
2659 EXPECT_REF(unk, 3);
2660 hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node3);
2661 EXPECT_HR(hr, S_OK);
2662 todo_wine ok(node2 != node3, "%d: got %p and %p\n", ptr->type, node2, node3);
2663 EXPECT_REF(unk, 4);
2664 todo_wine EXPECT_REF(node3, 1);
2665
2666 IXMLDOMNode_Release(node2);
2667 IXMLDOMNode_Release(node3);
2668
2669 /* try IDispatchEx from IUnknown */
2670 EXPECT_REF(unk, 2);
2671 hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
2672 EXPECT_HR(hr, S_OK);
2673 ok(unk != (IUnknown*)dispex, "%d: got %p and %p\n", ptr->type, unk, dispex);
2674 EXPECT_REF(unk, 3);
2675 todo_wine EXPECT_REF(dispex, 1);
2676
2677 EXPECT_REF(unk, 3);
2678 hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex2);
2679 EXPECT_HR(hr, S_OK);
2680 todo_wine ok(dispex != dispex2, "%d: got %p and %p\n", ptr->type, dispex, dispex2);
2681 EXPECT_REF(unk, 4);
2682 todo_wine EXPECT_REF(dispex2, 1);
2683
2684 IDispatchEx_Release(dispex);
2685 IDispatchEx_Release(dispex2);
2686
2687 /* try corresponding IXMLDOM* */
2688 EXPECT_REF(unk, 2);
2689 hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed);
2690 EXPECT_HR(hr, S_OK);
2691 EXPECT_REF(unk, 3);
2692 hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed2);
2693 EXPECT_HR(hr, S_OK);
2694 EXPECT_REF(unk, 4);
2695 todo_wine ok(node_typed != node_typed2, "%d: got %p and %p\n", ptr->type, node_typed, node_typed2);
2696 IUnknown_Release(node_typed);
2697 IUnknown_Release(node_typed2);
2698
2699 /* try invalid IXMLDOM* */
2700 hr = IUnknown_QueryInterface(unk, (ptr+1)->iid, (void**)&node_typed);
2701 EXPECT_HR(hr, E_NOINTERFACE);
2702
2703 IUnknown_Release(unk);
2704
2705 EXPECT_REF(node, 1);
2706 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMNode, (void**)&node2);
2707 EXPECT_HR(hr, S_OK);
2708 EXPECT_REF(node, 2);
2709 ok(node == node2, "%d: got %p and %p\n", ptr->type, node, node2);
2710
2711 EXPECT_REF(node, 2);
2712 hr = IXMLDOMNode_QueryInterface(node, ptr->iid, (void**)&node_typed);
2713 EXPECT_HR(hr, S_OK);
2714 EXPECT_REF(node, 3);
2715todo_wine {
2716 EXPECT_REF(node_typed, 2);
2717 ok((IUnknown*)node != node_typed, "%d: got %p and %p\n", ptr->type, node, node_typed);
2718}
2719 IUnknown_Release(node_typed);
2720
2721 IXMLDOMNode_Release(node2);
2722 IXMLDOMNode_Release(node);
2723
2724 ptr++;
2725 }
2726
2727 EXPECT_REF(doc, 1);
2728 ref = IXMLDOMDocument_Release(doc);
2729 ok( ref == 0, "ref %d\n", ref);
2730
2731 /* check IUnknown after releasing DOM iface */
2732 doc = create_document(&IID_IXMLDOMDocument);
2733 EXPECT_REF(doc, 1);
2734 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2735 EXPECT_HR(hr, S_OK);
2736todo_wine {
2737 EXPECT_REF(unk, 3);
2738 EXPECT_REF(doc, 1);
2739}
2740 IXMLDOMDocument_Release(doc);
2741 EXPECT_REF(unk, 1);
2742 IUnknown_Release(unk);
2743
2744 doc = create_document(&IID_IXMLDOMDocument);
2745
2746 EXPECT_REF(doc, 1);
2747 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2748 EXPECT_HR(hr, S_OK);
2749todo_wine {
2750 EXPECT_REF(unk, 3);
2751 EXPECT_REF(doc, 1);
2752}
2753 IUnknown_Release(unk);
2754
2755 /* IXMLDOMImplementation */
2756 EXPECT_REF(doc, 1);
2757 hr = IXMLDOMDocument_get_implementation(doc, &impl);
2758 EXPECT_HR(hr, S_OK);
2759 EXPECT_REF(doc, 1);
2760 EXPECT_REF(impl, 1);
2761 hr = IXMLDOMDocument_get_implementation(doc, &impl2);
2762 EXPECT_HR(hr, S_OK);
2763 EXPECT_REF(doc, 1);
2764 EXPECT_REF(impl2, 1);
2765 ok(impl != impl2, "got %p, %p\n", impl, impl2);
2766 IXMLDOMImplementation_Release(impl);
2767 IXMLDOMImplementation_Release(impl2);
2768
2769 hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2770 EXPECT_HR(hr, S_OK);
2771 ok( b == VARIANT_TRUE, "failed to load XML string\n");
2772
2773 EXPECT_REF(doc, 1);
2774 IXMLDOMDocument_AddRef( doc );
2775 EXPECT_REF(doc, 2);
2776 IXMLDOMDocument_AddRef( doc );
2777 EXPECT_REF(doc, 3);
2778
2779 IXMLDOMDocument_Release( doc );
2780 IXMLDOMDocument_Release( doc );
2781
2782 EXPECT_REF(doc, 1);
2783 hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2784 EXPECT_HR(hr, S_OK);
2785todo_wine {
2786 EXPECT_REF(unk, 3);
2787 EXPECT_REF(doc, 1);
2788}
2789 hr = IXMLDOMDocument_get_documentElement(doc, &element);
2790 EXPECT_HR(hr, S_OK);
2791todo_wine {
2792 EXPECT_REF(doc, 1);
2793 EXPECT_REF(element, 2);
2794}
2795 hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
2796 EXPECT_HR(hr, S_OK);
2797
2798todo_wine {
2799 EXPECT_REF(doc, 1);
2800 EXPECT_REF(element, 2);
2801 EXPECT_REF(elem2, 2);
2802}
2803 IXMLDOMElement_AddRef(element);
2804 todo_wine EXPECT_REF(element, 3);
2805 IXMLDOMElement_Release(element);
2806
2807 /* get IUnknown from a node doesn't touch node instance refcount */
2808 hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
2809 EXPECT_HR(hr, S_OK);
2810 EXPECT_REF(element, 2);
2811todo_wine {
2812 EXPECT_REF(unk, 4);
2813 EXPECT_REF(elem2, 2);
2814}
2815 hr = IXMLDOMElement_QueryInterface(elem2, &IID_IUnknown, (void**)&unk2);
2816 EXPECT_HR(hr, S_OK);
2817todo_wine {
2818 EXPECT_REF(unk, 5);
2819 EXPECT_REF(unk2, 5);
2820}
2821 EXPECT_REF(element, 2);
2822 EXPECT_REF(elem2, 2);
2823
2824 todo_wine ok(unk == unk2, "got %p and %p\n", unk, unk2);
2825 IUnknown_Release(unk);
2826
2827 /* IUnknown refcount is not affected by node refcount */
2828 todo_wine EXPECT_REF(unk2, 4);
2829 IXMLDOMElement_AddRef(elem2);
2830 todo_wine EXPECT_REF(unk2, 4);
2831 IXMLDOMElement_Release(elem2);
2832
2833 IXMLDOMElement_Release(elem2);
2834 todo_wine EXPECT_REF(unk2, 3);
2835
2836 IUnknown_Release(unk2);
2837
2838 hr = IXMLDOMElement_get_childNodes( element, &node_list );
2839 EXPECT_HR(hr, S_OK);
2840
2841 todo_wine EXPECT_REF(element, 2);
2842 EXPECT_REF(node_list, 1);
2843
2844 hr = IXMLDOMNodeList_get_item( node_list, 0, &node );
2845 EXPECT_HR(hr, S_OK);
2846 EXPECT_REF(node_list, 1);
2847 EXPECT_REF(node, 1);
2848
2849 hr = IXMLDOMNodeList_get_item( node_list, 0, &node2 );
2850 EXPECT_HR(hr, S_OK);
2851 EXPECT_REF(node_list, 1);
2852 EXPECT_REF(node2, 1);
2853
2854 ref = IXMLDOMNode_Release( node );
2855 ok( ref == 0, "ref %d\n", ref );
2856 ref = IXMLDOMNode_Release( node2 );
2857 ok( ref == 0, "ref %d\n", ref );
2858
2859 ref = IXMLDOMNodeList_Release( node_list );
2860 ok( ref == 0, "ref %d\n", ref );
2861
2862 ok( node != node2, "node %p node2 %p\n", node, node2 );
2863
2864 ref = IXMLDOMDocument_Release( doc );
2865 todo_wine ok( ref == 0, "ref %d\n", ref );
2866
2867 todo_wine EXPECT_REF(element, 2);
2868
2869 /* IUnknown must be unique however we obtain it */
2870 hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
2871 EXPECT_HR(hr, S_OK);
2872 EXPECT_REF(element, 2);
2873 hr = IXMLDOMElement_QueryInterface(element, &IID_IXMLDOMNode, (void**)&node);
2874 EXPECT_HR(hr, S_OK);
2875 todo_wine EXPECT_REF(element, 2);
2876 hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk2);
2877 EXPECT_HR(hr, S_OK);
2878 todo_wine EXPECT_REF(element, 2);
2879 ok(unk == unk2, "unk %p unk2 %p\n", unk, unk2);
2880 todo_wine ok(element != (void*)node, "node %p element %p\n", node, element);
2881
2882 IUnknown_Release( unk2 );
2883 IUnknown_Release( unk );
2884 IXMLDOMNode_Release( node );
2885 todo_wine EXPECT_REF(element, 2);
2886
2887 IXMLDOMElement_Release( element );
2888
2889 free_bstrs();
2890}
refcount_test
static const refcount_test_t refcount_test[]
Definition: domdoc.c:2582
refcount_test_t
Definition: domdoc.c:2577

Referenced by START_TEST().

◆ test_removeChild()

static void test_removeChild ( void  )
static

Definition at line 3798 of file domdoc.c.

3799{
3800 HRESULT r;
3801 VARIANT_BOOL b;
3802 IXMLDOMDocument *doc;
3803 IXMLDOMElement *element, *lc_element;
3804 IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
3805 IXMLDOMNodeList *root_list, *fo_list;
3806
3807 doc = create_document(&IID_IXMLDOMDocument);
3808
3809 r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3810 ok( r == S_OK, "loadXML failed\n");
3811 ok( b == VARIANT_TRUE, "failed to load XML string\n");
3812
3813 r = IXMLDOMDocument_get_documentElement( doc, &element );
3814 ok( r == S_OK, "ret %08x\n", r);
3815 todo_wine EXPECT_REF(element, 2);
3816
3817 r = IXMLDOMElement_get_childNodes( element, &root_list );
3818 ok( r == S_OK, "ret %08x\n", r);
3819 EXPECT_REF(root_list, 1);
3820
3821 r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3822 ok( r == S_OK, "ret %08x\n", r);
3823 EXPECT_REF(fo_node, 1);
3824
3825 r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3826 ok( r == S_OK, "ret %08x\n", r);
3827 EXPECT_REF(fo_list, 1);
3828
3829 r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3830 ok( r == S_OK, "ret %08x\n", r);
3831 EXPECT_REF(ba_node, 1);
3832
3833 /* invalid parameter: NULL ptr */
3834 removed_node = (void*)0xdeadbeef;
3835 r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
3836 ok( r == E_INVALIDARG, "ret %08x\n", r );
3837 ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3838
3839 /* ba_node is a descendant of element, but not a direct child. */
3840 removed_node = (void*)0xdeadbeef;
3841 EXPECT_REF(ba_node, 1);
3842 EXPECT_CHILDREN(fo_node);
3843 r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
3844 ok( r == E_INVALIDARG, "ret %08x\n", r );
3845 ok( removed_node == NULL, "%p\n", removed_node );
3846 EXPECT_REF(ba_node, 1);
3847 EXPECT_CHILDREN(fo_node);
3848
3849 EXPECT_REF(ba_node, 1);
3850 EXPECT_REF(fo_node, 1);
3851 r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
3852 ok( r == S_OK, "ret %08x\n", r);
3853 ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
3854 EXPECT_REF(fo_node, 2);
3855 EXPECT_REF(ba_node, 1);
3856
3857 /* try removing already removed child */
3858 temp_node = (void*)0xdeadbeef;
3859 r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
3860 ok( r == E_INVALIDARG, "ret %08x\n", r);
3861 ok( temp_node == NULL, "%p\n", temp_node );
3862 IXMLDOMNode_Release( fo_node );
3863
3864 /* the removed node has no parent anymore */
3865 r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
3866 ok( r == S_FALSE, "ret %08x\n", r);
3867 ok( temp_node == NULL, "%p\n", temp_node );
3868
3869 IXMLDOMNode_Release( removed_node );
3870 IXMLDOMNode_Release( ba_node );
3871 IXMLDOMNodeList_Release( fo_list );
3872
3873 r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3874 ok( r == S_OK, "ret %08x\n", r);
3875
3876 r = IXMLDOMNode_QueryInterface( lc_node, &IID_IXMLDOMElement, (void**)&lc_element );
3877 ok( r == S_OK, "ret %08x\n", r);
3878
3879 /* MS quirk: passing wrong interface pointer works, too */
3880 r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
3881 ok( r == S_OK, "ret %08x\n", r);
3882 IXMLDOMElement_Release( lc_element );
3883
3884 temp_node = (void*)0xdeadbeef;
3885 r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
3886 ok( r == S_FALSE, "ret %08x\n", r);
3887 ok( temp_node == NULL, "%p\n", temp_node );
3888
3889 IXMLDOMNode_Release( lc_node );
3890 IXMLDOMNodeList_Release( root_list );
3891 IXMLDOMElement_Release( element );
3892 IXMLDOMDocument_Release( doc );
3893
3894 free_bstrs();
3895}

Referenced by START_TEST().

◆ test_removeNamedItem()

static void test_removeNamedItem ( void  )
static

Definition at line 4009 of file domdoc.c.

4010{
4011 IXMLDOMDocument *doc;
4012 IXMLDOMElement *element;
4013 IXMLDOMNode *pr_node, *removed_node, *removed_node2;
4014 IXMLDOMNodeList *root_list;
4015 IXMLDOMNamedNodeMap * pr_attrs;
4016 VARIANT_BOOL b;
4017 BSTR str;
4018 LONG len;
4019 HRESULT r;
4020
4021 doc = create_document(&IID_IXMLDOMDocument);
4022
4023 r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4024 ok( r == S_OK, "loadXML failed\n");
4025 ok( b == VARIANT_TRUE, "failed to load XML string\n");
4026
4027 r = IXMLDOMDocument_get_documentElement( doc, &element );
4028 ok( r == S_OK, "ret %08x\n", r);
4029
4030 r = IXMLDOMElement_get_childNodes( element, &root_list );
4031 ok( r == S_OK, "ret %08x\n", r);
4032
4033 r = IXMLDOMNodeList_get_item( root_list, 1, &pr_node );
4034 ok( r == S_OK, "ret %08x\n", r);
4035
4036 r = IXMLDOMNode_get_attributes( pr_node, &pr_attrs );
4037 ok( r == S_OK, "ret %08x\n", r);
4038
4039 r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4040 ok( r == S_OK, "ret %08x\n", r);
4041 ok( len == 3, "length %d\n", len);
4042
4043 removed_node = (void*)0xdeadbeef;
4044 r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, NULL, &removed_node);
4045 ok ( r == E_INVALIDARG, "ret %08x\n", r);
4046 ok ( removed_node == (void*)0xdeadbeef, "got %p\n", removed_node);
4047
4048 removed_node = (void*)0xdeadbeef;
4049 str = SysAllocString(szvr);
4050 r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node);
4051 ok ( r == S_OK, "ret %08x\n", r);
4052
4053 removed_node2 = (void*)0xdeadbeef;
4054 r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node2);
4055 ok ( r == S_FALSE, "ret %08x\n", r);
4056 ok ( removed_node2 == NULL, "got %p\n", removed_node2 );
4057
4058 r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4059 ok( r == S_OK, "ret %08x\n", r);
4060 ok( len == 2, "length %d\n", len);
4061
4062 r = IXMLDOMNamedNodeMap_setNamedItem( pr_attrs, removed_node, NULL);
4063 ok ( r == S_OK, "ret %08x\n", r);
4064 IXMLDOMNode_Release(removed_node);
4065
4066 r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4067 ok( r == S_OK, "ret %08x\n", r);
4068 ok( len == 3, "length %d\n", len);
4069
4070 r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
4071 ok ( r == S_OK, "ret %08x\n", r);
4072
4073 r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4074 ok( r == S_OK, "ret %08x\n", r);
4075 ok( len == 2, "length %d\n", len);
4076
4077 r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
4078 ok ( r == S_FALSE, "ret %08x\n", r);
4079
4080 SysFreeString(str);
4081
4082 IXMLDOMNamedNodeMap_Release( pr_attrs );
4083 IXMLDOMNode_Release( pr_node );
4084 IXMLDOMNodeList_Release( root_list );
4085 IXMLDOMElement_Release( element );
4086 IXMLDOMDocument_Release( doc );
4087
4088 free_bstrs();
4089}

Referenced by START_TEST().

◆ test_removeQualifiedItem()

static void test_removeQualifiedItem ( void  )
static

Definition at line 7772 of file domdoc.c.

7773{
7774 IXMLDOMDocument *doc;
7775 IXMLDOMElement *element;
7776 IXMLDOMNode *pr_node, *node;
7777 IXMLDOMNodeList *root_list;
7778 IXMLDOMNamedNodeMap *map;
7779 VARIANT_BOOL b;
7780 LONG len;
7781 HRESULT hr;
7782
7783 doc = create_document(&IID_IXMLDOMDocument);
7784
7785 hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7786 ok( hr == S_OK, "loadXML failed\n");
7787 ok( b == VARIANT_TRUE, "failed to load XML string\n");
7788
7789 hr = IXMLDOMDocument_get_documentElement(doc, &element);
7790 ok( hr == S_OK, "ret %08x\n", hr);
7791
7792 hr = IXMLDOMElement_get_childNodes(element, &root_list);
7793 ok( hr == S_OK, "ret %08x\n", hr);
7794
7795 hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7796 ok( hr == S_OK, "ret %08x\n", hr);
7797 IXMLDOMNodeList_Release(root_list);
7798
7799 hr = IXMLDOMNode_get_attributes(pr_node, &map);
7800 ok( hr == S_OK, "ret %08x\n", hr);
7801 IXMLDOMNode_Release(pr_node);
7802
7803 hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7804 ok( hr == S_OK, "ret %08x\n", hr);
7805 ok( len == 3, "length %d\n", len);
7806
7807 hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, NULL);
7808 ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7809
7810 node = (void*)0xdeadbeef;
7811 hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, &node);
7812 ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7813 ok( node == (void*)0xdeadbeef, "got %p\n", node);
7814
7815 /* out pointer is optional */
7816 hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7817 ok( hr == S_OK, "ret %08x\n", hr);
7818
7819 /* already removed */
7820 hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7821 ok( hr == S_FALSE, "ret %08x\n", hr);
7822
7823 hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("vr"), NULL, &node);
7824 ok( hr == S_OK, "ret %08x\n", hr);
7825 IXMLDOMNode_Release(node);
7826
7827 IXMLDOMNamedNodeMap_Release( map );
7828 IXMLDOMElement_Release( element );
7829 IXMLDOMDocument_Release( doc );
7830 free_bstrs();
7831}

Referenced by START_TEST().

◆ test_replaceChild()

static void test_replaceChild ( void  )
static

Definition at line 3897 of file domdoc.c.

3898{
3899 HRESULT r;
3900 VARIANT_BOOL b;
3901 IXMLDOMDocument *doc;
3902 IXMLDOMElement *element, *ba_element;
3903 IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
3904 IXMLDOMNodeList *root_list, *fo_list;
3905 IUnknown * unk1, *unk2;
3906 LONG len;
3907
3908 doc = create_document(&IID_IXMLDOMDocument);
3909
3910 r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3911 ok( r == S_OK, "loadXML failed\n");
3912 ok( b == VARIANT_TRUE, "failed to load XML string\n");
3913
3914 r = IXMLDOMDocument_get_documentElement( doc, &element );
3915 ok( r == S_OK, "ret %08x\n", r);
3916
3917 r = IXMLDOMElement_get_childNodes( element, &root_list );
3918 ok( r == S_OK, "ret %08x\n", r);
3919
3920 r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3921 ok( r == S_OK, "ret %08x\n", r);
3922
3923 r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3924 ok( r == S_OK, "ret %08x\n", r);
3925
3926 r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3927 ok( r == S_OK, "ret %08x\n", r);
3928
3929 r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3930 ok( r == S_OK, "ret %08x\n", r);
3931
3932 IXMLDOMNodeList_Release( fo_list );
3933
3934 /* invalid parameter: NULL ptr for element to remove */
3935 removed_node = (void*)0xdeadbeef;
3936 r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
3937 ok( r == E_INVALIDARG, "ret %08x\n", r );
3938 ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3939
3940 /* invalid parameter: NULL for replacement element. (Sic!) */
3941 removed_node = (void*)0xdeadbeef;
3942 r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
3943 ok( r == E_INVALIDARG, "ret %08x\n", r );
3944 ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3945
3946 /* invalid parameter: OldNode is not a child */
3947 removed_node = (void*)0xdeadbeef;
3948 r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
3949 ok( r == E_INVALIDARG, "ret %08x\n", r );
3950 ok( removed_node == NULL, "%p\n", removed_node );
3951 IXMLDOMNode_Release( lc_node );
3952
3953 /* invalid parameter: would create loop */
3954 removed_node = (void*)0xdeadbeef;
3955 r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
3956 ok( r == E_FAIL, "ret %08x\n", r );
3957 ok( removed_node == NULL, "%p\n", removed_node );
3958
3959 r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
3960 ok( r == S_OK, "ret %08x\n", r );
3961
3962 r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
3963 ok( r == S_OK, "ret %08x\n", r );
3964
3965 /* ba_node and temp_node refer to the same node, yet they
3966 are different interface pointers */
3967 ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
3968 r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
3969 ok( r == S_OK, "ret %08x\n", r );
3970 r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
3971 ok( r == S_OK, "ret %08x\n", r );
3972 todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
3973
3974 IUnknown_Release( unk1 );
3975 IUnknown_Release( unk2 );
3976
3977 /* ba_node should have been removed from below fo_node */
3978 r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3979 ok( r == S_OK, "ret %08x\n", r );
3980
3981 /* MS quirk: replaceChild also accepts elements instead of nodes */
3982 r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
3983 ok( r == S_OK, "ret %08x\n", r );
3984 EXPECT_REF(ba_element, 2);
3985
3986 removed_node = NULL;
3987 r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
3988 ok( r == S_OK, "ret %08x\n", r );
3989 ok( removed_node != NULL, "got %p\n", removed_node);
3990 EXPECT_REF(ba_element, 3);
3991 IXMLDOMElement_Release( ba_element );
3992
3993 r = IXMLDOMNodeList_get_length( fo_list, &len);
3994 ok( r == S_OK, "ret %08x\n", r );
3995 ok( len == 0, "len %d\n", len);
3996
3997 IXMLDOMNodeList_Release( fo_list );
3998
3999 IXMLDOMNode_Release(ba_node);
4000 IXMLDOMNode_Release(fo_node);
4001 IXMLDOMNode_Release(temp_node);
4002 IXMLDOMNodeList_Release( root_list );
4003 IXMLDOMElement_Release( element );
4004 IXMLDOMDocument_Release( doc );
4005
4006 free_bstrs();
4007}

Referenced by START_TEST().

◆ test_save()

static void test_save ( void  )
static

Definition at line 6403 of file domdoc.c.

6404{
6405 IXMLDOMDocument *doc, *doc2;
6406 IXMLDOMElement *root;
6407 BSTR sOrig, sNew, filename;
6408 char buffer[100];
6409 IStream *stream;
6410 HGLOBAL global;
6411 VARIANT_BOOL b;
6412 DWORD read = 0;
6413 VARIANT dest;
6414 HANDLE hfile;
6415 HRESULT hr;
6416 char *ptr;
6417
6418 doc = create_document(&IID_IXMLDOMDocument);
6419 doc2 = create_document(&IID_IXMLDOMDocument);
6420
6421 /* save to IXMLDOMDocument */
6422 hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
6423 EXPECT_HR(hr, S_OK);
6424
6425 hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
6426 EXPECT_HR(hr, S_OK);
6427
6428 V_VT(&dest) = VT_UNKNOWN;
6429 V_UNKNOWN(&dest) = (IUnknown*)doc2;
6430
6431 hr = IXMLDOMDocument_save(doc, dest);
6432 EXPECT_HR(hr, S_OK);
6433
6434 hr = IXMLDOMDocument_get_xml(doc, &sOrig);
6435 EXPECT_HR(hr, S_OK);
6436
6437 hr = IXMLDOMDocument_get_xml(doc2, &sNew);
6438 EXPECT_HR(hr, S_OK);
6439
6440 ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as original\n");
6441
6442 SysFreeString(sOrig);
6443 SysFreeString(sNew);
6444
6445 IXMLDOMElement_Release(root);
6446 IXMLDOMDocument_Release(doc2);
6447
6448 /* save to path */
6449 V_VT(&dest) = VT_BSTR;
6450 V_BSTR(&dest) = _bstr_("test.xml");
6451
6452 hr = IXMLDOMDocument_save(doc, dest);
6453 EXPECT_HR(hr, S_OK);
6454
6455 hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
6456 ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
6457 if(hfile == INVALID_HANDLE_VALUE) return;
6458
6459 ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
6460 ok(read != 0, "could not read file\n");
6461 ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
6462
6463 CloseHandle(hfile);
6464 DeleteFileA("test.xml");
6465
6466 /* save to path VT_BSTR | VT_BYREF */
6467 filename = _bstr_("test.xml");
6468 V_VT(&dest) = VT_BSTR | VT_BYREF;
6469 V_BSTRREF(&dest) = &filename;
6470
6471 hr = IXMLDOMDocument_save(doc, dest);
6472 EXPECT_HR(hr, S_OK);
6473
6474 hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
6475 ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
6476 if(hfile == INVALID_HANDLE_VALUE) return;
6477
6478 if (hfile != INVALID_HANDLE_VALUE)
6479 {
6480 ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
6481 ok(read != 0, "could not read file\n");
6482 ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
6483
6484 CloseHandle(hfile);
6485 DeleteFileA("test.xml");
6486 }
6487
6488 /* save to stream */
6489 V_VT(&dest) = VT_UNKNOWN;
6490 V_UNKNOWN(&dest) = (IUnknown*)&savestream;
6491
6492 hr = IXMLDOMDocument_save(doc, dest);
6493 EXPECT_HR(hr, S_OK);
6494
6495 /* loaded data contains xml declaration */
6496 hr = IXMLDOMDocument_loadXML(doc, _bstr_(win1252xml), &b);
6497 EXPECT_HR(hr, S_OK);
6498
6499 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
6500 ok(hr == S_OK, "got 0x%08x\n", hr);
6501 V_VT(&dest) = VT_UNKNOWN;
6502 V_UNKNOWN(&dest) = (IUnknown*)stream;
6503 hr = IXMLDOMDocument_save(doc, dest);
6504 EXPECT_HR(hr, S_OK);
6505
6506 hr = GetHGlobalFromStream(stream, &global);
6507 EXPECT_HR(hr, S_OK);
6508 ptr = GlobalLock(global);
6509 ok(!memcmp(ptr, win1252decl, strlen(win1252decl)), "got wrong xml declaration\n");
6510 GlobalUnlock(global);
6511 IStream_Release(stream);
6512
6513 /* loaded data without xml declaration */
6514 hr = IXMLDOMDocument_loadXML(doc, _bstr_("<a/>"), &b);
6515 EXPECT_HR(hr, S_OK);
6516
6517 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
6518 ok(hr == S_OK, "got 0x%08x\n", hr);
6519 V_VT(&dest) = VT_UNKNOWN;
6520 V_UNKNOWN(&dest) = (IUnknown*)stream;
6521 hr = IXMLDOMDocument_save(doc, dest);
6522 EXPECT_HR(hr, S_OK);
6523
6524 hr = GetHGlobalFromStream(stream, &global);
6525 EXPECT_HR(hr, S_OK);
6526 ptr = GlobalLock(global);
6527 ok(ptr[0] == '<' && ptr[1] != '?', "got wrong start tag %c%c\n", ptr[0], ptr[1]);
6528 GlobalUnlock(global);
6529 IStream_Release(stream);
6530
6531 IXMLDOMDocument_Release(doc);
6532 free_bstrs();
6533}
read
#define read
Definition: acwin.h:96
OPEN_EXISTING
#define OPEN_EXISTING
Definition: compat.h:775
ReadFile
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135
GetHGlobalFromStream
HRESULT WINAPI GetHGlobalFromStream(IStream *pstm, HGLOBAL *phglobal)
Definition: hglobalstream.c:654
CreateStreamOnHGlobal
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
Definition: hglobalstream.c:623
global
int global
Definition: ehframes.cpp:22
buffer
GLuint buffer
Definition: glext.h:5915
GlobalLock
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
GlobalUnlock
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
filename
const char * filename
Definition: ioapi.h:137
win1252decl
static const char win1252decl[]
Definition: domdoc.c:776
savestream
static IStream savestream
Definition: domdoc.c:354
dest
static char * dest
Definition: rtl.c:135

Referenced by START_TEST().

◆ test_selection()

static void test_selection ( void  )
static

Definition at line 9927 of file domdoc.c.

9928{
9929 IXMLDOMSelection *selection, *selection2;
9930 IEnumVARIANT *enum1, *enum2, *enum3;
9931 IXMLDOMNodeList *list;
9932 IUnknown *unk1, *unk2;
9933 IXMLDOMDocument *doc;
9934 IDispatchEx *dispex;
9935 IXMLDOMNode *node;
9936 IDispatch *disp;
9937 VARIANT_BOOL b;
9938 HRESULT hr;
9939 DISPID did;
9940 VARIANT v;
9941 BSTR name;
9942 ULONG ret;
9943 LONG len;
9944
9945 doc = create_document(&IID_IXMLDOMDocument);
9946
9947 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
9948 EXPECT_HR(hr, S_OK);
9949
9950 hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list);
9951 EXPECT_HR(hr, S_OK);
9952
9953 hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9954 EXPECT_HR(hr, S_OK);
9955 IXMLDOMSelection_Release(selection);
9956
9957 /* collection disp id */
9958 hr = IXMLDOMSelection_QueryInterface(selection, &IID_IDispatchEx, (void**)&dispex);
9959 EXPECT_HR(hr, S_OK);
9960 did = 0;
9961 hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
9962 EXPECT_HR(hr, S_OK);
9963 ok(did == DISPID_DOM_COLLECTION_BASE, "got %d\n", did);
9964 len = 0;
9965 hr = IXMLDOMSelection_get_length(selection, &len);
9966 EXPECT_HR(hr, S_OK);
9967 ok(len == 1, "got %d\n", len);
9968 hr = IDispatchEx_GetDispID(dispex, _bstr_("10"), 0, &did);
9969 EXPECT_HR(hr, S_OK);
9970 ok(did == DISPID_DOM_COLLECTION_BASE+10, "got %d\n", did);
9971 IDispatchEx_Release(dispex);
9972
9973 /* IEnumVARIANT tests */
9974 enum1 = NULL;
9975 hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum1);
9976 EXPECT_HR(hr, S_OK);
9977 ok(enum1 != NULL, "got %p\n", enum1);
9978 EXPECT_REF(enum1, 2);
9979
9980 EXPECT_REF(selection, 1);
9981 hr = IXMLDOMSelection_QueryInterface(selection, &IID_IUnknown, (void**)&unk1);
9982 EXPECT_HR(hr, S_OK);
9983 EXPECT_REF(selection, 2);
9984 EXPECT_REF(enum1, 2);
9985
9986 /* enumerator and selection object return same IUnknown* */
9987 hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
9988 EXPECT_HR(hr, S_OK);
9989 EXPECT_REF(selection, 3);
9990 EXPECT_REF(enum1, 2);
9991 ok(unk2 == unk1, "got %p, %p\n", unk1, unk2);
9992 IUnknown_Release(unk2);
9993
9994 EXPECT_REF(selection, 2);
9995 IEnumVARIANT_AddRef(enum1);
9996 EXPECT_REF(selection, 2);
9997 IEnumVARIANT_Release(enum1);
9998
9999 enum3 = NULL;
10000 hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum3);
10001 EXPECT_HR(hr, S_OK);
10002 ok(enum3 != NULL, "got %p\n", enum3);
10003 ok(enum1 == enum3, "got %p and %p\n", enum1, enum3);
10004 EXPECT_REF(enum1, 3);
10005 IEnumVARIANT_Release(enum3);
10006
10007 EXPECT_REF(selection, 2);
10008 EXPECT_REF(enum1, 2);
10009
10010 enum2 = NULL;
10011 hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
10012 EXPECT_HR(hr, S_OK);
10013 ok(enum2 != NULL, "got %p\n", enum2);
10014
10015 EXPECT_REF(selection, 3);
10016 EXPECT_REF(enum1, 2);
10017 EXPECT_REF(enum2, 1);
10018
10019 ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
10020
10021 hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
10022 EXPECT_HR(hr, S_OK);
10023 EXPECT_REF(selection, 3);
10024 EXPECT_REF(enum2, 2);
10025 ok(unk2 != unk1, "got %p, %p\n", unk1, unk2);
10026 IUnknown_Release(unk2);
10027 IUnknown_Release(unk1);
10028
10029 selection2 = NULL;
10030 hr = IEnumVARIANT_QueryInterface(enum1, &IID_IXMLDOMSelection, (void**)&selection2);
10031 EXPECT_HR(hr, S_OK);
10032 ok(selection2 == selection, "got %p and %p\n", selection, selection2);
10033 EXPECT_REF(selection, 3);
10034 EXPECT_REF(enum1, 2);
10035
10036 IXMLDOMSelection_Release(selection2);
10037
10038 hr = IEnumVARIANT_QueryInterface(enum1, &IID_IDispatch, (void**)&disp);
10039 EXPECT_HR(hr, S_OK);
10040 EXPECT_REF(selection, 3);
10041 IDispatch_Release(disp);
10042
10043 hr = IEnumVARIANT_QueryInterface(enum1, &IID_IEnumVARIANT, (void**)&enum3);
10044 EXPECT_HR(hr, S_OK);
10045 ok(enum3 == enum1, "got %p and %p\n", enum3, enum1);
10046 EXPECT_REF(selection, 2);
10047 EXPECT_REF(enum1, 3);
10048
10049 IEnumVARIANT_Release(enum1);
10050 IEnumVARIANT_Release(enum2);
10051 IEnumVARIANT_Release(enum3);
10052
10053 enum1 = NULL;
10054 hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
10055 EXPECT_HR(hr, S_OK);
10056 ok(enum1 != NULL, "got %p\n", enum1);
10057 EXPECT_REF(enum1, 1);
10058 EXPECT_REF(selection, 2);
10059
10060 enum2 = NULL;
10061 hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
10062 EXPECT_HR(hr, S_OK);
10063 ok(enum2 != NULL, "got %p\n", enum2);
10064 EXPECT_REF(enum2, 1);
10065 EXPECT_REF(selection, 3);
10066
10067 ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
10068
10069 IEnumVARIANT_AddRef(enum1);
10070 EXPECT_REF(selection, 3);
10071 EXPECT_REF(enum1, 2);
10072 EXPECT_REF(enum2, 1);
10073 IEnumVARIANT_Release(enum1);
10074
10075 IEnumVARIANT_Release(enum1);
10076 IEnumVARIANT_Release(enum2);
10077
10078 EXPECT_REF(selection, 1);
10079
10080 IXMLDOMNodeList_Release(list);
10081
10082 hr = IXMLDOMDocument_get_childNodes(doc, &list);
10083 EXPECT_HR(hr, S_OK);
10084
10085 hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
10086 EXPECT_HR(hr, E_NOINTERFACE);
10087
10088 IXMLDOMNodeList_Release(list);
10089
10090 /* test if IEnumVARIANT touches selection context */
10091 hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
10092 EXPECT_HR(hr, S_OK);
10093
10094 hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/*"), &list);
10095 EXPECT_HR(hr, S_OK);
10096
10097 hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
10098 EXPECT_HR(hr, S_OK);
10099
10100 len = 0;
10101 hr = IXMLDOMSelection_get_length(selection, &len);
10102 EXPECT_HR(hr, S_OK);
10103 ok(len == 4, "got %d\n", len);
10104
10105 enum1 = NULL;
10106 hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
10107 EXPECT_HR(hr, S_OK);
10108
10109 /* no-op if zero count */
10110 V_VT(&v) = VT_I2;
10111 hr = IEnumVARIANT_Next(enum1, 0, &v, NULL);
10112 EXPECT_HR(hr, S_OK);
10113 ok(V_VT(&v) == VT_I2, "got var type %d\n", V_VT(&v));
10114
10115 /* positive count, null array pointer */
10116 hr = IEnumVARIANT_Next(enum1, 1, NULL, NULL);
10117 EXPECT_HR(hr, E_INVALIDARG);
10118
10119 ret = 1;
10120 hr = IEnumVARIANT_Next(enum1, 1, NULL, &ret);
10121 EXPECT_HR(hr, E_INVALIDARG);
10122 ok(ret == 0, "got %d\n", ret);
10123
10124 V_VT(&v) = VT_I2;
10125 hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
10126 EXPECT_HR(hr, S_OK);
10127 ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
10128
10129 hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
10130 EXPECT_HR(hr, S_OK);
10131 hr = IXMLDOMNode_get_nodeName(node, &name);
10132 EXPECT_HR(hr, S_OK);
10133 ok(!lstrcmpW(name, _bstr_("a")), "got node name %s\n", wine_dbgstr_w(name));
10134 SysFreeString(name);
10135 IXMLDOMNode_Release(node);
10136 VariantClear(&v);
10137
10138 /* list cursor is updated */
10139 hr = IXMLDOMSelection_nextNode(selection, &node);
10140 EXPECT_HR(hr, S_OK);
10141 hr = IXMLDOMNode_get_nodeName(node, &name);
10142 EXPECT_HR(hr, S_OK);
10143 ok(!lstrcmpW(name, _bstr_("c")), "got node name %s\n", wine_dbgstr_w(name));
10144 IXMLDOMNode_Release(node);
10145 SysFreeString(name);
10146
10147 V_VT(&v) = VT_I2;
10148 hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
10149 EXPECT_HR(hr, S_OK);
10150 ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
10151 hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
10152 EXPECT_HR(hr, S_OK);
10153 hr = IXMLDOMNode_get_nodeName(node, &name);
10154 EXPECT_HR(hr, S_OK);
10155 ok(!lstrcmpW(name, _bstr_("b")), "got node name %s\n", wine_dbgstr_w(name));
10156 SysFreeString(name);
10157 IXMLDOMNode_Release(node);
10158 VariantClear(&v);
10159 IEnumVARIANT_Release(enum1);
10160
10161 hr = IXMLDOMSelection_nextNode(selection, &node);
10162 EXPECT_HR(hr, S_OK);
10163 hr = IXMLDOMNode_get_nodeName(node, &name);
10164 EXPECT_HR(hr, S_OK);
10165 ok(!lstrcmpW(name, _bstr_("d")), "got node name %s\n", wine_dbgstr_w(name));
10166 IXMLDOMNode_Release(node);
10167 SysFreeString(name);
10168
10169 IXMLDOMSelection_Release(selection);
10170 IXMLDOMNodeList_Release(list);
10171 IXMLDOMDocument_Release(doc);
10172
10173 free_bstrs();
10174}
selection
int selection
Definition: ctm.c:92

Referenced by START_TEST().

◆ test_selectSingleNode()

static void test_selectSingleNode ( void  )
static

Definition at line 8381 of file domdoc.c.

8382{
8383 IXMLDOMDocument *doc;
8384 IXMLDOMNodeList *list;
8385 IXMLDOMNode *node;
8386 VARIANT_BOOL b;
8387 HRESULT hr;
8388 LONG len;
8389
8390 doc = create_document(&IID_IXMLDOMDocument);
8391
8392 hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
8393 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8394
8395 hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
8396 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8397
8398 hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8399 ok( hr == S_OK, "loadXML failed\n");
8400 ok( b == VARIANT_TRUE, "failed to load XML string\n");
8401
8402 hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
8403 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8404
8405 hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
8406 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8407
8408 hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), NULL);
8409 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8410
8411 hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), NULL);
8412 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8413
8414 hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), &node);
8415 ok(hr == S_OK, "got 0x%08x\n", hr);
8416 IXMLDOMNode_Release(node);
8417
8418 hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), &list);
8419 ok(hr == S_OK, "got 0x%08x\n", hr);
8420 IXMLDOMNodeList_Release(list);
8421
8422 list = (void*)0xdeadbeef;
8423 hr = IXMLDOMDocument_selectNodes(doc, NULL, &list);
8424 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8425 ok(list == (void*)0xdeadbeef, "got %p\n", list);
8426
8427 node = (void*)0xdeadbeef;
8428 hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("nonexistent"), &node);
8429 ok(hr == S_FALSE, "got 0x%08x\n", hr);
8430 ok(node == 0, "got %p\n", node);
8431
8432 list = (void*)0xdeadbeef;
8433 hr = IXMLDOMDocument_selectNodes(doc, _bstr_("nonexistent"), &list);
8434 ok(hr == S_OK, "got 0x%08x\n", hr);
8435 len = 1;
8436 hr = IXMLDOMNodeList_get_length(list, &len);
8437 ok(hr == S_OK, "got 0x%08x\n", hr);
8438 ok(len == 0, "got %d\n", len);
8439 IXMLDOMNodeList_Release(list);
8440
8441 IXMLDOMDocument_Release(doc);
8442 free_bstrs();
8443}

Referenced by START_TEST().

◆ test_setAttributeNode()

static void test_setAttributeNode ( void  )
static

Definition at line 8034 of file domdoc.c.

8035{
8036 IXMLDOMDocument *doc, *doc2;
8037 IXMLDOMElement *elem, *elem2;
8038 IXMLDOMAttribute *attr, *attr2, *ret_attr;
8039 VARIANT_BOOL b;
8040 HRESULT hr;
8041 VARIANT v;
8042 BSTR str;
8043 ULONG ref1, ref2;
8044
8045 doc = create_document(&IID_IXMLDOMDocument);
8046
8047 hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8048 ok( hr == S_OK, "loadXML failed\n");
8049 ok( b == VARIANT_TRUE, "failed to load XML string\n");
8050
8051 hr = IXMLDOMDocument_get_documentElement(doc, &elem);
8052 ok( hr == S_OK, "got 0x%08x\n", hr);
8053
8054 hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
8055 ok( hr == S_OK, "got 0x%08x\n", hr);
8056 ok( elem2 != elem, "got same instance\n");
8057
8058 ret_attr = (void*)0xdeadbeef;
8059 hr = IXMLDOMElement_setAttributeNode(elem, NULL, &ret_attr);
8060 ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
8061 ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8062
8063 hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8064 ok( hr == S_OK, "got 0x%08x\n", hr);
8065
8066 ref1 = IXMLDOMElement_AddRef(elem);
8067 IXMLDOMElement_Release(elem);
8068
8069 ret_attr = (void*)0xdeadbeef;
8070 hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8071 ok( hr == S_OK, "got 0x%08x\n", hr);
8072 ok( ret_attr == NULL, "got %p\n", ret_attr);
8073
8074 /* no reference added */
8075 ref2 = IXMLDOMElement_AddRef(elem);
8076 IXMLDOMElement_Release(elem);
8077 ok(ref2 == ref1, "got %d, expected %d\n", ref2, ref1);
8078
8079 EXPECT_CHILDREN(elem);
8080 EXPECT_CHILDREN(elem2);
8081
8082 IXMLDOMElement_Release(elem2);
8083
8084 attr2 = NULL;
8085 hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attr"), &attr2);
8086 ok( hr == S_OK, "got 0x%08x\n", hr);
8087 ok( attr2 != attr, "got same instance %p\n", attr2);
8088 IXMLDOMAttribute_Release(attr2);
8089
8090 /* try to add it another time */
8091 ret_attr = (void*)0xdeadbeef;
8092 hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8093 ok( hr == E_FAIL, "got 0x%08x\n", hr);
8094 ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8095
8096 IXMLDOMElement_Release(elem);
8097
8098 /* initially used element is released, attribute still 'has' a container */
8099 hr = IXMLDOMDocument_get_documentElement(doc, &elem);
8100 ok( hr == S_OK, "got 0x%08x\n", hr);
8101 ret_attr = (void*)0xdeadbeef;
8102 hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8103 ok( hr == E_FAIL, "got 0x%08x\n", hr);
8104 ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8105 IXMLDOMElement_Release(elem);
8106
8107 /* add attribute already attached to another document */
8108 doc2 = create_document(&IID_IXMLDOMDocument);
8109
8110 hr = IXMLDOMDocument_loadXML( doc2, _bstr_(complete4A), &b );
8111 ok( hr == S_OK, "loadXML failed\n");
8112 ok( b == VARIANT_TRUE, "failed to load XML string\n");
8113
8114 hr = IXMLDOMDocument_get_documentElement(doc2, &elem);
8115 ok( hr == S_OK, "got 0x%08x\n", hr);
8116 hr = IXMLDOMElement_setAttributeNode(elem, attr, NULL);
8117 ok( hr == E_FAIL, "got 0x%08x\n", hr);
8118 IXMLDOMElement_Release(elem);
8119
8120 IXMLDOMAttribute_Release(attr);
8121
8122 /* create element, add attribute, see if it's copied or linked */
8123 hr = IXMLDOMDocument_createElement(doc, _bstr_("test"), &elem);
8124 ok( hr == S_OK, "got 0x%08x\n", hr);
8125
8126 attr = NULL;
8127 hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8128 ok(hr == S_OK, "got 0x%08x\n", hr);
8129 ok(attr != NULL, "got %p\n", attr);
8130
8131 ref1 = IXMLDOMAttribute_AddRef(attr);
8132 IXMLDOMAttribute_Release(attr);
8133
8134 V_VT(&v) = VT_BSTR;
8135 V_BSTR(&v) = _bstr_("attrvalue1");
8136 hr = IXMLDOMAttribute_put_nodeValue(attr, v);
8137 ok( hr == S_OK, "got 0x%08x\n", hr);
8138
8139 str = NULL;
8140 hr = IXMLDOMAttribute_get_xml(attr, &str);
8141 ok( hr == S_OK, "got 0x%08x\n", hr);
8142 ok( lstrcmpW(str, _bstr_("attr=\"attrvalue1\"")) == 0,
8143 "got %s\n", wine_dbgstr_w(str));
8144 SysFreeString(str);
8145
8146 ret_attr = (void*)0xdeadbeef;
8147 hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8148 ok(hr == S_OK, "got 0x%08x\n", hr);
8149 ok(ret_attr == NULL, "got %p\n", ret_attr);
8150
8151 /* attribute reference increased */
8152 ref2 = IXMLDOMAttribute_AddRef(attr);
8153 IXMLDOMAttribute_Release(attr);
8154 ok(ref1 == ref2, "got %d, expected %d\n", ref2, ref1);
8155
8156 hr = IXMLDOMElement_get_xml(elem, &str);
8157 ok( hr == S_OK, "got 0x%08x\n", hr);
8158 ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue1\"/>")) == 0,
8159 "got %s\n", wine_dbgstr_w(str));
8160 SysFreeString(str);
8161
8162 V_VT(&v) = VT_BSTR;
8163 V_BSTR(&v) = _bstr_("attrvalue2");
8164 hr = IXMLDOMAttribute_put_nodeValue(attr, v);
8165 ok( hr == S_OK, "got 0x%08x\n", hr);
8166
8167 hr = IXMLDOMElement_get_xml(elem, &str);
8168 ok( hr == S_OK, "got 0x%08x\n", hr);
8169 todo_wine ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue2\"/>")) == 0,
8170 "got %s\n", wine_dbgstr_w(str));
8171 SysFreeString(str);
8172
8173 IXMLDOMElement_Release(elem);
8174 IXMLDOMAttribute_Release(attr);
8175 IXMLDOMDocument_Release(doc2);
8176 IXMLDOMDocument_Release(doc);
8177 free_bstrs();
8178}

Referenced by START_TEST().

◆ test_splitText()

static void test_splitText ( void  )
static

Definition at line 7527 of file domdoc.c.

7528{
7529 IXMLDOMCDATASection *cdata;
7530 IXMLDOMElement *root;
7531 IXMLDOMDocument *doc;
7532 IXMLDOMText *text, *text2;
7533 IXMLDOMNode *node;
7534 VARIANT var;
7535 VARIANT_BOOL success;
7536 LONG length;
7537 HRESULT hr;
7538
7539 doc = create_document(&IID_IXMLDOMDocument);
7540
7541 hr = IXMLDOMDocument_loadXML(doc, _bstr_("<root></root>"), &success);
7542 ok(hr == S_OK, "got 0x%08x\n", hr);
7543
7544 hr = IXMLDOMDocument_get_documentElement(doc, &root);
7545 ok(hr == S_OK, "got 0x%08x\n", hr);
7546
7547 hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("beautiful plumage"), &cdata);
7548 ok(hr == S_OK, "got 0x%08x\n", hr);
7549
7550 V_VT(&var) = VT_EMPTY;
7551 hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)cdata, NULL);
7552 ok(hr == S_OK, "got 0x%08x\n", hr);
7553
7554 length = 0;
7555 hr = IXMLDOMCDATASection_get_length(cdata, &length);
7556 ok(hr == S_OK, "got 0x%08x\n", hr);
7557 ok(length > 0, "got %d\n", length);
7558
7559 hr = IXMLDOMCDATASection_splitText(cdata, 0, NULL);
7560 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7561
7562 text = (void*)0xdeadbeef;
7563 /* negative offset */
7564 hr = IXMLDOMCDATASection_splitText(cdata, -1, &text);
7565 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7566 ok(text == (void*)0xdeadbeef, "got %p\n", text);
7567
7568 text = (void*)0xdeadbeef;
7569 /* offset outside data */
7570 hr = IXMLDOMCDATASection_splitText(cdata, length + 1, &text);
7571 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7572 ok(text == 0, "got %p\n", text);
7573
7574 text = (void*)0xdeadbeef;
7575 /* offset outside data */
7576 hr = IXMLDOMCDATASection_splitText(cdata, length, &text);
7577 ok(hr == S_FALSE, "got 0x%08x\n", hr);
7578 ok(text == 0, "got %p\n", text);
7579
7580 /* no empty node created */
7581 node = (void*)0xdeadbeef;
7582 hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7583 ok(hr == S_FALSE, "got 0x%08x\n", hr);
7584 ok(node == 0, "got %p\n", text);
7585
7586 hr = IXMLDOMCDATASection_splitText(cdata, 10, &text);
7587 ok(hr == S_OK, "got 0x%08x\n", hr);
7588
7589 length = 0;
7590 hr = IXMLDOMText_get_length(text, &length);
7591 ok(hr == S_OK, "got 0x%08x\n", hr);
7592 ok(length == 7, "got %d\n", length);
7593
7594 hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7595 ok(hr == S_OK, "got 0x%08x\n", hr);
7596 IXMLDOMNode_Release(node);
7597
7598 /* split new text node */
7599 hr = IXMLDOMText_get_length(text, &length);
7600 ok(hr == S_OK, "got 0x%08x\n", hr);
7601
7602 node = (void*)0xdeadbeef;
7603 hr = IXMLDOMText_get_nextSibling(text, &node);
7604 ok(hr == S_FALSE, "got 0x%08x\n", hr);
7605 ok(node == 0, "got %p\n", text);
7606
7607 hr = IXMLDOMText_splitText(text, 0, NULL);
7608 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7609
7610 text2 = (void*)0xdeadbeef;
7611 /* negative offset */
7612 hr = IXMLDOMText_splitText(text, -1, &text2);
7613 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7614 ok(text2 == (void*)0xdeadbeef, "got %p\n", text2);
7615
7616 text2 = (void*)0xdeadbeef;
7617 /* offset outside data */
7618 hr = IXMLDOMText_splitText(text, length + 1, &text2);
7619 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7620 ok(text2 == 0, "got %p\n", text2);
7621
7622 text2 = (void*)0xdeadbeef;
7623 /* offset outside data */
7624 hr = IXMLDOMText_splitText(text, length, &text2);
7625 ok(hr == S_FALSE, "got 0x%08x\n", hr);
7626 ok(text2 == 0, "got %p\n", text);
7627
7628 text2 = 0;
7629 hr = IXMLDOMText_splitText(text, 4, &text2);
7630 todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7631 if (text2) IXMLDOMText_Release(text2);
7632
7633 node = 0;
7634 hr = IXMLDOMText_get_nextSibling(text, &node);
7635 todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7636 if (node) IXMLDOMNode_Release(node);
7637
7638 IXMLDOMText_Release(text);
7639 IXMLDOMElement_Release(root);
7640 IXMLDOMCDATASection_Release(cdata);
7641 free_bstrs();
7642}
success
#define success(from, fromstr, to, tostr)
Definition: win_iconv_test.c:158

Referenced by START_TEST().

◆ test_supporterrorinfo()

static void test_supporterrorinfo ( void  )
static

Definition at line 11539 of file domdoc.c.

11540{
11541 static REFIID iids[5] = { &IID_IXMLDOMNode, &IID_IXMLDOMDocument,
11542 &IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3 };
11543 const supporterror_t *ptr = supporterror_test;
11544 ISupportErrorInfo *errorinfo, *info2;
11545 IXMLDOMSchemaCollection *schemacache;
11546 IXMLDOMNamedNodeMap *map, *map2;
11547 IXMLDOMDocument *doc;
11548 IXMLDOMElement *elem;
11549 VARIANT_BOOL b;
11550 IUnknown *unk;
11551 REFIID *iid;
11552 void *dummy;
11553 HRESULT hr;
11554
11555 if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument3)) return;
11556 doc = create_document_version(60, &IID_IXMLDOMDocument3);
11557
11558 EXPECT_REF(doc, 1);
11559 hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&errorinfo);
11560 EXPECT_HR(hr, S_OK);
11561 EXPECT_REF(doc, 1);
11562 ISupportErrorInfo_AddRef(errorinfo);
11563 EXPECT_REF(errorinfo, 2);
11564 EXPECT_REF(doc, 1);
11565 ISupportErrorInfo_Release(errorinfo);
11566
11567 hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&info2);
11568 EXPECT_HR(hr, S_OK);
11569 ok(errorinfo != info2, "got %p, %p\n", info2, errorinfo);
11570
11571 /* error interface can't be queried back for DOM interface */
11572 hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMDocument, &dummy);
11573 EXPECT_HR(hr, E_NOINTERFACE);
11574 hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMNode, &dummy);
11575 EXPECT_HR(hr, E_NOINTERFACE);
11576
11577 ISupportErrorInfo_Release(info2);
11578
11579 iid = iids;
11580 while (*iid)
11581 {
11582 hr = IXMLDOMDocument_QueryInterface(doc, *iid, (void**)&unk);
11583 EXPECT_HR(hr, S_OK);
11584 if (hr == S_OK)
11585 {
11586 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
11587 ok(hr == S_OK, "got 0x%08x for %s\n", hr, wine_dbgstr_guid(*iid));
11588 IUnknown_Release(unk);
11589 }
11590
11591 iid++;
11592 }
11593
11594 ISupportErrorInfo_Release(errorinfo);
11595
11596 while (ptr->type != NODE_INVALID)
11597 {
11598 IXMLDOMNode *node;
11599 VARIANT type;
11600
11601 V_VT(&type) = VT_I1;
11602 V_I1(&type) = ptr->type;
11603
11604 hr = IXMLDOMDocument_createNode(doc, type, _bstr_(ptr->name), NULL, &node);
11605 ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
11606
11607 EXPECT_REF(node, 1);
11608 hr = IXMLDOMNode_QueryInterface(node, &IID_ISupportErrorInfo, (void**)&errorinfo);
11609 ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
11610 EXPECT_REF(node, 1);
11611
11612 hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNode, &dummy);
11613 ok(hr == E_NOINTERFACE, "%d: got 0x%08x\n", ptr->type, hr);
11614
11615 iid = ptr->iids;
11616
11617 while (*iid)
11618 {
11619 hr = IXMLDOMNode_QueryInterface(node, *iid, (void**)&unk);
11620 if (hr == S_OK)
11621 {
11622 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
11623 ok(hr == S_OK, "%d: got 0x%08x for %s\n", ptr->type, hr, wine_dbgstr_guid(*iid));
11624 IUnknown_Release(unk);
11625 }
11626
11627 iid++;
11628 }
11629
11630 ISupportErrorInfo_Release(errorinfo);
11631 IXMLDOMNode_Release(node);
11632 ptr++;
11633 }
11634
11635 /* IXMLDOMNamedNodeMap */
11636 b = VARIANT_FALSE;
11637 hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
11638 EXPECT_HR(hr, S_OK);
11639 ok(b == VARIANT_TRUE, "got %d\n", b);
11640
11641 hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11642 EXPECT_HR(hr, S_OK);
11643
11644 hr = IXMLDOMElement_get_attributes(elem, &map);
11645 EXPECT_HR(hr, S_OK);
11646
11647 EXPECT_REF(map, 1);
11648 hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_ISupportErrorInfo, (void**)&errorinfo);
11649 EXPECT_HR(hr, S_OK);
11650 EXPECT_REF(map, 2);
11651
11652 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMNamedNodeMap);
11653 EXPECT_HR(hr, S_OK);
11654
11655 hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNamedNodeMap, (void**)&map2);
11656 EXPECT_HR(hr, S_OK);
11657 ok(map == map2, "got %p\n", map2);
11658 IXMLDOMNamedNodeMap_Release(map2);
11659
11660 EXPECT_REF(errorinfo, 2);
11661 hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IUnknown, (void**)&unk);
11662 EXPECT_HR(hr, S_OK);
11663 EXPECT_REF(errorinfo, 3);
11664 EXPECT_REF(map, 3);
11665 IUnknown_Release(unk);
11666
11667 ISupportErrorInfo_Release(errorinfo);
11668 IXMLDOMNamedNodeMap_Release(map);
11669 IXMLDOMElement_Release(elem);
11670
11671 IXMLDOMDocument_Release(doc);
11672
11673 /* IXMLDOMSchemaCollection */
11674 hr = CoCreateInstance(&CLSID_XMLSchemaCache, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMSchemaCollection, (void**)&schemacache);
11675 ok(hr == S_OK, "failed to create schema collection, 0x%08x\n", hr);
11676
11677 hr = IXMLDOMSchemaCollection_QueryInterface(schemacache, &IID_ISupportErrorInfo, (void**)&errorinfo);
11678 ok(hr == S_OK, "got 0x%08x\n", hr);
11679
11680 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMSchemaCollection);
11681 ok(hr == S_OK, "got 0x%08x\n", hr);
11682
11683 ISupportErrorInfo_Release(errorinfo);
11684 IXMLDOMSchemaCollection_Release(schemacache);
11685
11686 free_bstrs();
11687}
supporterror_test
static const supporterror_t supporterror_test[]
Definition: domdoc.c:11528
REFIID
#define REFIID
Definition: guiddef.h:118
supporterror_t
Definition: domdoc.c:11522

Referenced by START_TEST().

◆ test_testTransforms()

static void test_testTransforms ( void  )
static

Definition at line 6535 of file domdoc.c.

6536{
6537 IXMLDOMDocument *doc, *docSS;
6538 IXMLDOMNode *pNode;
6539 VARIANT_BOOL bSucc;
6540 HRESULT hr;
6541
6542 doc = create_document(&IID_IXMLDOMDocument);
6543 docSS = create_document(&IID_IXMLDOMDocument);
6544
6545 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
6546 ok(hr == S_OK, "ret %08x\n", hr );
6547
6548 hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
6549 ok(hr == S_OK, "ret %08x\n", hr );
6550
6551 hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (void**)&pNode );
6552 ok(hr == S_OK, "ret %08x\n", hr );
6553 if(hr == S_OK)
6554 {
6555 BSTR bOut;
6556
6557 hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
6558 ok(hr == S_OK, "ret %08x\n", hr );
6559 if(hr == S_OK)
6560 {
6561 ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "got output %s\n", wine_dbgstr_w(bOut));
6562 SysFreeString(bOut);
6563 }
6564
6565 IXMLDOMNode_Release(pNode);
6566 }
6567
6568 IXMLDOMDocument_Release(docSS);
6569 IXMLDOMDocument_Release(doc);
6570
6571 free_bstrs();
6572}
szTransformXML
static const CHAR szTransformXML[]
Definition: domdoc.c:852
compareIgnoreReturns
static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
Definition: domdoc.c:1267
szTransformOutput
static const CHAR szTransformOutput[]
Definition: domdoc.c:875

Referenced by START_TEST().

◆ test_transformNodeToObject()

static void test_transformNodeToObject ( void  )
static

Definition at line 12787 of file domdoc.c.

12788{
12789 IUnknown transformdest = { &transformdestvtbl };
12790 IXMLDOMDocument *doc, *doc2, *doc3;
12791 VARIANT_BOOL b;
12792 HRESULT hr;
12793 VARIANT v;
12794
12795 doc = create_document(&IID_IXMLDOMDocument);
12796 doc2 = create_document(&IID_IXMLDOMDocument);
12797 doc3 = create_document(&IID_IXMLDOMDocument);
12798
12799 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &b);
12800 ok(hr == S_OK, "Failed to load document, hr %#x.\n", hr);
12801 hr = IXMLDOMDocument_loadXML(doc2, _bstr_(szTransformSSXML), &b);
12802 ok(hr == S_OK, "Failed to load document, hr %#x.\n", hr);
12803
12804 V_VT(&v) = VT_UNKNOWN;
12805 V_UNKNOWN(&v) = &transformdest;
12806 hr = IXMLDOMDocument_transformNodeToObject(doc, (IXMLDOMNode *)doc2, v);
12807 ok(hr == E_INVALIDARG, "Failed to transform node, hr %#x.\n", hr);
12808
12809 V_VT(&v) = VT_UNKNOWN;
12810 V_UNKNOWN(&v) = NULL;
12811 hr = IXMLDOMDocument_transformNodeToObject(doc, (IXMLDOMNode *)doc2, v);
12812 ok(hr == E_INVALIDARG, "Failed to transform node, hr %#x.\n", hr);
12813
12814 V_VT(&v) = VT_DISPATCH;
12815 V_DISPATCH(&v) = NULL;
12816 hr = IXMLDOMDocument_transformNodeToObject(doc, (IXMLDOMNode *)doc2, v);
12817 ok(hr == E_INVALIDARG, "Failed to transform node, hr %#x.\n", hr);
12818
12819 V_VT(&v) = VT_DISPATCH;
12820 V_DISPATCH(&v) = (IDispatch *)doc3;
12821 hr = IXMLDOMDocument_transformNodeToObject(doc, (IXMLDOMNode *)doc2, v);
12822 ok(hr == S_OK, "Failed to transform node, hr %#x.\n", hr);
12823
12824 IXMLDOMDocument_Release(doc3);
12825 IXMLDOMDocument_Release(doc2);
12826 IXMLDOMDocument_Release(doc);
12827 free_bstrs();
12828}
transformdestvtbl
static const IUnknownVtbl transformdestvtbl
Definition: domdoc.c:12780

Referenced by START_TEST().

◆ test_TransformWithLoadingLocalFile()

static void test_TransformWithLoadingLocalFile ( void  )
static

Definition at line 7026 of file domdoc.c.

7027{
7028 IXMLDOMDocument *doc;
7029 IXMLDOMDocument *xsl;
7030 IXMLDOMNode *pNode;
7031 VARIANT_BOOL bSucc;
7032 HRESULT hr;
7033 HANDLE file;
7034 DWORD dwWritten;
7035 char lpPathBuffer[MAX_PATH];
7036 int i;
7037
7038 /* Create a Temp File. */
7039 GetTempPathA(MAX_PATH, lpPathBuffer);
7040 strcat(lpPathBuffer, "customers.xml" );
7041
7042 file = CreateFileA(lpPathBuffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
7043 ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
7044 if(file == INVALID_HANDLE_VALUE)
7045 return;
7046
7047 WriteFile(file, szBasicTransformXML, strlen(szBasicTransformXML), &dwWritten, NULL);
7048 CloseHandle(file);
7049
7050 /* Correct path to not include an escape character. */
7051 for(i=0; i < strlen(lpPathBuffer); i++)
7052 {
7053 if(lpPathBuffer[i] == '\\')
7054 lpPathBuffer[i] = '/';
7055 }
7056
7057 doc = create_document(&IID_IXMLDOMDocument);
7058 xsl = create_document(&IID_IXMLDOMDocument);
7059
7060 hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
7061 ok(hr == S_OK, "ret %08x\n", hr );
7062 ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7063 if(bSucc == VARIANT_TRUE)
7064 {
7065 BSTR sXSL;
7066 BSTR sPart1 = _bstr_(szBasicTransformSSXMLPart1);
7067 BSTR sPart2 = _bstr_(szBasicTransformSSXMLPart2);
7068 BSTR sFileName = _bstr_(lpPathBuffer);
7069 int nLength = lstrlenW(sPart1) + lstrlenW(sPart2) + lstrlenW(sFileName) + 1;
7070
7071 sXSL = SysAllocStringLen(NULL, nLength);
7072 lstrcpyW(sXSL, sPart1);
7073 lstrcatW(sXSL, sFileName);
7074 lstrcatW(sXSL, sPart2);
7075
7076 hr = IXMLDOMDocument_loadXML(xsl, sXSL, &bSucc);
7077 ok(hr == S_OK, "ret %08x\n", hr );
7078 ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7079 if(bSucc == VARIANT_TRUE)
7080 {
7081 BSTR sResult;
7082
7083 hr = IXMLDOMDocument_QueryInterface(xsl, &IID_IXMLDOMNode, (void**)&pNode );
7084 ok(hr == S_OK, "ret %08x\n", hr );
7085 if(hr == S_OK)
7086 {
7087 /* This will load the temp file via the XSL */
7088 hr = IXMLDOMDocument_transformNode(doc, pNode, &sResult);
7089 ok(hr == S_OK, "ret %08x\n", hr );
7090 if(hr == S_OK)
7091 {
7092 ok( compareIgnoreReturns( sResult, _bstr_(szBasicTransformOutput)), "Stylesheet output not correct\n");
7093 SysFreeString(sResult);
7094 }
7095
7096 IXMLDOMNode_Release(pNode);
7097 }
7098 }
7099
7100 SysFreeString(sXSL);
7101 }
7102
7103 IXMLDOMDocument_Release(doc);
7104 IXMLDOMDocument_Release(xsl);
7105
7106 DeleteFileA(lpPathBuffer);
7107 free_bstrs();
7108}
lstrcpyW
#define lstrcpyW
Definition: compat.h:749
lstrcatW
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
szBasicTransformSSXMLPart1
static const CHAR szBasicTransformSSXMLPart1[]
Definition: domdoc.c:911
szBasicTransformXML
static const CHAR szBasicTransformXML[]
Definition: domdoc.c:936
szBasicTransformSSXMLPart2
static const CHAR szBasicTransformSSXMLPart2[]
Definition: domdoc.c:919
szBasicTransformOutput
static const CHAR szBasicTransformOutput[]
Definition: domdoc.c:939

Referenced by START_TEST().

◆ test_url()

static void test_url ( void  )
static

Definition at line 12671 of file domdoc.c.

12672{
12673 IXMLDOMDocument *doc;
12674 HRESULT hr;
12675 BSTR s;
12676
12677 doc = create_document(&IID_IXMLDOMDocument);
12678
12679 hr = IXMLDOMDocument_get_url(doc, NULL);
12680 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
12681
12682 s = (void *)0xdeadbeef;
12683 hr = IXMLDOMDocument_get_url(doc, &s);
12684 ok(hr == S_FALSE, "got 0x%08x\n", hr);
12685 ok(s == NULL, "got %s\n", wine_dbgstr_w(s));
12686
12687 IXMLDOMDocument_Release(doc);
12688}

Referenced by START_TEST().

◆ test_whitespace()

static void test_whitespace ( void  )
static

Definition at line 4657 of file domdoc.c.

4658{
4659 const struct whitespace_t *class_ptr = whitespace_test_data;
4660
4661 while (class_ptr->clsid)
4662 {
4663 IXMLDOMDocument2 *doc1, *doc2, *doc3, *doc4;
4664 IXMLDOMNodeList *list;
4665 IXMLDOMElement *root;
4666 VARIANT_BOOL b;
4667 HRESULT hr;
4668 LONG len;
4669
4670 if (!is_clsid_supported(class_ptr->clsid, &IID_IXMLDOMDocument2))
4671 {
4672 class_ptr++;
4673 continue;
4674 }
4675
4676 hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
4677 &IID_IXMLDOMDocument2, (void**)&doc1);
4678 ok(hr == S_OK, "got 0x%08x\n", hr);
4679
4680 hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
4681 &IID_IXMLDOMDocument2, (void**)&doc2);
4682 ok(hr == S_OK, "got 0x%08x\n", hr);
4683
4684 ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_TRUE));
4685 ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4686 ok(b == VARIANT_FALSE, "expected false\n");
4687 ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4688 ok(b == VARIANT_TRUE, "expected true\n");
4689
4690 ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4691 ok(b == VARIANT_TRUE, "failed to load XML string\n");
4692 ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4693 ok(b == VARIANT_TRUE, "failed to load XML string\n");
4694
4695 /* switch to XPath */
4696 ole_check(IXMLDOMDocument2_setProperty(doc1, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4697 ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4698
4699 check_ws_ignored(class_ptr->name, doc1, NULL);
4700 check_ws_preserved(class_ptr->name, doc2, NULL);
4701
4702 /* new instances copy the property */
4703 ole_check(IXMLDOMDocument2_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**) &doc3));
4704 ole_check(IXMLDOMDocument2_QueryInterface(doc2, &IID_IXMLDOMDocument2, (void**) &doc4));
4705
4706 ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4707 ok(b == VARIANT_FALSE, "expected false\n");
4708 ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4709 ok(b == VARIANT_TRUE, "expected true\n");
4710
4711 check_ws_ignored(class_ptr->name, doc3, NULL);
4712 check_ws_preserved(class_ptr->name, doc4, NULL);
4713
4714 /* setting after loading xml affects trimming of leading/trailing ws only */
4715 ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_TRUE));
4716 ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_FALSE));
4717
4718 /* the trailing "\n " isn't there, because it was ws-only node */
4719 check_ws_ignored(class_ptr->name, doc1, " This is a description. ");
4720 check_ws_preserved(class_ptr->name, doc2, " This is a description.");
4721
4722 /* it takes effect on reload */
4723 ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4724 ok(b == VARIANT_TRUE, "expected true\n");
4725 ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4726 ok(b == VARIANT_FALSE, "expected false\n");
4727
4728 ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4729 ok(b == VARIANT_TRUE, "failed to load XML string\n");
4730 ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4731 ok(b == VARIANT_TRUE, "failed to load XML string\n");
4732
4733 check_ws_preserved(class_ptr->name, doc1, NULL);
4734 check_ws_ignored(class_ptr->name, doc2, NULL);
4735
4736 /* other instances follow suit */
4737 ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4738 ok(b == VARIANT_TRUE, "expected true\n");
4739 ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4740 ok(b == VARIANT_FALSE, "expected false\n");
4741
4742 check_ws_preserved(class_ptr->name, doc3, NULL);
4743 check_ws_ignored(class_ptr->name, doc4, NULL);
4744
4745 IXMLDOMDocument2_Release(doc2);
4746 IXMLDOMDocument2_Release(doc3);
4747 IXMLDOMDocument2_Release(doc4);
4748
4749 /* text with char references */
4750 test_preserve_charref(doc1, VARIANT_TRUE);
4751 test_preserve_charref(doc1, VARIANT_FALSE);
4752
4753 /* formatting whitespaces */
4754 hr = IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_FALSE);
4755 ok(hr == S_OK, "got 0x%08x\n", hr);
4756
4757 hr = IXMLDOMDocument2_loadXML(doc1, _bstr_(complete7), &b);
4758 ok(hr == S_OK, "got 0x%08x\n", hr);
4759 ok(b == VARIANT_TRUE, "for %x\n", b);
4760
4761 hr = IXMLDOMDocument2_get_documentElement(doc1, &root);
4762 ok(hr == S_OK, "got 0x%08x\n", hr);
4763 hr = IXMLDOMElement_get_childNodes(root, &list);
4764 ok(hr == S_OK, "got 0x%08x\n", hr);
4765 len = 0;
4766 hr = IXMLDOMNodeList_get_length(list, &len);
4767 ok(hr == S_OK, "got 0x%08x\n", hr);
4768 ok(len == 3, "got %d\n", len);
4769 IXMLDOMNodeList_Release(list);
4770 IXMLDOMElement_Release(root);
4771
4772 IXMLDOMDocument2_Release(doc1);
4773
4774 free_bstrs();
4775
4776 class_ptr++;
4777 }
4778}
whitespace_test_data
static const struct whitespace_t whitespace_test_data[]
Definition: domdoc.c:4647
test_preserve_charref
static void test_preserve_charref(IXMLDOMDocument2 *doc, VARIANT_BOOL preserve)
Definition: domdoc.c:4594
check_ws_ignored
#define check_ws_ignored(ver, doc, str)
Definition: domdoc.c:4517
complete7
static const char complete7[]
Definition: domdoc.c:760
check_ws_preserved
#define check_ws_preserved(ver, doc, str)
Definition: domdoc.c:4555
whitespace_t
Definition: domdoc.c:4642
whitespace_t::clsid
const CLSID * clsid
Definition: domdoc.c:4643
whitespace_t::name
const char * name
Definition: domdoc.c:4644

Referenced by START_TEST().

◆ test_xmlns_attribute()

static void test_xmlns_attribute ( void  )
static

Definition at line 11754 of file domdoc.c.

11755{
11756 BSTR str;
11757 IXMLDOMDocument *doc;
11758 IXMLDOMElement *root;
11759 IXMLDOMAttribute *pAttribute;
11760 IXMLDOMElement *elem;
11761 HRESULT hr;
11762 VARIANT v;
11763
11764 doc = create_document(&IID_IXMLDOMDocument);
11765
11766 hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
11767 EXPECT_HR(hr, S_OK);
11768
11769 hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
11770 EXPECT_HR(hr, S_OK);
11771
11772 hr = IXMLDOMDocument_createAttribute(doc, _bstr_("xmlns:dt"), &pAttribute);
11773 ok( hr == S_OK, "returns %08x\n", hr );
11774
11775 V_VT(&v) = VT_BSTR;
11776 V_BSTR(&v) = _bstr_("urn:schemas-microsoft-com:datatypes");
11777 hr = IXMLDOMAttribute_put_nodeValue(pAttribute, v);
11778 ok(hr == S_OK, "ret %08x\n", hr );
11779
11780 hr = IXMLDOMElement_setAttributeNode(root, pAttribute, NULL);
11781 ok(hr == S_OK, "ret %08x\n", hr );
11782
11783 hr = IXMLDOMNode_put_dataType((IXMLDOMNode*)root, _bstr_("bin.base64"));
11784 ok(hr == S_OK, "ret %08x\n", hr );
11785
11786 hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11787 EXPECT_HR(hr, S_OK);
11788
11789 str = NULL;
11790 hr = IXMLDOMElement_get_xml(elem, &str);
11791 ok( hr == S_OK, "got 0x%08x\n", hr);
11792 todo_wine ok( lstrcmpW(str, _bstr_("<Testing xmlns:dt=\"urn:schemas-microsoft-com:datatypes\" dt:dt=\"bin.base64\"/>")) == 0,
11793 "got %s\n", wine_dbgstr_w(str));
11794 SysFreeString(str);
11795
11796 IXMLDOMElement_Release(elem);
11797 IXMLDOMAttribute_Release( pAttribute);
11798
11799 IXMLDOMDocument_Release(doc);
11800
11801 free_bstrs();
11802}

Referenced by START_TEST().

◆ test_xmlTypes()

static void test_xmlTypes ( void  )
static

Definition at line 5332 of file domdoc.c.

5333{
5334 IXMLDOMDocument *doc;
5335 IXMLDOMElement *pRoot;
5336 HRESULT hr;
5337 IXMLDOMComment *pComment;
5338 IXMLDOMElement *pElement;
5339 IXMLDOMAttribute *pAttribute;
5340 IXMLDOMNamedNodeMap *pAttribs;
5341 IXMLDOMCDATASection *pCDataSec;
5342 IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
5343 IXMLDOMDocumentFragment *pDocFrag = NULL;
5344 IXMLDOMEntityReference *pEntityRef = NULL;
5345 BSTR str;
5346 IXMLDOMNode *pNextChild;
5347 VARIANT v;
5348 LONG len = 0;
5349
5350 doc = create_document(&IID_IXMLDOMDocument);
5351
5352 hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
5353 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5354
5355 pNextChild = (void*)0xdeadbeef;
5356 hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
5357 ok(hr == S_FALSE, "ret %08x\n", hr );
5358 ok(pNextChild == NULL, "pDocChild not NULL\n");
5359
5360 /* test previous Sibling */
5361 hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
5362 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5363
5364 pNextChild = (void*)0xdeadbeef;
5365 hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
5366 ok(hr == S_FALSE, "ret %08x\n", hr );
5367 ok(pNextChild == NULL, "pNextChild not NULL\n");
5368
5369 /* test get_dataType */
5370 V_VT(&v) = VT_EMPTY;
5371 hr = IXMLDOMDocument_get_dataType(doc, &v);
5372 ok(hr == S_FALSE, "ret %08x\n", hr );
5373 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
5374 VariantClear(&v);
5375
5376 /* test implementation */
5377 hr = IXMLDOMDocument_get_implementation(doc, NULL);
5378 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5379
5380 hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
5381 ok(hr == S_OK, "ret %08x\n", hr );
5382 if(hr == S_OK)
5383 {
5384 VARIANT_BOOL hasFeature = VARIANT_TRUE;
5385 BSTR sEmpty = SysAllocStringLen(NULL, 0);
5386
5387 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
5388 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5389
5390 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
5391 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5392
5393 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
5394 ok(hr == S_OK, "ret %08x\n", hr );
5395 ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
5396
5397 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
5398 ok(hr == S_OK, "ret %08x\n", hr );
5399 ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
5400
5401 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
5402 ok(hr == S_OK, "ret %08x\n", hr );
5403 ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
5404
5405 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
5406 ok(hr == S_OK, "ret %08x\n", hr );
5407 ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
5408
5409 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
5410 ok(hr == S_OK, "ret %08x\n", hr );
5411 ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
5412
5413 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
5414 ok(hr == S_OK, "ret %08x\n", hr );
5415 ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
5416
5417 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
5418 ok(hr == S_OK, "ret %08x\n", hr );
5419 ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
5420
5421 hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
5422 ok(hr == S_OK, "ret %08x\n", hr );
5423 ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
5424
5425 SysFreeString(sEmpty);
5426 IXMLDOMImplementation_Release(pIXMLDOMImplementation);
5427 }
5428
5429 pRoot = (IXMLDOMElement*)0x1;
5430 hr = IXMLDOMDocument_createElement(doc, NULL, &pRoot);
5431 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5432 ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
5433
5434 pRoot = (IXMLDOMElement*)0x1;
5435 hr = IXMLDOMDocument_createElement(doc, _bstr_(""), &pRoot);
5436 ok(hr == E_FAIL, "ret %08x\n", hr );
5437 ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
5438
5439 hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
5440 ok(hr == S_OK, "ret %08x\n", hr );
5441 if(hr == S_OK)
5442 {
5443 hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
5444 ok(hr == S_OK, "ret %08x\n", hr );
5445 if(hr == S_OK)
5446 {
5447 /* Comment */
5448 str = SysAllocString(szComment);
5449 hr = IXMLDOMDocument_createComment(doc, str, &pComment);
5450 SysFreeString(str);
5451 ok(hr == S_OK, "ret %08x\n", hr );
5452 if(hr == S_OK)
5453 {
5454 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
5455 ok(hr == S_OK, "ret %08x\n", hr );
5456
5457 hr = IXMLDOMComment_get_nodeName(pComment, &str);
5458 ok(hr == S_OK, "ret %08x\n", hr );
5459 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
5460 SysFreeString(str);
5461
5462 hr = IXMLDOMComment_get_xml(pComment, &str);
5463 ok(hr == S_OK, "ret %08x\n", hr );
5464 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
5465 SysFreeString(str);
5466
5467 /* put data Tests */
5468 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
5469 ok(hr == S_OK, "ret %08x\n", hr );
5470
5471 /* get data Tests */
5472 hr = IXMLDOMComment_get_data(pComment, &str);
5473 ok(hr == S_OK, "ret %08x\n", hr );
5474 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
5475 SysFreeString(str);
5476
5477 /* Confirm XML text is good */
5478 hr = IXMLDOMComment_get_xml(pComment, &str);
5479 ok(hr == S_OK, "ret %08x\n", hr );
5480 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
5481 SysFreeString(str);
5482
5483 /* Confirm we get the put_data Text back */
5484 hr = IXMLDOMComment_get_text(pComment, &str);
5485 ok(hr == S_OK, "ret %08x\n", hr );
5486 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
5487 SysFreeString(str);
5488
5489 /* test length property */
5490 hr = IXMLDOMComment_get_length(pComment, &len);
5491 ok(hr == S_OK, "ret %08x\n", hr );
5492 ok(len == 21, "expected 21 got %d\n", len);
5493
5494 /* test substringData */
5495 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
5496 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5497
5498 /* test substringData - Invalid offset */
5499 str = (void *)0xdeadbeef;
5500 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
5501 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5502 ok( str == NULL, "incorrect string\n");
5503
5504 /* test substringData - Invalid offset */
5505 str = (void *)0xdeadbeef;
5506 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
5507 ok(hr == S_FALSE, "ret %08x\n", hr );
5508 ok( str == NULL, "incorrect string\n");
5509
5510 /* test substringData - Invalid size */
5511 str = (void *)0xdeadbeef;
5512 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
5513 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5514 ok( str == NULL, "incorrect string\n");
5515
5516 /* test substringData - Invalid size */
5517 str = (void *)0xdeadbeef;
5518 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
5519 ok(hr == S_FALSE, "ret %08x\n", hr );
5520 ok( str == NULL, "incorrect string\n");
5521
5522 /* test substringData - Start of string */
5523 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
5524 ok(hr == S_OK, "ret %08x\n", hr );
5525 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
5526 SysFreeString(str);
5527
5528 /* test substringData - Middle of string */
5529 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
5530 ok(hr == S_OK, "ret %08x\n", hr );
5531 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
5532 SysFreeString(str);
5533
5534 /* test substringData - End of string */
5535 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
5536 ok(hr == S_OK, "ret %08x\n", hr );
5537 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
5538 SysFreeString(str);
5539
5540 /* test appendData */
5541 hr = IXMLDOMComment_appendData(pComment, NULL);
5542 ok(hr == S_OK, "ret %08x\n", hr );
5543
5544 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
5545 ok(hr == S_OK, "ret %08x\n", hr );
5546
5547 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
5548 ok(hr == S_OK, "ret %08x\n", hr );
5549
5550 hr = IXMLDOMComment_get_text(pComment, &str);
5551 ok(hr == S_OK, "ret %08x\n", hr );
5552 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5553 SysFreeString(str);
5554
5555 /* test insertData */
5556 str = SysAllocStringLen(NULL, 0);
5557 hr = IXMLDOMComment_insertData(pComment, -1, str);
5558 ok(hr == S_OK, "ret %08x\n", hr );
5559
5560 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
5561 ok(hr == S_OK, "ret %08x\n", hr );
5562
5563 hr = IXMLDOMComment_insertData(pComment, 1000, str);
5564 ok(hr == S_OK, "ret %08x\n", hr );
5565
5566 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
5567 ok(hr == S_OK, "ret %08x\n", hr );
5568
5569 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
5570 ok(hr == S_OK, "ret %08x\n", hr );
5571
5572 hr = IXMLDOMComment_insertData(pComment, 0, str);
5573 ok(hr == S_OK, "ret %08x\n", hr );
5574 SysFreeString(str);
5575
5576 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
5577 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5578
5579 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
5580 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5581
5582 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
5583 ok(hr == S_OK, "ret %08x\n", hr );
5584
5585 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
5586 ok(hr == S_OK, "ret %08x\n", hr );
5587
5588 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
5589 ok(hr == S_OK, "ret %08x\n", hr );
5590
5591 hr = IXMLDOMComment_get_text(pComment, &str);
5592 ok(hr == S_OK, "ret %08x\n", hr );
5593 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5594 SysFreeString(str);
5595
5596 /* delete data */
5597 /* invalid arguments */
5598 hr = IXMLDOMComment_deleteData(pComment, -1, 1);
5599 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5600
5601 hr = IXMLDOMComment_deleteData(pComment, 0, 0);
5602 ok(hr == S_OK, "ret %08x\n", hr );
5603
5604 hr = IXMLDOMComment_deleteData(pComment, 0, -1);
5605 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5606
5607 hr = IXMLDOMComment_get_length(pComment, &len);
5608 ok(hr == S_OK, "ret %08x\n", hr );
5609 ok(len == 43, "expected 43 got %d\n", len);
5610
5611 hr = IXMLDOMComment_deleteData(pComment, len, 1);
5612 ok(hr == S_OK, "ret %08x\n", hr );
5613
5614 hr = IXMLDOMComment_deleteData(pComment, len+1, 1);
5615 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5616
5617 /* delete from start */
5618 hr = IXMLDOMComment_deleteData(pComment, 0, 5);
5619 ok(hr == S_OK, "ret %08x\n", hr );
5620
5621 hr = IXMLDOMComment_get_length(pComment, &len);
5622 ok(hr == S_OK, "ret %08x\n", hr );
5623 ok(len == 38, "expected 38 got %d\n", len);
5624
5625 hr = IXMLDOMComment_get_text(pComment, &str);
5626 ok(hr == S_OK, "ret %08x\n", hr );
5627 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5628 SysFreeString(str);
5629
5630 /* delete from end */
5631 hr = IXMLDOMComment_deleteData(pComment, 35, 3);
5632 ok(hr == S_OK, "ret %08x\n", hr );
5633
5634 hr = IXMLDOMComment_get_length(pComment, &len);
5635 ok(hr == S_OK, "ret %08x\n", hr );
5636 ok(len == 35, "expected 35 got %d\n", len);
5637
5638 hr = IXMLDOMComment_get_text(pComment, &str);
5639 ok(hr == S_OK, "ret %08x\n", hr );
5640 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5641 SysFreeString(str);
5642
5643 /* delete from inside */
5644 hr = IXMLDOMComment_deleteData(pComment, 1, 33);
5645 ok(hr == S_OK, "ret %08x\n", hr );
5646
5647 hr = IXMLDOMComment_get_length(pComment, &len);
5648 ok(hr == S_OK, "ret %08x\n", hr );
5649 ok(len == 2, "expected 2 got %d\n", len);
5650
5651 hr = IXMLDOMComment_get_text(pComment, &str);
5652 ok(hr == S_OK, "ret %08x\n", hr );
5653 ok( !lstrcmpW( str, _bstr_(" ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5654 SysFreeString(str);
5655
5656 /* delete whole data ... */
5657 hr = IXMLDOMComment_get_length(pComment, &len);
5658 ok(hr == S_OK, "ret %08x\n", hr );
5659
5660 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5661 ok(hr == S_OK, "ret %08x\n", hr );
5662 /* ... and try again with empty string */
5663 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5664 ok(hr == S_OK, "ret %08x\n", hr );
5665
5666 /* ::replaceData() */
5667 V_VT(&v) = VT_BSTR;
5668 V_BSTR(&v) = SysAllocString(szstr1);
5669 hr = IXMLDOMComment_put_nodeValue(pComment, v);
5670 ok(hr == S_OK, "ret %08x\n", hr );
5671 VariantClear(&v);
5672
5673 hr = IXMLDOMComment_replaceData(pComment, 6, 0, NULL);
5674 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5675 hr = IXMLDOMComment_get_text(pComment, &str);
5676 ok(hr == S_OK, "ret %08x\n", hr );
5677 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5678 SysFreeString(str);
5679
5680 hr = IXMLDOMComment_replaceData(pComment, 0, 0, NULL);
5681 ok(hr == S_OK, "ret %08x\n", hr );
5682 hr = IXMLDOMComment_get_text(pComment, &str);
5683 ok(hr == S_OK, "ret %08x\n", hr );
5684 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5685 SysFreeString(str);
5686
5687 /* NULL pointer means delete */
5688 hr = IXMLDOMComment_replaceData(pComment, 0, 1, NULL);
5689 ok(hr == S_OK, "ret %08x\n", hr );
5690 hr = IXMLDOMComment_get_text(pComment, &str);
5691 ok(hr == S_OK, "ret %08x\n", hr );
5692 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5693 SysFreeString(str);
5694
5695 /* empty string means delete */
5696 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_(""));
5697 ok(hr == S_OK, "ret %08x\n", hr );
5698 hr = IXMLDOMComment_get_text(pComment, &str);
5699 ok(hr == S_OK, "ret %08x\n", hr );
5700 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5701 SysFreeString(str);
5702
5703 /* zero count means insert */
5704 hr = IXMLDOMComment_replaceData(pComment, 0, 0, _bstr_("a"));
5705 ok(hr == S_OK, "ret %08x\n", hr );
5706 hr = IXMLDOMComment_get_text(pComment, &str);
5707 ok(hr == S_OK, "ret %08x\n", hr );
5708 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5709 SysFreeString(str);
5710
5711 hr = IXMLDOMComment_replaceData(pComment, 0, 2, NULL);
5712 ok(hr == S_OK, "ret %08x\n", hr );
5713
5714 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("m"));
5715 ok(hr == S_OK, "ret %08x\n", hr );
5716 hr = IXMLDOMComment_get_text(pComment, &str);
5717 ok(hr == S_OK, "ret %08x\n", hr );
5718 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5719 SysFreeString(str);
5720
5721 /* nonempty string, count greater than its length */
5722 hr = IXMLDOMComment_replaceData(pComment, 0, 2, _bstr_("a1.2"));
5723 ok(hr == S_OK, "ret %08x\n", hr );
5724 hr = IXMLDOMComment_get_text(pComment, &str);
5725 ok(hr == S_OK, "ret %08x\n", hr );
5726 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5727 SysFreeString(str);
5728
5729 /* nonempty string, count less than its length */
5730 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_("wine"));
5731 ok(hr == S_OK, "ret %08x\n", hr );
5732 hr = IXMLDOMComment_get_text(pComment, &str);
5733 ok(hr == S_OK, "ret %08x\n", hr );
5734 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5735 SysFreeString(str);
5736
5737 IXMLDOMComment_Release(pComment);
5738 }
5739
5740 /* Element */
5741 str = SysAllocString(szElement);
5742 hr = IXMLDOMDocument_createElement(doc, str, &pElement);
5743 SysFreeString(str);
5744 ok(hr == S_OK, "ret %08x\n", hr );
5745 if(hr == S_OK)
5746 {
5747 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5748 ok(hr == S_OK, "ret %08x\n", hr );
5749
5750 hr = IXMLDOMElement_get_nodeName(pElement, &str);
5751 ok(hr == S_OK, "ret %08x\n", hr );
5752 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
5753 SysFreeString(str);
5754
5755 hr = IXMLDOMElement_get_xml(pElement, &str);
5756 ok(hr == S_OK, "ret %08x\n", hr );
5757 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
5758 SysFreeString(str);
5759
5760 /* Attribute */
5761 pAttribute = (IXMLDOMAttribute*)0x1;
5762 hr = IXMLDOMDocument_createAttribute(doc, NULL, &pAttribute);
5763 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5764 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5765
5766 pAttribute = (IXMLDOMAttribute*)0x1;
5767 hr = IXMLDOMDocument_createAttribute(doc, _bstr_(""), &pAttribute);
5768 ok(hr == E_FAIL, "ret %08x\n", hr );
5769 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5770
5771 str = SysAllocString(szAttribute);
5772 hr = IXMLDOMDocument_createAttribute(doc, str, &pAttribute);
5773 SysFreeString(str);
5774 ok(hr == S_OK, "ret %08x\n", hr );
5775 if(hr == S_OK)
5776 {
5777 IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
5778
5779 hr = IXMLDOMAttribute_get_nextSibling(pAttribute, NULL);
5780 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5781
5782 pNextChild = (IXMLDOMNode *)0x1;
5783 hr = IXMLDOMAttribute_get_nextSibling(pAttribute, &pNextChild);
5784 ok(hr == S_FALSE, "ret %08x\n", hr );
5785 ok(pNextChild == NULL, "pNextChild not NULL\n");
5786
5787 /* test Previous Sibling*/
5788 hr = IXMLDOMAttribute_get_previousSibling(pAttribute, NULL);
5789 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5790
5791 pNextChild = (IXMLDOMNode *)0x1;
5792 hr = IXMLDOMAttribute_get_previousSibling(pAttribute, &pNextChild);
5793 ok(hr == S_FALSE, "ret %08x\n", hr );
5794 ok(pNextChild == NULL, "pNextChild not NULL\n");
5795
5796 hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttribute, &pNewChild);
5797 ok(hr == E_FAIL, "ret %08x\n", hr );
5798 ok(pNewChild == NULL, "pNewChild not NULL\n");
5799
5800 hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
5801 ok(hr == S_OK, "ret %08x\n", hr );
5802 if ( hr == S_OK )
5803 {
5804 hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttribute, NULL );
5805 ok(hr == S_OK, "ret %08x\n", hr );
5806
5807 IXMLDOMNamedNodeMap_Release(pAttribs);
5808 }
5809
5810 hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5811 ok(hr == S_OK, "ret %08x\n", hr );
5812 ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
5813 SysFreeString(str);
5814
5815 /* test nodeName */
5816 hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5817 ok(hr == S_OK, "ret %08x\n", hr );
5818 ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
5819 SysFreeString(str);
5820
5821 /* test name property */
5822 hr = IXMLDOMAttribute_get_name(pAttribute, &str);
5823 ok(hr == S_OK, "ret %08x\n", hr );
5824 ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
5825 SysFreeString(str);
5826
5827 hr = IXMLDOMAttribute_get_xml(pAttribute, &str);
5828 ok(hr == S_OK, "ret %08x\n", hr );
5829 ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
5830 SysFreeString(str);
5831
5832 IXMLDOMAttribute_Release(pAttribute);
5833
5834 /* Check Element again with the Add Attribute*/
5835 hr = IXMLDOMElement_get_xml(pElement, &str);
5836 ok(hr == S_OK, "ret %08x\n", hr );
5837 ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
5838 SysFreeString(str);
5839 }
5840
5841 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
5842 ok(hr == S_OK, "ret %08x\n", hr );
5843
5844 hr = IXMLDOMElement_get_xml(pElement, &str);
5845 ok(hr == S_OK, "ret %08x\n", hr );
5846 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
5847 SysFreeString(str);
5848
5849 /* Test for reversible escaping */
5850 str = SysAllocString( szStrangeChars );
5851 hr = IXMLDOMElement_put_text(pElement, str);
5852 ok(hr == S_OK, "ret %08x\n", hr );
5853 SysFreeString( str );
5854
5855 hr = IXMLDOMElement_get_xml(pElement, &str);
5856 ok(hr == S_OK, "ret %08x\n", hr );
5857 ok( !lstrcmpW( str, szElementXML4 ), "incorrect element xml\n");
5858 SysFreeString(str);
5859
5860 hr = IXMLDOMElement_get_text(pElement, &str);
5861 ok(hr == S_OK, "ret %08x\n", hr );
5862 ok( !lstrcmpW( str, szStrangeChars ), "incorrect element text\n");
5863 SysFreeString(str);
5864
5865 IXMLDOMElement_Release(pElement);
5866 }
5867
5868 /* CData Section */
5869 str = SysAllocString(szCData);
5870 hr = IXMLDOMDocument_createCDATASection(doc, str, NULL);
5871 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5872
5873 hr = IXMLDOMDocument_createCDATASection(doc, str, &pCDataSec);
5874 SysFreeString(str);
5875 ok(hr == S_OK, "ret %08x\n", hr );
5876 if(hr == S_OK)
5877 {
5878 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
5879 VARIANT var;
5880
5881 VariantInit(&var);
5882
5883 hr = IXMLDOMCDATASection_QueryInterface(pCDataSec, &IID_IXMLDOMElement, (void**)&pElement);
5884 ok(hr == E_NOINTERFACE, "ret %08x\n", hr);
5885
5886 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
5887 ok(hr == S_OK, "ret %08x\n", hr );
5888
5889 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
5890 ok(hr == S_OK, "ret %08x\n", hr );
5891 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
5892 SysFreeString(str);
5893
5894 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5895 ok(hr == S_OK, "ret %08x\n", hr );
5896 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
5897 SysFreeString(str);
5898
5899 /* test lastChild */
5900 pNextChild = (IXMLDOMNode*)0x1;
5901 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
5902 ok(hr == S_FALSE, "ret %08x\n", hr );
5903 ok(pNextChild == NULL, "pNextChild not NULL\n");
5904
5905 /* put data Tests */
5906 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
5907 ok(hr == S_OK, "ret %08x\n", hr );
5908
5909 /* Confirm XML text is good */
5910 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5911 ok(hr == S_OK, "ret %08x\n", hr );
5912 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
5913 SysFreeString(str);
5914
5915 /* Confirm we get the put_data Text back */
5916 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5917 ok(hr == S_OK, "ret %08x\n", hr );
5918 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5919 SysFreeString(str);
5920
5921 /* test length property */
5922 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5923 ok(hr == S_OK, "ret %08x\n", hr );
5924 ok(len == 21, "expected 21 got %d\n", len);
5925
5926 /* test get data */
5927 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
5928 ok(hr == S_OK, "ret %08x\n", hr );
5929 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5930 SysFreeString(str);
5931
5932 /* test substringData */
5933 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
5934 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5935
5936 /* test substringData - Invalid offset */
5937 str = (void *)0xdeadbeef;
5938 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
5939 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5940 ok( str == NULL, "incorrect string\n");
5941
5942 /* test substringData - Invalid offset */
5943 str = (void *)0xdeadbeef;
5944 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
5945 ok(hr == S_FALSE, "ret %08x\n", hr );
5946 ok( str == NULL, "incorrect string\n");
5947
5948 /* test substringData - Invalid size */
5949 str = (void *)0xdeadbeef;
5950 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
5951 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5952 ok( str == NULL, "incorrect string\n");
5953
5954 /* test substringData - Invalid size */
5955 str = (void *)0xdeadbeef;
5956 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
5957 ok(hr == S_FALSE, "ret %08x\n", hr );
5958 ok( str == NULL, "incorrect string\n");
5959
5960 /* test substringData - Start of string */
5961 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
5962 ok(hr == S_OK, "ret %08x\n", hr );
5963 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
5964 SysFreeString(str);
5965
5966 /* test substringData - Middle of string */
5967 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
5968 ok(hr == S_OK, "ret %08x\n", hr );
5969 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
5970 SysFreeString(str);
5971
5972 /* test substringData - End of string */
5973 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
5974 ok(hr == S_OK, "ret %08x\n", hr );
5975 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
5976 SysFreeString(str);
5977
5978 /* test appendData */
5979 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
5980 ok(hr == S_OK, "ret %08x\n", hr );
5981
5982 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
5983 ok(hr == S_OK, "ret %08x\n", hr );
5984
5985 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
5986 ok(hr == S_OK, "ret %08x\n", hr );
5987
5988 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5989 ok(hr == S_OK, "ret %08x\n", hr );
5990 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5991 SysFreeString(str);
5992
5993 /* test insertData */
5994 str = SysAllocStringLen(NULL, 0);
5995 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
5996 ok(hr == S_OK, "ret %08x\n", hr );
5997
5998 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
5999 ok(hr == S_OK, "ret %08x\n", hr );
6000
6001 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
6002 ok(hr == S_OK, "ret %08x\n", hr );
6003
6004 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
6005 ok(hr == S_OK, "ret %08x\n", hr );
6006
6007 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
6008 ok(hr == S_OK, "ret %08x\n", hr );
6009
6010 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
6011 ok(hr == S_OK, "ret %08x\n", hr );
6012 SysFreeString(str);
6013
6014 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
6015 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6016
6017 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
6018 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6019
6020 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
6021 ok(hr == S_OK, "ret %08x\n", hr );
6022
6023 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
6024 ok(hr == S_OK, "ret %08x\n", hr );
6025
6026 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
6027 ok(hr == S_OK, "ret %08x\n", hr );
6028
6029 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6030 ok(hr == S_OK, "ret %08x\n", hr );
6031 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6032 SysFreeString(str);
6033
6034 /* delete data */
6035 /* invalid arguments */
6036 hr = IXMLDOMCDATASection_deleteData(pCDataSec, -1, 1);
6037 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6038
6039 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 0);
6040 ok(hr == S_OK, "ret %08x\n", hr );
6041
6042 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, -1);
6043 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6044
6045 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6046 ok(hr == S_OK, "ret %08x\n", hr );
6047 ok(len == 43, "expected 43 got %d\n", len);
6048
6049 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len, 1);
6050 ok(hr == S_OK, "ret %08x\n", hr );
6051
6052 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len+1, 1);
6053 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6054
6055 /* delete from start */
6056 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 5);
6057 ok(hr == S_OK, "ret %08x\n", hr );
6058
6059 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6060 ok(hr == S_OK, "ret %08x\n", hr );
6061 ok(len == 38, "expected 38 got %d\n", len);
6062
6063 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6064 ok(hr == S_OK, "ret %08x\n", hr );
6065 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6066 SysFreeString(str);
6067
6068 /* delete from end */
6069 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 35, 3);
6070 ok(hr == S_OK, "ret %08x\n", hr );
6071
6072 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6073 ok(hr == S_OK, "ret %08x\n", hr );
6074 ok(len == 35, "expected 35 got %d\n", len);
6075
6076 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6077 ok(hr == S_OK, "ret %08x\n", hr );
6078 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6079 SysFreeString(str);
6080
6081 /* delete from inside */
6082 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 1, 33);
6083 ok(hr == S_OK, "ret %08x\n", hr );
6084
6085 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6086 ok(hr == S_OK, "ret %08x\n", hr );
6087 ok(len == 2, "expected 2 got %d\n", len);
6088
6089 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6090 ok(hr == S_OK, "ret %08x\n", hr );
6091 ok( !lstrcmpW( str, _bstr_(" ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6092 SysFreeString(str);
6093
6094 /* delete whole data ... */
6095 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6096 ok(hr == S_OK, "ret %08x\n", hr );
6097
6098 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
6099 ok(hr == S_OK, "ret %08x\n", hr );
6100
6101 /* ... and try again with empty string */
6102 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
6103 ok(hr == S_OK, "ret %08x\n", hr );
6104
6105 /* ::replaceData() */
6106 V_VT(&v) = VT_BSTR;
6107 V_BSTR(&v) = SysAllocString(szstr1);
6108 hr = IXMLDOMCDATASection_put_nodeValue(pCDataSec, v);
6109 ok(hr == S_OK, "ret %08x\n", hr );
6110 VariantClear(&v);
6111
6112 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 6, 0, NULL);
6113 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6114 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6115 ok(hr == S_OK, "ret %08x\n", hr );
6116 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6117 SysFreeString(str);
6118
6119 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, NULL);
6120 ok(hr == S_OK, "ret %08x\n", hr );
6121 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6122 ok(hr == S_OK, "ret %08x\n", hr );
6123 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6124 SysFreeString(str);
6125
6126 /* NULL pointer means delete */
6127 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, NULL);
6128 ok(hr == S_OK, "ret %08x\n", hr );
6129 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6130 ok(hr == S_OK, "ret %08x\n", hr );
6131 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6132 SysFreeString(str);
6133
6134 /* empty string means delete */
6135 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_(""));
6136 ok(hr == S_OK, "ret %08x\n", hr );
6137 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6138 ok(hr == S_OK, "ret %08x\n", hr );
6139 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6140 SysFreeString(str);
6141
6142 /* zero count means insert */
6143 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, _bstr_("a"));
6144 ok(hr == S_OK, "ret %08x\n", hr );
6145 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6146 ok(hr == S_OK, "ret %08x\n", hr );
6147 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6148 SysFreeString(str);
6149
6150 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, NULL);
6151 ok(hr == S_OK, "ret %08x\n", hr );
6152
6153 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("m"));
6154 ok(hr == S_OK, "ret %08x\n", hr );
6155 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6156 ok(hr == S_OK, "ret %08x\n", hr );
6157 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6158 SysFreeString(str);
6159
6160 /* nonempty string, count greater than its length */
6161 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, _bstr_("a1.2"));
6162 ok(hr == S_OK, "ret %08x\n", hr );
6163 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6164 ok(hr == S_OK, "ret %08x\n", hr );
6165 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6166 SysFreeString(str);
6167
6168 /* nonempty string, count less than its length */
6169 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_("wine"));
6170 ok(hr == S_OK, "ret %08x\n", hr );
6171 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6172 ok(hr == S_OK, "ret %08x\n", hr );
6173 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6174 SysFreeString(str);
6175
6176 IXMLDOMCDATASection_Release(pCDataSec);
6177 }
6178
6179 /* Document Fragments */
6180 hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
6181 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6182
6183 hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
6184 ok(hr == S_OK, "ret %08x\n", hr );
6185 if(hr == S_OK)
6186 {
6187 IXMLDOMNode *node;
6188
6189 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, NULL);
6190 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6191
6192 node = (IXMLDOMNode *)0x1;
6193 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, &node);
6194 ok(hr == S_FALSE, "ret %08x\n", hr );
6195 ok(node == NULL, "expected NULL, got %p\n", node);
6196
6197 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
6198 ok(hr == S_OK, "ret %08x\n", hr );
6199
6200 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
6201 ok(hr == S_OK, "ret %08x\n", hr );
6202 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
6203 SysFreeString(str);
6204
6205 /* test next Sibling*/
6206 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
6207 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6208
6209 node = (IXMLDOMNode *)0x1;
6210 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &node);
6211 ok(hr == S_FALSE, "ret %08x\n", hr );
6212 ok(node == NULL, "next sibling not NULL\n");
6213
6214 /* test Previous Sibling*/
6215 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
6216 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6217
6218 node = (IXMLDOMNode *)0x1;
6219 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &node);
6220 ok(hr == S_FALSE, "ret %08x\n", hr );
6221 ok(node == NULL, "previous sibling not NULL\n");
6222
6223 IXMLDOMDocumentFragment_Release(pDocFrag);
6224 }
6225
6226 /* Entity References */
6227 hr = IXMLDOMDocument_createEntityReference(doc, NULL, &pEntityRef);
6228 ok(hr == E_FAIL, "ret %08x\n", hr );
6229 hr = IXMLDOMDocument_createEntityReference(doc, _bstr_(""), &pEntityRef);
6230 ok(hr == E_FAIL, "ret %08x\n", hr );
6231
6232 str = SysAllocString(szEntityRef);
6233 hr = IXMLDOMDocument_createEntityReference(doc, str, NULL);
6234 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6235
6236 hr = IXMLDOMDocument_createEntityReference(doc, str, &pEntityRef);
6237 SysFreeString(str);
6238 ok(hr == S_OK, "ret %08x\n", hr );
6239 if(hr == S_OK)
6240 {
6241 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
6242 ok(hr == S_OK, "ret %08x\n", hr );
6243
6244 /* test get_xml*/
6245 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
6246 ok(hr == S_OK, "ret %08x\n", hr );
6247 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
6248 SysFreeString(str);
6249
6250 IXMLDOMEntityReference_Release(pEntityRef);
6251 }
6252
6253 IXMLDOMElement_Release( pRoot );
6254 }
6255 }
6256
6257 IXMLDOMDocument_Release(doc);
6258
6259 free_bstrs();
6260}
szCommentXML
static const WCHAR szCommentXML[]
Definition: domdoc.c:1168
szAttributeXML
static const WCHAR szAttributeXML[]
Definition: domdoc.c:1180
szCData
static const WCHAR szCData[]
Definition: domdoc.c:1182
szEntityRef
static const WCHAR szEntityRef[]
Definition: domdoc.c:1190
szElementXML3
static const WCHAR szElementXML3[]
Definition: domdoc.c:1174
szDocFragmentText
static const WCHAR szDocFragmentText[]
Definition: domdoc.c:1188
szElementXML
static const WCHAR szElementXML[]
Definition: domdoc.c:1172
szCDataNodeText
static const WCHAR szCDataNodeText[]
Definition: domdoc.c:1187
szCommentNodeText
static const WCHAR szCommentNodeText[]
Definition: domdoc.c:1169
szCDataXML
static const WCHAR szCDataXML[]
Definition: domdoc.c:1184
szStrangeChars
static const WCHAR szStrangeChars[]
Definition: domdoc.c:1192
szEntityRefXML
static const WCHAR szEntityRefXML[]
Definition: domdoc.c:1191
szElementXML4
static const WCHAR szElementXML4[]
Definition: domdoc.c:1176
szElementXML2
static const WCHAR szElementXML2[]
Definition: domdoc.c:1173
szElement
static WCHAR szElement[]
Definition: domdoc.c:1171

Referenced by START_TEST().

◆ test_XPath()

static void test_XPath ( void  )
static

Definition at line 4857 of file domdoc.c.

4858{
4859 const selection_ns_t *ptr = selection_ns_data;
4860 const xpath_test_t *xptest = xpath_test;
4861 VARIANT var;
4862 VARIANT_BOOL b;
4863 IXMLDOMDocument2 *doc;
4864 IXMLDOMDocument *doc2;
4865 IXMLDOMNode *rootNode;
4866 IXMLDOMNode *elem1Node;
4867 IXMLDOMNode *node;
4868 IXMLDOMNodeList *list;
4869 IXMLDOMElement *elem;
4870 IXMLDOMAttribute *attr;
4871 DOMNodeType type;
4872 HRESULT hr;
4873 LONG len;
4874 BSTR str;
4875
4876 if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
4877 doc = create_document(&IID_IXMLDOMDocument2);
4878
4879 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4880 EXPECT_HR(hr, S_OK);
4881 ok(b == VARIANT_TRUE, "failed to load XML string\n");
4882
4883 /* switch to XPath */
4884 ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4885
4886 /* some simple queries*/
4887 EXPECT_REF(doc, 1);
4888 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4889 EXPECT_HR(hr, S_OK);
4890 EXPECT_REF(doc, 1);
4891 EXPECT_LIST_LEN(list, 1);
4892
4893 EXPECT_REF(list, 1);
4894 hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4895 EXPECT_HR(hr, S_OK);
4896 EXPECT_REF(list, 1);
4897 EXPECT_REF(rootNode, 1);
4898
4899 hr = IXMLDOMNodeList_reset(list);
4900 EXPECT_HR(hr, S_OK);
4901 expect_list_and_release(list, "E2.D1");
4902
4903 /* peform xpath tests */
4904 for ( ; xptest->query ; xptest++ )
4905 {
4906 char *str;
4907
4908 hr = IXMLDOMNode_selectNodes(rootNode, _bstr_(xptest->query), &list);
4909 ok(hr == S_OK, "query evaluation failed for query=%s\n", xptest->query);
4910
4911 if (hr != S_OK)
4912 continue;
4913
4914 str = list_to_string(list);
4915
4916 ok(!strcmp(str, xptest->list), "query=%s, invalid node list: \"%s\", expected \"%s\"\n",
4917 xptest->query, str, xptest->list);
4918
4919 if (list)
4920 IXMLDOMNodeList_Release(list);
4921 }
4922
4923if (0)
4924{
4925 /* namespace:: axis test is disabled until namespace definitions
4926 are supported as attribute nodes, currently it's another node type */
4927 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("/root/namespace::*"), &list);
4928 EXPECT_HR(hr, S_OK);
4929 len = -1;
4930 hr = IXMLDOMNodeList_get_length(list, &len);
4931 EXPECT_HR(hr, S_OK);
4932 ok(len == 2, "got %d\n", len);
4933
4934 hr = IXMLDOMNodeList_nextNode(list, &node);
4935 EXPECT_HR(hr, S_OK);
4936 type = NODE_INVALID;
4937 hr = IXMLDOMNode_get_nodeType(node, &type);
4938 EXPECT_HR(hr, S_OK);
4939 ok(type == NODE_ATTRIBUTE, "got %d\n", type);
4940 IXMLDOMNode_Release(node);
4941
4942 IXMLDOMNodeList_Release(list);
4943}
4944
4945 ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//c"), &list));
4946 expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
4947
4948 ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//c[@type]"), &list));
4949 expect_list_and_release(list, "E3.E2.E2.D1");
4950
4951 ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
4952 /* using get_item for query results advances the position */
4953 ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
4954 expect_node(node, "E2.E2.D1");
4955 IXMLDOMNode_Release(node);
4956 ole_check(IXMLDOMNodeList_nextNode(list, &node));
4957 expect_node(node, "E4.E2.D1");
4958 IXMLDOMNode_Release(node);
4959 ole_check(IXMLDOMNodeList_reset(list));
4960 expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
4961
4962 ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
4963 expect_list_and_release(list, "E2.D1");
4964
4965 ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
4966 ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
4967 ole_check(IXMLDOMNodeList_reset(list));
4968 expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
4969
4970 /* select an attribute */
4971 ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
4972 expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
4973
4974 /* would evaluate to a number */
4975 ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
4976 /* would evaluate to a boolean */
4977 ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
4978 /* would evaluate to a string */
4979 ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
4980
4981 /* no results */
4982 ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
4983 expect_list_and_release(list, "");
4984 ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("elem//c"), &list));
4985 expect_list_and_release(list, "");
4986 ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem[4]"), &list));
4987 expect_list_and_release(list, "");
4988 ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[0]"), &list));
4989 expect_list_and_release(list, "");
4990
4991 /* foo undeclared in document node */
4992 ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4993 /* undeclared in <root> node */
4994 ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
4995 /* undeclared in <elem> node */
4996 ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
4997 /* but this trick can be used */
4998 ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
4999 expect_list_and_release(list, "E3.E4.E2.D1");
5000
5001 /* it has to be declared in SelectionNamespaces */
5002 ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5003 _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
5004
5005 /* now the namespace can be used */
5006 ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list));
5007 expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5008 ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
5009 expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5010 ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
5011 expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5012 ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
5013 expect_list_and_release(list, "E6.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1");
5014
5015 /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
5016 ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5017 _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
5018
5019 ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5020
5021 VariantInit(&var);
5022 ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
5023 expect_eq(V_VT(&var), VT_BSTR, int, "%x");
5024 if (V_VT(&var) == VT_BSTR)
5025 expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
5026
5027 /* extra attributes - same thing*/
5028 ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5029 _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
5030 ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5031
5032 IXMLDOMNode_Release(rootNode);
5033 IXMLDOMNode_Release(elem1Node);
5034
5035 /* alter document with already built list */
5036 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5037 EXPECT_HR(hr, S_OK);
5038 EXPECT_LIST_LEN(list, 1);
5039
5040 hr = IXMLDOMDocument2_get_lastChild(doc, &rootNode);
5041 EXPECT_HR(hr, S_OK);
5042 EXPECT_REF(rootNode, 1);
5043 EXPECT_REF(doc, 1);
5044
5045 hr = IXMLDOMDocument2_removeChild(doc, rootNode, NULL);
5046 EXPECT_HR(hr, S_OK);
5047 IXMLDOMNode_Release(rootNode);
5048
5049 EXPECT_LIST_LEN(list, 1);
5050
5051 hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5052 EXPECT_HR(hr, S_OK);
5053 EXPECT_REF(rootNode, 1);
5054
5055 IXMLDOMNodeList_Release(list);
5056
5057 hr = IXMLDOMNode_get_nodeName(rootNode, &str);
5058 EXPECT_HR(hr, S_OK);
5059 ok(!lstrcmpW(str, _bstr_("root")), "got %s\n", wine_dbgstr_w(str));
5060 SysFreeString(str);
5061 IXMLDOMNode_Release(rootNode);
5062
5063 /* alter node from list and get it another time */
5064 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5065 EXPECT_HR(hr, S_OK);
5066 ok(b == VARIANT_TRUE, "failed to load XML string\n");
5067
5068 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5069 EXPECT_HR(hr, S_OK);
5070 EXPECT_LIST_LEN(list, 1);
5071
5072 hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5073 EXPECT_HR(hr, S_OK);
5074
5075 hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
5076 EXPECT_HR(hr, S_OK);
5077
5078 V_VT(&var) = VT_I2;
5079 V_I2(&var) = 1;
5080 hr = IXMLDOMElement_setAttribute(elem, _bstr_("attrtest"), var);
5081 EXPECT_HR(hr, S_OK);
5082 IXMLDOMElement_Release(elem);
5083 IXMLDOMNode_Release(rootNode);
5084
5085 /* now check attribute to be present */
5086 hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5087 EXPECT_HR(hr, S_OK);
5088
5089 hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
5090 EXPECT_HR(hr, S_OK);
5091
5092 hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
5093 EXPECT_HR(hr, S_OK);
5094 IXMLDOMAttribute_Release(attr);
5095
5096 IXMLDOMElement_Release(elem);
5097 IXMLDOMNode_Release(rootNode);
5098
5099 /* and now check for attribute in original document */
5100 hr = IXMLDOMDocument2_get_documentElement(doc, &elem);
5101 EXPECT_HR(hr, S_OK);
5102
5103 hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
5104 EXPECT_HR(hr, S_OK);
5105 IXMLDOMAttribute_Release(attr);
5106
5107 IXMLDOMElement_Release(elem);
5108
5109 /* attach node from list to another document */
5110 doc2 = create_document(&IID_IXMLDOMDocument);
5111
5112 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5113 EXPECT_HR(hr, S_OK);
5114 ok(b == VARIANT_TRUE, "failed to load XML string\n");
5115
5116 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5117 EXPECT_HR(hr, S_OK);
5118 EXPECT_LIST_LEN(list, 1);
5119
5120 hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5121 EXPECT_HR(hr, S_OK);
5122 EXPECT_REF(rootNode, 1);
5123
5124 hr = IXMLDOMDocument_appendChild(doc2, rootNode, NULL);
5125 EXPECT_HR(hr, S_OK);
5126 EXPECT_REF(rootNode, 1);
5127 EXPECT_REF(doc2, 1);
5128 EXPECT_REF(list, 1);
5129
5130 EXPECT_LIST_LEN(list, 1);
5131
5132 IXMLDOMNode_Release(rootNode);
5133 IXMLDOMNodeList_Release(list);
5134 IXMLDOMDocument_Release(doc2);
5135 IXMLDOMDocument2_Release(doc);
5136
5137 while (ptr->clsid)
5138 {
5139 if (is_clsid_supported(ptr->clsid, &IID_IXMLDOMDocument2))
5140 {
5141 hr = CoCreateInstance(ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
5142 ok(hr == S_OK, "got 0x%08x\n", hr);
5143 }
5144 else
5145 {
5146 ptr++;
5147 continue;
5148 }
5149
5150 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5151 EXPECT_HR(hr, S_OK);
5152 ok(b == VARIANT_TRUE, "failed to load, %s\n", ptr->name);
5153
5154 hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath"));
5155 EXPECT_HR(hr, S_OK);
5156
5157 V_VT(&var) = VT_BSTR;
5158 V_BSTR(&var) = _bstr_(ptr->ns);
5159
5160 hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), var);
5161 ok(hr == ptr->hr, "got 0x%08x, for %s, %s\n", hr, ptr->name, ptr->ns);
5162
5163 V_VT(&var) = VT_EMPTY;
5164 hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var);
5165 EXPECT_HR(hr, S_OK);
5166 ok(V_VT(&var) == VT_BSTR, "got wrong property type %d\n", V_VT(&var));
5167 ok(!lstrcmpW(V_BSTR(&var), _bstr_(ptr->ns)), "got wrong value %s\n", wine_dbgstr_w(V_BSTR(&var)));
5168 VariantClear(&var);
5169
5170 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list);
5171 EXPECT_HR(hr, S_OK);
5172 if (hr == S_OK)
5173 expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5174
5175 IXMLDOMDocument2_Release(doc);
5176 ptr++;
5177 free_bstrs();
5178 }
5179
5180 free_bstrs();
5181}
EXPECT_LIST_LEN
#define EXPECT_LIST_LEN(list, len)
Definition: domdoc.c:688
selection_ns_data
static const selection_ns_t selection_ns_data[]
Definition: domdoc.c:4788
xpath_test
static const xpath_test_t xpath_test[]
Definition: domdoc.c:4822
selection_ns_t
Definition: domdoc.c:4780
xpath_test_t
Definition: domdoc.c:4817
xpath_test_t::list
const char * list
Definition: domdoc.c:4819
xpath_test_t::query
const char * query
Definition: domdoc.c:4818

Referenced by START_TEST().

◆ test_XSLPattern()

static void test_XSLPattern ( void  )
static

Definition at line 7378 of file domdoc.c.

7379{
7380 const xslpattern_test_t *ptr = xslpattern_test;
7381 IXMLDOMDocument2 *doc;
7382 IXMLDOMNodeList *list;
7383 VARIANT_BOOL b;
7384 HRESULT hr;
7385 LONG len;
7386
7387 doc = create_document(&IID_IXMLDOMDocument2);
7388
7389 b = VARIANT_FALSE;
7390 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
7391 EXPECT_HR(hr, S_OK);
7392 ok(b == VARIANT_TRUE, "failed to load XML string\n");
7393
7394 /* switch to XSLPattern */
7395 hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern"));
7396 EXPECT_HR(hr, S_OK);
7397
7398 /* XPath doesn't select elements with non-null default namespace with unqualified selectors, XSLPattern does */
7399 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem/c"), &list);
7400 EXPECT_HR(hr, S_OK);
7401
7402 len = 0;
7403 hr = IXMLDOMNodeList_get_length(list, &len);
7404 EXPECT_HR(hr, S_OK);
7405 /* should select <elem><c> and <elem xmlns='...'><c> but not <elem><foo:c> */
7406 ok(len == 3, "expected 3 entries in list, got %d\n", len);
7407 IXMLDOMNodeList_Release(list);
7408
7409 while (ptr->query)
7410 {
7411 list = NULL;
7412 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
7413 ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7414 len = 0;
7415 hr = IXMLDOMNodeList_get_length(list, &len);
7416 ok(len != 0, "query=%s, empty list\n", ptr->query);
7417 if (len) {
7418 if (ptr->todo) {
7419 char *str = list_to_string(list);
7420 todo_wine
7421 ok(!strcmp(str, ptr->list), "Invalid node list: %s, expected %s\n", str, ptr->list);
7422 IXMLDOMNodeList_Release(list);
7423 }
7424 else
7425 expect_list_and_release(list, ptr->list);
7426 }
7427
7428 ptr++;
7429 }
7430
7431 /* namespace handling */
7432 /* no registered namespaces */
7433 hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_(""));
7434 EXPECT_HR(hr, S_OK);
7435
7436 ptr = xslpattern_test_no_ns;
7437 while (ptr->query)
7438 {
7439 list = NULL;
7440 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
7441 ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7442
7443 if (*ptr->list)
7444 {
7445 len = 0;
7446 hr = IXMLDOMNodeList_get_length(list, &len);
7447 EXPECT_HR(hr, S_OK);
7448 ok(len != 0, "query=%s, empty list\n", ptr->query);
7449 }
7450 else
7451 {
7452 len = 1;
7453 hr = IXMLDOMNodeList_get_length(list, &len);
7454 EXPECT_HR(hr, S_OK);
7455 ok(len == 0, "query=%s, empty list\n", ptr->query);
7456 }
7457 if (len)
7458 expect_list_and_release(list, ptr->list);
7459
7460 ptr++;
7461 }
7462
7463 /* explicitly register prefix foo */
7464 ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
7465
7466 /* now we get the same behavior as XPath */
7467 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
7468 EXPECT_HR(hr, S_OK);
7469 len = 0;
7470 hr = IXMLDOMNodeList_get_length(list, &len);
7471 EXPECT_HR(hr, S_OK);
7472 ok(len != 0, "expected filled list\n");
7473 if (len)
7474 expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
7475
7476 /* set prefix foo to some nonexistent namespace */
7477 hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:nonexistent-foo'"));
7478 EXPECT_HR(hr, S_OK);
7479
7480 /* the registered prefix takes precedence */
7481 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
7482 EXPECT_HR(hr, S_OK);
7483 len = 0;
7484 hr = IXMLDOMNodeList_get_length(list, &len);
7485 EXPECT_HR(hr, S_OK);
7486 ok(len == 0, "expected empty list\n");
7487 IXMLDOMNodeList_Release(list);
7488
7489 IXMLDOMDocument2_Release(doc);
7490
7491 doc = create_document(&IID_IXMLDOMDocument2);
7492
7493 hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNodeTypesXML), &b);
7494 EXPECT_HR(hr, S_OK);
7495 ok(b == VARIANT_TRUE, "failed to load XML string\n");
7496
7497 ptr = xslpattern_test_func;
7498 while (ptr->query)
7499 {
7500 list = NULL;
7501 hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
7502 if (ptr->list)
7503 {
7504 ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7505 len = 0;
7506 hr = IXMLDOMNodeList_get_length(list, &len);
7507 ok(hr == S_OK, "Failed to get list length, hr %#x.\n", hr);
7508 if (*ptr->list)
7509 {
7510 ok(len != 0, "query=%s, empty list\n", ptr->query);
7511 if (len)
7512 expect_list_and_release(list, ptr->list);
7513 }
7514 else
7515 ok(len == 0, "query=%s, filled list\n", ptr->query);
7516 }
7517 else
7518 ok(hr == E_FAIL, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7519
7520 ptr++;
7521 }
7522
7523 IXMLDOMDocument2_Release(doc);
7524 free_bstrs();
7525}
szNodeTypesXML
static const CHAR szNodeTypesXML[]
Definition: domdoc.c:828
xslpattern_test_no_ns
static const xslpattern_test_t xslpattern_test_no_ns[]
Definition: domdoc.c:7343
xslpattern_test
static const xslpattern_test_t xslpattern_test[]
Definition: domdoc.c:7279
xslpattern_test_func
static const xslpattern_test_t xslpattern_test_func[]
Definition: domdoc.c:7352
xslpattern_test_t
Definition: domdoc.c:7273

Referenced by START_TEST().

◆ test_xsltemplate()

static void test_xsltemplate ( void  )
static

Definition at line 8837 of file domdoc.c.

8838{
8839 IXMLDOMDocument *doc, *doc2, *doc3;
8840 IXSLTemplate *template;
8841 IXSLProcessor *processor;
8842 IStream *stream;
8843 VARIANT_BOOL b;
8844 HRESULT hr;
8845 ULONG ref1, ref2;
8846 VARIANT v;
8847 BSTR str;
8848
8849 if (!is_clsid_supported(&CLSID_XSLTemplate, &IID_IXSLTemplate)) return;
8850 template = create_xsltemplate(&IID_IXSLTemplate);
8851
8852 /* works as reset */
8853 hr = IXSLTemplate_putref_stylesheet(template, NULL);
8854 ok(hr == S_OK, "got 0x%08x\n", hr);
8855
8856 doc = create_document(&IID_IXMLDOMDocument);
8857
8858 b = VARIANT_TRUE;
8859 hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8860 ok(hr == S_OK, "got 0x%08x\n", hr);
8861 ok( b == VARIANT_TRUE, "got %d\n", b);
8862
8863 /* putref with non-xsl document */
8864 hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8865 todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8866
8867 b = VARIANT_TRUE;
8868 hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8869 ok(hr == S_OK, "got 0x%08x\n", hr);
8870 ok( b == VARIANT_TRUE, "got %d\n", b);
8871
8872 /* not a freethreaded document */
8873 hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8874 todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8875
8876 IXMLDOMDocument_Release(doc);
8877
8878 if (!is_clsid_supported(&CLSID_FreeThreadedDOMDocument, &IID_IXMLDOMDocument))
8879 {
8880 IXSLTemplate_Release(template);
8881 return;
8882 }
8883
8884 hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
8885 ok(hr == S_OK, "got 0x%08x\n", hr);
8886
8887 b = VARIANT_TRUE;
8888 hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8889 ok(hr == S_OK, "got 0x%08x\n", hr);
8890 ok( b == VARIANT_TRUE, "got %d\n", b);
8891
8892 /* freethreaded document */
8893 ref1 = IXMLDOMDocument_AddRef(doc);
8894 IXMLDOMDocument_Release(doc);
8895 hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8896 ok(hr == S_OK, "got 0x%08x\n", hr);
8897 ref2 = IXMLDOMDocument_AddRef(doc);
8898 IXMLDOMDocument_Release(doc);
8899 ok(ref2 > ref1, "got %d\n", ref2);
8900
8901 /* processor */
8902 hr = IXSLTemplate_createProcessor(template, NULL);
8903 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8904
8905 EXPECT_REF(template, 1);
8906 hr = IXSLTemplate_createProcessor(template, &processor);
8907 ok(hr == S_OK, "got 0x%08x\n", hr);
8908 EXPECT_REF(template, 2);
8909
8910 /* input no set yet */
8911 V_VT(&v) = VT_BSTR;
8912 V_BSTR(&v) = NULL;
8913 hr = IXSLProcessor_get_input(processor, &v);
8914todo_wine {
8915 ok(hr == S_OK, "got 0x%08x\n", hr);
8916 ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
8917}
8918
8919 hr = IXSLProcessor_get_output(processor, NULL);
8920 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8921
8922 /* reset before it was set */
8923 V_VT(&v) = VT_EMPTY;
8924 hr = IXSLProcessor_put_output(processor, v);
8925 ok(hr == S_OK, "got 0x%08x\n", hr);
8926
8927 V_VT(&v) = VT_UNKNOWN;
8928 V_UNKNOWN(&v) = NULL;
8929 hr = IXSLProcessor_put_output(processor, v);
8930 ok(hr == S_OK, "got 0x%08x\n", hr);
8931
8932 V_VT(&v) = VT_UNKNOWN;
8933 V_DISPATCH(&v) = NULL;
8934 hr = IXSLProcessor_put_output(processor, v);
8935 ok(hr == S_OK, "got 0x%08x\n", hr);
8936
8937 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
8938 ok(hr == S_OK, "got 0x%08x\n", hr);
8939 EXPECT_REF(stream, 1);
8940
8941 V_VT(&v) = VT_UNKNOWN;
8942 V_UNKNOWN(&v) = (IUnknown*)stream;
8943 hr = IXSLProcessor_put_output(processor, v);
8944 ok(hr == S_OK, "got 0x%08x\n", hr);
8945
8946 /* it seems processor grabs 2 references */
8947 todo_wine EXPECT_REF(stream, 3);
8948
8949 V_VT(&v) = VT_EMPTY;
8950 hr = IXSLProcessor_get_output(processor, &v);
8951 ok(hr == S_OK, "got 0x%08x\n", hr);
8952 ok(V_VT(&v) == VT_UNKNOWN, "got type %d\n", V_VT(&v));
8953 ok(V_UNKNOWN(&v) == (IUnknown*)stream, "got %p\n", V_UNKNOWN(&v));
8954
8955 todo_wine EXPECT_REF(stream, 4);
8956 VariantClear(&v);
8957
8958 hr = IXSLProcessor_transform(processor, NULL);
8959 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8960
8961 /* reset and check stream refcount */
8962 V_VT(&v) = VT_EMPTY;
8963 hr = IXSLProcessor_put_output(processor, v);
8964 ok(hr == S_OK, "got 0x%08x\n", hr);
8965
8966 EXPECT_REF(stream, 1);
8967
8968 IStream_Release(stream);
8969
8970 /* no output interface set, check output */
8971 doc2 = create_document(&IID_IXMLDOMDocument);
8972
8973 b = VARIANT_FALSE;
8974 hr = IXMLDOMDocument_loadXML( doc2, _bstr_("<a>test</a>"), &b );
8975 ok(hr == S_OK, "got 0x%08x\n", hr);
8976 ok( b == VARIANT_TRUE, "got %d\n", b);
8977
8978 V_VT(&v) = VT_UNKNOWN;
8979 V_UNKNOWN(&v) = (IUnknown*)doc2;
8980 hr = IXSLProcessor_put_input(processor, v);
8981 ok(hr == S_OK, "got 0x%08x\n", hr);
8982
8983 hr = IXSLProcessor_transform(processor, &b);
8984 ok(hr == S_OK, "got 0x%08x\n", hr);
8985
8986 V_VT(&v) = VT_EMPTY;
8987 hr = IXSLProcessor_get_output(processor, &v);
8988 ok(hr == S_OK, "got 0x%08x\n", hr);
8989 ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8990 ok(*V_BSTR(&v) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8991 VariantClear(&v);
8992
8993 /* transform to document */
8994 b = VARIANT_FALSE;
8995 hr = IXMLDOMDocument_loadXML(doc2, _bstr_(szTransformXML), &b);
8996 ok(hr == S_OK, "got 0x%08x\n", hr);
8997 ok(b == VARIANT_TRUE, "got %d\n", b);
8998
8999 V_VT(&v) = VT_UNKNOWN;
9000 V_UNKNOWN(&v) = (IUnknown*)doc2;
9001 hr = IXSLProcessor_put_input(processor, v);
9002 ok(hr == S_OK, "got 0x%08x\n", hr);
9003
9004 doc3 = create_document(&IID_IXMLDOMDocument);
9005 V_VT(&v) = VT_UNKNOWN;
9006 V_UNKNOWN(&v) = (IUnknown *)doc3;
9007 hr = IXSLProcessor_put_output(processor, v);
9008 ok(hr == S_OK, "got 0x%08x\n", hr);
9009
9010 hr = IXMLDOMDocument_get_xml(doc3, &str);
9011 ok(hr == S_OK, "got 0x%08x\n", hr);
9012 ok(!*str, "Expected empty document\n");
9013 SysFreeString(str);
9014
9015 hr = IXSLProcessor_transform(processor, &b);
9016 ok(hr == S_OK, "got 0x%08x\n", hr);
9017
9018 V_VT(&v) = VT_EMPTY;
9019 hr = IXSLProcessor_get_output(processor, &v);
9020 ok(hr == S_OK, "got 0x%08x\n", hr);
9021 ok(V_VT(&v) == VT_UNKNOWN, "got type %d\n", V_VT(&v));
9022 VariantClear(&v);
9023
9024 hr = IXMLDOMDocument_get_xml(doc3, &str);
9025 ok(hr == S_OK, "got 0x%08x\n", hr);
9026 ok(!!*str, "Expected document\n");
9027 SysFreeString(str);
9028
9029 /* transform to IResponse */
9030 V_VT(&v) = VT_EMPTY;
9031 hr = IXSLProcessor_put_output(processor, v);
9032 ok(hr == S_OK, "got 0x%08x\n", hr);
9033
9034 V_VT(&v) = VT_UNKNOWN;
9035 V_UNKNOWN(&v) = (IUnknown *)&testresponse;
9036 hr = IXSLProcessor_put_output(processor, v);
9037 ok(hr == S_OK, "got 0x%08x\n", hr);
9038
9039 b = VARIANT_FALSE;
9040 hr = IXSLProcessor_transform(processor, &b);
9041 ok(hr == S_OK, "got 0x%08x\n", hr);
9042 ok(b == VARIANT_TRUE, "got %x\n", b);
9043
9044 IXSLProcessor_Release(processor);
9045 IXMLDOMDocument_Release(doc2);
9046 IXMLDOMDocument_Release(doc3);
9047
9048 /* drop reference */
9049 hr = IXSLTemplate_putref_stylesheet(template, NULL);
9050 ok(hr == S_OK, "got 0x%08x\n", hr);
9051 ref2 = IXMLDOMDocument_AddRef(doc);
9052 IXMLDOMDocument_Release(doc);
9053 ok(ref2 == ref1, "got %d\n", ref2);
9054
9055 IXMLDOMDocument_Release(doc);
9056 IXSLTemplate_Release(template);
9057 free_bstrs();
9058}
testresponse
static IResponse testresponse
Definition: domdoc.c:653

Referenced by START_TEST().

◆ test_xsltext()

static void test_xsltext ( void  )
static

Definition at line 12540 of file domdoc.c.

12541{
12542 IXMLDOMDocument *doc, *doc2;
12543 VARIANT_BOOL b;
12544 HRESULT hr;
12545 BSTR ret;
12546
12547 doc = create_document(&IID_IXMLDOMDocument);
12548 doc2 = create_document(&IID_IXMLDOMDocument);
12549
12550 hr = IXMLDOMDocument_loadXML(doc, _bstr_(xsltext_xsl), &b);
12551 EXPECT_HR(hr, S_OK);
12552
12553 hr = IXMLDOMDocument_loadXML(doc2, _bstr_("<testkey/>"), &b);
12554 EXPECT_HR(hr, S_OK);
12555
12556 hr = IXMLDOMDocument_transformNode(doc2, (IXMLDOMNode*)doc, &ret);
12557 EXPECT_HR(hr, S_OK);
12558 ok(!lstrcmpW(ret, _bstr_("testdata")), "transform result %s\n", wine_dbgstr_w(ret));
12559 SysFreeString(ret);
12560
12561 /* omit-xml-declaration */
12562 hr = IXMLDOMDocument_loadXML(doc, _bstr_(omitxmldecl_xsl), &b);
12563 ok(hr == S_OK, "got 0x%08x\n", hr);
12564 hr = IXMLDOMDocument_loadXML(doc2, _bstr_(omitxmldecl_doc), &b);
12565 ok(hr == S_OK, "got 0x%08x\n", hr);
12566
12567 hr = IXMLDOMDocument_transformNode(doc2, (IXMLDOMNode*)doc, &ret);
12568 ok(hr == S_OK, "got 0x%08x\n", hr);
12569 ok(!lstrcmpW(ret, _bstr_("<node>item1</node><node>item2</node>")), "transform result %s\n", wine_dbgstr_w(ret));
12570 SysFreeString(ret);
12571
12572 IXMLDOMDocument_Release(doc2);
12573 IXMLDOMDocument_Release(doc);
12574 free_bstrs();
12575}
xsltext_xsl
static const char xsltext_xsl[]
Definition: domdoc.c:12507
omitxmldecl_xsl
static const char omitxmldecl_xsl[]
Definition: domdoc.c:12520
omitxmldecl_doc
static const char omitxmldecl_doc[]
Definition: domdoc.c:12533

Referenced by START_TEST().

◆ transformdest_AddRef()

static ULONG WINAPI transformdest_AddRef ( IUnknown *  iface)
static

Definition at line 12770 of file domdoc.c.

12771{
12772 return 2;
12773}

◆ transformdest_QueryInterface()

static HRESULT WINAPI transformdest_QueryInterface ( IUnknown *  iface,
REFIID  riid,
void **  obj 
)
static

Definition at line 12755 of file domdoc.c.

12756{
12757 BOOL known_iid = IsEqualIID(riid, &IID_IHTMLObjectElement) ||
12758 IsEqualIID(riid, &IID_transformdest_unknown) ||
12759 IsEqualIID(riid, &IID_IServiceProvider) ||
12760 IsEqualIID(riid, &IID_IStream) ||
12761 IsEqualIID(riid, &IID_ISequentialStream) ||
12762 IsEqualIID(riid, &IID_IRequestDictionary);
12763
12764todo_wine_if(IsEqualIID(riid, &IID_IXMLDOMDocument))
12765 ok(known_iid, "Unexpected riid %s\n", wine_dbgstr_guid(riid));
12766
12767 return E_NOINTERFACE;
12768}
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
todo_wine_if
#define todo_wine_if(is_todo)
Definition: custom.c:86

◆ transformdest_Release()

static ULONG WINAPI transformdest_Release ( IUnknown *  iface)
static

Definition at line 12775 of file domdoc.c.

12776{
12777 return 1;
12778}

◆ url_forward_slash()

static void url_forward_slash ( char *  url)
static

Definition at line 10235 of file domdoc.c.

10236{
10237 char *p = url;
10238
10239 while (*p)
10240 {
10241 if (*p == '\\')
10242 *p = '/';
10243 p++;
10244 }
10245}

Referenced by test_load().

◆ write_to_file()

static void write_to_file ( const char *  name,
const char *  data 
)
static

Definition at line 10176 of file domdoc.c.

10177{
10178 DWORD written;
10179 HANDLE hfile;
10180 BOOL ret;
10181
10182 hfile = CreateFileA(name, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
10183 ok(hfile != INVALID_HANDLE_VALUE, "failed to create test file: %s\n", name);
10184
10185 ret = WriteFile(hfile, data, strlen(data), &written, NULL);
10186 ok(ret, "WriteFile failed: %s, %d\n", name, GetLastError());
10187
10188 CloseHandle(hfile);
10189}

Referenced by test_load().

Variable Documentation

◆ alloced_bstrs

BSTR alloced_bstrs[256]
static

Definition at line 1241 of file domdoc.c.

Referenced by _bstr_(), and free_bstrs().

◆ alloced_bstrs_count

int alloced_bstrs_count
static

Definition at line 1242 of file domdoc.c.

Referenced by _bstr_(), and free_bstrs().

◆ attributes_map

const char attributes_map[]
static
Initial value:
= {
"<?xml version=\"1.0\"?>"
"<a attr1=\"value1\" attr2=\"value2\" attr3=\"value3\" attr4=\"value4\" />"
}

Definition at line 1142 of file domdoc.c.

Referenced by test_namedmap_newenum().

◆ attrtests

struct attrtest_t attrtests[]
static
Initial value:
= {
{ "xmlns", "http://www.w3.org/2000/xmlns/", "xmlns", "xmlns" },
{ "xmlns", "nondefaulturi", "xmlns", "xmlns" },
{ "c", "http://www.w3.org/2000/xmlns/", NULL, "http://www.w3.org/2000/xmlns/" },
{ "c", "nsref1", NULL, "nsref1" },
{ "ns:c", "nsref1", "ns", "nsref1" },
{ "xmlns:c", "http://www.w3.org/2000/xmlns/", "xmlns", "" },
{ "xmlns:c", "nondefaulturi", "xmlns", "" },
{ 0 }
}

Definition at line 12584 of file domdoc.c.

Referenced by test_create_attribute().

◆ charrefsxml

const char charrefsxml[]
static
Initial value:
=
"<?xml version='1.0'?>"
"<a>"
"<b1> Text &#65; end </b1>"
"<b2>&#65;&#66; &#67; </b2>"
"</a>"

Definition at line 821 of file domdoc.c.

Referenced by test_preserve_charref().

◆ complete4A

const char complete4A[]
static
Initial value:
=
"<?xml version=\'1.0\'?>\n"
"<lc dl=\'str1\'>\n"
"<bs vr=\'str2\' sz=\'1234\'>"
"fn1.txt\n"
"</bs>\n"
"<pr id=\'str3\' vr=\'1.2.3\' pn=\'wine 20050804\'>\n"
"fn2.txt\n"
"</pr>\n"
"<empty></empty>\n"
"<fo>\n"
"<ba>\n"
"f1\n"
"</ba>\n"
"</fo>\n"
"</lc>\n"

Definition at line 723 of file domdoc.c.

Referenced by test_cloneNode(), test_domdoc(), test_domnode(), test_get_attributes(), test_get_childNodes(), test_get_firstChild(), test_get_lastChild(), test_get_ownerDocument(), test_get_text(), test_getElementsByTagName(), test_getQualifiedItem(), test_IXMLDOMDocument2(), test_refs(), test_removeChild(), test_removeNamedItem(), test_removeQualifiedItem(), test_replaceChild(), test_selectSingleNode(), test_setAttributeNode(), and test_supporterrorinfo().

◆ complete7

const char complete7[]
static
Initial value:
= {
"<?xml version=\"1.0\"?>\n\t"
"<root>\n"
"\t<a/>\n"
"\t<b/>\n"
"\t<c/>\n"
"</root>"
}

Definition at line 760 of file domdoc.c.

Referenced by test_whitespace().

◆ default_ns_doc

const char default_ns_doc[]
static
Initial value:
= {
"<?xml version=\"1.0\"?>"
"<a xmlns:ns=\"nshref\" xml:lang=\"ru\" ns:b=\"b attr\" xml:c=\"c attr\" "
" d=\"d attr\" />"
}

Definition at line 1136 of file domdoc.c.

Referenced by test_getQualifiedItem().

◆ dispeventVtbl

const IDispatchVtbl dispeventVtbl
static
Initial value:
=
{
dispevent_QueryInterface,
dispevent_AddRef,
dispevent_Release,
dispevent_GetTypeInfoCount,
dispevent_GetTypeInfo,
dispevent_GetIDsOfNames,
dispevent_Invoke
}
dispevent_GetTypeInfo
static HRESULT WINAPI dispevent_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: domdoc.c:188
dispevent_Invoke
static HRESULT WINAPI dispevent_Invoke(IDispatch *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepInfo, UINT *argErr)
Definition: domdoc.c:202
dispevent_AddRef
static ULONG WINAPI dispevent_AddRef(IDispatch *iface)
Definition: domdoc.c:164
dispevent_QueryInterface
static HRESULT WINAPI dispevent_QueryInterface(IDispatch *iface, REFIID riid, void **ppvObject)
Definition: domdoc.c:147
dispevent_GetTypeInfoCount
static HRESULT WINAPI dispevent_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
Definition: domdoc.c:181
dispevent_GetIDsOfNames
static HRESULT WINAPI dispevent_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: domdoc.c:195
dispevent_Release
static ULONG WINAPI dispevent_Release(IDispatch *iface)
Definition: domdoc.c:170

Definition at line 223 of file domdoc.c.

Referenced by create_dispevent().

◆ domdoc_support_data

struct msxmlsupported_data_t domdoc_support_data[]
static
Initial value:
=
{
{ &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 }
}
CLSID_DOMDocument
const struct _GUID CLSID_DOMDocument

Definition at line 62 of file domdoc.c.

Referenced by is_clsid_supported(), START_TEST(), and test_newline_normalization().

◆ elementsbytagname

const struct queryresult_t elementsbytagname[]
static
Initial value:
= {
{ "", "P1.D1 E2.D1 E1.E2.D1 T1.E1.E2.D1 E2.E2.D1 T1.E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1 T1.E1.E4.E2.D1", 10 },
{ "*", "E2.D1 E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1", 6 },
{ "bs", "E1.E2.D1", 1 },
{ "dl", "", 0 },
{ "str1","", 0 },
{ NULL }
}

Definition at line 3347 of file domdoc.c.

Referenced by test_getElementsByTagName().

◆ g_expectedcall

int g_expectedcall
static

Definition at line 52 of file domdoc.c.

Referenced by dispevent_Invoke().

◆ g_unexpectedcall

int g_unexpectedcall
static

Definition at line 52 of file domdoc.c.

Referenced by dispevent_GetIDsOfNames(), dispevent_GetTypeInfo(), and dispevent_GetTypeInfoCount().

◆ get_attributes

const get_attributes_t get_attributes[]
static
Initial value:
= {
{ NODE_ATTRIBUTE, S_FALSE },
{ NODE_TEXT, S_FALSE },
{ NODE_CDATA_SECTION , S_FALSE },
{ NODE_ENTITY_REFERENCE, S_FALSE },
{ NODE_PROCESSING_INSTRUCTION, S_FALSE },
{ NODE_COMMENT, S_FALSE },
{ NODE_DOCUMENT_FRAGMENT, S_FALSE },
{ 0 }
}

Definition at line 9673 of file domdoc.c.

Referenced by test_get_attributes().

◆ get_datatype

const node_type_t get_datatype[]
static
Initial value:
= {
{ NODE_ELEMENT, "element", VT_NULL, S_FALSE },
{ NODE_ATTRIBUTE, "attr", VT_NULL, S_FALSE },
{ NODE_TEXT, "text", VT_NULL, S_FALSE },
{ NODE_CDATA_SECTION , "cdata", VT_NULL, S_FALSE },
{ NODE_ENTITY_REFERENCE, "entityref", VT_NULL, S_FALSE },
{ NODE_PROCESSING_INSTRUCTION, "pi", VT_NULL, S_FALSE },
{ NODE_COMMENT, "comment", VT_NULL, S_FALSE },
{ NODE_DOCUMENT_FRAGMENT, "docfrag", VT_NULL, S_FALSE },
{ 0 }
}

Definition at line 9560 of file domdoc.c.

Referenced by test_get_dataType().

◆ get_node_typestring

const get_node_typestring_t get_node_typestring[]
static
Initial value:
= {
{ NODE_ELEMENT, "element" },
{ NODE_ATTRIBUTE, "attribute" },
{ NODE_TEXT, "text" },
{ NODE_CDATA_SECTION , "cdatasection" },
{ NODE_ENTITY_REFERENCE, "entityreference" },
{ NODE_PROCESSING_INSTRUCTION, "processinginstruction" },
{ NODE_COMMENT, "comment" },
{ NODE_DOCUMENT_FRAGMENT, "documentfragment" },
{ 0 }
}

Definition at line 9615 of file domdoc.c.

Referenced by test_get_nodeTypeString().

◆ get_nodetypedvalue

const nodetypedvalue_t get_nodetypedvalue[]
static
Initial value:
= {
{ "root/string", VT_BSTR, "Wine" },
{ "root/string2", VT_BSTR, "String" },
{ "root/number", VT_BSTR, "12.44" },
{ "root/number2", VT_BSTR, "-3.71e3" },
{ "root/int", VT_I4, "-13" },
{ "root/fixed", VT_CY, "7322.9371" },
{ "root/bool", VT_BOOL, "-1" },
{ "root/datetime", VT_DATE, "40135.14" },
{ "root/datetimetz",VT_DATE, "37813.59" },
{ "root/date", VT_DATE, "665413" },
{ "root/time", VT_DATE, "0.5813889" },
{ "root/timetz", VT_DATE, "1.112512" },
{ "root/i1", VT_I1, "-13" },
{ "root/i2", VT_I2, "31915" },
{ "root/i4", VT_I4, "-312232" },
{ "root/ui1", VT_UI1, "123" },
{ "root/ui2", VT_UI2, "48282" },
{ "root/ui4", VT_UI4, "949281" },
{ "root/r4", VT_R4, "213124" },
{ "root/r8", VT_R8, "0.412" },
{ "root/float", VT_R8, "41221.421" },
{ "root/uuid", VT_BSTR, "333C7BC4-460F-11D0-BC04-0080C7055a83" },
{ "root/binbase64", VT_ARRAY|VT_UI1, "base64 test" },
{ "root/binbase64_1", VT_ARRAY|VT_UI1, "base64 test" },
{ "root/binbase64_2", VT_ARRAY|VT_UI1, "base64 test" },
{ 0 }
}
VT_UI4
@ VT_UI4
Definition: compat.h:2313

Definition at line 6789 of file domdoc.c.

Referenced by test_nodeTypedValue().

◆ get_prefix_doc

const char get_prefix_doc[]
static
Initial value:
=
"<?xml version=\"1.0\" ?>"
"<a xmlns:ns1=\"ns1 href\" />"

Definition at line 8264 of file domdoc.c.

Referenced by test_get_prefix().

◆ leading_spaces_classdata

const struct leading_spaces_t leading_spaces_classdata[]
static
Initial value:
= {
{ &CLSID_DOMDocument, "CLSID_DOMDocument", {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE, S_OK } }},
{ &CLSID_DOMDocument2, "CLSID_DOMDocument2", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
{ &CLSID_DOMDocument26, "CLSID_DOMDocument26", {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE, S_OK } }},
{ &CLSID_DOMDocument30, "CLSID_DOMDocument30", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
{ &CLSID_DOMDocument40, "CLSID_DOMDocument40", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
{ &CLSID_DOMDocument60, "CLSID_DOMDocument60", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
{ NULL }
}

Definition at line 1418 of file domdoc.c.

Referenced by test_domdoc().

◆ leading_spaces_xmldata

const char* leading_spaces_xmldata[]
static
Initial value:
= {
"\n<?xml version=\"1.0\" encoding=\"UTF-16\" ?><root/>",
" <?xml version=\"1.0\"?><root/>",
"\n<?xml version=\"1.0\"?><root/>",
"\t<?xml version=\"1.0\"?><root/>",
"\r\n<?xml version=\"1.0\"?><root/>",
"\r<?xml version=\"1.0\"?><root/>",
"\r\r\r\r\t\t \n\n <?xml version=\"1.0\"?><root/>",
0
}

Definition at line 1428 of file domdoc.c.

Referenced by test_domdoc().

◆ named_item_tests

const ns_item_t named_item_tests[]
static
Initial value:
= {
{ "xml:lang", NULL, S_OK },
{ "lang", NULL, S_FALSE },
{ "ns:b", NULL, S_OK },
{ "b", NULL, S_FALSE },
{ "d", NULL, S_OK },
{ NULL }
}

Definition at line 7662 of file domdoc.c.

Referenced by test_getQualifiedItem().

◆ namespace_as_attribute_test_data

const namespace_as_attribute_t namespace_as_attribute_test_data[]
static
Initial value:
= {
{ &CLSID_DOMDocument, "CLSID_DOMDocument", "" },
{ &CLSID_DOMDocument2, "CLSID_DOMDocument2", "" },
{ &CLSID_DOMDocument26, "CLSID_DOMDocument26", "" },
{ &CLSID_DOMDocument30, "CLSID_DOMDocument30", "" },
{ &CLSID_DOMDocument40, "CLSID_DOMDocument40", "" },
{ &CLSID_DOMDocument60, "CLSID_DOMDocument60", "http://www.w3.org/2000/xmlns/" },
{ 0 }
}

Definition at line 12874 of file domdoc.c.

Referenced by test_namespaces_as_attributes().

◆ namespaces_change_test_data

const struct namespaces_change_t namespaces_change_test_data[]
static
Initial value:
= {
{ &CLSID_DOMDocument, "CLSID_DOMDocument" },
{ &CLSID_DOMDocument2, "CLSID_DOMDocument2" },
{ &CLSID_DOMDocument26, "CLSID_DOMDocument26" },
{ &CLSID_DOMDocument30, "CLSID_DOMDocument30" },
{ &CLSID_DOMDocument40, "CLSID_DOMDocument40" },
{ &CLSID_DOMDocument60, "CLSID_DOMDocument60" },
{ 0 }
}

Definition at line 6579 of file domdoc.c.

Referenced by test_namespaces_change().

◆ namespacesA

const char namespacesA[]
static
Initial value:
=
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
" <ns1:elem1 xmlns:ns1=\"http://blah.org\" b='1' >"
" <ns2:elem2 xmlns:ns2=\"http://blah.org\"/>"
" <ns1:elem3/>"
" <ns1:elem4/>"
" <elem5 xmlns=\"http://blahblah.org\"/>"
" <ns1:elem6>true</ns1:elem6>"
" </ns1:elem1>"

Definition at line 11804 of file domdoc.c.

Referenced by test_get_namespaces().

◆ nocontent

const char nocontent[] = "no xml content here"
static

Definition at line 780 of file domdoc.c.

Referenced by test_load().

◆ nodetypes_test

const DOMNodeType nodetypes_test[]
static
Initial value:
=
{
NODE_ELEMENT,
NODE_ATTRIBUTE,
NODE_TEXT,
NODE_CDATA_SECTION,
NODE_ENTITY_REFERENCE,
NODE_PROCESSING_INSTRUCTION,
NODE_COMMENT,
NODE_DOCUMENT_FRAGMENT,
NODE_INVALID
}

Definition at line 10966 of file domdoc.c.

Referenced by test_dispex().

◆ nodevalue_test

const node_value_t nodevalue_test[]
static
Initial value:
= {
{ NODE_ELEMENT, "element", "", E_FAIL, VT_NULL, S_FALSE },
{ NODE_ATTRIBUTE, "attr", "value", S_OK, VT_BSTR, S_OK },
{ NODE_TEXT, "text", "textdata", S_OK, VT_BSTR, S_OK },
{ NODE_CDATA_SECTION , "cdata", "cdata data", S_OK, VT_BSTR, S_OK },
{ NODE_ENTITY_REFERENCE, "entityref", "ref", E_FAIL, VT_NULL, S_FALSE },
{ NODE_PROCESSING_INSTRUCTION, "pi", "instr", S_OK, VT_BSTR, S_OK },
{ NODE_COMMENT, "comment", "comment data", S_OK, VT_BSTR, S_OK },
{ NODE_DOCUMENT_FRAGMENT, "docfrag", "", E_FAIL, VT_NULL, S_FALSE },
{ NODE_INVALID }
}

Definition at line 11698 of file domdoc.c.

Referenced by test_nodeValue().

◆ nonexistent_attrW

const WCHAR nonexistent_attrW[]
static
Initial value:
= {
'n','o','n','E','x','i','s','i','t','i','n','g','A','t','t','r','i','b','u','t','e',0
}

Definition at line 1150 of file domdoc.c.

Referenced by test_getAttributeNode().

◆ nonexistent_fileW

const WCHAR nonexistent_fileW[]
static
Initial value:
= {
'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
}

Definition at line 1147 of file domdoc.c.

Referenced by test_domdoc(), test_domnode(), and test_getAttributeNode().

◆ omitxmldecl_doc

const char omitxmldecl_doc[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
"<a>"
" <item name=\"item1\"/>"
" <item name=\"item2\"/>"
"</a>"

Definition at line 12533 of file domdoc.c.

Referenced by test_xsltext().

◆ omitxmldecl_xsl

const char omitxmldecl_xsl[]
static
Initial value:
=
"<?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>"

Definition at line 12520 of file domdoc.c.

Referenced by test_xsltext().

◆ properties_test_data

const property_test_t properties_test_data[]
static
Initial value:
= {
{ &CLSID_DOMDocument, "CLSID_DOMDocument" , "SelectionLanguage", "XSLPattern" },
{ &CLSID_DOMDocument2, "CLSID_DOMDocument2" , "SelectionLanguage", "XSLPattern" },
{ &CLSID_DOMDocument30, "CLSID_DOMDocument30", "SelectionLanguage", "XSLPattern" },
{ &CLSID_DOMDocument40, "CLSID_DOMDocument40", "SelectionLanguage", "XPath" },
{ &CLSID_DOMDocument60, "CLSID_DOMDocument60", "SelectionLanguage", "XPath" },
{ 0 }
}

Definition at line 7233 of file domdoc.c.

Referenced by test_default_properties().

◆ put_data_types

const DOMNodeType put_data_types[]
static
Initial value:
= {
NODE_TEXT,
NODE_CDATA_SECTION,
NODE_PROCESSING_INSTRUCTION,
NODE_COMMENT,
NODE_INVALID
}

Definition at line 12070 of file domdoc.c.

Referenced by test_put_data().

◆ put_datatype_data

put_datatype_t put_datatype_data[]
static
Initial value:
= {
{ "test_inval", "abcdefg", E_FAIL },
{ "test_bool", "Boolean", S_OK },
{ "test_string", "String", S_OK },
{ "test_number", "number", S_OK },
{ "test_int", "InT", S_OK },
{ "test_fixed", "fixed.14.4", S_OK },
{ "test_datetime", "DateTime", S_OK },
{ "test_datetimetz", "DateTime.tz", S_OK },
{ "test_date", "Date", S_OK },
{ "test_time", "Time", S_OK },
{ "test_timetz", "Time.tz", S_OK },
{ "test_I1", "I1", S_OK },
{ "test_I2", "I2", S_OK },
{ "test_I4", "I4", S_OK },
{ "test_UI1", "UI1", S_OK },
{ "test_UI2", "UI2", S_OK },
{ "test_UI4", "UI4", S_OK },
{ "test_r4", "r4", S_OK },
{ "test_r8", "r8", S_OK },
{ "test_float", "float", S_OK },
{ "test_uuid", "UuId", S_OK },
{ "test_binhex", "bin.hex", S_OK },
{ "test_binbase64", "bin.base64", S_OK },
{ NULL }
}

Definition at line 6270 of file domdoc.c.

Referenced by test_put_dataType().

◆ put_dt_notype

put_datatype_notype_t put_dt_notype[]
static
Initial value:
= {
{ NODE_PROCESSING_INSTRUCTION, E_FAIL },
{ NODE_DOCUMENT_FRAGMENT, E_FAIL },
{ NODE_ENTITY_REFERENCE, E_FAIL },
{ NODE_CDATA_SECTION, E_FAIL },
{ NODE_COMMENT, E_FAIL },
{ NODE_INVALID }
}

Definition at line 6302 of file domdoc.c.

Referenced by test_put_dataType().

◆ qualified_item_tests

const ns_item_t qualified_item_tests[]
static
Initial value:
= {
{ "xml:lang", NULL, S_FALSE },
{ "xml:lang", "http://www.w3.org/XML/1998/namespace", S_FALSE },
{ "lang", "http://www.w3.org/XML/1998/namespace", S_OK },
{ "ns:b", NULL, S_FALSE },
{ "ns:b", "nshref", S_FALSE },
{ "b", "nshref", S_OK },
{ "d", NULL, S_OK },
{ NULL }
}

Definition at line 7651 of file domdoc.c.

Referenced by test_getQualifiedItem().

◆ refcount_test

const refcount_test_t refcount_test[]
static
Initial value:
= {
{ NODE_ELEMENT, &IID_IXMLDOMElement },
{ NODE_ATTRIBUTE, &IID_IXMLDOMAttribute },
{ NODE_TEXT, &IID_IXMLDOMText },
{ NODE_CDATA_SECTION, &IID_IXMLDOMCDATASection },
{ NODE_ENTITY_REFERENCE, &IID_IXMLDOMEntityReference },
{ NODE_PROCESSING_INSTRUCTION, &IID_IXMLDOMProcessingInstruction },
{ NODE_COMMENT, &IID_IXMLDOMComment },
{ NODE_DOCUMENT_FRAGMENT, &IID_IXMLDOMDocumentFragment },
{ NODE_INVALID, &IID_NULL }
}

Definition at line 2582 of file domdoc.c.

Referenced by test_refs().

◆ savestream

IStream savestream = { &StreamVtbl }
static

Definition at line 354 of file domdoc.c.

Referenced by test_save().

◆ selection_ns_data

const selection_ns_t selection_ns_data[]
static
Initial value:
= {
{ &CLSID_DOMDocument, "CLSID_DOMDocument", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument, "CLSID_DOMDocument", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument, "CLSID_DOMDocument", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument, "CLSID_DOMDocument", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
{ &CLSID_DOMDocument2, "CLSID_DOMDocument2", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument2, "CLSID_DOMDocument2", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument2, "CLSID_DOMDocument2", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument2, "CLSID_DOMDocument2", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
{ &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument30, "CLSID_DOMDocument30", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument30, "CLSID_DOMDocument30", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
{ &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument40, "CLSID_DOMDocument40", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument40, "CLSID_DOMDocument40", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
{ &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument60, "CLSID_DOMDocument60", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
{ &CLSID_DOMDocument60, "CLSID_DOMDocument60", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
{ NULL }
}

Definition at line 4788 of file domdoc.c.

Referenced by test_XPath().

◆ StreamVtbl

const IStreamVtbl StreamVtbl
static
Initial value:
= {
istream_QueryInterface,
istream_AddRef,
istream_Release,
istream_Read,
istream_Write,
istream_Seek,
istream_SetSize,
istream_CopyTo,
istream_Commit,
istream_Revert,
istream_LockRegion,
istream_UnlockRegion,
istream_Stat,
istream_Clone
}
istream_Commit
static HRESULT WINAPI istream_Commit(IStream *iface, DWORD flags)
Definition: domdoc.c:299
istream_Seek
static HRESULT WINAPI istream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
Definition: domdoc.c:280
istream_CopyTo
static HRESULT WINAPI istream_CopyTo(IStream *iface, IStream *stream, ULARGE_INTEGER len, ULARGE_INTEGER *pread, ULARGE_INTEGER *written)
Definition: domdoc.c:292
istream_Release
static ULONG WINAPI istream_Release(IStream *iface)
Definition: domdoc.c:263
istream_LockRegion
static HRESULT WINAPI istream_LockRegion(IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER len, DWORD locktype)
Definition: domdoc.c:311
istream_Revert
static HRESULT WINAPI istream_Revert(IStream *iface)
Definition: domdoc.c:305
istream_SetSize
static HRESULT WINAPI istream_SetSize(IStream *iface, ULARGE_INTEGER size)
Definition: domdoc.c:286
istream_AddRef
static ULONG WINAPI istream_AddRef(IStream *iface)
Definition: domdoc.c:258
istream_QueryInterface
static HRESULT WINAPI istream_QueryInterface(IStream *iface, REFIID riid, void **ppvObject)
Definition: domdoc.c:245
istream_Read
static HRESULT WINAPI istream_Read(IStream *iface, void *ptr, ULONG len, ULONG *pread)
Definition: domdoc.c:268
istream_Clone
static HRESULT WINAPI istream_Clone(IStream *iface, IStream **stream)
Definition: domdoc.c:331
istream_Stat
static HRESULT WINAPI istream_Stat(IStream *iface, STATSTG *pstatstg, DWORD flag)
Definition: domdoc.c:325
istream_Write
static HRESULT WINAPI istream_Write(IStream *iface, const void *ptr, ULONG len, ULONG *written)
Definition: domdoc.c:274
istream_UnlockRegion
static HRESULT WINAPI istream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER len, DWORD locktype)
Definition: domdoc.c:318

Definition at line 337 of file domdoc.c.

◆ supporterror_test

const supporterror_t supporterror_test[]
static
Initial value:
= {
{ NODE_ELEMENT, "element", { &IID_IXMLDOMNode, &IID_IXMLDOMElement } },
{ NODE_ATTRIBUTE, "attribute", { &IID_IXMLDOMNode, &IID_IXMLDOMAttribute } },
{ NODE_CDATA_SECTION, "cdata", { &IID_IXMLDOMNode, &IID_IXMLDOMCDATASection } },
{ NODE_ENTITY_REFERENCE, "entityref", { &IID_IXMLDOMNode, &IID_IXMLDOMEntityReference } },
{ NODE_PROCESSING_INSTRUCTION, "pi", { &IID_IXMLDOMNode, &IID_IXMLDOMProcessingInstruction } },
{ NODE_COMMENT, "comment", { &IID_IXMLDOMNode, &IID_IXMLDOMComment } },
{ NODE_DOCUMENT_FRAGMENT, "fragment", { &IID_IXMLDOMNode, &IID_IXMLDOMDocumentFragment } },
{ NODE_INVALID }
}

Definition at line 11528 of file domdoc.c.

Referenced by test_supporterrorinfo().

◆ szAttribute

const WCHAR szAttribute[] = {'A','t','t','r',0 }
static

Definition at line 1179 of file domdoc.c.

Referenced by Installer_ProductInfo(), MSI_GetProductInfo(), MsiGetProductInfoA(), MsiGetProductInfoW(), test_create(), test_domdoc(), and test_xmlTypes().

◆ szAttributeXML

const WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 }
static

Definition at line 1180 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szBasicTransformOutput

const CHAR szBasicTransformOutput[]
static
Initial value:
=
"<HTML><BODY><TABLE><TD>Wine</TD><TD>$25.00</TD></TABLE></BODY></HTML>"

Definition at line 939 of file domdoc.c.

Referenced by test_TransformWithLoadingLocalFile().

◆ szBasicTransformSSXMLPart1

const CHAR szBasicTransformSSXMLPart1[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
"<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
"<xsl:output method=\"html\"/>\n"
"<xsl:template match=\"/\">"
"<HTML><BODY><TABLE>"
" <xsl:apply-templates select='document(\""

Definition at line 911 of file domdoc.c.

Referenced by test_TransformWithLoadingLocalFile().

◆ szBasicTransformSSXMLPart2

const CHAR szBasicTransformSSXMLPart2[]
static
Initial value:
=
"\")/bottle/wine'>"
" <xsl:sort select=\"cost\"/><xsl:sort select=\"name\"/>"
" </xsl:apply-templates>"
"</TABLE></BODY></HTML>"
"</xsl:template>"
"<xsl:template match=\"bottle\">"
" <TR><xsl:apply-templates select=\"name\" /><xsl:apply-templates select=\"cost\" /></TR>"
"</xsl:template>"
"<xsl:template match=\"name\">"
" <TD><xsl:apply-templates /></TD>"
"</xsl:template>"
"<xsl:template match=\"cost\">"
" <TD><xsl:apply-templates /></TD>"
"</xsl:template>"
"</xsl:stylesheet>"

Definition at line 919 of file domdoc.c.

Referenced by test_TransformWithLoadingLocalFile().

◆ szBasicTransformXML

const CHAR szBasicTransformXML[]
static
Initial value:
=
"<?xml version=\"1.0\"?><bottle><wine><name>Wine</name><cost>$25.00</cost></wine></bottle>"

Definition at line 936 of file domdoc.c.

Referenced by test_TransformWithLoadingLocalFile().

◆ szbs

const WCHAR szbs[] = { 'b','s',0 }
static

Definition at line 1161 of file domdoc.c.

Referenced by test_create(), test_domnode(), and test_get_text().

◆ szCData

const WCHAR szCData[]
static
Initial value:
= {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
' ','n','o','t',' ','r','i','g','h','t','!', 0}

Definition at line 1182 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szCDataNodeText

const WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 }
static

Definition at line 1187 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szCDataXML

const WCHAR szCDataXML[]
static
Initial value:
= {'<','!','[','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}

Definition at line 1184 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szComment

const WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 }
static

Definition at line 1167 of file domdoc.c.

Referenced by SampInitializeSAM(), test_domdoc(), test_xmlTypes(), unz64local_GetCurrentFileInfoInternal(), unzGetCurrentFileInfo(), unzGetCurrentFileInfo64(), and unzGetGlobalComment().

◆ szCommentNodeText

const WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 }
static

Definition at line 1169 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szCommentXML

const WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 }
static

Definition at line 1168 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szComplete1

const WCHAR szComplete1[]
static
Initial value:
= {
'<','?','x','m','l',' ',
'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
'<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
}

Definition at line 713 of file domdoc.c.

Referenced by test_domdoc(), and test_load().

◆ szComplete2

const WCHAR szComplete2[]
static
Initial value:
= {
'<','?','x','m','l',' ',
'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
'<','a','>','<','/','a','>','\n',0
}

Definition at line 718 of file domdoc.c.

Referenced by test_domdoc().

◆ szComplete5

const WCHAR szComplete5[]
static
Initial value:
= {
'<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
'x','m','l','n','s',':','C','=','"','u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','o','f','f','i','c','e',':','c','l','i','p','g','a','l','l','e','r','y','"',
' ','x','m','l','n','s',':','S','=','"','u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','o','f','f','i','c','e',':','c','l','i','p','g','a','l','l','e','r','y',':','s','e','a','r','c','h','"','>',
'<','S',':','s','c','o','p','e','>',
'<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
'<','/','S',':','s','c','o','p','e','>',
'<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
'<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
'c','o','m','p','u','t','e','r',
'<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
'<','/','S',':','s','e','a','r','c','h','>',0
}

Definition at line 740 of file domdoc.c.

Referenced by test_domnode().

◆ szComplete6

const WCHAR szComplete6[]
static
Initial value:
= {
'<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'',' ',
'e','n','c','o','d','i','n','g','=','\'','W','i','n','d','o','w','s','-','1','2','5','2','\'','?','>','\n',
'<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
}

Definition at line 754 of file domdoc.c.

Referenced by test_domdoc().

◆ szdl

const WCHAR szdl[] = { 'd','l',0 }
static

Definition at line 1158 of file domdoc.c.

Referenced by test_create(), and test_domnode().

◆ szDocFragmentText

const WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 }
static

Definition at line 1188 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szDocument

const WCHAR szDocument[]
static
Initial value:
= {
'#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
}

Definition at line 1153 of file domdoc.c.

Referenced by test_domdoc().

◆ szElement

WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 }
static

Definition at line 1171 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szElementXML

const WCHAR szElementXML[] = {'<','E','l','e','T','e','s','t','/','>',0 }
static

Definition at line 1172 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szElementXML2

const WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 }
static

Definition at line 1173 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szElementXML3

const WCHAR szElementXML3[]
static
Initial value:
= {'<','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 }

Definition at line 1174 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szElementXML4

const WCHAR szElementXML4[]
static
Initial value:
= {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
'&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 }

Definition at line 1176 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szEmailXML

const CHAR szEmailXML[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email attachments=\"patch1\">"
" <recipients>"
" <to>wine-patches@winehq.org</to>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 87)</subject>"
" <body>"
" It no longer causes spontaneous combustion..."
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"
SZ_EMAIL_DTD
#define SZ_EMAIL_DTD
Definition: domdoc.c:942

Definition at line 963 of file domdoc.c.

Referenced by test_get_doctype(), test_IXMLDOMDocument2(), and test_nodeTypedValue().

◆ szEmailXML_0D

const CHAR szEmailXML_0D[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email attachments=\"patch1\">"
" <recipients>"
" <to>wine-patches@winehq.org</to>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 88)</subject>"
" <body>"
" <undecl />"
" XML_ELEMENT_UNDECLARED 0xC00CE00D"
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"

Definition at line 978 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmailXML_0E

const CHAR szEmailXML_0E[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email attachments=\"patch1\">"
" <recipients>"
" <to>wine-patches@winehq.org</to>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 89)</subject>"
" <body>"
" XML_ELEMENT_ID_NOT_FOUND 0xC00CE00E"
" </body>"
" <attachment id=\"patch\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"

Definition at line 994 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmailXML_11

const CHAR szEmailXML_11[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email attachments=\"patch1\">"
" <recipients>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 90)</subject>"
" <body>"
" XML_EMPTY_NOT_ALLOWED 0xC00CE011"
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"

Definition at line 1009 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmailXML_13

const CHAR szEmailXML_13[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<msg attachments=\"patch1\">"
" <recipients>"
" <to>wine-patches@winehq.org</to>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 91)</subject>"
" <body>"
" XML_ROOT_NAME_MISMATCH 0xC00CE013"
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</msg>"

Definition at line 1023 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmailXML_14

const CHAR szEmailXML_14[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email attachments=\"patch1\">"
" <to>wine-patches@winehq.org</to>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 92)</subject>"
" <body>"
" XML_INVALID_CONTENT 0xC00CE014"
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"

Definition at line 1038 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmailXML_15

const CHAR szEmailXML_15[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email attachments=\"patch1\" ip=\"127.0.0.1\">"
" <recipients>"
" <to>wine-patches@winehq.org</to>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 93)</subject>"
" <body>"
" XML_ATTRIBUTE_NOT_DEFINED 0xC00CE015"
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"

Definition at line 1051 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmailXML_16

const CHAR szEmailXML_16[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email attachments=\"patch1\">"
" <recipients>"
" <to>wine-patches@winehq.org</to>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 94)</subject>"
" <body enc=\"ASCII\">"
" XML_ATTRIBUTE_FIXED 0xC00CE016"
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"

Definition at line 1066 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmailXML_17

const CHAR szEmailXML_17[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email attachments=\"patch1\" sent=\"true\">"
" <recipients>"
" <to>wine-patches@winehq.org</to>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 95)</subject>"
" <body>"
" XML_ATTRIBUTE_VALUE 0xC00CE017"
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"

Definition at line 1081 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmailXML_18

const CHAR szEmailXML_18[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email attachments=\"patch1\">"
" oops"
" <recipients>"
" <to>wine-patches@winehq.org</to>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 96)</subject>"
" <body>"
" XML_ILLEGAL_TEXT 0xC00CE018"
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"

Definition at line 1096 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmailXML_20

const CHAR szEmailXML_20[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
SZ_EMAIL_DTD
"<email>"
" <recipients>"
" <to>wine-patches@winehq.org</to>"
" </recipients>"
" <from name=\"Anonymous\">user@localhost</from>"
" <subject>msxml3/tests: DTD validation (try 97)</subject>"
" <body>"
" XML_REQUIRED_ATTRIBUTE_MISSING 0xC00CE020"
" </body>"
" <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
"</email>"

Definition at line 1112 of file domdoc.c.

Referenced by test_IXMLDOMDocument2().

◆ szEmpty

const WCHAR szEmpty[] = { 0 }
static

Definition at line 708 of file domdoc.c.

Referenced by test_domdoc().

◆ szEntityRef

const WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 }
static

Definition at line 1190 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szEntityRefXML

const WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 }
static

Definition at line 1191 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szExampleXML

const char szExampleXML[]
static

Definition at line 782 of file domdoc.c.

Referenced by test_getAttribute(), test_getAttributeNode(), test_load(), test_selection(), test_whitespace(), test_XPath(), and test_XSLPattern().

◆ szfn1_txt

const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0}
static

Definition at line 1165 of file domdoc.c.

Referenced by test_get_text().

◆ szIncomplete

const WCHAR szIncomplete[]
static
Initial value:
= {
'<','?','x','m','l',' ',
'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
}

Definition at line 709 of file domdoc.c.

Referenced by test_domdoc().

◆ szlc

const WCHAR szlc[] = { 'l','c',0 }
static

Definition at line 1160 of file domdoc.c.

Referenced by test_create(), and test_domnode().

◆ szNodeTypesXML

const CHAR szNodeTypesXML[]
static
Initial value:
=
"<?xml version='1.0'?>"
"<!-- comment node 0 -->"
"<root id='0' depth='0'>"
" <!-- comment node 1 -->"
" text node 0"
" <x id='1' depth='1'>"
" <?foo value='PI for x'?>"
" <!-- comment node 2 -->"
" text node 1"
" <a id='3' depth='2'/>"
" <b id='4' depth='2'/>"
" <c id='5' depth='2'/>"
" </x>"
" <y id='2' depth='1'>"
" <?bar value='PI for y'?>"
" <!-- comment node 3 -->"
" text node 2"
" <a id='6' depth='2'/>"
" <b id='7' depth='2'/>"
" <c id='8' depth='2'/>"
" </y>"
"</root>"

Definition at line 828 of file domdoc.c.

Referenced by test_XSLPattern().

◆ szOpen

const WCHAR szOpen[] = { 'o','p','e','n',0 }
static

Definition at line 1157 of file domdoc.c.

Referenced by IHlink_fnNavigate(), test_domdoc(), and test_domnode().

◆ szstar

const WCHAR szstar[] = { '*',0 }
static

Definition at line 1164 of file domdoc.c.

Referenced by test_domobj_dispex(), and test_getElementsByTagName().

◆ szstr1

const WCHAR szstr1[] = { 's','t','r','1',0 }
static

Definition at line 1162 of file domdoc.c.

Referenced by test_create(), test_domdoc(), test_domnode(), test_merging_text(), and test_xmlTypes().

◆ szstr2

const WCHAR szstr2[] = { 's','t','r','2',0 }
static

Definition at line 1163 of file domdoc.c.

Referenced by test_create(), test_get_text(), and test_merging_text().

◆ szStrangeChars

const WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0}
static

Definition at line 1192 of file domdoc.c.

Referenced by test_xmlTypes().

◆ szTransformOutput

const CHAR szTransformOutput[]
static
Initial value:
=
"<html><body><h1>"
"Hello World"
"</h1></body></html>"

Definition at line 875 of file domdoc.c.

Referenced by test_testTransforms().

◆ szTransformSSXML

const CHAR szTransformSSXML[]
static
Initial value:
=
"<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
" <xsl:output method=\"html\"/>\n"
" <xsl:template match=\"/\">\n"
" <xsl:apply-templates select=\"greeting\"/>\n"
" </xsl:template>\n"
" <xsl:template match=\"greeting\">\n"
" <html>\n"
" <body>\n"
" <h1>\n"
" <xsl:value-of select=\".\"/>\n"
" </h1>\n"
" </body>\n"
" </html>\n"
" </xsl:template>\n"
"</xsl:stylesheet>"

Definition at line 858 of file domdoc.c.

Referenced by test_dispex(), test_testTransforms(), test_transformNodeToObject(), and test_xsltemplate().

◆ szTransformXML

const CHAR szTransformXML[]
static
Initial value:
=
"<?xml version=\"1.0\"?>\n"
"<greeting>\n"
"Hello World\n"
"</greeting>"

Definition at line 852 of file domdoc.c.

Referenced by test_testTransforms(), test_transformNodeToObject(), and test_xsltemplate().

◆ szTypeValueXML

const CHAR szTypeValueXML[]
static
Initial value:
=
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
"<root xmlns:dt=\"urn:schemas-microsoft-com:datatypes\">\n"
" <string>Wine</string>\n"
" <string2 dt:dt=\"string\">String</string2>\n"
" <number dt:dt=\"number\">12.44</number>\n"
" <number2 dt:dt=\"NUMbEr\">-3.71e3</number2>\n"
" <int dt:dt=\"int\">-13</int>\n"
" <fixed dt:dt=\"fixed.14.4\">7322.9371</fixed>\n"
" <bool dt:dt=\"boolean\">1</bool>\n"
" <datetime dt:dt=\"datetime\">2009-11-18T03:21:33.12</datetime>\n"
" <datetimetz dt:dt=\"datetime.tz\">2003-07-11T11:13:57+03:00</datetimetz>\n"
" <date dt:dt=\"date\">3721-11-01</date>\n"
" <time dt:dt=\"time\">13:57:12.31321</time>\n"
" <timetz dt:dt=\"time.tz\">23:21:01.13+03:21</timetz>\n"
" <i1 dt:dt=\"i1\">-13</i1>\n"
" <i2 dt:dt=\"i2\">31915</i2>\n"
" <i4 dt:dt=\"i4\">-312232</i4>\n"
" <ui1 dt:dt=\"ui1\">123</ui1>\n"
" <ui2 dt:dt=\"ui2\">48282</ui2>\n"
" <ui4 dt:dt=\"ui4\">949281</ui4>\n"
" <r4 dt:dt=\"r4\">213124.0</r4>\n"
" <r8 dt:dt=\"r8\">0.412</r8>\n"
" <float dt:dt=\"float\">41221.421</float>\n"
" <uuid dt:dt=\"uuid\">333C7BC4-460F-11D0-BC04-0080C7055a83</uuid>\n"
" <binhex dt:dt=\"bin.hex\">fffca012003c</binhex>\n"
" <binbase64 dt:dt=\"bin.base64\">YmFzZTY0IHRlc3Q=</binbase64>\n"
" <binbase64_1 dt:dt=\"bin.base64\">\nYmFzZTY0\nIHRlc3Q=\n</binbase64_1>\n"
" <binbase64_2 dt:dt=\"bin.base64\">\nYmF\r\t z ZTY0\nIHRlc3Q=\n</binbase64_2>\n"
"</root>"

Definition at line 880 of file domdoc.c.

Referenced by test_nodeTypedValue(), and test_TransformWithLoadingLocalFile().

◆ szvr

const WCHAR szvr[] = { 'v','r',0 }
static

Definition at line 1159 of file domdoc.c.

Referenced by test_get_text(), and test_removeNamedItem().

◆ testresponse

IResponse testresponse = { &testresponsevtbl }
static

Definition at line 653 of file domdoc.c.

Referenced by test_xsltemplate().

◆ testresponsevtbl

const IResponseVtbl testresponsevtbl
static

Definition at line 611 of file domdoc.c.

◆ transformdestvtbl

const IUnknownVtbl transformdestvtbl
static
Initial value:
=
{
transformdest_QueryInterface,
transformdest_AddRef,
transformdest_Release,
}
transformdest_Release
static ULONG WINAPI transformdest_Release(IUnknown *iface)
Definition: domdoc.c:12775
transformdest_AddRef
static ULONG WINAPI transformdest_AddRef(IUnknown *iface)
Definition: domdoc.c:12770
transformdest_QueryInterface
static HRESULT WINAPI transformdest_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
Definition: domdoc.c:12755

Definition at line 12780 of file domdoc.c.

Referenced by test_transformNodeToObject().

◆ whitespace_test_data

const struct whitespace_t whitespace_test_data[]
static
Initial value:
= {
{ &CLSID_DOMDocument, "CLSID_DOMDocument" },
{ &CLSID_DOMDocument2, "CLSID_DOMDocument2" },
{ &CLSID_DOMDocument26, "CLSID_DOMDocument26" },
{ &CLSID_DOMDocument30, "CLSID_DOMDocument30" },
{ &CLSID_DOMDocument40, "CLSID_DOMDocument40" },
{ &CLSID_DOMDocument60, "CLSID_DOMDocument60" },
{ 0 }
}

Definition at line 4647 of file domdoc.c.

Referenced by test_whitespace().

◆ win1252decl

const char win1252decl[]
static
Initial value:
=
DECL_WIN_1252
DECL_WIN_1252
#define DECL_WIN_1252
Definition: domdoc.c:769

Definition at line 776 of file domdoc.c.

Referenced by test_save().

◆ win1252xml

const char win1252xml[]
static
Initial value:
=
DECL_WIN_1252
"<open></open>"

Definition at line 772 of file domdoc.c.

Referenced by test_domdoc(), test_load(), and test_save().

◆ xpath_simple_list

const char xpath_simple_list[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
"<root>"
" <a attr1=\"1\" attr2=\"2\" />"
" <b/>"
" <c/>"
" <d/>"
"</root>"

Definition at line 1127 of file domdoc.c.

Referenced by test_dispex(), and test_selection().

◆ xpath_test

const xpath_test_t xpath_test[]
static

Definition at line 4822 of file domdoc.c.

Referenced by test_XPath().

◆ xsd_schema1_uri

const char xsd_schema1_uri[] = "x-schema:test1.xsd"
static

Definition at line 11814 of file domdoc.c.

Referenced by test_get_namespaces().

◆ xsd_schema1_xml

const char xsd_schema1_xml[]
static
Initial value:
=
"<?xml version='1.0'?>"
"<schema xmlns='http://www.w3.org/2001/XMLSchema'"
" targetNamespace='x-schema:test1.xsd'>"
" <element name='root'>"
" <complexType>"
" <sequence maxOccurs='unbounded'>"
" <any/>"
" </sequence>"
" </complexType>"
" </element>"
"</schema>"

Definition at line 11815 of file domdoc.c.

Referenced by test_get_namespaces().

◆ xslpattern_test

const xslpattern_test_t xslpattern_test[]
static

Definition at line 7279 of file domdoc.c.

Referenced by test_XSLPattern().

◆ xslpattern_test_func

const xslpattern_test_t xslpattern_test_func[]
static
Initial value:
= {
{ "attribute()", "" },
{ "attribute('depth')", "" },
{ "root/attribute('depth')", "A'depth'.E3.D1" },
{ "//x/attribute()", "A'id'.E3.E3.D1 A'depth'.E3.E3.D1" },
{ "//x//attribute(id)", NULL },
{ "//x//attribute('id')", "A'id'.E3.E3.D1 A'id'.E4.E3.E3.D1 A'id'.E5.E3.E3.D1 A'id'.E6.E3.E3.D1" },
{ "comment()", "C2.D1" },
{ "//comment()", "C2.D1 C1.E3.D1 C2.E3.E3.D1 C2.E4.E3.D1" },
{ "element()", "E3.D1" },
{ "root/y/element()", "E4.E4.E3.D1 E5.E4.E3.D1 E6.E4.E3.D1" },
{ "//element(a)", NULL },
{ "//element('a')", "E4.E3.E3.D1 E4.E4.E3.D1" },
{ "node()", "P1.D1 C2.D1 E3.D1" },
{ "//x/node()", "P1.E3.E3.D1 C2.E3.E3.D1 T3.E3.E3.D1 E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1" },
{ "//x/node()[nodeType()=1]", "E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1" },
{ "//x/node()[nodeType()=3]", "T3.E3.E3.D1" },
{ "//x/node()[nodeType()=7]", "P1.E3.E3.D1" },
{ "//x/node()[nodeType()=8]", "C2.E3.E3.D1" },
{ "pi()", "P1.D1" },
{ "//y/pi()", "P1.E4.E3.D1" },
{ "root/textnode()", "T2.E3.D1" },
{ "root/element()/textnode()", "T3.E3.E3.D1 T3.E4.E3.D1" },
{ NULL }
}

Definition at line 7352 of file domdoc.c.

Referenced by test_XSLPattern().

◆ xslpattern_test_no_ns

const xslpattern_test_t xslpattern_test_no_ns[]
static
Initial value:
= {
{ "//bar:x", "E6.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1" },
{ "//foo:elem", "" },
{ "//foo:c", "E3.E4.E2.D1" },
{ NULL }
}

Definition at line 7343 of file domdoc.c.

Referenced by test_XSLPattern().

◆ xsltext_xsl

const char xsltext_xsl[]
static
Initial value:
=
"<?xml version=\"1.0\"?>"
"<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
"<xsl:output method=\"html\" encoding=\"us-ascii\"/>"
"<xsl:template match=\"/\">"
" <xsl:choose>"
" <xsl:when test=\"testkey\">"
" <xsl:text>testdata</xsl:text>"
" </xsl:when>"
" </xsl:choose>"
"</xsl:template>"
"</xsl:stylesheet>"

Definition at line 12507 of file domdoc.c.

Referenced by test_xsltext().