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;
 380     IUnknown_AddRef(obj);
 381     rc = IUnknown_Release(obj);
 382     ok_(__FILE__,line)(rc == ref, "expected refcount %d, got %d\n", ref, rc);
 383 }
 384
 385 #define EXPECT_LIST_LEN(list,len) _expect_list_len(list, len, __LINE__)
 386 static void _expect_list_len(IXMLDOMNodeList *list, LONG len, int line)
 387 {
 388     LONG length;
 389     HRESULT hr;
 390
 391     length = 0;
 392     hr = IXMLDOMNodeList_get_length(list, &length);
 393     ok_(__FILE__,line)(hr == S_OK, "got 0x%08x\n", hr);
 394     ok_(__FILE__,line)(length == len, "got %d, expected %d\n", length, len);
 395 }
 396
 397 #define EXPECT_HR(hr,hr_exp) \
 398     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
 399
 400 static const WCHAR szEmpty[] = { 0 };
 401 static const WCHAR szIncomplete[] = {
 402     '<','?','x','m','l',' ',
 403     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
 404 };
 405 static const WCHAR szComplete1[] = {
 406     '<','?','x','m','l',' ',
 407     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 408     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
 409 };
 410 static const WCHAR szComplete2[] = {
 411     '<','?','x','m','l',' ',
 412     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 413     '<','o','>','<','/','o','>','\n',0
 414 };
 415 static const WCHAR szComplete3[] = {
 416     '<','?','x','m','l',' ',
 417     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 418     '<','a','>','<','/','a','>','\n',0
 419 };
 420 static const char complete4A[] =
 421     "<?xml version=\'1.0\'?>\n"
 422     "<lc dl=\'str1\'>\n"
 423         "<bs vr=\'str2\' sz=\'1234\'>"
 424             "fn1.txt\n"
 425         "</bs>\n"
 426         "<pr id=\'str3\' vr=\'1.2.3\' pn=\'wine 20050804\'>\n"
 427             "fn2.txt\n"
 428         "</pr>\n"
 429         "<empty></empty>\n"
 430         "<fo>\n"
 431             "<ba>\n"
 432                 "f1\n"
 433             "</ba>\n"
 434         "</fo>\n"
 435     "</lc>\n";
 436
 437 static const WCHAR szComplete5[] = {
 438     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
 439     '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','"',
 440     ' ','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','"','>',
 441         '<','S',':','s','c','o','p','e','>',
 442             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
 443         '<','/','S',':','s','c','o','p','e','>',
 444         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
 445             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
 446             'c','o','m','p','u','t','e','r',
 447         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
 448     '<','/','S',':','s','e','a','r','c','h','>',0
 449 };
 450
 451 static const WCHAR szComplete6[] = {
 452     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'',' ',
 453     'e','n','c','o','d','i','n','g','=','\'','W','i','n','d','o','w','s','-','1','2','5','2','\'','?','>','\n',
 454     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
 455 };
 456
 457 static const char complete7[] = {
 458     "<?xml version=\"1.0\"?>\n\t"
 459     "<root>\n"
 460     "\t<a/>\n"
 461     "\t<b/>\n"
 462     "\t<c/>\n"
 463     "</root>"
 464 };
 465
 466 #define DECL_WIN_1252 \
 467 "<?xml version=\"1.0\" encoding=\"Windows-1252\"?>"
 468
 469 static const char win1252xml[] =
 470 DECL_WIN_1252
 471 "<open></open>";
 472
 473 static const char win1252decl[] =
 474 DECL_WIN_1252
 475 ;
 476
 477 static const char nocontent[] = "no xml content here";
 478
 479 static const char szExampleXML[] =
 480 "<?xml version='1.0' encoding='utf-8'?>\n"
 481 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' a=\"attr a\" foo:b=\"attr b\" >\n"
 482 "    <elem>\n"
 483 "        <a>A1 field</a>\n"
 484 "        <b>B1 field</b>\n"
 485 "        <c>C1 field</c>\n"
 486 "        <d>D1 field</d>\n"
 487 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 488 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
 489 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
 490 "            </html>\n"
 491 "            <html xml:space='preserve' xmlns='http://www.w3.org/1999/xhtml'>\n"
 492 "                This is <strong>a</strong> <i>description</i> with preserved whitespace. <bar:x/>\n"
 493 "            </html>\n"
 494 "        </description>\n"
 495 "    </elem>\n"
 496 "\n"
 497 "    <elem a='a'>\n"
 498 "        <a>A2 field</a>\n"
 499 "        <b>B2 field</b>\n"
 500 "        <c type=\"old\">C2 field</c>\n"
 501 "        <d>D2 field</d>\n"
 502 "    </elem>\n"
 503 "\n"
 504 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 505 "        <a>A3 field</a>\n"
 506 "        <b>B3 field</b>\n"
 507 "        <c>C3 field</c>\n"
 508 "    </elem>\n"
 509 "\n"
 510 "    <elem>\n"
 511 "        <a>A4 field</a>\n"
 512 "        <b>B4 field</b>\n"
 513 "        <foo:c>C4 field</foo:c>\n"
 514 "        <d>D4 field</d>\n"
 515 "    </elem>\n"
 516 "</root>\n";
 517
 518 static const char charrefsxml[] =
 519 "<?xml version='1.0'?>"
 520 "<a>"
 521 "<b1> Text &#65; end </b1>"
 522 "<b2>&#65;&#66; &#67; </b2>"
 523 "</a>";
 524
 525 static const CHAR szNodeTypesXML[] =
 526 "<?xml version='1.0'?>"
 527 "<!-- comment node 0 -->"
 528 "<root id='0' depth='0'>"
 529 "   <!-- comment node 1 -->"
 530 "   text node 0"
 531 "   <x id='1' depth='1'>"
 532 "       <?foo value='PI for x'?>"
 533 "       <!-- comment node 2 -->"
 534 "       text node 1"
 535 "       <a id='3' depth='2'/>"
 536 "       <b id='4' depth='2'/>"
 537 "       <c id='5' depth='2'/>"
 538 "   </x>"
 539 "   <y id='2' depth='1'>"
 540 "       <?bar value='PI for y'?>"
 541 "       <!-- comment node 3 -->"
 542 "       text node 2"
 543 "       <a id='6' depth='2'/>"
 544 "       <b id='7' depth='2'/>"
 545 "       <c id='8' depth='2'/>"
 546 "   </y>"
 547 "</root>";
 548
 549 static const CHAR szTransformXML[] =
 550 "<?xml version=\"1.0\"?>\n"
 551 "<greeting>\n"
 552 "Hello World\n"
 553 "</greeting>";
 554
 555 static  const CHAR szTransformSSXML[] =
 556 "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
 557 "   <xsl:output method=\"html\"/>\n"
 558 "   <xsl:template match=\"/\">\n"
 559 "       <xsl:apply-templates select=\"greeting\"/>\n"
 560 "   </xsl:template>\n"
 561 "   <xsl:template match=\"greeting\">\n"
 562 "       <html>\n"
 563 "           <body>\n"
 564 "               <h1>\n"
 565 "                   <xsl:value-of select=\".\"/>\n"
 566 "               </h1>\n"
 567 "           </body>\n"
 568 "       </html>\n"
 569 "   </xsl:template>\n"
 570 "</xsl:stylesheet>";
 571
 572 static  const CHAR szTransformOutput[] =
 573 "<html><body><h1>"
 574 "Hello World"
 575 "</h1></body></html>";
 576
 577 static const CHAR szTypeValueXML[] =
 578 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
 579 "<root xmlns:dt=\"urn:schemas-microsoft-com:datatypes\">\n"
 580 "   <string>Wine</string>\n"
 581 "   <string2 dt:dt=\"string\">String</string2>\n"
 582 "   <number dt:dt=\"number\">12.44</number>\n"
 583 "   <number2 dt:dt=\"NUMbEr\">-3.71e3</number2>\n"
 584 "   <int dt:dt=\"int\">-13</int>\n"
 585 "   <fixed dt:dt=\"fixed.14.4\">7322.9371</fixed>\n"
 586 "   <bool dt:dt=\"boolean\">1</bool>\n"
 587 "   <datetime dt:dt=\"datetime\">2009-11-18T03:21:33.12</datetime>\n"
 588 "   <datetimetz dt:dt=\"datetime.tz\">2003-07-11T11:13:57+03:00</datetimetz>\n"
 589 "   <date dt:dt=\"date\">3721-11-01</date>\n"
 590 "   <time dt:dt=\"time\">13:57:12.31321</time>\n"
 591 "   <timetz dt:dt=\"time.tz\">23:21:01.13+03:21</timetz>\n"
 592 "   <i1 dt:dt=\"i1\">-13</i1>\n"
 593 "   <i2 dt:dt=\"i2\">31915</i2>\n"
 594 "   <i4 dt:dt=\"i4\">-312232</i4>\n"
 595 "   <ui1 dt:dt=\"ui1\">123</ui1>\n"
 596 "   <ui2 dt:dt=\"ui2\">48282</ui2>\n"
 597 "   <ui4 dt:dt=\"ui4\">949281</ui4>\n"
 598 "   <r4 dt:dt=\"r4\">213124.0</r4>\n"
 599 "   <r8 dt:dt=\"r8\">0.412</r8>\n"
 600 "   <float dt:dt=\"float\">41221.421</float>\n"
 601 "   <uuid dt:dt=\"uuid\">333C7BC4-460F-11D0-BC04-0080C7055a83</uuid>\n"
 602 "   <binhex dt:dt=\"bin.hex\">fffca012003c</binhex>\n"
 603 "   <binbase64 dt:dt=\"bin.base64\">YmFzZTY0IHRlc3Q=</binbase64>\n"
 604 "   <binbase64_1 dt:dt=\"bin.base64\">\nYmFzZTY0\nIHRlc3Q=\n</binbase64_1>\n"
 605 "   <binbase64_2 dt:dt=\"bin.base64\">\nYmF\r\t z  ZTY0\nIHRlc3Q=\n</binbase64_2>\n"
 606 "</root>";
 607
 608 static const CHAR szBasicTransformSSXMLPart1[] =
 609 "<?xml version=\"1.0\"?>"
 610 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
 611 "<xsl:output method=\"html\"/>\n"
 612 "<xsl:template match=\"/\">"
 613 "<HTML><BODY><TABLE>"
 614 "        <xsl:apply-templates select='document(\"";
 615
 616 static const CHAR szBasicTransformSSXMLPart2[] =
 617 "\")/bottle/wine'>"
 618 "           <xsl:sort select=\"cost\"/><xsl:sort select=\"name\"/>"
 619 "        </xsl:apply-templates>"
 620 "</TABLE></BODY></HTML>"
 621 "</xsl:template>"
 622 "<xsl:template match=\"bottle\">"
 623 "   <TR><xsl:apply-templates select=\"name\" /><xsl:apply-templates select=\"cost\" /></TR>"
 624 "</xsl:template>"
 625 "<xsl:template match=\"name\">"
 626 "   <TD><xsl:apply-templates /></TD>"
 627 "</xsl:template>"
 628 "<xsl:template match=\"cost\">"
 629 "   <TD><xsl:apply-templates /></TD>"
 630 "</xsl:template>"
 631 "</xsl:stylesheet>";
 632
 633 static const CHAR szBasicTransformXML[] =
 634 "<?xml version=\"1.0\"?><bottle><wine><name>Wine</name><cost>$25.00</cost></wine></bottle>";
 635
 636 static const CHAR szBasicTransformOutput[] =
 637 "<HTML><BODY><TABLE><TD>Wine</TD><TD>$25.00</TD></TABLE></BODY></HTML>";
 638
 639 #define SZ_EMAIL_DTD \
 640 "<!DOCTYPE email ["\
 641 "   <!ELEMENT email         (recipients,from,reply-to?,subject,body,attachment*)>"\
 642 "       <!ATTLIST email attachments IDREFS #REQUIRED>"\
 643 "       <!ATTLIST email sent (yes|no) \"no\">"\
 644 "   <!ELEMENT recipients    (to+,cc*)>"\
 645 "   <!ELEMENT to            (#PCDATA)>"\
 646 "       <!ATTLIST to name CDATA #IMPLIED>"\
 647 "   <!ELEMENT cc            (#PCDATA)>"\
 648 "       <!ATTLIST cc name CDATA #IMPLIED>"\
 649 "   <!ELEMENT from          (#PCDATA)>"\
 650 "       <!ATTLIST from name CDATA #IMPLIED>"\
 651 "   <!ELEMENT reply-to      (#PCDATA)>"\
 652 "       <!ATTLIST reply-to name CDATA #IMPLIED>"\
 653 "   <!ELEMENT subject       ANY>"\
 654 "   <!ELEMENT body          ANY>"\
 655 "       <!ATTLIST body enc CDATA #FIXED \"UTF-8\">"\
 656 "   <!ELEMENT attachment    (#PCDATA)>"\
 657 "       <!ATTLIST attachment id ID #REQUIRED>"\
 658 "]>"
 659
 660 static const CHAR szEmailXML[] =
 661 "<?xml version=\"1.0\"?>"
 662 SZ_EMAIL_DTD
 663 "<email attachments=\"patch1\">"
 664 "   <recipients>"
 665 "       <to>wine-patches@winehq.org</to>"
 666 "   </recipients>"
 667 "   <from name=\"Anonymous\">user@localhost</from>"
 668 "   <subject>msxml3/tests: DTD validation (try 87)</subject>"
 669 "   <body>"
 670 "       It no longer causes spontaneous combustion..."
 671 "   </body>"
 672 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 673 "</email>";
 674
 675 static const CHAR szEmailXML_0D[] =
 676 "<?xml version=\"1.0\"?>"
 677 SZ_EMAIL_DTD
 678 "<email attachments=\"patch1\">"
 679 "   <recipients>"
 680 "       <to>wine-patches@winehq.org</to>"
 681 "   </recipients>"
 682 "   <from name=\"Anonymous\">user@localhost</from>"
 683 "   <subject>msxml3/tests: DTD validation (try 88)</subject>"
 684 "   <body>"
 685 "       <undecl />"
 686 "       XML_ELEMENT_UNDECLARED 0xC00CE00D"
 687 "   </body>"
 688 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 689 "</email>";
 690
 691 static const CHAR szEmailXML_0E[] =
 692 "<?xml version=\"1.0\"?>"
 693 SZ_EMAIL_DTD
 694 "<email attachments=\"patch1\">"
 695 "   <recipients>"
 696 "       <to>wine-patches@winehq.org</to>"
 697 "   </recipients>"
 698 "   <from name=\"Anonymous\">user@localhost</from>"
 699 "   <subject>msxml3/tests: DTD validation (try 89)</subject>"
 700 "   <body>"
 701 "       XML_ELEMENT_ID_NOT_FOUND 0xC00CE00E"
 702 "   </body>"
 703 "   <attachment id=\"patch\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 704 "</email>";
 705
 706 static const CHAR szEmailXML_11[] =
 707 "<?xml version=\"1.0\"?>"
 708 SZ_EMAIL_DTD
 709 "<email attachments=\"patch1\">"
 710 "   <recipients>"
 711 "   </recipients>"
 712 "   <from name=\"Anonymous\">user@localhost</from>"
 713 "   <subject>msxml3/tests: DTD validation (try 90)</subject>"
 714 "   <body>"
 715 "       XML_EMPTY_NOT_ALLOWED 0xC00CE011"
 716 "   </body>"
 717 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 718 "</email>";
 719
 720 static const CHAR szEmailXML_13[] =
 721 "<?xml version=\"1.0\"?>"
 722 SZ_EMAIL_DTD
 723 "<msg attachments=\"patch1\">"
 724 "   <recipients>"
 725 "       <to>wine-patches@winehq.org</to>"
 726 "   </recipients>"
 727 "   <from name=\"Anonymous\">user@localhost</from>"
 728 "   <subject>msxml3/tests: DTD validation (try 91)</subject>"
 729 "   <body>"
 730 "       XML_ROOT_NAME_MISMATCH 0xC00CE013"
 731 "   </body>"
 732 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 733 "</msg>";
 734
 735 static const CHAR szEmailXML_14[] =
 736 "<?xml version=\"1.0\"?>"
 737 SZ_EMAIL_DTD
 738 "<email attachments=\"patch1\">"
 739 "   <to>wine-patches@winehq.org</to>"
 740 "   <from name=\"Anonymous\">user@localhost</from>"
 741 "   <subject>msxml3/tests: DTD validation (try 92)</subject>"
 742 "   <body>"
 743 "       XML_INVALID_CONTENT 0xC00CE014"
 744 "   </body>"
 745 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 746 "</email>";
 747
 748 static const CHAR szEmailXML_15[] =
 749 "<?xml version=\"1.0\"?>"
 750 SZ_EMAIL_DTD
 751 "<email attachments=\"patch1\" ip=\"127.0.0.1\">"
 752 "   <recipients>"
 753 "       <to>wine-patches@winehq.org</to>"
 754 "   </recipients>"
 755 "   <from name=\"Anonymous\">user@localhost</from>"
 756 "   <subject>msxml3/tests: DTD validation (try 93)</subject>"
 757 "   <body>"
 758 "       XML_ATTRIBUTE_NOT_DEFINED 0xC00CE015"
 759 "   </body>"
 760 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 761 "</email>";
 762
 763 static const CHAR szEmailXML_16[] =
 764 "<?xml version=\"1.0\"?>"
 765 SZ_EMAIL_DTD
 766 "<email attachments=\"patch1\">"
 767 "   <recipients>"
 768 "       <to>wine-patches@winehq.org</to>"
 769 "   </recipients>"
 770 "   <from name=\"Anonymous\">user@localhost</from>"
 771 "   <subject>msxml3/tests: DTD validation (try 94)</subject>"
 772 "   <body enc=\"ASCII\">"
 773 "       XML_ATTRIBUTE_FIXED 0xC00CE016"
 774 "   </body>"
 775 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 776 "</email>";
 777
 778 static const CHAR szEmailXML_17[] =
 779 "<?xml version=\"1.0\"?>"
 780 SZ_EMAIL_DTD
 781 "<email attachments=\"patch1\" sent=\"true\">"
 782 "   <recipients>"
 783 "       <to>wine-patches@winehq.org</to>"
 784 "   </recipients>"
 785 "   <from name=\"Anonymous\">user@localhost</from>"
 786 "   <subject>msxml3/tests: DTD validation (try 95)</subject>"
 787 "   <body>"
 788 "       XML_ATTRIBUTE_VALUE 0xC00CE017"
 789 "   </body>"
 790 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 791 "</email>";
 792
 793 static const CHAR szEmailXML_18[] =
 794 "<?xml version=\"1.0\"?>"
 795 SZ_EMAIL_DTD
 796 "<email attachments=\"patch1\">"
 797 "   oops"
 798 "   <recipients>"
 799 "       <to>wine-patches@winehq.org</to>"
 800 "   </recipients>"
 801 "   <from name=\"Anonymous\">user@localhost</from>"
 802 "   <subject>msxml3/tests: DTD validation (try 96)</subject>"
 803 "   <body>"
 804 "       XML_ILLEGAL_TEXT 0xC00CE018"
 805 "   </body>"
 806 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 807 "</email>";
 808
 809 static const CHAR szEmailXML_20[] =
 810 "<?xml version=\"1.0\"?>"
 811 SZ_EMAIL_DTD
 812 "<email>"
 813 "   <recipients>"
 814 "       <to>wine-patches@winehq.org</to>"
 815 "   </recipients>"
 816 "   <from name=\"Anonymous\">user@localhost</from>"
 817 "   <subject>msxml3/tests: DTD validation (try 97)</subject>"
 818 "   <body>"
 819 "       XML_REQUIRED_ATTRIBUTE_MISSING 0xC00CE020"
 820 "   </body>"
 821 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 822 "</email>";
 823
 824 static const char xpath_simple_list[] =
 825 "<?xml version=\"1.0\"?>"
 826 "<root>"
 827 "   <a attr1=\"1\" attr2=\"2\" />"
 828 "   <b/>"
 829 "   <c/>"
 830 "   <d/>"
 831 "</root>";
 832
 833 static const char default_ns_doc[] = {
 834     "<?xml version=\"1.0\"?>"
 835     "<a xmlns:ns=\"nshref\" xml:lang=\"ru\" ns:b=\"b attr\" xml:c=\"c attr\" "
 836     "    d=\"d attr\" />"
 837 };
 838
 839 static const char attributes_map[] = {
 840     "<?xml version=\"1.0\"?>"
 841     "<a attr1=\"value1\" attr2=\"value2\" attr3=\"value3\" attr4=\"value4\" />"
 842 };
 843
 844 static const WCHAR nonexistent_fileW[] = {
 845     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
 846 };
 847 static const WCHAR nonexistent_attrW[] = {
 848     'n','o','n','E','x','i','s','i','t','i','n','g','A','t','t','r','i','b','u','t','e',0
 849 };
 850 static const WCHAR szDocument[] = {
 851     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
 852 };
 853
 854 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
 855 static const WCHAR szdl[] = { 'd','l',0 };
 856 static const WCHAR szvr[] = { 'v','r',0 };
 857 static const WCHAR szlc[] = { 'l','c',0 };
 858 static const WCHAR szbs[] = { 'b','s',0 };
 859 static const WCHAR szstr1[] = { 's','t','r','1',0 };
 860 static const WCHAR szstr2[] = { 's','t','r','2',0 };
 861 static const WCHAR szstar[] = { '*',0 };
 862 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
 863
 864 static const WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
 865 static const WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
 866 static const WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
 867
 868 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
 869 static const WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
 870 static const WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
 871 static const WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 872                                       'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
 873 static const WCHAR szElementXML4[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 874                                       '&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 };
 875
 876 static const WCHAR szAttribute[] = {'A','t','t','r',0 };
 877 static const WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
 878
 879 static const WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
 880                                 ' ','n','o','t',' ','r','i','g','h','t','!', 0};
 881 static const WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
 882                                    'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
 883                                    '!',']',']','>',0};
 884 static const WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
 885 static const WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
 886
 887 static const WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
 888 static const WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
 889 static const WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0};
 890
 891 #define expect_bstr_eq_and_free(bstr, expect) { \
 892     BSTR bstrExp = alloc_str_from_narrow(expect); \
 893     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
 894     SysFreeString(bstr); \
 895     SysFreeString(bstrExp); \
 896 }
 897
 898 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
 899
 900 #define ole_check(expr) { \
 901     HRESULT r = expr; \
 902     ok(r == S_OK, #expr " returned %x\n", r); \
 903 }
 904
 905 #define ole_expect(expr, expect) { \
 906     HRESULT r = expr; \
 907     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
 908 }
 909
 910 #define double_eq(x, y) ok((x)-(y)<=1e-14*(x) && (x)-(y)>=-1e-14*(x), "expected %.16g, got %.16g\n", x, y)
 911
 912 static void* _create_object(const GUID *clsid, const char *name, const IID *iid, int line)
 913 {
 914     void *obj = NULL;
 915     HRESULT hr;
 916
 917     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
 918     ok(hr == S_OK, "failed to create %s instance: 0x%08x\n", name, hr);
 919
 920     return obj;
 921 }
 922
 923 #define _create(cls) cls, #cls
 924
 925 #define create_document(iid) _create_object(&_create(CLSID_DOMDocument2), iid, __LINE__)
 926 #define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
 927 #define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
 928 #define create_xsltemplate(iid) _create_object(&_create(CLSID_XSLTemplate), iid, __LINE__)
 929
 930 static BSTR alloc_str_from_narrow(const char *str)
 931 {
 932     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 933     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
 934     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 935     return ret;
 936 }
 937
 938 static BSTR alloced_bstrs[256];
 939 static int alloced_bstrs_count;
 940
 941 static BSTR _bstr_(const char *str)
 942 {
 943     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
 944     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
 945     return alloced_bstrs[alloced_bstrs_count++];
 946 }
 947
 948 static void free_bstrs(void)
 949 {
 950     int i;
 951     for (i = 0; i < alloced_bstrs_count; i++)
 952         SysFreeString(alloced_bstrs[i]);
 953     alloced_bstrs_count = 0;
 954 }
 955
 956 static VARIANT _variantbstr_(const char *str)
 957 {
 958     VARIANT v;
 959     V_VT(&v) = VT_BSTR;
 960     V_BSTR(&v) = _bstr_(str);
 961     return v;
 962 }
 963
 964 static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
 965 {
 966     for (;;)
 967     {
 968         while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
 969         while (*sRight == '\r' || *sRight == '\n') sRight++;
 970         if (*sLeft != *sRight) return FALSE;
 971         if (!*sLeft) return TRUE;
 972         sLeft++;
 973         sRight++;
 974     }
 975 }
 976
 977 static void get_str_for_type(DOMNodeType type, char *buf)
 978 {
 979     switch (type)
 980     {
 981         case NODE_ATTRIBUTE:
 982             strcpy(buf, "A");
 983             break;
 984         case NODE_ELEMENT:
 985             strcpy(buf, "E");
 986             break;
 987         case NODE_DOCUMENT:
 988             strcpy(buf, "D");
 989             break;
 990         case NODE_TEXT:
 991             strcpy(buf, "T");
 992             break;
 993         case NODE_COMMENT:
 994             strcpy(buf, "C");
 995             break;
 996         case NODE_PROCESSING_INSTRUCTION:
 997             strcpy(buf, "P");
 998             break;
 999         default:
1000             wsprintfA(buf, "[%d]", type);
1001     }
1002 }
1003
1004 static int get_node_position(IXMLDOMNode *node)
1005 {
1006     HRESULT r;
1007     int pos = 0;
1008
1009     IXMLDOMNode_AddRef(node);
1010     do
1011     {
1012         IXMLDOMNode *new_node;
1013
1014         pos++;
1015         r = IXMLDOMNode_get_previousSibling(node, &new_node);
1016         ok(SUCCEEDED(r), "get_previousSibling failed\n");
1017         IXMLDOMNode_Release(node);
1018         node = new_node;
1019     } while (r == S_OK);
1020     return pos;
1021 }
1022
1023 static void node_to_string(IXMLDOMNode *node, char *buf)
1024 {
1025     HRESULT r = S_OK;
1026     DOMNodeType type;
1027
1028     if (node == NULL)
1029     {
1030         lstrcpyA(buf, "(null)");
1031         return;
1032     }
1033
1034     IXMLDOMNode_AddRef(node);
1035     while (r == S_OK)
1036     {
1037         IXMLDOMNode *new_node;
1038
1039         ole_check(IXMLDOMNode_get_nodeType(node, &type));
1040         get_str_for_type(type, buf);
1041         buf+=strlen(buf);
1042
1043         if (type == NODE_ATTRIBUTE)
1044         {
1045             BSTR bstr;
1046             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
1047             *(buf++) = '\'';
1048             wsprintfA(buf, "%ws", bstr);
1049             buf += strlen(buf);
1050             *(buf++) = '\'';
1051             SysFreeString(bstr);
1052
1053             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
1054         }
1055         else
1056         {
1057             r = IXMLDOMNode_get_parentNode(node, &new_node);
1058             sprintf(buf, "%d", get_node_position(node));
1059             buf += strlen(buf);
1060         }
1061
1062         ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
1063         IXMLDOMNode_Release(node);
1064         node = new_node;
1065         if (r == S_OK)
1066             *(buf++) = '.';
1067     }
1068
1069     *buf = 0;
1070 }
1071
1072 static char *list_to_string(IXMLDOMNodeList *list)
1073 {
1074     static char buf[4096];
1075     char *pos = buf;
1076     LONG len = 0;
1077     HRESULT hr;
1078     int i;
1079
1080     if (list == NULL)
1081     {
1082         strcpy(buf, "(null)");
1083         return buf;
1084     }
1085     hr = IXMLDOMNodeList_get_length(list, &len);
1086     ok(hr == S_OK, "got 0x%08x\n", hr);
1087     for (i = 0; i < len; i++)
1088     {
1089         IXMLDOMNode *node;
1090         if (i > 0)
1091             *(pos++) = ' ';
1092         ole_check(IXMLDOMNodeList_nextNode(list, &node));
1093         node_to_string(node, pos);
1094         pos += strlen(pos);
1095         IXMLDOMNode_Release(node);
1096     }
1097     *pos = 0;
1098     return buf;
1099 }
1100
1101 #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); }
1102 #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); }
1103
1104 struct docload_ret_t {
1105     VARIANT_BOOL b;
1106     HRESULT hr;
1107 };
1108
1109 struct leading_spaces_t {
1110     const CLSID *clsid;
1111     const char *name;
1112     struct docload_ret_t ret[2]; /* 0 - ::load(), 1 - ::loadXML() */
1113 };
1114
1115 static const struct leading_spaces_t leading_spaces_classdata[] = {
1116     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
1117     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1118     { &CLSID_DOMDocument26, "CLSID_DOMDocument26", {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
1119     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1120     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1121     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1122     { NULL }
1123 };
1124
1125 static const char* leading_spaces_xmldata[] = {
1126     "\n<?xml version=\"1.0\" encoding=\"UTF-16\" ?><root/>",
1127     " <?xml version=\"1.0\"?><root/>",
1128     "\n<?xml version=\"1.0\"?><root/>",
1129     "\t<?xml version=\"1.0\"?><root/>",
1130     "\r\n<?xml version=\"1.0\"?><root/>",
1131     "\r<?xml version=\"1.0\"?><root/>",
1132     "\r\r\r\r\t\t \n\n <?xml version=\"1.0\"?><root/>",
1133     0
1134 };
1135
1136 static void test_domdoc( void )
1137 {
1138     HRESULT r, hr;
1139     IXMLDOMDocument *doc;
1140     IXMLDOMParseError *error;
1141     IXMLDOMElement *element = NULL;
1142     IXMLDOMNode *node;
1143     IXMLDOMText *nodetext = NULL;
1144     IXMLDOMComment *node_comment = NULL;
1145     IXMLDOMAttribute *node_attr = NULL;
1146     IXMLDOMNode *nodeChild = NULL;
1147     IXMLDOMProcessingInstruction *nodePI = NULL;
1148     const struct leading_spaces_t *class_ptr;
1149     const char **data_ptr;
1150     VARIANT_BOOL b;
1151     VARIANT var;
1152     BSTR str;
1153     LONG code, ref;
1154     LONG nLength = 0;
1155     WCHAR buff[100];
1156     char path[MAX_PATH];
1157     int index;
1158
1159     GetTempPathA(MAX_PATH, path);
1160     strcat(path, "leading_spaces.xml");
1161
1162     /* Load document with leading spaces
1163      *
1164      * Test all CLSIDs with all test data XML strings
1165      */
1166     class_ptr = leading_spaces_classdata;
1167     index = 0;
1168     while (class_ptr->clsid)
1169     {
1170         HRESULT hr;
1171         int i;
1172
1173         if (is_clsid_supported(class_ptr->clsid, &IID_IXMLDOMDocument))
1174         {
1175             hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
1176         }
1177         else
1178         {
1179             class_ptr++;
1180             index++;
1181             continue;
1182         }
1183
1184         data_ptr = leading_spaces_xmldata;
1185         i = 0;
1186         while (*data_ptr) {
1187             BSTR data = _bstr_(*data_ptr);
1188             DWORD written;
1189             HANDLE file;
1190
1191             file = CreateFileA(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
1192             ok(file != INVALID_HANDLE_VALUE, "can't create file %s: %u\n", path, GetLastError());
1193
1194             WriteFile(file, data, lstrlenW(data)*sizeof(WCHAR), &written, NULL);
1195             CloseHandle(file);
1196
1197             b = 0xc;
1198             V_VT(&var) = VT_BSTR;
1199             V_BSTR(&var) = _bstr_(path);
1200             hr = IXMLDOMDocument_load(doc, var, &b);
1201             EXPECT_HR(hr, class_ptr->ret[0].hr);
1202             ok(b == class_ptr->ret[0].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[0].b);
1203
1204             DeleteFileA(path);
1205
1206             b = 0xc;
1207             hr = IXMLDOMDocument_loadXML(doc, data, &b);
1208             EXPECT_HR(hr, class_ptr->ret[1].hr);
1209             ok(b == class_ptr->ret[1].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[1].b);
1210
1211             data_ptr++;
1212             i++;
1213         }
1214
1215         class_ptr++;
1216         index++;
1217         free_bstrs();
1218     }
1219
1220     doc = create_document(&IID_IXMLDOMDocument);
1221     if (!doc) return;
1222
1223 if (0)
1224 {
1225     /* crashes on native */
1226     IXMLDOMDocument_loadXML( doc, (BSTR)0x1, NULL );
1227 }
1228
1229     /* try some stupid things */
1230     hr = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1231     EXPECT_HR(hr, S_FALSE);
1232
1233     b = VARIANT_TRUE;
1234     hr = IXMLDOMDocument_loadXML( doc, NULL, &b );
1235     EXPECT_HR(hr, S_FALSE);
1236     ok( b == VARIANT_FALSE, "failed to load XML string\n");
1237
1238     /* try to load a document from a nonexistent file */
1239     b = VARIANT_TRUE;
1240     str = SysAllocString( nonexistent_fileW );
1241     VariantInit(&var);
1242     V_VT(&var) = VT_BSTR;
1243     V_BSTR(&var) = str;
1244
1245     r = IXMLDOMDocument_load( doc, var, &b);
1246     ok( r == S_FALSE, "loadXML succeeded\n");
1247     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1248     SysFreeString( str );
1249
1250     str = (BSTR)0x1;
1251     hr = IXMLDOMDocument_get_url(doc, &str);
1252     ok(hr == S_FALSE, "got 0x%08x\n", hr);
1253     ok(str == NULL, "got %p\n", str);
1254
1255     /* try load an empty document */
1256     b = VARIANT_TRUE;
1257     str = SysAllocString( szEmpty );
1258     r = IXMLDOMDocument_loadXML( doc, str, &b );
1259     ok( r == S_FALSE, "loadXML succeeded\n");
1260     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1261     SysFreeString( str );
1262
1263     r = IXMLDOMDocument_get_async( doc, &b );
1264     ok( r == S_OK, "get_async failed (%08x)\n", r);
1265     ok( b == VARIANT_TRUE, "Wrong default value\n");
1266
1267     /* check that there's no document element */
1268     element = NULL;
1269     r = IXMLDOMDocument_get_documentElement( doc, &element );
1270     ok( r == S_FALSE, "should be no document element\n");
1271
1272     /* try finding a node */
1273     node = NULL;
1274     str = SysAllocString( szstr1 );
1275     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
1276     ok( r == S_FALSE, "ret %08x\n", r );
1277     SysFreeString( str );
1278
1279     b = VARIANT_TRUE;
1280     str = SysAllocString( szIncomplete );
1281     r = IXMLDOMDocument_loadXML( doc, str, &b );
1282     ok( r == S_FALSE, "loadXML succeeded\n");
1283     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1284     SysFreeString( str );
1285
1286     /* check that there's no document element */
1287     element = (IXMLDOMElement*)1;
1288     r = IXMLDOMDocument_get_documentElement( doc, &element );
1289     ok( r == S_FALSE, "should be no document element\n");
1290     ok( element == NULL, "Element should be NULL\n");
1291
1292     /* test for BSTR handling, pass broken BSTR */
1293     memcpy(&buff[2], szComplete1, sizeof(szComplete1));
1294     /* just a big length */
1295     *(DWORD*)buff = 0xf0f0;
1296     b = VARIANT_FALSE;
1297     r = IXMLDOMDocument_loadXML( doc, &buff[2], &b );
1298     ok( r == S_OK, "loadXML failed\n");
1299     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1300
1301     /* loadXML ignores the encoding attribute and always expects Unicode */
1302     b = VARIANT_FALSE;
1303     str = SysAllocString( szComplete6 );
1304     r = IXMLDOMDocument_loadXML( doc, str, &b );
1305     ok( r == S_OK, "loadXML failed\n");
1306     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1307     SysFreeString( str );
1308
1309     /* try a BSTR containing a Windows-1252 document */
1310     b = VARIANT_TRUE;
1311     str = SysAllocStringByteLen( win1252xml, strlen(win1252xml) );
1312     r = IXMLDOMDocument_loadXML( doc, str, &b );
1313     ok( r == S_FALSE, "loadXML succeeded\n");
1314     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1315     SysFreeString( str );
1316
1317     /* try to load something valid */
1318     b = VARIANT_FALSE;
1319     str = SysAllocString( szComplete1 );
1320     r = IXMLDOMDocument_loadXML( doc, str, &b );
1321     ok( r == S_OK, "loadXML failed\n");
1322     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1323     SysFreeString( str );
1324
1325     /* check if nodename is correct */
1326     r = IXMLDOMDocument_get_nodeName( doc, NULL );
1327     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1328
1329     str = (BSTR)0xdeadbeef;
1330     r = IXMLDOMDocument_get_baseName( doc, &str );
1331     ok ( r == S_FALSE, "got 0x%08x\n", r);
1332     ok (str == NULL, "got %p\n", str);
1333
1334     /* content doesn't matter here */
1335     str = NULL;
1336     r = IXMLDOMDocument_get_nodeName( doc, &str );
1337     ok ( r == S_OK, "get_nodeName wrong code\n");
1338     ok ( str != NULL, "str is null\n");
1339     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
1340     SysFreeString( str );
1341
1342     /* test put_text */
1343     r = IXMLDOMDocument_put_text( doc, _bstr_("Should fail") );
1344     ok( r == E_FAIL, "ret %08x\n", r );
1345
1346     /* check that there's a document element */
1347     element = NULL;
1348     r = IXMLDOMDocument_get_documentElement( doc, &element );
1349     ok( r == S_OK, "should be a document element\n");
1350     if( element )
1351     {
1352         IObjectIdentity *ident;
1353
1354         r = IXMLDOMElement_QueryInterface( element, &IID_IObjectIdentity, (void**)&ident );
1355         ok( r == E_NOINTERFACE, "ret %08x\n", r);
1356
1357         IXMLDOMElement_Release( element );
1358         element = NULL;
1359     }
1360
1361     /* as soon as we call loadXML again, the document element will disappear */
1362     b = 2;
1363     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1364     ok( r == S_FALSE, "loadXML failed\n");
1365     ok( b == 2, "variant modified\n");
1366     r = IXMLDOMDocument_get_documentElement( doc, &element );
1367     ok( r == S_FALSE, "should be no document element\n");
1368
1369     /* try to load something else simple and valid */
1370     b = VARIANT_FALSE;
1371     str = SysAllocString( szComplete3 );
1372     r = IXMLDOMDocument_loadXML( doc, str, &b );
1373     ok( r == S_OK, "loadXML failed\n");
1374     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1375     SysFreeString( str );
1376
1377     /* try something a little more complicated */
1378     b = FALSE;
1379     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
1380     ok( r == S_OK, "loadXML failed\n");
1381     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1382
1383     r = IXMLDOMDocument_get_parseError( doc, &error );
1384     ok( r == S_OK, "returns %08x\n", r );
1385
1386     r = IXMLDOMParseError_get_errorCode( error, &code );
1387     ok( r == S_FALSE, "returns %08x\n", r );
1388     ok( code == 0, "code %d\n", code );
1389     IXMLDOMParseError_Release( error );
1390
1391     /* test createTextNode */
1392     r = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &nodetext);
1393     ok( r == S_OK, "returns %08x\n", r );
1394     IXMLDOMText_Release(nodetext);
1395
1396     str = SysAllocString( szOpen );
1397     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
1398     ok( r == E_INVALIDARG, "returns %08x\n", r );
1399     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
1400     ok( r == S_OK, "returns %08x\n", r );
1401     SysFreeString( str );
1402     if(nodetext)
1403     {
1404         r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (void**)&element);
1405         ok(r == E_NOINTERFACE, "ret %08x\n", r );
1406
1407         /* Text Last Child Checks */
1408         r = IXMLDOMText_get_lastChild(nodetext, NULL);
1409         ok(r == E_INVALIDARG, "ret %08x\n", r );
1410
1411         nodeChild = (IXMLDOMNode*)0x1;
1412         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
1413         ok(r == S_FALSE, "ret %08x\n", r );
1414         ok(nodeChild == NULL, "nodeChild not NULL\n");
1415
1416         /* test length property */
1417         r = IXMLDOMText_get_length(nodetext, NULL);
1418         ok(r == E_INVALIDARG, "ret %08x\n", r );
1419
1420         r = IXMLDOMText_get_length(nodetext, &nLength);
1421         ok(r == S_OK, "ret %08x\n", r );
1422         ok(nLength == 4, "expected 4 got %d\n", nLength);
1423
1424         /* put data Tests */
1425         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
1426         ok(r == S_OK, "ret %08x\n", r );
1427
1428         /* get data Tests */
1429         r = IXMLDOMText_get_data(nodetext, &str);
1430         ok(r == S_OK, "ret %08x\n", r );
1431         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
1432         SysFreeString(str);
1433
1434         /* Confirm XML text is good */
1435         r = IXMLDOMText_get_xml(nodetext, &str);
1436         ok(r == S_OK, "ret %08x\n", r );
1437         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
1438         SysFreeString(str);
1439
1440         /* Confirm we get the put_data Text back */
1441         r = IXMLDOMText_get_text(nodetext, &str);
1442         ok(r == S_OK, "ret %08x\n", r );
1443         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
1444         SysFreeString(str);
1445
1446         /* test substringData */
1447         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
1448         ok(r == E_INVALIDARG, "ret %08x\n", r );
1449
1450         /* test substringData - Invalid offset */
1451         str = (BSTR)&szElement;
1452         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
1453         ok(r == E_INVALIDARG, "ret %08x\n", r );
1454         ok( str == NULL, "incorrect string\n");
1455
1456         /* test substringData - Invalid offset */
1457         str = (BSTR)&szElement;
1458         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
1459         ok(r == S_FALSE, "ret %08x\n", r );
1460         ok( str == NULL, "incorrect string\n");
1461
1462         /* test substringData - Invalid size */
1463         str = (BSTR)&szElement;
1464         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
1465         ok(r == E_INVALIDARG, "ret %08x\n", r );
1466         ok( str == NULL, "incorrect string\n");
1467
1468         /* test substringData - Invalid size */
1469         str = (BSTR)&szElement;
1470         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
1471         ok(r == S_FALSE, "ret %08x\n", r );
1472         ok( str == NULL, "incorrect string\n");
1473
1474         /* test substringData - Start of string */
1475         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
1476         ok(r == S_OK, "ret %08x\n", r );
1477         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
1478         SysFreeString(str);
1479
1480         /* test substringData - Middle of string */
1481         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
1482         ok(r == S_OK, "ret %08x\n", r );
1483         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
1484         SysFreeString(str);
1485
1486         /* test substringData - End of string */
1487         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
1488         ok(r == S_OK, "ret %08x\n", r );
1489         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
1490         SysFreeString(str);
1491
1492         /* test appendData */
1493         r = IXMLDOMText_appendData(nodetext, NULL);
1494         ok(r == S_OK, "ret %08x\n", r );
1495
1496         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
1497         ok(r == S_OK, "ret %08x\n", r );
1498
1499         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
1500         ok(r == S_OK, "ret %08x\n", r );
1501
1502         r = IXMLDOMText_get_text(nodetext, &str);
1503         ok(r == S_OK, "ret %08x\n", r );
1504         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1505         SysFreeString(str);
1506
1507         /* test insertData */
1508         str = SysAllocStringLen(NULL, 0);
1509         r = IXMLDOMText_insertData(nodetext, -1, str);
1510         ok(r == S_OK, "ret %08x\n", r );
1511
1512         r = IXMLDOMText_insertData(nodetext, -1, NULL);
1513         ok(r == S_OK, "ret %08x\n", r );
1514
1515         r = IXMLDOMText_insertData(nodetext, 1000, str);
1516         ok(r == S_OK, "ret %08x\n", r );
1517
1518         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
1519         ok(r == S_OK, "ret %08x\n", r );
1520
1521         r = IXMLDOMText_insertData(nodetext, 0, NULL);
1522         ok(r == S_OK, "ret %08x\n", r );
1523
1524         r = IXMLDOMText_insertData(nodetext, 0, str);
1525         ok(r == S_OK, "ret %08x\n", r );
1526         SysFreeString(str);
1527
1528         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
1529         ok(r == E_INVALIDARG, "ret %08x\n", r );
1530
1531         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
1532         ok(r == E_INVALIDARG, "ret %08x\n", r );
1533
1534         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
1535         ok(r == S_OK, "ret %08x\n", r );
1536
1537         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
1538         ok(r == S_OK, "ret %08x\n", r );
1539
1540         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
1541         ok(r == S_OK, "ret %08x\n", r );
1542
1543         r = IXMLDOMText_get_text(nodetext, &str);
1544         ok(r == S_OK, "ret %08x\n", r );
1545         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1546         SysFreeString(str);
1547
1548         /* delete data */
1549         /* invalid arguments */
1550         r = IXMLDOMText_deleteData(nodetext, -1, 1);
1551         ok(r == E_INVALIDARG, "ret %08x\n", r );
1552
1553         r = IXMLDOMText_deleteData(nodetext, 0, 0);
1554         ok(r == S_OK, "ret %08x\n", r );
1555
1556         r = IXMLDOMText_deleteData(nodetext, 0, -1);
1557         ok(r == E_INVALIDARG, "ret %08x\n", r );
1558
1559         r = IXMLDOMText_get_length(nodetext, &nLength);
1560         ok(r == S_OK, "ret %08x\n", r );
1561         ok(nLength == 43, "expected 43 got %d\n", nLength);
1562
1563         r = IXMLDOMText_deleteData(nodetext, nLength, 1);
1564         ok(r == S_OK, "ret %08x\n", r );
1565
1566         r = IXMLDOMText_deleteData(nodetext, nLength+1, 1);
1567         ok(r == E_INVALIDARG, "ret %08x\n", r );
1568
1569         /* delete from start */
1570         r = IXMLDOMText_deleteData(nodetext, 0, 5);
1571         ok(r == S_OK, "ret %08x\n", r );
1572
1573         r = IXMLDOMText_get_length(nodetext, &nLength);
1574         ok(r == S_OK, "ret %08x\n", r );
1575         ok(nLength == 38, "expected 38 got %d\n", nLength);
1576
1577         r = IXMLDOMText_get_text(nodetext, &str);
1578         ok(r == S_OK, "ret %08x\n", r );
1579         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1580         SysFreeString(str);
1581
1582         /* delete from end */
1583         r = IXMLDOMText_deleteData(nodetext, 35, 3);
1584         ok(r == S_OK, "ret %08x\n", r );
1585
1586         r = IXMLDOMText_get_length(nodetext, &nLength);
1587         ok(r == S_OK, "ret %08x\n", r );
1588         ok(nLength == 35, "expected 35 got %d\n", nLength);
1589
1590         r = IXMLDOMText_get_text(nodetext, &str);
1591         ok(r == S_OK, "ret %08x\n", r );
1592         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1593         SysFreeString(str);
1594
1595         /* delete from inside */
1596         r = IXMLDOMText_deleteData(nodetext, 1, 33);
1597         ok(r == S_OK, "ret %08x\n", r );
1598
1599         r = IXMLDOMText_get_length(nodetext, &nLength);
1600         ok(r == S_OK, "ret %08x\n", r );
1601         ok(nLength == 2, "expected 2 got %d\n", nLength);
1602
1603         r = IXMLDOMText_get_text(nodetext, &str);
1604         ok(r == S_OK, "ret %08x\n", r );
1605         ok( !lstrcmpW( str, _bstr_("") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1606         SysFreeString(str);
1607
1608         /* delete whole data ... */
1609         r = IXMLDOMText_get_length(nodetext, &nLength);
1610         ok(r == S_OK, "ret %08x\n", r );
1611
1612         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1613         ok(r == S_OK, "ret %08x\n", r );
1614         /* ... and try again with empty string */
1615         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1616         ok(r == S_OK, "ret %08x\n", r );
1617
1618         /* test put_data */
1619         V_VT(&var) = VT_BSTR;
1620         V_BSTR(&var) = SysAllocString(szstr1);
1621         r = IXMLDOMText_put_nodeValue(nodetext, var);
1622         ok(r == S_OK, "ret %08x\n", r );
1623         VariantClear(&var);
1624
1625         r = IXMLDOMText_get_text(nodetext, &str);
1626         ok(r == S_OK, "ret %08x\n", r );
1627         ok( !lstrcmpW( str, szstr1 ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1628         SysFreeString(str);
1629
1630         /* test put_data */
1631         V_VT(&var) = VT_I4;
1632         V_I4(&var) = 99;
1633         r = IXMLDOMText_put_nodeValue(nodetext, var);
1634         ok(r == S_OK, "ret %08x\n", r );
1635         VariantClear(&var);
1636
1637         r = IXMLDOMText_get_text(nodetext, &str);
1638         ok(r == S_OK, "ret %08x\n", r );
1639         ok( !lstrcmpW( str, _bstr_("99") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1640         SysFreeString(str);
1641
1642         /* ::replaceData() */
1643         V_VT(&var) = VT_BSTR;
1644         V_BSTR(&var) = SysAllocString(szstr1);
1645         r = IXMLDOMText_put_nodeValue(nodetext, var);
1646         ok(r == S_OK, "ret %08x\n", r );
1647         VariantClear(&var);
1648
1649         r = IXMLDOMText_replaceData(nodetext, 6, 0, NULL);
1650         ok(r == E_INVALIDARG, "ret %08x\n", r );
1651         r = IXMLDOMText_get_text(nodetext, &str);
1652         ok(r == S_OK, "ret %08x\n", r );
1653         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1654         SysFreeString(str);
1655
1656         r = IXMLDOMText_replaceData(nodetext, 0, 0, NULL);
1657         ok(r == S_OK, "ret %08x\n", r );
1658         r = IXMLDOMText_get_text(nodetext, &str);
1659         ok(r == S_OK, "ret %08x\n", r );
1660         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1661         SysFreeString(str);
1662
1663         /* NULL pointer means delete */
1664         r = IXMLDOMText_replaceData(nodetext, 0, 1, NULL);
1665         ok(r == S_OK, "ret %08x\n", r );
1666         r = IXMLDOMText_get_text(nodetext, &str);
1667         ok(r == S_OK, "ret %08x\n", r );
1668         ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1669         SysFreeString(str);
1670
1671         /* empty string means delete */
1672         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_(""));
1673         ok(r == S_OK, "ret %08x\n", r );
1674         r = IXMLDOMText_get_text(nodetext, &str);
1675         ok(r == S_OK, "ret %08x\n", r );
1676         ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1677         SysFreeString(str);
1678
1679         /* zero count means insert */
1680         r = IXMLDOMText_replaceData(nodetext, 0, 0, _bstr_("a"));
1681         ok(r == S_OK, "ret %08x\n", r );
1682         r = IXMLDOMText_get_text(nodetext, &str);
1683         ok(r == S_OK, "ret %08x\n", r );
1684         ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1685         SysFreeString(str);
1686
1687         r = IXMLDOMText_replaceData(nodetext, 0, 2, NULL);
1688         ok(r == S_OK, "ret %08x\n", r );
1689
1690         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("m"));
1691         ok(r == S_OK, "ret %08x\n", r );
1692         r = IXMLDOMText_get_text(nodetext, &str);
1693         ok(r == S_OK, "ret %08x\n", r );
1694         ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1695         SysFreeString(str);
1696
1697         /* nonempty string, count greater than its length */
1698         r = IXMLDOMText_replaceData(nodetext, 0, 2, _bstr_("a1.2"));
1699         ok(r == S_OK, "ret %08x\n", r );
1700         r = IXMLDOMText_get_text(nodetext, &str);
1701         ok(r == S_OK, "ret %08x\n", r );
1702         ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1703         SysFreeString(str);
1704
1705         /* nonempty string, count less than its length */
1706         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_("wine"));
1707         ok(r == S_OK, "ret %08x\n", r );
1708         r = IXMLDOMText_get_text(nodetext, &str);
1709         ok(r == S_OK, "ret %08x\n", r );
1710         ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1711         SysFreeString(str);
1712
1713         IXMLDOMText_Release( nodetext );
1714     }
1715
1716     /* test Create Comment */
1717     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
1718     ok( r == E_INVALIDARG, "returns %08x\n", r );
1719     node_comment = (IXMLDOMComment*)0x1;
1720
1721     /* empty comment */
1722     r = IXMLDOMDocument_createComment(doc, _bstr_(""), &node_comment);
1723     ok( r == S_OK, "returns %08x\n", r );
1724     str = (BSTR)0x1;
1725     r = IXMLDOMComment_get_data(node_comment, &str);
1726     ok( r == S_OK, "returns %08x\n", r );
1727     ok( str && SysStringLen(str) == 0, "expected empty string data\n");
1728     IXMLDOMComment_Release(node_comment);
1729     SysFreeString(str);
1730
1731     r = IXMLDOMDocument_createComment(doc, NULL, &node_comment);
1732     ok( r == S_OK, "returns %08x\n", r );
1733     str = (BSTR)0x1;
1734     r = IXMLDOMComment_get_data(node_comment, &str);
1735     ok( r == S_OK, "returns %08x\n", r );
1736     ok( str && (SysStringLen(str) == 0), "expected empty string data\n");
1737     IXMLDOMComment_Release(node_comment);
1738     SysFreeString(str);
1739
1740     str = SysAllocString(szComment);
1741     r = IXMLDOMDocument_createComment(doc, str, &node_comment);
1742     SysFreeString(str);
1743     ok( r == S_OK, "returns %08x\n", r );
1744     if(node_comment)
1745     {
1746         /* Last Child Checks */
1747         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
1748         ok(r == E_INVALIDARG, "ret %08x\n", r );
1749
1750         nodeChild = (IXMLDOMNode*)0x1;
1751         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
1752         ok(r == S_FALSE, "ret %08x\n", r );
1753         ok(nodeChild == NULL, "pLastChild not NULL\n");
1754
1755         /* baseName */
1756         str = (BSTR)0xdeadbeef;
1757         r = IXMLDOMComment_get_baseName(node_comment, &str);
1758         ok(r == S_FALSE, "ret %08x\n", r );
1759         ok(str == NULL, "Expected NULL\n");
1760
1761         IXMLDOMComment_Release( node_comment );
1762     }
1763
1764     /* test Create Attribute */
1765     str = SysAllocString(szAttribute);
1766     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
1767     ok( r == E_INVALIDARG, "returns %08x\n", r );
1768     r = IXMLDOMDocument_createAttribute(doc, str, &node_attr);
1769     ok( r == S_OK, "returns %08x\n", r );
1770     IXMLDOMAttribute_Release( node_attr);
1771     SysFreeString(str);
1772
1773     /* test Processing Instruction */
1774     str = SysAllocStringLen(NULL, 0);
1775     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
1776     ok( r == E_INVALIDARG, "returns %08x\n", r );
1777     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
1778     ok( r == E_FAIL, "returns %08x\n", r );
1779     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
1780     ok( r == E_FAIL, "returns %08x\n", r );
1781     SysFreeString(str);
1782
1783     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
1784     ok( r == S_OK, "returns %08x\n", r );
1785     if(nodePI)
1786     {
1787         /* Last Child Checks */
1788         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
1789         ok(r == E_INVALIDARG, "ret %08x\n", r );
1790
1791         nodeChild = (IXMLDOMNode*)0x1;
1792         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
1793         ok(r == S_FALSE, "ret %08x\n", r );
1794         ok(nodeChild == NULL, "nodeChild not NULL\n");
1795
1796         /* test nodeName */
1797         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
1798         ok(r == S_OK, "ret %08x\n", r );
1799         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1800         SysFreeString(str);
1801
1802         /* test baseName */
1803         str = (BSTR)0x1;
1804         r = IXMLDOMProcessingInstruction_get_baseName(nodePI, &str);
1805         ok(r == S_OK, "ret %08x\n", r );
1806         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1807         SysFreeString(str);
1808
1809         /* test Target */
1810         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
1811         ok(r == S_OK, "ret %08x\n", r );
1812         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
1813         SysFreeString(str);
1814
1815         /* test get_data */
1816         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
1817         ok(r == S_OK, "ret %08x\n", r );
1818         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
1819         SysFreeString(str);
1820
1821         /* test put_data */
1822         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
1823         ok(r == E_FAIL, "ret %08x\n", r );
1824
1825         /* test put_data */
1826         V_VT(&var) = VT_BSTR;
1827         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
1828         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
1829         ok(r == E_FAIL, "ret %08x\n", r );
1830         VariantClear(&var);
1831
1832         /* test get nodeName */
1833         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
1834         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1835         ok(r == S_OK, "ret %08x\n", r );
1836         SysFreeString(str);
1837
1838         IXMLDOMProcessingInstruction_Release(nodePI);
1839     }
1840
1841     ref = IXMLDOMDocument_Release( doc );
1842     ok( ref == 0, "got %d\n", ref);
1843
1844     free_bstrs();
1845 }
1846
1847 static void test_persiststreaminit(void)
1848 {
1849     IXMLDOMDocument *doc;
1850     IPersistStreamInit *streaminit;
1851     ULARGE_INTEGER size;
1852     HRESULT hr;
1853
1854     doc = create_document(&IID_IXMLDOMDocument);
1855
1856     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&streaminit);
1857     ok(hr == S_OK, "got 0x%08x\n", hr);
1858
1859     hr = IPersistStreamInit_InitNew(streaminit);
1860     ok(hr == S_OK, "got 0x%08x\n", hr);
1861
1862     hr = IPersistStreamInit_GetSizeMax(streaminit, &size);
1863     ok(hr == E_NOTIMPL, "got 0x%08x\n", hr);
1864
1865     IXMLDOMDocument_Release(doc);
1866 }
1867
1868 static void test_domnode( void )
1869 {
1870     HRESULT r;
1871     IXMLDOMDocument *doc, *owner = NULL;
1872     IXMLDOMElement *element = NULL;
1873     IXMLDOMNamedNodeMap *map = NULL;
1874     IXMLDOMNode *node = NULL, *next = NULL;
1875     IXMLDOMNodeList *list = NULL;
1876     IXMLDOMAttribute *attr = NULL;
1877     DOMNodeType type = NODE_INVALID;
1878     VARIANT_BOOL b;
1879     BSTR str;
1880     VARIANT var;
1881     LONG count;
1882
1883     doc = create_document(&IID_IXMLDOMDocument);
1884
1885     b = FALSE;
1886     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
1887     ok( r == S_OK, "loadXML failed\n");
1888     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1889
1890     EXPECT_CHILDREN(doc);
1891
1892     r = IXMLDOMDocument_get_documentElement( doc, &element );
1893     ok( r == S_OK, "should be a document element\n");
1894     ok( element != NULL, "should be an element\n");
1895
1896     VariantInit(&var);
1897     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
1898
1899     r = IXMLDOMDocument_get_nodeValue( doc, NULL );
1900     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
1901
1902     r = IXMLDOMDocument_get_nodeValue( doc, &var );
1903     ok( r == S_FALSE, "nextNode returned wrong code\n");
1904     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
1905     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
1906
1907     if (element)
1908     {
1909         owner = NULL;
1910         r = IXMLDOMElement_get_ownerDocument( element, &owner );
1911         ok( r == S_OK, "get_ownerDocument return code\n");
1912         ok( owner != doc, "get_ownerDocument return\n");
1913         IXMLDOMDocument_Release(owner);
1914
1915         type = NODE_INVALID;
1916         r = IXMLDOMElement_get_nodeType( element, &type);
1917         ok( r == S_OK, "got %08x\n", r);
1918         ok( type == NODE_ELEMENT, "node not an element\n");
1919
1920         str = NULL;
1921         r = IXMLDOMElement_get_baseName( element, &str );
1922         ok( r == S_OK, "get_baseName returned wrong code\n");
1923         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
1924         SysFreeString(str);
1925
1926         /* check if nodename is correct */
1927         r = IXMLDOMElement_get_nodeName( element, NULL );
1928         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1929
1930         /* content doesn't matter here */
1931         str = NULL;
1932         r = IXMLDOMElement_get_nodeName( element, &str );
1933         ok ( r == S_OK, "get_nodeName wrong code\n");
1934         ok ( str != NULL, "str is null\n");
1935         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
1936         SysFreeString( str );
1937
1938         str = SysAllocString( nonexistent_fileW );
1939         V_VT(&var) = VT_I4;
1940         V_I4(&var) = 0x1234;
1941         r = IXMLDOMElement_getAttribute( element, str, &var );
1942         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
1943         ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
1944         VariantClear(&var);
1945         SysFreeString(str);
1946
1947         str = SysAllocString( szdl );
1948         V_VT(&var) = VT_I4;
1949         V_I4(&var) = 0x1234;
1950         r = IXMLDOMElement_getAttribute( element, str, &var );
1951         ok( r == S_OK, "getAttribute ret %08x\n", r );
1952         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
1953         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
1954         VariantClear( &var );
1955
1956         r = IXMLDOMElement_getAttribute( element, NULL, &var );
1957         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
1958
1959         r = IXMLDOMElement_getAttribute( element, str, NULL );
1960         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
1961
1962         attr = NULL;
1963         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
1964         ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
1965         ok( attr != NULL, "getAttributeNode returned NULL\n" );
1966         if (attr)
1967         {
1968             r = IXMLDOMAttribute_get_parentNode( attr, NULL );
1969             ok( r == E_INVALIDARG, "Expected E_INVALIDARG, ret %08x\n", r );
1970
1971             /* attribute doesn't have a parent in msxml interpretation */
1972             node = (IXMLDOMNode*)0xdeadbeef;
1973             r = IXMLDOMAttribute_get_parentNode( attr, &node );
1974             ok( r == S_FALSE, "Expected S_FALSE, ret %08x\n", r );
1975             ok( node == NULL, "Expected NULL, got %p\n", node );
1976
1977             IXMLDOMAttribute_Release(attr);
1978         }
1979
1980         SysFreeString( str );
1981
1982         r = IXMLDOMElement_get_attributes( element, &map );
1983         ok( r == S_OK, "get_attributes returned wrong code\n");
1984         ok( map != NULL, "should be attributes\n");
1985
1986         EXPECT_CHILDREN(element);
1987     }
1988     else
1989         ok( FALSE, "no element\n");
1990
1991     if (map)
1992     {
1993         str = SysAllocString( szdl );
1994         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
1995         ok( r == S_OK, "getNamedItem returned wrong code\n");
1996         ok( node != NULL, "should be attributes\n");
1997         IXMLDOMNode_Release(node);
1998         SysFreeString( str );
1999
2000         str = SysAllocString( szdl );
2001         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
2002         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
2003         SysFreeString( str );
2004
2005         /* something that isn't in complete4A */
2006         str = SysAllocString( szOpen );
2007         node = (IXMLDOMNode *) 1;
2008         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
2009         ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
2010         ok( node == NULL, "getNamedItem should have returned NULL\n");
2011         SysFreeString( str );
2012
2013         /* test indexed access of attributes */
2014         r = IXMLDOMNamedNodeMap_get_length( map, NULL );
2015         ok ( r == E_INVALIDARG, "get_length should return E_INVALIDARG\n");
2016
2017         r = IXMLDOMNamedNodeMap_get_length( map, &count );
2018         ok ( r == S_OK, "get_length wrong code\n");
2019         ok ( count == 1, "get_length != 1\n");
2020
2021         node = NULL;
2022         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
2023         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
2024         ok ( node == NULL, "there is no node\n");
2025
2026         node = NULL;
2027         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
2028         ok ( r == S_FALSE, "get_item (1) wrong code\n");
2029         ok ( node == NULL, "there is no attribute\n");
2030
2031         node = NULL;
2032         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
2033         ok ( r == S_OK, "get_item (0) wrong code\n");
2034         ok ( node != NULL, "should be attribute\n");
2035
2036         r = IXMLDOMNode_get_nodeName( node, NULL );
2037         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2038
2039         /* content doesn't matter here */
2040         str = NULL;
2041         r = IXMLDOMNode_get_nodeName( node, &str );
2042         ok ( r == S_OK, "get_nodeName wrong code\n");
2043         ok ( str != NULL, "str is null\n");
2044         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
2045         SysFreeString( str );
2046         IXMLDOMNode_Release( node );
2047
2048         /* test sequential access of attributes */
2049         node = NULL;
2050         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2051         ok ( r == S_OK, "nextNode (first time) wrong code\n");
2052         ok ( node != NULL, "nextNode, should be attribute\n");
2053         IXMLDOMNode_Release( node );
2054
2055         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2056         ok ( r != S_OK, "nextNode (second time) wrong code\n");
2057         ok ( node == NULL, "nextNode, there is no attribute\n");
2058
2059         r = IXMLDOMNamedNodeMap_reset( map );
2060         ok ( r == S_OK, "reset should return S_OK\n");
2061
2062         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2063         ok ( r == S_OK, "nextNode (third time) wrong code\n");
2064         ok ( node != NULL, "nextNode, should be attribute\n");
2065     }
2066     else
2067         ok( FALSE, "no map\n");
2068
2069     if (node)
2070     {
2071         type = NODE_INVALID;
2072         r = IXMLDOMNode_get_nodeType( node, &type);
2073         ok( r == S_OK, "getNamedItem returned wrong code\n");
2074         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
2075
2076         str = NULL;
2077         r = IXMLDOMNode_get_baseName( node, NULL );
2078         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
2079
2080         str = NULL;
2081         r = IXMLDOMNode_get_baseName( node, &str );
2082         ok( r == S_OK, "get_baseName returned wrong code\n");
2083         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
2084         SysFreeString( str );
2085
2086         r = IXMLDOMNode_get_childNodes( node, NULL );
2087         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
2088
2089         r = IXMLDOMNode_get_childNodes( node, &list );
2090         ok( r == S_OK, "get_childNodes returned wrong code\n");
2091
2092         if (list)
2093         {
2094             r = IXMLDOMNodeList_nextNode( list, &next );
2095             ok( r == S_OK, "nextNode returned wrong code\n");
2096         }
2097         else
2098             ok( FALSE, "no childlist\n");
2099
2100         if (next)
2101         {
2102             EXPECT_NO_CHILDREN(next);
2103
2104             type = NODE_INVALID;
2105             r = IXMLDOMNode_get_nodeType( next, &type);
2106             ok( r == S_OK, "getNamedItem returned wrong code\n");
2107             ok( type == NODE_TEXT, "node not text\n");
2108
2109             str = (BSTR) 1;
2110             r = IXMLDOMNode_get_baseName( next, &str );
2111             ok( r == S_FALSE, "get_baseName returned wrong code\n");
2112             ok( str == NULL, "basename was wrong\n");
2113             SysFreeString(str);
2114         }
2115         else
2116             ok( FALSE, "no next\n");
2117
2118         if (next)
2119             IXMLDOMNode_Release( next );
2120         next = NULL;
2121         if (list)
2122             IXMLDOMNodeList_Release( list );
2123         list = NULL;
2124         if (node)
2125             IXMLDOMNode_Release( node );
2126     }
2127     else
2128         ok( FALSE, "no node\n");
2129     node = NULL;
2130
2131     if (map)
2132         IXMLDOMNamedNodeMap_Release( map );
2133
2134     /* now traverse the tree from the root element */
2135     if (element)
2136     {
2137         r = IXMLDOMElement_get_childNodes( element, &list );
2138         ok( r == S_OK, "get_childNodes returned wrong code\n");
2139
2140         /* using get_item for child list doesn't advance the position */
2141         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
2142         expect_node(node, "E2.E2.D1");
2143         IXMLDOMNode_Release(node);
2144         ole_check(IXMLDOMNodeList_nextNode(list, &node));
2145         expect_node(node, "E1.E2.D1");
2146         IXMLDOMNode_Release(node);
2147         ole_check(IXMLDOMNodeList_reset(list));
2148
2149         IXMLDOMNodeList_AddRef(list);
2150         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
2151         ole_check(IXMLDOMNodeList_reset(list));
2152
2153         node = (void*)0xdeadbeef;
2154         str = SysAllocString(szdl);
2155         r = IXMLDOMElement_selectSingleNode( element, str, &node );
2156         SysFreeString(str);
2157         ok( r == S_FALSE, "ret %08x\n", r );
2158         ok( node == NULL, "node %p\n", node );
2159
2160         str = SysAllocString(szbs);
2161         r = IXMLDOMElement_selectSingleNode( element, str, &node );
2162         SysFreeString(str);
2163         ok( r == S_OK, "ret %08x\n", r );
2164         r = IXMLDOMNode_Release( node );
2165         ok( r == 0, "ret %08x\n", r );
2166     }
2167     else
2168         ok( FALSE, "no element\n");
2169
2170     if (list)
2171     {
2172         r = IXMLDOMNodeList_get_item(list, 0, NULL);
2173         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2174
2175         r = IXMLDOMNodeList_get_length(list, NULL);
2176         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2177
2178         r = IXMLDOMNodeList_get_length( list, &count );
2179         ok( r == S_OK, "get_length returns %08x\n", r );
2180         ok( count == 4, "get_length got %d\n", count );
2181
2182         r = IXMLDOMNodeList_nextNode(list, NULL);
2183         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2184
2185         r = IXMLDOMNodeList_nextNode( list, &node );
2186         ok( r == S_OK, "nextNode returned wrong code\n");
2187     }
2188     else
2189         ok( FALSE, "no list\n");
2190
2191     if (node)
2192     {
2193         type = NODE_INVALID;
2194         r = IXMLDOMNode_get_nodeType( node, &type);
2195         ok( r == S_OK, "getNamedItem returned wrong code\n");
2196         ok( type == NODE_ELEMENT, "node not text\n");
2197
2198         r = IXMLDOMNode_hasChildNodes( node, NULL );
2199         ok( r == E_INVALIDARG, "hasChildNodes bad return\n");
2200
2201         EXPECT_CHILDREN(node);
2202
2203         str = NULL;
2204         r = IXMLDOMNode_get_baseName( node, &str );
2205         ok( r == S_OK, "get_baseName returned wrong code\n");
2206         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
2207         SysFreeString(str);
2208     }
2209     else
2210         ok( FALSE, "no node\n");
2211
2212     if (node)
2213         IXMLDOMNode_Release( node );
2214     if (list)
2215         IXMLDOMNodeList_Release( list );
2216     if (element)
2217         IXMLDOMElement_Release( element );
2218
2219     b = FALSE;
2220     str = SysAllocString( szComplete5 );
2221     r = IXMLDOMDocument_loadXML( doc, str, &b );
2222     ok( r == S_OK, "loadXML failed\n");
2223     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2224     SysFreeString( str );
2225
2226     EXPECT_CHILDREN(doc);
2227
2228     r = IXMLDOMDocument_get_documentElement( doc, &element );
2229     ok( r == S_OK, "should be a document element\n");
2230     ok( element != NULL, "should be an element\n");
2231
2232     if (element)
2233     {
2234         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
2235         BSTR tag = NULL;
2236
2237         /* check if the tag is correct */
2238         r = IXMLDOMElement_get_tagName( element, &tag );
2239         ok( r == S_OK, "couldn't get tag name\n");
2240         ok( tag != NULL, "tag was null\n");
2241         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
2242         SysFreeString( tag );
2243     }
2244
2245     if (element)
2246         IXMLDOMElement_Release( element );
2247     ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
2248
2249     free_bstrs();
2250 }
2251
2252 typedef struct {
2253     DOMNodeType type;
2254     REFIID iid;
2255 } refcount_test_t;
2256
2257 static const refcount_test_t refcount_test[] = {
2258     { NODE_ELEMENT,                &IID_IXMLDOMElement },
2259     { NODE_ATTRIBUTE,              &IID_IXMLDOMAttribute },
2260     { NODE_TEXT,                   &IID_IXMLDOMText },
2261     { NODE_CDATA_SECTION,          &IID_IXMLDOMCDATASection },
2262     { NODE_ENTITY_REFERENCE,       &IID_IXMLDOMEntityReference },
2263     { NODE_PROCESSING_INSTRUCTION, &IID_IXMLDOMProcessingInstruction },
2264     { NODE_COMMENT,                &IID_IXMLDOMComment },
2265     { NODE_DOCUMENT_FRAGMENT,      &IID_IXMLDOMDocumentFragment },
2266     { NODE_INVALID,                &IID_NULL }
2267 };
2268
2269 static void test_refs(void)
2270 {
2271     IXMLDOMImplementation *impl, *impl2;
2272     IXMLDOMElement *element, *elem2;
2273     IXMLDOMNodeList *node_list = NULL;
2274     IXMLDOMNode *node, *node2, *node3;
2275     const refcount_test_t *ptr;
2276     IXMLDOMDocument *doc;
2277     IUnknown *unk, *unk2;
2278     VARIANT_BOOL b;
2279     HRESULT hr;
2280     LONG ref;
2281
2282     doc = create_document(&IID_IXMLDOMDocument);
2283
2284     ptr = refcount_test;
2285     while (ptr->type != NODE_INVALID)
2286     {
2287         IUnknown *node_typed, *node_typed2;
2288         IDispatchEx *dispex, *dispex2;
2289         IDispatch *disp, *disp2;
2290         VARIANT type;
2291
2292         V_VT(&type) = VT_I1;
2293         V_I1(&type) = ptr->type;
2294
2295         EXPECT_REF(doc, 1);
2296         hr = IXMLDOMDocument_createNode(doc, type, _bstr_("name"), NULL, &node);
2297         EXPECT_HR(hr, S_OK);
2298         EXPECT_REF(doc, 1);
2299         EXPECT_REF(node, 1);
2300
2301         /* try IDispatch and IUnknown from IXMLDOMNode */
2302         hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
2303         EXPECT_HR(hr, S_OK);
2304         EXPECT_REF(unk, 2);
2305 todo_wine {
2306         EXPECT_REF(node, 1);
2307         ok(unk != (IUnknown*)node, "%d: got %p and %p\n", ptr->type, unk, node);
2308 }
2309         EXPECT_REF(unk, 2);
2310         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
2311         EXPECT_HR(hr, S_OK);
2312         todo_wine ok(unk != (IUnknown*)disp, "%d: got %p and %p\n", ptr->type, unk, disp);
2313         EXPECT_REF(unk, 3);
2314         todo_wine EXPECT_REF(disp, 1);
2315
2316         EXPECT_REF(unk, 3);
2317         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp2);
2318         EXPECT_HR(hr, S_OK);
2319         todo_wine ok(disp != disp2, "%d: got %p and %p\n", ptr->type, disp, disp2);
2320         EXPECT_REF(unk, 4);
2321         todo_wine EXPECT_REF(disp2, 1);
2322
2323         IDispatch_Release(disp);
2324         IDispatch_Release(disp2);
2325
2326         /* get IXMLDOMNode from this IUnknown */
2327         EXPECT_REF(unk, 2);
2328         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node2);
2329         EXPECT_HR(hr, S_OK);
2330         todo_wine ok(unk != (IUnknown*)node2, "%d: got %p and %p\n", ptr->type, unk, node2);
2331         EXPECT_REF(unk, 3);
2332         todo_wine EXPECT_REF(node2, 1);
2333
2334         EXPECT_REF(unk, 3);
2335         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node3);
2336         EXPECT_HR(hr, S_OK);
2337         todo_wine ok(node2 != node3, "%d: got %p and %p\n", ptr->type, node2, node3);
2338         EXPECT_REF(unk, 4);
2339         todo_wine EXPECT_REF(node3, 1);
2340
2341         IXMLDOMNode_Release(node2);
2342         IXMLDOMNode_Release(node3);
2343
2344         /* try IDispatchEx from IUnknown */
2345         EXPECT_REF(unk, 2);
2346         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
2347         EXPECT_HR(hr, S_OK);
2348         ok(unk != (IUnknown*)dispex, "%d: got %p and %p\n", ptr->type, unk, dispex);
2349         EXPECT_REF(unk, 3);
2350         todo_wine EXPECT_REF(dispex, 1);
2351
2352         EXPECT_REF(unk, 3);
2353         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex2);
2354         EXPECT_HR(hr, S_OK);
2355         todo_wine ok(dispex != dispex2, "%d: got %p and %p\n", ptr->type, dispex, dispex2);
2356         EXPECT_REF(unk, 4);
2357         todo_wine EXPECT_REF(dispex2, 1);
2358
2359         IDispatchEx_Release(dispex);
2360         IDispatchEx_Release(dispex2);
2361
2362         /* try corresponding IXMLDOM* */
2363         EXPECT_REF(unk, 2);
2364         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed);
2365         EXPECT_HR(hr, S_OK);
2366         EXPECT_REF(unk, 3);
2367         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed2);
2368         EXPECT_HR(hr, S_OK);
2369         EXPECT_REF(unk, 4);
2370         todo_wine ok(node_typed != node_typed2, "%d: got %p and %p\n", ptr->type, node_typed, node_typed2);
2371         IUnknown_Release(node_typed);
2372         IUnknown_Release(node_typed2);
2373
2374         /* try invalid IXMLDOM* */
2375         hr = IUnknown_QueryInterface(unk, (ptr+1)->iid, (void**)&node_typed);
2376         EXPECT_HR(hr, E_NOINTERFACE);
2377
2378         IUnknown_Release(unk);
2379
2380         EXPECT_REF(node, 1);
2381         hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMNode, (void**)&node2);
2382         EXPECT_HR(hr, S_OK);
2383         EXPECT_REF(node, 2);
2384         ok(node == node2, "%d: got %p and %p\n", ptr->type, node, node2);
2385
2386         EXPECT_REF(node, 2);
2387         hr = IXMLDOMNode_QueryInterface(node, ptr->iid, (void**)&node_typed);
2388         EXPECT_HR(hr, S_OK);
2389         EXPECT_REF(node, 3);
2390 todo_wine {
2391         EXPECT_REF(node_typed, 2);
2392         ok((IUnknown*)node != node_typed, "%d: got %p and %p\n", ptr->type, node, node_typed);
2393 }
2394         IUnknown_Release(node_typed);
2395
2396         IXMLDOMNode_Release(node2);
2397         IXMLDOMNode_Release(node);
2398
2399         ptr++;
2400     }
2401
2402     EXPECT_REF(doc, 1);
2403     ref = IXMLDOMDocument_Release(doc);
2404     ok( ref == 0, "ref %d\n", ref);
2405
2406     /* check IUnknown after releasing DOM iface */
2407     doc = create_document(&IID_IXMLDOMDocument);
2408     EXPECT_REF(doc, 1);
2409     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2410     EXPECT_HR(hr, S_OK);
2411 todo_wine {
2412     EXPECT_REF(unk, 3);
2413     EXPECT_REF(doc, 1);
2414 }
2415     IXMLDOMDocument_Release(doc);
2416     EXPECT_REF(unk, 1);
2417     IUnknown_Release(unk);
2418
2419     doc = create_document(&IID_IXMLDOMDocument);
2420
2421     EXPECT_REF(doc, 1);
2422     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2423     EXPECT_HR(hr, S_OK);
2424 todo_wine {
2425     EXPECT_REF(unk, 3);
2426     EXPECT_REF(doc, 1);
2427 }
2428     IUnknown_Release(unk);
2429
2430     /* IXMLDOMImplementation */
2431     EXPECT_REF(doc, 1);
2432     hr = IXMLDOMDocument_get_implementation(doc, &impl);
2433     EXPECT_HR(hr, S_OK);
2434     EXPECT_REF(doc, 1);
2435     EXPECT_REF(impl, 1);
2436     hr = IXMLDOMDocument_get_implementation(doc, &impl2);
2437     EXPECT_HR(hr, S_OK);
2438     EXPECT_REF(doc, 1);
2439     EXPECT_REF(impl2, 1);
2440     ok(impl != impl2, "got %p, %p\n", impl, impl2);
2441     IXMLDOMImplementation_Release(impl);
2442     IXMLDOMImplementation_Release(impl2);
2443
2444     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2445     EXPECT_HR(hr, S_OK);
2446     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2447
2448     EXPECT_REF(doc, 1);
2449     IXMLDOMDocument_AddRef( doc );
2450     EXPECT_REF(doc, 2);
2451     IXMLDOMDocument_AddRef( doc );
2452     EXPECT_REF(doc, 3);
2453
2454     IXMLDOMDocument_Release( doc );
2455     IXMLDOMDocument_Release( doc );
2456
2457     EXPECT_REF(doc, 1);
2458     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2459     EXPECT_HR(hr, S_OK);
2460 todo_wine {
2461     EXPECT_REF(unk, 3);
2462     EXPECT_REF(doc, 1);
2463 }
2464     hr = IXMLDOMDocument_get_documentElement(doc, &element);
2465     EXPECT_HR(hr, S_OK);
2466 todo_wine {
2467     EXPECT_REF(doc, 1);
2468     EXPECT_REF(element, 2);
2469 }
2470     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
2471     EXPECT_HR(hr, S_OK);
2472
2473 todo_wine {
2474     EXPECT_REF(doc, 1);
2475     EXPECT_REF(element, 2);
2476     EXPECT_REF(elem2, 2);
2477 }
2478     IXMLDOMElement_AddRef(element);
2479     todo_wine EXPECT_REF(element, 3);
2480     IXMLDOMElement_Release(element);
2481
2482     /* get IUnknown from a node doesn't touch node instance refcount */
2483     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
2484     EXPECT_HR(hr, S_OK);
2485     EXPECT_REF(element, 2);
2486 todo_wine {
2487     EXPECT_REF(unk, 4);
2488     EXPECT_REF(elem2, 2);
2489 }
2490     hr = IXMLDOMElement_QueryInterface(elem2, &IID_IUnknown, (void**)&unk2);
2491     EXPECT_HR(hr, S_OK);
2492 todo_wine {
2493     EXPECT_REF(unk, 5);
2494     EXPECT_REF(unk2, 5);
2495 }
2496     EXPECT_REF(element, 2);
2497     EXPECT_REF(elem2, 2);
2498
2499     todo_wine ok(unk == unk2, "got %p and %p\n", unk, unk2);
2500     IUnknown_Release(unk);
2501
2502     /* IUnknown refcount is not affected by node refcount */
2503     todo_wine EXPECT_REF(unk2, 4);
2504     IXMLDOMElement_AddRef(elem2);
2505     todo_wine EXPECT_REF(unk2, 4);
2506     IXMLDOMElement_Release(elem2);
2507
2508     IXMLDOMElement_Release(elem2);
2509     todo_wine EXPECT_REF(unk2, 3);
2510
2511     IUnknown_Release(unk2);
2512
2513     hr = IXMLDOMElement_get_childNodes( element, &node_list );
2514     EXPECT_HR(hr, S_OK);
2515
2516     todo_wine EXPECT_REF(element, 2);
2517     EXPECT_REF(node_list, 1);
2518
2519     hr = IXMLDOMNodeList_get_item( node_list, 0, &node );
2520     EXPECT_HR(hr, S_OK);
2521     EXPECT_REF(node_list, 1);
2522     EXPECT_REF(node, 1);
2523
2524     hr = IXMLDOMNodeList_get_item( node_list, 0, &node2 );
2525     EXPECT_HR(hr, S_OK);
2526     EXPECT_REF(node_list, 1);
2527     EXPECT_REF(node2, 1);
2528
2529     ref = IXMLDOMNode_Release( node );
2530     ok( ref == 0, "ref %d\n", ref );
2531     ref = IXMLDOMNode_Release( node2 );
2532     ok( ref == 0, "ref %d\n", ref );
2533
2534     ref = IXMLDOMNodeList_Release( node_list );
2535     ok( ref == 0, "ref %d\n", ref );
2536
2537     ok( node != node2, "node %p node2 %p\n", node, node2 );
2538
2539     ref = IXMLDOMDocument_Release( doc );
2540     todo_wine ok( ref == 0, "ref %d\n", ref );
2541
2542     todo_wine EXPECT_REF(element, 2);
2543
2544     /* IUnknown must be unique however we obtain it */
2545     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
2546     EXPECT_HR(hr, S_OK);
2547     EXPECT_REF(element, 2);
2548     hr = IXMLDOMElement_QueryInterface(element, &IID_IXMLDOMNode, (void**)&node);
2549     EXPECT_HR(hr, S_OK);
2550     todo_wine EXPECT_REF(element, 2);
2551     hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk2);
2552     EXPECT_HR(hr, S_OK);
2553     todo_wine EXPECT_REF(element, 2);
2554     ok(unk == unk2, "unk %p unk2 %p\n", unk, unk2);
2555     todo_wine ok(element != (void*)node, "node %p element %p\n", node, element);
2556
2557     IUnknown_Release( unk2 );
2558     IUnknown_Release( unk );
2559     IXMLDOMNode_Release( node );
2560     todo_wine EXPECT_REF(element, 2);
2561
2562     IXMLDOMElement_Release( element );
2563
2564     free_bstrs();
2565 }
2566
2567 static void test_create(void)
2568 {
2569     static const WCHAR szOne[] = {'1',0};
2570     static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
2571     HRESULT r;
2572     VARIANT var;
2573     BSTR str, name;
2574     IXMLDOMDocument *doc;
2575     IXMLDOMElement *element;
2576     IXMLDOMComment *comment;
2577     IXMLDOMText *text;
2578     IXMLDOMCDATASection *cdata;
2579     IXMLDOMNode *root, *node, *child;
2580     IXMLDOMNamedNodeMap *attr_map;
2581     IUnknown *unk;
2582     LONG ref;
2583     LONG num;
2584
2585     doc = create_document(&IID_IXMLDOMDocument);
2586
2587     EXPECT_REF(doc, 1);
2588
2589     /* types not supported for creation */
2590     V_VT(&var) = VT_I1;
2591     V_I1(&var) = NODE_DOCUMENT;
2592     node = (IXMLDOMNode*)0x1;
2593     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2594     ok( r == E_INVALIDARG, "returns %08x\n", r );
2595     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2596
2597     V_VT(&var) = VT_I1;
2598     V_I1(&var) = NODE_DOCUMENT_TYPE;
2599     node = (IXMLDOMNode*)0x1;
2600     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2601     ok( r == E_INVALIDARG, "returns %08x\n", r );
2602     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2603
2604     V_VT(&var) = VT_I1;
2605     V_I1(&var) = NODE_ENTITY;
2606     node = (IXMLDOMNode*)0x1;
2607     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2608     ok( r == E_INVALIDARG, "returns %08x\n", r );
2609     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2610
2611     V_VT(&var) = VT_I1;
2612     V_I1(&var) = NODE_NOTATION;
2613     node = (IXMLDOMNode*)0x1;
2614     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2615     ok( r == E_INVALIDARG, "returns %08x\n", r );
2616     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2617
2618     /* NODE_COMMENT */
2619     V_VT(&var) = VT_I1;
2620     V_I1(&var) = NODE_COMMENT;
2621     node = NULL;
2622     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2623     ok( r == S_OK, "returns %08x\n", r );
2624     ok( node != NULL, "\n");
2625
2626     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2627     ok( r == S_OK, "returns %08x\n", r );
2628     IXMLDOMNode_Release(node);
2629
2630     str = NULL;
2631     r = IXMLDOMComment_get_data(comment, &str);
2632     ok( r == S_OK, "returns %08x\n", r );
2633     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2634     IXMLDOMComment_Release(comment);
2635     SysFreeString(str);
2636
2637     node = (IXMLDOMNode*)0x1;
2638     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2639     ok( r == S_OK, "returns %08x\n", r );
2640
2641     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2642     ok( r == S_OK, "returns %08x\n", r );
2643     IXMLDOMNode_Release(node);
2644
2645     str = NULL;
2646     r = IXMLDOMComment_get_data(comment, &str);
2647     ok( r == S_OK, "returns %08x\n", r );
2648     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2649     IXMLDOMComment_Release(comment);
2650     SysFreeString(str);
2651
2652     node = (IXMLDOMNode*)0x1;
2653     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2654     ok( r == S_OK, "returns %08x\n", r );
2655
2656     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2657     ok( r == S_OK, "returns %08x\n", r );
2658     IXMLDOMNode_Release(node);
2659
2660     str = NULL;
2661     r = IXMLDOMComment_get_data(comment, &str);
2662     ok( r == S_OK, "returns %08x\n", r );
2663     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2664     IXMLDOMComment_Release(comment);
2665     SysFreeString(str);
2666
2667     /* NODE_TEXT */
2668     V_VT(&var) = VT_I1;
2669     V_I1(&var) = NODE_TEXT;
2670     node = NULL;
2671     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2672     ok( r == S_OK, "returns %08x\n", r );
2673     ok( node != NULL, "\n");
2674
2675     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2676     ok( r == S_OK, "returns %08x\n", r );
2677     IXMLDOMNode_Release(node);
2678
2679     str = NULL;
2680     r = IXMLDOMText_get_data(text, &str);
2681     ok( r == S_OK, "returns %08x\n", r );
2682     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2683     IXMLDOMText_Release(text);
2684     SysFreeString(str);
2685
2686     node = (IXMLDOMNode*)0x1;
2687     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2688     ok( r == S_OK, "returns %08x\n", r );
2689
2690     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2691     ok( r == S_OK, "returns %08x\n", r );
2692     IXMLDOMNode_Release(node);
2693
2694     str = NULL;
2695     r = IXMLDOMText_get_data(text, &str);
2696     ok( r == S_OK, "returns %08x\n", r );
2697     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2698     IXMLDOMText_Release(text);
2699     SysFreeString(str);
2700
2701     node = (IXMLDOMNode*)0x1;
2702     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2703     ok( r == S_OK, "returns %08x\n", r );
2704
2705     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2706     ok( r == S_OK, "returns %08x\n", r );
2707     IXMLDOMNode_Release(node);
2708
2709     str = NULL;
2710     r = IXMLDOMText_get_data(text, &str);
2711     ok( r == S_OK, "returns %08x\n", r );
2712     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2713     IXMLDOMText_Release(text);
2714     SysFreeString(str);
2715
2716     /* NODE_CDATA_SECTION */
2717     V_VT(&var) = VT_I1;
2718     V_I1(&var) = NODE_CDATA_SECTION;
2719     node = NULL;
2720     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2721     ok( r == S_OK, "returns %08x\n", r );
2722     ok( node != NULL, "\n");
2723
2724     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2725     ok( r == S_OK, "returns %08x\n", r );
2726     IXMLDOMNode_Release(node);
2727
2728     str = NULL;
2729     r = IXMLDOMCDATASection_get_data(cdata, &str);
2730     ok( r == S_OK, "returns %08x\n", r );
2731     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2732     IXMLDOMCDATASection_Release(cdata);
2733     SysFreeString(str);
2734
2735     node = (IXMLDOMNode*)0x1;
2736     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2737     ok( r == S_OK, "returns %08x\n", r );
2738
2739     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2740     ok( r == S_OK, "returns %08x\n", r );
2741     IXMLDOMNode_Release(node);
2742
2743     str = NULL;
2744     r = IXMLDOMCDATASection_get_data(cdata, &str);
2745     ok( r == S_OK, "returns %08x\n", r );
2746     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2747     IXMLDOMCDATASection_Release(cdata);
2748     SysFreeString(str);
2749
2750     node = (IXMLDOMNode*)0x1;
2751     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2752     ok( r == S_OK, "returns %08x\n", r );
2753
2754     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2755     ok( r == S_OK, "returns %08x\n", r );
2756     IXMLDOMNode_Release(node);
2757
2758     str = NULL;
2759     r = IXMLDOMCDATASection_get_data(cdata, &str);
2760     ok( r == S_OK, "returns %08x\n", r );
2761     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2762     IXMLDOMCDATASection_Release(cdata);
2763     SysFreeString(str);
2764
2765     /* NODE_ATTRIBUTE */
2766     V_VT(&var) = VT_I1;
2767     V_I1(&var) = NODE_ATTRIBUTE;
2768     node = (IXMLDOMNode*)0x1;
2769     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2770     ok( r == E_FAIL, "returns %08x\n", r );
2771     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2772
2773     V_VT(&var) = VT_I1;
2774     V_I1(&var) = NODE_ATTRIBUTE;
2775     node = (IXMLDOMNode*)0x1;
2776     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2777     ok( r == E_FAIL, "returns %08x\n", r );
2778     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2779
2780     V_VT(&var) = VT_I1;
2781     V_I1(&var) = NODE_ATTRIBUTE;
2782     str = SysAllocString( szlc );
2783     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2784     ok( r == S_OK, "returns %08x\n", r );
2785     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2786     SysFreeString(str);
2787
2788     /* a name is required for attribute, try a BSTR with first null wchar */
2789     V_VT(&var) = VT_I1;
2790     V_I1(&var) = NODE_ATTRIBUTE;
2791     str = SysAllocString( szstr1 );
2792     str[0] = 0;
2793     node = (IXMLDOMNode*)0x1;
2794     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2795     ok( r == E_FAIL, "returns %08x\n", r );
2796     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2797     SysFreeString(str);
2798
2799     /* NODE_PROCESSING_INSTRUCTION */
2800     V_VT(&var) = VT_I1;
2801     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2802     node = (IXMLDOMNode*)0x1;
2803     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2804     ok( r == E_FAIL, "returns %08x\n", r );
2805     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2806
2807     V_VT(&var) = VT_I1;
2808     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2809     node = (IXMLDOMNode*)0x1;
2810     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2811     ok( r == E_FAIL, "returns %08x\n", r );
2812     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2813
2814     V_VT(&var) = VT_I1;
2815     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2816     r = IXMLDOMDocument_createNode( doc, var, _bstr_("pi"), NULL, NULL );
2817     ok( r == E_INVALIDARG, "returns %08x\n", r );
2818
2819     /* NODE_ENTITY_REFERENCE */
2820     V_VT(&var) = VT_I1;
2821     V_I1(&var) = NODE_ENTITY_REFERENCE;
2822     node = (IXMLDOMNode*)0x1;
2823     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2824     ok( r == E_FAIL, "returns %08x\n", r );
2825     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2826
2827     V_VT(&var) = VT_I1;
2828     V_I1(&var) = NODE_ENTITY_REFERENCE;
2829     node = (IXMLDOMNode*)0x1;
2830     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2831     ok( r == E_FAIL, "returns %08x\n", r );
2832     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2833
2834     /* NODE_ELEMENT */
2835     V_VT(&var) = VT_I1;
2836     V_I1(&var) = NODE_ELEMENT;
2837     node = (IXMLDOMNode*)0x1;
2838     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2839     ok( r == E_FAIL, "returns %08x\n", r );
2840     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2841
2842     V_VT(&var) = VT_I1;
2843     V_I1(&var) = NODE_ELEMENT;
2844     node = (IXMLDOMNode*)0x1;
2845     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2846     ok( r == E_FAIL, "returns %08x\n", r );
2847     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2848
2849     V_VT(&var) = VT_I1;
2850     V_I1(&var) = NODE_ELEMENT;
2851     str = SysAllocString( szlc );
2852     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2853     ok( r == S_OK, "returns %08x\n", r );
2854     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2855
2856     V_VT(&var) = VT_I1;
2857     V_I1(&var) = NODE_ELEMENT;
2858     r = IXMLDOMDocument_createNode( doc, var, str, NULL, NULL );
2859     ok( r == E_INVALIDARG, "returns %08x\n", r );
2860
2861     V_VT(&var) = VT_R4;
2862     V_R4(&var) = NODE_ELEMENT;
2863     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2864     ok( r == S_OK, "returns %08x\n", r );
2865     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2866
2867     V_VT(&var) = VT_BSTR;
2868     V_BSTR(&var) = SysAllocString( szOne );
2869     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2870     ok( r == S_OK, "returns %08x\n", r );
2871     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2872     VariantClear(&var);
2873
2874     V_VT(&var) = VT_BSTR;
2875     V_BSTR(&var) = SysAllocString( szOneGarbage );
2876     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2877     ok( r == E_INVALIDARG, "returns %08x\n", r );
2878     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2879     VariantClear(&var);
2880
2881     V_VT(&var) = VT_I4;
2882     V_I4(&var) = NODE_ELEMENT;
2883     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2884     ok( r == S_OK, "returns %08x\n", r );
2885
2886     EXPECT_REF(doc, 1);
2887     r = IXMLDOMDocument_appendChild( doc, node, &root );
2888     ok( r == S_OK, "returns %08x\n", r );
2889     ok( node == root, "%p %p\n", node, root );
2890     EXPECT_REF(doc, 1);
2891
2892     EXPECT_REF(node, 2);
2893
2894     ref = IXMLDOMNode_Release( node );
2895     ok(ref == 1, "ref %d\n", ref);
2896     SysFreeString( str );
2897
2898     V_VT(&var) = VT_I4;
2899     V_I4(&var) = NODE_ELEMENT;
2900     str = SysAllocString( szbs );
2901     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2902     ok( r == S_OK, "returns %08x\n", r );
2903     SysFreeString( str );
2904
2905     EXPECT_REF(node, 1);
2906
2907     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk );
2908     ok( r == S_OK, "returns %08x\n", r );
2909
2910     EXPECT_REF(unk, 2);
2911
2912     V_VT(&var) = VT_EMPTY;
2913     child = NULL;
2914     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
2915     ok( r == S_OK, "returns %08x\n", r );
2916     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
2917
2918     todo_wine EXPECT_REF(unk, 4);
2919
2920     IXMLDOMNode_Release( child );
2921     IUnknown_Release( unk );
2922
2923     V_VT(&var) = VT_NULL;
2924     V_DISPATCH(&var) = (IDispatch*)node;
2925     r = IXMLDOMNode_insertBefore( root, node, var, &child );
2926     ok( r == S_OK, "returns %08x\n", r );
2927     ok( node == child, "%p %p\n", node, child );
2928     IXMLDOMNode_Release( child );
2929
2930     V_VT(&var) = VT_NULL;
2931     V_DISPATCH(&var) = (IDispatch*)node;
2932     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
2933     ok( r == S_OK, "returns %08x\n", r );
2934     IXMLDOMNode_Release( node );
2935
2936     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (void**)&element );
2937     ok( r == S_OK, "returns %08x\n", r );
2938
2939     r = IXMLDOMElement_get_attributes( element, &attr_map );
2940     ok( r == S_OK, "returns %08x\n", r );
2941     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2942     ok( r == S_OK, "returns %08x\n", r );
2943     ok( num == 0, "num %d\n", num );
2944     IXMLDOMNamedNodeMap_Release( attr_map );
2945
2946     V_VT(&var) = VT_BSTR;
2947     V_BSTR(&var) = SysAllocString( szstr1 );
2948     name = SysAllocString( szdl );
2949     r = IXMLDOMElement_setAttribute( element, name, var );
2950     ok( r == S_OK, "returns %08x\n", r );
2951     r = IXMLDOMElement_get_attributes( element, &attr_map );
2952     ok( r == S_OK, "returns %08x\n", r );
2953     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2954     ok( r == S_OK, "returns %08x\n", r );
2955     ok( num == 1, "num %d\n", num );
2956     IXMLDOMNamedNodeMap_Release( attr_map );
2957     VariantClear(&var);
2958
2959     V_VT(&var) = VT_BSTR;
2960     V_BSTR(&var) = SysAllocString( szstr2 );
2961     r = IXMLDOMElement_setAttribute( element, name, var );
2962     ok( r == S_OK, "returns %08x\n", r );
2963     r = IXMLDOMElement_get_attributes( element, &attr_map );
2964     ok( r == S_OK, "returns %08x\n", r );
2965     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2966     ok( r == S_OK, "returns %08x\n", r );
2967     ok( num == 1, "num %d\n", num );
2968     IXMLDOMNamedNodeMap_Release( attr_map );
2969     VariantClear(&var);
2970     r = IXMLDOMElement_getAttribute( element, name, &var );
2971     ok( r == S_OK, "returns %08x\n", r );
2972     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
2973     VariantClear(&var);
2974     SysFreeString(name);
2975
2976     V_VT(&var) = VT_BSTR;
2977     V_BSTR(&var) = SysAllocString( szstr1 );
2978     name = SysAllocString( szlc );
2979     r = IXMLDOMElement_setAttribute( element, name, var );
2980     ok( r == S_OK, "returns %08x\n", r );
2981     r = IXMLDOMElement_get_attributes( element, &attr_map );
2982     ok( r == S_OK, "returns %08x\n", r );
2983     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2984     ok( r == S_OK, "returns %08x\n", r );
2985     ok( num == 2, "num %d\n", num );
2986     IXMLDOMNamedNodeMap_Release( attr_map );
2987     VariantClear(&var);
2988     SysFreeString(name);
2989
2990     V_VT(&var) = VT_I4;
2991     V_I4(&var) = 10;
2992     name = SysAllocString( szbs );
2993     r = IXMLDOMElement_setAttribute( element, name, var );
2994     ok( r == S_OK, "returns %08x\n", r );
2995     VariantClear(&var);
2996     r = IXMLDOMElement_getAttribute( element, name, &var );
2997     ok( r == S_OK, "returns %08x\n", r );
2998     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
2999     VariantClear(&var);
3000     SysFreeString(name);
3001
3002     /* Create an Attribute */
3003     V_VT(&var) = VT_I4;
3004     V_I4(&var) = NODE_ATTRIBUTE;
3005     str = SysAllocString( szAttribute );
3006     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3007     ok( r == S_OK, "returns %08x\n", r );
3008     ok( node != NULL, "node was null\n");
3009     SysFreeString(str);
3010
3011     IXMLDOMElement_Release( element );
3012     IXMLDOMNode_Release( root );
3013     IXMLDOMDocument_Release( doc );
3014 }
3015
3016 struct queryresult_t {
3017     const char *query;
3018     const char *result;
3019     int len;
3020 };
3021
3022 static const struct queryresult_t elementsbytagname[] = {
3023     { "",    "P1.D1 E2.D1 E1.E2.D1 T1.E1.E2.D1 E2.E2.D1 T1.E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1 T1.E1.E4.E2.D1", 10 },
3024     { "*",   "E2.D1 E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1", 6 },
3025     { "bs",  "E1.E2.D1", 1 },
3026     { "dl",  "", 0 },
3027     { "str1","", 0 },
3028     { NULL }
3029 };
3030
3031 static void test_getElementsByTagName(void)
3032 {
3033     const struct queryresult_t *ptr = elementsbytagname;
3034     IXMLDOMNodeList *node_list;
3035     IXMLDOMDocument *doc;
3036     IXMLDOMElement *elem;
3037     WCHAR buff[100];
3038     VARIANT_BOOL b;
3039     HRESULT r;
3040     LONG len;
3041     BSTR str;
3042
3043     doc = create_document(&IID_IXMLDOMDocument);
3044
3045     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3046     ok( r == S_OK, "loadXML failed\n");
3047     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3048
3049     /* null arguments cases */
3050     r = IXMLDOMDocument_getElementsByTagName(doc, NULL, &node_list);
3051     ok( r == E_INVALIDARG, "ret %08x\n", r );
3052     r = IXMLDOMDocument_getElementsByTagName(doc, _bstr_("*"), NULL);
3053     ok( r == E_INVALIDARG, "ret %08x\n", r );
3054
3055     while (ptr->query)
3056     {
3057         r = IXMLDOMDocument_getElementsByTagName(doc, _bstr_(ptr->query), &node_list);
3058         ok(r == S_OK, "ret %08x\n", r);
3059         r = IXMLDOMNodeList_get_length(node_list, &len);
3060         ok(r == S_OK, "ret %08x\n", r);
3061         ok(len == ptr->len, "%s: got len %d, expected %d\n", ptr->query, len, ptr->len);
3062         expect_list_and_release(node_list, ptr->result);
3063
3064         free_bstrs();
3065         ptr++;
3066     }
3067
3068     /* broken query BSTR */
3069     memcpy(&buff[2], szstar, sizeof(szstar));
3070     /* just a big length */
3071     *(DWORD*)buff = 0xf0f0;
3072     r = IXMLDOMDocument_getElementsByTagName(doc, &buff[2], &node_list);
3073     ok( r == S_OK, "ret %08x\n", r );
3074     r = IXMLDOMNodeList_get_length( node_list, &len );
3075     ok( r == S_OK, "ret %08x\n", r );
3076     ok( len == 6, "len %d\n", len );
3077     IXMLDOMNodeList_Release( node_list );
3078
3079     /* test for element */
3080     r = IXMLDOMDocument_get_documentElement(doc, &elem);
3081     ok( r == S_OK, "ret %08x\n", r );
3082
3083     str = SysAllocString( szstar );
3084
3085     /* null arguments cases */
3086     r = IXMLDOMElement_getElementsByTagName(elem, NULL, &node_list);
3087     ok( r == E_INVALIDARG, "ret %08x\n", r );
3088     r = IXMLDOMElement_getElementsByTagName(elem, str, NULL);
3089     ok( r == E_INVALIDARG, "ret %08x\n", r );
3090
3091     r = IXMLDOMElement_getElementsByTagName(elem, str, &node_list);
3092     ok( r == S_OK, "ret %08x\n", r );
3093     r = IXMLDOMNodeList_get_length( node_list, &len );
3094     ok( r == S_OK, "ret %08x\n", r );
3095     ok( len == 5, "len %d\n", len );
3096     expect_list_and_release(node_list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1");
3097     SysFreeString( str );
3098
3099     /* broken query BSTR */
3100     memcpy(&buff[2], szstar, sizeof(szstar));
3101     /* just a big length */
3102     *(DWORD*)buff = 0xf0f0;
3103     r = IXMLDOMElement_getElementsByTagName(elem, &buff[2], &node_list);
3104     ok( r == S_OK, "ret %08x\n", r );
3105     r = IXMLDOMNodeList_get_length( node_list, &len );
3106     ok( r == S_OK, "ret %08x\n", r );
3107     ok( len == 5, "len %d\n", len );
3108     IXMLDOMNodeList_Release( node_list );
3109
3110     IXMLDOMElement_Release(elem);
3111
3112     IXMLDOMDocument_Release( doc );
3113
3114     free_bstrs();
3115 }
3116
3117 static void test_get_text(void)
3118 {
3119     HRESULT r;
3120     BSTR str;
3121     VARIANT_BOOL b;
3122     IXMLDOMDocument *doc;
3123     IXMLDOMNode *node, *node2, *node3;
3124     IXMLDOMNode *nodeRoot;
3125     IXMLDOMNodeList *node_list;
3126     IXMLDOMNamedNodeMap *node_map;
3127     LONG len;
3128
3129     doc = create_document(&IID_IXMLDOMDocument);
3130
3131     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3132     ok( r == S_OK, "loadXML failed\n");
3133     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3134
3135     str = SysAllocString( szbs );
3136     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
3137     ok( r == S_OK, "ret %08x\n", r );
3138     SysFreeString(str);
3139
3140     /* Test to get all child node text. */
3141     r = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&nodeRoot);
3142     ok( r == S_OK, "ret %08x\n", r );
3143     if(r == S_OK)
3144     {
3145         r = IXMLDOMNode_get_text( nodeRoot, &str );
3146         ok( r == S_OK, "ret %08x\n", r );
3147         ok( compareIgnoreReturns(str, _bstr_("fn1.txt\n\n fn2.txt \n\nf1\n")), "wrong get_text: %s\n", wine_dbgstr_w(str));
3148         SysFreeString(str);
3149
3150         IXMLDOMNode_Release(nodeRoot);
3151     }
3152
3153     r = IXMLDOMNodeList_get_length( node_list, NULL );
3154     ok( r == E_INVALIDARG, "ret %08x\n", r );
3155
3156     r = IXMLDOMNodeList_get_length( node_list, &len );
3157     ok( r == S_OK, "ret %08x\n", r );
3158     ok( len == 1, "expect 1 got %d\n", len );
3159
3160     r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
3161     ok( r == E_INVALIDARG, "ret %08x\n", r );
3162
3163     r = IXMLDOMNodeList_nextNode( node_list, NULL );
3164     ok( r == E_INVALIDARG, "ret %08x\n", r );
3165
3166     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
3167     ok( r == S_OK, "ret %08x\n", r );
3168     IXMLDOMNodeList_Release( node_list );
3169
3170     /* Invalid output parameter*/
3171     r = IXMLDOMNode_get_text( node, NULL );
3172     ok( r == E_INVALIDARG, "ret %08x\n", r );
3173
3174     r = IXMLDOMNode_get_text( node, &str );
3175     ok( r == S_OK, "ret %08x\n", r );
3176     ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
3177     SysFreeString(str);
3178
3179     r = IXMLDOMNode_get_attributes( node, &node_map );
3180     ok( r == S_OK, "ret %08x\n", r );
3181
3182     str = SysAllocString( szvr );
3183     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
3184     ok( r == S_OK, "ret %08x\n", r );
3185     SysFreeString(str);
3186
3187     r = IXMLDOMNode_get_text( node2, &str );
3188     ok( r == S_OK, "ret %08x\n", r );
3189     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3190     SysFreeString(str);
3191
3192     r = IXMLDOMNode_get_firstChild( node2, &node3 );
3193     ok( r == S_OK, "ret %08x\n", r );
3194
3195     r = IXMLDOMNode_get_text( node3, &str );
3196     ok( r == S_OK, "ret %08x\n", r );
3197     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3198     SysFreeString(str);
3199
3200
3201     IXMLDOMNode_Release( node3 );
3202     IXMLDOMNode_Release( node2 );
3203     IXMLDOMNamedNodeMap_Release( node_map );
3204     IXMLDOMNode_Release( node );
3205     IXMLDOMDocument_Release( doc );
3206
3207     free_bstrs();
3208 }
3209
3210 static void test_get_childNodes(void)
3211 {
3212     IXMLDOMNodeList *node_list, *node_list2;
3213     IEnumVARIANT *enum1, *enum2, *enum3;
3214     VARIANT_BOOL b;
3215     IXMLDOMDocument *doc;
3216     IXMLDOMNode *node, *node2;
3217     IXMLDOMElement *element;
3218     IUnknown *unk1, *unk2;
3219     HRESULT hr;
3220     VARIANT v;
3221     BSTR str;
3222     LONG len;
3223
3224     doc = create_document(&IID_IXMLDOMDocument);
3225
3226     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3227     EXPECT_HR(hr, S_OK);
3228     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3229
3230     hr = IXMLDOMDocument_get_documentElement( doc, &element );
3231     EXPECT_HR(hr, S_OK);
3232
3233     hr = IXMLDOMElement_get_childNodes( element, &node_list );
3234     EXPECT_HR(hr, S_OK);
3235
3236     hr = IXMLDOMNodeList_get_length( node_list, &len );
3237     EXPECT_HR(hr, S_OK);
3238     ok( len == 4, "len %d\n", len);
3239
3240     /* refcount tests for IEnumVARIANT support */
3241     EXPECT_REF(node_list, 1);
3242     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum1);
3243     EXPECT_HR(hr, S_OK);
3244     EXPECT_REF(node_list, 1);
3245     EXPECT_REF(enum1, 2);
3246
3247     EXPECT_REF(node_list, 1);
3248     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum2);
3249     EXPECT_HR(hr, S_OK);
3250     EXPECT_REF(node_list, 1);
3251     ok(enum2 == enum1, "got %p, %p\n", enum2, enum1);
3252     IEnumVARIANT_Release(enum2);
3253
3254     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
3255     EXPECT_HR(hr, S_OK);
3256     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
3257     EXPECT_HR(hr, S_OK);
3258     EXPECT_REF(node_list, 3);
3259     EXPECT_REF(enum1, 2);
3260     ok(unk1 == unk2, "got %p, %p\n", unk1, unk2);
3261     IUnknown_Release(unk1);
3262     IUnknown_Release(unk2);
3263
3264     EXPECT_REF(node_list, 1);
3265     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum2);
3266     EXPECT_HR(hr, S_OK);
3267     EXPECT_REF(node_list, 2);
3268     EXPECT_REF(enum2, 1);
3269     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
3270
3271     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
3272     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
3273     EXPECT_HR(hr, S_OK);
3274     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
3275     EXPECT_HR(hr, S_OK);
3276     EXPECT_REF(node_list, 3);
3277     EXPECT_REF(enum2, 2);
3278     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
3279     IUnknown_Release(unk1);
3280     IUnknown_Release(unk2);
3281
3282     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum3);
3283     EXPECT_HR(hr, S_OK);
3284     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
3285     IEnumVARIANT_Release(enum3);
3286     IEnumVARIANT_Release(enum2);
3287
3288     /* iteration tests */
3289     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
3290     EXPECT_HR(hr, S_OK);
3291     hr = IXMLDOMNode_get_nodeName(node, &str);
3292     EXPECT_HR(hr, S_OK);
3293     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
3294     SysFreeString(str);
3295     IXMLDOMNode_Release(node);
3296
3297     hr = IXMLDOMNodeList_nextNode(node_list, &node);
3298     EXPECT_HR(hr, S_OK);
3299     hr = IXMLDOMNode_get_nodeName(node, &str);
3300     EXPECT_HR(hr, S_OK);
3301     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
3302     SysFreeString(str);
3303     IXMLDOMNode_Release(node);
3304
3305     V_VT(&v) = VT_EMPTY;
3306     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
3307     EXPECT_HR(hr, S_OK);
3308     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
3309     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
3310     EXPECT_HR(hr, S_OK);
3311     hr = IXMLDOMNode_get_nodeName(node, &str);
3312     EXPECT_HR(hr, S_OK);
3313     ok(!lstrcmpW(str, _bstr_("bs")), "got node name %s\n", wine_dbgstr_w(str));
3314     SysFreeString(str);
3315     IXMLDOMNode_Release(node);
3316     VariantClear(&v);
3317
3318     hr = IXMLDOMNodeList_nextNode(node_list, &node);
3319     EXPECT_HR(hr, S_OK);
3320     hr = IXMLDOMNode_get_nodeName(node, &str);
3321     EXPECT_HR(hr, S_OK);
3322     ok(!lstrcmpW(str, _bstr_("pr")), "got %s\n", wine_dbgstr_w(str));
3323     SysFreeString(str);
3324     IXMLDOMNode_Release(node);
3325
3326     IEnumVARIANT_Release(enum1);
3327
3328     hr = IXMLDOMNodeList_get_item( node_list, 2, &node );
3329     EXPECT_HR(hr, S_OK);
3330
3331     hr = IXMLDOMNode_get_childNodes( node, &node_list2 );
3332     EXPECT_HR(hr, S_OK);
3333
3334     hr = IXMLDOMNodeList_get_length( node_list2, &len );
3335     EXPECT_HR(hr, S_OK);
3336     ok( len == 0, "len %d\n", len);
3337
3338     hr = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
3339     EXPECT_HR(hr, S_FALSE);
3340
3341     IXMLDOMNodeList_Release( node_list2 );
3342     IXMLDOMNode_Release( node );
3343     IXMLDOMNodeList_Release( node_list );
3344     IXMLDOMElement_Release( element );
3345
3346     /* test for children of <?xml ..?> node */
3347     hr = IXMLDOMDocument_get_firstChild(doc, &node);
3348     EXPECT_HR(hr, S_OK);
3349
3350     str = NULL;
3351     hr = IXMLDOMNode_get_nodeName(node, &str);
3352     EXPECT_HR(hr, S_OK);
3353     ok(!lstrcmpW(str, _bstr_("xml")), "got %s\n", wine_dbgstr_w(str));
3354     SysFreeString(str);
3355
3356     /* it returns empty but valid node list */
3357     node_list = (void*)0xdeadbeef;
3358     hr = IXMLDOMNode_get_childNodes(node, &node_list);
3359     EXPECT_HR(hr, S_OK);
3360
3361     len = -1;
3362     hr = IXMLDOMNodeList_get_length(node_list, &len);
3363     EXPECT_HR(hr, S_OK);
3364     ok(len == 0, "got %d\n", len);
3365
3366     IXMLDOMNodeList_Release( node_list );
3367     IXMLDOMNode_Release(node);
3368
3369     IXMLDOMDocument_Release( doc );
3370     free_bstrs();
3371 }
3372
3373 static void test_get_firstChild(void)
3374 {
3375     static const WCHAR xmlW[] = {'x','m','l',0};
3376     IXMLDOMDocument *doc;
3377     IXMLDOMNode *node;
3378     VARIANT_BOOL b;
3379     HRESULT r;
3380     BSTR str;
3381
3382     doc = create_document(&IID_IXMLDOMDocument);
3383
3384     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3385     ok( r == S_OK, "loadXML failed\n");
3386     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3387
3388     r = IXMLDOMDocument_get_firstChild( doc, &node );
3389     ok( r == S_OK, "ret %08x\n", r);
3390
3391     r = IXMLDOMNode_get_nodeName( node, &str );
3392     ok( r == S_OK, "ret %08x\n", r);
3393
3394     ok(!lstrcmpW(str, xmlW), "expected \"xml\" node name, got %s\n", wine_dbgstr_w(str));
3395
3396     SysFreeString(str);
3397     IXMLDOMNode_Release( node );
3398     IXMLDOMDocument_Release( doc );
3399
3400     free_bstrs();
3401 }
3402
3403 static void test_get_lastChild(void)
3404 {
3405     static const WCHAR lcW[] = {'l','c',0};
3406     static const WCHAR foW[] = {'f','o',0};
3407     IXMLDOMDocument *doc;
3408     IXMLDOMNode *node, *child;
3409     VARIANT_BOOL b;
3410     HRESULT r;
3411     BSTR str;
3412
3413     doc = create_document(&IID_IXMLDOMDocument);
3414
3415     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3416     ok( r == S_OK, "loadXML failed\n");
3417     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3418
3419     r = IXMLDOMDocument_get_lastChild( doc, &node );
3420     ok( r == S_OK, "ret %08x\n", r);
3421
3422     r = IXMLDOMNode_get_nodeName( node, &str );
3423     ok( r == S_OK, "ret %08x\n", r);
3424
3425     ok(memcmp(str, lcW, sizeof(lcW)) == 0, "expected \"lc\" node name\n");
3426     SysFreeString(str);
3427
3428     r = IXMLDOMNode_get_lastChild( node, &child );
3429     ok( r == S_OK, "ret %08x\n", r);
3430
3431     r = IXMLDOMNode_get_nodeName( child, &str );
3432     ok( r == S_OK, "ret %08x\n", r);
3433
3434     ok(memcmp(str, foW, sizeof(foW)) == 0, "expected \"fo\" node name\n");
3435     SysFreeString(str);
3436
3437     IXMLDOMNode_Release( child );
3438     IXMLDOMNode_Release( node );
3439     IXMLDOMDocument_Release( doc );
3440
3441     free_bstrs();
3442 }
3443
3444 static void test_removeChild(void)
3445 {
3446     HRESULT r;
3447     VARIANT_BOOL b;
3448     IXMLDOMDocument *doc;
3449     IXMLDOMElement *element, *lc_element;
3450     IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
3451     IXMLDOMNodeList *root_list, *fo_list;
3452
3453     doc = create_document(&IID_IXMLDOMDocument);
3454
3455     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3456     ok( r == S_OK, "loadXML failed\n");
3457     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3458
3459     r = IXMLDOMDocument_get_documentElement( doc, &element );
3460     ok( r == S_OK, "ret %08x\n", r);
3461     todo_wine EXPECT_REF(element, 2);
3462
3463     r = IXMLDOMElement_get_childNodes( element, &root_list );
3464     ok( r == S_OK, "ret %08x\n", r);
3465     EXPECT_REF(root_list, 1);
3466
3467     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3468     ok( r == S_OK, "ret %08x\n", r);
3469     EXPECT_REF(fo_node, 1);
3470
3471     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3472     ok( r == S_OK, "ret %08x\n", r);
3473     EXPECT_REF(fo_list, 1);
3474
3475     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3476     ok( r == S_OK, "ret %08x\n", r);
3477     EXPECT_REF(ba_node, 1);
3478
3479     /* invalid parameter: NULL ptr */
3480     removed_node = (void*)0xdeadbeef;
3481     r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
3482     ok( r == E_INVALIDARG, "ret %08x\n", r );
3483     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3484
3485     /* ba_node is a descendant of element, but not a direct child. */
3486     removed_node = (void*)0xdeadbeef;
3487     EXPECT_REF(ba_node, 1);
3488     EXPECT_CHILDREN(fo_node);
3489     r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
3490     ok( r == E_INVALIDARG, "ret %08x\n", r );
3491     ok( removed_node == NULL, "%p\n", removed_node );
3492     EXPECT_REF(ba_node, 1);
3493     EXPECT_CHILDREN(fo_node);
3494
3495     EXPECT_REF(ba_node, 1);
3496     EXPECT_REF(fo_node, 1);
3497     r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
3498     ok( r == S_OK, "ret %08x\n", r);
3499     ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
3500     EXPECT_REF(fo_node, 2);
3501     EXPECT_REF(ba_node, 1);
3502
3503     /* try removing already removed child */
3504     temp_node = (void*)0xdeadbeef;
3505     r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
3506     ok( r == E_INVALIDARG, "ret %08x\n", r);
3507     ok( temp_node == NULL, "%p\n", temp_node );
3508     IXMLDOMNode_Release( fo_node );
3509
3510     /* the removed node has no parent anymore */
3511     r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
3512     ok( r == S_FALSE, "ret %08x\n", r);
3513     ok( temp_node == NULL, "%p\n", temp_node );
3514
3515     IXMLDOMNode_Release( removed_node );
3516     IXMLDOMNode_Release( ba_node );
3517     IXMLDOMNodeList_Release( fo_list );
3518
3519     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3520     ok( r == S_OK, "ret %08x\n", r);
3521
3522     r = IXMLDOMNode_QueryInterface( lc_node, &IID_IXMLDOMElement, (void**)&lc_element );
3523     ok( r == S_OK, "ret %08x\n", r);
3524
3525     /* MS quirk: passing wrong interface pointer works, too */
3526     r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
3527     ok( r == S_OK, "ret %08x\n", r);
3528     IXMLDOMElement_Release( lc_element );
3529
3530     temp_node = (void*)0xdeadbeef;
3531     r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
3532     ok( r == S_FALSE, "ret %08x\n", r);
3533     ok( temp_node == NULL, "%p\n", temp_node );
3534
3535     IXMLDOMNode_Release( lc_node );
3536     IXMLDOMNodeList_Release( root_list );
3537     IXMLDOMElement_Release( element );
3538     IXMLDOMDocument_Release( doc );
3539
3540     free_bstrs();
3541 }
3542
3543 static void test_replaceChild(void)
3544 {
3545     HRESULT r;
3546     VARIANT_BOOL b;
3547     IXMLDOMDocument *doc;
3548     IXMLDOMElement *element, *ba_element;
3549     IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
3550     IXMLDOMNodeList *root_list, *fo_list;
3551     IUnknown * unk1, *unk2;
3552     LONG len;
3553
3554     doc = create_document(&IID_IXMLDOMDocument);
3555
3556     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3557     ok( r == S_OK, "loadXML failed\n");
3558     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3559
3560     r = IXMLDOMDocument_get_documentElement( doc, &element );
3561     ok( r == S_OK, "ret %08x\n", r);
3562
3563     r = IXMLDOMElement_get_childNodes( element, &root_list );
3564     ok( r == S_OK, "ret %08x\n", r);
3565
3566     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3567     ok( r == S_OK, "ret %08x\n", r);
3568
3569     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3570     ok( r == S_OK, "ret %08x\n", r);
3571
3572     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3573     ok( r == S_OK, "ret %08x\n", r);
3574
3575     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3576     ok( r == S_OK, "ret %08x\n", r);
3577
3578     IXMLDOMNodeList_Release( fo_list );
3579
3580     /* invalid parameter: NULL ptr for element to remove */
3581     removed_node = (void*)0xdeadbeef;
3582     r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
3583     ok( r == E_INVALIDARG, "ret %08x\n", r );
3584     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3585
3586     /* invalid parameter: NULL for replacement element. (Sic!) */
3587     removed_node = (void*)0xdeadbeef;
3588     r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
3589     ok( r == E_INVALIDARG, "ret %08x\n", r );
3590     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3591
3592     /* invalid parameter: OldNode is not a child */
3593     removed_node = (void*)0xdeadbeef;
3594     r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
3595     ok( r == E_INVALIDARG, "ret %08x\n", r );
3596     ok( removed_node == NULL, "%p\n", removed_node );
3597     IXMLDOMNode_Release( lc_node );
3598
3599     /* invalid parameter: would create loop */
3600     removed_node = (void*)0xdeadbeef;
3601     r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
3602     ok( r == E_FAIL, "ret %08x\n", r );
3603     ok( removed_node == NULL, "%p\n", removed_node );
3604
3605     r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
3606     ok( r == S_OK, "ret %08x\n", r );
3607
3608     r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
3609     ok( r == S_OK, "ret %08x\n", r );
3610
3611     /* ba_node and temp_node refer to the same node, yet they
3612        are different interface pointers */
3613     ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
3614     r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
3615     ok( r == S_OK, "ret %08x\n", r );
3616     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
3617     ok( r == S_OK, "ret %08x\n", r );
3618     todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
3619
3620     IUnknown_Release( unk1 );
3621     IUnknown_Release( unk2 );
3622
3623     /* ba_node should have been removed from below fo_node */
3624     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3625     ok( r == S_OK, "ret %08x\n", r );
3626
3627     /* MS quirk: replaceChild also accepts elements instead of nodes */
3628     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
3629     ok( r == S_OK, "ret %08x\n", r );
3630     EXPECT_REF(ba_element, 2);
3631
3632     removed_node = NULL;
3633     r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
3634     ok( r == S_OK, "ret %08x\n", r );
3635     ok( removed_node != NULL, "got %p\n", removed_node);
3636     EXPECT_REF(ba_element, 3);
3637     IXMLDOMElement_Release( ba_element );
3638
3639     r = IXMLDOMNodeList_get_length( fo_list, &len);
3640     ok( r == S_OK, "ret %08x\n", r );
3641     ok( len == 0, "len %d\n", len);
3642
3643     IXMLDOMNodeList_Release( fo_list );
3644
3645     IXMLDOMNode_Release(ba_node);
3646     IXMLDOMNode_Release(fo_node);
3647     IXMLDOMNode_Release(temp_node);
3648     IXMLDOMNodeList_Release( root_list );
3649     IXMLDOMElement_Release( element );
3650     IXMLDOMDocument_Release( doc );
3651
3652     free_bstrs();
3653 }
3654
3655 static void test_removeNamedItem(void)
3656 {
3657     IXMLDOMDocument *doc;
3658     IXMLDOMElement *element;
3659     IXMLDOMNode *pr_node, *removed_node, *removed_node2;
3660     IXMLDOMNodeList *root_list;
3661     IXMLDOMNamedNodeMap * pr_attrs;
3662     VARIANT_BOOL b;
3663     BSTR str;
3664     LONG len;
3665     HRESULT r;
3666
3667     doc = create_document(&IID_IXMLDOMDocument);
3668
3669     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3670     ok( r == S_OK, "loadXML failed\n");
3671     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3672
3673     r = IXMLDOMDocument_get_documentElement( doc, &element );
3674     ok( r == S_OK, "ret %08x\n", r);
3675
3676     r = IXMLDOMElement_get_childNodes( element, &root_list );
3677     ok( r == S_OK, "ret %08x\n", r);
3678
3679     r = IXMLDOMNodeList_get_item( root_list, 1, &pr_node );
3680     ok( r == S_OK, "ret %08x\n", r);
3681
3682     r = IXMLDOMNode_get_attributes( pr_node, &pr_attrs );
3683     ok( r == S_OK, "ret %08x\n", r);
3684
3685     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3686     ok( r == S_OK, "ret %08x\n", r);
3687     ok( len == 3, "length %d\n", len);
3688
3689     removed_node = (void*)0xdeadbeef;
3690     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, NULL, &removed_node);
3691     ok ( r == E_INVALIDARG, "ret %08x\n", r);
3692     ok ( removed_node == (void*)0xdeadbeef, "got %p\n", removed_node);
3693
3694     removed_node = (void*)0xdeadbeef;
3695     str = SysAllocString(szvr);
3696     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node);
3697     ok ( r == S_OK, "ret %08x\n", r);
3698
3699     removed_node2 = (void*)0xdeadbeef;
3700     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node2);
3701     ok ( r == S_FALSE, "ret %08x\n", r);
3702     ok ( removed_node2 == NULL, "got %p\n", removed_node2 );
3703
3704     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3705     ok( r == S_OK, "ret %08x\n", r);
3706     ok( len == 2, "length %d\n", len);
3707
3708     r = IXMLDOMNamedNodeMap_setNamedItem( pr_attrs, removed_node, NULL);
3709     ok ( r == S_OK, "ret %08x\n", r);
3710     IXMLDOMNode_Release(removed_node);
3711
3712     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3713     ok( r == S_OK, "ret %08x\n", r);
3714     ok( len == 3, "length %d\n", len);
3715
3716     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
3717     ok ( r == S_OK, "ret %08x\n", r);
3718
3719     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3720     ok( r == S_OK, "ret %08x\n", r);
3721     ok( len == 2, "length %d\n", len);
3722
3723     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
3724     ok ( r == S_FALSE, "ret %08x\n", r);
3725
3726     SysFreeString(str);
3727
3728     IXMLDOMNamedNodeMap_Release( pr_attrs );
3729     IXMLDOMNode_Release( pr_node );
3730     IXMLDOMNodeList_Release( root_list );
3731     IXMLDOMElement_Release( element );
3732     IXMLDOMDocument_Release( doc );
3733
3734     free_bstrs();
3735 }
3736
3737 #define test_IObjectSafety_set(p, r, r2, s, m, e, e2) _test_IObjectSafety_set(__LINE__,p, r, r2, s, m, e, e2)
3738 static void _test_IObjectSafety_set(unsigned line, IObjectSafety *safety, HRESULT result,
3739                                     HRESULT result2, DWORD set, DWORD mask, DWORD expected,
3740                                     DWORD expected2)
3741 {
3742     DWORD enabled, supported;
3743     HRESULT hr;
3744
3745     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL, set, mask);
3746     if (result == result2)
3747         ok_(__FILE__,line)(hr == result, "SetInterfaceSafetyOptions: expected %08x, returned %08x\n", result, hr );
3748     else
3749         ok_(__FILE__,line)(broken(hr == result) || hr == result2,
3750            "SetInterfaceSafetyOptions: expected %08x, got %08x\n", result2, hr );
3751
3752     supported = enabled = 0xCAFECAFE;
3753     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3754     ok(hr == S_OK, "ret %08x\n", hr );
3755     if (expected == expected2)
3756         ok_(__FILE__,line)(enabled == expected, "Expected %08x, got %08x\n", expected, enabled);
3757     else
3758         ok_(__FILE__,line)(broken(enabled == expected) || enabled == expected2,
3759            "Expected %08x, got %08x\n", expected2, enabled);
3760
3761     /* reset the safety options */
3762
3763     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
3764             INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER,
3765             0);
3766     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3767
3768     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3769     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3770     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
3771 }
3772
3773 #define test_IObjectSafety_common(s) _test_IObjectSafety_common(__LINE__,s)
3774 static void _test_IObjectSafety_common(unsigned line, IObjectSafety *safety)
3775 {
3776     DWORD enabled = 0, supported = 0;
3777     HRESULT hr;
3778
3779     /* get */
3780     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, NULL, &enabled);
3781     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
3782     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, NULL);
3783     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
3784
3785     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3786     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3787     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
3788        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
3789         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
3790              "got %08x\n", supported);
3791     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
3792
3793     /* set -- individual flags */
3794
3795     test_IObjectSafety_set(safety, S_OK, S_OK,
3796         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3797         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER);
3798
3799     test_IObjectSafety_set(safety, S_OK, S_OK,
3800         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA,
3801         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA);
3802
3803     test_IObjectSafety_set(safety, S_OK, S_OK,
3804         INTERFACE_USES_SECURITY_MANAGER, INTERFACE_USES_SECURITY_MANAGER,
3805         0, INTERFACE_USES_SECURITY_MANAGER /* msxml3 SP8+ */);
3806
3807     /* set INTERFACE_USES_DISPEX  */
3808
3809     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
3810         INTERFACE_USES_DISPEX, INTERFACE_USES_DISPEX,
3811         0, 0);
3812
3813     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
3814         INTERFACE_USES_DISPEX, 0,
3815         0, 0);
3816
3817     test_IObjectSafety_set(safety, S_OK, S_OK /* msxml3 SP8+ */,
3818         0, INTERFACE_USES_DISPEX,
3819         0, 0);
3820
3821     /* set option masking */
3822
3823     test_IObjectSafety_set(safety, S_OK, S_OK,
3824         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
3825         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3826         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3827         INTERFACESAFE_FOR_UNTRUSTED_CALLER);
3828
3829     test_IObjectSafety_set(safety, S_OK, S_OK,
3830         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
3831         INTERFACESAFE_FOR_UNTRUSTED_DATA,
3832         INTERFACESAFE_FOR_UNTRUSTED_DATA,
3833         INTERFACESAFE_FOR_UNTRUSTED_DATA);
3834
3835     test_IObjectSafety_set(safety, S_OK, S_OK,
3836         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
3837         INTERFACE_USES_SECURITY_MANAGER,
3838         0,
3839         0);
3840
3841     /* set -- inheriting previous settings */
3842
3843     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
3844                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3845                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER);
3846     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3847     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3848     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3849     ok_(__FILE__,line)(enabled == INTERFACESAFE_FOR_UNTRUSTED_CALLER, "Expected INTERFACESAFE_FOR_UNTRUSTED_CALLER got %08x\n", enabled);
3850     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
3851        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
3852         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
3853              "got %08x\n", supported);
3854
3855     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
3856                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA,
3857                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA);
3858     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3859     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3860     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3861     ok_(__FILE__,line)(broken(enabled == INTERFACESAFE_FOR_UNTRUSTED_DATA) ||
3862                        enabled == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA),
3863                        "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA) got %08x\n", enabled);
3864     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
3865        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
3866         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
3867              "got %08x\n", supported);
3868 }
3869
3870 static void test_IXMLDOMDocument2(void)
3871 {
3872     static const WCHAR emptyW[] = {0};
3873     IXMLDOMDocument2 *doc2, *dtddoc2;
3874     IXMLDOMDocument *doc;
3875     IXMLDOMParseError* err;
3876     IDispatchEx *dispex;
3877     VARIANT_BOOL b;
3878     VARIANT var;
3879     HRESULT r;
3880     LONG res;
3881
3882     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
3883
3884     doc = create_document(&IID_IXMLDOMDocument);
3885     dtddoc2 = create_document(&IID_IXMLDOMDocument2);
3886
3887     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
3888     ok( r == S_OK, "ret %08x\n", r );
3889     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
3890
3891     ole_expect(IXMLDOMDocument2_get_readyState(doc2, NULL), E_INVALIDARG);
3892     ole_check(IXMLDOMDocument2_get_readyState(doc2, &res));
3893     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
3894
3895     err = NULL;
3896     ole_expect(IXMLDOMDocument2_validate(doc2, NULL), S_FALSE);
3897     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
3898     ok(err != NULL, "expected a pointer\n");
3899     if (err)
3900     {
3901         res = 0;
3902         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3903         /* XML_E_NOTWF */
3904         ok(res == E_XML_NOTWF, "got %08x\n", res);
3905         IXMLDOMParseError_Release(err);
3906     }
3907
3908     r = IXMLDOMDocument2_loadXML( doc2, _bstr_(complete4A), &b );
3909     ok( r == S_OK, "loadXML failed\n");
3910     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3911
3912     ole_check(IXMLDOMDocument_get_readyState(doc, &res));
3913     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
3914
3915     err = NULL;
3916     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
3917     ok(err != NULL, "expected a pointer\n");
3918     if (err)
3919     {
3920         res = 0;
3921         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3922         /* XML_E_NODTD */
3923         ok(res == E_XML_NODTD, "got %08x\n", res);
3924         IXMLDOMParseError_Release(err);
3925     }
3926
3927     r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
3928     ok( r == S_OK, "ret %08x\n", r );
3929     if(r == S_OK)
3930     {
3931         IDispatchEx_Release(dispex);
3932     }
3933
3934     /* we will check if the variant got cleared */
3935     IXMLDOMDocument2_AddRef(doc2);
3936     EXPECT_REF(doc2, 3); /* doc, doc2, AddRef*/
3937
3938     V_VT(&var) = VT_UNKNOWN;
3939     V_UNKNOWN(&var) = (IUnknown *)doc2;
3940
3941     /* invalid calls */
3942     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
3943     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
3944     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
3945
3946     /* valid call */
3947     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
3948     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
3949     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
3950     V_VT(&var) = VT_R4;
3951
3952     /* the variant didn't get cleared*/
3953     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
3954
3955     /* setProperty tests */
3956     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
3957     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
3958     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
3959     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
3960     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
3961     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
3962
3963     V_VT(&var) = VT_BSTR;
3964     V_BSTR(&var) = SysAllocString(emptyW);
3965     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
3966     ok(r == S_OK, "got 0x%08x\n", r);
3967     VariantClear(&var);
3968
3969     V_VT(&var) = VT_I2;
3970     V_I2(&var) = 0;
3971     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
3972     ok(r == E_FAIL, "got 0x%08x\n", r);
3973
3974     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
3975     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
3976     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
3977     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
3978
3979     IXMLDOMDocument2_Release( doc2 );
3980     IXMLDOMDocument_Release( doc );
3981
3982     /* DTD validation */
3983     ole_check(IXMLDOMDocument2_put_validateOnParse(dtddoc2, VARIANT_FALSE));
3984     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML), &b));
3985     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3986     err = NULL;
3987     ole_check(IXMLDOMDocument2_validate(dtddoc2, &err));
3988     ok(err != NULL, "expected pointer\n");
3989     if (err)
3990     {
3991         res = 0;
3992         ole_expect(IXMLDOMParseError_get_errorCode(err, &res), S_FALSE);
3993         ok(res == 0, "got %08x\n", res);
3994         IXMLDOMParseError_Release(err);
3995     }
3996
3997     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0D), &b));
3998     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3999     err = NULL;
4000     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4001     ok(err != NULL, "expected pointer\n");
4002     if (err)
4003     {
4004         res = 0;
4005         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4006         /* XML_ELEMENT_UNDECLARED */
4007         todo_wine ok(res == 0xC00CE00D, "got %08x\n", res);
4008         IXMLDOMParseError_Release(err);
4009     }
4010
4011     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0E), &b));
4012     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4013     err = NULL;
4014     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4015     ok(err != NULL, "expected pointer\n");
4016     if (err)
4017     {
4018         res = 0;
4019         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4020         /* XML_ELEMENT_ID_NOT_FOUND */
4021         todo_wine ok(res == 0xC00CE00E, "got %08x\n", res);
4022         IXMLDOMParseError_Release(err);
4023     }
4024
4025     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_11), &b));
4026     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4027     err = NULL;
4028     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4029     ok(err != NULL, "expected pointer\n");
4030     if (err)
4031     {
4032         res = 0;
4033         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4034         /* XML_EMPTY_NOT_ALLOWED */
4035         todo_wine ok(res == 0xC00CE011, "got %08x\n", res);
4036         IXMLDOMParseError_Release(err);
4037     }
4038
4039     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_13), &b));
4040     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4041     err = NULL;
4042     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4043     ok(err != NULL, "expected pointer\n");
4044     if (err)
4045     {
4046         res = 0;
4047         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4048         /* XML_ROOT_NAME_MISMATCH */
4049         todo_wine ok(res == 0xC00CE013, "got %08x\n", res);
4050         IXMLDOMParseError_Release(err);
4051     }
4052
4053     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_14), &b));
4054     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4055     err = NULL;
4056     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4057     ok(err != NULL, "expected pointer\n");
4058     if (err)
4059     {
4060         res = 0;
4061         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4062         /* XML_INVALID_CONTENT */
4063         todo_wine ok(res == 0xC00CE014, "got %08x\n", res);
4064         IXMLDOMParseError_Release(err);
4065     }
4066
4067     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_15), &b));
4068     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4069     err = NULL;
4070     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4071     ok(err != NULL, "expected pointer\n");
4072     if (err)
4073     {
4074         res = 0;
4075         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4076         /* XML_ATTRIBUTE_NOT_DEFINED */
4077         todo_wine ok(res == 0xC00CE015, "got %08x\n", res);
4078         IXMLDOMParseError_Release(err);
4079     }
4080
4081     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_16), &b));
4082     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4083     err = NULL;
4084     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4085     ok(err != NULL, "expected pointer\n");
4086     if (err)
4087     {
4088         res = 0;
4089         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4090         /* XML_ATTRIBUTE_FIXED */
4091         todo_wine ok(res == 0xC00CE016, "got %08x\n", res);
4092         IXMLDOMParseError_Release(err);
4093     }
4094
4095     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_17), &b));
4096     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4097     err = NULL;
4098     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4099     ok(err != NULL, "expected pointer\n");
4100     if (err)
4101     {
4102         res = 0;
4103         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4104         /* XML_ATTRIBUTE_VALUE */
4105         todo_wine ok(res == 0xC00CE017, "got %08x\n", res);
4106         IXMLDOMParseError_Release(err);
4107     }
4108
4109     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_18), &b));
4110     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4111     err = NULL;
4112     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4113     ok(err != NULL, "expected pointer\n");
4114     if (err)
4115     {
4116         res = 0;
4117         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4118         /* XML_ILLEGAL_TEXT */
4119         todo_wine ok(res == 0xC00CE018, "got %08x\n", res);
4120         IXMLDOMParseError_Release(err);
4121     }
4122
4123     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_20), &b));
4124     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4125     err = NULL;
4126     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4127     ok(err != NULL, "expected pointer\n");
4128     if (err)
4129     {
4130         res = 0;
4131         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4132         /* XML_REQUIRED_ATTRIBUTE_MISSING */
4133         todo_wine ok(res == 0xC00CE020, "got %08x\n", res);
4134         IXMLDOMParseError_Release(err);
4135     }
4136
4137     IXMLDOMDocument2_Release( dtddoc2 );
4138     free_bstrs();
4139 }
4140
4141 #define helper_ole_check(expr) { \
4142     HRESULT r = expr; \
4143     ok_(__FILE__, line)(r == S_OK, "=> %i: " #expr " returned %08x\n", __LINE__, r); \
4144 }
4145
4146 #define helper_expect_list_and_release(list, expstr) { \
4147     char *str = list_to_string(list); \
4148     ok_(__FILE__, line)(strcmp(str, expstr)==0, "=> %i: Invalid node list: %s, expected %s\n", __LINE__, str, expstr); \
4149     if (list) IXMLDOMNodeList_Release(list); \
4150 }
4151
4152 #define helper_expect_bstr_and_release(bstr, str) { \
4153     ok_(__FILE__, line)(lstrcmpW(bstr, _bstr_(str)) == 0, \
4154        "=> %i: got %s\n", __LINE__, wine_dbgstr_w(bstr)); \
4155     SysFreeString(bstr); \
4156 }
4157
4158 #define check_ws_ignored(doc, str) _check_ws_ignored(__LINE__, doc, str)
4159 static inline void _check_ws_ignored(int line, IXMLDOMDocument2* doc, char const* str)
4160 {
4161     IXMLDOMNode *node1, *node2;
4162     IXMLDOMNodeList *list;
4163     BSTR bstr;
4164
4165     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4166     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
4167     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
4168     helper_ole_check(IXMLDOMNodeList_reset(list));
4169     helper_expect_list_and_release(list, "E1.E5.E1.E2.D1 E2.E5.E1.E2.D1");
4170
4171     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
4172     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");
4173     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
4174     if (str)
4175     {
4176         helper_expect_bstr_and_release(bstr, str);
4177     }
4178     else
4179     {
4180         helper_expect_bstr_and_release(bstr, "This is a description.");
4181     }
4182     IXMLDOMNode_Release(node1);
4183
4184     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
4185     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");
4186     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
4187     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
4188     IXMLDOMNode_Release(node2);
4189 }
4190
4191 #define check_ws_preserved(doc, str) _check_ws_preserved(__LINE__, doc, str)
4192 static inline void _check_ws_preserved(int line, IXMLDOMDocument2* doc, char const* str)
4193 {
4194     IXMLDOMNode *node1, *node2;
4195     IXMLDOMNodeList *list;
4196     BSTR bstr;
4197
4198     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4199     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
4200     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
4201     helper_ole_check(IXMLDOMNodeList_reset(list));
4202     helper_expect_list_and_release(list, "E2.E10.E2.E2.D1 E4.E10.E2.E2.D1");
4203
4204     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
4205     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");
4206     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
4207     if (str)
4208     {
4209         helper_expect_bstr_and_release(bstr, str);
4210     }
4211     else
4212     {
4213         helper_expect_bstr_and_release(bstr, "\n                This is a description. \n            ");
4214     }
4215     IXMLDOMNode_Release(node1);
4216
4217     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
4218     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");
4219     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
4220     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
4221     IXMLDOMNode_Release(node2);
4222 }
4223
4224 static void test_preserve_charref(IXMLDOMDocument2 *doc, VARIANT_BOOL preserve)
4225 {
4226     static const WCHAR b1_p[] = {' ','T','e','x','t',' ','A',' ','e','n','d',' ',0};
4227     static const WCHAR b1_i[] = {'T','e','x','t',' ','A',' ','e','n','d',0};
4228     static const WCHAR b2_p[] = {'A','B',' ','C',' ',0};
4229     static const WCHAR b2_i[] = {'A','B',' ','C',0};
4230     IXMLDOMNodeList *list;
4231     IXMLDOMElement *root;
4232     IXMLDOMNode *node;
4233     const WCHAR *text;
4234     VARIANT_BOOL b;
4235     HRESULT hr;
4236     BSTR s;
4237
4238     hr = IXMLDOMDocument2_put_preserveWhiteSpace(doc, preserve);
4239     ok(hr == S_OK, "got 0x%08x\n", hr);
4240
4241     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(charrefsxml), &b);
4242     ok(hr == S_OK, "got 0x%08x\n", hr);
4243
4244     hr = IXMLDOMDocument2_get_documentElement(doc, &root);
4245     ok(hr == S_OK, "got 0x%08x\n", hr);
4246
4247     hr = IXMLDOMElement_get_childNodes(root, &list);
4248     ok(hr == S_OK, "got 0x%08x\n", hr);
4249     IXMLDOMElement_Release(root);
4250
4251     text = preserve == VARIANT_TRUE ? b1_p : b1_i;
4252     hr = IXMLDOMNodeList_get_item(list, 0, &node);
4253     ok(hr == S_OK, "got 0x%08x\n", hr);
4254     hr = IXMLDOMNode_get_text(node, &s);
4255     ok(hr == S_OK, "got 0x%08x\n", hr);
4256     ok(!lstrcmpW(s, text), "0x%x, got %s\n", preserve, wine_dbgstr_w(s));
4257     SysFreeString(s);
4258     IXMLDOMNode_Release(node);
4259
4260     text = preserve == VARIANT_TRUE ? b2_p : b2_i;
4261     hr = IXMLDOMNodeList_get_item(list, 1, &node);
4262     ok(hr == S_OK, "got 0x%08x\n", hr);
4263     hr = IXMLDOMNode_get_text(node, &s);
4264     ok(hr == S_OK, "got 0x%08x\n", hr);
4265     ok(!lstrcmpW(s, text), "0x%x, got %s\n", preserve, wine_dbgstr_w(s));
4266     SysFreeString(s);
4267     IXMLDOMNode_Release(node);
4268
4269     IXMLDOMNodeList_Release(list);
4270 }
4271
4272 static void test_whitespace(void)
4273 {
4274     IXMLDOMDocument2 *doc1, *doc2, *doc3, *doc4;
4275     IXMLDOMNodeList *list;
4276     IXMLDOMElement *root;
4277     VARIANT_BOOL b;
4278     HRESULT hr;
4279     LONG len;
4280
4281     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
4282     doc1 = create_document(&IID_IXMLDOMDocument2);
4283     doc2 = create_document(&IID_IXMLDOMDocument2);
4284
4285     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_TRUE));
4286     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4287     ok(b == VARIANT_FALSE, "expected false\n");
4288     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4289     ok(b == VARIANT_TRUE, "expected true\n");
4290
4291     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4292     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4293     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4294     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4295
4296     /* switch to XPath */
4297     ole_check(IXMLDOMDocument2_setProperty(doc1, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4298     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4299
4300     check_ws_ignored(doc1, NULL);
4301     check_ws_preserved(doc2, NULL);
4302
4303     /* new instances copy the property */
4304     ole_check(IXMLDOMDocument2_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**) &doc3));
4305     ole_check(IXMLDOMDocument2_QueryInterface(doc2, &IID_IXMLDOMDocument2, (void**) &doc4));
4306
4307     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4308     ok(b == VARIANT_FALSE, "expected false\n");
4309     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4310     ok(b == VARIANT_TRUE, "expected true\n");
4311
4312     check_ws_ignored(doc3, NULL);
4313     check_ws_preserved(doc4, NULL);
4314
4315     /* setting after loading xml affects trimming of leading/trailing ws only */
4316     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_TRUE));
4317     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_FALSE));
4318
4319     /* the trailing "\n            " isn't there, because it was ws-only node */
4320     check_ws_ignored(doc1, "\n                This is a description. ");
4321     check_ws_preserved(doc2, "This is a description.");
4322
4323     /* it takes effect on reload */
4324     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4325     ok(b == VARIANT_TRUE, "expected true\n");
4326     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4327     ok(b == VARIANT_FALSE, "expected false\n");
4328
4329     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4330     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4331     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4332     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4333
4334     check_ws_preserved(doc1, NULL);
4335     check_ws_ignored(doc2, NULL);
4336
4337     /* other instances follow suit */
4338     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4339     ok(b == VARIANT_TRUE, "expected true\n");
4340     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4341     ok(b == VARIANT_FALSE, "expected false\n");
4342
4343     check_ws_preserved(doc3, NULL);
4344     check_ws_ignored(doc4, NULL);
4345
4346     IXMLDOMDocument2_Release(doc2);
4347     IXMLDOMDocument2_Release(doc3);
4348     IXMLDOMDocument2_Release(doc4);
4349
4350     /* text with char references */
4351     test_preserve_charref(doc1, VARIANT_TRUE);
4352     test_preserve_charref(doc1, VARIANT_FALSE);
4353
4354     /* formatting whitespaces */
4355     hr = IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_FALSE);
4356     ok(hr == S_OK, "got 0x%08x\n", hr);
4357
4358     hr = IXMLDOMDocument2_loadXML(doc1, _bstr_(complete7), &b);
4359     ok(hr == S_OK, "got 0x%08x\n", hr);
4360     ok(b == VARIANT_TRUE, "for %x\n", b);
4361
4362     hr = IXMLDOMDocument2_get_documentElement(doc1, &root);
4363     ok(hr == S_OK, "got 0x%08x\n", hr);
4364     hr = IXMLDOMElement_get_childNodes(root, &list);
4365     ok(hr == S_OK, "got 0x%08x\n", hr);
4366     len = 0;
4367     hr = IXMLDOMNodeList_get_length(list, &len);
4368     ok(hr == S_OK, "got 0x%08x\n", hr);
4369     ok(len == 3, "got %d\n", len);
4370     IXMLDOMNodeList_Release(list);
4371     IXMLDOMElement_Release(root);
4372
4373     IXMLDOMDocument2_Release(doc1);
4374
4375     free_bstrs();
4376 }
4377
4378 typedef struct {
4379     const GUID *clsid;
4380     const char *name;
4381     const char *ns;
4382     HRESULT hr;
4383 } selection_ns_t;
4384
4385 /* supposed to be tested with szExampleXML */
4386 static const selection_ns_t selection_ns_data[] = {
4387     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4388     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4389     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4390     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4391
4392     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4393     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4394     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4395     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4396
4397     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4398     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4399     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4400     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4401
4402     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4403     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4404     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4405     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4406
4407     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4408     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4409     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4410     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4411
4412     { NULL }
4413 };
4414
4415 typedef struct {
4416     const char *query;
4417     const char *list;
4418 } xpath_test_t;
4419
4420 static const xpath_test_t xpath_test[] = {
4421     { "*/a", "E1.E1.E2.D1 E1.E2.E2.D1 E1.E4.E2.D1" },
4422     { "*/b", "E2.E1.E2.D1 E2.E2.E2.D1 E2.E4.E2.D1" },
4423     { "*/c", "E3.E1.E2.D1 E3.E2.E2.D1" },
4424     { "*/d", "E4.E1.E2.D1 E4.E2.E2.D1 E4.E4.E2.D1" },
4425     { "//a", "E1.E1.E2.D1 E1.E2.E2.D1 E1.E4.E2.D1" },
4426     { "//b", "E2.E1.E2.D1 E2.E2.E2.D1 E2.E4.E2.D1" },
4427     { "//c", "E3.E1.E2.D1 E3.E2.E2.D1" },
4428     { "//d", "E4.E1.E2.D1 E4.E2.E2.D1 E4.E4.E2.D1" },
4429     { "//c[@type]", "E3.E2.E2.D1" },
4430     { "//c[@type]/ancestor::node()[1]", "E2.E2.D1" },
4431     { "//c[@type]/ancestor-or-self::node()[1]", "E3.E2.E2.D1" },
4432     { "//c[@type]/attribute::node()[1]", "A'type'.E3.E2.E2.D1" },
4433     { "//c[@type]/child::node()[1]", "T1.E3.E2.E2.D1"  },
4434     { "//c[@type]/descendant::node()[1]", "T1.E3.E2.E2.D1" },
4435     { "//c[@type]/descendant-or-self::node()[1]", "E3.E2.E2.D1" },
4436     { "//c[@type]/following::node()[1]", "E4.E2.E2.D1" },
4437     { "//c[@type]/following-sibling::node()[1]", "E4.E2.E2.D1" },
4438     { "//c[@type]/parent::node()[1]", "E2.E2.D1" },
4439     { "//c[@type]/preceding::node()[1]", "T1.E2.E2.E2.D1" },
4440     { "//c[@type]/self::node()[1]", "E3.E2.E2.D1" },
4441     { "child::*", "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1" },
4442     { "child::node()", "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1" },
4443     { "child::text()", "" },
4444     { "child::*/..", "E2.D1" },
4445     { "child::*//@*/..", "E2.E5.E1.E2.D1 E2.E2.D1 E3.E2.E2.D1" },
4446     { "self::node()", "E2.D1" },
4447     { "ancestor::node()", "D1" },
4448     { "elem[c][last()]/a", "E1.E2.E2.D1"},
4449     { "ancestor-or-self::node()[1]", "E2.D1" },
4450     { "((//a)[1])[last()]", "E1.E1.E2.D1" },
4451     { "//elem[@*]", "E2.E2.D1" },
4452     { NULL }
4453 };
4454
4455 static void test_XPath(void)
4456 {
4457     const selection_ns_t *ptr = selection_ns_data;
4458     const xpath_test_t *xptest = xpath_test;
4459     VARIANT var;
4460     VARIANT_BOOL b;
4461     IXMLDOMDocument2 *doc;
4462     IXMLDOMDocument *doc2;
4463     IXMLDOMNode *rootNode;
4464     IXMLDOMNode *elem1Node;
4465     IXMLDOMNode *node;
4466     IXMLDOMNodeList *list;
4467     IXMLDOMElement *elem;
4468     IXMLDOMAttribute *attr;
4469     DOMNodeType type;
4470     HRESULT hr;
4471     LONG len;
4472     BSTR str;
4473
4474     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
4475     doc = create_document(&IID_IXMLDOMDocument2);
4476
4477     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4478     EXPECT_HR(hr, S_OK);
4479     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4480
4481     /* switch to XPath */
4482     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4483
4484     /* some simple queries*/
4485     EXPECT_REF(doc, 1);
4486     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4487     EXPECT_HR(hr, S_OK);
4488     EXPECT_REF(doc, 1);
4489     EXPECT_LIST_LEN(list, 1);
4490
4491     EXPECT_REF(list, 1);
4492     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4493     EXPECT_HR(hr, S_OK);
4494     EXPECT_REF(list, 1);
4495     EXPECT_REF(rootNode, 1);
4496
4497     hr = IXMLDOMNodeList_reset(list);
4498     EXPECT_HR(hr, S_OK);
4499     expect_list_and_release(list, "E2.D1");
4500
4501     /* peform xpath tests */
4502     for ( ; xptest->query ; xptest++ )
4503     {
4504         char *str;
4505
4506         hr = IXMLDOMNode_selectNodes(rootNode, _bstr_(xptest->query), &list);
4507         ok(hr == S_OK, "query evaluation failed for query=%s\n", xptest->query);
4508
4509         if (hr != S_OK)
4510             continue;
4511
4512         str = list_to_string(list);
4513
4514         ok(!strcmp(str, xptest->list), "query=%s, invalid node list: \"%s\", expected \"%s\"\n",
4515             xptest->query, str, xptest->list);
4516
4517         if (list)
4518             IXMLDOMNodeList_Release(list);
4519     }
4520
4521 if (0)
4522 {
4523     /* namespace:: axis test is disabled until namespace definitions
4524        are supported as attribute nodes, currently it's another node type */
4525     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("/root/namespace::*"), &list);
4526     EXPECT_HR(hr, S_OK);
4527     len = -1;
4528     hr = IXMLDOMNodeList_get_length(list, &len);
4529     EXPECT_HR(hr, S_OK);
4530     ok(len == 2, "got %d\n", len);
4531
4532     hr = IXMLDOMNodeList_nextNode(list, &node);
4533     EXPECT_HR(hr, S_OK);
4534     type = NODE_INVALID;
4535     hr = IXMLDOMNode_get_nodeType(node, &type);
4536     EXPECT_HR(hr, S_OK);
4537     ok(type == NODE_ATTRIBUTE, "got %d\n", type);
4538     IXMLDOMNode_Release(node);
4539
4540     IXMLDOMNodeList_Release(list);
4541 }
4542
4543     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//c"), &list));
4544     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
4545
4546     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//c[@type]"), &list));
4547     expect_list_and_release(list, "E3.E2.E2.D1");
4548
4549     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
4550     /* using get_item for query results advances the position */
4551     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
4552     expect_node(node, "E2.E2.D1");
4553     IXMLDOMNode_Release(node);
4554     ole_check(IXMLDOMNodeList_nextNode(list, &node));
4555     expect_node(node, "E4.E2.D1");
4556     IXMLDOMNode_Release(node);
4557     ole_check(IXMLDOMNodeList_reset(list));
4558     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
4559
4560     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
4561     expect_list_and_release(list, "E2.D1");
4562
4563     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
4564     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
4565     ole_check(IXMLDOMNodeList_reset(list));
4566     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
4567
4568     /* select an attribute */
4569     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
4570     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
4571
4572     /* would evaluate to a number */
4573     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
4574     /* would evaluate to a boolean */
4575     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
4576     /* would evaluate to a string */
4577     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
4578
4579     /* no results */
4580     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
4581     expect_list_and_release(list, "");
4582     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("elem//c"), &list));
4583     expect_list_and_release(list, "");
4584     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem[4]"), &list));
4585     expect_list_and_release(list, "");
4586     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[0]"), &list));
4587     expect_list_and_release(list, "");
4588
4589     /* foo undeclared in document node */
4590     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4591     /* undeclared in <root> node */
4592     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
4593     /* undeclared in <elem> node */
4594     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
4595     /* but this trick can be used */
4596     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
4597     expect_list_and_release(list, "E3.E4.E2.D1");
4598
4599     /* it has to be declared in SelectionNamespaces */
4600     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4601         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
4602
4603     /* now the namespace can be used */
4604     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list));
4605     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4606     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
4607     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4608     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
4609     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4610     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
4611     expect_list_and_release(list, "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1");
4612
4613     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
4614     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4615         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
4616
4617     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4618
4619     VariantInit(&var);
4620     ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
4621     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
4622     if (V_VT(&var) == VT_BSTR)
4623         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
4624
4625     /* extra attributes - same thing*/
4626     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4627         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
4628     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4629
4630     IXMLDOMNode_Release(rootNode);
4631     IXMLDOMNode_Release(elem1Node);
4632
4633     /* alter document with already built list */
4634     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4635     EXPECT_HR(hr, S_OK);
4636     EXPECT_LIST_LEN(list, 1);
4637
4638     hr = IXMLDOMDocument2_get_lastChild(doc, &rootNode);
4639     EXPECT_HR(hr, S_OK);
4640     EXPECT_REF(rootNode, 1);
4641     EXPECT_REF(doc, 1);
4642
4643     hr = IXMLDOMDocument2_removeChild(doc, rootNode, NULL);
4644     EXPECT_HR(hr, S_OK);
4645     IXMLDOMNode_Release(rootNode);
4646
4647     EXPECT_LIST_LEN(list, 1);
4648
4649     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4650     EXPECT_HR(hr, S_OK);
4651     EXPECT_REF(rootNode, 1);
4652
4653     IXMLDOMNodeList_Release(list);
4654
4655     hr = IXMLDOMNode_get_nodeName(rootNode, &str);
4656     EXPECT_HR(hr, S_OK);
4657     ok(!lstrcmpW(str, _bstr_("root")), "got %s\n", wine_dbgstr_w(str));
4658     SysFreeString(str);
4659     IXMLDOMNode_Release(rootNode);
4660
4661     /* alter node from list and get it another time */
4662     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4663     EXPECT_HR(hr, S_OK);
4664     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4665
4666     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4667     EXPECT_HR(hr, S_OK);
4668     EXPECT_LIST_LEN(list, 1);
4669
4670     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4671     EXPECT_HR(hr, S_OK);
4672
4673     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
4674     EXPECT_HR(hr, S_OK);
4675
4676     V_VT(&var) = VT_I2;
4677     V_I2(&var) = 1;
4678     hr = IXMLDOMElement_setAttribute(elem, _bstr_("attrtest"), var);
4679     EXPECT_HR(hr, S_OK);
4680     IXMLDOMElement_Release(elem);
4681     IXMLDOMNode_Release(rootNode);
4682
4683     /* now check attribute to be present */
4684     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4685     EXPECT_HR(hr, S_OK);
4686
4687     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
4688     EXPECT_HR(hr, S_OK);
4689
4690     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
4691     EXPECT_HR(hr, S_OK);
4692     IXMLDOMAttribute_Release(attr);
4693
4694     IXMLDOMElement_Release(elem);
4695     IXMLDOMNode_Release(rootNode);
4696
4697     /* and now check for attribute in original document */
4698     hr = IXMLDOMDocument2_get_documentElement(doc, &elem);
4699     EXPECT_HR(hr, S_OK);
4700
4701     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
4702     EXPECT_HR(hr, S_OK);
4703     IXMLDOMAttribute_Release(attr);
4704
4705     IXMLDOMElement_Release(elem);
4706
4707     /* attach node from list to another document */
4708     doc2 = create_document(&IID_IXMLDOMDocument);
4709
4710     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4711     EXPECT_HR(hr, S_OK);
4712     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4713
4714     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4715     EXPECT_HR(hr, S_OK);
4716     EXPECT_LIST_LEN(list, 1);
4717
4718     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4719     EXPECT_HR(hr, S_OK);
4720     EXPECT_REF(rootNode, 1);
4721
4722     hr = IXMLDOMDocument_appendChild(doc2, rootNode, NULL);
4723     EXPECT_HR(hr, S_OK);
4724     EXPECT_REF(rootNode, 1);
4725     EXPECT_REF(doc2, 1);
4726     EXPECT_REF(list, 1);
4727
4728     EXPECT_LIST_LEN(list, 1);
4729
4730     IXMLDOMNode_Release(rootNode);
4731     IXMLDOMNodeList_Release(list);
4732     IXMLDOMDocument_Release(doc2);
4733     IXMLDOMDocument2_Release(doc);
4734
4735     while (ptr->clsid)
4736     {
4737         if (is_clsid_supported(ptr->clsid, &IID_IXMLDOMDocument2))
4738         {
4739             hr = CoCreateInstance(ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
4740             ok(hr == S_OK, "got 0x%08x\n", hr);
4741         }
4742         else
4743         {
4744             ptr++;
4745             continue;
4746         }
4747
4748         hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4749         EXPECT_HR(hr, S_OK);
4750         ok(b == VARIANT_TRUE, "failed to load, %s\n", ptr->name);
4751
4752         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath"));
4753         EXPECT_HR(hr, S_OK);
4754
4755         V_VT(&var) = VT_BSTR;
4756         V_BSTR(&var) = _bstr_(ptr->ns);
4757
4758         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), var);
4759         ok(hr == ptr->hr, "got 0x%08x, for %s, %s\n", hr, ptr->name, ptr->ns);
4760
4761         V_VT(&var) = VT_EMPTY;
4762         hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var);
4763         EXPECT_HR(hr, S_OK);
4764         ok(V_VT(&var) == VT_BSTR, "got wrong property type %d\n", V_VT(&var));
4765         ok(!lstrcmpW(V_BSTR(&var), _bstr_(ptr->ns)), "got wrong value %s\n", wine_dbgstr_w(V_BSTR(&var)));
4766         VariantClear(&var);
4767
4768         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list);
4769         EXPECT_HR(hr, S_OK);
4770         if (hr == S_OK)
4771             expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4772
4773         IXMLDOMDocument2_Release(doc);
4774         ptr++;
4775         free_bstrs();
4776     }
4777
4778     free_bstrs();
4779 }
4780
4781 static void test_cloneNode(void )
4782 {
4783     IXMLDOMDocument *doc, *doc2;
4784     VARIANT_BOOL b;
4785     IXMLDOMNodeList *pList;
4786     IXMLDOMNamedNodeMap *mapAttr;
4787     LONG length, length1;
4788     LONG attr_cnt, attr_cnt1;
4789     IXMLDOMNode *node, *attr;
4790     IXMLDOMNode *node_clone;
4791     IXMLDOMNode *node_first;
4792     HRESULT hr;
4793
4794     doc = create_document(&IID_IXMLDOMDocument);
4795
4796     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b));
4797     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4798
4799     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc/pr"), &node);
4800     ok( hr == S_OK, "ret %08x\n", hr );
4801     ok( node != NULL, "node %p\n", node );
4802
4803     /* Check invalid parameter */
4804     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
4805     ok( hr == E_INVALIDARG, "ret %08x\n", hr );
4806
4807     /* All Children */
4808     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
4809     ok( hr == S_OK, "ret %08x\n", hr );
4810     ok( node_clone != NULL, "node %p\n", node );
4811
4812     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
4813     ok( hr == S_OK, "ret %08x\n", hr );
4814     hr = IXMLDOMNode_get_ownerDocument(node_clone, &doc2);
4815     ok( hr == S_OK, "ret %08x\n", hr );
4816     IXMLDOMDocument_Release(doc2);
4817     IXMLDOMNode_Release(node_first);
4818
4819     hr = IXMLDOMNode_get_childNodes(node, &pList);
4820     ok( hr == S_OK, "ret %08x\n", hr );
4821     length = 0;
4822     hr = IXMLDOMNodeList_get_length(pList, &length);
4823     ok( hr == S_OK, "ret %08x\n", hr );
4824     ok(length == 1, "got %d\n", length);
4825     IXMLDOMNodeList_Release(pList);
4826
4827     hr = IXMLDOMNode_get_attributes(node, &mapAttr);
4828     ok( hr == S_OK, "ret %08x\n", hr );
4829     attr_cnt = 0;
4830     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt);
4831     ok( hr == S_OK, "ret %08x\n", hr );
4832     ok(attr_cnt == 3, "got %d\n", attr_cnt);
4833     IXMLDOMNamedNodeMap_Release(mapAttr);
4834
4835     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
4836     ok( hr == S_OK, "ret %08x\n", hr );
4837     length1 = 0;
4838     hr = IXMLDOMNodeList_get_length(pList, &length1);
4839     ok(length1 == 1, "got %d\n", length1);
4840     ok( hr == S_OK, "ret %08x\n", hr );
4841     IXMLDOMNodeList_Release(pList);
4842
4843     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
4844     ok( hr == S_OK, "ret %08x\n", hr );
4845     attr_cnt1 = 0;
4846     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
4847     ok( hr == S_OK, "ret %08x\n", hr );
4848     ok(attr_cnt1 == 3, "got %d\n", attr_cnt1);
4849     /* now really get some attributes from cloned element */
4850     attr = NULL;
4851     hr = IXMLDOMNamedNodeMap_getNamedItem(mapAttr, _bstr_("id"), &attr);
4852     ok(hr == S_OK, "ret %08x\n", hr);
4853     IXMLDOMNode_Release(attr);
4854     IXMLDOMNamedNodeMap_Release(mapAttr);
4855
4856     ok(length == length1, "wrong Child count (%d, %d)\n", length, length1);
4857     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
4858     IXMLDOMNode_Release(node_clone);
4859
4860     /* No Children */
4861     hr = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
4862     ok( hr == S_OK, "ret %08x\n", hr );
4863     ok( node_clone != NULL, "node %p\n", node );
4864
4865     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
4866     ok(hr == S_FALSE, "ret %08x\n", hr );
4867
4868     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
4869     ok(hr == S_OK, "ret %08x\n", hr );
4870     hr = IXMLDOMNodeList_get_length(pList, &length1);
4871     ok(hr == S_OK, "ret %08x\n", hr );
4872     ok( length1 == 0, "Length should be 0 (%d)\n", length1);
4873     IXMLDOMNodeList_Release(pList);
4874
4875     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
4876     ok(hr == S_OK, "ret %08x\n", hr );
4877     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
4878     ok(hr == S_OK, "ret %08x\n", hr );
4879     ok(attr_cnt1 == 3, "Attribute count should be 3 (%d)\n", attr_cnt1);
4880     IXMLDOMNamedNodeMap_Release(mapAttr);
4881
4882     ok(length != length1, "wrong Child count (%d, %d)\n", length, length1);
4883     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
4884     IXMLDOMNode_Release(node_clone);
4885
4886     IXMLDOMNode_Release(node);
4887     IXMLDOMDocument_Release(doc);
4888     free_bstrs();
4889 }
4890
4891 static void test_xmlTypes(void)
4892 {
4893     IXMLDOMDocument *doc;
4894     IXMLDOMElement *pRoot;
4895     HRESULT hr;
4896     IXMLDOMComment *pComment;
4897     IXMLDOMElement *pElement;
4898     IXMLDOMAttribute *pAttribute;
4899     IXMLDOMNamedNodeMap *pAttribs;
4900     IXMLDOMCDATASection *pCDataSec;
4901     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
4902     IXMLDOMDocumentFragment *pDocFrag = NULL;
4903     IXMLDOMEntityReference *pEntityRef = NULL;
4904     BSTR str;
4905     IXMLDOMNode *pNextChild;
4906     VARIANT v;
4907     LONG len = 0;
4908
4909     doc = create_document(&IID_IXMLDOMDocument);
4910
4911     pNextChild = (void*)0xdeadbeef;
4912     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
4913     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4914
4915     pNextChild = (void*)0xdeadbeef;
4916     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
4917     ok(hr == S_FALSE, "ret %08x\n", hr );
4918     ok(pNextChild == NULL, "pDocChild not NULL\n");
4919
4920     /* test previous Sibling */
4921     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
4922     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4923
4924     pNextChild = (void*)0xdeadbeef;
4925     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
4926     ok(hr == S_FALSE, "ret %08x\n", hr );
4927     ok(pNextChild == NULL, "pNextChild not NULL\n");
4928
4929     /* test get_dataType */
4930     V_VT(&v) = VT_EMPTY;
4931     hr = IXMLDOMDocument_get_dataType(doc, &v);
4932     ok(hr == S_FALSE, "ret %08x\n", hr );
4933     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
4934     VariantClear(&v);
4935
4936     /* test implementation */
4937     hr = IXMLDOMDocument_get_implementation(doc, NULL);
4938     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4939
4940     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
4941     ok(hr == S_OK, "ret %08x\n", hr );
4942     if(hr == S_OK)
4943     {
4944         VARIANT_BOOL hasFeature = VARIANT_TRUE;
4945         BSTR sEmpty = SysAllocStringLen(NULL, 0);
4946
4947         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
4948         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4949
4950         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
4951         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4952
4953         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
4954         ok(hr == S_OK, "ret %08x\n", hr );
4955         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4956
4957         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
4958         ok(hr == S_OK, "ret %08x\n", hr );
4959         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
4960
4961         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
4962         ok(hr == S_OK, "ret %08x\n", hr );
4963         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
4964
4965         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
4966         ok(hr == S_OK, "ret %08x\n", hr );
4967         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4968
4969         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
4970         ok(hr == S_OK, "ret %08x\n", hr );
4971         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4972
4973         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _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_("MS-DOM"), _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_("SSS"), NULL, &hasFeature);
4982         ok(hr == S_OK, "ret %08x\n", hr );
4983         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4984
4985         SysFreeString(sEmpty);
4986         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
4987     }
4988
4989     pRoot = (IXMLDOMElement*)0x1;
4990     hr = IXMLDOMDocument_createElement(doc, NULL, &pRoot);
4991     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4992     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
4993
4994     pRoot = (IXMLDOMElement*)0x1;
4995     hr = IXMLDOMDocument_createElement(doc, _bstr_(""), &pRoot);
4996     ok(hr == E_FAIL, "ret %08x\n", hr );
4997     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
4998
4999     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
5000     ok(hr == S_OK, "ret %08x\n", hr );
5001     if(hr == S_OK)
5002     {
5003         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
5004         ok(hr == S_OK, "ret %08x\n", hr );
5005         if(hr == S_OK)
5006         {
5007             /* Comment */
5008             str = SysAllocString(szComment);
5009             hr = IXMLDOMDocument_createComment(doc, str, &pComment);
5010             SysFreeString(str);
5011             ok(hr == S_OK, "ret %08x\n", hr );
5012             if(hr == S_OK)
5013             {
5014                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
5015                 ok(hr == S_OK, "ret %08x\n", hr );
5016
5017                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
5018                 ok(hr == S_OK, "ret %08x\n", hr );
5019                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
5020                 SysFreeString(str);
5021
5022                 hr = IXMLDOMComment_get_xml(pComment, &str);
5023                 ok(hr == S_OK, "ret %08x\n", hr );
5024                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
5025                 SysFreeString(str);
5026
5027                 /* put data Tests */
5028                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
5029                 ok(hr == S_OK, "ret %08x\n", hr );
5030
5031                 /* get data Tests */
5032                 hr = IXMLDOMComment_get_data(pComment, &str);
5033                 ok(hr == S_OK, "ret %08x\n", hr );
5034                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
5035                 SysFreeString(str);
5036
5037                 /* Confirm XML text is good */
5038                 hr = IXMLDOMComment_get_xml(pComment, &str);
5039                 ok(hr == S_OK, "ret %08x\n", hr );
5040                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
5041                 SysFreeString(str);
5042
5043                 /* Confirm we get the put_data Text back */
5044                 hr = IXMLDOMComment_get_text(pComment, &str);
5045                 ok(hr == S_OK, "ret %08x\n", hr );
5046                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
5047                 SysFreeString(str);
5048
5049                 /* test length property */
5050                 hr = IXMLDOMComment_get_length(pComment, &len);
5051                 ok(hr == S_OK, "ret %08x\n", hr );
5052                 ok(len == 21, "expected 21 got %d\n", len);
5053
5054                 /* test substringData */
5055                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
5056                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5057
5058                 /* test substringData - Invalid offset */
5059                 str = (BSTR)&szElement;
5060                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
5061                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5062                 ok( str == NULL, "incorrect string\n");
5063
5064                 /* test substringData - Invalid offset */
5065                 str = (BSTR)&szElement;
5066                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
5067                 ok(hr == S_FALSE, "ret %08x\n", hr );
5068                 ok( str == NULL, "incorrect string\n");
5069
5070                 /* test substringData - Invalid size */
5071                 str = (BSTR)&szElement;
5072                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
5073                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5074                 ok( str == NULL, "incorrect string\n");
5075
5076                 /* test substringData - Invalid size */
5077                 str = (BSTR)&szElement;
5078                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
5079                 ok(hr == S_FALSE, "ret %08x\n", hr );
5080                 ok( str == NULL, "incorrect string\n");
5081
5082                 /* test substringData - Start of string */
5083                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
5084                 ok(hr == S_OK, "ret %08x\n", hr );
5085                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
5086                 SysFreeString(str);
5087
5088                 /* test substringData - Middle of string */
5089                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
5090                 ok(hr == S_OK, "ret %08x\n", hr );
5091                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
5092                 SysFreeString(str);
5093
5094                 /* test substringData - End of string */
5095                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
5096                 ok(hr == S_OK, "ret %08x\n", hr );
5097                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
5098                 SysFreeString(str);
5099
5100                 /* test appendData */
5101                 hr = IXMLDOMComment_appendData(pComment, NULL);
5102                 ok(hr == S_OK, "ret %08x\n", hr );
5103
5104                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
5105                 ok(hr == S_OK, "ret %08x\n", hr );
5106
5107                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
5108                 ok(hr == S_OK, "ret %08x\n", hr );
5109
5110                 hr = IXMLDOMComment_get_text(pComment, &str);
5111                 ok(hr == S_OK, "ret %08x\n", hr );
5112                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5113                 SysFreeString(str);
5114
5115                 /* test insertData */
5116                 str = SysAllocStringLen(NULL, 0);
5117                 hr = IXMLDOMComment_insertData(pComment, -1, str);
5118                 ok(hr == S_OK, "ret %08x\n", hr );
5119
5120                 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
5121                 ok(hr == S_OK, "ret %08x\n", hr );
5122
5123                 hr = IXMLDOMComment_insertData(pComment, 1000, str);
5124                 ok(hr == S_OK, "ret %08x\n", hr );
5125
5126                 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
5127                 ok(hr == S_OK, "ret %08x\n", hr );
5128
5129                 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
5130                 ok(hr == S_OK, "ret %08x\n", hr );
5131
5132                 hr = IXMLDOMComment_insertData(pComment, 0, str);
5133                 ok(hr == S_OK, "ret %08x\n", hr );
5134                 SysFreeString(str);
5135
5136                 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
5137                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5138
5139                 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
5140                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5141
5142                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
5143                 ok(hr == S_OK, "ret %08x\n", hr );
5144
5145                 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
5146                 ok(hr == S_OK, "ret %08x\n", hr );
5147
5148                 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
5149                 ok(hr == S_OK, "ret %08x\n", hr );
5150
5151                 hr = IXMLDOMComment_get_text(pComment, &str);
5152                 ok(hr == S_OK, "ret %08x\n", hr );
5153                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5154                 SysFreeString(str);
5155
5156                 /* delete data */
5157                 /* invalid arguments */
5158                 hr = IXMLDOMComment_deleteData(pComment, -1, 1);
5159                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5160
5161                 hr = IXMLDOMComment_deleteData(pComment, 0, 0);
5162                 ok(hr == S_OK, "ret %08x\n", hr );
5163
5164                 hr = IXMLDOMComment_deleteData(pComment, 0, -1);
5165                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5166
5167                 hr = IXMLDOMComment_get_length(pComment, &len);
5168                 ok(hr == S_OK, "ret %08x\n", hr );
5169                 ok(len == 43, "expected 43 got %d\n", len);
5170
5171                 hr = IXMLDOMComment_deleteData(pComment, len, 1);
5172                 ok(hr == S_OK, "ret %08x\n", hr );
5173
5174                 hr = IXMLDOMComment_deleteData(pComment, len+1, 1);
5175                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5176
5177                 /* delete from start */
5178                 hr = IXMLDOMComment_deleteData(pComment, 0, 5);
5179                 ok(hr == S_OK, "ret %08x\n", hr );
5180
5181                 hr = IXMLDOMComment_get_length(pComment, &len);
5182                 ok(hr == S_OK, "ret %08x\n", hr );
5183                 ok(len == 38, "expected 38 got %d\n", len);
5184
5185                 hr = IXMLDOMComment_get_text(pComment, &str);
5186                 ok(hr == S_OK, "ret %08x\n", hr );
5187                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5188                 SysFreeString(str);
5189
5190                 /* delete from end */
5191                 hr = IXMLDOMComment_deleteData(pComment, 35, 3);
5192                 ok(hr == S_OK, "ret %08x\n", hr );
5193
5194                 hr = IXMLDOMComment_get_length(pComment, &len);
5195                 ok(hr == S_OK, "ret %08x\n", hr );
5196                 ok(len == 35, "expected 35 got %d\n", len);
5197
5198                 hr = IXMLDOMComment_get_text(pComment, &str);
5199                 ok(hr == S_OK, "ret %08x\n", hr );
5200                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5201                 SysFreeString(str);
5202
5203                 /* delete from inside */
5204                 hr = IXMLDOMComment_deleteData(pComment, 1, 33);
5205                 ok(hr == S_OK, "ret %08x\n", hr );
5206
5207                 hr = IXMLDOMComment_get_length(pComment, &len);
5208                 ok(hr == S_OK, "ret %08x\n", hr );
5209                 ok(len == 2, "expected 2 got %d\n", len);
5210
5211                 hr = IXMLDOMComment_get_text(pComment, &str);
5212                 ok(hr == S_OK, "ret %08x\n", hr );
5213                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5214                 SysFreeString(str);
5215
5216                 /* delete whole data ... */
5217                 hr = IXMLDOMComment_get_length(pComment, &len);
5218                 ok(hr == S_OK, "ret %08x\n", hr );
5219
5220                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5221                 ok(hr == S_OK, "ret %08x\n", hr );
5222                 /* ... and try again with empty string */
5223                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5224                 ok(hr == S_OK, "ret %08x\n", hr );
5225
5226                 /* ::replaceData() */
5227                 V_VT(&v) = VT_BSTR;
5228                 V_BSTR(&v) = SysAllocString(szstr1);
5229                 hr = IXMLDOMComment_put_nodeValue(pComment, v);
5230                 ok(hr == S_OK, "ret %08x\n", hr );
5231                 VariantClear(&v);
5232
5233                 hr = IXMLDOMComment_replaceData(pComment, 6, 0, NULL);
5234                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5235                 hr = IXMLDOMComment_get_text(pComment, &str);
5236                 ok(hr == S_OK, "ret %08x\n", hr );
5237                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5238                 SysFreeString(str);
5239
5240                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, NULL);
5241                 ok(hr == S_OK, "ret %08x\n", hr );
5242                 hr = IXMLDOMComment_get_text(pComment, &str);
5243                 ok(hr == S_OK, "ret %08x\n", hr );
5244                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5245                 SysFreeString(str);
5246
5247                 /* NULL pointer means delete */
5248                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, NULL);
5249                 ok(hr == S_OK, "ret %08x\n", hr );
5250                 hr = IXMLDOMComment_get_text(pComment, &str);
5251                 ok(hr == S_OK, "ret %08x\n", hr );
5252                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5253                 SysFreeString(str);
5254
5255                 /* empty string means delete */
5256                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_(""));
5257                 ok(hr == S_OK, "ret %08x\n", hr );
5258                 hr = IXMLDOMComment_get_text(pComment, &str);
5259                 ok(hr == S_OK, "ret %08x\n", hr );
5260                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5261                 SysFreeString(str);
5262
5263                 /* zero count means insert */
5264                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, _bstr_("a"));
5265                 ok(hr == S_OK, "ret %08x\n", hr );
5266                 hr = IXMLDOMComment_get_text(pComment, &str);
5267                 ok(hr == S_OK, "ret %08x\n", hr );
5268                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5269                 SysFreeString(str);
5270
5271                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, NULL);
5272                 ok(hr == S_OK, "ret %08x\n", hr );
5273
5274                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("m"));
5275                 ok(hr == S_OK, "ret %08x\n", hr );
5276                 hr = IXMLDOMComment_get_text(pComment, &str);
5277                 ok(hr == S_OK, "ret %08x\n", hr );
5278                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5279                 SysFreeString(str);
5280
5281                 /* nonempty string, count greater than its length */
5282                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, _bstr_("a1.2"));
5283                 ok(hr == S_OK, "ret %08x\n", hr );
5284                 hr = IXMLDOMComment_get_text(pComment, &str);
5285                 ok(hr == S_OK, "ret %08x\n", hr );
5286                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5287                 SysFreeString(str);
5288
5289                 /* nonempty string, count less than its length */
5290                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_("wine"));
5291                 ok(hr == S_OK, "ret %08x\n", hr );
5292                 hr = IXMLDOMComment_get_text(pComment, &str);
5293                 ok(hr == S_OK, "ret %08x\n", hr );
5294                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5295                 SysFreeString(str);
5296
5297                 IXMLDOMComment_Release(pComment);
5298             }
5299
5300             /* Element */
5301             str = SysAllocString(szElement);
5302             hr = IXMLDOMDocument_createElement(doc, str, &pElement);
5303             SysFreeString(str);
5304             ok(hr == S_OK, "ret %08x\n", hr );
5305             if(hr == S_OK)
5306             {
5307                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5308                 ok(hr == S_OK, "ret %08x\n", hr );
5309
5310                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
5311                 ok(hr == S_OK, "ret %08x\n", hr );
5312                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
5313                 SysFreeString(str);
5314
5315                 hr = IXMLDOMElement_get_xml(pElement, &str);
5316                 ok(hr == S_OK, "ret %08x\n", hr );
5317                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
5318                 SysFreeString(str);
5319
5320                 /* Attribute */
5321                 pAttribute = (IXMLDOMAttribute*)0x1;
5322                 hr = IXMLDOMDocument_createAttribute(doc, NULL, &pAttribute);
5323                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5324                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5325
5326                 pAttribute = (IXMLDOMAttribute*)0x1;
5327                 hr = IXMLDOMDocument_createAttribute(doc, _bstr_(""), &pAttribute);
5328                 ok(hr == E_FAIL, "ret %08x\n", hr );
5329                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5330
5331                 str = SysAllocString(szAttribute);
5332                 hr = IXMLDOMDocument_createAttribute(doc, str, &pAttribute);
5333                 SysFreeString(str);
5334                 ok(hr == S_OK, "ret %08x\n", hr );
5335                 if(hr == S_OK)
5336                 {
5337                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
5338
5339                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, NULL);
5340                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5341
5342                     pNextChild = (IXMLDOMNode *)0x1;
5343                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, &pNextChild);
5344                     ok(hr == S_FALSE, "ret %08x\n", hr );
5345                     ok(pNextChild == NULL, "pNextChild not NULL\n");
5346
5347                     /* test Previous Sibling*/
5348                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, NULL);
5349                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5350
5351                     pNextChild = (IXMLDOMNode *)0x1;
5352                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, &pNextChild);
5353                     ok(hr == S_FALSE, "ret %08x\n", hr );
5354                     ok(pNextChild == NULL, "pNextChild not NULL\n");
5355
5356                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttribute, &pNewChild);
5357                     ok(hr == E_FAIL, "ret %08x\n", hr );
5358                     ok(pNewChild == NULL, "pNewChild not NULL\n");
5359
5360                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
5361                     ok(hr == S_OK, "ret %08x\n", hr );
5362                     if ( hr == S_OK )
5363                     {
5364                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttribute, NULL );
5365                         ok(hr == S_OK, "ret %08x\n", hr );
5366
5367                         IXMLDOMNamedNodeMap_Release(pAttribs);
5368                     }
5369
5370                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5371                     ok(hr == S_OK, "ret %08x\n", hr );
5372                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
5373                     SysFreeString(str);
5374
5375                     /* test nodeName */
5376                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5377                     ok(hr == S_OK, "ret %08x\n", hr );
5378                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
5379                     SysFreeString(str);
5380
5381                     /* test name property */
5382                     hr = IXMLDOMAttribute_get_name(pAttribute, &str);
5383                     ok(hr == S_OK, "ret %08x\n", hr );
5384                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
5385                     SysFreeString(str);
5386
5387                     hr = IXMLDOMAttribute_get_xml(pAttribute, &str);
5388                     ok(hr == S_OK, "ret %08x\n", hr );
5389                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
5390                     SysFreeString(str);
5391
5392                     IXMLDOMAttribute_Release(pAttribute);
5393
5394                     /* Check Element again with the Add Attribute*/
5395                     hr = IXMLDOMElement_get_xml(pElement, &str);
5396                     ok(hr == S_OK, "ret %08x\n", hr );
5397                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
5398                     SysFreeString(str);
5399                 }
5400
5401                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
5402                 ok(hr == S_OK, "ret %08x\n", hr );
5403
5404                 hr = IXMLDOMElement_get_xml(pElement, &str);
5405                 ok(hr == S_OK, "ret %08x\n", hr );
5406                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
5407                 SysFreeString(str);
5408
5409                 /* Test for reversible escaping */
5410                 str = SysAllocString( szStrangeChars );
5411                 hr = IXMLDOMElement_put_text(pElement, str);
5412                 ok(hr == S_OK, "ret %08x\n", hr );
5413                 SysFreeString( str );
5414
5415                 hr = IXMLDOMElement_get_xml(pElement, &str);
5416                 ok(hr == S_OK, "ret %08x\n", hr );
5417                 ok( !lstrcmpW( str, szElementXML4 ), "incorrect element xml\n");
5418                 SysFreeString(str);
5419
5420                 hr = IXMLDOMElement_get_text(pElement, &str);
5421                 ok(hr == S_OK, "ret %08x\n", hr );
5422                 ok( !lstrcmpW( str, szStrangeChars ), "incorrect element text\n");
5423                 SysFreeString(str);
5424
5425                 IXMLDOMElement_Release(pElement);
5426             }
5427
5428             /* CData Section */
5429             str = SysAllocString(szCData);
5430             hr = IXMLDOMDocument_createCDATASection(doc, str, NULL);
5431             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5432
5433             hr = IXMLDOMDocument_createCDATASection(doc, str, &pCDataSec);
5434             SysFreeString(str);
5435             ok(hr == S_OK, "ret %08x\n", hr );
5436             if(hr == S_OK)
5437             {
5438                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
5439                 VARIANT var;
5440
5441                 VariantInit(&var);
5442
5443                 hr = IXMLDOMCDATASection_QueryInterface(pCDataSec, &IID_IXMLDOMElement, (void**)&pElement);
5444                 ok(hr == E_NOINTERFACE, "ret %08x\n", hr);
5445
5446                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
5447                 ok(hr == S_OK, "ret %08x\n", hr );
5448
5449                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
5450                 ok(hr == S_OK, "ret %08x\n", hr );
5451                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
5452                 SysFreeString(str);
5453
5454                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5455                 ok(hr == S_OK, "ret %08x\n", hr );
5456                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
5457                 SysFreeString(str);
5458
5459                 /* test lastChild */
5460                 pNextChild = (IXMLDOMNode*)0x1;
5461                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
5462                 ok(hr == S_FALSE, "ret %08x\n", hr );
5463                 ok(pNextChild == NULL, "pNextChild not NULL\n");
5464
5465                 /* put data Tests */
5466                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
5467                 ok(hr == S_OK, "ret %08x\n", hr );
5468
5469                 /* Confirm XML text is good */
5470                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5471                 ok(hr == S_OK, "ret %08x\n", hr );
5472                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
5473                 SysFreeString(str);
5474
5475                 /* Confirm we get the put_data Text back */
5476                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5477                 ok(hr == S_OK, "ret %08x\n", hr );
5478                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5479                 SysFreeString(str);
5480
5481                 /* test length property */
5482                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5483                 ok(hr == S_OK, "ret %08x\n", hr );
5484                 ok(len == 21, "expected 21 got %d\n", len);
5485
5486                 /* test get data */
5487                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
5488                 ok(hr == S_OK, "ret %08x\n", hr );
5489                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5490                 SysFreeString(str);
5491
5492                 /* test substringData */
5493                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
5494                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5495
5496                 /* test substringData - Invalid offset */
5497                 str = (BSTR)&szElement;
5498                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
5499                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5500                 ok( str == NULL, "incorrect string\n");
5501
5502                 /* test substringData - Invalid offset */
5503                 str = (BSTR)&szElement;
5504                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
5505                 ok(hr == S_FALSE, "ret %08x\n", hr );
5506                 ok( str == NULL, "incorrect string\n");
5507
5508                 /* test substringData - Invalid size */
5509                 str = (BSTR)&szElement;
5510                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
5511                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5512                 ok( str == NULL, "incorrect string\n");
5513
5514                 /* test substringData - Invalid size */
5515                 str = (BSTR)&szElement;
5516                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
5517                 ok(hr == S_FALSE, "ret %08x\n", hr );
5518                 ok( str == NULL, "incorrect string\n");
5519
5520                 /* test substringData - Start of string */
5521                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
5522                 ok(hr == S_OK, "ret %08x\n", hr );
5523                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
5524                 SysFreeString(str);
5525
5526                 /* test substringData - Middle of string */
5527                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
5528                 ok(hr == S_OK, "ret %08x\n", hr );
5529                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
5530                 SysFreeString(str);
5531
5532                 /* test substringData - End of string */
5533                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
5534                 ok(hr == S_OK, "ret %08x\n", hr );
5535                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
5536                 SysFreeString(str);
5537
5538                 /* test appendData */
5539                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
5540                 ok(hr == S_OK, "ret %08x\n", hr );
5541
5542                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
5543                 ok(hr == S_OK, "ret %08x\n", hr );
5544
5545                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
5546                 ok(hr == S_OK, "ret %08x\n", hr );
5547
5548                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5549                 ok(hr == S_OK, "ret %08x\n", hr );
5550                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5551                 SysFreeString(str);
5552
5553                 /* test insertData */
5554                 str = SysAllocStringLen(NULL, 0);
5555                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
5556                 ok(hr == S_OK, "ret %08x\n", hr );
5557
5558                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
5559                 ok(hr == S_OK, "ret %08x\n", hr );
5560
5561                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
5562                 ok(hr == S_OK, "ret %08x\n", hr );
5563
5564                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
5565                 ok(hr == S_OK, "ret %08x\n", hr );
5566
5567                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
5568                 ok(hr == S_OK, "ret %08x\n", hr );
5569
5570                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
5571                 ok(hr == S_OK, "ret %08x\n", hr );
5572                 SysFreeString(str);
5573
5574                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
5575                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5576
5577                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
5578                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5579
5580                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
5581                 ok(hr == S_OK, "ret %08x\n", hr );
5582
5583                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
5584                 ok(hr == S_OK, "ret %08x\n", hr );
5585
5586                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
5587                 ok(hr == S_OK, "ret %08x\n", hr );
5588
5589                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5590                 ok(hr == S_OK, "ret %08x\n", hr );
5591                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5592                 SysFreeString(str);
5593
5594                 /* delete data */
5595                 /* invalid arguments */
5596                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, -1, 1);
5597                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5598
5599                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 0);
5600                 ok(hr == S_OK, "ret %08x\n", hr );
5601
5602                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, -1);
5603                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5604
5605                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5606                 ok(hr == S_OK, "ret %08x\n", hr );
5607                 ok(len == 43, "expected 43 got %d\n", len);
5608
5609                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len, 1);
5610                 ok(hr == S_OK, "ret %08x\n", hr );
5611
5612                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len+1, 1);
5613                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5614
5615                 /* delete from start */
5616                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 5);
5617                 ok(hr == S_OK, "ret %08x\n", hr );
5618
5619                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5620                 ok(hr == S_OK, "ret %08x\n", hr );
5621                 ok(len == 38, "expected 38 got %d\n", len);
5622
5623                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5624                 ok(hr == S_OK, "ret %08x\n", hr );
5625                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5626                 SysFreeString(str);
5627
5628                 /* delete from end */
5629                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 35, 3);
5630                 ok(hr == S_OK, "ret %08x\n", hr );
5631
5632                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5633                 ok(hr == S_OK, "ret %08x\n", hr );
5634                 ok(len == 35, "expected 35 got %d\n", len);
5635
5636                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5637                 ok(hr == S_OK, "ret %08x\n", hr );
5638                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5639                 SysFreeString(str);
5640
5641                 /* delete from inside */
5642                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 1, 33);
5643                 ok(hr == S_OK, "ret %08x\n", hr );
5644
5645                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5646                 ok(hr == S_OK, "ret %08x\n", hr );
5647                 ok(len == 2, "expected 2 got %d\n", len);
5648
5649                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5650                 ok(hr == S_OK, "ret %08x\n", hr );
5651                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5652                 SysFreeString(str);
5653
5654                 /* delete whole data ... */
5655                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5656                 ok(hr == S_OK, "ret %08x\n", hr );
5657
5658                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
5659                 ok(hr == S_OK, "ret %08x\n", hr );
5660
5661                 /* ... and try again with empty string */
5662                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
5663                 ok(hr == S_OK, "ret %08x\n", hr );
5664
5665                 /* ::replaceData() */
5666                 V_VT(&v) = VT_BSTR;
5667                 V_BSTR(&v) = SysAllocString(szstr1);
5668                 hr = IXMLDOMCDATASection_put_nodeValue(pCDataSec, v);
5669                 ok(hr == S_OK, "ret %08x\n", hr );
5670                 VariantClear(&v);
5671
5672                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 6, 0, NULL);
5673                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5674                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5675                 ok(hr == S_OK, "ret %08x\n", hr );
5676                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5677                 SysFreeString(str);
5678
5679                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, NULL);
5680                 ok(hr == S_OK, "ret %08x\n", hr );
5681                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5682                 ok(hr == S_OK, "ret %08x\n", hr );
5683                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5684                 SysFreeString(str);
5685
5686                 /* NULL pointer means delete */
5687                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, NULL);
5688                 ok(hr == S_OK, "ret %08x\n", hr );
5689                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5690                 ok(hr == S_OK, "ret %08x\n", hr );
5691                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5692                 SysFreeString(str);
5693
5694                 /* empty string means delete */
5695                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_(""));
5696                 ok(hr == S_OK, "ret %08x\n", hr );
5697                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5698                 ok(hr == S_OK, "ret %08x\n", hr );
5699                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5700                 SysFreeString(str);
5701
5702                 /* zero count means insert */
5703                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, _bstr_("a"));
5704                 ok(hr == S_OK, "ret %08x\n", hr );
5705                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5706                 ok(hr == S_OK, "ret %08x\n", hr );
5707                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5708                 SysFreeString(str);
5709
5710                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, NULL);
5711                 ok(hr == S_OK, "ret %08x\n", hr );
5712
5713                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("m"));
5714                 ok(hr == S_OK, "ret %08x\n", hr );
5715                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5716                 ok(hr == S_OK, "ret %08x\n", hr );
5717                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5718                 SysFreeString(str);
5719
5720                 /* nonempty string, count greater than its length */
5721                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, _bstr_("a1.2"));
5722                 ok(hr == S_OK, "ret %08x\n", hr );
5723                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5724                 ok(hr == S_OK, "ret %08x\n", hr );
5725                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5726                 SysFreeString(str);
5727
5728                 /* nonempty string, count less than its length */
5729                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_("wine"));
5730                 ok(hr == S_OK, "ret %08x\n", hr );
5731                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5732                 ok(hr == S_OK, "ret %08x\n", hr );
5733                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5734                 SysFreeString(str);
5735
5736                 IXMLDOMCDATASection_Release(pCDataSec);
5737             }
5738
5739             /* Document Fragments */
5740             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
5741             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5742
5743             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
5744             ok(hr == S_OK, "ret %08x\n", hr );
5745             if(hr == S_OK)
5746             {
5747                 IXMLDOMNode *node;
5748
5749                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, NULL);
5750                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5751
5752                 node = (IXMLDOMNode *)0x1;
5753                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, &node);
5754                 ok(hr == S_FALSE, "ret %08x\n", hr );
5755                 ok(node == NULL, "expected NULL, got %p\n", node);
5756
5757                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
5758                 ok(hr == S_OK, "ret %08x\n", hr );
5759
5760                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
5761                 ok(hr == S_OK, "ret %08x\n", hr );
5762                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
5763                 SysFreeString(str);
5764
5765                 /* test next Sibling*/
5766                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
5767                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5768
5769                 node = (IXMLDOMNode *)0x1;
5770                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &node);
5771                 ok(hr == S_FALSE, "ret %08x\n", hr );
5772                 ok(node == NULL, "next sibling not NULL\n");
5773
5774                 /* test Previous Sibling*/
5775                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
5776                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5777
5778                 node = (IXMLDOMNode *)0x1;
5779                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &node);
5780                 ok(hr == S_FALSE, "ret %08x\n", hr );
5781                 ok(node == NULL, "previous sibling not NULL\n");
5782
5783                 IXMLDOMDocumentFragment_Release(pDocFrag);
5784             }
5785
5786             /* Entity References */
5787             hr = IXMLDOMDocument_createEntityReference(doc, NULL, &pEntityRef);
5788             ok(hr == E_FAIL, "ret %08x\n", hr );
5789             hr = IXMLDOMDocument_createEntityReference(doc, _bstr_(""), &pEntityRef);
5790             ok(hr == E_FAIL, "ret %08x\n", hr );
5791
5792             str = SysAllocString(szEntityRef);
5793             hr = IXMLDOMDocument_createEntityReference(doc, str, NULL);
5794             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5795
5796             hr = IXMLDOMDocument_createEntityReference(doc, str, &pEntityRef);
5797             SysFreeString(str);
5798             ok(hr == S_OK, "ret %08x\n", hr );
5799             if(hr == S_OK)
5800             {
5801                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
5802                 ok(hr == S_OK, "ret %08x\n", hr );
5803
5804                 /* test get_xml*/
5805                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
5806                 ok(hr == S_OK, "ret %08x\n", hr );
5807                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
5808                 SysFreeString(str);
5809
5810                 IXMLDOMEntityReference_Release(pEntityRef);
5811             }
5812
5813             IXMLDOMElement_Release( pRoot );
5814         }
5815     }
5816
5817     IXMLDOMDocument_Release(doc);
5818
5819     free_bstrs();
5820 }
5821
5822 typedef struct {
5823     const char *name;
5824     const char *type;
5825     HRESULT hr;
5826 } put_datatype_t;
5827
5828 /* Type test for elements only. Name passed into put_dataType is case-insensitive.
5829    So many of the names have been changed to reflect this. */
5830 static put_datatype_t put_datatype_data[] = {
5831     { "test_inval",      "abcdefg",     E_FAIL },
5832     { "test_bool",       "Boolean",     S_OK },
5833     { "test_string",     "String",      S_OK },
5834     { "test_number",     "number",      S_OK },
5835     { "test_int",        "InT",         S_OK },
5836     { "test_fixed",      "fixed.14.4",  S_OK },
5837     { "test_datetime",   "DateTime",    S_OK },
5838     { "test_datetimetz", "DateTime.tz", S_OK },
5839     { "test_date",       "Date",        S_OK },
5840     { "test_time",       "Time",        S_OK },
5841     { "test_timetz",     "Time.tz",     S_OK },
5842     { "test_I1",         "I1",          S_OK },
5843     { "test_I2",         "I2",          S_OK },
5844     { "test_I4",         "I4",          S_OK },
5845     { "test_UI1",        "UI1",         S_OK },
5846     { "test_UI2",        "UI2",         S_OK },
5847     { "test_UI4",        "UI4",         S_OK },
5848     { "test_r4",         "r4",          S_OK },
5849     { "test_r8",         "r8",          S_OK },
5850     { "test_float",      "float",       S_OK },
5851     { "test_uuid",       "UuId",        S_OK },
5852     { "test_binhex",     "bin.hex",     S_OK },
5853     { "test_binbase64",  "bin.base64",  S_OK },
5854     { NULL }
5855 };
5856
5857 typedef struct {
5858     DOMNodeType type;
5859     HRESULT hr;
5860 } put_datatype_notype_t;
5861
5862 static put_datatype_notype_t put_dt_notype[] = {
5863     { NODE_PROCESSING_INSTRUCTION, E_FAIL },
5864     { NODE_DOCUMENT_FRAGMENT,      E_FAIL },
5865     { NODE_ENTITY_REFERENCE,       E_FAIL },
5866     { NODE_CDATA_SECTION,          E_FAIL },
5867     { NODE_COMMENT,                E_FAIL },
5868     { NODE_INVALID }
5869 };
5870
5871 static void test_put_dataType( void )
5872 {
5873     const put_datatype_notype_t *ptr2 = put_dt_notype;
5874     const put_datatype_t *ptr = put_datatype_data;
5875     IXMLDOMElement *root, *element;
5876     BSTR nameW, type1W, type2W;
5877     IXMLDOMDocument *doc;
5878     HRESULT hr;
5879
5880     doc = create_document(&IID_IXMLDOMDocument);
5881
5882     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), NULL);
5883     EXPECT_HR(hr, E_INVALIDARG);
5884
5885     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
5886     EXPECT_HR(hr, S_OK);
5887
5888     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
5889     EXPECT_HR(hr, S_OK);
5890
5891     hr = IXMLDOMElement_put_dataType(root, NULL);
5892     EXPECT_HR(hr, E_INVALIDARG);
5893
5894     while (ptr->name)
5895     {
5896         hr = IXMLDOMDocument_createElement(doc, _bstr_(ptr->name), &element);
5897         EXPECT_HR(hr, S_OK);
5898         if(hr == S_OK)
5899         {
5900             hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
5901             EXPECT_HR(hr, S_OK);
5902
5903             hr = IXMLDOMElement_put_dataType(element, _bstr_(ptr->type));
5904             ok(hr == ptr->hr, "failed for %s:%s, 0x%08x\n", ptr->name, ptr->type, ptr->hr);
5905
5906             IXMLDOMElement_Release(element);
5907         }
5908         ptr++;
5909     }
5910
5911     /* check changing types */
5912     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &element);
5913     EXPECT_HR(hr, S_OK);
5914
5915     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
5916     EXPECT_HR(hr, S_OK);
5917
5918     hr = IXMLDOMElement_put_dataType(element, _bstr_("DateTime.tz"));
5919     EXPECT_HR(hr, S_OK);
5920
5921     hr = IXMLDOMElement_put_dataType(element, _bstr_("string"));
5922     EXPECT_HR(hr, S_OK);
5923
5924     IXMLDOMElement_Release(element);
5925
5926     /* try to set type for node without a type */
5927     nameW  = _bstr_("testname");
5928     type1W = _bstr_("string");
5929     type2W = _bstr_("number");
5930     while (ptr2->type != NODE_INVALID)
5931     {
5932         IXMLDOMNode *node;
5933         VARIANT type;
5934
5935         V_VT(&type) = VT_I2;
5936         V_I2(&type) = ptr2->type;
5937
5938         hr = IXMLDOMDocument_createNode(doc, type, nameW, NULL, &node);
5939         EXPECT_HR(hr, S_OK);
5940         if(hr == S_OK)
5941         {
5942             hr = IXMLDOMElement_appendChild(root, node, NULL);
5943             EXPECT_HR(hr, S_OK);
5944
5945             hr = IXMLDOMNode_put_dataType(node, NULL);
5946             EXPECT_HR(hr, E_INVALIDARG);
5947
5948             hr = IXMLDOMNode_put_dataType(node, type1W);
5949             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
5950             hr = IXMLDOMNode_put_dataType(node, type2W);
5951             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
5952
5953             IXMLDOMNode_Release(node);
5954         }
5955         ptr2++;
5956     }
5957
5958     IXMLDOMElement_Release(root);
5959     IXMLDOMDocument_Release(doc);
5960     free_bstrs();
5961 }
5962
5963 static void test_save(void)
5964 {
5965     IXMLDOMDocument *doc, *doc2;
5966     IXMLDOMElement *root;
5967     BSTR sOrig, sNew, filename;
5968     char buffer[100];
5969     IStream *stream;
5970     HGLOBAL global;
5971     VARIANT_BOOL b;
5972     DWORD read = 0;
5973     VARIANT dest;
5974     HANDLE hfile;
5975     HRESULT hr;
5976     char *ptr;
5977
5978     doc = create_document(&IID_IXMLDOMDocument);
5979     doc2 = create_document(&IID_IXMLDOMDocument);
5980
5981     /* save to IXMLDOMDocument */
5982     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
5983     EXPECT_HR(hr, S_OK);
5984
5985     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
5986     EXPECT_HR(hr, S_OK);
5987
5988     V_VT(&dest) = VT_UNKNOWN;
5989     V_UNKNOWN(&dest) = (IUnknown*)doc2;
5990
5991     hr = IXMLDOMDocument_save(doc, dest);
5992     EXPECT_HR(hr, S_OK);
5993
5994     hr = IXMLDOMDocument_get_xml(doc, &sOrig);
5995     EXPECT_HR(hr, S_OK);
5996
5997     hr = IXMLDOMDocument_get_xml(doc2, &sNew);
5998     EXPECT_HR(hr, S_OK);
5999
6000     ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as original\n");
6001
6002     SysFreeString(sOrig);
6003     SysFreeString(sNew);
6004
6005     IXMLDOMElement_Release(root);
6006     IXMLDOMDocument_Release(doc2);
6007
6008     /* save to path */
6009     V_VT(&dest) = VT_BSTR;
6010     V_BSTR(&dest) = _bstr_("test.xml");
6011
6012     hr = IXMLDOMDocument_save(doc, dest);
6013     EXPECT_HR(hr, S_OK);
6014
6015     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
6016     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
6017     if(hfile == INVALID_HANDLE_VALUE) return;
6018
6019     ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
6020     ok(read != 0, "could not read file\n");
6021     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
6022
6023     CloseHandle(hfile);
6024     DeleteFileA("test.xml");
6025
6026     /* save to path VT_BSTR | VT_BYREF */
6027     filename = _bstr_("test.xml");
6028     V_VT(&dest) = VT_BSTR | VT_BYREF;
6029     V_BSTRREF(&dest) = &filename;
6030
6031     hr = IXMLDOMDocument_save(doc, dest);
6032     EXPECT_HR(hr, S_OK);
6033
6034     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
6035     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
6036     if(hfile == INVALID_HANDLE_VALUE) return;
6037
6038     if (hfile != INVALID_HANDLE_VALUE)
6039     {
6040        ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
6041        ok(read != 0, "could not read file\n");
6042        ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
6043
6044        CloseHandle(hfile);
6045        DeleteFileA("test.xml");
6046     }
6047
6048     /* save to stream */
6049     V_VT(&dest) = VT_UNKNOWN;
6050     V_UNKNOWN(&dest) = (IUnknown*)&savestream;
6051
6052     hr = IXMLDOMDocument_save(doc, dest);
6053     EXPECT_HR(hr, S_OK);
6054
6055     /* loaded data contains xml declaration */
6056     hr = IXMLDOMDocument_loadXML(doc, _bstr_(win1252xml), &b);
6057     EXPECT_HR(hr, S_OK);
6058
6059     CreateStreamOnHGlobal(NULL, TRUE, &stream);
6060     V_VT(&dest) = VT_UNKNOWN;
6061     V_UNKNOWN(&dest) = (IUnknown*)stream;
6062     hr = IXMLDOMDocument_save(doc, dest);
6063     EXPECT_HR(hr, S_OK);
6064
6065     hr = GetHGlobalFromStream(stream, &global);
6066     EXPECT_HR(hr, S_OK);
6067     ptr = GlobalLock(global);
6068     ok(!memcmp(ptr, win1252decl, strlen(win1252decl)), "got wrong xml declaration\n");
6069     GlobalUnlock(global);
6070     IStream_Release(stream);
6071
6072     /* loaded data without xml declaration */
6073     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<a/>"), &b);
6074     EXPECT_HR(hr, S_OK);
6075
6076     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
6077     ok(hr == S_OK, "got 0x%08x\n", hr);
6078     V_VT(&dest) = VT_UNKNOWN;
6079     V_UNKNOWN(&dest) = (IUnknown*)stream;
6080     hr = IXMLDOMDocument_save(doc, dest);
6081     EXPECT_HR(hr, S_OK);
6082
6083     hr = GetHGlobalFromStream(stream, &global);
6084     EXPECT_HR(hr, S_OK);
6085     ptr = GlobalLock(global);
6086     ok(ptr[0] == '<' && ptr[1] != '?', "got wrong start tag %c%c\n", ptr[0], ptr[1]);
6087     GlobalUnlock(global);
6088     IStream_Release(stream);
6089
6090     IXMLDOMDocument_Release(doc);
6091     free_bstrs();
6092 }
6093
6094 static void test_testTransforms(void)
6095 {
6096     IXMLDOMDocument *doc, *docSS;
6097     IXMLDOMNode *pNode;
6098     VARIANT_BOOL bSucc;
6099     HRESULT hr;
6100
6101     doc = create_document(&IID_IXMLDOMDocument);
6102     docSS = create_document(&IID_IXMLDOMDocument);
6103
6104     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
6105     ok(hr == S_OK, "ret %08x\n", hr );
6106
6107     hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
6108     ok(hr == S_OK, "ret %08x\n", hr );
6109
6110     hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (void**)&pNode );
6111     ok(hr == S_OK, "ret %08x\n", hr );
6112     if(hr == S_OK)
6113     {
6114         BSTR bOut;
6115
6116         hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
6117         ok(hr == S_OK, "ret %08x\n", hr );
6118         if(hr == S_OK)
6119         {
6120             ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "got output %s\n", wine_dbgstr_w(bOut));
6121             SysFreeString(bOut);
6122         }
6123
6124         IXMLDOMNode_Release(pNode);
6125     }
6126
6127     IXMLDOMDocument_Release(docSS);
6128     IXMLDOMDocument_Release(doc);
6129
6130     free_bstrs();
6131 }
6132
6133 struct namespaces_change_t {
6134     const CLSID *clsid;
6135     const char *name;
6136 };
6137
6138 static const struct namespaces_change_t namespaces_change_test_data[] = {
6139     { &CLSID_DOMDocument,   "CLSID_DOMDocument"   },
6140     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2"  },
6141     { &CLSID_DOMDocument26, "CLSID_DOMDocument26" },
6142     { &CLSID_DOMDocument30, "CLSID_DOMDocument30" },
6143     { &CLSID_DOMDocument40, "CLSID_DOMDocument40" },
6144     { &CLSID_DOMDocument60, "CLSID_DOMDocument60" },
6145     { 0 }
6146 };
6147
6148 static void test_namespaces_change(void)
6149 {
6150     const struct namespaces_change_t *class_ptr = namespaces_change_test_data;
6151
6152     while (class_ptr->clsid)
6153     {
6154         IXMLDOMDocument *doc = NULL;
6155         IXMLDOMElement *elem = NULL;
6156         IXMLDOMNode *node = NULL;
6157
6158         VARIANT var;
6159         HRESULT hr;
6160         BSTR str;
6161
6162         if (!is_clsid_supported(class_ptr->clsid, &IID_IXMLDOMDocument))
6163         {
6164             class_ptr++;
6165             continue;
6166         }
6167
6168         hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
6169                               &IID_IXMLDOMDocument, (void**)&doc);
6170         ok(hr == S_OK, "got 0x%08x\n", hr);
6171
6172         V_VT(&var) = VT_I2;
6173         V_I2(&var) = NODE_ELEMENT;
6174
6175         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("ns:elem"), _bstr_("ns/uri"), &node);
6176         EXPECT_HR(hr, S_OK);
6177
6178         hr = IXMLDOMDocument_appendChild(doc, node, NULL);
6179         EXPECT_HR(hr, S_OK);
6180
6181         hr = IXMLDOMDocument_get_documentElement(doc, &elem);
6182         EXPECT_HR(hr, S_OK);
6183
6184         /* try same prefix, different uri */
6185         V_VT(&var) = VT_BSTR;
6186         V_BSTR(&var) = _bstr_("ns/uri2");
6187
6188         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
6189         EXPECT_HR(hr, E_INVALIDARG);
6190
6191         /* try same prefix and uri */
6192         V_VT(&var) = VT_BSTR;
6193         V_BSTR(&var) = _bstr_("ns/uri");
6194
6195         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
6196         EXPECT_HR(hr, S_OK);
6197
6198         hr = IXMLDOMElement_get_xml(elem, &str);
6199         EXPECT_HR(hr, S_OK);
6200         ok(!lstrcmpW(str, _bstr_("<ns:elem xmlns:ns=\"ns/uri\"/>")), "got element %s for %s\n",
6201            wine_dbgstr_w(str), class_ptr->name);
6202         SysFreeString(str);
6203
6204         IXMLDOMElement_Release(elem);
6205         IXMLDOMDocument_Release(doc);
6206
6207         free_bstrs();
6208
6209         class_ptr++;
6210     }
6211 }
6212
6213 static void test_namespaces_basic(void)
6214 {
6215     static const CHAR namespaces_xmlA[] =
6216         "<?xml version=\"1.0\"?>\n"
6217         "<XMI xmi.version=\"1.1\" xmlns:Model=\"http://omg.org/mof.Model/1.3\">"
6218         "  <XMI.content>"
6219         "    <Model:Package name=\"WinePackage\" Model:name2=\"name2 attr\" />"
6220         "  </XMI.content>"
6221         "</XMI>";
6222
6223     IXMLDOMDocument *doc;
6224     IXMLDOMElement *elem;
6225     IXMLDOMNode *node;
6226
6227     VARIANT_BOOL b;
6228     HRESULT hr;
6229     BSTR str;
6230
6231     doc = create_document(&IID_IXMLDOMDocument);
6232
6233     hr = IXMLDOMDocument_loadXML(doc, _bstr_(namespaces_xmlA), &b);
6234     EXPECT_HR(hr, S_OK);
6235     ok(b == VARIANT_TRUE, "got %d\n", b);
6236
6237     str = (BSTR)0xdeadbeef;
6238     hr = IXMLDOMDocument_get_namespaceURI(doc, &str);
6239     EXPECT_HR(hr, S_FALSE);
6240     ok(str == NULL, "got %p\n", str);
6241
6242     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("//XMI.content"), &node );
6243     EXPECT_HR(hr, S_OK);
6244     if(hr == S_OK)
6245     {
6246         IXMLDOMAttribute *attr;
6247         IXMLDOMNode *node2;
6248
6249         hr = IXMLDOMNode_get_firstChild(node, &node2);
6250         EXPECT_HR(hr, S_OK);
6251         ok(node2 != NULL, "got %p\n", node2);
6252
6253         /* Test get_prefix */
6254         hr = IXMLDOMNode_get_prefix(node2, NULL);
6255         EXPECT_HR(hr, E_INVALIDARG);
6256         /* NOTE: Need to test that arg2 gets cleared on Error. */
6257
6258         hr = IXMLDOMNode_get_prefix(node2, &str);
6259         EXPECT_HR(hr, S_OK);
6260         ok( !lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
6261         SysFreeString(str);
6262
6263         hr = IXMLDOMNode_get_nodeName(node2, &str);
6264         EXPECT_HR(hr, S_OK);
6265         ok(!lstrcmpW( str, _bstr_("Model:Package")), "got %s\n", wine_dbgstr_w(str));
6266         SysFreeString(str);
6267
6268         /* Test get_namespaceURI */
6269         hr = IXMLDOMNode_get_namespaceURI(node2, NULL);
6270         EXPECT_HR(hr, E_INVALIDARG);
6271         /* NOTE: Need to test that arg2 gets cleared on Error. */
6272
6273         hr = IXMLDOMNode_get_namespaceURI(node2, &str);
6274         EXPECT_HR(hr, S_OK);
6275         ok(!lstrcmpW( str, _bstr_("http://omg.org/mof.Model/1.3")), "got %s\n", wine_dbgstr_w(str));
6276         SysFreeString(str);
6277
6278         hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&elem);
6279         EXPECT_HR(hr, S_OK);
6280
6281         hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("Model:name2"), &attr);
6282         EXPECT_HR(hr, S_OK);
6283
6284         hr = IXMLDOMAttribute_get_nodeName(attr, &str);
6285         EXPECT_HR(hr, S_OK);
6286         ok(!lstrcmpW( str, _bstr_("Model:name2")), "got %s\n", wine_dbgstr_w(str));
6287         SysFreeString(str);
6288
6289         hr = IXMLDOMAttribute_get_prefix(attr, &str);
6290         EXPECT_HR(hr, S_OK);
6291         ok(!lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
6292         SysFreeString(str);
6293
6294         IXMLDOMAttribute_Release(attr);
6295         IXMLDOMElement_Release(elem);
6296
6297         IXMLDOMNode_Release(node2);
6298         IXMLDOMNode_Release(node);
6299     }
6300
6301     IXMLDOMDocument_Release(doc);
6302
6303     free_bstrs();
6304 }
6305
6306 static void test_FormattingXML(void)
6307 {
6308     IXMLDOMDocument *doc;
6309     IXMLDOMElement *pElement;
6310     VARIANT_BOOL bSucc;
6311     HRESULT hr;
6312     BSTR str;
6313     static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
6314     static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
6315
6316     doc = create_document(&IID_IXMLDOMDocument);
6317
6318     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
6319     ok(hr == S_OK, "ret %08x\n", hr );
6320     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6321
6322     if(bSucc == VARIANT_TRUE)
6323     {
6324         hr = IXMLDOMDocument_get_documentElement(doc, &pElement);
6325         ok(hr == S_OK, "ret %08x\n", hr );
6326         if(hr == S_OK)
6327         {
6328             hr = IXMLDOMElement_get_xml(pElement, &str);
6329             ok(hr == S_OK, "ret %08x\n", hr );
6330             ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
6331             SysFreeString(str);
6332
6333             IXMLDOMElement_Release(pElement);
6334         }
6335     }
6336
6337     IXMLDOMDocument_Release(doc);
6338
6339     free_bstrs();
6340 }
6341
6342 typedef struct _nodetypedvalue_t {
6343     const char *name;
6344     VARTYPE type;
6345     const char *value; /* value in string format */
6346 } nodetypedvalue_t;
6347
6348 static const nodetypedvalue_t get_nodetypedvalue[] = {
6349     { "root/string",    VT_BSTR, "Wine" },
6350     { "root/string2",   VT_BSTR, "String" },
6351     { "root/number",    VT_BSTR, "12.44" },
6352     { "root/number2",   VT_BSTR, "-3.71e3" },
6353     { "root/int",       VT_I4,   "-13" },
6354     { "root/fixed",     VT_CY,   "7322.9371" },
6355     { "root/bool",      VT_BOOL, "-1" },
6356     { "root/datetime",  VT_DATE, "40135.14" },
6357     { "root/datetimetz",VT_DATE, "37813.59" },
6358     { "root/date",      VT_DATE, "665413" },
6359     { "root/time",      VT_DATE, "0.5813889" },
6360     { "root/timetz",    VT_DATE, "1.112512" },
6361     { "root/i1",        VT_I1,   "-13" },
6362     { "root/i2",        VT_I2,   "31915" },
6363     { "root/i4",        VT_I4,   "-312232" },
6364     { "root/ui1",       VT_UI1,  "123" },
6365     { "root/ui2",       VT_UI2,  "48282" },
6366     { "root/ui4",       VT_UI4,  "949281" },
6367     { "root/r4",        VT_R4,   "213124" },
6368     { "root/r8",        VT_R8,   "0.412" },
6369     { "root/float",     VT_R8,   "41221.421" },
6370     { "root/uuid",      VT_BSTR, "333C7BC4-460F-11D0-BC04-0080C7055a83" },
6371     { "root/binbase64", VT_ARRAY|VT_UI1, "base64 test" },
6372     { "root/binbase64_1", VT_ARRAY|VT_UI1, "base64 test" },
6373     { "root/binbase64_2", VT_ARRAY|VT_UI1, "base64 test" },
6374     { 0 }
6375 };
6376
6377 static void test_nodeTypedValue(void)
6378 {
6379     const nodetypedvalue_t *entry = get_nodetypedvalue;
6380     IXMLDOMDocumentType *doctype, *doctype2;
6381     IXMLDOMProcessingInstruction *pi;
6382     IXMLDOMDocumentFragment *frag;
6383     IXMLDOMDocument *doc, *doc2;
6384     IXMLDOMCDATASection *cdata;
6385     IXMLDOMComment *comment;
6386     IXMLDOMNode *node;
6387     VARIANT_BOOL b;
6388     VARIANT value;
6389     HRESULT hr;
6390
6391     doc = create_document(&IID_IXMLDOMDocument);
6392
6393     b = VARIANT_FALSE;
6394     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &b);
6395     ok(hr == S_OK, "ret %08x\n", hr );
6396     ok(b == VARIANT_TRUE, "got %d\n", b);
6397
6398     hr = IXMLDOMDocument_get_nodeValue(doc, NULL);
6399     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6400
6401     V_VT(&value) = VT_BSTR;
6402     V_BSTR(&value) = NULL;
6403     hr = IXMLDOMDocument_get_nodeValue(doc, &value);
6404     ok(hr == S_FALSE, "ret %08x\n", hr );
6405     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6406
6407     hr = IXMLDOMDocument_get_nodeTypedValue(doc, NULL);
6408     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6409
6410     V_VT(&value) = VT_EMPTY;
6411     hr = IXMLDOMDocument_get_nodeTypedValue(doc, &value);
6412     ok(hr == S_FALSE, "ret %08x\n", hr );
6413     ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6414
6415     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/string"), &node);
6416     ok(hr == S_OK, "ret %08x\n", hr );
6417
6418     V_VT(&value) = VT_BSTR;
6419     V_BSTR(&value) = NULL;
6420     hr = IXMLDOMNode_get_nodeValue(node, &value);
6421     ok(hr == S_FALSE, "ret %08x\n", hr );
6422     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6423
6424     hr = IXMLDOMNode_get_nodeTypedValue(node, NULL);
6425     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6426
6427     IXMLDOMNode_Release(node);
6428
6429     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/binhex"), &node);
6430     ok(hr == S_OK, "ret %08x\n", hr );
6431     {
6432         BYTE bytes[] = {0xff,0xfc,0xa0,0x12,0x00,0x3c};
6433
6434         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6435         ok(hr == S_OK, "ret %08x\n", hr );
6436         ok(V_VT(&value) == (VT_ARRAY|VT_UI1), "incorrect type\n");
6437         ok(V_ARRAY(&value)->rgsabound[0].cElements == 6, "incorrect array size\n");
6438         if(V_ARRAY(&value)->rgsabound[0].cElements == 6)
6439             ok(!memcmp(bytes, V_ARRAY(&value)->pvData, sizeof(bytes)), "incorrect value\n");
6440         VariantClear(&value);
6441         IXMLDOMNode_Release(node);
6442     }
6443
6444     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("foo"), _bstr_("value"), &pi);
6445     ok(hr == S_OK, "ret %08x\n", hr );
6446     {
6447         V_VT(&value) = VT_NULL;
6448         V_BSTR(&value) = (void*)0xdeadbeef;
6449         hr = IXMLDOMProcessingInstruction_get_nodeTypedValue(pi, &value);
6450         ok(hr == S_OK, "ret %08x\n", hr );
6451         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6452         ok(!lstrcmpW(V_BSTR(&value), _bstr_("value")), "got wrong value\n");
6453         IXMLDOMProcessingInstruction_Release(pi);
6454         VariantClear(&value);
6455     }
6456
6457     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("[1]*2=3; &gee that's not right!"), &cdata);
6458     ok(hr == S_OK, "ret %08x\n", hr );
6459     {
6460         V_VT(&value) = VT_NULL;
6461         V_BSTR(&value) = (void*)0xdeadbeef;
6462         hr = IXMLDOMCDATASection_get_nodeTypedValue(cdata, &value);
6463         ok(hr == S_OK, "ret %08x\n", hr );
6464         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6465         ok(!lstrcmpW(V_BSTR(&value), _bstr_("[1]*2=3; &gee that's not right!")), "got wrong value\n");
6466         IXMLDOMCDATASection_Release(cdata);
6467         VariantClear(&value);
6468     }
6469
6470     hr = IXMLDOMDocument_createComment(doc, _bstr_("comment"), &comment);
6471     ok(hr == S_OK, "ret %08x\n", hr );
6472     {
6473         V_VT(&value) = VT_NULL;
6474         V_BSTR(&value) = (void*)0xdeadbeef;
6475         hr = IXMLDOMComment_get_nodeTypedValue(comment, &value);
6476         ok(hr == S_OK, "ret %08x\n", hr );
6477         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6478         ok(!lstrcmpW(V_BSTR(&value), _bstr_("comment")), "got wrong value\n");
6479         IXMLDOMComment_Release(comment);
6480         VariantClear(&value);
6481     }
6482
6483     hr = IXMLDOMDocument_createDocumentFragment(doc, &frag);
6484     ok(hr == S_OK, "ret %08x\n", hr );
6485     {
6486         V_VT(&value) = VT_EMPTY;
6487         hr = IXMLDOMDocumentFragment_get_nodeTypedValue(frag, &value);
6488         ok(hr == S_FALSE, "ret %08x\n", hr );
6489         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6490         IXMLDOMDocumentFragment_Release(frag);
6491     }
6492
6493     doc2 = create_document(&IID_IXMLDOMDocument);
6494
6495     b = VARIANT_FALSE;
6496     hr = IXMLDOMDocument_loadXML(doc2, _bstr_(szEmailXML), &b);
6497     ok(hr == S_OK, "ret %08x\n", hr );
6498     ok(b == VARIANT_TRUE, "got %d\n", b);
6499
6500     EXPECT_REF(doc2, 1);
6501
6502     hr = IXMLDOMDocument_get_doctype(doc2, &doctype);
6503     ok(hr == S_OK, "ret %08x\n", hr );
6504
6505     EXPECT_REF(doc2, 1);
6506     todo_wine EXPECT_REF(doctype, 2);
6507
6508     {
6509         V_VT(&value) = VT_EMPTY;
6510         hr = IXMLDOMDocumentType_get_nodeTypedValue(doctype, &value);
6511         ok(hr == S_FALSE, "ret %08x\n", hr );
6512         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6513     }
6514
6515     hr = IXMLDOMDocument_get_doctype(doc2, &doctype2);
6516     ok(hr == S_OK, "ret %08x\n", hr );
6517     ok(doctype != doctype2, "got %p, was %p\n", doctype2, doctype);
6518
6519     IXMLDOMDocumentType_Release(doctype2);
6520     IXMLDOMDocumentType_Release(doctype);
6521
6522     IXMLDOMDocument_Release(doc2);
6523
6524     while (entry->name)
6525     {
6526         hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_(entry->name), &node);
6527         ok(hr == S_OK, "ret %08x\n", hr );
6528
6529         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6530         ok(hr == S_OK, "ret %08x\n", hr );
6531         ok(V_VT(&value) == entry->type, "incorrect type, expected %d, got %d\n", entry->type, V_VT(&value));
6532
6533         if (entry->type == (VT_ARRAY|VT_UI1))
6534         {
6535             ok(V_ARRAY(&value)->rgsabound[0].cElements == strlen(entry->value),
6536                "incorrect array size %d\n", V_ARRAY(&value)->rgsabound[0].cElements);
6537         }
6538
6539         if (entry->type != VT_BSTR)
6540         {
6541            if (entry->type == VT_DATE ||
6542                entry->type == VT_R8 ||
6543                entry->type == VT_CY)
6544            {
6545                if (entry->type == VT_DATE)
6546                {
6547                    hr = VariantChangeType(&value, &value, 0, VT_R4);
6548                    ok(hr == S_OK, "ret %08x\n", hr );
6549                }
6550                hr = VariantChangeTypeEx(&value, &value,
6551                                         MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT),
6552                                         VARIANT_NOUSEROVERRIDE, VT_BSTR);
6553                ok(hr == S_OK, "ret %08x\n", hr );
6554            }
6555            else
6556            {
6557                hr = VariantChangeType(&value, &value, 0, VT_BSTR);
6558                ok(hr == S_OK, "ret %08x\n", hr );
6559            }
6560
6561            /* for byte array from VT_ARRAY|VT_UI1 it's not a WCHAR buffer */
6562            if (entry->type == (VT_ARRAY|VT_UI1))
6563            {
6564                ok(!memcmp( V_BSTR(&value), entry->value, strlen(entry->value)),
6565                   "expected %s\n", entry->value);
6566            }
6567            else
6568                ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
6569                   "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
6570         }
6571         else
6572            ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
6573                "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
6574
6575         VariantClear( &value );
6576         IXMLDOMNode_Release(node);
6577
6578         entry++;
6579     }
6580
6581     IXMLDOMDocument_Release(doc);
6582     free_bstrs();
6583 }
6584
6585 static void test_TransformWithLoadingLocalFile(void)
6586 {
6587     IXMLDOMDocument *doc;
6588     IXMLDOMDocument *xsl;
6589     IXMLDOMNode *pNode;
6590     VARIANT_BOOL bSucc;
6591     HRESULT hr;
6592     HANDLE file;
6593     DWORD dwWritten;
6594     char lpPathBuffer[MAX_PATH];
6595     int i;
6596
6597     /* Create a Temp File. */
6598     GetTempPathA(MAX_PATH, lpPathBuffer);
6599     strcat(lpPathBuffer, "customers.xml" );
6600
6601     file = CreateFileA(lpPathBuffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
6602     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
6603     if(file == INVALID_HANDLE_VALUE)
6604         return;
6605
6606     WriteFile(file, szBasicTransformXML, strlen(szBasicTransformXML), &dwWritten, NULL);
6607     CloseHandle(file);
6608
6609     /* Correct path to not include an escape character. */
6610     for(i=0; i < strlen(lpPathBuffer); i++)
6611     {
6612         if(lpPathBuffer[i] == '\\')
6613             lpPathBuffer[i] = '/';
6614     }
6615
6616     doc = create_document(&IID_IXMLDOMDocument);
6617     xsl = create_document(&IID_IXMLDOMDocument);
6618
6619     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
6620     ok(hr == S_OK, "ret %08x\n", hr );
6621     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6622     if(bSucc == VARIANT_TRUE)
6623     {
6624         BSTR sXSL;
6625         BSTR sPart1 = _bstr_(szBasicTransformSSXMLPart1);
6626         BSTR sPart2 = _bstr_(szBasicTransformSSXMLPart2);
6627         BSTR sFileName = _bstr_(lpPathBuffer);
6628         int nLegnth = lstrlenW(sPart1) + lstrlenW(sPart2) + lstrlenW(sFileName) + 1;
6629
6630         sXSL = SysAllocStringLen(NULL, nLegnth);
6631         lstrcpyW(sXSL, sPart1);
6632         lstrcatW(sXSL, sFileName);
6633         lstrcatW(sXSL, sPart2);
6634
6635         hr = IXMLDOMDocument_loadXML(xsl, sXSL, &bSucc);
6636         ok(hr == S_OK, "ret %08x\n", hr );
6637         ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6638         if(bSucc == VARIANT_TRUE)
6639         {
6640             BSTR sResult;
6641
6642             hr = IXMLDOMDocument_QueryInterface(xsl, &IID_IXMLDOMNode, (void**)&pNode );
6643             ok(hr == S_OK, "ret %08x\n", hr );
6644             if(hr == S_OK)
6645             {
6646                 /* This will load the temp file via the XSL */
6647                 hr = IXMLDOMDocument_transformNode(doc, pNode, &sResult);
6648                 ok(hr == S_OK, "ret %08x\n", hr );
6649                 if(hr == S_OK)
6650                 {
6651                     ok( compareIgnoreReturns( sResult, _bstr_(szBasicTransformOutput)), "Stylesheet output not correct\n");
6652                     SysFreeString(sResult);
6653                 }
6654
6655                 IXMLDOMNode_Release(pNode);
6656             }
6657         }
6658
6659         SysFreeString(sXSL);
6660     }
6661
6662     IXMLDOMDocument_Release(doc);
6663     IXMLDOMDocument_Release(xsl);
6664
6665     DeleteFileA(lpPathBuffer);
6666     free_bstrs();
6667 }
6668
6669 static void test_put_nodeValue(void)
6670 {
6671     static const WCHAR jeevesW[] = {'J','e','e','v','e','s',' ','&',' ','W','o','o','s','t','e','r',0};
6672     IXMLDOMDocument *doc;
6673     IXMLDOMText *text;
6674     IXMLDOMEntityReference *entityref;
6675     IXMLDOMAttribute *attr;
6676     IXMLDOMNode *node;
6677     HRESULT hr;
6678     VARIANT data, type;
6679
6680     doc = create_document(&IID_IXMLDOMDocument);
6681
6682     /* test for unsupported types */
6683     /* NODE_DOCUMENT */
6684     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&node);
6685     ok(hr == S_OK, "ret %08x\n", hr );
6686     V_VT(&data) = VT_BSTR;
6687     V_BSTR(&data) = _bstr_("one two three");
6688     hr = IXMLDOMNode_put_nodeValue(node, data);
6689     ok(hr == E_FAIL, "ret %08x\n", hr );
6690     IXMLDOMNode_Release(node);
6691
6692     /* NODE_DOCUMENT_FRAGMENT */
6693     V_VT(&type) = VT_I1;
6694     V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
6695     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
6696     ok(hr == S_OK, "ret %08x\n", hr );
6697     V_VT(&data) = VT_BSTR;
6698     V_BSTR(&data) = _bstr_("one two three");
6699     hr = IXMLDOMNode_put_nodeValue(node, data);
6700     ok(hr == E_FAIL, "ret %08x\n", hr );
6701     IXMLDOMNode_Release(node);
6702
6703     /* NODE_ELEMENT */
6704     V_VT(&type) = VT_I1;
6705     V_I1(&type) = NODE_ELEMENT;
6706     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
6707     ok(hr == S_OK, "ret %08x\n", hr );
6708     V_VT(&data) = VT_BSTR;
6709     V_BSTR(&data) = _bstr_("one two three");
6710     hr = IXMLDOMNode_put_nodeValue(node, data);
6711     ok(hr == E_FAIL, "ret %08x\n", hr );
6712     IXMLDOMNode_Release(node);
6713
6714     /* NODE_ENTITY_REFERENCE */
6715     hr = IXMLDOMDocument_createEntityReference(doc, _bstr_("ref"), &entityref);
6716     ok(hr == S_OK, "ret %08x\n", hr );
6717
6718     V_VT(&data) = VT_BSTR;
6719     V_BSTR(&data) = _bstr_("one two three");
6720     hr = IXMLDOMEntityReference_put_nodeValue(entityref, data);
6721     ok(hr == E_FAIL, "ret %08x\n", hr );
6722
6723     hr = IXMLDOMEntityReference_QueryInterface(entityref, &IID_IXMLDOMNode, (void**)&node);
6724     ok(hr == S_OK, "ret %08x\n", hr );
6725     V_VT(&data) = VT_BSTR;
6726     V_BSTR(&data) = _bstr_("one two three");
6727     hr = IXMLDOMNode_put_nodeValue(node, data);
6728     ok(hr == E_FAIL, "ret %08x\n", hr );
6729     IXMLDOMNode_Release(node);
6730     IXMLDOMEntityReference_Release(entityref);
6731
6732     /* supported types */
6733     hr = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &text);
6734     ok(hr == S_OK, "ret %08x\n", hr );
6735     V_VT(&data) = VT_BSTR;
6736     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
6737     hr = IXMLDOMText_put_nodeValue(text, data);
6738     ok(hr == S_OK, "ret %08x\n", hr );
6739     IXMLDOMText_Release(text);
6740
6741     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
6742     ok(hr == S_OK, "ret %08x\n", hr );
6743     V_VT(&data) = VT_BSTR;
6744     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
6745     hr = IXMLDOMAttribute_put_nodeValue(attr, data);
6746     ok(hr == S_OK, "ret %08x\n", hr );
6747     hr = IXMLDOMAttribute_get_nodeValue(attr, &data);
6748     ok(hr == S_OK, "ret %08x\n", hr );
6749     ok(memcmp(V_BSTR(&data), jeevesW, sizeof(jeevesW)) == 0, "got %s\n",
6750         wine_dbgstr_w(V_BSTR(&data)));
6751     VariantClear(&data);
6752     IXMLDOMAttribute_Release(attr);
6753
6754     free_bstrs();
6755
6756     IXMLDOMDocument_Release(doc);
6757 }
6758
6759 static void test_IObjectSafety(void)
6760 {
6761     IXMLDOMDocument *doc;
6762     IObjectSafety *safety;
6763     HRESULT hr;
6764
6765     doc = create_document(&IID_IXMLDOMDocument);
6766
6767     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IObjectSafety, (void**)&safety);
6768     ok(hr == S_OK, "ret %08x\n", hr );
6769
6770     test_IObjectSafety_common(safety);
6771
6772     IObjectSafety_Release(safety);
6773     IXMLDOMDocument_Release(doc);
6774
6775     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
6776         &IID_IObjectSafety, (void**)&safety);
6777     ok(hr == S_OK, "Could not create XMLHTTPRequest instance: %08x\n", hr);
6778
6779     test_IObjectSafety_common(safety);
6780
6781     IObjectSafety_Release(safety);
6782
6783 }
6784
6785 typedef struct _property_test_t {
6786     const GUID *guid;
6787     const char *clsid;
6788     const char *property;
6789     const char *value;
6790 } property_test_t;
6791
6792 static const property_test_t properties_test_data[] = {
6793     { &CLSID_DOMDocument,  "CLSID_DOMDocument" , "SelectionLanguage", "XSLPattern" },
6794     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2" , "SelectionLanguage", "XSLPattern" },
6795     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "SelectionLanguage", "XSLPattern" },
6796     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "SelectionLanguage", "XPath" },
6797     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "SelectionLanguage", "XPath" },
6798     { 0 }
6799 };
6800
6801 static void test_default_properties(void)
6802 {
6803     const property_test_t *entry = properties_test_data;
6804
6805     while (entry->guid)
6806     {
6807         IXMLDOMDocument2 *doc;
6808         VARIANT var;
6809         HRESULT hr;
6810
6811         if (!is_clsid_supported(entry->guid, &IID_IXMLDOMDocument2))
6812         {
6813             entry++;
6814             continue;
6815         }
6816
6817         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
6818         ok(hr == S_OK, "got 0x%08x\n", hr);
6819
6820         hr = IXMLDOMDocument2_getProperty(doc, _bstr_(entry->property), &var);
6821         ok(hr == S_OK, "got 0x%08x\n", hr);
6822         ok(lstrcmpW(V_BSTR(&var), _bstr_(entry->value)) == 0, "expected %s, for %s\n",
6823            entry->value, entry->clsid);
6824         VariantClear(&var);
6825
6826         IXMLDOMDocument2_Release(doc);
6827
6828         entry++;
6829     }
6830 }
6831
6832 typedef struct {
6833     const char *query;
6834     const char *list;
6835     BOOL todo;
6836 } xslpattern_test_t;
6837
6838 static const xslpattern_test_t xslpattern_test[] = {
6839     { "root//elem[0]", "E1.E2.D1" },
6840     { "root//elem[index()=1]", "E2.E2.D1" },
6841     { "root//elem[index() $eq$ 1]", "E2.E2.D1" },
6842     { "root//elem[end()]", "E4.E2.D1" },
6843     { "root//elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
6844     { "root//elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6845     { "root//elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6846     { "root//elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
6847     { "root//elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
6848     { "root//elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
6849     { "root//elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
6850     { "root//elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
6851     { "root//elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
6852     { "root//elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
6853     { "root//elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
6854     { "root//elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
6855     { "root//elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6856     { "root//elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
6857     { "root//elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
6858     { "root//elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
6859     { "root//elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
6860     { "root//elem[$any$ *='B2 field']", "E2.E2.D1" },
6861     { "root//elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6862     { "root//elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
6863     { "root//elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
6864     { "root//elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
6865     { "root//elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6866     { "root//elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6867     { "root//elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6868     { "root/elem[0]", "E1.E2.D1" },
6869     { "root/elem[index()=1]", "E2.E2.D1" },
6870     { "root/elem[index() $eq$ 1]", "E2.E2.D1" },
6871     { "root/elem[end()]", "E4.E2.D1" },
6872     { "root/elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
6873     { "root/elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6874     { "root/elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6875     { "root/elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
6876     { "root/elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
6877     { "root/elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
6878     { "root/elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
6879     { "root/elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
6880     { "root/elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
6881     { "root/elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
6882     { "root/elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
6883     { "root/elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
6884     { "root/elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6885     { "root/elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
6886     { "root/elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
6887     { "root/elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
6888     { "root/elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
6889     { "root/elem[$any$ *='B2 field']", "E2.E2.D1" },
6890     { "root/elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6891     { "root/elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
6892     { "root/elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
6893     { "root/elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
6894     { "root/elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6895     { "root/elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6896     { "root/elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6897     { "root/elem[d]", "E1.E2.D1 E2.E2.D1 E4.E2.D1" },
6898     { "root/elem[@*]", "E2.E2.D1 E3.E2.D1", TRUE },
6899     { NULL }
6900 };
6901
6902 static const xslpattern_test_t xslpattern_test_no_ns[] = {
6903     /* prefixes don't need to be registered, you may use them as they are in the doc */
6904     { "//bar:x", "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1" },
6905     /* prefixes must be explicitly specified in the name */
6906     { "//foo:elem", "" },
6907     { "//foo:c", "E3.E4.E2.D1" },
6908     { NULL }
6909 };
6910
6911 static const xslpattern_test_t xslpattern_test_func[] = {
6912     { "attribute()", "" },
6913     { "attribute('depth')", "" },
6914     { "root/attribute('depth')", "A'depth'.E3.D1" },
6915     { "//x/attribute()", "A'id'.E3.E3.D1 A'depth'.E3.E3.D1" },
6916     { "//x//attribute(id)", NULL },
6917     { "//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" },
6918     { "comment()", "C2.D1" },
6919     { "//comment()", "C2.D1 C1.E3.D1 C2.E3.E3.D1 C2.E4.E3.D1" },
6920     { "element()", "E3.D1" },
6921     { "root/y/element()", "E4.E4.E3.D1 E5.E4.E3.D1 E6.E4.E3.D1" },
6922     { "//element(a)", NULL },
6923     { "//element('a')", "E4.E3.E3.D1 E4.E4.E3.D1" },
6924     { "node()", "P1.D1 C2.D1 E3.D1" },
6925     { "//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" },
6926     { "//x/node()[nodeType()=1]", "E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1" },
6927     { "//x/node()[nodeType()=3]", "T3.E3.E3.D1" },
6928     { "//x/node()[nodeType()=7]", "P1.E3.E3.D1" },
6929     { "//x/node()[nodeType()=8]", "C2.E3.E3.D1" },
6930     { "pi()", "P1.D1" },
6931     { "//y/pi()", "P1.E4.E3.D1" },
6932     { "root/textnode()", "T2.E3.D1" },
6933     { "root/element()/textnode()", "T3.E3.E3.D1 T3.E4.E3.D1" },
6934     { NULL }
6935 };
6936
6937 static void test_XSLPattern(void)
6938 {
6939     const xslpattern_test_t *ptr = xslpattern_test;
6940     IXMLDOMDocument2 *doc;
6941     IXMLDOMNodeList *list;
6942     VARIANT_BOOL b;
6943     HRESULT hr;
6944     LONG len;
6945
6946     doc = create_document(&IID_IXMLDOMDocument2);
6947
6948     b = VARIANT_FALSE;
6949     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
6950     EXPECT_HR(hr, S_OK);
6951     ok(b == VARIANT_TRUE, "failed to load XML string\n");
6952
6953     /* switch to XSLPattern */
6954     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern"));
6955     EXPECT_HR(hr, S_OK);
6956
6957     /* XPath doesn't select elements with non-null default namespace with unqualified selectors, XSLPattern does */
6958     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem/c"), &list);
6959     EXPECT_HR(hr, S_OK);
6960
6961     len = 0;
6962     hr = IXMLDOMNodeList_get_length(list, &len);
6963     EXPECT_HR(hr, S_OK);
6964     /* should select <elem><c> and <elem xmlns='...'><c> but not <elem><foo:c> */
6965     ok(len == 3, "expected 3 entries in list, got %d\n", len);
6966     IXMLDOMNodeList_Release(list);
6967
6968     while (ptr->query)
6969     {
6970         list = NULL;
6971         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
6972         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
6973         len = 0;
6974         hr = IXMLDOMNodeList_get_length(list, &len);
6975         ok(len != 0, "query=%s, empty list\n", ptr->query);
6976         if (len) {
6977             if (ptr->todo) {
6978                 char *str = list_to_string(list);
6979             todo_wine
6980                 ok(!strcmp(str, ptr->list), "Invalid node list: %s, expected %s\n", str, ptr->list);
6981                 IXMLDOMNodeList_Release(list);
6982             }
6983             else
6984                 expect_list_and_release(list, ptr->list);
6985         }
6986
6987         ptr++;
6988     }
6989
6990     /* namespace handling */
6991     /* no registered namespaces */
6992     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_(""));
6993     EXPECT_HR(hr, S_OK);
6994
6995     ptr = xslpattern_test_no_ns;
6996     while (ptr->query)
6997     {
6998         list = NULL;
6999         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
7000         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7001
7002         if (*ptr->list)
7003         {
7004             len = 0;
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         else
7010         {
7011             len = 1;
7012             hr = IXMLDOMNodeList_get_length(list, &len);
7013             EXPECT_HR(hr, S_OK);
7014             ok(len == 0, "query=%s, empty list\n", ptr->query);
7015         }
7016         if (len)
7017             expect_list_and_release(list, ptr->list);
7018
7019         ptr++;
7020     }
7021
7022     /* explicitly register prefix foo */
7023     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
7024
7025     /* now we get the same behavior as XPath */
7026     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
7027     EXPECT_HR(hr, S_OK);
7028     len = 0;
7029     hr = IXMLDOMNodeList_get_length(list, &len);
7030     EXPECT_HR(hr, S_OK);
7031     ok(len != 0, "expected filled list\n");
7032     if (len)
7033         expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
7034
7035     /* set prefix foo to some nonexistent namespace */
7036     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:nonexistent-foo'"));
7037     EXPECT_HR(hr, S_OK);
7038
7039     /* the registered prefix takes precedence */
7040     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
7041     EXPECT_HR(hr, S_OK);
7042     len = 0;
7043     hr = IXMLDOMNodeList_get_length(list, &len);
7044     EXPECT_HR(hr, S_OK);
7045     ok(len == 0, "expected empty list\n");
7046     IXMLDOMNodeList_Release(list);
7047
7048     IXMLDOMDocument2_Release(doc);
7049
7050     doc = create_document(&IID_IXMLDOMDocument2);
7051
7052     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNodeTypesXML), &b);
7053     EXPECT_HR(hr, S_OK);
7054     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7055
7056     ptr = xslpattern_test_func;
7057     while (ptr->query)
7058     {
7059         list = NULL;
7060         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
7061         if (ptr->list)
7062         {
7063             ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7064             len = 0;
7065             hr = IXMLDOMNodeList_get_length(list, &len);
7066             if (*ptr->list)
7067             {
7068                 ok(len != 0, "query=%s, empty list\n", ptr->query);
7069                 if (len)
7070                     expect_list_and_release(list, ptr->list);
7071             }
7072             else
7073                 ok(len == 0, "query=%s, filled list\n", ptr->query);
7074         }
7075         else
7076             ok(hr == E_FAIL, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7077
7078         ptr++;
7079     }
7080
7081     IXMLDOMDocument2_Release(doc);
7082     free_bstrs();
7083 }
7084
7085 static void test_splitText(void)
7086 {
7087     IXMLDOMCDATASection *cdata;
7088     IXMLDOMElement *root;
7089     IXMLDOMDocument *doc;
7090     IXMLDOMText *text, *text2;
7091     IXMLDOMNode *node;
7092     VARIANT var;
7093     VARIANT_BOOL success;
7094     LONG length;
7095     HRESULT hr;
7096
7097     doc = create_document(&IID_IXMLDOMDocument);
7098
7099     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<root></root>"), &success);
7100     ok(hr == S_OK, "got 0x%08x\n", hr);
7101
7102     hr = IXMLDOMDocument_get_documentElement(doc, &root);
7103     ok(hr == S_OK, "got 0x%08x\n", hr);
7104
7105     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("beautiful plumage"), &cdata);
7106     ok(hr == S_OK, "got 0x%08x\n", hr);
7107
7108     V_VT(&var) = VT_EMPTY;
7109     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)cdata, NULL);
7110     ok(hr == S_OK, "got 0x%08x\n", hr);
7111
7112     length = 0;
7113     hr = IXMLDOMCDATASection_get_length(cdata, &length);
7114     ok(hr == S_OK, "got 0x%08x\n", hr);
7115     ok(length > 0, "got %d\n", length);
7116
7117     hr = IXMLDOMCDATASection_splitText(cdata, 0, NULL);
7118     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7119
7120     text = (void*)0xdeadbeef;
7121     /* negative offset */
7122     hr = IXMLDOMCDATASection_splitText(cdata, -1, &text);
7123     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7124     ok(text == (void*)0xdeadbeef, "got %p\n", text);
7125
7126     text = (void*)0xdeadbeef;
7127     /* offset outside data */
7128     hr = IXMLDOMCDATASection_splitText(cdata, length + 1, &text);
7129     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7130     ok(text == 0, "got %p\n", text);
7131
7132     text = (void*)0xdeadbeef;
7133     /* offset outside data */
7134     hr = IXMLDOMCDATASection_splitText(cdata, length, &text);
7135     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7136     ok(text == 0, "got %p\n", text);
7137
7138     /* no empty node created */
7139     node = (void*)0xdeadbeef;
7140     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7141     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7142     ok(node == 0, "got %p\n", text);
7143
7144     hr = IXMLDOMCDATASection_splitText(cdata, 10, &text);
7145     ok(hr == S_OK, "got 0x%08x\n", hr);
7146
7147     length = 0;
7148     hr = IXMLDOMText_get_length(text, &length);
7149     ok(hr == S_OK, "got 0x%08x\n", hr);
7150     ok(length == 7, "got %d\n", length);
7151
7152     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7153     ok(hr == S_OK, "got 0x%08x\n", hr);
7154     IXMLDOMNode_Release(node);
7155
7156     /* split new text node */
7157     hr = IXMLDOMText_get_length(text, &length);
7158     ok(hr == S_OK, "got 0x%08x\n", hr);
7159
7160     node = (void*)0xdeadbeef;
7161     hr = IXMLDOMText_get_nextSibling(text, &node);
7162     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7163     ok(node == 0, "got %p\n", text);
7164
7165     hr = IXMLDOMText_splitText(text, 0, NULL);
7166     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7167
7168     text2 = (void*)0xdeadbeef;
7169     /* negative offset */
7170     hr = IXMLDOMText_splitText(text, -1, &text2);
7171     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7172     ok(text2 == (void*)0xdeadbeef, "got %p\n", text2);
7173
7174     text2 = (void*)0xdeadbeef;
7175     /* offset outside data */
7176     hr = IXMLDOMText_splitText(text, length + 1, &text2);
7177     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7178     ok(text2 == 0, "got %p\n", text2);
7179
7180     text2 = (void*)0xdeadbeef;
7181     /* offset outside data */
7182     hr = IXMLDOMText_splitText(text, length, &text2);
7183     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7184     ok(text2 == 0, "got %p\n", text);
7185
7186     text2 = 0;
7187     hr = IXMLDOMText_splitText(text, 4, &text2);
7188     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7189     if (text2) IXMLDOMText_Release(text2);
7190
7191     node = 0;
7192     hr = IXMLDOMText_get_nextSibling(text, &node);
7193     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7194     if (node) IXMLDOMNode_Release(node);
7195
7196     IXMLDOMText_Release(text);
7197     IXMLDOMElement_Release(root);
7198     IXMLDOMCDATASection_Release(cdata);
7199     free_bstrs();
7200 }
7201
7202 typedef struct {
7203     const char *name;
7204     const char *uri;
7205     HRESULT hr;
7206 } ns_item_t;
7207
7208 /* default_ns_doc used */
7209 static const ns_item_t qualified_item_tests[] = {
7210     { "xml:lang", NULL, S_FALSE },
7211     { "xml:lang", "http://www.w3.org/XML/1998/namespace", S_FALSE },
7212     { "lang", "http://www.w3.org/XML/1998/namespace", S_OK },
7213     { "ns:b", NULL, S_FALSE },
7214     { "ns:b", "nshref", S_FALSE },
7215     { "b", "nshref", S_OK },
7216     { "d", NULL, S_OK },
7217     { NULL }
7218 };
7219
7220 static const ns_item_t named_item_tests[] = {
7221     { "xml:lang", NULL, S_OK },
7222     { "lang", NULL, S_FALSE },
7223     { "ns:b", NULL, S_OK },
7224     { "b", NULL, S_FALSE },
7225     { "d", NULL, S_OK },
7226     { NULL }
7227 };
7228
7229 static void test_getQualifiedItem(void)
7230 {
7231     IXMLDOMNode *pr_node, *node;
7232     IXMLDOMNodeList *root_list;
7233     IXMLDOMNamedNodeMap *map;
7234     IXMLDOMElement *element;
7235     const ns_item_t* ptr;
7236     IXMLDOMDocument *doc;
7237     VARIANT_BOOL b;
7238     HRESULT hr;
7239     LONG len;
7240
7241     doc = create_document(&IID_IXMLDOMDocument);
7242
7243     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7244     EXPECT_HR(hr, S_OK);
7245     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7246
7247     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7248     EXPECT_HR(hr, S_OK);
7249
7250     hr = IXMLDOMElement_get_childNodes(element, &root_list);
7251     EXPECT_HR(hr, S_OK);
7252
7253     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7254     EXPECT_HR(hr, S_OK);
7255     IXMLDOMNodeList_Release(root_list);
7256
7257     hr = IXMLDOMNode_get_attributes(pr_node, &map);
7258     EXPECT_HR(hr, S_OK);
7259     IXMLDOMNode_Release(pr_node);
7260
7261     len = 0;
7262     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7263     EXPECT_HR(hr, S_OK);
7264     ok( len == 3, "length %d\n", len);
7265
7266     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, NULL);
7267     EXPECT_HR(hr, E_INVALIDARG);
7268
7269     node = (void*)0xdeadbeef;
7270     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, &node);
7271     EXPECT_HR(hr, E_INVALIDARG);
7272     ok( node == (void*)0xdeadbeef, "got %p\n", node);
7273
7274     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, NULL);
7275     EXPECT_HR(hr, E_INVALIDARG);
7276
7277     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, &node);
7278     EXPECT_HR(hr, S_OK);
7279
7280     IXMLDOMNode_Release(node);
7281     IXMLDOMNamedNodeMap_Release(map);
7282     IXMLDOMElement_Release(element);
7283
7284     hr = IXMLDOMDocument_loadXML(doc, _bstr_(default_ns_doc), &b);
7285     EXPECT_HR(hr, S_OK);
7286
7287     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("a"), &node);
7288     EXPECT_HR(hr, S_OK);
7289
7290     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&element);
7291     EXPECT_HR(hr, S_OK);
7292     IXMLDOMNode_Release(node);
7293
7294     hr = IXMLDOMElement_get_attributes(element, &map);
7295     EXPECT_HR(hr, S_OK);
7296
7297     ptr = qualified_item_tests;
7298     while (ptr->name)
7299     {
7300        node = (void*)0xdeadbeef;
7301        hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
7302        ok(hr == ptr->hr, "%s, %s: got 0x%08x, expected 0x%08x\n", ptr->name, ptr->uri, hr, ptr->hr);
7303        if (hr == S_OK)
7304            IXMLDOMNode_Release(node);
7305        else
7306            ok(node == NULL, "%s, %s: got %p\n", ptr->name, ptr->uri, node);
7307        ptr++;
7308     }
7309
7310     ptr = named_item_tests;
7311     while (ptr->name)
7312     {
7313        node = (void*)0xdeadbeef;
7314        hr = IXMLDOMNamedNodeMap_getNamedItem(map, _bstr_(ptr->name), &node);
7315        ok(hr == ptr->hr, "%s: got 0x%08x, expected 0x%08x\n", ptr->name, hr, ptr->hr);
7316        if (hr == S_OK)
7317            IXMLDOMNode_Release(node);
7318        else
7319            ok(node == NULL, "%s: got %p\n", ptr->name, node);
7320        ptr++;
7321     }
7322
7323     IXMLDOMNamedNodeMap_Release(map);
7324
7325     IXMLDOMElement_Release(element);
7326     IXMLDOMDocument_Release(doc);
7327     free_bstrs();
7328 }
7329
7330 static void test_removeQualifiedItem(void)
7331 {
7332     IXMLDOMDocument *doc;
7333     IXMLDOMElement *element;
7334     IXMLDOMNode *pr_node, *node;
7335     IXMLDOMNodeList *root_list;
7336     IXMLDOMNamedNodeMap *map;
7337     VARIANT_BOOL b;
7338     LONG len;
7339     HRESULT hr;
7340
7341     doc = create_document(&IID_IXMLDOMDocument);
7342
7343     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7344     ok( hr == S_OK, "loadXML failed\n");
7345     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7346
7347     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7348     ok( hr == S_OK, "ret %08x\n", hr);
7349
7350     hr = IXMLDOMElement_get_childNodes(element, &root_list);
7351     ok( hr == S_OK, "ret %08x\n", hr);
7352
7353     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7354     ok( hr == S_OK, "ret %08x\n", hr);
7355     IXMLDOMNodeList_Release(root_list);
7356
7357     hr = IXMLDOMNode_get_attributes(pr_node, &map);
7358     ok( hr == S_OK, "ret %08x\n", hr);
7359     IXMLDOMNode_Release(pr_node);
7360
7361     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7362     ok( hr == S_OK, "ret %08x\n", hr);
7363     ok( len == 3, "length %d\n", len);
7364
7365     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, NULL);
7366     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7367
7368     node = (void*)0xdeadbeef;
7369     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, &node);
7370     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7371     ok( node == (void*)0xdeadbeef, "got %p\n", node);
7372
7373     /* out pointer is optional */
7374     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7375     ok( hr == S_OK, "ret %08x\n", hr);
7376
7377     /* already removed */
7378     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7379     ok( hr == S_FALSE, "ret %08x\n", hr);
7380
7381     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("vr"), NULL, &node);
7382     ok( hr == S_OK, "ret %08x\n", hr);
7383     IXMLDOMNode_Release(node);
7384
7385     IXMLDOMNamedNodeMap_Release( map );
7386     IXMLDOMElement_Release( element );
7387     IXMLDOMDocument_Release( doc );
7388     free_bstrs();
7389 }
7390
7391 #define check_default_props(doc) _check_default_props(__LINE__, doc)
7392 static inline void _check_default_props(int line, IXMLDOMDocument2* doc)
7393 {
7394     VARIANT_BOOL b;
7395     VARIANT var;
7396     HRESULT hr;
7397
7398     VariantInit(&var);
7399     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
7400     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XSLPattern")) == 0, "expected XSLPattern\n");
7401     VariantClear(&var);
7402
7403     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
7404     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("")) == 0, "expected empty string\n");
7405     VariantClear(&var);
7406
7407     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
7408     ok_(__FILE__, line)(b == VARIANT_FALSE, "expected FALSE\n");
7409
7410     hr = IXMLDOMDocument2_get_schemas(doc, &var);
7411     ok_(__FILE__, line)(hr == S_FALSE, "got %08x\n", hr);
7412     VariantClear(&var);
7413 }
7414
7415 #define check_set_props(doc) _check_set_props(__LINE__, doc)
7416 static inline void _check_set_props(int line, IXMLDOMDocument2* doc)
7417 {
7418     VARIANT_BOOL b;
7419     VARIANT var;
7420
7421     VariantInit(&var);
7422     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
7423     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XPath")) == 0, "expected XPath\n");
7424     VariantClear(&var);
7425
7426     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
7427     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("xmlns:wi=\'www.winehq.org\'")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&var)));
7428     VariantClear(&var);
7429
7430     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
7431     ok_(__FILE__, line)(b == VARIANT_TRUE, "expected TRUE\n");
7432
7433     helper_ole_check(IXMLDOMDocument2_get_schemas(doc, &var));
7434     ok_(__FILE__, line)(V_VT(&var) != VT_NULL, "expected pointer\n");
7435     VariantClear(&var);
7436 }
7437
7438 #define set_props(doc, cache) _set_props(__LINE__, doc, cache)
7439 static inline void _set_props(int line, IXMLDOMDocument2* doc, IXMLDOMSchemaCollection* cache)
7440 {
7441     VARIANT var;
7442
7443     VariantInit(&var);
7444     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
7445     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:wi=\'www.winehq.org\'")));
7446     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_TRUE));
7447     V_VT(&var) = VT_DISPATCH;
7448     V_DISPATCH(&var) = NULL;
7449     helper_ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&var)));
7450     ok_(__FILE__, line)(V_DISPATCH(&var) != NULL, "expected pointer\n");
7451     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
7452     VariantClear(&var);
7453 }
7454
7455 #define unset_props(doc) _unset_props(__LINE__, doc)
7456 static inline void _unset_props(int line, IXMLDOMDocument2* doc)
7457 {
7458     VARIANT var;
7459
7460     VariantInit(&var);
7461     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
7462     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("")));
7463     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_FALSE));
7464     V_VT(&var) = VT_NULL;
7465     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
7466     VariantClear(&var);
7467 }
7468
7469 static void test_get_ownerDocument(void)
7470 {
7471     IXMLDOMDocument *doc1, *doc2, *doc3;
7472     IXMLDOMDocument2 *doc, *doc_owner;
7473     IXMLDOMNode *node;
7474     IXMLDOMSchemaCollection *cache;
7475     VARIANT_BOOL b;
7476     VARIANT var;
7477
7478     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
7479     if (!is_clsid_supported(&CLSID_XMLSchemaCache, &IID_IXMLDOMSchemaCollection)) return;
7480
7481     doc = create_document(&IID_IXMLDOMDocument2);
7482     cache = create_cache(&IID_IXMLDOMSchemaCollection);
7483
7484     VariantInit(&var);
7485
7486     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
7487     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7488
7489     check_default_props(doc);
7490
7491     /* set properties and check that new instances use them */
7492     set_props(doc, cache);
7493     check_set_props(doc);
7494
7495     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
7496     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc1));
7497
7498     /* new interface keeps props */
7499     ole_check(IXMLDOMDocument_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**)&doc_owner));
7500     ok( doc_owner != doc, "got %p, doc %p\n", doc_owner, doc);
7501     check_set_props(doc_owner);
7502     IXMLDOMDocument2_Release(doc_owner);
7503
7504     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc2));
7505     IXMLDOMNode_Release(node);
7506
7507     ok(doc1 != doc2, "got %p, expected %p. original %p\n", doc2, doc1, doc);
7508
7509     /* reload */
7510     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
7511     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7512
7513     /* properties retained even after reload */
7514     check_set_props(doc);
7515
7516     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
7517     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc3));
7518     IXMLDOMNode_Release(node);
7519
7520     ole_check(IXMLDOMDocument_QueryInterface(doc3, &IID_IXMLDOMDocument2, (void**)&doc_owner));
7521     ok(doc3 != doc1 && doc3 != doc2 && doc_owner != doc, "got %p, (%p, %p, %p)\n", doc3, doc, doc1, doc2);
7522     check_set_props(doc_owner);
7523
7524     /* changing properties for one instance changes them for all */
7525     unset_props(doc_owner);
7526     check_default_props(doc_owner);
7527     check_default_props(doc);
7528
7529     IXMLDOMSchemaCollection_Release(cache);
7530     IXMLDOMDocument_Release(doc1);
7531     IXMLDOMDocument_Release(doc2);
7532     IXMLDOMDocument_Release(doc3);
7533     IXMLDOMDocument2_Release(doc);
7534     IXMLDOMDocument2_Release(doc_owner);
7535     free_bstrs();
7536 }
7537
7538 static void test_setAttributeNode(void)
7539 {
7540     IXMLDOMDocument *doc, *doc2;
7541     IXMLDOMElement *elem, *elem2;
7542     IXMLDOMAttribute *attr, *attr2, *ret_attr;
7543     VARIANT_BOOL b;
7544     HRESULT hr;
7545     VARIANT v;
7546     BSTR str;
7547     ULONG ref1, ref2;
7548
7549     doc = create_document(&IID_IXMLDOMDocument);
7550
7551     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7552     ok( hr == S_OK, "loadXML failed\n");
7553     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7554
7555     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7556     ok( hr == S_OK, "got 0x%08x\n", hr);
7557
7558     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
7559     ok( hr == S_OK, "got 0x%08x\n", hr);
7560     ok( elem2 != elem, "got same instance\n");
7561
7562     ret_attr = (void*)0xdeadbeef;
7563     hr = IXMLDOMElement_setAttributeNode(elem, NULL, &ret_attr);
7564     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
7565     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7566
7567     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
7568     ok( hr == S_OK, "got 0x%08x\n", hr);
7569
7570     ref1 = IXMLDOMElement_AddRef(elem);
7571     IXMLDOMElement_Release(elem);
7572
7573     ret_attr = (void*)0xdeadbeef;
7574     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7575     ok( hr == S_OK, "got 0x%08x\n", hr);
7576     ok( ret_attr == NULL, "got %p\n", ret_attr);
7577
7578     /* no reference added */
7579     ref2 = IXMLDOMElement_AddRef(elem);
7580     IXMLDOMElement_Release(elem);
7581     ok(ref2 == ref1, "got %d, expected %d\n", ref2, ref1);
7582
7583     EXPECT_CHILDREN(elem);
7584     EXPECT_CHILDREN(elem2);
7585
7586     IXMLDOMElement_Release(elem2);
7587
7588     attr2 = NULL;
7589     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attr"), &attr2);
7590     ok( hr == S_OK, "got 0x%08x\n", hr);
7591     ok( attr2 != attr, "got same instance %p\n", attr2);
7592     IXMLDOMAttribute_Release(attr2);
7593
7594     /* try to add it another time */
7595     ret_attr = (void*)0xdeadbeef;
7596     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7597     ok( hr == E_FAIL, "got 0x%08x\n", hr);
7598     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7599
7600     IXMLDOMElement_Release(elem);
7601
7602     /* initially used element is released, attribute still 'has' a container */
7603     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7604     ok( hr == S_OK, "got 0x%08x\n", hr);
7605     ret_attr = (void*)0xdeadbeef;
7606     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7607     ok( hr == E_FAIL, "got 0x%08x\n", hr);
7608     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7609     IXMLDOMElement_Release(elem);
7610
7611     /* add attribute already attached to another document */
7612     doc2 = create_document(&IID_IXMLDOMDocument);
7613
7614     hr = IXMLDOMDocument_loadXML( doc2, _bstr_(complete4A), &b );
7615     ok( hr == S_OK, "loadXML failed\n");
7616     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7617
7618     hr = IXMLDOMDocument_get_documentElement(doc2, &elem);
7619     ok( hr == S_OK, "got 0x%08x\n", hr);
7620     hr = IXMLDOMElement_setAttributeNode(elem, attr, NULL);
7621     ok( hr == E_FAIL, "got 0x%08x\n", hr);
7622     IXMLDOMElement_Release(elem);
7623
7624     IXMLDOMAttribute_Release(attr);
7625
7626     /* create element, add attribute, see if it's copied or linked */
7627     hr = IXMLDOMDocument_createElement(doc, _bstr_("test"), &elem);
7628     ok( hr == S_OK, "got 0x%08x\n", hr);
7629
7630     attr = NULL;
7631     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
7632     ok(hr == S_OK, "got 0x%08x\n", hr);
7633     ok(attr != NULL, "got %p\n", attr);
7634
7635     ref1 = IXMLDOMAttribute_AddRef(attr);
7636     IXMLDOMAttribute_Release(attr);
7637
7638     V_VT(&v) = VT_BSTR;
7639     V_BSTR(&v) = _bstr_("attrvalue1");
7640     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
7641     ok( hr == S_OK, "got 0x%08x\n", hr);
7642
7643     str = NULL;
7644     hr = IXMLDOMAttribute_get_xml(attr, &str);
7645     ok( hr == S_OK, "got 0x%08x\n", hr);
7646     ok( lstrcmpW(str, _bstr_("attr=\"attrvalue1\"")) == 0,
7647         "got %s\n", wine_dbgstr_w(str));
7648     SysFreeString(str);
7649
7650     ret_attr = (void*)0xdeadbeef;
7651     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7652     ok(hr == S_OK, "got 0x%08x\n", hr);
7653     ok(ret_attr == NULL, "got %p\n", ret_attr);
7654
7655     /* attribute reference increased */
7656     ref2 = IXMLDOMAttribute_AddRef(attr);
7657     IXMLDOMAttribute_Release(attr);
7658     ok(ref1 == ref2, "got %d, expected %d\n", ref2, ref1);
7659
7660     hr = IXMLDOMElement_get_xml(elem, &str);
7661     ok( hr == S_OK, "got 0x%08x\n", hr);
7662     ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue1\"/>")) == 0,
7663         "got %s\n", wine_dbgstr_w(str));
7664     SysFreeString(str);
7665
7666     V_VT(&v) = VT_BSTR;
7667     V_BSTR(&v) = _bstr_("attrvalue2");
7668     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
7669     ok( hr == S_OK, "got 0x%08x\n", hr);
7670
7671     hr = IXMLDOMElement_get_xml(elem, &str);
7672     ok( hr == S_OK, "got 0x%08x\n", hr);
7673     todo_wine ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue2\"/>")) == 0,
7674         "got %s\n", wine_dbgstr_w(str));
7675     SysFreeString(str);
7676
7677     IXMLDOMElement_Release(elem);
7678     IXMLDOMAttribute_Release(attr);
7679     IXMLDOMDocument_Release(doc2);
7680     IXMLDOMDocument_Release(doc);
7681     free_bstrs();
7682 }
7683
7684 static void test_createNode(void)
7685 {
7686     IXMLDOMDocument *doc;
7687     IXMLDOMElement *elem;
7688     IXMLDOMNode *node;
7689     VARIANT v, var;
7690     BSTR prefix, str;
7691     HRESULT hr;
7692     ULONG ref;
7693
7694     doc = create_document(&IID_IXMLDOMDocument);
7695
7696     EXPECT_REF(doc, 1);
7697
7698     /* reference count tests */
7699     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
7700     ok( hr == S_OK, "got 0x%08x\n", hr);
7701
7702     /* initial reference is 2 */
7703 todo_wine {
7704     EXPECT_REF(elem, 2);
7705     ref = IXMLDOMElement_Release(elem);
7706     ok(ref == 1, "got %d\n", ref);
7707     /* it's released already, attempt to release now will crash it */
7708 }
7709
7710     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
7711     ok( hr == S_OK, "got 0x%08x\n", hr);
7712     todo_wine EXPECT_REF(elem, 2);
7713     IXMLDOMDocument_Release(doc);
7714     todo_wine EXPECT_REF(elem, 2);
7715     IXMLDOMElement_Release(elem);
7716
7717     doc = create_document(&IID_IXMLDOMDocument);
7718
7719     /* NODE_ELEMENT nodes */
7720     /* 1. specified namespace */
7721     V_VT(&v) = VT_I4;
7722     V_I4(&v) = NODE_ELEMENT;
7723
7724     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("ns1:test"), _bstr_("http://winehq.org"), &node);
7725     ok( hr == S_OK, "got 0x%08x\n", hr);
7726     prefix = NULL;
7727     hr = IXMLDOMNode_get_prefix(node, &prefix);
7728     ok( hr == S_OK, "got 0x%08x\n", hr);
7729     ok(lstrcmpW(prefix, _bstr_("ns1")) == 0, "wrong prefix\n");
7730     SysFreeString(prefix);
7731     IXMLDOMNode_Release(node);
7732
7733     /* 2. default namespace */
7734     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("test"), _bstr_("http://winehq.org/default"), &node);
7735     ok( hr == S_OK, "got 0x%08x\n", hr);
7736     prefix = (void*)0xdeadbeef;
7737     hr = IXMLDOMNode_get_prefix(node, &prefix);
7738     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7739     ok(prefix == 0, "expected empty prefix, got %p\n", prefix);
7740     /* check dump */
7741     hr = IXMLDOMNode_get_xml(node, &str);
7742     ok( hr == S_OK, "got 0x%08x\n", hr);
7743     ok( lstrcmpW(str, _bstr_("<test xmlns=\"http://winehq.org/default\"/>")) == 0,
7744         "got %s\n", wine_dbgstr_w(str));
7745     SysFreeString(str);
7746
7747     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
7748     ok( hr == S_OK, "got 0x%08x\n", hr);
7749
7750     V_VT(&var) = VT_BSTR;
7751     hr = IXMLDOMElement_getAttribute(elem, _bstr_("xmlns"), &var);
7752     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7753     ok( V_VT(&var) == VT_NULL, "got %d\n", V_VT(&var));
7754
7755     str = NULL;
7756     hr = IXMLDOMElement_get_namespaceURI(elem, &str);
7757     ok( hr == S_OK, "got 0x%08x\n", hr);
7758     ok( lstrcmpW(str, _bstr_("http://winehq.org/default")) == 0, "expected default namespace\n");
7759     SysFreeString(str);
7760
7761     IXMLDOMElement_Release(elem);
7762     IXMLDOMNode_Release(node);
7763
7764     IXMLDOMDocument_Release(doc);
7765     free_bstrs();
7766 }
7767
7768 static const char get_prefix_doc[] =
7769     "<?xml version=\"1.0\" ?>"
7770     "<a xmlns:ns1=\"ns1 href\" />";
7771
7772 static void test_get_prefix(void)
7773 {
7774     IXMLDOMDocumentFragment *fragment;
7775     IXMLDOMCDATASection *cdata;
7776     IXMLDOMElement *element;
7777     IXMLDOMComment *comment;
7778     IXMLDOMDocument *doc;
7779     VARIANT_BOOL b;
7780     HRESULT hr;
7781     BSTR str;
7782
7783     doc = create_document(&IID_IXMLDOMDocument);
7784
7785     /* nodes that can't support prefix */
7786     /* 1. document */
7787     str = (void*)0xdeadbeef;
7788     hr = IXMLDOMDocument_get_prefix(doc, &str);
7789     EXPECT_HR(hr, S_FALSE);
7790     ok(str == NULL, "got %p\n", str);
7791
7792     hr = IXMLDOMDocument_get_prefix(doc, NULL);
7793     EXPECT_HR(hr, E_INVALIDARG);
7794
7795     /* 2. cdata */
7796     hr = IXMLDOMDocument_createCDATASection(doc, NULL, &cdata);
7797     ok(hr == S_OK, "got %08x\n", hr );
7798
7799     str = (void*)0xdeadbeef;
7800     hr = IXMLDOMCDATASection_get_prefix(cdata, &str);
7801     ok(hr == S_FALSE, "got %08x\n", hr);
7802     ok( str == 0, "got %p\n", str);
7803
7804     hr = IXMLDOMCDATASection_get_prefix(cdata, NULL);
7805     ok(hr == E_INVALIDARG, "got %08x\n", hr);
7806     IXMLDOMCDATASection_Release(cdata);
7807
7808     /* 3. comment */
7809     hr = IXMLDOMDocument_createComment(doc, NULL, &comment);
7810     ok(hr == S_OK, "got %08x\n", hr );
7811
7812     str = (void*)0xdeadbeef;
7813     hr = IXMLDOMComment_get_prefix(comment, &str);
7814     ok(hr == S_FALSE, "got %08x\n", hr);
7815     ok( str == 0, "got %p\n", str);
7816
7817     hr = IXMLDOMComment_get_prefix(comment, NULL);
7818     ok(hr == E_INVALIDARG, "got %08x\n", hr);
7819     IXMLDOMComment_Release(comment);
7820
7821     /* 4. fragment */
7822     hr = IXMLDOMDocument_createDocumentFragment(doc, &fragment);
7823     ok(hr == S_OK, "got %08x\n", hr );
7824
7825     str = (void*)0xdeadbeef;
7826     hr = IXMLDOMDocumentFragment_get_prefix(fragment, &str);
7827     ok(hr == S_FALSE, "got %08x\n", hr);
7828     ok( str == 0, "got %p\n", str);
7829
7830     hr = IXMLDOMDocumentFragment_get_prefix(fragment, NULL);
7831     ok(hr == E_INVALIDARG, "got %08x\n", hr);
7832     IXMLDOMDocumentFragment_Release(fragment);
7833
7834     /* no prefix */
7835     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &element);
7836     ok( hr == S_OK, "got 0x%08x\n", hr);
7837
7838     hr = IXMLDOMElement_get_prefix(element, NULL);
7839     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
7840
7841     str = (void*)0xdeadbeef;
7842     hr = IXMLDOMElement_get_prefix(element, &str);
7843     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7844     ok( str == 0, "got %p\n", str);
7845
7846     IXMLDOMElement_Release(element);
7847
7848     /* with prefix */
7849     hr = IXMLDOMDocument_createElement(doc, _bstr_("a:elem"), &element);
7850     ok( hr == S_OK, "got 0x%08x\n", hr);
7851
7852     str = (void*)0xdeadbeef;
7853     hr = IXMLDOMElement_get_prefix(element, &str);
7854     ok( hr == S_OK, "got 0x%08x\n", hr);
7855     ok( lstrcmpW(str, _bstr_("a")) == 0, "expected prefix \"a\"\n");
7856     SysFreeString(str);
7857
7858     str = (void*)0xdeadbeef;
7859     hr = IXMLDOMElement_get_namespaceURI(element, &str);
7860     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7861     ok( str == 0, "got %p\n", str);
7862
7863     IXMLDOMElement_Release(element);
7864
7865     hr = IXMLDOMDocument_loadXML(doc, _bstr_(get_prefix_doc), &b);
7866     EXPECT_HR(hr, S_OK);
7867
7868     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7869     EXPECT_HR(hr, S_OK);
7870
7871     str = (void*)0xdeadbeef;
7872     hr = IXMLDOMElement_get_prefix(element, &str);
7873     EXPECT_HR(hr, S_FALSE);
7874     ok(str == NULL, "got %p\n", str);
7875
7876     str = (void*)0xdeadbeef;
7877     hr = IXMLDOMElement_get_namespaceURI(element, &str);
7878     EXPECT_HR(hr, S_FALSE);
7879     ok(str == NULL, "got %s\n", wine_dbgstr_w(str));
7880
7881     IXMLDOMDocument_Release(doc);
7882     free_bstrs();
7883 }
7884
7885 static void test_selectSingleNode(void)
7886 {
7887     IXMLDOMDocument *doc;
7888     IXMLDOMNodeList *list;
7889     IXMLDOMNode *node;
7890     VARIANT_BOOL b;
7891     HRESULT hr;
7892     LONG len;
7893
7894     doc = create_document(&IID_IXMLDOMDocument);
7895
7896     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
7897     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7898
7899     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
7900     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7901
7902     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7903     ok( hr == S_OK, "loadXML failed\n");
7904     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7905
7906     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
7907     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7908
7909     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
7910     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7911
7912     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), NULL);
7913     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7914
7915     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), NULL);
7916     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7917
7918     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), &node);
7919     ok(hr == S_OK, "got 0x%08x\n", hr);
7920     IXMLDOMNode_Release(node);
7921
7922     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), &list);
7923     ok(hr == S_OK, "got 0x%08x\n", hr);
7924     IXMLDOMNodeList_Release(list);
7925
7926     list = (void*)0xdeadbeef;
7927     hr = IXMLDOMDocument_selectNodes(doc, NULL, &list);
7928     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7929     ok(list == (void*)0xdeadbeef, "got %p\n", list);
7930
7931     node = (void*)0xdeadbeef;
7932     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("nonexistent"), &node);
7933     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7934     ok(node == 0, "got %p\n", node);
7935
7936     list = (void*)0xdeadbeef;
7937     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("nonexistent"), &list);
7938     ok(hr == S_OK, "got 0x%08x\n", hr);
7939     len = 1;
7940     hr = IXMLDOMNodeList_get_length(list, &len);
7941     ok(hr == S_OK, "got 0x%08x\n", hr);
7942     ok(len == 0, "got %d\n", len);
7943     IXMLDOMNodeList_Release(list);
7944
7945     IXMLDOMDocument_Release(doc);
7946     free_bstrs();
7947 }
7948
7949 static void test_events(void)
7950 {
7951     IConnectionPointContainer *conn;
7952     IConnectionPoint *point;
7953     IXMLDOMDocument *doc;
7954     HRESULT hr;
7955     VARIANT v;
7956     IDispatch *event;
7957
7958     doc = create_document(&IID_IXMLDOMDocument);
7959
7960     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&conn);
7961     ok(hr == S_OK, "got 0x%08x\n", hr);
7962
7963     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IDispatch, &point);
7964     ok(hr == S_OK, "got 0x%08x\n", hr);
7965     IConnectionPoint_Release(point);
7966     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IPropertyNotifySink, &point);
7967     ok(hr == S_OK, "got 0x%08x\n", hr);
7968     IConnectionPoint_Release(point);
7969     hr = IConnectionPointContainer_FindConnectionPoint(conn, &DIID_XMLDOMDocumentEvents, &point);
7970     ok(hr == S_OK, "got 0x%08x\n", hr);
7971     IConnectionPoint_Release(point);
7972
7973     IConnectionPointContainer_Release(conn);
7974
7975     /* ready state callback */
7976     VariantInit(&v);
7977     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7978     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
7979
7980     event = create_dispevent();
7981     V_VT(&v) = VT_UNKNOWN;
7982     V_UNKNOWN(&v) = (IUnknown*)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     V_VT(&v) = VT_DISPATCH;
7989     V_DISPATCH(&v) = event;
7990
7991     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7992     ok(hr == S_OK, "got 0x%08x\n", hr);
7993     EXPECT_REF(event, 2);
7994
7995     /* VT_NULL doesn't reset event handler */
7996     V_VT(&v) = VT_NULL;
7997     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7998     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
7999     EXPECT_REF(event, 2);
8000
8001     V_VT(&v) = VT_DISPATCH;
8002     V_DISPATCH(&v) = NULL;
8003
8004     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8005     ok(hr == S_OK, "got 0x%08x\n", hr);
8006     EXPECT_REF(event, 1);
8007
8008     V_VT(&v) = VT_UNKNOWN;
8009     V_DISPATCH(&v) = NULL;
8010     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8011     ok(hr == S_OK, "got 0x%08x\n", hr);
8012
8013     IDispatch_Release(event);
8014
8015     IXMLDOMDocument_Release(doc);
8016 }
8017
8018 static void test_createProcessingInstruction(void)
8019 {
8020     static const WCHAR bodyW[] = {'t','e','s','t',0};
8021     IXMLDOMProcessingInstruction *pi;
8022     IXMLDOMDocument *doc;
8023     WCHAR buff[10];
8024     HRESULT hr;
8025
8026     doc = create_document(&IID_IXMLDOMDocument);
8027
8028     /* test for BSTR handling, pass broken BSTR */
8029     memcpy(&buff[2], bodyW, sizeof(bodyW));
8030     /* just a big length */
8031     *(DWORD*)buff = 0xf0f0;
8032     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("test"), &buff[2], &pi);
8033     ok(hr == S_OK, "got 0x%08x\n", hr);
8034
8035     IXMLDOMProcessingInstruction_Release(pi);
8036     IXMLDOMDocument_Release(doc);
8037 }
8038
8039 static void test_put_nodeTypedValue(void)
8040 {
8041     static const BYTE binhexdata[16] =
8042         {0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf};
8043     IXMLDOMDocument *doc;
8044     IXMLDOMElement *elem;
8045     VARIANT type, value;
8046     LONG ubound, lbound;
8047     IXMLDOMNode *node;
8048     SAFEARRAY *array;
8049     HRESULT hr;
8050     BYTE *ptr;
8051     BSTR str;
8052
8053     doc = create_document(&IID_IXMLDOMDocument);
8054
8055     hr = IXMLDOMDocument_createElement(doc, _bstr_("Element"), &elem);
8056     EXPECT_HR(hr, S_OK);
8057
8058     V_VT(&type) = VT_EMPTY;
8059     hr = IXMLDOMElement_get_dataType(elem, &type);
8060     EXPECT_HR(hr, S_FALSE);
8061     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8062
8063     /* set typed value for untyped node */
8064     V_VT(&type) = VT_I1;
8065     V_I1(&type) = 1;
8066     hr = IXMLDOMElement_put_nodeTypedValue(elem, type);
8067     EXPECT_HR(hr, S_OK);
8068
8069     V_VT(&type) = VT_EMPTY;
8070     hr = IXMLDOMElement_get_dataType(elem, &type);
8071     EXPECT_HR(hr, S_FALSE);
8072     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8073
8074     /* no type info stored */
8075     V_VT(&type) = VT_EMPTY;
8076     hr = IXMLDOMElement_get_nodeTypedValue(elem, &type);
8077     EXPECT_HR(hr, S_OK);
8078     ok(V_VT(&type) == VT_BSTR, "got %d, expected VT_BSTR\n", V_VT(&type));
8079     ok(memcmp(V_BSTR(&type), _bstr_("1"), 2*sizeof(WCHAR)) == 0,
8080        "got %s, expected \"1\"\n", wine_dbgstr_w(V_BSTR(&type)));
8081     VariantClear(&type);
8082
8083     hr = IXMLDOMElement_get_firstChild(elem, &node);
8084     EXPECT_HR(hr, S_OK);
8085     hr = IXMLDOMElement_removeChild(elem, node, NULL);
8086     EXPECT_HR(hr, S_OK);
8087     IXMLDOMNode_Release(node);
8088
8089     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)elem, NULL);
8090     EXPECT_HR(hr, S_OK);
8091
8092     /* bin.base64 */
8093     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.base64"));
8094     EXPECT_HR(hr, S_OK);
8095
8096     V_VT(&value) = VT_BSTR;
8097     V_BSTR(&value) = _bstr_("ABCD");
8098     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8099     EXPECT_HR(hr, S_OK);
8100
8101     V_VT(&value) = VT_EMPTY;
8102     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8103     EXPECT_HR(hr, S_OK);
8104     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8105     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8106     ubound = 0;
8107     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8108     EXPECT_HR(hr, S_OK);
8109     ok(ubound == 2, "got %d\n", ubound);
8110     lbound = 0;
8111     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8112     EXPECT_HR(hr, S_OK);
8113     ok(lbound == 0, "got %d\n", lbound);
8114     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8115     EXPECT_HR(hr, S_OK);
8116     ok(ptr[0] == 0, "got %x\n", ptr[0]);
8117     ok(ptr[1] == 0x10, "got %x\n", ptr[1]);
8118     ok(ptr[2] == 0x83, "got %x\n", ptr[2]);
8119     SafeArrayUnaccessData(V_ARRAY(&value));
8120     VariantClear(&value);
8121
8122     /* when set as VT_BSTR it's stored as is */
8123     hr = IXMLDOMElement_get_firstChild(elem, &node);
8124     EXPECT_HR(hr, S_OK);
8125     hr = IXMLDOMNode_get_text(node, &str);
8126     EXPECT_HR(hr, S_OK);
8127     ok(!lstrcmpW(str, _bstr_("ABCD")), "%s\n", wine_dbgstr_w(str));
8128     IXMLDOMNode_Release(node);
8129     SysFreeString(str);
8130
8131     array = SafeArrayCreateVector(VT_UI1, 0, 7);
8132     hr = SafeArrayAccessData(array, (void*)&ptr);
8133     EXPECT_HR(hr, S_OK);
8134     memcpy(ptr, "dGVzdA=", strlen("dGVzdA="));
8135     SafeArrayUnaccessData(array);
8136
8137     V_VT(&value) = VT_UI1|VT_ARRAY;
8138     V_ARRAY(&value) = array;
8139     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8140     EXPECT_HR(hr, S_OK);
8141
8142     V_VT(&value) = VT_EMPTY;
8143     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8144     EXPECT_HR(hr, S_OK);
8145     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8146     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8147     ubound = 0;
8148     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8149     EXPECT_HR(hr, S_OK);
8150     ok(ubound == 6, "got %d\n", ubound);
8151     lbound = 0;
8152     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8153     EXPECT_HR(hr, S_OK);
8154     ok(lbound == 0, "got %d\n", lbound);
8155     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8156     EXPECT_HR(hr, S_OK);
8157     ok(!memcmp(ptr, "dGVzdA=", strlen("dGVzdA=")), "got wrong data, %s\n", ptr);
8158     SafeArrayUnaccessData(V_ARRAY(&value));
8159     VariantClear(&value);
8160
8161     /* if set with VT_UI1|VT_ARRAY it's encoded */
8162     hr = IXMLDOMElement_get_firstChild(elem, &node);
8163     EXPECT_HR(hr, S_OK);
8164     hr = IXMLDOMNode_get_text(node, &str);
8165     EXPECT_HR(hr, S_OK);
8166     ok(!lstrcmpW(str, _bstr_("ZEdWemRBPQ==")), "%s\n", wine_dbgstr_w(str));
8167     IXMLDOMNode_Release(node);
8168     SafeArrayDestroyData(array);
8169     SysFreeString(str);
8170
8171     /* bin.hex */
8172     V_VT(&value) = VT_BSTR;
8173     V_BSTR(&value) = _bstr_("");
8174     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8175     EXPECT_HR(hr, S_OK);
8176
8177     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.hex"));
8178     EXPECT_HR(hr, S_OK);
8179
8180     array = SafeArrayCreateVector(VT_UI1, 0, 16);
8181     hr = SafeArrayAccessData(array, (void*)&ptr);
8182     EXPECT_HR(hr, S_OK);
8183     memcpy(ptr, binhexdata, sizeof(binhexdata));
8184     SafeArrayUnaccessData(array);
8185
8186     V_VT(&value) = VT_UI1|VT_ARRAY;
8187     V_ARRAY(&value) = array;
8188     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8189     EXPECT_HR(hr, S_OK);
8190
8191     V_VT(&value) = VT_EMPTY;
8192     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8193     EXPECT_HR(hr, S_OK);
8194     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8195     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8196     ubound = 0;
8197     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8198     EXPECT_HR(hr, S_OK);
8199     ok(ubound == 15, "got %d\n", ubound);
8200     lbound = 0;
8201     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8202     EXPECT_HR(hr, S_OK);
8203     ok(lbound == 0, "got %d\n", lbound);
8204     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8205     EXPECT_HR(hr, S_OK);
8206     ok(!memcmp(ptr, binhexdata, sizeof(binhexdata)), "got wrong data\n");
8207     SafeArrayUnaccessData(V_ARRAY(&value));
8208     VariantClear(&value);
8209
8210     /* if set with VT_UI1|VT_ARRAY it's encoded */
8211     hr = IXMLDOMElement_get_firstChild(elem, &node);
8212     EXPECT_HR(hr, S_OK);
8213     hr = IXMLDOMNode_get_text(node, &str);
8214     EXPECT_HR(hr, S_OK);
8215     ok(!lstrcmpW(str, _bstr_("000102030405060708090a0b0c0d0e0f")), "%s\n", wine_dbgstr_w(str));
8216     IXMLDOMNode_Release(node);
8217     SafeArrayDestroyData(array);
8218     SysFreeString(str);
8219
8220     IXMLDOMElement_Release(elem);
8221     IXMLDOMDocument_Release(doc);
8222     free_bstrs();
8223 }
8224
8225 static void test_get_xml(void)
8226 {
8227     static const char xmlA[] = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\r\n<a>test</a>\r\n";
8228     static const char attrA[] = "attr=\"&quot;a &amp; b&quot;\"";
8229     static const char attr2A[] = "\"a & b\"";
8230     static const char attr3A[] = "attr=\"&amp;quot;a\"";
8231     static const char attr4A[] = "&quot;a";
8232     static const char fooA[] = "<foo/>";
8233     IXMLDOMProcessingInstruction *pi;
8234     IXMLDOMNode *first;
8235     IXMLDOMElement *elem = NULL;
8236     IXMLDOMAttribute *attr;
8237     IXMLDOMDocument *doc;
8238     VARIANT_BOOL b;
8239     VARIANT v;
8240     BSTR xml;
8241     HRESULT hr;
8242
8243     doc = create_document(&IID_IXMLDOMDocument);
8244
8245     b = VARIANT_TRUE;
8246     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8247     ok(hr == S_OK, "got 0x%08x\n", hr);
8248     ok( b == VARIANT_TRUE, "got %d\n", b);
8249
8250     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"),
8251                              _bstr_("version=\"1.0\" encoding=\"UTF-16\""), &pi);
8252     ok(hr == S_OK, "got 0x%08x\n", hr);
8253
8254     hr = IXMLDOMDocument_get_firstChild(doc, &first);
8255     ok(hr == S_OK, "got 0x%08x\n", hr);
8256
8257     V_UNKNOWN(&v) = (IUnknown*)first;
8258     V_VT(&v) = VT_UNKNOWN;
8259
8260     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)pi, v, NULL);
8261     ok(hr == S_OK, "got 0x%08x\n", hr);
8262
8263     IXMLDOMProcessingInstruction_Release(pi);
8264     IXMLDOMNode_Release(first);
8265
8266     hr = IXMLDOMDocument_get_xml(doc, &xml);
8267     ok(hr == S_OK, "got 0x%08x\n", hr);
8268
8269     ok(memcmp(xml, _bstr_(xmlA), sizeof(xmlA)*sizeof(WCHAR)) == 0,
8270         "got %s, expected %s\n", wine_dbgstr_w(xml), xmlA);
8271     SysFreeString(xml);
8272
8273     IXMLDOMDocument_Release(doc);
8274
8275     doc = create_document(&IID_IXMLDOMDocument);
8276
8277     hr = IXMLDOMDocument_createElement(doc, _bstr_("foo"), &elem);
8278     ok(hr == S_OK, "got 0x%08x\n", hr);
8279
8280     hr = IXMLDOMDocument_putref_documentElement(doc, elem);
8281     ok(hr == S_OK, "got 0x%08x\n", hr);
8282
8283     hr = IXMLDOMDocument_get_xml(doc, &xml);
8284     ok(hr == S_OK, "got 0x%08x\n", hr);
8285
8286     ok(memcmp(xml, _bstr_(fooA), (sizeof(fooA)-1)*sizeof(WCHAR)) == 0,
8287         "got %s, expected %s\n", wine_dbgstr_w(xml), fooA);
8288     SysFreeString(xml);
8289
8290     IXMLDOMElement_Release(elem);
8291
8292     /* attribute node */
8293     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8294     ok(hr == S_OK, "got 0x%08x\n", hr);
8295
8296     V_VT(&v) = VT_BSTR;
8297     V_BSTR(&v) = _bstr_("\"a & b\"");
8298     hr = IXMLDOMAttribute_put_value(attr, v);
8299     ok(hr == S_OK, "got 0x%08x\n", hr);
8300
8301     xml = NULL;
8302     hr = IXMLDOMAttribute_get_xml(attr, &xml);
8303     ok(hr == S_OK, "got 0x%08x\n", hr);
8304     ok(!memcmp(xml, _bstr_(attrA), (sizeof(attrA)-1)*sizeof(WCHAR)), "got %s\n", wine_dbgstr_w(xml));
8305     SysFreeString(xml);
8306
8307     VariantInit(&v);
8308     hr = IXMLDOMAttribute_get_value(attr, &v);
8309     ok(hr == S_OK, "got 0x%08x\n", hr);
8310     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8311     ok(!memcmp(V_BSTR(&v), _bstr_(attr2A), (sizeof(attr2A)-1)*sizeof(WCHAR)),
8312         "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8313     VariantClear(&v);
8314
8315     V_VT(&v) = VT_BSTR;
8316     V_BSTR(&v) = _bstr_("&quot;a");
8317     hr = IXMLDOMAttribute_put_value(attr, v);
8318     ok(hr == S_OK, "got 0x%08x\n", hr);
8319
8320     xml = NULL;
8321     hr = IXMLDOMAttribute_get_xml(attr, &xml);
8322     ok(hr == S_OK, "got 0x%08x\n", hr);
8323     ok(!memcmp(xml, _bstr_(attr3A), (sizeof(attr3A)-1)*sizeof(WCHAR)), "got %s\n", wine_dbgstr_w(xml));
8324     SysFreeString(xml);
8325
8326     VariantInit(&v);
8327     hr = IXMLDOMAttribute_get_value(attr, &v);
8328     ok(hr == S_OK, "got 0x%08x\n", hr);
8329     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8330     ok(!memcmp(V_BSTR(&v), _bstr_(attr4A), (sizeof(attr4A)-1)*sizeof(WCHAR)),
8331         "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8332     VariantClear(&v);
8333
8334     IXMLDOMAttribute_Release(attr);
8335
8336     IXMLDOMDocument_Release(doc);
8337
8338     free_bstrs();
8339 }
8340
8341 static void test_xsltemplate(void)
8342 {
8343     IXSLTemplate *template;
8344     IXSLProcessor *processor;
8345     IXMLDOMDocument *doc, *doc2;
8346     IStream *stream;
8347     VARIANT_BOOL b;
8348     HRESULT hr;
8349     ULONG ref1, ref2;
8350     VARIANT v;
8351
8352     if (!is_clsid_supported(&CLSID_XSLTemplate, &IID_IXSLTemplate)) return;
8353     template = create_xsltemplate(&IID_IXSLTemplate);
8354
8355     /* works as reset */
8356     hr = IXSLTemplate_putref_stylesheet(template, NULL);
8357     ok(hr == S_OK, "got 0x%08x\n", hr);
8358
8359     doc = create_document(&IID_IXMLDOMDocument);
8360
8361     b = VARIANT_TRUE;
8362     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8363     ok(hr == S_OK, "got 0x%08x\n", hr);
8364     ok( b == VARIANT_TRUE, "got %d\n", b);
8365
8366     /* putref with non-xsl document */
8367     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8368     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8369
8370     b = VARIANT_TRUE;
8371     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8372     ok(hr == S_OK, "got 0x%08x\n", hr);
8373     ok( b == VARIANT_TRUE, "got %d\n", b);
8374
8375     /* not a freethreaded document */
8376     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8377     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8378
8379     IXMLDOMDocument_Release(doc);
8380
8381     if (!is_clsid_supported(&CLSID_FreeThreadedDOMDocument, &IID_IXMLDOMDocument))
8382     {
8383         IXSLTemplate_Release(template);
8384         return;
8385     }
8386
8387     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
8388     ok(hr == S_OK, "got 0x%08x\n", hr);
8389
8390     b = VARIANT_TRUE;
8391     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8392     ok(hr == S_OK, "got 0x%08x\n", hr);
8393     ok( b == VARIANT_TRUE, "got %d\n", b);
8394
8395     /* freethreaded document */
8396     ref1 = IXMLDOMDocument_AddRef(doc);
8397     IXMLDOMDocument_Release(doc);
8398     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8399     ok(hr == S_OK, "got 0x%08x\n", hr);
8400     ref2 = IXMLDOMDocument_AddRef(doc);
8401     IXMLDOMDocument_Release(doc);
8402     ok(ref2 > ref1, "got %d\n", ref2);
8403
8404     /* processor */
8405     hr = IXSLTemplate_createProcessor(template, NULL);
8406     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8407
8408     EXPECT_REF(template, 1);
8409     hr = IXSLTemplate_createProcessor(template, &processor);
8410     ok(hr == S_OK, "got 0x%08x\n", hr);
8411     EXPECT_REF(template, 2);
8412
8413     /* input no set yet */
8414     V_VT(&v) = VT_BSTR;
8415     V_BSTR(&v) = NULL;
8416     hr = IXSLProcessor_get_input(processor, &v);
8417 todo_wine {
8418     ok(hr == S_OK, "got 0x%08x\n", hr);
8419     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
8420 }
8421
8422     hr = IXSLProcessor_get_output(processor, NULL);
8423     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8424
8425     /* reset before it was set */
8426     V_VT(&v) = VT_EMPTY;
8427     hr = IXSLProcessor_put_output(processor, v);
8428     ok(hr == S_OK, "got 0x%08x\n", hr);
8429
8430     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
8431     ok(hr == S_OK, "got 0x%08x\n", hr);
8432     EXPECT_REF(stream, 1);
8433
8434     V_VT(&v) = VT_UNKNOWN;
8435     V_UNKNOWN(&v) = (IUnknown*)stream;
8436     hr = IXSLProcessor_put_output(processor, v);
8437     ok(hr == S_OK, "got 0x%08x\n", hr);
8438
8439     /* it seems processor grabs 2 references */
8440     todo_wine EXPECT_REF(stream, 3);
8441
8442     V_VT(&v) = VT_EMPTY;
8443     hr = IXSLProcessor_get_output(processor, &v);
8444     ok(hr == S_OK, "got 0x%08x\n", hr);
8445     ok(V_VT(&v) == VT_UNKNOWN, "got type %d\n", V_VT(&v));
8446     ok(V_UNKNOWN(&v) == (IUnknown*)stream, "got %p\n", V_UNKNOWN(&v));
8447
8448     todo_wine EXPECT_REF(stream, 4);
8449     VariantClear(&v);
8450
8451     hr = IXSLProcessor_transform(processor, NULL);
8452     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8453
8454     /* reset and check stream refcount */
8455     V_VT(&v) = VT_EMPTY;
8456     hr = IXSLProcessor_put_output(processor, v);
8457     ok(hr == S_OK, "got 0x%08x\n", hr);
8458
8459     EXPECT_REF(stream, 1);
8460
8461     IStream_Release(stream);
8462
8463     /* no output interface set, check output */
8464     doc2 = create_document(&IID_IXMLDOMDocument);
8465
8466     b = VARIANT_TRUE;
8467     hr = IXMLDOMDocument_loadXML( doc2, _bstr_("<a>test</a>"), &b );
8468     ok(hr == S_OK, "got 0x%08x\n", hr);
8469     ok( b == VARIANT_TRUE, "got %d\n", b);
8470
8471     V_VT(&v) = VT_UNKNOWN;
8472     V_UNKNOWN(&v) = (IUnknown*)doc2;
8473     hr = IXSLProcessor_put_input(processor, v);
8474     ok(hr == S_OK, "got 0x%08x\n", hr);
8475
8476     hr = IXSLProcessor_transform(processor, &b);
8477     ok(hr == S_OK, "got 0x%08x\n", hr);
8478
8479     V_VT(&v) = VT_EMPTY;
8480     hr = IXSLProcessor_get_output(processor, &v);
8481     ok(hr == S_OK, "got 0x%08x\n", hr);
8482     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8483     ok(*V_BSTR(&v) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8484     IXMLDOMDocument_Release(doc2);
8485     VariantClear(&v);
8486
8487     IXSLProcessor_Release(processor);
8488
8489     /* drop reference */
8490     hr = IXSLTemplate_putref_stylesheet(template, NULL);
8491     ok(hr == S_OK, "got 0x%08x\n", hr);
8492     ref2 = IXMLDOMDocument_AddRef(doc);
8493     IXMLDOMDocument_Release(doc);
8494     ok(ref2 == ref1, "got %d\n", ref2);
8495
8496     IXMLDOMDocument_Release(doc);
8497     IXSLTemplate_Release(template);
8498     free_bstrs();
8499 }
8500
8501 static void test_insertBefore(void)
8502 {
8503     IXMLDOMDocument *doc, *doc2, *doc3;
8504     IXMLDOMAttribute *attr;
8505     IXMLDOMElement *elem1, *elem2, *elem3, *elem4, *elem5;
8506     IXMLDOMNode *node, *newnode, *cdata;
8507     HRESULT hr;
8508     VARIANT v;
8509     BSTR p;
8510
8511     doc = create_document(&IID_IXMLDOMDocument);
8512     doc3 = create_document(&IID_IXMLDOMDocument);
8513
8514     /* document to document */
8515     V_VT(&v) = VT_NULL;
8516     node = (void*)0xdeadbeef;
8517     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)doc3, v, &node);
8518     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8519     ok(node == NULL, "got %p\n", node);
8520
8521     /* document to itself */
8522     V_VT(&v) = VT_NULL;
8523     node = (void*)0xdeadbeef;
8524     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)doc, v, &node);
8525     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8526     ok(node == NULL, "got %p\n", node);
8527
8528     /* insertBefore behaviour for attribute node */
8529     V_VT(&v) = VT_I4;
8530     V_I4(&v) = NODE_ATTRIBUTE;
8531
8532     attr = NULL;
8533     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr"), NULL, (IXMLDOMNode**)&attr);
8534     ok(hr == S_OK, "got 0x%08x\n", hr);
8535     ok(attr != NULL, "got %p\n", attr);
8536
8537     /* attribute to document */
8538     V_VT(&v) = VT_NULL;
8539     node = (void*)0xdeadbeef;
8540     hr = IXMLDOMDocument_insertBefore(doc3, (IXMLDOMNode*)attr, v, &node);
8541     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8542     ok(node == NULL, "got %p\n", node);
8543
8544     /* cdata to document */
8545     V_VT(&v) = VT_I4;
8546     V_I4(&v) = NODE_CDATA_SECTION;
8547
8548     cdata = NULL;
8549     hr = IXMLDOMDocument_createNode(doc3, v, _bstr_("cdata"), NULL, &cdata);
8550     ok(hr == S_OK, "got 0x%08x\n", hr);
8551     ok(cdata != NULL, "got %p\n", cdata);
8552
8553     EXPECT_NO_CHILDREN(cdata);
8554
8555     /* attribute to cdata */
8556     V_VT(&v) = VT_NULL;
8557     node = (void*)0xdeadbeef;
8558     hr = IXMLDOMNode_insertBefore(cdata, (IXMLDOMNode*)attr, v, &node);
8559     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8560     ok(node == NULL, "got %p\n", node);
8561
8562     /* document to cdata */
8563     V_VT(&v) = VT_NULL;
8564     node = (void*)0xdeadbeef;
8565     hr = IXMLDOMNode_insertBefore(cdata, (IXMLDOMNode*)doc, v, &node);
8566     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8567     ok(node == NULL, "got %p\n", node);
8568
8569     V_VT(&v) = VT_NULL;
8570     node = (void*)0xdeadbeef;
8571     hr = IXMLDOMDocument_insertBefore(doc3, cdata, v, &node);
8572     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8573     ok(node == NULL, "got %p\n", node);
8574
8575     IXMLDOMNode_Release(cdata);
8576     IXMLDOMDocument_Release(doc3);
8577
8578     /* attribute to attribute */
8579     V_VT(&v) = VT_I4;
8580     V_I4(&v) = NODE_ATTRIBUTE;
8581     newnode = NULL;
8582     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr2"), NULL, &newnode);
8583     ok(hr == S_OK, "got 0x%08x\n", hr);
8584     ok(newnode != NULL, "got %p\n", newnode);
8585
8586     V_VT(&v) = VT_NULL;
8587     node = (void*)0xdeadbeef;
8588     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8589     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8590     ok(node == NULL, "got %p\n", node);
8591
8592     V_VT(&v) = VT_UNKNOWN;
8593     V_UNKNOWN(&v) = (IUnknown*)attr;
8594     node = (void*)0xdeadbeef;
8595     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8596     todo_wine ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8597     ok(node == NULL, "got %p\n", node);
8598     IXMLDOMNode_Release(newnode);
8599
8600     /* cdata to attribute */
8601     V_VT(&v) = VT_I4;
8602     V_I4(&v) = NODE_CDATA_SECTION;
8603     newnode = NULL;
8604     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8605     ok(hr == S_OK, "got 0x%08x\n", hr);
8606     ok(newnode != NULL, "got %p\n", newnode);
8607
8608     V_VT(&v) = VT_NULL;
8609     node = (void*)0xdeadbeef;
8610     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8611     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8612     ok(node == NULL, "got %p\n", node);
8613     IXMLDOMNode_Release(newnode);
8614
8615     /* comment to attribute */
8616     V_VT(&v) = VT_I4;
8617     V_I4(&v) = NODE_COMMENT;
8618     newnode = NULL;
8619     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8620     ok(hr == S_OK, "got 0x%08x\n", hr);
8621     ok(newnode != NULL, "got %p\n", newnode);
8622
8623     V_VT(&v) = VT_NULL;
8624     node = (void*)0xdeadbeef;
8625     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8626     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8627     ok(node == NULL, "got %p\n", node);
8628     IXMLDOMNode_Release(newnode);
8629
8630     /* element to attribute */
8631     V_VT(&v) = VT_I4;
8632     V_I4(&v) = NODE_ELEMENT;
8633     newnode = NULL;
8634     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8635     ok(hr == S_OK, "got 0x%08x\n", hr);
8636     ok(newnode != NULL, "got %p\n", newnode);
8637
8638     V_VT(&v) = VT_NULL;
8639     node = (void*)0xdeadbeef;
8640     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8641     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8642     ok(node == NULL, "got %p\n", node);
8643     IXMLDOMNode_Release(newnode);
8644
8645     /* pi to attribute */
8646     V_VT(&v) = VT_I4;
8647     V_I4(&v) = NODE_PROCESSING_INSTRUCTION;
8648     newnode = NULL;
8649     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8650     ok(hr == S_OK, "got 0x%08x\n", hr);
8651     ok(newnode != NULL, "got %p\n", newnode);
8652
8653     V_VT(&v) = VT_NULL;
8654     node = (void*)0xdeadbeef;
8655     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8656     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8657     ok(node == NULL, "got %p\n", node);
8658     IXMLDOMNode_Release(newnode);
8659     IXMLDOMAttribute_Release(attr);
8660
8661     /* insertBefore for elements */
8662     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem1);
8663     ok(hr == S_OK, "got 0x%08x\n", hr);
8664
8665     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem2"), &elem2);
8666     ok(hr == S_OK, "got 0x%08x\n", hr);
8667
8668     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
8669     ok(hr == S_OK, "got 0x%08x\n", hr);
8670
8671     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
8672     ok(hr == S_OK, "got 0x%08x\n", hr);
8673
8674     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem4"), &elem4);
8675     ok(hr == S_OK, "got 0x%08x\n", hr);
8676
8677     EXPECT_NO_CHILDREN(elem1);
8678     EXPECT_NO_CHILDREN(elem2);
8679     EXPECT_NO_CHILDREN(elem3);
8680
8681     todo_wine EXPECT_REF(elem2, 2);
8682
8683     /* document to element */
8684     V_VT(&v) = VT_DISPATCH;
8685     V_DISPATCH(&v) = NULL;
8686     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)doc, v, NULL);
8687     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8688
8689     V_VT(&v) = VT_DISPATCH;
8690     V_DISPATCH(&v) = NULL;
8691     node = NULL;
8692     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem4, v, &node);
8693     ok(hr == S_OK, "got 0x%08x\n", hr);
8694     ok(node == (void*)elem4, "got %p\n", node);
8695
8696     EXPECT_CHILDREN(elem1);
8697     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem4, NULL);
8698     EXPECT_HR(hr, S_OK);
8699     IXMLDOMElement_Release(elem4);
8700
8701     EXPECT_NO_CHILDREN(elem1);
8702
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     todo_wine EXPECT_REF(elem2, 3);
8711     IXMLDOMNode_Release(node);
8712
8713     /* again for already linked node */
8714     V_VT(&v) = VT_NULL;
8715     node = NULL;
8716     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
8717     ok(hr == S_OK, "got 0x%08x\n", hr);
8718     ok(node == (void*)elem2, "got %p\n", node);
8719
8720     EXPECT_CHILDREN(elem1);
8721
8722     /* increments each time */
8723     todo_wine EXPECT_REF(elem2, 3);
8724     IXMLDOMNode_Release(node);
8725
8726     /* try to add to another element */
8727     V_VT(&v) = VT_NULL;
8728     node = (void*)0xdeadbeef;
8729     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem2, v, &node);
8730     ok(hr == S_OK, "got 0x%08x\n", hr);
8731     ok(node == (void*)elem2, "got %p\n", node);
8732
8733     EXPECT_CHILDREN(elem3);
8734     EXPECT_NO_CHILDREN(elem1);
8735
8736     IXMLDOMNode_Release(node);
8737
8738     /* cross document case - try to add as child to a node created with other doc */
8739     doc2 = create_document(&IID_IXMLDOMDocument);
8740
8741     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem4);
8742     ok(hr == S_OK, "got 0x%08x\n", hr);
8743     todo_wine EXPECT_REF(elem4, 2);
8744
8745     /* same name, another instance */
8746     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem5);
8747     ok(hr == S_OK, "got 0x%08x\n", hr);
8748     todo_wine EXPECT_REF(elem5, 2);
8749
8750     todo_wine EXPECT_REF(elem3, 2);
8751     V_VT(&v) = VT_NULL;
8752     node = NULL;
8753     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem4, v, &node);
8754     ok(hr == S_OK, "got 0x%08x\n", hr);
8755     ok(node == (void*)elem4, "got %p\n", node);
8756     todo_wine EXPECT_REF(elem4, 3);
8757     todo_wine EXPECT_REF(elem3, 2);
8758     IXMLDOMNode_Release(node);
8759
8760     V_VT(&v) = VT_NULL;
8761     node = NULL;
8762     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem5, v, &node);
8763     ok(hr == S_OK, "got 0x%08x\n", hr);
8764     ok(node == (void*)elem5, "got %p\n", node);
8765     todo_wine EXPECT_REF(elem4, 2);
8766     todo_wine EXPECT_REF(elem5, 3);
8767     IXMLDOMNode_Release(node);
8768
8769     IXMLDOMDocument_Release(doc2);
8770
8771     IXMLDOMElement_Release(elem1);
8772     IXMLDOMElement_Release(elem2);
8773     IXMLDOMElement_Release(elem3);
8774     IXMLDOMElement_Release(elem4);
8775     IXMLDOMElement_Release(elem5);
8776
8777     /* elements with same default namespace */
8778     V_VT(&v) = VT_I4;
8779     V_I4(&v) = NODE_ELEMENT;
8780     elem1 = NULL;
8781     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
8782     ok(hr == S_OK, "got 0x%08x\n", hr);
8783     ok(elem1 != NULL, "got %p\n", elem1);
8784
8785     V_VT(&v) = VT_I4;
8786     V_I4(&v) = NODE_ELEMENT;
8787     elem2 = NULL;
8788     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem2);
8789     ok(hr == S_OK, "got 0x%08x\n", hr);
8790     ok(elem2 != NULL, "got %p\n", elem2);
8791
8792     /* check contents so far */
8793     p = NULL;
8794     hr = IXMLDOMElement_get_xml(elem1, &p);
8795     ok(hr == S_OK, "got 0x%08x\n", hr);
8796     ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
8797     SysFreeString(p);
8798
8799     p = NULL;
8800     hr = IXMLDOMElement_get_xml(elem2, &p);
8801     ok(hr == S_OK, "got 0x%08x\n", hr);
8802     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
8803     SysFreeString(p);
8804
8805     V_VT(&v) = VT_NULL;
8806     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
8807     ok(hr == S_OK, "got 0x%08x\n", hr);
8808
8809     /* get_xml depends on context, for top node it omits child namespace attribute,
8810        but at child level it's still returned */
8811     p = NULL;
8812     hr = IXMLDOMElement_get_xml(elem1, &p);
8813     ok(hr == S_OK, "got 0x%08x\n", hr);
8814     todo_wine ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"><elem2/></elem1>")),
8815         "got %s\n", wine_dbgstr_w(p));
8816     SysFreeString(p);
8817
8818     p = NULL;
8819     hr = IXMLDOMElement_get_xml(elem2, &p);
8820     ok(hr == S_OK, "got 0x%08x\n", hr);
8821     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
8822     SysFreeString(p);
8823
8824     IXMLDOMElement_Release(elem1);
8825     IXMLDOMElement_Release(elem2);
8826
8827     /* child without default namespace added to node with default namespace */
8828     V_VT(&v) = VT_I4;
8829     V_I4(&v) = NODE_ELEMENT;
8830     elem1 = NULL;
8831     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
8832     ok(hr == S_OK, "got 0x%08x\n", hr);
8833     ok(elem1 != NULL, "got %p\n", elem1);
8834
8835     V_VT(&v) = VT_I4;
8836     V_I4(&v) = NODE_ELEMENT;
8837     elem2 = NULL;
8838     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), NULL, (IXMLDOMNode**)&elem2);
8839     ok(hr == S_OK, "got 0x%08x\n", hr);
8840     ok(elem2 != NULL, "got %p\n", elem2);
8841
8842     EXPECT_REF(elem2, 1);
8843     V_VT(&v) = VT_NULL;
8844     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
8845     ok(hr == S_OK, "got 0x%08x\n", hr);
8846     EXPECT_REF(elem2, 1);
8847
8848     p = NULL;
8849     hr = IXMLDOMElement_get_xml(elem2, &p);
8850     ok(hr == S_OK, "got 0x%08x\n", hr);
8851     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
8852     SysFreeString(p);
8853
8854     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem2, NULL);
8855     ok(hr == S_OK, "got 0x%08x\n", hr);
8856
8857     p = NULL;
8858     hr = IXMLDOMElement_get_xml(elem2, &p);
8859     ok(hr == S_OK, "got 0x%08x\n", hr);
8860     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
8861     SysFreeString(p);
8862
8863     IXMLDOMElement_Release(elem1);
8864     IXMLDOMElement_Release(elem2);
8865     IXMLDOMDocument_Release(doc);
8866 }
8867
8868 static void test_appendChild(void)
8869 {
8870     IXMLDOMDocument *doc, *doc2;
8871     IXMLDOMElement *elem, *elem2;
8872     HRESULT hr;
8873
8874     doc = create_document(&IID_IXMLDOMDocument);
8875     doc2 = create_document(&IID_IXMLDOMDocument);
8876
8877     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
8878     ok(hr == S_OK, "got 0x%08x\n", hr);
8879
8880     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem2"), &elem2);
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_NO_CHILDREN(doc2);
8889
8890     hr = IXMLDOMDocument_appendChild(doc2, NULL, NULL);
8891     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8892
8893     hr = IXMLDOMElement_appendChild(elem, NULL, NULL);
8894     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8895
8896     /* append from another document */
8897     hr = IXMLDOMDocument_appendChild(doc2, (IXMLDOMNode*)elem, NULL);
8898     ok(hr == S_OK, "got 0x%08x\n", hr);
8899
8900     EXPECT_REF(doc, 1);
8901     todo_wine EXPECT_REF(elem, 2);
8902     EXPECT_REF(doc2, 1);
8903     todo_wine EXPECT_REF(elem2, 2);
8904     EXPECT_NO_CHILDREN(doc);
8905     EXPECT_CHILDREN(doc2);
8906
8907     IXMLDOMElement_Release(elem);
8908     IXMLDOMElement_Release(elem2);
8909     IXMLDOMDocument_Release(doc);
8910     IXMLDOMDocument_Release(doc2);
8911 }
8912
8913 static void test_get_doctype(void)
8914 {
8915     static const WCHAR emailW[] = {'e','m','a','i','l',0};
8916     IXMLDOMDocumentType *doctype;
8917     IXMLDOMDocument *doc;
8918     VARIANT_BOOL b;
8919     HRESULT hr;
8920     BSTR s;
8921
8922     doc = create_document(&IID_IXMLDOMDocument);
8923
8924     hr = IXMLDOMDocument_get_doctype(doc, NULL);
8925     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8926
8927     doctype = (void*)0xdeadbeef;
8928     hr = IXMLDOMDocument_get_doctype(doc, &doctype);
8929     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8930     ok(doctype == NULL, "got %p\n", doctype);
8931
8932     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szEmailXML), &b);
8933     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8934
8935     doctype = NULL;
8936     hr = IXMLDOMDocument_get_doctype(doc, &doctype);
8937     ok(hr == S_OK, "got 0x%08x\n", hr);
8938     ok(doctype != NULL, "got %p\n", doctype);
8939
8940     hr = IXMLDOMDocumentType_get_name(doctype, NULL);
8941     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8942
8943     hr = IXMLDOMDocumentType_get_name(doctype, &s);
8944     ok(hr == S_OK, "got 0x%08x\n", hr);
8945     ok(!lstrcmpW(emailW, s), "got name %s\n", wine_dbgstr_w(s));
8946     SysFreeString(s);
8947
8948     hr = IXMLDOMDocumentType_get_nodeName(doctype, &s);
8949     ok(hr == S_OK, "got 0x%08x\n", hr);
8950     ok(!lstrcmpW(emailW, s), "got name %s\n", wine_dbgstr_w(s));
8951     SysFreeString(s);
8952
8953     IXMLDOMDocumentType_Release(doctype);
8954     IXMLDOMDocument_Release(doc);
8955 }
8956
8957 static void test_get_tagName(void)
8958 {
8959     IXMLDOMDocument *doc;
8960     IXMLDOMElement *elem, *elem2;
8961     HRESULT hr;
8962     BSTR str;
8963
8964     doc = create_document(&IID_IXMLDOMDocument);
8965
8966     hr = IXMLDOMDocument_createElement(doc, _bstr_("element"), &elem);
8967     ok(hr == S_OK, "got 0x%08x\n", hr);
8968
8969     hr = IXMLDOMElement_get_tagName(elem, NULL);
8970     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8971
8972     str = NULL;
8973     hr = IXMLDOMElement_get_tagName(elem, &str);
8974     ok(hr == S_OK, "got 0x%08x\n", hr);
8975     ok(!lstrcmpW(str, _bstr_("element")), "got %s\n", wine_dbgstr_w(str));
8976     SysFreeString(str);
8977
8978     hr = IXMLDOMDocument_createElement(doc, _bstr_("s:element"), &elem2);
8979     ok(hr == S_OK, "got 0x%08x\n", hr);
8980
8981     str = NULL;
8982     hr = IXMLDOMElement_get_tagName(elem2, &str);
8983     ok(hr == S_OK, "got 0x%08x\n", hr);
8984     ok(!lstrcmpW(str, _bstr_("s:element")), "got %s\n", wine_dbgstr_w(str));
8985     SysFreeString(str);
8986
8987     IXMLDOMElement_Release(elem);
8988     IXMLDOMElement_Release(elem2);
8989     IXMLDOMDocument_Release(doc);
8990     free_bstrs();
8991 }
8992
8993 typedef struct {
8994     DOMNodeType type;
8995     const char *name;
8996     VARTYPE vt;
8997     HRESULT hr;
8998 } node_type_t;
8999
9000 static const node_type_t get_datatype[] = {
9001     { NODE_ELEMENT,                "element",   VT_NULL, S_FALSE },
9002     { NODE_ATTRIBUTE,              "attr",      VT_NULL, S_FALSE },
9003     { NODE_TEXT,                   "text",      VT_NULL, S_FALSE },
9004     { NODE_CDATA_SECTION ,         "cdata",     VT_NULL, S_FALSE },
9005     { NODE_ENTITY_REFERENCE,       "entityref", VT_NULL, S_FALSE },
9006     { NODE_PROCESSING_INSTRUCTION, "pi",        VT_NULL, S_FALSE },
9007     { NODE_COMMENT,                "comment",   VT_NULL, S_FALSE },
9008     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   VT_NULL, S_FALSE },
9009     { 0 }
9010 };
9011
9012 static void test_get_dataType(void)
9013 {
9014     const node_type_t *entry = get_datatype;
9015     IXMLDOMDocument *doc;
9016
9017     doc = create_document(&IID_IXMLDOMDocument);
9018
9019     while (entry->type)
9020     {
9021         IXMLDOMNode *node = NULL;
9022         VARIANT var, type;
9023         HRESULT hr;
9024
9025         V_VT(&var) = VT_I4;
9026         V_I4(&var) = entry->type;
9027         hr = IXMLDOMDocument_createNode(doc, var, _bstr_(entry->name), NULL, &node);
9028         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9029
9030         hr = IXMLDOMNode_get_dataType(node, NULL);
9031         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9032
9033         VariantInit(&type);
9034         hr = IXMLDOMNode_get_dataType(node, &type);
9035         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
9036             hr, entry->hr, entry->type);
9037         ok(V_VT(&type) == entry->vt, "got %d, expected %d. node type %d\n",
9038             V_VT(&type), entry->vt, entry->type);
9039         VariantClear(&type);
9040
9041         IXMLDOMNode_Release(node);
9042
9043         entry++;
9044     }
9045
9046     IXMLDOMDocument_Release(doc);
9047     free_bstrs();
9048 }
9049
9050 typedef struct _get_node_typestring_t {
9051     DOMNodeType type;
9052     const char *string;
9053 } get_node_typestring_t;
9054
9055 static const get_node_typestring_t get_node_typestring[] = {
9056     { NODE_ELEMENT,                "element"               },
9057     { NODE_ATTRIBUTE,              "attribute"             },
9058     { NODE_TEXT,                   "text"                  },
9059     { NODE_CDATA_SECTION ,         "cdatasection"          },
9060     { NODE_ENTITY_REFERENCE,       "entityreference"       },
9061     { NODE_PROCESSING_INSTRUCTION, "processinginstruction" },
9062     { NODE_COMMENT,                "comment"               },
9063     { NODE_DOCUMENT_FRAGMENT,      "documentfragment"      },
9064     { 0 }
9065 };
9066
9067 static void test_get_nodeTypeString(void)
9068 {
9069     const get_node_typestring_t *entry = get_node_typestring;
9070     IXMLDOMDocument *doc;
9071     HRESULT hr;
9072     BSTR str;
9073
9074     doc = create_document(&IID_IXMLDOMDocument);
9075
9076     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
9077     ok(hr == S_OK, "got 0x%08x\n", hr);
9078     ok(!lstrcmpW(str, _bstr_("document")), "got string %s\n", wine_dbgstr_w(str));
9079     SysFreeString(str);
9080
9081     while (entry->type)
9082     {
9083         IXMLDOMNode *node = NULL;
9084         VARIANT var;
9085
9086         V_VT(&var) = VT_I4;
9087         V_I4(&var) = entry->type;
9088         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
9089         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9090
9091         hr = IXMLDOMNode_get_nodeTypeString(node, NULL);
9092         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9093
9094         hr = IXMLDOMNode_get_nodeTypeString(node, &str);
9095         ok(hr == S_OK, "got 0x%08x\n", hr);
9096         ok(!lstrcmpW(str, _bstr_(entry->string)), "got string %s, expected %s. node type %d\n",
9097             wine_dbgstr_w(str), entry->string, entry->type);
9098         SysFreeString(str);
9099         IXMLDOMNode_Release(node);
9100
9101         entry++;
9102     }
9103
9104     IXMLDOMDocument_Release(doc);
9105     free_bstrs();
9106 }
9107
9108 typedef struct _get_attributes_t {
9109     DOMNodeType type;
9110     HRESULT hr;
9111 } get_attributes_t;
9112
9113 static const get_attributes_t get_attributes[] = {
9114     { NODE_ATTRIBUTE,              S_FALSE },
9115     { NODE_TEXT,                   S_FALSE },
9116     { NODE_CDATA_SECTION ,         S_FALSE },
9117     { NODE_ENTITY_REFERENCE,       S_FALSE },
9118     { NODE_PROCESSING_INSTRUCTION, S_FALSE },
9119     { NODE_COMMENT,                S_FALSE },
9120     { NODE_DOCUMENT_FRAGMENT,      S_FALSE },
9121     { 0 }
9122 };
9123
9124 static void test_get_attributes(void)
9125 {
9126     const get_attributes_t *entry = get_attributes;
9127     IXMLDOMNamedNodeMap *map;
9128     IXMLDOMDocument *doc;
9129     IXMLDOMNode *node, *node2;
9130     VARIANT_BOOL b;
9131     HRESULT hr;
9132     BSTR str;
9133     LONG length;
9134
9135     doc = create_document(&IID_IXMLDOMDocument);
9136
9137     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
9138     ok(hr == S_OK, "got %08x\n", hr);
9139
9140     hr = IXMLDOMDocument_get_attributes(doc, NULL);
9141     ok(hr == E_INVALIDARG, "got %08x\n", hr);
9142
9143     map = (void*)0xdeadbeef;
9144     hr = IXMLDOMDocument_get_attributes(doc, &map);
9145     ok(hr == S_FALSE, "got %08x\n", hr);
9146     ok(map == NULL, "got %p\n", map);
9147
9148     /* first child is <?xml ?> */
9149     hr = IXMLDOMDocument_get_firstChild(doc, &node);
9150     ok(hr == S_OK, "got %08x\n", hr);
9151
9152     hr = IXMLDOMNode_get_attributes(node, &map);
9153     ok(hr == S_OK, "got %08x\n", hr);
9154
9155     length = -1;
9156     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9157     EXPECT_HR(hr, S_OK);
9158     todo_wine ok(length == 1, "got %d\n", length);
9159
9160     if (hr == S_OK && length == 1)
9161     {
9162         IXMLDOMAttribute *attr;
9163         DOMNodeType type;
9164         VARIANT v;
9165
9166         node2 = NULL;
9167         hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9168         EXPECT_HR(hr, S_OK);
9169         ok(node != NULL, "got %p\n", node2);
9170
9171         hr = IXMLDOMNode_get_nodeName(node2, &str);
9172         EXPECT_HR(hr, S_OK);
9173         ok(!lstrcmpW(str, _bstr_("version")), "got %s\n", wine_dbgstr_w(str));
9174         SysFreeString(str);
9175
9176         length = -1;
9177         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9178         EXPECT_HR(hr, S_OK);
9179         ok(length == 1, "got %d\n", length);
9180
9181         type = -1;
9182         hr = IXMLDOMNode_get_nodeType(node2, &type);
9183         EXPECT_HR(hr, S_OK);
9184         ok(type == NODE_ATTRIBUTE, "got %d\n", type);
9185
9186         hr = IXMLDOMNode_get_xml(node, &str);
9187         EXPECT_HR(hr, S_OK);
9188         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9189         SysFreeString(str);
9190
9191         hr = IXMLDOMNode_get_text(node, &str);
9192         EXPECT_HR(hr, S_OK);
9193         ok(!lstrcmpW(str, _bstr_("version=\"1.0\"")), "got %s\n", wine_dbgstr_w(str));
9194         SysFreeString(str);
9195
9196         hr = IXMLDOMNamedNodeMap_removeNamedItem(map, _bstr_("version"), NULL);
9197         EXPECT_HR(hr, S_OK);
9198
9199         length = -1;
9200         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9201         EXPECT_HR(hr, S_OK);
9202         ok(length == 0, "got %d\n", length);
9203
9204         hr = IXMLDOMNode_get_xml(node, &str);
9205         EXPECT_HR(hr, S_OK);
9206         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9207         SysFreeString(str);
9208
9209         hr = IXMLDOMNode_get_text(node, &str);
9210         EXPECT_HR(hr, S_OK);
9211         ok(!lstrcmpW(str, _bstr_("")), "got %s\n", wine_dbgstr_w(str));
9212         SysFreeString(str);
9213
9214         IXMLDOMNamedNodeMap_Release(map);
9215
9216         hr = IXMLDOMNode_get_attributes(node, &map);
9217         ok(hr == S_OK, "got %08x\n", hr);
9218
9219         length = -1;
9220         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9221         EXPECT_HR(hr, S_OK);
9222         ok(length == 0, "got %d\n", length);
9223
9224         hr = IXMLDOMDocument_createAttribute(doc, _bstr_("encoding"), &attr);
9225         EXPECT_HR(hr, S_OK);
9226
9227         V_VT(&v) = VT_BSTR;
9228         V_BSTR(&v) = _bstr_("UTF-8");
9229         hr = IXMLDOMAttribute_put_nodeValue(attr, v);
9230         EXPECT_HR(hr, S_OK);
9231
9232         EXPECT_REF(attr, 2);
9233         hr = IXMLDOMNamedNodeMap_setNamedItem(map, (IXMLDOMNode*)attr, NULL);
9234         EXPECT_HR(hr, S_OK);
9235         EXPECT_REF(attr, 2);
9236
9237         hr = IXMLDOMNode_get_attributes(node, &map);
9238         ok(hr == S_OK, "got %08x\n", hr);
9239
9240         length = -1;
9241         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9242         EXPECT_HR(hr, S_OK);
9243         ok(length == 1, "got %d\n", length);
9244
9245         hr = IXMLDOMNode_get_xml(node, &str);
9246         EXPECT_HR(hr, S_OK);
9247         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9248         SysFreeString(str);
9249
9250         hr = IXMLDOMNode_get_text(node, &str);
9251         EXPECT_HR(hr, S_OK);
9252         ok(!lstrcmpW(str, _bstr_("encoding=\"UTF-8\"")), "got %s\n", wine_dbgstr_w(str));
9253         SysFreeString(str);
9254
9255         IXMLDOMNamedNodeMap_Release(map);
9256         IXMLDOMNode_Release(node2);
9257     }
9258
9259     IXMLDOMNode_Release(node);
9260
9261     /* last child is element */
9262     EXPECT_REF(doc, 1);
9263     hr = IXMLDOMDocument_get_lastChild(doc, &node);
9264     ok(hr == S_OK, "got %08x\n", hr);
9265     EXPECT_REF(doc, 1);
9266
9267     EXPECT_REF(node, 1);
9268     hr = IXMLDOMNode_get_attributes(node, &map);
9269     ok(hr == S_OK, "got %08x\n", hr);
9270     EXPECT_REF(node, 1);
9271     EXPECT_REF(doc, 1);
9272
9273     EXPECT_REF(map, 1);
9274     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9275     ok(hr == S_OK, "got %08x\n", hr);
9276     EXPECT_REF(node, 1);
9277     EXPECT_REF(node2, 1);
9278     EXPECT_REF(map, 1);
9279     EXPECT_REF(doc, 1);
9280     IXMLDOMNode_Release(node2);
9281
9282     /* release node before map release, map still works */
9283     IXMLDOMNode_Release(node);
9284
9285     length = 0;
9286     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9287     ok(hr == S_OK, "got %08x\n", hr);
9288     ok(length == 1, "got %d\n", length);
9289
9290     node2 = NULL;
9291     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9292     ok(hr == S_OK, "got %08x\n", hr);
9293     EXPECT_REF(node2, 1);
9294     IXMLDOMNode_Release(node2);
9295
9296     IXMLDOMNamedNodeMap_Release(map);
9297
9298     while (entry->type)
9299     {
9300         VARIANT var;
9301
9302         node = NULL;
9303
9304         V_VT(&var) = VT_I4;
9305         V_I4(&var) = entry->type;
9306         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
9307         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9308
9309         hr = IXMLDOMNode_get_attributes(node, NULL);
9310         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9311
9312         map = (void*)0xdeadbeef;
9313         hr = IXMLDOMNode_get_attributes(node, &map);
9314         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
9315             hr, entry->hr, entry->type);
9316         ok(map == NULL, "got %p\n", map);
9317
9318         IXMLDOMNode_Release(node);
9319
9320         entry++;
9321     }
9322
9323     IXMLDOMDocument_Release(doc);
9324     free_bstrs();
9325 }
9326
9327 static void test_selection(void)
9328 {
9329     IXMLDOMSelection *selection, *selection2;
9330     IEnumVARIANT *enum1, *enum2, *enum3;
9331     IXMLDOMNodeList *list;
9332     IUnknown *unk1, *unk2;
9333     IXMLDOMDocument *doc;
9334     IDispatchEx *dispex;
9335     IXMLDOMNode *node;
9336     IDispatch *disp;
9337     VARIANT_BOOL b;
9338     HRESULT hr;
9339     DISPID did;
9340     VARIANT v;
9341     BSTR name;
9342     ULONG ret;
9343     LONG len;
9344
9345     doc = create_document(&IID_IXMLDOMDocument);
9346
9347     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
9348     EXPECT_HR(hr, S_OK);
9349
9350     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list);
9351     EXPECT_HR(hr, S_OK);
9352
9353     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9354     EXPECT_HR(hr, S_OK);
9355     IXMLDOMSelection_Release(selection);
9356
9357     /* collection disp id */
9358     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IDispatchEx, (void**)&dispex);
9359     EXPECT_HR(hr, S_OK);
9360     did = 0;
9361     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
9362     EXPECT_HR(hr, S_OK);
9363     ok(did == DISPID_DOM_COLLECTION_BASE, "got %d\n", did);
9364     len = 0;
9365     hr = IXMLDOMSelection_get_length(selection, &len);
9366     EXPECT_HR(hr, S_OK);
9367     ok(len == 1, "got %d\n", len);
9368     hr = IDispatchEx_GetDispID(dispex, _bstr_("10"), 0, &did);
9369     EXPECT_HR(hr, S_OK);
9370     ok(did == DISPID_DOM_COLLECTION_BASE+10, "got %d\n", did);
9371     IDispatchEx_Release(dispex);
9372
9373     /* IEnumVARIANT tests */
9374     enum1 = NULL;
9375     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum1);
9376     EXPECT_HR(hr, S_OK);
9377     ok(enum1 != NULL, "got %p\n", enum1);
9378     EXPECT_REF(enum1, 2);
9379
9380     EXPECT_REF(selection, 1);
9381     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IUnknown, (void**)&unk1);
9382     EXPECT_HR(hr, S_OK);
9383     EXPECT_REF(selection, 2);
9384     EXPECT_REF(enum1, 2);
9385
9386     /* enumerator and selection object return same IUnknown* */
9387     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
9388     EXPECT_HR(hr, S_OK);
9389     EXPECT_REF(selection, 3);
9390     EXPECT_REF(enum1, 2);
9391     ok(unk2 == unk1, "got %p, %p\n", unk1, unk2);
9392     IUnknown_Release(unk2);
9393
9394     EXPECT_REF(selection, 2);
9395     IEnumVARIANT_AddRef(enum1);
9396     EXPECT_REF(selection, 2);
9397     IEnumVARIANT_Release(enum1);
9398
9399     enum3 = NULL;
9400     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum3);
9401     EXPECT_HR(hr, S_OK);
9402     ok(enum3 != NULL, "got %p\n", enum3);
9403     ok(enum1 == enum3, "got %p and %p\n", enum1, enum3);
9404     EXPECT_REF(enum1, 3);
9405     IEnumVARIANT_Release(enum3);
9406
9407     EXPECT_REF(selection, 2);
9408     EXPECT_REF(enum1, 2);
9409
9410     enum2 = NULL;
9411     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
9412     EXPECT_HR(hr, S_OK);
9413     ok(enum2 != NULL, "got %p\n", enum2);
9414
9415     EXPECT_REF(selection, 3);
9416     EXPECT_REF(enum1, 2);
9417     EXPECT_REF(enum2, 1);
9418
9419     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
9420
9421     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
9422     EXPECT_HR(hr, S_OK);
9423     EXPECT_REF(selection, 3);
9424     EXPECT_REF(enum2, 2);
9425     ok(unk2 != unk1, "got %p, %p\n", unk1, unk2);
9426     IUnknown_Release(unk2);
9427     IUnknown_Release(unk1);
9428
9429     selection2 = NULL;
9430     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IXMLDOMSelection, (void**)&selection2);
9431     EXPECT_HR(hr, S_OK);
9432     ok(selection2 == selection, "got %p and %p\n", selection, selection2);
9433     EXPECT_REF(selection, 3);
9434     EXPECT_REF(enum1, 2);
9435
9436     IXMLDOMSelection_Release(selection2);
9437
9438     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IDispatch, (void**)&disp);
9439     EXPECT_HR(hr, S_OK);
9440     EXPECT_REF(selection, 3);
9441     IDispatch_Release(disp);
9442
9443     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IEnumVARIANT, (void**)&enum3);
9444     EXPECT_HR(hr, S_OK);
9445     ok(enum3 == enum1, "got %p and %p\n", enum3, enum1);
9446     EXPECT_REF(selection, 2);
9447     EXPECT_REF(enum1, 3);
9448
9449     IEnumVARIANT_Release(enum1);
9450     IEnumVARIANT_Release(enum2);
9451     IEnumVARIANT_Release(enum3);
9452
9453     enum1 = NULL;
9454     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
9455     EXPECT_HR(hr, S_OK);
9456     ok(enum1 != NULL, "got %p\n", enum1);
9457     EXPECT_REF(enum1, 1);
9458     EXPECT_REF(selection, 2);
9459
9460     enum2 = NULL;
9461     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
9462     EXPECT_HR(hr, S_OK);
9463     ok(enum2 != NULL, "got %p\n", enum2);
9464     EXPECT_REF(enum2, 1);
9465     EXPECT_REF(selection, 3);
9466
9467     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
9468
9469     IEnumVARIANT_AddRef(enum1);
9470     EXPECT_REF(selection, 3);
9471     EXPECT_REF(enum1, 2);
9472     EXPECT_REF(enum2, 1);
9473     IEnumVARIANT_Release(enum1);
9474
9475     IEnumVARIANT_Release(enum1);
9476     IEnumVARIANT_Release(enum2);
9477
9478     EXPECT_REF(selection, 1);
9479
9480     IXMLDOMNodeList_Release(list);
9481
9482     hr = IXMLDOMDocument_get_childNodes(doc, &list);
9483     EXPECT_HR(hr, S_OK);
9484
9485     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9486     EXPECT_HR(hr, E_NOINTERFACE);
9487
9488     IXMLDOMNodeList_Release(list);
9489
9490     /* test if IEnumVARIANT touches selection context */
9491     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
9492     EXPECT_HR(hr, S_OK);
9493
9494     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/*"), &list);
9495     EXPECT_HR(hr, S_OK);
9496
9497     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9498     EXPECT_HR(hr, S_OK);
9499
9500     len = 0;
9501     hr = IXMLDOMSelection_get_length(selection, &len);
9502     EXPECT_HR(hr, S_OK);
9503     ok(len == 4, "got %d\n", len);
9504
9505     enum1 = NULL;
9506     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
9507     EXPECT_HR(hr, S_OK);
9508
9509     /* no-op if zero count */
9510     V_VT(&v) = VT_I2;
9511     hr = IEnumVARIANT_Next(enum1, 0, &v, NULL);
9512     EXPECT_HR(hr, S_OK);
9513     ok(V_VT(&v) == VT_I2, "got var type %d\n", V_VT(&v));
9514
9515     /* positive count, null array pointer */
9516     hr = IEnumVARIANT_Next(enum1, 1, NULL, NULL);
9517     EXPECT_HR(hr, E_INVALIDARG);
9518
9519     ret = 1;
9520     hr = IEnumVARIANT_Next(enum1, 1, NULL, &ret);
9521     EXPECT_HR(hr, E_INVALIDARG);
9522     ok(ret == 0, "got %d\n", ret);
9523
9524     V_VT(&v) = VT_I2;
9525     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
9526     EXPECT_HR(hr, S_OK);
9527     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
9528
9529     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
9530     EXPECT_HR(hr, S_OK);
9531     hr = IXMLDOMNode_get_nodeName(node, &name);
9532     EXPECT_HR(hr, S_OK);
9533     ok(!lstrcmpW(name, _bstr_("a")), "got node name %s\n", wine_dbgstr_w(name));
9534     SysFreeString(name);
9535     IXMLDOMNode_Release(node);
9536     VariantClear(&v);
9537
9538     /* list cursor is updated */
9539     hr = IXMLDOMSelection_nextNode(selection, &node);
9540     EXPECT_HR(hr, S_OK);
9541     hr = IXMLDOMNode_get_nodeName(node, &name);
9542     EXPECT_HR(hr, S_OK);
9543     ok(!lstrcmpW(name, _bstr_("c")), "got node name %s\n", wine_dbgstr_w(name));
9544     IXMLDOMNode_Release(node);
9545     SysFreeString(name);
9546
9547     V_VT(&v) = VT_I2;
9548     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
9549     EXPECT_HR(hr, S_OK);
9550     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
9551     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
9552     EXPECT_HR(hr, S_OK);
9553     hr = IXMLDOMNode_get_nodeName(node, &name);
9554     EXPECT_HR(hr, S_OK);
9555     ok(!lstrcmpW(name, _bstr_("b")), "got node name %s\n", wine_dbgstr_w(name));
9556     SysFreeString(name);
9557     IXMLDOMNode_Release(node);
9558     VariantClear(&v);
9559     IEnumVARIANT_Release(enum1);
9560
9561     hr = IXMLDOMSelection_nextNode(selection, &node);
9562     EXPECT_HR(hr, S_OK);
9563     hr = IXMLDOMNode_get_nodeName(node, &name);
9564     EXPECT_HR(hr, S_OK);
9565     ok(!lstrcmpW(name, _bstr_("d")), "got node name %s\n", wine_dbgstr_w(name));
9566     IXMLDOMNode_Release(node);
9567     SysFreeString(name);
9568
9569     IXMLDOMSelection_Release(selection);
9570     IXMLDOMNodeList_Release(list);
9571     IXMLDOMDocument_Release(doc);
9572
9573     free_bstrs();
9574 }
9575
9576 static void write_to_file(const char *name, const char *data)
9577 {
9578     DWORD written;
9579     HANDLE hfile;
9580     BOOL ret;
9581
9582     hfile = CreateFileA(name, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
9583     ok(hfile != INVALID_HANDLE_VALUE, "failed to create test file: %s\n", name);
9584
9585     ret = WriteFile(hfile, data, strlen(data), &written, NULL);
9586     ok(ret, "WriteFile failed: %s, %d\n", name, GetLastError());
9587
9588     CloseHandle(hfile);
9589 }
9590
9591 static void test_load(void)
9592 {
9593     IXMLDOMDocument *doc, *doc2;
9594     IXMLDOMNodeList *list;
9595     IXMLDOMElement *elem;
9596     VARIANT_BOOL b;
9597     VARIANT src;
9598     HRESULT hr;
9599     BSTR path, bstr1, bstr2;
9600     void* ptr;
9601
9602     /* prepare a file */
9603     write_to_file("test.xml", win1252xml);
9604
9605     doc = create_document(&IID_IXMLDOMDocument);
9606
9607     /* null pointer as input */
9608     V_VT(&src) = VT_UNKNOWN;
9609     V_UNKNOWN(&src) = NULL;
9610     hr = IXMLDOMDocument_load(doc, src, &b);
9611     EXPECT_HR(hr, E_INVALIDARG);
9612     ok(b == VARIANT_FALSE, "got %d\n", b);
9613
9614     path = _bstr_("test.xml");
9615
9616     /* load from path: VT_BSTR */
9617     V_VT(&src) = VT_BSTR;
9618     V_BSTR(&src) = path;
9619     hr = IXMLDOMDocument_load(doc, src, &b);
9620     EXPECT_HR(hr, S_OK);
9621     ok(b == VARIANT_TRUE, "got %d\n", b);
9622
9623     bstr1 = NULL;
9624     hr = IXMLDOMDocument_get_url(doc, &bstr1);
9625     ok(hr == S_OK, "got 0x%08x\n", hr);
9626     SysFreeString(bstr1);
9627
9628     /* load from a path: VT_BSTR|VT_BYREF */
9629     V_VT(&src) = VT_BSTR | VT_BYREF;
9630     V_BSTRREF(&src) = &path;
9631     hr = IXMLDOMDocument_load(doc, src, &b);
9632     EXPECT_HR(hr, S_OK);
9633     ok(b == VARIANT_TRUE, "got %d\n", b);
9634
9635     bstr1 = NULL;
9636     hr = IXMLDOMDocument_get_url(doc, &bstr1);
9637     ok(hr == S_OK, "got 0x%08x\n", hr);
9638
9639     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
9640     ok(hr == S_OK, "got 0x%08x\n", hr);
9641
9642     /* create another instance for the same document, check url */
9643     hr = IXMLDOMElement_get_ownerDocument(elem, &doc2);
9644     ok(hr == S_OK, "got 0x%08x\n", hr);
9645
9646     hr = IXMLDOMDocument_get_url(doc, &bstr2);
9647     ok(hr == S_OK, "got 0x%08x\n", hr);
9648     ok(!lstrcmpW(bstr1, bstr2), "got %s\n", wine_dbgstr_w(bstr2));
9649
9650     IXMLDOMDocument_Release(doc2);
9651     IXMLDOMElement_Release(elem);
9652
9653     SysFreeString(bstr1);
9654     SysFreeString(bstr2);
9655
9656     /* load from a path: VT_BSTR|VT_BYREF, null ptr */
9657     V_VT(&src) = VT_BSTR | VT_BYREF;
9658     V_BSTRREF(&src) = NULL;
9659     hr = IXMLDOMDocument_load(doc, src, &b);
9660     EXPECT_HR(hr, E_INVALIDARG);
9661     ok(b == VARIANT_FALSE, "got %d\n", b);
9662
9663     bstr1 = NULL;
9664     hr = IXMLDOMDocument_get_url(doc, &bstr1);
9665     ok(hr == S_OK, "got 0x%08x\n", hr);
9666     SysFreeString(bstr1);
9667
9668     DeleteFileA("test.xml");
9669
9670     /* load from existing path, no xml content */
9671     write_to_file("test.xml", nocontent);
9672
9673     V_VT(&src) = VT_BSTR;
9674     V_BSTR(&src) = path;
9675     b = VARIANT_TRUE;
9676     hr = IXMLDOMDocument_load(doc, src, &b);
9677     ok(hr == S_FALSE, "got 0x%08x\n", hr);
9678     ok(b == VARIANT_FALSE, "got %d\n", b);
9679
9680     bstr1 = (BSTR)0x1;
9681     hr = IXMLDOMDocument_get_url(doc, &bstr1);
9682     ok(hr == S_FALSE, "got 0x%08x\n", hr);
9683     ok(bstr1 == NULL, "got %p\n", bstr1);
9684
9685     DeleteFileA("test.xml");
9686     IXMLDOMDocument_Release(doc);
9687
9688     doc = create_document(&IID_IXMLDOMDocument);
9689
9690     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
9691     EXPECT_HR(hr, S_OK);
9692     ok(b == VARIANT_TRUE, "got %d\n", b);
9693
9694     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
9695     EXPECT_HR(hr, S_OK);
9696     bstr1 = _bstr_(list_to_string(list));
9697
9698     hr = IXMLDOMNodeList_reset(list);
9699     EXPECT_HR(hr, S_OK);
9700
9701     IXMLDOMDocument_Release(doc);
9702
9703     doc = create_document(&IID_IXMLDOMDocument);
9704
9705     VariantInit(&src);
9706     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenA(szExampleXML));
9707     V_VT(&src) = VT_ARRAY|VT_UI1;
9708     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
9709     ptr = NULL;
9710     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
9711     EXPECT_HR(hr, S_OK);
9712     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
9713
9714     memcpy(ptr, szExampleXML, lstrlenA(szExampleXML));
9715     hr = SafeArrayUnlock(V_ARRAY(&src));
9716     EXPECT_HR(hr, S_OK);
9717
9718     hr = IXMLDOMDocument_load(doc, src, &b);
9719     EXPECT_HR(hr, S_OK);
9720     ok(b == VARIANT_TRUE, "got %d\n", b);
9721
9722     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
9723     EXPECT_HR(hr, S_OK);
9724     bstr2 = _bstr_(list_to_string(list));
9725
9726     hr = IXMLDOMNodeList_reset(list);
9727     EXPECT_HR(hr, S_OK);
9728
9729     ok(lstrcmpW(bstr1, bstr2) == 0, "strings not equal: %s : %s\n",
9730        wine_dbgstr_w(bstr1), wine_dbgstr_w(bstr2));
9731
9732     IXMLDOMDocument_Release(doc);
9733     IXMLDOMNodeList_Release(list);
9734     VariantClear(&src);
9735
9736     /* UTF-16 isn't accepted */
9737     doc = create_document(&IID_IXMLDOMDocument);
9738
9739     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenW(szComplete1) * sizeof(WCHAR));
9740     V_VT(&src) = VT_ARRAY|VT_UI1;
9741     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
9742     ptr = NULL;
9743     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
9744     EXPECT_HR(hr, S_OK);
9745     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
9746
9747     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
9748     hr = SafeArrayUnlock(V_ARRAY(&src));
9749     EXPECT_HR(hr, S_OK);
9750
9751     hr = IXMLDOMDocument_load(doc, src, &b);
9752     todo_wine EXPECT_HR(hr, S_FALSE);
9753     todo_wine ok(b == VARIANT_FALSE, "got %d\n", b);
9754
9755     VariantClear(&src);
9756
9757     /* it doesn't like it as a VT_ARRAY|VT_UI2 either */
9758     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI2, 0, lstrlenW(szComplete1));
9759     V_VT(&src) = VT_ARRAY|VT_UI2;
9760     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
9761     ptr = NULL;
9762     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
9763     EXPECT_HR(hr, S_OK);
9764     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
9765
9766     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
9767     hr = SafeArrayUnlock(V_ARRAY(&src));
9768     EXPECT_HR(hr, S_OK);
9769
9770     hr = IXMLDOMDocument_load(doc, src, &b);
9771     todo_wine EXPECT_HR(hr, E_INVALIDARG);
9772     ok(b == VARIANT_FALSE, "got %d\n", b);
9773
9774     VariantClear(&src);
9775     IXMLDOMDocument_Release(doc);
9776
9777     free_bstrs();
9778 }
9779
9780 static void test_domobj_dispex(IUnknown *obj)
9781 {
9782     static const WCHAR testW[] = {'t','e','s','t','p','r','o','p',0};
9783     DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
9784     IDispatchEx *dispex;
9785     IUnknown *unk;
9786     DWORD props;
9787     UINT ticnt;
9788     HRESULT hr;
9789     BSTR name;
9790
9791     hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
9792     EXPECT_HR(hr, S_OK);
9793     if (FAILED(hr)) return;
9794
9795     ticnt = 0;
9796     hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
9797     EXPECT_HR(hr, S_OK);
9798     ok(ticnt == 1, "ticnt=%u\n", ticnt);
9799
9800     name = SysAllocString(szstar);
9801     hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
9802     EXPECT_HR(hr, E_NOTIMPL);
9803     SysFreeString(name);
9804
9805     hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
9806     EXPECT_HR(hr, E_NOTIMPL);
9807
9808     props = 0;
9809     hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
9810     EXPECT_HR(hr, E_NOTIMPL);
9811     ok(props == 0, "expected 0 got %d\n", props);
9812
9813     hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
9814     EXPECT_HR(hr, E_NOTIMPL);
9815     if (SUCCEEDED(hr)) SysFreeString(name);
9816
9817     hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
9818     EXPECT_HR(hr, E_NOTIMPL);
9819
9820     unk = (IUnknown*)0xdeadbeef;
9821     hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
9822     EXPECT_HR(hr, E_NOTIMPL);
9823     ok(unk == (IUnknown*)0xdeadbeef, "got %p\n", unk);
9824
9825     name = SysAllocString(testW);
9826     hr = IDispatchEx_GetDispID(dispex, name, fdexNameEnsure, &dispid);
9827     ok(hr == DISP_E_UNKNOWNNAME, "got 0x%08x\n", hr);
9828     SysFreeString(name);
9829
9830     IDispatchEx_Release(dispex);
9831 }
9832
9833 static void test_mxnamespacemanager(void)
9834 {
9835     static const char xmluriA[] = "http://www.w3.org/XML/1998/namespace";
9836     IMXNamespacePrefixes *prefixes;
9837     IVBMXNamespaceManager *mgr2;
9838     IMXNamespaceManager *nsmgr;
9839     IUnknown *unk1, *unk2;
9840     WCHAR buffW[250];
9841     IDispatch *disp;
9842     IUnknown *unk;
9843     HRESULT hr;
9844     INT len;
9845
9846     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
9847         &IID_IMXNamespaceManager, (void**)&nsmgr);
9848     EXPECT_HR(hr, S_OK);
9849
9850     /* IMXNamespaceManager inherits from IUnknown */
9851     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IDispatch, (void**)&disp);
9852     EXPECT_HR(hr, S_OK);
9853     IDispatch_Release(disp);
9854
9855     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IVBMXNamespaceManager, (void**)&mgr2);
9856     EXPECT_HR(hr, S_OK);
9857
9858     EXPECT_REF(nsmgr, 2);
9859     EXPECT_REF(mgr2, 2);
9860     prefixes = NULL;
9861     hr = IVBMXNamespaceManager_getDeclaredPrefixes(mgr2, &prefixes);
9862 todo_wine
9863     ok(hr == S_OK, "got 0x%08x\n", hr);
9864     if (hr == S_OK)
9865     {
9866         IDispatchEx *dispex;
9867         VARIANT arg, ret;
9868         DISPPARAMS dispparams;
9869
9870         ok(prefixes != NULL, "got %p\n", prefixes);
9871         EXPECT_REF(nsmgr, 2);
9872         EXPECT_REF(mgr2, 2);
9873         EXPECT_REF(prefixes, 1);
9874
9875         IVBMXNamespaceManager_QueryInterface(mgr2, &IID_IUnknown, (void**)&unk1);
9876         IMXNamespacePrefixes_QueryInterface(prefixes, &IID_IUnknown, (void**)&unk2);
9877
9878         EXPECT_REF(mgr2, 3);
9879         EXPECT_REF(prefixes, 2);
9880
9881         IUnknown_Release(unk1);
9882         IUnknown_Release(unk2);
9883
9884         hr = IMXNamespacePrefixes_QueryInterface(prefixes, &IID_IDispatchEx, (void**)&dispex);
9885         ok(hr == S_OK, "got 0x%08x\n", hr);
9886
9887         V_VT(&arg) = VT_I4;
9888         V_I4(&arg) = 0;
9889         dispparams.cArgs = 1;
9890         dispparams.cNamedArgs = 0;
9891         dispparams.rgdispidNamedArgs = NULL;
9892         dispparams.rgvarg = &arg;
9893
9894         V_VT(&ret) = VT_EMPTY;
9895         V_DISPATCH(&ret) = (void*)0x1;
9896         hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
9897         ok(hr == S_OK, "got 0x%08x\n", hr);
9898         ok(V_VT(&ret) == VT_BSTR, "got %d\n", V_VT(&ret));
9899         ok(V_BSTR(&ret) != NULL, "got %p\n", V_BSTR(&ret));
9900         VariantClear(&ret);
9901
9902         IDispatchEx_Release(dispex);
9903         IMXNamespacePrefixes_Release(prefixes);
9904     }
9905     IVBMXNamespaceManager_Release(mgr2);
9906
9907     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
9908     EXPECT_HR(hr, S_OK);
9909
9910     /* prefix already added */
9911     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
9912     EXPECT_HR(hr, S_FALSE);
9913
9914     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), NULL);
9915     EXPECT_HR(hr, E_INVALIDARG);
9916
9917     /* "xml" and "xmlns" are not allowed here */
9918     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xml"), _bstr_("uri1"));
9919     EXPECT_HR(hr, E_INVALIDARG);
9920
9921     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xmlns"), _bstr_("uri1"));
9922     EXPECT_HR(hr, E_INVALIDARG);
9923 todo_wine {
9924     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, -1, NULL, NULL);
9925     EXPECT_HR(hr, E_FAIL);
9926 }
9927     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, NULL);
9928     EXPECT_HR(hr, E_POINTER);
9929
9930     len = -1;
9931     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, &len);
9932     EXPECT_HR(hr, S_OK);
9933     ok(len == 3, "got %d\n", len);
9934
9935     len = -1;
9936     buffW[0] = 0x1;
9937     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
9938     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
9939     ok(len == -1, "got %d\n", len);
9940     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9941
9942     len = 10;
9943     buffW[0] = 0x1;
9944     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
9945     EXPECT_HR(hr, S_OK);
9946     ok(len == 3, "got %d\n", len);
9947     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
9948
9949     /* getURI */
9950     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, NULL);
9951     EXPECT_HR(hr, E_INVALIDARG);
9952
9953     len = -1;
9954     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, &len);
9955     EXPECT_HR(hr, E_INVALIDARG);
9956     ok(len == -1, "got %d\n", len);
9957
9958     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, NULL);
9959     EXPECT_HR(hr, E_POINTER);
9960
9961     len = -1;
9962     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, &len);
9963     EXPECT_HR(hr, S_OK);
9964     /* length of "xml" uri is constant */
9965     ok(len == strlen(xmluriA), "got %d\n", len);
9966
9967     len = 100;
9968     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
9969     EXPECT_HR(hr, S_OK);
9970     ok(len == strlen(xmluriA), "got %d\n", len);
9971     ok(!lstrcmpW(buffW, _bstr_(xmluriA)), "got prefix %s\n", wine_dbgstr_w(buffW));
9972
9973     len = strlen(xmluriA)-1;
9974     buffW[0] = 0x1;
9975     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
9976     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
9977     ok(len == strlen(xmluriA)-1, "got %d\n", len);
9978     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9979
9980     /* prefix xml1 not defined */
9981     len = -1;
9982     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, NULL, &len);
9983     EXPECT_HR(hr, S_FALSE);
9984     ok(len == 0, "got %d\n", len);
9985
9986     len = 100;
9987     buffW[0] = 0x1;
9988     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, buffW, &len);
9989     EXPECT_HR(hr, S_FALSE);
9990     ok(buffW[0] == 0, "got %x\n", buffW[0]);
9991     ok(len == 0, "got %d\n", len);
9992
9993     /* IDispatchEx tests */
9994     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IUnknown, (void**)&unk);
9995     EXPECT_HR(hr, S_OK);
9996     test_domobj_dispex(unk);
9997     IUnknown_Release(unk);
9998
9999     IMXNamespaceManager_Release(nsmgr);
10000
10001     /* ::getPrefix() */
10002     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10003         &IID_IMXNamespaceManager, (void**)&nsmgr);
10004     EXPECT_HR(hr, S_OK);
10005
10006     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, NULL);
10007     EXPECT_HR(hr, E_INVALIDARG);
10008
10009     len = -1;
10010     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, &len);
10011     EXPECT_HR(hr, E_INVALIDARG);
10012     ok(len == -1, "got %d\n", len);
10013
10014     len = 100;
10015     buffW[0] = 0x1;
10016     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
10017     EXPECT_HR(hr, E_FAIL);
10018     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10019     ok(len == 100, "got %d\n", len);
10020
10021     len = 0;
10022     buffW[0] = 0x1;
10023     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
10024     EXPECT_HR(hr, E_FAIL);
10025     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10026     ok(len == 0, "got %d\n", len);
10027
10028     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
10029     EXPECT_HR(hr, S_OK);
10030
10031     len = 100;
10032     buffW[0] = 0x1;
10033     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10034     EXPECT_HR(hr, S_OK);
10035     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10036     ok(len == 3, "got %d\n", len);
10037
10038     len = 100;
10039     buffW[0] = 0x1;
10040     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, buffW, &len);
10041     EXPECT_HR(hr, S_OK);
10042     ok(!lstrcmpW(buffW, _bstr_("xml")), "got %s\n", wine_dbgstr_w(buffW));
10043     ok(len == 3, "got %d\n", len);
10044
10045     /* with null buffer it's possible to get required length */
10046     len = 100;
10047     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
10048     EXPECT_HR(hr, S_OK);
10049     ok(len == 3, "got %d\n", len);
10050
10051     len = 0;
10052     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
10053     EXPECT_HR(hr, S_OK);
10054     ok(len == 3, "got %d\n", len);
10055
10056     len = 100;
10057     buffW[0] = 0x1;
10058     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 1, buffW, &len);
10059     EXPECT_HR(hr, E_FAIL);
10060     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10061     ok(len == 100, "got %d\n", len);
10062
10063     len = 100;
10064     buffW[0] = 0x1;
10065     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 2, buffW, &len);
10066     EXPECT_HR(hr, E_FAIL);
10067     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10068     ok(len == 100, "got %d\n", len);
10069
10070     len = 100;
10071     buffW[0] = 0x1;
10072     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 0, buffW, &len);
10073     EXPECT_HR(hr, E_INVALIDARG);
10074     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10075     ok(len == 100, "got %d\n", len);
10076
10077     len = 100;
10078     buffW[0] = 0x1;
10079     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
10080     EXPECT_HR(hr, E_INVALIDARG);
10081     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10082     ok(len == 100, "got %d\n", len);
10083
10084     len = 100;
10085     buffW[0] = 0x1;
10086     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, buffW, &len);
10087     EXPECT_HR(hr, E_INVALIDARG);
10088     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10089     ok(len == 100, "got %d\n", len);
10090
10091     len = 100;
10092     buffW[0] = 0x1;
10093     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 1, buffW, &len);
10094     EXPECT_HR(hr, E_FAIL);
10095     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10096     ok(len == 100, "got %d\n", len);
10097
10098     len = 100;
10099     buffW[0] = 0x1;
10100     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
10101     EXPECT_HR(hr, E_INVALIDARG);
10102     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10103     ok(len == 100, "got %d\n", len);
10104
10105     /* declare another one, indices are shifted */
10106     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
10107     EXPECT_HR(hr, S_OK);
10108
10109     len = 100;
10110     buffW[0] = 0x1;
10111     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10112     EXPECT_HR(hr, S_OK);
10113     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10114     ok(len == 3, "got %d\n", len);
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     len = 100;
10124     buffW[0] = 0x1;
10125     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 1, buffW, &len);
10126     EXPECT_HR(hr, E_FAIL);
10127     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10128     ok(len == 100, "got %d\n", len);
10129
10130     len = 100;
10131     buffW[0] = 0x1;
10132     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
10133     EXPECT_HR(hr, E_INVALIDARG);
10134     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10135     ok(len == 100, "got %d\n", len);
10136
10137     IMXNamespaceManager_Release(nsmgr);
10138
10139     /* push/pop tests */
10140     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10141         &IID_IMXNamespaceManager, (void**)&nsmgr);
10142     EXPECT_HR(hr, S_OK);
10143
10144     /* pop with empty stack */
10145     hr = IMXNamespaceManager_popContext(nsmgr);
10146     EXPECT_HR(hr, E_FAIL);
10147
10148     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
10149     EXPECT_HR(hr, S_OK);
10150
10151     len = 100;
10152     buffW[0] = 0x1;
10153     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10154     EXPECT_HR(hr, S_OK);
10155     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10156     ok(len == 3, "got %d\n", len);
10157
10158     hr = IMXNamespaceManager_pushContext(nsmgr);
10159     EXPECT_HR(hr, S_OK);
10160
10161     len = 100;
10162     buffW[0] = 0x1;
10163     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10164     EXPECT_HR(hr, S_OK);
10165     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10166     ok(len == 3, "got %d\n", len);
10167
10168     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
10169     EXPECT_HR(hr, S_OK);
10170
10171     len = 100;
10172     buffW[0] = 0x1;
10173     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10174     EXPECT_HR(hr, S_OK);
10175     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
10176     ok(len == 3, "got %d\n", len);
10177
10178     hr = IMXNamespaceManager_pushContext(nsmgr);
10179     EXPECT_HR(hr, S_OK);
10180     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns3"), _bstr_("ns3 uri"));
10181     EXPECT_HR(hr, S_OK);
10182
10183     len = 100;
10184     buffW[0] = 0x1;
10185     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10186     EXPECT_HR(hr, S_OK);
10187     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
10188     ok(len == 3, "got %d\n", len);
10189
10190     len = 100;
10191     buffW[0] = 0x1;
10192     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10193     EXPECT_HR(hr, S_OK);
10194     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10195     ok(len == 3, "got %d\n", len);
10196
10197     hr = IMXNamespaceManager_popContext(nsmgr);
10198     EXPECT_HR(hr, S_OK);
10199
10200     hr = IMXNamespaceManager_popContext(nsmgr);
10201     EXPECT_HR(hr, S_OK);
10202
10203     len = 100;
10204     buffW[0] = 0x1;
10205     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
10206     EXPECT_HR(hr, E_FAIL);
10207     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10208     ok(len == 100, "got %d\n", len);
10209
10210     len = 100;
10211     buffW[0] = 0x1;
10212     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
10213     EXPECT_HR(hr, S_OK);
10214     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
10215     ok(len == 3, "got %d\n", len);
10216
10217     IMXNamespaceManager_Release(nsmgr);
10218
10219     free_bstrs();
10220 }
10221
10222 static void test_mxnamespacemanager_override(void)
10223 {
10224     IMXNamespaceManager *nsmgr;
10225     WCHAR buffW[250];
10226     VARIANT_BOOL b;
10227     HRESULT hr;
10228     INT len;
10229
10230     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10231         &IID_IMXNamespaceManager, (void**)&nsmgr);
10232     EXPECT_HR(hr, S_OK);
10233
10234     len = sizeof(buffW)/sizeof(WCHAR);
10235     buffW[0] = 0;
10236     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10237     EXPECT_HR(hr, S_OK);
10238     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10239
10240     len = sizeof(buffW)/sizeof(WCHAR);
10241     buffW[0] = 0;
10242     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10243     EXPECT_HR(hr, E_FAIL);
10244
10245     hr = IMXNamespaceManager_getAllowOverride(nsmgr, NULL);
10246     EXPECT_HR(hr, E_POINTER);
10247
10248     b = VARIANT_FALSE;
10249     hr = IMXNamespaceManager_getAllowOverride(nsmgr, &b);
10250     EXPECT_HR(hr, S_OK);
10251     ok(b == VARIANT_TRUE, "got %d\n", b);
10252
10253     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_FALSE);
10254     EXPECT_HR(hr, S_OK);
10255
10256     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10257     EXPECT_HR(hr, S_OK);
10258
10259     len = sizeof(buffW)/sizeof(WCHAR);
10260     buffW[0] = 0;
10261     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
10262     EXPECT_HR(hr, S_OK);
10263     ok(!lstrcmpW(buffW, _bstr_("ns0 uri")), "got uri %s\n", wine_dbgstr_w(buffW));
10264
10265     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), _bstr_("ns0 uri"));
10266     EXPECT_HR(hr, S_OK);
10267
10268     len = sizeof(buffW)/sizeof(WCHAR);
10269     buffW[0] = 0;
10270     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10271     EXPECT_HR(hr, S_OK);
10272     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10273
10274     len = sizeof(buffW)/sizeof(WCHAR);
10275     buffW[0] = 0;
10276     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10277     EXPECT_HR(hr, S_OK);
10278     ok(!lstrcmpW(buffW, _bstr_("ns0")), "got prefix %s\n", wine_dbgstr_w(buffW));
10279
10280     len = sizeof(buffW)/sizeof(WCHAR);
10281     buffW[0] = 0;
10282     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 2, buffW, &len);
10283     EXPECT_HR(hr, S_OK);
10284     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
10285
10286     /* new prefix placed at index 1 always */
10287     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
10288     EXPECT_HR(hr, S_OK);
10289
10290     len = sizeof(buffW)/sizeof(WCHAR);
10291     buffW[0] = 0;
10292     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10293     EXPECT_HR(hr, S_OK);
10294     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got prefix %s\n", wine_dbgstr_w(buffW));
10295
10296     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_(""), NULL);
10297     todo_wine EXPECT_HR(hr, E_FAIL);
10298
10299     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
10300     EXPECT_HR(hr, E_FAIL);
10301
10302     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10303     EXPECT_HR(hr, E_FAIL);
10304
10305     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_TRUE);
10306     EXPECT_HR(hr, S_OK);
10307
10308     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri override"));
10309     EXPECT_HR(hr, S_FALSE);
10310
10311     len = sizeof(buffW)/sizeof(WCHAR);
10312     buffW[0] = 0;
10313     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
10314     EXPECT_HR(hr, S_OK);
10315     ok(!lstrcmpW(buffW, _bstr_("ns0 uri override")), "got uri %s\n", wine_dbgstr_w(buffW));
10316
10317     len = sizeof(buffW)/sizeof(WCHAR);
10318     buffW[0] = 0;
10319     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 3, buffW, &len);
10320     EXPECT_HR(hr, S_OK);
10321     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
10322
10323     IMXNamespaceManager_Release(nsmgr);
10324
10325     free_bstrs();
10326 }
10327
10328 static const DOMNodeType nodetypes_test[] =
10329 {
10330     NODE_ELEMENT,
10331     NODE_ATTRIBUTE,
10332     NODE_TEXT,
10333     NODE_CDATA_SECTION,
10334     NODE_ENTITY_REFERENCE,
10335     NODE_PROCESSING_INSTRUCTION,
10336     NODE_COMMENT,
10337     NODE_DOCUMENT_FRAGMENT,
10338     NODE_INVALID
10339 };
10340
10341 static void test_dispex(void)
10342 {
10343     const DOMNodeType *type = nodetypes_test;
10344     IXMLDOMImplementation *impl;
10345     IXMLDOMNodeList *node_list;
10346     IXMLDOMParseError *error;
10347     IXMLDOMNamedNodeMap *map;
10348     IXSLProcessor *processor;
10349     IXSLTemplate *template;
10350     IXMLDOMDocument *doc;
10351     IXMLHTTPRequest *req;
10352     IXMLDOMElement *elem;
10353     IDispatchEx *dispex;
10354     DISPPARAMS dispparams;
10355     IXMLDOMNode *node;
10356     VARIANT arg, ret;
10357     VARIANT_BOOL b;
10358     IUnknown *unk;
10359     HRESULT hr;
10360     DISPID did;
10361
10362     doc = create_document(&IID_IXMLDOMDocument);
10363
10364     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
10365     ok(hr == S_OK, "got 0x%08x\n", hr);
10366     test_domobj_dispex(unk);
10367     IUnknown_Release(unk);
10368
10369     for(; *type != NODE_INVALID; type++)
10370     {
10371         IXMLDOMNode *node;
10372         VARIANT v;
10373
10374         V_VT(&v) = VT_I2;
10375         V_I2(&v) = *type;
10376
10377         hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
10378         ok(hr == S_OK, "failed to create node type %d\n", *type);
10379
10380         IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
10381
10382         test_domobj_dispex(unk);
10383         IUnknown_Release(unk);
10384         IXMLDOMNode_Release(node);
10385     }
10386
10387     /* IXMLDOMNodeList */
10388     hr = IXMLDOMDocument_getElementsByTagName(doc, _bstr_("*"), &node_list);
10389     EXPECT_HR(hr, S_OK);
10390     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
10391     test_domobj_dispex(unk);
10392     IUnknown_Release(unk);
10393     IXMLDOMNodeList_Release(node_list);
10394
10395     /* IXMLDOMNodeList for children list */
10396     hr = IXMLDOMDocument_get_childNodes(doc, &node_list);
10397     EXPECT_HR(hr, S_OK);
10398     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
10399     ok(hr == S_OK, "got 0x%08x\n", hr);
10400     test_domobj_dispex(unk);
10401     IUnknown_Release(unk);
10402
10403     /* collection dispex test, empty collection */
10404     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatchEx, (void**)&dispex);
10405     EXPECT_HR(hr, S_OK);
10406     did = 0;
10407     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10408     EXPECT_HR(hr, S_OK);
10409     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10410     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
10411     EXPECT_HR(hr, S_OK);
10412     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
10413     IDispatchEx_Release(dispex);
10414
10415     did = -1;
10416     hr = IDispatchEx_GetDispID(dispex, _bstr_("item"), 0, &did);
10417     ok(hr == S_OK, "got 0x%08x\n", hr);
10418     ok(did == DISPID_VALUE, "got %d\n", did);
10419
10420     V_VT(&arg) = VT_I4;
10421     V_I4(&arg) = 0;
10422     dispparams.cArgs = 0;
10423     dispparams.cNamedArgs = 0;
10424     dispparams.rgdispidNamedArgs = NULL;
10425     dispparams.rgvarg = &arg;
10426
10427     V_VT(&ret) = VT_EMPTY;
10428     V_DISPATCH(&ret) = (void*)0x1;
10429     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10430     ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
10431     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10432 todo_wine
10433     ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
10434
10435     V_VT(&arg) = VT_I4;
10436     V_I4(&arg) = 0;
10437     dispparams.cArgs = 2;
10438     dispparams.cNamedArgs = 0;
10439     dispparams.rgdispidNamedArgs = NULL;
10440     dispparams.rgvarg = &arg;
10441
10442     V_VT(&ret) = VT_EMPTY;
10443     V_DISPATCH(&ret) = (void*)0x1;
10444     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10445     ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
10446     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10447 todo_wine
10448     ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
10449
10450     V_VT(&arg) = VT_I4;
10451     V_I4(&arg) = 0;
10452     dispparams.cArgs = 1;
10453     dispparams.cNamedArgs = 0;
10454     dispparams.rgdispidNamedArgs = NULL;
10455     dispparams.rgvarg = &arg;
10456
10457     V_VT(&ret) = VT_EMPTY;
10458     V_DISPATCH(&ret) = (void*)0x1;
10459     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10460     ok(hr == S_OK, "got 0x%08x\n", hr);
10461     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10462     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10463
10464     V_VT(&ret) = VT_EMPTY;
10465     V_DISPATCH(&ret) = (void*)0x1;
10466     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10467     ok(hr == S_OK, "got 0x%08x\n", hr);
10468     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10469     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10470
10471     V_VT(&ret) = VT_EMPTY;
10472     V_DISPATCH(&ret) = (void*)0x1;
10473     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10474     ok(hr == S_OK, "got 0x%08x\n", hr);
10475     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10476     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10477
10478     dispparams.cArgs = 0;
10479     dispparams.cNamedArgs = 0;
10480     dispparams.rgdispidNamedArgs = NULL;
10481     dispparams.rgvarg = NULL;
10482
10483     V_VT(&ret) = VT_EMPTY;
10484     V_I4(&ret) = 1;
10485     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10486     ok(hr == S_OK, "got 0x%08x\n", hr);
10487     ok(V_VT(&ret) == VT_I4, "got %d\n", V_VT(&ret));
10488     ok(V_I4(&ret) == 0, "got %d\n", V_I4(&ret));
10489
10490     dispparams.cArgs = 0;
10491     dispparams.cNamedArgs = 0;
10492     dispparams.rgdispidNamedArgs = NULL;
10493     dispparams.rgvarg = NULL;
10494
10495     V_VT(&ret) = VT_EMPTY;
10496     V_I4(&ret) = 1;
10497     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10498     ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
10499     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10500 todo_wine
10501     ok(broken(V_I4(&ret) == 1) || (V_I4(&ret) == 0), "got %d\n", V_I4(&ret));
10502
10503     IXMLDOMNodeList_Release(node_list);
10504
10505     /* IXMLDOMParseError */
10506     hr = IXMLDOMDocument_get_parseError(doc, &error);
10507     EXPECT_HR(hr, S_OK);
10508     IXMLDOMParseError_QueryInterface(error, &IID_IUnknown, (void**)&unk);
10509     test_domobj_dispex(unk);
10510
10511     hr = IXMLDOMParseError_QueryInterface(error, &IID_IDispatchEx, (void**)&dispex);
10512     ok(hr == S_OK, "got 0x%08x\n", hr);
10513
10514     V_VT(&arg) = VT_I4;
10515     V_I4(&arg) = 0;
10516     dispparams.cArgs = 1;
10517     dispparams.cNamedArgs = 0;
10518     dispparams.rgdispidNamedArgs = NULL;
10519     dispparams.rgvarg = &arg;
10520
10521     V_VT(&ret) = VT_EMPTY;
10522     V_DISPATCH(&ret) = (void*)0x1;
10523     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10524     ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
10525     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10526 todo_wine
10527     ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
10528
10529     IDispatchEx_Release(dispex);
10530
10531     IUnknown_Release(unk);
10532     IXMLDOMParseError_Release(error);
10533
10534     /* IXMLDOMNamedNodeMap */
10535     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
10536     EXPECT_HR(hr, S_OK);
10537
10538     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/a"), &node_list);
10539     EXPECT_HR(hr, S_OK);
10540     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
10541     EXPECT_HR(hr, S_OK);
10542     IXMLDOMNodeList_Release(node_list);
10543
10544     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
10545     EXPECT_HR(hr, S_OK);
10546     IXMLDOMNode_Release(node);
10547     hr = IXMLDOMElement_get_attributes(elem, &map);
10548     EXPECT_HR(hr, S_OK);
10549     IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk);
10550     test_domobj_dispex(unk);
10551     IUnknown_Release(unk);
10552     /* collection dispex test */
10553     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
10554     EXPECT_HR(hr, S_OK);
10555     did = 0;
10556     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10557     EXPECT_HR(hr, S_OK);
10558     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10559     IDispatchEx_Release(dispex);
10560     IXMLDOMNamedNodeMap_Release(map);
10561
10562     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/b"), &node_list);
10563     EXPECT_HR(hr, S_OK);
10564     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
10565     EXPECT_HR(hr, S_OK);
10566     IXMLDOMNodeList_Release(node_list);
10567     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
10568     EXPECT_HR(hr, S_OK);
10569     IXMLDOMNode_Release(node);
10570     hr = IXMLDOMElement_get_attributes(elem, &map);
10571     EXPECT_HR(hr, S_OK);
10572     /* collection dispex test, empty collection */
10573     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
10574     EXPECT_HR(hr, S_OK);
10575     did = 0;
10576     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10577     EXPECT_HR(hr, S_OK);
10578     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10579     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
10580     EXPECT_HR(hr, S_OK);
10581     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
10582     IXMLDOMNamedNodeMap_Release(map);
10583
10584     did = -1;
10585     hr = IDispatchEx_GetDispID(dispex, _bstr_("item"), 0, &did);
10586     ok(hr == S_OK, "got 0x%08x\n", hr);
10587     ok(did == DISPID_VALUE, "got %d\n", did);
10588
10589     V_VT(&arg) = VT_I4;
10590     V_I4(&arg) = 0;
10591     dispparams.cArgs = 0;
10592     dispparams.cNamedArgs = 0;
10593     dispparams.rgdispidNamedArgs = NULL;
10594     dispparams.rgvarg = &arg;
10595
10596     V_VT(&ret) = VT_EMPTY;
10597     V_DISPATCH(&ret) = (void*)0x1;
10598     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10599 todo_wine {
10600     ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
10601     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10602 }
10603     ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
10604
10605     V_VT(&arg) = VT_I4;
10606     V_I4(&arg) = 0;
10607     dispparams.cArgs = 2;
10608     dispparams.cNamedArgs = 0;
10609     dispparams.rgdispidNamedArgs = NULL;
10610     dispparams.rgvarg = &arg;
10611
10612     V_VT(&ret) = VT_EMPTY;
10613     V_DISPATCH(&ret) = (void*)0x1;
10614     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10615 todo_wine {
10616     ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
10617     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10618 }
10619     ok(broken(V_DISPATCH(&ret) == (void*)0x1) || (V_DISPATCH(&ret) == NULL), "got %p\n", V_DISPATCH(&ret));
10620
10621     V_VT(&arg) = VT_I4;
10622     V_I4(&arg) = 0;
10623     dispparams.cArgs = 1;
10624     dispparams.cNamedArgs = 0;
10625     dispparams.rgdispidNamedArgs = NULL;
10626     dispparams.rgvarg = &arg;
10627
10628     V_VT(&ret) = VT_EMPTY;
10629     V_DISPATCH(&ret) = (void*)0x1;
10630     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10631 todo_wine
10632     ok(hr == S_OK, "got 0x%08x\n", hr);
10633     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10634     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10635
10636     V_VT(&ret) = VT_EMPTY;
10637     V_DISPATCH(&ret) = (void*)0x1;
10638     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10639     ok(hr == S_OK, "got 0x%08x\n", hr);
10640     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10641     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10642
10643     V_VT(&ret) = VT_EMPTY;
10644     V_DISPATCH(&ret) = (void*)0x1;
10645     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10646     ok(hr == S_OK, "got 0x%08x\n", hr);
10647     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10648     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10649
10650     dispparams.cArgs = 0;
10651     dispparams.cNamedArgs = 0;
10652     dispparams.rgdispidNamedArgs = NULL;
10653     dispparams.rgvarg = NULL;
10654
10655     V_VT(&ret) = VT_EMPTY;
10656     V_I4(&ret) = 1;
10657     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10658     ok(hr == S_OK, "got 0x%08x\n", hr);
10659     ok(V_VT(&ret) == VT_I4, "got %d\n", V_VT(&ret));
10660     ok(V_I4(&ret) == 0, "got %d\n", V_I4(&ret));
10661
10662     dispparams.cArgs = 0;
10663     dispparams.cNamedArgs = 0;
10664     dispparams.rgdispidNamedArgs = NULL;
10665     dispparams.rgvarg = NULL;
10666
10667     V_VT(&ret) = VT_EMPTY;
10668     V_I4(&ret) = 1;
10669     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10670     ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
10671 todo_wine
10672     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10673     ok(broken(V_I4(&ret) == 1) || (V_I4(&ret) == 0), "got %d\n", V_I4(&ret));
10674
10675     IDispatchEx_Release(dispex);
10676     IXMLDOMElement_Release(elem);
10677
10678     /* IXMLDOMImplementation */
10679     hr = IXMLDOMDocument_get_implementation(doc, &impl);
10680     EXPECT_HR(hr, S_OK);
10681
10682     hr = IXMLDOMImplementation_QueryInterface(impl, &IID_IDispatchEx, (void**)&dispex);
10683     EXPECT_HR(hr, S_OK);
10684     IDispatchEx_Release(dispex);
10685     IXMLDOMImplementation_Release(impl);
10686
10687     IXMLDOMDocument_Release(doc);
10688
10689     /* IXMLHTTPRequest */
10690     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
10691         &IID_IXMLHttpRequest, (void**)&req);
10692     if (hr == S_OK)
10693     {
10694         hr = IXMLHTTPRequest_QueryInterface(req, &IID_IDispatchEx, (void**)&dispex);
10695         EXPECT_HR(hr, E_NOINTERFACE);
10696         IXMLHTTPRequest_Release(req);
10697     }
10698
10699     /* IXSLTemplate */
10700     template = create_xsltemplate(&IID_IXSLTemplate);
10701     hr = IXSLTemplate_QueryInterface(template, &IID_IDispatchEx, (void**)&dispex);
10702     EXPECT_HR(hr, S_OK);
10703     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
10704     EXPECT_HR(hr, S_OK);
10705     test_domobj_dispex(unk);
10706     IUnknown_Release(unk);
10707     IDispatchEx_Release(dispex);
10708
10709     /* IXSLProcessor */
10710     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
10711     EXPECT_HR(hr, S_OK);
10712     b = VARIANT_FALSE;
10713     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformSSXML), &b);
10714     EXPECT_HR(hr, S_OK);
10715     ok(b == VARIANT_TRUE, "got %d\n", b);
10716
10717     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
10718     EXPECT_HR(hr, S_OK);
10719     IXMLDOMDocument_Release(doc);
10720
10721     hr = IXSLTemplate_createProcessor(template, &processor);
10722     EXPECT_HR(hr, S_OK);
10723     hr = IXSLProcessor_QueryInterface(processor, &IID_IDispatchEx, (void**)&dispex);
10724     EXPECT_HR(hr, S_OK);
10725     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
10726     EXPECT_HR(hr, S_OK);
10727     test_domobj_dispex(unk);
10728     IUnknown_Release(unk);
10729     IDispatchEx_Release(dispex);
10730
10731     IXSLProcessor_Release(processor);
10732     IXSLTemplate_Release(template);
10733
10734     if (is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument))
10735     {
10736         doc = create_document_version(60, &IID_IXMLDOMDocument);
10737         test_domobj_dispex((IUnknown*)doc);
10738         IXMLDOMDocument_Release(doc);
10739     }
10740
10741     free_bstrs();
10742 }
10743
10744 static void test_parseerror(void)
10745 {
10746     IXMLDOMParseError2 *error2;
10747     IXMLDOMParseError *error;
10748     IXMLDOMDocument *doc;
10749     HRESULT hr;
10750
10751     doc = create_document(&IID_IXMLDOMDocument);
10752
10753     hr = IXMLDOMDocument_get_parseError(doc, &error);
10754     EXPECT_HR(hr, S_OK);
10755
10756     hr = IXMLDOMParseError_get_line(error, NULL);
10757     EXPECT_HR(hr, E_INVALIDARG);
10758
10759     hr = IXMLDOMParseError_get_srcText(error, NULL);
10760     EXPECT_HR(hr, E_INVALIDARG);
10761
10762     hr = IXMLDOMParseError_get_linepos(error, NULL);
10763     EXPECT_HR(hr, E_INVALIDARG);
10764
10765     IXMLDOMParseError_Release(error);
10766     IXMLDOMDocument_Release(doc);
10767
10768     if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument)) return;
10769     doc = create_document_version(60, &IID_IXMLDOMDocument);
10770
10771     hr = IXMLDOMDocument_get_parseError(doc, &error);
10772     EXPECT_HR(hr, S_OK);
10773     hr = IXMLDOMParseError_QueryInterface(error, &IID_IXMLDOMParseError2, (void**)&error2);
10774     EXPECT_HR(hr, S_OK);
10775     IXMLDOMParseError2_Release(error2);
10776     IXMLDOMParseError_Release(error);
10777     IXMLDOMDocument_Release(doc);
10778 }
10779
10780 static void test_getAttributeNode(void)
10781 {
10782     IXMLDOMAttribute *attr;
10783     IXMLDOMDocument *doc;
10784     IXMLDOMElement *elem;
10785     VARIANT_BOOL v;
10786     HRESULT hr;
10787     BSTR str;
10788
10789     doc = create_document(&IID_IXMLDOMDocument);
10790
10791     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &v);
10792     EXPECT_HR(hr, S_OK);
10793
10794     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10795     EXPECT_HR(hr, S_OK);
10796
10797     str = SysAllocString(nonexistent_fileW);
10798     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
10799     EXPECT_HR(hr, E_FAIL);
10800
10801     attr = (IXMLDOMAttribute*)0xdeadbeef;
10802     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
10803     EXPECT_HR(hr, E_FAIL);
10804     ok(attr == NULL, "got %p\n", attr);
10805     SysFreeString(str);
10806
10807     str = SysAllocString(nonexistent_attrW);
10808     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
10809     EXPECT_HR(hr, S_FALSE);
10810
10811     attr = (IXMLDOMAttribute*)0xdeadbeef;
10812     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
10813     EXPECT_HR(hr, S_FALSE);
10814     ok(attr == NULL, "got %p\n", attr);
10815     SysFreeString(str);
10816
10817     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("foo:b"), &attr);
10818     EXPECT_HR(hr, S_OK);
10819     IXMLDOMAttribute_Release(attr);
10820
10821     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("b"), &attr);
10822     EXPECT_HR(hr, S_FALSE);
10823
10824     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("a"), &attr);
10825     EXPECT_HR(hr, S_OK);
10826     IXMLDOMAttribute_Release(attr);
10827
10828     IXMLDOMElement_Release(elem);
10829     IXMLDOMDocument_Release(doc);
10830     free_bstrs();
10831 }
10832
10833 typedef struct {
10834     DOMNodeType type;
10835     const char *name;
10836     REFIID iids[3];
10837 } supporterror_t;
10838
10839 static const supporterror_t supporterror_test[] = {
10840     { NODE_ELEMENT,                "element",   { &IID_IXMLDOMNode, &IID_IXMLDOMElement } },
10841     { NODE_ATTRIBUTE,              "attribute", { &IID_IXMLDOMNode, &IID_IXMLDOMAttribute } },
10842     { NODE_CDATA_SECTION,          "cdata",     { &IID_IXMLDOMNode, &IID_IXMLDOMCDATASection } },
10843     { NODE_ENTITY_REFERENCE,       "entityref", { &IID_IXMLDOMNode, &IID_IXMLDOMEntityReference } },
10844     { NODE_PROCESSING_INSTRUCTION, "pi",        { &IID_IXMLDOMNode, &IID_IXMLDOMProcessingInstruction } },
10845     { NODE_COMMENT,                "comment",   { &IID_IXMLDOMNode, &IID_IXMLDOMComment } },
10846     { NODE_DOCUMENT_FRAGMENT,      "fragment",  { &IID_IXMLDOMNode, &IID_IXMLDOMDocumentFragment } },
10847     { NODE_INVALID }
10848 };
10849
10850 static void test_supporterrorinfo(void)
10851 {
10852     static REFIID iids[5] = { &IID_IXMLDOMNode, &IID_IXMLDOMDocument,
10853                               &IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3 };
10854     const supporterror_t *ptr = supporterror_test;
10855     ISupportErrorInfo *errorinfo, *info2;
10856     IXMLDOMSchemaCollection *schemacache;
10857     IXMLDOMNamedNodeMap *map, *map2;
10858     IXMLDOMDocument *doc;
10859     IXMLDOMElement *elem;
10860     VARIANT_BOOL b;
10861     IUnknown *unk;
10862     REFIID *iid;
10863     void *dummy;
10864     HRESULT hr;
10865
10866     if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument3)) return;
10867     doc = create_document_version(60, &IID_IXMLDOMDocument3);
10868
10869     EXPECT_REF(doc, 1);
10870     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&errorinfo);
10871     EXPECT_HR(hr, S_OK);
10872     EXPECT_REF(doc, 1);
10873     ISupportErrorInfo_AddRef(errorinfo);
10874     EXPECT_REF(errorinfo, 2);
10875     EXPECT_REF(doc, 1);
10876     ISupportErrorInfo_Release(errorinfo);
10877
10878     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&info2);
10879     EXPECT_HR(hr, S_OK);
10880     ok(errorinfo != info2, "got %p, %p\n", info2, errorinfo);
10881
10882     /* error interface can't be queried back for DOM interface */
10883     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMDocument, &dummy);
10884     EXPECT_HR(hr, E_NOINTERFACE);
10885     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMNode, &dummy);
10886     EXPECT_HR(hr, E_NOINTERFACE);
10887
10888     ISupportErrorInfo_Release(info2);
10889
10890     iid = iids;
10891     while (*iid)
10892     {
10893         hr = IXMLDOMDocument_QueryInterface(doc, *iid, (void**)&unk);
10894         EXPECT_HR(hr, S_OK);
10895         if (hr == S_OK)
10896         {
10897             hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
10898             ok(hr == S_OK, "got 0x%08x for %s\n", hr, wine_dbgstr_guid(*iid));
10899             IUnknown_Release(unk);
10900         }
10901
10902         iid++;
10903     }
10904
10905     ISupportErrorInfo_Release(errorinfo);
10906
10907     while (ptr->type != NODE_INVALID)
10908     {
10909         IXMLDOMNode *node;
10910         VARIANT type;
10911
10912         V_VT(&type) = VT_I1;
10913         V_I1(&type) = ptr->type;
10914
10915         hr = IXMLDOMDocument_createNode(doc, type, _bstr_(ptr->name), NULL, &node);
10916         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
10917
10918         EXPECT_REF(node, 1);
10919         hr = IXMLDOMNode_QueryInterface(node, &IID_ISupportErrorInfo, (void**)&errorinfo);
10920         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
10921         EXPECT_REF(node, 1);
10922
10923         hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNode, &dummy);
10924         ok(hr == E_NOINTERFACE, "%d: got 0x%08x\n", ptr->type, hr);
10925
10926         iid = ptr->iids;
10927
10928         while (*iid)
10929         {
10930             hr = IXMLDOMNode_QueryInterface(node, *iid, (void**)&unk);
10931             if (hr == S_OK)
10932             {
10933                 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
10934                 ok(hr == S_OK, "%d: got 0x%08x for %s\n", ptr->type, hr, wine_dbgstr_guid(*iid));
10935                 IUnknown_Release(unk);
10936             }
10937
10938             iid++;
10939         }
10940
10941         ISupportErrorInfo_Release(errorinfo);
10942         IXMLDOMNode_Release(node);
10943         ptr++;
10944     }
10945
10946     /* IXMLDOMNamedNodeMap */
10947     b = VARIANT_FALSE;
10948     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
10949     EXPECT_HR(hr, S_OK);
10950     ok(b == VARIANT_TRUE, "got %d\n", b);
10951
10952     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10953     EXPECT_HR(hr, S_OK);
10954
10955     hr = IXMLDOMElement_get_attributes(elem, &map);
10956     EXPECT_HR(hr, S_OK);
10957
10958     EXPECT_REF(map, 1);
10959     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_ISupportErrorInfo, (void**)&errorinfo);
10960     EXPECT_HR(hr, S_OK);
10961     EXPECT_REF(map, 2);
10962
10963     hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMNamedNodeMap);
10964     EXPECT_HR(hr, S_OK);
10965
10966     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNamedNodeMap, (void**)&map2);
10967     EXPECT_HR(hr, S_OK);
10968     ok(map == map2, "got %p\n", map2);
10969     IXMLDOMNamedNodeMap_Release(map2);
10970
10971     EXPECT_REF(errorinfo, 2);
10972     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IUnknown, (void**)&unk);
10973     EXPECT_HR(hr, S_OK);
10974     EXPECT_REF(errorinfo, 3);
10975     EXPECT_REF(map, 3);
10976     IUnknown_Release(unk);
10977
10978     ISupportErrorInfo_Release(errorinfo);
10979     IXMLDOMNamedNodeMap_Release(map);
10980     IXMLDOMElement_Release(elem);
10981
10982     IXMLDOMDocument_Release(doc);
10983
10984     /* IXMLDOMSchemaCollection */
10985     hr = CoCreateInstance(&CLSID_XMLSchemaCache, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMSchemaCollection, (void**)&schemacache);
10986     ok(hr == S_OK, "failed to create schema collection, 0x%08x\n", hr);
10987
10988     hr = IXMLDOMSchemaCollection_QueryInterface(schemacache, &IID_ISupportErrorInfo, (void**)&errorinfo);
10989     ok(hr == S_OK, "got 0x%08x\n", hr);
10990
10991     hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMSchemaCollection);
10992     ok(hr == S_OK, "got 0x%08x\n", hr);
10993
10994     ISupportErrorInfo_Release(errorinfo);
10995     IXMLDOMSchemaCollection_Release(schemacache);
10996
10997     free_bstrs();
10998 }
10999
11000 typedef struct {
11001     DOMNodeType type;
11002     const char *name;
11003     const char *put_content;
11004     HRESULT put_hr;
11005     VARTYPE get_vt;
11006     HRESULT get_hr;
11007 } node_value_t;
11008
11009 static const node_value_t nodevalue_test[] = {
11010     { NODE_ELEMENT,                "element",   "",             E_FAIL, VT_NULL, S_FALSE },
11011     { NODE_ATTRIBUTE,              "attr",      "value",        S_OK,   VT_BSTR, S_OK },
11012     { NODE_TEXT,                   "text",      "textdata",     S_OK,   VT_BSTR, S_OK },
11013     { NODE_CDATA_SECTION ,         "cdata",     "cdata data",   S_OK,   VT_BSTR, S_OK },
11014     { NODE_ENTITY_REFERENCE,       "entityref", "ref",          E_FAIL, VT_NULL, S_FALSE },
11015     { NODE_PROCESSING_INSTRUCTION, "pi",        "instr",        S_OK,   VT_BSTR, S_OK },
11016     { NODE_COMMENT,                "comment",   "comment data", S_OK,   VT_BSTR, S_OK },
11017     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   "",             E_FAIL, VT_NULL, S_FALSE },
11018     { NODE_INVALID }
11019 };
11020
11021 static void test_nodeValue(void)
11022 {
11023     const node_value_t *ptr = nodevalue_test;
11024     IXMLDOMDocument *doc;
11025     HRESULT hr;
11026
11027     doc = create_document(&IID_IXMLDOMDocument);
11028
11029     while (ptr->type != NODE_INVALID)
11030     {
11031         IXMLDOMNode *node;
11032         VARIANT v;
11033
11034         V_VT(&v) = VT_I2;
11035         V_I2(&v) = ptr->type;
11036
11037         hr = IXMLDOMDocument_createNode(doc, v, _bstr_(ptr->name), NULL, &node);
11038         ok(hr == S_OK, "failed to create node type %d\n", ptr->type);
11039
11040         hr = IXMLDOMNode_get_nodeValue(node, NULL);
11041         ok(hr == E_INVALIDARG, "%d: got 0x%08x\n", ptr->type, hr);
11042
11043         V_VT(&v) = VT_BSTR;
11044         V_BSTR(&v) = _bstr_(ptr->put_content);
11045         hr = IXMLDOMNode_put_nodeValue(node, v);
11046         ok(hr == ptr->put_hr, "%d: got 0x%08x\n", ptr->type, hr);
11047
11048         V_VT(&v) = VT_EMPTY;
11049         hr = IXMLDOMNode_get_nodeValue(node, &v);
11050         ok(hr == ptr->get_hr, "%d: got 0x%08x, expected 0x%08x\n", ptr->type, hr, ptr->get_hr);
11051         ok(V_VT(&v) == ptr->get_vt, "%d: got %d, expected %d\n", ptr->type, V_VT(&v), ptr->get_vt);
11052         if (hr == S_OK)
11053             ok(!lstrcmpW(V_BSTR(&v), _bstr_(ptr->put_content)), "%d: got %s\n", ptr->type,
11054                 wine_dbgstr_w(V_BSTR(&v)));
11055         VariantClear(&v);
11056
11057         IXMLDOMNode_Release(node);
11058
11059         ptr++;
11060     }
11061
11062     IXMLDOMDocument_Release(doc);
11063 }
11064
11065 static void test_xmlns_attribute(void)
11066 {
11067     BSTR str;
11068     IXMLDOMDocument *doc;
11069     IXMLDOMElement *root;
11070     IXMLDOMAttribute *pAttribute;
11071     IXMLDOMElement *elem;
11072     HRESULT hr;
11073     VARIANT v;
11074
11075     doc = create_document(&IID_IXMLDOMDocument);
11076
11077     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
11078     EXPECT_HR(hr, S_OK);
11079
11080     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
11081     EXPECT_HR(hr, S_OK);
11082
11083     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("xmlns:dt"), &pAttribute);
11084     ok( hr == S_OK, "returns %08x\n", hr );
11085
11086     V_VT(&v) = VT_BSTR;
11087     V_BSTR(&v) = _bstr_("urn:schemas-microsoft-com:datatypes");
11088     hr = IXMLDOMAttribute_put_nodeValue(pAttribute, v);
11089
11090     hr = IXMLDOMElement_setAttributeNode(root, pAttribute, NULL);
11091     ok(hr == S_OK, "ret %08x\n", hr );
11092
11093     hr = IXMLDOMNode_put_dataType((IXMLDOMNode*)root, _bstr_("bin.base64"));
11094     ok(hr == S_OK, "ret %08x\n", hr );
11095
11096     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11097     EXPECT_HR(hr, S_OK);
11098
11099     str = NULL;
11100     hr = IXMLDOMElement_get_xml(elem, &str);
11101     ok( hr == S_OK, "got 0x%08x\n", hr);
11102     todo_wine ok( lstrcmpW(str, _bstr_("<Testing xmlns:dt=\"urn:schemas-microsoft-com:datatypes\" dt:dt=\"bin.base64\"/>")) == 0,
11103     "got %s\n", wine_dbgstr_w(str));
11104     SysFreeString(str);
11105
11106     IXMLDOMElement_Release(elem);
11107     IXMLDOMAttribute_Release( pAttribute);
11108
11109     IXMLDOMDocument_Release(doc);
11110
11111     free_bstrs();
11112 }
11113
11114 static const char namespacesA[] =
11115 "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
11116 "   <ns1:elem1 xmlns:ns1=\"http://blah.org\" b='1' >"
11117 "     <ns2:elem2 xmlns:ns2=\"http://blah.org\"/>"
11118 "     <ns1:elem3/>"
11119 "     <ns1:elem4/>"
11120 "     <elem5 xmlns=\"http://blahblah.org\"/>"
11121 "     <ns1:elem6>true</ns1:elem6>"
11122 "   </ns1:elem1>";
11123
11124 static const char xsd_schema1_uri[] = "x-schema:test1.xsd";
11125 static const char xsd_schema1_xml[] =
11126 "<?xml version='1.0'?>"
11127 "<schema xmlns='http://www.w3.org/2001/XMLSchema'"
11128 "            targetNamespace='x-schema:test1.xsd'>"
11129 "   <element name='root'>"
11130 "       <complexType>"
11131 "           <sequence maxOccurs='unbounded'>"
11132 "               <any/>"
11133 "           </sequence>"
11134 "       </complexType>"
11135 "   </element>"
11136 "</schema>";
11137
11138 static void test_get_namespaces(void)
11139 {
11140     IXMLDOMSchemaCollection *collection, *collection2;
11141     IXMLDOMDocument2 *doc, *doc2;
11142     IEnumVARIANT *enumv, *enum2;
11143     IUnknown *unk1, *unk2;
11144     IXMLDOMNode *node;
11145     VARIANT_BOOL b;
11146     HRESULT hr;
11147     VARIANT v;
11148     LONG len;
11149     BSTR s;
11150
11151     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
11152     doc = create_document(&IID_IXMLDOMDocument2);
11153
11154     /* null pointer */
11155     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
11156     EXPECT_HR(hr, E_POINTER);
11157
11158     /* no document loaded */
11159     collection = (void*)0xdeadbeef;
11160     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11161     EXPECT_HR(hr, S_OK);
11162     if (hr != S_OK)
11163     {
11164         IXMLDOMDocument2_Release(doc);
11165         return;
11166     }
11167     EXPECT_REF(collection, 2);
11168
11169     collection2 = (void*)0xdeadbeef;
11170     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
11171     EXPECT_HR(hr, S_OK);
11172     ok(collection == collection2, "got %p\n", collection2);
11173     EXPECT_REF(collection, 3);
11174     IXMLDOMSchemaCollection_Release(collection);
11175
11176     len = -1;
11177     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11178     EXPECT_HR(hr, S_OK);
11179     ok(len == 0, "got %d\n", len);
11180     IXMLDOMSchemaCollection_Release(collection);
11181
11182     /* now with document */
11183     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
11184     EXPECT_HR(hr, S_OK);
11185
11186     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11187     EXPECT_HR(hr, S_OK);
11188
11189     len = -1;
11190     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11191     EXPECT_HR(hr, S_OK);
11192     ok(len == 2, "got %d\n", len);
11193
11194     /* try to lookup some uris */
11195     node = (void*)0xdeadbeef;
11196     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
11197     EXPECT_HR(hr, S_OK);
11198     ok(node == NULL, "got %p\n", node);
11199
11200     node = (void*)0xdeadbeef;
11201     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah1.org"), &node);
11202     EXPECT_HR(hr, S_OK);
11203     ok(node == NULL, "got %p\n", node);
11204
11205     /* load schema and try to add it */
11206     doc2 = create_document(&IID_IXMLDOMDocument2);
11207     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
11208     EXPECT_HR(hr, S_OK);
11209
11210     V_VT(&v) = VT_DISPATCH;
11211     V_DISPATCH(&v) = (IDispatch*)doc2;
11212     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
11213     EXPECT_HR(hr, E_FAIL);
11214
11215     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
11216     EXPECT_HR(hr, S_OK);
11217     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
11218     SysFreeString(s);
11219
11220     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
11221     EXPECT_HR(hr, S_OK);
11222     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
11223     SysFreeString(s);
11224
11225     s = (void*)0xdeadbeef;
11226     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
11227     EXPECT_HR(hr, E_FAIL);
11228     ok(s == (void*)0xdeadbeef, "got %p\n", s);
11229
11230     /* enumerate */
11231     enumv = (void*)0xdeadbeef;
11232     EXPECT_REF(collection, 2);
11233     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
11234     EXPECT_HR(hr, S_OK);
11235     EXPECT_REF(collection, 3);
11236     ok(enumv != NULL, "got %p\n", enumv);
11237
11238     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IUnknown, (void**)&unk1);
11239     EXPECT_HR(hr, S_OK);
11240     hr = IEnumVARIANT_QueryInterface(enumv, &IID_IUnknown, (void**)&unk2);
11241     EXPECT_HR(hr, S_OK);
11242     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
11243     IUnknown_Release(unk1);
11244     IUnknown_Release(unk2);
11245
11246     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IEnumVARIANT, (void**)&enum2);
11247     EXPECT_HR(hr, E_NOINTERFACE);
11248
11249     V_VT(&v) = VT_EMPTY;
11250     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11251     EXPECT_HR(hr, S_OK);
11252     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11253     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11254     VariantClear(&v);
11255
11256     V_VT(&v) = VT_EMPTY;
11257     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11258     EXPECT_HR(hr, S_OK);
11259     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11260     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11261     VariantClear(&v);
11262
11263     V_VT(&v) = VT_NULL;
11264     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11265     EXPECT_HR(hr, S_FALSE);
11266     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
11267
11268     IEnumVARIANT_Release(enumv);
11269     IXMLDOMSchemaCollection_Release(collection);
11270
11271     IXMLDOMDocument2_Release(doc);
11272
11273     /* now with CLSID_DOMDocument60 */
11274     if (!is_clsid_supported(&CLSID_DOMDocument60, &IID_IXMLDOMDocument2)) return;
11275     doc = create_document_version(60, &IID_IXMLDOMDocument2);
11276
11277     /* null pointer */
11278     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
11279     EXPECT_HR(hr, E_POINTER);
11280
11281     /* no document loaded */
11282     collection = (void*)0xdeadbeef;
11283     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11284     EXPECT_HR(hr, S_OK);
11285     if (hr != S_OK)
11286     {
11287         IXMLDOMDocument2_Release(doc);
11288         return;
11289     }
11290     EXPECT_REF(collection, 2);
11291
11292     collection2 = (void*)0xdeadbeef;
11293     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
11294     EXPECT_HR(hr, S_OK);
11295     ok(collection == collection2, "got %p\n", collection2);
11296     EXPECT_REF(collection, 3);
11297     IXMLDOMSchemaCollection_Release(collection);
11298
11299     len = -1;
11300     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11301     EXPECT_HR(hr, S_OK);
11302     ok(len == 0, "got %d\n", len);
11303     IXMLDOMSchemaCollection_Release(collection);
11304
11305     /* now with document */
11306     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
11307     EXPECT_HR(hr, S_OK);
11308
11309     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11310     EXPECT_HR(hr, S_OK);
11311
11312     len = -1;
11313     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11314     EXPECT_HR(hr, S_OK);
11315     ok(len == 2, "got %d\n", len);
11316
11317     /* try to lookup some uris */
11318     node = (void*)0xdeadbeef;
11319     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
11320     EXPECT_HR(hr, E_NOTIMPL);
11321     ok(broken(node == (void*)0xdeadbeef) || (node == NULL), "got %p\n", node);
11322
11323     /* load schema and try to add it */
11324     doc2 = create_document(&IID_IXMLDOMDocument2);
11325     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
11326     EXPECT_HR(hr, S_OK);
11327
11328     V_VT(&v) = VT_DISPATCH;
11329     V_DISPATCH(&v) = (IDispatch*)doc2;
11330     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
11331     EXPECT_HR(hr, E_FAIL);
11332     IXMLDOMDocument2_Release(doc2);
11333
11334     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
11335     EXPECT_HR(hr, S_OK);
11336     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
11337     SysFreeString(s);
11338
11339     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
11340     EXPECT_HR(hr, S_OK);
11341     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
11342     SysFreeString(s);
11343
11344     s = (void*)0xdeadbeef;
11345     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
11346     EXPECT_HR(hr, E_FAIL);
11347     ok(broken(s == (void*)0xdeadbeef) || (s == NULL), "got %p\n", s);
11348
11349     /* enumerate */
11350     enumv = (void*)0xdeadbeef;
11351     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
11352     EXPECT_HR(hr, S_OK);
11353     ok(enumv != NULL, "got %p\n", enumv);
11354
11355     V_VT(&v) = VT_EMPTY;
11356     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11357     EXPECT_HR(hr, S_OK);
11358     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11359     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11360     VariantClear(&v);
11361
11362     V_VT(&v) = VT_EMPTY;
11363     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11364     EXPECT_HR(hr, S_OK);
11365     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
11366     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
11367     VariantClear(&v);
11368
11369     V_VT(&v) = VT_NULL;
11370     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
11371     EXPECT_HR(hr, S_FALSE);
11372     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
11373
11374     IEnumVARIANT_Release(enumv);
11375     IXMLDOMSchemaCollection_Release(collection);
11376     IXMLDOMDocument2_Release(doc);
11377     free_bstrs();
11378 }
11379
11380 static DOMNodeType put_data_types[] = {
11381     NODE_TEXT,
11382     NODE_CDATA_SECTION,
11383     NODE_PROCESSING_INSTRUCTION,
11384     NODE_COMMENT,
11385     NODE_INVALID
11386 };
11387
11388 static void test_put_data(void)
11389 {
11390     static const WCHAR test_data[] = {'t','e','s','t',' ','n','o','d','e',' ','d','a','t','a',0};
11391     WCHAR buff[100], *data;
11392     IXMLDOMDocument *doc;
11393     DOMNodeType *type;
11394     IXMLDOMText *text;
11395     IXMLDOMNode *node;
11396     VARIANT v;
11397     BSTR get_data;
11398     HRESULT hr;
11399
11400     doc = create_document(&IID_IXMLDOMDocument);
11401
11402     memcpy(&buff[2], test_data, sizeof(test_data));
11403     /* just a big length */
11404     *(DWORD*)buff = 0xf0f0;
11405     data = &buff[2];
11406
11407     type = put_data_types;
11408     while (*type != NODE_INVALID)
11409     {
11410        V_VT(&v) = VT_I2;
11411        V_I2(&v) = *type;
11412
11413        hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
11414        EXPECT_HR(hr, S_OK);
11415
11416        /* put_data() is interface-specific */
11417        switch (*type)
11418        {
11419            case NODE_TEXT:
11420            {
11421               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
11422               EXPECT_HR(hr, S_OK);
11423               hr = IXMLDOMText_put_data(text, data);
11424               EXPECT_HR(hr, S_OK);
11425
11426               hr = IXMLDOMText_get_data(text, &get_data);
11427               EXPECT_HR(hr, S_OK);
11428
11429               IXMLDOMText_Release(text);
11430               break;
11431            }
11432            case NODE_CDATA_SECTION:
11433            {
11434               IXMLDOMCDATASection *cdata;
11435
11436               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
11437               EXPECT_HR(hr, S_OK);
11438               hr = IXMLDOMCDATASection_put_data(cdata, data);
11439               EXPECT_HR(hr, S_OK);
11440
11441               hr = IXMLDOMCDATASection_get_data(cdata, &get_data);
11442               EXPECT_HR(hr, S_OK);
11443
11444               IXMLDOMCDATASection_Release(cdata);
11445               break;
11446            }
11447            case NODE_PROCESSING_INSTRUCTION:
11448            {
11449               IXMLDOMProcessingInstruction *pi;
11450
11451               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)&pi);
11452               EXPECT_HR(hr, S_OK);
11453               hr = IXMLDOMProcessingInstruction_put_data(pi, data);
11454               EXPECT_HR(hr, S_OK);
11455
11456               hr = IXMLDOMProcessingInstruction_get_data(pi, &get_data);
11457               EXPECT_HR(hr, S_OK);
11458
11459               IXMLDOMProcessingInstruction_Release(pi);
11460               break;
11461            }
11462            case NODE_COMMENT:
11463            {
11464               IXMLDOMComment *comment;
11465
11466               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
11467               EXPECT_HR(hr, S_OK);
11468               hr = IXMLDOMComment_put_data(comment, data);
11469               EXPECT_HR(hr, S_OK);
11470
11471               hr = IXMLDOMComment_get_data(comment, &get_data);
11472               EXPECT_HR(hr, S_OK);
11473
11474               IXMLDOMComment_Release(comment);
11475               break;
11476            }
11477            default:
11478               break;
11479        }
11480
11481        /* compare */
11482        ok(!lstrcmpW(data, get_data), "%d: got wrong data %s, expected %s\n", *type, wine_dbgstr_w(get_data),
11483            wine_dbgstr_w(data));
11484        SysFreeString(get_data);
11485
11486        IXMLDOMNode_Release(node);
11487        type++;
11488     }
11489
11490     /* \r\n sequence is never escaped */
11491     V_VT(&v) = VT_I2;
11492     V_I2(&v) = NODE_TEXT;
11493
11494     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
11495     ok(hr == S_OK, "got 0x%08x\n", hr);
11496
11497     IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
11498
11499     hr = IXMLDOMText_put_data(text, _bstr_("\r\n"));
11500     ok(hr == S_OK, "got 0x%08x\n", hr);
11501
11502     hr = IXMLDOMText_get_data(text, &get_data);
11503     ok(hr == S_OK, "got 0x%08x\n", hr);
11504 todo_wine
11505     ok(!lstrcmpW(get_data, _bstr_("\n")), "got %s\n", wine_dbgstr_w(get_data));
11506     SysFreeString(get_data);
11507
11508     hr = IXMLDOMText_get_xml(text, &get_data);
11509     ok(hr == S_OK, "got 0x%08x\n", hr);
11510     ok(!lstrcmpW(get_data, _bstr_("\r\n")), "got %s\n", wine_dbgstr_w(get_data));
11511     SysFreeString(get_data);
11512
11513     IXMLDOMText_Release(text);
11514     IXMLDOMNode_Release(node);
11515
11516     IXMLDOMDocument_Release(doc);
11517     free_bstrs();
11518 }
11519
11520 static void test_putref_schemas(void)
11521 {
11522     IXMLDOMSchemaCollection *cache;
11523     IXMLDOMDocument2 *doc;
11524     VARIANT schema;
11525     HRESULT hr;
11526
11527     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument2)) return;
11528     if (!is_clsid_supported(&CLSID_XMLSchemaCache, &IID_IXMLDOMSchemaCollection)) return;
11529
11530     doc = create_document(&IID_IXMLDOMDocument2);
11531     cache = create_cache(&IID_IXMLDOMSchemaCollection);
11532
11533     /* set to NULL iface when no schema is set */
11534     V_VT(&schema) = VT_DISPATCH;
11535     V_DISPATCH(&schema) = NULL;
11536     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11537     EXPECT_HR(hr, S_OK);
11538
11539     V_VT(&schema) = VT_UNKNOWN;
11540     V_UNKNOWN(&schema) = NULL;
11541     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11542     EXPECT_HR(hr, S_OK);
11543
11544     /* set as VT_DISPATCH, reset with it */
11545     V_VT(&schema) = VT_DISPATCH;
11546     V_DISPATCH(&schema) = (IDispatch*)cache;
11547     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11548     EXPECT_HR(hr, S_OK);
11549
11550     V_DISPATCH(&schema) = NULL;
11551     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
11552     EXPECT_HR(hr, S_OK);
11553     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
11554
11555     V_VT(&schema) = VT_DISPATCH;
11556     V_DISPATCH(&schema) = NULL;
11557     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11558     EXPECT_HR(hr, S_OK);
11559
11560     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
11561     V_VT(&schema) = VT_I2;
11562     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
11563     EXPECT_HR(hr, S_FALSE);
11564     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
11565     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
11566
11567     /* set as VT_UNKNOWN, reset with it */
11568     V_VT(&schema) = VT_UNKNOWN;
11569     V_UNKNOWN(&schema) = (IUnknown*)cache;
11570     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11571     EXPECT_HR(hr, S_OK);
11572
11573     V_DISPATCH(&schema) = NULL;
11574     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
11575     EXPECT_HR(hr, S_OK);
11576     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
11577
11578     V_VT(&schema) = VT_UNKNOWN;
11579     V_UNKNOWN(&schema) = NULL;
11580     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
11581     EXPECT_HR(hr, S_OK);
11582
11583     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
11584     V_VT(&schema) = VT_I2;
11585     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
11586     EXPECT_HR(hr, S_FALSE);
11587     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
11588     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
11589
11590     IXMLDOMSchemaCollection_Release(cache);
11591     IXMLDOMDocument2_Release(doc);
11592 }
11593
11594 static void test_namedmap_newenum(void)
11595 {
11596     IEnumVARIANT *enum1, *enum2, *enum3;
11597     IXMLDOMNamedNodeMap *map;
11598     IUnknown *unk1, *unk2;
11599     IXMLDOMDocument *doc;
11600     IXMLDOMElement *elem;
11601     IXMLDOMNode *node;
11602     VARIANT_BOOL b;
11603     HRESULT hr;
11604     VARIANT v;
11605     BSTR str;
11606
11607     doc = create_document(&IID_IXMLDOMDocument);
11608
11609     hr = IXMLDOMDocument_loadXML(doc, _bstr_(attributes_map), &b);
11610     EXPECT_HR(hr, S_OK);
11611
11612     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11613     EXPECT_HR(hr, S_OK);
11614
11615     hr = IXMLDOMElement_get_attributes(elem, &map);
11616     EXPECT_HR(hr, S_OK);
11617     IXMLDOMElement_Release(elem);
11618
11619     enum1 = NULL;
11620     EXPECT_REF(map, 1);
11621     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum1);
11622     EXPECT_HR(hr, S_OK);
11623     ok(enum1 != NULL, "got %p\n", enum1);
11624     EXPECT_REF(map, 1);
11625     EXPECT_REF(enum1, 2);
11626
11627     enum2 = NULL;
11628     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum2);
11629     EXPECT_HR(hr, S_OK);
11630     ok(enum2 == enum1, "got %p\n", enum2);
11631
11632     IEnumVARIANT_Release(enum2);
11633
11634     EXPECT_REF(map, 1);
11635     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum2);
11636     EXPECT_HR(hr, S_OK);
11637     EXPECT_REF(map, 2);
11638     EXPECT_REF(enum2, 1);
11639     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
11640
11641     IEnumVARIANT_Release(enum1);
11642
11643     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
11644     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk1);
11645     EXPECT_HR(hr, S_OK);
11646     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
11647     EXPECT_HR(hr, S_OK);
11648     EXPECT_REF(map, 3);
11649     EXPECT_REF(enum2, 2);
11650     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
11651     IUnknown_Release(unk1);
11652     IUnknown_Release(unk2);
11653
11654     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum3);
11655     EXPECT_HR(hr, S_OK);
11656     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
11657     IEnumVARIANT_Release(enum3);
11658
11659     /* iteration tests */
11660     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node);
11661     EXPECT_HR(hr, S_OK);
11662     hr = IXMLDOMNode_get_nodeName(node, &str);
11663     EXPECT_HR(hr, S_OK);
11664     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
11665     SysFreeString(str);
11666     IXMLDOMNode_Release(node);
11667
11668     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
11669     EXPECT_HR(hr, S_OK);
11670     hr = IXMLDOMNode_get_nodeName(node, &str);
11671     EXPECT_HR(hr, S_OK);
11672     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
11673     SysFreeString(str);
11674     IXMLDOMNode_Release(node);
11675
11676     V_VT(&v) = VT_EMPTY;
11677     hr = IEnumVARIANT_Next(enum2, 1, &v, NULL);
11678     EXPECT_HR(hr, S_OK);
11679     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
11680     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
11681     EXPECT_HR(hr, S_OK);
11682     hr = IXMLDOMNode_get_nodeName(node, &str);
11683     EXPECT_HR(hr, S_OK);
11684     ok(!lstrcmpW(str, _bstr_("attr1")), "got node name %s\n", wine_dbgstr_w(str));
11685     SysFreeString(str);
11686     IXMLDOMNode_Release(node);
11687     VariantClear(&v);
11688
11689     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
11690     EXPECT_HR(hr, S_OK);
11691     hr = IXMLDOMNode_get_nodeName(node, &str);
11692     EXPECT_HR(hr, S_OK);
11693     ok(!lstrcmpW(str, _bstr_("attr2")), "got %s\n", wine_dbgstr_w(str));
11694     SysFreeString(str);
11695     IXMLDOMNode_Release(node);
11696
11697     IEnumVARIANT_Release(enum2);
11698     IXMLDOMNamedNodeMap_Release(map);
11699     IXMLDOMDocument_Release(doc);
11700 }
11701
11702 static const char xsltext_xsl[] =
11703 "<?xml version=\"1.0\"?>"
11704 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
11705 "<xsl:output method=\"html\" encoding=\"us-ascii\"/>"
11706 "<xsl:template match=\"/\">"
11707 "    <xsl:choose>"
11708 "        <xsl:when test=\"testkey\">"
11709 "            <xsl:text>testdata</xsl:text>"
11710 "        </xsl:when>"
11711 "    </xsl:choose>"
11712 "</xsl:template>"
11713 "</xsl:stylesheet>";
11714
11715 static const char omitxmldecl_xsl[] =
11716 "<?xml version=\"1.0\"?>"
11717 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
11718 "<xsl:output method=\"xml\" omit-xml-declaration=\"yes\"/>"
11719 "<xsl:template match=\"/\">"
11720 "    <xsl:for-each select=\"/a/item\">"
11721 "        <xsl:element name=\"node\">"
11722 "            <xsl:value-of select=\"@name\"/>"
11723 "        </xsl:element>"
11724 "    </xsl:for-each>"
11725 "</xsl:template>"
11726 "</xsl:stylesheet>";
11727
11728 static const char omitxmldecl_doc[] =
11729 "<?xml version=\"1.0\"?>"
11730 "<a>"
11731 "    <item name=\"item1\"/>"
11732 "    <item name=\"item2\"/>"
11733 "</a>";
11734
11735 static void test_xsltext(void)
11736 {
11737     IXMLDOMDocument *doc, *doc2;
11738     VARIANT_BOOL b;
11739     HRESULT hr;
11740     BSTR ret;
11741
11742     doc = create_document(&IID_IXMLDOMDocument);
11743     doc2 = create_document(&IID_IXMLDOMDocument);
11744
11745     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xsltext_xsl), &b);
11746     EXPECT_HR(hr, S_OK);
11747
11748     hr = IXMLDOMDocument_loadXML(doc2, _bstr_("<testkey/>"), &b);
11749     EXPECT_HR(hr, S_OK);
11750
11751     hr = IXMLDOMDocument_transformNode(doc2, (IXMLDOMNode*)doc, &ret);
11752     EXPECT_HR(hr, S_OK);
11753     ok(!lstrcmpW(ret, _bstr_("testdata")), "transform result %s\n", wine_dbgstr_w(ret));
11754     SysFreeString(ret);
11755
11756     /* omit-xml-declaration */
11757     hr = IXMLDOMDocument_loadXML(doc, _bstr_(omitxmldecl_xsl), &b);
11758     ok(hr == S_OK, "got 0x%08x\n", hr);
11759     hr = IXMLDOMDocument_loadXML(doc2, _bstr_(omitxmldecl_doc), &b);
11760     ok(hr == S_OK, "got 0x%08x\n", hr);
11761
11762     hr = IXMLDOMDocument_transformNode(doc2, (IXMLDOMNode*)doc, &ret);
11763     ok(hr == S_OK, "got 0x%08x\n", hr);
11764     ok(!lstrcmpW(ret, _bstr_("<node>item1</node><node>item2</node>")), "transform result %s\n", wine_dbgstr_w(ret));
11765     SysFreeString(ret);
11766
11767     IXMLDOMDocument_Release(doc2);
11768     IXMLDOMDocument_Release(doc);
11769     free_bstrs();
11770 }
11771
11772 struct attrtest_t {
11773     const char *name;
11774     const char *uri;
11775     const char *prefix;
11776     const char *href;
11777 };
11778
11779 static struct attrtest_t attrtests[] = {
11780     { "xmlns", "http://www.w3.org/2000/xmlns/", "xmlns", "xmlns" },
11781     { "xmlns", "nondefaulturi", "xmlns", "xmlns" },
11782     { "c", "http://www.w3.org/2000/xmlns/", NULL, "http://www.w3.org/2000/xmlns/" },
11783     { "c", "nsref1", NULL, "nsref1" },
11784     { "ns:c", "nsref1", "ns", "nsref1" },
11785     { "xmlns:c", "http://www.w3.org/2000/xmlns/", "xmlns", "" },
11786     { "xmlns:c", "nondefaulturi", "xmlns", "" },
11787     { 0 }
11788 };
11789
11790 static void test_create_attribute(void)
11791 {
11792     struct attrtest_t *ptr = attrtests;
11793     IXMLDOMElement *el;
11794     IXMLDOMDocument *doc;
11795     IXMLDOMNode *node, *node2;
11796     VARIANT var;
11797     HRESULT hr;
11798     int i = 0;
11799     BSTR str;
11800
11801     doc = create_document(&IID_IXMLDOMDocument);
11802
11803     while (ptr->name)
11804     {
11805         V_VT(&var) = VT_I1;
11806         V_I1(&var) = NODE_ATTRIBUTE;
11807         hr = IXMLDOMDocument_createNode(doc, var, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
11808         ok(hr == S_OK, "got 0x%08x\n", hr);
11809
11810         str = NULL;
11811         hr = IXMLDOMNode_get_prefix(node, &str);
11812         if (ptr->prefix)
11813         {
11814             ok(hr == S_OK, "%d: got 0x%08x\n", i, hr);
11815             ok(!lstrcmpW(str, _bstr_(ptr->prefix)), "%d: got prefix %s, expected %s\n", i, wine_dbgstr_w(str), ptr->prefix);
11816         }
11817         else
11818         {
11819             ok(hr == S_FALSE, "%d: got 0x%08x\n", i, hr);
11820             ok(str == NULL, "%d: got prefix %s\n", i, wine_dbgstr_w(str));
11821         }
11822         SysFreeString(str);
11823
11824         str = NULL;
11825         hr = IXMLDOMNode_get_namespaceURI(node, &str);
11826         ok(hr == S_OK, "%d: got 0x%08x\n", i, hr);
11827         ok(!lstrcmpW(str, _bstr_(ptr->href)), "%d: got uri %s, expected %s\n", i, wine_dbgstr_w(str), ptr->href);
11828         SysFreeString(str);
11829
11830         IXMLDOMNode_Release(node);
11831         free_bstrs();
11832
11833         i++;
11834         ptr++;
11835     }
11836
11837     V_VT(&var) = VT_I1;
11838     V_I1(&var) = NODE_ELEMENT;
11839     hr = IXMLDOMDocument_createNode(doc, var, _bstr_("e"), NULL, &node2);
11840     ok(hr == S_OK, "got 0x%08x\n", hr);
11841
11842     hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&el);
11843     ok(hr == S_OK, "got 0x%08x\n", hr);
11844     IXMLDOMNode_Release(node2);
11845
11846     V_VT(&var) = VT_I1;
11847     V_I1(&var) = NODE_ATTRIBUTE;
11848     hr = IXMLDOMDocument_createNode(doc, var, _bstr_("xmlns:a"), _bstr_("http://www.w3.org/2000/xmlns/"), &node);
11849     ok(hr == S_OK, "got 0x%08x\n", hr);
11850
11851     hr = IXMLDOMElement_setAttributeNode(el, (IXMLDOMAttribute*)node, NULL);
11852     ok(hr == S_OK, "got 0x%08x\n", hr);
11853
11854     /* for some reason default namespace uri is not reported */
11855     hr = IXMLDOMNode_get_namespaceURI(node, &str);
11856     ok(hr == S_OK, "got 0x%08x\n", hr);
11857     ok(!lstrcmpW(str, _bstr_("")), "got uri %s\n", wine_dbgstr_w(str));
11858     SysFreeString(str);
11859
11860     IXMLDOMNode_Release(node);
11861     IXMLDOMElement_Release(el);
11862     IXMLDOMDocument_Release(doc);
11863     free_bstrs();
11864 }
11865
11866 static void test_url(void)
11867 {
11868     IXMLDOMDocument *doc;
11869     HRESULT hr;
11870     BSTR s;
11871
11872     doc = create_document(&IID_IXMLDOMDocument);
11873
11874     hr = IXMLDOMDocument_get_url(doc, NULL);
11875     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
11876
11877     s = (BSTR)0x1;
11878     hr = IXMLDOMDocument_get_url(doc, &s);
11879     ok(hr == S_FALSE, "got 0x%08x\n", hr);
11880     ok(s == NULL, "got %s\n", wine_dbgstr_w(s));
11881
11882     IXMLDOMDocument_Release(doc);
11883 }
11884
11885 START_TEST(domdoc)
11886 {
11887     HRESULT hr;
11888
11889     hr = CoInitialize( NULL );
11890     ok( hr == S_OK, "failed to init com\n");
11891     if (hr != S_OK) return;
11892
11893     get_class_support_data(domdoc_support_data);
11894     if (!is_clsid_supported(&CLSID_DOMDocument2, &IID_IXMLDOMDocument))
11895     {
11896         win_skip("DOMDocument2 is not supported. Skipping all tests.\n");
11897         CoUninitialize();
11898         return;
11899     }
11900
11901     test_domdoc();
11902     test_persiststreaminit();
11903     test_domnode();
11904     test_refs();
11905     test_create();
11906     test_getElementsByTagName();
11907     test_get_text();
11908     test_get_childNodes();
11909     test_get_firstChild();
11910     test_get_lastChild();
11911     test_removeChild();
11912     test_replaceChild();
11913     test_removeNamedItem();
11914     test_IXMLDOMDocument2();
11915     test_whitespace();
11916     test_XPath();
11917     test_XSLPattern();
11918     test_cloneNode();
11919     test_xmlTypes();
11920     test_save();
11921     test_testTransforms();
11922     test_namespaces_basic();
11923     test_namespaces_change();
11924     test_FormattingXML();
11925     test_nodeTypedValue();
11926     test_TransformWithLoadingLocalFile();
11927     test_put_nodeValue();
11928     test_IObjectSafety();
11929     test_splitText();
11930     test_getQualifiedItem();
11931     test_removeQualifiedItem();
11932     test_get_ownerDocument();
11933     test_setAttributeNode();
11934     test_put_dataType();
11935     test_createNode();
11936     test_create_attribute();
11937     test_get_prefix();
11938     test_default_properties();
11939     test_selectSingleNode();
11940     test_events();
11941     test_createProcessingInstruction();
11942     test_put_nodeTypedValue();
11943     test_get_xml();
11944     test_insertBefore();
11945     test_appendChild();
11946     test_get_doctype();
11947     test_get_tagName();
11948     test_get_dataType();
11949     test_get_nodeTypeString();
11950     test_get_attributes();
11951     test_selection();
11952     test_load();
11953     test_dispex();
11954     test_parseerror();
11955     test_getAttributeNode();
11956     test_supporterrorinfo();
11957     test_nodeValue();
11958     test_get_namespaces();
11959     test_put_data();
11960     test_putref_schemas();
11961     test_namedmap_newenum();
11962     test_xmlns_attribute();
11963     test_url();
11964
11965     test_xsltemplate();
11966     test_xsltext();
11967
11968     if (is_clsid_supported(&CLSID_MXNamespaceManager40, &IID_IMXNamespaceManager))
11969     {
11970         test_mxnamespacemanager();
11971         test_mxnamespacemanager_override();
11972     }
11973
11974     CoUninitialize();
11975 }