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-2012 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 "msxml2.h"
  34 #include "msxml2did.h"
  35 #include "ole2.h"
  36 #include "dispex.h"
  37
  38 #include "initguid.h"
  39 #include "objsafe.h"
  40 #include "mshtml.h"
  41
  42 #include "wine/test.h"
  43
  44 /* undef the #define in msxml2 so that we can access all versions */
  45 #undef CLSID_DOMDocument
  46
  47 DEFINE_GUID(SID_SContainerDispatch, 0xb722be00, 0x4e68, 0x101b, 0xa2, 0xbc, 0x00, 0xaa, 0x00, 0x40, 0x47, 0x70);
  48 DEFINE_GUID(SID_UnknownSID, 0x75dd09cb, 0x6c40, 0x11d5, 0x85, 0x43, 0x00, 0xc0, 0x4f, 0xa0, 0xfb, 0xa3);
  49 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  50
  51 #define DEFINE_EXPECT(func) \
  52     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  53
  54 #define SET_EXPECT(func) \
  55     expect_ ## func = TRUE
  56
  57 #define CHECK_EXPECT2(func) \
  58     do { \
  59         ok(expect_ ##func, "unexpected call " #func "\n"); \
  60         called_ ## func = TRUE; \
  61     }while(0)
  62
  63 #define CHECK_CALLED(func) \
  64     do { \
  65         ok(called_ ## func, "expected " #func "\n"); \
  66         expect_ ## func = called_ ## func = FALSE; \
  67     }while(0)
  68
  69 static const char *debugstr_guid(REFIID riid)
  70 {
  71     static char buf[50];
  72
  73     if(!riid)
  74         return "(null)";
  75
  76     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  77             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
  78             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
  79             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
  80
  81     return buf;
  82 }
  83
  84 static int g_unexpectedcall, g_expectedcall;
  85
  86 typedef struct
  87 {
  88     IDispatch IDispatch_iface;
  89     LONG ref;
  90 } dispevent;
  91
  92 static inline dispevent *impl_from_IDispatch( IDispatch *iface )
  93 {
  94     return CONTAINING_RECORD(iface, dispevent, IDispatch_iface);
  95 }
  96
  97 static HRESULT WINAPI dispevent_QueryInterface(IDispatch *iface, REFIID riid, void **ppvObject)
  98 {
  99     *ppvObject = NULL;
 100
 101     if ( IsEqualGUID( riid, &IID_IDispatch) ||
 102          IsEqualGUID( riid, &IID_IUnknown) )
 103     {
 104         *ppvObject = iface;
 105     }
 106     else
 107         return E_NOINTERFACE;
 108
 109     IDispatch_AddRef( iface );
 110
 111     return S_OK;
 112 }
 113
 114 static ULONG WINAPI dispevent_AddRef(IDispatch *iface)
 115 {
 116     dispevent *This = impl_from_IDispatch( iface );
 117     return InterlockedIncrement( &This->ref );
 118 }
 119
 120 static ULONG WINAPI dispevent_Release(IDispatch *iface)
 121 {
 122     dispevent *This = impl_from_IDispatch( iface );
 123     ULONG ref = InterlockedDecrement( &This->ref );
 124
 125     if (ref == 0)
 126         HeapFree(GetProcessHeap(), 0, This);
 127
 128     return ref;
 129 }
 130
 131 static HRESULT WINAPI dispevent_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 132 {
 133     g_unexpectedcall++;
 134     *pctinfo = 0;
 135     return S_OK;
 136 }
 137
 138 static HRESULT WINAPI dispevent_GetTypeInfo(IDispatch *iface, UINT iTInfo,
 139         LCID lcid, ITypeInfo **ppTInfo)
 140 {
 141     g_unexpectedcall++;
 142     return S_OK;
 143 }
 144
 145 static HRESULT WINAPI dispevent_GetIDsOfNames(IDispatch *iface, REFIID riid,
 146         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 147 {
 148     g_unexpectedcall++;
 149     return S_OK;
 150 }
 151
 152 static HRESULT WINAPI dispevent_Invoke(IDispatch *iface, DISPID member, REFIID riid,
 153         LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result,
 154         EXCEPINFO *excepInfo, UINT *argErr)
 155 {
 156     ok(member == 0, "expected 0 member, got %d\n", member);
 157     ok(lcid == LOCALE_SYSTEM_DEFAULT, "expected LOCALE_SYSTEM_DEFAULT, got lcid %x\n", lcid);
 158     ok(flags == DISPATCH_METHOD, "expected DISPATCH_METHOD, got %d\n", flags);
 159
 160     ok(params->cArgs == 0, "got %d\n", params->cArgs);
 161     ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
 162     ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
 163     ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
 164
 165     ok(result == NULL, "got %p\n", result);
 166     ok(excepInfo == NULL, "got %p\n", excepInfo);
 167     ok(argErr == NULL, "got %p\n", argErr);
 168
 169     g_expectedcall++;
 170     return E_FAIL;
 171 }
 172
 173 static const IDispatchVtbl dispeventVtbl =
 174 {
 175     dispevent_QueryInterface,
 176     dispevent_AddRef,
 177     dispevent_Release,
 178     dispevent_GetTypeInfoCount,
 179     dispevent_GetTypeInfo,
 180     dispevent_GetIDsOfNames,
 181     dispevent_Invoke
 182 };
 183
 184 static IDispatch* create_dispevent(void)
 185 {
 186     dispevent *event = HeapAlloc(GetProcessHeap(), 0, sizeof(*event));
 187
 188     event->IDispatch_iface.lpVtbl = &dispeventVtbl;
 189     event->ref = 1;
 190
 191     return (IDispatch*)&event->IDispatch_iface;
 192 }
 193
 194 /* object site */
 195 DEFINE_EXPECT(site_qi_IServiceProvider);
 196 DEFINE_EXPECT(site_qi_IXMLDOMDocument);
 197 DEFINE_EXPECT(site_qi_IOleClientSite);
 198
 199 DEFINE_EXPECT(sp_queryservice_SID_SBindHost);
 200 DEFINE_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
 201 DEFINE_EXPECT(sp_queryservice_SID_secmgr_htmldoc2);
 202 DEFINE_EXPECT(sp_queryservice_SID_secmgr_xmldomdoc);
 203 DEFINE_EXPECT(sp_queryservice_SID_secmgr_secmgr);
 204
 205 DEFINE_EXPECT(htmldoc2_get_all);
 206 DEFINE_EXPECT(htmldoc2_get_url);
 207 DEFINE_EXPECT(collection_get_length);
 208
 209 typedef struct
 210 {
 211     IServiceProvider IServiceProvider_iface;
 212 } testprov_t;
 213
 214 testprov_t testprov;
 215
 216 static HRESULT WINAPI site_QueryInterface(IUnknown *iface, REFIID riid, void **ppvObject)
 217 {
 218     *ppvObject = NULL;
 219
 220     if (IsEqualGUID(riid, &IID_IServiceProvider))
 221         CHECK_EXPECT2(site_qi_IServiceProvider);
 222
 223     if (IsEqualGUID(riid, &IID_IXMLDOMDocument))
 224         CHECK_EXPECT2(site_qi_IXMLDOMDocument);
 225
 226     if (IsEqualGUID(riid, &IID_IOleClientSite))
 227         CHECK_EXPECT2(site_qi_IOleClientSite);
 228
 229     if (IsEqualGUID(riid, &IID_IUnknown))
 230          *ppvObject = iface;
 231     else if (IsEqualGUID(riid, &IID_IServiceProvider))
 232          *ppvObject = &testprov.IServiceProvider_iface;
 233
 234     if (*ppvObject) IUnknown_AddRef(iface);
 235
 236     return *ppvObject ? S_OK : E_NOINTERFACE;
 237 }
 238
 239 static ULONG WINAPI site_AddRef(IUnknown *iface)
 240 {
 241     return 2;
 242 }
 243
 244 static ULONG WINAPI site_Release(IUnknown *iface)
 245 {
 246     return 1;
 247 }
 248
 249 static const IUnknownVtbl testsiteVtbl =
 250 {
 251     site_QueryInterface,
 252     site_AddRef,
 253     site_Release
 254 };
 255
 256 typedef struct
 257 {
 258     IUnknown IUnknown_iface;
 259 } testsite_t;
 260
 261 static testsite_t testsite = { { &testsiteVtbl } };
 262
 263 /* test IHTMLElementCollection */
 264 static HRESULT WINAPI htmlecoll_QueryInterface(IHTMLElementCollection *iface, REFIID riid, void **ppvObject)
 265 {
 266     ok(0, "unexpected call\n");
 267     *ppvObject = NULL;
 268     return E_NOINTERFACE;
 269 }
 270
 271 static ULONG WINAPI htmlecoll_AddRef(IHTMLElementCollection *iface)
 272 {
 273     return 2;
 274 }
 275
 276 static ULONG WINAPI htmlecoll_Release(IHTMLElementCollection *iface)
 277 {
 278     return 1;
 279 }
 280
 281 static HRESULT WINAPI htmlecoll_GetTypeInfoCount(IHTMLElementCollection *iface, UINT *pctinfo)
 282 {
 283     ok(0, "unexpected call\n");
 284     return E_NOTIMPL;
 285 }
 286
 287 static HRESULT WINAPI htmlecoll_GetTypeInfo(IHTMLElementCollection *iface, UINT iTInfo,
 288                                                 LCID lcid, ITypeInfo **ppTInfo)
 289 {
 290     ok(0, "unexpected call\n");
 291     return E_NOTIMPL;
 292 }
 293
 294 static HRESULT WINAPI htmlecoll_GetIDsOfNames(IHTMLElementCollection *iface, REFIID riid,
 295                                                 LPOLESTR *rgszNames, UINT cNames,
 296                                                 LCID lcid, DISPID *rgDispId)
 297 {
 298     ok(0, "unexpected call\n");
 299     return E_NOTIMPL;
 300 }
 301
 302 static HRESULT WINAPI htmlecoll_Invoke(IHTMLElementCollection *iface, DISPID dispIdMember,
 303                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 304                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 305 {
 306     ok(0, "unexpected call\n");
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI htmlecoll_toString(IHTMLElementCollection *iface, BSTR *String)
 311 {
 312     ok(0, "unexpected call\n");
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI htmlecoll_put_length(IHTMLElementCollection *iface, LONG v)
 317 {
 318     ok(0, "unexpected call\n");
 319     return E_NOTIMPL;
 320 }
 321
 322 static HRESULT WINAPI htmlecoll_get_length(IHTMLElementCollection *iface, LONG *v)
 323 {
 324     CHECK_EXPECT2(collection_get_length);
 325     return E_NOTIMPL;
 326 }
 327
 328 static HRESULT WINAPI htmlecoll_get__newEnum(IHTMLElementCollection *iface, IUnknown **p)
 329 {
 330     ok(0, "unexpected call\n");
 331     return E_NOTIMPL;
 332 }
 333
 334 static HRESULT WINAPI htmlecoll_item(IHTMLElementCollection *iface, VARIANT name, VARIANT index, IDispatch **pdisp)
 335 {
 336     ok(0, "unexpected call\n");
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI htmlecoll_tags(IHTMLElementCollection *iface, VARIANT tagName, IDispatch **pdisp)
 341 {
 342     ok(0, "unexpected call\n");
 343     return E_NOTIMPL;
 344 }
 345
 346 static const IHTMLElementCollectionVtbl TestHTMLECollectionVtbl = {
 347     htmlecoll_QueryInterface,
 348     htmlecoll_AddRef,
 349     htmlecoll_Release,
 350     htmlecoll_GetTypeInfoCount,
 351     htmlecoll_GetTypeInfo,
 352     htmlecoll_GetIDsOfNames,
 353     htmlecoll_Invoke,
 354
 355     htmlecoll_toString,
 356     htmlecoll_put_length,
 357     htmlecoll_get_length,
 358     htmlecoll_get__newEnum,
 359     htmlecoll_item,
 360     htmlecoll_tags
 361 };
 362
 363 typedef struct
 364 {
 365     IHTMLElementCollection IHTMLElementCollection_iface;
 366 } testhtmlecoll_t;
 367
 368 static testhtmlecoll_t htmlecoll = { { &TestHTMLECollectionVtbl } };
 369
 370 /* test IHTMLDocument2 */
 371 static HRESULT WINAPI htmldoc2_QueryInterface(IHTMLDocument2 *iface, REFIID riid, void **ppvObject)
 372 {
 373    trace("\n");
 374    *ppvObject = NULL;
 375    return E_NOINTERFACE;
 376 }
 377
 378 static ULONG WINAPI htmldoc2_AddRef(IHTMLDocument2 *iface)
 379 {
 380     return 2;
 381 }
 382
 383 static ULONG WINAPI htmldoc2_Release(IHTMLDocument2 *iface)
 384 {
 385     return 1;
 386 }
 387
 388 static HRESULT WINAPI htmldoc2_GetTypeInfoCount(IHTMLDocument2 *iface, UINT *pctinfo)
 389 {
 390     ok(0, "unexpected call\n");
 391     return E_NOTIMPL;
 392 }
 393
 394 static HRESULT WINAPI htmldoc2_GetTypeInfo(IHTMLDocument2 *iface, UINT iTInfo,
 395                                                 LCID lcid, ITypeInfo **ppTInfo)
 396 {
 397     ok(0, "unexpected call\n");
 398     return E_NOTIMPL;
 399 }
 400
 401 static HRESULT WINAPI htmldoc2_GetIDsOfNames(IHTMLDocument2 *iface, REFIID riid,
 402                                                 LPOLESTR *rgszNames, UINT cNames,
 403                                                 LCID lcid, DISPID *rgDispId)
 404 {
 405     ok(0, "unexpected call\n");
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI htmldoc2_Invoke(IHTMLDocument2 *iface, DISPID dispIdMember,
 410                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 411                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 412 {
 413     ok(0, "unexpected call\n");
 414     return E_NOTIMPL;
 415 }
 416
 417 static HRESULT WINAPI htmldoc2_get_Script(IHTMLDocument2 *iface, IDispatch **p)
 418 {
 419     ok(0, "unexpected call\n");
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI htmldoc2_get_all(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 424 {
 425     CHECK_EXPECT2(htmldoc2_get_all);
 426     *p = &htmlecoll.IHTMLElementCollection_iface;
 427     return S_OK;
 428 }
 429
 430 static HRESULT WINAPI htmldoc2_get_body(IHTMLDocument2 *iface, IHTMLElement **p)
 431 {
 432     ok(0, "unexpected call\n");
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT WINAPI htmldoc2_get_activeElement(IHTMLDocument2 *iface, IHTMLElement **p)
 437 {
 438     ok(0, "unexpected call\n");
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI htmldoc2_get_images(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 443 {
 444     ok(0, "unexpected call\n");
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI htmldoc2_get_applets(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 449 {
 450     ok(0, "unexpected call\n");
 451     return E_NOTIMPL;
 452 }
 453
 454 static HRESULT WINAPI htmldoc2_get_links(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 455 {
 456     ok(0, "unexpected call\n");
 457     return E_NOTIMPL;
 458 }
 459
 460 static HRESULT WINAPI htmldoc2_get_forms(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 461 {
 462     ok(0, "unexpected call\n");
 463     return E_NOTIMPL;
 464 }
 465
 466 static HRESULT WINAPI htmldoc2_get_anchors(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 467 {
 468     ok(0, "unexpected call\n");
 469     return E_NOTIMPL;
 470 }
 471
 472 static HRESULT WINAPI htmldoc2_put_title(IHTMLDocument2 *iface, BSTR v)
 473 {
 474     ok(0, "unexpected call\n");
 475     return E_NOTIMPL;
 476 }
 477
 478 static HRESULT WINAPI htmldoc2_get_title(IHTMLDocument2 *iface, BSTR *p)
 479 {
 480     ok(0, "unexpected call\n");
 481     return E_NOTIMPL;
 482 }
 483
 484 static HRESULT WINAPI htmldoc2_get_scripts(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 485 {
 486     ok(0, "unexpected call\n");
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI htmldoc2_put_designMode(IHTMLDocument2 *iface, BSTR v)
 491 {
 492     ok(0, "unexpected call\n");
 493     return E_NOTIMPL;
 494 }
 495
 496 static HRESULT WINAPI htmldoc2_get_designMode(IHTMLDocument2 *iface, BSTR *p)
 497 {
 498     ok(0, "unexpected call\n");
 499     return E_NOTIMPL;
 500 }
 501
 502 static HRESULT WINAPI htmldoc2_get_selection(IHTMLDocument2 *iface, IHTMLSelectionObject **p)
 503 {
 504     ok(0, "unexpected call\n");
 505     return E_NOTIMPL;
 506 }
 507
 508 static HRESULT WINAPI htmldoc2_get_readyState(IHTMLDocument2 *iface, BSTR *p)
 509 {
 510     ok(0, "unexpected call\n");
 511     return E_NOTIMPL;
 512 }
 513
 514 static HRESULT WINAPI htmldoc2_get_frames(IHTMLDocument2 *iface, IHTMLFramesCollection2 **p)
 515 {
 516     ok(0, "unexpected call\n");
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI htmldoc2_get_embeds(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 521 {
 522     ok(0, "unexpected call\n");
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI htmldoc2_get_plugins(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 527 {
 528     ok(0, "unexpected call\n");
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI htmldoc2_put_alinkColor(IHTMLDocument2 *iface, VARIANT v)
 533 {
 534     ok(0, "unexpected call\n");
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI htmldoc2_get_alinkColor(IHTMLDocument2 *iface, VARIANT *p)
 539 {
 540     ok(0, "unexpected call\n");
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI htmldoc2_put_bgColor(IHTMLDocument2 *iface, VARIANT v)
 545 {
 546     ok(0, "unexpected call\n");
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI htmldoc2_get_bgColor(IHTMLDocument2 *iface, VARIANT *p)
 551 {
 552     ok(0, "unexpected call\n");
 553     return E_NOTIMPL;
 554 }
 555
 556 static HRESULT WINAPI htmldoc2_put_fgColor(IHTMLDocument2 *iface, VARIANT v)
 557 {
 558     ok(0, "unexpected call\n");
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI htmldoc2_get_fgColor(IHTMLDocument2 *iface, VARIANT *p)
 563 {
 564     ok(0, "unexpected call\n");
 565     return E_NOTIMPL;
 566 }
 567
 568 static HRESULT WINAPI htmldoc2_put_linkColor(IHTMLDocument2 *iface, VARIANT v)
 569 {
 570     ok(0, "unexpected call\n");
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI htmldoc2_get_linkColor(IHTMLDocument2 *iface, VARIANT *p)
 575 {
 576     ok(0, "unexpected call\n");
 577     return E_NOTIMPL;
 578 }
 579
 580 static HRESULT WINAPI htmldoc2_put_vlinkColor(IHTMLDocument2 *iface, VARIANT v)
 581 {
 582     ok(0, "unexpected call\n");
 583     return E_NOTIMPL;
 584 }
 585
 586 static HRESULT WINAPI htmldoc2_get_vlinkColor(IHTMLDocument2 *iface, VARIANT *p)
 587 {
 588     ok(0, "unexpected call\n");
 589     return E_NOTIMPL;
 590 }
 591
 592 static HRESULT WINAPI htmldoc2_get_referrer(IHTMLDocument2 *iface, BSTR *p)
 593 {
 594     ok(0, "unexpected call\n");
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI htmldoc2_get_location(IHTMLDocument2 *iface, IHTMLLocation **p)
 599 {
 600     ok(0, "unexpected call\n");
 601     return E_NOTIMPL;
 602 }
 603
 604 static HRESULT WINAPI htmldoc2_get_lastModified(IHTMLDocument2 *iface, BSTR *p)
 605 {
 606     ok(0, "unexpected call\n");
 607     return E_NOTIMPL;
 608 }
 609
 610 static HRESULT WINAPI htmldoc2_put_URL(IHTMLDocument2 *iface, BSTR v)
 611 {
 612     ok(0, "unexpected call\n");
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI htmldoc2_get_URL(IHTMLDocument2 *iface, BSTR *p)
 617 {
 618     CHECK_EXPECT2(htmldoc2_get_url);
 619     *p = SysAllocString(NULL);
 620     return S_OK;
 621 }
 622
 623 static HRESULT WINAPI htmldoc2_put_domain(IHTMLDocument2 *iface, BSTR v)
 624 {
 625     ok(0, "unexpected call\n");
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT WINAPI htmldoc2_get_domain(IHTMLDocument2 *iface, BSTR *p)
 630 {
 631     ok(0, "unexpected call\n");
 632     return E_NOTIMPL;
 633 }
 634
 635 static HRESULT WINAPI htmldoc2_put_cookie(IHTMLDocument2 *iface, BSTR v)
 636 {
 637     ok(0, "unexpected call\n");
 638     return E_NOTIMPL;
 639 }
 640
 641 static HRESULT WINAPI htmldoc2_get_cookie(IHTMLDocument2 *iface, BSTR *p)
 642 {
 643     ok(0, "unexpected call\n");
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI htmldoc2_put_expando(IHTMLDocument2 *iface, VARIANT_BOOL v)
 648 {
 649     ok(0, "unexpected call\n");
 650     return E_NOTIMPL;
 651 }
 652
 653 static HRESULT WINAPI htmldoc2_get_expando(IHTMLDocument2 *iface, VARIANT_BOOL *p)
 654 {
 655     ok(0, "unexpected call\n");
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT WINAPI htmldoc2_put_charset(IHTMLDocument2 *iface, BSTR v)
 660 {
 661     ok(0, "unexpected call\n");
 662     return E_NOTIMPL;
 663 }
 664
 665 static HRESULT WINAPI htmldoc2_get_charset(IHTMLDocument2 *iface, BSTR *p)
 666 {
 667     ok(0, "unexpected call\n");
 668     return E_NOTIMPL;
 669 }
 670
 671 static HRESULT WINAPI htmldoc2_put_defaultCharset(IHTMLDocument2 *iface, BSTR v)
 672 {
 673     ok(0, "unexpected call\n");
 674     return E_NOTIMPL;
 675 }
 676
 677 static HRESULT WINAPI htmldoc2_get_defaultCharset(IHTMLDocument2 *iface, BSTR *p)
 678 {
 679     ok(0, "unexpected call\n");
 680     return E_NOTIMPL;
 681 }
 682
 683 static HRESULT WINAPI htmldoc2_get_mimeType(IHTMLDocument2 *iface, BSTR *p)
 684 {
 685     ok(0, "unexpected call\n");
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI htmldoc2_get_fileSize(IHTMLDocument2 *iface, BSTR *p)
 690 {
 691     ok(0, "unexpected call\n");
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI htmldoc2_get_fileCreatedDate(IHTMLDocument2 *iface, BSTR *p)
 696 {
 697     ok(0, "unexpected call\n");
 698     return E_NOTIMPL;
 699 }
 700
 701 static HRESULT WINAPI htmldoc2_get_fileModifiedDate(IHTMLDocument2 *iface, BSTR *p)
 702 {
 703     ok(0, "unexpected call\n");
 704     return E_NOTIMPL;
 705 }
 706
 707 static HRESULT WINAPI htmldoc2_get_fileUpdatedDate(IHTMLDocument2 *iface, BSTR *p)
 708 {
 709     ok(0, "unexpected call\n");
 710     return E_NOTIMPL;
 711 }
 712
 713 static HRESULT WINAPI htmldoc2_get_security(IHTMLDocument2 *iface, BSTR *p)
 714 {
 715     ok(0, "unexpected call\n");
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI htmldoc2_get_protocol(IHTMLDocument2 *iface, BSTR *p)
 720 {
 721     ok(0, "unexpected call\n");
 722     return E_NOTIMPL;
 723 }
 724
 725 static HRESULT WINAPI htmldoc2_get_nameProp(IHTMLDocument2 *iface, BSTR *p)
 726 {
 727     ok(0, "unexpected call\n");
 728     return E_NOTIMPL;
 729 }
 730
 731 static HRESULT WINAPI htmldoc2_write(IHTMLDocument2 *iface, SAFEARRAY *psarray)
 732 {
 733     ok(0, "unexpected call\n");
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI htmldoc2_writeln(IHTMLDocument2 *iface, SAFEARRAY *psarray)
 738 {
 739     ok(0, "unexpected call\n");
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI htmldoc2_open(IHTMLDocument2 *iface, BSTR url, VARIANT name,
 744                         VARIANT features, VARIANT replace, IDispatch **pomWindowResult)
 745 {
 746     ok(0, "unexpected call\n");
 747     return E_NOTIMPL;
 748 }
 749
 750 static HRESULT WINAPI htmldoc2_close(IHTMLDocument2 *iface)
 751 {
 752     ok(0, "unexpected call\n");
 753     return E_NOTIMPL;
 754 }
 755
 756 static HRESULT WINAPI htmldoc2_clear(IHTMLDocument2 *iface)
 757 {
 758     ok(0, "unexpected call\n");
 759     return E_NOTIMPL;
 760 }
 761
 762 static HRESULT WINAPI htmldoc2_queryCommandSupported(IHTMLDocument2 *iface, BSTR cmdID,
 763                                                         VARIANT_BOOL *pfRet)
 764 {
 765     ok(0, "unexpected call\n");
 766     return E_NOTIMPL;
 767 }
 768
 769 static HRESULT WINAPI htmldoc2_queryCommandEnabled(IHTMLDocument2 *iface, BSTR cmdID,
 770                                                         VARIANT_BOOL *pfRet)
 771 {
 772     ok(0, "unexpected call\n");
 773     return E_NOTIMPL;
 774 }
 775
 776 static HRESULT WINAPI htmldoc2_queryCommandState(IHTMLDocument2 *iface, BSTR cmdID,
 777                                                         VARIANT_BOOL *pfRet)
 778 {
 779     ok(0, "unexpected call\n");
 780     return E_NOTIMPL;
 781 }
 782
 783 static HRESULT WINAPI htmldoc2_queryCommandIndeterm(IHTMLDocument2 *iface, BSTR cmdID,
 784                                                         VARIANT_BOOL *pfRet)
 785 {
 786     ok(0, "unexpected call\n");
 787     return E_NOTIMPL;
 788 }
 789
 790 static HRESULT WINAPI htmldoc2_queryCommandText(IHTMLDocument2 *iface, BSTR cmdID,
 791                                                         BSTR *pfRet)
 792 {
 793     ok(0, "unexpected call\n");
 794     return E_NOTIMPL;
 795 }
 796
 797 static HRESULT WINAPI htmldoc2_queryCommandValue(IHTMLDocument2 *iface, BSTR cmdID,
 798                                                         VARIANT *pfRet)
 799 {
 800     ok(0, "unexpected call\n");
 801     return E_NOTIMPL;
 802 }
 803
 804 static HRESULT WINAPI htmldoc2_execCommand(IHTMLDocument2 *iface, BSTR cmdID,
 805                                 VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
 806 {
 807     ok(0, "unexpected call\n");
 808     return E_NOTIMPL;
 809 }
 810
 811 static HRESULT WINAPI htmldoc2_execCommandShowHelp(IHTMLDocument2 *iface, BSTR cmdID,
 812                                                         VARIANT_BOOL *pfRet)
 813 {
 814     ok(0, "unexpected call\n");
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT WINAPI htmldoc2_createElement(IHTMLDocument2 *iface, BSTR eTag,
 819                                                  IHTMLElement **newElem)
 820 {
 821     ok(0, "unexpected call\n");
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI htmldoc2_put_onhelp(IHTMLDocument2 *iface, VARIANT v)
 826 {
 827     ok(0, "unexpected call\n");
 828     return E_NOTIMPL;
 829 }
 830
 831 static HRESULT WINAPI htmldoc2_get_onhelp(IHTMLDocument2 *iface, VARIANT *p)
 832 {
 833     ok(0, "unexpected call\n");
 834     return E_NOTIMPL;
 835 }
 836
 837 static HRESULT WINAPI htmldoc2_put_onclick(IHTMLDocument2 *iface, VARIANT v)
 838 {
 839     ok(0, "unexpected call\n");
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI htmldoc2_get_onclick(IHTMLDocument2 *iface, VARIANT *p)
 844 {
 845     ok(0, "unexpected call\n");
 846     return E_NOTIMPL;
 847 }
 848
 849 static HRESULT WINAPI htmldoc2_put_ondblclick(IHTMLDocument2 *iface, VARIANT v)
 850 {
 851     ok(0, "unexpected call\n");
 852     return E_NOTIMPL;
 853 }
 854
 855 static HRESULT WINAPI htmldoc2_get_ondblclick(IHTMLDocument2 *iface, VARIANT *p)
 856 {
 857     ok(0, "unexpected call\n");
 858     return E_NOTIMPL;
 859 }
 860
 861 static HRESULT WINAPI htmldoc2_put_onkeyup(IHTMLDocument2 *iface, VARIANT v)
 862 {
 863     ok(0, "unexpected call\n");
 864     return E_NOTIMPL;
 865 }
 866
 867 static HRESULT WINAPI htmldoc2_get_onkeyup(IHTMLDocument2 *iface, VARIANT *p)
 868 {
 869     ok(0, "unexpected call\n");
 870     return E_NOTIMPL;
 871 }
 872
 873 static HRESULT WINAPI htmldoc2_put_onkeydown(IHTMLDocument2 *iface, VARIANT v)
 874 {
 875     ok(0, "unexpected call\n");
 876     return E_NOTIMPL;
 877 }
 878
 879 static HRESULT WINAPI htmldoc2_get_onkeydown(IHTMLDocument2 *iface, VARIANT *p)
 880 {
 881     ok(0, "unexpected call\n");
 882     return E_NOTIMPL;
 883 }
 884
 885 static HRESULT WINAPI htmldoc2_put_onkeypress(IHTMLDocument2 *iface, VARIANT v)
 886 {
 887     ok(0, "unexpected call\n");
 888     return E_NOTIMPL;
 889 }
 890
 891 static HRESULT WINAPI htmldoc2_get_onkeypress(IHTMLDocument2 *iface, VARIANT *p)
 892 {
 893     ok(0, "unexpected call\n");
 894     return E_NOTIMPL;
 895 }
 896
 897 static HRESULT WINAPI htmldoc2_put_onmouseup(IHTMLDocument2 *iface, VARIANT v)
 898 {
 899     ok(0, "unexpected call\n");
 900     return E_NOTIMPL;
 901 }
 902
 903 static HRESULT WINAPI htmldoc2_get_onmouseup(IHTMLDocument2 *iface, VARIANT *p)
 904 {
 905     ok(0, "unexpected call\n");
 906     return E_NOTIMPL;
 907 }
 908
 909 static HRESULT WINAPI htmldoc2_put_onmousedown(IHTMLDocument2 *iface, VARIANT v)
 910 {
 911     ok(0, "unexpected call\n");
 912     return E_NOTIMPL;
 913 }
 914
 915 static HRESULT WINAPI htmldoc2_get_onmousedown(IHTMLDocument2 *iface, VARIANT *p)
 916 {
 917     ok(0, "unexpected call\n");
 918     return E_NOTIMPL;
 919 }
 920
 921 static HRESULT WINAPI htmldoc2_put_onmousemove(IHTMLDocument2 *iface, VARIANT v)
 922 {
 923     ok(0, "unexpected call\n");
 924     return E_NOTIMPL;
 925 }
 926
 927 static HRESULT WINAPI htmldoc2_get_onmousemove(IHTMLDocument2 *iface, VARIANT *p)
 928 {
 929     ok(0, "unexpected call\n");
 930     return E_NOTIMPL;
 931 }
 932
 933 static HRESULT WINAPI htmldoc2_put_onmouseout(IHTMLDocument2 *iface, VARIANT v)
 934 {
 935     ok(0, "unexpected call\n");
 936     return E_NOTIMPL;
 937 }
 938
 939 static HRESULT WINAPI htmldoc2_get_onmouseout(IHTMLDocument2 *iface, VARIANT *p)
 940 {
 941     ok(0, "unexpected call\n");
 942     return E_NOTIMPL;
 943 }
 944
 945 static HRESULT WINAPI htmldoc2_put_onmouseover(IHTMLDocument2 *iface, VARIANT v)
 946 {
 947     ok(0, "unexpected call\n");
 948     return E_NOTIMPL;
 949 }
 950
 951 static HRESULT WINAPI htmldoc2_get_onmouseover(IHTMLDocument2 *iface, VARIANT *p)
 952 {
 953     ok(0, "unexpected call\n");
 954     return E_NOTIMPL;
 955 }
 956
 957 static HRESULT WINAPI htmldoc2_put_onreadystatechange(IHTMLDocument2 *iface, VARIANT v)
 958 {
 959     ok(0, "unexpected call\n");
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI htmldoc2_get_onreadystatechange(IHTMLDocument2 *iface, VARIANT *p)
 964 {
 965     ok(0, "unexpected call\n");
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI htmldoc2_put_onafterupdate(IHTMLDocument2 *iface, VARIANT v)
 970 {
 971     ok(0, "unexpected call\n");
 972     return E_NOTIMPL;
 973 }
 974
 975 static HRESULT WINAPI htmldoc2_get_onafterupdate(IHTMLDocument2 *iface, VARIANT *p)
 976 {
 977     ok(0, "unexpected call\n");
 978     return E_NOTIMPL;
 979 }
 980
 981 static HRESULT WINAPI htmldoc2_put_onrowexit(IHTMLDocument2 *iface, VARIANT v)
 982 {
 983     ok(0, "unexpected call\n");
 984     return E_NOTIMPL;
 985 }
 986
 987 static HRESULT WINAPI htmldoc2_get_onrowexit(IHTMLDocument2 *iface, VARIANT *p)
 988 {
 989     ok(0, "unexpected call\n");
 990     return E_NOTIMPL;
 991 }
 992
 993 static HRESULT WINAPI htmldoc2_put_onrowenter(IHTMLDocument2 *iface, VARIANT v)
 994 {
 995     ok(0, "unexpected call\n");
 996     return E_NOTIMPL;
 997 }
 998
 999 static HRESULT WINAPI htmldoc2_get_onrowenter(IHTMLDocument2 *iface, VARIANT *p)
1000 {
1001     ok(0, "unexpected call\n");
1002     return E_NOTIMPL;
1003 }
1004
1005 static HRESULT WINAPI htmldoc2_put_ondragstart(IHTMLDocument2 *iface, VARIANT v)
1006 {
1007     ok(0, "unexpected call\n");
1008     return E_NOTIMPL;
1009 }
1010
1011 static HRESULT WINAPI htmldoc2_get_ondragstart(IHTMLDocument2 *iface, VARIANT *p)
1012 {
1013     ok(0, "unexpected call\n");
1014     return E_NOTIMPL;
1015 }
1016
1017 static HRESULT WINAPI htmldoc2_put_onselectstart(IHTMLDocument2 *iface, VARIANT v)
1018 {
1019     ok(0, "unexpected call\n");
1020     return E_NOTIMPL;
1021 }
1022
1023 static HRESULT WINAPI htmldoc2_get_onselectstart(IHTMLDocument2 *iface, VARIANT *p)
1024 {
1025     ok(0, "unexpected call\n");
1026     return E_NOTIMPL;
1027 }
1028
1029 static HRESULT WINAPI htmldoc2_elementFromPoint(IHTMLDocument2 *iface, LONG x, LONG y,
1030                                                         IHTMLElement **elementHit)
1031 {
1032     ok(0, "unexpected call\n");
1033     return E_NOTIMPL;
1034 }
1035
1036 static HRESULT WINAPI htmldoc2_get_parentWindow(IHTMLDocument2 *iface, IHTMLWindow2 **p)
1037 {
1038     ok(0, "unexpected call\n");
1039     return E_NOTIMPL;
1040 }
1041
1042 static HRESULT WINAPI htmldoc2_get_styleSheets(IHTMLDocument2 *iface,
1043                                                    IHTMLStyleSheetsCollection **p)
1044 {
1045     ok(0, "unexpected call\n");
1046     return E_NOTIMPL;
1047 }
1048
1049 static HRESULT WINAPI htmldoc2_put_onbeforeupdate(IHTMLDocument2 *iface, VARIANT v)
1050 {
1051     ok(0, "unexpected call\n");
1052     return E_NOTIMPL;
1053 }
1054
1055 static HRESULT WINAPI htmldoc2_get_onbeforeupdate(IHTMLDocument2 *iface, VARIANT *p)
1056 {
1057     ok(0, "unexpected call\n");
1058     return E_NOTIMPL;
1059 }
1060
1061 static HRESULT WINAPI htmldoc2_put_onerrorupdate(IHTMLDocument2 *iface, VARIANT v)
1062 {
1063     ok(0, "unexpected call\n");
1064     return E_NOTIMPL;
1065 }
1066
1067 static HRESULT WINAPI htmldoc2_get_onerrorupdate(IHTMLDocument2 *iface, VARIANT *p)
1068 {
1069     ok(0, "unexpected call\n");
1070     return E_NOTIMPL;
1071 }
1072
1073 static HRESULT WINAPI htmldoc2_toString(IHTMLDocument2 *iface, BSTR *String)
1074 {
1075     ok(0, "unexpected call\n");
1076     return E_NOTIMPL;
1077 }
1078
1079 static HRESULT WINAPI htmldoc2_createStyleSheet(IHTMLDocument2 *iface, BSTR bstrHref,
1080                                             LONG lIndex, IHTMLStyleSheet **ppnewStyleSheet)
1081 {
1082     ok(0, "unexpected call\n");
1083     return E_NOTIMPL;
1084 }
1085
1086 static const IHTMLDocument2Vtbl TestHTMLDocumentVtbl = {
1087     htmldoc2_QueryInterface,
1088     htmldoc2_AddRef,
1089     htmldoc2_Release,
1090     htmldoc2_GetTypeInfoCount,
1091     htmldoc2_GetTypeInfo,
1092     htmldoc2_GetIDsOfNames,
1093     htmldoc2_Invoke,
1094     htmldoc2_get_Script,
1095     htmldoc2_get_all,
1096     htmldoc2_get_body,
1097     htmldoc2_get_activeElement,
1098     htmldoc2_get_images,
1099     htmldoc2_get_applets,
1100     htmldoc2_get_links,
1101     htmldoc2_get_forms,
1102     htmldoc2_get_anchors,
1103     htmldoc2_put_title,
1104     htmldoc2_get_title,
1105     htmldoc2_get_scripts,
1106     htmldoc2_put_designMode,
1107     htmldoc2_get_designMode,
1108     htmldoc2_get_selection,
1109     htmldoc2_get_readyState,
1110     htmldoc2_get_frames,
1111     htmldoc2_get_embeds,
1112     htmldoc2_get_plugins,
1113     htmldoc2_put_alinkColor,
1114     htmldoc2_get_alinkColor,
1115     htmldoc2_put_bgColor,
1116     htmldoc2_get_bgColor,
1117     htmldoc2_put_fgColor,
1118     htmldoc2_get_fgColor,
1119     htmldoc2_put_linkColor,
1120     htmldoc2_get_linkColor,
1121     htmldoc2_put_vlinkColor,
1122     htmldoc2_get_vlinkColor,
1123     htmldoc2_get_referrer,
1124     htmldoc2_get_location,
1125     htmldoc2_get_lastModified,
1126     htmldoc2_put_URL,
1127     htmldoc2_get_URL,
1128     htmldoc2_put_domain,
1129     htmldoc2_get_domain,
1130     htmldoc2_put_cookie,
1131     htmldoc2_get_cookie,
1132     htmldoc2_put_expando,
1133     htmldoc2_get_expando,
1134     htmldoc2_put_charset,
1135     htmldoc2_get_charset,
1136     htmldoc2_put_defaultCharset,
1137     htmldoc2_get_defaultCharset,
1138     htmldoc2_get_mimeType,
1139     htmldoc2_get_fileSize,
1140     htmldoc2_get_fileCreatedDate,
1141     htmldoc2_get_fileModifiedDate,
1142     htmldoc2_get_fileUpdatedDate,
1143     htmldoc2_get_security,
1144     htmldoc2_get_protocol,
1145     htmldoc2_get_nameProp,
1146     htmldoc2_write,
1147     htmldoc2_writeln,
1148     htmldoc2_open,
1149     htmldoc2_close,
1150     htmldoc2_clear,
1151     htmldoc2_queryCommandSupported,
1152     htmldoc2_queryCommandEnabled,
1153     htmldoc2_queryCommandState,
1154     htmldoc2_queryCommandIndeterm,
1155     htmldoc2_queryCommandText,
1156     htmldoc2_queryCommandValue,
1157     htmldoc2_execCommand,
1158     htmldoc2_execCommandShowHelp,
1159     htmldoc2_createElement,
1160     htmldoc2_put_onhelp,
1161     htmldoc2_get_onhelp,
1162     htmldoc2_put_onclick,
1163     htmldoc2_get_onclick,
1164     htmldoc2_put_ondblclick,
1165     htmldoc2_get_ondblclick,
1166     htmldoc2_put_onkeyup,
1167     htmldoc2_get_onkeyup,
1168     htmldoc2_put_onkeydown,
1169     htmldoc2_get_onkeydown,
1170     htmldoc2_put_onkeypress,
1171     htmldoc2_get_onkeypress,
1172     htmldoc2_put_onmouseup,
1173     htmldoc2_get_onmouseup,
1174     htmldoc2_put_onmousedown,
1175     htmldoc2_get_onmousedown,
1176     htmldoc2_put_onmousemove,
1177     htmldoc2_get_onmousemove,
1178     htmldoc2_put_onmouseout,
1179     htmldoc2_get_onmouseout,
1180     htmldoc2_put_onmouseover,
1181     htmldoc2_get_onmouseover,
1182     htmldoc2_put_onreadystatechange,
1183     htmldoc2_get_onreadystatechange,
1184     htmldoc2_put_onafterupdate,
1185     htmldoc2_get_onafterupdate,
1186     htmldoc2_put_onrowexit,
1187     htmldoc2_get_onrowexit,
1188     htmldoc2_put_onrowenter,
1189     htmldoc2_get_onrowenter,
1190     htmldoc2_put_ondragstart,
1191     htmldoc2_get_ondragstart,
1192     htmldoc2_put_onselectstart,
1193     htmldoc2_get_onselectstart,
1194     htmldoc2_elementFromPoint,
1195     htmldoc2_get_parentWindow,
1196     htmldoc2_get_styleSheets,
1197     htmldoc2_put_onbeforeupdate,
1198     htmldoc2_get_onbeforeupdate,
1199     htmldoc2_put_onerrorupdate,
1200     htmldoc2_get_onerrorupdate,
1201     htmldoc2_toString,
1202     htmldoc2_createStyleSheet
1203 };
1204
1205 typedef struct
1206 {
1207     IHTMLDocument2 IHTMLDocument2_iface;
1208 } testhtmldoc2_t;
1209
1210 static testhtmldoc2_t htmldoc2 = { { &TestHTMLDocumentVtbl } };
1211
1212 static HRESULT WINAPI sp_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppvObject)
1213 {
1214     *ppvObject = NULL;
1215
1216     if (IsEqualGUID(riid, &IID_IUnknown) ||
1217         IsEqualGUID(riid, &IID_IServiceProvider))
1218     {
1219         *ppvObject = iface;
1220         IServiceProvider_AddRef(iface);
1221         return S_OK;
1222     }
1223
1224     ok(0, "unexpected query interface: %s\n", debugstr_guid(riid));
1225
1226     return E_NOINTERFACE;
1227 }
1228
1229 static ULONG WINAPI sp_AddRef(IServiceProvider *iface)
1230 {
1231     return 2;
1232 }
1233
1234 static ULONG WINAPI sp_Release(IServiceProvider *iface)
1235 {
1236     return 1;
1237 }
1238
1239 static HRESULT WINAPI sp_QueryService(IServiceProvider *iface, REFGUID service, REFIID riid, void **obj)
1240 {
1241     *obj = NULL;
1242
1243     if (IsEqualGUID(service, &SID_SBindHost) &&
1244         IsEqualGUID(riid, &IID_IBindHost))
1245     {
1246         CHECK_EXPECT2(sp_queryservice_SID_SBindHost);
1247     }
1248     else if (IsEqualGUID(service, &SID_SContainerDispatch) &&
1249              IsEqualGUID(riid, &IID_IHTMLDocument2))
1250     {
1251         CHECK_EXPECT2(sp_queryservice_SID_SContainerDispatch_htmldoc2);
1252     }
1253     else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&
1254              IsEqualGUID(riid, &IID_IHTMLDocument2))
1255     {
1256         CHECK_EXPECT2(sp_queryservice_SID_secmgr_htmldoc2);
1257         *obj = &htmldoc2.IHTMLDocument2_iface;
1258         return S_OK;
1259     }
1260     else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&
1261              IsEqualGUID(riid, &IID_IXMLDOMDocument))
1262     {
1263         CHECK_EXPECT2(sp_queryservice_SID_secmgr_xmldomdoc);
1264     }
1265     else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&
1266              IsEqualGUID(riid, &IID_IInternetHostSecurityManager))
1267     {
1268         CHECK_EXPECT2(sp_queryservice_SID_secmgr_secmgr);
1269     }
1270     else if (IsEqualGUID(service, &SID_UnknownSID) &&
1271              IsEqualGUID(riid, &IID_IStream))
1272     {
1273         /* FIXME: unidentified service id */
1274     }
1275     else
1276         ok(0, "unexpected request: sid %s, riid %s\n", debugstr_guid(service), debugstr_guid(riid));
1277
1278     return E_NOTIMPL;
1279 }
1280
1281 static const IServiceProviderVtbl testprovVtbl =
1282 {
1283     sp_QueryInterface,
1284     sp_AddRef,
1285     sp_Release,
1286     sp_QueryService
1287 };
1288
1289 testprov_t testprov = { { &testprovVtbl } };
1290
1291 /* IStream */
1292 static HRESULT WINAPI istream_QueryInterface(IStream *iface, REFIID riid, void **ppvObject)
1293 {
1294     *ppvObject = NULL;
1295
1296     if (IsEqualGUID(riid, &IID_IStream) ||
1297         IsEqualGUID(riid, &IID_IUnknown))
1298         *ppvObject = iface;
1299     else
1300         return E_NOINTERFACE;
1301
1302     return S_OK;
1303 }
1304
1305 static ULONG WINAPI istream_AddRef(IStream *iface)
1306 {
1307     return 2;
1308 }
1309
1310 static ULONG WINAPI istream_Release(IStream *iface)
1311 {
1312     return 1;
1313 }
1314
1315 static HRESULT WINAPI istream_Read(IStream *iface, void *ptr, ULONG len, ULONG *pread)
1316 {
1317     ok(0, "unexpected call\n");
1318     return E_NOTIMPL;
1319 }
1320
1321 static HRESULT WINAPI istream_Write(IStream *iface, const void *ptr, ULONG len, ULONG *written)
1322 {
1323     *written = len/2;
1324     return S_OK;
1325 }
1326
1327 static HRESULT WINAPI istream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
1328 {
1329     ok(0, "unexpected call\n");
1330     return E_NOTIMPL;
1331 }
1332
1333 static HRESULT WINAPI istream_SetSize(IStream *iface, ULARGE_INTEGER size)
1334 {
1335     ok(0, "unexpected call\n");
1336     return E_NOTIMPL;
1337 }
1338
1339 static HRESULT WINAPI istream_CopyTo(IStream *iface, IStream *stream, ULARGE_INTEGER len,
1340         ULARGE_INTEGER *pread, ULARGE_INTEGER *written)
1341 {
1342     ok(0, "unexpected call\n");
1343     return E_NOTIMPL;
1344 }
1345
1346 static HRESULT WINAPI istream_Commit(IStream *iface, DWORD flags)
1347 {
1348     ok(0, "unexpected call\n");
1349     return E_NOTIMPL;
1350 }
1351
1352 static HRESULT WINAPI istream_Revert(IStream *iface)
1353 {
1354     ok(0, "unexpected call\n");
1355     return E_NOTIMPL;
1356 }
1357
1358 static HRESULT WINAPI istream_LockRegion(IStream *iface, ULARGE_INTEGER offset,
1359         ULARGE_INTEGER len, DWORD locktype)
1360 {
1361     ok(0, "unexpected call\n");
1362     return E_NOTIMPL;
1363 }
1364
1365 static HRESULT WINAPI istream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset,
1366         ULARGE_INTEGER len, DWORD locktype)
1367 {
1368     ok(0, "unexpected call\n");
1369     return E_NOTIMPL;
1370 }
1371
1372 static HRESULT WINAPI istream_Stat(IStream *iface, STATSTG *pstatstg, DWORD flag)
1373 {
1374     ok(0, "unexpected call\n");
1375     return E_NOTIMPL;
1376 }
1377
1378 static HRESULT WINAPI istream_Clone(IStream *iface, IStream **stream)
1379 {
1380     ok(0, "unexpected call\n");
1381     return E_NOTIMPL;
1382 }
1383
1384 static const IStreamVtbl StreamVtbl = {
1385     istream_QueryInterface,
1386     istream_AddRef,
1387     istream_Release,
1388     istream_Read,
1389     istream_Write,
1390     istream_Seek,
1391     istream_SetSize,
1392     istream_CopyTo,
1393     istream_Commit,
1394     istream_Revert,
1395     istream_LockRegion,
1396     istream_UnlockRegion,
1397     istream_Stat,
1398     istream_Clone
1399 };
1400
1401 static IStream savestream = { &StreamVtbl };
1402
1403 #define EXPECT_CHILDREN(node) _expect_children((IXMLDOMNode*)node, __LINE__)
1404 static void _expect_children(IXMLDOMNode *node, int line)
1405 {
1406     VARIANT_BOOL b;
1407     HRESULT hr;
1408
1409     b = VARIANT_FALSE;
1410     hr = IXMLDOMNode_hasChildNodes(node, &b);
1411     ok_(__FILE__,line)(hr == S_OK, "hasChildNodes() failed, 0x%08x\n", hr);
1412     ok_(__FILE__,line)(b == VARIANT_TRUE, "no children, %d\n", b);
1413 }
1414
1415 #define EXPECT_NO_CHILDREN(node) _expect_no_children((IXMLDOMNode*)node, __LINE__)
1416 static void _expect_no_children(IXMLDOMNode *node, int line)
1417 {
1418     VARIANT_BOOL b;
1419     HRESULT hr;
1420
1421     b = VARIANT_TRUE;
1422     hr = IXMLDOMNode_hasChildNodes(node, &b);
1423     ok_(__FILE__,line)(hr == S_FALSE, "hasChildNodes() failed, 0x%08x\n", hr);
1424     ok_(__FILE__,line)(b == VARIANT_FALSE, "no children, %d\n", b);
1425 }
1426
1427 #define EXPECT_REF(node,ref) _expect_ref((IUnknown*)node, ref, __LINE__)
1428 static void _expect_ref(IUnknown* obj, ULONG ref, int line)
1429 {
1430     ULONG rc = IUnknown_AddRef(obj);
1431     IUnknown_Release(obj);
1432     ok_(__FILE__,line)(rc-1 == ref, "expected refcount %d, got %d\n", ref, rc-1);
1433 }
1434
1435 #define EXPECT_LIST_LEN(list,len) _expect_list_len(list, len, __LINE__)
1436 static void _expect_list_len(IXMLDOMNodeList *list, LONG len, int line)
1437 {
1438     LONG length;
1439     HRESULT hr;
1440
1441     length = 0;
1442     hr = IXMLDOMNodeList_get_length(list, &length);
1443     ok_(__FILE__,line)(hr == S_OK, "got 0x%08x\n", hr);
1444     ok_(__FILE__,line)(length == len, "got %d, expected %d\n", length, len);
1445 }
1446
1447 #define EXPECT_HR(hr,hr_exp) \
1448     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
1449
1450 static const WCHAR szEmpty[] = { 0 };
1451 static const WCHAR szIncomplete[] = {
1452     '<','?','x','m','l',' ',
1453     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
1454 };
1455 static const WCHAR szComplete1[] = {
1456     '<','?','x','m','l',' ',
1457     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
1458     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
1459 };
1460 static const WCHAR szComplete2[] = {
1461     '<','?','x','m','l',' ',
1462     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
1463     '<','o','>','<','/','o','>','\n',0
1464 };
1465 static const WCHAR szComplete3[] = {
1466     '<','?','x','m','l',' ',
1467     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
1468     '<','a','>','<','/','a','>','\n',0
1469 };
1470 static const char complete4A[] =
1471     "<?xml version=\'1.0\'?>\n"
1472     "<lc dl=\'str1\'>\n"
1473         "<bs vr=\'str2\' sz=\'1234\'>"
1474             "fn1.txt\n"
1475         "</bs>\n"
1476         "<pr id=\'str3\' vr=\'1.2.3\' pn=\'wine 20050804\'>\n"
1477             "fn2.txt\n"
1478         "</pr>\n"
1479         "<empty></empty>\n"
1480         "<fo>\n"
1481             "<ba>\n"
1482                 "f1\n"
1483             "</ba>\n"
1484         "</fo>\n"
1485     "</lc>\n";
1486
1487 static const WCHAR szComplete5[] = {
1488     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
1489     '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','"',
1490     ' ','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','"','>',
1491         '<','S',':','s','c','o','p','e','>',
1492             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
1493         '<','/','S',':','s','c','o','p','e','>',
1494         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
1495             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
1496             'c','o','m','p','u','t','e','r',
1497         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
1498     '<','/','S',':','s','e','a','r','c','h','>',0
1499 };
1500
1501 static const WCHAR szComplete6[] = {
1502     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'',' ',
1503     'e','n','c','o','d','i','n','g','=','\'','W','i','n','d','o','w','s','-','1','2','5','2','\'','?','>','\n',
1504     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
1505 };
1506
1507 #define DECL_WIN_1252 \
1508 "<?xml version=\"1.0\" encoding=\"Windows-1252\"?>"
1509
1510 static const char win1252xml[] =
1511 DECL_WIN_1252
1512 "<open></open>";
1513
1514 static const char win1252decl[] =
1515 DECL_WIN_1252
1516 ;
1517
1518 static const char szExampleXML[] =
1519 "<?xml version='1.0' encoding='utf-8'?>\n"
1520 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' a=\"attr a\" foo:b=\"attr b\" >\n"
1521 "    <elem>\n"
1522 "        <a>A1 field</a>\n"
1523 "        <b>B1 field</b>\n"
1524 "        <c>C1 field</c>\n"
1525 "        <d>D1 field</d>\n"
1526 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
1527 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
1528 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
1529 "            </html>\n"
1530 "            <html xml:space='preserve' xmlns='http://www.w3.org/1999/xhtml'>\n"
1531 "                This is <strong>a</strong> <i>description</i> with preserved whitespace. <bar:x/>\n"
1532 "            </html>\n"
1533 "        </description>\n"
1534 "    </elem>\n"
1535 "\n"
1536 "    <elem>\n"
1537 "        <a>A2 field</a>\n"
1538 "        <b>B2 field</b>\n"
1539 "        <c type=\"old\">C2 field</c>\n"
1540 "        <d>D2 field</d>\n"
1541 "    </elem>\n"
1542 "\n"
1543 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
1544 "        <a>A3 field</a>\n"
1545 "        <b>B3 field</b>\n"
1546 "        <c>C3 field</c>\n"
1547 "    </elem>\n"
1548 "\n"
1549 "    <elem>\n"
1550 "        <a>A4 field</a>\n"
1551 "        <b>B4 field</b>\n"
1552 "        <foo:c>C4 field</foo:c>\n"
1553 "        <d>D4 field</d>\n"
1554 "    </elem>\n"
1555 "</root>\n";
1556
1557 static const CHAR szNodeTypesXML[] =
1558 "<?xml version='1.0'?>"
1559 "<!-- comment node 0 -->"
1560 "<root id='0' depth='0'>"
1561 "   <!-- comment node 1 -->"
1562 "   text node 0"
1563 "   <x id='1' depth='1'>"
1564 "       <?foo value='PI for x'?>"
1565 "       <!-- comment node 2 -->"
1566 "       text node 1"
1567 "       <a id='3' depth='2'/>"
1568 "       <b id='4' depth='2'/>"
1569 "       <c id='5' depth='2'/>"
1570 "   </x>"
1571 "   <y id='2' depth='1'>"
1572 "       <?bar value='PI for y'?>"
1573 "       <!-- comment node 3 -->"
1574 "       text node 2"
1575 "       <a id='6' depth='2'/>"
1576 "       <b id='7' depth='2'/>"
1577 "       <c id='8' depth='2'/>"
1578 "   </y>"
1579 "</root>";
1580
1581 static const CHAR szTransformXML[] =
1582 "<?xml version=\"1.0\"?>\n"
1583 "<greeting>\n"
1584 "Hello World\n"
1585 "</greeting>";
1586
1587 static  const CHAR szTransformSSXML[] =
1588 "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
1589 "   <xsl:output method=\"html\"/>\n"
1590 "   <xsl:template match=\"/\">\n"
1591 "       <xsl:apply-templates select=\"greeting\"/>\n"
1592 "   </xsl:template>\n"
1593 "   <xsl:template match=\"greeting\">\n"
1594 "       <html>\n"
1595 "           <body>\n"
1596 "               <h1>\n"
1597 "                   <xsl:value-of select=\".\"/>\n"
1598 "               </h1>\n"
1599 "           </body>\n"
1600 "       </html>\n"
1601 "   </xsl:template>\n"
1602 "</xsl:stylesheet>";
1603
1604 static  const CHAR szTransformOutput[] =
1605 "<html><body><h1>"
1606 "Hello World"
1607 "</h1></body></html>";
1608
1609 static const CHAR szTypeValueXML[] =
1610 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
1611 "<root xmlns:dt=\"urn:schemas-microsoft-com:datatypes\">\n"
1612 "   <string>Wine</string>\n"
1613 "   <string2 dt:dt=\"string\">String</string2>\n"
1614 "   <number dt:dt=\"number\">12.44</number>\n"
1615 "   <number2 dt:dt=\"NUMbEr\">-3.71e3</number2>\n"
1616 "   <int dt:dt=\"int\">-13</int>\n"
1617 "   <fixed dt:dt=\"fixed.14.4\">7322.9371</fixed>\n"
1618 "   <bool dt:dt=\"boolean\">1</bool>\n"
1619 "   <datetime dt:dt=\"datetime\">2009-11-18T03:21:33.12</datetime>\n"
1620 "   <datetimetz dt:dt=\"datetime.tz\">2003-07-11T11:13:57+03:00</datetimetz>\n"
1621 "   <date dt:dt=\"date\">3721-11-01</date>\n"
1622 "   <time dt:dt=\"time\">13:57:12.31321</time>\n"
1623 "   <timetz dt:dt=\"time.tz\">23:21:01.13+03:21</timetz>\n"
1624 "   <i1 dt:dt=\"i1\">-13</i1>\n"
1625 "   <i2 dt:dt=\"i2\">31915</i2>\n"
1626 "   <i4 dt:dt=\"i4\">-312232</i4>\n"
1627 "   <ui1 dt:dt=\"ui1\">123</ui1>\n"
1628 "   <ui2 dt:dt=\"ui2\">48282</ui2>\n"
1629 "   <ui4 dt:dt=\"ui4\">949281</ui4>\n"
1630 "   <r4 dt:dt=\"r4\">213124.0</r4>\n"
1631 "   <r8 dt:dt=\"r8\">0.412</r8>\n"
1632 "   <float dt:dt=\"float\">41221.421</float>\n"
1633 "   <uuid dt:dt=\"uuid\">333C7BC4-460F-11D0-BC04-0080C7055a83</uuid>\n"
1634 "   <binhex dt:dt=\"bin.hex\">fffca012003c</binhex>\n"
1635 "   <binbase64 dt:dt=\"bin.base64\">YmFzZTY0IHRlc3Q=</binbase64>\n"
1636 "   <binbase64_1 dt:dt=\"bin.base64\">\nYmFzZTY0\nIHRlc3Q=\n</binbase64_1>\n"
1637 "   <binbase64_2 dt:dt=\"bin.base64\">\nYmF\r\t z  ZTY0\nIHRlc3Q=\n</binbase64_2>\n"
1638 "</root>";
1639
1640 static const CHAR szBasicTransformSSXMLPart1[] =
1641 "<?xml version=\"1.0\"?>"
1642 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
1643 "<xsl:output method=\"html\"/>\n"
1644 "<xsl:template match=\"/\">"
1645 "<HTML><BODY><TABLE>"
1646 "        <xsl:apply-templates select='document(\"";
1647
1648 static const CHAR szBasicTransformSSXMLPart2[] =
1649 "\")/bottle/wine'>"
1650 "           <xsl:sort select=\"cost\"/><xsl:sort select=\"name\"/>"
1651 "        </xsl:apply-templates>"
1652 "</TABLE></BODY></HTML>"
1653 "</xsl:template>"
1654 "<xsl:template match=\"bottle\">"
1655 "   <TR><xsl:apply-templates select=\"name\" /><xsl:apply-templates select=\"cost\" /></TR>"
1656 "</xsl:template>"
1657 "<xsl:template match=\"name\">"
1658 "   <TD><xsl:apply-templates /></TD>"
1659 "</xsl:template>"
1660 "<xsl:template match=\"cost\">"
1661 "   <TD><xsl:apply-templates /></TD>"
1662 "</xsl:template>"
1663 "</xsl:stylesheet>";
1664
1665 static const CHAR szBasicTransformXML[] =
1666 "<?xml version=\"1.0\"?><bottle><wine><name>Wine</name><cost>$25.00</cost></wine></bottle>";
1667
1668 static const CHAR szBasicTransformOutput[] =
1669 "<HTML><BODY><TABLE><TD>Wine</TD><TD>$25.00</TD></TABLE></BODY></HTML>";
1670
1671 #define SZ_EMAIL_DTD \
1672 "<!DOCTYPE email ["\
1673 "   <!ELEMENT email         (recipients,from,reply-to?,subject,body,attachment*)>"\
1674 "       <!ATTLIST email attachments IDREFS #REQUIRED>"\
1675 "       <!ATTLIST email sent (yes|no) \"no\">"\
1676 "   <!ELEMENT recipients    (to+,cc*)>"\
1677 "   <!ELEMENT to            (#PCDATA)>"\
1678 "       <!ATTLIST to name CDATA #IMPLIED>"\
1679 "   <!ELEMENT cc            (#PCDATA)>"\
1680 "       <!ATTLIST cc name CDATA #IMPLIED>"\
1681 "   <!ELEMENT from          (#PCDATA)>"\
1682 "       <!ATTLIST from name CDATA #IMPLIED>"\
1683 "   <!ELEMENT reply-to      (#PCDATA)>"\
1684 "       <!ATTLIST reply-to name CDATA #IMPLIED>"\
1685 "   <!ELEMENT subject       ANY>"\
1686 "   <!ELEMENT body          ANY>"\
1687 "       <!ATTLIST body enc CDATA #FIXED \"UTF-8\">"\
1688 "   <!ELEMENT attachment    (#PCDATA)>"\
1689 "       <!ATTLIST attachment id ID #REQUIRED>"\
1690 "]>"
1691
1692 static const CHAR szEmailXML[] =
1693 "<?xml version=\"1.0\"?>"
1694 SZ_EMAIL_DTD
1695 "<email attachments=\"patch1\">"
1696 "   <recipients>"
1697 "       <to>wine-patches@winehq.org</to>"
1698 "   </recipients>"
1699 "   <from name=\"Anonymous\">user@localhost</from>"
1700 "   <subject>msxml3/tests: DTD validation (try 87)</subject>"
1701 "   <body>"
1702 "       It no longer causes spontaneous combustion..."
1703 "   </body>"
1704 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1705 "</email>";
1706
1707 static const CHAR szEmailXML_0D[] =
1708 "<?xml version=\"1.0\"?>"
1709 SZ_EMAIL_DTD
1710 "<email attachments=\"patch1\">"
1711 "   <recipients>"
1712 "       <to>wine-patches@winehq.org</to>"
1713 "   </recipients>"
1714 "   <from name=\"Anonymous\">user@localhost</from>"
1715 "   <subject>msxml3/tests: DTD validation (try 88)</subject>"
1716 "   <body>"
1717 "       <undecl />"
1718 "       XML_ELEMENT_UNDECLARED 0xC00CE00D"
1719 "   </body>"
1720 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1721 "</email>";
1722
1723 static const CHAR szEmailXML_0E[] =
1724 "<?xml version=\"1.0\"?>"
1725 SZ_EMAIL_DTD
1726 "<email attachments=\"patch1\">"
1727 "   <recipients>"
1728 "       <to>wine-patches@winehq.org</to>"
1729 "   </recipients>"
1730 "   <from name=\"Anonymous\">user@localhost</from>"
1731 "   <subject>msxml3/tests: DTD validation (try 89)</subject>"
1732 "   <body>"
1733 "       XML_ELEMENT_ID_NOT_FOUND 0xC00CE00E"
1734 "   </body>"
1735 "   <attachment id=\"patch\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1736 "</email>";
1737
1738 static const CHAR szEmailXML_11[] =
1739 "<?xml version=\"1.0\"?>"
1740 SZ_EMAIL_DTD
1741 "<email attachments=\"patch1\">"
1742 "   <recipients>"
1743 "   </recipients>"
1744 "   <from name=\"Anonymous\">user@localhost</from>"
1745 "   <subject>msxml3/tests: DTD validation (try 90)</subject>"
1746 "   <body>"
1747 "       XML_EMPTY_NOT_ALLOWED 0xC00CE011"
1748 "   </body>"
1749 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1750 "</email>";
1751
1752 static const CHAR szEmailXML_13[] =
1753 "<?xml version=\"1.0\"?>"
1754 SZ_EMAIL_DTD
1755 "<msg attachments=\"patch1\">"
1756 "   <recipients>"
1757 "       <to>wine-patches@winehq.org</to>"
1758 "   </recipients>"
1759 "   <from name=\"Anonymous\">user@localhost</from>"
1760 "   <subject>msxml3/tests: DTD validation (try 91)</subject>"
1761 "   <body>"
1762 "       XML_ROOT_NAME_MISMATCH 0xC00CE013"
1763 "   </body>"
1764 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1765 "</msg>";
1766
1767 static const CHAR szEmailXML_14[] =
1768 "<?xml version=\"1.0\"?>"
1769 SZ_EMAIL_DTD
1770 "<email attachments=\"patch1\">"
1771 "   <to>wine-patches@winehq.org</to>"
1772 "   <from name=\"Anonymous\">user@localhost</from>"
1773 "   <subject>msxml3/tests: DTD validation (try 92)</subject>"
1774 "   <body>"
1775 "       XML_INVALID_CONTENT 0xC00CE014"
1776 "   </body>"
1777 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1778 "</email>";
1779
1780 static const CHAR szEmailXML_15[] =
1781 "<?xml version=\"1.0\"?>"
1782 SZ_EMAIL_DTD
1783 "<email attachments=\"patch1\" ip=\"127.0.0.1\">"
1784 "   <recipients>"
1785 "       <to>wine-patches@winehq.org</to>"
1786 "   </recipients>"
1787 "   <from name=\"Anonymous\">user@localhost</from>"
1788 "   <subject>msxml3/tests: DTD validation (try 93)</subject>"
1789 "   <body>"
1790 "       XML_ATTRIBUTE_NOT_DEFINED 0xC00CE015"
1791 "   </body>"
1792 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1793 "</email>";
1794
1795 static const CHAR szEmailXML_16[] =
1796 "<?xml version=\"1.0\"?>"
1797 SZ_EMAIL_DTD
1798 "<email attachments=\"patch1\">"
1799 "   <recipients>"
1800 "       <to>wine-patches@winehq.org</to>"
1801 "   </recipients>"
1802 "   <from name=\"Anonymous\">user@localhost</from>"
1803 "   <subject>msxml3/tests: DTD validation (try 94)</subject>"
1804 "   <body enc=\"ASCII\">"
1805 "       XML_ATTRIBUTE_FIXED 0xC00CE016"
1806 "   </body>"
1807 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1808 "</email>";
1809
1810 static const CHAR szEmailXML_17[] =
1811 "<?xml version=\"1.0\"?>"
1812 SZ_EMAIL_DTD
1813 "<email attachments=\"patch1\" sent=\"true\">"
1814 "   <recipients>"
1815 "       <to>wine-patches@winehq.org</to>"
1816 "   </recipients>"
1817 "   <from name=\"Anonymous\">user@localhost</from>"
1818 "   <subject>msxml3/tests: DTD validation (try 95)</subject>"
1819 "   <body>"
1820 "       XML_ATTRIBUTE_VALUE 0xC00CE017"
1821 "   </body>"
1822 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1823 "</email>";
1824
1825 static const CHAR szEmailXML_18[] =
1826 "<?xml version=\"1.0\"?>"
1827 SZ_EMAIL_DTD
1828 "<email attachments=\"patch1\">"
1829 "   oops"
1830 "   <recipients>"
1831 "       <to>wine-patches@winehq.org</to>"
1832 "   </recipients>"
1833 "   <from name=\"Anonymous\">user@localhost</from>"
1834 "   <subject>msxml3/tests: DTD validation (try 96)</subject>"
1835 "   <body>"
1836 "       XML_ILLEGAL_TEXT 0xC00CE018"
1837 "   </body>"
1838 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1839 "</email>";
1840
1841 static const CHAR szEmailXML_20[] =
1842 "<?xml version=\"1.0\"?>"
1843 SZ_EMAIL_DTD
1844 "<email>"
1845 "   <recipients>"
1846 "       <to>wine-patches@winehq.org</to>"
1847 "   </recipients>"
1848 "   <from name=\"Anonymous\">user@localhost</from>"
1849 "   <subject>msxml3/tests: DTD validation (try 97)</subject>"
1850 "   <body>"
1851 "       XML_REQUIRED_ATTRIBUTE_MISSING 0xC00CE020"
1852 "   </body>"
1853 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1854 "</email>";
1855
1856 static const char xpath_simple_list[] =
1857 "<?xml version=\"1.0\"?>"
1858 "<root>"
1859 "   <a attr1=\"1\" attr2=\"2\" />"
1860 "   <b/>"
1861 "   <c/>"
1862 "   <d/>"
1863 "</root>";
1864
1865 static const char default_ns_doc[] = {
1866     "<?xml version=\"1.0\"?>"
1867     "<a xmlns:ns=\"nshref\" xml:lang=\"ru\" ns:b=\"b attr\" xml:c=\"c attr\" "
1868     "    d=\"d attr\" />"
1869 };
1870
1871 static const char attributes_map[] = {
1872     "<?xml version=\"1.0\"?>"
1873     "<a attr1=\"value1\" attr2=\"value2\" attr3=\"value3\" attr4=\"value4\" />"
1874 };
1875
1876 static const WCHAR nonexistent_fileW[] = {
1877     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
1878 };
1879 static const WCHAR nonexistent_attrW[] = {
1880     'n','o','n','E','x','i','s','i','t','i','n','g','A','t','t','r','i','b','u','t','e',0
1881 };
1882 static const WCHAR szDocument[] = {
1883     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
1884 };
1885
1886 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
1887 static WCHAR szdl[] = { 'd','l',0 };
1888 static const WCHAR szvr[] = { 'v','r',0 };
1889 static const WCHAR szlc[] = { 'l','c',0 };
1890 static WCHAR szbs[] = { 'b','s',0 };
1891 static const WCHAR szstr1[] = { 's','t','r','1',0 };
1892 static const WCHAR szstr2[] = { 's','t','r','2',0 };
1893 static const WCHAR szstar[] = { '*',0 };
1894 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
1895
1896 static WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
1897 static WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
1898 static WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
1899
1900 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
1901 static WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
1902 static WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
1903 static WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
1904                                 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
1905 static WCHAR szElementXML4[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
1906                                 '&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 };
1907
1908 static WCHAR szAttribute[] = {'A','t','t','r',0 };
1909 static WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
1910
1911 static WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
1912                           ' ','n','o','t',' ','r','i','g','h','t','!', 0};
1913 static WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
1914                              'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
1915                              '!',']',']','>',0};
1916 static WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
1917 static WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
1918
1919 static WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
1920 static WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
1921 static WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0};
1922
1923 #define expect_bstr_eq_and_free(bstr, expect) { \
1924     BSTR bstrExp = alloc_str_from_narrow(expect); \
1925     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
1926     SysFreeString(bstr); \
1927     SysFreeString(bstrExp); \
1928 }
1929
1930 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
1931
1932 #define ole_check(expr) { \
1933     HRESULT r = expr; \
1934     ok(r == S_OK, #expr " returned %x\n", r); \
1935 }
1936
1937 #define ole_expect(expr, expect) { \
1938     HRESULT r = expr; \
1939     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
1940 }
1941
1942 #define double_eq(x, y) ok((x)-(y)<=1e-14*(x) && (x)-(y)>=-1e-14*(x), "expected %.16g, got %.16g\n", x, y)
1943
1944 static void* _create_object(const GUID *clsid, const char *name, const IID *iid, int line)
1945 {
1946     void *obj = NULL;
1947     HRESULT hr;
1948
1949     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
1950     if (hr != S_OK)
1951         win_skip_(__FILE__,line)("failed to create %s instance: 0x%08x\n", name, hr);
1952
1953     return obj;
1954 }
1955
1956 #define _create(cls) cls, #cls
1957
1958 #define create_document(iid) _create_object(&_create(CLSID_DOMDocument2), iid, __LINE__)
1959 #define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
1960 #define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
1961 #define create_cache_version(v, iid) _create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)
1962 #define create_xsltemplate(iid) _create_object(&_create(CLSID_XSLTemplate), iid, __LINE__)
1963
1964 static BSTR alloc_str_from_narrow(const char *str)
1965 {
1966     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
1967     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
1968     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
1969     return ret;
1970 }
1971
1972 static BSTR alloced_bstrs[256];
1973 static int alloced_bstrs_count;
1974
1975 static BSTR _bstr_(const char *str)
1976 {
1977     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
1978     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
1979     return alloced_bstrs[alloced_bstrs_count++];
1980 }
1981
1982 static void free_bstrs(void)
1983 {
1984     int i;
1985     for (i = 0; i < alloced_bstrs_count; i++)
1986         SysFreeString(alloced_bstrs[i]);
1987     alloced_bstrs_count = 0;
1988 }
1989
1990 static VARIANT _variantbstr_(const char *str)
1991 {
1992     VARIANT v;
1993     V_VT(&v) = VT_BSTR;
1994     V_BSTR(&v) = _bstr_(str);
1995     return v;
1996 }
1997
1998 static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
1999 {
2000     for (;;)
2001     {
2002         while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
2003         while (*sRight == '\r' || *sRight == '\n') sRight++;
2004         if (*sLeft != *sRight) return FALSE;
2005         if (!*sLeft) return TRUE;
2006         sLeft++;
2007         sRight++;
2008     }
2009 }
2010
2011 static void get_str_for_type(DOMNodeType type, char *buf)
2012 {
2013     switch (type)
2014     {
2015         case NODE_ATTRIBUTE:
2016             strcpy(buf, "A");
2017             break;
2018         case NODE_ELEMENT:
2019             strcpy(buf, "E");
2020             break;
2021         case NODE_DOCUMENT:
2022             strcpy(buf, "D");
2023             break;
2024         case NODE_TEXT:
2025             strcpy(buf, "T");
2026             break;
2027         case NODE_COMMENT:
2028             strcpy(buf, "C");
2029             break;
2030         case NODE_PROCESSING_INSTRUCTION:
2031             strcpy(buf, "P");
2032             break;
2033         default:
2034             wsprintfA(buf, "[%d]", type);
2035     }
2036 }
2037
2038 static int get_node_position(IXMLDOMNode *node)
2039 {
2040     HRESULT r;
2041     int pos = 0;
2042
2043     IXMLDOMNode_AddRef(node);
2044     do
2045     {
2046         IXMLDOMNode *new_node;
2047
2048         pos++;
2049         r = IXMLDOMNode_get_previousSibling(node, &new_node);
2050         ok(SUCCEEDED(r), "get_previousSibling failed\n");
2051         IXMLDOMNode_Release(node);
2052         node = new_node;
2053     } while (r == S_OK);
2054     return pos;
2055 }
2056
2057 static void node_to_string(IXMLDOMNode *node, char *buf)
2058 {
2059     HRESULT r = S_OK;
2060     DOMNodeType type;
2061
2062     if (node == NULL)
2063     {
2064         lstrcpyA(buf, "(null)");
2065         return;
2066     }
2067
2068     IXMLDOMNode_AddRef(node);
2069     while (r == S_OK)
2070     {
2071         IXMLDOMNode *new_node;
2072
2073         ole_check(IXMLDOMNode_get_nodeType(node, &type));
2074         get_str_for_type(type, buf);
2075         buf+=strlen(buf);
2076
2077         if (type == NODE_ATTRIBUTE)
2078         {
2079             BSTR bstr;
2080             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
2081             *(buf++) = '\'';
2082             wsprintfA(buf, "%ws", bstr);
2083             buf += strlen(buf);
2084             *(buf++) = '\'';
2085             SysFreeString(bstr);
2086
2087             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
2088         }
2089         else
2090         {
2091             r = IXMLDOMNode_get_parentNode(node, &new_node);
2092             wsprintf(buf, "%d", get_node_position(node));
2093             buf += strlen(buf);
2094         }
2095
2096         ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
2097         IXMLDOMNode_Release(node);
2098         node = new_node;
2099         if (r == S_OK)
2100             *(buf++) = '.';
2101     }
2102
2103     *buf = 0;
2104 }
2105
2106 static char *list_to_string(IXMLDOMNodeList *list)
2107 {
2108     static char buf[4096];
2109     char *pos = buf;
2110     LONG len = 0;
2111     int i;
2112
2113     if (list == NULL)
2114     {
2115         lstrcpyA(buf, "(null)");
2116         return buf;
2117     }
2118     ole_check(IXMLDOMNodeList_get_length(list, &len));
2119     for (i = 0; i < len; i++)
2120     {
2121         IXMLDOMNode *node;
2122         if (i > 0)
2123             *(pos++) = ' ';
2124         ole_check(IXMLDOMNodeList_nextNode(list, &node));
2125         node_to_string(node, pos);
2126         pos += strlen(pos);
2127         IXMLDOMNode_Release(node);
2128     }
2129     *pos = 0;
2130     return buf;
2131 }
2132
2133 #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); }
2134 #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); }
2135
2136 struct docload_ret_t {
2137     VARIANT_BOOL b;
2138     HRESULT hr;
2139 };
2140
2141 struct leading_spaces_t {
2142     const CLSID *clsid;
2143     const char *name;
2144     struct docload_ret_t ret[2]; /* 0 - ::load(), 1 - ::loadXML() */
2145 };
2146
2147 static const struct leading_spaces_t leading_spaces_classdata[] = {
2148     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
2149     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
2150     { &CLSID_DOMDocument26, "CLSID_DOMDocument26", {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
2151     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
2152     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
2153     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
2154     { NULL }
2155 };
2156
2157 static const char* leading_spaces_xmldata[] = {
2158     "\n<?xml version=\"1.0\" encoding=\"UTF-16\" ?><root/>",
2159     " <?xml version=\"1.0\"?><root/>",
2160     "\n<?xml version=\"1.0\"?><root/>",
2161     "\t<?xml version=\"1.0\"?><root/>",
2162     "\r\n<?xml version=\"1.0\"?><root/>",
2163     "\r<?xml version=\"1.0\"?><root/>",
2164     "\r\r\r\r\t\t \n\n <?xml version=\"1.0\"?><root/>",
2165     0
2166 };
2167
2168 static void test_domdoc( void )
2169 {
2170     HRESULT r, hr;
2171     IXMLDOMDocument *doc;
2172     IXMLDOMParseError *error;
2173     IXMLDOMElement *element = NULL;
2174     IXMLDOMNode *node;
2175     IXMLDOMText *nodetext = NULL;
2176     IXMLDOMComment *node_comment = NULL;
2177     IXMLDOMAttribute *node_attr = NULL;
2178     IXMLDOMNode *nodeChild = NULL;
2179     IXMLDOMProcessingInstruction *nodePI = NULL;
2180     const struct leading_spaces_t *class_ptr;
2181     const char **data_ptr;
2182     VARIANT_BOOL b;
2183     VARIANT var;
2184     BSTR str;
2185     LONG code, ref;
2186     LONG nLength = 0;
2187     WCHAR buff[100];
2188     char path[MAX_PATH];
2189     int index;
2190
2191     GetTempPathA(MAX_PATH, path);
2192     strcat(path, "leading_spaces.xml");
2193
2194     /* Load document with leading spaces
2195      *
2196      * Test all CLSIDs with all test data XML strings
2197      */
2198     class_ptr = leading_spaces_classdata;
2199     index = 0;
2200     while (class_ptr->clsid)
2201     {
2202         HRESULT hr;
2203         int i;
2204
2205         hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
2206              &IID_IXMLDOMDocument, (void**)&doc);
2207         if (hr != S_OK) {
2208             win_skip("%d: failed to create class instance for %s\n", index, class_ptr->name);
2209             class_ptr++;
2210             index++;
2211             continue;
2212         }
2213
2214         data_ptr = leading_spaces_xmldata;
2215         i = 0;
2216         while (*data_ptr) {
2217             BSTR data = _bstr_(*data_ptr);
2218             DWORD written;
2219             HANDLE file;
2220
2221             file = CreateFileA(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
2222             ok(file != INVALID_HANDLE_VALUE, "can't create file %s: %u\n", path, GetLastError());
2223
2224             WriteFile(file, data, lstrlenW(data)*sizeof(WCHAR), &written, NULL);
2225             CloseHandle(file);
2226
2227             b = 0xc;
2228             V_VT(&var) = VT_BSTR;
2229             V_BSTR(&var) = _bstr_(path);
2230             hr = IXMLDOMDocument_load(doc, var, &b);
2231         todo_wine {
2232             EXPECT_HR(hr, class_ptr->ret[0].hr);
2233             ok(b == class_ptr->ret[0].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[0].b);
2234         }
2235             DeleteFileA(path);
2236
2237             b = 0xc;
2238             hr = IXMLDOMDocument_loadXML(doc, data, &b);
2239             EXPECT_HR(hr, class_ptr->ret[1].hr);
2240             ok(b == class_ptr->ret[1].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[1].b);
2241
2242             data_ptr++;
2243             i++;
2244         }
2245
2246         class_ptr++;
2247         index++;
2248         free_bstrs();
2249     }
2250
2251     doc = create_document(&IID_IXMLDOMDocument);
2252     if (!doc) return;
2253
2254 if (0)
2255 {
2256     /* crashes on native */
2257     IXMLDOMDocument_loadXML( doc, (BSTR)0x1, NULL );
2258 }
2259
2260     /* try some stupid things */
2261     hr = IXMLDOMDocument_loadXML( doc, NULL, NULL );
2262     EXPECT_HR(hr, S_FALSE);
2263
2264     b = VARIANT_TRUE;
2265     hr = IXMLDOMDocument_loadXML( doc, NULL, &b );
2266     EXPECT_HR(hr, S_FALSE);
2267     ok( b == VARIANT_FALSE, "failed to load XML string\n");
2268
2269     /* try to load a document from a nonexistent file */
2270     b = VARIANT_TRUE;
2271     str = SysAllocString( nonexistent_fileW );
2272     VariantInit(&var);
2273     V_VT(&var) = VT_BSTR;
2274     V_BSTR(&var) = str;
2275
2276     r = IXMLDOMDocument_load( doc, var, &b);
2277     ok( r == S_FALSE, "loadXML succeeded\n");
2278     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2279     SysFreeString( str );
2280
2281     /* try load an empty document */
2282     b = VARIANT_TRUE;
2283     str = SysAllocString( szEmpty );
2284     r = IXMLDOMDocument_loadXML( doc, str, &b );
2285     ok( r == S_FALSE, "loadXML succeeded\n");
2286     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2287     SysFreeString( str );
2288
2289     r = IXMLDOMDocument_get_async( doc, &b );
2290     ok( r == S_OK, "get_async failed (%08x)\n", r);
2291     ok( b == VARIANT_TRUE, "Wrong default value\n");
2292
2293     /* check that there's no document element */
2294     element = NULL;
2295     r = IXMLDOMDocument_get_documentElement( doc, &element );
2296     ok( r == S_FALSE, "should be no document element\n");
2297
2298     /* try finding a node */
2299     node = NULL;
2300     str = SysAllocString( szstr1 );
2301     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
2302     ok( r == S_FALSE, "ret %08x\n", r );
2303     SysFreeString( str );
2304
2305     b = VARIANT_TRUE;
2306     str = SysAllocString( szIncomplete );
2307     r = IXMLDOMDocument_loadXML( doc, str, &b );
2308     ok( r == S_FALSE, "loadXML succeeded\n");
2309     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2310     SysFreeString( str );
2311
2312     /* check that there's no document element */
2313     element = (IXMLDOMElement*)1;
2314     r = IXMLDOMDocument_get_documentElement( doc, &element );
2315     ok( r == S_FALSE, "should be no document element\n");
2316     ok( element == NULL, "Element should be NULL\n");
2317
2318     /* test for BSTR handling, pass broken BSTR */
2319     memcpy(&buff[2], szComplete1, sizeof(szComplete1));
2320     /* just a big length */
2321     *(DWORD*)buff = 0xf0f0;
2322     b = VARIANT_FALSE;
2323     r = IXMLDOMDocument_loadXML( doc, &buff[2], &b );
2324     ok( r == S_OK, "loadXML failed\n");
2325     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2326
2327     /* loadXML ignores the encoding attribute and always expects Unicode */
2328     b = VARIANT_FALSE;
2329     str = SysAllocString( szComplete6 );
2330     r = IXMLDOMDocument_loadXML( doc, str, &b );
2331     ok( r == S_OK, "loadXML failed\n");
2332     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2333     SysFreeString( str );
2334
2335     /* try a BSTR containing a Windows-1252 document */
2336     b = VARIANT_TRUE;
2337     str = SysAllocStringByteLen( win1252xml, strlen(win1252xml) );
2338     r = IXMLDOMDocument_loadXML( doc, str, &b );
2339     ok( r == S_FALSE, "loadXML succeeded\n");
2340     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2341     SysFreeString( str );
2342
2343     /* try to load something valid */
2344     b = VARIANT_FALSE;
2345     str = SysAllocString( szComplete1 );
2346     r = IXMLDOMDocument_loadXML( doc, str, &b );
2347     ok( r == S_OK, "loadXML failed\n");
2348     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2349     SysFreeString( str );
2350
2351     /* check if nodename is correct */
2352     r = IXMLDOMDocument_get_nodeName( doc, NULL );
2353     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2354
2355     str = (BSTR)0xdeadbeef;
2356     r = IXMLDOMDocument_get_baseName( doc, &str );
2357     ok ( r == S_FALSE, "got 0x%08x\n", r);
2358     ok (str == NULL, "got %p\n", str);
2359
2360     /* content doesn't matter here */
2361     str = NULL;
2362     r = IXMLDOMDocument_get_nodeName( doc, &str );
2363     ok ( r == S_OK, "get_nodeName wrong code\n");
2364     ok ( str != NULL, "str is null\n");
2365     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
2366     SysFreeString( str );
2367
2368     /* test put_text */
2369     r = IXMLDOMDocument_put_text( doc, _bstr_("Should Fail") );
2370     ok( r == E_FAIL, "ret %08x\n", r );
2371
2372     /* check that there's a document element */
2373     element = NULL;
2374     r = IXMLDOMDocument_get_documentElement( doc, &element );
2375     ok( r == S_OK, "should be a document element\n");
2376     if( element )
2377     {
2378         IObjectIdentity *ident;
2379
2380         r = IXMLDOMElement_QueryInterface( element, &IID_IObjectIdentity, (void**)&ident );
2381         ok( r == E_NOINTERFACE, "ret %08x\n", r);
2382
2383         IXMLDOMElement_Release( element );
2384         element = NULL;
2385     }
2386
2387     /* as soon as we call loadXML again, the document element will disappear */
2388     b = 2;
2389     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
2390     ok( r == S_FALSE, "loadXML failed\n");
2391     ok( b == 2, "variant modified\n");
2392     r = IXMLDOMDocument_get_documentElement( doc, &element );
2393     ok( r == S_FALSE, "should be no document element\n");
2394
2395     /* try to load something else simple and valid */
2396     b = VARIANT_FALSE;
2397     str = SysAllocString( szComplete3 );
2398     r = IXMLDOMDocument_loadXML( doc, str, &b );
2399     ok( r == S_OK, "loadXML failed\n");
2400     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2401     SysFreeString( str );
2402
2403     /* try something a little more complicated */
2404     b = FALSE;
2405     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2406     ok( r == S_OK, "loadXML failed\n");
2407     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2408
2409     r = IXMLDOMDocument_get_parseError( doc, &error );
2410     ok( r == S_OK, "returns %08x\n", r );
2411
2412     r = IXMLDOMParseError_get_errorCode( error, &code );
2413     ok( r == S_FALSE, "returns %08x\n", r );
2414     ok( code == 0, "code %d\n", code );
2415     IXMLDOMParseError_Release( error );
2416
2417     /* test createTextNode */
2418     r = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &nodetext);
2419     ok( r == S_OK, "returns %08x\n", r );
2420     IXMLDOMText_Release(nodetext);
2421
2422     str = SysAllocString( szOpen );
2423     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
2424     ok( r == E_INVALIDARG, "returns %08x\n", r );
2425     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
2426     ok( r == S_OK, "returns %08x\n", r );
2427     SysFreeString( str );
2428     if(nodetext)
2429     {
2430         r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (void**)&element);
2431         ok(r == E_NOINTERFACE, "ret %08x\n", r );
2432
2433         /* Text Last Child Checks */
2434         r = IXMLDOMText_get_lastChild(nodetext, NULL);
2435         ok(r == E_INVALIDARG, "ret %08x\n", r );
2436
2437         nodeChild = (IXMLDOMNode*)0x1;
2438         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
2439         ok(r == S_FALSE, "ret %08x\n", r );
2440         ok(nodeChild == NULL, "nodeChild not NULL\n");
2441
2442         /* test length property */
2443         r = IXMLDOMText_get_length(nodetext, NULL);
2444         ok(r == E_INVALIDARG, "ret %08x\n", r );
2445
2446         r = IXMLDOMText_get_length(nodetext, &nLength);
2447         ok(r == S_OK, "ret %08x\n", r );
2448         ok(nLength == 4, "expected 4 got %d\n", nLength);
2449
2450         /* put data Tests */
2451         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
2452         ok(r == S_OK, "ret %08x\n", r );
2453
2454         /* get data Tests */
2455         r = IXMLDOMText_get_data(nodetext, &str);
2456         ok(r == S_OK, "ret %08x\n", r );
2457         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
2458         SysFreeString(str);
2459
2460         /* Confirm XML text is good */
2461         r = IXMLDOMText_get_xml(nodetext, &str);
2462         ok(r == S_OK, "ret %08x\n", r );
2463         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
2464         SysFreeString(str);
2465
2466         /* Confirm we get the put_data Text back */
2467         r = IXMLDOMText_get_text(nodetext, &str);
2468         ok(r == S_OK, "ret %08x\n", r );
2469         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
2470         SysFreeString(str);
2471
2472         /* test substringData */
2473         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
2474         ok(r == E_INVALIDARG, "ret %08x\n", r );
2475
2476         /* test substringData - Invalid offset */
2477         str = (BSTR)&szElement;
2478         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
2479         ok(r == E_INVALIDARG, "ret %08x\n", r );
2480         ok( str == NULL, "incorrect string\n");
2481
2482         /* test substringData - Invalid offset */
2483         str = (BSTR)&szElement;
2484         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
2485         ok(r == S_FALSE, "ret %08x\n", r );
2486         ok( str == NULL, "incorrect string\n");
2487
2488         /* test substringData - Invalid size */
2489         str = (BSTR)&szElement;
2490         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
2491         ok(r == E_INVALIDARG, "ret %08x\n", r );
2492         ok( str == NULL, "incorrect string\n");
2493
2494         /* test substringData - Invalid size */
2495         str = (BSTR)&szElement;
2496         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
2497         ok(r == S_FALSE, "ret %08x\n", r );
2498         ok( str == NULL, "incorrect string\n");
2499
2500         /* test substringData - Start of string */
2501         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
2502         ok(r == S_OK, "ret %08x\n", r );
2503         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
2504         SysFreeString(str);
2505
2506         /* test substringData - Middle of string */
2507         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
2508         ok(r == S_OK, "ret %08x\n", r );
2509         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
2510         SysFreeString(str);
2511
2512         /* test substringData - End of string */
2513         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
2514         ok(r == S_OK, "ret %08x\n", r );
2515         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
2516         SysFreeString(str);
2517
2518         /* test appendData */
2519         r = IXMLDOMText_appendData(nodetext, NULL);
2520         ok(r == S_OK, "ret %08x\n", r );
2521
2522         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
2523         ok(r == S_OK, "ret %08x\n", r );
2524
2525         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
2526         ok(r == S_OK, "ret %08x\n", r );
2527
2528         r = IXMLDOMText_get_text(nodetext, &str);
2529         ok(r == S_OK, "ret %08x\n", r );
2530         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2531         SysFreeString(str);
2532
2533         /* test insertData */
2534         str = SysAllocStringLen(NULL, 0);
2535         r = IXMLDOMText_insertData(nodetext, -1, str);
2536         ok(r == S_OK, "ret %08x\n", r );
2537
2538         r = IXMLDOMText_insertData(nodetext, -1, NULL);
2539         ok(r == S_OK, "ret %08x\n", r );
2540
2541         r = IXMLDOMText_insertData(nodetext, 1000, str);
2542         ok(r == S_OK, "ret %08x\n", r );
2543
2544         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
2545         ok(r == S_OK, "ret %08x\n", r );
2546
2547         r = IXMLDOMText_insertData(nodetext, 0, NULL);
2548         ok(r == S_OK, "ret %08x\n", r );
2549
2550         r = IXMLDOMText_insertData(nodetext, 0, str);
2551         ok(r == S_OK, "ret %08x\n", r );
2552         SysFreeString(str);
2553
2554         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
2555         ok(r == E_INVALIDARG, "ret %08x\n", r );
2556
2557         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
2558         ok(r == E_INVALIDARG, "ret %08x\n", r );
2559
2560         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
2561         ok(r == S_OK, "ret %08x\n", r );
2562
2563         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
2564         ok(r == S_OK, "ret %08x\n", r );
2565
2566         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
2567         ok(r == S_OK, "ret %08x\n", r );
2568
2569         r = IXMLDOMText_get_text(nodetext, &str);
2570         ok(r == S_OK, "ret %08x\n", r );
2571         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2572         SysFreeString(str);
2573
2574         /* delete data */
2575         /* invalid arguments */
2576         r = IXMLDOMText_deleteData(nodetext, -1, 1);
2577         ok(r == E_INVALIDARG, "ret %08x\n", r );
2578
2579         r = IXMLDOMText_deleteData(nodetext, 0, 0);
2580         ok(r == S_OK, "ret %08x\n", r );
2581
2582         r = IXMLDOMText_deleteData(nodetext, 0, -1);
2583         ok(r == E_INVALIDARG, "ret %08x\n", r );
2584
2585         r = IXMLDOMText_get_length(nodetext, &nLength);
2586         ok(r == S_OK, "ret %08x\n", r );
2587         ok(nLength == 43, "expected 43 got %d\n", nLength);
2588
2589         r = IXMLDOMText_deleteData(nodetext, nLength, 1);
2590         ok(r == S_OK, "ret %08x\n", r );
2591
2592         r = IXMLDOMText_deleteData(nodetext, nLength+1, 1);
2593         ok(r == E_INVALIDARG, "ret %08x\n", r );
2594
2595         /* delete from start */
2596         r = IXMLDOMText_deleteData(nodetext, 0, 5);
2597         ok(r == S_OK, "ret %08x\n", r );
2598
2599         r = IXMLDOMText_get_length(nodetext, &nLength);
2600         ok(r == S_OK, "ret %08x\n", r );
2601         ok(nLength == 38, "expected 38 got %d\n", nLength);
2602
2603         r = IXMLDOMText_get_text(nodetext, &str);
2604         ok(r == S_OK, "ret %08x\n", r );
2605         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2606         SysFreeString(str);
2607
2608         /* delete from end */
2609         r = IXMLDOMText_deleteData(nodetext, 35, 3);
2610         ok(r == S_OK, "ret %08x\n", r );
2611
2612         r = IXMLDOMText_get_length(nodetext, &nLength);
2613         ok(r == S_OK, "ret %08x\n", r );
2614         ok(nLength == 35, "expected 35 got %d\n", nLength);
2615
2616         r = IXMLDOMText_get_text(nodetext, &str);
2617         ok(r == S_OK, "ret %08x\n", r );
2618         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2619         SysFreeString(str);
2620
2621         /* delete from inside */
2622         r = IXMLDOMText_deleteData(nodetext, 1, 33);
2623         ok(r == S_OK, "ret %08x\n", r );
2624
2625         r = IXMLDOMText_get_length(nodetext, &nLength);
2626         ok(r == S_OK, "ret %08x\n", r );
2627         ok(nLength == 2, "expected 2 got %d\n", nLength);
2628
2629         r = IXMLDOMText_get_text(nodetext, &str);
2630         ok(r == S_OK, "ret %08x\n", r );
2631         ok( !lstrcmpW( str, _bstr_("") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2632         SysFreeString(str);
2633
2634         /* delete whole data ... */
2635         r = IXMLDOMText_get_length(nodetext, &nLength);
2636         ok(r == S_OK, "ret %08x\n", r );
2637
2638         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
2639         ok(r == S_OK, "ret %08x\n", r );
2640         /* ... and try again with empty string */
2641         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
2642         ok(r == S_OK, "ret %08x\n", r );
2643
2644         /* test put_data */
2645         V_VT(&var) = VT_BSTR;
2646         V_BSTR(&var) = SysAllocString(szstr1);
2647         r = IXMLDOMText_put_nodeValue(nodetext, var);
2648         ok(r == S_OK, "ret %08x\n", r );
2649         VariantClear(&var);
2650
2651         r = IXMLDOMText_get_text(nodetext, &str);
2652         ok(r == S_OK, "ret %08x\n", r );
2653         ok( !lstrcmpW( str, szstr1 ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2654         SysFreeString(str);
2655
2656         /* test put_data */
2657         V_VT(&var) = VT_I4;
2658         V_I4(&var) = 99;
2659         r = IXMLDOMText_put_nodeValue(nodetext, var);
2660         ok(r == S_OK, "ret %08x\n", r );
2661         VariantClear(&var);
2662
2663         r = IXMLDOMText_get_text(nodetext, &str);
2664         ok(r == S_OK, "ret %08x\n", r );
2665         ok( !lstrcmpW( str, _bstr_("99") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2666         SysFreeString(str);
2667
2668         /* ::replaceData() */
2669         V_VT(&var) = VT_BSTR;
2670         V_BSTR(&var) = SysAllocString(szstr1);
2671         r = IXMLDOMText_put_nodeValue(nodetext, var);
2672         ok(r == S_OK, "ret %08x\n", r );
2673         VariantClear(&var);
2674
2675         r = IXMLDOMText_replaceData(nodetext, 6, 0, NULL);
2676         ok(r == E_INVALIDARG, "ret %08x\n", r );
2677         r = IXMLDOMText_get_text(nodetext, &str);
2678         ok(r == S_OK, "ret %08x\n", r );
2679         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2680         SysFreeString(str);
2681
2682         r = IXMLDOMText_replaceData(nodetext, 0, 0, NULL);
2683         ok(r == S_OK, "ret %08x\n", r );
2684         r = IXMLDOMText_get_text(nodetext, &str);
2685         ok(r == S_OK, "ret %08x\n", r );
2686         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2687         SysFreeString(str);
2688
2689         /* NULL pointer means delete */
2690         r = IXMLDOMText_replaceData(nodetext, 0, 1, NULL);
2691         ok(r == S_OK, "ret %08x\n", r );
2692         r = IXMLDOMText_get_text(nodetext, &str);
2693         ok(r == S_OK, "ret %08x\n", r );
2694         ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2695         SysFreeString(str);
2696
2697         /* empty string means delete */
2698         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_(""));
2699         ok(r == S_OK, "ret %08x\n", r );
2700         r = IXMLDOMText_get_text(nodetext, &str);
2701         ok(r == S_OK, "ret %08x\n", r );
2702         ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2703         SysFreeString(str);
2704
2705         /* zero count means insert */
2706         r = IXMLDOMText_replaceData(nodetext, 0, 0, _bstr_("a"));
2707         ok(r == S_OK, "ret %08x\n", r );
2708         r = IXMLDOMText_get_text(nodetext, &str);
2709         ok(r == S_OK, "ret %08x\n", r );
2710         ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2711         SysFreeString(str);
2712
2713         r = IXMLDOMText_replaceData(nodetext, 0, 2, NULL);
2714         ok(r == S_OK, "ret %08x\n", r );
2715
2716         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("m"));
2717         ok(r == S_OK, "ret %08x\n", r );
2718         r = IXMLDOMText_get_text(nodetext, &str);
2719         ok(r == S_OK, "ret %08x\n", r );
2720         ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2721         SysFreeString(str);
2722
2723         /* nonempty string, count greater than its length */
2724         r = IXMLDOMText_replaceData(nodetext, 0, 2, _bstr_("a1.2"));
2725         ok(r == S_OK, "ret %08x\n", r );
2726         r = IXMLDOMText_get_text(nodetext, &str);
2727         ok(r == S_OK, "ret %08x\n", r );
2728         ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2729         SysFreeString(str);
2730
2731         /* nonempty string, count less than its length */
2732         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_("wine"));
2733         ok(r == S_OK, "ret %08x\n", r );
2734         r = IXMLDOMText_get_text(nodetext, &str);
2735         ok(r == S_OK, "ret %08x\n", r );
2736         ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2737         SysFreeString(str);
2738
2739         IXMLDOMText_Release( nodetext );
2740     }
2741
2742     /* test Create Comment */
2743     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
2744     ok( r == E_INVALIDARG, "returns %08x\n", r );
2745     node_comment = (IXMLDOMComment*)0x1;
2746
2747     /* empty comment */
2748     r = IXMLDOMDocument_createComment(doc, _bstr_(""), &node_comment);
2749     ok( r == S_OK, "returns %08x\n", r );
2750     str = (BSTR)0x1;
2751     r = IXMLDOMComment_get_data(node_comment, &str);
2752     ok( r == S_OK, "returns %08x\n", r );
2753     ok( str && SysStringLen(str) == 0, "expected empty string data\n");
2754     IXMLDOMComment_Release(node_comment);
2755     SysFreeString(str);
2756
2757     r = IXMLDOMDocument_createComment(doc, NULL, &node_comment);
2758     ok( r == S_OK, "returns %08x\n", r );
2759     str = (BSTR)0x1;
2760     r = IXMLDOMComment_get_data(node_comment, &str);
2761     ok( r == S_OK, "returns %08x\n", r );
2762     ok( str && (SysStringLen(str) == 0), "expected empty string data\n");
2763     IXMLDOMComment_Release(node_comment);
2764     SysFreeString(str);
2765
2766     str = SysAllocString(szComment);
2767     r = IXMLDOMDocument_createComment(doc, str, &node_comment);
2768     SysFreeString(str);
2769     ok( r == S_OK, "returns %08x\n", r );
2770     if(node_comment)
2771     {
2772         /* Last Child Checks */
2773         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
2774         ok(r == E_INVALIDARG, "ret %08x\n", r );
2775
2776         nodeChild = (IXMLDOMNode*)0x1;
2777         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
2778         ok(r == S_FALSE, "ret %08x\n", r );
2779         ok(nodeChild == NULL, "pLastChild not NULL\n");
2780
2781         /* baseName */
2782         str = (BSTR)0xdeadbeef;
2783         r = IXMLDOMComment_get_baseName(node_comment, &str);
2784         ok(r == S_FALSE, "ret %08x\n", r );
2785         ok(str == NULL, "Expected NULL\n");
2786
2787         IXMLDOMComment_Release( node_comment );
2788     }
2789
2790     /* test Create Attribute */
2791     str = SysAllocString(szAttribute);
2792     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
2793     ok( r == E_INVALIDARG, "returns %08x\n", r );
2794     r = IXMLDOMDocument_createAttribute(doc, str, &node_attr);
2795     ok( r == S_OK, "returns %08x\n", r );
2796     IXMLDOMText_Release( node_attr);
2797     SysFreeString(str);
2798
2799     /* test Processing Instruction */
2800     str = SysAllocStringLen(NULL, 0);
2801     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
2802     ok( r == E_INVALIDARG, "returns %08x\n", r );
2803     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
2804     ok( r == E_FAIL, "returns %08x\n", r );
2805     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
2806     ok( r == E_FAIL, "returns %08x\n", r );
2807     SysFreeString(str);
2808
2809     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
2810     ok( r == S_OK, "returns %08x\n", r );
2811     if(nodePI)
2812     {
2813         /* Last Child Checks */
2814         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
2815         ok(r == E_INVALIDARG, "ret %08x\n", r );
2816
2817         nodeChild = (IXMLDOMNode*)0x1;
2818         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
2819         ok(r == S_FALSE, "ret %08x\n", r );
2820         ok(nodeChild == NULL, "nodeChild not NULL\n");
2821
2822         /* test nodeName */
2823         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
2824         ok(r == S_OK, "ret %08x\n", r );
2825         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2826         SysFreeString(str);
2827
2828         /* test baseName */
2829         str = (BSTR)0x1;
2830         r = IXMLDOMProcessingInstruction_get_baseName(nodePI, &str);
2831         ok(r == S_OK, "ret %08x\n", r );
2832         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2833         SysFreeString(str);
2834
2835         /* test Target */
2836         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
2837         ok(r == S_OK, "ret %08x\n", r );
2838         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
2839         SysFreeString(str);
2840
2841         /* test get_data */
2842         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
2843         ok(r == S_OK, "ret %08x\n", r );
2844         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
2845         SysFreeString(str);
2846
2847         /* test put_data */
2848         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
2849         ok(r == E_FAIL, "ret %08x\n", r );
2850
2851         /* test put_data */
2852         V_VT(&var) = VT_BSTR;
2853         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
2854         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
2855         ok(r == E_FAIL, "ret %08x\n", r );
2856         VariantClear(&var);
2857
2858         /* test get nodeName */
2859         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
2860         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2861         ok(r == S_OK, "ret %08x\n", r );
2862         SysFreeString(str);
2863
2864         IXMLDOMProcessingInstruction_Release(nodePI);
2865     }
2866
2867     ref = IXMLDOMDocument_Release( doc );
2868     ok( ref == 0, "got %d\n", ref);
2869
2870     free_bstrs();
2871 }
2872
2873 static void test_persiststreaminit(void)
2874 {
2875     IXMLDOMDocument *doc;
2876     IPersistStreamInit *streaminit;
2877     HRESULT hr;
2878
2879     doc = create_document(&IID_IXMLDOMDocument);
2880     if (!doc) return;
2881
2882     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&streaminit);
2883     ok( hr == S_OK, "failed with 0x%08x\n", hr );
2884
2885     hr = IPersistStreamInit_InitNew(streaminit);
2886     ok( hr == S_OK, "failed with 0x%08x\n", hr );
2887
2888     IXMLDOMDocument_Release(doc);
2889 }
2890
2891 static void test_domnode( void )
2892 {
2893     HRESULT r;
2894     IXMLDOMDocument *doc, *owner = NULL;
2895     IXMLDOMElement *element = NULL;
2896     IXMLDOMNamedNodeMap *map = NULL;
2897     IXMLDOMNode *node = NULL, *next = NULL;
2898     IXMLDOMNodeList *list = NULL;
2899     IXMLDOMAttribute *attr = NULL;
2900     DOMNodeType type = NODE_INVALID;
2901     VARIANT_BOOL b;
2902     BSTR str;
2903     VARIANT var;
2904     LONG count;
2905
2906     doc = create_document(&IID_IXMLDOMDocument);
2907     if (!doc) return;
2908
2909     b = FALSE;
2910     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2911     ok( r == S_OK, "loadXML failed\n");
2912     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2913
2914     EXPECT_CHILDREN(doc);
2915
2916     r = IXMLDOMDocument_get_documentElement( doc, &element );
2917     ok( r == S_OK, "should be a document element\n");
2918     ok( element != NULL, "should be an element\n");
2919
2920     VariantInit(&var);
2921     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
2922
2923     r = IXMLDOMNode_get_nodeValue( doc, NULL );
2924     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
2925
2926     r = IXMLDOMNode_get_nodeValue( doc, &var );
2927     ok( r == S_FALSE, "nextNode returned wrong code\n");
2928     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
2929     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
2930
2931     if (element)
2932     {
2933         owner = NULL;
2934         r = IXMLDOMNode_get_ownerDocument( element, &owner );
2935         ok( r == S_OK, "get_ownerDocument return code\n");
2936         ok( owner != doc, "get_ownerDocument return\n");
2937         IXMLDOMDocument_Release(owner);
2938
2939         type = NODE_INVALID;
2940         r = IXMLDOMNode_get_nodeType( element, &type);
2941         ok( r == S_OK, "got %08x\n", r);
2942         ok( type == NODE_ELEMENT, "node not an element\n");
2943
2944         str = NULL;
2945         r = IXMLDOMNode_get_baseName( element, &str );
2946         ok( r == S_OK, "get_baseName returned wrong code\n");
2947         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
2948         SysFreeString(str);
2949
2950         /* check if nodename is correct */
2951         r = IXMLDOMElement_get_nodeName( element, NULL );
2952         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2953
2954         /* content doesn't matter here */
2955         str = NULL;
2956         r = IXMLDOMElement_get_nodeName( element, &str );
2957         ok ( r == S_OK, "get_nodeName wrong code\n");
2958         ok ( str != NULL, "str is null\n");
2959         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
2960         SysFreeString( str );
2961
2962         str = SysAllocString( nonexistent_fileW );
2963         V_VT(&var) = VT_I4;
2964         V_I4(&var) = 0x1234;
2965         r = IXMLDOMElement_getAttribute( element, str, &var );
2966         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
2967         ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
2968         VariantClear(&var);
2969
2970         str = SysAllocString( szdl );
2971         V_VT(&var) = VT_I4;
2972         V_I4(&var) = 0x1234;
2973         r = IXMLDOMElement_getAttribute( element, str, &var );
2974         ok( r == S_OK, "getAttribute ret %08x\n", r );
2975         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
2976         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
2977         VariantClear( &var );
2978
2979         r = IXMLDOMElement_getAttribute( element, NULL, &var );
2980         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
2981
2982         r = IXMLDOMElement_getAttribute( element, str, NULL );
2983         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
2984
2985         attr = NULL;
2986         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
2987         ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
2988         ok( attr != NULL, "getAttributeNode returned NULL\n" );
2989         if (attr)
2990         {
2991             r = IXMLDOMAttribute_get_parentNode( attr, NULL );
2992             ok( r == E_INVALIDARG, "Expected E_INVALIDARG, ret %08x\n", r );
2993
2994             /* attribute doesn't have a parent in msxml interpretation */
2995             node = (IXMLDOMNode*)0xdeadbeef;
2996             r = IXMLDOMAttribute_get_parentNode( attr, &node );
2997             ok( r == S_FALSE, "Expected S_FALSE, ret %08x\n", r );
2998             ok( node == NULL, "Expected NULL, got %p\n", node );
2999
3000             IXMLDOMAttribute_Release(attr);
3001         }
3002
3003         SysFreeString( str );
3004
3005         r = IXMLDOMElement_get_attributes( element, &map );
3006         ok( r == S_OK, "get_attributes returned wrong code\n");
3007         ok( map != NULL, "should be attributes\n");
3008
3009         EXPECT_CHILDREN(element);
3010     }
3011     else
3012         ok( FALSE, "no element\n");
3013
3014     if (map)
3015     {
3016         str = SysAllocString( szdl );
3017         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
3018         ok( r == S_OK, "getNamedItem returned wrong code\n");
3019         ok( node != NULL, "should be attributes\n");
3020         IXMLDOMNode_Release(node);
3021         SysFreeString( str );
3022
3023         str = SysAllocString( szdl );
3024         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
3025         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
3026         SysFreeString( str );
3027
3028         /* something that isn't in complete4A */
3029         str = SysAllocString( szOpen );
3030         node = (IXMLDOMNode *) 1;
3031         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
3032         ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
3033         ok( node == NULL, "getNamedItem should have returned NULL\n");
3034         SysFreeString( str );
3035
3036         /* test indexed access of attributes */
3037         r = IXMLDOMNamedNodeMap_get_length( map, NULL );
3038         ok ( r == E_INVALIDARG, "get_length should return E_INVALIDARG\n");
3039
3040         r = IXMLDOMNamedNodeMap_get_length( map, &count );
3041         ok ( r == S_OK, "get_length wrong code\n");
3042         ok ( count == 1, "get_length != 1\n");
3043
3044         node = NULL;
3045         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
3046         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
3047         ok ( node == NULL, "there is no node\n");
3048
3049         node = NULL;
3050         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
3051         ok ( r == S_FALSE, "get_item (1) wrong code\n");
3052         ok ( node == NULL, "there is no attribute\n");
3053
3054         node = NULL;
3055         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
3056         ok ( r == S_OK, "get_item (0) wrong code\n");
3057         ok ( node != NULL, "should be attribute\n");
3058
3059         r = IXMLDOMNode_get_nodeName( node, NULL );
3060         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
3061
3062         /* content doesn't matter here */
3063         str = NULL;
3064         r = IXMLDOMNode_get_nodeName( node, &str );
3065         ok ( r == S_OK, "get_nodeName wrong code\n");
3066         ok ( str != NULL, "str is null\n");
3067         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
3068         SysFreeString( str );
3069         IXMLDOMNode_Release( node );
3070
3071         /* test sequential access of attributes */
3072         node = NULL;
3073         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
3074         ok ( r == S_OK, "nextNode (first time) wrong code\n");
3075         ok ( node != NULL, "nextNode, should be attribute\n");
3076         IXMLDOMNode_Release( node );
3077
3078         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
3079         ok ( r != S_OK, "nextNode (second time) wrong code\n");
3080         ok ( node == NULL, "nextNode, there is no attribute\n");
3081
3082         r = IXMLDOMNamedNodeMap_reset( map );
3083         ok ( r == S_OK, "reset should return S_OK\n");
3084
3085         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
3086         ok ( r == S_OK, "nextNode (third time) wrong code\n");
3087         ok ( node != NULL, "nextNode, should be attribute\n");
3088     }
3089     else
3090         ok( FALSE, "no map\n");
3091
3092     if (node)
3093     {
3094         type = NODE_INVALID;
3095         r = IXMLDOMNode_get_nodeType( node, &type);
3096         ok( r == S_OK, "getNamedItem returned wrong code\n");
3097         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
3098
3099         str = NULL;
3100         r = IXMLDOMNode_get_baseName( node, NULL );
3101         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
3102
3103         str = NULL;
3104         r = IXMLDOMNode_get_baseName( node, &str );
3105         ok( r == S_OK, "get_baseName returned wrong code\n");
3106         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
3107         SysFreeString( str );
3108
3109         r = IXMLDOMNode_get_childNodes( node, NULL );
3110         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
3111
3112         r = IXMLDOMNode_get_childNodes( node, &list );
3113         ok( r == S_OK, "get_childNodes returned wrong code\n");
3114
3115         if (list)
3116         {
3117             r = IXMLDOMNodeList_nextNode( list, &next );
3118             ok( r == S_OK, "nextNode returned wrong code\n");
3119         }
3120         else
3121             ok( FALSE, "no childlist\n");
3122
3123         if (next)
3124         {
3125             EXPECT_NO_CHILDREN(next);
3126
3127             type = NODE_INVALID;
3128             r = IXMLDOMNode_get_nodeType( next, &type);
3129             ok( r == S_OK, "getNamedItem returned wrong code\n");
3130             ok( type == NODE_TEXT, "node not text\n");
3131
3132             str = (BSTR) 1;
3133             r = IXMLDOMNode_get_baseName( next, &str );
3134             ok( r == S_FALSE, "get_baseName returned wrong code\n");
3135             ok( str == NULL, "basename was wrong\n");
3136             SysFreeString(str);
3137         }
3138         else
3139             ok( FALSE, "no next\n");
3140
3141         if (next)
3142             IXMLDOMNode_Release( next );
3143         next = NULL;
3144         if (list)
3145             IXMLDOMNodeList_Release( list );
3146         list = NULL;
3147         if (node)
3148             IXMLDOMNode_Release( node );
3149     }
3150     else
3151         ok( FALSE, "no node\n");
3152     node = NULL;
3153
3154     if (map)
3155         IXMLDOMNamedNodeMap_Release( map );
3156
3157     /* now traverse the tree from the root element */
3158     if (element)
3159     {
3160         r = IXMLDOMNode_get_childNodes( element, &list );
3161         ok( r == S_OK, "get_childNodes returned wrong code\n");
3162
3163         /* using get_item for child list doesn't advance the position */
3164         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
3165         expect_node(node, "E2.E2.D1");
3166         IXMLDOMNode_Release(node);
3167         ole_check(IXMLDOMNodeList_nextNode(list, &node));
3168         expect_node(node, "E1.E2.D1");
3169         IXMLDOMNode_Release(node);
3170         ole_check(IXMLDOMNodeList_reset(list));
3171
3172         IXMLDOMNodeList_AddRef(list);
3173         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
3174         ole_check(IXMLDOMNodeList_reset(list));
3175
3176         node = (void*)0xdeadbeef;
3177         str = SysAllocString(szdl);
3178         r = IXMLDOMNode_selectSingleNode( element, str, &node );
3179         SysFreeString(str);
3180         ok( r == S_FALSE, "ret %08x\n", r );
3181         ok( node == NULL, "node %p\n", node );
3182
3183         str = SysAllocString(szbs);
3184         r = IXMLDOMNode_selectSingleNode( element, str, &node );
3185         SysFreeString(str);
3186         ok( r == S_OK, "ret %08x\n", r );
3187         r = IXMLDOMNode_Release( node );
3188         ok( r == 0, "ret %08x\n", r );
3189     }
3190     else
3191         ok( FALSE, "no element\n");
3192
3193     if (list)
3194     {
3195         r = IXMLDOMNodeList_get_item(list, 0, NULL);
3196         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
3197
3198         r = IXMLDOMNodeList_get_length(list, NULL);
3199         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
3200
3201         r = IXMLDOMNodeList_get_length( list, &count );
3202         ok( r == S_OK, "get_length returns %08x\n", r );
3203         ok( count == 4, "get_length got %d\n", count );
3204
3205         r = IXMLDOMNodeList_nextNode(list, NULL);
3206         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
3207
3208         r = IXMLDOMNodeList_nextNode( list, &node );
3209         ok( r == S_OK, "nextNode returned wrong code\n");
3210     }
3211     else
3212         ok( FALSE, "no list\n");
3213
3214     if (node)
3215     {
3216         type = NODE_INVALID;
3217         r = IXMLDOMNode_get_nodeType( node, &type);
3218         ok( r == S_OK, "getNamedItem returned wrong code\n");
3219         ok( type == NODE_ELEMENT, "node not text\n");
3220
3221         r = IXMLDOMNode_hasChildNodes( node, NULL );
3222         ok( r == E_INVALIDARG, "hasChildNodes bad return\n");
3223
3224         EXPECT_CHILDREN(node);
3225
3226         str = NULL;
3227         r = IXMLDOMNode_get_baseName( node, &str );
3228         ok( r == S_OK, "get_baseName returned wrong code\n");
3229         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
3230         SysFreeString(str);
3231     }
3232     else
3233         ok( FALSE, "no node\n");
3234
3235     if (node)
3236         IXMLDOMNode_Release( node );
3237     if (list)
3238         IXMLDOMNodeList_Release( list );
3239     if (element)
3240         IXMLDOMElement_Release( element );
3241
3242     b = FALSE;
3243     str = SysAllocString( szComplete5 );
3244     r = IXMLDOMDocument_loadXML( doc, str, &b );
3245     ok( r == S_OK, "loadXML failed\n");
3246     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3247     SysFreeString( str );
3248
3249     EXPECT_CHILDREN(doc);
3250
3251     r = IXMLDOMDocument_get_documentElement( doc, &element );
3252     ok( r == S_OK, "should be a document element\n");
3253     ok( element != NULL, "should be an element\n");
3254
3255     if (element)
3256     {
3257         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
3258         BSTR tag = NULL;
3259
3260         /* check if the tag is correct */
3261         r = IXMLDOMElement_get_tagName( element, &tag );
3262         ok( r == S_OK, "couldn't get tag name\n");
3263         ok( tag != NULL, "tag was null\n");
3264         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
3265         SysFreeString( tag );
3266     }
3267
3268     if (element)
3269         IXMLDOMElement_Release( element );
3270     ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
3271
3272     free_bstrs();
3273 }
3274
3275 typedef struct {
3276     DOMNodeType type;
3277     REFIID iid;
3278 } refcount_test_t;
3279
3280 static const refcount_test_t refcount_test[] = {
3281     { NODE_ELEMENT,                &IID_IXMLDOMElement },
3282     { NODE_ATTRIBUTE,              &IID_IXMLDOMAttribute },
3283     { NODE_TEXT,                   &IID_IXMLDOMText },
3284     { NODE_CDATA_SECTION,          &IID_IXMLDOMCDATASection },
3285     { NODE_ENTITY_REFERENCE,       &IID_IXMLDOMEntityReference },
3286     { NODE_PROCESSING_INSTRUCTION, &IID_IXMLDOMProcessingInstruction },
3287     { NODE_COMMENT,                &IID_IXMLDOMComment },
3288     { NODE_DOCUMENT_FRAGMENT,      &IID_IXMLDOMDocumentFragment },
3289     { NODE_INVALID,                &IID_NULL }
3290 };
3291
3292 static void test_refs(void)
3293 {
3294     IXMLDOMImplementation *impl, *impl2;
3295     IXMLDOMElement *element, *elem2;
3296     IXMLDOMNodeList *node_list = NULL;
3297     IXMLDOMNode *node, *node2, *node3;
3298     const refcount_test_t *ptr;
3299     IXMLDOMDocument *doc;
3300     IUnknown *unk, *unk2;
3301     VARIANT_BOOL b;
3302     HRESULT hr;
3303     LONG ref;
3304
3305     doc = create_document(&IID_IXMLDOMDocument);
3306     if (!doc) return;
3307
3308     ptr = refcount_test;
3309     while (ptr->type != NODE_INVALID)
3310     {
3311         IUnknown *node_typed, *node_typed2;
3312         IDispatchEx *dispex, *dispex2;
3313         IDispatch *disp, *disp2;
3314         VARIANT type;
3315
3316         V_VT(&type) = VT_I1;
3317         V_I1(&type) = ptr->type;
3318
3319         EXPECT_REF(doc, 1);
3320         hr = IXMLDOMDocument_createNode(doc, type, _bstr_("name"), NULL, &node);
3321         EXPECT_HR(hr, S_OK);
3322         EXPECT_REF(doc, 1);
3323         EXPECT_REF(node, 1);
3324
3325         /* try IDispatch and IUnknown from IXMLDOMNode */
3326         hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
3327         EXPECT_HR(hr, S_OK);
3328         EXPECT_REF(unk, 2);
3329 todo_wine {
3330         EXPECT_REF(node, 1);
3331         ok(unk != (IUnknown*)node, "%d: got %p and %p\n", ptr->type, unk, node);
3332 }
3333         EXPECT_REF(unk, 2);
3334         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
3335         EXPECT_HR(hr, S_OK);
3336         todo_wine ok(unk != (IUnknown*)disp, "%d: got %p and %p\n", ptr->type, unk, disp);
3337         EXPECT_REF(unk, 3);
3338         todo_wine EXPECT_REF(disp, 1);
3339
3340         EXPECT_REF(unk, 3);
3341         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp2);
3342         EXPECT_HR(hr, S_OK);
3343         todo_wine ok(disp != disp2, "%d: got %p and %p\n", ptr->type, disp, disp2);
3344         EXPECT_REF(unk, 4);
3345         todo_wine EXPECT_REF(disp2, 1);
3346
3347         IDispatch_Release(disp);
3348         IDispatch_Release(disp2);
3349
3350         /* get IXMLDOMNode from this IUnknown */
3351         EXPECT_REF(unk, 2);
3352         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node2);
3353         EXPECT_HR(hr, S_OK);
3354         todo_wine ok(unk != (IUnknown*)node2, "%d: got %p and %p\n", ptr->type, unk, node2);
3355         EXPECT_REF(unk, 3);
3356         todo_wine EXPECT_REF(node2, 1);
3357
3358         EXPECT_REF(unk, 3);
3359         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node3);
3360         EXPECT_HR(hr, S_OK);
3361         todo_wine ok(node2 != node3, "%d: got %p and %p\n", ptr->type, node2, node3);
3362         EXPECT_REF(unk, 4);
3363         todo_wine EXPECT_REF(node3, 1);
3364
3365         IXMLDOMNode_Release(node2);
3366         IXMLDOMNode_Release(node3);
3367
3368         /* try IDispatchEx from IUnknown */
3369         EXPECT_REF(unk, 2);
3370         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
3371         EXPECT_HR(hr, S_OK);
3372         ok(unk != (IUnknown*)dispex, "%d: got %p and %p\n", ptr->type, unk, dispex);
3373         EXPECT_REF(unk, 3);
3374         todo_wine EXPECT_REF(dispex, 1);
3375
3376         EXPECT_REF(unk, 3);
3377         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex2);
3378         EXPECT_HR(hr, S_OK);
3379         todo_wine ok(dispex != dispex2, "%d: got %p and %p\n", ptr->type, dispex, dispex2);
3380         EXPECT_REF(unk, 4);
3381         todo_wine EXPECT_REF(dispex2, 1);
3382
3383         IDispatch_Release(dispex);
3384         IDispatch_Release(dispex2);
3385
3386         /* try corresponding IXMLDOM* */
3387         EXPECT_REF(unk, 2);
3388         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed);
3389         EXPECT_HR(hr, S_OK);
3390         EXPECT_REF(unk, 3);
3391         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed2);
3392         EXPECT_HR(hr, S_OK);
3393         EXPECT_REF(unk, 4);
3394         todo_wine ok(node_typed != node_typed2, "%d: got %p and %p\n", ptr->type, node_typed, node_typed2);
3395         IUnknown_Release(node_typed);
3396         IUnknown_Release(node_typed2);
3397
3398         /* try invalid IXMLDOM* */
3399         hr = IUnknown_QueryInterface(unk, (ptr+1)->iid, (void**)&node_typed);
3400         EXPECT_HR(hr, E_NOINTERFACE);
3401
3402         IUnknown_Release(unk);
3403
3404         EXPECT_REF(node, 1);
3405         hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMNode, (void**)&node2);
3406         EXPECT_HR(hr, S_OK);
3407         EXPECT_REF(node, 2);
3408         ok(node == node2, "%d: got %p and %p\n", ptr->type, node, node2);
3409
3410         EXPECT_REF(node, 2);
3411         hr = IXMLDOMNode_QueryInterface(node, ptr->iid, (void**)&node_typed);
3412         EXPECT_HR(hr, S_OK);
3413         EXPECT_REF(node, 3);
3414 todo_wine {
3415         EXPECT_REF(node_typed, 2);
3416         ok((IUnknown*)node != node_typed, "%d: got %p and %p\n", ptr->type, node, node_typed);
3417 }
3418         IUnknown_Release(node_typed);
3419
3420         IXMLDOMNode_Release(node2);
3421         IXMLDOMNode_Release(node);
3422
3423         ptr++;
3424     }
3425
3426     EXPECT_REF(doc, 1);
3427     ref = IXMLDOMDocument_Release(doc);
3428     ok( ref == 0, "ref %d\n", ref);
3429
3430     /* check IUnknown after releasing DOM iface */
3431     doc = create_document(&IID_IXMLDOMDocument);
3432     EXPECT_REF(doc, 1);
3433     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
3434     EXPECT_HR(hr, S_OK);
3435 todo_wine {
3436     EXPECT_REF(unk, 3);
3437     EXPECT_REF(doc, 1);
3438 }
3439     IXMLDOMDocument_Release(doc);
3440     EXPECT_REF(unk, 1);
3441     IUnknown_Release(unk);
3442
3443     doc = create_document(&IID_IXMLDOMDocument);
3444     if (!doc) return;
3445
3446     EXPECT_REF(doc, 1);
3447     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
3448     EXPECT_HR(hr, S_OK);
3449 todo_wine {
3450     EXPECT_REF(unk, 3);
3451     EXPECT_REF(doc, 1);
3452 }
3453     IUnknown_Release(unk);
3454
3455     /* IXMLDOMImplementation */
3456     EXPECT_REF(doc, 1);
3457     hr = IXMLDOMDocument_get_implementation(doc, &impl);
3458     EXPECT_HR(hr, S_OK);
3459     EXPECT_REF(doc, 1);
3460     EXPECT_REF(impl, 1);
3461     hr = IXMLDOMDocument_get_implementation(doc, &impl2);
3462     EXPECT_HR(hr, S_OK);
3463     EXPECT_REF(doc, 1);
3464     EXPECT_REF(impl2, 1);
3465     ok(impl != impl2, "got %p, %p\n", impl, impl2);
3466     IXMLDOMImplementation_Release(impl);
3467     IXMLDOMImplementation_Release(impl2);
3468
3469     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3470     EXPECT_HR(hr, S_OK);
3471     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3472
3473     EXPECT_REF(doc, 1);
3474     IXMLDOMDocument_AddRef( doc );
3475     EXPECT_REF(doc, 2);
3476     IXMLDOMDocument_AddRef( doc );
3477     EXPECT_REF(doc, 3);
3478
3479     IXMLDOMDocument_Release( doc );
3480     IXMLDOMDocument_Release( doc );
3481
3482     EXPECT_REF(doc, 1);
3483     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
3484     EXPECT_HR(hr, S_OK);
3485 todo_wine {
3486     EXPECT_REF(unk, 3);
3487     EXPECT_REF(doc, 1);
3488 }
3489     hr = IXMLDOMDocument_get_documentElement(doc, &element);
3490     EXPECT_HR(hr, S_OK);
3491 todo_wine {
3492     EXPECT_REF(doc, 1);
3493     EXPECT_REF(element, 2);
3494 }
3495     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
3496     EXPECT_HR(hr, S_OK);
3497
3498 todo_wine {
3499     EXPECT_REF(doc, 1);
3500     EXPECT_REF(element, 2);
3501     EXPECT_REF(elem2, 2);
3502 }
3503     IXMLDOMElement_AddRef(element);
3504     todo_wine EXPECT_REF(element, 3);
3505     IXMLDOMElement_Release(element);
3506
3507     /* get IUnknown from a node doesn't touch node instance refcount */
3508     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
3509     EXPECT_HR(hr, S_OK);
3510     EXPECT_REF(element, 2);
3511 todo_wine {
3512     EXPECT_REF(unk, 4);
3513     EXPECT_REF(elem2, 2);
3514 }
3515     hr = IXMLDOMElement_QueryInterface(elem2, &IID_IUnknown, (void**)&unk2);
3516     EXPECT_HR(hr, S_OK);
3517 todo_wine {
3518     EXPECT_REF(unk, 5);
3519     EXPECT_REF(unk2, 5);
3520 }
3521     EXPECT_REF(element, 2);
3522     EXPECT_REF(elem2, 2);
3523
3524     todo_wine ok(unk == unk2, "got %p and %p\n", unk, unk2);
3525
3526     IUnknown_Release(unk);
3527     IUnknown_Release(unk2);
3528
3529     /* IUnknown refcount is not affected by node refcount */
3530     todo_wine EXPECT_REF(unk2, 3);
3531     IXMLDOMElement_AddRef(elem2);
3532     todo_wine EXPECT_REF(unk2, 3);
3533     IXMLDOMElement_Release(elem2);
3534
3535     IXMLDOMElement_Release(elem2);
3536     todo_wine EXPECT_REF(unk2, 2);
3537
3538     hr = IXMLDOMElement_get_childNodes( element, &node_list );
3539     EXPECT_HR(hr, S_OK);
3540
3541     todo_wine EXPECT_REF(element, 2);
3542     EXPECT_REF(node_list, 1);
3543
3544     hr = IXMLDOMNodeList_get_item( node_list, 0, &node );
3545     EXPECT_HR(hr, S_OK);
3546     EXPECT_REF(node_list, 1);
3547     EXPECT_REF(node, 1);
3548
3549     hr = IXMLDOMNodeList_get_item( node_list, 0, &node2 );
3550     EXPECT_HR(hr, S_OK);
3551     EXPECT_REF(node_list, 1);
3552     EXPECT_REF(node2, 1);
3553
3554     ref = IXMLDOMNode_Release( node );
3555     ok( ref == 0, "ref %d\n", ref );
3556     ref = IXMLDOMNode_Release( node2 );
3557     ok( ref == 0, "ref %d\n", ref );
3558
3559     ref = IXMLDOMNodeList_Release( node_list );
3560     ok( ref == 0, "ref %d\n", ref );
3561
3562     ok( node != node2, "node %p node2 %p\n", node, node2 );
3563
3564     ref = IXMLDOMDocument_Release( doc );
3565     todo_wine ok( ref == 0, "ref %d\n", ref );
3566
3567     todo_wine EXPECT_REF(element, 2);
3568
3569     /* IUnknown must be unique however we obtain it */
3570     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
3571     EXPECT_HR(hr, S_OK);
3572     EXPECT_REF(element, 2);
3573     hr = IXMLDOMElement_QueryInterface(element, &IID_IXMLDOMNode, (void**)&node);
3574     EXPECT_HR(hr, S_OK);
3575     todo_wine EXPECT_REF(element, 2);
3576     hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk2);
3577     EXPECT_HR(hr, S_OK);
3578     todo_wine EXPECT_REF(element, 2);
3579     ok(unk == unk2, "unk %p unk2 %p\n", unk, unk2);
3580     todo_wine ok(element != (void*)node, "node %p element %p\n", node, element);
3581
3582     IUnknown_Release( unk2 );
3583     IUnknown_Release( unk );
3584     IXMLDOMNode_Release( node );
3585     todo_wine EXPECT_REF(element, 2);
3586
3587     IXMLDOMElement_Release( element );
3588
3589     free_bstrs();
3590 }
3591
3592 static void test_create(void)
3593 {
3594     static const WCHAR szOne[] = {'1',0};
3595     static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
3596     HRESULT r;
3597     VARIANT var;
3598     BSTR str, name;
3599     IXMLDOMDocument *doc;
3600     IXMLDOMElement *element;
3601     IXMLDOMComment *comment;
3602     IXMLDOMText *text;
3603     IXMLDOMCDATASection *cdata;
3604     IXMLDOMNode *root, *node, *child;
3605     IXMLDOMNamedNodeMap *attr_map;
3606     IUnknown *unk;
3607     LONG ref;
3608     LONG num;
3609
3610     doc = create_document(&IID_IXMLDOMDocument);
3611     if (!doc) return;
3612
3613     EXPECT_REF(doc, 1);
3614
3615     /* types not supported for creation */
3616     V_VT(&var) = VT_I1;
3617     V_I1(&var) = NODE_DOCUMENT;
3618     node = (IXMLDOMNode*)0x1;
3619     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3620     ok( r == E_INVALIDARG, "returns %08x\n", r );
3621     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3622
3623     V_VT(&var) = VT_I1;
3624     V_I1(&var) = NODE_DOCUMENT_TYPE;
3625     node = (IXMLDOMNode*)0x1;
3626     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3627     ok( r == E_INVALIDARG, "returns %08x\n", r );
3628     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3629
3630     V_VT(&var) = VT_I1;
3631     V_I1(&var) = NODE_ENTITY;
3632     node = (IXMLDOMNode*)0x1;
3633     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3634     ok( r == E_INVALIDARG, "returns %08x\n", r );
3635     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3636
3637     V_VT(&var) = VT_I1;
3638     V_I1(&var) = NODE_NOTATION;
3639     node = (IXMLDOMNode*)0x1;
3640     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3641     ok( r == E_INVALIDARG, "returns %08x\n", r );
3642     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3643
3644     /* NODE_COMMENT */
3645     V_VT(&var) = VT_I1;
3646     V_I1(&var) = NODE_COMMENT;
3647     node = NULL;
3648     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3649     ok( r == S_OK, "returns %08x\n", r );
3650     ok( node != NULL, "\n");
3651
3652     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
3653     ok( r == S_OK, "returns %08x\n", r );
3654     IXMLDOMNode_Release(node);
3655
3656     str = NULL;
3657     r = IXMLDOMComment_get_data(comment, &str);
3658     ok( r == S_OK, "returns %08x\n", r );
3659     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3660     IXMLDOMComment_Release(comment);
3661     SysFreeString(str);
3662
3663     node = (IXMLDOMNode*)0x1;
3664     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3665     ok( r == S_OK, "returns %08x\n", r );
3666
3667     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
3668     ok( r == S_OK, "returns %08x\n", r );
3669     IXMLDOMNode_Release(node);
3670
3671     str = NULL;
3672     r = IXMLDOMComment_get_data(comment, &str);
3673     ok( r == S_OK, "returns %08x\n", r );
3674     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3675     IXMLDOMComment_Release(comment);
3676     SysFreeString(str);
3677
3678     node = (IXMLDOMNode*)0x1;
3679     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3680     ok( r == S_OK, "returns %08x\n", r );
3681
3682     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
3683     ok( r == S_OK, "returns %08x\n", r );
3684     IXMLDOMNode_Release(node);
3685
3686     str = NULL;
3687     r = IXMLDOMComment_get_data(comment, &str);
3688     ok( r == S_OK, "returns %08x\n", r );
3689     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3690     IXMLDOMComment_Release(comment);
3691     SysFreeString(str);
3692
3693     /* NODE_TEXT */
3694     V_VT(&var) = VT_I1;
3695     V_I1(&var) = NODE_TEXT;
3696     node = NULL;
3697     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3698     ok( r == S_OK, "returns %08x\n", r );
3699     ok( node != NULL, "\n");
3700
3701     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3702     ok( r == S_OK, "returns %08x\n", r );
3703     IXMLDOMNode_Release(node);
3704
3705     str = NULL;
3706     r = IXMLDOMText_get_data(text, &str);
3707     ok( r == S_OK, "returns %08x\n", r );
3708     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3709     IXMLDOMText_Release(text);
3710     SysFreeString(str);
3711
3712     node = (IXMLDOMNode*)0x1;
3713     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3714     ok( r == S_OK, "returns %08x\n", r );
3715
3716     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3717     ok( r == S_OK, "returns %08x\n", r );
3718     IXMLDOMNode_Release(node);
3719
3720     str = NULL;
3721     r = IXMLDOMText_get_data(text, &str);
3722     ok( r == S_OK, "returns %08x\n", r );
3723     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3724     IXMLDOMText_Release(text);
3725     SysFreeString(str);
3726
3727     node = (IXMLDOMNode*)0x1;
3728     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3729     ok( r == S_OK, "returns %08x\n", r );
3730
3731     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3732     ok( r == S_OK, "returns %08x\n", r );
3733     IXMLDOMNode_Release(node);
3734
3735     str = NULL;
3736     r = IXMLDOMText_get_data(text, &str);
3737     ok( r == S_OK, "returns %08x\n", r );
3738     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3739     IXMLDOMText_Release(text);
3740     SysFreeString(str);
3741
3742     /* NODE_CDATA_SECTION */
3743     V_VT(&var) = VT_I1;
3744     V_I1(&var) = NODE_CDATA_SECTION;
3745     node = NULL;
3746     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3747     ok( r == S_OK, "returns %08x\n", r );
3748     ok( node != NULL, "\n");
3749
3750     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3751     ok( r == S_OK, "returns %08x\n", r );
3752     IXMLDOMNode_Release(node);
3753
3754     str = NULL;
3755     r = IXMLDOMCDATASection_get_data(cdata, &str);
3756     ok( r == S_OK, "returns %08x\n", r );
3757     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3758     IXMLDOMCDATASection_Release(cdata);
3759     SysFreeString(str);
3760
3761     node = (IXMLDOMNode*)0x1;
3762     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3763     ok( r == S_OK, "returns %08x\n", r );
3764
3765     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3766     ok( r == S_OK, "returns %08x\n", r );
3767     IXMLDOMNode_Release(node);
3768
3769     str = NULL;
3770     r = IXMLDOMCDATASection_get_data(cdata, &str);
3771     ok( r == S_OK, "returns %08x\n", r );
3772     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3773     IXMLDOMCDATASection_Release(cdata);
3774     SysFreeString(str);
3775
3776     node = (IXMLDOMNode*)0x1;
3777     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3778     ok( r == S_OK, "returns %08x\n", r );
3779
3780     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3781     ok( r == S_OK, "returns %08x\n", r );
3782     IXMLDOMNode_Release(node);
3783
3784     str = NULL;
3785     r = IXMLDOMCDATASection_get_data(cdata, &str);
3786     ok( r == S_OK, "returns %08x\n", r );
3787     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3788     IXMLDOMCDATASection_Release(cdata);
3789     SysFreeString(str);
3790
3791     /* NODE_ATTRIBUTE */
3792     V_VT(&var) = VT_I1;
3793     V_I1(&var) = NODE_ATTRIBUTE;
3794     node = (IXMLDOMNode*)0x1;
3795     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3796     ok( r == E_FAIL, "returns %08x\n", r );
3797     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3798
3799     V_VT(&var) = VT_I1;
3800     V_I1(&var) = NODE_ATTRIBUTE;
3801     node = (IXMLDOMNode*)0x1;
3802     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3803     ok( r == E_FAIL, "returns %08x\n", r );
3804     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3805
3806     V_VT(&var) = VT_I1;
3807     V_I1(&var) = NODE_ATTRIBUTE;
3808     str = SysAllocString( szlc );
3809     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3810     ok( r == S_OK, "returns %08x\n", r );
3811     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3812     SysFreeString(str);
3813
3814     /* a name is required for attribute, try a BSTR with first null wchar */
3815     V_VT(&var) = VT_I1;
3816     V_I1(&var) = NODE_ATTRIBUTE;
3817     str = SysAllocString( szstr1 );
3818     str[0] = 0;
3819     node = (IXMLDOMNode*)0x1;
3820     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3821     ok( r == E_FAIL, "returns %08x\n", r );
3822     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3823     SysFreeString(str);
3824
3825     /* NODE_PROCESSING_INSTRUCTION */
3826     V_VT(&var) = VT_I1;
3827     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3828     node = (IXMLDOMNode*)0x1;
3829     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3830     ok( r == E_FAIL, "returns %08x\n", r );
3831     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3832
3833     V_VT(&var) = VT_I1;
3834     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3835     node = (IXMLDOMNode*)0x1;
3836     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3837     ok( r == E_FAIL, "returns %08x\n", r );
3838     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3839
3840     V_VT(&var) = VT_I1;
3841     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3842     r = IXMLDOMDocument_createNode( doc, var, _bstr_("pi"), NULL, NULL );
3843     ok( r == E_INVALIDARG, "returns %08x\n", r );
3844
3845     /* NODE_ENTITY_REFERENCE */
3846     V_VT(&var) = VT_I1;
3847     V_I1(&var) = NODE_ENTITY_REFERENCE;
3848     node = (IXMLDOMNode*)0x1;
3849     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3850     ok( r == E_FAIL, "returns %08x\n", r );
3851     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3852
3853     V_VT(&var) = VT_I1;
3854     V_I1(&var) = NODE_ENTITY_REFERENCE;
3855     node = (IXMLDOMNode*)0x1;
3856     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3857     ok( r == E_FAIL, "returns %08x\n", r );
3858     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3859
3860     /* NODE_ELEMENT */
3861     V_VT(&var) = VT_I1;
3862     V_I1(&var) = NODE_ELEMENT;
3863     node = (IXMLDOMNode*)0x1;
3864     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3865     ok( r == E_FAIL, "returns %08x\n", r );
3866     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3867
3868     V_VT(&var) = VT_I1;
3869     V_I1(&var) = NODE_ELEMENT;
3870     node = (IXMLDOMNode*)0x1;
3871     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3872     ok( r == E_FAIL, "returns %08x\n", r );
3873     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3874
3875     V_VT(&var) = VT_I1;
3876     V_I1(&var) = NODE_ELEMENT;
3877     str = SysAllocString( szlc );
3878     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3879     ok( r == S_OK, "returns %08x\n", r );
3880     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3881
3882     V_VT(&var) = VT_I1;
3883     V_I1(&var) = NODE_ELEMENT;
3884     r = IXMLDOMDocument_createNode( doc, var, str, NULL, NULL );
3885     ok( r == E_INVALIDARG, "returns %08x\n", r );
3886
3887     V_VT(&var) = VT_R4;
3888     V_R4(&var) = NODE_ELEMENT;
3889     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3890     ok( r == S_OK, "returns %08x\n", r );
3891     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3892
3893     V_VT(&var) = VT_BSTR;
3894     V_BSTR(&var) = SysAllocString( szOne );
3895     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3896     ok( r == S_OK, "returns %08x\n", r );
3897     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3898     VariantClear(&var);
3899
3900     V_VT(&var) = VT_BSTR;
3901     V_BSTR(&var) = SysAllocString( szOneGarbage );
3902     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3903     ok( r == E_INVALIDARG, "returns %08x\n", r );
3904     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3905     VariantClear(&var);
3906
3907     V_VT(&var) = VT_I4;
3908     V_I4(&var) = NODE_ELEMENT;
3909     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3910     ok( r == S_OK, "returns %08x\n", r );
3911
3912     EXPECT_REF(doc, 1);
3913     r = IXMLDOMDocument_appendChild( doc, node, &root );
3914     ok( r == S_OK, "returns %08x\n", r );
3915     ok( node == root, "%p %p\n", node, root );
3916     EXPECT_REF(doc, 1);
3917
3918     EXPECT_REF(node, 2);
3919
3920     ref = IXMLDOMNode_Release( node );
3921     ok(ref == 1, "ref %d\n", ref);
3922     SysFreeString( str );
3923
3924     V_VT(&var) = VT_I4;
3925     V_I4(&var) = NODE_ELEMENT;
3926     str = SysAllocString( szbs );
3927     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3928     ok( r == S_OK, "returns %08x\n", r );
3929     SysFreeString( str );
3930
3931     EXPECT_REF(node, 1);
3932
3933     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk );
3934     ok( r == S_OK, "returns %08x\n", r );
3935
3936     EXPECT_REF(unk, 2);
3937
3938     V_VT(&var) = VT_EMPTY;
3939     child = NULL;
3940     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
3941     ok( r == S_OK, "returns %08x\n", r );
3942     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
3943
3944     todo_wine EXPECT_REF(unk, 4);
3945
3946     IXMLDOMNode_Release( child );
3947     IUnknown_Release( unk );
3948
3949     V_VT(&var) = VT_NULL;
3950     V_DISPATCH(&var) = (IDispatch*)node;
3951     r = IXMLDOMNode_insertBefore( root, node, var, &child );
3952     ok( r == S_OK, "returns %08x\n", r );
3953     ok( node == child, "%p %p\n", node, child );
3954     IXMLDOMNode_Release( child );
3955
3956     V_VT(&var) = VT_NULL;
3957     V_DISPATCH(&var) = (IDispatch*)node;
3958     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
3959     ok( r == S_OK, "returns %08x\n", r );
3960     IXMLDOMNode_Release( node );
3961
3962     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (void**)&element );
3963     ok( r == S_OK, "returns %08x\n", r );
3964
3965     r = IXMLDOMElement_get_attributes( element, &attr_map );
3966     ok( r == S_OK, "returns %08x\n", r );
3967     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3968     ok( r == S_OK, "returns %08x\n", r );
3969     ok( num == 0, "num %d\n", num );
3970     IXMLDOMNamedNodeMap_Release( attr_map );
3971
3972     V_VT(&var) = VT_BSTR;
3973     V_BSTR(&var) = SysAllocString( szstr1 );
3974     name = SysAllocString( szdl );
3975     r = IXMLDOMElement_setAttribute( element, name, var );
3976     ok( r == S_OK, "returns %08x\n", r );
3977     r = IXMLDOMElement_get_attributes( element, &attr_map );
3978     ok( r == S_OK, "returns %08x\n", r );
3979     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3980     ok( r == S_OK, "returns %08x\n", r );
3981     ok( num == 1, "num %d\n", num );
3982     IXMLDOMNamedNodeMap_Release( attr_map );
3983     VariantClear(&var);
3984
3985     V_VT(&var) = VT_BSTR;
3986     V_BSTR(&var) = SysAllocString( szstr2 );
3987     r = IXMLDOMElement_setAttribute( element, name, var );
3988     ok( r == S_OK, "returns %08x\n", r );
3989     r = IXMLDOMElement_get_attributes( element, &attr_map );
3990     ok( r == S_OK, "returns %08x\n", r );
3991     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3992     ok( r == S_OK, "returns %08x\n", r );
3993     ok( num == 1, "num %d\n", num );
3994     IXMLDOMNamedNodeMap_Release( attr_map );
3995     VariantClear(&var);
3996     r = IXMLDOMElement_getAttribute( element, name, &var );
3997     ok( r == S_OK, "returns %08x\n", r );
3998     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
3999     VariantClear(&var);
4000     SysFreeString(name);
4001
4002     V_VT(&var) = VT_BSTR;
4003     V_BSTR(&var) = SysAllocString( szstr1 );
4004     name = SysAllocString( szlc );
4005     r = IXMLDOMElement_setAttribute( element, name, var );
4006     ok( r == S_OK, "returns %08x\n", r );
4007     r = IXMLDOMElement_get_attributes( element, &attr_map );
4008     ok( r == S_OK, "returns %08x\n", r );
4009     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
4010     ok( r == S_OK, "returns %08x\n", r );
4011     ok( num == 2, "num %d\n", num );
4012     IXMLDOMNamedNodeMap_Release( attr_map );
4013     VariantClear(&var);
4014     SysFreeString(name);
4015
4016     V_VT(&var) = VT_I4;
4017     V_I4(&var) = 10;
4018     name = SysAllocString( szbs );
4019     r = IXMLDOMElement_setAttribute( element, name, var );
4020     ok( r == S_OK, "returns %08x\n", r );
4021     VariantClear(&var);
4022     r = IXMLDOMElement_getAttribute( element, name, &var );
4023     ok( r == S_OK, "returns %08x\n", r );
4024     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
4025     VariantClear(&var);
4026     SysFreeString(name);
4027
4028     /* Create an Attribute */
4029     V_VT(&var) = VT_I4;
4030     V_I4(&var) = NODE_ATTRIBUTE;
4031     str = SysAllocString( szAttribute );
4032     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
4033     ok( r == S_OK, "returns %08x\n", r );
4034     ok( node != NULL, "node was null\n");
4035     SysFreeString(str);
4036
4037     IXMLDOMElement_Release( element );
4038     IXMLDOMNode_Release( root );
4039     IXMLDOMDocument_Release( doc );
4040 }
4041
4042 static void test_getElementsByTagName(void)
4043 {
4044     IXMLDOMNodeList *node_list;
4045     IXMLDOMDocument *doc;
4046     IXMLDOMElement *elem;
4047     WCHAR buff[100];
4048     VARIANT_BOOL b;
4049     HRESULT r;
4050     LONG len;
4051     BSTR str;
4052
4053     doc = create_document(&IID_IXMLDOMDocument);
4054     if (!doc) return;
4055
4056     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4057     ok( r == S_OK, "loadXML failed\n");
4058     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4059
4060     str = SysAllocString( szstar );
4061
4062     /* null arguments cases */
4063     r = IXMLDOMDocument_getElementsByTagName(doc, NULL, &node_list);
4064     ok( r == E_INVALIDARG, "ret %08x\n", r );
4065     r = IXMLDOMDocument_getElementsByTagName(doc, str, NULL);
4066     ok( r == E_INVALIDARG, "ret %08x\n", r );
4067
4068     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
4069     ok( r == S_OK, "ret %08x\n", r );
4070     r = IXMLDOMNodeList_get_length( node_list, &len );
4071     ok( r == S_OK, "ret %08x\n", r );
4072     ok( len == 6, "len %d\n", len );
4073
4074     IXMLDOMNodeList_Release( node_list );
4075     SysFreeString( str );
4076
4077     /* broken query BSTR */
4078     memcpy(&buff[2], szstar, sizeof(szstar));
4079     /* just a big length */
4080     *(DWORD*)buff = 0xf0f0;
4081     r = IXMLDOMDocument_getElementsByTagName(doc, &buff[2], &node_list);
4082     ok( r == S_OK, "ret %08x\n", r );
4083     r = IXMLDOMNodeList_get_length( node_list, &len );
4084     ok( r == S_OK, "ret %08x\n", r );
4085     ok( len == 6, "len %d\n", len );
4086     IXMLDOMNodeList_Release( node_list );
4087
4088     str = SysAllocString( szbs );
4089     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
4090     ok( r == S_OK, "ret %08x\n", r );
4091     r = IXMLDOMNodeList_get_length( node_list, &len );
4092     ok( r == S_OK, "ret %08x\n", r );
4093     ok( len == 1, "len %d\n", len );
4094     IXMLDOMNodeList_Release( node_list );
4095     SysFreeString( str );
4096
4097     str = SysAllocString( szdl );
4098     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
4099     ok( r == S_OK, "ret %08x\n", r );
4100     r = IXMLDOMNodeList_get_length( node_list, &len );
4101     ok( r == S_OK, "ret %08x\n", r );
4102     ok( len == 0, "len %d\n", len );
4103     IXMLDOMNodeList_Release( node_list );
4104     SysFreeString( str );
4105
4106     str = SysAllocString( szstr1 );
4107     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
4108     ok( r == S_OK, "ret %08x\n", r );
4109     r = IXMLDOMNodeList_get_length( node_list, &len );
4110     ok( r == S_OK, "ret %08x\n", r );
4111     ok( len == 0, "len %d\n", len );
4112     IXMLDOMNodeList_Release( node_list );
4113     SysFreeString( str );
4114
4115     /* test for element */
4116     r = IXMLDOMDocument_get_documentElement(doc, &elem);
4117     ok( r == S_OK, "ret %08x\n", r );
4118
4119     str = SysAllocString( szstar );
4120
4121     /* null arguments cases */
4122     r = IXMLDOMElement_getElementsByTagName(elem, NULL, &node_list);
4123     ok( r == E_INVALIDARG, "ret %08x\n", r );
4124     r = IXMLDOMElement_getElementsByTagName(elem, str, NULL);
4125     ok( r == E_INVALIDARG, "ret %08x\n", r );
4126
4127     r = IXMLDOMElement_getElementsByTagName(elem, str, &node_list);
4128     ok( r == S_OK, "ret %08x\n", r );
4129     r = IXMLDOMNodeList_get_length( node_list, &len );
4130     ok( r == S_OK, "ret %08x\n", r );
4131     ok( len == 5, "len %d\n", len );
4132     expect_list_and_release(node_list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1");
4133     SysFreeString( str );
4134
4135     /* broken query BSTR */
4136     memcpy(&buff[2], szstar, sizeof(szstar));
4137     /* just a big length */
4138     *(DWORD*)buff = 0xf0f0;
4139     r = IXMLDOMElement_getElementsByTagName(elem, &buff[2], &node_list);
4140     ok( r == S_OK, "ret %08x\n", r );
4141     r = IXMLDOMNodeList_get_length( node_list, &len );
4142     ok( r == S_OK, "ret %08x\n", r );
4143     ok( len == 5, "len %d\n", len );
4144     IXMLDOMNodeList_Release( node_list );
4145
4146     IXMLDOMElement_Release(elem);
4147
4148     IXMLDOMDocument_Release( doc );
4149
4150     free_bstrs();
4151 }
4152
4153 static void test_get_text(void)
4154 {
4155     HRESULT r;
4156     BSTR str;
4157     VARIANT_BOOL b;
4158     IXMLDOMDocument *doc;
4159     IXMLDOMNode *node, *node2, *node3;
4160     IXMLDOMNode *nodeRoot;
4161     IXMLDOMNodeList *node_list;
4162     IXMLDOMNamedNodeMap *node_map;
4163     LONG len;
4164
4165     doc = create_document(&IID_IXMLDOMDocument);
4166     if (!doc) return;
4167
4168     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4169     ok( r == S_OK, "loadXML failed\n");
4170     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4171
4172     str = SysAllocString( szbs );
4173     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
4174     ok( r == S_OK, "ret %08x\n", r );
4175     SysFreeString(str);
4176
4177     /* Test to get all child node text. */
4178     r = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&nodeRoot);
4179     ok( r == S_OK, "ret %08x\n", r );
4180     if(r == S_OK)
4181     {
4182         r = IXMLDOMNode_get_text( nodeRoot, &str );
4183         ok( r == S_OK, "ret %08x\n", r );
4184         ok( compareIgnoreReturns(str, _bstr_("fn1.txt\n\n fn2.txt \n\nf1\n")), "wrong get_text: %s\n", wine_dbgstr_w(str));
4185         SysFreeString(str);
4186
4187         IXMLDOMNode_Release(nodeRoot);
4188     }
4189
4190     r = IXMLDOMNodeList_get_length( node_list, NULL );
4191     ok( r == E_INVALIDARG, "ret %08x\n", r );
4192
4193     r = IXMLDOMNodeList_get_length( node_list, &len );
4194     ok( r == S_OK, "ret %08x\n", r );
4195     ok( len == 1, "expect 1 got %d\n", len );
4196
4197     r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
4198     ok( r == E_INVALIDARG, "ret %08x\n", r );
4199
4200     r = IXMLDOMNodeList_nextNode( node_list, NULL );
4201     ok( r == E_INVALIDARG, "ret %08x\n", r );
4202
4203     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
4204     ok( r == S_OK, "ret %08x\n", r );
4205     IXMLDOMNodeList_Release( node_list );
4206
4207     /* Invalid output parameter*/
4208     r = IXMLDOMNode_get_text( node, NULL );
4209     ok( r == E_INVALIDARG, "ret %08x\n", r );
4210
4211     r = IXMLDOMNode_get_text( node, &str );
4212     ok( r == S_OK, "ret %08x\n", r );
4213     ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
4214     SysFreeString(str);
4215
4216     r = IXMLDOMNode_get_attributes( node, &node_map );
4217     ok( r == S_OK, "ret %08x\n", r );
4218
4219     str = SysAllocString( szvr );
4220     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
4221     ok( r == S_OK, "ret %08x\n", r );
4222     SysFreeString(str);
4223
4224     r = IXMLDOMNode_get_text( node2, &str );
4225     ok( r == S_OK, "ret %08x\n", r );
4226     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
4227     SysFreeString(str);
4228
4229     r = IXMLDOMNode_get_firstChild( node2, &node3 );
4230     ok( r == S_OK, "ret %08x\n", r );
4231
4232     r = IXMLDOMNode_get_text( node3, &str );
4233     ok( r == S_OK, "ret %08x\n", r );
4234     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
4235     SysFreeString(str);
4236
4237
4238     IXMLDOMNode_Release( node3 );
4239     IXMLDOMNode_Release( node2 );
4240     IXMLDOMNamedNodeMap_Release( node_map );
4241     IXMLDOMNode_Release( node );
4242     IXMLDOMDocument_Release( doc );
4243
4244     free_bstrs();
4245 }
4246
4247 static void test_get_childNodes(void)
4248 {
4249     IXMLDOMNodeList *node_list, *node_list2;
4250     IEnumVARIANT *enum1, *enum2, *enum3;
4251     VARIANT_BOOL b;
4252     IXMLDOMDocument *doc;
4253     IXMLDOMNode *node, *node2;
4254     IXMLDOMElement *element;
4255     IUnknown *unk1, *unk2;
4256     HRESULT hr;
4257     VARIANT v;
4258     BSTR str;
4259     LONG len;
4260
4261     doc = create_document(&IID_IXMLDOMDocument);
4262     if (!doc) return;
4263
4264     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4265     EXPECT_HR(hr, S_OK);
4266     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4267
4268     hr = IXMLDOMDocument_get_documentElement( doc, &element );
4269     EXPECT_HR(hr, S_OK);
4270
4271     hr = IXMLDOMElement_get_childNodes( element, &node_list );
4272     EXPECT_HR(hr, S_OK);
4273
4274     hr = IXMLDOMNodeList_get_length( node_list, &len );
4275     EXPECT_HR(hr, S_OK);
4276     ok( len == 4, "len %d\n", len);
4277
4278     /* refcount tests for IEnumVARIANT support */
4279     EXPECT_REF(node_list, 1);
4280     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum1);
4281     EXPECT_HR(hr, S_OK);
4282     EXPECT_REF(node_list, 1);
4283     EXPECT_REF(enum1, 2);
4284
4285     EXPECT_REF(node_list, 1);
4286     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum2);
4287     EXPECT_HR(hr, S_OK);
4288     EXPECT_REF(node_list, 1);
4289     ok(enum2 == enum1, "got %p, %p\n", enum2, enum1);
4290     IEnumVARIANT_Release(enum2);
4291
4292     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
4293     EXPECT_HR(hr, S_OK);
4294     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
4295     EXPECT_HR(hr, S_OK);
4296     EXPECT_REF(node_list, 3);
4297     EXPECT_REF(enum1, 2);
4298     ok(unk1 == unk2, "got %p, %p\n", unk1, unk2);
4299     IUnknown_Release(unk1);
4300     IUnknown_Release(unk2);
4301
4302     EXPECT_REF(node_list, 1);
4303     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum2);
4304     EXPECT_HR(hr, S_OK);
4305     EXPECT_REF(node_list, 2);
4306     EXPECT_REF(enum2, 1);
4307     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
4308
4309     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
4310     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
4311     EXPECT_HR(hr, S_OK);
4312     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
4313     EXPECT_HR(hr, S_OK);
4314     EXPECT_REF(node_list, 3);
4315     EXPECT_REF(enum2, 2);
4316     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
4317     IUnknown_Release(unk1);
4318     IUnknown_Release(unk2);
4319
4320     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum3);
4321     EXPECT_HR(hr, S_OK);
4322     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
4323     IEnumVARIANT_Release(enum3);
4324     IEnumVARIANT_Release(enum2);
4325
4326     /* iteration tests */
4327     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
4328     EXPECT_HR(hr, S_OK);
4329     hr = IXMLDOMNode_get_nodeName(node, &str);
4330     EXPECT_HR(hr, S_OK);
4331     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
4332     SysFreeString(str);
4333     IXMLDOMNode_Release(node);
4334
4335     hr = IXMLDOMNodeList_nextNode(node_list, &node);
4336     EXPECT_HR(hr, S_OK);
4337     hr = IXMLDOMNode_get_nodeName(node, &str);
4338     EXPECT_HR(hr, S_OK);
4339     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
4340     SysFreeString(str);
4341     IXMLDOMNode_Release(node);
4342
4343     V_VT(&v) = VT_EMPTY;
4344     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
4345     EXPECT_HR(hr, S_OK);
4346     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
4347     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
4348     EXPECT_HR(hr, S_OK);
4349     hr = IXMLDOMNode_get_nodeName(node, &str);
4350     EXPECT_HR(hr, S_OK);
4351     ok(!lstrcmpW(str, _bstr_("bs")), "got node name %s\n", wine_dbgstr_w(str));
4352     SysFreeString(str);
4353     IXMLDOMNode_Release(node);
4354     VariantClear(&v);
4355
4356     hr = IXMLDOMNodeList_nextNode(node_list, &node);
4357     EXPECT_HR(hr, S_OK);
4358     hr = IXMLDOMNode_get_nodeName(node, &str);
4359     EXPECT_HR(hr, S_OK);
4360     ok(!lstrcmpW(str, _bstr_("pr")), "got %s\n", wine_dbgstr_w(str));
4361     SysFreeString(str);
4362     IXMLDOMNode_Release(node);
4363
4364     IEnumVARIANT_Release(enum1);
4365
4366     hr = IXMLDOMNodeList_get_item( node_list, 2, &node );
4367     EXPECT_HR(hr, S_OK);
4368
4369     hr = IXMLDOMNode_get_childNodes( node, &node_list2 );
4370     EXPECT_HR(hr, S_OK);
4371
4372     hr = IXMLDOMNodeList_get_length( node_list2, &len );
4373     EXPECT_HR(hr, S_OK);
4374     ok( len == 0, "len %d\n", len);
4375
4376     hr = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
4377     EXPECT_HR(hr, S_FALSE);
4378
4379     IXMLDOMNodeList_Release( node_list2 );
4380     IXMLDOMNode_Release( node );
4381     IXMLDOMNodeList_Release( node_list );
4382     IXMLDOMElement_Release( element );
4383
4384     /* test for children of <?xml ..?> node */
4385     hr = IXMLDOMDocument_get_firstChild(doc, &node);
4386     EXPECT_HR(hr, S_OK);
4387
4388     str = NULL;
4389     hr = IXMLDOMNode_get_nodeName(node, &str);
4390     EXPECT_HR(hr, S_OK);
4391     ok(!lstrcmpW(str, _bstr_("xml")), "got %s\n", wine_dbgstr_w(str));
4392     SysFreeString(str);
4393
4394     /* it returns empty but valid node list */
4395     node_list = (void*)0xdeadbeef;
4396     hr = IXMLDOMNode_get_childNodes(node, &node_list);
4397     EXPECT_HR(hr, S_OK);
4398
4399     len = -1;
4400     hr = IXMLDOMNodeList_get_length(node_list, &len);
4401     EXPECT_HR(hr, S_OK);
4402     ok(len == 0, "got %d\n", len);
4403
4404     IXMLDOMNodeList_Release( node_list );
4405     IXMLDOMNode_Release(node);
4406
4407     IXMLDOMDocument_Release( doc );
4408     free_bstrs();
4409 }
4410
4411 static void test_get_firstChild(void)
4412 {
4413     static WCHAR xmlW[] = {'x','m','l',0};
4414     IXMLDOMDocument *doc;
4415     IXMLDOMNode *node;
4416     VARIANT_BOOL b;
4417     HRESULT r;
4418     BSTR str;
4419
4420     doc = create_document(&IID_IXMLDOMDocument);
4421     if (!doc) return;
4422
4423     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4424     ok( r == S_OK, "loadXML failed\n");
4425     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4426
4427     r = IXMLDOMDocument_get_firstChild( doc, &node );
4428     ok( r == S_OK, "ret %08x\n", r);
4429
4430     r = IXMLDOMNode_get_nodeName( node, &str );
4431     ok( r == S_OK, "ret %08x\n", r);
4432
4433     ok(!lstrcmpW(str, xmlW), "expected \"xml\" node name, got %s\n", wine_dbgstr_w(str));
4434
4435     SysFreeString(str);
4436     IXMLDOMNode_Release( node );
4437     IXMLDOMDocument_Release( doc );
4438
4439     free_bstrs();
4440 }
4441
4442 static void test_get_lastChild(void)
4443 {
4444     static WCHAR lcW[] = {'l','c',0};
4445     static WCHAR foW[] = {'f','o',0};
4446     IXMLDOMDocument *doc;
4447     IXMLDOMNode *node, *child;
4448     VARIANT_BOOL b;
4449     HRESULT r;
4450     BSTR str;
4451
4452     doc = create_document(&IID_IXMLDOMDocument);
4453     if (!doc) return;
4454
4455     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4456     ok( r == S_OK, "loadXML failed\n");
4457     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4458
4459     r = IXMLDOMDocument_get_lastChild( doc, &node );
4460     ok( r == S_OK, "ret %08x\n", r);
4461
4462     r = IXMLDOMNode_get_nodeName( node, &str );
4463     ok( r == S_OK, "ret %08x\n", r);
4464
4465     ok(memcmp(str, lcW, sizeof(lcW)) == 0, "expected \"lc\" node name\n");
4466     SysFreeString(str);
4467
4468     r = IXMLDOMNode_get_lastChild( node, &child );
4469     ok( r == S_OK, "ret %08x\n", r);
4470
4471     r = IXMLDOMNode_get_nodeName( child, &str );
4472     ok( r == S_OK, "ret %08x\n", r);
4473
4474     ok(memcmp(str, foW, sizeof(foW)) == 0, "expected \"fo\" node name\n");
4475     SysFreeString(str);
4476
4477     IXMLDOMNode_Release( child );
4478     IXMLDOMNode_Release( node );
4479     IXMLDOMDocument_Release( doc );
4480
4481     free_bstrs();
4482 }
4483
4484 static void test_removeChild(void)
4485 {
4486     HRESULT r;
4487     VARIANT_BOOL b;
4488     IXMLDOMDocument *doc;
4489     IXMLDOMElement *element, *lc_element;
4490     IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
4491     IXMLDOMNodeList *root_list, *fo_list;
4492
4493     doc = create_document(&IID_IXMLDOMDocument);
4494     if (!doc) return;
4495
4496     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4497     ok( r == S_OK, "loadXML failed\n");
4498     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4499
4500     r = IXMLDOMDocument_get_documentElement( doc, &element );
4501     ok( r == S_OK, "ret %08x\n", r);
4502     todo_wine EXPECT_REF(element, 2);
4503
4504     r = IXMLDOMElement_get_childNodes( element, &root_list );
4505     ok( r == S_OK, "ret %08x\n", r);
4506     EXPECT_REF(root_list, 1);
4507
4508     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
4509     ok( r == S_OK, "ret %08x\n", r);
4510     EXPECT_REF(fo_node, 1);
4511
4512     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
4513     ok( r == S_OK, "ret %08x\n", r);
4514     EXPECT_REF(fo_list, 1);
4515
4516     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
4517     ok( r == S_OK, "ret %08x\n", r);
4518     EXPECT_REF(ba_node, 1);
4519
4520     /* invalid parameter: NULL ptr */
4521     removed_node = (void*)0xdeadbeef;
4522     r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
4523     ok( r == E_INVALIDARG, "ret %08x\n", r );
4524     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
4525
4526     /* ba_node is a descendant of element, but not a direct child. */
4527     removed_node = (void*)0xdeadbeef;
4528     EXPECT_REF(ba_node, 1);
4529     EXPECT_CHILDREN(fo_node);
4530     r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
4531     ok( r == E_INVALIDARG, "ret %08x\n", r );
4532     ok( removed_node == NULL, "%p\n", removed_node );
4533     EXPECT_REF(ba_node, 1);
4534     EXPECT_CHILDREN(fo_node);
4535
4536     EXPECT_REF(ba_node, 1);
4537     EXPECT_REF(fo_node, 1);
4538     r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
4539     ok( r == S_OK, "ret %08x\n", r);
4540     ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
4541     EXPECT_REF(fo_node, 2);
4542     EXPECT_REF(ba_node, 1);
4543
4544     /* try removing already removed child */
4545     temp_node = (void*)0xdeadbeef;
4546     r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
4547     ok( r == E_INVALIDARG, "ret %08x\n", r);
4548     ok( temp_node == NULL, "%p\n", temp_node );
4549     IXMLDOMNode_Release( fo_node );
4550
4551     /* the removed node has no parent anymore */
4552     r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
4553     ok( r == S_FALSE, "ret %08x\n", r);
4554     ok( temp_node == NULL, "%p\n", temp_node );
4555
4556     IXMLDOMNode_Release( removed_node );
4557     IXMLDOMNode_Release( ba_node );
4558     IXMLDOMNodeList_Release( fo_list );
4559
4560     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
4561     ok( r == S_OK, "ret %08x\n", r);
4562
4563     r = IXMLDOMElement_QueryInterface( lc_node, &IID_IXMLDOMElement, (void**)&lc_element );
4564     ok( r == S_OK, "ret %08x\n", r);
4565
4566     /* MS quirk: passing wrong interface pointer works, too */
4567     r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
4568     ok( r == S_OK, "ret %08x\n", r);
4569     IXMLDOMElement_Release( lc_element );
4570
4571     temp_node = (void*)0xdeadbeef;
4572     r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
4573     ok( r == S_FALSE, "ret %08x\n", r);
4574     ok( temp_node == NULL, "%p\n", temp_node );
4575
4576     IXMLDOMNode_Release( lc_node );
4577     IXMLDOMNodeList_Release( root_list );
4578     IXMLDOMElement_Release( element );
4579     IXMLDOMDocument_Release( doc );
4580
4581     free_bstrs();
4582 }
4583
4584 static void test_replaceChild(void)
4585 {
4586     HRESULT r;
4587     VARIANT_BOOL b;
4588     IXMLDOMDocument *doc;
4589     IXMLDOMElement *element, *ba_element;
4590     IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
4591     IXMLDOMNodeList *root_list, *fo_list;
4592     IUnknown * unk1, *unk2;
4593     LONG len;
4594
4595     doc = create_document(&IID_IXMLDOMDocument);
4596     if (!doc) return;
4597
4598     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4599     ok( r == S_OK, "loadXML failed\n");
4600     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4601
4602     r = IXMLDOMDocument_get_documentElement( doc, &element );
4603     ok( r == S_OK, "ret %08x\n", r);
4604
4605     r = IXMLDOMElement_get_childNodes( element, &root_list );
4606     ok( r == S_OK, "ret %08x\n", r);
4607
4608     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
4609     ok( r == S_OK, "ret %08x\n", r);
4610
4611     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
4612     ok( r == S_OK, "ret %08x\n", r);
4613
4614     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
4615     ok( r == S_OK, "ret %08x\n", r);
4616
4617     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
4618     ok( r == S_OK, "ret %08x\n", r);
4619
4620     IXMLDOMNodeList_Release( fo_list );
4621
4622     /* invalid parameter: NULL ptr for element to remove */
4623     removed_node = (void*)0xdeadbeef;
4624     r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
4625     ok( r == E_INVALIDARG, "ret %08x\n", r );
4626     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
4627
4628     /* invalid parameter: NULL for replacement element. (Sic!) */
4629     removed_node = (void*)0xdeadbeef;
4630     r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
4631     ok( r == E_INVALIDARG, "ret %08x\n", r );
4632     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
4633
4634     /* invalid parameter: OldNode is not a child */
4635     removed_node = (void*)0xdeadbeef;
4636     r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
4637     ok( r == E_INVALIDARG, "ret %08x\n", r );
4638     ok( removed_node == NULL, "%p\n", removed_node );
4639     IXMLDOMNode_Release( lc_node );
4640
4641     /* invalid parameter: would create loop */
4642     removed_node = (void*)0xdeadbeef;
4643     r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
4644     ok( r == E_FAIL, "ret %08x\n", r );
4645     ok( removed_node == NULL, "%p\n", removed_node );
4646
4647     r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
4648     ok( r == S_OK, "ret %08x\n", r );
4649
4650     r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
4651     ok( r == S_OK, "ret %08x\n", r );
4652
4653     /* ba_node and temp_node refer to the same node, yet they
4654        are different interface pointers */
4655     ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
4656     r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
4657     ok( r == S_OK, "ret %08x\n", r );
4658     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
4659     ok( r == S_OK, "ret %08x\n", r );
4660     todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
4661
4662     IUnknown_Release( unk1 );
4663     IUnknown_Release( unk2 );
4664
4665     /* ba_node should have been removed from below fo_node */
4666     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
4667     ok( r == S_OK, "ret %08x\n", r );
4668
4669     /* MS quirk: replaceChild also accepts elements instead of nodes */
4670     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
4671     ok( r == S_OK, "ret %08x\n", r );
4672     EXPECT_REF(ba_element, 2);
4673
4674     removed_node = NULL;
4675     r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
4676     ok( r == S_OK, "ret %08x\n", r );
4677     ok( removed_node != NULL, "got %p\n", removed_node);
4678     EXPECT_REF(ba_element, 3);
4679     IXMLDOMElement_Release( ba_element );
4680
4681     r = IXMLDOMNodeList_get_length( fo_list, &len);
4682     ok( r == S_OK, "ret %08x\n", r );
4683     ok( len == 0, "len %d\n", len);
4684
4685     IXMLDOMNodeList_Release( fo_list );
4686
4687     IXMLDOMNode_Release(ba_node);
4688     IXMLDOMNode_Release(fo_node);
4689     IXMLDOMNode_Release(temp_node);
4690     IXMLDOMNodeList_Release( root_list );
4691     IXMLDOMElement_Release( element );
4692     IXMLDOMDocument_Release( doc );
4693
4694     free_bstrs();
4695 }
4696
4697 static void test_removeNamedItem(void)
4698 {
4699     IXMLDOMDocument *doc;
4700     IXMLDOMElement *element;
4701     IXMLDOMNode *pr_node, *removed_node, *removed_node2;
4702     IXMLDOMNodeList *root_list;
4703     IXMLDOMNamedNodeMap * pr_attrs;
4704     VARIANT_BOOL b;
4705     BSTR str;
4706     LONG len;
4707     HRESULT r;
4708
4709     doc = create_document(&IID_IXMLDOMDocument);
4710     if (!doc) return;
4711
4712     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4713     ok( r == S_OK, "loadXML failed\n");
4714     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4715
4716     r = IXMLDOMDocument_get_documentElement( doc, &element );
4717     ok( r == S_OK, "ret %08x\n", r);
4718
4719     r = IXMLDOMElement_get_childNodes( element, &root_list );
4720     ok( r == S_OK, "ret %08x\n", r);
4721
4722     r = IXMLDOMNodeList_get_item( root_list, 1, &pr_node );
4723     ok( r == S_OK, "ret %08x\n", r);
4724
4725     r = IXMLDOMNode_get_attributes( pr_node, &pr_attrs );
4726     ok( r == S_OK, "ret %08x\n", r);
4727
4728     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4729     ok( r == S_OK, "ret %08x\n", r);
4730     ok( len == 3, "length %d\n", len);
4731
4732     removed_node = (void*)0xdeadbeef;
4733     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, NULL, &removed_node);
4734     ok ( r == E_INVALIDARG, "ret %08x\n", r);
4735     ok ( removed_node == (void*)0xdeadbeef, "got %p\n", removed_node);
4736
4737     removed_node = (void*)0xdeadbeef;
4738     str = SysAllocString(szvr);
4739     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node);
4740     ok ( r == S_OK, "ret %08x\n", r);
4741
4742     removed_node2 = (void*)0xdeadbeef;
4743     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node2);
4744     ok ( r == S_FALSE, "ret %08x\n", r);
4745     ok ( removed_node2 == NULL, "got %p\n", removed_node2 );
4746
4747     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4748     ok( r == S_OK, "ret %08x\n", r);
4749     ok( len == 2, "length %d\n", len);
4750
4751     r = IXMLDOMNamedNodeMap_setNamedItem( pr_attrs, removed_node, NULL);
4752     ok ( r == S_OK, "ret %08x\n", r);
4753     IXMLDOMNode_Release(removed_node);
4754
4755     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4756     ok( r == S_OK, "ret %08x\n", r);
4757     ok( len == 3, "length %d\n", len);
4758
4759     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
4760     ok ( r == S_OK, "ret %08x\n", r);
4761
4762     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4763     ok( r == S_OK, "ret %08x\n", r);
4764     ok( len == 2, "length %d\n", len);
4765
4766     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
4767     ok ( r == S_FALSE, "ret %08x\n", r);
4768
4769     SysFreeString(str);
4770
4771     IXMLDOMNamedNodeMap_Release( pr_attrs );
4772     IXMLDOMNode_Release( pr_node );
4773     IXMLDOMNodeList_Release( root_list );
4774     IXMLDOMElement_Release( element );
4775     IXMLDOMDocument_Release( doc );
4776
4777     free_bstrs();
4778 }
4779
4780 #define test_IObjectSafety_set(p, r, r2, s, m, e, e2) _test_IObjectSafety_set(__LINE__,p, r, r2, s, m, e, e2)
4781 static void _test_IObjectSafety_set(unsigned line, IObjectSafety *safety, HRESULT result,
4782                                     HRESULT result2, DWORD set, DWORD mask, DWORD expected,
4783                                     DWORD expected2)
4784 {
4785     DWORD enabled, supported;
4786     HRESULT hr;
4787
4788     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL, set, mask);
4789     if (result == result2)
4790         ok_(__FILE__,line)(hr == result, "SetInterfaceSafetyOptions: expected %08x, returned %08x\n", result, hr );
4791     else
4792         ok_(__FILE__,line)(broken(hr == result) || hr == result2,
4793            "SetInterfaceSafetyOptions: expected %08x, got %08x\n", result2, hr );
4794
4795     supported = enabled = 0xCAFECAFE;
4796     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4797     ok(hr == S_OK, "ret %08x\n", hr );
4798     if (expected == expected2)
4799         ok_(__FILE__,line)(enabled == expected, "Expected %08x, got %08x\n", expected, enabled);
4800     else
4801         ok_(__FILE__,line)(broken(enabled == expected) || enabled == expected2,
4802            "Expected %08x, got %08x\n", expected2, enabled);
4803
4804     /* reset the safety options */
4805
4806     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4807             INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER,
4808             0);
4809     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4810
4811     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4812     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4813     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
4814 }
4815
4816 #define test_IObjectSafety_common(s) _test_IObjectSafety_common(__LINE__,s)
4817 static void _test_IObjectSafety_common(unsigned line, IObjectSafety *safety)
4818 {
4819     DWORD enabled = 0, supported = 0;
4820     HRESULT hr;
4821
4822     /* get */
4823     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, NULL, &enabled);
4824     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
4825     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, NULL);
4826     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
4827
4828     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4829     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4830     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4831        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4832         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4833              "got %08x\n", supported);
4834     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
4835
4836     /* set -- individual flags */
4837
4838     test_IObjectSafety_set(safety, S_OK, S_OK,
4839         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4840         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4841
4842     test_IObjectSafety_set(safety, S_OK, S_OK,
4843         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA,
4844         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA);
4845
4846     test_IObjectSafety_set(safety, S_OK, S_OK,
4847         INTERFACE_USES_SECURITY_MANAGER, INTERFACE_USES_SECURITY_MANAGER,
4848         0, INTERFACE_USES_SECURITY_MANAGER /* msxml3 SP8+ */);
4849
4850     /* set INTERFACE_USES_DISPEX  */
4851
4852     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
4853         INTERFACE_USES_DISPEX, INTERFACE_USES_DISPEX,
4854         0, 0);
4855
4856     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
4857         INTERFACE_USES_DISPEX, 0,
4858         0, 0);
4859
4860     test_IObjectSafety_set(safety, S_OK, S_OK /* msxml3 SP8+ */,
4861         0, INTERFACE_USES_DISPEX,
4862         0, 0);
4863
4864     /* set option masking */
4865
4866     test_IObjectSafety_set(safety, S_OK, S_OK,
4867         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4868         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4869         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4870         INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4871
4872     test_IObjectSafety_set(safety, S_OK, S_OK,
4873         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4874         INTERFACESAFE_FOR_UNTRUSTED_DATA,
4875         INTERFACESAFE_FOR_UNTRUSTED_DATA,
4876         INTERFACESAFE_FOR_UNTRUSTED_DATA);
4877
4878     test_IObjectSafety_set(safety, S_OK, S_OK,
4879         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4880         INTERFACE_USES_SECURITY_MANAGER,
4881         0,
4882         0);
4883
4884     /* set -- inheriting previous settings */
4885
4886     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4887                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4888                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4889     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4890     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4891     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4892     ok_(__FILE__,line)(enabled == INTERFACESAFE_FOR_UNTRUSTED_CALLER, "Expected INTERFACESAFE_FOR_UNTRUSTED_CALLER got %08x\n", enabled);
4893     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4894        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4895         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4896              "got %08x\n", supported);
4897
4898     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4899                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA,
4900                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA);
4901     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4902     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4903     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4904     ok_(__FILE__,line)(broken(enabled == INTERFACESAFE_FOR_UNTRUSTED_DATA) ||
4905                        enabled == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA),
4906                        "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA) got %08x\n", enabled);
4907     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4908        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4909         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4910              "got %08x\n", supported);
4911 }
4912
4913 static void test_XMLHTTP(void)
4914 {
4915     static const char bodyA[] = "mode=Test";
4916     static const char urlA[] = "http://crossover.codeweavers.com/posttest.php";
4917     static const char xmltestA[] = "http://crossover.codeweavers.com/xmltest.xml";
4918     static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
4919     static const CHAR xmltestbodyA[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<a>TEST</a>\n";
4920
4921     IXMLHttpRequest *xhr;
4922     IObjectSafety *safety;
4923     IObjectWithSite *obj_site, *obj_site2;
4924     BSTR bstrResponse, str, str1;
4925     VARIANT varbody, varbody_ref;
4926     VARIANT dummy;
4927     VARIANT async;
4928     LONG state, status, bound;
4929     IDispatch *event;
4930     void *ptr;
4931     HRESULT hr;
4932     HGLOBAL g;
4933
4934     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
4935         &IID_IXMLHttpRequest, (void**)&xhr);
4936     if (FAILED(hr))
4937     {
4938         win_skip("IXMLHTTPRequest is not available (0x%08x)\n", hr);
4939         return;
4940     }
4941
4942     VariantInit(&dummy);
4943     V_VT(&dummy) = VT_ERROR;
4944     V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
4945     VariantInit(&async);
4946     V_VT(&async) = VT_BOOL;
4947     V_BOOL(&async) = VARIANT_FALSE;
4948
4949     hr = IXMLHttpRequest_put_onreadystatechange(xhr, NULL);
4950     EXPECT_HR(hr, S_OK);
4951
4952     hr = IXMLHttpRequest_abort(xhr);
4953     EXPECT_HR(hr, S_OK);
4954
4955     V_VT(&varbody) = VT_I2;
4956     V_I2(&varbody) = 1;
4957     hr = IXMLHttpRequest_get_responseBody(xhr, &varbody);
4958     EXPECT_HR(hr, E_PENDING);
4959     ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody));
4960     ok(V_I2(&varbody) == 1, "got %d\n", V_I2(&varbody));
4961
4962     V_VT(&varbody) = VT_I2;
4963     V_I2(&varbody) = 1;
4964     hr = IXMLHttpRequest_get_responseStream(xhr, &varbody);
4965     EXPECT_HR(hr, E_PENDING);
4966     ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody));
4967     ok(V_I2(&varbody) == 1, "got %d\n", V_I2(&varbody));
4968
4969     /* send before open */
4970     hr = IXMLHttpRequest_send(xhr, dummy);
4971     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4972
4973     /* initial status code */
4974     hr = IXMLHttpRequest_get_status(xhr, NULL);
4975     EXPECT_HR(hr, E_INVALIDARG);
4976
4977     status = 0xdeadbeef;
4978     hr = IXMLHttpRequest_get_status(xhr, &status);
4979     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4980     ok(status == 0xdeadbeef, "got %d\n", status);
4981
4982     hr = IXMLHttpRequest_get_statusText(xhr, &str);
4983     ok(hr == E_FAIL, "got 0x%08x\n", hr);
4984
4985     /* invalid parameters */
4986     hr = IXMLHttpRequest_open(xhr, NULL, NULL, async, dummy, dummy);
4987     EXPECT_HR(hr, E_INVALIDARG);
4988
4989     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), NULL, async, dummy, dummy);
4990     EXPECT_HR(hr, E_INVALIDARG);
4991
4992     hr = IXMLHttpRequest_open(xhr, NULL, _bstr_(urlA), async, dummy, dummy);
4993     EXPECT_HR(hr, E_INVALIDARG);
4994
4995     hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, NULL);
4996     EXPECT_HR(hr, E_INVALIDARG);
4997
4998     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), NULL);
4999     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
5000
5001     hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
5002     EXPECT_HR(hr, E_INVALIDARG);
5003
5004     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
5005     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
5006
5007     hr = IXMLHttpRequest_get_readyState(xhr, NULL);
5008     EXPECT_HR(hr, E_INVALIDARG);
5009
5010     state = -1;
5011     hr = IXMLHttpRequest_get_readyState(xhr, &state);
5012     EXPECT_HR(hr, S_OK);
5013     ok(state == READYSTATE_UNINITIALIZED, "got %d, expected READYSTATE_UNINITIALIZED\n", state);
5014
5015     event = create_dispevent();
5016
5017     EXPECT_REF(event, 1);
5018     hr = IXMLHttpRequest_put_onreadystatechange(xhr, event);
5019     EXPECT_HR(hr, S_OK);
5020     EXPECT_REF(event, 2);
5021
5022     g_unexpectedcall = g_expectedcall = 0;
5023
5024     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), _bstr_(urlA), async, dummy, dummy);
5025     EXPECT_HR(hr, S_OK);
5026
5027     ok(g_unexpectedcall == 0, "unexpected disp event call\n");
5028     ok(g_expectedcall == 1 || broken(g_expectedcall == 0) /* win2k */, "no expected disp event call\n");
5029
5030     /* status code after ::open() */
5031     status = 0xdeadbeef;
5032     hr = IXMLHttpRequest_get_status(xhr, &status);
5033     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
5034     ok(status == 0xdeadbeef, "got %d\n", status);
5035
5036     state = -1;
5037     hr = IXMLHttpRequest_get_readyState(xhr, &state);
5038     EXPECT_HR(hr, S_OK);
5039     ok(state == READYSTATE_LOADING, "got %d, expected READYSTATE_LOADING\n", state);
5040
5041     hr = IXMLHttpRequest_abort(xhr);
5042     EXPECT_HR(hr, S_OK);
5043
5044     state = -1;
5045     hr = IXMLHttpRequest_get_readyState(xhr, &state);
5046     EXPECT_HR(hr, S_OK);
5047     ok(state == READYSTATE_UNINITIALIZED || broken(state == READYSTATE_LOADING) /* win2k */,
5048         "got %d, expected READYSTATE_UNINITIALIZED\n", state);
5049
5050     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), _bstr_(urlA), async, dummy, dummy);
5051     EXPECT_HR(hr, S_OK);
5052
5053     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
5054     EXPECT_HR(hr, S_OK);
5055
5056     hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
5057     EXPECT_HR(hr, E_INVALIDARG);
5058
5059     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_(""), _bstr_("value1"));
5060     EXPECT_HR(hr, E_INVALIDARG);
5061
5062     V_VT(&varbody) = VT_BSTR;
5063     V_BSTR(&varbody) = _bstr_(bodyA);
5064
5065     hr = IXMLHttpRequest_send(xhr, varbody);
5066     if (hr == INET_E_RESOURCE_NOT_FOUND)
5067     {
5068         skip("No connection could be made with crossover.codeweavers.com\n");
5069         IXMLHttpRequest_Release(xhr);
5070         return;
5071     }
5072     EXPECT_HR(hr, S_OK);
5073
5074     /* response headers */
5075     hr = IXMLHttpRequest_getAllResponseHeaders(xhr, NULL);
5076     EXPECT_HR(hr, E_INVALIDARG);
5077     hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str);
5078     EXPECT_HR(hr, S_OK);
5079     /* status line is stripped already */
5080     ok(memcmp(str, _bstr_("HTTP"), 4*sizeof(WCHAR)), "got response headers %s\n", wine_dbgstr_w(str));
5081     ok(*str, "got empty headers\n");
5082     hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str1);
5083     EXPECT_HR(hr, S_OK);
5084     ok(str1 != str, "got %p\n", str1);
5085     SysFreeString(str1);
5086     SysFreeString(str);
5087
5088     hr = IXMLHttpRequest_getResponseHeader(xhr, NULL, NULL);
5089     EXPECT_HR(hr, E_INVALIDARG);
5090     hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), NULL);
5091     EXPECT_HR(hr, E_INVALIDARG);
5092     hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), &str);
5093     EXPECT_HR(hr, S_OK);
5094     ok(*str != ' ', "got leading space in header %s\n", wine_dbgstr_w(str));
5095     SysFreeString(str);
5096
5097     /* status code after ::send() */
5098     status = 0xdeadbeef;
5099     hr = IXMLHttpRequest_get_status(xhr, &status);
5100     EXPECT_HR(hr, S_OK);
5101     ok(status == 200, "got %d\n", status);
5102
5103     hr = IXMLHttpRequest_get_statusText(xhr, NULL);
5104     EXPECT_HR(hr, E_INVALIDARG);
5105
5106     hr = IXMLHttpRequest_get_statusText(xhr, &str);
5107     EXPECT_HR(hr, S_OK);
5108     ok(!lstrcmpW(str, _bstr_("OK")), "got status %s\n", wine_dbgstr_w(str));
5109     SysFreeString(str);
5110
5111     /* another ::send() after completed request */
5112     V_VT(&varbody) = VT_BSTR;
5113     V_BSTR(&varbody) = _bstr_(bodyA);
5114
5115     hr = IXMLHttpRequest_send(xhr, varbody);
5116     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
5117
5118     hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
5119     EXPECT_HR(hr, S_OK);
5120     /* the server currently returns "FAILED" because the Content-Type header is
5121      * not what the server expects */
5122     if(hr == S_OK)
5123     {
5124         ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)),
5125             "expected %s, got %s\n", wine_dbgstr_w(wszExpectedResponse), wine_dbgstr_w(bstrResponse));
5126         SysFreeString(bstrResponse);
5127     }
5128
5129     /* POST: VT_VARIANT|VT_BYREF body */
5130     V_VT(&varbody_ref) = VT_VARIANT|VT_BYREF;
5131     V_VARIANTREF(&varbody_ref) = &varbody;
5132     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), _bstr_(urlA), async, dummy, dummy);
5133     EXPECT_HR(hr, S_OK);
5134     hr = IXMLHttpRequest_send(xhr, varbody_ref);
5135     EXPECT_HR(hr, S_OK);
5136
5137     /* GET request */
5138     hr = IXMLHttpRequest_open(xhr, _bstr_("GET"), _bstr_(xmltestA), async, dummy, dummy);
5139     EXPECT_HR(hr, S_OK);
5140
5141     V_VT(&varbody) = VT_EMPTY;
5142
5143     hr = IXMLHttpRequest_send(xhr, varbody);
5144     if (hr == INET_E_RESOURCE_NOT_FOUND)
5145     {
5146         skip("No connection could be made with crossover.codeweavers.com\n");
5147         IXMLHttpRequest_Release(xhr);
5148         return;
5149     }
5150     EXPECT_HR(hr, S_OK);
5151
5152     hr = IXMLHttpRequest_get_responseText(xhr, NULL);
5153     EXPECT_HR(hr, E_INVALIDARG);
5154
5155     hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
5156     EXPECT_HR(hr, S_OK);
5157     ok(!memcmp(bstrResponse, _bstr_(xmltestbodyA), sizeof(xmltestbodyA)*sizeof(WCHAR)),
5158         "expected %s, got %s\n", xmltestbodyA, wine_dbgstr_w(bstrResponse));
5159     SysFreeString(bstrResponse);
5160
5161     hr = IXMLHttpRequest_get_responseBody(xhr, NULL);
5162     EXPECT_HR(hr, E_INVALIDARG);
5163
5164     V_VT(&varbody) = VT_EMPTY;
5165     hr = IXMLHttpRequest_get_responseBody(xhr, &varbody);
5166     EXPECT_HR(hr, S_OK);
5167     ok(V_VT(&varbody) == (VT_ARRAY|VT_UI1), "got type %d, expected %d\n", V_VT(&varbody), VT_ARRAY|VT_UI1);
5168     ok(SafeArrayGetDim(V_ARRAY(&varbody)) == 1, "got %d, expected one dimension\n", SafeArrayGetDim(V_ARRAY(&varbody)));
5169
5170     bound = -1;
5171     hr = SafeArrayGetLBound(V_ARRAY(&varbody), 1, &bound);
5172     EXPECT_HR(hr, S_OK);
5173     ok(bound == 0, "got %d, expected zero bound\n", bound);
5174
5175     hr = SafeArrayAccessData(V_ARRAY(&varbody), &ptr);
5176     EXPECT_HR(hr, S_OK);
5177     ok(memcmp(ptr, xmltestbodyA, sizeof(xmltestbodyA)-1) == 0, "got wrong body data\n");
5178     SafeArrayUnaccessData(V_ARRAY(&varbody));
5179
5180     VariantClear(&varbody);
5181
5182     /* get_responseStream */
5183     hr = IXMLHttpRequest_get_responseStream(xhr, NULL);
5184     EXPECT_HR(hr, E_INVALIDARG);
5185
5186     V_VT(&varbody) = VT_EMPTY;
5187     hr = IXMLHttpRequest_get_responseStream(xhr, &varbody);
5188     ok(V_VT(&varbody) == VT_UNKNOWN, "got type %d\n", V_VT(&varbody));
5189     EXPECT_HR(hr, S_OK);
5190     EXPECT_REF(V_UNKNOWN(&varbody), 1);
5191
5192     g = NULL;
5193     hr = GetHGlobalFromStream((IStream*)V_UNKNOWN(&varbody), &g);
5194     EXPECT_HR(hr, S_OK);
5195     ok(g != NULL, "got %p\n", g);
5196
5197     hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectSafety, (void**)&safety);
5198     EXPECT_HR(hr, S_OK);
5199     if(hr == S_OK)
5200     {
5201         test_IObjectSafety_common(safety);
5202         IObjectSafety_Release(safety);
5203     }
5204
5205     IDispatch_Release(event);
5206
5207     /* interaction with object site */
5208     EXPECT_REF(xhr, 1);
5209     hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site);
5210     EXPECT_HR(hr, S_OK);
5211 todo_wine {
5212     EXPECT_REF(xhr, 1);
5213     EXPECT_REF(obj_site, 1);
5214 }
5215
5216     IObjectWithSite_AddRef(obj_site);
5217 todo_wine {
5218     EXPECT_REF(obj_site, 2);
5219     EXPECT_REF(xhr, 1);
5220 }
5221     IObjectWithSite_Release(obj_site);
5222
5223     hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site2);
5224     EXPECT_HR(hr, S_OK);
5225 todo_wine {
5226     EXPECT_REF(xhr, 1);
5227     EXPECT_REF(obj_site, 1);
5228     EXPECT_REF(obj_site2, 1);
5229     ok(obj_site != obj_site2, "expected new instance\n");
5230 }
5231     SET_EXPECT(site_qi_IServiceProvider);
5232     SET_EXPECT(sp_queryservice_SID_SBindHost);
5233     SET_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
5234     SET_EXPECT(sp_queryservice_SID_secmgr_htmldoc2);
5235     SET_EXPECT(sp_queryservice_SID_secmgr_xmldomdoc);
5236     SET_EXPECT(sp_queryservice_SID_secmgr_secmgr);
5237
5238     /* calls to IHTMLDocument2 */
5239     SET_EXPECT(htmldoc2_get_all);
5240     SET_EXPECT(collection_get_length);
5241     SET_EXPECT(htmldoc2_get_url);
5242
5243     SET_EXPECT(site_qi_IXMLDOMDocument);
5244     SET_EXPECT(site_qi_IOleClientSite);
5245
5246     hr = IObjectWithSite_SetSite(obj_site, &testsite.IUnknown_iface);
5247     EXPECT_HR(hr, S_OK);
5248
5249     CHECK_CALLED(site_qi_IServiceProvider);
5250 todo_wine
5251     CHECK_CALLED(sp_queryservice_SID_SBindHost);
5252     CHECK_CALLED(sp_queryservice_SID_SContainerDispatch_htmldoc2);
5253 todo_wine {
5254     CHECK_CALLED(sp_queryservice_SID_secmgr_htmldoc2);
5255     CHECK_CALLED(sp_queryservice_SID_secmgr_xmldomdoc);
5256     /* this one isn't very reliable
5257     CHECK_CALLED(sp_queryservice_SID_secmgr_secmgr); */
5258
5259     CHECK_CALLED(htmldoc2_get_all);
5260     CHECK_CALLED(collection_get_length);
5261     CHECK_CALLED(htmldoc2_get_url);
5262
5263     CHECK_CALLED(site_qi_IXMLDOMDocument);
5264     CHECK_CALLED(site_qi_IOleClientSite);
5265 }
5266     IObjectWithSite_Release(obj_site);
5267
5268     /* try to set site another time */
5269
5270     /* to be removed once IObjectWithSite is properly separated */
5271     SET_EXPECT(site_qi_IServiceProvider);
5272     SET_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
5273
5274     hr = IObjectWithSite_SetSite(obj_site2, &testsite.IUnknown_iface);
5275     EXPECT_HR(hr, S_OK);
5276
5277     todo_wine EXPECT_REF(xhr, 1);
5278     IXMLHttpRequest_Release(xhr);
5279
5280     /* still works after request is released */
5281
5282     /* to be removed once IObjectWithSite is properly separated */
5283     SET_EXPECT(site_qi_IServiceProvider);
5284     SET_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
5285
5286     hr = IObjectWithSite_SetSite(obj_site2, &testsite.IUnknown_iface);
5287     EXPECT_HR(hr, S_OK);
5288     IObjectWithSite_Release(obj_site2);
5289
5290     free_bstrs();
5291 }
5292
5293 static void test_IXMLDOMDocument2(void)
5294 {
5295     static const WCHAR emptyW[] = {0};
5296     IXMLDOMDocument2 *doc2, *dtddoc2;
5297     IXMLDOMDocument *doc;
5298     IXMLDOMParseError* err;
5299     IDispatchEx *dispex;
5300     VARIANT_BOOL b;
5301     VARIANT var;
5302     HRESULT r;
5303     LONG res;
5304
5305     doc = create_document(&IID_IXMLDOMDocument);
5306     if (!doc) return;
5307
5308     dtddoc2 = create_document(&IID_IXMLDOMDocument2);
5309     if (!dtddoc2)
5310     {
5311         IXMLDOMDocument_Release(doc);
5312         return;
5313     }
5314
5315     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
5316     ok( r == S_OK, "ret %08x\n", r );
5317     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
5318
5319     ole_expect(IXMLDOMDocument2_get_readyState(doc2, NULL), E_INVALIDARG);
5320     ole_check(IXMLDOMDocument2_get_readyState(doc2, &res));
5321     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
5322
5323     err = NULL;
5324     ole_expect(IXMLDOMDocument2_validate(doc2, NULL), S_FALSE);
5325     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
5326     ok(err != NULL, "expected a pointer\n");
5327     if (err)
5328     {
5329         res = 0;
5330         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5331         /* XML_E_NOTWF */
5332         ok(res == E_XML_NOTWF, "got %08x\n", res);
5333         IXMLDOMParseError_Release(err);
5334     }
5335
5336     r = IXMLDOMDocument_loadXML( doc2, _bstr_(complete4A), &b );
5337     ok( r == S_OK, "loadXML failed\n");
5338     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5339
5340     ole_check(IXMLDOMDocument2_get_readyState(doc, &res));
5341     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
5342
5343     err = NULL;
5344     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
5345     ok(err != NULL, "expected a pointer\n");
5346     if (err)
5347     {
5348         res = 0;
5349         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5350         /* XML_E_NODTD */
5351         ok(res == E_XML_NODTD, "got %08x\n", res);
5352         IXMLDOMParseError_Release(err);
5353     }
5354
5355     r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
5356     ok( r == S_OK, "ret %08x\n", r );
5357     if(r == S_OK)
5358     {
5359         IDispatchEx_Release(dispex);
5360     }
5361
5362     /* we will check if the variant got cleared */
5363     IXMLDOMDocument2_AddRef(doc2);
5364     EXPECT_REF(doc2, 3); /* doc, doc2, AddRef*/
5365
5366     V_VT(&var) = VT_UNKNOWN;
5367     V_UNKNOWN(&var) = (IUnknown *)doc2;
5368
5369     /* invalid calls */
5370     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
5371     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
5372     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
5373
5374     /* valid call */
5375     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
5376     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
5377     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
5378     V_VT(&var) = VT_R4;
5379
5380     /* the variant didn't get cleared*/
5381     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
5382
5383     /* setProperty tests */
5384     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
5385     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
5386     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
5387     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
5388     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5389     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
5390
5391     V_VT(&var) = VT_BSTR;
5392     V_BSTR(&var) = SysAllocString(emptyW);
5393     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
5394     ok(r == S_OK, "got 0x%08x\n", r);
5395     VariantClear(&var);
5396
5397     V_VT(&var) = VT_I2;
5398     V_I2(&var) = 0;
5399     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
5400     ok(r == E_FAIL, "got 0x%08x\n", r);
5401
5402     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
5403     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
5404     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
5405     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
5406
5407     IXMLDOMDocument2_Release( doc2 );
5408     IXMLDOMDocument_Release( doc );
5409
5410     /* DTD validation */
5411     ole_check(IXMLDOMDocument2_put_validateOnParse(dtddoc2, VARIANT_FALSE));
5412     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML), &b));
5413     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5414     err = NULL;
5415     ole_check(IXMLDOMDocument2_validate(dtddoc2, &err));
5416     ok(err != NULL, "expected pointer\n");
5417     if (err)
5418     {
5419         res = 0;
5420         ole_expect(IXMLDOMParseError_get_errorCode(err, &res), S_FALSE);
5421         ok(res == 0, "got %08x\n", res);
5422         IXMLDOMParseError_Release(err);
5423     }
5424
5425     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0D), &b));
5426     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5427     err = NULL;
5428     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5429     ok(err != NULL, "expected pointer\n");
5430     if (err)
5431     {
5432         res = 0;
5433         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5434         /* XML_ELEMENT_UNDECLARED */
5435         todo_wine ok(res == 0xC00CE00D, "got %08x\n", res);
5436         IXMLDOMParseError_Release(err);
5437     }
5438
5439     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0E), &b));
5440     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5441     err = NULL;
5442     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5443     ok(err != NULL, "expected pointer\n");
5444     if (err)
5445     {
5446         res = 0;
5447         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5448         /* XML_ELEMENT_ID_NOT_FOUND */
5449         todo_wine ok(res == 0xC00CE00E, "got %08x\n", res);
5450         IXMLDOMParseError_Release(err);
5451     }
5452
5453     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_11), &b));
5454     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5455     err = NULL;
5456     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5457     ok(err != NULL, "expected pointer\n");
5458     if (err)
5459     {
5460         res = 0;
5461         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5462         /* XML_EMPTY_NOT_ALLOWED */
5463         todo_wine ok(res == 0xC00CE011, "got %08x\n", res);
5464         IXMLDOMParseError_Release(err);
5465     }
5466
5467     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_13), &b));
5468     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5469     err = NULL;
5470     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5471     ok(err != NULL, "expected pointer\n");
5472     if (err)
5473     {
5474         res = 0;
5475         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5476         /* XML_ROOT_NAME_MISMATCH */
5477         todo_wine ok(res == 0xC00CE013, "got %08x\n", res);
5478         IXMLDOMParseError_Release(err);
5479     }
5480
5481     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_14), &b));
5482     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5483     err = NULL;
5484     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5485     ok(err != NULL, "expected pointer\n");
5486     if (err)
5487     {
5488         res = 0;
5489         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5490         /* XML_INVALID_CONTENT */
5491         todo_wine ok(res == 0xC00CE014, "got %08x\n", res);
5492         IXMLDOMParseError_Release(err);
5493     }
5494
5495     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_15), &b));
5496     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5497     err = NULL;
5498     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5499     ok(err != NULL, "expected pointer\n");
5500     if (err)
5501     {
5502         res = 0;
5503         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5504         /* XML_ATTRIBUTE_NOT_DEFINED */
5505         todo_wine ok(res == 0xC00CE015, "got %08x\n", res);
5506         IXMLDOMParseError_Release(err);
5507     }
5508
5509     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_16), &b));
5510     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5511     err = NULL;
5512     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5513     ok(err != NULL, "expected pointer\n");
5514     if (err)
5515     {
5516         res = 0;
5517         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5518         /* XML_ATTRIBUTE_FIXED */
5519         todo_wine ok(res == 0xC00CE016, "got %08x\n", res);
5520         IXMLDOMParseError_Release(err);
5521     }
5522
5523     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_17), &b));
5524     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5525     err = NULL;
5526     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5527     ok(err != NULL, "expected pointer\n");
5528     if (err)
5529     {
5530         res = 0;
5531         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5532         /* XML_ATTRIBUTE_VALUE */
5533         todo_wine ok(res == 0xC00CE017, "got %08x\n", res);
5534         IXMLDOMParseError_Release(err);
5535     }
5536
5537     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_18), &b));
5538     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5539     err = NULL;
5540     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5541     ok(err != NULL, "expected pointer\n");
5542     if (err)
5543     {
5544         res = 0;
5545         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5546         /* XML_ILLEGAL_TEXT */
5547         todo_wine ok(res == 0xC00CE018, "got %08x\n", res);
5548         IXMLDOMParseError_Release(err);
5549     }
5550
5551     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_20), &b));
5552     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5553     err = NULL;
5554     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5555     ok(err != NULL, "expected pointer\n");
5556     if (err)
5557     {
5558         res = 0;
5559         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5560         /* XML_REQUIRED_ATTRIBUTE_MISSING */
5561         todo_wine ok(res == 0xC00CE020, "got %08x\n", res);
5562         IXMLDOMParseError_Release(err);
5563     }
5564
5565     IXMLDOMDocument2_Release( dtddoc2 );
5566     free_bstrs();
5567 }
5568
5569 #define helper_ole_check(expr) { \
5570     HRESULT r = expr; \
5571     ok_(__FILE__, line)(r == S_OK, "=> %i: " #expr " returned %08x\n", __LINE__, r); \
5572 }
5573
5574 #define helper_expect_list_and_release(list, expstr) { \
5575     char *str = list_to_string(list); \
5576     ok_(__FILE__, line)(strcmp(str, expstr)==0, "=> %i: Invalid node list: %s, expected %s\n", __LINE__, str, expstr); \
5577     if (list) IXMLDOMNodeList_Release(list); \
5578 }
5579
5580 #define helper_expect_bstr_and_release(bstr, str) { \
5581     ok_(__FILE__, line)(lstrcmpW(bstr, _bstr_(str)) == 0, \
5582        "=> %i: got %s\n", __LINE__, wine_dbgstr_w(bstr)); \
5583     SysFreeString(bstr); \
5584 }
5585
5586 #define check_ws_ignored(doc, str) _check_ws_ignored(__LINE__, doc, str)
5587 static inline void _check_ws_ignored(int line, IXMLDOMDocument2* doc, char const* str)
5588 {
5589     IXMLDOMNode *node1, *node2;
5590     IXMLDOMNodeList *list;
5591     BSTR bstr;
5592
5593     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
5594     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
5595     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
5596     helper_ole_check(IXMLDOMNodeList_reset(list));
5597     helper_expect_list_and_release(list, "E1.E5.E1.E2.D1 E2.E5.E1.E2.D1");
5598
5599     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
5600     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");
5601     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
5602     if (str)
5603     {
5604         helper_expect_bstr_and_release(bstr, str);
5605     }
5606     else
5607     {
5608         helper_expect_bstr_and_release(bstr, "This is a description.");
5609     }
5610     IXMLDOMNode_Release(node1);
5611
5612     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
5613     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");
5614     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
5615     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
5616     IXMLDOMNode_Release(node2);
5617 }
5618
5619 #define check_ws_preserved(doc, str) _check_ws_preserved(__LINE__, doc, str)
5620 static inline void _check_ws_preserved(int line, IXMLDOMDocument2* doc, char const* str)
5621 {
5622     IXMLDOMNode *node1, *node2;
5623     IXMLDOMNodeList *list;
5624     BSTR bstr;
5625
5626     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
5627     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
5628     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
5629     helper_ole_check(IXMLDOMNodeList_reset(list));
5630     helper_expect_list_and_release(list, "E2.E10.E2.E2.D1 E4.E10.E2.E2.D1");
5631
5632     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
5633     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");
5634     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
5635     if (str)
5636     {
5637         helper_expect_bstr_and_release(bstr, str);
5638     }
5639     else
5640     {
5641         helper_expect_bstr_and_release(bstr, "\n                This is a description. \n            ");
5642     }
5643     IXMLDOMNode_Release(node1);
5644
5645     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
5646     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");
5647     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
5648     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
5649     IXMLDOMNode_Release(node2);
5650 }
5651
5652 static void test_whitespace(void)
5653 {
5654     VARIANT_BOOL b;
5655     IXMLDOMDocument2 *doc1, *doc2, *doc3, *doc4;
5656
5657     doc1 = create_document(&IID_IXMLDOMDocument2);
5658     doc2 = create_document(&IID_IXMLDOMDocument2);
5659     if (!doc1 || !doc2) return;
5660
5661     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_TRUE));
5662     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
5663     ok(b == VARIANT_FALSE, "expected false\n");
5664     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
5665     ok(b == VARIANT_TRUE, "expected true\n");
5666
5667     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
5668     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5669     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
5670     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5671
5672     /* switch to XPath */
5673     ole_check(IXMLDOMDocument2_setProperty(doc1, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5674     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5675
5676     check_ws_ignored(doc1, NULL);
5677     check_ws_preserved(doc2, NULL);
5678
5679     /* new instances copy the property */
5680     ole_check(IXMLDOMDocument2_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**) &doc3));
5681     ole_check(IXMLDOMDocument2_QueryInterface(doc2, &IID_IXMLDOMDocument2, (void**) &doc4));
5682
5683     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
5684     ok(b == VARIANT_FALSE, "expected false\n");
5685     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
5686     ok(b == VARIANT_TRUE, "expected true\n");
5687
5688     check_ws_ignored(doc3, NULL);
5689     check_ws_preserved(doc4, NULL);
5690
5691     /* setting after loading xml affects trimming of leading/trailing ws only */
5692     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_TRUE));
5693     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_FALSE));
5694
5695     /* the trailing "\n            " isn't there, because it was ws-only node */
5696     check_ws_ignored(doc1, "\n                This is a description. ");
5697     check_ws_preserved(doc2, "This is a description.");
5698
5699     /* it takes effect on reload */
5700     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
5701     ok(b == VARIANT_TRUE, "expected true\n");
5702     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
5703     ok(b == VARIANT_FALSE, "expected false\n");
5704
5705     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
5706     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5707     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
5708     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5709
5710     check_ws_preserved(doc1, NULL);
5711     check_ws_ignored(doc2, NULL);
5712
5713     /* other instances follow suit */
5714     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
5715     ok(b == VARIANT_TRUE, "expected true\n");
5716     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
5717     ok(b == VARIANT_FALSE, "expected false\n");
5718
5719     check_ws_preserved(doc3, NULL);
5720     check_ws_ignored(doc4, NULL);
5721
5722     IXMLDOMDocument_Release(doc1);
5723     IXMLDOMDocument_Release(doc2);
5724     IXMLDOMDocument_Release(doc3);
5725     IXMLDOMDocument_Release(doc4);
5726     free_bstrs();
5727 }
5728
5729 typedef struct {
5730     const GUID *clsid;
5731     const char *name;
5732     const char *ns;
5733     HRESULT hr;
5734 } selection_ns_t;
5735
5736 /* supposed to be tested with szExampleXML */
5737 static const selection_ns_t selection_ns_data[] = {
5738     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5739     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5740     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5741
5742     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5743     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5744     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5745
5746     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5747     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5748     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5749
5750     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5751     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5752     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5753
5754     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5755     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5756     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5757
5758     { NULL }
5759 };
5760
5761 static void test_XPath(void)
5762 {
5763     const selection_ns_t *ptr = selection_ns_data;
5764     VARIANT var;
5765     VARIANT_BOOL b;
5766     IXMLDOMDocument2 *doc;
5767     IXMLDOMDocument *doc2;
5768     IXMLDOMNode *rootNode;
5769     IXMLDOMNode *elem1Node;
5770     IXMLDOMNode *node;
5771     IXMLDOMNodeList *list;
5772     IXMLDOMElement *elem;
5773     IXMLDOMAttribute *attr;
5774     DOMNodeType type;
5775     HRESULT hr;
5776     LONG len;
5777     BSTR str;
5778
5779     doc = create_document(&IID_IXMLDOMDocument2);
5780     if (!doc) return;
5781
5782     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5783     EXPECT_HR(hr, S_OK);
5784     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5785
5786     /* switch to XPath */
5787     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5788
5789     /* some simple queries*/
5790     EXPECT_REF(doc, 1);
5791     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5792     EXPECT_HR(hr, S_OK);
5793     EXPECT_REF(doc, 1);
5794     EXPECT_LIST_LEN(list, 1);
5795
5796     EXPECT_REF(list, 1);
5797     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5798     EXPECT_HR(hr, S_OK);
5799     EXPECT_REF(list, 1);
5800     EXPECT_REF(rootNode, 1);
5801
5802     hr = IXMLDOMNodeList_reset(list);
5803     EXPECT_HR(hr, S_OK);
5804     expect_list_and_release(list, "E2.D1");
5805
5806 if (0)
5807 {
5808     /* namespace:: axis test is disabled until namespace definitions
5809        are supported as attribute nodes, currently it's another node type */
5810     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("/root/namespace::*"), &list);
5811     EXPECT_HR(hr, S_OK);
5812     len = -1;
5813     hr = IXMLDOMNodeList_get_length(list, &len);
5814     EXPECT_HR(hr, S_OK);
5815     ok(len == 2, "got %d\n", len);
5816
5817     hr = IXMLDOMNodeList_nextNode(list, &node);
5818     EXPECT_HR(hr, S_OK);
5819     type = NODE_INVALID;
5820     hr = IXMLDOMNode_get_nodeType(node, &type);
5821     EXPECT_HR(hr, S_OK);
5822     ok(type == NODE_ATTRIBUTE, "got %d\n", type);
5823     IXMLDOMNode_Release(node);
5824
5825     IXMLDOMNodeList_Release(list);
5826 }
5827
5828     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//c"), &list));
5829     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
5830
5831     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//c[@type]"), &list));
5832     expect_list_and_release(list, "E3.E2.E2.D1");
5833
5834     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
5835     /* using get_item for query results advances the position */
5836     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
5837     expect_node(node, "E2.E2.D1");
5838     IXMLDOMNode_Release(node);
5839     ole_check(IXMLDOMNodeList_nextNode(list, &node));
5840     expect_node(node, "E4.E2.D1");
5841     IXMLDOMNode_Release(node);
5842     ole_check(IXMLDOMNodeList_reset(list));
5843     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
5844
5845     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
5846     expect_list_and_release(list, "E2.D1");
5847
5848     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
5849     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
5850     ole_check(IXMLDOMNodeList_reset(list));
5851     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
5852
5853     /* select an attribute */
5854     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
5855     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
5856
5857     /* would evaluate to a number */
5858     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
5859     /* would evaluate to a boolean */
5860     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
5861     /* would evaluate to a string */
5862     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
5863
5864     /* no results */
5865     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
5866     expect_list_and_release(list, "");
5867     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("elem//c"), &list));
5868     expect_list_and_release(list, "");
5869     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//elem[4]"), &list));
5870     expect_list_and_release(list, "");
5871     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//elem[0]"), &list));
5872     expect_list_and_release(list, "");
5873
5874     /* foo undeclared in document node */
5875     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5876     /* undeclared in <root> node */
5877     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
5878     /* undeclared in <elem> node */
5879     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
5880     /* but this trick can be used */
5881     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
5882     expect_list_and_release(list, "E3.E4.E2.D1");
5883
5884     /* it has to be declared in SelectionNamespaces */
5885     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5886         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
5887
5888     /* now the namespace can be used */
5889     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list));
5890     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5891     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
5892     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5893     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
5894     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5895     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
5896     expect_list_and_release(list, "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1");
5897
5898     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
5899     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5900         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
5901
5902     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5903
5904     VariantInit(&var);
5905     ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
5906     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
5907     if (V_VT(&var) == VT_BSTR)
5908         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
5909
5910     /* extra attributes - same thing*/
5911     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5912         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
5913     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5914
5915     IXMLDOMNode_Release(rootNode);
5916     IXMLDOMNode_Release(elem1Node);
5917
5918     /* alter document with already built list */
5919     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5920     EXPECT_HR(hr, S_OK);
5921     EXPECT_LIST_LEN(list, 1);
5922
5923     hr = IXMLDOMDocument2_get_lastChild(doc, &rootNode);
5924     EXPECT_HR(hr, S_OK);
5925     EXPECT_REF(rootNode, 1);
5926     EXPECT_REF(doc, 1);
5927
5928     hr = IXMLDOMDocument2_removeChild(doc, rootNode, NULL);
5929     EXPECT_HR(hr, S_OK);
5930     IXMLDOMNode_Release(rootNode);
5931
5932     EXPECT_LIST_LEN(list, 1);
5933
5934     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5935     EXPECT_HR(hr, S_OK);
5936     EXPECT_REF(rootNode, 1);
5937
5938     IXMLDOMNodeList_Release(list);
5939
5940     hr = IXMLDOMNode_get_nodeName(rootNode, &str);
5941     EXPECT_HR(hr, S_OK);
5942     ok(!lstrcmpW(str, _bstr_("root")), "got %s\n", wine_dbgstr_w(str));
5943     SysFreeString(str);
5944     IXMLDOMNode_Release(rootNode);
5945
5946     /* alter node from list and get it another time */
5947     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5948     EXPECT_HR(hr, S_OK);
5949     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5950
5951     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5952     EXPECT_HR(hr, S_OK);
5953     EXPECT_LIST_LEN(list, 1);
5954
5955     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5956     EXPECT_HR(hr, S_OK);
5957
5958     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
5959     EXPECT_HR(hr, S_OK);
5960
5961     V_VT(&var) = VT_I2;
5962     V_I2(&var) = 1;
5963     hr = IXMLDOMElement_setAttribute(elem, _bstr_("attrtest"), var);
5964     EXPECT_HR(hr, S_OK);
5965     IXMLDOMElement_Release(elem);
5966     IXMLDOMNode_Release(rootNode);
5967
5968     /* now check attribute to be present */
5969     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5970     EXPECT_HR(hr, S_OK);
5971
5972     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
5973     EXPECT_HR(hr, S_OK);
5974
5975     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
5976     EXPECT_HR(hr, S_OK);
5977     IXMLDOMAttribute_Release(attr);
5978
5979     IXMLDOMElement_Release(elem);
5980     IXMLDOMNode_Release(rootNode);
5981
5982     /* and now check for attribute in original document */
5983     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
5984     EXPECT_HR(hr, S_OK);
5985
5986     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
5987     EXPECT_HR(hr, S_OK);
5988     IXMLDOMAttribute_Release(attr);
5989
5990     IXMLDOMElement_Release(elem);
5991
5992     /* attach node from list to another document */
5993     doc2 = create_document(&IID_IXMLDOMDocument);
5994
5995     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5996     EXPECT_HR(hr, S_OK);
5997     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5998
5999     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
6000     EXPECT_HR(hr, S_OK);
6001     EXPECT_LIST_LEN(list, 1);
6002
6003     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
6004     EXPECT_HR(hr, S_OK);
6005     EXPECT_REF(rootNode, 1);
6006
6007     hr = IXMLDOMDocument_appendChild(doc2, rootNode, NULL);
6008     EXPECT_HR(hr, S_OK);
6009     EXPECT_REF(rootNode, 1);
6010     EXPECT_REF(doc2, 1);
6011     EXPECT_REF(list, 1);
6012
6013     EXPECT_LIST_LEN(list, 1);
6014
6015     IXMLDOMNode_Release(rootNode);
6016     IXMLDOMNodeList_Release(list);
6017     IXMLDOMDocument_Release(doc2);
6018     IXMLDOMDocument2_Release(doc);
6019
6020     while (ptr->clsid)
6021     {
6022         hr = CoCreateInstance(ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
6023         if (hr != S_OK)
6024         {
6025             win_skip("can't create instance of %s\n", ptr->name);
6026             ptr++;
6027             continue;
6028         }
6029
6030         hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
6031         EXPECT_HR(hr, S_OK);
6032         ok(b == VARIANT_TRUE, "failed to load, %s\n", ptr->name);
6033
6034         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath"));
6035         EXPECT_HR(hr, S_OK);
6036
6037         V_VT(&var) = VT_BSTR;
6038         V_BSTR(&var) = _bstr_(ptr->ns);
6039
6040         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), var);
6041         ok(hr == ptr->hr, "got 0x%08x, for %s, %s\n", hr, ptr->name, ptr->ns);
6042
6043         V_VT(&var) = VT_EMPTY;
6044         hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var);
6045         EXPECT_HR(hr, S_OK);
6046         ok(V_VT(&var) == VT_BSTR, "got wrong property type %d\n", V_VT(&var));
6047         ok(!lstrcmpW(V_BSTR(&var), _bstr_(ptr->ns)), "got wrong value %s\n", wine_dbgstr_w(V_BSTR(&var)));
6048         VariantClear(&var);
6049
6050         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list);
6051         EXPECT_HR(hr, S_OK);
6052         if (hr == S_OK)
6053             expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
6054
6055         IXMLDOMDocument2_Release(doc);
6056         ptr++;
6057     }
6058
6059     free_bstrs();
6060 }
6061
6062 static void test_cloneNode(void )
6063 {
6064     IXMLDOMDocument *doc, *doc2;
6065     VARIANT_BOOL b;
6066     IXMLDOMNodeList *pList;
6067     IXMLDOMNamedNodeMap *mapAttr;
6068     LONG length, length1;
6069     LONG attr_cnt, attr_cnt1;
6070     IXMLDOMNode *node;
6071     IXMLDOMNode *node_clone;
6072     IXMLDOMNode *node_first;
6073     HRESULT hr;
6074
6075     doc = create_document(&IID_IXMLDOMDocument);
6076     if (!doc) return;
6077
6078     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b));
6079     ok(b == VARIANT_TRUE, "failed to load XML string\n");
6080
6081     hr = IXMLDOMNode_selectSingleNode(doc, _bstr_("lc/pr"), &node);
6082     ok( hr == S_OK, "ret %08x\n", hr );
6083     ok( node != NULL, "node %p\n", node );
6084
6085     /* Check invalid parameter */
6086     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
6087     ok( hr == E_INVALIDARG, "ret %08x\n", hr );
6088
6089     /* All Children */
6090     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
6091     ok( hr == S_OK, "ret %08x\n", hr );
6092     ok( node_clone != NULL, "node %p\n", node );
6093
6094     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
6095     ok( hr == S_OK, "ret %08x\n", hr );
6096     hr = IXMLDOMNode_get_ownerDocument(node_clone, &doc2);
6097     ok( hr == S_OK, "ret %08x\n", hr );
6098     IXMLDOMDocument_Release(doc2);
6099     IXMLDOMNode_Release(node_first);
6100
6101     hr = IXMLDOMNode_get_childNodes(node, &pList);
6102     ok( hr == S_OK, "ret %08x\n", hr );
6103     length = 0;
6104     hr = IXMLDOMNodeList_get_length(pList, &length);
6105     ok( hr == S_OK, "ret %08x\n", hr );
6106     ok(length == 1, "got %d\n", length);
6107     IXMLDOMNodeList_Release(pList);
6108
6109     hr = IXMLDOMNode_get_attributes(node, &mapAttr);
6110     ok( hr == S_OK, "ret %08x\n", hr );
6111     attr_cnt = 0;
6112     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt);
6113     ok( hr == S_OK, "ret %08x\n", hr );
6114     ok(attr_cnt == 3, "got %d\n", attr_cnt);
6115     IXMLDOMNamedNodeMap_Release(mapAttr);
6116
6117     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
6118     ok( hr == S_OK, "ret %08x\n", hr );
6119     length1 = 0;
6120     hr = IXMLDOMNodeList_get_length(pList, &length1);
6121     ok(length1 == 1, "got %d\n", length1);
6122     ok( hr == S_OK, "ret %08x\n", hr );
6123     IXMLDOMNodeList_Release(pList);
6124
6125     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
6126     ok( hr == S_OK, "ret %08x\n", hr );
6127     attr_cnt1 = 0;
6128     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
6129     ok( hr == S_OK, "ret %08x\n", hr );
6130     ok(attr_cnt1 == 3, "got %d\n", attr_cnt1);
6131     IXMLDOMNamedNodeMap_Release(mapAttr);
6132
6133     ok(length == length1, "wrong Child count (%d, %d)\n", length, length1);
6134     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
6135     IXMLDOMNode_Release(node_clone);
6136
6137     /* No Children */
6138     hr = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
6139     ok( hr == S_OK, "ret %08x\n", hr );
6140     ok( node_clone != NULL, "node %p\n", node );
6141
6142     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
6143     ok(hr == S_FALSE, "ret %08x\n", hr );
6144
6145     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
6146     ok(hr == S_OK, "ret %08x\n", hr );
6147     hr = IXMLDOMNodeList_get_length(pList, &length1);
6148     ok(hr == S_OK, "ret %08x\n", hr );
6149     ok( length1 == 0, "Length should be 0 (%d)\n", length1);
6150     IXMLDOMNodeList_Release(pList);
6151
6152     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
6153     ok(hr == S_OK, "ret %08x\n", hr );
6154     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
6155     ok(hr == S_OK, "ret %08x\n", hr );
6156     ok(attr_cnt1 == 3, "Attribute count should be 3 (%d)\n", attr_cnt1);
6157     IXMLDOMNamedNodeMap_Release(mapAttr);
6158
6159     ok(length != length1, "wrong Child count (%d, %d)\n", length, length1);
6160     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
6161     IXMLDOMNode_Release(node_clone);
6162
6163     IXMLDOMNode_Release(node);
6164     IXMLDOMDocument_Release(doc);
6165     free_bstrs();
6166 }
6167
6168 static void test_xmlTypes(void)
6169 {
6170     IXMLDOMDocument *doc;
6171     IXMLDOMElement *pRoot;
6172     HRESULT hr;
6173     IXMLDOMComment *pComment;
6174     IXMLDOMElement *pElement;
6175     IXMLDOMAttribute *pAttribute;
6176     IXMLDOMNamedNodeMap *pAttribs;
6177     IXMLDOMCDATASection *pCDataSec;
6178     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
6179     IXMLDOMDocumentFragment *pDocFrag = NULL;
6180     IXMLDOMEntityReference *pEntityRef = NULL;
6181     BSTR str;
6182     IXMLDOMNode *pNextChild;
6183     VARIANT v;
6184     LONG len = 0;
6185
6186     doc = create_document(&IID_IXMLDOMDocument);
6187     if (!doc) return;
6188
6189     pNextChild = (void*)0xdeadbeef;
6190     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
6191     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6192
6193     pNextChild = (void*)0xdeadbeef;
6194     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
6195     ok(hr == S_FALSE, "ret %08x\n", hr );
6196     ok(pNextChild == NULL, "pDocChild not NULL\n");
6197
6198     /* test previous Sibling */
6199     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
6200     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6201
6202     pNextChild = (void*)0xdeadbeef;
6203     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
6204     ok(hr == S_FALSE, "ret %08x\n", hr );
6205     ok(pNextChild == NULL, "pNextChild not NULL\n");
6206
6207     /* test get_dataType */
6208     V_VT(&v) = VT_EMPTY;
6209     hr = IXMLDOMDocument_get_dataType(doc, &v);
6210     ok(hr == S_FALSE, "ret %08x\n", hr );
6211     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
6212     VariantClear(&v);
6213
6214     /* test implementation */
6215     hr = IXMLDOMDocument_get_implementation(doc, NULL);
6216     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6217
6218     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
6219     ok(hr == S_OK, "ret %08x\n", hr );
6220     if(hr == S_OK)
6221     {
6222         VARIANT_BOOL hasFeature = VARIANT_TRUE;
6223         BSTR sEmpty = SysAllocStringLen(NULL, 0);
6224
6225         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
6226         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6227
6228         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
6229         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6230
6231         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
6232         ok(hr == S_OK, "ret %08x\n", hr );
6233         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
6234
6235         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
6236         ok(hr == S_OK, "ret %08x\n", hr );
6237         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
6238
6239         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
6240         ok(hr == S_OK, "ret %08x\n", hr );
6241         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
6242
6243         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
6244         ok(hr == S_OK, "ret %08x\n", hr );
6245         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
6246
6247         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
6248         ok(hr == S_OK, "ret %08x\n", hr );
6249         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
6250
6251         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
6252         ok(hr == S_OK, "ret %08x\n", hr );
6253         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
6254
6255         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
6256         ok(hr == S_OK, "ret %08x\n", hr );
6257         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
6258
6259         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
6260         ok(hr == S_OK, "ret %08x\n", hr );
6261         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
6262
6263         SysFreeString(sEmpty);
6264         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
6265     }
6266
6267     pRoot = (IXMLDOMElement*)0x1;
6268     hr = IXMLDOMDocument_createElement(doc, NULL, &pRoot);
6269     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6270     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
6271
6272     pRoot = (IXMLDOMElement*)0x1;
6273     hr = IXMLDOMDocument_createElement(doc, _bstr_(""), &pRoot);
6274     ok(hr == E_FAIL, "ret %08x\n", hr );
6275     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
6276
6277     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
6278     ok(hr == S_OK, "ret %08x\n", hr );
6279     if(hr == S_OK)
6280     {
6281         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
6282         ok(hr == S_OK, "ret %08x\n", hr );
6283         if(hr == S_OK)
6284         {
6285             /* Comment */
6286             str = SysAllocString(szComment);
6287             hr = IXMLDOMDocument_createComment(doc, str, &pComment);
6288             SysFreeString(str);
6289             ok(hr == S_OK, "ret %08x\n", hr );
6290             if(hr == S_OK)
6291             {
6292                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
6293                 ok(hr == S_OK, "ret %08x\n", hr );
6294
6295                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
6296                 ok(hr == S_OK, "ret %08x\n", hr );
6297                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
6298                 SysFreeString(str);
6299
6300                 hr = IXMLDOMComment_get_xml(pComment, &str);
6301                 ok(hr == S_OK, "ret %08x\n", hr );
6302                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
6303                 SysFreeString(str);
6304
6305                 /* put data Tests */
6306                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
6307                 ok(hr == S_OK, "ret %08x\n", hr );
6308
6309                 /* get data Tests */
6310                 hr = IXMLDOMComment_get_data(pComment, &str);
6311                 ok(hr == S_OK, "ret %08x\n", hr );
6312                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
6313                 SysFreeString(str);
6314
6315                 /* Confirm XML text is good */
6316                 hr = IXMLDOMComment_get_xml(pComment, &str);
6317                 ok(hr == S_OK, "ret %08x\n", hr );
6318                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
6319                 SysFreeString(str);
6320
6321                 /* Confirm we get the put_data Text back */
6322                 hr = IXMLDOMComment_get_text(pComment, &str);
6323                 ok(hr == S_OK, "ret %08x\n", hr );
6324                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
6325                 SysFreeString(str);
6326
6327                 /* test length property */
6328                 hr = IXMLDOMComment_get_length(pComment, &len);
6329                 ok(hr == S_OK, "ret %08x\n", hr );
6330                 ok(len == 21, "expected 21 got %d\n", len);
6331
6332                 /* test substringData */
6333                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
6334                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6335
6336                 /* test substringData - Invalid offset */
6337                 str = (BSTR)&szElement;
6338                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
6339                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6340                 ok( str == NULL, "incorrect string\n");
6341
6342                 /* test substringData - Invalid offset */
6343                 str = (BSTR)&szElement;
6344                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
6345                 ok(hr == S_FALSE, "ret %08x\n", hr );
6346                 ok( str == NULL, "incorrect string\n");
6347
6348                 /* test substringData - Invalid size */
6349                 str = (BSTR)&szElement;
6350                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
6351                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6352                 ok( str == NULL, "incorrect string\n");
6353
6354                 /* test substringData - Invalid size */
6355                 str = (BSTR)&szElement;
6356                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
6357                 ok(hr == S_FALSE, "ret %08x\n", hr );
6358                 ok( str == NULL, "incorrect string\n");
6359
6360                 /* test substringData - Start of string */
6361                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
6362                 ok(hr == S_OK, "ret %08x\n", hr );
6363                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
6364                 SysFreeString(str);
6365
6366                 /* test substringData - Middle of string */
6367                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
6368                 ok(hr == S_OK, "ret %08x\n", hr );
6369                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
6370                 SysFreeString(str);
6371
6372                 /* test substringData - End of string */
6373                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
6374                 ok(hr == S_OK, "ret %08x\n", hr );
6375                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
6376                 SysFreeString(str);
6377
6378                 /* test appendData */
6379                 hr = IXMLDOMComment_appendData(pComment, NULL);
6380                 ok(hr == S_OK, "ret %08x\n", hr );
6381
6382                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
6383                 ok(hr == S_OK, "ret %08x\n", hr );
6384
6385                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
6386                 ok(hr == S_OK, "ret %08x\n", hr );
6387
6388                 hr = IXMLDOMComment_get_text(pComment, &str);
6389                 ok(hr == S_OK, "ret %08x\n", hr );
6390                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6391                 SysFreeString(str);
6392
6393                 /* test insertData */
6394                 str = SysAllocStringLen(NULL, 0);
6395                 hr = IXMLDOMComment_insertData(pComment, -1, str);
6396                 ok(hr == S_OK, "ret %08x\n", hr );
6397
6398                 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
6399                 ok(hr == S_OK, "ret %08x\n", hr );
6400
6401                 hr = IXMLDOMComment_insertData(pComment, 1000, str);
6402                 ok(hr == S_OK, "ret %08x\n", hr );
6403
6404                 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
6405                 ok(hr == S_OK, "ret %08x\n", hr );
6406
6407                 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
6408                 ok(hr == S_OK, "ret %08x\n", hr );
6409
6410                 hr = IXMLDOMComment_insertData(pComment, 0, str);
6411                 ok(hr == S_OK, "ret %08x\n", hr );
6412                 SysFreeString(str);
6413
6414                 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
6415                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6416
6417                 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
6418                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6419
6420                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
6421                 ok(hr == S_OK, "ret %08x\n", hr );
6422
6423                 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
6424                 ok(hr == S_OK, "ret %08x\n", hr );
6425
6426                 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
6427                 ok(hr == S_OK, "ret %08x\n", hr );
6428
6429                 hr = IXMLDOMComment_get_text(pComment, &str);
6430                 ok(hr == S_OK, "ret %08x\n", hr );
6431                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6432                 SysFreeString(str);
6433
6434                 /* delete data */
6435                 /* invalid arguments */
6436                 hr = IXMLDOMComment_deleteData(pComment, -1, 1);
6437                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6438
6439                 hr = IXMLDOMComment_deleteData(pComment, 0, 0);
6440                 ok(hr == S_OK, "ret %08x\n", hr );
6441
6442                 hr = IXMLDOMComment_deleteData(pComment, 0, -1);
6443                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6444
6445                 hr = IXMLDOMComment_get_length(pComment, &len);
6446                 ok(hr == S_OK, "ret %08x\n", hr );
6447                 ok(len == 43, "expected 43 got %d\n", len);
6448
6449                 hr = IXMLDOMComment_deleteData(pComment, len, 1);
6450                 ok(hr == S_OK, "ret %08x\n", hr );
6451
6452                 hr = IXMLDOMComment_deleteData(pComment, len+1, 1);
6453                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6454
6455                 /* delete from start */
6456                 hr = IXMLDOMComment_deleteData(pComment, 0, 5);
6457                 ok(hr == S_OK, "ret %08x\n", hr );
6458
6459                 hr = IXMLDOMComment_get_length(pComment, &len);
6460                 ok(hr == S_OK, "ret %08x\n", hr );
6461                 ok(len == 38, "expected 38 got %d\n", len);
6462
6463                 hr = IXMLDOMComment_get_text(pComment, &str);
6464                 ok(hr == S_OK, "ret %08x\n", hr );
6465                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6466                 SysFreeString(str);
6467
6468                 /* delete from end */
6469                 hr = IXMLDOMComment_deleteData(pComment, 35, 3);
6470                 ok(hr == S_OK, "ret %08x\n", hr );
6471
6472                 hr = IXMLDOMComment_get_length(pComment, &len);
6473                 ok(hr == S_OK, "ret %08x\n", hr );
6474                 ok(len == 35, "expected 35 got %d\n", len);
6475
6476                 hr = IXMLDOMComment_get_text(pComment, &str);
6477                 ok(hr == S_OK, "ret %08x\n", hr );
6478                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6479                 SysFreeString(str);
6480
6481                 /* delete from inside */
6482                 hr = IXMLDOMComment_deleteData(pComment, 1, 33);
6483                 ok(hr == S_OK, "ret %08x\n", hr );
6484
6485                 hr = IXMLDOMComment_get_length(pComment, &len);
6486                 ok(hr == S_OK, "ret %08x\n", hr );
6487                 ok(len == 2, "expected 2 got %d\n", len);
6488
6489                 hr = IXMLDOMComment_get_text(pComment, &str);
6490                 ok(hr == S_OK, "ret %08x\n", hr );
6491                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6492                 SysFreeString(str);
6493
6494                 /* delete whole data ... */
6495                 hr = IXMLDOMComment_get_length(pComment, &len);
6496                 ok(hr == S_OK, "ret %08x\n", hr );
6497
6498                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
6499                 ok(hr == S_OK, "ret %08x\n", hr );
6500                 /* ... and try again with empty string */
6501                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
6502                 ok(hr == S_OK, "ret %08x\n", hr );
6503
6504                 /* ::replaceData() */
6505                 V_VT(&v) = VT_BSTR;
6506                 V_BSTR(&v) = SysAllocString(szstr1);
6507                 hr = IXMLDOMComment_put_nodeValue(pComment, v);
6508                 ok(hr == S_OK, "ret %08x\n", hr );
6509                 VariantClear(&v);
6510
6511                 hr = IXMLDOMComment_replaceData(pComment, 6, 0, NULL);
6512                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6513                 hr = IXMLDOMComment_get_text(pComment, &str);
6514                 ok(hr == S_OK, "ret %08x\n", hr );
6515                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6516                 SysFreeString(str);
6517
6518                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, NULL);
6519                 ok(hr == S_OK, "ret %08x\n", hr );
6520                 hr = IXMLDOMComment_get_text(pComment, &str);
6521                 ok(hr == S_OK, "ret %08x\n", hr );
6522                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6523                 SysFreeString(str);
6524
6525                 /* NULL pointer means delete */
6526                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, NULL);
6527                 ok(hr == S_OK, "ret %08x\n", hr );
6528                 hr = IXMLDOMComment_get_text(pComment, &str);
6529                 ok(hr == S_OK, "ret %08x\n", hr );
6530                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6531                 SysFreeString(str);
6532
6533                 /* empty string means delete */
6534                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_(""));
6535                 ok(hr == S_OK, "ret %08x\n", hr );
6536                 hr = IXMLDOMComment_get_text(pComment, &str);
6537                 ok(hr == S_OK, "ret %08x\n", hr );
6538                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6539                 SysFreeString(str);
6540
6541                 /* zero count means insert */
6542                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, _bstr_("a"));
6543                 ok(hr == S_OK, "ret %08x\n", hr );
6544                 hr = IXMLDOMComment_get_text(pComment, &str);
6545                 ok(hr == S_OK, "ret %08x\n", hr );
6546                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6547                 SysFreeString(str);
6548
6549                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, NULL);
6550                 ok(hr == S_OK, "ret %08x\n", hr );
6551
6552                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("m"));
6553                 ok(hr == S_OK, "ret %08x\n", hr );
6554                 hr = IXMLDOMComment_get_text(pComment, &str);
6555                 ok(hr == S_OK, "ret %08x\n", hr );
6556                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6557                 SysFreeString(str);
6558
6559                 /* nonempty string, count greater than its length */
6560                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, _bstr_("a1.2"));
6561                 ok(hr == S_OK, "ret %08x\n", hr );
6562                 hr = IXMLDOMComment_get_text(pComment, &str);
6563                 ok(hr == S_OK, "ret %08x\n", hr );
6564                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6565                 SysFreeString(str);
6566
6567                 /* nonempty string, count less than its length */
6568                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_("wine"));
6569                 ok(hr == S_OK, "ret %08x\n", hr );
6570                 hr = IXMLDOMComment_get_text(pComment, &str);
6571                 ok(hr == S_OK, "ret %08x\n", hr );
6572                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6573                 SysFreeString(str);
6574
6575                 IXMLDOMComment_Release(pComment);
6576             }
6577
6578             /* Element */
6579             str = SysAllocString(szElement);
6580             hr = IXMLDOMDocument_createElement(doc, str, &pElement);
6581             SysFreeString(str);
6582             ok(hr == S_OK, "ret %08x\n", hr );
6583             if(hr == S_OK)
6584             {
6585                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6586                 ok(hr == S_OK, "ret %08x\n", hr );
6587
6588                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
6589                 ok(hr == S_OK, "ret %08x\n", hr );
6590                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
6591                 SysFreeString(str);
6592
6593                 hr = IXMLDOMElement_get_xml(pElement, &str);
6594                 ok(hr == S_OK, "ret %08x\n", hr );
6595                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
6596                 SysFreeString(str);
6597
6598                 /* Attribute */
6599                 pAttribute = (IXMLDOMAttribute*)0x1;
6600                 hr = IXMLDOMDocument_createAttribute(doc, NULL, &pAttribute);
6601                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6602                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
6603
6604                 pAttribute = (IXMLDOMAttribute*)0x1;
6605                 hr = IXMLDOMDocument_createAttribute(doc, _bstr_(""), &pAttribute);
6606                 ok(hr == E_FAIL, "ret %08x\n", hr );
6607                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
6608
6609                 str = SysAllocString(szAttribute);
6610                 hr = IXMLDOMDocument_createAttribute(doc, str, &pAttribute);
6611                 SysFreeString(str);
6612                 ok(hr == S_OK, "ret %08x\n", hr );
6613                 if(hr == S_OK)
6614                 {
6615                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
6616
6617                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, NULL);
6618                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6619
6620                     pNextChild = (IXMLDOMNode *)0x1;
6621                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, &pNextChild);
6622                     ok(hr == S_FALSE, "ret %08x\n", hr );
6623                     ok(pNextChild == NULL, "pNextChild not NULL\n");
6624
6625                     /* test Previous Sibling*/
6626                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, NULL);
6627                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6628
6629                     pNextChild = (IXMLDOMNode *)0x1;
6630                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, &pNextChild);
6631                     ok(hr == S_FALSE, "ret %08x\n", hr );
6632                     ok(pNextChild == NULL, "pNextChild not NULL\n");
6633
6634                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttribute, &pNewChild);
6635                     ok(hr == E_FAIL, "ret %08x\n", hr );
6636                     ok(pNewChild == NULL, "pNewChild not NULL\n");
6637
6638                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
6639                     ok(hr == S_OK, "ret %08x\n", hr );
6640                     if ( hr == S_OK )
6641                     {
6642                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttribute, NULL );
6643                         ok(hr == S_OK, "ret %08x\n", hr );
6644
6645                         IXMLDOMNamedNodeMap_Release(pAttribs);
6646                     }
6647
6648                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
6649                     ok(hr == S_OK, "ret %08x\n", hr );
6650                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
6651                     SysFreeString(str);
6652
6653                     /* test nodeName */
6654                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
6655                     ok(hr == S_OK, "ret %08x\n", hr );
6656                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
6657                     SysFreeString(str);
6658
6659                     /* test name property */
6660                     hr = IXMLDOMAttribute_get_name(pAttribute, &str);
6661                     ok(hr == S_OK, "ret %08x\n", hr );
6662                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
6663                     SysFreeString(str);
6664
6665                     hr = IXMLDOMAttribute_get_xml(pAttribute, &str);
6666                     ok(hr == S_OK, "ret %08x\n", hr );
6667                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
6668                     SysFreeString(str);
6669
6670                     IXMLDOMAttribute_Release(pAttribute);
6671
6672                     /* Check Element again with the Add Attribute*/
6673                     hr = IXMLDOMElement_get_xml(pElement, &str);
6674                     ok(hr == S_OK, "ret %08x\n", hr );
6675                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
6676                     SysFreeString(str);
6677                 }
6678
6679                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
6680                 ok(hr == S_OK, "ret %08x\n", hr );
6681
6682                 hr = IXMLDOMElement_get_xml(pElement, &str);
6683                 ok(hr == S_OK, "ret %08x\n", hr );
6684                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
6685                 SysFreeString(str);
6686
6687                 /* Test for reversible escaping */
6688                 str = SysAllocString( szStrangeChars );
6689                 hr = IXMLDOMElement_put_text(pElement, str);
6690                 ok(hr == S_OK, "ret %08x\n", hr );
6691                 SysFreeString( str );
6692
6693                 hr = IXMLDOMElement_get_xml(pElement, &str);
6694                 ok(hr == S_OK, "ret %08x\n", hr );
6695                 ok( !lstrcmpW( str, szElementXML4 ), "incorrect element xml\n");
6696                 SysFreeString(str);
6697
6698                 hr = IXMLDOMElement_get_text(pElement, &str);
6699                 ok(hr == S_OK, "ret %08x\n", hr );
6700                 ok( !lstrcmpW( str, szStrangeChars ), "incorrect element text\n");
6701                 SysFreeString(str);
6702
6703                 IXMLDOMElement_Release(pElement);
6704             }
6705
6706             /* CData Section */
6707             str = SysAllocString(szCData);
6708             hr = IXMLDOMDocument_createCDATASection(doc, str, NULL);
6709             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6710
6711             hr = IXMLDOMDocument_createCDATASection(doc, str, &pCDataSec);
6712             SysFreeString(str);
6713             ok(hr == S_OK, "ret %08x\n", hr );
6714             if(hr == S_OK)
6715             {
6716                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
6717                 VARIANT var;
6718
6719                 VariantInit(&var);
6720
6721                 hr = IXMLDOMCDATASection_QueryInterface(pCDataSec, &IID_IXMLDOMElement, (void**)&pElement);
6722                 ok(hr == E_NOINTERFACE, "ret %08x\n", hr);
6723
6724                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
6725                 ok(hr == S_OK, "ret %08x\n", hr );
6726
6727                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
6728                 ok(hr == S_OK, "ret %08x\n", hr );
6729                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
6730                 SysFreeString(str);
6731
6732                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
6733                 ok(hr == S_OK, "ret %08x\n", hr );
6734                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
6735                 SysFreeString(str);
6736
6737                 /* test lastChild */
6738                 pNextChild = (IXMLDOMNode*)0x1;
6739                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
6740                 ok(hr == S_FALSE, "ret %08x\n", hr );
6741                 ok(pNextChild == NULL, "pNextChild not NULL\n");
6742
6743                 /* put data Tests */
6744                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
6745                 ok(hr == S_OK, "ret %08x\n", hr );
6746
6747                 /* Confirm XML text is good */
6748                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
6749                 ok(hr == S_OK, "ret %08x\n", hr );
6750                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
6751                 SysFreeString(str);
6752
6753                 /* Confirm we get the put_data Text back */
6754                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6755                 ok(hr == S_OK, "ret %08x\n", hr );
6756                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
6757                 SysFreeString(str);
6758
6759                 /* test length property */
6760                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6761                 ok(hr == S_OK, "ret %08x\n", hr );
6762                 ok(len == 21, "expected 21 got %d\n", len);
6763
6764                 /* test get data */
6765                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
6766                 ok(hr == S_OK, "ret %08x\n", hr );
6767                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
6768                 SysFreeString(str);
6769
6770                 /* test substringData */
6771                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
6772                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6773
6774                 /* test substringData - Invalid offset */
6775                 str = (BSTR)&szElement;
6776                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
6777                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6778                 ok( str == NULL, "incorrect string\n");
6779
6780                 /* test substringData - Invalid offset */
6781                 str = (BSTR)&szElement;
6782                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
6783                 ok(hr == S_FALSE, "ret %08x\n", hr );
6784                 ok( str == NULL, "incorrect string\n");
6785
6786                 /* test substringData - Invalid size */
6787                 str = (BSTR)&szElement;
6788                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
6789                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6790                 ok( str == NULL, "incorrect string\n");
6791
6792                 /* test substringData - Invalid size */
6793                 str = (BSTR)&szElement;
6794                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
6795                 ok(hr == S_FALSE, "ret %08x\n", hr );
6796                 ok( str == NULL, "incorrect string\n");
6797
6798                 /* test substringData - Start of string */
6799                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
6800                 ok(hr == S_OK, "ret %08x\n", hr );
6801                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
6802                 SysFreeString(str);
6803
6804                 /* test substringData - Middle of string */
6805                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
6806                 ok(hr == S_OK, "ret %08x\n", hr );
6807                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
6808                 SysFreeString(str);
6809
6810                 /* test substringData - End of string */
6811                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
6812                 ok(hr == S_OK, "ret %08x\n", hr );
6813                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
6814                 SysFreeString(str);
6815
6816                 /* test appendData */
6817                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
6818                 ok(hr == S_OK, "ret %08x\n", hr );
6819
6820                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
6821                 ok(hr == S_OK, "ret %08x\n", hr );
6822
6823                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
6824                 ok(hr == S_OK, "ret %08x\n", hr );
6825
6826                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6827                 ok(hr == S_OK, "ret %08x\n", hr );
6828                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6829                 SysFreeString(str);
6830
6831                 /* test insertData */
6832                 str = SysAllocStringLen(NULL, 0);
6833                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
6834                 ok(hr == S_OK, "ret %08x\n", hr );
6835
6836                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
6837                 ok(hr == S_OK, "ret %08x\n", hr );
6838
6839                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
6840                 ok(hr == S_OK, "ret %08x\n", hr );
6841
6842                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
6843                 ok(hr == S_OK, "ret %08x\n", hr );
6844
6845                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
6846                 ok(hr == S_OK, "ret %08x\n", hr );
6847
6848                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
6849                 ok(hr == S_OK, "ret %08x\n", hr );
6850                 SysFreeString(str);
6851
6852                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
6853                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6854
6855                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
6856                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6857
6858                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
6859                 ok(hr == S_OK, "ret %08x\n", hr );
6860
6861                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
6862                 ok(hr == S_OK, "ret %08x\n", hr );
6863
6864                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
6865                 ok(hr == S_OK, "ret %08x\n", hr );
6866
6867                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6868                 ok(hr == S_OK, "ret %08x\n", hr );
6869                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6870                 SysFreeString(str);
6871
6872                 /* delete data */
6873                 /* invalid arguments */
6874                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, -1, 1);
6875                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6876
6877                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 0);
6878                 ok(hr == S_OK, "ret %08x\n", hr );
6879
6880                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, -1);
6881                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6882
6883                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6884                 ok(hr == S_OK, "ret %08x\n", hr );
6885                 ok(len == 43, "expected 43 got %d\n", len);
6886
6887                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len, 1);
6888                 ok(hr == S_OK, "ret %08x\n", hr );
6889
6890                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len+1, 1);
6891                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6892
6893                 /* delete from start */
6894                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 5);
6895                 ok(hr == S_OK, "ret %08x\n", hr );
6896
6897                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6898                 ok(hr == S_OK, "ret %08x\n", hr );
6899                 ok(len == 38, "expected 38 got %d\n", len);
6900
6901                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6902                 ok(hr == S_OK, "ret %08x\n", hr );
6903                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6904                 SysFreeString(str);
6905
6906                 /* delete from end */
6907                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 35, 3);
6908                 ok(hr == S_OK, "ret %08x\n", hr );
6909
6910                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6911                 ok(hr == S_OK, "ret %08x\n", hr );
6912                 ok(len == 35, "expected 35 got %d\n", len);
6913
6914                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6915                 ok(hr == S_OK, "ret %08x\n", hr );
6916                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6917                 SysFreeString(str);
6918
6919                 /* delete from inside */
6920                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 1, 33);
6921                 ok(hr == S_OK, "ret %08x\n", hr );
6922
6923                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6924                 ok(hr == S_OK, "ret %08x\n", hr );
6925                 ok(len == 2, "expected 2 got %d\n", len);
6926
6927                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6928                 ok(hr == S_OK, "ret %08x\n", hr );
6929                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6930                 SysFreeString(str);
6931
6932                 /* delete whole data ... */
6933                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6934                 ok(hr == S_OK, "ret %08x\n", hr );
6935
6936                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
6937                 ok(hr == S_OK, "ret %08x\n", hr );
6938
6939                 /* ... and try again with empty string */
6940                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
6941                 ok(hr == S_OK, "ret %08x\n", hr );
6942
6943                 /* ::replaceData() */
6944                 V_VT(&v) = VT_BSTR;
6945                 V_BSTR(&v) = SysAllocString(szstr1);
6946                 hr = IXMLDOMCDATASection_put_nodeValue(pCDataSec, v);
6947                 ok(hr == S_OK, "ret %08x\n", hr );
6948                 VariantClear(&v);
6949
6950                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 6, 0, NULL);
6951                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6952                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6953                 ok(hr == S_OK, "ret %08x\n", hr );
6954                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6955                 SysFreeString(str);
6956
6957                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, NULL);
6958                 ok(hr == S_OK, "ret %08x\n", hr );
6959                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6960                 ok(hr == S_OK, "ret %08x\n", hr );
6961                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6962                 SysFreeString(str);
6963
6964                 /* NULL pointer means delete */
6965                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, NULL);
6966                 ok(hr == S_OK, "ret %08x\n", hr );
6967                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6968                 ok(hr == S_OK, "ret %08x\n", hr );
6969                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6970                 SysFreeString(str);
6971
6972                 /* empty string means delete */
6973                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_(""));
6974                 ok(hr == S_OK, "ret %08x\n", hr );
6975                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6976                 ok(hr == S_OK, "ret %08x\n", hr );
6977                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6978                 SysFreeString(str);
6979
6980                 /* zero count means insert */
6981                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, _bstr_("a"));
6982                 ok(hr == S_OK, "ret %08x\n", hr );
6983                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6984                 ok(hr == S_OK, "ret %08x\n", hr );
6985                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6986                 SysFreeString(str);
6987
6988                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, NULL);
6989                 ok(hr == S_OK, "ret %08x\n", hr );
6990
6991                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("m"));
6992                 ok(hr == S_OK, "ret %08x\n", hr );
6993                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6994                 ok(hr == S_OK, "ret %08x\n", hr );
6995                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6996                 SysFreeString(str);
6997
6998                 /* nonempty string, count greater than its length */
6999                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, _bstr_("a1.2"));
7000                 ok(hr == S_OK, "ret %08x\n", hr );
7001                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
7002                 ok(hr == S_OK, "ret %08x\n", hr );
7003                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
7004                 SysFreeString(str);
7005
7006                 /* nonempty string, count less than its length */
7007                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_("wine"));
7008                 ok(hr == S_OK, "ret %08x\n", hr );
7009                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
7010                 ok(hr == S_OK, "ret %08x\n", hr );
7011                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
7012                 SysFreeString(str);
7013
7014                 IXMLDOMCDATASection_Release(pCDataSec);
7015             }
7016
7017             /* Document Fragments */
7018             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
7019             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7020
7021             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
7022             ok(hr == S_OK, "ret %08x\n", hr );
7023             if(hr == S_OK)
7024             {
7025                 IXMLDOMNode *node;
7026
7027                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, NULL);
7028                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7029
7030                 node = (IXMLDOMNode *)0x1;
7031                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, &node);
7032                 ok(hr == S_FALSE, "ret %08x\n", hr );
7033                 ok(node == NULL, "expected NULL, got %p\n", node);
7034
7035                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
7036                 ok(hr == S_OK, "ret %08x\n", hr );
7037
7038                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
7039                 ok(hr == S_OK, "ret %08x\n", hr );
7040                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
7041                 SysFreeString(str);
7042
7043                 /* test next Sibling*/
7044                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
7045                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7046
7047                 node = (IXMLDOMNode *)0x1;
7048                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &node);
7049                 ok(hr == S_FALSE, "ret %08x\n", hr );
7050                 ok(node == NULL, "next sibling not NULL\n");
7051
7052                 /* test Previous Sibling*/
7053                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
7054                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7055
7056                 node = (IXMLDOMNode *)0x1;
7057                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &node);
7058                 ok(hr == S_FALSE, "ret %08x\n", hr );
7059                 ok(node == NULL, "previous sibling not NULL\n");
7060
7061                 IXMLDOMDocumentFragment_Release(pDocFrag);
7062             }
7063
7064             /* Entity References */
7065             hr = IXMLDOMDocument_createEntityReference(doc, NULL, &pEntityRef);
7066             ok(hr == E_FAIL, "ret %08x\n", hr );
7067             hr = IXMLDOMDocument_createEntityReference(doc, _bstr_(""), &pEntityRef);
7068             ok(hr == E_FAIL, "ret %08x\n", hr );
7069
7070             str = SysAllocString(szEntityRef);
7071             hr = IXMLDOMDocument_createEntityReference(doc, str, NULL);
7072             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7073
7074             hr = IXMLDOMDocument_createEntityReference(doc, str, &pEntityRef);
7075             SysFreeString(str);
7076             ok(hr == S_OK, "ret %08x\n", hr );
7077             if(hr == S_OK)
7078             {
7079                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
7080                 ok(hr == S_OK, "ret %08x\n", hr );
7081
7082                 /* test get_xml*/
7083                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
7084                 ok(hr == S_OK, "ret %08x\n", hr );
7085                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
7086                 SysFreeString(str);
7087
7088                 IXMLDOMEntityReference_Release(pEntityRef);
7089             }
7090
7091             IXMLDOMElement_Release( pRoot );
7092         }
7093     }
7094
7095     IXMLDOMDocument_Release(doc);
7096
7097     free_bstrs();
7098 }
7099
7100 typedef struct {
7101     const char *name;
7102     const char *type;
7103     HRESULT hr;
7104 } put_datatype_t;
7105
7106 /* Type test for elements only. Name passed into put_dataType is case-insensitive.
7107    So many of the names have been changed to reflect this. */
7108 static put_datatype_t put_datatype_data[] = {
7109     { "test_inval",      "abcdefg",     E_FAIL },
7110     { "test_bool",       "Boolean",     S_OK },
7111     { "test_string",     "String",      S_OK },
7112     { "test_number",     "number",      S_OK },
7113     { "test_int",        "InT",         S_OK },
7114     { "test_fixed",      "fixed.14.4",  S_OK },
7115     { "test_datetime",   "DateTime",    S_OK },
7116     { "test_datetimetz", "DateTime.tz", S_OK },
7117     { "test_date",       "Date",        S_OK },
7118     { "test_time",       "Time",        S_OK },
7119     { "test_timetz",     "Time.tz",     S_OK },
7120     { "test_I1",         "I1",          S_OK },
7121     { "test_I2",         "I2",          S_OK },
7122     { "test_I4",         "I4",          S_OK },
7123     { "test_UI1",        "UI1",         S_OK },
7124     { "test_UI2",        "UI2",         S_OK },
7125     { "test_UI4",        "UI4",         S_OK },
7126     { "test_r4",         "r4",          S_OK },
7127     { "test_r8",         "r8",          S_OK },
7128     { "test_float",      "float",       S_OK },
7129     { "test_uuid",       "UuId",        S_OK },
7130     { "test_binhex",     "bin.hex",     S_OK },
7131     { "test_binbase64",  "bin.base64",  S_OK },
7132     { NULL }
7133 };
7134
7135 typedef struct {
7136     DOMNodeType type;
7137     HRESULT hr;
7138 } put_datatype_notype_t;
7139
7140 static put_datatype_notype_t put_dt_notype[] = {
7141     { NODE_PROCESSING_INSTRUCTION, E_FAIL },
7142     { NODE_DOCUMENT_FRAGMENT,      E_FAIL },
7143     { NODE_ENTITY_REFERENCE,       E_FAIL },
7144     { NODE_CDATA_SECTION,          E_FAIL },
7145     { NODE_COMMENT,                E_FAIL },
7146     { NODE_INVALID }
7147 };
7148
7149 static void test_put_dataType( void )
7150 {
7151     const put_datatype_notype_t *ptr2 = put_dt_notype;
7152     const put_datatype_t *ptr = put_datatype_data;
7153     IXMLDOMElement *root, *element;
7154     BSTR nameW, type1W, type2W;
7155     IXMLDOMDocument *doc;
7156     HRESULT hr;
7157
7158     doc = create_document(&IID_IXMLDOMDocument);
7159     if (!doc) return;
7160
7161     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), NULL);
7162     EXPECT_HR(hr, E_INVALIDARG);
7163
7164     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
7165     EXPECT_HR(hr, S_OK);
7166
7167     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
7168     EXPECT_HR(hr, S_OK);
7169
7170     hr = IXMLDOMElement_put_dataType(root, NULL);
7171     EXPECT_HR(hr, E_INVALIDARG);
7172
7173     while (ptr->name)
7174     {
7175         hr = IXMLDOMDocument_createElement(doc, _bstr_(ptr->name), &element);
7176         EXPECT_HR(hr, S_OK);
7177         if(hr == S_OK)
7178         {
7179             hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
7180             EXPECT_HR(hr, S_OK);
7181
7182             hr = IXMLDOMElement_put_dataType(element, _bstr_(ptr->type));
7183             ok(hr == ptr->hr, "failed for %s:%s, 0x%08x\n", ptr->name, ptr->type, ptr->hr);
7184
7185             IXMLDOMElement_Release(element);
7186         }
7187         ptr++;
7188     }
7189
7190     /* check changing types */
7191     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &element);
7192     EXPECT_HR(hr, S_OK);
7193
7194     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
7195     EXPECT_HR(hr, S_OK);
7196
7197     hr = IXMLDOMElement_put_dataType(element, _bstr_("DateTime.tz"));
7198     EXPECT_HR(hr, S_OK);
7199
7200     hr = IXMLDOMElement_put_dataType(element, _bstr_("string"));
7201     EXPECT_HR(hr, S_OK);
7202
7203     IXMLDOMElement_Release(element);
7204
7205     /* try to set type for node without a type */
7206     nameW  = _bstr_("testname");
7207     type1W = _bstr_("string");
7208     type2W = _bstr_("number");
7209     while (ptr2->type != NODE_INVALID)
7210     {
7211         IXMLDOMNode *node;
7212         VARIANT type;
7213
7214         V_VT(&type) = VT_I2;
7215         V_I2(&type) = ptr2->type;
7216
7217         hr = IXMLDOMDocument_createNode(doc, type, nameW, NULL, &node);
7218         EXPECT_HR(hr, S_OK);
7219         if(hr == S_OK)
7220         {
7221             hr = IXMLDOMElement_appendChild(root, node, NULL);
7222             EXPECT_HR(hr, S_OK);
7223
7224             hr = IXMLDOMNode_put_dataType(node, NULL);
7225             EXPECT_HR(hr, E_INVALIDARG);
7226
7227             hr = IXMLDOMNode_put_dataType(node, type1W);
7228             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
7229             hr = IXMLDOMNode_put_dataType(node, type2W);
7230             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
7231
7232             IXMLDOMNode_Release(node);
7233         }
7234         ptr2++;
7235     }
7236
7237     IXMLDOMElement_Release(root);
7238     IXMLDOMDocument_Release(doc);
7239     free_bstrs();
7240 }
7241
7242 static void test_save(void)
7243 {
7244     IXMLDOMDocument *doc, *doc2;
7245     IXMLDOMElement *root;
7246     BSTR sOrig, sNew, filename;
7247     char buffer[100];
7248     IStream *stream;
7249     HGLOBAL global;
7250     VARIANT_BOOL b;
7251     DWORD read = 0;
7252     VARIANT dest;
7253     HANDLE hfile;
7254     HRESULT hr;
7255     char *ptr;
7256
7257     doc = create_document(&IID_IXMLDOMDocument);
7258     if (!doc) return;
7259
7260     doc2 = create_document(&IID_IXMLDOMDocument);
7261     if (!doc2)
7262     {
7263         IXMLDOMDocument_Release(doc);
7264         return;
7265     }
7266
7267     /* save to IXMLDOMDocument */
7268     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
7269     EXPECT_HR(hr, S_OK);
7270
7271     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
7272     EXPECT_HR(hr, S_OK);
7273
7274     V_VT(&dest) = VT_UNKNOWN;
7275     V_UNKNOWN(&dest) = (IUnknown*)doc2;
7276
7277     hr = IXMLDOMDocument_save(doc, dest);
7278     EXPECT_HR(hr, S_OK);
7279
7280     hr = IXMLDOMDocument_get_xml(doc, &sOrig);
7281     EXPECT_HR(hr, S_OK);
7282
7283     hr = IXMLDOMDocument_get_xml(doc2, &sNew);
7284     EXPECT_HR(hr, S_OK);
7285
7286     ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as original\n");
7287
7288     SysFreeString(sOrig);
7289     SysFreeString(sNew);
7290
7291     IXMLDOMElement_Release(root);
7292     IXMLDOMDocument_Release(doc2);
7293
7294     /* save to path */
7295     V_VT(&dest) = VT_BSTR;
7296     V_BSTR(&dest) = _bstr_("test.xml");
7297
7298     hr = IXMLDOMDocument_save(doc, dest);
7299     EXPECT_HR(hr, S_OK);
7300
7301     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
7302     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
7303     if(hfile == INVALID_HANDLE_VALUE) return;
7304
7305     ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
7306     ok(read != 0, "could not read file\n");
7307     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
7308
7309     CloseHandle(hfile);
7310     DeleteFile("test.xml");
7311
7312     /* save to path VT_BSTR | VT_BYREF */
7313     filename = _bstr_("test.xml");
7314     V_VT(&dest) = VT_BSTR | VT_BYREF;
7315     V_BSTRREF(&dest) = &filename;
7316
7317     hr = IXMLDOMDocument_save(doc, dest);
7318     EXPECT_HR(hr, S_OK);
7319
7320     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
7321     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
7322     if(hfile == INVALID_HANDLE_VALUE) return;
7323
7324     if (hfile != INVALID_HANDLE_VALUE)
7325     {
7326        ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
7327        ok(read != 0, "could not read file\n");
7328        ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
7329
7330        CloseHandle(hfile);
7331        DeleteFile("test.xml");
7332     }
7333
7334     /* save to stream */
7335     V_VT(&dest) = VT_UNKNOWN;
7336     V_UNKNOWN(&dest) = (IUnknown*)&savestream;
7337
7338     hr = IXMLDOMDocument_save(doc, dest);
7339     EXPECT_HR(hr, S_OK);
7340
7341     /* loaded data contains xml declaration */
7342     hr = IXMLDOMDocument_loadXML(doc, _bstr_(win1252xml), &b);
7343     EXPECT_HR(hr, S_OK);
7344
7345     CreateStreamOnHGlobal(NULL, TRUE, &stream);
7346     V_VT(&dest) = VT_UNKNOWN;
7347     V_UNKNOWN(&dest) = (IUnknown*)stream;
7348     hr = IXMLDOMDocument_save(doc, dest);
7349     EXPECT_HR(hr, S_OK);
7350
7351     hr = GetHGlobalFromStream(stream, &global);
7352     EXPECT_HR(hr, S_OK);
7353     ptr = GlobalLock(global);
7354     ok(!memcmp(ptr, win1252decl, strlen(win1252decl)), "got wrong xml declaration\n");
7355     GlobalUnlock(global);
7356     IStream_Release(stream);
7357
7358     /* loaded data without xml declaration */
7359     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<a/>"), &b);
7360     EXPECT_HR(hr, S_OK);
7361
7362     CreateStreamOnHGlobal(NULL, TRUE, &stream);
7363     V_VT(&dest) = VT_UNKNOWN;
7364     V_UNKNOWN(&dest) = (IUnknown*)stream;
7365     hr = IXMLDOMDocument_save(doc, dest);
7366     EXPECT_HR(hr, S_OK);
7367
7368     hr = GetHGlobalFromStream(stream, &global);
7369     EXPECT_HR(hr, S_OK);
7370     ptr = GlobalLock(global);
7371     ok(ptr[0] == '<' && ptr[1] != '?', "got wrong start tag %c%c\n", ptr[0], ptr[1]);
7372     GlobalUnlock(global);
7373     IStream_Release(stream);
7374
7375     IXMLDOMDocument_Release(doc);
7376     free_bstrs();
7377 }
7378
7379 static void test_testTransforms(void)
7380 {
7381     IXMLDOMDocument *doc, *docSS;
7382     IXMLDOMNode *pNode;
7383     VARIANT_BOOL bSucc;
7384
7385     HRESULT hr;
7386
7387     doc = create_document(&IID_IXMLDOMDocument);
7388     if (!doc) return;
7389
7390     docSS = create_document(&IID_IXMLDOMDocument);
7391     if (!docSS)
7392     {
7393         IXMLDOMDocument_Release(doc);
7394         return;
7395     }
7396
7397     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
7398     ok(hr == S_OK, "ret %08x\n", hr );
7399
7400     hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
7401     ok(hr == S_OK, "ret %08x\n", hr );
7402
7403     hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (void**)&pNode );
7404     ok(hr == S_OK, "ret %08x\n", hr );
7405     if(hr == S_OK)
7406     {
7407         BSTR bOut;
7408
7409         hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
7410         ok(hr == S_OK, "ret %08x\n", hr );
7411         if(hr == S_OK)
7412         {
7413             ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "Stylesheet output not correct\n");
7414             SysFreeString(bOut);
7415         }
7416
7417         IXMLDOMNode_Release(pNode);
7418     }
7419
7420     IXMLDOMDocument_Release(docSS);
7421     IXMLDOMDocument_Release(doc);
7422
7423     free_bstrs();
7424 }
7425
7426 struct namespaces_change_t {
7427     const CLSID *clsid;
7428     const char *name;
7429 };
7430
7431 static const struct namespaces_change_t namespaces_change_test_data[] = {
7432     { &CLSID_DOMDocument,   "CLSID_DOMDocument"   },
7433     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2"  },
7434     { &CLSID_DOMDocument26, "CLSID_DOMDocument26" },
7435     { &CLSID_DOMDocument30, "CLSID_DOMDocument30" },
7436     { &CLSID_DOMDocument40, "CLSID_DOMDocument40" },
7437     { &CLSID_DOMDocument60, "CLSID_DOMDocument60" },
7438     { 0 }
7439 };
7440
7441 static void test_namespaces_change(void)
7442 {
7443     const struct namespaces_change_t *class_ptr = namespaces_change_test_data;
7444
7445     while (class_ptr->clsid)
7446     {
7447         IXMLDOMDocument *doc = NULL;
7448         IXMLDOMElement *elem = NULL;
7449         IXMLDOMNode *node = NULL;
7450
7451         VARIANT var;
7452         HRESULT hr;
7453         BSTR str;
7454
7455         hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
7456                               &IID_IXMLDOMDocument, (void**)&doc);
7457         if (hr != S_OK)
7458         {
7459             win_skip("failed to create class instance for %s\n", class_ptr->name);
7460             class_ptr++;
7461             continue;
7462         }
7463
7464         V_VT(&var) = VT_I2;
7465         V_I2(&var) = NODE_ELEMENT;
7466
7467         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("ns:elem"), _bstr_("ns/uri"), &node);
7468         EXPECT_HR(hr, S_OK);
7469
7470         hr = IXMLDOMDocument_appendChild(doc, node, NULL);
7471         EXPECT_HR(hr, S_OK);
7472
7473         hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7474         EXPECT_HR(hr, S_OK);
7475
7476         /* try same prefix, different uri */
7477         V_VT(&var) = VT_BSTR;
7478         V_BSTR(&var) = _bstr_("ns/uri2");
7479
7480         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
7481         EXPECT_HR(hr, E_INVALIDARG);
7482
7483         /* try same prefix and uri */
7484         V_VT(&var) = VT_BSTR;
7485         V_BSTR(&var) = _bstr_("ns/uri");
7486
7487         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
7488         EXPECT_HR(hr, S_OK);
7489
7490         hr = IXMLDOMElement_get_xml(elem, &str);
7491         EXPECT_HR(hr, S_OK);
7492         ok(!lstrcmpW(str, _bstr_("<ns:elem xmlns:ns=\"ns/uri\"/>")), "got element %s for %s\n",
7493            wine_dbgstr_w(str), class_ptr->name);
7494         SysFreeString(str);
7495
7496         IXMLDOMElement_Release(elem);
7497         IXMLDOMDocument_Release(doc);
7498
7499         free_bstrs();
7500
7501         class_ptr++;
7502     }
7503 }
7504
7505 static void test_namespaces_basic(void)
7506 {
7507     static const CHAR namespaces_xmlA[] =
7508         "<?xml version=\"1.0\"?>\n"
7509         "<XMI xmi.version=\"1.1\" xmlns:Model=\"http://omg.org/mof.Model/1.3\">"
7510         "  <XMI.content>"
7511         "    <Model:Package name=\"WinePackage\" Model:name2=\"name2 attr\" />"
7512         "  </XMI.content>"
7513         "</XMI>";
7514
7515     IXMLDOMDocument *doc;
7516     IXMLDOMElement *elem;
7517     IXMLDOMNode *node;
7518
7519     VARIANT_BOOL b;
7520     HRESULT hr;
7521     BSTR str;
7522
7523     doc = create_document(&IID_IXMLDOMDocument);
7524     if (!doc) return;
7525
7526     hr = IXMLDOMDocument_loadXML(doc, _bstr_(namespaces_xmlA), &b);
7527     EXPECT_HR(hr, S_OK);
7528     ok(b == VARIANT_TRUE, "got %d\n", b);
7529
7530     str = (BSTR)0xdeadbeef;
7531     hr = IXMLDOMDocument_get_namespaceURI(doc, &str);
7532     EXPECT_HR(hr, S_FALSE);
7533     ok(str == NULL, "got %p\n", str);
7534
7535     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("//XMI.content"), &node );
7536     EXPECT_HR(hr, S_OK);
7537     if(hr == S_OK)
7538     {
7539         IXMLDOMAttribute *attr;
7540         IXMLDOMNode *node2;
7541
7542         hr = IXMLDOMNode_get_firstChild(node, &node2);
7543         EXPECT_HR(hr, S_OK);
7544         ok(node2 != NULL, "got %p\n", node2);
7545
7546         /* Test get_prefix */
7547         hr = IXMLDOMNode_get_prefix(node2, NULL);
7548         EXPECT_HR(hr, E_INVALIDARG);
7549         /* NOTE: Need to test that arg2 gets cleared on Error. */
7550
7551         hr = IXMLDOMNode_get_prefix(node2, &str);
7552         EXPECT_HR(hr, S_OK);
7553         ok( !lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
7554         SysFreeString(str);
7555
7556         hr = IXMLDOMNode_get_nodeName(node2, &str);
7557         EXPECT_HR(hr, S_OK);
7558         ok(!lstrcmpW( str, _bstr_("Model:Package")), "got %s\n", wine_dbgstr_w(str));
7559         SysFreeString(str);
7560
7561         /* Test get_namespaceURI */
7562         hr = IXMLDOMNode_get_namespaceURI(node2, NULL);
7563         EXPECT_HR(hr, E_INVALIDARG);
7564         /* NOTE: Need to test that arg2 gets cleared on Error. */
7565
7566         hr = IXMLDOMNode_get_namespaceURI(node2, &str);
7567         EXPECT_HR(hr, S_OK);
7568         ok(!lstrcmpW( str, _bstr_("http://omg.org/mof.Model/1.3")), "got %s\n", wine_dbgstr_w(str));
7569         SysFreeString(str);
7570
7571         hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&elem);
7572         EXPECT_HR(hr, S_OK);
7573
7574         hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("Model:name2"), &attr);
7575         EXPECT_HR(hr, S_OK);
7576
7577         hr = IXMLDOMAttribute_get_nodeName(attr, &str);
7578         EXPECT_HR(hr, S_OK);
7579         ok(!lstrcmpW( str, _bstr_("Model:name2")), "got %s\n", wine_dbgstr_w(str));
7580         SysFreeString(str);
7581
7582         hr = IXMLDOMAttribute_get_prefix(attr, &str);
7583         EXPECT_HR(hr, S_OK);
7584         ok(!lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
7585         SysFreeString(str);
7586
7587         IXMLDOMAttribute_Release(attr);
7588         IXMLDOMElement_Release(elem);
7589
7590         IXMLDOMNode_Release(node2);
7591         IXMLDOMNode_Release(node);
7592     }
7593
7594     IXMLDOMDocument_Release(doc);
7595
7596     free_bstrs();
7597 }
7598
7599 static void test_FormattingXML(void)
7600 {
7601     IXMLDOMDocument *doc;
7602     IXMLDOMElement *pElement;
7603     VARIANT_BOOL bSucc;
7604     HRESULT hr;
7605     BSTR str;
7606     static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
7607     static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
7608
7609     doc = create_document(&IID_IXMLDOMDocument);
7610     if (!doc) return;
7611
7612     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
7613     ok(hr == S_OK, "ret %08x\n", hr );
7614     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7615
7616     if(bSucc == VARIANT_TRUE)
7617     {
7618         hr = IXMLDOMDocument_get_documentElement(doc, &pElement);
7619         ok(hr == S_OK, "ret %08x\n", hr );
7620         if(hr == S_OK)
7621         {
7622             hr = IXMLDOMElement_get_xml(pElement, &str);
7623             ok(hr == S_OK, "ret %08x\n", hr );
7624             ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
7625             SysFreeString(str);
7626
7627             IXMLDOMElement_Release(pElement);
7628         }
7629     }
7630
7631     IXMLDOMDocument_Release(doc);
7632
7633     free_bstrs();
7634 }
7635
7636 typedef struct _nodetypedvalue_t {
7637     const char *name;
7638     VARTYPE type;
7639     const char *value; /* value in string format */
7640 } nodetypedvalue_t;
7641
7642 static const nodetypedvalue_t get_nodetypedvalue[] = {
7643     { "root/string",    VT_BSTR, "Wine" },
7644     { "root/string2",   VT_BSTR, "String" },
7645     { "root/number",    VT_BSTR, "12.44" },
7646     { "root/number2",   VT_BSTR, "-3.71e3" },
7647     { "root/int",       VT_I4,   "-13" },
7648     { "root/fixed",     VT_CY,   "7322.9371" },
7649     { "root/bool",      VT_BOOL, "-1" },
7650     { "root/datetime",  VT_DATE, "40135.14" },
7651     { "root/datetimetz",VT_DATE, "37813.59" },
7652     { "root/date",      VT_DATE, "665413" },
7653     { "root/time",      VT_DATE, "0.5813889" },
7654     { "root/timetz",    VT_DATE, "1.112512" },
7655     { "root/i1",        VT_I1,   "-13" },
7656     { "root/i2",        VT_I2,   "31915" },
7657     { "root/i4",        VT_I4,   "-312232" },
7658     { "root/ui1",       VT_UI1,  "123" },
7659     { "root/ui2",       VT_UI2,  "48282" },
7660     { "root/ui4",       VT_UI4,  "949281" },
7661     { "root/r4",        VT_R4,   "213124" },
7662     { "root/r8",        VT_R8,   "0.412" },
7663     { "root/float",     VT_R8,   "41221.421" },
7664     { "root/uuid",      VT_BSTR, "333C7BC4-460F-11D0-BC04-0080C7055a83" },
7665     { "root/binbase64", VT_ARRAY|VT_UI1, "base64 test" },
7666     { "root/binbase64_1", VT_ARRAY|VT_UI1, "base64 test" },
7667     { "root/binbase64_2", VT_ARRAY|VT_UI1, "base64 test" },
7668     { 0 }
7669 };
7670
7671 static void test_nodeTypedValue(void)
7672 {
7673     const nodetypedvalue_t *entry = get_nodetypedvalue;
7674     IXMLDOMDocumentType *doctype, *doctype2;
7675     IXMLDOMProcessingInstruction *pi;
7676     IXMLDOMDocumentFragment *frag;
7677     IXMLDOMDocument *doc, *doc2;
7678     IXMLDOMCDATASection *cdata;
7679     IXMLDOMComment *comment;
7680     IXMLDOMNode *node;
7681     VARIANT_BOOL b;
7682     VARIANT value;
7683     HRESULT hr;
7684
7685     doc = create_document(&IID_IXMLDOMDocument);
7686     if (!doc) return;
7687
7688     b = VARIANT_FALSE;
7689     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &b);
7690     ok(hr == S_OK, "ret %08x\n", hr );
7691     ok(b == VARIANT_TRUE, "got %d\n", b);
7692
7693     hr = IXMLDOMDocument_get_nodeValue(doc, NULL);
7694     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7695
7696     V_VT(&value) = VT_BSTR;
7697     V_BSTR(&value) = NULL;
7698     hr = IXMLDOMDocument_get_nodeValue(doc, &value);
7699     ok(hr == S_FALSE, "ret %08x\n", hr );
7700     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
7701
7702     hr = IXMLDOMDocument_get_nodeTypedValue(doc, NULL);
7703     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7704
7705     V_VT(&value) = VT_EMPTY;
7706     hr = IXMLDOMDocument_get_nodeTypedValue(doc, &value);
7707     ok(hr == S_FALSE, "ret %08x\n", hr );
7708     ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
7709
7710     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/string"), &node);
7711     ok(hr == S_OK, "ret %08x\n", hr );
7712
7713     V_VT(&value) = VT_BSTR;
7714     V_BSTR(&value) = NULL;
7715     hr = IXMLDOMNode_get_nodeValue(node, &value);
7716     ok(hr == S_FALSE, "ret %08x\n", hr );
7717     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
7718
7719     hr = IXMLDOMNode_get_nodeTypedValue(node, NULL);
7720     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7721
7722     IXMLDOMNode_Release(node);
7723
7724     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/binhex"), &node);
7725     ok(hr == S_OK, "ret %08x\n", hr );
7726     {
7727         BYTE bytes[] = {0xff,0xfc,0xa0,0x12,0x00,0x3c};
7728
7729         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
7730         ok(hr == S_OK, "ret %08x\n", hr );
7731         ok(V_VT(&value) == (VT_ARRAY|VT_UI1), "incorrect type\n");
7732         ok(V_ARRAY(&value)->rgsabound[0].cElements == 6, "incorrect array size\n");
7733         if(V_ARRAY(&value)->rgsabound[0].cElements == 6)
7734             ok(!memcmp(bytes, V_ARRAY(&value)->pvData, sizeof(bytes)), "incorrect value\n");
7735         VariantClear(&value);
7736         IXMLDOMNode_Release(node);
7737     }
7738
7739     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("foo"), _bstr_("value"), &pi);
7740     ok(hr == S_OK, "ret %08x\n", hr );
7741     {
7742         V_VT(&value) = VT_NULL;
7743         V_BSTR(&value) = (void*)0xdeadbeef;
7744         hr = IXMLDOMProcessingInstruction_get_nodeTypedValue(pi, &value);
7745         ok(hr == S_OK, "ret %08x\n", hr );
7746         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
7747         ok(!lstrcmpW(V_BSTR(&value), _bstr_("value")), "got wrong value\n");
7748         IXMLDOMProcessingInstruction_Release(pi);
7749         VariantClear(&value);
7750     }
7751
7752     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("[1]*2=3; &gee that's not right!"), &cdata);
7753     ok(hr == S_OK, "ret %08x\n", hr );
7754     {
7755         V_VT(&value) = VT_NULL;
7756         V_BSTR(&value) = (void*)0xdeadbeef;
7757         hr = IXMLDOMCDATASection_get_nodeTypedValue(cdata, &value);
7758         ok(hr == S_OK, "ret %08x\n", hr );
7759         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
7760         ok(!lstrcmpW(V_BSTR(&value), _bstr_("[1]*2=3; &gee that's not right!")), "got wrong value\n");
7761         IXMLDOMCDATASection_Release(cdata);
7762         VariantClear(&value);
7763     }
7764
7765     hr = IXMLDOMDocument_createComment(doc, _bstr_("comment"), &comment);
7766     ok(hr == S_OK, "ret %08x\n", hr );
7767     {
7768         V_VT(&value) = VT_NULL;
7769         V_BSTR(&value) = (void*)0xdeadbeef;
7770         hr = IXMLDOMComment_get_nodeTypedValue(comment, &value);
7771         ok(hr == S_OK, "ret %08x\n", hr );
7772         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
7773         ok(!lstrcmpW(V_BSTR(&value), _bstr_("comment")), "got wrong value\n");
7774         IXMLDOMComment_Release(comment);
7775         VariantClear(&value);
7776     }
7777
7778     hr = IXMLDOMDocument_createDocumentFragment(doc, &frag);
7779     ok(hr == S_OK, "ret %08x\n", hr );
7780     {
7781         V_VT(&value) = VT_EMPTY;
7782         hr = IXMLDOMDocumentFragment_get_nodeTypedValue(frag, &value);
7783         ok(hr == S_FALSE, "ret %08x\n", hr );
7784         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
7785         IXMLDOMDocumentFragment_Release(frag);
7786     }
7787
7788     doc2 = create_document(&IID_IXMLDOMDocument);
7789
7790     b = VARIANT_FALSE;
7791     hr = IXMLDOMDocument_loadXML(doc2, _bstr_(szEmailXML), &b);
7792     ok(hr == S_OK, "ret %08x\n", hr );
7793     ok(b == VARIANT_TRUE, "got %d\n", b);
7794
7795     EXPECT_REF(doc2, 1);
7796
7797     hr = IXMLDOMDocument_get_doctype(doc2, &doctype);
7798     ok(hr == S_OK, "ret %08x\n", hr );
7799
7800     EXPECT_REF(doc2, 1);
7801     todo_wine EXPECT_REF(doctype, 2);
7802
7803     {
7804         V_VT(&value) = VT_EMPTY;
7805         hr = IXMLDOMDocumentType_get_nodeTypedValue(doctype, &value);
7806         ok(hr == S_FALSE, "ret %08x\n", hr );
7807         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
7808     }
7809
7810     hr = IXMLDOMDocument_get_doctype(doc2, &doctype2);
7811     ok(hr == S_OK, "ret %08x\n", hr );
7812     ok(doctype != doctype2, "got %p, was %p\n", doctype2, doctype);
7813
7814     IXMLDOMDocumentType_Release(doctype2);
7815     IXMLDOMDocumentType_Release(doctype);
7816
7817     IXMLDOMDocument_Release(doc2);
7818
7819     while (entry->name)
7820     {
7821         hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_(entry->name), &node);
7822         ok(hr == S_OK, "ret %08x\n", hr );
7823
7824         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
7825         ok(hr == S_OK, "ret %08x\n", hr );
7826         ok(V_VT(&value) == entry->type, "incorrect type, expected %d, got %d\n", entry->type, V_VT(&value));
7827
7828         if (entry->type == (VT_ARRAY|VT_UI1))
7829         {
7830             ok(V_ARRAY(&value)->rgsabound[0].cElements == strlen(entry->value),
7831                "incorrect array size %d\n", V_ARRAY(&value)->rgsabound[0].cElements);
7832         }
7833
7834         if (entry->type != VT_BSTR)
7835         {
7836            if (entry->type == VT_DATE ||
7837                entry->type == VT_R8 ||
7838                entry->type == VT_CY)
7839            {
7840                if (entry->type == VT_DATE)
7841                {
7842                    hr = VariantChangeType(&value, &value, 0, VT_R4);
7843                    ok(hr == S_OK, "ret %08x\n", hr );
7844                }
7845                hr = VariantChangeTypeEx(&value, &value,
7846                                         MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT),
7847                                         VARIANT_NOUSEROVERRIDE, VT_BSTR);
7848                ok(hr == S_OK, "ret %08x\n", hr );
7849            }
7850            else
7851            {
7852                hr = VariantChangeType(&value, &value, 0, VT_BSTR);
7853                ok(hr == S_OK, "ret %08x\n", hr );
7854            }
7855
7856            /* for byte array from VT_ARRAY|VT_UI1 it's not a WCHAR buffer */
7857            if (entry->type == (VT_ARRAY|VT_UI1))
7858            {
7859                ok(!memcmp( V_BSTR(&value), entry->value, strlen(entry->value)),
7860                   "expected %s\n", entry->value);
7861            }
7862            else
7863                ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
7864                   "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
7865         }
7866         else
7867            ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
7868                "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
7869
7870         VariantClear( &value );
7871         IXMLDOMNode_Release(node);
7872
7873         entry++;
7874     }
7875
7876     IXMLDOMDocument_Release(doc);
7877     free_bstrs();
7878 }
7879
7880 static void test_TransformWithLoadingLocalFile(void)
7881 {
7882     IXMLDOMDocument *doc;
7883     IXMLDOMDocument *xsl;
7884     IXMLDOMNode *pNode;
7885     VARIANT_BOOL bSucc;
7886     HRESULT hr;
7887     HANDLE file;
7888     DWORD dwWritten;
7889     char lpPathBuffer[MAX_PATH];
7890     int i;
7891
7892     /* Create a Temp File. */
7893     GetTempPathA(MAX_PATH, lpPathBuffer);
7894     strcat(lpPathBuffer, "customers.xml" );
7895
7896     file = CreateFileA(lpPathBuffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
7897     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
7898     if(file == INVALID_HANDLE_VALUE)
7899         return;
7900
7901     WriteFile(file, szBasicTransformXML, strlen(szBasicTransformXML), &dwWritten, NULL);
7902     CloseHandle(file);
7903
7904     /* Correct path to not include a escape character. */
7905     for(i=0; i < strlen(lpPathBuffer); i++)
7906     {
7907         if(lpPathBuffer[i] == '\\')
7908             lpPathBuffer[i] = '/';
7909     }
7910
7911     doc = create_document(&IID_IXMLDOMDocument);
7912     if (!doc) return;
7913
7914     xsl = create_document(&IID_IXMLDOMDocument);
7915     if (!xsl)
7916     {
7917         IXMLDOMDocument2_Release(doc);
7918         return;
7919     }
7920
7921     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
7922     ok(hr == S_OK, "ret %08x\n", hr );
7923     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7924     if(bSucc == VARIANT_TRUE)
7925     {
7926         BSTR sXSL;
7927         BSTR sPart1 = _bstr_(szBasicTransformSSXMLPart1);
7928         BSTR sPart2 = _bstr_(szBasicTransformSSXMLPart2);
7929         BSTR sFileName = _bstr_(lpPathBuffer);
7930         int nLegnth = lstrlenW(sPart1) + lstrlenW(sPart2) + lstrlenW(sFileName) + 1;
7931
7932         sXSL = SysAllocStringLen(NULL, nLegnth);
7933         lstrcpyW(sXSL, sPart1);
7934         lstrcatW(sXSL, sFileName);
7935         lstrcatW(sXSL, sPart2);
7936
7937         hr = IXMLDOMDocument_loadXML(xsl, sXSL, &bSucc);
7938         ok(hr == S_OK, "ret %08x\n", hr );
7939         ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7940         if(bSucc == VARIANT_TRUE)
7941         {
7942             BSTR sResult;
7943
7944             hr = IXMLDOMDocument_QueryInterface(xsl, &IID_IXMLDOMNode, (void**)&pNode );
7945             ok(hr == S_OK, "ret %08x\n", hr );
7946             if(hr == S_OK)
7947             {
7948                 /* This will load the temp file via the XSL */
7949                 hr = IXMLDOMDocument_transformNode(doc, pNode, &sResult);
7950                 ok(hr == S_OK, "ret %08x\n", hr );
7951                 if(hr == S_OK)
7952                 {
7953                     ok( compareIgnoreReturns( sResult, _bstr_(szBasicTransformOutput)), "Stylesheet output not correct\n");
7954                     SysFreeString(sResult);
7955                 }
7956
7957                 IXMLDOMNode_Release(pNode);
7958             }
7959         }
7960
7961         SysFreeString(sXSL);
7962     }
7963
7964     IXMLDOMDocument_Release(doc);
7965     IXMLDOMDocument_Release(xsl);
7966
7967     DeleteFile(lpPathBuffer);
7968     free_bstrs();
7969 }
7970
7971 static void test_put_nodeValue(void)
7972 {
7973     static const WCHAR jeevesW[] = {'J','e','e','v','e','s',' ','&',' ','W','o','o','s','t','e','r',0};
7974     IXMLDOMDocument *doc;
7975     IXMLDOMText *text;
7976     IXMLDOMEntityReference *entityref;
7977     IXMLDOMAttribute *attr;
7978     IXMLDOMNode *node;
7979     HRESULT hr;
7980     VARIANT data, type;
7981
7982     doc = create_document(&IID_IXMLDOMDocument);
7983     if (!doc) return;
7984
7985     /* test for unsupported types */
7986     /* NODE_DOCUMENT */
7987     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&node);
7988     ok(hr == S_OK, "ret %08x\n", hr );
7989     V_VT(&data) = VT_BSTR;
7990     V_BSTR(&data) = _bstr_("one two three");
7991     hr = IXMLDOMNode_put_nodeValue(node, data);
7992     ok(hr == E_FAIL, "ret %08x\n", hr );
7993     IXMLDOMNode_Release(node);
7994
7995     /* NODE_DOCUMENT_FRAGMENT */
7996     V_VT(&type) = VT_I1;
7997     V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
7998     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
7999     ok(hr == S_OK, "ret %08x\n", hr );
8000     V_VT(&data) = VT_BSTR;
8001     V_BSTR(&data) = _bstr_("one two three");
8002     hr = IXMLDOMNode_put_nodeValue(node, data);
8003     ok(hr == E_FAIL, "ret %08x\n", hr );
8004     IXMLDOMNode_Release(node);
8005
8006     /* NODE_ELEMENT */
8007     V_VT(&type) = VT_I1;
8008     V_I1(&type) = NODE_ELEMENT;
8009     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
8010     ok(hr == S_OK, "ret %08x\n", hr );
8011     V_VT(&data) = VT_BSTR;
8012     V_BSTR(&data) = _bstr_("one two three");
8013     hr = IXMLDOMNode_put_nodeValue(node, data);
8014     ok(hr == E_FAIL, "ret %08x\n", hr );
8015     IXMLDOMNode_Release(node);
8016
8017     /* NODE_ENTITY_REFERENCE */
8018     hr = IXMLDOMDocument_createEntityReference(doc, _bstr_("ref"), &entityref);
8019     ok(hr == S_OK, "ret %08x\n", hr );
8020
8021     V_VT(&data) = VT_BSTR;
8022     V_BSTR(&data) = _bstr_("one two three");
8023     hr = IXMLDOMEntityReference_put_nodeValue(entityref, data);
8024     ok(hr == E_FAIL, "ret %08x\n", hr );
8025
8026     hr = IXMLDOMEntityReference_QueryInterface(entityref, &IID_IXMLDOMNode, (void**)&node);
8027     ok(hr == S_OK, "ret %08x\n", hr );
8028     V_VT(&data) = VT_BSTR;
8029     V_BSTR(&data) = _bstr_("one two three");
8030     hr = IXMLDOMNode_put_nodeValue(node, data);
8031     ok(hr == E_FAIL, "ret %08x\n", hr );
8032     IXMLDOMNode_Release(node);
8033     IXMLDOMEntityReference_Release(entityref);
8034
8035     /* supported types */
8036     hr = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &text);
8037     ok(hr == S_OK, "ret %08x\n", hr );
8038     V_VT(&data) = VT_BSTR;
8039     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
8040     hr = IXMLDOMText_put_nodeValue(text, data);
8041     ok(hr == S_OK, "ret %08x\n", hr );
8042     IXMLDOMText_Release(text);
8043
8044     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8045     ok(hr == S_OK, "ret %08x\n", hr );
8046     V_VT(&data) = VT_BSTR;
8047     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
8048     hr = IXMLDOMAttribute_put_nodeValue(attr, data);
8049     ok(hr == S_OK, "ret %08x\n", hr );
8050     hr = IXMLDOMAttribute_get_nodeValue(attr, &data);
8051     ok(hr == S_OK, "ret %08x\n", hr );
8052     ok(memcmp(V_BSTR(&data), jeevesW, sizeof(jeevesW)) == 0, "got %s\n",
8053         wine_dbgstr_w(V_BSTR(&data)));
8054     VariantClear(&data);
8055     IXMLDOMAttribute_Release(attr);
8056
8057     free_bstrs();
8058
8059     IXMLDOMDocument_Release(doc);
8060 }
8061
8062 static void test_document_IObjectSafety(void)
8063 {
8064     IXMLDOMDocument *doc;
8065     IObjectSafety *safety;
8066     HRESULT hr;
8067
8068     doc = create_document(&IID_IXMLDOMDocument);
8069     if (!doc) return;
8070
8071     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IObjectSafety, (void**)&safety);
8072     ok(hr == S_OK, "ret %08x\n", hr );
8073
8074     test_IObjectSafety_common(safety);
8075
8076     IObjectSafety_Release(safety);
8077
8078     IXMLDOMDocument_Release(doc);
8079 }
8080
8081 typedef struct _property_test_t {
8082     const GUID *guid;
8083     const char *clsid;
8084     const char *property;
8085     const char *value;
8086 } property_test_t;
8087
8088 static const property_test_t properties_test_data[] = {
8089     { &CLSID_DOMDocument,  "CLSID_DOMDocument" , "SelectionLanguage", "XSLPattern" },
8090     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2" , "SelectionLanguage", "XSLPattern" },
8091     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "SelectionLanguage", "XSLPattern" },
8092     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "SelectionLanguage", "XPath" },
8093     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "SelectionLanguage", "XPath" },
8094     { 0 }
8095 };
8096
8097 static void test_default_properties(void)
8098 {
8099     const property_test_t *entry = properties_test_data;
8100
8101     while (entry->guid)
8102     {
8103         IXMLDOMDocument2 *doc;
8104         VARIANT var;
8105         HRESULT hr;
8106
8107         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
8108         if (hr != S_OK)
8109         {
8110             win_skip("can't create %s instance\n", entry->clsid);
8111             entry++;
8112             continue;
8113         }
8114
8115         hr = IXMLDOMDocument2_getProperty(doc, _bstr_(entry->property), &var);
8116         ok(hr == S_OK, "got 0x%08x\n", hr);
8117         ok(lstrcmpW(V_BSTR(&var), _bstr_(entry->value)) == 0, "expected %s, for %s\n",
8118            entry->value, entry->clsid);
8119         VariantClear(&var);
8120
8121         IXMLDOMDocument2_Release(doc);
8122
8123         entry++;
8124     }
8125 }
8126
8127 typedef struct {
8128     const char *query;
8129     const char *list;
8130 } xslpattern_test_t;
8131
8132 static const xslpattern_test_t xslpattern_test[] = {
8133     { "root//elem[0]", "E1.E2.D1" },
8134     { "root//elem[index()=1]", "E2.E2.D1" },
8135     { "root//elem[index() $eq$ 1]", "E2.E2.D1" },
8136     { "root//elem[end()]", "E4.E2.D1" },
8137     { "root//elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
8138     { "root//elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
8139     { "root//elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
8140     { "root//elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
8141     { "root//elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
8142     { "root//elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
8143     { "root//elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
8144     { "root//elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
8145     { "root//elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
8146     { "root//elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
8147     { "root//elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
8148     { "root//elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
8149     { "root//elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
8150     { "root//elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
8151     { "root//elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
8152     { "root//elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
8153     { "root//elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
8154     { "root//elem[$any$ *='B2 field']", "E2.E2.D1" },
8155     { "root//elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
8156     { "root//elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
8157     { "root//elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
8158     { "root//elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
8159     { "root//elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8160     { "root//elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8161     { "root//elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8162     { "root/elem[0]", "E1.E2.D1" },
8163     { "root/elem[index()=1]", "E2.E2.D1" },
8164     { "root/elem[index() $eq$ 1]", "E2.E2.D1" },
8165     { "root/elem[end()]", "E4.E2.D1" },
8166     { "root/elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
8167     { "root/elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
8168     { "root/elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
8169     { "root/elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
8170     { "root/elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
8171     { "root/elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
8172     { "root/elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
8173     { "root/elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
8174     { "root/elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
8175     { "root/elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
8176     { "root/elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
8177     { "root/elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
8178     { "root/elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
8179     { "root/elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
8180     { "root/elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
8181     { "root/elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
8182     { "root/elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
8183     { "root/elem[$any$ *='B2 field']", "E2.E2.D1" },
8184     { "root/elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
8185     { "root/elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
8186     { "root/elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
8187     { "root/elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
8188     { "root/elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8189     { "root/elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8190     { "root/elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8191     { "root/elem[d]", "E1.E2.D1 E2.E2.D1 E4.E2.D1" },
8192     { NULL }
8193 };
8194
8195 static const xslpattern_test_t xslpattern_test_no_ns[] = {
8196     /* prefixes don't need to be registered, you may use them as they are in the doc */
8197     { "//bar:x", "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1" },
8198     /* prefixes must be explicitly specified in the name */
8199     { "//foo:elem", "" },
8200     { "//foo:c", "E3.E4.E2.D1" },
8201     { NULL }
8202 };
8203
8204 static const xslpattern_test_t xslpattern_test_func[] = {
8205     { "attribute()", "" },
8206     { "attribute('depth')", "" },
8207     { "root/attribute('depth')", "A'depth'.E3.D1" },
8208     { "//x/attribute()", "A'id'.E3.E3.D1 A'depth'.E3.E3.D1" },
8209     { "//x//attribute(id)", NULL },
8210     { "//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" },
8211     { "comment()", "C2.D1" },
8212     { "//comment()", "C2.D1 C1.E3.D1 C2.E3.E3.D1 C2.E4.E3.D1" },
8213     { "element()", "E3.D1" },
8214     { "root/y/element()", "E4.E4.E3.D1 E5.E4.E3.D1 E6.E4.E3.D1" },
8215     { "//element(a)", NULL },
8216     { "//element('a')", "E4.E3.E3.D1 E4.E4.E3.D1" },
8217     { "node()", "P1.D1 C2.D1 E3.D1" },
8218     { "//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" },
8219     { "//x/node()[nodeType()=1]", "E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1" },
8220     { "//x/node()[nodeType()=3]", "T3.E3.E3.D1" },
8221     { "//x/node()[nodeType()=7]", "P1.E3.E3.D1" },
8222     { "//x/node()[nodeType()=8]", "C2.E3.E3.D1" },
8223     { "pi()", "P1.D1" },
8224     { "//y/pi()", "P1.E4.E3.D1" },
8225     { "root/textnode()", "T2.E3.D1" },
8226     { "root/element()/textnode()", "T3.E3.E3.D1 T3.E4.E3.D1" },
8227     { NULL }
8228 };
8229
8230 static void test_XSLPattern(void)
8231 {
8232     const xslpattern_test_t *ptr = xslpattern_test;
8233     IXMLDOMDocument2 *doc;
8234     IXMLDOMNodeList *list;
8235     VARIANT_BOOL b;
8236     HRESULT hr;
8237     LONG len;
8238
8239     doc = create_document(&IID_IXMLDOMDocument2);
8240     if (!doc) return;
8241
8242     b = VARIANT_FALSE;
8243     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
8244     EXPECT_HR(hr, S_OK);
8245     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8246
8247     /* switch to XSLPattern */
8248     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern"));
8249     EXPECT_HR(hr, S_OK);
8250
8251     /* XPath doesn't select elements with non-null default namespace with unqualified selectors, XSLPattern does */
8252     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem/c"), &list);
8253     EXPECT_HR(hr, S_OK);
8254
8255     len = 0;
8256     hr = IXMLDOMNodeList_get_length(list, &len);
8257     EXPECT_HR(hr, S_OK);
8258     /* should select <elem><c> and <elem xmlns='...'><c> but not <elem><foo:c> */
8259     ok(len == 3, "expected 3 entries in list, got %d\n", len);
8260     IXMLDOMNodeList_Release(list);
8261
8262     while (ptr->query)
8263     {
8264         list = NULL;
8265         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
8266         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
8267         len = 0;
8268         hr = IXMLDOMNodeList_get_length(list, &len);
8269         ok(len != 0, "query=%s, empty list\n", ptr->query);
8270         if (len)
8271             expect_list_and_release(list, ptr->list);
8272
8273         ptr++;
8274     }
8275
8276     /* namespace handling */
8277     /* no registered namespaces */
8278     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_(""));
8279     EXPECT_HR(hr, S_OK);
8280
8281     ptr = xslpattern_test_no_ns;
8282     while (ptr->query)
8283     {
8284         list = NULL;
8285         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
8286         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
8287
8288         if (*ptr->list)
8289         {
8290             len = 0;
8291             hr = IXMLDOMNodeList_get_length(list, &len);
8292             EXPECT_HR(hr, S_OK);
8293             ok(len != 0, "query=%s, empty list\n", ptr->query);
8294         }
8295         else
8296         {
8297             len = 1;
8298             hr = IXMLDOMNodeList_get_length(list, &len);
8299             EXPECT_HR(hr, S_OK);
8300             ok(len == 0, "query=%s, empty list\n", ptr->query);
8301         }
8302         if (len)
8303             expect_list_and_release(list, ptr->list);
8304
8305         ptr++;
8306     }
8307
8308     /* explicitly register prefix foo */
8309     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
8310
8311     /* now we get the same behavior as XPath */
8312     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
8313     EXPECT_HR(hr, S_OK);
8314     len = 0;
8315     hr = IXMLDOMNodeList_get_length(list, &len);
8316     EXPECT_HR(hr, S_OK);
8317     ok(len != 0, "expected filled list\n");
8318     if (len)
8319         expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
8320
8321     /* set prefix foo to some nonexistent namespace */
8322     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:nonexistent-foo'"));
8323     EXPECT_HR(hr, S_OK);
8324
8325     /* the registered prefix takes precedence */
8326     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
8327     EXPECT_HR(hr, S_OK);
8328     len = 0;
8329     hr = IXMLDOMNodeList_get_length(list, &len);
8330     EXPECT_HR(hr, S_OK);
8331     ok(len == 0, "expected empty list\n");
8332     IXMLDOMNodeList_Release(list);
8333
8334     IXMLDOMDocument2_Release(doc);
8335
8336     doc = create_document(&IID_IXMLDOMDocument2);
8337     if (!doc) return;
8338
8339     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNodeTypesXML), &b);
8340     EXPECT_HR(hr, S_OK);
8341     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8342
8343     ptr = xslpattern_test_func;
8344     while (ptr->query)
8345     {
8346         list = NULL;
8347         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
8348         if (ptr->list)
8349         {
8350             ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
8351             len = 0;
8352             hr = IXMLDOMNodeList_get_length(list, &len);
8353             if (*ptr->list)
8354             {
8355                 ok(len != 0, "query=%s, empty list\n", ptr->query);
8356                 if (len)
8357                     expect_list_and_release(list, ptr->list);
8358             }
8359             else
8360                 ok(len == 0, "query=%s, filled list\n", ptr->query);
8361         }
8362         else
8363             ok(hr == E_FAIL, "query=%s, failed with 0x%08x\n", ptr->query, hr);
8364
8365         ptr++;
8366     }
8367
8368     IXMLDOMDocument2_Release(doc);
8369     free_bstrs();
8370 }
8371
8372 static void test_splitText(void)
8373 {
8374     IXMLDOMCDATASection *cdata;
8375     IXMLDOMElement *root;
8376     IXMLDOMDocument *doc;
8377     IXMLDOMText *text, *text2;
8378     IXMLDOMNode *node;
8379     VARIANT var;
8380     VARIANT_BOOL success;
8381     LONG length;
8382     HRESULT hr;
8383
8384     doc = create_document(&IID_IXMLDOMDocument);
8385     if (!doc) return;
8386
8387     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<root></root>"), &success);
8388     ok(hr == S_OK, "got 0x%08x\n", hr);
8389
8390     hr = IXMLDOMDocument_get_documentElement(doc, &root);
8391     ok(hr == S_OK, "got 0x%08x\n", hr);
8392
8393     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("beautiful plumage"), &cdata);
8394     ok(hr == S_OK, "got 0x%08x\n", hr);
8395
8396     V_VT(&var) = VT_EMPTY;
8397     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)cdata, NULL);
8398     ok(hr == S_OK, "got 0x%08x\n", hr);
8399
8400     length = 0;
8401     hr = IXMLDOMCDATASection_get_length(cdata, &length);
8402     ok(hr == S_OK, "got 0x%08x\n", hr);
8403     ok(length > 0, "got %d\n", length);
8404
8405     hr = IXMLDOMCDATASection_splitText(cdata, 0, NULL);
8406     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8407
8408     text = (void*)0xdeadbeef;
8409     /* negative offset */
8410     hr = IXMLDOMCDATASection_splitText(cdata, -1, &text);
8411     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8412     ok(text == (void*)0xdeadbeef, "got %p\n", text);
8413
8414     text = (void*)0xdeadbeef;
8415     /* offset outside data */
8416     hr = IXMLDOMCDATASection_splitText(cdata, length + 1, &text);
8417     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8418     ok(text == 0, "got %p\n", text);
8419
8420     text = (void*)0xdeadbeef;
8421     /* offset outside data */
8422     hr = IXMLDOMCDATASection_splitText(cdata, length, &text);
8423     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8424     ok(text == 0, "got %p\n", text);
8425
8426     /* no empty node created */
8427     node = (void*)0xdeadbeef;
8428     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
8429     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8430     ok(node == 0, "got %p\n", text);
8431
8432     hr = IXMLDOMCDATASection_splitText(cdata, 10, &text);
8433     ok(hr == S_OK, "got 0x%08x\n", hr);
8434
8435     length = 0;
8436     hr = IXMLDOMText_get_length(text, &length);
8437     ok(hr == S_OK, "got 0x%08x\n", hr);
8438     ok(length == 7, "got %d\n", length);
8439
8440     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
8441     ok(hr == S_OK, "got 0x%08x\n", hr);
8442     IXMLDOMNode_Release(node);
8443
8444     /* split new text node */
8445     hr = IXMLDOMText_get_length(text, &length);
8446     ok(hr == S_OK, "got 0x%08x\n", hr);
8447
8448     node = (void*)0xdeadbeef;
8449     hr = IXMLDOMText_get_nextSibling(text, &node);
8450     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8451     ok(node == 0, "got %p\n", text);
8452
8453     hr = IXMLDOMText_splitText(text, 0, NULL);
8454     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8455
8456     text2 = (void*)0xdeadbeef;
8457     /* negative offset */
8458     hr = IXMLDOMText_splitText(text, -1, &text2);
8459     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8460     ok(text2 == (void*)0xdeadbeef, "got %p\n", text2);
8461
8462     text2 = (void*)0xdeadbeef;
8463     /* offset outside data */
8464     hr = IXMLDOMText_splitText(text, length + 1, &text2);
8465     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8466     ok(text2 == 0, "got %p\n", text2);
8467
8468     text2 = (void*)0xdeadbeef;
8469     /* offset outside data */
8470     hr = IXMLDOMText_splitText(text, length, &text2);
8471     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8472     ok(text2 == 0, "got %p\n", text);
8473
8474     text2 = 0;
8475     hr = IXMLDOMText_splitText(text, 4, &text2);
8476     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
8477     if (text2) IXMLDOMText_Release(text2);
8478
8479     node = 0;
8480     hr = IXMLDOMText_get_nextSibling(text, &node);
8481     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
8482     if (node) IXMLDOMNode_Release(node);
8483
8484     IXMLDOMText_Release(text);
8485     IXMLDOMElement_Release(root);
8486     IXMLDOMCDATASection_Release(cdata);
8487     free_bstrs();
8488 }
8489
8490 typedef struct {
8491     const char *name;
8492     const char *uri;
8493     HRESULT hr;
8494 } ns_item_t;
8495
8496 /* default_ns_doc used */
8497 static const ns_item_t qualified_item_tests[] = {
8498     { "xml:lang", NULL, S_FALSE },
8499     { "xml:lang", "http://www.w3.org/XML/1998/namespace", S_FALSE },
8500     { "lang", "http://www.w3.org/XML/1998/namespace", S_OK },
8501     { "ns:b", NULL, S_FALSE },
8502     { "ns:b", "nshref", S_FALSE },
8503     { "b", "nshref", S_OK },
8504     { "d", NULL, S_OK },
8505     { NULL }
8506 };
8507
8508 static const ns_item_t named_item_tests[] = {
8509     { "xml:lang", NULL, S_OK },
8510     { "lang", NULL, S_FALSE },
8511     { "ns:b", NULL, S_OK },
8512     { "b", NULL, S_FALSE },
8513     { "d", NULL, S_OK },
8514     { NULL }
8515 };
8516
8517 static void test_getQualifiedItem(void)
8518 {
8519     IXMLDOMNode *pr_node, *node;
8520     IXMLDOMNodeList *root_list;
8521     IXMLDOMNamedNodeMap *map;
8522     IXMLDOMElement *element;
8523     const ns_item_t* ptr;
8524     IXMLDOMDocument *doc;
8525     VARIANT_BOOL b;
8526     HRESULT hr;
8527     LONG len;
8528
8529     doc = create_document(&IID_IXMLDOMDocument);
8530     if (!doc) return;
8531
8532     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8533     EXPECT_HR(hr, S_OK);
8534     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8535
8536     hr = IXMLDOMDocument_get_documentElement(doc, &element);
8537     EXPECT_HR(hr, S_OK);
8538
8539     hr = IXMLDOMElement_get_childNodes(element, &root_list);
8540     EXPECT_HR(hr, S_OK);
8541
8542     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
8543     EXPECT_HR(hr, S_OK);
8544     IXMLDOMNodeList_Release(root_list);
8545
8546     hr = IXMLDOMNode_get_attributes(pr_node, &map);
8547     EXPECT_HR(hr, S_OK);
8548     IXMLDOMNode_Release(pr_node);
8549
8550     len = 0;
8551     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
8552     EXPECT_HR(hr, S_OK);
8553     ok( len == 3, "length %d\n", len);
8554
8555     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, NULL);
8556     EXPECT_HR(hr, E_INVALIDARG);
8557
8558     node = (void*)0xdeadbeef;
8559     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, &node);
8560     EXPECT_HR(hr, E_INVALIDARG);
8561     ok( node == (void*)0xdeadbeef, "got %p\n", node);
8562
8563     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, NULL);
8564     EXPECT_HR(hr, E_INVALIDARG);
8565
8566     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, &node);
8567     EXPECT_HR(hr, S_OK);
8568
8569     IXMLDOMNode_Release(node);
8570     IXMLDOMNamedNodeMap_Release(map);
8571     IXMLDOMElement_Release(element);
8572
8573     hr = IXMLDOMDocument_loadXML(doc, _bstr_(default_ns_doc), &b);
8574     EXPECT_HR(hr, S_OK);
8575
8576     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("a"), &node);
8577     EXPECT_HR(hr, S_OK);
8578
8579     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&element);
8580     EXPECT_HR(hr, S_OK);
8581     IXMLDOMNode_Release(node);
8582
8583     hr = IXMLDOMElement_get_attributes(element, &map);
8584     EXPECT_HR(hr, S_OK);
8585
8586     ptr = qualified_item_tests;
8587     while (ptr->name)
8588     {
8589        node = (void*)0xdeadbeef;
8590        hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
8591        ok(hr == ptr->hr, "%s, %s: got 0x%08x, expected 0x%08x\n", ptr->name, ptr->uri, hr, ptr->hr);
8592        if (hr == S_OK)
8593            IXMLDOMNode_Release(node);
8594        else
8595            ok(node == NULL, "%s, %s: got %p\n", ptr->name, ptr->uri, node);
8596        ptr++;
8597     }
8598
8599     ptr = named_item_tests;
8600     while (ptr->name)
8601     {
8602        node = (void*)0xdeadbeef;
8603        hr = IXMLDOMNamedNodeMap_getNamedItem(map, _bstr_(ptr->name), &node);
8604        ok(hr == ptr->hr, "%s: got 0x%08x, expected 0x%08x\n", ptr->name, hr, ptr->hr);
8605        if (hr == S_OK)
8606            IXMLDOMNode_Release(node);
8607        else
8608            ok(node == NULL, "%s: got %p\n", ptr->name, node);
8609        ptr++;
8610     }
8611
8612     IXMLDOMNamedNodeMap_Release(map);
8613
8614     IXMLDOMElement_Release(element);
8615     IXMLDOMDocument_Release(doc);
8616     free_bstrs();
8617 }
8618
8619 static void test_removeQualifiedItem(void)
8620 {
8621     IXMLDOMDocument *doc;
8622     IXMLDOMElement *element;
8623     IXMLDOMNode *pr_node, *node;
8624     IXMLDOMNodeList *root_list;
8625     IXMLDOMNamedNodeMap *map;
8626     VARIANT_BOOL b;
8627     LONG len;
8628     HRESULT hr;
8629
8630     doc = create_document(&IID_IXMLDOMDocument);
8631     if (!doc) return;
8632
8633     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8634     ok( hr == S_OK, "loadXML failed\n");
8635     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8636
8637     hr = IXMLDOMDocument_get_documentElement(doc, &element);
8638     ok( hr == S_OK, "ret %08x\n", hr);
8639
8640     hr = IXMLDOMElement_get_childNodes(element, &root_list);
8641     ok( hr == S_OK, "ret %08x\n", hr);
8642
8643     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
8644     ok( hr == S_OK, "ret %08x\n", hr);
8645     IXMLDOMNodeList_Release(root_list);
8646
8647     hr = IXMLDOMNode_get_attributes(pr_node, &map);
8648     ok( hr == S_OK, "ret %08x\n", hr);
8649     IXMLDOMNode_Release(pr_node);
8650
8651     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
8652     ok( hr == S_OK, "ret %08x\n", hr);
8653     ok( len == 3, "length %d\n", len);
8654
8655     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, NULL);
8656     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
8657
8658     node = (void*)0xdeadbeef;
8659     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, &node);
8660     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
8661     ok( node == (void*)0xdeadbeef, "got %p\n", node);
8662
8663     /* out pointer is optional */
8664     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
8665     ok( hr == S_OK, "ret %08x\n", hr);
8666
8667     /* already removed */
8668     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
8669     ok( hr == S_FALSE, "ret %08x\n", hr);
8670
8671     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("vr"), NULL, &node);
8672     ok( hr == S_OK, "ret %08x\n", hr);
8673     IXMLDOMNode_Release(node);
8674
8675     IXMLDOMNamedNodeMap_Release( map );
8676     IXMLDOMElement_Release( element );
8677     IXMLDOMDocument_Release( doc );
8678     free_bstrs();
8679 }
8680
8681 #define check_default_props(doc) _check_default_props(__LINE__, doc)
8682 static inline void _check_default_props(int line, IXMLDOMDocument2* doc)
8683 {
8684     VARIANT_BOOL b;
8685     VARIANT var;
8686     HRESULT hr;
8687
8688     VariantInit(&var);
8689     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
8690     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XSLPattern")) == 0, "expected XSLPattern\n");
8691     VariantClear(&var);
8692
8693     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
8694     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("")) == 0, "expected empty string\n");
8695     VariantClear(&var);
8696
8697     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
8698     ok_(__FILE__, line)(b == VARIANT_FALSE, "expected FALSE\n");
8699
8700     hr = IXMLDOMDocument2_get_schemas(doc, &var);
8701     ok_(__FILE__, line)(hr == S_FALSE, "got %08x\n", hr);
8702     VariantClear(&var);
8703 }
8704
8705 #define check_set_props(doc) _check_set_props(__LINE__, doc)
8706 static inline void _check_set_props(int line, IXMLDOMDocument2* doc)
8707 {
8708     VARIANT_BOOL b;
8709     VARIANT var;
8710
8711     VariantInit(&var);
8712     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
8713     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XPath")) == 0, "expected XPath\n");
8714     VariantClear(&var);
8715
8716     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
8717     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("xmlns:wi=\'www.winehq.org\'")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&var)));
8718     VariantClear(&var);
8719
8720     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
8721     ok_(__FILE__, line)(b == VARIANT_TRUE, "expected TRUE\n");
8722
8723     helper_ole_check(IXMLDOMDocument2_get_schemas(doc, &var));
8724     ok_(__FILE__, line)(V_VT(&var) != VT_NULL, "expected pointer\n");
8725     VariantClear(&var);
8726 }
8727
8728 #define set_props(doc, cache) _set_props(__LINE__, doc, cache)
8729 static inline void _set_props(int line, IXMLDOMDocument2* doc, IXMLDOMSchemaCollection* cache)
8730 {
8731     VARIANT var;
8732
8733     VariantInit(&var);
8734     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
8735     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:wi=\'www.winehq.org\'")));
8736     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_TRUE));
8737     V_VT(&var) = VT_DISPATCH;
8738     V_DISPATCH(&var) = NULL;
8739     helper_ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&var)));
8740     ok_(__FILE__, line)(V_DISPATCH(&var) != NULL, "expected pointer\n");
8741     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
8742     VariantClear(&var);
8743 }
8744
8745 #define unset_props(doc) _unset_props(__LINE__, doc)
8746 static inline void _unset_props(int line, IXMLDOMDocument2* doc)
8747 {
8748     VARIANT var;
8749
8750     VariantInit(&var);
8751     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
8752     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("")));
8753     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_FALSE));
8754     V_VT(&var) = VT_NULL;
8755     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
8756     VariantClear(&var);
8757 }
8758
8759 static void test_get_ownerDocument(void)
8760 {
8761     IXMLDOMDocument *doc1, *doc2, *doc3;
8762     IXMLDOMDocument2 *doc, *doc_owner;
8763     IXMLDOMNode *node;
8764     IXMLDOMSchemaCollection *cache;
8765     VARIANT_BOOL b;
8766     VARIANT var;
8767
8768     doc = create_document(&IID_IXMLDOMDocument2);
8769     cache = create_cache(&IID_IXMLDOMSchemaCollection);
8770     if (!doc || !cache)
8771     {
8772         if (doc) IXMLDOMDocument2_Release(doc);
8773         if (cache) IXMLDOMSchemaCollection_Release(cache);
8774         return;
8775     }
8776
8777     VariantInit(&var);
8778
8779     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b));
8780     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8781
8782     check_default_props(doc);
8783
8784     /* set properties and check that new instances use them */
8785     set_props(doc, cache);
8786     check_set_props(doc);
8787
8788     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
8789     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc1));
8790
8791     /* new interface keeps props */
8792     ole_check(IXMLDOMDocument_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**)&doc_owner));
8793     ok( doc_owner != doc, "got %p, doc %p\n", doc_owner, doc);
8794     check_set_props(doc_owner);
8795     IXMLDOMDocument2_Release(doc_owner);
8796
8797     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc2));
8798     IXMLDOMNode_Release(node);
8799
8800     ok(doc1 != doc2, "got %p, expected %p. original %p\n", doc2, doc1, doc);
8801
8802     /* reload */
8803     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
8804     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8805
8806     /* properties retained even after reload */
8807     check_set_props(doc);
8808
8809     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
8810     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc3));
8811     IXMLDOMNode_Release(node);
8812
8813     ole_check(IXMLDOMDocument_QueryInterface(doc3, &IID_IXMLDOMDocument2, (void**)&doc_owner));
8814     ok(doc3 != doc1 && doc3 != doc2 && doc_owner != doc, "got %p, (%p, %p, %p)\n", doc3, doc, doc1, doc2);
8815     check_set_props(doc_owner);
8816
8817     /* changing properties for one instance changes them for all */
8818     unset_props(doc_owner);
8819     check_default_props(doc_owner);
8820     check_default_props(doc);
8821
8822     IXMLDOMSchemaCollection_Release(cache);
8823     IXMLDOMDocument_Release(doc1);
8824     IXMLDOMDocument_Release(doc2);
8825     IXMLDOMDocument_Release(doc3);
8826     IXMLDOMDocument2_Release(doc);
8827     IXMLDOMDocument2_Release(doc_owner);
8828     free_bstrs();
8829 }
8830
8831 static void test_setAttributeNode(void)
8832 {
8833     IXMLDOMDocument *doc, *doc2;
8834     IXMLDOMElement *elem, *elem2;
8835     IXMLDOMAttribute *attr, *attr2, *ret_attr;
8836     VARIANT_BOOL b;
8837     HRESULT hr;
8838     VARIANT v;
8839     BSTR str;
8840     ULONG ref1, ref2;
8841
8842     doc = create_document(&IID_IXMLDOMDocument);
8843     if (!doc) return;
8844
8845     hr = IXMLDOMDocument2_loadXML( doc, _bstr_(complete4A), &b );
8846     ok( hr == S_OK, "loadXML failed\n");
8847     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8848
8849     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
8850     ok( hr == S_OK, "got 0x%08x\n", hr);
8851
8852     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
8853     ok( hr == S_OK, "got 0x%08x\n", hr);
8854     ok( elem2 != elem, "got same instance\n");
8855
8856     ret_attr = (void*)0xdeadbeef;
8857     hr = IXMLDOMElement_setAttributeNode(elem, NULL, &ret_attr);
8858     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
8859     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8860
8861     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8862     ok( hr == S_OK, "got 0x%08x\n", hr);
8863
8864     ref1 = IXMLDOMElement_AddRef(elem);
8865     IXMLDOMElement_Release(elem);
8866
8867     ret_attr = (void*)0xdeadbeef;
8868     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8869     ok( hr == S_OK, "got 0x%08x\n", hr);
8870     ok( ret_attr == NULL, "got %p\n", ret_attr);
8871
8872     /* no reference added */
8873     ref2 = IXMLDOMElement_AddRef(elem);
8874     IXMLDOMElement_Release(elem);
8875     ok(ref2 == ref1, "got %d, expected %d\n", ref2, ref1);
8876
8877     EXPECT_CHILDREN(elem);
8878     EXPECT_CHILDREN(elem2);
8879
8880     IXMLDOMElement_Release(elem2);
8881
8882     attr2 = NULL;
8883     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attr"), &attr2);
8884     ok( hr == S_OK, "got 0x%08x\n", hr);
8885     ok( attr2 != attr, "got same instance %p\n", attr2);
8886     IXMLDOMAttribute_Release(attr2);
8887
8888     /* try to add it another time */
8889     ret_attr = (void*)0xdeadbeef;
8890     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8891     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8892     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8893
8894     IXMLDOMElement_Release(elem);
8895
8896     /* initially used element is released, attribute still 'has' a container */
8897     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
8898     ok( hr == S_OK, "got 0x%08x\n", hr);
8899     ret_attr = (void*)0xdeadbeef;
8900     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8901     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8902     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8903     IXMLDOMElement_Release(elem);
8904
8905     /* add attribute already attached to another document */
8906     doc2 = create_document(&IID_IXMLDOMDocument);
8907
8908     hr = IXMLDOMDocument_loadXML( doc2, _bstr_(complete4A), &b );
8909     ok( hr == S_OK, "loadXML failed\n");
8910     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8911
8912     hr = IXMLDOMDocument_get_documentElement(doc2, &elem);
8913     ok( hr == S_OK, "got 0x%08x\n", hr);
8914     hr = IXMLDOMElement_setAttributeNode(elem, attr, NULL);
8915     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8916     IXMLDOMElement_Release(elem);
8917
8918     IXMLDOMAttribute_Release(attr);
8919
8920     /* create element, add attribute, see if it's copied or linked */
8921     hr = IXMLDOMDocument_createElement(doc, _bstr_("test"), &elem);
8922     ok( hr == S_OK, "got 0x%08x\n", hr);
8923
8924     attr = NULL;
8925     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8926     ok(hr == S_OK, "got 0x%08x\n", hr);
8927     ok(attr != NULL, "got %p\n", attr);
8928
8929     ref1 = IXMLDOMAttribute_AddRef(attr);
8930     IXMLDOMAttribute_Release(attr);
8931
8932     V_VT(&v) = VT_BSTR;
8933     V_BSTR(&v) = _bstr_("attrvalue1");
8934     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
8935     ok( hr == S_OK, "got 0x%08x\n", hr);
8936
8937     str = NULL;
8938     hr = IXMLDOMAttribute_get_xml(attr, &str);
8939     ok( hr == S_OK, "got 0x%08x\n", hr);
8940     ok( lstrcmpW(str, _bstr_("attr=\"attrvalue1\"")) == 0,
8941         "got %s\n", wine_dbgstr_w(str));
8942     SysFreeString(str);
8943
8944     ret_attr = (void*)0xdeadbeef;
8945     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8946     ok(hr == S_OK, "got 0x%08x\n", hr);
8947     ok(ret_attr == NULL, "got %p\n", ret_attr);
8948
8949     /* attribute reference increased */
8950     ref2 = IXMLDOMAttribute_AddRef(attr);
8951     IXMLDOMAttribute_Release(attr);
8952     ok(ref1 == ref2, "got %d, expected %d\n", ref2, ref1);
8953
8954     hr = IXMLDOMElement_get_xml(elem, &str);
8955     ok( hr == S_OK, "got 0x%08x\n", hr);
8956     ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue1\"/>")) == 0,
8957         "got %s\n", wine_dbgstr_w(str));
8958     SysFreeString(str);
8959
8960     V_VT(&v) = VT_BSTR;
8961     V_BSTR(&v) = _bstr_("attrvalue2");
8962     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
8963     ok( hr == S_OK, "got 0x%08x\n", hr);
8964
8965     hr = IXMLDOMElement_get_xml(elem, &str);
8966     ok( hr == S_OK, "got 0x%08x\n", hr);
8967     todo_wine ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue2\"/>")) == 0,
8968         "got %s\n", wine_dbgstr_w(str));
8969     SysFreeString(str);
8970
8971     IXMLDOMElement_Release(elem);
8972     IXMLDOMAttribute_Release(attr);
8973     IXMLDOMDocument_Release(doc2);
8974     IXMLDOMDocument_Release(doc);
8975     free_bstrs();
8976 }
8977
8978 static void test_createNode(void)
8979 {
8980     IXMLDOMDocument *doc;
8981     IXMLDOMElement *elem;
8982     IXMLDOMNode *node;
8983     VARIANT v, var;
8984     BSTR prefix, str;
8985     HRESULT hr;
8986     ULONG ref;
8987
8988     doc = create_document(&IID_IXMLDOMDocument);
8989     if (!doc) return;
8990
8991     EXPECT_REF(doc, 1);
8992
8993     /* reference count tests */
8994     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
8995     ok( hr == S_OK, "got 0x%08x\n", hr);
8996
8997     /* initial reference is 2 */
8998 todo_wine {
8999     EXPECT_REF(elem, 2);
9000     ref = IXMLDOMElement_Release(elem);
9001     ok(ref == 1, "got %d\n", ref);
9002     /* it's released already, attempt to release now will crash it */
9003 }
9004
9005     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
9006     ok( hr == S_OK, "got 0x%08x\n", hr);
9007     todo_wine EXPECT_REF(elem, 2);
9008     IXMLDOMDocument_Release(doc);
9009     todo_wine EXPECT_REF(elem, 2);
9010     IXMLDOMElement_Release(elem);
9011
9012     doc = create_document(&IID_IXMLDOMDocument);
9013
9014     /* NODE_ELEMENT nodes */
9015     /* 1. specified namespace */
9016     V_VT(&v) = VT_I4;
9017     V_I4(&v) = NODE_ELEMENT;
9018
9019     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("ns1:test"), _bstr_("http://winehq.org"), &node);
9020     ok( hr == S_OK, "got 0x%08x\n", hr);
9021     prefix = NULL;
9022     hr = IXMLDOMNode_get_prefix(node, &prefix);
9023     ok( hr == S_OK, "got 0x%08x\n", hr);
9024     ok(lstrcmpW(prefix, _bstr_("ns1")) == 0, "wrong prefix\n");
9025     SysFreeString(prefix);
9026     IXMLDOMNode_Release(node);
9027
9028     /* 2. default namespace */
9029     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("test"), _bstr_("http://winehq.org/default"), &node);
9030     ok( hr == S_OK, "got 0x%08x\n", hr);
9031     prefix = (void*)0xdeadbeef;
9032     hr = IXMLDOMNode_get_prefix(node, &prefix);
9033     ok( hr == S_FALSE, "got 0x%08x\n", hr);
9034     ok(prefix == 0, "expected empty prefix, got %p\n", prefix);
9035     /* check dump */
9036     hr = IXMLDOMNode_get_xml(node, &str);
9037     ok( hr == S_OK, "got 0x%08x\n", hr);
9038     ok( lstrcmpW(str, _bstr_("<test xmlns=\"http://winehq.org/default\"/>")) == 0,
9039         "got %s\n", wine_dbgstr_w(str));
9040     SysFreeString(str);
9041
9042     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
9043     ok( hr == S_OK, "got 0x%08x\n", hr);
9044
9045     V_VT(&var) = VT_BSTR;
9046     hr = IXMLDOMElement_getAttribute(elem, _bstr_("xmlns"), &var);
9047     ok( hr == S_FALSE, "got 0x%08x\n", hr);
9048     ok( V_VT(&var) == VT_NULL, "got %d\n", V_VT(&var));
9049
9050     str = NULL;
9051     hr = IXMLDOMElement_get_namespaceURI(elem, &str);
9052     ok( hr == S_OK, "got 0x%08x\n", hr);
9053     ok( lstrcmpW(str, _bstr_("http://winehq.org/default")) == 0, "expected default namespace\n");
9054     SysFreeString(str);
9055
9056     IXMLDOMElement_Release(elem);
9057     IXMLDOMNode_Release(node);
9058
9059     IXMLDOMDocument_Release(doc);
9060     free_bstrs();
9061 }
9062
9063 static const char get_prefix_doc[] =
9064     "<?xml version=\"1.0\" ?>"
9065     "<a xmlns:ns1=\"ns1 href\" />";
9066
9067 static void test_get_prefix(void)
9068 {
9069     IXMLDOMDocumentFragment *fragment;
9070     IXMLDOMCDATASection *cdata;
9071     IXMLDOMElement *element;
9072     IXMLDOMComment *comment;
9073     IXMLDOMDocument *doc;
9074     VARIANT_BOOL b;
9075     HRESULT hr;
9076     BSTR str;
9077
9078     doc = create_document(&IID_IXMLDOMDocument);
9079     if (!doc) return;
9080
9081     /* nodes that can't support prefix */
9082     /* 1. document */
9083     str = (void*)0xdeadbeef;
9084     hr = IXMLDOMDocument_get_prefix(doc, &str);
9085     EXPECT_HR(hr, S_FALSE);
9086     ok(str == NULL, "got %p\n", str);
9087
9088     hr = IXMLDOMDocument_get_prefix(doc, NULL);
9089     EXPECT_HR(hr, E_INVALIDARG);
9090
9091     /* 2. cdata */
9092     hr = IXMLDOMDocument_createCDATASection(doc, NULL, &cdata);
9093     ok(hr == S_OK, "got %08x\n", hr );
9094
9095     str = (void*)0xdeadbeef;
9096     hr = IXMLDOMCDATASection_get_prefix(cdata, &str);
9097     ok(hr == S_FALSE, "got %08x\n", hr);
9098     ok( str == 0, "got %p\n", str);
9099
9100     hr = IXMLDOMCDATASection_get_prefix(cdata, NULL);
9101     ok(hr == E_INVALIDARG, "got %08x\n", hr);
9102     IXMLDOMCDATASection_Release(cdata);
9103
9104     /* 3. comment */
9105     hr = IXMLDOMDocument_createComment(doc, NULL, &comment);
9106     ok(hr == S_OK, "got %08x\n", hr );
9107
9108     str = (void*)0xdeadbeef;
9109     hr = IXMLDOMComment_get_prefix(comment, &str);
9110     ok(hr == S_FALSE, "got %08x\n", hr);
9111     ok( str == 0, "got %p\n", str);
9112
9113     hr = IXMLDOMComment_get_prefix(comment, NULL);
9114     ok(hr == E_INVALIDARG, "got %08x\n", hr);
9115     IXMLDOMComment_Release(comment);
9116
9117     /* 4. fragment */
9118     hr = IXMLDOMDocument_createDocumentFragment(doc, &fragment);
9119     ok(hr == S_OK, "got %08x\n", hr );
9120
9121     str = (void*)0xdeadbeef;
9122     hr = IXMLDOMDocumentFragment_get_prefix(fragment, &str);
9123     ok(hr == S_FALSE, "got %08x\n", hr);
9124     ok( str == 0, "got %p\n", str);
9125
9126     hr = IXMLDOMDocumentFragment_get_prefix(fragment, NULL);
9127     ok(hr == E_INVALIDARG, "got %08x\n", hr);
9128     IXMLDOMDocumentFragment_Release(fragment);
9129
9130     /* no prefix */
9131     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &element);
9132     ok( hr == S_OK, "got 0x%08x\n", hr);
9133
9134     hr = IXMLDOMElement_get_prefix(element, NULL);
9135     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
9136
9137     str = (void*)0xdeadbeef;
9138     hr = IXMLDOMElement_get_prefix(element, &str);
9139     ok( hr == S_FALSE, "got 0x%08x\n", hr);
9140     ok( str == 0, "got %p\n", str);
9141
9142     IXMLDOMElement_Release(element);
9143
9144     /* with prefix */
9145     hr = IXMLDOMDocument_createElement(doc, _bstr_("a:elem"), &element);
9146     ok( hr == S_OK, "got 0x%08x\n", hr);
9147
9148     str = (void*)0xdeadbeef;
9149     hr = IXMLDOMElement_get_prefix(element, &str);
9150     ok( hr == S_OK, "got 0x%08x\n", hr);
9151     ok( lstrcmpW(str, _bstr_("a")) == 0, "expected prefix \"a\"\n");
9152     SysFreeString(str);
9153
9154     str = (void*)0xdeadbeef;
9155     hr = IXMLDOMElement_get_namespaceURI(element, &str);
9156     ok( hr == S_FALSE, "got 0x%08x\n", hr);
9157     ok( str == 0, "got %p\n", str);
9158
9159     IXMLDOMElement_Release(element);
9160
9161     hr = IXMLDOMDocument_loadXML(doc, _bstr_(get_prefix_doc), &b);
9162     EXPECT_HR(hr, S_OK);
9163
9164     hr = IXMLDOMDocument_get_documentElement(doc, &element);
9165     EXPECT_HR(hr, S_OK);
9166
9167     str = (void*)0xdeadbeef;
9168     hr = IXMLDOMElement_get_prefix(element, &str);
9169     EXPECT_HR(hr, S_FALSE);
9170     ok(str == NULL, "got %p\n", str);
9171
9172     str = (void*)0xdeadbeef;
9173     hr = IXMLDOMElement_get_namespaceURI(element, &str);
9174     EXPECT_HR(hr, S_FALSE);
9175     ok(str == NULL, "got %s\n", wine_dbgstr_w(str));
9176
9177     IXMLDOMDocument_Release(doc);
9178     free_bstrs();
9179 }
9180
9181 static void test_selectSingleNode(void)
9182 {
9183     IXMLDOMDocument *doc;
9184     IXMLDOMNodeList *list;
9185     IXMLDOMNode *node;
9186     VARIANT_BOOL b;
9187     HRESULT hr;
9188     LONG len;
9189
9190     doc = create_document(&IID_IXMLDOMDocument);
9191     if (!doc) return;
9192
9193     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
9194     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9195
9196     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
9197     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9198
9199     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
9200     ok( hr == S_OK, "loadXML failed\n");
9201     ok( b == VARIANT_TRUE, "failed to load XML string\n");
9202
9203     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
9204     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9205
9206     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
9207     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9208
9209     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), NULL);
9210     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9211
9212     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), NULL);
9213     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9214
9215     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), &node);
9216     ok(hr == S_OK, "got 0x%08x\n", hr);
9217     IXMLDOMNode_Release(node);
9218
9219     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), &list);
9220     ok(hr == S_OK, "got 0x%08x\n", hr);
9221     IXMLDOMNodeList_Release(list);
9222
9223     list = (void*)0xdeadbeef;
9224     hr = IXMLDOMDocument_selectNodes(doc, NULL, &list);
9225     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9226     ok(list == (void*)0xdeadbeef, "got %p\n", list);
9227
9228     node = (void*)0xdeadbeef;
9229     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("nonexistent"), &node);
9230     ok(hr == S_FALSE, "got 0x%08x\n", hr);
9231     ok(node == 0, "got %p\n", node);
9232
9233     list = (void*)0xdeadbeef;
9234     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("nonexistent"), &list);
9235     ok(hr == S_OK, "got 0x%08x\n", hr);
9236     len = 1;
9237     hr = IXMLDOMNodeList_get_length(list, &len);
9238     ok(hr == S_OK, "got 0x%08x\n", hr);
9239     ok(len == 0, "got %d\n", len);
9240     IXMLDOMNodeList_Release(list);
9241
9242     IXMLDOMDocument_Release(doc);
9243     free_bstrs();
9244 }
9245
9246 static void test_events(void)
9247 {
9248     IConnectionPointContainer *conn;
9249     IConnectionPoint *point;
9250     IXMLDOMDocument *doc;
9251     HRESULT hr;
9252     VARIANT v;
9253     IDispatch *event;
9254
9255     doc = create_document(&IID_IXMLDOMDocument);
9256     if (!doc) return;
9257
9258     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&conn);
9259     ok(hr == S_OK, "got 0x%08x\n", hr);
9260
9261     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IDispatch, &point);
9262     ok(hr == S_OK, "got 0x%08x\n", hr);
9263     IConnectionPoint_Release(point);
9264     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IPropertyNotifySink, &point);
9265     ok(hr == S_OK, "got 0x%08x\n", hr);
9266     IConnectionPoint_Release(point);
9267     hr = IConnectionPointContainer_FindConnectionPoint(conn, &DIID_XMLDOMDocumentEvents, &point);
9268     ok(hr == S_OK, "got 0x%08x\n", hr);
9269     IConnectionPoint_Release(point);
9270
9271     IConnectionPointContainer_Release(conn);
9272
9273     /* ready state callback */
9274     VariantInit(&v);
9275     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9276     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
9277
9278     event = create_dispevent();
9279     V_VT(&v) = VT_UNKNOWN;
9280     V_UNKNOWN(&v) = (IUnknown*)event;
9281
9282     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9283     ok(hr == S_OK, "got 0x%08x\n", hr);
9284     EXPECT_REF(event, 2);
9285
9286     V_VT(&v) = VT_DISPATCH;
9287     V_DISPATCH(&v) = event;
9288
9289     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9290     ok(hr == S_OK, "got 0x%08x\n", hr);
9291     EXPECT_REF(event, 2);
9292
9293     /* VT_NULL doesn't reset event handler */
9294     V_VT(&v) = VT_NULL;
9295     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9296     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
9297     EXPECT_REF(event, 2);
9298
9299     V_VT(&v) = VT_DISPATCH;
9300     V_DISPATCH(&v) = NULL;
9301
9302     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9303     ok(hr == S_OK, "got 0x%08x\n", hr);
9304     EXPECT_REF(event, 1);
9305
9306     V_VT(&v) = VT_UNKNOWN;
9307     V_DISPATCH(&v) = NULL;
9308     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9309     ok(hr == S_OK, "got 0x%08x\n", hr);
9310
9311     IDispatch_Release(event);
9312
9313     IXMLDOMDocument_Release(doc);
9314 }
9315
9316 static void test_createProcessingInstruction(void)
9317 {
9318     static const WCHAR bodyW[] = {'t','e','s','t',0};
9319     IXMLDOMProcessingInstruction *pi;
9320     IXMLDOMDocument *doc;
9321     WCHAR buff[10];
9322     HRESULT hr;
9323
9324     doc = create_document(&IID_IXMLDOMDocument);
9325     if (!doc) return;
9326
9327     /* test for BSTR handling, pass broken BSTR */
9328     memcpy(&buff[2], bodyW, sizeof(bodyW));
9329     /* just a big length */
9330     *(DWORD*)buff = 0xf0f0;
9331     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("test"), &buff[2], &pi);
9332     ok(hr == S_OK, "got 0x%08x\n", hr);
9333
9334     IXMLDOMProcessingInstruction_Release(pi);
9335     IXMLDOMDocument_Release(doc);
9336 }
9337
9338 static void test_put_nodeTypedValue(void)
9339 {
9340     static const BYTE binhexdata[16] =
9341         {0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf};
9342     IXMLDOMDocument *doc;
9343     IXMLDOMElement *elem;
9344     VARIANT type, value;
9345     LONG ubound, lbound;
9346     IXMLDOMNode *node;
9347     SAFEARRAY *array;
9348     HRESULT hr;
9349     BYTE *ptr;
9350     BSTR str;
9351
9352     doc = create_document(&IID_IXMLDOMDocument);
9353     if (!doc) return;
9354
9355     hr = IXMLDOMDocument_createElement(doc, _bstr_("Element"), &elem);
9356     EXPECT_HR(hr, S_OK);
9357
9358     V_VT(&type) = VT_EMPTY;
9359     hr = IXMLDOMElement_get_dataType(elem, &type);
9360     EXPECT_HR(hr, S_FALSE);
9361     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
9362
9363     /* set typed value for untyped node */
9364     V_VT(&type) = VT_I1;
9365     V_I1(&type) = 1;
9366     hr = IXMLDOMElement_put_nodeTypedValue(elem, type);
9367     EXPECT_HR(hr, S_OK);
9368
9369     V_VT(&type) = VT_EMPTY;
9370     hr = IXMLDOMElement_get_dataType(elem, &type);
9371     EXPECT_HR(hr, S_FALSE);
9372     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
9373
9374     /* no type info stored */
9375     V_VT(&type) = VT_EMPTY;
9376     hr = IXMLDOMElement_get_nodeTypedValue(elem, &type);
9377     EXPECT_HR(hr, S_OK);
9378     ok(V_VT(&type) == VT_BSTR, "got %d, expected VT_BSTR\n", V_VT(&type));
9379     ok(memcmp(V_BSTR(&type), _bstr_("1"), 2*sizeof(WCHAR)) == 0,
9380        "got %s, expected \"1\"\n", wine_dbgstr_w(V_BSTR(&type)));
9381     VariantClear(&type);
9382
9383     hr = IXMLDOMElement_get_firstChild(elem, &node);
9384     EXPECT_HR(hr, S_OK);
9385     hr = IXMLDOMElement_removeChild(elem, node, NULL);
9386     EXPECT_HR(hr, S_OK);
9387     IXMLDOMNode_Release(node);
9388
9389     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)elem, NULL);
9390     EXPECT_HR(hr, S_OK);
9391
9392     /* bin.base64 */
9393     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.base64"));
9394     EXPECT_HR(hr, S_OK);
9395
9396     V_VT(&value) = VT_BSTR;
9397     V_BSTR(&value) = _bstr_("ABCD");
9398     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
9399     EXPECT_HR(hr, S_OK);
9400
9401     V_VT(&value) = VT_EMPTY;
9402     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
9403     EXPECT_HR(hr, S_OK);
9404     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
9405     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
9406     ubound = 0;
9407     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
9408     EXPECT_HR(hr, S_OK);
9409     ok(ubound == 2, "got %d\n", ubound);
9410     lbound = 0;
9411     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
9412     EXPECT_HR(hr, S_OK);
9413     ok(lbound == 0, "got %d\n", lbound);
9414     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
9415     EXPECT_HR(hr, S_OK);
9416     ok(ptr[0] == 0, "got %x\n", ptr[0]);
9417     ok(ptr[1] == 0x10, "got %x\n", ptr[1]);
9418     ok(ptr[2] == 0x83, "got %x\n", ptr[2]);
9419     SafeArrayUnaccessData(V_ARRAY(&value));
9420     VariantClear(&value);
9421
9422     /* when set as VT_BSTR it's stored as is */
9423     hr = IXMLDOMElement_get_firstChild(elem, &node);
9424     EXPECT_HR(hr, S_OK);
9425     hr = IXMLDOMNode_get_text(node, &str);
9426     EXPECT_HR(hr, S_OK);
9427     ok(!lstrcmpW(str, _bstr_("ABCD")), "%s\n", wine_dbgstr_w(str));
9428     IXMLDOMNode_Release(node);
9429
9430     array = SafeArrayCreateVector(VT_UI1, 0, 7);
9431     hr = SafeArrayAccessData(array, (void*)&ptr);
9432     EXPECT_HR(hr, S_OK);
9433     memcpy(ptr, "dGVzdA=", strlen("dGVzdA="));
9434     SafeArrayUnaccessData(array);
9435
9436     V_VT(&value) = VT_UI1|VT_ARRAY;
9437     V_ARRAY(&value) = array;
9438     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
9439     EXPECT_HR(hr, S_OK);
9440
9441     V_VT(&value) = VT_EMPTY;
9442     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
9443     EXPECT_HR(hr, S_OK);
9444     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
9445     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
9446     ubound = 0;
9447     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
9448     EXPECT_HR(hr, S_OK);
9449     ok(ubound == 6, "got %d\n", ubound);
9450     lbound = 0;
9451     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
9452     EXPECT_HR(hr, S_OK);
9453     ok(lbound == 0, "got %d\n", lbound);
9454     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
9455     EXPECT_HR(hr, S_OK);
9456     ok(!memcmp(ptr, "dGVzdA=", strlen("dGVzdA=")), "got wrong data, %s\n", ptr);
9457     SafeArrayUnaccessData(V_ARRAY(&value));
9458     VariantClear(&value);
9459
9460     /* if set with VT_UI1|VT_ARRAY it's encoded */
9461     hr = IXMLDOMElement_get_firstChild(elem, &node);
9462     EXPECT_HR(hr, S_OK);
9463     hr = IXMLDOMNode_get_text(node, &str);
9464     EXPECT_HR(hr, S_OK);
9465     ok(!lstrcmpW(str, _bstr_("ZEdWemRBPQ==")), "%s\n", wine_dbgstr_w(str));
9466     IXMLDOMNode_Release(node);
9467     SafeArrayDestroyData(array);
9468
9469     /* bin.hex */
9470     V_VT(&value) = VT_BSTR;
9471     V_BSTR(&value) = _bstr_("");
9472     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
9473     EXPECT_HR(hr, S_OK);
9474
9475     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.hex"));
9476     EXPECT_HR(hr, S_OK);
9477
9478     array = SafeArrayCreateVector(VT_UI1, 0, 16);
9479     hr = SafeArrayAccessData(array, (void*)&ptr);
9480     EXPECT_HR(hr, S_OK);
9481     memcpy(ptr, binhexdata, sizeof(binhexdata));
9482     SafeArrayUnaccessData(array);
9483
9484     V_VT(&value) = VT_UI1|VT_ARRAY;
9485     V_ARRAY(&value) = array;
9486     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
9487     EXPECT_HR(hr, S_OK);
9488
9489     V_VT(&value) = VT_EMPTY;
9490     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
9491     EXPECT_HR(hr, S_OK);
9492     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
9493     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
9494     ubound = 0;
9495     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
9496     EXPECT_HR(hr, S_OK);
9497     ok(ubound == 15, "got %d\n", ubound);
9498     lbound = 0;
9499     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
9500     EXPECT_HR(hr, S_OK);
9501     ok(lbound == 0, "got %d\n", lbound);
9502     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
9503     EXPECT_HR(hr, S_OK);
9504     ok(!memcmp(ptr, binhexdata, sizeof(binhexdata)), "got wrong data\n");
9505     SafeArrayUnaccessData(V_ARRAY(&value));
9506     VariantClear(&value);
9507
9508     /* if set with VT_UI1|VT_ARRAY it's encoded */
9509     hr = IXMLDOMElement_get_firstChild(elem, &node);
9510     EXPECT_HR(hr, S_OK);
9511     hr = IXMLDOMNode_get_text(node, &str);
9512     EXPECT_HR(hr, S_OK);
9513     ok(!lstrcmpW(str, _bstr_("000102030405060708090a0b0c0d0e0f")), "%s\n", wine_dbgstr_w(str));
9514     IXMLDOMNode_Release(node);
9515     SafeArrayDestroyData(array);
9516
9517     IXMLDOMElement_Release(elem);
9518     IXMLDOMDocument_Release(doc);
9519     free_bstrs();
9520 }
9521
9522 static void test_get_xml(void)
9523 {
9524     static const char xmlA[] = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\r\n<a>test</a>\r\n";
9525     static const char fooA[] = "<foo/>";
9526     IXMLDOMProcessingInstruction *pi;
9527     IXMLDOMNode *first;
9528     IXMLDOMElement *elem = NULL;
9529     IXMLDOMDocument *doc;
9530     VARIANT_BOOL b;
9531     VARIANT v;
9532     BSTR xml;
9533     HRESULT hr;
9534
9535     doc = create_document(&IID_IXMLDOMDocument);
9536     if (!doc) return;
9537
9538     b = VARIANT_TRUE;
9539     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
9540     ok(hr == S_OK, "got 0x%08x\n", hr);
9541     ok( b == VARIANT_TRUE, "got %d\n", b);
9542
9543     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"),
9544                              _bstr_("version=\"1.0\" encoding=\"UTF-16\""), &pi);
9545     ok(hr == S_OK, "got 0x%08x\n", hr);
9546
9547     hr = IXMLDOMDocument_get_firstChild(doc, &first);
9548     ok(hr == S_OK, "got 0x%08x\n", hr);
9549
9550     V_UNKNOWN(&v) = (IUnknown*)first;
9551     V_VT(&v) = VT_UNKNOWN;
9552
9553     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)pi, v, NULL);
9554     ok(hr == S_OK, "got 0x%08x\n", hr);
9555
9556     IXMLDOMProcessingInstruction_Release(pi);
9557     IXMLDOMNode_Release(first);
9558
9559     hr = IXMLDOMDocument_get_xml(doc, &xml);
9560     ok(hr == S_OK, "got 0x%08x\n", hr);
9561
9562     ok(memcmp(xml, _bstr_(xmlA), sizeof(xmlA)*sizeof(WCHAR)) == 0,
9563         "got %s, expected %s\n", wine_dbgstr_w(xml), xmlA);
9564     SysFreeString(xml);
9565
9566     IXMLDOMDocument_Release(doc);
9567
9568     doc = create_document(&IID_IXMLDOMDocument);
9569
9570     hr = IXMLDOMDocument_createElement(doc, _bstr_("foo"), &elem);
9571     ok(hr == S_OK, "got 0x%08x\n", hr);
9572
9573     hr = IXMLDOMDocument_putref_documentElement(doc, elem);
9574     ok(hr == S_OK, "got 0x%08x\n", hr);
9575
9576     hr = IXMLDOMDocument_get_xml(doc, &xml);
9577     ok(hr == S_OK, "got 0x%08x\n", hr);
9578
9579     ok(memcmp(xml, _bstr_(fooA), (sizeof(fooA)-1)*sizeof(WCHAR)) == 0,
9580         "got %s, expected %s\n", wine_dbgstr_w(xml), fooA);
9581     SysFreeString(xml);
9582
9583     IXMLDOMElement_Release(elem);
9584     IXMLDOMDocument_Release(doc);
9585
9586     free_bstrs();
9587 }
9588
9589 static void test_xsltemplate(void)
9590 {
9591     IXSLTemplate *template;
9592     IXSLProcessor *processor;
9593     IXMLDOMDocument *doc, *doc2;
9594     IStream *stream;
9595     VARIANT_BOOL b;
9596     HRESULT hr;
9597     ULONG ref1, ref2;
9598     VARIANT v;
9599
9600     template = create_xsltemplate(&IID_IXSLTemplate);
9601     if (!template) return;
9602
9603     /* works as reset */
9604     hr = IXSLTemplate_putref_stylesheet(template, NULL);
9605     ok(hr == S_OK, "got 0x%08x\n", hr);
9606
9607     doc = create_document(&IID_IXMLDOMDocument);
9608
9609     b = VARIANT_TRUE;
9610     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
9611     ok(hr == S_OK, "got 0x%08x\n", hr);
9612     ok( b == VARIANT_TRUE, "got %d\n", b);
9613
9614     /* putref with non-xsl document */
9615     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
9616     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
9617
9618     b = VARIANT_TRUE;
9619     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
9620     ok(hr == S_OK, "got 0x%08x\n", hr);
9621     ok( b == VARIANT_TRUE, "got %d\n", b);
9622
9623     /* not a freethreaded document */
9624     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
9625     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
9626
9627     IXMLDOMDocument_Release(doc);
9628
9629     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
9630     if (hr != S_OK)
9631     {
9632         win_skip("failed to create free threaded document instance: 0x%08x\n", hr);
9633         IXSLTemplate_Release(template);
9634         return;
9635     }
9636
9637     b = VARIANT_TRUE;
9638     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
9639     ok(hr == S_OK, "got 0x%08x\n", hr);
9640     ok( b == VARIANT_TRUE, "got %d\n", b);
9641
9642     /* freethreaded document */
9643     ref1 = IXMLDOMDocument_AddRef(doc);
9644     IXMLDOMDocument_Release(doc);
9645     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
9646     ok(hr == S_OK, "got 0x%08x\n", hr);
9647     ref2 = IXMLDOMDocument_AddRef(doc);
9648     IXMLDOMDocument_Release(doc);
9649     ok(ref2 > ref1, "got %d\n", ref2);
9650
9651     /* processor */
9652     hr = IXSLTemplate_createProcessor(template, NULL);
9653     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9654
9655     EXPECT_REF(template, 1);
9656     hr = IXSLTemplate_createProcessor(template, &processor);
9657     ok(hr == S_OK, "got 0x%08x\n", hr);
9658     EXPECT_REF(template, 2);
9659
9660     /* input no set yet */
9661     V_VT(&v) = VT_BSTR;
9662     V_BSTR(&v) = NULL;
9663     hr = IXSLProcessor_get_input(processor, &v);
9664 todo_wine {
9665     ok(hr == S_OK, "got 0x%08x\n", hr);
9666     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
9667 }
9668
9669     hr = IXSLProcessor_get_output(processor, NULL);
9670     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9671
9672     /* reset before it was set */
9673     V_VT(&v) = VT_EMPTY;
9674     hr = IXSLProcessor_put_output(processor, v);
9675     ok(hr == S_OK, "got 0x%08x\n", hr);
9676
9677     CreateStreamOnHGlobal(NULL, TRUE, &stream);
9678     EXPECT_REF(stream, 1);
9679
9680     V_VT(&v) = VT_UNKNOWN;
9681     V_UNKNOWN(&v) = (IUnknown*)stream;
9682     hr = IXSLProcessor_put_output(processor, v);
9683     ok(hr == S_OK, "got 0x%08x\n", hr);
9684
9685     /* it seems processor grabs 2 references */
9686     todo_wine EXPECT_REF(stream, 3);
9687
9688     V_VT(&v) = VT_EMPTY;
9689     hr = IXSLProcessor_get_output(processor, &v);
9690     ok(hr == S_OK, "got 0x%08x\n", hr);
9691     ok(V_VT(&v) == VT_UNKNOWN, "got type %d\n", V_VT(&v));
9692     ok(V_UNKNOWN(&v) == (IUnknown*)stream, "got %p\n", V_UNKNOWN(&v));
9693
9694     todo_wine EXPECT_REF(stream, 4);
9695     VariantClear(&v);
9696
9697     hr = IXSLProcessor_transform(processor, NULL);
9698     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9699
9700     /* reset and check stream refcount */
9701     V_VT(&v) = VT_EMPTY;
9702     hr = IXSLProcessor_put_output(processor, v);
9703     ok(hr == S_OK, "got 0x%08x\n", hr);
9704
9705     EXPECT_REF(stream, 1);
9706
9707     IStream_Release(stream);
9708
9709     /* no output interface set, check output */
9710     doc2 = create_document(&IID_IXMLDOMDocument);
9711
9712     b = VARIANT_TRUE;
9713     hr = IXMLDOMDocument_loadXML( doc2, _bstr_("<a>test</a>"), &b );
9714     ok(hr == S_OK, "got 0x%08x\n", hr);
9715     ok( b == VARIANT_TRUE, "got %d\n", b);
9716
9717     V_VT(&v) = VT_UNKNOWN;
9718     V_UNKNOWN(&v) = (IUnknown*)doc2;
9719     hr = IXSLProcessor_put_input(processor, v);
9720     ok(hr == S_OK, "got 0x%08x\n", hr);
9721
9722     hr = IXSLProcessor_transform(processor, &b);
9723     ok(hr == S_OK, "got 0x%08x\n", hr);
9724
9725     V_VT(&v) = VT_EMPTY;
9726     hr = IXSLProcessor_get_output(processor, &v);
9727     ok(hr == S_OK, "got 0x%08x\n", hr);
9728     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
9729     /* we currently output one '\n' instead of empty string */
9730     todo_wine ok(lstrcmpW(V_BSTR(&v), _bstr_("")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
9731     IXMLDOMDocument_Release(doc2);
9732     VariantClear(&v);
9733
9734     IXSLProcessor_Release(processor);
9735
9736     /* drop reference */
9737     hr = IXSLTemplate_putref_stylesheet(template, NULL);
9738     ok(hr == S_OK, "got 0x%08x\n", hr);
9739     ref2 = IXMLDOMDocument_AddRef(doc);
9740     IXMLDOMDocument_Release(doc);
9741     ok(ref2 == ref1, "got %d\n", ref2);
9742
9743     IXMLDOMDocument_Release(doc);
9744     IXSLTemplate_Release(template);
9745     free_bstrs();
9746 }
9747
9748 static void test_insertBefore(void)
9749 {
9750     IXMLDOMDocument *doc, *doc2;
9751     IXMLDOMAttribute *attr;
9752     IXMLDOMElement *elem1, *elem2, *elem3, *elem4, *elem5;
9753     IXMLDOMNode *node, *newnode;
9754     HRESULT hr;
9755     VARIANT v;
9756     BSTR p;
9757
9758     doc = create_document(&IID_IXMLDOMDocument);
9759
9760     /* insertBefore behaviour for attribute node */
9761     V_VT(&v) = VT_I4;
9762     V_I4(&v) = NODE_ATTRIBUTE;
9763
9764     attr = NULL;
9765     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr"), NULL, (IXMLDOMNode**)&attr);
9766     ok(hr == S_OK, "got 0x%08x\n", hr);
9767     ok(attr != NULL, "got %p\n", attr);
9768
9769     /* attribute to attribute */
9770     V_VT(&v) = VT_I4;
9771     V_I4(&v) = NODE_ATTRIBUTE;
9772     newnode = NULL;
9773     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr2"), NULL, &newnode);
9774     ok(hr == S_OK, "got 0x%08x\n", hr);
9775     ok(newnode != NULL, "got %p\n", newnode);
9776
9777     V_VT(&v) = VT_NULL;
9778     node = (void*)0xdeadbeef;
9779     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9780     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9781     ok(node == NULL, "got %p\n", node);
9782
9783     V_VT(&v) = VT_UNKNOWN;
9784     V_UNKNOWN(&v) = (IUnknown*)attr;
9785     node = (void*)0xdeadbeef;
9786     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9787     todo_wine ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9788     ok(node == NULL, "got %p\n", node);
9789     IXMLDOMNode_Release(newnode);
9790
9791     /* cdata to attribute */
9792     V_VT(&v) = VT_I4;
9793     V_I4(&v) = NODE_CDATA_SECTION;
9794     newnode = NULL;
9795     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9796     ok(hr == S_OK, "got 0x%08x\n", hr);
9797     ok(newnode != NULL, "got %p\n", newnode);
9798
9799     V_VT(&v) = VT_NULL;
9800     node = (void*)0xdeadbeef;
9801     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9802     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9803     ok(node == NULL, "got %p\n", node);
9804     IXMLDOMNode_Release(newnode);
9805
9806     /* comment to attribute */
9807     V_VT(&v) = VT_I4;
9808     V_I4(&v) = NODE_COMMENT;
9809     newnode = NULL;
9810     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9811     ok(hr == S_OK, "got 0x%08x\n", hr);
9812     ok(newnode != NULL, "got %p\n", newnode);
9813
9814     V_VT(&v) = VT_NULL;
9815     node = (void*)0xdeadbeef;
9816     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9817     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9818     ok(node == NULL, "got %p\n", node);
9819     IXMLDOMNode_Release(newnode);
9820
9821     /* element to attribute */
9822     V_VT(&v) = VT_I4;
9823     V_I4(&v) = NODE_ELEMENT;
9824     newnode = NULL;
9825     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9826     ok(hr == S_OK, "got 0x%08x\n", hr);
9827     ok(newnode != NULL, "got %p\n", newnode);
9828
9829     V_VT(&v) = VT_NULL;
9830     node = (void*)0xdeadbeef;
9831     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9832     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9833     ok(node == NULL, "got %p\n", node);
9834     IXMLDOMNode_Release(newnode);
9835
9836     /* pi to attribute */
9837     V_VT(&v) = VT_I4;
9838     V_I4(&v) = NODE_PROCESSING_INSTRUCTION;
9839     newnode = NULL;
9840     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9841     ok(hr == S_OK, "got 0x%08x\n", hr);
9842     ok(newnode != NULL, "got %p\n", newnode);
9843
9844     V_VT(&v) = VT_NULL;
9845     node = (void*)0xdeadbeef;
9846     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9847     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9848     ok(node == NULL, "got %p\n", node);
9849     IXMLDOMNode_Release(newnode);
9850     IXMLDOMAttribute_Release(attr);
9851
9852     /* insertBefore for elements */
9853     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem1);
9854     ok(hr == S_OK, "got 0x%08x\n", hr);
9855
9856     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem2"), &elem2);
9857     ok(hr == S_OK, "got 0x%08x\n", hr);
9858
9859     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
9860     ok(hr == S_OK, "got 0x%08x\n", hr);
9861
9862     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
9863     ok(hr == S_OK, "got 0x%08x\n", hr);
9864
9865     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem4"), &elem4);
9866     ok(hr == S_OK, "got 0x%08x\n", hr);
9867
9868     EXPECT_NO_CHILDREN(elem1);
9869     EXPECT_NO_CHILDREN(elem2);
9870     EXPECT_NO_CHILDREN(elem3);
9871
9872     todo_wine EXPECT_REF(elem2, 2);
9873
9874     V_VT(&v) = VT_DISPATCH;
9875     V_DISPATCH(&v) = NULL;
9876     node = NULL;
9877     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem4, v, &node);
9878     ok(hr == S_OK, "got 0x%08x\n", hr);
9879     ok(node == (void*)elem4, "got %p\n", node);
9880
9881     EXPECT_CHILDREN(elem1);
9882     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem4, NULL);
9883     EXPECT_HR(hr, S_OK);
9884     IXMLDOMElement_Release(elem4);
9885
9886     EXPECT_NO_CHILDREN(elem1);
9887
9888     V_VT(&v) = VT_NULL;
9889     node = NULL;
9890     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
9891     ok(hr == S_OK, "got 0x%08x\n", hr);
9892     ok(node == (void*)elem2, "got %p\n", node);
9893
9894     EXPECT_CHILDREN(elem1);
9895     todo_wine EXPECT_REF(elem2, 3);
9896     IXMLDOMNode_Release(node);
9897
9898     /* again for already linked node */
9899     V_VT(&v) = VT_NULL;
9900     node = NULL;
9901     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
9902     ok(hr == S_OK, "got 0x%08x\n", hr);
9903     ok(node == (void*)elem2, "got %p\n", node);
9904
9905     EXPECT_CHILDREN(elem1);
9906
9907     /* increments each time */
9908     todo_wine EXPECT_REF(elem2, 3);
9909     IXMLDOMNode_Release(node);
9910
9911     /* try to add to another element */
9912     V_VT(&v) = VT_NULL;
9913     node = (void*)0xdeadbeef;
9914     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem2, v, &node);
9915     ok(hr == S_OK, "got 0x%08x\n", hr);
9916     ok(node == (void*)elem2, "got %p\n", node);
9917
9918     EXPECT_CHILDREN(elem3);
9919     EXPECT_NO_CHILDREN(elem1);
9920
9921     IXMLDOMNode_Release(node);
9922
9923     /* cross document case - try to add as child to a node created with other doc */
9924     doc2 = create_document(&IID_IXMLDOMDocument);
9925
9926     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem4);
9927     ok(hr == S_OK, "got 0x%08x\n", hr);
9928     todo_wine EXPECT_REF(elem4, 2);
9929
9930     /* same name, another instance */
9931     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem5);
9932     ok(hr == S_OK, "got 0x%08x\n", hr);
9933     todo_wine EXPECT_REF(elem5, 2);
9934
9935     todo_wine EXPECT_REF(elem3, 2);
9936     V_VT(&v) = VT_NULL;
9937     node = NULL;
9938     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem4, v, &node);
9939     ok(hr == S_OK, "got 0x%08x\n", hr);
9940     ok(node == (void*)elem4, "got %p\n", node);
9941     todo_wine EXPECT_REF(elem4, 3);
9942     todo_wine EXPECT_REF(elem3, 2);
9943     IXMLDOMNode_Release(node);
9944
9945     V_VT(&v) = VT_NULL;
9946     node = NULL;
9947     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem5, v, &node);
9948     ok(hr == S_OK, "got 0x%08x\n", hr);
9949     ok(node == (void*)elem5, "got %p\n", node);
9950     todo_wine EXPECT_REF(elem4, 2);
9951     todo_wine EXPECT_REF(elem5, 3);
9952     IXMLDOMNode_Release(node);
9953
9954     IXMLDOMDocument_Release(doc2);
9955
9956     IXMLDOMElement_Release(elem1);
9957     IXMLDOMElement_Release(elem2);
9958     IXMLDOMElement_Release(elem3);
9959     IXMLDOMElement_Release(elem4);
9960     IXMLDOMElement_Release(elem5);
9961
9962     /* elements with same default namespace */
9963     V_VT(&v) = VT_I4;
9964     V_I4(&v) = NODE_ELEMENT;
9965     elem1 = NULL;
9966     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
9967     ok(hr == S_OK, "got 0x%08x\n", hr);
9968     ok(elem1 != NULL, "got %p\n", elem1);
9969
9970     V_VT(&v) = VT_I4;
9971     V_I4(&v) = NODE_ELEMENT;
9972     elem2 = NULL;
9973     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem2);
9974     ok(hr == S_OK, "got 0x%08x\n", hr);
9975     ok(elem2 != NULL, "got %p\n", elem2);
9976
9977     /* check contents so far */
9978     p = NULL;
9979     hr = IXMLDOMElement_get_xml(elem1, &p);
9980     ok(hr == S_OK, "got 0x%08x\n", hr);
9981     ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9982     SysFreeString(p);
9983
9984     p = NULL;
9985     hr = IXMLDOMElement_get_xml(elem2, &p);
9986     ok(hr == S_OK, "got 0x%08x\n", hr);
9987     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9988     SysFreeString(p);
9989
9990     V_VT(&v) = VT_NULL;
9991     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
9992     ok(hr == S_OK, "got 0x%08x\n", hr);
9993
9994     /* get_xml depends on context, for top node it omits child namespace attribute,
9995        but at child level it's still returned */
9996     p = NULL;
9997     hr = IXMLDOMElement_get_xml(elem1, &p);
9998     ok(hr == S_OK, "got 0x%08x\n", hr);
9999     todo_wine ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"><elem2/></elem1>")),
10000         "got %s\n", wine_dbgstr_w(p));
10001     SysFreeString(p);
10002
10003     p = NULL;
10004     hr = IXMLDOMElement_get_xml(elem2, &p);
10005     ok(hr == S_OK, "got 0x%08x\n", hr);
10006     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
10007     SysFreeString(p);
10008
10009     IXMLDOMElement_Release(elem1);
10010     IXMLDOMElement_Release(elem2);
10011
10012     /* child without default namespace added to node with default namespace */
10013     V_VT(&v) = VT_I4;
10014     V_I4(&v) = NODE_ELEMENT;
10015     elem1 = NULL;
10016     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
10017     ok(hr == S_OK, "got 0x%08x\n", hr);
10018     ok(elem1 != NULL, "got %p\n", elem1);
10019
10020     V_VT(&v) = VT_I4;
10021     V_I4(&v) = NODE_ELEMENT;
10022     elem2 = NULL;
10023     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), NULL, (IXMLDOMNode**)&elem2);
10024     ok(hr == S_OK, "got 0x%08x\n", hr);
10025     ok(elem2 != NULL, "got %p\n", elem2);
10026
10027     EXPECT_REF(elem2, 1);
10028     V_VT(&v) = VT_NULL;
10029     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
10030     ok(hr == S_OK, "got 0x%08x\n", hr);
10031     EXPECT_REF(elem2, 1);
10032
10033     p = NULL;
10034     hr = IXMLDOMElement_get_xml(elem2, &p);
10035     ok(hr == S_OK, "got 0x%08x\n", hr);
10036     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
10037     SysFreeString(p);
10038
10039     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem2, NULL);
10040     ok(hr == S_OK, "got 0x%08x\n", hr);
10041
10042     p = NULL;
10043     hr = IXMLDOMElement_get_xml(elem2, &p);
10044     ok(hr == S_OK, "got 0x%08x\n", hr);
10045     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
10046     SysFreeString(p);
10047
10048     IXMLDOMElement_Release(elem1);
10049     IXMLDOMElement_Release(elem2);
10050     IXMLDOMDocument_Release(doc);
10051 }
10052
10053 static void test_appendChild(void)
10054 {
10055     IXMLDOMDocument *doc, *doc2;
10056     IXMLDOMElement *elem, *elem2;
10057     HRESULT hr;
10058
10059     doc = create_document(&IID_IXMLDOMDocument);
10060     doc2 = create_document(&IID_IXMLDOMDocument);
10061
10062     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
10063     ok(hr == S_OK, "got 0x%08x\n", hr);
10064
10065     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem2"), &elem2);
10066     ok(hr == S_OK, "got 0x%08x\n", hr);
10067
10068     EXPECT_REF(doc, 1);
10069     todo_wine EXPECT_REF(elem, 2);
10070     EXPECT_REF(doc2, 1);
10071     todo_wine EXPECT_REF(elem2, 2);
10072     EXPECT_NO_CHILDREN(doc);
10073     EXPECT_NO_CHILDREN(doc2);
10074
10075     /* append from another document */
10076     hr = IXMLDOMDocument_appendChild(doc2, (IXMLDOMNode*)elem, NULL);
10077     ok(hr == S_OK, "got 0x%08x\n", hr);
10078
10079     EXPECT_REF(doc, 1);
10080     todo_wine EXPECT_REF(elem, 2);
10081     EXPECT_REF(doc2, 1);
10082     todo_wine EXPECT_REF(elem2, 2);
10083     EXPECT_NO_CHILDREN(doc);
10084     EXPECT_CHILDREN(doc2);
10085
10086     IXMLDOMElement_Release(elem);
10087     IXMLDOMElement_Release(elem2);
10088     IXMLDOMDocument_Release(doc);
10089     IXMLDOMDocument_Release(doc2);
10090 }
10091
10092 static void test_get_doctype(void)
10093 {
10094     IXMLDOMDocumentType *doctype;
10095     IXMLDOMDocument *doc;
10096     HRESULT hr;
10097
10098     doc = create_document(&IID_IXMLDOMDocument);
10099
10100     hr = IXMLDOMDocument_get_doctype(doc, NULL);
10101     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10102
10103     doctype = (void*)0xdeadbeef;
10104     hr = IXMLDOMDocument_get_doctype(doc, &doctype);
10105     ok(hr == S_FALSE, "got 0x%08x\n", hr);
10106     ok(doctype == NULL, "got %p\n", doctype);
10107
10108     IXMLDOMDocument_Release(doc);
10109 }
10110
10111 static void test_get_tagName(void)
10112 {
10113     IXMLDOMDocument *doc;
10114     IXMLDOMElement *elem, *elem2;
10115     HRESULT hr;
10116     BSTR str;
10117
10118     doc = create_document(&IID_IXMLDOMDocument);
10119
10120     hr = IXMLDOMDocument_createElement(doc, _bstr_("element"), &elem);
10121     ok(hr == S_OK, "got 0x%08x\n", hr);
10122
10123     hr = IXMLDOMElement_get_tagName(elem, NULL);
10124     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10125
10126     str = NULL;
10127     hr = IXMLDOMElement_get_tagName(elem, &str);
10128     ok(hr == S_OK, "got 0x%08x\n", hr);
10129     ok(!lstrcmpW(str, _bstr_("element")), "got %s\n", wine_dbgstr_w(str));
10130     SysFreeString(str);
10131
10132     hr = IXMLDOMDocument_createElement(doc, _bstr_("s:element"), &elem2);
10133     ok(hr == S_OK, "got 0x%08x\n", hr);
10134
10135     str = NULL;
10136     hr = IXMLDOMElement_get_tagName(elem2, &str);
10137     ok(hr == S_OK, "got 0x%08x\n", hr);
10138     ok(!lstrcmpW(str, _bstr_("s:element")), "got %s\n", wine_dbgstr_w(str));
10139     SysFreeString(str);
10140
10141     IXMLDOMDocument_Release(elem);
10142     IXMLDOMDocument_Release(elem2);
10143     IXMLDOMDocument_Release(doc);
10144     free_bstrs();
10145 }
10146
10147 typedef struct {
10148     DOMNodeType type;
10149     const char *name;
10150     VARTYPE vt;
10151     HRESULT hr;
10152 } node_type_t;
10153
10154 static const node_type_t get_datatype[] = {
10155     { NODE_ELEMENT,                "element",   VT_NULL, S_FALSE },
10156     { NODE_ATTRIBUTE,              "attr",      VT_NULL, S_FALSE },
10157     { NODE_TEXT,                   "text",      VT_NULL, S_FALSE },
10158     { NODE_CDATA_SECTION ,         "cdata",     VT_NULL, S_FALSE },
10159     { NODE_ENTITY_REFERENCE,       "entityref", VT_NULL, S_FALSE },
10160     { NODE_PROCESSING_INSTRUCTION, "pi",        VT_NULL, S_FALSE },
10161     { NODE_COMMENT,                "comment",   VT_NULL, S_FALSE },
10162     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   VT_NULL, S_FALSE },
10163     { 0 }
10164 };
10165
10166 static void test_get_dataType(void)
10167 {
10168     const node_type_t *entry = get_datatype;
10169     IXMLDOMDocument *doc;
10170
10171     doc = create_document(&IID_IXMLDOMDocument);
10172
10173     while (entry->type)
10174     {
10175         IXMLDOMNode *node = NULL;
10176         VARIANT var, type;
10177         HRESULT hr;
10178
10179         V_VT(&var) = VT_I4;
10180         V_I4(&var) = entry->type;
10181         hr = IXMLDOMDocument_createNode(doc, var, _bstr_(entry->name), NULL, &node);
10182         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
10183
10184         hr = IXMLDOMNode_get_dataType(node, NULL);
10185         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10186
10187         VariantInit(&type);
10188         hr = IXMLDOMNode_get_dataType(node, &type);
10189         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
10190             hr, entry->hr, entry->type);
10191         ok(V_VT(&type) == entry->vt, "got %d, expected %d. node type %d\n",
10192             V_VT(&type), entry->vt, entry->type);
10193         VariantClear(&type);
10194
10195         IXMLDOMNode_Release(node);
10196
10197         entry++;
10198     }
10199
10200     IXMLDOMDocument_Release(doc);
10201     free_bstrs();
10202 }
10203
10204 typedef struct _get_node_typestring_t {
10205     DOMNodeType type;
10206     const char *string;
10207 } get_node_typestring_t;
10208
10209 static const get_node_typestring_t get_node_typestring[] = {
10210     { NODE_ELEMENT,                "element"               },
10211     { NODE_ATTRIBUTE,              "attribute"             },
10212     { NODE_TEXT,                   "text"                  },
10213     { NODE_CDATA_SECTION ,         "cdatasection"          },
10214     { NODE_ENTITY_REFERENCE,       "entityreference"       },
10215     { NODE_PROCESSING_INSTRUCTION, "processinginstruction" },
10216     { NODE_COMMENT,                "comment"               },
10217     { NODE_DOCUMENT_FRAGMENT,      "documentfragment"      },
10218     { 0 }
10219 };
10220
10221 static void test_get_nodeTypeString(void)
10222 {
10223     const get_node_typestring_t *entry = get_node_typestring;
10224     IXMLDOMDocument *doc;
10225     HRESULT hr;
10226     BSTR str;
10227
10228     doc = create_document(&IID_IXMLDOMDocument);
10229
10230     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
10231     ok(hr == S_OK, "got 0x%08x\n", hr);
10232     ok(!lstrcmpW(str, _bstr_("document")), "got string %s\n", wine_dbgstr_w(str));
10233     SysFreeString(str);
10234
10235     while (entry->type)
10236     {
10237         IXMLDOMNode *node = NULL;
10238         VARIANT var;
10239
10240         V_VT(&var) = VT_I4;
10241         V_I4(&var) = entry->type;
10242         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
10243         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
10244
10245         hr = IXMLDOMNode_get_nodeTypeString(node, NULL);
10246         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10247
10248         hr = IXMLDOMNode_get_nodeTypeString(node, &str);
10249         ok(hr == S_OK, "got 0x%08x\n", hr);
10250         ok(!lstrcmpW(str, _bstr_(entry->string)), "got string %s, expected %s. node type %d\n",
10251             wine_dbgstr_w(str), entry->string, entry->type);
10252         SysFreeString(str);
10253         IXMLDOMNode_Release(node);
10254
10255         entry++;
10256     }
10257
10258     IXMLDOMDocument_Release(doc);
10259     free_bstrs();
10260 }
10261
10262 typedef struct _get_attributes_t {
10263     DOMNodeType type;
10264     HRESULT hr;
10265 } get_attributes_t;
10266
10267 static const get_attributes_t get_attributes[] = {
10268     { NODE_ATTRIBUTE,              S_FALSE },
10269     { NODE_TEXT,                   S_FALSE },
10270     { NODE_CDATA_SECTION ,         S_FALSE },
10271     { NODE_ENTITY_REFERENCE,       S_FALSE },
10272     { NODE_PROCESSING_INSTRUCTION, S_FALSE },
10273     { NODE_COMMENT,                S_FALSE },
10274     { NODE_DOCUMENT_FRAGMENT,      S_FALSE },
10275     { 0 }
10276 };
10277
10278 static void test_get_attributes(void)
10279 {
10280     const get_attributes_t *entry = get_attributes;
10281     IXMLDOMNamedNodeMap *map;
10282     IXMLDOMDocument *doc;
10283     IXMLDOMNode *node, *node2;
10284     VARIANT_BOOL b;
10285     HRESULT hr;
10286     BSTR str;
10287     LONG length;
10288
10289     doc = create_document(&IID_IXMLDOMDocument);
10290
10291     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
10292     ok(hr == S_OK, "got %08x\n", hr);
10293
10294     hr = IXMLDOMDocument_get_attributes(doc, NULL);
10295     ok(hr == E_INVALIDARG, "got %08x\n", hr);
10296
10297     map = (void*)0xdeadbeef;
10298     hr = IXMLDOMDocument_get_attributes(doc, &map);
10299     ok(hr == S_FALSE, "got %08x\n", hr);
10300     ok(map == NULL, "got %p\n", map);
10301
10302     /* first child is <?xml ?> */
10303     hr = IXMLDOMDocument_get_firstChild(doc, &node);
10304     ok(hr == S_OK, "got %08x\n", hr);
10305
10306     hr = IXMLDOMNode_get_attributes(node, &map);
10307     ok(hr == S_OK, "got %08x\n", hr);
10308
10309     length = -1;
10310     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10311     EXPECT_HR(hr, S_OK);
10312     todo_wine ok(length == 1, "got %d\n", length);
10313
10314     if (hr == S_OK && length == 1)
10315     {
10316         IXMLDOMAttribute *attr;
10317         DOMNodeType type;
10318         VARIANT v;
10319
10320         node2 = NULL;
10321         hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
10322         EXPECT_HR(hr, S_OK);
10323         ok(node != NULL, "got %p\n", node2);
10324
10325         hr = IXMLDOMNode_get_nodeName(node2, &str);
10326         EXPECT_HR(hr, S_OK);
10327         ok(!lstrcmpW(str, _bstr_("version")), "got %s\n", wine_dbgstr_w(str));
10328         SysFreeString(str);
10329
10330         length = -1;
10331         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10332         EXPECT_HR(hr, S_OK);
10333         ok(length == 1, "got %d\n", length);
10334
10335         type = -1;
10336         hr = IXMLDOMNode_get_nodeType(node2, &type);
10337         EXPECT_HR(hr, S_OK);
10338         ok(type == NODE_ATTRIBUTE, "got %d\n", type);
10339
10340         hr = IXMLDOMNode_get_xml(node, &str);
10341         EXPECT_HR(hr, S_OK);
10342         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
10343         SysFreeString(str);
10344
10345         hr = IXMLDOMNode_get_text(node, &str);
10346         EXPECT_HR(hr, S_OK);
10347         ok(!lstrcmpW(str, _bstr_("version=\"1.0\"")), "got %s\n", wine_dbgstr_w(str));
10348         SysFreeString(str);
10349
10350         hr = IXMLDOMNamedNodeMap_removeNamedItem(map, _bstr_("version"), NULL);
10351         EXPECT_HR(hr, S_OK);
10352
10353         length = -1;
10354         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10355         EXPECT_HR(hr, S_OK);
10356         ok(length == 0, "got %d\n", length);
10357
10358         hr = IXMLDOMNode_get_xml(node, &str);
10359         EXPECT_HR(hr, S_OK);
10360         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
10361         SysFreeString(str);
10362
10363         hr = IXMLDOMNode_get_text(node, &str);
10364         EXPECT_HR(hr, S_OK);
10365         ok(!lstrcmpW(str, _bstr_("")), "got %s\n", wine_dbgstr_w(str));
10366         SysFreeString(str);
10367
10368         IXMLDOMNamedNodeMap_Release(map);
10369
10370         hr = IXMLDOMNode_get_attributes(node, &map);
10371         ok(hr == S_OK, "got %08x\n", hr);
10372
10373         length = -1;
10374         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10375         EXPECT_HR(hr, S_OK);
10376         ok(length == 0, "got %d\n", length);
10377
10378         hr = IXMLDOMDocument_createAttribute(doc, _bstr_("encoding"), &attr);
10379         EXPECT_HR(hr, S_OK);
10380
10381         V_VT(&v) = VT_BSTR;
10382         V_BSTR(&v) = _bstr_("UTF-8");
10383         hr = IXMLDOMAttribute_put_nodeValue(attr, v);
10384         EXPECT_HR(hr, S_OK);
10385
10386         EXPECT_REF(attr, 2);
10387         hr = IXMLDOMNamedNodeMap_setNamedItem(map, (IXMLDOMNode*)attr, NULL);
10388         EXPECT_HR(hr, S_OK);
10389         EXPECT_REF(attr, 2);
10390
10391         hr = IXMLDOMNode_get_attributes(node, &map);
10392         ok(hr == S_OK, "got %08x\n", hr);
10393
10394         length = -1;
10395         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10396         EXPECT_HR(hr, S_OK);
10397         ok(length == 1, "got %d\n", length);
10398
10399         hr = IXMLDOMNode_get_xml(node, &str);
10400         EXPECT_HR(hr, S_OK);
10401         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
10402         SysFreeString(str);
10403
10404         hr = IXMLDOMNode_get_text(node, &str);
10405         EXPECT_HR(hr, S_OK);
10406         ok(!lstrcmpW(str, _bstr_("encoding=\"UTF-8\"")), "got %s\n", wine_dbgstr_w(str));
10407         SysFreeString(str);
10408
10409         IXMLDOMNamedNodeMap_Release(map);
10410         IXMLDOMNode_Release(node2);
10411     }
10412
10413     IXMLDOMNode_Release(node);
10414
10415     /* last child is element */
10416     EXPECT_REF(doc, 1);
10417     hr = IXMLDOMDocument_get_lastChild(doc, &node);
10418     ok(hr == S_OK, "got %08x\n", hr);
10419     EXPECT_REF(doc, 1);
10420
10421     EXPECT_REF(node, 1);
10422     hr = IXMLDOMNode_get_attributes(node, &map);
10423     ok(hr == S_OK, "got %08x\n", hr);
10424     EXPECT_REF(node, 1);
10425     EXPECT_REF(doc, 1);
10426
10427     EXPECT_REF(map, 1);
10428     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
10429     ok(hr == S_OK, "got %08x\n", hr);
10430     EXPECT_REF(node, 1);
10431     EXPECT_REF(node2, 1);
10432     EXPECT_REF(map, 1);
10433     EXPECT_REF(doc, 1);
10434     IXMLDOMNode_Release(node2);
10435
10436     /* release node before map release, map still works */
10437     IXMLDOMNode_Release(node);
10438
10439     length = 0;
10440     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10441     ok(hr == S_OK, "got %08x\n", hr);
10442     ok(length == 1, "got %d\n", length);
10443
10444     node2 = NULL;
10445     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
10446     ok(hr == S_OK, "got %08x\n", hr);
10447     EXPECT_REF(node2, 1);
10448     IXMLDOMNode_Release(node2);
10449
10450     IXMLDOMNamedNodeMap_Release(map);
10451
10452     while (entry->type)
10453     {
10454         VARIANT var;
10455
10456         node = NULL;
10457
10458         V_VT(&var) = VT_I4;
10459         V_I4(&var) = entry->type;
10460         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
10461         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
10462
10463         hr = IXMLDOMNode_get_attributes(node, NULL);
10464         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10465
10466         map = (void*)0xdeadbeef;
10467         hr = IXMLDOMNode_get_attributes(node, &map);
10468         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
10469             hr, entry->hr, entry->type);
10470         ok(map == NULL, "got %p\n", map);
10471
10472         IXMLDOMNode_Release(node);
10473
10474         entry++;
10475     }
10476
10477     IXMLDOMDocument_Release(doc);
10478     free_bstrs();
10479 }
10480
10481 static void test_selection(void)
10482 {
10483     IXMLDOMSelection *selection, *selection2;
10484     IEnumVARIANT *enum1, *enum2, *enum3;
10485     IXMLDOMNodeList *list;
10486     IUnknown *unk1, *unk2;
10487     IXMLDOMDocument *doc;
10488     IDispatchEx *dispex;
10489     IXMLDOMNode *node;
10490     IDispatch *disp;
10491     VARIANT_BOOL b;
10492     HRESULT hr;
10493     DISPID did;
10494     VARIANT v;
10495     BSTR name;
10496     ULONG ret;
10497     LONG len;
10498
10499     doc = create_document(&IID_IXMLDOMDocument);
10500
10501     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
10502     EXPECT_HR(hr, S_OK);
10503
10504     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list);
10505     EXPECT_HR(hr, S_OK);
10506
10507     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
10508     EXPECT_HR(hr, S_OK);
10509     IXMLDOMSelection_Release(selection);
10510
10511     /* collection disp id */
10512     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IDispatchEx, (void**)&dispex);
10513     EXPECT_HR(hr, S_OK);
10514     did = 0;
10515     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10516     EXPECT_HR(hr, S_OK);
10517     ok(did == DISPID_DOM_COLLECTION_BASE, "got %d\n", did);
10518     len = 0;
10519     hr = IXMLDOMSelection_get_length(selection, &len);
10520     EXPECT_HR(hr, S_OK);
10521     ok(len == 1, "got %d\n", len);
10522     hr = IDispatchEx_GetDispID(dispex, _bstr_("10"), 0, &did);
10523     EXPECT_HR(hr, S_OK);
10524     ok(did == DISPID_DOM_COLLECTION_BASE+10, "got %d\n", did);
10525     IDispatchEx_Release(dispex);
10526
10527     /* IEnumVARIANT tests */
10528     enum1 = NULL;
10529     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum1);
10530     EXPECT_HR(hr, S_OK);
10531     ok(enum1 != NULL, "got %p\n", enum1);
10532     EXPECT_REF(enum1, 2);
10533
10534     EXPECT_REF(selection, 1);
10535     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IUnknown, (void**)&unk1);
10536     EXPECT_HR(hr, S_OK);
10537     EXPECT_REF(selection, 2);
10538     EXPECT_REF(enum1, 2);
10539
10540     /* enumerator and selection object return same IUnknown* */
10541     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
10542     EXPECT_HR(hr, S_OK);
10543     EXPECT_REF(selection, 3);
10544     EXPECT_REF(enum1, 2);
10545     ok(unk2 == unk1, "got %p, %p\n", unk1, unk2);
10546     IUnknown_Release(unk2);
10547
10548     EXPECT_REF(selection, 2);
10549     IEnumVARIANT_AddRef(enum1);
10550     EXPECT_REF(selection, 2);
10551     IEnumVARIANT_Release(enum1);
10552
10553     enum3 = NULL;
10554     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum3);
10555     EXPECT_HR(hr, S_OK);
10556     ok(enum3 != NULL, "got %p\n", enum3);
10557     ok(enum1 == enum3, "got %p and %p\n", enum1, enum3);
10558     EXPECT_REF(enum1, 3);
10559     IEnumVARIANT_Release(enum3);
10560
10561     EXPECT_REF(selection, 2);
10562     EXPECT_REF(enum1, 2);
10563
10564     enum2 = NULL;
10565     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
10566     EXPECT_HR(hr, S_OK);
10567     ok(enum2 != NULL, "got %p\n", enum2);
10568
10569     EXPECT_REF(selection, 3);
10570     EXPECT_REF(enum1, 2);
10571     EXPECT_REF(enum2, 1);
10572
10573     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
10574
10575     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
10576     EXPECT_HR(hr, S_OK);
10577     EXPECT_REF(selection, 3);
10578     EXPECT_REF(enum2, 2);
10579     ok(unk2 != unk1, "got %p, %p\n", unk1, unk2);
10580     IUnknown_Release(unk2);
10581     IUnknown_Release(unk1);
10582
10583     selection2 = NULL;
10584     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IXMLDOMSelection, (void**)&selection2);
10585     EXPECT_HR(hr, S_OK);
10586     ok(selection2 == selection, "got %p and %p\n", selection, selection2);
10587     EXPECT_REF(selection, 3);
10588     EXPECT_REF(enum1, 2);
10589
10590     IXMLDOMSelection_Release(selection2);
10591
10592     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IDispatch, (void**)&disp);
10593     EXPECT_HR(hr, S_OK);
10594     EXPECT_REF(selection, 3);
10595     IDispatch_Release(disp);
10596
10597     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IEnumVARIANT, (void**)&enum3);
10598     EXPECT_HR(hr, S_OK);
10599     ok(enum3 == enum1, "got %p and %p\n", enum3, enum1);
10600     EXPECT_REF(selection, 2);
10601     EXPECT_REF(enum1, 3);
10602
10603     IEnumVARIANT_Release(enum1);
10604     IEnumVARIANT_Release(enum2);
10605
10606     enum1 = NULL;
10607     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
10608     EXPECT_HR(hr, S_OK);
10609     ok(enum1 != NULL, "got %p\n", enum1);
10610     EXPECT_REF(enum1, 1);
10611     EXPECT_REF(selection, 2);
10612
10613     enum2 = NULL;
10614     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
10615     EXPECT_HR(hr, S_OK);
10616     ok(enum2 != NULL, "got %p\n", enum2);
10617     EXPECT_REF(enum2, 1);
10618     EXPECT_REF(selection, 3);
10619
10620     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
10621
10622     IEnumVARIANT_AddRef(enum1);
10623     EXPECT_REF(selection, 3);
10624     EXPECT_REF(enum1, 2);
10625     EXPECT_REF(enum2, 1);
10626     IEnumVARIANT_Release(enum1);
10627
10628     IEnumVARIANT_Release(enum1);
10629     IEnumVARIANT_Release(enum2);
10630
10631     EXPECT_REF(selection, 1);
10632
10633     IXMLDOMNodeList_Release(list);
10634
10635     hr = IXMLDOMDocument_get_childNodes(doc, &list);
10636     EXPECT_HR(hr, S_OK);
10637
10638     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
10639     EXPECT_HR(hr, E_NOINTERFACE);
10640
10641     IXMLDOMNodeList_Release(list);
10642
10643     /* test if IEnumVARIANT touches selection context */
10644     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(xpath_simple_list), &b);
10645     EXPECT_HR(hr, S_OK);
10646
10647     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/*"), &list);
10648     EXPECT_HR(hr, S_OK);
10649
10650     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
10651     EXPECT_HR(hr, S_OK);
10652
10653     len = 0;
10654     hr = IXMLDOMSelection_get_length(selection, &len);
10655     EXPECT_HR(hr, S_OK);
10656     ok(len == 4, "got %d\n", len);
10657
10658     enum1 = NULL;
10659     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
10660     EXPECT_HR(hr, S_OK);
10661
10662     /* no-op if zero count */
10663     V_VT(&v) = VT_I2;
10664     hr = IEnumVARIANT_Next(enum1, 0, &v, NULL);
10665     EXPECT_HR(hr, S_OK);
10666     ok(V_VT(&v) == VT_I2, "got var type %d\n", V_VT(&v));
10667
10668     /* positive count, null array pointer */
10669     hr = IEnumVARIANT_Next(enum1, 1, NULL, NULL);
10670     EXPECT_HR(hr, E_INVALIDARG);
10671
10672     ret = 1;
10673     hr = IEnumVARIANT_Next(enum1, 1, NULL, &ret);
10674     EXPECT_HR(hr, E_INVALIDARG);
10675     ok(ret == 0, "got %d\n", ret);
10676
10677     V_VT(&v) = VT_I2;
10678     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
10679     EXPECT_HR(hr, S_OK);
10680     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
10681
10682     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
10683     EXPECT_HR(hr, S_OK);
10684     hr = IXMLDOMNode_get_nodeName(node, &name);
10685     EXPECT_HR(hr, S_OK);
10686     ok(!lstrcmpW(name, _bstr_("a")), "got node name %s\n", wine_dbgstr_w(name));
10687     SysFreeString(name);
10688     IXMLDOMNode_Release(node);
10689     VariantClear(&v);
10690
10691     /* list cursor is updated */
10692     hr = IXMLDOMSelection_nextNode(selection, &node);
10693     EXPECT_HR(hr, S_OK);
10694     hr = IXMLDOMNode_get_nodeName(node, &name);
10695     EXPECT_HR(hr, S_OK);
10696     ok(!lstrcmpW(name, _bstr_("c")), "got node name %s\n", wine_dbgstr_w(name));
10697     IXMLDOMNode_Release(node);
10698
10699     V_VT(&v) = VT_I2;
10700     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
10701     EXPECT_HR(hr, S_OK);
10702     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
10703     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
10704     EXPECT_HR(hr, S_OK);
10705     hr = IXMLDOMNode_get_nodeName(node, &name);
10706     EXPECT_HR(hr, S_OK);
10707     ok(!lstrcmpW(name, _bstr_("b")), "got node name %s\n", wine_dbgstr_w(name));
10708     SysFreeString(name);
10709     IXMLDOMNode_Release(node);
10710     VariantClear(&v);
10711     IEnumVARIANT_Release(enum1);
10712
10713     hr = IXMLDOMSelection_nextNode(selection, &node);
10714     EXPECT_HR(hr, S_OK);
10715     hr = IXMLDOMNode_get_nodeName(node, &name);
10716     EXPECT_HR(hr, S_OK);
10717     ok(!lstrcmpW(name, _bstr_("d")), "got node name %s\n", wine_dbgstr_w(name));
10718     IXMLDOMNode_Release(node);
10719
10720     IXMLDOMSelection_Release(selection);
10721     IXMLDOMNodeList_Release(list);
10722     IXMLDOMDocument_Release(doc);
10723
10724     free_bstrs();
10725 }
10726
10727 static void test_load(void)
10728 {
10729     IXMLDOMDocument *doc;
10730     IXMLDOMNodeList *list;
10731     VARIANT_BOOL b;
10732     HANDLE hfile;
10733     VARIANT src;
10734     HRESULT hr;
10735     BOOL ret;
10736     BSTR path, bstr1, bstr2;
10737     DWORD written;
10738     void* ptr;
10739
10740     /* prepare a file */
10741     hfile = CreateFileA("test.xml", GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
10742     ok(hfile != INVALID_HANDLE_VALUE, "failed to create test file\n");
10743     if(hfile == INVALID_HANDLE_VALUE) return;
10744
10745     ret = WriteFile(hfile, win1252xml, strlen(win1252xml), &written, NULL);
10746     ok(ret, "WriteFile failed\n");
10747
10748     CloseHandle(hfile);
10749
10750     doc = create_document(&IID_IXMLDOMDocument);
10751
10752     /* null pointer as input */
10753     V_VT(&src) = VT_UNKNOWN;
10754     V_UNKNOWN(&src) = NULL;
10755     hr = IXMLDOMDocument_load(doc, src, &b);
10756     EXPECT_HR(hr, E_INVALIDARG);
10757     ok(b == VARIANT_FALSE, "got %d\n", b);
10758
10759     path = _bstr_("test.xml");
10760
10761     /* load from path: VT_BSTR */
10762     V_VT(&src) = VT_BSTR;
10763     V_BSTR(&src) = path;
10764     hr = IXMLDOMDocument_load(doc, src, &b);
10765     EXPECT_HR(hr, S_OK);
10766     ok(b == VARIANT_TRUE, "got %d\n", b);
10767
10768     /* load from a path: VT_BSTR|VT_BYREF */
10769     V_VT(&src) = VT_BSTR | VT_BYREF;
10770     V_BSTRREF(&src) = &path;
10771     hr = IXMLDOMDocument_load(doc, src, &b);
10772     EXPECT_HR(hr, S_OK);
10773     ok(b == VARIANT_TRUE, "got %d\n", b);
10774
10775     /* load from a path: VT_BSTR|VT_BYREF, null ptr */
10776     V_VT(&src) = VT_BSTR | VT_BYREF;
10777     V_BSTRREF(&src) = NULL;
10778     hr = IXMLDOMDocument_load(doc, src, &b);
10779     EXPECT_HR(hr, E_INVALIDARG);
10780     ok(b == VARIANT_FALSE, "got %d\n", b);
10781
10782     IXMLDOMDocument_Release(doc);
10783
10784     DeleteFileA("test.xml");
10785
10786     doc = create_document(&IID_IXMLDOMDocument);
10787
10788     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
10789     EXPECT_HR(hr, S_OK);
10790     ok(b == VARIANT_TRUE, "got %d\n", b);
10791
10792     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
10793     EXPECT_HR(hr, S_OK);
10794     bstr1 = _bstr_(list_to_string(list));
10795
10796     hr = IXMLDOMNodeList_reset(list);
10797     EXPECT_HR(hr, S_OK);
10798
10799     IXMLDOMDocument_Release(doc);
10800
10801     doc = create_document(&IID_IXMLDOMDocument);
10802
10803     VariantInit(&src);
10804     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenA(szExampleXML));
10805     V_VT(&src) = VT_ARRAY|VT_UI1;
10806     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10807     ptr = NULL;
10808     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10809     EXPECT_HR(hr, S_OK);
10810     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10811
10812     memcpy(ptr, szExampleXML, lstrlenA(szExampleXML));
10813     hr = SafeArrayUnlock(V_ARRAY(&src));
10814     EXPECT_HR(hr, S_OK);
10815
10816     hr = IXMLDOMDocument_load(doc, src, &b);
10817     EXPECT_HR(hr, S_OK);
10818     ok(b == VARIANT_TRUE, "got %d\n", b);
10819
10820     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
10821     EXPECT_HR(hr, S_OK);
10822     bstr2 = _bstr_(list_to_string(list));
10823
10824     hr = IXMLDOMNodeList_reset(list);
10825     EXPECT_HR(hr, S_OK);
10826
10827     ok(lstrcmpW(bstr1, bstr2) == 0, "strings not equal: %s : %s\n",
10828        wine_dbgstr_w(bstr1), wine_dbgstr_w(bstr2));
10829
10830     IXMLDOMDocument_Release(doc);
10831     IXMLDOMNodeList_Release(list);
10832     VariantClear(&src);
10833
10834     /* UTF-16 isn't accepted */
10835     doc = create_document(&IID_IXMLDOMDocument);
10836
10837     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenW(szComplete1) * sizeof(WCHAR));
10838     V_VT(&src) = VT_ARRAY|VT_UI1;
10839     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10840     ptr = NULL;
10841     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10842     EXPECT_HR(hr, S_OK);
10843     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10844
10845     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
10846     hr = SafeArrayUnlock(V_ARRAY(&src));
10847     EXPECT_HR(hr, S_OK);
10848
10849     hr = IXMLDOMDocument_load(doc, src, &b);
10850     todo_wine EXPECT_HR(hr, S_FALSE);
10851     todo_wine ok(b == VARIANT_FALSE, "got %d\n", b);
10852
10853     VariantClear(&src);
10854
10855     /* it doesn't like it as a VT_ARRAY|VT_UI2 either */
10856     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI2, 0, lstrlenW(szComplete1));
10857     V_VT(&src) = VT_ARRAY|VT_UI2;
10858     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10859     ptr = NULL;
10860     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10861     EXPECT_HR(hr, S_OK);
10862     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10863
10864     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
10865     hr = SafeArrayUnlock(V_ARRAY(&src));
10866     EXPECT_HR(hr, S_OK);
10867
10868     hr = IXMLDOMDocument_load(doc, src, &b);
10869     todo_wine EXPECT_HR(hr, E_INVALIDARG);
10870     ok(b == VARIANT_FALSE, "got %d\n", b);
10871
10872     VariantClear(&src);
10873     IXMLDOMDocument_Release(doc);
10874
10875     free_bstrs();
10876 }
10877
10878 static void test_domobj_dispex(IUnknown *obj)
10879 {
10880     DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
10881     IDispatchEx *dispex;
10882     IUnknown *unk;
10883     DWORD props;
10884     UINT ticnt;
10885     HRESULT hr;
10886     BSTR name;
10887
10888     hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
10889     EXPECT_HR(hr, S_OK);
10890     if (FAILED(hr)) return;
10891
10892     ticnt = 0;
10893     hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
10894     EXPECT_HR(hr, S_OK);
10895     ok(ticnt == 1, "ticnt=%u\n", ticnt);
10896
10897     name = SysAllocString(szstar);
10898     hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
10899     EXPECT_HR(hr, E_NOTIMPL);
10900     SysFreeString(name);
10901
10902     hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
10903     EXPECT_HR(hr, E_NOTIMPL);
10904
10905     props = 0;
10906     hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
10907     EXPECT_HR(hr, E_NOTIMPL);
10908     ok(props == 0, "expected 0 got %d\n", props);
10909
10910     hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
10911     EXPECT_HR(hr, E_NOTIMPL);
10912     if (SUCCEEDED(hr)) SysFreeString(name);
10913
10914     hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
10915     EXPECT_HR(hr, E_NOTIMPL);
10916
10917     hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
10918     EXPECT_HR(hr, E_NOTIMPL);
10919     if (hr == S_OK && unk) IUnknown_Release(unk);
10920
10921     IDispatchEx_Release(dispex);
10922 }
10923
10924 static void test_mxnamespacemanager(void)
10925 {
10926     static const char xmluriA[] = "http://www.w3.org/XML/1998/namespace";
10927     IMXNamespacePrefixes *prefixes;
10928     IVBMXNamespaceManager *mgr2;
10929     IMXNamespaceManager *nsmgr;
10930     IUnknown *unk1, *unk2;
10931     WCHAR buffW[250];
10932     IDispatch *disp;
10933     IUnknown *unk;
10934     HRESULT hr;
10935     INT len;
10936
10937     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10938         &IID_IMXNamespaceManager, (void**)&nsmgr);
10939     EXPECT_HR(hr, S_OK);
10940
10941     /* IMXNamespaceManager inherits from IUnknown */
10942     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IDispatch, (void**)&disp);
10943     EXPECT_HR(hr, S_OK);
10944     IDispatch_Release(disp);
10945
10946     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IVBMXNamespaceManager, (void**)&mgr2);
10947     EXPECT_HR(hr, S_OK);
10948
10949     EXPECT_REF(nsmgr, 2);
10950     EXPECT_REF(mgr2, 2);
10951     prefixes = NULL;
10952     hr = IVBMXNamespaceManager_getDeclaredPrefixes(mgr2, &prefixes);
10953     if (hr == S_OK)
10954     {
10955         ok(prefixes != NULL, "got %p\n", prefixes);
10956         EXPECT_REF(nsmgr, 2);
10957         EXPECT_REF(mgr2, 2);
10958         EXPECT_REF(prefixes, 1);
10959
10960         IVBMXNamespaceManager_QueryInterface(mgr2, &IID_IUnknown, (void**)&unk1);
10961         IMXNamespacePrefixes_QueryInterface(prefixes, &IID_IUnknown, (void**)&unk2);
10962
10963         EXPECT_REF(mgr2, 3);
10964         EXPECT_REF(prefixes, 2);
10965
10966         IUnknown_Release(unk1);
10967         IUnknown_Release(unk2);
10968         IMXNamespacePrefixes_Release(prefixes);
10969     }
10970     IVBMXNamespaceManager_Release(mgr2);
10971
10972     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
10973     EXPECT_HR(hr, S_OK);
10974
10975     /* prefix already added */
10976     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10977     EXPECT_HR(hr, S_FALSE);
10978
10979     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), NULL);
10980     EXPECT_HR(hr, E_INVALIDARG);
10981
10982     /* "xml" and "xmlns" are not allowed here */
10983     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xml"), _bstr_("uri1"));
10984     EXPECT_HR(hr, E_INVALIDARG);
10985
10986     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xmlns"), _bstr_("uri1"));
10987     EXPECT_HR(hr, E_INVALIDARG);
10988 todo_wine {
10989     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, -1, NULL, NULL);
10990     EXPECT_HR(hr, E_FAIL);
10991 }
10992     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, NULL);
10993     EXPECT_HR(hr, E_POINTER);
10994
10995     len = -1;
10996     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, &len);
10997     EXPECT_HR(hr, S_OK);
10998     ok(len == 3, "got %d\n", len);
10999
11000     len = -1;
11001     buffW[0] = 0x1;
11002     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
11003     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
11004     ok(len == -1, "got %d\n", len);
11005     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11006
11007     len = 10;
11008     buffW[0] = 0x1;
11009     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
11010     EXPECT_HR(hr, S_OK);
11011     ok(len == 3, "got %d\n", len);
11012     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
11013
11014     /* getURI */
11015     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, NULL);
11016     EXPECT_HR(hr, E_INVALIDARG);
11017
11018     len = -1;
11019     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, &len);
11020     EXPECT_HR(hr, E_INVALIDARG);
11021     ok(len == -1, "got %d\n", len);
11022
11023     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, NULL);
11024     EXPECT_HR(hr, E_POINTER);
11025
11026     len = -1;
11027     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, &len);
11028     EXPECT_HR(hr, S_OK);
11029     /* length of "xml" uri is constant */
11030     ok(len == strlen(xmluriA), "got %d\n", len);
11031
11032     len = 100;
11033     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
11034     EXPECT_HR(hr, S_OK);
11035     ok(len == strlen(xmluriA), "got %d\n", len);
11036     ok(!lstrcmpW(buffW, _bstr_(xmluriA)), "got prefix %s\n", wine_dbgstr_w(buffW));
11037
11038     len = strlen(xmluriA)-1;
11039     buffW[0] = 0x1;
11040     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
11041     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
11042     ok(len == strlen(xmluriA)-1, "got %d\n", len);
11043     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11044
11045     /* prefix xml1 not defined */
11046     len = -1;
11047     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, NULL, &len);
11048     EXPECT_HR(hr, S_FALSE);
11049     ok(len == 0, "got %d\n", len);
11050
11051     len = 100;
11052     buffW[0] = 0x1;
11053     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, buffW, &len);
11054     EXPECT_HR(hr, S_FALSE);
11055     ok(buffW[0] == 0, "got %x\n", buffW[0]);
11056     ok(len == 0, "got %d\n", len);
11057
11058     /* IDispatchEx tests */
11059     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IUnknown, (void**)&unk);
11060     EXPECT_HR(hr, S_OK);
11061     test_domobj_dispex(unk);
11062     IUnknown_Release(unk);
11063
11064     IMXNamespaceManager_Release(nsmgr);
11065
11066     /* ::getPrefix() */
11067     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
11068         &IID_IMXNamespaceManager, (void**)&nsmgr);
11069     EXPECT_HR(hr, S_OK);
11070
11071     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, NULL);
11072     EXPECT_HR(hr, E_INVALIDARG);
11073
11074     len = -1;
11075     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, &len);
11076     EXPECT_HR(hr, E_INVALIDARG);
11077     ok(len == -1, "got %d\n", len);
11078
11079     len = 100;
11080     buffW[0] = 0x1;
11081     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
11082     EXPECT_HR(hr, E_FAIL);
11083     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11084     ok(len == 100, "got %d\n", len);
11085
11086     len = 0;
11087     buffW[0] = 0x1;
11088     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
11089     EXPECT_HR(hr, E_FAIL);
11090     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11091     ok(len == 0, "got %d\n", len);
11092
11093     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
11094     EXPECT_HR(hr, S_OK);
11095
11096     len = 100;
11097     buffW[0] = 0x1;
11098     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11099     EXPECT_HR(hr, S_OK);
11100     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11101     ok(len == 3, "got %d\n", len);
11102
11103     len = 100;
11104     buffW[0] = 0x1;
11105     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, buffW, &len);
11106     EXPECT_HR(hr, S_OK);
11107     ok(!lstrcmpW(buffW, _bstr_("xml")), "got %s\n", wine_dbgstr_w(buffW));
11108     ok(len == 3, "got %d\n", len);
11109
11110     /* with null buffer it's possible to get required length */
11111     len = 100;
11112     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
11113     EXPECT_HR(hr, S_OK);
11114     ok(len == 3, "got %d\n", len);
11115
11116     len = 0;
11117     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
11118     EXPECT_HR(hr, S_OK);
11119     ok(len == 3, "got %d\n", len);
11120
11121     len = 100;
11122     buffW[0] = 0x1;
11123     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 1, buffW, &len);
11124     EXPECT_HR(hr, E_FAIL);
11125     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11126     ok(len == 100, "got %d\n", len);
11127
11128     len = 100;
11129     buffW[0] = 0x1;
11130     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 2, buffW, &len);
11131     EXPECT_HR(hr, E_FAIL);
11132     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11133     ok(len == 100, "got %d\n", len);
11134
11135     len = 100;
11136     buffW[0] = 0x1;
11137     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 0, buffW, &len);
11138     EXPECT_HR(hr, E_INVALIDARG);
11139     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11140     ok(len == 100, "got %d\n", len);
11141
11142     len = 100;
11143     buffW[0] = 0x1;
11144     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
11145     EXPECT_HR(hr, E_INVALIDARG);
11146     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11147     ok(len == 100, "got %d\n", len);
11148
11149     len = 100;
11150     buffW[0] = 0x1;
11151     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, buffW, &len);
11152     EXPECT_HR(hr, E_INVALIDARG);
11153     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11154     ok(len == 100, "got %d\n", len);
11155
11156     len = 100;
11157     buffW[0] = 0x1;
11158     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 1, buffW, &len);
11159     EXPECT_HR(hr, E_FAIL);
11160     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11161     ok(len == 100, "got %d\n", len);
11162
11163     len = 100;
11164     buffW[0] = 0x1;
11165     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
11166     EXPECT_HR(hr, E_INVALIDARG);
11167     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11168     ok(len == 100, "got %d\n", len);
11169
11170     /* declare another one, indices are shifted */
11171     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
11172     EXPECT_HR(hr, S_OK);
11173
11174     len = 100;
11175     buffW[0] = 0x1;
11176     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11177     EXPECT_HR(hr, S_OK);
11178     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11179     ok(len == 3, "got %d\n", len);
11180
11181     len = 100;
11182     buffW[0] = 0x1;
11183     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
11184     EXPECT_HR(hr, S_OK);
11185     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
11186     ok(len == 3, "got %d\n", len);
11187
11188     len = 100;
11189     buffW[0] = 0x1;
11190     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 1, buffW, &len);
11191     EXPECT_HR(hr, E_FAIL);
11192     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11193     ok(len == 100, "got %d\n", len);
11194
11195     len = 100;
11196     buffW[0] = 0x1;
11197     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
11198     EXPECT_HR(hr, E_INVALIDARG);
11199     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11200     ok(len == 100, "got %d\n", len);
11201
11202     IMXNamespaceManager_Release(nsmgr);
11203
11204     /* push/pop tests */
11205     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
11206         &IID_IMXNamespaceManager, (void**)&nsmgr);
11207     EXPECT_HR(hr, S_OK);
11208
11209     /* pop with empty stack */
11210     hr = IMXNamespaceManager_popContext(nsmgr);
11211     EXPECT_HR(hr, E_FAIL);
11212
11213     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
11214     EXPECT_HR(hr, S_OK);
11215
11216     len = 100;
11217     buffW[0] = 0x1;
11218     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11219     EXPECT_HR(hr, S_OK);
11220     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11221     ok(len == 3, "got %d\n", len);
11222
11223     hr = IMXNamespaceManager_pushContext(nsmgr);
11224     EXPECT_HR(hr, S_OK);
11225
11226     len = 100;
11227     buffW[0] = 0x1;
11228     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11229     EXPECT_HR(hr, S_OK);
11230     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11231     ok(len == 3, "got %d\n", len);
11232
11233     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
11234     EXPECT_HR(hr, S_OK);
11235
11236     len = 100;
11237     buffW[0] = 0x1;
11238     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
11239     EXPECT_HR(hr, S_OK);
11240     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
11241     ok(len == 3, "got %d\n", len);
11242
11243     hr = IMXNamespaceManager_pushContext(nsmgr);
11244     EXPECT_HR(hr, S_OK);
11245     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns3"), _bstr_("ns3 uri"));
11246     EXPECT_HR(hr, S_OK);
11247
11248     len = 100;
11249     buffW[0] = 0x1;
11250     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
11251     EXPECT_HR(hr, S_OK);
11252     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
11253     ok(len == 3, "got %d\n", len);
11254
11255     len = 100;
11256     buffW[0] = 0x1;
11257     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11258     EXPECT_HR(hr, S_OK);
11259     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11260     ok(len == 3, "got %d\n", len);
11261
11262     hr = IMXNamespaceManager_popContext(nsmgr);
11263     EXPECT_HR(hr, S_OK);
11264
11265     hr = IMXNamespaceManager_popContext(nsmgr);
11266     EXPECT_HR(hr, S_OK);
11267
11268     len = 100;
11269     buffW[0] = 0x1;
11270     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
11271     EXPECT_HR(hr, E_FAIL);
11272     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11273     ok(len == 100, "got %d\n", len);
11274
11275     len = 100;
11276     buffW[0] = 0x1;
11277     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11278     EXPECT_HR(hr, S_OK);
11279     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11280     ok(len == 3, "got %d\n", len);
11281
11282     IMXNamespaceManager_Release(nsmgr);
11283
11284     free_bstrs();
11285 }
11286
11287 static void test_mxnamespacemanager_override(void)
11288 {
11289     IMXNamespaceManager *nsmgr;
11290     WCHAR buffW[250];
11291     VARIANT_BOOL b;
11292     HRESULT hr;
11293     INT len;
11294
11295     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
11296         &IID_IMXNamespaceManager, (void**)&nsmgr);
11297     EXPECT_HR(hr, S_OK);
11298
11299     len = sizeof(buffW)/sizeof(WCHAR);
11300     buffW[0] = 0;
11301     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
11302     EXPECT_HR(hr, S_OK);
11303     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
11304
11305     len = sizeof(buffW)/sizeof(WCHAR);
11306     buffW[0] = 0;
11307     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
11308     EXPECT_HR(hr, E_FAIL);
11309
11310     hr = IMXNamespaceManager_getAllowOverride(nsmgr, NULL);
11311     EXPECT_HR(hr, E_POINTER);
11312
11313     b = VARIANT_FALSE;
11314     hr = IMXNamespaceManager_getAllowOverride(nsmgr, &b);
11315     EXPECT_HR(hr, S_OK);
11316     ok(b == VARIANT_TRUE, "got %d\n", b);
11317
11318     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_FALSE);
11319     EXPECT_HR(hr, S_OK);
11320
11321     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
11322     EXPECT_HR(hr, S_OK);
11323
11324     len = sizeof(buffW)/sizeof(WCHAR);
11325     buffW[0] = 0;
11326     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
11327     EXPECT_HR(hr, S_OK);
11328     ok(!lstrcmpW(buffW, _bstr_("ns0 uri")), "got uri %s\n", wine_dbgstr_w(buffW));
11329
11330     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), _bstr_("ns0 uri"));
11331     EXPECT_HR(hr, S_OK);
11332
11333     len = sizeof(buffW)/sizeof(WCHAR);
11334     buffW[0] = 0;
11335     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
11336     EXPECT_HR(hr, S_OK);
11337     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
11338
11339     len = sizeof(buffW)/sizeof(WCHAR);
11340     buffW[0] = 0;
11341     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
11342     EXPECT_HR(hr, S_OK);
11343     ok(!lstrcmpW(buffW, _bstr_("ns0")), "got prefix %s\n", wine_dbgstr_w(buffW));
11344
11345     len = sizeof(buffW)/sizeof(WCHAR);
11346     buffW[0] = 0;
11347     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 2, buffW, &len);
11348     EXPECT_HR(hr, S_OK);
11349     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
11350
11351     /* new prefix placed at index 1 always */
11352     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
11353     EXPECT_HR(hr, S_OK);
11354
11355     len = sizeof(buffW)/sizeof(WCHAR);
11356     buffW[0] = 0;
11357     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
11358     EXPECT_HR(hr, S_OK);
11359     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got prefix %s\n", wine_dbgstr_w(buffW));
11360
11361     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_(""), NULL);
11362     todo_wine EXPECT_HR(hr, E_FAIL);
11363
11364     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
11365     EXPECT_HR(hr, E_FAIL);
11366
11367     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
11368     EXPECT_HR(hr, E_FAIL);
11369
11370     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_TRUE);
11371     EXPECT_HR(hr, S_OK);
11372
11373     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri override"));
11374     EXPECT_HR(hr, S_FALSE);
11375
11376     len = sizeof(buffW)/sizeof(WCHAR);
11377     buffW[0] = 0;
11378     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
11379     EXPECT_HR(hr, S_OK);
11380     ok(!lstrcmpW(buffW, _bstr_("ns0 uri override")), "got uri %s\n", wine_dbgstr_w(buffW));
11381
11382     len = sizeof(buffW)/sizeof(WCHAR);
11383     buffW[0] = 0;
11384     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 3, buffW, &len);
11385     EXPECT_HR(hr, S_OK);
11386     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
11387
11388     IMXNamespaceManager_Release(nsmgr);
11389
11390     free_bstrs();
11391 }
11392
11393 static const DOMNodeType nodetypes_test[] =
11394 {
11395     NODE_ELEMENT,
11396     NODE_ATTRIBUTE,
11397     NODE_TEXT,
11398     NODE_CDATA_SECTION,
11399     NODE_ENTITY_REFERENCE,
11400     NODE_PROCESSING_INSTRUCTION,
11401     NODE_COMMENT,
11402     NODE_DOCUMENT_FRAGMENT,
11403     NODE_INVALID
11404 };
11405
11406 static void test_dispex(void)
11407 {
11408     const DOMNodeType *type = nodetypes_test;
11409     IXMLDOMImplementation *impl;
11410     IXMLDOMNodeList *node_list;
11411     IXMLDOMParseError *error;
11412     IXMLDOMNamedNodeMap *map;
11413     IXSLProcessor *processor;
11414     IXSLTemplate *template;
11415     IXMLDOMDocument *doc;
11416     IXMLHTTPRequest *req;
11417     IXMLDOMElement *elem;
11418     IDispatchEx *dispex;
11419     IXMLDOMNode *node;
11420     VARIANT_BOOL b;
11421     IUnknown *unk;
11422     HRESULT hr;
11423     DISPID did;
11424
11425     doc = create_document(&IID_IXMLDOMDocument);
11426
11427     IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
11428     test_domobj_dispex(unk);
11429     IUnknown_Release(unk);
11430
11431     for(; *type != NODE_INVALID; type++)
11432     {
11433         IXMLDOMNode *node;
11434         VARIANT v;
11435
11436         V_VT(&v) = VT_I2;
11437         V_I2(&v) = *type;
11438
11439         hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
11440         ok(hr == S_OK, "failed to create node type %d\n", *type);
11441
11442         IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
11443
11444         test_domobj_dispex(unk);
11445         IUnknown_Release(unk);
11446         IXMLDOMNode_Release(node);
11447     }
11448
11449     /* IXMLDOMNodeList */
11450     hr = IXMLDOMDocument_getElementsByTagName(doc, _bstr_("*"), &node_list);
11451     EXPECT_HR(hr, S_OK);
11452     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
11453     test_domobj_dispex(unk);
11454     IUnknown_Release(unk);
11455     IXMLDOMNodeList_Release(node_list);
11456
11457     /* IXMLDOMNodeList for children list */
11458     hr = IXMLDOMDocument_get_childNodes(doc, &node_list);
11459     EXPECT_HR(hr, S_OK);
11460     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
11461     test_domobj_dispex(unk);
11462     IUnknown_Release(unk);
11463
11464     /* collection dispex test, empty collection */
11465     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatchEx, (void**)&dispex);
11466     EXPECT_HR(hr, S_OK);
11467     did = 0;
11468     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
11469     EXPECT_HR(hr, S_OK);
11470     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
11471     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
11472     EXPECT_HR(hr, S_OK);
11473     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
11474     IDispatchEx_Release(dispex);
11475
11476     IXMLDOMNodeList_Release(node_list);
11477
11478     /* IXMLDOMParseError */
11479     hr = IXMLDOMDocument_get_parseError(doc, &error);
11480     EXPECT_HR(hr, S_OK);
11481     IXMLDOMParseError_QueryInterface(error, &IID_IUnknown, (void**)&unk);
11482     test_domobj_dispex(unk);
11483     IUnknown_Release(unk);
11484     IXMLDOMParseError_Release(error);
11485
11486     /* IXMLDOMNamedNodeMap */
11487     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(xpath_simple_list), &b);
11488     EXPECT_HR(hr, S_OK);
11489
11490     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/a"), &node_list);
11491     EXPECT_HR(hr, S_OK);
11492     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
11493     EXPECT_HR(hr, S_OK);
11494     IXMLDOMNodeList_Release(node_list);
11495
11496     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
11497     EXPECT_HR(hr, S_OK);
11498     IXMLDOMNode_Release(node);
11499     hr = IXMLDOMElement_get_attributes(elem, &map);
11500     EXPECT_HR(hr, S_OK);
11501     IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk);
11502     test_domobj_dispex(unk);
11503     IUnknown_Release(unk);
11504     /* collection dispex test */
11505     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
11506     EXPECT_HR(hr, S_OK);
11507     did = 0;
11508     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
11509     EXPECT_HR(hr, S_OK);
11510     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
11511     IDispatchEx_Release(dispex);
11512
11513     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/b"), &node_list);
11514     EXPECT_HR(hr, S_OK);
11515     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
11516     EXPECT_HR(hr, S_OK);
11517     IXMLDOMNodeList_Release(node_list);
11518     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
11519     EXPECT_HR(hr, S_OK);
11520     IXMLDOMNode_Release(node);
11521     hr = IXMLDOMElement_get_attributes(elem, &map);
11522     EXPECT_HR(hr, S_OK);
11523     /* collection dispex test, empty collection */
11524     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
11525     EXPECT_HR(hr, S_OK);
11526     did = 0;
11527     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
11528     EXPECT_HR(hr, S_OK);
11529     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
11530     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
11531     EXPECT_HR(hr, S_OK);
11532     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
11533     IDispatchEx_Release(dispex);
11534
11535     IXMLDOMNamedNodeMap_Release(map);
11536     IXMLDOMElement_Release(elem);
11537
11538     /* IXMLDOMImplementation */
11539     hr = IXMLDOMDocument_get_implementation(doc, &impl);
11540     EXPECT_HR(hr, S_OK);
11541
11542     hr = IXMLDOMImplementation_QueryInterface(impl, &IID_IDispatchEx, (void**)&dispex);
11543     EXPECT_HR(hr, S_OK);
11544     IDispatchEx_Release(dispex);
11545     IXMLDOMImplementation_Release(impl);
11546
11547     IXMLDOMDocument_Release(doc);
11548
11549     /* IXMLHTTPRequest */
11550     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
11551         &IID_IXMLHttpRequest, (void**)&req);
11552     if (hr == S_OK)
11553     {
11554         hr = IXMLHTTPRequest_QueryInterface(req, &IID_IDispatchEx, (void**)&dispex);
11555         EXPECT_HR(hr, E_NOINTERFACE);
11556         IXMLHTTPRequest_Release(req);
11557     }
11558
11559     /* IXSLTemplate */
11560     template = create_xsltemplate(&IID_IXSLTemplate);
11561     hr = IXSLTemplate_QueryInterface(template, &IID_IDispatchEx, (void**)&dispex);
11562     EXPECT_HR(hr, S_OK);
11563     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
11564     EXPECT_HR(hr, S_OK);
11565     test_domobj_dispex(unk);
11566     IUnknown_Release(unk);
11567     IDispatchEx_Release(dispex);
11568
11569     /* IXSLProcessor */
11570     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
11571     EXPECT_HR(hr, S_OK);
11572     b = VARIANT_FALSE;
11573     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformSSXML), &b);
11574     EXPECT_HR(hr, S_OK);
11575     ok(b == VARIANT_TRUE, "got %d\n", b);
11576
11577     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
11578     EXPECT_HR(hr, S_OK);
11579     IXMLDOMDocument_Release(doc);
11580
11581     hr = IXSLTemplate_createProcessor(template, &processor);
11582     EXPECT_HR(hr, S_OK);
11583     hr = IXSLProcessor_QueryInterface(processor, &IID_IDispatchEx, (void**)&dispex);
11584     EXPECT_HR(hr, S_OK);
11585     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
11586     EXPECT_HR(hr, S_OK);
11587     test_domobj_dispex(unk);
11588     IUnknown_Release(unk);
11589     IDispatchEx_Release(dispex);
11590
11591     IXSLProcessor_Release(processor);
11592     IXSLTemplate_Release(template);
11593
11594     free_bstrs();
11595 }
11596
11597 static void test_parseerror(void)
11598 {
11599     IXMLDOMParseError2 *error2;
11600     IXMLDOMParseError *error;
11601     IXMLDOMDocument *doc;
11602     HRESULT hr;
11603
11604     doc = create_document(&IID_IXMLDOMDocument);
11605
11606     hr = IXMLDOMDocument_get_parseError(doc, &error);
11607     EXPECT_HR(hr, S_OK);
11608
11609     hr = IXMLDOMParseError_get_line(error, NULL);
11610     EXPECT_HR(hr, E_INVALIDARG);
11611
11612     hr = IXMLDOMParseError_get_srcText(error, NULL);
11613     EXPECT_HR(hr, E_INVALIDARG);
11614
11615     hr = IXMLDOMParseError_get_linepos(error, NULL);
11616     EXPECT_HR(hr, E_INVALIDARG);
11617
11618     IXMLDOMParseError_Release(error);
11619     IXMLDOMDocument_Release(doc);
11620
11621     doc = create_document_version(60, &IID_IXMLDOMDocument);
11622     if (!doc) return;
11623     hr = IXMLDOMDocument_get_parseError(doc, &error);
11624     EXPECT_HR(hr, S_OK);
11625     hr = IXMLDOMParseError_QueryInterface(error, &IID_IXMLDOMParseError2, (void**)&error2);
11626     EXPECT_HR(hr, S_OK);
11627     IXMLDOMParseError2_Release(error2);
11628     IXMLDOMParseError_Release(error);
11629     IXMLDOMDocument_Release(doc);
11630 }
11631
11632 static void test_getAttributeNode(void)
11633 {
11634     IXMLDOMAttribute *attr;
11635     IXMLDOMDocument *doc;
11636     IXMLDOMElement *elem;
11637     VARIANT_BOOL v;
11638     HRESULT hr;
11639     BSTR str;
11640
11641     doc = create_document(&IID_IXMLDOMDocument);
11642
11643     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &v);
11644     EXPECT_HR(hr, S_OK);
11645
11646     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11647     EXPECT_HR(hr, S_OK);
11648
11649     str = SysAllocString(nonexistent_fileW);
11650     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
11651     EXPECT_HR(hr, E_FAIL);
11652
11653     attr = (IXMLDOMAttribute*)0xdeadbeef;
11654     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
11655     EXPECT_HR(hr, E_FAIL);
11656     ok(attr == NULL, "got %p\n", attr);
11657     SysFreeString(str);
11658
11659     str = SysAllocString(nonexistent_attrW);
11660     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
11661     EXPECT_HR(hr, S_FALSE);
11662
11663     attr = (IXMLDOMAttribute*)0xdeadbeef;
11664     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
11665     EXPECT_HR(hr, S_FALSE);
11666     ok(attr == NULL, "got %p\n", attr);
11667     SysFreeString(str);
11668
11669     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("foo:b"), &attr);
11670     EXPECT_HR(hr, S_OK);
11671     IXMLDOMAttribute_Release(attr);
11672
11673     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("b"), &attr);
11674     EXPECT_HR(hr, S_FALSE);
11675
11676     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("a"), &attr);
11677     EXPECT_HR(hr, S_OK);
11678     IXMLDOMAttribute_Release(attr);
11679
11680     IXMLDOMElement_Release(elem);
11681     IXMLDOMDocument_Release(doc);
11682     free_bstrs();
11683 }
11684
11685 typedef struct {
11686     DOMNodeType type;
11687     const char *name;
11688     REFIID iids[3];
11689 } supporterror_t;
11690
11691 static const supporterror_t supporterror_test[] = {
11692     { NODE_ELEMENT,                "element",   { &IID_IXMLDOMNode, &IID_IXMLDOMElement } },
11693     { NODE_ATTRIBUTE,              "attribute", { &IID_IXMLDOMNode, &IID_IXMLDOMAttribute } },
11694     { NODE_CDATA_SECTION,          "cdata",     { &IID_IXMLDOMNode, &IID_IXMLDOMCDATASection } },
11695     { NODE_ENTITY_REFERENCE,       "entityref", { &IID_IXMLDOMNode, &IID_IXMLDOMEntityReference } },
11696     { NODE_PROCESSING_INSTRUCTION, "pi",        { &IID_IXMLDOMNode, &IID_IXMLDOMProcessingInstruction } },
11697     { NODE_COMMENT,                "comment",   { &IID_IXMLDOMNode, &IID_IXMLDOMComment } },
11698     { NODE_DOCUMENT_FRAGMENT,      "fragment",  { &IID_IXMLDOMNode, &IID_IXMLDOMDocumentFragment } },
11699     { NODE_INVALID }
11700 };
11701
11702 static void test_supporterrorinfo(void)
11703 {
11704     static REFIID iids[5] = { &IID_IXMLDOMNode, &IID_IXMLDOMDocument,
11705                               &IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3 };
11706     const supporterror_t *ptr = supporterror_test;
11707     ISupportErrorInfo *errorinfo, *info2;
11708     IXMLDOMNamedNodeMap *map, *map2;
11709     IXMLDOMDocument *doc;
11710     IXMLDOMElement *elem;
11711     VARIANT_BOOL b;
11712     IUnknown *unk;
11713     REFIID *iid;
11714     void *dummy;
11715     HRESULT hr;
11716
11717     doc = create_document_version(60, &IID_IXMLDOMDocument3);
11718     if (!doc) return;
11719
11720     EXPECT_REF(doc, 1);
11721     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&errorinfo);
11722     EXPECT_HR(hr, S_OK);
11723     EXPECT_REF(doc, 1);
11724     ISupportErrorInfo_AddRef(errorinfo);
11725     EXPECT_REF(errorinfo, 2);
11726     EXPECT_REF(doc, 1);
11727     ISupportErrorInfo_Release(errorinfo);
11728
11729     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&info2);
11730     EXPECT_HR(hr, S_OK);
11731     ok(errorinfo != info2, "got %p, %p\n", info2, errorinfo);
11732
11733     /* error interface can't be queried back for DOM interface */
11734     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMDocument, &dummy);
11735     EXPECT_HR(hr, E_NOINTERFACE);
11736     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMNode, &dummy);
11737     EXPECT_HR(hr, E_NOINTERFACE);
11738
11739     ISupportErrorInfo_Release(info2);
11740
11741     iid = iids;
11742     while (*iid)
11743     {
11744         hr = IXMLDOMDocument_QueryInterface(doc, *iid, (void**)&unk);
11745         EXPECT_HR(hr, S_OK);
11746         if (hr == S_OK)
11747         {
11748             hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
11749             ok(hr == S_OK, "got 0x%08x for %s\n", hr, debugstr_guid(*iid));
11750             IUnknown_Release(unk);
11751         }
11752
11753         iid++;
11754     }
11755
11756     ISupportErrorInfo_Release(errorinfo);
11757
11758     while (ptr->type != NODE_INVALID)
11759     {
11760         IXMLDOMNode *node;
11761         VARIANT type;
11762
11763         V_VT(&type) = VT_I1;
11764         V_I1(&type) = ptr->type;
11765
11766         hr = IXMLDOMDocument_createNode(doc, type, _bstr_(ptr->name), NULL, &node);
11767         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
11768
11769         EXPECT_REF(node, 1);
11770         hr = IXMLDOMNode_QueryInterface(node, &IID_ISupportErrorInfo, (void**)&errorinfo);
11771         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
11772         EXPECT_REF(node, 1);
11773
11774         hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNode, &dummy);
11775         ok(hr == E_NOINTERFACE, "%d: got 0x%08x\n", ptr->type, hr);
11776
11777         iid = ptr->iids;
11778
11779         while (*iid)
11780         {
11781             hr = IXMLDOMNode_QueryInterface(node, *iid, (void**)&unk);
11782             if (hr == S_OK)
11783             {
11784                 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
11785                 ok(hr == S_OK, "%d: got 0x%08x for %s\n", ptr->type, hr, debugstr_guid(*iid));
11786                 IUnknown_Release(unk);
11787             }
11788
11789             iid++;
11790         }
11791
11792         ISupportErrorInfo_Release(errorinfo);
11793         IXMLDOMNode_Release(node);
11794         ptr++;
11795     }
11796
11797     /* IXMLDOMNamedNodeMap */
11798     b = VARIANT_FALSE;
11799     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
11800     EXPECT_HR(hr, S_OK);
11801     ok(b == VARIANT_TRUE, "got %d\n", b);
11802
11803     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11804     EXPECT_HR(hr, S_OK);
11805
11806     hr = IXMLDOMElement_get_attributes(elem, &map);
11807     EXPECT_HR(hr, S_OK);
11808
11809     EXPECT_REF(map, 1);
11810     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_ISupportErrorInfo, (void**)&errorinfo);
11811     EXPECT_HR(hr, S_OK);
11812     EXPECT_REF(map, 2);
11813
11814     hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMNamedNodeMap);
11815     EXPECT_HR(hr, S_OK);
11816
11817     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNamedNodeMap, (void**)&map2);
11818     EXPECT_HR(hr, S_OK);
11819     ok(map == map2, "got %p\n", map2);
11820     IXMLDOMNamedNodeMap_Release(map2);
11821
11822     EXPECT_REF(errorinfo, 2);
11823     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IUnknown, (void**)&unk);
11824     EXPECT_HR(hr, S_OK);
11825     EXPECT_REF(errorinfo, 3);
11826     EXPECT_REF(map, 3);
11827     IUnknown_Release(unk);
11828
11829     ISupportErrorInfo_Release(errorinfo);
11830     IXMLDOMNamedNodeMap_Release(map);
11831     IXMLDOMElement_Release(elem);
11832
11833     IXMLDOMDocument_Release(doc);
11834     free_bstrs();
11835 }
11836
11837 typedef struct {
11838     DOMNodeType type;
11839     const char *name;
11840     const char *put_content;
11841     HRESULT put_hr;
11842     VARTYPE get_vt;
11843     HRESULT get_hr;
11844 } node_value_t;
11845
11846 static const node_value_t nodevalue_test[] = {
11847     { NODE_ELEMENT,                "element",   "",             E_FAIL, VT_NULL, S_FALSE },
11848     { NODE_ATTRIBUTE,              "attr",      "value",        S_OK,   VT_BSTR, S_OK },
11849     { NODE_TEXT,                   "text",      "textdata",     S_OK,   VT_BSTR, S_OK },
11850     { NODE_CDATA_SECTION ,         "cdata",     "cdata data",   S_OK,   VT_BSTR, S_OK },
11851     { NODE_ENTITY_REFERENCE,       "entityref", "ref",          E_FAIL, VT_NULL, S_FALSE },
11852     { NODE_PROCESSING_INSTRUCTION, "pi",        "instr",        S_OK,   VT_BSTR, S_OK },
11853     { NODE_COMMENT,                "comment",   "comment data", S_OK,   VT_BSTR, S_OK },
11854     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   "",             E_FAIL, VT_NULL, S_FALSE },
11855     { NODE_INVALID }
11856 };
11857
11858 static void test_nodeValue(void)
11859 {
11860     const node_value_t *ptr = nodevalue_test;
11861     IXMLDOMDocument *doc;
11862     HRESULT hr;
11863
11864     doc = create_document(&IID_IXMLDOMDocument);
11865     if (!doc) return;
11866
11867     while (ptr->type != NODE_INVALID)
11868     {
11869         IXMLDOMNode *node;
11870         VARIANT v;
11871
11872         V_VT(&v) = VT_I2;
11873         V_I2(&v) = ptr->type;
11874
11875         hr = IXMLDOMDocument_createNode(doc, v, _bstr_(ptr->name), NULL, &node);
11876         ok(hr == S_OK, "failed to create node type %d\n", ptr->type);
11877
11878         hr = IXMLDOMNode_get_nodeValue(node, NULL);
11879         ok(hr == E_INVALIDARG, "%d: got 0x%08x\n", ptr->type, hr);
11880
11881         V_VT(&v) = VT_BSTR;
11882         V_BSTR(&v) = _bstr_(ptr->put_content);
11883         hr = IXMLDOMNode_put_nodeValue(node, v);
11884         ok(hr == ptr->put_hr, "%d: got 0x%08x\n", ptr->type, hr);
11885
11886         V_VT(&v) = VT_EMPTY;
11887         hr = IXMLDOMNode_get_nodeValue(node, &v);
11888         ok(hr == ptr->get_hr, "%d: got 0x%08x, expected 0x%08x\n", ptr->type, hr, ptr->get_hr);
11889         ok(V_VT(&v) == ptr->get_vt, "%d: got %d, expected %d\n", ptr->type, V_VT(&v), ptr->get_vt);
11890         if (hr == S_OK)
11891             ok(!lstrcmpW(V_BSTR(&v), _bstr_(ptr->put_content)), "%d: got %s\n", ptr->type,
11892                 wine_dbgstr_w(V_BSTR(&v)));
11893         VariantClear(&v);
11894
11895         IXMLDOMNode_Release(node);
11896
11897         ptr++;
11898     }
11899
11900     IXMLDOMDocument_Release(doc);
11901 }
11902
11903 static const char namespacesA[] =
11904 "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
11905 "   <ns1:elem1 xmlns:ns1=\"http://blah.org\" b='1' >"
11906 "     <ns2:elem2 xmlns:ns2=\"http://blah.org\"/>"
11907 "     <ns1:elem3/>"
11908 "     <ns1:elem4/>"
11909 "     <elem5 xmlns=\"http://blahblah.org\"/>"
11910 "     <ns1:elem6>true</ns1:elem6>"
11911 "   </ns1:elem1>";
11912
11913 static const char xsd_schema1_uri[] = "x-schema:test1.xsd";
11914 static const char xsd_schema1_xml[] =
11915 "<?xml version='1.0'?>"
11916 "<schema xmlns='http://www.w3.org/2001/XMLSchema'"
11917 "            targetNamespace='x-schema:test1.xsd'>"
11918 "   <element name='root'>"
11919 "       <complexType>"
11920 "           <sequence maxOccurs='unbounded'>"
11921 "               <any/>"
11922 "           </sequence>"
11923 "       </complexType>"
11924 "   </element>"
11925 "</schema>";
11926
11927 static void test_get_namespaces(void)
11928 {
11929     IXMLDOMSchemaCollection *collection, *collection2;
11930     IXMLDOMDocument2 *doc, *doc2;
11931     IEnumVARIANT *enumv, *enum2;
11932     IUnknown *unk1, *unk2;
11933     IXMLDOMNode *node;
11934     VARIANT_BOOL b;
11935     HRESULT hr;
11936     VARIANT v;
11937     LONG len;
11938     BSTR s;
11939
11940     doc = create_document(&IID_IXMLDOMDocument2);
11941     if (!doc) return;
11942
11943     /* null pointer */
11944     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
11945     EXPECT_HR(hr, E_POINTER);
11946
11947     /* no document loaded */
11948     collection = (void*)0xdeadbeef;
11949     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11950     EXPECT_HR(hr, S_OK);
11951     if (hr != S_OK)
11952     {
11953         IXMLDOMDocument_Release(doc);
11954         return;
11955     }
11956     EXPECT_REF(collection, 2);
11957
11958     collection2 = (void*)0xdeadbeef;
11959     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
11960     EXPECT_HR(hr, S_OK);
11961     ok(collection == collection2, "got %p\n", collection2);
11962     EXPECT_REF(collection, 3);
11963     IXMLDOMSchemaCollection_Release(collection);
11964
11965     len = -1;
11966     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11967     EXPECT_HR(hr, S_OK);
11968     ok(len == 0, "got %d\n", len);
11969     IXMLDOMSchemaCollection_Release(collection);
11970
11971     /* now with document */
11972     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
11973     EXPECT_HR(hr, S_OK);
11974
11975     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11976     EXPECT_HR(hr, S_OK);
11977
11978     len = -1;
11979     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11980     EXPECT_HR(hr, S_OK);
11981     ok(len == 2, "got %d\n", len);
11982
11983     /* try to lookup some uris */
11984     node = (void*)0xdeadbeef;
11985     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
11986     EXPECT_HR(hr, S_OK);
11987     ok(node == NULL, "got %p\n", node);
11988
11989     node = (void*)0xdeadbeef;
11990     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah1.org"), &node);
11991     EXPECT_HR(hr, S_OK);
11992     ok(node == NULL, "got %p\n", node);
11993
11994     /* load schema and try to add it */
11995     doc2 = create_document(&IID_IXMLDOMDocument2);
11996     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
11997     EXPECT_HR(hr, S_OK);
11998
11999     V_VT(&v) = VT_DISPATCH;
12000     V_DISPATCH(&v) = (IDispatch*)doc2;
12001     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
12002     EXPECT_HR(hr, E_FAIL);
12003
12004     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
12005     EXPECT_HR(hr, S_OK);
12006     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
12007     SysFreeString(s);
12008
12009     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
12010     EXPECT_HR(hr, S_OK);
12011     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
12012     SysFreeString(s);
12013
12014     s = (void*)0xdeadbeef;
12015     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
12016     EXPECT_HR(hr, E_FAIL);
12017     ok(s == (void*)0xdeadbeef, "got %p\n", s);
12018
12019     /* enumerate */
12020     enumv = (void*)0xdeadbeef;
12021     EXPECT_REF(collection, 2);
12022     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
12023     EXPECT_HR(hr, S_OK);
12024     EXPECT_REF(collection, 3);
12025     ok(enumv != NULL, "got %p\n", enumv);
12026
12027     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IUnknown, (void**)&unk1);
12028     EXPECT_HR(hr, S_OK);
12029     hr = IEnumVARIANT_QueryInterface(enumv, &IID_IUnknown, (void**)&unk2);
12030     EXPECT_HR(hr, S_OK);
12031     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
12032     IUnknown_Release(unk1);
12033     IUnknown_Release(unk2);
12034
12035     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IEnumVARIANT, (void**)&enum2);
12036     EXPECT_HR(hr, E_NOINTERFACE);
12037
12038     V_VT(&v) = VT_EMPTY;
12039     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12040     EXPECT_HR(hr, S_OK);
12041     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12042     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12043     VariantClear(&v);
12044
12045     V_VT(&v) = VT_EMPTY;
12046     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12047     EXPECT_HR(hr, S_OK);
12048     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12049     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12050     VariantClear(&v);
12051
12052     V_VT(&v) = VT_NULL;
12053     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12054     EXPECT_HR(hr, S_FALSE);
12055     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
12056
12057     IEnumVARIANT_Release(enumv);
12058     IXMLDOMSchemaCollection_Release(collection);
12059
12060     IXMLDOMDocument2_Release(doc);
12061
12062     /* now with CLSID_DOMDocument60 */
12063     doc = create_document_version(60, &IID_IXMLDOMDocument2);
12064     if (!doc) return;
12065
12066     /* null pointer */
12067     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
12068     EXPECT_HR(hr, E_POINTER);
12069
12070     /* no document loaded */
12071     collection = (void*)0xdeadbeef;
12072     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
12073     EXPECT_HR(hr, S_OK);
12074     if (hr != S_OK)
12075     {
12076         IXMLDOMDocument_Release(doc);
12077         return;
12078     }
12079     EXPECT_REF(collection, 2);
12080
12081     collection2 = (void*)0xdeadbeef;
12082     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
12083     EXPECT_HR(hr, S_OK);
12084     ok(collection == collection2, "got %p\n", collection2);
12085     EXPECT_REF(collection, 3);
12086     IXMLDOMSchemaCollection_Release(collection);
12087
12088     len = -1;
12089     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
12090     EXPECT_HR(hr, S_OK);
12091     ok(len == 0, "got %d\n", len);
12092     IXMLDOMSchemaCollection_Release(collection);
12093
12094     /* now with document */
12095     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
12096     EXPECT_HR(hr, S_OK);
12097
12098     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
12099     EXPECT_HR(hr, S_OK);
12100
12101     len = -1;
12102     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
12103     EXPECT_HR(hr, S_OK);
12104     ok(len == 2, "got %d\n", len);
12105
12106     /* try to lookup some uris */
12107     node = (void*)0xdeadbeef;
12108     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
12109     EXPECT_HR(hr, E_NOTIMPL);
12110     ok(node == (void*)0xdeadbeef, "got %p\n", node);
12111
12112     /* load schema and try to add it */
12113     doc2 = create_document(&IID_IXMLDOMDocument2);
12114     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
12115     EXPECT_HR(hr, S_OK);
12116
12117     V_VT(&v) = VT_DISPATCH;
12118     V_DISPATCH(&v) = (IDispatch*)doc2;
12119     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
12120     EXPECT_HR(hr, E_FAIL);
12121     IXMLDOMSchemaCollection_Release(doc2);
12122
12123     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
12124     EXPECT_HR(hr, S_OK);
12125     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
12126     SysFreeString(s);
12127
12128     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
12129     EXPECT_HR(hr, S_OK);
12130     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
12131     SysFreeString(s);
12132
12133     s = (void*)0xdeadbeef;
12134     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
12135     EXPECT_HR(hr, E_FAIL);
12136     ok(s == (void*)0xdeadbeef, "got %p\n", s);
12137
12138     /* enumerate */
12139     enumv = (void*)0xdeadbeef;
12140     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
12141     EXPECT_HR(hr, S_OK);
12142     ok(enumv != NULL, "got %p\n", enumv);
12143
12144     V_VT(&v) = VT_EMPTY;
12145     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12146     EXPECT_HR(hr, S_OK);
12147     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12148     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12149     VariantClear(&v);
12150
12151     V_VT(&v) = VT_EMPTY;
12152     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12153     EXPECT_HR(hr, S_OK);
12154     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12155     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12156     VariantClear(&v);
12157
12158     V_VT(&v) = VT_NULL;
12159     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12160     EXPECT_HR(hr, S_FALSE);
12161     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
12162
12163     IEnumVARIANT_Release(enumv);
12164     IXMLDOMSchemaCollection_Release(collection);
12165     IXMLDOMDocument2_Release(doc);
12166     free_bstrs();
12167 }
12168
12169 static DOMNodeType put_data_types[] = {
12170     NODE_TEXT,
12171     NODE_CDATA_SECTION,
12172     NODE_PROCESSING_INSTRUCTION,
12173     NODE_COMMENT,
12174     NODE_INVALID
12175 };
12176
12177 static void test_put_data(void)
12178 {
12179     static const WCHAR test_data[] = {'t','e','s','t',' ','n','o','d','e',' ','d','a','t','a',0};
12180     WCHAR buff[100], *data;
12181     IXMLDOMDocument *doc;
12182     DOMNodeType *type;
12183     BSTR get_data;
12184     HRESULT hr;
12185
12186     doc = create_document(&IID_IXMLDOMDocument);
12187     if (!doc) return;
12188
12189     memcpy(&buff[2], test_data, sizeof(test_data));
12190     /* just a big length */
12191     *(DWORD*)buff = 0xf0f0;
12192     data = &buff[2];
12193
12194     type = put_data_types;
12195     while (*type != NODE_INVALID)
12196     {
12197        IXMLDOMNode *node;
12198        VARIANT v;
12199
12200        V_VT(&v) = VT_I2;
12201        V_I2(&v) = *type;
12202
12203        hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
12204        EXPECT_HR(hr, S_OK);
12205
12206        /* put_data() is interface-specific */
12207        switch (*type)
12208        {
12209            case NODE_TEXT:
12210            {
12211               IXMLDOMText *text;
12212
12213               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
12214               EXPECT_HR(hr, S_OK);
12215               hr = IXMLDOMText_put_data(text, data);
12216               EXPECT_HR(hr, S_OK);
12217
12218               hr = IXMLDOMText_get_data(text, &get_data);
12219               EXPECT_HR(hr, S_OK);
12220
12221               IXMLDOMText_Release(text);
12222               break;
12223            }
12224            case NODE_CDATA_SECTION:
12225            {
12226               IXMLDOMCDATASection *cdata;
12227
12228               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
12229               EXPECT_HR(hr, S_OK);
12230               hr = IXMLDOMCDATASection_put_data(cdata, data);
12231               EXPECT_HR(hr, S_OK);
12232
12233               hr = IXMLDOMCDATASection_get_data(cdata, &get_data);
12234               EXPECT_HR(hr, S_OK);
12235
12236               IXMLDOMCDATASection_Release(cdata);
12237               break;
12238            }
12239            case NODE_PROCESSING_INSTRUCTION:
12240            {
12241               IXMLDOMProcessingInstruction *pi;
12242
12243               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)&pi);
12244               EXPECT_HR(hr, S_OK);
12245               hr = IXMLDOMProcessingInstruction_put_data(pi, data);
12246               EXPECT_HR(hr, S_OK);
12247
12248               hr = IXMLDOMProcessingInstruction_get_data(pi, &get_data);
12249               EXPECT_HR(hr, S_OK);
12250
12251               IXMLDOMProcessingInstruction_Release(pi);
12252               break;
12253            }
12254            case NODE_COMMENT:
12255            {
12256               IXMLDOMComment *comment;
12257
12258               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
12259               EXPECT_HR(hr, S_OK);
12260               hr = IXMLDOMComment_put_data(comment, data);
12261               EXPECT_HR(hr, S_OK);
12262
12263               hr = IXMLDOMComment_get_data(comment, &get_data);
12264               EXPECT_HR(hr, S_OK);
12265
12266               IXMLDOMComment_Release(comment);
12267               break;
12268            }
12269            default:
12270               break;
12271        }
12272
12273        /* compare */
12274        ok(!lstrcmpW(data, get_data), "%d: got wrong data %s, expected %s\n", *type, wine_dbgstr_w(get_data),
12275            wine_dbgstr_w(data));
12276        SysFreeString(get_data);
12277
12278        IXMLDOMNode_Release(node);
12279        type++;
12280     }
12281
12282     IXMLDOMDocument_Release(doc);
12283     free_bstrs();
12284 }
12285
12286 static void test_putref_schemas(void)
12287 {
12288     IXMLDOMSchemaCollection *cache;
12289     IXMLDOMDocument2 *doc;
12290     VARIANT schema;
12291     HRESULT hr;
12292
12293     doc = create_document(&IID_IXMLDOMDocument2);
12294     if (!doc) return;
12295     cache = create_cache(&IID_IXMLDOMSchemaCollection);
12296
12297     /* set to NULL iface when no schema is set */
12298     V_VT(&schema) = VT_DISPATCH;
12299     V_DISPATCH(&schema) = NULL;
12300     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12301     EXPECT_HR(hr, S_OK);
12302
12303     V_VT(&schema) = VT_UNKNOWN;
12304     V_UNKNOWN(&schema) = NULL;
12305     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12306     EXPECT_HR(hr, S_OK);
12307
12308     /* set as VT_DISPATCH, reset with it */
12309     V_VT(&schema) = VT_DISPATCH;
12310     V_DISPATCH(&schema) = (IDispatch*)cache;
12311     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12312     EXPECT_HR(hr, S_OK);
12313
12314     V_DISPATCH(&schema) = NULL;
12315     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12316     EXPECT_HR(hr, S_OK);
12317     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
12318
12319     V_VT(&schema) = VT_DISPATCH;
12320     V_DISPATCH(&schema) = NULL;
12321     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12322     EXPECT_HR(hr, S_OK);
12323
12324     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
12325     V_VT(&schema) = VT_I2;
12326     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12327     EXPECT_HR(hr, S_FALSE);
12328     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
12329     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
12330
12331     /* set as VT_UNKNOWN, reset with it */
12332     V_VT(&schema) = VT_UNKNOWN;
12333     V_UNKNOWN(&schema) = (IUnknown*)cache;
12334     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12335     EXPECT_HR(hr, S_OK);
12336
12337     V_DISPATCH(&schema) = NULL;
12338     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12339     EXPECT_HR(hr, S_OK);
12340     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
12341
12342     V_VT(&schema) = VT_UNKNOWN;
12343     V_UNKNOWN(&schema) = NULL;
12344     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12345     EXPECT_HR(hr, S_OK);
12346
12347     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
12348     V_VT(&schema) = VT_I2;
12349     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12350     EXPECT_HR(hr, S_FALSE);
12351     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
12352     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
12353
12354     IXMLDOMSchemaCollection_Release(cache);
12355     IXMLDOMDocument2_Release(doc);
12356 }
12357
12358 static void test_namedmap_newenum(void)
12359 {
12360     IEnumVARIANT *enum1, *enum2, *enum3;
12361     IXMLDOMNamedNodeMap *map;
12362     IUnknown *unk1, *unk2;
12363     IXMLDOMDocument *doc;
12364     IXMLDOMElement *elem;
12365     IXMLDOMNode *node;
12366     VARIANT_BOOL b;
12367     HRESULT hr;
12368     VARIANT v;
12369     BSTR str;
12370
12371     doc = create_document(&IID_IXMLDOMDocument);
12372
12373     hr = IXMLDOMDocument_loadXML(doc, _bstr_(attributes_map), &b);
12374     EXPECT_HR(hr, S_OK);
12375
12376     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
12377     EXPECT_HR(hr, S_OK);
12378
12379     hr = IXMLDOMElement_get_attributes(elem, &map);
12380     EXPECT_HR(hr, S_OK);
12381     IXMLDOMElement_Release(elem);
12382
12383     enum1 = NULL;
12384     EXPECT_REF(map, 1);
12385     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum1);
12386     EXPECT_HR(hr, S_OK);
12387     ok(enum1 != NULL, "got %p\n", enum1);
12388     EXPECT_REF(map, 1);
12389     EXPECT_REF(enum1, 2);
12390
12391     enum2 = NULL;
12392     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum2);
12393     EXPECT_HR(hr, S_OK);
12394     ok(enum2 == enum1, "got %p\n", enum2);
12395
12396     IEnumVARIANT_Release(enum2);
12397
12398     EXPECT_REF(map, 1);
12399     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum2);
12400     EXPECT_HR(hr, S_OK);
12401     EXPECT_REF(map, 2);
12402     EXPECT_REF(enum2, 1);
12403     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
12404
12405     IEnumVARIANT_Release(enum1);
12406
12407     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
12408     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk1);
12409     EXPECT_HR(hr, S_OK);
12410     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
12411     EXPECT_HR(hr, S_OK);
12412     EXPECT_REF(map, 3);
12413     EXPECT_REF(enum2, 2);
12414     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
12415     IUnknown_Release(unk1);
12416     IUnknown_Release(unk2);
12417
12418     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum3);
12419     EXPECT_HR(hr, S_OK);
12420     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
12421     IEnumVARIANT_Release(enum3);
12422
12423     /* iteration tests */
12424     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node);
12425     EXPECT_HR(hr, S_OK);
12426     hr = IXMLDOMNode_get_nodeName(node, &str);
12427     EXPECT_HR(hr, S_OK);
12428     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
12429     SysFreeString(str);
12430     IXMLDOMNode_Release(node);
12431
12432     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
12433     EXPECT_HR(hr, S_OK);
12434     hr = IXMLDOMNode_get_nodeName(node, &str);
12435     EXPECT_HR(hr, S_OK);
12436     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
12437     SysFreeString(str);
12438     IXMLDOMNode_Release(node);
12439
12440     V_VT(&v) = VT_EMPTY;
12441     hr = IEnumVARIANT_Next(enum2, 1, &v, NULL);
12442     EXPECT_HR(hr, S_OK);
12443     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
12444     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
12445     EXPECT_HR(hr, S_OK);
12446     hr = IXMLDOMNode_get_nodeName(node, &str);
12447     EXPECT_HR(hr, S_OK);
12448     ok(!lstrcmpW(str, _bstr_("attr1")), "got node name %s\n", wine_dbgstr_w(str));
12449     SysFreeString(str);
12450     IXMLDOMNode_Release(node);
12451     VariantClear(&v);
12452
12453     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
12454     EXPECT_HR(hr, S_OK);
12455     hr = IXMLDOMNode_get_nodeName(node, &str);
12456     EXPECT_HR(hr, S_OK);
12457     ok(!lstrcmpW(str, _bstr_("attr2")), "got %s\n", wine_dbgstr_w(str));
12458     SysFreeString(str);
12459     IXMLDOMNode_Release(node);
12460
12461     IEnumVARIANT_Release(enum2);
12462     IXMLDOMNamedNodeMap_Release(map);
12463     IXMLDOMDocument_Release(doc);
12464 }
12465
12466 START_TEST(domdoc)
12467 {
12468     IXMLDOMDocument *doc;
12469     IUnknown *unk;
12470     HRESULT hr;
12471
12472     hr = CoInitialize( NULL );
12473     ok( hr == S_OK, "failed to init com\n");
12474     if (hr != S_OK) return;
12475
12476     test_XMLHTTP();
12477
12478     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc );
12479     if (hr != S_OK)
12480     {
12481         win_skip("IXMLDOMDocument is not available (0x%08x)\n", hr);
12482         return;
12483     }
12484
12485     IXMLDOMDocument_Release(doc);
12486
12487     test_domdoc();
12488     test_persiststreaminit();
12489     test_domnode();
12490     test_refs();
12491     test_create();
12492     test_getElementsByTagName();
12493     test_get_text();
12494     test_get_childNodes();
12495     test_get_firstChild();
12496     test_get_lastChild();
12497     test_removeChild();
12498     test_replaceChild();
12499     test_removeNamedItem();
12500     test_IXMLDOMDocument2();
12501     test_whitespace();
12502     test_XPath();
12503     test_XSLPattern();
12504     test_cloneNode();
12505     test_xmlTypes();
12506     test_save();
12507     test_testTransforms();
12508     test_namespaces_basic();
12509     test_namespaces_change();
12510     test_FormattingXML();
12511     test_nodeTypedValue();
12512     test_TransformWithLoadingLocalFile();
12513     test_put_nodeValue();
12514     test_document_IObjectSafety();
12515     test_splitText();
12516     test_getQualifiedItem();
12517     test_removeQualifiedItem();
12518     test_get_ownerDocument();
12519     test_setAttributeNode();
12520     test_put_dataType();
12521     test_createNode();
12522     test_get_prefix();
12523     test_default_properties();
12524     test_selectSingleNode();
12525     test_events();
12526     test_createProcessingInstruction();
12527     test_put_nodeTypedValue();
12528     test_get_xml();
12529     test_insertBefore();
12530     test_appendChild();
12531     test_get_doctype();
12532     test_get_tagName();
12533     test_get_dataType();
12534     test_get_nodeTypeString();
12535     test_get_attributes();
12536     test_selection();
12537     test_load();
12538     test_dispex();
12539     test_parseerror();
12540     test_getAttributeNode();
12541     test_supporterrorinfo();
12542     test_nodeValue();
12543     test_get_namespaces();
12544     test_put_data();
12545     test_putref_schemas();
12546     test_namedmap_newenum();
12547
12548     test_xsltemplate();
12549
12550     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
12551         &IID_IMXNamespaceManager, (void**)&unk);
12552     if (hr == S_OK)
12553     {
12554         test_mxnamespacemanager();
12555         test_mxnamespacemanager_override();
12556
12557         IUnknown_Release(unk);
12558     }
12559     else
12560         win_skip("MXNamespaceManager is not available\n");
12561
12562     CoUninitialize();
12563 }