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-2011 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 DEFINE_GUID(SID_SContainerDispatch, 0xb722be00, 0x4e68, 0x101b, 0xa2, 0xbc, 0x00, 0xaa, 0x00, 0x40, 0x47, 0x70);
  45 DEFINE_GUID(SID_UnknownSID, 0x75dd09cb, 0x6c40, 0x11d5, 0x85, 0x43, 0x00, 0xc0, 0x4f, 0xa0, 0xfb, 0xa3);
  46
  47 #define DEFINE_EXPECT(func) \
  48     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  49
  50 #define SET_EXPECT(func) \
  51     expect_ ## func = TRUE
  52
  53 #define CHECK_EXPECT2(func) \
  54     do { \
  55         ok(expect_ ##func, "unexpected call " #func "\n"); \
  56         called_ ## func = TRUE; \
  57     }while(0)
  58
  59 #define CHECK_CALLED(func) \
  60     do { \
  61         ok(called_ ## func, "expected " #func "\n"); \
  62         expect_ ## func = called_ ## func = FALSE; \
  63     }while(0)
  64
  65 static const char *debugstr_guid(REFIID riid)
  66 {
  67     static char buf[50];
  68
  69     if(!riid)
  70         return "(null)";
  71
  72     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  73             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
  74             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
  75             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
  76
  77     return buf;
  78 }
  79
  80 static int g_unexpectedcall, g_expectedcall;
  81
  82 typedef struct
  83 {
  84     IDispatch IDispatch_iface;
  85     LONG ref;
  86 } dispevent;
  87
  88 static inline dispevent *impl_from_IDispatch( IDispatch *iface )
  89 {
  90     return CONTAINING_RECORD(iface, dispevent, IDispatch_iface);
  91 }
  92
  93 static HRESULT WINAPI dispevent_QueryInterface(IDispatch *iface, REFIID riid, void **ppvObject)
  94 {
  95     *ppvObject = NULL;
  96
  97     if ( IsEqualGUID( riid, &IID_IDispatch) ||
  98          IsEqualGUID( riid, &IID_IUnknown) )
  99     {
 100         *ppvObject = iface;
 101     }
 102     else
 103         return E_NOINTERFACE;
 104
 105     IDispatch_AddRef( iface );
 106
 107     return S_OK;
 108 }
 109
 110 static ULONG WINAPI dispevent_AddRef(IDispatch *iface)
 111 {
 112     dispevent *This = impl_from_IDispatch( iface );
 113     return InterlockedIncrement( &This->ref );
 114 }
 115
 116 static ULONG WINAPI dispevent_Release(IDispatch *iface)
 117 {
 118     dispevent *This = impl_from_IDispatch( iface );
 119     ULONG ref = InterlockedDecrement( &This->ref );
 120
 121     if (ref == 0)
 122         HeapFree(GetProcessHeap(), 0, This);
 123
 124     return ref;
 125 }
 126
 127 static HRESULT WINAPI dispevent_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 128 {
 129     g_unexpectedcall++;
 130     *pctinfo = 0;
 131     return S_OK;
 132 }
 133
 134 static HRESULT WINAPI dispevent_GetTypeInfo(IDispatch *iface, UINT iTInfo,
 135         LCID lcid, ITypeInfo **ppTInfo)
 136 {
 137     g_unexpectedcall++;
 138     return S_OK;
 139 }
 140
 141 static HRESULT WINAPI dispevent_GetIDsOfNames(IDispatch *iface, REFIID riid,
 142         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 143 {
 144     g_unexpectedcall++;
 145     return S_OK;
 146 }
 147
 148 static HRESULT WINAPI dispevent_Invoke(IDispatch *iface, DISPID member, REFIID riid,
 149         LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result,
 150         EXCEPINFO *excepInfo, UINT *argErr)
 151 {
 152     ok(member == 0, "expected 0 member, got %d\n", member);
 153     ok(lcid == LOCALE_SYSTEM_DEFAULT, "expected LOCALE_SYSTEM_DEFAULT, got lcid %x\n", lcid);
 154     ok(flags == DISPATCH_METHOD, "expected DISPATCH_METHOD, got %d\n", flags);
 155
 156     ok(params->cArgs == 0, "got %d\n", params->cArgs);
 157     ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
 158     ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
 159     ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
 160
 161     ok(result == NULL, "got %p\n", result);
 162     ok(excepInfo == NULL, "got %p\n", excepInfo);
 163     ok(argErr == NULL, "got %p\n", argErr);
 164
 165     g_expectedcall++;
 166     return E_FAIL;
 167 }
 168
 169 static const IDispatchVtbl dispeventVtbl =
 170 {
 171     dispevent_QueryInterface,
 172     dispevent_AddRef,
 173     dispevent_Release,
 174     dispevent_GetTypeInfoCount,
 175     dispevent_GetTypeInfo,
 176     dispevent_GetIDsOfNames,
 177     dispevent_Invoke
 178 };
 179
 180 static IDispatch* create_dispevent(void)
 181 {
 182     dispevent *event = HeapAlloc(GetProcessHeap(), 0, sizeof(*event));
 183
 184     event->IDispatch_iface.lpVtbl = &dispeventVtbl;
 185     event->ref = 1;
 186
 187     return (IDispatch*)&event->IDispatch_iface;
 188 }
 189
 190 /* object site */
 191 DEFINE_EXPECT(site_qi_IServiceProvider);
 192 DEFINE_EXPECT(site_qi_IXMLDOMDocument);
 193 DEFINE_EXPECT(site_qi_IOleClientSite);
 194
 195 DEFINE_EXPECT(sp_queryservice_SID_SBindHost);
 196 DEFINE_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
 197 DEFINE_EXPECT(sp_queryservice_SID_secmgr_htmldoc2);
 198 DEFINE_EXPECT(sp_queryservice_SID_secmgr_xmldomdoc);
 199 DEFINE_EXPECT(sp_queryservice_SID_secmgr_secmgr);
 200
 201 DEFINE_EXPECT(htmldoc2_get_all);
 202 DEFINE_EXPECT(htmldoc2_get_url);
 203 DEFINE_EXPECT(collection_get_length);
 204
 205 typedef struct
 206 {
 207     IServiceProvider IServiceProvider_iface;
 208 } testprov_t;
 209
 210 testprov_t testprov;
 211
 212 static HRESULT WINAPI site_QueryInterface(IUnknown *iface, REFIID riid, void **ppvObject)
 213 {
 214     *ppvObject = NULL;
 215
 216     if (IsEqualGUID(riid, &IID_IServiceProvider))
 217         CHECK_EXPECT2(site_qi_IServiceProvider);
 218
 219     if (IsEqualGUID(riid, &IID_IXMLDOMDocument))
 220         CHECK_EXPECT2(site_qi_IXMLDOMDocument);
 221
 222     if (IsEqualGUID(riid, &IID_IOleClientSite))
 223         CHECK_EXPECT2(site_qi_IOleClientSite);
 224
 225     if (IsEqualGUID(riid, &IID_IUnknown))
 226          *ppvObject = iface;
 227     else if (IsEqualGUID(riid, &IID_IServiceProvider))
 228          *ppvObject = &testprov.IServiceProvider_iface;
 229
 230     if (*ppvObject) IUnknown_AddRef(iface);
 231
 232     return *ppvObject ? S_OK : E_NOINTERFACE;
 233 }
 234
 235 static ULONG WINAPI site_AddRef(IUnknown *iface)
 236 {
 237     return 2;
 238 }
 239
 240 static ULONG WINAPI site_Release(IUnknown *iface)
 241 {
 242     return 1;
 243 }
 244
 245 static const IUnknownVtbl testsiteVtbl =
 246 {
 247     site_QueryInterface,
 248     site_AddRef,
 249     site_Release
 250 };
 251
 252 typedef struct
 253 {
 254     IUnknown IUnknown_iface;
 255 } testsite_t;
 256
 257 static testsite_t testsite = { { &testsiteVtbl } };
 258
 259 /* test IHTMLElementCollection */
 260 static HRESULT WINAPI htmlecoll_QueryInterface(IHTMLElementCollection *iface, REFIID riid, void **ppvObject)
 261 {
 262     ok(0, "unexpected call\n");
 263     *ppvObject = NULL;
 264     return E_NOINTERFACE;
 265 }
 266
 267 static ULONG WINAPI htmlecoll_AddRef(IHTMLElementCollection *iface)
 268 {
 269     return 2;
 270 }
 271
 272 static ULONG WINAPI htmlecoll_Release(IHTMLElementCollection *iface)
 273 {
 274     return 1;
 275 }
 276
 277 static HRESULT WINAPI htmlecoll_GetTypeInfoCount(IHTMLElementCollection *iface, UINT *pctinfo)
 278 {
 279     ok(0, "unexpected call\n");
 280     return E_NOTIMPL;
 281 }
 282
 283 static HRESULT WINAPI htmlecoll_GetTypeInfo(IHTMLElementCollection *iface, UINT iTInfo,
 284                                                 LCID lcid, ITypeInfo **ppTInfo)
 285 {
 286     ok(0, "unexpected call\n");
 287     return E_NOTIMPL;
 288 }
 289
 290 static HRESULT WINAPI htmlecoll_GetIDsOfNames(IHTMLElementCollection *iface, REFIID riid,
 291                                                 LPOLESTR *rgszNames, UINT cNames,
 292                                                 LCID lcid, DISPID *rgDispId)
 293 {
 294     ok(0, "unexpected call\n");
 295     return E_NOTIMPL;
 296 }
 297
 298 static HRESULT WINAPI htmlecoll_Invoke(IHTMLElementCollection *iface, DISPID dispIdMember,
 299                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 300                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 301 {
 302     ok(0, "unexpected call\n");
 303     return E_NOTIMPL;
 304 }
 305
 306 static HRESULT WINAPI htmlecoll_toString(IHTMLElementCollection *iface, BSTR *String)
 307 {
 308     ok(0, "unexpected call\n");
 309     return E_NOTIMPL;
 310 }
 311
 312 static HRESULT WINAPI htmlecoll_put_length(IHTMLElementCollection *iface, LONG v)
 313 {
 314     ok(0, "unexpected call\n");
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT WINAPI htmlecoll_get_length(IHTMLElementCollection *iface, LONG *v)
 319 {
 320     CHECK_EXPECT2(collection_get_length);
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI htmlecoll_get__newEnum(IHTMLElementCollection *iface, IUnknown **p)
 325 {
 326     ok(0, "unexpected call\n");
 327     return E_NOTIMPL;
 328 }
 329
 330 static HRESULT WINAPI htmlecoll_item(IHTMLElementCollection *iface, VARIANT name, VARIANT index, IDispatch **pdisp)
 331 {
 332     ok(0, "unexpected call\n");
 333     return E_NOTIMPL;
 334 }
 335
 336 static HRESULT WINAPI htmlecoll_tags(IHTMLElementCollection *iface, VARIANT tagName, IDispatch **pdisp)
 337 {
 338     ok(0, "unexpected call\n");
 339     return E_NOTIMPL;
 340 }
 341
 342 static const IHTMLElementCollectionVtbl TestHTMLECollectionVtbl = {
 343     htmlecoll_QueryInterface,
 344     htmlecoll_AddRef,
 345     htmlecoll_Release,
 346     htmlecoll_GetTypeInfoCount,
 347     htmlecoll_GetTypeInfo,
 348     htmlecoll_GetIDsOfNames,
 349     htmlecoll_Invoke,
 350
 351     htmlecoll_toString,
 352     htmlecoll_put_length,
 353     htmlecoll_get_length,
 354     htmlecoll_get__newEnum,
 355     htmlecoll_item,
 356     htmlecoll_tags
 357 };
 358
 359 typedef struct
 360 {
 361     IHTMLElementCollection IHTMLElementCollection_iface;
 362 } testhtmlecoll_t;
 363
 364 static testhtmlecoll_t htmlecoll = { { &TestHTMLECollectionVtbl } };
 365
 366 /* test IHTMLDocument2 */
 367 static HRESULT WINAPI htmldoc2_QueryInterface(IHTMLDocument2 *iface, REFIID riid, void **ppvObject)
 368 {
 369    trace("\n");
 370    *ppvObject = NULL;
 371    return E_NOINTERFACE;
 372 }
 373
 374 static ULONG WINAPI htmldoc2_AddRef(IHTMLDocument2 *iface)
 375 {
 376     return 2;
 377 }
 378
 379 static ULONG WINAPI htmldoc2_Release(IHTMLDocument2 *iface)
 380 {
 381     return 1;
 382 }
 383
 384 static HRESULT WINAPI htmldoc2_GetTypeInfoCount(IHTMLDocument2 *iface, UINT *pctinfo)
 385 {
 386     ok(0, "unexpected call\n");
 387     return E_NOTIMPL;
 388 }
 389
 390 static HRESULT WINAPI htmldoc2_GetTypeInfo(IHTMLDocument2 *iface, UINT iTInfo,
 391                                                 LCID lcid, ITypeInfo **ppTInfo)
 392 {
 393     ok(0, "unexpected call\n");
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI htmldoc2_GetIDsOfNames(IHTMLDocument2 *iface, REFIID riid,
 398                                                 LPOLESTR *rgszNames, UINT cNames,
 399                                                 LCID lcid, DISPID *rgDispId)
 400 {
 401     ok(0, "unexpected call\n");
 402     return E_NOTIMPL;
 403 }
 404
 405 static HRESULT WINAPI htmldoc2_Invoke(IHTMLDocument2 *iface, DISPID dispIdMember,
 406                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 407                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 408 {
 409     ok(0, "unexpected call\n");
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI htmldoc2_get_Script(IHTMLDocument2 *iface, IDispatch **p)
 414 {
 415     ok(0, "unexpected call\n");
 416     return E_NOTIMPL;
 417 }
 418
 419 static HRESULT WINAPI htmldoc2_get_all(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 420 {
 421     CHECK_EXPECT2(htmldoc2_get_all);
 422     *p = &htmlecoll.IHTMLElementCollection_iface;
 423     return S_OK;
 424 }
 425
 426 static HRESULT WINAPI htmldoc2_get_body(IHTMLDocument2 *iface, IHTMLElement **p)
 427 {
 428     ok(0, "unexpected call\n");
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI htmldoc2_get_activeElement(IHTMLDocument2 *iface, IHTMLElement **p)
 433 {
 434     ok(0, "unexpected call\n");
 435     return E_NOTIMPL;
 436 }
 437
 438 static HRESULT WINAPI htmldoc2_get_images(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 439 {
 440     ok(0, "unexpected call\n");
 441     return E_NOTIMPL;
 442 }
 443
 444 static HRESULT WINAPI htmldoc2_get_applets(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 445 {
 446     ok(0, "unexpected call\n");
 447     return E_NOTIMPL;
 448 }
 449
 450 static HRESULT WINAPI htmldoc2_get_links(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 451 {
 452     ok(0, "unexpected call\n");
 453     return E_NOTIMPL;
 454 }
 455
 456 static HRESULT WINAPI htmldoc2_get_forms(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 457 {
 458     ok(0, "unexpected call\n");
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT WINAPI htmldoc2_get_anchors(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 463 {
 464     ok(0, "unexpected call\n");
 465     return E_NOTIMPL;
 466 }
 467
 468 static HRESULT WINAPI htmldoc2_put_title(IHTMLDocument2 *iface, BSTR v)
 469 {
 470     ok(0, "unexpected call\n");
 471     return E_NOTIMPL;
 472 }
 473
 474 static HRESULT WINAPI htmldoc2_get_title(IHTMLDocument2 *iface, BSTR *p)
 475 {
 476     ok(0, "unexpected call\n");
 477     return E_NOTIMPL;
 478 }
 479
 480 static HRESULT WINAPI htmldoc2_get_scripts(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 481 {
 482     ok(0, "unexpected call\n");
 483     return E_NOTIMPL;
 484 }
 485
 486 static HRESULT WINAPI htmldoc2_put_designMode(IHTMLDocument2 *iface, BSTR v)
 487 {
 488     ok(0, "unexpected call\n");
 489     return E_NOTIMPL;
 490 }
 491
 492 static HRESULT WINAPI htmldoc2_get_designMode(IHTMLDocument2 *iface, BSTR *p)
 493 {
 494     ok(0, "unexpected call\n");
 495     return E_NOTIMPL;
 496 }
 497
 498 static HRESULT WINAPI htmldoc2_get_selection(IHTMLDocument2 *iface, IHTMLSelectionObject **p)
 499 {
 500     ok(0, "unexpected call\n");
 501     return E_NOTIMPL;
 502 }
 503
 504 static HRESULT WINAPI htmldoc2_get_readyState(IHTMLDocument2 *iface, BSTR *p)
 505 {
 506     ok(0, "unexpected call\n");
 507     return E_NOTIMPL;
 508 }
 509
 510 static HRESULT WINAPI htmldoc2_get_frames(IHTMLDocument2 *iface, IHTMLFramesCollection2 **p)
 511 {
 512     ok(0, "unexpected call\n");
 513     return E_NOTIMPL;
 514 }
 515
 516 static HRESULT WINAPI htmldoc2_get_embeds(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 517 {
 518     ok(0, "unexpected call\n");
 519     return E_NOTIMPL;
 520 }
 521
 522 static HRESULT WINAPI htmldoc2_get_plugins(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 523 {
 524     ok(0, "unexpected call\n");
 525     return E_NOTIMPL;
 526 }
 527
 528 static HRESULT WINAPI htmldoc2_put_alinkColor(IHTMLDocument2 *iface, VARIANT v)
 529 {
 530     ok(0, "unexpected call\n");
 531     return E_NOTIMPL;
 532 }
 533
 534 static HRESULT WINAPI htmldoc2_get_alinkColor(IHTMLDocument2 *iface, VARIANT *p)
 535 {
 536     ok(0, "unexpected call\n");
 537     return E_NOTIMPL;
 538 }
 539
 540 static HRESULT WINAPI htmldoc2_put_bgColor(IHTMLDocument2 *iface, VARIANT v)
 541 {
 542     ok(0, "unexpected call\n");
 543     return E_NOTIMPL;
 544 }
 545
 546 static HRESULT WINAPI htmldoc2_get_bgColor(IHTMLDocument2 *iface, VARIANT *p)
 547 {
 548     ok(0, "unexpected call\n");
 549     return E_NOTIMPL;
 550 }
 551
 552 static HRESULT WINAPI htmldoc2_put_fgColor(IHTMLDocument2 *iface, VARIANT v)
 553 {
 554     ok(0, "unexpected call\n");
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI htmldoc2_get_fgColor(IHTMLDocument2 *iface, VARIANT *p)
 559 {
 560     ok(0, "unexpected call\n");
 561     return E_NOTIMPL;
 562 }
 563
 564 static HRESULT WINAPI htmldoc2_put_linkColor(IHTMLDocument2 *iface, VARIANT v)
 565 {
 566     ok(0, "unexpected call\n");
 567     return E_NOTIMPL;
 568 }
 569
 570 static HRESULT WINAPI htmldoc2_get_linkColor(IHTMLDocument2 *iface, VARIANT *p)
 571 {
 572     ok(0, "unexpected call\n");
 573     return E_NOTIMPL;
 574 }
 575
 576 static HRESULT WINAPI htmldoc2_put_vlinkColor(IHTMLDocument2 *iface, VARIANT v)
 577 {
 578     ok(0, "unexpected call\n");
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI htmldoc2_get_vlinkColor(IHTMLDocument2 *iface, VARIANT *p)
 583 {
 584     ok(0, "unexpected call\n");
 585     return E_NOTIMPL;
 586 }
 587
 588 static HRESULT WINAPI htmldoc2_get_referrer(IHTMLDocument2 *iface, BSTR *p)
 589 {
 590     ok(0, "unexpected call\n");
 591     return E_NOTIMPL;
 592 }
 593
 594 static HRESULT WINAPI htmldoc2_get_location(IHTMLDocument2 *iface, IHTMLLocation **p)
 595 {
 596     ok(0, "unexpected call\n");
 597     return E_NOTIMPL;
 598 }
 599
 600 static HRESULT WINAPI htmldoc2_get_lastModified(IHTMLDocument2 *iface, BSTR *p)
 601 {
 602     ok(0, "unexpected call\n");
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI htmldoc2_put_URL(IHTMLDocument2 *iface, BSTR v)
 607 {
 608     ok(0, "unexpected call\n");
 609     return E_NOTIMPL;
 610 }
 611
 612 static HRESULT WINAPI htmldoc2_get_URL(IHTMLDocument2 *iface, BSTR *p)
 613 {
 614     CHECK_EXPECT2(htmldoc2_get_url);
 615     *p = SysAllocString(NULL);
 616     return S_OK;
 617 }
 618
 619 static HRESULT WINAPI htmldoc2_put_domain(IHTMLDocument2 *iface, BSTR v)
 620 {
 621     ok(0, "unexpected call\n");
 622     return E_NOTIMPL;
 623 }
 624
 625 static HRESULT WINAPI htmldoc2_get_domain(IHTMLDocument2 *iface, BSTR *p)
 626 {
 627     ok(0, "unexpected call\n");
 628     return E_NOTIMPL;
 629 }
 630
 631 static HRESULT WINAPI htmldoc2_put_cookie(IHTMLDocument2 *iface, BSTR v)
 632 {
 633     ok(0, "unexpected call\n");
 634     return E_NOTIMPL;
 635 }
 636
 637 static HRESULT WINAPI htmldoc2_get_cookie(IHTMLDocument2 *iface, BSTR *p)
 638 {
 639     ok(0, "unexpected call\n");
 640     return E_NOTIMPL;
 641 }
 642
 643 static HRESULT WINAPI htmldoc2_put_expando(IHTMLDocument2 *iface, VARIANT_BOOL v)
 644 {
 645     ok(0, "unexpected call\n");
 646     return E_NOTIMPL;
 647 }
 648
 649 static HRESULT WINAPI htmldoc2_get_expando(IHTMLDocument2 *iface, VARIANT_BOOL *p)
 650 {
 651     ok(0, "unexpected call\n");
 652     return E_NOTIMPL;
 653 }
 654
 655 static HRESULT WINAPI htmldoc2_put_charset(IHTMLDocument2 *iface, BSTR v)
 656 {
 657     ok(0, "unexpected call\n");
 658     return E_NOTIMPL;
 659 }
 660
 661 static HRESULT WINAPI htmldoc2_get_charset(IHTMLDocument2 *iface, BSTR *p)
 662 {
 663     ok(0, "unexpected call\n");
 664     return E_NOTIMPL;
 665 }
 666
 667 static HRESULT WINAPI htmldoc2_put_defaultCharset(IHTMLDocument2 *iface, BSTR v)
 668 {
 669     ok(0, "unexpected call\n");
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI htmldoc2_get_defaultCharset(IHTMLDocument2 *iface, BSTR *p)
 674 {
 675     ok(0, "unexpected call\n");
 676     return E_NOTIMPL;
 677 }
 678
 679 static HRESULT WINAPI htmldoc2_get_mimeType(IHTMLDocument2 *iface, BSTR *p)
 680 {
 681     ok(0, "unexpected call\n");
 682     return E_NOTIMPL;
 683 }
 684
 685 static HRESULT WINAPI htmldoc2_get_fileSize(IHTMLDocument2 *iface, BSTR *p)
 686 {
 687     ok(0, "unexpected call\n");
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT WINAPI htmldoc2_get_fileCreatedDate(IHTMLDocument2 *iface, BSTR *p)
 692 {
 693     ok(0, "unexpected call\n");
 694     return E_NOTIMPL;
 695 }
 696
 697 static HRESULT WINAPI htmldoc2_get_fileModifiedDate(IHTMLDocument2 *iface, BSTR *p)
 698 {
 699     ok(0, "unexpected call\n");
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI htmldoc2_get_fileUpdatedDate(IHTMLDocument2 *iface, BSTR *p)
 704 {
 705     ok(0, "unexpected call\n");
 706     return E_NOTIMPL;
 707 }
 708
 709 static HRESULT WINAPI htmldoc2_get_security(IHTMLDocument2 *iface, BSTR *p)
 710 {
 711     ok(0, "unexpected call\n");
 712     return E_NOTIMPL;
 713 }
 714
 715 static HRESULT WINAPI htmldoc2_get_protocol(IHTMLDocument2 *iface, BSTR *p)
 716 {
 717     ok(0, "unexpected call\n");
 718     return E_NOTIMPL;
 719 }
 720
 721 static HRESULT WINAPI htmldoc2_get_nameProp(IHTMLDocument2 *iface, BSTR *p)
 722 {
 723     ok(0, "unexpected call\n");
 724     return E_NOTIMPL;
 725 }
 726
 727 static HRESULT WINAPI htmldoc2_write(IHTMLDocument2 *iface, SAFEARRAY *psarray)
 728 {
 729     ok(0, "unexpected call\n");
 730     return E_NOTIMPL;
 731 }
 732
 733 static HRESULT WINAPI htmldoc2_writeln(IHTMLDocument2 *iface, SAFEARRAY *psarray)
 734 {
 735     ok(0, "unexpected call\n");
 736     return E_NOTIMPL;
 737 }
 738
 739 static HRESULT WINAPI htmldoc2_open(IHTMLDocument2 *iface, BSTR url, VARIANT name,
 740                         VARIANT features, VARIANT replace, IDispatch **pomWindowResult)
 741 {
 742     ok(0, "unexpected call\n");
 743     return E_NOTIMPL;
 744 }
 745
 746 static HRESULT WINAPI htmldoc2_close(IHTMLDocument2 *iface)
 747 {
 748     ok(0, "unexpected call\n");
 749     return E_NOTIMPL;
 750 }
 751
 752 static HRESULT WINAPI htmldoc2_clear(IHTMLDocument2 *iface)
 753 {
 754     ok(0, "unexpected call\n");
 755     return E_NOTIMPL;
 756 }
 757
 758 static HRESULT WINAPI htmldoc2_queryCommandSupported(IHTMLDocument2 *iface, BSTR cmdID,
 759                                                         VARIANT_BOOL *pfRet)
 760 {
 761     ok(0, "unexpected call\n");
 762     return E_NOTIMPL;
 763 }
 764
 765 static HRESULT WINAPI htmldoc2_queryCommandEnabled(IHTMLDocument2 *iface, BSTR cmdID,
 766                                                         VARIANT_BOOL *pfRet)
 767 {
 768     ok(0, "unexpected call\n");
 769     return E_NOTIMPL;
 770 }
 771
 772 static HRESULT WINAPI htmldoc2_queryCommandState(IHTMLDocument2 *iface, BSTR cmdID,
 773                                                         VARIANT_BOOL *pfRet)
 774 {
 775     ok(0, "unexpected call\n");
 776     return E_NOTIMPL;
 777 }
 778
 779 static HRESULT WINAPI htmldoc2_queryCommandIndeterm(IHTMLDocument2 *iface, BSTR cmdID,
 780                                                         VARIANT_BOOL *pfRet)
 781 {
 782     ok(0, "unexpected call\n");
 783     return E_NOTIMPL;
 784 }
 785
 786 static HRESULT WINAPI htmldoc2_queryCommandText(IHTMLDocument2 *iface, BSTR cmdID,
 787                                                         BSTR *pfRet)
 788 {
 789     ok(0, "unexpected call\n");
 790     return E_NOTIMPL;
 791 }
 792
 793 static HRESULT WINAPI htmldoc2_queryCommandValue(IHTMLDocument2 *iface, BSTR cmdID,
 794                                                         VARIANT *pfRet)
 795 {
 796     ok(0, "unexpected call\n");
 797     return E_NOTIMPL;
 798 }
 799
 800 static HRESULT WINAPI htmldoc2_execCommand(IHTMLDocument2 *iface, BSTR cmdID,
 801                                 VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
 802 {
 803     ok(0, "unexpected call\n");
 804     return E_NOTIMPL;
 805 }
 806
 807 static HRESULT WINAPI htmldoc2_execCommandShowHelp(IHTMLDocument2 *iface, BSTR cmdID,
 808                                                         VARIANT_BOOL *pfRet)
 809 {
 810     ok(0, "unexpected call\n");
 811     return E_NOTIMPL;
 812 }
 813
 814 static HRESULT WINAPI htmldoc2_createElement(IHTMLDocument2 *iface, BSTR eTag,
 815                                                  IHTMLElement **newElem)
 816 {
 817     ok(0, "unexpected call\n");
 818     return E_NOTIMPL;
 819 }
 820
 821 static HRESULT WINAPI htmldoc2_put_onhelp(IHTMLDocument2 *iface, VARIANT v)
 822 {
 823     ok(0, "unexpected call\n");
 824     return E_NOTIMPL;
 825 }
 826
 827 static HRESULT WINAPI htmldoc2_get_onhelp(IHTMLDocument2 *iface, VARIANT *p)
 828 {
 829     ok(0, "unexpected call\n");
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI htmldoc2_put_onclick(IHTMLDocument2 *iface, VARIANT v)
 834 {
 835     ok(0, "unexpected call\n");
 836     return E_NOTIMPL;
 837 }
 838
 839 static HRESULT WINAPI htmldoc2_get_onclick(IHTMLDocument2 *iface, VARIANT *p)
 840 {
 841     ok(0, "unexpected call\n");
 842     return E_NOTIMPL;
 843 }
 844
 845 static HRESULT WINAPI htmldoc2_put_ondblclick(IHTMLDocument2 *iface, VARIANT v)
 846 {
 847     ok(0, "unexpected call\n");
 848     return E_NOTIMPL;
 849 }
 850
 851 static HRESULT WINAPI htmldoc2_get_ondblclick(IHTMLDocument2 *iface, VARIANT *p)
 852 {
 853     ok(0, "unexpected call\n");
 854     return E_NOTIMPL;
 855 }
 856
 857 static HRESULT WINAPI htmldoc2_put_onkeyup(IHTMLDocument2 *iface, VARIANT v)
 858 {
 859     ok(0, "unexpected call\n");
 860     return E_NOTIMPL;
 861 }
 862
 863 static HRESULT WINAPI htmldoc2_get_onkeyup(IHTMLDocument2 *iface, VARIANT *p)
 864 {
 865     ok(0, "unexpected call\n");
 866     return E_NOTIMPL;
 867 }
 868
 869 static HRESULT WINAPI htmldoc2_put_onkeydown(IHTMLDocument2 *iface, VARIANT v)
 870 {
 871     ok(0, "unexpected call\n");
 872     return E_NOTIMPL;
 873 }
 874
 875 static HRESULT WINAPI htmldoc2_get_onkeydown(IHTMLDocument2 *iface, VARIANT *p)
 876 {
 877     ok(0, "unexpected call\n");
 878     return E_NOTIMPL;
 879 }
 880
 881 static HRESULT WINAPI htmldoc2_put_onkeypress(IHTMLDocument2 *iface, VARIANT v)
 882 {
 883     ok(0, "unexpected call\n");
 884     return E_NOTIMPL;
 885 }
 886
 887 static HRESULT WINAPI htmldoc2_get_onkeypress(IHTMLDocument2 *iface, VARIANT *p)
 888 {
 889     ok(0, "unexpected call\n");
 890     return E_NOTIMPL;
 891 }
 892
 893 static HRESULT WINAPI htmldoc2_put_onmouseup(IHTMLDocument2 *iface, VARIANT v)
 894 {
 895     ok(0, "unexpected call\n");
 896     return E_NOTIMPL;
 897 }
 898
 899 static HRESULT WINAPI htmldoc2_get_onmouseup(IHTMLDocument2 *iface, VARIANT *p)
 900 {
 901     ok(0, "unexpected call\n");
 902     return E_NOTIMPL;
 903 }
 904
 905 static HRESULT WINAPI htmldoc2_put_onmousedown(IHTMLDocument2 *iface, VARIANT v)
 906 {
 907     ok(0, "unexpected call\n");
 908     return E_NOTIMPL;
 909 }
 910
 911 static HRESULT WINAPI htmldoc2_get_onmousedown(IHTMLDocument2 *iface, VARIANT *p)
 912 {
 913     ok(0, "unexpected call\n");
 914     return E_NOTIMPL;
 915 }
 916
 917 static HRESULT WINAPI htmldoc2_put_onmousemove(IHTMLDocument2 *iface, VARIANT v)
 918 {
 919     ok(0, "unexpected call\n");
 920     return E_NOTIMPL;
 921 }
 922
 923 static HRESULT WINAPI htmldoc2_get_onmousemove(IHTMLDocument2 *iface, VARIANT *p)
 924 {
 925     ok(0, "unexpected call\n");
 926     return E_NOTIMPL;
 927 }
 928
 929 static HRESULT WINAPI htmldoc2_put_onmouseout(IHTMLDocument2 *iface, VARIANT v)
 930 {
 931     ok(0, "unexpected call\n");
 932     return E_NOTIMPL;
 933 }
 934
 935 static HRESULT WINAPI htmldoc2_get_onmouseout(IHTMLDocument2 *iface, VARIANT *p)
 936 {
 937     ok(0, "unexpected call\n");
 938     return E_NOTIMPL;
 939 }
 940
 941 static HRESULT WINAPI htmldoc2_put_onmouseover(IHTMLDocument2 *iface, VARIANT v)
 942 {
 943     ok(0, "unexpected call\n");
 944     return E_NOTIMPL;
 945 }
 946
 947 static HRESULT WINAPI htmldoc2_get_onmouseover(IHTMLDocument2 *iface, VARIANT *p)
 948 {
 949     ok(0, "unexpected call\n");
 950     return E_NOTIMPL;
 951 }
 952
 953 static HRESULT WINAPI htmldoc2_put_onreadystatechange(IHTMLDocument2 *iface, VARIANT v)
 954 {
 955     ok(0, "unexpected call\n");
 956     return E_NOTIMPL;
 957 }
 958
 959 static HRESULT WINAPI htmldoc2_get_onreadystatechange(IHTMLDocument2 *iface, VARIANT *p)
 960 {
 961     ok(0, "unexpected call\n");
 962     return E_NOTIMPL;
 963 }
 964
 965 static HRESULT WINAPI htmldoc2_put_onafterupdate(IHTMLDocument2 *iface, VARIANT v)
 966 {
 967     ok(0, "unexpected call\n");
 968     return E_NOTIMPL;
 969 }
 970
 971 static HRESULT WINAPI htmldoc2_get_onafterupdate(IHTMLDocument2 *iface, VARIANT *p)
 972 {
 973     ok(0, "unexpected call\n");
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI htmldoc2_put_onrowexit(IHTMLDocument2 *iface, VARIANT v)
 978 {
 979     ok(0, "unexpected call\n");
 980     return E_NOTIMPL;
 981 }
 982
 983 static HRESULT WINAPI htmldoc2_get_onrowexit(IHTMLDocument2 *iface, VARIANT *p)
 984 {
 985     ok(0, "unexpected call\n");
 986     return E_NOTIMPL;
 987 }
 988
 989 static HRESULT WINAPI htmldoc2_put_onrowenter(IHTMLDocument2 *iface, VARIANT v)
 990 {
 991     ok(0, "unexpected call\n");
 992     return E_NOTIMPL;
 993 }
 994
 995 static HRESULT WINAPI htmldoc2_get_onrowenter(IHTMLDocument2 *iface, VARIANT *p)
 996 {
 997     ok(0, "unexpected call\n");
 998     return E_NOTIMPL;
 999 }
1000
1001 static HRESULT WINAPI htmldoc2_put_ondragstart(IHTMLDocument2 *iface, VARIANT v)
1002 {
1003     ok(0, "unexpected call\n");
1004     return E_NOTIMPL;
1005 }
1006
1007 static HRESULT WINAPI htmldoc2_get_ondragstart(IHTMLDocument2 *iface, VARIANT *p)
1008 {
1009     ok(0, "unexpected call\n");
1010     return E_NOTIMPL;
1011 }
1012
1013 static HRESULT WINAPI htmldoc2_put_onselectstart(IHTMLDocument2 *iface, VARIANT v)
1014 {
1015     ok(0, "unexpected call\n");
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI htmldoc2_get_onselectstart(IHTMLDocument2 *iface, VARIANT *p)
1020 {
1021     ok(0, "unexpected call\n");
1022     return E_NOTIMPL;
1023 }
1024
1025 static HRESULT WINAPI htmldoc2_elementFromPoint(IHTMLDocument2 *iface, LONG x, LONG y,
1026                                                         IHTMLElement **elementHit)
1027 {
1028     ok(0, "unexpected call\n");
1029     return E_NOTIMPL;
1030 }
1031
1032 static HRESULT WINAPI htmldoc2_get_parentWindow(IHTMLDocument2 *iface, IHTMLWindow2 **p)
1033 {
1034     ok(0, "unexpected call\n");
1035     return E_NOTIMPL;
1036 }
1037
1038 static HRESULT WINAPI htmldoc2_get_styleSheets(IHTMLDocument2 *iface,
1039                                                    IHTMLStyleSheetsCollection **p)
1040 {
1041     ok(0, "unexpected call\n");
1042     return E_NOTIMPL;
1043 }
1044
1045 static HRESULT WINAPI htmldoc2_put_onbeforeupdate(IHTMLDocument2 *iface, VARIANT v)
1046 {
1047     ok(0, "unexpected call\n");
1048     return E_NOTIMPL;
1049 }
1050
1051 static HRESULT WINAPI htmldoc2_get_onbeforeupdate(IHTMLDocument2 *iface, VARIANT *p)
1052 {
1053     ok(0, "unexpected call\n");
1054     return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI htmldoc2_put_onerrorupdate(IHTMLDocument2 *iface, VARIANT v)
1058 {
1059     ok(0, "unexpected call\n");
1060     return E_NOTIMPL;
1061 }
1062
1063 static HRESULT WINAPI htmldoc2_get_onerrorupdate(IHTMLDocument2 *iface, VARIANT *p)
1064 {
1065     ok(0, "unexpected call\n");
1066     return E_NOTIMPL;
1067 }
1068
1069 static HRESULT WINAPI htmldoc2_toString(IHTMLDocument2 *iface, BSTR *String)
1070 {
1071     ok(0, "unexpected call\n");
1072     return E_NOTIMPL;
1073 }
1074
1075 static HRESULT WINAPI htmldoc2_createStyleSheet(IHTMLDocument2 *iface, BSTR bstrHref,
1076                                             LONG lIndex, IHTMLStyleSheet **ppnewStyleSheet)
1077 {
1078     ok(0, "unexpected call\n");
1079     return E_NOTIMPL;
1080 }
1081
1082 static const IHTMLDocument2Vtbl TestHTMLDocumentVtbl = {
1083     htmldoc2_QueryInterface,
1084     htmldoc2_AddRef,
1085     htmldoc2_Release,
1086     htmldoc2_GetTypeInfoCount,
1087     htmldoc2_GetTypeInfo,
1088     htmldoc2_GetIDsOfNames,
1089     htmldoc2_Invoke,
1090     htmldoc2_get_Script,
1091     htmldoc2_get_all,
1092     htmldoc2_get_body,
1093     htmldoc2_get_activeElement,
1094     htmldoc2_get_images,
1095     htmldoc2_get_applets,
1096     htmldoc2_get_links,
1097     htmldoc2_get_forms,
1098     htmldoc2_get_anchors,
1099     htmldoc2_put_title,
1100     htmldoc2_get_title,
1101     htmldoc2_get_scripts,
1102     htmldoc2_put_designMode,
1103     htmldoc2_get_designMode,
1104     htmldoc2_get_selection,
1105     htmldoc2_get_readyState,
1106     htmldoc2_get_frames,
1107     htmldoc2_get_embeds,
1108     htmldoc2_get_plugins,
1109     htmldoc2_put_alinkColor,
1110     htmldoc2_get_alinkColor,
1111     htmldoc2_put_bgColor,
1112     htmldoc2_get_bgColor,
1113     htmldoc2_put_fgColor,
1114     htmldoc2_get_fgColor,
1115     htmldoc2_put_linkColor,
1116     htmldoc2_get_linkColor,
1117     htmldoc2_put_vlinkColor,
1118     htmldoc2_get_vlinkColor,
1119     htmldoc2_get_referrer,
1120     htmldoc2_get_location,
1121     htmldoc2_get_lastModified,
1122     htmldoc2_put_URL,
1123     htmldoc2_get_URL,
1124     htmldoc2_put_domain,
1125     htmldoc2_get_domain,
1126     htmldoc2_put_cookie,
1127     htmldoc2_get_cookie,
1128     htmldoc2_put_expando,
1129     htmldoc2_get_expando,
1130     htmldoc2_put_charset,
1131     htmldoc2_get_charset,
1132     htmldoc2_put_defaultCharset,
1133     htmldoc2_get_defaultCharset,
1134     htmldoc2_get_mimeType,
1135     htmldoc2_get_fileSize,
1136     htmldoc2_get_fileCreatedDate,
1137     htmldoc2_get_fileModifiedDate,
1138     htmldoc2_get_fileUpdatedDate,
1139     htmldoc2_get_security,
1140     htmldoc2_get_protocol,
1141     htmldoc2_get_nameProp,
1142     htmldoc2_write,
1143     htmldoc2_writeln,
1144     htmldoc2_open,
1145     htmldoc2_close,
1146     htmldoc2_clear,
1147     htmldoc2_queryCommandSupported,
1148     htmldoc2_queryCommandEnabled,
1149     htmldoc2_queryCommandState,
1150     htmldoc2_queryCommandIndeterm,
1151     htmldoc2_queryCommandText,
1152     htmldoc2_queryCommandValue,
1153     htmldoc2_execCommand,
1154     htmldoc2_execCommandShowHelp,
1155     htmldoc2_createElement,
1156     htmldoc2_put_onhelp,
1157     htmldoc2_get_onhelp,
1158     htmldoc2_put_onclick,
1159     htmldoc2_get_onclick,
1160     htmldoc2_put_ondblclick,
1161     htmldoc2_get_ondblclick,
1162     htmldoc2_put_onkeyup,
1163     htmldoc2_get_onkeyup,
1164     htmldoc2_put_onkeydown,
1165     htmldoc2_get_onkeydown,
1166     htmldoc2_put_onkeypress,
1167     htmldoc2_get_onkeypress,
1168     htmldoc2_put_onmouseup,
1169     htmldoc2_get_onmouseup,
1170     htmldoc2_put_onmousedown,
1171     htmldoc2_get_onmousedown,
1172     htmldoc2_put_onmousemove,
1173     htmldoc2_get_onmousemove,
1174     htmldoc2_put_onmouseout,
1175     htmldoc2_get_onmouseout,
1176     htmldoc2_put_onmouseover,
1177     htmldoc2_get_onmouseover,
1178     htmldoc2_put_onreadystatechange,
1179     htmldoc2_get_onreadystatechange,
1180     htmldoc2_put_onafterupdate,
1181     htmldoc2_get_onafterupdate,
1182     htmldoc2_put_onrowexit,
1183     htmldoc2_get_onrowexit,
1184     htmldoc2_put_onrowenter,
1185     htmldoc2_get_onrowenter,
1186     htmldoc2_put_ondragstart,
1187     htmldoc2_get_ondragstart,
1188     htmldoc2_put_onselectstart,
1189     htmldoc2_get_onselectstart,
1190     htmldoc2_elementFromPoint,
1191     htmldoc2_get_parentWindow,
1192     htmldoc2_get_styleSheets,
1193     htmldoc2_put_onbeforeupdate,
1194     htmldoc2_get_onbeforeupdate,
1195     htmldoc2_put_onerrorupdate,
1196     htmldoc2_get_onerrorupdate,
1197     htmldoc2_toString,
1198     htmldoc2_createStyleSheet
1199 };
1200
1201 typedef struct
1202 {
1203     IHTMLDocument2 IHTMLDocument2_iface;
1204 } testhtmldoc2_t;
1205
1206 static testhtmldoc2_t htmldoc2 = { { &TestHTMLDocumentVtbl } };
1207
1208 static HRESULT WINAPI sp_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppvObject)
1209 {
1210     *ppvObject = NULL;
1211
1212     if (IsEqualGUID(riid, &IID_IUnknown) ||
1213         IsEqualGUID(riid, &IID_IServiceProvider))
1214     {
1215         *ppvObject = iface;
1216         IServiceProvider_AddRef(iface);
1217         return S_OK;
1218     }
1219
1220     ok(0, "unexpected query interface: %s\n", debugstr_guid(riid));
1221
1222     return E_NOINTERFACE;
1223 }
1224
1225 static ULONG WINAPI sp_AddRef(IServiceProvider *iface)
1226 {
1227     return 2;
1228 }
1229
1230 static ULONG WINAPI sp_Release(IServiceProvider *iface)
1231 {
1232     return 1;
1233 }
1234
1235 static HRESULT WINAPI sp_QueryService(IServiceProvider *iface, REFGUID service, REFIID riid, void **obj)
1236 {
1237     *obj = NULL;
1238
1239     if (IsEqualGUID(service, &SID_SBindHost) &&
1240         IsEqualGUID(riid, &IID_IBindHost))
1241     {
1242         CHECK_EXPECT2(sp_queryservice_SID_SBindHost);
1243     }
1244     else if (IsEqualGUID(service, &SID_SContainerDispatch) &&
1245              IsEqualGUID(riid, &IID_IHTMLDocument2))
1246     {
1247         CHECK_EXPECT2(sp_queryservice_SID_SContainerDispatch_htmldoc2);
1248     }
1249     else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&
1250              IsEqualGUID(riid, &IID_IHTMLDocument2))
1251     {
1252         CHECK_EXPECT2(sp_queryservice_SID_secmgr_htmldoc2);
1253         *obj = &htmldoc2.IHTMLDocument2_iface;
1254         return S_OK;
1255     }
1256     else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&
1257              IsEqualGUID(riid, &IID_IXMLDOMDocument))
1258     {
1259         CHECK_EXPECT2(sp_queryservice_SID_secmgr_xmldomdoc);
1260     }
1261     else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&
1262              IsEqualGUID(riid, &IID_IInternetHostSecurityManager))
1263     {
1264         CHECK_EXPECT2(sp_queryservice_SID_secmgr_secmgr);
1265     }
1266     else if (IsEqualGUID(service, &SID_UnknownSID) &&
1267              IsEqualGUID(riid, &IID_IStream))
1268     {
1269         /* FIXME: unidentified service id */
1270     }
1271     else
1272         ok(0, "unexpected request: sid %s, riid %s\n", debugstr_guid(service), debugstr_guid(riid));
1273
1274     return E_NOTIMPL;
1275 }
1276
1277 static const IServiceProviderVtbl testprovVtbl =
1278 {
1279     sp_QueryInterface,
1280     sp_AddRef,
1281     sp_Release,
1282     sp_QueryService
1283 };
1284
1285 testprov_t testprov = { { &testprovVtbl } };
1286
1287 #define EXPECT_CHILDREN(node) _expect_children((IXMLDOMNode*)node, __LINE__)
1288 static void _expect_children(IXMLDOMNode *node, int line)
1289 {
1290     VARIANT_BOOL b;
1291     HRESULT hr;
1292
1293     b = VARIANT_FALSE;
1294     hr = IXMLDOMNode_hasChildNodes(node, &b);
1295     ok_(__FILE__,line)(hr == S_OK, "hasChildNodes() failed, 0x%08x\n", hr);
1296     ok_(__FILE__,line)(b == VARIANT_TRUE, "no children, %d\n", b);
1297 }
1298
1299 #define EXPECT_NO_CHILDREN(node) _expect_no_children((IXMLDOMNode*)node, __LINE__)
1300 static void _expect_no_children(IXMLDOMNode *node, int line)
1301 {
1302     VARIANT_BOOL b;
1303     HRESULT hr;
1304
1305     b = VARIANT_TRUE;
1306     hr = IXMLDOMNode_hasChildNodes(node, &b);
1307     ok_(__FILE__,line)(hr == S_FALSE, "hasChildNodes() failed, 0x%08x\n", hr);
1308     ok_(__FILE__,line)(b == VARIANT_FALSE, "no children, %d\n", b);
1309 }
1310
1311 #define EXPECT_REF(node,ref) _expect_ref((IUnknown*)node, ref, __LINE__)
1312 static void _expect_ref(IUnknown* obj, ULONG ref, int line)
1313 {
1314     ULONG rc = IUnknown_AddRef(obj);
1315     IUnknown_Release(obj);
1316     ok_(__FILE__,line)(rc-1 == ref, "expected refcount %d, got %d\n", ref, rc-1);
1317 }
1318
1319 #define EXPECT_LIST_LEN(list,len) _expect_list_len(list, len, __LINE__)
1320 static void _expect_list_len(IXMLDOMNodeList *list, LONG len, int line)
1321 {
1322     LONG length;
1323     HRESULT hr;
1324
1325     length = 0;
1326     hr = IXMLDOMNodeList_get_length(list, &length);
1327     ok_(__FILE__,line)(hr == S_OK, "got 0x%08x\n", hr);
1328     ok_(__FILE__,line)(length == len, "got %d, expected %d\n", length, len);
1329 }
1330
1331 #define EXPECT_HR(hr,hr_exp) \
1332     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
1333
1334 static const WCHAR szEmpty[] = { 0 };
1335 static const WCHAR szIncomplete[] = {
1336     '<','?','x','m','l',' ',
1337     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
1338 };
1339 static const WCHAR szComplete1[] = {
1340     '<','?','x','m','l',' ',
1341     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
1342     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
1343 };
1344 static const WCHAR szComplete2[] = {
1345     '<','?','x','m','l',' ',
1346     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
1347     '<','o','>','<','/','o','>','\n',0
1348 };
1349 static const WCHAR szComplete3[] = {
1350     '<','?','x','m','l',' ',
1351     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
1352     '<','a','>','<','/','a','>','\n',0
1353 };
1354 static const char complete4A[] =
1355     "<?xml version=\'1.0\'?>\n"
1356     "<lc dl=\'str1\'>\n"
1357         "<bs vr=\'str2\' sz=\'1234\'>"
1358             "fn1.txt\n"
1359         "</bs>\n"
1360         "<pr id=\'str3\' vr=\'1.2.3\' pn=\'wine 20050804\'>\n"
1361             "fn2.txt\n"
1362         "</pr>\n"
1363         "<empty></empty>\n"
1364         "<fo>\n"
1365             "<ba>\n"
1366                 "f1\n"
1367             "</ba>\n"
1368         "</fo>\n"
1369     "</lc>\n";
1370
1371 static const WCHAR szComplete5[] = {
1372     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
1373     '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','"',
1374     ' ','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','"','>',
1375         '<','S',':','s','c','o','p','e','>',
1376             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
1377         '<','/','S',':','s','c','o','p','e','>',
1378         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
1379             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
1380             'c','o','m','p','u','t','e','r',
1381         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
1382     '<','/','S',':','s','e','a','r','c','h','>',0
1383 };
1384
1385 static const WCHAR szComplete6[] = {
1386     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'',' ',
1387     'e','n','c','o','d','i','n','g','=','\'','W','i','n','d','o','w','s','-','1','2','5','2','\'','?','>','\n',
1388     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
1389 };
1390
1391 static const CHAR szNonUnicodeXML[] =
1392 "<?xml version='1.0' encoding='Windows-1252'?>\n"
1393 "<open></open>\n";
1394
1395 static const char szExampleXML[] =
1396 "<?xml version='1.0' encoding='utf-8'?>\n"
1397 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' a=\"attr a\" foo:b=\"attr b\" >\n"
1398 "    <elem>\n"
1399 "        <a>A1 field</a>\n"
1400 "        <b>B1 field</b>\n"
1401 "        <c>C1 field</c>\n"
1402 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
1403 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
1404 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
1405 "            </html>\n"
1406 "            <html xml:space='preserve' xmlns='http://www.w3.org/1999/xhtml'>\n"
1407 "                This is <strong>a</strong> <i>description</i> with preserved whitespace. <bar:x/>\n"
1408 "            </html>\n"
1409 "        </description>\n"
1410 "    </elem>\n"
1411 "\n"
1412 "    <elem>\n"
1413 "        <a>A2 field</a>\n"
1414 "        <b>B2 field</b>\n"
1415 "        <c type=\"old\">C2 field</c>\n"
1416 "    </elem>\n"
1417 "\n"
1418 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
1419 "        <a>A3 field</a>\n"
1420 "        <b>B3 field</b>\n"
1421 "        <c>C3 field</c>\n"
1422 "    </elem>\n"
1423 "\n"
1424 "    <elem>\n"
1425 "        <a>A4 field</a>\n"
1426 "        <b>B4 field</b>\n"
1427 "        <foo:c>C4 field</foo:c>\n"
1428 "    </elem>\n"
1429 "</root>\n";
1430
1431 static const CHAR szNodeTypesXML[] =
1432 "<?xml version='1.0'?>"
1433 "<!-- comment node 0 -->"
1434 "<root id='0' depth='0'>"
1435 "   <!-- comment node 1 -->"
1436 "   text node 0"
1437 "   <x id='1' depth='1'>"
1438 "       <?foo value='PI for x'?>"
1439 "       <!-- comment node 2 -->"
1440 "       text node 1"
1441 "       <a id='3' depth='2'/>"
1442 "       <b id='4' depth='2'/>"
1443 "       <c id='5' depth='2'/>"
1444 "   </x>"
1445 "   <y id='2' depth='1'>"
1446 "       <?bar value='PI for y'?>"
1447 "       <!-- comment node 3 -->"
1448 "       text node 2"
1449 "       <a id='6' depth='2'/>"
1450 "       <b id='7' depth='2'/>"
1451 "       <c id='8' depth='2'/>"
1452 "   </y>"
1453 "</root>";
1454
1455 static const CHAR szTransformXML[] =
1456 "<?xml version=\"1.0\"?>\n"
1457 "<greeting>\n"
1458 "Hello World\n"
1459 "</greeting>";
1460
1461 static  const CHAR szTransformSSXML[] =
1462 "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
1463 "   <xsl:output method=\"html\"/>\n"
1464 "   <xsl:template match=\"/\">\n"
1465 "       <xsl:apply-templates select=\"greeting\"/>\n"
1466 "   </xsl:template>\n"
1467 "   <xsl:template match=\"greeting\">\n"
1468 "       <html>\n"
1469 "           <body>\n"
1470 "               <h1>\n"
1471 "                   <xsl:value-of select=\".\"/>\n"
1472 "               </h1>\n"
1473 "           </body>\n"
1474 "       </html>\n"
1475 "   </xsl:template>\n"
1476 "</xsl:stylesheet>";
1477
1478 static  const CHAR szTransformOutput[] =
1479 "<html><body><h1>"
1480 "Hello World"
1481 "</h1></body></html>";
1482
1483 static const CHAR szTypeValueXML[] =
1484 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
1485 "<root xmlns:dt=\"urn:schemas-microsoft-com:datatypes\">\n"
1486 "   <string>Wine</string>\n"
1487 "   <string2 dt:dt=\"string\">String</string2>\n"
1488 "   <number dt:dt=\"number\">12.44</number>\n"
1489 "   <number2 dt:dt=\"NUMbEr\">-3.71e3</number2>\n"
1490 "   <int dt:dt=\"int\">-13</int>\n"
1491 "   <fixed dt:dt=\"fixed.14.4\">7322.9371</fixed>\n"
1492 "   <bool dt:dt=\"boolean\">1</bool>\n"
1493 "   <datetime dt:dt=\"datetime\">2009-11-18T03:21:33.12</datetime>\n"
1494 "   <datetimetz dt:dt=\"datetime.tz\">2003-07-11T11:13:57+03:00</datetimetz>\n"
1495 "   <date dt:dt=\"date\">3721-11-01</date>\n"
1496 "   <time dt:dt=\"time\">13:57:12.31321</time>\n"
1497 "   <timetz dt:dt=\"time.tz\">23:21:01.13+03:21</timetz>\n"
1498 "   <i1 dt:dt=\"i1\">-13</i1>\n"
1499 "   <i2 dt:dt=\"i2\">31915</i2>\n"
1500 "   <i4 dt:dt=\"i4\">-312232</i4>\n"
1501 "   <ui1 dt:dt=\"ui1\">123</ui1>\n"
1502 "   <ui2 dt:dt=\"ui2\">48282</ui2>\n"
1503 "   <ui4 dt:dt=\"ui4\">949281</ui4>\n"
1504 "   <r4 dt:dt=\"r4\">213124.0</r4>\n"
1505 "   <r8 dt:dt=\"r8\">0.412</r8>\n"
1506 "   <float dt:dt=\"float\">41221.421</float>\n"
1507 "   <uuid dt:dt=\"uuid\">333C7BC4-460F-11D0-BC04-0080C7055a83</uuid>\n"
1508 "   <binhex dt:dt=\"bin.hex\">fffca012003c</binhex>\n"
1509 "   <binbase64 dt:dt=\"bin.base64\">YmFzZTY0IHRlc3Q=</binbase64>\n"
1510 "   <binbase64_1 dt:dt=\"bin.base64\">\nYmFzZTY0\nIHRlc3Q=\n</binbase64_1>\n"
1511 "   <binbase64_2 dt:dt=\"bin.base64\">\nYmF\r\t z  ZTY0\nIHRlc3Q=\n</binbase64_2>\n"
1512 "</root>";
1513
1514 static const CHAR szBasicTransformSSXMLPart1[] =
1515 "<?xml version=\"1.0\"?>"
1516 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
1517 "<xsl:output method=\"html\"/>\n"
1518 "<xsl:template match=\"/\">"
1519 "<HTML><BODY><TABLE>"
1520 "        <xsl:apply-templates select='document(\"";
1521
1522 static const CHAR szBasicTransformSSXMLPart2[] =
1523 "\")/bottle/wine'>"
1524 "           <xsl:sort select=\"cost\"/><xsl:sort select=\"name\"/>"
1525 "        </xsl:apply-templates>"
1526 "</TABLE></BODY></HTML>"
1527 "</xsl:template>"
1528 "<xsl:template match=\"bottle\">"
1529 "   <TR><xsl:apply-templates select=\"name\" /><xsl:apply-templates select=\"cost\" /></TR>"
1530 "</xsl:template>"
1531 "<xsl:template match=\"name\">"
1532 "   <TD><xsl:apply-templates /></TD>"
1533 "</xsl:template>"
1534 "<xsl:template match=\"cost\">"
1535 "   <TD><xsl:apply-templates /></TD>"
1536 "</xsl:template>"
1537 "</xsl:stylesheet>";
1538
1539 static const CHAR szBasicTransformXML[] =
1540 "<?xml version=\"1.0\"?><bottle><wine><name>Wine</name><cost>$25.00</cost></wine></bottle>";
1541
1542 static const CHAR szBasicTransformOutput[] =
1543 "<HTML><BODY><TABLE><TD>Wine</TD><TD>$25.00</TD></TABLE></BODY></HTML>";
1544
1545 #define SZ_EMAIL_DTD \
1546 "<!DOCTYPE email ["\
1547 "   <!ELEMENT email         (recipients,from,reply-to?,subject,body,attachment*)>"\
1548 "       <!ATTLIST email attachments IDREFS #REQUIRED>"\
1549 "       <!ATTLIST email sent (yes|no) \"no\">"\
1550 "   <!ELEMENT recipients    (to+,cc*)>"\
1551 "   <!ELEMENT to            (#PCDATA)>"\
1552 "       <!ATTLIST to name CDATA #IMPLIED>"\
1553 "   <!ELEMENT cc            (#PCDATA)>"\
1554 "       <!ATTLIST cc name CDATA #IMPLIED>"\
1555 "   <!ELEMENT from          (#PCDATA)>"\
1556 "       <!ATTLIST from name CDATA #IMPLIED>"\
1557 "   <!ELEMENT reply-to      (#PCDATA)>"\
1558 "       <!ATTLIST reply-to name CDATA #IMPLIED>"\
1559 "   <!ELEMENT subject       ANY>"\
1560 "   <!ELEMENT body          ANY>"\
1561 "       <!ATTLIST body enc CDATA #FIXED \"UTF-8\">"\
1562 "   <!ELEMENT attachment    (#PCDATA)>"\
1563 "       <!ATTLIST attachment id ID #REQUIRED>"\
1564 "]>"
1565
1566 static const CHAR szEmailXML[] =
1567 "<?xml version=\"1.0\"?>"
1568 SZ_EMAIL_DTD
1569 "<email attachments=\"patch1\">"
1570 "   <recipients>"
1571 "       <to>wine-patches@winehq.org</to>"
1572 "   </recipients>"
1573 "   <from name=\"Anonymous\">user@localhost</from>"
1574 "   <subject>msxml3/tests: DTD validation (try 87)</subject>"
1575 "   <body>"
1576 "       It no longer causes spontaneous combustion..."
1577 "   </body>"
1578 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1579 "</email>";
1580
1581 static const CHAR szEmailXML_0D[] =
1582 "<?xml version=\"1.0\"?>"
1583 SZ_EMAIL_DTD
1584 "<email attachments=\"patch1\">"
1585 "   <recipients>"
1586 "       <to>wine-patches@winehq.org</to>"
1587 "   </recipients>"
1588 "   <from name=\"Anonymous\">user@localhost</from>"
1589 "   <subject>msxml3/tests: DTD validation (try 88)</subject>"
1590 "   <body>"
1591 "       <undecl />"
1592 "       XML_ELEMENT_UNDECLARED 0xC00CE00D"
1593 "   </body>"
1594 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1595 "</email>";
1596
1597 static const CHAR szEmailXML_0E[] =
1598 "<?xml version=\"1.0\"?>"
1599 SZ_EMAIL_DTD
1600 "<email attachments=\"patch1\">"
1601 "   <recipients>"
1602 "       <to>wine-patches@winehq.org</to>"
1603 "   </recipients>"
1604 "   <from name=\"Anonymous\">user@localhost</from>"
1605 "   <subject>msxml3/tests: DTD validation (try 89)</subject>"
1606 "   <body>"
1607 "       XML_ELEMENT_ID_NOT_FOUND 0xC00CE00E"
1608 "   </body>"
1609 "   <attachment id=\"patch\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1610 "</email>";
1611
1612 static const CHAR szEmailXML_11[] =
1613 "<?xml version=\"1.0\"?>"
1614 SZ_EMAIL_DTD
1615 "<email attachments=\"patch1\">"
1616 "   <recipients>"
1617 "   </recipients>"
1618 "   <from name=\"Anonymous\">user@localhost</from>"
1619 "   <subject>msxml3/tests: DTD validation (try 90)</subject>"
1620 "   <body>"
1621 "       XML_EMPTY_NOT_ALLOWED 0xC00CE011"
1622 "   </body>"
1623 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1624 "</email>";
1625
1626 static const CHAR szEmailXML_13[] =
1627 "<?xml version=\"1.0\"?>"
1628 SZ_EMAIL_DTD
1629 "<msg attachments=\"patch1\">"
1630 "   <recipients>"
1631 "       <to>wine-patches@winehq.org</to>"
1632 "   </recipients>"
1633 "   <from name=\"Anonymous\">user@localhost</from>"
1634 "   <subject>msxml3/tests: DTD validation (try 91)</subject>"
1635 "   <body>"
1636 "       XML_ROOT_NAME_MISMATCH 0xC00CE013"
1637 "   </body>"
1638 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1639 "</msg>";
1640
1641 static const CHAR szEmailXML_14[] =
1642 "<?xml version=\"1.0\"?>"
1643 SZ_EMAIL_DTD
1644 "<email attachments=\"patch1\">"
1645 "   <to>wine-patches@winehq.org</to>"
1646 "   <from name=\"Anonymous\">user@localhost</from>"
1647 "   <subject>msxml3/tests: DTD validation (try 92)</subject>"
1648 "   <body>"
1649 "       XML_INVALID_CONTENT 0xC00CE014"
1650 "   </body>"
1651 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1652 "</email>";
1653
1654 static const CHAR szEmailXML_15[] =
1655 "<?xml version=\"1.0\"?>"
1656 SZ_EMAIL_DTD
1657 "<email attachments=\"patch1\" ip=\"127.0.0.1\">"
1658 "   <recipients>"
1659 "       <to>wine-patches@winehq.org</to>"
1660 "   </recipients>"
1661 "   <from name=\"Anonymous\">user@localhost</from>"
1662 "   <subject>msxml3/tests: DTD validation (try 93)</subject>"
1663 "   <body>"
1664 "       XML_ATTRIBUTE_NOT_DEFINED 0xC00CE015"
1665 "   </body>"
1666 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1667 "</email>";
1668
1669 static const CHAR szEmailXML_16[] =
1670 "<?xml version=\"1.0\"?>"
1671 SZ_EMAIL_DTD
1672 "<email attachments=\"patch1\">"
1673 "   <recipients>"
1674 "       <to>wine-patches@winehq.org</to>"
1675 "   </recipients>"
1676 "   <from name=\"Anonymous\">user@localhost</from>"
1677 "   <subject>msxml3/tests: DTD validation (try 94)</subject>"
1678 "   <body enc=\"ASCII\">"
1679 "       XML_ATTRIBUTE_FIXED 0xC00CE016"
1680 "   </body>"
1681 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1682 "</email>";
1683
1684 static const CHAR szEmailXML_17[] =
1685 "<?xml version=\"1.0\"?>"
1686 SZ_EMAIL_DTD
1687 "<email attachments=\"patch1\" sent=\"true\">"
1688 "   <recipients>"
1689 "       <to>wine-patches@winehq.org</to>"
1690 "   </recipients>"
1691 "   <from name=\"Anonymous\">user@localhost</from>"
1692 "   <subject>msxml3/tests: DTD validation (try 95)</subject>"
1693 "   <body>"
1694 "       XML_ATTRIBUTE_VALUE 0xC00CE017"
1695 "   </body>"
1696 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1697 "</email>";
1698
1699 static const CHAR szEmailXML_18[] =
1700 "<?xml version=\"1.0\"?>"
1701 SZ_EMAIL_DTD
1702 "<email attachments=\"patch1\">"
1703 "   oops"
1704 "   <recipients>"
1705 "       <to>wine-patches@winehq.org</to>"
1706 "   </recipients>"
1707 "   <from name=\"Anonymous\">user@localhost</from>"
1708 "   <subject>msxml3/tests: DTD validation (try 96)</subject>"
1709 "   <body>"
1710 "       XML_ILLEGAL_TEXT 0xC00CE018"
1711 "   </body>"
1712 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1713 "</email>";
1714
1715 static const CHAR szEmailXML_20[] =
1716 "<?xml version=\"1.0\"?>"
1717 SZ_EMAIL_DTD
1718 "<email>"
1719 "   <recipients>"
1720 "       <to>wine-patches@winehq.org</to>"
1721 "   </recipients>"
1722 "   <from name=\"Anonymous\">user@localhost</from>"
1723 "   <subject>msxml3/tests: DTD validation (try 97)</subject>"
1724 "   <body>"
1725 "       XML_REQUIRED_ATTRIBUTE_MISSING 0xC00CE020"
1726 "   </body>"
1727 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1728 "</email>";
1729
1730 static const char xpath_simple_list[] =
1731 "<?xml version=\"1.0\"?>"
1732 "<root>"
1733 "   <a attr1=\"1\" attr2=\"2\" />"
1734 "   <b/>"
1735 "   <c/>"
1736 "   <d/>"
1737 "</root>";
1738
1739 static const char* leading_spaces[] = {
1740     "\n<?xml version=\"1.0\"?><root/>",
1741     " <?xml version=\"1.0\"?><root/>",
1742     "\t<?xml version=\"1.0\"?><root/>",
1743     "\r\n<?xml version=\"1.0\"?><root/>",
1744     "\r<?xml version=\"1.0\"?><root/>",
1745     0
1746 };
1747
1748 static const char default_ns_doc[] = {
1749     "<?xml version=\"1.0\"?>"
1750     "<a xmlns:ns=\"nshref\" xml:lang=\"ru\" ns:b=\"b attr\" xml:c=\"c attr\" "
1751     "    d=\"d attr\" />"
1752 };
1753
1754 static const WCHAR nonexistent_fileW[] = {
1755     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
1756 };
1757 static const WCHAR nonexistent_attrW[] = {
1758     'n','o','n','E','x','i','s','i','t','i','n','g','A','t','t','r','i','b','u','t','e',0
1759 };
1760 static const WCHAR szDocument[] = {
1761     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
1762 };
1763
1764 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
1765 static WCHAR szdl[] = { 'd','l',0 };
1766 static const WCHAR szvr[] = { 'v','r',0 };
1767 static const WCHAR szlc[] = { 'l','c',0 };
1768 static WCHAR szbs[] = { 'b','s',0 };
1769 static const WCHAR szstr1[] = { 's','t','r','1',0 };
1770 static const WCHAR szstr2[] = { 's','t','r','2',0 };
1771 static const WCHAR szstar[] = { '*',0 };
1772 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
1773
1774 static WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
1775 static WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
1776 static WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
1777
1778 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
1779 static WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
1780 static WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
1781 static WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
1782                                 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
1783 static WCHAR szElementXML4[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
1784                                 '&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 };
1785
1786 static WCHAR szAttribute[] = {'A','t','t','r',0 };
1787 static WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
1788
1789 static WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
1790                           ' ','n','o','t',' ','r','i','g','h','t','!', 0};
1791 static WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
1792                              'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
1793                              '!',']',']','>',0};
1794 static WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
1795 static WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
1796
1797 static WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
1798 static WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
1799 static WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0};
1800
1801 #define expect_bstr_eq_and_free(bstr, expect) { \
1802     BSTR bstrExp = alloc_str_from_narrow(expect); \
1803     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
1804     SysFreeString(bstr); \
1805     SysFreeString(bstrExp); \
1806 }
1807
1808 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
1809
1810 #define ole_check(expr) { \
1811     HRESULT r = expr; \
1812     ok(r == S_OK, #expr " returned %x\n", r); \
1813 }
1814
1815 #define ole_expect(expr, expect) { \
1816     HRESULT r = expr; \
1817     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
1818 }
1819
1820 #define double_eq(x, y) ok((x)-(y)<=1e-14*(x) && (x)-(y)>=-1e-14*(x), "expected %.16g, got %.16g\n", x, y)
1821
1822 static void* _create_object(const GUID *clsid, const char *name, const IID *iid, int line)
1823 {
1824     void *obj = NULL;
1825     HRESULT hr;
1826
1827     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
1828     if (hr != S_OK)
1829         win_skip_(__FILE__,line)("failed to create %s instance: 0x%08x\n", name, hr);
1830
1831     return obj;
1832 }
1833
1834 #define _create(cls) cls, #cls
1835
1836 #define create_document(iid) _create_object(&_create(CLSID_DOMDocument), iid, __LINE__)
1837 #define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
1838 #define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
1839 #define create_cache_version(v, iid) _create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)
1840 #define create_xsltemplate(iid) _create_object(&_create(CLSID_XSLTemplate), iid, __LINE__)
1841
1842 static BSTR alloc_str_from_narrow(const char *str)
1843 {
1844     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
1845     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
1846     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
1847     return ret;
1848 }
1849
1850 static BSTR alloced_bstrs[256];
1851 static int alloced_bstrs_count;
1852
1853 static BSTR _bstr_(const char *str)
1854 {
1855     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
1856     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
1857     return alloced_bstrs[alloced_bstrs_count++];
1858 }
1859
1860 static void free_bstrs(void)
1861 {
1862     int i;
1863     for (i = 0; i < alloced_bstrs_count; i++)
1864         SysFreeString(alloced_bstrs[i]);
1865     alloced_bstrs_count = 0;
1866 }
1867
1868 static VARIANT _variantbstr_(const char *str)
1869 {
1870     VARIANT v;
1871     V_VT(&v) = VT_BSTR;
1872     V_BSTR(&v) = _bstr_(str);
1873     return v;
1874 }
1875
1876 static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
1877 {
1878     for (;;)
1879     {
1880         while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
1881         while (*sRight == '\r' || *sRight == '\n') sRight++;
1882         if (*sLeft != *sRight) return FALSE;
1883         if (!*sLeft) return TRUE;
1884         sLeft++;
1885         sRight++;
1886     }
1887 }
1888
1889 static void get_str_for_type(DOMNodeType type, char *buf)
1890 {
1891     switch (type)
1892     {
1893         case NODE_ATTRIBUTE:
1894             strcpy(buf, "A");
1895             break;
1896         case NODE_ELEMENT:
1897             strcpy(buf, "E");
1898             break;
1899         case NODE_DOCUMENT:
1900             strcpy(buf, "D");
1901             break;
1902         case NODE_TEXT:
1903             strcpy(buf, "T");
1904             break;
1905         case NODE_COMMENT:
1906             strcpy(buf, "C");
1907             break;
1908         case NODE_PROCESSING_INSTRUCTION:
1909             strcpy(buf, "P");
1910             break;
1911         default:
1912             wsprintfA(buf, "[%d]", type);
1913     }
1914 }
1915
1916 static int get_node_position(IXMLDOMNode *node)
1917 {
1918     HRESULT r;
1919     int pos = 0;
1920
1921     IXMLDOMNode_AddRef(node);
1922     do
1923     {
1924         IXMLDOMNode *new_node;
1925
1926         pos++;
1927         r = IXMLDOMNode_get_previousSibling(node, &new_node);
1928         ok(SUCCEEDED(r), "get_previousSibling failed\n");
1929         IXMLDOMNode_Release(node);
1930         node = new_node;
1931     } while (r == S_OK);
1932     return pos;
1933 }
1934
1935 static void node_to_string(IXMLDOMNode *node, char *buf)
1936 {
1937     HRESULT r = S_OK;
1938     DOMNodeType type;
1939
1940     if (node == NULL)
1941     {
1942         lstrcpyA(buf, "(null)");
1943         return;
1944     }
1945
1946     IXMLDOMNode_AddRef(node);
1947     while (r == S_OK)
1948     {
1949         IXMLDOMNode *new_node;
1950
1951         ole_check(IXMLDOMNode_get_nodeType(node, &type));
1952         get_str_for_type(type, buf);
1953         buf+=strlen(buf);
1954
1955         if (type == NODE_ATTRIBUTE)
1956         {
1957             BSTR bstr;
1958             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
1959             *(buf++) = '\'';
1960             wsprintfA(buf, "%ws", bstr);
1961             buf += strlen(buf);
1962             *(buf++) = '\'';
1963             SysFreeString(bstr);
1964
1965             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
1966         }
1967         else
1968         {
1969             r = IXMLDOMNode_get_parentNode(node, &new_node);
1970             wsprintf(buf, "%d", get_node_position(node));
1971             buf += strlen(buf);
1972         }
1973
1974         ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
1975         IXMLDOMNode_Release(node);
1976         node = new_node;
1977         if (r == S_OK)
1978             *(buf++) = '.';
1979     }
1980
1981     *buf = 0;
1982 }
1983
1984 static char *list_to_string(IXMLDOMNodeList *list)
1985 {
1986     static char buf[4096];
1987     char *pos = buf;
1988     LONG len = 0;
1989     int i;
1990
1991     if (list == NULL)
1992     {
1993         lstrcpyA(buf, "(null)");
1994         return buf;
1995     }
1996     ole_check(IXMLDOMNodeList_get_length(list, &len));
1997     for (i = 0; i < len; i++)
1998     {
1999         IXMLDOMNode *node;
2000         if (i > 0)
2001             *(pos++) = ' ';
2002         ole_check(IXMLDOMNodeList_nextNode(list, &node));
2003         node_to_string(node, pos);
2004         pos += strlen(pos);
2005         IXMLDOMNode_Release(node);
2006     }
2007     *pos = 0;
2008     return buf;
2009 }
2010
2011 #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); }
2012 #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); }
2013
2014 static void test_domdoc( void )
2015 {
2016     HRESULT r, hr;
2017     IXMLDOMDocument *doc;
2018     IXMLDOMParseError *error;
2019     IXMLDOMElement *element = NULL;
2020     IXMLDOMNode *node;
2021     IXMLDOMText *nodetext = NULL;
2022     IXMLDOMComment *node_comment = NULL;
2023     IXMLDOMAttribute *node_attr = NULL;
2024     IXMLDOMNode *nodeChild = NULL;
2025     IXMLDOMProcessingInstruction *nodePI = NULL;
2026     VARIANT_BOOL b;
2027     VARIANT var;
2028     BSTR str;
2029     LONG code, ref;
2030     LONG nLength = 0;
2031     WCHAR buff[100];
2032     const char **ptr;
2033
2034     doc = create_document(&IID_IXMLDOMDocument);
2035     if (!doc) return;
2036
2037 if (0)
2038 {
2039     /* crashes on native */
2040     IXMLDOMDocument_loadXML( doc, (BSTR)0x1, NULL );
2041 }
2042
2043     /* try some stupid things */
2044     hr = IXMLDOMDocument_loadXML( doc, NULL, NULL );
2045     EXPECT_HR(hr, S_FALSE);
2046
2047     b = VARIANT_TRUE;
2048     hr = IXMLDOMDocument_loadXML( doc, NULL, &b );
2049     EXPECT_HR(hr, S_FALSE);
2050     ok( b == VARIANT_FALSE, "failed to load XML string\n");
2051
2052     /* load document with leading spaces */
2053     ptr = leading_spaces;
2054     while (*ptr)
2055     {
2056         b = VARIANT_TRUE;
2057         V_VT(&var) = VT_BSTR;
2058         V_BSTR(&var) = _bstr_(*ptr);
2059         hr = IXMLDOMDocument_load( doc, var, &b);
2060         EXPECT_HR(hr, S_FALSE);
2061         ok( b == VARIANT_FALSE, "got %x\n", b);
2062         ptr++;
2063     }
2064
2065     /* try to load a document from a nonexistent file */
2066     b = VARIANT_TRUE;
2067     str = SysAllocString( nonexistent_fileW );
2068     VariantInit(&var);
2069     V_VT(&var) = VT_BSTR;
2070     V_BSTR(&var) = str;
2071
2072     r = IXMLDOMDocument_load( doc, var, &b);
2073     ok( r == S_FALSE, "loadXML succeeded\n");
2074     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2075     SysFreeString( str );
2076
2077     /* try load an empty document */
2078     b = VARIANT_TRUE;
2079     str = SysAllocString( szEmpty );
2080     r = IXMLDOMDocument_loadXML( doc, str, &b );
2081     ok( r == S_FALSE, "loadXML succeeded\n");
2082     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2083     SysFreeString( str );
2084
2085     r = IXMLDOMDocument_get_async( doc, &b );
2086     ok( r == S_OK, "get_async failed (%08x)\n", r);
2087     ok( b == VARIANT_TRUE, "Wrong default value\n");
2088
2089     /* check that there's no document element */
2090     element = NULL;
2091     r = IXMLDOMDocument_get_documentElement( doc, &element );
2092     ok( r == S_FALSE, "should be no document element\n");
2093
2094     /* try finding a node */
2095     node = NULL;
2096     str = SysAllocString( szstr1 );
2097     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
2098     ok( r == S_FALSE, "ret %08x\n", r );
2099     SysFreeString( str );
2100
2101     b = VARIANT_TRUE;
2102     str = SysAllocString( szIncomplete );
2103     r = IXMLDOMDocument_loadXML( doc, str, &b );
2104     ok( r == S_FALSE, "loadXML succeeded\n");
2105     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2106     SysFreeString( str );
2107
2108     /* check that there's no document element */
2109     element = (IXMLDOMElement*)1;
2110     r = IXMLDOMDocument_get_documentElement( doc, &element );
2111     ok( r == S_FALSE, "should be no document element\n");
2112     ok( element == NULL, "Element should be NULL\n");
2113
2114     /* test for BSTR handling, pass broken BSTR */
2115     memcpy(&buff[2], szComplete1, sizeof(szComplete1));
2116     /* just a big length */
2117     *(DWORD*)buff = 0xf0f0;
2118     b = VARIANT_FALSE;
2119     r = IXMLDOMDocument_loadXML( doc, &buff[2], &b );
2120     ok( r == S_OK, "loadXML failed\n");
2121     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2122
2123     /* loadXML ignores the encoding attribute and always expects Unicode */
2124     b = VARIANT_FALSE;
2125     str = SysAllocString( szComplete6 );
2126     r = IXMLDOMDocument_loadXML( doc, str, &b );
2127     ok( r == S_OK, "loadXML failed\n");
2128     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2129     SysFreeString( str );
2130
2131     /* try a BSTR containing a Windows-1252 document */
2132     b = VARIANT_TRUE;
2133     str = SysAllocStringByteLen( szNonUnicodeXML, sizeof(szNonUnicodeXML) - 1 );
2134     r = IXMLDOMDocument_loadXML( doc, str, &b );
2135     ok( r == S_FALSE, "loadXML succeeded\n");
2136     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2137     SysFreeString( str );
2138
2139     /* try to load something valid */
2140     b = VARIANT_FALSE;
2141     str = SysAllocString( szComplete1 );
2142     r = IXMLDOMDocument_loadXML( doc, str, &b );
2143     ok( r == S_OK, "loadXML failed\n");
2144     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2145     SysFreeString( str );
2146
2147     /* check if nodename is correct */
2148     r = IXMLDOMDocument_get_nodeName( doc, NULL );
2149     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2150
2151     str = (BSTR)0xdeadbeef;
2152     r = IXMLDOMDocument_get_baseName( doc, &str );
2153     ok ( r == S_FALSE, "got 0x%08x\n", r);
2154     ok (str == NULL, "got %p\n", str);
2155
2156     /* content doesn't matter here */
2157     str = NULL;
2158     r = IXMLDOMDocument_get_nodeName( doc, &str );
2159     ok ( r == S_OK, "get_nodeName wrong code\n");
2160     ok ( str != NULL, "str is null\n");
2161     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
2162     SysFreeString( str );
2163
2164     /* test put_text */
2165     r = IXMLDOMDocument_put_text( doc, _bstr_("Should Fail") );
2166     ok( r == E_FAIL, "ret %08x\n", r );
2167
2168     /* check that there's a document element */
2169     element = NULL;
2170     r = IXMLDOMDocument_get_documentElement( doc, &element );
2171     ok( r == S_OK, "should be a document element\n");
2172     if( element )
2173     {
2174         IObjectIdentity *ident;
2175
2176         r = IXMLDOMElement_QueryInterface( element, &IID_IObjectIdentity, (void**)&ident );
2177         ok( r == E_NOINTERFACE, "ret %08x\n", r);
2178
2179         IXMLDOMElement_Release( element );
2180         element = NULL;
2181     }
2182
2183     /* as soon as we call loadXML again, the document element will disappear */
2184     b = 2;
2185     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
2186     ok( r == S_FALSE, "loadXML failed\n");
2187     ok( b == 2, "variant modified\n");
2188     r = IXMLDOMDocument_get_documentElement( doc, &element );
2189     ok( r == S_FALSE, "should be no document element\n");
2190
2191     /* try to load something else simple and valid */
2192     b = VARIANT_FALSE;
2193     str = SysAllocString( szComplete3 );
2194     r = IXMLDOMDocument_loadXML( doc, str, &b );
2195     ok( r == S_OK, "loadXML failed\n");
2196     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2197     SysFreeString( str );
2198
2199     /* try something a little more complicated */
2200     b = FALSE;
2201     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2202     ok( r == S_OK, "loadXML failed\n");
2203     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2204
2205     r = IXMLDOMDocument_get_parseError( doc, &error );
2206     ok( r == S_OK, "returns %08x\n", r );
2207
2208     r = IXMLDOMParseError_get_errorCode( error, &code );
2209     ok( r == S_FALSE, "returns %08x\n", r );
2210     ok( code == 0, "code %d\n", code );
2211     IXMLDOMParseError_Release( error );
2212
2213     /* test createTextNode */
2214     r = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &nodetext);
2215     ok( r == S_OK, "returns %08x\n", r );
2216     IXMLDOMText_Release(nodetext);
2217
2218     str = SysAllocString( szOpen );
2219     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
2220     ok( r == E_INVALIDARG, "returns %08x\n", r );
2221     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
2222     ok( r == S_OK, "returns %08x\n", r );
2223     SysFreeString( str );
2224     if(nodetext)
2225     {
2226         r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (void**)&element);
2227         ok(r == E_NOINTERFACE, "ret %08x\n", r );
2228
2229         /* Text Last Child Checks */
2230         r = IXMLDOMText_get_lastChild(nodetext, NULL);
2231         ok(r == E_INVALIDARG, "ret %08x\n", r );
2232
2233         nodeChild = (IXMLDOMNode*)0x1;
2234         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
2235         ok(r == S_FALSE, "ret %08x\n", r );
2236         ok(nodeChild == NULL, "nodeChild not NULL\n");
2237
2238         /* test length property */
2239         r = IXMLDOMText_get_length(nodetext, NULL);
2240         ok(r == E_INVALIDARG, "ret %08x\n", r );
2241
2242         r = IXMLDOMText_get_length(nodetext, &nLength);
2243         ok(r == S_OK, "ret %08x\n", r );
2244         ok(nLength == 4, "expected 4 got %d\n", nLength);
2245
2246         /* put data Tests */
2247         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
2248         ok(r == S_OK, "ret %08x\n", r );
2249
2250         /* get data Tests */
2251         r = IXMLDOMText_get_data(nodetext, &str);
2252         ok(r == S_OK, "ret %08x\n", r );
2253         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
2254         SysFreeString(str);
2255
2256         /* Confirm XML text is good */
2257         r = IXMLDOMText_get_xml(nodetext, &str);
2258         ok(r == S_OK, "ret %08x\n", r );
2259         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
2260         SysFreeString(str);
2261
2262         /* Confirm we get the put_data Text back */
2263         r = IXMLDOMText_get_text(nodetext, &str);
2264         ok(r == S_OK, "ret %08x\n", r );
2265         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
2266         SysFreeString(str);
2267
2268         /* test substringData */
2269         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
2270         ok(r == E_INVALIDARG, "ret %08x\n", r );
2271
2272         /* test substringData - Invalid offset */
2273         str = (BSTR)&szElement;
2274         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
2275         ok(r == E_INVALIDARG, "ret %08x\n", r );
2276         ok( str == NULL, "incorrect string\n");
2277
2278         /* test substringData - Invalid offset */
2279         str = (BSTR)&szElement;
2280         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
2281         ok(r == S_FALSE, "ret %08x\n", r );
2282         ok( str == NULL, "incorrect string\n");
2283
2284         /* test substringData - Invalid size */
2285         str = (BSTR)&szElement;
2286         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
2287         ok(r == E_INVALIDARG, "ret %08x\n", r );
2288         ok( str == NULL, "incorrect string\n");
2289
2290         /* test substringData - Invalid size */
2291         str = (BSTR)&szElement;
2292         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
2293         ok(r == S_FALSE, "ret %08x\n", r );
2294         ok( str == NULL, "incorrect string\n");
2295
2296         /* test substringData - Start of string */
2297         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
2298         ok(r == S_OK, "ret %08x\n", r );
2299         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
2300         SysFreeString(str);
2301
2302         /* test substringData - Middle of string */
2303         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
2304         ok(r == S_OK, "ret %08x\n", r );
2305         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
2306         SysFreeString(str);
2307
2308         /* test substringData - End of string */
2309         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
2310         ok(r == S_OK, "ret %08x\n", r );
2311         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
2312         SysFreeString(str);
2313
2314         /* test appendData */
2315         r = IXMLDOMText_appendData(nodetext, NULL);
2316         ok(r == S_OK, "ret %08x\n", r );
2317
2318         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
2319         ok(r == S_OK, "ret %08x\n", r );
2320
2321         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
2322         ok(r == S_OK, "ret %08x\n", r );
2323
2324         r = IXMLDOMText_get_text(nodetext, &str);
2325         ok(r == S_OK, "ret %08x\n", r );
2326         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2327         SysFreeString(str);
2328
2329         /* test insertData */
2330         str = SysAllocStringLen(NULL, 0);
2331         r = IXMLDOMText_insertData(nodetext, -1, str);
2332         ok(r == S_OK, "ret %08x\n", r );
2333
2334         r = IXMLDOMText_insertData(nodetext, -1, NULL);
2335         ok(r == S_OK, "ret %08x\n", r );
2336
2337         r = IXMLDOMText_insertData(nodetext, 1000, str);
2338         ok(r == S_OK, "ret %08x\n", r );
2339
2340         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
2341         ok(r == S_OK, "ret %08x\n", r );
2342
2343         r = IXMLDOMText_insertData(nodetext, 0, NULL);
2344         ok(r == S_OK, "ret %08x\n", r );
2345
2346         r = IXMLDOMText_insertData(nodetext, 0, str);
2347         ok(r == S_OK, "ret %08x\n", r );
2348         SysFreeString(str);
2349
2350         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
2351         ok(r == E_INVALIDARG, "ret %08x\n", r );
2352
2353         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
2354         ok(r == E_INVALIDARG, "ret %08x\n", r );
2355
2356         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
2357         ok(r == S_OK, "ret %08x\n", r );
2358
2359         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
2360         ok(r == S_OK, "ret %08x\n", r );
2361
2362         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
2363         ok(r == S_OK, "ret %08x\n", r );
2364
2365         r = IXMLDOMText_get_text(nodetext, &str);
2366         ok(r == S_OK, "ret %08x\n", r );
2367         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2368         SysFreeString(str);
2369
2370         /* delete data */
2371         /* invalid arguments */
2372         r = IXMLDOMText_deleteData(nodetext, -1, 1);
2373         ok(r == E_INVALIDARG, "ret %08x\n", r );
2374
2375         r = IXMLDOMText_deleteData(nodetext, 0, 0);
2376         ok(r == S_OK, "ret %08x\n", r );
2377
2378         r = IXMLDOMText_deleteData(nodetext, 0, -1);
2379         ok(r == E_INVALIDARG, "ret %08x\n", r );
2380
2381         r = IXMLDOMText_get_length(nodetext, &nLength);
2382         ok(r == S_OK, "ret %08x\n", r );
2383         ok(nLength == 43, "expected 43 got %d\n", nLength);
2384
2385         r = IXMLDOMText_deleteData(nodetext, nLength, 1);
2386         ok(r == S_OK, "ret %08x\n", r );
2387
2388         r = IXMLDOMText_deleteData(nodetext, nLength+1, 1);
2389         ok(r == E_INVALIDARG, "ret %08x\n", r );
2390
2391         /* delete from start */
2392         r = IXMLDOMText_deleteData(nodetext, 0, 5);
2393         ok(r == S_OK, "ret %08x\n", r );
2394
2395         r = IXMLDOMText_get_length(nodetext, &nLength);
2396         ok(r == S_OK, "ret %08x\n", r );
2397         ok(nLength == 38, "expected 38 got %d\n", nLength);
2398
2399         r = IXMLDOMText_get_text(nodetext, &str);
2400         ok(r == S_OK, "ret %08x\n", r );
2401         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2402         SysFreeString(str);
2403
2404         /* delete from end */
2405         r = IXMLDOMText_deleteData(nodetext, 35, 3);
2406         ok(r == S_OK, "ret %08x\n", r );
2407
2408         r = IXMLDOMText_get_length(nodetext, &nLength);
2409         ok(r == S_OK, "ret %08x\n", r );
2410         ok(nLength == 35, "expected 35 got %d\n", nLength);
2411
2412         r = IXMLDOMText_get_text(nodetext, &str);
2413         ok(r == S_OK, "ret %08x\n", r );
2414         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2415         SysFreeString(str);
2416
2417         /* delete from inside */
2418         r = IXMLDOMText_deleteData(nodetext, 1, 33);
2419         ok(r == S_OK, "ret %08x\n", r );
2420
2421         r = IXMLDOMText_get_length(nodetext, &nLength);
2422         ok(r == S_OK, "ret %08x\n", r );
2423         ok(nLength == 2, "expected 2 got %d\n", nLength);
2424
2425         r = IXMLDOMText_get_text(nodetext, &str);
2426         ok(r == S_OK, "ret %08x\n", r );
2427         ok( !lstrcmpW( str, _bstr_("") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2428         SysFreeString(str);
2429
2430         /* delete whole data ... */
2431         r = IXMLDOMText_get_length(nodetext, &nLength);
2432         ok(r == S_OK, "ret %08x\n", r );
2433
2434         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
2435         ok(r == S_OK, "ret %08x\n", r );
2436         /* ... and try again with empty string */
2437         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
2438         ok(r == S_OK, "ret %08x\n", r );
2439
2440         /* test put_data */
2441         V_VT(&var) = VT_BSTR;
2442         V_BSTR(&var) = SysAllocString(szstr1);
2443         r = IXMLDOMText_put_nodeValue(nodetext, var);
2444         ok(r == S_OK, "ret %08x\n", r );
2445         VariantClear(&var);
2446
2447         r = IXMLDOMText_get_text(nodetext, &str);
2448         ok(r == S_OK, "ret %08x\n", r );
2449         ok( !lstrcmpW( str, szstr1 ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2450         SysFreeString(str);
2451
2452         /* test put_data */
2453         V_VT(&var) = VT_I4;
2454         V_I4(&var) = 99;
2455         r = IXMLDOMText_put_nodeValue(nodetext, var);
2456         ok(r == S_OK, "ret %08x\n", r );
2457         VariantClear(&var);
2458
2459         r = IXMLDOMText_get_text(nodetext, &str);
2460         ok(r == S_OK, "ret %08x\n", r );
2461         ok( !lstrcmpW( str, _bstr_("99") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2462         SysFreeString(str);
2463
2464         /* ::replaceData() */
2465         V_VT(&var) = VT_BSTR;
2466         V_BSTR(&var) = SysAllocString(szstr1);
2467         r = IXMLDOMText_put_nodeValue(nodetext, var);
2468         ok(r == S_OK, "ret %08x\n", r );
2469         VariantClear(&var);
2470
2471         r = IXMLDOMText_replaceData(nodetext, 6, 0, NULL);
2472         ok(r == E_INVALIDARG, "ret %08x\n", r );
2473         r = IXMLDOMText_get_text(nodetext, &str);
2474         ok(r == S_OK, "ret %08x\n", r );
2475         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2476         SysFreeString(str);
2477
2478         r = IXMLDOMText_replaceData(nodetext, 0, 0, NULL);
2479         ok(r == S_OK, "ret %08x\n", r );
2480         r = IXMLDOMText_get_text(nodetext, &str);
2481         ok(r == S_OK, "ret %08x\n", r );
2482         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2483         SysFreeString(str);
2484
2485         /* NULL pointer means delete */
2486         r = IXMLDOMText_replaceData(nodetext, 0, 1, NULL);
2487         ok(r == S_OK, "ret %08x\n", r );
2488         r = IXMLDOMText_get_text(nodetext, &str);
2489         ok(r == S_OK, "ret %08x\n", r );
2490         ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2491         SysFreeString(str);
2492
2493         /* empty string means delete */
2494         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_(""));
2495         ok(r == S_OK, "ret %08x\n", r );
2496         r = IXMLDOMText_get_text(nodetext, &str);
2497         ok(r == S_OK, "ret %08x\n", r );
2498         ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2499         SysFreeString(str);
2500
2501         /* zero count means insert */
2502         r = IXMLDOMText_replaceData(nodetext, 0, 0, _bstr_("a"));
2503         ok(r == S_OK, "ret %08x\n", r );
2504         r = IXMLDOMText_get_text(nodetext, &str);
2505         ok(r == S_OK, "ret %08x\n", r );
2506         ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2507         SysFreeString(str);
2508
2509         r = IXMLDOMText_replaceData(nodetext, 0, 2, NULL);
2510         ok(r == S_OK, "ret %08x\n", r );
2511
2512         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("m"));
2513         ok(r == S_OK, "ret %08x\n", r );
2514         r = IXMLDOMText_get_text(nodetext, &str);
2515         ok(r == S_OK, "ret %08x\n", r );
2516         ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2517         SysFreeString(str);
2518
2519         /* nonempty string, count greater than its length */
2520         r = IXMLDOMText_replaceData(nodetext, 0, 2, _bstr_("a1.2"));
2521         ok(r == S_OK, "ret %08x\n", r );
2522         r = IXMLDOMText_get_text(nodetext, &str);
2523         ok(r == S_OK, "ret %08x\n", r );
2524         ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2525         SysFreeString(str);
2526
2527         /* nonempty string, count less than its length */
2528         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_("wine"));
2529         ok(r == S_OK, "ret %08x\n", r );
2530         r = IXMLDOMText_get_text(nodetext, &str);
2531         ok(r == S_OK, "ret %08x\n", r );
2532         ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2533         SysFreeString(str);
2534
2535         IXMLDOMText_Release( nodetext );
2536     }
2537
2538     /* test Create Comment */
2539     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
2540     ok( r == E_INVALIDARG, "returns %08x\n", r );
2541     node_comment = (IXMLDOMComment*)0x1;
2542
2543     /* empty comment */
2544     r = IXMLDOMDocument_createComment(doc, _bstr_(""), &node_comment);
2545     ok( r == S_OK, "returns %08x\n", r );
2546     str = (BSTR)0x1;
2547     r = IXMLDOMComment_get_data(node_comment, &str);
2548     ok( r == S_OK, "returns %08x\n", r );
2549     ok( str && SysStringLen(str) == 0, "expected empty string data\n");
2550     IXMLDOMComment_Release(node_comment);
2551     SysFreeString(str);
2552
2553     r = IXMLDOMDocument_createComment(doc, NULL, &node_comment);
2554     ok( r == S_OK, "returns %08x\n", r );
2555     str = (BSTR)0x1;
2556     r = IXMLDOMComment_get_data(node_comment, &str);
2557     ok( r == S_OK, "returns %08x\n", r );
2558     ok( str && (SysStringLen(str) == 0), "expected empty string data\n");
2559     IXMLDOMComment_Release(node_comment);
2560     SysFreeString(str);
2561
2562     str = SysAllocString(szComment);
2563     r = IXMLDOMDocument_createComment(doc, str, &node_comment);
2564     SysFreeString(str);
2565     ok( r == S_OK, "returns %08x\n", r );
2566     if(node_comment)
2567     {
2568         /* Last Child Checks */
2569         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
2570         ok(r == E_INVALIDARG, "ret %08x\n", r );
2571
2572         nodeChild = (IXMLDOMNode*)0x1;
2573         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
2574         ok(r == S_FALSE, "ret %08x\n", r );
2575         ok(nodeChild == NULL, "pLastChild not NULL\n");
2576
2577         /* baseName */
2578         str = (BSTR)0xdeadbeef;
2579         IXMLDOMComment_get_baseName(node_comment, &str);
2580         ok(r == S_FALSE, "ret %08x\n", r );
2581         ok(str == NULL, "Expected NULL\n");
2582
2583         IXMLDOMComment_Release( node_comment );
2584     }
2585
2586     /* test Create Attribute */
2587     str = SysAllocString(szAttribute);
2588     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
2589     ok( r == E_INVALIDARG, "returns %08x\n", r );
2590     r = IXMLDOMDocument_createAttribute(doc, str, &node_attr);
2591     ok( r == S_OK, "returns %08x\n", r );
2592     IXMLDOMText_Release( node_attr);
2593     SysFreeString(str);
2594
2595     /* test Processing Instruction */
2596     str = SysAllocStringLen(NULL, 0);
2597     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
2598     ok( r == E_INVALIDARG, "returns %08x\n", r );
2599     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
2600     ok( r == E_FAIL, "returns %08x\n", r );
2601     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
2602     ok( r == E_FAIL, "returns %08x\n", r );
2603     SysFreeString(str);
2604
2605     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
2606     ok( r == S_OK, "returns %08x\n", r );
2607     if(nodePI)
2608     {
2609         /* Last Child Checks */
2610         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
2611         ok(r == E_INVALIDARG, "ret %08x\n", r );
2612
2613         nodeChild = (IXMLDOMNode*)0x1;
2614         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
2615         ok(r == S_FALSE, "ret %08x\n", r );
2616         ok(nodeChild == NULL, "nodeChild not NULL\n");
2617
2618         /* test nodeName */
2619         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
2620         ok(r == S_OK, "ret %08x\n", r );
2621         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2622         SysFreeString(str);
2623
2624         /* test baseName */
2625         str = (BSTR)0x1;
2626         r = IXMLDOMProcessingInstruction_get_baseName(nodePI, &str);
2627         ok(r == S_OK, "ret %08x\n", r );
2628         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2629         SysFreeString(str);
2630
2631         /* test Target */
2632         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
2633         ok(r == S_OK, "ret %08x\n", r );
2634         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
2635         SysFreeString(str);
2636
2637         /* test get_nodeValue */
2638         r = IXMLDOMProcessingInstruction_get_nodeValue(nodePI, &var);
2639         ok(r == S_OK, "ret %08x\n", r );
2640         ok( !lstrcmpW( V_BSTR(&var), _bstr_("version=\"1.0\"") ), "incorrect data string\n");
2641         VariantClear(&var);
2642
2643         /* test get_data */
2644         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
2645         ok(r == S_OK, "ret %08x\n", r );
2646         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
2647         SysFreeString(str);
2648
2649         /* test put_data */
2650         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
2651         ok(r == E_FAIL, "ret %08x\n", r );
2652
2653         /* test put_data */
2654         V_VT(&var) = VT_BSTR;
2655         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
2656         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
2657         ok(r == E_FAIL, "ret %08x\n", r );
2658         VariantClear(&var);
2659
2660         /* test get nodeName */
2661         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
2662         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2663         ok(r == S_OK, "ret %08x\n", r );
2664         SysFreeString(str);
2665
2666         IXMLDOMProcessingInstruction_Release(nodePI);
2667     }
2668
2669     ref = IXMLDOMDocument_Release( doc );
2670     ok( ref == 0, "got %d\n", ref);
2671
2672     free_bstrs();
2673 }
2674
2675 static void test_persiststreaminit(void)
2676 {
2677     IXMLDOMDocument *doc;
2678     IPersistStreamInit *streaminit;
2679     HRESULT hr;
2680
2681     doc = create_document(&IID_IXMLDOMDocument);
2682     if (!doc) return;
2683
2684     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&streaminit);
2685     ok( hr == S_OK, "failed with 0x%08x\n", hr );
2686
2687     hr = IPersistStreamInit_InitNew(streaminit);
2688     ok( hr == S_OK, "failed with 0x%08x\n", hr );
2689
2690     IXMLDOMDocument_Release(doc);
2691 }
2692
2693 static void test_domnode( void )
2694 {
2695     HRESULT r;
2696     IXMLDOMDocument *doc, *owner = NULL;
2697     IXMLDOMElement *element = NULL;
2698     IXMLDOMNamedNodeMap *map = NULL;
2699     IXMLDOMNode *node = NULL, *next = NULL;
2700     IXMLDOMNodeList *list = NULL;
2701     IXMLDOMAttribute *attr = NULL;
2702     DOMNodeType type = NODE_INVALID;
2703     VARIANT_BOOL b;
2704     BSTR str;
2705     VARIANT var;
2706     LONG count;
2707
2708     doc = create_document(&IID_IXMLDOMDocument);
2709     if (!doc) return;
2710
2711     b = FALSE;
2712     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2713     ok( r == S_OK, "loadXML failed\n");
2714     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2715
2716     EXPECT_CHILDREN(doc);
2717
2718     r = IXMLDOMDocument_get_documentElement( doc, &element );
2719     ok( r == S_OK, "should be a document element\n");
2720     ok( element != NULL, "should be an element\n");
2721
2722     VariantInit(&var);
2723     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
2724
2725     r = IXMLDOMNode_get_nodeValue( doc, NULL );
2726     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
2727
2728     r = IXMLDOMNode_get_nodeValue( doc, &var );
2729     ok( r == S_FALSE, "nextNode returned wrong code\n");
2730     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
2731     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
2732
2733     if (element)
2734     {
2735         owner = NULL;
2736         r = IXMLDOMNode_get_ownerDocument( element, &owner );
2737         ok( r == S_OK, "get_ownerDocument return code\n");
2738         ok( owner != doc, "get_ownerDocument return\n");
2739         IXMLDOMDocument_Release(owner);
2740
2741         type = NODE_INVALID;
2742         r = IXMLDOMNode_get_nodeType( element, &type);
2743         ok( r == S_OK, "got %08x\n", r);
2744         ok( type == NODE_ELEMENT, "node not an element\n");
2745
2746         str = NULL;
2747         r = IXMLDOMNode_get_baseName( element, &str );
2748         ok( r == S_OK, "get_baseName returned wrong code\n");
2749         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
2750         SysFreeString(str);
2751
2752         /* check if nodename is correct */
2753         r = IXMLDOMElement_get_nodeName( element, NULL );
2754         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2755
2756         /* content doesn't matter here */
2757         str = NULL;
2758         r = IXMLDOMElement_get_nodeName( element, &str );
2759         ok ( r == S_OK, "get_nodeName wrong code\n");
2760         ok ( str != NULL, "str is null\n");
2761         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
2762         SysFreeString( str );
2763
2764         str = SysAllocString( nonexistent_fileW );
2765         V_VT(&var) = VT_I4;
2766         V_I4(&var) = 0x1234;
2767         r = IXMLDOMElement_getAttribute( element, str, &var );
2768         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
2769         ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
2770         VariantClear(&var);
2771
2772         str = SysAllocString( szdl );
2773         V_VT(&var) = VT_I4;
2774         V_I4(&var) = 0x1234;
2775         r = IXMLDOMElement_getAttribute( element, str, &var );
2776         ok( r == S_OK, "getAttribute ret %08x\n", r );
2777         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
2778         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
2779         VariantClear( &var );
2780
2781         r = IXMLDOMElement_getAttribute( element, NULL, &var );
2782         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
2783
2784         r = IXMLDOMElement_getAttribute( element, str, NULL );
2785         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
2786
2787         attr = NULL;
2788         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
2789         ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
2790         ok( attr != NULL, "getAttributeNode returned NULL\n" );
2791         if (attr)
2792         {
2793             r = IXMLDOMAttribute_get_parentNode( attr, NULL );
2794             ok( r == E_INVALIDARG, "Expected E_INVALIDARG, ret %08x\n", r );
2795
2796             /* attribute doesn't have a parent in msxml interpretation */
2797             node = (IXMLDOMNode*)0xdeadbeef;
2798             r = IXMLDOMAttribute_get_parentNode( attr, &node );
2799             ok( r == S_FALSE, "Expected S_FALSE, ret %08x\n", r );
2800             ok( node == NULL, "Expected NULL, got %p\n", node );
2801
2802             IXMLDOMAttribute_Release(attr);
2803         }
2804
2805         SysFreeString( str );
2806
2807         r = IXMLDOMElement_get_attributes( element, &map );
2808         ok( r == S_OK, "get_attributes returned wrong code\n");
2809         ok( map != NULL, "should be attributes\n");
2810
2811         EXPECT_CHILDREN(element);
2812     }
2813     else
2814         ok( FALSE, "no element\n");
2815
2816     if (map)
2817     {
2818         str = SysAllocString( szdl );
2819         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
2820         ok( r == S_OK, "getNamedItem returned wrong code\n");
2821         ok( node != NULL, "should be attributes\n");
2822         IXMLDOMNode_Release(node);
2823         SysFreeString( str );
2824
2825         str = SysAllocString( szdl );
2826         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
2827         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
2828         SysFreeString( str );
2829
2830         /* something that isn't in complete4A */
2831         str = SysAllocString( szOpen );
2832         node = (IXMLDOMNode *) 1;
2833         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
2834         ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
2835         ok( node == NULL, "getNamedItem should have returned NULL\n");
2836         SysFreeString( str );
2837
2838         /* test indexed access of attributes */
2839         r = IXMLDOMNamedNodeMap_get_length( map, NULL );
2840         ok ( r == E_INVALIDARG, "get_length should return E_INVALIDARG\n");
2841
2842         r = IXMLDOMNamedNodeMap_get_length( map, &count );
2843         ok ( r == S_OK, "get_length wrong code\n");
2844         ok ( count == 1, "get_length != 1\n");
2845
2846         node = NULL;
2847         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
2848         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
2849         ok ( node == NULL, "there is no node\n");
2850
2851         node = NULL;
2852         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
2853         ok ( r == S_FALSE, "get_item (1) wrong code\n");
2854         ok ( node == NULL, "there is no attribute\n");
2855
2856         node = NULL;
2857         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
2858         ok ( r == S_OK, "get_item (0) wrong code\n");
2859         ok ( node != NULL, "should be attribute\n");
2860
2861         r = IXMLDOMNode_get_nodeName( node, NULL );
2862         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2863
2864         /* content doesn't matter here */
2865         str = NULL;
2866         r = IXMLDOMNode_get_nodeName( node, &str );
2867         ok ( r == S_OK, "get_nodeName wrong code\n");
2868         ok ( str != NULL, "str is null\n");
2869         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
2870         SysFreeString( str );
2871         IXMLDOMNode_Release( node );
2872
2873         /* test sequential access of attributes */
2874         node = NULL;
2875         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2876         ok ( r == S_OK, "nextNode (first time) wrong code\n");
2877         ok ( node != NULL, "nextNode, should be attribute\n");
2878         IXMLDOMNode_Release( node );
2879
2880         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2881         ok ( r != S_OK, "nextNode (second time) wrong code\n");
2882         ok ( node == NULL, "nextNode, there is no attribute\n");
2883
2884         r = IXMLDOMNamedNodeMap_reset( map );
2885         ok ( r == S_OK, "reset should return S_OK\n");
2886
2887         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2888         ok ( r == S_OK, "nextNode (third time) wrong code\n");
2889         ok ( node != NULL, "nextNode, should be attribute\n");
2890     }
2891     else
2892         ok( FALSE, "no map\n");
2893
2894     if (node)
2895     {
2896         type = NODE_INVALID;
2897         r = IXMLDOMNode_get_nodeType( node, &type);
2898         ok( r == S_OK, "getNamedItem returned wrong code\n");
2899         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
2900
2901         str = NULL;
2902         r = IXMLDOMNode_get_baseName( node, NULL );
2903         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
2904
2905         str = NULL;
2906         r = IXMLDOMNode_get_baseName( node, &str );
2907         ok( r == S_OK, "get_baseName returned wrong code\n");
2908         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
2909         SysFreeString( str );
2910
2911         r = IXMLDOMNode_get_nodeValue( node, &var );
2912         ok( r == S_OK, "returns %08x\n", r );
2913         ok( V_VT(&var) == VT_BSTR, "vt %x\n", V_VT(&var));
2914         ok( !lstrcmpW(V_BSTR(&var), szstr1), "nodeValue incorrect\n");
2915         VariantClear(&var);
2916
2917         r = IXMLDOMNode_get_childNodes( node, NULL );
2918         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
2919
2920         r = IXMLDOMNode_get_childNodes( node, &list );
2921         ok( r == S_OK, "get_childNodes returned wrong code\n");
2922
2923         if (list)
2924         {
2925             r = IXMLDOMNodeList_nextNode( list, &next );
2926             ok( r == S_OK, "nextNode returned wrong code\n");
2927         }
2928         else
2929             ok( FALSE, "no childlist\n");
2930
2931         if (next)
2932         {
2933             EXPECT_NO_CHILDREN(next);
2934
2935             type = NODE_INVALID;
2936             r = IXMLDOMNode_get_nodeType( next, &type);
2937             ok( r == S_OK, "getNamedItem returned wrong code\n");
2938             ok( type == NODE_TEXT, "node not text\n");
2939
2940             str = (BSTR) 1;
2941             r = IXMLDOMNode_get_baseName( next, &str );
2942             ok( r == S_FALSE, "get_baseName returned wrong code\n");
2943             ok( str == NULL, "basename was wrong\n");
2944             SysFreeString(str);
2945         }
2946         else
2947             ok( FALSE, "no next\n");
2948
2949         if (next)
2950             IXMLDOMNode_Release( next );
2951         next = NULL;
2952         if (list)
2953             IXMLDOMNodeList_Release( list );
2954         list = NULL;
2955         if (node)
2956             IXMLDOMNode_Release( node );
2957     }
2958     else
2959         ok( FALSE, "no node\n");
2960     node = NULL;
2961
2962     if (map)
2963         IXMLDOMNamedNodeMap_Release( map );
2964
2965     /* now traverse the tree from the root element */
2966     if (element)
2967     {
2968         r = IXMLDOMNode_get_childNodes( element, &list );
2969         ok( r == S_OK, "get_childNodes returned wrong code\n");
2970
2971         /* using get_item for child list doesn't advance the position */
2972         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
2973         expect_node(node, "E2.E2.D1");
2974         IXMLDOMNode_Release(node);
2975         ole_check(IXMLDOMNodeList_nextNode(list, &node));
2976         expect_node(node, "E1.E2.D1");
2977         IXMLDOMNode_Release(node);
2978         ole_check(IXMLDOMNodeList_reset(list));
2979
2980         IXMLDOMNodeList_AddRef(list);
2981         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
2982         ole_check(IXMLDOMNodeList_reset(list));
2983
2984         node = (void*)0xdeadbeef;
2985         str = SysAllocString(szdl);
2986         r = IXMLDOMNode_selectSingleNode( element, str, &node );
2987         SysFreeString(str);
2988         ok( r == S_FALSE, "ret %08x\n", r );
2989         ok( node == NULL, "node %p\n", node );
2990
2991         str = SysAllocString(szbs);
2992         r = IXMLDOMNode_selectSingleNode( element, str, &node );
2993         SysFreeString(str);
2994         ok( r == S_OK, "ret %08x\n", r );
2995         r = IXMLDOMNode_Release( node );
2996         ok( r == 0, "ret %08x\n", r );
2997     }
2998     else
2999         ok( FALSE, "no element\n");
3000
3001     if (list)
3002     {
3003         r = IXMLDOMNodeList_get_item(list, 0, NULL);
3004         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
3005
3006         r = IXMLDOMNodeList_get_length(list, NULL);
3007         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
3008
3009         r = IXMLDOMNodeList_get_length( list, &count );
3010         ok( r == S_OK, "get_length returns %08x\n", r );
3011         ok( count == 4, "get_length got %d\n", count );
3012
3013         r = IXMLDOMNodeList_nextNode(list, NULL);
3014         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
3015
3016         r = IXMLDOMNodeList_nextNode( list, &node );
3017         ok( r == S_OK, "nextNode returned wrong code\n");
3018     }
3019     else
3020         ok( FALSE, "no list\n");
3021
3022     if (node)
3023     {
3024         type = NODE_INVALID;
3025         r = IXMLDOMNode_get_nodeType( node, &type);
3026         ok( r == S_OK, "getNamedItem returned wrong code\n");
3027         ok( type == NODE_ELEMENT, "node not text\n");
3028
3029         VariantInit(&var);
3030         ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
3031         r = IXMLDOMNode_get_nodeValue( node, &var );
3032         ok( r == S_FALSE, "nextNode returned wrong code\n");
3033         ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
3034         ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
3035
3036         r = IXMLDOMNode_hasChildNodes( node, NULL );
3037         ok( r == E_INVALIDARG, "hasChildNodes bad return\n");
3038
3039         EXPECT_CHILDREN(node);
3040
3041         str = NULL;
3042         r = IXMLDOMNode_get_baseName( node, &str );
3043         ok( r == S_OK, "get_baseName returned wrong code\n");
3044         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
3045         SysFreeString(str);
3046     }
3047     else
3048         ok( FALSE, "no node\n");
3049
3050     if (node)
3051         IXMLDOMNode_Release( node );
3052     if (list)
3053         IXMLDOMNodeList_Release( list );
3054     if (element)
3055         IXMLDOMElement_Release( element );
3056
3057     b = FALSE;
3058     str = SysAllocString( szComplete5 );
3059     r = IXMLDOMDocument_loadXML( doc, str, &b );
3060     ok( r == S_OK, "loadXML failed\n");
3061     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3062     SysFreeString( str );
3063
3064     EXPECT_CHILDREN(doc);
3065
3066     r = IXMLDOMDocument_get_documentElement( doc, &element );
3067     ok( r == S_OK, "should be a document element\n");
3068     ok( element != NULL, "should be an element\n");
3069
3070     if (element)
3071     {
3072         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
3073         BSTR tag = NULL;
3074
3075         /* check if the tag is correct */
3076         r = IXMLDOMElement_get_tagName( element, &tag );
3077         ok( r == S_OK, "couldn't get tag name\n");
3078         ok( tag != NULL, "tag was null\n");
3079         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
3080         SysFreeString( tag );
3081     }
3082
3083     if (element)
3084         IXMLDOMElement_Release( element );
3085     ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
3086
3087     free_bstrs();
3088 }
3089
3090 static void test_refs(void)
3091 {
3092     HRESULT r;
3093     VARIANT_BOOL b;
3094     IXMLDOMDocument *doc;
3095     IXMLDOMElement *element = NULL;
3096     IXMLDOMNode *node = NULL, *node2;
3097     IXMLDOMNodeList *node_list = NULL;
3098     LONG ref;
3099     IUnknown *unk, *unk2;
3100
3101     doc = create_document(&IID_IXMLDOMDocument);
3102     if (!doc) return;
3103
3104     EXPECT_REF(doc, 1);
3105     ref = IXMLDOMDocument_Release(doc);
3106     ok( ref == 0, "ref %d\n", ref);
3107
3108     doc = create_document(&IID_IXMLDOMDocument);
3109     if (!doc) return;
3110
3111     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3112     ok( r == S_OK, "loadXML failed\n");
3113     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3114
3115     EXPECT_REF(doc, 1);
3116     IXMLDOMDocument_AddRef( doc );
3117     EXPECT_REF(doc, 2);
3118     IXMLDOMDocument_AddRef( doc );
3119     EXPECT_REF(doc, 3);
3120
3121     IXMLDOMDocument_Release( doc );
3122     IXMLDOMDocument_Release( doc );
3123
3124     r = IXMLDOMDocument_get_documentElement( doc, &element );
3125     ok( r == S_OK, "should be a document element\n");
3126     ok( element != NULL, "should be an element\n");
3127
3128     EXPECT_REF(doc, 1);
3129     todo_wine EXPECT_REF(element, 2);
3130
3131     IXMLDOMElement_AddRef(element);
3132     todo_wine EXPECT_REF(element, 3);
3133     IXMLDOMElement_Release(element);
3134
3135     r = IXMLDOMElement_get_childNodes( element, &node_list );
3136     ok( r == S_OK, "rets %08x\n", r);
3137
3138     todo_wine EXPECT_REF(element, 2);
3139     EXPECT_REF(node_list, 1);
3140
3141     IXMLDOMNodeList_get_item( node_list, 0, &node );
3142     ok( r == S_OK, "rets %08x\n", r);
3143     EXPECT_REF(node_list, 1);
3144     EXPECT_REF(node, 1);
3145
3146     IXMLDOMNodeList_get_item( node_list, 0, &node2 );
3147     ok( r == S_OK, "rets %08x\n", r);
3148     EXPECT_REF(node_list, 1);
3149     EXPECT_REF(node2, 1);
3150
3151     ref = IXMLDOMNode_Release( node );
3152     ok( ref == 0, "ref %d\n", ref );
3153     ref = IXMLDOMNode_Release( node2 );
3154     ok( ref == 0, "ref %d\n", ref );
3155
3156     ref = IXMLDOMNodeList_Release( node_list );
3157     ok( ref == 0, "ref %d\n", ref );
3158
3159     ok( node != node2, "node %p node2 %p\n", node, node2 );
3160
3161     ref = IXMLDOMDocument_Release( doc );
3162     ok( ref == 0, "ref %d\n", ref );
3163
3164     todo_wine EXPECT_REF(element, 2);
3165
3166     /* IUnknown must be unique however we obtain it */
3167     r = IXMLDOMElement_QueryInterface( element, &IID_IUnknown, (void**)&unk );
3168     ok( r == S_OK, "rets %08x\n", r );
3169     EXPECT_REF(element, 2);
3170     r = IXMLDOMElement_QueryInterface( element, &IID_IXMLDOMNode, (void**)&node );
3171     ok( r == S_OK, "rets %08x\n", r );
3172     todo_wine EXPECT_REF(element, 2);
3173     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk2 );
3174     ok( r == S_OK, "rets %08x\n", r );
3175     todo_wine EXPECT_REF(element, 2);
3176     ok( unk == unk2, "unk %p unk2 %p\n", unk, unk2 );
3177     todo_wine ok( element != (void*)node, "node %p element %p\n", node, element );
3178
3179     IUnknown_Release( unk2 );
3180     IUnknown_Release( unk );
3181     IXMLDOMNode_Release( node );
3182     todo_wine EXPECT_REF(element, 2);
3183
3184     IXMLDOMElement_Release( element );
3185
3186     free_bstrs();
3187 }
3188
3189 static void test_create(void)
3190 {
3191     static const WCHAR szOne[] = {'1',0};
3192     static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
3193     HRESULT r;
3194     VARIANT var;
3195     BSTR str, name;
3196     IXMLDOMDocument *doc;
3197     IXMLDOMElement *element;
3198     IXMLDOMComment *comment;
3199     IXMLDOMText *text;
3200     IXMLDOMCDATASection *cdata;
3201     IXMLDOMNode *root, *node, *child;
3202     IXMLDOMNamedNodeMap *attr_map;
3203     IUnknown *unk;
3204     LONG ref;
3205     LONG num;
3206
3207     doc = create_document(&IID_IXMLDOMDocument);
3208     if (!doc) return;
3209
3210     EXPECT_REF(doc, 1);
3211
3212     /* types not supported for creation */
3213     V_VT(&var) = VT_I1;
3214     V_I1(&var) = NODE_DOCUMENT;
3215     node = (IXMLDOMNode*)0x1;
3216     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3217     ok( r == E_INVALIDARG, "returns %08x\n", r );
3218     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3219
3220     V_VT(&var) = VT_I1;
3221     V_I1(&var) = NODE_DOCUMENT_TYPE;
3222     node = (IXMLDOMNode*)0x1;
3223     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3224     ok( r == E_INVALIDARG, "returns %08x\n", r );
3225     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3226
3227     V_VT(&var) = VT_I1;
3228     V_I1(&var) = NODE_ENTITY;
3229     node = (IXMLDOMNode*)0x1;
3230     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3231     ok( r == E_INVALIDARG, "returns %08x\n", r );
3232     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3233
3234     V_VT(&var) = VT_I1;
3235     V_I1(&var) = NODE_NOTATION;
3236     node = (IXMLDOMNode*)0x1;
3237     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3238     ok( r == E_INVALIDARG, "returns %08x\n", r );
3239     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3240
3241     /* NODE_COMMENT */
3242     V_VT(&var) = VT_I1;
3243     V_I1(&var) = NODE_COMMENT;
3244     node = NULL;
3245     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3246     ok( r == S_OK, "returns %08x\n", r );
3247     ok( node != NULL, "\n");
3248
3249     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
3250     ok( r == S_OK, "returns %08x\n", r );
3251     IXMLDOMNode_Release(node);
3252
3253     str = NULL;
3254     r = IXMLDOMComment_get_data(comment, &str);
3255     ok( r == S_OK, "returns %08x\n", r );
3256     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3257     IXMLDOMComment_Release(comment);
3258     SysFreeString(str);
3259
3260     node = (IXMLDOMNode*)0x1;
3261     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3262     ok( r == S_OK, "returns %08x\n", r );
3263
3264     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
3265     ok( r == S_OK, "returns %08x\n", r );
3266     IXMLDOMNode_Release(node);
3267
3268     str = NULL;
3269     r = IXMLDOMComment_get_data(comment, &str);
3270     ok( r == S_OK, "returns %08x\n", r );
3271     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3272     IXMLDOMComment_Release(comment);
3273     SysFreeString(str);
3274
3275     node = (IXMLDOMNode*)0x1;
3276     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3277     ok( r == S_OK, "returns %08x\n", r );
3278
3279     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
3280     ok( r == S_OK, "returns %08x\n", r );
3281     IXMLDOMNode_Release(node);
3282
3283     str = NULL;
3284     r = IXMLDOMComment_get_data(comment, &str);
3285     ok( r == S_OK, "returns %08x\n", r );
3286     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3287     IXMLDOMComment_Release(comment);
3288     SysFreeString(str);
3289
3290     /* NODE_TEXT */
3291     V_VT(&var) = VT_I1;
3292     V_I1(&var) = NODE_TEXT;
3293     node = NULL;
3294     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3295     ok( r == S_OK, "returns %08x\n", r );
3296     ok( node != NULL, "\n");
3297
3298     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3299     ok( r == S_OK, "returns %08x\n", r );
3300     IXMLDOMNode_Release(node);
3301
3302     str = NULL;
3303     r = IXMLDOMText_get_data(text, &str);
3304     ok( r == S_OK, "returns %08x\n", r );
3305     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3306     IXMLDOMText_Release(text);
3307     SysFreeString(str);
3308
3309     node = (IXMLDOMNode*)0x1;
3310     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3311     ok( r == S_OK, "returns %08x\n", r );
3312
3313     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3314     ok( r == S_OK, "returns %08x\n", r );
3315     IXMLDOMNode_Release(node);
3316
3317     str = NULL;
3318     r = IXMLDOMText_get_data(text, &str);
3319     ok( r == S_OK, "returns %08x\n", r );
3320     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3321     IXMLDOMText_Release(text);
3322     SysFreeString(str);
3323
3324     node = (IXMLDOMNode*)0x1;
3325     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3326     ok( r == S_OK, "returns %08x\n", r );
3327
3328     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3329     ok( r == S_OK, "returns %08x\n", r );
3330     IXMLDOMNode_Release(node);
3331
3332     str = NULL;
3333     r = IXMLDOMText_get_data(text, &str);
3334     ok( r == S_OK, "returns %08x\n", r );
3335     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3336     IXMLDOMText_Release(text);
3337     SysFreeString(str);
3338
3339     /* NODE_CDATA_SECTION */
3340     V_VT(&var) = VT_I1;
3341     V_I1(&var) = NODE_CDATA_SECTION;
3342     node = NULL;
3343     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3344     ok( r == S_OK, "returns %08x\n", r );
3345     ok( node != NULL, "\n");
3346
3347     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3348     ok( r == S_OK, "returns %08x\n", r );
3349     IXMLDOMNode_Release(node);
3350
3351     str = NULL;
3352     r = IXMLDOMCDATASection_get_data(cdata, &str);
3353     ok( r == S_OK, "returns %08x\n", r );
3354     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3355     IXMLDOMCDATASection_Release(cdata);
3356     SysFreeString(str);
3357
3358     node = (IXMLDOMNode*)0x1;
3359     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3360     ok( r == S_OK, "returns %08x\n", r );
3361
3362     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3363     ok( r == S_OK, "returns %08x\n", r );
3364     IXMLDOMNode_Release(node);
3365
3366     str = NULL;
3367     r = IXMLDOMCDATASection_get_data(cdata, &str);
3368     ok( r == S_OK, "returns %08x\n", r );
3369     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3370     IXMLDOMCDATASection_Release(cdata);
3371     SysFreeString(str);
3372
3373     node = (IXMLDOMNode*)0x1;
3374     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3375     ok( r == S_OK, "returns %08x\n", r );
3376
3377     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3378     ok( r == S_OK, "returns %08x\n", r );
3379     IXMLDOMNode_Release(node);
3380
3381     str = NULL;
3382     r = IXMLDOMCDATASection_get_data(cdata, &str);
3383     ok( r == S_OK, "returns %08x\n", r );
3384     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3385     IXMLDOMCDATASection_Release(cdata);
3386     SysFreeString(str);
3387
3388     /* NODE_ATTRIBUTE */
3389     V_VT(&var) = VT_I1;
3390     V_I1(&var) = NODE_ATTRIBUTE;
3391     node = (IXMLDOMNode*)0x1;
3392     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3393     ok( r == E_FAIL, "returns %08x\n", r );
3394     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3395
3396     V_VT(&var) = VT_I1;
3397     V_I1(&var) = NODE_ATTRIBUTE;
3398     node = (IXMLDOMNode*)0x1;
3399     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3400     ok( r == E_FAIL, "returns %08x\n", r );
3401     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3402
3403     V_VT(&var) = VT_I1;
3404     V_I1(&var) = NODE_ATTRIBUTE;
3405     str = SysAllocString( szlc );
3406     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3407     ok( r == S_OK, "returns %08x\n", r );
3408     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3409     SysFreeString(str);
3410
3411     /* a name is required for attribute, try a BSTR with first null wchar */
3412     V_VT(&var) = VT_I1;
3413     V_I1(&var) = NODE_ATTRIBUTE;
3414     str = SysAllocString( szstr1 );
3415     str[0] = 0;
3416     node = (IXMLDOMNode*)0x1;
3417     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3418     ok( r == E_FAIL, "returns %08x\n", r );
3419     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3420     SysFreeString(str);
3421
3422     /* NODE_PROCESSING_INSTRUCTION */
3423     V_VT(&var) = VT_I1;
3424     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3425     node = (IXMLDOMNode*)0x1;
3426     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3427     ok( r == E_FAIL, "returns %08x\n", r );
3428     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3429
3430     V_VT(&var) = VT_I1;
3431     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3432     node = (IXMLDOMNode*)0x1;
3433     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3434     ok( r == E_FAIL, "returns %08x\n", r );
3435     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3436
3437     V_VT(&var) = VT_I1;
3438     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3439     r = IXMLDOMDocument_createNode( doc, var, _bstr_("pi"), NULL, NULL );
3440     ok( r == E_INVALIDARG, "returns %08x\n", r );
3441
3442     /* NODE_ENTITY_REFERENCE */
3443     V_VT(&var) = VT_I1;
3444     V_I1(&var) = NODE_ENTITY_REFERENCE;
3445     node = (IXMLDOMNode*)0x1;
3446     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3447     ok( r == E_FAIL, "returns %08x\n", r );
3448     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3449
3450     V_VT(&var) = VT_I1;
3451     V_I1(&var) = NODE_ENTITY_REFERENCE;
3452     node = (IXMLDOMNode*)0x1;
3453     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3454     ok( r == E_FAIL, "returns %08x\n", r );
3455     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3456
3457     /* NODE_ELEMENT */
3458     V_VT(&var) = VT_I1;
3459     V_I1(&var) = NODE_ELEMENT;
3460     node = (IXMLDOMNode*)0x1;
3461     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3462     ok( r == E_FAIL, "returns %08x\n", r );
3463     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3464
3465     V_VT(&var) = VT_I1;
3466     V_I1(&var) = NODE_ELEMENT;
3467     node = (IXMLDOMNode*)0x1;
3468     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3469     ok( r == E_FAIL, "returns %08x\n", r );
3470     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3471
3472     V_VT(&var) = VT_I1;
3473     V_I1(&var) = NODE_ELEMENT;
3474     str = SysAllocString( szlc );
3475     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3476     ok( r == S_OK, "returns %08x\n", r );
3477     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3478
3479     V_VT(&var) = VT_I1;
3480     V_I1(&var) = NODE_ELEMENT;
3481     r = IXMLDOMDocument_createNode( doc, var, str, NULL, NULL );
3482     ok( r == E_INVALIDARG, "returns %08x\n", r );
3483
3484     V_VT(&var) = VT_R4;
3485     V_R4(&var) = NODE_ELEMENT;
3486     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3487     ok( r == S_OK, "returns %08x\n", r );
3488     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3489
3490     V_VT(&var) = VT_BSTR;
3491     V_BSTR(&var) = SysAllocString( szOne );
3492     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3493     ok( r == S_OK, "returns %08x\n", r );
3494     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3495     VariantClear(&var);
3496
3497     V_VT(&var) = VT_BSTR;
3498     V_BSTR(&var) = SysAllocString( szOneGarbage );
3499     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3500     ok( r == E_INVALIDARG, "returns %08x\n", r );
3501     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3502     VariantClear(&var);
3503
3504     V_VT(&var) = VT_I4;
3505     V_I4(&var) = NODE_ELEMENT;
3506     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3507     ok( r == S_OK, "returns %08x\n", r );
3508
3509     EXPECT_REF(doc, 1);
3510     r = IXMLDOMDocument_appendChild( doc, node, &root );
3511     ok( r == S_OK, "returns %08x\n", r );
3512     ok( node == root, "%p %p\n", node, root );
3513     EXPECT_REF(doc, 1);
3514
3515     EXPECT_REF(node, 2);
3516
3517     ref = IXMLDOMNode_Release( node );
3518     ok(ref == 1, "ref %d\n", ref);
3519     SysFreeString( str );
3520
3521     V_VT(&var) = VT_I4;
3522     V_I4(&var) = NODE_ELEMENT;
3523     str = SysAllocString( szbs );
3524     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3525     ok( r == S_OK, "returns %08x\n", r );
3526     SysFreeString( str );
3527
3528     EXPECT_REF(node, 1);
3529
3530     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk );
3531     ok( r == S_OK, "returns %08x\n", r );
3532
3533     EXPECT_REF(unk, 2);
3534
3535     V_VT(&var) = VT_EMPTY;
3536     child = NULL;
3537     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
3538     ok( r == S_OK, "returns %08x\n", r );
3539     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
3540
3541     todo_wine EXPECT_REF(unk, 4);
3542
3543     IXMLDOMNode_Release( child );
3544     IUnknown_Release( unk );
3545
3546     V_VT(&var) = VT_NULL;
3547     V_DISPATCH(&var) = (IDispatch*)node;
3548     r = IXMLDOMNode_insertBefore( root, node, var, &child );
3549     ok( r == S_OK, "returns %08x\n", r );
3550     ok( node == child, "%p %p\n", node, child );
3551     IXMLDOMNode_Release( child );
3552
3553     V_VT(&var) = VT_NULL;
3554     V_DISPATCH(&var) = (IDispatch*)node;
3555     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
3556     ok( r == S_OK, "returns %08x\n", r );
3557     IXMLDOMNode_Release( node );
3558
3559     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (void**)&element );
3560     ok( r == S_OK, "returns %08x\n", r );
3561
3562     r = IXMLDOMElement_get_attributes( element, &attr_map );
3563     ok( r == S_OK, "returns %08x\n", r );
3564     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3565     ok( r == S_OK, "returns %08x\n", r );
3566     ok( num == 0, "num %d\n", num );
3567     IXMLDOMNamedNodeMap_Release( attr_map );
3568
3569     V_VT(&var) = VT_BSTR;
3570     V_BSTR(&var) = SysAllocString( szstr1 );
3571     name = SysAllocString( szdl );
3572     r = IXMLDOMElement_setAttribute( element, name, var );
3573     ok( r == S_OK, "returns %08x\n", r );
3574     r = IXMLDOMElement_get_attributes( element, &attr_map );
3575     ok( r == S_OK, "returns %08x\n", r );
3576     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3577     ok( r == S_OK, "returns %08x\n", r );
3578     ok( num == 1, "num %d\n", num );
3579     IXMLDOMNamedNodeMap_Release( attr_map );
3580     VariantClear(&var);
3581
3582     V_VT(&var) = VT_BSTR;
3583     V_BSTR(&var) = SysAllocString( szstr2 );
3584     r = IXMLDOMElement_setAttribute( element, name, var );
3585     ok( r == S_OK, "returns %08x\n", r );
3586     r = IXMLDOMElement_get_attributes( element, &attr_map );
3587     ok( r == S_OK, "returns %08x\n", r );
3588     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3589     ok( r == S_OK, "returns %08x\n", r );
3590     ok( num == 1, "num %d\n", num );
3591     IXMLDOMNamedNodeMap_Release( attr_map );
3592     VariantClear(&var);
3593     r = IXMLDOMElement_getAttribute( element, name, &var );
3594     ok( r == S_OK, "returns %08x\n", r );
3595     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
3596     VariantClear(&var);
3597     SysFreeString(name);
3598
3599     V_VT(&var) = VT_BSTR;
3600     V_BSTR(&var) = SysAllocString( szstr1 );
3601     name = SysAllocString( szlc );
3602     r = IXMLDOMElement_setAttribute( element, name, var );
3603     ok( r == S_OK, "returns %08x\n", r );
3604     r = IXMLDOMElement_get_attributes( element, &attr_map );
3605     ok( r == S_OK, "returns %08x\n", r );
3606     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3607     ok( r == S_OK, "returns %08x\n", r );
3608     ok( num == 2, "num %d\n", num );
3609     IXMLDOMNamedNodeMap_Release( attr_map );
3610     VariantClear(&var);
3611     SysFreeString(name);
3612
3613     V_VT(&var) = VT_I4;
3614     V_I4(&var) = 10;
3615     name = SysAllocString( szbs );
3616     r = IXMLDOMElement_setAttribute( element, name, var );
3617     ok( r == S_OK, "returns %08x\n", r );
3618     VariantClear(&var);
3619     r = IXMLDOMElement_getAttribute( element, name, &var );
3620     ok( r == S_OK, "returns %08x\n", r );
3621     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
3622     VariantClear(&var);
3623     SysFreeString(name);
3624
3625     /* Create an Attribute */
3626     V_VT(&var) = VT_I4;
3627     V_I4(&var) = NODE_ATTRIBUTE;
3628     str = SysAllocString( szAttribute );
3629     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3630     ok( r == S_OK, "returns %08x\n", r );
3631     ok( node != NULL, "node was null\n");
3632     SysFreeString(str);
3633
3634     IXMLDOMElement_Release( element );
3635     IXMLDOMNode_Release( root );
3636     IXMLDOMDocument_Release( doc );
3637 }
3638
3639 static void test_getElementsByTagName(void)
3640 {
3641     IXMLDOMNodeList *node_list;
3642     IXMLDOMDocument *doc;
3643     IXMLDOMElement *elem;
3644     WCHAR buff[100];
3645     VARIANT_BOOL b;
3646     HRESULT r;
3647     LONG len;
3648     BSTR str;
3649
3650     doc = create_document(&IID_IXMLDOMDocument);
3651     if (!doc) return;
3652
3653     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3654     ok( r == S_OK, "loadXML failed\n");
3655     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3656
3657     str = SysAllocString( szstar );
3658
3659     /* null arguments cases */
3660     r = IXMLDOMDocument_getElementsByTagName(doc, NULL, &node_list);
3661     ok( r == E_INVALIDARG, "ret %08x\n", r );
3662     r = IXMLDOMDocument_getElementsByTagName(doc, str, NULL);
3663     ok( r == E_INVALIDARG, "ret %08x\n", r );
3664
3665     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
3666     ok( r == S_OK, "ret %08x\n", r );
3667     r = IXMLDOMNodeList_get_length( node_list, &len );
3668     ok( r == S_OK, "ret %08x\n", r );
3669     ok( len == 6, "len %d\n", len );
3670
3671     IXMLDOMNodeList_Release( node_list );
3672     SysFreeString( str );
3673
3674     /* broken query BSTR */
3675     memcpy(&buff[2], szstar, sizeof(szstar));
3676     /* just a big length */
3677     *(DWORD*)buff = 0xf0f0;
3678     r = IXMLDOMDocument_getElementsByTagName(doc, &buff[2], &node_list);
3679     ok( r == S_OK, "ret %08x\n", r );
3680     r = IXMLDOMNodeList_get_length( node_list, &len );
3681     ok( r == S_OK, "ret %08x\n", r );
3682     ok( len == 6, "len %d\n", len );
3683     IXMLDOMNodeList_Release( node_list );
3684
3685     str = SysAllocString( szbs );
3686     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
3687     ok( r == S_OK, "ret %08x\n", r );
3688     r = IXMLDOMNodeList_get_length( node_list, &len );
3689     ok( r == S_OK, "ret %08x\n", r );
3690     ok( len == 1, "len %d\n", len );
3691     IXMLDOMNodeList_Release( node_list );
3692     SysFreeString( str );
3693
3694     str = SysAllocString( szdl );
3695     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
3696     ok( r == S_OK, "ret %08x\n", r );
3697     r = IXMLDOMNodeList_get_length( node_list, &len );
3698     ok( r == S_OK, "ret %08x\n", r );
3699     ok( len == 0, "len %d\n", len );
3700     IXMLDOMNodeList_Release( node_list );
3701     SysFreeString( str );
3702
3703     str = SysAllocString( szstr1 );
3704     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
3705     ok( r == S_OK, "ret %08x\n", r );
3706     r = IXMLDOMNodeList_get_length( node_list, &len );
3707     ok( r == S_OK, "ret %08x\n", r );
3708     ok( len == 0, "len %d\n", len );
3709     IXMLDOMNodeList_Release( node_list );
3710     SysFreeString( str );
3711
3712     /* test for element */
3713     r = IXMLDOMDocument_get_documentElement(doc, &elem);
3714     ok( r == S_OK, "ret %08x\n", r );
3715
3716     str = SysAllocString( szstar );
3717
3718     /* null arguments cases */
3719     r = IXMLDOMElement_getElementsByTagName(elem, NULL, &node_list);
3720     ok( r == E_INVALIDARG, "ret %08x\n", r );
3721     r = IXMLDOMElement_getElementsByTagName(elem, str, NULL);
3722     ok( r == E_INVALIDARG, "ret %08x\n", r );
3723
3724     r = IXMLDOMElement_getElementsByTagName(elem, str, &node_list);
3725     ok( r == S_OK, "ret %08x\n", r );
3726     r = IXMLDOMNodeList_get_length( node_list, &len );
3727     ok( r == S_OK, "ret %08x\n", r );
3728     ok( len == 5, "len %d\n", len );
3729     expect_list_and_release(node_list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1");
3730     SysFreeString( str );
3731
3732     /* broken query BSTR */
3733     memcpy(&buff[2], szstar, sizeof(szstar));
3734     /* just a big length */
3735     *(DWORD*)buff = 0xf0f0;
3736     r = IXMLDOMElement_getElementsByTagName(elem, &buff[2], &node_list);
3737     ok( r == S_OK, "ret %08x\n", r );
3738     r = IXMLDOMNodeList_get_length( node_list, &len );
3739     ok( r == S_OK, "ret %08x\n", r );
3740     ok( len == 5, "len %d\n", len );
3741     IXMLDOMNodeList_Release( node_list );
3742
3743     IXMLDOMElement_Release(elem);
3744
3745     IXMLDOMDocument_Release( doc );
3746
3747     free_bstrs();
3748 }
3749
3750 static void test_get_text(void)
3751 {
3752     HRESULT r;
3753     BSTR str;
3754     VARIANT_BOOL b;
3755     IXMLDOMDocument *doc;
3756     IXMLDOMNode *node, *node2, *node3;
3757     IXMLDOMNode *nodeRoot;
3758     IXMLDOMNodeList *node_list;
3759     IXMLDOMNamedNodeMap *node_map;
3760     LONG len;
3761
3762     doc = create_document(&IID_IXMLDOMDocument);
3763     if (!doc) return;
3764
3765     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3766     ok( r == S_OK, "loadXML failed\n");
3767     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3768
3769     str = SysAllocString( szbs );
3770     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
3771     ok( r == S_OK, "ret %08x\n", r );
3772     SysFreeString(str);
3773
3774     /* Test to get all child node text. */
3775     r = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&nodeRoot);
3776     ok( r == S_OK, "ret %08x\n", r );
3777     if(r == S_OK)
3778     {
3779         r = IXMLDOMNode_get_text( nodeRoot, &str );
3780         ok( r == S_OK, "ret %08x\n", r );
3781         ok( compareIgnoreReturns(str, _bstr_("fn1.txt\n\n fn2.txt \n\nf1\n")), "wrong get_text: %s\n", wine_dbgstr_w(str));
3782         SysFreeString(str);
3783
3784         IXMLDOMNode_Release(nodeRoot);
3785     }
3786
3787     r = IXMLDOMNodeList_get_length( node_list, NULL );
3788     ok( r == E_INVALIDARG, "ret %08x\n", r );
3789
3790     r = IXMLDOMNodeList_get_length( node_list, &len );
3791     ok( r == S_OK, "ret %08x\n", r );
3792     ok( len == 1, "expect 1 got %d\n", len );
3793
3794     r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
3795     ok( r == E_INVALIDARG, "ret %08x\n", r );
3796
3797     r = IXMLDOMNodeList_nextNode( node_list, NULL );
3798     ok( r == E_INVALIDARG, "ret %08x\n", r );
3799
3800     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
3801     ok( r == S_OK, "ret %08x\n", r );
3802     IXMLDOMNodeList_Release( node_list );
3803
3804     /* Invalid output parameter*/
3805     r = IXMLDOMNode_get_text( node, NULL );
3806     ok( r == E_INVALIDARG, "ret %08x\n", r );
3807
3808     r = IXMLDOMNode_get_text( node, &str );
3809     ok( r == S_OK, "ret %08x\n", r );
3810     ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
3811     SysFreeString(str);
3812
3813     r = IXMLDOMNode_get_attributes( node, &node_map );
3814     ok( r == S_OK, "ret %08x\n", r );
3815
3816     str = SysAllocString( szvr );
3817     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
3818     ok( r == S_OK, "ret %08x\n", r );
3819     SysFreeString(str);
3820
3821     r = IXMLDOMNode_get_text( node2, &str );
3822     ok( r == S_OK, "ret %08x\n", r );
3823     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3824     SysFreeString(str);
3825
3826     r = IXMLDOMNode_get_firstChild( node2, &node3 );
3827     ok( r == S_OK, "ret %08x\n", r );
3828
3829     r = IXMLDOMNode_get_text( node3, &str );
3830     ok( r == S_OK, "ret %08x\n", r );
3831     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3832     SysFreeString(str);
3833
3834
3835     IXMLDOMNode_Release( node3 );
3836     IXMLDOMNode_Release( node2 );
3837     IXMLDOMNamedNodeMap_Release( node_map );
3838     IXMLDOMNode_Release( node );
3839     IXMLDOMDocument_Release( doc );
3840
3841     free_bstrs();
3842 }
3843
3844 static void test_get_childNodes(void)
3845 {
3846     BSTR str;
3847     VARIANT_BOOL b;
3848     IXMLDOMDocument *doc;
3849     IXMLDOMElement *element;
3850     IXMLDOMNode *node, *node2;
3851     IXMLDOMNodeList *node_list, *node_list2;
3852     HRESULT hr;
3853     LONG len;
3854
3855     doc = create_document(&IID_IXMLDOMDocument);
3856     if (!doc) return;
3857
3858     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3859     EXPECT_HR(hr, S_OK);
3860     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3861
3862     hr = IXMLDOMDocument_get_documentElement( doc, &element );
3863     EXPECT_HR(hr, S_OK);
3864
3865     hr = IXMLDOMElement_get_childNodes( element, &node_list );
3866     EXPECT_HR(hr, S_OK);
3867
3868     hr = IXMLDOMNodeList_get_length( node_list, &len );
3869     EXPECT_HR(hr, S_OK);
3870     ok( len == 4, "len %d\n", len);
3871
3872     hr = IXMLDOMNodeList_get_item( node_list, 2, &node );
3873     EXPECT_HR(hr, S_OK);
3874
3875     hr = IXMLDOMNode_get_childNodes( node, &node_list2 );
3876     EXPECT_HR(hr, S_OK);
3877
3878     hr = IXMLDOMNodeList_get_length( node_list2, &len );
3879     EXPECT_HR(hr, S_OK);
3880     ok( len == 0, "len %d\n", len);
3881
3882     hr = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
3883     EXPECT_HR(hr, S_FALSE);
3884
3885     IXMLDOMNodeList_Release( node_list2 );
3886     IXMLDOMNode_Release( node );
3887     IXMLDOMNodeList_Release( node_list );
3888     IXMLDOMElement_Release( element );
3889
3890     /* test for children of <?xml ..?> node */
3891     hr = IXMLDOMDocument_get_firstChild(doc, &node);
3892     EXPECT_HR(hr, S_OK);
3893
3894     str = NULL;
3895     hr = IXMLDOMNode_get_nodeName(node, &str);
3896     EXPECT_HR(hr, S_OK);
3897     ok(!lstrcmpW(str, _bstr_("xml")), "got %s\n", wine_dbgstr_w(str));
3898     SysFreeString(str);
3899
3900     /* it returns empty but valid node list */
3901     node_list = (void*)0xdeadbeef;
3902     hr = IXMLDOMNode_get_childNodes(node, &node_list);
3903     EXPECT_HR(hr, S_OK);
3904
3905     len = -1;
3906     hr = IXMLDOMNodeList_get_length(node_list, &len);
3907     EXPECT_HR(hr, S_OK);
3908     ok(len == 0, "got %d\n", len);
3909
3910     IXMLDOMNodeList_Release( node_list );
3911     IXMLDOMNode_Release(node);
3912
3913     IXMLDOMDocument_Release( doc );
3914     free_bstrs();
3915 }
3916
3917 static void test_get_firstChild(void)
3918 {
3919     static WCHAR xmlW[] = {'x','m','l',0};
3920     IXMLDOMDocument *doc;
3921     IXMLDOMNode *node;
3922     VARIANT_BOOL b;
3923     HRESULT r;
3924     BSTR str;
3925
3926     doc = create_document(&IID_IXMLDOMDocument);
3927     if (!doc) return;
3928
3929     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3930     ok( r == S_OK, "loadXML failed\n");
3931     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3932
3933     r = IXMLDOMDocument_get_firstChild( doc, &node );
3934     ok( r == S_OK, "ret %08x\n", r);
3935
3936     r = IXMLDOMNode_get_nodeName( node, &str );
3937     ok( r == S_OK, "ret %08x\n", r);
3938
3939     ok(!lstrcmpW(str, xmlW), "expected \"xml\" node name, got %s\n", wine_dbgstr_w(str));
3940
3941     SysFreeString(str);
3942     IXMLDOMNode_Release( node );
3943     IXMLDOMDocument_Release( doc );
3944
3945     free_bstrs();
3946 }
3947
3948 static void test_get_lastChild(void)
3949 {
3950     static WCHAR lcW[] = {'l','c',0};
3951     static WCHAR foW[] = {'f','o',0};
3952     IXMLDOMDocument *doc;
3953     IXMLDOMNode *node, *child;
3954     VARIANT_BOOL b;
3955     HRESULT r;
3956     BSTR str;
3957
3958     doc = create_document(&IID_IXMLDOMDocument);
3959     if (!doc) return;
3960
3961     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3962     ok( r == S_OK, "loadXML failed\n");
3963     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3964
3965     r = IXMLDOMDocument_get_lastChild( doc, &node );
3966     ok( r == S_OK, "ret %08x\n", r);
3967
3968     r = IXMLDOMNode_get_nodeName( node, &str );
3969     ok( r == S_OK, "ret %08x\n", r);
3970
3971     ok(memcmp(str, lcW, sizeof(lcW)) == 0, "expected \"lc\" node name\n");
3972     SysFreeString(str);
3973
3974     r = IXMLDOMNode_get_lastChild( node, &child );
3975     ok( r == S_OK, "ret %08x\n", r);
3976
3977     r = IXMLDOMNode_get_nodeName( child, &str );
3978     ok( r == S_OK, "ret %08x\n", r);
3979
3980     ok(memcmp(str, foW, sizeof(foW)) == 0, "expected \"fo\" node name\n");
3981     SysFreeString(str);
3982
3983     IXMLDOMNode_Release( child );
3984     IXMLDOMNode_Release( node );
3985     IXMLDOMDocument_Release( doc );
3986
3987     free_bstrs();
3988 }
3989
3990 static void test_removeChild(void)
3991 {
3992     HRESULT r;
3993     VARIANT_BOOL b;
3994     IXMLDOMDocument *doc;
3995     IXMLDOMElement *element, *lc_element;
3996     IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
3997     IXMLDOMNodeList *root_list, *fo_list;
3998
3999     doc = create_document(&IID_IXMLDOMDocument);
4000     if (!doc) return;
4001
4002     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4003     ok( r == S_OK, "loadXML failed\n");
4004     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4005
4006     r = IXMLDOMDocument_get_documentElement( doc, &element );
4007     ok( r == S_OK, "ret %08x\n", r);
4008     todo_wine EXPECT_REF(element, 2);
4009
4010     r = IXMLDOMElement_get_childNodes( element, &root_list );
4011     ok( r == S_OK, "ret %08x\n", r);
4012     EXPECT_REF(root_list, 1);
4013
4014     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
4015     ok( r == S_OK, "ret %08x\n", r);
4016     EXPECT_REF(fo_node, 1);
4017
4018     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
4019     ok( r == S_OK, "ret %08x\n", r);
4020     EXPECT_REF(fo_list, 1);
4021
4022     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
4023     ok( r == S_OK, "ret %08x\n", r);
4024     EXPECT_REF(ba_node, 1);
4025
4026     /* invalid parameter: NULL ptr */
4027     removed_node = (void*)0xdeadbeef;
4028     r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
4029     ok( r == E_INVALIDARG, "ret %08x\n", r );
4030     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
4031
4032     /* ba_node is a descendant of element, but not a direct child. */
4033     removed_node = (void*)0xdeadbeef;
4034     EXPECT_REF(ba_node, 1);
4035     EXPECT_CHILDREN(fo_node);
4036     r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
4037     ok( r == E_INVALIDARG, "ret %08x\n", r );
4038     ok( removed_node == NULL, "%p\n", removed_node );
4039     EXPECT_REF(ba_node, 1);
4040     EXPECT_CHILDREN(fo_node);
4041
4042     EXPECT_REF(ba_node, 1);
4043     EXPECT_REF(fo_node, 1);
4044     r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
4045     ok( r == S_OK, "ret %08x\n", r);
4046     ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
4047     EXPECT_REF(fo_node, 2);
4048     EXPECT_REF(ba_node, 1);
4049
4050     /* try removing already removed child */
4051     temp_node = (void*)0xdeadbeef;
4052     r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
4053     ok( r == E_INVALIDARG, "ret %08x\n", r);
4054     ok( temp_node == NULL, "%p\n", temp_node );
4055     IXMLDOMNode_Release( fo_node );
4056
4057     /* the removed node has no parent anymore */
4058     r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
4059     ok( r == S_FALSE, "ret %08x\n", r);
4060     ok( temp_node == NULL, "%p\n", temp_node );
4061
4062     IXMLDOMNode_Release( removed_node );
4063     IXMLDOMNode_Release( ba_node );
4064     IXMLDOMNodeList_Release( fo_list );
4065
4066     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
4067     ok( r == S_OK, "ret %08x\n", r);
4068
4069     r = IXMLDOMElement_QueryInterface( lc_node, &IID_IXMLDOMElement, (void**)&lc_element );
4070     ok( r == S_OK, "ret %08x\n", r);
4071
4072     /* MS quirk: passing wrong interface pointer works, too */
4073     r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
4074     ok( r == S_OK, "ret %08x\n", r);
4075     IXMLDOMElement_Release( lc_element );
4076
4077     temp_node = (void*)0xdeadbeef;
4078     r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
4079     ok( r == S_FALSE, "ret %08x\n", r);
4080     ok( temp_node == NULL, "%p\n", temp_node );
4081
4082     IXMLDOMNode_Release( lc_node );
4083     IXMLDOMNodeList_Release( root_list );
4084     IXMLDOMElement_Release( element );
4085     IXMLDOMDocument_Release( doc );
4086
4087     free_bstrs();
4088 }
4089
4090 static void test_replaceChild(void)
4091 {
4092     HRESULT r;
4093     VARIANT_BOOL b;
4094     IXMLDOMDocument *doc;
4095     IXMLDOMElement *element, *ba_element;
4096     IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
4097     IXMLDOMNodeList *root_list, *fo_list;
4098     IUnknown * unk1, *unk2;
4099     LONG len;
4100
4101     doc = create_document(&IID_IXMLDOMDocument);
4102     if (!doc) return;
4103
4104     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4105     ok( r == S_OK, "loadXML failed\n");
4106     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4107
4108     r = IXMLDOMDocument_get_documentElement( doc, &element );
4109     ok( r == S_OK, "ret %08x\n", r);
4110
4111     r = IXMLDOMElement_get_childNodes( element, &root_list );
4112     ok( r == S_OK, "ret %08x\n", r);
4113
4114     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
4115     ok( r == S_OK, "ret %08x\n", r);
4116
4117     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
4118     ok( r == S_OK, "ret %08x\n", r);
4119
4120     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
4121     ok( r == S_OK, "ret %08x\n", r);
4122
4123     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
4124     ok( r == S_OK, "ret %08x\n", r);
4125
4126     IXMLDOMNodeList_Release( fo_list );
4127
4128     /* invalid parameter: NULL ptr for element to remove */
4129     removed_node = (void*)0xdeadbeef;
4130     r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
4131     ok( r == E_INVALIDARG, "ret %08x\n", r );
4132     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
4133
4134     /* invalid parameter: NULL for replacement element. (Sic!) */
4135     removed_node = (void*)0xdeadbeef;
4136     r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
4137     ok( r == E_INVALIDARG, "ret %08x\n", r );
4138     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
4139
4140     /* invalid parameter: OldNode is not a child */
4141     removed_node = (void*)0xdeadbeef;
4142     r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
4143     ok( r == E_INVALIDARG, "ret %08x\n", r );
4144     ok( removed_node == NULL, "%p\n", removed_node );
4145     IXMLDOMNode_Release( lc_node );
4146
4147     /* invalid parameter: would create loop */
4148     removed_node = (void*)0xdeadbeef;
4149     r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
4150     ok( r == E_FAIL, "ret %08x\n", r );
4151     ok( removed_node == NULL, "%p\n", removed_node );
4152
4153     r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
4154     ok( r == S_OK, "ret %08x\n", r );
4155
4156     r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
4157     ok( r == S_OK, "ret %08x\n", r );
4158
4159     /* ba_node and temp_node refer to the same node, yet they
4160        are different interface pointers */
4161     ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
4162     r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
4163     ok( r == S_OK, "ret %08x\n", r );
4164     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
4165     ok( r == S_OK, "ret %08x\n", r );
4166     todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
4167
4168     IUnknown_Release( unk1 );
4169     IUnknown_Release( unk2 );
4170
4171     /* ba_node should have been removed from below fo_node */
4172     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
4173     ok( r == S_OK, "ret %08x\n", r );
4174
4175     /* MS quirk: replaceChild also accepts elements instead of nodes */
4176     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
4177     ok( r == S_OK, "ret %08x\n", r );
4178     EXPECT_REF(ba_element, 2);
4179
4180     removed_node = NULL;
4181     r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
4182     ok( r == S_OK, "ret %08x\n", r );
4183     ok( removed_node != NULL, "got %p\n", removed_node);
4184     EXPECT_REF(ba_element, 3);
4185     IXMLDOMElement_Release( ba_element );
4186
4187     r = IXMLDOMNodeList_get_length( fo_list, &len);
4188     ok( r == S_OK, "ret %08x\n", r );
4189     ok( len == 0, "len %d\n", len);
4190
4191     IXMLDOMNodeList_Release( fo_list );
4192
4193     IXMLDOMNode_Release(ba_node);
4194     IXMLDOMNode_Release(fo_node);
4195     IXMLDOMNode_Release(temp_node);
4196     IXMLDOMNodeList_Release( root_list );
4197     IXMLDOMElement_Release( element );
4198     IXMLDOMDocument_Release( doc );
4199
4200     free_bstrs();
4201 }
4202
4203 static void test_removeNamedItem(void)
4204 {
4205     IXMLDOMDocument *doc;
4206     IXMLDOMElement *element;
4207     IXMLDOMNode *pr_node, *removed_node, *removed_node2;
4208     IXMLDOMNodeList *root_list;
4209     IXMLDOMNamedNodeMap * pr_attrs;
4210     VARIANT_BOOL b;
4211     BSTR str;
4212     LONG len;
4213     HRESULT r;
4214
4215     doc = create_document(&IID_IXMLDOMDocument);
4216     if (!doc) return;
4217
4218     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4219     ok( r == S_OK, "loadXML failed\n");
4220     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4221
4222     r = IXMLDOMDocument_get_documentElement( doc, &element );
4223     ok( r == S_OK, "ret %08x\n", r);
4224
4225     r = IXMLDOMElement_get_childNodes( element, &root_list );
4226     ok( r == S_OK, "ret %08x\n", r);
4227
4228     r = IXMLDOMNodeList_get_item( root_list, 1, &pr_node );
4229     ok( r == S_OK, "ret %08x\n", r);
4230
4231     r = IXMLDOMNode_get_attributes( pr_node, &pr_attrs );
4232     ok( r == S_OK, "ret %08x\n", r);
4233
4234     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4235     ok( r == S_OK, "ret %08x\n", r);
4236     ok( len == 3, "length %d\n", len);
4237
4238     removed_node = (void*)0xdeadbeef;
4239     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, NULL, &removed_node);
4240     ok ( r == E_INVALIDARG, "ret %08x\n", r);
4241     ok ( removed_node == (void*)0xdeadbeef, "got %p\n", removed_node);
4242
4243     removed_node = (void*)0xdeadbeef;
4244     str = SysAllocString(szvr);
4245     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node);
4246     ok ( r == S_OK, "ret %08x\n", r);
4247
4248     removed_node2 = (void*)0xdeadbeef;
4249     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node2);
4250     ok ( r == S_FALSE, "ret %08x\n", r);
4251     ok ( removed_node2 == NULL, "got %p\n", removed_node2 );
4252
4253     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4254     ok( r == S_OK, "ret %08x\n", r);
4255     ok( len == 2, "length %d\n", len);
4256
4257     r = IXMLDOMNamedNodeMap_setNamedItem( pr_attrs, removed_node, NULL);
4258     ok ( r == S_OK, "ret %08x\n", r);
4259     IXMLDOMNode_Release(removed_node);
4260
4261     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4262     ok( r == S_OK, "ret %08x\n", r);
4263     ok( len == 3, "length %d\n", len);
4264
4265     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
4266     ok ( r == S_OK, "ret %08x\n", r);
4267
4268     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4269     ok( r == S_OK, "ret %08x\n", r);
4270     ok( len == 2, "length %d\n", len);
4271
4272     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
4273     ok ( r == S_FALSE, "ret %08x\n", r);
4274
4275     SysFreeString(str);
4276
4277     IXMLDOMNamedNodeMap_Release( pr_attrs );
4278     IXMLDOMNode_Release( pr_node );
4279     IXMLDOMNodeList_Release( root_list );
4280     IXMLDOMElement_Release( element );
4281     IXMLDOMDocument_Release( doc );
4282
4283     free_bstrs();
4284 }
4285
4286 #define test_IObjectSafety_set(p, r, r2, s, m, e, e2) _test_IObjectSafety_set(__LINE__,p, r, r2, s, m, e, e2)
4287 static void _test_IObjectSafety_set(unsigned line, IObjectSafety *safety, HRESULT result,
4288                                     HRESULT result2, DWORD set, DWORD mask, DWORD expected,
4289                                     DWORD expected2)
4290 {
4291     DWORD enabled, supported;
4292     HRESULT hr;
4293
4294     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL, set, mask);
4295     if (result == result2)
4296         ok_(__FILE__,line)(hr == result, "SetInterfaceSafetyOptions: expected %08x, returned %08x\n", result, hr );
4297     else
4298         ok_(__FILE__,line)(broken(hr == result) || hr == result2,
4299            "SetInterfaceSafetyOptions: expected %08x, got %08x\n", result2, hr );
4300
4301     supported = enabled = 0xCAFECAFE;
4302     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4303     ok(hr == S_OK, "ret %08x\n", hr );
4304     if (expected == expected2)
4305         ok_(__FILE__,line)(enabled == expected, "Expected %08x, got %08x\n", expected, enabled);
4306     else
4307         ok_(__FILE__,line)(broken(enabled == expected) || enabled == expected2,
4308            "Expected %08x, got %08x\n", expected2, enabled);
4309
4310     /* reset the safety options */
4311
4312     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4313             INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER,
4314             0);
4315     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4316
4317     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4318     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4319     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
4320 }
4321
4322 #define test_IObjectSafety_common(s) _test_IObjectSafety_common(__LINE__,s)
4323 static void _test_IObjectSafety_common(unsigned line, IObjectSafety *safety)
4324 {
4325     DWORD enabled = 0, supported = 0;
4326     HRESULT hr;
4327
4328     /* get */
4329     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, NULL, &enabled);
4330     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
4331     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, NULL);
4332     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
4333
4334     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4335     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4336     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4337        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4338         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4339              "got %08x\n", supported);
4340     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
4341
4342     /* set -- individual flags */
4343
4344     test_IObjectSafety_set(safety, S_OK, S_OK,
4345         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4346         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4347
4348     test_IObjectSafety_set(safety, S_OK, S_OK,
4349         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA,
4350         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA);
4351
4352     test_IObjectSafety_set(safety, S_OK, S_OK,
4353         INTERFACE_USES_SECURITY_MANAGER, INTERFACE_USES_SECURITY_MANAGER,
4354         0, INTERFACE_USES_SECURITY_MANAGER /* msxml3 SP8+ */);
4355
4356     /* set INTERFACE_USES_DISPEX  */
4357
4358     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
4359         INTERFACE_USES_DISPEX, INTERFACE_USES_DISPEX,
4360         0, 0);
4361
4362     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
4363         INTERFACE_USES_DISPEX, 0,
4364         0, 0);
4365
4366     test_IObjectSafety_set(safety, S_OK, S_OK /* msxml3 SP8+ */,
4367         0, INTERFACE_USES_DISPEX,
4368         0, 0);
4369
4370     /* set option masking */
4371
4372     test_IObjectSafety_set(safety, S_OK, S_OK,
4373         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4374         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4375         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4376         INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4377
4378     test_IObjectSafety_set(safety, S_OK, S_OK,
4379         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4380         INTERFACESAFE_FOR_UNTRUSTED_DATA,
4381         INTERFACESAFE_FOR_UNTRUSTED_DATA,
4382         INTERFACESAFE_FOR_UNTRUSTED_DATA);
4383
4384     test_IObjectSafety_set(safety, S_OK, S_OK,
4385         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4386         INTERFACE_USES_SECURITY_MANAGER,
4387         0,
4388         0);
4389
4390     /* set -- inheriting previous settings */
4391
4392     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4393                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4394                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4395     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4396     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4397     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4398     ok_(__FILE__,line)(enabled == INTERFACESAFE_FOR_UNTRUSTED_CALLER, "Expected INTERFACESAFE_FOR_UNTRUSTED_CALLER got %08x\n", enabled);
4399     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4400        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4401         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4402              "got %08x\n", supported);
4403
4404     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4405                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA,
4406                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA);
4407     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4408     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4409     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4410     ok_(__FILE__,line)(broken(enabled == INTERFACESAFE_FOR_UNTRUSTED_DATA) ||
4411                        enabled == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA),
4412                        "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA) got %08x\n", enabled);
4413     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4414        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4415         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4416              "got %08x\n", supported);
4417 }
4418
4419 static void test_XMLHTTP(void)
4420 {
4421     static const WCHAR wszBody[] = {'m','o','d','e','=','T','e','s','t',0};
4422     static const WCHAR wszUrl[] = {'h','t','t','p',':','/','/',
4423         'c','r','o','s','s','o','v','e','r','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
4424         'p','o','s','t','t','e','s','t','.','p','h','p',0};
4425     static const WCHAR xmltestW[] = {'h','t','t','p',':','/','/',
4426         'c','r','o','s','s','o','v','e','r','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
4427         'x','m','l','t','e','s','t','.','x','m','l',0};
4428     static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
4429     static const CHAR xmltestbodyA[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<a>TEST</a>\n";
4430
4431     IXMLHttpRequest *xhr;
4432     IObjectSafety *safety;
4433     IObjectWithSite *obj_site, *obj_site2;
4434     BSTR bstrResponse, url;
4435     VARIANT dummy;
4436     VARIANT async;
4437     VARIANT varbody;
4438     LONG state, status, bound;
4439     IDispatch *event;
4440     void *ptr;
4441     HRESULT hr;
4442
4443     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
4444         &IID_IXMLHttpRequest, (void**)&xhr);
4445     if (FAILED(hr))
4446     {
4447         win_skip("IXMLHTTPRequest is not available (0x%08x)\n", hr);
4448         return;
4449     }
4450
4451     VariantInit(&dummy);
4452     V_VT(&dummy) = VT_ERROR;
4453     V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
4454     VariantInit(&async);
4455     V_VT(&async) = VT_BOOL;
4456     V_BOOL(&async) = VARIANT_FALSE;
4457     V_VT(&varbody) = VT_BSTR;
4458     V_BSTR(&varbody) = SysAllocString(wszBody);
4459
4460     url = SysAllocString(wszUrl);
4461
4462     hr = IXMLHttpRequest_put_onreadystatechange(xhr, NULL);
4463     EXPECT_HR(hr, S_OK);
4464
4465     hr = IXMLHttpRequest_abort(xhr);
4466     EXPECT_HR(hr, S_OK);
4467
4468     /* send before open */
4469     hr = IXMLHttpRequest_send(xhr, dummy);
4470     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4471
4472     /* initial status code */
4473     hr = IXMLHttpRequest_get_status(xhr, NULL);
4474     EXPECT_HR(hr, E_INVALIDARG);
4475
4476     status = 0xdeadbeef;
4477     hr = IXMLHttpRequest_get_status(xhr, &status);
4478     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4479     ok(status == 0xdeadbeef, "got %d\n", status);
4480
4481     /* invalid parameters */
4482     hr = IXMLHttpRequest_open(xhr, NULL, NULL, async, dummy, dummy);
4483     EXPECT_HR(hr, E_INVALIDARG);
4484
4485     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), NULL, async, dummy, dummy);
4486     EXPECT_HR(hr, E_INVALIDARG);
4487
4488     hr = IXMLHttpRequest_open(xhr, NULL, url, async, dummy, dummy);
4489     EXPECT_HR(hr, E_INVALIDARG);
4490
4491     hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, NULL);
4492     EXPECT_HR(hr, E_INVALIDARG);
4493
4494     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), NULL);
4495     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4496
4497     hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
4498     EXPECT_HR(hr, E_INVALIDARG);
4499
4500     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
4501     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4502
4503     hr = IXMLHttpRequest_get_readyState(xhr, NULL);
4504     EXPECT_HR(hr, E_INVALIDARG);
4505
4506     state = -1;
4507     hr = IXMLHttpRequest_get_readyState(xhr, &state);
4508     EXPECT_HR(hr, S_OK);
4509     ok(state == READYSTATE_UNINITIALIZED, "got %d, expected READYSTATE_UNINITIALIZED\n", state);
4510
4511     event = create_dispevent();
4512
4513     EXPECT_REF(event, 1);
4514     hr = IXMLHttpRequest_put_onreadystatechange(xhr, event);
4515     EXPECT_HR(hr, S_OK);
4516     EXPECT_REF(event, 2);
4517
4518     g_unexpectedcall = g_expectedcall = 0;
4519
4520     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), url, async, dummy, dummy);
4521     EXPECT_HR(hr, S_OK);
4522
4523     ok(g_unexpectedcall == 0, "unexpected disp event call\n");
4524     ok(g_expectedcall == 1 || broken(g_expectedcall == 0) /* win2k */, "no expected disp event call\n");
4525
4526     /* status code after ::open() */
4527     status = 0xdeadbeef;
4528     hr = IXMLHttpRequest_get_status(xhr, &status);
4529     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4530     ok(status == 0xdeadbeef, "got %d\n", status);
4531
4532     state = -1;
4533     hr = IXMLHttpRequest_get_readyState(xhr, &state);
4534     EXPECT_HR(hr, S_OK);
4535     ok(state == READYSTATE_LOADING, "got %d, expected READYSTATE_LOADING\n", state);
4536
4537     hr = IXMLHttpRequest_abort(xhr);
4538     EXPECT_HR(hr, S_OK);
4539
4540     state = -1;
4541     hr = IXMLHttpRequest_get_readyState(xhr, &state);
4542     EXPECT_HR(hr, S_OK);
4543     ok(state == READYSTATE_UNINITIALIZED || broken(state == READYSTATE_LOADING) /* win2k */,
4544         "got %d, expected READYSTATE_UNINITIALIZED\n", state);
4545
4546     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), url, async, dummy, dummy);
4547     EXPECT_HR(hr, S_OK);
4548
4549     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
4550     EXPECT_HR(hr, S_OK);
4551
4552     hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
4553     EXPECT_HR(hr, E_INVALIDARG);
4554
4555     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_(""), _bstr_("value1"));
4556     EXPECT_HR(hr, E_INVALIDARG);
4557
4558     SysFreeString(url);
4559
4560     hr = IXMLHttpRequest_send(xhr, varbody);
4561     if (hr == INET_E_RESOURCE_NOT_FOUND)
4562     {
4563         skip("No connection could be made with crossover.codeweavers.com\n");
4564         IXMLHttpRequest_Release(xhr);
4565         return;
4566     }
4567     EXPECT_HR(hr, S_OK);
4568
4569     /* status code after ::send() */
4570     status = 0xdeadbeef;
4571     hr = IXMLHttpRequest_get_status(xhr, &status);
4572     EXPECT_HR(hr, S_OK);
4573     ok(status == 200, "got %d\n", status);
4574
4575     /* another ::send() after completed request */
4576     hr = IXMLHttpRequest_send(xhr, varbody);
4577     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4578
4579     VariantClear(&varbody);
4580
4581     hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
4582     EXPECT_HR(hr, S_OK);
4583     /* the server currently returns "FAILED" because the Content-Type header is
4584      * not what the server expects */
4585     if(hr == S_OK)
4586     {
4587         ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)),
4588             "expected %s, got %s\n", wine_dbgstr_w(wszExpectedResponse), wine_dbgstr_w(bstrResponse));
4589         SysFreeString(bstrResponse);
4590     }
4591
4592     /* GET request */
4593     url = SysAllocString(xmltestW);
4594
4595     hr = IXMLHttpRequest_open(xhr, _bstr_("GET"), url, async, dummy, dummy);
4596     EXPECT_HR(hr, S_OK);
4597
4598     V_VT(&varbody) = VT_EMPTY;
4599
4600     hr = IXMLHttpRequest_send(xhr, varbody);
4601     if (hr == INET_E_RESOURCE_NOT_FOUND)
4602     {
4603         skip("No connection could be made with crossover.codeweavers.com\n");
4604         IXMLHttpRequest_Release(xhr);
4605         return;
4606     }
4607     EXPECT_HR(hr, S_OK);
4608
4609     hr = IXMLHttpRequest_get_responseText(xhr, NULL);
4610     EXPECT_HR(hr, E_INVALIDARG);
4611
4612     hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
4613     EXPECT_HR(hr, S_OK);
4614     ok(!memcmp(bstrResponse, _bstr_(xmltestbodyA), sizeof(xmltestbodyA)*sizeof(WCHAR)),
4615         "expected %s, got %s\n", xmltestbodyA, wine_dbgstr_w(bstrResponse));
4616     SysFreeString(bstrResponse);
4617
4618     hr = IXMLHttpRequest_get_responseBody(xhr, NULL);
4619     EXPECT_HR(hr, E_INVALIDARG);
4620
4621     V_VT(&varbody) = VT_EMPTY;
4622     hr = IXMLHttpRequest_get_responseBody(xhr, &varbody);
4623     EXPECT_HR(hr, S_OK);
4624     ok(V_VT(&varbody) == (VT_ARRAY|VT_UI1), "got type %d, expected %d\n", V_VT(&varbody), VT_ARRAY|VT_UI1);
4625     ok(SafeArrayGetDim(V_ARRAY(&varbody)) == 1, "got %d, expected one dimension\n", SafeArrayGetDim(V_ARRAY(&varbody)));
4626
4627     bound = -1;
4628     hr = SafeArrayGetLBound(V_ARRAY(&varbody), 1, &bound);
4629     EXPECT_HR(hr, S_OK);
4630     ok(bound == 0, "got %d, expected zero bound\n", bound);
4631
4632     hr = SafeArrayAccessData(V_ARRAY(&varbody), &ptr);
4633     EXPECT_HR(hr, S_OK);
4634     ok(memcmp(ptr, xmltestbodyA, sizeof(xmltestbodyA)-1) == 0, "got wrong body data\n");
4635     SafeArrayUnaccessData(V_ARRAY(&varbody));
4636
4637     VariantClear(&varbody);
4638
4639     SysFreeString(url);
4640
4641     hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectSafety, (void**)&safety);
4642     EXPECT_HR(hr, S_OK);
4643     if(hr == S_OK)
4644     {
4645         test_IObjectSafety_common(safety);
4646         IObjectSafety_Release(safety);
4647     }
4648
4649     IDispatch_Release(event);
4650
4651     /* interaction with object site */
4652     EXPECT_REF(xhr, 1);
4653     hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site);
4654     EXPECT_HR(hr, S_OK);
4655 todo_wine {
4656     EXPECT_REF(xhr, 1);
4657     EXPECT_REF(obj_site, 1);
4658 }
4659
4660     IObjectWithSite_AddRef(obj_site);
4661 todo_wine {
4662     EXPECT_REF(obj_site, 2);
4663     EXPECT_REF(xhr, 1);
4664 }
4665     IObjectWithSite_Release(obj_site);
4666
4667     hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site2);
4668     EXPECT_HR(hr, S_OK);
4669 todo_wine {
4670     EXPECT_REF(xhr, 1);
4671     EXPECT_REF(obj_site, 1);
4672     EXPECT_REF(obj_site2, 1);
4673     ok(obj_site != obj_site2, "expected new instance\n");
4674 }
4675     SET_EXPECT(site_qi_IServiceProvider);
4676     SET_EXPECT(sp_queryservice_SID_SBindHost);
4677     SET_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
4678     SET_EXPECT(sp_queryservice_SID_secmgr_htmldoc2);
4679     SET_EXPECT(sp_queryservice_SID_secmgr_xmldomdoc);
4680     SET_EXPECT(sp_queryservice_SID_secmgr_secmgr);
4681
4682     /* calls to IHTMLDocument2 */
4683     SET_EXPECT(htmldoc2_get_all);
4684     SET_EXPECT(collection_get_length);
4685     SET_EXPECT(htmldoc2_get_url);
4686
4687     SET_EXPECT(site_qi_IXMLDOMDocument);
4688     SET_EXPECT(site_qi_IOleClientSite);
4689
4690     hr = IObjectWithSite_SetSite(obj_site, &testsite.IUnknown_iface);
4691     EXPECT_HR(hr, S_OK);
4692
4693 todo_wine{
4694     CHECK_CALLED(site_qi_IServiceProvider);
4695
4696     CHECK_CALLED(sp_queryservice_SID_SBindHost);
4697     CHECK_CALLED(sp_queryservice_SID_SContainerDispatch_htmldoc2);
4698     CHECK_CALLED(sp_queryservice_SID_secmgr_htmldoc2);
4699     CHECK_CALLED(sp_queryservice_SID_secmgr_xmldomdoc);
4700     /* this one isn't very reliable
4701     CHECK_CALLED(sp_queryservice_SID_secmgr_secmgr); */
4702
4703     CHECK_CALLED(htmldoc2_get_all);
4704     CHECK_CALLED(collection_get_length);
4705     CHECK_CALLED(htmldoc2_get_url);
4706
4707     CHECK_CALLED(site_qi_IXMLDOMDocument);
4708     CHECK_CALLED(site_qi_IOleClientSite);
4709 }
4710     IObjectWithSite_Release(obj_site);
4711
4712     todo_wine EXPECT_REF(xhr, 1);
4713     IXMLHttpRequest_Release(xhr);
4714
4715     /* still works after request is released */
4716     SET_EXPECT(site_qi_IServiceProvider);
4717
4718     hr = IObjectWithSite_SetSite(obj_site2, &testsite.IUnknown_iface);
4719     EXPECT_HR(hr, S_OK);
4720     IObjectWithSite_Release(obj_site2);
4721
4722     free_bstrs();
4723 }
4724
4725 static void test_IXMLDOMDocument2(void)
4726 {
4727     static const WCHAR emptyW[] = {0};
4728     IXMLDOMDocument2 *doc2, *dtddoc2;
4729     IXMLDOMDocument *doc;
4730     IXMLDOMParseError* err;
4731     IDispatchEx *dispex;
4732     VARIANT_BOOL b;
4733     VARIANT var;
4734     HRESULT r;
4735     LONG res;
4736
4737     doc = create_document(&IID_IXMLDOMDocument);
4738     if (!doc) return;
4739
4740     dtddoc2 = create_document(&IID_IXMLDOMDocument2);
4741     if (!dtddoc2)
4742     {
4743         IXMLDOMDocument_Release(doc);
4744         return;
4745     }
4746
4747     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
4748     ok( r == S_OK, "ret %08x\n", r );
4749     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
4750
4751     ole_expect(IXMLDOMDocument2_get_readyState(doc2, NULL), E_INVALIDARG);
4752     ole_check(IXMLDOMDocument2_get_readyState(doc2, &res));
4753     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
4754
4755     err = NULL;
4756     ole_expect(IXMLDOMDocument2_validate(doc2, NULL), S_FALSE);
4757     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
4758     ok(err != NULL, "expected a pointer\n");
4759     if (err)
4760     {
4761         res = 0;
4762         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4763         /* XML_E_NOTWF */
4764         ok(res == E_XML_NOTWF, "got %08x\n", res);
4765         IXMLDOMParseError_Release(err);
4766     }
4767
4768     r = IXMLDOMDocument_loadXML( doc2, _bstr_(complete4A), &b );
4769     ok( r == S_OK, "loadXML failed\n");
4770     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4771
4772     ole_check(IXMLDOMDocument2_get_readyState(doc, &res));
4773     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
4774
4775     err = NULL;
4776     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
4777     ok(err != NULL, "expected a pointer\n");
4778     if (err)
4779     {
4780         res = 0;
4781         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4782         /* XML_E_NODTD */
4783         ok(res == E_XML_NODTD, "got %08x\n", res);
4784         IXMLDOMParseError_Release(err);
4785     }
4786
4787     r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
4788     ok( r == S_OK, "ret %08x\n", r );
4789     if(r == S_OK)
4790     {
4791         IDispatchEx_Release(dispex);
4792     }
4793
4794     /* we will check if the variant got cleared */
4795     IXMLDOMDocument2_AddRef(doc2);
4796     EXPECT_REF(doc2, 3); /* doc, doc2, AddRef*/
4797
4798     V_VT(&var) = VT_UNKNOWN;
4799     V_UNKNOWN(&var) = (IUnknown *)doc2;
4800
4801     /* invalid calls */
4802     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
4803     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
4804     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
4805
4806     /* valid call */
4807     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
4808     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
4809     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
4810     V_VT(&var) = VT_R4;
4811
4812     /* the variant didn't get cleared*/
4813     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
4814
4815     /* setProperty tests */
4816     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
4817     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
4818     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
4819     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
4820     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4821     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
4822
4823     V_VT(&var) = VT_BSTR;
4824     V_BSTR(&var) = SysAllocString(emptyW);
4825     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
4826     ok(r == S_OK, "got 0x%08x\n", r);
4827     VariantClear(&var);
4828
4829     V_VT(&var) = VT_I2;
4830     V_I2(&var) = 0;
4831     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
4832     ok(r == E_FAIL, "got 0x%08x\n", r);
4833
4834     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
4835     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
4836     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
4837     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
4838
4839     IXMLDOMDocument2_Release( doc2 );
4840     IXMLDOMDocument_Release( doc );
4841
4842     /* DTD validation */
4843     ole_check(IXMLDOMDocument2_put_validateOnParse(dtddoc2, VARIANT_FALSE));
4844     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML), &b));
4845     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4846     err = NULL;
4847     ole_check(IXMLDOMDocument2_validate(dtddoc2, &err));
4848     ok(err != NULL, "expected pointer\n");
4849     if (err)
4850     {
4851         res = 0;
4852         ole_expect(IXMLDOMParseError_get_errorCode(err, &res), S_FALSE);
4853         ok(res == 0, "got %08x\n", res);
4854         IXMLDOMParseError_Release(err);
4855     }
4856
4857     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0D), &b));
4858     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4859     err = NULL;
4860     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4861     ok(err != NULL, "expected pointer\n");
4862     if (err)
4863     {
4864         res = 0;
4865         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4866         /* XML_ELEMENT_UNDECLARED */
4867         todo_wine ok(res == 0xC00CE00D, "got %08x\n", res);
4868         IXMLDOMParseError_Release(err);
4869     }
4870
4871     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0E), &b));
4872     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4873     err = NULL;
4874     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4875     ok(err != NULL, "expected pointer\n");
4876     if (err)
4877     {
4878         res = 0;
4879         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4880         /* XML_ELEMENT_ID_NOT_FOUND */
4881         todo_wine ok(res == 0xC00CE00E, "got %08x\n", res);
4882         IXMLDOMParseError_Release(err);
4883     }
4884
4885     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_11), &b));
4886     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4887     err = NULL;
4888     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4889     ok(err != NULL, "expected pointer\n");
4890     if (err)
4891     {
4892         res = 0;
4893         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4894         /* XML_EMPTY_NOT_ALLOWED */
4895         todo_wine ok(res == 0xC00CE011, "got %08x\n", res);
4896         IXMLDOMParseError_Release(err);
4897     }
4898
4899     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_13), &b));
4900     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4901     err = NULL;
4902     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4903     ok(err != NULL, "expected pointer\n");
4904     if (err)
4905     {
4906         res = 0;
4907         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4908         /* XML_ROOT_NAME_MISMATCH */
4909         todo_wine ok(res == 0xC00CE013, "got %08x\n", res);
4910         IXMLDOMParseError_Release(err);
4911     }
4912
4913     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_14), &b));
4914     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4915     err = NULL;
4916     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4917     ok(err != NULL, "expected pointer\n");
4918     if (err)
4919     {
4920         res = 0;
4921         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4922         /* XML_INVALID_CONTENT */
4923         todo_wine ok(res == 0xC00CE014, "got %08x\n", res);
4924         IXMLDOMParseError_Release(err);
4925     }
4926
4927     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_15), &b));
4928     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4929     err = NULL;
4930     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4931     ok(err != NULL, "expected pointer\n");
4932     if (err)
4933     {
4934         res = 0;
4935         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4936         /* XML_ATTRIBUTE_NOT_DEFINED */
4937         todo_wine ok(res == 0xC00CE015, "got %08x\n", res);
4938         IXMLDOMParseError_Release(err);
4939     }
4940
4941     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_16), &b));
4942     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4943     err = NULL;
4944     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4945     ok(err != NULL, "expected pointer\n");
4946     if (err)
4947     {
4948         res = 0;
4949         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4950         /* XML_ATTRIBUTE_FIXED */
4951         todo_wine ok(res == 0xC00CE016, "got %08x\n", res);
4952         IXMLDOMParseError_Release(err);
4953     }
4954
4955     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_17), &b));
4956     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4957     err = NULL;
4958     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4959     ok(err != NULL, "expected pointer\n");
4960     if (err)
4961     {
4962         res = 0;
4963         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4964         /* XML_ATTRIBUTE_VALUE */
4965         todo_wine ok(res == 0xC00CE017, "got %08x\n", res);
4966         IXMLDOMParseError_Release(err);
4967     }
4968
4969     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_18), &b));
4970     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4971     err = NULL;
4972     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4973     ok(err != NULL, "expected pointer\n");
4974     if (err)
4975     {
4976         res = 0;
4977         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4978         /* XML_ILLEGAL_TEXT */
4979         todo_wine ok(res == 0xC00CE018, "got %08x\n", res);
4980         IXMLDOMParseError_Release(err);
4981     }
4982
4983     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_20), &b));
4984     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4985     err = NULL;
4986     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4987     ok(err != NULL, "expected pointer\n");
4988     if (err)
4989     {
4990         res = 0;
4991         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4992         /* XML_REQUIRED_ATTRIBUTE_MISSING */
4993         todo_wine ok(res == 0xC00CE020, "got %08x\n", res);
4994         IXMLDOMParseError_Release(err);
4995     }
4996
4997     IXMLDOMDocument2_Release( dtddoc2 );
4998     free_bstrs();
4999 }
5000
5001 #define helper_ole_check(expr) { \
5002     HRESULT r = expr; \
5003     ok_(__FILE__, line)(r == S_OK, "=> %i: " #expr " returned %08x\n", __LINE__, r); \
5004 }
5005
5006 #define helper_expect_list_and_release(list, expstr) { \
5007     char *str = list_to_string(list); \
5008     ok_(__FILE__, line)(strcmp(str, expstr)==0, "=> %i: Invalid node list: %s, expected %s\n", __LINE__, str, expstr); \
5009     if (list) IXMLDOMNodeList_Release(list); \
5010 }
5011
5012 #define helper_expect_bstr_and_release(bstr, str) { \
5013     ok_(__FILE__, line)(lstrcmpW(bstr, _bstr_(str)) == 0, \
5014        "=> %i: got %s\n", __LINE__, wine_dbgstr_w(bstr)); \
5015     SysFreeString(bstr); \
5016 }
5017
5018 #define check_ws_ignored(doc, str) _check_ws_ignored(__LINE__, doc, str)
5019 static inline void _check_ws_ignored(int line, IXMLDOMDocument2* doc, char const* str)
5020 {
5021     IXMLDOMNode *node1, *node2;
5022     IXMLDOMNodeList *list;
5023     BSTR bstr;
5024
5025     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
5026     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
5027     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
5028     helper_ole_check(IXMLDOMNodeList_reset(list));
5029     helper_expect_list_and_release(list, "E1.E4.E1.E2.D1 E2.E4.E1.E2.D1");
5030
5031     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
5032     helper_expect_list_and_release(list, "T1.E1.E4.E1.E2.D1 E2.E1.E4.E1.E2.D1 E3.E1.E4.E1.E2.D1 T4.E1.E4.E1.E2.D1 E5.E1.E4.E1.E2.D1");
5033     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
5034     if (str)
5035     {
5036         helper_expect_bstr_and_release(bstr, str);
5037     }
5038     else
5039     {
5040         helper_expect_bstr_and_release(bstr, "This is a description.");
5041     }
5042     IXMLDOMNode_Release(node1);
5043
5044     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
5045     helper_expect_list_and_release(list, "T1.E2.E4.E1.E2.D1 E2.E2.E4.E1.E2.D1 T3.E2.E4.E1.E2.D1 E4.E2.E4.E1.E2.D1 T5.E2.E4.E1.E2.D1 E6.E2.E4.E1.E2.D1 T7.E2.E4.E1.E2.D1");
5046     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
5047     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
5048     IXMLDOMNode_Release(node2);
5049 }
5050
5051 #define check_ws_preserved(doc, str) _check_ws_preserved(__LINE__, doc, str)
5052 static inline void _check_ws_preserved(int line, IXMLDOMDocument2* doc, char const* str)
5053 {
5054     IXMLDOMNode *node1, *node2;
5055     IXMLDOMNodeList *list;
5056     BSTR bstr;
5057
5058     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
5059     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
5060     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
5061     helper_ole_check(IXMLDOMNodeList_reset(list));
5062     helper_expect_list_and_release(list, "E2.E8.E2.E2.D1 E4.E8.E2.E2.D1");
5063
5064     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
5065     helper_expect_list_and_release(list, "T1.E2.E8.E2.E2.D1 E2.E2.E8.E2.E2.D1 T3.E2.E8.E2.E2.D1 E4.E2.E8.E2.E2.D1 T5.E2.E8.E2.E2.D1 E6.E2.E8.E2.E2.D1 T7.E2.E8.E2.E2.D1");
5066     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
5067     if (str)
5068     {
5069         helper_expect_bstr_and_release(bstr, str);
5070     }
5071     else
5072     {
5073         helper_expect_bstr_and_release(bstr, "\n                This is a description. \n            ");
5074     }
5075     IXMLDOMNode_Release(node1);
5076
5077     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
5078     helper_expect_list_and_release(list, "T1.E4.E8.E2.E2.D1 E2.E4.E8.E2.E2.D1 T3.E4.E8.E2.E2.D1 E4.E4.E8.E2.E2.D1 T5.E4.E8.E2.E2.D1 E6.E4.E8.E2.E2.D1 T7.E4.E8.E2.E2.D1");
5079     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
5080     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
5081     IXMLDOMNode_Release(node2);
5082 }
5083
5084 static void test_whitespace(void)
5085 {
5086     VARIANT_BOOL b;
5087     IXMLDOMDocument2 *doc1, *doc2, *doc3, *doc4;
5088
5089     doc1 = create_document(&IID_IXMLDOMDocument2);
5090     doc2 = create_document(&IID_IXMLDOMDocument2);
5091     if (!doc1 || !doc2) return;
5092
5093     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_TRUE));
5094     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
5095     ok(b == VARIANT_FALSE, "expected false\n");
5096     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
5097     ok(b == VARIANT_TRUE, "expected true\n");
5098
5099     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
5100     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5101     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
5102     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5103
5104     /* switch to XPath */
5105     ole_check(IXMLDOMDocument2_setProperty(doc1, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5106     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5107
5108     check_ws_ignored(doc1, NULL);
5109     check_ws_preserved(doc2, NULL);
5110
5111     /* new instances copy the property */
5112     ole_check(IXMLDOMDocument2_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**) &doc3));
5113     ole_check(IXMLDOMDocument2_QueryInterface(doc2, &IID_IXMLDOMDocument2, (void**) &doc4));
5114
5115     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
5116     ok(b == VARIANT_FALSE, "expected false\n");
5117     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
5118     ok(b == VARIANT_TRUE, "expected true\n");
5119
5120     check_ws_ignored(doc3, NULL);
5121     check_ws_preserved(doc4, NULL);
5122
5123     /* setting after loading xml affects trimming of leading/trailing ws only */
5124     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_TRUE));
5125     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_FALSE));
5126
5127     /* the trailing "\n            " isn't there, because it was ws-only node */
5128     check_ws_ignored(doc1, "\n                This is a description. ");
5129     check_ws_preserved(doc2, "This is a description.");
5130
5131     /* it takes effect on reload */
5132     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
5133     ok(b == VARIANT_TRUE, "expected true\n");
5134     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
5135     ok(b == VARIANT_FALSE, "expected false\n");
5136
5137     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
5138     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5139     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
5140     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5141
5142     check_ws_preserved(doc1, NULL);
5143     check_ws_ignored(doc2, NULL);
5144
5145     /* other instances follow suit */
5146     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
5147     ok(b == VARIANT_TRUE, "expected true\n");
5148     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
5149     ok(b == VARIANT_FALSE, "expected false\n");
5150
5151     check_ws_preserved(doc3, NULL);
5152     check_ws_ignored(doc4, NULL);
5153
5154     IXMLDOMDocument_Release(doc1);
5155     IXMLDOMDocument_Release(doc2);
5156     IXMLDOMDocument_Release(doc3);
5157     IXMLDOMDocument_Release(doc4);
5158     free_bstrs();
5159 }
5160
5161 static void test_XPath(void)
5162 {
5163     VARIANT var;
5164     VARIANT_BOOL b;
5165     IXMLDOMDocument2 *doc;
5166     IXMLDOMDocument *doc2;
5167     IXMLDOMNode *rootNode;
5168     IXMLDOMNode *elem1Node;
5169     IXMLDOMNode *node;
5170     IXMLDOMNodeList *list;
5171     IXMLDOMElement *elem;
5172     IXMLDOMAttribute *attr;
5173     HRESULT hr;
5174     BSTR str;
5175
5176     doc = create_document(&IID_IXMLDOMDocument2);
5177     if (!doc) return;
5178
5179     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b));
5180     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5181
5182     /* switch to XPath */
5183     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5184
5185     /* some simple queries*/
5186     EXPECT_REF(doc, 1);
5187     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5188     EXPECT_HR(hr, S_OK);
5189     EXPECT_REF(doc, 1);
5190     EXPECT_LIST_LEN(list, 1);
5191
5192     EXPECT_REF(list, 1);
5193     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5194     EXPECT_HR(hr, S_OK);
5195     EXPECT_REF(list, 1);
5196     EXPECT_REF(rootNode, 1);
5197
5198     hr = IXMLDOMNodeList_reset(list);
5199     EXPECT_HR(hr, S_OK);
5200     expect_list_and_release(list, "E2.D1");
5201
5202     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//c"), &list));
5203     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
5204
5205     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//c[@type]"), &list));
5206     expect_list_and_release(list, "E3.E2.E2.D1");
5207
5208     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
5209     /* using get_item for query results advances the position */
5210     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
5211     expect_node(node, "E2.E2.D1");
5212     IXMLDOMNode_Release(node);
5213     ole_check(IXMLDOMNodeList_nextNode(list, &node));
5214     expect_node(node, "E4.E2.D1");
5215     IXMLDOMNode_Release(node);
5216     ole_check(IXMLDOMNodeList_reset(list));
5217     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
5218
5219     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
5220     expect_list_and_release(list, "E2.D1");
5221
5222     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
5223     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
5224     ole_check(IXMLDOMNodeList_reset(list));
5225     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
5226
5227     /* select an attribute */
5228     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
5229     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
5230
5231     /* would evaluate to a number */
5232     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
5233     /* would evaluate to a boolean */
5234     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
5235     /* would evaluate to a string */
5236     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
5237
5238     /* no results */
5239     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
5240     expect_list_and_release(list, "");
5241     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("elem//c"), &list));
5242     expect_list_and_release(list, "");
5243     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//elem[4]"), &list));
5244     expect_list_and_release(list, "");
5245     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//elem[0]"), &list));
5246     expect_list_and_release(list, "");
5247
5248     /* foo undeclared in document node */
5249     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5250     /* undeclared in <root> node */
5251     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
5252     /* undeclared in <elem> node */
5253     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
5254     /* but this trick can be used */
5255     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
5256     expect_list_and_release(list, "E3.E4.E2.D1");
5257
5258     /* it has to be declared in SelectionNamespaces */
5259     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5260         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
5261
5262     /* now the namespace can be used */
5263     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list));
5264     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5265     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
5266     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5267     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
5268     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5269     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
5270     expect_list_and_release(list, "E5.E1.E4.E1.E2.D1 E6.E2.E4.E1.E2.D1");
5271
5272     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
5273     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5274         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
5275
5276     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5277
5278     VariantInit(&var);
5279     ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
5280     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
5281     if (V_VT(&var) == VT_BSTR)
5282         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
5283
5284     /* extra attributes - same thing*/
5285     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5286         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
5287     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5288
5289     IXMLDOMNode_Release(rootNode);
5290     IXMLDOMNode_Release(elem1Node);
5291
5292     /* alter document with already built list */
5293     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5294     EXPECT_HR(hr, S_OK);
5295     EXPECT_LIST_LEN(list, 1);
5296
5297     hr = IXMLDOMDocument2_get_lastChild(doc, &rootNode);
5298     EXPECT_HR(hr, S_OK);
5299     EXPECT_REF(rootNode, 1);
5300     EXPECT_REF(doc, 1);
5301
5302     hr = IXMLDOMDocument2_removeChild(doc, rootNode, NULL);
5303     EXPECT_HR(hr, S_OK);
5304     IXMLDOMNode_Release(rootNode);
5305
5306     EXPECT_LIST_LEN(list, 1);
5307
5308     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5309     EXPECT_HR(hr, S_OK);
5310     EXPECT_REF(rootNode, 1);
5311
5312     IXMLDOMNodeList_Release(list);
5313
5314     hr = IXMLDOMNode_get_nodeName(rootNode, &str);
5315     EXPECT_HR(hr, S_OK);
5316     ok(!lstrcmpW(str, _bstr_("root")), "got %s\n", wine_dbgstr_w(str));
5317     SysFreeString(str);
5318     IXMLDOMNode_Release(rootNode);
5319
5320     /* alter node from list and get it another time */
5321     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5322     EXPECT_HR(hr, S_OK);
5323     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5324
5325     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5326     EXPECT_HR(hr, S_OK);
5327     EXPECT_LIST_LEN(list, 1);
5328
5329     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5330     EXPECT_HR(hr, S_OK);
5331
5332     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
5333     EXPECT_HR(hr, S_OK);
5334
5335     V_VT(&var) = VT_I2;
5336     V_I2(&var) = 1;
5337     hr = IXMLDOMElement_setAttribute(elem, _bstr_("attrtest"), var);
5338     EXPECT_HR(hr, S_OK);
5339     IXMLDOMElement_Release(elem);
5340     IXMLDOMNode_Release(rootNode);
5341
5342     /* now check attribute to be present */
5343     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5344     EXPECT_HR(hr, S_OK);
5345
5346     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
5347     EXPECT_HR(hr, S_OK);
5348
5349     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
5350     EXPECT_HR(hr, S_OK);
5351     IXMLDOMAttribute_Release(attr);
5352
5353     IXMLDOMElement_Release(elem);
5354     IXMLDOMNode_Release(rootNode);
5355
5356     /* and now check for attribute in original document */
5357     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
5358     EXPECT_HR(hr, S_OK);
5359
5360     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
5361     EXPECT_HR(hr, S_OK);
5362     IXMLDOMAttribute_Release(attr);
5363
5364     IXMLDOMElement_Release(elem);
5365
5366     /* attach node from list to another document */
5367     doc2 = create_document(&IID_IXMLDOMDocument);
5368
5369     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5370     EXPECT_HR(hr, S_OK);
5371     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5372
5373     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5374     EXPECT_HR(hr, S_OK);
5375     EXPECT_LIST_LEN(list, 1);
5376
5377     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5378     EXPECT_HR(hr, S_OK);
5379     EXPECT_REF(rootNode, 1);
5380
5381     hr = IXMLDOMDocument_appendChild(doc2, rootNode, NULL);
5382     EXPECT_HR(hr, S_OK);
5383     EXPECT_REF(rootNode, 1);
5384     EXPECT_REF(doc2, 1);
5385     EXPECT_REF(list, 1);
5386
5387     EXPECT_LIST_LEN(list, 1);
5388
5389     IXMLDOMNode_Release(rootNode);
5390     IXMLDOMNodeList_Release(list);
5391     IXMLDOMDocument_Release(doc2);
5392
5393     IXMLDOMDocument2_Release(doc);
5394     free_bstrs();
5395 }
5396
5397 static void test_cloneNode(void )
5398 {
5399     IXMLDOMDocument *doc, *doc2;
5400     VARIANT_BOOL b;
5401     IXMLDOMNodeList *pList;
5402     IXMLDOMNamedNodeMap *mapAttr;
5403     LONG length, length1;
5404     LONG attr_cnt, attr_cnt1;
5405     IXMLDOMNode *node;
5406     IXMLDOMNode *node_clone;
5407     IXMLDOMNode *node_first;
5408     HRESULT hr;
5409
5410     doc = create_document(&IID_IXMLDOMDocument);
5411     if (!doc) return;
5412
5413     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b));
5414     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5415
5416     hr = IXMLDOMNode_selectSingleNode(doc, _bstr_("lc/pr"), &node);
5417     ok( hr == S_OK, "ret %08x\n", hr );
5418     ok( node != NULL, "node %p\n", node );
5419
5420     /* Check invalid parameter */
5421     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
5422     ok( hr == E_INVALIDARG, "ret %08x\n", hr );
5423
5424     /* All Children */
5425     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
5426     ok( hr == S_OK, "ret %08x\n", hr );
5427     ok( node_clone != NULL, "node %p\n", node );
5428
5429     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
5430     ok( hr == S_OK, "ret %08x\n", hr );
5431     hr = IXMLDOMNode_get_ownerDocument(node_clone, &doc2);
5432     ok( hr == S_OK, "ret %08x\n", hr );
5433     IXMLDOMDocument_Release(doc2);
5434     IXMLDOMNode_Release(node_first);
5435
5436     hr = IXMLDOMNode_get_childNodes(node, &pList);
5437     ok( hr == S_OK, "ret %08x\n", hr );
5438     length = 0;
5439     hr = IXMLDOMNodeList_get_length(pList, &length);
5440     ok( hr == S_OK, "ret %08x\n", hr );
5441     ok(length == 1, "got %d\n", length);
5442     IXMLDOMNodeList_Release(pList);
5443
5444     hr = IXMLDOMNode_get_attributes(node, &mapAttr);
5445     ok( hr == S_OK, "ret %08x\n", hr );
5446     attr_cnt = 0;
5447     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt);
5448     ok( hr == S_OK, "ret %08x\n", hr );
5449     ok(attr_cnt == 3, "got %d\n", attr_cnt);
5450     IXMLDOMNamedNodeMap_Release(mapAttr);
5451
5452     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
5453     ok( hr == S_OK, "ret %08x\n", hr );
5454     length1 = 0;
5455     hr = IXMLDOMNodeList_get_length(pList, &length1);
5456     ok(length1 == 1, "got %d\n", length1);
5457     ok( hr == S_OK, "ret %08x\n", hr );
5458     IXMLDOMNodeList_Release(pList);
5459
5460     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
5461     ok( hr == S_OK, "ret %08x\n", hr );
5462     attr_cnt1 = 0;
5463     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
5464     ok( hr == S_OK, "ret %08x\n", hr );
5465     ok(attr_cnt1 == 3, "got %d\n", attr_cnt1);
5466     IXMLDOMNamedNodeMap_Release(mapAttr);
5467
5468     ok(length == length1, "wrong Child count (%d, %d)\n", length, length1);
5469     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
5470     IXMLDOMNode_Release(node_clone);
5471
5472     /* No Children */
5473     hr = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
5474     ok( hr == S_OK, "ret %08x\n", hr );
5475     ok( node_clone != NULL, "node %p\n", node );
5476
5477     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
5478     ok(hr == S_FALSE, "ret %08x\n", hr );
5479
5480     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
5481     ok(hr == S_OK, "ret %08x\n", hr );
5482     hr = IXMLDOMNodeList_get_length(pList, &length1);
5483     ok(hr == S_OK, "ret %08x\n", hr );
5484     ok( length1 == 0, "Length should be 0 (%d)\n", length1);
5485     IXMLDOMNodeList_Release(pList);
5486
5487     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
5488     ok(hr == S_OK, "ret %08x\n", hr );
5489     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
5490     ok(hr == S_OK, "ret %08x\n", hr );
5491     ok(attr_cnt1 == 3, "Attribute count should be 3 (%d)\n", attr_cnt1);
5492     IXMLDOMNamedNodeMap_Release(mapAttr);
5493
5494     ok(length != length1, "wrong Child count (%d, %d)\n", length, length1);
5495     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
5496     IXMLDOMNode_Release(node_clone);
5497
5498     IXMLDOMNode_Release(node);
5499     IXMLDOMDocument_Release(doc);
5500     free_bstrs();
5501 }
5502
5503 static void test_xmlTypes(void)
5504 {
5505     IXMLDOMDocument *doc;
5506     IXMLDOMElement *pRoot;
5507     HRESULT hr;
5508     IXMLDOMComment *pComment;
5509     IXMLDOMElement *pElement;
5510     IXMLDOMAttribute *pAttribute;
5511     IXMLDOMNamedNodeMap *pAttribs;
5512     IXMLDOMCDATASection *pCDataSec;
5513     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
5514     IXMLDOMDocumentFragment *pDocFrag = NULL;
5515     IXMLDOMEntityReference *pEntityRef = NULL;
5516     BSTR str;
5517     IXMLDOMNode *pNextChild;
5518     VARIANT v;
5519     LONG len = 0;
5520
5521     doc = create_document(&IID_IXMLDOMDocument);
5522     if (!doc) return;
5523
5524     pNextChild = (void*)0xdeadbeef;
5525     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
5526     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5527
5528     pNextChild = (void*)0xdeadbeef;
5529     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
5530     ok(hr == S_FALSE, "ret %08x\n", hr );
5531     ok(pNextChild == NULL, "pDocChild not NULL\n");
5532
5533     /* test previous Sibling */
5534     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
5535     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5536
5537     pNextChild = (void*)0xdeadbeef;
5538     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
5539     ok(hr == S_FALSE, "ret %08x\n", hr );
5540     ok(pNextChild == NULL, "pNextChild not NULL\n");
5541
5542     /* test get_dataType */
5543     V_VT(&v) = VT_EMPTY;
5544     hr = IXMLDOMDocument_get_dataType(doc, &v);
5545     ok(hr == S_FALSE, "ret %08x\n", hr );
5546     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
5547     VariantClear(&v);
5548
5549     /* test implementation */
5550     hr = IXMLDOMDocument_get_implementation(doc, NULL);
5551     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5552
5553     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
5554     ok(hr == S_OK, "ret %08x\n", hr );
5555     if(hr == S_OK)
5556     {
5557         VARIANT_BOOL hasFeature = VARIANT_TRUE;
5558         BSTR sEmpty = SysAllocStringLen(NULL, 0);
5559
5560         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
5561         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5562
5563         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
5564         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5565
5566         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
5567         ok(hr == S_OK, "ret %08x\n", hr );
5568         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
5569
5570         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
5571         ok(hr == S_OK, "ret %08x\n", hr );
5572         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
5573
5574         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
5575         ok(hr == S_OK, "ret %08x\n", hr );
5576         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
5577
5578         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
5579         ok(hr == S_OK, "ret %08x\n", hr );
5580         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
5581
5582         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
5583         ok(hr == S_OK, "ret %08x\n", hr );
5584         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
5585
5586         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
5587         ok(hr == S_OK, "ret %08x\n", hr );
5588         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
5589
5590         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
5591         ok(hr == S_OK, "ret %08x\n", hr );
5592         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
5593
5594         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
5595         ok(hr == S_OK, "ret %08x\n", hr );
5596         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
5597
5598         SysFreeString(sEmpty);
5599         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
5600     }
5601
5602     pRoot = (IXMLDOMElement*)0x1;
5603     hr = IXMLDOMDocument_createElement(doc, NULL, &pRoot);
5604     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5605     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
5606
5607     pRoot = (IXMLDOMElement*)0x1;
5608     hr = IXMLDOMDocument_createElement(doc, _bstr_(""), &pRoot);
5609     ok(hr == E_FAIL, "ret %08x\n", hr );
5610     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
5611
5612     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
5613     ok(hr == S_OK, "ret %08x\n", hr );
5614     if(hr == S_OK)
5615     {
5616         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
5617         ok(hr == S_OK, "ret %08x\n", hr );
5618         if(hr == S_OK)
5619         {
5620             /* Comment */
5621             str = SysAllocString(szComment);
5622             hr = IXMLDOMDocument_createComment(doc, str, &pComment);
5623             SysFreeString(str);
5624             ok(hr == S_OK, "ret %08x\n", hr );
5625             if(hr == S_OK)
5626             {
5627                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
5628                 ok(hr == S_OK, "ret %08x\n", hr );
5629
5630                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
5631                 ok(hr == S_OK, "ret %08x\n", hr );
5632                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
5633                 SysFreeString(str);
5634
5635                 hr = IXMLDOMComment_get_xml(pComment, &str);
5636                 ok(hr == S_OK, "ret %08x\n", hr );
5637                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
5638                 SysFreeString(str);
5639
5640                 /* put data Tests */
5641                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
5642                 ok(hr == S_OK, "ret %08x\n", hr );
5643
5644                 /* get data Tests */
5645                 hr = IXMLDOMComment_get_data(pComment, &str);
5646                 ok(hr == S_OK, "ret %08x\n", hr );
5647                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
5648                 SysFreeString(str);
5649
5650                 /* get data Tests */
5651                 hr = IXMLDOMComment_get_nodeValue(pComment, &v);
5652                 ok(hr == S_OK, "ret %08x\n", hr );
5653                 ok( V_VT(&v) == VT_BSTR, "incorrect dataType type\n");
5654                 ok( !lstrcmpW( V_BSTR(&v), _bstr_("This &is a ; test <>\\") ), "incorrect get_nodeValue string\n");
5655                 VariantClear(&v);
5656
5657                 /* Confirm XML text is good */
5658                 hr = IXMLDOMComment_get_xml(pComment, &str);
5659                 ok(hr == S_OK, "ret %08x\n", hr );
5660                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
5661                 SysFreeString(str);
5662
5663                 /* Confirm we get the put_data Text back */
5664                 hr = IXMLDOMComment_get_text(pComment, &str);
5665                 ok(hr == S_OK, "ret %08x\n", hr );
5666                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
5667                 SysFreeString(str);
5668
5669                 /* test length property */
5670                 hr = IXMLDOMComment_get_length(pComment, &len);
5671                 ok(hr == S_OK, "ret %08x\n", hr );
5672                 ok(len == 21, "expected 21 got %d\n", len);
5673
5674                 /* test substringData */
5675                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
5676                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5677
5678                 /* test substringData - Invalid offset */
5679                 str = (BSTR)&szElement;
5680                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
5681                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5682                 ok( str == NULL, "incorrect string\n");
5683
5684                 /* test substringData - Invalid offset */
5685                 str = (BSTR)&szElement;
5686                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
5687                 ok(hr == S_FALSE, "ret %08x\n", hr );
5688                 ok( str == NULL, "incorrect string\n");
5689
5690                 /* test substringData - Invalid size */
5691                 str = (BSTR)&szElement;
5692                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
5693                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5694                 ok( str == NULL, "incorrect string\n");
5695
5696                 /* test substringData - Invalid size */
5697                 str = (BSTR)&szElement;
5698                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
5699                 ok(hr == S_FALSE, "ret %08x\n", hr );
5700                 ok( str == NULL, "incorrect string\n");
5701
5702                 /* test substringData - Start of string */
5703                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
5704                 ok(hr == S_OK, "ret %08x\n", hr );
5705                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
5706                 SysFreeString(str);
5707
5708                 /* test substringData - Middle of string */
5709                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
5710                 ok(hr == S_OK, "ret %08x\n", hr );
5711                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
5712                 SysFreeString(str);
5713
5714                 /* test substringData - End of string */
5715                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
5716                 ok(hr == S_OK, "ret %08x\n", hr );
5717                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
5718                 SysFreeString(str);
5719
5720                 /* test appendData */
5721                 hr = IXMLDOMComment_appendData(pComment, NULL);
5722                 ok(hr == S_OK, "ret %08x\n", hr );
5723
5724                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
5725                 ok(hr == S_OK, "ret %08x\n", hr );
5726
5727                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
5728                 ok(hr == S_OK, "ret %08x\n", hr );
5729
5730                 hr = IXMLDOMComment_get_text(pComment, &str);
5731                 ok(hr == S_OK, "ret %08x\n", hr );
5732                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5733                 SysFreeString(str);
5734
5735                 /* test insertData */
5736                 str = SysAllocStringLen(NULL, 0);
5737                 hr = IXMLDOMComment_insertData(pComment, -1, str);
5738                 ok(hr == S_OK, "ret %08x\n", hr );
5739
5740                 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
5741                 ok(hr == S_OK, "ret %08x\n", hr );
5742
5743                 hr = IXMLDOMComment_insertData(pComment, 1000, str);
5744                 ok(hr == S_OK, "ret %08x\n", hr );
5745
5746                 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
5747                 ok(hr == S_OK, "ret %08x\n", hr );
5748
5749                 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
5750                 ok(hr == S_OK, "ret %08x\n", hr );
5751
5752                 hr = IXMLDOMComment_insertData(pComment, 0, str);
5753                 ok(hr == S_OK, "ret %08x\n", hr );
5754                 SysFreeString(str);
5755
5756                 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
5757                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5758
5759                 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
5760                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5761
5762                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
5763                 ok(hr == S_OK, "ret %08x\n", hr );
5764
5765                 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
5766                 ok(hr == S_OK, "ret %08x\n", hr );
5767
5768                 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
5769                 ok(hr == S_OK, "ret %08x\n", hr );
5770
5771                 hr = IXMLDOMComment_get_text(pComment, &str);
5772                 ok(hr == S_OK, "ret %08x\n", hr );
5773                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5774                 SysFreeString(str);
5775
5776                 /* delete data */
5777                 /* invalid arguments */
5778                 hr = IXMLDOMComment_deleteData(pComment, -1, 1);
5779                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5780
5781                 hr = IXMLDOMComment_deleteData(pComment, 0, 0);
5782                 ok(hr == S_OK, "ret %08x\n", hr );
5783
5784                 hr = IXMLDOMComment_deleteData(pComment, 0, -1);
5785                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5786
5787                 hr = IXMLDOMComment_get_length(pComment, &len);
5788                 ok(hr == S_OK, "ret %08x\n", hr );
5789                 ok(len == 43, "expected 43 got %d\n", len);
5790
5791                 hr = IXMLDOMComment_deleteData(pComment, len, 1);
5792                 ok(hr == S_OK, "ret %08x\n", hr );
5793
5794                 hr = IXMLDOMComment_deleteData(pComment, len+1, 1);
5795                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5796
5797                 /* delete from start */
5798                 hr = IXMLDOMComment_deleteData(pComment, 0, 5);
5799                 ok(hr == S_OK, "ret %08x\n", hr );
5800
5801                 hr = IXMLDOMComment_get_length(pComment, &len);
5802                 ok(hr == S_OK, "ret %08x\n", hr );
5803                 ok(len == 38, "expected 38 got %d\n", len);
5804
5805                 hr = IXMLDOMComment_get_text(pComment, &str);
5806                 ok(hr == S_OK, "ret %08x\n", hr );
5807                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5808                 SysFreeString(str);
5809
5810                 /* delete from end */
5811                 hr = IXMLDOMComment_deleteData(pComment, 35, 3);
5812                 ok(hr == S_OK, "ret %08x\n", hr );
5813
5814                 hr = IXMLDOMComment_get_length(pComment, &len);
5815                 ok(hr == S_OK, "ret %08x\n", hr );
5816                 ok(len == 35, "expected 35 got %d\n", len);
5817
5818                 hr = IXMLDOMComment_get_text(pComment, &str);
5819                 ok(hr == S_OK, "ret %08x\n", hr );
5820                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5821                 SysFreeString(str);
5822
5823                 /* delete from inside */
5824                 hr = IXMLDOMComment_deleteData(pComment, 1, 33);
5825                 ok(hr == S_OK, "ret %08x\n", hr );
5826
5827                 hr = IXMLDOMComment_get_length(pComment, &len);
5828                 ok(hr == S_OK, "ret %08x\n", hr );
5829                 ok(len == 2, "expected 2 got %d\n", len);
5830
5831                 hr = IXMLDOMComment_get_text(pComment, &str);
5832                 ok(hr == S_OK, "ret %08x\n", hr );
5833                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5834                 SysFreeString(str);
5835
5836                 /* delete whole data ... */
5837                 hr = IXMLDOMComment_get_length(pComment, &len);
5838                 ok(hr == S_OK, "ret %08x\n", hr );
5839
5840                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5841                 ok(hr == S_OK, "ret %08x\n", hr );
5842                 /* ... and try again with empty string */
5843                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5844                 ok(hr == S_OK, "ret %08x\n", hr );
5845
5846                 /* ::replaceData() */
5847                 V_VT(&v) = VT_BSTR;
5848                 V_BSTR(&v) = SysAllocString(szstr1);
5849                 hr = IXMLDOMComment_put_nodeValue(pComment, v);
5850                 ok(hr == S_OK, "ret %08x\n", hr );
5851                 VariantClear(&v);
5852
5853                 hr = IXMLDOMComment_replaceData(pComment, 6, 0, NULL);
5854                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5855                 hr = IXMLDOMComment_get_text(pComment, &str);
5856                 ok(hr == S_OK, "ret %08x\n", hr );
5857                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5858                 SysFreeString(str);
5859
5860                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, NULL);
5861                 ok(hr == S_OK, "ret %08x\n", hr );
5862                 hr = IXMLDOMComment_get_text(pComment, &str);
5863                 ok(hr == S_OK, "ret %08x\n", hr );
5864                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5865                 SysFreeString(str);
5866
5867                 /* NULL pointer means delete */
5868                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, NULL);
5869                 ok(hr == S_OK, "ret %08x\n", hr );
5870                 hr = IXMLDOMComment_get_text(pComment, &str);
5871                 ok(hr == S_OK, "ret %08x\n", hr );
5872                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5873                 SysFreeString(str);
5874
5875                 /* empty string means delete */
5876                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_(""));
5877                 ok(hr == S_OK, "ret %08x\n", hr );
5878                 hr = IXMLDOMComment_get_text(pComment, &str);
5879                 ok(hr == S_OK, "ret %08x\n", hr );
5880                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5881                 SysFreeString(str);
5882
5883                 /* zero count means insert */
5884                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, _bstr_("a"));
5885                 ok(hr == S_OK, "ret %08x\n", hr );
5886                 hr = IXMLDOMComment_get_text(pComment, &str);
5887                 ok(hr == S_OK, "ret %08x\n", hr );
5888                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5889                 SysFreeString(str);
5890
5891                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, NULL);
5892                 ok(hr == S_OK, "ret %08x\n", hr );
5893
5894                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("m"));
5895                 ok(hr == S_OK, "ret %08x\n", hr );
5896                 hr = IXMLDOMComment_get_text(pComment, &str);
5897                 ok(hr == S_OK, "ret %08x\n", hr );
5898                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5899                 SysFreeString(str);
5900
5901                 /* nonempty string, count greater than its length */
5902                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, _bstr_("a1.2"));
5903                 ok(hr == S_OK, "ret %08x\n", hr );
5904                 hr = IXMLDOMComment_get_text(pComment, &str);
5905                 ok(hr == S_OK, "ret %08x\n", hr );
5906                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5907                 SysFreeString(str);
5908
5909                 /* nonempty string, count less than its length */
5910                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_("wine"));
5911                 ok(hr == S_OK, "ret %08x\n", hr );
5912                 hr = IXMLDOMComment_get_text(pComment, &str);
5913                 ok(hr == S_OK, "ret %08x\n", hr );
5914                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5915                 SysFreeString(str);
5916
5917                 IXMLDOMComment_Release(pComment);
5918             }
5919
5920             /* Element */
5921             str = SysAllocString(szElement);
5922             hr = IXMLDOMDocument_createElement(doc, str, &pElement);
5923             SysFreeString(str);
5924             ok(hr == S_OK, "ret %08x\n", hr );
5925             if(hr == S_OK)
5926             {
5927                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5928                 ok(hr == S_OK, "ret %08x\n", hr );
5929
5930                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
5931                 ok(hr == S_OK, "ret %08x\n", hr );
5932                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
5933                 SysFreeString(str);
5934
5935                 hr = IXMLDOMElement_get_xml(pElement, &str);
5936                 ok(hr == S_OK, "ret %08x\n", hr );
5937                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
5938                 SysFreeString(str);
5939
5940                 /* Attribute */
5941                 pAttribute = (IXMLDOMAttribute*)0x1;
5942                 hr = IXMLDOMDocument_createAttribute(doc, NULL, &pAttribute);
5943                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5944                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5945
5946                 pAttribute = (IXMLDOMAttribute*)0x1;
5947                 hr = IXMLDOMDocument_createAttribute(doc, _bstr_(""), &pAttribute);
5948                 ok(hr == E_FAIL, "ret %08x\n", hr );
5949                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5950
5951                 str = SysAllocString(szAttribute);
5952                 hr = IXMLDOMDocument_createAttribute(doc, str, &pAttribute);
5953                 SysFreeString(str);
5954                 ok(hr == S_OK, "ret %08x\n", hr );
5955                 if(hr == S_OK)
5956                 {
5957                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
5958
5959                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, NULL);
5960                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5961
5962                     pNextChild = (IXMLDOMNode *)0x1;
5963                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, &pNextChild);
5964                     ok(hr == S_FALSE, "ret %08x\n", hr );
5965                     ok(pNextChild == NULL, "pNextChild not NULL\n");
5966
5967                     /* test Previous Sibling*/
5968                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, NULL);
5969                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5970
5971                     pNextChild = (IXMLDOMNode *)0x1;
5972                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, &pNextChild);
5973                     ok(hr == S_FALSE, "ret %08x\n", hr );
5974                     ok(pNextChild == NULL, "pNextChild not NULL\n");
5975
5976                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttribute, &pNewChild);
5977                     ok(hr == E_FAIL, "ret %08x\n", hr );
5978                     ok(pNewChild == NULL, "pNewChild not NULL\n");
5979
5980                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
5981                     ok(hr == S_OK, "ret %08x\n", hr );
5982                     if ( hr == S_OK )
5983                     {
5984                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttribute, NULL );
5985                         ok(hr == S_OK, "ret %08x\n", hr );
5986
5987                         IXMLDOMNamedNodeMap_Release(pAttribs);
5988                     }
5989
5990                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5991                     ok(hr == S_OK, "ret %08x\n", hr );
5992                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
5993                     SysFreeString(str);
5994
5995                     /* test nodeName */
5996                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5997                     ok(hr == S_OK, "ret %08x\n", hr );
5998                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
5999                     SysFreeString(str);
6000
6001                     /* test name property */
6002                     hr = IXMLDOMAttribute_get_name(pAttribute, &str);
6003                     ok(hr == S_OK, "ret %08x\n", hr );
6004                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
6005                     SysFreeString(str);
6006
6007                     hr = IXMLDOMAttribute_get_xml(pAttribute, &str);
6008                     ok(hr == S_OK, "ret %08x\n", hr );
6009                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
6010                     SysFreeString(str);
6011
6012                     IXMLDOMAttribute_Release(pAttribute);
6013
6014                     /* Check Element again with the Add Attribute*/
6015                     hr = IXMLDOMElement_get_xml(pElement, &str);
6016                     ok(hr == S_OK, "ret %08x\n", hr );
6017                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
6018                     SysFreeString(str);
6019                 }
6020
6021                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
6022                 ok(hr == S_OK, "ret %08x\n", hr );
6023
6024                 hr = IXMLDOMElement_get_xml(pElement, &str);
6025                 ok(hr == S_OK, "ret %08x\n", hr );
6026                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
6027                 SysFreeString(str);
6028
6029                 /* Test for reversible escaping */
6030                 str = SysAllocString( szStrangeChars );
6031                 hr = IXMLDOMElement_put_text(pElement, str);
6032                 ok(hr == S_OK, "ret %08x\n", hr );
6033                 SysFreeString( str );
6034
6035                 hr = IXMLDOMElement_get_xml(pElement, &str);
6036                 ok(hr == S_OK, "ret %08x\n", hr );
6037                 ok( !lstrcmpW( str, szElementXML4 ), "incorrect element xml\n");
6038                 SysFreeString(str);
6039
6040                 hr = IXMLDOMElement_get_text(pElement, &str);
6041                 ok(hr == S_OK, "ret %08x\n", hr );
6042                 ok( !lstrcmpW( str, szStrangeChars ), "incorrect element text\n");
6043                 SysFreeString(str);
6044
6045                 IXMLDOMElement_Release(pElement);
6046             }
6047
6048             /* CData Section */
6049             str = SysAllocString(szCData);
6050             hr = IXMLDOMDocument_createCDATASection(doc, str, NULL);
6051             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6052
6053             hr = IXMLDOMDocument_createCDATASection(doc, str, &pCDataSec);
6054             SysFreeString(str);
6055             ok(hr == S_OK, "ret %08x\n", hr );
6056             if(hr == S_OK)
6057             {
6058                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
6059                 VARIANT var;
6060
6061                 VariantInit(&var);
6062
6063                 hr = IXMLDOMCDATASection_QueryInterface(pCDataSec, &IID_IXMLDOMElement, (void**)&pElement);
6064                 ok(hr == E_NOINTERFACE, "ret %08x\n", hr);
6065
6066                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
6067                 ok(hr == S_OK, "ret %08x\n", hr );
6068
6069                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
6070                 ok(hr == S_OK, "ret %08x\n", hr );
6071                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
6072                 SysFreeString(str);
6073
6074                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
6075                 ok(hr == S_OK, "ret %08x\n", hr );
6076                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
6077                 SysFreeString(str);
6078
6079                 /* test lastChild */
6080                 pNextChild = (IXMLDOMNode*)0x1;
6081                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
6082                 ok(hr == S_FALSE, "ret %08x\n", hr );
6083                 ok(pNextChild == NULL, "pNextChild not NULL\n");
6084
6085                 /* put data Tests */
6086                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
6087                 ok(hr == S_OK, "ret %08x\n", hr );
6088
6089                 /* Confirm XML text is good */
6090                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
6091                 ok(hr == S_OK, "ret %08x\n", hr );
6092                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
6093                 SysFreeString(str);
6094
6095                 /* Confirm we get the put_data Text back */
6096                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6097                 ok(hr == S_OK, "ret %08x\n", hr );
6098                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
6099                 SysFreeString(str);
6100
6101                 /* test length property */
6102                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6103                 ok(hr == S_OK, "ret %08x\n", hr );
6104                 ok(len == 21, "expected 21 got %d\n", len);
6105
6106                 /* test get nodeValue */
6107                 hr = IXMLDOMCDATASection_get_nodeValue(pCDataSec, &var);
6108                 ok(hr == S_OK, "ret %08x\n", hr );
6109                 ok(V_VT(&var) == VT_BSTR, "got vt %04x\n", V_VT(&var));
6110                 ok( !lstrcmpW( V_BSTR(&var), _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
6111                 VariantClear(&var);
6112
6113                 /* test get data */
6114                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
6115                 ok(hr == S_OK, "ret %08x\n", hr );
6116                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
6117                 SysFreeString(str);
6118
6119                 /* test substringData */
6120                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
6121                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6122
6123                 /* test substringData - Invalid offset */
6124                 str = (BSTR)&szElement;
6125                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
6126                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6127                 ok( str == NULL, "incorrect string\n");
6128
6129                 /* test substringData - Invalid offset */
6130                 str = (BSTR)&szElement;
6131                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
6132                 ok(hr == S_FALSE, "ret %08x\n", hr );
6133                 ok( str == NULL, "incorrect string\n");
6134
6135                 /* test substringData - Invalid size */
6136                 str = (BSTR)&szElement;
6137                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
6138                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6139                 ok( str == NULL, "incorrect string\n");
6140
6141                 /* test substringData - Invalid size */
6142                 str = (BSTR)&szElement;
6143                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
6144                 ok(hr == S_FALSE, "ret %08x\n", hr );
6145                 ok( str == NULL, "incorrect string\n");
6146
6147                 /* test substringData - Start of string */
6148                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
6149                 ok(hr == S_OK, "ret %08x\n", hr );
6150                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
6151                 SysFreeString(str);
6152
6153                 /* test substringData - Middle of string */
6154                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
6155                 ok(hr == S_OK, "ret %08x\n", hr );
6156                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
6157                 SysFreeString(str);
6158
6159                 /* test substringData - End of string */
6160                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
6161                 ok(hr == S_OK, "ret %08x\n", hr );
6162                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
6163                 SysFreeString(str);
6164
6165                 /* test appendData */
6166                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
6167                 ok(hr == S_OK, "ret %08x\n", hr );
6168
6169                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
6170                 ok(hr == S_OK, "ret %08x\n", hr );
6171
6172                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
6173                 ok(hr == S_OK, "ret %08x\n", hr );
6174
6175                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6176                 ok(hr == S_OK, "ret %08x\n", hr );
6177                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6178                 SysFreeString(str);
6179
6180                 /* test insertData */
6181                 str = SysAllocStringLen(NULL, 0);
6182                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
6183                 ok(hr == S_OK, "ret %08x\n", hr );
6184
6185                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
6186                 ok(hr == S_OK, "ret %08x\n", hr );
6187
6188                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
6189                 ok(hr == S_OK, "ret %08x\n", hr );
6190
6191                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
6192                 ok(hr == S_OK, "ret %08x\n", hr );
6193
6194                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
6195                 ok(hr == S_OK, "ret %08x\n", hr );
6196
6197                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
6198                 ok(hr == S_OK, "ret %08x\n", hr );
6199                 SysFreeString(str);
6200
6201                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
6202                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6203
6204                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
6205                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6206
6207                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
6208                 ok(hr == S_OK, "ret %08x\n", hr );
6209
6210                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
6211                 ok(hr == S_OK, "ret %08x\n", hr );
6212
6213                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
6214                 ok(hr == S_OK, "ret %08x\n", hr );
6215
6216                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6217                 ok(hr == S_OK, "ret %08x\n", hr );
6218                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6219                 SysFreeString(str);
6220
6221                 /* delete data */
6222                 /* invalid arguments */
6223                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, -1, 1);
6224                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6225
6226                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 0);
6227                 ok(hr == S_OK, "ret %08x\n", hr );
6228
6229                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, -1);
6230                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6231
6232                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6233                 ok(hr == S_OK, "ret %08x\n", hr );
6234                 ok(len == 43, "expected 43 got %d\n", len);
6235
6236                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len, 1);
6237                 ok(hr == S_OK, "ret %08x\n", hr );
6238
6239                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len+1, 1);
6240                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6241
6242                 /* delete from start */
6243                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 5);
6244                 ok(hr == S_OK, "ret %08x\n", hr );
6245
6246                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6247                 ok(hr == S_OK, "ret %08x\n", hr );
6248                 ok(len == 38, "expected 38 got %d\n", len);
6249
6250                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6251                 ok(hr == S_OK, "ret %08x\n", hr );
6252                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6253                 SysFreeString(str);
6254
6255                 /* delete from end */
6256                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 35, 3);
6257                 ok(hr == S_OK, "ret %08x\n", hr );
6258
6259                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6260                 ok(hr == S_OK, "ret %08x\n", hr );
6261                 ok(len == 35, "expected 35 got %d\n", len);
6262
6263                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6264                 ok(hr == S_OK, "ret %08x\n", hr );
6265                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6266                 SysFreeString(str);
6267
6268                 /* delete from inside */
6269                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 1, 33);
6270                 ok(hr == S_OK, "ret %08x\n", hr );
6271
6272                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6273                 ok(hr == S_OK, "ret %08x\n", hr );
6274                 ok(len == 2, "expected 2 got %d\n", len);
6275
6276                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6277                 ok(hr == S_OK, "ret %08x\n", hr );
6278                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6279                 SysFreeString(str);
6280
6281                 /* delete whole data ... */
6282                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6283                 ok(hr == S_OK, "ret %08x\n", hr );
6284
6285                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
6286                 ok(hr == S_OK, "ret %08x\n", hr );
6287
6288                 /* ... and try again with empty string */
6289                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
6290                 ok(hr == S_OK, "ret %08x\n", hr );
6291
6292                 /* ::replaceData() */
6293                 V_VT(&v) = VT_BSTR;
6294                 V_BSTR(&v) = SysAllocString(szstr1);
6295                 hr = IXMLDOMCDATASection_put_nodeValue(pCDataSec, v);
6296                 ok(hr == S_OK, "ret %08x\n", hr );
6297                 VariantClear(&v);
6298
6299                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 6, 0, NULL);
6300                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6301                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6302                 ok(hr == S_OK, "ret %08x\n", hr );
6303                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6304                 SysFreeString(str);
6305
6306                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, NULL);
6307                 ok(hr == S_OK, "ret %08x\n", hr );
6308                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6309                 ok(hr == S_OK, "ret %08x\n", hr );
6310                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6311                 SysFreeString(str);
6312
6313                 /* NULL pointer means delete */
6314                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, NULL);
6315                 ok(hr == S_OK, "ret %08x\n", hr );
6316                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6317                 ok(hr == S_OK, "ret %08x\n", hr );
6318                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6319                 SysFreeString(str);
6320
6321                 /* empty string means delete */
6322                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_(""));
6323                 ok(hr == S_OK, "ret %08x\n", hr );
6324                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6325                 ok(hr == S_OK, "ret %08x\n", hr );
6326                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6327                 SysFreeString(str);
6328
6329                 /* zero count means insert */
6330                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, _bstr_("a"));
6331                 ok(hr == S_OK, "ret %08x\n", hr );
6332                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6333                 ok(hr == S_OK, "ret %08x\n", hr );
6334                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6335                 SysFreeString(str);
6336
6337                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, NULL);
6338                 ok(hr == S_OK, "ret %08x\n", hr );
6339
6340                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("m"));
6341                 ok(hr == S_OK, "ret %08x\n", hr );
6342                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6343                 ok(hr == S_OK, "ret %08x\n", hr );
6344                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6345                 SysFreeString(str);
6346
6347                 /* nonempty string, count greater than its length */
6348                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, _bstr_("a1.2"));
6349                 ok(hr == S_OK, "ret %08x\n", hr );
6350                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6351                 ok(hr == S_OK, "ret %08x\n", hr );
6352                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6353                 SysFreeString(str);
6354
6355                 /* nonempty string, count less than its length */
6356                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_("wine"));
6357                 ok(hr == S_OK, "ret %08x\n", hr );
6358                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6359                 ok(hr == S_OK, "ret %08x\n", hr );
6360                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6361                 SysFreeString(str);
6362
6363                 IXMLDOMCDATASection_Release(pCDataSec);
6364             }
6365
6366             /* Document Fragments */
6367             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
6368             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6369
6370             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
6371             ok(hr == S_OK, "ret %08x\n", hr );
6372             if(hr == S_OK)
6373             {
6374                 IXMLDOMNode *node;
6375
6376                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, NULL);
6377                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6378
6379                 node = (IXMLDOMNode *)0x1;
6380                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, &node);
6381                 ok(hr == S_FALSE, "ret %08x\n", hr );
6382                 ok(node == NULL, "expected NULL, got %p\n", node);
6383
6384                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
6385                 ok(hr == S_OK, "ret %08x\n", hr );
6386
6387                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
6388                 ok(hr == S_OK, "ret %08x\n", hr );
6389                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
6390                 SysFreeString(str);
6391
6392                 /* test next Sibling*/
6393                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
6394                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6395
6396                 node = (IXMLDOMNode *)0x1;
6397                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &node);
6398                 ok(hr == S_FALSE, "ret %08x\n", hr );
6399                 ok(node == NULL, "next sibling not NULL\n");
6400
6401                 /* test Previous Sibling*/
6402                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
6403                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6404
6405                 node = (IXMLDOMNode *)0x1;
6406                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &node);
6407                 ok(hr == S_FALSE, "ret %08x\n", hr );
6408                 ok(node == NULL, "previous sibling not NULL\n");
6409
6410                 IXMLDOMDocumentFragment_Release(pDocFrag);
6411             }
6412
6413             /* Entity References */
6414             hr = IXMLDOMDocument_createEntityReference(doc, NULL, &pEntityRef);
6415             ok(hr == E_FAIL, "ret %08x\n", hr );
6416             hr = IXMLDOMDocument_createEntityReference(doc, _bstr_(""), &pEntityRef);
6417             ok(hr == E_FAIL, "ret %08x\n", hr );
6418
6419             str = SysAllocString(szEntityRef);
6420             hr = IXMLDOMDocument_createEntityReference(doc, str, NULL);
6421             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6422
6423             hr = IXMLDOMDocument_createEntityReference(doc, str, &pEntityRef);
6424             SysFreeString(str);
6425             ok(hr == S_OK, "ret %08x\n", hr );
6426             if(hr == S_OK)
6427             {
6428                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
6429                 ok(hr == S_OK, "ret %08x\n", hr );
6430
6431                 /* test get_xml*/
6432                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
6433                 ok(hr == S_OK, "ret %08x\n", hr );
6434                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
6435                 SysFreeString(str);
6436
6437                 IXMLDOMEntityReference_Release(pEntityRef);
6438             }
6439
6440             IXMLDOMElement_Release( pRoot );
6441         }
6442     }
6443
6444     IXMLDOMDocument_Release(doc);
6445
6446     free_bstrs();
6447 }
6448
6449 static void test_nodeTypeTests( void )
6450 {
6451     IXMLDOMDocument *doc = NULL;
6452     IXMLDOMElement *pRoot;
6453     IXMLDOMElement *pElement;
6454     HRESULT hr;
6455
6456     doc = create_document(&IID_IXMLDOMDocument);
6457     if (!doc) return;
6458
6459     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), NULL);
6460     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6461
6462     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
6463     ok(hr == S_OK, "ret %08x\n", hr );
6464     if(hr == S_OK)
6465     {
6466         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
6467         ok(hr == S_OK, "ret %08x\n", hr );
6468         if(hr == S_OK)
6469         {
6470             hr = IXMLDOMElement_put_dataType(pRoot, NULL);
6471             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6472
6473             /* Invalid Value */
6474             hr = IXMLDOMElement_put_dataType(pRoot, _bstr_("abcdefg") );
6475             ok(hr == E_FAIL, "ret %08x\n", hr );
6476
6477             /* NOTE:
6478              *   The name passed into put_dataType is case-insensitive. So many of the names
6479              *     have been changed to reflect this.
6480              */
6481             /* Boolean */
6482             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Boolean"), &pElement);
6483             ok(hr == S_OK, "ret %08x\n", hr );
6484             if(hr == S_OK)
6485             {
6486                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6487
6488                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Boolean") );
6489                 ok(hr == S_OK, "ret %08x\n", hr );
6490
6491                 IXMLDOMElement_Release(pElement);
6492             }
6493
6494             /* String */
6495             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_String"), &pElement);
6496             ok(hr == S_OK, "ret %08x\n", hr );
6497             if(hr == S_OK)
6498             {
6499                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6500
6501                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("String") );
6502                 ok(hr == S_OK, "ret %08x\n", hr );
6503
6504                 IXMLDOMElement_Release(pElement);
6505             }
6506
6507             /* Number */
6508             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Number"), &pElement);
6509             ok(hr == S_OK, "ret %08x\n", hr );
6510             if(hr == S_OK)
6511             {
6512                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6513
6514                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("number") );
6515                 ok(hr == S_OK, "ret %08x\n", hr );
6516
6517                 IXMLDOMElement_Release(pElement);
6518             }
6519
6520             /* Int */
6521             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Int"), &pElement);
6522             ok(hr == S_OK, "ret %08x\n", hr );
6523             if(hr == S_OK)
6524             {
6525                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6526
6527                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("InT") );
6528                 ok(hr == S_OK, "ret %08x\n", hr );
6529
6530                 IXMLDOMElement_Release(pElement);
6531             }
6532
6533             /* Fixed */
6534             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Fixed"), &pElement);
6535             ok(hr == S_OK, "ret %08x\n", hr );
6536             if(hr == S_OK)
6537             {
6538                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6539
6540                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("fixed.14.4") );
6541                 ok(hr == S_OK, "ret %08x\n", hr );
6542
6543                 IXMLDOMElement_Release(pElement);
6544             }
6545
6546             /* DateTime */
6547             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime"), &pElement);
6548             ok(hr == S_OK, "ret %08x\n", hr );
6549             if(hr == S_OK)
6550             {
6551                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6552
6553                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime") );
6554                 ok(hr == S_OK, "ret %08x\n", hr );
6555
6556                 IXMLDOMElement_Release(pElement);
6557             }
6558
6559             /* DateTime TZ */
6560             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime_tz"), &pElement);
6561             ok(hr == S_OK, "ret %08x\n", hr );
6562             if(hr == S_OK)
6563             {
6564                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6565
6566                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
6567                 ok(hr == S_OK, "ret %08x\n", hr );
6568
6569                 IXMLDOMElement_Release(pElement);
6570             }
6571
6572             /* Date */
6573             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Date"), &pElement);
6574             ok(hr == S_OK, "ret %08x\n", hr );
6575             if(hr == S_OK)
6576             {
6577                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6578
6579                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Date") );
6580                 ok(hr == S_OK, "ret %08x\n", hr );
6581
6582                 IXMLDOMElement_Release(pElement);
6583             }
6584
6585             /* Time */
6586             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time"), &pElement);
6587             ok(hr == S_OK, "ret %08x\n", hr );
6588             if(hr == S_OK)
6589             {
6590                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6591
6592                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time") );
6593                 ok(hr == S_OK, "ret %08x\n", hr );
6594
6595                 IXMLDOMElement_Release(pElement);
6596             }
6597
6598             /* Time.tz */
6599             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time_TZ"), &pElement);
6600             ok(hr == S_OK, "ret %08x\n", hr );
6601             if(hr == S_OK)
6602             {
6603                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6604
6605                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time.tz") );
6606                 ok(hr == S_OK, "ret %08x\n", hr );
6607
6608                 IXMLDOMElement_Release(pElement);
6609             }
6610
6611             /* I1 */
6612             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I1"), &pElement);
6613             ok(hr == S_OK, "ret %08x\n", hr );
6614             if(hr == S_OK)
6615             {
6616                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6617
6618                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I1") );
6619                 ok(hr == S_OK, "ret %08x\n", hr );
6620
6621                 IXMLDOMElement_Release(pElement);
6622             }
6623
6624             /* I2 */
6625             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I2"), &pElement);
6626             ok(hr == S_OK, "ret %08x\n", hr );
6627             if(hr == S_OK)
6628             {
6629                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6630
6631                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I2") );
6632                 ok(hr == S_OK, "ret %08x\n", hr );
6633
6634                 IXMLDOMElement_Release(pElement);
6635             }
6636
6637             /* I4 */
6638             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I4"), &pElement);
6639             ok(hr == S_OK, "ret %08x\n", hr );
6640             if(hr == S_OK)
6641             {
6642                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6643
6644                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I4") );
6645                 ok(hr == S_OK, "ret %08x\n", hr );
6646
6647                 IXMLDOMElement_Release(pElement);
6648             }
6649
6650             /* UI1 */
6651             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI1"), &pElement);
6652             ok(hr == S_OK, "ret %08x\n", hr );
6653             if(hr == S_OK)
6654             {
6655                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6656
6657                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI1") );
6658                 ok(hr == S_OK, "ret %08x\n", hr );
6659
6660                 IXMLDOMElement_Release(pElement);
6661             }
6662
6663             /* UI2 */
6664             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI2"), &pElement);
6665             ok(hr == S_OK, "ret %08x\n", hr );
6666             if(hr == S_OK)
6667             {
6668                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6669
6670                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI2") );
6671                 ok(hr == S_OK, "ret %08x\n", hr );
6672
6673                 IXMLDOMElement_Release(pElement);
6674             }
6675
6676             /* UI4 */
6677             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI4"), &pElement);
6678             ok(hr == S_OK, "ret %08x\n", hr );
6679             if(hr == S_OK)
6680             {
6681                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6682
6683                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI4") );
6684                 ok(hr == S_OK, "ret %08x\n", hr );
6685
6686                 IXMLDOMElement_Release(pElement);
6687             }
6688
6689             /* r4 */
6690             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r4"), &pElement);
6691             ok(hr == S_OK, "ret %08x\n", hr );
6692             if(hr == S_OK)
6693             {
6694                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6695
6696                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r4") );
6697                 ok(hr == S_OK, "ret %08x\n", hr );
6698
6699                 IXMLDOMElement_Release(pElement);
6700             }
6701
6702             /* r8 */
6703             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r8"), &pElement);
6704             ok(hr == S_OK, "ret %08x\n", hr );
6705             if(hr == S_OK)
6706             {
6707                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6708
6709                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r8") );
6710                 ok(hr == S_OK, "ret %08x\n", hr );
6711
6712                 IXMLDOMElement_Release(pElement);
6713             }
6714
6715             /* float */
6716             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_float"), &pElement);
6717             ok(hr == S_OK, "ret %08x\n", hr );
6718             if(hr == S_OK)
6719             {
6720                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6721
6722                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("float") );
6723                 ok(hr == S_OK, "ret %08x\n", hr );
6724
6725                 IXMLDOMElement_Release(pElement);
6726             }
6727
6728             /* uuid */
6729             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_uuid"), &pElement);
6730             ok(hr == S_OK, "ret %08x\n", hr );
6731             if(hr == S_OK)
6732             {
6733                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6734
6735                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UuId") );
6736                 ok(hr == S_OK, "ret %08x\n", hr );
6737
6738                 IXMLDOMElement_Release(pElement);
6739             }
6740
6741             /* bin.hex */
6742             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_hex"), &pElement);
6743             ok(hr == S_OK, "ret %08x\n", hr );
6744             if(hr == S_OK)
6745             {
6746                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6747
6748                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.hex") );
6749                 ok(hr == S_OK, "ret %08x\n", hr );
6750
6751                 IXMLDOMElement_Release(pElement);
6752             }
6753
6754             /* bin.base64 */
6755             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_base64"), &pElement);
6756             ok(hr == S_OK, "ret %08x\n", hr );
6757             if(hr == S_OK)
6758             {
6759                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6760
6761                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.base64") );
6762                 ok(hr == S_OK, "ret %08x\n", hr );
6763
6764                 IXMLDOMElement_Release(pElement);
6765             }
6766
6767             /* Check changing types */
6768             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &pElement);
6769             ok(hr == S_OK, "ret %08x\n", hr );
6770             if(hr == S_OK)
6771             {
6772                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6773
6774                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
6775                 ok(hr == S_OK, "ret %08x\n", hr );
6776
6777                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("string") );
6778                 ok(hr == S_OK, "ret %08x\n", hr );
6779
6780                 IXMLDOMElement_Release(pElement);
6781             }
6782
6783             IXMLDOMElement_Release(pRoot);
6784         }
6785     }
6786
6787     IXMLDOMDocument_Release(doc);
6788
6789     free_bstrs();
6790 }
6791
6792 static void test_save(void)
6793 {
6794     IXMLDOMDocument *doc, *doc2;
6795     IXMLDOMElement *root;
6796     VARIANT file, vDoc;
6797     BSTR sOrig, sNew, filename;
6798     char buffer[100];
6799     DWORD read = 0;
6800     HANDLE hfile;
6801     HRESULT hr;
6802
6803     doc = create_document(&IID_IXMLDOMDocument);
6804     if (!doc) return;
6805
6806     doc2 = create_document(&IID_IXMLDOMDocument);
6807     if (!doc2)
6808     {
6809         IXMLDOMDocument_Release(doc);
6810         return;
6811     }
6812
6813     /* save to IXMLDOMDocument */
6814     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
6815     EXPECT_HR(hr, S_OK);
6816
6817     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
6818     EXPECT_HR(hr, S_OK);
6819
6820     V_VT(&vDoc) = VT_UNKNOWN;
6821     V_UNKNOWN(&vDoc) = (IUnknown*)doc2;
6822
6823     hr = IXMLDOMDocument_save(doc, vDoc);
6824     EXPECT_HR(hr, S_OK);
6825
6826     hr = IXMLDOMDocument_get_xml(doc, &sOrig);
6827     EXPECT_HR(hr, S_OK);
6828
6829     hr = IXMLDOMDocument_get_xml(doc2, &sNew);
6830     EXPECT_HR(hr, S_OK);
6831
6832     ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as original\n");
6833
6834     SysFreeString(sOrig);
6835     SysFreeString(sNew);
6836
6837     IXMLDOMElement_Release(root);
6838     IXMLDOMDocument_Release(doc2);
6839
6840     /* save to path */
6841     V_VT(&file) = VT_BSTR;
6842     V_BSTR(&file) = _bstr_("test.xml");
6843
6844     hr = IXMLDOMDocument_save(doc, file);
6845     EXPECT_HR(hr, S_OK);
6846
6847     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
6848     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
6849     if(hfile == INVALID_HANDLE_VALUE) return;
6850
6851     ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
6852     ok(read != 0, "could not read file\n");
6853     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
6854
6855     CloseHandle(hfile);
6856     DeleteFile("test.xml");
6857
6858     /* save to path VT_BSTR | VT_BYREF */
6859     filename = _bstr_("test.xml");
6860     V_VT(&file) = VT_BSTR | VT_BYREF;
6861     V_BSTRREF(&file) = &filename;
6862
6863     hr = IXMLDOMDocument_save(doc, file);
6864     EXPECT_HR(hr, S_OK);
6865
6866     IXMLDOMDocument_Release(doc);
6867
6868     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
6869     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
6870     if(hfile == INVALID_HANDLE_VALUE) return;
6871
6872     ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
6873     ok(read != 0, "could not read file\n");
6874     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
6875
6876     CloseHandle(hfile);
6877     DeleteFile("test.xml");
6878     free_bstrs();
6879 }
6880
6881 static void test_testTransforms(void)
6882 {
6883     IXMLDOMDocument *doc, *docSS;
6884     IXMLDOMNode *pNode;
6885     VARIANT_BOOL bSucc;
6886
6887     HRESULT hr;
6888
6889     doc = create_document(&IID_IXMLDOMDocument);
6890     if (!doc) return;
6891
6892     docSS = create_document(&IID_IXMLDOMDocument);
6893     if (!docSS)
6894     {
6895         IXMLDOMDocument_Release(doc);
6896         return;
6897     }
6898
6899     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
6900     ok(hr == S_OK, "ret %08x\n", hr );
6901
6902     hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
6903     ok(hr == S_OK, "ret %08x\n", hr );
6904
6905     hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (void**)&pNode );
6906     ok(hr == S_OK, "ret %08x\n", hr );
6907     if(hr == S_OK)
6908     {
6909         BSTR bOut;
6910
6911         hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
6912         ok(hr == S_OK, "ret %08x\n", hr );
6913         if(hr == S_OK)
6914         {
6915             ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "Stylesheet output not correct\n");
6916             SysFreeString(bOut);
6917         }
6918
6919         IXMLDOMNode_Release(pNode);
6920     }
6921
6922     IXMLDOMDocument_Release(docSS);
6923     IXMLDOMDocument_Release(doc);
6924
6925     free_bstrs();
6926 }
6927
6928 static void test_namespaces(void)
6929 {
6930     static const CHAR namespaces_xmlA[] =
6931         "<?xml version=\"1.0\"?>\n"
6932         "<XMI xmi.version=\"1.1\" xmlns:Model=\"http://omg.org/mof.Model/1.3\">"
6933         "  <XMI.content>"
6934         "    <Model:Package name=\"WinePackage\" Model:name2=\"name2 attr\" />"
6935         "  </XMI.content>"
6936         "</XMI>";
6937
6938     IXMLDOMDocument *doc;
6939     IXMLDOMElement *elem;
6940     IXMLDOMNode *node;
6941
6942     VARIANT_BOOL b;
6943     VARIANT var;
6944     HRESULT hr;
6945     BSTR str;
6946
6947     doc = create_document(&IID_IXMLDOMDocument);
6948     if (!doc) return;
6949
6950     hr = IXMLDOMDocument_loadXML(doc, _bstr_(namespaces_xmlA), &b);
6951     EXPECT_HR(hr, S_OK);
6952     ok(b == VARIANT_TRUE, "got %d\n", b);
6953
6954     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("//XMI.content"), &node );
6955     EXPECT_HR(hr, S_OK);
6956     if(hr == S_OK)
6957     {
6958         IXMLDOMAttribute *attr;
6959         IXMLDOMNode *node2;
6960
6961         hr = IXMLDOMNode_get_firstChild(node, &node2);
6962         EXPECT_HR(hr, S_OK);
6963         ok(node2 != NULL, "got %p\n", node2);
6964
6965         /* Test get_prefix */
6966         hr = IXMLDOMNode_get_prefix(node2, NULL);
6967         EXPECT_HR(hr, E_INVALIDARG);
6968         /* NOTE: Need to test that arg2 gets cleared on Error. */
6969
6970         hr = IXMLDOMNode_get_prefix(node2, &str);
6971         EXPECT_HR(hr, S_OK);
6972         ok( !lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
6973         SysFreeString(str);
6974
6975         hr = IXMLDOMNode_get_nodeName(node2, &str);
6976         EXPECT_HR(hr, S_OK);
6977         ok(!lstrcmpW( str, _bstr_("Model:Package")), "got %s\n", wine_dbgstr_w(str));
6978         SysFreeString(str);
6979
6980         /* Test get_namespaceURI */
6981         hr = IXMLDOMNode_get_namespaceURI(node2, NULL);
6982         EXPECT_HR(hr, E_INVALIDARG);
6983         /* NOTE: Need to test that arg2 gets cleared on Error. */
6984
6985         hr = IXMLDOMNode_get_namespaceURI(node2, &str);
6986         EXPECT_HR(hr, S_OK);
6987         ok(!lstrcmpW( str, _bstr_("http://omg.org/mof.Model/1.3")), "got %s\n", wine_dbgstr_w(str));
6988         SysFreeString(str);
6989
6990         hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&elem);
6991         EXPECT_HR(hr, S_OK);
6992
6993         hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("Model:name2"), &attr);
6994         EXPECT_HR(hr, S_OK);
6995
6996         hr = IXMLDOMAttribute_get_nodeName(attr, &str);
6997         EXPECT_HR(hr, S_OK);
6998         ok(!lstrcmpW( str, _bstr_("Model:name2")), "got %s\n", wine_dbgstr_w(str));
6999         SysFreeString(str);
7000
7001         hr = IXMLDOMAttribute_get_prefix(attr, &str);
7002         EXPECT_HR(hr, S_OK);
7003         ok(!lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
7004         SysFreeString(str);
7005
7006         IXMLDOMAttribute_Release(attr);
7007         IXMLDOMElement_Release(elem);
7008
7009         IXMLDOMNode_Release(node2);
7010         IXMLDOMNode_Release(node);
7011     }
7012
7013     IXMLDOMDocument_Release(doc);
7014
7015     /* create on element and try to alter namespace after that */
7016     doc = create_document(&IID_IXMLDOMDocument);
7017     if (!doc) return;
7018
7019     V_VT(&var) = VT_I2;
7020     V_I2(&var) = NODE_ELEMENT;
7021
7022     hr = IXMLDOMDocument_createNode(doc, var, _bstr_("ns:elem"), _bstr_("ns/uri"), &node);
7023     EXPECT_HR(hr, S_OK);
7024
7025     hr = IXMLDOMDocument_appendChild(doc, node, NULL);
7026     EXPECT_HR(hr, S_OK);
7027
7028     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7029     EXPECT_HR(hr, S_OK);
7030
7031     V_VT(&var) = VT_BSTR;
7032     V_BSTR(&var) = _bstr_("ns/uri2");
7033
7034     hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
7035     EXPECT_HR(hr, E_INVALIDARG);
7036
7037     V_VT(&var) = VT_BSTR;
7038     V_BSTR(&var) = _bstr_("ns/uri");
7039
7040     hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
7041     EXPECT_HR(hr, S_OK);
7042
7043     hr = IXMLDOMElement_get_xml(elem, &str);
7044     EXPECT_HR(hr, S_OK);
7045     ok(!lstrcmpW(str, _bstr_("<ns:elem xmlns:ns=\"ns/uri\"/>")), "got element %s\n", wine_dbgstr_w(str));
7046     SysFreeString(str);
7047
7048     IXMLDOMElement_Release(elem);
7049     IXMLDOMDocument_Release(doc);
7050
7051     /* create on element and try to alter namespace after that */
7052     doc = create_document_version(60, &IID_IXMLDOMDocument);
7053     if (!doc) return;
7054
7055     V_VT(&var) = VT_I2;
7056     V_I2(&var) = NODE_ELEMENT;
7057
7058     hr = IXMLDOMDocument_createNode(doc, var, _bstr_("ns:elem"), _bstr_("ns/uri"), &node);
7059     EXPECT_HR(hr, S_OK);
7060
7061     hr = IXMLDOMDocument_appendChild(doc, node, NULL);
7062     EXPECT_HR(hr, S_OK);
7063
7064     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7065     EXPECT_HR(hr, S_OK);
7066
7067     /* try same prefix, different uri */
7068     V_VT(&var) = VT_BSTR;
7069     V_BSTR(&var) = _bstr_("ns/uri2");
7070
7071     hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
7072     EXPECT_HR(hr, E_INVALIDARG);
7073
7074     /* try same prefix and uri */
7075     V_VT(&var) = VT_BSTR;
7076     V_BSTR(&var) = _bstr_("ns/uri");
7077
7078     hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
7079     EXPECT_HR(hr, S_OK);
7080
7081     hr = IXMLDOMElement_get_xml(elem, &str);
7082     EXPECT_HR(hr, S_OK);
7083     ok(!lstrcmpW(str, _bstr_("<ns:elem xmlns:ns=\"ns/uri\"/>")), "got element %s\n", wine_dbgstr_w(str));
7084     SysFreeString(str);
7085
7086     IXMLDOMElement_Release(elem);
7087     IXMLDOMDocument_Release(doc);
7088
7089     free_bstrs();
7090 }
7091
7092 static void test_FormattingXML(void)
7093 {
7094     IXMLDOMDocument *doc;
7095     IXMLDOMElement *pElement;
7096     VARIANT_BOOL bSucc;
7097     HRESULT hr;
7098     BSTR str;
7099     static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
7100     static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
7101
7102     doc = create_document(&IID_IXMLDOMDocument);
7103     if (!doc) return;
7104
7105     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
7106     ok(hr == S_OK, "ret %08x\n", hr );
7107     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7108
7109     if(bSucc == VARIANT_TRUE)
7110     {
7111         hr = IXMLDOMDocument_get_documentElement(doc, &pElement);
7112         ok(hr == S_OK, "ret %08x\n", hr );
7113         if(hr == S_OK)
7114         {
7115             hr = IXMLDOMElement_get_xml(pElement, &str);
7116             ok(hr == S_OK, "ret %08x\n", hr );
7117             ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
7118             SysFreeString(str);
7119
7120             IXMLDOMElement_Release(pElement);
7121         }
7122     }
7123
7124     IXMLDOMDocument_Release(doc);
7125
7126     free_bstrs();
7127 }
7128
7129 typedef struct _nodetypedvalue_t {
7130     const char *name;
7131     VARTYPE type;
7132     const char *value; /* value in string format */
7133 } nodetypedvalue_t;
7134
7135 static const nodetypedvalue_t get_nodetypedvalue[] = {
7136     { "root/string",    VT_BSTR, "Wine" },
7137     { "root/string2",   VT_BSTR, "String" },
7138     { "root/number",    VT_BSTR, "12.44" },
7139     { "root/number2",   VT_BSTR, "-3.71e3" },
7140     { "root/int",       VT_I4,   "-13" },
7141     { "root/fixed",     VT_CY,   "7322.9371" },
7142     { "root/bool",      VT_BOOL, "-1" },
7143     { "root/datetime",  VT_DATE, "40135.14" },
7144     { "root/datetimetz",VT_DATE, "37813.59" },
7145     { "root/date",      VT_DATE, "665413" },
7146     { "root/time",      VT_DATE, "0.5813889" },
7147     { "root/timetz",    VT_DATE, "1.112512" },
7148     { "root/i1",        VT_I1,   "-13" },
7149     { "root/i2",        VT_I2,   "31915" },
7150     { "root/i4",        VT_I4,   "-312232" },
7151     { "root/ui1",       VT_UI1,  "123" },
7152     { "root/ui2",       VT_UI2,  "48282" },
7153     { "root/ui4",       VT_UI4,  "949281" },
7154     { "root/r4",        VT_R4,   "213124" },
7155     { "root/r8",        VT_R8,   "0.412" },
7156     { "root/float",     VT_R8,   "41221.421" },
7157     { "root/uuid",      VT_BSTR, "333C7BC4-460F-11D0-BC04-0080C7055a83" },
7158     { "root/binbase64", VT_ARRAY|VT_UI1, "base64 test" },
7159     { "root/binbase64_1", VT_ARRAY|VT_UI1, "base64 test" },
7160     { "root/binbase64_2", VT_ARRAY|VT_UI1, "base64 test" },
7161     { 0 }
7162 };
7163
7164 static void test_nodeTypedValue(void)
7165 {
7166     const nodetypedvalue_t *entry = get_nodetypedvalue;
7167     IXMLDOMDocumentType *doctype, *doctype2;
7168     IXMLDOMProcessingInstruction *pi;
7169     IXMLDOMDocumentFragment *frag;
7170     IXMLDOMDocument *doc, *doc2;
7171     IXMLDOMCDATASection *cdata;
7172     IXMLDOMComment *comment;
7173     IXMLDOMNode *node;
7174     VARIANT_BOOL b;
7175     VARIANT value;
7176     HRESULT hr;
7177
7178     doc = create_document(&IID_IXMLDOMDocument);
7179     if (!doc) return;
7180
7181     b = VARIANT_FALSE;
7182     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &b);
7183     ok(hr == S_OK, "ret %08x\n", hr );
7184     ok(b == VARIANT_TRUE, "got %d\n", b);
7185
7186     hr = IXMLDOMDocument_get_nodeValue(doc, NULL);
7187     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7188
7189     V_VT(&value) = VT_BSTR;
7190     V_BSTR(&value) = NULL;
7191     hr = IXMLDOMDocument_get_nodeValue(doc, &value);
7192     ok(hr == S_FALSE, "ret %08x\n", hr );
7193     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
7194
7195     hr = IXMLDOMDocument_get_nodeTypedValue(doc, NULL);
7196     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7197
7198     V_VT(&value) = VT_EMPTY;
7199     hr = IXMLDOMDocument_get_nodeTypedValue(doc, &value);
7200     ok(hr == S_FALSE, "ret %08x\n", hr );
7201     ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
7202
7203     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/string"), &node);
7204     ok(hr == S_OK, "ret %08x\n", hr );
7205
7206     V_VT(&value) = VT_BSTR;
7207     V_BSTR(&value) = NULL;
7208     hr = IXMLDOMNode_get_nodeValue(node, &value);
7209     ok(hr == S_FALSE, "ret %08x\n", hr );
7210     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
7211
7212     hr = IXMLDOMNode_get_nodeTypedValue(node, NULL);
7213     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7214
7215     IXMLDOMNode_Release(node);
7216
7217     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/binhex"), &node);
7218     ok(hr == S_OK, "ret %08x\n", hr );
7219     {
7220         BYTE bytes[] = {0xff,0xfc,0xa0,0x12,0x00,0x3c};
7221
7222         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
7223         ok(hr == S_OK, "ret %08x\n", hr );
7224         ok(V_VT(&value) == (VT_ARRAY|VT_UI1), "incorrect type\n");
7225         ok(V_ARRAY(&value)->rgsabound[0].cElements == 6, "incorrect array size\n");
7226         if(V_ARRAY(&value)->rgsabound[0].cElements == 6)
7227             ok(!memcmp(bytes, V_ARRAY(&value)->pvData, sizeof(bytes)), "incorrect value\n");
7228         VariantClear(&value);
7229         IXMLDOMNode_Release(node);
7230     }
7231
7232     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("foo"), _bstr_("value"), &pi);
7233     ok(hr == S_OK, "ret %08x\n", hr );
7234     {
7235         V_VT(&value) = VT_NULL;
7236         V_BSTR(&value) = (void*)0xdeadbeef;
7237         hr = IXMLDOMProcessingInstruction_get_nodeTypedValue(pi, &value);
7238         ok(hr == S_OK, "ret %08x\n", hr );
7239         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
7240         ok(!lstrcmpW(V_BSTR(&value), _bstr_("value")), "got wrong value\n");
7241         IXMLDOMProcessingInstruction_Release(pi);
7242         VariantClear(&value);
7243     }
7244
7245     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("[1]*2=3; &gee that's not right!"), &cdata);
7246     ok(hr == S_OK, "ret %08x\n", hr );
7247     {
7248         V_VT(&value) = VT_NULL;
7249         V_BSTR(&value) = (void*)0xdeadbeef;
7250         hr = IXMLDOMCDATASection_get_nodeTypedValue(cdata, &value);
7251         ok(hr == S_OK, "ret %08x\n", hr );
7252         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
7253         ok(!lstrcmpW(V_BSTR(&value), _bstr_("[1]*2=3; &gee that's not right!")), "got wrong value\n");
7254         IXMLDOMCDATASection_Release(cdata);
7255         VariantClear(&value);
7256     }
7257
7258     hr = IXMLDOMDocument_createComment(doc, _bstr_("comment"), &comment);
7259     ok(hr == S_OK, "ret %08x\n", hr );
7260     {
7261         V_VT(&value) = VT_NULL;
7262         V_BSTR(&value) = (void*)0xdeadbeef;
7263         hr = IXMLDOMComment_get_nodeTypedValue(comment, &value);
7264         ok(hr == S_OK, "ret %08x\n", hr );
7265         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
7266         ok(!lstrcmpW(V_BSTR(&value), _bstr_("comment")), "got wrong value\n");
7267         IXMLDOMComment_Release(comment);
7268         VariantClear(&value);
7269     }
7270
7271     hr = IXMLDOMDocument_createDocumentFragment(doc, &frag);
7272     ok(hr == S_OK, "ret %08x\n", hr );
7273     {
7274         V_VT(&value) = VT_EMPTY;
7275         hr = IXMLDOMDocumentFragment_get_nodeTypedValue(frag, &value);
7276         ok(hr == S_FALSE, "ret %08x\n", hr );
7277         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
7278         IXMLDOMDocumentFragment_Release(frag);
7279     }
7280
7281     doc2 = create_document(&IID_IXMLDOMDocument);
7282
7283     b = VARIANT_FALSE;
7284     hr = IXMLDOMDocument_loadXML(doc2, _bstr_(szEmailXML), &b);
7285     ok(hr == S_OK, "ret %08x\n", hr );
7286     ok(b == VARIANT_TRUE, "got %d\n", b);
7287
7288     EXPECT_REF(doc2, 1);
7289
7290     hr = IXMLDOMDocument_get_doctype(doc2, &doctype);
7291     ok(hr == S_OK, "ret %08x\n", hr );
7292
7293     EXPECT_REF(doc2, 1);
7294     todo_wine EXPECT_REF(doctype, 2);
7295
7296     {
7297         V_VT(&value) = VT_EMPTY;
7298         hr = IXMLDOMDocumentType_get_nodeTypedValue(doctype, &value);
7299         ok(hr == S_FALSE, "ret %08x\n", hr );
7300         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
7301     }
7302
7303     hr = IXMLDOMDocument_get_doctype(doc2, &doctype2);
7304     ok(hr == S_OK, "ret %08x\n", hr );
7305     ok(doctype != doctype2, "got %p, was %p\n", doctype2, doctype);
7306
7307     IXMLDOMDocumentType_Release(doctype2);
7308     IXMLDOMDocumentType_Release(doctype);
7309
7310     IXMLDOMDocument_Release(doc2);
7311
7312     while (entry->name)
7313     {
7314         hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_(entry->name), &node);
7315         ok(hr == S_OK, "ret %08x\n", hr );
7316
7317         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
7318         ok(hr == S_OK, "ret %08x\n", hr );
7319         ok(V_VT(&value) == entry->type, "incorrect type, expected %d, got %d\n", entry->type, V_VT(&value));
7320
7321         if (entry->type == (VT_ARRAY|VT_UI1))
7322         {
7323             ok(V_ARRAY(&value)->rgsabound[0].cElements == strlen(entry->value),
7324                "incorrect array size %d\n", V_ARRAY(&value)->rgsabound[0].cElements);
7325         }
7326
7327         if (entry->type != VT_BSTR)
7328         {
7329            if (entry->type == VT_DATE ||
7330                entry->type == VT_R8 ||
7331                entry->type == VT_CY)
7332            {
7333                if (entry->type == VT_DATE)
7334                {
7335                    hr = VariantChangeType(&value, &value, 0, VT_R4);
7336                    ok(hr == S_OK, "ret %08x\n", hr );
7337                }
7338                hr = VariantChangeTypeEx(&value, &value,
7339                                         MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT),
7340                                         VARIANT_NOUSEROVERRIDE, VT_BSTR);
7341                ok(hr == S_OK, "ret %08x\n", hr );
7342            }
7343            else
7344            {
7345                hr = VariantChangeType(&value, &value, 0, VT_BSTR);
7346                ok(hr == S_OK, "ret %08x\n", hr );
7347            }
7348
7349            /* for byte array from VT_ARRAY|VT_UI1 it's not a WCHAR buffer */
7350            if (entry->type == (VT_ARRAY|VT_UI1))
7351            {
7352                ok(!memcmp( V_BSTR(&value), entry->value, strlen(entry->value)),
7353                   "expected %s\n", entry->value);
7354            }
7355            else
7356                ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
7357                   "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
7358         }
7359         else
7360            ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
7361                "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
7362
7363         VariantClear( &value );
7364         IXMLDOMNode_Release(node);
7365
7366         entry++;
7367     }
7368
7369     IXMLDOMDocument_Release(doc);
7370     free_bstrs();
7371 }
7372
7373 static void test_TransformWithLoadingLocalFile(void)
7374 {
7375     IXMLDOMDocument *doc;
7376     IXMLDOMDocument *xsl;
7377     IXMLDOMNode *pNode;
7378     VARIANT_BOOL bSucc;
7379     HRESULT hr;
7380     HANDLE file;
7381     DWORD dwWritten;
7382     char lpPathBuffer[MAX_PATH];
7383     int i;
7384
7385     /* Create a Temp File. */
7386     GetTempPathA(MAX_PATH, lpPathBuffer);
7387     strcat(lpPathBuffer, "customers.xml" );
7388
7389     file = CreateFileA(lpPathBuffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
7390     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
7391     if(file == INVALID_HANDLE_VALUE)
7392         return;
7393
7394     WriteFile(file, szBasicTransformXML, strlen(szBasicTransformXML), &dwWritten, NULL);
7395     CloseHandle(file);
7396
7397     /* Correct path to not include a escape character. */
7398     for(i=0; i < strlen(lpPathBuffer); i++)
7399     {
7400         if(lpPathBuffer[i] == '\\')
7401             lpPathBuffer[i] = '/';
7402     }
7403
7404     doc = create_document(&IID_IXMLDOMDocument);
7405     if (!doc) return;
7406
7407     xsl = create_document(&IID_IXMLDOMDocument);
7408     if (!xsl)
7409     {
7410         IXMLDOMDocument2_Release(doc);
7411         return;
7412     }
7413
7414     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
7415     ok(hr == S_OK, "ret %08x\n", hr );
7416     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7417     if(bSucc == VARIANT_TRUE)
7418     {
7419         BSTR sXSL;
7420         BSTR sPart1 = _bstr_(szBasicTransformSSXMLPart1);
7421         BSTR sPart2 = _bstr_(szBasicTransformSSXMLPart2);
7422         BSTR sFileName = _bstr_(lpPathBuffer);
7423         int nLegnth = lstrlenW(sPart1) + lstrlenW(sPart2) + lstrlenW(sFileName) + 1;
7424
7425         sXSL = SysAllocStringLen(NULL, nLegnth);
7426         lstrcpyW(sXSL, sPart1);
7427         lstrcatW(sXSL, sFileName);
7428         lstrcatW(sXSL, sPart2);
7429
7430         hr = IXMLDOMDocument_loadXML(xsl, sXSL, &bSucc);
7431         ok(hr == S_OK, "ret %08x\n", hr );
7432         ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7433         if(bSucc == VARIANT_TRUE)
7434         {
7435             BSTR sResult;
7436
7437             hr = IXMLDOMDocument_QueryInterface(xsl, &IID_IXMLDOMNode, (void**)&pNode );
7438             ok(hr == S_OK, "ret %08x\n", hr );
7439             if(hr == S_OK)
7440             {
7441                 /* This will load the temp file via the XSL */
7442                 hr = IXMLDOMDocument_transformNode(doc, pNode, &sResult);
7443                 ok(hr == S_OK, "ret %08x\n", hr );
7444                 if(hr == S_OK)
7445                 {
7446                     ok( compareIgnoreReturns( sResult, _bstr_(szBasicTransformOutput)), "Stylesheet output not correct\n");
7447                     SysFreeString(sResult);
7448                 }
7449
7450                 IXMLDOMNode_Release(pNode);
7451             }
7452         }
7453
7454         SysFreeString(sXSL);
7455     }
7456
7457     IXMLDOMDocument_Release(doc);
7458     IXMLDOMDocument_Release(xsl);
7459
7460     DeleteFile(lpPathBuffer);
7461     free_bstrs();
7462 }
7463
7464 static void test_put_nodeValue(void)
7465 {
7466     static const WCHAR jeevesW[] = {'J','e','e','v','e','s',' ','&',' ','W','o','o','s','t','e','r',0};
7467     IXMLDOMDocument *doc;
7468     IXMLDOMText *text;
7469     IXMLDOMEntityReference *entityref;
7470     IXMLDOMAttribute *attr;
7471     IXMLDOMNode *node;
7472     HRESULT hr;
7473     VARIANT data, type;
7474
7475     doc = create_document(&IID_IXMLDOMDocument);
7476     if (!doc) return;
7477
7478     /* test for unsupported types */
7479     /* NODE_DOCUMENT */
7480     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&node);
7481     ok(hr == S_OK, "ret %08x\n", hr );
7482     V_VT(&data) = VT_BSTR;
7483     V_BSTR(&data) = _bstr_("one two three");
7484     hr = IXMLDOMNode_put_nodeValue(node, data);
7485     ok(hr == E_FAIL, "ret %08x\n", hr );
7486     IXMLDOMNode_Release(node);
7487
7488     /* NODE_DOCUMENT_FRAGMENT */
7489     V_VT(&type) = VT_I1;
7490     V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
7491     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
7492     ok(hr == S_OK, "ret %08x\n", hr );
7493     V_VT(&data) = VT_BSTR;
7494     V_BSTR(&data) = _bstr_("one two three");
7495     hr = IXMLDOMNode_put_nodeValue(node, data);
7496     ok(hr == E_FAIL, "ret %08x\n", hr );
7497     IXMLDOMNode_Release(node);
7498
7499     /* NODE_ELEMENT */
7500     V_VT(&type) = VT_I1;
7501     V_I1(&type) = NODE_ELEMENT;
7502     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
7503     ok(hr == S_OK, "ret %08x\n", hr );
7504     V_VT(&data) = VT_BSTR;
7505     V_BSTR(&data) = _bstr_("one two three");
7506     hr = IXMLDOMNode_put_nodeValue(node, data);
7507     ok(hr == E_FAIL, "ret %08x\n", hr );
7508     IXMLDOMNode_Release(node);
7509
7510     /* NODE_ENTITY_REFERENCE */
7511     hr = IXMLDOMDocument_createEntityReference(doc, _bstr_("ref"), &entityref);
7512     ok(hr == S_OK, "ret %08x\n", hr );
7513
7514     V_VT(&data) = VT_BSTR;
7515     V_BSTR(&data) = _bstr_("one two three");
7516     hr = IXMLDOMEntityReference_put_nodeValue(entityref, data);
7517     ok(hr == E_FAIL, "ret %08x\n", hr );
7518
7519     hr = IXMLDOMEntityReference_QueryInterface(entityref, &IID_IXMLDOMNode, (void**)&node);
7520     ok(hr == S_OK, "ret %08x\n", hr );
7521     V_VT(&data) = VT_BSTR;
7522     V_BSTR(&data) = _bstr_("one two three");
7523     hr = IXMLDOMNode_put_nodeValue(node, data);
7524     ok(hr == E_FAIL, "ret %08x\n", hr );
7525     IXMLDOMNode_Release(node);
7526     IXMLDOMEntityReference_Release(entityref);
7527
7528     /* supported types */
7529     hr = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &text);
7530     ok(hr == S_OK, "ret %08x\n", hr );
7531     V_VT(&data) = VT_BSTR;
7532     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
7533     hr = IXMLDOMText_put_nodeValue(text, data);
7534     ok(hr == S_OK, "ret %08x\n", hr );
7535     IXMLDOMText_Release(text);
7536
7537     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
7538     ok(hr == S_OK, "ret %08x\n", hr );
7539     V_VT(&data) = VT_BSTR;
7540     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
7541     hr = IXMLDOMAttribute_put_nodeValue(attr, data);
7542     ok(hr == S_OK, "ret %08x\n", hr );
7543     hr = IXMLDOMAttribute_get_nodeValue(attr, &data);
7544     ok(hr == S_OK, "ret %08x\n", hr );
7545     ok(memcmp(V_BSTR(&data), jeevesW, sizeof(jeevesW)) == 0, "got %s\n",
7546         wine_dbgstr_w(V_BSTR(&data)));
7547     VariantClear(&data);
7548     IXMLDOMAttribute_Release(attr);
7549
7550     free_bstrs();
7551
7552     IXMLDOMDocument_Release(doc);
7553 }
7554
7555 static void test_document_IObjectSafety(void)
7556 {
7557     IXMLDOMDocument *doc;
7558     IObjectSafety *safety;
7559     HRESULT hr;
7560
7561     doc = create_document(&IID_IXMLDOMDocument);
7562     if (!doc) return;
7563
7564     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IObjectSafety, (void**)&safety);
7565     ok(hr == S_OK, "ret %08x\n", hr );
7566
7567     test_IObjectSafety_common(safety);
7568
7569     IObjectSafety_Release(safety);
7570
7571     IXMLDOMDocument_Release(doc);
7572 }
7573
7574 typedef struct _property_test_t {
7575     const GUID *guid;
7576     const char *clsid;
7577     const char *property;
7578     const char *value;
7579 } property_test_t;
7580
7581 static const property_test_t properties_test_data[] = {
7582     { &CLSID_DOMDocument,  "CLSID_DOMDocument" , "SelectionLanguage", "XSLPattern" },
7583     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2" , "SelectionLanguage", "XSLPattern" },
7584     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "SelectionLanguage", "XSLPattern" },
7585     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "SelectionLanguage", "XPath" },
7586     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "SelectionLanguage", "XPath" },
7587     { 0 }
7588 };
7589
7590 static void test_default_properties(void)
7591 {
7592     const property_test_t *entry = properties_test_data;
7593
7594     while (entry->guid)
7595     {
7596         IXMLDOMDocument2 *doc;
7597         VARIANT var;
7598         HRESULT hr;
7599
7600         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
7601         if (hr != S_OK)
7602         {
7603             win_skip("can't create %s instance\n", entry->clsid);
7604             entry++;
7605             continue;
7606         }
7607
7608         hr = IXMLDOMDocument2_getProperty(doc, _bstr_(entry->property), &var);
7609         ok(hr == S_OK, "got 0x%08x\n", hr);
7610         ok(lstrcmpW(V_BSTR(&var), _bstr_(entry->value)) == 0, "expected %s, for %s\n",
7611            entry->value, entry->clsid);
7612         VariantClear(&var);
7613
7614         IXMLDOMDocument2_Release(doc);
7615
7616         entry++;
7617     }
7618 }
7619
7620 typedef struct {
7621     const char *query;
7622     const char *list;
7623 } xslpattern_test_t;
7624
7625 static const xslpattern_test_t xslpattern_test[] = {
7626     { "root//elem[0]", "E1.E2.D1" },
7627     { "root//elem[index()=1]", "E2.E2.D1" },
7628     { "root//elem[index() $eq$ 1]", "E2.E2.D1" },
7629     { "root//elem[end()]", "E4.E2.D1" },
7630     { "root//elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
7631     { "root//elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
7632     { "root//elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
7633     { "root//elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
7634     { "root//elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
7635     { "root//elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
7636     { "root//elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
7637     { "root//elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
7638     { "root//elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
7639     { "root//elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
7640     { "root//elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
7641     { "root//elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
7642     { "root//elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
7643     { "root//elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
7644     { "root//elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
7645     { "root//elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
7646     { "root//elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
7647     { "root//elem[$any$ *='B2 field']", "E2.E2.D1" },
7648     { "root//elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
7649     { "root//elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
7650     { "root//elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
7651     { "root//elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
7652     { "root//elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
7653     { "root//elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
7654     { "root//elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
7655     { NULL }
7656 };
7657
7658 static const xslpattern_test_t xslpattern_test_no_ns[] = {
7659     /* prefixes don't need to be registered, you may use them as they are in the doc */
7660     { "//bar:x", "E5.E1.E4.E1.E2.D1 E6.E2.E4.E1.E2.D1" },
7661     /* prefixes must be explicitly specified in the name */
7662     { "//foo:elem", "" },
7663     { "//foo:c", "E3.E4.E2.D1" },
7664     { NULL }
7665 };
7666
7667 static const xslpattern_test_t xslpattern_test_func[] = {
7668     { "attribute()", "" },
7669     { "attribute('depth')", "" },
7670     { "root/attribute('depth')", "A'depth'.E3.D1" },
7671     { "//x/attribute()", "A'id'.E3.E3.D1 A'depth'.E3.E3.D1" },
7672     { "//x//attribute(id)", NULL },
7673     { "//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" },
7674     { "comment()", "C2.D1" },
7675     { "//comment()", "C2.D1 C1.E3.D1 C2.E3.E3.D1 C2.E4.E3.D1" },
7676     { "element()", "E3.D1" },
7677     { "root/y/element()", "E4.E4.E3.D1 E5.E4.E3.D1 E6.E4.E3.D1" },
7678     { "//element(a)", NULL },
7679     { "//element('a')", "E4.E3.E3.D1 E4.E4.E3.D1" },
7680     { "node()", "P1.D1 C2.D1 E3.D1" },
7681     { "//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" },
7682     { "//x/node()[nodeType()=1]", "E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1" },
7683     { "//x/node()[nodeType()=3]", "T3.E3.E3.D1" },
7684     { "//x/node()[nodeType()=7]", "P1.E3.E3.D1" },
7685     { "//x/node()[nodeType()=8]", "C2.E3.E3.D1" },
7686     { "pi()", "P1.D1" },
7687     { "//y/pi()", "P1.E4.E3.D1" },
7688     { "root/textnode()", "T2.E3.D1" },
7689     { "root/element()/textnode()", "T3.E3.E3.D1 T3.E4.E3.D1" },
7690     { NULL }
7691 };
7692
7693 static void test_XSLPattern(void)
7694 {
7695     const xslpattern_test_t *ptr = xslpattern_test;
7696     IXMLDOMDocument2 *doc;
7697     IXMLDOMNodeList *list;
7698     VARIANT_BOOL b;
7699     HRESULT hr;
7700     LONG len;
7701
7702     doc = create_document(&IID_IXMLDOMDocument2);
7703     if (!doc) return;
7704
7705     b = VARIANT_FALSE;
7706     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
7707     EXPECT_HR(hr, S_OK);
7708     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7709
7710     /* switch to XSLPattern */
7711     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern"));
7712     EXPECT_HR(hr, S_OK);
7713
7714     /* XPath doesn't select elements with non-null default namespace with unqualified selectors, XSLPattern does */
7715     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem/c"), &list);
7716     EXPECT_HR(hr, S_OK);
7717
7718     len = 0;
7719     hr = IXMLDOMNodeList_get_length(list, &len);
7720     EXPECT_HR(hr, S_OK);
7721     /* should select <elem><c> and <elem xmlns='...'><c> but not <elem><foo:c> */
7722     ok(len == 3, "expected 3 entries in list, got %d\n", len);
7723     IXMLDOMNodeList_Release(list);
7724
7725     while (ptr->query)
7726     {
7727         list = NULL;
7728         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
7729         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7730         len = 0;
7731         hr = IXMLDOMNodeList_get_length(list, &len);
7732         ok(len != 0, "query=%s, empty list\n", ptr->query);
7733         if (len)
7734             expect_list_and_release(list, ptr->list);
7735
7736         ptr++;
7737     }
7738
7739     /* namespace handling */
7740     /* no registered namespaces */
7741     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_(""));
7742     EXPECT_HR(hr, S_OK);
7743
7744     ptr = xslpattern_test_no_ns;
7745     while (ptr->query)
7746     {
7747         list = NULL;
7748         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
7749         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7750
7751         if (*ptr->list)
7752         {
7753             len = 0;
7754             hr = IXMLDOMNodeList_get_length(list, &len);
7755             EXPECT_HR(hr, S_OK);
7756             ok(len != 0, "query=%s, empty list\n", ptr->query);
7757         }
7758         else
7759         {
7760             len = 1;
7761             hr = IXMLDOMNodeList_get_length(list, &len);
7762             EXPECT_HR(hr, S_OK);
7763             ok(len == 0, "query=%s, empty list\n", ptr->query);
7764         }
7765         if (len)
7766             expect_list_and_release(list, ptr->list);
7767
7768         ptr++;
7769     }
7770
7771     /* explicitly register prefix foo */
7772     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
7773
7774     /* now we get the same behavior as XPath */
7775     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
7776     EXPECT_HR(hr, S_OK);
7777     len = 0;
7778     hr = IXMLDOMNodeList_get_length(list, &len);
7779     EXPECT_HR(hr, S_OK);
7780     ok(len != 0, "expected filled list\n");
7781     if (len)
7782         expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
7783
7784     /* set prefix foo to some nonexistent namespace */
7785     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:nonexistent-foo'"));
7786     EXPECT_HR(hr, S_OK);
7787
7788     /* the registered prefix takes precedence */
7789     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
7790     EXPECT_HR(hr, S_OK);
7791     len = 0;
7792     hr = IXMLDOMNodeList_get_length(list, &len);
7793     EXPECT_HR(hr, S_OK);
7794     ok(len == 0, "expected empty list\n");
7795     IXMLDOMNodeList_Release(list);
7796
7797     IXMLDOMDocument2_Release(doc);
7798
7799     doc = create_document(&IID_IXMLDOMDocument2);
7800     if (!doc) return;
7801
7802     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNodeTypesXML), &b);
7803     EXPECT_HR(hr, S_OK);
7804     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7805
7806     ptr = xslpattern_test_func;
7807     while (ptr->query)
7808     {
7809         list = NULL;
7810         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
7811         if (ptr->list)
7812         {
7813             ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7814             len = 0;
7815             hr = IXMLDOMNodeList_get_length(list, &len);
7816             if (*ptr->list)
7817             {
7818                 ok(len != 0, "query=%s, empty list\n", ptr->query);
7819                 if (len)
7820                     expect_list_and_release(list, ptr->list);
7821             }
7822             else
7823                 ok(len == 0, "query=%s, filled list\n", ptr->query);
7824         }
7825         else
7826             ok(hr == E_FAIL, "query=%s, failed with 0x%08x\n", ptr->query, hr);
7827
7828         ptr++;
7829     }
7830
7831     IXMLDOMDocument2_Release(doc);
7832     free_bstrs();
7833 }
7834
7835 static void test_splitText(void)
7836 {
7837     IXMLDOMCDATASection *cdata;
7838     IXMLDOMElement *root;
7839     IXMLDOMDocument *doc;
7840     IXMLDOMText *text, *text2;
7841     IXMLDOMNode *node;
7842     VARIANT var;
7843     VARIANT_BOOL success;
7844     LONG length;
7845     HRESULT hr;
7846
7847     doc = create_document(&IID_IXMLDOMDocument);
7848     if (!doc) return;
7849
7850     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<root></root>"), &success);
7851     ok(hr == S_OK, "got 0x%08x\n", hr);
7852
7853     hr = IXMLDOMDocument_get_documentElement(doc, &root);
7854     ok(hr == S_OK, "got 0x%08x\n", hr);
7855
7856     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("beautiful plumage"), &cdata);
7857     ok(hr == S_OK, "got 0x%08x\n", hr);
7858
7859     V_VT(&var) = VT_EMPTY;
7860     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)cdata, NULL);
7861     ok(hr == S_OK, "got 0x%08x\n", hr);
7862
7863     length = 0;
7864     hr = IXMLDOMCDATASection_get_length(cdata, &length);
7865     ok(hr == S_OK, "got 0x%08x\n", hr);
7866     ok(length > 0, "got %d\n", length);
7867
7868     hr = IXMLDOMCDATASection_splitText(cdata, 0, NULL);
7869     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7870
7871     text = (void*)0xdeadbeef;
7872     /* negative offset */
7873     hr = IXMLDOMCDATASection_splitText(cdata, -1, &text);
7874     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7875     ok(text == (void*)0xdeadbeef, "got %p\n", text);
7876
7877     text = (void*)0xdeadbeef;
7878     /* offset outside data */
7879     hr = IXMLDOMCDATASection_splitText(cdata, length + 1, &text);
7880     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7881     ok(text == 0, "got %p\n", text);
7882
7883     text = (void*)0xdeadbeef;
7884     /* offset outside data */
7885     hr = IXMLDOMCDATASection_splitText(cdata, length, &text);
7886     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7887     ok(text == 0, "got %p\n", text);
7888
7889     /* no empty node created */
7890     node = (void*)0xdeadbeef;
7891     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7892     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7893     ok(node == 0, "got %p\n", text);
7894
7895     hr = IXMLDOMCDATASection_splitText(cdata, 10, &text);
7896     ok(hr == S_OK, "got 0x%08x\n", hr);
7897
7898     length = 0;
7899     hr = IXMLDOMText_get_length(text, &length);
7900     ok(hr == S_OK, "got 0x%08x\n", hr);
7901     ok(length == 7, "got %d\n", length);
7902
7903     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7904     ok(hr == S_OK, "got 0x%08x\n", hr);
7905     IXMLDOMNode_Release(node);
7906
7907     /* split new text node */
7908     hr = IXMLDOMText_get_length(text, &length);
7909     ok(hr == S_OK, "got 0x%08x\n", hr);
7910
7911     node = (void*)0xdeadbeef;
7912     hr = IXMLDOMText_get_nextSibling(text, &node);
7913     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7914     ok(node == 0, "got %p\n", text);
7915
7916     hr = IXMLDOMText_splitText(text, 0, NULL);
7917     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7918
7919     text2 = (void*)0xdeadbeef;
7920     /* negative offset */
7921     hr = IXMLDOMText_splitText(text, -1, &text2);
7922     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7923     ok(text2 == (void*)0xdeadbeef, "got %p\n", text2);
7924
7925     text2 = (void*)0xdeadbeef;
7926     /* offset outside data */
7927     hr = IXMLDOMText_splitText(text, length + 1, &text2);
7928     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7929     ok(text2 == 0, "got %p\n", text2);
7930
7931     text2 = (void*)0xdeadbeef;
7932     /* offset outside data */
7933     hr = IXMLDOMText_splitText(text, length, &text2);
7934     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7935     ok(text2 == 0, "got %p\n", text);
7936
7937     text2 = 0;
7938     hr = IXMLDOMText_splitText(text, 4, &text2);
7939     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7940     if (text2) IXMLDOMText_Release(text2);
7941
7942     node = 0;
7943     hr = IXMLDOMText_get_nextSibling(text, &node);
7944     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7945     if (node) IXMLDOMNode_Release(node);
7946
7947     IXMLDOMText_Release(text);
7948     IXMLDOMElement_Release(root);
7949     IXMLDOMCDATASection_Release(cdata);
7950     free_bstrs();
7951 }
7952
7953 typedef struct {
7954     const char *name;
7955     const char *uri;
7956     HRESULT hr;
7957 } ns_item_t;
7958
7959 /* default_ns_doc used */
7960 static const ns_item_t qualified_item_tests[] = {
7961     { "xml:lang", NULL, S_FALSE },
7962     { "xml:lang", "http://www.w3.org/XML/1998/namespace", S_FALSE },
7963     { "lang", "http://www.w3.org/XML/1998/namespace", S_OK },
7964     { "ns:b", NULL, S_FALSE },
7965     { "ns:b", "nshref", S_FALSE },
7966     { "b", "nshref", S_OK },
7967     { "d", NULL, S_OK },
7968     { NULL }
7969 };
7970
7971 static const ns_item_t named_item_tests[] = {
7972     { "xml:lang", NULL, S_OK },
7973     { "lang", NULL, S_FALSE },
7974     { "ns:b", NULL, S_OK },
7975     { "b", NULL, S_FALSE },
7976     { "d", NULL, S_OK },
7977     { NULL }
7978 };
7979
7980 static void test_getQualifiedItem(void)
7981 {
7982     IXMLDOMNode *pr_node, *node;
7983     IXMLDOMNodeList *root_list;
7984     IXMLDOMNamedNodeMap *map;
7985     IXMLDOMElement *element;
7986     const ns_item_t* ptr;
7987     IXMLDOMDocument *doc;
7988     VARIANT_BOOL b;
7989     HRESULT hr;
7990     LONG len;
7991
7992     doc = create_document(&IID_IXMLDOMDocument);
7993     if (!doc) return;
7994
7995     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7996     EXPECT_HR(hr, S_OK);
7997     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7998
7999     hr = IXMLDOMDocument_get_documentElement(doc, &element);
8000     EXPECT_HR(hr, S_OK);
8001
8002     hr = IXMLDOMElement_get_childNodes(element, &root_list);
8003     EXPECT_HR(hr, S_OK);
8004
8005     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
8006     EXPECT_HR(hr, S_OK);
8007     IXMLDOMNodeList_Release(root_list);
8008
8009     hr = IXMLDOMNode_get_attributes(pr_node, &map);
8010     EXPECT_HR(hr, S_OK);
8011     IXMLDOMNode_Release(pr_node);
8012
8013     len = 0;
8014     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
8015     EXPECT_HR(hr, S_OK);
8016     ok( len == 3, "length %d\n", len);
8017
8018     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, NULL);
8019     EXPECT_HR(hr, E_INVALIDARG);
8020
8021     node = (void*)0xdeadbeef;
8022     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, &node);
8023     EXPECT_HR(hr, E_INVALIDARG);
8024     ok( node == (void*)0xdeadbeef, "got %p\n", node);
8025
8026     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, NULL);
8027     EXPECT_HR(hr, E_INVALIDARG);
8028
8029     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, &node);
8030     EXPECT_HR(hr, S_OK);
8031
8032     IXMLDOMNode_Release(node);
8033     IXMLDOMNamedNodeMap_Release(map);
8034     IXMLDOMElement_Release(element);
8035
8036     hr = IXMLDOMDocument_loadXML(doc, _bstr_(default_ns_doc), &b);
8037     EXPECT_HR(hr, S_OK);
8038
8039     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("a"), &node);
8040     EXPECT_HR(hr, S_OK);
8041
8042     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&element);
8043     EXPECT_HR(hr, S_OK);
8044     IXMLDOMNode_Release(node);
8045
8046     hr = IXMLDOMElement_get_attributes(element, &map);
8047     EXPECT_HR(hr, S_OK);
8048
8049     ptr = qualified_item_tests;
8050     while (ptr->name)
8051     {
8052        node = (void*)0xdeadbeef;
8053        hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
8054        ok(hr == ptr->hr, "%s, %s: got 0x%08x, expected 0x%08x\n", ptr->name, ptr->uri, hr, ptr->hr);
8055        if (hr == S_OK)
8056            IXMLDOMNode_Release(node);
8057        else
8058            ok(node == NULL, "%s, %s: got %p\n", ptr->name, ptr->uri, node);
8059        ptr++;
8060     }
8061
8062     ptr = named_item_tests;
8063     while (ptr->name)
8064     {
8065        node = (void*)0xdeadbeef;
8066        hr = IXMLDOMNamedNodeMap_getNamedItem(map, _bstr_(ptr->name), &node);
8067        ok(hr == ptr->hr, "%s: got 0x%08x, expected 0x%08x\n", ptr->name, hr, ptr->hr);
8068        if (hr == S_OK)
8069            IXMLDOMNode_Release(node);
8070        else
8071            ok(node == NULL, "%s: got %p\n", ptr->name, node);
8072        ptr++;
8073     }
8074
8075     IXMLDOMNamedNodeMap_Release(map);
8076
8077     IXMLDOMElement_Release(element);
8078     IXMLDOMDocument_Release(doc);
8079     free_bstrs();
8080 }
8081
8082 static void test_removeQualifiedItem(void)
8083 {
8084     IXMLDOMDocument *doc;
8085     IXMLDOMElement *element;
8086     IXMLDOMNode *pr_node, *node;
8087     IXMLDOMNodeList *root_list;
8088     IXMLDOMNamedNodeMap *map;
8089     VARIANT_BOOL b;
8090     LONG len;
8091     HRESULT hr;
8092
8093     doc = create_document(&IID_IXMLDOMDocument);
8094     if (!doc) return;
8095
8096     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8097     ok( hr == S_OK, "loadXML failed\n");
8098     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8099
8100     hr = IXMLDOMDocument_get_documentElement(doc, &element);
8101     ok( hr == S_OK, "ret %08x\n", hr);
8102
8103     hr = IXMLDOMElement_get_childNodes(element, &root_list);
8104     ok( hr == S_OK, "ret %08x\n", hr);
8105
8106     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
8107     ok( hr == S_OK, "ret %08x\n", hr);
8108     IXMLDOMNodeList_Release(root_list);
8109
8110     hr = IXMLDOMNode_get_attributes(pr_node, &map);
8111     ok( hr == S_OK, "ret %08x\n", hr);
8112     IXMLDOMNode_Release(pr_node);
8113
8114     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
8115     ok( hr == S_OK, "ret %08x\n", hr);
8116     ok( len == 3, "length %d\n", len);
8117
8118     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, NULL);
8119     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
8120
8121     node = (void*)0xdeadbeef;
8122     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, &node);
8123     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
8124     ok( node == (void*)0xdeadbeef, "got %p\n", node);
8125
8126     /* out pointer is optional */
8127     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
8128     ok( hr == S_OK, "ret %08x\n", hr);
8129
8130     /* already removed */
8131     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
8132     ok( hr == S_FALSE, "ret %08x\n", hr);
8133
8134     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("vr"), NULL, &node);
8135     ok( hr == S_OK, "ret %08x\n", hr);
8136     IXMLDOMNode_Release(node);
8137
8138     IXMLDOMNamedNodeMap_Release( map );
8139     IXMLDOMElement_Release( element );
8140     IXMLDOMDocument_Release( doc );
8141     free_bstrs();
8142 }
8143
8144 #define check_default_props(doc) _check_default_props(__LINE__, doc)
8145 static inline void _check_default_props(int line, IXMLDOMDocument2* doc)
8146 {
8147     VARIANT_BOOL b;
8148     VARIANT var;
8149     HRESULT hr;
8150
8151     VariantInit(&var);
8152     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
8153     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XSLPattern")) == 0, "expected XSLPattern\n");
8154     VariantClear(&var);
8155
8156     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
8157     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("")) == 0, "expected empty string\n");
8158     VariantClear(&var);
8159
8160     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
8161     ok_(__FILE__, line)(b == VARIANT_FALSE, "expected FALSE\n");
8162
8163     hr = IXMLDOMDocument2_get_schemas(doc, &var);
8164     ok_(__FILE__, line)(hr == S_FALSE, "got %08x\n", hr);
8165     VariantClear(&var);
8166 }
8167
8168 #define check_set_props(doc) _check_set_props(__LINE__, doc)
8169 static inline void _check_set_props(int line, IXMLDOMDocument2* doc)
8170 {
8171     VARIANT_BOOL b;
8172     VARIANT var;
8173
8174     VariantInit(&var);
8175     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
8176     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XPath")) == 0, "expected XPath\n");
8177     VariantClear(&var);
8178
8179     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
8180     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("xmlns:wi=\'www.winehq.org\'")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&var)));
8181     VariantClear(&var);
8182
8183     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
8184     ok_(__FILE__, line)(b == VARIANT_TRUE, "expected TRUE\n");
8185
8186     helper_ole_check(IXMLDOMDocument2_get_schemas(doc, &var));
8187     ok_(__FILE__, line)(V_VT(&var) != VT_NULL, "expected pointer\n");
8188     VariantClear(&var);
8189 }
8190
8191 #define set_props(doc, cache) _set_props(__LINE__, doc, cache)
8192 static inline void _set_props(int line, IXMLDOMDocument2* doc, IXMLDOMSchemaCollection* cache)
8193 {
8194     VARIANT var;
8195
8196     VariantInit(&var);
8197     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
8198     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:wi=\'www.winehq.org\'")));
8199     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_TRUE));
8200     V_VT(&var) = VT_DISPATCH;
8201     V_DISPATCH(&var) = NULL;
8202     helper_ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&var)));
8203     ok_(__FILE__, line)(V_DISPATCH(&var) != NULL, "expected pointer\n");
8204     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
8205     VariantClear(&var);
8206 }
8207
8208 #define unset_props(doc) _unset_props(__LINE__, doc)
8209 static inline void _unset_props(int line, IXMLDOMDocument2* doc)
8210 {
8211     VARIANT var;
8212
8213     VariantInit(&var);
8214     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
8215     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("")));
8216     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_FALSE));
8217     V_VT(&var) = VT_NULL;
8218     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
8219     VariantClear(&var);
8220 }
8221
8222 static void test_get_ownerDocument(void)
8223 {
8224     IXMLDOMDocument *doc1, *doc2, *doc3;
8225     IXMLDOMDocument2 *doc, *doc_owner;
8226     IXMLDOMNode *node;
8227     IXMLDOMSchemaCollection *cache;
8228     VARIANT_BOOL b;
8229     VARIANT var;
8230
8231     doc = create_document(&IID_IXMLDOMDocument2);
8232     cache = create_cache(&IID_IXMLDOMSchemaCollection);
8233     if (!doc || !cache)
8234     {
8235         if (doc) IXMLDOMDocument2_Release(doc);
8236         if (cache) IXMLDOMSchemaCollection_Release(cache);
8237         return;
8238     }
8239
8240     VariantInit(&var);
8241
8242     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b));
8243     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8244
8245     check_default_props(doc);
8246
8247     /* set properties and check that new instances use them */
8248     set_props(doc, cache);
8249     check_set_props(doc);
8250
8251     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
8252     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc1));
8253
8254     /* new interface keeps props */
8255     ole_check(IXMLDOMDocument_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**)&doc_owner));
8256     ok( doc_owner != doc, "got %p, doc %p\n", doc_owner, doc);
8257     check_set_props(doc_owner);
8258     IXMLDOMDocument2_Release(doc_owner);
8259
8260     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc2));
8261     IXMLDOMNode_Release(node);
8262
8263     ok(doc1 != doc2, "got %p, expected %p. original %p\n", doc2, doc1, doc);
8264
8265     /* reload */
8266     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
8267     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8268
8269     /* properties retained even after reload */
8270     check_set_props(doc);
8271
8272     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
8273     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc3));
8274     IXMLDOMNode_Release(node);
8275
8276     ole_check(IXMLDOMDocument_QueryInterface(doc3, &IID_IXMLDOMDocument2, (void**)&doc_owner));
8277     ok(doc3 != doc1 && doc3 != doc2 && doc_owner != doc, "got %p, (%p, %p, %p)\n", doc3, doc, doc1, doc2);
8278     check_set_props(doc_owner);
8279
8280     /* changing properties for one instance changes them for all */
8281     unset_props(doc_owner);
8282     check_default_props(doc_owner);
8283     check_default_props(doc);
8284
8285     IXMLDOMSchemaCollection_Release(cache);
8286     IXMLDOMDocument_Release(doc1);
8287     IXMLDOMDocument_Release(doc2);
8288     IXMLDOMDocument_Release(doc3);
8289     IXMLDOMDocument2_Release(doc);
8290     IXMLDOMDocument2_Release(doc_owner);
8291     free_bstrs();
8292 }
8293
8294 static void test_setAttributeNode(void)
8295 {
8296     IXMLDOMDocument *doc, *doc2;
8297     IXMLDOMElement *elem, *elem2;
8298     IXMLDOMAttribute *attr, *attr2, *ret_attr;
8299     VARIANT_BOOL b;
8300     HRESULT hr;
8301     VARIANT v;
8302     BSTR str;
8303     ULONG ref1, ref2;
8304
8305     doc = create_document(&IID_IXMLDOMDocument);
8306     if (!doc) return;
8307
8308     hr = IXMLDOMDocument2_loadXML( doc, _bstr_(complete4A), &b );
8309     ok( hr == S_OK, "loadXML failed\n");
8310     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8311
8312     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
8313     ok( hr == S_OK, "got 0x%08x\n", hr);
8314
8315     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
8316     ok( hr == S_OK, "got 0x%08x\n", hr);
8317     ok( elem2 != elem, "got same instance\n");
8318
8319     ret_attr = (void*)0xdeadbeef;
8320     hr = IXMLDOMElement_setAttributeNode(elem, NULL, &ret_attr);
8321     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
8322     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8323
8324     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8325     ok( hr == S_OK, "got 0x%08x\n", hr);
8326
8327     ref1 = IXMLDOMElement_AddRef(elem);
8328     IXMLDOMElement_Release(elem);
8329
8330     ret_attr = (void*)0xdeadbeef;
8331     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8332     ok( hr == S_OK, "got 0x%08x\n", hr);
8333     ok( ret_attr == NULL, "got %p\n", ret_attr);
8334
8335     /* no reference added */
8336     ref2 = IXMLDOMElement_AddRef(elem);
8337     IXMLDOMElement_Release(elem);
8338     ok(ref2 == ref1, "got %d, expected %d\n", ref2, ref1);
8339
8340     EXPECT_CHILDREN(elem);
8341     EXPECT_CHILDREN(elem2);
8342
8343     IXMLDOMElement_Release(elem2);
8344
8345     attr2 = NULL;
8346     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attr"), &attr2);
8347     ok( hr == S_OK, "got 0x%08x\n", hr);
8348     ok( attr2 != attr, "got same instance %p\n", attr2);
8349     IXMLDOMAttribute_Release(attr2);
8350
8351     /* try to add it another time */
8352     ret_attr = (void*)0xdeadbeef;
8353     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8354     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8355     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8356
8357     IXMLDOMElement_Release(elem);
8358
8359     /* initially used element is released, attribute still 'has' a container */
8360     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
8361     ok( hr == S_OK, "got 0x%08x\n", hr);
8362     ret_attr = (void*)0xdeadbeef;
8363     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8364     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8365     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8366     IXMLDOMElement_Release(elem);
8367
8368     /* add attribute already attached to another document */
8369     doc2 = create_document(&IID_IXMLDOMDocument);
8370
8371     hr = IXMLDOMDocument_loadXML( doc2, _bstr_(complete4A), &b );
8372     ok( hr == S_OK, "loadXML failed\n");
8373     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8374
8375     hr = IXMLDOMDocument_get_documentElement(doc2, &elem);
8376     ok( hr == S_OK, "got 0x%08x\n", hr);
8377     hr = IXMLDOMElement_setAttributeNode(elem, attr, NULL);
8378     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8379     IXMLDOMElement_Release(elem);
8380
8381     IXMLDOMAttribute_Release(attr);
8382
8383     /* create element, add attribute, see if it's copied or linked */
8384     hr = IXMLDOMDocument_createElement(doc, _bstr_("test"), &elem);
8385     ok( hr == S_OK, "got 0x%08x\n", hr);
8386
8387     attr = NULL;
8388     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8389     ok(hr == S_OK, "got 0x%08x\n", hr);
8390     ok(attr != NULL, "got %p\n", attr);
8391
8392     ref1 = IXMLDOMAttribute_AddRef(attr);
8393     IXMLDOMAttribute_Release(attr);
8394
8395     V_VT(&v) = VT_BSTR;
8396     V_BSTR(&v) = _bstr_("attrvalue1");
8397     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
8398     ok( hr == S_OK, "got 0x%08x\n", hr);
8399
8400     str = NULL;
8401     hr = IXMLDOMAttribute_get_xml(attr, &str);
8402     ok( hr == S_OK, "got 0x%08x\n", hr);
8403     ok( lstrcmpW(str, _bstr_("attr=\"attrvalue1\"")) == 0,
8404         "got %s\n", wine_dbgstr_w(str));
8405     SysFreeString(str);
8406
8407     ret_attr = (void*)0xdeadbeef;
8408     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8409     ok(hr == S_OK, "got 0x%08x\n", hr);
8410     ok(ret_attr == NULL, "got %p\n", ret_attr);
8411
8412     /* attribute reference increased */
8413     ref2 = IXMLDOMAttribute_AddRef(attr);
8414     IXMLDOMAttribute_Release(attr);
8415     ok(ref1 == ref2, "got %d, expected %d\n", ref2, ref1);
8416
8417     hr = IXMLDOMElement_get_xml(elem, &str);
8418     ok( hr == S_OK, "got 0x%08x\n", hr);
8419     ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue1\"/>")) == 0,
8420         "got %s\n", wine_dbgstr_w(str));
8421     SysFreeString(str);
8422
8423     V_VT(&v) = VT_BSTR;
8424     V_BSTR(&v) = _bstr_("attrvalue2");
8425     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
8426     ok( hr == S_OK, "got 0x%08x\n", hr);
8427
8428     hr = IXMLDOMElement_get_xml(elem, &str);
8429     ok( hr == S_OK, "got 0x%08x\n", hr);
8430     todo_wine ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue2\"/>")) == 0,
8431         "got %s\n", wine_dbgstr_w(str));
8432     SysFreeString(str);
8433
8434     IXMLDOMElement_Release(elem);
8435     IXMLDOMAttribute_Release(attr);
8436     IXMLDOMDocument_Release(doc2);
8437     IXMLDOMDocument_Release(doc);
8438     free_bstrs();
8439 }
8440
8441 static void test_put_dataType(void)
8442 {
8443     IXMLDOMCDATASection *cdata;
8444     IXMLDOMDocument *doc;
8445     VARIANT_BOOL b;
8446     HRESULT hr;
8447
8448     doc = create_document(&IID_IXMLDOMDocument);
8449     if (!doc) return;
8450
8451     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8452     ok( hr == S_OK, "loadXML failed\n");
8453     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8454
8455     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("test"), &cdata);
8456     ok( hr == S_OK, "got 0x%08x\n", hr);
8457     hr = IXMLDOMCDATASection_put_dataType(cdata, _bstr_("number"));
8458     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8459     hr = IXMLDOMCDATASection_put_dataType(cdata, _bstr_("string"));
8460     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8461     IXMLDOMCDATASection_Release(cdata);
8462
8463     IXMLDOMDocument_Release(doc);
8464     free_bstrs();
8465 }
8466
8467 static void test_createNode(void)
8468 {
8469     IXMLDOMDocument *doc;
8470     IXMLDOMElement *elem;
8471     IXMLDOMNode *node;
8472     VARIANT v, var;
8473     BSTR prefix, str;
8474     HRESULT hr;
8475     ULONG ref;
8476
8477     doc = create_document(&IID_IXMLDOMDocument);
8478     if (!doc) return;
8479
8480     EXPECT_REF(doc, 1);
8481
8482     /* reference count tests */
8483     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
8484     ok( hr == S_OK, "got 0x%08x\n", hr);
8485
8486     /* initial reference is 2 */
8487 todo_wine {
8488     EXPECT_REF(elem, 2);
8489     ref = IXMLDOMElement_Release(elem);
8490     ok(ref == 1, "got %d\n", ref);
8491     /* it's released already, attempt to release now will crash it */
8492 }
8493
8494     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
8495     ok( hr == S_OK, "got 0x%08x\n", hr);
8496     todo_wine EXPECT_REF(elem, 2);
8497     IXMLDOMDocument_Release(doc);
8498     todo_wine EXPECT_REF(elem, 2);
8499     IXMLDOMElement_Release(elem);
8500
8501     doc = create_document(&IID_IXMLDOMDocument);
8502
8503     /* NODE_ELEMENT nodes */
8504     /* 1. specified namespace */
8505     V_VT(&v) = VT_I4;
8506     V_I4(&v) = NODE_ELEMENT;
8507
8508     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("ns1:test"), _bstr_("http://winehq.org"), &node);
8509     ok( hr == S_OK, "got 0x%08x\n", hr);
8510     prefix = NULL;
8511     hr = IXMLDOMNode_get_prefix(node, &prefix);
8512     ok( hr == S_OK, "got 0x%08x\n", hr);
8513     ok(lstrcmpW(prefix, _bstr_("ns1")) == 0, "wrong prefix\n");
8514     SysFreeString(prefix);
8515     IXMLDOMNode_Release(node);
8516
8517     /* 2. default namespace */
8518     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("test"), _bstr_("http://winehq.org/default"), &node);
8519     ok( hr == S_OK, "got 0x%08x\n", hr);
8520     prefix = (void*)0xdeadbeef;
8521     hr = IXMLDOMNode_get_prefix(node, &prefix);
8522     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8523     ok(prefix == 0, "expected empty prefix, got %p\n", prefix);
8524     /* check dump */
8525     hr = IXMLDOMNode_get_xml(node, &str);
8526     ok( hr == S_OK, "got 0x%08x\n", hr);
8527     ok( lstrcmpW(str, _bstr_("<test xmlns=\"http://winehq.org/default\"/>")) == 0,
8528         "got %s\n", wine_dbgstr_w(str));
8529     SysFreeString(str);
8530
8531     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
8532     ok( hr == S_OK, "got 0x%08x\n", hr);
8533
8534     V_VT(&var) = VT_BSTR;
8535     hr = IXMLDOMElement_getAttribute(elem, _bstr_("xmlns"), &var);
8536     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8537     ok( V_VT(&var) == VT_NULL, "got %d\n", V_VT(&var));
8538
8539     str = NULL;
8540     hr = IXMLDOMElement_get_namespaceURI(elem, &str);
8541     ok( hr == S_OK, "got 0x%08x\n", hr);
8542     ok( lstrcmpW(str, _bstr_("http://winehq.org/default")) == 0, "expected default namespace\n");
8543     SysFreeString(str);
8544
8545     IXMLDOMElement_Release(elem);
8546     IXMLDOMNode_Release(node);
8547
8548     IXMLDOMDocument_Release(doc);
8549     free_bstrs();
8550 }
8551
8552 static const char get_prefix_doc[] =
8553     "<?xml version=\"1.0\" ?>"
8554     "<a xmlns:ns1=\"ns1 href\" />";
8555
8556 static void test_get_prefix(void)
8557 {
8558     IXMLDOMDocumentFragment *fragment;
8559     IXMLDOMCDATASection *cdata;
8560     IXMLDOMElement *element;
8561     IXMLDOMComment *comment;
8562     IXMLDOMDocument *doc;
8563     VARIANT_BOOL b;
8564     HRESULT hr;
8565     BSTR str;
8566
8567     doc = create_document(&IID_IXMLDOMDocument);
8568     if (!doc) return;
8569
8570     /* nodes that can't support prefix */
8571     /* 1. document */
8572     str = (void*)0xdeadbeef;
8573     hr = IXMLDOMDocument_get_prefix(doc, &str);
8574     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8575     ok( str == 0, "got %p\n", str);
8576
8577     hr = IXMLDOMDocument_get_prefix(doc, NULL);
8578     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
8579
8580     /* 2. cdata */
8581     hr = IXMLDOMDocument_createCDATASection(doc, NULL, &cdata);
8582     ok(hr == S_OK, "got %08x\n", hr );
8583
8584     str = (void*)0xdeadbeef;
8585     hr = IXMLDOMCDATASection_get_prefix(cdata, &str);
8586     ok(hr == S_FALSE, "got %08x\n", hr);
8587     ok( str == 0, "got %p\n", str);
8588
8589     hr = IXMLDOMCDATASection_get_prefix(cdata, NULL);
8590     ok(hr == E_INVALIDARG, "got %08x\n", hr);
8591     IXMLDOMCDATASection_Release(cdata);
8592
8593     /* 3. comment */
8594     hr = IXMLDOMDocument_createComment(doc, NULL, &comment);
8595     ok(hr == S_OK, "got %08x\n", hr );
8596
8597     str = (void*)0xdeadbeef;
8598     hr = IXMLDOMComment_get_prefix(comment, &str);
8599     ok(hr == S_FALSE, "got %08x\n", hr);
8600     ok( str == 0, "got %p\n", str);
8601
8602     hr = IXMLDOMComment_get_prefix(comment, NULL);
8603     ok(hr == E_INVALIDARG, "got %08x\n", hr);
8604     IXMLDOMComment_Release(comment);
8605
8606     /* 4. fragment */
8607     hr = IXMLDOMDocument_createDocumentFragment(doc, &fragment);
8608     ok(hr == S_OK, "got %08x\n", hr );
8609
8610     str = (void*)0xdeadbeef;
8611     hr = IXMLDOMDocumentFragment_get_prefix(fragment, &str);
8612     ok(hr == S_FALSE, "got %08x\n", hr);
8613     ok( str == 0, "got %p\n", str);
8614
8615     hr = IXMLDOMDocumentFragment_get_prefix(fragment, NULL);
8616     ok(hr == E_INVALIDARG, "got %08x\n", hr);
8617     IXMLDOMDocumentFragment_Release(fragment);
8618
8619     /* no prefix */
8620     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &element);
8621     ok( hr == S_OK, "got 0x%08x\n", hr);
8622
8623     hr = IXMLDOMElement_get_prefix(element, NULL);
8624     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
8625
8626     str = (void*)0xdeadbeef;
8627     hr = IXMLDOMElement_get_prefix(element, &str);
8628     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8629     ok( str == 0, "got %p\n", str);
8630
8631     IXMLDOMElement_Release(element);
8632
8633     /* with prefix */
8634     hr = IXMLDOMDocument_createElement(doc, _bstr_("a:elem"), &element);
8635     ok( hr == S_OK, "got 0x%08x\n", hr);
8636
8637     str = (void*)0xdeadbeef;
8638     hr = IXMLDOMElement_get_prefix(element, &str);
8639     ok( hr == S_OK, "got 0x%08x\n", hr);
8640     ok( lstrcmpW(str, _bstr_("a")) == 0, "expected prefix \"a\"\n");
8641     SysFreeString(str);
8642
8643     str = (void*)0xdeadbeef;
8644     hr = IXMLDOMElement_get_namespaceURI(element, &str);
8645     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8646     ok( str == 0, "got %p\n", str);
8647
8648     IXMLDOMElement_Release(element);
8649
8650     hr = IXMLDOMDocument_loadXML(doc, _bstr_(get_prefix_doc), &b);
8651     EXPECT_HR(hr, S_OK);
8652
8653     hr = IXMLDOMDocument_get_documentElement(doc, &element);
8654     EXPECT_HR(hr, S_OK);
8655
8656     str = (void*)0xdeadbeef;
8657     hr = IXMLDOMElement_get_prefix(element, &str);
8658     EXPECT_HR(hr, S_FALSE);
8659     ok(str == NULL, "got %p\n", str);
8660
8661     str = (void*)0xdeadbeef;
8662     hr = IXMLDOMElement_get_namespaceURI(element, &str);
8663     EXPECT_HR(hr, S_FALSE);
8664     ok(str == NULL, "got %s\n", wine_dbgstr_w(str));
8665
8666     IXMLDOMDocument_Release(doc);
8667     free_bstrs();
8668 }
8669
8670 static void test_selectSingleNode(void)
8671 {
8672     IXMLDOMDocument *doc;
8673     IXMLDOMNodeList *list;
8674     IXMLDOMNode *node;
8675     VARIANT_BOOL b;
8676     HRESULT hr;
8677     LONG len;
8678
8679     doc = create_document(&IID_IXMLDOMDocument);
8680     if (!doc) return;
8681
8682     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
8683     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8684
8685     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
8686     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8687
8688     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8689     ok( hr == S_OK, "loadXML failed\n");
8690     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8691
8692     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
8693     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8694
8695     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
8696     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8697
8698     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), NULL);
8699     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8700
8701     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), NULL);
8702     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8703
8704     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), &node);
8705     ok(hr == S_OK, "got 0x%08x\n", hr);
8706     IXMLDOMNode_Release(node);
8707
8708     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), &list);
8709     ok(hr == S_OK, "got 0x%08x\n", hr);
8710     IXMLDOMNodeList_Release(list);
8711
8712     list = (void*)0xdeadbeef;
8713     hr = IXMLDOMDocument_selectNodes(doc, NULL, &list);
8714     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8715     ok(list == (void*)0xdeadbeef, "got %p\n", list);
8716
8717     node = (void*)0xdeadbeef;
8718     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("nonexistent"), &node);
8719     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8720     ok(node == 0, "got %p\n", node);
8721
8722     list = (void*)0xdeadbeef;
8723     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("nonexistent"), &list);
8724     ok(hr == S_OK, "got 0x%08x\n", hr);
8725     len = 1;
8726     hr = IXMLDOMNodeList_get_length(list, &len);
8727     ok(hr == S_OK, "got 0x%08x\n", hr);
8728     ok(len == 0, "got %d\n", len);
8729     IXMLDOMNodeList_Release(list);
8730
8731     IXMLDOMDocument_Release(doc);
8732     free_bstrs();
8733 }
8734
8735 static void test_events(void)
8736 {
8737     IConnectionPointContainer *conn;
8738     IConnectionPoint *point;
8739     IXMLDOMDocument *doc;
8740     HRESULT hr;
8741     VARIANT v;
8742     IDispatch *event;
8743
8744     doc = create_document(&IID_IXMLDOMDocument);
8745     if (!doc) return;
8746
8747     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&conn);
8748     ok(hr == S_OK, "got 0x%08x\n", hr);
8749
8750     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IDispatch, &point);
8751     ok(hr == S_OK, "got 0x%08x\n", hr);
8752     IConnectionPoint_Release(point);
8753     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IPropertyNotifySink, &point);
8754     ok(hr == S_OK, "got 0x%08x\n", hr);
8755     IConnectionPoint_Release(point);
8756     hr = IConnectionPointContainer_FindConnectionPoint(conn, &DIID_XMLDOMDocumentEvents, &point);
8757     ok(hr == S_OK, "got 0x%08x\n", hr);
8758     IConnectionPoint_Release(point);
8759
8760     IConnectionPointContainer_Release(conn);
8761
8762     /* ready state callback */
8763     VariantInit(&v);
8764     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8765     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
8766
8767     event = create_dispevent();
8768     V_VT(&v) = VT_UNKNOWN;
8769     V_UNKNOWN(&v) = (IUnknown*)event;
8770
8771     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8772     ok(hr == S_OK, "got 0x%08x\n", hr);
8773     EXPECT_REF(event, 2);
8774
8775     V_VT(&v) = VT_DISPATCH;
8776     V_DISPATCH(&v) = event;
8777
8778     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8779     ok(hr == S_OK, "got 0x%08x\n", hr);
8780     EXPECT_REF(event, 2);
8781
8782     /* VT_NULL doesn't reset event handler */
8783     V_VT(&v) = VT_NULL;
8784     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8785     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
8786     EXPECT_REF(event, 2);
8787
8788     V_VT(&v) = VT_DISPATCH;
8789     V_DISPATCH(&v) = NULL;
8790
8791     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8792     ok(hr == S_OK, "got 0x%08x\n", hr);
8793     EXPECT_REF(event, 1);
8794
8795     V_VT(&v) = VT_UNKNOWN;
8796     V_DISPATCH(&v) = NULL;
8797     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
8798     ok(hr == S_OK, "got 0x%08x\n", hr);
8799
8800     IDispatch_Release(event);
8801
8802     IXMLDOMDocument_Release(doc);
8803 }
8804
8805 static void test_createProcessingInstruction(void)
8806 {
8807     static const WCHAR bodyW[] = {'t','e','s','t',0};
8808     IXMLDOMProcessingInstruction *pi;
8809     IXMLDOMDocument *doc;
8810     WCHAR buff[10];
8811     HRESULT hr;
8812
8813     doc = create_document(&IID_IXMLDOMDocument);
8814     if (!doc) return;
8815
8816     /* test for BSTR handling, pass broken BSTR */
8817     memcpy(&buff[2], bodyW, sizeof(bodyW));
8818     /* just a big length */
8819     *(DWORD*)buff = 0xf0f0;
8820     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("test"), &buff[2], &pi);
8821     ok(hr == S_OK, "got 0x%08x\n", hr);
8822
8823     IXMLDOMProcessingInstruction_Release(pi);
8824     IXMLDOMDocument_Release(doc);
8825 }
8826
8827 static void test_put_nodeTypedValue(void)
8828 {
8829     IXMLDOMDocument *doc;
8830     IXMLDOMElement *elem;
8831     VARIANT type;
8832     HRESULT hr;
8833
8834     doc = create_document(&IID_IXMLDOMDocument);
8835     if (!doc) return;
8836
8837     hr = IXMLDOMDocument_createElement(doc, _bstr_("Element"), &elem);
8838     ok(hr == S_OK, "got 0x%08x\n", hr);
8839
8840     V_VT(&type) = VT_EMPTY;
8841     hr = IXMLDOMElement_get_dataType(elem, &type);
8842     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8843     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8844
8845     /* set typed value for untyped node */
8846     V_VT(&type) = VT_I1;
8847     V_I1(&type) = 1;
8848     hr = IXMLDOMElement_put_nodeTypedValue(elem, type);
8849     ok(hr == S_OK, "got 0x%08x\n", hr);
8850
8851     V_VT(&type) = VT_EMPTY;
8852     hr = IXMLDOMElement_get_dataType(elem, &type);
8853     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8854     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8855
8856     /* no type info stored */
8857     V_VT(&type) = VT_EMPTY;
8858     hr = IXMLDOMElement_get_nodeTypedValue(elem, &type);
8859     ok(hr == S_OK, "got 0x%08x\n", hr);
8860     ok(V_VT(&type) == VT_BSTR, "got %d, expected VT_BSTR\n", V_VT(&type));
8861     ok(memcmp(V_BSTR(&type), _bstr_("1"), 2*sizeof(WCHAR)) == 0,
8862        "got %s, expected \"1\"\n", wine_dbgstr_w(V_BSTR(&type)));
8863     VariantClear(&type);
8864
8865     IXMLDOMElement_Release(elem);
8866     IXMLDOMDocument_Release(doc);
8867     free_bstrs();
8868 }
8869
8870 static void test_get_xml(void)
8871 {
8872     static const char xmlA[] = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\r\n<a>test</a>\r\n";
8873     static const char fooA[] = "<foo/>";
8874     IXMLDOMProcessingInstruction *pi;
8875     IXMLDOMNode *first;
8876     IXMLDOMElement *elem = NULL;
8877     IXMLDOMDocument *doc;
8878     VARIANT_BOOL b;
8879     VARIANT v;
8880     BSTR xml;
8881     HRESULT hr;
8882
8883     doc = create_document(&IID_IXMLDOMDocument);
8884     if (!doc) return;
8885
8886     b = VARIANT_TRUE;
8887     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8888     ok(hr == S_OK, "got 0x%08x\n", hr);
8889     ok( b == VARIANT_TRUE, "got %d\n", b);
8890
8891     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"),
8892                              _bstr_("version=\"1.0\" encoding=\"UTF-16\""), &pi);
8893     ok(hr == S_OK, "got 0x%08x\n", hr);
8894
8895     hr = IXMLDOMDocument_get_firstChild(doc, &first);
8896     ok(hr == S_OK, "got 0x%08x\n", hr);
8897
8898     V_UNKNOWN(&v) = (IUnknown*)first;
8899     V_VT(&v) = VT_UNKNOWN;
8900
8901     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)pi, v, NULL);
8902     ok(hr == S_OK, "got 0x%08x\n", hr);
8903
8904     IXMLDOMProcessingInstruction_Release(pi);
8905     IXMLDOMNode_Release(first);
8906
8907     hr = IXMLDOMDocument_get_xml(doc, &xml);
8908     ok(hr == S_OK, "got 0x%08x\n", hr);
8909
8910     ok(memcmp(xml, _bstr_(xmlA), sizeof(xmlA)*sizeof(WCHAR)) == 0,
8911         "got %s, expected %s\n", wine_dbgstr_w(xml), xmlA);
8912     SysFreeString(xml);
8913
8914     IXMLDOMDocument_Release(doc);
8915
8916     doc = create_document(&IID_IXMLDOMDocument);
8917
8918     hr = IXMLDOMDocument_createElement(doc, _bstr_("foo"), &elem);
8919     ok(hr == S_OK, "got 0x%08x\n", hr);
8920
8921     hr = IXMLDOMDocument_putref_documentElement(doc, elem);
8922     ok(hr == S_OK, "got 0x%08x\n", hr);
8923
8924     hr = IXMLDOMDocument_get_xml(doc, &xml);
8925     ok(hr == S_OK, "got 0x%08x\n", hr);
8926
8927     ok(memcmp(xml, _bstr_(fooA), (sizeof(fooA)-1)*sizeof(WCHAR)) == 0,
8928         "got %s, expected %s\n", wine_dbgstr_w(xml), fooA);
8929     SysFreeString(xml);
8930
8931     IXMLDOMElement_Release(elem);
8932     IXMLDOMDocument_Release(doc);
8933
8934     free_bstrs();
8935 }
8936
8937 static void test_xsltemplate(void)
8938 {
8939     IXSLTemplate *template;
8940     IXSLProcessor *processor;
8941     IXMLDOMDocument *doc, *doc2;
8942     IStream *stream;
8943     VARIANT_BOOL b;
8944     HRESULT hr;
8945     ULONG ref1, ref2;
8946     VARIANT v;
8947
8948     template = create_xsltemplate(&IID_IXSLTemplate);
8949     if (!template) return;
8950
8951     /* works as reset */
8952     hr = IXSLTemplate_putref_stylesheet(template, NULL);
8953     ok(hr == S_OK, "got 0x%08x\n", hr);
8954
8955     doc = create_document(&IID_IXMLDOMDocument);
8956
8957     b = VARIANT_TRUE;
8958     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8959     ok(hr == S_OK, "got 0x%08x\n", hr);
8960     ok( b == VARIANT_TRUE, "got %d\n", b);
8961
8962     /* putref with non-xsl document */
8963     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8964     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8965
8966     b = VARIANT_TRUE;
8967     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8968     ok(hr == S_OK, "got 0x%08x\n", hr);
8969     ok( b == VARIANT_TRUE, "got %d\n", b);
8970
8971     /* not a freethreaded document */
8972     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8973     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8974
8975     IXMLDOMDocument_Release(doc);
8976
8977     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
8978     if (hr != S_OK)
8979     {
8980         win_skip("failed to create free threaded document instance: 0x%08x\n", hr);
8981         IXSLTemplate_Release(template);
8982         return;
8983     }
8984
8985     b = VARIANT_TRUE;
8986     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8987     ok(hr == S_OK, "got 0x%08x\n", hr);
8988     ok( b == VARIANT_TRUE, "got %d\n", b);
8989
8990     /* freethreaded document */
8991     ref1 = IXMLDOMDocument_AddRef(doc);
8992     IXMLDOMDocument_Release(doc);
8993     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8994     ok(hr == S_OK, "got 0x%08x\n", hr);
8995     ref2 = IXMLDOMDocument_AddRef(doc);
8996     IXMLDOMDocument_Release(doc);
8997     ok(ref2 > ref1, "got %d\n", ref2);
8998
8999     /* processor */
9000     hr = IXSLTemplate_createProcessor(template, NULL);
9001     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9002
9003     EXPECT_REF(template, 1);
9004     hr = IXSLTemplate_createProcessor(template, &processor);
9005     ok(hr == S_OK, "got 0x%08x\n", hr);
9006     EXPECT_REF(template, 2);
9007
9008     /* input no set yet */
9009     V_VT(&v) = VT_BSTR;
9010     V_BSTR(&v) = NULL;
9011     hr = IXSLProcessor_get_input(processor, &v);
9012 todo_wine {
9013     ok(hr == S_OK, "got 0x%08x\n", hr);
9014     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
9015 }
9016
9017     hr = IXSLProcessor_get_output(processor, NULL);
9018     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9019
9020     /* reset before it was set */
9021     V_VT(&v) = VT_EMPTY;
9022     hr = IXSLProcessor_put_output(processor, v);
9023     ok(hr == S_OK, "got 0x%08x\n", hr);
9024
9025     CreateStreamOnHGlobal(NULL, TRUE, &stream);
9026     EXPECT_REF(stream, 1);
9027
9028     V_VT(&v) = VT_UNKNOWN;
9029     V_UNKNOWN(&v) = (IUnknown*)stream;
9030     hr = IXSLProcessor_put_output(processor, v);
9031     ok(hr == S_OK, "got 0x%08x\n", hr);
9032
9033     /* it seems processor grabs 2 references */
9034     todo_wine EXPECT_REF(stream, 3);
9035
9036     V_VT(&v) = VT_EMPTY;
9037     hr = IXSLProcessor_get_output(processor, &v);
9038     ok(hr == S_OK, "got 0x%08x\n", hr);
9039     ok(V_VT(&v) == VT_UNKNOWN, "got type %d\n", V_VT(&v));
9040     ok(V_UNKNOWN(&v) == (IUnknown*)stream, "got %p\n", V_UNKNOWN(&v));
9041
9042     todo_wine EXPECT_REF(stream, 4);
9043     VariantClear(&v);
9044
9045     hr = IXSLProcessor_transform(processor, NULL);
9046     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9047
9048     /* reset and check stream refcount */
9049     V_VT(&v) = VT_EMPTY;
9050     hr = IXSLProcessor_put_output(processor, v);
9051     ok(hr == S_OK, "got 0x%08x\n", hr);
9052
9053     EXPECT_REF(stream, 1);
9054
9055     IStream_Release(stream);
9056
9057     /* no output interface set, check output */
9058     doc2 = create_document(&IID_IXMLDOMDocument);
9059
9060     b = VARIANT_TRUE;
9061     hr = IXMLDOMDocument_loadXML( doc2, _bstr_("<a>test</a>"), &b );
9062     ok(hr == S_OK, "got 0x%08x\n", hr);
9063     ok( b == VARIANT_TRUE, "got %d\n", b);
9064
9065     V_VT(&v) = VT_UNKNOWN;
9066     V_UNKNOWN(&v) = (IUnknown*)doc2;
9067     hr = IXSLProcessor_put_input(processor, v);
9068     ok(hr == S_OK, "got 0x%08x\n", hr);
9069
9070     hr = IXSLProcessor_transform(processor, &b);
9071     ok(hr == S_OK, "got 0x%08x\n", hr);
9072
9073     V_VT(&v) = VT_EMPTY;
9074     hr = IXSLProcessor_get_output(processor, &v);
9075     ok(hr == S_OK, "got 0x%08x\n", hr);
9076     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
9077     /* we currently output one '\n' instead of empty string */
9078     todo_wine ok(lstrcmpW(V_BSTR(&v), _bstr_("")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
9079     IXMLDOMDocument_Release(doc2);
9080     VariantClear(&v);
9081
9082     IXSLProcessor_Release(processor);
9083
9084     /* drop reference */
9085     hr = IXSLTemplate_putref_stylesheet(template, NULL);
9086     ok(hr == S_OK, "got 0x%08x\n", hr);
9087     ref2 = IXMLDOMDocument_AddRef(doc);
9088     IXMLDOMDocument_Release(doc);
9089     ok(ref2 == ref1, "got %d\n", ref2);
9090
9091     IXMLDOMDocument_Release(doc);
9092     IXSLTemplate_Release(template);
9093     free_bstrs();
9094 }
9095
9096 static void test_insertBefore(void)
9097 {
9098     IXMLDOMDocument *doc, *doc2;
9099     IXMLDOMAttribute *attr;
9100     IXMLDOMElement *elem1, *elem2, *elem3, *elem4, *elem5;
9101     IXMLDOMNode *node, *newnode;
9102     HRESULT hr;
9103     VARIANT v;
9104     BSTR p;
9105
9106     doc = create_document(&IID_IXMLDOMDocument);
9107
9108     /* insertBefore behaviour for attribute node */
9109     V_VT(&v) = VT_I4;
9110     V_I4(&v) = NODE_ATTRIBUTE;
9111
9112     attr = NULL;
9113     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr"), NULL, (IXMLDOMNode**)&attr);
9114     ok(hr == S_OK, "got 0x%08x\n", hr);
9115     ok(attr != NULL, "got %p\n", attr);
9116
9117     /* attribute to attribute */
9118     V_VT(&v) = VT_I4;
9119     V_I4(&v) = NODE_ATTRIBUTE;
9120     newnode = NULL;
9121     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr2"), NULL, &newnode);
9122     ok(hr == S_OK, "got 0x%08x\n", hr);
9123     ok(newnode != NULL, "got %p\n", newnode);
9124
9125     V_VT(&v) = VT_NULL;
9126     node = (void*)0xdeadbeef;
9127     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9128     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9129     ok(node == NULL, "got %p\n", node);
9130
9131     V_VT(&v) = VT_UNKNOWN;
9132     V_UNKNOWN(&v) = (IUnknown*)attr;
9133     node = (void*)0xdeadbeef;
9134     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9135     todo_wine ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9136     ok(node == NULL, "got %p\n", node);
9137     IXMLDOMNode_Release(newnode);
9138
9139     /* cdata to attribute */
9140     V_VT(&v) = VT_I4;
9141     V_I4(&v) = NODE_CDATA_SECTION;
9142     newnode = NULL;
9143     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9144     ok(hr == S_OK, "got 0x%08x\n", hr);
9145     ok(newnode != NULL, "got %p\n", newnode);
9146
9147     V_VT(&v) = VT_NULL;
9148     node = (void*)0xdeadbeef;
9149     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9150     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9151     ok(node == NULL, "got %p\n", node);
9152     IXMLDOMNode_Release(newnode);
9153
9154     /* comment to attribute */
9155     V_VT(&v) = VT_I4;
9156     V_I4(&v) = NODE_COMMENT;
9157     newnode = NULL;
9158     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9159     ok(hr == S_OK, "got 0x%08x\n", hr);
9160     ok(newnode != NULL, "got %p\n", newnode);
9161
9162     V_VT(&v) = VT_NULL;
9163     node = (void*)0xdeadbeef;
9164     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9165     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9166     ok(node == NULL, "got %p\n", node);
9167     IXMLDOMNode_Release(newnode);
9168
9169     /* element to attribute */
9170     V_VT(&v) = VT_I4;
9171     V_I4(&v) = NODE_ELEMENT;
9172     newnode = NULL;
9173     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9174     ok(hr == S_OK, "got 0x%08x\n", hr);
9175     ok(newnode != NULL, "got %p\n", newnode);
9176
9177     V_VT(&v) = VT_NULL;
9178     node = (void*)0xdeadbeef;
9179     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9180     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9181     ok(node == NULL, "got %p\n", node);
9182     IXMLDOMNode_Release(newnode);
9183
9184     /* pi to attribute */
9185     V_VT(&v) = VT_I4;
9186     V_I4(&v) = NODE_PROCESSING_INSTRUCTION;
9187     newnode = NULL;
9188     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9189     ok(hr == S_OK, "got 0x%08x\n", hr);
9190     ok(newnode != NULL, "got %p\n", newnode);
9191
9192     V_VT(&v) = VT_NULL;
9193     node = (void*)0xdeadbeef;
9194     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9195     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9196     ok(node == NULL, "got %p\n", node);
9197     IXMLDOMNode_Release(newnode);
9198     IXMLDOMAttribute_Release(attr);
9199
9200     /* insertBefore for elements */
9201     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem1);
9202     ok(hr == S_OK, "got 0x%08x\n", hr);
9203
9204     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem2"), &elem2);
9205     ok(hr == S_OK, "got 0x%08x\n", hr);
9206
9207     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
9208     ok(hr == S_OK, "got 0x%08x\n", hr);
9209
9210     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
9211     ok(hr == S_OK, "got 0x%08x\n", hr);
9212
9213     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem4"), &elem4);
9214     ok(hr == S_OK, "got 0x%08x\n", hr);
9215
9216     EXPECT_NO_CHILDREN(elem1);
9217     EXPECT_NO_CHILDREN(elem2);
9218     EXPECT_NO_CHILDREN(elem3);
9219
9220     todo_wine EXPECT_REF(elem2, 2);
9221
9222     V_VT(&v) = VT_DISPATCH;
9223     V_DISPATCH(&v) = NULL;
9224     node = NULL;
9225     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem4, v, &node);
9226     ok(hr == S_OK, "got 0x%08x\n", hr);
9227     ok(node == (void*)elem4, "got %p\n", node);
9228
9229     EXPECT_CHILDREN(elem1);
9230     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem4, NULL);
9231     EXPECT_HR(hr, S_OK);
9232     IXMLDOMElement_Release(elem4);
9233
9234     EXPECT_NO_CHILDREN(elem1);
9235
9236     V_VT(&v) = VT_NULL;
9237     node = NULL;
9238     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
9239     ok(hr == S_OK, "got 0x%08x\n", hr);
9240     ok(node == (void*)elem2, "got %p\n", node);
9241
9242     EXPECT_CHILDREN(elem1);
9243     todo_wine EXPECT_REF(elem2, 3);
9244     IXMLDOMNode_Release(node);
9245
9246     /* again for already linked node */
9247     V_VT(&v) = VT_NULL;
9248     node = NULL;
9249     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
9250     ok(hr == S_OK, "got 0x%08x\n", hr);
9251     ok(node == (void*)elem2, "got %p\n", node);
9252
9253     EXPECT_CHILDREN(elem1);
9254
9255     /* increments each time */
9256     todo_wine EXPECT_REF(elem2, 3);
9257     IXMLDOMNode_Release(node);
9258
9259     /* try to add to another element */
9260     V_VT(&v) = VT_NULL;
9261     node = (void*)0xdeadbeef;
9262     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem2, v, &node);
9263     ok(hr == S_OK, "got 0x%08x\n", hr);
9264     ok(node == (void*)elem2, "got %p\n", node);
9265
9266     EXPECT_CHILDREN(elem3);
9267     EXPECT_NO_CHILDREN(elem1);
9268
9269     IXMLDOMNode_Release(node);
9270
9271     /* cross document case - try to add as child to a node created with other doc */
9272     doc2 = create_document(&IID_IXMLDOMDocument);
9273
9274     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem4);
9275     ok(hr == S_OK, "got 0x%08x\n", hr);
9276     todo_wine EXPECT_REF(elem4, 2);
9277
9278     /* same name, another instance */
9279     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem5);
9280     ok(hr == S_OK, "got 0x%08x\n", hr);
9281     todo_wine EXPECT_REF(elem5, 2);
9282
9283     todo_wine EXPECT_REF(elem3, 2);
9284     V_VT(&v) = VT_NULL;
9285     node = NULL;
9286     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem4, v, &node);
9287     ok(hr == S_OK, "got 0x%08x\n", hr);
9288     ok(node == (void*)elem4, "got %p\n", node);
9289     todo_wine EXPECT_REF(elem4, 3);
9290     todo_wine EXPECT_REF(elem3, 2);
9291     IXMLDOMNode_Release(node);
9292
9293     V_VT(&v) = VT_NULL;
9294     node = NULL;
9295     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem5, v, &node);
9296     ok(hr == S_OK, "got 0x%08x\n", hr);
9297     ok(node == (void*)elem5, "got %p\n", node);
9298     todo_wine EXPECT_REF(elem4, 2);
9299     todo_wine EXPECT_REF(elem5, 3);
9300     IXMLDOMNode_Release(node);
9301
9302     IXMLDOMDocument_Release(doc2);
9303
9304     IXMLDOMElement_Release(elem1);
9305     IXMLDOMElement_Release(elem2);
9306     IXMLDOMElement_Release(elem3);
9307     IXMLDOMElement_Release(elem4);
9308     IXMLDOMElement_Release(elem5);
9309
9310     /* elements with same default namespace */
9311     V_VT(&v) = VT_I4;
9312     V_I4(&v) = NODE_ELEMENT;
9313     elem1 = NULL;
9314     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
9315     ok(hr == S_OK, "got 0x%08x\n", hr);
9316     ok(elem1 != NULL, "got %p\n", elem1);
9317
9318     V_VT(&v) = VT_I4;
9319     V_I4(&v) = NODE_ELEMENT;
9320     elem2 = NULL;
9321     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem2);
9322     ok(hr == S_OK, "got 0x%08x\n", hr);
9323     ok(elem2 != NULL, "got %p\n", elem2);
9324
9325     /* check contents so far */
9326     p = NULL;
9327     hr = IXMLDOMElement_get_xml(elem1, &p);
9328     ok(hr == S_OK, "got 0x%08x\n", hr);
9329     ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9330     SysFreeString(p);
9331
9332     p = NULL;
9333     hr = IXMLDOMElement_get_xml(elem2, &p);
9334     ok(hr == S_OK, "got 0x%08x\n", hr);
9335     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9336     SysFreeString(p);
9337
9338     V_VT(&v) = VT_NULL;
9339     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
9340     ok(hr == S_OK, "got 0x%08x\n", hr);
9341
9342     /* get_xml depends on context, for top node it omits child namespace attribute,
9343        but at child level it's still returned */
9344     p = NULL;
9345     hr = IXMLDOMElement_get_xml(elem1, &p);
9346     ok(hr == S_OK, "got 0x%08x\n", hr);
9347     todo_wine ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"><elem2/></elem1>")),
9348         "got %s\n", wine_dbgstr_w(p));
9349     SysFreeString(p);
9350
9351     p = NULL;
9352     hr = IXMLDOMElement_get_xml(elem2, &p);
9353     ok(hr == S_OK, "got 0x%08x\n", hr);
9354     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9355     SysFreeString(p);
9356
9357     IXMLDOMElement_Release(elem1);
9358     IXMLDOMElement_Release(elem2);
9359
9360     /* child without default namespace added to node with default namespace */
9361     V_VT(&v) = VT_I4;
9362     V_I4(&v) = NODE_ELEMENT;
9363     elem1 = NULL;
9364     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
9365     ok(hr == S_OK, "got 0x%08x\n", hr);
9366     ok(elem1 != NULL, "got %p\n", elem1);
9367
9368     V_VT(&v) = VT_I4;
9369     V_I4(&v) = NODE_ELEMENT;
9370     elem2 = NULL;
9371     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), NULL, (IXMLDOMNode**)&elem2);
9372     ok(hr == S_OK, "got 0x%08x\n", hr);
9373     ok(elem2 != NULL, "got %p\n", elem2);
9374
9375     EXPECT_REF(elem2, 1);
9376     V_VT(&v) = VT_NULL;
9377     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
9378     ok(hr == S_OK, "got 0x%08x\n", hr);
9379     EXPECT_REF(elem2, 1);
9380
9381     p = NULL;
9382     hr = IXMLDOMElement_get_xml(elem2, &p);
9383     ok(hr == S_OK, "got 0x%08x\n", hr);
9384     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
9385     SysFreeString(p);
9386
9387     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem2, NULL);
9388     ok(hr == S_OK, "got 0x%08x\n", hr);
9389
9390     p = NULL;
9391     hr = IXMLDOMElement_get_xml(elem2, &p);
9392     ok(hr == S_OK, "got 0x%08x\n", hr);
9393     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
9394     SysFreeString(p);
9395
9396     IXMLDOMElement_Release(elem1);
9397     IXMLDOMElement_Release(elem2);
9398     IXMLDOMDocument_Release(doc);
9399 }
9400
9401 static void test_appendChild(void)
9402 {
9403     IXMLDOMDocument *doc, *doc2;
9404     IXMLDOMElement *elem, *elem2;
9405     HRESULT hr;
9406
9407     doc = create_document(&IID_IXMLDOMDocument);
9408     doc2 = create_document(&IID_IXMLDOMDocument);
9409
9410     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
9411     ok(hr == S_OK, "got 0x%08x\n", hr);
9412
9413     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem2"), &elem2);
9414     ok(hr == S_OK, "got 0x%08x\n", hr);
9415
9416     EXPECT_REF(doc, 1);
9417     todo_wine EXPECT_REF(elem, 2);
9418     EXPECT_REF(doc2, 1);
9419     todo_wine EXPECT_REF(elem2, 2);
9420     EXPECT_NO_CHILDREN(doc);
9421     EXPECT_NO_CHILDREN(doc2);
9422
9423     /* append from another document */
9424     hr = IXMLDOMDocument_appendChild(doc2, (IXMLDOMNode*)elem, NULL);
9425     ok(hr == S_OK, "got 0x%08x\n", hr);
9426
9427     EXPECT_REF(doc, 1);
9428     todo_wine EXPECT_REF(elem, 2);
9429     EXPECT_REF(doc2, 1);
9430     todo_wine EXPECT_REF(elem2, 2);
9431     EXPECT_NO_CHILDREN(doc);
9432     EXPECT_CHILDREN(doc2);
9433
9434     IXMLDOMElement_Release(elem);
9435     IXMLDOMElement_Release(elem2);
9436     IXMLDOMDocument_Release(doc);
9437     IXMLDOMDocument_Release(doc2);
9438 }
9439
9440 static void test_get_doctype(void)
9441 {
9442     IXMLDOMDocumentType *doctype;
9443     IXMLDOMDocument *doc;
9444     HRESULT hr;
9445
9446     doc = create_document(&IID_IXMLDOMDocument);
9447
9448     hr = IXMLDOMDocument_get_doctype(doc, NULL);
9449     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9450
9451     doctype = (void*)0xdeadbeef;
9452     hr = IXMLDOMDocument_get_doctype(doc, &doctype);
9453     ok(hr == S_FALSE, "got 0x%08x\n", hr);
9454     ok(doctype == NULL, "got %p\n", doctype);
9455
9456     IXMLDOMDocument_Release(doc);
9457 }
9458
9459 static void test_get_tagName(void)
9460 {
9461     IXMLDOMDocument *doc;
9462     IXMLDOMElement *elem, *elem2;
9463     HRESULT hr;
9464     BSTR str;
9465
9466     doc = create_document(&IID_IXMLDOMDocument);
9467
9468     hr = IXMLDOMDocument_createElement(doc, _bstr_("element"), &elem);
9469     ok(hr == S_OK, "got 0x%08x\n", hr);
9470
9471     hr = IXMLDOMElement_get_tagName(elem, NULL);
9472     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9473
9474     str = NULL;
9475     hr = IXMLDOMElement_get_tagName(elem, &str);
9476     ok(hr == S_OK, "got 0x%08x\n", hr);
9477     ok(!lstrcmpW(str, _bstr_("element")), "got %s\n", wine_dbgstr_w(str));
9478     SysFreeString(str);
9479
9480     hr = IXMLDOMDocument_createElement(doc, _bstr_("s:element"), &elem2);
9481     ok(hr == S_OK, "got 0x%08x\n", hr);
9482
9483     str = NULL;
9484     hr = IXMLDOMElement_get_tagName(elem2, &str);
9485     ok(hr == S_OK, "got 0x%08x\n", hr);
9486     ok(!lstrcmpW(str, _bstr_("s:element")), "got %s\n", wine_dbgstr_w(str));
9487     SysFreeString(str);
9488
9489     IXMLDOMDocument_Release(elem);
9490     IXMLDOMDocument_Release(elem2);
9491     IXMLDOMDocument_Release(doc);
9492     free_bstrs();
9493 }
9494
9495 typedef struct _get_datatype_t {
9496     DOMNodeType type;
9497     const char *name;
9498     VARTYPE vt;
9499     HRESULT hr;
9500 } get_datatype_t;
9501
9502 static const get_datatype_t get_datatype[] = {
9503     { NODE_ELEMENT,                "element",   VT_NULL, S_FALSE },
9504     { NODE_ATTRIBUTE,              "attr",      VT_NULL, S_FALSE },
9505     { NODE_TEXT,                   "text",      VT_NULL, S_FALSE },
9506     { NODE_CDATA_SECTION ,         "cdata",     VT_NULL, S_FALSE },
9507     { NODE_ENTITY_REFERENCE,       "entityref", VT_NULL, S_FALSE },
9508     { NODE_PROCESSING_INSTRUCTION, "pi",        VT_NULL, S_FALSE },
9509     { NODE_COMMENT,                "comment",   VT_NULL, S_FALSE },
9510     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   VT_NULL, S_FALSE },
9511     { 0 }
9512 };
9513
9514 static void test_get_dataType(void)
9515 {
9516     IXMLDOMDocument *doc;
9517     const get_datatype_t *entry = get_datatype;
9518
9519     doc = create_document(&IID_IXMLDOMDocument);
9520
9521     while (entry->type)
9522     {
9523         IXMLDOMNode *node = NULL;
9524         VARIANT var, type;
9525         HRESULT hr;
9526
9527         V_VT(&var) = VT_I4;
9528         V_I4(&var) = entry->type;
9529         hr = IXMLDOMDocument_createNode(doc, var, _bstr_(entry->name), NULL, &node);
9530         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9531
9532         hr = IXMLDOMNode_get_dataType(node, NULL);
9533         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9534
9535         VariantInit(&type);
9536         hr = IXMLDOMNode_get_dataType(node, &type);
9537         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
9538             hr, entry->hr, entry->type);
9539         ok(V_VT(&type) == entry->vt, "got %d, expected %d. node type %d\n",
9540             V_VT(&type), entry->vt, entry->type);
9541         VariantClear(&type);
9542
9543         IXMLDOMNode_Release(node);
9544
9545         entry++;
9546     }
9547
9548     IXMLDOMDocument_Release(doc);
9549     free_bstrs();
9550 }
9551
9552 typedef struct _get_node_typestring_t {
9553     DOMNodeType type;
9554     const char *string;
9555 } get_node_typestring_t;
9556
9557 static const get_node_typestring_t get_node_typestring[] = {
9558     { NODE_ELEMENT,                "element"               },
9559     { NODE_ATTRIBUTE,              "attribute"             },
9560     { NODE_TEXT,                   "text"                  },
9561     { NODE_CDATA_SECTION ,         "cdatasection"          },
9562     { NODE_ENTITY_REFERENCE,       "entityreference"       },
9563     { NODE_PROCESSING_INSTRUCTION, "processinginstruction" },
9564     { NODE_COMMENT,                "comment"               },
9565     { NODE_DOCUMENT_FRAGMENT,      "documentfragment"      },
9566     { 0 }
9567 };
9568
9569 static void test_get_nodeTypeString(void)
9570 {
9571     const get_node_typestring_t *entry = get_node_typestring;
9572     IXMLDOMDocument *doc;
9573     HRESULT hr;
9574     BSTR str;
9575
9576     doc = create_document(&IID_IXMLDOMDocument);
9577
9578     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
9579     ok(hr == S_OK, "got 0x%08x\n", hr);
9580     ok(!lstrcmpW(str, _bstr_("document")), "got string %s\n", wine_dbgstr_w(str));
9581     SysFreeString(str);
9582
9583     while (entry->type)
9584     {
9585         IXMLDOMNode *node = NULL;
9586         VARIANT var;
9587
9588         V_VT(&var) = VT_I4;
9589         V_I4(&var) = entry->type;
9590         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
9591         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9592
9593         hr = IXMLDOMNode_get_nodeTypeString(node, NULL);
9594         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9595
9596         hr = IXMLDOMNode_get_nodeTypeString(node, &str);
9597         ok(hr == S_OK, "got 0x%08x\n", hr);
9598         ok(!lstrcmpW(str, _bstr_(entry->string)), "got string %s, expected %s. node type %d\n",
9599             wine_dbgstr_w(str), entry->string, entry->type);
9600         SysFreeString(str);
9601         IXMLDOMNode_Release(node);
9602
9603         entry++;
9604     }
9605
9606     IXMLDOMDocument_Release(doc);
9607     free_bstrs();
9608 }
9609
9610 typedef struct _get_attributes_t {
9611     DOMNodeType type;
9612     HRESULT hr;
9613 } get_attributes_t;
9614
9615 static const get_attributes_t get_attributes[] = {
9616     { NODE_ATTRIBUTE,              S_FALSE },
9617     { NODE_TEXT,                   S_FALSE },
9618     { NODE_CDATA_SECTION ,         S_FALSE },
9619     { NODE_ENTITY_REFERENCE,       S_FALSE },
9620     { NODE_PROCESSING_INSTRUCTION, S_FALSE },
9621     { NODE_COMMENT,                S_FALSE },
9622     { NODE_DOCUMENT_FRAGMENT,      S_FALSE },
9623     { 0 }
9624 };
9625
9626 static void test_get_attributes(void)
9627 {
9628     const get_attributes_t *entry = get_attributes;
9629     IXMLDOMNamedNodeMap *map;
9630     IXMLDOMDocument *doc;
9631     IXMLDOMNode *node, *node2;
9632     VARIANT_BOOL b;
9633     HRESULT hr;
9634     BSTR str;
9635     LONG length;
9636
9637     doc = create_document(&IID_IXMLDOMDocument);
9638
9639     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
9640     ok(hr == S_OK, "got %08x\n", hr);
9641
9642     hr = IXMLDOMDocument_get_attributes(doc, NULL);
9643     ok(hr == E_INVALIDARG, "got %08x\n", hr);
9644
9645     map = (void*)0xdeadbeef;
9646     hr = IXMLDOMDocument_get_attributes(doc, &map);
9647     ok(hr == S_FALSE, "got %08x\n", hr);
9648     ok(map == NULL, "got %p\n", map);
9649
9650     /* first child is <?xml ?> */
9651     hr = IXMLDOMDocument_get_firstChild(doc, &node);
9652     ok(hr == S_OK, "got %08x\n", hr);
9653
9654     hr = IXMLDOMNode_get_attributes(node, &map);
9655     ok(hr == S_OK, "got %08x\n", hr);
9656
9657     length = -1;
9658     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9659     EXPECT_HR(hr, S_OK);
9660     todo_wine ok(length == 1, "got %d\n", length);
9661
9662     if (hr == S_OK && length == 1)
9663     {
9664         IXMLDOMAttribute *attr;
9665         DOMNodeType type;
9666         VARIANT v;
9667
9668         node2 = NULL;
9669         hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9670         EXPECT_HR(hr, S_OK);
9671         ok(node != NULL, "got %p\n", node2);
9672
9673         hr = IXMLDOMNode_get_nodeName(node2, &str);
9674         EXPECT_HR(hr, S_OK);
9675         ok(!lstrcmpW(str, _bstr_("version")), "got %s\n", wine_dbgstr_w(str));
9676         SysFreeString(str);
9677
9678         length = -1;
9679         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9680         EXPECT_HR(hr, S_OK);
9681         ok(length == 1, "got %d\n", length);
9682
9683         type = -1;
9684         hr = IXMLDOMNode_get_nodeType(node2, &type);
9685         EXPECT_HR(hr, S_OK);
9686         ok(type == NODE_ATTRIBUTE, "got %d\n", type);
9687
9688         hr = IXMLDOMNode_get_xml(node, &str);
9689         EXPECT_HR(hr, S_OK);
9690         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9691         SysFreeString(str);
9692
9693         hr = IXMLDOMNode_get_text(node, &str);
9694         EXPECT_HR(hr, S_OK);
9695         ok(!lstrcmpW(str, _bstr_("version=\"1.0\"")), "got %s\n", wine_dbgstr_w(str));
9696         SysFreeString(str);
9697
9698         hr = IXMLDOMNamedNodeMap_removeNamedItem(map, _bstr_("version"), NULL);
9699         EXPECT_HR(hr, S_OK);
9700
9701         length = -1;
9702         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9703         EXPECT_HR(hr, S_OK);
9704         ok(length == 0, "got %d\n", length);
9705
9706         hr = IXMLDOMNode_get_xml(node, &str);
9707         EXPECT_HR(hr, S_OK);
9708         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9709         SysFreeString(str);
9710
9711         hr = IXMLDOMNode_get_text(node, &str);
9712         EXPECT_HR(hr, S_OK);
9713         ok(!lstrcmpW(str, _bstr_("")), "got %s\n", wine_dbgstr_w(str));
9714         SysFreeString(str);
9715
9716         IXMLDOMNamedNodeMap_Release(map);
9717
9718         hr = IXMLDOMNode_get_attributes(node, &map);
9719         ok(hr == S_OK, "got %08x\n", hr);
9720
9721         length = -1;
9722         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9723         EXPECT_HR(hr, S_OK);
9724         ok(length == 0, "got %d\n", length);
9725
9726         hr = IXMLDOMDocument_createAttribute(doc, _bstr_("encoding"), &attr);
9727         EXPECT_HR(hr, S_OK);
9728
9729         V_VT(&v) = VT_BSTR;
9730         V_BSTR(&v) = _bstr_("UTF-8");
9731         hr = IXMLDOMAttribute_put_nodeValue(attr, v);
9732         EXPECT_HR(hr, S_OK);
9733
9734         EXPECT_REF(attr, 2);
9735         hr = IXMLDOMNamedNodeMap_setNamedItem(map, (IXMLDOMNode*)attr, NULL);
9736         EXPECT_HR(hr, S_OK);
9737         EXPECT_REF(attr, 2);
9738
9739         hr = IXMLDOMNode_get_attributes(node, &map);
9740         ok(hr == S_OK, "got %08x\n", hr);
9741
9742         length = -1;
9743         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9744         EXPECT_HR(hr, S_OK);
9745         ok(length == 1, "got %d\n", length);
9746
9747         hr = IXMLDOMNode_get_xml(node, &str);
9748         EXPECT_HR(hr, S_OK);
9749         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
9750         SysFreeString(str);
9751
9752         hr = IXMLDOMNode_get_text(node, &str);
9753         EXPECT_HR(hr, S_OK);
9754         ok(!lstrcmpW(str, _bstr_("encoding=\"UTF-8\"")), "got %s\n", wine_dbgstr_w(str));
9755         SysFreeString(str);
9756
9757         IXMLDOMNamedNodeMap_Release(map);
9758         IXMLDOMNode_Release(node2);
9759     }
9760
9761     IXMLDOMNode_Release(node);
9762
9763     /* last child is element */
9764     EXPECT_REF(doc, 1);
9765     hr = IXMLDOMDocument_get_lastChild(doc, &node);
9766     ok(hr == S_OK, "got %08x\n", hr);
9767     EXPECT_REF(doc, 1);
9768
9769     EXPECT_REF(node, 1);
9770     hr = IXMLDOMNode_get_attributes(node, &map);
9771     ok(hr == S_OK, "got %08x\n", hr);
9772     EXPECT_REF(node, 1);
9773     EXPECT_REF(doc, 1);
9774
9775     EXPECT_REF(map, 1);
9776     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9777     ok(hr == S_OK, "got %08x\n", hr);
9778     EXPECT_REF(node, 1);
9779     EXPECT_REF(node2, 1);
9780     EXPECT_REF(map, 1);
9781     EXPECT_REF(doc, 1);
9782     IXMLDOMNode_Release(node2);
9783
9784     /* release node before map release, map still works */
9785     IXMLDOMNode_Release(node);
9786
9787     length = 0;
9788     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
9789     ok(hr == S_OK, "got %08x\n", hr);
9790     ok(length == 1, "got %d\n", length);
9791
9792     node2 = NULL;
9793     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
9794     ok(hr == S_OK, "got %08x\n", hr);
9795     EXPECT_REF(node2, 1);
9796     IXMLDOMNode_Release(node2);
9797
9798     IXMLDOMNamedNodeMap_Release(map);
9799
9800     while (entry->type)
9801     {
9802         VARIANT var;
9803
9804         node = NULL;
9805
9806         V_VT(&var) = VT_I4;
9807         V_I4(&var) = entry->type;
9808         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
9809         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
9810
9811         hr = IXMLDOMNode_get_attributes(node, NULL);
9812         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9813
9814         map = (void*)0xdeadbeef;
9815         hr = IXMLDOMNode_get_attributes(node, &map);
9816         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
9817             hr, entry->hr, entry->type);
9818         ok(map == NULL, "got %p\n", map);
9819
9820         IXMLDOMNode_Release(node);
9821
9822         entry++;
9823     }
9824
9825     IXMLDOMDocument_Release(doc);
9826     free_bstrs();
9827 }
9828
9829 static void test_selection(void)
9830 {
9831     IXMLDOMSelection *selection, *selection2;
9832     IEnumVARIANT *enum1, *enum2, *enum3;
9833     IXMLDOMNodeList *list;
9834     IXMLDOMDocument *doc;
9835     IDispatchEx *dispex;
9836     IXMLDOMNode *node;
9837     IDispatch *disp;
9838     VARIANT_BOOL b;
9839     HRESULT hr;
9840     DISPID did;
9841     VARIANT v;
9842     BSTR name;
9843     ULONG ret;
9844     LONG len;
9845
9846     doc = create_document(&IID_IXMLDOMDocument);
9847
9848     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
9849     EXPECT_HR(hr, S_OK);
9850
9851     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list);
9852     EXPECT_HR(hr, S_OK);
9853
9854     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9855     EXPECT_HR(hr, S_OK);
9856     IXMLDOMSelection_Release(selection);
9857
9858     /* collection disp id */
9859     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IDispatchEx, (void**)&dispex);
9860     EXPECT_HR(hr, S_OK);
9861     did = 0;
9862     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
9863     EXPECT_HR(hr, S_OK);
9864     ok(did == DISPID_DOM_COLLECTION_BASE, "got %d\n", did);
9865     len = 0;
9866     hr = IXMLDOMSelection_get_length(selection, &len);
9867     EXPECT_HR(hr, S_OK);
9868     ok(len == 1, "got %d\n", len);
9869     hr = IDispatchEx_GetDispID(dispex, _bstr_("10"), 0, &did);
9870     EXPECT_HR(hr, S_OK);
9871     ok(did == DISPID_DOM_COLLECTION_BASE+10, "got %d\n", did);
9872     IDispatchEx_Release(dispex);
9873
9874     /* IEnumVARIANT tests */
9875     enum1 = NULL;
9876     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum1);
9877     EXPECT_HR(hr, S_OK);
9878     ok(enum1 != NULL, "got %p\n", enum1);
9879     EXPECT_REF(enum1, 2);
9880
9881     enum3 = NULL;
9882     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum3);
9883     EXPECT_HR(hr, S_OK);
9884     ok(enum3 != NULL, "got %p\n", enum3);
9885     ok(enum1 == enum3, "got %p and %p\n", enum1, enum3);
9886     EXPECT_REF(enum1, 3);
9887     IEnumVARIANT_Release(enum3);
9888
9889     EXPECT_REF(selection, 1);
9890     EXPECT_REF(enum1, 2);
9891
9892     enum2 = NULL;
9893     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
9894     EXPECT_HR(hr, S_OK);
9895     ok(enum2 != NULL, "got %p\n", enum2);
9896
9897     EXPECT_REF(selection, 2);
9898     EXPECT_REF(enum1, 2);
9899     EXPECT_REF(enum2, 1);
9900
9901     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
9902
9903     selection2 = NULL;
9904     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IXMLDOMSelection, (void**)&selection2);
9905     EXPECT_HR(hr, S_OK);
9906     ok(selection2 == selection, "got %p and %p\n", selection, selection2);
9907     EXPECT_REF(selection, 3);
9908     EXPECT_REF(enum1, 2);
9909
9910     IXMLDOMSelection_Release(selection2);
9911
9912     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IDispatch, (void**)&disp);
9913     EXPECT_HR(hr, S_OK);
9914     EXPECT_REF(selection, 3);
9915     IDispatch_Release(disp);
9916
9917     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IEnumVARIANT, (void**)&enum3);
9918     EXPECT_HR(hr, S_OK);
9919     ok(enum3 == enum1, "got %p and %p\n", enum3, enum1);
9920     EXPECT_REF(selection, 2);
9921     EXPECT_REF(enum1, 3);
9922
9923     IEnumVARIANT_Release(enum1);
9924     IEnumVARIANT_Release(enum2);
9925
9926     enum1 = NULL;
9927     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
9928     EXPECT_HR(hr, S_OK);
9929     ok(enum1 != NULL, "got %p\n", enum1);
9930     EXPECT_REF(enum1, 1);
9931     EXPECT_REF(selection, 2);
9932
9933     enum2 = NULL;
9934     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
9935     EXPECT_HR(hr, S_OK);
9936     ok(enum2 != NULL, "got %p\n", enum2);
9937     EXPECT_REF(enum2, 1);
9938     EXPECT_REF(selection, 3);
9939
9940     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
9941
9942     IEnumVARIANT_AddRef(enum1);
9943     EXPECT_REF(selection, 3);
9944     EXPECT_REF(enum1, 2);
9945     EXPECT_REF(enum2, 1);
9946     IEnumVARIANT_Release(enum1);
9947
9948     IEnumVARIANT_Release(enum1);
9949     IEnumVARIANT_Release(enum2);
9950
9951     EXPECT_REF(selection, 1);
9952
9953     IXMLDOMNodeList_Release(list);
9954
9955     hr = IXMLDOMDocument_get_childNodes(doc, &list);
9956     EXPECT_HR(hr, S_OK);
9957
9958     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9959     EXPECT_HR(hr, E_NOINTERFACE);
9960
9961     IXMLDOMNodeList_Release(list);
9962
9963     /* test if IEnumVARIANT touches selection context */
9964     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(xpath_simple_list), &b);
9965     EXPECT_HR(hr, S_OK);
9966
9967     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/*"), &list);
9968     EXPECT_HR(hr, S_OK);
9969
9970     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9971     EXPECT_HR(hr, S_OK);
9972
9973     len = 0;
9974     hr = IXMLDOMSelection_get_length(selection, &len);
9975     EXPECT_HR(hr, S_OK);
9976     ok(len == 4, "got %d\n", len);
9977
9978     enum1 = NULL;
9979     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
9980     EXPECT_HR(hr, S_OK);
9981
9982     /* no-op if zero count */
9983     V_VT(&v) = VT_I2;
9984     hr = IEnumVARIANT_Next(enum1, 0, &v, NULL);
9985     EXPECT_HR(hr, S_OK);
9986     ok(V_VT(&v) == VT_I2, "got var type %d\n", V_VT(&v));
9987
9988     /* positive count, null array pointer */
9989     hr = IEnumVARIANT_Next(enum1, 1, NULL, NULL);
9990     EXPECT_HR(hr, E_INVALIDARG);
9991
9992     ret = 1;
9993     hr = IEnumVARIANT_Next(enum1, 1, NULL, &ret);
9994     EXPECT_HR(hr, E_INVALIDARG);
9995     ok(ret == 0, "got %d\n", ret);
9996
9997     V_VT(&v) = VT_I2;
9998     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
9999     EXPECT_HR(hr, S_OK);
10000     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
10001
10002     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
10003     EXPECT_HR(hr, S_OK);
10004     hr = IXMLDOMNode_get_nodeName(node, &name);
10005     EXPECT_HR(hr, S_OK);
10006     ok(!lstrcmpW(name, _bstr_("a")), "got node name %s\n", wine_dbgstr_w(name));
10007     SysFreeString(name);
10008     IXMLDOMNode_Release(node);
10009     VariantClear(&v);
10010
10011     /* list cursor is updated */
10012     hr = IXMLDOMSelection_nextNode(selection, &node);
10013     EXPECT_HR(hr, S_OK);
10014     hr = IXMLDOMNode_get_nodeName(node, &name);
10015     EXPECT_HR(hr, S_OK);
10016     ok(!lstrcmpW(name, _bstr_("c")), "got node name %s\n", wine_dbgstr_w(name));
10017     IXMLDOMNode_Release(node);
10018
10019     V_VT(&v) = VT_I2;
10020     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
10021     EXPECT_HR(hr, S_OK);
10022     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
10023     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
10024     EXPECT_HR(hr, S_OK);
10025     hr = IXMLDOMNode_get_nodeName(node, &name);
10026     EXPECT_HR(hr, S_OK);
10027     ok(!lstrcmpW(name, _bstr_("b")), "got node name %s\n", wine_dbgstr_w(name));
10028     SysFreeString(name);
10029     IXMLDOMNode_Release(node);
10030     VariantClear(&v);
10031
10032     hr = IXMLDOMSelection_nextNode(selection, &node);
10033     EXPECT_HR(hr, S_OK);
10034     hr = IXMLDOMNode_get_nodeName(node, &name);
10035     EXPECT_HR(hr, S_OK);
10036     ok(!lstrcmpW(name, _bstr_("d")), "got node name %s\n", wine_dbgstr_w(name));
10037     IXMLDOMNode_Release(node);
10038
10039     IXMLDOMSelection_Release(selection);
10040     IXMLDOMNodeList_Release(list);
10041     IXMLDOMDocument_Release(doc);
10042
10043     free_bstrs();
10044 }
10045
10046 static void test_load(void)
10047 {
10048     IXMLDOMDocument *doc;
10049     IXMLDOMNodeList *list;
10050     VARIANT_BOOL b;
10051     HANDLE hfile;
10052     VARIANT src;
10053     HRESULT hr;
10054     BOOL ret;
10055     BSTR path, bstr1, bstr2;
10056     DWORD written;
10057     void* ptr;
10058
10059     /* prepare a file */
10060     hfile = CreateFileA("test.xml", GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
10061     ok(hfile != INVALID_HANDLE_VALUE, "failed to create test file\n");
10062     if(hfile == INVALID_HANDLE_VALUE) return;
10063
10064     ret = WriteFile(hfile, szNonUnicodeXML, sizeof(szNonUnicodeXML)-1, &written, NULL);
10065     ok(ret, "WriteFile failed\n");
10066
10067     CloseHandle(hfile);
10068
10069     doc = create_document(&IID_IXMLDOMDocument);
10070
10071     path = _bstr_("test.xml");
10072
10073     /* load from path: VT_BSTR */
10074     V_VT(&src) = VT_BSTR;
10075     V_BSTR(&src) = path;
10076     hr = IXMLDOMDocument_load(doc, src, &b);
10077     EXPECT_HR(hr, S_OK);
10078     ok(b == VARIANT_TRUE, "got %d\n", b);
10079
10080     /* load from a path: VT_BSTR|VT_BYREF */
10081     V_VT(&src) = VT_BSTR | VT_BYREF;
10082     V_BSTRREF(&src) = &path;
10083     hr = IXMLDOMDocument_load(doc, src, &b);
10084     EXPECT_HR(hr, S_OK);
10085     ok(b == VARIANT_TRUE, "got %d\n", b);
10086
10087     /* load from a path: VT_BSTR|VT_BYREF, null ptr */
10088     V_VT(&src) = VT_BSTR | VT_BYREF;
10089     V_BSTRREF(&src) = NULL;
10090     hr = IXMLDOMDocument_load(doc, src, &b);
10091     EXPECT_HR(hr, E_INVALIDARG);
10092     ok(b == VARIANT_FALSE, "got %d\n", b);
10093
10094     IXMLDOMDocument_Release(doc);
10095
10096     DeleteFileA("test.xml");
10097
10098     doc = create_document(&IID_IXMLDOMDocument);
10099
10100     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
10101     EXPECT_HR(hr, S_OK);
10102     ok(b == VARIANT_TRUE, "got %d\n", b);
10103
10104     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
10105     EXPECT_HR(hr, S_OK);
10106     bstr1 = _bstr_(list_to_string(list));
10107
10108     hr = IXMLDOMNodeList_reset(list);
10109     EXPECT_HR(hr, S_OK);
10110
10111     IXMLDOMDocument_Release(doc);
10112
10113     doc = create_document(&IID_IXMLDOMDocument);
10114
10115     VariantInit(&src);
10116     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenA(szExampleXML));
10117     V_VT(&src) = VT_ARRAY|VT_UI1;
10118     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10119     ptr = NULL;
10120     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10121     EXPECT_HR(hr, S_OK);
10122     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10123
10124     memcpy(ptr, szExampleXML, lstrlenA(szExampleXML));
10125     hr = SafeArrayUnlock(V_ARRAY(&src));
10126     EXPECT_HR(hr, S_OK);
10127
10128     hr = IXMLDOMDocument_load(doc, src, &b);
10129     EXPECT_HR(hr, S_OK);
10130     ok(b == VARIANT_TRUE, "got %d\n", b);
10131
10132     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
10133     EXPECT_HR(hr, S_OK);
10134     bstr2 = _bstr_(list_to_string(list));
10135
10136     hr = IXMLDOMNodeList_reset(list);
10137     EXPECT_HR(hr, S_OK);
10138
10139     ok(lstrcmpW(bstr1, bstr2) == 0, "strings not equal: %s : %s\n",
10140        wine_dbgstr_w(bstr1), wine_dbgstr_w(bstr2));
10141
10142     IXMLDOMDocument_Release(doc);
10143     IXMLDOMNodeList_Release(list);
10144     VariantClear(&src);
10145
10146     /* UTF-16 isn't accepted */
10147     doc = create_document(&IID_IXMLDOMDocument);
10148
10149     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenW(szComplete1) * sizeof(WCHAR));
10150     V_VT(&src) = VT_ARRAY|VT_UI1;
10151     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10152     ptr = NULL;
10153     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10154     EXPECT_HR(hr, S_OK);
10155     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10156
10157     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
10158     hr = SafeArrayUnlock(V_ARRAY(&src));
10159     EXPECT_HR(hr, S_OK);
10160
10161     hr = IXMLDOMDocument_load(doc, src, &b);
10162     todo_wine EXPECT_HR(hr, S_FALSE);
10163     todo_wine ok(b == VARIANT_FALSE, "got %d\n", b);
10164
10165     VariantClear(&src);
10166
10167     /* it doesn't like it as a VT_ARRAY|VT_UI2 either */
10168     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI2, 0, lstrlenW(szComplete1));
10169     V_VT(&src) = VT_ARRAY|VT_UI2;
10170     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10171     ptr = NULL;
10172     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10173     EXPECT_HR(hr, S_OK);
10174     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10175
10176     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
10177     hr = SafeArrayUnlock(V_ARRAY(&src));
10178     EXPECT_HR(hr, S_OK);
10179
10180     hr = IXMLDOMDocument_load(doc, src, &b);
10181     todo_wine EXPECT_HR(hr, E_INVALIDARG);
10182     ok(b == VARIANT_FALSE, "got %d\n", b);
10183
10184     VariantClear(&src);
10185     IXMLDOMDocument_Release(doc);
10186
10187     free_bstrs();
10188 }
10189
10190 static void test_nsnamespacemanager(void)
10191 {
10192     static const char xmluriA[] = "http://www.w3.org/XML/1998/namespace";
10193     IMXNamespaceManager *nsmgr;
10194     IVBMXNamespaceManager *mgr2;
10195     IDispatch *disp;
10196     HRESULT hr;
10197     WCHAR buffW[250];
10198     INT len;
10199
10200     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10201         &IID_IMXNamespaceManager, (void**)&nsmgr);
10202     if (hr != S_OK)
10203     {
10204         win_skip("MXNamespaceManager is not available\n");
10205         return;
10206     }
10207
10208     /* IMXNamespaceManager inherits from IUnknown */
10209     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IDispatch, (void**)&disp);
10210     EXPECT_HR(hr, S_OK);
10211     IDispatch_Release(disp);
10212
10213     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IVBMXNamespaceManager, (void**)&mgr2);
10214     EXPECT_HR(hr, S_OK);
10215     IVBMXNamespaceManager_Release(mgr2);
10216
10217     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
10218     EXPECT_HR(hr, S_OK);
10219
10220     /* prefix already added */
10221     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10222     EXPECT_HR(hr, S_FALSE);
10223
10224     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), NULL);
10225     EXPECT_HR(hr, E_INVALIDARG);
10226
10227     /* "xml" and "xmlns" are not allowed here */
10228     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xml"), _bstr_("uri1"));
10229     EXPECT_HR(hr, E_INVALIDARG);
10230
10231     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xmlns"), _bstr_("uri1"));
10232     EXPECT_HR(hr, E_INVALIDARG);
10233 todo_wine {
10234     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, -1, NULL, NULL);
10235     EXPECT_HR(hr, E_FAIL);
10236 }
10237     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, NULL);
10238     EXPECT_HR(hr, E_POINTER);
10239
10240     len = -1;
10241     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, &len);
10242     EXPECT_HR(hr, S_OK);
10243     ok(len == 3, "got %d\n", len);
10244
10245     len = -1;
10246     buffW[0] = 0x1;
10247     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10248     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
10249     ok(len == -1, "got %d\n", len);
10250     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10251
10252     len = 10;
10253     buffW[0] = 0x1;
10254     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10255     EXPECT_HR(hr, S_OK);
10256     ok(len == 3, "got %d\n", len);
10257     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10258
10259     /* getURI */
10260     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, NULL);
10261     EXPECT_HR(hr, E_INVALIDARG);
10262
10263     len = -1;
10264     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, &len);
10265     EXPECT_HR(hr, E_INVALIDARG);
10266     ok(len == -1, "got %d\n", len);
10267
10268     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, NULL);
10269     EXPECT_HR(hr, E_POINTER);
10270
10271     len = -1;
10272     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, &len);
10273     EXPECT_HR(hr, S_OK);
10274     /* length of "xml" uri is constant */
10275     ok(len == strlen(xmluriA), "got %d\n", len);
10276
10277     len = 100;
10278     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
10279     EXPECT_HR(hr, S_OK);
10280     ok(len == strlen(xmluriA), "got %d\n", len);
10281     ok(!lstrcmpW(buffW, _bstr_(xmluriA)), "got prefix %s\n", wine_dbgstr_w(buffW));
10282
10283     len = strlen(xmluriA)-1;
10284     buffW[0] = 0x1;
10285     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
10286     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
10287     ok(len == strlen(xmluriA)-1, "got %d\n", len);
10288     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
10289
10290     /* prefix xml1 not defined */
10291     len = -1;
10292     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, NULL, &len);
10293     EXPECT_HR(hr, S_FALSE);
10294     ok(len == 0, "got %d\n", len);
10295
10296     len = 100;
10297     buffW[0] = 0x1;
10298     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, buffW, &len);
10299     EXPECT_HR(hr, S_FALSE);
10300     ok(buffW[0] == 0, "got %x\n", buffW[0]);
10301     ok(len == 0, "got %d\n", len);
10302
10303     IMXNamespaceManager_Release(nsmgr);
10304
10305     free_bstrs();
10306 }
10307
10308 static void test_nsnamespacemanager_override(void)
10309 {
10310     IMXNamespaceManager *nsmgr;
10311     WCHAR buffW[250];
10312     VARIANT_BOOL b;
10313     HRESULT hr;
10314     INT len;
10315
10316     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10317         &IID_IMXNamespaceManager, (void**)&nsmgr);
10318     if (hr != S_OK)
10319     {
10320         win_skip("MXNamespaceManager is not available\n");
10321         return;
10322     }
10323
10324     len = sizeof(buffW)/sizeof(WCHAR);
10325     buffW[0] = 0;
10326     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10327     EXPECT_HR(hr, S_OK);
10328     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10329
10330     len = sizeof(buffW)/sizeof(WCHAR);
10331     buffW[0] = 0;
10332     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10333     EXPECT_HR(hr, E_FAIL);
10334
10335     hr = IMXNamespaceManager_getAllowOverride(nsmgr, NULL);
10336     EXPECT_HR(hr, E_POINTER);
10337
10338     b = VARIANT_FALSE;
10339     hr = IMXNamespaceManager_getAllowOverride(nsmgr, &b);
10340     EXPECT_HR(hr, S_OK);
10341     ok(b == VARIANT_TRUE, "got %d\n", b);
10342
10343     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_FALSE);
10344     EXPECT_HR(hr, S_OK);
10345
10346     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10347     EXPECT_HR(hr, S_OK);
10348
10349     len = sizeof(buffW)/sizeof(WCHAR);
10350     buffW[0] = 0;
10351     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
10352     EXPECT_HR(hr, S_OK);
10353     ok(!lstrcmpW(buffW, _bstr_("ns0 uri")), "got uri %s\n", wine_dbgstr_w(buffW));
10354
10355     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), _bstr_("ns0 uri"));
10356     EXPECT_HR(hr, S_OK);
10357
10358     len = sizeof(buffW)/sizeof(WCHAR);
10359     buffW[0] = 0;
10360     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
10361     EXPECT_HR(hr, S_OK);
10362     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
10363
10364     len = sizeof(buffW)/sizeof(WCHAR);
10365     buffW[0] = 0;
10366     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10367     EXPECT_HR(hr, S_OK);
10368     ok(!lstrcmpW(buffW, _bstr_("ns0")), "got prefix %s\n", wine_dbgstr_w(buffW));
10369
10370     len = sizeof(buffW)/sizeof(WCHAR);
10371     buffW[0] = 0;
10372     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 2, buffW, &len);
10373     EXPECT_HR(hr, S_OK);
10374     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
10375
10376     /* new prefix placed at index 1 always */
10377     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
10378     EXPECT_HR(hr, S_OK);
10379
10380     len = sizeof(buffW)/sizeof(WCHAR);
10381     buffW[0] = 0;
10382     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
10383     EXPECT_HR(hr, S_OK);
10384     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got prefix %s\n", wine_dbgstr_w(buffW));
10385
10386     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_(""), NULL);
10387     todo_wine EXPECT_HR(hr, E_FAIL);
10388
10389     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
10390     EXPECT_HR(hr, E_FAIL);
10391
10392     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10393     EXPECT_HR(hr, E_FAIL);
10394
10395     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_TRUE);
10396     EXPECT_HR(hr, S_OK);
10397
10398     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri override"));
10399     EXPECT_HR(hr, S_FALSE);
10400
10401     len = sizeof(buffW)/sizeof(WCHAR);
10402     buffW[0] = 0;
10403     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
10404     EXPECT_HR(hr, S_OK);
10405     ok(!lstrcmpW(buffW, _bstr_("ns0 uri override")), "got uri %s\n", wine_dbgstr_w(buffW));
10406
10407     len = sizeof(buffW)/sizeof(WCHAR);
10408     buffW[0] = 0;
10409     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 3, buffW, &len);
10410     EXPECT_HR(hr, S_OK);
10411     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
10412
10413     IMXNamespaceManager_Release(nsmgr);
10414
10415     free_bstrs();
10416 }
10417
10418 static void test_domobj_dispex(IUnknown *obj)
10419 {
10420     DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
10421     IDispatchEx *dispex;
10422     IUnknown *unk;
10423     DWORD props;
10424     UINT ticnt;
10425     HRESULT hr;
10426     BSTR name;
10427
10428     hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
10429     EXPECT_HR(hr, S_OK);
10430     if (FAILED(hr)) return;
10431
10432     ticnt = 0;
10433     hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
10434     EXPECT_HR(hr, S_OK);
10435     ok(ticnt == 1, "ticnt=%u\n", ticnt);
10436
10437     name = SysAllocString(szstar);
10438     hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
10439     EXPECT_HR(hr, E_NOTIMPL);
10440     SysFreeString(name);
10441
10442     hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
10443     EXPECT_HR(hr, E_NOTIMPL);
10444
10445     props = 0;
10446     hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
10447     EXPECT_HR(hr, E_NOTIMPL);
10448     ok(props == 0, "expected 0 got %d\n", props);
10449
10450     hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
10451     EXPECT_HR(hr, E_NOTIMPL);
10452     if (SUCCEEDED(hr)) SysFreeString(name);
10453
10454     hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
10455     EXPECT_HR(hr, E_NOTIMPL);
10456
10457     hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
10458     EXPECT_HR(hr, E_NOTIMPL);
10459     if (hr == S_OK && unk) IUnknown_Release(unk);
10460
10461     IDispatchEx_Release(dispex);
10462 }
10463
10464 static const DOMNodeType dispex_types_test[] =
10465 {
10466     NODE_ELEMENT,
10467     NODE_ATTRIBUTE,
10468     NODE_TEXT,
10469     NODE_CDATA_SECTION,
10470     NODE_ENTITY_REFERENCE,
10471     NODE_PROCESSING_INSTRUCTION,
10472     NODE_COMMENT,
10473     NODE_DOCUMENT_FRAGMENT,
10474     NODE_INVALID
10475 };
10476
10477 static void test_dispex(void)
10478 {
10479     const DOMNodeType *type = dispex_types_test;
10480     IXMLDOMImplementation *impl;
10481     IXMLDOMNodeList *node_list;
10482     IXMLDOMParseError *error;
10483     IXMLDOMNamedNodeMap *map;
10484     IXMLDOMDocument *doc;
10485     IXMLHTTPRequest *req;
10486     IXMLDOMElement *elem;
10487     IDispatchEx *dispex;
10488     IXMLDOMNode *node;
10489     VARIANT_BOOL b;
10490     IUnknown *unk;
10491     HRESULT hr;
10492     DISPID did;
10493
10494     doc = create_document(&IID_IXMLDOMDocument);
10495
10496     IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
10497     test_domobj_dispex(unk);
10498     IUnknown_Release(unk);
10499
10500     for(; *type != NODE_INVALID; type++)
10501     {
10502         IXMLDOMNode *node;
10503         VARIANT v;
10504
10505         V_VT(&v) = VT_I2;
10506         V_I2(&v) = *type;
10507
10508         hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
10509         ok(hr == S_OK, "failed to create node type %d\n", *type);
10510
10511         IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
10512
10513         test_domobj_dispex(unk);
10514         IUnknown_Release(unk);
10515         IXMLDOMNode_Release(node);
10516     }
10517
10518     /* IXMLDOMNodeList */
10519     hr = IXMLDOMDocument_getElementsByTagName(doc, _bstr_("*"), &node_list);
10520     EXPECT_HR(hr, S_OK);
10521     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
10522     test_domobj_dispex(unk);
10523     IUnknown_Release(unk);
10524     IXMLDOMNodeList_Release(node_list);
10525
10526     /* IXMLDOMNodeList for children list */
10527     hr = IXMLDOMDocument_get_childNodes(doc, &node_list);
10528     EXPECT_HR(hr, S_OK);
10529     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
10530     test_domobj_dispex(unk);
10531     IUnknown_Release(unk);
10532
10533     /* collection dispex test, empty collection */
10534     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatchEx, (void**)&dispex);
10535     EXPECT_HR(hr, S_OK);
10536     did = 0;
10537     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10538     EXPECT_HR(hr, S_OK);
10539     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10540     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
10541     EXPECT_HR(hr, S_OK);
10542     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
10543     IDispatchEx_Release(dispex);
10544
10545     IXMLDOMNodeList_Release(node_list);
10546
10547     /* IXMLDOMParseError */
10548     hr = IXMLDOMDocument_get_parseError(doc, &error);
10549     EXPECT_HR(hr, S_OK);
10550     IXMLDOMParseError_QueryInterface(error, &IID_IUnknown, (void**)&unk);
10551     test_domobj_dispex(unk);
10552     IUnknown_Release(unk);
10553     IXMLDOMParseError_Release(error);
10554
10555     /* IXMLDOMNamedNodeMap */
10556     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(xpath_simple_list), &b);
10557     EXPECT_HR(hr, S_OK);
10558
10559     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/a"), &node_list);
10560     EXPECT_HR(hr, S_OK);
10561     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
10562     EXPECT_HR(hr, S_OK);
10563     IXMLDOMNodeList_Release(node_list);
10564
10565     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
10566     EXPECT_HR(hr, S_OK);
10567     IXMLDOMNode_Release(node);
10568     hr = IXMLDOMElement_get_attributes(elem, &map);
10569     EXPECT_HR(hr, S_OK);
10570     IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk);
10571     test_domobj_dispex(unk);
10572     IUnknown_Release(unk);
10573     /* collection dispex test */
10574     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
10575     EXPECT_HR(hr, S_OK);
10576     did = 0;
10577     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10578     EXPECT_HR(hr, S_OK);
10579     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10580     IDispatchEx_Release(dispex);
10581
10582     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/b"), &node_list);
10583     EXPECT_HR(hr, S_OK);
10584     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
10585     EXPECT_HR(hr, S_OK);
10586     IXMLDOMNodeList_Release(node_list);
10587     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
10588     EXPECT_HR(hr, S_OK);
10589     IXMLDOMNode_Release(node);
10590     hr = IXMLDOMElement_get_attributes(elem, &map);
10591     EXPECT_HR(hr, S_OK);
10592     /* collection dispex test, empty collection */
10593     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
10594     EXPECT_HR(hr, S_OK);
10595     did = 0;
10596     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10597     EXPECT_HR(hr, S_OK);
10598     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10599     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
10600     EXPECT_HR(hr, S_OK);
10601     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
10602     IDispatchEx_Release(dispex);
10603
10604     IXMLDOMNamedNodeMap_Release(map);
10605     IXMLDOMElement_Release(elem);
10606
10607     /* IXMLDOMImplementation */
10608     hr = IXMLDOMDocument_get_implementation(doc, &impl);
10609     EXPECT_HR(hr, S_OK);
10610
10611     hr = IXMLDOMImplementation_QueryInterface(impl, &IID_IDispatchEx, (void**)&dispex);
10612     EXPECT_HR(hr, S_OK);
10613     IDispatchEx_Release(dispex);
10614     IXMLDOMImplementation_Release(impl);
10615
10616     IXMLDOMDocument_Release(doc);
10617
10618     /* IXMLHTTPRequest */
10619     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
10620         &IID_IXMLHttpRequest, (void**)&req);
10621     if (hr == S_OK)
10622     {
10623         hr = IXMLHTTPRequest_QueryInterface(req, &IID_IDispatchEx, (void**)&dispex);
10624         EXPECT_HR(hr, E_NOINTERFACE);
10625         IXMLHTTPRequest_Release(req);
10626     }
10627
10628     free_bstrs();
10629 }
10630
10631 static void test_parseerror(void)
10632 {
10633     IXMLDOMParseError *error;
10634     IXMLDOMDocument *doc;
10635     HRESULT hr;
10636
10637     doc = create_document(&IID_IXMLDOMDocument);
10638
10639     hr = IXMLDOMDocument_get_parseError(doc, &error);
10640     EXPECT_HR(hr, S_OK);
10641
10642     hr = IXMLDOMParseError_get_line(error, NULL);
10643     EXPECT_HR(hr, E_INVALIDARG);
10644
10645     hr = IXMLDOMParseError_get_srcText(error, NULL);
10646     EXPECT_HR(hr, E_INVALIDARG);
10647
10648     hr = IXMLDOMParseError_get_linepos(error, NULL);
10649     EXPECT_HR(hr, E_INVALIDARG);
10650
10651     IXMLDOMParseError_Release(error);
10652
10653     IXMLDOMDocument_Release(doc);
10654 }
10655
10656 static void test_getAttributeNode(void)
10657 {
10658     IXMLDOMAttribute *attr;
10659     IXMLDOMDocument *doc;
10660     IXMLDOMElement *elem;
10661     VARIANT_BOOL v;
10662     HRESULT hr;
10663     BSTR str;
10664
10665     doc = create_document(&IID_IXMLDOMDocument);
10666
10667     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &v);
10668     EXPECT_HR(hr, S_OK);
10669
10670     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10671     EXPECT_HR(hr, S_OK);
10672
10673     str = SysAllocString(nonexistent_fileW);
10674     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
10675     EXPECT_HR(hr, E_FAIL);
10676
10677     attr = (IXMLDOMAttribute*)0xdeadbeef;
10678     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
10679     EXPECT_HR(hr, E_FAIL);
10680     ok(attr == NULL, "got %p\n", attr);
10681     SysFreeString(str);
10682
10683     str = SysAllocString(nonexistent_attrW);
10684     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
10685     EXPECT_HR(hr, S_FALSE);
10686
10687     attr = (IXMLDOMAttribute*)0xdeadbeef;
10688     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
10689     EXPECT_HR(hr, S_FALSE);
10690     ok(attr == NULL, "got %p\n", attr);
10691     SysFreeString(str);
10692
10693     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("foo:b"), &attr);
10694     EXPECT_HR(hr, S_OK);
10695     IXMLDOMAttribute_Release(attr);
10696
10697     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("b"), &attr);
10698     EXPECT_HR(hr, S_FALSE);
10699
10700     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("a"), &attr);
10701     EXPECT_HR(hr, S_OK);
10702     IXMLDOMAttribute_Release(attr);
10703
10704     IXMLDOMElement_Release(elem);
10705     IXMLDOMDocument_Release(doc);
10706     free_bstrs();
10707 }
10708
10709 typedef struct {
10710     DOMNodeType type;
10711     const char *name;
10712     REFIID iids[3];
10713 } supporterror_t;
10714
10715 static const supporterror_t supporterror_test[] = {
10716     { NODE_ELEMENT,                "element",   { &IID_IXMLDOMNode, &IID_IXMLDOMElement } },
10717     { NODE_ATTRIBUTE,              "attribute", { &IID_IXMLDOMNode, &IID_IXMLDOMAttribute } },
10718     { NODE_CDATA_SECTION,          "cdata",     { &IID_IXMLDOMNode, &IID_IXMLDOMCDATASection } },
10719     { NODE_ENTITY_REFERENCE,       "entityref", { &IID_IXMLDOMNode, &IID_IXMLDOMEntityReference } },
10720     { NODE_PROCESSING_INSTRUCTION, "pi",        { &IID_IXMLDOMNode, &IID_IXMLDOMProcessingInstruction } },
10721     { NODE_COMMENT,                "comment",   { &IID_IXMLDOMNode, &IID_IXMLDOMComment } },
10722     { NODE_DOCUMENT_FRAGMENT,      "fragment",  { &IID_IXMLDOMNode, &IID_IXMLDOMDocumentFragment } },
10723     { NODE_INVALID }
10724 };
10725
10726 static void test_supporterrorinfo(void)
10727 {
10728     static REFIID iids[5] = { &IID_IXMLDOMNode, &IID_IXMLDOMDocument,
10729                               &IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3 };
10730     const supporterror_t *ptr = supporterror_test;
10731     ISupportErrorInfo *errorinfo, *info2;
10732     IXMLDOMNamedNodeMap *map, *map2;
10733     IXMLDOMDocument *doc;
10734     IXMLDOMElement *elem;
10735     VARIANT_BOOL b;
10736     IUnknown *unk;
10737     REFIID *iid;
10738     void *dummy;
10739     HRESULT hr;
10740
10741     doc = create_document_version(60, &IID_IXMLDOMDocument3);
10742     if (!doc) return;
10743
10744     EXPECT_REF(doc, 1);
10745     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&errorinfo);
10746     EXPECT_HR(hr, S_OK);
10747     EXPECT_REF(doc, 1);
10748     ISupportErrorInfo_AddRef(errorinfo);
10749     EXPECT_REF(errorinfo, 2);
10750     EXPECT_REF(doc, 1);
10751     ISupportErrorInfo_Release(errorinfo);
10752
10753     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&info2);
10754     EXPECT_HR(hr, S_OK);
10755     ok(errorinfo != info2, "got %p, %p\n", info2, errorinfo);
10756
10757     /* error interface can't be queried back for DOM interface */
10758     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMDocument, &dummy);
10759     EXPECT_HR(hr, E_NOINTERFACE);
10760     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMNode, &dummy);
10761     EXPECT_HR(hr, E_NOINTERFACE);
10762
10763     ISupportErrorInfo_Release(info2);
10764
10765     iid = iids;
10766     while (*iid)
10767     {
10768         hr = IXMLDOMDocument_QueryInterface(doc, *iid, (void**)&unk);
10769         EXPECT_HR(hr, S_OK);
10770         if (hr == S_OK)
10771         {
10772             hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
10773             ok(hr == S_OK, "got 0x%08x for %s\n", hr, debugstr_guid(*iid));
10774             IUnknown_Release(unk);
10775         }
10776
10777         iid++;
10778     }
10779
10780     ISupportErrorInfo_Release(errorinfo);
10781
10782     while (ptr->type != NODE_INVALID)
10783     {
10784         IXMLDOMNode *node;
10785         VARIANT type;
10786
10787         V_VT(&type) = VT_I1;
10788         V_I1(&type) = ptr->type;
10789
10790         hr = IXMLDOMDocument_createNode(doc, type, _bstr_(ptr->name), NULL, &node);
10791         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
10792
10793         EXPECT_REF(node, 1);
10794         hr = IXMLDOMNode_QueryInterface(node, &IID_ISupportErrorInfo, (void**)&errorinfo);
10795         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
10796         EXPECT_REF(node, 1);
10797
10798         hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNode, &dummy);
10799         ok(hr == E_NOINTERFACE, "%d: got 0x%08x\n", ptr->type, hr);
10800
10801         iid = ptr->iids;
10802
10803         while (*iid)
10804         {
10805             hr = IXMLDOMNode_QueryInterface(node, *iid, (void**)&unk);
10806             if (hr == S_OK)
10807             {
10808                 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
10809                 ok(hr == S_OK, "%d: got 0x%08x for %s\n", ptr->type, hr, debugstr_guid(*iid));
10810                 IUnknown_Release(unk);
10811             }
10812
10813             iid++;
10814         }
10815
10816         ISupportErrorInfo_Release(errorinfo);
10817         IXMLDOMNode_Release(node);
10818         ptr++;
10819     }
10820
10821     /* IXMLDOMNamedNodeMap */
10822     b = VARIANT_FALSE;
10823     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
10824     EXPECT_HR(hr, S_OK);
10825     ok(b == VARIANT_TRUE, "got %d\n", b);
10826
10827     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10828     EXPECT_HR(hr, S_OK);
10829
10830     hr = IXMLDOMElement_get_attributes(elem, &map);
10831     EXPECT_HR(hr, S_OK);
10832
10833     EXPECT_REF(map, 1);
10834     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_ISupportErrorInfo, (void**)&errorinfo);
10835     EXPECT_HR(hr, S_OK);
10836     EXPECT_REF(map, 2);
10837
10838     hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMNamedNodeMap);
10839     EXPECT_HR(hr, S_OK);
10840
10841     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNamedNodeMap, (void**)&map2);
10842     EXPECT_HR(hr, S_OK);
10843     ok(map == map2, "got %p\n", map2);
10844     IXMLDOMNamedNodeMap_Release(map2);
10845
10846     EXPECT_REF(errorinfo, 2);
10847     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IUnknown, (void**)&unk);
10848     EXPECT_HR(hr, S_OK);
10849     EXPECT_REF(errorinfo, 3);
10850     EXPECT_REF(map, 3);
10851     IUnknown_Release(unk);
10852
10853     ISupportErrorInfo_Release(errorinfo);
10854     IXMLDOMNamedNodeMap_Release(map);
10855     IXMLDOMElement_Release(elem);
10856
10857     IXMLDOMDocument_Release(doc);
10858     free_bstrs();
10859 }
10860
10861 START_TEST(domdoc)
10862 {
10863     IXMLDOMDocument *doc;
10864     HRESULT hr;
10865
10866     hr = CoInitialize( NULL );
10867     ok( hr == S_OK, "failed to init com\n");
10868     if (hr != S_OK) return;
10869
10870     test_XMLHTTP();
10871
10872     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc );
10873     if (hr != S_OK)
10874     {
10875         win_skip("IXMLDOMDocument is not available (0x%08x)\n", hr);
10876         return;
10877     }
10878
10879     IXMLDOMDocument_Release(doc);
10880
10881     test_domdoc();
10882     test_persiststreaminit();
10883     test_domnode();
10884     test_refs();
10885     test_create();
10886     test_getElementsByTagName();
10887     test_get_text();
10888     test_get_childNodes();
10889     test_get_firstChild();
10890     test_get_lastChild();
10891     test_removeChild();
10892     test_replaceChild();
10893     test_removeNamedItem();
10894     test_IXMLDOMDocument2();
10895     test_whitespace();
10896     test_XPath();
10897     test_XSLPattern();
10898     test_cloneNode();
10899     test_xmlTypes();
10900     test_nodeTypeTests();
10901     test_save();
10902     test_testTransforms();
10903     test_namespaces();
10904     test_FormattingXML();
10905     test_nodeTypedValue();
10906     test_TransformWithLoadingLocalFile();
10907     test_put_nodeValue();
10908     test_document_IObjectSafety();
10909     test_splitText();
10910     test_getQualifiedItem();
10911     test_removeQualifiedItem();
10912     test_get_ownerDocument();
10913     test_setAttributeNode();
10914     test_put_dataType();
10915     test_createNode();
10916     test_get_prefix();
10917     test_default_properties();
10918     test_selectSingleNode();
10919     test_events();
10920     test_createProcessingInstruction();
10921     test_put_nodeTypedValue();
10922     test_get_xml();
10923     test_insertBefore();
10924     test_appendChild();
10925     test_get_doctype();
10926     test_get_tagName();
10927     test_get_dataType();
10928     test_get_nodeTypeString();
10929     test_get_attributes();
10930     test_selection();
10931     test_load();
10932     test_dispex();
10933     test_parseerror();
10934     test_getAttributeNode();
10935     test_supporterrorinfo();
10936
10937     test_xsltemplate();
10938
10939     test_nsnamespacemanager();
10940     test_nsnamespacemanager_override();
10941
10942     CoUninitialize();
10943 }