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 #include "objsafe.h"
  38 #include "initguid.h"
  39
  40 #include "wine/test.h"
  41
  42 /* undef the #define in msxml2 so that we can access all versions */
  43 #undef CLSID_DOMDocument
  44
  45 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  46
  47 static const char *debugstr_guid(REFIID riid)
  48 {
  49     static char buf[50];
  50
  51     if(!riid)
  52         return "(null)";
  53
  54     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  55             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
  56             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
  57             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
  58
  59     return buf;
  60 }
  61
  62 static int g_unexpectedcall, g_expectedcall;
  63
  64 typedef struct
  65 {
  66     IDispatch IDispatch_iface;
  67     LONG ref;
  68 } dispevent;
  69
  70 static inline dispevent *impl_from_IDispatch( IDispatch *iface )
  71 {
  72     return CONTAINING_RECORD(iface, dispevent, IDispatch_iface);
  73 }
  74
  75 static HRESULT WINAPI dispevent_QueryInterface(IDispatch *iface, REFIID riid, void **ppvObject)
  76 {
  77     *ppvObject = NULL;
  78
  79     if ( IsEqualGUID( riid, &IID_IDispatch) ||
  80          IsEqualGUID( riid, &IID_IUnknown) )
  81     {
  82         *ppvObject = iface;
  83     }
  84     else
  85         return E_NOINTERFACE;
  86
  87     IDispatch_AddRef( iface );
  88
  89     return S_OK;
  90 }
  91
  92 static ULONG WINAPI dispevent_AddRef(IDispatch *iface)
  93 {
  94     dispevent *This = impl_from_IDispatch( iface );
  95     return InterlockedIncrement( &This->ref );
  96 }
  97
  98 static ULONG WINAPI dispevent_Release(IDispatch *iface)
  99 {
 100     dispevent *This = impl_from_IDispatch( iface );
 101     ULONG ref = InterlockedDecrement( &This->ref );
 102
 103     if (ref == 0)
 104         HeapFree(GetProcessHeap(), 0, This);
 105
 106     return ref;
 107 }
 108
 109 static HRESULT WINAPI dispevent_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 110 {
 111     g_unexpectedcall++;
 112     *pctinfo = 0;
 113     return S_OK;
 114 }
 115
 116 static HRESULT WINAPI dispevent_GetTypeInfo(IDispatch *iface, UINT iTInfo,
 117         LCID lcid, ITypeInfo **ppTInfo)
 118 {
 119     g_unexpectedcall++;
 120     return S_OK;
 121 }
 122
 123 static HRESULT WINAPI dispevent_GetIDsOfNames(IDispatch *iface, REFIID riid,
 124         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 125 {
 126     g_unexpectedcall++;
 127     return S_OK;
 128 }
 129
 130 static HRESULT WINAPI dispevent_Invoke(IDispatch *iface, DISPID member, REFIID riid,
 131         LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result,
 132         EXCEPINFO *excepInfo, UINT *argErr)
 133 {
 134     ok(member == 0, "expected 0 member, got %d\n", member);
 135     ok(lcid == LOCALE_SYSTEM_DEFAULT, "expected LOCALE_SYSTEM_DEFAULT, got lcid %x\n", lcid);
 136     ok(flags == DISPATCH_METHOD, "expected DISPATCH_METHOD, got %d\n", flags);
 137
 138     ok(params->cArgs == 0, "got %d\n", params->cArgs);
 139     ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
 140     ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
 141     ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
 142
 143     ok(result == NULL, "got %p\n", result);
 144     ok(excepInfo == NULL, "got %p\n", excepInfo);
 145     ok(argErr == NULL, "got %p\n", argErr);
 146
 147     g_expectedcall++;
 148     return E_FAIL;
 149 }
 150
 151 static const IDispatchVtbl dispeventVtbl =
 152 {
 153     dispevent_QueryInterface,
 154     dispevent_AddRef,
 155     dispevent_Release,
 156     dispevent_GetTypeInfoCount,
 157     dispevent_GetTypeInfo,
 158     dispevent_GetIDsOfNames,
 159     dispevent_Invoke
 160 };
 161
 162 static IDispatch* create_dispevent(void)
 163 {
 164     dispevent *event = HeapAlloc(GetProcessHeap(), 0, sizeof(*event));
 165
 166     event->IDispatch_iface.lpVtbl = &dispeventVtbl;
 167     event->ref = 1;
 168
 169     return (IDispatch*)&event->IDispatch_iface;
 170 }
 171
 172 /* IStream */
 173 static HRESULT WINAPI istream_QueryInterface(IStream *iface, REFIID riid, void **ppvObject)
 174 {
 175     *ppvObject = NULL;
 176
 177     if (IsEqualGUID(riid, &IID_IStream) ||
 178         IsEqualGUID(riid, &IID_IUnknown))
 179         *ppvObject = iface;
 180     else
 181         return E_NOINTERFACE;
 182
 183     return S_OK;
 184 }
 185
 186 static ULONG WINAPI istream_AddRef(IStream *iface)
 187 {
 188     return 2;
 189 }
 190
 191 static ULONG WINAPI istream_Release(IStream *iface)
 192 {
 193     return 1;
 194 }
 195
 196 static HRESULT WINAPI istream_Read(IStream *iface, void *ptr, ULONG len, ULONG *pread)
 197 {
 198     ok(0, "unexpected call\n");
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT WINAPI istream_Write(IStream *iface, const void *ptr, ULONG len, ULONG *written)
 203 {
 204     *written = len/2;
 205     return S_OK;
 206 }
 207
 208 static HRESULT WINAPI istream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
 209 {
 210     ok(0, "unexpected call\n");
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI istream_SetSize(IStream *iface, ULARGE_INTEGER size)
 215 {
 216     ok(0, "unexpected call\n");
 217     return E_NOTIMPL;
 218 }
 219
 220 static HRESULT WINAPI istream_CopyTo(IStream *iface, IStream *stream, ULARGE_INTEGER len,
 221         ULARGE_INTEGER *pread, ULARGE_INTEGER *written)
 222 {
 223     ok(0, "unexpected call\n");
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI istream_Commit(IStream *iface, DWORD flags)
 228 {
 229     ok(0, "unexpected call\n");
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT WINAPI istream_Revert(IStream *iface)
 234 {
 235     ok(0, "unexpected call\n");
 236     return E_NOTIMPL;
 237 }
 238
 239 static HRESULT WINAPI istream_LockRegion(IStream *iface, ULARGE_INTEGER offset,
 240         ULARGE_INTEGER len, DWORD locktype)
 241 {
 242     ok(0, "unexpected call\n");
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT WINAPI istream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset,
 247         ULARGE_INTEGER len, DWORD locktype)
 248 {
 249     ok(0, "unexpected call\n");
 250     return E_NOTIMPL;
 251 }
 252
 253 static HRESULT WINAPI istream_Stat(IStream *iface, STATSTG *pstatstg, DWORD flag)
 254 {
 255     ok(0, "unexpected call\n");
 256     return E_NOTIMPL;
 257 }
 258
 259 static HRESULT WINAPI istream_Clone(IStream *iface, IStream **stream)
 260 {
 261     ok(0, "unexpected call\n");
 262     return E_NOTIMPL;
 263 }
 264
 265 static const IStreamVtbl StreamVtbl = {
 266     istream_QueryInterface,
 267     istream_AddRef,
 268     istream_Release,
 269     istream_Read,
 270     istream_Write,
 271     istream_Seek,
 272     istream_SetSize,
 273     istream_CopyTo,
 274     istream_Commit,
 275     istream_Revert,
 276     istream_LockRegion,
 277     istream_UnlockRegion,
 278     istream_Stat,
 279     istream_Clone
 280 };
 281
 282 static IStream savestream = { &StreamVtbl };
 283
 284 #define EXPECT_CHILDREN(node) _expect_children((IXMLDOMNode*)node, __LINE__)
 285 static void _expect_children(IXMLDOMNode *node, int line)
 286 {
 287     VARIANT_BOOL b;
 288     HRESULT hr;
 289
 290     b = VARIANT_FALSE;
 291     hr = IXMLDOMNode_hasChildNodes(node, &b);
 292     ok_(__FILE__,line)(hr == S_OK, "hasChildNodes() failed, 0x%08x\n", hr);
 293     ok_(__FILE__,line)(b == VARIANT_TRUE, "no children, %d\n", b);
 294 }
 295
 296 #define EXPECT_NO_CHILDREN(node) _expect_no_children((IXMLDOMNode*)node, __LINE__)
 297 static void _expect_no_children(IXMLDOMNode *node, int line)
 298 {
 299     VARIANT_BOOL b;
 300     HRESULT hr;
 301
 302     b = VARIANT_TRUE;
 303     hr = IXMLDOMNode_hasChildNodes(node, &b);
 304     ok_(__FILE__,line)(hr == S_FALSE, "hasChildNodes() failed, 0x%08x\n", hr);
 305     ok_(__FILE__,line)(b == VARIANT_FALSE, "no children, %d\n", b);
 306 }
 307
 308 #define EXPECT_REF(node,ref) _expect_ref((IUnknown*)node, ref, __LINE__)
 309 static void _expect_ref(IUnknown* obj, ULONG ref, int line)
 310 {
 311     ULONG rc = IUnknown_AddRef(obj);
 312     IUnknown_Release(obj);
 313     ok_(__FILE__,line)(rc-1 == ref, "expected refcount %d, got %d\n", ref, rc-1);
 314 }
 315
 316 #define EXPECT_LIST_LEN(list,len) _expect_list_len(list, len, __LINE__)
 317 static void _expect_list_len(IXMLDOMNodeList *list, LONG len, int line)
 318 {
 319     LONG length;
 320     HRESULT hr;
 321
 322     length = 0;
 323     hr = IXMLDOMNodeList_get_length(list, &length);
 324     ok_(__FILE__,line)(hr == S_OK, "got 0x%08x\n", hr);
 325     ok_(__FILE__,line)(length == len, "got %d, expected %d\n", length, len);
 326 }
 327
 328 #define EXPECT_HR(hr,hr_exp) \
 329     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
 330
 331 static const WCHAR szEmpty[] = { 0 };
 332 static const WCHAR szIncomplete[] = {
 333     '<','?','x','m','l',' ',
 334     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
 335 };
 336 static const WCHAR szComplete1[] = {
 337     '<','?','x','m','l',' ',
 338     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 339     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
 340 };
 341 static const WCHAR szComplete2[] = {
 342     '<','?','x','m','l',' ',
 343     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 344     '<','o','>','<','/','o','>','\n',0
 345 };
 346 static const WCHAR szComplete3[] = {
 347     '<','?','x','m','l',' ',
 348     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 349     '<','a','>','<','/','a','>','\n',0
 350 };
 351 static const char complete4A[] =
 352     "<?xml version=\'1.0\'?>\n"
 353     "<lc dl=\'str1\'>\n"
 354         "<bs vr=\'str2\' sz=\'1234\'>"
 355             "fn1.txt\n"
 356         "</bs>\n"
 357         "<pr id=\'str3\' vr=\'1.2.3\' pn=\'wine 20050804\'>\n"
 358             "fn2.txt\n"
 359         "</pr>\n"
 360         "<empty></empty>\n"
 361         "<fo>\n"
 362             "<ba>\n"
 363                 "f1\n"
 364             "</ba>\n"
 365         "</fo>\n"
 366     "</lc>\n";
 367
 368 static const WCHAR szComplete5[] = {
 369     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
 370     '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','"',
 371     ' ','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','"','>',
 372         '<','S',':','s','c','o','p','e','>',
 373             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
 374         '<','/','S',':','s','c','o','p','e','>',
 375         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
 376             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
 377             'c','o','m','p','u','t','e','r',
 378         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
 379     '<','/','S',':','s','e','a','r','c','h','>',0
 380 };
 381
 382 static const WCHAR szComplete6[] = {
 383     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'',' ',
 384     'e','n','c','o','d','i','n','g','=','\'','W','i','n','d','o','w','s','-','1','2','5','2','\'','?','>','\n',
 385     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
 386 };
 387
 388 #define DECL_WIN_1252 \
 389 "<?xml version=\"1.0\" encoding=\"Windows-1252\"?>"
 390
 391 static const char win1252xml[] =
 392 DECL_WIN_1252
 393 "<open></open>";
 394
 395 static const char win1252decl[] =
 396 DECL_WIN_1252
 397 ;
 398
 399 static const char szExampleXML[] =
 400 "<?xml version='1.0' encoding='utf-8'?>\n"
 401 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' a=\"attr a\" foo:b=\"attr b\" >\n"
 402 "    <elem>\n"
 403 "        <a>A1 field</a>\n"
 404 "        <b>B1 field</b>\n"
 405 "        <c>C1 field</c>\n"
 406 "        <d>D1 field</d>\n"
 407 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 408 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
 409 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
 410 "            </html>\n"
 411 "            <html xml:space='preserve' xmlns='http://www.w3.org/1999/xhtml'>\n"
 412 "                This is <strong>a</strong> <i>description</i> with preserved whitespace. <bar:x/>\n"
 413 "            </html>\n"
 414 "        </description>\n"
 415 "    </elem>\n"
 416 "\n"
 417 "    <elem>\n"
 418 "        <a>A2 field</a>\n"
 419 "        <b>B2 field</b>\n"
 420 "        <c type=\"old\">C2 field</c>\n"
 421 "        <d>D2 field</d>\n"
 422 "    </elem>\n"
 423 "\n"
 424 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 425 "        <a>A3 field</a>\n"
 426 "        <b>B3 field</b>\n"
 427 "        <c>C3 field</c>\n"
 428 "    </elem>\n"
 429 "\n"
 430 "    <elem>\n"
 431 "        <a>A4 field</a>\n"
 432 "        <b>B4 field</b>\n"
 433 "        <foo:c>C4 field</foo:c>\n"
 434 "        <d>D4 field</d>\n"
 435 "    </elem>\n"
 436 "</root>\n";
 437
 438 static const CHAR szNodeTypesXML[] =
 439 "<?xml version='1.0'?>"
 440 "<!-- comment node 0 -->"
 441 "<root id='0' depth='0'>"
 442 "   <!-- comment node 1 -->"
 443 "   text node 0"
 444 "   <x id='1' depth='1'>"
 445 "       <?foo value='PI for x'?>"
 446 "       <!-- comment node 2 -->"
 447 "       text node 1"
 448 "       <a id='3' depth='2'/>"
 449 "       <b id='4' depth='2'/>"
 450 "       <c id='5' depth='2'/>"
 451 "   </x>"
 452 "   <y id='2' depth='1'>"
 453 "       <?bar value='PI for y'?>"
 454 "       <!-- comment node 3 -->"
 455 "       text node 2"
 456 "       <a id='6' depth='2'/>"
 457 "       <b id='7' depth='2'/>"
 458 "       <c id='8' depth='2'/>"
 459 "   </y>"
 460 "</root>";
 461
 462 static const CHAR szTransformXML[] =
 463 "<?xml version=\"1.0\"?>\n"
 464 "<greeting>\n"
 465 "Hello World\n"
 466 "</greeting>";
 467
 468 static  const CHAR szTransformSSXML[] =
 469 "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
 470 "   <xsl:output method=\"html\"/>\n"
 471 "   <xsl:template match=\"/\">\n"
 472 "       <xsl:apply-templates select=\"greeting\"/>\n"
 473 "   </xsl:template>\n"
 474 "   <xsl:template match=\"greeting\">\n"
 475 "       <html>\n"
 476 "           <body>\n"
 477 "               <h1>\n"
 478 "                   <xsl:value-of select=\".\"/>\n"
 479 "               </h1>\n"
 480 "           </body>\n"
 481 "       </html>\n"
 482 "   </xsl:template>\n"
 483 "</xsl:stylesheet>";
 484
 485 static  const CHAR szTransformOutput[] =
 486 "<html><body><h1>"
 487 "Hello World"
 488 "</h1></body></html>";
 489
 490 static const CHAR szTypeValueXML[] =
 491 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
 492 "<root xmlns:dt=\"urn:schemas-microsoft-com:datatypes\">\n"
 493 "   <string>Wine</string>\n"
 494 "   <string2 dt:dt=\"string\">String</string2>\n"
 495 "   <number dt:dt=\"number\">12.44</number>\n"
 496 "   <number2 dt:dt=\"NUMbEr\">-3.71e3</number2>\n"
 497 "   <int dt:dt=\"int\">-13</int>\n"
 498 "   <fixed dt:dt=\"fixed.14.4\">7322.9371</fixed>\n"
 499 "   <bool dt:dt=\"boolean\">1</bool>\n"
 500 "   <datetime dt:dt=\"datetime\">2009-11-18T03:21:33.12</datetime>\n"
 501 "   <datetimetz dt:dt=\"datetime.tz\">2003-07-11T11:13:57+03:00</datetimetz>\n"
 502 "   <date dt:dt=\"date\">3721-11-01</date>\n"
 503 "   <time dt:dt=\"time\">13:57:12.31321</time>\n"
 504 "   <timetz dt:dt=\"time.tz\">23:21:01.13+03:21</timetz>\n"
 505 "   <i1 dt:dt=\"i1\">-13</i1>\n"
 506 "   <i2 dt:dt=\"i2\">31915</i2>\n"
 507 "   <i4 dt:dt=\"i4\">-312232</i4>\n"
 508 "   <ui1 dt:dt=\"ui1\">123</ui1>\n"
 509 "   <ui2 dt:dt=\"ui2\">48282</ui2>\n"
 510 "   <ui4 dt:dt=\"ui4\">949281</ui4>\n"
 511 "   <r4 dt:dt=\"r4\">213124.0</r4>\n"
 512 "   <r8 dt:dt=\"r8\">0.412</r8>\n"
 513 "   <float dt:dt=\"float\">41221.421</float>\n"
 514 "   <uuid dt:dt=\"uuid\">333C7BC4-460F-11D0-BC04-0080C7055a83</uuid>\n"
 515 "   <binhex dt:dt=\"bin.hex\">fffca012003c</binhex>\n"
 516 "   <binbase64 dt:dt=\"bin.base64\">YmFzZTY0IHRlc3Q=</binbase64>\n"
 517 "   <binbase64_1 dt:dt=\"bin.base64\">\nYmFzZTY0\nIHRlc3Q=\n</binbase64_1>\n"
 518 "   <binbase64_2 dt:dt=\"bin.base64\">\nYmF\r\t z  ZTY0\nIHRlc3Q=\n</binbase64_2>\n"
 519 "</root>";
 520
 521 static const CHAR szBasicTransformSSXMLPart1[] =
 522 "<?xml version=\"1.0\"?>"
 523 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
 524 "<xsl:output method=\"html\"/>\n"
 525 "<xsl:template match=\"/\">"
 526 "<HTML><BODY><TABLE>"
 527 "        <xsl:apply-templates select='document(\"";
 528
 529 static const CHAR szBasicTransformSSXMLPart2[] =
 530 "\")/bottle/wine'>"
 531 "           <xsl:sort select=\"cost\"/><xsl:sort select=\"name\"/>"
 532 "        </xsl:apply-templates>"
 533 "</TABLE></BODY></HTML>"
 534 "</xsl:template>"
 535 "<xsl:template match=\"bottle\">"
 536 "   <TR><xsl:apply-templates select=\"name\" /><xsl:apply-templates select=\"cost\" /></TR>"
 537 "</xsl:template>"
 538 "<xsl:template match=\"name\">"
 539 "   <TD><xsl:apply-templates /></TD>"
 540 "</xsl:template>"
 541 "<xsl:template match=\"cost\">"
 542 "   <TD><xsl:apply-templates /></TD>"
 543 "</xsl:template>"
 544 "</xsl:stylesheet>";
 545
 546 static const CHAR szBasicTransformXML[] =
 547 "<?xml version=\"1.0\"?><bottle><wine><name>Wine</name><cost>$25.00</cost></wine></bottle>";
 548
 549 static const CHAR szBasicTransformOutput[] =
 550 "<HTML><BODY><TABLE><TD>Wine</TD><TD>$25.00</TD></TABLE></BODY></HTML>";
 551
 552 #define SZ_EMAIL_DTD \
 553 "<!DOCTYPE email ["\
 554 "   <!ELEMENT email         (recipients,from,reply-to?,subject,body,attachment*)>"\
 555 "       <!ATTLIST email attachments IDREFS #REQUIRED>"\
 556 "       <!ATTLIST email sent (yes|no) \"no\">"\
 557 "   <!ELEMENT recipients    (to+,cc*)>"\
 558 "   <!ELEMENT to            (#PCDATA)>"\
 559 "       <!ATTLIST to name CDATA #IMPLIED>"\
 560 "   <!ELEMENT cc            (#PCDATA)>"\
 561 "       <!ATTLIST cc name CDATA #IMPLIED>"\
 562 "   <!ELEMENT from          (#PCDATA)>"\
 563 "       <!ATTLIST from name CDATA #IMPLIED>"\
 564 "   <!ELEMENT reply-to      (#PCDATA)>"\
 565 "       <!ATTLIST reply-to name CDATA #IMPLIED>"\
 566 "   <!ELEMENT subject       ANY>"\
 567 "   <!ELEMENT body          ANY>"\
 568 "       <!ATTLIST body enc CDATA #FIXED \"UTF-8\">"\
 569 "   <!ELEMENT attachment    (#PCDATA)>"\
 570 "       <!ATTLIST attachment id ID #REQUIRED>"\
 571 "]>"
 572
 573 static const CHAR szEmailXML[] =
 574 "<?xml version=\"1.0\"?>"
 575 SZ_EMAIL_DTD
 576 "<email attachments=\"patch1\">"
 577 "   <recipients>"
 578 "       <to>wine-patches@winehq.org</to>"
 579 "   </recipients>"
 580 "   <from name=\"Anonymous\">user@localhost</from>"
 581 "   <subject>msxml3/tests: DTD validation (try 87)</subject>"
 582 "   <body>"
 583 "       It no longer causes spontaneous combustion..."
 584 "   </body>"
 585 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 586 "</email>";
 587
 588 static const CHAR szEmailXML_0D[] =
 589 "<?xml version=\"1.0\"?>"
 590 SZ_EMAIL_DTD
 591 "<email attachments=\"patch1\">"
 592 "   <recipients>"
 593 "       <to>wine-patches@winehq.org</to>"
 594 "   </recipients>"
 595 "   <from name=\"Anonymous\">user@localhost</from>"
 596 "   <subject>msxml3/tests: DTD validation (try 88)</subject>"
 597 "   <body>"
 598 "       <undecl />"
 599 "       XML_ELEMENT_UNDECLARED 0xC00CE00D"
 600 "   </body>"
 601 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 602 "</email>";
 603
 604 static const CHAR szEmailXML_0E[] =
 605 "<?xml version=\"1.0\"?>"
 606 SZ_EMAIL_DTD
 607 "<email attachments=\"patch1\">"
 608 "   <recipients>"
 609 "       <to>wine-patches@winehq.org</to>"
 610 "   </recipients>"
 611 "   <from name=\"Anonymous\">user@localhost</from>"
 612 "   <subject>msxml3/tests: DTD validation (try 89)</subject>"
 613 "   <body>"
 614 "       XML_ELEMENT_ID_NOT_FOUND 0xC00CE00E"
 615 "   </body>"
 616 "   <attachment id=\"patch\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 617 "</email>";
 618
 619 static const CHAR szEmailXML_11[] =
 620 "<?xml version=\"1.0\"?>"
 621 SZ_EMAIL_DTD
 622 "<email attachments=\"patch1\">"
 623 "   <recipients>"
 624 "   </recipients>"
 625 "   <from name=\"Anonymous\">user@localhost</from>"
 626 "   <subject>msxml3/tests: DTD validation (try 90)</subject>"
 627 "   <body>"
 628 "       XML_EMPTY_NOT_ALLOWED 0xC00CE011"
 629 "   </body>"
 630 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 631 "</email>";
 632
 633 static const CHAR szEmailXML_13[] =
 634 "<?xml version=\"1.0\"?>"
 635 SZ_EMAIL_DTD
 636 "<msg attachments=\"patch1\">"
 637 "   <recipients>"
 638 "       <to>wine-patches@winehq.org</to>"
 639 "   </recipients>"
 640 "   <from name=\"Anonymous\">user@localhost</from>"
 641 "   <subject>msxml3/tests: DTD validation (try 91)</subject>"
 642 "   <body>"
 643 "       XML_ROOT_NAME_MISMATCH 0xC00CE013"
 644 "   </body>"
 645 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 646 "</msg>";
 647
 648 static const CHAR szEmailXML_14[] =
 649 "<?xml version=\"1.0\"?>"
 650 SZ_EMAIL_DTD
 651 "<email attachments=\"patch1\">"
 652 "   <to>wine-patches@winehq.org</to>"
 653 "   <from name=\"Anonymous\">user@localhost</from>"
 654 "   <subject>msxml3/tests: DTD validation (try 92)</subject>"
 655 "   <body>"
 656 "       XML_INVALID_CONTENT 0xC00CE014"
 657 "   </body>"
 658 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 659 "</email>";
 660
 661 static const CHAR szEmailXML_15[] =
 662 "<?xml version=\"1.0\"?>"
 663 SZ_EMAIL_DTD
 664 "<email attachments=\"patch1\" ip=\"127.0.0.1\">"
 665 "   <recipients>"
 666 "       <to>wine-patches@winehq.org</to>"
 667 "   </recipients>"
 668 "   <from name=\"Anonymous\">user@localhost</from>"
 669 "   <subject>msxml3/tests: DTD validation (try 93)</subject>"
 670 "   <body>"
 671 "       XML_ATTRIBUTE_NOT_DEFINED 0xC00CE015"
 672 "   </body>"
 673 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 674 "</email>";
 675
 676 static const CHAR szEmailXML_16[] =
 677 "<?xml version=\"1.0\"?>"
 678 SZ_EMAIL_DTD
 679 "<email attachments=\"patch1\">"
 680 "   <recipients>"
 681 "       <to>wine-patches@winehq.org</to>"
 682 "   </recipients>"
 683 "   <from name=\"Anonymous\">user@localhost</from>"
 684 "   <subject>msxml3/tests: DTD validation (try 94)</subject>"
 685 "   <body enc=\"ASCII\">"
 686 "       XML_ATTRIBUTE_FIXED 0xC00CE016"
 687 "   </body>"
 688 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 689 "</email>";
 690
 691 static const CHAR szEmailXML_17[] =
 692 "<?xml version=\"1.0\"?>"
 693 SZ_EMAIL_DTD
 694 "<email attachments=\"patch1\" sent=\"true\">"
 695 "   <recipients>"
 696 "       <to>wine-patches@winehq.org</to>"
 697 "   </recipients>"
 698 "   <from name=\"Anonymous\">user@localhost</from>"
 699 "   <subject>msxml3/tests: DTD validation (try 95)</subject>"
 700 "   <body>"
 701 "       XML_ATTRIBUTE_VALUE 0xC00CE017"
 702 "   </body>"
 703 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 704 "</email>";
 705
 706 static const CHAR szEmailXML_18[] =
 707 "<?xml version=\"1.0\"?>"
 708 SZ_EMAIL_DTD
 709 "<email attachments=\"patch1\">"
 710 "   oops"
 711 "   <recipients>"
 712 "       <to>wine-patches@winehq.org</to>"
 713 "   </recipients>"
 714 "   <from name=\"Anonymous\">user@localhost</from>"
 715 "   <subject>msxml3/tests: DTD validation (try 96)</subject>"
 716 "   <body>"
 717 "       XML_ILLEGAL_TEXT 0xC00CE018"
 718 "   </body>"
 719 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 720 "</email>";
 721
 722 static const CHAR szEmailXML_20[] =
 723 "<?xml version=\"1.0\"?>"
 724 SZ_EMAIL_DTD
 725 "<email>"
 726 "   <recipients>"
 727 "       <to>wine-patches@winehq.org</to>"
 728 "   </recipients>"
 729 "   <from name=\"Anonymous\">user@localhost</from>"
 730 "   <subject>msxml3/tests: DTD validation (try 97)</subject>"
 731 "   <body>"
 732 "       XML_REQUIRED_ATTRIBUTE_MISSING 0xC00CE020"
 733 "   </body>"
 734 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 735 "</email>";
 736
 737 static const char xpath_simple_list[] =
 738 "<?xml version=\"1.0\"?>"
 739 "<root>"
 740 "   <a attr1=\"1\" attr2=\"2\" />"
 741 "   <b/>"
 742 "   <c/>"
 743 "   <d/>"
 744 "</root>";
 745
 746 static const char default_ns_doc[] = {
 747     "<?xml version=\"1.0\"?>"
 748     "<a xmlns:ns=\"nshref\" xml:lang=\"ru\" ns:b=\"b attr\" xml:c=\"c attr\" "
 749     "    d=\"d attr\" />"
 750 };
 751
 752 static const char attributes_map[] = {
 753     "<?xml version=\"1.0\"?>"
 754     "<a attr1=\"value1\" attr2=\"value2\" attr3=\"value3\" attr4=\"value4\" />"
 755 };
 756
 757 static const WCHAR nonexistent_fileW[] = {
 758     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
 759 };
 760 static const WCHAR nonexistent_attrW[] = {
 761     'n','o','n','E','x','i','s','i','t','i','n','g','A','t','t','r','i','b','u','t','e',0
 762 };
 763 static const WCHAR szDocument[] = {
 764     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
 765 };
 766
 767 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
 768 static WCHAR szdl[] = { 'd','l',0 };
 769 static const WCHAR szvr[] = { 'v','r',0 };
 770 static const WCHAR szlc[] = { 'l','c',0 };
 771 static WCHAR szbs[] = { 'b','s',0 };
 772 static const WCHAR szstr1[] = { 's','t','r','1',0 };
 773 static const WCHAR szstr2[] = { 's','t','r','2',0 };
 774 static const WCHAR szstar[] = { '*',0 };
 775 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
 776
 777 static WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
 778 static WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
 779 static WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
 780
 781 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
 782 static WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
 783 static WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
 784 static WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 785                                 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
 786 static WCHAR szElementXML4[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 787                                 '&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 };
 788
 789 static WCHAR szAttribute[] = {'A','t','t','r',0 };
 790 static WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
 791
 792 static WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
 793                           ' ','n','o','t',' ','r','i','g','h','t','!', 0};
 794 static WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
 795                              'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
 796                              '!',']',']','>',0};
 797 static WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
 798 static WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
 799
 800 static WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
 801 static WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
 802 static WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0};
 803
 804 #define expect_bstr_eq_and_free(bstr, expect) { \
 805     BSTR bstrExp = alloc_str_from_narrow(expect); \
 806     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
 807     SysFreeString(bstr); \
 808     SysFreeString(bstrExp); \
 809 }
 810
 811 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
 812
 813 #define ole_check(expr) { \
 814     HRESULT r = expr; \
 815     ok(r == S_OK, #expr " returned %x\n", r); \
 816 }
 817
 818 #define ole_expect(expr, expect) { \
 819     HRESULT r = expr; \
 820     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
 821 }
 822
 823 #define double_eq(x, y) ok((x)-(y)<=1e-14*(x) && (x)-(y)>=-1e-14*(x), "expected %.16g, got %.16g\n", x, y)
 824
 825 static void* _create_object(const GUID *clsid, const char *name, const IID *iid, int line)
 826 {
 827     void *obj = NULL;
 828     HRESULT hr;
 829
 830     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
 831     if (hr != S_OK)
 832         win_skip_(__FILE__,line)("failed to create %s instance: 0x%08x\n", name, hr);
 833
 834     return obj;
 835 }
 836
 837 #define _create(cls) cls, #cls
 838
 839 #define create_document(iid) _create_object(&_create(CLSID_DOMDocument2), iid, __LINE__)
 840 #define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
 841 #define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
 842 #define create_cache_version(v, iid) _create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)
 843 #define create_xsltemplate(iid) _create_object(&_create(CLSID_XSLTemplate), iid, __LINE__)
 844
 845 static BSTR alloc_str_from_narrow(const char *str)
 846 {
 847     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 848     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
 849     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 850     return ret;
 851 }
 852
 853 static BSTR alloced_bstrs[256];
 854 static int alloced_bstrs_count;
 855
 856 static BSTR _bstr_(const char *str)
 857 {
 858     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
 859     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
 860     return alloced_bstrs[alloced_bstrs_count++];
 861 }
 862
 863 static void free_bstrs(void)
 864 {
 865     int i;
 866     for (i = 0; i < alloced_bstrs_count; i++)
 867         SysFreeString(alloced_bstrs[i]);
 868     alloced_bstrs_count = 0;
 869 }
 870
 871 static VARIANT _variantbstr_(const char *str)
 872 {
 873     VARIANT v;
 874     V_VT(&v) = VT_BSTR;
 875     V_BSTR(&v) = _bstr_(str);
 876     return v;
 877 }
 878
 879 static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
 880 {
 881     for (;;)
 882     {
 883         while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
 884         while (*sRight == '\r' || *sRight == '\n') sRight++;
 885         if (*sLeft != *sRight) return FALSE;
 886         if (!*sLeft) return TRUE;
 887         sLeft++;
 888         sRight++;
 889     }
 890 }
 891
 892 static void get_str_for_type(DOMNodeType type, char *buf)
 893 {
 894     switch (type)
 895     {
 896         case NODE_ATTRIBUTE:
 897             strcpy(buf, "A");
 898             break;
 899         case NODE_ELEMENT:
 900             strcpy(buf, "E");
 901             break;
 902         case NODE_DOCUMENT:
 903             strcpy(buf, "D");
 904             break;
 905         case NODE_TEXT:
 906             strcpy(buf, "T");
 907             break;
 908         case NODE_COMMENT:
 909             strcpy(buf, "C");
 910             break;
 911         case NODE_PROCESSING_INSTRUCTION:
 912             strcpy(buf, "P");
 913             break;
 914         default:
 915             wsprintfA(buf, "[%d]", type);
 916     }
 917 }
 918
 919 static int get_node_position(IXMLDOMNode *node)
 920 {
 921     HRESULT r;
 922     int pos = 0;
 923
 924     IXMLDOMNode_AddRef(node);
 925     do
 926     {
 927         IXMLDOMNode *new_node;
 928
 929         pos++;
 930         r = IXMLDOMNode_get_previousSibling(node, &new_node);
 931         ok(SUCCEEDED(r), "get_previousSibling failed\n");
 932         IXMLDOMNode_Release(node);
 933         node = new_node;
 934     } while (r == S_OK);
 935     return pos;
 936 }
 937
 938 static void node_to_string(IXMLDOMNode *node, char *buf)
 939 {
 940     HRESULT r = S_OK;
 941     DOMNodeType type;
 942
 943     if (node == NULL)
 944     {
 945         lstrcpyA(buf, "(null)");
 946         return;
 947     }
 948
 949     IXMLDOMNode_AddRef(node);
 950     while (r == S_OK)
 951     {
 952         IXMLDOMNode *new_node;
 953
 954         ole_check(IXMLDOMNode_get_nodeType(node, &type));
 955         get_str_for_type(type, buf);
 956         buf+=strlen(buf);
 957
 958         if (type == NODE_ATTRIBUTE)
 959         {
 960             BSTR bstr;
 961             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
 962             *(buf++) = '\'';
 963             wsprintfA(buf, "%ws", bstr);
 964             buf += strlen(buf);
 965             *(buf++) = '\'';
 966             SysFreeString(bstr);
 967
 968             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
 969         }
 970         else
 971         {
 972             r = IXMLDOMNode_get_parentNode(node, &new_node);
 973             wsprintf(buf, "%d", get_node_position(node));
 974             buf += strlen(buf);
 975         }
 976
 977         ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
 978         IXMLDOMNode_Release(node);
 979         node = new_node;
 980         if (r == S_OK)
 981             *(buf++) = '.';
 982     }
 983
 984     *buf = 0;
 985 }
 986
 987 static char *list_to_string(IXMLDOMNodeList *list)
 988 {
 989     static char buf[4096];
 990     char *pos = buf;
 991     LONG len = 0;
 992     int i;
 993
 994     if (list == NULL)
 995     {
 996         lstrcpyA(buf, "(null)");
 997         return buf;
 998     }
 999     ole_check(IXMLDOMNodeList_get_length(list, &len));
1000     for (i = 0; i < len; i++)
1001     {
1002         IXMLDOMNode *node;
1003         if (i > 0)
1004             *(pos++) = ' ';
1005         ole_check(IXMLDOMNodeList_nextNode(list, &node));
1006         node_to_string(node, pos);
1007         pos += strlen(pos);
1008         IXMLDOMNode_Release(node);
1009     }
1010     *pos = 0;
1011     return buf;
1012 }
1013
1014 #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); }
1015 #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); }
1016
1017 struct docload_ret_t {
1018     VARIANT_BOOL b;
1019     HRESULT hr;
1020 };
1021
1022 struct leading_spaces_t {
1023     const CLSID *clsid;
1024     const char *name;
1025     struct docload_ret_t ret[2]; /* 0 - ::load(), 1 - ::loadXML() */
1026 };
1027
1028 static const struct leading_spaces_t leading_spaces_classdata[] = {
1029     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
1030     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1031     { &CLSID_DOMDocument26, "CLSID_DOMDocument26", {{VARIANT_FALSE, S_FALSE }, {VARIANT_TRUE,  S_OK } }},
1032     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1033     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1034     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", {{VARIANT_FALSE, S_FALSE }, {VARIANT_FALSE, S_FALSE } }},
1035     { NULL }
1036 };
1037
1038 static const char* leading_spaces_xmldata[] = {
1039     "\n<?xml version=\"1.0\" encoding=\"UTF-16\" ?><root/>",
1040     " <?xml version=\"1.0\"?><root/>",
1041     "\n<?xml version=\"1.0\"?><root/>",
1042     "\t<?xml version=\"1.0\"?><root/>",
1043     "\r\n<?xml version=\"1.0\"?><root/>",
1044     "\r<?xml version=\"1.0\"?><root/>",
1045     "\r\r\r\r\t\t \n\n <?xml version=\"1.0\"?><root/>",
1046     0
1047 };
1048
1049 static void test_domdoc( void )
1050 {
1051     HRESULT r, hr;
1052     IXMLDOMDocument *doc;
1053     IXMLDOMParseError *error;
1054     IXMLDOMElement *element = NULL;
1055     IXMLDOMNode *node;
1056     IXMLDOMText *nodetext = NULL;
1057     IXMLDOMComment *node_comment = NULL;
1058     IXMLDOMAttribute *node_attr = NULL;
1059     IXMLDOMNode *nodeChild = NULL;
1060     IXMLDOMProcessingInstruction *nodePI = NULL;
1061     const struct leading_spaces_t *class_ptr;
1062     const char **data_ptr;
1063     VARIANT_BOOL b;
1064     VARIANT var;
1065     BSTR str;
1066     LONG code, ref;
1067     LONG nLength = 0;
1068     WCHAR buff[100];
1069     char path[MAX_PATH];
1070     int index;
1071
1072     GetTempPathA(MAX_PATH, path);
1073     strcat(path, "leading_spaces.xml");
1074
1075     /* Load document with leading spaces
1076      *
1077      * Test all CLSIDs with all test data XML strings
1078      */
1079     class_ptr = leading_spaces_classdata;
1080     index = 0;
1081     while (class_ptr->clsid)
1082     {
1083         HRESULT hr;
1084         int i;
1085
1086         hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
1087              &IID_IXMLDOMDocument, (void**)&doc);
1088         if (hr != S_OK) {
1089             win_skip("%d: failed to create class instance for %s\n", index, class_ptr->name);
1090             class_ptr++;
1091             index++;
1092             continue;
1093         }
1094
1095         data_ptr = leading_spaces_xmldata;
1096         i = 0;
1097         while (*data_ptr) {
1098             BSTR data = _bstr_(*data_ptr);
1099             DWORD written;
1100             HANDLE file;
1101
1102             file = CreateFileA(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
1103             ok(file != INVALID_HANDLE_VALUE, "can't create file %s: %u\n", path, GetLastError());
1104
1105             WriteFile(file, data, lstrlenW(data)*sizeof(WCHAR), &written, NULL);
1106             CloseHandle(file);
1107
1108             b = 0xc;
1109             V_VT(&var) = VT_BSTR;
1110             V_BSTR(&var) = _bstr_(path);
1111             hr = IXMLDOMDocument_load(doc, var, &b);
1112         todo_wine {
1113             EXPECT_HR(hr, class_ptr->ret[0].hr);
1114             ok(b == class_ptr->ret[0].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[0].b);
1115         }
1116             DeleteFileA(path);
1117
1118             b = 0xc;
1119             hr = IXMLDOMDocument_loadXML(doc, data, &b);
1120             EXPECT_HR(hr, class_ptr->ret[1].hr);
1121             ok(b == class_ptr->ret[1].b, "%d:%d, got %d, expected %d\n", index, i, b, class_ptr->ret[1].b);
1122
1123             data_ptr++;
1124             i++;
1125         }
1126
1127         class_ptr++;
1128         index++;
1129         free_bstrs();
1130     }
1131
1132     doc = create_document(&IID_IXMLDOMDocument);
1133     if (!doc) return;
1134
1135 if (0)
1136 {
1137     /* crashes on native */
1138     IXMLDOMDocument_loadXML( doc, (BSTR)0x1, NULL );
1139 }
1140
1141     /* try some stupid things */
1142     hr = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1143     EXPECT_HR(hr, S_FALSE);
1144
1145     b = VARIANT_TRUE;
1146     hr = IXMLDOMDocument_loadXML( doc, NULL, &b );
1147     EXPECT_HR(hr, S_FALSE);
1148     ok( b == VARIANT_FALSE, "failed to load XML string\n");
1149
1150     /* try to load a document from a nonexistent file */
1151     b = VARIANT_TRUE;
1152     str = SysAllocString( nonexistent_fileW );
1153     VariantInit(&var);
1154     V_VT(&var) = VT_BSTR;
1155     V_BSTR(&var) = str;
1156
1157     r = IXMLDOMDocument_load( doc, var, &b);
1158     ok( r == S_FALSE, "loadXML succeeded\n");
1159     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1160     SysFreeString( str );
1161
1162     /* try load an empty document */
1163     b = VARIANT_TRUE;
1164     str = SysAllocString( szEmpty );
1165     r = IXMLDOMDocument_loadXML( doc, str, &b );
1166     ok( r == S_FALSE, "loadXML succeeded\n");
1167     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1168     SysFreeString( str );
1169
1170     r = IXMLDOMDocument_get_async( doc, &b );
1171     ok( r == S_OK, "get_async failed (%08x)\n", r);
1172     ok( b == VARIANT_TRUE, "Wrong default value\n");
1173
1174     /* check that there's no document element */
1175     element = NULL;
1176     r = IXMLDOMDocument_get_documentElement( doc, &element );
1177     ok( r == S_FALSE, "should be no document element\n");
1178
1179     /* try finding a node */
1180     node = NULL;
1181     str = SysAllocString( szstr1 );
1182     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
1183     ok( r == S_FALSE, "ret %08x\n", r );
1184     SysFreeString( str );
1185
1186     b = VARIANT_TRUE;
1187     str = SysAllocString( szIncomplete );
1188     r = IXMLDOMDocument_loadXML( doc, str, &b );
1189     ok( r == S_FALSE, "loadXML succeeded\n");
1190     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1191     SysFreeString( str );
1192
1193     /* check that there's no document element */
1194     element = (IXMLDOMElement*)1;
1195     r = IXMLDOMDocument_get_documentElement( doc, &element );
1196     ok( r == S_FALSE, "should be no document element\n");
1197     ok( element == NULL, "Element should be NULL\n");
1198
1199     /* test for BSTR handling, pass broken BSTR */
1200     memcpy(&buff[2], szComplete1, sizeof(szComplete1));
1201     /* just a big length */
1202     *(DWORD*)buff = 0xf0f0;
1203     b = VARIANT_FALSE;
1204     r = IXMLDOMDocument_loadXML( doc, &buff[2], &b );
1205     ok( r == S_OK, "loadXML failed\n");
1206     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1207
1208     /* loadXML ignores the encoding attribute and always expects Unicode */
1209     b = VARIANT_FALSE;
1210     str = SysAllocString( szComplete6 );
1211     r = IXMLDOMDocument_loadXML( doc, str, &b );
1212     ok( r == S_OK, "loadXML failed\n");
1213     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1214     SysFreeString( str );
1215
1216     /* try a BSTR containing a Windows-1252 document */
1217     b = VARIANT_TRUE;
1218     str = SysAllocStringByteLen( win1252xml, strlen(win1252xml) );
1219     r = IXMLDOMDocument_loadXML( doc, str, &b );
1220     ok( r == S_FALSE, "loadXML succeeded\n");
1221     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1222     SysFreeString( str );
1223
1224     /* try to load something valid */
1225     b = VARIANT_FALSE;
1226     str = SysAllocString( szComplete1 );
1227     r = IXMLDOMDocument_loadXML( doc, str, &b );
1228     ok( r == S_OK, "loadXML failed\n");
1229     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1230     SysFreeString( str );
1231
1232     /* check if nodename is correct */
1233     r = IXMLDOMDocument_get_nodeName( doc, NULL );
1234     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1235
1236     str = (BSTR)0xdeadbeef;
1237     r = IXMLDOMDocument_get_baseName( doc, &str );
1238     ok ( r == S_FALSE, "got 0x%08x\n", r);
1239     ok (str == NULL, "got %p\n", str);
1240
1241     /* content doesn't matter here */
1242     str = NULL;
1243     r = IXMLDOMDocument_get_nodeName( doc, &str );
1244     ok ( r == S_OK, "get_nodeName wrong code\n");
1245     ok ( str != NULL, "str is null\n");
1246     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
1247     SysFreeString( str );
1248
1249     /* test put_text */
1250     r = IXMLDOMDocument_put_text( doc, _bstr_("Should Fail") );
1251     ok( r == E_FAIL, "ret %08x\n", r );
1252
1253     /* check that there's a document element */
1254     element = NULL;
1255     r = IXMLDOMDocument_get_documentElement( doc, &element );
1256     ok( r == S_OK, "should be a document element\n");
1257     if( element )
1258     {
1259         IObjectIdentity *ident;
1260
1261         r = IXMLDOMElement_QueryInterface( element, &IID_IObjectIdentity, (void**)&ident );
1262         ok( r == E_NOINTERFACE, "ret %08x\n", r);
1263
1264         IXMLDOMElement_Release( element );
1265         element = NULL;
1266     }
1267
1268     /* as soon as we call loadXML again, the document element will disappear */
1269     b = 2;
1270     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1271     ok( r == S_FALSE, "loadXML failed\n");
1272     ok( b == 2, "variant modified\n");
1273     r = IXMLDOMDocument_get_documentElement( doc, &element );
1274     ok( r == S_FALSE, "should be no document element\n");
1275
1276     /* try to load something else simple and valid */
1277     b = VARIANT_FALSE;
1278     str = SysAllocString( szComplete3 );
1279     r = IXMLDOMDocument_loadXML( doc, str, &b );
1280     ok( r == S_OK, "loadXML failed\n");
1281     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1282     SysFreeString( str );
1283
1284     /* try something a little more complicated */
1285     b = FALSE;
1286     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
1287     ok( r == S_OK, "loadXML failed\n");
1288     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1289
1290     r = IXMLDOMDocument_get_parseError( doc, &error );
1291     ok( r == S_OK, "returns %08x\n", r );
1292
1293     r = IXMLDOMParseError_get_errorCode( error, &code );
1294     ok( r == S_FALSE, "returns %08x\n", r );
1295     ok( code == 0, "code %d\n", code );
1296     IXMLDOMParseError_Release( error );
1297
1298     /* test createTextNode */
1299     r = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &nodetext);
1300     ok( r == S_OK, "returns %08x\n", r );
1301     IXMLDOMText_Release(nodetext);
1302
1303     str = SysAllocString( szOpen );
1304     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
1305     ok( r == E_INVALIDARG, "returns %08x\n", r );
1306     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
1307     ok( r == S_OK, "returns %08x\n", r );
1308     SysFreeString( str );
1309     if(nodetext)
1310     {
1311         r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (void**)&element);
1312         ok(r == E_NOINTERFACE, "ret %08x\n", r );
1313
1314         /* Text Last Child Checks */
1315         r = IXMLDOMText_get_lastChild(nodetext, NULL);
1316         ok(r == E_INVALIDARG, "ret %08x\n", r );
1317
1318         nodeChild = (IXMLDOMNode*)0x1;
1319         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
1320         ok(r == S_FALSE, "ret %08x\n", r );
1321         ok(nodeChild == NULL, "nodeChild not NULL\n");
1322
1323         /* test length property */
1324         r = IXMLDOMText_get_length(nodetext, NULL);
1325         ok(r == E_INVALIDARG, "ret %08x\n", r );
1326
1327         r = IXMLDOMText_get_length(nodetext, &nLength);
1328         ok(r == S_OK, "ret %08x\n", r );
1329         ok(nLength == 4, "expected 4 got %d\n", nLength);
1330
1331         /* put data Tests */
1332         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
1333         ok(r == S_OK, "ret %08x\n", r );
1334
1335         /* get data Tests */
1336         r = IXMLDOMText_get_data(nodetext, &str);
1337         ok(r == S_OK, "ret %08x\n", r );
1338         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
1339         SysFreeString(str);
1340
1341         /* Confirm XML text is good */
1342         r = IXMLDOMText_get_xml(nodetext, &str);
1343         ok(r == S_OK, "ret %08x\n", r );
1344         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
1345         SysFreeString(str);
1346
1347         /* Confirm we get the put_data Text back */
1348         r = IXMLDOMText_get_text(nodetext, &str);
1349         ok(r == S_OK, "ret %08x\n", r );
1350         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
1351         SysFreeString(str);
1352
1353         /* test substringData */
1354         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
1355         ok(r == E_INVALIDARG, "ret %08x\n", r );
1356
1357         /* test substringData - Invalid offset */
1358         str = (BSTR)&szElement;
1359         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
1360         ok(r == E_INVALIDARG, "ret %08x\n", r );
1361         ok( str == NULL, "incorrect string\n");
1362
1363         /* test substringData - Invalid offset */
1364         str = (BSTR)&szElement;
1365         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
1366         ok(r == S_FALSE, "ret %08x\n", r );
1367         ok( str == NULL, "incorrect string\n");
1368
1369         /* test substringData - Invalid size */
1370         str = (BSTR)&szElement;
1371         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
1372         ok(r == E_INVALIDARG, "ret %08x\n", r );
1373         ok( str == NULL, "incorrect string\n");
1374
1375         /* test substringData - Invalid size */
1376         str = (BSTR)&szElement;
1377         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
1378         ok(r == S_FALSE, "ret %08x\n", r );
1379         ok( str == NULL, "incorrect string\n");
1380
1381         /* test substringData - Start of string */
1382         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
1383         ok(r == S_OK, "ret %08x\n", r );
1384         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
1385         SysFreeString(str);
1386
1387         /* test substringData - Middle of string */
1388         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
1389         ok(r == S_OK, "ret %08x\n", r );
1390         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
1391         SysFreeString(str);
1392
1393         /* test substringData - End of string */
1394         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
1395         ok(r == S_OK, "ret %08x\n", r );
1396         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
1397         SysFreeString(str);
1398
1399         /* test appendData */
1400         r = IXMLDOMText_appendData(nodetext, NULL);
1401         ok(r == S_OK, "ret %08x\n", r );
1402
1403         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
1404         ok(r == S_OK, "ret %08x\n", r );
1405
1406         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
1407         ok(r == S_OK, "ret %08x\n", r );
1408
1409         r = IXMLDOMText_get_text(nodetext, &str);
1410         ok(r == S_OK, "ret %08x\n", r );
1411         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1412         SysFreeString(str);
1413
1414         /* test insertData */
1415         str = SysAllocStringLen(NULL, 0);
1416         r = IXMLDOMText_insertData(nodetext, -1, str);
1417         ok(r == S_OK, "ret %08x\n", r );
1418
1419         r = IXMLDOMText_insertData(nodetext, -1, NULL);
1420         ok(r == S_OK, "ret %08x\n", r );
1421
1422         r = IXMLDOMText_insertData(nodetext, 1000, str);
1423         ok(r == S_OK, "ret %08x\n", r );
1424
1425         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
1426         ok(r == S_OK, "ret %08x\n", r );
1427
1428         r = IXMLDOMText_insertData(nodetext, 0, NULL);
1429         ok(r == S_OK, "ret %08x\n", r );
1430
1431         r = IXMLDOMText_insertData(nodetext, 0, str);
1432         ok(r == S_OK, "ret %08x\n", r );
1433         SysFreeString(str);
1434
1435         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
1436         ok(r == E_INVALIDARG, "ret %08x\n", r );
1437
1438         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
1439         ok(r == E_INVALIDARG, "ret %08x\n", r );
1440
1441         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
1442         ok(r == S_OK, "ret %08x\n", r );
1443
1444         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
1445         ok(r == S_OK, "ret %08x\n", r );
1446
1447         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
1448         ok(r == S_OK, "ret %08x\n", r );
1449
1450         r = IXMLDOMText_get_text(nodetext, &str);
1451         ok(r == S_OK, "ret %08x\n", r );
1452         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1453         SysFreeString(str);
1454
1455         /* delete data */
1456         /* invalid arguments */
1457         r = IXMLDOMText_deleteData(nodetext, -1, 1);
1458         ok(r == E_INVALIDARG, "ret %08x\n", r );
1459
1460         r = IXMLDOMText_deleteData(nodetext, 0, 0);
1461         ok(r == S_OK, "ret %08x\n", r );
1462
1463         r = IXMLDOMText_deleteData(nodetext, 0, -1);
1464         ok(r == E_INVALIDARG, "ret %08x\n", r );
1465
1466         r = IXMLDOMText_get_length(nodetext, &nLength);
1467         ok(r == S_OK, "ret %08x\n", r );
1468         ok(nLength == 43, "expected 43 got %d\n", nLength);
1469
1470         r = IXMLDOMText_deleteData(nodetext, nLength, 1);
1471         ok(r == S_OK, "ret %08x\n", r );
1472
1473         r = IXMLDOMText_deleteData(nodetext, nLength+1, 1);
1474         ok(r == E_INVALIDARG, "ret %08x\n", r );
1475
1476         /* delete from start */
1477         r = IXMLDOMText_deleteData(nodetext, 0, 5);
1478         ok(r == S_OK, "ret %08x\n", r );
1479
1480         r = IXMLDOMText_get_length(nodetext, &nLength);
1481         ok(r == S_OK, "ret %08x\n", r );
1482         ok(nLength == 38, "expected 38 got %d\n", nLength);
1483
1484         r = IXMLDOMText_get_text(nodetext, &str);
1485         ok(r == S_OK, "ret %08x\n", r );
1486         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1487         SysFreeString(str);
1488
1489         /* delete from end */
1490         r = IXMLDOMText_deleteData(nodetext, 35, 3);
1491         ok(r == S_OK, "ret %08x\n", r );
1492
1493         r = IXMLDOMText_get_length(nodetext, &nLength);
1494         ok(r == S_OK, "ret %08x\n", r );
1495         ok(nLength == 35, "expected 35 got %d\n", nLength);
1496
1497         r = IXMLDOMText_get_text(nodetext, &str);
1498         ok(r == S_OK, "ret %08x\n", r );
1499         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1500         SysFreeString(str);
1501
1502         /* delete from inside */
1503         r = IXMLDOMText_deleteData(nodetext, 1, 33);
1504         ok(r == S_OK, "ret %08x\n", r );
1505
1506         r = IXMLDOMText_get_length(nodetext, &nLength);
1507         ok(r == S_OK, "ret %08x\n", r );
1508         ok(nLength == 2, "expected 2 got %d\n", nLength);
1509
1510         r = IXMLDOMText_get_text(nodetext, &str);
1511         ok(r == S_OK, "ret %08x\n", r );
1512         ok( !lstrcmpW( str, _bstr_("") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1513         SysFreeString(str);
1514
1515         /* delete whole data ... */
1516         r = IXMLDOMText_get_length(nodetext, &nLength);
1517         ok(r == S_OK, "ret %08x\n", r );
1518
1519         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1520         ok(r == S_OK, "ret %08x\n", r );
1521         /* ... and try again with empty string */
1522         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1523         ok(r == S_OK, "ret %08x\n", r );
1524
1525         /* test put_data */
1526         V_VT(&var) = VT_BSTR;
1527         V_BSTR(&var) = SysAllocString(szstr1);
1528         r = IXMLDOMText_put_nodeValue(nodetext, var);
1529         ok(r == S_OK, "ret %08x\n", r );
1530         VariantClear(&var);
1531
1532         r = IXMLDOMText_get_text(nodetext, &str);
1533         ok(r == S_OK, "ret %08x\n", r );
1534         ok( !lstrcmpW( str, szstr1 ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1535         SysFreeString(str);
1536
1537         /* test put_data */
1538         V_VT(&var) = VT_I4;
1539         V_I4(&var) = 99;
1540         r = IXMLDOMText_put_nodeValue(nodetext, var);
1541         ok(r == S_OK, "ret %08x\n", r );
1542         VariantClear(&var);
1543
1544         r = IXMLDOMText_get_text(nodetext, &str);
1545         ok(r == S_OK, "ret %08x\n", r );
1546         ok( !lstrcmpW( str, _bstr_("99") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1547         SysFreeString(str);
1548
1549         /* ::replaceData() */
1550         V_VT(&var) = VT_BSTR;
1551         V_BSTR(&var) = SysAllocString(szstr1);
1552         r = IXMLDOMText_put_nodeValue(nodetext, var);
1553         ok(r == S_OK, "ret %08x\n", r );
1554         VariantClear(&var);
1555
1556         r = IXMLDOMText_replaceData(nodetext, 6, 0, NULL);
1557         ok(r == E_INVALIDARG, "ret %08x\n", r );
1558         r = IXMLDOMText_get_text(nodetext, &str);
1559         ok(r == S_OK, "ret %08x\n", r );
1560         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1561         SysFreeString(str);
1562
1563         r = IXMLDOMText_replaceData(nodetext, 0, 0, NULL);
1564         ok(r == S_OK, "ret %08x\n", r );
1565         r = IXMLDOMText_get_text(nodetext, &str);
1566         ok(r == S_OK, "ret %08x\n", r );
1567         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1568         SysFreeString(str);
1569
1570         /* NULL pointer means delete */
1571         r = IXMLDOMText_replaceData(nodetext, 0, 1, NULL);
1572         ok(r == S_OK, "ret %08x\n", r );
1573         r = IXMLDOMText_get_text(nodetext, &str);
1574         ok(r == S_OK, "ret %08x\n", r );
1575         ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1576         SysFreeString(str);
1577
1578         /* empty string means delete */
1579         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_(""));
1580         ok(r == S_OK, "ret %08x\n", r );
1581         r = IXMLDOMText_get_text(nodetext, &str);
1582         ok(r == S_OK, "ret %08x\n", r );
1583         ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1584         SysFreeString(str);
1585
1586         /* zero count means insert */
1587         r = IXMLDOMText_replaceData(nodetext, 0, 0, _bstr_("a"));
1588         ok(r == S_OK, "ret %08x\n", r );
1589         r = IXMLDOMText_get_text(nodetext, &str);
1590         ok(r == S_OK, "ret %08x\n", r );
1591         ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1592         SysFreeString(str);
1593
1594         r = IXMLDOMText_replaceData(nodetext, 0, 2, NULL);
1595         ok(r == S_OK, "ret %08x\n", r );
1596
1597         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("m"));
1598         ok(r == S_OK, "ret %08x\n", r );
1599         r = IXMLDOMText_get_text(nodetext, &str);
1600         ok(r == S_OK, "ret %08x\n", r );
1601         ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1602         SysFreeString(str);
1603
1604         /* nonempty string, count greater than its length */
1605         r = IXMLDOMText_replaceData(nodetext, 0, 2, _bstr_("a1.2"));
1606         ok(r == S_OK, "ret %08x\n", r );
1607         r = IXMLDOMText_get_text(nodetext, &str);
1608         ok(r == S_OK, "ret %08x\n", r );
1609         ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1610         SysFreeString(str);
1611
1612         /* nonempty string, count less than its length */
1613         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_("wine"));
1614         ok(r == S_OK, "ret %08x\n", r );
1615         r = IXMLDOMText_get_text(nodetext, &str);
1616         ok(r == S_OK, "ret %08x\n", r );
1617         ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1618         SysFreeString(str);
1619
1620         IXMLDOMText_Release( nodetext );
1621     }
1622
1623     /* test Create Comment */
1624     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
1625     ok( r == E_INVALIDARG, "returns %08x\n", r );
1626     node_comment = (IXMLDOMComment*)0x1;
1627
1628     /* empty comment */
1629     r = IXMLDOMDocument_createComment(doc, _bstr_(""), &node_comment);
1630     ok( r == S_OK, "returns %08x\n", r );
1631     str = (BSTR)0x1;
1632     r = IXMLDOMComment_get_data(node_comment, &str);
1633     ok( r == S_OK, "returns %08x\n", r );
1634     ok( str && SysStringLen(str) == 0, "expected empty string data\n");
1635     IXMLDOMComment_Release(node_comment);
1636     SysFreeString(str);
1637
1638     r = IXMLDOMDocument_createComment(doc, NULL, &node_comment);
1639     ok( r == S_OK, "returns %08x\n", r );
1640     str = (BSTR)0x1;
1641     r = IXMLDOMComment_get_data(node_comment, &str);
1642     ok( r == S_OK, "returns %08x\n", r );
1643     ok( str && (SysStringLen(str) == 0), "expected empty string data\n");
1644     IXMLDOMComment_Release(node_comment);
1645     SysFreeString(str);
1646
1647     str = SysAllocString(szComment);
1648     r = IXMLDOMDocument_createComment(doc, str, &node_comment);
1649     SysFreeString(str);
1650     ok( r == S_OK, "returns %08x\n", r );
1651     if(node_comment)
1652     {
1653         /* Last Child Checks */
1654         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
1655         ok(r == E_INVALIDARG, "ret %08x\n", r );
1656
1657         nodeChild = (IXMLDOMNode*)0x1;
1658         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
1659         ok(r == S_FALSE, "ret %08x\n", r );
1660         ok(nodeChild == NULL, "pLastChild not NULL\n");
1661
1662         /* baseName */
1663         str = (BSTR)0xdeadbeef;
1664         r = IXMLDOMComment_get_baseName(node_comment, &str);
1665         ok(r == S_FALSE, "ret %08x\n", r );
1666         ok(str == NULL, "Expected NULL\n");
1667
1668         IXMLDOMComment_Release( node_comment );
1669     }
1670
1671     /* test Create Attribute */
1672     str = SysAllocString(szAttribute);
1673     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
1674     ok( r == E_INVALIDARG, "returns %08x\n", r );
1675     r = IXMLDOMDocument_createAttribute(doc, str, &node_attr);
1676     ok( r == S_OK, "returns %08x\n", r );
1677     IXMLDOMAttribute_Release( node_attr);
1678     SysFreeString(str);
1679
1680     /* test Processing Instruction */
1681     str = SysAllocStringLen(NULL, 0);
1682     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
1683     ok( r == E_INVALIDARG, "returns %08x\n", r );
1684     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
1685     ok( r == E_FAIL, "returns %08x\n", r );
1686     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
1687     ok( r == E_FAIL, "returns %08x\n", r );
1688     SysFreeString(str);
1689
1690     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
1691     ok( r == S_OK, "returns %08x\n", r );
1692     if(nodePI)
1693     {
1694         /* Last Child Checks */
1695         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
1696         ok(r == E_INVALIDARG, "ret %08x\n", r );
1697
1698         nodeChild = (IXMLDOMNode*)0x1;
1699         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
1700         ok(r == S_FALSE, "ret %08x\n", r );
1701         ok(nodeChild == NULL, "nodeChild not NULL\n");
1702
1703         /* test nodeName */
1704         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
1705         ok(r == S_OK, "ret %08x\n", r );
1706         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1707         SysFreeString(str);
1708
1709         /* test baseName */
1710         str = (BSTR)0x1;
1711         r = IXMLDOMProcessingInstruction_get_baseName(nodePI, &str);
1712         ok(r == S_OK, "ret %08x\n", r );
1713         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1714         SysFreeString(str);
1715
1716         /* test Target */
1717         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
1718         ok(r == S_OK, "ret %08x\n", r );
1719         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
1720         SysFreeString(str);
1721
1722         /* test get_data */
1723         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
1724         ok(r == S_OK, "ret %08x\n", r );
1725         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
1726         SysFreeString(str);
1727
1728         /* test put_data */
1729         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
1730         ok(r == E_FAIL, "ret %08x\n", r );
1731
1732         /* test put_data */
1733         V_VT(&var) = VT_BSTR;
1734         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
1735         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
1736         ok(r == E_FAIL, "ret %08x\n", r );
1737         VariantClear(&var);
1738
1739         /* test get nodeName */
1740         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
1741         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1742         ok(r == S_OK, "ret %08x\n", r );
1743         SysFreeString(str);
1744
1745         IXMLDOMProcessingInstruction_Release(nodePI);
1746     }
1747
1748     ref = IXMLDOMDocument_Release( doc );
1749     ok( ref == 0, "got %d\n", ref);
1750
1751     free_bstrs();
1752 }
1753
1754 static void test_persiststreaminit(void)
1755 {
1756     IXMLDOMDocument *doc;
1757     IPersistStreamInit *streaminit;
1758     ULARGE_INTEGER size;
1759     HRESULT hr;
1760
1761     doc = create_document(&IID_IXMLDOMDocument);
1762     if (!doc) return;
1763
1764     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&streaminit);
1765     ok(hr == S_OK, "got 0x%08x\n", hr);
1766
1767     hr = IPersistStreamInit_InitNew(streaminit);
1768     ok(hr == S_OK, "got 0x%08x\n", hr);
1769
1770     hr = IPersistStreamInit_GetSizeMax(streaminit, &size);
1771     ok(hr == E_NOTIMPL, "got 0x%08x\n", hr);
1772
1773     IXMLDOMDocument_Release(doc);
1774 }
1775
1776 static void test_domnode( void )
1777 {
1778     HRESULT r;
1779     IXMLDOMDocument *doc, *owner = NULL;
1780     IXMLDOMElement *element = NULL;
1781     IXMLDOMNamedNodeMap *map = NULL;
1782     IXMLDOMNode *node = NULL, *next = NULL;
1783     IXMLDOMNodeList *list = NULL;
1784     IXMLDOMAttribute *attr = NULL;
1785     DOMNodeType type = NODE_INVALID;
1786     VARIANT_BOOL b;
1787     BSTR str;
1788     VARIANT var;
1789     LONG count;
1790
1791     doc = create_document(&IID_IXMLDOMDocument);
1792     if (!doc) return;
1793
1794     b = FALSE;
1795     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
1796     ok( r == S_OK, "loadXML failed\n");
1797     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1798
1799     EXPECT_CHILDREN(doc);
1800
1801     r = IXMLDOMDocument_get_documentElement( doc, &element );
1802     ok( r == S_OK, "should be a document element\n");
1803     ok( element != NULL, "should be an element\n");
1804
1805     VariantInit(&var);
1806     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
1807
1808     r = IXMLDOMDocument_get_nodeValue( doc, NULL );
1809     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
1810
1811     r = IXMLDOMDocument_get_nodeValue( doc, &var );
1812     ok( r == S_FALSE, "nextNode returned wrong code\n");
1813     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
1814     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
1815
1816     if (element)
1817     {
1818         owner = NULL;
1819         r = IXMLDOMElement_get_ownerDocument( element, &owner );
1820         ok( r == S_OK, "get_ownerDocument return code\n");
1821         ok( owner != doc, "get_ownerDocument return\n");
1822         IXMLDOMDocument_Release(owner);
1823
1824         type = NODE_INVALID;
1825         r = IXMLDOMElement_get_nodeType( element, &type);
1826         ok( r == S_OK, "got %08x\n", r);
1827         ok( type == NODE_ELEMENT, "node not an element\n");
1828
1829         str = NULL;
1830         r = IXMLDOMElement_get_baseName( element, &str );
1831         ok( r == S_OK, "get_baseName returned wrong code\n");
1832         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
1833         SysFreeString(str);
1834
1835         /* check if nodename is correct */
1836         r = IXMLDOMElement_get_nodeName( element, NULL );
1837         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1838
1839         /* content doesn't matter here */
1840         str = NULL;
1841         r = IXMLDOMElement_get_nodeName( element, &str );
1842         ok ( r == S_OK, "get_nodeName wrong code\n");
1843         ok ( str != NULL, "str is null\n");
1844         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
1845         SysFreeString( str );
1846
1847         str = SysAllocString( nonexistent_fileW );
1848         V_VT(&var) = VT_I4;
1849         V_I4(&var) = 0x1234;
1850         r = IXMLDOMElement_getAttribute( element, str, &var );
1851         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
1852         ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
1853         VariantClear(&var);
1854
1855         str = SysAllocString( szdl );
1856         V_VT(&var) = VT_I4;
1857         V_I4(&var) = 0x1234;
1858         r = IXMLDOMElement_getAttribute( element, str, &var );
1859         ok( r == S_OK, "getAttribute ret %08x\n", r );
1860         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
1861         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
1862         VariantClear( &var );
1863
1864         r = IXMLDOMElement_getAttribute( element, NULL, &var );
1865         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
1866
1867         r = IXMLDOMElement_getAttribute( element, str, NULL );
1868         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
1869
1870         attr = NULL;
1871         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
1872         ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
1873         ok( attr != NULL, "getAttributeNode returned NULL\n" );
1874         if (attr)
1875         {
1876             r = IXMLDOMAttribute_get_parentNode( attr, NULL );
1877             ok( r == E_INVALIDARG, "Expected E_INVALIDARG, ret %08x\n", r );
1878
1879             /* attribute doesn't have a parent in msxml interpretation */
1880             node = (IXMLDOMNode*)0xdeadbeef;
1881             r = IXMLDOMAttribute_get_parentNode( attr, &node );
1882             ok( r == S_FALSE, "Expected S_FALSE, ret %08x\n", r );
1883             ok( node == NULL, "Expected NULL, got %p\n", node );
1884
1885             IXMLDOMAttribute_Release(attr);
1886         }
1887
1888         SysFreeString( str );
1889
1890         r = IXMLDOMElement_get_attributes( element, &map );
1891         ok( r == S_OK, "get_attributes returned wrong code\n");
1892         ok( map != NULL, "should be attributes\n");
1893
1894         EXPECT_CHILDREN(element);
1895     }
1896     else
1897         ok( FALSE, "no element\n");
1898
1899     if (map)
1900     {
1901         str = SysAllocString( szdl );
1902         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
1903         ok( r == S_OK, "getNamedItem returned wrong code\n");
1904         ok( node != NULL, "should be attributes\n");
1905         IXMLDOMNode_Release(node);
1906         SysFreeString( str );
1907
1908         str = SysAllocString( szdl );
1909         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
1910         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
1911         SysFreeString( str );
1912
1913         /* something that isn't in complete4A */
1914         str = SysAllocString( szOpen );
1915         node = (IXMLDOMNode *) 1;
1916         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
1917         ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
1918         ok( node == NULL, "getNamedItem should have returned NULL\n");
1919         SysFreeString( str );
1920
1921         /* test indexed access of attributes */
1922         r = IXMLDOMNamedNodeMap_get_length( map, NULL );
1923         ok ( r == E_INVALIDARG, "get_length should return E_INVALIDARG\n");
1924
1925         r = IXMLDOMNamedNodeMap_get_length( map, &count );
1926         ok ( r == S_OK, "get_length wrong code\n");
1927         ok ( count == 1, "get_length != 1\n");
1928
1929         node = NULL;
1930         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
1931         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
1932         ok ( node == NULL, "there is no node\n");
1933
1934         node = NULL;
1935         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
1936         ok ( r == S_FALSE, "get_item (1) wrong code\n");
1937         ok ( node == NULL, "there is no attribute\n");
1938
1939         node = NULL;
1940         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
1941         ok ( r == S_OK, "get_item (0) wrong code\n");
1942         ok ( node != NULL, "should be attribute\n");
1943
1944         r = IXMLDOMNode_get_nodeName( node, NULL );
1945         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1946
1947         /* content doesn't matter here */
1948         str = NULL;
1949         r = IXMLDOMNode_get_nodeName( node, &str );
1950         ok ( r == S_OK, "get_nodeName wrong code\n");
1951         ok ( str != NULL, "str is null\n");
1952         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
1953         SysFreeString( str );
1954         IXMLDOMNode_Release( node );
1955
1956         /* test sequential access of attributes */
1957         node = NULL;
1958         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1959         ok ( r == S_OK, "nextNode (first time) wrong code\n");
1960         ok ( node != NULL, "nextNode, should be attribute\n");
1961         IXMLDOMNode_Release( node );
1962
1963         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1964         ok ( r != S_OK, "nextNode (second time) wrong code\n");
1965         ok ( node == NULL, "nextNode, there is no attribute\n");
1966
1967         r = IXMLDOMNamedNodeMap_reset( map );
1968         ok ( r == S_OK, "reset should return S_OK\n");
1969
1970         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1971         ok ( r == S_OK, "nextNode (third time) wrong code\n");
1972         ok ( node != NULL, "nextNode, should be attribute\n");
1973     }
1974     else
1975         ok( FALSE, "no map\n");
1976
1977     if (node)
1978     {
1979         type = NODE_INVALID;
1980         r = IXMLDOMNode_get_nodeType( node, &type);
1981         ok( r == S_OK, "getNamedItem returned wrong code\n");
1982         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
1983
1984         str = NULL;
1985         r = IXMLDOMNode_get_baseName( node, NULL );
1986         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
1987
1988         str = NULL;
1989         r = IXMLDOMNode_get_baseName( node, &str );
1990         ok( r == S_OK, "get_baseName returned wrong code\n");
1991         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
1992         SysFreeString( str );
1993
1994         r = IXMLDOMNode_get_childNodes( node, NULL );
1995         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
1996
1997         r = IXMLDOMNode_get_childNodes( node, &list );
1998         ok( r == S_OK, "get_childNodes returned wrong code\n");
1999
2000         if (list)
2001         {
2002             r = IXMLDOMNodeList_nextNode( list, &next );
2003             ok( r == S_OK, "nextNode returned wrong code\n");
2004         }
2005         else
2006             ok( FALSE, "no childlist\n");
2007
2008         if (next)
2009         {
2010             EXPECT_NO_CHILDREN(next);
2011
2012             type = NODE_INVALID;
2013             r = IXMLDOMNode_get_nodeType( next, &type);
2014             ok( r == S_OK, "getNamedItem returned wrong code\n");
2015             ok( type == NODE_TEXT, "node not text\n");
2016
2017             str = (BSTR) 1;
2018             r = IXMLDOMNode_get_baseName( next, &str );
2019             ok( r == S_FALSE, "get_baseName returned wrong code\n");
2020             ok( str == NULL, "basename was wrong\n");
2021             SysFreeString(str);
2022         }
2023         else
2024             ok( FALSE, "no next\n");
2025
2026         if (next)
2027             IXMLDOMNode_Release( next );
2028         next = NULL;
2029         if (list)
2030             IXMLDOMNodeList_Release( list );
2031         list = NULL;
2032         if (node)
2033             IXMLDOMNode_Release( node );
2034     }
2035     else
2036         ok( FALSE, "no node\n");
2037     node = NULL;
2038
2039     if (map)
2040         IXMLDOMNamedNodeMap_Release( map );
2041
2042     /* now traverse the tree from the root element */
2043     if (element)
2044     {
2045         r = IXMLDOMElement_get_childNodes( element, &list );
2046         ok( r == S_OK, "get_childNodes returned wrong code\n");
2047
2048         /* using get_item for child list doesn't advance the position */
2049         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
2050         expect_node(node, "E2.E2.D1");
2051         IXMLDOMNode_Release(node);
2052         ole_check(IXMLDOMNodeList_nextNode(list, &node));
2053         expect_node(node, "E1.E2.D1");
2054         IXMLDOMNode_Release(node);
2055         ole_check(IXMLDOMNodeList_reset(list));
2056
2057         IXMLDOMNodeList_AddRef(list);
2058         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
2059         ole_check(IXMLDOMNodeList_reset(list));
2060
2061         node = (void*)0xdeadbeef;
2062         str = SysAllocString(szdl);
2063         r = IXMLDOMElement_selectSingleNode( element, str, &node );
2064         SysFreeString(str);
2065         ok( r == S_FALSE, "ret %08x\n", r );
2066         ok( node == NULL, "node %p\n", node );
2067
2068         str = SysAllocString(szbs);
2069         r = IXMLDOMElement_selectSingleNode( element, str, &node );
2070         SysFreeString(str);
2071         ok( r == S_OK, "ret %08x\n", r );
2072         r = IXMLDOMNode_Release( node );
2073         ok( r == 0, "ret %08x\n", r );
2074     }
2075     else
2076         ok( FALSE, "no element\n");
2077
2078     if (list)
2079     {
2080         r = IXMLDOMNodeList_get_item(list, 0, NULL);
2081         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2082
2083         r = IXMLDOMNodeList_get_length(list, NULL);
2084         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2085
2086         r = IXMLDOMNodeList_get_length( list, &count );
2087         ok( r == S_OK, "get_length returns %08x\n", r );
2088         ok( count == 4, "get_length got %d\n", count );
2089
2090         r = IXMLDOMNodeList_nextNode(list, NULL);
2091         ok(r == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", r);
2092
2093         r = IXMLDOMNodeList_nextNode( list, &node );
2094         ok( r == S_OK, "nextNode returned wrong code\n");
2095     }
2096     else
2097         ok( FALSE, "no list\n");
2098
2099     if (node)
2100     {
2101         type = NODE_INVALID;
2102         r = IXMLDOMNode_get_nodeType( node, &type);
2103         ok( r == S_OK, "getNamedItem returned wrong code\n");
2104         ok( type == NODE_ELEMENT, "node not text\n");
2105
2106         r = IXMLDOMNode_hasChildNodes( node, NULL );
2107         ok( r == E_INVALIDARG, "hasChildNodes bad return\n");
2108
2109         EXPECT_CHILDREN(node);
2110
2111         str = NULL;
2112         r = IXMLDOMNode_get_baseName( node, &str );
2113         ok( r == S_OK, "get_baseName returned wrong code\n");
2114         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
2115         SysFreeString(str);
2116     }
2117     else
2118         ok( FALSE, "no node\n");
2119
2120     if (node)
2121         IXMLDOMNode_Release( node );
2122     if (list)
2123         IXMLDOMNodeList_Release( list );
2124     if (element)
2125         IXMLDOMElement_Release( element );
2126
2127     b = FALSE;
2128     str = SysAllocString( szComplete5 );
2129     r = IXMLDOMDocument_loadXML( doc, str, &b );
2130     ok( r == S_OK, "loadXML failed\n");
2131     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2132     SysFreeString( str );
2133
2134     EXPECT_CHILDREN(doc);
2135
2136     r = IXMLDOMDocument_get_documentElement( doc, &element );
2137     ok( r == S_OK, "should be a document element\n");
2138     ok( element != NULL, "should be an element\n");
2139
2140     if (element)
2141     {
2142         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
2143         BSTR tag = NULL;
2144
2145         /* check if the tag is correct */
2146         r = IXMLDOMElement_get_tagName( element, &tag );
2147         ok( r == S_OK, "couldn't get tag name\n");
2148         ok( tag != NULL, "tag was null\n");
2149         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
2150         SysFreeString( tag );
2151     }
2152
2153     if (element)
2154         IXMLDOMElement_Release( element );
2155     ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
2156
2157     free_bstrs();
2158 }
2159
2160 typedef struct {
2161     DOMNodeType type;
2162     REFIID iid;
2163 } refcount_test_t;
2164
2165 static const refcount_test_t refcount_test[] = {
2166     { NODE_ELEMENT,                &IID_IXMLDOMElement },
2167     { NODE_ATTRIBUTE,              &IID_IXMLDOMAttribute },
2168     { NODE_TEXT,                   &IID_IXMLDOMText },
2169     { NODE_CDATA_SECTION,          &IID_IXMLDOMCDATASection },
2170     { NODE_ENTITY_REFERENCE,       &IID_IXMLDOMEntityReference },
2171     { NODE_PROCESSING_INSTRUCTION, &IID_IXMLDOMProcessingInstruction },
2172     { NODE_COMMENT,                &IID_IXMLDOMComment },
2173     { NODE_DOCUMENT_FRAGMENT,      &IID_IXMLDOMDocumentFragment },
2174     { NODE_INVALID,                &IID_NULL }
2175 };
2176
2177 static void test_refs(void)
2178 {
2179     IXMLDOMImplementation *impl, *impl2;
2180     IXMLDOMElement *element, *elem2;
2181     IXMLDOMNodeList *node_list = NULL;
2182     IXMLDOMNode *node, *node2, *node3;
2183     const refcount_test_t *ptr;
2184     IXMLDOMDocument *doc;
2185     IUnknown *unk, *unk2;
2186     VARIANT_BOOL b;
2187     HRESULT hr;
2188     LONG ref;
2189
2190     doc = create_document(&IID_IXMLDOMDocument);
2191     if (!doc) return;
2192
2193     ptr = refcount_test;
2194     while (ptr->type != NODE_INVALID)
2195     {
2196         IUnknown *node_typed, *node_typed2;
2197         IDispatchEx *dispex, *dispex2;
2198         IDispatch *disp, *disp2;
2199         VARIANT type;
2200
2201         V_VT(&type) = VT_I1;
2202         V_I1(&type) = ptr->type;
2203
2204         EXPECT_REF(doc, 1);
2205         hr = IXMLDOMDocument_createNode(doc, type, _bstr_("name"), NULL, &node);
2206         EXPECT_HR(hr, S_OK);
2207         EXPECT_REF(doc, 1);
2208         EXPECT_REF(node, 1);
2209
2210         /* try IDispatch and IUnknown from IXMLDOMNode */
2211         hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
2212         EXPECT_HR(hr, S_OK);
2213         EXPECT_REF(unk, 2);
2214 todo_wine {
2215         EXPECT_REF(node, 1);
2216         ok(unk != (IUnknown*)node, "%d: got %p and %p\n", ptr->type, unk, node);
2217 }
2218         EXPECT_REF(unk, 2);
2219         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
2220         EXPECT_HR(hr, S_OK);
2221         todo_wine ok(unk != (IUnknown*)disp, "%d: got %p and %p\n", ptr->type, unk, disp);
2222         EXPECT_REF(unk, 3);
2223         todo_wine EXPECT_REF(disp, 1);
2224
2225         EXPECT_REF(unk, 3);
2226         hr = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp2);
2227         EXPECT_HR(hr, S_OK);
2228         todo_wine ok(disp != disp2, "%d: got %p and %p\n", ptr->type, disp, disp2);
2229         EXPECT_REF(unk, 4);
2230         todo_wine EXPECT_REF(disp2, 1);
2231
2232         IDispatch_Release(disp);
2233         IDispatch_Release(disp2);
2234
2235         /* get IXMLDOMNode from this IUnknown */
2236         EXPECT_REF(unk, 2);
2237         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node2);
2238         EXPECT_HR(hr, S_OK);
2239         todo_wine ok(unk != (IUnknown*)node2, "%d: got %p and %p\n", ptr->type, unk, node2);
2240         EXPECT_REF(unk, 3);
2241         todo_wine EXPECT_REF(node2, 1);
2242
2243         EXPECT_REF(unk, 3);
2244         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMNode, (void**)&node3);
2245         EXPECT_HR(hr, S_OK);
2246         todo_wine ok(node2 != node3, "%d: got %p and %p\n", ptr->type, node2, node3);
2247         EXPECT_REF(unk, 4);
2248         todo_wine EXPECT_REF(node3, 1);
2249
2250         IXMLDOMNode_Release(node2);
2251         IXMLDOMNode_Release(node3);
2252
2253         /* try IDispatchEx from IUnknown */
2254         EXPECT_REF(unk, 2);
2255         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
2256         EXPECT_HR(hr, S_OK);
2257         ok(unk != (IUnknown*)dispex, "%d: got %p and %p\n", ptr->type, unk, dispex);
2258         EXPECT_REF(unk, 3);
2259         todo_wine EXPECT_REF(dispex, 1);
2260
2261         EXPECT_REF(unk, 3);
2262         hr = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex2);
2263         EXPECT_HR(hr, S_OK);
2264         todo_wine ok(dispex != dispex2, "%d: got %p and %p\n", ptr->type, dispex, dispex2);
2265         EXPECT_REF(unk, 4);
2266         todo_wine EXPECT_REF(dispex2, 1);
2267
2268         IDispatchEx_Release(dispex);
2269         IDispatchEx_Release(dispex2);
2270
2271         /* try corresponding IXMLDOM* */
2272         EXPECT_REF(unk, 2);
2273         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed);
2274         EXPECT_HR(hr, S_OK);
2275         EXPECT_REF(unk, 3);
2276         hr = IUnknown_QueryInterface(unk, ptr->iid, (void**)&node_typed2);
2277         EXPECT_HR(hr, S_OK);
2278         EXPECT_REF(unk, 4);
2279         todo_wine ok(node_typed != node_typed2, "%d: got %p and %p\n", ptr->type, node_typed, node_typed2);
2280         IUnknown_Release(node_typed);
2281         IUnknown_Release(node_typed2);
2282
2283         /* try invalid IXMLDOM* */
2284         hr = IUnknown_QueryInterface(unk, (ptr+1)->iid, (void**)&node_typed);
2285         EXPECT_HR(hr, E_NOINTERFACE);
2286
2287         IUnknown_Release(unk);
2288
2289         EXPECT_REF(node, 1);
2290         hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMNode, (void**)&node2);
2291         EXPECT_HR(hr, S_OK);
2292         EXPECT_REF(node, 2);
2293         ok(node == node2, "%d: got %p and %p\n", ptr->type, node, node2);
2294
2295         EXPECT_REF(node, 2);
2296         hr = IXMLDOMNode_QueryInterface(node, ptr->iid, (void**)&node_typed);
2297         EXPECT_HR(hr, S_OK);
2298         EXPECT_REF(node, 3);
2299 todo_wine {
2300         EXPECT_REF(node_typed, 2);
2301         ok((IUnknown*)node != node_typed, "%d: got %p and %p\n", ptr->type, node, node_typed);
2302 }
2303         IUnknown_Release(node_typed);
2304
2305         IXMLDOMNode_Release(node2);
2306         IXMLDOMNode_Release(node);
2307
2308         ptr++;
2309     }
2310
2311     EXPECT_REF(doc, 1);
2312     ref = IXMLDOMDocument_Release(doc);
2313     ok( ref == 0, "ref %d\n", ref);
2314
2315     /* check IUnknown after releasing DOM iface */
2316     doc = create_document(&IID_IXMLDOMDocument);
2317     EXPECT_REF(doc, 1);
2318     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2319     EXPECT_HR(hr, S_OK);
2320 todo_wine {
2321     EXPECT_REF(unk, 3);
2322     EXPECT_REF(doc, 1);
2323 }
2324     IXMLDOMDocument_Release(doc);
2325     EXPECT_REF(unk, 1);
2326     IUnknown_Release(unk);
2327
2328     doc = create_document(&IID_IXMLDOMDocument);
2329     if (!doc) return;
2330
2331     EXPECT_REF(doc, 1);
2332     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2333     EXPECT_HR(hr, S_OK);
2334 todo_wine {
2335     EXPECT_REF(unk, 3);
2336     EXPECT_REF(doc, 1);
2337 }
2338     IUnknown_Release(unk);
2339
2340     /* IXMLDOMImplementation */
2341     EXPECT_REF(doc, 1);
2342     hr = IXMLDOMDocument_get_implementation(doc, &impl);
2343     EXPECT_HR(hr, S_OK);
2344     EXPECT_REF(doc, 1);
2345     EXPECT_REF(impl, 1);
2346     hr = IXMLDOMDocument_get_implementation(doc, &impl2);
2347     EXPECT_HR(hr, S_OK);
2348     EXPECT_REF(doc, 1);
2349     EXPECT_REF(impl2, 1);
2350     ok(impl != impl2, "got %p, %p\n", impl, impl2);
2351     IXMLDOMImplementation_Release(impl);
2352     IXMLDOMImplementation_Release(impl2);
2353
2354     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2355     EXPECT_HR(hr, S_OK);
2356     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2357
2358     EXPECT_REF(doc, 1);
2359     IXMLDOMDocument_AddRef( doc );
2360     EXPECT_REF(doc, 2);
2361     IXMLDOMDocument_AddRef( doc );
2362     EXPECT_REF(doc, 3);
2363
2364     IXMLDOMDocument_Release( doc );
2365     IXMLDOMDocument_Release( doc );
2366
2367     EXPECT_REF(doc, 1);
2368     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
2369     EXPECT_HR(hr, S_OK);
2370 todo_wine {
2371     EXPECT_REF(unk, 3);
2372     EXPECT_REF(doc, 1);
2373 }
2374     hr = IXMLDOMDocument_get_documentElement(doc, &element);
2375     EXPECT_HR(hr, S_OK);
2376 todo_wine {
2377     EXPECT_REF(doc, 1);
2378     EXPECT_REF(element, 2);
2379 }
2380     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
2381     EXPECT_HR(hr, S_OK);
2382
2383 todo_wine {
2384     EXPECT_REF(doc, 1);
2385     EXPECT_REF(element, 2);
2386     EXPECT_REF(elem2, 2);
2387 }
2388     IXMLDOMElement_AddRef(element);
2389     todo_wine EXPECT_REF(element, 3);
2390     IXMLDOMElement_Release(element);
2391
2392     /* get IUnknown from a node doesn't touch node instance refcount */
2393     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
2394     EXPECT_HR(hr, S_OK);
2395     EXPECT_REF(element, 2);
2396 todo_wine {
2397     EXPECT_REF(unk, 4);
2398     EXPECT_REF(elem2, 2);
2399 }
2400     hr = IXMLDOMElement_QueryInterface(elem2, &IID_IUnknown, (void**)&unk2);
2401     EXPECT_HR(hr, S_OK);
2402 todo_wine {
2403     EXPECT_REF(unk, 5);
2404     EXPECT_REF(unk2, 5);
2405 }
2406     EXPECT_REF(element, 2);
2407     EXPECT_REF(elem2, 2);
2408
2409     todo_wine ok(unk == unk2, "got %p and %p\n", unk, unk2);
2410
2411     IUnknown_Release(unk);
2412     IUnknown_Release(unk2);
2413
2414     /* IUnknown refcount is not affected by node refcount */
2415     todo_wine EXPECT_REF(unk2, 3);
2416     IXMLDOMElement_AddRef(elem2);
2417     todo_wine EXPECT_REF(unk2, 3);
2418     IXMLDOMElement_Release(elem2);
2419
2420     IXMLDOMElement_Release(elem2);
2421     todo_wine EXPECT_REF(unk2, 2);
2422
2423     hr = IXMLDOMElement_get_childNodes( element, &node_list );
2424     EXPECT_HR(hr, S_OK);
2425
2426     todo_wine EXPECT_REF(element, 2);
2427     EXPECT_REF(node_list, 1);
2428
2429     hr = IXMLDOMNodeList_get_item( node_list, 0, &node );
2430     EXPECT_HR(hr, S_OK);
2431     EXPECT_REF(node_list, 1);
2432     EXPECT_REF(node, 1);
2433
2434     hr = IXMLDOMNodeList_get_item( node_list, 0, &node2 );
2435     EXPECT_HR(hr, S_OK);
2436     EXPECT_REF(node_list, 1);
2437     EXPECT_REF(node2, 1);
2438
2439     ref = IXMLDOMNode_Release( node );
2440     ok( ref == 0, "ref %d\n", ref );
2441     ref = IXMLDOMNode_Release( node2 );
2442     ok( ref == 0, "ref %d\n", ref );
2443
2444     ref = IXMLDOMNodeList_Release( node_list );
2445     ok( ref == 0, "ref %d\n", ref );
2446
2447     ok( node != node2, "node %p node2 %p\n", node, node2 );
2448
2449     ref = IXMLDOMDocument_Release( doc );
2450     todo_wine ok( ref == 0, "ref %d\n", ref );
2451
2452     todo_wine EXPECT_REF(element, 2);
2453
2454     /* IUnknown must be unique however we obtain it */
2455     hr = IXMLDOMElement_QueryInterface(element, &IID_IUnknown, (void**)&unk);
2456     EXPECT_HR(hr, S_OK);
2457     EXPECT_REF(element, 2);
2458     hr = IXMLDOMElement_QueryInterface(element, &IID_IXMLDOMNode, (void**)&node);
2459     EXPECT_HR(hr, S_OK);
2460     todo_wine EXPECT_REF(element, 2);
2461     hr = IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk2);
2462     EXPECT_HR(hr, S_OK);
2463     todo_wine EXPECT_REF(element, 2);
2464     ok(unk == unk2, "unk %p unk2 %p\n", unk, unk2);
2465     todo_wine ok(element != (void*)node, "node %p element %p\n", node, element);
2466
2467     IUnknown_Release( unk2 );
2468     IUnknown_Release( unk );
2469     IXMLDOMNode_Release( node );
2470     todo_wine EXPECT_REF(element, 2);
2471
2472     IXMLDOMElement_Release( element );
2473
2474     free_bstrs();
2475 }
2476
2477 static void test_create(void)
2478 {
2479     static const WCHAR szOne[] = {'1',0};
2480     static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
2481     HRESULT r;
2482     VARIANT var;
2483     BSTR str, name;
2484     IXMLDOMDocument *doc;
2485     IXMLDOMElement *element;
2486     IXMLDOMComment *comment;
2487     IXMLDOMText *text;
2488     IXMLDOMCDATASection *cdata;
2489     IXMLDOMNode *root, *node, *child;
2490     IXMLDOMNamedNodeMap *attr_map;
2491     IUnknown *unk;
2492     LONG ref;
2493     LONG num;
2494
2495     doc = create_document(&IID_IXMLDOMDocument);
2496     if (!doc) return;
2497
2498     EXPECT_REF(doc, 1);
2499
2500     /* types not supported for creation */
2501     V_VT(&var) = VT_I1;
2502     V_I1(&var) = NODE_DOCUMENT;
2503     node = (IXMLDOMNode*)0x1;
2504     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2505     ok( r == E_INVALIDARG, "returns %08x\n", r );
2506     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2507
2508     V_VT(&var) = VT_I1;
2509     V_I1(&var) = NODE_DOCUMENT_TYPE;
2510     node = (IXMLDOMNode*)0x1;
2511     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2512     ok( r == E_INVALIDARG, "returns %08x\n", r );
2513     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2514
2515     V_VT(&var) = VT_I1;
2516     V_I1(&var) = NODE_ENTITY;
2517     node = (IXMLDOMNode*)0x1;
2518     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2519     ok( r == E_INVALIDARG, "returns %08x\n", r );
2520     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2521
2522     V_VT(&var) = VT_I1;
2523     V_I1(&var) = NODE_NOTATION;
2524     node = (IXMLDOMNode*)0x1;
2525     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2526     ok( r == E_INVALIDARG, "returns %08x\n", r );
2527     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2528
2529     /* NODE_COMMENT */
2530     V_VT(&var) = VT_I1;
2531     V_I1(&var) = NODE_COMMENT;
2532     node = NULL;
2533     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2534     ok( r == S_OK, "returns %08x\n", r );
2535     ok( node != NULL, "\n");
2536
2537     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2538     ok( r == S_OK, "returns %08x\n", r );
2539     IXMLDOMNode_Release(node);
2540
2541     str = NULL;
2542     r = IXMLDOMComment_get_data(comment, &str);
2543     ok( r == S_OK, "returns %08x\n", r );
2544     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2545     IXMLDOMComment_Release(comment);
2546     SysFreeString(str);
2547
2548     node = (IXMLDOMNode*)0x1;
2549     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2550     ok( r == S_OK, "returns %08x\n", r );
2551
2552     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2553     ok( r == S_OK, "returns %08x\n", r );
2554     IXMLDOMNode_Release(node);
2555
2556     str = NULL;
2557     r = IXMLDOMComment_get_data(comment, &str);
2558     ok( r == S_OK, "returns %08x\n", r );
2559     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2560     IXMLDOMComment_Release(comment);
2561     SysFreeString(str);
2562
2563     node = (IXMLDOMNode*)0x1;
2564     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2565     ok( r == S_OK, "returns %08x\n", r );
2566
2567     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2568     ok( r == S_OK, "returns %08x\n", r );
2569     IXMLDOMNode_Release(node);
2570
2571     str = NULL;
2572     r = IXMLDOMComment_get_data(comment, &str);
2573     ok( r == S_OK, "returns %08x\n", r );
2574     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2575     IXMLDOMComment_Release(comment);
2576     SysFreeString(str);
2577
2578     /* NODE_TEXT */
2579     V_VT(&var) = VT_I1;
2580     V_I1(&var) = NODE_TEXT;
2581     node = NULL;
2582     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2583     ok( r == S_OK, "returns %08x\n", r );
2584     ok( node != NULL, "\n");
2585
2586     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2587     ok( r == S_OK, "returns %08x\n", r );
2588     IXMLDOMNode_Release(node);
2589
2590     str = NULL;
2591     r = IXMLDOMText_get_data(text, &str);
2592     ok( r == S_OK, "returns %08x\n", r );
2593     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2594     IXMLDOMText_Release(text);
2595     SysFreeString(str);
2596
2597     node = (IXMLDOMNode*)0x1;
2598     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2599     ok( r == S_OK, "returns %08x\n", r );
2600
2601     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2602     ok( r == S_OK, "returns %08x\n", r );
2603     IXMLDOMNode_Release(node);
2604
2605     str = NULL;
2606     r = IXMLDOMText_get_data(text, &str);
2607     ok( r == S_OK, "returns %08x\n", r );
2608     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2609     IXMLDOMText_Release(text);
2610     SysFreeString(str);
2611
2612     node = (IXMLDOMNode*)0x1;
2613     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2614     ok( r == S_OK, "returns %08x\n", r );
2615
2616     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2617     ok( r == S_OK, "returns %08x\n", r );
2618     IXMLDOMNode_Release(node);
2619
2620     str = NULL;
2621     r = IXMLDOMText_get_data(text, &str);
2622     ok( r == S_OK, "returns %08x\n", r );
2623     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2624     IXMLDOMText_Release(text);
2625     SysFreeString(str);
2626
2627     /* NODE_CDATA_SECTION */
2628     V_VT(&var) = VT_I1;
2629     V_I1(&var) = NODE_CDATA_SECTION;
2630     node = NULL;
2631     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2632     ok( r == S_OK, "returns %08x\n", r );
2633     ok( node != NULL, "\n");
2634
2635     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2636     ok( r == S_OK, "returns %08x\n", r );
2637     IXMLDOMNode_Release(node);
2638
2639     str = NULL;
2640     r = IXMLDOMCDATASection_get_data(cdata, &str);
2641     ok( r == S_OK, "returns %08x\n", r );
2642     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2643     IXMLDOMCDATASection_Release(cdata);
2644     SysFreeString(str);
2645
2646     node = (IXMLDOMNode*)0x1;
2647     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2648     ok( r == S_OK, "returns %08x\n", r );
2649
2650     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2651     ok( r == S_OK, "returns %08x\n", r );
2652     IXMLDOMNode_Release(node);
2653
2654     str = NULL;
2655     r = IXMLDOMCDATASection_get_data(cdata, &str);
2656     ok( r == S_OK, "returns %08x\n", r );
2657     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2658     IXMLDOMCDATASection_Release(cdata);
2659     SysFreeString(str);
2660
2661     node = (IXMLDOMNode*)0x1;
2662     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2663     ok( r == S_OK, "returns %08x\n", r );
2664
2665     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2666     ok( r == S_OK, "returns %08x\n", r );
2667     IXMLDOMNode_Release(node);
2668
2669     str = NULL;
2670     r = IXMLDOMCDATASection_get_data(cdata, &str);
2671     ok( r == S_OK, "returns %08x\n", r );
2672     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2673     IXMLDOMCDATASection_Release(cdata);
2674     SysFreeString(str);
2675
2676     /* NODE_ATTRIBUTE */
2677     V_VT(&var) = VT_I1;
2678     V_I1(&var) = NODE_ATTRIBUTE;
2679     node = (IXMLDOMNode*)0x1;
2680     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2681     ok( r == E_FAIL, "returns %08x\n", r );
2682     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2683
2684     V_VT(&var) = VT_I1;
2685     V_I1(&var) = NODE_ATTRIBUTE;
2686     node = (IXMLDOMNode*)0x1;
2687     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2688     ok( r == E_FAIL, "returns %08x\n", r );
2689     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2690
2691     V_VT(&var) = VT_I1;
2692     V_I1(&var) = NODE_ATTRIBUTE;
2693     str = SysAllocString( szlc );
2694     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2695     ok( r == S_OK, "returns %08x\n", r );
2696     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2697     SysFreeString(str);
2698
2699     /* a name is required for attribute, try a BSTR with first null wchar */
2700     V_VT(&var) = VT_I1;
2701     V_I1(&var) = NODE_ATTRIBUTE;
2702     str = SysAllocString( szstr1 );
2703     str[0] = 0;
2704     node = (IXMLDOMNode*)0x1;
2705     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2706     ok( r == E_FAIL, "returns %08x\n", r );
2707     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2708     SysFreeString(str);
2709
2710     /* NODE_PROCESSING_INSTRUCTION */
2711     V_VT(&var) = VT_I1;
2712     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2713     node = (IXMLDOMNode*)0x1;
2714     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2715     ok( r == E_FAIL, "returns %08x\n", r );
2716     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2717
2718     V_VT(&var) = VT_I1;
2719     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2720     node = (IXMLDOMNode*)0x1;
2721     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2722     ok( r == E_FAIL, "returns %08x\n", r );
2723     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2724
2725     V_VT(&var) = VT_I1;
2726     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2727     r = IXMLDOMDocument_createNode( doc, var, _bstr_("pi"), NULL, NULL );
2728     ok( r == E_INVALIDARG, "returns %08x\n", r );
2729
2730     /* NODE_ENTITY_REFERENCE */
2731     V_VT(&var) = VT_I1;
2732     V_I1(&var) = NODE_ENTITY_REFERENCE;
2733     node = (IXMLDOMNode*)0x1;
2734     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2735     ok( r == E_FAIL, "returns %08x\n", r );
2736     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2737
2738     V_VT(&var) = VT_I1;
2739     V_I1(&var) = NODE_ENTITY_REFERENCE;
2740     node = (IXMLDOMNode*)0x1;
2741     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2742     ok( r == E_FAIL, "returns %08x\n", r );
2743     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2744
2745     /* NODE_ELEMENT */
2746     V_VT(&var) = VT_I1;
2747     V_I1(&var) = NODE_ELEMENT;
2748     node = (IXMLDOMNode*)0x1;
2749     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2750     ok( r == E_FAIL, "returns %08x\n", r );
2751     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2752
2753     V_VT(&var) = VT_I1;
2754     V_I1(&var) = NODE_ELEMENT;
2755     node = (IXMLDOMNode*)0x1;
2756     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2757     ok( r == E_FAIL, "returns %08x\n", r );
2758     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2759
2760     V_VT(&var) = VT_I1;
2761     V_I1(&var) = NODE_ELEMENT;
2762     str = SysAllocString( szlc );
2763     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2764     ok( r == S_OK, "returns %08x\n", r );
2765     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2766
2767     V_VT(&var) = VT_I1;
2768     V_I1(&var) = NODE_ELEMENT;
2769     r = IXMLDOMDocument_createNode( doc, var, str, NULL, NULL );
2770     ok( r == E_INVALIDARG, "returns %08x\n", r );
2771
2772     V_VT(&var) = VT_R4;
2773     V_R4(&var) = NODE_ELEMENT;
2774     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2775     ok( r == S_OK, "returns %08x\n", r );
2776     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2777
2778     V_VT(&var) = VT_BSTR;
2779     V_BSTR(&var) = SysAllocString( szOne );
2780     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2781     ok( r == S_OK, "returns %08x\n", r );
2782     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2783     VariantClear(&var);
2784
2785     V_VT(&var) = VT_BSTR;
2786     V_BSTR(&var) = SysAllocString( szOneGarbage );
2787     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2788     ok( r == E_INVALIDARG, "returns %08x\n", r );
2789     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2790     VariantClear(&var);
2791
2792     V_VT(&var) = VT_I4;
2793     V_I4(&var) = NODE_ELEMENT;
2794     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2795     ok( r == S_OK, "returns %08x\n", r );
2796
2797     EXPECT_REF(doc, 1);
2798     r = IXMLDOMDocument_appendChild( doc, node, &root );
2799     ok( r == S_OK, "returns %08x\n", r );
2800     ok( node == root, "%p %p\n", node, root );
2801     EXPECT_REF(doc, 1);
2802
2803     EXPECT_REF(node, 2);
2804
2805     ref = IXMLDOMNode_Release( node );
2806     ok(ref == 1, "ref %d\n", ref);
2807     SysFreeString( str );
2808
2809     V_VT(&var) = VT_I4;
2810     V_I4(&var) = NODE_ELEMENT;
2811     str = SysAllocString( szbs );
2812     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2813     ok( r == S_OK, "returns %08x\n", r );
2814     SysFreeString( str );
2815
2816     EXPECT_REF(node, 1);
2817
2818     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk );
2819     ok( r == S_OK, "returns %08x\n", r );
2820
2821     EXPECT_REF(unk, 2);
2822
2823     V_VT(&var) = VT_EMPTY;
2824     child = NULL;
2825     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
2826     ok( r == S_OK, "returns %08x\n", r );
2827     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
2828
2829     todo_wine EXPECT_REF(unk, 4);
2830
2831     IXMLDOMNode_Release( child );
2832     IUnknown_Release( unk );
2833
2834     V_VT(&var) = VT_NULL;
2835     V_DISPATCH(&var) = (IDispatch*)node;
2836     r = IXMLDOMNode_insertBefore( root, node, var, &child );
2837     ok( r == S_OK, "returns %08x\n", r );
2838     ok( node == child, "%p %p\n", node, child );
2839     IXMLDOMNode_Release( child );
2840
2841     V_VT(&var) = VT_NULL;
2842     V_DISPATCH(&var) = (IDispatch*)node;
2843     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
2844     ok( r == S_OK, "returns %08x\n", r );
2845     IXMLDOMNode_Release( node );
2846
2847     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (void**)&element );
2848     ok( r == S_OK, "returns %08x\n", r );
2849
2850     r = IXMLDOMElement_get_attributes( element, &attr_map );
2851     ok( r == S_OK, "returns %08x\n", r );
2852     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2853     ok( r == S_OK, "returns %08x\n", r );
2854     ok( num == 0, "num %d\n", num );
2855     IXMLDOMNamedNodeMap_Release( attr_map );
2856
2857     V_VT(&var) = VT_BSTR;
2858     V_BSTR(&var) = SysAllocString( szstr1 );
2859     name = SysAllocString( szdl );
2860     r = IXMLDOMElement_setAttribute( element, name, var );
2861     ok( r == S_OK, "returns %08x\n", r );
2862     r = IXMLDOMElement_get_attributes( element, &attr_map );
2863     ok( r == S_OK, "returns %08x\n", r );
2864     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2865     ok( r == S_OK, "returns %08x\n", r );
2866     ok( num == 1, "num %d\n", num );
2867     IXMLDOMNamedNodeMap_Release( attr_map );
2868     VariantClear(&var);
2869
2870     V_VT(&var) = VT_BSTR;
2871     V_BSTR(&var) = SysAllocString( szstr2 );
2872     r = IXMLDOMElement_setAttribute( element, name, var );
2873     ok( r == S_OK, "returns %08x\n", r );
2874     r = IXMLDOMElement_get_attributes( element, &attr_map );
2875     ok( r == S_OK, "returns %08x\n", r );
2876     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2877     ok( r == S_OK, "returns %08x\n", r );
2878     ok( num == 1, "num %d\n", num );
2879     IXMLDOMNamedNodeMap_Release( attr_map );
2880     VariantClear(&var);
2881     r = IXMLDOMElement_getAttribute( element, name, &var );
2882     ok( r == S_OK, "returns %08x\n", r );
2883     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
2884     VariantClear(&var);
2885     SysFreeString(name);
2886
2887     V_VT(&var) = VT_BSTR;
2888     V_BSTR(&var) = SysAllocString( szstr1 );
2889     name = SysAllocString( szlc );
2890     r = IXMLDOMElement_setAttribute( element, name, var );
2891     ok( r == S_OK, "returns %08x\n", r );
2892     r = IXMLDOMElement_get_attributes( element, &attr_map );
2893     ok( r == S_OK, "returns %08x\n", r );
2894     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2895     ok( r == S_OK, "returns %08x\n", r );
2896     ok( num == 2, "num %d\n", num );
2897     IXMLDOMNamedNodeMap_Release( attr_map );
2898     VariantClear(&var);
2899     SysFreeString(name);
2900
2901     V_VT(&var) = VT_I4;
2902     V_I4(&var) = 10;
2903     name = SysAllocString( szbs );
2904     r = IXMLDOMElement_setAttribute( element, name, var );
2905     ok( r == S_OK, "returns %08x\n", r );
2906     VariantClear(&var);
2907     r = IXMLDOMElement_getAttribute( element, name, &var );
2908     ok( r == S_OK, "returns %08x\n", r );
2909     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
2910     VariantClear(&var);
2911     SysFreeString(name);
2912
2913     /* Create an Attribute */
2914     V_VT(&var) = VT_I4;
2915     V_I4(&var) = NODE_ATTRIBUTE;
2916     str = SysAllocString( szAttribute );
2917     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2918     ok( r == S_OK, "returns %08x\n", r );
2919     ok( node != NULL, "node was null\n");
2920     SysFreeString(str);
2921
2922     IXMLDOMElement_Release( element );
2923     IXMLDOMNode_Release( root );
2924     IXMLDOMDocument_Release( doc );
2925 }
2926
2927 static void test_getElementsByTagName(void)
2928 {
2929     IXMLDOMNodeList *node_list;
2930     IXMLDOMDocument *doc;
2931     IXMLDOMElement *elem;
2932     WCHAR buff[100];
2933     VARIANT_BOOL b;
2934     HRESULT r;
2935     LONG len;
2936     BSTR str;
2937
2938     doc = create_document(&IID_IXMLDOMDocument);
2939     if (!doc) return;
2940
2941     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
2942     ok( r == S_OK, "loadXML failed\n");
2943     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2944
2945     str = SysAllocString( szstar );
2946
2947     /* null arguments cases */
2948     r = IXMLDOMDocument_getElementsByTagName(doc, NULL, &node_list);
2949     ok( r == E_INVALIDARG, "ret %08x\n", r );
2950     r = IXMLDOMDocument_getElementsByTagName(doc, str, NULL);
2951     ok( r == E_INVALIDARG, "ret %08x\n", r );
2952
2953     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
2954     ok( r == S_OK, "ret %08x\n", r );
2955     r = IXMLDOMNodeList_get_length( node_list, &len );
2956     ok( r == S_OK, "ret %08x\n", r );
2957     ok( len == 6, "len %d\n", len );
2958
2959     IXMLDOMNodeList_Release( node_list );
2960     SysFreeString( str );
2961
2962     /* broken query BSTR */
2963     memcpy(&buff[2], szstar, sizeof(szstar));
2964     /* just a big length */
2965     *(DWORD*)buff = 0xf0f0;
2966     r = IXMLDOMDocument_getElementsByTagName(doc, &buff[2], &node_list);
2967     ok( r == S_OK, "ret %08x\n", r );
2968     r = IXMLDOMNodeList_get_length( node_list, &len );
2969     ok( r == S_OK, "ret %08x\n", r );
2970     ok( len == 6, "len %d\n", len );
2971     IXMLDOMNodeList_Release( node_list );
2972
2973     str = SysAllocString( szbs );
2974     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
2975     ok( r == S_OK, "ret %08x\n", r );
2976     r = IXMLDOMNodeList_get_length( node_list, &len );
2977     ok( r == S_OK, "ret %08x\n", r );
2978     ok( len == 1, "len %d\n", len );
2979     IXMLDOMNodeList_Release( node_list );
2980     SysFreeString( str );
2981
2982     str = SysAllocString( szdl );
2983     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
2984     ok( r == S_OK, "ret %08x\n", r );
2985     r = IXMLDOMNodeList_get_length( node_list, &len );
2986     ok( r == S_OK, "ret %08x\n", r );
2987     ok( len == 0, "len %d\n", len );
2988     IXMLDOMNodeList_Release( node_list );
2989     SysFreeString( str );
2990
2991     str = SysAllocString( szstr1 );
2992     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
2993     ok( r == S_OK, "ret %08x\n", r );
2994     r = IXMLDOMNodeList_get_length( node_list, &len );
2995     ok( r == S_OK, "ret %08x\n", r );
2996     ok( len == 0, "len %d\n", len );
2997     IXMLDOMNodeList_Release( node_list );
2998     SysFreeString( str );
2999
3000     /* test for element */
3001     r = IXMLDOMDocument_get_documentElement(doc, &elem);
3002     ok( r == S_OK, "ret %08x\n", r );
3003
3004     str = SysAllocString( szstar );
3005
3006     /* null arguments cases */
3007     r = IXMLDOMElement_getElementsByTagName(elem, NULL, &node_list);
3008     ok( r == E_INVALIDARG, "ret %08x\n", r );
3009     r = IXMLDOMElement_getElementsByTagName(elem, str, NULL);
3010     ok( r == E_INVALIDARG, "ret %08x\n", r );
3011
3012     r = IXMLDOMElement_getElementsByTagName(elem, str, &node_list);
3013     ok( r == S_OK, "ret %08x\n", r );
3014     r = IXMLDOMNodeList_get_length( node_list, &len );
3015     ok( r == S_OK, "ret %08x\n", r );
3016     ok( len == 5, "len %d\n", len );
3017     expect_list_and_release(node_list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1 E1.E4.E2.D1");
3018     SysFreeString( str );
3019
3020     /* broken query BSTR */
3021     memcpy(&buff[2], szstar, sizeof(szstar));
3022     /* just a big length */
3023     *(DWORD*)buff = 0xf0f0;
3024     r = IXMLDOMElement_getElementsByTagName(elem, &buff[2], &node_list);
3025     ok( r == S_OK, "ret %08x\n", r );
3026     r = IXMLDOMNodeList_get_length( node_list, &len );
3027     ok( r == S_OK, "ret %08x\n", r );
3028     ok( len == 5, "len %d\n", len );
3029     IXMLDOMNodeList_Release( node_list );
3030
3031     IXMLDOMElement_Release(elem);
3032
3033     IXMLDOMDocument_Release( doc );
3034
3035     free_bstrs();
3036 }
3037
3038 static void test_get_text(void)
3039 {
3040     HRESULT r;
3041     BSTR str;
3042     VARIANT_BOOL b;
3043     IXMLDOMDocument *doc;
3044     IXMLDOMNode *node, *node2, *node3;
3045     IXMLDOMNode *nodeRoot;
3046     IXMLDOMNodeList *node_list;
3047     IXMLDOMNamedNodeMap *node_map;
3048     LONG len;
3049
3050     doc = create_document(&IID_IXMLDOMDocument);
3051     if (!doc) return;
3052
3053     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3054     ok( r == S_OK, "loadXML failed\n");
3055     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3056
3057     str = SysAllocString( szbs );
3058     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
3059     ok( r == S_OK, "ret %08x\n", r );
3060     SysFreeString(str);
3061
3062     /* Test to get all child node text. */
3063     r = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&nodeRoot);
3064     ok( r == S_OK, "ret %08x\n", r );
3065     if(r == S_OK)
3066     {
3067         r = IXMLDOMNode_get_text( nodeRoot, &str );
3068         ok( r == S_OK, "ret %08x\n", r );
3069         ok( compareIgnoreReturns(str, _bstr_("fn1.txt\n\n fn2.txt \n\nf1\n")), "wrong get_text: %s\n", wine_dbgstr_w(str));
3070         SysFreeString(str);
3071
3072         IXMLDOMNode_Release(nodeRoot);
3073     }
3074
3075     r = IXMLDOMNodeList_get_length( node_list, NULL );
3076     ok( r == E_INVALIDARG, "ret %08x\n", r );
3077
3078     r = IXMLDOMNodeList_get_length( node_list, &len );
3079     ok( r == S_OK, "ret %08x\n", r );
3080     ok( len == 1, "expect 1 got %d\n", len );
3081
3082     r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
3083     ok( r == E_INVALIDARG, "ret %08x\n", r );
3084
3085     r = IXMLDOMNodeList_nextNode( node_list, NULL );
3086     ok( r == E_INVALIDARG, "ret %08x\n", r );
3087
3088     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
3089     ok( r == S_OK, "ret %08x\n", r );
3090     IXMLDOMNodeList_Release( node_list );
3091
3092     /* Invalid output parameter*/
3093     r = IXMLDOMNode_get_text( node, NULL );
3094     ok( r == E_INVALIDARG, "ret %08x\n", r );
3095
3096     r = IXMLDOMNode_get_text( node, &str );
3097     ok( r == S_OK, "ret %08x\n", r );
3098     ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
3099     SysFreeString(str);
3100
3101     r = IXMLDOMNode_get_attributes( node, &node_map );
3102     ok( r == S_OK, "ret %08x\n", r );
3103
3104     str = SysAllocString( szvr );
3105     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
3106     ok( r == S_OK, "ret %08x\n", r );
3107     SysFreeString(str);
3108
3109     r = IXMLDOMNode_get_text( node2, &str );
3110     ok( r == S_OK, "ret %08x\n", r );
3111     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3112     SysFreeString(str);
3113
3114     r = IXMLDOMNode_get_firstChild( node2, &node3 );
3115     ok( r == S_OK, "ret %08x\n", r );
3116
3117     r = IXMLDOMNode_get_text( node3, &str );
3118     ok( r == S_OK, "ret %08x\n", r );
3119     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3120     SysFreeString(str);
3121
3122
3123     IXMLDOMNode_Release( node3 );
3124     IXMLDOMNode_Release( node2 );
3125     IXMLDOMNamedNodeMap_Release( node_map );
3126     IXMLDOMNode_Release( node );
3127     IXMLDOMDocument_Release( doc );
3128
3129     free_bstrs();
3130 }
3131
3132 static void test_get_childNodes(void)
3133 {
3134     IXMLDOMNodeList *node_list, *node_list2;
3135     IEnumVARIANT *enum1, *enum2, *enum3;
3136     VARIANT_BOOL b;
3137     IXMLDOMDocument *doc;
3138     IXMLDOMNode *node, *node2;
3139     IXMLDOMElement *element;
3140     IUnknown *unk1, *unk2;
3141     HRESULT hr;
3142     VARIANT v;
3143     BSTR str;
3144     LONG len;
3145
3146     doc = create_document(&IID_IXMLDOMDocument);
3147     if (!doc) return;
3148
3149     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3150     EXPECT_HR(hr, S_OK);
3151     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3152
3153     hr = IXMLDOMDocument_get_documentElement( doc, &element );
3154     EXPECT_HR(hr, S_OK);
3155
3156     hr = IXMLDOMElement_get_childNodes( element, &node_list );
3157     EXPECT_HR(hr, S_OK);
3158
3159     hr = IXMLDOMNodeList_get_length( node_list, &len );
3160     EXPECT_HR(hr, S_OK);
3161     ok( len == 4, "len %d\n", len);
3162
3163     /* refcount tests for IEnumVARIANT support */
3164     EXPECT_REF(node_list, 1);
3165     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum1);
3166     EXPECT_HR(hr, S_OK);
3167     EXPECT_REF(node_list, 1);
3168     EXPECT_REF(enum1, 2);
3169
3170     EXPECT_REF(node_list, 1);
3171     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IEnumVARIANT, (void**)&enum2);
3172     EXPECT_HR(hr, S_OK);
3173     EXPECT_REF(node_list, 1);
3174     ok(enum2 == enum1, "got %p, %p\n", enum2, enum1);
3175     IEnumVARIANT_Release(enum2);
3176
3177     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
3178     EXPECT_HR(hr, S_OK);
3179     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
3180     EXPECT_HR(hr, S_OK);
3181     EXPECT_REF(node_list, 3);
3182     EXPECT_REF(enum1, 2);
3183     ok(unk1 == unk2, "got %p, %p\n", unk1, unk2);
3184     IUnknown_Release(unk1);
3185     IUnknown_Release(unk2);
3186
3187     EXPECT_REF(node_list, 1);
3188     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum2);
3189     EXPECT_HR(hr, S_OK);
3190     EXPECT_REF(node_list, 2);
3191     EXPECT_REF(enum2, 1);
3192     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
3193
3194     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
3195     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk1);
3196     EXPECT_HR(hr, S_OK);
3197     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
3198     EXPECT_HR(hr, S_OK);
3199     EXPECT_REF(node_list, 3);
3200     EXPECT_REF(enum2, 2);
3201     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
3202     IUnknown_Release(unk1);
3203     IUnknown_Release(unk2);
3204
3205     hr = IXMLDOMNodeList__newEnum(node_list, (IUnknown**)&enum3);
3206     EXPECT_HR(hr, S_OK);
3207     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
3208     IEnumVARIANT_Release(enum3);
3209     IEnumVARIANT_Release(enum2);
3210
3211     /* iteration tests */
3212     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
3213     EXPECT_HR(hr, S_OK);
3214     hr = IXMLDOMNode_get_nodeName(node, &str);
3215     EXPECT_HR(hr, S_OK);
3216     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
3217     SysFreeString(str);
3218     IXMLDOMNode_Release(node);
3219
3220     hr = IXMLDOMNodeList_nextNode(node_list, &node);
3221     EXPECT_HR(hr, S_OK);
3222     hr = IXMLDOMNode_get_nodeName(node, &str);
3223     EXPECT_HR(hr, S_OK);
3224     ok(!lstrcmpW(str, _bstr_("bs")), "got %s\n", wine_dbgstr_w(str));
3225     SysFreeString(str);
3226     IXMLDOMNode_Release(node);
3227
3228     V_VT(&v) = VT_EMPTY;
3229     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
3230     EXPECT_HR(hr, S_OK);
3231     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
3232     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
3233     EXPECT_HR(hr, S_OK);
3234     hr = IXMLDOMNode_get_nodeName(node, &str);
3235     EXPECT_HR(hr, S_OK);
3236     ok(!lstrcmpW(str, _bstr_("bs")), "got node name %s\n", wine_dbgstr_w(str));
3237     SysFreeString(str);
3238     IXMLDOMNode_Release(node);
3239     VariantClear(&v);
3240
3241     hr = IXMLDOMNodeList_nextNode(node_list, &node);
3242     EXPECT_HR(hr, S_OK);
3243     hr = IXMLDOMNode_get_nodeName(node, &str);
3244     EXPECT_HR(hr, S_OK);
3245     ok(!lstrcmpW(str, _bstr_("pr")), "got %s\n", wine_dbgstr_w(str));
3246     SysFreeString(str);
3247     IXMLDOMNode_Release(node);
3248
3249     IEnumVARIANT_Release(enum1);
3250
3251     hr = IXMLDOMNodeList_get_item( node_list, 2, &node );
3252     EXPECT_HR(hr, S_OK);
3253
3254     hr = IXMLDOMNode_get_childNodes( node, &node_list2 );
3255     EXPECT_HR(hr, S_OK);
3256
3257     hr = IXMLDOMNodeList_get_length( node_list2, &len );
3258     EXPECT_HR(hr, S_OK);
3259     ok( len == 0, "len %d\n", len);
3260
3261     hr = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
3262     EXPECT_HR(hr, S_FALSE);
3263
3264     IXMLDOMNodeList_Release( node_list2 );
3265     IXMLDOMNode_Release( node );
3266     IXMLDOMNodeList_Release( node_list );
3267     IXMLDOMElement_Release( element );
3268
3269     /* test for children of <?xml ..?> node */
3270     hr = IXMLDOMDocument_get_firstChild(doc, &node);
3271     EXPECT_HR(hr, S_OK);
3272
3273     str = NULL;
3274     hr = IXMLDOMNode_get_nodeName(node, &str);
3275     EXPECT_HR(hr, S_OK);
3276     ok(!lstrcmpW(str, _bstr_("xml")), "got %s\n", wine_dbgstr_w(str));
3277     SysFreeString(str);
3278
3279     /* it returns empty but valid node list */
3280     node_list = (void*)0xdeadbeef;
3281     hr = IXMLDOMNode_get_childNodes(node, &node_list);
3282     EXPECT_HR(hr, S_OK);
3283
3284     len = -1;
3285     hr = IXMLDOMNodeList_get_length(node_list, &len);
3286     EXPECT_HR(hr, S_OK);
3287     ok(len == 0, "got %d\n", len);
3288
3289     IXMLDOMNodeList_Release( node_list );
3290     IXMLDOMNode_Release(node);
3291
3292     IXMLDOMDocument_Release( doc );
3293     free_bstrs();
3294 }
3295
3296 static void test_get_firstChild(void)
3297 {
3298     static WCHAR xmlW[] = {'x','m','l',0};
3299     IXMLDOMDocument *doc;
3300     IXMLDOMNode *node;
3301     VARIANT_BOOL b;
3302     HRESULT r;
3303     BSTR str;
3304
3305     doc = create_document(&IID_IXMLDOMDocument);
3306     if (!doc) return;
3307
3308     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3309     ok( r == S_OK, "loadXML failed\n");
3310     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3311
3312     r = IXMLDOMDocument_get_firstChild( doc, &node );
3313     ok( r == S_OK, "ret %08x\n", r);
3314
3315     r = IXMLDOMNode_get_nodeName( node, &str );
3316     ok( r == S_OK, "ret %08x\n", r);
3317
3318     ok(!lstrcmpW(str, xmlW), "expected \"xml\" node name, got %s\n", wine_dbgstr_w(str));
3319
3320     SysFreeString(str);
3321     IXMLDOMNode_Release( node );
3322     IXMLDOMDocument_Release( doc );
3323
3324     free_bstrs();
3325 }
3326
3327 static void test_get_lastChild(void)
3328 {
3329     static WCHAR lcW[] = {'l','c',0};
3330     static WCHAR foW[] = {'f','o',0};
3331     IXMLDOMDocument *doc;
3332     IXMLDOMNode *node, *child;
3333     VARIANT_BOOL b;
3334     HRESULT r;
3335     BSTR str;
3336
3337     doc = create_document(&IID_IXMLDOMDocument);
3338     if (!doc) return;
3339
3340     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3341     ok( r == S_OK, "loadXML failed\n");
3342     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3343
3344     r = IXMLDOMDocument_get_lastChild( doc, &node );
3345     ok( r == S_OK, "ret %08x\n", r);
3346
3347     r = IXMLDOMNode_get_nodeName( node, &str );
3348     ok( r == S_OK, "ret %08x\n", r);
3349
3350     ok(memcmp(str, lcW, sizeof(lcW)) == 0, "expected \"lc\" node name\n");
3351     SysFreeString(str);
3352
3353     r = IXMLDOMNode_get_lastChild( node, &child );
3354     ok( r == S_OK, "ret %08x\n", r);
3355
3356     r = IXMLDOMNode_get_nodeName( child, &str );
3357     ok( r == S_OK, "ret %08x\n", r);
3358
3359     ok(memcmp(str, foW, sizeof(foW)) == 0, "expected \"fo\" node name\n");
3360     SysFreeString(str);
3361
3362     IXMLDOMNode_Release( child );
3363     IXMLDOMNode_Release( node );
3364     IXMLDOMDocument_Release( doc );
3365
3366     free_bstrs();
3367 }
3368
3369 static void test_removeChild(void)
3370 {
3371     HRESULT r;
3372     VARIANT_BOOL b;
3373     IXMLDOMDocument *doc;
3374     IXMLDOMElement *element, *lc_element;
3375     IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
3376     IXMLDOMNodeList *root_list, *fo_list;
3377
3378     doc = create_document(&IID_IXMLDOMDocument);
3379     if (!doc) return;
3380
3381     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3382     ok( r == S_OK, "loadXML failed\n");
3383     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3384
3385     r = IXMLDOMDocument_get_documentElement( doc, &element );
3386     ok( r == S_OK, "ret %08x\n", r);
3387     todo_wine EXPECT_REF(element, 2);
3388
3389     r = IXMLDOMElement_get_childNodes( element, &root_list );
3390     ok( r == S_OK, "ret %08x\n", r);
3391     EXPECT_REF(root_list, 1);
3392
3393     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3394     ok( r == S_OK, "ret %08x\n", r);
3395     EXPECT_REF(fo_node, 1);
3396
3397     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3398     ok( r == S_OK, "ret %08x\n", r);
3399     EXPECT_REF(fo_list, 1);
3400
3401     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3402     ok( r == S_OK, "ret %08x\n", r);
3403     EXPECT_REF(ba_node, 1);
3404
3405     /* invalid parameter: NULL ptr */
3406     removed_node = (void*)0xdeadbeef;
3407     r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
3408     ok( r == E_INVALIDARG, "ret %08x\n", r );
3409     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3410
3411     /* ba_node is a descendant of element, but not a direct child. */
3412     removed_node = (void*)0xdeadbeef;
3413     EXPECT_REF(ba_node, 1);
3414     EXPECT_CHILDREN(fo_node);
3415     r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
3416     ok( r == E_INVALIDARG, "ret %08x\n", r );
3417     ok( removed_node == NULL, "%p\n", removed_node );
3418     EXPECT_REF(ba_node, 1);
3419     EXPECT_CHILDREN(fo_node);
3420
3421     EXPECT_REF(ba_node, 1);
3422     EXPECT_REF(fo_node, 1);
3423     r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
3424     ok( r == S_OK, "ret %08x\n", r);
3425     ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
3426     EXPECT_REF(fo_node, 2);
3427     EXPECT_REF(ba_node, 1);
3428
3429     /* try removing already removed child */
3430     temp_node = (void*)0xdeadbeef;
3431     r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
3432     ok( r == E_INVALIDARG, "ret %08x\n", r);
3433     ok( temp_node == NULL, "%p\n", temp_node );
3434     IXMLDOMNode_Release( fo_node );
3435
3436     /* the removed node has no parent anymore */
3437     r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
3438     ok( r == S_FALSE, "ret %08x\n", r);
3439     ok( temp_node == NULL, "%p\n", temp_node );
3440
3441     IXMLDOMNode_Release( removed_node );
3442     IXMLDOMNode_Release( ba_node );
3443     IXMLDOMNodeList_Release( fo_list );
3444
3445     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3446     ok( r == S_OK, "ret %08x\n", r);
3447
3448     r = IXMLDOMNode_QueryInterface( lc_node, &IID_IXMLDOMElement, (void**)&lc_element );
3449     ok( r == S_OK, "ret %08x\n", r);
3450
3451     /* MS quirk: passing wrong interface pointer works, too */
3452     r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
3453     ok( r == S_OK, "ret %08x\n", r);
3454     IXMLDOMElement_Release( lc_element );
3455
3456     temp_node = (void*)0xdeadbeef;
3457     r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
3458     ok( r == S_FALSE, "ret %08x\n", r);
3459     ok( temp_node == NULL, "%p\n", temp_node );
3460
3461     IXMLDOMNode_Release( lc_node );
3462     IXMLDOMNodeList_Release( root_list );
3463     IXMLDOMElement_Release( element );
3464     IXMLDOMDocument_Release( doc );
3465
3466     free_bstrs();
3467 }
3468
3469 static void test_replaceChild(void)
3470 {
3471     HRESULT r;
3472     VARIANT_BOOL b;
3473     IXMLDOMDocument *doc;
3474     IXMLDOMElement *element, *ba_element;
3475     IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
3476     IXMLDOMNodeList *root_list, *fo_list;
3477     IUnknown * unk1, *unk2;
3478     LONG len;
3479
3480     doc = create_document(&IID_IXMLDOMDocument);
3481     if (!doc) return;
3482
3483     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3484     ok( r == S_OK, "loadXML failed\n");
3485     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3486
3487     r = IXMLDOMDocument_get_documentElement( doc, &element );
3488     ok( r == S_OK, "ret %08x\n", r);
3489
3490     r = IXMLDOMElement_get_childNodes( element, &root_list );
3491     ok( r == S_OK, "ret %08x\n", r);
3492
3493     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3494     ok( r == S_OK, "ret %08x\n", r);
3495
3496     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3497     ok( r == S_OK, "ret %08x\n", r);
3498
3499     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3500     ok( r == S_OK, "ret %08x\n", r);
3501
3502     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3503     ok( r == S_OK, "ret %08x\n", r);
3504
3505     IXMLDOMNodeList_Release( fo_list );
3506
3507     /* invalid parameter: NULL ptr for element to remove */
3508     removed_node = (void*)0xdeadbeef;
3509     r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
3510     ok( r == E_INVALIDARG, "ret %08x\n", r );
3511     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3512
3513     /* invalid parameter: NULL for replacement element. (Sic!) */
3514     removed_node = (void*)0xdeadbeef;
3515     r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
3516     ok( r == E_INVALIDARG, "ret %08x\n", r );
3517     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3518
3519     /* invalid parameter: OldNode is not a child */
3520     removed_node = (void*)0xdeadbeef;
3521     r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
3522     ok( r == E_INVALIDARG, "ret %08x\n", r );
3523     ok( removed_node == NULL, "%p\n", removed_node );
3524     IXMLDOMNode_Release( lc_node );
3525
3526     /* invalid parameter: would create loop */
3527     removed_node = (void*)0xdeadbeef;
3528     r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
3529     ok( r == E_FAIL, "ret %08x\n", r );
3530     ok( removed_node == NULL, "%p\n", removed_node );
3531
3532     r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
3533     ok( r == S_OK, "ret %08x\n", r );
3534
3535     r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
3536     ok( r == S_OK, "ret %08x\n", r );
3537
3538     /* ba_node and temp_node refer to the same node, yet they
3539        are different interface pointers */
3540     ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
3541     r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
3542     ok( r == S_OK, "ret %08x\n", r );
3543     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
3544     ok( r == S_OK, "ret %08x\n", r );
3545     todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
3546
3547     IUnknown_Release( unk1 );
3548     IUnknown_Release( unk2 );
3549
3550     /* ba_node should have been removed from below fo_node */
3551     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3552     ok( r == S_OK, "ret %08x\n", r );
3553
3554     /* MS quirk: replaceChild also accepts elements instead of nodes */
3555     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
3556     ok( r == S_OK, "ret %08x\n", r );
3557     EXPECT_REF(ba_element, 2);
3558
3559     removed_node = NULL;
3560     r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
3561     ok( r == S_OK, "ret %08x\n", r );
3562     ok( removed_node != NULL, "got %p\n", removed_node);
3563     EXPECT_REF(ba_element, 3);
3564     IXMLDOMElement_Release( ba_element );
3565
3566     r = IXMLDOMNodeList_get_length( fo_list, &len);
3567     ok( r == S_OK, "ret %08x\n", r );
3568     ok( len == 0, "len %d\n", len);
3569
3570     IXMLDOMNodeList_Release( fo_list );
3571
3572     IXMLDOMNode_Release(ba_node);
3573     IXMLDOMNode_Release(fo_node);
3574     IXMLDOMNode_Release(temp_node);
3575     IXMLDOMNodeList_Release( root_list );
3576     IXMLDOMElement_Release( element );
3577     IXMLDOMDocument_Release( doc );
3578
3579     free_bstrs();
3580 }
3581
3582 static void test_removeNamedItem(void)
3583 {
3584     IXMLDOMDocument *doc;
3585     IXMLDOMElement *element;
3586     IXMLDOMNode *pr_node, *removed_node, *removed_node2;
3587     IXMLDOMNodeList *root_list;
3588     IXMLDOMNamedNodeMap * pr_attrs;
3589     VARIANT_BOOL b;
3590     BSTR str;
3591     LONG len;
3592     HRESULT r;
3593
3594     doc = create_document(&IID_IXMLDOMDocument);
3595     if (!doc) return;
3596
3597     r = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
3598     ok( r == S_OK, "loadXML failed\n");
3599     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3600
3601     r = IXMLDOMDocument_get_documentElement( doc, &element );
3602     ok( r == S_OK, "ret %08x\n", r);
3603
3604     r = IXMLDOMElement_get_childNodes( element, &root_list );
3605     ok( r == S_OK, "ret %08x\n", r);
3606
3607     r = IXMLDOMNodeList_get_item( root_list, 1, &pr_node );
3608     ok( r == S_OK, "ret %08x\n", r);
3609
3610     r = IXMLDOMNode_get_attributes( pr_node, &pr_attrs );
3611     ok( r == S_OK, "ret %08x\n", r);
3612
3613     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3614     ok( r == S_OK, "ret %08x\n", r);
3615     ok( len == 3, "length %d\n", len);
3616
3617     removed_node = (void*)0xdeadbeef;
3618     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, NULL, &removed_node);
3619     ok ( r == E_INVALIDARG, "ret %08x\n", r);
3620     ok ( removed_node == (void*)0xdeadbeef, "got %p\n", removed_node);
3621
3622     removed_node = (void*)0xdeadbeef;
3623     str = SysAllocString(szvr);
3624     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node);
3625     ok ( r == S_OK, "ret %08x\n", r);
3626
3627     removed_node2 = (void*)0xdeadbeef;
3628     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node2);
3629     ok ( r == S_FALSE, "ret %08x\n", r);
3630     ok ( removed_node2 == NULL, "got %p\n", removed_node2 );
3631
3632     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3633     ok( r == S_OK, "ret %08x\n", r);
3634     ok( len == 2, "length %d\n", len);
3635
3636     r = IXMLDOMNamedNodeMap_setNamedItem( pr_attrs, removed_node, NULL);
3637     ok ( r == S_OK, "ret %08x\n", r);
3638     IXMLDOMNode_Release(removed_node);
3639
3640     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3641     ok( r == S_OK, "ret %08x\n", r);
3642     ok( len == 3, "length %d\n", len);
3643
3644     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
3645     ok ( r == S_OK, "ret %08x\n", r);
3646
3647     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3648     ok( r == S_OK, "ret %08x\n", r);
3649     ok( len == 2, "length %d\n", len);
3650
3651     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
3652     ok ( r == S_FALSE, "ret %08x\n", r);
3653
3654     SysFreeString(str);
3655
3656     IXMLDOMNamedNodeMap_Release( pr_attrs );
3657     IXMLDOMNode_Release( pr_node );
3658     IXMLDOMNodeList_Release( root_list );
3659     IXMLDOMElement_Release( element );
3660     IXMLDOMDocument_Release( doc );
3661
3662     free_bstrs();
3663 }
3664
3665 #define test_IObjectSafety_set(p, r, r2, s, m, e, e2) _test_IObjectSafety_set(__LINE__,p, r, r2, s, m, e, e2)
3666 static void _test_IObjectSafety_set(unsigned line, IObjectSafety *safety, HRESULT result,
3667                                     HRESULT result2, DWORD set, DWORD mask, DWORD expected,
3668                                     DWORD expected2)
3669 {
3670     DWORD enabled, supported;
3671     HRESULT hr;
3672
3673     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL, set, mask);
3674     if (result == result2)
3675         ok_(__FILE__,line)(hr == result, "SetInterfaceSafetyOptions: expected %08x, returned %08x\n", result, hr );
3676     else
3677         ok_(__FILE__,line)(broken(hr == result) || hr == result2,
3678            "SetInterfaceSafetyOptions: expected %08x, got %08x\n", result2, hr );
3679
3680     supported = enabled = 0xCAFECAFE;
3681     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3682     ok(hr == S_OK, "ret %08x\n", hr );
3683     if (expected == expected2)
3684         ok_(__FILE__,line)(enabled == expected, "Expected %08x, got %08x\n", expected, enabled);
3685     else
3686         ok_(__FILE__,line)(broken(enabled == expected) || enabled == expected2,
3687            "Expected %08x, got %08x\n", expected2, enabled);
3688
3689     /* reset the safety options */
3690
3691     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
3692             INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER,
3693             0);
3694     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3695
3696     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3697     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3698     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
3699 }
3700
3701 #define test_IObjectSafety_common(s) _test_IObjectSafety_common(__LINE__,s)
3702 static void _test_IObjectSafety_common(unsigned line, IObjectSafety *safety)
3703 {
3704     DWORD enabled = 0, supported = 0;
3705     HRESULT hr;
3706
3707     /* get */
3708     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, NULL, &enabled);
3709     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
3710     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, NULL);
3711     ok_(__FILE__,line)(hr == E_POINTER, "ret %08x\n", hr );
3712
3713     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3714     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3715     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
3716        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
3717         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
3718              "got %08x\n", supported);
3719     ok_(__FILE__,line)(enabled == 0, "Expected 0, got %08x\n", enabled);
3720
3721     /* set -- individual flags */
3722
3723     test_IObjectSafety_set(safety, S_OK, S_OK,
3724         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3725         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER);
3726
3727     test_IObjectSafety_set(safety, S_OK, S_OK,
3728         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA,
3729         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA);
3730
3731     test_IObjectSafety_set(safety, S_OK, S_OK,
3732         INTERFACE_USES_SECURITY_MANAGER, INTERFACE_USES_SECURITY_MANAGER,
3733         0, INTERFACE_USES_SECURITY_MANAGER /* msxml3 SP8+ */);
3734
3735     /* set INTERFACE_USES_DISPEX  */
3736
3737     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
3738         INTERFACE_USES_DISPEX, INTERFACE_USES_DISPEX,
3739         0, 0);
3740
3741     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
3742         INTERFACE_USES_DISPEX, 0,
3743         0, 0);
3744
3745     test_IObjectSafety_set(safety, S_OK, S_OK /* msxml3 SP8+ */,
3746         0, INTERFACE_USES_DISPEX,
3747         0, 0);
3748
3749     /* set option masking */
3750
3751     test_IObjectSafety_set(safety, S_OK, S_OK,
3752         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
3753         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3754         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3755         INTERFACESAFE_FOR_UNTRUSTED_CALLER);
3756
3757     test_IObjectSafety_set(safety, S_OK, S_OK,
3758         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
3759         INTERFACESAFE_FOR_UNTRUSTED_DATA,
3760         INTERFACESAFE_FOR_UNTRUSTED_DATA,
3761         INTERFACESAFE_FOR_UNTRUSTED_DATA);
3762
3763     test_IObjectSafety_set(safety, S_OK, S_OK,
3764         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
3765         INTERFACE_USES_SECURITY_MANAGER,
3766         0,
3767         0);
3768
3769     /* set -- inheriting previous settings */
3770
3771     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
3772                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER,
3773                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER);
3774     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3775     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3776     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3777     ok_(__FILE__,line)(enabled == INTERFACESAFE_FOR_UNTRUSTED_CALLER, "Expected INTERFACESAFE_FOR_UNTRUSTED_CALLER got %08x\n", enabled);
3778     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
3779        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
3780         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
3781              "got %08x\n", supported);
3782
3783     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
3784                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA,
3785                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA);
3786     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3787     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
3788     ok_(__FILE__,line)(hr == S_OK, "ret %08x\n", hr );
3789     ok_(__FILE__,line)(broken(enabled == INTERFACESAFE_FOR_UNTRUSTED_DATA) ||
3790                        enabled == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA),
3791                        "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA) got %08x\n", enabled);
3792     ok_(__FILE__,line)(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
3793        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
3794         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
3795              "got %08x\n", supported);
3796 }
3797
3798 static void test_IXMLDOMDocument2(void)
3799 {
3800     static const WCHAR emptyW[] = {0};
3801     IXMLDOMDocument2 *doc2, *dtddoc2;
3802     IXMLDOMDocument *doc;
3803     IXMLDOMParseError* err;
3804     IDispatchEx *dispex;
3805     VARIANT_BOOL b;
3806     VARIANT var;
3807     HRESULT r;
3808     LONG res;
3809
3810     doc = create_document(&IID_IXMLDOMDocument);
3811     if (!doc) return;
3812
3813     dtddoc2 = create_document(&IID_IXMLDOMDocument2);
3814     if (!dtddoc2)
3815     {
3816         IXMLDOMDocument_Release(doc);
3817         return;
3818     }
3819
3820     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
3821     ok( r == S_OK, "ret %08x\n", r );
3822     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
3823
3824     ole_expect(IXMLDOMDocument2_get_readyState(doc2, NULL), E_INVALIDARG);
3825     ole_check(IXMLDOMDocument2_get_readyState(doc2, &res));
3826     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
3827
3828     err = NULL;
3829     ole_expect(IXMLDOMDocument2_validate(doc2, NULL), S_FALSE);
3830     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
3831     ok(err != NULL, "expected a pointer\n");
3832     if (err)
3833     {
3834         res = 0;
3835         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3836         /* XML_E_NOTWF */
3837         ok(res == E_XML_NOTWF, "got %08x\n", res);
3838         IXMLDOMParseError_Release(err);
3839     }
3840
3841     r = IXMLDOMDocument2_loadXML( doc2, _bstr_(complete4A), &b );
3842     ok( r == S_OK, "loadXML failed\n");
3843     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3844
3845     ole_check(IXMLDOMDocument_get_readyState(doc, &res));
3846     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
3847
3848     err = NULL;
3849     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
3850     ok(err != NULL, "expected a pointer\n");
3851     if (err)
3852     {
3853         res = 0;
3854         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3855         /* XML_E_NODTD */
3856         ok(res == E_XML_NODTD, "got %08x\n", res);
3857         IXMLDOMParseError_Release(err);
3858     }
3859
3860     r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
3861     ok( r == S_OK, "ret %08x\n", r );
3862     if(r == S_OK)
3863     {
3864         IDispatchEx_Release(dispex);
3865     }
3866
3867     /* we will check if the variant got cleared */
3868     IXMLDOMDocument2_AddRef(doc2);
3869     EXPECT_REF(doc2, 3); /* doc, doc2, AddRef*/
3870
3871     V_VT(&var) = VT_UNKNOWN;
3872     V_UNKNOWN(&var) = (IUnknown *)doc2;
3873
3874     /* invalid calls */
3875     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
3876     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
3877     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
3878
3879     /* valid call */
3880     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
3881     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
3882     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
3883     V_VT(&var) = VT_R4;
3884
3885     /* the variant didn't get cleared*/
3886     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
3887
3888     /* setProperty tests */
3889     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
3890     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
3891     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
3892     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
3893     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
3894     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
3895
3896     V_VT(&var) = VT_BSTR;
3897     V_BSTR(&var) = SysAllocString(emptyW);
3898     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
3899     ok(r == S_OK, "got 0x%08x\n", r);
3900     VariantClear(&var);
3901
3902     V_VT(&var) = VT_I2;
3903     V_I2(&var) = 0;
3904     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
3905     ok(r == E_FAIL, "got 0x%08x\n", r);
3906
3907     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
3908     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
3909     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
3910     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
3911
3912     IXMLDOMDocument2_Release( doc2 );
3913     IXMLDOMDocument_Release( doc );
3914
3915     /* DTD validation */
3916     ole_check(IXMLDOMDocument2_put_validateOnParse(dtddoc2, VARIANT_FALSE));
3917     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML), &b));
3918     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3919     err = NULL;
3920     ole_check(IXMLDOMDocument2_validate(dtddoc2, &err));
3921     ok(err != NULL, "expected pointer\n");
3922     if (err)
3923     {
3924         res = 0;
3925         ole_expect(IXMLDOMParseError_get_errorCode(err, &res), S_FALSE);
3926         ok(res == 0, "got %08x\n", res);
3927         IXMLDOMParseError_Release(err);
3928     }
3929
3930     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0D), &b));
3931     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3932     err = NULL;
3933     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3934     ok(err != NULL, "expected pointer\n");
3935     if (err)
3936     {
3937         res = 0;
3938         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3939         /* XML_ELEMENT_UNDECLARED */
3940         todo_wine ok(res == 0xC00CE00D, "got %08x\n", res);
3941         IXMLDOMParseError_Release(err);
3942     }
3943
3944     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0E), &b));
3945     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3946     err = NULL;
3947     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3948     ok(err != NULL, "expected pointer\n");
3949     if (err)
3950     {
3951         res = 0;
3952         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3953         /* XML_ELEMENT_ID_NOT_FOUND */
3954         todo_wine ok(res == 0xC00CE00E, "got %08x\n", res);
3955         IXMLDOMParseError_Release(err);
3956     }
3957
3958     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_11), &b));
3959     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3960     err = NULL;
3961     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3962     ok(err != NULL, "expected pointer\n");
3963     if (err)
3964     {
3965         res = 0;
3966         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3967         /* XML_EMPTY_NOT_ALLOWED */
3968         todo_wine ok(res == 0xC00CE011, "got %08x\n", res);
3969         IXMLDOMParseError_Release(err);
3970     }
3971
3972     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_13), &b));
3973     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3974     err = NULL;
3975     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3976     ok(err != NULL, "expected pointer\n");
3977     if (err)
3978     {
3979         res = 0;
3980         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3981         /* XML_ROOT_NAME_MISMATCH */
3982         todo_wine ok(res == 0xC00CE013, "got %08x\n", res);
3983         IXMLDOMParseError_Release(err);
3984     }
3985
3986     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_14), &b));
3987     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3988     err = NULL;
3989     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3990     ok(err != NULL, "expected pointer\n");
3991     if (err)
3992     {
3993         res = 0;
3994         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3995         /* XML_INVALID_CONTENT */
3996         todo_wine ok(res == 0xC00CE014, "got %08x\n", res);
3997         IXMLDOMParseError_Release(err);
3998     }
3999
4000     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_15), &b));
4001     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4002     err = NULL;
4003     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4004     ok(err != NULL, "expected pointer\n");
4005     if (err)
4006     {
4007         res = 0;
4008         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4009         /* XML_ATTRIBUTE_NOT_DEFINED */
4010         todo_wine ok(res == 0xC00CE015, "got %08x\n", res);
4011         IXMLDOMParseError_Release(err);
4012     }
4013
4014     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_16), &b));
4015     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4016     err = NULL;
4017     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4018     ok(err != NULL, "expected pointer\n");
4019     if (err)
4020     {
4021         res = 0;
4022         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4023         /* XML_ATTRIBUTE_FIXED */
4024         todo_wine ok(res == 0xC00CE016, "got %08x\n", res);
4025         IXMLDOMParseError_Release(err);
4026     }
4027
4028     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_17), &b));
4029     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4030     err = NULL;
4031     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4032     ok(err != NULL, "expected pointer\n");
4033     if (err)
4034     {
4035         res = 0;
4036         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4037         /* XML_ATTRIBUTE_VALUE */
4038         todo_wine ok(res == 0xC00CE017, "got %08x\n", res);
4039         IXMLDOMParseError_Release(err);
4040     }
4041
4042     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_18), &b));
4043     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4044     err = NULL;
4045     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4046     ok(err != NULL, "expected pointer\n");
4047     if (err)
4048     {
4049         res = 0;
4050         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4051         /* XML_ILLEGAL_TEXT */
4052         todo_wine ok(res == 0xC00CE018, "got %08x\n", res);
4053         IXMLDOMParseError_Release(err);
4054     }
4055
4056     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_20), &b));
4057     ok( b == VARIANT_TRUE, "failed to load XML string\n");
4058     err = NULL;
4059     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
4060     ok(err != NULL, "expected pointer\n");
4061     if (err)
4062     {
4063         res = 0;
4064         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
4065         /* XML_REQUIRED_ATTRIBUTE_MISSING */
4066         todo_wine ok(res == 0xC00CE020, "got %08x\n", res);
4067         IXMLDOMParseError_Release(err);
4068     }
4069
4070     IXMLDOMDocument2_Release( dtddoc2 );
4071     free_bstrs();
4072 }
4073
4074 #define helper_ole_check(expr) { \
4075     HRESULT r = expr; \
4076     ok_(__FILE__, line)(r == S_OK, "=> %i: " #expr " returned %08x\n", __LINE__, r); \
4077 }
4078
4079 #define helper_expect_list_and_release(list, expstr) { \
4080     char *str = list_to_string(list); \
4081     ok_(__FILE__, line)(strcmp(str, expstr)==0, "=> %i: Invalid node list: %s, expected %s\n", __LINE__, str, expstr); \
4082     if (list) IXMLDOMNodeList_Release(list); \
4083 }
4084
4085 #define helper_expect_bstr_and_release(bstr, str) { \
4086     ok_(__FILE__, line)(lstrcmpW(bstr, _bstr_(str)) == 0, \
4087        "=> %i: got %s\n", __LINE__, wine_dbgstr_w(bstr)); \
4088     SysFreeString(bstr); \
4089 }
4090
4091 #define check_ws_ignored(doc, str) _check_ws_ignored(__LINE__, doc, str)
4092 static inline void _check_ws_ignored(int line, IXMLDOMDocument2* doc, char const* str)
4093 {
4094     IXMLDOMNode *node1, *node2;
4095     IXMLDOMNodeList *list;
4096     BSTR bstr;
4097
4098     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4099     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
4100     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
4101     helper_ole_check(IXMLDOMNodeList_reset(list));
4102     helper_expect_list_and_release(list, "E1.E5.E1.E2.D1 E2.E5.E1.E2.D1");
4103
4104     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
4105     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");
4106     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
4107     if (str)
4108     {
4109         helper_expect_bstr_and_release(bstr, str);
4110     }
4111     else
4112     {
4113         helper_expect_bstr_and_release(bstr, "This is a description.");
4114     }
4115     IXMLDOMNode_Release(node1);
4116
4117     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
4118     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");
4119     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
4120     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
4121     IXMLDOMNode_Release(node2);
4122 }
4123
4124 #define check_ws_preserved(doc, str) _check_ws_preserved(__LINE__, doc, str)
4125 static inline void _check_ws_preserved(int line, IXMLDOMDocument2* doc, char const* str)
4126 {
4127     IXMLDOMNode *node1, *node2;
4128     IXMLDOMNodeList *list;
4129     BSTR bstr;
4130
4131     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4132     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
4133     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
4134     helper_ole_check(IXMLDOMNodeList_reset(list));
4135     helper_expect_list_and_release(list, "E2.E10.E2.E2.D1 E4.E10.E2.E2.D1");
4136
4137     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
4138     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");
4139     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
4140     if (str)
4141     {
4142         helper_expect_bstr_and_release(bstr, str);
4143     }
4144     else
4145     {
4146         helper_expect_bstr_and_release(bstr, "\n                This is a description. \n            ");
4147     }
4148     IXMLDOMNode_Release(node1);
4149
4150     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
4151     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");
4152     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
4153     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
4154     IXMLDOMNode_Release(node2);
4155 }
4156
4157 static void test_whitespace(void)
4158 {
4159     VARIANT_BOOL b;
4160     IXMLDOMDocument2 *doc1, *doc2, *doc3, *doc4;
4161
4162     doc1 = create_document(&IID_IXMLDOMDocument2);
4163     doc2 = create_document(&IID_IXMLDOMDocument2);
4164     if (!doc1 || !doc2) return;
4165
4166     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_TRUE));
4167     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4168     ok(b == VARIANT_FALSE, "expected false\n");
4169     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4170     ok(b == VARIANT_TRUE, "expected true\n");
4171
4172     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4173     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4174     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4175     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4176
4177     /* switch to XPath */
4178     ole_check(IXMLDOMDocument2_setProperty(doc1, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4179     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4180
4181     check_ws_ignored(doc1, NULL);
4182     check_ws_preserved(doc2, NULL);
4183
4184     /* new instances copy the property */
4185     ole_check(IXMLDOMDocument2_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**) &doc3));
4186     ole_check(IXMLDOMDocument2_QueryInterface(doc2, &IID_IXMLDOMDocument2, (void**) &doc4));
4187
4188     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4189     ok(b == VARIANT_FALSE, "expected false\n");
4190     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4191     ok(b == VARIANT_TRUE, "expected true\n");
4192
4193     check_ws_ignored(doc3, NULL);
4194     check_ws_preserved(doc4, NULL);
4195
4196     /* setting after loading xml affects trimming of leading/trailing ws only */
4197     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_TRUE));
4198     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_FALSE));
4199
4200     /* the trailing "\n            " isn't there, because it was ws-only node */
4201     check_ws_ignored(doc1, "\n                This is a description. ");
4202     check_ws_preserved(doc2, "This is a description.");
4203
4204     /* it takes effect on reload */
4205     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4206     ok(b == VARIANT_TRUE, "expected true\n");
4207     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4208     ok(b == VARIANT_FALSE, "expected false\n");
4209
4210     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4211     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4212     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4213     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4214
4215     check_ws_preserved(doc1, NULL);
4216     check_ws_ignored(doc2, NULL);
4217
4218     /* other instances follow suit */
4219     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4220     ok(b == VARIANT_TRUE, "expected true\n");
4221     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4222     ok(b == VARIANT_FALSE, "expected false\n");
4223
4224     check_ws_preserved(doc3, NULL);
4225     check_ws_ignored(doc4, NULL);
4226
4227     IXMLDOMDocument2_Release(doc1);
4228     IXMLDOMDocument2_Release(doc2);
4229     IXMLDOMDocument2_Release(doc3);
4230     IXMLDOMDocument2_Release(doc4);
4231     free_bstrs();
4232 }
4233
4234 typedef struct {
4235     const GUID *clsid;
4236     const char *name;
4237     const char *ns;
4238     HRESULT hr;
4239 } selection_ns_t;
4240
4241 /* supposed to be tested with szExampleXML */
4242 static const selection_ns_t selection_ns_data[] = {
4243     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4244     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4245     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4246     { &CLSID_DOMDocument,   "CLSID_DOMDocument",   "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4247
4248     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4249     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4250     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4251     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2",  "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4252
4253     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4254     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4255     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4256     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4257
4258     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4259     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4260     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4261     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4262
4263     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\txmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4264     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "\n\rxmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4265     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", " xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'", S_OK },
4266     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' ", S_OK },
4267
4268     { NULL }
4269 };
4270
4271 static void test_XPath(void)
4272 {
4273     const selection_ns_t *ptr = selection_ns_data;
4274     VARIANT var;
4275     VARIANT_BOOL b;
4276     IXMLDOMDocument2 *doc;
4277     IXMLDOMDocument *doc2;
4278     IXMLDOMNode *rootNode;
4279     IXMLDOMNode *elem1Node;
4280     IXMLDOMNode *node;
4281     IXMLDOMNodeList *list;
4282     IXMLDOMElement *elem;
4283     IXMLDOMAttribute *attr;
4284     DOMNodeType type;
4285     HRESULT hr;
4286     LONG len;
4287     BSTR str;
4288
4289     doc = create_document(&IID_IXMLDOMDocument2);
4290     if (!doc) return;
4291
4292     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4293     EXPECT_HR(hr, S_OK);
4294     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4295
4296     /* switch to XPath */
4297     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4298
4299     /* some simple queries*/
4300     EXPECT_REF(doc, 1);
4301     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4302     EXPECT_HR(hr, S_OK);
4303     EXPECT_REF(doc, 1);
4304     EXPECT_LIST_LEN(list, 1);
4305
4306     EXPECT_REF(list, 1);
4307     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4308     EXPECT_HR(hr, S_OK);
4309     EXPECT_REF(list, 1);
4310     EXPECT_REF(rootNode, 1);
4311
4312     hr = IXMLDOMNodeList_reset(list);
4313     EXPECT_HR(hr, S_OK);
4314     expect_list_and_release(list, "E2.D1");
4315
4316 if (0)
4317 {
4318     /* namespace:: axis test is disabled until namespace definitions
4319        are supported as attribute nodes, currently it's another node type */
4320     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("/root/namespace::*"), &list);
4321     EXPECT_HR(hr, S_OK);
4322     len = -1;
4323     hr = IXMLDOMNodeList_get_length(list, &len);
4324     EXPECT_HR(hr, S_OK);
4325     ok(len == 2, "got %d\n", len);
4326
4327     hr = IXMLDOMNodeList_nextNode(list, &node);
4328     EXPECT_HR(hr, S_OK);
4329     type = NODE_INVALID;
4330     hr = IXMLDOMNode_get_nodeType(node, &type);
4331     EXPECT_HR(hr, S_OK);
4332     ok(type == NODE_ATTRIBUTE, "got %d\n", type);
4333     IXMLDOMNode_Release(node);
4334
4335     IXMLDOMNodeList_Release(list);
4336 }
4337
4338     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//c"), &list));
4339     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
4340
4341     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//c[@type]"), &list));
4342     expect_list_and_release(list, "E3.E2.E2.D1");
4343
4344     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
4345     /* using get_item for query results advances the position */
4346     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
4347     expect_node(node, "E2.E2.D1");
4348     IXMLDOMNode_Release(node);
4349     ole_check(IXMLDOMNodeList_nextNode(list, &node));
4350     expect_node(node, "E4.E2.D1");
4351     IXMLDOMNode_Release(node);
4352     ole_check(IXMLDOMNodeList_reset(list));
4353     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
4354
4355     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
4356     expect_list_and_release(list, "E2.D1");
4357
4358     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
4359     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
4360     ole_check(IXMLDOMNodeList_reset(list));
4361     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
4362
4363     /* select an attribute */
4364     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
4365     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
4366
4367     /* would evaluate to a number */
4368     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
4369     /* would evaluate to a boolean */
4370     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
4371     /* would evaluate to a string */
4372     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
4373
4374     /* no results */
4375     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
4376     expect_list_and_release(list, "");
4377     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("elem//c"), &list));
4378     expect_list_and_release(list, "");
4379     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem[4]"), &list));
4380     expect_list_and_release(list, "");
4381     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[0]"), &list));
4382     expect_list_and_release(list, "");
4383
4384     /* foo undeclared in document node */
4385     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4386     /* undeclared in <root> node */
4387     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
4388     /* undeclared in <elem> node */
4389     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
4390     /* but this trick can be used */
4391     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
4392     expect_list_and_release(list, "E3.E4.E2.D1");
4393
4394     /* it has to be declared in SelectionNamespaces */
4395     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4396         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
4397
4398     /* now the namespace can be used */
4399     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list));
4400     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4401     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
4402     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4403     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
4404     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4405     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
4406     expect_list_and_release(list, "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1");
4407
4408     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
4409     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4410         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
4411
4412     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4413
4414     VariantInit(&var);
4415     ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
4416     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
4417     if (V_VT(&var) == VT_BSTR)
4418         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
4419
4420     /* extra attributes - same thing*/
4421     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4422         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
4423     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4424
4425     IXMLDOMNode_Release(rootNode);
4426     IXMLDOMNode_Release(elem1Node);
4427
4428     /* alter document with already built list */
4429     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4430     EXPECT_HR(hr, S_OK);
4431     EXPECT_LIST_LEN(list, 1);
4432
4433     hr = IXMLDOMDocument2_get_lastChild(doc, &rootNode);
4434     EXPECT_HR(hr, S_OK);
4435     EXPECT_REF(rootNode, 1);
4436     EXPECT_REF(doc, 1);
4437
4438     hr = IXMLDOMDocument2_removeChild(doc, rootNode, NULL);
4439     EXPECT_HR(hr, S_OK);
4440     IXMLDOMNode_Release(rootNode);
4441
4442     EXPECT_LIST_LEN(list, 1);
4443
4444     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4445     EXPECT_HR(hr, S_OK);
4446     EXPECT_REF(rootNode, 1);
4447
4448     IXMLDOMNodeList_Release(list);
4449
4450     hr = IXMLDOMNode_get_nodeName(rootNode, &str);
4451     EXPECT_HR(hr, S_OK);
4452     ok(!lstrcmpW(str, _bstr_("root")), "got %s\n", wine_dbgstr_w(str));
4453     SysFreeString(str);
4454     IXMLDOMNode_Release(rootNode);
4455
4456     /* alter node from list and get it another time */
4457     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4458     EXPECT_HR(hr, S_OK);
4459     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4460
4461     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4462     EXPECT_HR(hr, S_OK);
4463     EXPECT_LIST_LEN(list, 1);
4464
4465     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4466     EXPECT_HR(hr, S_OK);
4467
4468     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
4469     EXPECT_HR(hr, S_OK);
4470
4471     V_VT(&var) = VT_I2;
4472     V_I2(&var) = 1;
4473     hr = IXMLDOMElement_setAttribute(elem, _bstr_("attrtest"), var);
4474     EXPECT_HR(hr, S_OK);
4475     IXMLDOMElement_Release(elem);
4476     IXMLDOMNode_Release(rootNode);
4477
4478     /* now check attribute to be present */
4479     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4480     EXPECT_HR(hr, S_OK);
4481
4482     hr = IXMLDOMNode_QueryInterface(rootNode, &IID_IXMLDOMElement, (void**)&elem);
4483     EXPECT_HR(hr, S_OK);
4484
4485     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
4486     EXPECT_HR(hr, S_OK);
4487     IXMLDOMAttribute_Release(attr);
4488
4489     IXMLDOMElement_Release(elem);
4490     IXMLDOMNode_Release(rootNode);
4491
4492     /* and now check for attribute in original document */
4493     hr = IXMLDOMDocument2_get_documentElement(doc, &elem);
4494     EXPECT_HR(hr, S_OK);
4495
4496     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attrtest"), &attr);
4497     EXPECT_HR(hr, S_OK);
4498     IXMLDOMAttribute_Release(attr);
4499
4500     IXMLDOMElement_Release(elem);
4501
4502     /* attach node from list to another document */
4503     doc2 = create_document(&IID_IXMLDOMDocument);
4504
4505     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4506     EXPECT_HR(hr, S_OK);
4507     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4508
4509     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root"), &list);
4510     EXPECT_HR(hr, S_OK);
4511     EXPECT_LIST_LEN(list, 1);
4512
4513     hr = IXMLDOMNodeList_get_item(list, 0, &rootNode);
4514     EXPECT_HR(hr, S_OK);
4515     EXPECT_REF(rootNode, 1);
4516
4517     hr = IXMLDOMDocument_appendChild(doc2, rootNode, NULL);
4518     EXPECT_HR(hr, S_OK);
4519     EXPECT_REF(rootNode, 1);
4520     EXPECT_REF(doc2, 1);
4521     EXPECT_REF(list, 1);
4522
4523     EXPECT_LIST_LEN(list, 1);
4524
4525     IXMLDOMNode_Release(rootNode);
4526     IXMLDOMNodeList_Release(list);
4527     IXMLDOMDocument_Release(doc2);
4528     IXMLDOMDocument2_Release(doc);
4529
4530     while (ptr->clsid)
4531     {
4532         hr = CoCreateInstance(ptr->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
4533         if (hr != S_OK)
4534         {
4535             win_skip("can't create instance of %s\n", ptr->name);
4536             ptr++;
4537             continue;
4538         }
4539
4540         hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
4541         EXPECT_HR(hr, S_OK);
4542         ok(b == VARIANT_TRUE, "failed to load, %s\n", ptr->name);
4543
4544         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath"));
4545         EXPECT_HR(hr, S_OK);
4546
4547         V_VT(&var) = VT_BSTR;
4548         V_BSTR(&var) = _bstr_(ptr->ns);
4549
4550         hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), var);
4551         ok(hr == ptr->hr, "got 0x%08x, for %s, %s\n", hr, ptr->name, ptr->ns);
4552
4553         V_VT(&var) = VT_EMPTY;
4554         hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var);
4555         EXPECT_HR(hr, S_OK);
4556         ok(V_VT(&var) == VT_BSTR, "got wrong property type %d\n", V_VT(&var));
4557         ok(!lstrcmpW(V_BSTR(&var), _bstr_(ptr->ns)), "got wrong value %s\n", wine_dbgstr_w(V_BSTR(&var)));
4558         VariantClear(&var);
4559
4560         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("root//test:c"), &list);
4561         EXPECT_HR(hr, S_OK);
4562         if (hr == S_OK)
4563             expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4564
4565         IXMLDOMDocument2_Release(doc);
4566         ptr++;
4567         free_bstrs();
4568     }
4569
4570     free_bstrs();
4571 }
4572
4573 static void test_cloneNode(void )
4574 {
4575     IXMLDOMDocument *doc, *doc2;
4576     VARIANT_BOOL b;
4577     IXMLDOMNodeList *pList;
4578     IXMLDOMNamedNodeMap *mapAttr;
4579     LONG length, length1;
4580     LONG attr_cnt, attr_cnt1;
4581     IXMLDOMNode *node, *attr;
4582     IXMLDOMNode *node_clone;
4583     IXMLDOMNode *node_first;
4584     HRESULT hr;
4585
4586     doc = create_document(&IID_IXMLDOMDocument);
4587     if (!doc) return;
4588
4589     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b));
4590     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4591
4592     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc/pr"), &node);
4593     ok( hr == S_OK, "ret %08x\n", hr );
4594     ok( node != NULL, "node %p\n", node );
4595
4596     /* Check invalid parameter */
4597     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
4598     ok( hr == E_INVALIDARG, "ret %08x\n", hr );
4599
4600     /* All Children */
4601     hr = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
4602     ok( hr == S_OK, "ret %08x\n", hr );
4603     ok( node_clone != NULL, "node %p\n", node );
4604
4605     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
4606     ok( hr == S_OK, "ret %08x\n", hr );
4607     hr = IXMLDOMNode_get_ownerDocument(node_clone, &doc2);
4608     ok( hr == S_OK, "ret %08x\n", hr );
4609     IXMLDOMDocument_Release(doc2);
4610     IXMLDOMNode_Release(node_first);
4611
4612     hr = IXMLDOMNode_get_childNodes(node, &pList);
4613     ok( hr == S_OK, "ret %08x\n", hr );
4614     length = 0;
4615     hr = IXMLDOMNodeList_get_length(pList, &length);
4616     ok( hr == S_OK, "ret %08x\n", hr );
4617     ok(length == 1, "got %d\n", length);
4618     IXMLDOMNodeList_Release(pList);
4619
4620     hr = IXMLDOMNode_get_attributes(node, &mapAttr);
4621     ok( hr == S_OK, "ret %08x\n", hr );
4622     attr_cnt = 0;
4623     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt);
4624     ok( hr == S_OK, "ret %08x\n", hr );
4625     ok(attr_cnt == 3, "got %d\n", attr_cnt);
4626     IXMLDOMNamedNodeMap_Release(mapAttr);
4627
4628     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
4629     ok( hr == S_OK, "ret %08x\n", hr );
4630     length1 = 0;
4631     hr = IXMLDOMNodeList_get_length(pList, &length1);
4632     ok(length1 == 1, "got %d\n", length1);
4633     ok( hr == S_OK, "ret %08x\n", hr );
4634     IXMLDOMNodeList_Release(pList);
4635
4636     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
4637     ok( hr == S_OK, "ret %08x\n", hr );
4638     attr_cnt1 = 0;
4639     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
4640     ok( hr == S_OK, "ret %08x\n", hr );
4641     ok(attr_cnt1 == 3, "got %d\n", attr_cnt1);
4642     /* now really get some attributes from cloned element */
4643     attr = NULL;
4644     hr = IXMLDOMNamedNodeMap_getNamedItem(mapAttr, _bstr_("id"), &attr);
4645     ok(hr == S_OK, "ret %08x\n", hr);
4646     IXMLDOMNode_Release(attr);
4647     IXMLDOMNamedNodeMap_Release(mapAttr);
4648
4649     ok(length == length1, "wrong Child count (%d, %d)\n", length, length1);
4650     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
4651     IXMLDOMNode_Release(node_clone);
4652
4653     /* No Children */
4654     hr = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
4655     ok( hr == S_OK, "ret %08x\n", hr );
4656     ok( node_clone != NULL, "node %p\n", node );
4657
4658     hr = IXMLDOMNode_get_firstChild(node_clone, &node_first);
4659     ok(hr == S_FALSE, "ret %08x\n", hr );
4660
4661     hr = IXMLDOMNode_get_childNodes(node_clone, &pList);
4662     ok(hr == S_OK, "ret %08x\n", hr );
4663     hr = IXMLDOMNodeList_get_length(pList, &length1);
4664     ok(hr == S_OK, "ret %08x\n", hr );
4665     ok( length1 == 0, "Length should be 0 (%d)\n", length1);
4666     IXMLDOMNodeList_Release(pList);
4667
4668     hr = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
4669     ok(hr == S_OK, "ret %08x\n", hr );
4670     hr = IXMLDOMNamedNodeMap_get_length(mapAttr, &attr_cnt1);
4671     ok(hr == S_OK, "ret %08x\n", hr );
4672     ok(attr_cnt1 == 3, "Attribute count should be 3 (%d)\n", attr_cnt1);
4673     IXMLDOMNamedNodeMap_Release(mapAttr);
4674
4675     ok(length != length1, "wrong Child count (%d, %d)\n", length, length1);
4676     ok(attr_cnt == attr_cnt1, "wrong Attribute count (%d, %d)\n", attr_cnt, attr_cnt1);
4677     IXMLDOMNode_Release(node_clone);
4678
4679     IXMLDOMNode_Release(node);
4680     IXMLDOMDocument_Release(doc);
4681     free_bstrs();
4682 }
4683
4684 static void test_xmlTypes(void)
4685 {
4686     IXMLDOMDocument *doc;
4687     IXMLDOMElement *pRoot;
4688     HRESULT hr;
4689     IXMLDOMComment *pComment;
4690     IXMLDOMElement *pElement;
4691     IXMLDOMAttribute *pAttribute;
4692     IXMLDOMNamedNodeMap *pAttribs;
4693     IXMLDOMCDATASection *pCDataSec;
4694     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
4695     IXMLDOMDocumentFragment *pDocFrag = NULL;
4696     IXMLDOMEntityReference *pEntityRef = NULL;
4697     BSTR str;
4698     IXMLDOMNode *pNextChild;
4699     VARIANT v;
4700     LONG len = 0;
4701
4702     doc = create_document(&IID_IXMLDOMDocument);
4703     if (!doc) return;
4704
4705     pNextChild = (void*)0xdeadbeef;
4706     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
4707     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4708
4709     pNextChild = (void*)0xdeadbeef;
4710     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
4711     ok(hr == S_FALSE, "ret %08x\n", hr );
4712     ok(pNextChild == NULL, "pDocChild not NULL\n");
4713
4714     /* test previous Sibling */
4715     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
4716     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4717
4718     pNextChild = (void*)0xdeadbeef;
4719     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
4720     ok(hr == S_FALSE, "ret %08x\n", hr );
4721     ok(pNextChild == NULL, "pNextChild not NULL\n");
4722
4723     /* test get_dataType */
4724     V_VT(&v) = VT_EMPTY;
4725     hr = IXMLDOMDocument_get_dataType(doc, &v);
4726     ok(hr == S_FALSE, "ret %08x\n", hr );
4727     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
4728     VariantClear(&v);
4729
4730     /* test implementation */
4731     hr = IXMLDOMDocument_get_implementation(doc, NULL);
4732     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4733
4734     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
4735     ok(hr == S_OK, "ret %08x\n", hr );
4736     if(hr == S_OK)
4737     {
4738         VARIANT_BOOL hasFeature = VARIANT_TRUE;
4739         BSTR sEmpty = SysAllocStringLen(NULL, 0);
4740
4741         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
4742         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4743
4744         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
4745         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4746
4747         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
4748         ok(hr == S_OK, "ret %08x\n", hr );
4749         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4750
4751         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
4752         ok(hr == S_OK, "ret %08x\n", hr );
4753         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
4754
4755         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
4756         ok(hr == S_OK, "ret %08x\n", hr );
4757         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
4758
4759         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
4760         ok(hr == S_OK, "ret %08x\n", hr );
4761         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4762
4763         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
4764         ok(hr == S_OK, "ret %08x\n", hr );
4765         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4766
4767         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
4768         ok(hr == S_OK, "ret %08x\n", hr );
4769         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4770
4771         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
4772         ok(hr == S_OK, "ret %08x\n", hr );
4773         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4774
4775         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
4776         ok(hr == S_OK, "ret %08x\n", hr );
4777         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4778
4779         SysFreeString(sEmpty);
4780         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
4781     }
4782
4783     pRoot = (IXMLDOMElement*)0x1;
4784     hr = IXMLDOMDocument_createElement(doc, NULL, &pRoot);
4785     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4786     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
4787
4788     pRoot = (IXMLDOMElement*)0x1;
4789     hr = IXMLDOMDocument_createElement(doc, _bstr_(""), &pRoot);
4790     ok(hr == E_FAIL, "ret %08x\n", hr );
4791     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
4792
4793     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
4794     ok(hr == S_OK, "ret %08x\n", hr );
4795     if(hr == S_OK)
4796     {
4797         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
4798         ok(hr == S_OK, "ret %08x\n", hr );
4799         if(hr == S_OK)
4800         {
4801             /* Comment */
4802             str = SysAllocString(szComment);
4803             hr = IXMLDOMDocument_createComment(doc, str, &pComment);
4804             SysFreeString(str);
4805             ok(hr == S_OK, "ret %08x\n", hr );
4806             if(hr == S_OK)
4807             {
4808                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
4809                 ok(hr == S_OK, "ret %08x\n", hr );
4810
4811                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
4812                 ok(hr == S_OK, "ret %08x\n", hr );
4813                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
4814                 SysFreeString(str);
4815
4816                 hr = IXMLDOMComment_get_xml(pComment, &str);
4817                 ok(hr == S_OK, "ret %08x\n", hr );
4818                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
4819                 SysFreeString(str);
4820
4821                 /* put data Tests */
4822                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
4823                 ok(hr == S_OK, "ret %08x\n", hr );
4824
4825                 /* get data Tests */
4826                 hr = IXMLDOMComment_get_data(pComment, &str);
4827                 ok(hr == S_OK, "ret %08x\n", hr );
4828                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
4829                 SysFreeString(str);
4830
4831                 /* Confirm XML text is good */
4832                 hr = IXMLDOMComment_get_xml(pComment, &str);
4833                 ok(hr == S_OK, "ret %08x\n", hr );
4834                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
4835                 SysFreeString(str);
4836
4837                 /* Confirm we get the put_data Text back */
4838                 hr = IXMLDOMComment_get_text(pComment, &str);
4839                 ok(hr == S_OK, "ret %08x\n", hr );
4840                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
4841                 SysFreeString(str);
4842
4843                 /* test length property */
4844                 hr = IXMLDOMComment_get_length(pComment, &len);
4845                 ok(hr == S_OK, "ret %08x\n", hr );
4846                 ok(len == 21, "expected 21 got %d\n", len);
4847
4848                 /* test substringData */
4849                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
4850                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4851
4852                 /* test substringData - Invalid offset */
4853                 str = (BSTR)&szElement;
4854                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
4855                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4856                 ok( str == NULL, "incorrect string\n");
4857
4858                 /* test substringData - Invalid offset */
4859                 str = (BSTR)&szElement;
4860                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
4861                 ok(hr == S_FALSE, "ret %08x\n", hr );
4862                 ok( str == NULL, "incorrect string\n");
4863
4864                 /* test substringData - Invalid size */
4865                 str = (BSTR)&szElement;
4866                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
4867                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4868                 ok( str == NULL, "incorrect string\n");
4869
4870                 /* test substringData - Invalid size */
4871                 str = (BSTR)&szElement;
4872                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
4873                 ok(hr == S_FALSE, "ret %08x\n", hr );
4874                 ok( str == NULL, "incorrect string\n");
4875
4876                 /* test substringData - Start of string */
4877                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
4878                 ok(hr == S_OK, "ret %08x\n", hr );
4879                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
4880                 SysFreeString(str);
4881
4882                 /* test substringData - Middle of string */
4883                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
4884                 ok(hr == S_OK, "ret %08x\n", hr );
4885                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
4886                 SysFreeString(str);
4887
4888                 /* test substringData - End of string */
4889                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
4890                 ok(hr == S_OK, "ret %08x\n", hr );
4891                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
4892                 SysFreeString(str);
4893
4894                 /* test appendData */
4895                 hr = IXMLDOMComment_appendData(pComment, NULL);
4896                 ok(hr == S_OK, "ret %08x\n", hr );
4897
4898                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
4899                 ok(hr == S_OK, "ret %08x\n", hr );
4900
4901                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
4902                 ok(hr == S_OK, "ret %08x\n", hr );
4903
4904                 hr = IXMLDOMComment_get_text(pComment, &str);
4905                 ok(hr == S_OK, "ret %08x\n", hr );
4906                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4907                 SysFreeString(str);
4908
4909                 /* test insertData */
4910                 str = SysAllocStringLen(NULL, 0);
4911                 hr = IXMLDOMComment_insertData(pComment, -1, str);
4912                 ok(hr == S_OK, "ret %08x\n", hr );
4913
4914                 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
4915                 ok(hr == S_OK, "ret %08x\n", hr );
4916
4917                 hr = IXMLDOMComment_insertData(pComment, 1000, str);
4918                 ok(hr == S_OK, "ret %08x\n", hr );
4919
4920                 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
4921                 ok(hr == S_OK, "ret %08x\n", hr );
4922
4923                 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
4924                 ok(hr == S_OK, "ret %08x\n", hr );
4925
4926                 hr = IXMLDOMComment_insertData(pComment, 0, str);
4927                 ok(hr == S_OK, "ret %08x\n", hr );
4928                 SysFreeString(str);
4929
4930                 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
4931                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4932
4933                 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
4934                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4935
4936                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
4937                 ok(hr == S_OK, "ret %08x\n", hr );
4938
4939                 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
4940                 ok(hr == S_OK, "ret %08x\n", hr );
4941
4942                 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
4943                 ok(hr == S_OK, "ret %08x\n", hr );
4944
4945                 hr = IXMLDOMComment_get_text(pComment, &str);
4946                 ok(hr == S_OK, "ret %08x\n", hr );
4947                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4948                 SysFreeString(str);
4949
4950                 /* delete data */
4951                 /* invalid arguments */
4952                 hr = IXMLDOMComment_deleteData(pComment, -1, 1);
4953                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4954
4955                 hr = IXMLDOMComment_deleteData(pComment, 0, 0);
4956                 ok(hr == S_OK, "ret %08x\n", hr );
4957
4958                 hr = IXMLDOMComment_deleteData(pComment, 0, -1);
4959                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4960
4961                 hr = IXMLDOMComment_get_length(pComment, &len);
4962                 ok(hr == S_OK, "ret %08x\n", hr );
4963                 ok(len == 43, "expected 43 got %d\n", len);
4964
4965                 hr = IXMLDOMComment_deleteData(pComment, len, 1);
4966                 ok(hr == S_OK, "ret %08x\n", hr );
4967
4968                 hr = IXMLDOMComment_deleteData(pComment, len+1, 1);
4969                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4970
4971                 /* delete from start */
4972                 hr = IXMLDOMComment_deleteData(pComment, 0, 5);
4973                 ok(hr == S_OK, "ret %08x\n", hr );
4974
4975                 hr = IXMLDOMComment_get_length(pComment, &len);
4976                 ok(hr == S_OK, "ret %08x\n", hr );
4977                 ok(len == 38, "expected 38 got %d\n", len);
4978
4979                 hr = IXMLDOMComment_get_text(pComment, &str);
4980                 ok(hr == S_OK, "ret %08x\n", hr );
4981                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4982                 SysFreeString(str);
4983
4984                 /* delete from end */
4985                 hr = IXMLDOMComment_deleteData(pComment, 35, 3);
4986                 ok(hr == S_OK, "ret %08x\n", hr );
4987
4988                 hr = IXMLDOMComment_get_length(pComment, &len);
4989                 ok(hr == S_OK, "ret %08x\n", hr );
4990                 ok(len == 35, "expected 35 got %d\n", len);
4991
4992                 hr = IXMLDOMComment_get_text(pComment, &str);
4993                 ok(hr == S_OK, "ret %08x\n", hr );
4994                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4995                 SysFreeString(str);
4996
4997                 /* delete from inside */
4998                 hr = IXMLDOMComment_deleteData(pComment, 1, 33);
4999                 ok(hr == S_OK, "ret %08x\n", hr );
5000
5001                 hr = IXMLDOMComment_get_length(pComment, &len);
5002                 ok(hr == S_OK, "ret %08x\n", hr );
5003                 ok(len == 2, "expected 2 got %d\n", len);
5004
5005                 hr = IXMLDOMComment_get_text(pComment, &str);
5006                 ok(hr == S_OK, "ret %08x\n", hr );
5007                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5008                 SysFreeString(str);
5009
5010                 /* delete whole data ... */
5011                 hr = IXMLDOMComment_get_length(pComment, &len);
5012                 ok(hr == S_OK, "ret %08x\n", hr );
5013
5014                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5015                 ok(hr == S_OK, "ret %08x\n", hr );
5016                 /* ... and try again with empty string */
5017                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
5018                 ok(hr == S_OK, "ret %08x\n", hr );
5019
5020                 /* ::replaceData() */
5021                 V_VT(&v) = VT_BSTR;
5022                 V_BSTR(&v) = SysAllocString(szstr1);
5023                 hr = IXMLDOMComment_put_nodeValue(pComment, v);
5024                 ok(hr == S_OK, "ret %08x\n", hr );
5025                 VariantClear(&v);
5026
5027                 hr = IXMLDOMComment_replaceData(pComment, 6, 0, NULL);
5028                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5029                 hr = IXMLDOMComment_get_text(pComment, &str);
5030                 ok(hr == S_OK, "ret %08x\n", hr );
5031                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5032                 SysFreeString(str);
5033
5034                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, NULL);
5035                 ok(hr == S_OK, "ret %08x\n", hr );
5036                 hr = IXMLDOMComment_get_text(pComment, &str);
5037                 ok(hr == S_OK, "ret %08x\n", hr );
5038                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5039                 SysFreeString(str);
5040
5041                 /* NULL pointer means delete */
5042                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, NULL);
5043                 ok(hr == S_OK, "ret %08x\n", hr );
5044                 hr = IXMLDOMComment_get_text(pComment, &str);
5045                 ok(hr == S_OK, "ret %08x\n", hr );
5046                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5047                 SysFreeString(str);
5048
5049                 /* empty string means delete */
5050                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_(""));
5051                 ok(hr == S_OK, "ret %08x\n", hr );
5052                 hr = IXMLDOMComment_get_text(pComment, &str);
5053                 ok(hr == S_OK, "ret %08x\n", hr );
5054                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5055                 SysFreeString(str);
5056
5057                 /* zero count means insert */
5058                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, _bstr_("a"));
5059                 ok(hr == S_OK, "ret %08x\n", hr );
5060                 hr = IXMLDOMComment_get_text(pComment, &str);
5061                 ok(hr == S_OK, "ret %08x\n", hr );
5062                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5063                 SysFreeString(str);
5064
5065                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, NULL);
5066                 ok(hr == S_OK, "ret %08x\n", hr );
5067
5068                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("m"));
5069                 ok(hr == S_OK, "ret %08x\n", hr );
5070                 hr = IXMLDOMComment_get_text(pComment, &str);
5071                 ok(hr == S_OK, "ret %08x\n", hr );
5072                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5073                 SysFreeString(str);
5074
5075                 /* nonempty string, count greater than its length */
5076                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, _bstr_("a1.2"));
5077                 ok(hr == S_OK, "ret %08x\n", hr );
5078                 hr = IXMLDOMComment_get_text(pComment, &str);
5079                 ok(hr == S_OK, "ret %08x\n", hr );
5080                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5081                 SysFreeString(str);
5082
5083                 /* nonempty string, count less than its length */
5084                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_("wine"));
5085                 ok(hr == S_OK, "ret %08x\n", hr );
5086                 hr = IXMLDOMComment_get_text(pComment, &str);
5087                 ok(hr == S_OK, "ret %08x\n", hr );
5088                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5089                 SysFreeString(str);
5090
5091                 IXMLDOMComment_Release(pComment);
5092             }
5093
5094             /* Element */
5095             str = SysAllocString(szElement);
5096             hr = IXMLDOMDocument_createElement(doc, str, &pElement);
5097             SysFreeString(str);
5098             ok(hr == S_OK, "ret %08x\n", hr );
5099             if(hr == S_OK)
5100             {
5101                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5102                 ok(hr == S_OK, "ret %08x\n", hr );
5103
5104                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
5105                 ok(hr == S_OK, "ret %08x\n", hr );
5106                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
5107                 SysFreeString(str);
5108
5109                 hr = IXMLDOMElement_get_xml(pElement, &str);
5110                 ok(hr == S_OK, "ret %08x\n", hr );
5111                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
5112                 SysFreeString(str);
5113
5114                 /* Attribute */
5115                 pAttribute = (IXMLDOMAttribute*)0x1;
5116                 hr = IXMLDOMDocument_createAttribute(doc, NULL, &pAttribute);
5117                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5118                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5119
5120                 pAttribute = (IXMLDOMAttribute*)0x1;
5121                 hr = IXMLDOMDocument_createAttribute(doc, _bstr_(""), &pAttribute);
5122                 ok(hr == E_FAIL, "ret %08x\n", hr );
5123                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
5124
5125                 str = SysAllocString(szAttribute);
5126                 hr = IXMLDOMDocument_createAttribute(doc, str, &pAttribute);
5127                 SysFreeString(str);
5128                 ok(hr == S_OK, "ret %08x\n", hr );
5129                 if(hr == S_OK)
5130                 {
5131                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
5132
5133                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, NULL);
5134                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5135
5136                     pNextChild = (IXMLDOMNode *)0x1;
5137                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, &pNextChild);
5138                     ok(hr == S_FALSE, "ret %08x\n", hr );
5139                     ok(pNextChild == NULL, "pNextChild not NULL\n");
5140
5141                     /* test Previous Sibling*/
5142                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, NULL);
5143                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5144
5145                     pNextChild = (IXMLDOMNode *)0x1;
5146                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, &pNextChild);
5147                     ok(hr == S_FALSE, "ret %08x\n", hr );
5148                     ok(pNextChild == NULL, "pNextChild not NULL\n");
5149
5150                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttribute, &pNewChild);
5151                     ok(hr == E_FAIL, "ret %08x\n", hr );
5152                     ok(pNewChild == NULL, "pNewChild not NULL\n");
5153
5154                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
5155                     ok(hr == S_OK, "ret %08x\n", hr );
5156                     if ( hr == S_OK )
5157                     {
5158                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttribute, NULL );
5159                         ok(hr == S_OK, "ret %08x\n", hr );
5160
5161                         IXMLDOMNamedNodeMap_Release(pAttribs);
5162                     }
5163
5164                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5165                     ok(hr == S_OK, "ret %08x\n", hr );
5166                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
5167                     SysFreeString(str);
5168
5169                     /* test nodeName */
5170                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
5171                     ok(hr == S_OK, "ret %08x\n", hr );
5172                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
5173                     SysFreeString(str);
5174
5175                     /* test name property */
5176                     hr = IXMLDOMAttribute_get_name(pAttribute, &str);
5177                     ok(hr == S_OK, "ret %08x\n", hr );
5178                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
5179                     SysFreeString(str);
5180
5181                     hr = IXMLDOMAttribute_get_xml(pAttribute, &str);
5182                     ok(hr == S_OK, "ret %08x\n", hr );
5183                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
5184                     SysFreeString(str);
5185
5186                     IXMLDOMAttribute_Release(pAttribute);
5187
5188                     /* Check Element again with the Add Attribute*/
5189                     hr = IXMLDOMElement_get_xml(pElement, &str);
5190                     ok(hr == S_OK, "ret %08x\n", hr );
5191                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
5192                     SysFreeString(str);
5193                 }
5194
5195                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
5196                 ok(hr == S_OK, "ret %08x\n", hr );
5197
5198                 hr = IXMLDOMElement_get_xml(pElement, &str);
5199                 ok(hr == S_OK, "ret %08x\n", hr );
5200                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
5201                 SysFreeString(str);
5202
5203                 /* Test for reversible escaping */
5204                 str = SysAllocString( szStrangeChars );
5205                 hr = IXMLDOMElement_put_text(pElement, str);
5206                 ok(hr == S_OK, "ret %08x\n", hr );
5207                 SysFreeString( str );
5208
5209                 hr = IXMLDOMElement_get_xml(pElement, &str);
5210                 ok(hr == S_OK, "ret %08x\n", hr );
5211                 ok( !lstrcmpW( str, szElementXML4 ), "incorrect element xml\n");
5212                 SysFreeString(str);
5213
5214                 hr = IXMLDOMElement_get_text(pElement, &str);
5215                 ok(hr == S_OK, "ret %08x\n", hr );
5216                 ok( !lstrcmpW( str, szStrangeChars ), "incorrect element text\n");
5217                 SysFreeString(str);
5218
5219                 IXMLDOMElement_Release(pElement);
5220             }
5221
5222             /* CData Section */
5223             str = SysAllocString(szCData);
5224             hr = IXMLDOMDocument_createCDATASection(doc, str, NULL);
5225             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5226
5227             hr = IXMLDOMDocument_createCDATASection(doc, str, &pCDataSec);
5228             SysFreeString(str);
5229             ok(hr == S_OK, "ret %08x\n", hr );
5230             if(hr == S_OK)
5231             {
5232                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
5233                 VARIANT var;
5234
5235                 VariantInit(&var);
5236
5237                 hr = IXMLDOMCDATASection_QueryInterface(pCDataSec, &IID_IXMLDOMElement, (void**)&pElement);
5238                 ok(hr == E_NOINTERFACE, "ret %08x\n", hr);
5239
5240                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
5241                 ok(hr == S_OK, "ret %08x\n", hr );
5242
5243                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
5244                 ok(hr == S_OK, "ret %08x\n", hr );
5245                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
5246                 SysFreeString(str);
5247
5248                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5249                 ok(hr == S_OK, "ret %08x\n", hr );
5250                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
5251                 SysFreeString(str);
5252
5253                 /* test lastChild */
5254                 pNextChild = (IXMLDOMNode*)0x1;
5255                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
5256                 ok(hr == S_FALSE, "ret %08x\n", hr );
5257                 ok(pNextChild == NULL, "pNextChild not NULL\n");
5258
5259                 /* put data Tests */
5260                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
5261                 ok(hr == S_OK, "ret %08x\n", hr );
5262
5263                 /* Confirm XML text is good */
5264                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5265                 ok(hr == S_OK, "ret %08x\n", hr );
5266                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
5267                 SysFreeString(str);
5268
5269                 /* Confirm we get the put_data Text back */
5270                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5271                 ok(hr == S_OK, "ret %08x\n", hr );
5272                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5273                 SysFreeString(str);
5274
5275                 /* test length property */
5276                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5277                 ok(hr == S_OK, "ret %08x\n", hr );
5278                 ok(len == 21, "expected 21 got %d\n", len);
5279
5280                 /* test get data */
5281                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
5282                 ok(hr == S_OK, "ret %08x\n", hr );
5283                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5284                 SysFreeString(str);
5285
5286                 /* test substringData */
5287                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
5288                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5289
5290                 /* test substringData - Invalid offset */
5291                 str = (BSTR)&szElement;
5292                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
5293                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5294                 ok( str == NULL, "incorrect string\n");
5295
5296                 /* test substringData - Invalid offset */
5297                 str = (BSTR)&szElement;
5298                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
5299                 ok(hr == S_FALSE, "ret %08x\n", hr );
5300                 ok( str == NULL, "incorrect string\n");
5301
5302                 /* test substringData - Invalid size */
5303                 str = (BSTR)&szElement;
5304                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
5305                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5306                 ok( str == NULL, "incorrect string\n");
5307
5308                 /* test substringData - Invalid size */
5309                 str = (BSTR)&szElement;
5310                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
5311                 ok(hr == S_FALSE, "ret %08x\n", hr );
5312                 ok( str == NULL, "incorrect string\n");
5313
5314                 /* test substringData - Start of string */
5315                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
5316                 ok(hr == S_OK, "ret %08x\n", hr );
5317                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
5318                 SysFreeString(str);
5319
5320                 /* test substringData - Middle of string */
5321                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
5322                 ok(hr == S_OK, "ret %08x\n", hr );
5323                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
5324                 SysFreeString(str);
5325
5326                 /* test substringData - End of string */
5327                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
5328                 ok(hr == S_OK, "ret %08x\n", hr );
5329                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
5330                 SysFreeString(str);
5331
5332                 /* test appendData */
5333                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
5334                 ok(hr == S_OK, "ret %08x\n", hr );
5335
5336                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
5337                 ok(hr == S_OK, "ret %08x\n", hr );
5338
5339                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
5340                 ok(hr == S_OK, "ret %08x\n", hr );
5341
5342                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5343                 ok(hr == S_OK, "ret %08x\n", hr );
5344                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5345                 SysFreeString(str);
5346
5347                 /* test insertData */
5348                 str = SysAllocStringLen(NULL, 0);
5349                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
5350                 ok(hr == S_OK, "ret %08x\n", hr );
5351
5352                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
5353                 ok(hr == S_OK, "ret %08x\n", hr );
5354
5355                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
5356                 ok(hr == S_OK, "ret %08x\n", hr );
5357
5358                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
5359                 ok(hr == S_OK, "ret %08x\n", hr );
5360
5361                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
5362                 ok(hr == S_OK, "ret %08x\n", hr );
5363
5364                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
5365                 ok(hr == S_OK, "ret %08x\n", hr );
5366                 SysFreeString(str);
5367
5368                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
5369                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5370
5371                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
5372                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5373
5374                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
5375                 ok(hr == S_OK, "ret %08x\n", hr );
5376
5377                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
5378                 ok(hr == S_OK, "ret %08x\n", hr );
5379
5380                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
5381                 ok(hr == S_OK, "ret %08x\n", hr );
5382
5383                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5384                 ok(hr == S_OK, "ret %08x\n", hr );
5385                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5386                 SysFreeString(str);
5387
5388                 /* delete data */
5389                 /* invalid arguments */
5390                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, -1, 1);
5391                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5392
5393                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 0);
5394                 ok(hr == S_OK, "ret %08x\n", hr );
5395
5396                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, -1);
5397                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5398
5399                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5400                 ok(hr == S_OK, "ret %08x\n", hr );
5401                 ok(len == 43, "expected 43 got %d\n", len);
5402
5403                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len, 1);
5404                 ok(hr == S_OK, "ret %08x\n", hr );
5405
5406                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len+1, 1);
5407                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5408
5409                 /* delete from start */
5410                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 5);
5411                 ok(hr == S_OK, "ret %08x\n", hr );
5412
5413                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5414                 ok(hr == S_OK, "ret %08x\n", hr );
5415                 ok(len == 38, "expected 38 got %d\n", len);
5416
5417                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5418                 ok(hr == S_OK, "ret %08x\n", hr );
5419                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5420                 SysFreeString(str);
5421
5422                 /* delete from end */
5423                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 35, 3);
5424                 ok(hr == S_OK, "ret %08x\n", hr );
5425
5426                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5427                 ok(hr == S_OK, "ret %08x\n", hr );
5428                 ok(len == 35, "expected 35 got %d\n", len);
5429
5430                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5431                 ok(hr == S_OK, "ret %08x\n", hr );
5432                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5433                 SysFreeString(str);
5434
5435                 /* delete from inside */
5436                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 1, 33);
5437                 ok(hr == S_OK, "ret %08x\n", hr );
5438
5439                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5440                 ok(hr == S_OK, "ret %08x\n", hr );
5441                 ok(len == 2, "expected 2 got %d\n", len);
5442
5443                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5444                 ok(hr == S_OK, "ret %08x\n", hr );
5445                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5446                 SysFreeString(str);
5447
5448                 /* delete whole data ... */
5449                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5450                 ok(hr == S_OK, "ret %08x\n", hr );
5451
5452                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
5453                 ok(hr == S_OK, "ret %08x\n", hr );
5454
5455                 /* ... and try again with empty string */
5456                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
5457                 ok(hr == S_OK, "ret %08x\n", hr );
5458
5459                 /* ::replaceData() */
5460                 V_VT(&v) = VT_BSTR;
5461                 V_BSTR(&v) = SysAllocString(szstr1);
5462                 hr = IXMLDOMCDATASection_put_nodeValue(pCDataSec, v);
5463                 ok(hr == S_OK, "ret %08x\n", hr );
5464                 VariantClear(&v);
5465
5466                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 6, 0, NULL);
5467                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5468                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5469                 ok(hr == S_OK, "ret %08x\n", hr );
5470                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5471                 SysFreeString(str);
5472
5473                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, NULL);
5474                 ok(hr == S_OK, "ret %08x\n", hr );
5475                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5476                 ok(hr == S_OK, "ret %08x\n", hr );
5477                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5478                 SysFreeString(str);
5479
5480                 /* NULL pointer means delete */
5481                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, NULL);
5482                 ok(hr == S_OK, "ret %08x\n", hr );
5483                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5484                 ok(hr == S_OK, "ret %08x\n", hr );
5485                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5486                 SysFreeString(str);
5487
5488                 /* empty string means delete */
5489                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_(""));
5490                 ok(hr == S_OK, "ret %08x\n", hr );
5491                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5492                 ok(hr == S_OK, "ret %08x\n", hr );
5493                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5494                 SysFreeString(str);
5495
5496                 /* zero count means insert */
5497                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, _bstr_("a"));
5498                 ok(hr == S_OK, "ret %08x\n", hr );
5499                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5500                 ok(hr == S_OK, "ret %08x\n", hr );
5501                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5502                 SysFreeString(str);
5503
5504                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, NULL);
5505                 ok(hr == S_OK, "ret %08x\n", hr );
5506
5507                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("m"));
5508                 ok(hr == S_OK, "ret %08x\n", hr );
5509                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5510                 ok(hr == S_OK, "ret %08x\n", hr );
5511                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5512                 SysFreeString(str);
5513
5514                 /* nonempty string, count greater than its length */
5515                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, _bstr_("a1.2"));
5516                 ok(hr == S_OK, "ret %08x\n", hr );
5517                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5518                 ok(hr == S_OK, "ret %08x\n", hr );
5519                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5520                 SysFreeString(str);
5521
5522                 /* nonempty string, count less than its length */
5523                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_("wine"));
5524                 ok(hr == S_OK, "ret %08x\n", hr );
5525                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5526                 ok(hr == S_OK, "ret %08x\n", hr );
5527                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5528                 SysFreeString(str);
5529
5530                 IXMLDOMCDATASection_Release(pCDataSec);
5531             }
5532
5533             /* Document Fragments */
5534             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
5535             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5536
5537             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
5538             ok(hr == S_OK, "ret %08x\n", hr );
5539             if(hr == S_OK)
5540             {
5541                 IXMLDOMNode *node;
5542
5543                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, NULL);
5544                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5545
5546                 node = (IXMLDOMNode *)0x1;
5547                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, &node);
5548                 ok(hr == S_FALSE, "ret %08x\n", hr );
5549                 ok(node == NULL, "expected NULL, got %p\n", node);
5550
5551                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
5552                 ok(hr == S_OK, "ret %08x\n", hr );
5553
5554                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
5555                 ok(hr == S_OK, "ret %08x\n", hr );
5556                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
5557                 SysFreeString(str);
5558
5559                 /* test next Sibling*/
5560                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
5561                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5562
5563                 node = (IXMLDOMNode *)0x1;
5564                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &node);
5565                 ok(hr == S_FALSE, "ret %08x\n", hr );
5566                 ok(node == NULL, "next sibling not NULL\n");
5567
5568                 /* test Previous Sibling*/
5569                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
5570                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5571
5572                 node = (IXMLDOMNode *)0x1;
5573                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &node);
5574                 ok(hr == S_FALSE, "ret %08x\n", hr );
5575                 ok(node == NULL, "previous sibling not NULL\n");
5576
5577                 IXMLDOMDocumentFragment_Release(pDocFrag);
5578             }
5579
5580             /* Entity References */
5581             hr = IXMLDOMDocument_createEntityReference(doc, NULL, &pEntityRef);
5582             ok(hr == E_FAIL, "ret %08x\n", hr );
5583             hr = IXMLDOMDocument_createEntityReference(doc, _bstr_(""), &pEntityRef);
5584             ok(hr == E_FAIL, "ret %08x\n", hr );
5585
5586             str = SysAllocString(szEntityRef);
5587             hr = IXMLDOMDocument_createEntityReference(doc, str, NULL);
5588             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5589
5590             hr = IXMLDOMDocument_createEntityReference(doc, str, &pEntityRef);
5591             SysFreeString(str);
5592             ok(hr == S_OK, "ret %08x\n", hr );
5593             if(hr == S_OK)
5594             {
5595                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
5596                 ok(hr == S_OK, "ret %08x\n", hr );
5597
5598                 /* test get_xml*/
5599                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
5600                 ok(hr == S_OK, "ret %08x\n", hr );
5601                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
5602                 SysFreeString(str);
5603
5604                 IXMLDOMEntityReference_Release(pEntityRef);
5605             }
5606
5607             IXMLDOMElement_Release( pRoot );
5608         }
5609     }
5610
5611     IXMLDOMDocument_Release(doc);
5612
5613     free_bstrs();
5614 }
5615
5616 typedef struct {
5617     const char *name;
5618     const char *type;
5619     HRESULT hr;
5620 } put_datatype_t;
5621
5622 /* Type test for elements only. Name passed into put_dataType is case-insensitive.
5623    So many of the names have been changed to reflect this. */
5624 static put_datatype_t put_datatype_data[] = {
5625     { "test_inval",      "abcdefg",     E_FAIL },
5626     { "test_bool",       "Boolean",     S_OK },
5627     { "test_string",     "String",      S_OK },
5628     { "test_number",     "number",      S_OK },
5629     { "test_int",        "InT",         S_OK },
5630     { "test_fixed",      "fixed.14.4",  S_OK },
5631     { "test_datetime",   "DateTime",    S_OK },
5632     { "test_datetimetz", "DateTime.tz", S_OK },
5633     { "test_date",       "Date",        S_OK },
5634     { "test_time",       "Time",        S_OK },
5635     { "test_timetz",     "Time.tz",     S_OK },
5636     { "test_I1",         "I1",          S_OK },
5637     { "test_I2",         "I2",          S_OK },
5638     { "test_I4",         "I4",          S_OK },
5639     { "test_UI1",        "UI1",         S_OK },
5640     { "test_UI2",        "UI2",         S_OK },
5641     { "test_UI4",        "UI4",         S_OK },
5642     { "test_r4",         "r4",          S_OK },
5643     { "test_r8",         "r8",          S_OK },
5644     { "test_float",      "float",       S_OK },
5645     { "test_uuid",       "UuId",        S_OK },
5646     { "test_binhex",     "bin.hex",     S_OK },
5647     { "test_binbase64",  "bin.base64",  S_OK },
5648     { NULL }
5649 };
5650
5651 typedef struct {
5652     DOMNodeType type;
5653     HRESULT hr;
5654 } put_datatype_notype_t;
5655
5656 static put_datatype_notype_t put_dt_notype[] = {
5657     { NODE_PROCESSING_INSTRUCTION, E_FAIL },
5658     { NODE_DOCUMENT_FRAGMENT,      E_FAIL },
5659     { NODE_ENTITY_REFERENCE,       E_FAIL },
5660     { NODE_CDATA_SECTION,          E_FAIL },
5661     { NODE_COMMENT,                E_FAIL },
5662     { NODE_INVALID }
5663 };
5664
5665 static void test_put_dataType( void )
5666 {
5667     const put_datatype_notype_t *ptr2 = put_dt_notype;
5668     const put_datatype_t *ptr = put_datatype_data;
5669     IXMLDOMElement *root, *element;
5670     BSTR nameW, type1W, type2W;
5671     IXMLDOMDocument *doc;
5672     HRESULT hr;
5673
5674     doc = create_document(&IID_IXMLDOMDocument);
5675     if (!doc) return;
5676
5677     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), NULL);
5678     EXPECT_HR(hr, E_INVALIDARG);
5679
5680     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
5681     EXPECT_HR(hr, S_OK);
5682
5683     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
5684     EXPECT_HR(hr, S_OK);
5685
5686     hr = IXMLDOMElement_put_dataType(root, NULL);
5687     EXPECT_HR(hr, E_INVALIDARG);
5688
5689     while (ptr->name)
5690     {
5691         hr = IXMLDOMDocument_createElement(doc, _bstr_(ptr->name), &element);
5692         EXPECT_HR(hr, S_OK);
5693         if(hr == S_OK)
5694         {
5695             hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
5696             EXPECT_HR(hr, S_OK);
5697
5698             hr = IXMLDOMElement_put_dataType(element, _bstr_(ptr->type));
5699             ok(hr == ptr->hr, "failed for %s:%s, 0x%08x\n", ptr->name, ptr->type, ptr->hr);
5700
5701             IXMLDOMElement_Release(element);
5702         }
5703         ptr++;
5704     }
5705
5706     /* check changing types */
5707     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &element);
5708     EXPECT_HR(hr, S_OK);
5709
5710     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)element, NULL);
5711     EXPECT_HR(hr, S_OK);
5712
5713     hr = IXMLDOMElement_put_dataType(element, _bstr_("DateTime.tz"));
5714     EXPECT_HR(hr, S_OK);
5715
5716     hr = IXMLDOMElement_put_dataType(element, _bstr_("string"));
5717     EXPECT_HR(hr, S_OK);
5718
5719     IXMLDOMElement_Release(element);
5720
5721     /* try to set type for node without a type */
5722     nameW  = _bstr_("testname");
5723     type1W = _bstr_("string");
5724     type2W = _bstr_("number");
5725     while (ptr2->type != NODE_INVALID)
5726     {
5727         IXMLDOMNode *node;
5728         VARIANT type;
5729
5730         V_VT(&type) = VT_I2;
5731         V_I2(&type) = ptr2->type;
5732
5733         hr = IXMLDOMDocument_createNode(doc, type, nameW, NULL, &node);
5734         EXPECT_HR(hr, S_OK);
5735         if(hr == S_OK)
5736         {
5737             hr = IXMLDOMElement_appendChild(root, node, NULL);
5738             EXPECT_HR(hr, S_OK);
5739
5740             hr = IXMLDOMNode_put_dataType(node, NULL);
5741             EXPECT_HR(hr, E_INVALIDARG);
5742
5743             hr = IXMLDOMNode_put_dataType(node, type1W);
5744             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
5745             hr = IXMLDOMNode_put_dataType(node, type2W);
5746             ok(hr == ptr2->hr, "failed for type %d, 0x%08x\n", ptr2->type, ptr->hr);
5747
5748             IXMLDOMNode_Release(node);
5749         }
5750         ptr2++;
5751     }
5752
5753     IXMLDOMElement_Release(root);
5754     IXMLDOMDocument_Release(doc);
5755     free_bstrs();
5756 }
5757
5758 static void test_save(void)
5759 {
5760     IXMLDOMDocument *doc, *doc2;
5761     IXMLDOMElement *root;
5762     BSTR sOrig, sNew, filename;
5763     char buffer[100];
5764     IStream *stream;
5765     HGLOBAL global;
5766     VARIANT_BOOL b;
5767     DWORD read = 0;
5768     VARIANT dest;
5769     HANDLE hfile;
5770     HRESULT hr;
5771     char *ptr;
5772
5773     doc = create_document(&IID_IXMLDOMDocument);
5774     if (!doc) return;
5775
5776     doc2 = create_document(&IID_IXMLDOMDocument);
5777     if (!doc2)
5778     {
5779         IXMLDOMDocument_Release(doc);
5780         return;
5781     }
5782
5783     /* save to IXMLDOMDocument */
5784     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &root);
5785     EXPECT_HR(hr, S_OK);
5786
5787     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)root, NULL);
5788     EXPECT_HR(hr, S_OK);
5789
5790     V_VT(&dest) = VT_UNKNOWN;
5791     V_UNKNOWN(&dest) = (IUnknown*)doc2;
5792
5793     hr = IXMLDOMDocument_save(doc, dest);
5794     EXPECT_HR(hr, S_OK);
5795
5796     hr = IXMLDOMDocument_get_xml(doc, &sOrig);
5797     EXPECT_HR(hr, S_OK);
5798
5799     hr = IXMLDOMDocument_get_xml(doc2, &sNew);
5800     EXPECT_HR(hr, S_OK);
5801
5802     ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as original\n");
5803
5804     SysFreeString(sOrig);
5805     SysFreeString(sNew);
5806
5807     IXMLDOMElement_Release(root);
5808     IXMLDOMDocument_Release(doc2);
5809
5810     /* save to path */
5811     V_VT(&dest) = VT_BSTR;
5812     V_BSTR(&dest) = _bstr_("test.xml");
5813
5814     hr = IXMLDOMDocument_save(doc, dest);
5815     EXPECT_HR(hr, S_OK);
5816
5817     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
5818     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
5819     if(hfile == INVALID_HANDLE_VALUE) return;
5820
5821     ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
5822     ok(read != 0, "could not read file\n");
5823     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
5824
5825     CloseHandle(hfile);
5826     DeleteFile("test.xml");
5827
5828     /* save to path VT_BSTR | VT_BYREF */
5829     filename = _bstr_("test.xml");
5830     V_VT(&dest) = VT_BSTR | VT_BYREF;
5831     V_BSTRREF(&dest) = &filename;
5832
5833     hr = IXMLDOMDocument_save(doc, dest);
5834     EXPECT_HR(hr, S_OK);
5835
5836     hfile = CreateFileA("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
5837     ok(hfile != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
5838     if(hfile == INVALID_HANDLE_VALUE) return;
5839
5840     if (hfile != INVALID_HANDLE_VALUE)
5841     {
5842        ReadFile(hfile, buffer, sizeof(buffer), &read, NULL);
5843        ok(read != 0, "could not read file\n");
5844        ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
5845
5846        CloseHandle(hfile);
5847        DeleteFile("test.xml");
5848     }
5849
5850     /* save to stream */
5851     V_VT(&dest) = VT_UNKNOWN;
5852     V_UNKNOWN(&dest) = (IUnknown*)&savestream;
5853
5854     hr = IXMLDOMDocument_save(doc, dest);
5855     EXPECT_HR(hr, S_OK);
5856
5857     /* loaded data contains xml declaration */
5858     hr = IXMLDOMDocument_loadXML(doc, _bstr_(win1252xml), &b);
5859     EXPECT_HR(hr, S_OK);
5860
5861     CreateStreamOnHGlobal(NULL, TRUE, &stream);
5862     V_VT(&dest) = VT_UNKNOWN;
5863     V_UNKNOWN(&dest) = (IUnknown*)stream;
5864     hr = IXMLDOMDocument_save(doc, dest);
5865     EXPECT_HR(hr, S_OK);
5866
5867     hr = GetHGlobalFromStream(stream, &global);
5868     EXPECT_HR(hr, S_OK);
5869     ptr = GlobalLock(global);
5870     ok(!memcmp(ptr, win1252decl, strlen(win1252decl)), "got wrong xml declaration\n");
5871     GlobalUnlock(global);
5872     IStream_Release(stream);
5873
5874     /* loaded data without xml declaration */
5875     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<a/>"), &b);
5876     EXPECT_HR(hr, S_OK);
5877
5878     CreateStreamOnHGlobal(NULL, TRUE, &stream);
5879     V_VT(&dest) = VT_UNKNOWN;
5880     V_UNKNOWN(&dest) = (IUnknown*)stream;
5881     hr = IXMLDOMDocument_save(doc, dest);
5882     EXPECT_HR(hr, S_OK);
5883
5884     hr = GetHGlobalFromStream(stream, &global);
5885     EXPECT_HR(hr, S_OK);
5886     ptr = GlobalLock(global);
5887     ok(ptr[0] == '<' && ptr[1] != '?', "got wrong start tag %c%c\n", ptr[0], ptr[1]);
5888     GlobalUnlock(global);
5889     IStream_Release(stream);
5890
5891     IXMLDOMDocument_Release(doc);
5892     free_bstrs();
5893 }
5894
5895 static void test_testTransforms(void)
5896 {
5897     IXMLDOMDocument *doc, *docSS;
5898     IXMLDOMNode *pNode;
5899     VARIANT_BOOL bSucc;
5900
5901     HRESULT hr;
5902
5903     doc = create_document(&IID_IXMLDOMDocument);
5904     if (!doc) return;
5905
5906     docSS = create_document(&IID_IXMLDOMDocument);
5907     if (!docSS)
5908     {
5909         IXMLDOMDocument_Release(doc);
5910         return;
5911     }
5912
5913     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
5914     ok(hr == S_OK, "ret %08x\n", hr );
5915
5916     hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
5917     ok(hr == S_OK, "ret %08x\n", hr );
5918
5919     hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (void**)&pNode );
5920     ok(hr == S_OK, "ret %08x\n", hr );
5921     if(hr == S_OK)
5922     {
5923         BSTR bOut;
5924
5925         hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
5926         ok(hr == S_OK, "ret %08x\n", hr );
5927         if(hr == S_OK)
5928         {
5929             ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "Stylesheet output not correct\n");
5930             SysFreeString(bOut);
5931         }
5932
5933         IXMLDOMNode_Release(pNode);
5934     }
5935
5936     IXMLDOMDocument_Release(docSS);
5937     IXMLDOMDocument_Release(doc);
5938
5939     free_bstrs();
5940 }
5941
5942 struct namespaces_change_t {
5943     const CLSID *clsid;
5944     const char *name;
5945 };
5946
5947 static const struct namespaces_change_t namespaces_change_test_data[] = {
5948     { &CLSID_DOMDocument,   "CLSID_DOMDocument"   },
5949     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2"  },
5950     { &CLSID_DOMDocument26, "CLSID_DOMDocument26" },
5951     { &CLSID_DOMDocument30, "CLSID_DOMDocument30" },
5952     { &CLSID_DOMDocument40, "CLSID_DOMDocument40" },
5953     { &CLSID_DOMDocument60, "CLSID_DOMDocument60" },
5954     { 0 }
5955 };
5956
5957 static void test_namespaces_change(void)
5958 {
5959     const struct namespaces_change_t *class_ptr = namespaces_change_test_data;
5960
5961     while (class_ptr->clsid)
5962     {
5963         IXMLDOMDocument *doc = NULL;
5964         IXMLDOMElement *elem = NULL;
5965         IXMLDOMNode *node = NULL;
5966
5967         VARIANT var;
5968         HRESULT hr;
5969         BSTR str;
5970
5971         hr = CoCreateInstance(class_ptr->clsid, NULL, CLSCTX_INPROC_SERVER,
5972                               &IID_IXMLDOMDocument, (void**)&doc);
5973         if (hr != S_OK)
5974         {
5975             win_skip("failed to create class instance for %s\n", class_ptr->name);
5976             class_ptr++;
5977             continue;
5978         }
5979
5980         V_VT(&var) = VT_I2;
5981         V_I2(&var) = NODE_ELEMENT;
5982
5983         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("ns:elem"), _bstr_("ns/uri"), &node);
5984         EXPECT_HR(hr, S_OK);
5985
5986         hr = IXMLDOMDocument_appendChild(doc, node, NULL);
5987         EXPECT_HR(hr, S_OK);
5988
5989         hr = IXMLDOMDocument_get_documentElement(doc, &elem);
5990         EXPECT_HR(hr, S_OK);
5991
5992         /* try same prefix, different uri */
5993         V_VT(&var) = VT_BSTR;
5994         V_BSTR(&var) = _bstr_("ns/uri2");
5995
5996         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
5997         EXPECT_HR(hr, E_INVALIDARG);
5998
5999         /* try same prefix and uri */
6000         V_VT(&var) = VT_BSTR;
6001         V_BSTR(&var) = _bstr_("ns/uri");
6002
6003         hr = IXMLDOMElement_setAttribute(elem, _bstr_("xmlns:ns"), var);
6004         EXPECT_HR(hr, S_OK);
6005
6006         hr = IXMLDOMElement_get_xml(elem, &str);
6007         EXPECT_HR(hr, S_OK);
6008         ok(!lstrcmpW(str, _bstr_("<ns:elem xmlns:ns=\"ns/uri\"/>")), "got element %s for %s\n",
6009            wine_dbgstr_w(str), class_ptr->name);
6010         SysFreeString(str);
6011
6012         IXMLDOMElement_Release(elem);
6013         IXMLDOMDocument_Release(doc);
6014
6015         free_bstrs();
6016
6017         class_ptr++;
6018     }
6019 }
6020
6021 static void test_namespaces_basic(void)
6022 {
6023     static const CHAR namespaces_xmlA[] =
6024         "<?xml version=\"1.0\"?>\n"
6025         "<XMI xmi.version=\"1.1\" xmlns:Model=\"http://omg.org/mof.Model/1.3\">"
6026         "  <XMI.content>"
6027         "    <Model:Package name=\"WinePackage\" Model:name2=\"name2 attr\" />"
6028         "  </XMI.content>"
6029         "</XMI>";
6030
6031     IXMLDOMDocument *doc;
6032     IXMLDOMElement *elem;
6033     IXMLDOMNode *node;
6034
6035     VARIANT_BOOL b;
6036     HRESULT hr;
6037     BSTR str;
6038
6039     doc = create_document(&IID_IXMLDOMDocument);
6040     if (!doc) return;
6041
6042     hr = IXMLDOMDocument_loadXML(doc, _bstr_(namespaces_xmlA), &b);
6043     EXPECT_HR(hr, S_OK);
6044     ok(b == VARIANT_TRUE, "got %d\n", b);
6045
6046     str = (BSTR)0xdeadbeef;
6047     hr = IXMLDOMDocument_get_namespaceURI(doc, &str);
6048     EXPECT_HR(hr, S_FALSE);
6049     ok(str == NULL, "got %p\n", str);
6050
6051     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("//XMI.content"), &node );
6052     EXPECT_HR(hr, S_OK);
6053     if(hr == S_OK)
6054     {
6055         IXMLDOMAttribute *attr;
6056         IXMLDOMNode *node2;
6057
6058         hr = IXMLDOMNode_get_firstChild(node, &node2);
6059         EXPECT_HR(hr, S_OK);
6060         ok(node2 != NULL, "got %p\n", node2);
6061
6062         /* Test get_prefix */
6063         hr = IXMLDOMNode_get_prefix(node2, NULL);
6064         EXPECT_HR(hr, E_INVALIDARG);
6065         /* NOTE: Need to test that arg2 gets cleared on Error. */
6066
6067         hr = IXMLDOMNode_get_prefix(node2, &str);
6068         EXPECT_HR(hr, S_OK);
6069         ok( !lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
6070         SysFreeString(str);
6071
6072         hr = IXMLDOMNode_get_nodeName(node2, &str);
6073         EXPECT_HR(hr, S_OK);
6074         ok(!lstrcmpW( str, _bstr_("Model:Package")), "got %s\n", wine_dbgstr_w(str));
6075         SysFreeString(str);
6076
6077         /* Test get_namespaceURI */
6078         hr = IXMLDOMNode_get_namespaceURI(node2, NULL);
6079         EXPECT_HR(hr, E_INVALIDARG);
6080         /* NOTE: Need to test that arg2 gets cleared on Error. */
6081
6082         hr = IXMLDOMNode_get_namespaceURI(node2, &str);
6083         EXPECT_HR(hr, S_OK);
6084         ok(!lstrcmpW( str, _bstr_("http://omg.org/mof.Model/1.3")), "got %s\n", wine_dbgstr_w(str));
6085         SysFreeString(str);
6086
6087         hr = IXMLDOMNode_QueryInterface(node2, &IID_IXMLDOMElement, (void**)&elem);
6088         EXPECT_HR(hr, S_OK);
6089
6090         hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("Model:name2"), &attr);
6091         EXPECT_HR(hr, S_OK);
6092
6093         hr = IXMLDOMAttribute_get_nodeName(attr, &str);
6094         EXPECT_HR(hr, S_OK);
6095         ok(!lstrcmpW( str, _bstr_("Model:name2")), "got %s\n", wine_dbgstr_w(str));
6096         SysFreeString(str);
6097
6098         hr = IXMLDOMAttribute_get_prefix(attr, &str);
6099         EXPECT_HR(hr, S_OK);
6100         ok(!lstrcmpW( str, _bstr_("Model")), "got %s\n", wine_dbgstr_w(str));
6101         SysFreeString(str);
6102
6103         IXMLDOMAttribute_Release(attr);
6104         IXMLDOMElement_Release(elem);
6105
6106         IXMLDOMNode_Release(node2);
6107         IXMLDOMNode_Release(node);
6108     }
6109
6110     IXMLDOMDocument_Release(doc);
6111
6112     free_bstrs();
6113 }
6114
6115 static void test_FormattingXML(void)
6116 {
6117     IXMLDOMDocument *doc;
6118     IXMLDOMElement *pElement;
6119     VARIANT_BOOL bSucc;
6120     HRESULT hr;
6121     BSTR str;
6122     static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
6123     static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
6124
6125     doc = create_document(&IID_IXMLDOMDocument);
6126     if (!doc) return;
6127
6128     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
6129     ok(hr == S_OK, "ret %08x\n", hr );
6130     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6131
6132     if(bSucc == VARIANT_TRUE)
6133     {
6134         hr = IXMLDOMDocument_get_documentElement(doc, &pElement);
6135         ok(hr == S_OK, "ret %08x\n", hr );
6136         if(hr == S_OK)
6137         {
6138             hr = IXMLDOMElement_get_xml(pElement, &str);
6139             ok(hr == S_OK, "ret %08x\n", hr );
6140             ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
6141             SysFreeString(str);
6142
6143             IXMLDOMElement_Release(pElement);
6144         }
6145     }
6146
6147     IXMLDOMDocument_Release(doc);
6148
6149     free_bstrs();
6150 }
6151
6152 typedef struct _nodetypedvalue_t {
6153     const char *name;
6154     VARTYPE type;
6155     const char *value; /* value in string format */
6156 } nodetypedvalue_t;
6157
6158 static const nodetypedvalue_t get_nodetypedvalue[] = {
6159     { "root/string",    VT_BSTR, "Wine" },
6160     { "root/string2",   VT_BSTR, "String" },
6161     { "root/number",    VT_BSTR, "12.44" },
6162     { "root/number2",   VT_BSTR, "-3.71e3" },
6163     { "root/int",       VT_I4,   "-13" },
6164     { "root/fixed",     VT_CY,   "7322.9371" },
6165     { "root/bool",      VT_BOOL, "-1" },
6166     { "root/datetime",  VT_DATE, "40135.14" },
6167     { "root/datetimetz",VT_DATE, "37813.59" },
6168     { "root/date",      VT_DATE, "665413" },
6169     { "root/time",      VT_DATE, "0.5813889" },
6170     { "root/timetz",    VT_DATE, "1.112512" },
6171     { "root/i1",        VT_I1,   "-13" },
6172     { "root/i2",        VT_I2,   "31915" },
6173     { "root/i4",        VT_I4,   "-312232" },
6174     { "root/ui1",       VT_UI1,  "123" },
6175     { "root/ui2",       VT_UI2,  "48282" },
6176     { "root/ui4",       VT_UI4,  "949281" },
6177     { "root/r4",        VT_R4,   "213124" },
6178     { "root/r8",        VT_R8,   "0.412" },
6179     { "root/float",     VT_R8,   "41221.421" },
6180     { "root/uuid",      VT_BSTR, "333C7BC4-460F-11D0-BC04-0080C7055a83" },
6181     { "root/binbase64", VT_ARRAY|VT_UI1, "base64 test" },
6182     { "root/binbase64_1", VT_ARRAY|VT_UI1, "base64 test" },
6183     { "root/binbase64_2", VT_ARRAY|VT_UI1, "base64 test" },
6184     { 0 }
6185 };
6186
6187 static void test_nodeTypedValue(void)
6188 {
6189     const nodetypedvalue_t *entry = get_nodetypedvalue;
6190     IXMLDOMDocumentType *doctype, *doctype2;
6191     IXMLDOMProcessingInstruction *pi;
6192     IXMLDOMDocumentFragment *frag;
6193     IXMLDOMDocument *doc, *doc2;
6194     IXMLDOMCDATASection *cdata;
6195     IXMLDOMComment *comment;
6196     IXMLDOMNode *node;
6197     VARIANT_BOOL b;
6198     VARIANT value;
6199     HRESULT hr;
6200
6201     doc = create_document(&IID_IXMLDOMDocument);
6202     if (!doc) return;
6203
6204     b = VARIANT_FALSE;
6205     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &b);
6206     ok(hr == S_OK, "ret %08x\n", hr );
6207     ok(b == VARIANT_TRUE, "got %d\n", b);
6208
6209     hr = IXMLDOMDocument_get_nodeValue(doc, NULL);
6210     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6211
6212     V_VT(&value) = VT_BSTR;
6213     V_BSTR(&value) = NULL;
6214     hr = IXMLDOMDocument_get_nodeValue(doc, &value);
6215     ok(hr == S_FALSE, "ret %08x\n", hr );
6216     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6217
6218     hr = IXMLDOMDocument_get_nodeTypedValue(doc, NULL);
6219     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6220
6221     V_VT(&value) = VT_EMPTY;
6222     hr = IXMLDOMDocument_get_nodeTypedValue(doc, &value);
6223     ok(hr == S_FALSE, "ret %08x\n", hr );
6224     ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6225
6226     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/string"), &node);
6227     ok(hr == S_OK, "ret %08x\n", hr );
6228
6229     V_VT(&value) = VT_BSTR;
6230     V_BSTR(&value) = NULL;
6231     hr = IXMLDOMNode_get_nodeValue(node, &value);
6232     ok(hr == S_FALSE, "ret %08x\n", hr );
6233     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6234
6235     hr = IXMLDOMNode_get_nodeTypedValue(node, NULL);
6236     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6237
6238     IXMLDOMNode_Release(node);
6239
6240     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/binhex"), &node);
6241     ok(hr == S_OK, "ret %08x\n", hr );
6242     {
6243         BYTE bytes[] = {0xff,0xfc,0xa0,0x12,0x00,0x3c};
6244
6245         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6246         ok(hr == S_OK, "ret %08x\n", hr );
6247         ok(V_VT(&value) == (VT_ARRAY|VT_UI1), "incorrect type\n");
6248         ok(V_ARRAY(&value)->rgsabound[0].cElements == 6, "incorrect array size\n");
6249         if(V_ARRAY(&value)->rgsabound[0].cElements == 6)
6250             ok(!memcmp(bytes, V_ARRAY(&value)->pvData, sizeof(bytes)), "incorrect value\n");
6251         VariantClear(&value);
6252         IXMLDOMNode_Release(node);
6253     }
6254
6255     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("foo"), _bstr_("value"), &pi);
6256     ok(hr == S_OK, "ret %08x\n", hr );
6257     {
6258         V_VT(&value) = VT_NULL;
6259         V_BSTR(&value) = (void*)0xdeadbeef;
6260         hr = IXMLDOMProcessingInstruction_get_nodeTypedValue(pi, &value);
6261         ok(hr == S_OK, "ret %08x\n", hr );
6262         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6263         ok(!lstrcmpW(V_BSTR(&value), _bstr_("value")), "got wrong value\n");
6264         IXMLDOMProcessingInstruction_Release(pi);
6265         VariantClear(&value);
6266     }
6267
6268     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("[1]*2=3; &gee that's not right!"), &cdata);
6269     ok(hr == S_OK, "ret %08x\n", hr );
6270     {
6271         V_VT(&value) = VT_NULL;
6272         V_BSTR(&value) = (void*)0xdeadbeef;
6273         hr = IXMLDOMCDATASection_get_nodeTypedValue(cdata, &value);
6274         ok(hr == S_OK, "ret %08x\n", hr );
6275         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6276         ok(!lstrcmpW(V_BSTR(&value), _bstr_("[1]*2=3; &gee that's not right!")), "got wrong value\n");
6277         IXMLDOMCDATASection_Release(cdata);
6278         VariantClear(&value);
6279     }
6280
6281     hr = IXMLDOMDocument_createComment(doc, _bstr_("comment"), &comment);
6282     ok(hr == S_OK, "ret %08x\n", hr );
6283     {
6284         V_VT(&value) = VT_NULL;
6285         V_BSTR(&value) = (void*)0xdeadbeef;
6286         hr = IXMLDOMComment_get_nodeTypedValue(comment, &value);
6287         ok(hr == S_OK, "ret %08x\n", hr );
6288         ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
6289         ok(!lstrcmpW(V_BSTR(&value), _bstr_("comment")), "got wrong value\n");
6290         IXMLDOMComment_Release(comment);
6291         VariantClear(&value);
6292     }
6293
6294     hr = IXMLDOMDocument_createDocumentFragment(doc, &frag);
6295     ok(hr == S_OK, "ret %08x\n", hr );
6296     {
6297         V_VT(&value) = VT_EMPTY;
6298         hr = IXMLDOMDocumentFragment_get_nodeTypedValue(frag, &value);
6299         ok(hr == S_FALSE, "ret %08x\n", hr );
6300         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6301         IXMLDOMDocumentFragment_Release(frag);
6302     }
6303
6304     doc2 = create_document(&IID_IXMLDOMDocument);
6305
6306     b = VARIANT_FALSE;
6307     hr = IXMLDOMDocument_loadXML(doc2, _bstr_(szEmailXML), &b);
6308     ok(hr == S_OK, "ret %08x\n", hr );
6309     ok(b == VARIANT_TRUE, "got %d\n", b);
6310
6311     EXPECT_REF(doc2, 1);
6312
6313     hr = IXMLDOMDocument_get_doctype(doc2, &doctype);
6314     ok(hr == S_OK, "ret %08x\n", hr );
6315
6316     EXPECT_REF(doc2, 1);
6317     todo_wine EXPECT_REF(doctype, 2);
6318
6319     {
6320         V_VT(&value) = VT_EMPTY;
6321         hr = IXMLDOMDocumentType_get_nodeTypedValue(doctype, &value);
6322         ok(hr == S_FALSE, "ret %08x\n", hr );
6323         ok(V_VT(&value) == VT_NULL, "got %d\n", V_VT(&value));
6324     }
6325
6326     hr = IXMLDOMDocument_get_doctype(doc2, &doctype2);
6327     ok(hr == S_OK, "ret %08x\n", hr );
6328     ok(doctype != doctype2, "got %p, was %p\n", doctype2, doctype);
6329
6330     IXMLDOMDocumentType_Release(doctype2);
6331     IXMLDOMDocumentType_Release(doctype);
6332
6333     IXMLDOMDocument_Release(doc2);
6334
6335     while (entry->name)
6336     {
6337         hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_(entry->name), &node);
6338         ok(hr == S_OK, "ret %08x\n", hr );
6339
6340         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6341         ok(hr == S_OK, "ret %08x\n", hr );
6342         ok(V_VT(&value) == entry->type, "incorrect type, expected %d, got %d\n", entry->type, V_VT(&value));
6343
6344         if (entry->type == (VT_ARRAY|VT_UI1))
6345         {
6346             ok(V_ARRAY(&value)->rgsabound[0].cElements == strlen(entry->value),
6347                "incorrect array size %d\n", V_ARRAY(&value)->rgsabound[0].cElements);
6348         }
6349
6350         if (entry->type != VT_BSTR)
6351         {
6352            if (entry->type == VT_DATE ||
6353                entry->type == VT_R8 ||
6354                entry->type == VT_CY)
6355            {
6356                if (entry->type == VT_DATE)
6357                {
6358                    hr = VariantChangeType(&value, &value, 0, VT_R4);
6359                    ok(hr == S_OK, "ret %08x\n", hr );
6360                }
6361                hr = VariantChangeTypeEx(&value, &value,
6362                                         MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT),
6363                                         VARIANT_NOUSEROVERRIDE, VT_BSTR);
6364                ok(hr == S_OK, "ret %08x\n", hr );
6365            }
6366            else
6367            {
6368                hr = VariantChangeType(&value, &value, 0, VT_BSTR);
6369                ok(hr == S_OK, "ret %08x\n", hr );
6370            }
6371
6372            /* for byte array from VT_ARRAY|VT_UI1 it's not a WCHAR buffer */
6373            if (entry->type == (VT_ARRAY|VT_UI1))
6374            {
6375                ok(!memcmp( V_BSTR(&value), entry->value, strlen(entry->value)),
6376                   "expected %s\n", entry->value);
6377            }
6378            else
6379                ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
6380                   "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
6381         }
6382         else
6383            ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
6384                "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
6385
6386         VariantClear( &value );
6387         IXMLDOMNode_Release(node);
6388
6389         entry++;
6390     }
6391
6392     IXMLDOMDocument_Release(doc);
6393     free_bstrs();
6394 }
6395
6396 static void test_TransformWithLoadingLocalFile(void)
6397 {
6398     IXMLDOMDocument *doc;
6399     IXMLDOMDocument *xsl;
6400     IXMLDOMNode *pNode;
6401     VARIANT_BOOL bSucc;
6402     HRESULT hr;
6403     HANDLE file;
6404     DWORD dwWritten;
6405     char lpPathBuffer[MAX_PATH];
6406     int i;
6407
6408     /* Create a Temp File. */
6409     GetTempPathA(MAX_PATH, lpPathBuffer);
6410     strcat(lpPathBuffer, "customers.xml" );
6411
6412     file = CreateFileA(lpPathBuffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
6413     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
6414     if(file == INVALID_HANDLE_VALUE)
6415         return;
6416
6417     WriteFile(file, szBasicTransformXML, strlen(szBasicTransformXML), &dwWritten, NULL);
6418     CloseHandle(file);
6419
6420     /* Correct path to not include a escape character. */
6421     for(i=0; i < strlen(lpPathBuffer); i++)
6422     {
6423         if(lpPathBuffer[i] == '\\')
6424             lpPathBuffer[i] = '/';
6425     }
6426
6427     doc = create_document(&IID_IXMLDOMDocument);
6428     if (!doc) return;
6429
6430     xsl = create_document(&IID_IXMLDOMDocument);
6431     if (!xsl)
6432     {
6433         IXMLDOMDocument_Release(doc);
6434         return;
6435     }
6436
6437     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
6438     ok(hr == S_OK, "ret %08x\n", hr );
6439     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6440     if(bSucc == VARIANT_TRUE)
6441     {
6442         BSTR sXSL;
6443         BSTR sPart1 = _bstr_(szBasicTransformSSXMLPart1);
6444         BSTR sPart2 = _bstr_(szBasicTransformSSXMLPart2);
6445         BSTR sFileName = _bstr_(lpPathBuffer);
6446         int nLegnth = lstrlenW(sPart1) + lstrlenW(sPart2) + lstrlenW(sFileName) + 1;
6447
6448         sXSL = SysAllocStringLen(NULL, nLegnth);
6449         lstrcpyW(sXSL, sPart1);
6450         lstrcatW(sXSL, sFileName);
6451         lstrcatW(sXSL, sPart2);
6452
6453         hr = IXMLDOMDocument_loadXML(xsl, sXSL, &bSucc);
6454         ok(hr == S_OK, "ret %08x\n", hr );
6455         ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6456         if(bSucc == VARIANT_TRUE)
6457         {
6458             BSTR sResult;
6459
6460             hr = IXMLDOMDocument_QueryInterface(xsl, &IID_IXMLDOMNode, (void**)&pNode );
6461             ok(hr == S_OK, "ret %08x\n", hr );
6462             if(hr == S_OK)
6463             {
6464                 /* This will load the temp file via the XSL */
6465                 hr = IXMLDOMDocument_transformNode(doc, pNode, &sResult);
6466                 ok(hr == S_OK, "ret %08x\n", hr );
6467                 if(hr == S_OK)
6468                 {
6469                     ok( compareIgnoreReturns( sResult, _bstr_(szBasicTransformOutput)), "Stylesheet output not correct\n");
6470                     SysFreeString(sResult);
6471                 }
6472
6473                 IXMLDOMNode_Release(pNode);
6474             }
6475         }
6476
6477         SysFreeString(sXSL);
6478     }
6479
6480     IXMLDOMDocument_Release(doc);
6481     IXMLDOMDocument_Release(xsl);
6482
6483     DeleteFile(lpPathBuffer);
6484     free_bstrs();
6485 }
6486
6487 static void test_put_nodeValue(void)
6488 {
6489     static const WCHAR jeevesW[] = {'J','e','e','v','e','s',' ','&',' ','W','o','o','s','t','e','r',0};
6490     IXMLDOMDocument *doc;
6491     IXMLDOMText *text;
6492     IXMLDOMEntityReference *entityref;
6493     IXMLDOMAttribute *attr;
6494     IXMLDOMNode *node;
6495     HRESULT hr;
6496     VARIANT data, type;
6497
6498     doc = create_document(&IID_IXMLDOMDocument);
6499     if (!doc) return;
6500
6501     /* test for unsupported types */
6502     /* NODE_DOCUMENT */
6503     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&node);
6504     ok(hr == S_OK, "ret %08x\n", hr );
6505     V_VT(&data) = VT_BSTR;
6506     V_BSTR(&data) = _bstr_("one two three");
6507     hr = IXMLDOMNode_put_nodeValue(node, data);
6508     ok(hr == E_FAIL, "ret %08x\n", hr );
6509     IXMLDOMNode_Release(node);
6510
6511     /* NODE_DOCUMENT_FRAGMENT */
6512     V_VT(&type) = VT_I1;
6513     V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
6514     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
6515     ok(hr == S_OK, "ret %08x\n", hr );
6516     V_VT(&data) = VT_BSTR;
6517     V_BSTR(&data) = _bstr_("one two three");
6518     hr = IXMLDOMNode_put_nodeValue(node, data);
6519     ok(hr == E_FAIL, "ret %08x\n", hr );
6520     IXMLDOMNode_Release(node);
6521
6522     /* NODE_ELEMENT */
6523     V_VT(&type) = VT_I1;
6524     V_I1(&type) = NODE_ELEMENT;
6525     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
6526     ok(hr == S_OK, "ret %08x\n", hr );
6527     V_VT(&data) = VT_BSTR;
6528     V_BSTR(&data) = _bstr_("one two three");
6529     hr = IXMLDOMNode_put_nodeValue(node, data);
6530     ok(hr == E_FAIL, "ret %08x\n", hr );
6531     IXMLDOMNode_Release(node);
6532
6533     /* NODE_ENTITY_REFERENCE */
6534     hr = IXMLDOMDocument_createEntityReference(doc, _bstr_("ref"), &entityref);
6535     ok(hr == S_OK, "ret %08x\n", hr );
6536
6537     V_VT(&data) = VT_BSTR;
6538     V_BSTR(&data) = _bstr_("one two three");
6539     hr = IXMLDOMEntityReference_put_nodeValue(entityref, data);
6540     ok(hr == E_FAIL, "ret %08x\n", hr );
6541
6542     hr = IXMLDOMEntityReference_QueryInterface(entityref, &IID_IXMLDOMNode, (void**)&node);
6543     ok(hr == S_OK, "ret %08x\n", hr );
6544     V_VT(&data) = VT_BSTR;
6545     V_BSTR(&data) = _bstr_("one two three");
6546     hr = IXMLDOMNode_put_nodeValue(node, data);
6547     ok(hr == E_FAIL, "ret %08x\n", hr );
6548     IXMLDOMNode_Release(node);
6549     IXMLDOMEntityReference_Release(entityref);
6550
6551     /* supported types */
6552     hr = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &text);
6553     ok(hr == S_OK, "ret %08x\n", hr );
6554     V_VT(&data) = VT_BSTR;
6555     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
6556     hr = IXMLDOMText_put_nodeValue(text, data);
6557     ok(hr == S_OK, "ret %08x\n", hr );
6558     IXMLDOMText_Release(text);
6559
6560     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
6561     ok(hr == S_OK, "ret %08x\n", hr );
6562     V_VT(&data) = VT_BSTR;
6563     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
6564     hr = IXMLDOMAttribute_put_nodeValue(attr, data);
6565     ok(hr == S_OK, "ret %08x\n", hr );
6566     hr = IXMLDOMAttribute_get_nodeValue(attr, &data);
6567     ok(hr == S_OK, "ret %08x\n", hr );
6568     ok(memcmp(V_BSTR(&data), jeevesW, sizeof(jeevesW)) == 0, "got %s\n",
6569         wine_dbgstr_w(V_BSTR(&data)));
6570     VariantClear(&data);
6571     IXMLDOMAttribute_Release(attr);
6572
6573     free_bstrs();
6574
6575     IXMLDOMDocument_Release(doc);
6576 }
6577
6578 static void test_IObjectSafety(void)
6579 {
6580     IXMLDOMDocument *doc;
6581     IObjectSafety *safety;
6582     HRESULT hr;
6583
6584     doc = create_document(&IID_IXMLDOMDocument);
6585     if (!doc) return;
6586
6587     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IObjectSafety, (void**)&safety);
6588     ok(hr == S_OK, "ret %08x\n", hr );
6589
6590     test_IObjectSafety_common(safety);
6591
6592     IObjectSafety_Release(safety);
6593     IXMLDOMDocument_Release(doc);
6594
6595     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
6596         &IID_IObjectSafety, (void**)&safety);
6597     ok(hr == S_OK, "Could not create XMLHTTPRequest instance: %08x\n", hr);
6598
6599     test_IObjectSafety_common(safety);
6600
6601     IObjectSafety_Release(safety);
6602
6603 }
6604
6605 typedef struct _property_test_t {
6606     const GUID *guid;
6607     const char *clsid;
6608     const char *property;
6609     const char *value;
6610 } property_test_t;
6611
6612 static const property_test_t properties_test_data[] = {
6613     { &CLSID_DOMDocument,  "CLSID_DOMDocument" , "SelectionLanguage", "XSLPattern" },
6614     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2" , "SelectionLanguage", "XSLPattern" },
6615     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "SelectionLanguage", "XSLPattern" },
6616     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "SelectionLanguage", "XPath" },
6617     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "SelectionLanguage", "XPath" },
6618     { 0 }
6619 };
6620
6621 static void test_default_properties(void)
6622 {
6623     const property_test_t *entry = properties_test_data;
6624
6625     while (entry->guid)
6626     {
6627         IXMLDOMDocument2 *doc;
6628         VARIANT var;
6629         HRESULT hr;
6630
6631         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
6632         if (hr != S_OK)
6633         {
6634             win_skip("can't create %s instance\n", entry->clsid);
6635             entry++;
6636             continue;
6637         }
6638
6639         hr = IXMLDOMDocument2_getProperty(doc, _bstr_(entry->property), &var);
6640         ok(hr == S_OK, "got 0x%08x\n", hr);
6641         ok(lstrcmpW(V_BSTR(&var), _bstr_(entry->value)) == 0, "expected %s, for %s\n",
6642            entry->value, entry->clsid);
6643         VariantClear(&var);
6644
6645         IXMLDOMDocument2_Release(doc);
6646
6647         entry++;
6648     }
6649 }
6650
6651 typedef struct {
6652     const char *query;
6653     const char *list;
6654 } xslpattern_test_t;
6655
6656 static const xslpattern_test_t xslpattern_test[] = {
6657     { "root//elem[0]", "E1.E2.D1" },
6658     { "root//elem[index()=1]", "E2.E2.D1" },
6659     { "root//elem[index() $eq$ 1]", "E2.E2.D1" },
6660     { "root//elem[end()]", "E4.E2.D1" },
6661     { "root//elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
6662     { "root//elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6663     { "root//elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6664     { "root//elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
6665     { "root//elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
6666     { "root//elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
6667     { "root//elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
6668     { "root//elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
6669     { "root//elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
6670     { "root//elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
6671     { "root//elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
6672     { "root//elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
6673     { "root//elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6674     { "root//elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
6675     { "root//elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
6676     { "root//elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
6677     { "root//elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
6678     { "root//elem[$any$ *='B2 field']", "E2.E2.D1" },
6679     { "root//elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6680     { "root//elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
6681     { "root//elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
6682     { "root//elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
6683     { "root//elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6684     { "root//elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6685     { "root//elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6686     { "root/elem[0]", "E1.E2.D1" },
6687     { "root/elem[index()=1]", "E2.E2.D1" },
6688     { "root/elem[index() $eq$ 1]", "E2.E2.D1" },
6689     { "root/elem[end()]", "E4.E2.D1" },
6690     { "root/elem[$not$ end()]", "E1.E2.D1 E2.E2.D1 E3.E2.D1" },
6691     { "root/elem[index() != 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6692     { "root/elem[index() $ne$ 0]", "E2.E2.D1 E3.E2.D1 E4.E2.D1" },
6693     { "root/elem[index() < 2]", "E1.E2.D1 E2.E2.D1" },
6694     { "root/elem[index() $lt$ 2]", "E1.E2.D1 E2.E2.D1" },
6695     { "root/elem[index() <= 1]", "E1.E2.D1 E2.E2.D1" },
6696     { "root/elem[index() $le$ 1]", "E1.E2.D1 E2.E2.D1" },
6697     { "root/elem[index() > 1]", "E3.E2.D1 E4.E2.D1" },
6698     { "root/elem[index() $gt$ 1]", "E3.E2.D1 E4.E2.D1" },
6699     { "root/elem[index() >= 2]", "E3.E2.D1 E4.E2.D1" },
6700     { "root/elem[index() $ge$ 2]", "E3.E2.D1 E4.E2.D1" },
6701     { "root/elem[a $ieq$ 'a2 field']", "E2.E2.D1" },
6702     { "root/elem[a $ine$ 'a2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6703     { "root/elem[a $ilt$ 'a3 field']", "E1.E2.D1 E2.E2.D1" },
6704     { "root/elem[a $ile$ 'a2 field']", "E1.E2.D1 E2.E2.D1" },
6705     { "root/elem[a $igt$ 'a2 field']", "E3.E2.D1 E4.E2.D1" },
6706     { "root/elem[a $ige$ 'a3 field']", "E3.E2.D1 E4.E2.D1" },
6707     { "root/elem[$any$ *='B2 field']", "E2.E2.D1" },
6708     { "root/elem[$all$ *!='B2 field']", "E1.E2.D1 E3.E2.D1 E4.E2.D1" },
6709     { "root/elem[index()=0 or end()]", "E1.E2.D1 E4.E2.D1" },
6710     { "root/elem[index()=0 $or$ end()]", "E1.E2.D1 E4.E2.D1" },
6711     { "root/elem[index()=0 || end()]", "E1.E2.D1 E4.E2.D1" },
6712     { "root/elem[index()>0 and $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6713     { "root/elem[index()>0 $and$ $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6714     { "root/elem[index()>0 && $not$ end()]", "E2.E2.D1 E3.E2.D1" },
6715     { "root/elem[d]", "E1.E2.D1 E2.E2.D1 E4.E2.D1" },
6716     { NULL }
6717 };
6718
6719 static const xslpattern_test_t xslpattern_test_no_ns[] = {
6720     /* prefixes don't need to be registered, you may use them as they are in the doc */
6721     { "//bar:x", "E5.E1.E5.E1.E2.D1 E6.E2.E5.E1.E2.D1" },
6722     /* prefixes must be explicitly specified in the name */
6723     { "//foo:elem", "" },
6724     { "//foo:c", "E3.E4.E2.D1" },
6725     { NULL }
6726 };
6727
6728 static const xslpattern_test_t xslpattern_test_func[] = {
6729     { "attribute()", "" },
6730     { "attribute('depth')", "" },
6731     { "root/attribute('depth')", "A'depth'.E3.D1" },
6732     { "//x/attribute()", "A'id'.E3.E3.D1 A'depth'.E3.E3.D1" },
6733     { "//x//attribute(id)", NULL },
6734     { "//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" },
6735     { "comment()", "C2.D1" },
6736     { "//comment()", "C2.D1 C1.E3.D1 C2.E3.E3.D1 C2.E4.E3.D1" },
6737     { "element()", "E3.D1" },
6738     { "root/y/element()", "E4.E4.E3.D1 E5.E4.E3.D1 E6.E4.E3.D1" },
6739     { "//element(a)", NULL },
6740     { "//element('a')", "E4.E3.E3.D1 E4.E4.E3.D1" },
6741     { "node()", "P1.D1 C2.D1 E3.D1" },
6742     { "//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" },
6743     { "//x/node()[nodeType()=1]", "E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1" },
6744     { "//x/node()[nodeType()=3]", "T3.E3.E3.D1" },
6745     { "//x/node()[nodeType()=7]", "P1.E3.E3.D1" },
6746     { "//x/node()[nodeType()=8]", "C2.E3.E3.D1" },
6747     { "pi()", "P1.D1" },
6748     { "//y/pi()", "P1.E4.E3.D1" },
6749     { "root/textnode()", "T2.E3.D1" },
6750     { "root/element()/textnode()", "T3.E3.E3.D1 T3.E4.E3.D1" },
6751     { NULL }
6752 };
6753
6754 static void test_XSLPattern(void)
6755 {
6756     const xslpattern_test_t *ptr = xslpattern_test;
6757     IXMLDOMDocument2 *doc;
6758     IXMLDOMNodeList *list;
6759     VARIANT_BOOL b;
6760     HRESULT hr;
6761     LONG len;
6762
6763     doc = create_document(&IID_IXMLDOMDocument2);
6764     if (!doc) return;
6765
6766     b = VARIANT_FALSE;
6767     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b);
6768     EXPECT_HR(hr, S_OK);
6769     ok(b == VARIANT_TRUE, "failed to load XML string\n");
6770
6771     /* switch to XSLPattern */
6772     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern"));
6773     EXPECT_HR(hr, S_OK);
6774
6775     /* XPath doesn't select elements with non-null default namespace with unqualified selectors, XSLPattern does */
6776     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem/c"), &list);
6777     EXPECT_HR(hr, S_OK);
6778
6779     len = 0;
6780     hr = IXMLDOMNodeList_get_length(list, &len);
6781     EXPECT_HR(hr, S_OK);
6782     /* should select <elem><c> and <elem xmlns='...'><c> but not <elem><foo:c> */
6783     ok(len == 3, "expected 3 entries in list, got %d\n", len);
6784     IXMLDOMNodeList_Release(list);
6785
6786     while (ptr->query)
6787     {
6788         list = NULL;
6789         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
6790         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
6791         len = 0;
6792         hr = IXMLDOMNodeList_get_length(list, &len);
6793         ok(len != 0, "query=%s, empty list\n", ptr->query);
6794         if (len)
6795             expect_list_and_release(list, ptr->list);
6796
6797         ptr++;
6798     }
6799
6800     /* namespace handling */
6801     /* no registered namespaces */
6802     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_(""));
6803     EXPECT_HR(hr, S_OK);
6804
6805     ptr = xslpattern_test_no_ns;
6806     while (ptr->query)
6807     {
6808         list = NULL;
6809         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
6810         ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
6811
6812         if (*ptr->list)
6813         {
6814             len = 0;
6815             hr = IXMLDOMNodeList_get_length(list, &len);
6816             EXPECT_HR(hr, S_OK);
6817             ok(len != 0, "query=%s, empty list\n", ptr->query);
6818         }
6819         else
6820         {
6821             len = 1;
6822             hr = IXMLDOMNodeList_get_length(list, &len);
6823             EXPECT_HR(hr, S_OK);
6824             ok(len == 0, "query=%s, empty list\n", ptr->query);
6825         }
6826         if (len)
6827             expect_list_and_release(list, ptr->list);
6828
6829         ptr++;
6830     }
6831
6832     /* explicitly register prefix foo */
6833     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
6834
6835     /* now we get the same behavior as XPath */
6836     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
6837     EXPECT_HR(hr, S_OK);
6838     len = 0;
6839     hr = IXMLDOMNodeList_get_length(list, &len);
6840     EXPECT_HR(hr, S_OK);
6841     ok(len != 0, "expected filled list\n");
6842     if (len)
6843         expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
6844
6845     /* set prefix foo to some nonexistent namespace */
6846     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:nonexistent-foo'"));
6847     EXPECT_HR(hr, S_OK);
6848
6849     /* the registered prefix takes precedence */
6850     hr = IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list);
6851     EXPECT_HR(hr, S_OK);
6852     len = 0;
6853     hr = IXMLDOMNodeList_get_length(list, &len);
6854     EXPECT_HR(hr, S_OK);
6855     ok(len == 0, "expected empty list\n");
6856     IXMLDOMNodeList_Release(list);
6857
6858     IXMLDOMDocument2_Release(doc);
6859
6860     doc = create_document(&IID_IXMLDOMDocument2);
6861     if (!doc) return;
6862
6863     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNodeTypesXML), &b);
6864     EXPECT_HR(hr, S_OK);
6865     ok(b == VARIANT_TRUE, "failed to load XML string\n");
6866
6867     ptr = xslpattern_test_func;
6868     while (ptr->query)
6869     {
6870         list = NULL;
6871         hr = IXMLDOMDocument2_selectNodes(doc, _bstr_(ptr->query), &list);
6872         if (ptr->list)
6873         {
6874             ok(hr == S_OK, "query=%s, failed with 0x%08x\n", ptr->query, hr);
6875             len = 0;
6876             hr = IXMLDOMNodeList_get_length(list, &len);
6877             if (*ptr->list)
6878             {
6879                 ok(len != 0, "query=%s, empty list\n", ptr->query);
6880                 if (len)
6881                     expect_list_and_release(list, ptr->list);
6882             }
6883             else
6884                 ok(len == 0, "query=%s, filled list\n", ptr->query);
6885         }
6886         else
6887             ok(hr == E_FAIL, "query=%s, failed with 0x%08x\n", ptr->query, hr);
6888
6889         ptr++;
6890     }
6891
6892     IXMLDOMDocument2_Release(doc);
6893     free_bstrs();
6894 }
6895
6896 static void test_splitText(void)
6897 {
6898     IXMLDOMCDATASection *cdata;
6899     IXMLDOMElement *root;
6900     IXMLDOMDocument *doc;
6901     IXMLDOMText *text, *text2;
6902     IXMLDOMNode *node;
6903     VARIANT var;
6904     VARIANT_BOOL success;
6905     LONG length;
6906     HRESULT hr;
6907
6908     doc = create_document(&IID_IXMLDOMDocument);
6909     if (!doc) return;
6910
6911     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<root></root>"), &success);
6912     ok(hr == S_OK, "got 0x%08x\n", hr);
6913
6914     hr = IXMLDOMDocument_get_documentElement(doc, &root);
6915     ok(hr == S_OK, "got 0x%08x\n", hr);
6916
6917     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("beautiful plumage"), &cdata);
6918     ok(hr == S_OK, "got 0x%08x\n", hr);
6919
6920     V_VT(&var) = VT_EMPTY;
6921     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)cdata, NULL);
6922     ok(hr == S_OK, "got 0x%08x\n", hr);
6923
6924     length = 0;
6925     hr = IXMLDOMCDATASection_get_length(cdata, &length);
6926     ok(hr == S_OK, "got 0x%08x\n", hr);
6927     ok(length > 0, "got %d\n", length);
6928
6929     hr = IXMLDOMCDATASection_splitText(cdata, 0, NULL);
6930     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
6931
6932     text = (void*)0xdeadbeef;
6933     /* negative offset */
6934     hr = IXMLDOMCDATASection_splitText(cdata, -1, &text);
6935     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
6936     ok(text == (void*)0xdeadbeef, "got %p\n", text);
6937
6938     text = (void*)0xdeadbeef;
6939     /* offset outside data */
6940     hr = IXMLDOMCDATASection_splitText(cdata, length + 1, &text);
6941     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
6942     ok(text == 0, "got %p\n", text);
6943
6944     text = (void*)0xdeadbeef;
6945     /* offset outside data */
6946     hr = IXMLDOMCDATASection_splitText(cdata, length, &text);
6947     ok(hr == S_FALSE, "got 0x%08x\n", hr);
6948     ok(text == 0, "got %p\n", text);
6949
6950     /* no empty node created */
6951     node = (void*)0xdeadbeef;
6952     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
6953     ok(hr == S_FALSE, "got 0x%08x\n", hr);
6954     ok(node == 0, "got %p\n", text);
6955
6956     hr = IXMLDOMCDATASection_splitText(cdata, 10, &text);
6957     ok(hr == S_OK, "got 0x%08x\n", hr);
6958
6959     length = 0;
6960     hr = IXMLDOMText_get_length(text, &length);
6961     ok(hr == S_OK, "got 0x%08x\n", hr);
6962     ok(length == 7, "got %d\n", length);
6963
6964     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
6965     ok(hr == S_OK, "got 0x%08x\n", hr);
6966     IXMLDOMNode_Release(node);
6967
6968     /* split new text node */
6969     hr = IXMLDOMText_get_length(text, &length);
6970     ok(hr == S_OK, "got 0x%08x\n", hr);
6971
6972     node = (void*)0xdeadbeef;
6973     hr = IXMLDOMText_get_nextSibling(text, &node);
6974     ok(hr == S_FALSE, "got 0x%08x\n", hr);
6975     ok(node == 0, "got %p\n", text);
6976
6977     hr = IXMLDOMText_splitText(text, 0, NULL);
6978     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
6979
6980     text2 = (void*)0xdeadbeef;
6981     /* negative offset */
6982     hr = IXMLDOMText_splitText(text, -1, &text2);
6983     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
6984     ok(text2 == (void*)0xdeadbeef, "got %p\n", text2);
6985
6986     text2 = (void*)0xdeadbeef;
6987     /* offset outside data */
6988     hr = IXMLDOMText_splitText(text, length + 1, &text2);
6989     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
6990     ok(text2 == 0, "got %p\n", text2);
6991
6992     text2 = (void*)0xdeadbeef;
6993     /* offset outside data */
6994     hr = IXMLDOMText_splitText(text, length, &text2);
6995     ok(hr == S_FALSE, "got 0x%08x\n", hr);
6996     ok(text2 == 0, "got %p\n", text);
6997
6998     text2 = 0;
6999     hr = IXMLDOMText_splitText(text, 4, &text2);
7000     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7001     if (text2) IXMLDOMText_Release(text2);
7002
7003     node = 0;
7004     hr = IXMLDOMText_get_nextSibling(text, &node);
7005     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7006     if (node) IXMLDOMNode_Release(node);
7007
7008     IXMLDOMText_Release(text);
7009     IXMLDOMElement_Release(root);
7010     IXMLDOMCDATASection_Release(cdata);
7011     free_bstrs();
7012 }
7013
7014 typedef struct {
7015     const char *name;
7016     const char *uri;
7017     HRESULT hr;
7018 } ns_item_t;
7019
7020 /* default_ns_doc used */
7021 static const ns_item_t qualified_item_tests[] = {
7022     { "xml:lang", NULL, S_FALSE },
7023     { "xml:lang", "http://www.w3.org/XML/1998/namespace", S_FALSE },
7024     { "lang", "http://www.w3.org/XML/1998/namespace", S_OK },
7025     { "ns:b", NULL, S_FALSE },
7026     { "ns:b", "nshref", S_FALSE },
7027     { "b", "nshref", S_OK },
7028     { "d", NULL, S_OK },
7029     { NULL }
7030 };
7031
7032 static const ns_item_t named_item_tests[] = {
7033     { "xml:lang", NULL, S_OK },
7034     { "lang", NULL, S_FALSE },
7035     { "ns:b", NULL, S_OK },
7036     { "b", NULL, S_FALSE },
7037     { "d", NULL, S_OK },
7038     { NULL }
7039 };
7040
7041 static void test_getQualifiedItem(void)
7042 {
7043     IXMLDOMNode *pr_node, *node;
7044     IXMLDOMNodeList *root_list;
7045     IXMLDOMNamedNodeMap *map;
7046     IXMLDOMElement *element;
7047     const ns_item_t* ptr;
7048     IXMLDOMDocument *doc;
7049     VARIANT_BOOL b;
7050     HRESULT hr;
7051     LONG len;
7052
7053     doc = create_document(&IID_IXMLDOMDocument);
7054     if (!doc) return;
7055
7056     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7057     EXPECT_HR(hr, S_OK);
7058     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7059
7060     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7061     EXPECT_HR(hr, S_OK);
7062
7063     hr = IXMLDOMElement_get_childNodes(element, &root_list);
7064     EXPECT_HR(hr, S_OK);
7065
7066     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7067     EXPECT_HR(hr, S_OK);
7068     IXMLDOMNodeList_Release(root_list);
7069
7070     hr = IXMLDOMNode_get_attributes(pr_node, &map);
7071     EXPECT_HR(hr, S_OK);
7072     IXMLDOMNode_Release(pr_node);
7073
7074     len = 0;
7075     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7076     EXPECT_HR(hr, S_OK);
7077     ok( len == 3, "length %d\n", len);
7078
7079     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, NULL);
7080     EXPECT_HR(hr, E_INVALIDARG);
7081
7082     node = (void*)0xdeadbeef;
7083     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, &node);
7084     EXPECT_HR(hr, E_INVALIDARG);
7085     ok( node == (void*)0xdeadbeef, "got %p\n", node);
7086
7087     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, NULL);
7088     EXPECT_HR(hr, E_INVALIDARG);
7089
7090     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, &node);
7091     EXPECT_HR(hr, S_OK);
7092
7093     IXMLDOMNode_Release(node);
7094     IXMLDOMNamedNodeMap_Release(map);
7095     IXMLDOMElement_Release(element);
7096
7097     hr = IXMLDOMDocument_loadXML(doc, _bstr_(default_ns_doc), &b);
7098     EXPECT_HR(hr, S_OK);
7099
7100     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("a"), &node);
7101     EXPECT_HR(hr, S_OK);
7102
7103     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&element);
7104     EXPECT_HR(hr, S_OK);
7105     IXMLDOMNode_Release(node);
7106
7107     hr = IXMLDOMElement_get_attributes(element, &map);
7108     EXPECT_HR(hr, S_OK);
7109
7110     ptr = qualified_item_tests;
7111     while (ptr->name)
7112     {
7113        node = (void*)0xdeadbeef;
7114        hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_(ptr->name), _bstr_(ptr->uri), &node);
7115        ok(hr == ptr->hr, "%s, %s: got 0x%08x, expected 0x%08x\n", ptr->name, ptr->uri, hr, ptr->hr);
7116        if (hr == S_OK)
7117            IXMLDOMNode_Release(node);
7118        else
7119            ok(node == NULL, "%s, %s: got %p\n", ptr->name, ptr->uri, node);
7120        ptr++;
7121     }
7122
7123     ptr = named_item_tests;
7124     while (ptr->name)
7125     {
7126        node = (void*)0xdeadbeef;
7127        hr = IXMLDOMNamedNodeMap_getNamedItem(map, _bstr_(ptr->name), &node);
7128        ok(hr == ptr->hr, "%s: got 0x%08x, expected 0x%08x\n", ptr->name, hr, ptr->hr);
7129        if (hr == S_OK)
7130            IXMLDOMNode_Release(node);
7131        else
7132            ok(node == NULL, "%s: got %p\n", ptr->name, node);
7133        ptr++;
7134     }
7135
7136     IXMLDOMNamedNodeMap_Release(map);
7137
7138     IXMLDOMElement_Release(element);
7139     IXMLDOMDocument_Release(doc);
7140     free_bstrs();
7141 }
7142
7143 static void test_removeQualifiedItem(void)
7144 {
7145     IXMLDOMDocument *doc;
7146     IXMLDOMElement *element;
7147     IXMLDOMNode *pr_node, *node;
7148     IXMLDOMNodeList *root_list;
7149     IXMLDOMNamedNodeMap *map;
7150     VARIANT_BOOL b;
7151     LONG len;
7152     HRESULT hr;
7153
7154     doc = create_document(&IID_IXMLDOMDocument);
7155     if (!doc) return;
7156
7157     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7158     ok( hr == S_OK, "loadXML failed\n");
7159     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7160
7161     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7162     ok( hr == S_OK, "ret %08x\n", hr);
7163
7164     hr = IXMLDOMElement_get_childNodes(element, &root_list);
7165     ok( hr == S_OK, "ret %08x\n", hr);
7166
7167     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7168     ok( hr == S_OK, "ret %08x\n", hr);
7169     IXMLDOMNodeList_Release(root_list);
7170
7171     hr = IXMLDOMNode_get_attributes(pr_node, &map);
7172     ok( hr == S_OK, "ret %08x\n", hr);
7173     IXMLDOMNode_Release(pr_node);
7174
7175     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7176     ok( hr == S_OK, "ret %08x\n", hr);
7177     ok( len == 3, "length %d\n", len);
7178
7179     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, NULL);
7180     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7181
7182     node = (void*)0xdeadbeef;
7183     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, &node);
7184     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7185     ok( node == (void*)0xdeadbeef, "got %p\n", node);
7186
7187     /* out pointer is optional */
7188     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7189     ok( hr == S_OK, "ret %08x\n", hr);
7190
7191     /* already removed */
7192     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7193     ok( hr == S_FALSE, "ret %08x\n", hr);
7194
7195     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("vr"), NULL, &node);
7196     ok( hr == S_OK, "ret %08x\n", hr);
7197     IXMLDOMNode_Release(node);
7198
7199     IXMLDOMNamedNodeMap_Release( map );
7200     IXMLDOMElement_Release( element );
7201     IXMLDOMDocument_Release( doc );
7202     free_bstrs();
7203 }
7204
7205 #define check_default_props(doc) _check_default_props(__LINE__, doc)
7206 static inline void _check_default_props(int line, IXMLDOMDocument2* doc)
7207 {
7208     VARIANT_BOOL b;
7209     VARIANT var;
7210     HRESULT hr;
7211
7212     VariantInit(&var);
7213     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
7214     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XSLPattern")) == 0, "expected XSLPattern\n");
7215     VariantClear(&var);
7216
7217     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
7218     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("")) == 0, "expected empty string\n");
7219     VariantClear(&var);
7220
7221     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
7222     ok_(__FILE__, line)(b == VARIANT_FALSE, "expected FALSE\n");
7223
7224     hr = IXMLDOMDocument2_get_schemas(doc, &var);
7225     ok_(__FILE__, line)(hr == S_FALSE, "got %08x\n", hr);
7226     VariantClear(&var);
7227 }
7228
7229 #define check_set_props(doc) _check_set_props(__LINE__, doc)
7230 static inline void _check_set_props(int line, IXMLDOMDocument2* doc)
7231 {
7232     VARIANT_BOOL b;
7233     VARIANT var;
7234
7235     VariantInit(&var);
7236     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var));
7237     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("XPath")) == 0, "expected XPath\n");
7238     VariantClear(&var);
7239
7240     helper_ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
7241     ok_(__FILE__, line)(lstrcmpW(V_BSTR(&var), _bstr_("xmlns:wi=\'www.winehq.org\'")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&var)));
7242     VariantClear(&var);
7243
7244     helper_ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc, &b));
7245     ok_(__FILE__, line)(b == VARIANT_TRUE, "expected TRUE\n");
7246
7247     helper_ole_check(IXMLDOMDocument2_get_schemas(doc, &var));
7248     ok_(__FILE__, line)(V_VT(&var) != VT_NULL, "expected pointer\n");
7249     VariantClear(&var);
7250 }
7251
7252 #define set_props(doc, cache) _set_props(__LINE__, doc, cache)
7253 static inline void _set_props(int line, IXMLDOMDocument2* doc, IXMLDOMSchemaCollection* cache)
7254 {
7255     VARIANT var;
7256
7257     VariantInit(&var);
7258     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
7259     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:wi=\'www.winehq.org\'")));
7260     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_TRUE));
7261     V_VT(&var) = VT_DISPATCH;
7262     V_DISPATCH(&var) = NULL;
7263     helper_ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&var)));
7264     ok_(__FILE__, line)(V_DISPATCH(&var) != NULL, "expected pointer\n");
7265     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
7266     VariantClear(&var);
7267 }
7268
7269 #define unset_props(doc) _unset_props(__LINE__, doc)
7270 static inline void _unset_props(int line, IXMLDOMDocument2* doc)
7271 {
7272     VARIANT var;
7273
7274     VariantInit(&var);
7275     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
7276     helper_ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("")));
7277     helper_ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc, VARIANT_FALSE));
7278     V_VT(&var) = VT_NULL;
7279     helper_ole_check(IXMLDOMDocument2_putref_schemas(doc, var));
7280     VariantClear(&var);
7281 }
7282
7283 static void test_get_ownerDocument(void)
7284 {
7285     IXMLDOMDocument *doc1, *doc2, *doc3;
7286     IXMLDOMDocument2 *doc, *doc_owner;
7287     IXMLDOMNode *node;
7288     IXMLDOMSchemaCollection *cache;
7289     VARIANT_BOOL b;
7290     VARIANT var;
7291
7292     doc = create_document(&IID_IXMLDOMDocument2);
7293     cache = create_cache(&IID_IXMLDOMSchemaCollection);
7294     if (!doc || !cache)
7295     {
7296         if (doc) IXMLDOMDocument2_Release(doc);
7297         if (cache) IXMLDOMSchemaCollection_Release(cache);
7298         return;
7299     }
7300
7301     VariantInit(&var);
7302
7303     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
7304     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7305
7306     check_default_props(doc);
7307
7308     /* set properties and check that new instances use them */
7309     set_props(doc, cache);
7310     check_set_props(doc);
7311
7312     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
7313     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc1));
7314
7315     /* new interface keeps props */
7316     ole_check(IXMLDOMDocument_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**)&doc_owner));
7317     ok( doc_owner != doc, "got %p, doc %p\n", doc_owner, doc);
7318     check_set_props(doc_owner);
7319     IXMLDOMDocument2_Release(doc_owner);
7320
7321     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc2));
7322     IXMLDOMNode_Release(node);
7323
7324     ok(doc1 != doc2, "got %p, expected %p. original %p\n", doc2, doc1, doc);
7325
7326     /* reload */
7327     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(complete4A), &b));
7328     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7329
7330     /* properties retained even after reload */
7331     check_set_props(doc);
7332
7333     ole_check(IXMLDOMDocument2_get_firstChild(doc, &node));
7334     ole_check(IXMLDOMNode_get_ownerDocument(node, &doc3));
7335     IXMLDOMNode_Release(node);
7336
7337     ole_check(IXMLDOMDocument_QueryInterface(doc3, &IID_IXMLDOMDocument2, (void**)&doc_owner));
7338     ok(doc3 != doc1 && doc3 != doc2 && doc_owner != doc, "got %p, (%p, %p, %p)\n", doc3, doc, doc1, doc2);
7339     check_set_props(doc_owner);
7340
7341     /* changing properties for one instance changes them for all */
7342     unset_props(doc_owner);
7343     check_default_props(doc_owner);
7344     check_default_props(doc);
7345
7346     IXMLDOMSchemaCollection_Release(cache);
7347     IXMLDOMDocument_Release(doc1);
7348     IXMLDOMDocument_Release(doc2);
7349     IXMLDOMDocument_Release(doc3);
7350     IXMLDOMDocument2_Release(doc);
7351     IXMLDOMDocument2_Release(doc_owner);
7352     free_bstrs();
7353 }
7354
7355 static void test_setAttributeNode(void)
7356 {
7357     IXMLDOMDocument *doc, *doc2;
7358     IXMLDOMElement *elem, *elem2;
7359     IXMLDOMAttribute *attr, *attr2, *ret_attr;
7360     VARIANT_BOOL b;
7361     HRESULT hr;
7362     VARIANT v;
7363     BSTR str;
7364     ULONG ref1, ref2;
7365
7366     doc = create_document(&IID_IXMLDOMDocument);
7367     if (!doc) return;
7368
7369     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7370     ok( hr == S_OK, "loadXML failed\n");
7371     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7372
7373     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7374     ok( hr == S_OK, "got 0x%08x\n", hr);
7375
7376     hr = IXMLDOMDocument_get_documentElement(doc, &elem2);
7377     ok( hr == S_OK, "got 0x%08x\n", hr);
7378     ok( elem2 != elem, "got same instance\n");
7379
7380     ret_attr = (void*)0xdeadbeef;
7381     hr = IXMLDOMElement_setAttributeNode(elem, NULL, &ret_attr);
7382     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
7383     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7384
7385     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
7386     ok( hr == S_OK, "got 0x%08x\n", hr);
7387
7388     ref1 = IXMLDOMElement_AddRef(elem);
7389     IXMLDOMElement_Release(elem);
7390
7391     ret_attr = (void*)0xdeadbeef;
7392     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7393     ok( hr == S_OK, "got 0x%08x\n", hr);
7394     ok( ret_attr == NULL, "got %p\n", ret_attr);
7395
7396     /* no reference added */
7397     ref2 = IXMLDOMElement_AddRef(elem);
7398     IXMLDOMElement_Release(elem);
7399     ok(ref2 == ref1, "got %d, expected %d\n", ref2, ref1);
7400
7401     EXPECT_CHILDREN(elem);
7402     EXPECT_CHILDREN(elem2);
7403
7404     IXMLDOMElement_Release(elem2);
7405
7406     attr2 = NULL;
7407     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attr"), &attr2);
7408     ok( hr == S_OK, "got 0x%08x\n", hr);
7409     ok( attr2 != attr, "got same instance %p\n", attr2);
7410     IXMLDOMAttribute_Release(attr2);
7411
7412     /* try to add it another time */
7413     ret_attr = (void*)0xdeadbeef;
7414     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7415     ok( hr == E_FAIL, "got 0x%08x\n", hr);
7416     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7417
7418     IXMLDOMElement_Release(elem);
7419
7420     /* initially used element is released, attribute still 'has' a container */
7421     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7422     ok( hr == S_OK, "got 0x%08x\n", hr);
7423     ret_attr = (void*)0xdeadbeef;
7424     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7425     ok( hr == E_FAIL, "got 0x%08x\n", hr);
7426     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7427     IXMLDOMElement_Release(elem);
7428
7429     /* add attribute already attached to another document */
7430     doc2 = create_document(&IID_IXMLDOMDocument);
7431
7432     hr = IXMLDOMDocument_loadXML( doc2, _bstr_(complete4A), &b );
7433     ok( hr == S_OK, "loadXML failed\n");
7434     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7435
7436     hr = IXMLDOMDocument_get_documentElement(doc2, &elem);
7437     ok( hr == S_OK, "got 0x%08x\n", hr);
7438     hr = IXMLDOMElement_setAttributeNode(elem, attr, NULL);
7439     ok( hr == E_FAIL, "got 0x%08x\n", hr);
7440     IXMLDOMElement_Release(elem);
7441
7442     IXMLDOMAttribute_Release(attr);
7443
7444     /* create element, add attribute, see if it's copied or linked */
7445     hr = IXMLDOMDocument_createElement(doc, _bstr_("test"), &elem);
7446     ok( hr == S_OK, "got 0x%08x\n", hr);
7447
7448     attr = NULL;
7449     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
7450     ok(hr == S_OK, "got 0x%08x\n", hr);
7451     ok(attr != NULL, "got %p\n", attr);
7452
7453     ref1 = IXMLDOMAttribute_AddRef(attr);
7454     IXMLDOMAttribute_Release(attr);
7455
7456     V_VT(&v) = VT_BSTR;
7457     V_BSTR(&v) = _bstr_("attrvalue1");
7458     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
7459     ok( hr == S_OK, "got 0x%08x\n", hr);
7460
7461     str = NULL;
7462     hr = IXMLDOMAttribute_get_xml(attr, &str);
7463     ok( hr == S_OK, "got 0x%08x\n", hr);
7464     ok( lstrcmpW(str, _bstr_("attr=\"attrvalue1\"")) == 0,
7465         "got %s\n", wine_dbgstr_w(str));
7466     SysFreeString(str);
7467
7468     ret_attr = (void*)0xdeadbeef;
7469     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7470     ok(hr == S_OK, "got 0x%08x\n", hr);
7471     ok(ret_attr == NULL, "got %p\n", ret_attr);
7472
7473     /* attribute reference increased */
7474     ref2 = IXMLDOMAttribute_AddRef(attr);
7475     IXMLDOMAttribute_Release(attr);
7476     ok(ref1 == ref2, "got %d, expected %d\n", ref2, ref1);
7477
7478     hr = IXMLDOMElement_get_xml(elem, &str);
7479     ok( hr == S_OK, "got 0x%08x\n", hr);
7480     ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue1\"/>")) == 0,
7481         "got %s\n", wine_dbgstr_w(str));
7482     SysFreeString(str);
7483
7484     V_VT(&v) = VT_BSTR;
7485     V_BSTR(&v) = _bstr_("attrvalue2");
7486     hr = IXMLDOMAttribute_put_nodeValue(attr, v);
7487     ok( hr == S_OK, "got 0x%08x\n", hr);
7488
7489     hr = IXMLDOMElement_get_xml(elem, &str);
7490     ok( hr == S_OK, "got 0x%08x\n", hr);
7491     todo_wine ok( lstrcmpW(str, _bstr_("<test attr=\"attrvalue2\"/>")) == 0,
7492         "got %s\n", wine_dbgstr_w(str));
7493     SysFreeString(str);
7494
7495     IXMLDOMElement_Release(elem);
7496     IXMLDOMAttribute_Release(attr);
7497     IXMLDOMDocument_Release(doc2);
7498     IXMLDOMDocument_Release(doc);
7499     free_bstrs();
7500 }
7501
7502 static void test_createNode(void)
7503 {
7504     IXMLDOMDocument *doc;
7505     IXMLDOMElement *elem;
7506     IXMLDOMNode *node;
7507     VARIANT v, var;
7508     BSTR prefix, str;
7509     HRESULT hr;
7510     ULONG ref;
7511
7512     doc = create_document(&IID_IXMLDOMDocument);
7513     if (!doc) return;
7514
7515     EXPECT_REF(doc, 1);
7516
7517     /* reference count tests */
7518     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
7519     ok( hr == S_OK, "got 0x%08x\n", hr);
7520
7521     /* initial reference is 2 */
7522 todo_wine {
7523     EXPECT_REF(elem, 2);
7524     ref = IXMLDOMElement_Release(elem);
7525     ok(ref == 1, "got %d\n", ref);
7526     /* it's released already, attempt to release now will crash it */
7527 }
7528
7529     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
7530     ok( hr == S_OK, "got 0x%08x\n", hr);
7531     todo_wine EXPECT_REF(elem, 2);
7532     IXMLDOMDocument_Release(doc);
7533     todo_wine EXPECT_REF(elem, 2);
7534     IXMLDOMElement_Release(elem);
7535
7536     doc = create_document(&IID_IXMLDOMDocument);
7537
7538     /* NODE_ELEMENT nodes */
7539     /* 1. specified namespace */
7540     V_VT(&v) = VT_I4;
7541     V_I4(&v) = NODE_ELEMENT;
7542
7543     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("ns1:test"), _bstr_("http://winehq.org"), &node);
7544     ok( hr == S_OK, "got 0x%08x\n", hr);
7545     prefix = NULL;
7546     hr = IXMLDOMNode_get_prefix(node, &prefix);
7547     ok( hr == S_OK, "got 0x%08x\n", hr);
7548     ok(lstrcmpW(prefix, _bstr_("ns1")) == 0, "wrong prefix\n");
7549     SysFreeString(prefix);
7550     IXMLDOMNode_Release(node);
7551
7552     /* 2. default namespace */
7553     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("test"), _bstr_("http://winehq.org/default"), &node);
7554     ok( hr == S_OK, "got 0x%08x\n", hr);
7555     prefix = (void*)0xdeadbeef;
7556     hr = IXMLDOMNode_get_prefix(node, &prefix);
7557     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7558     ok(prefix == 0, "expected empty prefix, got %p\n", prefix);
7559     /* check dump */
7560     hr = IXMLDOMNode_get_xml(node, &str);
7561     ok( hr == S_OK, "got 0x%08x\n", hr);
7562     ok( lstrcmpW(str, _bstr_("<test xmlns=\"http://winehq.org/default\"/>")) == 0,
7563         "got %s\n", wine_dbgstr_w(str));
7564     SysFreeString(str);
7565
7566     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
7567     ok( hr == S_OK, "got 0x%08x\n", hr);
7568
7569     V_VT(&var) = VT_BSTR;
7570     hr = IXMLDOMElement_getAttribute(elem, _bstr_("xmlns"), &var);
7571     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7572     ok( V_VT(&var) == VT_NULL, "got %d\n", V_VT(&var));
7573
7574     str = NULL;
7575     hr = IXMLDOMElement_get_namespaceURI(elem, &str);
7576     ok( hr == S_OK, "got 0x%08x\n", hr);
7577     ok( lstrcmpW(str, _bstr_("http://winehq.org/default")) == 0, "expected default namespace\n");
7578     SysFreeString(str);
7579
7580     IXMLDOMElement_Release(elem);
7581     IXMLDOMNode_Release(node);
7582
7583     IXMLDOMDocument_Release(doc);
7584     free_bstrs();
7585 }
7586
7587 static const char get_prefix_doc[] =
7588     "<?xml version=\"1.0\" ?>"
7589     "<a xmlns:ns1=\"ns1 href\" />";
7590
7591 static void test_get_prefix(void)
7592 {
7593     IXMLDOMDocumentFragment *fragment;
7594     IXMLDOMCDATASection *cdata;
7595     IXMLDOMElement *element;
7596     IXMLDOMComment *comment;
7597     IXMLDOMDocument *doc;
7598     VARIANT_BOOL b;
7599     HRESULT hr;
7600     BSTR str;
7601
7602     doc = create_document(&IID_IXMLDOMDocument);
7603     if (!doc) return;
7604
7605     /* nodes that can't support prefix */
7606     /* 1. document */
7607     str = (void*)0xdeadbeef;
7608     hr = IXMLDOMDocument_get_prefix(doc, &str);
7609     EXPECT_HR(hr, S_FALSE);
7610     ok(str == NULL, "got %p\n", str);
7611
7612     hr = IXMLDOMDocument_get_prefix(doc, NULL);
7613     EXPECT_HR(hr, E_INVALIDARG);
7614
7615     /* 2. cdata */
7616     hr = IXMLDOMDocument_createCDATASection(doc, NULL, &cdata);
7617     ok(hr == S_OK, "got %08x\n", hr );
7618
7619     str = (void*)0xdeadbeef;
7620     hr = IXMLDOMCDATASection_get_prefix(cdata, &str);
7621     ok(hr == S_FALSE, "got %08x\n", hr);
7622     ok( str == 0, "got %p\n", str);
7623
7624     hr = IXMLDOMCDATASection_get_prefix(cdata, NULL);
7625     ok(hr == E_INVALIDARG, "got %08x\n", hr);
7626     IXMLDOMCDATASection_Release(cdata);
7627
7628     /* 3. comment */
7629     hr = IXMLDOMDocument_createComment(doc, NULL, &comment);
7630     ok(hr == S_OK, "got %08x\n", hr );
7631
7632     str = (void*)0xdeadbeef;
7633     hr = IXMLDOMComment_get_prefix(comment, &str);
7634     ok(hr == S_FALSE, "got %08x\n", hr);
7635     ok( str == 0, "got %p\n", str);
7636
7637     hr = IXMLDOMComment_get_prefix(comment, NULL);
7638     ok(hr == E_INVALIDARG, "got %08x\n", hr);
7639     IXMLDOMComment_Release(comment);
7640
7641     /* 4. fragment */
7642     hr = IXMLDOMDocument_createDocumentFragment(doc, &fragment);
7643     ok(hr == S_OK, "got %08x\n", hr );
7644
7645     str = (void*)0xdeadbeef;
7646     hr = IXMLDOMDocumentFragment_get_prefix(fragment, &str);
7647     ok(hr == S_FALSE, "got %08x\n", hr);
7648     ok( str == 0, "got %p\n", str);
7649
7650     hr = IXMLDOMDocumentFragment_get_prefix(fragment, NULL);
7651     ok(hr == E_INVALIDARG, "got %08x\n", hr);
7652     IXMLDOMDocumentFragment_Release(fragment);
7653
7654     /* no prefix */
7655     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &element);
7656     ok( hr == S_OK, "got 0x%08x\n", hr);
7657
7658     hr = IXMLDOMElement_get_prefix(element, NULL);
7659     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
7660
7661     str = (void*)0xdeadbeef;
7662     hr = IXMLDOMElement_get_prefix(element, &str);
7663     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7664     ok( str == 0, "got %p\n", str);
7665
7666     IXMLDOMElement_Release(element);
7667
7668     /* with prefix */
7669     hr = IXMLDOMDocument_createElement(doc, _bstr_("a:elem"), &element);
7670     ok( hr == S_OK, "got 0x%08x\n", hr);
7671
7672     str = (void*)0xdeadbeef;
7673     hr = IXMLDOMElement_get_prefix(element, &str);
7674     ok( hr == S_OK, "got 0x%08x\n", hr);
7675     ok( lstrcmpW(str, _bstr_("a")) == 0, "expected prefix \"a\"\n");
7676     SysFreeString(str);
7677
7678     str = (void*)0xdeadbeef;
7679     hr = IXMLDOMElement_get_namespaceURI(element, &str);
7680     ok( hr == S_FALSE, "got 0x%08x\n", hr);
7681     ok( str == 0, "got %p\n", str);
7682
7683     IXMLDOMElement_Release(element);
7684
7685     hr = IXMLDOMDocument_loadXML(doc, _bstr_(get_prefix_doc), &b);
7686     EXPECT_HR(hr, S_OK);
7687
7688     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7689     EXPECT_HR(hr, S_OK);
7690
7691     str = (void*)0xdeadbeef;
7692     hr = IXMLDOMElement_get_prefix(element, &str);
7693     EXPECT_HR(hr, S_FALSE);
7694     ok(str == NULL, "got %p\n", str);
7695
7696     str = (void*)0xdeadbeef;
7697     hr = IXMLDOMElement_get_namespaceURI(element, &str);
7698     EXPECT_HR(hr, S_FALSE);
7699     ok(str == NULL, "got %s\n", wine_dbgstr_w(str));
7700
7701     IXMLDOMDocument_Release(doc);
7702     free_bstrs();
7703 }
7704
7705 static void test_selectSingleNode(void)
7706 {
7707     IXMLDOMDocument *doc;
7708     IXMLDOMNodeList *list;
7709     IXMLDOMNode *node;
7710     VARIANT_BOOL b;
7711     HRESULT hr;
7712     LONG len;
7713
7714     doc = create_document(&IID_IXMLDOMDocument);
7715     if (!doc) return;
7716
7717     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
7718     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7719
7720     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
7721     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7722
7723     hr = IXMLDOMDocument_loadXML( doc, _bstr_(complete4A), &b );
7724     ok( hr == S_OK, "loadXML failed\n");
7725     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7726
7727     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
7728     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7729
7730     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
7731     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7732
7733     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), NULL);
7734     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7735
7736     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), NULL);
7737     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7738
7739     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), &node);
7740     ok(hr == S_OK, "got 0x%08x\n", hr);
7741     IXMLDOMNode_Release(node);
7742
7743     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), &list);
7744     ok(hr == S_OK, "got 0x%08x\n", hr);
7745     IXMLDOMNodeList_Release(list);
7746
7747     list = (void*)0xdeadbeef;
7748     hr = IXMLDOMDocument_selectNodes(doc, NULL, &list);
7749     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7750     ok(list == (void*)0xdeadbeef, "got %p\n", list);
7751
7752     node = (void*)0xdeadbeef;
7753     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("nonexistent"), &node);
7754     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7755     ok(node == 0, "got %p\n", node);
7756
7757     list = (void*)0xdeadbeef;
7758     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("nonexistent"), &list);
7759     ok(hr == S_OK, "got 0x%08x\n", hr);
7760     len = 1;
7761     hr = IXMLDOMNodeList_get_length(list, &len);
7762     ok(hr == S_OK, "got 0x%08x\n", hr);
7763     ok(len == 0, "got %d\n", len);
7764     IXMLDOMNodeList_Release(list);
7765
7766     IXMLDOMDocument_Release(doc);
7767     free_bstrs();
7768 }
7769
7770 static void test_events(void)
7771 {
7772     IConnectionPointContainer *conn;
7773     IConnectionPoint *point;
7774     IXMLDOMDocument *doc;
7775     HRESULT hr;
7776     VARIANT v;
7777     IDispatch *event;
7778
7779     doc = create_document(&IID_IXMLDOMDocument);
7780     if (!doc) return;
7781
7782     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&conn);
7783     ok(hr == S_OK, "got 0x%08x\n", hr);
7784
7785     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IDispatch, &point);
7786     ok(hr == S_OK, "got 0x%08x\n", hr);
7787     IConnectionPoint_Release(point);
7788     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IPropertyNotifySink, &point);
7789     ok(hr == S_OK, "got 0x%08x\n", hr);
7790     IConnectionPoint_Release(point);
7791     hr = IConnectionPointContainer_FindConnectionPoint(conn, &DIID_XMLDOMDocumentEvents, &point);
7792     ok(hr == S_OK, "got 0x%08x\n", hr);
7793     IConnectionPoint_Release(point);
7794
7795     IConnectionPointContainer_Release(conn);
7796
7797     /* ready state callback */
7798     VariantInit(&v);
7799     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7800     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
7801
7802     event = create_dispevent();
7803     V_VT(&v) = VT_UNKNOWN;
7804     V_UNKNOWN(&v) = (IUnknown*)event;
7805
7806     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7807     ok(hr == S_OK, "got 0x%08x\n", hr);
7808     EXPECT_REF(event, 2);
7809
7810     V_VT(&v) = VT_DISPATCH;
7811     V_DISPATCH(&v) = event;
7812
7813     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7814     ok(hr == S_OK, "got 0x%08x\n", hr);
7815     EXPECT_REF(event, 2);
7816
7817     /* VT_NULL doesn't reset event handler */
7818     V_VT(&v) = VT_NULL;
7819     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7820     ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
7821     EXPECT_REF(event, 2);
7822
7823     V_VT(&v) = VT_DISPATCH;
7824     V_DISPATCH(&v) = NULL;
7825
7826     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7827     ok(hr == S_OK, "got 0x%08x\n", hr);
7828     EXPECT_REF(event, 1);
7829
7830     V_VT(&v) = VT_UNKNOWN;
7831     V_DISPATCH(&v) = NULL;
7832     hr = IXMLDOMDocument_put_onreadystatechange(doc, v);
7833     ok(hr == S_OK, "got 0x%08x\n", hr);
7834
7835     IDispatch_Release(event);
7836
7837     IXMLDOMDocument_Release(doc);
7838 }
7839
7840 static void test_createProcessingInstruction(void)
7841 {
7842     static const WCHAR bodyW[] = {'t','e','s','t',0};
7843     IXMLDOMProcessingInstruction *pi;
7844     IXMLDOMDocument *doc;
7845     WCHAR buff[10];
7846     HRESULT hr;
7847
7848     doc = create_document(&IID_IXMLDOMDocument);
7849     if (!doc) return;
7850
7851     /* test for BSTR handling, pass broken BSTR */
7852     memcpy(&buff[2], bodyW, sizeof(bodyW));
7853     /* just a big length */
7854     *(DWORD*)buff = 0xf0f0;
7855     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("test"), &buff[2], &pi);
7856     ok(hr == S_OK, "got 0x%08x\n", hr);
7857
7858     IXMLDOMProcessingInstruction_Release(pi);
7859     IXMLDOMDocument_Release(doc);
7860 }
7861
7862 static void test_put_nodeTypedValue(void)
7863 {
7864     static const BYTE binhexdata[16] =
7865         {0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf};
7866     IXMLDOMDocument *doc;
7867     IXMLDOMElement *elem;
7868     VARIANT type, value;
7869     LONG ubound, lbound;
7870     IXMLDOMNode *node;
7871     SAFEARRAY *array;
7872     HRESULT hr;
7873     BYTE *ptr;
7874     BSTR str;
7875
7876     doc = create_document(&IID_IXMLDOMDocument);
7877     if (!doc) return;
7878
7879     hr = IXMLDOMDocument_createElement(doc, _bstr_("Element"), &elem);
7880     EXPECT_HR(hr, S_OK);
7881
7882     V_VT(&type) = VT_EMPTY;
7883     hr = IXMLDOMElement_get_dataType(elem, &type);
7884     EXPECT_HR(hr, S_FALSE);
7885     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
7886
7887     /* set typed value for untyped node */
7888     V_VT(&type) = VT_I1;
7889     V_I1(&type) = 1;
7890     hr = IXMLDOMElement_put_nodeTypedValue(elem, type);
7891     EXPECT_HR(hr, S_OK);
7892
7893     V_VT(&type) = VT_EMPTY;
7894     hr = IXMLDOMElement_get_dataType(elem, &type);
7895     EXPECT_HR(hr, S_FALSE);
7896     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
7897
7898     /* no type info stored */
7899     V_VT(&type) = VT_EMPTY;
7900     hr = IXMLDOMElement_get_nodeTypedValue(elem, &type);
7901     EXPECT_HR(hr, S_OK);
7902     ok(V_VT(&type) == VT_BSTR, "got %d, expected VT_BSTR\n", V_VT(&type));
7903     ok(memcmp(V_BSTR(&type), _bstr_("1"), 2*sizeof(WCHAR)) == 0,
7904        "got %s, expected \"1\"\n", wine_dbgstr_w(V_BSTR(&type)));
7905     VariantClear(&type);
7906
7907     hr = IXMLDOMElement_get_firstChild(elem, &node);
7908     EXPECT_HR(hr, S_OK);
7909     hr = IXMLDOMElement_removeChild(elem, node, NULL);
7910     EXPECT_HR(hr, S_OK);
7911     IXMLDOMNode_Release(node);
7912
7913     hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)elem, NULL);
7914     EXPECT_HR(hr, S_OK);
7915
7916     /* bin.base64 */
7917     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.base64"));
7918     EXPECT_HR(hr, S_OK);
7919
7920     V_VT(&value) = VT_BSTR;
7921     V_BSTR(&value) = _bstr_("ABCD");
7922     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
7923     EXPECT_HR(hr, S_OK);
7924
7925     V_VT(&value) = VT_EMPTY;
7926     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
7927     EXPECT_HR(hr, S_OK);
7928     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
7929     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
7930     ubound = 0;
7931     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
7932     EXPECT_HR(hr, S_OK);
7933     ok(ubound == 2, "got %d\n", ubound);
7934     lbound = 0;
7935     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
7936     EXPECT_HR(hr, S_OK);
7937     ok(lbound == 0, "got %d\n", lbound);
7938     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
7939     EXPECT_HR(hr, S_OK);
7940     ok(ptr[0] == 0, "got %x\n", ptr[0]);
7941     ok(ptr[1] == 0x10, "got %x\n", ptr[1]);
7942     ok(ptr[2] == 0x83, "got %x\n", ptr[2]);
7943     SafeArrayUnaccessData(V_ARRAY(&value));
7944     VariantClear(&value);
7945
7946     /* when set as VT_BSTR it's stored as is */
7947     hr = IXMLDOMElement_get_firstChild(elem, &node);
7948     EXPECT_HR(hr, S_OK);
7949     hr = IXMLDOMNode_get_text(node, &str);
7950     EXPECT_HR(hr, S_OK);
7951     ok(!lstrcmpW(str, _bstr_("ABCD")), "%s\n", wine_dbgstr_w(str));
7952     IXMLDOMNode_Release(node);
7953
7954     array = SafeArrayCreateVector(VT_UI1, 0, 7);
7955     hr = SafeArrayAccessData(array, (void*)&ptr);
7956     EXPECT_HR(hr, S_OK);
7957     memcpy(ptr, "dGVzdA=", strlen("dGVzdA="));
7958     SafeArrayUnaccessData(array);
7959
7960     V_VT(&value) = VT_UI1|VT_ARRAY;
7961     V_ARRAY(&value) = array;
7962     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
7963     EXPECT_HR(hr, S_OK);
7964
7965     V_VT(&value) = VT_EMPTY;
7966     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
7967     EXPECT_HR(hr, S_OK);
7968     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
7969     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
7970     ubound = 0;
7971     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
7972     EXPECT_HR(hr, S_OK);
7973     ok(ubound == 6, "got %d\n", ubound);
7974     lbound = 0;
7975     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
7976     EXPECT_HR(hr, S_OK);
7977     ok(lbound == 0, "got %d\n", lbound);
7978     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
7979     EXPECT_HR(hr, S_OK);
7980     ok(!memcmp(ptr, "dGVzdA=", strlen("dGVzdA=")), "got wrong data, %s\n", ptr);
7981     SafeArrayUnaccessData(V_ARRAY(&value));
7982     VariantClear(&value);
7983
7984     /* if set with VT_UI1|VT_ARRAY it's encoded */
7985     hr = IXMLDOMElement_get_firstChild(elem, &node);
7986     EXPECT_HR(hr, S_OK);
7987     hr = IXMLDOMNode_get_text(node, &str);
7988     EXPECT_HR(hr, S_OK);
7989     ok(!lstrcmpW(str, _bstr_("ZEdWemRBPQ==")), "%s\n", wine_dbgstr_w(str));
7990     IXMLDOMNode_Release(node);
7991     SafeArrayDestroyData(array);
7992
7993     /* bin.hex */
7994     V_VT(&value) = VT_BSTR;
7995     V_BSTR(&value) = _bstr_("");
7996     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
7997     EXPECT_HR(hr, S_OK);
7998
7999     hr = IXMLDOMElement_put_dataType(elem, _bstr_("bin.hex"));
8000     EXPECT_HR(hr, S_OK);
8001
8002     array = SafeArrayCreateVector(VT_UI1, 0, 16);
8003     hr = SafeArrayAccessData(array, (void*)&ptr);
8004     EXPECT_HR(hr, S_OK);
8005     memcpy(ptr, binhexdata, sizeof(binhexdata));
8006     SafeArrayUnaccessData(array);
8007
8008     V_VT(&value) = VT_UI1|VT_ARRAY;
8009     V_ARRAY(&value) = array;
8010     hr = IXMLDOMElement_put_nodeTypedValue(elem, value);
8011     EXPECT_HR(hr, S_OK);
8012
8013     V_VT(&value) = VT_EMPTY;
8014     hr = IXMLDOMElement_get_nodeTypedValue(elem, &value);
8015     EXPECT_HR(hr, S_OK);
8016     ok(V_VT(&value) == (VT_UI1|VT_ARRAY), "got %d\n", V_VT(&value));
8017     ok(SafeArrayGetDim(V_ARRAY(&value)) == 1, "got wrong dimension\n");
8018     ubound = 0;
8019     hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
8020     EXPECT_HR(hr, S_OK);
8021     ok(ubound == 15, "got %d\n", ubound);
8022     lbound = 0;
8023     hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
8024     EXPECT_HR(hr, S_OK);
8025     ok(lbound == 0, "got %d\n", lbound);
8026     hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
8027     EXPECT_HR(hr, S_OK);
8028     ok(!memcmp(ptr, binhexdata, sizeof(binhexdata)), "got wrong data\n");
8029     SafeArrayUnaccessData(V_ARRAY(&value));
8030     VariantClear(&value);
8031
8032     /* if set with VT_UI1|VT_ARRAY it's encoded */
8033     hr = IXMLDOMElement_get_firstChild(elem, &node);
8034     EXPECT_HR(hr, S_OK);
8035     hr = IXMLDOMNode_get_text(node, &str);
8036     EXPECT_HR(hr, S_OK);
8037     ok(!lstrcmpW(str, _bstr_("000102030405060708090a0b0c0d0e0f")), "%s\n", wine_dbgstr_w(str));
8038     IXMLDOMNode_Release(node);
8039     SafeArrayDestroyData(array);
8040
8041     IXMLDOMElement_Release(elem);
8042     IXMLDOMDocument_Release(doc);
8043     free_bstrs();
8044 }
8045
8046 static void test_get_xml(void)
8047 {
8048     static const char xmlA[] = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\r\n<a>test</a>\r\n";
8049     static const char fooA[] = "<foo/>";
8050     IXMLDOMProcessingInstruction *pi;
8051     IXMLDOMNode *first;
8052     IXMLDOMElement *elem = NULL;
8053     IXMLDOMDocument *doc;
8054     VARIANT_BOOL b;
8055     VARIANT v;
8056     BSTR xml;
8057     HRESULT hr;
8058
8059     doc = create_document(&IID_IXMLDOMDocument);
8060     if (!doc) return;
8061
8062     b = VARIANT_TRUE;
8063     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8064     ok(hr == S_OK, "got 0x%08x\n", hr);
8065     ok( b == VARIANT_TRUE, "got %d\n", b);
8066
8067     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"),
8068                              _bstr_("version=\"1.0\" encoding=\"UTF-16\""), &pi);
8069     ok(hr == S_OK, "got 0x%08x\n", hr);
8070
8071     hr = IXMLDOMDocument_get_firstChild(doc, &first);
8072     ok(hr == S_OK, "got 0x%08x\n", hr);
8073
8074     V_UNKNOWN(&v) = (IUnknown*)first;
8075     V_VT(&v) = VT_UNKNOWN;
8076
8077     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)pi, v, NULL);
8078     ok(hr == S_OK, "got 0x%08x\n", hr);
8079
8080     IXMLDOMProcessingInstruction_Release(pi);
8081     IXMLDOMNode_Release(first);
8082
8083     hr = IXMLDOMDocument_get_xml(doc, &xml);
8084     ok(hr == S_OK, "got 0x%08x\n", hr);
8085
8086     ok(memcmp(xml, _bstr_(xmlA), sizeof(xmlA)*sizeof(WCHAR)) == 0,
8087         "got %s, expected %s\n", wine_dbgstr_w(xml), xmlA);
8088     SysFreeString(xml);
8089
8090     IXMLDOMDocument_Release(doc);
8091
8092     doc = create_document(&IID_IXMLDOMDocument);
8093
8094     hr = IXMLDOMDocument_createElement(doc, _bstr_("foo"), &elem);
8095     ok(hr == S_OK, "got 0x%08x\n", hr);
8096
8097     hr = IXMLDOMDocument_putref_documentElement(doc, elem);
8098     ok(hr == S_OK, "got 0x%08x\n", hr);
8099
8100     hr = IXMLDOMDocument_get_xml(doc, &xml);
8101     ok(hr == S_OK, "got 0x%08x\n", hr);
8102
8103     ok(memcmp(xml, _bstr_(fooA), (sizeof(fooA)-1)*sizeof(WCHAR)) == 0,
8104         "got %s, expected %s\n", wine_dbgstr_w(xml), fooA);
8105     SysFreeString(xml);
8106
8107     IXMLDOMElement_Release(elem);
8108     IXMLDOMDocument_Release(doc);
8109
8110     free_bstrs();
8111 }
8112
8113 static void test_xsltemplate(void)
8114 {
8115     IXSLTemplate *template;
8116     IXSLProcessor *processor;
8117     IXMLDOMDocument *doc, *doc2;
8118     IStream *stream;
8119     VARIANT_BOOL b;
8120     HRESULT hr;
8121     ULONG ref1, ref2;
8122     VARIANT v;
8123
8124     template = create_xsltemplate(&IID_IXSLTemplate);
8125     if (!template) return;
8126
8127     /* works as reset */
8128     hr = IXSLTemplate_putref_stylesheet(template, NULL);
8129     ok(hr == S_OK, "got 0x%08x\n", hr);
8130
8131     doc = create_document(&IID_IXMLDOMDocument);
8132
8133     b = VARIANT_TRUE;
8134     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8135     ok(hr == S_OK, "got 0x%08x\n", hr);
8136     ok( b == VARIANT_TRUE, "got %d\n", b);
8137
8138     /* putref with non-xsl document */
8139     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8140     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8141
8142     b = VARIANT_TRUE;
8143     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8144     ok(hr == S_OK, "got 0x%08x\n", hr);
8145     ok( b == VARIANT_TRUE, "got %d\n", b);
8146
8147     /* not a freethreaded document */
8148     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8149     todo_wine ok(hr == E_FAIL, "got 0x%08x\n", hr);
8150
8151     IXMLDOMDocument_Release(doc);
8152
8153     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
8154     if (hr != S_OK)
8155     {
8156         win_skip("failed to create free threaded document instance: 0x%08x\n", hr);
8157         IXSLTemplate_Release(template);
8158         return;
8159     }
8160
8161     b = VARIANT_TRUE;
8162     hr = IXMLDOMDocument_loadXML( doc, _bstr_(szTransformSSXML), &b );
8163     ok(hr == S_OK, "got 0x%08x\n", hr);
8164     ok( b == VARIANT_TRUE, "got %d\n", b);
8165
8166     /* freethreaded document */
8167     ref1 = IXMLDOMDocument_AddRef(doc);
8168     IXMLDOMDocument_Release(doc);
8169     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
8170     ok(hr == S_OK, "got 0x%08x\n", hr);
8171     ref2 = IXMLDOMDocument_AddRef(doc);
8172     IXMLDOMDocument_Release(doc);
8173     ok(ref2 > ref1, "got %d\n", ref2);
8174
8175     /* processor */
8176     hr = IXSLTemplate_createProcessor(template, NULL);
8177     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8178
8179     EXPECT_REF(template, 1);
8180     hr = IXSLTemplate_createProcessor(template, &processor);
8181     ok(hr == S_OK, "got 0x%08x\n", hr);
8182     EXPECT_REF(template, 2);
8183
8184     /* input no set yet */
8185     V_VT(&v) = VT_BSTR;
8186     V_BSTR(&v) = NULL;
8187     hr = IXSLProcessor_get_input(processor, &v);
8188 todo_wine {
8189     ok(hr == S_OK, "got 0x%08x\n", hr);
8190     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
8191 }
8192
8193     hr = IXSLProcessor_get_output(processor, NULL);
8194     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8195
8196     /* reset before it was set */
8197     V_VT(&v) = VT_EMPTY;
8198     hr = IXSLProcessor_put_output(processor, v);
8199     ok(hr == S_OK, "got 0x%08x\n", hr);
8200
8201     CreateStreamOnHGlobal(NULL, TRUE, &stream);
8202     EXPECT_REF(stream, 1);
8203
8204     V_VT(&v) = VT_UNKNOWN;
8205     V_UNKNOWN(&v) = (IUnknown*)stream;
8206     hr = IXSLProcessor_put_output(processor, v);
8207     ok(hr == S_OK, "got 0x%08x\n", hr);
8208
8209     /* it seems processor grabs 2 references */
8210     todo_wine EXPECT_REF(stream, 3);
8211
8212     V_VT(&v) = VT_EMPTY;
8213     hr = IXSLProcessor_get_output(processor, &v);
8214     ok(hr == S_OK, "got 0x%08x\n", hr);
8215     ok(V_VT(&v) == VT_UNKNOWN, "got type %d\n", V_VT(&v));
8216     ok(V_UNKNOWN(&v) == (IUnknown*)stream, "got %p\n", V_UNKNOWN(&v));
8217
8218     todo_wine EXPECT_REF(stream, 4);
8219     VariantClear(&v);
8220
8221     hr = IXSLProcessor_transform(processor, NULL);
8222     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8223
8224     /* reset and check stream refcount */
8225     V_VT(&v) = VT_EMPTY;
8226     hr = IXSLProcessor_put_output(processor, v);
8227     ok(hr == S_OK, "got 0x%08x\n", hr);
8228
8229     EXPECT_REF(stream, 1);
8230
8231     IStream_Release(stream);
8232
8233     /* no output interface set, check output */
8234     doc2 = create_document(&IID_IXMLDOMDocument);
8235
8236     b = VARIANT_TRUE;
8237     hr = IXMLDOMDocument_loadXML( doc2, _bstr_("<a>test</a>"), &b );
8238     ok(hr == S_OK, "got 0x%08x\n", hr);
8239     ok( b == VARIANT_TRUE, "got %d\n", b);
8240
8241     V_VT(&v) = VT_UNKNOWN;
8242     V_UNKNOWN(&v) = (IUnknown*)doc2;
8243     hr = IXSLProcessor_put_input(processor, v);
8244     ok(hr == S_OK, "got 0x%08x\n", hr);
8245
8246     hr = IXSLProcessor_transform(processor, &b);
8247     ok(hr == S_OK, "got 0x%08x\n", hr);
8248
8249     V_VT(&v) = VT_EMPTY;
8250     hr = IXSLProcessor_get_output(processor, &v);
8251     ok(hr == S_OK, "got 0x%08x\n", hr);
8252     ok(V_VT(&v) == VT_BSTR, "got type %d\n", V_VT(&v));
8253     ok(lstrcmpW(V_BSTR(&v), _bstr_("")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8254     IXMLDOMDocument_Release(doc2);
8255     VariantClear(&v);
8256
8257     IXSLProcessor_Release(processor);
8258
8259     /* drop reference */
8260     hr = IXSLTemplate_putref_stylesheet(template, NULL);
8261     ok(hr == S_OK, "got 0x%08x\n", hr);
8262     ref2 = IXMLDOMDocument_AddRef(doc);
8263     IXMLDOMDocument_Release(doc);
8264     ok(ref2 == ref1, "got %d\n", ref2);
8265
8266     IXMLDOMDocument_Release(doc);
8267     IXSLTemplate_Release(template);
8268     free_bstrs();
8269 }
8270
8271 static void test_insertBefore(void)
8272 {
8273     IXMLDOMDocument *doc, *doc2;
8274     IXMLDOMAttribute *attr;
8275     IXMLDOMElement *elem1, *elem2, *elem3, *elem4, *elem5;
8276     IXMLDOMNode *node, *newnode;
8277     HRESULT hr;
8278     VARIANT v;
8279     BSTR p;
8280
8281     doc = create_document(&IID_IXMLDOMDocument);
8282
8283     /* insertBefore behaviour for attribute node */
8284     V_VT(&v) = VT_I4;
8285     V_I4(&v) = NODE_ATTRIBUTE;
8286
8287     attr = NULL;
8288     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr"), NULL, (IXMLDOMNode**)&attr);
8289     ok(hr == S_OK, "got 0x%08x\n", hr);
8290     ok(attr != NULL, "got %p\n", attr);
8291
8292     /* attribute to attribute */
8293     V_VT(&v) = VT_I4;
8294     V_I4(&v) = NODE_ATTRIBUTE;
8295     newnode = NULL;
8296     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("attr2"), NULL, &newnode);
8297     ok(hr == S_OK, "got 0x%08x\n", hr);
8298     ok(newnode != NULL, "got %p\n", newnode);
8299
8300     V_VT(&v) = VT_NULL;
8301     node = (void*)0xdeadbeef;
8302     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8303     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8304     ok(node == NULL, "got %p\n", node);
8305
8306     V_VT(&v) = VT_UNKNOWN;
8307     V_UNKNOWN(&v) = (IUnknown*)attr;
8308     node = (void*)0xdeadbeef;
8309     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8310     todo_wine ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8311     ok(node == NULL, "got %p\n", node);
8312     IXMLDOMNode_Release(newnode);
8313
8314     /* cdata to attribute */
8315     V_VT(&v) = VT_I4;
8316     V_I4(&v) = NODE_CDATA_SECTION;
8317     newnode = NULL;
8318     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8319     ok(hr == S_OK, "got 0x%08x\n", hr);
8320     ok(newnode != NULL, "got %p\n", newnode);
8321
8322     V_VT(&v) = VT_NULL;
8323     node = (void*)0xdeadbeef;
8324     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8325     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8326     ok(node == NULL, "got %p\n", node);
8327     IXMLDOMNode_Release(newnode);
8328
8329     /* comment to attribute */
8330     V_VT(&v) = VT_I4;
8331     V_I4(&v) = NODE_COMMENT;
8332     newnode = NULL;
8333     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8334     ok(hr == S_OK, "got 0x%08x\n", hr);
8335     ok(newnode != NULL, "got %p\n", newnode);
8336
8337     V_VT(&v) = VT_NULL;
8338     node = (void*)0xdeadbeef;
8339     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8340     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8341     ok(node == NULL, "got %p\n", node);
8342     IXMLDOMNode_Release(newnode);
8343
8344     /* element to attribute */
8345     V_VT(&v) = VT_I4;
8346     V_I4(&v) = NODE_ELEMENT;
8347     newnode = NULL;
8348     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8349     ok(hr == S_OK, "got 0x%08x\n", hr);
8350     ok(newnode != NULL, "got %p\n", newnode);
8351
8352     V_VT(&v) = VT_NULL;
8353     node = (void*)0xdeadbeef;
8354     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8355     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8356     ok(node == NULL, "got %p\n", node);
8357     IXMLDOMNode_Release(newnode);
8358
8359     /* pi to attribute */
8360     V_VT(&v) = VT_I4;
8361     V_I4(&v) = NODE_PROCESSING_INSTRUCTION;
8362     newnode = NULL;
8363     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("cdata"), NULL, &newnode);
8364     ok(hr == S_OK, "got 0x%08x\n", hr);
8365     ok(newnode != NULL, "got %p\n", newnode);
8366
8367     V_VT(&v) = VT_NULL;
8368     node = (void*)0xdeadbeef;
8369     hr = IXMLDOMAttribute_insertBefore(attr, newnode, v, &node);
8370     ok(hr == E_FAIL, "got 0x%08x\n", hr);
8371     ok(node == NULL, "got %p\n", node);
8372     IXMLDOMNode_Release(newnode);
8373     IXMLDOMAttribute_Release(attr);
8374
8375     /* insertBefore for elements */
8376     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem1);
8377     ok(hr == S_OK, "got 0x%08x\n", hr);
8378
8379     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem2"), &elem2);
8380     ok(hr == S_OK, "got 0x%08x\n", hr);
8381
8382     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
8383     ok(hr == S_OK, "got 0x%08x\n", hr);
8384
8385     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem3"), &elem3);
8386     ok(hr == S_OK, "got 0x%08x\n", hr);
8387
8388     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem4"), &elem4);
8389     ok(hr == S_OK, "got 0x%08x\n", hr);
8390
8391     EXPECT_NO_CHILDREN(elem1);
8392     EXPECT_NO_CHILDREN(elem2);
8393     EXPECT_NO_CHILDREN(elem3);
8394
8395     todo_wine EXPECT_REF(elem2, 2);
8396
8397     V_VT(&v) = VT_DISPATCH;
8398     V_DISPATCH(&v) = NULL;
8399     node = NULL;
8400     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem4, v, &node);
8401     ok(hr == S_OK, "got 0x%08x\n", hr);
8402     ok(node == (void*)elem4, "got %p\n", node);
8403
8404     EXPECT_CHILDREN(elem1);
8405     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem4, NULL);
8406     EXPECT_HR(hr, S_OK);
8407     IXMLDOMElement_Release(elem4);
8408
8409     EXPECT_NO_CHILDREN(elem1);
8410
8411     V_VT(&v) = VT_NULL;
8412     node = NULL;
8413     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
8414     ok(hr == S_OK, "got 0x%08x\n", hr);
8415     ok(node == (void*)elem2, "got %p\n", node);
8416
8417     EXPECT_CHILDREN(elem1);
8418     todo_wine EXPECT_REF(elem2, 3);
8419     IXMLDOMNode_Release(node);
8420
8421     /* again for already linked node */
8422     V_VT(&v) = VT_NULL;
8423     node = NULL;
8424     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, &node);
8425     ok(hr == S_OK, "got 0x%08x\n", hr);
8426     ok(node == (void*)elem2, "got %p\n", node);
8427
8428     EXPECT_CHILDREN(elem1);
8429
8430     /* increments each time */
8431     todo_wine EXPECT_REF(elem2, 3);
8432     IXMLDOMNode_Release(node);
8433
8434     /* try to add to another element */
8435     V_VT(&v) = VT_NULL;
8436     node = (void*)0xdeadbeef;
8437     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem2, v, &node);
8438     ok(hr == S_OK, "got 0x%08x\n", hr);
8439     ok(node == (void*)elem2, "got %p\n", node);
8440
8441     EXPECT_CHILDREN(elem3);
8442     EXPECT_NO_CHILDREN(elem1);
8443
8444     IXMLDOMNode_Release(node);
8445
8446     /* cross document case - try to add as child to a node created with other doc */
8447     doc2 = create_document(&IID_IXMLDOMDocument);
8448
8449     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem4);
8450     ok(hr == S_OK, "got 0x%08x\n", hr);
8451     todo_wine EXPECT_REF(elem4, 2);
8452
8453     /* same name, another instance */
8454     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem4"), &elem5);
8455     ok(hr == S_OK, "got 0x%08x\n", hr);
8456     todo_wine EXPECT_REF(elem5, 2);
8457
8458     todo_wine EXPECT_REF(elem3, 2);
8459     V_VT(&v) = VT_NULL;
8460     node = NULL;
8461     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem4, v, &node);
8462     ok(hr == S_OK, "got 0x%08x\n", hr);
8463     ok(node == (void*)elem4, "got %p\n", node);
8464     todo_wine EXPECT_REF(elem4, 3);
8465     todo_wine EXPECT_REF(elem3, 2);
8466     IXMLDOMNode_Release(node);
8467
8468     V_VT(&v) = VT_NULL;
8469     node = NULL;
8470     hr = IXMLDOMElement_insertBefore(elem3, (IXMLDOMNode*)elem5, v, &node);
8471     ok(hr == S_OK, "got 0x%08x\n", hr);
8472     ok(node == (void*)elem5, "got %p\n", node);
8473     todo_wine EXPECT_REF(elem4, 2);
8474     todo_wine EXPECT_REF(elem5, 3);
8475     IXMLDOMNode_Release(node);
8476
8477     IXMLDOMDocument_Release(doc2);
8478
8479     IXMLDOMElement_Release(elem1);
8480     IXMLDOMElement_Release(elem2);
8481     IXMLDOMElement_Release(elem3);
8482     IXMLDOMElement_Release(elem4);
8483     IXMLDOMElement_Release(elem5);
8484
8485     /* elements with same default namespace */
8486     V_VT(&v) = VT_I4;
8487     V_I4(&v) = NODE_ELEMENT;
8488     elem1 = NULL;
8489     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
8490     ok(hr == S_OK, "got 0x%08x\n", hr);
8491     ok(elem1 != NULL, "got %p\n", elem1);
8492
8493     V_VT(&v) = VT_I4;
8494     V_I4(&v) = NODE_ELEMENT;
8495     elem2 = NULL;
8496     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem2);
8497     ok(hr == S_OK, "got 0x%08x\n", hr);
8498     ok(elem2 != NULL, "got %p\n", elem2);
8499
8500     /* check contents so far */
8501     p = NULL;
8502     hr = IXMLDOMElement_get_xml(elem1, &p);
8503     ok(hr == S_OK, "got 0x%08x\n", hr);
8504     ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
8505     SysFreeString(p);
8506
8507     p = NULL;
8508     hr = IXMLDOMElement_get_xml(elem2, &p);
8509     ok(hr == S_OK, "got 0x%08x\n", hr);
8510     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
8511     SysFreeString(p);
8512
8513     V_VT(&v) = VT_NULL;
8514     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
8515     ok(hr == S_OK, "got 0x%08x\n", hr);
8516
8517     /* get_xml depends on context, for top node it omits child namespace attribute,
8518        but at child level it's still returned */
8519     p = NULL;
8520     hr = IXMLDOMElement_get_xml(elem1, &p);
8521     ok(hr == S_OK, "got 0x%08x\n", hr);
8522     todo_wine ok(!lstrcmpW(p, _bstr_("<elem1 xmlns=\"http://winehq.org/default\"><elem2/></elem1>")),
8523         "got %s\n", wine_dbgstr_w(p));
8524     SysFreeString(p);
8525
8526     p = NULL;
8527     hr = IXMLDOMElement_get_xml(elem2, &p);
8528     ok(hr == S_OK, "got 0x%08x\n", hr);
8529     ok(!lstrcmpW(p, _bstr_("<elem2 xmlns=\"http://winehq.org/default\"/>")), "got %s\n", wine_dbgstr_w(p));
8530     SysFreeString(p);
8531
8532     IXMLDOMElement_Release(elem1);
8533     IXMLDOMElement_Release(elem2);
8534
8535     /* child without default namespace added to node with default namespace */
8536     V_VT(&v) = VT_I4;
8537     V_I4(&v) = NODE_ELEMENT;
8538     elem1 = NULL;
8539     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem1"), _bstr_("http://winehq.org/default"), (IXMLDOMNode**)&elem1);
8540     ok(hr == S_OK, "got 0x%08x\n", hr);
8541     ok(elem1 != NULL, "got %p\n", elem1);
8542
8543     V_VT(&v) = VT_I4;
8544     V_I4(&v) = NODE_ELEMENT;
8545     elem2 = NULL;
8546     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("elem2"), NULL, (IXMLDOMNode**)&elem2);
8547     ok(hr == S_OK, "got 0x%08x\n", hr);
8548     ok(elem2 != NULL, "got %p\n", elem2);
8549
8550     EXPECT_REF(elem2, 1);
8551     V_VT(&v) = VT_NULL;
8552     hr = IXMLDOMElement_insertBefore(elem1, (IXMLDOMNode*)elem2, v, NULL);
8553     ok(hr == S_OK, "got 0x%08x\n", hr);
8554     EXPECT_REF(elem2, 1);
8555
8556     p = NULL;
8557     hr = IXMLDOMElement_get_xml(elem2, &p);
8558     ok(hr == S_OK, "got 0x%08x\n", hr);
8559     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
8560     SysFreeString(p);
8561
8562     hr = IXMLDOMElement_removeChild(elem1, (IXMLDOMNode*)elem2, NULL);
8563     ok(hr == S_OK, "got 0x%08x\n", hr);
8564
8565     p = NULL;
8566     hr = IXMLDOMElement_get_xml(elem2, &p);
8567     ok(hr == S_OK, "got 0x%08x\n", hr);
8568     ok(!lstrcmpW(p, _bstr_("<elem2/>")), "got %s\n", wine_dbgstr_w(p));
8569     SysFreeString(p);
8570
8571     IXMLDOMElement_Release(elem1);
8572     IXMLDOMElement_Release(elem2);
8573     IXMLDOMDocument_Release(doc);
8574 }
8575
8576 static void test_appendChild(void)
8577 {
8578     IXMLDOMDocument *doc, *doc2;
8579     IXMLDOMElement *elem, *elem2;
8580     HRESULT hr;
8581
8582     doc = create_document(&IID_IXMLDOMDocument);
8583     doc2 = create_document(&IID_IXMLDOMDocument);
8584
8585     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &elem);
8586     ok(hr == S_OK, "got 0x%08x\n", hr);
8587
8588     hr = IXMLDOMDocument_createElement(doc2, _bstr_("elem2"), &elem2);
8589     ok(hr == S_OK, "got 0x%08x\n", hr);
8590
8591     EXPECT_REF(doc, 1);
8592     todo_wine EXPECT_REF(elem, 2);
8593     EXPECT_REF(doc2, 1);
8594     todo_wine EXPECT_REF(elem2, 2);
8595     EXPECT_NO_CHILDREN(doc);
8596     EXPECT_NO_CHILDREN(doc2);
8597
8598     /* append from another document */
8599     hr = IXMLDOMDocument_appendChild(doc2, (IXMLDOMNode*)elem, NULL);
8600     ok(hr == S_OK, "got 0x%08x\n", hr);
8601
8602     EXPECT_REF(doc, 1);
8603     todo_wine EXPECT_REF(elem, 2);
8604     EXPECT_REF(doc2, 1);
8605     todo_wine EXPECT_REF(elem2, 2);
8606     EXPECT_NO_CHILDREN(doc);
8607     EXPECT_CHILDREN(doc2);
8608
8609     IXMLDOMElement_Release(elem);
8610     IXMLDOMElement_Release(elem2);
8611     IXMLDOMDocument_Release(doc);
8612     IXMLDOMDocument_Release(doc2);
8613 }
8614
8615 static void test_get_doctype(void)
8616 {
8617     IXMLDOMDocumentType *doctype;
8618     IXMLDOMDocument *doc;
8619     HRESULT hr;
8620
8621     doc = create_document(&IID_IXMLDOMDocument);
8622
8623     hr = IXMLDOMDocument_get_doctype(doc, NULL);
8624     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8625
8626     doctype = (void*)0xdeadbeef;
8627     hr = IXMLDOMDocument_get_doctype(doc, &doctype);
8628     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8629     ok(doctype == NULL, "got %p\n", doctype);
8630
8631     IXMLDOMDocument_Release(doc);
8632 }
8633
8634 static void test_get_tagName(void)
8635 {
8636     IXMLDOMDocument *doc;
8637     IXMLDOMElement *elem, *elem2;
8638     HRESULT hr;
8639     BSTR str;
8640
8641     doc = create_document(&IID_IXMLDOMDocument);
8642
8643     hr = IXMLDOMDocument_createElement(doc, _bstr_("element"), &elem);
8644     ok(hr == S_OK, "got 0x%08x\n", hr);
8645
8646     hr = IXMLDOMElement_get_tagName(elem, NULL);
8647     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8648
8649     str = NULL;
8650     hr = IXMLDOMElement_get_tagName(elem, &str);
8651     ok(hr == S_OK, "got 0x%08x\n", hr);
8652     ok(!lstrcmpW(str, _bstr_("element")), "got %s\n", wine_dbgstr_w(str));
8653     SysFreeString(str);
8654
8655     hr = IXMLDOMDocument_createElement(doc, _bstr_("s:element"), &elem2);
8656     ok(hr == S_OK, "got 0x%08x\n", hr);
8657
8658     str = NULL;
8659     hr = IXMLDOMElement_get_tagName(elem2, &str);
8660     ok(hr == S_OK, "got 0x%08x\n", hr);
8661     ok(!lstrcmpW(str, _bstr_("s:element")), "got %s\n", wine_dbgstr_w(str));
8662     SysFreeString(str);
8663
8664     IXMLDOMElement_Release(elem);
8665     IXMLDOMElement_Release(elem2);
8666     IXMLDOMDocument_Release(doc);
8667     free_bstrs();
8668 }
8669
8670 typedef struct {
8671     DOMNodeType type;
8672     const char *name;
8673     VARTYPE vt;
8674     HRESULT hr;
8675 } node_type_t;
8676
8677 static const node_type_t get_datatype[] = {
8678     { NODE_ELEMENT,                "element",   VT_NULL, S_FALSE },
8679     { NODE_ATTRIBUTE,              "attr",      VT_NULL, S_FALSE },
8680     { NODE_TEXT,                   "text",      VT_NULL, S_FALSE },
8681     { NODE_CDATA_SECTION ,         "cdata",     VT_NULL, S_FALSE },
8682     { NODE_ENTITY_REFERENCE,       "entityref", VT_NULL, S_FALSE },
8683     { NODE_PROCESSING_INSTRUCTION, "pi",        VT_NULL, S_FALSE },
8684     { NODE_COMMENT,                "comment",   VT_NULL, S_FALSE },
8685     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   VT_NULL, S_FALSE },
8686     { 0 }
8687 };
8688
8689 static void test_get_dataType(void)
8690 {
8691     const node_type_t *entry = get_datatype;
8692     IXMLDOMDocument *doc;
8693
8694     doc = create_document(&IID_IXMLDOMDocument);
8695
8696     while (entry->type)
8697     {
8698         IXMLDOMNode *node = NULL;
8699         VARIANT var, type;
8700         HRESULT hr;
8701
8702         V_VT(&var) = VT_I4;
8703         V_I4(&var) = entry->type;
8704         hr = IXMLDOMDocument_createNode(doc, var, _bstr_(entry->name), NULL, &node);
8705         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
8706
8707         hr = IXMLDOMNode_get_dataType(node, NULL);
8708         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8709
8710         VariantInit(&type);
8711         hr = IXMLDOMNode_get_dataType(node, &type);
8712         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
8713             hr, entry->hr, entry->type);
8714         ok(V_VT(&type) == entry->vt, "got %d, expected %d. node type %d\n",
8715             V_VT(&type), entry->vt, entry->type);
8716         VariantClear(&type);
8717
8718         IXMLDOMNode_Release(node);
8719
8720         entry++;
8721     }
8722
8723     IXMLDOMDocument_Release(doc);
8724     free_bstrs();
8725 }
8726
8727 typedef struct _get_node_typestring_t {
8728     DOMNodeType type;
8729     const char *string;
8730 } get_node_typestring_t;
8731
8732 static const get_node_typestring_t get_node_typestring[] = {
8733     { NODE_ELEMENT,                "element"               },
8734     { NODE_ATTRIBUTE,              "attribute"             },
8735     { NODE_TEXT,                   "text"                  },
8736     { NODE_CDATA_SECTION ,         "cdatasection"          },
8737     { NODE_ENTITY_REFERENCE,       "entityreference"       },
8738     { NODE_PROCESSING_INSTRUCTION, "processinginstruction" },
8739     { NODE_COMMENT,                "comment"               },
8740     { NODE_DOCUMENT_FRAGMENT,      "documentfragment"      },
8741     { 0 }
8742 };
8743
8744 static void test_get_nodeTypeString(void)
8745 {
8746     const get_node_typestring_t *entry = get_node_typestring;
8747     IXMLDOMDocument *doc;
8748     HRESULT hr;
8749     BSTR str;
8750
8751     doc = create_document(&IID_IXMLDOMDocument);
8752
8753     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
8754     ok(hr == S_OK, "got 0x%08x\n", hr);
8755     ok(!lstrcmpW(str, _bstr_("document")), "got string %s\n", wine_dbgstr_w(str));
8756     SysFreeString(str);
8757
8758     while (entry->type)
8759     {
8760         IXMLDOMNode *node = NULL;
8761         VARIANT var;
8762
8763         V_VT(&var) = VT_I4;
8764         V_I4(&var) = entry->type;
8765         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
8766         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
8767
8768         hr = IXMLDOMNode_get_nodeTypeString(node, NULL);
8769         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8770
8771         hr = IXMLDOMNode_get_nodeTypeString(node, &str);
8772         ok(hr == S_OK, "got 0x%08x\n", hr);
8773         ok(!lstrcmpW(str, _bstr_(entry->string)), "got string %s, expected %s. node type %d\n",
8774             wine_dbgstr_w(str), entry->string, entry->type);
8775         SysFreeString(str);
8776         IXMLDOMNode_Release(node);
8777
8778         entry++;
8779     }
8780
8781     IXMLDOMDocument_Release(doc);
8782     free_bstrs();
8783 }
8784
8785 typedef struct _get_attributes_t {
8786     DOMNodeType type;
8787     HRESULT hr;
8788 } get_attributes_t;
8789
8790 static const get_attributes_t get_attributes[] = {
8791     { NODE_ATTRIBUTE,              S_FALSE },
8792     { NODE_TEXT,                   S_FALSE },
8793     { NODE_CDATA_SECTION ,         S_FALSE },
8794     { NODE_ENTITY_REFERENCE,       S_FALSE },
8795     { NODE_PROCESSING_INSTRUCTION, S_FALSE },
8796     { NODE_COMMENT,                S_FALSE },
8797     { NODE_DOCUMENT_FRAGMENT,      S_FALSE },
8798     { 0 }
8799 };
8800
8801 static void test_get_attributes(void)
8802 {
8803     const get_attributes_t *entry = get_attributes;
8804     IXMLDOMNamedNodeMap *map;
8805     IXMLDOMDocument *doc;
8806     IXMLDOMNode *node, *node2;
8807     VARIANT_BOOL b;
8808     HRESULT hr;
8809     BSTR str;
8810     LONG length;
8811
8812     doc = create_document(&IID_IXMLDOMDocument);
8813
8814     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
8815     ok(hr == S_OK, "got %08x\n", hr);
8816
8817     hr = IXMLDOMDocument_get_attributes(doc, NULL);
8818     ok(hr == E_INVALIDARG, "got %08x\n", hr);
8819
8820     map = (void*)0xdeadbeef;
8821     hr = IXMLDOMDocument_get_attributes(doc, &map);
8822     ok(hr == S_FALSE, "got %08x\n", hr);
8823     ok(map == NULL, "got %p\n", map);
8824
8825     /* first child is <?xml ?> */
8826     hr = IXMLDOMDocument_get_firstChild(doc, &node);
8827     ok(hr == S_OK, "got %08x\n", hr);
8828
8829     hr = IXMLDOMNode_get_attributes(node, &map);
8830     ok(hr == S_OK, "got %08x\n", hr);
8831
8832     length = -1;
8833     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
8834     EXPECT_HR(hr, S_OK);
8835     todo_wine ok(length == 1, "got %d\n", length);
8836
8837     if (hr == S_OK && length == 1)
8838     {
8839         IXMLDOMAttribute *attr;
8840         DOMNodeType type;
8841         VARIANT v;
8842
8843         node2 = NULL;
8844         hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
8845         EXPECT_HR(hr, S_OK);
8846         ok(node != NULL, "got %p\n", node2);
8847
8848         hr = IXMLDOMNode_get_nodeName(node2, &str);
8849         EXPECT_HR(hr, S_OK);
8850         ok(!lstrcmpW(str, _bstr_("version")), "got %s\n", wine_dbgstr_w(str));
8851         SysFreeString(str);
8852
8853         length = -1;
8854         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
8855         EXPECT_HR(hr, S_OK);
8856         ok(length == 1, "got %d\n", length);
8857
8858         type = -1;
8859         hr = IXMLDOMNode_get_nodeType(node2, &type);
8860         EXPECT_HR(hr, S_OK);
8861         ok(type == NODE_ATTRIBUTE, "got %d\n", type);
8862
8863         hr = IXMLDOMNode_get_xml(node, &str);
8864         EXPECT_HR(hr, S_OK);
8865         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
8866         SysFreeString(str);
8867
8868         hr = IXMLDOMNode_get_text(node, &str);
8869         EXPECT_HR(hr, S_OK);
8870         ok(!lstrcmpW(str, _bstr_("version=\"1.0\"")), "got %s\n", wine_dbgstr_w(str));
8871         SysFreeString(str);
8872
8873         hr = IXMLDOMNamedNodeMap_removeNamedItem(map, _bstr_("version"), NULL);
8874         EXPECT_HR(hr, S_OK);
8875
8876         length = -1;
8877         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
8878         EXPECT_HR(hr, S_OK);
8879         ok(length == 0, "got %d\n", length);
8880
8881         hr = IXMLDOMNode_get_xml(node, &str);
8882         EXPECT_HR(hr, S_OK);
8883         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
8884         SysFreeString(str);
8885
8886         hr = IXMLDOMNode_get_text(node, &str);
8887         EXPECT_HR(hr, S_OK);
8888         ok(!lstrcmpW(str, _bstr_("")), "got %s\n", wine_dbgstr_w(str));
8889         SysFreeString(str);
8890
8891         IXMLDOMNamedNodeMap_Release(map);
8892
8893         hr = IXMLDOMNode_get_attributes(node, &map);
8894         ok(hr == S_OK, "got %08x\n", hr);
8895
8896         length = -1;
8897         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
8898         EXPECT_HR(hr, S_OK);
8899         ok(length == 0, "got %d\n", length);
8900
8901         hr = IXMLDOMDocument_createAttribute(doc, _bstr_("encoding"), &attr);
8902         EXPECT_HR(hr, S_OK);
8903
8904         V_VT(&v) = VT_BSTR;
8905         V_BSTR(&v) = _bstr_("UTF-8");
8906         hr = IXMLDOMAttribute_put_nodeValue(attr, v);
8907         EXPECT_HR(hr, S_OK);
8908
8909         EXPECT_REF(attr, 2);
8910         hr = IXMLDOMNamedNodeMap_setNamedItem(map, (IXMLDOMNode*)attr, NULL);
8911         EXPECT_HR(hr, S_OK);
8912         EXPECT_REF(attr, 2);
8913
8914         hr = IXMLDOMNode_get_attributes(node, &map);
8915         ok(hr == S_OK, "got %08x\n", hr);
8916
8917         length = -1;
8918         hr = IXMLDOMNamedNodeMap_get_length(map, &length);
8919         EXPECT_HR(hr, S_OK);
8920         ok(length == 1, "got %d\n", length);
8921
8922         hr = IXMLDOMNode_get_xml(node, &str);
8923         EXPECT_HR(hr, S_OK);
8924         ok(!lstrcmpW(str, _bstr_("<?xml version=\"1.0\"?>")), "got %s\n", wine_dbgstr_w(str));
8925         SysFreeString(str);
8926
8927         hr = IXMLDOMNode_get_text(node, &str);
8928         EXPECT_HR(hr, S_OK);
8929         ok(!lstrcmpW(str, _bstr_("encoding=\"UTF-8\"")), "got %s\n", wine_dbgstr_w(str));
8930         SysFreeString(str);
8931
8932         IXMLDOMNamedNodeMap_Release(map);
8933         IXMLDOMNode_Release(node2);
8934     }
8935
8936     IXMLDOMNode_Release(node);
8937
8938     /* last child is element */
8939     EXPECT_REF(doc, 1);
8940     hr = IXMLDOMDocument_get_lastChild(doc, &node);
8941     ok(hr == S_OK, "got %08x\n", hr);
8942     EXPECT_REF(doc, 1);
8943
8944     EXPECT_REF(node, 1);
8945     hr = IXMLDOMNode_get_attributes(node, &map);
8946     ok(hr == S_OK, "got %08x\n", hr);
8947     EXPECT_REF(node, 1);
8948     EXPECT_REF(doc, 1);
8949
8950     EXPECT_REF(map, 1);
8951     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
8952     ok(hr == S_OK, "got %08x\n", hr);
8953     EXPECT_REF(node, 1);
8954     EXPECT_REF(node2, 1);
8955     EXPECT_REF(map, 1);
8956     EXPECT_REF(doc, 1);
8957     IXMLDOMNode_Release(node2);
8958
8959     /* release node before map release, map still works */
8960     IXMLDOMNode_Release(node);
8961
8962     length = 0;
8963     hr = IXMLDOMNamedNodeMap_get_length(map, &length);
8964     ok(hr == S_OK, "got %08x\n", hr);
8965     ok(length == 1, "got %d\n", length);
8966
8967     node2 = NULL;
8968     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node2);
8969     ok(hr == S_OK, "got %08x\n", hr);
8970     EXPECT_REF(node2, 1);
8971     IXMLDOMNode_Release(node2);
8972
8973     IXMLDOMNamedNodeMap_Release(map);
8974
8975     while (entry->type)
8976     {
8977         VARIANT var;
8978
8979         node = NULL;
8980
8981         V_VT(&var) = VT_I4;
8982         V_I4(&var) = entry->type;
8983         hr = IXMLDOMDocument_createNode(doc, var, _bstr_("node"), NULL, &node);
8984         ok(hr == S_OK, "failed to create node, type %d\n", entry->type);
8985
8986         hr = IXMLDOMNode_get_attributes(node, NULL);
8987         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8988
8989         map = (void*)0xdeadbeef;
8990         hr = IXMLDOMNode_get_attributes(node, &map);
8991         ok(hr == entry->hr, "got 0x%08x, expected 0x%08x. node type %d\n",
8992             hr, entry->hr, entry->type);
8993         ok(map == NULL, "got %p\n", map);
8994
8995         IXMLDOMNode_Release(node);
8996
8997         entry++;
8998     }
8999
9000     IXMLDOMDocument_Release(doc);
9001     free_bstrs();
9002 }
9003
9004 static void test_selection(void)
9005 {
9006     IXMLDOMSelection *selection, *selection2;
9007     IEnumVARIANT *enum1, *enum2, *enum3;
9008     IXMLDOMNodeList *list;
9009     IUnknown *unk1, *unk2;
9010     IXMLDOMDocument *doc;
9011     IDispatchEx *dispex;
9012     IXMLDOMNode *node;
9013     IDispatch *disp;
9014     VARIANT_BOOL b;
9015     HRESULT hr;
9016     DISPID did;
9017     VARIANT v;
9018     BSTR name;
9019     ULONG ret;
9020     LONG len;
9021
9022     doc = create_document(&IID_IXMLDOMDocument);
9023
9024     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
9025     EXPECT_HR(hr, S_OK);
9026
9027     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list);
9028     EXPECT_HR(hr, S_OK);
9029
9030     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9031     EXPECT_HR(hr, S_OK);
9032     IXMLDOMSelection_Release(selection);
9033
9034     /* collection disp id */
9035     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IDispatchEx, (void**)&dispex);
9036     EXPECT_HR(hr, S_OK);
9037     did = 0;
9038     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
9039     EXPECT_HR(hr, S_OK);
9040     ok(did == DISPID_DOM_COLLECTION_BASE, "got %d\n", did);
9041     len = 0;
9042     hr = IXMLDOMSelection_get_length(selection, &len);
9043     EXPECT_HR(hr, S_OK);
9044     ok(len == 1, "got %d\n", len);
9045     hr = IDispatchEx_GetDispID(dispex, _bstr_("10"), 0, &did);
9046     EXPECT_HR(hr, S_OK);
9047     ok(did == DISPID_DOM_COLLECTION_BASE+10, "got %d\n", did);
9048     IDispatchEx_Release(dispex);
9049
9050     /* IEnumVARIANT tests */
9051     enum1 = NULL;
9052     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum1);
9053     EXPECT_HR(hr, S_OK);
9054     ok(enum1 != NULL, "got %p\n", enum1);
9055     EXPECT_REF(enum1, 2);
9056
9057     EXPECT_REF(selection, 1);
9058     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IUnknown, (void**)&unk1);
9059     EXPECT_HR(hr, S_OK);
9060     EXPECT_REF(selection, 2);
9061     EXPECT_REF(enum1, 2);
9062
9063     /* enumerator and selection object return same IUnknown* */
9064     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IUnknown, (void**)&unk2);
9065     EXPECT_HR(hr, S_OK);
9066     EXPECT_REF(selection, 3);
9067     EXPECT_REF(enum1, 2);
9068     ok(unk2 == unk1, "got %p, %p\n", unk1, unk2);
9069     IUnknown_Release(unk2);
9070
9071     EXPECT_REF(selection, 2);
9072     IEnumVARIANT_AddRef(enum1);
9073     EXPECT_REF(selection, 2);
9074     IEnumVARIANT_Release(enum1);
9075
9076     enum3 = NULL;
9077     hr = IXMLDOMSelection_QueryInterface(selection, &IID_IEnumVARIANT, (void**)&enum3);
9078     EXPECT_HR(hr, S_OK);
9079     ok(enum3 != NULL, "got %p\n", enum3);
9080     ok(enum1 == enum3, "got %p and %p\n", enum1, enum3);
9081     EXPECT_REF(enum1, 3);
9082     IEnumVARIANT_Release(enum3);
9083
9084     EXPECT_REF(selection, 2);
9085     EXPECT_REF(enum1, 2);
9086
9087     enum2 = NULL;
9088     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
9089     EXPECT_HR(hr, S_OK);
9090     ok(enum2 != NULL, "got %p\n", enum2);
9091
9092     EXPECT_REF(selection, 3);
9093     EXPECT_REF(enum1, 2);
9094     EXPECT_REF(enum2, 1);
9095
9096     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
9097
9098     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
9099     EXPECT_HR(hr, S_OK);
9100     EXPECT_REF(selection, 3);
9101     EXPECT_REF(enum2, 2);
9102     ok(unk2 != unk1, "got %p, %p\n", unk1, unk2);
9103     IUnknown_Release(unk2);
9104     IUnknown_Release(unk1);
9105
9106     selection2 = NULL;
9107     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IXMLDOMSelection, (void**)&selection2);
9108     EXPECT_HR(hr, S_OK);
9109     ok(selection2 == selection, "got %p and %p\n", selection, selection2);
9110     EXPECT_REF(selection, 3);
9111     EXPECT_REF(enum1, 2);
9112
9113     IXMLDOMSelection_Release(selection2);
9114
9115     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IDispatch, (void**)&disp);
9116     EXPECT_HR(hr, S_OK);
9117     EXPECT_REF(selection, 3);
9118     IDispatch_Release(disp);
9119
9120     hr = IEnumVARIANT_QueryInterface(enum1, &IID_IEnumVARIANT, (void**)&enum3);
9121     EXPECT_HR(hr, S_OK);
9122     ok(enum3 == enum1, "got %p and %p\n", enum3, enum1);
9123     EXPECT_REF(selection, 2);
9124     EXPECT_REF(enum1, 3);
9125
9126     IEnumVARIANT_Release(enum1);
9127     IEnumVARIANT_Release(enum2);
9128
9129     enum1 = NULL;
9130     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
9131     EXPECT_HR(hr, S_OK);
9132     ok(enum1 != NULL, "got %p\n", enum1);
9133     EXPECT_REF(enum1, 1);
9134     EXPECT_REF(selection, 2);
9135
9136     enum2 = NULL;
9137     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum2);
9138     EXPECT_HR(hr, S_OK);
9139     ok(enum2 != NULL, "got %p\n", enum2);
9140     EXPECT_REF(enum2, 1);
9141     EXPECT_REF(selection, 3);
9142
9143     ok(enum1 != enum2, "got %p, %p\n", enum1, enum2);
9144
9145     IEnumVARIANT_AddRef(enum1);
9146     EXPECT_REF(selection, 3);
9147     EXPECT_REF(enum1, 2);
9148     EXPECT_REF(enum2, 1);
9149     IEnumVARIANT_Release(enum1);
9150
9151     IEnumVARIANT_Release(enum1);
9152     IEnumVARIANT_Release(enum2);
9153
9154     EXPECT_REF(selection, 1);
9155
9156     IXMLDOMNodeList_Release(list);
9157
9158     hr = IXMLDOMDocument_get_childNodes(doc, &list);
9159     EXPECT_HR(hr, S_OK);
9160
9161     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9162     EXPECT_HR(hr, E_NOINTERFACE);
9163
9164     IXMLDOMNodeList_Release(list);
9165
9166     /* test if IEnumVARIANT touches selection context */
9167     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
9168     EXPECT_HR(hr, S_OK);
9169
9170     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/*"), &list);
9171     EXPECT_HR(hr, S_OK);
9172
9173     hr = IXMLDOMNodeList_QueryInterface(list, &IID_IXMLDOMSelection, (void**)&selection);
9174     EXPECT_HR(hr, S_OK);
9175
9176     len = 0;
9177     hr = IXMLDOMSelection_get_length(selection, &len);
9178     EXPECT_HR(hr, S_OK);
9179     ok(len == 4, "got %d\n", len);
9180
9181     enum1 = NULL;
9182     hr = IXMLDOMSelection_get__newEnum(selection, (IUnknown**)&enum1);
9183     EXPECT_HR(hr, S_OK);
9184
9185     /* no-op if zero count */
9186     V_VT(&v) = VT_I2;
9187     hr = IEnumVARIANT_Next(enum1, 0, &v, NULL);
9188     EXPECT_HR(hr, S_OK);
9189     ok(V_VT(&v) == VT_I2, "got var type %d\n", V_VT(&v));
9190
9191     /* positive count, null array pointer */
9192     hr = IEnumVARIANT_Next(enum1, 1, NULL, NULL);
9193     EXPECT_HR(hr, E_INVALIDARG);
9194
9195     ret = 1;
9196     hr = IEnumVARIANT_Next(enum1, 1, NULL, &ret);
9197     EXPECT_HR(hr, E_INVALIDARG);
9198     ok(ret == 0, "got %d\n", ret);
9199
9200     V_VT(&v) = VT_I2;
9201     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
9202     EXPECT_HR(hr, S_OK);
9203     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
9204
9205     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
9206     EXPECT_HR(hr, S_OK);
9207     hr = IXMLDOMNode_get_nodeName(node, &name);
9208     EXPECT_HR(hr, S_OK);
9209     ok(!lstrcmpW(name, _bstr_("a")), "got node name %s\n", wine_dbgstr_w(name));
9210     SysFreeString(name);
9211     IXMLDOMNode_Release(node);
9212     VariantClear(&v);
9213
9214     /* list cursor is updated */
9215     hr = IXMLDOMSelection_nextNode(selection, &node);
9216     EXPECT_HR(hr, S_OK);
9217     hr = IXMLDOMNode_get_nodeName(node, &name);
9218     EXPECT_HR(hr, S_OK);
9219     ok(!lstrcmpW(name, _bstr_("c")), "got node name %s\n", wine_dbgstr_w(name));
9220     IXMLDOMNode_Release(node);
9221
9222     V_VT(&v) = VT_I2;
9223     hr = IEnumVARIANT_Next(enum1, 1, &v, NULL);
9224     EXPECT_HR(hr, S_OK);
9225     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
9226     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
9227     EXPECT_HR(hr, S_OK);
9228     hr = IXMLDOMNode_get_nodeName(node, &name);
9229     EXPECT_HR(hr, S_OK);
9230     ok(!lstrcmpW(name, _bstr_("b")), "got node name %s\n", wine_dbgstr_w(name));
9231     SysFreeString(name);
9232     IXMLDOMNode_Release(node);
9233     VariantClear(&v);
9234     IEnumVARIANT_Release(enum1);
9235
9236     hr = IXMLDOMSelection_nextNode(selection, &node);
9237     EXPECT_HR(hr, S_OK);
9238     hr = IXMLDOMNode_get_nodeName(node, &name);
9239     EXPECT_HR(hr, S_OK);
9240     ok(!lstrcmpW(name, _bstr_("d")), "got node name %s\n", wine_dbgstr_w(name));
9241     IXMLDOMNode_Release(node);
9242
9243     IXMLDOMSelection_Release(selection);
9244     IXMLDOMNodeList_Release(list);
9245     IXMLDOMDocument_Release(doc);
9246
9247     free_bstrs();
9248 }
9249
9250 static void test_load(void)
9251 {
9252     IXMLDOMDocument *doc;
9253     IXMLDOMNodeList *list;
9254     VARIANT_BOOL b;
9255     HANDLE hfile;
9256     VARIANT src;
9257     HRESULT hr;
9258     BOOL ret;
9259     BSTR path, bstr1, bstr2;
9260     DWORD written;
9261     void* ptr;
9262
9263     /* prepare a file */
9264     hfile = CreateFileA("test.xml", GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
9265     ok(hfile != INVALID_HANDLE_VALUE, "failed to create test file\n");
9266     if(hfile == INVALID_HANDLE_VALUE) return;
9267
9268     ret = WriteFile(hfile, win1252xml, strlen(win1252xml), &written, NULL);
9269     ok(ret, "WriteFile failed\n");
9270
9271     CloseHandle(hfile);
9272
9273     doc = create_document(&IID_IXMLDOMDocument);
9274
9275     /* null pointer as input */
9276     V_VT(&src) = VT_UNKNOWN;
9277     V_UNKNOWN(&src) = NULL;
9278     hr = IXMLDOMDocument_load(doc, src, &b);
9279     EXPECT_HR(hr, E_INVALIDARG);
9280     ok(b == VARIANT_FALSE, "got %d\n", b);
9281
9282     path = _bstr_("test.xml");
9283
9284     /* load from path: VT_BSTR */
9285     V_VT(&src) = VT_BSTR;
9286     V_BSTR(&src) = path;
9287     hr = IXMLDOMDocument_load(doc, src, &b);
9288     EXPECT_HR(hr, S_OK);
9289     ok(b == VARIANT_TRUE, "got %d\n", b);
9290
9291     /* load from a path: VT_BSTR|VT_BYREF */
9292     V_VT(&src) = VT_BSTR | VT_BYREF;
9293     V_BSTRREF(&src) = &path;
9294     hr = IXMLDOMDocument_load(doc, src, &b);
9295     EXPECT_HR(hr, S_OK);
9296     ok(b == VARIANT_TRUE, "got %d\n", b);
9297
9298     /* load from a path: VT_BSTR|VT_BYREF, null ptr */
9299     V_VT(&src) = VT_BSTR | VT_BYREF;
9300     V_BSTRREF(&src) = NULL;
9301     hr = IXMLDOMDocument_load(doc, src, &b);
9302     EXPECT_HR(hr, E_INVALIDARG);
9303     ok(b == VARIANT_FALSE, "got %d\n", b);
9304
9305     IXMLDOMDocument_Release(doc);
9306
9307     DeleteFileA("test.xml");
9308
9309     doc = create_document(&IID_IXMLDOMDocument);
9310
9311     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b);
9312     EXPECT_HR(hr, S_OK);
9313     ok(b == VARIANT_TRUE, "got %d\n", b);
9314
9315     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
9316     EXPECT_HR(hr, S_OK);
9317     bstr1 = _bstr_(list_to_string(list));
9318
9319     hr = IXMLDOMNodeList_reset(list);
9320     EXPECT_HR(hr, S_OK);
9321
9322     IXMLDOMDocument_Release(doc);
9323
9324     doc = create_document(&IID_IXMLDOMDocument);
9325
9326     VariantInit(&src);
9327     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenA(szExampleXML));
9328     V_VT(&src) = VT_ARRAY|VT_UI1;
9329     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
9330     ptr = NULL;
9331     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
9332     EXPECT_HR(hr, S_OK);
9333     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
9334
9335     memcpy(ptr, szExampleXML, lstrlenA(szExampleXML));
9336     hr = SafeArrayUnlock(V_ARRAY(&src));
9337     EXPECT_HR(hr, S_OK);
9338
9339     hr = IXMLDOMDocument_load(doc, src, &b);
9340     EXPECT_HR(hr, S_OK);
9341     ok(b == VARIANT_TRUE, "got %d\n", b);
9342
9343     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("//*"), &list);
9344     EXPECT_HR(hr, S_OK);
9345     bstr2 = _bstr_(list_to_string(list));
9346
9347     hr = IXMLDOMNodeList_reset(list);
9348     EXPECT_HR(hr, S_OK);
9349
9350     ok(lstrcmpW(bstr1, bstr2) == 0, "strings not equal: %s : %s\n",
9351        wine_dbgstr_w(bstr1), wine_dbgstr_w(bstr2));
9352
9353     IXMLDOMDocument_Release(doc);
9354     IXMLDOMNodeList_Release(list);
9355     VariantClear(&src);
9356
9357     /* UTF-16 isn't accepted */
9358     doc = create_document(&IID_IXMLDOMDocument);
9359
9360     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI1, 0, lstrlenW(szComplete1) * sizeof(WCHAR));
9361     V_VT(&src) = VT_ARRAY|VT_UI1;
9362     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
9363     ptr = NULL;
9364     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
9365     EXPECT_HR(hr, S_OK);
9366     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
9367
9368     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
9369     hr = SafeArrayUnlock(V_ARRAY(&src));
9370     EXPECT_HR(hr, S_OK);
9371
9372     hr = IXMLDOMDocument_load(doc, src, &b);
9373     todo_wine EXPECT_HR(hr, S_FALSE);
9374     todo_wine ok(b == VARIANT_FALSE, "got %d\n", b);
9375
9376     VariantClear(&src);
9377
9378     /* it doesn't like it as a VT_ARRAY|VT_UI2 either */
9379     V_ARRAY(&src) = SafeArrayCreateVector(VT_UI2, 0, lstrlenW(szComplete1));
9380     V_VT(&src) = VT_ARRAY|VT_UI2;
9381     ok(V_ARRAY(&src) != NULL, "SafeArrayCreateVector() returned NULL\n");
9382     ptr = NULL;
9383     hr = SafeArrayAccessData(V_ARRAY(&src), &ptr);
9384     EXPECT_HR(hr, S_OK);
9385     ok(ptr != NULL, "SafeArrayAccessData() returned NULL\n");
9386
9387     memcpy(ptr, szComplete1, lstrlenW(szComplete1) * sizeof(WCHAR));
9388     hr = SafeArrayUnlock(V_ARRAY(&src));
9389     EXPECT_HR(hr, S_OK);
9390
9391     hr = IXMLDOMDocument_load(doc, src, &b);
9392     todo_wine EXPECT_HR(hr, E_INVALIDARG);
9393     ok(b == VARIANT_FALSE, "got %d\n", b);
9394
9395     VariantClear(&src);
9396     IXMLDOMDocument_Release(doc);
9397
9398     free_bstrs();
9399 }
9400
9401 static void test_domobj_dispex(IUnknown *obj)
9402 {
9403     DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
9404     IDispatchEx *dispex;
9405     IUnknown *unk;
9406     DWORD props;
9407     UINT ticnt;
9408     HRESULT hr;
9409     BSTR name;
9410
9411     hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
9412     EXPECT_HR(hr, S_OK);
9413     if (FAILED(hr)) return;
9414
9415     ticnt = 0;
9416     hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
9417     EXPECT_HR(hr, S_OK);
9418     ok(ticnt == 1, "ticnt=%u\n", ticnt);
9419
9420     name = SysAllocString(szstar);
9421     hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
9422     EXPECT_HR(hr, E_NOTIMPL);
9423     SysFreeString(name);
9424
9425     hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
9426     EXPECT_HR(hr, E_NOTIMPL);
9427
9428     props = 0;
9429     hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
9430     EXPECT_HR(hr, E_NOTIMPL);
9431     ok(props == 0, "expected 0 got %d\n", props);
9432
9433     hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
9434     EXPECT_HR(hr, E_NOTIMPL);
9435     if (SUCCEEDED(hr)) SysFreeString(name);
9436
9437     hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
9438     EXPECT_HR(hr, E_NOTIMPL);
9439
9440     hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
9441     EXPECT_HR(hr, E_NOTIMPL);
9442     if (hr == S_OK && unk) IUnknown_Release(unk);
9443
9444     IDispatchEx_Release(dispex);
9445 }
9446
9447 static void test_mxnamespacemanager(void)
9448 {
9449     static const char xmluriA[] = "http://www.w3.org/XML/1998/namespace";
9450     IMXNamespacePrefixes *prefixes;
9451     IVBMXNamespaceManager *mgr2;
9452     IMXNamespaceManager *nsmgr;
9453     IUnknown *unk1, *unk2;
9454     WCHAR buffW[250];
9455     IDispatch *disp;
9456     IUnknown *unk;
9457     HRESULT hr;
9458     INT len;
9459
9460     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
9461         &IID_IMXNamespaceManager, (void**)&nsmgr);
9462     EXPECT_HR(hr, S_OK);
9463
9464     /* IMXNamespaceManager inherits from IUnknown */
9465     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IDispatch, (void**)&disp);
9466     EXPECT_HR(hr, S_OK);
9467     IDispatch_Release(disp);
9468
9469     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IVBMXNamespaceManager, (void**)&mgr2);
9470     EXPECT_HR(hr, S_OK);
9471
9472     EXPECT_REF(nsmgr, 2);
9473     EXPECT_REF(mgr2, 2);
9474     prefixes = NULL;
9475     hr = IVBMXNamespaceManager_getDeclaredPrefixes(mgr2, &prefixes);
9476     if (hr == S_OK)
9477     {
9478         ok(prefixes != NULL, "got %p\n", prefixes);
9479         EXPECT_REF(nsmgr, 2);
9480         EXPECT_REF(mgr2, 2);
9481         EXPECT_REF(prefixes, 1);
9482
9483         IVBMXNamespaceManager_QueryInterface(mgr2, &IID_IUnknown, (void**)&unk1);
9484         IMXNamespacePrefixes_QueryInterface(prefixes, &IID_IUnknown, (void**)&unk2);
9485
9486         EXPECT_REF(mgr2, 3);
9487         EXPECT_REF(prefixes, 2);
9488
9489         IUnknown_Release(unk1);
9490         IUnknown_Release(unk2);
9491         IMXNamespacePrefixes_Release(prefixes);
9492     }
9493     IVBMXNamespaceManager_Release(mgr2);
9494
9495     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
9496     EXPECT_HR(hr, S_OK);
9497
9498     /* prefix already added */
9499     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
9500     EXPECT_HR(hr, S_FALSE);
9501
9502     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), NULL);
9503     EXPECT_HR(hr, E_INVALIDARG);
9504
9505     /* "xml" and "xmlns" are not allowed here */
9506     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xml"), _bstr_("uri1"));
9507     EXPECT_HR(hr, E_INVALIDARG);
9508
9509     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("xmlns"), _bstr_("uri1"));
9510     EXPECT_HR(hr, E_INVALIDARG);
9511 todo_wine {
9512     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, -1, NULL, NULL);
9513     EXPECT_HR(hr, E_FAIL);
9514 }
9515     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, NULL);
9516     EXPECT_HR(hr, E_POINTER);
9517
9518     len = -1;
9519     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, NULL, &len);
9520     EXPECT_HR(hr, S_OK);
9521     ok(len == 3, "got %d\n", len);
9522
9523     len = -1;
9524     buffW[0] = 0x1;
9525     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
9526     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
9527     ok(len == -1, "got %d\n", len);
9528     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9529
9530     len = 10;
9531     buffW[0] = 0x1;
9532     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
9533     EXPECT_HR(hr, S_OK);
9534     ok(len == 3, "got %d\n", len);
9535     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
9536
9537     /* getURI */
9538     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, NULL);
9539     EXPECT_HR(hr, E_INVALIDARG);
9540
9541     len = -1;
9542     hr = IMXNamespaceManager_getURI(nsmgr, NULL, NULL, NULL, &len);
9543     EXPECT_HR(hr, E_INVALIDARG);
9544     ok(len == -1, "got %d\n", len);
9545
9546     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, NULL);
9547     EXPECT_HR(hr, E_POINTER);
9548
9549     len = -1;
9550     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, NULL, &len);
9551     EXPECT_HR(hr, S_OK);
9552     /* length of "xml" uri is constant */
9553     ok(len == strlen(xmluriA), "got %d\n", len);
9554
9555     len = 100;
9556     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
9557     EXPECT_HR(hr, S_OK);
9558     ok(len == strlen(xmluriA), "got %d\n", len);
9559     ok(!lstrcmpW(buffW, _bstr_(xmluriA)), "got prefix %s\n", wine_dbgstr_w(buffW));
9560
9561     len = strlen(xmluriA)-1;
9562     buffW[0] = 0x1;
9563     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml"), NULL, buffW, &len);
9564     EXPECT_HR(hr, E_XML_BUFFERTOOSMALL);
9565     ok(len == strlen(xmluriA)-1, "got %d\n", len);
9566     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9567
9568     /* prefix xml1 not defined */
9569     len = -1;
9570     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, NULL, &len);
9571     EXPECT_HR(hr, S_FALSE);
9572     ok(len == 0, "got %d\n", len);
9573
9574     len = 100;
9575     buffW[0] = 0x1;
9576     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_("xml1"), NULL, buffW, &len);
9577     EXPECT_HR(hr, S_FALSE);
9578     ok(buffW[0] == 0, "got %x\n", buffW[0]);
9579     ok(len == 0, "got %d\n", len);
9580
9581     /* IDispatchEx tests */
9582     hr = IMXNamespaceManager_QueryInterface(nsmgr, &IID_IUnknown, (void**)&unk);
9583     EXPECT_HR(hr, S_OK);
9584     test_domobj_dispex(unk);
9585     IUnknown_Release(unk);
9586
9587     IMXNamespaceManager_Release(nsmgr);
9588
9589     /* ::getPrefix() */
9590     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
9591         &IID_IMXNamespaceManager, (void**)&nsmgr);
9592     EXPECT_HR(hr, S_OK);
9593
9594     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, NULL);
9595     EXPECT_HR(hr, E_INVALIDARG);
9596
9597     len = -1;
9598     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, NULL, &len);
9599     EXPECT_HR(hr, E_INVALIDARG);
9600     ok(len == -1, "got %d\n", len);
9601
9602     len = 100;
9603     buffW[0] = 0x1;
9604     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
9605     EXPECT_HR(hr, E_FAIL);
9606     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9607     ok(len == 100, "got %d\n", len);
9608
9609     len = 0;
9610     buffW[0] = 0x1;
9611     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 0, buffW, &len);
9612     EXPECT_HR(hr, E_FAIL);
9613     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9614     ok(len == 0, "got %d\n", len);
9615
9616     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
9617     EXPECT_HR(hr, S_OK);
9618
9619     len = 100;
9620     buffW[0] = 0x1;
9621     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
9622     EXPECT_HR(hr, S_OK);
9623     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
9624     ok(len == 3, "got %d\n", len);
9625
9626     len = 100;
9627     buffW[0] = 0x1;
9628     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, buffW, &len);
9629     EXPECT_HR(hr, S_OK);
9630     ok(!lstrcmpW(buffW, _bstr_("xml")), "got %s\n", wine_dbgstr_w(buffW));
9631     ok(len == 3, "got %d\n", len);
9632
9633     /* with null buffer it's possible to get required length */
9634     len = 100;
9635     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
9636     EXPECT_HR(hr, S_OK);
9637     ok(len == 3, "got %d\n", len);
9638
9639     len = 0;
9640     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("http://www.w3.org/XML/1998/namespace"), 0, NULL, &len);
9641     EXPECT_HR(hr, S_OK);
9642     ok(len == 3, "got %d\n", len);
9643
9644     len = 100;
9645     buffW[0] = 0x1;
9646     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 1, buffW, &len);
9647     EXPECT_HR(hr, E_FAIL);
9648     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9649     ok(len == 100, "got %d\n", len);
9650
9651     len = 100;
9652     buffW[0] = 0x1;
9653     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 2, buffW, &len);
9654     EXPECT_HR(hr, E_FAIL);
9655     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9656     ok(len == 100, "got %d\n", len);
9657
9658     len = 100;
9659     buffW[0] = 0x1;
9660     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 0, buffW, &len);
9661     EXPECT_HR(hr, E_INVALIDARG);
9662     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9663     ok(len == 100, "got %d\n", len);
9664
9665     len = 100;
9666     buffW[0] = 0x1;
9667     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
9668     EXPECT_HR(hr, E_INVALIDARG);
9669     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9670     ok(len == 100, "got %d\n", len);
9671
9672     len = 100;
9673     buffW[0] = 0x1;
9674     hr = IMXNamespaceManager_getPrefix(nsmgr, NULL, 0, buffW, &len);
9675     EXPECT_HR(hr, E_INVALIDARG);
9676     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9677     ok(len == 100, "got %d\n", len);
9678
9679     len = 100;
9680     buffW[0] = 0x1;
9681     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns0 uri"), 1, buffW, &len);
9682     EXPECT_HR(hr, E_FAIL);
9683     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9684     ok(len == 100, "got %d\n", len);
9685
9686     len = 100;
9687     buffW[0] = 0x1;
9688     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
9689     EXPECT_HR(hr, E_INVALIDARG);
9690     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9691     ok(len == 100, "got %d\n", len);
9692
9693     /* declare another one, indices are shifted */
9694     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
9695     EXPECT_HR(hr, S_OK);
9696
9697     len = 100;
9698     buffW[0] = 0x1;
9699     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
9700     EXPECT_HR(hr, S_OK);
9701     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
9702     ok(len == 3, "got %d\n", len);
9703
9704     len = 100;
9705     buffW[0] = 0x1;
9706     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
9707     EXPECT_HR(hr, S_OK);
9708     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
9709     ok(len == 3, "got %d\n", len);
9710
9711     len = 100;
9712     buffW[0] = 0x1;
9713     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 1, buffW, &len);
9714     EXPECT_HR(hr, E_FAIL);
9715     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9716     ok(len == 100, "got %d\n", len);
9717
9718     len = 100;
9719     buffW[0] = 0x1;
9720     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_(""), 1, buffW, &len);
9721     EXPECT_HR(hr, E_INVALIDARG);
9722     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9723     ok(len == 100, "got %d\n", len);
9724
9725     IMXNamespaceManager_Release(nsmgr);
9726
9727     /* push/pop tests */
9728     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
9729         &IID_IMXNamespaceManager, (void**)&nsmgr);
9730     EXPECT_HR(hr, S_OK);
9731
9732     /* pop with empty stack */
9733     hr = IMXNamespaceManager_popContext(nsmgr);
9734     EXPECT_HR(hr, E_FAIL);
9735
9736     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
9737     EXPECT_HR(hr, S_OK);
9738
9739     len = 100;
9740     buffW[0] = 0x1;
9741     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
9742     EXPECT_HR(hr, S_OK);
9743     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
9744     ok(len == 3, "got %d\n", len);
9745
9746     hr = IMXNamespaceManager_pushContext(nsmgr);
9747     EXPECT_HR(hr, S_OK);
9748
9749     len = 100;
9750     buffW[0] = 0x1;
9751     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
9752     EXPECT_HR(hr, S_OK);
9753     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
9754     ok(len == 3, "got %d\n", len);
9755
9756     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns2"), _bstr_("ns2 uri"));
9757     EXPECT_HR(hr, S_OK);
9758
9759     len = 100;
9760     buffW[0] = 0x1;
9761     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
9762     EXPECT_HR(hr, S_OK);
9763     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
9764     ok(len == 3, "got %d\n", len);
9765
9766     hr = IMXNamespaceManager_pushContext(nsmgr);
9767     EXPECT_HR(hr, S_OK);
9768     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns3"), _bstr_("ns3 uri"));
9769     EXPECT_HR(hr, S_OK);
9770
9771     len = 100;
9772     buffW[0] = 0x1;
9773     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
9774     EXPECT_HR(hr, S_OK);
9775     ok(!lstrcmpW(buffW, _bstr_("ns2")), "got %s\n", wine_dbgstr_w(buffW));
9776     ok(len == 3, "got %d\n", len);
9777
9778     len = 100;
9779     buffW[0] = 0x1;
9780     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
9781     EXPECT_HR(hr, S_OK);
9782     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
9783     ok(len == 3, "got %d\n", len);
9784
9785     hr = IMXNamespaceManager_popContext(nsmgr);
9786     EXPECT_HR(hr, S_OK);
9787
9788     hr = IMXNamespaceManager_popContext(nsmgr);
9789     EXPECT_HR(hr, S_OK);
9790
9791     len = 100;
9792     buffW[0] = 0x1;
9793     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns2 uri"), 0, buffW, &len);
9794     EXPECT_HR(hr, E_FAIL);
9795     ok(buffW[0] == 0x1, "got %x\n", buffW[0]);
9796     ok(len == 100, "got %d\n", len);
9797
9798     len = 100;
9799     buffW[0] = 0x1;
9800     hr = IMXNamespaceManager_getPrefix(nsmgr, _bstr_("ns1 uri"), 0, buffW, &len);
9801     EXPECT_HR(hr, S_OK);
9802     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got %s\n", wine_dbgstr_w(buffW));
9803     ok(len == 3, "got %d\n", len);
9804
9805     IMXNamespaceManager_Release(nsmgr);
9806
9807     free_bstrs();
9808 }
9809
9810 static void test_mxnamespacemanager_override(void)
9811 {
9812     IMXNamespaceManager *nsmgr;
9813     WCHAR buffW[250];
9814     VARIANT_BOOL b;
9815     HRESULT hr;
9816     INT len;
9817
9818     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
9819         &IID_IMXNamespaceManager, (void**)&nsmgr);
9820     EXPECT_HR(hr, S_OK);
9821
9822     len = sizeof(buffW)/sizeof(WCHAR);
9823     buffW[0] = 0;
9824     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
9825     EXPECT_HR(hr, S_OK);
9826     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
9827
9828     len = sizeof(buffW)/sizeof(WCHAR);
9829     buffW[0] = 0;
9830     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
9831     EXPECT_HR(hr, E_FAIL);
9832
9833     hr = IMXNamespaceManager_getAllowOverride(nsmgr, NULL);
9834     EXPECT_HR(hr, E_POINTER);
9835
9836     b = VARIANT_FALSE;
9837     hr = IMXNamespaceManager_getAllowOverride(nsmgr, &b);
9838     EXPECT_HR(hr, S_OK);
9839     ok(b == VARIANT_TRUE, "got %d\n", b);
9840
9841     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_FALSE);
9842     EXPECT_HR(hr, S_OK);
9843
9844     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
9845     EXPECT_HR(hr, S_OK);
9846
9847     len = sizeof(buffW)/sizeof(WCHAR);
9848     buffW[0] = 0;
9849     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
9850     EXPECT_HR(hr, S_OK);
9851     ok(!lstrcmpW(buffW, _bstr_("ns0 uri")), "got uri %s\n", wine_dbgstr_w(buffW));
9852
9853     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns0"), _bstr_("ns0 uri"));
9854     EXPECT_HR(hr, S_OK);
9855
9856     len = sizeof(buffW)/sizeof(WCHAR);
9857     buffW[0] = 0;
9858     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 0, buffW, &len);
9859     EXPECT_HR(hr, S_OK);
9860     ok(!lstrcmpW(buffW, _bstr_("xml")), "got prefix %s\n", wine_dbgstr_w(buffW));
9861
9862     len = sizeof(buffW)/sizeof(WCHAR);
9863     buffW[0] = 0;
9864     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
9865     EXPECT_HR(hr, S_OK);
9866     ok(!lstrcmpW(buffW, _bstr_("ns0")), "got prefix %s\n", wine_dbgstr_w(buffW));
9867
9868     len = sizeof(buffW)/sizeof(WCHAR);
9869     buffW[0] = 0;
9870     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 2, buffW, &len);
9871     EXPECT_HR(hr, S_OK);
9872     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
9873
9874     /* new prefix placed at index 1 always */
9875     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_("ns1"), _bstr_("ns1 uri"));
9876     EXPECT_HR(hr, S_OK);
9877
9878     len = sizeof(buffW)/sizeof(WCHAR);
9879     buffW[0] = 0;
9880     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 1, buffW, &len);
9881     EXPECT_HR(hr, S_OK);
9882     ok(!lstrcmpW(buffW, _bstr_("ns1")), "got prefix %s\n", wine_dbgstr_w(buffW));
9883
9884     hr = IMXNamespaceManager_declarePrefix(nsmgr, _bstr_(""), NULL);
9885     todo_wine EXPECT_HR(hr, E_FAIL);
9886
9887     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, NULL);
9888     EXPECT_HR(hr, E_FAIL);
9889
9890     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri"));
9891     EXPECT_HR(hr, E_FAIL);
9892
9893     hr = IMXNamespaceManager_putAllowOverride(nsmgr, VARIANT_TRUE);
9894     EXPECT_HR(hr, S_OK);
9895
9896     hr = IMXNamespaceManager_declarePrefix(nsmgr, NULL, _bstr_("ns0 uri override"));
9897     EXPECT_HR(hr, S_FALSE);
9898
9899     len = sizeof(buffW)/sizeof(WCHAR);
9900     buffW[0] = 0;
9901     hr = IMXNamespaceManager_getURI(nsmgr, _bstr_(""), NULL, buffW, &len);
9902     EXPECT_HR(hr, S_OK);
9903     ok(!lstrcmpW(buffW, _bstr_("ns0 uri override")), "got uri %s\n", wine_dbgstr_w(buffW));
9904
9905     len = sizeof(buffW)/sizeof(WCHAR);
9906     buffW[0] = 0;
9907     hr = IMXNamespaceManager_getDeclaredPrefix(nsmgr, 3, buffW, &len);
9908     EXPECT_HR(hr, S_OK);
9909     ok(!lstrcmpW(buffW, _bstr_("")), "got prefix %s\n", wine_dbgstr_w(buffW));
9910
9911     IMXNamespaceManager_Release(nsmgr);
9912
9913     free_bstrs();
9914 }
9915
9916 static const DOMNodeType nodetypes_test[] =
9917 {
9918     NODE_ELEMENT,
9919     NODE_ATTRIBUTE,
9920     NODE_TEXT,
9921     NODE_CDATA_SECTION,
9922     NODE_ENTITY_REFERENCE,
9923     NODE_PROCESSING_INSTRUCTION,
9924     NODE_COMMENT,
9925     NODE_DOCUMENT_FRAGMENT,
9926     NODE_INVALID
9927 };
9928
9929 static void test_dispex(void)
9930 {
9931     const DOMNodeType *type = nodetypes_test;
9932     IXMLDOMImplementation *impl;
9933     IXMLDOMNodeList *node_list;
9934     IXMLDOMParseError *error;
9935     IXMLDOMNamedNodeMap *map;
9936     IXSLProcessor *processor;
9937     IXSLTemplate *template;
9938     IXMLDOMDocument *doc;
9939     IXMLHTTPRequest *req;
9940     IXMLDOMElement *elem;
9941     IDispatchEx *dispex;
9942     DISPPARAMS dispparams;
9943     IXMLDOMNode *node;
9944     VARIANT arg, ret;
9945     VARIANT_BOOL b;
9946     IUnknown *unk;
9947     HRESULT hr;
9948     DISPID did;
9949
9950     doc = create_document(&IID_IXMLDOMDocument);
9951
9952     IXMLDOMDocument_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
9953     test_domobj_dispex(unk);
9954     IUnknown_Release(unk);
9955
9956     for(; *type != NODE_INVALID; type++)
9957     {
9958         IXMLDOMNode *node;
9959         VARIANT v;
9960
9961         V_VT(&v) = VT_I2;
9962         V_I2(&v) = *type;
9963
9964         hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
9965         ok(hr == S_OK, "failed to create node type %d\n", *type);
9966
9967         IXMLDOMNode_QueryInterface(node, &IID_IUnknown, (void**)&unk);
9968
9969         test_domobj_dispex(unk);
9970         IUnknown_Release(unk);
9971         IXMLDOMNode_Release(node);
9972     }
9973
9974     /* IXMLDOMNodeList */
9975     hr = IXMLDOMDocument_getElementsByTagName(doc, _bstr_("*"), &node_list);
9976     EXPECT_HR(hr, S_OK);
9977     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
9978     test_domobj_dispex(unk);
9979     IUnknown_Release(unk);
9980     IXMLDOMNodeList_Release(node_list);
9981
9982     /* IXMLDOMNodeList for children list */
9983     hr = IXMLDOMDocument_get_childNodes(doc, &node_list);
9984     EXPECT_HR(hr, S_OK);
9985     IXMLDOMNodeList_QueryInterface(node_list, &IID_IUnknown, (void**)&unk);
9986     test_domobj_dispex(unk);
9987     IUnknown_Release(unk);
9988
9989     /* collection dispex test, empty collection */
9990     hr = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatchEx, (void**)&dispex);
9991     EXPECT_HR(hr, S_OK);
9992     did = 0;
9993     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
9994     EXPECT_HR(hr, S_OK);
9995     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
9996     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
9997     EXPECT_HR(hr, S_OK);
9998     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
9999     IDispatchEx_Release(dispex);
10000
10001     did = -1;
10002     hr = IDispatchEx_GetDispID(dispex, _bstr_("item"), 0, &did);
10003     ok(hr == S_OK, "got 0x%08x\n", hr);
10004     ok(did == DISPID_VALUE, "got %d\n", did);
10005
10006     V_VT(&arg) = VT_I4;
10007     V_I2(&arg) = 0;
10008     dispparams.cArgs = 1;
10009     dispparams.cNamedArgs = 0;
10010     dispparams.rgdispidNamedArgs = NULL;
10011     dispparams.rgvarg = &arg;
10012
10013     V_VT(&ret) = VT_EMPTY;
10014     V_DISPATCH(&ret) = (void*)0x1;
10015     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10016 todo_wine
10017     ok(hr == S_OK, "got 0x%08x\n", hr);
10018     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10019     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10020
10021     V_VT(&ret) = VT_EMPTY;
10022     V_DISPATCH(&ret) = (void*)0x1;
10023     hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10024     ok(hr == S_OK, "got 0x%08x\n", hr);
10025     ok(V_VT(&ret) == VT_DISPATCH, "got %d\n", V_VT(&ret));
10026     ok(V_DISPATCH(&ret) == NULL, "got %p\n", V_DISPATCH(&ret));
10027
10028     dispparams.cArgs = 0;
10029     dispparams.cNamedArgs = 0;
10030     dispparams.rgdispidNamedArgs = NULL;
10031     dispparams.rgvarg = NULL;
10032
10033     V_VT(&ret) = VT_EMPTY;
10034     V_I4(&ret) = 1;
10035     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &ret, NULL, NULL);
10036     ok(hr == S_OK, "got 0x%08x\n", hr);
10037     ok(V_VT(&ret) == VT_I4, "got %d\n", V_VT(&ret));
10038     ok(V_I4(&ret) == 0, "got %d\n", V_I4(&ret));
10039
10040     dispparams.cArgs = 0;
10041     dispparams.cNamedArgs = 0;
10042     dispparams.rgdispidNamedArgs = NULL;
10043     dispparams.rgvarg = NULL;
10044
10045     V_VT(&ret) = VT_EMPTY;
10046     V_I4(&ret) = 1;
10047     hr = IDispatchEx_Invoke(dispex, DISPID_DOM_NODELIST_LENGTH, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
10048     ok(hr == DISP_E_MEMBERNOTFOUND, "got 0x%08x\n", hr);
10049 todo_wine {
10050     ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
10051     ok(V_I4(&ret) == 1, "got %d\n", V_I4(&ret));
10052 }
10053     IXMLDOMNodeList_Release(node_list);
10054
10055     /* IXMLDOMParseError */
10056     hr = IXMLDOMDocument_get_parseError(doc, &error);
10057     EXPECT_HR(hr, S_OK);
10058     IXMLDOMParseError_QueryInterface(error, &IID_IUnknown, (void**)&unk);
10059     test_domobj_dispex(unk);
10060     IUnknown_Release(unk);
10061     IXMLDOMParseError_Release(error);
10062
10063     /* IXMLDOMNamedNodeMap */
10064     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xpath_simple_list), &b);
10065     EXPECT_HR(hr, S_OK);
10066
10067     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/a"), &node_list);
10068     EXPECT_HR(hr, S_OK);
10069     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
10070     EXPECT_HR(hr, S_OK);
10071     IXMLDOMNodeList_Release(node_list);
10072
10073     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
10074     EXPECT_HR(hr, S_OK);
10075     IXMLDOMNode_Release(node);
10076     hr = IXMLDOMElement_get_attributes(elem, &map);
10077     EXPECT_HR(hr, S_OK);
10078     IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk);
10079     test_domobj_dispex(unk);
10080     IUnknown_Release(unk);
10081     /* collection dispex test */
10082     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
10083     EXPECT_HR(hr, S_OK);
10084     did = 0;
10085     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10086     EXPECT_HR(hr, S_OK);
10087     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10088     IDispatchEx_Release(dispex);
10089
10090     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("root/b"), &node_list);
10091     EXPECT_HR(hr, S_OK);
10092     hr = IXMLDOMNodeList_get_item(node_list, 0, &node);
10093     EXPECT_HR(hr, S_OK);
10094     IXMLDOMNodeList_Release(node_list);
10095     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
10096     EXPECT_HR(hr, S_OK);
10097     IXMLDOMNode_Release(node);
10098     hr = IXMLDOMElement_get_attributes(elem, &map);
10099     EXPECT_HR(hr, S_OK);
10100     /* collection dispex test, empty collection */
10101     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IDispatchEx, (void**)&dispex);
10102     EXPECT_HR(hr, S_OK);
10103     did = 0;
10104     hr = IDispatchEx_GetDispID(dispex, _bstr_("0"), 0, &did);
10105     EXPECT_HR(hr, S_OK);
10106     ok(did == DISPID_DOM_COLLECTION_BASE, "got 0x%08x\n", did);
10107     hr = IDispatchEx_GetDispID(dispex, _bstr_("1"), 0, &did);
10108     EXPECT_HR(hr, S_OK);
10109     ok(did == DISPID_DOM_COLLECTION_BASE+1, "got 0x%08x\n", did);
10110     IDispatchEx_Release(dispex);
10111
10112     IXMLDOMNamedNodeMap_Release(map);
10113     IXMLDOMElement_Release(elem);
10114
10115     /* IXMLDOMImplementation */
10116     hr = IXMLDOMDocument_get_implementation(doc, &impl);
10117     EXPECT_HR(hr, S_OK);
10118
10119     hr = IXMLDOMImplementation_QueryInterface(impl, &IID_IDispatchEx, (void**)&dispex);
10120     EXPECT_HR(hr, S_OK);
10121     IDispatchEx_Release(dispex);
10122     IXMLDOMImplementation_Release(impl);
10123
10124     IXMLDOMDocument_Release(doc);
10125
10126     /* IXMLHTTPRequest */
10127     hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER,
10128         &IID_IXMLHttpRequest, (void**)&req);
10129     if (hr == S_OK)
10130     {
10131         hr = IXMLHTTPRequest_QueryInterface(req, &IID_IDispatchEx, (void**)&dispex);
10132         EXPECT_HR(hr, E_NOINTERFACE);
10133         IXMLHTTPRequest_Release(req);
10134     }
10135
10136     /* IXSLTemplate */
10137     template = create_xsltemplate(&IID_IXSLTemplate);
10138     hr = IXSLTemplate_QueryInterface(template, &IID_IDispatchEx, (void**)&dispex);
10139     EXPECT_HR(hr, S_OK);
10140     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
10141     EXPECT_HR(hr, S_OK);
10142     test_domobj_dispex(unk);
10143     IUnknown_Release(unk);
10144     IDispatchEx_Release(dispex);
10145
10146     /* IXSLProcessor */
10147     hr = CoCreateInstance(&CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc);
10148     EXPECT_HR(hr, S_OK);
10149     b = VARIANT_FALSE;
10150     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformSSXML), &b);
10151     EXPECT_HR(hr, S_OK);
10152     ok(b == VARIANT_TRUE, "got %d\n", b);
10153
10154     hr = IXSLTemplate_putref_stylesheet(template, (IXMLDOMNode*)doc);
10155     EXPECT_HR(hr, S_OK);
10156     IXMLDOMDocument_Release(doc);
10157
10158     hr = IXSLTemplate_createProcessor(template, &processor);
10159     EXPECT_HR(hr, S_OK);
10160     hr = IXSLProcessor_QueryInterface(processor, &IID_IDispatchEx, (void**)&dispex);
10161     EXPECT_HR(hr, S_OK);
10162     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
10163     EXPECT_HR(hr, S_OK);
10164     test_domobj_dispex(unk);
10165     IUnknown_Release(unk);
10166     IDispatchEx_Release(dispex);
10167
10168     IXSLProcessor_Release(processor);
10169     IXSLTemplate_Release(template);
10170
10171     free_bstrs();
10172 }
10173
10174 static void test_parseerror(void)
10175 {
10176     IXMLDOMParseError2 *error2;
10177     IXMLDOMParseError *error;
10178     IXMLDOMDocument *doc;
10179     HRESULT hr;
10180
10181     doc = create_document(&IID_IXMLDOMDocument);
10182
10183     hr = IXMLDOMDocument_get_parseError(doc, &error);
10184     EXPECT_HR(hr, S_OK);
10185
10186     hr = IXMLDOMParseError_get_line(error, NULL);
10187     EXPECT_HR(hr, E_INVALIDARG);
10188
10189     hr = IXMLDOMParseError_get_srcText(error, NULL);
10190     EXPECT_HR(hr, E_INVALIDARG);
10191
10192     hr = IXMLDOMParseError_get_linepos(error, NULL);
10193     EXPECT_HR(hr, E_INVALIDARG);
10194
10195     IXMLDOMParseError_Release(error);
10196     IXMLDOMDocument_Release(doc);
10197
10198     doc = create_document_version(60, &IID_IXMLDOMDocument);
10199     if (!doc) return;
10200     hr = IXMLDOMDocument_get_parseError(doc, &error);
10201     EXPECT_HR(hr, S_OK);
10202     hr = IXMLDOMParseError_QueryInterface(error, &IID_IXMLDOMParseError2, (void**)&error2);
10203     EXPECT_HR(hr, S_OK);
10204     IXMLDOMParseError2_Release(error2);
10205     IXMLDOMParseError_Release(error);
10206     IXMLDOMDocument_Release(doc);
10207 }
10208
10209 static void test_getAttributeNode(void)
10210 {
10211     IXMLDOMAttribute *attr;
10212     IXMLDOMDocument *doc;
10213     IXMLDOMElement *elem;
10214     VARIANT_BOOL v;
10215     HRESULT hr;
10216     BSTR str;
10217
10218     doc = create_document(&IID_IXMLDOMDocument);
10219
10220     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &v);
10221     EXPECT_HR(hr, S_OK);
10222
10223     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10224     EXPECT_HR(hr, S_OK);
10225
10226     str = SysAllocString(nonexistent_fileW);
10227     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
10228     EXPECT_HR(hr, E_FAIL);
10229
10230     attr = (IXMLDOMAttribute*)0xdeadbeef;
10231     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
10232     EXPECT_HR(hr, E_FAIL);
10233     ok(attr == NULL, "got %p\n", attr);
10234     SysFreeString(str);
10235
10236     str = SysAllocString(nonexistent_attrW);
10237     hr = IXMLDOMElement_getAttributeNode(elem, str, NULL);
10238     EXPECT_HR(hr, S_FALSE);
10239
10240     attr = (IXMLDOMAttribute*)0xdeadbeef;
10241     hr = IXMLDOMElement_getAttributeNode(elem, str, &attr);
10242     EXPECT_HR(hr, S_FALSE);
10243     ok(attr == NULL, "got %p\n", attr);
10244     SysFreeString(str);
10245
10246     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("foo:b"), &attr);
10247     EXPECT_HR(hr, S_OK);
10248     IXMLDOMAttribute_Release(attr);
10249
10250     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("b"), &attr);
10251     EXPECT_HR(hr, S_FALSE);
10252
10253     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("a"), &attr);
10254     EXPECT_HR(hr, S_OK);
10255     IXMLDOMAttribute_Release(attr);
10256
10257     IXMLDOMElement_Release(elem);
10258     IXMLDOMDocument_Release(doc);
10259     free_bstrs();
10260 }
10261
10262 typedef struct {
10263     DOMNodeType type;
10264     const char *name;
10265     REFIID iids[3];
10266 } supporterror_t;
10267
10268 static const supporterror_t supporterror_test[] = {
10269     { NODE_ELEMENT,                "element",   { &IID_IXMLDOMNode, &IID_IXMLDOMElement } },
10270     { NODE_ATTRIBUTE,              "attribute", { &IID_IXMLDOMNode, &IID_IXMLDOMAttribute } },
10271     { NODE_CDATA_SECTION,          "cdata",     { &IID_IXMLDOMNode, &IID_IXMLDOMCDATASection } },
10272     { NODE_ENTITY_REFERENCE,       "entityref", { &IID_IXMLDOMNode, &IID_IXMLDOMEntityReference } },
10273     { NODE_PROCESSING_INSTRUCTION, "pi",        { &IID_IXMLDOMNode, &IID_IXMLDOMProcessingInstruction } },
10274     { NODE_COMMENT,                "comment",   { &IID_IXMLDOMNode, &IID_IXMLDOMComment } },
10275     { NODE_DOCUMENT_FRAGMENT,      "fragment",  { &IID_IXMLDOMNode, &IID_IXMLDOMDocumentFragment } },
10276     { NODE_INVALID }
10277 };
10278
10279 static void test_supporterrorinfo(void)
10280 {
10281     static REFIID iids[5] = { &IID_IXMLDOMNode, &IID_IXMLDOMDocument,
10282                               &IID_IXMLDOMDocument2, &IID_IXMLDOMDocument3 };
10283     const supporterror_t *ptr = supporterror_test;
10284     ISupportErrorInfo *errorinfo, *info2;
10285     IXMLDOMNamedNodeMap *map, *map2;
10286     IXMLDOMDocument *doc;
10287     IXMLDOMElement *elem;
10288     VARIANT_BOOL b;
10289     IUnknown *unk;
10290     REFIID *iid;
10291     void *dummy;
10292     HRESULT hr;
10293
10294     doc = create_document_version(60, &IID_IXMLDOMDocument3);
10295     if (!doc) return;
10296
10297     EXPECT_REF(doc, 1);
10298     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&errorinfo);
10299     EXPECT_HR(hr, S_OK);
10300     EXPECT_REF(doc, 1);
10301     ISupportErrorInfo_AddRef(errorinfo);
10302     EXPECT_REF(errorinfo, 2);
10303     EXPECT_REF(doc, 1);
10304     ISupportErrorInfo_Release(errorinfo);
10305
10306     hr = IXMLDOMDocument_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&info2);
10307     EXPECT_HR(hr, S_OK);
10308     ok(errorinfo != info2, "got %p, %p\n", info2, errorinfo);
10309
10310     /* error interface can't be queried back for DOM interface */
10311     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMDocument, &dummy);
10312     EXPECT_HR(hr, E_NOINTERFACE);
10313     hr = ISupportErrorInfo_QueryInterface(info2, &IID_IXMLDOMNode, &dummy);
10314     EXPECT_HR(hr, E_NOINTERFACE);
10315
10316     ISupportErrorInfo_Release(info2);
10317
10318     iid = iids;
10319     while (*iid)
10320     {
10321         hr = IXMLDOMDocument_QueryInterface(doc, *iid, (void**)&unk);
10322         EXPECT_HR(hr, S_OK);
10323         if (hr == S_OK)
10324         {
10325             hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
10326             ok(hr == S_OK, "got 0x%08x for %s\n", hr, debugstr_guid(*iid));
10327             IUnknown_Release(unk);
10328         }
10329
10330         iid++;
10331     }
10332
10333     ISupportErrorInfo_Release(errorinfo);
10334
10335     while (ptr->type != NODE_INVALID)
10336     {
10337         IXMLDOMNode *node;
10338         VARIANT type;
10339
10340         V_VT(&type) = VT_I1;
10341         V_I1(&type) = ptr->type;
10342
10343         hr = IXMLDOMDocument_createNode(doc, type, _bstr_(ptr->name), NULL, &node);
10344         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
10345
10346         EXPECT_REF(node, 1);
10347         hr = IXMLDOMNode_QueryInterface(node, &IID_ISupportErrorInfo, (void**)&errorinfo);
10348         ok(hr == S_OK, "%d: got 0x%08x\n", ptr->type, hr);
10349         EXPECT_REF(node, 1);
10350
10351         hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNode, &dummy);
10352         ok(hr == E_NOINTERFACE, "%d: got 0x%08x\n", ptr->type, hr);
10353
10354         iid = ptr->iids;
10355
10356         while (*iid)
10357         {
10358             hr = IXMLDOMNode_QueryInterface(node, *iid, (void**)&unk);
10359             if (hr == S_OK)
10360             {
10361                 hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, *iid);
10362                 ok(hr == S_OK, "%d: got 0x%08x for %s\n", ptr->type, hr, debugstr_guid(*iid));
10363                 IUnknown_Release(unk);
10364             }
10365
10366             iid++;
10367         }
10368
10369         ISupportErrorInfo_Release(errorinfo);
10370         IXMLDOMNode_Release(node);
10371         ptr++;
10372     }
10373
10374     /* IXMLDOMNamedNodeMap */
10375     b = VARIANT_FALSE;
10376     hr = IXMLDOMDocument_loadXML(doc, _bstr_(complete4A), &b);
10377     EXPECT_HR(hr, S_OK);
10378     ok(b == VARIANT_TRUE, "got %d\n", b);
10379
10380     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10381     EXPECT_HR(hr, S_OK);
10382
10383     hr = IXMLDOMElement_get_attributes(elem, &map);
10384     EXPECT_HR(hr, S_OK);
10385
10386     EXPECT_REF(map, 1);
10387     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_ISupportErrorInfo, (void**)&errorinfo);
10388     EXPECT_HR(hr, S_OK);
10389     EXPECT_REF(map, 2);
10390
10391     hr = ISupportErrorInfo_InterfaceSupportsErrorInfo(errorinfo, &IID_IXMLDOMNamedNodeMap);
10392     EXPECT_HR(hr, S_OK);
10393
10394     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IXMLDOMNamedNodeMap, (void**)&map2);
10395     EXPECT_HR(hr, S_OK);
10396     ok(map == map2, "got %p\n", map2);
10397     IXMLDOMNamedNodeMap_Release(map2);
10398
10399     EXPECT_REF(errorinfo, 2);
10400     hr = ISupportErrorInfo_QueryInterface(errorinfo, &IID_IUnknown, (void**)&unk);
10401     EXPECT_HR(hr, S_OK);
10402     EXPECT_REF(errorinfo, 3);
10403     EXPECT_REF(map, 3);
10404     IUnknown_Release(unk);
10405
10406     ISupportErrorInfo_Release(errorinfo);
10407     IXMLDOMNamedNodeMap_Release(map);
10408     IXMLDOMElement_Release(elem);
10409
10410     IXMLDOMDocument_Release(doc);
10411     free_bstrs();
10412 }
10413
10414 typedef struct {
10415     DOMNodeType type;
10416     const char *name;
10417     const char *put_content;
10418     HRESULT put_hr;
10419     VARTYPE get_vt;
10420     HRESULT get_hr;
10421 } node_value_t;
10422
10423 static const node_value_t nodevalue_test[] = {
10424     { NODE_ELEMENT,                "element",   "",             E_FAIL, VT_NULL, S_FALSE },
10425     { NODE_ATTRIBUTE,              "attr",      "value",        S_OK,   VT_BSTR, S_OK },
10426     { NODE_TEXT,                   "text",      "textdata",     S_OK,   VT_BSTR, S_OK },
10427     { NODE_CDATA_SECTION ,         "cdata",     "cdata data",   S_OK,   VT_BSTR, S_OK },
10428     { NODE_ENTITY_REFERENCE,       "entityref", "ref",          E_FAIL, VT_NULL, S_FALSE },
10429     { NODE_PROCESSING_INSTRUCTION, "pi",        "instr",        S_OK,   VT_BSTR, S_OK },
10430     { NODE_COMMENT,                "comment",   "comment data", S_OK,   VT_BSTR, S_OK },
10431     { NODE_DOCUMENT_FRAGMENT,      "docfrag",   "",             E_FAIL, VT_NULL, S_FALSE },
10432     { NODE_INVALID }
10433 };
10434
10435 static void test_nodeValue(void)
10436 {
10437     const node_value_t *ptr = nodevalue_test;
10438     IXMLDOMDocument *doc;
10439     HRESULT hr;
10440
10441     doc = create_document(&IID_IXMLDOMDocument);
10442     if (!doc) return;
10443
10444     while (ptr->type != NODE_INVALID)
10445     {
10446         IXMLDOMNode *node;
10447         VARIANT v;
10448
10449         V_VT(&v) = VT_I2;
10450         V_I2(&v) = ptr->type;
10451
10452         hr = IXMLDOMDocument_createNode(doc, v, _bstr_(ptr->name), NULL, &node);
10453         ok(hr == S_OK, "failed to create node type %d\n", ptr->type);
10454
10455         hr = IXMLDOMNode_get_nodeValue(node, NULL);
10456         ok(hr == E_INVALIDARG, "%d: got 0x%08x\n", ptr->type, hr);
10457
10458         V_VT(&v) = VT_BSTR;
10459         V_BSTR(&v) = _bstr_(ptr->put_content);
10460         hr = IXMLDOMNode_put_nodeValue(node, v);
10461         ok(hr == ptr->put_hr, "%d: got 0x%08x\n", ptr->type, hr);
10462
10463         V_VT(&v) = VT_EMPTY;
10464         hr = IXMLDOMNode_get_nodeValue(node, &v);
10465         ok(hr == ptr->get_hr, "%d: got 0x%08x, expected 0x%08x\n", ptr->type, hr, ptr->get_hr);
10466         ok(V_VT(&v) == ptr->get_vt, "%d: got %d, expected %d\n", ptr->type, V_VT(&v), ptr->get_vt);
10467         if (hr == S_OK)
10468             ok(!lstrcmpW(V_BSTR(&v), _bstr_(ptr->put_content)), "%d: got %s\n", ptr->type,
10469                 wine_dbgstr_w(V_BSTR(&v)));
10470         VariantClear(&v);
10471
10472         IXMLDOMNode_Release(node);
10473
10474         ptr++;
10475     }
10476
10477     IXMLDOMDocument_Release(doc);
10478 }
10479
10480 static const char namespacesA[] =
10481 "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
10482 "   <ns1:elem1 xmlns:ns1=\"http://blah.org\" b='1' >"
10483 "     <ns2:elem2 xmlns:ns2=\"http://blah.org\"/>"
10484 "     <ns1:elem3/>"
10485 "     <ns1:elem4/>"
10486 "     <elem5 xmlns=\"http://blahblah.org\"/>"
10487 "     <ns1:elem6>true</ns1:elem6>"
10488 "   </ns1:elem1>";
10489
10490 static const char xsd_schema1_uri[] = "x-schema:test1.xsd";
10491 static const char xsd_schema1_xml[] =
10492 "<?xml version='1.0'?>"
10493 "<schema xmlns='http://www.w3.org/2001/XMLSchema'"
10494 "            targetNamespace='x-schema:test1.xsd'>"
10495 "   <element name='root'>"
10496 "       <complexType>"
10497 "           <sequence maxOccurs='unbounded'>"
10498 "               <any/>"
10499 "           </sequence>"
10500 "       </complexType>"
10501 "   </element>"
10502 "</schema>";
10503
10504 static void test_get_namespaces(void)
10505 {
10506     IXMLDOMSchemaCollection *collection, *collection2;
10507     IXMLDOMDocument2 *doc, *doc2;
10508     IEnumVARIANT *enumv, *enum2;
10509     IUnknown *unk1, *unk2;
10510     IXMLDOMNode *node;
10511     VARIANT_BOOL b;
10512     HRESULT hr;
10513     VARIANT v;
10514     LONG len;
10515     BSTR s;
10516
10517     doc = create_document(&IID_IXMLDOMDocument2);
10518     if (!doc) return;
10519
10520     /* null pointer */
10521     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
10522     EXPECT_HR(hr, E_POINTER);
10523
10524     /* no document loaded */
10525     collection = (void*)0xdeadbeef;
10526     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
10527     EXPECT_HR(hr, S_OK);
10528     if (hr != S_OK)
10529     {
10530         IXMLDOMDocument2_Release(doc);
10531         return;
10532     }
10533     EXPECT_REF(collection, 2);
10534
10535     collection2 = (void*)0xdeadbeef;
10536     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
10537     EXPECT_HR(hr, S_OK);
10538     ok(collection == collection2, "got %p\n", collection2);
10539     EXPECT_REF(collection, 3);
10540     IXMLDOMSchemaCollection_Release(collection);
10541
10542     len = -1;
10543     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
10544     EXPECT_HR(hr, S_OK);
10545     ok(len == 0, "got %d\n", len);
10546     IXMLDOMSchemaCollection_Release(collection);
10547
10548     /* now with document */
10549     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
10550     EXPECT_HR(hr, S_OK);
10551
10552     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
10553     EXPECT_HR(hr, S_OK);
10554
10555     len = -1;
10556     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
10557     EXPECT_HR(hr, S_OK);
10558     ok(len == 2, "got %d\n", len);
10559
10560     /* try to lookup some uris */
10561     node = (void*)0xdeadbeef;
10562     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
10563     EXPECT_HR(hr, S_OK);
10564     ok(node == NULL, "got %p\n", node);
10565
10566     node = (void*)0xdeadbeef;
10567     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah1.org"), &node);
10568     EXPECT_HR(hr, S_OK);
10569     ok(node == NULL, "got %p\n", node);
10570
10571     /* load schema and try to add it */
10572     doc2 = create_document(&IID_IXMLDOMDocument2);
10573     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
10574     EXPECT_HR(hr, S_OK);
10575
10576     V_VT(&v) = VT_DISPATCH;
10577     V_DISPATCH(&v) = (IDispatch*)doc2;
10578     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
10579     EXPECT_HR(hr, E_FAIL);
10580
10581     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
10582     EXPECT_HR(hr, S_OK);
10583     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
10584     SysFreeString(s);
10585
10586     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
10587     EXPECT_HR(hr, S_OK);
10588     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
10589     SysFreeString(s);
10590
10591     s = (void*)0xdeadbeef;
10592     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
10593     EXPECT_HR(hr, E_FAIL);
10594     ok(s == (void*)0xdeadbeef, "got %p\n", s);
10595
10596     /* enumerate */
10597     enumv = (void*)0xdeadbeef;
10598     EXPECT_REF(collection, 2);
10599     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
10600     EXPECT_HR(hr, S_OK);
10601     EXPECT_REF(collection, 3);
10602     ok(enumv != NULL, "got %p\n", enumv);
10603
10604     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IUnknown, (void**)&unk1);
10605     EXPECT_HR(hr, S_OK);
10606     hr = IEnumVARIANT_QueryInterface(enumv, &IID_IUnknown, (void**)&unk2);
10607     EXPECT_HR(hr, S_OK);
10608     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
10609     IUnknown_Release(unk1);
10610     IUnknown_Release(unk2);
10611
10612     hr = IXMLDOMSchemaCollection_QueryInterface(collection, &IID_IEnumVARIANT, (void**)&enum2);
10613     EXPECT_HR(hr, E_NOINTERFACE);
10614
10615     V_VT(&v) = VT_EMPTY;
10616     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
10617     EXPECT_HR(hr, S_OK);
10618     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
10619     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
10620     VariantClear(&v);
10621
10622     V_VT(&v) = VT_EMPTY;
10623     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
10624     EXPECT_HR(hr, S_OK);
10625     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
10626     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
10627     VariantClear(&v);
10628
10629     V_VT(&v) = VT_NULL;
10630     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
10631     EXPECT_HR(hr, S_FALSE);
10632     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
10633
10634     IEnumVARIANT_Release(enumv);
10635     IXMLDOMSchemaCollection_Release(collection);
10636
10637     IXMLDOMDocument2_Release(doc);
10638
10639     /* now with CLSID_DOMDocument60 */
10640     doc = create_document_version(60, &IID_IXMLDOMDocument2);
10641     if (!doc) return;
10642
10643     /* null pointer */
10644     hr = IXMLDOMDocument2_get_namespaces(doc, NULL);
10645     EXPECT_HR(hr, E_POINTER);
10646
10647     /* no document loaded */
10648     collection = (void*)0xdeadbeef;
10649     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
10650     EXPECT_HR(hr, S_OK);
10651     if (hr != S_OK)
10652     {
10653         IXMLDOMDocument2_Release(doc);
10654         return;
10655     }
10656     EXPECT_REF(collection, 2);
10657
10658     collection2 = (void*)0xdeadbeef;
10659     hr = IXMLDOMDocument2_get_namespaces(doc, &collection2);
10660     EXPECT_HR(hr, S_OK);
10661     ok(collection == collection2, "got %p\n", collection2);
10662     EXPECT_REF(collection, 3);
10663     IXMLDOMSchemaCollection_Release(collection);
10664
10665     len = -1;
10666     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
10667     EXPECT_HR(hr, S_OK);
10668     ok(len == 0, "got %d\n", len);
10669     IXMLDOMSchemaCollection_Release(collection);
10670
10671     /* now with document */
10672     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(namespacesA), &b);
10673     EXPECT_HR(hr, S_OK);
10674
10675     hr = IXMLDOMDocument2_get_namespaces(doc, &collection);
10676     EXPECT_HR(hr, S_OK);
10677
10678     len = -1;
10679     hr = IXMLDOMSchemaCollection_get_length(collection, &len);
10680     EXPECT_HR(hr, S_OK);
10681     ok(len == 2, "got %d\n", len);
10682
10683     /* try to lookup some uris */
10684     node = (void*)0xdeadbeef;
10685     hr = IXMLDOMSchemaCollection_get(collection, _bstr_("http://blah.org"), &node);
10686     EXPECT_HR(hr, E_NOTIMPL);
10687     ok(node == (void*)0xdeadbeef, "got %p\n", node);
10688
10689     /* load schema and try to add it */
10690     doc2 = create_document(&IID_IXMLDOMDocument2);
10691     hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(xsd_schema1_xml), &b);
10692     EXPECT_HR(hr, S_OK);
10693
10694     V_VT(&v) = VT_DISPATCH;
10695     V_DISPATCH(&v) = (IDispatch*)doc2;
10696     hr = IXMLDOMSchemaCollection_add(collection, _bstr_(xsd_schema1_uri), v);
10697     EXPECT_HR(hr, E_FAIL);
10698     IXMLDOMDocument2_Release(doc2);
10699
10700     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 0, &s);
10701     EXPECT_HR(hr, S_OK);
10702     ok(!lstrcmpW(s, _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(s));
10703     SysFreeString(s);
10704
10705     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 1, &s);
10706     EXPECT_HR(hr, S_OK);
10707     ok(!lstrcmpW(s, _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(s));
10708     SysFreeString(s);
10709
10710     s = (void*)0xdeadbeef;
10711     hr = IXMLDOMSchemaCollection_get_namespaceURI(collection, 2, &s);
10712     EXPECT_HR(hr, E_FAIL);
10713     ok(s == (void*)0xdeadbeef, "got %p\n", s);
10714
10715     /* enumerate */
10716     enumv = (void*)0xdeadbeef;
10717     hr = IXMLDOMSchemaCollection_get__newEnum(collection, (IUnknown**)&enumv);
10718     EXPECT_HR(hr, S_OK);
10719     ok(enumv != NULL, "got %p\n", enumv);
10720
10721     V_VT(&v) = VT_EMPTY;
10722     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
10723     EXPECT_HR(hr, S_OK);
10724     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
10725     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
10726     VariantClear(&v);
10727
10728     V_VT(&v) = VT_EMPTY;
10729     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
10730     EXPECT_HR(hr, S_OK);
10731     ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
10732     ok(!lstrcmpW(V_BSTR(&v), _bstr_("http://blahblah.org")), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
10733     VariantClear(&v);
10734
10735     V_VT(&v) = VT_NULL;
10736     hr = IEnumVARIANT_Next(enumv, 1, &v, NULL);
10737     EXPECT_HR(hr, S_FALSE);
10738     ok(V_VT(&v) == VT_EMPTY, "got %d\n", V_VT(&v));
10739
10740     IEnumVARIANT_Release(enumv);
10741     IXMLDOMSchemaCollection_Release(collection);
10742     IXMLDOMDocument2_Release(doc);
10743     free_bstrs();
10744 }
10745
10746 static DOMNodeType put_data_types[] = {
10747     NODE_TEXT,
10748     NODE_CDATA_SECTION,
10749     NODE_PROCESSING_INSTRUCTION,
10750     NODE_COMMENT,
10751     NODE_INVALID
10752 };
10753
10754 static void test_put_data(void)
10755 {
10756     static const WCHAR test_data[] = {'t','e','s','t',' ','n','o','d','e',' ','d','a','t','a',0};
10757     WCHAR buff[100], *data;
10758     IXMLDOMDocument *doc;
10759     DOMNodeType *type;
10760     IXMLDOMText *text;
10761     IXMLDOMNode *node;
10762     VARIANT v;
10763     BSTR get_data;
10764     HRESULT hr;
10765
10766     doc = create_document(&IID_IXMLDOMDocument);
10767     if (!doc) return;
10768
10769     memcpy(&buff[2], test_data, sizeof(test_data));
10770     /* just a big length */
10771     *(DWORD*)buff = 0xf0f0;
10772     data = &buff[2];
10773
10774     type = put_data_types;
10775     while (*type != NODE_INVALID)
10776     {
10777        V_VT(&v) = VT_I2;
10778        V_I2(&v) = *type;
10779
10780        hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
10781        EXPECT_HR(hr, S_OK);
10782
10783        /* put_data() is interface-specific */
10784        switch (*type)
10785        {
10786            case NODE_TEXT:
10787            {
10788               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
10789               EXPECT_HR(hr, S_OK);
10790               hr = IXMLDOMText_put_data(text, data);
10791               EXPECT_HR(hr, S_OK);
10792
10793               hr = IXMLDOMText_get_data(text, &get_data);
10794               EXPECT_HR(hr, S_OK);
10795
10796               IXMLDOMText_Release(text);
10797               break;
10798            }
10799            case NODE_CDATA_SECTION:
10800            {
10801               IXMLDOMCDATASection *cdata;
10802
10803               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
10804               EXPECT_HR(hr, S_OK);
10805               hr = IXMLDOMCDATASection_put_data(cdata, data);
10806               EXPECT_HR(hr, S_OK);
10807
10808               hr = IXMLDOMCDATASection_get_data(cdata, &get_data);
10809               EXPECT_HR(hr, S_OK);
10810
10811               IXMLDOMCDATASection_Release(cdata);
10812               break;
10813            }
10814            case NODE_PROCESSING_INSTRUCTION:
10815            {
10816               IXMLDOMProcessingInstruction *pi;
10817
10818               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)&pi);
10819               EXPECT_HR(hr, S_OK);
10820               hr = IXMLDOMProcessingInstruction_put_data(pi, data);
10821               EXPECT_HR(hr, S_OK);
10822
10823               hr = IXMLDOMProcessingInstruction_get_data(pi, &get_data);
10824               EXPECT_HR(hr, S_OK);
10825
10826               IXMLDOMProcessingInstruction_Release(pi);
10827               break;
10828            }
10829            case NODE_COMMENT:
10830            {
10831               IXMLDOMComment *comment;
10832
10833               hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
10834               EXPECT_HR(hr, S_OK);
10835               hr = IXMLDOMComment_put_data(comment, data);
10836               EXPECT_HR(hr, S_OK);
10837
10838               hr = IXMLDOMComment_get_data(comment, &get_data);
10839               EXPECT_HR(hr, S_OK);
10840
10841               IXMLDOMComment_Release(comment);
10842               break;
10843            }
10844            default:
10845               break;
10846        }
10847
10848        /* compare */
10849        ok(!lstrcmpW(data, get_data), "%d: got wrong data %s, expected %s\n", *type, wine_dbgstr_w(get_data),
10850            wine_dbgstr_w(data));
10851        SysFreeString(get_data);
10852
10853        IXMLDOMNode_Release(node);
10854        type++;
10855     }
10856
10857     /* \r\n sequence is never escaped */
10858     V_VT(&v) = VT_I2;
10859     V_I2(&v) = NODE_TEXT;
10860
10861     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("name"), NULL, &node);
10862     ok(hr == S_OK, "got 0x%08x\n", hr);
10863
10864     IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
10865
10866     hr = IXMLDOMText_put_data(text, _bstr_("\r\n"));
10867     ok(hr == S_OK, "got 0x%08x\n", hr);
10868
10869     hr = IXMLDOMText_get_data(text, &get_data);
10870     ok(hr == S_OK, "got 0x%08x\n", hr);
10871 todo_wine
10872     ok(!lstrcmpW(get_data, _bstr_("\n")), "got %s\n", wine_dbgstr_w(get_data));
10873     SysFreeString(get_data);
10874
10875     hr = IXMLDOMText_get_xml(text, &get_data);
10876     ok(hr == S_OK, "got 0x%08x\n", hr);
10877     ok(!lstrcmpW(get_data, _bstr_("\r\n")), "got %s\n", wine_dbgstr_w(get_data));
10878     SysFreeString(get_data);
10879
10880     IXMLDOMText_Release(text);
10881     IXMLDOMNode_Release(node);
10882
10883     IXMLDOMDocument_Release(doc);
10884     free_bstrs();
10885 }
10886
10887 static void test_putref_schemas(void)
10888 {
10889     IXMLDOMSchemaCollection *cache;
10890     IXMLDOMDocument2 *doc;
10891     VARIANT schema;
10892     HRESULT hr;
10893
10894     doc = create_document(&IID_IXMLDOMDocument2);
10895     if (!doc) return;
10896     cache = create_cache(&IID_IXMLDOMSchemaCollection);
10897
10898     /* set to NULL iface when no schema is set */
10899     V_VT(&schema) = VT_DISPATCH;
10900     V_DISPATCH(&schema) = NULL;
10901     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
10902     EXPECT_HR(hr, S_OK);
10903
10904     V_VT(&schema) = VT_UNKNOWN;
10905     V_UNKNOWN(&schema) = NULL;
10906     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
10907     EXPECT_HR(hr, S_OK);
10908
10909     /* set as VT_DISPATCH, reset with it */
10910     V_VT(&schema) = VT_DISPATCH;
10911     V_DISPATCH(&schema) = (IDispatch*)cache;
10912     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
10913     EXPECT_HR(hr, S_OK);
10914
10915     V_DISPATCH(&schema) = NULL;
10916     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
10917     EXPECT_HR(hr, S_OK);
10918     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
10919
10920     V_VT(&schema) = VT_DISPATCH;
10921     V_DISPATCH(&schema) = NULL;
10922     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
10923     EXPECT_HR(hr, S_OK);
10924
10925     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
10926     V_VT(&schema) = VT_I2;
10927     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
10928     EXPECT_HR(hr, S_FALSE);
10929     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
10930     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
10931
10932     /* set as VT_UNKNOWN, reset with it */
10933     V_VT(&schema) = VT_UNKNOWN;
10934     V_UNKNOWN(&schema) = (IUnknown*)cache;
10935     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
10936     EXPECT_HR(hr, S_OK);
10937
10938     V_DISPATCH(&schema) = NULL;
10939     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
10940     EXPECT_HR(hr, S_OK);
10941     ok(V_DISPATCH(&schema) == (IDispatch*)cache, "got %p\n", V_DISPATCH(&schema));
10942
10943     V_VT(&schema) = VT_UNKNOWN;
10944     V_UNKNOWN(&schema) = NULL;
10945     hr = IXMLDOMDocument2_putref_schemas(doc, schema);
10946     EXPECT_HR(hr, S_OK);
10947
10948     V_DISPATCH(&schema) = (IDispatch*)0xdeadbeef;
10949     V_VT(&schema) = VT_I2;
10950     hr = IXMLDOMDocument2_get_schemas(doc, &schema);
10951     EXPECT_HR(hr, S_FALSE);
10952     ok(V_DISPATCH(&schema) == NULL, "got %p\n", V_DISPATCH(&schema));
10953     ok(V_VT(&schema) == VT_NULL, "got %d\n", V_VT(&schema));
10954
10955     IXMLDOMSchemaCollection_Release(cache);
10956     IXMLDOMDocument2_Release(doc);
10957 }
10958
10959 static void test_namedmap_newenum(void)
10960 {
10961     IEnumVARIANT *enum1, *enum2, *enum3;
10962     IXMLDOMNamedNodeMap *map;
10963     IUnknown *unk1, *unk2;
10964     IXMLDOMDocument *doc;
10965     IXMLDOMElement *elem;
10966     IXMLDOMNode *node;
10967     VARIANT_BOOL b;
10968     HRESULT hr;
10969     VARIANT v;
10970     BSTR str;
10971
10972     doc = create_document(&IID_IXMLDOMDocument);
10973
10974     hr = IXMLDOMDocument_loadXML(doc, _bstr_(attributes_map), &b);
10975     EXPECT_HR(hr, S_OK);
10976
10977     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
10978     EXPECT_HR(hr, S_OK);
10979
10980     hr = IXMLDOMElement_get_attributes(elem, &map);
10981     EXPECT_HR(hr, S_OK);
10982     IXMLDOMElement_Release(elem);
10983
10984     enum1 = NULL;
10985     EXPECT_REF(map, 1);
10986     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum1);
10987     EXPECT_HR(hr, S_OK);
10988     ok(enum1 != NULL, "got %p\n", enum1);
10989     EXPECT_REF(map, 1);
10990     EXPECT_REF(enum1, 2);
10991
10992     enum2 = NULL;
10993     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IEnumVARIANT, (void**)&enum2);
10994     EXPECT_HR(hr, S_OK);
10995     ok(enum2 == enum1, "got %p\n", enum2);
10996
10997     IEnumVARIANT_Release(enum2);
10998
10999     EXPECT_REF(map, 1);
11000     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum2);
11001     EXPECT_HR(hr, S_OK);
11002     EXPECT_REF(map, 2);
11003     EXPECT_REF(enum2, 1);
11004     ok(enum2 != enum1, "got %p, %p\n", enum2, enum1);
11005
11006     IEnumVARIANT_Release(enum1);
11007
11008     /* enumerator created with _newEnum() doesn't share IUnknown* with main object */
11009     hr = IXMLDOMNamedNodeMap_QueryInterface(map, &IID_IUnknown, (void**)&unk1);
11010     EXPECT_HR(hr, S_OK);
11011     hr = IEnumVARIANT_QueryInterface(enum2, &IID_IUnknown, (void**)&unk2);
11012     EXPECT_HR(hr, S_OK);
11013     EXPECT_REF(map, 3);
11014     EXPECT_REF(enum2, 2);
11015     ok(unk1 != unk2, "got %p, %p\n", unk1, unk2);
11016     IUnknown_Release(unk1);
11017     IUnknown_Release(unk2);
11018
11019     hr = IXMLDOMNamedNodeMap__newEnum(map, (IUnknown**)&enum3);
11020     EXPECT_HR(hr, S_OK);
11021     ok(enum2 != enum3, "got %p, %p\n", enum2, enum3);
11022     IEnumVARIANT_Release(enum3);
11023
11024     /* iteration tests */
11025     hr = IXMLDOMNamedNodeMap_get_item(map, 0, &node);
11026     EXPECT_HR(hr, S_OK);
11027     hr = IXMLDOMNode_get_nodeName(node, &str);
11028     EXPECT_HR(hr, S_OK);
11029     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
11030     SysFreeString(str);
11031     IXMLDOMNode_Release(node);
11032
11033     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
11034     EXPECT_HR(hr, S_OK);
11035     hr = IXMLDOMNode_get_nodeName(node, &str);
11036     EXPECT_HR(hr, S_OK);
11037     ok(!lstrcmpW(str, _bstr_("attr1")), "got %s\n", wine_dbgstr_w(str));
11038     SysFreeString(str);
11039     IXMLDOMNode_Release(node);
11040
11041     V_VT(&v) = VT_EMPTY;
11042     hr = IEnumVARIANT_Next(enum2, 1, &v, NULL);
11043     EXPECT_HR(hr, S_OK);
11044     ok(V_VT(&v) == VT_DISPATCH, "got var type %d\n", V_VT(&v));
11045     hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IXMLDOMNode, (void**)&node);
11046     EXPECT_HR(hr, S_OK);
11047     hr = IXMLDOMNode_get_nodeName(node, &str);
11048     EXPECT_HR(hr, S_OK);
11049     ok(!lstrcmpW(str, _bstr_("attr1")), "got node name %s\n", wine_dbgstr_w(str));
11050     SysFreeString(str);
11051     IXMLDOMNode_Release(node);
11052     VariantClear(&v);
11053
11054     hr = IXMLDOMNamedNodeMap_nextNode(map, &node);
11055     EXPECT_HR(hr, S_OK);
11056     hr = IXMLDOMNode_get_nodeName(node, &str);
11057     EXPECT_HR(hr, S_OK);
11058     ok(!lstrcmpW(str, _bstr_("attr2")), "got %s\n", wine_dbgstr_w(str));
11059     SysFreeString(str);
11060     IXMLDOMNode_Release(node);
11061
11062     IEnumVARIANT_Release(enum2);
11063     IXMLDOMNamedNodeMap_Release(map);
11064     IXMLDOMDocument_Release(doc);
11065 }
11066
11067 static const char xsltext_xsl[] =
11068 "<?xml version=\"1.0\"?>"
11069 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
11070 "<xsl:output method=\"html\" encoding=\"us-ascii\"/>"
11071 "<xsl:template match=\"/\">"
11072 "    <xsl:choose>"
11073 "        <xsl:when test=\"testkey\">"
11074 "            <xsl:text>testdata</xsl:text>"
11075 "        </xsl:when>"
11076 "    </xsl:choose>"
11077 "</xsl:template>"
11078 "</xsl:stylesheet>";
11079
11080 static void test_xsltext(void)
11081 {
11082     IXMLDOMDocument *doc, *doc2;
11083     VARIANT_BOOL b;
11084     HRESULT hr;
11085     BSTR ret;
11086
11087     doc = create_document(&IID_IXMLDOMDocument);
11088     if (!doc) return;
11089
11090     doc2 = create_document(&IID_IXMLDOMDocument);
11091
11092     hr = IXMLDOMDocument_loadXML(doc, _bstr_(xsltext_xsl), &b);
11093     EXPECT_HR(hr, S_OK);
11094
11095     hr = IXMLDOMDocument_loadXML(doc2, _bstr_("<testkey/>"), &b);
11096     EXPECT_HR(hr, S_OK);
11097
11098     hr = IXMLDOMDocument_transformNode(doc2, (IXMLDOMNode*)doc, &ret);
11099     EXPECT_HR(hr, S_OK);
11100     ok(!lstrcmpW(ret, _bstr_("testdata")), "transform result %s\n", wine_dbgstr_w(ret));
11101     SysFreeString(ret);
11102
11103     IXMLDOMDocument_Release(doc2);
11104     IXMLDOMDocument_Release(doc);
11105     free_bstrs();
11106 }
11107
11108 START_TEST(domdoc)
11109 {
11110     IXMLDOMDocument *doc;
11111     IUnknown *unk;
11112     HRESULT hr;
11113
11114     hr = CoInitialize( NULL );
11115     ok( hr == S_OK, "failed to init com\n");
11116     if (hr != S_OK) return;
11117
11118     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc );
11119     if (hr != S_OK)
11120     {
11121         win_skip("IXMLDOMDocument is not available (0x%08x)\n", hr);
11122         return;
11123     }
11124
11125     IXMLDOMDocument_Release(doc);
11126
11127     test_domdoc();
11128     test_persiststreaminit();
11129     test_domnode();
11130     test_refs();
11131     test_create();
11132     test_getElementsByTagName();
11133     test_get_text();
11134     test_get_childNodes();
11135     test_get_firstChild();
11136     test_get_lastChild();
11137     test_removeChild();
11138     test_replaceChild();
11139     test_removeNamedItem();
11140     test_IXMLDOMDocument2();
11141     test_whitespace();
11142     test_XPath();
11143     test_XSLPattern();
11144     test_cloneNode();
11145     test_xmlTypes();
11146     test_save();
11147     test_testTransforms();
11148     test_namespaces_basic();
11149     test_namespaces_change();
11150     test_FormattingXML();
11151     test_nodeTypedValue();
11152     test_TransformWithLoadingLocalFile();
11153     test_put_nodeValue();
11154     test_IObjectSafety();
11155     test_splitText();
11156     test_getQualifiedItem();
11157     test_removeQualifiedItem();
11158     test_get_ownerDocument();
11159     test_setAttributeNode();
11160     test_put_dataType();
11161     test_createNode();
11162     test_get_prefix();
11163     test_default_properties();
11164     test_selectSingleNode();
11165     test_events();
11166     test_createProcessingInstruction();
11167     test_put_nodeTypedValue();
11168     test_get_xml();
11169     test_insertBefore();
11170     test_appendChild();
11171     test_get_doctype();
11172     test_get_tagName();
11173     test_get_dataType();
11174     test_get_nodeTypeString();
11175     test_get_attributes();
11176     test_selection();
11177     test_load();
11178     test_dispex();
11179     test_parseerror();
11180     test_getAttributeNode();
11181     test_supporterrorinfo();
11182     test_nodeValue();
11183     test_get_namespaces();
11184     test_put_data();
11185     test_putref_schemas();
11186     test_namedmap_newenum();
11187
11188     test_xsltemplate();
11189     test_xsltext();
11190
11191     hr = CoCreateInstance(&CLSID_MXNamespaceManager40, NULL, CLSCTX_INPROC_SERVER,
11192         &IID_IMXNamespaceManager, (void**)&unk);
11193     if (hr == S_OK)
11194     {
11195         test_mxnamespacemanager();
11196         test_mxnamespacemanager_override();
11197
11198         IUnknown_Release(unk);
11199     }
11200     else
11201         win_skip("MXNamespaceManager is not available\n");
11202
11203     CoUninitialize();
11204 }