dlls/msxml3/tests/domdoc.c

   1 /*
   2  * XML test
   3  *
   4  * Copyright 2005 Mike McCormack for CodeWeavers
   5  * Copyright 2007-2008 Alistair Leslie-Hughes
   6  * Copyright 2010-2011 Adam Martinson for CodeWeavers
   7  * Copyright 2010-2013 Nikolay Sivov for CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24
  25 #define COBJMACROS
  26 #define CONST_VTABLE
  27
  28 #include <stdio.h>
  29 #include <assert.h>
  30
  31 #include "windows.h"
  32
  33 #include "msxml.h"
  34 #include "msxml2.h"
  35 #include "msxml2did.h"
  36 #include "ole2.h"
  37 #include "dispex.h"
  38 #include "objsafe.h"
  39 #include "initguid.h"
  40
  41 #include "wine/test.h"
  42
  43 /* undef the #define in msxml2 so that we can access all versions */
  44 #undef CLSID_DOMDocument
  45
  46 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  47
  48 static int g_unexpectedcall, g_expectedcall;
  49
  50 struct msxmlsupported_data_t
  51 {
  52     const GUID *clsid;
  53     const char *name;
  54     const IID  *ifaces[3];
  55     BOOL        supported[3];
  56 };
  57
  58 static struct msxmlsupported_data_t domdoc_support_data[] =
  59 {
  60     { &CLSID_DOMDocument,   "DOMDocument",   {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
  61     { &CLSID_DOMDocument2,  "DOMDocument2",  {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
  62     { &CLSID_DOMDocument30, "DOMDocument30", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
  63     { &CLSID_DOMDocument40, "DOMDocument40", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
  64     { &CLSID_DOMDocument60, "DOMDocument60", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3} },
  65     { &CLSID_FreeThreadedDOMDocument, "FreeThreadedDOMDocument", {&IID_IXMLDOMDocument, &IID_IXMLDOMDocument2} },
  66     { &CLSID_XMLSchemaCache, "XMLSchemaCache", {&IID_IXMLDOMSchemaCollection} },
  67     { &CLSID_XSLTemplate,    "XSLTemplate", {&IID_IXSLTemplate} },
  68     { &CLSID_MXNamespaceManager40, "MXNamespaceManager40", {&IID_IMXNamespaceManager} },
  69     { NULL }
  70 };
  71
  72 static const char *debugstr_msxml_guid(REFIID riid)
  73 {
  74     if(!riid)
  75         return "(null)";
  76
  77     if (IsEqualIID(&IID_IXMLDOMDocument, riid))
  78         return "IXMLDOMDocument";
  79     else if (IsEqualIID(&IID_IXMLDOMDocument2, riid))
  80         return "IXMLDOMDocument2";
  81     else if (IsEqualIID(&IID_IXMLDOMDocument3, riid))
  82         return "IXMLDOMDocument3";
  83     else if (IsEqualIID(&IID_IXMLDOMSchemaCollection, riid))
  84         return "IXMLDOMSchemaCollection";
  85     else if (IsEqualIID(&IID_IXSLTemplate, riid))
  86         return "IXSLTemplate";
  87     else if (IsEqualIID(&IID_IMXNamespaceManager, riid))
  88         return "IMXNamespaceManager";
  89     else
  90         return wine_dbgstr_guid(riid);
  91 }
  92
  93 static void get_class_support_data(struct msxmlsupported_data_t *table)
  94 {
  95     while (table->clsid)
  96     {
  97         IUnknown *unk;
  98         HRESULT hr;
  99         int i;
 100
 101         for (i = 0; i < sizeof(table->ifaces)/sizeof(table->ifaces[0]) && table->ifaces[i] != NULL; i++)
 102         {
 103             hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, table->ifaces[i], (void**)&unk);
 104             if (hr == S_OK) IUnknown_Release(unk);
 105
 106             table->supported[i] = hr == S_OK;
 107             if (hr != S_OK) win_skip("class %s, iface %s not supported\n", table->name, debugstr_msxml_guid(table->ifaces[i]));
 108         }
 109
 110         table++;
 111     }
 112 }
 113
 114 static BOOL is_clsid_supported(const GUID *clsid, REFIID riid)
 115 {
 116     const struct msxmlsupported_data_t *table = domdoc_support_data;
 117     while (table->clsid)
 118     {
 119         if (table->clsid == clsid)
 120         {
 121             int i;
 122
 123             for (i = 0; i < sizeof(table->ifaces)/sizeof(table->ifaces[0]) && table->ifaces[i] != NULL; i++)
 124                 if (table->ifaces[i] == riid) return table->supported[i];
 125         }
 126
 127         table++;
 128     }
 129     return FALSE;
 130 }
 131
 132 typedef struct
 133 {
 134     IDispatch IDispatch_iface;
 135     LONG ref;
 136 } dispevent;
 137
 138 static inline dispevent *impl_from_IDispatch( IDispatch *iface )
 139 {
 140     return CONTAINING_RECORD(iface, dispevent, IDispatch_iface);
 141 }
 142
 143 static HRESULT WINAPI dispevent_QueryInterface(IDispatch *iface, REFIID riid, void **ppvObject)
 144 {
 145     *ppvObject = NULL;
 146
 147     if ( IsEqualGUID( riid, &IID_IDispatch) ||
 148          IsEqualGUID( riid, &IID_IUnknown) )
 149     {
 150         *ppvObject = iface;
 151     }
 152     else
 153         return E_NOINTERFACE;
 154
 155     IDispatch_AddRef( iface );
 156
 157     return S_OK;
 158 }
 159
 160 static ULONG WINAPI dispevent_AddRef(IDispatch *iface)
 161 {
 162     dispevent *This = impl_from_IDispatch( iface );
 163     return InterlockedIncrement( &This->ref );
 164 }
 165
 166 static ULONG WINAPI dispevent_Release(IDispatch *iface)
 167 {
 168     dispevent *This = impl_from_IDispatch( iface );
 169     ULONG ref = InterlockedDecrement( &This->ref );
 170
 171     if (ref == 0)
 172         HeapFree(GetProcessHeap(), 0, This);
 173
 174     return ref;
 175 }
 176
 177 static HRESULT WINAPI dispevent_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 178 {
 179     g_unexpectedcall++;
 180     *pctinfo = 0;
 181     return S_OK;
 182 }
 183
 184 static HRESULT WINAPI dispevent_GetTypeInfo(IDispatch *iface, UINT iTInfo,
 185         LCID lcid, ITypeInfo **ppTInfo)
 186 {
 187     g_unexpectedcall++;
 188     return S_OK;
 189 }
 190
 191 static HRESULT WINAPI dispevent_GetIDsOfNames(IDispatch *iface, REFIID riid,
 192         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 193 {
 194     g_unexpectedcall++;
 195     return S_OK;
 196 }
 197
 198 static HRESULT WINAPI dispevent_Invoke(IDispatch *iface, DISPID member, REFIID riid,
 199         LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result,
 200         EXCEPINFO *excepInfo, UINT *argErr)
 201 {
 202     ok(member == 0, "expected 0 member, got %d\n", member);
 203     ok(lcid == LOCALE_SYSTEM_DEFAULT, "expected LOCALE_SYSTEM_DEFAULT, got lcid %x\n", lcid);
 204     ok(flags == DISPATCH_METHOD, "expected DISPATCH_METHOD, got %d\n", flags);
 205
 206     ok(params->cArgs == 0, "got %d\n", params->cArgs);
 207     ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
 208     ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
 209     ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
 210
 211     ok(result == NULL, "got %p\n", result);
 212     ok(excepInfo == NULL, "got %p\n", excepInfo);
 213     ok(argErr == NULL, "got %p\n", argErr);
 214
 215     g_expectedcall++;
 216     return E_FAIL;
 217 }
 218
 219 static const IDispatchVtbl dispeventVtbl =
 220 {
 221     dispevent_QueryInterface,
 222     dispevent_AddRef,
 223     dispevent_Release,
 224     dispevent_GetTypeInfoCount,
 225     dispevent_GetTypeInfo,
 226     dispevent_GetIDsOfNames,
 227     dispevent_Invoke
 228 };
 229
 230 static IDispatch* create_dispevent(void)
 231 {
 232     dispevent *event = HeapAlloc(GetProcessHeap(), 0, sizeof(*event));
 233
 234     event->IDispatch_iface.lpVtbl = &dispeventVtbl;
 235     event->ref = 1;
 236
 237     return (IDispatch*)&event->IDispatch_iface;
 238 }
 239
 240 /* IStream */
 241 static HRESULT WINAPI istream_QueryInterface(IStream *iface, REFIID riid, void **ppvObject)
 242 {
 243     *ppvObject = NULL;
 244
 245     if (IsEqualGUID(riid, &IID_IStream) ||
 246         IsEqualGUID(riid, &IID_IUnknown))
 247         *ppvObject = iface;
 248     else
 249         return E_NOINTERFACE;
 250
 251     return S_OK;
 252 }
 253
 254 static ULONG WINAPI istream_AddRef(IStream *iface)
 255 {
 256     return 2;
 257 }
 258
 259 static ULONG WINAPI istream_Release(IStream *iface)
 260 {
 261     return 1;
 262 }
 263
 264 static HRESULT WINAPI istream_Read(IStream *iface, void *ptr, ULONG len, ULONG *pread)
 265 {
 266     ok(0, "unexpected call\n");
 267     return E_NOTIMPL;
 268 }
 269
 270 static HRESULT WINAPI istream_Write(IStream *iface, const void *ptr, ULONG len, ULONG *written)
 271 {
 272     *written = len/2;
 273     return S_OK;
 274 }
 275
 276 static HRESULT WINAPI istream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
 277 {
 278     ok(0, "unexpected call\n");
 279     return E_NOTIMPL;
 280 }
 281
 282 static HRESULT WINAPI istream_SetSize(IStream *iface, ULARGE_INTEGER size)
 283 {
 284     ok(0, "unexpected call\n");
 285     return E_NOTIMPL;
 286 }
 287
 288 static HRESULT WINAPI istream_CopyTo(IStream *iface, IStream *stream, ULARGE_INTEGER len,
 289         ULARGE_INTEGER *pread, ULARGE_INTEGER *written)
 290 {
 291     ok(0, "unexpected call\n");
 292     return E_NOTIMPL;
 293 }
 294
 295 static HRESULT WINAPI istream_Commit(IStream *iface, DWORD flags)
 296 {
 297     ok(0, "unexpected call\n");
 298     return E_NOTIMPL;
 299 }
 300
 301 static HRESULT WINAPI istream_Revert(IStream *iface)
 302 {
 303     ok(0, "unexpected call\n");
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI istream_LockRegion(IStream *iface, ULARGE_INTEGER offset,
 308         ULARGE_INTEGER len, DWORD locktype)
 309 {
 310     ok(0, "unexpected call\n");
 311     return E_NOTIMPL;
 312 }
 313
 314 static HRESULT WINAPI istream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset,
 315         ULARGE_INTEGER len, DWORD locktype)
 316 {
 317     ok(0, "unexpected call\n");
 318     return E_NOTIMPL;
 319 }
 320
 321 static HRESULT WINAPI istream_Stat(IStream *iface, STATSTG *pstatstg, DWORD flag)
 322 {
 323     ok(0, "unexpected call\n");
 324     return E_NOTIMPL;
 325 }
 326
 327 static HRESULT WINAPI istream_Clone(IStream *iface, IStream **stream)
 328 {
 329     ok(0, "unexpected call\n");
 330     return E_NOTIMPL;
 331 }
 332
 333 static const IStreamVtbl StreamVtbl = {
 334     istream_QueryInterface,
 335     istream_AddRef,
 336     istream_Release,
 337     istream_Read,
 338     istream_Write,
 339     istream_Seek,
 340     istream_SetSize,
 341     istream_CopyTo,
 342     istream_Commit,
 343     istream_Revert,
 344     istream_LockRegion,
 345     istream_UnlockRegion,
 346     istream_Stat,
 347     istream_Clone
 348 };
 349
 350 static IStream savestream = { &StreamVtbl };
 351
 352 #define EXPECT_CHILDREN(node) _expect_children((IXMLDOMNode*)node, __LINE__)
 353 static void _expect_children(IXMLDOMNode *node, int line)
 354 {
 355     VARIANT_BOOL b;
 356     HRESULT hr;
 357
 358     b = VARIANT_FALSE;
 359     hr = IXMLDOMNode_hasChildNodes(node, &b);
 360     ok_(__FILE__,line)(hr == S_OK, "hasChildNodes() failed, 0x%08x\n", hr);
 361     ok_(__FILE__,line)(b == VARIANT_TRUE, "no children, %d\n", b);
 362 }
 363
 364 #define EXPECT_NO_CHILDREN(node) _expect_no_children((IXMLDOMNode*)node, __LINE__)
 365 static void _expect_no_children(IXMLDOMNode *node, int line)
 366 {
 367     VARIANT_BOOL b;
 368     HRESULT hr;
 369
 370     b = VARIANT_TRUE;
 371     hr = IXMLDOMNode_hasChildNodes(node, &b);
 372     ok_(__FILE__,line)(hr == S_FALSE, "hasChildNodes() failed, 0x%08x\n", hr);
 373     ok_(__FILE__,line)(b == VARIANT_FALSE, "no children, %d\n", b);
 374 }
 375
 376 #define EXPECT_REF(node,ref) _expect_ref((IUnknown*)node, ref, __LINE__)
 377 static void _expect_ref(IUnknown* obj, ULONG ref, int line)
 378 {
 379     ULONG rc = IUnknown_AddRef(obj);
 380     IUnknown_Release(obj);
 381     ok_(__FILE__,line)(rc-1 == ref, "expected refcount %d, got %d\n", ref, rc-1);
 382 }
 383
 384 #define EXPECT_LIST_LEN(list,len) _expect_list_len(list, len, __LINE__)
 385 static void _expect_list_len(IXMLDOMNodeList *list, LONG len, int line)
 386 {
 387     LONG length;
 388     HRESULT hr;
 389
 390     length = 0;
 391     hr = IXMLDOMNodeList_get_length(list, &length);
 392     ok_(__FILE__,line)(hr == S_OK, "got 0x%08x\n", hr);
 393     ok_(__FILE__,line)(length == len, "got %d, expected %d\n", length, len);
 394 }
 395
 396 #define EXPECT_HR(hr,hr_exp) \
 397     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
 398
 399 static const WCHAR szEmpty[] = { 0 };
 400 static const WCHAR szIncomplete[] = {
 401     '<','?','x','m','l',' ',
 402     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
 403 };
 404 static const WCHAR szComplete1[] = {
 405     '<','?','x','m','l',' ',
 406     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 407     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
 408 };
 409 static const WCHAR szComplete2[] = {
 410     '<','?','x','m','l',' ',
 411     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 412     '<','o','>','<','/','o','>','\n',0
 413 };
 414 static const WCHAR szComplete3[] = {
 415     '<','?','x','m','l',' ',
 416     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 417     '<','a','>','<','/','a','>','\n',0
 418 };
 419 static const char complete4A[] =
 420     "<?xml version=\'1.0\'?>\n"
 421     "<lc dl=\'str1\'>\n"
 422         "<bs vr=\'str2\' sz=\'1234\'>"
 423             "fn1.txt\n"
 424         "</bs>\n"
 425         "<pr id=\'str3\' vr=\'1.2.3\' pn=\'wine 20050804\'>\n"
 426             "fn2.txt\n"
 427         "</pr>\n"
 428         "<empty></empty>\n"
 429         "<fo>\n"
 430             "<ba>\n"
 431                 "f1\n"
 432             "</ba>\n"
 433         "</fo>\n"
 434     "</lc>\n";
 435
 436 static const WCHAR szComplete5[] = {
 437     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
 438     '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','"',
 439     ' ','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','"','>',
 440         '<','S',':','s','c','o','p','e','>',
 441             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
 442         '<','/','S',':','s','c','o','p','e','>',
 443         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
 444             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
 445             'c','o','m','p','u','t','e','r',
 446         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
 447     '<','/','S',':','s','e','a','r','c','h','>',0
 448 };
 449
 450 static const WCHAR szComplete6[] = {
 451     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'',' ',
 452     'e','n','c','o','d','i','n','g','=','\'','W','i','n','d','o','w','s','-','1','2','5','2','\'','?','>','\n',
 453     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
 454 };
 455
 456 static const char complete7[] = {
 457     "<?xml version=\"1.0\"?>\n\t"
 458     "<root>\n"
 459     "\t<a/>\n"
 460     "\t<b/>\n"
 461     "\t<c/>\n"
 462     "</root>"
 463 };
 464
 465 #define DECL_WIN_1252 \
 466 "<?xml version=\"1.0\" encoding=\"Windows-1252\"?>"
 467
 468 static const char win1252xml[] =
 469 DECL_WIN_1252
 470 "<open></open>";
 471
 472 static const char win1252decl[] =
 473 DECL_WIN_1252
 474 ;
 475
 476 static const char nocontent[] = "no xml content here";
 477
 478 static const char szExampleXML[] =
 479 "<?xml version='1.0' encoding='utf-8'?>\n"
 480 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' a=\"attr a\" foo:b=\"attr b\" >\n"
 481 "    <elem>\n"
 482 "        <a>A1 field</a>\n"
 483 "        <b>B1 field</b>\n"
 484 "        <c>C1 field</c>\n"
 485 "        <d>D1 field</d>\n"
 486 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 487 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
 488 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
 489 "            </html>\n"
 490 "            <html xml:space='preserve' xmlns='http://www.w3.org/1999/xhtml'>\n"
 491 "                This is <strong>a</strong> <i>description</i> with preserved whitespace. <bar:x/>\n"
 492 "            </html>\n"
 493 "        </description>\n"
 494 "    </elem>\n"
 495 "\n"
 496 "    <elem>\n"
 497 "        <a>A2 field</a>\n"
 498 "        <b>B2 field</b>\n"
 499 "        <c type=\"old\">C2 field</c>\n"
 500 "        <d>D2 field</d>\n"
 501 "    </elem>\n"
 502 "\n"
 503 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 504 "        <a>A3 field</a>\n"
 505 "        <b>B3 field</b>\n"
 506 "        <c>C3 field</c>\n"
 507 "    </elem>\n"
 508 "\n"
 509 "    <elem>\n"
 510 "        <a>A4 field</a>\n"
 511 "        <b>B4 field</b>\n"
 512 "        <foo:c>C4 field</foo:c>\n"
 513 "        <d>D4 field</d>\n"
 514 "    </elem>\n"
 515 "</root>\n";
 516
 517 static const char charrefsxml[] =
 518 "<?xml version='1.0'?>"
 519 "<a>"
 520 "<b1> Text &#65; end </b1>"
 521 "<b2>&#65;&#66; &#67; </b2>"
 522 "</a>";
 523
 524 static const CHAR szNodeTypesXML[] =
 525 "<?xml version='1.0'?>"
 526 "<!-- comment node 0 -->"
 527 "<root id='0' depth='0'>"
 528 "   <!-- comment node 1 -->"
 529 "   text node 0"
 530 "   <x id='1' depth='1'>"
 531 "       <?foo value='PI for x'?>"
 532 "       <!-- comment node 2 -->"
 533 "       text node 1"
 534 "       <a id='3' depth='2'/>"
 535 "       <b id='4' depth='2'/>"
 536 "       <c id='5' depth='2'/>"
 537 "   </x>"
 538 "   <y id='2' depth='1'>"
 539 "       <?bar value='PI for y'?>"
 540 "       <!-- comment node 3 -->"
 541 "       text node 2"
 542 "       <a id='6' depth='2'/>"
 543 "       <b id='7' depth='2'/>"
 544 "       <c id='8' depth='2'/>"
 545 "   </y>"
 546 "</root>";
 547
 548 static const CHAR szTransformXML[] =
 549 "<?xml version=\"1.0\"?>\n"
 550 "<greeting>\n"
 551 "Hello World\n"
 552 "</greeting>";
 553
 554 static  const CHAR szTransformSSXML[] =
 555 "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
 556 "   <xsl:output method=\"html\"/>\n"
 557 "   <xsl:template match=\"/\">\n"
 558 "       <xsl:apply-templates select=\"greeting\"/>\n"
 559 "   </xsl:template>\n"
 560 "   <xsl:template match=\"greeting\">\n"
 561 "       <html>\n"
 562 "           <body>\n"
 563 "               <h1>\n"
 564 "                   <xsl:value-of select=\".\"/>\n"
 565 "               </h1>\n"
 566 "           </body>\n"
 567 "       </html>\n"
 568 "   </xsl:template>\n"
 569 "</xsl:stylesheet>";
 570
 571 static  const CHAR szTransformOutput[] =
 572 "<html><body><h1>"
 573 "Hello World"
 574 "</h1></body></html>";
 575
 576 static const CHAR szTypeValueXML[] =
 577 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
 578 "<root xmlns:dt=\"urn:schemas-microsoft-com:datatypes\">\n"
 579 "   <string>Wine</string>\n"
 580 "   <string2 dt:dt=\"string\">String</string2>\n"
 581 "   <number dt:dt=\"number\">12.44</number>\n"
 582 "   <number2 dt:dt=\"NUMbEr\">-3.71e3</number2>\n"
 583 "   <int dt:dt=\"int\">-13</int>\n"
 584 "   <fixed dt:dt=\"fixed.14.4\">7322.9371</fixed>\n"
 585 "   <bool dt:dt=\"boolean\">1</bool>\n"
 586 "   <datetime dt:dt=\"datetime\">2009-11-18T03:21:33.12</datetime>\n"
 587 "   <datetimetz dt:dt=\"datetime.tz\">2003-07-11T11:13:57+03:00</datetimetz>\n"
 588 "   <date dt:dt=\"date\">3721-11-01</date>\n"
 589 "   <time dt:dt=\"time\">13:57:12.31321</time>\n"
 590 "   <timetz dt:dt=\"time.tz\">23:21:01.13+03:21</timetz>\n"
 591 "   <i1 dt:dt=\"i1\">-13</i1>\n"
 592 "   <i2 dt:dt=\"i2\">31915</i2>\n"
 593 "   <i4 dt:dt=\"i4\">-312232</i4>\n"
 594 "   <ui1 dt:dt=\"ui1\">123</ui1>\n"
 595 "   <ui2 dt:dt=\"ui2\">48282</ui2>\n"
 596 "   <ui4 dt:dt=\"ui4\">949281</ui4>\n"
 597 "   <r4 dt:dt=\"r4\">213124.0</r4>\n"
 598 "   <r8 dt:dt=\"r8\">0.412</r8>\n"
 599 "   <float dt:dt=\"float\">41221.421</float>\n"
 600 "   <uuid dt:dt=\"uuid\">333C7BC4-460F-11D0-BC04-0080C7055a83</uuid>\n"
 601 "   <binhex dt:dt=\"bin.hex\">fffca012003c</binhex>\n"
 602 "   <binbase64 dt:dt=\"bin.base64\">YmFzZTY0IHRlc3Q=</binbase64>\n"
 603 "   <binbase64_1 dt:dt=\"bin.base64\">\nYmFzZTY0\nIHRlc3Q=\n</binbase64_1>\n"
 604 "   <binbase64_2 dt:dt=\"bin.base64\">\nYmF\r\t z  ZTY0\nIHRlc3Q=\n</binbase64_2>\n"
 605 "</root>";
 606
 607 static const CHAR szBasicTransformSSXMLPart1[] =
 608 "<?xml version=\"1.0\"?>"
 609 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
 610 "<xsl:output method=\"html\"/>\n"
 611 "<xsl:template match=\"/\">"
 612 "<HTML><BODY><TABLE>"
 613 "        <xsl:apply-templates select='document(\"";
 614
 615 static const CHAR szBasicTransformSSXMLPart2[] =
 616 "\")/bottle/wine'>"
 617 "           <xsl:sort select=\"cost\"/><xsl:sort select=\"name\"/>"
 618 "        </xsl:apply-templates>"
 619 "</TABLE></BODY></HTML>"
 620 "</xsl:template>"
 621 "<xsl:template match=\"bottle\">"
 622 "   <TR><xsl:apply-templates select=\"name\" /><xsl:apply-templates select=\"cost\" /></TR>"
 623 "</xsl:template>"
 624 "<xsl:template match=\"name\">"
 625 "   <TD><xsl:apply-templates /></TD>"
 626 "</xsl:template>"
 627 "<xsl:template match=\"cost\">"
 628 "   <TD><xsl:apply-templates /></TD>"
 629 "</xsl:template>"
 630 "</xsl:stylesheet>";
 631
 632 static const CHAR szBasicTransformXML[] =
 633 "<?xml version=\"1.0\"?><bottle><wine><name>Wine</name><cost>$25.00</cost></wine></bottle>";
 634
 635 static const CHAR szBasicTransformOutput[] =
 636 "<HTML><BODY><TABLE><TD>Wine</TD><TD>$25.00</TD></TABLE></BODY></HTML>";
 637
 638 #define SZ_EMAIL_DTD \
 639 "<!DOCTYPE email ["\
 640 "   <!ELEMENT email         (recipients,from,reply-to?,subject,body,attachment*)>"\
 641 "       <!ATTLIST email attachments IDREFS #REQUIRED>"\
 642 "       <!ATTLIST email sent (yes|no) \"no\">"\
 643 "   <!ELEMENT recipients    (to+,cc*)>"\
 644 "   <!ELEMENT to            (#PCDATA)>"\
 645 "       <!ATTLIST to name CDATA #IMPLIED>"\
 646 "   <!ELEMENT cc            (#PCDATA)>"\
 647 "       <!ATTLIST cc name CDATA #IMPLIED>"\
 648 "   <!ELEMENT from          (#PCDATA)>"\
 649 "       <!ATTLIST from name CDATA #IMPLIED>"\
 650 "   <!ELEMENT reply-to      (#PCDATA)>"\
 651 "       <!ATTLIST reply-to name CDATA #IMPLIED>"\
 652 "   <!ELEMENT subject       ANY>"\
 653 "   <!ELEMENT body          ANY>"\
 654 "       <!ATTLIST body enc CDATA #FIXED \"UTF-8\">"\
 655 "   <!ELEMENT attachment    (#PCDATA)>"\
 656 "       <!ATTLIST attachment id ID #REQUIRED>"\
 657 "]>"
 658
 659 static const CHAR szEmailXML[] =
 660 "<?xml version=\"1.0\"?>"
 661 SZ_EMAIL_DTD
 662 "<email attachments=\"patch1\">"
 663 "   <recipients>"
 664 "       <to>wine-patches@winehq.org</to>"
 665 "   </recipients>"
 666 "   <from name=\"Anonymous\">user@localhost</from>"
 667 "   <subject>msxml3/tests: DTD validation (try 87)</subject>"
 668 "   <body>"
 669 "       It no longer causes spontaneous combustion..."
 670 "   </body>"
 671 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 672 "</email>";
 673
 674 static const CHAR szEmailXML_0D[] =
 675 "<?xml version=\"1.0\"?>"
 676 SZ_EMAIL_DTD
 677 "<email attachments=\"patch1\">"
 678 "   <recipients>"
 679 "       <to>wine-patches@winehq.org</to>"
 680 "   </recipients>"
 681 "   <from name=\"Anonymous\">user@localhost</from>"
 682 "   <subject>msxml3/tests: DTD validation (try 88)</subject>"
 683 "   <body>"
 684 "       <undecl />"
 685 "       XML_ELEMENT_UNDECLARED 0xC00CE00D"
 686 "   </body>"
 687 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 688 "</email>";
 689
 690 static const CHAR szEmailXML_0E[] =
 691 "<?xml version=\"1.0\"?>"
 692 SZ_EMAIL_DTD
 693 "<email attachments=\"patch1\">"
 694 "   <recipients>"
 695 "       <to>wine-patches@winehq.org</to>"
 696 "   </recipients>"
 697 "   <from name=\"Anonymous\">user@localhost</from>"
 698 "   <subject>msxml3/tests: DTD validation (try 89)</subject>"
 699 "   <body>"
 700 "       XML_ELEMENT_ID_NOT_FOUND 0xC00CE00E"
 701 "   </body>"
 702 "   <attachment id=\"patch\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 703 "</email>";
 704
 705 static const CHAR szEmailXML_11[] =
 706 "<?xml version=\"1.0\"?>"
 707 SZ_EMAIL_DTD
 708 "<email attachments=\"patch1\">"
 709 "   <recipients>"
 710 "   </recipients>"
 711 "   <from name=\"Anonymous\">user@localhost</from>"
 712 "   <subject>msxml3/tests: DTD validation (try 90)</subject>"
 713 "   <body>"
 714 "       XML_EMPTY_NOT_ALLOWED 0xC00CE011"
 715 "   </body>"
 716 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 717 "</email>";
 718
 719 static const CHAR szEmailXML_13[] =
 720 "<?xml version=\"1.0\"?>"
 721 SZ_EMAIL_DTD
 722 "<msg attachments=\"patch1\">"
 723 "   <recipients>"
 724 "       <to>wine-patches@winehq.org</to>"
 725 "   </recipients>"
 726 "   <from name=\"Anonymous\">user@localhost</from>"
 727 "   <subject>msxml3/tests: DTD validation (try 91)</subject>"
 728 "   <body>"
 729 "       XML_ROOT_NAME_MISMATCH 0xC00CE013"
 730 "   </body>"
 731 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 732 "</msg>";
 733
 734 static const CHAR szEmailXML_14[] =
 735 "<?xml version=\"1.0\"?>"
 736 SZ_EMAIL_DTD
 737 "<email attachments=\"patch1\">"
 738 "   <to>wine-patches@winehq.org</to>"
 739 "   <from name=\"Anonymous\">user@localhost</from>"
 740 "   <subject>msxml3/tests: DTD validation (try 92)</subject>"
 741 "   <body>"
 742 "       XML_INVALID_CONTENT 0xC00CE014"
 743 "   </body>"
 744 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 745 "</email>";
 746
 747 static const CHAR szEmailXML_15[] =
 748 "<?xml version=\"1.0\"?>"
 749 SZ_EMAIL_DTD
 750 "<email attachments=\"patch1\" ip=\"127.0.0.1\">"
 751 "   <recipients>"
 752 "       <to>wine-patches@winehq.org</to>"
 753 "   </recipients>"
 754 "   <from name=\"Anonymous\">user@localhost</from>"
 755 "   <subject>msxml3/tests: DTD validation (try 93)</subject>"
 756 "   <body>"
 757 "       XML_ATTRIBUTE_NOT_DEFINED 0xC00CE015"
 758 "   </body>"
 759 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 760 "</email>";
 761
 762 static const CHAR szEmailXML_16[] =
 763 "<?xml version=\"1.0\"?>"
 764 SZ_EMAIL_DTD
 765 "<email attachments=\"patch1\">"
 766 "   <recipients>"
 767 "       <to>wine-patches@winehq.org</to>"
 768 "   </recipients>"
 769 "   <from name=\"Anonymous\">user@localhost</from>"
 770 "   <subject>msxml3/tests: DTD validation (try 94)</subject>"
 771 "   <body enc=\"ASCII\">"
 772 "       XML_ATTRIBUTE_FIXED 0xC00CE016"
 773 "   </body>"
 774 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 775 "</email>";
 776
 777 static const CHAR szEmailXML_17[] =
 778 "<?xml version=\"1.0\"?>"
 779 SZ_EMAIL_DTD
 780 "<email attachments=\"patch1\" sent=\"true\">"
 781 "   <recipients>"
 782 "       <to>wine-patches@winehq.org</to>"
 783 "   </recipients>"
 784 "   <from name=\"Anonymous\">user@localhost</from>"
 785 "   <subject>msxml3/tests: DTD validation (try 95)</subject>"
 786 "   <body>"
 787 "       XML_ATTRIBUTE_VALUE 0xC00CE017"
 788 "   </body>"
 789 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 790 "</email>";
 791
 792 static const CHAR szEmailXML_18[] =
 793 "<?xml version=\"1.0\"?>"
 794 SZ_EMAIL_DTD
 795 "<email attachments=\"patch1\">"
 796 "   oops"
 797 "   <recipients>"
 798 "       <to>wine-patches@winehq.org</to>"
 799 "   </recipients>"
 800 "   <from name=\"Anonymous\">user@localhost</from>"
 801 "   <subject>msxml3/tests: DTD validation (try 96)</subject>"
 802 "   <body>"
 803 "       XML_ILLEGAL_TEXT 0xC00CE018"
 804 "   </body>"
 805 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 806 "</email>";
 807
 808 static const CHAR szEmailXML_20[] =
 809 "<?xml version=\"1.0\"?>"
 810 SZ_EMAIL_DTD
 811 "<email>"
 812 "   <recipients>"
 813 "       <to>wine-patches@winehq.org</to>"
 814 "   </recipients>"
 815 "   <from name=\"Anonymous\">user@localhost</from>"
 816 "   <subject>msxml3/tests: DTD validation (try 97)</subject>"
 817 "   <body>"
 818 "       XML_REQUIRED_ATTRIBUTE_MISSING 0xC00CE020"
 819 "   </body>"
 820 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 821 "</email>";
 822
 823 static const char xpath_simple_list[] =
 824 "<?xml version=\"1.0\"?>"
 825 "<root>"
 826 "   <a attr1=\"1\" attr2=\"2\" />"
 827 "   <b/>"
 828 "   <c/>"
 829 "   <d/>"
 830 "</root>";
 831
 832 static const char default_ns_doc[] = {
 833     "<?xml version=\"1.0\"?>"
 834     "<a xmlns:ns=\"nshref\" xml:lang=\"ru\" ns:b=\"b attr\" xml:c=\"c attr\" "
 835     "    d=\"d attr\" />"
 836 };
 837
 838 static const char attributes_map[] = {
 839     "<?xml version=\"1.0\"?>"
 840     "<a attr1=\"value1\" attr2=\"value2\" attr3=\"value3\" attr4=\"value4\" />"
 841 };
 842
 843 static const WCHAR nonexistent_fileW[] = {
 844     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
 845 };
 846 static const WCHAR nonexistent_attrW[] = {
 847     'n','o','n','E','x','i','s','i','t','i','n','g','A','t','t','r','i','b','u','t','e',0
 848 };
 849 static const WCHAR szDocument[] = {
 850     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
 851 };
 852
 853 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
 854 static const WCHAR szdl[] = { 'd','l',0 };
 855 static const WCHAR szvr[] = { 'v','r',0 };
 856 static const WCHAR szlc[] = { 'l','c',0 };
 857 static const WCHAR szbs[] = { 'b','s',0 };
 858 static const WCHAR szstr1[] = { 's','t','r','1',0 };
 859 static const WCHAR szstr2[] = { 's','t','r','2',0 };
 860 static const WCHAR szstar[] = { '*',0 };
 861 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
 862
 863 static const WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
 864 static const WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
 865 static const WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
 866
 867 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
 868 static const WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
 869 static const WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
 870 static const WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 871                                       'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
 872 static const WCHAR szElementXML4[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 873                                       '&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 };
 874
 875 static const WCHAR szAttribute[] = {'A','t','t','r',0 };
 876 static const WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
 877
 878 static const WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
 879                                 ' ','n','o','t',' ','r','i','g','h','t','!', 0};
 880 static const WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
 881                                    'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
 882                                    '!',']',']','>',0};
 883 static const WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
 884 static const WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
 885
 886 static const WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
 887 static const WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
 888 static const WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0};
 889
 890 #define expect_bstr_eq_and_free(bstr, expect) { \
 891     BSTR bstrExp = alloc_str_from_narrow(expect); \
 892     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
 893     SysFreeString(bstr); \
 894     SysFreeString(bstrExp); \
 895 }
 896
 897 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
 898
 899 #define ole_check(expr) { \
 900     HRESULT r = expr; \
 901     ok(r == S_OK, #expr " returned %x\n", r); \
 902 }
 903
 904 #define ole_expect(expr, expect) { \
 905     HRESULT r = expr; \
 906     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
 907 }
 908
 909 #define double_eq(x, y) ok((x)-(y)<=1e-14*(x) && (x)-(y)>=-1e-14*(x), "expected %.16g, got %.16g\n", x, y)
 910
 911 static void* _create_object(const GUID *clsid, const char *name, const IID *iid, int line)
 912 {
 913     void *obj = NULL;
 914     HRESULT hr;
 915
 916     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
 917     ok(hr == S_OK, "failed to create %s instance: 0x%08x\n", name, hr);
 918
 919     return obj;
 920 }
 921
 922 #define _create(cls) cls, #cls
 923
 924 #define create_document(iid) _create_object(&_create(CLSID_DOMDocument2), iid, __LINE__)
 925 #define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
 926 #define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
 927 #define create_xsltemplate(iid) _create_object(&_create(CLSID_XSLTemplate), iid, __LINE__)
 928
 929 static BSTR alloc_str_from_narrow(const char *str)
 930 {
 931     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 932     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
 933     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 934     return ret;
 935 }
 936
 937 static BSTR alloced_bstrs[256];
 938 static int alloced_bstrs_count;
 939
 940 static BSTR _bstr_(const char *str)
 941 {
 942     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
 943     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
 944     return alloced_bstrs[alloced_bstrs_count++];
 945 }
 946
 947 static void free_bstrs(void)
 948 {
 949     int i;
 950     for (i = 0; i < alloced_bstrs_count; i++)
 951         SysFreeString(alloced_bstrs[i]);
 952     alloced_bstrs_count = 0;
 953 }
 954
 955 static VARIANT _variantbstr_(const char *str)
 956 {
 957     VARIANT v;
 958     V_VT(&v) = VT_BSTR;
 959     V_BSTR(&v) = _bstr_(str);
 960     return v;
 961 }
 962
 963 static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
 964 {
 965     for (;;)
 966     {
 967         while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
 968         while (*sRight == '\r' || *sRight == '\n') sRight++;
 969         if (*sLeft != *sRight) return FALSE;
 970         if (!*sLeft) return TRUE;
 971         sLeft++;
 972         sRight++;
 973     }
 974 }
 975
 976 static void get_str_for_type(DOMNodeType type, char *buf)
 977 {
 978     switch (type)
 979     {
 980         case NODE_ATTRIBUTE:
 981             strcpy(buf, "A");
 982             break;
 983         case NODE_ELEMENT:
 984             strcpy(buf, "E");
 985             break;
 986         case NODE_DOCUMENT:
 987             strcpy(buf, "D");
 988             break;
 989         case NODE_TEXT:
 990             strcpy(buf, "T");
 991             break;
 992         case NODE_COMMENT:
 993             strcpy(buf, "C");
 994             break;
 995         case NODE_PROCESSING_INSTRUCTION:
 996             strcpy(buf, "P");
 997             break;
 998         default:
 999             wsprintfA(buf, "[%d]", type);
1000     }
1001 }
1002
1003 static int get_node_position(IXMLDOMNode *node)
1004 {
1005     HRESULT r;
1006     int pos = 0;
1007
1008     IXMLDOMNode_AddRef(node);
1009     do
1010     {
1011         IXMLDOMNode *new_node;
1012
1013         pos++;
1014         r = IXMLDOMNode_get_previousSibling(node, &new_node);
1015         ok(SUCCEEDED(r), "get_previousSibling failed\n");
1016         IXMLDOMNode_Release(node);
1017         node = new_node;
1018     } while (r == S_OK);
1019     return pos;
1020 }
1021
1022 static void node_to_string(IXMLDOMNode *node, char *buf)
1023 {
1024     HRESULT r = S_OK;
1025     DOMNodeType type;
1026
1027     if (node == NULL)
1028     {
1029         lstrcpyA(buf, "(null)");
1030         return;
1031     }
1032
1033     IXMLDOMNode_AddRef(node);
1034     while (r == S_OK)
1035     {
1036         IXMLDOMNode *new_node;
1037
1038         ole_check(IXMLDOMNode_get_nodeType(node, &type));
1039         get_str_for_type(type, buf);
1040         buf+=strlen(buf);
1041
1042         if (type == NODE_ATTRIBUTE)
1043         {
1044             BSTR bstr;
1045             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
1046             *(buf++) = '\'';
1047             wsprintfA(buf, "%ws", bstr);
1048             buf += strlen(buf);
1049             *(buf++) = '\'';
1050             SysFreeString(bstr);
1051
1052             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
1053         }
1054         else
1055         {
1056             r = IXMLDOMNode_get_parentNode(node, &new_node);
1057             sprintf(buf, "%d", get_node_position(node));
1058             buf += strlen(buf);
1059         }
1060
1061         ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
1062         IXMLDOMNode_Release(node);
1063         node = new_node;
1064         if (r == S_OK)
1065             *(buf++) = '.';
1066     }
1067
1068     *buf = 0;
1069 }
1070
1071 static char *list_to_string(IXMLDOMNodeList *list)
1072 {
1073     static char buf[4096];
1074     char *pos = buf;
1075     LONG len = 0;
1076     int i;
1077
1078     if (list == NULL)
1079     {
1080         lstrcpyA(buf, "(null)");
1081         return buf;
1082     }
1083     ole_check(IXMLDOMNodeList_get_length(list, &len));
1084     for (i = 0; i < len; i++)
1085     {
1086         IXMLDOMNode *node;
1087         if (i > 0)
1088             *(pos++) = ' ';
1089         ole_check(IXMLDOMNodeList_nextNode(list, &node));
1090         node_to_string(node, pos);
1091         pos += strlen(pos);
1092         IXMLDOMNode_Release(node);
1093     }
1094     *pos = 0;
1095     return buf;
1096 }
1097
1098 #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); }
1099 #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); }
1100
1101 struct docload_ret_t {
1102     VARIANT_BOOL b;
1103     HRESULT hr;
1104 };
1105
1106 struct leading_spaces_t {
1107     const CLSID *clsid;
1108     const char *name;
1109     struct docload_ret_t ret[2]; /* 0 - ::load(), 1 - ::loadXML() */
1110 };
1111
1112 static const struct leading_spaces_t leading_spaces_classdata[] = {
1113     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
1114     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1115     { &CLSID_DOMDocument26, "CLSID_DOMDocument26", {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
1116     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1117     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1118     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1119     { NULL }
1120 };
1121
1122 static const char* leading_spaces_xmldata[] = {
1123     "\n<?xml version=\"1.0\" encoding=\"UTF-16\" ?><root/>",
1124     " <?xml version=\"1.0\"?><root/>",
1125     "\n<?xml version=\"1.0\"?><root/>",
1126     "\t<?xml version=\"1.0\"?><root/>",
1127     "\r\n<?xml version=\"1.0\"?><root/>",
1128     "\r<?xml version=\"1.0\"?><root/>",
1129     "\r\r\r\r\t\t \n\n <?xml version=\"1.0\"?><root/>",
1130     0
1131 };
1132
1133 static void test_domdoc( void )
1134 {
1135     HRESULT r, hr;
1136     IXMLDOMDocument *doc;
1137     IXMLDOMParseError *error;
1138     IXMLDOMElement *element = NULL;
1139     IXMLDOMNode *node;
1140     IXMLDOMText *nodetext = NULL;
1141     IXMLDOMComment *node_comment = NULL;
1142     IXMLDOMAttribute *node_attr = NULL;
1143     IXMLDOMNode *nodeChild = NULL;
1144     IXMLDOMProcessingInstruction *nodePI = NULL;
1145     const struct leading_spaces_t *class_ptr;
1146     const char **data_ptr;
1147     VARIANT_BOOL b;
1148     VARIANT var;
1149     BSTR str;
1150     LONG code, ref;
1151     LONG nLength = 0;
1152     WCHAR buff[100];
1153     char path[MAX_PATH];
1154     int index;
1155
1156     GetTempPathA(MAX_PATH, path);
1157     strcat(path, "leading_spaces.xml");
1158
1159     /* Load document with leading spaces
1160      *
1161      * Test all CLSIDs with all test data XML strings
1162      */
1163     class_ptr = leading_spaces_classdata;
1164     index = 0;
1165     while (class_ptr->clsid)
1166     {
1167         HRESULT hr;
1168         int i;
1169
1170         if (is_clsid_supported(class_ptr->clsid, &IID_IXMLDOMDocument))
1171         {
1172             hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
1173         }
1174         else
1175         {
1176             class_ptr++;
1177             index++;
1178             continue;
1179         }
1180
1181         data_ptr = leading_spaces_xmldata;
1182         i = 0;
1183         while (*data_ptr) {
1184             BSTR data = _bstr_(*data_ptr);
1185             DWORD written;
1186             HANDLE file;
1187
1188             file = CreateFileA(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
1189             ok(file != INVALID_HANDLE_VALUE, "can't create file %s: %u\n", path, GetLastError());
1190
1191             WriteFile(file, data, lstrlenW(data)*sizeof(WCHAR), &written, NULL);
1192             CloseHandle(file);
1193
1194             b = 0xc;
1195             V_VT(&var) = VT_BSTR;
1196             V_BSTR(&var) = _bstr_(path);
1197             hr = IXMLDOMDocument_load(doc, var, &b);
1198             EXPECT_HR(hr, class_ptr->ret[0].hr);
1199             ok(b == class_ptr->ret[0].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[0].b);
1200
1201             DeleteFileA(path);
1202
1203             b = 0xc;
1204             hr = IXMLDOMDocument_loadXML(doc, data, &b);
1205             EXPECT_HR(hr, class_ptr->ret[1].hr);
1206             ok(b == class_ptr->ret[1].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[1].b);
1207
1208             data_ptr++;
1209             i++;
1210         }
1211
1212         class_ptr++;
1213         index++;
1214         free_bstrs();
1215     }
1216
1217     doc = create_document(&IID_IXMLDOMDocument);
1218     if (!doc) return;
1219
1220 if (0)
1221 {
1222     /* crashes on native */
1223     IXMLDOMDocument_loadXML( doc, (BSTR)0x1, NULL );
1224 }
1225
1226     /* try some stupid things */
1227     hr = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1228     EXPECT_HR(hr, S_FALSE);
1229
1230     b = VARIANT_TRUE;
1231     hr = IXMLDOMDocument_loadXML( doc, NULL, &b );
1232     EXPECT_HR(hr, S_FALSE);
1233     ok( b == VARIANT_FALSE, "failed to load XML string\n");
1234
1235     /* try to load a document from a nonexistent file */
1236     b = VARIANT_TRUE;
1237     str = SysAllocString( nonexistent_fileW );
1238     VariantInit(&var);
1239     V_VT(&var) = VT_BSTR;
1240     V_BSTR(&var) = str;
1241
1242     r = IXMLDOMDocument_load( doc, var, &b);
1243     ok( r == S_FALSE, "loadXML succeeded\n");
1244     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1245     SysFreeString( str );
1246
1247     str = (BSTR)0x1;
1248     hr = IXMLDOMDocument_get_url(doc, &str);
1249     ok(hr == S_FALSE, "got 0x%08x\n", hr);
1250     ok(str == NULL, "got %p\n", str);
1251
1252     /* try load an empty document */
1253     b = VARIANT_TRUE;
1254     str = SysAllocString( szEmpty );
1255     r = IXMLDOMDocument_loadXML( doc, str, &b );
1256     ok( r == S_FALSE, "loadXML succeeded\n");
1257     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1258     SysFreeString( str );
1259
1260     r = IXMLDOMDocument_get_async( doc, &b );
1261     ok( r == S_OK, "get_async failed (%08x)\n", r);
1262     ok( b == VARIANT_TRUE, "Wrong default value\n");
1263
1264     /* check that there's no document element */
1265     element = NULL;
1266     r = IXMLDOMDocument_get_documentElement( doc, &element );
1267     ok( r == S_FALSE, "should be no document element\n");
1268
1269     /* try finding a node */
1270     node = NULL;
1271     str = SysAllocString( szstr1 );
1272     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
1273     ok( r == S_FALSE, "ret %08x\n", r );
1274     SysFreeString( str );
1275
1276     b = VARIANT_TRUE;
1277     str = SysAllocString( szIncomplete );
1278     r = IXMLDOMDocument_loadXML( doc, str, &b );
1279     ok( r == S_FALSE, "loadXML succeeded\n");
1280     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1281     SysFreeString( str );
1282
1283     /* check that there's no document element */
1284     element = (IXMLDOMElement*)1;
1285     r = IXMLDOMDocument_get_documentElement( doc, &element );
1286     ok( r == S_FALSE, "should be no document element\n");
1287     ok( element == NULL, "Element should be NULL\n");
1288
1289     /* test for BSTR handling, pass broken BSTR */
1290     memcpy(&buff[2], szComplete1, sizeof(szComplete1));
1291     /* just a big length */
1292     *(DWORD*)buff = 0xf0f0;
1293     b = VARIANT_FALSE;
1294     r = IXMLDOMDocument_loadXML( doc, &buff[2], &b );
1295     ok( r == S_OK, "loadXML failed\n");
1296     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1297
1298     /* loadXML ignores the encoding attribute and always expects Unicode */
1299     b = VARIANT_FALSE;
1300     str = SysAllocString( szComplete6 );
1301     r = IXMLDOMDocument_loadXML( doc, str, &b );
1302     ok( r == S_OK, "loadXML failed\n");
1303     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1304     SysFreeString( str );
1305
1306     /* try a BSTR containing a Windows-1252 document */
1307     b = VARIANT_TRUE;
1308     str = SysAllocStringByteLen( win1252xml, strlen(win1252xml) );
1309     r = IXMLDOMDocument_loadXML( doc, str, &b );
1310     ok( r == S_FALSE, "loadXML succeeded\n");
1311     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1312     SysFreeString( str );
1313
1314     /* try to load something valid */
1315     b = VARIANT_FALSE;
1316     str = SysAllocString( szComplete1 );
1317     r = IXMLDOMDocument_loadXML( doc, str, &b );
1318     ok( r == S_OK, "loadXML failed\n");
1319     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1320     SysFreeString( str );
1321
1322     /* check if nodename is correct */
1323     r = IXMLDOMDocument_get_nodeName( doc, NULL );
1324     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1325
1326     str = (BSTR)0xdeadbeef;
1327     r = IXMLDOMDocument_get_baseName( doc, &str );
1328     ok ( r == S_FALSE, "got 0x%08x\n", r);
1329     ok (str == NULL, "got %p\n", str);
1330
1331     /* content doesn't matter here */
1332     str = NULL;
1333     r = IXMLDOMDocument_get_nodeName( doc, &str );
1334     ok ( r == S_OK, "get_nodeName wrong code\n");
1335     ok ( str != NULL, "str is null\n");
1336     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
1337     SysFreeString( str );
1338
1339     /* test put_text */
1340     r = IXMLDOMDocument_put_text( doc, _bstr_("Should fail") );
1341     ok( r == E_FAIL, "ret %08x\n", r );
1342
1343     /* check that there's a document element */
1344     element = NULL;
1345     r = IXMLDOMDocument_get_documentElement( doc, &element );
1346     ok( r == S_OK, "should be a document element\n");
1347     if( element )
1348     {
1349         IObjectIdentity *ident;
1350
1351         r = IXMLDOMElement_QueryInterface( element, &IID_IObjectIdentity, (void**)&ident );
1352         ok( r == E_NOINTERFACE, "ret %08x\n", r);
1353
1354         IXMLDOMElement_Release( element );
1355         element = NULL;
1356     }
1357
1358     /* as soon as we call loadXML again, the document element will disappear */
1359     b = 2;
1360     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1361     ok( r == S_FALSE, "loadXML failed\n");
1362     ok( b == 2, "variant modified\n");
1363     r = IXMLDOMDocument_get_documentElement( doc, &element );
1364     ok( r == S_FALSE, "should be no document element\n");
1365
1366     /* try to load something else simple and valid */
1367     b = VARIANT_FALSE;
1368     str = SysAllocString( szComplete3 );
1369     r = IXMLDOMDocument_loadXML( doc, str, &b );
1370     ok( r == S_OK, "loadXML failed\n");
1371     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1372     SysFreeString( str );
1373
1374     /* try something a little more complicated */
1375     b = FALSE;
1376     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
1377     ok( r == S_OK, "loadXML failed\n");
1378     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1379
1380     r = IXMLDOMDocument_get_parseError( doc, &error );
1381     ok( r == S_OK, "returns %08x\n", r );
1382
1383     r = IXMLDOMParseError_get_errorCode( error, &code );
1384     ok( r == S_FALSE, "returns %08x\n", r );
1385     ok( code == 0, "code %d\n", code );
1386     IXMLDOMParseError_Release( error );
1387
1388     /* test createTextNode */
1389     r = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &nodetext);
1390     ok( r == S_OK, "returns %08x\n", r );
1391     IXMLDOMText_Release(nodetext);
1392
1393     str = SysAllocString( szOpen );
1394     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
1395     ok( r == E_INVALIDARG, "returns %08x\n", r );
1396     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
1397     ok( r == S_OK, "returns %08x\n", r );
1398     SysFreeString( str );
1399     if(nodetext)
1400     {
1401         r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (void**)&element);
1402         ok(r == E_NOINTERFACE, "ret %08x\n", r );
1403
1404         /* Text Last Child Checks */
1405         r = IXMLDOMText_get_lastChild(nodetext, NULL);
1406         ok(r == E_INVALIDARG, "ret %08x\n", r );
1407
1408         nodeChild = (IXMLDOMNode*)0x1;
1409         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
1410         ok(r == S_FALSE, "ret %08x\n", r );
1411         ok(nodeChild == NULL, "nodeChild not NULL\n");
1412
1413         /* test length property */
1414         r = IXMLDOMText_get_length(nodetext, NULL);
1415         ok(r == E_INVALIDARG, "ret %08x\n", r );
1416
1417         r = IXMLDOMText_get_length(nodetext, &nLength);
1418         ok(r == S_OK, "ret %08x\n", r );
1419         ok(nLength == 4, "expected 4 got %d\n", nLength);
1420
1421         /* put data Tests */
1422         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
1423         ok(r == S_OK, "ret %08x\n", r );
1424
1425         /* get data Tests */
1426         r = IXMLDOMText_get_data(nodetext, &str);
1427         ok(r == S_OK, "ret %08x\n", r );
1428         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
1429         SysFreeString(str);
1430
1431         /* Confirm XML text is good */
1432         r = IXMLDOMText_get_xml(nodetext, &str);
1433         ok(r == S_OK, "ret %08x\n", r );
1434         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
1435         SysFreeString(str);
1436
1437         /* Confirm we get the put_data Text back */
1438         r = IXMLDOMText_get_text(nodetext, &str);
1439         ok(r == S_OK, "ret %08x\n", r );
1440         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
1441         SysFreeString(str);
1442
1443         /* test substringData */
1444         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
1445         ok(r == E_INVALIDARG, "ret %08x\n", r );
1446
1447         /* test substringData - Invalid offset */
1448         str = (BSTR)&szElement;
1449         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
1450         ok(r == E_INVALIDARG, "ret %08x\n", r );
1451         ok( str == NULL, "incorrect string\n");
1452
1453         /* test substringData - Invalid offset */
1454         str = (BSTR)&szElement;
1455         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
1456         ok(r == S_FALSE, "ret %08x\n", r );
1457         ok( str == NULL, "incorrect string\n");
1458
1459         /* test substringData - Invalid size */
1460         str = (BSTR)&szElement;
1461         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
1462         ok(r == E_INVALIDARG, "ret %08x\n", r );
1463         ok( str == NULL, "incorrect string\n");
1464
1465         /* test substringData - Invalid size */
1466         str = (BSTR)&szElement;
1467         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
1468         ok(r == S_FALSE, "ret %08x\n", r );
1469         ok( str == NULL, "incorrect string\n");
1470
1471         /* test substringData - Start of string */
1472         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
1473         ok(r == S_OK, "ret %08x\n", r );
1474         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
1475         SysFreeString(str);
1476
1477         /* test substringData - Middle of string */
1478         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
1479         ok(r == S_OK, "ret %08x\n", r );
1480         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
1481         SysFreeString(str);
1482
1483         /* test substringData - End of string */
1484         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
1485         ok(r == S_OK, "ret %08x\n", r );
1486         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
1487         SysFreeString(str);
1488
1489         /* test appendData */
1490         r = IXMLDOMText_appendData(nodetext, NULL);
1491         ok(r == S_OK, "ret %08x\n", r );
1492
1493         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
1494         ok(r == S_OK, "ret %08x\n", r );
1495
1496         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
1497         ok(r == S_OK, "ret %08x\n", r );
1498
1499         r = IXMLDOMText_get_text(nodetext, &str);
1500         ok(r == S_OK, "ret %08x\n", r );
1501         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1502         SysFreeString(str);
1503
1504         /* test insertData */
1505         str = SysAllocStringLen(NULL, 0);
1506         r = IXMLDOMText_insertData(nodetext, -1, str);
1507         ok(r == S_OK, "ret %08x\n", r );
1508
1509         r = IXMLDOMText_insertData(nodetext, -1, NULL);
1510         ok(r == S_OK, "ret %08x\n", r );
1511
1512         r = IXMLDOMText_insertData(nodetext, 1000, str);
1513         ok(r == S_OK, "ret %08x\n", r );
1514
1515         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
1516         ok(r == S_OK, "ret %08x\n", r );
1517
1518         r = IXMLDOMText_insertData(nodetext, 0, NULL);
1519         ok(r == S_OK, "ret %08x\n", r );
1520
1521         r = IXMLDOMText_insertData(nodetext, 0, str);
1522         ok(r == S_OK, "ret %08x\n", r );
1523         SysFreeString(str);
1524
1525         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
1526         ok(r == E_INVALIDARG, "ret %08x\n", r );
1527
1528         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
1529         ok(r == E_INVALIDARG, "ret %08x\n", r );
1530
1531         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
1532         ok(r == S_OK, "ret %08x\n", r );
1533
1534         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
1535         ok(r == S_OK, "ret %08x\n", r );
1536
1537         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
1538         ok(r == S_OK, "ret %08x\n", r );
1539
1540         r = IXMLDOMText_get_text(nodetext, &str);
1541         ok(r == S_OK, "ret %08x\n", r );
1542         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1543         SysFreeString(str);
1544
1545         /* delete data */
1546         /* invalid arguments */
1547         r = IXMLDOMText_deleteData(nodetext, -1, 1);
1548         ok(r == E_INVALIDARG, "ret %08x\n", r );
1549
1550         r = IXMLDOMText_deleteData(nodetext, 0, 0);
1551         ok(r == S_OK, "ret %08x\n", r );
1552
1553         r = IXMLDOMText_deleteData(nodetext, 0, -1);
1554         ok(r == E_INVALIDARG, "ret %08x\n", r );
1555
1556         r = IXMLDOMText_get_length(nodetext, &nLength);
1557         ok(r == S_OK, "ret %08x\n", r );
1558         ok(nLength == 43, "expected 43 got %d\n", nLength);
1559
1560         r = IXMLDOMText_deleteData(nodetext, nLength, 1);
1561         ok(r == S_OK, "ret %08x\n", r );
1562
1563         r = IXMLDOMText_deleteData(nodetext, nLength+1, 1);
1564         ok(r == E_INVALIDARG, "ret %08x\n", r );
1565
1566         /* delete from start */
1567         r = IXMLDOMText_deleteData(nodetext, 0, 5);
1568         ok(r == S_OK, "ret %08x\n", r );
1569
1570         r = IXMLDOMText_get_length(nodetext, &nLength);
1571         ok(r == S_OK, "ret %08x\n", r );
1572         ok(nLength == 38, "expected 38 got %d\n", nLength);
1573
1574         r = IXMLDOMText_get_text(nodetext, &str);
1575         ok(r == S_OK, "ret %08x\n", r );
1576         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1577         SysFreeString(str);
1578
1579         /* delete from end */
1580         r = IXMLDOMText_deleteData(nodetext, 35, 3);
1581         ok(r == S_OK, "ret %08x\n", r );
1582
1583         r = IXMLDOMText_get_length(nodetext, &nLength);
1584         ok(r == S_OK, "ret %08x\n", r );
1585         ok(nLength == 35, "expected 35 got %d\n", nLength);
1586
1587         r = IXMLDOMText_get_text(nodetext, &str);
1588         ok(r == S_OK, "ret %08x\n", r );
1589         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1590         SysFreeString(str);
1591
1592         /* delete from inside */
1593         r = IXMLDOMText_deleteData(nodetext, 1, 33);
1594         ok(r == S_OK, "ret %08x\n", r );
1595
1596         r = IXMLDOMText_get_length(nodetext, &nLength);
1597         ok(r == S_OK, "ret %08x\n", r );
1598         ok(nLength == 2, "expected 2 got %d\n", nLength);
1599
1600         r = IXMLDOMText_get_text(nodetext, &str);
1601         ok(r == S_OK, "ret %08x\n", r );
1602         ok( !lstrcmpW( str, _bstr_("") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1603         SysFreeString(str);
1604
1605         /* delete whole data ... */
1606         r = IXMLDOMText_get_length(nodetext, &nLength);
1607         ok(r == S_OK, "ret %08x\n", r );
1608
1609         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1610         ok(r == S_OK, "ret %08x\n", r );
1611         /* ... and try again with empty string */
1612         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1613         ok(r == S_OK, "ret %08x\n", r );
1614
1615         /* test put_data */
1616         V_VT(&var) = VT_BSTR;
1617         V_BSTR(&var) = SysAllocString(szstr1);
1618         r = IXMLDOMText_put_nodeValue(nodetext, var);
1619         ok(r == S_OK, "ret %08x\n", r );
1620         VariantClear(&var);
1621
1622         r = IXMLDOMText_get_text(nodetext, &str);
1623         ok(r == S_OK, "ret %08x\n", r );
1624         ok( !lstrcmpW( str, szstr1 ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1625         SysFreeString(str);
1626
1627         /* test put_data */
1628         V_VT(&var) = VT_I4;
1629         V_I4(&var) = 99;
1630         r = IXMLDOMText_put_nodeValue(nodetext, var);
1631         ok(r == S_OK, "ret %08x\n", r );
1632         VariantClear(&var);
1633
1634         r = IXMLDOMText_get_text(nodetext, &str);
1635         ok(r == S_OK, "ret %08x\n", r );
1636         ok( !lstrcmpW( str, _bstr_("99") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1637         SysFreeString(str);
1638
1639         /* ::replaceData() */
1640         V_VT(&var) = VT_BSTR;
1641         V_BSTR(&var) = SysAllocString(szstr1);
1642         r = IXMLDOMText_put_nodeValue(nodetext, var);
1643         ok(r == S_OK, "ret %08x\n", r );
1644         VariantClear(&var);
1645
1646         r = IXMLDOMText_replaceData(nodetext, 6, 0, NULL);
1647         ok(r == E_INVALIDARG, "ret %08x\n", r );
1648         r = IXMLDOMText_get_text(nodetext, &str);
1649         ok(r == S_OK, "ret %08x\n", r );
1650         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1651         SysFreeString(str);
1652
1653         r = IXMLDOMText_replaceData(nodetext, 0, 0, NULL);
1654         ok(r == S_OK, "ret %08x\n", r );
1655         r = IXMLDOMText_get_text(nodetext, &str);
1656         ok(r == S_OK, "ret %08x\n", r );
1657         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1658         SysFreeString(str);
1659
1660         /* NULL pointer means delete */
1661         r = IXMLDOMText_replaceData(nodetext, 0, 1, NULL);
1662         ok(r == S_OK, "ret %08x\n", r );
1663         r = IXMLDOMText_get_text(nodetext, &str);
1664         ok(r == S_OK, "ret %08x\n", r );
1665         ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1666         SysFreeString(str);
1667
1668         /* empty string means delete */
1669         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_(""));
1670         ok(r == S_OK, "ret %08x\n", r );
1671         r = IXMLDOMText_get_text(nodetext, &str);
1672         ok(r == S_OK, "ret %08x\n", r );
1673         ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1674         SysFreeString(str);
1675
1676         /* zero count means insert */
1677         r = IXMLDOMText_replaceData(nodetext, 0, 0, _bstr_("a"));
1678         ok(r == S_OK, "ret %08x\n", r );
1679         r = IXMLDOMText_get_text(nodetext, &str);
1680         ok(r == S_OK, "ret %08x\n", r );
1681         ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1682         SysFreeString(str);
1683
1684         r = IXMLDOMText_replaceData(nodetext, 0, 2, NULL);
1685         ok(r == S_OK, "ret %08x\n", r );
1686
1687         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("m"));
1688         ok(r == S_OK, "ret %08x\n", r );
1689         r = IXMLDOMText_get_text(nodetext, &str);
1690         ok(r == S_OK, "ret %08x\n", r );
1691         ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1692         SysFreeString(str);
1693
1694         /* nonempty string, count greater than its length */
1695         r = IXMLDOMText_replaceData(nodetext, 0, 2, _bstr_("a1.2"));
1696         ok(r == S_OK, "ret %08x\n", r );
1697         r = IXMLDOMText_get_text(nodetext, &str);
1698         ok(r == S_OK, "ret %08x\n", r );
1699         ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1700         SysFreeString(str);
1701
1702         /* nonempty string, count less than its length */
1703         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_("wine"));
1704         ok(r == S_OK, "ret %08x\n", r );
1705         r = IXMLDOMText_get_text(nodetext, &str);
1706         ok(r == S_OK, "ret %08x\n", r );
1707         ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1708         SysFreeString(str);
1709
1710         IXMLDOMText_Release( nodetext );
1711     }
1712
1713     /* test Create Comment */
1714     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
1715     ok( r == E_INVALIDARG, "returns %08x\n", r );
1716     node_comment = (IXMLDOMComment*)0x1;
1717
1718     /* empty comment */
1719     r = IXMLDOMDocument_createComment(doc, _bstr_(""), &node_comment);
1720     ok( r == S_OK, "returns %08x\n", r );
1721     str = (BSTR)0x1;
1722     r = IXMLDOMComment_get_data(node_comment, &str);
1723     ok( r == S_OK, "returns %08x\n", r );
1724     ok( str && SysStringLen(str) == 0, "expected empty string data\n");
1725     IXMLDOMComment_Release(node_comment);
1726     SysFreeString(str);
1727
1728     r = IXMLDOMDocument_createComment(doc, NULL, &node_comment);
1729     ok( r == S_OK, "returns %08x\n", r );
1730     str = (BSTR)0x1;
1731     r = IXMLDOMComment_get_data(node_comment, &str);
1732     ok( r == S_OK, "returns %08x\n", r );
1733     ok( str && (SysStringLen(str) == 0), "expected empty string data\n");
1734     IXMLDOMComment_Release(node_comment);
1735     SysFreeString(str);
1736
1737     str = SysAllocString(szComment);
1738     r = IXMLDOMDocument_createComment(doc, str, &node_comment);
1739     SysFreeString(str);
1740     ok( r == S_OK, "returns %08x\n", r );
1741     if(node_comment)
1742     {
1743         /* Last Child Checks */
1744         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
1745         ok(r == E_INVALIDARG, "ret %08x\n", r );
1746
1747         nodeChild = (IXMLDOMNode*)0x1;
1748         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
1749         ok(r == S_FALSE, "ret %08x\n", r );
1750         ok(nodeChild == NULL, "pLastChild not NULL\n");
1751
1752         /* baseName */
1753         str = (BSTR)0xdeadbeef;
1754         r = IXMLDOMComment_get_baseName(node_comment, &str);
1755         ok(r == S_FALSE, "ret %08x\n", r );
1756         ok(str == NULL, "Expected NULL\n");
1757
1758         IXMLDOMComment_Release( node_comment );
1759     }
1760
1761     /* test Create Attribute */
1762     str = SysAllocString(szAttribute);
1763     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
1764     ok( r == E_INVALIDARG, "returns %08x\n", r );
1765     r = IXMLDOMDocument_createAttribute(doc, str, &node_attr);
1766     ok( r == S_OK, "returns %08x\n", r );
1767     IXMLDOMAttribute_Release( node_attr);
1768     SysFreeString(str);
1769
1770     /* test Processing Instruction */
1771     str = SysAllocStringLen(NULL, 0);
1772     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
1773     ok( r == E_INVALIDARG, "returns %08x\n", r );
1774     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
1775     ok( r == E_FAIL, "returns %08x\n", r );
1776     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
1777     ok( r == E_FAIL, "returns %08x\n", r );
1778     SysFreeString(str);
1779
1780     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
1781     ok( r == S_OK, "returns %08x\n", r );
1782     if(nodePI)
1783     {
1784         /* Last Child Checks */
1785         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
1786         ok(r == E_INVALIDARG, "ret %08x\n", r );
1787
1788         nodeChild = (IXMLDOMNode*)0x1;
1789         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
1790         ok(r == S_FALSE, "ret %08x\n", r );
1791         ok(nodeChild == NULL, "nodeChild not NULL\n");
1792
1793         /* test nodeName */
1794         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
1795         ok(r == S_OK, "ret %08x\n", r );
1796         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1797         SysFreeString(str);
1798
1799         /* test baseName */
1800         str = (BSTR)0x1;
1801         r = IXMLDOMProcessingInstruction_get_baseName(nodePI, &str);
1802         ok(r == S_OK, "ret %08x\n", r );
1803         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1804         SysFreeString(str);
1805
1806         /* test Target */
1807         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
1808         ok(r == S_OK, "ret %08x\n", r );
1809         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
1810         SysFreeString(str);
1811
1812         /* test get_data */
1813         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
1814         ok(r == S_OK, "ret %08x\n", r );
1815         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
1816         SysFreeString(str);
1817
1818         /* test put_data */
1819         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
1820         ok(r == E_FAIL, "ret %08x\n", r );
1821
1822         /* test put_data */
1823         V_VT(&var) = VT_BSTR;
1824         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
1825         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
1826         ok(r == E_FAIL, "ret %08x\n", r );
1827         VariantClear(&var);
1828
1829         /* test get nodeName */
1830         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
1831         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1832         ok(r == S_OK, "ret %08x\n", r );
1833         SysFreeString(str);
1834
1835         IXMLDOMProcessingInstruction_Release(nodePI);
1836     }
1837
1838     ref = IXMLDOMDocument_Release( doc );
1839     ok( ref == 0, "got %d\n", ref);
1840
1841     free_bstrs();
1842 }
1843
1844 static void test_persiststreaminit(void)
1845 {
1846     IXMLDOMDocument *doc;
1847     IPersistStreamInit *streaminit;
1848     ULARGE_INTEGER size;
1849     HRESULT hr;
1850
1851     doc = create_document(&IID_IXMLDOMDocument);
1852
1853     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&streaminit);
1854     ok(hr == S_OK, "got 0x%08x\n", hr);
1855
1856     hr = IPersistStreamInit_InitNew(streaminit);
1857     ok(hr == S_OK, "got 0x%08x\n", hr);
1858
1859     hr = IPersistStreamInit_GetSizeMax(streaminit, &size);
1860     ok(hr == E_NOTIMPL, "got 0x%08x\n", hr);
1861
1862     IXMLDOMDocument_Release(doc);
1863 }
1864
1865 static void test_domnode( void )
1866 {
1867     HRESULT r;
1868     IXMLDOMDocument *doc, *owner = NULL;
1869     IXMLDOMElement *element = NULL;
1870     IXMLDOMNamedNodeMap *map = NULL;
1871     IXMLDOMNode *node = NULL, *next = NULL;
1872     IXMLDOMNodeList *list = NULL;
1873     IXMLDOMAttribute *attr = NULL;
1874     DOMNodeType type = NODE_INVALID;
1875     VARIANT_BOOL b;
1876     BSTR str;
1877     VARIANT var;
1878     LONG count;
1879
1880     doc = create_document(&IID_IXMLDOMDocument);
1881
1882     b = FALSE;
1883     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
1884     ok( r == S_OK, "loadXML failed\n");
1885     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1886
1887     EXPECT_CHILDREN(doc);
1888
1889     r = IXMLDOMDocument_get_documentElement( doc, &element );
1890     ok( r == S_OK, "should be a document element\n");
1891     ok( element != NULL, "should be an element\n");
1892
1893     VariantInit(&var);
1894     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
1895
1896     r = IXMLDOMDocument_get_nodeValue( doc, NULL );
1897     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
1898
1899     r = IXMLDOMDocument_get_nodeValue( doc, &var );
1900     ok( r == S_FALSE, "nextNode returned wrong code\n");
1901     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
1902     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
1903
1904     if (element)
1905     {
1906         owner = NULL;
1907         r = IXMLDOMElement_get_ownerDocument( element, &owner );
1908         ok( r == S_OK, "get_ownerDocument return code\n");
1909         ok( owner != doc, "get_ownerDocument return\n");
1910         IXMLDOMDocument_Release(owner);
1911
1912         type = NODE_INVALID;
1913         r = IXMLDOMElement_get_nodeType( element, &type);
1914         ok( r == S_OK, "got %08x\n", r);
1915         ok( type == NODE_ELEMENT, "node not an element\n");
1916
1917         str = NULL;
1918         r = IXMLDOMElement_get_baseName( element, &str );
1919         ok( r == S_OK, "get_baseName returned wrong code\n");
1920         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
1921         SysFreeString(str);
1922
1923         /* check if nodename is correct */
1924         r = IXMLDOMElement_get_nodeName( element, NULL );
1925         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1926
1927         /* content doesn't matter here */
1928         str = NULL;
1929         r = IXMLDOMElement_get_nodeName( element, &str );
1930         ok ( r == S_OK, "get_nodeName wrong code\n");
1931         ok ( str != NULL, "str is null\n");
1932         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
1933         SysFreeString( str );
1934
1935         str = SysAllocString( nonexistent_fileW );
1936         V_VT(&var) = VT_I4;
1937         V_I4(&var) = 0x1234;
1938         r = IXMLDOMElement_getAttribute( element, str, &var );
1939         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
1940         ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
1941         VariantClear(&var);
1942
1943         str = SysAllocString( szdl );
1944         V_VT(&var) = VT_I4;
1945         V_I4(&var) = 0x1234;
1946         r = IXMLDOMElement_getAttribute( element, str, &var );
1947         ok( r == S_OK, "getAttribute ret %08x\n", r );
1948         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
1949         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
1950         VariantClear( &var );
1951
1952         r = IXMLDOMElement_getAttribute( element, NULL, &var );
1953         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
1954
1955         r = IXMLDOMElement_getAttribute( element, str, NULL );
1956         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
1957
1958         attr = NULL;
1959         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
1960         ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
1961         ok( attr != NULL, "getAttributeNode returned NULL\n" );
1962         if (attr)
1963         {
1964             r = IXMLDOMAttribute_get_parentNode( attr, NULL );
1965             ok( r == E_INVALIDARG, "Expected E_INVALIDARG, ret %08x\n", r );
1966
1967             /* attribute doesn't have a parent in msxml interpretation */
1968             node = (IXMLDOMNode*)0xdeadbeef;
1969             r = IXMLDOMAttribute_get_parentNode( attr, &node );
1970             ok( r == S_FALSE, "Expected S_FALSE, ret %08x\n", r );
1971             ok( node == NULL, "Expected NULL, got %p\n", node );
1972
1973             IXMLDOMAttribute_Release(attr);
1974         }
1975
1976         SysFreeString( str );
1977
1978         r = IXMLDOMElement_get_attributes( element, &map );
1979         ok( r == S_OK, "get_attributes returned wrong code\n");
1980         ok( map != NULL, "should be attributes\n");
1981
1982         EXPECT_CHILDREN(element);
1983     }
1984     else
1985         ok( FALSE, "no element\n");
1986
1987     if (map)
1988     {
1989         str = SysAllocString( szdl );
1990         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
1991         ok( r == S_OK, "getNamedItem returned wrong code\n");
1992         ok( node != NULL, "should be attributes\n");
1993         IXMLDOMNode_Release(node);
1994         SysFreeString( str );
1995
1996         str = SysAllocString( szdl );
1997         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
1998         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
1999         SysFreeString( str );
2000
2001         /* something that isn't in complete4A */
2002         str = SysAllocString( szOpen );
2003         node = (IXMLDOMNode *) 1;
2004         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
2005         ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
2006         ok( node == NULL, "getNamedItem should have returned NULL\n");
2007         SysFreeString( str );
2008
2009         /* test indexed access of attributes */
2010         r = IXMLDOMNamedNodeMap_get_length( map, NULL );
2011         ok ( r == E_INVALIDARG, "get_length should return E_INVALIDARG\n");
2012
2013         r = IXMLDOMNamedNodeMap_get_length( map, &count );
2014         ok ( r == S_OK, "get_length wrong code\n");
2015         ok ( count == 1, "get_length != 1\n");
2016
2017         node = NULL;
2018         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
2019         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
2020         ok ( node == NULL, "there is no node\n");
2021
2022         node = NULL;
2023         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
2024         ok ( r == S_FALSE, "get_item (1) wrong code\n");
2025         ok ( node == NULL, "there is no attribute\n");
2026
2027         node = NULL;
2028         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
2029         ok ( r == S_OK, "get_item (0) wrong code\n");
2030         ok ( node != NULL, "should be attribute\n");
2031
2032         r = IXMLDOMNode_get_nodeName( node, NULL );
2033         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2034
2035         /* content doesn't matter here */
2036         str = NULL;
2037         r = IXMLDOMNode_get_nodeName( node, &str );
2038         ok ( r == S_OK, "get_nodeName wrong code\n");
2039         ok ( str != NULL, "str is null\n");
2040         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
2041         SysFreeString( str );
2042         IXMLDOMNode_Release( node );
2043
2044         /* test sequential access of attributes */
2045         node = NULL;
2046         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2047         ok ( r == S_OK, "nextNode (first time) wrong code\n");
2048         ok ( node != NULL, "nextNode, should be attribute\n");
2049         IXMLDOMNode_Release( node );
2050
2051         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2052         ok ( r != S_OK, "nextNode (second time) wrong code\n");
2053         ok ( node == NULL, "nextNode, there is no attribute\n");
2054
2055         r = IXMLDOMNamedNodeMap_reset( map );
2056         ok ( r == S_OK, "reset should return S_OK\n");
2057
2058         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2059         ok ( r == S_OK, "nextNode (third time) wrong code\n");
2060         ok ( node != NULL, "nextNode, should be attribute\n");
2061     }
2062     else
2063         ok( FALSE, "no map\n");
2064
2065     if (node)
2066     {
2067         type = NODE_INVALID;
2068         r = IXMLDOMNode_get_nodeType( node, &type);
2069         ok( r == S_OK, "getNamedItem returned wrong code\n");
2070         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
2071
2072         str = NULL;
2073         r = IXMLDOMNode_get_baseName( node, NULL );
2074         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
2075
2076         str = NULL;
2077         r = IXMLDOMNode_get_baseName( node, &str );
2078         ok( r == S_OK, "get_baseName returned wrong code\n");
2079         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
2080         SysFreeString( str );
2081
2082         r = IXMLDOMNode_get_childNodes( node, NULL );
2083         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
2084
2085         r = IXMLDOMNode_get_childNodes( node, &list );
2086         ok( r == S_OK, "get_childNodes returned wrong code\n");
2087
2088         if (list)
2089         {
2090             r = IXMLDOMNodeList_nextNode( list, &next );
2091             ok( r == S_OK, "nextNode returned wrong code\n");
2092         }
2093         else
2094             ok( FALSE, "no childlist\n");
2095
2096         if (next)
2097         {
2098             EXPECT_NO_CHILDREN(next);
2099
2100             type = NODE_INVALID;
2101             r = IXMLDOMNode_get_nodeType( next, &type);
2102             ok( r == S_OK, "getNamedItem returned wrong code\n");
2103             ok( type == NODE_TEXT, "node not text\n");
2104
2105             str = (BSTR) 1;
2106             r = IXMLDOMNode_get_baseName( next, &str );
2107             ok( r == S_FALSE, "get_baseName returned wrong code\n");
2108             ok( str == NULL, "basename was wrong\n");
2109             SysFreeString(str);
2110         }
2111         else
2112             ok( FALSE, "no next\n");
2113
2114         if (next)
2115             IXMLDOMNode_Release( next );
2116         next = NULL;
2117         if (list)
2118             IXMLDOMNodeList_Release( list );
2119         list = NULL;
2120         if (node)
2121             IXMLDOMNode_Release( node );
2122     }
2123     else
2124         ok( FALSE, "no node\n");
2125     node = NULL;
2126
2127     if (map)
2128         IXMLDOMNamedNodeMap_Release( map );
2129
2130     /* now traverse the tree from the root element */
2131     if (element)
2132     {
2133         r = IXMLDOMElement_get_childNodes( element, &list );
2134         ok( r == S_OK, "get_childNodes returned wrong code\n");
2135
2136         /* using get_item for child list doesn't advance the position */
2137         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
2138         expect_node(node, "E2.E2.D1");
2139         IXMLDOMNode_Release(node);
2140         ole_check(IXMLDOMNodeList_nextNode(list, &node));
2141         expect_node(node, "E1.E2.D1");
2142         IXMLDOMNode_Release(node);
2143         ole_check(IXMLDOMNodeList_reset(list));
2144
2145         IXMLDOMNodeList_AddRef(list);
2146         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
2147         ole_check(IXMLDOMNodeList_reset(list));
2148
2149         node = (void*)0xdeadbeef;
2150         str = SysAllocString(szdl);
2151         r = IXMLDOMElement_selectSingleNode( element, str, &node );
2152         SysFreeString(str);
2153         ok( r == S_FALSE, "ret %08x\n", r );
2154         ok( node == NULL, "node %p\n", node );
2155
2156         str = SysAllocString(szbs);
2157         r = IXMLDOMElement_selectSingleNode( element, str, &node );
2158         SysFreeString(str);
2159         ok( r == S_OK, "ret %08x\n", r );
2160         r = IXMLDOMNode_Release( node );
2161         ok( r == 0, "ret %08x\n", r );
2162     }
2163     else
2164         ok( FALSE, "no element\n");
2165
2166     if (list)
2167     {
2168         r = IXMLDOMNodeList_get_item(list, 0, NULL);
2169         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2170
2171         r = IXMLDOMNodeList_get_length(list, NULL);
2172         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2173
2174         r = IXMLDOMNodeList_get_length( list, &count );
2175         ok( r == S_OK, "get_length returns %08x\n", r );
2176         ok( count == 4, "get_length got %d\n", count );
2177
2178         r = IXMLDOMNodeList_nextNode(list, NULL);
2179         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2180
2181         r = IXMLDOMNodeList_nextNode( list, &node );
2182         ok( r == S_OK, "nextNode returned wrong code\n");
2183     }
2184     else
2185         ok( FALSE, "no list\n");
2186
2187     if (node)
2188     {
2189         type = NODE_INVALID;
2190         r = IXMLDOMNode_get_nodeType( node, &type);
2191         ok( r == S_OK, "getNamedItem returned wrong code\n");
2192         ok( type == NODE_ELEMENT, "node not text\n");
2193
2194         r = IXMLDOMNode_hasChildNodes( node, NULL );
2195         ok( r == E_INVALIDARG, "hasChildNodes bad return\n");
2196
2197         EXPECT_CHILDREN(node);
2198
2199         str = NULL;
2200         r = IXMLDOMNode_get_baseName( node, &str );
2201         ok( r == S_OK, "get_baseName returned wrong code\n");
2202         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
2203         SysFreeString(str);
2204     }
2205     else
2206         ok( FALSE, "no node\n");
2207
2208     if (node)
2209         IXMLDOMNode_Release( node );
2210     if (list)
2211         IXMLDOMNodeList_Release( list );
2212     if (element)
2213         IXMLDOMElement_Release( element );
2214
2215     b = FALSE;
2216     str = SysAllocString( szComplete5 );
2217     r = IXMLDOMDocument_loadXML( doc, str, &b );
2218     ok( r == S_OK, "loadXML failed\n");
2219     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2220     SysFreeString( str );
2221
2222     EXPECT_CHILDREN(doc);
2223
2224     r = IXMLDOMDocument_get_documentElement( doc, &element );
2225     ok( r == S_OK, "should be a document element\n");
2226     ok( element != NULL, "should be an element\n");
2227
2228     if (element)
2229     {
2230         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
2231         BSTR tag = NULL;
2232
2233         /* check if the tag is correct */
2234         r = IXMLDOMElement_get_tagName( element, &tag );
2235         ok( r == S_OK, "couldn't get tag name\n");
2236         ok( tag != NULL, "tag was null\n");
2237         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
2238         SysFreeString( tag );
2239     }
2240
2241     if (element)
2242         IXMLDOMElement_Release( element );
2243     ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
2244
2245     free_bstrs();
2246 }
2247
2248 typedef struct {
2249     DOMNodeType type;
2250     REFIID iid;
2251 } refcount_test_t;
2252
2253 static const refcount_test_t refcount_test[] = {
2254     { NODE_ELEMENT,                &IID_IXMLDOMElement },
2255     { NODE_ATTRIBUTE,              &IID_IXMLDOMAttribute },
2256     { NODE_TEXT,                   &IID_IXMLDOMText },
2257     { NODE_CDATA_SECTION,          &IID_IXMLDOMCDATASection },
2258     { NODE_ENTITY_REFERENCE,       &IID_IXMLDOMEntityReference },
2259     { NODE_PROCESSING_INSTRUCTION, &IID_IXMLDOMProcessingInstruction },
2260     { NODE_COMMENT,                &IID_IXMLDOMComment },
2261     { NODE_DOCUMENT_FRAGMENT,      &IID_IXMLDOMDocumentFragment },
2262     { NODE_INVALID,                &IID_NULL }
2263 };
2264
2265 static void test_refs(void)
2266 {
2267     IXMLDOMImplementation *impl, *impl2;
2268     IXMLDOMElement *element, *elem2;
2269     IXMLDOMNodeList *node_list = NULL;
2270     IXMLDOMNode *node, *node2, *node3;
2271     const refcount_test_t *ptr;
2272     IXMLDOMDocument *doc;
2273     IUnknown *unk, *unk2;
2274     VARIANT_BOOL b;
2275     HRESULT hr;
2276     LONG ref;
2277
2278     doc = create_document(&IID_IXMLDOMDocument);
2279
2280     ptr = refcount_test;
2281     while (ptr->type != NODE_INVALID)
2282     {
2283         IUnknown *node_typed, *node_typed2;
2284         IDispatchEx *dispex, *dispex2;
2285         IDispatch *disp, *disp2;
2286         VARIANT type;
2287
2288         V_VT(&type) = VT_I1;
2289         V_I1(&type) = ptr->type;
2290
2291         EXPECT_REF(doc, 1);
2292         hr = IXMLDOMDocument_createNode(doc, type, _bstr_("name"), NULL, &node);
2293         EXPECT_HR(hr, S_OK);
2294         EXPECT_REF(doc, 1);
2295         EXPECT_REF(node, 1);
2296
2297         /* try IDispatch and IUnknown from IXMLDOMNode */
2298         hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
2299         EXPECT_HR(hr, S_OK);
2300         EXPECT_REF(unk, 2);
2301 todo_wine {
2302         EXPECT_REF(node, 1);
2303         ok(unk != (IUnknown*)node, "%d: got %p and %p\n", ptr->type, unk, node);
2304 }
2305         EXPECT_REF(unk, 2);
2306         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
2307         EXPECT_HR(hr, S_OK);
2308         todo_wine ok(unk != (IUnknown*)disp, "%d: got %p and %p\n", ptr->type, unk, disp);
2309         EXPECT_REF(unk, 3);
2310         todo_wine EXPECT_REF(disp, 1);
2311
2312         EXPECT_REF(unk, 3);
2313         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp2);
2314         EXPECT_HR(hr, S_OK);
2315         todo_wine ok(disp != disp2, "%d: got %p and %p\n", ptr->type, disp, disp2);
2316         EXPECT_REF(unk, 4);
2317         todo_wine EXPECT_REF(disp2, 1);
2318
2319         IDispatch_Release(disp);
2320         IDispatch_Release(disp2);
2321
2322         /* get IXMLDOMNode from this IUnknown */
2323         EXPECT_REF(unk, 2);
2324         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node2);
2325         EXPECT_HR(hr, S_OK);
2326         todo_wine ok(unk != (IUnknown*)node2, "%d: got %p and %p\n", ptr->type, unk, node2);
2327         EXPECT_REF(unk, 3);
2328         todo_wine EXPECT_REF(node2, 1);
2329
2330         EXPECT_REF(unk, 3);
2331         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node3);
2332         EXPECT_HR(hr, S_OK);
2333         todo_wine ok(node2 != node3, "%d: got %p and %p\n", ptr->type, node2, node3);
2334         EXPECT_REF(unk, 4);
2335         todo_wine EXPECT_REF(node3, 1);
2336
2337         IXMLDOMNode_Release(node2);
2338         IXMLDOMNode_Release(node3);
2339
2340         /* try IDispatchEx from IUnknown */
2341         EXPECT_REF(unk, 2);
2342         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
2343         EXPECT_HR(hr, S_OK);
2344         ok(unk != (IUnknown*)dispex, "%d: got %p and %p\n", ptr->type, unk, dispex);
2345         EXPECT_REF(unk, 3);
2346         todo_wine EXPECT_REF(dispex, 1);
2347
2348         EXPECT_REF(unk, 3);
2349         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex2);
2350         EXPECT_HR(hr, S_OK);
2351         todo_wine ok(dispex != dispex2, "%d: got %p and %p\n", ptr->type, dispex, dispex2);
2352         EXPECT_REF(unk, 4);
2353         todo_wine EXPECT_REF(dispex2, 1);
2354
2355         IDispatchEx_Release(dispex);
2356         IDispatchEx_Release(dispex2);
2357
2358         /* try corresponding IXMLDOM* */
2359         EXPECT_REF(unk, 2);
2360         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed);
2361         EXPECT_HR(hr, S_OK);
2362         EXPECT_REF(unk, 3);
2363         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed2);
2364         EXPECT_HR(hr, S_OK);
2365         EXPECT_REF(unk, 4);
2366         todo_wine ok(node_typed != node_typed2, "%d: got %p and %p\n", ptr->type, node_typed, node_typed2);
2367         IUnknown_Release(node_typed);
2368         IUnknown_Release(node_typed2);
2369
2370         /* try invalid IXMLDOM* */
2371         hr = IUnknown_QueryInterface(unk, (ptr+1)->iid, (void**)&node_typed);
2372         EXPECT_HR(hr, E_NOINTERFACE);
2373
2374         IUnknown_Release(unk);
2375
2376         EXPECT_REF(node, 1);
2377         hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMNode, (void**)&node2);
2378         EXPECT_HR(hr, S_OK);
2379         EXPECT_REF(node, 2);
2380         ok(node == node2, "%d: got %p and %p\n", ptr->type, node, node2);
2381
2382         EXPECT_REF(node, 2);
2383         hr = IXMLDOMNode_QueryInterface(node, ptr->iid, (void**)&node_typed);
2384         EXPECT_HR(hr, S_OK);
2385         EXPECT_REF(node, 3);
2386 todo_wine {
2387         EXPECT_REF(node_typed, 2);
2388         ok((IUnknown*)node != node_typed, "%d: got %p and %p\n", ptr->type, node, node_typed);
2389 }
2390         IUnknown_Release(node_typed);
2391
2392         IXMLDOMNode_Release(node2);
2393         IXMLDOMNode_Release(node);
2394
2395         ptr++;
2396     }
2397
2398     EXPECT_REF(doc, 1);
2399     ref = IXMLDOMDocument_Release(doc);
2400     ok( ref == 0, "ref %d\n", ref);
2401
2402     /* check IUnknown after releasing DOM iface */
2403     doc = create_document(&IID_IXMLDOMDocument);
2404     EXPECT_REF(doc, 1);
2405     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2406     EXPECT_HR(hr, S_OK);
2407 todo_wine {
2408     EXPECT_REF(unk, 3);
2409     EXPECT_REF(doc, 1);
2410 }
2411     IXMLDOMDocument_Release(doc);
2412     EXPECT_REF(unk, 1);
2413     IUnknown_Release(unk);
2414
2415     doc = create_document(&IID_IXMLDOMDocument);
2416
2417     EXPECT_REF(doc, 1);
2418     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2419     EXPECT_HR(hr, S_OK);
2420 todo_wine {
2421     EXPECT_REF(unk, 3);
2422     EXPECT_REF(doc, 1);
2423 }
2424     IUnknown_Release(unk);
2425
2426     /* IXMLDOMImplementation */
2427     EXPECT_REF(doc, 1);
2428     hr = IXMLDOMDocument_get_implementation(doc, &impl);
2429     EXPECT_HR(hr, S_OK);
2430     EXPECT_REF(doc, 1);
2431     EXPECT_REF(impl, 1);
2432     hr = IXMLDOMDocument_get_implementation(doc, &impl2);
2433     EXPECT_HR(hr, S_OK);
2434     EXPECT_REF(doc, 1);
2435     EXPECT_REF(impl2, 1);
2436     ok(impl != impl2, "got %p, %p\n", impl, impl2);
2437     IXMLDOMImplementation_Release(impl);
2438     IXMLDOMImplementation_Release(impl2);
2439
2440     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2441     EXPECT_HR(hr, S_OK);
2442     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2443
2444     EXPECT_REF(doc, 1);
2445     IXMLDOMDocument_AddRef( doc );
2446     EXPECT_REF(doc, 2);
2447     IXMLDOMDocument_AddRef( doc );
2448     EXPECT_REF(doc, 3);
2449
2450     IXMLDOMDocument_Release( doc );
2451     IXMLDOMDocument_Release( doc );
2452
2453     EXPECT_REF(doc, 1);
2454     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2455     EXPECT_HR(hr, S_OK);
2456 todo_wine {
2457     EXPECT_REF(unk, 3);
2458     EXPECT_REF(doc, 1);
2459 }
2460     hr = IXMLDOMDocument_get_documentElement(doc, &element);
2461     EXPECT_HR(hr, S_OK);
2462 todo_wine {
2463     EXPECT_REF(doc, 1);
2464     EXPECT_REF(element, 2);
2465 }
2466     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
2467     EXPECT_HR(hr, S_OK);
2468
2469 todo_wine {
2470     EXPECT_REF(doc, 1);
2471     EXPECT_REF(element, 2);
2472     EXPECT_REF(elem2, 2);
2473 }
2474     IXMLDOMElement_AddRef(element);
2475     todo_wine EXPECT_REF(element, 3);
2476     IXMLDOMElement_Release(element);
2477
2478     /* get IUnknown from a node doesn't touch node instance refcount */
2479     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
2480     EXPECT_HR(hr, S_OK);
2481     EXPECT_REF(element, 2);
2482 todo_wine {
2483     EXPECT_REF(unk, 4);
2484     EXPECT_REF(elem2, 2);
2485 }
2486     hr = IXMLDOMElement_QueryInterface(elem2, &IID_IUnknown, (void**)&unk2);
2487     EXPECT_HR(hr, S_OK);
2488 todo_wine {
2489     EXPECT_REF(unk, 5);
2490     EXPECT_REF(unk2, 5);
2491 }
2492     EXPECT_REF(element, 2);
2493     EXPECT_REF(elem2, 2);
2494
2495     todo_wine ok(unk == unk2, "got %p and %p\n", unk, unk2);
2496
2497     IUnknown_Release(unk);
2498     IUnknown_Release(unk2);
2499
2500     /* IUnknown refcount is not affected by node refcount */
2501     todo_wine EXPECT_REF(unk2, 3);
2502     IXMLDOMElement_AddRef(elem2);
2503     todo_wine EXPECT_REF(unk2, 3);
2504     IXMLDOMElement_Release(elem2);
2505
2506     IXMLDOMElement_Release(elem2);
2507     todo_wine EXPECT_REF(unk2, 2);
2508
2509     hr = IXMLDOMElement_get_childNodes( element, &node_list );
2510     EXPECT_HR(hr, S_OK);
2511
2512     todo_wine EXPECT_REF(element, 2);
2513     EXPECT_REF(node_list, 1);
2514
2515     hr = IXMLDOMNodeList_get_item( node_list, 0, &node );
2516     EXPECT_HR(hr, S_OK);
2517     EXPECT_REF(node_list, 1);
2518     EXPECT_REF(node, 1);
2519
2520     hr = IXMLDOMNodeList_get_item( node_list, 0, &node2 );
2521     EXPECT_HR(hr, S_OK);
2522     EXPECT_REF(node_list, 1);
2523     EXPECT_REF(node2, 1);
2524
2525     ref = IXMLDOMNode_Release( node );
2526     ok( ref == 0, "ref %d\n", ref );
2527     ref = IXMLDOMNode_Release( node2 );
2528     ok( ref == 0, "ref %d\n", ref );
2529
2530     ref = IXMLDOMNodeList_Release( node_list );
2531     ok( ref == 0, "ref %d\n", ref );
2532
2533     ok( node != node2, "node %p node2 %p\n", node, node2 );
2534
2535     ref = IXMLDOMDocument_Release( doc );
2536     todo_wine ok( ref == 0, "ref %d\n", ref );
2537
2538     todo_wine EXPECT_REF(element, 2);
2539
2540     /* IUnknown must be unique however we obtain it */
2541     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
2542     EXPECT_HR(hr, S_OK);
2543     EXPECT_REF(element, 2);
2544     hr = IXMLDOMElement_QueryInterface(element, &IID_IXMLDOMNode, (void**)&node);
2545     EXPECT_HR(hr, S_OK);
2546     todo_wine EXPECT_REF(element, 2);
2547     hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk2);
2548     EXPECT_HR(hr, S_OK);
2549     todo_wine EXPECT_REF(element, 2);
2550     ok(unk == unk2, "unk %p unk2 %p\n", unk, unk2);
2551     todo_wine ok(element != (void*)node, "node %p element %p\n", node, element);
2552
2553     IUnknown_Release( unk2 );
2554     IUnknown_Release( unk );
2555     IXMLDOMNode_Release( node );
2556     todo_wine EXPECT_REF(element, 2);
2557
2558     IXMLDOMElement_Release( element );
2559
2560     free_bstrs();
2561 }
2562
2563 static void test_create(void)
2564 {
2565     static const WCHAR szOne[] = {'1',0};
2566     static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
2567     HRESULT r;
2568     VARIANT var;
2569     BSTR str, name;
2570     IXMLDOMDocument *doc;
2571     IXMLDOMElement *element;
2572     IXMLDOMComment *comment;
2573     IXMLDOMText *text;
2574     IXMLDOMCDATASection *cdata;
2575     IXMLDOMNode *root, *node, *child;
2576     IXMLDOMNamedNodeMap *attr_map;
2577     IUnknown *unk;
2578     LONG ref;
2579     LONG num;
2580
2581     doc = create_document(&IID_IXMLDOMDocument);
2582
2583     EXPECT_REF(doc, 1);
2584
2585     /* types not supported for creation */
2586     V_VT(&var) = VT_I1;
2587     V_I1(&var) = NODE_DOCUMENT;
2588     node = (IXMLDOMNode*)0x1;
2589     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2590     ok( r == E_INVALIDARG, "returns %08x\n", r );
2591     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2592
2593     V_VT(&var) = VT_I1;
2594     V_I1(&var) = NODE_DOCUMENT_TYPE;
2595     node = (IXMLDOMNode*)0x1;
2596     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2597     ok( r == E_INVALIDARG, "returns %08x\n", r );
2598     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2599
2600     V_VT(&var) = VT_I1;
2601     V_I1(&var) = NODE_ENTITY;
2602     node = (IXMLDOMNode*)0x1;
2603     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2604     ok( r == E_INVALIDARG, "returns %08x\n", r );
2605     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2606
2607     V_VT(&var) = VT_I1;
2608     V_I1(&var) = NODE_NOTATION;
2609     node = (IXMLDOMNode*)0x1;
2610     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2611     ok( r == E_INVALIDARG, "returns %08x\n", r );
2612     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2613
2614     /* NODE_COMMENT */
2615     V_VT(&var) = VT_I1;
2616     V_I1(&var) = NODE_COMMENT;
2617     node = NULL;
2618     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2619     ok( r == S_OK, "returns %08x\n", r );
2620     ok( node != NULL, "\n");
2621
2622     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2623     ok( r == S_OK, "returns %08x\n", r );
2624     IXMLDOMNode_Release(node);
2625
2626     str = NULL;
2627     r = IXMLDOMComment_get_data(comment, &str);
2628     ok( r == S_OK, "returns %08x\n", r );
2629     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2630     IXMLDOMComment_Release(comment);
2631     SysFreeString(str);
2632
2633     node = (IXMLDOMNode*)0x1;
2634     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2635     ok( r == S_OK, "returns %08x\n", r );
2636
2637     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2638     ok( r == S_OK, "returns %08x\n", r );
2639     IXMLDOMNode_Release(node);
2640
2641     str = NULL;
2642     r = IXMLDOMComment_get_data(comment, &str);
2643     ok( r == S_OK, "returns %08x\n", r );
2644     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2645     IXMLDOMComment_Release(comment);
2646     SysFreeString(str);
2647
2648     node = (IXMLDOMNode*)0x1;
2649     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2650     ok( r == S_OK, "returns %08x\n", r );
2651
2652     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2653     ok( r == S_OK, "returns %08x\n", r );
2654     IXMLDOMNode_Release(node);
2655
2656     str = NULL;
2657     r = IXMLDOMComment_get_data(comment, &str);
2658     ok( r == S_OK, "returns %08x\n", r );
2659     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2660     IXMLDOMComment_Release(comment);
2661     SysFreeString(str);
2662
2663     /* NODE_TEXT */
2664     V_VT(&var) = VT_I1;
2665     V_I1(&var) = NODE_TEXT;
2666     node = NULL;
2667     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2668     ok( r == S_OK, "returns %08x\n", r );
2669     ok( node != NULL, "\n");
2670
2671     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2672     ok( r == S_OK, "returns %08x\n", r );
2673     IXMLDOMNode_Release(node);
2674
2675     str = NULL;
2676     r = IXMLDOMText_get_data(text, &str);
2677     ok( r == S_OK, "returns %08x\n", r );
2678     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2679     IXMLDOMText_Release(text);
2680     SysFreeString(str);
2681
2682     node = (IXMLDOMNode*)0x1;
2683     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2684     ok( r == S_OK, "returns %08x\n", r );
2685
2686     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2687     ok( r == S_OK, "returns %08x\n", r );
2688     IXMLDOMNode_Release(node);
2689
2690     str = NULL;
2691     r = IXMLDOMText_get_data(text, &str);
2692     ok( r == S_OK, "returns %08x\n", r );
2693     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2694     IXMLDOMText_Release(text);
2695     SysFreeString(str);
2696
2697     node = (IXMLDOMNode*)0x1;
2698     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2699     ok( r == S_OK, "returns %08x\n", r );
2700
2701     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2702     ok( r == S_OK, "returns %08x\n", r );
2703     IXMLDOMNode_Release(node);
2704
2705     str = NULL;
2706     r = IXMLDOMText_get_data(text, &str);
2707     ok( r == S_OK, "returns %08x\n", r );
2708     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2709     IXMLDOMText_Release(text);
2710     SysFreeString(str);
2711
2712     /* NODE_CDATA_SECTION */
2713     V_VT(&var) = VT_I1;
2714     V_I1(&var) = NODE_CDATA_SECTION;
2715     node = NULL;
2716     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2717     ok( r == S_OK, "returns %08x\n", r );
2718     ok( node != NULL, "\n");
2719
2720     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2721     ok( r == S_OK, "returns %08x\n", r );
2722     IXMLDOMNode_Release(node);
2723
2724     str = NULL;
2725     r = IXMLDOMCDATASection_get_data(cdata, &str);
2726     ok( r == S_OK, "returns %08x\n", r );
2727     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2728     IXMLDOMCDATASection_Release(cdata);
2729     SysFreeString(str);
2730
2731     node = (IXMLDOMNode*)0x1;
2732     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2733     ok( r == S_OK, "returns %08x\n", r );
2734
2735     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2736     ok( r == S_OK, "returns %08x\n", r );
2737     IXMLDOMNode_Release(node);
2738
2739     str = NULL;
2740     r = IXMLDOMCDATASection_get_data(cdata, &str);
2741     ok( r == S_OK, "returns %08x\n", r );
2742     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2743     IXMLDOMCDATASection_Release(cdata);
2744     SysFreeString(str);
2745
2746     node = (IXMLDOMNode*)0x1;
2747     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2748     ok( r == S_OK, "returns %08x\n", r );
2749
2750     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2751     ok( r == S_OK, "returns %08x\n", r );
2752     IXMLDOMNode_Release(node);
2753
2754     str = NULL;
2755     r = IXMLDOMCDATASection_get_data(cdata, &str);
2756     ok( r == S_OK, "returns %08x\n", r );
2757     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2758     IXMLDOMCDATASection_Release(cdata);
2759     SysFreeString(str);
2760
2761     /* NODE_ATTRIBUTE */
2762     V_VT(&var) = VT_I1;
2763     V_I1(&var) = NODE_ATTRIBUTE;
2764     node = (IXMLDOMNode*)0x1;
2765     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2766     ok( r == E_FAIL, "returns %08x\n", r );
2767     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2768
2769     V_VT(&var) = VT_I1;
2770     V_I1(&var) = NODE_ATTRIBUTE;
2771     node = (IXMLDOMNode*)0x1;
2772     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2773     ok( r == E_FAIL, "returns %08x\n", r );
2774     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2775
2776     V_VT(&var) = VT_I1;
2777     V_I1(&var) = NODE_ATTRIBUTE;
2778     str = SysAllocString( szlc );
2779     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2780     ok( r == S_OK, "returns %08x\n", r );
2781     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2782     SysFreeString(str);
2783
2784     /* a name is required for attribute, try a BSTR with first null wchar */
2785     V_VT(&var) = VT_I1;
2786     V_I1(&var) = NODE_ATTRIBUTE;
2787     str = SysAllocString( szstr1 );
2788     str[0] = 0;
2789     node = (IXMLDOMNode*)0x1;
2790     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2791     ok( r == E_FAIL, "returns %08x\n", r );
2792     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2793     SysFreeString(str);
2794
2795     /* NODE_PROCESSING_INSTRUCTION */
2796     V_VT(&var) = VT_I1;
2797     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2798     node = (IXMLDOMNode*)0x1;
2799     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2800     ok( r == E_FAIL, "returns %08x\n", r );
2801     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2802
2803     V_VT(&var) = VT_I1;
2804     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2805     node = (IXMLDOMNode*)0x1;
2806     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2807     ok( r == E_FAIL, "returns %08x\n", r );
2808     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2809
2810     V_VT(&var) = VT_I1;
2811     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2812     r = IXMLDOMDocument_createNode( doc, var, _bstr_("pi"), NULL, NULL );
2813     ok( r == E_INVALIDARG, "returns %08x\n", r );
2814
2815     /* NODE_ENTITY_REFERENCE */
2816     V_VT(&var) = VT_I1;
2817     V_I1(&var) = NODE_ENTITY_REFERENCE;
2818     node = (IXMLDOMNode*)0x1;
2819     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2820     ok( r == E_FAIL, "returns %08x\n", r );
2821     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2822
2823     V_VT(&var) = VT_I1;
2824     V_I1(&var) = NODE_ENTITY_REFERENCE;
2825     node = (IXMLDOMNode*)0x1;
2826     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2827     ok( r == E_FAIL, "returns %08x\n", r );
2828     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2829
2830     /* NODE_ELEMENT */
2831     V_VT(&var) = VT_I1;
2832     V_I1(&var) = NODE_ELEMENT;
2833     node = (IXMLDOMNode*)0x1;
2834     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2835     ok( r == E_FAIL, "returns %08x\n", r );
2836     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2837
2838     V_VT(&var) = VT_I1;
2839     V_I1(&var) = NODE_ELEMENT;
2840     node = (IXMLDOMNode*)0x1;
2841     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2842     ok( r == E_FAIL, "returns %08x\n", r );
2843     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2844
2845     V_VT(&var) = VT_I1;
2846     V_I1(&var) = NODE_ELEMENT;
2847     str = SysAllocString( szlc );
2848     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2849     ok( r == S_OK, "returns %08x\n", r );
2850     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2851
2852     V_VT(&var) = VT_I1;
2853     V_I1(&var) = NODE_ELEMENT;
2854     r = IXMLDOMDocument_createNode( doc, var, str, NULL, NULL );
2855     ok( r == E_INVALIDARG, "returns %08x\n", r );
2856
2857     V_VT(&var) = VT_R4;
2858     V_R4(&var) = NODE_ELEMENT;
2859     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2860     ok( r == S_OK, "returns %08x\n", r );
2861     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2862
2863     V_VT(&var) = VT_BSTR;
2864     V_BSTR(&var) = SysAllocString( szOne );
2865     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2866     ok( r == S_OK, "returns %08x\n", r );
2867     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2868     VariantClear(&var);
2869
2870     V_VT(&var) = VT_BSTR;
2871     V_BSTR(&var) = SysAllocString( szOneGarbage );
2872     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2873     ok( r == E_INVALIDARG, "returns %08x\n", r );
2874     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2875     VariantClear(&var);
2876
2877     V_VT(&var) = VT_I4;
2878     V_I4(&var) = NODE_ELEMENT;
2879     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2880     ok( r == S_OK, "returns %08x\n", r );
2881
2882     EXPECT_REF(doc, 1);
2883     r = IXMLDOMDocument_appendChild( doc, node, &root );
2884     ok( r == S_OK, "returns %08x\n", r );
2885     ok( node == root, "%p %p\n", node, root );
2886     EXPECT_REF(doc, 1);
2887
2888     EXPECT_REF(node, 2);
2889
2890     ref = IXMLDOMNode_Release( node );
2891     ok(ref == 1, "ref %d\n", ref);
2892     SysFreeString( str );
2893
2894     V_VT(&var) = VT_I4;
2895     V_I4(&var) = NODE_ELEMENT;
2896     str = SysAllocString( szbs );
2897     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2898     ok( r == S_OK, "returns %08x\n", r );
2899     SysFreeString( str );
2900
2901     EXPECT_REF(node, 1);
2902
2903     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk );
2904     ok( r == S_OK, "returns %08x\n", r );
2905
2906     EXPECT_REF(unk, 2);
2907
2908     V_VT(&var) = VT_EMPTY;
2909     child = NULL;
2910     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
2911     ok( r == S_OK, "returns %08x\n", r );
2912     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
2913
2914     todo_wine EXPECT_REF(unk, 4);
2915
2916     IXMLDOMNode_Release( child );
2917     IUnknown_Release( unk );
2918
2919     V_VT(&var) = VT_NULL;
2920     V_DISPATCH(&var) = (IDispatch*)node;
2921     r = IXMLDOMNode_insertBefore( root, node, var, &child );
2922     ok( r == S_OK, "returns %08x\n", r );
2923     ok( node == child, "%p %p\n", node, child );
2924     IXMLDOMNode_Release( child );
2925
2926     V_VT(&var) = VT_NULL;
2927     V_DISPATCH(&var) = (IDispatch*)node;
2928     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
2929     ok( r == S_OK, "returns %08x\n", r );
2930     IXMLDOMNode_Release( node );
2931
2932     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (void**)&element );
2933     ok( r == S_OK, "returns %08x\n", r );
2934
2935     r = IXMLDOMElement_get_attributes( element, &attr_map );
2936     ok( r == S_OK, "returns %08x\n", r );
2937     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2938     ok( r == S_OK, "returns %08x\n", r );
2939     ok( num == 0, "num %d\n", num );
2940     IXMLDOMNamedNodeMap_Release( attr_map );
2941
2942     V_VT(&var) = VT_BSTR;
2943     V_BSTR(&var) = SysAllocString( szstr1 );
2944     name = SysAllocString( szdl );
2945     r = IXMLDOMElement_setAttribute( element, name, var );
2946     ok( r == S_OK, "returns %08x\n", r );
2947     r = IXMLDOMElement_get_attributes( element, &attr_map );
2948     ok( r == S_OK, "returns %08x\n", r );
2949     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2950     ok( r == S_OK, "returns %08x\n", r );
2951     ok( num == 1, "num %d\n", num );
2952     IXMLDOMNamedNodeMap_Release( attr_map );
2953     VariantClear(&var);
2954
2955     V_VT(&var) = VT_BSTR;
2956     V_BSTR(&var) = SysAllocString( szstr2 );
2957     r = IXMLDOMElement_setAttribute( element, name, var );
2958     ok( r == S_OK, "returns %08x\n", r );
2959     r = IXMLDOMElement_get_attributes( element, &attr_map );
2960     ok( r == S_OK, "returns %08x\n", r );
2961     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2962     ok( r == S_OK, "returns %08x\n", r );
2963     ok( num == 1, "num %d\n", num );
2964     IXMLDOMNamedNodeMap_Release( attr_map );
2965     VariantClear(&var);
2966     r = IXMLDOMElement_getAttribute( element, name, &var );
2967     ok( r == S_OK, "returns %08x\n", r );
2968     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
2969     VariantClear(&var);
2970     SysFreeString(name);
2971
2972     V_VT(&var) = VT_BSTR;
2973     V_BSTR(&var) = SysAllocString( szstr1 );
2974     name = SysAllocString( szlc );
2975     r = IXMLDOMElement_setAttribute( element, name, var );
2976     ok( r == S_OK, "returns %08x\n", r );
2977     r = IXMLDOMElement_get_attributes( element, &attr_map );
2978     ok( r == S_OK, "returns %08x\n", r );
2979     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2980     ok( r == S_OK, "returns %08x\n", r );
2981     ok( num == 2, "num %d\n", num );
2982     IXMLDOMNamedNodeMap_Release( attr_map );
2983     VariantClear(&var);
2984     SysFreeString(name);
2985
2986     V_VT(&var) = VT_I4;
2987     V_I4(&var) = 10;
2988     name = SysAllocString( szbs );
2989     r = IXMLDOMElement_setAttribute( element, name, var );
2990     ok( r == S_OK, "returns %08x\n", r );
2991     VariantClear(&var);
2992     r = IXMLDOMElement_getAttribute( element, name, &var );
2993     ok( r == S_OK, "returns %08x\n", r );
2994     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
2995     VariantClear(&var);
2996     SysFreeString(name);
2997
2998     /* Create an Attribute */
2999     V_VT(&var) = VT_I4;
3000     V_I4(&var) = NODE_ATTRIBUTE;
3001     str = SysAllocString( szAttribute );
3002     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3003     ok( r == S_OK, "returns %08x\n", r );
3004     ok( node != NULL, "node was null\n");
3005     SysFreeString(str);
3006
3007     IXMLDOMElement_Release( element );
3008     IXMLDOMNode_Release( root );
3009     IXMLDOMDocument_Release( doc );
3010 }
3011
3012 static void test_getElementsByTagName(void)
3013 {
3014     IXMLDOMNodeList *node_list;
3015     IXMLDOMDocument *doc;
3016     IXMLDOMElement *elem;
3017     WCHAR buff[100];
3018     VARIANT_BOOL b;
3019     HRESULT r;
3020     LONG len;
3021     BSTR str;
3022
3023     doc = create_document(&IID_IXMLDOMDocument);
3024
3025     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3026     ok( r == S_OK, "loadXML failed\n");
3027     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3028
3029     str = SysAllocString( szstar );
3030
3031     /* null arguments cases */
3032     r = IXMLDOMDocument_getElementsByTagName(doc, NULL, &node_list);
3033     ok( r == E_INVALIDARG, "ret %08x\n", r );
3034     r = IXMLDOMDocument_getElementsByTagName(doc, str, NULL);
3035     ok( r == E_INVALIDARG, "ret %08x\n", r );
3036
3037     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
3038     ok( r == S_OK, "ret %08x\n", r );
3039     r = IXMLDOMNodeList_get_length( node_list, &len );
3040     ok( r == S_OK, "ret %08x\n", r );
3041     ok( len == 6, "len %d\n", len );
3042
3043     IXMLDOMNodeList_Release( node_list );
3044     SysFreeString( str );
3045
3046     /* broken query BSTR */
3047     memcpy(&buff[2], szstar, sizeof(szstar));
3048     /* just a big length */
3049     *(DWORD*)buff = 0xf0f0;
3050     r = IXMLDOMDocument_getElementsByTagName(doc, &buff[2], &node_list);
3051     ok( r == S_OK, "ret %08x\n", r );
3052     r = IXMLDOMNodeList_get_length( node_list, &len );
3053     ok( r == S_OK, "ret %08x\n", r );
3054     ok( len == 6, "len %d\n", len );
3055     IXMLDOMNodeList_Release( node_list );
3056
3057     str = SysAllocString( szbs );
3058     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
3059     ok( r == S_OK, "ret %08x\n", r );
3060     r = IXMLDOMNodeList_get_length( node_list, &len );
3061     ok( r == S_OK, "ret %08x\n", r );
3062     ok( len == 1, "len %d\n", len );
3063     IXMLDOMNodeList_Release( node_list );
3064     SysFreeString( str );
3065
3066     str = SysAllocString( szdl );
3067     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
3068     ok( r == S_OK, "ret %08x\n", r );
3069     r = IXMLDOMNodeList_get_length( node_list, &len );
3070     ok( r == S_OK, "ret %08x\n", r );
3071     ok( len == 0, "len %d\n", len );
3072     IXMLDOMNodeList_Release( node_list );
3073     SysFreeString( str );
3074
3075     str = SysAllocString( szstr1 );
3076     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
3077     ok( r == S_OK, "ret %08x\n", r );
3078     r = IXMLDOMNodeList_get_length( node_list, &len );
3079     ok( r == S_OK, "ret %08x\n", r );
3080     ok( len == 0, "len %d\n", len );
3081     IXMLDOMNodeList_Release( node_list );
3082     SysFreeString( str );
3083
3084     /* test for element */
3085     r = IXMLDOMDocument_get_documentElement(doc, &elem);
3086     ok( r == S_OK, "ret %08x\n", r );
3087
3088     str = SysAllocString( szstar );
3089
3090     /* null arguments cases */
3091     r = IXMLDOMElement_getElementsByTagName(elem, NULL, &node_list);
3092     ok( r == E_INVALIDARG, "ret %08x\n", r );
3093     r = IXMLDOMElement_getElementsByTagName(elem, str, NULL);
3094     ok( r == E_INVALIDARG, "ret %08x\n", r );
3095
3096     r = IXMLDOMElement_getElementsByTagName(elem, str, &node_list);
3097     ok( r == S_OK, "ret %08x\n", r );
3098     r = IXMLDOMNodeList_get_length( node_list, &len );
3099     ok( r == S_OK, "ret %08x\n", r );
3100     ok( len == 5, "len %d\n", len );
3101     expect_list_and_release(node_list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1");
3102     SysFreeString( str );
3103
3104     /* broken query BSTR */
3105     memcpy(&buff[2], szstar, sizeof(szstar));
3106     /* just a big length */
3107     *(DWORD*)buff = 0xf0f0;
3108     r = IXMLDOMElement_getElementsByTagName(elem, &buff[2], &node_list);
3109     ok( r == S_OK, "ret %08x\n", r );
3110     r = IXMLDOMNodeList_get_length( node_list, &len );
3111     ok( r == S_OK, "ret %08x\n", r );
3112     ok( len == 5, "len %d\n", len );
3113     IXMLDOMNodeList_Release( node_list );
3114
3115     IXMLDOMElement_Release(elem);
3116
3117     IXMLDOMDocument_Release( doc );
3118
3119     free_bstrs();
3120 }
3121
3122 static void test_get_text(void)
3123 {
3124     HRESULT r;
3125     BSTR str;
3126     VARIANT_BOOL b;
3127     IXMLDOMDocument *doc;
3128     IXMLDOMNode *node, *node2, *node3;
3129     IXMLDOMNode *nodeRoot;
3130     IXMLDOMNodeList *node_list;
3131     IXMLDOMNamedNodeMap *node_map;
3132     LONG len;
3133
3134     doc = create_document(&IID_IXMLDOMDocument);
3135
3136     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3137     ok( r == S_OK, "loadXML failed\n");
3138     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3139
3140     str = SysAllocString( szbs );
3141     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
3142     ok( r == S_OK, "ret %08x\n", r );
3143     SysFreeString(str);
3144
3145     /* Test to get all child node text. */
3146     r = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&nodeRoot);
3147     ok( r == S_OK, "ret %08x\n", r );
3148     if(r == S_OK)
3149     {
3150         r = IXMLDOMNode_get_text( nodeRoot, &str );
3151         ok( r == S_OK, "ret %08x\n", r );
3152         ok( compareIgnoreReturns(str, _bstr_("fn1.txt\n\n fn2.txt \n\nf1\n")), "wrong get_text: %s\n", wine_dbgstr_w(str));
3153         SysFreeString(str);
3154
3155         IXMLDOMNode_Release(nodeRoot);
3156     }
3157
3158     r = IXMLDOMNodeList_get_length( node_list, NULL );
3159     ok( r == E_INVALIDARG, "ret %08x\n", r );
3160
3161     r = IXMLDOMNodeList_get_length( node_list, &len );
3162     ok( r == S_OK, "ret %08x\n", r );
3163     ok( len == 1, "expect 1 got %d\n", len );
3164
3165     r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
3166     ok( r == E_INVALIDARG, "ret %08x\n", r );
3167
3168     r = IXMLDOMNodeList_nextNode( node_list, NULL );
3169     ok( r == E_INVALIDARG, "ret %08x\n", r );
3170
3171     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
3172     ok( r == S_OK, "ret %08x\n", r );
3173     IXMLDOMNodeList_Release( node_list );
3174
3175     /* Invalid output parameter*/
3176     r = IXMLDOMNode_get_text( node, NULL );
3177     ok( r == E_INVALIDARG, "ret %08x\n", r );
3178
3179     r = IXMLDOMNode_get_text( node, &str );
3180     ok( r == S_OK, "ret %08x\n", r );
3181     ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
3182     SysFreeString(str);
3183
3184     r = IXMLDOMNode_get_attributes( node, &node_map );
3185     ok( r == S_OK, "ret %08x\n", r );
3186
3187     str = SysAllocString( szvr );
3188     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
3189     ok( r == S_OK, "ret %08x\n", r );
3190     SysFreeString(str);
3191
3192     r = IXMLDOMNode_get_text( node2, &str );
3193     ok( r == S_OK, "ret %08x\n", r );
3194     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3195     SysFreeString(str);
3196
3197     r = IXMLDOMNode_get_firstChild( node2, &node3 );
3198     ok( r == S_OK, "ret %08x\n", r );
3199
3200     r = IXMLDOMNode_get_text( node3, &str );
3201     ok( r == S_OK, "ret %08x\n", r );
3202     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3203     SysFreeString(str);
3204
3205
3206     IXMLDOMNode_Release( node3 );
3207     IXMLDOMNode_Release( node2 );
3208     IXMLDOMNamedNodeMap_Release( node_map );
3209     IXMLDOMNode_Release( node );
3210     IXMLDOMDocument_Release( doc );
3211
3212     free_bstrs();
3213 }
3214
3215 static void test_get_childNodes(void)
3216 {
3217     IXMLDOMNodeList *node_list, *node_list2;
3218     IEnumVARIANT *enum1, *enum2, *enum3;
3219     VARIANT_BOOL b;
3220     IXMLDOMDocument *doc;
3221     IXMLDOMNode *node, *node2;
3222     IXMLDOMElement *element;
3223     IUnknown *unk1, *unk2;
3224     HRESULT hr;
3225     VARIANT v;
3226     BSTR str;
3227     LONG len;
3228
3229     doc = create_document(&IID_IXMLDOMDocument);
3230
3231     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3232     EXPECT_HR(hr, S_OK);
3233     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3234
3235     hr = IXMLDOMDocument_get_documentElement( doc, &element );
3236     EXPECT_HR(hr, S_OK);
3237
3238     hr = IXMLDOMElement_get_childNodes( element, &node_list );
3239     EXPECT_HR(hr, S_OK);
3240
3241     hr = IXMLDOMNodeList_get_length( node_list, &len );
3242     EXPECT_HR(hr, S_OK);
3243     ok( len == 4, "len %d\n", len);
3244
3245     /* refcount tests for IEnumVARIANT support */
3246     EXPECT_REF(node_list, 1);
3247     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum1);
3248     EXPECT_HR(hr, S_OK);
3249     EXPECT_REF(node_list, 1);
3250     EXPECT_REF(enum1, 2);
3251
3252     EXPECT_REF(node_list, 1);
3253     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum2);
3254     EXPECT_HR(hr, S_OK);
3255     EXPECT_REF(node_list, 1);
3256     ok(enum2 == enum1, "got %p, %p\n", enum2, enum1);
3257     IEnumVARIANT_Release(enum2);
3258
3259     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
3260     EXPECT_HR(hr, S_OK);
3261     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
3262     EXPECT_HR(hr, S_OK);
3263     EXPECT_REF(node_list, 3);
3264     EXPECT_REF(enum1, 2);
3265     ok(unk1 == unk2, "got %p, %p\n", unk1, unk2);
3266     IUnknown_Release(unk1);
3267     IUnknown_Release(unk2);
3268
3269     EXPECT_REF(node_list, 1);
3270     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum2);
3271     EXPECT_HR(hr, S_OK);
3272     EXPECT_REF(node_list, 2);
3273     EXPECT_REF(enum2, 1);
3274     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
3275
3276     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
3277     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
3278     EXPECT_HR(hr, S_OK);
3279     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
3280     EXPECT_HR(hr, S_OK);
3281     EXPECT_REF(node_list, 3);
3282     EXPECT_REF(enum2, 2);
3283     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
3284     IUnknown_Release(unk1);
3285     IUnknown_Release(unk2);
3286
3287     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum3);
3288     EXPECT_HR(hr, S_OK);
3289     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
3290     IEnumVARIANT_Release(enum3);
3291     IEnumVARIANT_Release(enum2);
3292
3293     /* iteration tests */
3294     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
3295     EXPECT_HR(hr, S_OK);
3296     hr = IXMLDOMNode_get_nodeName(node, &str);
3297     EXPECT_HR(hr, S_OK);
3298     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
3299     SysFreeString(str);
3300     IXMLDOMNode_Release(node);
3301
3302     hr = IXMLDOMNodeList_nextNode(node_list, &node);
3303     EXPECT_HR(hr, S_OK);
3304     hr = IXMLDOMNode_get_nodeName(node, &str);
3305     EXPECT_HR(hr, S_OK);
3306     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
3307     SysFreeString(str);
3308     IXMLDOMNode_Release(node);
3309
3310     V_VT(&v) = VT_EMPTY;
3311     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
3312     EXPECT_HR(hr, S_OK);
3313     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
3314     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
3315     EXPECT_HR(hr, S_OK);
3316     hr = IXMLDOMNode_get_nodeName(node, &str);
3317     EXPECT_HR(hr, S_OK);
3318     ok(!lstrcmpW(str, _bstr_("bs")), "got node name %s\n", wine_dbgstr_w(str));
3319     SysFreeString(str);
3320     IXMLDOMNode_Release(node);
3321     VariantClear(&v);
3322
3323     hr = IXMLDOMNodeList_nextNode(node_list, &node);
3324     EXPECT_HR(hr, S_OK);
3325     hr = IXMLDOMNode_get_nodeName(node, &str);
3326     EXPECT_HR(hr, S_OK);
3327     ok(!lstrcmpW(str, _bstr_("pr")), "got %s\n", wine_dbgstr_w(str));
3328     SysFreeString(str);
3329     IXMLDOMNode_Release(node);
3330
3331     IEnumVARIANT_Release(enum1);
3332
3333     hr = IXMLDOMNodeList_get_item( node_list, 2, &node );
3334     EXPECT_HR(hr, S_OK);
3335
3336     hr = IXMLDOMNode_get_childNodes( node, &node_list2 );
3337     EXPECT_HR(hr, S_OK);
3338
3339     hr = IXMLDOMNodeList_get_length( node_list2, &len );
3340     EXPECT_HR(hr, S_OK);
3341     ok( len == 0, "len %d\n", len);
3342
3343     hr = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
3344     EXPECT_HR(hr, S_FALSE);
3345
3346     IXMLDOMNodeList_Release( node_list2 );
3347     IXMLDOMNode_Release( node );
3348     IXMLDOMNodeList_Release( node_list );
3349     IXMLDOMElement_Release( element );
3350
3351     /* test for children of <?xml ..?> node */
3352     hr = IXMLDOMDocument_get_firstChild(doc, &node);
3353     EXPECT_HR(hr, S_OK);
3354
3355     str = NULL;
3356     hr = IXMLDOMNode_get_nodeName(node, &str);
3357     EXPECT_HR(hr, S_OK);
3358     ok(!lstrcmpW(str, _bstr_("xml")), "got %s\n", wine_dbgstr_w(str));
3359     SysFreeString(str);
3360
3361     /* it returns empty but valid node list */
3362     node_list = (void*)0xdeadbeef;
3363     hr = IXMLDOMNode_get_childNodes(node, &node_list);
3364     EXPECT_HR(hr, S_OK);
3365
3366     len = -1;
3367     hr = IXMLDOMNodeList_get_length(node_list, &len);
3368     EXPECT_HR(hr, S_OK);
3369     ok(len == 0, "got %d\n", len);
3370
3371     IXMLDOMNodeList_Release( node_list );
3372     IXMLDOMNode_Release(node);
3373
3374     IXMLDOMDocument_Release( doc );
3375     free_bstrs();
3376 }
3377
3378 static void test_get_firstChild(void)
3379 {
3380     static const WCHAR xmlW[] = {'x','m','l',0};
3381     IXMLDOMDocument *doc;
3382     IXMLDOMNode *node;
3383     VARIANT_BOOL b;
3384     HRESULT r;
3385     BSTR str;
3386
3387     doc = create_document(&IID_IXMLDOMDocument);
3388
3389     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3390     ok( r == S_OK, "loadXML failed\n");
3391     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3392
3393     r = IXMLDOMDocument_get_firstChild( doc, &node );
3394     ok( r == S_OK, "ret %08x\n", r);
3395
3396     r = IXMLDOMNode_get_nodeName( node, &str );
3397     ok( r == S_OK, "ret %08x\n", r);
3398
3399     ok(!lstrcmpW(str, xmlW), "expected \"xml\" node name, got %s\n", wine_dbgstr_w(str));
3400
3401     SysFreeString(str);
3402     IXMLDOMNode_Release( node );
3403     IXMLDOMDocument_Release( doc );
3404
3405     free_bstrs();
3406 }
3407
3408 static void test_get_lastChild(void)
3409 {
3410     static const WCHAR lcW[] = {'l','c',0};
3411     static const WCHAR foW[] = {'f','o',0};
3412     IXMLDOMDocument *doc;
3413     IXMLDOMNode *node, *child;
3414     VARIANT_BOOL b;
3415     HRESULT r;
3416     BSTR str;
3417
3418     doc = create_document(&IID_IXMLDOMDocument);
3419
3420     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3421     ok( r == S_OK, "loadXML failed\n");
3422     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3423
3424     r = IXMLDOMDocument_get_lastChild( doc, &node );
3425     ok( r == S_OK, "ret %08x\n", r);
3426
3427     r = IXMLDOMNode_get_nodeName( node, &str );
3428     ok( r == S_OK, "ret %08x\n", r);
3429
3430     ok(memcmp(str, lcW, sizeof(lcW)) == 0, "expected \"lc\" node name\n");
3431     SysFreeString(str);
3432
3433     r = IXMLDOMNode_get_lastChild( node, &child );
3434     ok( r == S_OK, "ret %08x\n", r);
3435
3436     r = IXMLDOMNode_get_nodeName( child, &str );
3437     ok( r == S_OK, "ret %08x\n", r);
3438
3439     ok(memcmp(str, foW, sizeof(foW)) == 0, "expected \"fo\" node name\n");
3440     SysFreeString(str);
3441
3442     IXMLDOMNode_Release( child );
3443     IXMLDOMNode_Release( node );
3444     IXMLDOMDocument_Release( doc );
3445
3446     free_bstrs();
3447 }
3448
3449 static void test_removeChild(void)
3450 {
3451     HRESULT r;
3452     VARIANT_BOOL b;
3453     IXMLDOMDocument *doc;
3454     IXMLDOMElement *element, *lc_element;
3455     IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
3456     IXMLDOMNodeList *root_list, *fo_list;
3457
3458     doc = create_document(&IID_IXMLDOMDocument);
3459
3460     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3461     ok( r == S_OK, "loadXML failed\n");
3462     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3463
3464     r = IXMLDOMDocument_get_documentElement( doc, &element );
3465     ok( r == S_OK, "ret %08x\n", r);
3466     todo_wine EXPECT_REF(element, 2);
3467
3468     r = IXMLDOMElement_get_childNodes( element, &root_list );
3469     ok( r == S_OK, "ret %08x\n", r);
3470     EXPECT_REF(root_list, 1);
3471
3472     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3473     ok( r == S_OK, "ret %08x\n", r);
3474     EXPECT_REF(fo_node, 1);
3475
3476     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3477     ok( r == S_OK, "ret %08x\n", r);
3478     EXPECT_REF(fo_list, 1);
3479
3480     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3481     ok( r == S_OK, "ret %08x\n", r);
3482     EXPECT_REF(ba_node, 1);
3483
3484     /* invalid parameter: NULL ptr */
3485     removed_node = (void*)0xdeadbeef;
3486     r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
3487     ok( r == E_INVALIDARG, "ret %08x\n", r );
3488     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3489
3490     /* ba_node is a descendant of element, but not a direct child. */
3491     removed_node = (void*)0xdeadbeef;
3492     EXPECT_REF(ba_node, 1);
3493     EXPECT_CHILDREN(fo_node);
3494     r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
3495     ok( r == E_INVALIDARG, "ret %08x\n", r );
3496     ok( removed_node == NULL, "%p\n", removed_node );
3497     EXPECT_REF(ba_node, 1);
3498     EXPECT_CHILDREN(fo_node);
3499
3500     EXPECT_REF(ba_node, 1);
3501     EXPECT_REF(fo_node, 1);
3502     r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
3503     ok( r == S_OK, "ret %08x\n", r);
3504     ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
3505     EXPECT_REF(fo_node, 2);
3506     EXPECT_REF(ba_node, 1);
3507
3508     /* try removing already removed child */
3509     temp_node = (void*)0xdeadbeef;
3510     r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
3511     ok( r == E_INVALIDARG, "ret %08x\n", r);
3512     ok( temp_node == NULL, "%p\n", temp_node );
3513     IXMLDOMNode_Release( fo_node );
3514
3515     /* the removed node has no parent anymore */
3516     r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
3517     ok( r == S_FALSE, "ret %08x\n", r);
3518     ok( temp_node == NULL, "%p\n", temp_node );
3519
3520     IXMLDOMNode_Release( removed_node );
3521     IXMLDOMNode_Release( ba_node );
3522     IXMLDOMNodeList_Release( fo_list );
3523
3524     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3525     ok( r == S_OK, "ret %08x\n", r);
3526
3527     r = IXMLDOMNode_QueryInterface( lc_node, &IID_IXMLDOMElement, (void**)&lc_element );
3528     ok( r == S_OK, "ret %08x\n", r);
3529
3530     /* MS quirk: passing wrong interface pointer works, too */
3531     r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
3532     ok( r == S_OK, "ret %08x\n", r);
3533     IXMLDOMElement_Release( lc_element );
3534
3535     temp_node = (void*)0xdeadbeef;
3536     r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
3537     ok( r == S_FALSE, "ret %08x\n", r);
3538     ok( temp_node == NULL, "%p\n", temp_node );
3539
3540     IXMLDOMNode_Release( lc_node );
3541     IXMLDOMNodeList_Release( root_list );
3542     IXMLDOMElement_Release( element );
3543     IXMLDOMDocument_Release( doc );
3544
3545     free_bstrs();
3546 }
3547
3548 static void test_replaceChild(void)
3549 {
3550     HRESULT r;
3551     VARIANT_BOOL b;
3552     IXMLDOMDocument *doc;
3553     IXMLDOMElement *element, *ba_element;
3554     IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
3555     IXMLDOMNodeList *root_list, *fo_list;
3556     IUnknown * unk1, *unk2;
3557     LONG len;
3558
3559     doc = create_document(&IID_IXMLDOMDocument);
3560
3561     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3562     ok( r == S_OK, "loadXML failed\n");
3563     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3564
3565     r = IXMLDOMDocument_get_documentElement( doc, &element );
3566     ok( r == S_OK, "ret %08x\n", r);
3567
3568     r = IXMLDOMElement_get_childNodes( element, &root_list );
3569     ok( r == S_OK, "ret %08x\n", r);
3570
3571     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3572     ok( r == S_OK, "ret %08x\n", r);
3573
3574     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3575     ok( r == S_OK, "ret %08x\n", r);
3576
3577     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3578     ok( r == S_OK, "ret %08x\n", r);
3579
3580     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3581     ok( r == S_OK, "ret %08x\n", r);
3582
3583     IXMLDOMNodeList_Release( fo_list );
3584
3585     /* invalid parameter: NULL ptr for element to remove */
3586     removed_node = (void*)0xdeadbeef;
3587     r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
3588     ok( r == E_INVALIDARG, "ret %08x\n", r );
3589     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3590
3591     /* invalid parameter: NULL for replacement element. (Sic!) */
3592     removed_node = (void*)0xdeadbeef;
3593     r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
3594     ok( r == E_INVALIDARG, "ret %08x\n", r );
3595     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3596
3597     /* invalid parameter: OldNode is not a child */
3598     removed_node = (void*)0xdeadbeef;
3599     r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
3600     ok( r == E_INVALIDARG, "ret %08x\n", r );
3601     ok( removed_node == NULL, "%p\n", removed_node );
3602     IXMLDOMNode_Release( lc_node );
3603
3604     /* invalid parameter: would create loop */
3605     removed_node = (void*)0xdeadbeef;
3606     r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
3607     ok( r == E_FAIL, "ret %08x\n", r );
3608     ok( removed_node == NULL, "%p\n", removed_node );
3609
3610     r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
3611     ok( r == S_OK, "ret %08x\n", r );
3612
3613     r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
3614     ok( r == S_OK, "ret %08x\n", r );
3615
3616     /* ba_node and temp_node refer to the same node, yet they
3617        are different interface pointers */
3618     ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
3619     r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
3620     ok( r == S_OK, "ret %08x\n", r );
3621     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
3622     ok( r == S_OK, "ret %08x\n", r );
3623     todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
3624
3625     IUnknown_Release( unk1 );
3626     IUnknown_Release( unk2 );
3627
3628     /* ba_node should have been removed from below fo_node */
3629     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3630     ok( r == S_OK, "ret %08x\n", r );
3631
3632     /* MS quirk: replaceChild also accepts elements instead of nodes */
3633     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
3634     ok( r == S_OK, "ret %08x\n", r );
3635     EXPECT_REF(ba_element, 2);
3636
3637     removed_node = NULL;
3638     r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
3639     ok( r == S_OK, "ret %08x\n", r );
3640     ok( removed_node != NULL, "got %p\n", removed_node);
3641     EXPECT_REF(ba_element, 3);
3642     IXMLDOMElement_Release( ba_element );
3643
3644     r = IXMLDOMNodeList_get_length( fo_list, &len);
3645     ok( r == S_OK, "ret %08x\n", r );
3646     ok( len == 0, "len %d\n", len);
3647
3648     IXMLDOMNodeList_Release( fo_list );
3649
3650     IXMLDOMNode_Release(ba_node);
3651     IXMLDOMNode_Release(fo_node);
3652     IXMLDOMNode_Release(temp_node);
3653     IXMLDOMNodeList_Release( root_list );
3654     IXMLDOMElement_Release( element );
3655     IXMLDOMDocument_Release( doc );
3656
3657     free_bstrs();
3658 }
3659
3660 static void test_removeNamedItem(void)
3661 {
3662     IXMLDOMDocument *doc;
3663     IXMLDOMElement *element;
3664     IXMLDOMNode *pr_node, *removed_node, *removed_node2;
3665     IXMLDOMNodeList *root_list;
3666     IXMLDOMNamedNodeMap * pr_attrs;
3667     VARIANT_BOOL b;
3668     BSTR str;
3669     LONG len;
3670     HRESULT r;
3671
3672     doc = create_document(&IID_IXMLDOMDocument);
3673
3674     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3675     ok( r == S_OK, "loadXML failed\n");
3676     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3677
3678     r = IXMLDOMDocument_get_documentElement( doc, &element );
3679     ok( r == S_OK, "ret %08x\n", r);
3680
3681     r = IXMLDOMElement_get_childNodes( element, &root_list );
3682     ok( r == S_OK, "ret %08x\n", r);
3683
3684     r = IXMLDOMNodeList_get_item( root_list, 1, &pr_node );
3685     ok( r == S_OK, "ret %08x\n", r);
3686
3687     r = IXMLDOMNode_get_attributes( pr_node, &pr_attrs );
3688     ok( r == S_OK, "ret %08x\n", r);
3689
3690     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3691     ok( r == S_OK, "ret %08x\n", r);
3692     ok( len == 3, "length %d\n", len);
3693
3694     removed_node = (void*)0xdeadbeef;
3695     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, NULL, &removed_node);
3696     ok ( r == E_INVALIDARG, "ret %08x\n", r);
3697     ok ( removed_node == (void*)0xdeadbeef, "got %p\n", removed_node);
3698
3699     removed_node = (void*)0xdeadbeef;
3700     str = SysAllocString(szvr);
3701     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node);
3702     ok ( r == S_OK, "ret %08x\n", r);
3703
3704     removed_node2 = (void*)0xdeadbeef;
3705     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node2);
3706     ok ( r == S_FALSE, "ret %08x\n", r);
3707     ok ( removed_node2 == NULL, "got %p\n", removed_node2 );
3708
3709     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3710     ok( r == S_OK, "ret %08x\n", r);
3711     ok( len == 2, "length %d\n", len);
3712
3713     r = IXMLDOMNamedNodeMap_setNamedItem( pr_attrs, removed_node, NULL);
3714     ok ( r == S_OK, "ret %08x\n", r);
3715     IXMLDOMNode_Release(removed_node);
3716
3717     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3718     ok( r == S_OK, "ret %08x\n", r);
3719     ok( len == 3, "length %d\n", len);
3720
3721     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
3722     ok ( r == S_OK, "ret %08x\n", r);
3723
3724     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3725     ok( r == S_OK, "ret %08x\n", r);
3726     ok( len == 2, "length %d\n", len);
3727
3728     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
3729     ok ( r == S_FALSE, "ret %08x\n", r);
3730
3731     SysFreeString(str);
3732
3733     IXMLDOMNamedNodeMap_Release( pr_attrs );
3734     IXMLDOMNode_Release( pr_node );
3735     IXMLDOMNodeList_Release( root_list );
3736     IXMLDOMElement_Release( element );
3737     IXMLDOMDocument_Release( doc );
3738
3739     free_bstrs();
3740 }
3741
3742 #define test_IObjectSafety_set(p, r, r2, s, m, e, e2) _test_IObjectSafety_set(__LINE__,p, r, r2, s, m, e, e2)
3743 static void _test_IObjectSafety_set(unsigned line, IObjectSafety *safety, HRESULT result,
3744                                     HRESULT result2, DWORD set, DWORD mask, DWORD expected,
3745                                     DWORD expected2)
3746 {
3747     DWORD enabled, supported;
3748     HRESULT hr;
3749
3750     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL, set, mask);
3751     if (result == result2)
3752         ok_(__FILE__,line)(hr == result, "SetInterfaceSafetyOptions: expected %08x, returned %08x\n", result, hr );
3753     else
3754         ok_(__FILE__,line)(broken(hr == result) || hr == result2,
3755            "SetInterfaceSafetyOptions: expected %08x, got %08x\n", result2, hr );
3756
3757     supported = enabled = 0xCAFECAFE;
3758     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3759     ok(hr == S_OK, "ret %08x\n", hr );
3760     if (expected == expected2)
3761         ok_(__FILE__,line)(enabled == expected, "Expected %08x, got %08x\n", expected, enabled);
3762     else
3763         ok_(__FILE__,line)(broken(enabled == expected) || enabled == expected2,
3764            "Expected %08x, got %08x\n", expected2, enabled);
3765
3766     /* reset the safety options */
3767
3768     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
3769             INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER,
3770             0);
3771     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3772
3773     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3774     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3775     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
3776 }
3777
3778 #define test_IObjectSafety_common(s) _test_IObjectSafety_common(__LINE__,s)
3779 static void _test_IObjectSafety_common(unsigned line, IObjectSafety *safety)
3780 {
3781     DWORD enabled = 0, supported = 0;
3782     HRESULT hr;
3783
3784     /* get */
3785     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, NULL, &enabled);
3786     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
3787     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, NULL);
3788     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
3789
3790     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3791     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3792     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
3793        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
3794         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
3795              "got %08x\n", supported);
3796     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
3797
3798     /* set -- individual flags */
3799
3800     test_IObjectSafety_set(safety, S_OK, S_OK,
3801         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3802         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER);
3803
3804     test_IObjectSafety_set(safety, S_OK, S_OK,
3805         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA,
3806         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA);
3807
3808     test_IObjectSafety_set(safety, S_OK, S_OK,
3809         INTERFACE_USES_SECURITY_MANAGER, INTERFACE_USES_SECURITY_MANAGER,
3810         0, INTERFACE_USES_SECURITY_MANAGER /* msxml3 SP8+ */);
3811
3812     /* set INTERFACE_USES_DISPEX  */
3813
3814     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
3815         INTERFACE_USES_DISPEX, INTERFACE_USES_DISPEX,
3816         0, 0);
3817
3818     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
3819         INTERFACE_USES_DISPEX, 0,
3820         0, 0);
3821
3822     test_IObjectSafety_set(safety, S_OK, S_OK /* msxml3 SP8+ */,
3823         0, INTERFACE_USES_DISPEX,
3824         0, 0);
3825
3826     /* set option masking */
3827
3828     test_IObjectSafety_set(safety, S_OK, S_OK,
3829         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
3830         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3831         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3832         INTERFACESAFE_FOR_UNTRUSTED_CALLER);
3833
3834     test_IObjectSafety_set(safety, S_OK, S_OK,
3835         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
3836         INTERFACESAFE_FOR_UNTRUSTED_DATA,
3837         INTERFACESAFE_FOR_UNTRUSTED_DATA,
3838         INTERFACESAFE_FOR_UNTRUSTED_DATA);
3839
3840     test_IObjectSafety_set(safety, S_OK, S_OK,
3841         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
3842         INTERFACE_USES_SECURITY_MANAGER,
3843         0,
3844         0);
3845
3846     /* set -- inheriting previous settings */
3847
3848     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
3849                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3850                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER);
3851     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3852     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3853     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3854     ok_(__FILE__,line)(enabled == INTERFACESAFE_FOR_UNTRUSTED_CALLER, "Expected INTERFACESAFE_FOR_UNTRUSTED_CALLER got %08x\n", enabled);
3855     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
3856        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
3857         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
3858              "got %08x\n", supported);
3859
3860     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
3861                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA,
3862                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA);
3863     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3864     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3865     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3866     ok_(__FILE__,line)(broken(enabled == INTERFACESAFE_FOR_UNTRUSTED_DATA) ||
3867                        enabled == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA),
3868                        "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA) got %08x\n", enabled);
3869     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
3870        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
3871         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
3872              "got %08x\n", supported);
3873 }
3874
3875 static void test_IXMLDOMDocument2(void)
3876 {
3877     static const WCHAR emptyW[] = {0};
3878     IXMLDOMDocument2 *doc2, *dtddoc2;
3879     IXMLDOMDocument *doc;
3880     IXMLDOMParseError* err;
3881     IDispatchEx *dispex;
3882     VARIANT_BOOL b;
3883     VARIANT var;
3884     HRESULT r;
3885     LONG res;
3886
3887     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
3888
3889     doc = create_document(&IID_IXMLDOMDocument);
3890     dtddoc2 = create_document(&IID_IXMLDOMDocument2);
3891
3892     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
3893     ok( r == S_OK, "ret %08x\n", r );
3894     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
3895
3896     ole_expect(IXMLDOMDocument2_get_readyState(doc2, NULL), E_INVALIDARG);
3897     ole_check(IXMLDOMDocument2_get_readyState(doc2, &res));
3898     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
3899
3900     err = NULL;
3901     ole_expect(IXMLDOMDocument2_validate(doc2, NULL), S_FALSE);
3902     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
3903     ok(err != NULL, "expected a pointer\n");
3904     if (err)
3905     {
3906         res = 0;
3907         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3908         /* XML_E_NOTWF */
3909         ok(res == E_XML_NOTWF, "got %08x\n", res);
3910         IXMLDOMParseError_Release(err);
3911     }
3912
3913     r = IXMLDOMDocument2_loadXML( doc2, _bstr_(complete4A), &b );
3914     ok( r == S_OK, "loadXML failed\n");
3915     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3916
3917     ole_check(IXMLDOMDocument_get_readyState(doc, &res));
3918     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
3919
3920     err = NULL;
3921     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
3922     ok(err != NULL, "expected a pointer\n");
3923     if (err)
3924     {
3925         res = 0;
3926         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3927         /* XML_E_NODTD */
3928         ok(res == E_XML_NODTD, "got %08x\n", res);
3929         IXMLDOMParseError_Release(err);
3930     }
3931
3932     r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
3933     ok( r == S_OK, "ret %08x\n", r );
3934     if(r == S_OK)
3935     {
3936         IDispatchEx_Release(dispex);
3937     }
3938
3939     /* we will check if the variant got cleared */
3940     IXMLDOMDocument2_AddRef(doc2);
3941     EXPECT_REF(doc2, 3); /* doc, doc2, AddRef*/
3942
3943     V_VT(&var) = VT_UNKNOWN;
3944     V_UNKNOWN(&var) = (IUnknown *)doc2;
3945
3946     /* invalid calls */
3947     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
3948     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
3949     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
3950
3951     /* valid call */
3952     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
3953     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
3954     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
3955     V_VT(&var) = VT_R4;
3956
3957     /* the variant didn't get cleared*/
3958     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
3959
3960     /* setProperty tests */
3961     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
3962     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
3963     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
3964     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
3965     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
3966     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
3967
3968     V_VT(&var) = VT_BSTR;
3969     V_BSTR(&var) = SysAllocString(emptyW);
3970     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
3971     ok(r == S_OK, "got 0x%08x\n", r);
3972     VariantClear(&var);
3973
3974     V_VT(&var) = VT_I2;
3975     V_I2(&var) = 0;
3976     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
3977     ok(r == E_FAIL, "got 0x%08x\n", r);
3978
3979     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
3980     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
3981     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
3982     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
3983
3984     IXMLDOMDocument2_Release( doc2 );
3985     IXMLDOMDocument_Release( doc );
3986
3987     /* DTD validation */
3988     ole_check(IXMLDOMDocument2_put_validateOnParse(dtddoc2, VARIANT_FALSE));
3989     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML), &b));
3990     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3991     err = NULL;
3992     ole_check(IXMLDOMDocument2_validate(dtddoc2, &err));
3993     ok(err != NULL, "expected pointer\n");
3994     if (err)
3995     {
3996         res = 0;
3997         ole_expect(IXMLDOMParseError_get_errorCode(err, &res), S_FALSE);
3998         ok(res == 0, "got %08x\n", res);
3999         IXMLDOMParseError_Release(err);
4000     }
4001
4002     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0D), &b));
4003     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4004     err = NULL;
4005     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4006     ok(err != NULL, "expected pointer\n");
4007     if (err)
4008     {
4009         res = 0;
4010         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4011         /* XML_ELEMENT_UNDECLARED */
4012         todo_wine ok(res == 0xC00CE00D, "got %08x\n", res);
4013         IXMLDOMParseError_Release(err);
4014     }
4015
4016     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0E), &b));
4017     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4018     err = NULL;
4019     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4020     ok(err != NULL, "expected pointer\n");
4021     if (err)
4022     {
4023         res = 0;
4024         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4025         /* XML_ELEMENT_ID_NOT_FOUND */
4026         todo_wine ok(res == 0xC00CE00E, "got %08x\n", res);
4027         IXMLDOMParseError_Release(err);
4028     }
4029
4030     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_11), &b));
4031     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4032     err = NULL;
4033     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4034     ok(err != NULL, "expected pointer\n");
4035     if (err)
4036     {
4037         res = 0;
4038         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4039         /* XML_EMPTY_NOT_ALLOWED */
4040         todo_wine ok(res == 0xC00CE011, "got %08x\n", res);
4041         IXMLDOMParseError_Release(err);
4042     }
4043
4044     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_13), &b));
4045     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4046     err = NULL;
4047     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4048     ok(err != NULL, "expected pointer\n");
4049     if (err)
4050     {
4051         res = 0;
4052         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4053         /* XML_ROOT_NAME_MISMATCH */
4054         todo_wine ok(res == 0xC00CE013, "got %08x\n", res);
4055         IXMLDOMParseError_Release(err);
4056     }
4057
4058     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_14), &b));
4059     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4060     err = NULL;
4061     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4062     ok(err != NULL, "expected pointer\n");
4063     if (err)
4064     {
4065         res = 0;
4066         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4067         /* XML_INVALID_CONTENT */
4068         todo_wine ok(res == 0xC00CE014, "got %08x\n", res);
4069         IXMLDOMParseError_Release(err);
4070     }
4071
4072     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_15), &b));
4073     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4074     err = NULL;
4075     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4076     ok(err != NULL, "expected pointer\n");
4077     if (err)
4078     {
4079         res = 0;
4080         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4081         /* XML_ATTRIBUTE_NOT_DEFINED */
4082         todo_wine ok(res == 0xC00CE015, "got %08x\n", res);
4083         IXMLDOMParseError_Release(err);
4084     }
4085
4086     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_16), &b));
4087     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4088     err = NULL;
4089     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4090     ok(err != NULL, "expected pointer\n");
4091     if (err)
4092     {
4093         res = 0;
4094         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4095         /* XML_ATTRIBUTE_FIXED */
4096         todo_wine ok(res == 0xC00CE016, "got %08x\n", res);
4097         IXMLDOMParseError_Release(err);
4098     }
4099
4100     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_17), &b));
4101     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4102     err = NULL;
4103     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4104     ok(err != NULL, "expected pointer\n");
4105     if (err)
4106     {
4107         res = 0;
4108         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4109         /* XML_ATTRIBUTE_VALUE */
4110         todo_wine ok(res == 0xC00CE017, "got %08x\n", res);
4111         IXMLDOMParseError_Release(err);
4112     }
4113
4114     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_18), &b));
4115     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4116     err = NULL;
4117     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4118     ok(err != NULL, "expected pointer\n");
4119     if (err)
4120     {
4121         res = 0;
4122         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4123         /* XML_ILLEGAL_TEXT */
4124         todo_wine ok(res == 0xC00CE018, "got %08x\n", res);
4125         IXMLDOMParseError_Release(err);
4126     }
4127
4128     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_20), &b));
4129     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4130     err = NULL;
4131     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4132     ok(err != NULL, "expected pointer\n");
4133     if (err)
4134     {
4135         res = 0;
4136         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4137         /* XML_REQUIRED_ATTRIBUTE_MISSING */
4138         todo_wine ok(res == 0xC00CE020, "got %08x\n", res);
4139         IXMLDOMParseError_Release(err);
4140     }
4141
4142     IXMLDOMDocument2_Release( dtddoc2 );
4143     free_bstrs();
4144 }
4145
4146 #define helper_ole_check(expr) { \
4147     HRESULT r = expr; \
4148     ok_(__FILE__, line)(r == S_OK, "=> %i: " #expr " returned %08x\n", __LINE__, r); \
4149 }
4150
4151 #define helper_expect_list_and_release(list, expstr) { \
4152     char *str = list_to_string(list); \
4153     ok_(__FILE__, line)(strcmp(str, expstr)==0, "=> %i: Invalid node list: %s, expected %s\n", __LINE__, str, expstr); \
4154     if (list) IXMLDOMNodeList_Release(list); \
4155 }
4156
4157 #define helper_expect_bstr_and_release(bstr, str) { \
4158     ok_(__FILE__, line)(lstrcmpW(bstr, _bstr_(str)) == 0, \
4159        "=> %i: got %s\n", __LINE__, wine_dbgstr_w(bstr)); \
4160     SysFreeString(bstr); \
4161 }
4162
4163 #define check_ws_ignored(doc, str) _check_ws_ignored(__LINE__, doc, str)
4164 static inline void _check_ws_ignored(int line, IXMLDOMDocument2* doc, char const* str)
4165 {
4166     IXMLDOMNode *node1, *node2;
4167     IXMLDOMNodeList *list;
4168     BSTR bstr;
4169
4170     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4171     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
4172     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
4173     helper_ole_check(IXMLDOMNodeList_reset(list));
4174     helper_expect_list_and_release(list, "E1.E5.E1.E2.D1 E2.E5.E1.E2.D1");
4175
4176     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
4177     helper_expect_list_and_release(list, "T1.E1.E5.E1.E2.D1 E2.E1.E5.E1.E2.D1 E3.E1.E5.E1.E2.D1 T4.E1.E5.E1.E2.D1 E5.E1.E5.E1.E2.D1");
4178     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
4179     if (str)
4180     {
4181         helper_expect_bstr_and_release(bstr, str);
4182     }
4183     else
4184     {
4185         helper_expect_bstr_and_release(bstr, "This is a description.");
4186     }
4187     IXMLDOMNode_Release(node1);
4188
4189     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
4190     helper_expect_list_and_release(list, "T1.E2.E5.E1.E2.D1 E2.E2.E5.E1.E2.D1 T3.E2.E5.E1.E2.D1 E4.E2.E5.E1.E2.D1 T5.E2.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1 T7.E2.E5.E1.E2.D1");
4191     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
4192     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
4193     IXMLDOMNode_Release(node2);
4194 }
4195
4196 #define check_ws_preserved(doc, str) _check_ws_preserved(__LINE__, doc, str)
4197 static inline void _check_ws_preserved(int line, IXMLDOMDocument2* doc, char const* str)
4198 {
4199     IXMLDOMNode *node1, *node2;
4200     IXMLDOMNodeList *list;
4201     BSTR bstr;
4202
4203     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4204     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
4205     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
4206     helper_ole_check(IXMLDOMNodeList_reset(list));
4207     helper_expect_list_and_release(list, "E2.E10.E2.E2.D1 E4.E10.E2.E2.D1");
4208
4209     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
4210     helper_expect_list_and_release(list, "T1.E2.E10.E2.E2.D1 E2.E2.E10.E2.E2.D1 T3.E2.E10.E2.E2.D1 E4.E2.E10.E2.E2.D1 T5.E2.E10.E2.E2.D1 E6.E2.E10.E2.E2.D1 T7.E2.E10.E2.E2.D1");
4211     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
4212     if (str)
4213     {
4214         helper_expect_bstr_and_release(bstr, str);
4215     }
4216     else
4217     {
4218         helper_expect_bstr_and_release(bstr, "\n                This is a description. \n            ");
4219     }
4220     IXMLDOMNode_Release(node1);
4221
4222     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
4223     helper_expect_list_and_release(list, "T1.E4.E10.E2.E2.D1 E2.E4.E10.E2.E2.D1 T3.E4.E10.E2.E2.D1 E4.E4.E10.E2.E2.D1 T5.E4.E10.E2.E2.D1 E6.E4.E10.E2.E2.D1 T7.E4.E10.E2.E2.D1");
4224     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
4225     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
4226     IXMLDOMNode_Release(node2);
4227 }
4228
4229 static void test_preserve_charref(IXMLDOMDocument2 *doc, VARIANT_BOOL preserve)
4230 {
4231     static const WCHAR b1_p[] = {' ','T','e','x','t',' ','A',' ','e','n','d',' ',0};
4232     static const WCHAR b1_i[] = {'T','e','x','t',' ','A',' ','e','n','d',0};
4233     static const WCHAR b2_p[] = {'A','B',' ','C',' ',0};
4234     static const WCHAR b2_i[] = {'A','B',' ','C',0};
4235     IXMLDOMNodeList *list;
4236     IXMLDOMElement *root;
4237     IXMLDOMNode *node;
4238     const WCHAR *text;
4239     VARIANT_BOOL b;
4240     HRESULT hr;
4241     BSTR s;
4242
4243     hr = IXMLDOMDocument2_put_preserveWhiteSpace(doc, preserve);
4244     ok(hr == S_OK, "got 0x%08x\n", hr);
4245
4246     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(charrefsxml), &b);
4247     ok(hr == S_OK, "got 0x%08x\n", hr);
4248
4249     hr = IXMLDOMDocument2_get_documentElement(doc, &root);
4250     ok(hr == S_OK, "got 0x%08x\n", hr);
4251
4252     hr = IXMLDOMElement_get_childNodes(root, &list);
4253     ok(hr == S_OK, "got 0x%08x\n", hr);
4254     IXMLDOMElement_Release(root);
4255
4256     text = preserve == VARIANT_TRUE ? b1_p : b1_i;
4257     hr = IXMLDOMNodeList_get_item(list, 0, &node);
4258     ok(hr == S_OK, "got 0x%08x\n", hr);
4259     hr = IXMLDOMNode_get_text(node, &s);
4260     ok(hr == S_OK, "got 0x%08x\n", hr);
4261     ok(!lstrcmpW(s, text), "0x%x, got %s\n", preserve, wine_dbgstr_w(s));
4262     SysFreeString(s);
4263     IXMLDOMNode_Release(node);
4264
4265     text = preserve == VARIANT_TRUE ? b2_p : b2_i;
4266     hr = IXMLDOMNodeList_get_item(list, 1, &node);
4267     ok(hr == S_OK, "got 0x%08x\n", hr);
4268     hr = IXMLDOMNode_get_text(node, &s);
4269     ok(hr == S_OK, "got 0x%08x\n", hr);
4270     ok(!lstrcmpW(s, text), "0x%x, got %s\n", preserve, wine_dbgstr_w(s));
4271     SysFreeString(s);
4272     IXMLDOMNode_Release(node);
4273
4274     IXMLDOMNodeList_Release(list);
4275 }
4276
4277 static void test_whitespace(void)
4278 {
4279     IXMLDOMDocument2 *doc1, *doc2, *doc3, *doc4;
4280     IXMLDOMNodeList *list;
4281     IXMLDOMElement *root;
4282     VARIANT_BOOL b;
4283     HRESULT hr;
4284     LONG len;
4285
4286     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
4287     doc1 = create_document(&IID_IXMLDOMDocument2);
4288     doc2 = create_document(&IID_IXMLDOMDocument2);
4289
4290     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_TRUE));
4291     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4292     ok(b == VARIANT_FALSE, "expected false\n");
4293     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4294     ok(b == VARIANT_TRUE, "expected true\n");
4295
4296     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4297     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4298     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4299     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4300
4301     /* switch to XPath */
4302     ole_check(IXMLDOMDocument2_setProperty(doc1, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4303     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4304
4305     check_ws_ignored(doc1, NULL);
4306     check_ws_preserved(doc2, NULL);
4307
4308     /* new instances copy the property */
4309     ole_check(IXMLDOMDocument2_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**) &doc3));
4310     ole_check(IXMLDOMDocument2_QueryInterface(doc2, &IID_IXMLDOMDocument2, (void**) &doc4));
4311
4312     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4313     ok(b == VARIANT_FALSE, "expected false\n");
4314     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4315     ok(b == VARIANT_TRUE, "expected true\n");
4316
4317     check_ws_ignored(doc3, NULL);
4318     check_ws_preserved(doc4, NULL);
4319
4320     /* setting after loading xml affects trimming of leading/trailing ws only */
4321     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_TRUE));
4322     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_FALSE));
4323
4324     /* the trailing "\n            " isn't there, because it was ws-only node */
4325     check_ws_ignored(doc1, "\n                This is a description. ");
4326     check_ws_preserved(doc2, "This is a description.");
4327
4328     /* it takes effect on reload */
4329     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4330     ok(b == VARIANT_TRUE, "expected true\n");
4331     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4332     ok(b == VARIANT_FALSE, "expected false\n");
4333
4334     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4335     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4336     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4337     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4338
4339     check_ws_preserved(doc1, NULL);
4340     check_ws_ignored(doc2, NULL);
4341
4342     /* other instances follow suit */
4343     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4344     ok(b == VARIANT_TRUE, "expected true\n");
4345     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4346     ok(b == VARIANT_FALSE, "expected false\n");
4347
4348     check_ws_preserved(doc3, NULL);
4349     check_ws_ignored(doc4, NULL);
4350
4351     IXMLDOMDocument2_Release(doc2);
4352     IXMLDOMDocument2_Release(doc3);
4353     IXMLDOMDocument2_Release(doc4);
4354
4355     /* text with char references */
4356     test_preserve_charref(doc1, VARIANT_TRUE);
4357     test_preserve_charref(doc1, VARIANT_FALSE);
4358
4359     /* formatting whitespaces */
4360     hr = IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_FALSE);
4361     ok(hr == S_OK, "got 0x%08x\n", hr);
4362
4363     hr = IXMLDOMDocument2_loadXML(doc1, _bstr_(complete7), &b);
4364     ok(hr == S_OK, "got 0x%08x\n", hr);
4365     ok(b == VARIANT_TRUE, "for %x\n", b);
4366
4367     hr = IXMLDOMDocument2_get_documentElement(doc1, &root);
4368     ok(hr == S_OK, "got 0x%08x\n", hr);
4369     hr = IXMLDOMElement_get_childNodes(root, &list);
4370     ok(hr == S_OK, "got 0x%08x\n", hr);
4371     len = 0;
4372     hr = IXMLDOMNodeList_get_length(list, &len);
4373     ok(hr == S_OK, "got 0x%08x\n", hr);
4374     ok(len == 3, "got %d\n", len);
4375     IXMLDOMNodeList_Release(list);
4376     IXMLDOMElement_Release(root);
4377
4378     IXMLDOMDocument2_Release(doc1);
4379
4380     free_bstrs();
4381 }
4382
4383 typedef struct {
4384     const GUID *clsid;
4385     const char *name;
4386     const char *ns;
4387     HRESULT hr;
4388 } selection_ns_t;
4389
4390 /* supposed to be tested with szExampleXML */
4391 static const selection_ns_t selection_ns_data[] = {
4392     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4393     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4394     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4395     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4396
4397     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4398     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4399     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4400     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4401
4402     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4403     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4404     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4405     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4406
4407     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4408     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4409     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4410     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4411
4412     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4413     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4414     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4415     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4416
4417     { NULL }
4418 };
4419
4420 typedef struct {
4421     const char *query;
4422     const char *list;
4423 } xpath_test_t;
4424
4425 static const xpath_test_t xpath_test[] = {
4426     { "*/a", "E1.E1.E2.D1 E1.E2.E2.D1 E1.E4.E2.D1" },
4427     { "*/b", "E2.E1.E2.D1 E2.E2.E2.D1 E2.E4.E2.D1" },
4428     { "*/c", "E3.E1.E2.D1 E3.E2.E2.D1" },
4429     { "*/d", "E4.E1.E2.D1 E4.E2.E2.D1 E4.E4.E2.D1" },
4430     { "//a", "E1.E1.E2.D1 E1.E2.E2.D1 E1.E4.E2.D1" },
4431     { "//b", "E2.E1.E2.D1 E2.E2.E2.D1 E2.E4.E2.D1" },
4432     { "//c", "E3.E1.E2.D1 E3.E2.E2.D1" },
4433     { "//d", "E4.E1.E2.D1 E4.E2.E2.D1 E4.E4.E2.D1" },
4434     { "//c[@type]", "E3.E2.E2.D1" },
4435     { "//c[@type]/ancestor::node()[1]", "E2.E2.D1" },
4436     { "//c[@type]/ancestor-or-self::node()[1]", "E3.E2.E2.D1" },
4437     { "//c[@type]/attribute::node()[1]", "A'type'.E3.E2.E2.D1" },
4438     { "//c[@type]/child::node()[1]", "T1.E3.E2.E2.D1"  },
4439     { "//c[@type]/descendant::node()[1]", "T1.E3.E2.E2.D1" },
4440     { "//c[@type]/descendant-or-self::node()[1]", "E3.E2.E2.D1" },
4441     { "//c[@type]/following::node()[1]", "E4.E2.E2.D1" },
4442     { "//c[@type]/following-sibling::node()[1]", "E4.E2.E2.D1" },
4443     { "//c[@type]/parent::node()[1]", "E2.E2.D1" },
4444     { "//c[@type]/preceding::node()[1]", "T1.E2.E2.E2.D1" },
4445     { "//c[@type]/self::node()[1]", "E3.E2.E2.D1" },
4446     { "child::*", "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1" },
4447     { "child::node()", "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1" },
4448     { "child::text()", "" },
4449     { "child::*/..", "E2.D1" },
4450     { "child::*//@*/..", "E2.E5.E1.E2.D1 E3.E2.E2.D1" },
4451     { "self::node()", "E2.D1" },
4452     { "ancestor::node()", "D1" },
4453     { "elem[c][last()]/a", "E1.E2.E2.D1"},
4454     { "ancestor-or-self::node()[1]", "E2.D1" },
4455     { "((//a)[1])[last()]", "E1.E1.E2.D1" },
4456     { NULL }
4457 };
4458
4459 static void test_XPath(void)
4460 {
4461     const selection_ns_t *ptr = selection_ns_data;
4462     const xpath_test_t *xptest = xpath_test;
4463     VARIANT var;
4464     VARIANT_BOOL b;
4465     IXMLDOMDocument2 *doc;
4466     IXMLDOMDocument *doc2;
4467     IXMLDOMNode *rootNode;
4468     IXMLDOMNode *elem1Node;
4469     IXMLDOMNode *node;
4470     IXMLDOMNodeList *list;
4471     IXMLDOMElement *elem;
4472     IXMLDOMAttribute *attr;
4473     DOMNodeType type;
4474     HRESULT hr;
4475     LONG len;
4476     BSTR str;
4477
4478     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
4479     doc = create_document(&IID_IXMLDOMDocument2);
4480
4481     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4482     EXPECT_HR(hr, S_OK);
4483     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4484
4485     /* switch to XPath */
4486     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4487
4488     /* some simple queries*/
4489     EXPECT_REF(doc, 1);
4490     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4491     EXPECT_HR(hr, S_OK);
4492     EXPECT_REF(doc, 1);
4493     EXPECT_LIST_LEN(list, 1);
4494
4495     EXPECT_REF(list, 1);
4496     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4497     EXPECT_HR(hr, S_OK);
4498     EXPECT_REF(list, 1);
4499     EXPECT_REF(rootNode, 1);
4500
4501     hr = IXMLDOMNodeList_reset(list);
4502     EXPECT_HR(hr, S_OK);
4503     expect_list_and_release(list, "E2.D1");
4504
4505     /* peform xpath tests */
4506     for ( ; xptest->query ; xptest++ )
4507     {
4508         char *str;
4509
4510         hr = IXMLDOMNode_selectNodes(rootNode, _bstr_(xptest->query), &list);
4511         ok(hr == S_OK, "query evaluation failed for query=%s\n", xptest->query);
4512
4513         if (hr != S_OK)
4514             continue;
4515
4516         str = list_to_string(list);
4517
4518         ok(strcmp(str, xptest->list)==0, "query=%s, invalid node list: %s, expected %s\n",
4519             xptest->query, str, xptest->list);
4520
4521         if (list)
4522             IXMLDOMNodeList_Release(list);
4523     }
4524
4525 if (0)
4526 {
4527     /* namespace:: axis test is disabled until namespace definitions
4528        are supported as attribute nodes, currently it's another node type */
4529     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("/root/namespace::*"), &list);
4530     EXPECT_HR(hr, S_OK);
4531     len = -1;
4532     hr = IXMLDOMNodeList_get_length(list, &len);
4533     EXPECT_HR(hr, S_OK);
4534     ok(len == 2, "got %d\n", len);
4535
4536     hr = IXMLDOMNodeList_nextNode(list, &node);
4537     EXPECT_HR(hr, S_OK);
4538     type = NODE_INVALID;
4539     hr = IXMLDOMNode_get_nodeType(node, &type);
4540     EXPECT_HR(hr, S_OK);
4541     ok(type == NODE_ATTRIBUTE, "got %d\n", type);
4542     IXMLDOMNode_Release(node);
4543
4544     IXMLDOMNodeList_Release(list);
4545 }
4546
4547     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//c"), &list));
4548     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
4549
4550     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//c[@type]"), &list));
4551     expect_list_and_release(list, "E3.E2.E2.D1");
4552
4553     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
4554     /* using get_item for query results advances the position */
4555     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
4556     expect_node(node, "E2.E2.D1");
4557     IXMLDOMNode_Release(node);
4558     ole_check(IXMLDOMNodeList_nextNode(list, &node));
4559     expect_node(node, "E4.E2.D1");
4560     IXMLDOMNode_Release(node);
4561     ole_check(IXMLDOMNodeList_reset(list));
4562     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
4563
4564     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
4565     expect_list_and_release(list, "E2.D1");
4566
4567     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
4568     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
4569     ole_check(IXMLDOMNodeList_reset(list));
4570     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
4571
4572     /* select an attribute */
4573     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
4574     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
4575
4576     /* would evaluate to a number */
4577     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
4578     /* would evaluate to a boolean */
4579     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
4580     /* would evaluate to a string */
4581     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
4582
4583     /* no results */
4584     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
4585     expect_list_and_release(list, "");
4586     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("elem//c"), &list));
4587     expect_list_and_release(list, "");
4588     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem[4]"), &list));
4589     expect_list_and_release(list, "");
4590     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[0]"), &list));
4591     expect_list_and_release(list, "");
4592
4593     /* foo undeclared in document node */
4594     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4595     /* undeclared in <root> node */
4596     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
4597     /* undeclared in <elem> node */
4598     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
4599     /* but this trick can be used */
4600     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
4601     expect_list_and_release(list, "E3.E4.E2.D1");
4602
4603     /* it has to be declared in SelectionNamespaces */
4604     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4605         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
4606
4607     /* now the namespace can be used */
4608     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list));
4609     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4610     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
4611     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4612     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
4613     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4614     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
4615     expect_list_and_release(list, "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1");
4616
4617     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
4618     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4619         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
4620
4621     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4622
4623     VariantInit(&var);
4624     ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
4625     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
4626     if (V_VT(&var) == VT_BSTR)
4627         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
4628
4629     /* extra attributes - same thing*/
4630     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4631         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
4632     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4633
4634     IXMLDOMNode_Release(rootNode);
4635     IXMLDOMNode_Release(elem1Node);
4636
4637     /* alter document with already built list */
4638     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4639     EXPECT_HR(hr, S_OK);
4640     EXPECT_LIST_LEN(list, 1);
4641
4642     hr = IXMLDOMDocument2_get_lastChild(doc, &rootNode);
4643     EXPECT_HR(hr, S_OK);
4644     EXPECT_REF(rootNode, 1);
4645     EXPECT_REF(doc, 1);
4646
4647     hr = IXMLDOMDocument2_removeChild(doc, rootNode, NULL);
4648     EXPECT_HR(hr, S_OK);
4649     IXMLDOMNode_Release(rootNode);
4650
4651     EXPECT_LIST_LEN(list, 1);
4652
4653     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4654     EXPECT_HR(hr, S_OK);
4655     EXPECT_REF(rootNode, 1);
4656
4657     IXMLDOMNodeList_Release(list);
4658
4659     hr = IXMLDOMNode_get_nodeName(rootNode, &str);
4660     EXPECT_HR(hr, S_OK);
4661     ok(!lstrcmpW(str, _bstr_("root")), "got %s\n", wine_dbgstr_w(str));
4662     SysFreeString(str);
4663     IXMLDOMNode_Release(rootNode);
4664
4665     /* alter node from list and get it another time */
4666     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4667     EXPECT_HR(hr, S_OK);
4668     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4669
4670     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4671     EXPECT_HR(hr, S_OK);
4672     EXPECT_LIST_LEN(list, 1);
4673
4674     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4675     EXPECT_HR(hr, S_OK);
4676
4677     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
4678     EXPECT_HR(hr, S_OK);
4679
4680     V_VT(&var) = VT_I2;
4681     V_I2(&var) = 1;
4682     hr = IXMLDOMElement_setAttribute(elem, _bstr_("attrtest"), var);
4683     EXPECT_HR(hr, S_OK);
4684     IXMLDOMElement_Release(elem);
4685     IXMLDOMNode_Release(rootNode);
4686
4687     /* now check attribute to be present */
4688     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4689     EXPECT_HR(hr, S_OK);
4690
4691     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
4692     EXPECT_HR(hr, S_OK);
4693
4694     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
4695     EXPECT_HR(hr, S_OK);
4696     IXMLDOMAttribute_Release(attr);
4697
4698     IXMLDOMElement_Release(elem);
4699     IXMLDOMNode_Release(rootNode);
4700
4701     /* and now check for attribute in original document */
4702     hr = IXMLDOMDocument2_get_documentElement(doc, &elem);
4703     EXPECT_HR(hr, S_OK);
4704
4705     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
4706     EXPECT_HR(hr, S_OK);
4707     IXMLDOMAttribute_Release(attr);
4708
4709     IXMLDOMElement_Release(elem);
4710
4711     /* attach node from list to another document */
4712     doc2 = create_document(&IID_IXMLDOMDocument);
4713
4714     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4715     EXPECT_HR(hr, S_OK);
4716     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4717
4718     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4719     EXPECT_HR(hr, S_OK);
4720     EXPECT_LIST_LEN(list, 1);
4721
4722     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4723     EXPECT_HR(hr, S_OK);
4724     EXPECT_REF(rootNode, 1);
4725
4726     hr = IXMLDOMDocument_appendChild(doc2, rootNode, NULL);
4727     EXPECT_HR(hr, S_OK);
4728     EXPECT_REF(rootNode, 1);
4729     EXPECT_REF(doc2, 1);
4730     EXPECT_REF(list, 1);
4731
4732     EXPECT_LIST_LEN(list, 1);
4733
4734     IXMLDOMNode_Release(rootNode);
4735     IXMLDOMNodeList_Release(list);
4736     IXMLDOMDocument_Release(doc2);
4737     IXMLDOMDocument2_Release(doc);
4738
4739     while (ptr->clsid)
4740     {
4741         if (is_clsid_supported(ptr->clsid, &IID_IXMLDOMDocument2))
4742         {
4743             hr = CoCreateInstance(ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
4744             ok(hr == S_OK, "got 0x%08x\n", hr);
4745         }
4746         else
4747         {
4748             ptr++;
4749             continue;
4750         }
4751
4752         hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4753         EXPECT_HR(hr, S_OK);
4754         ok(b == VARIANT_TRUE, "failed to load, %s\n", ptr->name);
4755
4756         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath"));
4757         EXPECT_HR(hr, S_OK);
4758
4759         V_VT(&var) = VT_BSTR;
4760         V_BSTR(&var) = _bstr_(ptr->ns);
4761
4762         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), var);
4763         ok(hr == ptr->hr, "got 0x%08x, for %s, %s\n", hr, ptr->name, ptr->ns);
4764
4765         V_VT(&var) = VT_EMPTY;
4766         hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var);
4767         EXPECT_HR(hr, S_OK);
4768         ok(V_VT(&var) == VT_BSTR, "got wrong property type %d\n", V_VT(&var));
4769         ok(!lstrcmpW(V_BSTR(&var), _bstr_(ptr->ns)), "got wrong value %s\n", wine_dbgstr_w(V_BSTR(&var)));
4770         VariantClear(&var);
4771
4772         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list);
4773         EXPECT_HR(hr, S_OK);
4774         if (hr == S_OK)
4775             expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4776
4777         IXMLDOMDocument2_Release(doc);
4778         ptr++;
4779         free_bstrs();
4780     }
4781
4782     free_bstrs();
4783 }
4784
4785 static void test_cloneNode(void )
4786 {
4787     IXMLDOMDocument *doc, *doc2;
4788     VARIANT_BOOL b;
4789     IXMLDOMNodeList *pList;
4790     IXMLDOMNamedNodeMap *mapAttr;
4791     LONG length, length1;
4792     LONG attr_cnt, attr_cnt1;
4793     IXMLDOMNode *node, *attr;
4794     IXMLDOMNode *node_clone;
4795     IXMLDOMNode *node_first;
4796     HRESULT hr;
4797
4798     doc = create_document(&IID_IXMLDOMDocument);
4799
4800     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b));
4801     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4802
4803     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc/pr"), &node);
4804     ok( hr == S_OK, "ret %08x\n", hr );
4805     ok( node != NULL, "node %p\n", node );
4806
4807     /* Check invalid parameter */
4808     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
4809     ok( hr == E_INVALIDARG, "ret %08x\n", hr );
4810
4811     /* All Children */
4812     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
4813     ok( hr == S_OK, "ret %08x\n", hr );
4814     ok( node_clone != NULL, "node %p\n", node );
4815
4816     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
4817     ok( hr == S_OK, "ret %08x\n", hr );
4818     hr = IXMLDOMNode_get_ownerDocument(node_clone, &doc2);
4819     ok( hr == S_OK, "ret %08x\n", hr );
4820     IXMLDOMDocument_Release(doc2);
4821     IXMLDOMNode_Release(node_first);
4822
4823     hr = IXMLDOMNode_get_childNodes(node, &pList);
4824     ok( hr == S_OK, "ret %08x\n", hr );
4825     length = 0;
4826     hr = IXMLDOMNodeList_get_length(pList, &length);
4827     ok( hr == S_OK, "ret %08x\n", hr );
4828     ok(length == 1, "got %d\n", length);
4829     IXMLDOMNodeList_Release(pList);
4830
4831     hr = IXMLDOMNode_get_attributes(node, &mapAttr);
4832     ok( hr == S_OK, "ret %08x\n", hr );
4833     attr_cnt = 0;
4834     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt);
4835     ok( hr == S_OK, "ret %08x\n", hr );
4836     ok(attr_cnt == 3, "got %d\n", attr_cnt);
4837     IXMLDOMNamedNodeMap_Release(mapAttr);
4838
4839     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
4840     ok( hr == S_OK, "ret %08x\n", hr );
4841     length1 = 0;
4842     hr = IXMLDOMNodeList_get_length(pList, &length1);
4843     ok(length1 == 1, "got %d\n", length1);
4844     ok( hr == S_OK, "ret %08x\n", hr );
4845     IXMLDOMNodeList_Release(pList);
4846
4847     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
4848     ok( hr == S_OK, "ret %08x\n", hr );
4849     attr_cnt1 = 0;
4850     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
4851     ok( hr == S_OK, "ret %08x\n", hr );
4852     ok(attr_cnt1 == 3, "got %d\n", attr_cnt1);
4853     /* now really get some attributes from cloned element */
4854     attr = NULL;
4855     hr = IXMLDOMNamedNodeMap_getNamedItem(mapAttr, _bstr_("id"), &attr);
4856     ok(hr == S_OK, "ret %08x\n", hr);
4857     IXMLDOMNode_Release(attr);
4858     IXMLDOMNamedNodeMap_Release(mapAttr);
4859
4860     ok(length == length1, "wrong Child count (%d, %d)\n", length, length1);
4861     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
4862     IXMLDOMNode_Release(node_clone);
4863
4864     /* No Children */
4865     hr = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
4866     ok( hr == S_OK, "ret %08x\n", hr );
4867     ok( node_clone != NULL, "node %p\n", node );
4868
4869     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
4870     ok(hr == S_FALSE, "ret %08x\n", hr );
4871
4872     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
4873     ok(hr == S_OK, "ret %08x\n", hr );
4874     hr = IXMLDOMNodeList_get_length(pList, &length1);
4875     ok(hr == S_OK, "ret %08x\n", hr );
4876     ok( length1 == 0, "Length should be 0 (%d)\n", length1);
4877     IXMLDOMNodeList_Release(pList);
4878
4879     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
4880     ok(hr == S_OK, "ret %08x\n", hr );
4881     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
4882     ok(hr == S_OK, "ret %08x\n", hr );
4883     ok(attr_cnt1 == 3, "Attribute count should be 3 (%d)\n", attr_cnt1);
4884     IXMLDOMNamedNodeMap_Release(mapAttr);
4885
4886     ok(length != length1, "wrong Child count (%d, %d)\n", length, length1);
4887     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
4888     IXMLDOMNode_Release(node_clone);
4889
4890     IXMLDOMNode_Release(node);
4891     IXMLDOMDocument_Release(doc);
4892     free_bstrs();
4893 }
4894
4895 static void test_xmlTypes(void)
4896 {
4897     IXMLDOMDocument *doc;
4898     IXMLDOMElement *pRoot;
4899     HRESULT hr;
4900     IXMLDOMComment *pComment;
4901     IXMLDOMElement *pElement;
4902     IXMLDOMAttribute *pAttribute;
4903     IXMLDOMNamedNodeMap *pAttribs;
4904     IXMLDOMCDATASection *pCDataSec;
4905     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
4906     IXMLDOMDocumentFragment *pDocFrag = NULL;
4907     IXMLDOMEntityReference *pEntityRef = NULL;
4908     BSTR str;
4909     IXMLDOMNode *pNextChild;
4910     VARIANT v;
4911     LONG len = 0;
4912
4913     doc = create_document(&IID_IXMLDOMDocument);
4914
4915     pNextChild = (void*)0xdeadbeef;
4916     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
4917     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4918
4919     pNextChild = (void*)0xdeadbeef;
4920     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
4921     ok(hr == S_FALSE, "ret %08x\n", hr );
4922     ok(pNextChild == NULL, "pDocChild not NULL\n");
4923
4924     /* test previous Sibling */
4925     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
4926     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4927
4928     pNextChild = (void*)0xdeadbeef;
4929     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
4930     ok(hr == S_FALSE, "ret %08x\n", hr );
4931     ok(pNextChild == NULL, "pNextChild not NULL\n");
4932
4933     /* test get_dataType */
4934     V_VT(&v) = VT_EMPTY;
4935     hr = IXMLDOMDocument_get_dataType(doc, &v);
4936     ok(hr == S_FALSE, "ret %08x\n", hr );
4937     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
4938     VariantClear(&v);
4939
4940     /* test implementation */
4941     hr = IXMLDOMDocument_get_implementation(doc, NULL);
4942     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4943
4944     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
4945     ok(hr == S_OK, "ret %08x\n", hr );
4946     if(hr == S_OK)
4947     {
4948         VARIANT_BOOL hasFeature = VARIANT_TRUE;
4949         BSTR sEmpty = SysAllocStringLen(NULL, 0);
4950
4951         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
4952         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4953
4954         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
4955         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4956
4957         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
4958         ok(hr == S_OK, "ret %08x\n", hr );
4959         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4960
4961         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
4962         ok(hr == S_OK, "ret %08x\n", hr );
4963         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
4964
4965         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
4966         ok(hr == S_OK, "ret %08x\n", hr );
4967         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
4968
4969         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
4970         ok(hr == S_OK, "ret %08x\n", hr );
4971         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4972
4973         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
4974         ok(hr == S_OK, "ret %08x\n", hr );
4975         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4976
4977         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
4978         ok(hr == S_OK, "ret %08x\n", hr );
4979         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4980
4981         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
4982         ok(hr == S_OK, "ret %08x\n", hr );
4983         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4984
4985         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
4986         ok(hr == S_OK, "ret %08x\n", hr );
4987         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4988
4989         SysFreeString(sEmpty);
4990         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
4991     }
4992
4993     pRoot = (IXMLDOMElement*)0x1;
4994     hr = IXMLDOMDocument_createElement(doc, NULL, &pRoot);
4995     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4996     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
4997
4998     pRoot = (IXMLDOMElement*)0x1;
4999     hr = IXMLDOMDocument_createElement(doc, _bstr_(""), &pRoot);
5000     ok(hr == E_FAIL, "ret %08x\n", hr );
5001     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
5002
5003     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
5004     ok(hr == S_OK, "ret %08x\n", hr );
5005     if(hr == S_OK)
5006     {
5007         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
5008         ok(hr == S_OK, "ret %08x\n", hr );
5009         if(hr == S_OK)
5010         {
5011             /* Comment */
5012             str = SysAllocString(szComment);
5013             hr = IXMLDOMDocument_createComment(doc, str, &pComment);
5014             SysFreeString(str);
5015             ok(hr == S_OK, "ret %08x\n", hr );
5016             if(hr == S_OK)
5017             {
5018                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
5019                 ok(hr == S_OK, "ret %08x\n", hr );
5020
5021                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
5022                 ok(hr == S_OK, "ret %08x\n", hr );
5023                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
5024                 SysFreeString(str);
5025
5026                 hr = IXMLDOMComment_get_xml(pComment, &str);
5027                 ok(hr == S_OK, "ret %08x\n", hr );
5028                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
5029                 SysFreeString(str);
5030
5031                 /* put data Tests */
5032                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
5033                 ok(hr == S_OK, "ret %08x\n", hr );
5034
5035                 /* get data Tests */
5036                 hr = IXMLDOMComment_get_data(pComment, &str);
5037                 ok(hr == S_OK, "ret %08x\n", hr );
5038                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
5039                 SysFreeString(str);
5040
5041                 /* Confirm XML text is good */
5042                 hr = IXMLDOMComment_get_xml(pComment, &str);
5043                 ok(hr == S_OK, "ret %08x\n", hr );
5044                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
5045                 SysFreeString(str);
5046
5047                 /* Confirm we get the put_data Text back */
5048                 hr = IXMLDOMComment_get_text(pComment, &str);
5049                 ok(hr == S_OK, "ret %08x\n", hr );
5050                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
5051                 SysFreeString(str);
5052
5053                 /* test length property */
5054                 hr = IXMLDOMComment_get_length(pComment, &len);
5055                 ok(hr == S_OK, "ret %08x\n", hr );
5056                 ok(len == 21, "expected 21 got %d\n", len);
5057
5058                 /* test substringData */
5059                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
5060                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5061
5062                 /* test substringData - Invalid offset */
5063                 str = (BSTR)&szElement;
5064                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
5065                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5066                 ok( str == NULL, "incorrect string\n");
5067
5068                 /* test substringData - Invalid offset */
5069                 str = (BSTR)&szElement;
5070                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
5071                 ok(hr == S_FALSE, "ret %08x\n", hr );
5072                 ok( str == NULL, "incorrect string\n");
5073
5074                 /* test substringData - Invalid size */
5075                 str = (BSTR)&szElement;
5076                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
5077                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5078                 ok( str == NULL, "incorrect string\n");
5079
5080                 /* test substringData - Invalid size */
5081                 str = (BSTR)&szElement;
5082                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
5083                 ok(hr == S_FALSE, "ret %08x\n", hr );
5084                 ok( str == NULL, "incorrect string\n");
5085
5086                 /* test substringData - Start of string */
5087                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
5088                 ok(hr == S_OK, "ret %08x\n", hr );
5089                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
5090                 SysFreeString(str);
5091
5092                 /* test substringData - Middle of string */
5093                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
5094                 ok(hr == S_OK, "ret %08x\n", hr );
5095                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
5096                 SysFreeString(str);
5097
5098                 /* test substringData - End of string */
5099                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
5100                 ok(hr == S_OK, "ret %08x\n", hr );
5101                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
5102                 SysFreeString(str);
5103
5104                 /* test appendData */
5105                 hr = IXMLDOMComment_appendData(pComment, NULL);
5106                 ok(hr == S_OK, "ret %08x\n", hr );
5107
5108                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
5109                 ok(hr == S_OK, "ret %08x\n", hr );
5110
5111                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
5112                 ok(hr == S_OK, "ret %08x\n", hr );
5113
5114                 hr = IXMLDOMComment_get_text(pComment, &str);
5115                 ok(hr == S_OK, "ret %08x\n", hr );
5116                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5117                 SysFreeString(str);
5118
5119                 /* test insertData */
5120                 str = SysAllocStringLen(NULL, 0);
5121                 hr = IXMLDOMComment_insertData(pComment, -1, str);
5122                 ok(hr == S_OK, "ret %08x\n", hr );
5123
5124                 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
5125                 ok(hr == S_OK, "ret %08x\n", hr );
5126
5127                 hr = IXMLDOMComment_insertData(pComment, 1000, str);
5128                 ok(hr == S_OK, "ret %08x\n", hr );
5129
5130                 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
5131                 ok(hr == S_OK, "ret %08x\n", hr );
5132
5133                 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
5134                 ok(hr == S_OK, "ret %08x\n", hr );
5135
5136                 hr = IXMLDOMComment_insertData(pComment, 0, str);
5137                 ok(hr == S_OK, "ret %08x\n", hr );
5138                 SysFreeString(str);
5139
5140                 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
5141                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5142
5143                 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
5144                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5145
5146                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
5147                 ok(hr == S_OK, "ret %08x\n", hr );
5148
5149                 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
5150                 ok(hr == S_OK, "ret %08x\n", hr );
5151
5152                 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
5153                 ok(hr == S_OK, "ret %08x\n", hr );
5154
5155                 hr = IXMLDOMComment_get_text(pComment, &str);
5156                 ok(hr == S_OK, "ret %08x\n", hr );
5157                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5158                 SysFreeString(str);
5159
5160                 /* delete data */
5161                 /* invalid arguments */
5162                 hr = IXMLDOMComment_deleteData(pComment, -1, 1);
5163                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5164
5165                 hr = IXMLDOMComment_deleteData(pComment, 0, 0);
5166                 ok(hr == S_OK, "ret %08x\n", hr );
5167
5168                 hr = IXMLDOMComment_deleteData(pComment, 0, -1);
5169                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5170
5171                 hr = IXMLDOMComment_get_length(pComment, &len);
5172                 ok(hr == S_OK, "ret %08x\n", hr );
5173                 ok(len == 43, "expected 43 got %d\n", len);
5174
5175                 hr = IXMLDOMComment_deleteData(pComment, len, 1);
5176                 ok(hr == S_OK, "ret %08x\n", hr );
5177
5178                 hr = IXMLDOMComment_deleteData(pComment, len+1, 1);
5179                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5180
5181                 /* delete from start */
5182                 hr = IXMLDOMComment_deleteData(pComment, 0, 5);
5183                 ok(hr == S_OK, "ret %08x\n", hr );
5184
5185                 hr = IXMLDOMComment_get_length(pComment, &len);
5186                 ok(hr == S_OK, "ret %08x\n", hr );
5187                 ok(len == 38, "expected 38 got %d\n", len);
5188
5189                 hr = IXMLDOMComment_get_text(pComment, &str);
5190                 ok(hr == S_OK, "ret %08x\n", hr );
5191                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5192                 SysFreeString(str);
5193
5194                 /* delete from end */
5195                 hr = IXMLDOMComment_deleteData(pComment, 35, 3);
5196                 ok(hr == S_OK, "ret %08x\n", hr );
5197
5198                 hr = IXMLDOMComment_get_length(pComment, &len);
5199                 ok(hr == S_OK, "ret %08x\n", hr );
5200                 ok(len == 35, "expected 35 got %d\n", len);
5201
5202                 hr = IXMLDOMComment_get_text(pComment, &str);
5203                 ok(hr == S_OK, "ret %08x\n", hr );
5204                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5205                 SysFreeString(str);
5206
5207                 /* delete from inside */
5208                 hr = IXMLDOMComment_deleteData(pComment, 1, 33);
5209                 ok(hr == S_OK, "ret %08x\n", hr );
5210
5211                 hr = IXMLDOMComment_get_length(pComment, &len);
5212                 ok(hr == S_OK, "ret %08x\n", hr );
5213                 ok(len == 2, "expected 2 got %d\n", len);
5214
5215                 hr = IXMLDOMComment_get_text(pComment, &str);
5216                 ok(hr == S_OK, "ret %08x\n", hr );
5217                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5218                 SysFreeString(str);
5219
5220                 /* delete whole data ... */
5221                 hr = IXMLDOMComment_get_length(pComment, &len);
5222                 ok(hr == S_OK, "ret %08x\n", hr );
5223
5224                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5225                 ok(hr == S_OK, "ret %08x\n", hr );
5226                 /* ... and try again with empty string */
5227                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5228                 ok(hr == S_OK, "ret %08x\n", hr );
5229
5230                 /* ::replaceData() */
5231                 V_VT(&v) = VT_BSTR;
5232                 V_BSTR(&v) = SysAllocString(szstr1);
5233                 hr = IXMLDOMComment_put_nodeValue(pComment, v);
5234                 ok(hr == S_OK, "ret %08x\n", hr );
5235                 VariantClear(&v);
5236
5237                 hr = IXMLDOMComment_replaceData(pComment, 6, 0, NULL);
5238                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5239                 hr = IXMLDOMComment_get_text(pComment, &str);
5240                 ok(hr == S_OK, "ret %08x\n", hr );
5241                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5242                 SysFreeString(str);
5243
5244                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, NULL);
5245                 ok(hr == S_OK, "ret %08x\n", hr );
5246                 hr = IXMLDOMComment_get_text(pComment, &str);
5247                 ok(hr == S_OK, "ret %08x\n", hr );
5248                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5249                 SysFreeString(str);
5250
5251                 /* NULL pointer means delete */
5252                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, NULL);
5253                 ok(hr == S_OK, "ret %08x\n", hr );
5254                 hr = IXMLDOMComment_get_text(pComment, &str);
5255                 ok(hr == S_OK, "ret %08x\n", hr );
5256                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5257                 SysFreeString(str);
5258
5259                 /* empty string means delete */
5260                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_(""));
5261                 ok(hr == S_OK, "ret %08x\n", hr );
5262                 hr = IXMLDOMComment_get_text(pComment, &str);
5263                 ok(hr == S_OK, "ret %08x\n", hr );
5264                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5265                 SysFreeString(str);
5266
5267                 /* zero count means insert */
5268                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, _bstr_("a"));
5269                 ok(hr == S_OK, "ret %08x\n", hr );
5270                 hr = IXMLDOMComment_get_text(pComment, &str);
5271                 ok(hr == S_OK, "ret %08x\n", hr );
5272                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5273                 SysFreeString(str);
5274
5275                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, NULL);
5276                 ok(hr == S_OK, "ret %08x\n", hr );
5277
5278                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("m"));
5279                 ok(hr == S_OK, "ret %08x\n", hr );
5280                 hr = IXMLDOMComment_get_text(pComment, &str);
5281                 ok(hr == S_OK, "ret %08x\n", hr );
5282                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5283                 SysFreeString(str);
5284
5285                 /* nonempty string, count greater than its length */
5286                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, _bstr_("a1.2"));
5287                 ok(hr == S_OK, "ret %08x\n", hr );
5288                 hr = IXMLDOMComment_get_text(pComment, &str);
5289                 ok(hr == S_OK, "ret %08x\n", hr );
5290                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5291                 SysFreeString(str);
5292
5293                 /* nonempty string, count less than its length */
5294                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_("wine"));
5295                 ok(hr == S_OK, "ret %08x\n", hr );
5296                 hr = IXMLDOMComment_get_text(pComment, &str);
5297                 ok(hr == S_OK, "ret %08x\n", hr );
5298                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5299                 SysFreeString(str);
5300
5301                 IXMLDOMComment_Release(pComment);
5302             }
5303
5304             /* Element */
5305             str = SysAllocString(szElement);
5306             hr = IXMLDOMDocument_createElement(doc, str, &pElement);
5307             SysFreeString(str);
5308             ok(hr == S_OK, "ret %08x\n", hr );
5309             if(hr == S_OK)
5310             {
5311                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5312                 ok(hr == S_OK, "ret %08x\n", hr );
5313
5314                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
5315                 ok(hr == S_OK, "ret %08x\n", hr );
5316                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
5317                 SysFreeString(str);
5318
5319                 hr = IXMLDOMElement_get_xml(pElement, &str);
5320                 ok(hr == S_OK, "ret %08x\n", hr );
5321                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
5322                 SysFreeString(str);
5323
5324                 /* Attribute */
5325                 pAttribute = (IXMLDOMAttribute*)0x1;
5326                 hr = IXMLDOMDocument_createAttribute(doc, NULL, &pAttribute);
5327                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5328                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5329
5330                 pAttribute = (IXMLDOMAttribute*)0x1;
5331                 hr = IXMLDOMDocument_createAttribute(doc, _bstr_(""), &pAttribute);
5332                 ok(hr == E_FAIL, "ret %08x\n", hr );
5333                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5334
5335                 str = SysAllocString(szAttribute);
5336                 hr = IXMLDOMDocument_createAttribute(doc, str, &pAttribute);
5337                 SysFreeString(str);
5338                 ok(hr == S_OK, "ret %08x\n", hr );
5339                 if(hr == S_OK)
5340                 {
5341                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
5342
5343                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, NULL);
5344                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5345
5346                     pNextChild = (IXMLDOMNode *)0x1;
5347                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, &pNextChild);
5348                     ok(hr == S_FALSE, "ret %08x\n", hr );
5349                     ok(pNextChild == NULL, "pNextChild not NULL\n");
5350
5351                     /* test Previous Sibling*/
5352                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, NULL);
5353                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5354
5355                     pNextChild = (IXMLDOMNode *)0x1;
5356                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, &pNextChild);
5357                     ok(hr == S_FALSE, "ret %08x\n", hr );
5358                     ok(pNextChild == NULL, "pNextChild not NULL\n");
5359
5360                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttribute, &pNewChild);
5361                     ok(hr == E_FAIL, "ret %08x\n", hr );
5362                     ok(pNewChild == NULL, "pNewChild not NULL\n");
5363
5364                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
5365                     ok(hr == S_OK, "ret %08x\n", hr );
5366                     if ( hr == S_OK )
5367                     {
5368                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttribute, NULL );
5369                         ok(hr == S_OK, "ret %08x\n", hr );
5370
5371                         IXMLDOMNamedNodeMap_Release(pAttribs);
5372                     }
5373
5374                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5375                     ok(hr == S_OK, "ret %08x\n", hr );
5376                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
5377                     SysFreeString(str);
5378
5379                     /* test nodeName */
5380                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5381                     ok(hr == S_OK, "ret %08x\n", hr );
5382                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
5383                     SysFreeString(str);
5384
5385                     /* test name property */
5386                     hr = IXMLDOMAttribute_get_name(pAttribute, &str);
5387                     ok(hr == S_OK, "ret %08x\n", hr );
5388                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
5389                     SysFreeString(str);
5390
5391                     hr = IXMLDOMAttribute_get_xml(pAttribute, &str);
5392                     ok(hr == S_OK, "ret %08x\n", hr );
5393                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
5394                     SysFreeString(str);
5395
5396                     IXMLDOMAttribute_Release(pAttribute);
5397
5398                     /* Check Element again with the Add Attribute*/
5399                     hr = IXMLDOMElement_get_xml(pElement, &str);
5400                     ok(hr == S_OK, "ret %08x\n", hr );
5401                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
5402                     SysFreeString(str);
5403                 }
5404
5405                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
5406                 ok(hr == S_OK, "ret %08x\n", hr );
5407
5408                 hr = IXMLDOMElement_get_xml(pElement, &str);
5409                 ok(hr == S_OK, "ret %08x\n", hr );
5410                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
5411                 SysFreeString(str);
5412
5413                 /* Test for reversible escaping */
5414                 str = SysAllocString( szStrangeChars );
5415                 hr = IXMLDOMElement_put_text(pElement, str);
5416                 ok(hr == S_OK, "ret %08x\n", hr );
5417                 SysFreeString( str );
5418
5419                 hr = IXMLDOMElement_get_xml(pElement, &str);
5420                 ok(hr == S_OK, "ret %08x\n", hr );
5421                 ok( !lstrcmpW( str, szElementXML4 ), "incorrect element xml\n");
5422                 SysFreeString(str);
5423
5424                 hr = IXMLDOMElement_get_text(pElement, &str);
5425                 ok(hr == S_OK, "ret %08x\n", hr );
5426                 ok( !lstrcmpW( str, szStrangeChars ), "incorrect element text\n");
5427                 SysFreeString(str);
5428
5429                 IXMLDOMElement_Release(pElement);
5430             }
5431
5432             /* CData Section */
5433             str = SysAllocString(szCData);
5434             hr = IXMLDOMDocument_createCDATASection(doc, str, NULL);
5435             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5436
5437             hr = IXMLDOMDocument_createCDATASection(doc, str, &pCDataSec);
5438             SysFreeString(str);
5439             ok(hr == S_OK, "ret %08x\n", hr );
5440             if(hr == S_OK)
5441             {
5442                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
5443                 VARIANT var;
5444
5445                 VariantInit(&var);
5446
5447                 hr = IXMLDOMCDATASection_QueryInterface(pCDataSec, &IID_IXMLDOMElement, (void**)&pElement);
5448                 ok(hr == E_NOINTERFACE, "ret %08x\n", hr);
5449
5450                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
5451                 ok(hr == S_OK, "ret %08x\n", hr );
5452
5453                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
5454                 ok(hr == S_OK, "ret %08x\n", hr );
5455                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
5456                 SysFreeString(str);
5457
5458                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5459                 ok(hr == S_OK, "ret %08x\n", hr );
5460                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
5461                 SysFreeString(str);
5462
5463                 /* test lastChild */
5464                 pNextChild = (IXMLDOMNode*)0x1;
5465                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
5466                 ok(hr == S_FALSE, "ret %08x\n", hr );
5467                 ok(pNextChild == NULL, "pNextChild not NULL\n");
5468
5469                 /* put data Tests */
5470                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
5471                 ok(hr == S_OK, "ret %08x\n", hr );
5472
5473                 /* Confirm XML text is good */
5474                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5475                 ok(hr == S_OK, "ret %08x\n", hr );
5476                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
5477                 SysFreeString(str);
5478
5479                 /* Confirm we get the put_data Text back */
5480                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5481                 ok(hr == S_OK, "ret %08x\n", hr );
5482                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5483                 SysFreeString(str);
5484
5485                 /* test length property */
5486                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5487                 ok(hr == S_OK, "ret %08x\n", hr );
5488                 ok(len == 21, "expected 21 got %d\n", len);
5489
5490                 /* test get data */
5491                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
5492                 ok(hr == S_OK, "ret %08x\n", hr );
5493                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5494                 SysFreeString(str);
5495
5496                 /* test substringData */
5497                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
5498                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5499
5500                 /* test substringData - Invalid offset */
5501                 str = (BSTR)&szElement;
5502                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
5503                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5504                 ok( str == NULL, "incorrect string\n");
5505
5506                 /* test substringData - Invalid offset */
5507                 str = (BSTR)&szElement;
5508                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
5509                 ok(hr == S_FALSE, "ret %08x\n", hr );
5510                 ok( str == NULL, "incorrect string\n");
5511
5512                 /* test substringData - Invalid size */
5513                 str = (BSTR)&szElement;
5514                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
5515                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5516                 ok( str == NULL, "incorrect string\n");
5517
5518                 /* test substringData - Invalid size */
5519                 str = (BSTR)&szElement;
5520                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
5521                 ok(hr == S_FALSE, "ret %08x\n", hr );
5522                 ok( str == NULL, "incorrect string\n");
5523
5524                 /* test substringData - Start of string */
5525                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
5526                 ok(hr == S_OK, "ret %08x\n", hr );
5527                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
5528                 SysFreeString(str);
5529
5530                 /* test substringData - Middle of string */
5531                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
5532                 ok(hr == S_OK, "ret %08x\n", hr );
5533                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
5534                 SysFreeString(str);
5535
5536                 /* test substringData - End of string */
5537                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
5538                 ok(hr == S_OK, "ret %08x\n", hr );
5539                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
5540                 SysFreeString(str);
5541
5542                 /* test appendData */
5543                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
5544                 ok(hr == S_OK, "ret %08x\n", hr );
5545
5546                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
5547                 ok(hr == S_OK, "ret %08x\n", hr );
5548
5549                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
5550                 ok(hr == S_OK, "ret %08x\n", hr );
5551
5552                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5553                 ok(hr == S_OK, "ret %08x\n", hr );
5554                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5555                 SysFreeString(str);
5556
5557                 /* test insertData */
5558                 str = SysAllocStringLen(NULL, 0);
5559                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
5560                 ok(hr == S_OK, "ret %08x\n", hr );
5561
5562                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
5563                 ok(hr == S_OK, "ret %08x\n", hr );
5564
5565                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
5566                 ok(hr == S_OK, "ret %08x\n", hr );
5567
5568                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
5569                 ok(hr == S_OK, "ret %08x\n", hr );
5570
5571                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
5572                 ok(hr == S_OK, "ret %08x\n", hr );
5573
5574                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
5575                 ok(hr == S_OK, "ret %08x\n", hr );
5576                 SysFreeString(str);
5577
5578                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
5579                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5580
5581                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
5582                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5583
5584                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
5585                 ok(hr == S_OK, "ret %08x\n", hr );
5586
5587                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
5588                 ok(hr == S_OK, "ret %08x\n", hr );
5589
5590                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
5591                 ok(hr == S_OK, "ret %08x\n", hr );
5592
5593                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5594                 ok(hr == S_OK, "ret %08x\n", hr );
5595                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5596                 SysFreeString(str);
5597
5598                 /* delete data */
5599                 /* invalid arguments */
5600                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, -1, 1);
5601                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5602
5603                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 0);
5604                 ok(hr == S_OK, "ret %08x\n", hr );
5605
5606                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, -1);
5607                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5608
5609                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5610                 ok(hr == S_OK, "ret %08x\n", hr );
5611                 ok(len == 43, "expected 43 got %d\n", len);
5612
5613                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len, 1);
5614                 ok(hr == S_OK, "ret %08x\n", hr );
5615
5616                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len+1, 1);
5617                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5618
5619                 /* delete from start */
5620                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 5);
5621                 ok(hr == S_OK, "ret %08x\n", hr );
5622
5623                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5624                 ok(hr == S_OK, "ret %08x\n", hr );
5625                 ok(len == 38, "expected 38 got %d\n", len);
5626
5627                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5628                 ok(hr == S_OK, "ret %08x\n", hr );
5629                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5630                 SysFreeString(str);
5631
5632                 /* delete from end */
5633                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 35, 3);
5634                 ok(hr == S_OK, "ret %08x\n", hr );
5635
5636                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5637                 ok(hr == S_OK, "ret %08x\n", hr );
5638                 ok(len == 35, "expected 35 got %d\n", len);
5639
5640                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5641                 ok(hr == S_OK, "ret %08x\n", hr );
5642                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5643                 SysFreeString(str);
5644
5645                 /* delete from inside */
5646                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 1, 33);
5647                 ok(hr == S_OK, "ret %08x\n", hr );
5648
5649                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5650                 ok(hr == S_OK, "ret %08x\n", hr );
5651                 ok(len == 2, "expected 2 got %d\n", len);
5652
5653                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5654                 ok(hr == S_OK, "ret %08x\n", hr );
5655                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5656                 SysFreeString(str);
5657
5658                 /* delete whole data ... */
5659                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5660                 ok(hr == S_OK, "ret %08x\n", hr );
5661
5662                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
5663                 ok(hr == S_OK, "ret %08x\n", hr );
5664
5665                 /* ... and try again with empty string */
5666                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
5667                 ok(hr == S_OK, "ret %08x\n", hr );
5668
5669                 /* ::replaceData() */
5670                 V_VT(&v) = VT_BSTR;
5671                 V_BSTR(&v) = SysAllocString(szstr1);
5672                 hr = IXMLDOMCDATASection_put_nodeValue(pCDataSec, v);
5673                 ok(hr == S_OK, "ret %08x\n", hr );
5674                 VariantClear(&v);
5675
5676                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 6, 0, NULL);
5677                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5678                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5679                 ok(hr == S_OK, "ret %08x\n", hr );
5680                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5681                 SysFreeString(str);
5682
5683                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, NULL);
5684                 ok(hr == S_OK, "ret %08x\n", hr );
5685                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5686                 ok(hr == S_OK, "ret %08x\n", hr );
5687                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5688                 SysFreeString(str);
5689
5690                 /* NULL pointer means delete */
5691                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, NULL);
5692                 ok(hr == S_OK, "ret %08x\n", hr );
5693                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5694                 ok(hr == S_OK, "ret %08x\n", hr );
5695                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5696                 SysFreeString(str);
5697
5698                 /* empty string means delete */
5699                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_(""));
5700                 ok(hr == S_OK, "ret %08x\n", hr );
5701                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5702                 ok(hr == S_OK, "ret %08x\n", hr );
5703                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5704                 SysFreeString(str);
5705
5706                 /* zero count means insert */
5707                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, _bstr_("a"));
5708                 ok(hr == S_OK, "ret %08x\n", hr );
5709                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5710                 ok(hr == S_OK, "ret %08x\n", hr );
5711                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5712                 SysFreeString(str);
5713
5714                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, NULL);
5715                 ok(hr == S_OK, "ret %08x\n", hr );
5716
5717                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("m"));
5718                 ok(hr == S_OK, "ret %08x\n", hr );
5719                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5720                 ok(hr == S_OK, "ret %08x\n", hr );
5721                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5722                 SysFreeString(str);
5723
5724                 /* nonempty string, count greater than its length */
5725                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, _bstr_("a1.2"));
5726                 ok(hr == S_OK, "ret %08x\n", hr );
5727                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5728                 ok(hr == S_OK, "ret %08x\n", hr );
5729                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5730                 SysFreeString(str);
5731
5732                 /* nonempty string, count less than its length */
5733                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_("wine"));
5734                 ok(hr == S_OK, "ret %08x\n", hr );
5735                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5736                 ok(hr == S_OK, "ret %08x\n", hr );
5737                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5738                 SysFreeString(str);
5739
5740                 IXMLDOMCDATASection_Release(pCDataSec);
5741             }
5742
5743             /* Document Fragments */
5744             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
5745             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5746
5747             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
5748             ok(hr == S_OK, "ret %08x\n", hr );
5749             if(hr == S_OK)
5750             {
5751                 IXMLDOMNode *node;
5752
5753                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, NULL);
5754                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5755
5756                 node = (IXMLDOMNode *)0x1;
5757                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, &node);
5758                 ok(hr == S_FALSE, "ret %08x\n", hr );
5759                 ok(node == NULL, "expected NULL, got %p\n", node);
5760
5761                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
5762                 ok(hr == S_OK, "ret %08x\n", hr );
5763
5764                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
5765                 ok(hr == S_OK, "ret %08x\n", hr );
5766                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
5767                 SysFreeString(str);
5768
5769                 /* test next Sibling*/
5770                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
5771                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5772
5773                 node = (IXMLDOMNode *)0x1;
5774                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &node);
5775                 ok(hr == S_FALSE, "ret %08x\n", hr );
5776                 ok(node == NULL, "next sibling not NULL\n");
5777
5778                 /* test Previous Sibling*/
5779                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
5780                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5781
5782                 node = (IXMLDOMNode *)0x1;
5783                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &node);
5784                 ok(hr == S_FALSE, "ret %08x\n", hr );
5785                 ok(node == NULL, "previous sibling not NULL\n");
5786
5787                 IXMLDOMDocumentFragment_Release(pDocFrag);
5788             }
5789
5790             /* Entity References */
5791             hr = IXMLDOMDocument_createEntityReference(doc, NULL, &pEntityRef);
5792             ok(hr == E_FAIL, "ret %08x\n", hr );
5793             hr = IXMLDOMDocument_createEntityReference(doc, _bstr_(""), &pEntityRef);
5794             ok(hr == E_FAIL, "ret %08x\n", hr );
5795
5796             str = SysAllocString(szEntityRef);
5797             hr = IXMLDOMDocument_createEntityReference(doc, str, NULL);
5798             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5799
5800             hr = IXMLDOMDocument_createEntityReference(doc, str, &pEntityRef);
5801             SysFreeString(str);
5802             ok(hr == S_OK, "ret %08x\n", hr );
5803             if(hr == S_OK)
5804             {
5805                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
5806                 ok(hr == S_OK, "ret %08x\n", hr );
5807
5808                 /* test get_xml*/
5809                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
5810                 ok(hr == S_OK, "ret %08x\n", hr );
5811                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
5812                 SysFreeString(str);
5813
5814                 IXMLDOMEntityReference_Release(pEntityRef);
5815             }
5816
5817             IXMLDOMElement_Release( pRoot );
5818         }
5819     }
5820
5821     IXMLDOMDocument_Release(doc);
5822
5823     free_bstrs();
5824 }
5825
5826 typedef struct {
5827     const char *name;
5828     const char *type;
5829     HRESULT hr;
5830 } put_datatype_t;
5831
5832 /* Type test for elements only. Name passed into put_dataType is case-insensitive.
5833    So many of the names have been changed to reflect this. */
5834 static put_datatype_t put_datatype_data[] = {
5835     { "test_inval",      "abcdefg",     E_FAIL },
5836     { "test_bool",       "Boolean",     S_OK },
5837     { "test_string",     "String",      S_OK },
5838     { "test_number",     "number",      S_OK },
5839     { "test_int",        "InT",         S_OK },
5840     { "test_fixed",      "fixed.14.4",  S_OK },
5841     { "test_datetime",   "DateTime",    S_OK },
5842     { "test_datetimetz", "DateTime.tz", S_OK },
5843     { "test_date",       "Date",        S_OK },
5844     { "test_time",       "Time",        S_OK },
5845     { "test_timetz",     "Time.tz",     S_OK },
5846     { "test_I1",         "I1",          S_OK },
5847     { "test_I2",         "I2",          S_OK },
5848     { "test_I4",         "I4",          S_OK },
5849     { "test_UI1",        "UI1",         S_OK },
5850     { "test_UI2",        "UI2",         S_OK },
5851     { "test_UI4",        "UI4",         S_OK },
5852     { "test_r4",         "r4",          S_OK },
5853     { "test_r8",         "r8",          S_OK },
5854     { "test_float",      "float",       S_OK },
5855     { "test_uuid",       "UuId",        S_OK },
5856     { "test_binhex",     "bin.hex",     S_OK },
5857     { "test_binbase64",  "bin.base64",  S_OK },
5858     { NULL }
5859 };
5860
5861 typedef struct {
5862     DOMNodeType type;
5863     HRESULT hr;
5864 } put_datatype_notype_t;
5865
5866 static put_datatype_notype_t put_dt_notype[] = {
5867     { NODE_PROCESSING_INSTRUCTION, E_FAIL },
5868     { NODE_DOCUMENT_FRAGMENT,      E_FAIL },
5869     { NODE_ENTITY_REFERENCE,       E_FAIL },
5870     { NODE_CDATA_SECTION,          E_FAIL },
5871     { NODE_COMMENT,                E_FAIL },
5872     { NODE_INVALID }
5873 };
5874
5875 static void test_put_dataType( void )
5876 {
5877     const put_datatype_notype_t *ptr2 = put_dt_notype;
5878     const put_datatype_t *ptr = put_datatype_data;
5879     IXMLDOMElement *root, *element;
5880     BSTR nameW, type1W, type2W;
5881     IXMLDOMDocument *doc;
5882     HRESULT hr;
5883
5884     doc = create_document(&IID_IXMLDOMDocument);
5885
5886     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), NULL);
5887     EXPECT_HR(hr, E_INVALIDARG);
5888
5889     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
5890     EXPECT_HR(hr, S_OK);
5891
5892     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
5893     EXPECT_HR(hr, S_OK);
5894
5895     hr = IXMLDOMElement_put_dataType(root, NULL);
5896     EXPECT_HR(hr, E_INVALIDARG);
5897
5898     while (ptr->name)
5899     {
5900         hr = IXMLDOMDocument_createElement(doc, _bstr_(ptr->name), &element);
5901         EXPECT_HR(hr, S_OK);
5902         if(hr == S_OK)
5903         {
5904             hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
5905             EXPECT_HR(hr, S_OK);
5906
5907             hr = IXMLDOMElement_put_dataType(element, _bstr_(ptr->type));
5908             ok(hr == ptr->hr, "failed for %s:%s, 0x%08x\n", ptr->name, ptr->type, ptr->hr);
5909
5910             IXMLDOMElement_Release(element);
5911         }
5912         ptr++;
5913     }
5914
5915     /* check changing types */
5916     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &element);
5917     EXPECT_HR(hr, S_OK);
5918
5919     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
5920     EXPECT_HR(hr, S_OK);
5921
5922     hr = IXMLDOMElement_put_dataType(element, _bstr_("DateTime.tz"));
5923     EXPECT_HR(hr, S_OK);
5924
5925     hr = IXMLDOMElement_put_dataType(element, _bstr_("string"));
5926     EXPECT_HR(hr, S_OK);
5927
5928     IXMLDOMElement_Release(element);
5929
5930     /* try to set type for node without a type */
5931     nameW  = _bstr_("testname");
5932     type1W = _bstr_("string");
5933     type2W = _bstr_("number");
5934     while (ptr2->type != NODE_INVALID)
5935     {
5936         IXMLDOMNode *node;
5937         VARIANT type;
5938
5939         V_VT(&type) = VT_I2;
5940         V_I2(&type) = ptr2->type;
5941
5942         hr = IXMLDOMDocument_createNode(doc, type, nameW, NULL, &node);
5943         EXPECT_HR(hr, S_OK);
5944         if(hr == S_OK)
5945         {
5946             hr = IXMLDOMElement_appendChild(root, node, NULL);
5947             EXPECT_HR(hr, S_OK);
5948
5949             hr = IXMLDOMNode_put_dataType(node, NULL);
5950             EXPECT_HR(hr, E_INVALIDARG);
5951
5952             hr = IXMLDOMNode_put_dataType(node, type1W);
5953             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
5954             hr = IXMLDOMNode_put_dataType(node, type2W);
5955             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
5956
5957             IXMLDOMNode_Release(node);
5958         }
5959         ptr2++;
5960     }
5961
5962     IXMLDOMElement_Release(root);
5963     IXMLDOMDocument_Release(doc);
5964     free_bstrs();
5965 }
5966
5967 static void test_save(void)
5968 {
5969     IXMLDOMDocument *doc, *doc2;
5970     IXMLDOMElement *root;
5971     BSTR sOrig, sNew, filename;
5972     char buffer[100];
5973     IStream *stream;
5974     HGLOBAL global;
5975     VARIANT_BOOL b;
5976     DWORD read = 0;
5977     VARIANT dest;
5978     HANDLE hfile;
5979     HRESULT hr;
5980     char *ptr;
5981
5982     doc = create_document(&IID_IXMLDOMDocument);
5983     doc2 = create_document(&IID_IXMLDOMDocument);
5984
5985     /* save to IXMLDOMDocument */
5986     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
5987     EXPECT_HR(hr, S_OK);
5988
5989     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
5990     EXPECT_HR(hr, S_OK);
5991
5992     V_VT(&dest) = VT_UNKNOWN;
5993     V_UNKNOWN(&dest) = (IUnknown*)doc2;
5994
5995     hr = IXMLDOMDocument_save(doc, dest);
5996     EXPECT_HR(hr, S_OK);
5997
5998     hr = IXMLDOMDocument_get_xml(doc, &sOrig);
5999     EXPECT_HR(hr, S_OK);
6000
6001     hr = IXMLDOMDocument_get_xml(doc2, &sNew);
6002     EXPECT_HR(hr, S_OK);
6003
6004     ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as original\n");
6005
6006     SysFreeString(sOrig);
6007     SysFreeString(sNew);
6008
6009     IXMLDOMElement_Release(root);
6010     IXMLDOMDocument_Release(doc2);
6011
6012     /* save to path */
6013     V_VT(&dest) = VT_BSTR;
6014     V_BSTR(&dest) = _bstr_("test.xml");
6015
6016     hr = IXMLDOMDocument_save(doc, dest);
6017     EXPECT_HR(hr, S_OK);
6018
6019     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
6020     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
6021     if(hfile == INVALID_HANDLE_VALUE) return;
6022
6023     ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
6024     ok(read != 0, "could not read file\n");
6025     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
6026
6027     CloseHandle(hfile);
6028     DeleteFileA("test.xml");
6029
6030     /* save to path VT_BSTR | VT_BYREF */
6031     filename = _bstr_("test.xml");
6032     V_VT(&dest) = VT_BSTR | VT_BYREF;
6033     V_BSTRREF(&dest) = &filename;
6034
6035     hr = IXMLDOMDocument_save(doc, dest);
6036     EXPECT_HR(hr, S_OK);
6037
6038     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
6039     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
6040     if(hfile == INVALID_HANDLE_VALUE) return;
6041
6042     if (hfile != INVALID_HANDLE_VALUE)
6043     {
6044        ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
6045        ok(read != 0, "could not read file\n");
6046        ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
6047
6048        CloseHandle(hfile);
6049        DeleteFileA("test.xml");
6050     }
6051
6052     /* save to stream */
6053     V_VT(&dest) = VT_UNKNOWN;
6054     V_UNKNOWN(&dest) = (IUnknown*)&savestream;
6055
6056     hr = IXMLDOMDocument_save(doc, dest);
6057     EXPECT_HR(hr, S_OK);
6058
6059     /* loaded data contains xml declaration */
6060     hr = IXMLDOMDocument_loadXML(doc, _bstr_(win1252xml), &b);
6061     EXPECT_HR(hr, S_OK);
6062
6063     CreateStreamOnHGlobal(NULL, TRUE, &stream);
6064     V_VT(&dest) = VT_UNKNOWN;
6065     V_UNKNOWN(&dest) = (IUnknown*)stream;
6066     hr = IXMLDOMDocument_save(doc, dest);
6067     EXPECT_HR(hr, S_OK);
6068
6069     hr = GetHGlobalFromStream(stream, &global);
6070     EXPECT_HR(hr, S_OK);
6071     ptr = GlobalLock(global);
6072     ok(!memcmp(ptr, win1252decl, strlen(win1252decl)), "got wrong xml declaration\n");
6073     GlobalUnlock(global);
6074     IStream_Release(stream);
6075
6076     /* loaded data without xml declaration */
6077     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<a/>"), &b);
6078     EXPECT_HR(hr, S_OK);
6079
6080     CreateStreamOnHGlobal(NULL, TRUE, &stream);
6081     V_VT(&dest) = VT_UNKNOWN;
6082     V_UNKNOWN(&dest) = (IUnknown*)stream;
6083     hr = IXMLDOMDocument_save(doc, dest);
6084     EXPECT_HR(hr, S_OK);
6085
6086     hr = GetHGlobalFromStream(stream, &global);
6087     EXPECT_HR(hr, S_OK);
6088     ptr = GlobalLock(global);
6089     ok(ptr[0] == '<' && ptr[1] != '?', "got wrong start tag %c%c\n", ptr[0], ptr[1]);
6090     GlobalUnlock(global);
6091     IStream_Release(stream);
6092
6093     IXMLDOMDocument_Release(doc);
6094     free_bstrs();
6095 }
6096
6097 static void test_testTransforms(void)
6098 {
6099     IXMLDOMDocument *doc, *docSS;
6100     IXMLDOMNode *pNode;
6101     VARIANT_BOOL bSucc;
6102     HRESULT hr;
6103
6104     doc = create_document(&IID_IXMLDOMDocument);
6105     docSS = create_document(&IID_IXMLDOMDocument);
6106
6107     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
6108     ok(hr == S_OK, "ret %08x\n", hr );
6109
6110     hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
6111     ok(hr == S_OK, "ret %08x\n", hr );
6112
6113     hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (void**)&pNode );
6114     ok(hr == S_OK, "ret %08x\n", hr );
6115     if(hr == S_OK)
6116     {
6117         BSTR bOut;
6118
6119         hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
6120         ok(hr == S_OK, "ret %08x\n", hr );
6121         if(hr == S_OK)
6122         {
6123             ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "Stylesheet output not correct\n");
6124             SysFreeString(bOut);
6125         }
6126
6127         IXMLDOMNode_Release(pNode);
6128     }
6129
6130     IXMLDOMDocument_Release(docSS);
6131     IXMLDOMDocument_Release(doc);
6132
6133     free_bstrs();
6134 }
6135
6136 struct namespaces_change_t {
6137     const CLSID *clsid;
6138     const char *name;
6139 };
6140
6141 static const struct namespaces_change_t namespaces_change_test_data[] = {
6142     { &CLSID_DOMDocument,   "CLSID_DOMDocument"   },
6143     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2"  },
6144     { &CLSID_DOMDocument26, "CLSID_DOMDocument26" },
6145     { &CLSID_DOMDocument30, "CLSID_DOMDocument30" },
6146     { &CLSID_DOMDocument40, "CLSID_DOMDocument40" },
6147     { &CLSID_DOMDocument60, "CLSID_DOMDocument60" },
6148     { 0 }
6149 };
6150
6151 static void test_namespaces_change(void)
6152 {
6153     const struct namespaces_change_t *class_ptr = namespaces_change_test_data;
6154
6155     while (class_ptr->clsid)
6156     {
6157         IXMLDOMDocument *doc = NULL;
6158         IXMLDOMElement *elem = NULL;
6159         IXMLDOMNode *node = NULL;
6160
6161         VARIANT var;
6162         HRESULT hr;
6163         BSTR str;
6164
6165         if (!is_clsid_supported(class_ptr->clsid, &IID_IXMLDOMDocument))
6166         {
6167             class_ptr++;
6168             continue;
6169         }
6170
6171         hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
6172                               &IID_IXMLDOMDocument, (void**)&doc);
6173         ok(hr == S_OK, "got 0x%08x\n", hr);
6174
6175         V_VT(&var) = VT_I2;
6176         V_I2(&var) = NODE_ELEMENT;
6177
6178         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("ns:elem"), _bstr_("ns/uri"), &node);
6179         EXPECT_HR(hr, S_OK);
6180
6181         hr = IXMLDOMDocument_appendChild(doc, node, NULL);
6182         EXPECT_HR(hr, S_OK);
6183
6184         hr = IXMLDOMDocument_get_documentElement(doc, &elem);
6185         EXPECT_HR(hr, S_OK);
6186
6187         /* try same prefix, different uri */
6188         V_VT(&var) = VT_BSTR;
6189         V_BSTR(&var) = _bstr_("ns/uri2");
6190
6191         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
6192         EXPECT_HR(hr, E_INVALIDARG);
6193
6194         /* try same prefix and uri */
6195         V_VT(&var) = VT_BSTR;
6196         V_BSTR(&var) = _bstr_("ns/uri");
6197
6198         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
6199         EXPECT_HR(hr, S_OK);
6200
6201         hr = IXMLDOMElement_get_xml(elem, &str);
6202         EXPECT_HR(hr, S_OK);
6203         ok(!lstrcmpW(str, _bstr_("<ns:elem xmlns:ns=\"ns/uri\"/>")), "got element %s for %s\n",
6204            wine_dbgstr_w(str), class_ptr->name);
6205         SysFreeString(str);
6206
6207         IXMLDOMElement_Release(elem);
6208         IXMLDOMDocument_Release(doc);
6209
6210         free_bstrs();
6211
6212         class_ptr++;
6213     }
6214 }
6215
6216 static void test_namespaces_basic(void)
6217 {
6218     static const CHAR namespaces_xmlA[] =
6219         "<?xml version=\"1.0\"?>\n"
6220         "<XMI xmi.version=\"1.1\" xmlns:Model=\"http://omg.org/mof.Model/1.3\">"
6221         "  <XMI.content>"
6222         "    <Model:Package name=\"WinePackage\" Model:name2=\"name2 attr\" />"
6223         "  </XMI.content>"
6224         "</XMI>";
6225
6226     IXMLDOMDocument *doc;
6227     IXMLDOMElement *elem;
6228     IXMLDOMNode *node;
6229
6230     VARIANT_BOOL b;
6231     HRESULT hr;
6232     BSTR str;
6233
6234     doc = create_document(&IID_IXMLDOMDocument);
6235
6236     hr = IXMLDOMDocument_loadXML(doc, _bstr_(namespaces_xmlA), &b);
6237     EXPECT_HR(hr, S_OK);
6238     ok(b == VARIANT_TRUE, "got %d\n", b);
6239
6240     str = (BSTR)0xdeadbeef;
6241     hr = IXMLDOMDocument_get_namespaceURI(doc, &str);
6242     EXPECT_HR(hr, S_FALSE);
6243     ok(str == NULL, "got %p\n", str);
6244
6245     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("//XMI.content"), &node );
6246     EXPECT_HR(hr, S_OK);
6247     if(hr == S_OK)
6248     {
6249         IXMLDOMAttribute *attr;
6250         IXMLDOMNode *node2;
6251
6252         hr = IXMLDOMNode_get_firstChild(node, &node2);
6253         EXPECT_HR(hr, S_OK);
6254         ok(node2 != NULL, "got %p\n", node2);
6255
6256         /* Test get_prefix */
6257         hr = IXMLDOMNode_get_prefix(node2, NULL);
6258         EXPECT_HR(hr, E_INVALIDARG);
6259         /* NOTE: Need to test that arg2 gets cleared on Error. */
6260
6261         hr = IXMLDOMNode_get_prefix(node2, &str);
6262         EXPECT_HR(hr, S_OK);
6263         ok( !lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
6264         SysFreeString(str);
6265
6266         hr = IXMLDOMNode_get_nodeName(node2, &str);
6267         EXPECT_HR(hr, S_OK);
6268         ok(!lstrcmpW( str, _bstr_("Model:Package")), "got %s\n", wine_dbgstr_w(str));
6269         SysFreeString(str);
6270
6271         /* Test get_namespaceURI */
6272         hr = IXMLDOMNode_get_namespaceURI(node2, NULL);
6273         EXPECT_HR(hr, E_INVALIDARG);
6274         /* NOTE: Need to test that arg2 gets cleared on Error. */
6275
6276         hr = IXMLDOMNode_get_namespaceURI(node2, &str);
6277         EXPECT_HR(hr, S_OK);
6278         ok(!lstrcmpW( str, _bstr_("http://omg.org/mof.Model/1.3")), "got %s\n", wine_dbgstr_w(str));
6279         SysFreeString(str);
6280
6281         hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&elem);
6282         EXPECT_HR(hr, S_OK);
6283
6284         hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("Model:name2"), &attr);
6285         EXPECT_HR(hr, S_OK);
6286
6287         hr = IXMLDOMAttribute_get_nodeName(attr, &str);
6288         EXPECT_HR(hr, S_OK);
6289         ok(!lstrcmpW( str, _bstr_("Model:name2")), "got %s\n", wine_dbgstr_w(str));
6290         SysFreeString(str);
6291
6292         hr = IXMLDOMAttribute_get_prefix(attr, &str);
6293         EXPECT_HR(hr, S_OK);
6294         ok(!lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
6295         SysFreeString(str);
6296
6297         IXMLDOMAttribute_Release(attr);
6298         IXMLDOMElement_Release(elem);
6299
6300         IXMLDOMNode_Release(node2);
6301         IXMLDOMNode_Release(node);
6302     }
6303
6304     IXMLDOMDocument_Release(doc);
6305
6306     free_bstrs();
6307 }
6308
6309 static void test_FormattingXML(void)
6310 {
6311     IXMLDOMDocument *doc;
6312     IXMLDOMElement *pElement;
6313     VARIANT_BOOL bSucc;
6314     HRESULT hr;
6315     BSTR str;
6316     static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
6317     static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
6318
6319     doc = create_document(&IID_IXMLDOMDocument);
6320
6321     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
6322     ok(hr == S_OK, "ret %08x\n", hr );
6323     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6324
6325     if(bSucc == VARIANT_TRUE)
6326     {
6327         hr = IXMLDOMDocument_get_documentElement(doc, &pElement);
6328         ok(hr == S_OK, "ret %08x\n", hr );
6329         if(hr == S_OK)
6330         {
6331             hr = IXMLDOMElement_get_xml(pElement, &str);
6332             ok(hr == S_OK, "ret %08x\n", hr );
6333             ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
6334             SysFreeString(str);
6335
6336             IXMLDOMElement_Release(pElement);
6337         }
6338     }
6339
6340     IXMLDOMDocument_Release(doc);
6341
6342     free_bstrs();
6343 }
6344
6345 typedef struct _nodetypedvalue_t {
6346     const char *name;
6347     VARTYPE type;
6348     const char *value; /* value in string format */
6349 } nodetypedvalue_t;
6350
6351 static const nodetypedvalue_t get_nodetypedvalue[] = {
6352     { "root/string",    VT_BSTR, "Wine" },
6353     { "root/string2",   VT_BSTR, "String" },
6354     { "root/number",    VT_BSTR, "12.44" },
6355     { "root/number2",   VT_BSTR, "-3.71e3" },
6356     { "root/int",       VT_I4,   "-13" },
6357     { "root/fixed",     VT_CY,   "7322.9371" },
6358     { "root/bool",      VT_BOOL, "-1" },
6359     { "root/datetime",  VT_DATE, "40135.14" },
6360     { "root/datetimetz",VT_DATE, "37813.59" },
6361     { "root/date",      VT_DATE, "665413" },
6362     { "root/time",      VT_DATE, "0.5813889" },
6363     { "root/timetz",    VT_DATE, "1.112512" },
6364     { "root/i1",        VT_I1,   "-13" },
6365     { "root/i2",        VT_I2,   "31915" },
6366     { "root/i4",        VT_I4,   "-312232" },
6367     { "root/ui1",       VT_UI1,  "123" },
6368     { "root/ui2",       VT_UI2,  "48282" },
6369     { "root/ui4",       VT_UI4,  "949281" },
6370     { "root/r4",        VT_R4,   "213124" },
6371     { "root/r8",        VT_R8,   "0.412" },
6372     { "root/float",     VT_R8,   "41221.421" },
6373     { "root/uuid",      VT_BSTR, "333C7BC4-460F-11D0-BC04-0080C7055a83" },
6374     { "root/binbase64", VT_ARRAY|VT_UI1, "base64 test" },
6375     { "root/binbase64_1", VT_ARRAY|VT_UI1, "base64 test" },
6376     { "root/binbase64_2", VT_ARRAY|VT_UI1, "base64 test" },
6377     { 0 }
6378 };
6379
6380 static void test_nodeTypedValue(void)
6381 {
6382     const nodetypedvalue_t *entry = get_nodetypedvalue;
6383     IXMLDOMDocumentType *doctype, *doctype2;
6384     IXMLDOMProcessingInstruction *pi;
6385     IXMLDOMDocumentFragment *frag;
6386     IXMLDOMDocument *doc, *doc2;
6387     IXMLDOMCDATASection *cdata;
6388     IXMLDOMComment *comment;
6389     IXMLDOMNode *node;
6390     VARIANT_BOOL b;
6391     VARIANT value;
6392     HRESULT hr;
6393
6394     doc = create_document(&IID_IXMLDOMDocument);
6395
6396     b = VARIANT_FALSE;
6397     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &b);
6398     ok(hr == S_OK, "ret %08x\n", hr );
6399     ok(b == VARIANT_TRUE, "got %d\n", b);
6400
6401     hr = IXMLDOMDocument_get_nodeValue(doc, NULL);
6402     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6403
6404     V_VT(&value) = VT_BSTR;
6405     V_BSTR(&value) = NULL;
6406     hr = IXMLDOMDocument_get_nodeValue(doc, &value);
6407     ok(hr == S_FALSE, "ret %08x\n", hr );
6408     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6409
6410     hr = IXMLDOMDocument_get_nodeTypedValue(doc, NULL);
6411     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6412
6413     V_VT(&value) = VT_EMPTY;
6414     hr = IXMLDOMDocument_get_nodeTypedValue(doc, &value);
6415     ok(hr == S_FALSE, "ret %08x\n", hr );
6416     ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6417
6418     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/string"), &node);
6419     ok(hr == S_OK, "ret %08x\n", hr );
6420
6421     V_VT(&value) = VT_BSTR;
6422     V_BSTR(&value) = NULL;
6423     hr = IXMLDOMNode_get_nodeValue(node, &value);
6424     ok(hr == S_FALSE, "ret %08x\n", hr );
6425     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6426
6427     hr = IXMLDOMNode_get_nodeTypedValue(node, NULL);
6428     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6429
6430     IXMLDOMNode_Release(node);
6431
6432     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/binhex"), &node);
6433     ok(hr == S_OK, "ret %08x\n", hr );
6434     {
6435         BYTE bytes[] = {0xff,0xfc,0xa0,0x12,0x00,0x3c};
6436
6437         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6438         ok(hr == S_OK, "ret %08x\n", hr );
6439         ok(V_VT(&value) == (VT_ARRAY|VT_UI1), "incorrect type\n");
6440         ok(V_ARRAY(&value)->rgsabound[0].cElements == 6, "incorrect array size\n");
6441         if(V_ARRAY(&value)->rgsabound[0].cElements == 6)
6442             ok(!memcmp(bytes, V_ARRAY(&value)->pvData, sizeof(bytes)), "incorrect value\n");
6443         VariantClear(&value);
6444         IXMLDOMNode_Release(node);
6445     }
6446
6447     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("foo"), _bstr_("value"), &pi);
6448     ok(hr == S_OK, "ret %08x\n", hr );
6449     {
6450         V_VT(&value) = VT_NULL;
6451         V_BSTR(&value) = (void*)0xdeadbeef;
6452         hr = IXMLDOMProcessingInstruction_get_nodeTypedValue(pi, &value);
6453         ok(hr == S_OK, "ret %08x\n", hr );
6454         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6455         ok(!lstrcmpW(V_BSTR(&value), _bstr_("value")), "got wrong value\n");
6456         IXMLDOMProcessingInstruction_Release(pi);
6457         VariantClear(&value);
6458     }
6459
6460     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("[1]*2=3; &gee that's not right!"), &cdata);
6461     ok(hr == S_OK, "ret %08x\n", hr );
6462     {
6463         V_VT(&value) = VT_NULL;
6464         V_BSTR(&value) = (void*)0xdeadbeef;
6465         hr = IXMLDOMCDATASection_get_nodeTypedValue(cdata, &value);
6466         ok(hr == S_OK, "ret %08x\n", hr );
6467         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6468         ok(!lstrcmpW(V_BSTR(&value), _bstr_("[1]*2=3; &gee that's not right!")), "got wrong value\n");
6469         IXMLDOMCDATASection_Release(cdata);
6470         VariantClear(&value);
6471     }
6472
6473     hr = IXMLDOMDocument_createComment(doc, _bstr_("comment"), &comment);
6474     ok(hr == S_OK, "ret %08x\n", hr );
6475     {
6476         V_VT(&value) = VT_NULL;
6477         V_BSTR(&value) = (void*)0xdeadbeef;
6478         hr = IXMLDOMComment_get_nodeTypedValue(comment, &value);
6479         ok(hr == S_OK, "ret %08x\n", hr );
6480         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6481         ok(!lstrcmpW(V_BSTR(&value), _bstr_("comment")), "got wrong value\n");
6482         IXMLDOMComment_Release(comment);
6483         VariantClear(&value);
6484     }
6485
6486     hr = IXMLDOMDocument_createDocumentFragment(doc, &frag);
6487     ok(hr == S_OK, "ret %08x\n", hr );
6488     {
6489         V_VT(&value) = VT_EMPTY;
6490         hr = IXMLDOMDocumentFragment_get_nodeTypedValue(frag, &value);
6491         ok(hr == S_FALSE, "ret %08x\n", hr );
6492         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6493         IXMLDOMDocumentFragment_Release(frag);
6494     }
6495
6496     doc2 = create_document(&IID_IXMLDOMDocument);
6497
6498     b = VARIANT_FALSE;
6499     hr = IXMLDOMDocument_loadXML(doc2, _bstr_(szEmailXML), &b);
6500     ok(hr == S_OK, "ret %08x\n", hr );
6501     ok(b == VARIANT_TRUE, "got %d\n", b);
6502
6503     EXPECT_REF(doc2, 1);
6504
6505     hr = IXMLDOMDocument_get_doctype(doc2, &doctype);
6506     ok(hr == S_OK, "ret %08x\n", hr );
6507
6508     EXPECT_REF(doc2, 1);
6509     todo_wine EXPECT_REF(doctype, 2);
6510
6511     {
6512         V_VT(&value) = VT_EMPTY;
6513         hr = IXMLDOMDocumentType_get_nodeTypedValue(doctype, &value);
6514         ok(hr == S_FALSE, "ret %08x\n", hr );
6515         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6516     }
6517
6518     hr = IXMLDOMDocument_get_doctype(doc2, &doctype2);
6519     ok(hr == S_OK, "ret %08x\n", hr );
6520     ok(doctype != doctype2, "got %p, was %p\n", doctype2, doctype);
6521
6522     IXMLDOMDocumentType_Release(doctype2);
6523     IXMLDOMDocumentType_Release(doctype);
6524
6525     IXMLDOMDocument_Release(doc2);
6526
6527     while (entry->name)
6528     {
6529         hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_(entry->name), &node);
6530         ok(hr == S_OK, "ret %08x\n", hr );
6531
6532         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6533         ok(hr == S_OK, "ret %08x\n", hr );
6534         ok(V_VT(&value) == entry->type, "incorrect type, expected %d, got %d\n", entry->type, V_VT(&value));
6535
6536         if (entry->type == (VT_ARRAY|VT_UI1))
6537         {
6538             ok(V_ARRAY(&value)->rgsabound[0].cElements == strlen(entry->value),
6539                "incorrect array size %d\n", V_ARRAY(&value)->rgsabound[0].cElements);
6540         }
6541
6542         if (entry->type != VT_BSTR)
6543         {
6544            if (entry->type == VT_DATE ||
6545                entry->type == VT_R8 ||
6546                entry->type == VT_CY)
6547            {
6548                if (entry->type == VT_DATE)
6549                {
6550                    hr = VariantChangeType(&value, &value, 0, VT_R4);
6551                    ok(hr == S_OK, "ret %08x\n", hr );
6552                }
6553                hr = VariantChangeTypeEx(&value, &value,
6554                                         MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT),
6555                                         VARIANT_NOUSEROVERRIDE, VT_BSTR);
6556                ok(hr == S_OK, "ret %08x\n", hr );
6557            }
6558            else
6559            {
6560                hr = VariantChangeType(&value, &value, 0, VT_BSTR);
6561                ok(hr == S_OK, "ret %08x\n", hr );
6562            }
6563
6564            /* for byte array from VT_ARRAY|VT_UI1 it's not a WCHAR buffer */
6565            if (entry->type == (VT_ARRAY|VT_UI1))
6566            {
6567                ok(!memcmp( V_BSTR(&value), entry->value, strlen(entry->value)),
6568                   "expected %s\n", entry->value);
6569            }
6570            else
6571                ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
6572                   "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
6573         }
6574         else
6575            ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
6576                "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
6577
6578         VariantClear( &value );
6579         IXMLDOMNode_Release(node);
6580
6581         entry++;
6582     }
6583
6584     IXMLDOMDocument_Release(doc);
6585     free_bstrs();
6586 }
6587
6588 static void test_TransformWithLoadingLocalFile(void)
6589 {
6590     IXMLDOMDocument *doc;
6591     IXMLDOMDocument *xsl;
6592     IXMLDOMNode *pNode;
6593     VARIANT_BOOL bSucc;
6594     HRESULT hr;
6595     HANDLE file;
6596     DWORD dwWritten;
6597     char lpPathBuffer[MAX_PATH];
6598     int i;
6599
6600     /* Create a Temp File. */
6601     GetTempPathA(MAX_PATH, lpPathBuffer);
6602     strcat(lpPathBuffer, "customers.xml" );
6603
6604     file = CreateFileA(lpPathBuffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
6605     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
6606     if(file == INVALID_HANDLE_VALUE)
6607         return;
6608
6609     WriteFile(file, szBasicTransformXML, strlen(szBasicTransformXML), &dwWritten, NULL);
6610     CloseHandle(file);
6611
6612     /* Correct path to not include an escape character. */
6613     for(i=0; i < strlen(lpPathBuffer); i++)
6614     {
6615         if(lpPathBuffer[i] == '\\')
6616             lpPathBuffer[i] = '/';
6617     }
6618
6619     doc = create_document(&IID_IXMLDOMDocument);
6620     xsl = create_document(&IID_IXMLDOMDocument);
6621
6622     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
6623     ok(hr == S_OK, "ret %08x\n", hr );
6624     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6625     if(bSucc == VARIANT_TRUE)
6626     {
6627         BSTR sXSL;
6628         BSTR sPart1 = _bstr_(szBasicTransformSSXMLPart1);
6629         BSTR sPart2 = _bstr_(szBasicTransformSSXMLPart2);
6630         BSTR sFileName = _bstr_(lpPathBuffer);
6631         int nLegnth = lstrlenW(sPart1) + lstrlenW(sPart2) + lstrlenW(sFileName) + 1;
6632
6633         sXSL = SysAllocStringLen(NULL, nLegnth);
6634         lstrcpyW(sXSL, sPart1);
6635         lstrcatW(sXSL, sFileName);
6636         lstrcatW(sXSL, sPart2);
6637
6638         hr = IXMLDOMDocument_loadXML(xsl, sXSL, &bSucc);
6639         ok(hr == S_OK, "ret %08x\n", hr );
6640         ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6641         if(bSucc == VARIANT_TRUE)
6642         {
6643             BSTR sResult;
6644
6645             hr = IXMLDOMDocument_QueryInterface(xsl, &IID_IXMLDOMNode, (void**)&pNode );
6646             ok(hr == S_OK, "ret %08x\n", hr );
6647             if(hr == S_OK)
6648             {
6649                 /* This will load the temp file via the XSL */
6650                 hr = IXMLDOMDocument_transformNode(doc, pNode, &sResult);
6651                 ok(hr == S_OK, "ret %08x\n", hr );
6652                 if(hr == S_OK)
6653                 {
6654                     ok( compareIgnoreReturns( sResult, _bstr_(szBasicTransformOutput)), "Stylesheet output not correct\n");
6655                     SysFreeString(sResult);
6656                 }
6657
6658                 IXMLDOMNode_Release(pNode);
6659             }
6660         }
6661
6662         SysFreeString(sXSL);
6663     }
6664
6665     IXMLDOMDocument_Release(doc);
6666     IXMLDOMDocument_Release(xsl);
6667
6668     DeleteFileA(lpPathBuffer);
6669     free_bstrs();
6670 }
6671
6672 static void test_put_nodeValue(void)
6673 {
6674     static const WCHAR jeevesW[] = {'J','e','e','v','e','s',' ','&',' ','W','o','o','s','t','e','r',0};
6675     IXMLDOMDocument *doc;
6676     IXMLDOMText *text;
6677     IXMLDOMEntityReference *entityref;
6678     IXMLDOMAttribute *attr;
6679     IXMLDOMNode *node;
6680     HRESULT hr;
6681     VARIANT data, type;
6682
6683     doc = create_document(&IID_IXMLDOMDocument);
6684
6685     /* test for unsupported types */
6686     /* NODE_DOCUMENT */
6687     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&node);
6688     ok(hr == S_OK, "ret %08x\n", hr );
6689     V_VT(&data) = VT_BSTR;
6690     V_BSTR(&data) = _bstr_("one two three");
6691     hr = IXMLDOMNode_put_nodeValue(node, data);
6692     ok(hr == E_FAIL, "ret %08x\n", hr );
6693     IXMLDOMNode_Release(node);
6694
6695     /* NODE_DOCUMENT_FRAGMENT */
6696     V_VT(&type) = VT_I1;
6697     V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
6698     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
6699     ok(hr == S_OK, "ret %08x\n", hr );
6700     V_VT(&data) = VT_BSTR;
6701     V_BSTR(&data) = _bstr_("one two three");
6702     hr = IXMLDOMNode_put_nodeValue(node, data);
6703     ok(hr == E_FAIL, "ret %08x\n", hr );
6704     IXMLDOMNode_Release(node);
6705
6706     /* NODE_ELEMENT */
6707     V_VT(&type) = VT_I1;
6708     V_I1(&type) = NODE_ELEMENT;
6709     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
6710     ok(hr == S_OK, "ret %08x\n", hr );
6711     V_VT(&data) = VT_BSTR;
6712     V_BSTR(&data) = _bstr_("one two three");
6713     hr = IXMLDOMNode_put_nodeValue(node, data);
6714     ok(hr == E_FAIL, "ret %08x\n", hr );
6715     IXMLDOMNode_Release(node);
6716
6717     /* NODE_ENTITY_REFERENCE */
6718     hr = IXMLDOMDocument_createEntityReference(doc, _bstr_("ref"), &entityref);
6719     ok(hr == S_OK, "ret %08x\n", hr );
6720
6721     V_VT(&data) = VT_BSTR;
6722     V_BSTR(&data) = _bstr_("one two three");
6723     hr = IXMLDOMEntityReference_put_nodeValue(entityref, data);
6724     ok(hr == E_FAIL, "ret %08x\n", hr );
6725
6726     hr = IXMLDOMEntityReference_QueryInterface(entityref, &IID_IXMLDOMNode, (void**)&node);
6727     ok(hr == S_OK, "ret %08x\n", hr );
6728     V_VT(&data) = VT_BSTR;
6729     V_BSTR(&data) = _bstr_("one two three");
6730     hr = IXMLDOMNode_put_nodeValue(node, data);
6731     ok(hr == E_FAIL, "ret %08x\n", hr );
6732     IXMLDOMNode_Release(node);
6733     IXMLDOMEntityReference_Release(entityref);
6734
6735     /* supported types */
6736     hr = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &text);
6737     ok(hr == S_OK, "ret %08x\n", hr );
6738     V_VT(&data) = VT_BSTR;
6739     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
6740     hr = IXMLDOMText_put_nodeValue(text, data);
6741     ok(hr == S_OK, "ret %08x\n", hr );
6742     IXMLDOMText_Release(text);
6743
6744     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
6745     ok(hr == S_OK, "ret %08x\n", hr );
6746     V_VT(&data) = VT_BSTR;
6747     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
6748     hr = IXMLDOMAttribute_put_nodeValue(attr, data);
6749     ok(hr == S_OK, "ret %08x\n", hr );
6750     hr = IXMLDOMAttribute_get_nodeValue(attr, &data);
6751     ok(hr == S_OK, "ret %08x\n", hr );
6752     ok(memcmp(V_BSTR(&data), jeevesW, sizeof(jeevesW)) == 0, "got %s\n",
6753         wine_dbgstr_w(V_BSTR(&data)));
6754     VariantClear(&data);
6755     IXMLDOMAttribute_Release(attr);
6756
6757     free_bstrs();
6758
6759     IXMLDOMDocument_Release(doc);
6760 }
6761
6762 static void test_IObjectSafety(void)
6763 {
6764     IXMLDOMDocument *doc;
6765     IObjectSafety *safety;
6766     HRESULT hr;
6767
6768     doc = create_document(&IID_IXMLDOMDocument);
6769
6770     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IObjectSafety, (void**)&safety);
6771     ok(hr == S_OK, "ret %08x\n", hr );
6772
6773     test_IObjectSafety_common(safety);
6774
6775     IObjectSafety_Release(safety);
6776     IXMLDOMDocument_Release(doc);
6777
6778     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
6779         &IID_IObjectSafety, (void**)&safety);
6780     ok(hr == S_OK, "Could not create XMLHTTPRequest instance: %08x\n", hr);
6781
6782     test_IObjectSafety_common(safety);
6783
6784     IObjectSafety_Release(safety);
6785
6786 }
6787
6788 typedef struct _property_test_t {
6789     const GUID *guid;
6790     const char *clsid;
6791     const char *property;
6792     const char *value;
6793 } property_test_t;
6794
6795 static const property_test_t properties_test_data[] = {
6796     { &CLSID_DOMDocument,  "CLSID_DOMDocument" , "SelectionLanguage", "XSLPattern" },
6797     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2" , "SelectionLanguage", "XSLPattern" },
6798     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "SelectionLanguage", "XSLPattern" },
6799     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "SelectionLanguage", "XPath" },
6800     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "SelectionLanguage", "XPath" },
6801     { 0 }
6802 };
6803
6804 static void test_default_properties(void)
6805 {
6806     const property_test_t *entry = properties_test_data;
6807
6808     while (entry->guid)
6809     {
6810         IXMLDOMDocument2 *doc;
6811         VARIANT var;
6812         HRESULT hr;
6813
6814         if (!is_clsid_supported(entry->guid, &IID_IXMLDOMDocument2))
6815         {
6816             entry++;
6817             continue;
6818         }
6819
6820         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
6821         ok(hr == S_OK, "got 0x%08x\n", hr);
6822
6823         hr = IXMLDOMDocument2_getProperty(doc, _bstr_(entry->property), &var);
6824         ok(hr == S_OK, "got 0x%08x\n", hr);
6825         ok(lstrcmpW(V_BSTR(&var), _bstr_(entry->value)) == 0, "expected %s, for %s\n",
6826            entry->value, entry->clsid);
6827         VariantClear(&var);
6828
6829         IXMLDOMDocument2_Release(doc);
6830
6831         entry++;
6832     }
6833 }
6834
6835 typedef struct {
6836     const char *query;
6837     const char *list;
6838 } xslpattern_test_t;
6839
6840 static const xslpattern_test_t xslpattern_test[] = {
6841     { "root//elem[0]", "E1.E2.D1" },
6842     { "root//elem[index()=1]", "E2.E2.D1" },
6843     { "root//elem[index() $eq$ 1]", "E2.E2.D1" },
6844     { "root//elem[end()]", "E4.E2.D1" },
6845     { "root//elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
6846     { "root//elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6847     { "root//elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6848     { "root//elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
6849     { "root//elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
6850     { "root//elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
6851     { "root//elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
6852     { "root//elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
6853     { "root//elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
6854     { "root//elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
6855     { "root//elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
6856     { "root//elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
6857     { "root//elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6858     { "root//elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
6859     { "root//elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
6860     { "root//elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
6861     { "root//elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
6862     { "root//elem[$any$ *='B2 field']", "E2.E2.D1" },
6863     { "root//elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6864     { "root//elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
6865     { "root//elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
6866     { "root//elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
6867     { "root//elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6868     { "root//elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6869     { "root//elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6870     { "root/elem[0]", "E1.E2.D1" },
6871     { "root/elem[index()=1]", "E2.E2.D1" },
6872     { "root/elem[index() $eq$ 1]", "E2.E2.D1" },
6873     { "root/elem[end()]", "E4.E2.D1" },
6874     { "root/elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
6875     { "root/elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6876     { "root/elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6877     { "root/elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
6878     { "root/elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
6879     { "root/elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
6880     { "root/elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
6881     { "root/elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
6882     { "root/elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
6883     { "root/elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
6884     { "root/elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
6885     { "root/elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
6886     { "root/elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6887     { "root/elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
6888     { "root/elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
6889     { "root/elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
6890     { "root/elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
6891     { "root/elem[$any$ *='B2 field']", "E2.E2.D1" },
6892     { "root/elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6893     { "root/elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
6894     { "root/elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
6895     { "root/elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
6896     { "root/elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6897     { "root/elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6898     { "root/elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6899     { "root/elem[d]", "E1.E2.D1 E2.E2.D1 E4.E2.D1" },
6900     { NULL }
6901 };
6902
6903 static const xslpattern_test_t xslpattern_test_no_ns[] = {
6904     /* prefixes don't need to be registered, you may use them as they are in the doc */
6905     { "//bar:x", "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1" },
6906     /* prefixes must be explicitly specified in the name */
6907     { "//foo:elem", "" },
6908     { "//foo:c", "E3.E4.E2.D1" },
6909     { NULL }
6910 };
6911
6912 static const xslpattern_test_t xslpattern_test_func[] = {
6913     { "attribute()", "" },
6914     { "attribute('depth')", "" },
6915     { "root/attribute('depth')", "A'depth'.E3.D1" },
6916     { "//x/attribute()", "A'id'.E3.E3.D1 A'depth'.E3.E3.D1" },
6917     { "//x//attribute(id)", NULL },
6918     { "//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" },
6919     { "comment()", "C2.D1" },
6920     { "//comment()", "C2.D1 C1.E3.D1 C2.E3.E3.D1 C2.E4.E3.D1" },
6921     { "element()", "E3.D1" },
6922     { "root/y/element()", "E4.E4.E3.D1 E5.E4.E3.D1 E6.E4.E3.D1" },
6923     { "//element(a)", NULL },
6924     { "//element('a')", "E4.E3.E3.D1 E4.E4.E3.D1" },
6925     { "node()", "P1.D1 C2.D1 E3.D1" },
6926     { "//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" },
6927     { "//x/node()[nodeType()=1]", "E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1" },
6928     { "//x/node()[nodeType()=3]", "T3.E3.E3.D1" },
6929     { "//x/node()[nodeType()=7]", "P1.E3.E3.D1" },
6930     { "//x/node()[nodeType()=8]", "C2.E3.E3.D1" },
6931     { "pi()", "P1.D1" },
6932     { "//y/pi()", "P1.E4.E3.D1" },
6933     { "root/textnode()", "T2.E3.D1" },
6934     { "root/element()/textnode()", "T3.E3.E3.D1 T3.E4.E3.D1" },
6935     { NULL }
6936 };
6937
6938 static void test_XSLPattern(void)
6939 {
6940     const xslpattern_test_t *ptr = xslpattern_test;
6941     IXMLDOMDocument2 *doc;
6942     IXMLDOMNodeList *list;
6943     VARIANT_BOOL b;
6944     HRESULT hr;
6945     LONG len;
6946
6947     doc = create_document(&IID_IXMLDOMDocument2);
6948
6949     b = VARIANT_FALSE;
6950     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
6951     EXPECT_HR(hr, S_OK);
6952     ok(b == VARIANT_TRUE, "failed to load XML string\n");
6953
6954     /* switch to XSLPattern */
6955     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern"));
6956     EXPECT_HR(hr, S_OK);
6957
6958     /* XPath doesn't select elements with non-null default namespace with unqualified selectors, XSLPattern does */
6959     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem/c"), &list);
6960     EXPECT_HR(hr, S_OK);
6961
6962     len = 0;
6963     hr = IXMLDOMNodeList_get_length(list, &len);
6964     EXPECT_HR(hr, S_OK);
6965     /* should select <elem><c> and <elem xmlns='...'><c> but not <elem><foo:c> */
6966     ok(len == 3, "expected 3 entries in list, got %d\n", len);
6967     IXMLDOMNodeList_Release(list);
6968
6969     while (ptr->query)
6970     {
6971         list = NULL;
6972         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
6973         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
6974         len = 0;
6975         hr = IXMLDOMNodeList_get_length(list, &len);
6976         ok(len != 0, "query=%s, empty list\n", ptr->query);
6977         if (len)
6978             expect_list_and_release(list, ptr->list);
6979
6980         ptr++;
6981     }
6982
6983     /* namespace handling */
6984     /* no registered namespaces */
6985     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_(""));
6986     EXPECT_HR(hr, S_OK);
6987
6988     ptr = xslpattern_test_no_ns;
6989     while (ptr->query)
6990     {
6991         list = NULL;
6992         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
6993         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
6994
6995         if (*ptr->list)
6996         {
6997             len = 0;
6998             hr = IXMLDOMNodeList_get_length(list, &len);
6999             EXPECT_HR(hr, S_OK);
7000             ok(len != 0, "query=%s, empty list\n", ptr->query);
7001         }
7002         else
7003         {
7004             len = 1;
7005             hr = IXMLDOMNodeList_get_length(list, &len);
7006             EXPECT_HR(hr, S_OK);
7007             ok(len == 0, "query=%s, empty list\n", ptr->query);
7008         }
7009         if (len)
7010             expect_list_and_release(list, ptr->list);
7011
7012         ptr++;
7013     }
7014
7015     /* explicitly register prefix foo */
7016     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
7017
7018     /* now we get the same behavior as XPath */
7019     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
7020     EXPECT_HR(hr, S_OK);
7021     len = 0;
7022     hr = IXMLDOMNodeList_get_length(list, &len);
7023     EXPECT_HR(hr, S_OK);
7024     ok(len != 0, "expected filled list\n");
7025     if (len)
7026         expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
7027
7028     /* set prefix foo to some nonexistent namespace */
7029     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:nonexistent-foo'"));
7030     EXPECT_HR(hr, S_OK);
7031
7032     /* the registered prefix takes precedence */
7033     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
7034     EXPECT_HR(hr, S_OK);
7035     len = 0;
7036     hr = IXMLDOMNodeList_get_length(list, &len);
7037     EXPECT_HR(hr, S_OK);
7038     ok(len == 0, "expected empty list\n");
7039     IXMLDOMNodeList_Release(list);
7040
7041     IXMLDOMDocument2_Release(doc);
7042
7043     doc = create_document(&IID_IXMLDOMDocument2);
7044
7045     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNodeTypesXML), &b);
7046     EXPECT_HR(hr, S_OK);
7047     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7048
7049     ptr = xslpattern_test_func;
7050     while (ptr->query)
7051     {
7052         list = NULL;
7053         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
7054         if (ptr->list)
7055         {
7056             ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7057             len = 0;
7058             hr = IXMLDOMNodeList_get_length(list, &len);
7059             if (*ptr->list)
7060             {
7061                 ok(len != 0, "query=%s, empty list\n", ptr->query);
7062                 if (len)
7063                     expect_list_and_release(list, ptr->list);
7064             }
7065             else
7066                 ok(len == 0, "query=%s, filled list\n", ptr->query);
7067         }
7068         else
7069             ok(hr == E_FAIL, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7070
7071         ptr++;
7072     }
7073
7074     IXMLDOMDocument2_Release(doc);
7075     free_bstrs();
7076 }
7077
7078 static void test_splitText(void)
7079 {
7080     IXMLDOMCDATASection *cdata;
7081     IXMLDOMElement *root;
7082     IXMLDOMDocument *doc;
7083     IXMLDOMText *text, *text2;
7084     IXMLDOMNode *node;
7085     VARIANT var;
7086     VARIANT_BOOL success;
7087     LONG length;
7088     HRESULT hr;
7089
7090     doc = create_document(&IID_IXMLDOMDocument);
7091
7092     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<root></root>"), &success);
7093     ok(hr == S_OK, "got 0x%08x\n", hr);
7094
7095     hr = IXMLDOMDocument_get_documentElement(doc, &root);
7096     ok(hr == S_OK, "got 0x%08x\n", hr);
7097
7098     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("beautiful plumage"), &cdata);
7099     ok(hr == S_OK, "got 0x%08x\n", hr);
7100
7101     V_VT(&var) = VT_EMPTY;
7102     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)cdata, NULL);
7103     ok(hr == S_OK, "got 0x%08x\n", hr);
7104
7105     length = 0;
7106     hr = IXMLDOMCDATASection_get_length(cdata, &length);
7107     ok(hr == S_OK, "got 0x%08x\n", hr);
7108     ok(length > 0, "got %d\n", length);
7109
7110     hr = IXMLDOMCDATASection_splitText(cdata, 0, NULL);
7111     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7112
7113     text = (void*)0xdeadbeef;
7114     /* negative offset */
7115     hr = IXMLDOMCDATASection_splitText(cdata, -1, &text);
7116     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7117     ok(text == (void*)0xdeadbeef, "got %p\n", text);
7118
7119     text = (void*)0xdeadbeef;
7120     /* offset outside data */
7121     hr = IXMLDOMCDATASection_splitText(cdata, length + 1, &text);
7122     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7123     ok(text == 0, "got %p\n", text);
7124
7125     text = (void*)0xdeadbeef;
7126     /* offset outside data */
7127     hr = IXMLDOMCDATASection_splitText(cdata, length, &text);
7128     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7129     ok(text == 0, "got %p\n", text);
7130
7131     /* no empty node created */
7132     node = (void*)0xdeadbeef;
7133     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7134     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7135     ok(node == 0, "got %p\n", text);
7136
7137     hr = IXMLDOMCDATASection_splitText(cdata, 10, &text);
7138     ok(hr == S_OK, "got 0x%08x\n", hr);
7139
7140     length = 0;
7141     hr = IXMLDOMText_get_length(text, &length);
7142     ok(hr == S_OK, "got 0x%08x\n", hr);
7143     ok(length == 7, "got %d\n", length);
7144
7145     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7146     ok(hr == S_OK, "got 0x%08x\n", hr);
7147     IXMLDOMNode_Release(node);
7148
7149     /* split new text node */
7150     hr = IXMLDOMText_get_length(text, &length);
7151     ok(hr == S_OK, "got 0x%08x\n", hr);
7152
7153     node = (void*)0xdeadbeef;
7154     hr = IXMLDOMText_get_nextSibling(text, &node);
7155     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7156     ok(node == 0, "got %p\n", text);
7157
7158     hr = IXMLDOMText_splitText(text, 0, NULL);
7159     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7160
7161     text2 = (void*)0xdeadbeef;
7162     /* negative offset */
7163     hr = IXMLDOMText_splitText(text, -1, &text2);
7164     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7165     ok(text2 == (void*)0xdeadbeef, "got %p\n", text2);
7166
7167     text2 = (void*)0xdeadbeef;
7168     /* offset outside data */
7169     hr = IXMLDOMText_splitText(text, length + 1, &text2);
7170     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7171     ok(text2 == 0, "got %p\n", text2);
7172
7173     text2 = (void*)0xdeadbeef;
7174     /* offset outside data */
7175     hr = IXMLDOMText_splitText(text, length, &text2);
7176     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7177     ok(text2 == 0, "got %p\n", text);
7178
7179     text2 = 0;
7180     hr = IXMLDOMText_splitText(text, 4, &text2);
7181     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7182     if (text2) IXMLDOMText_Release(text2);
7183
7184     node = 0;
7185     hr = IXMLDOMText_get_nextSibling(text, &node);
7186     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7187     if (node) IXMLDOMNode_Release(node);
7188
7189     IXMLDOMText_Release(text);
7190     IXMLDOMElement_Release(root);
7191     IXMLDOMCDATASection_Release(cdata);
7192     free_bstrs();
7193 }
7194
7195 typedef struct {
7196     const char *name;
7197     const char *uri;
7198     HRESULT hr;
7199 } ns_item_t;
7200
7201 /* default_ns_doc used */
7202 static const ns_item_t qualified_item_tests[] = {
7203     { "xml:lang", NULL, S_FALSE },
7204     { "xml:lang", "http://www.w3.org/XML/1998/namespace", S_FALSE },
7205     { "lang", "http://www.w3.org/XML/1998/namespace", S_OK },
7206     { "ns:b", NULL, S_FALSE },
7207     { "ns:b", "nshref", S_FALSE },
7208     { "b", "nshref", S_OK },
7209     { "d", NULL, S_OK },
7210     { NULL }
7211 };
7212
7213 static const ns_item_t named_item_tests[] = {
7214     { "xml:lang", NULL, S_OK },
7215     { "lang", NULL, S_FALSE },
7216     { "ns:b", NULL, S_OK },
7217     { "b", NULL, S_FALSE },
7218     { "d", NULL, S_OK },
7219     { NULL }
7220 };
7221
7222 static void test_getQualifiedItem(void)
7223 {
7224     IXMLDOMNode *pr_node, *node;
7225     IXMLDOMNodeList *root_list;
7226     IXMLDOMNamedNodeMap *map;
7227     IXMLDOMElement *element;
7228     const ns_item_t* ptr;
7229     IXMLDOMDocument *doc;
7230     VARIANT_BOOL b;
7231     HRESULT hr;
7232     LONG len;
7233
7234     doc = create_document(&IID_IXMLDOMDocument);
7235
7236     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7237     EXPECT_HR(hr, S_OK);
7238     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7239
7240     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7241     EXPECT_HR(hr, S_OK);
7242
7243     hr = IXMLDOMElement_get_childNodes(element, &root_list);
7244     EXPECT_HR(hr, S_OK);
7245
7246     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7247     EXPECT_HR(hr, S_OK);
7248     IXMLDOMNodeList_Release(root_list);
7249
7250     hr = IXMLDOMNode_get_attributes(pr_node, &map);
7251     EXPECT_HR(hr, S_OK);
7252     IXMLDOMNode_Release(pr_node);
7253
7254     len = 0;
7255     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7256     EXPECT_HR(hr, S_OK);
7257     ok( len == 3, "length %d\n", len);
7258
7259     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, NULL);
7260     EXPECT_HR(hr, E_INVALIDARG);
7261
7262     node = (void*)0xdeadbeef;
7263     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, &node);
7264     EXPECT_HR(hr, E_INVALIDARG);
7265     ok( node == (void*)0xdeadbeef, "got %p\n", node);
7266
7267     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, NULL);
7268     EXPECT_HR(hr, E_INVALIDARG);
7269
7270     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, &node);
7271     EXPECT_HR(hr, S_OK);
7272
7273     IXMLDOMNode_Release(node);
7274     IXMLDOMNamedNodeMap_Release(map);
7275     IXMLDOMElement_Release(element);
7276
7277     hr = IXMLDOMDocument_loadXML(doc, _bstr_(default_ns_doc), &b);
7278     EXPECT_HR(hr, S_OK);
7279
7280     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("a"), &node);
7281     EXPECT_HR(hr, S_OK);
7282
7283     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&element);
7284     EXPECT_HR(hr, S_OK);
7285     IXMLDOMNode_Release(node);
7286
7287     hr = IXMLDOMElement_get_attributes(element, &map);
7288     EXPECT_HR(hr, S_OK);
7289
7290     ptr = qualified_item_tests;
7291     while (ptr->name)
7292     {
7293        node = (void*)0xdeadbeef;
7294        hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
7295        ok(hr == ptr->hr, "%s, %s: got 0x%08x, expected 0x%08x\n", ptr->name, ptr->uri, hr, ptr->hr);
7296        if (hr == S_OK)
7297            IXMLDOMNode_Release(node);
7298        else
7299            ok(node == NULL, "%s, %s: got %p\n", ptr->name, ptr->uri, node);
7300        ptr++;
7301     }
7302
7303     ptr = named_item_tests;
7304     while (ptr->name)
7305     {
7306        node = (void*)0xdeadbeef;
7307        hr = IXMLDOMNamedNodeMap_getNamedItem(map, _bstr_(ptr->name), &node);
7308        ok(hr == ptr->hr, "%s: got 0x%08x, expected 0x%08x\n", ptr->name, hr, ptr->hr);
7309        if (hr == S_OK)
7310            IXMLDOMNode_Release(node);
7311        else
7312            ok(node == NULL, "%s: got %p\n", ptr->name, node);
7313        ptr++;
7314     }
7315
7316     IXMLDOMNamedNodeMap_Release(map);
7317
7318     IXMLDOMElement_Release(element);
7319     IXMLDOMDocument_Release(doc);
7320     free_bstrs();
7321 }
7322
7323 static void test_removeQualifiedItem(void)
7324 {
7325     IXMLDOMDocument *doc;
7326     IXMLDOMElement *element;
7327     IXMLDOMNode *pr_node, *node;
7328     IXMLDOMNodeList *root_list;
7329     IXMLDOMNamedNodeMap *map;
7330     VARIANT_BOOL b;
7331     LONG len;
7332     HRESULT hr;
7333
7334     doc = create_document(&IID_IXMLDOMDocument);
7335
7336     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7337     ok( hr == S_OK, "loadXML failed\n");
7338     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7339
7340     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7341     ok( hr == S_OK, "ret %08x\n", hr);
7342
7343     hr = IXMLDOMElement_get_childNodes(element, &root_list);
7344     ok( hr == S_OK, "ret %08x\n", hr);
7345
7346     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7347     ok( hr == S_OK, "ret %08x\n", hr);
7348     IXMLDOMNodeList_Release(root_list);
7349
7350     hr = IXMLDOMNode_get_attributes(pr_node, &map);
7351     ok( hr == S_OK, "ret %08x\n", hr);
7352     IXMLDOMNode_Release(pr_node);
7353
7354     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7355     ok( hr == S_OK, "ret %08x\n", hr);
7356     ok( len == 3, "length %d\n", len);
7357
7358     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, NULL);
7359     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7360
7361     node = (void*)0xdeadbeef;
7362     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, &node);
7363     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7364     ok( node == (void*)0xdeadbeef, "got %p\n", node);
7365
7366     /* out pointer is optional */
7367     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7368     ok( hr == S_OK, "ret %08x\n", hr);
7369
7370     /* already removed */
7371     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7372     ok( hr == S_FALSE, "ret %08x\n", hr);
7373
7374     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("vr"), NULL, &node);
7375     ok( hr == S_OK, "ret %08x\n", hr);
7376     IXMLDOMNode_Release(node);
7377
7378     IXMLDOMNamedNodeMap_Release( map );
7379     IXMLDOMElement_Release( element );
7380     IXMLDOMDocument_Release( doc );
7381     free_bstrs();
7382 }
7383
7384 #define check_default_props(doc) _check_default_props(__LINE__, doc)
7385 static inline void _check_default_props(int line, IXMLDOMDocument2* doc)
7386 {
7387     VARIANT_BOOL b;
7388     VARIANT var;
7389     HRESULT hr;
7390
7391     VariantInit(&var);
7392     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
7393     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XSLPattern")) == 0, "expected XSLPattern\n");
7394     VariantClear(&var);
7395
7396     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
7397     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("")) == 0, "expected empty string\n");
7398     VariantClear(&var);
7399
7400     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
7401     ok_(__FILE__, line)(b == VARIANT_FALSE, "expected FALSE\n");
7402
7403     hr = IXMLDOMDocument2_get_schemas(doc, &var);
7404     ok_(__FILE__, line)(hr == S_FALSE, "got %08x\n", hr);
7405     VariantClear(&var);
7406 }
7407
7408 #define check_set_props(doc) _check_set_props(__LINE__, doc)
7409 static inline void _check_set_props(int line, IXMLDOMDocument2* doc)
7410 {
7411     VARIANT_BOOL b;
7412     VARIANT var;
7413
7414     VariantInit(&var);
7415     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
7416     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XPath")) == 0, "expected XPath\n");
7417     VariantClear(&var);
7418
7419     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
7420     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("xmlns:wi=\'www.winehq.org\'")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&var)));
7421     VariantClear(&var);
7422
7423     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
7424     ok_(__FILE__, line)(b == VARIANT_TRUE, "expected TRUE\n");
7425
7426     helper_ole_check(IXMLDOMDocument2_get_schemas(doc, &var));
7427     ok_(__FILE__, line)(V_VT(&var) != VT_NULL, "expected pointer\n");
7428     VariantClear(&var);
7429 }
7430
7431 #define set_props(doc, cache) _set_props(__LINE__, doc, cache)
7432 static inline void _set_props(int line, IXMLDOMDocument2* doc, IXMLDOMSchemaCollection* cache)
7433 {
7434     VARIANT var;
7435
7436     VariantInit(&var);
7437     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
7438     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:wi=\'www.winehq.org\'")));
7439     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_TRUE));
7440     V_VT(&var) = VT_DISPATCH;
7441     V_DISPATCH(&var) = NULL;
7442     helper_ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&var)));
7443     ok_(__FILE__, line)(V_DISPATCH(&var) != NULL, "expected pointer\n");
7444     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
7445     VariantClear(&var);
7446 }
7447
7448 #define unset_props(doc) _unset_props(__LINE__, doc)
7449 static inline void _unset_props(int line, IXMLDOMDocument2* doc)
7450 {
7451     VARIANT var;
7452
7453     VariantInit(&var);
7454     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
7455     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("")));
7456     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_FALSE));
7457     V_VT(&var) = VT_NULL;
7458     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
7459     VariantClear(&var);
7460 }
7461
7462 static void test_get_ownerDocument(void)
7463 {
7464     IXMLDOMDocument *doc1, *doc2, *doc3;
7465     IXMLDOMDocument2 *doc, *doc_owner;
7466     IXMLDOMNode *node;
7467     IXMLDOMSchemaCollection *cache;
7468     VARIANT_BOOL b;
7469     VARIANT var;
7470
7471     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
7472     if (!is_clsid_supported(&CLSID_XMLSchemaCache, &IID_IXMLDOMSchemaCollection)) return;
7473
7474     doc = create_document(&IID_IXMLDOMDocument2);
7475     cache = create_cache(&IID_IXMLDOMSchemaCollection);
7476
7477     VariantInit(&var);
7478
7479     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
7480     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7481
7482     check_default_props(doc);
7483
7484     /* set properties and check that new instances use them */
7485     set_props(doc, cache);
7486     check_set_props(doc);
7487
7488     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
7489     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc1));
7490
7491     /* new interface keeps props */
7492     ole_check(IXMLDOMDocument_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**)&doc_owner));
7493     ok( doc_owner != doc, "got %p, doc %p\n", doc_owner, doc);
7494     check_set_props(doc_owner);
7495     IXMLDOMDocument2_Release(doc_owner);
7496
7497     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc2));
7498     IXMLDOMNode_Release(node);
7499
7500     ok(doc1 != doc2, "got %p, expected %p. original %p\n", doc2, doc1, doc);
7501
7502     /* reload */
7503     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
7504     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7505
7506     /* properties retained even after reload */
7507     check_set_props(doc);
7508
7509     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
7510     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc3));
7511     IXMLDOMNode_Release(node);
7512
7513     ole_check(IXMLDOMDocument_QueryInterface(doc3, &IID_IXMLDOMDocument2, (void**)&doc_owner));
7514     ok(doc3 != doc1 && doc3 != doc2 && doc_owner != doc, "got %p, (%p, %p, %p)\n", doc3, doc, doc1, doc2);
7515     check_set_props(doc_owner);
7516
7517     /* changing properties for one instance changes them for all */
7518     unset_props(doc_owner);
7519     check_default_props(doc_owner);
7520     check_default_props(doc);
7521
7522     IXMLDOMSchemaCollection_Release(cache);
7523     IXMLDOMDocument_Release(doc1);
7524     IXMLDOMDocument_Release(doc2);
7525     IXMLDOMDocument_Release(doc3);
7526     IXMLDOMDocument2_Release(doc);
7527     IXMLDOMDocument2_Release(doc_owner);
7528     free_bstrs();
7529 }
7530
7531 static void test_setAttributeNode(void)
7532 {
7533     IXMLDOMDocument *doc, *doc2;
7534     IXMLDOMElement *elem, *elem2;
7535     IXMLDOMAttribute *attr, *attr2, *ret_attr;
7536     VARIANT_BOOL b;
7537     HRESULT hr;
7538     VARIANT v;
7539     BSTR str;
7540     ULONG ref1, ref2;
7541
7542     doc = create_document(&IID_IXMLDOMDocument);
7543
7544     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7545     ok( hr == S_OK, "loadXML failed\n");
7546     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7547
7548     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7549     ok( hr == S_OK, "got 0x%08x\n", hr);
7550
7551     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
7552     ok( hr == S_OK, "got 0x%08x\n", hr);
7553     ok( elem2 != elem, "got same instance\n");
7554
7555     ret_attr = (void*)0xdeadbeef;
7556     hr = IXMLDOMElement_setAttributeNode(elem, NULL, &ret_attr);
7557     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
7558     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7559
7560     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
7561     ok( hr == S_OK, "got 0x%08x\n", hr);
7562
7563     ref1 = IXMLDOMElement_AddRef(elem);
7564     IXMLDOMElement_Release(elem);
7565
7566     ret_attr = (void*)0xdeadbeef;
7567     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7568     ok( hr == S_OK, "got 0x%08x\n", hr);
7569     ok( ret_attr == NULL, "got %p\n", ret_attr);
7570
7571     /* no reference added */
7572     ref2 = IXMLDOMElement_AddRef(elem);
7573     IXMLDOMElement_Release(elem);
7574     ok(ref2 == ref1, "got %d, expected %d\n", ref2, ref1);
7575
7576     EXPECT_CHILDREN(elem);
7577     EXPECT_CHILDREN(elem2);
7578
7579     IXMLDOMElement_Release(elem2);
7580
7581     attr2 = NULL;
7582     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attr"), &attr2);
7583     ok( hr == S_OK, "got 0x%08x\n", hr);
7584     ok( attr2 != attr, "got same instance %p\n", attr2);
7585     IXMLDOMAttribute_Release(attr2);
7586
7587     /* try to add it another time */
7588     ret_attr = (void*)0xdeadbeef;
7589     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7590     ok( hr == E_FAIL, "got 0x%08x\n", hr);
7591     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7592
7593     IXMLDOMElement_Release(elem);
7594
7595     /* initially used element is released, attribute still 'has' a container */
7596     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7597     ok( hr == S_OK, "got 0x%08x\n", hr);
7598     ret_attr = (void*)0xdeadbeef;
7599     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7600     ok( hr == E_FAIL, "got 0x%08x\n", hr);
7601     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7602     IXMLDOMElement_Release(elem);
7603
7604     /* add attribute already attached to another document */
7605     doc2 = create_document(&IID_IXMLDOMDocument);
7606
7607     hr = IXMLDOMDocument_loadXML( doc2, _bstr_(complete4A), &b );
7608     ok( hr == S_OK, "loadXML failed\n");
7609     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7610
7611     hr = IXMLDOMDocument_get_documentElement(doc2, &elem);
7612     ok( hr == S_OK, "got 0x%08x\n", hr);
7613     hr = IXMLDOMElement_setAttributeNode(elem, attr, NULL);
7614     ok( hr == E_FAIL, "got 0x%08x\n", hr);
7615     IXMLDOMElement_Release(elem);
7616
7617     IXMLDOMAttribute_Release(attr);
7618
7619     /* create element, add attribute, see if it's copied or linked */
7620     hr = IXMLDOMDocument_createElement(doc, _bstr_("test"), &elem);
7621     ok( hr == S_OK, "got 0x%08x\n", hr);
7622
7623     attr = NULL;
7624     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
7625     ok(hr == S_OK, "got 0x%08x\n", hr);
7626     ok(attr != NULL, "got %p\n", attr);
7627
7628     ref1 = IXMLDOMAttribute_AddRef(attr);
7629     IXMLDOMAttribute_Release(attr);
7630
7631     V_VT(&v) = VT_BSTR;
7632     V_BSTR(&v) = _bstr_("attrvalue1");
7633     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
7634     ok( hr == S_OK, "got 0x%08x\n", hr);
7635
7636     str = NULL;
7637     hr = IXMLDOMAttribute_get_xml(attr, &str);
7638     ok( hr == S_OK, "got 0x%08x\n", hr);
7639     ok( lstrcmpW(str, _bstr_("attr=\"attrvalue1\"")) == 0,
7640         "got %s\n", wine_dbgstr_w(str));
7641     SysFreeString(str);
7642
7643     ret_attr = (void*)0xdeadbeef;
7644     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7645     ok(hr == S_OK, "got 0x%08x\n", hr);
7646     ok(ret_attr == NULL, "got %p\n", ret_attr);
7647
7648     /* attribute reference increased */
7649     ref2 = IXMLDOMAttribute_AddRef(attr);
7650     IXMLDOMAttribute_Release(attr);
7651     ok(ref1 == ref2, "got %d, expected %d\n", ref2, ref1);
7652
7653     hr = IXMLDOMElement_get_xml(elem, &str);
7654     ok( hr == S_OK, "got 0x%08x\n", hr);
7655     ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue1\"/>")) == 0,
7656         "got %s\n", wine_dbgstr_w(str));
7657     SysFreeString(str);
7658
7659     V_VT(&v) = VT_BSTR;
7660     V_BSTR(&v) = _bstr_("attrvalue2");
7661     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
7662     ok( hr == S_OK, "got 0x%08x\n", hr);
7663
7664     hr = IXMLDOMElement_get_xml(elem, &str);
7665     ok( hr == S_OK, "got 0x%08x\n", hr);
7666     todo_wine ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue2\"/>")) == 0,
7667         "got %s\n", wine_dbgstr_w(str));
7668     SysFreeString(str);
7669
7670     IXMLDOMElement_Release(elem);
7671     IXMLDOMAttribute_Release(attr);
7672     IXMLDOMDocument_Release(doc2);
7673     IXMLDOMDocument_Release(doc);
7674     free_bstrs();
7675 }
7676
7677 static void test_createNode(void)
7678 {
7679     IXMLDOMDocument *doc;
7680     IXMLDOMElement *elem;
7681     IXMLDOMNode *node;
7682     VARIANT v, var;
7683     BSTR prefix, str;
7684     HRESULT hr;
7685     ULONG ref;
7686
7687     doc = create_document(&IID_IXMLDOMDocument);
7688
7689     EXPECT_REF(doc, 1);
7690
7691     /* reference count tests */
7692     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
7693     ok( hr == S_OK, "got 0x%08x\n", hr);
7694
7695     /* initial reference is 2 */
7696 todo_wine {
7697     EXPECT_REF(elem, 2);
7698     ref = IXMLDOMElement_Release(elem);
7699     ok(ref == 1, "got %d\n", ref);
7700     /* it's released already, attempt to release now will crash it */
7701 }
7702
7703     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
7704     ok( hr == S_OK, "got 0x%08x\n", hr);
7705     todo_wine EXPECT_REF(elem, 2);
7706     IXMLDOMDocument_Release(doc);
7707     todo_wine EXPECT_REF(elem, 2);
7708     IXMLDOMElement_Release(elem);
7709
7710     doc = create_document(&IID_IXMLDOMDocument);
7711
7712     /* NODE_ELEMENT nodes */
7713     /* 1. specified namespace */
7714     V_VT(&v) = VT_I4;
7715     V_I4(&v) = NODE_ELEMENT;
7716
7717     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("ns1:test"), _bstr_("http://winehq.org"), &node);
7718     ok( hr == S_OK, "got 0x%08x\n", hr);
7719     prefix = NULL;
7720     hr = IXMLDOMNode_get_prefix(node, &prefix);
7721     ok( hr == S_OK, "got 0x%08x\n", hr);
7722     ok(lstrcmpW(prefix, _bstr_("ns1")) == 0, "wrong prefix\n");
7723     SysFreeString(prefix);
7724     IXMLDOMNode_Release(node);
7725
7726     /* 2. default namespace */
7727     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("test"), _bstr_("http://winehq.org/default"), &node);
7728     ok( hr == S_OK, "got 0x%08x\n", hr);
7729     prefix = (void*)0xdeadbeef;
7730     hr = IXMLDOMNode_get_prefix(node, &prefix);
7731     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7732     ok(prefix == 0, "expected empty prefix, got %p\n", prefix);
7733     /* check dump */
7734     hr = IXMLDOMNode_get_xml(node, &str);
7735     ok( hr == S_OK, "got 0x%08x\n", hr);
7736     ok( lstrcmpW(str, _bstr_("<test xmlns=\"http://winehq.org/default\"/>")) == 0,
7737         "got %s\n", wine_dbgstr_w(str));
7738     SysFreeString(str);
7739
7740     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
7741     ok( hr == S_OK, "got 0x%08x\n", hr);
7742
7743     V_VT(&var) = VT_BSTR;
7744     hr = IXMLDOMElement_getAttribute(elem, _bstr_("xmlns"), &var);
7745     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7746     ok( V_VT(&var) == VT_NULL, "got %d\n", V_VT(&var));
7747
7748     str = NULL;
7749     hr = IXMLDOMElement_get_namespaceURI(elem, &str);
7750     ok( hr == S_OK, "got 0x%08x\n", hr);
7751     ok( lstrcmpW(str, _bstr_("http://winehq.org/default")) == 0, "expected default namespace\n");
7752     SysFreeString(str);
7753
7754     IXMLDOMElement_Release(elem);
7755     IXMLDOMNode_Release(node);
7756
7757     IXMLDOMDocument_Release(doc);
7758     free_bstrs();
7759 }
7760
7761 static const char get_prefix_doc[] =
7762     "<?xml version=\"1.0\" ?>"
7763     "<a xmlns:ns1=\"ns1 href\" />";
7764
7765 static void test_get_prefix(void)
7766 {
7767     IXMLDOMDocumentFragment *fragment;
7768     IXMLDOMCDATASection *cdata;
7769     IXMLDOMElement *element;
7770     IXMLDOMComment *comment;
7771     IXMLDOMDocument *doc;
7772     VARIANT_BOOL b;
7773     HRESULT hr;
7774     BSTR str;
7775
7776     doc = create_document(&IID_IXMLDOMDocument);
7777
7778     /* nodes that can't support prefix */
7779     /* 1. document */
7780     str = (void*)0xdeadbeef;
7781     hr = IXMLDOMDocument_get_prefix(doc, &str);
7782     EXPECT_HR(hr, S_FALSE);
7783     ok(str == NULL, "got %p\n", str);
7784
7785     hr = IXMLDOMDocument_get_prefix(doc, NULL);
7786     EXPECT_HR(hr, E_INVALIDARG);
7787
7788     /* 2. cdata */
7789     hr = IXMLDOMDocument_createCDATASection(doc, NULL, &cdata);
7790     ok(hr == S_OK, "got %08x\n", hr );
7791
7792     str = (void*)0xdeadbeef;
7793     hr = IXMLDOMCDATASection_get_prefix(cdata, &str);
7794     ok(hr == S_FALSE, "got %08x\n", hr);
7795     ok( str == 0, "got %p\n", str);
7796
7797     hr = IXMLDOMCDATASection_get_prefix(cdata, NULL);
7798     ok(hr == E_INVALIDARG, "got %08x\n", hr);
7799     IXMLDOMCDATASection_Release(cdata);
7800
7801     /* 3. comment */
7802     hr = IXMLDOMDocument_createComment(doc, NULL, &comment);
7803     ok(hr == S_OK, "got %08x\n", hr );
7804
7805     str = (void*)0xdeadbeef;
7806     hr = IXMLDOMComment_get_prefix(comment, &str);
7807     ok(hr == S_FALSE, "got %08x\n", hr);
7808     ok( str == 0, "got %p\n", str);
7809
7810     hr = IXMLDOMComment_get_prefix(comment, NULL);
7811     ok(hr == E_INVALIDARG, "got %08x\n", hr);
7812     IXMLDOMComment_Release(comment);
7813
7814     /* 4. fragment */
7815     hr = IXMLDOMDocument_createDocumentFragment(doc, &fragment);
7816     ok(hr == S_OK, "got %08x\n", hr );
7817
7818     str = (void*)0xdeadbeef;
7819     hr = IXMLDOMDocumentFragment_get_prefix(fragment, &str);
7820     ok(hr == S_FALSE, "got %08x\n", hr);
7821     ok( str == 0, "got %p\n", str);
7822
7823     hr = IXMLDOMDocumentFragment_get_prefix(fragment, NULL);
7824     ok(hr == E_INVALIDARG, "got %08x\n", hr);
7825     IXMLDOMDocumentFragment_Release(fragment);
7826
7827     /* no prefix */
7828     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &element);
7829     ok( hr == S_OK, "got 0x%08x\n", hr);
7830
7831     hr = IXMLDOMElement_get_prefix(element, NULL);
7832     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
7833
7834     str = (void*)0xdeadbeef;
7835     hr = IXMLDOMElement_get_prefix(element, &str);
7836     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7837     ok( str == 0, "got %p\n", str);
7838
7839     IXMLDOMElement_Release(element);
7840
7841     /* with prefix */
7842     hr = IXMLDOMDocument_createElement(doc, _bstr_("a:elem"), &element);
7843     ok( hr == S_OK, "got 0x%08x\n", hr);
7844
7845     str = (void*)0xdeadbeef;
7846     hr = IXMLDOMElement_get_prefix(element, &str);
7847     ok( hr == S_OK, "got 0x%08x\n", hr);
7848     ok( lstrcmpW(str, _bstr_("a")) == 0, "expected prefix \"a\"\n");
7849     SysFreeString(str);
7850
7851     str = (void*)0xdeadbeef;
7852     hr = IXMLDOMElement_get_namespaceURI(element, &str);
7853     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7854     ok( str == 0, "got %p\n", str);
7855
7856     IXMLDOMElement_Release(element);
7857
7858     hr = IXMLDOMDocument_loadXML(doc, _bstr_(get_prefix_doc), &b);
7859     EXPECT_HR(hr, S_OK);
7860
7861     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7862     EXPECT_HR(hr, S_OK);
7863
7864     str = (void*)0xdeadbeef;
7865     hr = IXMLDOMElement_get_prefix(element, &str);
7866     EXPECT_HR(hr, S_FALSE);
7867     ok(str == NULL, "got %p\n", str);
7868
7869     str = (void*)0xdeadbeef;
7870     hr = IXMLDOMElement_get_namespaceURI(element, &str);
7871     EXPECT_HR(hr, S_FALSE);
7872     ok(str == NULL, "got %s\n", wine_dbgstr_w(str));
7873
7874     IXMLDOMDocument_Release(doc);
7875     free_bstrs();
7876 }
7877
7878 static void test_selectSingleNode(void)
7879 {
7880     IXMLDOMDocument *doc;
7881     IXMLDOMNodeList *list;
7882     IXMLDOMNode *node;
7883     VARIANT_BOOL b;
7884     HRESULT hr;
7885     LONG len;
7886
7887     doc = create_document(&IID_IXMLDOMDocument);
7888
7889     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
7890     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7891
7892     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
7893     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7894
7895     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7896     ok( hr == S_OK, "loadXML failed\n");
7897     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7898
7899     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
7900     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7901
7902     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
7903     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7904
7905     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), NULL);
7906     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7907
7908     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), NULL);
7909     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7910
7911     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), &node);
7912     ok(hr == S_OK, "got 0x%08x\n", hr);
7913     IXMLDOMNode_Release(node);
7914
7915     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), &list);
7916     ok(hr == S_OK, "got 0x%08x\n", hr);
7917     IXMLDOMNodeList_Release(list);
7918
7919     list = (void*)0xdeadbeef;
7920     hr = IXMLDOMDocument_selectNodes(doc, NULL, &list);
7921     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7922     ok(list == (void*)0xdeadbeef, "got %p\n", list);
7923
7924     node = (void*)0xdeadbeef;
7925     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("nonexistent"), &node);
7926     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7927     ok(node == 0, "got %p\n", node);
7928
7929     list = (void*)0xdeadbeef;
7930     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("nonexistent"), &list);
7931     ok(hr == S_OK, "got 0x%08x\n", hr);
7932     len = 1;
7933     hr = IXMLDOMNodeList_get_length(list, &len);
7934     ok(hr == S_OK, "got 0x%08x\n", hr);
7935     ok(len == 0, "got %d\n", len);
7936     IXMLDOMNodeList_Release(list);
7937
7938     IXMLDOMDocument_Release(doc);
7939     free_bstrs();
7940 }
7941
7942 static void test_events(void)
7943 {
7944     IConnectionPointContainer *conn;
7945     IConnectionPoint *point;
7946     IXMLDOMDocument *doc;
7947     HRESULT hr;
7948     VARIANT v;
7949     IDispatch *event;
7950
7951     doc = create_document(&IID_IXMLDOMDocument);
7952
7953     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&conn);
7954     ok(hr == S_OK, "got 0x%08x\n", hr);
7955
7956     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IDispatch, &point);
7957     ok(hr == S_OK, "got 0x%08x\n", hr);
7958     IConnectionPoint_Release(point);
7959     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IPropertyNotifySink, &point);
7960     ok(hr == S_OK, "got 0x%08x\n", hr);
7961     IConnectionPoint_Release(point);
7962     hr = IConnectionPointContainer_FindConnectionPoint(conn, &DIID_XMLDOMDocumentEvents, &point);
7963     ok(hr == S_OK, "got 0x%08x\n", hr);
7964     IConnectionPoint_Release(point);
7965
7966     IConnectionPointContainer_Release(conn);
7967
7968     /* ready state callback */
7969     VariantInit(&v);
7970     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7971     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
7972
7973     event = create_dispevent();
7974     V_VT(&v) = VT_UNKNOWN;
7975     V_UNKNOWN(&v) = (IUnknown*)event;
7976
7977     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7978     ok(hr == S_OK, "got 0x%08x\n", hr);
7979     EXPECT_REF(event, 2);
7980
7981     V_VT(&v) = VT_DISPATCH;
7982     V_DISPATCH(&v) = event;
7983
7984     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7985     ok(hr == S_OK, "got 0x%08x\n", hr);
7986     EXPECT_REF(event, 2);
7987
7988     /* VT_NULL doesn't reset event handler */
7989     V_VT(&v) = VT_NULL;
7990     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7991     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
7992     EXPECT_REF(event, 2);
7993
7994     V_VT(&v) = VT_DISPATCH;
7995     V_DISPATCH(&v) = NULL;
7996
7997     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7998     ok(hr == S_OK, "got 0x%08x\n", hr);
7999     EXPECT_REF(event, 1);
8000
8001     V_VT(&v) = VT_UNKNOWN;
8002     V_DISPATCH(&v) = NULL;
8003     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8004     ok(hr == S_OK, "got 0x%08x\n", hr);
8005
8006     IDispatch_Release(event);
8007
8008     IXMLDOMDocument_Release(doc);
8009 }
8010
8011 static void test_createProcessingInstruction(void)
8012 {
8013     static const WCHAR bodyW[] = {'t','e','s','t',0};
8014     IXMLDOMProcessingInstruction *pi;
8015     IXMLDOMDocument *doc;
8016     WCHAR buff[10];
8017     HRESULT hr;
8018
8019     doc = create_document(&IID_IXMLDOMDocument);
8020
8021     /* test for BSTR handling, pass broken BSTR */
8022     memcpy(&buff[2], bodyW, sizeof(bodyW));
8023     /* just a big length */
8024     *(DWORD*)buff = 0xf0f0;
8025     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("test"), &buff[2], &pi);
8026     ok(hr == S_OK, "got 0x%08x\n", hr);
8027
8028     IXMLDOMProcessingInstruction_Release(pi);
8029     IXMLDOMDocument_Release(doc);
8030 }
8031
8032 static void test_put_nodeTypedValue(void)
8033 {
8034     static const BYTE binhexdata[16] =
8035         {0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf};
8036     IXMLDOMDocument *doc;
8037     IXMLDOMElement *elem;
8038     VARIANT type, value;
8039     LONG ubound, lbound;
8040     IXMLDOMNode *node;
8041     SAFEARRAY *array;
8042     HRESULT hr;
8043     BYTE *ptr;
8044     BSTR str;
8045
8046     doc = create_document(&IID_IXMLDOMDocument);
8047
8048     hr = IXMLDOMDocument_createElement(doc, _bstr_("Element"), &elem);
8049     EXPECT_HR(hr, S_OK);
8050
8051     V_VT(&type) = VT_EMPTY;
8052     hr = IXMLDOMElement_get_dataType(elem, &type);
8053     EXPECT_HR(hr, S_FALSE);
8054     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8055
8056     /* set typed value for untyped node */
8057     V_VT(&type) = VT_I1;
8058     V_I1(&type) = 1;
8059     hr = IXMLDOMElement_put_nodeTypedValue(elem, type);
8060     EXPECT_HR(hr, S_OK);
8061
8062     V_VT(&type) = VT_EMPTY;
8063     hr = IXMLDOMElement_get_dataType(elem, &type);
8064     EXPECT_HR(hr, S_FALSE);
8065     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8066
8067     /* no type info stored */
8068     V_VT(&type) = VT_EMPTY;
8069     hr = IXMLDOMElement_get_nodeTypedValue(elem, &type);
8070     EXPECT_HR(hr, S_OK);
8071     ok(V_VT(&type) == VT_BSTR, "got %d, expected VT_BSTR\n", V_VT(&type));
8072     ok(memcmp(V_BSTR(&type), _bstr_("1"), 2*sizeof(WCHAR)) == 0,
8073        "got %s, expected \"1\"\n", wine_dbgstr_w(V_BSTR(&type)));
8074     VariantClear(&type);
8075
8076     hr = IXMLDOMElement_get_firstChild(elem, &node);
8077     EXPECT_HR(hr, S_OK);
8078     hr = IXMLDOMElement_removeChild(elem, node, NULL);
8079     EXPECT_HR(hr, S_OK);
8080     IXMLDOMNode_Release(node);
8081
8082     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)elem, NULL);
8083     EXPECT_HR(hr, S_OK);
8084
8085     /* bin.base64 */
8086     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.base64"));
8087     EXPECT_HR(hr, S_OK);
8088
8089     V_VT(&value) = VT_BSTR;
8090     V_BSTR(&value) = _bstr_("ABCD");
8091     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8092     EXPECT_HR(hr, S_OK);
8093
8094     V_VT(&value) = VT_EMPTY;
8095     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8096     EXPECT_HR(hr, S_OK);
8097     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8098     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8099     ubound = 0;
8100     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8101     EXPECT_HR(hr, S_OK);
8102     ok(ubound == 2, "got %d\n", ubound);
8103     lbound = 0;
8104     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8105     EXPECT_HR(hr, S_OK);
8106     ok(lbound == 0, "got %d\n", lbound);
8107     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8108     EXPECT_HR(hr, S_OK);
8109     ok(ptr[0] == 0, "got %x\n", ptr[0]);
8110     ok(ptr[1] == 0x10, "got %x\n", ptr[1]);
8111     ok(ptr[2] == 0x83, "got %x\n", ptr[2]);
8112     SafeArrayUnaccessData(V_ARRAY(&value));
8113     VariantClear(&value);
8114
8115     /* when set as VT_BSTR it's stored as is */
8116     hr = IXMLDOMElement_get_firstChild(elem, &node);
8117     EXPECT_HR(hr, S_OK);
8118     hr = IXMLDOMNode_get_text(node, &str);
8119     EXPECT_HR(hr, S_OK);
8120     ok(!lstrcmpW(str, _bstr_("ABCD")), "%s\n", wine_dbgstr_w(str));
8121     IXMLDOMNode_Release(node);
8122
8123     array = SafeArrayCreateVector(VT_UI1, 0, 7);
8124     hr = SafeArrayAccessData(array, (void*)&ptr);
8125     EXPECT_HR(hr, S_OK);
8126     memcpy(ptr, "dGVzdA=", strlen("dGVzdA="));
8127     SafeArrayUnaccessData(array);
8128
8129     V_VT(&value) = VT_UI1|VT_ARRAY;
8130     V_ARRAY(&value) = array;
8131     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8132     EXPECT_HR(hr, S_OK);
8133
8134     V_VT(&value) = VT_EMPTY;
8135     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8136     EXPECT_HR(hr, S_OK);
8137     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8138     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8139     ubound = 0;
8140     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8141     EXPECT_HR(hr, S_OK);
8142     ok(ubound == 6, "got %d\n", ubound);
8143     lbound = 0;
8144     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8145     EXPECT_HR(hr, S_OK);
8146     ok(lbound == 0, "got %d\n", lbound);
8147     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8148     EXPECT_HR(hr, S_OK);
8149     ok(!memcmp(ptr, "dGVzdA=", strlen("dGVzdA=")), "got wrong data, %s\n", ptr);
8150     SafeArrayUnaccessData(V_ARRAY(&value));
8151     VariantClear(&value);
8152
8153     /* if set with VT_UI1|VT_ARRAY it's encoded */
8154     hr = IXMLDOMElement_get_firstChild(elem, &node);
8155     EXPECT_HR(hr, S_OK);
8156     hr = IXMLDOMNode_get_text(node, &str);
8157     EXPECT_HR(hr, S_OK);
8158     ok(!lstrcmpW(str, _bstr_("ZEdWemRBPQ==")), "%s\n", wine_dbgstr_w(str));
8159     IXMLDOMNode_Release(node);
8160     SafeArrayDestroyData(array);
8161
8162     /* bin.hex */
8163     V_VT(&value) = VT_BSTR;
8164     V_BSTR(&value) = _bstr_("");
8165     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8166     EXPECT_HR(hr, S_OK);
8167
8168     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.hex"));
8169     EXPECT_HR(hr, S_OK);
8170
8171     array = SafeArrayCreateVector(VT_UI1, 0, 16);
8172     hr = SafeArrayAccessData(array, (void*)&ptr);
8173     EXPECT_HR(hr, S_OK);
8174     memcpy(ptr, binhexdata, sizeof(binhexdata));
8175     SafeArrayUnaccessData(array);
8176
8177     V_VT(&value) = VT_UI1|VT_ARRAY;
8178     V_ARRAY(&value) = array;
8179     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8180     EXPECT_HR(hr, S_OK);
8181
8182     V_VT(&value) = VT_EMPTY;
8183     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8184     EXPECT_HR(hr, S_OK);
8185     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8186     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8187     ubound = 0;
8188     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8189     EXPECT_HR(hr, S_OK);
8190     ok(ubound == 15, "got %d\n", ubound);
8191     lbound = 0;
8192     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8193     EXPECT_HR(hr, S_OK);
8194     ok(lbound == 0, "got %d\n", lbound);
8195     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8196     EXPECT_HR(hr, S_OK);
8197     ok(!memcmp(ptr, binhexdata, sizeof(binhexdata)), "got wrong data\n");
8198     SafeArrayUnaccessData(V_ARRAY(&value));
8199     VariantClear(&value);
8200
8201     /* if set with VT_UI1|VT_ARRAY it's encoded */
8202     hr = IXMLDOMElement_get_firstChild(elem, &node);
8203     EXPECT_HR(hr, S_OK);
8204     hr = IXMLDOMNode_get_text(node, &str);
8205     EXPECT_HR(hr, S_OK);
8206     ok(!lstrcmpW(str, _bstr_("000102030405060708090a0b0c0d0e0f")), "%s\n", wine_dbgstr_w(str));
8207     IXMLDOMNode_Release(node);
8208     SafeArrayDestroyData(array);
8209
8210     IXMLDOMElement_Release(elem);
8211     IXMLDOMDocument_Release(doc);
8212     free_bstrs();
8213 }
8214
8215 static void test_get_xml(void)
8216 {
8217     static const char xmlA[] = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\r\n<a>test</a>\r\n";
8218     static const char attrA[] = "attr=\"&quot;a &amp; b&quot;\"";
8219     static const char attr2A[] = "\"a & b\"";
8220     static const char attr3A[] = "attr=\"&amp;quot;a\"";
8221     static const char attr4A[] = "&quot;a";
8222     static const char fooA[] = "<foo/>";
8223     IXMLDOMProcessingInstruction *pi;
8224     IXMLDOMNode *first;
8225     IXMLDOMElement *elem = NULL;
8226     IXMLDOMAttribute *attr;
8227     IXMLDOMDocument *doc;
8228     VARIANT_BOOL b;
8229     VARIANT v;
8230     BSTR xml;
8231     HRESULT hr;
8232
8233     doc = create_document(&IID_IXMLDOMDocument);
8234
8235     b = VARIANT_TRUE;
8236     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8237     ok(hr == S_OK, "got 0x%08x\n", hr);
8238     ok( b == VARIANT_TRUE, "got %d\n", b);
8239
8240     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"),
8241                              _bstr_("version=\"1.0\" encoding=\"UTF-16\""), &pi);
8242     ok(hr == S_OK, "got 0x%08x\n", hr);
8243
8244     hr = IXMLDOMDocument_get_firstChild(doc, &first);
8245     ok(hr == S_OK, "got 0x%08x\n", hr);
8246
8247     V_UNKNOWN(&v) = (IUnknown*)first;
8248     V_VT(&v) = VT_UNKNOWN;
8249
8250     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)pi, v, NULL);
8251     ok(hr == S_OK, "got 0x%08x\n", hr);
8252
8253     IXMLDOMProcessingInstruction_Release(pi);
8254     IXMLDOMNode_Release(first);
8255
8256     hr = IXMLDOMDocument_get_xml(doc, &xml);
8257     ok(hr == S_OK, "got 0x%08x\n", hr);
8258
8259     ok(memcmp(xml, _bstr_(xmlA), sizeof(xmlA)*sizeof(WCHAR)) == 0,
8260         "got %s, expected %s\n", wine_dbgstr_w(xml), xmlA);
8261     SysFreeString(xml);
8262
8263     IXMLDOMDocument_Release(doc);
8264
8265     doc = create_document(&IID_IXMLDOMDocument);
8266
8267     hr = IXMLDOMDocument_createElement(doc, _bstr_("foo"), &elem);
8268     ok(hr == S_OK, "got 0x%08x\n", hr);
8269
8270     hr = IXMLDOMDocument_putref_documentElement(doc, elem);
8271     ok(hr == S_OK, "got 0x%08x\n", hr);
8272
8273     hr = IXMLDOMDocument_get_xml(doc, &xml);
8274     ok(hr == S_OK, "got 0x%08x\n", hr);
8275
8276     ok(memcmp(xml, _bstr_(fooA), (sizeof(fooA)-1)*sizeof(WCHAR)) == 0,
8277         "got %s, expected %s\n", wine_dbgstr_w(xml), fooA);
8278     SysFreeString(xml);
8279
8280     IXMLDOMElement_Release(elem);
8281
8282     /* attribute node */
8283     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8284     ok(hr == S_OK, "got 0x%08x\n", hr);
8285
8286     V_VT(&v) = VT_BSTR;
8287     V_BSTR(&v) = _bstr_("\"a & b\"");
8288     hr = IXMLDOMAttribute_put_value(attr, v);
8289     ok(hr == S_OK, "got 0x%08x\n", hr);
8290
8291     xml = NULL;
8292     hr = IXMLDOMAttribute_get_xml(attr, &xml);
8293     ok(hr == S_OK, "got 0x%08x\n", hr);
8294     ok(!memcmp(xml, _bstr_(attrA), (sizeof(attrA)-1)*sizeof(WCHAR)), "got %s\n", wine_dbgstr_w(xml));
8295     SysFreeString(xml);
8296
8297     VariantInit(&v);
8298     hr = IXMLDOMAttribute_get_value(attr, &v);
8299     ok(hr == S_OK, "got 0x%08x\n", hr);
8300     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8301     ok(!memcmp(V_BSTR(&v), _bstr_(attr2A), (sizeof(attr2A)-1)*sizeof(WCHAR)),
8302         "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8303     VariantClear(&v);
8304
8305     V_VT(&v) = VT_BSTR;
8306     V_BSTR(&v) = _bstr_("&quot;a");
8307     hr = IXMLDOMAttribute_put_value(attr, v);
8308     ok(hr == S_OK, "got 0x%08x\n", hr);
8309
8310     xml = NULL;
8311     hr = IXMLDOMAttribute_get_xml(attr, &xml);
8312     ok(hr == S_OK, "got 0x%08x\n", hr);
8313     ok(!memcmp(xml, _bstr_(attr3A), (sizeof(attr3A)-1)*sizeof(WCHAR)), "got %s\n", wine_dbgstr_w(xml));
8314     SysFreeString(xml);
8315
8316     VariantInit(&v);
8317     hr = IXMLDOMAttribute_get_value(attr, &v);
8318     ok(hr == S_OK, "got 0x%08x\n", hr);
8319     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8320     ok(!memcmp(V_BSTR(&v), _bstr_(attr4A), (sizeof(attr4A)-1)*sizeof(WCHAR)),
8321         "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8322     VariantClear(&v);
8323
8324     IXMLDOMAttribute_Release(attr);
8325
8326     IXMLDOMDocument_Release(doc);
8327
8328     free_bstrs();
8329 }
8330
8331 static void test_xsltemplate(void)
8332 {
8333     IXSLTemplate *template;
8334     IXSLProcessor *processor;
8335     IXMLDOMDocument *doc, *doc2;
8336     IStream *stream;
8337     VARIANT_BOOL b;
8338     HRESULT hr;
8339     ULONG ref1, ref2;
8340     VARIANT v;
8341
8342     if (!is_clsid_supported(&CLSID_XSLTemplate, &IID_IXSLTemplate)) return;
8343     template = create_xsltemplate(&IID_IXSLTemplate);
8344
8345     /* works as reset */
8346     hr = IXSLTemplate_putref_stylesheet(template, NULL);
8347     ok(hr == S_OK, "got 0x%08x\n", hr);
8348
8349     doc = create_document(&IID_IXMLDOMDocument);
8350
8351     b = VARIANT_TRUE;
8352     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8353     ok(hr == S_OK, "got 0x%08x\n", hr);
8354     ok( b == VARIANT_TRUE, "got %d\n", b);
8355
8356     /* putref with non-xsl document */
8357     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8358     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8359
8360     b = VARIANT_TRUE;
8361     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8362     ok(hr == S_OK, "got 0x%08x\n", hr);
8363     ok( b == VARIANT_TRUE, "got %d\n", b);
8364
8365     /* not a freethreaded document */
8366     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8367     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8368
8369     IXMLDOMDocument_Release(doc);
8370
8371     if (!is_clsid_supported(&CLSID_FreeThreadedDOMDocument, &IID_IXMLDOMDocument))
8372     {
8373         IXSLTemplate_Release(template);
8374         return;
8375     }
8376
8377     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
8378     ok(hr == S_OK, "got 0x%08x\n", hr);
8379
8380     b = VARIANT_TRUE;
8381     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8382     ok(hr == S_OK, "got 0x%08x\n", hr);
8383     ok( b == VARIANT_TRUE, "got %d\n", b);
8384
8385     /* freethreaded document */
8386     ref1 = IXMLDOMDocument_AddRef(doc);
8387     IXMLDOMDocument_Release(doc);
8388     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8389     ok(hr == S_OK, "got 0x%08x\n", hr);
8390     ref2 = IXMLDOMDocument_AddRef(doc);
8391     IXMLDOMDocument_Release(doc);
8392     ok(ref2 > ref1, "got %d\n", ref2);
8393
8394     /* processor */
8395     hr = IXSLTemplate_createProcessor(template, NULL);
8396     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8397
8398     EXPECT_REF(template, 1);
8399     hr = IXSLTemplate_createProcessor(template, &processor);
8400     ok(hr == S_OK, "got 0x%08x\n", hr);
8401     EXPECT_REF(template, 2);
8402
8403     /* input no set yet */
8404     V_VT(&v) = VT_BSTR;
8405     V_BSTR(&v) = NULL;
8406     hr = IXSLProcessor_get_input(processor, &v);
8407 todo_wine {
8408     ok(hr == S_OK, "got 0x%08x\n", hr);
8409     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
8410 }
8411
8412     hr = IXSLProcessor_get_output(processor, NULL);
8413     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8414
8415     /* reset before it was set */
8416     V_VT(&v) = VT_EMPTY;
8417     hr = IXSLProcessor_put_output(processor, v);
8418     ok(hr == S_OK, "got 0x%08x\n", hr);
8419
8420     CreateStreamOnHGlobal(NULL, TRUE, &stream);
8421     EXPECT_REF(stream, 1);
8422
8423     V_VT(&v) = VT_UNKNOWN;
8424     V_UNKNOWN(&v) = (IUnknown*)stream;
8425     hr = IXSLProcessor_put_output(processor, v);
8426     ok(hr == S_OK, "got 0x%08x\n", hr);
8427
8428     /* it seems processor grabs 2 references */
8429     todo_wine EXPECT_REF(stream, 3);
8430
8431     V_VT(&v) = VT_EMPTY;
8432     hr = IXSLProcessor_get_output(processor, &v);
8433     ok(hr == S_OK, "got 0x%08x\n", hr);
8434     ok(V_VT(&v) == VT_UNKNOWN, "got type %d\n", V_VT(&v));
8435     ok(V_UNKNOWN(&v) == (IUnknown*)stream, "got %p\n", V_UNKNOWN(&v));
8436
8437     todo_wine EXPECT_REF(stream, 4);
8438     VariantClear(&v);
8439
8440     hr = IXSLProcessor_transform(processor, NULL);
8441     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8442
8443     /* reset and check stream refcount */
8444     V_VT(&v) = VT_EMPTY;
8445     hr = IXSLProcessor_put_output(processor, v);
8446     ok(hr == S_OK, "got 0x%08x\n", hr);
8447
8448     EXPECT_REF(stream, 1);
8449
8450     IStream_Release(stream);
8451
8452     /* no output interface set, check output */
8453     doc2 = create_document(&IID_IXMLDOMDocument);
8454
8455     b = VARIANT_TRUE;
8456     hr = IXMLDOMDocument_loadXML( doc2, _bstr_("<a>test</a>"), &b );
8457     ok(hr == S_OK, "got 0x%08x\n", hr);
8458     ok( b == VARIANT_TRUE, "got %d\n", b);
8459
8460     V_VT(&v) = VT_UNKNOWN;
8461     V_UNKNOWN(&v) = (IUnknown*)doc2;
8462     hr = IXSLProcessor_put_input(processor, v);
8463     ok(hr == S_OK, "got 0x%08x\n", hr);
8464
8465     hr = IXSLProcessor_transform(processor, &b);
8466     ok(hr == S_OK, "got 0x%08x\n", hr);
8467
8468     V_VT(&v) = VT_EMPTY;
8469     hr = IXSLProcessor_get_output(processor, &v);
8470     ok(hr == S_OK, "got 0x%08x\n", hr);
8471     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8472     ok(lstrcmpW(V_BSTR(&v), _bstr_("")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8473     IXMLDOMDocument_Release(doc2);
8474     VariantClear(&v);
8475
8476     IXSLProcessor_Release(processor);
8477
8478     /* drop reference */
8479     hr = IXSLTemplate_putref_stylesheet(template, NULL);
8480     ok(hr == S_OK, "got 0x%08x\n", hr);
8481     ref2 = IXMLDOMDocument_AddRef(doc);
8482     IXMLDOMDocument_Release(doc);
8483     ok(ref2 == ref1, "got %d\n", ref2);
8484
8485     IXMLDOMDocument_Release(doc);
8486     IXSLTemplate_Release(template);
8487     free_bstrs();
8488 }
8489
8490 static void test_insertBefore(void)
8491 {
8492     IXMLDOMDocument *doc, *doc2, *doc3;
8493     IXMLDOMAttribute *attr;
8494     IXMLDOMElement *elem1, *elem2, *elem3, *elem4, *elem5;
8495     IXMLDOMNode *node, *newnode, *cdata;
8496     HRESULT hr;
8497     VARIANT v;
8498     BSTR p;
8499
8500     doc = create_document(&IID_IXMLDOMDocument);
8501     doc3 = create_document(&IID_IXMLDOMDocument);
8502
8503     /* document to document */
8504     V_VT(&v) = VT_NULL;
8505     node = (void*)0xdeadbeef;
8506     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)doc3, v, &node);
8507     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8508     ok(node == NULL, "got %p\n", node);
8509
8510     /* document to itself */
8511     V_VT(&v) = VT_NULL;
8512     node = (void*)0xdeadbeef;
8513     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)doc, v, &node);
8514     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8515     ok(node == NULL, "got %p\n", node);
8516
8517     /* insertBefore behaviour for attribute node */
8518     V_VT(&v) = VT_I4;
8519     V_I4(&v) = NODE_ATTRIBUTE;
8520
8521     attr = NULL;
8522     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr"), NULL, (IXMLDOMNode**)&attr);
8523     ok(hr == S_OK, "got 0x%08x\n", hr);
8524     ok(attr != NULL, "got %p\n", attr);
8525
8526     /* attribute to document */
8527     V_VT(&v) = VT_NULL;
8528     node = (void*)0xdeadbeef;
8529     hr = IXMLDOMDocument_insertBefore(doc3, (IXMLDOMNode*)attr, v, &node);
8530     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8531     ok(node == NULL, "got %p\n", node);
8532
8533     /* cdata to document */
8534     V_VT(&v) = VT_I4;
8535     V_I4(&v) = NODE_CDATA_SECTION;
8536
8537     cdata = NULL;
8538     hr = IXMLDOMDocument_createNode(doc3, v, _bstr_("cdata"), NULL, &cdata);
8539     ok(hr == S_OK, "got 0x%08x\n", hr);
8540     ok(cdata != NULL, "got %p\n", cdata);
8541
8542     EXPECT_NO_CHILDREN(cdata);
8543
8544     /* attribute to cdata */
8545     V_VT(&v) = VT_NULL;
8546     node = (void*)0xdeadbeef;
8547     hr = IXMLDOMNode_insertBefore(cdata, (IXMLDOMNode*)attr, v, &node);
8548     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8549     ok(node == NULL, "got %p\n", node);
8550
8551     /* document to cdata */
8552     V_VT(&v) = VT_NULL;
8553     node = (void*)0xdeadbeef;
8554     hr = IXMLDOMNode_insertBefore(cdata, (IXMLDOMNode*)doc, v, &node);
8555     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8556     ok(node == NULL, "got %p\n", node);
8557
8558     V_VT(&v) = VT_NULL;
8559     node = (void*)0xdeadbeef;
8560     hr = IXMLDOMDocument_insertBefore(doc3, cdata, v, &node);
8561     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8562     ok(node == NULL, "got %p\n", node);
8563
8564     IXMLDOMNode_Release(cdata);
8565     IXMLDOMDocument_Release(doc3);
8566
8567     /* attribute to attribute */
8568     V_VT(&v) = VT_I4;
8569     V_I4(&v) = NODE_ATTRIBUTE;
8570     newnode = NULL;
8571     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr2"), NULL, &newnode);
8572     ok(hr == S_OK, "got 0x%08x\n", hr);
8573     ok(newnode != NULL, "got %p\n", newnode);
8574
8575     V_VT(&v) = VT_NULL;
8576     node = (void*)0xdeadbeef;
8577     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8578     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8579     ok(node == NULL, "got %p\n", node);
8580
8581     V_VT(&v) = VT_UNKNOWN;
8582     V_UNKNOWN(&v) = (IUnknown*)attr;
8583     node = (void*)0xdeadbeef;
8584     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8585     todo_wine ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8586     ok(node == NULL, "got %p\n", node);
8587     IXMLDOMNode_Release(newnode);
8588
8589     /* cdata to attribute */
8590     V_VT(&v) = VT_I4;
8591     V_I4(&v) = NODE_CDATA_SECTION;
8592     newnode = NULL;
8593     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8594     ok(hr == S_OK, "got 0x%08x\n", hr);
8595     ok(newnode != NULL, "got %p\n", newnode);
8596
8597     V_VT(&v) = VT_NULL;
8598     node = (void*)0xdeadbeef;
8599     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8600     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8601     ok(node == NULL, "got %p\n", node);
8602     IXMLDOMNode_Release(newnode);
8603
8604     /* comment to attribute */
8605     V_VT(&v) = VT_I4;
8606     V_I4(&v) = NODE_COMMENT;
8607     newnode = NULL;
8608     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8609     ok(hr == S_OK, "got 0x%08x\n", hr);
8610     ok(newnode != NULL, "got %p\n", newnode);
8611
8612     V_VT(&v) = VT_NULL;
8613     node = (void*)0xdeadbeef;
8614     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8615     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8616     ok(node == NULL, "got %p\n", node);
8617     IXMLDOMNode_Release(newnode);
8618
8619     /* element to attribute */
8620     V_VT(&v) = VT_I4;
8621     V_I4(&v) = NODE_ELEMENT;
8622     newnode = NULL;
8623     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8624     ok(hr == S_OK, "got 0x%08x\n", hr);
8625     ok(newnode != NULL, "got %p\n", newnode);
8626
8627     V_VT(&v) = VT_NULL;
8628     node = (void*)0xdeadbeef;
8629     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8630     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8631     ok(node == NULL, "got %p\n", node);
8632     IXMLDOMNode_Release(newnode);
8633
8634     /* pi to attribute */
8635     V_VT(&v) = VT_I4;
8636     V_I4(&v) = NODE_PROCESSING_INSTRUCTION;
8637     newnode = NULL;
8638     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8639     ok(hr == S_OK, "got 0x%08x\n", hr);
8640     ok(newnode != NULL, "got %p\n", newnode);
8641
8642     V_VT(&v) = VT_NULL;
8643     node = (void*)0xdeadbeef;
8644     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8645     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8646     ok(node == NULL, "got %p\n", node);
8647     IXMLDOMNode_Release(newnode);
8648     IXMLDOMAttribute_Release(attr);
8649
8650     /* insertBefore for elements */
8651     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem1);
8652     ok(hr == S_OK, "got 0x%08x\n", hr);
8653
8654     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem2"), &elem2);
8655     ok(hr == S_OK, "got 0x%08x\n", hr);
8656
8657     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
8658     ok(hr == S_OK, "got 0x%08x\n", hr);
8659
8660     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
8661     ok(hr == S_OK, "got 0x%08x\n", hr);
8662
8663     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem4"), &elem4);
8664     ok(hr == S_OK, "got 0x%08x\n", hr);
8665
8666     EXPECT_NO_CHILDREN(elem1);
8667     EXPECT_NO_CHILDREN(elem2);
8668     EXPECT_NO_CHILDREN(elem3);
8669
8670     todo_wine EXPECT_REF(elem2, 2);
8671
8672     /* document to element */
8673     V_VT(&v) = VT_DISPATCH;
8674     V_DISPATCH(&v) = NULL;
8675     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)doc, v, NULL);
8676     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8677
8678     V_VT(&v) = VT_DISPATCH;
8679     V_DISPATCH(&v) = NULL;
8680     node = NULL;
8681     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem4, v, &node);
8682     ok(hr == S_OK, "got 0x%08x\n", hr);
8683     ok(node == (void*)elem4, "got %p\n", node);
8684
8685     EXPECT_CHILDREN(elem1);
8686     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem4, NULL);
8687     EXPECT_HR(hr, S_OK);
8688     IXMLDOMElement_Release(elem4);
8689
8690     EXPECT_NO_CHILDREN(elem1);
8691
8692     V_VT(&v) = VT_NULL;
8693     node = NULL;
8694     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
8695     ok(hr == S_OK, "got 0x%08x\n", hr);
8696     ok(node == (void*)elem2, "got %p\n", node);
8697
8698     EXPECT_CHILDREN(elem1);
8699     todo_wine EXPECT_REF(elem2, 3);
8700     IXMLDOMNode_Release(node);
8701
8702     /* again for already linked node */
8703     V_VT(&v) = VT_NULL;
8704     node = NULL;
8705     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
8706     ok(hr == S_OK, "got 0x%08x\n", hr);
8707     ok(node == (void*)elem2, "got %p\n", node);
8708
8709     EXPECT_CHILDREN(elem1);
8710
8711     /* increments each time */
8712     todo_wine EXPECT_REF(elem2, 3);
8713     IXMLDOMNode_Release(node);
8714
8715     /* try to add to another element */
8716     V_VT(&v) = VT_NULL;
8717     node = (void*)0xdeadbeef;
8718     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem2, v, &node);
8719     ok(hr == S_OK, "got 0x%08x\n", hr);
8720     ok(node == (void*)elem2, "got %p\n", node);
8721
8722     EXPECT_CHILDREN(elem3);
8723     EXPECT_NO_CHILDREN(elem1);
8724
8725     IXMLDOMNode_Release(node);
8726
8727     /* cross document case - try to add as child to a node created with other doc */
8728     doc2 = create_document(&IID_IXMLDOMDocument);
8729
8730     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem4);
8731     ok(hr == S_OK, "got 0x%08x\n", hr);
8732     todo_wine EXPECT_REF(elem4, 2);
8733
8734     /* same name, another instance */
8735     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem5);
8736     ok(hr == S_OK, "got 0x%08x\n", hr);
8737     todo_wine EXPECT_REF(elem5, 2);
8738
8739     todo_wine EXPECT_REF(elem3, 2);
8740     V_VT(&v) = VT_NULL;
8741     node = NULL;
8742     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem4, v, &node);
8743     ok(hr == S_OK, "got 0x%08x\n", hr);
8744     ok(node == (void*)elem4, "got %p\n", node);
8745     todo_wine EXPECT_REF(elem4, 3);
8746     todo_wine EXPECT_REF(elem3, 2);
8747     IXMLDOMNode_Release(node);
8748
8749     V_VT(&v) = VT_NULL;
8750     node = NULL;
8751     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem5, v, &node);
8752     ok(hr == S_OK, "got 0x%08x\n", hr);
8753     ok(node == (void*)elem5, "got %p\n", node);
8754     todo_wine EXPECT_REF(elem4, 2);
8755     todo_wine EXPECT_REF(elem5, 3);
8756     IXMLDOMNode_Release(node);
8757
8758     IXMLDOMDocument_Release(doc2);
8759
8760     IXMLDOMElement_Release(elem1);
8761     IXMLDOMElement_Release(elem2);
8762     IXMLDOMElement_Release(elem3);
8763     IXMLDOMElement_Release(elem4);
8764     IXMLDOMElement_Release(elem5);
8765
8766     /* elements with same default namespace */
8767     V_VT(&v) = VT_I4;
8768     V_I4(&v) = NODE_ELEMENT;
8769     elem1 = NULL;
8770     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
8771     ok(hr == S_OK, "got 0x%08x\n", hr);
8772     ok(elem1 != NULL, "got %p\n", elem1);
8773
8774     V_VT(&v) = VT_I4;
8775     V_I4(&v) = NODE_ELEMENT;
8776     elem2 = NULL;
8777     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem2);
8778     ok(hr == S_OK, "got 0x%08x\n", hr);
8779     ok(elem2 != NULL, "got %p\n", elem2);
8780
8781     /* check contents so far */
8782     p = NULL;
8783     hr = IXMLDOMElement_get_xml(elem1, &p);
8784     ok(hr == S_OK, "got 0x%08x\n", hr);
8785     ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
8786     SysFreeString(p);
8787
8788     p = NULL;
8789     hr = IXMLDOMElement_get_xml(elem2, &p);
8790     ok(hr == S_OK, "got 0x%08x\n", hr);
8791     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
8792     SysFreeString(p);
8793
8794     V_VT(&v) = VT_NULL;
8795     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
8796     ok(hr == S_OK, "got 0x%08x\n", hr);
8797
8798     /* get_xml depends on context, for top node it omits child namespace attribute,
8799        but at child level it's still returned */
8800     p = NULL;
8801     hr = IXMLDOMElement_get_xml(elem1, &p);
8802     ok(hr == S_OK, "got 0x%08x\n", hr);
8803     todo_wine ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"><elem2/></elem1>")),
8804         "got %s\n", wine_dbgstr_w(p));
8805     SysFreeString(p);
8806
8807     p = NULL;
8808     hr = IXMLDOMElement_get_xml(elem2, &p);
8809     ok(hr == S_OK, "got 0x%08x\n", hr);
8810     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
8811     SysFreeString(p);
8812
8813     IXMLDOMElement_Release(elem1);
8814     IXMLDOMElement_Release(elem2);
8815
8816     /* child without default namespace added to node with default namespace */
8817     V_VT(&v) = VT_I4;
8818     V_I4(&v) = NODE_ELEMENT;
8819     elem1 = NULL;
8820     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
8821     ok(hr == S_OK, "got 0x%08x\n", hr);
8822     ok(elem1 != NULL, "got %p\n", elem1);
8823
8824     V_VT(&v) = VT_I4;
8825     V_I4(&v) = NODE_ELEMENT;
8826     elem2 = NULL;
8827     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), NULL, (IXMLDOMNode**)&elem2);
8828     ok(hr == S_OK, "got 0x%08x\n", hr);
8829     ok(elem2 != NULL, "got %p\n", elem2);
8830
8831     EXPECT_REF(elem2, 1);
8832     V_VT(&v) = VT_NULL;
8833     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
8834     ok(hr == S_OK, "got 0x%08x\n", hr);
8835     EXPECT_REF(elem2, 1);
8836
8837     p = NULL;
8838     hr = IXMLDOMElement_get_xml(elem2, &p);
8839     ok(hr == S_OK, "got 0x%08x\n", hr);
8840     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
8841     SysFreeString(p);
8842
8843     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem2, NULL);
8844     ok(hr == S_OK, "got 0x%08x\n", hr);
8845
8846     p = NULL;
8847     hr = IXMLDOMElement_get_xml(elem2, &p);
8848     ok(hr == S_OK, "got 0x%08x\n", hr);
8849     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
8850     SysFreeString(p);
8851
8852     IXMLDOMElement_Release(elem1);
8853     IXMLDOMElement_Release(elem2);
8854     IXMLDOMDocument_Release(doc);
8855 }
8856
8857 static void test_appendChild(void)
8858 {
8859     IXMLDOMDocument *doc, *doc2;
8860     IXMLDOMElement *elem, *elem2;
8861     HRESULT hr;
8862
8863     doc = create_document(&IID_IXMLDOMDocument);
8864     doc2 = create_document(&IID_IXMLDOMDocument);
8865
8866     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
8867     ok(hr == S_OK, "got 0x%08x\n", hr);
8868
8869     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem2"), &elem2);
8870     ok(hr == S_OK, "got 0x%08x\n", hr);
8871
8872     EXPECT_REF(doc, 1);
8873     todo_wine EXPECT_REF(elem, 2);
8874     EXPECT_REF(doc2, 1);
8875     todo_wine EXPECT_REF(elem2, 2);
8876     EXPECT_NO_CHILDREN(doc);
8877     EXPECT_NO_CHILDREN(doc2);
8878
8879     /* append from another document */
8880     hr = IXMLDOMDocument_appendChild(doc2, (IXMLDOMNode*)elem, NULL);
8881     ok(hr == S_OK, "got 0x%08x\n", hr);
8882
8883     EXPECT_REF(doc, 1);
8884     todo_wine EXPECT_REF(elem, 2);
8885     EXPECT_REF(doc2, 1);
8886     todo_wine EXPECT_REF(elem2, 2);
8887     EXPECT_NO_CHILDREN(doc);
8888     EXPECT_CHILDREN(doc2);
8889
8890     IXMLDOMElement_Release(elem);
8891     IXMLDOMElement_Release(elem2);
8892     IXMLDOMDocument_Release(doc);
8893     IXMLDOMDocument_Release(doc2);
8894 }
8895
8896 static void test_get_doctype(void)
8897 {
8898     IXMLDOMDocumentType *doctype;
8899     IXMLDOMDocument *doc;
8900     HRESULT hr;
8901
8902     doc = create_document(&IID_IXMLDOMDocument);
8903
8904     hr = IXMLDOMDocument_get_doctype(doc, NULL);
8905     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8906
8907     doctype = (void*)0xdeadbeef;
8908     hr = IXMLDOMDocument_get_doctype(doc, &doctype);
8909     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8910     ok(doctype == NULL, "got %p\n", doctype);
8911
8912     IXMLDOMDocument_Release(doc);
8913 }
8914
8915 static void test_get_tagName(void)
8916 {
8917     IXMLDOMDocument *doc;
8918     IXMLDOMElement *elem, *elem2;
8919     HRESULT hr;
8920     BSTR str;
8921
8922     doc = create_document(&IID_IXMLDOMDocument);
8923
8924     hr = IXMLDOMDocument_createElement(doc, _bstr_("element"), &elem);
8925     ok(hr == S_OK, "got 0x%08x\n", hr);
8926
8927     hr = IXMLDOMElement_get_tagName(elem, NULL);
8928     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8929
8930     str = NULL;
8931     hr = IXMLDOMElement_get_tagName(elem, &str);
8932     ok(hr == S_OK, "got 0x%08x\n", hr);
8933     ok(!lstrcmpW(str, _bstr_("element")), "got %s\n", wine_dbgstr_w(str));
8934     SysFreeString(str);
8935
8936     hr = IXMLDOMDocument_createElement(doc, _bstr_("s:element"), &elem2);
8937     ok(hr == S_OK, "got 0x%08x\n", hr);
8938
8939     str = NULL;
8940     hr = IXMLDOMElement_get_tagName(elem2, &str);
8941     ok(hr == S_OK, "got 0x%08x\n", hr);
8942     ok(!lstrcmpW(str, _bstr_("s:element")), "got %s\n", wine_dbgstr_w(str));
8943     SysFreeString(str);
8944
8945     IXMLDOMElement_Release(elem);
8946     IXMLDOMElement_Release(elem2);
8947     IXMLDOMDocument_Release(doc);
8948     free_bstrs();
8949 }
8950
8951 typedef struct {
8952     DOMNodeType type;
8953     const char *name;
8954     VARTYPE vt;
8955     HRESULT hr;
8956 } node_type_t;
8957
8958 static const node_type_t get_datatype[] = {
8959     { NODE_ELEMENT,                "element",   VT_NULL, S_FALSE },
8960     { NODE_ATTRIBUTE,              "attr",      VT_NULL, S_FALSE },
8961     { NODE_TEXT,                   "text",      VT_NULL, S_FALSE },
8962     { NODE_CDATA_SECTION ,         "cdata",     VT_NULL, S_FALSE },
8963     { NODE_ENTITY_REFERENCE,       "entityref", VT_NULL, S_FALSE },
8964     { NODE_PROCESSING_INSTRUCTION, "pi",        VT_NULL, S_FALSE },
8965     { NODE_COMMENT,                "comment",   VT_NULL, S_FALSE },
8966     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   VT_NULL, S_FALSE },
8967     { 0 }
8968 };
8969
8970 static void test_get_dataType(void)
8971 {
8972     const node_type_t *entry = get_datatype;
8973     IXMLDOMDocument *doc;
8974
8975     doc = create_document(&IID_IXMLDOMDocument);
8976
8977     while (entry->type)
8978     {
8979         IXMLDOMNode *node = NULL;
8980         VARIANT var, type;
8981         HRESULT hr;
8982
8983         V_VT(&var) = VT_I4;
8984         V_I4(&var) = entry->type;
8985         hr = IXMLDOMDocument_createNode(doc, var, _bstr_(entry->name), NULL, &node);
8986         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
8987
8988         hr = IXMLDOMNode_get_dataType(node, NULL);
8989         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8990
8991         VariantInit(&type);
8992         hr = IXMLDOMNode_get_dataType(node, &type);
8993         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
8994             hr, entry->hr, entry->type);
8995         ok(V_VT(&type) == entry->vt, "got %d, expected %d. node type %d\n",
8996             V_VT(&type), entry->vt, entry->type);
8997         VariantClear(&type);
8998
8999         IXMLDOMNode_Release(node);
9000
9001         entry++;
9002     }
9003
9004     IXMLDOMDocument_Release(doc);
9005     free_bstrs();
9006 }
9007
9008 typedef struct _get_node_typestring_t {
9009     DOMNodeType type;
9010     const char *string;
9011 } get_node_typestring_t;
9012
9013 static const get_node_typestring_t get_node_typestring[] = {
9014     { NODE_ELEMENT,                "element"               },
9015     { NODE_ATTRIBUTE,              "attribute"             },
9016     { NODE_TEXT,                   "text"                  },
9017     { NODE_CDATA_SECTION ,         "cdatasection"          },
9018     { NODE_ENTITY_REFERENCE,       "entityreference"       },
9019     { NODE_PROCESSING_INSTRUCTION, "processinginstruction" },
9020     { NODE_COMMENT,                "comment"               },
9021     { NODE_DOCUMENT_FRAGMENT,      "documentfragment"      },
9022     { 0 }
9023 };
9024
9025 static void test_get_nodeTypeString(void)
9026 {
9027     const get_node_typestring_t *entry = get_node_typestring;
9028     IXMLDOMDocument *doc;
9029     HRESULT hr;
9030     BSTR str;
9031
9032     doc = create_document(&IID_IXMLDOMDocument);
9033
9034     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
9035     ok(hr == S_OK, "got 0x%08x\n", hr);
9036     ok(!lstrcmpW(str, _bstr_("document")), "got string %s\n", wine_dbgstr_w(str));
9037     SysFreeString(str);
9038
9039     while (entry->type)
9040     {
9041         IXMLDOMNode *node = NULL;
9042         VARIANT var;
9043
9044         V_VT(&var) = VT_I4;
9045         V_I4(&var) = entry->type;
9046         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
9047         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9048
9049         hr = IXMLDOMNode_get_nodeTypeString(node, NULL);
9050         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9051
9052         hr = IXMLDOMNode_get_nodeTypeString(node, &str);
9053         ok(hr == S_OK, "got 0x%08x\n", hr);
9054         ok(!lstrcmpW(str, _bstr_(entry->string)), "got string %s, expected %s. node type %d\n",
9055             wine_dbgstr_w(str), entry->string, entry->type);
9056         SysFreeString(str);
9057         IXMLDOMNode_Release(node);
9058
9059         entry++;
9060     }
9061
9062     IXMLDOMDocument_Release(doc);
9063     free_bstrs();
9064 }
9065
9066 typedef struct _get_attributes_t {
9067     DOMNodeType type;
9068     HRESULT hr;
9069 } get_attributes_t;
9070
9071 static const get_attributes_t get_attributes[] = {
9072     { NODE_ATTRIBUTE,              S_FALSE },
9073     { NODE_TEXT,                   S_FALSE },
9074     { NODE_CDATA_SECTION ,         S_FALSE },
9075     { NODE_ENTITY_REFERENCE,       S_FALSE },
9076     { NODE_PROCESSING_INSTRUCTION, S_FALSE },
9077     { NODE_COMMENT,                S_FALSE },
9078     { NODE_DOCUMENT_FRAGMENT,      S_FALSE },
9079     { 0 }
9080 };
9081
9082 static void test_get_attributes(void)
9083 {
9084     const get_attributes_t *entry = get_attributes;
9085     IXMLDOMNamedNodeMap *map;
9086     IXMLDOMDocument *doc;
9087     IXMLDOMNode *node, *node2;
9088     VARIANT_BOOL b;
9089     HRESULT hr;
9090     BSTR str;
9091     LONG length;
9092
9093     doc = create_document(&IID_IXMLDOMDocument);
9094
9095     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
9096     ok(hr == S_OK, "got %08x\n", hr);
9097
9098     hr = IXMLDOMDocument_get_attributes(doc, NULL);
9099     ok(hr == E_INVALIDARG, "got %08x\n", hr);
9100
9101     map = (void*)0xdeadbeef;
9102     hr = IXMLDOMDocument_get_attributes(doc, &map);
9103     ok(hr == S_FALSE, "got %08x\n", hr);
9104     ok(map == NULL, "got %p\n", map);
9105
9106     /* first child is <?xml ?> */
9107     hr = IXMLDOMDocument_get_firstChild(doc, &node);
9108     ok(hr == S_OK, "got %08x\n", hr);
9109
9110     hr = IXMLDOMNode_get_attributes(node, &map);
9111     ok(hr == S_OK, "got %08x\n", hr);
9112
9113     length = -1;
9114     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9115     EXPECT_HR(hr, S_OK);
9116     todo_wine ok(length == 1, "got %d\n", length);
9117
9118     if (hr == S_OK && length == 1)
9119     {
9120         IXMLDOMAttribute *attr;
9121         DOMNodeType type;
9122         VARIANT v;
9123
9124         node2 = NULL;
9125         hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9126         EXPECT_HR(hr, S_OK);
9127         ok(node != NULL, "got %p\n", node2);
9128
9129         hr = IXMLDOMNode_get_nodeName(node2, &str);
9130         EXPECT_HR(hr, S_OK);
9131         ok(!lstrcmpW(str, _bstr_("version")), "got %s\n", wine_dbgstr_w(str));
9132         SysFreeString(str);
9133
9134         length = -1;
9135         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9136         EXPECT_HR(hr, S_OK);
9137         ok(length == 1, "got %d\n", length);
9138
9139         type = -1;
9140         hr = IXMLDOMNode_get_nodeType(node2, &type);
9141         EXPECT_HR(hr, S_OK);
9142         ok(type == NODE_ATTRIBUTE, "got %d\n", type);
9143
9144         hr = IXMLDOMNode_get_xml(node, &str);
9145         EXPECT_HR(hr, S_OK);
9146         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9147         SysFreeString(str);
9148
9149         hr = IXMLDOMNode_get_text(node, &str);
9150         EXPECT_HR(hr, S_OK);
9151         ok(!lstrcmpW(str, _bstr_("version=\"1.0\"")), "got %s\n", wine_dbgstr_w(str));
9152         SysFreeString(str);
9153
9154         hr = IXMLDOMNamedNodeMap_removeNamedItem(map, _bstr_("version"), NULL);
9155         EXPECT_HR(hr, S_OK);
9156
9157         length = -1;
9158         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9159         EXPECT_HR(hr, S_OK);
9160         ok(length == 0, "got %d\n", length);
9161
9162         hr = IXMLDOMNode_get_xml(node, &str);
9163         EXPECT_HR(hr, S_OK);
9164         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9165         SysFreeString(str);
9166
9167         hr = IXMLDOMNode_get_text(node, &str);
9168         EXPECT_HR(hr, S_OK);
9169         ok(!lstrcmpW(str, _bstr_("")), "got %s\n", wine_dbgstr_w(str));
9170         SysFreeString(str);
9171
9172         IXMLDOMNamedNodeMap_Release(map);
9173
9174         hr = IXMLDOMNode_get_attributes(node, &map);
9175         ok(hr == S_OK, "got %08x\n", hr);
9176
9177         length = -1;
9178         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9179         EXPECT_HR(hr, S_OK);
9180         ok(length == 0, "got %d\n", length);
9181
9182         hr = IXMLDOMDocument_createAttribute(doc, _bstr_("encoding"), &attr);
9183         EXPECT_HR(hr, S_OK);
9184
9185         V_VT(&v) = VT_BSTR;
9186         V_BSTR(&v) = _bstr_("UTF-8");
9187         hr = IXMLDOMAttribute_put_nodeValue(attr, v);
9188         EXPECT_HR(hr, S_OK);
9189
9190         EXPECT_REF(attr, 2);
9191         hr = IXMLDOMNamedNodeMap_setNamedItem(map, (IXMLDOMNode*)attr, NULL);
9192         EXPECT_HR(hr, S_OK);
9193         EXPECT_REF(attr, 2);
9194
9195         hr = IXMLDOMNode_get_attributes(node, &map);
9196         ok(hr == S_OK, "got %08x\n", hr);
9197
9198         length = -1;
9199         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9200         EXPECT_HR(hr, S_OK);
9201         ok(length == 1, "got %d\n", length);
9202
9203         hr = IXMLDOMNode_get_xml(node, &str);
9204         EXPECT_HR(hr, S_OK);
9205         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9206         SysFreeString(str);
9207
9208         hr = IXMLDOMNode_get_text(node, &str);
9209         EXPECT_HR(hr, S_OK);
9210         ok(!lstrcmpW(str, _bstr_("encoding=\"UTF-8\"")), "got %s\n", wine_dbgstr_w(str));
9211         SysFreeString(str);
9212
9213         IXMLDOMNamedNodeMap_Release(map);
9214         IXMLDOMNode_Release(node2);
9215     }
9216
9217     IXMLDOMNode_Release(node);
9218
9219     /* last child is element */
9220     EXPECT_REF(doc, 1);
9221     hr = IXMLDOMDocument_get_lastChild(doc, &node);
9222     ok(hr == S_OK, "got %08x\n", hr);
9223     EXPECT_REF(doc, 1);
9224
9225     EXPECT_REF(node, 1);
9226     hr = IXMLDOMNode_get_attributes(node, &map);
9227     ok(hr == S_OK, "got %08x\n", hr);
9228     EXPECT_REF(node, 1);
9229     EXPECT_REF(doc, 1);
9230
9231     EXPECT_REF(map, 1);
9232     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9233     ok(hr == S_OK, "got %08x\n", hr);
9234     EXPECT_REF(node, 1);
9235     EXPECT_REF(node2, 1);
9236     EXPECT_REF(map, 1);
9237     EXPECT_REF(doc, 1);
9238     IXMLDOMNode_Release(node2);
9239
9240     /* release node before map release, map still works */
9241     IXMLDOMNode_Release(node);
9242
9243     length = 0;
9244     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9245     ok(hr == S_OK, "got %08x\n", hr);
9246     ok(length == 1, "got %d\n", length);
9247
9248     node2 = NULL;
9249     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9250     ok(hr == S_OK, "got %08x\n", hr);
9251     EXPECT_REF(node2, 1);
9252     IXMLDOMNode_Release(node2);
9253
9254     IXMLDOMNamedNodeMap_Release(map);
9255
9256     while (entry->type)
9257     {
9258         VARIANT var;
9259
9260         node = NULL;
9261
9262         V_VT(&var) = VT_I4;
9263         V_I4(&var) = entry->type;
9264         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
9265         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9266
9267         hr = IXMLDOMNode_get_attributes(node, NULL);
9268         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9269
9270         map = (void*)0xdeadbeef;
9271         hr = IXMLDOMNode_get_attributes(node, &map);
9272         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
9273             hr, entry->hr, entry->type);
9274         ok(map == NULL, "got %p\n", map);
9275
9276         IXMLDOMNode_Release(node);
9277
9278         entry++;
9279     }
9280
9281     IXMLDOMDocument_Release(doc);
9282     free_bstrs();
9283 }
9284
9285 static void test_selection(void)
9286 {
9287     IXMLDOMSelection *selection, *selection2;
9288     IEnumVARIANT *enum1, *enum2, *enum3;
9289     IXMLDOMNodeList *list;
9290     IUnknown *unk1, *unk2;
9291     IXMLDOMDocument *doc;
9292     IDispatchEx *dispex;
9293     IXMLDOMNode *node;
9294     IDispatch *disp;
9295     VARIANT_BOOL b;
9296     HRESULT hr;
9297     DISPID did;
9298     VARIANT v;
9299     BSTR name;
9300     ULONG ret;
9301     LONG len;
9302
9303     doc = create_document(&IID_IXMLDOMDocument);
9304
9305     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
9306     EXPECT_HR(hr, S_OK);
9307
9308     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list);
9309     EXPECT_HR(hr, S_OK);
9310
9311     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9312     EXPECT_HR(hr, S_OK);
9313     IXMLDOMSelection_Release(selection);
9314
9315     /* collection disp id */
9316     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IDispatchEx, (void**)&dispex);
9317     EXPECT_HR(hr, S_OK);
9318     did = 0;
9319     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
9320     EXPECT_HR(hr, S_OK);
9321     ok(did == DISPID_DOM_COLLECTION_BASE, "got %d\n", did);
9322     len = 0;
9323     hr = IXMLDOMSelection_get_length(selection, &len);
9324     EXPECT_HR(hr, S_OK);
9325     ok(len == 1, "got %d\n", len);
9326     hr = IDispatchEx_GetDispID(dispex, _bstr_("10"), 0, &did);
9327     EXPECT_HR(hr, S_OK);
9328     ok(did == DISPID_DOM_COLLECTION_BASE+10, "got %d\n", did);
9329     IDispatchEx_Release(dispex);
9330
9331     /* IEnumVARIANT tests */
9332     enum1 = NULL;
9333     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum1);
9334     EXPECT_HR(hr, S_OK);
9335     ok(enum1 != NULL, "got %p\n", enum1);
9336     EXPECT_REF(enum1, 2);
9337
9338     EXPECT_REF(selection, 1);
9339     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IUnknown, (void**)&unk1);
9340     EXPECT_HR(hr, S_OK);
9341     EXPECT_REF(selection, 2);
9342     EXPECT_REF(enum1, 2);
9343
9344     /* enumerator and selection object return same IUnknown* */
9345     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
9346     EXPECT_HR(hr, S_OK);
9347     EXPECT_REF(selection, 3);
9348     EXPECT_REF(enum1, 2);
9349     ok(unk2 == unk1, "got %p, %p\n", unk1, unk2);
9350     IUnknown_Release(unk2);
9351
9352     EXPECT_REF(selection, 2);
9353     IEnumVARIANT_AddRef(enum1);
9354     EXPECT_REF(selection, 2);
9355     IEnumVARIANT_Release(enum1);
9356
9357     enum3 = NULL;
9358     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum3);
9359     EXPECT_HR(hr, S_OK);
9360     ok(enum3 != NULL, "got %p\n", enum3);
9361     ok(enum1 == enum3, "got %p and %p\n", enum1, enum3);
9362     EXPECT_REF(enum1, 3);
9363     IEnumVARIANT_Release(enum3);
9364
9365     EXPECT_REF(selection, 2);
9366     EXPECT_REF(enum1, 2);
9367
9368     enum2 = NULL;
9369     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
9370     EXPECT_HR(hr, S_OK);
9371     ok(enum2 != NULL, "got %p\n", enum2);
9372
9373     EXPECT_REF(selection, 3);
9374     EXPECT_REF(enum1, 2);
9375     EXPECT_REF(enum2, 1);
9376
9377     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
9378
9379     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
9380     EXPECT_HR(hr, S_OK);
9381     EXPECT_REF(selection, 3);
9382     EXPECT_REF(enum2, 2);
9383     ok(unk2 != unk1, "got %p, %p\n", unk1, unk2);
9384     IUnknown_Release(unk2);
9385     IUnknown_Release(unk1);
9386
9387     selection2 = NULL;
9388     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IXMLDOMSelection, (void**)&selection2);
9389     EXPECT_HR(hr, S_OK);
9390     ok(selection2 == selection, "got %p and %p\n", selection, selection2);
9391     EXPECT_REF(selection, 3);
9392     EXPECT_REF(enum1, 2);
9393
9394     IXMLDOMSelection_Release(selection2);
9395
9396     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IDispatch, (void**)&disp);
9397     EXPECT_HR(hr, S_OK);
9398     EXPECT_REF(selection, 3);
9399     IDispatch_Release(disp);
9400
9401     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IEnumVARIANT, (void**)&enum3);
9402     EXPECT_HR(hr, S_OK);
9403     ok(enum3 == enum1, "got %p and %p\n", enum3, enum1);
9404     EXPECT_REF(selection, 2);
9405     EXPECT_REF(enum1, 3);
9406
9407     IEnumVARIANT_Release(enum1);
9408     IEnumVARIANT_Release(enum2);
9409
9410     enum1 = NULL;
9411     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
9412     EXPECT_HR(hr, S_OK);
9413     ok(enum1 != NULL, "got %p\n", enum1);
9414     EXPECT_REF(enum1, 1);
9415     EXPECT_REF(selection, 2);
9416
9417     enum2 = NULL;
9418     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
9419     EXPECT_HR(hr, S_OK);
9420     ok(enum2 != NULL, "got %p\n", enum2);
9421     EXPECT_REF(enum2, 1);
9422     EXPECT_REF(selection, 3);
9423
9424     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
9425
9426     IEnumVARIANT_AddRef(enum1);
9427     EXPECT_REF(selection, 3);
9428     EXPECT_REF(enum1, 2);
9429     EXPECT_REF(enum2, 1);
9430     IEnumVARIANT_Release(enum1);
9431
9432     IEnumVARIANT_Release(enum1);
9433     IEnumVARIANT_Release(enum2);
9434
9435     EXPECT_REF(selection, 1);
9436
9437     IXMLDOMNodeList_Release(list);
9438
9439     hr = IXMLDOMDocument_get_childNodes(doc, &list);
9440     EXPECT_HR(hr, S_OK);
9441
9442     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9443     EXPECT_HR(hr, E_NOINTERFACE);
9444
9445     IXMLDOMNodeList_Release(list);
9446
9447     /* test if IEnumVARIANT touches selection context */
9448     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
9449     EXPECT_HR(hr, S_OK);
9450
9451     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/*"), &list);
9452     EXPECT_HR(hr, S_OK);
9453
9454     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9455     EXPECT_HR(hr, S_OK);
9456
9457     len = 0;
9458     hr = IXMLDOMSelection_get_length(selection, &len);
9459     EXPECT_HR(hr, S_OK);
9460     ok(len == 4, "got %d\n", len);
9461
9462     enum1 = NULL;
9463     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
9464     EXPECT_HR(hr, S_OK);
9465
9466     /* no-op if zero count */
9467     V_VT(&v) = VT_I2;
9468     hr = IEnumVARIANT_Next(enum1, 0, &v, NULL);
9469     EXPECT_HR(hr, S_OK);
9470     ok(V_VT(&v) == VT_I2, "got var type %d\n", V_VT(&v));
9471
9472     /* positive count, null array pointer */
9473     hr = IEnumVARIANT_Next(enum1, 1, NULL, NULL);
9474     EXPECT_HR(hr, E_INVALIDARG);
9475
9476     ret = 1;
9477     hr = IEnumVARIANT_Next(enum1, 1, NULL, &ret);
9478     EXPECT_HR(hr, E_INVALIDARG);
9479     ok(ret == 0, "got %d\n", ret);
9480
9481     V_VT(&v) = VT_I2;
9482     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
9483     EXPECT_HR(hr, S_OK);
9484     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
9485
9486     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
9487     EXPECT_HR(hr, S_OK);
9488     hr = IXMLDOMNode_get_nodeName(node, &name);
9489     EXPECT_HR(hr, S_OK);
9490     ok(!lstrcmpW(name, _bstr_("a")), "got node name %s\n", wine_dbgstr_w(name));
9491     SysFreeString(name);
9492     IXMLDOMNode_Release(node);
9493     VariantClear(&v);
9494
9495     /* list cursor is updated */
9496     hr = IXMLDOMSelection_nextNode(selection, &node);
9497     EXPECT_HR(hr, S_OK);
9498     hr = IXMLDOMNode_get_nodeName(node, &name);
9499     EXPECT_HR(hr, S_OK);
9500     ok(!lstrcmpW(name, _bstr_("c")), "got node name %s\n", wine_dbgstr_w(name));
9501     IXMLDOMNode_Release(node);
9502
9503     V_VT(&v) = VT_I2;
9504     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
9505     EXPECT_HR(hr, S_OK);
9506     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
9507     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
9508     EXPECT_HR(hr, S_OK);
9509     hr = IXMLDOMNode_get_nodeName(node, &name);
9510     EXPECT_HR(hr, S_OK);
9511     ok(!lstrcmpW(name, _bstr_("b")), "got node name %s\n", wine_dbgstr_w(name));
9512     SysFreeString(name);
9513     IXMLDOMNode_Release(node);
9514     VariantClear(&v);
9515     IEnumVARIANT_Release(enum1);
9516
9517     hr = IXMLDOMSelection_nextNode(selection, &node);
9518     EXPECT_HR(hr, S_OK);
9519     hr = IXMLDOMNode_get_nodeName(node, &name);
9520     EXPECT_HR(hr, S_OK);
9521     ok(!lstrcmpW(name, _bstr_("d")), "got node name %s\n", wine_dbgstr_w(name));
9522     IXMLDOMNode_Release(node);
9523
9524     IXMLDOMSelection_Release(selection);
9525     IXMLDOMNodeList_Release(list);
9526     IXMLDOMDocument_Release(doc);
9527
9528     free_bstrs();
9529 }
9530
9531 static void write_to_file(const char *name, const char *data)
9532 {
9533     DWORD written;
9534     HANDLE hfile;
9535     BOOL ret;
9536
9537     hfile = CreateFileA(name, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
9538     ok(hfile != INVALID_HANDLE_VALUE, "failed to create test file: %s\n", name);
9539
9540     ret = WriteFile(hfile, data, strlen(data), &written, NULL);
9541     ok(ret, "WriteFile failed: %s, %d\n", name, GetLastError());
9542
9543     CloseHandle(hfile);
9544 }
9545
9546 static void test_load(void)
9547 {
9548     IXMLDOMDocument *doc, *doc2;
9549     IXMLDOMNodeList *list;
9550     IXMLDOMElement *elem;
9551     VARIANT_BOOL b;
9552     VARIANT src;
9553     HRESULT hr;
9554     BSTR path, bstr1, bstr2;
9555     void* ptr;
9556
9557     /* prepare a file */
9558     write_to_file("test.xml", win1252xml);
9559
9560     doc = create_document(&IID_IXMLDOMDocument);
9561
9562     /* null pointer as input */
9563     V_VT(&src) = VT_UNKNOWN;
9564     V_UNKNOWN(&src) = NULL;
9565     hr = IXMLDOMDocument_load(doc, src, &b);
9566     EXPECT_HR(hr, E_INVALIDARG);
9567     ok(b == VARIANT_FALSE, "got %d\n", b);
9568
9569     path = _bstr_("test.xml");
9570
9571     /* load from path: VT_BSTR */
9572     V_VT(&src) = VT_BSTR;
9573     V_BSTR(&src) = path;
9574     hr = IXMLDOMDocument_load(doc, src, &b);
9575     EXPECT_HR(hr, S_OK);
9576     ok(b == VARIANT_TRUE, "got %d\n", b);
9577
9578     bstr1 = NULL;
9579     hr = IXMLDOMDocument_get_url(doc, &bstr1);
9580     ok(hr == S_OK, "got 0x%08x\n", hr);
9581     SysFreeString(bstr1);
9582
9583     /* load from a path: VT_BSTR|VT_BYREF */
9584     V_VT(&src) = VT_BSTR | VT_BYREF;
9585     V_BSTRREF(&src) = &path;
9586     hr = IXMLDOMDocument_load(doc, src, &b);
9587     EXPECT_HR(hr, S_OK);
9588     ok(b == VARIANT_TRUE, "got %d\n", b);
9589
9590     bstr1 = NULL;
9591     hr = IXMLDOMDocument_get_url(doc, &bstr1);
9592     ok(hr == S_OK, "got 0x%08x\n", hr);
9593
9594     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
9595     ok(hr == S_OK, "got 0x%08x\n", hr);
9596
9597     /* create another instance for the same document, check url */
9598     hr = IXMLDOMElement_get_ownerDocument(elem, &doc2);
9599     ok(hr == S_OK, "got 0x%08x\n", hr);
9600
9601     hr = IXMLDOMDocument_get_url(doc, &bstr2);
9602     ok(hr == S_OK, "got 0x%08x\n", hr);
9603     ok(!lstrcmpW(bstr1, bstr2), "got %s\n", wine_dbgstr_w(bstr2));
9604
9605     IXMLDOMDocument_Release(doc2);
9606     IXMLDOMElement_Release(elem);
9607
9608     SysFreeString(bstr1);
9609     SysFreeString(bstr2);
9610
9611     /* load from a path: VT_BSTR|VT_BYREF, null ptr */
9612     V_VT(&src) = VT_BSTR | VT_BYREF;
9613     V_BSTRREF(&src) = NULL;
9614     hr = IXMLDOMDocument_load(doc, src, &b);
9615     EXPECT_HR(hr, E_INVALIDARG);
9616     ok(b == VARIANT_FALSE, "got %d\n", b);
9617
9618     bstr1 = NULL;
9619     hr = IXMLDOMDocument_get_url(doc, &bstr1);
9620     ok(hr == S_OK, "got 0x%08x\n", hr);
9621     SysFreeString(bstr1);
9622
9623     DeleteFileA("test.xml");
9624
9625     /* load from existing path, no xml content */
9626     write_to_file("test.xml", nocontent);
9627
9628     V_VT(&src) = VT_BSTR;
9629     V_BSTR(&src) = path;
9630     b = VARIANT_TRUE;
9631     hr = IXMLDOMDocument_load(doc, src, &b);
9632     ok(hr == S_FALSE, "got 0x%08x\n", hr);
9633     ok(b == VARIANT_FALSE, "got %d\n", b);
9634
9635     bstr1 = (BSTR)0x1;
9636     hr = IXMLDOMDocument_get_url(doc, &bstr1);
9637     ok(hr == S_FALSE, "got 0x%08x\n", hr);
9638     ok(bstr1 == NULL, "got %p\n", bstr1);
9639
9640     DeleteFileA("test.xml");
9641     IXMLDOMDocument_Release(doc);
9642
9643     doc = create_document(&IID_IXMLDOMDocument);
9644
9645     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
9646     EXPECT_HR(hr, S_OK);
9647     ok(b == VARIANT_TRUE, "got %d\n", b);
9648
9649     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
9650     EXPECT_HR(hr, S_OK);
9651     bstr1 = _bstr_(list_to_string(list));
9652
9653     hr = IXMLDOMNodeList_reset(list);
9654     EXPECT_HR(hr, S_OK);
9655
9656     IXMLDOMDocument_Release(doc);
9657
9658     doc = create_document(&IID_IXMLDOMDocument);
9659
9660     VariantInit(&src);
9661     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenA(szExampleXML));
9662     V_VT(&src) = VT_ARRAY|VT_UI1;
9663     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
9664     ptr = NULL;
9665     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
9666     EXPECT_HR(hr, S_OK);
9667     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
9668
9669     memcpy(ptr, szExampleXML, lstrlenA(szExampleXML));
9670     hr = SafeArrayUnlock(V_ARRAY(&src));
9671     EXPECT_HR(hr, S_OK);
9672
9673     hr = IXMLDOMDocument_load(doc, src, &b);
9674     EXPECT_HR(hr, S_OK);
9675     ok(b == VARIANT_TRUE, "got %d\n", b);
9676
9677     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
9678     EXPECT_HR(hr, S_OK);
9679     bstr2 = _bstr_(list_to_string(list));
9680
9681     hr = IXMLDOMNodeList_reset(list);
9682     EXPECT_HR(hr, S_OK);
9683
9684     ok(lstrcmpW(bstr1, bstr2) == 0, "strings not equal: %s : %s\n",
9685        wine_dbgstr_w(bstr1), wine_dbgstr_w(bstr2));
9686
9687     IXMLDOMDocument_Release(doc);
9688     IXMLDOMNodeList_Release(list);
9689     VariantClear(&src);
9690
9691     /* UTF-16 isn't accepted */
9692     doc = create_document(&IID_IXMLDOMDocument);
9693
9694     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenW(szComplete1) * sizeof(WCHAR));
9695     V_VT(&src) = VT_ARRAY|VT_UI1;
9696     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
9697     ptr = NULL;
9698     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
9699     EXPECT_HR(hr, S_OK);
9700     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
9701
9702     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
9703     hr = SafeArrayUnlock(V_ARRAY(&src));
9704     EXPECT_HR(hr, S_OK);
9705
9706     hr = IXMLDOMDocument_load(doc, src, &b);
9707     todo_wine EXPECT_HR(hr, S_FALSE);
9708     todo_wine ok(b == VARIANT_FALSE, "got %d\n", b);
9709
9710     VariantClear(&src);
9711
9712     /* it doesn't like it as a VT_ARRAY|VT_UI2 either */
9713     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI2, 0, lstrlenW(szComplete1));
9714     V_VT(&src) = VT_ARRAY|VT_UI2;
9715     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
9716     ptr = NULL;
9717     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
9718     EXPECT_HR(hr, S_OK);
9719     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
9720
9721     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
9722     hr = SafeArrayUnlock(V_ARRAY(&src));
9723     EXPECT_HR(hr, S_OK);
9724
9725     hr = IXMLDOMDocument_load(doc, src, &b);
9726     todo_wine EXPECT_HR(hr, E_INVALIDARG);
9727     ok(b == VARIANT_FALSE, "got %d\n", b);
9728
9729     VariantClear(&src);
9730     IXMLDOMDocument_Release(doc);
9731
9732     free_bstrs();
9733 }
9734
9735 static void test_domobj_dispex(IUnknown *obj)
9736 {
9737     DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
9738     IDispatchEx *dispex;
9739     IUnknown *unk;
9740     DWORD props;
9741     UINT ticnt;
9742     HRESULT hr;
9743     BSTR name;
9744
9745     hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
9746     EXPECT_HR(hr, S_OK);
9747     if (FAILED(hr)) return;
9748
9749     ticnt = 0;
9750     hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
9751     EXPECT_HR(hr, S_OK);
9752     ok(ticnt == 1, "ticnt=%u\n", ticnt);
9753
9754     name = SysAllocString(szstar);
9755     hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
9756     EXPECT_HR(hr, E_NOTIMPL);
9757     SysFreeString(name);
9758
9759     hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
9760     EXPECT_HR(hr, E_NOTIMPL);
9761
9762     props = 0;
9763     hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
9764     EXPECT_HR(hr, E_NOTIMPL);
9765     ok(props == 0, "expected 0 got %d\n", props);
9766
9767     hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
9768     EXPECT_HR(hr, E_NOTIMPL);
9769     if (SUCCEEDED(hr)) SysFreeString(name);
9770
9771     hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
9772     EXPECT_HR(hr, E_NOTIMPL);
9773
9774     hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
9775     EXPECT_HR(hr, E_NOTIMPL);
9776     if (hr == S_OK && unk) IUnknown_Release(unk);
9777
9778     IDispatchEx_Release(dispex);
9779 }
9780
9781 static void test_mxnamespacemanager(void)
9782 {
9783     static const char xmluriA[] = "http://www.w3.org/XML/1998/namespace";
9784     IMXNamespacePrefixes *prefixes;
9785     IVBMXNamespaceManager *mgr2;
9786     IMXNamespaceManager *nsmgr;
9787     IUnknown *unk1, *unk2;
9788     WCHAR buffW[250];
9789     IDispatch *disp;
9790     IUnknown *unk;
9791     HRESULT hr;
9792     INT len;
9793
9794     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
9795         &IID_IMXNamespaceManager, (void**)&nsmgr);
9796     EXPECT_HR(hr, S_OK);
9797
9798     /* IMXNamespaceManager inherits from IUnknown */
9799     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IDispatch, (void**)&disp);
9800     EXPECT_HR(hr, S_OK);
9801     IDispatch_Release(disp);
9802
9803     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IVBMXNamespaceManager, (void**)&mgr2);
9804     EXPECT_HR(hr, S_OK);
9805
9806     EXPECT_REF(nsmgr, 2);
9807     EXPECT_REF(mgr2, 2);
9808     prefixes = NULL;
9809     hr = IVBMXNamespaceManager_getDeclaredPrefixes(mgr2, &prefixes);
9810     if (hr == S_OK)
9811     {
9812         IDispatchEx *dispex;
9813         VARIANT arg, ret;
9814         DISPPARAMS dispparams;
9815
9816         ok(prefixes != NULL, "got %p\n", prefixes);
9817         EXPECT_REF(nsmgr, 2);
9818         EXPECT_REF(mgr2, 2);
9819         EXPECT_REF(prefixes, 1);
9820
9821         IVBMXNamespaceManager_QueryInterface(mgr2, &IID_IUnknown, (void**)&unk1);
9822         IMXNamespacePrefixes_QueryInterface(prefixes, &IID_IUnknown, (void**)&unk2);
9823
9824         EXPECT_REF(mgr2, 3);
9825         EXPECT_REF(prefixes, 2);
9826
9827         IUnknown_Release(unk1);
9828         IUnknown_Release(unk2);
9829
9830         hr = IMXNamespacePrefixes_QueryInterface(prefixes, &IID_IDispatchEx, (void**)&dispex);
9831         ok(hr == S_OK, "got 0x%08x\n", hr);
9832
9833         V_VT(&arg) = VT_I4;
9834         V_I4(&arg) = 0;
9835         dispparams.cArgs = 1;
9836         dispparams.cNamedArgs = 0;
9837         dispparams.rgdispidNamedArgs = NULL;
9838         dispparams.rgvarg = &arg;
9839
9840         V_VT(&ret) = VT_EMPTY;
9841         V_DISPATCH(&ret) = (void*)0x1;
9842         hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
9843         ok(hr == S_OK, "got 0x%08x\n", hr);
9844         ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
9845         ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
9846
9847         IDispatchEx_Release(dispex);
9848         IMXNamespacePrefixes_Release(prefixes);
9849     }
9850     IVBMXNamespaceManager_Release(mgr2);
9851
9852     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
9853     EXPECT_HR(hr, S_OK);
9854
9855     /* prefix already added */
9856     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
9857     EXPECT_HR(hr, S_FALSE);
9858
9859     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), NULL);
9860     EXPECT_HR(hr, E_INVALIDARG);
9861
9862     /* "xml" and "xmlns" are not allowed here */
9863     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xml"), _bstr_("uri1"));
9864     EXPECT_HR(hr, E_INVALIDARG);
9865
9866     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xmlns"), _bstr_("uri1"));
9867     EXPECT_HR(hr, E_INVALIDARG);
9868 todo_wine {
9869     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, -1, NULL, NULL);
9870     EXPECT_HR(hr, E_FAIL);
9871 }
9872     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, NULL);
9873     EXPECT_HR(hr, E_POINTER);
9874
9875     len = -1;
9876     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, &len);
9877     EXPECT_HR(hr, S_OK);
9878     ok(len == 3, "got %d\n", len);
9879
9880     len = -1;
9881     buffW[0] = 0x1;
9882     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
9883     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
9884     ok(len == -1, "got %d\n", len);
9885     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9886
9887     len = 10;
9888     buffW[0] = 0x1;
9889     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
9890     EXPECT_HR(hr, S_OK);
9891     ok(len == 3, "got %d\n", len);
9892     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
9893
9894     /* getURI */
9895     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, NULL);
9896     EXPECT_HR(hr, E_INVALIDARG);
9897
9898     len = -1;
9899     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, &len);
9900     EXPECT_HR(hr, E_INVALIDARG);
9901     ok(len == -1, "got %d\n", len);
9902
9903     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, NULL);
9904     EXPECT_HR(hr, E_POINTER);
9905
9906     len = -1;
9907     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, &len);
9908     EXPECT_HR(hr, S_OK);
9909     /* length of "xml" uri is constant */
9910     ok(len == strlen(xmluriA), "got %d\n", len);
9911
9912     len = 100;
9913     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
9914     EXPECT_HR(hr, S_OK);
9915     ok(len == strlen(xmluriA), "got %d\n", len);
9916     ok(!lstrcmpW(buffW, _bstr_(xmluriA)), "got prefix %s\n", wine_dbgstr_w(buffW));
9917
9918     len = strlen(xmluriA)-1;
9919     buffW[0] = 0x1;
9920     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
9921     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
9922     ok(len == strlen(xmluriA)-1, "got %d\n", len);
9923     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9924
9925     /* prefix xml1 not defined */
9926     len = -1;
9927     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, NULL, &len);
9928     EXPECT_HR(hr, S_FALSE);
9929     ok(len == 0, "got %d\n", len);
9930
9931     len = 100;
9932     buffW[0] = 0x1;
9933     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, buffW, &len);
9934     EXPECT_HR(hr, S_FALSE);
9935     ok(buffW[0] == 0, "got %x\n", buffW[0]);
9936     ok(len == 0, "got %d\n", len);
9937
9938     /* IDispatchEx tests */
9939     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IUnknown, (void**)&unk);
9940     EXPECT_HR(hr, S_OK);
9941     test_domobj_dispex(unk);
9942     IUnknown_Release(unk);
9943
9944     IMXNamespaceManager_Release(nsmgr);
9945
9946     /* ::getPrefix() */
9947     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
9948         &IID_IMXNamespaceManager, (void**)&nsmgr);
9949     EXPECT_HR(hr, S_OK);
9950
9951     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, NULL);
9952     EXPECT_HR(hr, E_INVALIDARG);
9953
9954     len = -1;
9955     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, &len);
9956     EXPECT_HR(hr, E_INVALIDARG);
9957     ok(len == -1, "got %d\n", len);
9958
9959     len = 100;
9960     buffW[0] = 0x1;
9961     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
9962     EXPECT_HR(hr, E_FAIL);
9963     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9964     ok(len == 100, "got %d\n", len);
9965
9966     len = 0;
9967     buffW[0] = 0x1;
9968     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
9969     EXPECT_HR(hr, E_FAIL);
9970     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9971     ok(len == 0, "got %d\n", len);
9972
9973     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
9974     EXPECT_HR(hr, S_OK);
9975
9976     len = 100;
9977     buffW[0] = 0x1;
9978     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
9979     EXPECT_HR(hr, S_OK);
9980     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
9981     ok(len == 3, "got %d\n", len);
9982
9983     len = 100;
9984     buffW[0] = 0x1;
9985     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, buffW, &len);
9986     EXPECT_HR(hr, S_OK);
9987     ok(!lstrcmpW(buffW, _bstr_("xml")), "got %s\n", wine_dbgstr_w(buffW));
9988     ok(len == 3, "got %d\n", len);
9989
9990     /* with null buffer it's possible to get required length */
9991     len = 100;
9992     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
9993     EXPECT_HR(hr, S_OK);
9994     ok(len == 3, "got %d\n", len);
9995
9996     len = 0;
9997     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
9998     EXPECT_HR(hr, S_OK);
9999     ok(len == 3, "got %d\n", len);
10000
10001     len = 100;
10002     buffW[0] = 0x1;
10003     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 1, buffW, &len);
10004     EXPECT_HR(hr, E_FAIL);
10005     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10006     ok(len == 100, "got %d\n", len);
10007
10008     len = 100;
10009     buffW[0] = 0x1;
10010     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 2, buffW, &len);
10011     EXPECT_HR(hr, E_FAIL);
10012     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10013     ok(len == 100, "got %d\n", len);
10014
10015     len = 100;
10016     buffW[0] = 0x1;
10017     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 0, buffW, &len);
10018     EXPECT_HR(hr, E_INVALIDARG);
10019     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10020     ok(len == 100, "got %d\n", len);
10021
10022     len = 100;
10023     buffW[0] = 0x1;
10024     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
10025     EXPECT_HR(hr, E_INVALIDARG);
10026     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10027     ok(len == 100, "got %d\n", len);
10028
10029     len = 100;
10030     buffW[0] = 0x1;
10031     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, buffW, &len);
10032     EXPECT_HR(hr, E_INVALIDARG);
10033     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10034     ok(len == 100, "got %d\n", len);
10035
10036     len = 100;
10037     buffW[0] = 0x1;
10038     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 1, buffW, &len);
10039     EXPECT_HR(hr, E_FAIL);
10040     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10041     ok(len == 100, "got %d\n", len);
10042
10043     len = 100;
10044     buffW[0] = 0x1;
10045     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
10046     EXPECT_HR(hr, E_INVALIDARG);
10047     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10048     ok(len == 100, "got %d\n", len);
10049
10050     /* declare another one, indices are shifted */
10051     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
10052     EXPECT_HR(hr, S_OK);
10053
10054     len = 100;
10055     buffW[0] = 0x1;
10056     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10057     EXPECT_HR(hr, S_OK);
10058     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10059     ok(len == 3, "got %d\n", len);
10060
10061     len = 100;
10062     buffW[0] = 0x1;
10063     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10064     EXPECT_HR(hr, S_OK);
10065     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
10066     ok(len == 3, "got %d\n", len);
10067
10068     len = 100;
10069     buffW[0] = 0x1;
10070     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 1, buffW, &len);
10071     EXPECT_HR(hr, E_FAIL);
10072     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10073     ok(len == 100, "got %d\n", len);
10074
10075     len = 100;
10076     buffW[0] = 0x1;
10077     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
10078     EXPECT_HR(hr, E_INVALIDARG);
10079     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10080     ok(len == 100, "got %d\n", len);
10081
10082     IMXNamespaceManager_Release(nsmgr);
10083
10084     /* push/pop tests */
10085     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10086         &IID_IMXNamespaceManager, (void**)&nsmgr);
10087     EXPECT_HR(hr, S_OK);
10088
10089     /* pop with empty stack */
10090     hr = IMXNamespaceManager_popContext(nsmgr);
10091     EXPECT_HR(hr, E_FAIL);
10092
10093     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
10094     EXPECT_HR(hr, S_OK);
10095
10096     len = 100;
10097     buffW[0] = 0x1;
10098     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10099     EXPECT_HR(hr, S_OK);
10100     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10101     ok(len == 3, "got %d\n", len);
10102
10103     hr = IMXNamespaceManager_pushContext(nsmgr);
10104     EXPECT_HR(hr, S_OK);
10105
10106     len = 100;
10107     buffW[0] = 0x1;
10108     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10109     EXPECT_HR(hr, S_OK);
10110     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10111     ok(len == 3, "got %d\n", len);
10112
10113     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
10114     EXPECT_HR(hr, S_OK);
10115
10116     len = 100;
10117     buffW[0] = 0x1;
10118     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10119     EXPECT_HR(hr, S_OK);
10120     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
10121     ok(len == 3, "got %d\n", len);
10122
10123     hr = IMXNamespaceManager_pushContext(nsmgr);
10124     EXPECT_HR(hr, S_OK);
10125     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns3"), _bstr_("ns3 uri"));
10126     EXPECT_HR(hr, S_OK);
10127
10128     len = 100;
10129     buffW[0] = 0x1;
10130     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10131     EXPECT_HR(hr, S_OK);
10132     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
10133     ok(len == 3, "got %d\n", len);
10134
10135     len = 100;
10136     buffW[0] = 0x1;
10137     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10138     EXPECT_HR(hr, S_OK);
10139     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10140     ok(len == 3, "got %d\n", len);
10141
10142     hr = IMXNamespaceManager_popContext(nsmgr);
10143     EXPECT_HR(hr, S_OK);
10144
10145     hr = IMXNamespaceManager_popContext(nsmgr);
10146     EXPECT_HR(hr, S_OK);
10147
10148     len = 100;
10149     buffW[0] = 0x1;
10150     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10151     EXPECT_HR(hr, E_FAIL);
10152     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10153     ok(len == 100, "got %d\n", len);
10154
10155     len = 100;
10156     buffW[0] = 0x1;
10157     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10158     EXPECT_HR(hr, S_OK);
10159     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10160     ok(len == 3, "got %d\n", len);
10161
10162     IMXNamespaceManager_Release(nsmgr);
10163
10164     free_bstrs();
10165 }
10166
10167 static void test_mxnamespacemanager_override(void)
10168 {
10169     IMXNamespaceManager *nsmgr;
10170     WCHAR buffW[250];
10171     VARIANT_BOOL b;
10172     HRESULT hr;
10173     INT len;
10174
10175     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10176         &IID_IMXNamespaceManager, (void**)&nsmgr);
10177     EXPECT_HR(hr, S_OK);
10178
10179     len = sizeof(buffW)/sizeof(WCHAR);
10180     buffW[0] = 0;
10181     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10182     EXPECT_HR(hr, S_OK);
10183     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10184
10185     len = sizeof(buffW)/sizeof(WCHAR);
10186     buffW[0] = 0;
10187     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10188     EXPECT_HR(hr, E_FAIL);
10189
10190     hr = IMXNamespaceManager_getAllowOverride(nsmgr, NULL);
10191     EXPECT_HR(hr, E_POINTER);
10192
10193     b = VARIANT_FALSE;
10194     hr = IMXNamespaceManager_getAllowOverride(nsmgr, &b);
10195     EXPECT_HR(hr, S_OK);
10196     ok(b == VARIANT_TRUE, "got %d\n", b);
10197
10198     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_FALSE);
10199     EXPECT_HR(hr, S_OK);
10200
10201     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10202     EXPECT_HR(hr, S_OK);
10203
10204     len = sizeof(buffW)/sizeof(WCHAR);
10205     buffW[0] = 0;
10206     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
10207     EXPECT_HR(hr, S_OK);
10208     ok(!lstrcmpW(buffW, _bstr_("ns0 uri")), "got uri %s\n", wine_dbgstr_w(buffW));
10209
10210     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), _bstr_("ns0 uri"));
10211     EXPECT_HR(hr, S_OK);
10212
10213     len = sizeof(buffW)/sizeof(WCHAR);
10214     buffW[0] = 0;
10215     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10216     EXPECT_HR(hr, S_OK);
10217     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10218
10219     len = sizeof(buffW)/sizeof(WCHAR);
10220     buffW[0] = 0;
10221     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10222     EXPECT_HR(hr, S_OK);
10223     ok(!lstrcmpW(buffW, _bstr_("ns0")), "got prefix %s\n", wine_dbgstr_w(buffW));
10224
10225     len = sizeof(buffW)/sizeof(WCHAR);
10226     buffW[0] = 0;
10227     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 2, buffW, &len);
10228     EXPECT_HR(hr, S_OK);
10229     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
10230
10231     /* new prefix placed at index 1 always */
10232     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
10233     EXPECT_HR(hr, S_OK);
10234
10235     len = sizeof(buffW)/sizeof(WCHAR);
10236     buffW[0] = 0;
10237     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10238     EXPECT_HR(hr, S_OK);
10239     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got prefix %s\n", wine_dbgstr_w(buffW));
10240
10241     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_(""), NULL);
10242     todo_wine EXPECT_HR(hr, E_FAIL);
10243
10244     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
10245     EXPECT_HR(hr, E_FAIL);
10246
10247     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10248     EXPECT_HR(hr, E_FAIL);
10249
10250     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_TRUE);
10251     EXPECT_HR(hr, S_OK);
10252
10253     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri override"));
10254     EXPECT_HR(hr, S_FALSE);
10255
10256     len = sizeof(buffW)/sizeof(WCHAR);
10257     buffW[0] = 0;
10258     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
10259     EXPECT_HR(hr, S_OK);
10260     ok(!lstrcmpW(buffW, _bstr_("ns0 uri override")), "got uri %s\n", wine_dbgstr_w(buffW));
10261
10262     len = sizeof(buffW)/sizeof(WCHAR);
10263     buffW[0] = 0;
10264     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 3, buffW, &len);
10265     EXPECT_HR(hr, S_OK);
10266     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
10267
10268     IMXNamespaceManager_Release(nsmgr);
10269
10270     free_bstrs();
10271 }
10272
10273 static const DOMNodeType nodetypes_test[] =
10274 {
10275     NODE_ELEMENT,
10276     NODE_ATTRIBUTE,
10277     NODE_TEXT,
10278     NODE_CDATA_SECTION,
10279     NODE_ENTITY_REFERENCE,
10280     NODE_PROCESSING_INSTRUCTION,
10281     NODE_COMMENT,
10282     NODE_DOCUMENT_FRAGMENT,
10283     NODE_INVALID
10284 };
10285
10286 static void test_dispex(void)
10287 {
10288     const DOMNodeType *type = nodetypes_test;
10289     IXMLDOMImplementation *impl;
10290     IXMLDOMNodeList *node_list;
10291     IXMLDOMParseError *error;
10292     IXMLDOMNamedNodeMap *map;
10293     IXSLProcessor *processor;
10294     IXSLTemplate *template;
10295     IXMLDOMDocument *doc;
10296     IXMLHTTPRequest *req;
10297     IXMLDOMElement *elem;
10298     IDispatchEx *dispex;
10299     DISPPARAMS dispparams;
10300     IXMLDOMNode *node;
10301     VARIANT arg, ret;
10302     VARIANT_BOOL b;
10303     IUnknown *unk;
10304     HRESULT hr;
10305     DISPID did;
10306
10307     doc = create_document(&IID_IXMLDOMDocument);
10308
10309     IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
10310     test_domobj_dispex(unk);
10311     IUnknown_Release(unk);
10312
10313     for(; *type != NODE_INVALID; type++)
10314     {
10315         IXMLDOMNode *node;
10316         VARIANT v;
10317
10318         V_VT(&v) = VT_I2;
10319         V_I2(&v) = *type;
10320
10321         hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
10322         ok(hr == S_OK, "failed to create node type %d\n", *type);
10323
10324         IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
10325
10326         test_domobj_dispex(unk);
10327         IUnknown_Release(unk);
10328         IXMLDOMNode_Release(node);
10329     }
10330
10331     /* IXMLDOMNodeList */
10332     hr = IXMLDOMDocument_getElementsByTagName(doc, _bstr_("*"), &node_list);
10333     EXPECT_HR(hr, S_OK);
10334     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
10335     test_domobj_dispex(unk);
10336     IUnknown_Release(unk);
10337     IXMLDOMNodeList_Release(node_list);
10338
10339     /* IXMLDOMNodeList for children list */
10340     hr = IXMLDOMDocument_get_childNodes(doc, &node_list);
10341     EXPECT_HR(hr, S_OK);
10342     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
10343     test_domobj_dispex(unk);
10344     IUnknown_Release(unk);
10345
10346     /* collection dispex test, empty collection */
10347     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatchEx, (void**)&dispex);
10348     EXPECT_HR(hr, S_OK);
10349     did = 0;
10350     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10351     EXPECT_HR(hr, S_OK);
10352     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10353     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
10354     EXPECT_HR(hr, S_OK);
10355     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
10356     IDispatchEx_Release(dispex);
10357
10358     did = -1;
10359     hr = IDispatchEx_GetDispID(dispex, _bstr_("item"), 0, &did);
10360     ok(hr == S_OK, "got 0x%08x\n", hr);
10361     ok(did == DISPID_VALUE, "got %d\n", did);
10362
10363     V_VT(&arg) = VT_I4;
10364     V_I4(&arg) = 0;
10365     dispparams.cArgs = 0;
10366     dispparams.cNamedArgs = 0;
10367     dispparams.rgdispidNamedArgs = NULL;
10368     dispparams.rgvarg = &arg;
10369
10370     V_VT(&ret) = VT_EMPTY;
10371     V_DISPATCH(&ret) = (void*)0x1;
10372     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10373     ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
10374     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10375     ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
10376
10377     V_VT(&arg) = VT_I4;
10378     V_I4(&arg) = 0;
10379     dispparams.cArgs = 2;
10380     dispparams.cNamedArgs = 0;
10381     dispparams.rgdispidNamedArgs = NULL;
10382     dispparams.rgvarg = &arg;
10383
10384     V_VT(&ret) = VT_EMPTY;
10385     V_DISPATCH(&ret) = (void*)0x1;
10386     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10387     ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
10388     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10389     ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
10390
10391     V_VT(&arg) = VT_I4;
10392     V_I4(&arg) = 0;
10393     dispparams.cArgs = 1;
10394     dispparams.cNamedArgs = 0;
10395     dispparams.rgdispidNamedArgs = NULL;
10396     dispparams.rgvarg = &arg;
10397
10398     V_VT(&ret) = VT_EMPTY;
10399     V_DISPATCH(&ret) = (void*)0x1;
10400     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10401     ok(hr == S_OK, "got 0x%08x\n", hr);
10402     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10403     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10404
10405     V_VT(&ret) = VT_EMPTY;
10406     V_DISPATCH(&ret) = (void*)0x1;
10407     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10408     ok(hr == S_OK, "got 0x%08x\n", hr);
10409     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10410     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10411
10412     V_VT(&ret) = VT_EMPTY;
10413     V_DISPATCH(&ret) = (void*)0x1;
10414     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10415     ok(hr == S_OK, "got 0x%08x\n", hr);
10416     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10417     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10418
10419     dispparams.cArgs = 0;
10420     dispparams.cNamedArgs = 0;
10421     dispparams.rgdispidNamedArgs = NULL;
10422     dispparams.rgvarg = NULL;
10423
10424     V_VT(&ret) = VT_EMPTY;
10425     V_I4(&ret) = 1;
10426     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10427     ok(hr == S_OK, "got 0x%08x\n", hr);
10428     ok(V_VT(&ret) == VT_I4, "got %d\n", V_VT(&ret));
10429     ok(V_I4(&ret) == 0, "got %d\n", V_I4(&ret));
10430
10431     dispparams.cArgs = 0;
10432     dispparams.cNamedArgs = 0;
10433     dispparams.rgdispidNamedArgs = NULL;
10434     dispparams.rgvarg = NULL;
10435
10436     V_VT(&ret) = VT_EMPTY;
10437     V_I4(&ret) = 1;
10438     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10439     ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
10440     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10441     ok(V_I4(&ret) == 1, "got %d\n", V_I4(&ret));
10442
10443     IXMLDOMNodeList_Release(node_list);
10444
10445     /* IXMLDOMParseError */
10446     hr = IXMLDOMDocument_get_parseError(doc, &error);
10447     EXPECT_HR(hr, S_OK);
10448     IXMLDOMParseError_QueryInterface(error, &IID_IUnknown, (void**)&unk);
10449     test_domobj_dispex(unk);
10450
10451     hr = IXMLDOMParseError_QueryInterface(error, &IID_IDispatchEx, (void**)&dispex);
10452     ok(hr == S_OK, "got 0x%08x\n", hr);
10453
10454     V_VT(&arg) = VT_I4;
10455     V_I4(&arg) = 0;
10456     dispparams.cArgs = 1;
10457     dispparams.cNamedArgs = 0;
10458     dispparams.rgdispidNamedArgs = NULL;
10459     dispparams.rgvarg = &arg;
10460
10461     V_VT(&ret) = VT_EMPTY;
10462     V_DISPATCH(&ret) = (void*)0x1;
10463     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10464     ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
10465     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10466     ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
10467
10468     IDispatchEx_Release(dispex);
10469
10470     IUnknown_Release(unk);
10471     IXMLDOMParseError_Release(error);
10472
10473     /* IXMLDOMNamedNodeMap */
10474     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
10475     EXPECT_HR(hr, S_OK);
10476
10477     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/a"), &node_list);
10478     EXPECT_HR(hr, S_OK);
10479     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
10480     EXPECT_HR(hr, S_OK);
10481     IXMLDOMNodeList_Release(node_list);
10482
10483     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
10484     EXPECT_HR(hr, S_OK);
10485     IXMLDOMNode_Release(node);
10486     hr = IXMLDOMElement_get_attributes(elem, &map);
10487     EXPECT_HR(hr, S_OK);
10488     IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk);
10489     test_domobj_dispex(unk);
10490     IUnknown_Release(unk);
10491     /* collection dispex test */
10492     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
10493     EXPECT_HR(hr, S_OK);
10494     did = 0;
10495     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10496     EXPECT_HR(hr, S_OK);
10497     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10498     IDispatchEx_Release(dispex);
10499
10500     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/b"), &node_list);
10501     EXPECT_HR(hr, S_OK);
10502     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
10503     EXPECT_HR(hr, S_OK);
10504     IXMLDOMNodeList_Release(node_list);
10505     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
10506     EXPECT_HR(hr, S_OK);
10507     IXMLDOMNode_Release(node);
10508     hr = IXMLDOMElement_get_attributes(elem, &map);
10509     EXPECT_HR(hr, S_OK);
10510     /* collection dispex test, empty collection */
10511     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
10512     EXPECT_HR(hr, S_OK);
10513     did = 0;
10514     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10515     EXPECT_HR(hr, S_OK);
10516     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10517     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
10518     EXPECT_HR(hr, S_OK);
10519     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
10520     IDispatchEx_Release(dispex);
10521
10522     did = -1;
10523     hr = IDispatchEx_GetDispID(dispex, _bstr_("item"), 0, &did);
10524     ok(hr == S_OK, "got 0x%08x\n", hr);
10525     ok(did == DISPID_VALUE, "got %d\n", did);
10526
10527     V_VT(&arg) = VT_I4;
10528     V_I4(&arg) = 0;
10529     dispparams.cArgs = 0;
10530     dispparams.cNamedArgs = 0;
10531     dispparams.rgdispidNamedArgs = NULL;
10532     dispparams.rgvarg = &arg;
10533
10534     V_VT(&ret) = VT_EMPTY;
10535     V_DISPATCH(&ret) = (void*)0x1;
10536     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10537 todo_wine {
10538     ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
10539     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10540     ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
10541 }
10542     V_VT(&arg) = VT_I4;
10543     V_I4(&arg) = 0;
10544     dispparams.cArgs = 2;
10545     dispparams.cNamedArgs = 0;
10546     dispparams.rgdispidNamedArgs = NULL;
10547     dispparams.rgvarg = &arg;
10548
10549     V_VT(&ret) = VT_EMPTY;
10550     V_DISPATCH(&ret) = (void*)0x1;
10551     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10552 todo_wine {
10553     ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
10554     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10555     ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
10556 }
10557     V_VT(&arg) = VT_I4;
10558     V_I4(&arg) = 0;
10559     dispparams.cArgs = 1;
10560     dispparams.cNamedArgs = 0;
10561     dispparams.rgdispidNamedArgs = NULL;
10562     dispparams.rgvarg = &arg;
10563
10564     V_VT(&ret) = VT_EMPTY;
10565     V_DISPATCH(&ret) = (void*)0x1;
10566     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10567 todo_wine
10568     ok(hr == S_OK, "got 0x%08x\n", hr);
10569     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10570     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10571
10572     V_VT(&ret) = VT_EMPTY;
10573     V_DISPATCH(&ret) = (void*)0x1;
10574     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10575     ok(hr == S_OK, "got 0x%08x\n", hr);
10576     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10577     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10578
10579     V_VT(&ret) = VT_EMPTY;
10580     V_DISPATCH(&ret) = (void*)0x1;
10581     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10582     ok(hr == S_OK, "got 0x%08x\n", hr);
10583     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10584     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10585
10586     dispparams.cArgs = 0;
10587     dispparams.cNamedArgs = 0;
10588     dispparams.rgdispidNamedArgs = NULL;
10589     dispparams.rgvarg = NULL;
10590
10591     V_VT(&ret) = VT_EMPTY;
10592     V_I4(&ret) = 1;
10593     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10594     ok(hr == S_OK, "got 0x%08x\n", hr);
10595     ok(V_VT(&ret) == VT_I4, "got %d\n", V_VT(&ret));
10596     ok(V_I4(&ret) == 0, "got %d\n", V_I4(&ret));
10597
10598     dispparams.cArgs = 0;
10599     dispparams.cNamedArgs = 0;
10600     dispparams.rgdispidNamedArgs = NULL;
10601     dispparams.rgvarg = NULL;
10602
10603     V_VT(&ret) = VT_EMPTY;
10604     V_I4(&ret) = 1;
10605     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10606     ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
10607 todo_wine {
10608     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10609     ok(V_I4(&ret) == 1, "got %d\n", V_I4(&ret));
10610 }
10611     IXMLDOMNamedNodeMap_Release(map);
10612     IXMLDOMElement_Release(elem);
10613
10614     /* IXMLDOMImplementation */
10615     hr = IXMLDOMDocument_get_implementation(doc, &impl);
10616     EXPECT_HR(hr, S_OK);
10617
10618     hr = IXMLDOMImplementation_QueryInterface(impl, &IID_IDispatchEx, (void**)&dispex);
10619     EXPECT_HR(hr, S_OK);
10620     IDispatchEx_Release(dispex);
10621     IXMLDOMImplementation_Release(impl);
10622
10623     IXMLDOMDocument_Release(doc);
10624
10625     /* IXMLHTTPRequest */
10626     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
10627         &IID_IXMLHttpRequest, (void**)&req);
10628     if (hr == S_OK)
10629     {
10630         hr = IXMLHTTPRequest_QueryInterface(req, &IID_IDispatchEx, (void**)&dispex);
10631         EXPECT_HR(hr, E_NOINTERFACE);
10632         IXMLHTTPRequest_Release(req);
10633     }
10634
10635     /* IXSLTemplate */
10636     template = create_xsltemplate(&IID_IXSLTemplate);
10637     hr = IXSLTemplate_QueryInterface(template, &IID_IDispatchEx, (void**)&dispex);
10638     EXPECT_HR(hr, S_OK);
10639     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
10640     EXPECT_HR(hr, S_OK);
10641     test_domobj_dispex(unk);
10642     IUnknown_Release(unk);
10643     IDispatchEx_Release(dispex);
10644
10645     /* IXSLProcessor */
10646     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
10647     EXPECT_HR(hr, S_OK);
10648     b = VARIANT_FALSE;
10649     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformSSXML), &b);
10650     EXPECT_HR(hr, S_OK);
10651     ok(b == VARIANT_TRUE, "got %d\n", b);
10652
10653     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
10654     EXPECT_HR(hr, S_OK);
10655     IXMLDOMDocument_Release(doc);
10656
10657     hr = IXSLTemplate_createProcessor(template, &processor);
10658     EXPECT_HR(hr, S_OK);
10659     hr = IXSLProcessor_QueryInterface(processor, &IID_IDispatchEx, (void**)&dispex);
10660     EXPECT_HR(hr, S_OK);
10661     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
10662     EXPECT_HR(hr, S_OK);
10663     test_domobj_dispex(unk);
10664     IUnknown_Release(unk);
10665     IDispatchEx_Release(dispex);
10666
10667     IXSLProcessor_Release(processor);
10668     IXSLTemplate_Release(template);
10669
10670     free_bstrs();
10671 }
10672
10673 static void test_parseerror(void)
10674 {
10675     IXMLDOMParseError2 *error2;
10676     IXMLDOMParseError *error;
10677     IXMLDOMDocument *doc;
10678     HRESULT hr;
10679
10680     doc = create_document(&IID_IXMLDOMDocument);
10681
10682     hr = IXMLDOMDocument_get_parseError(doc, &error);
10683     EXPECT_HR(hr, S_OK);
10684
10685     hr = IXMLDOMParseError_get_line(error, NULL);
10686     EXPECT_HR(hr, E_INVALIDARG);
10687
10688     hr = IXMLDOMParseError_get_srcText(error, NULL);
10689     EXPECT_HR(hr, E_INVALIDARG);
10690
10691     hr = IXMLDOMParseError_get_linepos(error, NULL);
10692     EXPECT_HR(hr, E_INVALIDARG);
10693
10694     IXMLDOMParseError_Release(error);
10695     IXMLDOMDocument_Release(doc);
10696
10697     if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument)) return;
10698     doc = create_document_version(60, &IID_IXMLDOMDocument);
10699
10700     hr = IXMLDOMDocument_get_parseError(doc, &error);
10701     EXPECT_HR(hr, S_OK);
10702     hr = IXMLDOMParseError_QueryInterface(error, &IID_IXMLDOMParseError2, (void**)&error2);
10703     EXPECT_HR(hr, S_OK);
10704     IXMLDOMParseError2_Release(error2);
10705     IXMLDOMParseError_Release(error);
10706     IXMLDOMDocument_Release(doc);
10707 }
10708
10709 static void test_getAttributeNode(void)
10710 {
10711     IXMLDOMAttribute *attr;
10712     IXMLDOMDocument *doc;
10713     IXMLDOMElement *elem;
10714     VARIANT_BOOL v;
10715     HRESULT hr;
10716     BSTR str;
10717
10718     doc = create_document(&IID_IXMLDOMDocument);
10719
10720     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &v);
10721     EXPECT_HR(hr, S_OK);
10722
10723     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10724     EXPECT_HR(hr, S_OK);
10725
10726     str = SysAllocString(nonexistent_fileW);
10727     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
10728     EXPECT_HR(hr, E_FAIL);
10729
10730     attr = (IXMLDOMAttribute*)0xdeadbeef;
10731     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
10732     EXPECT_HR(hr, E_FAIL);
10733     ok(attr == NULL, "got %p\n", attr);
10734     SysFreeString(str);
10735
10736     str = SysAllocString(nonexistent_attrW);
10737     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
10738     EXPECT_HR(hr, S_FALSE);
10739
10740     attr = (IXMLDOMAttribute*)0xdeadbeef;
10741     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
10742     EXPECT_HR(hr, S_FALSE);
10743     ok(attr == NULL, "got %p\n", attr);
10744     SysFreeString(str);
10745
10746     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("foo:b"), &attr);
10747     EXPECT_HR(hr, S_OK);
10748     IXMLDOMAttribute_Release(attr);
10749
10750     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("b"), &attr);
10751     EXPECT_HR(hr, S_FALSE);
10752
10753     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("a"), &attr);
10754     EXPECT_HR(hr, S_OK);
10755     IXMLDOMAttribute_Release(attr);
10756
10757     IXMLDOMElement_Release(elem);
10758     IXMLDOMDocument_Release(doc);
10759     free_bstrs();
10760 }
10761
10762 typedef struct {
10763     DOMNodeType type;
10764     const char *name;
10765     REFIID iids[3];
10766 } supporterror_t;
10767
10768 static const supporterror_t supporterror_test[] = {
10769     { NODE_ELEMENT,                "element",   { &IID_IXMLDOMNode, &IID_IXMLDOMElement } },
10770     { NODE_ATTRIBUTE,              "attribute", { &IID_IXMLDOMNode, &IID_IXMLDOMAttribute } },
10771     { NODE_CDATA_SECTION,          "cdata",     { &IID_IXMLDOMNode, &IID_IXMLDOMCDATASection } },
10772     { NODE_ENTITY_REFERENCE,       "entityref", { &IID_IXMLDOMNode, &IID_IXMLDOMEntityReference } },
10773     { NODE_PROCESSING_INSTRUCTION, "pi",        { &IID_IXMLDOMNode, &IID_IXMLDOMProcessingInstruction } },
10774     { NODE_COMMENT,                "comment",   { &IID_IXMLDOMNode, &IID_IXMLDOMComment } },
10775     { NODE_DOCUMENT_FRAGMENT,      "fragment",  { &IID_IXMLDOMNode, &IID_IXMLDOMDocumentFragment } },
10776     { NODE_INVALID }
10777 };
10778
10779 static void test_supporterrorinfo(void)
10780 {
10781     static REFIID iids[5] = { &IID_IXMLDOMNode, &IID_IXMLDOMDocument,
10782                               &IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3 };
10783     const supporterror_t *ptr = supporterror_test;
10784     ISupportErrorInfo *errorinfo, *info2;
10785     IXMLDOMSchemaCollection *schemacache;
10786     IXMLDOMNamedNodeMap *map, *map2;
10787     IXMLDOMDocument *doc;
10788     IXMLDOMElement *elem;
10789     VARIANT_BOOL b;
10790     IUnknown *unk;
10791     REFIID *iid;
10792     void *dummy;
10793     HRESULT hr;
10794
10795     if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument3)) return;
10796     doc = create_document_version(60, &IID_IXMLDOMDocument3);
10797
10798     EXPECT_REF(doc, 1);
10799     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&errorinfo);
10800     EXPECT_HR(hr, S_OK);
10801     EXPECT_REF(doc, 1);
10802     ISupportErrorInfo_AddRef(errorinfo);
10803     EXPECT_REF(errorinfo, 2);
10804     EXPECT_REF(doc, 1);
10805     ISupportErrorInfo_Release(errorinfo);
10806
10807     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&info2);
10808     EXPECT_HR(hr, S_OK);
10809     ok(errorinfo != info2, "got %p, %p\n", info2, errorinfo);
10810
10811     /* error interface can't be queried back for DOM interface */
10812     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMDocument, &dummy);
10813     EXPECT_HR(hr, E_NOINTERFACE);
10814     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMNode, &dummy);
10815     EXPECT_HR(hr, E_NOINTERFACE);
10816
10817     ISupportErrorInfo_Release(info2);
10818
10819     iid = iids;
10820     while (*iid)
10821     {
10822         hr = IXMLDOMDocument_QueryInterface(doc, *iid, (void**)&unk);
10823         EXPECT_HR(hr, S_OK);
10824         if (hr == S_OK)
10825         {
10826             hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
10827             ok(hr == S_OK, "got 0x%08x for %s\n", hr, wine_dbgstr_guid(*iid));
10828             IUnknown_Release(unk);
10829         }
10830
10831         iid++;
10832     }
10833
10834     ISupportErrorInfo_Release(errorinfo);
10835
10836     while (ptr->type != NODE_INVALID)
10837     {
10838         IXMLDOMNode *node;
10839         VARIANT type;
10840
10841         V_VT(&type) = VT_I1;
10842         V_I1(&type) = ptr->type;
10843
10844         hr = IXMLDOMDocument_createNode(doc, type, _bstr_(ptr->name), NULL, &node);
10845         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
10846
10847         EXPECT_REF(node, 1);
10848         hr = IXMLDOMNode_QueryInterface(node, &IID_ISupportErrorInfo, (void**)&errorinfo);
10849         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
10850         EXPECT_REF(node, 1);
10851
10852         hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNode, &dummy);
10853         ok(hr == E_NOINTERFACE, "%d: got 0x%08x\n", ptr->type, hr);
10854
10855         iid = ptr->iids;
10856
10857         while (*iid)
10858         {
10859             hr = IXMLDOMNode_QueryInterface(node, *iid, (void**)&unk);
10860             if (hr == S_OK)
10861             {
10862                 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
10863                 ok(hr == S_OK, "%d: got 0x%08x for %s\n", ptr->type, hr, wine_dbgstr_guid(*iid));
10864                 IUnknown_Release(unk);
10865             }
10866
10867             iid++;
10868         }
10869
10870         ISupportErrorInfo_Release(errorinfo);
10871         IXMLDOMNode_Release(node);
10872         ptr++;
10873     }
10874
10875     /* IXMLDOMNamedNodeMap */
10876     b = VARIANT_FALSE;
10877     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
10878     EXPECT_HR(hr, S_OK);
10879     ok(b == VARIANT_TRUE, "got %d\n", b);
10880
10881     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10882     EXPECT_HR(hr, S_OK);
10883
10884     hr = IXMLDOMElement_get_attributes(elem, &map);
10885     EXPECT_HR(hr, S_OK);
10886
10887     EXPECT_REF(map, 1);
10888     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_ISupportErrorInfo, (void**)&errorinfo);
10889     EXPECT_HR(hr, S_OK);
10890     EXPECT_REF(map, 2);
10891
10892     hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMNamedNodeMap);
10893     EXPECT_HR(hr, S_OK);
10894
10895     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNamedNodeMap, (void**)&map2);
10896     EXPECT_HR(hr, S_OK);
10897     ok(map == map2, "got %p\n", map2);
10898     IXMLDOMNamedNodeMap_Release(map2);
10899
10900     EXPECT_REF(errorinfo, 2);
10901     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IUnknown, (void**)&unk);
10902     EXPECT_HR(hr, S_OK);
10903     EXPECT_REF(errorinfo, 3);
10904     EXPECT_REF(map, 3);
10905     IUnknown_Release(unk);
10906
10907     ISupportErrorInfo_Release(errorinfo);
10908     IXMLDOMNamedNodeMap_Release(map);
10909     IXMLDOMElement_Release(elem);
10910
10911     IXMLDOMDocument_Release(doc);
10912
10913     /* IXMLDOMSchemaCollection */
10914     hr = CoCreateInstance(&CLSID_XMLSchemaCache, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMSchemaCollection, (void**)&schemacache);
10915     ok(hr == S_OK, "failed to create schema collection, 0x%08x\n", hr);
10916
10917     hr = IXMLDOMSchemaCollection_QueryInterface(schemacache, &IID_ISupportErrorInfo, (void**)&errorinfo);
10918     ok(hr == S_OK, "got 0x%08x\n", hr);
10919
10920     hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMSchemaCollection);
10921     ok(hr == S_OK, "got 0x%08x\n", hr);
10922
10923     ISupportErrorInfo_Release(errorinfo);
10924     IXMLDOMSchemaCollection_Release(schemacache);
10925
10926     free_bstrs();
10927 }
10928
10929 typedef struct {
10930     DOMNodeType type;
10931     const char *name;
10932     const char *put_content;
10933     HRESULT put_hr;
10934     VARTYPE get_vt;
10935     HRESULT get_hr;
10936 } node_value_t;
10937
10938 static const node_value_t nodevalue_test[] = {
10939     { NODE_ELEMENT,                "element",   "",             E_FAIL, VT_NULL, S_FALSE },
10940     { NODE_ATTRIBUTE,              "attr",      "value",        S_OK,   VT_BSTR, S_OK },
10941     { NODE_TEXT,                   "text",      "textdata",     S_OK,   VT_BSTR, S_OK },
10942     { NODE_CDATA_SECTION ,         "cdata",     "cdata data",   S_OK,   VT_BSTR, S_OK },
10943     { NODE_ENTITY_REFERENCE,       "entityref", "ref",          E_FAIL, VT_NULL, S_FALSE },
10944     { NODE_PROCESSING_INSTRUCTION, "pi",        "instr",        S_OK,   VT_BSTR, S_OK },
10945     { NODE_COMMENT,                "comment",   "comment data", S_OK,   VT_BSTR, S_OK },
10946     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   "",             E_FAIL, VT_NULL, S_FALSE },
10947     { NODE_INVALID }
10948 };
10949
10950 static void test_nodeValue(void)
10951 {
10952     const node_value_t *ptr = nodevalue_test;
10953     IXMLDOMDocument *doc;
10954     HRESULT hr;
10955
10956     doc = create_document(&IID_IXMLDOMDocument);
10957
10958     while (ptr->type != NODE_INVALID)
10959     {
10960         IXMLDOMNode *node;
10961         VARIANT v;
10962
10963         V_VT(&v) = VT_I2;
10964         V_I2(&v) = ptr->type;
10965
10966         hr = IXMLDOMDocument_createNode(doc, v, _bstr_(ptr->name), NULL, &node);
10967         ok(hr == S_OK, "failed to create node type %d\n", ptr->type);
10968
10969         hr = IXMLDOMNode_get_nodeValue(node, NULL);
10970         ok(hr == E_INVALIDARG, "%d: got 0x%08x\n", ptr->type, hr);
10971
10972         V_VT(&v) = VT_BSTR;
10973         V_BSTR(&v) = _bstr_(ptr->put_content);
10974         hr = IXMLDOMNode_put_nodeValue(node, v);
10975         ok(hr == ptr->put_hr, "%d: got 0x%08x\n", ptr->type, hr);
10976
10977         V_VT(&v) = VT_EMPTY;
10978         hr = IXMLDOMNode_get_nodeValue(node, &v);
10979         ok(hr == ptr->get_hr, "%d: got 0x%08x, expected 0x%08x\n", ptr->type, hr, ptr->get_hr);
10980         ok(V_VT(&v) == ptr->get_vt, "%d: got %d, expected %d\n", ptr->type, V_VT(&v), ptr->get_vt);
10981         if (hr == S_OK)
10982             ok(!lstrcmpW(V_BSTR(&v), _bstr_(ptr->put_content)), "%d: got %s\n", ptr->type,
10983                 wine_dbgstr_w(V_BSTR(&v)));
10984         VariantClear(&v);
10985
10986         IXMLDOMNode_Release(node);
10987
10988         ptr++;
10989     }
10990
10991     IXMLDOMDocument_Release(doc);
10992 }
10993
10994 static void test_xmlns_attribute(void)
10995 {
10996     BSTR str;
10997     IXMLDOMDocument *doc;
10998     IXMLDOMElement *root;
10999     IXMLDOMAttribute *pAttribute;
11000     IXMLDOMElement *elem;
11001     HRESULT hr;
11002     VARIANT v;
11003
11004     doc = create_document(&IID_IXMLDOMDocument);
11005
11006     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
11007     EXPECT_HR(hr, S_OK);
11008
11009     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
11010     EXPECT_HR(hr, S_OK);
11011
11012     str = SysAllocString(szAttribute);
11013     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("xmlns:dt"), &pAttribute);
11014     ok( hr == S_OK, "returns %08x\n", hr );
11015
11016     V_VT(&v) = VT_BSTR;
11017     V_BSTR(&v) = _bstr_("urn:schemas-microsoft-com:datatypes");
11018     hr = IXMLDOMAttribute_put_nodeValue(pAttribute, v);
11019
11020     hr = IXMLDOMElement_setAttributeNode(root, pAttribute, NULL);
11021     ok(hr == S_OK, "ret %08x\n", hr );
11022
11023     hr = IXMLDOMNode_put_dataType((IXMLDOMNode*)root, _bstr_("bin.base64"));
11024     ok(hr == S_OK, "ret %08x\n", hr );
11025
11026     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11027     EXPECT_HR(hr, S_OK);
11028
11029     hr = IXMLDOMElement_get_xml(elem, &str);
11030     ok( hr == S_OK, "got 0x%08x\n", hr);
11031     todo_wine ok( lstrcmpW(str, _bstr_("<Testing xmlns:dt=\"urn:schemas-microsoft-com:datatypes\" dt:dt=\"bin.base64\"/>")) == 0,
11032     "got %s\n", wine_dbgstr_w(str));
11033
11034     IXMLDOMElement_Release(elem);
11035     IXMLDOMAttribute_Release( pAttribute);
11036
11037     SysFreeString(str);
11038
11039     IXMLDOMDocument_Release(doc);
11040
11041     free_bstrs();
11042 }
11043
11044 static const char namespacesA[] =
11045 "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
11046 "   <ns1:elem1 xmlns:ns1=\"http://blah.org\" b='1' >"
11047 "     <ns2:elem2 xmlns:ns2=\"http://blah.org\"/>"
11048 "     <ns1:elem3/>"
11049 "     <ns1:elem4/>"
11050 "     <elem5 xmlns=\"http://blahblah.org\"/>"
11051 "     <ns1:elem6>true</ns1:elem6>"
11052 "   </ns1:elem1>";
11053
11054 static const char xsd_schema1_uri[] = "x-schema:test1.xsd";
11055 static const char xsd_schema1_xml[] =
11056 "<?xml version='1.0'?>"
11057 "<schema xmlns='http://www.w3.org/2001/XMLSchema'"
11058 "            targetNamespace='x-schema:test1.xsd'>"
11059 "   <element name='root'>"
11060 "       <complexType>"
11061 "           <sequence maxOccurs='unbounded'>"
11062 "               <any/>"
11063 "           </sequence>"
11064 "       </complexType>"
11065 "   </element>"
11066 "</schema>";
11067
11068 static void test_get_namespaces(void)
11069 {
11070     IXMLDOMSchemaCollection *collection, *collection2;
11071     IXMLDOMDocument2 *doc, *doc2;
11072     IEnumVARIANT *enumv, *enum2;
11073     IUnknown *unk1, *unk2;
11074     IXMLDOMNode *node;
11075     VARIANT_BOOL b;
11076     HRESULT hr;
11077     VARIANT v;
11078     LONG len;
11079     BSTR s;
11080
11081     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
11082     doc = create_document(&IID_IXMLDOMDocument2);
11083
11084     /* null pointer */
11085     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
11086     EXPECT_HR(hr, E_POINTER);
11087
11088     /* no document loaded */
11089     collection = (void*)0xdeadbeef;
11090     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11091     EXPECT_HR(hr, S_OK);
11092     if (hr != S_OK)
11093     {
11094         IXMLDOMDocument2_Release(doc);
11095         return;
11096     }
11097     EXPECT_REF(collection, 2);
11098
11099     collection2 = (void*)0xdeadbeef;
11100     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
11101     EXPECT_HR(hr, S_OK);
11102     ok(collection == collection2, "got %p\n", collection2);
11103     EXPECT_REF(collection, 3);
11104     IXMLDOMSchemaCollection_Release(collection);
11105
11106     len = -1;
11107     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11108     EXPECT_HR(hr, S_OK);
11109     ok(len == 0, "got %d\n", len);
11110     IXMLDOMSchemaCollection_Release(collection);
11111
11112     /* now with document */
11113     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
11114     EXPECT_HR(hr, S_OK);
11115
11116     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11117     EXPECT_HR(hr, S_OK);
11118
11119     len = -1;
11120     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11121     EXPECT_HR(hr, S_OK);
11122     ok(len == 2, "got %d\n", len);
11123
11124     /* try to lookup some uris */
11125     node = (void*)0xdeadbeef;
11126     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
11127     EXPECT_HR(hr, S_OK);
11128     ok(node == NULL, "got %p\n", node);
11129
11130     node = (void*)0xdeadbeef;
11131     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah1.org"), &node);
11132     EXPECT_HR(hr, S_OK);
11133     ok(node == NULL, "got %p\n", node);
11134
11135     /* load schema and try to add it */
11136     doc2 = create_document(&IID_IXMLDOMDocument2);
11137     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
11138     EXPECT_HR(hr, S_OK);
11139
11140     V_VT(&v) = VT_DISPATCH;
11141     V_DISPATCH(&v) = (IDispatch*)doc2;
11142     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
11143     EXPECT_HR(hr, E_FAIL);
11144
11145     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
11146     EXPECT_HR(hr, S_OK);
11147     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
11148     SysFreeString(s);
11149
11150     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
11151     EXPECT_HR(hr, S_OK);
11152     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
11153     SysFreeString(s);
11154
11155     s = (void*)0xdeadbeef;
11156     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
11157     EXPECT_HR(hr, E_FAIL);
11158     ok(s == (void*)0xdeadbeef, "got %p\n", s);
11159
11160     /* enumerate */
11161     enumv = (void*)0xdeadbeef;
11162     EXPECT_REF(collection, 2);
11163     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
11164     EXPECT_HR(hr, S_OK);
11165     EXPECT_REF(collection, 3);
11166     ok(enumv != NULL, "got %p\n", enumv);
11167
11168     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IUnknown, (void**)&unk1);
11169     EXPECT_HR(hr, S_OK);
11170     hr = IEnumVARIANT_QueryInterface(enumv, &IID_IUnknown, (void**)&unk2);
11171     EXPECT_HR(hr, S_OK);
11172     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
11173     IUnknown_Release(unk1);
11174     IUnknown_Release(unk2);
11175
11176     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IEnumVARIANT, (void**)&enum2);
11177     EXPECT_HR(hr, E_NOINTERFACE);
11178
11179     V_VT(&v) = VT_EMPTY;
11180     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11181     EXPECT_HR(hr, S_OK);
11182     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11183     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11184     VariantClear(&v);
11185
11186     V_VT(&v) = VT_EMPTY;
11187     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11188     EXPECT_HR(hr, S_OK);
11189     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11190     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11191     VariantClear(&v);
11192
11193     V_VT(&v) = VT_NULL;
11194     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11195     EXPECT_HR(hr, S_FALSE);
11196     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
11197
11198     IEnumVARIANT_Release(enumv);
11199     IXMLDOMSchemaCollection_Release(collection);
11200
11201     IXMLDOMDocument2_Release(doc);
11202
11203     /* now with CLSID_DOMDocument60 */
11204     if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument2)) return;
11205     doc = create_document_version(60, &IID_IXMLDOMDocument2);
11206
11207     /* null pointer */
11208     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
11209     EXPECT_HR(hr, E_POINTER);
11210
11211     /* no document loaded */
11212     collection = (void*)0xdeadbeef;
11213     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11214     EXPECT_HR(hr, S_OK);
11215     if (hr != S_OK)
11216     {
11217         IXMLDOMDocument2_Release(doc);
11218         return;
11219     }
11220     EXPECT_REF(collection, 2);
11221
11222     collection2 = (void*)0xdeadbeef;
11223     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
11224     EXPECT_HR(hr, S_OK);
11225     ok(collection == collection2, "got %p\n", collection2);
11226     EXPECT_REF(collection, 3);
11227     IXMLDOMSchemaCollection_Release(collection);
11228
11229     len = -1;
11230     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11231     EXPECT_HR(hr, S_OK);
11232     ok(len == 0, "got %d\n", len);
11233     IXMLDOMSchemaCollection_Release(collection);
11234
11235     /* now with document */
11236     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
11237     EXPECT_HR(hr, S_OK);
11238
11239     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11240     EXPECT_HR(hr, S_OK);
11241
11242     len = -1;
11243     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11244     EXPECT_HR(hr, S_OK);
11245     ok(len == 2, "got %d\n", len);
11246
11247     /* try to lookup some uris */
11248     node = (void*)0xdeadbeef;
11249     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
11250     EXPECT_HR(hr, E_NOTIMPL);
11251     ok(node == (void*)0xdeadbeef, "got %p\n", node);
11252
11253     /* load schema and try to add it */
11254     doc2 = create_document(&IID_IXMLDOMDocument2);
11255     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
11256     EXPECT_HR(hr, S_OK);
11257
11258     V_VT(&v) = VT_DISPATCH;
11259     V_DISPATCH(&v) = (IDispatch*)doc2;
11260     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
11261     EXPECT_HR(hr, E_FAIL);
11262     IXMLDOMDocument2_Release(doc2);
11263
11264     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
11265     EXPECT_HR(hr, S_OK);
11266     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
11267     SysFreeString(s);
11268
11269     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
11270     EXPECT_HR(hr, S_OK);
11271     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
11272     SysFreeString(s);
11273
11274     s = (void*)0xdeadbeef;
11275     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
11276     EXPECT_HR(hr, E_FAIL);
11277     ok(s == (void*)0xdeadbeef, "got %p\n", s);
11278
11279     /* enumerate */
11280     enumv = (void*)0xdeadbeef;
11281     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
11282     EXPECT_HR(hr, S_OK);
11283     ok(enumv != NULL, "got %p\n", enumv);
11284
11285     V_VT(&v) = VT_EMPTY;
11286     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11287     EXPECT_HR(hr, S_OK);
11288     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11289     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11290     VariantClear(&v);
11291
11292     V_VT(&v) = VT_EMPTY;
11293     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11294     EXPECT_HR(hr, S_OK);
11295     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11296     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11297     VariantClear(&v);
11298
11299     V_VT(&v) = VT_NULL;
11300     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11301     EXPECT_HR(hr, S_FALSE);
11302     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
11303
11304     IEnumVARIANT_Release(enumv);
11305     IXMLDOMSchemaCollection_Release(collection);
11306     IXMLDOMDocument2_Release(doc);
11307     free_bstrs();
11308 }
11309
11310 static DOMNodeType put_data_types[] = {
11311     NODE_TEXT,
11312     NODE_CDATA_SECTION,
11313     NODE_PROCESSING_INSTRUCTION,
11314     NODE_COMMENT,
11315     NODE_INVALID
11316 };
11317
11318 static void test_put_data(void)
11319 {
11320     static const WCHAR test_data[] = {'t','e','s','t',' ','n','o','d','e',' ','d','a','t','a',0};
11321     WCHAR buff[100], *data;
11322     IXMLDOMDocument *doc;
11323     DOMNodeType *type;
11324     IXMLDOMText *text;
11325     IXMLDOMNode *node;
11326     VARIANT v;
11327     BSTR get_data;
11328     HRESULT hr;
11329
11330     doc = create_document(&IID_IXMLDOMDocument);
11331
11332     memcpy(&buff[2], test_data, sizeof(test_data));
11333     /* just a big length */
11334     *(DWORD*)buff = 0xf0f0;
11335     data = &buff[2];
11336
11337     type = put_data_types;
11338     while (*type != NODE_INVALID)
11339     {
11340        V_VT(&v) = VT_I2;
11341        V_I2(&v) = *type;
11342
11343        hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
11344        EXPECT_HR(hr, S_OK);
11345
11346        /* put_data() is interface-specific */
11347        switch (*type)
11348        {
11349            case NODE_TEXT:
11350            {
11351               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
11352               EXPECT_HR(hr, S_OK);
11353               hr = IXMLDOMText_put_data(text, data);
11354               EXPECT_HR(hr, S_OK);
11355
11356               hr = IXMLDOMText_get_data(text, &get_data);
11357               EXPECT_HR(hr, S_OK);
11358
11359               IXMLDOMText_Release(text);
11360               break;
11361            }
11362            case NODE_CDATA_SECTION:
11363            {
11364               IXMLDOMCDATASection *cdata;
11365
11366               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
11367               EXPECT_HR(hr, S_OK);
11368               hr = IXMLDOMCDATASection_put_data(cdata, data);
11369               EXPECT_HR(hr, S_OK);
11370
11371               hr = IXMLDOMCDATASection_get_data(cdata, &get_data);
11372               EXPECT_HR(hr, S_OK);
11373
11374               IXMLDOMCDATASection_Release(cdata);
11375               break;
11376            }
11377            case NODE_PROCESSING_INSTRUCTION:
11378            {
11379               IXMLDOMProcessingInstruction *pi;
11380
11381               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)&pi);
11382               EXPECT_HR(hr, S_OK);
11383               hr = IXMLDOMProcessingInstruction_put_data(pi, data);
11384               EXPECT_HR(hr, S_OK);
11385
11386               hr = IXMLDOMProcessingInstruction_get_data(pi, &get_data);
11387               EXPECT_HR(hr, S_OK);
11388
11389               IXMLDOMProcessingInstruction_Release(pi);
11390               break;
11391            }
11392            case NODE_COMMENT:
11393            {
11394               IXMLDOMComment *comment;
11395
11396               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
11397               EXPECT_HR(hr, S_OK);
11398               hr = IXMLDOMComment_put_data(comment, data);
11399               EXPECT_HR(hr, S_OK);
11400
11401               hr = IXMLDOMComment_get_data(comment, &get_data);
11402               EXPECT_HR(hr, S_OK);
11403
11404               IXMLDOMComment_Release(comment);
11405               break;
11406            }
11407            default:
11408               break;
11409        }
11410
11411        /* compare */
11412        ok(!lstrcmpW(data, get_data), "%d: got wrong data %s, expected %s\n", *type, wine_dbgstr_w(get_data),
11413            wine_dbgstr_w(data));
11414        SysFreeString(get_data);
11415
11416        IXMLDOMNode_Release(node);
11417        type++;
11418     }
11419
11420     /* \r\n sequence is never escaped */
11421     V_VT(&v) = VT_I2;
11422     V_I2(&v) = NODE_TEXT;
11423
11424     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
11425     ok(hr == S_OK, "got 0x%08x\n", hr);
11426
11427     IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
11428
11429     hr = IXMLDOMText_put_data(text, _bstr_("\r\n"));
11430     ok(hr == S_OK, "got 0x%08x\n", hr);
11431
11432     hr = IXMLDOMText_get_data(text, &get_data);
11433     ok(hr == S_OK, "got 0x%08x\n", hr);
11434 todo_wine
11435     ok(!lstrcmpW(get_data, _bstr_("\n")), "got %s\n", wine_dbgstr_w(get_data));
11436     SysFreeString(get_data);
11437
11438     hr = IXMLDOMText_get_xml(text, &get_data);
11439     ok(hr == S_OK, "got 0x%08x\n", hr);
11440     ok(!lstrcmpW(get_data, _bstr_("\r\n")), "got %s\n", wine_dbgstr_w(get_data));
11441     SysFreeString(get_data);
11442
11443     IXMLDOMText_Release(text);
11444     IXMLDOMNode_Release(node);
11445
11446     IXMLDOMDocument_Release(doc);
11447     free_bstrs();
11448 }
11449
11450 static void test_putref_schemas(void)
11451 {
11452     IXMLDOMSchemaCollection *cache;
11453     IXMLDOMDocument2 *doc;
11454     VARIANT schema;
11455     HRESULT hr;
11456
11457     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
11458     if (!is_clsid_supported(&CLSID_XMLSchemaCache, &IID_IXMLDOMSchemaCollection)) return;
11459
11460     doc = create_document(&IID_IXMLDOMDocument2);
11461     cache = create_cache(&IID_IXMLDOMSchemaCollection);
11462
11463     /* set to NULL iface when no schema is set */
11464     V_VT(&schema) = VT_DISPATCH;
11465     V_DISPATCH(&schema) = NULL;
11466     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11467     EXPECT_HR(hr, S_OK);
11468
11469     V_VT(&schema) = VT_UNKNOWN;
11470     V_UNKNOWN(&schema) = NULL;
11471     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11472     EXPECT_HR(hr, S_OK);
11473
11474     /* set as VT_DISPATCH, reset with it */
11475     V_VT(&schema) = VT_DISPATCH;
11476     V_DISPATCH(&schema) = (IDispatch*)cache;
11477     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11478     EXPECT_HR(hr, S_OK);
11479
11480     V_DISPATCH(&schema) = NULL;
11481     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
11482     EXPECT_HR(hr, S_OK);
11483     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
11484
11485     V_VT(&schema) = VT_DISPATCH;
11486     V_DISPATCH(&schema) = NULL;
11487     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11488     EXPECT_HR(hr, S_OK);
11489
11490     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
11491     V_VT(&schema) = VT_I2;
11492     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
11493     EXPECT_HR(hr, S_FALSE);
11494     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
11495     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
11496
11497     /* set as VT_UNKNOWN, reset with it */
11498     V_VT(&schema) = VT_UNKNOWN;
11499     V_UNKNOWN(&schema) = (IUnknown*)cache;
11500     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11501     EXPECT_HR(hr, S_OK);
11502
11503     V_DISPATCH(&schema) = NULL;
11504     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
11505     EXPECT_HR(hr, S_OK);
11506     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
11507
11508     V_VT(&schema) = VT_UNKNOWN;
11509     V_UNKNOWN(&schema) = NULL;
11510     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11511     EXPECT_HR(hr, S_OK);
11512
11513     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
11514     V_VT(&schema) = VT_I2;
11515     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
11516     EXPECT_HR(hr, S_FALSE);
11517     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
11518     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
11519
11520     IXMLDOMSchemaCollection_Release(cache);
11521     IXMLDOMDocument2_Release(doc);
11522 }
11523
11524 static void test_namedmap_newenum(void)
11525 {
11526     IEnumVARIANT *enum1, *enum2, *enum3;
11527     IXMLDOMNamedNodeMap *map;
11528     IUnknown *unk1, *unk2;
11529     IXMLDOMDocument *doc;
11530     IXMLDOMElement *elem;
11531     IXMLDOMNode *node;
11532     VARIANT_BOOL b;
11533     HRESULT hr;
11534     VARIANT v;
11535     BSTR str;
11536
11537     doc = create_document(&IID_IXMLDOMDocument);
11538
11539     hr = IXMLDOMDocument_loadXML(doc, _bstr_(attributes_map), &b);
11540     EXPECT_HR(hr, S_OK);
11541
11542     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11543     EXPECT_HR(hr, S_OK);
11544
11545     hr = IXMLDOMElement_get_attributes(elem, &map);
11546     EXPECT_HR(hr, S_OK);
11547     IXMLDOMElement_Release(elem);
11548
11549     enum1 = NULL;
11550     EXPECT_REF(map, 1);
11551     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum1);
11552     EXPECT_HR(hr, S_OK);
11553     ok(enum1 != NULL, "got %p\n", enum1);
11554     EXPECT_REF(map, 1);
11555     EXPECT_REF(enum1, 2);
11556
11557     enum2 = NULL;
11558     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum2);
11559     EXPECT_HR(hr, S_OK);
11560     ok(enum2 == enum1, "got %p\n", enum2);
11561
11562     IEnumVARIANT_Release(enum2);
11563
11564     EXPECT_REF(map, 1);
11565     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum2);
11566     EXPECT_HR(hr, S_OK);
11567     EXPECT_REF(map, 2);
11568     EXPECT_REF(enum2, 1);
11569     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
11570
11571     IEnumVARIANT_Release(enum1);
11572
11573     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
11574     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk1);
11575     EXPECT_HR(hr, S_OK);
11576     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
11577     EXPECT_HR(hr, S_OK);
11578     EXPECT_REF(map, 3);
11579     EXPECT_REF(enum2, 2);
11580     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
11581     IUnknown_Release(unk1);
11582     IUnknown_Release(unk2);
11583
11584     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum3);
11585     EXPECT_HR(hr, S_OK);
11586     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
11587     IEnumVARIANT_Release(enum3);
11588
11589     /* iteration tests */
11590     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node);
11591     EXPECT_HR(hr, S_OK);
11592     hr = IXMLDOMNode_get_nodeName(node, &str);
11593     EXPECT_HR(hr, S_OK);
11594     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
11595     SysFreeString(str);
11596     IXMLDOMNode_Release(node);
11597
11598     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
11599     EXPECT_HR(hr, S_OK);
11600     hr = IXMLDOMNode_get_nodeName(node, &str);
11601     EXPECT_HR(hr, S_OK);
11602     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
11603     SysFreeString(str);
11604     IXMLDOMNode_Release(node);
11605
11606     V_VT(&v) = VT_EMPTY;
11607     hr = IEnumVARIANT_Next(enum2, 1, &v, NULL);
11608     EXPECT_HR(hr, S_OK);
11609     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
11610     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
11611     EXPECT_HR(hr, S_OK);
11612     hr = IXMLDOMNode_get_nodeName(node, &str);
11613     EXPECT_HR(hr, S_OK);
11614     ok(!lstrcmpW(str, _bstr_("attr1")), "got node name %s\n", wine_dbgstr_w(str));
11615     SysFreeString(str);
11616     IXMLDOMNode_Release(node);
11617     VariantClear(&v);
11618
11619     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
11620     EXPECT_HR(hr, S_OK);
11621     hr = IXMLDOMNode_get_nodeName(node, &str);
11622     EXPECT_HR(hr, S_OK);
11623     ok(!lstrcmpW(str, _bstr_("attr2")), "got %s\n", wine_dbgstr_w(str));
11624     SysFreeString(str);
11625     IXMLDOMNode_Release(node);
11626
11627     IEnumVARIANT_Release(enum2);
11628     IXMLDOMNamedNodeMap_Release(map);
11629     IXMLDOMDocument_Release(doc);
11630 }
11631
11632 static const char xsltext_xsl[] =
11633 "<?xml version=\"1.0\"?>"
11634 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
11635 "<xsl:output method=\"html\" encoding=\"us-ascii\"/>"
11636 "<xsl:template match=\"/\">"
11637 "    <xsl:choose>"
11638 "        <xsl:when test=\"testkey\">"
11639 "            <xsl:text>testdata</xsl:text>"
11640 "        </xsl:when>"
11641 "    </xsl:choose>"
11642 "</xsl:template>"
11643 "</xsl:stylesheet>";
11644
11645 static void test_xsltext(void)
11646 {
11647     IXMLDOMDocument *doc, *doc2;
11648     VARIANT_BOOL b;
11649     HRESULT hr;
11650     BSTR ret;
11651
11652     doc = create_document(&IID_IXMLDOMDocument);
11653     doc2 = create_document(&IID_IXMLDOMDocument);
11654
11655     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xsltext_xsl), &b);
11656     EXPECT_HR(hr, S_OK);
11657
11658     hr = IXMLDOMDocument_loadXML(doc2, _bstr_("<testkey/>"), &b);
11659     EXPECT_HR(hr, S_OK);
11660
11661     hr = IXMLDOMDocument_transformNode(doc2, (IXMLDOMNode*)doc, &ret);
11662     EXPECT_HR(hr, S_OK);
11663     ok(!lstrcmpW(ret, _bstr_("testdata")), "transform result %s\n", wine_dbgstr_w(ret));
11664     SysFreeString(ret);
11665
11666     IXMLDOMDocument_Release(doc2);
11667     IXMLDOMDocument_Release(doc);
11668     free_bstrs();
11669 }
11670
11671 struct attrtest_t {
11672     const char *name;
11673     const char *uri;
11674     const char *prefix;
11675     const char *href;
11676 };
11677
11678 static struct attrtest_t attrtests[] = {
11679     { "xmlns", "http://www.w3.org/2000/xmlns/", "xmlns", "xmlns" },
11680     { "xmlns", "nondefaulturi", "xmlns", "xmlns" },
11681     { "c", "http://www.w3.org/2000/xmlns/", NULL, "http://www.w3.org/2000/xmlns/" },
11682     { "c", "nsref1", NULL, "nsref1" },
11683     { "ns:c", "nsref1", "ns", "nsref1" },
11684     { "xmlns:c", "http://www.w3.org/2000/xmlns/", "xmlns", "" },
11685     { "xmlns:c", "nondefaulturi", "xmlns", "" },
11686     { 0 }
11687 };
11688
11689 static void test_create_attribute(void)
11690 {
11691     struct attrtest_t *ptr = attrtests;
11692     IXMLDOMElement *el;
11693     IXMLDOMDocument *doc;
11694     IXMLDOMNode *node, *node2;
11695     VARIANT var;
11696     HRESULT hr;
11697     int i = 0;
11698     BSTR str;
11699
11700     doc = create_document(&IID_IXMLDOMDocument);
11701
11702     while (ptr->name)
11703     {
11704         V_VT(&var) = VT_I1;
11705         V_I1(&var) = NODE_ATTRIBUTE;
11706         hr = IXMLDOMDocument_createNode(doc, var, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
11707         ok(hr == S_OK, "got 0x%08x\n", hr);
11708
11709         str = NULL;
11710         hr = IXMLDOMNode_get_prefix(node, &str);
11711         if (ptr->prefix)
11712         {
11713             ok(hr == S_OK, "%d: got 0x%08x\n", i, hr);
11714             ok(!lstrcmpW(str, _bstr_(ptr->prefix)), "%d: got prefix %s, expected %s\n", i, wine_dbgstr_w(str), ptr->prefix);
11715         }
11716         else
11717         {
11718             ok(hr == S_FALSE, "%d: got 0x%08x\n", i, hr);
11719             ok(str == NULL, "%d: got prefix %s\n", i, wine_dbgstr_w(str));
11720         }
11721
11722         str = NULL;
11723         hr = IXMLDOMNode_get_namespaceURI(node, &str);
11724         ok(hr == S_OK, "%d: got 0x%08x\n", i, hr);
11725         ok(!lstrcmpW(str, _bstr_(ptr->href)), "%d: got uri %s, expected %s\n", i, wine_dbgstr_w(str), ptr->href);
11726         SysFreeString(str);
11727
11728         IXMLDOMNode_Release(node);
11729         free_bstrs();
11730
11731         i++;
11732         ptr++;
11733     }
11734
11735     V_VT(&var) = VT_I1;
11736     V_I1(&var) = NODE_ELEMENT;
11737     hr = IXMLDOMDocument_createNode(doc, var, _bstr_("e"), NULL, &node2);
11738     ok(hr == S_OK, "got 0x%08x\n", hr);
11739
11740     hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&el);
11741     ok(hr == S_OK, "got 0x%08x\n", hr);
11742     IXMLDOMNode_Release(node2);
11743
11744     V_VT(&var) = VT_I1;
11745     V_I1(&var) = NODE_ATTRIBUTE;
11746     hr = IXMLDOMDocument_createNode(doc, var, _bstr_("xmlns:a"), _bstr_("http://www.w3.org/2000/xmlns/"), &node);
11747     ok(hr == S_OK, "got 0x%08x\n", hr);
11748
11749     hr = IXMLDOMElement_setAttributeNode(el, (IXMLDOMAttribute*)node, NULL);
11750     ok(hr == S_OK, "got 0x%08x\n", hr);
11751
11752     /* for some reason default namespace uri is not reported */
11753     hr = IXMLDOMNode_get_namespaceURI(node, &str);
11754     ok(hr == S_OK, "got 0x%08x\n", hr);
11755     ok(!lstrcmpW(str, _bstr_("")), "got uri %s\n", wine_dbgstr_w(str));
11756     SysFreeString(str);
11757
11758     IXMLDOMNode_Release(node);
11759     IXMLDOMElement_Release(el);
11760     IXMLDOMDocument_Release(doc);
11761     free_bstrs();
11762 }
11763
11764 static void test_url(void)
11765 {
11766     IXMLDOMDocument *doc;
11767     HRESULT hr;
11768     BSTR s;
11769
11770     doc = create_document(&IID_IXMLDOMDocument);
11771
11772     hr = IXMLDOMDocument_get_url(doc, NULL);
11773     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
11774
11775     s = (BSTR)0x1;
11776     hr = IXMLDOMDocument_get_url(doc, &s);
11777     ok(hr == S_FALSE, "got 0x%08x\n", hr);
11778     ok(s == NULL, "got %s\n", wine_dbgstr_w(s));
11779
11780     IXMLDOMDocument_Release(doc);
11781 }
11782
11783 START_TEST(domdoc)
11784 {
11785     HRESULT hr;
11786
11787     hr = CoInitialize( NULL );
11788     ok( hr == S_OK, "failed to init com\n");
11789     if (hr != S_OK) return;
11790
11791     get_class_support_data(domdoc_support_data);
11792     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument))
11793     {
11794         win_skip("DOMDocument2 is not supported. Skipping all tests.\n");
11795         CoUninitialize();
11796         return;
11797     }
11798
11799     test_domdoc();
11800     test_persiststreaminit();
11801     test_domnode();
11802     test_refs();
11803     test_create();
11804     test_getElementsByTagName();
11805     test_get_text();
11806     test_get_childNodes();
11807     test_get_firstChild();
11808     test_get_lastChild();
11809     test_removeChild();
11810     test_replaceChild();
11811     test_removeNamedItem();
11812     test_IXMLDOMDocument2();
11813     test_whitespace();
11814     test_XPath();
11815     test_XSLPattern();
11816     test_cloneNode();
11817     test_xmlTypes();
11818     test_save();
11819     test_testTransforms();
11820     test_namespaces_basic();
11821     test_namespaces_change();
11822     test_FormattingXML();
11823     test_nodeTypedValue();
11824     test_TransformWithLoadingLocalFile();
11825     test_put_nodeValue();
11826     test_IObjectSafety();
11827     test_splitText();
11828     test_getQualifiedItem();
11829     test_removeQualifiedItem();
11830     test_get_ownerDocument();
11831     test_setAttributeNode();
11832     test_put_dataType();
11833     test_createNode();
11834     test_create_attribute();
11835     test_get_prefix();
11836     test_default_properties();
11837     test_selectSingleNode();
11838     test_events();
11839     test_createProcessingInstruction();
11840     test_put_nodeTypedValue();
11841     test_get_xml();
11842     test_insertBefore();
11843     test_appendChild();
11844     test_get_doctype();
11845     test_get_tagName();
11846     test_get_dataType();
11847     test_get_nodeTypeString();
11848     test_get_attributes();
11849     test_selection();
11850     test_load();
11851     test_dispex();
11852     test_parseerror();
11853     test_getAttributeNode();
11854     test_supporterrorinfo();
11855     test_nodeValue();
11856     test_get_namespaces();
11857     test_put_data();
11858     test_putref_schemas();
11859     test_namedmap_newenum();
11860     test_xmlns_attribute();
11861     test_url();
11862
11863     test_xsltemplate();
11864     test_xsltext();
11865
11866     if (is_clsid_supported(&CLSID_MXNamespaceManager40, &IID_IMXNamespaceManager))
11867     {
11868         test_mxnamespacemanager();
11869         test_mxnamespacemanager_override();
11870     }
11871
11872     CoUninitialize();
11873 }