git.oblomov.eu Git - wine/blob - dlls/msxml3/tests/domdoc.c

   1 /*
   2  * XML test
   3  *
   4  * Copyright 2005 Mike McCormack for CodeWeavers
   5  * Copyright 2007-2008 Alistair Leslie-Hughes
   6  * Copyright 2010-2011 Adam Martinson for CodeWeavers
   7  * Copyright 2010-2012 Nikolay Sivov for CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24
  25 #define COBJMACROS
  26 #define CONST_VTABLE
  27
  28 #include <stdio.h>
  29 #include <assert.h>
  30
  31 #include "windows.h"
  32
  33 #include "msxml2.h"
  34 #include "msxml2did.h"
  35 #include "ole2.h"
  36 #include "dispex.h"
  37
  38 #include "initguid.h"
  39 #include "objsafe.h"
  40 #include "mshtml.h"
  41
  42 #include "wine/test.h"
  43
  44 /* undef the #define in msxml2 so that we can access all versions */
  45 #undef CLSID_DOMDocument
  46
  47 DEFINE_GUID(SID_SContainerDispatch, 0xb722be00, 0x4e68, 0x101b, 0xa2, 0xbc, 0x00, 0xaa, 0x00, 0x40, 0x47, 0x70);
  48 DEFINE_GUID(SID_UnknownSID, 0x75dd09cb, 0x6c40, 0x11d5, 0x85, 0x43, 0x00, 0xc0, 0x4f, 0xa0, 0xfb, 0xa3);
  49 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  50
  51 #define DEFINE_EXPECT(func) \
  52     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  53
  54 #define SET_EXPECT(func) \
  55     expect_ ## func = TRUE
  56
  57 #define CHECK_EXPECT2(func) \
  58     do { \
  59         ok(expect_ ##func, "unexpected call " #func "\n"); \
  60         called_ ## func = TRUE; \
  61     }while(0)
  62
  63 #define CHECK_CALLED(func) \
  64     do { \
  65         ok(called_ ## func, "expected " #func "\n"); \
  66         expect_ ## func = called_ ## func = FALSE; \
  67     }while(0)
  68
  69 static const char *debugstr_guid(REFIID riid)
  70 {
  71     static char buf[50];
  72
  73     if(!riid)
  74         return "(null)";
  75
  76     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  77             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
  78             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
  79             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
  80
  81     return buf;
  82 }
  83
  84 static int g_unexpectedcall, g_expectedcall;
  85
  86 typedef struct
  87 {
  88     IDispatch IDispatch_iface;
  89     LONG ref;
  90 } dispevent;
  91
  92 static inline dispevent *impl_from_IDispatch( IDispatch *iface )
  93 {
  94     return CONTAINING_RECORD(iface, dispevent, IDispatch_iface);
  95 }
  96
  97 static HRESULT WINAPI dispevent_QueryInterface(IDispatch *iface, REFIID riid, void **ppvObject)
  98 {
  99     *ppvObject = NULL;
 100
 101     if ( IsEqualGUID( riid, &IID_IDispatch) ||
 102          IsEqualGUID( riid, &IID_IUnknown) )
 103     {
 104         *ppvObject = iface;
 105     }
 106     else
 107         return E_NOINTERFACE;
 108
 109     IDispatch_AddRef( iface );
 110
 111     return S_OK;
 112 }
 113
 114 static ULONG WINAPI dispevent_AddRef(IDispatch *iface)
 115 {
 116     dispevent *This = impl_from_IDispatch( iface );
 117     return InterlockedIncrement( &This->ref );
 118 }
 119
 120 static ULONG WINAPI dispevent_Release(IDispatch *iface)
 121 {
 122     dispevent *This = impl_from_IDispatch( iface );
 123     ULONG ref = InterlockedDecrement( &This->ref );
 124
 125     if (ref == 0)
 126         HeapFree(GetProcessHeap(), 0, This);
 127
 128     return ref;
 129 }
 130
 131 static HRESULT WINAPI dispevent_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 132 {
 133     g_unexpectedcall++;
 134     *pctinfo = 0;
 135     return S_OK;
 136 }
 137
 138 static HRESULT WINAPI dispevent_GetTypeInfo(IDispatch *iface, UINT iTInfo,
 139         LCID lcid, ITypeInfo **ppTInfo)
 140 {
 141     g_unexpectedcall++;
 142     return S_OK;
 143 }
 144
 145 static HRESULT WINAPI dispevent_GetIDsOfNames(IDispatch *iface, REFIID riid,
 146         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 147 {
 148     g_unexpectedcall++;
 149     return S_OK;
 150 }
 151
 152 static HRESULT WINAPI dispevent_Invoke(IDispatch *iface, DISPID member, REFIID riid,
 153         LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result,
 154         EXCEPINFO *excepInfo, UINT *argErr)
 155 {
 156     ok(member == 0, "expected 0 member, got %d\n", member);
 157     ok(lcid == LOCALE_SYSTEM_DEFAULT, "expected LOCALE_SYSTEM_DEFAULT, got lcid %x\n", lcid);
 158     ok(flags == DISPATCH_METHOD, "expected DISPATCH_METHOD, got %d\n", flags);
 159
 160     ok(params->cArgs == 0, "got %d\n", params->cArgs);
 161     ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
 162     ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
 163     ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
 164
 165     ok(result == NULL, "got %p\n", result);
 166     ok(excepInfo == NULL, "got %p\n", excepInfo);
 167     ok(argErr == NULL, "got %p\n", argErr);
 168
 169     g_expectedcall++;
 170     return E_FAIL;
 171 }
 172
 173 static const IDispatchVtbl dispeventVtbl =
 174 {
 175     dispevent_QueryInterface,
 176     dispevent_AddRef,
 177     dispevent_Release,
 178     dispevent_GetTypeInfoCount,
 179     dispevent_GetTypeInfo,
 180     dispevent_GetIDsOfNames,
 181     dispevent_Invoke
 182 };
 183
 184 static IDispatch* create_dispevent(void)
 185 {
 186     dispevent *event = HeapAlloc(GetProcessHeap(), 0, sizeof(*event));
 187
 188     event->IDispatch_iface.lpVtbl = &dispeventVtbl;
 189     event->ref = 1;
 190
 191     return (IDispatch*)&event->IDispatch_iface;
 192 }
 193
 194 /* object site */
 195 DEFINE_EXPECT(site_qi_IServiceProvider);
 196 DEFINE_EXPECT(site_qi_IXMLDOMDocument);
 197 DEFINE_EXPECT(site_qi_IOleClientSite);
 198
 199 DEFINE_EXPECT(sp_queryservice_SID_SBindHost);
 200 DEFINE_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
 201 DEFINE_EXPECT(sp_queryservice_SID_secmgr_htmldoc2);
 202 DEFINE_EXPECT(sp_queryservice_SID_secmgr_xmldomdoc);
 203 DEFINE_EXPECT(sp_queryservice_SID_secmgr_secmgr);
 204
 205 DEFINE_EXPECT(htmldoc2_get_all);
 206 DEFINE_EXPECT(htmldoc2_get_url);
 207 DEFINE_EXPECT(collection_get_length);
 208
 209 typedef struct
 210 {
 211     IServiceProvider IServiceProvider_iface;
 212 } testprov_t;
 213
 214 testprov_t testprov;
 215
 216 static HRESULT WINAPI site_QueryInterface(IUnknown *iface, REFIID riid, void **ppvObject)
 217 {
 218     *ppvObject = NULL;
 219
 220     if (IsEqualGUID(riid, &IID_IServiceProvider))
 221         CHECK_EXPECT2(site_qi_IServiceProvider);
 222
 223     if (IsEqualGUID(riid, &IID_IXMLDOMDocument))
 224         CHECK_EXPECT2(site_qi_IXMLDOMDocument);
 225
 226     if (IsEqualGUID(riid, &IID_IOleClientSite))
 227         CHECK_EXPECT2(site_qi_IOleClientSite);
 228
 229     if (IsEqualGUID(riid, &IID_IUnknown))
 230          *ppvObject = iface;
 231     else if (IsEqualGUID(riid, &IID_IServiceProvider))
 232          *ppvObject = &testprov.IServiceProvider_iface;
 233
 234     if (*ppvObject) IUnknown_AddRef(iface);
 235
 236     return *ppvObject ? S_OK : E_NOINTERFACE;
 237 }
 238
 239 static ULONG WINAPI site_AddRef(IUnknown *iface)
 240 {
 241     return 2;
 242 }
 243
 244 static ULONG WINAPI site_Release(IUnknown *iface)
 245 {
 246     return 1;
 247 }
 248
 249 static const IUnknownVtbl testsiteVtbl =
 250 {
 251     site_QueryInterface,
 252     site_AddRef,
 253     site_Release
 254 };
 255
 256 typedef struct
 257 {
 258     IUnknown IUnknown_iface;
 259 } testsite_t;
 260
 261 static testsite_t testsite = { { &testsiteVtbl } };
 262
 263 /* test IHTMLElementCollection */
 264 static HRESULT WINAPI htmlecoll_QueryInterface(IHTMLElementCollection *iface, REFIID riid, void **ppvObject)
 265 {
 266     ok(0, "unexpected call\n");
 267     *ppvObject = NULL;
 268     return E_NOINTERFACE;
 269 }
 270
 271 static ULONG WINAPI htmlecoll_AddRef(IHTMLElementCollection *iface)
 272 {
 273     return 2;
 274 }
 275
 276 static ULONG WINAPI htmlecoll_Release(IHTMLElementCollection *iface)
 277 {
 278     return 1;
 279 }
 280
 281 static HRESULT WINAPI htmlecoll_GetTypeInfoCount(IHTMLElementCollection *iface, UINT *pctinfo)
 282 {
 283     ok(0, "unexpected call\n");
 284     return E_NOTIMPL;
 285 }
 286
 287 static HRESULT WINAPI htmlecoll_GetTypeInfo(IHTMLElementCollection *iface, UINT iTInfo,
 288                                                 LCID lcid, ITypeInfo **ppTInfo)
 289 {
 290     ok(0, "unexpected call\n");
 291     return E_NOTIMPL;
 292 }
 293
 294 static HRESULT WINAPI htmlecoll_GetIDsOfNames(IHTMLElementCollection *iface, REFIID riid,
 295                                                 LPOLESTR *rgszNames, UINT cNames,
 296                                                 LCID lcid, DISPID *rgDispId)
 297 {
 298     ok(0, "unexpected call\n");
 299     return E_NOTIMPL;
 300 }
 301
 302 static HRESULT WINAPI htmlecoll_Invoke(IHTMLElementCollection *iface, DISPID dispIdMember,
 303                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 304                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 305 {
 306     ok(0, "unexpected call\n");
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI htmlecoll_toString(IHTMLElementCollection *iface, BSTR *String)
 311 {
 312     ok(0, "unexpected call\n");
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI htmlecoll_put_length(IHTMLElementCollection *iface, LONG v)
 317 {
 318     ok(0, "unexpected call\n");
 319     return E_NOTIMPL;
 320 }
 321
 322 static HRESULT WINAPI htmlecoll_get_length(IHTMLElementCollection *iface, LONG *v)
 323 {
 324     CHECK_EXPECT2(collection_get_length);
 325     return E_NOTIMPL;
 326 }
 327
 328 static HRESULT WINAPI htmlecoll_get__newEnum(IHTMLElementCollection *iface, IUnknown **p)
 329 {
 330     ok(0, "unexpected call\n");
 331     return E_NOTIMPL;
 332 }
 333
 334 static HRESULT WINAPI htmlecoll_item(IHTMLElementCollection *iface, VARIANT name, VARIANT index, IDispatch **pdisp)
 335 {
 336     ok(0, "unexpected call\n");
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI htmlecoll_tags(IHTMLElementCollection *iface, VARIANT tagName, IDispatch **pdisp)
 341 {
 342     ok(0, "unexpected call\n");
 343     return E_NOTIMPL;
 344 }
 345
 346 static const IHTMLElementCollectionVtbl TestHTMLECollectionVtbl = {
 347     htmlecoll_QueryInterface,
 348     htmlecoll_AddRef,
 349     htmlecoll_Release,
 350     htmlecoll_GetTypeInfoCount,
 351     htmlecoll_GetTypeInfo,
 352     htmlecoll_GetIDsOfNames,
 353     htmlecoll_Invoke,
 354
 355     htmlecoll_toString,
 356     htmlecoll_put_length,
 357     htmlecoll_get_length,
 358     htmlecoll_get__newEnum,
 359     htmlecoll_item,
 360     htmlecoll_tags
 361 };
 362
 363 typedef struct
 364 {
 365     IHTMLElementCollection IHTMLElementCollection_iface;
 366 } testhtmlecoll_t;
 367
 368 static testhtmlecoll_t htmlecoll = { { &TestHTMLECollectionVtbl } };
 369
 370 /* test IHTMLDocument2 */
 371 static HRESULT WINAPI htmldoc2_QueryInterface(IHTMLDocument2 *iface, REFIID riid, void **ppvObject)
 372 {
 373    trace("\n");
 374    *ppvObject = NULL;
 375    return E_NOINTERFACE;
 376 }
 377
 378 static ULONG WINAPI htmldoc2_AddRef(IHTMLDocument2 *iface)
 379 {
 380     return 2;
 381 }
 382
 383 static ULONG WINAPI htmldoc2_Release(IHTMLDocument2 *iface)
 384 {
 385     return 1;
 386 }
 387
 388 static HRESULT WINAPI htmldoc2_GetTypeInfoCount(IHTMLDocument2 *iface, UINT *pctinfo)
 389 {
 390     ok(0, "unexpected call\n");
 391     return E_NOTIMPL;
 392 }
 393
 394 static HRESULT WINAPI htmldoc2_GetTypeInfo(IHTMLDocument2 *iface, UINT iTInfo,
 395                                                 LCID lcid, ITypeInfo **ppTInfo)
 396 {
 397     ok(0, "unexpected call\n");
 398     return E_NOTIMPL;
 399 }
 400
 401 static HRESULT WINAPI htmldoc2_GetIDsOfNames(IHTMLDocument2 *iface, REFIID riid,
 402                                                 LPOLESTR *rgszNames, UINT cNames,
 403                                                 LCID lcid, DISPID *rgDispId)
 404 {
 405     ok(0, "unexpected call\n");
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI htmldoc2_Invoke(IHTMLDocument2 *iface, DISPID dispIdMember,
 410                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 411                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 412 {
 413     ok(0, "unexpected call\n");
 414     return E_NOTIMPL;
 415 }
 416
 417 static HRESULT WINAPI htmldoc2_get_Script(IHTMLDocument2 *iface, IDispatch **p)
 418 {
 419     ok(0, "unexpected call\n");
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI htmldoc2_get_all(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 424 {
 425     CHECK_EXPECT2(htmldoc2_get_all);
 426     *p = &htmlecoll.IHTMLElementCollection_iface;
 427     return S_OK;
 428 }
 429
 430 static HRESULT WINAPI htmldoc2_get_body(IHTMLDocument2 *iface, IHTMLElement **p)
 431 {
 432     ok(0, "unexpected call\n");
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT WINAPI htmldoc2_get_activeElement(IHTMLDocument2 *iface, IHTMLElement **p)
 437 {
 438     ok(0, "unexpected call\n");
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI htmldoc2_get_images(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 443 {
 444     ok(0, "unexpected call\n");
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI htmldoc2_get_applets(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 449 {
 450     ok(0, "unexpected call\n");
 451     return E_NOTIMPL;
 452 }
 453
 454 static HRESULT WINAPI htmldoc2_get_links(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 455 {
 456     ok(0, "unexpected call\n");
 457     return E_NOTIMPL;
 458 }
 459
 460 static HRESULT WINAPI htmldoc2_get_forms(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 461 {
 462     ok(0, "unexpected call\n");
 463     return E_NOTIMPL;
 464 }
 465
 466 static HRESULT WINAPI htmldoc2_get_anchors(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 467 {
 468     ok(0, "unexpected call\n");
 469     return E_NOTIMPL;
 470 }
 471
 472 static HRESULT WINAPI htmldoc2_put_title(IHTMLDocument2 *iface, BSTR v)
 473 {
 474     ok(0, "unexpected call\n");
 475     return E_NOTIMPL;
 476 }
 477
 478 static HRESULT WINAPI htmldoc2_get_title(IHTMLDocument2 *iface, BSTR *p)
 479 {
 480     ok(0, "unexpected call\n");
 481     return E_NOTIMPL;
 482 }
 483
 484 static HRESULT WINAPI htmldoc2_get_scripts(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 485 {
 486     ok(0, "unexpected call\n");
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI htmldoc2_put_designMode(IHTMLDocument2 *iface, BSTR v)
 491 {
 492     ok(0, "unexpected call\n");
 493     return E_NOTIMPL;
 494 }
 495
 496 static HRESULT WINAPI htmldoc2_get_designMode(IHTMLDocument2 *iface, BSTR *p)
 497 {
 498     ok(0, "unexpected call\n");
 499     return E_NOTIMPL;
 500 }
 501
 502 static HRESULT WINAPI htmldoc2_get_selection(IHTMLDocument2 *iface, IHTMLSelectionObject **p)
 503 {
 504     ok(0, "unexpected call\n");
 505     return E_NOTIMPL;
 506 }
 507
 508 static HRESULT WINAPI htmldoc2_get_readyState(IHTMLDocument2 *iface, BSTR *p)
 509 {
 510     ok(0, "unexpected call\n");
 511     return E_NOTIMPL;
 512 }
 513
 514 static HRESULT WINAPI htmldoc2_get_frames(IHTMLDocument2 *iface, IHTMLFramesCollection2 **p)
 515 {
 516     ok(0, "unexpected call\n");
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI htmldoc2_get_embeds(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 521 {
 522     ok(0, "unexpected call\n");
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI htmldoc2_get_plugins(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 527 {
 528     ok(0, "unexpected call\n");
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI htmldoc2_put_alinkColor(IHTMLDocument2 *iface, VARIANT v)
 533 {
 534     ok(0, "unexpected call\n");
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI htmldoc2_get_alinkColor(IHTMLDocument2 *iface, VARIANT *p)
 539 {
 540     ok(0, "unexpected call\n");
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI htmldoc2_put_bgColor(IHTMLDocument2 *iface, VARIANT v)
 545 {
 546     ok(0, "unexpected call\n");
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI htmldoc2_get_bgColor(IHTMLDocument2 *iface, VARIANT *p)
 551 {
 552     ok(0, "unexpected call\n");
 553     return E_NOTIMPL;
 554 }
 555
 556 static HRESULT WINAPI htmldoc2_put_fgColor(IHTMLDocument2 *iface, VARIANT v)
 557 {
 558     ok(0, "unexpected call\n");
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI htmldoc2_get_fgColor(IHTMLDocument2 *iface, VARIANT *p)
 563 {
 564     ok(0, "unexpected call\n");
 565     return E_NOTIMPL;
 566 }
 567
 568 static HRESULT WINAPI htmldoc2_put_linkColor(IHTMLDocument2 *iface, VARIANT v)
 569 {
 570     ok(0, "unexpected call\n");
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI htmldoc2_get_linkColor(IHTMLDocument2 *iface, VARIANT *p)
 575 {
 576     ok(0, "unexpected call\n");
 577     return E_NOTIMPL;
 578 }
 579
 580 static HRESULT WINAPI htmldoc2_put_vlinkColor(IHTMLDocument2 *iface, VARIANT v)
 581 {
 582     ok(0, "unexpected call\n");
 583     return E_NOTIMPL;
 584 }
 585
 586 static HRESULT WINAPI htmldoc2_get_vlinkColor(IHTMLDocument2 *iface, VARIANT *p)
 587 {
 588     ok(0, "unexpected call\n");
 589     return E_NOTIMPL;
 590 }
 591
 592 static HRESULT WINAPI htmldoc2_get_referrer(IHTMLDocument2 *iface, BSTR *p)
 593 {
 594     ok(0, "unexpected call\n");
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI htmldoc2_get_location(IHTMLDocument2 *iface, IHTMLLocation **p)
 599 {
 600     ok(0, "unexpected call\n");
 601     return E_NOTIMPL;
 602 }
 603
 604 static HRESULT WINAPI htmldoc2_get_lastModified(IHTMLDocument2 *iface, BSTR *p)
 605 {
 606     ok(0, "unexpected call\n");
 607     return E_NOTIMPL;
 608 }
 609
 610 static HRESULT WINAPI htmldoc2_put_URL(IHTMLDocument2 *iface, BSTR v)
 611 {
 612     ok(0, "unexpected call\n");
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI htmldoc2_get_URL(IHTMLDocument2 *iface, BSTR *p)
 617 {
 618     CHECK_EXPECT2(htmldoc2_get_url);
 619     *p = SysAllocString(NULL);
 620     return S_OK;
 621 }
 622
 623 static HRESULT WINAPI htmldoc2_put_domain(IHTMLDocument2 *iface, BSTR v)
 624 {
 625     ok(0, "unexpected call\n");
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT WINAPI htmldoc2_get_domain(IHTMLDocument2 *iface, BSTR *p)
 630 {
 631     ok(0, "unexpected call\n");
 632     return E_NOTIMPL;
 633 }
 634
 635 static HRESULT WINAPI htmldoc2_put_cookie(IHTMLDocument2 *iface, BSTR v)
 636 {
 637     ok(0, "unexpected call\n");
 638     return E_NOTIMPL;
 639 }
 640
 641 static HRESULT WINAPI htmldoc2_get_cookie(IHTMLDocument2 *iface, BSTR *p)
 642 {
 643     ok(0, "unexpected call\n");
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI htmldoc2_put_expando(IHTMLDocument2 *iface, VARIANT_BOOL v)
 648 {
 649     ok(0, "unexpected call\n");
 650     return E_NOTIMPL;
 651 }
 652
 653 static HRESULT WINAPI htmldoc2_get_expando(IHTMLDocument2 *iface, VARIANT_BOOL *p)
 654 {
 655     ok(0, "unexpected call\n");
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT WINAPI htmldoc2_put_charset(IHTMLDocument2 *iface, BSTR v)
 660 {
 661     ok(0, "unexpected call\n");
 662     return E_NOTIMPL;
 663 }
 664
 665 static HRESULT WINAPI htmldoc2_get_charset(IHTMLDocument2 *iface, BSTR *p)
 666 {
 667     ok(0, "unexpected call\n");
 668     return E_NOTIMPL;
 669 }
 670
 671 static HRESULT WINAPI htmldoc2_put_defaultCharset(IHTMLDocument2 *iface, BSTR v)
 672 {
 673     ok(0, "unexpected call\n");
 674     return E_NOTIMPL;
 675 }
 676
 677 static HRESULT WINAPI htmldoc2_get_defaultCharset(IHTMLDocument2 *iface, BSTR *p)
 678 {
 679     ok(0, "unexpected call\n");
 680     return E_NOTIMPL;
 681 }
 682
 683 static HRESULT WINAPI htmldoc2_get_mimeType(IHTMLDocument2 *iface, BSTR *p)
 684 {
 685     ok(0, "unexpected call\n");
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI htmldoc2_get_fileSize(IHTMLDocument2 *iface, BSTR *p)
 690 {
 691     ok(0, "unexpected call\n");
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI htmldoc2_get_fileCreatedDate(IHTMLDocument2 *iface, BSTR *p)
 696 {
 697     ok(0, "unexpected call\n");
 698     return E_NOTIMPL;
 699 }
 700
 701 static HRESULT WINAPI htmldoc2_get_fileModifiedDate(IHTMLDocument2 *iface, BSTR *p)
 702 {
 703     ok(0, "unexpected call\n");
 704     return E_NOTIMPL;
 705 }
 706
 707 static HRESULT WINAPI htmldoc2_get_fileUpdatedDate(IHTMLDocument2 *iface, BSTR *p)
 708 {
 709     ok(0, "unexpected call\n");
 710     return E_NOTIMPL;
 711 }
 712
 713 static HRESULT WINAPI htmldoc2_get_security(IHTMLDocument2 *iface, BSTR *p)
 714 {
 715     ok(0, "unexpected call\n");
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI htmldoc2_get_protocol(IHTMLDocument2 *iface, BSTR *p)
 720 {
 721     ok(0, "unexpected call\n");
 722     return E_NOTIMPL;
 723 }
 724
 725 static HRESULT WINAPI htmldoc2_get_nameProp(IHTMLDocument2 *iface, BSTR *p)
 726 {
 727     ok(0, "unexpected call\n");
 728     return E_NOTIMPL;
 729 }
 730
 731 static HRESULT WINAPI htmldoc2_write(IHTMLDocument2 *iface, SAFEARRAY *psarray)
 732 {
 733     ok(0, "unexpected call\n");
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI htmldoc2_writeln(IHTMLDocument2 *iface, SAFEARRAY *psarray)
 738 {
 739     ok(0, "unexpected call\n");
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI htmldoc2_open(IHTMLDocument2 *iface, BSTR url, VARIANT name,
 744                         VARIANT features, VARIANT replace, IDispatch **pomWindowResult)
 745 {
 746     ok(0, "unexpected call\n");
 747     return E_NOTIMPL;
 748 }
 749
 750 static HRESULT WINAPI htmldoc2_close(IHTMLDocument2 *iface)
 751 {
 752     ok(0, "unexpected call\n");
 753     return E_NOTIMPL;
 754 }
 755
 756 static HRESULT WINAPI htmldoc2_clear(IHTMLDocument2 *iface)
 757 {
 758     ok(0, "unexpected call\n");
 759     return E_NOTIMPL;
 760 }
 761
 762 static HRESULT WINAPI htmldoc2_queryCommandSupported(IHTMLDocument2 *iface, BSTR cmdID,
 763                                                         VARIANT_BOOL *pfRet)
 764 {
 765     ok(0, "unexpected call\n");
 766     return E_NOTIMPL;
 767 }
 768
 769 static HRESULT WINAPI htmldoc2_queryCommandEnabled(IHTMLDocument2 *iface, BSTR cmdID,
 770                                                         VARIANT_BOOL *pfRet)
 771 {
 772     ok(0, "unexpected call\n");
 773     return E_NOTIMPL;
 774 }
 775
 776 static HRESULT WINAPI htmldoc2_queryCommandState(IHTMLDocument2 *iface, BSTR cmdID,
 777                                                         VARIANT_BOOL *pfRet)
 778 {
 779     ok(0, "unexpected call\n");
 780     return E_NOTIMPL;
 781 }
 782
 783 static HRESULT WINAPI htmldoc2_queryCommandIndeterm(IHTMLDocument2 *iface, BSTR cmdID,
 784                                                         VARIANT_BOOL *pfRet)
 785 {
 786     ok(0, "unexpected call\n");
 787     return E_NOTIMPL;
 788 }
 789
 790 static HRESULT WINAPI htmldoc2_queryCommandText(IHTMLDocument2 *iface, BSTR cmdID,
 791                                                         BSTR *pfRet)
 792 {
 793     ok(0, "unexpected call\n");
 794     return E_NOTIMPL;
 795 }
 796
 797 static HRESULT WINAPI htmldoc2_queryCommandValue(IHTMLDocument2 *iface, BSTR cmdID,
 798                                                         VARIANT *pfRet)
 799 {
 800     ok(0, "unexpected call\n");
 801     return E_NOTIMPL;
 802 }
 803
 804 static HRESULT WINAPI htmldoc2_execCommand(IHTMLDocument2 *iface, BSTR cmdID,
 805                                 VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
 806 {
 807     ok(0, "unexpected call\n");
 808     return E_NOTIMPL;
 809 }
 810
 811 static HRESULT WINAPI htmldoc2_execCommandShowHelp(IHTMLDocument2 *iface, BSTR cmdID,
 812                                                         VARIANT_BOOL *pfRet)
 813 {
 814     ok(0, "unexpected call\n");
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT WINAPI htmldoc2_createElement(IHTMLDocument2 *iface, BSTR eTag,
 819                                                  IHTMLElement **newElem)
 820 {
 821     ok(0, "unexpected call\n");
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI htmldoc2_put_onhelp(IHTMLDocument2 *iface, VARIANT v)
 826 {
 827     ok(0, "unexpected call\n");
 828     return E_NOTIMPL;
 829 }
 830
 831 static HRESULT WINAPI htmldoc2_get_onhelp(IHTMLDocument2 *iface, VARIANT *p)
 832 {
 833     ok(0, "unexpected call\n");
 834     return E_NOTIMPL;
 835 }
 836
 837 static HRESULT WINAPI htmldoc2_put_onclick(IHTMLDocument2 *iface, VARIANT v)
 838 {
 839     ok(0, "unexpected call\n");
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI htmldoc2_get_onclick(IHTMLDocument2 *iface, VARIANT *p)
 844 {
 845     ok(0, "unexpected call\n");
 846     return E_NOTIMPL;
 847 }
 848
 849 static HRESULT WINAPI htmldoc2_put_ondblclick(IHTMLDocument2 *iface, VARIANT v)
 850 {
 851     ok(0, "unexpected call\n");
 852     return E_NOTIMPL;
 853 }
 854
 855 static HRESULT WINAPI htmldoc2_get_ondblclick(IHTMLDocument2 *iface, VARIANT *p)
 856 {
 857     ok(0, "unexpected call\n");
 858     return E_NOTIMPL;
 859 }
 860
 861 static HRESULT WINAPI htmldoc2_put_onkeyup(IHTMLDocument2 *iface, VARIANT v)
 862 {
 863     ok(0, "unexpected call\n");
 864     return E_NOTIMPL;
 865 }
 866
 867 static HRESULT WINAPI htmldoc2_get_onkeyup(IHTMLDocument2 *iface, VARIANT *p)
 868 {
 869     ok(0, "unexpected call\n");
 870     return E_NOTIMPL;
 871 }
 872
 873 static HRESULT WINAPI htmldoc2_put_onkeydown(IHTMLDocument2 *iface, VARIANT v)
 874 {
 875     ok(0, "unexpected call\n");
 876     return E_NOTIMPL;
 877 }
 878
 879 static HRESULT WINAPI htmldoc2_get_onkeydown(IHTMLDocument2 *iface, VARIANT *p)
 880 {
 881     ok(0, "unexpected call\n");
 882     return E_NOTIMPL;
 883 }
 884
 885 static HRESULT WINAPI htmldoc2_put_onkeypress(IHTMLDocument2 *iface, VARIANT v)
 886 {
 887     ok(0, "unexpected call\n");
 888     return E_NOTIMPL;
 889 }
 890
 891 static HRESULT WINAPI htmldoc2_get_onkeypress(IHTMLDocument2 *iface, VARIANT *p)
 892 {
 893     ok(0, "unexpected call\n");
 894     return E_NOTIMPL;
 895 }
 896
 897 static HRESULT WINAPI htmldoc2_put_onmouseup(IHTMLDocument2 *iface, VARIANT v)
 898 {
 899     ok(0, "unexpected call\n");
 900     return E_NOTIMPL;
 901 }
 902
 903 static HRESULT WINAPI htmldoc2_get_onmouseup(IHTMLDocument2 *iface, VARIANT *p)
 904 {
 905     ok(0, "unexpected call\n");
 906     return E_NOTIMPL;
 907 }
 908
 909 static HRESULT WINAPI htmldoc2_put_onmousedown(IHTMLDocument2 *iface, VARIANT v)
 910 {
 911     ok(0, "unexpected call\n");
 912     return E_NOTIMPL;
 913 }
 914
 915 static HRESULT WINAPI htmldoc2_get_onmousedown(IHTMLDocument2 *iface, VARIANT *p)
 916 {
 917     ok(0, "unexpected call\n");
 918     return E_NOTIMPL;
 919 }
 920
 921 static HRESULT WINAPI htmldoc2_put_onmousemove(IHTMLDocument2 *iface, VARIANT v)
 922 {
 923     ok(0, "unexpected call\n");
 924     return E_NOTIMPL;
 925 }
 926
 927 static HRESULT WINAPI htmldoc2_get_onmousemove(IHTMLDocument2 *iface, VARIANT *p)
 928 {
 929     ok(0, "unexpected call\n");
 930     return E_NOTIMPL;
 931 }
 932
 933 static HRESULT WINAPI htmldoc2_put_onmouseout(IHTMLDocument2 *iface, VARIANT v)
 934 {
 935     ok(0, "unexpected call\n");
 936     return E_NOTIMPL;
 937 }
 938
 939 static HRESULT WINAPI htmldoc2_get_onmouseout(IHTMLDocument2 *iface, VARIANT *p)
 940 {
 941     ok(0, "unexpected call\n");
 942     return E_NOTIMPL;
 943 }
 944
 945 static HRESULT WINAPI htmldoc2_put_onmouseover(IHTMLDocument2 *iface, VARIANT v)
 946 {
 947     ok(0, "unexpected call\n");
 948     return E_NOTIMPL;
 949 }
 950
 951 static HRESULT WINAPI htmldoc2_get_onmouseover(IHTMLDocument2 *iface, VARIANT *p)
 952 {
 953     ok(0, "unexpected call\n");
 954     return E_NOTIMPL;
 955 }
 956
 957 static HRESULT WINAPI htmldoc2_put_onreadystatechange(IHTMLDocument2 *iface, VARIANT v)
 958 {
 959     ok(0, "unexpected call\n");
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI htmldoc2_get_onreadystatechange(IHTMLDocument2 *iface, VARIANT *p)
 964 {
 965     ok(0, "unexpected call\n");
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI htmldoc2_put_onafterupdate(IHTMLDocument2 *iface, VARIANT v)
 970 {
 971     ok(0, "unexpected call\n");
 972     return E_NOTIMPL;
 973 }
 974
 975 static HRESULT WINAPI htmldoc2_get_onafterupdate(IHTMLDocument2 *iface, VARIANT *p)
 976 {
 977     ok(0, "unexpected call\n");
 978     return E_NOTIMPL;
 979 }
 980
 981 static HRESULT WINAPI htmldoc2_put_onrowexit(IHTMLDocument2 *iface, VARIANT v)
 982 {
 983     ok(0, "unexpected call\n");
 984     return E_NOTIMPL;
 985 }
 986
 987 static HRESULT WINAPI htmldoc2_get_onrowexit(IHTMLDocument2 *iface, VARIANT *p)
 988 {
 989     ok(0, "unexpected call\n");
 990     return E_NOTIMPL;
 991 }
 992
 993 static HRESULT WINAPI htmldoc2_put_onrowenter(IHTMLDocument2 *iface, VARIANT v)
 994 {
 995     ok(0, "unexpected call\n");
 996     return E_NOTIMPL;
 997 }
 998
 999 static HRESULT WINAPI htmldoc2_get_onrowenter(IHTMLDocument2 *iface, VARIANT *p)
1000 {
1001     ok(0, "unexpected call\n");
1002     return E_NOTIMPL;
1003 }
1004
1005 static HRESULT WINAPI htmldoc2_put_ondragstart(IHTMLDocument2 *iface, VARIANT v)
1006 {
1007     ok(0, "unexpected call\n");
1008     return E_NOTIMPL;
1009 }
1010
1011 static HRESULT WINAPI htmldoc2_get_ondragstart(IHTMLDocument2 *iface, VARIANT *p)
1012 {
1013     ok(0, "unexpected call\n");
1014     return E_NOTIMPL;
1015 }
1016
1017 static HRESULT WINAPI htmldoc2_put_onselectstart(IHTMLDocument2 *iface, VARIANT v)
1018 {
1019     ok(0, "unexpected call\n");
1020     return E_NOTIMPL;
1021 }
1022
1023 static HRESULT WINAPI htmldoc2_get_onselectstart(IHTMLDocument2 *iface, VARIANT *p)
1024 {
1025     ok(0, "unexpected call\n");
1026     return E_NOTIMPL;
1027 }
1028
1029 static HRESULT WINAPI htmldoc2_elementFromPoint(IHTMLDocument2 *iface, LONG x, LONG y,
1030                                                         IHTMLElement **elementHit)
1031 {
1032     ok(0, "unexpected call\n");
1033     return E_NOTIMPL;
1034 }
1035
1036 static HRESULT WINAPI htmldoc2_get_parentWindow(IHTMLDocument2 *iface, IHTMLWindow2 **p)
1037 {
1038     ok(0, "unexpected call\n");
1039     return E_NOTIMPL;
1040 }
1041
1042 static HRESULT WINAPI htmldoc2_get_styleSheets(IHTMLDocument2 *iface,
1043                                                    IHTMLStyleSheetsCollection **p)
1044 {
1045     ok(0, "unexpected call\n");
1046     return E_NOTIMPL;
1047 }
1048
1049 static HRESULT WINAPI htmldoc2_put_onbeforeupdate(IHTMLDocument2 *iface, VARIANT v)
1050 {
1051     ok(0, "unexpected call\n");
1052     return E_NOTIMPL;
1053 }
1054
1055 static HRESULT WINAPI htmldoc2_get_onbeforeupdate(IHTMLDocument2 *iface, VARIANT *p)
1056 {
1057     ok(0, "unexpected call\n");
1058     return E_NOTIMPL;
1059 }
1060
1061 static HRESULT WINAPI htmldoc2_put_onerrorupdate(IHTMLDocument2 *iface, VARIANT v)
1062 {
1063     ok(0, "unexpected call\n");
1064     return E_NOTIMPL;
1065 }
1066
1067 static HRESULT WINAPI htmldoc2_get_onerrorupdate(IHTMLDocument2 *iface, VARIANT *p)
1068 {
1069     ok(0, "unexpected call\n");
1070     return E_NOTIMPL;
1071 }
1072
1073 static HRESULT WINAPI htmldoc2_toString(IHTMLDocument2 *iface, BSTR *String)
1074 {
1075     ok(0, "unexpected call\n");
1076     return E_NOTIMPL;
1077 }
1078
1079 static HRESULT WINAPI htmldoc2_createStyleSheet(IHTMLDocument2 *iface, BSTR bstrHref,
1080                                             LONG lIndex, IHTMLStyleSheet **ppnewStyleSheet)
1081 {
1082     ok(0, "unexpected call\n");
1083     return E_NOTIMPL;
1084 }
1085
1086 static const IHTMLDocument2Vtbl TestHTMLDocumentVtbl = {
1087     htmldoc2_QueryInterface,
1088     htmldoc2_AddRef,
1089     htmldoc2_Release,
1090     htmldoc2_GetTypeInfoCount,
1091     htmldoc2_GetTypeInfo,
1092     htmldoc2_GetIDsOfNames,
1093     htmldoc2_Invoke,
1094     htmldoc2_get_Script,
1095     htmldoc2_get_all,
1096     htmldoc2_get_body,
1097     htmldoc2_get_activeElement,
1098     htmldoc2_get_images,
1099     htmldoc2_get_applets,
1100     htmldoc2_get_links,
1101     htmldoc2_get_forms,
1102     htmldoc2_get_anchors,
1103     htmldoc2_put_title,
1104     htmldoc2_get_title,
1105     htmldoc2_get_scripts,
1106     htmldoc2_put_designMode,
1107     htmldoc2_get_designMode,
1108     htmldoc2_get_selection,
1109     htmldoc2_get_readyState,
1110     htmldoc2_get_frames,
1111     htmldoc2_get_embeds,
1112     htmldoc2_get_plugins,
1113     htmldoc2_put_alinkColor,
1114     htmldoc2_get_alinkColor,
1115     htmldoc2_put_bgColor,
1116     htmldoc2_get_bgColor,
1117     htmldoc2_put_fgColor,
1118     htmldoc2_get_fgColor,
1119     htmldoc2_put_linkColor,
1120     htmldoc2_get_linkColor,
1121     htmldoc2_put_vlinkColor,
1122     htmldoc2_get_vlinkColor,
1123     htmldoc2_get_referrer,
1124     htmldoc2_get_location,
1125     htmldoc2_get_lastModified,
1126     htmldoc2_put_URL,
1127     htmldoc2_get_URL,
1128     htmldoc2_put_domain,
1129     htmldoc2_get_domain,
1130     htmldoc2_put_cookie,
1131     htmldoc2_get_cookie,
1132     htmldoc2_put_expando,
1133     htmldoc2_get_expando,
1134     htmldoc2_put_charset,
1135     htmldoc2_get_charset,
1136     htmldoc2_put_defaultCharset,
1137     htmldoc2_get_defaultCharset,
1138     htmldoc2_get_mimeType,
1139     htmldoc2_get_fileSize,
1140     htmldoc2_get_fileCreatedDate,
1141     htmldoc2_get_fileModifiedDate,
1142     htmldoc2_get_fileUpdatedDate,
1143     htmldoc2_get_security,
1144     htmldoc2_get_protocol,
1145     htmldoc2_get_nameProp,
1146     htmldoc2_write,
1147     htmldoc2_writeln,
1148     htmldoc2_open,
1149     htmldoc2_close,
1150     htmldoc2_clear,
1151     htmldoc2_queryCommandSupported,
1152     htmldoc2_queryCommandEnabled,
1153     htmldoc2_queryCommandState,
1154     htmldoc2_queryCommandIndeterm,
1155     htmldoc2_queryCommandText,
1156     htmldoc2_queryCommandValue,
1157     htmldoc2_execCommand,
1158     htmldoc2_execCommandShowHelp,
1159     htmldoc2_createElement,
1160     htmldoc2_put_onhelp,
1161     htmldoc2_get_onhelp,
1162     htmldoc2_put_onclick,
1163     htmldoc2_get_onclick,
1164     htmldoc2_put_ondblclick,
1165     htmldoc2_get_ondblclick,
1166     htmldoc2_put_onkeyup,
1167     htmldoc2_get_onkeyup,
1168     htmldoc2_put_onkeydown,
1169     htmldoc2_get_onkeydown,
1170     htmldoc2_put_onkeypress,
1171     htmldoc2_get_onkeypress,
1172     htmldoc2_put_onmouseup,
1173     htmldoc2_get_onmouseup,
1174     htmldoc2_put_onmousedown,
1175     htmldoc2_get_onmousedown,
1176     htmldoc2_put_onmousemove,
1177     htmldoc2_get_onmousemove,
1178     htmldoc2_put_onmouseout,
1179     htmldoc2_get_onmouseout,
1180     htmldoc2_put_onmouseover,
1181     htmldoc2_get_onmouseover,
1182     htmldoc2_put_onreadystatechange,
1183     htmldoc2_get_onreadystatechange,
1184     htmldoc2_put_onafterupdate,
1185     htmldoc2_get_onafterupdate,
1186     htmldoc2_put_onrowexit,
1187     htmldoc2_get_onrowexit,
1188     htmldoc2_put_onrowenter,
1189     htmldoc2_get_onrowenter,
1190     htmldoc2_put_ondragstart,
1191     htmldoc2_get_ondragstart,
1192     htmldoc2_put_onselectstart,
1193     htmldoc2_get_onselectstart,
1194     htmldoc2_elementFromPoint,
1195     htmldoc2_get_parentWindow,
1196     htmldoc2_get_styleSheets,
1197     htmldoc2_put_onbeforeupdate,
1198     htmldoc2_get_onbeforeupdate,
1199     htmldoc2_put_onerrorupdate,
1200     htmldoc2_get_onerrorupdate,
1201     htmldoc2_toString,
1202     htmldoc2_createStyleSheet
1203 };
1204
1205 typedef struct
1206 {
1207     IHTMLDocument2 IHTMLDocument2_iface;
1208 } testhtmldoc2_t;
1209
1210 static testhtmldoc2_t htmldoc2 = { { &TestHTMLDocumentVtbl } };
1211
1212 static HRESULT WINAPI sp_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppvObject)
1213 {
1214     *ppvObject = NULL;
1215
1216     if (IsEqualGUID(riid, &IID_IUnknown) ||
1217         IsEqualGUID(riid, &IID_IServiceProvider))
1218     {
1219         *ppvObject = iface;
1220         IServiceProvider_AddRef(iface);
1221         return S_OK;
1222     }
1223
1224     ok(0, "unexpected query interface: %s\n", debugstr_guid(riid));
1225
1226     return E_NOINTERFACE;
1227 }
1228
1229 static ULONG WINAPI sp_AddRef(IServiceProvider *iface)
1230 {
1231     return 2;
1232 }
1233
1234 static ULONG WINAPI sp_Release(IServiceProvider *iface)
1235 {
1236     return 1;
1237 }
1238
1239 static HRESULT WINAPI sp_QueryService(IServiceProvider *iface, REFGUID service, REFIID riid, void **obj)
1240 {
1241     *obj = NULL;
1242
1243     if (IsEqualGUID(service, &SID_SBindHost) &&
1244         IsEqualGUID(riid, &IID_IBindHost))
1245     {
1246         CHECK_EXPECT2(sp_queryservice_SID_SBindHost);
1247     }
1248     else if (IsEqualGUID(service, &SID_SContainerDispatch) &&
1249              IsEqualGUID(riid, &IID_IHTMLDocument2))
1250     {
1251         CHECK_EXPECT2(sp_queryservice_SID_SContainerDispatch_htmldoc2);
1252     }
1253     else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&
1254              IsEqualGUID(riid, &IID_IHTMLDocument2))
1255     {
1256         CHECK_EXPECT2(sp_queryservice_SID_secmgr_htmldoc2);
1257         *obj = &htmldoc2.IHTMLDocument2_iface;
1258         return S_OK;
1259     }
1260     else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&
1261              IsEqualGUID(riid, &IID_IXMLDOMDocument))
1262     {
1263         CHECK_EXPECT2(sp_queryservice_SID_secmgr_xmldomdoc);
1264     }
1265     else if (IsEqualGUID(service, &SID_SInternetHostSecurityManager) &&
1266              IsEqualGUID(riid, &IID_IInternetHostSecurityManager))
1267     {
1268         CHECK_EXPECT2(sp_queryservice_SID_secmgr_secmgr);
1269     }
1270     else if (IsEqualGUID(service, &SID_UnknownSID) &&
1271              IsEqualGUID(riid, &IID_IStream))
1272     {
1273         /* FIXME: unidentified service id */
1274     }
1275     else
1276         ok(0, "unexpected request: sid %s, riid %s\n", debugstr_guid(service), debugstr_guid(riid));
1277
1278     return E_NOTIMPL;
1279 }
1280
1281 static const IServiceProviderVtbl testprovVtbl =
1282 {
1283     sp_QueryInterface,
1284     sp_AddRef,
1285     sp_Release,
1286     sp_QueryService
1287 };
1288
1289 testprov_t testprov = { { &testprovVtbl } };
1290
1291 /* IStream */
1292 static HRESULT WINAPI istream_QueryInterface(IStream *iface, REFIID riid, void **ppvObject)
1293 {
1294     *ppvObject = NULL;
1295
1296     if (IsEqualGUID(riid, &IID_IStream) ||
1297         IsEqualGUID(riid, &IID_IUnknown))
1298         *ppvObject = iface;
1299     else
1300         return E_NOINTERFACE;
1301
1302     return S_OK;
1303 }
1304
1305 static ULONG WINAPI istream_AddRef(IStream *iface)
1306 {
1307     return 2;
1308 }
1309
1310 static ULONG WINAPI istream_Release(IStream *iface)
1311 {
1312     return 1;
1313 }
1314
1315 static HRESULT WINAPI istream_Read(IStream *iface, void *ptr, ULONG len, ULONG *pread)
1316 {
1317     ok(0, "unexpected call\n");
1318     return E_NOTIMPL;
1319 }
1320
1321 static HRESULT WINAPI istream_Write(IStream *iface, const void *ptr, ULONG len, ULONG *written)
1322 {
1323     *written = len/2;
1324     return S_OK;
1325 }
1326
1327 static HRESULT WINAPI istream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
1328 {
1329     ok(0, "unexpected call\n");
1330     return E_NOTIMPL;
1331 }
1332
1333 static HRESULT WINAPI istream_SetSize(IStream *iface, ULARGE_INTEGER size)
1334 {
1335     ok(0, "unexpected call\n");
1336     return E_NOTIMPL;
1337 }
1338
1339 static HRESULT WINAPI istream_CopyTo(IStream *iface, IStream *stream, ULARGE_INTEGER len,
1340         ULARGE_INTEGER *pread, ULARGE_INTEGER *written)
1341 {
1342     ok(0, "unexpected call\n");
1343     return E_NOTIMPL;
1344 }
1345
1346 static HRESULT WINAPI istream_Commit(IStream *iface, DWORD flags)
1347 {
1348     ok(0, "unexpected call\n");
1349     return E_NOTIMPL;
1350 }
1351
1352 static HRESULT WINAPI istream_Revert(IStream *iface)
1353 {
1354     ok(0, "unexpected call\n");
1355     return E_NOTIMPL;
1356 }
1357
1358 static HRESULT WINAPI istream_LockRegion(IStream *iface, ULARGE_INTEGER offset,
1359         ULARGE_INTEGER len, DWORD locktype)
1360 {
1361     ok(0, "unexpected call\n");
1362     return E_NOTIMPL;
1363 }
1364
1365 static HRESULT WINAPI istream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset,
1366         ULARGE_INTEGER len, DWORD locktype)
1367 {
1368     ok(0, "unexpected call\n");
1369     return E_NOTIMPL;
1370 }
1371
1372 static HRESULT WINAPI istream_Stat(IStream *iface, STATSTG *pstatstg, DWORD flag)
1373 {
1374     ok(0, "unexpected call\n");
1375     return E_NOTIMPL;
1376 }
1377
1378 static HRESULT WINAPI istream_Clone(IStream *iface, IStream **stream)
1379 {
1380     ok(0, "unexpected call\n");
1381     return E_NOTIMPL;
1382 }
1383
1384 static const IStreamVtbl StreamVtbl = {
1385     istream_QueryInterface,
1386     istream_AddRef,
1387     istream_Release,
1388     istream_Read,
1389     istream_Write,
1390     istream_Seek,
1391     istream_SetSize,
1392     istream_CopyTo,
1393     istream_Commit,
1394     istream_Revert,
1395     istream_LockRegion,
1396     istream_UnlockRegion,
1397     istream_Stat,
1398     istream_Clone
1399 };
1400
1401 static IStream savestream = { &StreamVtbl };
1402
1403 #define EXPECT_CHILDREN(node) _expect_children((IXMLDOMNode*)node, __LINE__)
1404 static void _expect_children(IXMLDOMNode *node, int line)
1405 {
1406     VARIANT_BOOL b;
1407     HRESULT hr;
1408
1409     b = VARIANT_FALSE;
1410     hr = IXMLDOMNode_hasChildNodes(node, &b);
1411     ok_(__FILE__,line)(hr == S_OK, "hasChildNodes() failed, 0x%08x\n", hr);
1412     ok_(__FILE__,line)(b == VARIANT_TRUE, "no children, %d\n", b);
1413 }
1414
1415 #define EXPECT_NO_CHILDREN(node) _expect_no_children((IXMLDOMNode*)node, __LINE__)
1416 static void _expect_no_children(IXMLDOMNode *node, int line)
1417 {
1418     VARIANT_BOOL b;
1419     HRESULT hr;
1420
1421     b = VARIANT_TRUE;
1422     hr = IXMLDOMNode_hasChildNodes(node, &b);
1423     ok_(__FILE__,line)(hr == S_FALSE, "hasChildNodes() failed, 0x%08x\n", hr);
1424     ok_(__FILE__,line)(b == VARIANT_FALSE, "no children, %d\n", b);
1425 }
1426
1427 #define EXPECT_REF(node,ref) _expect_ref((IUnknown*)node, ref, __LINE__)
1428 static void _expect_ref(IUnknown* obj, ULONG ref, int line)
1429 {
1430     ULONG rc = IUnknown_AddRef(obj);
1431     IUnknown_Release(obj);
1432     ok_(__FILE__,line)(rc-1 == ref, "expected refcount %d, got %d\n", ref, rc-1);
1433 }
1434
1435 #define EXPECT_LIST_LEN(list,len) _expect_list_len(list, len, __LINE__)
1436 static void _expect_list_len(IXMLDOMNodeList *list, LONG len, int line)
1437 {
1438     LONG length;
1439     HRESULT hr;
1440
1441     length = 0;
1442     hr = IXMLDOMNodeList_get_length(list, &length);
1443     ok_(__FILE__,line)(hr == S_OK, "got 0x%08x\n", hr);
1444     ok_(__FILE__,line)(length == len, "got %d, expected %d\n", length, len);
1445 }
1446
1447 #define EXPECT_HR(hr,hr_exp) \
1448     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
1449
1450 static const WCHAR szEmpty[] = { 0 };
1451 static const WCHAR szIncomplete[] = {
1452     '<','?','x','m','l',' ',
1453     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
1454 };
1455 static const WCHAR szComplete1[] = {
1456     '<','?','x','m','l',' ',
1457     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
1458     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
1459 };
1460 static const WCHAR szComplete2[] = {
1461     '<','?','x','m','l',' ',
1462     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
1463     '<','o','>','<','/','o','>','\n',0
1464 };
1465 static const WCHAR szComplete3[] = {
1466     '<','?','x','m','l',' ',
1467     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
1468     '<','a','>','<','/','a','>','\n',0
1469 };
1470 static const char complete4A[] =
1471     "<?xml version=\'1.0\'?>\n"
1472     "<lc dl=\'str1\'>\n"
1473         "<bs vr=\'str2\' sz=\'1234\'>"
1474             "fn1.txt\n"
1475         "</bs>\n"
1476         "<pr id=\'str3\' vr=\'1.2.3\' pn=\'wine 20050804\'>\n"
1477             "fn2.txt\n"
1478         "</pr>\n"
1479         "<empty></empty>\n"
1480         "<fo>\n"
1481             "<ba>\n"
1482                 "f1\n"
1483             "</ba>\n"
1484         "</fo>\n"
1485     "</lc>\n";
1486
1487 static const WCHAR szComplete5[] = {
1488     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
1489     'x','m','l','n','s',':','C','=','"','u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','o','f','f','i','c','e',':','c','l','i','p','g','a','l','l','e','r','y','"',
1490     ' ','x','m','l','n','s',':','S','=','"','u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','o','f','f','i','c','e',':','c','l','i','p','g','a','l','l','e','r','y',':','s','e','a','r','c','h','"','>',
1491         '<','S',':','s','c','o','p','e','>',
1492             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
1493         '<','/','S',':','s','c','o','p','e','>',
1494         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
1495             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
1496             'c','o','m','p','u','t','e','r',
1497         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
1498     '<','/','S',':','s','e','a','r','c','h','>',0
1499 };
1500
1501 static const WCHAR szComplete6[] = {
1502     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'',' ',
1503     'e','n','c','o','d','i','n','g','=','\'','W','i','n','d','o','w','s','-','1','2','5','2','\'','?','>','\n',
1504     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
1505 };
1506
1507 #define DECL_WIN_1252 \
1508 "<?xml version=\"1.0\" encoding=\"Windows-1252\"?>"
1509
1510 static const char win1252xml[] =
1511 DECL_WIN_1252
1512 "<open></open>";
1513
1514 static const char win1252decl[] =
1515 DECL_WIN_1252
1516 ;
1517
1518 static const char szExampleXML[] =
1519 "<?xml version='1.0' encoding='utf-8'?>\n"
1520 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' a=\"attr a\" foo:b=\"attr b\" >\n"
1521 "    <elem>\n"
1522 "        <a>A1 field</a>\n"
1523 "        <b>B1 field</b>\n"
1524 "        <c>C1 field</c>\n"
1525 "        <d>D1 field</d>\n"
1526 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
1527 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
1528 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
1529 "            </html>\n"
1530 "            <html xml:space='preserve' xmlns='http://www.w3.org/1999/xhtml'>\n"
1531 "                This is <strong>a</strong> <i>description</i> with preserved whitespace. <bar:x/>\n"
1532 "            </html>\n"
1533 "        </description>\n"
1534 "    </elem>\n"
1535 "\n"
1536 "    <elem>\n"
1537 "        <a>A2 field</a>\n"
1538 "        <b>B2 field</b>\n"
1539 "        <c type=\"old\">C2 field</c>\n"
1540 "        <d>D2 field</d>\n"
1541 "    </elem>\n"
1542 "\n"
1543 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
1544 "        <a>A3 field</a>\n"
1545 "        <b>B3 field</b>\n"
1546 "        <c>C3 field</c>\n"
1547 "    </elem>\n"
1548 "\n"
1549 "    <elem>\n"
1550 "        <a>A4 field</a>\n"
1551 "        <b>B4 field</b>\n"
1552 "        <foo:c>C4 field</foo:c>\n"
1553 "        <d>D4 field</d>\n"
1554 "    </elem>\n"
1555 "</root>\n";
1556
1557 static const CHAR szNodeTypesXML[] =
1558 "<?xml version='1.0'?>"
1559 "<!-- comment node 0 -->"
1560 "<root id='0' depth='0'>"
1561 "   <!-- comment node 1 -->"
1562 "   text node 0"
1563 "   <x id='1' depth='1'>"
1564 "       <?foo value='PI for x'?>"
1565 "       <!-- comment node 2 -->"
1566 "       text node 1"
1567 "       <a id='3' depth='2'/>"
1568 "       <b id='4' depth='2'/>"
1569 "       <c id='5' depth='2'/>"
1570 "   </x>"
1571 "   <y id='2' depth='1'>"
1572 "       <?bar value='PI for y'?>"
1573 "       <!-- comment node 3 -->"
1574 "       text node 2"
1575 "       <a id='6' depth='2'/>"
1576 "       <b id='7' depth='2'/>"
1577 "       <c id='8' depth='2'/>"
1578 "   </y>"
1579 "</root>";
1580
1581 static const CHAR szTransformXML[] =
1582 "<?xml version=\"1.0\"?>\n"
1583 "<greeting>\n"
1584 "Hello World\n"
1585 "</greeting>";
1586
1587 static  const CHAR szTransformSSXML[] =
1588 "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
1589 "   <xsl:output method=\"html\"/>\n"
1590 "   <xsl:template match=\"/\">\n"
1591 "       <xsl:apply-templates select=\"greeting\"/>\n"
1592 "   </xsl:template>\n"
1593 "   <xsl:template match=\"greeting\">\n"
1594 "       <html>\n"
1595 "           <body>\n"
1596 "               <h1>\n"
1597 "                   <xsl:value-of select=\".\"/>\n"
1598 "               </h1>\n"
1599 "           </body>\n"
1600 "       </html>\n"
1601 "   </xsl:template>\n"
1602 "</xsl:stylesheet>";
1603
1604 static  const CHAR szTransformOutput[] =
1605 "<html><body><h1>"
1606 "Hello World"
1607 "</h1></body></html>";
1608
1609 static const CHAR szTypeValueXML[] =
1610 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
1611 "<root xmlns:dt=\"urn:schemas-microsoft-com:datatypes\">\n"
1612 "   <string>Wine</string>\n"
1613 "   <string2 dt:dt=\"string\">String</string2>\n"
1614 "   <number dt:dt=\"number\">12.44</number>\n"
1615 "   <number2 dt:dt=\"NUMbEr\">-3.71e3</number2>\n"
1616 "   <int dt:dt=\"int\">-13</int>\n"
1617 "   <fixed dt:dt=\"fixed.14.4\">7322.9371</fixed>\n"
1618 "   <bool dt:dt=\"boolean\">1</bool>\n"
1619 "   <datetime dt:dt=\"datetime\">2009-11-18T03:21:33.12</datetime>\n"
1620 "   <datetimetz dt:dt=\"datetime.tz\">2003-07-11T11:13:57+03:00</datetimetz>\n"
1621 "   <date dt:dt=\"date\">3721-11-01</date>\n"
1622 "   <time dt:dt=\"time\">13:57:12.31321</time>\n"
1623 "   <timetz dt:dt=\"time.tz\">23:21:01.13+03:21</timetz>\n"
1624 "   <i1 dt:dt=\"i1\">-13</i1>\n"
1625 "   <i2 dt:dt=\"i2\">31915</i2>\n"
1626 "   <i4 dt:dt=\"i4\">-312232</i4>\n"
1627 "   <ui1 dt:dt=\"ui1\">123</ui1>\n"
1628 "   <ui2 dt:dt=\"ui2\">48282</ui2>\n"
1629 "   <ui4 dt:dt=\"ui4\">949281</ui4>\n"
1630 "   <r4 dt:dt=\"r4\">213124.0</r4>\n"
1631 "   <r8 dt:dt=\"r8\">0.412</r8>\n"
1632 "   <float dt:dt=\"float\">41221.421</float>\n"
1633 "   <uuid dt:dt=\"uuid\">333C7BC4-460F-11D0-BC04-0080C7055a83</uuid>\n"
1634 "   <binhex dt:dt=\"bin.hex\">fffca012003c</binhex>\n"
1635 "   <binbase64 dt:dt=\"bin.base64\">YmFzZTY0IHRlc3Q=</binbase64>\n"
1636 "   <binbase64_1 dt:dt=\"bin.base64\">\nYmFzZTY0\nIHRlc3Q=\n</binbase64_1>\n"
1637 "   <binbase64_2 dt:dt=\"bin.base64\">\nYmF\r\t z  ZTY0\nIHRlc3Q=\n</binbase64_2>\n"
1638 "</root>";
1639
1640 static const CHAR szBasicTransformSSXMLPart1[] =
1641 "<?xml version=\"1.0\"?>"
1642 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
1643 "<xsl:output method=\"html\"/>\n"
1644 "<xsl:template match=\"/\">"
1645 "<HTML><BODY><TABLE>"
1646 "        <xsl:apply-templates select='document(\"";
1647
1648 static const CHAR szBasicTransformSSXMLPart2[] =
1649 "\")/bottle/wine'>"
1650 "           <xsl:sort select=\"cost\"/><xsl:sort select=\"name\"/>"
1651 "        </xsl:apply-templates>"
1652 "</TABLE></BODY></HTML>"
1653 "</xsl:template>"
1654 "<xsl:template match=\"bottle\">"
1655 "   <TR><xsl:apply-templates select=\"name\" /><xsl:apply-templates select=\"cost\" /></TR>"
1656 "</xsl:template>"
1657 "<xsl:template match=\"name\">"
1658 "   <TD><xsl:apply-templates /></TD>"
1659 "</xsl:template>"
1660 "<xsl:template match=\"cost\">"
1661 "   <TD><xsl:apply-templates /></TD>"
1662 "</xsl:template>"
1663 "</xsl:stylesheet>";
1664
1665 static const CHAR szBasicTransformXML[] =
1666 "<?xml version=\"1.0\"?><bottle><wine><name>Wine</name><cost>$25.00</cost></wine></bottle>";
1667
1668 static const CHAR szBasicTransformOutput[] =
1669 "<HTML><BODY><TABLE><TD>Wine</TD><TD>$25.00</TD></TABLE></BODY></HTML>";
1670
1671 #define SZ_EMAIL_DTD \
1672 "<!DOCTYPE email ["\
1673 "   <!ELEMENT email         (recipients,from,reply-to?,subject,body,attachment*)>"\
1674 "       <!ATTLIST email attachments IDREFS #REQUIRED>"\
1675 "       <!ATTLIST email sent (yes|no) \"no\">"\
1676 "   <!ELEMENT recipients    (to+,cc*)>"\
1677 "   <!ELEMENT to            (#PCDATA)>"\
1678 "       <!ATTLIST to name CDATA #IMPLIED>"\
1679 "   <!ELEMENT cc            (#PCDATA)>"\
1680 "       <!ATTLIST cc name CDATA #IMPLIED>"\
1681 "   <!ELEMENT from          (#PCDATA)>"\
1682 "       <!ATTLIST from name CDATA #IMPLIED>"\
1683 "   <!ELEMENT reply-to      (#PCDATA)>"\
1684 "       <!ATTLIST reply-to name CDATA #IMPLIED>"\
1685 "   <!ELEMENT subject       ANY>"\
1686 "   <!ELEMENT body          ANY>"\
1687 "       <!ATTLIST body enc CDATA #FIXED \"UTF-8\">"\
1688 "   <!ELEMENT attachment    (#PCDATA)>"\
1689 "       <!ATTLIST attachment id ID #REQUIRED>"\
1690 "]>"
1691
1692 static const CHAR szEmailXML[] =
1693 "<?xml version=\"1.0\"?>"
1694 SZ_EMAIL_DTD
1695 "<email attachments=\"patch1\">"
1696 "   <recipients>"
1697 "       <to>wine-patches@winehq.org</to>"
1698 "   </recipients>"
1699 "   <from name=\"Anonymous\">user@localhost</from>"
1700 "   <subject>msxml3/tests: DTD validation (try 87)</subject>"
1701 "   <body>"
1702 "       It no longer causes spontaneous combustion..."
1703 "   </body>"
1704 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1705 "</email>";
1706
1707 static const CHAR szEmailXML_0D[] =
1708 "<?xml version=\"1.0\"?>"
1709 SZ_EMAIL_DTD
1710 "<email attachments=\"patch1\">"
1711 "   <recipients>"
1712 "       <to>wine-patches@winehq.org</to>"
1713 "   </recipients>"
1714 "   <from name=\"Anonymous\">user@localhost</from>"
1715 "   <subject>msxml3/tests: DTD validation (try 88)</subject>"
1716 "   <body>"
1717 "       <undecl />"
1718 "       XML_ELEMENT_UNDECLARED 0xC00CE00D"
1719 "   </body>"
1720 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1721 "</email>";
1722
1723 static const CHAR szEmailXML_0E[] =
1724 "<?xml version=\"1.0\"?>"
1725 SZ_EMAIL_DTD
1726 "<email attachments=\"patch1\">"
1727 "   <recipients>"
1728 "       <to>wine-patches@winehq.org</to>"
1729 "   </recipients>"
1730 "   <from name=\"Anonymous\">user@localhost</from>"
1731 "   <subject>msxml3/tests: DTD validation (try 89)</subject>"
1732 "   <body>"
1733 "       XML_ELEMENT_ID_NOT_FOUND 0xC00CE00E"
1734 "   </body>"
1735 "   <attachment id=\"patch\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1736 "</email>";
1737
1738 static const CHAR szEmailXML_11[] =
1739 "<?xml version=\"1.0\"?>"
1740 SZ_EMAIL_DTD
1741 "<email attachments=\"patch1\">"
1742 "   <recipients>"
1743 "   </recipients>"
1744 "   <from name=\"Anonymous\">user@localhost</from>"
1745 "   <subject>msxml3/tests: DTD validation (try 90)</subject>"
1746 "   <body>"
1747 "       XML_EMPTY_NOT_ALLOWED 0xC00CE011"
1748 "   </body>"
1749 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1750 "</email>";
1751
1752 static const CHAR szEmailXML_13[] =
1753 "<?xml version=\"1.0\"?>"
1754 SZ_EMAIL_DTD
1755 "<msg attachments=\"patch1\">"
1756 "   <recipients>"
1757 "       <to>wine-patches@winehq.org</to>"
1758 "   </recipients>"
1759 "   <from name=\"Anonymous\">user@localhost</from>"
1760 "   <subject>msxml3/tests: DTD validation (try 91)</subject>"
1761 "   <body>"
1762 "       XML_ROOT_NAME_MISMATCH 0xC00CE013"
1763 "   </body>"
1764 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1765 "</msg>";
1766
1767 static const CHAR szEmailXML_14[] =
1768 "<?xml version=\"1.0\"?>"
1769 SZ_EMAIL_DTD
1770 "<email attachments=\"patch1\">"
1771 "   <to>wine-patches@winehq.org</to>"
1772 "   <from name=\"Anonymous\">user@localhost</from>"
1773 "   <subject>msxml3/tests: DTD validation (try 92)</subject>"
1774 "   <body>"
1775 "       XML_INVALID_CONTENT 0xC00CE014"
1776 "   </body>"
1777 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1778 "</email>";
1779
1780 static const CHAR szEmailXML_15[] =
1781 "<?xml version=\"1.0\"?>"
1782 SZ_EMAIL_DTD
1783 "<email attachments=\"patch1\" ip=\"127.0.0.1\">"
1784 "   <recipients>"
1785 "       <to>wine-patches@winehq.org</to>"
1786 "   </recipients>"
1787 "   <from name=\"Anonymous\">user@localhost</from>"
1788 "   <subject>msxml3/tests: DTD validation (try 93)</subject>"
1789 "   <body>"
1790 "       XML_ATTRIBUTE_NOT_DEFINED 0xC00CE015"
1791 "   </body>"
1792 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1793 "</email>";
1794
1795 static const CHAR szEmailXML_16[] =
1796 "<?xml version=\"1.0\"?>"
1797 SZ_EMAIL_DTD
1798 "<email attachments=\"patch1\">"
1799 "   <recipients>"
1800 "       <to>wine-patches@winehq.org</to>"
1801 "   </recipients>"
1802 "   <from name=\"Anonymous\">user@localhost</from>"
1803 "   <subject>msxml3/tests: DTD validation (try 94)</subject>"
1804 "   <body enc=\"ASCII\">"
1805 "       XML_ATTRIBUTE_FIXED 0xC00CE016"
1806 "   </body>"
1807 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1808 "</email>";
1809
1810 static const CHAR szEmailXML_17[] =
1811 "<?xml version=\"1.0\"?>"
1812 SZ_EMAIL_DTD
1813 "<email attachments=\"patch1\" sent=\"true\">"
1814 "   <recipients>"
1815 "       <to>wine-patches@winehq.org</to>"
1816 "   </recipients>"
1817 "   <from name=\"Anonymous\">user@localhost</from>"
1818 "   <subject>msxml3/tests: DTD validation (try 95)</subject>"
1819 "   <body>"
1820 "       XML_ATTRIBUTE_VALUE 0xC00CE017"
1821 "   </body>"
1822 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1823 "</email>";
1824
1825 static const CHAR szEmailXML_18[] =
1826 "<?xml version=\"1.0\"?>"
1827 SZ_EMAIL_DTD
1828 "<email attachments=\"patch1\">"
1829 "   oops"
1830 "   <recipients>"
1831 "       <to>wine-patches@winehq.org</to>"
1832 "   </recipients>"
1833 "   <from name=\"Anonymous\">user@localhost</from>"
1834 "   <subject>msxml3/tests: DTD validation (try 96)</subject>"
1835 "   <body>"
1836 "       XML_ILLEGAL_TEXT 0xC00CE018"
1837 "   </body>"
1838 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1839 "</email>";
1840
1841 static const CHAR szEmailXML_20[] =
1842 "<?xml version=\"1.0\"?>"
1843 SZ_EMAIL_DTD
1844 "<email>"
1845 "   <recipients>"
1846 "       <to>wine-patches@winehq.org</to>"
1847 "   </recipients>"
1848 "   <from name=\"Anonymous\">user@localhost</from>"
1849 "   <subject>msxml3/tests: DTD validation (try 97)</subject>"
1850 "   <body>"
1851 "       XML_REQUIRED_ATTRIBUTE_MISSING 0xC00CE020"
1852 "   </body>"
1853 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
1854 "</email>";
1855
1856 static const char xpath_simple_list[] =
1857 "<?xml version=\"1.0\"?>"
1858 "<root>"
1859 "   <a attr1=\"1\" attr2=\"2\" />"
1860 "   <b/>"
1861 "   <c/>"
1862 "   <d/>"
1863 "</root>";
1864
1865 static const char default_ns_doc[] = {
1866     "<?xml version=\"1.0\"?>"
1867     "<a xmlns:ns=\"nshref\" xml:lang=\"ru\" ns:b=\"b attr\" xml:c=\"c attr\" "
1868     "    d=\"d attr\" />"
1869 };
1870
1871 static const char attributes_map[] = {
1872     "<?xml version=\"1.0\"?>"
1873     "<a attr1=\"value1\" attr2=\"value2\" attr3=\"value3\" attr4=\"value4\" />"
1874 };
1875
1876 static const WCHAR nonexistent_fileW[] = {
1877     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
1878 };
1879 static const WCHAR nonexistent_attrW[] = {
1880     'n','o','n','E','x','i','s','i','t','i','n','g','A','t','t','r','i','b','u','t','e',0
1881 };
1882 static const WCHAR szDocument[] = {
1883     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
1884 };
1885
1886 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
1887 static WCHAR szdl[] = { 'd','l',0 };
1888 static const WCHAR szvr[] = { 'v','r',0 };
1889 static const WCHAR szlc[] = { 'l','c',0 };
1890 static WCHAR szbs[] = { 'b','s',0 };
1891 static const WCHAR szstr1[] = { 's','t','r','1',0 };
1892 static const WCHAR szstr2[] = { 's','t','r','2',0 };
1893 static const WCHAR szstar[] = { '*',0 };
1894 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
1895
1896 static WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
1897 static WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
1898 static WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
1899
1900 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
1901 static WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
1902 static WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
1903 static WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
1904                                 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
1905 static WCHAR szElementXML4[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
1906                                 '&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 };
1907
1908 static WCHAR szAttribute[] = {'A','t','t','r',0 };
1909 static WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
1910
1911 static WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
1912                           ' ','n','o','t',' ','r','i','g','h','t','!', 0};
1913 static WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
1914                              'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
1915                              '!',']',']','>',0};
1916 static WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
1917 static WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
1918
1919 static WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
1920 static WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
1921 static WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0};
1922
1923 #define expect_bstr_eq_and_free(bstr, expect) { \
1924     BSTR bstrExp = alloc_str_from_narrow(expect); \
1925     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
1926     SysFreeString(bstr); \
1927     SysFreeString(bstrExp); \
1928 }
1929
1930 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
1931
1932 #define ole_check(expr) { \
1933     HRESULT r = expr; \
1934     ok(r == S_OK, #expr " returned %x\n", r); \
1935 }
1936
1937 #define ole_expect(expr, expect) { \
1938     HRESULT r = expr; \
1939     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
1940 }
1941
1942 #define double_eq(x, y) ok((x)-(y)<=1e-14*(x) && (x)-(y)>=-1e-14*(x), "expected %.16g, got %.16g\n", x, y)
1943
1944 static void* _create_object(const GUID *clsid, const char *name, const IID *iid, int line)
1945 {
1946     void *obj = NULL;
1947     HRESULT hr;
1948
1949     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
1950     if (hr != S_OK)
1951         win_skip_(__FILE__,line)("failed to create %s instance: 0x%08x\n", name, hr);
1952
1953     return obj;
1954 }
1955
1956 #define _create(cls) cls, #cls
1957
1958 #define create_document(iid) _create_object(&_create(CLSID_DOMDocument2), iid, __LINE__)
1959 #define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
1960 #define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
1961 #define create_cache_version(v, iid) _create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)
1962 #define create_xsltemplate(iid) _create_object(&_create(CLSID_XSLTemplate), iid, __LINE__)
1963
1964 static BSTR alloc_str_from_narrow(const char *str)
1965 {
1966     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
1967     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
1968     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
1969     return ret;
1970 }
1971
1972 static BSTR alloced_bstrs[256];
1973 static int alloced_bstrs_count;
1974
1975 static BSTR _bstr_(const char *str)
1976 {
1977     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
1978     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
1979     return alloced_bstrs[alloced_bstrs_count++];
1980 }
1981
1982 static void free_bstrs(void)
1983 {
1984     int i;
1985     for (i = 0; i < alloced_bstrs_count; i++)
1986         SysFreeString(alloced_bstrs[i]);
1987     alloced_bstrs_count = 0;
1988 }
1989
1990 static VARIANT _variantbstr_(const char *str)
1991 {
1992     VARIANT v;
1993     V_VT(&v) = VT_BSTR;
1994     V_BSTR(&v) = _bstr_(str);
1995     return v;
1996 }
1997
1998 static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
1999 {
2000     for (;;)
2001     {
2002         while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
2003         while (*sRight == '\r' || *sRight == '\n') sRight++;
2004         if (*sLeft != *sRight) return FALSE;
2005         if (!*sLeft) return TRUE;
2006         sLeft++;
2007         sRight++;
2008     }
2009 }
2010
2011 static void get_str_for_type(DOMNodeType type, char *buf)
2012 {
2013     switch (type)
2014     {
2015         case NODE_ATTRIBUTE:
2016             strcpy(buf, "A");
2017             break;
2018         case NODE_ELEMENT:
2019             strcpy(buf, "E");
2020             break;
2021         case NODE_DOCUMENT:
2022             strcpy(buf, "D");
2023             break;
2024         case NODE_TEXT:
2025             strcpy(buf, "T");
2026             break;
2027         case NODE_COMMENT:
2028             strcpy(buf, "C");
2029             break;
2030         case NODE_PROCESSING_INSTRUCTION:
2031             strcpy(buf, "P");
2032             break;
2033         default:
2034             wsprintfA(buf, "[%d]", type);
2035     }
2036 }
2037
2038 static int get_node_position(IXMLDOMNode *node)
2039 {
2040     HRESULT r;
2041     int pos = 0;
2042
2043     IXMLDOMNode_AddRef(node);
2044     do
2045     {
2046         IXMLDOMNode *new_node;
2047
2048         pos++;
2049         r = IXMLDOMNode_get_previousSibling(node, &new_node);
2050         ok(SUCCEEDED(r), "get_previousSibling failed\n");
2051         IXMLDOMNode_Release(node);
2052         node = new_node;
2053     } while (r == S_OK);
2054     return pos;
2055 }
2056
2057 static void node_to_string(IXMLDOMNode *node, char *buf)
2058 {
2059     HRESULT r = S_OK;
2060     DOMNodeType type;
2061
2062     if (node == NULL)
2063     {
2064         lstrcpyA(buf, "(null)");
2065         return;
2066     }
2067
2068     IXMLDOMNode_AddRef(node);
2069     while (r == S_OK)
2070     {
2071         IXMLDOMNode *new_node;
2072
2073         ole_check(IXMLDOMNode_get_nodeType(node, &type));
2074         get_str_for_type(type, buf);
2075         buf+=strlen(buf);
2076
2077         if (type == NODE_ATTRIBUTE)
2078         {
2079             BSTR bstr;
2080             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
2081             *(buf++) = '\'';
2082             wsprintfA(buf, "%ws", bstr);
2083             buf += strlen(buf);
2084             *(buf++) = '\'';
2085             SysFreeString(bstr);
2086
2087             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
2088         }
2089         else
2090         {
2091             r = IXMLDOMNode_get_parentNode(node, &new_node);
2092             wsprintf(buf, "%d", get_node_position(node));
2093             buf += strlen(buf);
2094         }
2095
2096         ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
2097         IXMLDOMNode_Release(node);
2098         node = new_node;
2099         if (r == S_OK)
2100             *(buf++) = '.';
2101     }
2102
2103     *buf = 0;
2104 }
2105
2106 static char *list_to_string(IXMLDOMNodeList *list)
2107 {
2108     static char buf[4096];
2109     char *pos = buf;
2110     LONG len = 0;
2111     int i;
2112
2113     if (list == NULL)
2114     {
2115         lstrcpyA(buf, "(null)");
2116         return buf;
2117     }
2118     ole_check(IXMLDOMNodeList_get_length(list, &len));
2119     for (i = 0; i < len; i++)
2120     {
2121         IXMLDOMNode *node;
2122         if (i > 0)
2123             *(pos++) = ' ';
2124         ole_check(IXMLDOMNodeList_nextNode(list, &node));
2125         node_to_string(node, pos);
2126         pos += strlen(pos);
2127         IXMLDOMNode_Release(node);
2128     }
2129     *pos = 0;
2130     return buf;
2131 }
2132
2133 #define expect_node(node, expstr) { char str[4096]; node_to_string(node, str); ok(strcmp(str, expstr)==0, "Invalid node: %s, expected %s\n", str, expstr); }
2134 #define expect_list_and_release(list, expstr) { char *str = list_to_string(list); ok(strcmp(str, expstr)==0, "Invalid node list: %s, expected %s\n", str, expstr); if (list) IXMLDOMNodeList_Release(list); }
2135
2136 struct docload_ret_t {
2137     VARIANT_BOOL b;
2138     HRESULT hr;
2139 };
2140
2141 struct leading_spaces_t {
2142     const CLSID *clsid;
2143     const char *name;
2144     struct docload_ret_t ret[2]; /* 0 - ::load(), 1 - ::loadXML() */
2145 };
2146
2147 static const struct leading_spaces_t leading_spaces_classdata[] = {
2148     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
2149     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
2150     { &CLSID_DOMDocument26, "CLSID_DOMDocument26", {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
2151     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
2152     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
2153     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
2154     { NULL }
2155 };
2156
2157 static const char* leading_spaces_xmldata[] = {
2158     "\n<?xml version=\"1.0\" encoding=\"UTF-16\" ?><root/>",
2159     " <?xml version=\"1.0\"?><root/>",
2160     "\n<?xml version=\"1.0\"?><root/>",
2161     "\t<?xml version=\"1.0\"?><root/>",
2162     "\r\n<?xml version=\"1.0\"?><root/>",
2163     "\r<?xml version=\"1.0\"?><root/>",
2164     "\r\r\r\r\t\t \n\n <?xml version=\"1.0\"?><root/>",
2165     0
2166 };
2167
2168 static void test_domdoc( void )
2169 {
2170     HRESULT r, hr;
2171     IXMLDOMDocument *doc;
2172     IXMLDOMParseError *error;
2173     IXMLDOMElement *element = NULL;
2174     IXMLDOMNode *node;
2175     IXMLDOMText *nodetext = NULL;
2176     IXMLDOMComment *node_comment = NULL;
2177     IXMLDOMAttribute *node_attr = NULL;
2178     IXMLDOMNode *nodeChild = NULL;
2179     IXMLDOMProcessingInstruction *nodePI = NULL;
2180     const struct leading_spaces_t *class_ptr;
2181     const char **data_ptr;
2182     VARIANT_BOOL b;
2183     VARIANT var;
2184     BSTR str;
2185     LONG code, ref;
2186     LONG nLength = 0;
2187     WCHAR buff[100];
2188     char path[MAX_PATH];
2189     int index;
2190
2191     GetTempPathA(MAX_PATH, path);
2192     strcat(path, "leading_spaces.xml");
2193
2194     /* Load document with leading spaces
2195      *
2196      * Test all CLSIDs with all test data XML strings
2197      */
2198     class_ptr = leading_spaces_classdata;
2199     index = 0;
2200     while (class_ptr->clsid)
2201     {
2202         HRESULT hr;
2203         int i;
2204
2205         hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
2206              &IID_IXMLDOMDocument, (void**)&doc);
2207         if (hr != S_OK) {
2208             win_skip("%d: failed to create class instance for %s\n", index, class_ptr->name);
2209             class_ptr++;
2210             index++;
2211             continue;
2212         }
2213
2214         data_ptr = leading_spaces_xmldata;
2215         i = 0;
2216         while (*data_ptr) {
2217             BSTR data = _bstr_(*data_ptr);
2218             DWORD written;
2219             HANDLE file;
2220
2221             file = CreateFileA(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
2222             ok(file != INVALID_HANDLE_VALUE, "can't create file %s: %u\n", path, GetLastError());
2223
2224             WriteFile(file, data, lstrlenW(data)*sizeof(WCHAR), &written, NULL);
2225             CloseHandle(file);
2226
2227             b = 0xc;
2228             V_VT(&var) = VT_BSTR;
2229             V_BSTR(&var) = _bstr_(path);
2230             hr = IXMLDOMDocument_load(doc, var, &b);
2231         todo_wine {
2232             EXPECT_HR(hr, class_ptr->ret[0].hr);
2233             ok(b == class_ptr->ret[0].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[0].b);
2234         }
2235             DeleteFileA(path);
2236
2237             b = 0xc;
2238             hr = IXMLDOMDocument_loadXML(doc, data, &b);
2239             EXPECT_HR(hr, class_ptr->ret[1].hr);
2240             ok(b == class_ptr->ret[1].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[1].b);
2241
2242             data_ptr++;
2243             i++;
2244         }
2245
2246         class_ptr++;
2247         index++;
2248         free_bstrs();
2249     }
2250
2251     doc = create_document(&IID_IXMLDOMDocument);
2252     if (!doc) return;
2253
2254 if (0)
2255 {
2256     /* crashes on native */
2257     IXMLDOMDocument_loadXML( doc, (BSTR)0x1, NULL );
2258 }
2259
2260     /* try some stupid things */
2261     hr = IXMLDOMDocument_loadXML( doc, NULL, NULL );
2262     EXPECT_HR(hr, S_FALSE);
2263
2264     b = VARIANT_TRUE;
2265     hr = IXMLDOMDocument_loadXML( doc, NULL, &b );
2266     EXPECT_HR(hr, S_FALSE);
2267     ok( b == VARIANT_FALSE, "failed to load XML string\n");
2268
2269     /* try to load a document from a nonexistent file */
2270     b = VARIANT_TRUE;
2271     str = SysAllocString( nonexistent_fileW );
2272     VariantInit(&var);
2273     V_VT(&var) = VT_BSTR;
2274     V_BSTR(&var) = str;
2275
2276     r = IXMLDOMDocument_load( doc, var, &b);
2277     ok( r == S_FALSE, "loadXML succeeded\n");
2278     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2279     SysFreeString( str );
2280
2281     /* try load an empty document */
2282     b = VARIANT_TRUE;
2283     str = SysAllocString( szEmpty );
2284     r = IXMLDOMDocument_loadXML( doc, str, &b );
2285     ok( r == S_FALSE, "loadXML succeeded\n");
2286     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2287     SysFreeString( str );
2288
2289     r = IXMLDOMDocument_get_async( doc, &b );
2290     ok( r == S_OK, "get_async failed (%08x)\n", r);
2291     ok( b == VARIANT_TRUE, "Wrong default value\n");
2292
2293     /* check that there's no document element */
2294     element = NULL;
2295     r = IXMLDOMDocument_get_documentElement( doc, &element );
2296     ok( r == S_FALSE, "should be no document element\n");
2297
2298     /* try finding a node */
2299     node = NULL;
2300     str = SysAllocString( szstr1 );
2301     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
2302     ok( r == S_FALSE, "ret %08x\n", r );
2303     SysFreeString( str );
2304
2305     b = VARIANT_TRUE;
2306     str = SysAllocString( szIncomplete );
2307     r = IXMLDOMDocument_loadXML( doc, str, &b );
2308     ok( r == S_FALSE, "loadXML succeeded\n");
2309     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2310     SysFreeString( str );
2311
2312     /* check that there's no document element */
2313     element = (IXMLDOMElement*)1;
2314     r = IXMLDOMDocument_get_documentElement( doc, &element );
2315     ok( r == S_FALSE, "should be no document element\n");
2316     ok( element == NULL, "Element should be NULL\n");
2317
2318     /* test for BSTR handling, pass broken BSTR */
2319     memcpy(&buff[2], szComplete1, sizeof(szComplete1));
2320     /* just a big length */
2321     *(DWORD*)buff = 0xf0f0;
2322     b = VARIANT_FALSE;
2323     r = IXMLDOMDocument_loadXML( doc, &buff[2], &b );
2324     ok( r == S_OK, "loadXML failed\n");
2325     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2326
2327     /* loadXML ignores the encoding attribute and always expects Unicode */
2328     b = VARIANT_FALSE;
2329     str = SysAllocString( szComplete6 );
2330     r = IXMLDOMDocument_loadXML( doc, str, &b );
2331     ok( r == S_OK, "loadXML failed\n");
2332     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2333     SysFreeString( str );
2334
2335     /* try a BSTR containing a Windows-1252 document */
2336     b = VARIANT_TRUE;
2337     str = SysAllocStringByteLen( win1252xml, strlen(win1252xml) );
2338     r = IXMLDOMDocument_loadXML( doc, str, &b );
2339     ok( r == S_FALSE, "loadXML succeeded\n");
2340     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
2341     SysFreeString( str );
2342
2343     /* try to load something valid */
2344     b = VARIANT_FALSE;
2345     str = SysAllocString( szComplete1 );
2346     r = IXMLDOMDocument_loadXML( doc, str, &b );
2347     ok( r == S_OK, "loadXML failed\n");
2348     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2349     SysFreeString( str );
2350
2351     /* check if nodename is correct */
2352     r = IXMLDOMDocument_get_nodeName( doc, NULL );
2353     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2354
2355     str = (BSTR)0xdeadbeef;
2356     r = IXMLDOMDocument_get_baseName( doc, &str );
2357     ok ( r == S_FALSE, "got 0x%08x\n", r);
2358     ok (str == NULL, "got %p\n", str);
2359
2360     /* content doesn't matter here */
2361     str = NULL;
2362     r = IXMLDOMDocument_get_nodeName( doc, &str );
2363     ok ( r == S_OK, "get_nodeName wrong code\n");
2364     ok ( str != NULL, "str is null\n");
2365     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
2366     SysFreeString( str );
2367
2368     /* test put_text */
2369     r = IXMLDOMDocument_put_text( doc, _bstr_("Should Fail") );
2370     ok( r == E_FAIL, "ret %08x\n", r );
2371
2372     /* check that there's a document element */
2373     element = NULL;
2374     r = IXMLDOMDocument_get_documentElement( doc, &element );
2375     ok( r == S_OK, "should be a document element\n");
2376     if( element )
2377     {
2378         IObjectIdentity *ident;
2379
2380         r = IXMLDOMElement_QueryInterface( element, &IID_IObjectIdentity, (void**)&ident );
2381         ok( r == E_NOINTERFACE, "ret %08x\n", r);
2382
2383         IXMLDOMElement_Release( element );
2384         element = NULL;
2385     }
2386
2387     /* as soon as we call loadXML again, the document element will disappear */
2388     b = 2;
2389     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
2390     ok( r == S_FALSE, "loadXML failed\n");
2391     ok( b == 2, "variant modified\n");
2392     r = IXMLDOMDocument_get_documentElement( doc, &element );
2393     ok( r == S_FALSE, "should be no document element\n");
2394
2395     /* try to load something else simple and valid */
2396     b = VARIANT_FALSE;
2397     str = SysAllocString( szComplete3 );
2398     r = IXMLDOMDocument_loadXML( doc, str, &b );
2399     ok( r == S_OK, "loadXML failed\n");
2400     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2401     SysFreeString( str );
2402
2403     /* try something a little more complicated */
2404     b = FALSE;
2405     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2406     ok( r == S_OK, "loadXML failed\n");
2407     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2408
2409     r = IXMLDOMDocument_get_parseError( doc, &error );
2410     ok( r == S_OK, "returns %08x\n", r );
2411
2412     r = IXMLDOMParseError_get_errorCode( error, &code );
2413     ok( r == S_FALSE, "returns %08x\n", r );
2414     ok( code == 0, "code %d\n", code );
2415     IXMLDOMParseError_Release( error );
2416
2417     /* test createTextNode */
2418     r = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &nodetext);
2419     ok( r == S_OK, "returns %08x\n", r );
2420     IXMLDOMText_Release(nodetext);
2421
2422     str = SysAllocString( szOpen );
2423     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
2424     ok( r == E_INVALIDARG, "returns %08x\n", r );
2425     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
2426     ok( r == S_OK, "returns %08x\n", r );
2427     SysFreeString( str );
2428     if(nodetext)
2429     {
2430         r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (void**)&element);
2431         ok(r == E_NOINTERFACE, "ret %08x\n", r );
2432
2433         /* Text Last Child Checks */
2434         r = IXMLDOMText_get_lastChild(nodetext, NULL);
2435         ok(r == E_INVALIDARG, "ret %08x\n", r );
2436
2437         nodeChild = (IXMLDOMNode*)0x1;
2438         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
2439         ok(r == S_FALSE, "ret %08x\n", r );
2440         ok(nodeChild == NULL, "nodeChild not NULL\n");
2441
2442         /* test length property */
2443         r = IXMLDOMText_get_length(nodetext, NULL);
2444         ok(r == E_INVALIDARG, "ret %08x\n", r );
2445
2446         r = IXMLDOMText_get_length(nodetext, &nLength);
2447         ok(r == S_OK, "ret %08x\n", r );
2448         ok(nLength == 4, "expected 4 got %d\n", nLength);
2449
2450         /* put data Tests */
2451         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
2452         ok(r == S_OK, "ret %08x\n", r );
2453
2454         /* get data Tests */
2455         r = IXMLDOMText_get_data(nodetext, &str);
2456         ok(r == S_OK, "ret %08x\n", r );
2457         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
2458         SysFreeString(str);
2459
2460         /* Confirm XML text is good */
2461         r = IXMLDOMText_get_xml(nodetext, &str);
2462         ok(r == S_OK, "ret %08x\n", r );
2463         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
2464         SysFreeString(str);
2465
2466         /* Confirm we get the put_data Text back */
2467         r = IXMLDOMText_get_text(nodetext, &str);
2468         ok(r == S_OK, "ret %08x\n", r );
2469         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
2470         SysFreeString(str);
2471
2472         /* test substringData */
2473         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
2474         ok(r == E_INVALIDARG, "ret %08x\n", r );
2475
2476         /* test substringData - Invalid offset */
2477         str = (BSTR)&szElement;
2478         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
2479         ok(r == E_INVALIDARG, "ret %08x\n", r );
2480         ok( str == NULL, "incorrect string\n");
2481
2482         /* test substringData - Invalid offset */
2483         str = (BSTR)&szElement;
2484         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
2485         ok(r == S_FALSE, "ret %08x\n", r );
2486         ok( str == NULL, "incorrect string\n");
2487
2488         /* test substringData - Invalid size */
2489         str = (BSTR)&szElement;
2490         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
2491         ok(r == E_INVALIDARG, "ret %08x\n", r );
2492         ok( str == NULL, "incorrect string\n");
2493
2494         /* test substringData - Invalid size */
2495         str = (BSTR)&szElement;
2496         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
2497         ok(r == S_FALSE, "ret %08x\n", r );
2498         ok( str == NULL, "incorrect string\n");
2499
2500         /* test substringData - Start of string */
2501         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
2502         ok(r == S_OK, "ret %08x\n", r );
2503         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
2504         SysFreeString(str);
2505
2506         /* test substringData - Middle of string */
2507         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
2508         ok(r == S_OK, "ret %08x\n", r );
2509         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
2510         SysFreeString(str);
2511
2512         /* test substringData - End of string */
2513         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
2514         ok(r == S_OK, "ret %08x\n", r );
2515         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
2516         SysFreeString(str);
2517
2518         /* test appendData */
2519         r = IXMLDOMText_appendData(nodetext, NULL);
2520         ok(r == S_OK, "ret %08x\n", r );
2521
2522         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
2523         ok(r == S_OK, "ret %08x\n", r );
2524
2525         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
2526         ok(r == S_OK, "ret %08x\n", r );
2527
2528         r = IXMLDOMText_get_text(nodetext, &str);
2529         ok(r == S_OK, "ret %08x\n", r );
2530         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2531         SysFreeString(str);
2532
2533         /* test insertData */
2534         str = SysAllocStringLen(NULL, 0);
2535         r = IXMLDOMText_insertData(nodetext, -1, str);
2536         ok(r == S_OK, "ret %08x\n", r );
2537
2538         r = IXMLDOMText_insertData(nodetext, -1, NULL);
2539         ok(r == S_OK, "ret %08x\n", r );
2540
2541         r = IXMLDOMText_insertData(nodetext, 1000, str);
2542         ok(r == S_OK, "ret %08x\n", r );
2543
2544         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
2545         ok(r == S_OK, "ret %08x\n", r );
2546
2547         r = IXMLDOMText_insertData(nodetext, 0, NULL);
2548         ok(r == S_OK, "ret %08x\n", r );
2549
2550         r = IXMLDOMText_insertData(nodetext, 0, str);
2551         ok(r == S_OK, "ret %08x\n", r );
2552         SysFreeString(str);
2553
2554         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
2555         ok(r == E_INVALIDARG, "ret %08x\n", r );
2556
2557         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
2558         ok(r == E_INVALIDARG, "ret %08x\n", r );
2559
2560         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
2561         ok(r == S_OK, "ret %08x\n", r );
2562
2563         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
2564         ok(r == S_OK, "ret %08x\n", r );
2565
2566         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
2567         ok(r == S_OK, "ret %08x\n", r );
2568
2569         r = IXMLDOMText_get_text(nodetext, &str);
2570         ok(r == S_OK, "ret %08x\n", r );
2571         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2572         SysFreeString(str);
2573
2574         /* delete data */
2575         /* invalid arguments */
2576         r = IXMLDOMText_deleteData(nodetext, -1, 1);
2577         ok(r == E_INVALIDARG, "ret %08x\n", r );
2578
2579         r = IXMLDOMText_deleteData(nodetext, 0, 0);
2580         ok(r == S_OK, "ret %08x\n", r );
2581
2582         r = IXMLDOMText_deleteData(nodetext, 0, -1);
2583         ok(r == E_INVALIDARG, "ret %08x\n", r );
2584
2585         r = IXMLDOMText_get_length(nodetext, &nLength);
2586         ok(r == S_OK, "ret %08x\n", r );
2587         ok(nLength == 43, "expected 43 got %d\n", nLength);
2588
2589         r = IXMLDOMText_deleteData(nodetext, nLength, 1);
2590         ok(r == S_OK, "ret %08x\n", r );
2591
2592         r = IXMLDOMText_deleteData(nodetext, nLength+1, 1);
2593         ok(r == E_INVALIDARG, "ret %08x\n", r );
2594
2595         /* delete from start */
2596         r = IXMLDOMText_deleteData(nodetext, 0, 5);
2597         ok(r == S_OK, "ret %08x\n", r );
2598
2599         r = IXMLDOMText_get_length(nodetext, &nLength);
2600         ok(r == S_OK, "ret %08x\n", r );
2601         ok(nLength == 38, "expected 38 got %d\n", nLength);
2602
2603         r = IXMLDOMText_get_text(nodetext, &str);
2604         ok(r == S_OK, "ret %08x\n", r );
2605         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2606         SysFreeString(str);
2607
2608         /* delete from end */
2609         r = IXMLDOMText_deleteData(nodetext, 35, 3);
2610         ok(r == S_OK, "ret %08x\n", r );
2611
2612         r = IXMLDOMText_get_length(nodetext, &nLength);
2613         ok(r == S_OK, "ret %08x\n", r );
2614         ok(nLength == 35, "expected 35 got %d\n", nLength);
2615
2616         r = IXMLDOMText_get_text(nodetext, &str);
2617         ok(r == S_OK, "ret %08x\n", r );
2618         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2619         SysFreeString(str);
2620
2621         /* delete from inside */
2622         r = IXMLDOMText_deleteData(nodetext, 1, 33);
2623         ok(r == S_OK, "ret %08x\n", r );
2624
2625         r = IXMLDOMText_get_length(nodetext, &nLength);
2626         ok(r == S_OK, "ret %08x\n", r );
2627         ok(nLength == 2, "expected 2 got %d\n", nLength);
2628
2629         r = IXMLDOMText_get_text(nodetext, &str);
2630         ok(r == S_OK, "ret %08x\n", r );
2631         ok( !lstrcmpW( str, _bstr_("") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2632         SysFreeString(str);
2633
2634         /* delete whole data ... */
2635         r = IXMLDOMText_get_length(nodetext, &nLength);
2636         ok(r == S_OK, "ret %08x\n", r );
2637
2638         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
2639         ok(r == S_OK, "ret %08x\n", r );
2640         /* ... and try again with empty string */
2641         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
2642         ok(r == S_OK, "ret %08x\n", r );
2643
2644         /* test put_data */
2645         V_VT(&var) = VT_BSTR;
2646         V_BSTR(&var) = SysAllocString(szstr1);
2647         r = IXMLDOMText_put_nodeValue(nodetext, var);
2648         ok(r == S_OK, "ret %08x\n", r );
2649         VariantClear(&var);
2650
2651         r = IXMLDOMText_get_text(nodetext, &str);
2652         ok(r == S_OK, "ret %08x\n", r );
2653         ok( !lstrcmpW( str, szstr1 ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2654         SysFreeString(str);
2655
2656         /* test put_data */
2657         V_VT(&var) = VT_I4;
2658         V_I4(&var) = 99;
2659         r = IXMLDOMText_put_nodeValue(nodetext, var);
2660         ok(r == S_OK, "ret %08x\n", r );
2661         VariantClear(&var);
2662
2663         r = IXMLDOMText_get_text(nodetext, &str);
2664         ok(r == S_OK, "ret %08x\n", r );
2665         ok( !lstrcmpW( str, _bstr_("99") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2666         SysFreeString(str);
2667
2668         /* ::replaceData() */
2669         V_VT(&var) = VT_BSTR;
2670         V_BSTR(&var) = SysAllocString(szstr1);
2671         r = IXMLDOMText_put_nodeValue(nodetext, var);
2672         ok(r == S_OK, "ret %08x\n", r );
2673         VariantClear(&var);
2674
2675         r = IXMLDOMText_replaceData(nodetext, 6, 0, NULL);
2676         ok(r == E_INVALIDARG, "ret %08x\n", r );
2677         r = IXMLDOMText_get_text(nodetext, &str);
2678         ok(r == S_OK, "ret %08x\n", r );
2679         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2680         SysFreeString(str);
2681
2682         r = IXMLDOMText_replaceData(nodetext, 0, 0, NULL);
2683         ok(r == S_OK, "ret %08x\n", r );
2684         r = IXMLDOMText_get_text(nodetext, &str);
2685         ok(r == S_OK, "ret %08x\n", r );
2686         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2687         SysFreeString(str);
2688
2689         /* NULL pointer means delete */
2690         r = IXMLDOMText_replaceData(nodetext, 0, 1, NULL);
2691         ok(r == S_OK, "ret %08x\n", r );
2692         r = IXMLDOMText_get_text(nodetext, &str);
2693         ok(r == S_OK, "ret %08x\n", r );
2694         ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2695         SysFreeString(str);
2696
2697         /* empty string means delete */
2698         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_(""));
2699         ok(r == S_OK, "ret %08x\n", r );
2700         r = IXMLDOMText_get_text(nodetext, &str);
2701         ok(r == S_OK, "ret %08x\n", r );
2702         ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2703         SysFreeString(str);
2704
2705         /* zero count means insert */
2706         r = IXMLDOMText_replaceData(nodetext, 0, 0, _bstr_("a"));
2707         ok(r == S_OK, "ret %08x\n", r );
2708         r = IXMLDOMText_get_text(nodetext, &str);
2709         ok(r == S_OK, "ret %08x\n", r );
2710         ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2711         SysFreeString(str);
2712
2713         r = IXMLDOMText_replaceData(nodetext, 0, 2, NULL);
2714         ok(r == S_OK, "ret %08x\n", r );
2715
2716         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("m"));
2717         ok(r == S_OK, "ret %08x\n", r );
2718         r = IXMLDOMText_get_text(nodetext, &str);
2719         ok(r == S_OK, "ret %08x\n", r );
2720         ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2721         SysFreeString(str);
2722
2723         /* nonempty string, count greater than its length */
2724         r = IXMLDOMText_replaceData(nodetext, 0, 2, _bstr_("a1.2"));
2725         ok(r == S_OK, "ret %08x\n", r );
2726         r = IXMLDOMText_get_text(nodetext, &str);
2727         ok(r == S_OK, "ret %08x\n", r );
2728         ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2729         SysFreeString(str);
2730
2731         /* nonempty string, count less than its length */
2732         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_("wine"));
2733         ok(r == S_OK, "ret %08x\n", r );
2734         r = IXMLDOMText_get_text(nodetext, &str);
2735         ok(r == S_OK, "ret %08x\n", r );
2736         ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
2737         SysFreeString(str);
2738
2739         IXMLDOMText_Release( nodetext );
2740     }
2741
2742     /* test Create Comment */
2743     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
2744     ok( r == E_INVALIDARG, "returns %08x\n", r );
2745     node_comment = (IXMLDOMComment*)0x1;
2746
2747     /* empty comment */
2748     r = IXMLDOMDocument_createComment(doc, _bstr_(""), &node_comment);
2749     ok( r == S_OK, "returns %08x\n", r );
2750     str = (BSTR)0x1;
2751     r = IXMLDOMComment_get_data(node_comment, &str);
2752     ok( r == S_OK, "returns %08x\n", r );
2753     ok( str && SysStringLen(str) == 0, "expected empty string data\n");
2754     IXMLDOMComment_Release(node_comment);
2755     SysFreeString(str);
2756
2757     r = IXMLDOMDocument_createComment(doc, NULL, &node_comment);
2758     ok( r == S_OK, "returns %08x\n", r );
2759     str = (BSTR)0x1;
2760     r = IXMLDOMComment_get_data(node_comment, &str);
2761     ok( r == S_OK, "returns %08x\n", r );
2762     ok( str && (SysStringLen(str) == 0), "expected empty string data\n");
2763     IXMLDOMComment_Release(node_comment);
2764     SysFreeString(str);
2765
2766     str = SysAllocString(szComment);
2767     r = IXMLDOMDocument_createComment(doc, str, &node_comment);
2768     SysFreeString(str);
2769     ok( r == S_OK, "returns %08x\n", r );
2770     if(node_comment)
2771     {
2772         /* Last Child Checks */
2773         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
2774         ok(r == E_INVALIDARG, "ret %08x\n", r );
2775
2776         nodeChild = (IXMLDOMNode*)0x1;
2777         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
2778         ok(r == S_FALSE, "ret %08x\n", r );
2779         ok(nodeChild == NULL, "pLastChild not NULL\n");
2780
2781         /* baseName */
2782         str = (BSTR)0xdeadbeef;
2783         r = IXMLDOMComment_get_baseName(node_comment, &str);
2784         ok(r == S_FALSE, "ret %08x\n", r );
2785         ok(str == NULL, "Expected NULL\n");
2786
2787         IXMLDOMComment_Release( node_comment );
2788     }
2789
2790     /* test Create Attribute */
2791     str = SysAllocString(szAttribute);
2792     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
2793     ok( r == E_INVALIDARG, "returns %08x\n", r );
2794     r = IXMLDOMDocument_createAttribute(doc, str, &node_attr);
2795     ok( r == S_OK, "returns %08x\n", r );
2796     IXMLDOMAttribute_Release( node_attr);
2797     SysFreeString(str);
2798
2799     /* test Processing Instruction */
2800     str = SysAllocStringLen(NULL, 0);
2801     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
2802     ok( r == E_INVALIDARG, "returns %08x\n", r );
2803     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
2804     ok( r == E_FAIL, "returns %08x\n", r );
2805     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
2806     ok( r == E_FAIL, "returns %08x\n", r );
2807     SysFreeString(str);
2808
2809     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
2810     ok( r == S_OK, "returns %08x\n", r );
2811     if(nodePI)
2812     {
2813         /* Last Child Checks */
2814         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
2815         ok(r == E_INVALIDARG, "ret %08x\n", r );
2816
2817         nodeChild = (IXMLDOMNode*)0x1;
2818         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
2819         ok(r == S_FALSE, "ret %08x\n", r );
2820         ok(nodeChild == NULL, "nodeChild not NULL\n");
2821
2822         /* test nodeName */
2823         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
2824         ok(r == S_OK, "ret %08x\n", r );
2825         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2826         SysFreeString(str);
2827
2828         /* test baseName */
2829         str = (BSTR)0x1;
2830         r = IXMLDOMProcessingInstruction_get_baseName(nodePI, &str);
2831         ok(r == S_OK, "ret %08x\n", r );
2832         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2833         SysFreeString(str);
2834
2835         /* test Target */
2836         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
2837         ok(r == S_OK, "ret %08x\n", r );
2838         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
2839         SysFreeString(str);
2840
2841         /* test get_data */
2842         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
2843         ok(r == S_OK, "ret %08x\n", r );
2844         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
2845         SysFreeString(str);
2846
2847         /* test put_data */
2848         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
2849         ok(r == E_FAIL, "ret %08x\n", r );
2850
2851         /* test put_data */
2852         V_VT(&var) = VT_BSTR;
2853         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
2854         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
2855         ok(r == E_FAIL, "ret %08x\n", r );
2856         VariantClear(&var);
2857
2858         /* test get nodeName */
2859         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
2860         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
2861         ok(r == S_OK, "ret %08x\n", r );
2862         SysFreeString(str);
2863
2864         IXMLDOMProcessingInstruction_Release(nodePI);
2865     }
2866
2867     ref = IXMLDOMDocument_Release( doc );
2868     ok( ref == 0, "got %d\n", ref);
2869
2870     free_bstrs();
2871 }
2872
2873 static void test_persiststreaminit(void)
2874 {
2875     IXMLDOMDocument *doc;
2876     IPersistStreamInit *streaminit;
2877     HRESULT hr;
2878
2879     doc = create_document(&IID_IXMLDOMDocument);
2880     if (!doc) return;
2881
2882     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&streaminit);
2883     ok( hr == S_OK, "failed with 0x%08x\n", hr );
2884
2885     hr = IPersistStreamInit_InitNew(streaminit);
2886     ok( hr == S_OK, "failed with 0x%08x\n", hr );
2887
2888     IXMLDOMDocument_Release(doc);
2889 }
2890
2891 static void test_domnode( void )
2892 {
2893     HRESULT r;
2894     IXMLDOMDocument *doc, *owner = NULL;
2895     IXMLDOMElement *element = NULL;
2896     IXMLDOMNamedNodeMap *map = NULL;
2897     IXMLDOMNode *node = NULL, *next = NULL;
2898     IXMLDOMNodeList *list = NULL;
2899     IXMLDOMAttribute *attr = NULL;
2900     DOMNodeType type = NODE_INVALID;
2901     VARIANT_BOOL b;
2902     BSTR str;
2903     VARIANT var;
2904     LONG count;
2905
2906     doc = create_document(&IID_IXMLDOMDocument);
2907     if (!doc) return;
2908
2909     b = FALSE;
2910     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2911     ok( r == S_OK, "loadXML failed\n");
2912     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2913
2914     EXPECT_CHILDREN(doc);
2915
2916     r = IXMLDOMDocument_get_documentElement( doc, &element );
2917     ok( r == S_OK, "should be a document element\n");
2918     ok( element != NULL, "should be an element\n");
2919
2920     VariantInit(&var);
2921     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
2922
2923     r = IXMLDOMDocument_get_nodeValue( doc, NULL );
2924     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
2925
2926     r = IXMLDOMDocument_get_nodeValue( doc, &var );
2927     ok( r == S_FALSE, "nextNode returned wrong code\n");
2928     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
2929     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
2930
2931     if (element)
2932     {
2933         owner = NULL;
2934         r = IXMLDOMElement_get_ownerDocument( element, &owner );
2935         ok( r == S_OK, "get_ownerDocument return code\n");
2936         ok( owner != doc, "get_ownerDocument return\n");
2937         IXMLDOMDocument_Release(owner);
2938
2939         type = NODE_INVALID;
2940         r = IXMLDOMElement_get_nodeType( element, &type);
2941         ok( r == S_OK, "got %08x\n", r);
2942         ok( type == NODE_ELEMENT, "node not an element\n");
2943
2944         str = NULL;
2945         r = IXMLDOMElement_get_baseName( element, &str );
2946         ok( r == S_OK, "get_baseName returned wrong code\n");
2947         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
2948         SysFreeString(str);
2949
2950         /* check if nodename is correct */
2951         r = IXMLDOMElement_get_nodeName( element, NULL );
2952         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2953
2954         /* content doesn't matter here */
2955         str = NULL;
2956         r = IXMLDOMElement_get_nodeName( element, &str );
2957         ok ( r == S_OK, "get_nodeName wrong code\n");
2958         ok ( str != NULL, "str is null\n");
2959         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
2960         SysFreeString( str );
2961
2962         str = SysAllocString( nonexistent_fileW );
2963         V_VT(&var) = VT_I4;
2964         V_I4(&var) = 0x1234;
2965         r = IXMLDOMElement_getAttribute( element, str, &var );
2966         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
2967         ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
2968         VariantClear(&var);
2969
2970         str = SysAllocString( szdl );
2971         V_VT(&var) = VT_I4;
2972         V_I4(&var) = 0x1234;
2973         r = IXMLDOMElement_getAttribute( element, str, &var );
2974         ok( r == S_OK, "getAttribute ret %08x\n", r );
2975         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
2976         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
2977         VariantClear( &var );
2978
2979         r = IXMLDOMElement_getAttribute( element, NULL, &var );
2980         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
2981
2982         r = IXMLDOMElement_getAttribute( element, str, NULL );
2983         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
2984
2985         attr = NULL;
2986         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
2987         ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
2988         ok( attr != NULL, "getAttributeNode returned NULL\n" );
2989         if (attr)
2990         {
2991             r = IXMLDOMAttribute_get_parentNode( attr, NULL );
2992             ok( r == E_INVALIDARG, "Expected E_INVALIDARG, ret %08x\n", r );
2993
2994             /* attribute doesn't have a parent in msxml interpretation */
2995             node = (IXMLDOMNode*)0xdeadbeef;
2996             r = IXMLDOMAttribute_get_parentNode( attr, &node );
2997             ok( r == S_FALSE, "Expected S_FALSE, ret %08x\n", r );
2998             ok( node == NULL, "Expected NULL, got %p\n", node );
2999
3000             IXMLDOMAttribute_Release(attr);
3001         }
3002
3003         SysFreeString( str );
3004
3005         r = IXMLDOMElement_get_attributes( element, &map );
3006         ok( r == S_OK, "get_attributes returned wrong code\n");
3007         ok( map != NULL, "should be attributes\n");
3008
3009         EXPECT_CHILDREN(element);
3010     }
3011     else
3012         ok( FALSE, "no element\n");
3013
3014     if (map)
3015     {
3016         str = SysAllocString( szdl );
3017         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
3018         ok( r == S_OK, "getNamedItem returned wrong code\n");
3019         ok( node != NULL, "should be attributes\n");
3020         IXMLDOMNode_Release(node);
3021         SysFreeString( str );
3022
3023         str = SysAllocString( szdl );
3024         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
3025         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
3026         SysFreeString( str );
3027
3028         /* something that isn't in complete4A */
3029         str = SysAllocString( szOpen );
3030         node = (IXMLDOMNode *) 1;
3031         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
3032         ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
3033         ok( node == NULL, "getNamedItem should have returned NULL\n");
3034         SysFreeString( str );
3035
3036         /* test indexed access of attributes */
3037         r = IXMLDOMNamedNodeMap_get_length( map, NULL );
3038         ok ( r == E_INVALIDARG, "get_length should return E_INVALIDARG\n");
3039
3040         r = IXMLDOMNamedNodeMap_get_length( map, &count );
3041         ok ( r == S_OK, "get_length wrong code\n");
3042         ok ( count == 1, "get_length != 1\n");
3043
3044         node = NULL;
3045         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
3046         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
3047         ok ( node == NULL, "there is no node\n");
3048
3049         node = NULL;
3050         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
3051         ok ( r == S_FALSE, "get_item (1) wrong code\n");
3052         ok ( node == NULL, "there is no attribute\n");
3053
3054         node = NULL;
3055         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
3056         ok ( r == S_OK, "get_item (0) wrong code\n");
3057         ok ( node != NULL, "should be attribute\n");
3058
3059         r = IXMLDOMNode_get_nodeName( node, NULL );
3060         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
3061
3062         /* content doesn't matter here */
3063         str = NULL;
3064         r = IXMLDOMNode_get_nodeName( node, &str );
3065         ok ( r == S_OK, "get_nodeName wrong code\n");
3066         ok ( str != NULL, "str is null\n");
3067         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
3068         SysFreeString( str );
3069         IXMLDOMNode_Release( node );
3070
3071         /* test sequential access of attributes */
3072         node = NULL;
3073         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
3074         ok ( r == S_OK, "nextNode (first time) wrong code\n");
3075         ok ( node != NULL, "nextNode, should be attribute\n");
3076         IXMLDOMNode_Release( node );
3077
3078         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
3079         ok ( r != S_OK, "nextNode (second time) wrong code\n");
3080         ok ( node == NULL, "nextNode, there is no attribute\n");
3081
3082         r = IXMLDOMNamedNodeMap_reset( map );
3083         ok ( r == S_OK, "reset should return S_OK\n");
3084
3085         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
3086         ok ( r == S_OK, "nextNode (third time) wrong code\n");
3087         ok ( node != NULL, "nextNode, should be attribute\n");
3088     }
3089     else
3090         ok( FALSE, "no map\n");
3091
3092     if (node)
3093     {
3094         type = NODE_INVALID;
3095         r = IXMLDOMNode_get_nodeType( node, &type);
3096         ok( r == S_OK, "getNamedItem returned wrong code\n");
3097         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
3098
3099         str = NULL;
3100         r = IXMLDOMNode_get_baseName( node, NULL );
3101         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
3102
3103         str = NULL;
3104         r = IXMLDOMNode_get_baseName( node, &str );
3105         ok( r == S_OK, "get_baseName returned wrong code\n");
3106         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
3107         SysFreeString( str );
3108
3109         r = IXMLDOMNode_get_childNodes( node, NULL );
3110         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
3111
3112         r = IXMLDOMNode_get_childNodes( node, &list );
3113         ok( r == S_OK, "get_childNodes returned wrong code\n");
3114
3115         if (list)
3116         {
3117             r = IXMLDOMNodeList_nextNode( list, &next );
3118             ok( r == S_OK, "nextNode returned wrong code\n");
3119         }
3120         else
3121             ok( FALSE, "no childlist\n");
3122
3123         if (next)
3124         {
3125             EXPECT_NO_CHILDREN(next);
3126
3127             type = NODE_INVALID;
3128             r = IXMLDOMNode_get_nodeType( next, &type);
3129             ok( r == S_OK, "getNamedItem returned wrong code\n");
3130             ok( type == NODE_TEXT, "node not text\n");
3131
3132             str = (BSTR) 1;
3133             r = IXMLDOMNode_get_baseName( next, &str );
3134             ok( r == S_FALSE, "get_baseName returned wrong code\n");
3135             ok( str == NULL, "basename was wrong\n");
3136             SysFreeString(str);
3137         }
3138         else
3139             ok( FALSE, "no next\n");
3140
3141         if (next)
3142             IXMLDOMNode_Release( next );
3143         next = NULL;
3144         if (list)
3145             IXMLDOMNodeList_Release( list );
3146         list = NULL;
3147         if (node)
3148             IXMLDOMNode_Release( node );
3149     }
3150     else
3151         ok( FALSE, "no node\n");
3152     node = NULL;
3153
3154     if (map)
3155         IXMLDOMNamedNodeMap_Release( map );
3156
3157     /* now traverse the tree from the root element */
3158     if (element)
3159     {
3160         r = IXMLDOMElement_get_childNodes( element, &list );
3161         ok( r == S_OK, "get_childNodes returned wrong code\n");
3162
3163         /* using get_item for child list doesn't advance the position */
3164         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
3165         expect_node(node, "E2.E2.D1");
3166         IXMLDOMNode_Release(node);
3167         ole_check(IXMLDOMNodeList_nextNode(list, &node));
3168         expect_node(node, "E1.E2.D1");
3169         IXMLDOMNode_Release(node);
3170         ole_check(IXMLDOMNodeList_reset(list));
3171
3172         IXMLDOMNodeList_AddRef(list);
3173         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
3174         ole_check(IXMLDOMNodeList_reset(list));
3175
3176         node = (void*)0xdeadbeef;
3177         str = SysAllocString(szdl);
3178         r = IXMLDOMElement_selectSingleNode( element, str, &node );
3179         SysFreeString(str);
3180         ok( r == S_FALSE, "ret %08x\n", r );
3181         ok( node == NULL, "node %p\n", node );
3182
3183         str = SysAllocString(szbs);
3184         r = IXMLDOMElement_selectSingleNode( element, str, &node );
3185         SysFreeString(str);
3186         ok( r == S_OK, "ret %08x\n", r );
3187         r = IXMLDOMNode_Release( node );
3188         ok( r == 0, "ret %08x\n", r );
3189     }
3190     else
3191         ok( FALSE, "no element\n");
3192
3193     if (list)
3194     {
3195         r = IXMLDOMNodeList_get_item(list, 0, NULL);
3196         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
3197
3198         r = IXMLDOMNodeList_get_length(list, NULL);
3199         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
3200
3201         r = IXMLDOMNodeList_get_length( list, &count );
3202         ok( r == S_OK, "get_length returns %08x\n", r );
3203         ok( count == 4, "get_length got %d\n", count );
3204
3205         r = IXMLDOMNodeList_nextNode(list, NULL);
3206         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
3207
3208         r = IXMLDOMNodeList_nextNode( list, &node );
3209         ok( r == S_OK, "nextNode returned wrong code\n");
3210     }
3211     else
3212         ok( FALSE, "no list\n");
3213
3214     if (node)
3215     {
3216         type = NODE_INVALID;
3217         r = IXMLDOMNode_get_nodeType( node, &type);
3218         ok( r == S_OK, "getNamedItem returned wrong code\n");
3219         ok( type == NODE_ELEMENT, "node not text\n");
3220
3221         r = IXMLDOMNode_hasChildNodes( node, NULL );
3222         ok( r == E_INVALIDARG, "hasChildNodes bad return\n");
3223
3224         EXPECT_CHILDREN(node);
3225
3226         str = NULL;
3227         r = IXMLDOMNode_get_baseName( node, &str );
3228         ok( r == S_OK, "get_baseName returned wrong code\n");
3229         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
3230         SysFreeString(str);
3231     }
3232     else
3233         ok( FALSE, "no node\n");
3234
3235     if (node)
3236         IXMLDOMNode_Release( node );
3237     if (list)
3238         IXMLDOMNodeList_Release( list );
3239     if (element)
3240         IXMLDOMElement_Release( element );
3241
3242     b = FALSE;
3243     str = SysAllocString( szComplete5 );
3244     r = IXMLDOMDocument_loadXML( doc, str, &b );
3245     ok( r == S_OK, "loadXML failed\n");
3246     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3247     SysFreeString( str );
3248
3249     EXPECT_CHILDREN(doc);
3250
3251     r = IXMLDOMDocument_get_documentElement( doc, &element );
3252     ok( r == S_OK, "should be a document element\n");
3253     ok( element != NULL, "should be an element\n");
3254
3255     if (element)
3256     {
3257         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
3258         BSTR tag = NULL;
3259
3260         /* check if the tag is correct */
3261         r = IXMLDOMElement_get_tagName( element, &tag );
3262         ok( r == S_OK, "couldn't get tag name\n");
3263         ok( tag != NULL, "tag was null\n");
3264         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
3265         SysFreeString( tag );
3266     }
3267
3268     if (element)
3269         IXMLDOMElement_Release( element );
3270     ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
3271
3272     free_bstrs();
3273 }
3274
3275 typedef struct {
3276     DOMNodeType type;
3277     REFIID iid;
3278 } refcount_test_t;
3279
3280 static const refcount_test_t refcount_test[] = {
3281     { NODE_ELEMENT,                &IID_IXMLDOMElement },
3282     { NODE_ATTRIBUTE,              &IID_IXMLDOMAttribute },
3283     { NODE_TEXT,                   &IID_IXMLDOMText },
3284     { NODE_CDATA_SECTION,          &IID_IXMLDOMCDATASection },
3285     { NODE_ENTITY_REFERENCE,       &IID_IXMLDOMEntityReference },
3286     { NODE_PROCESSING_INSTRUCTION, &IID_IXMLDOMProcessingInstruction },
3287     { NODE_COMMENT,                &IID_IXMLDOMComment },
3288     { NODE_DOCUMENT_FRAGMENT,      &IID_IXMLDOMDocumentFragment },
3289     { NODE_INVALID,                &IID_NULL }
3290 };
3291
3292 static void test_refs(void)
3293 {
3294     IXMLDOMImplementation *impl, *impl2;
3295     IXMLDOMElement *element, *elem2;
3296     IXMLDOMNodeList *node_list = NULL;
3297     IXMLDOMNode *node, *node2, *node3;
3298     const refcount_test_t *ptr;
3299     IXMLDOMDocument *doc;
3300     IUnknown *unk, *unk2;
3301     VARIANT_BOOL b;
3302     HRESULT hr;
3303     LONG ref;
3304
3305     doc = create_document(&IID_IXMLDOMDocument);
3306     if (!doc) return;
3307
3308     ptr = refcount_test;
3309     while (ptr->type != NODE_INVALID)
3310     {
3311         IUnknown *node_typed, *node_typed2;
3312         IDispatchEx *dispex, *dispex2;
3313         IDispatch *disp, *disp2;
3314         VARIANT type;
3315
3316         V_VT(&type) = VT_I1;
3317         V_I1(&type) = ptr->type;
3318
3319         EXPECT_REF(doc, 1);
3320         hr = IXMLDOMDocument_createNode(doc, type, _bstr_("name"), NULL, &node);
3321         EXPECT_HR(hr, S_OK);
3322         EXPECT_REF(doc, 1);
3323         EXPECT_REF(node, 1);
3324
3325         /* try IDispatch and IUnknown from IXMLDOMNode */
3326         hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
3327         EXPECT_HR(hr, S_OK);
3328         EXPECT_REF(unk, 2);
3329 todo_wine {
3330         EXPECT_REF(node, 1);
3331         ok(unk != (IUnknown*)node, "%d: got %p and %p\n", ptr->type, unk, node);
3332 }
3333         EXPECT_REF(unk, 2);
3334         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
3335         EXPECT_HR(hr, S_OK);
3336         todo_wine ok(unk != (IUnknown*)disp, "%d: got %p and %p\n", ptr->type, unk, disp);
3337         EXPECT_REF(unk, 3);
3338         todo_wine EXPECT_REF(disp, 1);
3339
3340         EXPECT_REF(unk, 3);
3341         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp2);
3342         EXPECT_HR(hr, S_OK);
3343         todo_wine ok(disp != disp2, "%d: got %p and %p\n", ptr->type, disp, disp2);
3344         EXPECT_REF(unk, 4);
3345         todo_wine EXPECT_REF(disp2, 1);
3346
3347         IDispatch_Release(disp);
3348         IDispatch_Release(disp2);
3349
3350         /* get IXMLDOMNode from this IUnknown */
3351         EXPECT_REF(unk, 2);
3352         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node2);
3353         EXPECT_HR(hr, S_OK);
3354         todo_wine ok(unk != (IUnknown*)node2, "%d: got %p and %p\n", ptr->type, unk, node2);
3355         EXPECT_REF(unk, 3);
3356         todo_wine EXPECT_REF(node2, 1);
3357
3358         EXPECT_REF(unk, 3);
3359         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node3);
3360         EXPECT_HR(hr, S_OK);
3361         todo_wine ok(node2 != node3, "%d: got %p and %p\n", ptr->type, node2, node3);
3362         EXPECT_REF(unk, 4);
3363         todo_wine EXPECT_REF(node3, 1);
3364
3365         IXMLDOMNode_Release(node2);
3366         IXMLDOMNode_Release(node3);
3367
3368         /* try IDispatchEx from IUnknown */
3369         EXPECT_REF(unk, 2);
3370         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
3371         EXPECT_HR(hr, S_OK);
3372         ok(unk != (IUnknown*)dispex, "%d: got %p and %p\n", ptr->type, unk, dispex);
3373         EXPECT_REF(unk, 3);
3374         todo_wine EXPECT_REF(dispex, 1);
3375
3376         EXPECT_REF(unk, 3);
3377         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex2);
3378         EXPECT_HR(hr, S_OK);
3379         todo_wine ok(dispex != dispex2, "%d: got %p and %p\n", ptr->type, dispex, dispex2);
3380         EXPECT_REF(unk, 4);
3381         todo_wine EXPECT_REF(dispex2, 1);
3382
3383         IDispatchEx_Release(dispex);
3384         IDispatchEx_Release(dispex2);
3385
3386         /* try corresponding IXMLDOM* */
3387         EXPECT_REF(unk, 2);
3388         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed);
3389         EXPECT_HR(hr, S_OK);
3390         EXPECT_REF(unk, 3);
3391         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed2);
3392         EXPECT_HR(hr, S_OK);
3393         EXPECT_REF(unk, 4);
3394         todo_wine ok(node_typed != node_typed2, "%d: got %p and %p\n", ptr->type, node_typed, node_typed2);
3395         IUnknown_Release(node_typed);
3396         IUnknown_Release(node_typed2);
3397
3398         /* try invalid IXMLDOM* */
3399         hr = IUnknown_QueryInterface(unk, (ptr+1)->iid, (void**)&node_typed);
3400         EXPECT_HR(hr, E_NOINTERFACE);
3401
3402         IUnknown_Release(unk);
3403
3404         EXPECT_REF(node, 1);
3405         hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMNode, (void**)&node2);
3406         EXPECT_HR(hr, S_OK);
3407         EXPECT_REF(node, 2);
3408         ok(node == node2, "%d: got %p and %p\n", ptr->type, node, node2);
3409
3410         EXPECT_REF(node, 2);
3411         hr = IXMLDOMNode_QueryInterface(node, ptr->iid, (void**)&node_typed);
3412         EXPECT_HR(hr, S_OK);
3413         EXPECT_REF(node, 3);
3414 todo_wine {
3415         EXPECT_REF(node_typed, 2);
3416         ok((IUnknown*)node != node_typed, "%d: got %p and %p\n", ptr->type, node, node_typed);
3417 }
3418         IUnknown_Release(node_typed);
3419
3420         IXMLDOMNode_Release(node2);
3421         IXMLDOMNode_Release(node);
3422
3423         ptr++;
3424     }
3425
3426     EXPECT_REF(doc, 1);
3427     ref = IXMLDOMDocument_Release(doc);
3428     ok( ref == 0, "ref %d\n", ref);
3429
3430     /* check IUnknown after releasing DOM iface */
3431     doc = create_document(&IID_IXMLDOMDocument);
3432     EXPECT_REF(doc, 1);
3433     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
3434     EXPECT_HR(hr, S_OK);
3435 todo_wine {
3436     EXPECT_REF(unk, 3);
3437     EXPECT_REF(doc, 1);
3438 }
3439     IXMLDOMDocument_Release(doc);
3440     EXPECT_REF(unk, 1);
3441     IUnknown_Release(unk);
3442
3443     doc = create_document(&IID_IXMLDOMDocument);
3444     if (!doc) return;
3445
3446     EXPECT_REF(doc, 1);
3447     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
3448     EXPECT_HR(hr, S_OK);
3449 todo_wine {
3450     EXPECT_REF(unk, 3);
3451     EXPECT_REF(doc, 1);
3452 }
3453     IUnknown_Release(unk);
3454
3455     /* IXMLDOMImplementation */
3456     EXPECT_REF(doc, 1);
3457     hr = IXMLDOMDocument_get_implementation(doc, &impl);
3458     EXPECT_HR(hr, S_OK);
3459     EXPECT_REF(doc, 1);
3460     EXPECT_REF(impl, 1);
3461     hr = IXMLDOMDocument_get_implementation(doc, &impl2);
3462     EXPECT_HR(hr, S_OK);
3463     EXPECT_REF(doc, 1);
3464     EXPECT_REF(impl2, 1);
3465     ok(impl != impl2, "got %p, %p\n", impl, impl2);
3466     IXMLDOMImplementation_Release(impl);
3467     IXMLDOMImplementation_Release(impl2);
3468
3469     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3470     EXPECT_HR(hr, S_OK);
3471     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3472
3473     EXPECT_REF(doc, 1);
3474     IXMLDOMDocument_AddRef( doc );
3475     EXPECT_REF(doc, 2);
3476     IXMLDOMDocument_AddRef( doc );
3477     EXPECT_REF(doc, 3);
3478
3479     IXMLDOMDocument_Release( doc );
3480     IXMLDOMDocument_Release( doc );
3481
3482     EXPECT_REF(doc, 1);
3483     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
3484     EXPECT_HR(hr, S_OK);
3485 todo_wine {
3486     EXPECT_REF(unk, 3);
3487     EXPECT_REF(doc, 1);
3488 }
3489     hr = IXMLDOMDocument_get_documentElement(doc, &element);
3490     EXPECT_HR(hr, S_OK);
3491 todo_wine {
3492     EXPECT_REF(doc, 1);
3493     EXPECT_REF(element, 2);
3494 }
3495     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
3496     EXPECT_HR(hr, S_OK);
3497
3498 todo_wine {
3499     EXPECT_REF(doc, 1);
3500     EXPECT_REF(element, 2);
3501     EXPECT_REF(elem2, 2);
3502 }
3503     IXMLDOMElement_AddRef(element);
3504     todo_wine EXPECT_REF(element, 3);
3505     IXMLDOMElement_Release(element);
3506
3507     /* get IUnknown from a node doesn't touch node instance refcount */
3508     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
3509     EXPECT_HR(hr, S_OK);
3510     EXPECT_REF(element, 2);
3511 todo_wine {
3512     EXPECT_REF(unk, 4);
3513     EXPECT_REF(elem2, 2);
3514 }
3515     hr = IXMLDOMElement_QueryInterface(elem2, &IID_IUnknown, (void**)&unk2);
3516     EXPECT_HR(hr, S_OK);
3517 todo_wine {
3518     EXPECT_REF(unk, 5);
3519     EXPECT_REF(unk2, 5);
3520 }
3521     EXPECT_REF(element, 2);
3522     EXPECT_REF(elem2, 2);
3523
3524     todo_wine ok(unk == unk2, "got %p and %p\n", unk, unk2);
3525
3526     IUnknown_Release(unk);
3527     IUnknown_Release(unk2);
3528
3529     /* IUnknown refcount is not affected by node refcount */
3530     todo_wine EXPECT_REF(unk2, 3);
3531     IXMLDOMElement_AddRef(elem2);
3532     todo_wine EXPECT_REF(unk2, 3);
3533     IXMLDOMElement_Release(elem2);
3534
3535     IXMLDOMElement_Release(elem2);
3536     todo_wine EXPECT_REF(unk2, 2);
3537
3538     hr = IXMLDOMElement_get_childNodes( element, &node_list );
3539     EXPECT_HR(hr, S_OK);
3540
3541     todo_wine EXPECT_REF(element, 2);
3542     EXPECT_REF(node_list, 1);
3543
3544     hr = IXMLDOMNodeList_get_item( node_list, 0, &node );
3545     EXPECT_HR(hr, S_OK);
3546     EXPECT_REF(node_list, 1);
3547     EXPECT_REF(node, 1);
3548
3549     hr = IXMLDOMNodeList_get_item( node_list, 0, &node2 );
3550     EXPECT_HR(hr, S_OK);
3551     EXPECT_REF(node_list, 1);
3552     EXPECT_REF(node2, 1);
3553
3554     ref = IXMLDOMNode_Release( node );
3555     ok( ref == 0, "ref %d\n", ref );
3556     ref = IXMLDOMNode_Release( node2 );
3557     ok( ref == 0, "ref %d\n", ref );
3558
3559     ref = IXMLDOMNodeList_Release( node_list );
3560     ok( ref == 0, "ref %d\n", ref );
3561
3562     ok( node != node2, "node %p node2 %p\n", node, node2 );
3563
3564     ref = IXMLDOMDocument_Release( doc );
3565     todo_wine ok( ref == 0, "ref %d\n", ref );
3566
3567     todo_wine EXPECT_REF(element, 2);
3568
3569     /* IUnknown must be unique however we obtain it */
3570     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
3571     EXPECT_HR(hr, S_OK);
3572     EXPECT_REF(element, 2);
3573     hr = IXMLDOMElement_QueryInterface(element, &IID_IXMLDOMNode, (void**)&node);
3574     EXPECT_HR(hr, S_OK);
3575     todo_wine EXPECT_REF(element, 2);
3576     hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk2);
3577     EXPECT_HR(hr, S_OK);
3578     todo_wine EXPECT_REF(element, 2);
3579     ok(unk == unk2, "unk %p unk2 %p\n", unk, unk2);
3580     todo_wine ok(element != (void*)node, "node %p element %p\n", node, element);
3581
3582     IUnknown_Release( unk2 );
3583     IUnknown_Release( unk );
3584     IXMLDOMNode_Release( node );
3585     todo_wine EXPECT_REF(element, 2);
3586
3587     IXMLDOMElement_Release( element );
3588
3589     free_bstrs();
3590 }
3591
3592 static void test_create(void)
3593 {
3594     static const WCHAR szOne[] = {'1',0};
3595     static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
3596     HRESULT r;
3597     VARIANT var;
3598     BSTR str, name;
3599     IXMLDOMDocument *doc;
3600     IXMLDOMElement *element;
3601     IXMLDOMComment *comment;
3602     IXMLDOMText *text;
3603     IXMLDOMCDATASection *cdata;
3604     IXMLDOMNode *root, *node, *child;
3605     IXMLDOMNamedNodeMap *attr_map;
3606     IUnknown *unk;
3607     LONG ref;
3608     LONG num;
3609
3610     doc = create_document(&IID_IXMLDOMDocument);
3611     if (!doc) return;
3612
3613     EXPECT_REF(doc, 1);
3614
3615     /* types not supported for creation */
3616     V_VT(&var) = VT_I1;
3617     V_I1(&var) = NODE_DOCUMENT;
3618     node = (IXMLDOMNode*)0x1;
3619     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3620     ok( r == E_INVALIDARG, "returns %08x\n", r );
3621     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3622
3623     V_VT(&var) = VT_I1;
3624     V_I1(&var) = NODE_DOCUMENT_TYPE;
3625     node = (IXMLDOMNode*)0x1;
3626     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3627     ok( r == E_INVALIDARG, "returns %08x\n", r );
3628     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3629
3630     V_VT(&var) = VT_I1;
3631     V_I1(&var) = NODE_ENTITY;
3632     node = (IXMLDOMNode*)0x1;
3633     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3634     ok( r == E_INVALIDARG, "returns %08x\n", r );
3635     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3636
3637     V_VT(&var) = VT_I1;
3638     V_I1(&var) = NODE_NOTATION;
3639     node = (IXMLDOMNode*)0x1;
3640     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3641     ok( r == E_INVALIDARG, "returns %08x\n", r );
3642     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3643
3644     /* NODE_COMMENT */
3645     V_VT(&var) = VT_I1;
3646     V_I1(&var) = NODE_COMMENT;
3647     node = NULL;
3648     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3649     ok( r == S_OK, "returns %08x\n", r );
3650     ok( node != NULL, "\n");
3651
3652     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
3653     ok( r == S_OK, "returns %08x\n", r );
3654     IXMLDOMNode_Release(node);
3655
3656     str = NULL;
3657     r = IXMLDOMComment_get_data(comment, &str);
3658     ok( r == S_OK, "returns %08x\n", r );
3659     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3660     IXMLDOMComment_Release(comment);
3661     SysFreeString(str);
3662
3663     node = (IXMLDOMNode*)0x1;
3664     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3665     ok( r == S_OK, "returns %08x\n", r );
3666
3667     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
3668     ok( r == S_OK, "returns %08x\n", r );
3669     IXMLDOMNode_Release(node);
3670
3671     str = NULL;
3672     r = IXMLDOMComment_get_data(comment, &str);
3673     ok( r == S_OK, "returns %08x\n", r );
3674     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3675     IXMLDOMComment_Release(comment);
3676     SysFreeString(str);
3677
3678     node = (IXMLDOMNode*)0x1;
3679     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3680     ok( r == S_OK, "returns %08x\n", r );
3681
3682     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
3683     ok( r == S_OK, "returns %08x\n", r );
3684     IXMLDOMNode_Release(node);
3685
3686     str = NULL;
3687     r = IXMLDOMComment_get_data(comment, &str);
3688     ok( r == S_OK, "returns %08x\n", r );
3689     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3690     IXMLDOMComment_Release(comment);
3691     SysFreeString(str);
3692
3693     /* NODE_TEXT */
3694     V_VT(&var) = VT_I1;
3695     V_I1(&var) = NODE_TEXT;
3696     node = NULL;
3697     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3698     ok( r == S_OK, "returns %08x\n", r );
3699     ok( node != NULL, "\n");
3700
3701     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3702     ok( r == S_OK, "returns %08x\n", r );
3703     IXMLDOMNode_Release(node);
3704
3705     str = NULL;
3706     r = IXMLDOMText_get_data(text, &str);
3707     ok( r == S_OK, "returns %08x\n", r );
3708     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3709     IXMLDOMText_Release(text);
3710     SysFreeString(str);
3711
3712     node = (IXMLDOMNode*)0x1;
3713     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3714     ok( r == S_OK, "returns %08x\n", r );
3715
3716     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3717     ok( r == S_OK, "returns %08x\n", r );
3718     IXMLDOMNode_Release(node);
3719
3720     str = NULL;
3721     r = IXMLDOMText_get_data(text, &str);
3722     ok( r == S_OK, "returns %08x\n", r );
3723     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3724     IXMLDOMText_Release(text);
3725     SysFreeString(str);
3726
3727     node = (IXMLDOMNode*)0x1;
3728     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3729     ok( r == S_OK, "returns %08x\n", r );
3730
3731     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
3732     ok( r == S_OK, "returns %08x\n", r );
3733     IXMLDOMNode_Release(node);
3734
3735     str = NULL;
3736     r = IXMLDOMText_get_data(text, &str);
3737     ok( r == S_OK, "returns %08x\n", r );
3738     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3739     IXMLDOMText_Release(text);
3740     SysFreeString(str);
3741
3742     /* NODE_CDATA_SECTION */
3743     V_VT(&var) = VT_I1;
3744     V_I1(&var) = NODE_CDATA_SECTION;
3745     node = NULL;
3746     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3747     ok( r == S_OK, "returns %08x\n", r );
3748     ok( node != NULL, "\n");
3749
3750     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3751     ok( r == S_OK, "returns %08x\n", r );
3752     IXMLDOMNode_Release(node);
3753
3754     str = NULL;
3755     r = IXMLDOMCDATASection_get_data(cdata, &str);
3756     ok( r == S_OK, "returns %08x\n", r );
3757     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3758     IXMLDOMCDATASection_Release(cdata);
3759     SysFreeString(str);
3760
3761     node = (IXMLDOMNode*)0x1;
3762     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3763     ok( r == S_OK, "returns %08x\n", r );
3764
3765     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3766     ok( r == S_OK, "returns %08x\n", r );
3767     IXMLDOMNode_Release(node);
3768
3769     str = NULL;
3770     r = IXMLDOMCDATASection_get_data(cdata, &str);
3771     ok( r == S_OK, "returns %08x\n", r );
3772     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3773     IXMLDOMCDATASection_Release(cdata);
3774     SysFreeString(str);
3775
3776     node = (IXMLDOMNode*)0x1;
3777     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
3778     ok( r == S_OK, "returns %08x\n", r );
3779
3780     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
3781     ok( r == S_OK, "returns %08x\n", r );
3782     IXMLDOMNode_Release(node);
3783
3784     str = NULL;
3785     r = IXMLDOMCDATASection_get_data(cdata, &str);
3786     ok( r == S_OK, "returns %08x\n", r );
3787     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
3788     IXMLDOMCDATASection_Release(cdata);
3789     SysFreeString(str);
3790
3791     /* NODE_ATTRIBUTE */
3792     V_VT(&var) = VT_I1;
3793     V_I1(&var) = NODE_ATTRIBUTE;
3794     node = (IXMLDOMNode*)0x1;
3795     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3796     ok( r == E_FAIL, "returns %08x\n", r );
3797     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3798
3799     V_VT(&var) = VT_I1;
3800     V_I1(&var) = NODE_ATTRIBUTE;
3801     node = (IXMLDOMNode*)0x1;
3802     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3803     ok( r == E_FAIL, "returns %08x\n", r );
3804     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3805
3806     V_VT(&var) = VT_I1;
3807     V_I1(&var) = NODE_ATTRIBUTE;
3808     str = SysAllocString( szlc );
3809     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3810     ok( r == S_OK, "returns %08x\n", r );
3811     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3812     SysFreeString(str);
3813
3814     /* a name is required for attribute, try a BSTR with first null wchar */
3815     V_VT(&var) = VT_I1;
3816     V_I1(&var) = NODE_ATTRIBUTE;
3817     str = SysAllocString( szstr1 );
3818     str[0] = 0;
3819     node = (IXMLDOMNode*)0x1;
3820     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3821     ok( r == E_FAIL, "returns %08x\n", r );
3822     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3823     SysFreeString(str);
3824
3825     /* NODE_PROCESSING_INSTRUCTION */
3826     V_VT(&var) = VT_I1;
3827     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3828     node = (IXMLDOMNode*)0x1;
3829     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3830     ok( r == E_FAIL, "returns %08x\n", r );
3831     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3832
3833     V_VT(&var) = VT_I1;
3834     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3835     node = (IXMLDOMNode*)0x1;
3836     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3837     ok( r == E_FAIL, "returns %08x\n", r );
3838     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3839
3840     V_VT(&var) = VT_I1;
3841     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
3842     r = IXMLDOMDocument_createNode( doc, var, _bstr_("pi"), NULL, NULL );
3843     ok( r == E_INVALIDARG, "returns %08x\n", r );
3844
3845     /* NODE_ENTITY_REFERENCE */
3846     V_VT(&var) = VT_I1;
3847     V_I1(&var) = NODE_ENTITY_REFERENCE;
3848     node = (IXMLDOMNode*)0x1;
3849     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3850     ok( r == E_FAIL, "returns %08x\n", r );
3851     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3852
3853     V_VT(&var) = VT_I1;
3854     V_I1(&var) = NODE_ENTITY_REFERENCE;
3855     node = (IXMLDOMNode*)0x1;
3856     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3857     ok( r == E_FAIL, "returns %08x\n", r );
3858     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3859
3860     /* NODE_ELEMENT */
3861     V_VT(&var) = VT_I1;
3862     V_I1(&var) = NODE_ELEMENT;
3863     node = (IXMLDOMNode*)0x1;
3864     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
3865     ok( r == E_FAIL, "returns %08x\n", r );
3866     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3867
3868     V_VT(&var) = VT_I1;
3869     V_I1(&var) = NODE_ELEMENT;
3870     node = (IXMLDOMNode*)0x1;
3871     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
3872     ok( r == E_FAIL, "returns %08x\n", r );
3873     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
3874
3875     V_VT(&var) = VT_I1;
3876     V_I1(&var) = NODE_ELEMENT;
3877     str = SysAllocString( szlc );
3878     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3879     ok( r == S_OK, "returns %08x\n", r );
3880     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3881
3882     V_VT(&var) = VT_I1;
3883     V_I1(&var) = NODE_ELEMENT;
3884     r = IXMLDOMDocument_createNode( doc, var, str, NULL, NULL );
3885     ok( r == E_INVALIDARG, "returns %08x\n", r );
3886
3887     V_VT(&var) = VT_R4;
3888     V_R4(&var) = NODE_ELEMENT;
3889     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3890     ok( r == S_OK, "returns %08x\n", r );
3891     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3892
3893     V_VT(&var) = VT_BSTR;
3894     V_BSTR(&var) = SysAllocString( szOne );
3895     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3896     ok( r == S_OK, "returns %08x\n", r );
3897     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3898     VariantClear(&var);
3899
3900     V_VT(&var) = VT_BSTR;
3901     V_BSTR(&var) = SysAllocString( szOneGarbage );
3902     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3903     ok( r == E_INVALIDARG, "returns %08x\n", r );
3904     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
3905     VariantClear(&var);
3906
3907     V_VT(&var) = VT_I4;
3908     V_I4(&var) = NODE_ELEMENT;
3909     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3910     ok( r == S_OK, "returns %08x\n", r );
3911
3912     EXPECT_REF(doc, 1);
3913     r = IXMLDOMDocument_appendChild( doc, node, &root );
3914     ok( r == S_OK, "returns %08x\n", r );
3915     ok( node == root, "%p %p\n", node, root );
3916     EXPECT_REF(doc, 1);
3917
3918     EXPECT_REF(node, 2);
3919
3920     ref = IXMLDOMNode_Release( node );
3921     ok(ref == 1, "ref %d\n", ref);
3922     SysFreeString( str );
3923
3924     V_VT(&var) = VT_I4;
3925     V_I4(&var) = NODE_ELEMENT;
3926     str = SysAllocString( szbs );
3927     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
3928     ok( r == S_OK, "returns %08x\n", r );
3929     SysFreeString( str );
3930
3931     EXPECT_REF(node, 1);
3932
3933     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk );
3934     ok( r == S_OK, "returns %08x\n", r );
3935
3936     EXPECT_REF(unk, 2);
3937
3938     V_VT(&var) = VT_EMPTY;
3939     child = NULL;
3940     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
3941     ok( r == S_OK, "returns %08x\n", r );
3942     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
3943
3944     todo_wine EXPECT_REF(unk, 4);
3945
3946     IXMLDOMNode_Release( child );
3947     IUnknown_Release( unk );
3948
3949     V_VT(&var) = VT_NULL;
3950     V_DISPATCH(&var) = (IDispatch*)node;
3951     r = IXMLDOMNode_insertBefore( root, node, var, &child );
3952     ok( r == S_OK, "returns %08x\n", r );
3953     ok( node == child, "%p %p\n", node, child );
3954     IXMLDOMNode_Release( child );
3955
3956     V_VT(&var) = VT_NULL;
3957     V_DISPATCH(&var) = (IDispatch*)node;
3958     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
3959     ok( r == S_OK, "returns %08x\n", r );
3960     IXMLDOMNode_Release( node );
3961
3962     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (void**)&element );
3963     ok( r == S_OK, "returns %08x\n", r );
3964
3965     r = IXMLDOMElement_get_attributes( element, &attr_map );
3966     ok( r == S_OK, "returns %08x\n", r );
3967     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3968     ok( r == S_OK, "returns %08x\n", r );
3969     ok( num == 0, "num %d\n", num );
3970     IXMLDOMNamedNodeMap_Release( attr_map );
3971
3972     V_VT(&var) = VT_BSTR;
3973     V_BSTR(&var) = SysAllocString( szstr1 );
3974     name = SysAllocString( szdl );
3975     r = IXMLDOMElement_setAttribute( element, name, var );
3976     ok( r == S_OK, "returns %08x\n", r );
3977     r = IXMLDOMElement_get_attributes( element, &attr_map );
3978     ok( r == S_OK, "returns %08x\n", r );
3979     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3980     ok( r == S_OK, "returns %08x\n", r );
3981     ok( num == 1, "num %d\n", num );
3982     IXMLDOMNamedNodeMap_Release( attr_map );
3983     VariantClear(&var);
3984
3985     V_VT(&var) = VT_BSTR;
3986     V_BSTR(&var) = SysAllocString( szstr2 );
3987     r = IXMLDOMElement_setAttribute( element, name, var );
3988     ok( r == S_OK, "returns %08x\n", r );
3989     r = IXMLDOMElement_get_attributes( element, &attr_map );
3990     ok( r == S_OK, "returns %08x\n", r );
3991     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
3992     ok( r == S_OK, "returns %08x\n", r );
3993     ok( num == 1, "num %d\n", num );
3994     IXMLDOMNamedNodeMap_Release( attr_map );
3995     VariantClear(&var);
3996     r = IXMLDOMElement_getAttribute( element, name, &var );
3997     ok( r == S_OK, "returns %08x\n", r );
3998     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
3999     VariantClear(&var);
4000     SysFreeString(name);
4001
4002     V_VT(&var) = VT_BSTR;
4003     V_BSTR(&var) = SysAllocString( szstr1 );
4004     name = SysAllocString( szlc );
4005     r = IXMLDOMElement_setAttribute( element, name, var );
4006     ok( r == S_OK, "returns %08x\n", r );
4007     r = IXMLDOMElement_get_attributes( element, &attr_map );
4008     ok( r == S_OK, "returns %08x\n", r );
4009     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
4010     ok( r == S_OK, "returns %08x\n", r );
4011     ok( num == 2, "num %d\n", num );
4012     IXMLDOMNamedNodeMap_Release( attr_map );
4013     VariantClear(&var);
4014     SysFreeString(name);
4015
4016     V_VT(&var) = VT_I4;
4017     V_I4(&var) = 10;
4018     name = SysAllocString( szbs );
4019     r = IXMLDOMElement_setAttribute( element, name, var );
4020     ok( r == S_OK, "returns %08x\n", r );
4021     VariantClear(&var);
4022     r = IXMLDOMElement_getAttribute( element, name, &var );
4023     ok( r == S_OK, "returns %08x\n", r );
4024     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
4025     VariantClear(&var);
4026     SysFreeString(name);
4027
4028     /* Create an Attribute */
4029     V_VT(&var) = VT_I4;
4030     V_I4(&var) = NODE_ATTRIBUTE;
4031     str = SysAllocString( szAttribute );
4032     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
4033     ok( r == S_OK, "returns %08x\n", r );
4034     ok( node != NULL, "node was null\n");
4035     SysFreeString(str);
4036
4037     IXMLDOMElement_Release( element );
4038     IXMLDOMNode_Release( root );
4039     IXMLDOMDocument_Release( doc );
4040 }
4041
4042 static void test_getElementsByTagName(void)
4043 {
4044     IXMLDOMNodeList *node_list;
4045     IXMLDOMDocument *doc;
4046     IXMLDOMElement *elem;
4047     WCHAR buff[100];
4048     VARIANT_BOOL b;
4049     HRESULT r;
4050     LONG len;
4051     BSTR str;
4052
4053     doc = create_document(&IID_IXMLDOMDocument);
4054     if (!doc) return;
4055
4056     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4057     ok( r == S_OK, "loadXML failed\n");
4058     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4059
4060     str = SysAllocString( szstar );
4061
4062     /* null arguments cases */
4063     r = IXMLDOMDocument_getElementsByTagName(doc, NULL, &node_list);
4064     ok( r == E_INVALIDARG, "ret %08x\n", r );
4065     r = IXMLDOMDocument_getElementsByTagName(doc, str, NULL);
4066     ok( r == E_INVALIDARG, "ret %08x\n", r );
4067
4068     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
4069     ok( r == S_OK, "ret %08x\n", r );
4070     r = IXMLDOMNodeList_get_length( node_list, &len );
4071     ok( r == S_OK, "ret %08x\n", r );
4072     ok( len == 6, "len %d\n", len );
4073
4074     IXMLDOMNodeList_Release( node_list );
4075     SysFreeString( str );
4076
4077     /* broken query BSTR */
4078     memcpy(&buff[2], szstar, sizeof(szstar));
4079     /* just a big length */
4080     *(DWORD*)buff = 0xf0f0;
4081     r = IXMLDOMDocument_getElementsByTagName(doc, &buff[2], &node_list);
4082     ok( r == S_OK, "ret %08x\n", r );
4083     r = IXMLDOMNodeList_get_length( node_list, &len );
4084     ok( r == S_OK, "ret %08x\n", r );
4085     ok( len == 6, "len %d\n", len );
4086     IXMLDOMNodeList_Release( node_list );
4087
4088     str = SysAllocString( szbs );
4089     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
4090     ok( r == S_OK, "ret %08x\n", r );
4091     r = IXMLDOMNodeList_get_length( node_list, &len );
4092     ok( r == S_OK, "ret %08x\n", r );
4093     ok( len == 1, "len %d\n", len );
4094     IXMLDOMNodeList_Release( node_list );
4095     SysFreeString( str );
4096
4097     str = SysAllocString( szdl );
4098     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
4099     ok( r == S_OK, "ret %08x\n", r );
4100     r = IXMLDOMNodeList_get_length( node_list, &len );
4101     ok( r == S_OK, "ret %08x\n", r );
4102     ok( len == 0, "len %d\n", len );
4103     IXMLDOMNodeList_Release( node_list );
4104     SysFreeString( str );
4105
4106     str = SysAllocString( szstr1 );
4107     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
4108     ok( r == S_OK, "ret %08x\n", r );
4109     r = IXMLDOMNodeList_get_length( node_list, &len );
4110     ok( r == S_OK, "ret %08x\n", r );
4111     ok( len == 0, "len %d\n", len );
4112     IXMLDOMNodeList_Release( node_list );
4113     SysFreeString( str );
4114
4115     /* test for element */
4116     r = IXMLDOMDocument_get_documentElement(doc, &elem);
4117     ok( r == S_OK, "ret %08x\n", r );
4118
4119     str = SysAllocString( szstar );
4120
4121     /* null arguments cases */
4122     r = IXMLDOMElement_getElementsByTagName(elem, NULL, &node_list);
4123     ok( r == E_INVALIDARG, "ret %08x\n", r );
4124     r = IXMLDOMElement_getElementsByTagName(elem, str, NULL);
4125     ok( r == E_INVALIDARG, "ret %08x\n", r );
4126
4127     r = IXMLDOMElement_getElementsByTagName(elem, str, &node_list);
4128     ok( r == S_OK, "ret %08x\n", r );
4129     r = IXMLDOMNodeList_get_length( node_list, &len );
4130     ok( r == S_OK, "ret %08x\n", r );
4131     ok( len == 5, "len %d\n", len );
4132     expect_list_and_release(node_list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1");
4133     SysFreeString( str );
4134
4135     /* broken query BSTR */
4136     memcpy(&buff[2], szstar, sizeof(szstar));
4137     /* just a big length */
4138     *(DWORD*)buff = 0xf0f0;
4139     r = IXMLDOMElement_getElementsByTagName(elem, &buff[2], &node_list);
4140     ok( r == S_OK, "ret %08x\n", r );
4141     r = IXMLDOMNodeList_get_length( node_list, &len );
4142     ok( r == S_OK, "ret %08x\n", r );
4143     ok( len == 5, "len %d\n", len );
4144     IXMLDOMNodeList_Release( node_list );
4145
4146     IXMLDOMElement_Release(elem);
4147
4148     IXMLDOMDocument_Release( doc );
4149
4150     free_bstrs();
4151 }
4152
4153 static void test_get_text(void)
4154 {
4155     HRESULT r;
4156     BSTR str;
4157     VARIANT_BOOL b;
4158     IXMLDOMDocument *doc;
4159     IXMLDOMNode *node, *node2, *node3;
4160     IXMLDOMNode *nodeRoot;
4161     IXMLDOMNodeList *node_list;
4162     IXMLDOMNamedNodeMap *node_map;
4163     LONG len;
4164
4165     doc = create_document(&IID_IXMLDOMDocument);
4166     if (!doc) return;
4167
4168     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4169     ok( r == S_OK, "loadXML failed\n");
4170     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4171
4172     str = SysAllocString( szbs );
4173     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
4174     ok( r == S_OK, "ret %08x\n", r );
4175     SysFreeString(str);
4176
4177     /* Test to get all child node text. */
4178     r = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&nodeRoot);
4179     ok( r == S_OK, "ret %08x\n", r );
4180     if(r == S_OK)
4181     {
4182         r = IXMLDOMNode_get_text( nodeRoot, &str );
4183         ok( r == S_OK, "ret %08x\n", r );
4184         ok( compareIgnoreReturns(str, _bstr_("fn1.txt\n\n fn2.txt \n\nf1\n")), "wrong get_text: %s\n", wine_dbgstr_w(str));
4185         SysFreeString(str);
4186
4187         IXMLDOMNode_Release(nodeRoot);
4188     }
4189
4190     r = IXMLDOMNodeList_get_length( node_list, NULL );
4191     ok( r == E_INVALIDARG, "ret %08x\n", r );
4192
4193     r = IXMLDOMNodeList_get_length( node_list, &len );
4194     ok( r == S_OK, "ret %08x\n", r );
4195     ok( len == 1, "expect 1 got %d\n", len );
4196
4197     r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
4198     ok( r == E_INVALIDARG, "ret %08x\n", r );
4199
4200     r = IXMLDOMNodeList_nextNode( node_list, NULL );
4201     ok( r == E_INVALIDARG, "ret %08x\n", r );
4202
4203     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
4204     ok( r == S_OK, "ret %08x\n", r );
4205     IXMLDOMNodeList_Release( node_list );
4206
4207     /* Invalid output parameter*/
4208     r = IXMLDOMNode_get_text( node, NULL );
4209     ok( r == E_INVALIDARG, "ret %08x\n", r );
4210
4211     r = IXMLDOMNode_get_text( node, &str );
4212     ok( r == S_OK, "ret %08x\n", r );
4213     ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
4214     SysFreeString(str);
4215
4216     r = IXMLDOMNode_get_attributes( node, &node_map );
4217     ok( r == S_OK, "ret %08x\n", r );
4218
4219     str = SysAllocString( szvr );
4220     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
4221     ok( r == S_OK, "ret %08x\n", r );
4222     SysFreeString(str);
4223
4224     r = IXMLDOMNode_get_text( node2, &str );
4225     ok( r == S_OK, "ret %08x\n", r );
4226     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
4227     SysFreeString(str);
4228
4229     r = IXMLDOMNode_get_firstChild( node2, &node3 );
4230     ok( r == S_OK, "ret %08x\n", r );
4231
4232     r = IXMLDOMNode_get_text( node3, &str );
4233     ok( r == S_OK, "ret %08x\n", r );
4234     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
4235     SysFreeString(str);
4236
4237
4238     IXMLDOMNode_Release( node3 );
4239     IXMLDOMNode_Release( node2 );
4240     IXMLDOMNamedNodeMap_Release( node_map );
4241     IXMLDOMNode_Release( node );
4242     IXMLDOMDocument_Release( doc );
4243
4244     free_bstrs();
4245 }
4246
4247 static void test_get_childNodes(void)
4248 {
4249     IXMLDOMNodeList *node_list, *node_list2;
4250     IEnumVARIANT *enum1, *enum2, *enum3;
4251     VARIANT_BOOL b;
4252     IXMLDOMDocument *doc;
4253     IXMLDOMNode *node, *node2;
4254     IXMLDOMElement *element;
4255     IUnknown *unk1, *unk2;
4256     HRESULT hr;
4257     VARIANT v;
4258     BSTR str;
4259     LONG len;
4260
4261     doc = create_document(&IID_IXMLDOMDocument);
4262     if (!doc) return;
4263
4264     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4265     EXPECT_HR(hr, S_OK);
4266     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4267
4268     hr = IXMLDOMDocument_get_documentElement( doc, &element );
4269     EXPECT_HR(hr, S_OK);
4270
4271     hr = IXMLDOMElement_get_childNodes( element, &node_list );
4272     EXPECT_HR(hr, S_OK);
4273
4274     hr = IXMLDOMNodeList_get_length( node_list, &len );
4275     EXPECT_HR(hr, S_OK);
4276     ok( len == 4, "len %d\n", len);
4277
4278     /* refcount tests for IEnumVARIANT support */
4279     EXPECT_REF(node_list, 1);
4280     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum1);
4281     EXPECT_HR(hr, S_OK);
4282     EXPECT_REF(node_list, 1);
4283     EXPECT_REF(enum1, 2);
4284
4285     EXPECT_REF(node_list, 1);
4286     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum2);
4287     EXPECT_HR(hr, S_OK);
4288     EXPECT_REF(node_list, 1);
4289     ok(enum2 == enum1, "got %p, %p\n", enum2, enum1);
4290     IEnumVARIANT_Release(enum2);
4291
4292     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
4293     EXPECT_HR(hr, S_OK);
4294     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
4295     EXPECT_HR(hr, S_OK);
4296     EXPECT_REF(node_list, 3);
4297     EXPECT_REF(enum1, 2);
4298     ok(unk1 == unk2, "got %p, %p\n", unk1, unk2);
4299     IUnknown_Release(unk1);
4300     IUnknown_Release(unk2);
4301
4302     EXPECT_REF(node_list, 1);
4303     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum2);
4304     EXPECT_HR(hr, S_OK);
4305     EXPECT_REF(node_list, 2);
4306     EXPECT_REF(enum2, 1);
4307     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
4308
4309     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
4310     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
4311     EXPECT_HR(hr, S_OK);
4312     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
4313     EXPECT_HR(hr, S_OK);
4314     EXPECT_REF(node_list, 3);
4315     EXPECT_REF(enum2, 2);
4316     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
4317     IUnknown_Release(unk1);
4318     IUnknown_Release(unk2);
4319
4320     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum3);
4321     EXPECT_HR(hr, S_OK);
4322     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
4323     IEnumVARIANT_Release(enum3);
4324     IEnumVARIANT_Release(enum2);
4325
4326     /* iteration tests */
4327     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
4328     EXPECT_HR(hr, S_OK);
4329     hr = IXMLDOMNode_get_nodeName(node, &str);
4330     EXPECT_HR(hr, S_OK);
4331     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
4332     SysFreeString(str);
4333     IXMLDOMNode_Release(node);
4334
4335     hr = IXMLDOMNodeList_nextNode(node_list, &node);
4336     EXPECT_HR(hr, S_OK);
4337     hr = IXMLDOMNode_get_nodeName(node, &str);
4338     EXPECT_HR(hr, S_OK);
4339     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
4340     SysFreeString(str);
4341     IXMLDOMNode_Release(node);
4342
4343     V_VT(&v) = VT_EMPTY;
4344     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
4345     EXPECT_HR(hr, S_OK);
4346     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
4347     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
4348     EXPECT_HR(hr, S_OK);
4349     hr = IXMLDOMNode_get_nodeName(node, &str);
4350     EXPECT_HR(hr, S_OK);
4351     ok(!lstrcmpW(str, _bstr_("bs")), "got node name %s\n", wine_dbgstr_w(str));
4352     SysFreeString(str);
4353     IXMLDOMNode_Release(node);
4354     VariantClear(&v);
4355
4356     hr = IXMLDOMNodeList_nextNode(node_list, &node);
4357     EXPECT_HR(hr, S_OK);
4358     hr = IXMLDOMNode_get_nodeName(node, &str);
4359     EXPECT_HR(hr, S_OK);
4360     ok(!lstrcmpW(str, _bstr_("pr")), "got %s\n", wine_dbgstr_w(str));
4361     SysFreeString(str);
4362     IXMLDOMNode_Release(node);
4363
4364     IEnumVARIANT_Release(enum1);
4365
4366     hr = IXMLDOMNodeList_get_item( node_list, 2, &node );
4367     EXPECT_HR(hr, S_OK);
4368
4369     hr = IXMLDOMNode_get_childNodes( node, &node_list2 );
4370     EXPECT_HR(hr, S_OK);
4371
4372     hr = IXMLDOMNodeList_get_length( node_list2, &len );
4373     EXPECT_HR(hr, S_OK);
4374     ok( len == 0, "len %d\n", len);
4375
4376     hr = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
4377     EXPECT_HR(hr, S_FALSE);
4378
4379     IXMLDOMNodeList_Release( node_list2 );
4380     IXMLDOMNode_Release( node );
4381     IXMLDOMNodeList_Release( node_list );
4382     IXMLDOMElement_Release( element );
4383
4384     /* test for children of <?xml ..?> node */
4385     hr = IXMLDOMDocument_get_firstChild(doc, &node);
4386     EXPECT_HR(hr, S_OK);
4387
4388     str = NULL;
4389     hr = IXMLDOMNode_get_nodeName(node, &str);
4390     EXPECT_HR(hr, S_OK);
4391     ok(!lstrcmpW(str, _bstr_("xml")), "got %s\n", wine_dbgstr_w(str));
4392     SysFreeString(str);
4393
4394     /* it returns empty but valid node list */
4395     node_list = (void*)0xdeadbeef;
4396     hr = IXMLDOMNode_get_childNodes(node, &node_list);
4397     EXPECT_HR(hr, S_OK);
4398
4399     len = -1;
4400     hr = IXMLDOMNodeList_get_length(node_list, &len);
4401     EXPECT_HR(hr, S_OK);
4402     ok(len == 0, "got %d\n", len);
4403
4404     IXMLDOMNodeList_Release( node_list );
4405     IXMLDOMNode_Release(node);
4406
4407     IXMLDOMDocument_Release( doc );
4408     free_bstrs();
4409 }
4410
4411 static void test_get_firstChild(void)
4412 {
4413     static WCHAR xmlW[] = {'x','m','l',0};
4414     IXMLDOMDocument *doc;
4415     IXMLDOMNode *node;
4416     VARIANT_BOOL b;
4417     HRESULT r;
4418     BSTR str;
4419
4420     doc = create_document(&IID_IXMLDOMDocument);
4421     if (!doc) return;
4422
4423     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4424     ok( r == S_OK, "loadXML failed\n");
4425     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4426
4427     r = IXMLDOMDocument_get_firstChild( doc, &node );
4428     ok( r == S_OK, "ret %08x\n", r);
4429
4430     r = IXMLDOMNode_get_nodeName( node, &str );
4431     ok( r == S_OK, "ret %08x\n", r);
4432
4433     ok(!lstrcmpW(str, xmlW), "expected \"xml\" node name, got %s\n", wine_dbgstr_w(str));
4434
4435     SysFreeString(str);
4436     IXMLDOMNode_Release( node );
4437     IXMLDOMDocument_Release( doc );
4438
4439     free_bstrs();
4440 }
4441
4442 static void test_get_lastChild(void)
4443 {
4444     static WCHAR lcW[] = {'l','c',0};
4445     static WCHAR foW[] = {'f','o',0};
4446     IXMLDOMDocument *doc;
4447     IXMLDOMNode *node, *child;
4448     VARIANT_BOOL b;
4449     HRESULT r;
4450     BSTR str;
4451
4452     doc = create_document(&IID_IXMLDOMDocument);
4453     if (!doc) return;
4454
4455     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4456     ok( r == S_OK, "loadXML failed\n");
4457     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4458
4459     r = IXMLDOMDocument_get_lastChild( doc, &node );
4460     ok( r == S_OK, "ret %08x\n", r);
4461
4462     r = IXMLDOMNode_get_nodeName( node, &str );
4463     ok( r == S_OK, "ret %08x\n", r);
4464
4465     ok(memcmp(str, lcW, sizeof(lcW)) == 0, "expected \"lc\" node name\n");
4466     SysFreeString(str);
4467
4468     r = IXMLDOMNode_get_lastChild( node, &child );
4469     ok( r == S_OK, "ret %08x\n", r);
4470
4471     r = IXMLDOMNode_get_nodeName( child, &str );
4472     ok( r == S_OK, "ret %08x\n", r);
4473
4474     ok(memcmp(str, foW, sizeof(foW)) == 0, "expected \"fo\" node name\n");
4475     SysFreeString(str);
4476
4477     IXMLDOMNode_Release( child );
4478     IXMLDOMNode_Release( node );
4479     IXMLDOMDocument_Release( doc );
4480
4481     free_bstrs();
4482 }
4483
4484 static void test_removeChild(void)
4485 {
4486     HRESULT r;
4487     VARIANT_BOOL b;
4488     IXMLDOMDocument *doc;
4489     IXMLDOMElement *element, *lc_element;
4490     IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
4491     IXMLDOMNodeList *root_list, *fo_list;
4492
4493     doc = create_document(&IID_IXMLDOMDocument);
4494     if (!doc) return;
4495
4496     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4497     ok( r == S_OK, "loadXML failed\n");
4498     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4499
4500     r = IXMLDOMDocument_get_documentElement( doc, &element );
4501     ok( r == S_OK, "ret %08x\n", r);
4502     todo_wine EXPECT_REF(element, 2);
4503
4504     r = IXMLDOMElement_get_childNodes( element, &root_list );
4505     ok( r == S_OK, "ret %08x\n", r);
4506     EXPECT_REF(root_list, 1);
4507
4508     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
4509     ok( r == S_OK, "ret %08x\n", r);
4510     EXPECT_REF(fo_node, 1);
4511
4512     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
4513     ok( r == S_OK, "ret %08x\n", r);
4514     EXPECT_REF(fo_list, 1);
4515
4516     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
4517     ok( r == S_OK, "ret %08x\n", r);
4518     EXPECT_REF(ba_node, 1);
4519
4520     /* invalid parameter: NULL ptr */
4521     removed_node = (void*)0xdeadbeef;
4522     r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
4523     ok( r == E_INVALIDARG, "ret %08x\n", r );
4524     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
4525
4526     /* ba_node is a descendant of element, but not a direct child. */
4527     removed_node = (void*)0xdeadbeef;
4528     EXPECT_REF(ba_node, 1);
4529     EXPECT_CHILDREN(fo_node);
4530     r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
4531     ok( r == E_INVALIDARG, "ret %08x\n", r );
4532     ok( removed_node == NULL, "%p\n", removed_node );
4533     EXPECT_REF(ba_node, 1);
4534     EXPECT_CHILDREN(fo_node);
4535
4536     EXPECT_REF(ba_node, 1);
4537     EXPECT_REF(fo_node, 1);
4538     r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
4539     ok( r == S_OK, "ret %08x\n", r);
4540     ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
4541     EXPECT_REF(fo_node, 2);
4542     EXPECT_REF(ba_node, 1);
4543
4544     /* try removing already removed child */
4545     temp_node = (void*)0xdeadbeef;
4546     r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
4547     ok( r == E_INVALIDARG, "ret %08x\n", r);
4548     ok( temp_node == NULL, "%p\n", temp_node );
4549     IXMLDOMNode_Release( fo_node );
4550
4551     /* the removed node has no parent anymore */
4552     r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
4553     ok( r == S_FALSE, "ret %08x\n", r);
4554     ok( temp_node == NULL, "%p\n", temp_node );
4555
4556     IXMLDOMNode_Release( removed_node );
4557     IXMLDOMNode_Release( ba_node );
4558     IXMLDOMNodeList_Release( fo_list );
4559
4560     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
4561     ok( r == S_OK, "ret %08x\n", r);
4562
4563     r = IXMLDOMNode_QueryInterface( lc_node, &IID_IXMLDOMElement, (void**)&lc_element );
4564     ok( r == S_OK, "ret %08x\n", r);
4565
4566     /* MS quirk: passing wrong interface pointer works, too */
4567     r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
4568     ok( r == S_OK, "ret %08x\n", r);
4569     IXMLDOMElement_Release( lc_element );
4570
4571     temp_node = (void*)0xdeadbeef;
4572     r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
4573     ok( r == S_FALSE, "ret %08x\n", r);
4574     ok( temp_node == NULL, "%p\n", temp_node );
4575
4576     IXMLDOMNode_Release( lc_node );
4577     IXMLDOMNodeList_Release( root_list );
4578     IXMLDOMElement_Release( element );
4579     IXMLDOMDocument_Release( doc );
4580
4581     free_bstrs();
4582 }
4583
4584 static void test_replaceChild(void)
4585 {
4586     HRESULT r;
4587     VARIANT_BOOL b;
4588     IXMLDOMDocument *doc;
4589     IXMLDOMElement *element, *ba_element;
4590     IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
4591     IXMLDOMNodeList *root_list, *fo_list;
4592     IUnknown * unk1, *unk2;
4593     LONG len;
4594
4595     doc = create_document(&IID_IXMLDOMDocument);
4596     if (!doc) return;
4597
4598     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4599     ok( r == S_OK, "loadXML failed\n");
4600     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4601
4602     r = IXMLDOMDocument_get_documentElement( doc, &element );
4603     ok( r == S_OK, "ret %08x\n", r);
4604
4605     r = IXMLDOMElement_get_childNodes( element, &root_list );
4606     ok( r == S_OK, "ret %08x\n", r);
4607
4608     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
4609     ok( r == S_OK, "ret %08x\n", r);
4610
4611     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
4612     ok( r == S_OK, "ret %08x\n", r);
4613
4614     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
4615     ok( r == S_OK, "ret %08x\n", r);
4616
4617     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
4618     ok( r == S_OK, "ret %08x\n", r);
4619
4620     IXMLDOMNodeList_Release( fo_list );
4621
4622     /* invalid parameter: NULL ptr for element to remove */
4623     removed_node = (void*)0xdeadbeef;
4624     r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
4625     ok( r == E_INVALIDARG, "ret %08x\n", r );
4626     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
4627
4628     /* invalid parameter: NULL for replacement element. (Sic!) */
4629     removed_node = (void*)0xdeadbeef;
4630     r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
4631     ok( r == E_INVALIDARG, "ret %08x\n", r );
4632     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
4633
4634     /* invalid parameter: OldNode is not a child */
4635     removed_node = (void*)0xdeadbeef;
4636     r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
4637     ok( r == E_INVALIDARG, "ret %08x\n", r );
4638     ok( removed_node == NULL, "%p\n", removed_node );
4639     IXMLDOMNode_Release( lc_node );
4640
4641     /* invalid parameter: would create loop */
4642     removed_node = (void*)0xdeadbeef;
4643     r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
4644     ok( r == E_FAIL, "ret %08x\n", r );
4645     ok( removed_node == NULL, "%p\n", removed_node );
4646
4647     r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
4648     ok( r == S_OK, "ret %08x\n", r );
4649
4650     r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
4651     ok( r == S_OK, "ret %08x\n", r );
4652
4653     /* ba_node and temp_node refer to the same node, yet they
4654        are different interface pointers */
4655     ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
4656     r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
4657     ok( r == S_OK, "ret %08x\n", r );
4658     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
4659     ok( r == S_OK, "ret %08x\n", r );
4660     todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
4661
4662     IUnknown_Release( unk1 );
4663     IUnknown_Release( unk2 );
4664
4665     /* ba_node should have been removed from below fo_node */
4666     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
4667     ok( r == S_OK, "ret %08x\n", r );
4668
4669     /* MS quirk: replaceChild also accepts elements instead of nodes */
4670     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
4671     ok( r == S_OK, "ret %08x\n", r );
4672     EXPECT_REF(ba_element, 2);
4673
4674     removed_node = NULL;
4675     r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
4676     ok( r == S_OK, "ret %08x\n", r );
4677     ok( removed_node != NULL, "got %p\n", removed_node);
4678     EXPECT_REF(ba_element, 3);
4679     IXMLDOMElement_Release( ba_element );
4680
4681     r = IXMLDOMNodeList_get_length( fo_list, &len);
4682     ok( r == S_OK, "ret %08x\n", r );
4683     ok( len == 0, "len %d\n", len);
4684
4685     IXMLDOMNodeList_Release( fo_list );
4686
4687     IXMLDOMNode_Release(ba_node);
4688     IXMLDOMNode_Release(fo_node);
4689     IXMLDOMNode_Release(temp_node);
4690     IXMLDOMNodeList_Release( root_list );
4691     IXMLDOMElement_Release( element );
4692     IXMLDOMDocument_Release( doc );
4693
4694     free_bstrs();
4695 }
4696
4697 static void test_removeNamedItem(void)
4698 {
4699     IXMLDOMDocument *doc;
4700     IXMLDOMElement *element;
4701     IXMLDOMNode *pr_node, *removed_node, *removed_node2;
4702     IXMLDOMNodeList *root_list;
4703     IXMLDOMNamedNodeMap * pr_attrs;
4704     VARIANT_BOOL b;
4705     BSTR str;
4706     LONG len;
4707     HRESULT r;
4708
4709     doc = create_document(&IID_IXMLDOMDocument);
4710     if (!doc) return;
4711
4712     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
4713     ok( r == S_OK, "loadXML failed\n");
4714     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4715
4716     r = IXMLDOMDocument_get_documentElement( doc, &element );
4717     ok( r == S_OK, "ret %08x\n", r);
4718
4719     r = IXMLDOMElement_get_childNodes( element, &root_list );
4720     ok( r == S_OK, "ret %08x\n", r);
4721
4722     r = IXMLDOMNodeList_get_item( root_list, 1, &pr_node );
4723     ok( r == S_OK, "ret %08x\n", r);
4724
4725     r = IXMLDOMNode_get_attributes( pr_node, &pr_attrs );
4726     ok( r == S_OK, "ret %08x\n", r);
4727
4728     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4729     ok( r == S_OK, "ret %08x\n", r);
4730     ok( len == 3, "length %d\n", len);
4731
4732     removed_node = (void*)0xdeadbeef;
4733     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, NULL, &removed_node);
4734     ok ( r == E_INVALIDARG, "ret %08x\n", r);
4735     ok ( removed_node == (void*)0xdeadbeef, "got %p\n", removed_node);
4736
4737     removed_node = (void*)0xdeadbeef;
4738     str = SysAllocString(szvr);
4739     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node);
4740     ok ( r == S_OK, "ret %08x\n", r);
4741
4742     removed_node2 = (void*)0xdeadbeef;
4743     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node2);
4744     ok ( r == S_FALSE, "ret %08x\n", r);
4745     ok ( removed_node2 == NULL, "got %p\n", removed_node2 );
4746
4747     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4748     ok( r == S_OK, "ret %08x\n", r);
4749     ok( len == 2, "length %d\n", len);
4750
4751     r = IXMLDOMNamedNodeMap_setNamedItem( pr_attrs, removed_node, NULL);
4752     ok ( r == S_OK, "ret %08x\n", r);
4753     IXMLDOMNode_Release(removed_node);
4754
4755     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4756     ok( r == S_OK, "ret %08x\n", r);
4757     ok( len == 3, "length %d\n", len);
4758
4759     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
4760     ok ( r == S_OK, "ret %08x\n", r);
4761
4762     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
4763     ok( r == S_OK, "ret %08x\n", r);
4764     ok( len == 2, "length %d\n", len);
4765
4766     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
4767     ok ( r == S_FALSE, "ret %08x\n", r);
4768
4769     SysFreeString(str);
4770
4771     IXMLDOMNamedNodeMap_Release( pr_attrs );
4772     IXMLDOMNode_Release( pr_node );
4773     IXMLDOMNodeList_Release( root_list );
4774     IXMLDOMElement_Release( element );
4775     IXMLDOMDocument_Release( doc );
4776
4777     free_bstrs();
4778 }
4779
4780 #define test_IObjectSafety_set(p, r, r2, s, m, e, e2) _test_IObjectSafety_set(__LINE__,p, r, r2, s, m, e, e2)
4781 static void _test_IObjectSafety_set(unsigned line, IObjectSafety *safety, HRESULT result,
4782                                     HRESULT result2, DWORD set, DWORD mask, DWORD expected,
4783                                     DWORD expected2)
4784 {
4785     DWORD enabled, supported;
4786     HRESULT hr;
4787
4788     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL, set, mask);
4789     if (result == result2)
4790         ok_(__FILE__,line)(hr == result, "SetInterfaceSafetyOptions: expected %08x, returned %08x\n", result, hr );
4791     else
4792         ok_(__FILE__,line)(broken(hr == result) || hr == result2,
4793            "SetInterfaceSafetyOptions: expected %08x, got %08x\n", result2, hr );
4794
4795     supported = enabled = 0xCAFECAFE;
4796     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4797     ok(hr == S_OK, "ret %08x\n", hr );
4798     if (expected == expected2)
4799         ok_(__FILE__,line)(enabled == expected, "Expected %08x, got %08x\n", expected, enabled);
4800     else
4801         ok_(__FILE__,line)(broken(enabled == expected) || enabled == expected2,
4802            "Expected %08x, got %08x\n", expected2, enabled);
4803
4804     /* reset the safety options */
4805
4806     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4807             INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER,
4808             0);
4809     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4810
4811     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4812     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4813     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
4814 }
4815
4816 #define test_IObjectSafety_common(s) _test_IObjectSafety_common(__LINE__,s)
4817 static void _test_IObjectSafety_common(unsigned line, IObjectSafety *safety)
4818 {
4819     DWORD enabled = 0, supported = 0;
4820     HRESULT hr;
4821
4822     /* get */
4823     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, NULL, &enabled);
4824     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
4825     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, NULL);
4826     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
4827
4828     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4829     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4830     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4831        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4832         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4833              "got %08x\n", supported);
4834     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
4835
4836     /* set -- individual flags */
4837
4838     test_IObjectSafety_set(safety, S_OK, S_OK,
4839         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4840         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4841
4842     test_IObjectSafety_set(safety, S_OK, S_OK,
4843         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA,
4844         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA);
4845
4846     test_IObjectSafety_set(safety, S_OK, S_OK,
4847         INTERFACE_USES_SECURITY_MANAGER, INTERFACE_USES_SECURITY_MANAGER,
4848         0, INTERFACE_USES_SECURITY_MANAGER /* msxml3 SP8+ */);
4849
4850     /* set INTERFACE_USES_DISPEX  */
4851
4852     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
4853         INTERFACE_USES_DISPEX, INTERFACE_USES_DISPEX,
4854         0, 0);
4855
4856     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
4857         INTERFACE_USES_DISPEX, 0,
4858         0, 0);
4859
4860     test_IObjectSafety_set(safety, S_OK, S_OK /* msxml3 SP8+ */,
4861         0, INTERFACE_USES_DISPEX,
4862         0, 0);
4863
4864     /* set option masking */
4865
4866     test_IObjectSafety_set(safety, S_OK, S_OK,
4867         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4868         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4869         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4870         INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4871
4872     test_IObjectSafety_set(safety, S_OK, S_OK,
4873         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4874         INTERFACESAFE_FOR_UNTRUSTED_DATA,
4875         INTERFACESAFE_FOR_UNTRUSTED_DATA,
4876         INTERFACESAFE_FOR_UNTRUSTED_DATA);
4877
4878     test_IObjectSafety_set(safety, S_OK, S_OK,
4879         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
4880         INTERFACE_USES_SECURITY_MANAGER,
4881         0,
4882         0);
4883
4884     /* set -- inheriting previous settings */
4885
4886     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4887                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER,
4888                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER);
4889     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4890     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4891     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4892     ok_(__FILE__,line)(enabled == INTERFACESAFE_FOR_UNTRUSTED_CALLER, "Expected INTERFACESAFE_FOR_UNTRUSTED_CALLER got %08x\n", enabled);
4893     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4894        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4895         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4896              "got %08x\n", supported);
4897
4898     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
4899                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA,
4900                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA);
4901     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4902     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
4903     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
4904     ok_(__FILE__,line)(broken(enabled == INTERFACESAFE_FOR_UNTRUSTED_DATA) ||
4905                        enabled == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA),
4906                        "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA) got %08x\n", enabled);
4907     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
4908        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
4909         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
4910              "got %08x\n", supported);
4911 }
4912
4913 static void test_XMLHTTP(void)
4914 {
4915     static const char bodyA[] = "mode=Test";
4916     static const char urlA[] = "http://crossover.codeweavers.com/posttest.php";
4917     static const char xmltestA[] = "http://crossover.codeweavers.com/xmltest.xml";
4918     static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
4919     static const CHAR xmltestbodyA[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<a>TEST</a>\n";
4920
4921     IXMLHttpRequest *xhr;
4922     IObjectSafety *safety;
4923     IObjectWithSite *obj_site, *obj_site2;
4924     BSTR bstrResponse, str, str1;
4925     VARIANT varbody, varbody_ref;
4926     VARIANT dummy;
4927     VARIANT async;
4928     LONG state, status, bound;
4929     IDispatch *event;
4930     void *ptr;
4931     HRESULT hr;
4932     HGLOBAL g;
4933
4934     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
4935         &IID_IXMLHttpRequest, (void**)&xhr);
4936     if (FAILED(hr))
4937     {
4938         win_skip("IXMLHTTPRequest is not available (0x%08x)\n", hr);
4939         return;
4940     }
4941
4942     VariantInit(&dummy);
4943     V_VT(&dummy) = VT_ERROR;
4944     V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
4945     VariantInit(&async);
4946     V_VT(&async) = VT_BOOL;
4947     V_BOOL(&async) = VARIANT_FALSE;
4948
4949     hr = IXMLHttpRequest_put_onreadystatechange(xhr, NULL);
4950     EXPECT_HR(hr, S_OK);
4951
4952     hr = IXMLHttpRequest_abort(xhr);
4953     EXPECT_HR(hr, S_OK);
4954
4955     V_VT(&varbody) = VT_I2;
4956     V_I2(&varbody) = 1;
4957     hr = IXMLHttpRequest_get_responseBody(xhr, &varbody);
4958     EXPECT_HR(hr, E_PENDING);
4959     ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody));
4960     ok(V_I2(&varbody) == 1, "got %d\n", V_I2(&varbody));
4961
4962     V_VT(&varbody) = VT_I2;
4963     V_I2(&varbody) = 1;
4964     hr = IXMLHttpRequest_get_responseStream(xhr, &varbody);
4965     EXPECT_HR(hr, E_PENDING);
4966     ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody));
4967     ok(V_I2(&varbody) == 1, "got %d\n", V_I2(&varbody));
4968
4969     /* send before open */
4970     hr = IXMLHttpRequest_send(xhr, dummy);
4971     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4972
4973     /* initial status code */
4974     hr = IXMLHttpRequest_get_status(xhr, NULL);
4975     EXPECT_HR(hr, E_INVALIDARG);
4976
4977     status = 0xdeadbeef;
4978     hr = IXMLHttpRequest_get_status(xhr, &status);
4979     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
4980     ok(status == 0xdeadbeef, "got %d\n", status);
4981
4982     hr = IXMLHttpRequest_get_statusText(xhr, &str);
4983     ok(hr == E_FAIL, "got 0x%08x\n", hr);
4984
4985     /* invalid parameters */
4986     hr = IXMLHttpRequest_open(xhr, NULL, NULL, async, dummy, dummy);
4987     EXPECT_HR(hr, E_INVALIDARG);
4988
4989     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), NULL, async, dummy, dummy);
4990     EXPECT_HR(hr, E_INVALIDARG);
4991
4992     hr = IXMLHttpRequest_open(xhr, NULL, _bstr_(urlA), async, dummy, dummy);
4993     EXPECT_HR(hr, E_INVALIDARG);
4994
4995     hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, NULL);
4996     EXPECT_HR(hr, E_INVALIDARG);
4997
4998     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), NULL);
4999     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
5000
5001     hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
5002     EXPECT_HR(hr, E_INVALIDARG);
5003
5004     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
5005     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
5006
5007     hr = IXMLHttpRequest_get_readyState(xhr, NULL);
5008     EXPECT_HR(hr, E_INVALIDARG);
5009
5010     state = -1;
5011     hr = IXMLHttpRequest_get_readyState(xhr, &state);
5012     EXPECT_HR(hr, S_OK);
5013     ok(state == READYSTATE_UNINITIALIZED, "got %d, expected READYSTATE_UNINITIALIZED\n", state);
5014
5015     event = create_dispevent();
5016
5017     EXPECT_REF(event, 1);
5018     hr = IXMLHttpRequest_put_onreadystatechange(xhr, event);
5019     EXPECT_HR(hr, S_OK);
5020     EXPECT_REF(event, 2);
5021
5022     g_unexpectedcall = g_expectedcall = 0;
5023
5024     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), _bstr_(urlA), async, dummy, dummy);
5025     EXPECT_HR(hr, S_OK);
5026
5027     ok(g_unexpectedcall == 0, "unexpected disp event call\n");
5028     ok(g_expectedcall == 1 || broken(g_expectedcall == 0) /* win2k */, "no expected disp event call\n");
5029
5030     /* status code after ::open() */
5031     status = 0xdeadbeef;
5032     hr = IXMLHttpRequest_get_status(xhr, &status);
5033     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
5034     ok(status == 0xdeadbeef, "got %d\n", status);
5035
5036     state = -1;
5037     hr = IXMLHttpRequest_get_readyState(xhr, &state);
5038     EXPECT_HR(hr, S_OK);
5039     ok(state == READYSTATE_LOADING, "got %d, expected READYSTATE_LOADING\n", state);
5040
5041     hr = IXMLHttpRequest_abort(xhr);
5042     EXPECT_HR(hr, S_OK);
5043
5044     state = -1;
5045     hr = IXMLHttpRequest_get_readyState(xhr, &state);
5046     EXPECT_HR(hr, S_OK);
5047     ok(state == READYSTATE_UNINITIALIZED || broken(state == READYSTATE_LOADING) /* win2k */,
5048         "got %d, expected READYSTATE_UNINITIALIZED\n", state);
5049
5050     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), _bstr_(urlA), async, dummy, dummy);
5051     EXPECT_HR(hr, S_OK);
5052
5053     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
5054     EXPECT_HR(hr, S_OK);
5055
5056     hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
5057     EXPECT_HR(hr, E_INVALIDARG);
5058
5059     hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_(""), _bstr_("value1"));
5060     EXPECT_HR(hr, E_INVALIDARG);
5061
5062     V_VT(&varbody) = VT_BSTR;
5063     V_BSTR(&varbody) = _bstr_(bodyA);
5064
5065     hr = IXMLHttpRequest_send(xhr, varbody);
5066     if (hr == INET_E_RESOURCE_NOT_FOUND)
5067     {
5068         skip("No connection could be made with crossover.codeweavers.com\n");
5069         IXMLHttpRequest_Release(xhr);
5070         return;
5071     }
5072     EXPECT_HR(hr, S_OK);
5073
5074     /* response headers */
5075     hr = IXMLHttpRequest_getAllResponseHeaders(xhr, NULL);
5076     EXPECT_HR(hr, E_INVALIDARG);
5077     hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str);
5078     EXPECT_HR(hr, S_OK);
5079     /* status line is stripped already */
5080     ok(memcmp(str, _bstr_("HTTP"), 4*sizeof(WCHAR)), "got response headers %s\n", wine_dbgstr_w(str));
5081     ok(*str, "got empty headers\n");
5082     hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str1);
5083     EXPECT_HR(hr, S_OK);
5084     ok(str1 != str, "got %p\n", str1);
5085     SysFreeString(str1);
5086     SysFreeString(str);
5087
5088     hr = IXMLHttpRequest_getResponseHeader(xhr, NULL, NULL);
5089     EXPECT_HR(hr, E_INVALIDARG);
5090     hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), NULL);
5091     EXPECT_HR(hr, E_INVALIDARG);
5092     hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), &str);
5093     EXPECT_HR(hr, S_OK);
5094     ok(*str != ' ', "got leading space in header %s\n", wine_dbgstr_w(str));
5095     SysFreeString(str);
5096
5097     /* status code after ::send() */
5098     status = 0xdeadbeef;
5099     hr = IXMLHttpRequest_get_status(xhr, &status);
5100     EXPECT_HR(hr, S_OK);
5101     ok(status == 200, "got %d\n", status);
5102
5103     hr = IXMLHttpRequest_get_statusText(xhr, NULL);
5104     EXPECT_HR(hr, E_INVALIDARG);
5105
5106     hr = IXMLHttpRequest_get_statusText(xhr, &str);
5107     EXPECT_HR(hr, S_OK);
5108     ok(!lstrcmpW(str, _bstr_("OK")), "got status %s\n", wine_dbgstr_w(str));
5109     SysFreeString(str);
5110
5111     /* another ::send() after completed request */
5112     V_VT(&varbody) = VT_BSTR;
5113     V_BSTR(&varbody) = _bstr_(bodyA);
5114
5115     hr = IXMLHttpRequest_send(xhr, varbody);
5116     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
5117
5118     hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
5119     EXPECT_HR(hr, S_OK);
5120     /* the server currently returns "FAILED" because the Content-Type header is
5121      * not what the server expects */
5122     if(hr == S_OK)
5123     {
5124         ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)),
5125             "expected %s, got %s\n", wine_dbgstr_w(wszExpectedResponse), wine_dbgstr_w(bstrResponse));
5126         SysFreeString(bstrResponse);
5127     }
5128
5129     /* POST: VT_VARIANT|VT_BYREF body */
5130     V_VT(&varbody_ref) = VT_VARIANT|VT_BYREF;
5131     V_VARIANTREF(&varbody_ref) = &varbody;
5132     hr = IXMLHttpRequest_open(xhr, _bstr_("POST"), _bstr_(urlA), async, dummy, dummy);
5133     EXPECT_HR(hr, S_OK);
5134     hr = IXMLHttpRequest_send(xhr, varbody_ref);
5135     EXPECT_HR(hr, S_OK);
5136
5137     /* GET request */
5138     hr = IXMLHttpRequest_open(xhr, _bstr_("GET"), _bstr_(xmltestA), async, dummy, dummy);
5139     EXPECT_HR(hr, S_OK);
5140
5141     V_VT(&varbody) = VT_EMPTY;
5142
5143     hr = IXMLHttpRequest_send(xhr, varbody);
5144     if (hr == INET_E_RESOURCE_NOT_FOUND)
5145     {
5146         skip("No connection could be made with crossover.codeweavers.com\n");
5147         IXMLHttpRequest_Release(xhr);
5148         return;
5149     }
5150     EXPECT_HR(hr, S_OK);
5151
5152     hr = IXMLHttpRequest_get_responseText(xhr, NULL);
5153     EXPECT_HR(hr, E_INVALIDARG);
5154
5155     hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
5156     EXPECT_HR(hr, S_OK);
5157     ok(!memcmp(bstrResponse, _bstr_(xmltestbodyA), sizeof(xmltestbodyA)*sizeof(WCHAR)),
5158         "expected %s, got %s\n", xmltestbodyA, wine_dbgstr_w(bstrResponse));
5159     SysFreeString(bstrResponse);
5160
5161     hr = IXMLHttpRequest_get_responseBody(xhr, NULL);
5162     EXPECT_HR(hr, E_INVALIDARG);
5163
5164     V_VT(&varbody) = VT_EMPTY;
5165     hr = IXMLHttpRequest_get_responseBody(xhr, &varbody);
5166     EXPECT_HR(hr, S_OK);
5167     ok(V_VT(&varbody) == (VT_ARRAY|VT_UI1), "got type %d, expected %d\n", V_VT(&varbody), VT_ARRAY|VT_UI1);
5168     ok(SafeArrayGetDim(V_ARRAY(&varbody)) == 1, "got %d, expected one dimension\n", SafeArrayGetDim(V_ARRAY(&varbody)));
5169
5170     bound = -1;
5171     hr = SafeArrayGetLBound(V_ARRAY(&varbody), 1, &bound);
5172     EXPECT_HR(hr, S_OK);
5173     ok(bound == 0, "got %d, expected zero bound\n", bound);
5174
5175     hr = SafeArrayAccessData(V_ARRAY(&varbody), &ptr);
5176     EXPECT_HR(hr, S_OK);
5177     ok(memcmp(ptr, xmltestbodyA, sizeof(xmltestbodyA)-1) == 0, "got wrong body data\n");
5178     SafeArrayUnaccessData(V_ARRAY(&varbody));
5179
5180     VariantClear(&varbody);
5181
5182     /* get_responseStream */
5183     hr = IXMLHttpRequest_get_responseStream(xhr, NULL);
5184     EXPECT_HR(hr, E_INVALIDARG);
5185
5186     V_VT(&varbody) = VT_EMPTY;
5187     hr = IXMLHttpRequest_get_responseStream(xhr, &varbody);
5188     ok(V_VT(&varbody) == VT_UNKNOWN, "got type %d\n", V_VT(&varbody));
5189     EXPECT_HR(hr, S_OK);
5190     EXPECT_REF(V_UNKNOWN(&varbody), 1);
5191
5192     g = NULL;
5193     hr = GetHGlobalFromStream((IStream*)V_UNKNOWN(&varbody), &g);
5194     EXPECT_HR(hr, S_OK);
5195     ok(g != NULL, "got %p\n", g);
5196
5197     hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectSafety, (void**)&safety);
5198     EXPECT_HR(hr, S_OK);
5199     if(hr == S_OK)
5200     {
5201         test_IObjectSafety_common(safety);
5202         IObjectSafety_Release(safety);
5203     }
5204
5205     IDispatch_Release(event);
5206
5207     /* interaction with object site */
5208     EXPECT_REF(xhr, 1);
5209     hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site);
5210     EXPECT_HR(hr, S_OK);
5211 todo_wine {
5212     EXPECT_REF(xhr, 1);
5213     EXPECT_REF(obj_site, 1);
5214 }
5215
5216     IObjectWithSite_AddRef(obj_site);
5217 todo_wine {
5218     EXPECT_REF(obj_site, 2);
5219     EXPECT_REF(xhr, 1);
5220 }
5221     IObjectWithSite_Release(obj_site);
5222
5223     hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site2);
5224     EXPECT_HR(hr, S_OK);
5225 todo_wine {
5226     EXPECT_REF(xhr, 1);
5227     EXPECT_REF(obj_site, 1);
5228     EXPECT_REF(obj_site2, 1);
5229     ok(obj_site != obj_site2, "expected new instance\n");
5230 }
5231     SET_EXPECT(site_qi_IServiceProvider);
5232     SET_EXPECT(sp_queryservice_SID_SBindHost);
5233     SET_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
5234     SET_EXPECT(sp_queryservice_SID_secmgr_htmldoc2);
5235     SET_EXPECT(sp_queryservice_SID_secmgr_xmldomdoc);
5236     SET_EXPECT(sp_queryservice_SID_secmgr_secmgr);
5237
5238     /* calls to IHTMLDocument2 */
5239     SET_EXPECT(htmldoc2_get_all);
5240     SET_EXPECT(collection_get_length);
5241     SET_EXPECT(htmldoc2_get_url);
5242
5243     SET_EXPECT(site_qi_IXMLDOMDocument);
5244     SET_EXPECT(site_qi_IOleClientSite);
5245
5246     hr = IObjectWithSite_SetSite(obj_site, &testsite.IUnknown_iface);
5247     EXPECT_HR(hr, S_OK);
5248
5249     CHECK_CALLED(site_qi_IServiceProvider);
5250 todo_wine
5251     CHECK_CALLED(sp_queryservice_SID_SBindHost);
5252     CHECK_CALLED(sp_queryservice_SID_SContainerDispatch_htmldoc2);
5253 todo_wine {
5254     CHECK_CALLED(sp_queryservice_SID_secmgr_htmldoc2);
5255     CHECK_CALLED(sp_queryservice_SID_secmgr_xmldomdoc);
5256     /* this one isn't very reliable
5257     CHECK_CALLED(sp_queryservice_SID_secmgr_secmgr); */
5258
5259     CHECK_CALLED(htmldoc2_get_all);
5260     CHECK_CALLED(collection_get_length);
5261     CHECK_CALLED(htmldoc2_get_url);
5262
5263     CHECK_CALLED(site_qi_IXMLDOMDocument);
5264     CHECK_CALLED(site_qi_IOleClientSite);
5265 }
5266     IObjectWithSite_Release(obj_site);
5267
5268     /* try to set site another time */
5269
5270     /* to be removed once IObjectWithSite is properly separated */
5271     SET_EXPECT(site_qi_IServiceProvider);
5272     SET_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
5273
5274     hr = IObjectWithSite_SetSite(obj_site2, &testsite.IUnknown_iface);
5275     EXPECT_HR(hr, S_OK);
5276
5277     todo_wine EXPECT_REF(xhr, 1);
5278     IXMLHttpRequest_Release(xhr);
5279
5280     /* still works after request is released */
5281
5282     /* to be removed once IObjectWithSite is properly separated */
5283     SET_EXPECT(site_qi_IServiceProvider);
5284     SET_EXPECT(sp_queryservice_SID_SContainerDispatch_htmldoc2);
5285
5286     hr = IObjectWithSite_SetSite(obj_site2, &testsite.IUnknown_iface);
5287     EXPECT_HR(hr, S_OK);
5288     IObjectWithSite_Release(obj_site2);
5289
5290     free_bstrs();
5291 }
5292
5293 static void test_IXMLDOMDocument2(void)
5294 {
5295     static const WCHAR emptyW[] = {0};
5296     IXMLDOMDocument2 *doc2, *dtddoc2;
5297     IXMLDOMDocument *doc;
5298     IXMLDOMParseError* err;
5299     IDispatchEx *dispex;
5300     VARIANT_BOOL b;
5301     VARIANT var;
5302     HRESULT r;
5303     LONG res;
5304
5305     doc = create_document(&IID_IXMLDOMDocument);
5306     if (!doc) return;
5307
5308     dtddoc2 = create_document(&IID_IXMLDOMDocument2);
5309     if (!dtddoc2)
5310     {
5311         IXMLDOMDocument_Release(doc);
5312         return;
5313     }
5314
5315     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
5316     ok( r == S_OK, "ret %08x\n", r );
5317     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
5318
5319     ole_expect(IXMLDOMDocument2_get_readyState(doc2, NULL), E_INVALIDARG);
5320     ole_check(IXMLDOMDocument2_get_readyState(doc2, &res));
5321     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
5322
5323     err = NULL;
5324     ole_expect(IXMLDOMDocument2_validate(doc2, NULL), S_FALSE);
5325     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
5326     ok(err != NULL, "expected a pointer\n");
5327     if (err)
5328     {
5329         res = 0;
5330         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5331         /* XML_E_NOTWF */
5332         ok(res == E_XML_NOTWF, "got %08x\n", res);
5333         IXMLDOMParseError_Release(err);
5334     }
5335
5336     r = IXMLDOMDocument2_loadXML( doc2, _bstr_(complete4A), &b );
5337     ok( r == S_OK, "loadXML failed\n");
5338     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5339
5340     ole_check(IXMLDOMDocument_get_readyState(doc, &res));
5341     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
5342
5343     err = NULL;
5344     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
5345     ok(err != NULL, "expected a pointer\n");
5346     if (err)
5347     {
5348         res = 0;
5349         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5350         /* XML_E_NODTD */
5351         ok(res == E_XML_NODTD, "got %08x\n", res);
5352         IXMLDOMParseError_Release(err);
5353     }
5354
5355     r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
5356     ok( r == S_OK, "ret %08x\n", r );
5357     if(r == S_OK)
5358     {
5359         IDispatchEx_Release(dispex);
5360     }
5361
5362     /* we will check if the variant got cleared */
5363     IXMLDOMDocument2_AddRef(doc2);
5364     EXPECT_REF(doc2, 3); /* doc, doc2, AddRef*/
5365
5366     V_VT(&var) = VT_UNKNOWN;
5367     V_UNKNOWN(&var) = (IUnknown *)doc2;
5368
5369     /* invalid calls */
5370     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
5371     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
5372     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
5373
5374     /* valid call */
5375     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
5376     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
5377     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
5378     V_VT(&var) = VT_R4;
5379
5380     /* the variant didn't get cleared*/
5381     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
5382
5383     /* setProperty tests */
5384     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
5385     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
5386     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
5387     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
5388     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5389     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
5390
5391     V_VT(&var) = VT_BSTR;
5392     V_BSTR(&var) = SysAllocString(emptyW);
5393     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
5394     ok(r == S_OK, "got 0x%08x\n", r);
5395     VariantClear(&var);
5396
5397     V_VT(&var) = VT_I2;
5398     V_I2(&var) = 0;
5399     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
5400     ok(r == E_FAIL, "got 0x%08x\n", r);
5401
5402     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
5403     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
5404     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
5405     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
5406
5407     IXMLDOMDocument2_Release( doc2 );
5408     IXMLDOMDocument_Release( doc );
5409
5410     /* DTD validation */
5411     ole_check(IXMLDOMDocument2_put_validateOnParse(dtddoc2, VARIANT_FALSE));
5412     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML), &b));
5413     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5414     err = NULL;
5415     ole_check(IXMLDOMDocument2_validate(dtddoc2, &err));
5416     ok(err != NULL, "expected pointer\n");
5417     if (err)
5418     {
5419         res = 0;
5420         ole_expect(IXMLDOMParseError_get_errorCode(err, &res), S_FALSE);
5421         ok(res == 0, "got %08x\n", res);
5422         IXMLDOMParseError_Release(err);
5423     }
5424
5425     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0D), &b));
5426     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5427     err = NULL;
5428     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5429     ok(err != NULL, "expected pointer\n");
5430     if (err)
5431     {
5432         res = 0;
5433         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5434         /* XML_ELEMENT_UNDECLARED */
5435         todo_wine ok(res == 0xC00CE00D, "got %08x\n", res);
5436         IXMLDOMParseError_Release(err);
5437     }
5438
5439     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0E), &b));
5440     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5441     err = NULL;
5442     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5443     ok(err != NULL, "expected pointer\n");
5444     if (err)
5445     {
5446         res = 0;
5447         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5448         /* XML_ELEMENT_ID_NOT_FOUND */
5449         todo_wine ok(res == 0xC00CE00E, "got %08x\n", res);
5450         IXMLDOMParseError_Release(err);
5451     }
5452
5453     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_11), &b));
5454     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5455     err = NULL;
5456     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5457     ok(err != NULL, "expected pointer\n");
5458     if (err)
5459     {
5460         res = 0;
5461         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5462         /* XML_EMPTY_NOT_ALLOWED */
5463         todo_wine ok(res == 0xC00CE011, "got %08x\n", res);
5464         IXMLDOMParseError_Release(err);
5465     }
5466
5467     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_13), &b));
5468     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5469     err = NULL;
5470     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5471     ok(err != NULL, "expected pointer\n");
5472     if (err)
5473     {
5474         res = 0;
5475         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5476         /* XML_ROOT_NAME_MISMATCH */
5477         todo_wine ok(res == 0xC00CE013, "got %08x\n", res);
5478         IXMLDOMParseError_Release(err);
5479     }
5480
5481     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_14), &b));
5482     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5483     err = NULL;
5484     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5485     ok(err != NULL, "expected pointer\n");
5486     if (err)
5487     {
5488         res = 0;
5489         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5490         /* XML_INVALID_CONTENT */
5491         todo_wine ok(res == 0xC00CE014, "got %08x\n", res);
5492         IXMLDOMParseError_Release(err);
5493     }
5494
5495     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_15), &b));
5496     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5497     err = NULL;
5498     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5499     ok(err != NULL, "expected pointer\n");
5500     if (err)
5501     {
5502         res = 0;
5503         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5504         /* XML_ATTRIBUTE_NOT_DEFINED */
5505         todo_wine ok(res == 0xC00CE015, "got %08x\n", res);
5506         IXMLDOMParseError_Release(err);
5507     }
5508
5509     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_16), &b));
5510     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5511     err = NULL;
5512     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5513     ok(err != NULL, "expected pointer\n");
5514     if (err)
5515     {
5516         res = 0;
5517         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5518         /* XML_ATTRIBUTE_FIXED */
5519         todo_wine ok(res == 0xC00CE016, "got %08x\n", res);
5520         IXMLDOMParseError_Release(err);
5521     }
5522
5523     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_17), &b));
5524     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5525     err = NULL;
5526     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5527     ok(err != NULL, "expected pointer\n");
5528     if (err)
5529     {
5530         res = 0;
5531         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5532         /* XML_ATTRIBUTE_VALUE */
5533         todo_wine ok(res == 0xC00CE017, "got %08x\n", res);
5534         IXMLDOMParseError_Release(err);
5535     }
5536
5537     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_18), &b));
5538     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5539     err = NULL;
5540     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5541     ok(err != NULL, "expected pointer\n");
5542     if (err)
5543     {
5544         res = 0;
5545         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5546         /* XML_ILLEGAL_TEXT */
5547         todo_wine ok(res == 0xC00CE018, "got %08x\n", res);
5548         IXMLDOMParseError_Release(err);
5549     }
5550
5551     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_20), &b));
5552     ok( b == VARIANT_TRUE, "failed to load XML string\n");
5553     err = NULL;
5554     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
5555     ok(err != NULL, "expected pointer\n");
5556     if (err)
5557     {
5558         res = 0;
5559         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
5560         /* XML_REQUIRED_ATTRIBUTE_MISSING */
5561         todo_wine ok(res == 0xC00CE020, "got %08x\n", res);
5562         IXMLDOMParseError_Release(err);
5563     }
5564
5565     IXMLDOMDocument2_Release( dtddoc2 );
5566     free_bstrs();
5567 }
5568
5569 #define helper_ole_check(expr) { \
5570     HRESULT r = expr; \
5571     ok_(__FILE__, line)(r == S_OK, "=> %i: " #expr " returned %08x\n", __LINE__, r); \
5572 }
5573
5574 #define helper_expect_list_and_release(list, expstr) { \
5575     char *str = list_to_string(list); \
5576     ok_(__FILE__, line)(strcmp(str, expstr)==0, "=> %i: Invalid node list: %s, expected %s\n", __LINE__, str, expstr); \
5577     if (list) IXMLDOMNodeList_Release(list); \
5578 }
5579
5580 #define helper_expect_bstr_and_release(bstr, str) { \
5581     ok_(__FILE__, line)(lstrcmpW(bstr, _bstr_(str)) == 0, \
5582        "=> %i: got %s\n", __LINE__, wine_dbgstr_w(bstr)); \
5583     SysFreeString(bstr); \
5584 }
5585
5586 #define check_ws_ignored(doc, str) _check_ws_ignored(__LINE__, doc, str)
5587 static inline void _check_ws_ignored(int line, IXMLDOMDocument2* doc, char const* str)
5588 {
5589     IXMLDOMNode *node1, *node2;
5590     IXMLDOMNodeList *list;
5591     BSTR bstr;
5592
5593     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
5594     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
5595     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
5596     helper_ole_check(IXMLDOMNodeList_reset(list));
5597     helper_expect_list_and_release(list, "E1.E5.E1.E2.D1 E2.E5.E1.E2.D1");
5598
5599     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
5600     helper_expect_list_and_release(list, "T1.E1.E5.E1.E2.D1 E2.E1.E5.E1.E2.D1 E3.E1.E5.E1.E2.D1 T4.E1.E5.E1.E2.D1 E5.E1.E5.E1.E2.D1");
5601     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
5602     if (str)
5603     {
5604         helper_expect_bstr_and_release(bstr, str);
5605     }
5606     else
5607     {
5608         helper_expect_bstr_and_release(bstr, "This is a description.");
5609     }
5610     IXMLDOMNode_Release(node1);
5611
5612     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
5613     helper_expect_list_and_release(list, "T1.E2.E5.E1.E2.D1 E2.E2.E5.E1.E2.D1 T3.E2.E5.E1.E2.D1 E4.E2.E5.E1.E2.D1 T5.E2.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1 T7.E2.E5.E1.E2.D1");
5614     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
5615     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
5616     IXMLDOMNode_Release(node2);
5617 }
5618
5619 #define check_ws_preserved(doc, str) _check_ws_preserved(__LINE__, doc, str)
5620 static inline void _check_ws_preserved(int line, IXMLDOMDocument2* doc, char const* str)
5621 {
5622     IXMLDOMNode *node1, *node2;
5623     IXMLDOMNodeList *list;
5624     BSTR bstr;
5625
5626     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
5627     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
5628     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
5629     helper_ole_check(IXMLDOMNodeList_reset(list));
5630     helper_expect_list_and_release(list, "E2.E10.E2.E2.D1 E4.E10.E2.E2.D1");
5631
5632     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
5633     helper_expect_list_and_release(list, "T1.E2.E10.E2.E2.D1 E2.E2.E10.E2.E2.D1 T3.E2.E10.E2.E2.D1 E4.E2.E10.E2.E2.D1 T5.E2.E10.E2.E2.D1 E6.E2.E10.E2.E2.D1 T7.E2.E10.E2.E2.D1");
5634     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
5635     if (str)
5636     {
5637         helper_expect_bstr_and_release(bstr, str);
5638     }
5639     else
5640     {
5641         helper_expect_bstr_and_release(bstr, "\n                This is a description. \n            ");
5642     }
5643     IXMLDOMNode_Release(node1);
5644
5645     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
5646     helper_expect_list_and_release(list, "T1.E4.E10.E2.E2.D1 E2.E4.E10.E2.E2.D1 T3.E4.E10.E2.E2.D1 E4.E4.E10.E2.E2.D1 T5.E4.E10.E2.E2.D1 E6.E4.E10.E2.E2.D1 T7.E4.E10.E2.E2.D1");
5647     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
5648     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
5649     IXMLDOMNode_Release(node2);
5650 }
5651
5652 static void test_whitespace(void)
5653 {
5654     VARIANT_BOOL b;
5655     IXMLDOMDocument2 *doc1, *doc2, *doc3, *doc4;
5656
5657     doc1 = create_document(&IID_IXMLDOMDocument2);
5658     doc2 = create_document(&IID_IXMLDOMDocument2);
5659     if (!doc1 || !doc2) return;
5660
5661     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_TRUE));
5662     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
5663     ok(b == VARIANT_FALSE, "expected false\n");
5664     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
5665     ok(b == VARIANT_TRUE, "expected true\n");
5666
5667     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
5668     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5669     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
5670     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5671
5672     /* switch to XPath */
5673     ole_check(IXMLDOMDocument2_setProperty(doc1, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5674     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5675
5676     check_ws_ignored(doc1, NULL);
5677     check_ws_preserved(doc2, NULL);
5678
5679     /* new instances copy the property */
5680     ole_check(IXMLDOMDocument2_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**) &doc3));
5681     ole_check(IXMLDOMDocument2_QueryInterface(doc2, &IID_IXMLDOMDocument2, (void**) &doc4));
5682
5683     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
5684     ok(b == VARIANT_FALSE, "expected false\n");
5685     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
5686     ok(b == VARIANT_TRUE, "expected true\n");
5687
5688     check_ws_ignored(doc3, NULL);
5689     check_ws_preserved(doc4, NULL);
5690
5691     /* setting after loading xml affects trimming of leading/trailing ws only */
5692     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_TRUE));
5693     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_FALSE));
5694
5695     /* the trailing "\n            " isn't there, because it was ws-only node */
5696     check_ws_ignored(doc1, "\n                This is a description. ");
5697     check_ws_preserved(doc2, "This is a description.");
5698
5699     /* it takes effect on reload */
5700     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
5701     ok(b == VARIANT_TRUE, "expected true\n");
5702     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
5703     ok(b == VARIANT_FALSE, "expected false\n");
5704
5705     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
5706     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5707     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
5708     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5709
5710     check_ws_preserved(doc1, NULL);
5711     check_ws_ignored(doc2, NULL);
5712
5713     /* other instances follow suit */
5714     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
5715     ok(b == VARIANT_TRUE, "expected true\n");
5716     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
5717     ok(b == VARIANT_FALSE, "expected false\n");
5718
5719     check_ws_preserved(doc3, NULL);
5720     check_ws_ignored(doc4, NULL);
5721
5722     IXMLDOMDocument2_Release(doc1);
5723     IXMLDOMDocument2_Release(doc2);
5724     IXMLDOMDocument2_Release(doc3);
5725     IXMLDOMDocument2_Release(doc4);
5726     free_bstrs();
5727 }
5728
5729 typedef struct {
5730     const GUID *clsid;
5731     const char *name;
5732     const char *ns;
5733     HRESULT hr;
5734 } selection_ns_t;
5735
5736 /* supposed to be tested with szExampleXML */
5737 static const selection_ns_t selection_ns_data[] = {
5738     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5739     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5740     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5741     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
5742
5743     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5744     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5745     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5746     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
5747
5748     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5749     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5750     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5751     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
5752
5753     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5754     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5755     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5756     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
5757
5758     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5759     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5760     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
5761     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
5762
5763     { NULL }
5764 };
5765
5766 static void test_XPath(void)
5767 {
5768     const selection_ns_t *ptr = selection_ns_data;
5769     VARIANT var;
5770     VARIANT_BOOL b;
5771     IXMLDOMDocument2 *doc;
5772     IXMLDOMDocument *doc2;
5773     IXMLDOMNode *rootNode;
5774     IXMLDOMNode *elem1Node;
5775     IXMLDOMNode *node;
5776     IXMLDOMNodeList *list;
5777     IXMLDOMElement *elem;
5778     IXMLDOMAttribute *attr;
5779     DOMNodeType type;
5780     HRESULT hr;
5781     LONG len;
5782     BSTR str;
5783
5784     doc = create_document(&IID_IXMLDOMDocument2);
5785     if (!doc) return;
5786
5787     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5788     EXPECT_HR(hr, S_OK);
5789     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5790
5791     /* switch to XPath */
5792     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
5793
5794     /* some simple queries*/
5795     EXPECT_REF(doc, 1);
5796     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5797     EXPECT_HR(hr, S_OK);
5798     EXPECT_REF(doc, 1);
5799     EXPECT_LIST_LEN(list, 1);
5800
5801     EXPECT_REF(list, 1);
5802     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5803     EXPECT_HR(hr, S_OK);
5804     EXPECT_REF(list, 1);
5805     EXPECT_REF(rootNode, 1);
5806
5807     hr = IXMLDOMNodeList_reset(list);
5808     EXPECT_HR(hr, S_OK);
5809     expect_list_and_release(list, "E2.D1");
5810
5811 if (0)
5812 {
5813     /* namespace:: axis test is disabled until namespace definitions
5814        are supported as attribute nodes, currently it's another node type */
5815     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("/root/namespace::*"), &list);
5816     EXPECT_HR(hr, S_OK);
5817     len = -1;
5818     hr = IXMLDOMNodeList_get_length(list, &len);
5819     EXPECT_HR(hr, S_OK);
5820     ok(len == 2, "got %d\n", len);
5821
5822     hr = IXMLDOMNodeList_nextNode(list, &node);
5823     EXPECT_HR(hr, S_OK);
5824     type = NODE_INVALID;
5825     hr = IXMLDOMNode_get_nodeType(node, &type);
5826     EXPECT_HR(hr, S_OK);
5827     ok(type == NODE_ATTRIBUTE, "got %d\n", type);
5828     IXMLDOMNode_Release(node);
5829
5830     IXMLDOMNodeList_Release(list);
5831 }
5832
5833     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//c"), &list));
5834     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
5835
5836     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//c[@type]"), &list));
5837     expect_list_and_release(list, "E3.E2.E2.D1");
5838
5839     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
5840     /* using get_item for query results advances the position */
5841     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
5842     expect_node(node, "E2.E2.D1");
5843     IXMLDOMNode_Release(node);
5844     ole_check(IXMLDOMNodeList_nextNode(list, &node));
5845     expect_node(node, "E4.E2.D1");
5846     IXMLDOMNode_Release(node);
5847     ole_check(IXMLDOMNodeList_reset(list));
5848     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
5849
5850     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
5851     expect_list_and_release(list, "E2.D1");
5852
5853     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
5854     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
5855     ole_check(IXMLDOMNodeList_reset(list));
5856     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
5857
5858     /* select an attribute */
5859     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
5860     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
5861
5862     /* would evaluate to a number */
5863     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
5864     /* would evaluate to a boolean */
5865     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
5866     /* would evaluate to a string */
5867     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
5868
5869     /* no results */
5870     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
5871     expect_list_and_release(list, "");
5872     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("elem//c"), &list));
5873     expect_list_and_release(list, "");
5874     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem[4]"), &list));
5875     expect_list_and_release(list, "");
5876     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[0]"), &list));
5877     expect_list_and_release(list, "");
5878
5879     /* foo undeclared in document node */
5880     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5881     /* undeclared in <root> node */
5882     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
5883     /* undeclared in <elem> node */
5884     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
5885     /* but this trick can be used */
5886     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
5887     expect_list_and_release(list, "E3.E4.E2.D1");
5888
5889     /* it has to be declared in SelectionNamespaces */
5890     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5891         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
5892
5893     /* now the namespace can be used */
5894     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list));
5895     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5896     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
5897     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5898     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
5899     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
5900     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
5901     expect_list_and_release(list, "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1");
5902
5903     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
5904     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5905         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
5906
5907     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5908
5909     VariantInit(&var);
5910     ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
5911     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
5912     if (V_VT(&var) == VT_BSTR)
5913         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
5914
5915     /* extra attributes - same thing*/
5916     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
5917         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
5918     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
5919
5920     IXMLDOMNode_Release(rootNode);
5921     IXMLDOMNode_Release(elem1Node);
5922
5923     /* alter document with already built list */
5924     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5925     EXPECT_HR(hr, S_OK);
5926     EXPECT_LIST_LEN(list, 1);
5927
5928     hr = IXMLDOMDocument2_get_lastChild(doc, &rootNode);
5929     EXPECT_HR(hr, S_OK);
5930     EXPECT_REF(rootNode, 1);
5931     EXPECT_REF(doc, 1);
5932
5933     hr = IXMLDOMDocument2_removeChild(doc, rootNode, NULL);
5934     EXPECT_HR(hr, S_OK);
5935     IXMLDOMNode_Release(rootNode);
5936
5937     EXPECT_LIST_LEN(list, 1);
5938
5939     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5940     EXPECT_HR(hr, S_OK);
5941     EXPECT_REF(rootNode, 1);
5942
5943     IXMLDOMNodeList_Release(list);
5944
5945     hr = IXMLDOMNode_get_nodeName(rootNode, &str);
5946     EXPECT_HR(hr, S_OK);
5947     ok(!lstrcmpW(str, _bstr_("root")), "got %s\n", wine_dbgstr_w(str));
5948     SysFreeString(str);
5949     IXMLDOMNode_Release(rootNode);
5950
5951     /* alter node from list and get it another time */
5952     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
5953     EXPECT_HR(hr, S_OK);
5954     ok(b == VARIANT_TRUE, "failed to load XML string\n");
5955
5956     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
5957     EXPECT_HR(hr, S_OK);
5958     EXPECT_LIST_LEN(list, 1);
5959
5960     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5961     EXPECT_HR(hr, S_OK);
5962
5963     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
5964     EXPECT_HR(hr, S_OK);
5965
5966     V_VT(&var) = VT_I2;
5967     V_I2(&var) = 1;
5968     hr = IXMLDOMElement_setAttribute(elem, _bstr_("attrtest"), var);
5969     EXPECT_HR(hr, S_OK);
5970     IXMLDOMElement_Release(elem);
5971     IXMLDOMNode_Release(rootNode);
5972
5973     /* now check attribute to be present */
5974     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
5975     EXPECT_HR(hr, S_OK);
5976
5977     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
5978     EXPECT_HR(hr, S_OK);
5979
5980     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
5981     EXPECT_HR(hr, S_OK);
5982     IXMLDOMAttribute_Release(attr);
5983
5984     IXMLDOMElement_Release(elem);
5985     IXMLDOMNode_Release(rootNode);
5986
5987     /* and now check for attribute in original document */
5988     hr = IXMLDOMDocument2_get_documentElement(doc, &elem);
5989     EXPECT_HR(hr, S_OK);
5990
5991     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
5992     EXPECT_HR(hr, S_OK);
5993     IXMLDOMAttribute_Release(attr);
5994
5995     IXMLDOMElement_Release(elem);
5996
5997     /* attach node from list to another document */
5998     doc2 = create_document(&IID_IXMLDOMDocument);
5999
6000     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
6001     EXPECT_HR(hr, S_OK);
6002     ok(b == VARIANT_TRUE, "failed to load XML string\n");
6003
6004     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
6005     EXPECT_HR(hr, S_OK);
6006     EXPECT_LIST_LEN(list, 1);
6007
6008     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
6009     EXPECT_HR(hr, S_OK);
6010     EXPECT_REF(rootNode, 1);
6011
6012     hr = IXMLDOMDocument_appendChild(doc2, rootNode, NULL);
6013     EXPECT_HR(hr, S_OK);
6014     EXPECT_REF(rootNode, 1);
6015     EXPECT_REF(doc2, 1);
6016     EXPECT_REF(list, 1);
6017
6018     EXPECT_LIST_LEN(list, 1);
6019
6020     IXMLDOMNode_Release(rootNode);
6021     IXMLDOMNodeList_Release(list);
6022     IXMLDOMDocument_Release(doc2);
6023     IXMLDOMDocument2_Release(doc);
6024
6025     while (ptr->clsid)
6026     {
6027         hr = CoCreateInstance(ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
6028         if (hr != S_OK)
6029         {
6030             win_skip("can't create instance of %s\n", ptr->name);
6031             ptr++;
6032             continue;
6033         }
6034
6035         hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
6036         EXPECT_HR(hr, S_OK);
6037         ok(b == VARIANT_TRUE, "failed to load, %s\n", ptr->name);
6038
6039         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath"));
6040         EXPECT_HR(hr, S_OK);
6041
6042         V_VT(&var) = VT_BSTR;
6043         V_BSTR(&var) = _bstr_(ptr->ns);
6044
6045         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), var);
6046         ok(hr == ptr->hr, "got 0x%08x, for %s, %s\n", hr, ptr->name, ptr->ns);
6047
6048         V_VT(&var) = VT_EMPTY;
6049         hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var);
6050         EXPECT_HR(hr, S_OK);
6051         ok(V_VT(&var) == VT_BSTR, "got wrong property type %d\n", V_VT(&var));
6052         ok(!lstrcmpW(V_BSTR(&var), _bstr_(ptr->ns)), "got wrong value %s\n", wine_dbgstr_w(V_BSTR(&var)));
6053         VariantClear(&var);
6054
6055         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list);
6056         EXPECT_HR(hr, S_OK);
6057         if (hr == S_OK)
6058             expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
6059
6060         IXMLDOMDocument2_Release(doc);
6061         ptr++;
6062         free_bstrs();
6063     }
6064
6065     free_bstrs();
6066 }
6067
6068 static void test_cloneNode(void )
6069 {
6070     IXMLDOMDocument *doc, *doc2;
6071     VARIANT_BOOL b;
6072     IXMLDOMNodeList *pList;
6073     IXMLDOMNamedNodeMap *mapAttr;
6074     LONG length, length1;
6075     LONG attr_cnt, attr_cnt1;
6076     IXMLDOMNode *node, *attr;
6077     IXMLDOMNode *node_clone;
6078     IXMLDOMNode *node_first;
6079     HRESULT hr;
6080
6081     doc = create_document(&IID_IXMLDOMDocument);
6082     if (!doc) return;
6083
6084     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b));
6085     ok(b == VARIANT_TRUE, "failed to load XML string\n");
6086
6087     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc/pr"), &node);
6088     ok( hr == S_OK, "ret %08x\n", hr );
6089     ok( node != NULL, "node %p\n", node );
6090
6091     /* Check invalid parameter */
6092     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
6093     ok( hr == E_INVALIDARG, "ret %08x\n", hr );
6094
6095     /* All Children */
6096     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
6097     ok( hr == S_OK, "ret %08x\n", hr );
6098     ok( node_clone != NULL, "node %p\n", node );
6099
6100     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
6101     ok( hr == S_OK, "ret %08x\n", hr );
6102     hr = IXMLDOMNode_get_ownerDocument(node_clone, &doc2);
6103     ok( hr == S_OK, "ret %08x\n", hr );
6104     IXMLDOMDocument_Release(doc2);
6105     IXMLDOMNode_Release(node_first);
6106
6107     hr = IXMLDOMNode_get_childNodes(node, &pList);
6108     ok( hr == S_OK, "ret %08x\n", hr );
6109     length = 0;
6110     hr = IXMLDOMNodeList_get_length(pList, &length);
6111     ok( hr == S_OK, "ret %08x\n", hr );
6112     ok(length == 1, "got %d\n", length);
6113     IXMLDOMNodeList_Release(pList);
6114
6115     hr = IXMLDOMNode_get_attributes(node, &mapAttr);
6116     ok( hr == S_OK, "ret %08x\n", hr );
6117     attr_cnt = 0;
6118     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt);
6119     ok( hr == S_OK, "ret %08x\n", hr );
6120     ok(attr_cnt == 3, "got %d\n", attr_cnt);
6121     IXMLDOMNamedNodeMap_Release(mapAttr);
6122
6123     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
6124     ok( hr == S_OK, "ret %08x\n", hr );
6125     length1 = 0;
6126     hr = IXMLDOMNodeList_get_length(pList, &length1);
6127     ok(length1 == 1, "got %d\n", length1);
6128     ok( hr == S_OK, "ret %08x\n", hr );
6129     IXMLDOMNodeList_Release(pList);
6130
6131     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
6132     ok( hr == S_OK, "ret %08x\n", hr );
6133     attr_cnt1 = 0;
6134     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
6135     ok( hr == S_OK, "ret %08x\n", hr );
6136     ok(attr_cnt1 == 3, "got %d\n", attr_cnt1);
6137     /* now really get some attributes from cloned element */
6138     attr = NULL;
6139     hr = IXMLDOMNamedNodeMap_getNamedItem(mapAttr, _bstr_("id"), &attr);
6140     ok(hr == S_OK, "ret %08x\n", hr);
6141     IXMLDOMNode_Release(attr);
6142     IXMLDOMNamedNodeMap_Release(mapAttr);
6143
6144     ok(length == length1, "wrong Child count (%d, %d)\n", length, length1);
6145     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
6146     IXMLDOMNode_Release(node_clone);
6147
6148     /* No Children */
6149     hr = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
6150     ok( hr == S_OK, "ret %08x\n", hr );
6151     ok( node_clone != NULL, "node %p\n", node );
6152
6153     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
6154     ok(hr == S_FALSE, "ret %08x\n", hr );
6155
6156     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
6157     ok(hr == S_OK, "ret %08x\n", hr );
6158     hr = IXMLDOMNodeList_get_length(pList, &length1);
6159     ok(hr == S_OK, "ret %08x\n", hr );
6160     ok( length1 == 0, "Length should be 0 (%d)\n", length1);
6161     IXMLDOMNodeList_Release(pList);
6162
6163     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
6164     ok(hr == S_OK, "ret %08x\n", hr );
6165     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
6166     ok(hr == S_OK, "ret %08x\n", hr );
6167     ok(attr_cnt1 == 3, "Attribute count should be 3 (%d)\n", attr_cnt1);
6168     IXMLDOMNamedNodeMap_Release(mapAttr);
6169
6170     ok(length != length1, "wrong Child count (%d, %d)\n", length, length1);
6171     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
6172     IXMLDOMNode_Release(node_clone);
6173
6174     IXMLDOMNode_Release(node);
6175     IXMLDOMDocument_Release(doc);
6176     free_bstrs();
6177 }
6178
6179 static void test_xmlTypes(void)
6180 {
6181     IXMLDOMDocument *doc;
6182     IXMLDOMElement *pRoot;
6183     HRESULT hr;
6184     IXMLDOMComment *pComment;
6185     IXMLDOMElement *pElement;
6186     IXMLDOMAttribute *pAttribute;
6187     IXMLDOMNamedNodeMap *pAttribs;
6188     IXMLDOMCDATASection *pCDataSec;
6189     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
6190     IXMLDOMDocumentFragment *pDocFrag = NULL;
6191     IXMLDOMEntityReference *pEntityRef = NULL;
6192     BSTR str;
6193     IXMLDOMNode *pNextChild;
6194     VARIANT v;
6195     LONG len = 0;
6196
6197     doc = create_document(&IID_IXMLDOMDocument);
6198     if (!doc) return;
6199
6200     pNextChild = (void*)0xdeadbeef;
6201     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
6202     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6203
6204     pNextChild = (void*)0xdeadbeef;
6205     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
6206     ok(hr == S_FALSE, "ret %08x\n", hr );
6207     ok(pNextChild == NULL, "pDocChild not NULL\n");
6208
6209     /* test previous Sibling */
6210     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
6211     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6212
6213     pNextChild = (void*)0xdeadbeef;
6214     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
6215     ok(hr == S_FALSE, "ret %08x\n", hr );
6216     ok(pNextChild == NULL, "pNextChild not NULL\n");
6217
6218     /* test get_dataType */
6219     V_VT(&v) = VT_EMPTY;
6220     hr = IXMLDOMDocument_get_dataType(doc, &v);
6221     ok(hr == S_FALSE, "ret %08x\n", hr );
6222     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
6223     VariantClear(&v);
6224
6225     /* test implementation */
6226     hr = IXMLDOMDocument_get_implementation(doc, NULL);
6227     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6228
6229     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
6230     ok(hr == S_OK, "ret %08x\n", hr );
6231     if(hr == S_OK)
6232     {
6233         VARIANT_BOOL hasFeature = VARIANT_TRUE;
6234         BSTR sEmpty = SysAllocStringLen(NULL, 0);
6235
6236         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
6237         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6238
6239         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
6240         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6241
6242         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
6243         ok(hr == S_OK, "ret %08x\n", hr );
6244         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
6245
6246         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
6247         ok(hr == S_OK, "ret %08x\n", hr );
6248         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
6249
6250         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
6251         ok(hr == S_OK, "ret %08x\n", hr );
6252         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
6253
6254         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
6255         ok(hr == S_OK, "ret %08x\n", hr );
6256         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
6257
6258         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
6259         ok(hr == S_OK, "ret %08x\n", hr );
6260         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
6261
6262         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
6263         ok(hr == S_OK, "ret %08x\n", hr );
6264         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
6265
6266         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
6267         ok(hr == S_OK, "ret %08x\n", hr );
6268         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
6269
6270         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
6271         ok(hr == S_OK, "ret %08x\n", hr );
6272         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
6273
6274         SysFreeString(sEmpty);
6275         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
6276     }
6277
6278     pRoot = (IXMLDOMElement*)0x1;
6279     hr = IXMLDOMDocument_createElement(doc, NULL, &pRoot);
6280     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6281     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
6282
6283     pRoot = (IXMLDOMElement*)0x1;
6284     hr = IXMLDOMDocument_createElement(doc, _bstr_(""), &pRoot);
6285     ok(hr == E_FAIL, "ret %08x\n", hr );
6286     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
6287
6288     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
6289     ok(hr == S_OK, "ret %08x\n", hr );
6290     if(hr == S_OK)
6291     {
6292         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
6293         ok(hr == S_OK, "ret %08x\n", hr );
6294         if(hr == S_OK)
6295         {
6296             /* Comment */
6297             str = SysAllocString(szComment);
6298             hr = IXMLDOMDocument_createComment(doc, str, &pComment);
6299             SysFreeString(str);
6300             ok(hr == S_OK, "ret %08x\n", hr );
6301             if(hr == S_OK)
6302             {
6303                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
6304                 ok(hr == S_OK, "ret %08x\n", hr );
6305
6306                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
6307                 ok(hr == S_OK, "ret %08x\n", hr );
6308                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
6309                 SysFreeString(str);
6310
6311                 hr = IXMLDOMComment_get_xml(pComment, &str);
6312                 ok(hr == S_OK, "ret %08x\n", hr );
6313                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
6314                 SysFreeString(str);
6315
6316                 /* put data Tests */
6317                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
6318                 ok(hr == S_OK, "ret %08x\n", hr );
6319
6320                 /* get data Tests */
6321                 hr = IXMLDOMComment_get_data(pComment, &str);
6322                 ok(hr == S_OK, "ret %08x\n", hr );
6323                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
6324                 SysFreeString(str);
6325
6326                 /* Confirm XML text is good */
6327                 hr = IXMLDOMComment_get_xml(pComment, &str);
6328                 ok(hr == S_OK, "ret %08x\n", hr );
6329                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
6330                 SysFreeString(str);
6331
6332                 /* Confirm we get the put_data Text back */
6333                 hr = IXMLDOMComment_get_text(pComment, &str);
6334                 ok(hr == S_OK, "ret %08x\n", hr );
6335                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
6336                 SysFreeString(str);
6337
6338                 /* test length property */
6339                 hr = IXMLDOMComment_get_length(pComment, &len);
6340                 ok(hr == S_OK, "ret %08x\n", hr );
6341                 ok(len == 21, "expected 21 got %d\n", len);
6342
6343                 /* test substringData */
6344                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
6345                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6346
6347                 /* test substringData - Invalid offset */
6348                 str = (BSTR)&szElement;
6349                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
6350                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6351                 ok( str == NULL, "incorrect string\n");
6352
6353                 /* test substringData - Invalid offset */
6354                 str = (BSTR)&szElement;
6355                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
6356                 ok(hr == S_FALSE, "ret %08x\n", hr );
6357                 ok( str == NULL, "incorrect string\n");
6358
6359                 /* test substringData - Invalid size */
6360                 str = (BSTR)&szElement;
6361                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
6362                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6363                 ok( str == NULL, "incorrect string\n");
6364
6365                 /* test substringData - Invalid size */
6366                 str = (BSTR)&szElement;
6367                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
6368                 ok(hr == S_FALSE, "ret %08x\n", hr );
6369                 ok( str == NULL, "incorrect string\n");
6370
6371                 /* test substringData - Start of string */
6372                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
6373                 ok(hr == S_OK, "ret %08x\n", hr );
6374                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
6375                 SysFreeString(str);
6376
6377                 /* test substringData - Middle of string */
6378                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
6379                 ok(hr == S_OK, "ret %08x\n", hr );
6380                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
6381                 SysFreeString(str);
6382
6383                 /* test substringData - End of string */
6384                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
6385                 ok(hr == S_OK, "ret %08x\n", hr );
6386                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
6387                 SysFreeString(str);
6388
6389                 /* test appendData */
6390                 hr = IXMLDOMComment_appendData(pComment, NULL);
6391                 ok(hr == S_OK, "ret %08x\n", hr );
6392
6393                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
6394                 ok(hr == S_OK, "ret %08x\n", hr );
6395
6396                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
6397                 ok(hr == S_OK, "ret %08x\n", hr );
6398
6399                 hr = IXMLDOMComment_get_text(pComment, &str);
6400                 ok(hr == S_OK, "ret %08x\n", hr );
6401                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6402                 SysFreeString(str);
6403
6404                 /* test insertData */
6405                 str = SysAllocStringLen(NULL, 0);
6406                 hr = IXMLDOMComment_insertData(pComment, -1, str);
6407                 ok(hr == S_OK, "ret %08x\n", hr );
6408
6409                 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
6410                 ok(hr == S_OK, "ret %08x\n", hr );
6411
6412                 hr = IXMLDOMComment_insertData(pComment, 1000, str);
6413                 ok(hr == S_OK, "ret %08x\n", hr );
6414
6415                 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
6416                 ok(hr == S_OK, "ret %08x\n", hr );
6417
6418                 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
6419                 ok(hr == S_OK, "ret %08x\n", hr );
6420
6421                 hr = IXMLDOMComment_insertData(pComment, 0, str);
6422                 ok(hr == S_OK, "ret %08x\n", hr );
6423                 SysFreeString(str);
6424
6425                 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
6426                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6427
6428                 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
6429                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6430
6431                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
6432                 ok(hr == S_OK, "ret %08x\n", hr );
6433
6434                 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
6435                 ok(hr == S_OK, "ret %08x\n", hr );
6436
6437                 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
6438                 ok(hr == S_OK, "ret %08x\n", hr );
6439
6440                 hr = IXMLDOMComment_get_text(pComment, &str);
6441                 ok(hr == S_OK, "ret %08x\n", hr );
6442                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6443                 SysFreeString(str);
6444
6445                 /* delete data */
6446                 /* invalid arguments */
6447                 hr = IXMLDOMComment_deleteData(pComment, -1, 1);
6448                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6449
6450                 hr = IXMLDOMComment_deleteData(pComment, 0, 0);
6451                 ok(hr == S_OK, "ret %08x\n", hr );
6452
6453                 hr = IXMLDOMComment_deleteData(pComment, 0, -1);
6454                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6455
6456                 hr = IXMLDOMComment_get_length(pComment, &len);
6457                 ok(hr == S_OK, "ret %08x\n", hr );
6458                 ok(len == 43, "expected 43 got %d\n", len);
6459
6460                 hr = IXMLDOMComment_deleteData(pComment, len, 1);
6461                 ok(hr == S_OK, "ret %08x\n", hr );
6462
6463                 hr = IXMLDOMComment_deleteData(pComment, len+1, 1);
6464                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6465
6466                 /* delete from start */
6467                 hr = IXMLDOMComment_deleteData(pComment, 0, 5);
6468                 ok(hr == S_OK, "ret %08x\n", hr );
6469
6470                 hr = IXMLDOMComment_get_length(pComment, &len);
6471                 ok(hr == S_OK, "ret %08x\n", hr );
6472                 ok(len == 38, "expected 38 got %d\n", len);
6473
6474                 hr = IXMLDOMComment_get_text(pComment, &str);
6475                 ok(hr == S_OK, "ret %08x\n", hr );
6476                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6477                 SysFreeString(str);
6478
6479                 /* delete from end */
6480                 hr = IXMLDOMComment_deleteData(pComment, 35, 3);
6481                 ok(hr == S_OK, "ret %08x\n", hr );
6482
6483                 hr = IXMLDOMComment_get_length(pComment, &len);
6484                 ok(hr == S_OK, "ret %08x\n", hr );
6485                 ok(len == 35, "expected 35 got %d\n", len);
6486
6487                 hr = IXMLDOMComment_get_text(pComment, &str);
6488                 ok(hr == S_OK, "ret %08x\n", hr );
6489                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6490                 SysFreeString(str);
6491
6492                 /* delete from inside */
6493                 hr = IXMLDOMComment_deleteData(pComment, 1, 33);
6494                 ok(hr == S_OK, "ret %08x\n", hr );
6495
6496                 hr = IXMLDOMComment_get_length(pComment, &len);
6497                 ok(hr == S_OK, "ret %08x\n", hr );
6498                 ok(len == 2, "expected 2 got %d\n", len);
6499
6500                 hr = IXMLDOMComment_get_text(pComment, &str);
6501                 ok(hr == S_OK, "ret %08x\n", hr );
6502                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6503                 SysFreeString(str);
6504
6505                 /* delete whole data ... */
6506                 hr = IXMLDOMComment_get_length(pComment, &len);
6507                 ok(hr == S_OK, "ret %08x\n", hr );
6508
6509                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
6510                 ok(hr == S_OK, "ret %08x\n", hr );
6511                 /* ... and try again with empty string */
6512                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
6513                 ok(hr == S_OK, "ret %08x\n", hr );
6514
6515                 /* ::replaceData() */
6516                 V_VT(&v) = VT_BSTR;
6517                 V_BSTR(&v) = SysAllocString(szstr1);
6518                 hr = IXMLDOMComment_put_nodeValue(pComment, v);
6519                 ok(hr == S_OK, "ret %08x\n", hr );
6520                 VariantClear(&v);
6521
6522                 hr = IXMLDOMComment_replaceData(pComment, 6, 0, NULL);
6523                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6524                 hr = IXMLDOMComment_get_text(pComment, &str);
6525                 ok(hr == S_OK, "ret %08x\n", hr );
6526                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6527                 SysFreeString(str);
6528
6529                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, NULL);
6530                 ok(hr == S_OK, "ret %08x\n", hr );
6531                 hr = IXMLDOMComment_get_text(pComment, &str);
6532                 ok(hr == S_OK, "ret %08x\n", hr );
6533                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6534                 SysFreeString(str);
6535
6536                 /* NULL pointer means delete */
6537                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, NULL);
6538                 ok(hr == S_OK, "ret %08x\n", hr );
6539                 hr = IXMLDOMComment_get_text(pComment, &str);
6540                 ok(hr == S_OK, "ret %08x\n", hr );
6541                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6542                 SysFreeString(str);
6543
6544                 /* empty string means delete */
6545                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_(""));
6546                 ok(hr == S_OK, "ret %08x\n", hr );
6547                 hr = IXMLDOMComment_get_text(pComment, &str);
6548                 ok(hr == S_OK, "ret %08x\n", hr );
6549                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6550                 SysFreeString(str);
6551
6552                 /* zero count means insert */
6553                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, _bstr_("a"));
6554                 ok(hr == S_OK, "ret %08x\n", hr );
6555                 hr = IXMLDOMComment_get_text(pComment, &str);
6556                 ok(hr == S_OK, "ret %08x\n", hr );
6557                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6558                 SysFreeString(str);
6559
6560                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, NULL);
6561                 ok(hr == S_OK, "ret %08x\n", hr );
6562
6563                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("m"));
6564                 ok(hr == S_OK, "ret %08x\n", hr );
6565                 hr = IXMLDOMComment_get_text(pComment, &str);
6566                 ok(hr == S_OK, "ret %08x\n", hr );
6567                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6568                 SysFreeString(str);
6569
6570                 /* nonempty string, count greater than its length */
6571                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, _bstr_("a1.2"));
6572                 ok(hr == S_OK, "ret %08x\n", hr );
6573                 hr = IXMLDOMComment_get_text(pComment, &str);
6574                 ok(hr == S_OK, "ret %08x\n", hr );
6575                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6576                 SysFreeString(str);
6577
6578                 /* nonempty string, count less than its length */
6579                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_("wine"));
6580                 ok(hr == S_OK, "ret %08x\n", hr );
6581                 hr = IXMLDOMComment_get_text(pComment, &str);
6582                 ok(hr == S_OK, "ret %08x\n", hr );
6583                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6584                 SysFreeString(str);
6585
6586                 IXMLDOMComment_Release(pComment);
6587             }
6588
6589             /* Element */
6590             str = SysAllocString(szElement);
6591             hr = IXMLDOMDocument_createElement(doc, str, &pElement);
6592             SysFreeString(str);
6593             ok(hr == S_OK, "ret %08x\n", hr );
6594             if(hr == S_OK)
6595             {
6596                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
6597                 ok(hr == S_OK, "ret %08x\n", hr );
6598
6599                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
6600                 ok(hr == S_OK, "ret %08x\n", hr );
6601                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
6602                 SysFreeString(str);
6603
6604                 hr = IXMLDOMElement_get_xml(pElement, &str);
6605                 ok(hr == S_OK, "ret %08x\n", hr );
6606                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
6607                 SysFreeString(str);
6608
6609                 /* Attribute */
6610                 pAttribute = (IXMLDOMAttribute*)0x1;
6611                 hr = IXMLDOMDocument_createAttribute(doc, NULL, &pAttribute);
6612                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6613                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
6614
6615                 pAttribute = (IXMLDOMAttribute*)0x1;
6616                 hr = IXMLDOMDocument_createAttribute(doc, _bstr_(""), &pAttribute);
6617                 ok(hr == E_FAIL, "ret %08x\n", hr );
6618                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
6619
6620                 str = SysAllocString(szAttribute);
6621                 hr = IXMLDOMDocument_createAttribute(doc, str, &pAttribute);
6622                 SysFreeString(str);
6623                 ok(hr == S_OK, "ret %08x\n", hr );
6624                 if(hr == S_OK)
6625                 {
6626                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
6627
6628                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, NULL);
6629                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6630
6631                     pNextChild = (IXMLDOMNode *)0x1;
6632                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, &pNextChild);
6633                     ok(hr == S_FALSE, "ret %08x\n", hr );
6634                     ok(pNextChild == NULL, "pNextChild not NULL\n");
6635
6636                     /* test Previous Sibling*/
6637                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, NULL);
6638                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6639
6640                     pNextChild = (IXMLDOMNode *)0x1;
6641                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, &pNextChild);
6642                     ok(hr == S_FALSE, "ret %08x\n", hr );
6643                     ok(pNextChild == NULL, "pNextChild not NULL\n");
6644
6645                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttribute, &pNewChild);
6646                     ok(hr == E_FAIL, "ret %08x\n", hr );
6647                     ok(pNewChild == NULL, "pNewChild not NULL\n");
6648
6649                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
6650                     ok(hr == S_OK, "ret %08x\n", hr );
6651                     if ( hr == S_OK )
6652                     {
6653                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttribute, NULL );
6654                         ok(hr == S_OK, "ret %08x\n", hr );
6655
6656                         IXMLDOMNamedNodeMap_Release(pAttribs);
6657                     }
6658
6659                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
6660                     ok(hr == S_OK, "ret %08x\n", hr );
6661                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
6662                     SysFreeString(str);
6663
6664                     /* test nodeName */
6665                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
6666                     ok(hr == S_OK, "ret %08x\n", hr );
6667                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
6668                     SysFreeString(str);
6669
6670                     /* test name property */
6671                     hr = IXMLDOMAttribute_get_name(pAttribute, &str);
6672                     ok(hr == S_OK, "ret %08x\n", hr );
6673                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
6674                     SysFreeString(str);
6675
6676                     hr = IXMLDOMAttribute_get_xml(pAttribute, &str);
6677                     ok(hr == S_OK, "ret %08x\n", hr );
6678                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
6679                     SysFreeString(str);
6680
6681                     IXMLDOMAttribute_Release(pAttribute);
6682
6683                     /* Check Element again with the Add Attribute*/
6684                     hr = IXMLDOMElement_get_xml(pElement, &str);
6685                     ok(hr == S_OK, "ret %08x\n", hr );
6686                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
6687                     SysFreeString(str);
6688                 }
6689
6690                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
6691                 ok(hr == S_OK, "ret %08x\n", hr );
6692
6693                 hr = IXMLDOMElement_get_xml(pElement, &str);
6694                 ok(hr == S_OK, "ret %08x\n", hr );
6695                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
6696                 SysFreeString(str);
6697
6698                 /* Test for reversible escaping */
6699                 str = SysAllocString( szStrangeChars );
6700                 hr = IXMLDOMElement_put_text(pElement, str);
6701                 ok(hr == S_OK, "ret %08x\n", hr );
6702                 SysFreeString( str );
6703
6704                 hr = IXMLDOMElement_get_xml(pElement, &str);
6705                 ok(hr == S_OK, "ret %08x\n", hr );
6706                 ok( !lstrcmpW( str, szElementXML4 ), "incorrect element xml\n");
6707                 SysFreeString(str);
6708
6709                 hr = IXMLDOMElement_get_text(pElement, &str);
6710                 ok(hr == S_OK, "ret %08x\n", hr );
6711                 ok( !lstrcmpW( str, szStrangeChars ), "incorrect element text\n");
6712                 SysFreeString(str);
6713
6714                 IXMLDOMElement_Release(pElement);
6715             }
6716
6717             /* CData Section */
6718             str = SysAllocString(szCData);
6719             hr = IXMLDOMDocument_createCDATASection(doc, str, NULL);
6720             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6721
6722             hr = IXMLDOMDocument_createCDATASection(doc, str, &pCDataSec);
6723             SysFreeString(str);
6724             ok(hr == S_OK, "ret %08x\n", hr );
6725             if(hr == S_OK)
6726             {
6727                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
6728                 VARIANT var;
6729
6730                 VariantInit(&var);
6731
6732                 hr = IXMLDOMCDATASection_QueryInterface(pCDataSec, &IID_IXMLDOMElement, (void**)&pElement);
6733                 ok(hr == E_NOINTERFACE, "ret %08x\n", hr);
6734
6735                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
6736                 ok(hr == S_OK, "ret %08x\n", hr );
6737
6738                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
6739                 ok(hr == S_OK, "ret %08x\n", hr );
6740                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
6741                 SysFreeString(str);
6742
6743                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
6744                 ok(hr == S_OK, "ret %08x\n", hr );
6745                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
6746                 SysFreeString(str);
6747
6748                 /* test lastChild */
6749                 pNextChild = (IXMLDOMNode*)0x1;
6750                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
6751                 ok(hr == S_FALSE, "ret %08x\n", hr );
6752                 ok(pNextChild == NULL, "pNextChild not NULL\n");
6753
6754                 /* put data Tests */
6755                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
6756                 ok(hr == S_OK, "ret %08x\n", hr );
6757
6758                 /* Confirm XML text is good */
6759                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
6760                 ok(hr == S_OK, "ret %08x\n", hr );
6761                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
6762                 SysFreeString(str);
6763
6764                 /* Confirm we get the put_data Text back */
6765                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6766                 ok(hr == S_OK, "ret %08x\n", hr );
6767                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
6768                 SysFreeString(str);
6769
6770                 /* test length property */
6771                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6772                 ok(hr == S_OK, "ret %08x\n", hr );
6773                 ok(len == 21, "expected 21 got %d\n", len);
6774
6775                 /* test get data */
6776                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
6777                 ok(hr == S_OK, "ret %08x\n", hr );
6778                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
6779                 SysFreeString(str);
6780
6781                 /* test substringData */
6782                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
6783                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6784
6785                 /* test substringData - Invalid offset */
6786                 str = (BSTR)&szElement;
6787                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
6788                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6789                 ok( str == NULL, "incorrect string\n");
6790
6791                 /* test substringData - Invalid offset */
6792                 str = (BSTR)&szElement;
6793                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
6794                 ok(hr == S_FALSE, "ret %08x\n", hr );
6795                 ok( str == NULL, "incorrect string\n");
6796
6797                 /* test substringData - Invalid size */
6798                 str = (BSTR)&szElement;
6799                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
6800                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6801                 ok( str == NULL, "incorrect string\n");
6802
6803                 /* test substringData - Invalid size */
6804                 str = (BSTR)&szElement;
6805                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
6806                 ok(hr == S_FALSE, "ret %08x\n", hr );
6807                 ok( str == NULL, "incorrect string\n");
6808
6809                 /* test substringData - Start of string */
6810                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
6811                 ok(hr == S_OK, "ret %08x\n", hr );
6812                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
6813                 SysFreeString(str);
6814
6815                 /* test substringData - Middle of string */
6816                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
6817                 ok(hr == S_OK, "ret %08x\n", hr );
6818                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
6819                 SysFreeString(str);
6820
6821                 /* test substringData - End of string */
6822                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
6823                 ok(hr == S_OK, "ret %08x\n", hr );
6824                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
6825                 SysFreeString(str);
6826
6827                 /* test appendData */
6828                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
6829                 ok(hr == S_OK, "ret %08x\n", hr );
6830
6831                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
6832                 ok(hr == S_OK, "ret %08x\n", hr );
6833
6834                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
6835                 ok(hr == S_OK, "ret %08x\n", hr );
6836
6837                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6838                 ok(hr == S_OK, "ret %08x\n", hr );
6839                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6840                 SysFreeString(str);
6841
6842                 /* test insertData */
6843                 str = SysAllocStringLen(NULL, 0);
6844                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
6845                 ok(hr == S_OK, "ret %08x\n", hr );
6846
6847                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
6848                 ok(hr == S_OK, "ret %08x\n", hr );
6849
6850                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
6851                 ok(hr == S_OK, "ret %08x\n", hr );
6852
6853                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
6854                 ok(hr == S_OK, "ret %08x\n", hr );
6855
6856                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
6857                 ok(hr == S_OK, "ret %08x\n", hr );
6858
6859                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
6860                 ok(hr == S_OK, "ret %08x\n", hr );
6861                 SysFreeString(str);
6862
6863                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
6864                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6865
6866                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
6867                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6868
6869                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
6870                 ok(hr == S_OK, "ret %08x\n", hr );
6871
6872                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
6873                 ok(hr == S_OK, "ret %08x\n", hr );
6874
6875                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
6876                 ok(hr == S_OK, "ret %08x\n", hr );
6877
6878                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6879                 ok(hr == S_OK, "ret %08x\n", hr );
6880                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6881                 SysFreeString(str);
6882
6883                 /* delete data */
6884                 /* invalid arguments */
6885                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, -1, 1);
6886                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6887
6888                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 0);
6889                 ok(hr == S_OK, "ret %08x\n", hr );
6890
6891                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, -1);
6892                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6893
6894                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6895                 ok(hr == S_OK, "ret %08x\n", hr );
6896                 ok(len == 43, "expected 43 got %d\n", len);
6897
6898                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len, 1);
6899                 ok(hr == S_OK, "ret %08x\n", hr );
6900
6901                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len+1, 1);
6902                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6903
6904                 /* delete from start */
6905                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 5);
6906                 ok(hr == S_OK, "ret %08x\n", hr );
6907
6908                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6909                 ok(hr == S_OK, "ret %08x\n", hr );
6910                 ok(len == 38, "expected 38 got %d\n", len);
6911
6912                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6913                 ok(hr == S_OK, "ret %08x\n", hr );
6914                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6915                 SysFreeString(str);
6916
6917                 /* delete from end */
6918                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 35, 3);
6919                 ok(hr == S_OK, "ret %08x\n", hr );
6920
6921                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6922                 ok(hr == S_OK, "ret %08x\n", hr );
6923                 ok(len == 35, "expected 35 got %d\n", len);
6924
6925                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6926                 ok(hr == S_OK, "ret %08x\n", hr );
6927                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6928                 SysFreeString(str);
6929
6930                 /* delete from inside */
6931                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 1, 33);
6932                 ok(hr == S_OK, "ret %08x\n", hr );
6933
6934                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6935                 ok(hr == S_OK, "ret %08x\n", hr );
6936                 ok(len == 2, "expected 2 got %d\n", len);
6937
6938                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6939                 ok(hr == S_OK, "ret %08x\n", hr );
6940                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6941                 SysFreeString(str);
6942
6943                 /* delete whole data ... */
6944                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
6945                 ok(hr == S_OK, "ret %08x\n", hr );
6946
6947                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
6948                 ok(hr == S_OK, "ret %08x\n", hr );
6949
6950                 /* ... and try again with empty string */
6951                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
6952                 ok(hr == S_OK, "ret %08x\n", hr );
6953
6954                 /* ::replaceData() */
6955                 V_VT(&v) = VT_BSTR;
6956                 V_BSTR(&v) = SysAllocString(szstr1);
6957                 hr = IXMLDOMCDATASection_put_nodeValue(pCDataSec, v);
6958                 ok(hr == S_OK, "ret %08x\n", hr );
6959                 VariantClear(&v);
6960
6961                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 6, 0, NULL);
6962                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6963                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6964                 ok(hr == S_OK, "ret %08x\n", hr );
6965                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6966                 SysFreeString(str);
6967
6968                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, NULL);
6969                 ok(hr == S_OK, "ret %08x\n", hr );
6970                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6971                 ok(hr == S_OK, "ret %08x\n", hr );
6972                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6973                 SysFreeString(str);
6974
6975                 /* NULL pointer means delete */
6976                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, NULL);
6977                 ok(hr == S_OK, "ret %08x\n", hr );
6978                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6979                 ok(hr == S_OK, "ret %08x\n", hr );
6980                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6981                 SysFreeString(str);
6982
6983                 /* empty string means delete */
6984                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_(""));
6985                 ok(hr == S_OK, "ret %08x\n", hr );
6986                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6987                 ok(hr == S_OK, "ret %08x\n", hr );
6988                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6989                 SysFreeString(str);
6990
6991                 /* zero count means insert */
6992                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, _bstr_("a"));
6993                 ok(hr == S_OK, "ret %08x\n", hr );
6994                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
6995                 ok(hr == S_OK, "ret %08x\n", hr );
6996                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
6997                 SysFreeString(str);
6998
6999                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, NULL);
7000                 ok(hr == S_OK, "ret %08x\n", hr );
7001
7002                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("m"));
7003                 ok(hr == S_OK, "ret %08x\n", hr );
7004                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
7005                 ok(hr == S_OK, "ret %08x\n", hr );
7006                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
7007                 SysFreeString(str);
7008
7009                 /* nonempty string, count greater than its length */
7010                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, _bstr_("a1.2"));
7011                 ok(hr == S_OK, "ret %08x\n", hr );
7012                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
7013                 ok(hr == S_OK, "ret %08x\n", hr );
7014                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
7015                 SysFreeString(str);
7016
7017                 /* nonempty string, count less than its length */
7018                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_("wine"));
7019                 ok(hr == S_OK, "ret %08x\n", hr );
7020                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
7021                 ok(hr == S_OK, "ret %08x\n", hr );
7022                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
7023                 SysFreeString(str);
7024
7025                 IXMLDOMCDATASection_Release(pCDataSec);
7026             }
7027
7028             /* Document Fragments */
7029             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
7030             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7031
7032             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
7033             ok(hr == S_OK, "ret %08x\n", hr );
7034             if(hr == S_OK)
7035             {
7036                 IXMLDOMNode *node;
7037
7038                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, NULL);
7039                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7040
7041                 node = (IXMLDOMNode *)0x1;
7042                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, &node);
7043                 ok(hr == S_FALSE, "ret %08x\n", hr );
7044                 ok(node == NULL, "expected NULL, got %p\n", node);
7045
7046                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
7047                 ok(hr == S_OK, "ret %08x\n", hr );
7048
7049                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
7050                 ok(hr == S_OK, "ret %08x\n", hr );
7051                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
7052                 SysFreeString(str);
7053
7054                 /* test next Sibling*/
7055                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
7056                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7057
7058                 node = (IXMLDOMNode *)0x1;
7059                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &node);
7060                 ok(hr == S_FALSE, "ret %08x\n", hr );
7061                 ok(node == NULL, "next sibling not NULL\n");
7062
7063                 /* test Previous Sibling*/
7064                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
7065                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7066
7067                 node = (IXMLDOMNode *)0x1;
7068                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &node);
7069                 ok(hr == S_FALSE, "ret %08x\n", hr );
7070                 ok(node == NULL, "previous sibling not NULL\n");
7071
7072                 IXMLDOMDocumentFragment_Release(pDocFrag);
7073             }
7074
7075             /* Entity References */
7076             hr = IXMLDOMDocument_createEntityReference(doc, NULL, &pEntityRef);
7077             ok(hr == E_FAIL, "ret %08x\n", hr );
7078             hr = IXMLDOMDocument_createEntityReference(doc, _bstr_(""), &pEntityRef);
7079             ok(hr == E_FAIL, "ret %08x\n", hr );
7080
7081             str = SysAllocString(szEntityRef);
7082             hr = IXMLDOMDocument_createEntityReference(doc, str, NULL);
7083             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7084
7085             hr = IXMLDOMDocument_createEntityReference(doc, str, &pEntityRef);
7086             SysFreeString(str);
7087             ok(hr == S_OK, "ret %08x\n", hr );
7088             if(hr == S_OK)
7089             {
7090                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
7091                 ok(hr == S_OK, "ret %08x\n", hr );
7092
7093                 /* test get_xml*/
7094                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
7095                 ok(hr == S_OK, "ret %08x\n", hr );
7096                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
7097                 SysFreeString(str);
7098
7099                 IXMLDOMEntityReference_Release(pEntityRef);
7100             }
7101
7102             IXMLDOMElement_Release( pRoot );
7103         }
7104     }
7105
7106     IXMLDOMDocument_Release(doc);
7107
7108     free_bstrs();
7109 }
7110
7111 typedef struct {
7112     const char *name;
7113     const char *type;
7114     HRESULT hr;
7115 } put_datatype_t;
7116
7117 /* Type test for elements only. Name passed into put_dataType is case-insensitive.
7118    So many of the names have been changed to reflect this. */
7119 static put_datatype_t put_datatype_data[] = {
7120     { "test_inval",      "abcdefg",     E_FAIL },
7121     { "test_bool",       "Boolean",     S_OK },
7122     { "test_string",     "String",      S_OK },
7123     { "test_number",     "number",      S_OK },
7124     { "test_int",        "InT",         S_OK },
7125     { "test_fixed",      "fixed.14.4",  S_OK },
7126     { "test_datetime",   "DateTime",    S_OK },
7127     { "test_datetimetz", "DateTime.tz", S_OK },
7128     { "test_date",       "Date",        S_OK },
7129     { "test_time",       "Time",        S_OK },
7130     { "test_timetz",     "Time.tz",     S_OK },
7131     { "test_I1",         "I1",          S_OK },
7132     { "test_I2",         "I2",          S_OK },
7133     { "test_I4",         "I4",          S_OK },
7134     { "test_UI1",        "UI1",         S_OK },
7135     { "test_UI2",        "UI2",         S_OK },
7136     { "test_UI4",        "UI4",         S_OK },
7137     { "test_r4",         "r4",          S_OK },
7138     { "test_r8",         "r8",          S_OK },
7139     { "test_float",      "float",       S_OK },
7140     { "test_uuid",       "UuId",        S_OK },
7141     { "test_binhex",     "bin.hex",     S_OK },
7142     { "test_binbase64",  "bin.base64",  S_OK },
7143     { NULL }
7144 };
7145
7146 typedef struct {
7147     DOMNodeType type;
7148     HRESULT hr;
7149 } put_datatype_notype_t;
7150
7151 static put_datatype_notype_t put_dt_notype[] = {
7152     { NODE_PROCESSING_INSTRUCTION, E_FAIL },
7153     { NODE_DOCUMENT_FRAGMENT,      E_FAIL },
7154     { NODE_ENTITY_REFERENCE,       E_FAIL },
7155     { NODE_CDATA_SECTION,          E_FAIL },
7156     { NODE_COMMENT,                E_FAIL },
7157     { NODE_INVALID }
7158 };
7159
7160 static void test_put_dataType( void )
7161 {
7162     const put_datatype_notype_t *ptr2 = put_dt_notype;
7163     const put_datatype_t *ptr = put_datatype_data;
7164     IXMLDOMElement *root, *element;
7165     BSTR nameW, type1W, type2W;
7166     IXMLDOMDocument *doc;
7167     HRESULT hr;
7168
7169     doc = create_document(&IID_IXMLDOMDocument);
7170     if (!doc) return;
7171
7172     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), NULL);
7173     EXPECT_HR(hr, E_INVALIDARG);
7174
7175     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
7176     EXPECT_HR(hr, S_OK);
7177
7178     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
7179     EXPECT_HR(hr, S_OK);
7180
7181     hr = IXMLDOMElement_put_dataType(root, NULL);
7182     EXPECT_HR(hr, E_INVALIDARG);
7183
7184     while (ptr->name)
7185     {
7186         hr = IXMLDOMDocument_createElement(doc, _bstr_(ptr->name), &element);
7187         EXPECT_HR(hr, S_OK);
7188         if(hr == S_OK)
7189         {
7190             hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
7191             EXPECT_HR(hr, S_OK);
7192
7193             hr = IXMLDOMElement_put_dataType(element, _bstr_(ptr->type));
7194             ok(hr == ptr->hr, "failed for %s:%s, 0x%08x\n", ptr->name, ptr->type, ptr->hr);
7195
7196             IXMLDOMElement_Release(element);
7197         }
7198         ptr++;
7199     }
7200
7201     /* check changing types */
7202     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &element);
7203     EXPECT_HR(hr, S_OK);
7204
7205     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
7206     EXPECT_HR(hr, S_OK);
7207
7208     hr = IXMLDOMElement_put_dataType(element, _bstr_("DateTime.tz"));
7209     EXPECT_HR(hr, S_OK);
7210
7211     hr = IXMLDOMElement_put_dataType(element, _bstr_("string"));
7212     EXPECT_HR(hr, S_OK);
7213
7214     IXMLDOMElement_Release(element);
7215
7216     /* try to set type for node without a type */
7217     nameW  = _bstr_("testname");
7218     type1W = _bstr_("string");
7219     type2W = _bstr_("number");
7220     while (ptr2->type != NODE_INVALID)
7221     {
7222         IXMLDOMNode *node;
7223         VARIANT type;
7224
7225         V_VT(&type) = VT_I2;
7226         V_I2(&type) = ptr2->type;
7227
7228         hr = IXMLDOMDocument_createNode(doc, type, nameW, NULL, &node);
7229         EXPECT_HR(hr, S_OK);
7230         if(hr == S_OK)
7231         {
7232             hr = IXMLDOMElement_appendChild(root, node, NULL);
7233             EXPECT_HR(hr, S_OK);
7234
7235             hr = IXMLDOMNode_put_dataType(node, NULL);
7236             EXPECT_HR(hr, E_INVALIDARG);
7237
7238             hr = IXMLDOMNode_put_dataType(node, type1W);
7239             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
7240             hr = IXMLDOMNode_put_dataType(node, type2W);
7241             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
7242
7243             IXMLDOMNode_Release(node);
7244         }
7245         ptr2++;
7246     }
7247
7248     IXMLDOMElement_Release(root);
7249     IXMLDOMDocument_Release(doc);
7250     free_bstrs();
7251 }
7252
7253 static void test_save(void)
7254 {
7255     IXMLDOMDocument *doc, *doc2;
7256     IXMLDOMElement *root;
7257     BSTR sOrig, sNew, filename;
7258     char buffer[100];
7259     IStream *stream;
7260     HGLOBAL global;
7261     VARIANT_BOOL b;
7262     DWORD read = 0;
7263     VARIANT dest;
7264     HANDLE hfile;
7265     HRESULT hr;
7266     char *ptr;
7267
7268     doc = create_document(&IID_IXMLDOMDocument);
7269     if (!doc) return;
7270
7271     doc2 = create_document(&IID_IXMLDOMDocument);
7272     if (!doc2)
7273     {
7274         IXMLDOMDocument_Release(doc);
7275         return;
7276     }
7277
7278     /* save to IXMLDOMDocument */
7279     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
7280     EXPECT_HR(hr, S_OK);
7281
7282     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
7283     EXPECT_HR(hr, S_OK);
7284
7285     V_VT(&dest) = VT_UNKNOWN;
7286     V_UNKNOWN(&dest) = (IUnknown*)doc2;
7287
7288     hr = IXMLDOMDocument_save(doc, dest);
7289     EXPECT_HR(hr, S_OK);
7290
7291     hr = IXMLDOMDocument_get_xml(doc, &sOrig);
7292     EXPECT_HR(hr, S_OK);
7293
7294     hr = IXMLDOMDocument_get_xml(doc2, &sNew);
7295     EXPECT_HR(hr, S_OK);
7296
7297     ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as original\n");
7298
7299     SysFreeString(sOrig);
7300     SysFreeString(sNew);
7301
7302     IXMLDOMElement_Release(root);
7303     IXMLDOMDocument_Release(doc2);
7304
7305     /* save to path */
7306     V_VT(&dest) = VT_BSTR;
7307     V_BSTR(&dest) = _bstr_("test.xml");
7308
7309     hr = IXMLDOMDocument_save(doc, dest);
7310     EXPECT_HR(hr, S_OK);
7311
7312     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
7313     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
7314     if(hfile == INVALID_HANDLE_VALUE) return;
7315
7316     ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
7317     ok(read != 0, "could not read file\n");
7318     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
7319
7320     CloseHandle(hfile);
7321     DeleteFile("test.xml");
7322
7323     /* save to path VT_BSTR | VT_BYREF */
7324     filename = _bstr_("test.xml");
7325     V_VT(&dest) = VT_BSTR | VT_BYREF;
7326     V_BSTRREF(&dest) = &filename;
7327
7328     hr = IXMLDOMDocument_save(doc, dest);
7329     EXPECT_HR(hr, S_OK);
7330
7331     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
7332     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
7333     if(hfile == INVALID_HANDLE_VALUE) return;
7334
7335     if (hfile != INVALID_HANDLE_VALUE)
7336     {
7337        ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
7338        ok(read != 0, "could not read file\n");
7339        ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
7340
7341        CloseHandle(hfile);
7342        DeleteFile("test.xml");
7343     }
7344
7345     /* save to stream */
7346     V_VT(&dest) = VT_UNKNOWN;
7347     V_UNKNOWN(&dest) = (IUnknown*)&savestream;
7348
7349     hr = IXMLDOMDocument_save(doc, dest);
7350     EXPECT_HR(hr, S_OK);
7351
7352     /* loaded data contains xml declaration */
7353     hr = IXMLDOMDocument_loadXML(doc, _bstr_(win1252xml), &b);
7354     EXPECT_HR(hr, S_OK);
7355
7356     CreateStreamOnHGlobal(NULL, TRUE, &stream);
7357     V_VT(&dest) = VT_UNKNOWN;
7358     V_UNKNOWN(&dest) = (IUnknown*)stream;
7359     hr = IXMLDOMDocument_save(doc, dest);
7360     EXPECT_HR(hr, S_OK);
7361
7362     hr = GetHGlobalFromStream(stream, &global);
7363     EXPECT_HR(hr, S_OK);
7364     ptr = GlobalLock(global);
7365     ok(!memcmp(ptr, win1252decl, strlen(win1252decl)), "got wrong xml declaration\n");
7366     GlobalUnlock(global);
7367     IStream_Release(stream);
7368
7369     /* loaded data without xml declaration */
7370     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<a/>"), &b);
7371     EXPECT_HR(hr, S_OK);
7372
7373     CreateStreamOnHGlobal(NULL, TRUE, &stream);
7374     V_VT(&dest) = VT_UNKNOWN;
7375     V_UNKNOWN(&dest) = (IUnknown*)stream;
7376     hr = IXMLDOMDocument_save(doc, dest);
7377     EXPECT_HR(hr, S_OK);
7378
7379     hr = GetHGlobalFromStream(stream, &global);
7380     EXPECT_HR(hr, S_OK);
7381     ptr = GlobalLock(global);
7382     ok(ptr[0] == '<' && ptr[1] != '?', "got wrong start tag %c%c\n", ptr[0], ptr[1]);
7383     GlobalUnlock(global);
7384     IStream_Release(stream);
7385
7386     IXMLDOMDocument_Release(doc);
7387     free_bstrs();
7388 }
7389
7390 static void test_testTransforms(void)
7391 {
7392     IXMLDOMDocument *doc, *docSS;
7393     IXMLDOMNode *pNode;
7394     VARIANT_BOOL bSucc;
7395
7396     HRESULT hr;
7397
7398     doc = create_document(&IID_IXMLDOMDocument);
7399     if (!doc) return;
7400
7401     docSS = create_document(&IID_IXMLDOMDocument);
7402     if (!docSS)
7403     {
7404         IXMLDOMDocument_Release(doc);
7405         return;
7406     }
7407
7408     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
7409     ok(hr == S_OK, "ret %08x\n", hr );
7410
7411     hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
7412     ok(hr == S_OK, "ret %08x\n", hr );
7413
7414     hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (void**)&pNode );
7415     ok(hr == S_OK, "ret %08x\n", hr );
7416     if(hr == S_OK)
7417     {
7418         BSTR bOut;
7419
7420         hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
7421         ok(hr == S_OK, "ret %08x\n", hr );
7422         if(hr == S_OK)
7423         {
7424             ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "Stylesheet output not correct\n");
7425             SysFreeString(bOut);
7426         }
7427
7428         IXMLDOMNode_Release(pNode);
7429     }
7430
7431     IXMLDOMDocument_Release(docSS);
7432     IXMLDOMDocument_Release(doc);
7433
7434     free_bstrs();
7435 }
7436
7437 struct namespaces_change_t {
7438     const CLSID *clsid;
7439     const char *name;
7440 };
7441
7442 static const struct namespaces_change_t namespaces_change_test_data[] = {
7443     { &CLSID_DOMDocument,   "CLSID_DOMDocument"   },
7444     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2"  },
7445     { &CLSID_DOMDocument26, "CLSID_DOMDocument26" },
7446     { &CLSID_DOMDocument30, "CLSID_DOMDocument30" },
7447     { &CLSID_DOMDocument40, "CLSID_DOMDocument40" },
7448     { &CLSID_DOMDocument60, "CLSID_DOMDocument60" },
7449     { 0 }
7450 };
7451
7452 static void test_namespaces_change(void)
7453 {
7454     const struct namespaces_change_t *class_ptr = namespaces_change_test_data;
7455
7456     while (class_ptr->clsid)
7457     {
7458         IXMLDOMDocument *doc = NULL;
7459         IXMLDOMElement *elem = NULL;
7460         IXMLDOMNode *node = NULL;
7461
7462         VARIANT var;
7463         HRESULT hr;
7464         BSTR str;
7465
7466         hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
7467                               &IID_IXMLDOMDocument, (void**)&doc);
7468         if (hr != S_OK)
7469         {
7470             win_skip("failed to create class instance for %s\n", class_ptr->name);
7471             class_ptr++;
7472             continue;
7473         }
7474
7475         V_VT(&var) = VT_I2;
7476         V_I2(&var) = NODE_ELEMENT;
7477
7478         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("ns:elem"), _bstr_("ns/uri"), &node);
7479         EXPECT_HR(hr, S_OK);
7480
7481         hr = IXMLDOMDocument_appendChild(doc, node, NULL);
7482         EXPECT_HR(hr, S_OK);
7483
7484         hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7485         EXPECT_HR(hr, S_OK);
7486
7487         /* try same prefix, different uri */
7488         V_VT(&var) = VT_BSTR;
7489         V_BSTR(&var) = _bstr_("ns/uri2");
7490
7491         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
7492         EXPECT_HR(hr, E_INVALIDARG);
7493
7494         /* try same prefix and uri */
7495         V_VT(&var) = VT_BSTR;
7496         V_BSTR(&var) = _bstr_("ns/uri");
7497
7498         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
7499         EXPECT_HR(hr, S_OK);
7500
7501         hr = IXMLDOMElement_get_xml(elem, &str);
7502         EXPECT_HR(hr, S_OK);
7503         ok(!lstrcmpW(str, _bstr_("<ns:elem xmlns:ns=\"ns/uri\"/>")), "got element %s for %s\n",
7504            wine_dbgstr_w(str), class_ptr->name);
7505         SysFreeString(str);
7506
7507         IXMLDOMElement_Release(elem);
7508         IXMLDOMDocument_Release(doc);
7509
7510         free_bstrs();
7511
7512         class_ptr++;
7513     }
7514 }
7515
7516 static void test_namespaces_basic(void)
7517 {
7518     static const CHAR namespaces_xmlA[] =
7519         "<?xml version=\"1.0\"?>\n"
7520         "<XMI xmi.version=\"1.1\" xmlns:Model=\"http://omg.org/mof.Model/1.3\">"
7521         "  <XMI.content>"
7522         "    <Model:Package name=\"WinePackage\" Model:name2=\"name2 attr\" />"
7523         "  </XMI.content>"
7524         "</XMI>";
7525
7526     IXMLDOMDocument *doc;
7527     IXMLDOMElement *elem;
7528     IXMLDOMNode *node;
7529
7530     VARIANT_BOOL b;
7531     HRESULT hr;
7532     BSTR str;
7533
7534     doc = create_document(&IID_IXMLDOMDocument);
7535     if (!doc) return;
7536
7537     hr = IXMLDOMDocument_loadXML(doc, _bstr_(namespaces_xmlA), &b);
7538     EXPECT_HR(hr, S_OK);
7539     ok(b == VARIANT_TRUE, "got %d\n", b);
7540
7541     str = (BSTR)0xdeadbeef;
7542     hr = IXMLDOMDocument_get_namespaceURI(doc, &str);
7543     EXPECT_HR(hr, S_FALSE);
7544     ok(str == NULL, "got %p\n", str);
7545
7546     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("//XMI.content"), &node );
7547     EXPECT_HR(hr, S_OK);
7548     if(hr == S_OK)
7549     {
7550         IXMLDOMAttribute *attr;
7551         IXMLDOMNode *node2;
7552
7553         hr = IXMLDOMNode_get_firstChild(node, &node2);
7554         EXPECT_HR(hr, S_OK);
7555         ok(node2 != NULL, "got %p\n", node2);
7556
7557         /* Test get_prefix */
7558         hr = IXMLDOMNode_get_prefix(node2, NULL);
7559         EXPECT_HR(hr, E_INVALIDARG);
7560         /* NOTE: Need to test that arg2 gets cleared on Error. */
7561
7562         hr = IXMLDOMNode_get_prefix(node2, &str);
7563         EXPECT_HR(hr, S_OK);
7564         ok( !lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
7565         SysFreeString(str);
7566
7567         hr = IXMLDOMNode_get_nodeName(node2, &str);
7568         EXPECT_HR(hr, S_OK);
7569         ok(!lstrcmpW( str, _bstr_("Model:Package")), "got %s\n", wine_dbgstr_w(str));
7570         SysFreeString(str);
7571
7572         /* Test get_namespaceURI */
7573         hr = IXMLDOMNode_get_namespaceURI(node2, NULL);
7574         EXPECT_HR(hr, E_INVALIDARG);
7575         /* NOTE: Need to test that arg2 gets cleared on Error. */
7576
7577         hr = IXMLDOMNode_get_namespaceURI(node2, &str);
7578         EXPECT_HR(hr, S_OK);
7579         ok(!lstrcmpW( str, _bstr_("http://omg.org/mof.Model/1.3")), "got %s\n", wine_dbgstr_w(str));
7580         SysFreeString(str);
7581
7582         hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&elem);
7583         EXPECT_HR(hr, S_OK);
7584
7585         hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("Model:name2"), &attr);
7586         EXPECT_HR(hr, S_OK);
7587
7588         hr = IXMLDOMAttribute_get_nodeName(attr, &str);
7589         EXPECT_HR(hr, S_OK);
7590         ok(!lstrcmpW( str, _bstr_("Model:name2")), "got %s\n", wine_dbgstr_w(str));
7591         SysFreeString(str);
7592
7593         hr = IXMLDOMAttribute_get_prefix(attr, &str);
7594         EXPECT_HR(hr, S_OK);
7595         ok(!lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
7596         SysFreeString(str);
7597
7598         IXMLDOMAttribute_Release(attr);
7599         IXMLDOMElement_Release(elem);
7600
7601         IXMLDOMNode_Release(node2);
7602         IXMLDOMNode_Release(node);
7603     }
7604
7605     IXMLDOMDocument_Release(doc);
7606
7607     free_bstrs();
7608 }
7609
7610 static void test_FormattingXML(void)
7611 {
7612     IXMLDOMDocument *doc;
7613     IXMLDOMElement *pElement;
7614     VARIANT_BOOL bSucc;
7615     HRESULT hr;
7616     BSTR str;
7617     static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
7618     static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
7619
7620     doc = create_document(&IID_IXMLDOMDocument);
7621     if (!doc) return;
7622
7623     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
7624     ok(hr == S_OK, "ret %08x\n", hr );
7625     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7626
7627     if(bSucc == VARIANT_TRUE)
7628     {
7629         hr = IXMLDOMDocument_get_documentElement(doc, &pElement);
7630         ok(hr == S_OK, "ret %08x\n", hr );
7631         if(hr == S_OK)
7632         {
7633             hr = IXMLDOMElement_get_xml(pElement, &str);
7634             ok(hr == S_OK, "ret %08x\n", hr );
7635             ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
7636             SysFreeString(str);
7637
7638             IXMLDOMElement_Release(pElement);
7639         }
7640     }
7641
7642     IXMLDOMDocument_Release(doc);
7643
7644     free_bstrs();
7645 }
7646
7647 typedef struct _nodetypedvalue_t {
7648     const char *name;
7649     VARTYPE type;
7650     const char *value; /* value in string format */
7651 } nodetypedvalue_t;
7652
7653 static const nodetypedvalue_t get_nodetypedvalue[] = {
7654     { "root/string",    VT_BSTR, "Wine" },
7655     { "root/string2",   VT_BSTR, "String" },
7656     { "root/number",    VT_BSTR, "12.44" },
7657     { "root/number2",   VT_BSTR, "-3.71e3" },
7658     { "root/int",       VT_I4,   "-13" },
7659     { "root/fixed",     VT_CY,   "7322.9371" },
7660     { "root/bool",      VT_BOOL, "-1" },
7661     { "root/datetime",  VT_DATE, "40135.14" },
7662     { "root/datetimetz",VT_DATE, "37813.59" },
7663     { "root/date",      VT_DATE, "665413" },
7664     { "root/time",      VT_DATE, "0.5813889" },
7665     { "root/timetz",    VT_DATE, "1.112512" },
7666     { "root/i1",        VT_I1,   "-13" },
7667     { "root/i2",        VT_I2,   "31915" },
7668     { "root/i4",        VT_I4,   "-312232" },
7669     { "root/ui1",       VT_UI1,  "123" },
7670     { "root/ui2",       VT_UI2,  "48282" },
7671     { "root/ui4",       VT_UI4,  "949281" },
7672     { "root/r4",        VT_R4,   "213124" },
7673     { "root/r8",        VT_R8,   "0.412" },
7674     { "root/float",     VT_R8,   "41221.421" },
7675     { "root/uuid",      VT_BSTR, "333C7BC4-460F-11D0-BC04-0080C7055a83" },
7676     { "root/binbase64", VT_ARRAY|VT_UI1, "base64 test" },
7677     { "root/binbase64_1", VT_ARRAY|VT_UI1, "base64 test" },
7678     { "root/binbase64_2", VT_ARRAY|VT_UI1, "base64 test" },
7679     { 0 }
7680 };
7681
7682 static void test_nodeTypedValue(void)
7683 {
7684     const nodetypedvalue_t *entry = get_nodetypedvalue;
7685     IXMLDOMDocumentType *doctype, *doctype2;
7686     IXMLDOMProcessingInstruction *pi;
7687     IXMLDOMDocumentFragment *frag;
7688     IXMLDOMDocument *doc, *doc2;
7689     IXMLDOMCDATASection *cdata;
7690     IXMLDOMComment *comment;
7691     IXMLDOMNode *node;
7692     VARIANT_BOOL b;
7693     VARIANT value;
7694     HRESULT hr;
7695
7696     doc = create_document(&IID_IXMLDOMDocument);
7697     if (!doc) return;
7698
7699     b = VARIANT_FALSE;
7700     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &b);
7701     ok(hr == S_OK, "ret %08x\n", hr );
7702     ok(b == VARIANT_TRUE, "got %d\n", b);
7703
7704     hr = IXMLDOMDocument_get_nodeValue(doc, NULL);
7705     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7706
7707     V_VT(&value) = VT_BSTR;
7708     V_BSTR(&value) = NULL;
7709     hr = IXMLDOMDocument_get_nodeValue(doc, &value);
7710     ok(hr == S_FALSE, "ret %08x\n", hr );
7711     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
7712
7713     hr = IXMLDOMDocument_get_nodeTypedValue(doc, NULL);
7714     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7715
7716     V_VT(&value) = VT_EMPTY;
7717     hr = IXMLDOMDocument_get_nodeTypedValue(doc, &value);
7718     ok(hr == S_FALSE, "ret %08x\n", hr );
7719     ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
7720
7721     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/string"), &node);
7722     ok(hr == S_OK, "ret %08x\n", hr );
7723
7724     V_VT(&value) = VT_BSTR;
7725     V_BSTR(&value) = NULL;
7726     hr = IXMLDOMNode_get_nodeValue(node, &value);
7727     ok(hr == S_FALSE, "ret %08x\n", hr );
7728     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
7729
7730     hr = IXMLDOMNode_get_nodeTypedValue(node, NULL);
7731     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
7732
7733     IXMLDOMNode_Release(node);
7734
7735     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/binhex"), &node);
7736     ok(hr == S_OK, "ret %08x\n", hr );
7737     {
7738         BYTE bytes[] = {0xff,0xfc,0xa0,0x12,0x00,0x3c};
7739
7740         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
7741         ok(hr == S_OK, "ret %08x\n", hr );
7742         ok(V_VT(&value) == (VT_ARRAY|VT_UI1), "incorrect type\n");
7743         ok(V_ARRAY(&value)->rgsabound[0].cElements == 6, "incorrect array size\n");
7744         if(V_ARRAY(&value)->rgsabound[0].cElements == 6)
7745             ok(!memcmp(bytes, V_ARRAY(&value)->pvData, sizeof(bytes)), "incorrect value\n");
7746         VariantClear(&value);
7747         IXMLDOMNode_Release(node);
7748     }
7749
7750     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("foo"), _bstr_("value"), &pi);
7751     ok(hr == S_OK, "ret %08x\n", hr );
7752     {
7753         V_VT(&value) = VT_NULL;
7754         V_BSTR(&value) = (void*)0xdeadbeef;
7755         hr = IXMLDOMProcessingInstruction_get_nodeTypedValue(pi, &value);
7756         ok(hr == S_OK, "ret %08x\n", hr );
7757         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
7758         ok(!lstrcmpW(V_BSTR(&value), _bstr_("value")), "got wrong value\n");
7759         IXMLDOMProcessingInstruction_Release(pi);
7760         VariantClear(&value);
7761     }
7762
7763     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("[1]*2=3; &gee that's not right!"), &cdata);
7764     ok(hr == S_OK, "ret %08x\n", hr );
7765     {
7766         V_VT(&value) = VT_NULL;
7767         V_BSTR(&value) = (void*)0xdeadbeef;
7768         hr = IXMLDOMCDATASection_get_nodeTypedValue(cdata, &value);
7769         ok(hr == S_OK, "ret %08x\n", hr );
7770         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
7771         ok(!lstrcmpW(V_BSTR(&value), _bstr_("[1]*2=3; &gee that's not right!")), "got wrong value\n");
7772         IXMLDOMCDATASection_Release(cdata);
7773         VariantClear(&value);
7774     }
7775
7776     hr = IXMLDOMDocument_createComment(doc, _bstr_("comment"), &comment);
7777     ok(hr == S_OK, "ret %08x\n", hr );
7778     {
7779         V_VT(&value) = VT_NULL;
7780         V_BSTR(&value) = (void*)0xdeadbeef;
7781         hr = IXMLDOMComment_get_nodeTypedValue(comment, &value);
7782         ok(hr == S_OK, "ret %08x\n", hr );
7783         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
7784         ok(!lstrcmpW(V_BSTR(&value), _bstr_("comment")), "got wrong value\n");
7785         IXMLDOMComment_Release(comment);
7786         VariantClear(&value);
7787     }
7788
7789     hr = IXMLDOMDocument_createDocumentFragment(doc, &frag);
7790     ok(hr == S_OK, "ret %08x\n", hr );
7791     {
7792         V_VT(&value) = VT_EMPTY;
7793         hr = IXMLDOMDocumentFragment_get_nodeTypedValue(frag, &value);
7794         ok(hr == S_FALSE, "ret %08x\n", hr );
7795         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
7796         IXMLDOMDocumentFragment_Release(frag);
7797     }
7798
7799     doc2 = create_document(&IID_IXMLDOMDocument);
7800
7801     b = VARIANT_FALSE;
7802     hr = IXMLDOMDocument_loadXML(doc2, _bstr_(szEmailXML), &b);
7803     ok(hr == S_OK, "ret %08x\n", hr );
7804     ok(b == VARIANT_TRUE, "got %d\n", b);
7805
7806     EXPECT_REF(doc2, 1);
7807
7808     hr = IXMLDOMDocument_get_doctype(doc2, &doctype);
7809     ok(hr == S_OK, "ret %08x\n", hr );
7810
7811     EXPECT_REF(doc2, 1);
7812     todo_wine EXPECT_REF(doctype, 2);
7813
7814     {
7815         V_VT(&value) = VT_EMPTY;
7816         hr = IXMLDOMDocumentType_get_nodeTypedValue(doctype, &value);
7817         ok(hr == S_FALSE, "ret %08x\n", hr );
7818         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
7819     }
7820
7821     hr = IXMLDOMDocument_get_doctype(doc2, &doctype2);
7822     ok(hr == S_OK, "ret %08x\n", hr );
7823     ok(doctype != doctype2, "got %p, was %p\n", doctype2, doctype);
7824
7825     IXMLDOMDocumentType_Release(doctype2);
7826     IXMLDOMDocumentType_Release(doctype);
7827
7828     IXMLDOMDocument_Release(doc2);
7829
7830     while (entry->name)
7831     {
7832         hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_(entry->name), &node);
7833         ok(hr == S_OK, "ret %08x\n", hr );
7834
7835         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
7836         ok(hr == S_OK, "ret %08x\n", hr );
7837         ok(V_VT(&value) == entry->type, "incorrect type, expected %d, got %d\n", entry->type, V_VT(&value));
7838
7839         if (entry->type == (VT_ARRAY|VT_UI1))
7840         {
7841             ok(V_ARRAY(&value)->rgsabound[0].cElements == strlen(entry->value),
7842                "incorrect array size %d\n", V_ARRAY(&value)->rgsabound[0].cElements);
7843         }
7844
7845         if (entry->type != VT_BSTR)
7846         {
7847            if (entry->type == VT_DATE ||
7848                entry->type == VT_R8 ||
7849                entry->type == VT_CY)
7850            {
7851                if (entry->type == VT_DATE)
7852                {
7853                    hr = VariantChangeType(&value, &value, 0, VT_R4);
7854                    ok(hr == S_OK, "ret %08x\n", hr );
7855                }
7856                hr = VariantChangeTypeEx(&value, &value,
7857                                         MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT),
7858                                         VARIANT_NOUSEROVERRIDE, VT_BSTR);
7859                ok(hr == S_OK, "ret %08x\n", hr );
7860            }
7861            else
7862            {
7863                hr = VariantChangeType(&value, &value, 0, VT_BSTR);
7864                ok(hr == S_OK, "ret %08x\n", hr );
7865            }
7866
7867            /* for byte array from VT_ARRAY|VT_UI1 it's not a WCHAR buffer */
7868            if (entry->type == (VT_ARRAY|VT_UI1))
7869            {
7870                ok(!memcmp( V_BSTR(&value), entry->value, strlen(entry->value)),
7871                   "expected %s\n", entry->value);
7872            }
7873            else
7874                ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
7875                   "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
7876         }
7877         else
7878            ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
7879                "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
7880
7881         VariantClear( &value );
7882         IXMLDOMNode_Release(node);
7883
7884         entry++;
7885     }
7886
7887     IXMLDOMDocument_Release(doc);
7888     free_bstrs();
7889 }
7890
7891 static void test_TransformWithLoadingLocalFile(void)
7892 {
7893     IXMLDOMDocument *doc;
7894     IXMLDOMDocument *xsl;
7895     IXMLDOMNode *pNode;
7896     VARIANT_BOOL bSucc;
7897     HRESULT hr;
7898     HANDLE file;
7899     DWORD dwWritten;
7900     char lpPathBuffer[MAX_PATH];
7901     int i;
7902
7903     /* Create a Temp File. */
7904     GetTempPathA(MAX_PATH, lpPathBuffer);
7905     strcat(lpPathBuffer, "customers.xml" );
7906
7907     file = CreateFileA(lpPathBuffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
7908     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
7909     if(file == INVALID_HANDLE_VALUE)
7910         return;
7911
7912     WriteFile(file, szBasicTransformXML, strlen(szBasicTransformXML), &dwWritten, NULL);
7913     CloseHandle(file);
7914
7915     /* Correct path to not include a escape character. */
7916     for(i=0; i < strlen(lpPathBuffer); i++)
7917     {
7918         if(lpPathBuffer[i] == '\\')
7919             lpPathBuffer[i] = '/';
7920     }
7921
7922     doc = create_document(&IID_IXMLDOMDocument);
7923     if (!doc) return;
7924
7925     xsl = create_document(&IID_IXMLDOMDocument);
7926     if (!xsl)
7927     {
7928         IXMLDOMDocument_Release(doc);
7929         return;
7930     }
7931
7932     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
7933     ok(hr == S_OK, "ret %08x\n", hr );
7934     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7935     if(bSucc == VARIANT_TRUE)
7936     {
7937         BSTR sXSL;
7938         BSTR sPart1 = _bstr_(szBasicTransformSSXMLPart1);
7939         BSTR sPart2 = _bstr_(szBasicTransformSSXMLPart2);
7940         BSTR sFileName = _bstr_(lpPathBuffer);
7941         int nLegnth = lstrlenW(sPart1) + lstrlenW(sPart2) + lstrlenW(sFileName) + 1;
7942
7943         sXSL = SysAllocStringLen(NULL, nLegnth);
7944         lstrcpyW(sXSL, sPart1);
7945         lstrcatW(sXSL, sFileName);
7946         lstrcatW(sXSL, sPart2);
7947
7948         hr = IXMLDOMDocument_loadXML(xsl, sXSL, &bSucc);
7949         ok(hr == S_OK, "ret %08x\n", hr );
7950         ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
7951         if(bSucc == VARIANT_TRUE)
7952         {
7953             BSTR sResult;
7954
7955             hr = IXMLDOMDocument_QueryInterface(xsl, &IID_IXMLDOMNode, (void**)&pNode );
7956             ok(hr == S_OK, "ret %08x\n", hr );
7957             if(hr == S_OK)
7958             {
7959                 /* This will load the temp file via the XSL */
7960                 hr = IXMLDOMDocument_transformNode(doc, pNode, &sResult);
7961                 ok(hr == S_OK, "ret %08x\n", hr );
7962                 if(hr == S_OK)
7963                 {
7964                     ok( compareIgnoreReturns( sResult, _bstr_(szBasicTransformOutput)), "Stylesheet output not correct\n");
7965                     SysFreeString(sResult);
7966                 }
7967
7968                 IXMLDOMNode_Release(pNode);
7969             }
7970         }
7971
7972         SysFreeString(sXSL);
7973     }
7974
7975     IXMLDOMDocument_Release(doc);
7976     IXMLDOMDocument_Release(xsl);
7977
7978     DeleteFile(lpPathBuffer);
7979     free_bstrs();
7980 }
7981
7982 static void test_put_nodeValue(void)
7983 {
7984     static const WCHAR jeevesW[] = {'J','e','e','v','e','s',' ','&',' ','W','o','o','s','t','e','r',0};
7985     IXMLDOMDocument *doc;
7986     IXMLDOMText *text;
7987     IXMLDOMEntityReference *entityref;
7988     IXMLDOMAttribute *attr;
7989     IXMLDOMNode *node;
7990     HRESULT hr;
7991     VARIANT data, type;
7992
7993     doc = create_document(&IID_IXMLDOMDocument);
7994     if (!doc) return;
7995
7996     /* test for unsupported types */
7997     /* NODE_DOCUMENT */
7998     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&node);
7999     ok(hr == S_OK, "ret %08x\n", hr );
8000     V_VT(&data) = VT_BSTR;
8001     V_BSTR(&data) = _bstr_("one two three");
8002     hr = IXMLDOMNode_put_nodeValue(node, data);
8003     ok(hr == E_FAIL, "ret %08x\n", hr );
8004     IXMLDOMNode_Release(node);
8005
8006     /* NODE_DOCUMENT_FRAGMENT */
8007     V_VT(&type) = VT_I1;
8008     V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
8009     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
8010     ok(hr == S_OK, "ret %08x\n", hr );
8011     V_VT(&data) = VT_BSTR;
8012     V_BSTR(&data) = _bstr_("one two three");
8013     hr = IXMLDOMNode_put_nodeValue(node, data);
8014     ok(hr == E_FAIL, "ret %08x\n", hr );
8015     IXMLDOMNode_Release(node);
8016
8017     /* NODE_ELEMENT */
8018     V_VT(&type) = VT_I1;
8019     V_I1(&type) = NODE_ELEMENT;
8020     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
8021     ok(hr == S_OK, "ret %08x\n", hr );
8022     V_VT(&data) = VT_BSTR;
8023     V_BSTR(&data) = _bstr_("one two three");
8024     hr = IXMLDOMNode_put_nodeValue(node, data);
8025     ok(hr == E_FAIL, "ret %08x\n", hr );
8026     IXMLDOMNode_Release(node);
8027
8028     /* NODE_ENTITY_REFERENCE */
8029     hr = IXMLDOMDocument_createEntityReference(doc, _bstr_("ref"), &entityref);
8030     ok(hr == S_OK, "ret %08x\n", hr );
8031
8032     V_VT(&data) = VT_BSTR;
8033     V_BSTR(&data) = _bstr_("one two three");
8034     hr = IXMLDOMEntityReference_put_nodeValue(entityref, data);
8035     ok(hr == E_FAIL, "ret %08x\n", hr );
8036
8037     hr = IXMLDOMEntityReference_QueryInterface(entityref, &IID_IXMLDOMNode, (void**)&node);
8038     ok(hr == S_OK, "ret %08x\n", hr );
8039     V_VT(&data) = VT_BSTR;
8040     V_BSTR(&data) = _bstr_("one two three");
8041     hr = IXMLDOMNode_put_nodeValue(node, data);
8042     ok(hr == E_FAIL, "ret %08x\n", hr );
8043     IXMLDOMNode_Release(node);
8044     IXMLDOMEntityReference_Release(entityref);
8045
8046     /* supported types */
8047     hr = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &text);
8048     ok(hr == S_OK, "ret %08x\n", hr );
8049     V_VT(&data) = VT_BSTR;
8050     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
8051     hr = IXMLDOMText_put_nodeValue(text, data);
8052     ok(hr == S_OK, "ret %08x\n", hr );
8053     IXMLDOMText_Release(text);
8054
8055     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8056     ok(hr == S_OK, "ret %08x\n", hr );
8057     V_VT(&data) = VT_BSTR;
8058     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
8059     hr = IXMLDOMAttribute_put_nodeValue(attr, data);
8060     ok(hr == S_OK, "ret %08x\n", hr );
8061     hr = IXMLDOMAttribute_get_nodeValue(attr, &data);
8062     ok(hr == S_OK, "ret %08x\n", hr );
8063     ok(memcmp(V_BSTR(&data), jeevesW, sizeof(jeevesW)) == 0, "got %s\n",
8064         wine_dbgstr_w(V_BSTR(&data)));
8065     VariantClear(&data);
8066     IXMLDOMAttribute_Release(attr);
8067
8068     free_bstrs();
8069
8070     IXMLDOMDocument_Release(doc);
8071 }
8072
8073 static void test_document_IObjectSafety(void)
8074 {
8075     IXMLDOMDocument *doc;
8076     IObjectSafety *safety;
8077     HRESULT hr;
8078
8079     doc = create_document(&IID_IXMLDOMDocument);
8080     if (!doc) return;
8081
8082     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IObjectSafety, (void**)&safety);
8083     ok(hr == S_OK, "ret %08x\n", hr );
8084
8085     test_IObjectSafety_common(safety);
8086
8087     IObjectSafety_Release(safety);
8088
8089     IXMLDOMDocument_Release(doc);
8090 }
8091
8092 typedef struct _property_test_t {
8093     const GUID *guid;
8094     const char *clsid;
8095     const char *property;
8096     const char *value;
8097 } property_test_t;
8098
8099 static const property_test_t properties_test_data[] = {
8100     { &CLSID_DOMDocument,  "CLSID_DOMDocument" , "SelectionLanguage", "XSLPattern" },
8101     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2" , "SelectionLanguage", "XSLPattern" },
8102     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "SelectionLanguage", "XSLPattern" },
8103     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "SelectionLanguage", "XPath" },
8104     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "SelectionLanguage", "XPath" },
8105     { 0 }
8106 };
8107
8108 static void test_default_properties(void)
8109 {
8110     const property_test_t *entry = properties_test_data;
8111
8112     while (entry->guid)
8113     {
8114         IXMLDOMDocument2 *doc;
8115         VARIANT var;
8116         HRESULT hr;
8117
8118         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
8119         if (hr != S_OK)
8120         {
8121             win_skip("can't create %s instance\n", entry->clsid);
8122             entry++;
8123             continue;
8124         }
8125
8126         hr = IXMLDOMDocument2_getProperty(doc, _bstr_(entry->property), &var);
8127         ok(hr == S_OK, "got 0x%08x\n", hr);
8128         ok(lstrcmpW(V_BSTR(&var), _bstr_(entry->value)) == 0, "expected %s, for %s\n",
8129            entry->value, entry->clsid);
8130         VariantClear(&var);
8131
8132         IXMLDOMDocument2_Release(doc);
8133
8134         entry++;
8135     }
8136 }
8137
8138 typedef struct {
8139     const char *query;
8140     const char *list;
8141 } xslpattern_test_t;
8142
8143 static const xslpattern_test_t xslpattern_test[] = {
8144     { "root//elem[0]", "E1.E2.D1" },
8145     { "root//elem[index()=1]", "E2.E2.D1" },
8146     { "root//elem[index() $eq$ 1]", "E2.E2.D1" },
8147     { "root//elem[end()]", "E4.E2.D1" },
8148     { "root//elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
8149     { "root//elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
8150     { "root//elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
8151     { "root//elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
8152     { "root//elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
8153     { "root//elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
8154     { "root//elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
8155     { "root//elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
8156     { "root//elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
8157     { "root//elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
8158     { "root//elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
8159     { "root//elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
8160     { "root//elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
8161     { "root//elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
8162     { "root//elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
8163     { "root//elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
8164     { "root//elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
8165     { "root//elem[$any$ *='B2 field']", "E2.E2.D1" },
8166     { "root//elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
8167     { "root//elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
8168     { "root//elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
8169     { "root//elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
8170     { "root//elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8171     { "root//elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8172     { "root//elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8173     { "root/elem[0]", "E1.E2.D1" },
8174     { "root/elem[index()=1]", "E2.E2.D1" },
8175     { "root/elem[index() $eq$ 1]", "E2.E2.D1" },
8176     { "root/elem[end()]", "E4.E2.D1" },
8177     { "root/elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
8178     { "root/elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
8179     { "root/elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
8180     { "root/elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
8181     { "root/elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
8182     { "root/elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
8183     { "root/elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
8184     { "root/elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
8185     { "root/elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
8186     { "root/elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
8187     { "root/elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
8188     { "root/elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
8189     { "root/elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
8190     { "root/elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
8191     { "root/elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
8192     { "root/elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
8193     { "root/elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
8194     { "root/elem[$any$ *='B2 field']", "E2.E2.D1" },
8195     { "root/elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
8196     { "root/elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
8197     { "root/elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
8198     { "root/elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
8199     { "root/elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8200     { "root/elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8201     { "root/elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
8202     { "root/elem[d]", "E1.E2.D1 E2.E2.D1 E4.E2.D1" },
8203     { NULL }
8204 };
8205
8206 static const xslpattern_test_t xslpattern_test_no_ns[] = {
8207     /* prefixes don't need to be registered, you may use them as they are in the doc */
8208     { "//bar:x", "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1" },
8209     /* prefixes must be explicitly specified in the name */
8210     { "//foo:elem", "" },
8211     { "//foo:c", "E3.E4.E2.D1" },
8212     { NULL }
8213 };
8214
8215 static const xslpattern_test_t xslpattern_test_func[] = {
8216     { "attribute()", "" },
8217     { "attribute('depth')", "" },
8218     { "root/attribute('depth')", "A'depth'.E3.D1" },
8219     { "//x/attribute()", "A'id'.E3.E3.D1 A'depth'.E3.E3.D1" },
8220     { "//x//attribute(id)", NULL },
8221     { "//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" },
8222     { "comment()", "C2.D1" },
8223     { "//comment()", "C2.D1 C1.E3.D1 C2.E3.E3.D1 C2.E4.E3.D1" },
8224     { "element()", "E3.D1" },
8225     { "root/y/element()", "E4.E4.E3.D1 E5.E4.E3.D1 E6.E4.E3.D1" },
8226     { "//element(a)", NULL },
8227     { "//element('a')", "E4.E3.E3.D1 E4.E4.E3.D1" },
8228     { "node()", "P1.D1 C2.D1 E3.D1" },
8229     { "//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" },
8230     { "//x/node()[nodeType()=1]", "E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1" },
8231     { "//x/node()[nodeType()=3]", "T3.E3.E3.D1" },
8232     { "//x/node()[nodeType()=7]", "P1.E3.E3.D1" },
8233     { "//x/node()[nodeType()=8]", "C2.E3.E3.D1" },
8234     { "pi()", "P1.D1" },
8235     { "//y/pi()", "P1.E4.E3.D1" },
8236     { "root/textnode()", "T2.E3.D1" },
8237     { "root/element()/textnode()", "T3.E3.E3.D1 T3.E4.E3.D1" },
8238     { NULL }
8239 };
8240
8241 static void test_XSLPattern(void)
8242 {
8243     const xslpattern_test_t *ptr = xslpattern_test;
8244     IXMLDOMDocument2 *doc;
8245     IXMLDOMNodeList *list;
8246     VARIANT_BOOL b;
8247     HRESULT hr;
8248     LONG len;
8249
8250     doc = create_document(&IID_IXMLDOMDocument2);
8251     if (!doc) return;
8252
8253     b = VARIANT_FALSE;
8254     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
8255     EXPECT_HR(hr, S_OK);
8256     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8257
8258     /* switch to XSLPattern */
8259     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern"));
8260     EXPECT_HR(hr, S_OK);
8261
8262     /* XPath doesn't select elements with non-null default namespace with unqualified selectors, XSLPattern does */
8263     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem/c"), &list);
8264     EXPECT_HR(hr, S_OK);
8265
8266     len = 0;
8267     hr = IXMLDOMNodeList_get_length(list, &len);
8268     EXPECT_HR(hr, S_OK);
8269     /* should select <elem><c> and <elem xmlns='...'><c> but not <elem><foo:c> */
8270     ok(len == 3, "expected 3 entries in list, got %d\n", len);
8271     IXMLDOMNodeList_Release(list);
8272
8273     while (ptr->query)
8274     {
8275         list = NULL;
8276         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
8277         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
8278         len = 0;
8279         hr = IXMLDOMNodeList_get_length(list, &len);
8280         ok(len != 0, "query=%s, empty list\n", ptr->query);
8281         if (len)
8282             expect_list_and_release(list, ptr->list);
8283
8284         ptr++;
8285     }
8286
8287     /* namespace handling */
8288     /* no registered namespaces */
8289     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_(""));
8290     EXPECT_HR(hr, S_OK);
8291
8292     ptr = xslpattern_test_no_ns;
8293     while (ptr->query)
8294     {
8295         list = NULL;
8296         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
8297         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
8298
8299         if (*ptr->list)
8300         {
8301             len = 0;
8302             hr = IXMLDOMNodeList_get_length(list, &len);
8303             EXPECT_HR(hr, S_OK);
8304             ok(len != 0, "query=%s, empty list\n", ptr->query);
8305         }
8306         else
8307         {
8308             len = 1;
8309             hr = IXMLDOMNodeList_get_length(list, &len);
8310             EXPECT_HR(hr, S_OK);
8311             ok(len == 0, "query=%s, empty list\n", ptr->query);
8312         }
8313         if (len)
8314             expect_list_and_release(list, ptr->list);
8315
8316         ptr++;
8317     }
8318
8319     /* explicitly register prefix foo */
8320     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
8321
8322     /* now we get the same behavior as XPath */
8323     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
8324     EXPECT_HR(hr, S_OK);
8325     len = 0;
8326     hr = IXMLDOMNodeList_get_length(list, &len);
8327     EXPECT_HR(hr, S_OK);
8328     ok(len != 0, "expected filled list\n");
8329     if (len)
8330         expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
8331
8332     /* set prefix foo to some nonexistent namespace */
8333     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:nonexistent-foo'"));
8334     EXPECT_HR(hr, S_OK);
8335
8336     /* the registered prefix takes precedence */
8337     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
8338     EXPECT_HR(hr, S_OK);
8339     len = 0;
8340     hr = IXMLDOMNodeList_get_length(list, &len);
8341     EXPECT_HR(hr, S_OK);
8342     ok(len == 0, "expected empty list\n");
8343     IXMLDOMNodeList_Release(list);
8344
8345     IXMLDOMDocument2_Release(doc);
8346
8347     doc = create_document(&IID_IXMLDOMDocument2);
8348     if (!doc) return;
8349
8350     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNodeTypesXML), &b);
8351     EXPECT_HR(hr, S_OK);
8352     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8353
8354     ptr = xslpattern_test_func;
8355     while (ptr->query)
8356     {
8357         list = NULL;
8358         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
8359         if (ptr->list)
8360         {
8361             ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
8362             len = 0;
8363             hr = IXMLDOMNodeList_get_length(list, &len);
8364             if (*ptr->list)
8365             {
8366                 ok(len != 0, "query=%s, empty list\n", ptr->query);
8367                 if (len)
8368                     expect_list_and_release(list, ptr->list);
8369             }
8370             else
8371                 ok(len == 0, "query=%s, filled list\n", ptr->query);
8372         }
8373         else
8374             ok(hr == E_FAIL, "query=%s, failed with 0x%08x\n", ptr->query, hr);
8375
8376         ptr++;
8377     }
8378
8379     IXMLDOMDocument2_Release(doc);
8380     free_bstrs();
8381 }
8382
8383 static void test_splitText(void)
8384 {
8385     IXMLDOMCDATASection *cdata;
8386     IXMLDOMElement *root;
8387     IXMLDOMDocument *doc;
8388     IXMLDOMText *text, *text2;
8389     IXMLDOMNode *node;
8390     VARIANT var;
8391     VARIANT_BOOL success;
8392     LONG length;
8393     HRESULT hr;
8394
8395     doc = create_document(&IID_IXMLDOMDocument);
8396     if (!doc) return;
8397
8398     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<root></root>"), &success);
8399     ok(hr == S_OK, "got 0x%08x\n", hr);
8400
8401     hr = IXMLDOMDocument_get_documentElement(doc, &root);
8402     ok(hr == S_OK, "got 0x%08x\n", hr);
8403
8404     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("beautiful plumage"), &cdata);
8405     ok(hr == S_OK, "got 0x%08x\n", hr);
8406
8407     V_VT(&var) = VT_EMPTY;
8408     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)cdata, NULL);
8409     ok(hr == S_OK, "got 0x%08x\n", hr);
8410
8411     length = 0;
8412     hr = IXMLDOMCDATASection_get_length(cdata, &length);
8413     ok(hr == S_OK, "got 0x%08x\n", hr);
8414     ok(length > 0, "got %d\n", length);
8415
8416     hr = IXMLDOMCDATASection_splitText(cdata, 0, NULL);
8417     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8418
8419     text = (void*)0xdeadbeef;
8420     /* negative offset */
8421     hr = IXMLDOMCDATASection_splitText(cdata, -1, &text);
8422     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8423     ok(text == (void*)0xdeadbeef, "got %p\n", text);
8424
8425     text = (void*)0xdeadbeef;
8426     /* offset outside data */
8427     hr = IXMLDOMCDATASection_splitText(cdata, length + 1, &text);
8428     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8429     ok(text == 0, "got %p\n", text);
8430
8431     text = (void*)0xdeadbeef;
8432     /* offset outside data */
8433     hr = IXMLDOMCDATASection_splitText(cdata, length, &text);
8434     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8435     ok(text == 0, "got %p\n", text);
8436
8437     /* no empty node created */
8438     node = (void*)0xdeadbeef;
8439     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
8440     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8441     ok(node == 0, "got %p\n", text);
8442
8443     hr = IXMLDOMCDATASection_splitText(cdata, 10, &text);
8444     ok(hr == S_OK, "got 0x%08x\n", hr);
8445
8446     length = 0;
8447     hr = IXMLDOMText_get_length(text, &length);
8448     ok(hr == S_OK, "got 0x%08x\n", hr);
8449     ok(length == 7, "got %d\n", length);
8450
8451     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
8452     ok(hr == S_OK, "got 0x%08x\n", hr);
8453     IXMLDOMNode_Release(node);
8454
8455     /* split new text node */
8456     hr = IXMLDOMText_get_length(text, &length);
8457     ok(hr == S_OK, "got 0x%08x\n", hr);
8458
8459     node = (void*)0xdeadbeef;
8460     hr = IXMLDOMText_get_nextSibling(text, &node);
8461     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8462     ok(node == 0, "got %p\n", text);
8463
8464     hr = IXMLDOMText_splitText(text, 0, NULL);
8465     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8466
8467     text2 = (void*)0xdeadbeef;
8468     /* negative offset */
8469     hr = IXMLDOMText_splitText(text, -1, &text2);
8470     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8471     ok(text2 == (void*)0xdeadbeef, "got %p\n", text2);
8472
8473     text2 = (void*)0xdeadbeef;
8474     /* offset outside data */
8475     hr = IXMLDOMText_splitText(text, length + 1, &text2);
8476     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8477     ok(text2 == 0, "got %p\n", text2);
8478
8479     text2 = (void*)0xdeadbeef;
8480     /* offset outside data */
8481     hr = IXMLDOMText_splitText(text, length, &text2);
8482     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8483     ok(text2 == 0, "got %p\n", text);
8484
8485     text2 = 0;
8486     hr = IXMLDOMText_splitText(text, 4, &text2);
8487     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
8488     if (text2) IXMLDOMText_Release(text2);
8489
8490     node = 0;
8491     hr = IXMLDOMText_get_nextSibling(text, &node);
8492     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
8493     if (node) IXMLDOMNode_Release(node);
8494
8495     IXMLDOMText_Release(text);
8496     IXMLDOMElement_Release(root);
8497     IXMLDOMCDATASection_Release(cdata);
8498     free_bstrs();
8499 }
8500
8501 typedef struct {
8502     const char *name;
8503     const char *uri;
8504     HRESULT hr;
8505 } ns_item_t;
8506
8507 /* default_ns_doc used */
8508 static const ns_item_t qualified_item_tests[] = {
8509     { "xml:lang", NULL, S_FALSE },
8510     { "xml:lang", "http://www.w3.org/XML/1998/namespace", S_FALSE },
8511     { "lang", "http://www.w3.org/XML/1998/namespace", S_OK },
8512     { "ns:b", NULL, S_FALSE },
8513     { "ns:b", "nshref", S_FALSE },
8514     { "b", "nshref", S_OK },
8515     { "d", NULL, S_OK },
8516     { NULL }
8517 };
8518
8519 static const ns_item_t named_item_tests[] = {
8520     { "xml:lang", NULL, S_OK },
8521     { "lang", NULL, S_FALSE },
8522     { "ns:b", NULL, S_OK },
8523     { "b", NULL, S_FALSE },
8524     { "d", NULL, S_OK },
8525     { NULL }
8526 };
8527
8528 static void test_getQualifiedItem(void)
8529 {
8530     IXMLDOMNode *pr_node, *node;
8531     IXMLDOMNodeList *root_list;
8532     IXMLDOMNamedNodeMap *map;
8533     IXMLDOMElement *element;
8534     const ns_item_t* ptr;
8535     IXMLDOMDocument *doc;
8536     VARIANT_BOOL b;
8537     HRESULT hr;
8538     LONG len;
8539
8540     doc = create_document(&IID_IXMLDOMDocument);
8541     if (!doc) return;
8542
8543     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8544     EXPECT_HR(hr, S_OK);
8545     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8546
8547     hr = IXMLDOMDocument_get_documentElement(doc, &element);
8548     EXPECT_HR(hr, S_OK);
8549
8550     hr = IXMLDOMElement_get_childNodes(element, &root_list);
8551     EXPECT_HR(hr, S_OK);
8552
8553     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
8554     EXPECT_HR(hr, S_OK);
8555     IXMLDOMNodeList_Release(root_list);
8556
8557     hr = IXMLDOMNode_get_attributes(pr_node, &map);
8558     EXPECT_HR(hr, S_OK);
8559     IXMLDOMNode_Release(pr_node);
8560
8561     len = 0;
8562     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
8563     EXPECT_HR(hr, S_OK);
8564     ok( len == 3, "length %d\n", len);
8565
8566     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, NULL);
8567     EXPECT_HR(hr, E_INVALIDARG);
8568
8569     node = (void*)0xdeadbeef;
8570     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, &node);
8571     EXPECT_HR(hr, E_INVALIDARG);
8572     ok( node == (void*)0xdeadbeef, "got %p\n", node);
8573
8574     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, NULL);
8575     EXPECT_HR(hr, E_INVALIDARG);
8576
8577     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, &node);
8578     EXPECT_HR(hr, S_OK);
8579
8580     IXMLDOMNode_Release(node);
8581     IXMLDOMNamedNodeMap_Release(map);
8582     IXMLDOMElement_Release(element);
8583
8584     hr = IXMLDOMDocument_loadXML(doc, _bstr_(default_ns_doc), &b);
8585     EXPECT_HR(hr, S_OK);
8586
8587     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("a"), &node);
8588     EXPECT_HR(hr, S_OK);
8589
8590     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&element);
8591     EXPECT_HR(hr, S_OK);
8592     IXMLDOMNode_Release(node);
8593
8594     hr = IXMLDOMElement_get_attributes(element, &map);
8595     EXPECT_HR(hr, S_OK);
8596
8597     ptr = qualified_item_tests;
8598     while (ptr->name)
8599     {
8600        node = (void*)0xdeadbeef;
8601        hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
8602        ok(hr == ptr->hr, "%s, %s: got 0x%08x, expected 0x%08x\n", ptr->name, ptr->uri, hr, ptr->hr);
8603        if (hr == S_OK)
8604            IXMLDOMNode_Release(node);
8605        else
8606            ok(node == NULL, "%s, %s: got %p\n", ptr->name, ptr->uri, node);
8607        ptr++;
8608     }
8609
8610     ptr = named_item_tests;
8611     while (ptr->name)
8612     {
8613        node = (void*)0xdeadbeef;
8614        hr = IXMLDOMNamedNodeMap_getNamedItem(map, _bstr_(ptr->name), &node);
8615        ok(hr == ptr->hr, "%s: got 0x%08x, expected 0x%08x\n", ptr->name, hr, ptr->hr);
8616        if (hr == S_OK)
8617            IXMLDOMNode_Release(node);
8618        else
8619            ok(node == NULL, "%s: got %p\n", ptr->name, node);
8620        ptr++;
8621     }
8622
8623     IXMLDOMNamedNodeMap_Release(map);
8624
8625     IXMLDOMElement_Release(element);
8626     IXMLDOMDocument_Release(doc);
8627     free_bstrs();
8628 }
8629
8630 static void test_removeQualifiedItem(void)
8631 {
8632     IXMLDOMDocument *doc;
8633     IXMLDOMElement *element;
8634     IXMLDOMNode *pr_node, *node;
8635     IXMLDOMNodeList *root_list;
8636     IXMLDOMNamedNodeMap *map;
8637     VARIANT_BOOL b;
8638     LONG len;
8639     HRESULT hr;
8640
8641     doc = create_document(&IID_IXMLDOMDocument);
8642     if (!doc) return;
8643
8644     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8645     ok( hr == S_OK, "loadXML failed\n");
8646     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8647
8648     hr = IXMLDOMDocument_get_documentElement(doc, &element);
8649     ok( hr == S_OK, "ret %08x\n", hr);
8650
8651     hr = IXMLDOMElement_get_childNodes(element, &root_list);
8652     ok( hr == S_OK, "ret %08x\n", hr);
8653
8654     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
8655     ok( hr == S_OK, "ret %08x\n", hr);
8656     IXMLDOMNodeList_Release(root_list);
8657
8658     hr = IXMLDOMNode_get_attributes(pr_node, &map);
8659     ok( hr == S_OK, "ret %08x\n", hr);
8660     IXMLDOMNode_Release(pr_node);
8661
8662     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
8663     ok( hr == S_OK, "ret %08x\n", hr);
8664     ok( len == 3, "length %d\n", len);
8665
8666     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, NULL);
8667     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
8668
8669     node = (void*)0xdeadbeef;
8670     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, &node);
8671     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
8672     ok( node == (void*)0xdeadbeef, "got %p\n", node);
8673
8674     /* out pointer is optional */
8675     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
8676     ok( hr == S_OK, "ret %08x\n", hr);
8677
8678     /* already removed */
8679     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
8680     ok( hr == S_FALSE, "ret %08x\n", hr);
8681
8682     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("vr"), NULL, &node);
8683     ok( hr == S_OK, "ret %08x\n", hr);
8684     IXMLDOMNode_Release(node);
8685
8686     IXMLDOMNamedNodeMap_Release( map );
8687     IXMLDOMElement_Release( element );
8688     IXMLDOMDocument_Release( doc );
8689     free_bstrs();
8690 }
8691
8692 #define check_default_props(doc) _check_default_props(__LINE__, doc)
8693 static inline void _check_default_props(int line, IXMLDOMDocument2* doc)
8694 {
8695     VARIANT_BOOL b;
8696     VARIANT var;
8697     HRESULT hr;
8698
8699     VariantInit(&var);
8700     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
8701     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XSLPattern")) == 0, "expected XSLPattern\n");
8702     VariantClear(&var);
8703
8704     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
8705     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("")) == 0, "expected empty string\n");
8706     VariantClear(&var);
8707
8708     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
8709     ok_(__FILE__, line)(b == VARIANT_FALSE, "expected FALSE\n");
8710
8711     hr = IXMLDOMDocument2_get_schemas(doc, &var);
8712     ok_(__FILE__, line)(hr == S_FALSE, "got %08x\n", hr);
8713     VariantClear(&var);
8714 }
8715
8716 #define check_set_props(doc) _check_set_props(__LINE__, doc)
8717 static inline void _check_set_props(int line, IXMLDOMDocument2* doc)
8718 {
8719     VARIANT_BOOL b;
8720     VARIANT var;
8721
8722     VariantInit(&var);
8723     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
8724     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XPath")) == 0, "expected XPath\n");
8725     VariantClear(&var);
8726
8727     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
8728     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("xmlns:wi=\'www.winehq.org\'")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&var)));
8729     VariantClear(&var);
8730
8731     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
8732     ok_(__FILE__, line)(b == VARIANT_TRUE, "expected TRUE\n");
8733
8734     helper_ole_check(IXMLDOMDocument2_get_schemas(doc, &var));
8735     ok_(__FILE__, line)(V_VT(&var) != VT_NULL, "expected pointer\n");
8736     VariantClear(&var);
8737 }
8738
8739 #define set_props(doc, cache) _set_props(__LINE__, doc, cache)
8740 static inline void _set_props(int line, IXMLDOMDocument2* doc, IXMLDOMSchemaCollection* cache)
8741 {
8742     VARIANT var;
8743
8744     VariantInit(&var);
8745     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
8746     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:wi=\'www.winehq.org\'")));
8747     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_TRUE));
8748     V_VT(&var) = VT_DISPATCH;
8749     V_DISPATCH(&var) = NULL;
8750     helper_ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&var)));
8751     ok_(__FILE__, line)(V_DISPATCH(&var) != NULL, "expected pointer\n");
8752     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
8753     VariantClear(&var);
8754 }
8755
8756 #define unset_props(doc) _unset_props(__LINE__, doc)
8757 static inline void _unset_props(int line, IXMLDOMDocument2* doc)
8758 {
8759     VARIANT var;
8760
8761     VariantInit(&var);
8762     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
8763     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("")));
8764     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_FALSE));
8765     V_VT(&var) = VT_NULL;
8766     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
8767     VariantClear(&var);
8768 }
8769
8770 static void test_get_ownerDocument(void)
8771 {
8772     IXMLDOMDocument *doc1, *doc2, *doc3;
8773     IXMLDOMDocument2 *doc, *doc_owner;
8774     IXMLDOMNode *node;
8775     IXMLDOMSchemaCollection *cache;
8776     VARIANT_BOOL b;
8777     VARIANT var;
8778
8779     doc = create_document(&IID_IXMLDOMDocument2);
8780     cache = create_cache(&IID_IXMLDOMSchemaCollection);
8781     if (!doc || !cache)
8782     {
8783         if (doc) IXMLDOMDocument2_Release(doc);
8784         if (cache) IXMLDOMSchemaCollection_Release(cache);
8785         return;
8786     }
8787
8788     VariantInit(&var);
8789
8790     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
8791     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8792
8793     check_default_props(doc);
8794
8795     /* set properties and check that new instances use them */
8796     set_props(doc, cache);
8797     check_set_props(doc);
8798
8799     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
8800     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc1));
8801
8802     /* new interface keeps props */
8803     ole_check(IXMLDOMDocument_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**)&doc_owner));
8804     ok( doc_owner != doc, "got %p, doc %p\n", doc_owner, doc);
8805     check_set_props(doc_owner);
8806     IXMLDOMDocument2_Release(doc_owner);
8807
8808     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc2));
8809     IXMLDOMNode_Release(node);
8810
8811     ok(doc1 != doc2, "got %p, expected %p. original %p\n", doc2, doc1, doc);
8812
8813     /* reload */
8814     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
8815     ok(b == VARIANT_TRUE, "failed to load XML string\n");
8816
8817     /* properties retained even after reload */
8818     check_set_props(doc);
8819
8820     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
8821     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc3));
8822     IXMLDOMNode_Release(node);
8823
8824     ole_check(IXMLDOMDocument_QueryInterface(doc3, &IID_IXMLDOMDocument2, (void**)&doc_owner));
8825     ok(doc3 != doc1 && doc3 != doc2 && doc_owner != doc, "got %p, (%p, %p, %p)\n", doc3, doc, doc1, doc2);
8826     check_set_props(doc_owner);
8827
8828     /* changing properties for one instance changes them for all */
8829     unset_props(doc_owner);
8830     check_default_props(doc_owner);
8831     check_default_props(doc);
8832
8833     IXMLDOMSchemaCollection_Release(cache);
8834     IXMLDOMDocument_Release(doc1);
8835     IXMLDOMDocument_Release(doc2);
8836     IXMLDOMDocument_Release(doc3);
8837     IXMLDOMDocument2_Release(doc);
8838     IXMLDOMDocument2_Release(doc_owner);
8839     free_bstrs();
8840 }
8841
8842 static void test_setAttributeNode(void)
8843 {
8844     IXMLDOMDocument *doc, *doc2;
8845     IXMLDOMElement *elem, *elem2;
8846     IXMLDOMAttribute *attr, *attr2, *ret_attr;
8847     VARIANT_BOOL b;
8848     HRESULT hr;
8849     VARIANT v;
8850     BSTR str;
8851     ULONG ref1, ref2;
8852
8853     doc = create_document(&IID_IXMLDOMDocument);
8854     if (!doc) return;
8855
8856     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
8857     ok( hr == S_OK, "loadXML failed\n");
8858     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8859
8860     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
8861     ok( hr == S_OK, "got 0x%08x\n", hr);
8862
8863     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
8864     ok( hr == S_OK, "got 0x%08x\n", hr);
8865     ok( elem2 != elem, "got same instance\n");
8866
8867     ret_attr = (void*)0xdeadbeef;
8868     hr = IXMLDOMElement_setAttributeNode(elem, NULL, &ret_attr);
8869     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
8870     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8871
8872     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8873     ok( hr == S_OK, "got 0x%08x\n", hr);
8874
8875     ref1 = IXMLDOMElement_AddRef(elem);
8876     IXMLDOMElement_Release(elem);
8877
8878     ret_attr = (void*)0xdeadbeef;
8879     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8880     ok( hr == S_OK, "got 0x%08x\n", hr);
8881     ok( ret_attr == NULL, "got %p\n", ret_attr);
8882
8883     /* no reference added */
8884     ref2 = IXMLDOMElement_AddRef(elem);
8885     IXMLDOMElement_Release(elem);
8886     ok(ref2 == ref1, "got %d, expected %d\n", ref2, ref1);
8887
8888     EXPECT_CHILDREN(elem);
8889     EXPECT_CHILDREN(elem2);
8890
8891     IXMLDOMElement_Release(elem2);
8892
8893     attr2 = NULL;
8894     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attr"), &attr2);
8895     ok( hr == S_OK, "got 0x%08x\n", hr);
8896     ok( attr2 != attr, "got same instance %p\n", attr2);
8897     IXMLDOMAttribute_Release(attr2);
8898
8899     /* try to add it another time */
8900     ret_attr = (void*)0xdeadbeef;
8901     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8902     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8903     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8904
8905     IXMLDOMElement_Release(elem);
8906
8907     /* initially used element is released, attribute still 'has' a container */
8908     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
8909     ok( hr == S_OK, "got 0x%08x\n", hr);
8910     ret_attr = (void*)0xdeadbeef;
8911     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8912     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8913     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
8914     IXMLDOMElement_Release(elem);
8915
8916     /* add attribute already attached to another document */
8917     doc2 = create_document(&IID_IXMLDOMDocument);
8918
8919     hr = IXMLDOMDocument_loadXML( doc2, _bstr_(complete4A), &b );
8920     ok( hr == S_OK, "loadXML failed\n");
8921     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8922
8923     hr = IXMLDOMDocument_get_documentElement(doc2, &elem);
8924     ok( hr == S_OK, "got 0x%08x\n", hr);
8925     hr = IXMLDOMElement_setAttributeNode(elem, attr, NULL);
8926     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8927     IXMLDOMElement_Release(elem);
8928
8929     IXMLDOMAttribute_Release(attr);
8930
8931     /* create element, add attribute, see if it's copied or linked */
8932     hr = IXMLDOMDocument_createElement(doc, _bstr_("test"), &elem);
8933     ok( hr == S_OK, "got 0x%08x\n", hr);
8934
8935     attr = NULL;
8936     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
8937     ok(hr == S_OK, "got 0x%08x\n", hr);
8938     ok(attr != NULL, "got %p\n", attr);
8939
8940     ref1 = IXMLDOMAttribute_AddRef(attr);
8941     IXMLDOMAttribute_Release(attr);
8942
8943     V_VT(&v) = VT_BSTR;
8944     V_BSTR(&v) = _bstr_("attrvalue1");
8945     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
8946     ok( hr == S_OK, "got 0x%08x\n", hr);
8947
8948     str = NULL;
8949     hr = IXMLDOMAttribute_get_xml(attr, &str);
8950     ok( hr == S_OK, "got 0x%08x\n", hr);
8951     ok( lstrcmpW(str, _bstr_("attr=\"attrvalue1\"")) == 0,
8952         "got %s\n", wine_dbgstr_w(str));
8953     SysFreeString(str);
8954
8955     ret_attr = (void*)0xdeadbeef;
8956     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
8957     ok(hr == S_OK, "got 0x%08x\n", hr);
8958     ok(ret_attr == NULL, "got %p\n", ret_attr);
8959
8960     /* attribute reference increased */
8961     ref2 = IXMLDOMAttribute_AddRef(attr);
8962     IXMLDOMAttribute_Release(attr);
8963     ok(ref1 == ref2, "got %d, expected %d\n", ref2, ref1);
8964
8965     hr = IXMLDOMElement_get_xml(elem, &str);
8966     ok( hr == S_OK, "got 0x%08x\n", hr);
8967     ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue1\"/>")) == 0,
8968         "got %s\n", wine_dbgstr_w(str));
8969     SysFreeString(str);
8970
8971     V_VT(&v) = VT_BSTR;
8972     V_BSTR(&v) = _bstr_("attrvalue2");
8973     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
8974     ok( hr == S_OK, "got 0x%08x\n", hr);
8975
8976     hr = IXMLDOMElement_get_xml(elem, &str);
8977     ok( hr == S_OK, "got 0x%08x\n", hr);
8978     todo_wine ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue2\"/>")) == 0,
8979         "got %s\n", wine_dbgstr_w(str));
8980     SysFreeString(str);
8981
8982     IXMLDOMElement_Release(elem);
8983     IXMLDOMAttribute_Release(attr);
8984     IXMLDOMDocument_Release(doc2);
8985     IXMLDOMDocument_Release(doc);
8986     free_bstrs();
8987 }
8988
8989 static void test_createNode(void)
8990 {
8991     IXMLDOMDocument *doc;
8992     IXMLDOMElement *elem;
8993     IXMLDOMNode *node;
8994     VARIANT v, var;
8995     BSTR prefix, str;
8996     HRESULT hr;
8997     ULONG ref;
8998
8999     doc = create_document(&IID_IXMLDOMDocument);
9000     if (!doc) return;
9001
9002     EXPECT_REF(doc, 1);
9003
9004     /* reference count tests */
9005     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
9006     ok( hr == S_OK, "got 0x%08x\n", hr);
9007
9008     /* initial reference is 2 */
9009 todo_wine {
9010     EXPECT_REF(elem, 2);
9011     ref = IXMLDOMElement_Release(elem);
9012     ok(ref == 1, "got %d\n", ref);
9013     /* it's released already, attempt to release now will crash it */
9014 }
9015
9016     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
9017     ok( hr == S_OK, "got 0x%08x\n", hr);
9018     todo_wine EXPECT_REF(elem, 2);
9019     IXMLDOMDocument_Release(doc);
9020     todo_wine EXPECT_REF(elem, 2);
9021     IXMLDOMElement_Release(elem);
9022
9023     doc = create_document(&IID_IXMLDOMDocument);
9024
9025     /* NODE_ELEMENT nodes */
9026     /* 1. specified namespace */
9027     V_VT(&v) = VT_I4;
9028     V_I4(&v) = NODE_ELEMENT;
9029
9030     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("ns1:test"), _bstr_("http://winehq.org"), &node);
9031     ok( hr == S_OK, "got 0x%08x\n", hr);
9032     prefix = NULL;
9033     hr = IXMLDOMNode_get_prefix(node, &prefix);
9034     ok( hr == S_OK, "got 0x%08x\n", hr);
9035     ok(lstrcmpW(prefix, _bstr_("ns1")) == 0, "wrong prefix\n");
9036     SysFreeString(prefix);
9037     IXMLDOMNode_Release(node);
9038
9039     /* 2. default namespace */
9040     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("test"), _bstr_("http://winehq.org/default"), &node);
9041     ok( hr == S_OK, "got 0x%08x\n", hr);
9042     prefix = (void*)0xdeadbeef;
9043     hr = IXMLDOMNode_get_prefix(node, &prefix);
9044     ok( hr == S_FALSE, "got 0x%08x\n", hr);
9045     ok(prefix == 0, "expected empty prefix, got %p\n", prefix);
9046     /* check dump */
9047     hr = IXMLDOMNode_get_xml(node, &str);
9048     ok( hr == S_OK, "got 0x%08x\n", hr);
9049     ok( lstrcmpW(str, _bstr_("<test xmlns=\"http://winehq.org/default\"/>")) == 0,
9050         "got %s\n", wine_dbgstr_w(str));
9051     SysFreeString(str);
9052
9053     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
9054     ok( hr == S_OK, "got 0x%08x\n", hr);
9055
9056     V_VT(&var) = VT_BSTR;
9057     hr = IXMLDOMElement_getAttribute(elem, _bstr_("xmlns"), &var);
9058     ok( hr == S_FALSE, "got 0x%08x\n", hr);
9059     ok( V_VT(&var) == VT_NULL, "got %d\n", V_VT(&var));
9060
9061     str = NULL;
9062     hr = IXMLDOMElement_get_namespaceURI(elem, &str);
9063     ok( hr == S_OK, "got 0x%08x\n", hr);
9064     ok( lstrcmpW(str, _bstr_("http://winehq.org/default")) == 0, "expected default namespace\n");
9065     SysFreeString(str);
9066
9067     IXMLDOMElement_Release(elem);
9068     IXMLDOMNode_Release(node);
9069
9070     IXMLDOMDocument_Release(doc);
9071     free_bstrs();
9072 }
9073
9074 static const char get_prefix_doc[] =
9075     "<?xml version=\"1.0\" ?>"
9076     "<a xmlns:ns1=\"ns1 href\" />";
9077
9078 static void test_get_prefix(void)
9079 {
9080     IXMLDOMDocumentFragment *fragment;
9081     IXMLDOMCDATASection *cdata;
9082     IXMLDOMElement *element;
9083     IXMLDOMComment *comment;
9084     IXMLDOMDocument *doc;
9085     VARIANT_BOOL b;
9086     HRESULT hr;
9087     BSTR str;
9088
9089     doc = create_document(&IID_IXMLDOMDocument);
9090     if (!doc) return;
9091
9092     /* nodes that can't support prefix */
9093     /* 1. document */
9094     str = (void*)0xdeadbeef;
9095     hr = IXMLDOMDocument_get_prefix(doc, &str);
9096     EXPECT_HR(hr, S_FALSE);
9097     ok(str == NULL, "got %p\n", str);
9098
9099     hr = IXMLDOMDocument_get_prefix(doc, NULL);
9100     EXPECT_HR(hr, E_INVALIDARG);
9101
9102     /* 2. cdata */
9103     hr = IXMLDOMDocument_createCDATASection(doc, NULL, &cdata);
9104     ok(hr == S_OK, "got %08x\n", hr );
9105
9106     str = (void*)0xdeadbeef;
9107     hr = IXMLDOMCDATASection_get_prefix(cdata, &str);
9108     ok(hr == S_FALSE, "got %08x\n", hr);
9109     ok( str == 0, "got %p\n", str);
9110
9111     hr = IXMLDOMCDATASection_get_prefix(cdata, NULL);
9112     ok(hr == E_INVALIDARG, "got %08x\n", hr);
9113     IXMLDOMCDATASection_Release(cdata);
9114
9115     /* 3. comment */
9116     hr = IXMLDOMDocument_createComment(doc, NULL, &comment);
9117     ok(hr == S_OK, "got %08x\n", hr );
9118
9119     str = (void*)0xdeadbeef;
9120     hr = IXMLDOMComment_get_prefix(comment, &str);
9121     ok(hr == S_FALSE, "got %08x\n", hr);
9122     ok( str == 0, "got %p\n", str);
9123
9124     hr = IXMLDOMComment_get_prefix(comment, NULL);
9125     ok(hr == E_INVALIDARG, "got %08x\n", hr);
9126     IXMLDOMComment_Release(comment);
9127
9128     /* 4. fragment */
9129     hr = IXMLDOMDocument_createDocumentFragment(doc, &fragment);
9130     ok(hr == S_OK, "got %08x\n", hr );
9131
9132     str = (void*)0xdeadbeef;
9133     hr = IXMLDOMDocumentFragment_get_prefix(fragment, &str);
9134     ok(hr == S_FALSE, "got %08x\n", hr);
9135     ok( str == 0, "got %p\n", str);
9136
9137     hr = IXMLDOMDocumentFragment_get_prefix(fragment, NULL);
9138     ok(hr == E_INVALIDARG, "got %08x\n", hr);
9139     IXMLDOMDocumentFragment_Release(fragment);
9140
9141     /* no prefix */
9142     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &element);
9143     ok( hr == S_OK, "got 0x%08x\n", hr);
9144
9145     hr = IXMLDOMElement_get_prefix(element, NULL);
9146     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
9147
9148     str = (void*)0xdeadbeef;
9149     hr = IXMLDOMElement_get_prefix(element, &str);
9150     ok( hr == S_FALSE, "got 0x%08x\n", hr);
9151     ok( str == 0, "got %p\n", str);
9152
9153     IXMLDOMElement_Release(element);
9154
9155     /* with prefix */
9156     hr = IXMLDOMDocument_createElement(doc, _bstr_("a:elem"), &element);
9157     ok( hr == S_OK, "got 0x%08x\n", hr);
9158
9159     str = (void*)0xdeadbeef;
9160     hr = IXMLDOMElement_get_prefix(element, &str);
9161     ok( hr == S_OK, "got 0x%08x\n", hr);
9162     ok( lstrcmpW(str, _bstr_("a")) == 0, "expected prefix \"a\"\n");
9163     SysFreeString(str);
9164
9165     str = (void*)0xdeadbeef;
9166     hr = IXMLDOMElement_get_namespaceURI(element, &str);
9167     ok( hr == S_FALSE, "got 0x%08x\n", hr);
9168     ok( str == 0, "got %p\n", str);
9169
9170     IXMLDOMElement_Release(element);
9171
9172     hr = IXMLDOMDocument_loadXML(doc, _bstr_(get_prefix_doc), &b);
9173     EXPECT_HR(hr, S_OK);
9174
9175     hr = IXMLDOMDocument_get_documentElement(doc, &element);
9176     EXPECT_HR(hr, S_OK);
9177
9178     str = (void*)0xdeadbeef;
9179     hr = IXMLDOMElement_get_prefix(element, &str);
9180     EXPECT_HR(hr, S_FALSE);
9181     ok(str == NULL, "got %p\n", str);
9182
9183     str = (void*)0xdeadbeef;
9184     hr = IXMLDOMElement_get_namespaceURI(element, &str);
9185     EXPECT_HR(hr, S_FALSE);
9186     ok(str == NULL, "got %s\n", wine_dbgstr_w(str));
9187
9188     IXMLDOMDocument_Release(doc);
9189     free_bstrs();
9190 }
9191
9192 static void test_selectSingleNode(void)
9193 {
9194     IXMLDOMDocument *doc;
9195     IXMLDOMNodeList *list;
9196     IXMLDOMNode *node;
9197     VARIANT_BOOL b;
9198     HRESULT hr;
9199     LONG len;
9200
9201     doc = create_document(&IID_IXMLDOMDocument);
9202     if (!doc) return;
9203
9204     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
9205     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9206
9207     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
9208     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9209
9210     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
9211     ok( hr == S_OK, "loadXML failed\n");
9212     ok( b == VARIANT_TRUE, "failed to load XML string\n");
9213
9214     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
9215     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9216
9217     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
9218     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9219
9220     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), NULL);
9221     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9222
9223     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), NULL);
9224     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9225
9226     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), &node);
9227     ok(hr == S_OK, "got 0x%08x\n", hr);
9228     IXMLDOMNode_Release(node);
9229
9230     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), &list);
9231     ok(hr == S_OK, "got 0x%08x\n", hr);
9232     IXMLDOMNodeList_Release(list);
9233
9234     list = (void*)0xdeadbeef;
9235     hr = IXMLDOMDocument_selectNodes(doc, NULL, &list);
9236     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9237     ok(list == (void*)0xdeadbeef, "got %p\n", list);
9238
9239     node = (void*)0xdeadbeef;
9240     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("nonexistent"), &node);
9241     ok(hr == S_FALSE, "got 0x%08x\n", hr);
9242     ok(node == 0, "got %p\n", node);
9243
9244     list = (void*)0xdeadbeef;
9245     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("nonexistent"), &list);
9246     ok(hr == S_OK, "got 0x%08x\n", hr);
9247     len = 1;
9248     hr = IXMLDOMNodeList_get_length(list, &len);
9249     ok(hr == S_OK, "got 0x%08x\n", hr);
9250     ok(len == 0, "got %d\n", len);
9251     IXMLDOMNodeList_Release(list);
9252
9253     IXMLDOMDocument_Release(doc);
9254     free_bstrs();
9255 }
9256
9257 static void test_events(void)
9258 {
9259     IConnectionPointContainer *conn;
9260     IConnectionPoint *point;
9261     IXMLDOMDocument *doc;
9262     HRESULT hr;
9263     VARIANT v;
9264     IDispatch *event;
9265
9266     doc = create_document(&IID_IXMLDOMDocument);
9267     if (!doc) return;
9268
9269     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&conn);
9270     ok(hr == S_OK, "got 0x%08x\n", hr);
9271
9272     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IDispatch, &point);
9273     ok(hr == S_OK, "got 0x%08x\n", hr);
9274     IConnectionPoint_Release(point);
9275     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IPropertyNotifySink, &point);
9276     ok(hr == S_OK, "got 0x%08x\n", hr);
9277     IConnectionPoint_Release(point);
9278     hr = IConnectionPointContainer_FindConnectionPoint(conn, &DIID_XMLDOMDocumentEvents, &point);
9279     ok(hr == S_OK, "got 0x%08x\n", hr);
9280     IConnectionPoint_Release(point);
9281
9282     IConnectionPointContainer_Release(conn);
9283
9284     /* ready state callback */
9285     VariantInit(&v);
9286     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9287     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
9288
9289     event = create_dispevent();
9290     V_VT(&v) = VT_UNKNOWN;
9291     V_UNKNOWN(&v) = (IUnknown*)event;
9292
9293     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9294     ok(hr == S_OK, "got 0x%08x\n", hr);
9295     EXPECT_REF(event, 2);
9296
9297     V_VT(&v) = VT_DISPATCH;
9298     V_DISPATCH(&v) = event;
9299
9300     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9301     ok(hr == S_OK, "got 0x%08x\n", hr);
9302     EXPECT_REF(event, 2);
9303
9304     /* VT_NULL doesn't reset event handler */
9305     V_VT(&v) = VT_NULL;
9306     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9307     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
9308     EXPECT_REF(event, 2);
9309
9310     V_VT(&v) = VT_DISPATCH;
9311     V_DISPATCH(&v) = NULL;
9312
9313     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9314     ok(hr == S_OK, "got 0x%08x\n", hr);
9315     EXPECT_REF(event, 1);
9316
9317     V_VT(&v) = VT_UNKNOWN;
9318     V_DISPATCH(&v) = NULL;
9319     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
9320     ok(hr == S_OK, "got 0x%08x\n", hr);
9321
9322     IDispatch_Release(event);
9323
9324     IXMLDOMDocument_Release(doc);
9325 }
9326
9327 static void test_createProcessingInstruction(void)
9328 {
9329     static const WCHAR bodyW[] = {'t','e','s','t',0};
9330     IXMLDOMProcessingInstruction *pi;
9331     IXMLDOMDocument *doc;
9332     WCHAR buff[10];
9333     HRESULT hr;
9334
9335     doc = create_document(&IID_IXMLDOMDocument);
9336     if (!doc) return;
9337
9338     /* test for BSTR handling, pass broken BSTR */
9339     memcpy(&buff[2], bodyW, sizeof(bodyW));
9340     /* just a big length */
9341     *(DWORD*)buff = 0xf0f0;
9342     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("test"), &buff[2], &pi);
9343     ok(hr == S_OK, "got 0x%08x\n", hr);
9344
9345     IXMLDOMProcessingInstruction_Release(pi);
9346     IXMLDOMDocument_Release(doc);
9347 }
9348
9349 static void test_put_nodeTypedValue(void)
9350 {
9351     static const BYTE binhexdata[16] =
9352         {0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf};
9353     IXMLDOMDocument *doc;
9354     IXMLDOMElement *elem;
9355     VARIANT type, value;
9356     LONG ubound, lbound;
9357     IXMLDOMNode *node;
9358     SAFEARRAY *array;
9359     HRESULT hr;
9360     BYTE *ptr;
9361     BSTR str;
9362
9363     doc = create_document(&IID_IXMLDOMDocument);
9364     if (!doc) return;
9365
9366     hr = IXMLDOMDocument_createElement(doc, _bstr_("Element"), &elem);
9367     EXPECT_HR(hr, S_OK);
9368
9369     V_VT(&type) = VT_EMPTY;
9370     hr = IXMLDOMElement_get_dataType(elem, &type);
9371     EXPECT_HR(hr, S_FALSE);
9372     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
9373
9374     /* set typed value for untyped node */
9375     V_VT(&type) = VT_I1;
9376     V_I1(&type) = 1;
9377     hr = IXMLDOMElement_put_nodeTypedValue(elem, type);
9378     EXPECT_HR(hr, S_OK);
9379
9380     V_VT(&type) = VT_EMPTY;
9381     hr = IXMLDOMElement_get_dataType(elem, &type);
9382     EXPECT_HR(hr, S_FALSE);
9383     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
9384
9385     /* no type info stored */
9386     V_VT(&type) = VT_EMPTY;
9387     hr = IXMLDOMElement_get_nodeTypedValue(elem, &type);
9388     EXPECT_HR(hr, S_OK);
9389     ok(V_VT(&type) == VT_BSTR, "got %d, expected VT_BSTR\n", V_VT(&type));
9390     ok(memcmp(V_BSTR(&type), _bstr_("1"), 2*sizeof(WCHAR)) == 0,
9391        "got %s, expected \"1\"\n", wine_dbgstr_w(V_BSTR(&type)));
9392     VariantClear(&type);
9393
9394     hr = IXMLDOMElement_get_firstChild(elem, &node);
9395     EXPECT_HR(hr, S_OK);
9396     hr = IXMLDOMElement_removeChild(elem, node, NULL);
9397     EXPECT_HR(hr, S_OK);
9398     IXMLDOMNode_Release(node);
9399
9400     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)elem, NULL);
9401     EXPECT_HR(hr, S_OK);
9402
9403     /* bin.base64 */
9404     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.base64"));
9405     EXPECT_HR(hr, S_OK);
9406
9407     V_VT(&value) = VT_BSTR;
9408     V_BSTR(&value) = _bstr_("ABCD");
9409     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
9410     EXPECT_HR(hr, S_OK);
9411
9412     V_VT(&value) = VT_EMPTY;
9413     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
9414     EXPECT_HR(hr, S_OK);
9415     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
9416     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
9417     ubound = 0;
9418     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
9419     EXPECT_HR(hr, S_OK);
9420     ok(ubound == 2, "got %d\n", ubound);
9421     lbound = 0;
9422     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
9423     EXPECT_HR(hr, S_OK);
9424     ok(lbound == 0, "got %d\n", lbound);
9425     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
9426     EXPECT_HR(hr, S_OK);
9427     ok(ptr[0] == 0, "got %x\n", ptr[0]);
9428     ok(ptr[1] == 0x10, "got %x\n", ptr[1]);
9429     ok(ptr[2] == 0x83, "got %x\n", ptr[2]);
9430     SafeArrayUnaccessData(V_ARRAY(&value));
9431     VariantClear(&value);
9432
9433     /* when set as VT_BSTR it's stored as is */
9434     hr = IXMLDOMElement_get_firstChild(elem, &node);
9435     EXPECT_HR(hr, S_OK);
9436     hr = IXMLDOMNode_get_text(node, &str);
9437     EXPECT_HR(hr, S_OK);
9438     ok(!lstrcmpW(str, _bstr_("ABCD")), "%s\n", wine_dbgstr_w(str));
9439     IXMLDOMNode_Release(node);
9440
9441     array = SafeArrayCreateVector(VT_UI1, 0, 7);
9442     hr = SafeArrayAccessData(array, (void*)&ptr);
9443     EXPECT_HR(hr, S_OK);
9444     memcpy(ptr, "dGVzdA=", strlen("dGVzdA="));
9445     SafeArrayUnaccessData(array);
9446
9447     V_VT(&value) = VT_UI1|VT_ARRAY;
9448     V_ARRAY(&value) = array;
9449     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
9450     EXPECT_HR(hr, S_OK);
9451
9452     V_VT(&value) = VT_EMPTY;
9453     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
9454     EXPECT_HR(hr, S_OK);
9455     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
9456     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
9457     ubound = 0;
9458     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
9459     EXPECT_HR(hr, S_OK);
9460     ok(ubound == 6, "got %d\n", ubound);
9461     lbound = 0;
9462     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
9463     EXPECT_HR(hr, S_OK);
9464     ok(lbound == 0, "got %d\n", lbound);
9465     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
9466     EXPECT_HR(hr, S_OK);
9467     ok(!memcmp(ptr, "dGVzdA=", strlen("dGVzdA=")), "got wrong data, %s\n", ptr);
9468     SafeArrayUnaccessData(V_ARRAY(&value));
9469     VariantClear(&value);
9470
9471     /* if set with VT_UI1|VT_ARRAY it's encoded */
9472     hr = IXMLDOMElement_get_firstChild(elem, &node);
9473     EXPECT_HR(hr, S_OK);
9474     hr = IXMLDOMNode_get_text(node, &str);
9475     EXPECT_HR(hr, S_OK);
9476     ok(!lstrcmpW(str, _bstr_("ZEdWemRBPQ==")), "%s\n", wine_dbgstr_w(str));
9477     IXMLDOMNode_Release(node);
9478     SafeArrayDestroyData(array);
9479
9480     /* bin.hex */
9481     V_VT(&value) = VT_BSTR;
9482     V_BSTR(&value) = _bstr_("");
9483     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
9484     EXPECT_HR(hr, S_OK);
9485
9486     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.hex"));
9487     EXPECT_HR(hr, S_OK);
9488
9489     array = SafeArrayCreateVector(VT_UI1, 0, 16);
9490     hr = SafeArrayAccessData(array, (void*)&ptr);
9491     EXPECT_HR(hr, S_OK);
9492     memcpy(ptr, binhexdata, sizeof(binhexdata));
9493     SafeArrayUnaccessData(array);
9494
9495     V_VT(&value) = VT_UI1|VT_ARRAY;
9496     V_ARRAY(&value) = array;
9497     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
9498     EXPECT_HR(hr, S_OK);
9499
9500     V_VT(&value) = VT_EMPTY;
9501     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
9502     EXPECT_HR(hr, S_OK);
9503     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
9504     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
9505     ubound = 0;
9506     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
9507     EXPECT_HR(hr, S_OK);
9508     ok(ubound == 15, "got %d\n", ubound);
9509     lbound = 0;
9510     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
9511     EXPECT_HR(hr, S_OK);
9512     ok(lbound == 0, "got %d\n", lbound);
9513     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
9514     EXPECT_HR(hr, S_OK);
9515     ok(!memcmp(ptr, binhexdata, sizeof(binhexdata)), "got wrong data\n");
9516     SafeArrayUnaccessData(V_ARRAY(&value));
9517     VariantClear(&value);
9518
9519     /* if set with VT_UI1|VT_ARRAY it's encoded */
9520     hr = IXMLDOMElement_get_firstChild(elem, &node);
9521     EXPECT_HR(hr, S_OK);
9522     hr = IXMLDOMNode_get_text(node, &str);
9523     EXPECT_HR(hr, S_OK);
9524     ok(!lstrcmpW(str, _bstr_("000102030405060708090a0b0c0d0e0f")), "%s\n", wine_dbgstr_w(str));
9525     IXMLDOMNode_Release(node);
9526     SafeArrayDestroyData(array);
9527
9528     IXMLDOMElement_Release(elem);
9529     IXMLDOMDocument_Release(doc);
9530     free_bstrs();
9531 }
9532
9533 static void test_get_xml(void)
9534 {
9535     static const char xmlA[] = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\r\n<a>test</a>\r\n";
9536     static const char fooA[] = "<foo/>";
9537     IXMLDOMProcessingInstruction *pi;
9538     IXMLDOMNode *first;
9539     IXMLDOMElement *elem = NULL;
9540     IXMLDOMDocument *doc;
9541     VARIANT_BOOL b;
9542     VARIANT v;
9543     BSTR xml;
9544     HRESULT hr;
9545
9546     doc = create_document(&IID_IXMLDOMDocument);
9547     if (!doc) return;
9548
9549     b = VARIANT_TRUE;
9550     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
9551     ok(hr == S_OK, "got 0x%08x\n", hr);
9552     ok( b == VARIANT_TRUE, "got %d\n", b);
9553
9554     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"),
9555                              _bstr_("version=\"1.0\" encoding=\"UTF-16\""), &pi);
9556     ok(hr == S_OK, "got 0x%08x\n", hr);
9557
9558     hr = IXMLDOMDocument_get_firstChild(doc, &first);
9559     ok(hr == S_OK, "got 0x%08x\n", hr);
9560
9561     V_UNKNOWN(&v) = (IUnknown*)first;
9562     V_VT(&v) = VT_UNKNOWN;
9563
9564     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)pi, v, NULL);
9565     ok(hr == S_OK, "got 0x%08x\n", hr);
9566
9567     IXMLDOMProcessingInstruction_Release(pi);
9568     IXMLDOMNode_Release(first);
9569
9570     hr = IXMLDOMDocument_get_xml(doc, &xml);
9571     ok(hr == S_OK, "got 0x%08x\n", hr);
9572
9573     ok(memcmp(xml, _bstr_(xmlA), sizeof(xmlA)*sizeof(WCHAR)) == 0,
9574         "got %s, expected %s\n", wine_dbgstr_w(xml), xmlA);
9575     SysFreeString(xml);
9576
9577     IXMLDOMDocument_Release(doc);
9578
9579     doc = create_document(&IID_IXMLDOMDocument);
9580
9581     hr = IXMLDOMDocument_createElement(doc, _bstr_("foo"), &elem);
9582     ok(hr == S_OK, "got 0x%08x\n", hr);
9583
9584     hr = IXMLDOMDocument_putref_documentElement(doc, elem);
9585     ok(hr == S_OK, "got 0x%08x\n", hr);
9586
9587     hr = IXMLDOMDocument_get_xml(doc, &xml);
9588     ok(hr == S_OK, "got 0x%08x\n", hr);
9589
9590     ok(memcmp(xml, _bstr_(fooA), (sizeof(fooA)-1)*sizeof(WCHAR)) == 0,
9591         "got %s, expected %s\n", wine_dbgstr_w(xml), fooA);
9592     SysFreeString(xml);
9593
9594     IXMLDOMElement_Release(elem);
9595     IXMLDOMDocument_Release(doc);
9596
9597     free_bstrs();
9598 }
9599
9600 static void test_xsltemplate(void)
9601 {
9602     IXSLTemplate *template;
9603     IXSLProcessor *processor;
9604     IXMLDOMDocument *doc, *doc2;
9605     IStream *stream;
9606     VARIANT_BOOL b;
9607     HRESULT hr;
9608     ULONG ref1, ref2;
9609     VARIANT v;
9610
9611     template = create_xsltemplate(&IID_IXSLTemplate);
9612     if (!template) return;
9613
9614     /* works as reset */
9615     hr = IXSLTemplate_putref_stylesheet(template, NULL);
9616     ok(hr == S_OK, "got 0x%08x\n", hr);
9617
9618     doc = create_document(&IID_IXMLDOMDocument);
9619
9620     b = VARIANT_TRUE;
9621     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
9622     ok(hr == S_OK, "got 0x%08x\n", hr);
9623     ok( b == VARIANT_TRUE, "got %d\n", b);
9624
9625     /* putref with non-xsl document */
9626     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
9627     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
9628
9629     b = VARIANT_TRUE;
9630     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
9631     ok(hr == S_OK, "got 0x%08x\n", hr);
9632     ok( b == VARIANT_TRUE, "got %d\n", b);
9633
9634     /* not a freethreaded document */
9635     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
9636     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
9637
9638     IXMLDOMDocument_Release(doc);
9639
9640     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
9641     if (hr != S_OK)
9642     {
9643         win_skip("failed to create free threaded document instance: 0x%08x\n", hr);
9644         IXSLTemplate_Release(template);
9645         return;
9646     }
9647
9648     b = VARIANT_TRUE;
9649     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
9650     ok(hr == S_OK, "got 0x%08x\n", hr);
9651     ok( b == VARIANT_TRUE, "got %d\n", b);
9652
9653     /* freethreaded document */
9654     ref1 = IXMLDOMDocument_AddRef(doc);
9655     IXMLDOMDocument_Release(doc);
9656     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
9657     ok(hr == S_OK, "got 0x%08x\n", hr);
9658     ref2 = IXMLDOMDocument_AddRef(doc);
9659     IXMLDOMDocument_Release(doc);
9660     ok(ref2 > ref1, "got %d\n", ref2);
9661
9662     /* processor */
9663     hr = IXSLTemplate_createProcessor(template, NULL);
9664     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9665
9666     EXPECT_REF(template, 1);
9667     hr = IXSLTemplate_createProcessor(template, &processor);
9668     ok(hr == S_OK, "got 0x%08x\n", hr);
9669     EXPECT_REF(template, 2);
9670
9671     /* input no set yet */
9672     V_VT(&v) = VT_BSTR;
9673     V_BSTR(&v) = NULL;
9674     hr = IXSLProcessor_get_input(processor, &v);
9675 todo_wine {
9676     ok(hr == S_OK, "got 0x%08x\n", hr);
9677     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
9678 }
9679
9680     hr = IXSLProcessor_get_output(processor, NULL);
9681     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9682
9683     /* reset before it was set */
9684     V_VT(&v) = VT_EMPTY;
9685     hr = IXSLProcessor_put_output(processor, v);
9686     ok(hr == S_OK, "got 0x%08x\n", hr);
9687
9688     CreateStreamOnHGlobal(NULL, TRUE, &stream);
9689     EXPECT_REF(stream, 1);
9690
9691     V_VT(&v) = VT_UNKNOWN;
9692     V_UNKNOWN(&v) = (IUnknown*)stream;
9693     hr = IXSLProcessor_put_output(processor, v);
9694     ok(hr == S_OK, "got 0x%08x\n", hr);
9695
9696     /* it seems processor grabs 2 references */
9697     todo_wine EXPECT_REF(stream, 3);
9698
9699     V_VT(&v) = VT_EMPTY;
9700     hr = IXSLProcessor_get_output(processor, &v);
9701     ok(hr == S_OK, "got 0x%08x\n", hr);
9702     ok(V_VT(&v) == VT_UNKNOWN, "got type %d\n", V_VT(&v));
9703     ok(V_UNKNOWN(&v) == (IUnknown*)stream, "got %p\n", V_UNKNOWN(&v));
9704
9705     todo_wine EXPECT_REF(stream, 4);
9706     VariantClear(&v);
9707
9708     hr = IXSLProcessor_transform(processor, NULL);
9709     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9710
9711     /* reset and check stream refcount */
9712     V_VT(&v) = VT_EMPTY;
9713     hr = IXSLProcessor_put_output(processor, v);
9714     ok(hr == S_OK, "got 0x%08x\n", hr);
9715
9716     EXPECT_REF(stream, 1);
9717
9718     IStream_Release(stream);
9719
9720     /* no output interface set, check output */
9721     doc2 = create_document(&IID_IXMLDOMDocument);
9722
9723     b = VARIANT_TRUE;
9724     hr = IXMLDOMDocument_loadXML( doc2, _bstr_("<a>test</a>"), &b );
9725     ok(hr == S_OK, "got 0x%08x\n", hr);
9726     ok( b == VARIANT_TRUE, "got %d\n", b);
9727
9728     V_VT(&v) = VT_UNKNOWN;
9729     V_UNKNOWN(&v) = (IUnknown*)doc2;
9730     hr = IXSLProcessor_put_input(processor, v);
9731     ok(hr == S_OK, "got 0x%08x\n", hr);
9732
9733     hr = IXSLProcessor_transform(processor, &b);
9734     ok(hr == S_OK, "got 0x%08x\n", hr);
9735
9736     V_VT(&v) = VT_EMPTY;
9737     hr = IXSLProcessor_get_output(processor, &v);
9738     ok(hr == S_OK, "got 0x%08x\n", hr);
9739     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
9740     ok(lstrcmpW(V_BSTR(&v), _bstr_("")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
9741     IXMLDOMDocument_Release(doc2);
9742     VariantClear(&v);
9743
9744     IXSLProcessor_Release(processor);
9745
9746     /* drop reference */
9747     hr = IXSLTemplate_putref_stylesheet(template, NULL);
9748     ok(hr == S_OK, "got 0x%08x\n", hr);
9749     ref2 = IXMLDOMDocument_AddRef(doc);
9750     IXMLDOMDocument_Release(doc);
9751     ok(ref2 == ref1, "got %d\n", ref2);
9752
9753     IXMLDOMDocument_Release(doc);
9754     IXSLTemplate_Release(template);
9755     free_bstrs();
9756 }
9757
9758 static void test_insertBefore(void)
9759 {
9760     IXMLDOMDocument *doc, *doc2;
9761     IXMLDOMAttribute *attr;
9762     IXMLDOMElement *elem1, *elem2, *elem3, *elem4, *elem5;
9763     IXMLDOMNode *node, *newnode;
9764     HRESULT hr;
9765     VARIANT v;
9766     BSTR p;
9767
9768     doc = create_document(&IID_IXMLDOMDocument);
9769
9770     /* insertBefore behaviour for attribute node */
9771     V_VT(&v) = VT_I4;
9772     V_I4(&v) = NODE_ATTRIBUTE;
9773
9774     attr = NULL;
9775     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr"), NULL, (IXMLDOMNode**)&attr);
9776     ok(hr == S_OK, "got 0x%08x\n", hr);
9777     ok(attr != NULL, "got %p\n", attr);
9778
9779     /* attribute to attribute */
9780     V_VT(&v) = VT_I4;
9781     V_I4(&v) = NODE_ATTRIBUTE;
9782     newnode = NULL;
9783     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr2"), NULL, &newnode);
9784     ok(hr == S_OK, "got 0x%08x\n", hr);
9785     ok(newnode != NULL, "got %p\n", newnode);
9786
9787     V_VT(&v) = VT_NULL;
9788     node = (void*)0xdeadbeef;
9789     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9790     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9791     ok(node == NULL, "got %p\n", node);
9792
9793     V_VT(&v) = VT_UNKNOWN;
9794     V_UNKNOWN(&v) = (IUnknown*)attr;
9795     node = (void*)0xdeadbeef;
9796     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9797     todo_wine ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
9798     ok(node == NULL, "got %p\n", node);
9799     IXMLDOMNode_Release(newnode);
9800
9801     /* cdata to attribute */
9802     V_VT(&v) = VT_I4;
9803     V_I4(&v) = NODE_CDATA_SECTION;
9804     newnode = NULL;
9805     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9806     ok(hr == S_OK, "got 0x%08x\n", hr);
9807     ok(newnode != NULL, "got %p\n", newnode);
9808
9809     V_VT(&v) = VT_NULL;
9810     node = (void*)0xdeadbeef;
9811     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9812     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9813     ok(node == NULL, "got %p\n", node);
9814     IXMLDOMNode_Release(newnode);
9815
9816     /* comment to attribute */
9817     V_VT(&v) = VT_I4;
9818     V_I4(&v) = NODE_COMMENT;
9819     newnode = NULL;
9820     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9821     ok(hr == S_OK, "got 0x%08x\n", hr);
9822     ok(newnode != NULL, "got %p\n", newnode);
9823
9824     V_VT(&v) = VT_NULL;
9825     node = (void*)0xdeadbeef;
9826     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9827     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9828     ok(node == NULL, "got %p\n", node);
9829     IXMLDOMNode_Release(newnode);
9830
9831     /* element to attribute */
9832     V_VT(&v) = VT_I4;
9833     V_I4(&v) = NODE_ELEMENT;
9834     newnode = NULL;
9835     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9836     ok(hr == S_OK, "got 0x%08x\n", hr);
9837     ok(newnode != NULL, "got %p\n", newnode);
9838
9839     V_VT(&v) = VT_NULL;
9840     node = (void*)0xdeadbeef;
9841     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9842     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9843     ok(node == NULL, "got %p\n", node);
9844     IXMLDOMNode_Release(newnode);
9845
9846     /* pi to attribute */
9847     V_VT(&v) = VT_I4;
9848     V_I4(&v) = NODE_PROCESSING_INSTRUCTION;
9849     newnode = NULL;
9850     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
9851     ok(hr == S_OK, "got 0x%08x\n", hr);
9852     ok(newnode != NULL, "got %p\n", newnode);
9853
9854     V_VT(&v) = VT_NULL;
9855     node = (void*)0xdeadbeef;
9856     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
9857     ok(hr == E_FAIL, "got 0x%08x\n", hr);
9858     ok(node == NULL, "got %p\n", node);
9859     IXMLDOMNode_Release(newnode);
9860     IXMLDOMAttribute_Release(attr);
9861
9862     /* insertBefore for elements */
9863     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem1);
9864     ok(hr == S_OK, "got 0x%08x\n", hr);
9865
9866     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem2"), &elem2);
9867     ok(hr == S_OK, "got 0x%08x\n", hr);
9868
9869     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
9870     ok(hr == S_OK, "got 0x%08x\n", hr);
9871
9872     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
9873     ok(hr == S_OK, "got 0x%08x\n", hr);
9874
9875     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem4"), &elem4);
9876     ok(hr == S_OK, "got 0x%08x\n", hr);
9877
9878     EXPECT_NO_CHILDREN(elem1);
9879     EXPECT_NO_CHILDREN(elem2);
9880     EXPECT_NO_CHILDREN(elem3);
9881
9882     todo_wine EXPECT_REF(elem2, 2);
9883
9884     V_VT(&v) = VT_DISPATCH;
9885     V_DISPATCH(&v) = NULL;
9886     node = NULL;
9887     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem4, v, &node);
9888     ok(hr == S_OK, "got 0x%08x\n", hr);
9889     ok(node == (void*)elem4, "got %p\n", node);
9890
9891     EXPECT_CHILDREN(elem1);
9892     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem4, NULL);
9893     EXPECT_HR(hr, S_OK);
9894     IXMLDOMElement_Release(elem4);
9895
9896     EXPECT_NO_CHILDREN(elem1);
9897
9898     V_VT(&v) = VT_NULL;
9899     node = NULL;
9900     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
9901     ok(hr == S_OK, "got 0x%08x\n", hr);
9902     ok(node == (void*)elem2, "got %p\n", node);
9903
9904     EXPECT_CHILDREN(elem1);
9905     todo_wine EXPECT_REF(elem2, 3);
9906     IXMLDOMNode_Release(node);
9907
9908     /* again for already linked node */
9909     V_VT(&v) = VT_NULL;
9910     node = NULL;
9911     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
9912     ok(hr == S_OK, "got 0x%08x\n", hr);
9913     ok(node == (void*)elem2, "got %p\n", node);
9914
9915     EXPECT_CHILDREN(elem1);
9916
9917     /* increments each time */
9918     todo_wine EXPECT_REF(elem2, 3);
9919     IXMLDOMNode_Release(node);
9920
9921     /* try to add to another element */
9922     V_VT(&v) = VT_NULL;
9923     node = (void*)0xdeadbeef;
9924     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem2, v, &node);
9925     ok(hr == S_OK, "got 0x%08x\n", hr);
9926     ok(node == (void*)elem2, "got %p\n", node);
9927
9928     EXPECT_CHILDREN(elem3);
9929     EXPECT_NO_CHILDREN(elem1);
9930
9931     IXMLDOMNode_Release(node);
9932
9933     /* cross document case - try to add as child to a node created with other doc */
9934     doc2 = create_document(&IID_IXMLDOMDocument);
9935
9936     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem4);
9937     ok(hr == S_OK, "got 0x%08x\n", hr);
9938     todo_wine EXPECT_REF(elem4, 2);
9939
9940     /* same name, another instance */
9941     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem5);
9942     ok(hr == S_OK, "got 0x%08x\n", hr);
9943     todo_wine EXPECT_REF(elem5, 2);
9944
9945     todo_wine EXPECT_REF(elem3, 2);
9946     V_VT(&v) = VT_NULL;
9947     node = NULL;
9948     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem4, v, &node);
9949     ok(hr == S_OK, "got 0x%08x\n", hr);
9950     ok(node == (void*)elem4, "got %p\n", node);
9951     todo_wine EXPECT_REF(elem4, 3);
9952     todo_wine EXPECT_REF(elem3, 2);
9953     IXMLDOMNode_Release(node);
9954
9955     V_VT(&v) = VT_NULL;
9956     node = NULL;
9957     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem5, v, &node);
9958     ok(hr == S_OK, "got 0x%08x\n", hr);
9959     ok(node == (void*)elem5, "got %p\n", node);
9960     todo_wine EXPECT_REF(elem4, 2);
9961     todo_wine EXPECT_REF(elem5, 3);
9962     IXMLDOMNode_Release(node);
9963
9964     IXMLDOMDocument_Release(doc2);
9965
9966     IXMLDOMElement_Release(elem1);
9967     IXMLDOMElement_Release(elem2);
9968     IXMLDOMElement_Release(elem3);
9969     IXMLDOMElement_Release(elem4);
9970     IXMLDOMElement_Release(elem5);
9971
9972     /* elements with same default namespace */
9973     V_VT(&v) = VT_I4;
9974     V_I4(&v) = NODE_ELEMENT;
9975     elem1 = NULL;
9976     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
9977     ok(hr == S_OK, "got 0x%08x\n", hr);
9978     ok(elem1 != NULL, "got %p\n", elem1);
9979
9980     V_VT(&v) = VT_I4;
9981     V_I4(&v) = NODE_ELEMENT;
9982     elem2 = NULL;
9983     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem2);
9984     ok(hr == S_OK, "got 0x%08x\n", hr);
9985     ok(elem2 != NULL, "got %p\n", elem2);
9986
9987     /* check contents so far */
9988     p = NULL;
9989     hr = IXMLDOMElement_get_xml(elem1, &p);
9990     ok(hr == S_OK, "got 0x%08x\n", hr);
9991     ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9992     SysFreeString(p);
9993
9994     p = NULL;
9995     hr = IXMLDOMElement_get_xml(elem2, &p);
9996     ok(hr == S_OK, "got 0x%08x\n", hr);
9997     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
9998     SysFreeString(p);
9999
10000     V_VT(&v) = VT_NULL;
10001     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
10002     ok(hr == S_OK, "got 0x%08x\n", hr);
10003
10004     /* get_xml depends on context, for top node it omits child namespace attribute,
10005        but at child level it's still returned */
10006     p = NULL;
10007     hr = IXMLDOMElement_get_xml(elem1, &p);
10008     ok(hr == S_OK, "got 0x%08x\n", hr);
10009     todo_wine ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"><elem2/></elem1>")),
10010         "got %s\n", wine_dbgstr_w(p));
10011     SysFreeString(p);
10012
10013     p = NULL;
10014     hr = IXMLDOMElement_get_xml(elem2, &p);
10015     ok(hr == S_OK, "got 0x%08x\n", hr);
10016     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
10017     SysFreeString(p);
10018
10019     IXMLDOMElement_Release(elem1);
10020     IXMLDOMElement_Release(elem2);
10021
10022     /* child without default namespace added to node with default namespace */
10023     V_VT(&v) = VT_I4;
10024     V_I4(&v) = NODE_ELEMENT;
10025     elem1 = NULL;
10026     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
10027     ok(hr == S_OK, "got 0x%08x\n", hr);
10028     ok(elem1 != NULL, "got %p\n", elem1);
10029
10030     V_VT(&v) = VT_I4;
10031     V_I4(&v) = NODE_ELEMENT;
10032     elem2 = NULL;
10033     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), NULL, (IXMLDOMNode**)&elem2);
10034     ok(hr == S_OK, "got 0x%08x\n", hr);
10035     ok(elem2 != NULL, "got %p\n", elem2);
10036
10037     EXPECT_REF(elem2, 1);
10038     V_VT(&v) = VT_NULL;
10039     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
10040     ok(hr == S_OK, "got 0x%08x\n", hr);
10041     EXPECT_REF(elem2, 1);
10042
10043     p = NULL;
10044     hr = IXMLDOMElement_get_xml(elem2, &p);
10045     ok(hr == S_OK, "got 0x%08x\n", hr);
10046     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
10047     SysFreeString(p);
10048
10049     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem2, NULL);
10050     ok(hr == S_OK, "got 0x%08x\n", hr);
10051
10052     p = NULL;
10053     hr = IXMLDOMElement_get_xml(elem2, &p);
10054     ok(hr == S_OK, "got 0x%08x\n", hr);
10055     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
10056     SysFreeString(p);
10057
10058     IXMLDOMElement_Release(elem1);
10059     IXMLDOMElement_Release(elem2);
10060     IXMLDOMDocument_Release(doc);
10061 }
10062
10063 static void test_appendChild(void)
10064 {
10065     IXMLDOMDocument *doc, *doc2;
10066     IXMLDOMElement *elem, *elem2;
10067     HRESULT hr;
10068
10069     doc = create_document(&IID_IXMLDOMDocument);
10070     doc2 = create_document(&IID_IXMLDOMDocument);
10071
10072     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
10073     ok(hr == S_OK, "got 0x%08x\n", hr);
10074
10075     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem2"), &elem2);
10076     ok(hr == S_OK, "got 0x%08x\n", hr);
10077
10078     EXPECT_REF(doc, 1);
10079     todo_wine EXPECT_REF(elem, 2);
10080     EXPECT_REF(doc2, 1);
10081     todo_wine EXPECT_REF(elem2, 2);
10082     EXPECT_NO_CHILDREN(doc);
10083     EXPECT_NO_CHILDREN(doc2);
10084
10085     /* append from another document */
10086     hr = IXMLDOMDocument_appendChild(doc2, (IXMLDOMNode*)elem, NULL);
10087     ok(hr == S_OK, "got 0x%08x\n", hr);
10088
10089     EXPECT_REF(doc, 1);
10090     todo_wine EXPECT_REF(elem, 2);
10091     EXPECT_REF(doc2, 1);
10092     todo_wine EXPECT_REF(elem2, 2);
10093     EXPECT_NO_CHILDREN(doc);
10094     EXPECT_CHILDREN(doc2);
10095
10096     IXMLDOMElement_Release(elem);
10097     IXMLDOMElement_Release(elem2);
10098     IXMLDOMDocument_Release(doc);
10099     IXMLDOMDocument_Release(doc2);
10100 }
10101
10102 static void test_get_doctype(void)
10103 {
10104     IXMLDOMDocumentType *doctype;
10105     IXMLDOMDocument *doc;
10106     HRESULT hr;
10107
10108     doc = create_document(&IID_IXMLDOMDocument);
10109
10110     hr = IXMLDOMDocument_get_doctype(doc, NULL);
10111     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10112
10113     doctype = (void*)0xdeadbeef;
10114     hr = IXMLDOMDocument_get_doctype(doc, &doctype);
10115     ok(hr == S_FALSE, "got 0x%08x\n", hr);
10116     ok(doctype == NULL, "got %p\n", doctype);
10117
10118     IXMLDOMDocument_Release(doc);
10119 }
10120
10121 static void test_get_tagName(void)
10122 {
10123     IXMLDOMDocument *doc;
10124     IXMLDOMElement *elem, *elem2;
10125     HRESULT hr;
10126     BSTR str;
10127
10128     doc = create_document(&IID_IXMLDOMDocument);
10129
10130     hr = IXMLDOMDocument_createElement(doc, _bstr_("element"), &elem);
10131     ok(hr == S_OK, "got 0x%08x\n", hr);
10132
10133     hr = IXMLDOMElement_get_tagName(elem, NULL);
10134     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10135
10136     str = NULL;
10137     hr = IXMLDOMElement_get_tagName(elem, &str);
10138     ok(hr == S_OK, "got 0x%08x\n", hr);
10139     ok(!lstrcmpW(str, _bstr_("element")), "got %s\n", wine_dbgstr_w(str));
10140     SysFreeString(str);
10141
10142     hr = IXMLDOMDocument_createElement(doc, _bstr_("s:element"), &elem2);
10143     ok(hr == S_OK, "got 0x%08x\n", hr);
10144
10145     str = NULL;
10146     hr = IXMLDOMElement_get_tagName(elem2, &str);
10147     ok(hr == S_OK, "got 0x%08x\n", hr);
10148     ok(!lstrcmpW(str, _bstr_("s:element")), "got %s\n", wine_dbgstr_w(str));
10149     SysFreeString(str);
10150
10151     IXMLDOMElement_Release(elem);
10152     IXMLDOMElement_Release(elem2);
10153     IXMLDOMDocument_Release(doc);
10154     free_bstrs();
10155 }
10156
10157 typedef struct {
10158     DOMNodeType type;
10159     const char *name;
10160     VARTYPE vt;
10161     HRESULT hr;
10162 } node_type_t;
10163
10164 static const node_type_t get_datatype[] = {
10165     { NODE_ELEMENT,                "element",   VT_NULL, S_FALSE },
10166     { NODE_ATTRIBUTE,              "attr",      VT_NULL, S_FALSE },
10167     { NODE_TEXT,                   "text",      VT_NULL, S_FALSE },
10168     { NODE_CDATA_SECTION ,         "cdata",     VT_NULL, S_FALSE },
10169     { NODE_ENTITY_REFERENCE,       "entityref", VT_NULL, S_FALSE },
10170     { NODE_PROCESSING_INSTRUCTION, "pi",        VT_NULL, S_FALSE },
10171     { NODE_COMMENT,                "comment",   VT_NULL, S_FALSE },
10172     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   VT_NULL, S_FALSE },
10173     { 0 }
10174 };
10175
10176 static void test_get_dataType(void)
10177 {
10178     const node_type_t *entry = get_datatype;
10179     IXMLDOMDocument *doc;
10180
10181     doc = create_document(&IID_IXMLDOMDocument);
10182
10183     while (entry->type)
10184     {
10185         IXMLDOMNode *node = NULL;
10186         VARIANT var, type;
10187         HRESULT hr;
10188
10189         V_VT(&var) = VT_I4;
10190         V_I4(&var) = entry->type;
10191         hr = IXMLDOMDocument_createNode(doc, var, _bstr_(entry->name), NULL, &node);
10192         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
10193
10194         hr = IXMLDOMNode_get_dataType(node, NULL);
10195         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10196
10197         VariantInit(&type);
10198         hr = IXMLDOMNode_get_dataType(node, &type);
10199         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
10200             hr, entry->hr, entry->type);
10201         ok(V_VT(&type) == entry->vt, "got %d, expected %d. node type %d\n",
10202             V_VT(&type), entry->vt, entry->type);
10203         VariantClear(&type);
10204
10205         IXMLDOMNode_Release(node);
10206
10207         entry++;
10208     }
10209
10210     IXMLDOMDocument_Release(doc);
10211     free_bstrs();
10212 }
10213
10214 typedef struct _get_node_typestring_t {
10215     DOMNodeType type;
10216     const char *string;
10217 } get_node_typestring_t;
10218
10219 static const get_node_typestring_t get_node_typestring[] = {
10220     { NODE_ELEMENT,                "element"               },
10221     { NODE_ATTRIBUTE,              "attribute"             },
10222     { NODE_TEXT,                   "text"                  },
10223     { NODE_CDATA_SECTION ,         "cdatasection"          },
10224     { NODE_ENTITY_REFERENCE,       "entityreference"       },
10225     { NODE_PROCESSING_INSTRUCTION, "processinginstruction" },
10226     { NODE_COMMENT,                "comment"               },
10227     { NODE_DOCUMENT_FRAGMENT,      "documentfragment"      },
10228     { 0 }
10229 };
10230
10231 static void test_get_nodeTypeString(void)
10232 {
10233     const get_node_typestring_t *entry = get_node_typestring;
10234     IXMLDOMDocument *doc;
10235     HRESULT hr;
10236     BSTR str;
10237
10238     doc = create_document(&IID_IXMLDOMDocument);
10239
10240     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
10241     ok(hr == S_OK, "got 0x%08x\n", hr);
10242     ok(!lstrcmpW(str, _bstr_("document")), "got string %s\n", wine_dbgstr_w(str));
10243     SysFreeString(str);
10244
10245     while (entry->type)
10246     {
10247         IXMLDOMNode *node = NULL;
10248         VARIANT var;
10249
10250         V_VT(&var) = VT_I4;
10251         V_I4(&var) = entry->type;
10252         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
10253         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
10254
10255         hr = IXMLDOMNode_get_nodeTypeString(node, NULL);
10256         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10257
10258         hr = IXMLDOMNode_get_nodeTypeString(node, &str);
10259         ok(hr == S_OK, "got 0x%08x\n", hr);
10260         ok(!lstrcmpW(str, _bstr_(entry->string)), "got string %s, expected %s. node type %d\n",
10261             wine_dbgstr_w(str), entry->string, entry->type);
10262         SysFreeString(str);
10263         IXMLDOMNode_Release(node);
10264
10265         entry++;
10266     }
10267
10268     IXMLDOMDocument_Release(doc);
10269     free_bstrs();
10270 }
10271
10272 typedef struct _get_attributes_t {
10273     DOMNodeType type;
10274     HRESULT hr;
10275 } get_attributes_t;
10276
10277 static const get_attributes_t get_attributes[] = {
10278     { NODE_ATTRIBUTE,              S_FALSE },
10279     { NODE_TEXT,                   S_FALSE },
10280     { NODE_CDATA_SECTION ,         S_FALSE },
10281     { NODE_ENTITY_REFERENCE,       S_FALSE },
10282     { NODE_PROCESSING_INSTRUCTION, S_FALSE },
10283     { NODE_COMMENT,                S_FALSE },
10284     { NODE_DOCUMENT_FRAGMENT,      S_FALSE },
10285     { 0 }
10286 };
10287
10288 static void test_get_attributes(void)
10289 {
10290     const get_attributes_t *entry = get_attributes;
10291     IXMLDOMNamedNodeMap *map;
10292     IXMLDOMDocument *doc;
10293     IXMLDOMNode *node, *node2;
10294     VARIANT_BOOL b;
10295     HRESULT hr;
10296     BSTR str;
10297     LONG length;
10298
10299     doc = create_document(&IID_IXMLDOMDocument);
10300
10301     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
10302     ok(hr == S_OK, "got %08x\n", hr);
10303
10304     hr = IXMLDOMDocument_get_attributes(doc, NULL);
10305     ok(hr == E_INVALIDARG, "got %08x\n", hr);
10306
10307     map = (void*)0xdeadbeef;
10308     hr = IXMLDOMDocument_get_attributes(doc, &map);
10309     ok(hr == S_FALSE, "got %08x\n", hr);
10310     ok(map == NULL, "got %p\n", map);
10311
10312     /* first child is <?xml ?> */
10313     hr = IXMLDOMDocument_get_firstChild(doc, &node);
10314     ok(hr == S_OK, "got %08x\n", hr);
10315
10316     hr = IXMLDOMNode_get_attributes(node, &map);
10317     ok(hr == S_OK, "got %08x\n", hr);
10318
10319     length = -1;
10320     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10321     EXPECT_HR(hr, S_OK);
10322     todo_wine ok(length == 1, "got %d\n", length);
10323
10324     if (hr == S_OK && length == 1)
10325     {
10326         IXMLDOMAttribute *attr;
10327         DOMNodeType type;
10328         VARIANT v;
10329
10330         node2 = NULL;
10331         hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
10332         EXPECT_HR(hr, S_OK);
10333         ok(node != NULL, "got %p\n", node2);
10334
10335         hr = IXMLDOMNode_get_nodeName(node2, &str);
10336         EXPECT_HR(hr, S_OK);
10337         ok(!lstrcmpW(str, _bstr_("version")), "got %s\n", wine_dbgstr_w(str));
10338         SysFreeString(str);
10339
10340         length = -1;
10341         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10342         EXPECT_HR(hr, S_OK);
10343         ok(length == 1, "got %d\n", length);
10344
10345         type = -1;
10346         hr = IXMLDOMNode_get_nodeType(node2, &type);
10347         EXPECT_HR(hr, S_OK);
10348         ok(type == NODE_ATTRIBUTE, "got %d\n", type);
10349
10350         hr = IXMLDOMNode_get_xml(node, &str);
10351         EXPECT_HR(hr, S_OK);
10352         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
10353         SysFreeString(str);
10354
10355         hr = IXMLDOMNode_get_text(node, &str);
10356         EXPECT_HR(hr, S_OK);
10357         ok(!lstrcmpW(str, _bstr_("version=\"1.0\"")), "got %s\n", wine_dbgstr_w(str));
10358         SysFreeString(str);
10359
10360         hr = IXMLDOMNamedNodeMap_removeNamedItem(map, _bstr_("version"), NULL);
10361         EXPECT_HR(hr, S_OK);
10362
10363         length = -1;
10364         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10365         EXPECT_HR(hr, S_OK);
10366         ok(length == 0, "got %d\n", length);
10367
10368         hr = IXMLDOMNode_get_xml(node, &str);
10369         EXPECT_HR(hr, S_OK);
10370         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
10371         SysFreeString(str);
10372
10373         hr = IXMLDOMNode_get_text(node, &str);
10374         EXPECT_HR(hr, S_OK);
10375         ok(!lstrcmpW(str, _bstr_("")), "got %s\n", wine_dbgstr_w(str));
10376         SysFreeString(str);
10377
10378         IXMLDOMNamedNodeMap_Release(map);
10379
10380         hr = IXMLDOMNode_get_attributes(node, &map);
10381         ok(hr == S_OK, "got %08x\n", hr);
10382
10383         length = -1;
10384         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10385         EXPECT_HR(hr, S_OK);
10386         ok(length == 0, "got %d\n", length);
10387
10388         hr = IXMLDOMDocument_createAttribute(doc, _bstr_("encoding"), &attr);
10389         EXPECT_HR(hr, S_OK);
10390
10391         V_VT(&v) = VT_BSTR;
10392         V_BSTR(&v) = _bstr_("UTF-8");
10393         hr = IXMLDOMAttribute_put_nodeValue(attr, v);
10394         EXPECT_HR(hr, S_OK);
10395
10396         EXPECT_REF(attr, 2);
10397         hr = IXMLDOMNamedNodeMap_setNamedItem(map, (IXMLDOMNode*)attr, NULL);
10398         EXPECT_HR(hr, S_OK);
10399         EXPECT_REF(attr, 2);
10400
10401         hr = IXMLDOMNode_get_attributes(node, &map);
10402         ok(hr == S_OK, "got %08x\n", hr);
10403
10404         length = -1;
10405         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10406         EXPECT_HR(hr, S_OK);
10407         ok(length == 1, "got %d\n", length);
10408
10409         hr = IXMLDOMNode_get_xml(node, &str);
10410         EXPECT_HR(hr, S_OK);
10411         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
10412         SysFreeString(str);
10413
10414         hr = IXMLDOMNode_get_text(node, &str);
10415         EXPECT_HR(hr, S_OK);
10416         ok(!lstrcmpW(str, _bstr_("encoding=\"UTF-8\"")), "got %s\n", wine_dbgstr_w(str));
10417         SysFreeString(str);
10418
10419         IXMLDOMNamedNodeMap_Release(map);
10420         IXMLDOMNode_Release(node2);
10421     }
10422
10423     IXMLDOMNode_Release(node);
10424
10425     /* last child is element */
10426     EXPECT_REF(doc, 1);
10427     hr = IXMLDOMDocument_get_lastChild(doc, &node);
10428     ok(hr == S_OK, "got %08x\n", hr);
10429     EXPECT_REF(doc, 1);
10430
10431     EXPECT_REF(node, 1);
10432     hr = IXMLDOMNode_get_attributes(node, &map);
10433     ok(hr == S_OK, "got %08x\n", hr);
10434     EXPECT_REF(node, 1);
10435     EXPECT_REF(doc, 1);
10436
10437     EXPECT_REF(map, 1);
10438     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
10439     ok(hr == S_OK, "got %08x\n", hr);
10440     EXPECT_REF(node, 1);
10441     EXPECT_REF(node2, 1);
10442     EXPECT_REF(map, 1);
10443     EXPECT_REF(doc, 1);
10444     IXMLDOMNode_Release(node2);
10445
10446     /* release node before map release, map still works */
10447     IXMLDOMNode_Release(node);
10448
10449     length = 0;
10450     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
10451     ok(hr == S_OK, "got %08x\n", hr);
10452     ok(length == 1, "got %d\n", length);
10453
10454     node2 = NULL;
10455     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
10456     ok(hr == S_OK, "got %08x\n", hr);
10457     EXPECT_REF(node2, 1);
10458     IXMLDOMNode_Release(node2);
10459
10460     IXMLDOMNamedNodeMap_Release(map);
10461
10462     while (entry->type)
10463     {
10464         VARIANT var;
10465
10466         node = NULL;
10467
10468         V_VT(&var) = VT_I4;
10469         V_I4(&var) = entry->type;
10470         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
10471         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
10472
10473         hr = IXMLDOMNode_get_attributes(node, NULL);
10474         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
10475
10476         map = (void*)0xdeadbeef;
10477         hr = IXMLDOMNode_get_attributes(node, &map);
10478         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
10479             hr, entry->hr, entry->type);
10480         ok(map == NULL, "got %p\n", map);
10481
10482         IXMLDOMNode_Release(node);
10483
10484         entry++;
10485     }
10486
10487     IXMLDOMDocument_Release(doc);
10488     free_bstrs();
10489 }
10490
10491 static void test_selection(void)
10492 {
10493     IXMLDOMSelection *selection, *selection2;
10494     IEnumVARIANT *enum1, *enum2, *enum3;
10495     IXMLDOMNodeList *list;
10496     IUnknown *unk1, *unk2;
10497     IXMLDOMDocument *doc;
10498     IDispatchEx *dispex;
10499     IXMLDOMNode *node;
10500     IDispatch *disp;
10501     VARIANT_BOOL b;
10502     HRESULT hr;
10503     DISPID did;
10504     VARIANT v;
10505     BSTR name;
10506     ULONG ret;
10507     LONG len;
10508
10509     doc = create_document(&IID_IXMLDOMDocument);
10510
10511     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
10512     EXPECT_HR(hr, S_OK);
10513
10514     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list);
10515     EXPECT_HR(hr, S_OK);
10516
10517     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
10518     EXPECT_HR(hr, S_OK);
10519     IXMLDOMSelection_Release(selection);
10520
10521     /* collection disp id */
10522     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IDispatchEx, (void**)&dispex);
10523     EXPECT_HR(hr, S_OK);
10524     did = 0;
10525     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10526     EXPECT_HR(hr, S_OK);
10527     ok(did == DISPID_DOM_COLLECTION_BASE, "got %d\n", did);
10528     len = 0;
10529     hr = IXMLDOMSelection_get_length(selection, &len);
10530     EXPECT_HR(hr, S_OK);
10531     ok(len == 1, "got %d\n", len);
10532     hr = IDispatchEx_GetDispID(dispex, _bstr_("10"), 0, &did);
10533     EXPECT_HR(hr, S_OK);
10534     ok(did == DISPID_DOM_COLLECTION_BASE+10, "got %d\n", did);
10535     IDispatchEx_Release(dispex);
10536
10537     /* IEnumVARIANT tests */
10538     enum1 = NULL;
10539     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum1);
10540     EXPECT_HR(hr, S_OK);
10541     ok(enum1 != NULL, "got %p\n", enum1);
10542     EXPECT_REF(enum1, 2);
10543
10544     EXPECT_REF(selection, 1);
10545     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IUnknown, (void**)&unk1);
10546     EXPECT_HR(hr, S_OK);
10547     EXPECT_REF(selection, 2);
10548     EXPECT_REF(enum1, 2);
10549
10550     /* enumerator and selection object return same IUnknown* */
10551     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
10552     EXPECT_HR(hr, S_OK);
10553     EXPECT_REF(selection, 3);
10554     EXPECT_REF(enum1, 2);
10555     ok(unk2 == unk1, "got %p, %p\n", unk1, unk2);
10556     IUnknown_Release(unk2);
10557
10558     EXPECT_REF(selection, 2);
10559     IEnumVARIANT_AddRef(enum1);
10560     EXPECT_REF(selection, 2);
10561     IEnumVARIANT_Release(enum1);
10562
10563     enum3 = NULL;
10564     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum3);
10565     EXPECT_HR(hr, S_OK);
10566     ok(enum3 != NULL, "got %p\n", enum3);
10567     ok(enum1 == enum3, "got %p and %p\n", enum1, enum3);
10568     EXPECT_REF(enum1, 3);
10569     IEnumVARIANT_Release(enum3);
10570
10571     EXPECT_REF(selection, 2);
10572     EXPECT_REF(enum1, 2);
10573
10574     enum2 = NULL;
10575     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
10576     EXPECT_HR(hr, S_OK);
10577     ok(enum2 != NULL, "got %p\n", enum2);
10578
10579     EXPECT_REF(selection, 3);
10580     EXPECT_REF(enum1, 2);
10581     EXPECT_REF(enum2, 1);
10582
10583     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
10584
10585     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
10586     EXPECT_HR(hr, S_OK);
10587     EXPECT_REF(selection, 3);
10588     EXPECT_REF(enum2, 2);
10589     ok(unk2 != unk1, "got %p, %p\n", unk1, unk2);
10590     IUnknown_Release(unk2);
10591     IUnknown_Release(unk1);
10592
10593     selection2 = NULL;
10594     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IXMLDOMSelection, (void**)&selection2);
10595     EXPECT_HR(hr, S_OK);
10596     ok(selection2 == selection, "got %p and %p\n", selection, selection2);
10597     EXPECT_REF(selection, 3);
10598     EXPECT_REF(enum1, 2);
10599
10600     IXMLDOMSelection_Release(selection2);
10601
10602     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IDispatch, (void**)&disp);
10603     EXPECT_HR(hr, S_OK);
10604     EXPECT_REF(selection, 3);
10605     IDispatch_Release(disp);
10606
10607     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IEnumVARIANT, (void**)&enum3);
10608     EXPECT_HR(hr, S_OK);
10609     ok(enum3 == enum1, "got %p and %p\n", enum3, enum1);
10610     EXPECT_REF(selection, 2);
10611     EXPECT_REF(enum1, 3);
10612
10613     IEnumVARIANT_Release(enum1);
10614     IEnumVARIANT_Release(enum2);
10615
10616     enum1 = NULL;
10617     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
10618     EXPECT_HR(hr, S_OK);
10619     ok(enum1 != NULL, "got %p\n", enum1);
10620     EXPECT_REF(enum1, 1);
10621     EXPECT_REF(selection, 2);
10622
10623     enum2 = NULL;
10624     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
10625     EXPECT_HR(hr, S_OK);
10626     ok(enum2 != NULL, "got %p\n", enum2);
10627     EXPECT_REF(enum2, 1);
10628     EXPECT_REF(selection, 3);
10629
10630     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
10631
10632     IEnumVARIANT_AddRef(enum1);
10633     EXPECT_REF(selection, 3);
10634     EXPECT_REF(enum1, 2);
10635     EXPECT_REF(enum2, 1);
10636     IEnumVARIANT_Release(enum1);
10637
10638     IEnumVARIANT_Release(enum1);
10639     IEnumVARIANT_Release(enum2);
10640
10641     EXPECT_REF(selection, 1);
10642
10643     IXMLDOMNodeList_Release(list);
10644
10645     hr = IXMLDOMDocument_get_childNodes(doc, &list);
10646     EXPECT_HR(hr, S_OK);
10647
10648     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
10649     EXPECT_HR(hr, E_NOINTERFACE);
10650
10651     IXMLDOMNodeList_Release(list);
10652
10653     /* test if IEnumVARIANT touches selection context */
10654     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
10655     EXPECT_HR(hr, S_OK);
10656
10657     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/*"), &list);
10658     EXPECT_HR(hr, S_OK);
10659
10660     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
10661     EXPECT_HR(hr, S_OK);
10662
10663     len = 0;
10664     hr = IXMLDOMSelection_get_length(selection, &len);
10665     EXPECT_HR(hr, S_OK);
10666     ok(len == 4, "got %d\n", len);
10667
10668     enum1 = NULL;
10669     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
10670     EXPECT_HR(hr, S_OK);
10671
10672     /* no-op if zero count */
10673     V_VT(&v) = VT_I2;
10674     hr = IEnumVARIANT_Next(enum1, 0, &v, NULL);
10675     EXPECT_HR(hr, S_OK);
10676     ok(V_VT(&v) == VT_I2, "got var type %d\n", V_VT(&v));
10677
10678     /* positive count, null array pointer */
10679     hr = IEnumVARIANT_Next(enum1, 1, NULL, NULL);
10680     EXPECT_HR(hr, E_INVALIDARG);
10681
10682     ret = 1;
10683     hr = IEnumVARIANT_Next(enum1, 1, NULL, &ret);
10684     EXPECT_HR(hr, E_INVALIDARG);
10685     ok(ret == 0, "got %d\n", ret);
10686
10687     V_VT(&v) = VT_I2;
10688     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
10689     EXPECT_HR(hr, S_OK);
10690     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
10691
10692     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
10693     EXPECT_HR(hr, S_OK);
10694     hr = IXMLDOMNode_get_nodeName(node, &name);
10695     EXPECT_HR(hr, S_OK);
10696     ok(!lstrcmpW(name, _bstr_("a")), "got node name %s\n", wine_dbgstr_w(name));
10697     SysFreeString(name);
10698     IXMLDOMNode_Release(node);
10699     VariantClear(&v);
10700
10701     /* list cursor is updated */
10702     hr = IXMLDOMSelection_nextNode(selection, &node);
10703     EXPECT_HR(hr, S_OK);
10704     hr = IXMLDOMNode_get_nodeName(node, &name);
10705     EXPECT_HR(hr, S_OK);
10706     ok(!lstrcmpW(name, _bstr_("c")), "got node name %s\n", wine_dbgstr_w(name));
10707     IXMLDOMNode_Release(node);
10708
10709     V_VT(&v) = VT_I2;
10710     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
10711     EXPECT_HR(hr, S_OK);
10712     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
10713     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
10714     EXPECT_HR(hr, S_OK);
10715     hr = IXMLDOMNode_get_nodeName(node, &name);
10716     EXPECT_HR(hr, S_OK);
10717     ok(!lstrcmpW(name, _bstr_("b")), "got node name %s\n", wine_dbgstr_w(name));
10718     SysFreeString(name);
10719     IXMLDOMNode_Release(node);
10720     VariantClear(&v);
10721     IEnumVARIANT_Release(enum1);
10722
10723     hr = IXMLDOMSelection_nextNode(selection, &node);
10724     EXPECT_HR(hr, S_OK);
10725     hr = IXMLDOMNode_get_nodeName(node, &name);
10726     EXPECT_HR(hr, S_OK);
10727     ok(!lstrcmpW(name, _bstr_("d")), "got node name %s\n", wine_dbgstr_w(name));
10728     IXMLDOMNode_Release(node);
10729
10730     IXMLDOMSelection_Release(selection);
10731     IXMLDOMNodeList_Release(list);
10732     IXMLDOMDocument_Release(doc);
10733
10734     free_bstrs();
10735 }
10736
10737 static void test_load(void)
10738 {
10739     IXMLDOMDocument *doc;
10740     IXMLDOMNodeList *list;
10741     VARIANT_BOOL b;
10742     HANDLE hfile;
10743     VARIANT src;
10744     HRESULT hr;
10745     BOOL ret;
10746     BSTR path, bstr1, bstr2;
10747     DWORD written;
10748     void* ptr;
10749
10750     /* prepare a file */
10751     hfile = CreateFileA("test.xml", GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
10752     ok(hfile != INVALID_HANDLE_VALUE, "failed to create test file\n");
10753     if(hfile == INVALID_HANDLE_VALUE) return;
10754
10755     ret = WriteFile(hfile, win1252xml, strlen(win1252xml), &written, NULL);
10756     ok(ret, "WriteFile failed\n");
10757
10758     CloseHandle(hfile);
10759
10760     doc = create_document(&IID_IXMLDOMDocument);
10761
10762     /* null pointer as input */
10763     V_VT(&src) = VT_UNKNOWN;
10764     V_UNKNOWN(&src) = NULL;
10765     hr = IXMLDOMDocument_load(doc, src, &b);
10766     EXPECT_HR(hr, E_INVALIDARG);
10767     ok(b == VARIANT_FALSE, "got %d\n", b);
10768
10769     path = _bstr_("test.xml");
10770
10771     /* load from path: VT_BSTR */
10772     V_VT(&src) = VT_BSTR;
10773     V_BSTR(&src) = path;
10774     hr = IXMLDOMDocument_load(doc, src, &b);
10775     EXPECT_HR(hr, S_OK);
10776     ok(b == VARIANT_TRUE, "got %d\n", b);
10777
10778     /* load from a path: VT_BSTR|VT_BYREF */
10779     V_VT(&src) = VT_BSTR | VT_BYREF;
10780     V_BSTRREF(&src) = &path;
10781     hr = IXMLDOMDocument_load(doc, src, &b);
10782     EXPECT_HR(hr, S_OK);
10783     ok(b == VARIANT_TRUE, "got %d\n", b);
10784
10785     /* load from a path: VT_BSTR|VT_BYREF, null ptr */
10786     V_VT(&src) = VT_BSTR | VT_BYREF;
10787     V_BSTRREF(&src) = NULL;
10788     hr = IXMLDOMDocument_load(doc, src, &b);
10789     EXPECT_HR(hr, E_INVALIDARG);
10790     ok(b == VARIANT_FALSE, "got %d\n", b);
10791
10792     IXMLDOMDocument_Release(doc);
10793
10794     DeleteFileA("test.xml");
10795
10796     doc = create_document(&IID_IXMLDOMDocument);
10797
10798     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
10799     EXPECT_HR(hr, S_OK);
10800     ok(b == VARIANT_TRUE, "got %d\n", b);
10801
10802     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
10803     EXPECT_HR(hr, S_OK);
10804     bstr1 = _bstr_(list_to_string(list));
10805
10806     hr = IXMLDOMNodeList_reset(list);
10807     EXPECT_HR(hr, S_OK);
10808
10809     IXMLDOMDocument_Release(doc);
10810
10811     doc = create_document(&IID_IXMLDOMDocument);
10812
10813     VariantInit(&src);
10814     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenA(szExampleXML));
10815     V_VT(&src) = VT_ARRAY|VT_UI1;
10816     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10817     ptr = NULL;
10818     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10819     EXPECT_HR(hr, S_OK);
10820     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10821
10822     memcpy(ptr, szExampleXML, lstrlenA(szExampleXML));
10823     hr = SafeArrayUnlock(V_ARRAY(&src));
10824     EXPECT_HR(hr, S_OK);
10825
10826     hr = IXMLDOMDocument_load(doc, src, &b);
10827     EXPECT_HR(hr, S_OK);
10828     ok(b == VARIANT_TRUE, "got %d\n", b);
10829
10830     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
10831     EXPECT_HR(hr, S_OK);
10832     bstr2 = _bstr_(list_to_string(list));
10833
10834     hr = IXMLDOMNodeList_reset(list);
10835     EXPECT_HR(hr, S_OK);
10836
10837     ok(lstrcmpW(bstr1, bstr2) == 0, "strings not equal: %s : %s\n",
10838        wine_dbgstr_w(bstr1), wine_dbgstr_w(bstr2));
10839
10840     IXMLDOMDocument_Release(doc);
10841     IXMLDOMNodeList_Release(list);
10842     VariantClear(&src);
10843
10844     /* UTF-16 isn't accepted */
10845     doc = create_document(&IID_IXMLDOMDocument);
10846
10847     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenW(szComplete1) * sizeof(WCHAR));
10848     V_VT(&src) = VT_ARRAY|VT_UI1;
10849     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10850     ptr = NULL;
10851     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10852     EXPECT_HR(hr, S_OK);
10853     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10854
10855     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
10856     hr = SafeArrayUnlock(V_ARRAY(&src));
10857     EXPECT_HR(hr, S_OK);
10858
10859     hr = IXMLDOMDocument_load(doc, src, &b);
10860     todo_wine EXPECT_HR(hr, S_FALSE);
10861     todo_wine ok(b == VARIANT_FALSE, "got %d\n", b);
10862
10863     VariantClear(&src);
10864
10865     /* it doesn't like it as a VT_ARRAY|VT_UI2 either */
10866     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI2, 0, lstrlenW(szComplete1));
10867     V_VT(&src) = VT_ARRAY|VT_UI2;
10868     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
10869     ptr = NULL;
10870     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
10871     EXPECT_HR(hr, S_OK);
10872     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
10873
10874     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
10875     hr = SafeArrayUnlock(V_ARRAY(&src));
10876     EXPECT_HR(hr, S_OK);
10877
10878     hr = IXMLDOMDocument_load(doc, src, &b);
10879     todo_wine EXPECT_HR(hr, E_INVALIDARG);
10880     ok(b == VARIANT_FALSE, "got %d\n", b);
10881
10882     VariantClear(&src);
10883     IXMLDOMDocument_Release(doc);
10884
10885     free_bstrs();
10886 }
10887
10888 static void test_domobj_dispex(IUnknown *obj)
10889 {
10890     DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
10891     IDispatchEx *dispex;
10892     IUnknown *unk;
10893     DWORD props;
10894     UINT ticnt;
10895     HRESULT hr;
10896     BSTR name;
10897
10898     hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
10899     EXPECT_HR(hr, S_OK);
10900     if (FAILED(hr)) return;
10901
10902     ticnt = 0;
10903     hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
10904     EXPECT_HR(hr, S_OK);
10905     ok(ticnt == 1, "ticnt=%u\n", ticnt);
10906
10907     name = SysAllocString(szstar);
10908     hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
10909     EXPECT_HR(hr, E_NOTIMPL);
10910     SysFreeString(name);
10911
10912     hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
10913     EXPECT_HR(hr, E_NOTIMPL);
10914
10915     props = 0;
10916     hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
10917     EXPECT_HR(hr, E_NOTIMPL);
10918     ok(props == 0, "expected 0 got %d\n", props);
10919
10920     hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
10921     EXPECT_HR(hr, E_NOTIMPL);
10922     if (SUCCEEDED(hr)) SysFreeString(name);
10923
10924     hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
10925     EXPECT_HR(hr, E_NOTIMPL);
10926
10927     hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
10928     EXPECT_HR(hr, E_NOTIMPL);
10929     if (hr == S_OK && unk) IUnknown_Release(unk);
10930
10931     IDispatchEx_Release(dispex);
10932 }
10933
10934 static void test_mxnamespacemanager(void)
10935 {
10936     static const char xmluriA[] = "http://www.w3.org/XML/1998/namespace";
10937     IMXNamespacePrefixes *prefixes;
10938     IVBMXNamespaceManager *mgr2;
10939     IMXNamespaceManager *nsmgr;
10940     IUnknown *unk1, *unk2;
10941     WCHAR buffW[250];
10942     IDispatch *disp;
10943     IUnknown *unk;
10944     HRESULT hr;
10945     INT len;
10946
10947     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
10948         &IID_IMXNamespaceManager, (void**)&nsmgr);
10949     EXPECT_HR(hr, S_OK);
10950
10951     /* IMXNamespaceManager inherits from IUnknown */
10952     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IDispatch, (void**)&disp);
10953     EXPECT_HR(hr, S_OK);
10954     IDispatch_Release(disp);
10955
10956     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IVBMXNamespaceManager, (void**)&mgr2);
10957     EXPECT_HR(hr, S_OK);
10958
10959     EXPECT_REF(nsmgr, 2);
10960     EXPECT_REF(mgr2, 2);
10961     prefixes = NULL;
10962     hr = IVBMXNamespaceManager_getDeclaredPrefixes(mgr2, &prefixes);
10963     if (hr == S_OK)
10964     {
10965         ok(prefixes != NULL, "got %p\n", prefixes);
10966         EXPECT_REF(nsmgr, 2);
10967         EXPECT_REF(mgr2, 2);
10968         EXPECT_REF(prefixes, 1);
10969
10970         IVBMXNamespaceManager_QueryInterface(mgr2, &IID_IUnknown, (void**)&unk1);
10971         IMXNamespacePrefixes_QueryInterface(prefixes, &IID_IUnknown, (void**)&unk2);
10972
10973         EXPECT_REF(mgr2, 3);
10974         EXPECT_REF(prefixes, 2);
10975
10976         IUnknown_Release(unk1);
10977         IUnknown_Release(unk2);
10978         IMXNamespacePrefixes_Release(prefixes);
10979     }
10980     IVBMXNamespaceManager_Release(mgr2);
10981
10982     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
10983     EXPECT_HR(hr, S_OK);
10984
10985     /* prefix already added */
10986     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
10987     EXPECT_HR(hr, S_FALSE);
10988
10989     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), NULL);
10990     EXPECT_HR(hr, E_INVALIDARG);
10991
10992     /* "xml" and "xmlns" are not allowed here */
10993     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xml"), _bstr_("uri1"));
10994     EXPECT_HR(hr, E_INVALIDARG);
10995
10996     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xmlns"), _bstr_("uri1"));
10997     EXPECT_HR(hr, E_INVALIDARG);
10998 todo_wine {
10999     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, -1, NULL, NULL);
11000     EXPECT_HR(hr, E_FAIL);
11001 }
11002     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, NULL);
11003     EXPECT_HR(hr, E_POINTER);
11004
11005     len = -1;
11006     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, &len);
11007     EXPECT_HR(hr, S_OK);
11008     ok(len == 3, "got %d\n", len);
11009
11010     len = -1;
11011     buffW[0] = 0x1;
11012     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
11013     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
11014     ok(len == -1, "got %d\n", len);
11015     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11016
11017     len = 10;
11018     buffW[0] = 0x1;
11019     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
11020     EXPECT_HR(hr, S_OK);
11021     ok(len == 3, "got %d\n", len);
11022     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
11023
11024     /* getURI */
11025     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, NULL);
11026     EXPECT_HR(hr, E_INVALIDARG);
11027
11028     len = -1;
11029     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, &len);
11030     EXPECT_HR(hr, E_INVALIDARG);
11031     ok(len == -1, "got %d\n", len);
11032
11033     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, NULL);
11034     EXPECT_HR(hr, E_POINTER);
11035
11036     len = -1;
11037     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, &len);
11038     EXPECT_HR(hr, S_OK);
11039     /* length of "xml" uri is constant */
11040     ok(len == strlen(xmluriA), "got %d\n", len);
11041
11042     len = 100;
11043     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
11044     EXPECT_HR(hr, S_OK);
11045     ok(len == strlen(xmluriA), "got %d\n", len);
11046     ok(!lstrcmpW(buffW, _bstr_(xmluriA)), "got prefix %s\n", wine_dbgstr_w(buffW));
11047
11048     len = strlen(xmluriA)-1;
11049     buffW[0] = 0x1;
11050     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
11051     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
11052     ok(len == strlen(xmluriA)-1, "got %d\n", len);
11053     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11054
11055     /* prefix xml1 not defined */
11056     len = -1;
11057     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, NULL, &len);
11058     EXPECT_HR(hr, S_FALSE);
11059     ok(len == 0, "got %d\n", len);
11060
11061     len = 100;
11062     buffW[0] = 0x1;
11063     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, buffW, &len);
11064     EXPECT_HR(hr, S_FALSE);
11065     ok(buffW[0] == 0, "got %x\n", buffW[0]);
11066     ok(len == 0, "got %d\n", len);
11067
11068     /* IDispatchEx tests */
11069     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IUnknown, (void**)&unk);
11070     EXPECT_HR(hr, S_OK);
11071     test_domobj_dispex(unk);
11072     IUnknown_Release(unk);
11073
11074     IMXNamespaceManager_Release(nsmgr);
11075
11076     /* ::getPrefix() */
11077     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
11078         &IID_IMXNamespaceManager, (void**)&nsmgr);
11079     EXPECT_HR(hr, S_OK);
11080
11081     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, NULL);
11082     EXPECT_HR(hr, E_INVALIDARG);
11083
11084     len = -1;
11085     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, &len);
11086     EXPECT_HR(hr, E_INVALIDARG);
11087     ok(len == -1, "got %d\n", len);
11088
11089     len = 100;
11090     buffW[0] = 0x1;
11091     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
11092     EXPECT_HR(hr, E_FAIL);
11093     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11094     ok(len == 100, "got %d\n", len);
11095
11096     len = 0;
11097     buffW[0] = 0x1;
11098     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
11099     EXPECT_HR(hr, E_FAIL);
11100     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11101     ok(len == 0, "got %d\n", len);
11102
11103     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
11104     EXPECT_HR(hr, S_OK);
11105
11106     len = 100;
11107     buffW[0] = 0x1;
11108     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11109     EXPECT_HR(hr, S_OK);
11110     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11111     ok(len == 3, "got %d\n", len);
11112
11113     len = 100;
11114     buffW[0] = 0x1;
11115     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, buffW, &len);
11116     EXPECT_HR(hr, S_OK);
11117     ok(!lstrcmpW(buffW, _bstr_("xml")), "got %s\n", wine_dbgstr_w(buffW));
11118     ok(len == 3, "got %d\n", len);
11119
11120     /* with null buffer it's possible to get required length */
11121     len = 100;
11122     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
11123     EXPECT_HR(hr, S_OK);
11124     ok(len == 3, "got %d\n", len);
11125
11126     len = 0;
11127     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
11128     EXPECT_HR(hr, S_OK);
11129     ok(len == 3, "got %d\n", len);
11130
11131     len = 100;
11132     buffW[0] = 0x1;
11133     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 1, buffW, &len);
11134     EXPECT_HR(hr, E_FAIL);
11135     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11136     ok(len == 100, "got %d\n", len);
11137
11138     len = 100;
11139     buffW[0] = 0x1;
11140     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 2, buffW, &len);
11141     EXPECT_HR(hr, E_FAIL);
11142     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11143     ok(len == 100, "got %d\n", len);
11144
11145     len = 100;
11146     buffW[0] = 0x1;
11147     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 0, buffW, &len);
11148     EXPECT_HR(hr, E_INVALIDARG);
11149     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11150     ok(len == 100, "got %d\n", len);
11151
11152     len = 100;
11153     buffW[0] = 0x1;
11154     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
11155     EXPECT_HR(hr, E_INVALIDARG);
11156     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11157     ok(len == 100, "got %d\n", len);
11158
11159     len = 100;
11160     buffW[0] = 0x1;
11161     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, buffW, &len);
11162     EXPECT_HR(hr, E_INVALIDARG);
11163     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11164     ok(len == 100, "got %d\n", len);
11165
11166     len = 100;
11167     buffW[0] = 0x1;
11168     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 1, buffW, &len);
11169     EXPECT_HR(hr, E_FAIL);
11170     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11171     ok(len == 100, "got %d\n", len);
11172
11173     len = 100;
11174     buffW[0] = 0x1;
11175     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
11176     EXPECT_HR(hr, E_INVALIDARG);
11177     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11178     ok(len == 100, "got %d\n", len);
11179
11180     /* declare another one, indices are shifted */
11181     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
11182     EXPECT_HR(hr, S_OK);
11183
11184     len = 100;
11185     buffW[0] = 0x1;
11186     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11187     EXPECT_HR(hr, S_OK);
11188     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11189     ok(len == 3, "got %d\n", len);
11190
11191     len = 100;
11192     buffW[0] = 0x1;
11193     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
11194     EXPECT_HR(hr, S_OK);
11195     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
11196     ok(len == 3, "got %d\n", len);
11197
11198     len = 100;
11199     buffW[0] = 0x1;
11200     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 1, buffW, &len);
11201     EXPECT_HR(hr, E_FAIL);
11202     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11203     ok(len == 100, "got %d\n", len);
11204
11205     len = 100;
11206     buffW[0] = 0x1;
11207     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
11208     EXPECT_HR(hr, E_INVALIDARG);
11209     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11210     ok(len == 100, "got %d\n", len);
11211
11212     IMXNamespaceManager_Release(nsmgr);
11213
11214     /* push/pop tests */
11215     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
11216         &IID_IMXNamespaceManager, (void**)&nsmgr);
11217     EXPECT_HR(hr, S_OK);
11218
11219     /* pop with empty stack */
11220     hr = IMXNamespaceManager_popContext(nsmgr);
11221     EXPECT_HR(hr, E_FAIL);
11222
11223     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
11224     EXPECT_HR(hr, S_OK);
11225
11226     len = 100;
11227     buffW[0] = 0x1;
11228     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11229     EXPECT_HR(hr, S_OK);
11230     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11231     ok(len == 3, "got %d\n", len);
11232
11233     hr = IMXNamespaceManager_pushContext(nsmgr);
11234     EXPECT_HR(hr, S_OK);
11235
11236     len = 100;
11237     buffW[0] = 0x1;
11238     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11239     EXPECT_HR(hr, S_OK);
11240     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11241     ok(len == 3, "got %d\n", len);
11242
11243     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
11244     EXPECT_HR(hr, S_OK);
11245
11246     len = 100;
11247     buffW[0] = 0x1;
11248     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
11249     EXPECT_HR(hr, S_OK);
11250     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
11251     ok(len == 3, "got %d\n", len);
11252
11253     hr = IMXNamespaceManager_pushContext(nsmgr);
11254     EXPECT_HR(hr, S_OK);
11255     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns3"), _bstr_("ns3 uri"));
11256     EXPECT_HR(hr, S_OK);
11257
11258     len = 100;
11259     buffW[0] = 0x1;
11260     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
11261     EXPECT_HR(hr, S_OK);
11262     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
11263     ok(len == 3, "got %d\n", len);
11264
11265     len = 100;
11266     buffW[0] = 0x1;
11267     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11268     EXPECT_HR(hr, S_OK);
11269     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11270     ok(len == 3, "got %d\n", len);
11271
11272     hr = IMXNamespaceManager_popContext(nsmgr);
11273     EXPECT_HR(hr, S_OK);
11274
11275     hr = IMXNamespaceManager_popContext(nsmgr);
11276     EXPECT_HR(hr, S_OK);
11277
11278     len = 100;
11279     buffW[0] = 0x1;
11280     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
11281     EXPECT_HR(hr, E_FAIL);
11282     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
11283     ok(len == 100, "got %d\n", len);
11284
11285     len = 100;
11286     buffW[0] = 0x1;
11287     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
11288     EXPECT_HR(hr, S_OK);
11289     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
11290     ok(len == 3, "got %d\n", len);
11291
11292     IMXNamespaceManager_Release(nsmgr);
11293
11294     free_bstrs();
11295 }
11296
11297 static void test_mxnamespacemanager_override(void)
11298 {
11299     IMXNamespaceManager *nsmgr;
11300     WCHAR buffW[250];
11301     VARIANT_BOOL b;
11302     HRESULT hr;
11303     INT len;
11304
11305     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
11306         &IID_IMXNamespaceManager, (void**)&nsmgr);
11307     EXPECT_HR(hr, S_OK);
11308
11309     len = sizeof(buffW)/sizeof(WCHAR);
11310     buffW[0] = 0;
11311     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
11312     EXPECT_HR(hr, S_OK);
11313     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
11314
11315     len = sizeof(buffW)/sizeof(WCHAR);
11316     buffW[0] = 0;
11317     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
11318     EXPECT_HR(hr, E_FAIL);
11319
11320     hr = IMXNamespaceManager_getAllowOverride(nsmgr, NULL);
11321     EXPECT_HR(hr, E_POINTER);
11322
11323     b = VARIANT_FALSE;
11324     hr = IMXNamespaceManager_getAllowOverride(nsmgr, &b);
11325     EXPECT_HR(hr, S_OK);
11326     ok(b == VARIANT_TRUE, "got %d\n", b);
11327
11328     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_FALSE);
11329     EXPECT_HR(hr, S_OK);
11330
11331     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
11332     EXPECT_HR(hr, S_OK);
11333
11334     len = sizeof(buffW)/sizeof(WCHAR);
11335     buffW[0] = 0;
11336     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
11337     EXPECT_HR(hr, S_OK);
11338     ok(!lstrcmpW(buffW, _bstr_("ns0 uri")), "got uri %s\n", wine_dbgstr_w(buffW));
11339
11340     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), _bstr_("ns0 uri"));
11341     EXPECT_HR(hr, S_OK);
11342
11343     len = sizeof(buffW)/sizeof(WCHAR);
11344     buffW[0] = 0;
11345     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
11346     EXPECT_HR(hr, S_OK);
11347     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
11348
11349     len = sizeof(buffW)/sizeof(WCHAR);
11350     buffW[0] = 0;
11351     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
11352     EXPECT_HR(hr, S_OK);
11353     ok(!lstrcmpW(buffW, _bstr_("ns0")), "got prefix %s\n", wine_dbgstr_w(buffW));
11354
11355     len = sizeof(buffW)/sizeof(WCHAR);
11356     buffW[0] = 0;
11357     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 2, buffW, &len);
11358     EXPECT_HR(hr, S_OK);
11359     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
11360
11361     /* new prefix placed at index 1 always */
11362     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
11363     EXPECT_HR(hr, S_OK);
11364
11365     len = sizeof(buffW)/sizeof(WCHAR);
11366     buffW[0] = 0;
11367     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
11368     EXPECT_HR(hr, S_OK);
11369     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got prefix %s\n", wine_dbgstr_w(buffW));
11370
11371     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_(""), NULL);
11372     todo_wine EXPECT_HR(hr, E_FAIL);
11373
11374     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
11375     EXPECT_HR(hr, E_FAIL);
11376
11377     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
11378     EXPECT_HR(hr, E_FAIL);
11379
11380     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_TRUE);
11381     EXPECT_HR(hr, S_OK);
11382
11383     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri override"));
11384     EXPECT_HR(hr, S_FALSE);
11385
11386     len = sizeof(buffW)/sizeof(WCHAR);
11387     buffW[0] = 0;
11388     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
11389     EXPECT_HR(hr, S_OK);
11390     ok(!lstrcmpW(buffW, _bstr_("ns0 uri override")), "got uri %s\n", wine_dbgstr_w(buffW));
11391
11392     len = sizeof(buffW)/sizeof(WCHAR);
11393     buffW[0] = 0;
11394     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 3, buffW, &len);
11395     EXPECT_HR(hr, S_OK);
11396     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
11397
11398     IMXNamespaceManager_Release(nsmgr);
11399
11400     free_bstrs();
11401 }
11402
11403 static const DOMNodeType nodetypes_test[] =
11404 {
11405     NODE_ELEMENT,
11406     NODE_ATTRIBUTE,
11407     NODE_TEXT,
11408     NODE_CDATA_SECTION,
11409     NODE_ENTITY_REFERENCE,
11410     NODE_PROCESSING_INSTRUCTION,
11411     NODE_COMMENT,
11412     NODE_DOCUMENT_FRAGMENT,
11413     NODE_INVALID
11414 };
11415
11416 static void test_dispex(void)
11417 {
11418     const DOMNodeType *type = nodetypes_test;
11419     IXMLDOMImplementation *impl;
11420     IXMLDOMNodeList *node_list;
11421     IXMLDOMParseError *error;
11422     IXMLDOMNamedNodeMap *map;
11423     IXSLProcessor *processor;
11424     IXSLTemplate *template;
11425     IXMLDOMDocument *doc;
11426     IXMLHTTPRequest *req;
11427     IXMLDOMElement *elem;
11428     IDispatchEx *dispex;
11429     IXMLDOMNode *node;
11430     VARIANT_BOOL b;
11431     IUnknown *unk;
11432     HRESULT hr;
11433     DISPID did;
11434
11435     doc = create_document(&IID_IXMLDOMDocument);
11436
11437     IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
11438     test_domobj_dispex(unk);
11439     IUnknown_Release(unk);
11440
11441     for(; *type != NODE_INVALID; type++)
11442     {
11443         IXMLDOMNode *node;
11444         VARIANT v;
11445
11446         V_VT(&v) = VT_I2;
11447         V_I2(&v) = *type;
11448
11449         hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
11450         ok(hr == S_OK, "failed to create node type %d\n", *type);
11451
11452         IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
11453
11454         test_domobj_dispex(unk);
11455         IUnknown_Release(unk);
11456         IXMLDOMNode_Release(node);
11457     }
11458
11459     /* IXMLDOMNodeList */
11460     hr = IXMLDOMDocument_getElementsByTagName(doc, _bstr_("*"), &node_list);
11461     EXPECT_HR(hr, S_OK);
11462     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
11463     test_domobj_dispex(unk);
11464     IUnknown_Release(unk);
11465     IXMLDOMNodeList_Release(node_list);
11466
11467     /* IXMLDOMNodeList for children list */
11468     hr = IXMLDOMDocument_get_childNodes(doc, &node_list);
11469     EXPECT_HR(hr, S_OK);
11470     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
11471     test_domobj_dispex(unk);
11472     IUnknown_Release(unk);
11473
11474     /* collection dispex test, empty collection */
11475     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatchEx, (void**)&dispex);
11476     EXPECT_HR(hr, S_OK);
11477     did = 0;
11478     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
11479     EXPECT_HR(hr, S_OK);
11480     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
11481     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
11482     EXPECT_HR(hr, S_OK);
11483     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
11484     IDispatchEx_Release(dispex);
11485
11486     IXMLDOMNodeList_Release(node_list);
11487
11488     /* IXMLDOMParseError */
11489     hr = IXMLDOMDocument_get_parseError(doc, &error);
11490     EXPECT_HR(hr, S_OK);
11491     IXMLDOMParseError_QueryInterface(error, &IID_IUnknown, (void**)&unk);
11492     test_domobj_dispex(unk);
11493     IUnknown_Release(unk);
11494     IXMLDOMParseError_Release(error);
11495
11496     /* IXMLDOMNamedNodeMap */
11497     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
11498     EXPECT_HR(hr, S_OK);
11499
11500     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/a"), &node_list);
11501     EXPECT_HR(hr, S_OK);
11502     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
11503     EXPECT_HR(hr, S_OK);
11504     IXMLDOMNodeList_Release(node_list);
11505
11506     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
11507     EXPECT_HR(hr, S_OK);
11508     IXMLDOMNode_Release(node);
11509     hr = IXMLDOMElement_get_attributes(elem, &map);
11510     EXPECT_HR(hr, S_OK);
11511     IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk);
11512     test_domobj_dispex(unk);
11513     IUnknown_Release(unk);
11514     /* collection dispex test */
11515     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
11516     EXPECT_HR(hr, S_OK);
11517     did = 0;
11518     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
11519     EXPECT_HR(hr, S_OK);
11520     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
11521     IDispatchEx_Release(dispex);
11522
11523     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/b"), &node_list);
11524     EXPECT_HR(hr, S_OK);
11525     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
11526     EXPECT_HR(hr, S_OK);
11527     IXMLDOMNodeList_Release(node_list);
11528     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
11529     EXPECT_HR(hr, S_OK);
11530     IXMLDOMNode_Release(node);
11531     hr = IXMLDOMElement_get_attributes(elem, &map);
11532     EXPECT_HR(hr, S_OK);
11533     /* collection dispex test, empty collection */
11534     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
11535     EXPECT_HR(hr, S_OK);
11536     did = 0;
11537     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
11538     EXPECT_HR(hr, S_OK);
11539     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
11540     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
11541     EXPECT_HR(hr, S_OK);
11542     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
11543     IDispatchEx_Release(dispex);
11544
11545     IXMLDOMNamedNodeMap_Release(map);
11546     IXMLDOMElement_Release(elem);
11547
11548     /* IXMLDOMImplementation */
11549     hr = IXMLDOMDocument_get_implementation(doc, &impl);
11550     EXPECT_HR(hr, S_OK);
11551
11552     hr = IXMLDOMImplementation_QueryInterface(impl, &IID_IDispatchEx, (void**)&dispex);
11553     EXPECT_HR(hr, S_OK);
11554     IDispatchEx_Release(dispex);
11555     IXMLDOMImplementation_Release(impl);
11556
11557     IXMLDOMDocument_Release(doc);
11558
11559     /* IXMLHTTPRequest */
11560     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
11561         &IID_IXMLHttpRequest, (void**)&req);
11562     if (hr == S_OK)
11563     {
11564         hr = IXMLHTTPRequest_QueryInterface(req, &IID_IDispatchEx, (void**)&dispex);
11565         EXPECT_HR(hr, E_NOINTERFACE);
11566         IXMLHTTPRequest_Release(req);
11567     }
11568
11569     /* IXSLTemplate */
11570     template = create_xsltemplate(&IID_IXSLTemplate);
11571     hr = IXSLTemplate_QueryInterface(template, &IID_IDispatchEx, (void**)&dispex);
11572     EXPECT_HR(hr, S_OK);
11573     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
11574     EXPECT_HR(hr, S_OK);
11575     test_domobj_dispex(unk);
11576     IUnknown_Release(unk);
11577     IDispatchEx_Release(dispex);
11578
11579     /* IXSLProcessor */
11580     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
11581     EXPECT_HR(hr, S_OK);
11582     b = VARIANT_FALSE;
11583     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformSSXML), &b);
11584     EXPECT_HR(hr, S_OK);
11585     ok(b == VARIANT_TRUE, "got %d\n", b);
11586
11587     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
11588     EXPECT_HR(hr, S_OK);
11589     IXMLDOMDocument_Release(doc);
11590
11591     hr = IXSLTemplate_createProcessor(template, &processor);
11592     EXPECT_HR(hr, S_OK);
11593     hr = IXSLProcessor_QueryInterface(processor, &IID_IDispatchEx, (void**)&dispex);
11594     EXPECT_HR(hr, S_OK);
11595     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
11596     EXPECT_HR(hr, S_OK);
11597     test_domobj_dispex(unk);
11598     IUnknown_Release(unk);
11599     IDispatchEx_Release(dispex);
11600
11601     IXSLProcessor_Release(processor);
11602     IXSLTemplate_Release(template);
11603
11604     free_bstrs();
11605 }
11606
11607 static void test_parseerror(void)
11608 {
11609     IXMLDOMParseError2 *error2;
11610     IXMLDOMParseError *error;
11611     IXMLDOMDocument *doc;
11612     HRESULT hr;
11613
11614     doc = create_document(&IID_IXMLDOMDocument);
11615
11616     hr = IXMLDOMDocument_get_parseError(doc, &error);
11617     EXPECT_HR(hr, S_OK);
11618
11619     hr = IXMLDOMParseError_get_line(error, NULL);
11620     EXPECT_HR(hr, E_INVALIDARG);
11621
11622     hr = IXMLDOMParseError_get_srcText(error, NULL);
11623     EXPECT_HR(hr, E_INVALIDARG);
11624
11625     hr = IXMLDOMParseError_get_linepos(error, NULL);
11626     EXPECT_HR(hr, E_INVALIDARG);
11627
11628     IXMLDOMParseError_Release(error);
11629     IXMLDOMDocument_Release(doc);
11630
11631     doc = create_document_version(60, &IID_IXMLDOMDocument);
11632     if (!doc) return;
11633     hr = IXMLDOMDocument_get_parseError(doc, &error);
11634     EXPECT_HR(hr, S_OK);
11635     hr = IXMLDOMParseError_QueryInterface(error, &IID_IXMLDOMParseError2, (void**)&error2);
11636     EXPECT_HR(hr, S_OK);
11637     IXMLDOMParseError2_Release(error2);
11638     IXMLDOMParseError_Release(error);
11639     IXMLDOMDocument_Release(doc);
11640 }
11641
11642 static void test_getAttributeNode(void)
11643 {
11644     IXMLDOMAttribute *attr;
11645     IXMLDOMDocument *doc;
11646     IXMLDOMElement *elem;
11647     VARIANT_BOOL v;
11648     HRESULT hr;
11649     BSTR str;
11650
11651     doc = create_document(&IID_IXMLDOMDocument);
11652
11653     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &v);
11654     EXPECT_HR(hr, S_OK);
11655
11656     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11657     EXPECT_HR(hr, S_OK);
11658
11659     str = SysAllocString(nonexistent_fileW);
11660     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
11661     EXPECT_HR(hr, E_FAIL);
11662
11663     attr = (IXMLDOMAttribute*)0xdeadbeef;
11664     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
11665     EXPECT_HR(hr, E_FAIL);
11666     ok(attr == NULL, "got %p\n", attr);
11667     SysFreeString(str);
11668
11669     str = SysAllocString(nonexistent_attrW);
11670     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
11671     EXPECT_HR(hr, S_FALSE);
11672
11673     attr = (IXMLDOMAttribute*)0xdeadbeef;
11674     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
11675     EXPECT_HR(hr, S_FALSE);
11676     ok(attr == NULL, "got %p\n", attr);
11677     SysFreeString(str);
11678
11679     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("foo:b"), &attr);
11680     EXPECT_HR(hr, S_OK);
11681     IXMLDOMAttribute_Release(attr);
11682
11683     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("b"), &attr);
11684     EXPECT_HR(hr, S_FALSE);
11685
11686     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("a"), &attr);
11687     EXPECT_HR(hr, S_OK);
11688     IXMLDOMAttribute_Release(attr);
11689
11690     IXMLDOMElement_Release(elem);
11691     IXMLDOMDocument_Release(doc);
11692     free_bstrs();
11693 }
11694
11695 typedef struct {
11696     DOMNodeType type;
11697     const char *name;
11698     REFIID iids[3];
11699 } supporterror_t;
11700
11701 static const supporterror_t supporterror_test[] = {
11702     { NODE_ELEMENT,                "element",   { &IID_IXMLDOMNode, &IID_IXMLDOMElement } },
11703     { NODE_ATTRIBUTE,              "attribute", { &IID_IXMLDOMNode, &IID_IXMLDOMAttribute } },
11704     { NODE_CDATA_SECTION,          "cdata",     { &IID_IXMLDOMNode, &IID_IXMLDOMCDATASection } },
11705     { NODE_ENTITY_REFERENCE,       "entityref", { &IID_IXMLDOMNode, &IID_IXMLDOMEntityReference } },
11706     { NODE_PROCESSING_INSTRUCTION, "pi",        { &IID_IXMLDOMNode, &IID_IXMLDOMProcessingInstruction } },
11707     { NODE_COMMENT,                "comment",   { &IID_IXMLDOMNode, &IID_IXMLDOMComment } },
11708     { NODE_DOCUMENT_FRAGMENT,      "fragment",  { &IID_IXMLDOMNode, &IID_IXMLDOMDocumentFragment } },
11709     { NODE_INVALID }
11710 };
11711
11712 static void test_supporterrorinfo(void)
11713 {
11714     static REFIID iids[5] = { &IID_IXMLDOMNode, &IID_IXMLDOMDocument,
11715                               &IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3 };
11716     const supporterror_t *ptr = supporterror_test;
11717     ISupportErrorInfo *errorinfo, *info2;
11718     IXMLDOMNamedNodeMap *map, *map2;
11719     IXMLDOMDocument *doc;
11720     IXMLDOMElement *elem;
11721     VARIANT_BOOL b;
11722     IUnknown *unk;
11723     REFIID *iid;
11724     void *dummy;
11725     HRESULT hr;
11726
11727     doc = create_document_version(60, &IID_IXMLDOMDocument3);
11728     if (!doc) return;
11729
11730     EXPECT_REF(doc, 1);
11731     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&errorinfo);
11732     EXPECT_HR(hr, S_OK);
11733     EXPECT_REF(doc, 1);
11734     ISupportErrorInfo_AddRef(errorinfo);
11735     EXPECT_REF(errorinfo, 2);
11736     EXPECT_REF(doc, 1);
11737     ISupportErrorInfo_Release(errorinfo);
11738
11739     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&info2);
11740     EXPECT_HR(hr, S_OK);
11741     ok(errorinfo != info2, "got %p, %p\n", info2, errorinfo);
11742
11743     /* error interface can't be queried back for DOM interface */
11744     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMDocument, &dummy);
11745     EXPECT_HR(hr, E_NOINTERFACE);
11746     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMNode, &dummy);
11747     EXPECT_HR(hr, E_NOINTERFACE);
11748
11749     ISupportErrorInfo_Release(info2);
11750
11751     iid = iids;
11752     while (*iid)
11753     {
11754         hr = IXMLDOMDocument_QueryInterface(doc, *iid, (void**)&unk);
11755         EXPECT_HR(hr, S_OK);
11756         if (hr == S_OK)
11757         {
11758             hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
11759             ok(hr == S_OK, "got 0x%08x for %s\n", hr, debugstr_guid(*iid));
11760             IUnknown_Release(unk);
11761         }
11762
11763         iid++;
11764     }
11765
11766     ISupportErrorInfo_Release(errorinfo);
11767
11768     while (ptr->type != NODE_INVALID)
11769     {
11770         IXMLDOMNode *node;
11771         VARIANT type;
11772
11773         V_VT(&type) = VT_I1;
11774         V_I1(&type) = ptr->type;
11775
11776         hr = IXMLDOMDocument_createNode(doc, type, _bstr_(ptr->name), NULL, &node);
11777         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
11778
11779         EXPECT_REF(node, 1);
11780         hr = IXMLDOMNode_QueryInterface(node, &IID_ISupportErrorInfo, (void**)&errorinfo);
11781         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
11782         EXPECT_REF(node, 1);
11783
11784         hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNode, &dummy);
11785         ok(hr == E_NOINTERFACE, "%d: got 0x%08x\n", ptr->type, hr);
11786
11787         iid = ptr->iids;
11788
11789         while (*iid)
11790         {
11791             hr = IXMLDOMNode_QueryInterface(node, *iid, (void**)&unk);
11792             if (hr == S_OK)
11793             {
11794                 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
11795                 ok(hr == S_OK, "%d: got 0x%08x for %s\n", ptr->type, hr, debugstr_guid(*iid));
11796                 IUnknown_Release(unk);
11797             }
11798
11799             iid++;
11800         }
11801
11802         ISupportErrorInfo_Release(errorinfo);
11803         IXMLDOMNode_Release(node);
11804         ptr++;
11805     }
11806
11807     /* IXMLDOMNamedNodeMap */
11808     b = VARIANT_FALSE;
11809     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
11810     EXPECT_HR(hr, S_OK);
11811     ok(b == VARIANT_TRUE, "got %d\n", b);
11812
11813     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
11814     EXPECT_HR(hr, S_OK);
11815
11816     hr = IXMLDOMElement_get_attributes(elem, &map);
11817     EXPECT_HR(hr, S_OK);
11818
11819     EXPECT_REF(map, 1);
11820     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_ISupportErrorInfo, (void**)&errorinfo);
11821     EXPECT_HR(hr, S_OK);
11822     EXPECT_REF(map, 2);
11823
11824     hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMNamedNodeMap);
11825     EXPECT_HR(hr, S_OK);
11826
11827     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNamedNodeMap, (void**)&map2);
11828     EXPECT_HR(hr, S_OK);
11829     ok(map == map2, "got %p\n", map2);
11830     IXMLDOMNamedNodeMap_Release(map2);
11831
11832     EXPECT_REF(errorinfo, 2);
11833     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IUnknown, (void**)&unk);
11834     EXPECT_HR(hr, S_OK);
11835     EXPECT_REF(errorinfo, 3);
11836     EXPECT_REF(map, 3);
11837     IUnknown_Release(unk);
11838
11839     ISupportErrorInfo_Release(errorinfo);
11840     IXMLDOMNamedNodeMap_Release(map);
11841     IXMLDOMElement_Release(elem);
11842
11843     IXMLDOMDocument_Release(doc);
11844     free_bstrs();
11845 }
11846
11847 typedef struct {
11848     DOMNodeType type;
11849     const char *name;
11850     const char *put_content;
11851     HRESULT put_hr;
11852     VARTYPE get_vt;
11853     HRESULT get_hr;
11854 } node_value_t;
11855
11856 static const node_value_t nodevalue_test[] = {
11857     { NODE_ELEMENT,                "element",   "",             E_FAIL, VT_NULL, S_FALSE },
11858     { NODE_ATTRIBUTE,              "attr",      "value",        S_OK,   VT_BSTR, S_OK },
11859     { NODE_TEXT,                   "text",      "textdata",     S_OK,   VT_BSTR, S_OK },
11860     { NODE_CDATA_SECTION ,         "cdata",     "cdata data",   S_OK,   VT_BSTR, S_OK },
11861     { NODE_ENTITY_REFERENCE,       "entityref", "ref",          E_FAIL, VT_NULL, S_FALSE },
11862     { NODE_PROCESSING_INSTRUCTION, "pi",        "instr",        S_OK,   VT_BSTR, S_OK },
11863     { NODE_COMMENT,                "comment",   "comment data", S_OK,   VT_BSTR, S_OK },
11864     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   "",             E_FAIL, VT_NULL, S_FALSE },
11865     { NODE_INVALID }
11866 };
11867
11868 static void test_nodeValue(void)
11869 {
11870     const node_value_t *ptr = nodevalue_test;
11871     IXMLDOMDocument *doc;
11872     HRESULT hr;
11873
11874     doc = create_document(&IID_IXMLDOMDocument);
11875     if (!doc) return;
11876
11877     while (ptr->type != NODE_INVALID)
11878     {
11879         IXMLDOMNode *node;
11880         VARIANT v;
11881
11882         V_VT(&v) = VT_I2;
11883         V_I2(&v) = ptr->type;
11884
11885         hr = IXMLDOMDocument_createNode(doc, v, _bstr_(ptr->name), NULL, &node);
11886         ok(hr == S_OK, "failed to create node type %d\n", ptr->type);
11887
11888         hr = IXMLDOMNode_get_nodeValue(node, NULL);
11889         ok(hr == E_INVALIDARG, "%d: got 0x%08x\n", ptr->type, hr);
11890
11891         V_VT(&v) = VT_BSTR;
11892         V_BSTR(&v) = _bstr_(ptr->put_content);
11893         hr = IXMLDOMNode_put_nodeValue(node, v);
11894         ok(hr == ptr->put_hr, "%d: got 0x%08x\n", ptr->type, hr);
11895
11896         V_VT(&v) = VT_EMPTY;
11897         hr = IXMLDOMNode_get_nodeValue(node, &v);
11898         ok(hr == ptr->get_hr, "%d: got 0x%08x, expected 0x%08x\n", ptr->type, hr, ptr->get_hr);
11899         ok(V_VT(&v) == ptr->get_vt, "%d: got %d, expected %d\n", ptr->type, V_VT(&v), ptr->get_vt);
11900         if (hr == S_OK)
11901             ok(!lstrcmpW(V_BSTR(&v), _bstr_(ptr->put_content)), "%d: got %s\n", ptr->type,
11902                 wine_dbgstr_w(V_BSTR(&v)));
11903         VariantClear(&v);
11904
11905         IXMLDOMNode_Release(node);
11906
11907         ptr++;
11908     }
11909
11910     IXMLDOMDocument_Release(doc);
11911 }
11912
11913 static const char namespacesA[] =
11914 "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
11915 "   <ns1:elem1 xmlns:ns1=\"http://blah.org\" b='1' >"
11916 "     <ns2:elem2 xmlns:ns2=\"http://blah.org\"/>"
11917 "     <ns1:elem3/>"
11918 "     <ns1:elem4/>"
11919 "     <elem5 xmlns=\"http://blahblah.org\"/>"
11920 "     <ns1:elem6>true</ns1:elem6>"
11921 "   </ns1:elem1>";
11922
11923 static const char xsd_schema1_uri[] = "x-schema:test1.xsd";
11924 static const char xsd_schema1_xml[] =
11925 "<?xml version='1.0'?>"
11926 "<schema xmlns='http://www.w3.org/2001/XMLSchema'"
11927 "            targetNamespace='x-schema:test1.xsd'>"
11928 "   <element name='root'>"
11929 "       <complexType>"
11930 "           <sequence maxOccurs='unbounded'>"
11931 "               <any/>"
11932 "           </sequence>"
11933 "       </complexType>"
11934 "   </element>"
11935 "</schema>";
11936
11937 static void test_get_namespaces(void)
11938 {
11939     IXMLDOMSchemaCollection *collection, *collection2;
11940     IXMLDOMDocument2 *doc, *doc2;
11941     IEnumVARIANT *enumv, *enum2;
11942     IUnknown *unk1, *unk2;
11943     IXMLDOMNode *node;
11944     VARIANT_BOOL b;
11945     HRESULT hr;
11946     VARIANT v;
11947     LONG len;
11948     BSTR s;
11949
11950     doc = create_document(&IID_IXMLDOMDocument2);
11951     if (!doc) return;
11952
11953     /* null pointer */
11954     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
11955     EXPECT_HR(hr, E_POINTER);
11956
11957     /* no document loaded */
11958     collection = (void*)0xdeadbeef;
11959     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11960     EXPECT_HR(hr, S_OK);
11961     if (hr != S_OK)
11962     {
11963         IXMLDOMDocument2_Release(doc);
11964         return;
11965     }
11966     EXPECT_REF(collection, 2);
11967
11968     collection2 = (void*)0xdeadbeef;
11969     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
11970     EXPECT_HR(hr, S_OK);
11971     ok(collection == collection2, "got %p\n", collection2);
11972     EXPECT_REF(collection, 3);
11973     IXMLDOMSchemaCollection_Release(collection);
11974
11975     len = -1;
11976     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11977     EXPECT_HR(hr, S_OK);
11978     ok(len == 0, "got %d\n", len);
11979     IXMLDOMSchemaCollection_Release(collection);
11980
11981     /* now with document */
11982     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
11983     EXPECT_HR(hr, S_OK);
11984
11985     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
11986     EXPECT_HR(hr, S_OK);
11987
11988     len = -1;
11989     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
11990     EXPECT_HR(hr, S_OK);
11991     ok(len == 2, "got %d\n", len);
11992
11993     /* try to lookup some uris */
11994     node = (void*)0xdeadbeef;
11995     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
11996     EXPECT_HR(hr, S_OK);
11997     ok(node == NULL, "got %p\n", node);
11998
11999     node = (void*)0xdeadbeef;
12000     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah1.org"), &node);
12001     EXPECT_HR(hr, S_OK);
12002     ok(node == NULL, "got %p\n", node);
12003
12004     /* load schema and try to add it */
12005     doc2 = create_document(&IID_IXMLDOMDocument2);
12006     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
12007     EXPECT_HR(hr, S_OK);
12008
12009     V_VT(&v) = VT_DISPATCH;
12010     V_DISPATCH(&v) = (IDispatch*)doc2;
12011     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
12012     EXPECT_HR(hr, E_FAIL);
12013
12014     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
12015     EXPECT_HR(hr, S_OK);
12016     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
12017     SysFreeString(s);
12018
12019     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
12020     EXPECT_HR(hr, S_OK);
12021     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
12022     SysFreeString(s);
12023
12024     s = (void*)0xdeadbeef;
12025     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
12026     EXPECT_HR(hr, E_FAIL);
12027     ok(s == (void*)0xdeadbeef, "got %p\n", s);
12028
12029     /* enumerate */
12030     enumv = (void*)0xdeadbeef;
12031     EXPECT_REF(collection, 2);
12032     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
12033     EXPECT_HR(hr, S_OK);
12034     EXPECT_REF(collection, 3);
12035     ok(enumv != NULL, "got %p\n", enumv);
12036
12037     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IUnknown, (void**)&unk1);
12038     EXPECT_HR(hr, S_OK);
12039     hr = IEnumVARIANT_QueryInterface(enumv, &IID_IUnknown, (void**)&unk2);
12040     EXPECT_HR(hr, S_OK);
12041     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
12042     IUnknown_Release(unk1);
12043     IUnknown_Release(unk2);
12044
12045     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IEnumVARIANT, (void**)&enum2);
12046     EXPECT_HR(hr, E_NOINTERFACE);
12047
12048     V_VT(&v) = VT_EMPTY;
12049     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12050     EXPECT_HR(hr, S_OK);
12051     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12052     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12053     VariantClear(&v);
12054
12055     V_VT(&v) = VT_EMPTY;
12056     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12057     EXPECT_HR(hr, S_OK);
12058     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12059     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12060     VariantClear(&v);
12061
12062     V_VT(&v) = VT_NULL;
12063     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12064     EXPECT_HR(hr, S_FALSE);
12065     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
12066
12067     IEnumVARIANT_Release(enumv);
12068     IXMLDOMSchemaCollection_Release(collection);
12069
12070     IXMLDOMDocument2_Release(doc);
12071
12072     /* now with CLSID_DOMDocument60 */
12073     doc = create_document_version(60, &IID_IXMLDOMDocument2);
12074     if (!doc) return;
12075
12076     /* null pointer */
12077     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
12078     EXPECT_HR(hr, E_POINTER);
12079
12080     /* no document loaded */
12081     collection = (void*)0xdeadbeef;
12082     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
12083     EXPECT_HR(hr, S_OK);
12084     if (hr != S_OK)
12085     {
12086         IXMLDOMDocument2_Release(doc);
12087         return;
12088     }
12089     EXPECT_REF(collection, 2);
12090
12091     collection2 = (void*)0xdeadbeef;
12092     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
12093     EXPECT_HR(hr, S_OK);
12094     ok(collection == collection2, "got %p\n", collection2);
12095     EXPECT_REF(collection, 3);
12096     IXMLDOMSchemaCollection_Release(collection);
12097
12098     len = -1;
12099     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
12100     EXPECT_HR(hr, S_OK);
12101     ok(len == 0, "got %d\n", len);
12102     IXMLDOMSchemaCollection_Release(collection);
12103
12104     /* now with document */
12105     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
12106     EXPECT_HR(hr, S_OK);
12107
12108     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
12109     EXPECT_HR(hr, S_OK);
12110
12111     len = -1;
12112     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
12113     EXPECT_HR(hr, S_OK);
12114     ok(len == 2, "got %d\n", len);
12115
12116     /* try to lookup some uris */
12117     node = (void*)0xdeadbeef;
12118     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
12119     EXPECT_HR(hr, E_NOTIMPL);
12120     ok(node == (void*)0xdeadbeef, "got %p\n", node);
12121
12122     /* load schema and try to add it */
12123     doc2 = create_document(&IID_IXMLDOMDocument2);
12124     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
12125     EXPECT_HR(hr, S_OK);
12126
12127     V_VT(&v) = VT_DISPATCH;
12128     V_DISPATCH(&v) = (IDispatch*)doc2;
12129     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
12130     EXPECT_HR(hr, E_FAIL);
12131     IXMLDOMDocument2_Release(doc2);
12132
12133     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
12134     EXPECT_HR(hr, S_OK);
12135     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
12136     SysFreeString(s);
12137
12138     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
12139     EXPECT_HR(hr, S_OK);
12140     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
12141     SysFreeString(s);
12142
12143     s = (void*)0xdeadbeef;
12144     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
12145     EXPECT_HR(hr, E_FAIL);
12146     ok(s == (void*)0xdeadbeef, "got %p\n", s);
12147
12148     /* enumerate */
12149     enumv = (void*)0xdeadbeef;
12150     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
12151     EXPECT_HR(hr, S_OK);
12152     ok(enumv != NULL, "got %p\n", enumv);
12153
12154     V_VT(&v) = VT_EMPTY;
12155     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12156     EXPECT_HR(hr, S_OK);
12157     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12158     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12159     VariantClear(&v);
12160
12161     V_VT(&v) = VT_EMPTY;
12162     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12163     EXPECT_HR(hr, S_OK);
12164     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
12165     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
12166     VariantClear(&v);
12167
12168     V_VT(&v) = VT_NULL;
12169     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
12170     EXPECT_HR(hr, S_FALSE);
12171     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
12172
12173     IEnumVARIANT_Release(enumv);
12174     IXMLDOMSchemaCollection_Release(collection);
12175     IXMLDOMDocument2_Release(doc);
12176     free_bstrs();
12177 }
12178
12179 static DOMNodeType put_data_types[] = {
12180     NODE_TEXT,
12181     NODE_CDATA_SECTION,
12182     NODE_PROCESSING_INSTRUCTION,
12183     NODE_COMMENT,
12184     NODE_INVALID
12185 };
12186
12187 static void test_put_data(void)
12188 {
12189     static const WCHAR test_data[] = {'t','e','s','t',' ','n','o','d','e',' ','d','a','t','a',0};
12190     WCHAR buff[100], *data;
12191     IXMLDOMDocument *doc;
12192     DOMNodeType *type;
12193     IXMLDOMText *text;
12194     IXMLDOMNode *node;
12195     VARIANT v;
12196     BSTR get_data;
12197     HRESULT hr;
12198
12199     doc = create_document(&IID_IXMLDOMDocument);
12200     if (!doc) return;
12201
12202     memcpy(&buff[2], test_data, sizeof(test_data));
12203     /* just a big length */
12204     *(DWORD*)buff = 0xf0f0;
12205     data = &buff[2];
12206
12207     type = put_data_types;
12208     while (*type != NODE_INVALID)
12209     {
12210        V_VT(&v) = VT_I2;
12211        V_I2(&v) = *type;
12212
12213        hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
12214        EXPECT_HR(hr, S_OK);
12215
12216        /* put_data() is interface-specific */
12217        switch (*type)
12218        {
12219            case NODE_TEXT:
12220            {
12221               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
12222               EXPECT_HR(hr, S_OK);
12223               hr = IXMLDOMText_put_data(text, data);
12224               EXPECT_HR(hr, S_OK);
12225
12226               hr = IXMLDOMText_get_data(text, &get_data);
12227               EXPECT_HR(hr, S_OK);
12228
12229               IXMLDOMText_Release(text);
12230               break;
12231            }
12232            case NODE_CDATA_SECTION:
12233            {
12234               IXMLDOMCDATASection *cdata;
12235
12236               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
12237               EXPECT_HR(hr, S_OK);
12238               hr = IXMLDOMCDATASection_put_data(cdata, data);
12239               EXPECT_HR(hr, S_OK);
12240
12241               hr = IXMLDOMCDATASection_get_data(cdata, &get_data);
12242               EXPECT_HR(hr, S_OK);
12243
12244               IXMLDOMCDATASection_Release(cdata);
12245               break;
12246            }
12247            case NODE_PROCESSING_INSTRUCTION:
12248            {
12249               IXMLDOMProcessingInstruction *pi;
12250
12251               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)&pi);
12252               EXPECT_HR(hr, S_OK);
12253               hr = IXMLDOMProcessingInstruction_put_data(pi, data);
12254               EXPECT_HR(hr, S_OK);
12255
12256               hr = IXMLDOMProcessingInstruction_get_data(pi, &get_data);
12257               EXPECT_HR(hr, S_OK);
12258
12259               IXMLDOMProcessingInstruction_Release(pi);
12260               break;
12261            }
12262            case NODE_COMMENT:
12263            {
12264               IXMLDOMComment *comment;
12265
12266               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
12267               EXPECT_HR(hr, S_OK);
12268               hr = IXMLDOMComment_put_data(comment, data);
12269               EXPECT_HR(hr, S_OK);
12270
12271               hr = IXMLDOMComment_get_data(comment, &get_data);
12272               EXPECT_HR(hr, S_OK);
12273
12274               IXMLDOMComment_Release(comment);
12275               break;
12276            }
12277            default:
12278               break;
12279        }
12280
12281        /* compare */
12282        ok(!lstrcmpW(data, get_data), "%d: got wrong data %s, expected %s\n", *type, wine_dbgstr_w(get_data),
12283            wine_dbgstr_w(data));
12284        SysFreeString(get_data);
12285
12286        IXMLDOMNode_Release(node);
12287        type++;
12288     }
12289
12290     /* \r\n sequence is never escaped */
12291     V_VT(&v) = VT_I2;
12292     V_I2(&v) = NODE_TEXT;
12293
12294     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
12295     ok(hr == S_OK, "got 0x%08x\n", hr);
12296
12297     IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
12298
12299     hr = IXMLDOMText_put_data(text, _bstr_("\r\n"));
12300     ok(hr == S_OK, "got 0x%08x\n", hr);
12301
12302     hr = IXMLDOMText_get_data(text, &get_data);
12303     ok(hr == S_OK, "got 0x%08x\n", hr);
12304 todo_wine
12305     ok(!lstrcmpW(get_data, _bstr_("\n")), "got %s\n", wine_dbgstr_w(get_data));
12306     SysFreeString(get_data);
12307
12308     hr = IXMLDOMText_get_xml(text, &get_data);
12309     ok(hr == S_OK, "got 0x%08x\n", hr);
12310     ok(!lstrcmpW(get_data, _bstr_("\r\n")), "got %s\n", wine_dbgstr_w(get_data));
12311     SysFreeString(get_data);
12312
12313     IXMLDOMText_Release(text);
12314     IXMLDOMNode_Release(node);
12315
12316     IXMLDOMDocument_Release(doc);
12317     free_bstrs();
12318 }
12319
12320 static void test_putref_schemas(void)
12321 {
12322     IXMLDOMSchemaCollection *cache;
12323     IXMLDOMDocument2 *doc;
12324     VARIANT schema;
12325     HRESULT hr;
12326
12327     doc = create_document(&IID_IXMLDOMDocument2);
12328     if (!doc) return;
12329     cache = create_cache(&IID_IXMLDOMSchemaCollection);
12330
12331     /* set to NULL iface when no schema is set */
12332     V_VT(&schema) = VT_DISPATCH;
12333     V_DISPATCH(&schema) = NULL;
12334     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12335     EXPECT_HR(hr, S_OK);
12336
12337     V_VT(&schema) = VT_UNKNOWN;
12338     V_UNKNOWN(&schema) = NULL;
12339     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12340     EXPECT_HR(hr, S_OK);
12341
12342     /* set as VT_DISPATCH, reset with it */
12343     V_VT(&schema) = VT_DISPATCH;
12344     V_DISPATCH(&schema) = (IDispatch*)cache;
12345     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12346     EXPECT_HR(hr, S_OK);
12347
12348     V_DISPATCH(&schema) = NULL;
12349     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12350     EXPECT_HR(hr, S_OK);
12351     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
12352
12353     V_VT(&schema) = VT_DISPATCH;
12354     V_DISPATCH(&schema) = NULL;
12355     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12356     EXPECT_HR(hr, S_OK);
12357
12358     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
12359     V_VT(&schema) = VT_I2;
12360     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12361     EXPECT_HR(hr, S_FALSE);
12362     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
12363     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
12364
12365     /* set as VT_UNKNOWN, reset with it */
12366     V_VT(&schema) = VT_UNKNOWN;
12367     V_UNKNOWN(&schema) = (IUnknown*)cache;
12368     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12369     EXPECT_HR(hr, S_OK);
12370
12371     V_DISPATCH(&schema) = NULL;
12372     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12373     EXPECT_HR(hr, S_OK);
12374     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
12375
12376     V_VT(&schema) = VT_UNKNOWN;
12377     V_UNKNOWN(&schema) = NULL;
12378     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
12379     EXPECT_HR(hr, S_OK);
12380
12381     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
12382     V_VT(&schema) = VT_I2;
12383     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
12384     EXPECT_HR(hr, S_FALSE);
12385     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
12386     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
12387
12388     IXMLDOMSchemaCollection_Release(cache);
12389     IXMLDOMDocument2_Release(doc);
12390 }
12391
12392 static void test_namedmap_newenum(void)
12393 {
12394     IEnumVARIANT *enum1, *enum2, *enum3;
12395     IXMLDOMNamedNodeMap *map;
12396     IUnknown *unk1, *unk2;
12397     IXMLDOMDocument *doc;
12398     IXMLDOMElement *elem;
12399     IXMLDOMNode *node;
12400     VARIANT_BOOL b;
12401     HRESULT hr;
12402     VARIANT v;
12403     BSTR str;
12404
12405     doc = create_document(&IID_IXMLDOMDocument);
12406
12407     hr = IXMLDOMDocument_loadXML(doc, _bstr_(attributes_map), &b);
12408     EXPECT_HR(hr, S_OK);
12409
12410     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
12411     EXPECT_HR(hr, S_OK);
12412
12413     hr = IXMLDOMElement_get_attributes(elem, &map);
12414     EXPECT_HR(hr, S_OK);
12415     IXMLDOMElement_Release(elem);
12416
12417     enum1 = NULL;
12418     EXPECT_REF(map, 1);
12419     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum1);
12420     EXPECT_HR(hr, S_OK);
12421     ok(enum1 != NULL, "got %p\n", enum1);
12422     EXPECT_REF(map, 1);
12423     EXPECT_REF(enum1, 2);
12424
12425     enum2 = NULL;
12426     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum2);
12427     EXPECT_HR(hr, S_OK);
12428     ok(enum2 == enum1, "got %p\n", enum2);
12429
12430     IEnumVARIANT_Release(enum2);
12431
12432     EXPECT_REF(map, 1);
12433     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum2);
12434     EXPECT_HR(hr, S_OK);
12435     EXPECT_REF(map, 2);
12436     EXPECT_REF(enum2, 1);
12437     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
12438
12439     IEnumVARIANT_Release(enum1);
12440
12441     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
12442     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk1);
12443     EXPECT_HR(hr, S_OK);
12444     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
12445     EXPECT_HR(hr, S_OK);
12446     EXPECT_REF(map, 3);
12447     EXPECT_REF(enum2, 2);
12448     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
12449     IUnknown_Release(unk1);
12450     IUnknown_Release(unk2);
12451
12452     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum3);
12453     EXPECT_HR(hr, S_OK);
12454     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
12455     IEnumVARIANT_Release(enum3);
12456
12457     /* iteration tests */
12458     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node);
12459     EXPECT_HR(hr, S_OK);
12460     hr = IXMLDOMNode_get_nodeName(node, &str);
12461     EXPECT_HR(hr, S_OK);
12462     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
12463     SysFreeString(str);
12464     IXMLDOMNode_Release(node);
12465
12466     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
12467     EXPECT_HR(hr, S_OK);
12468     hr = IXMLDOMNode_get_nodeName(node, &str);
12469     EXPECT_HR(hr, S_OK);
12470     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
12471     SysFreeString(str);
12472     IXMLDOMNode_Release(node);
12473
12474     V_VT(&v) = VT_EMPTY;
12475     hr = IEnumVARIANT_Next(enum2, 1, &v, NULL);
12476     EXPECT_HR(hr, S_OK);
12477     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
12478     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
12479     EXPECT_HR(hr, S_OK);
12480     hr = IXMLDOMNode_get_nodeName(node, &str);
12481     EXPECT_HR(hr, S_OK);
12482     ok(!lstrcmpW(str, _bstr_("attr1")), "got node name %s\n", wine_dbgstr_w(str));
12483     SysFreeString(str);
12484     IXMLDOMNode_Release(node);
12485     VariantClear(&v);
12486
12487     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
12488     EXPECT_HR(hr, S_OK);
12489     hr = IXMLDOMNode_get_nodeName(node, &str);
12490     EXPECT_HR(hr, S_OK);
12491     ok(!lstrcmpW(str, _bstr_("attr2")), "got %s\n", wine_dbgstr_w(str));
12492     SysFreeString(str);
12493     IXMLDOMNode_Release(node);
12494
12495     IEnumVARIANT_Release(enum2);
12496     IXMLDOMNamedNodeMap_Release(map);
12497     IXMLDOMDocument_Release(doc);
12498 }
12499
12500 static const char xsltext_xsl[] =
12501 "<?xml version=\"1.0\"?>"
12502 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
12503 "<xsl:output method=\"html\" encoding=\"us-ascii\"/>"
12504 "<xsl:template match=\"/\">"
12505 "    <xsl:choose>"
12506 "        <xsl:when test=\"testkey\">"
12507 "            <xsl:text>testdata</xsl:text>"
12508 "        </xsl:when>"
12509 "    </xsl:choose>"
12510 "</xsl:template>"
12511 "</xsl:stylesheet>";
12512
12513 static void test_xsltext(void)
12514 {
12515     IXMLDOMDocument *doc, *doc2;
12516     VARIANT_BOOL b;
12517     HRESULT hr;
12518     BSTR ret;
12519
12520     doc = create_document(&IID_IXMLDOMDocument);
12521     if (!doc) return;
12522
12523     doc2 = create_document(&IID_IXMLDOMDocument);
12524
12525     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xsltext_xsl), &b);
12526     EXPECT_HR(hr, S_OK);
12527
12528     hr = IXMLDOMDocument_loadXML(doc2, _bstr_("<testkey/>"), &b);
12529     EXPECT_HR(hr, S_OK);
12530
12531     hr = IXMLDOMDocument_transformNode(doc2, (IXMLDOMNode*)doc, &ret);
12532     EXPECT_HR(hr, S_OK);
12533     ok(!lstrcmpW(ret, _bstr_("testdata")), "transform result %s\n", wine_dbgstr_w(ret));
12534     SysFreeString(ret);
12535
12536     IXMLDOMDocument_Release(doc2);
12537     IXMLDOMDocument_Release(doc);
12538     free_bstrs();
12539 }
12540
12541 START_TEST(domdoc)
12542 {
12543     IXMLDOMDocument *doc;
12544     IUnknown *unk;
12545     HRESULT hr;
12546
12547     hr = CoInitialize( NULL );
12548     ok( hr == S_OK, "failed to init com\n");
12549     if (hr != S_OK) return;
12550
12551     test_XMLHTTP();
12552
12553     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc );
12554     if (hr != S_OK)
12555     {
12556         win_skip("IXMLDOMDocument is not available (0x%08x)\n", hr);
12557         return;
12558     }
12559
12560     IXMLDOMDocument_Release(doc);
12561
12562     test_domdoc();
12563     test_persiststreaminit();
12564     test_domnode();
12565     test_refs();
12566     test_create();
12567     test_getElementsByTagName();
12568     test_get_text();
12569     test_get_childNodes();
12570     test_get_firstChild();
12571     test_get_lastChild();
12572     test_removeChild();
12573     test_replaceChild();
12574     test_removeNamedItem();
12575     test_IXMLDOMDocument2();
12576     test_whitespace();
12577     test_XPath();
12578     test_XSLPattern();
12579     test_cloneNode();
12580     test_xmlTypes();
12581     test_save();
12582     test_testTransforms();
12583     test_namespaces_basic();
12584     test_namespaces_change();
12585     test_FormattingXML();
12586     test_nodeTypedValue();
12587     test_TransformWithLoadingLocalFile();
12588     test_put_nodeValue();
12589     test_document_IObjectSafety();
12590     test_splitText();
12591     test_getQualifiedItem();
12592     test_removeQualifiedItem();
12593     test_get_ownerDocument();
12594     test_setAttributeNode();
12595     test_put_dataType();
12596     test_createNode();
12597     test_get_prefix();
12598     test_default_properties();
12599     test_selectSingleNode();
12600     test_events();
12601     test_createProcessingInstruction();
12602     test_put_nodeTypedValue();
12603     test_get_xml();
12604     test_insertBefore();
12605     test_appendChild();
12606     test_get_doctype();
12607     test_get_tagName();
12608     test_get_dataType();
12609     test_get_nodeTypeString();
12610     test_get_attributes();
12611     test_selection();
12612     test_load();
12613     test_dispex();
12614     test_parseerror();
12615     test_getAttributeNode();
12616     test_supporterrorinfo();
12617     test_nodeValue();
12618     test_get_namespaces();
12619     test_put_data();
12620     test_putref_schemas();
12621     test_namedmap_newenum();
12622
12623     test_xsltemplate();
12624     test_xsltext();
12625
12626     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
12627         &IID_IMXNamespaceManager, (void**)&unk);
12628     if (hr == S_OK)
12629     {
12630         test_mxnamespacemanager();
12631         test_mxnamespacemanager_override();
12632
12633         IUnknown_Release(unk);
12634     }
12635     else
12636         win_skip("MXNamespaceManager is not available\n");
12637
12638     CoUninitialize();
12639 }