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 Adam Martinson for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23
  24 #define COBJMACROS
  25
  26 #include "windows.h"
  27 #include "ole2.h"
  28 #include "objsafe.h"
  29 #include "xmldom.h"
  30 #include "msxml2.h"
  31 #include "msxml2did.h"
  32 #include "dispex.h"
  33 #include <stdio.h>
  34 #include <assert.h>
  35
  36 #include "wine/test.h"
  37
  38 #include "initguid.h"
  39
  40 DEFINE_GUID(IID_IObjectSafety, 0xcb5bdc81, 0x93c1, 0x11cf, 0x8f,0x20, 0x00,0x80,0x5f,0x2c,0xd0,0x64);
  41
  42 static int g_unexpectedcall, g_expectedcall;
  43
  44 typedef struct
  45 {
  46     const struct IDispatchVtbl *lpVtbl;
  47     LONG ref;
  48 } dispevent;
  49
  50 static inline dispevent *impl_from_IDispatch( IDispatch *iface )
  51 {
  52     return (dispevent *)((char*)iface - FIELD_OFFSET(dispevent, lpVtbl));
  53 }
  54
  55 static HRESULT WINAPI dispevent_QueryInterface(IDispatch *iface, REFIID riid, void **ppvObject)
  56 {
  57     *ppvObject = NULL;
  58
  59     if ( IsEqualGUID( riid, &IID_IDispatch) ||
  60          IsEqualGUID( riid, &IID_IUnknown) )
  61     {
  62         *ppvObject = iface;
  63     }
  64     else
  65         return E_NOINTERFACE;
  66
  67     IDispatch_AddRef( iface );
  68
  69     return S_OK;
  70 }
  71
  72 static ULONG WINAPI dispevent_AddRef(IDispatch *iface)
  73 {
  74     dispevent *This = impl_from_IDispatch( iface );
  75     return InterlockedIncrement( &This->ref );
  76 }
  77
  78 static ULONG WINAPI dispevent_Release(IDispatch *iface)
  79 {
  80     dispevent *This = impl_from_IDispatch( iface );
  81     ULONG ref = InterlockedDecrement( &This->ref );
  82
  83     if (ref == 0)
  84         HeapFree(GetProcessHeap(), 0, This);
  85
  86     return ref;
  87 }
  88
  89 static HRESULT WINAPI dispevent_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
  90 {
  91     g_unexpectedcall++;
  92     *pctinfo = 0;
  93     return S_OK;
  94 }
  95
  96 static HRESULT WINAPI dispevent_GetTypeInfo(IDispatch *iface, UINT iTInfo,
  97         LCID lcid, ITypeInfo **ppTInfo)
  98 {
  99     g_unexpectedcall++;
 100     return S_OK;
 101 }
 102
 103 static HRESULT WINAPI dispevent_GetIDsOfNames(IDispatch *iface, REFIID riid,
 104         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 105 {
 106     g_unexpectedcall++;
 107     return S_OK;
 108 }
 109
 110 static HRESULT WINAPI dispevent_Invoke(IDispatch *iface, DISPID member, REFIID riid,
 111         LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result,
 112         EXCEPINFO *excepInfo, UINT *argErr)
 113 {
 114     ok(member == 0, "expected 0 member, got %d\n", member);
 115     ok(lcid == LOCALE_SYSTEM_DEFAULT, "expected LOCALE_SYSTEM_DEFAULT, got lcid %x\n", lcid);
 116     ok(flags == DISPATCH_METHOD, "expected DISPATCH_METHOD, got %d\n", flags);
 117
 118     ok(params->cArgs == 0, "got %d\n", params->cArgs);
 119     ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
 120     ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
 121     ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
 122
 123     ok(result == NULL, "got %p\n", result);
 124     ok(excepInfo == NULL, "got %p\n", excepInfo);
 125     ok(argErr == NULL, "got %p\n", argErr);
 126
 127     g_expectedcall++;
 128     return E_FAIL;
 129 }
 130
 131 static const IDispatchVtbl dispeventVtbl =
 132 {
 133     dispevent_QueryInterface,
 134     dispevent_AddRef,
 135     dispevent_Release,
 136     dispevent_GetTypeInfoCount,
 137     dispevent_GetTypeInfo,
 138     dispevent_GetIDsOfNames,
 139     dispevent_Invoke
 140 };
 141
 142 static IDispatch* create_dispevent(void)
 143 {
 144     dispevent *event = HeapAlloc(GetProcessHeap(), 0, sizeof(*event));
 145
 146     event->lpVtbl = &dispeventVtbl;
 147     event->ref = 1;
 148
 149     return (IDispatch*)&event->lpVtbl;
 150 }
 151
 152
 153 static const WCHAR szEmpty[] = { 0 };
 154 static const WCHAR szIncomplete[] = {
 155     '<','?','x','m','l',' ',
 156     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
 157 };
 158 static const WCHAR szComplete1[] = {
 159     '<','?','x','m','l',' ',
 160     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 161     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
 162 };
 163 static const WCHAR szComplete2[] = {
 164     '<','?','x','m','l',' ',
 165     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 166     '<','o','>','<','/','o','>','\n',0
 167 };
 168 static const WCHAR szComplete3[] = {
 169     '<','?','x','m','l',' ',
 170     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 171     '<','a','>','<','/','a','>','\n',0
 172 };
 173 static const WCHAR szComplete4[] = {
 174     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
 175     '<','l','c',' ','d','l','=','\'','s','t','r','1','\'','>','\n',
 176         '<','b','s',' ','v','r','=','\'','s','t','r','2','\'',' ','s','z','=','\'','1','2','3','4','\'','>',
 177             'f','n','1','.','t','x','t','\n',
 178         '<','/','b','s','>','\n',
 179         '<','p','r',' ','i','d','=','\'','s','t','r','3','\'',' ','v','r','=','\'','1','.','2','.','3','\'',' ',
 180                     'p','n','=','\'','w','i','n','e',' ','2','0','0','5','0','8','0','4','\'','>','\n',
 181             'f','n','2','.','t','x','t','\n',
 182         '<','/','p','r','>','\n',
 183         '<','e','m','p','t','y','>','<','/','e','m','p','t','y','>','\n',
 184         '<','f','o','>','\n',
 185             '<','b','a','>','\n',
 186                 'f','1','\n',
 187             '<','/','b','a','>','\n',
 188         '<','/','f','o','>','\n',
 189     '<','/','l','c','>','\n',0
 190 };
 191 static const WCHAR szComplete5[] = {
 192     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
 193     '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','"',
 194     ' ','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','"','>',
 195         '<','S',':','s','c','o','p','e','>',
 196             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
 197         '<','/','S',':','s','c','o','p','e','>',
 198         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
 199             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
 200             'c','o','m','p','u','t','e','r',
 201         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
 202     '<','/','S',':','s','e','a','r','c','h','>',0
 203 };
 204
 205 static const WCHAR szComplete6[] = {
 206     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'',' ',
 207     'e','n','c','o','d','i','n','g','=','\'','W','i','n','d','o','w','s','-','1','2','5','2','\'','?','>','\n',
 208     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
 209 };
 210
 211 static const CHAR szNonUnicodeXML[] =
 212 "<?xml version='1.0' encoding='Windows-1252'?>\n"
 213 "<open></open>\n";
 214
 215 static const CHAR szExampleXML[] =
 216 "<?xml version='1.0' encoding='utf-8'?>\n"
 217 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 218 "    <elem>\n"
 219 "        <a>A1 field</a>\n"
 220 "        <b>B1 field</b>\n"
 221 "        <c>C1 field</c>\n"
 222 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 223 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
 224 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
 225 "            </html>\n"
 226 "            <html xml:space='preserve' xmlns='http://www.w3.org/1999/xhtml'>\n"
 227 "                This is <strong>a</strong> <i>description</i> with preserved whitespace. <bar:x/>\n"
 228 "            </html>\n"
 229 "        </description>\n"
 230 "    </elem>\n"
 231 "\n"
 232 "    <elem>\n"
 233 "        <a>A2 field</a>\n"
 234 "        <b>B2 field</b>\n"
 235 "        <c type=\"old\">C2 field</c>\n"
 236 "    </elem>\n"
 237 "\n"
 238 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 239 "        <a>A3 field</a>\n"
 240 "        <b>B3 field</b>\n"
 241 "        <c>C3 field</c>\n"
 242 "    </elem>\n"
 243 "\n"
 244 "    <elem>\n"
 245 "        <a>A4 field</a>\n"
 246 "        <b>B4 field</b>\n"
 247 "        <foo:c>C4 field</foo:c>\n"
 248 "    </elem>\n"
 249 "</root>\n";
 250
 251 static const CHAR szNodeTypesXML[] =
 252 "<?xml version='1.0'?>"
 253 "<!-- comment node 0 -->"
 254 "<root id='0' depth='0'>"
 255 "   <!-- comment node 1 -->"
 256 "   text node 0"
 257 "   <x id='1' depth='1'>"
 258 "       <?foo value='PI for x'?>"
 259 "       <!-- comment node 2 -->"
 260 "       text node 1"
 261 "       <a id='3' depth='2'/>"
 262 "       <b id='4' depth='2'/>"
 263 "       <c id='5' depth='2'/>"
 264 "   </x>"
 265 "   <y id='2' depth='1'>"
 266 "       <?bar value='PI for y'?>"
 267 "       <!-- comment node 3 -->"
 268 "       text node 2"
 269 "       <a id='6' depth='2'/>"
 270 "       <b id='7' depth='2'/>"
 271 "       <c id='8' depth='2'/>"
 272 "   </y>"
 273 "</root>";
 274
 275 static const CHAR szTransformXML[] =
 276 "<?xml version=\"1.0\"?>\n"
 277 "<greeting>\n"
 278 "Hello World\n"
 279 "</greeting>";
 280
 281 static  const CHAR szTransformSSXML[] =
 282 "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
 283 "   <xsl:output method=\"html\"/>\n"
 284 "   <xsl:template match=\"/\">\n"
 285 "       <xsl:apply-templates select=\"greeting\"/>\n"
 286 "   </xsl:template>\n"
 287 "   <xsl:template match=\"greeting\">\n"
 288 "       <html>\n"
 289 "           <body>\n"
 290 "               <h1>\n"
 291 "                   <xsl:value-of select=\".\"/>\n"
 292 "               </h1>\n"
 293 "           </body>\n"
 294 "       </html>\n"
 295 "   </xsl:template>\n"
 296 "</xsl:stylesheet>";
 297
 298 static  const CHAR szTransformOutput[] =
 299 "<html><body><h1>"
 300 "Hello World"
 301 "</h1></body></html>";
 302
 303 static const CHAR szTypeValueXML[] =
 304 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
 305 "<root xmlns:dt=\"urn:schemas-microsoft-com:datatypes\">\n"
 306 "   <string>Wine</string>\n"
 307 "   <string2 dt:dt=\"string\">String</string2>\n"
 308 "   <number dt:dt=\"number\">12.44</number>\n"
 309 "   <number2 dt:dt=\"NUMbEr\">-3.71e3</number2>\n"
 310 "   <int dt:dt=\"int\">-13</int>\n"
 311 "   <fixed dt:dt=\"fixed.14.4\">7322.9371</fixed>\n"
 312 "   <bool dt:dt=\"boolean\">1</bool>\n"
 313 "   <datetime dt:dt=\"datetime\">2009-11-18T03:21:33.12</datetime>\n"
 314 "   <datetimetz dt:dt=\"datetime.tz\">2003-07-11T11:13:57+03:00</datetimetz>\n"
 315 "   <date dt:dt=\"date\">3721-11-01</date>\n"
 316 "   <time dt:dt=\"time\">13:57:12.31321</time>\n"
 317 "   <timetz dt:dt=\"time.tz\">23:21:01.13+03:21</timetz>\n"
 318 "   <i1 dt:dt=\"i1\">-13</i1>\n"
 319 "   <i2 dt:dt=\"i2\">31915</i2>\n"
 320 "   <i4 dt:dt=\"i4\">-312232</i4>\n"
 321 "   <ui1 dt:dt=\"ui1\">123</ui1>\n"
 322 "   <ui2 dt:dt=\"ui2\">48282</ui2>\n"
 323 "   <ui4 dt:dt=\"ui4\">949281</ui4>\n"
 324 "   <r4 dt:dt=\"r4\">213124.0</r4>\n"
 325 "   <r8 dt:dt=\"r8\">0.412</r8>\n"
 326 "   <float dt:dt=\"float\">41221.421</float>\n"
 327 "   <uuid dt:dt=\"uuid\">333C7BC4-460F-11D0-BC04-0080C7055a83</uuid>\n"
 328 "   <binhex dt:dt=\"bin.hex\">fffca012003c</binhex>\n"
 329 "   <binbase64 dt:dt=\"bin.base64\">YmFzZTY0IHRlc3Q=</binbase64>\n"
 330 "</root>";
 331
 332 static const CHAR szBasicTransformSSXMLPart1[] =
 333 "<?xml version=\"1.0\"?>"
 334 "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" >"
 335 "<xsl:output method=\"html\"/>\n"
 336 "<xsl:template match=\"/\">"
 337 "<HTML><BODY><TABLE>"
 338 "        <xsl:apply-templates select='document(\"";
 339
 340 static const CHAR szBasicTransformSSXMLPart2[] =
 341 "\")/bottle/wine'>"
 342 "           <xsl:sort select=\"cost\"/><xsl:sort select=\"name\"/>"
 343 "        </xsl:apply-templates>"
 344 "</TABLE></BODY></HTML>"
 345 "</xsl:template>"
 346 "<xsl:template match=\"bottle\">"
 347 "   <TR><xsl:apply-templates select=\"name\" /><xsl:apply-templates select=\"cost\" /></TR>"
 348 "</xsl:template>"
 349 "<xsl:template match=\"name\">"
 350 "   <TD><xsl:apply-templates /></TD>"
 351 "</xsl:template>"
 352 "<xsl:template match=\"cost\">"
 353 "   <TD><xsl:apply-templates /></TD>"
 354 "</xsl:template>"
 355 "</xsl:stylesheet>";
 356
 357 static const CHAR szBasicTransformXML[] =
 358 "<?xml version=\"1.0\"?><bottle><wine><name>Wine</name><cost>$25.00</cost></wine></bottle>";
 359
 360 static const CHAR szBasicTransformOutput[] =
 361 "<HTML><BODY><TABLE><TD>Wine</TD><TD>$25.00</TD></TABLE></BODY></HTML>";
 362
 363 #define SZ_EMAIL_DTD \
 364 "<!DOCTYPE email ["\
 365 "   <!ELEMENT email         (recipients,from,reply-to?,subject,body,attachment*)>"\
 366 "       <!ATTLIST email attachments IDREFS #REQUIRED>"\
 367 "       <!ATTLIST email sent (yes|no) \"no\">"\
 368 "   <!ELEMENT recipients    (to+,cc*)>"\
 369 "   <!ELEMENT to            (#PCDATA)>"\
 370 "       <!ATTLIST to name CDATA #IMPLIED>"\
 371 "   <!ELEMENT cc            (#PCDATA)>"\
 372 "       <!ATTLIST cc name CDATA #IMPLIED>"\
 373 "   <!ELEMENT from          (#PCDATA)>"\
 374 "       <!ATTLIST from name CDATA #IMPLIED>"\
 375 "   <!ELEMENT reply-to      (#PCDATA)>"\
 376 "       <!ATTLIST reply-to name CDATA #IMPLIED>"\
 377 "   <!ELEMENT subject       ANY>"\
 378 "   <!ELEMENT body          ANY>"\
 379 "       <!ATTLIST body enc CDATA #FIXED \"UTF-8\">"\
 380 "   <!ELEMENT attachment    (#PCDATA)>"\
 381 "       <!ATTLIST attachment id ID #REQUIRED>"\
 382 "]>"
 383
 384 static const CHAR szEmailXML[] =
 385 "<?xml version=\"1.0\"?>"
 386 SZ_EMAIL_DTD
 387 "<email attachments=\"patch1\">"
 388 "   <recipients>"
 389 "       <to>wine-patches@winehq.org</to>"
 390 "   </recipients>"
 391 "   <from name=\"Anonymous\">user@localhost</from>"
 392 "   <subject>msxml3/tests: DTD validation (try 87)</subject>"
 393 "   <body>"
 394 "       It no longer causes spontaneous combustion..."
 395 "   </body>"
 396 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 397 "</email>";
 398
 399 static const CHAR szEmailXML_0D[] =
 400 "<?xml version=\"1.0\"?>"
 401 SZ_EMAIL_DTD
 402 "<email attachments=\"patch1\">"
 403 "   <recipients>"
 404 "       <to>wine-patches@winehq.org</to>"
 405 "   </recipients>"
 406 "   <from name=\"Anonymous\">user@localhost</from>"
 407 "   <subject>msxml3/tests: DTD validation (try 88)</subject>"
 408 "   <body>"
 409 "       <undecl />"
 410 "       XML_ELEMENT_UNDECLARED 0xC00CE00D"
 411 "   </body>"
 412 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 413 "</email>";
 414
 415 static const CHAR szEmailXML_0E[] =
 416 "<?xml version=\"1.0\"?>"
 417 SZ_EMAIL_DTD
 418 "<email attachments=\"patch1\">"
 419 "   <recipients>"
 420 "       <to>wine-patches@winehq.org</to>"
 421 "   </recipients>"
 422 "   <from name=\"Anonymous\">user@localhost</from>"
 423 "   <subject>msxml3/tests: DTD validation (try 89)</subject>"
 424 "   <body>"
 425 "       XML_ELEMENT_ID_NOT_FOUND 0xC00CE00E"
 426 "   </body>"
 427 "   <attachment id=\"patch\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 428 "</email>";
 429
 430 static const CHAR szEmailXML_11[] =
 431 "<?xml version=\"1.0\"?>"
 432 SZ_EMAIL_DTD
 433 "<email attachments=\"patch1\">"
 434 "   <recipients>"
 435 "   </recipients>"
 436 "   <from name=\"Anonymous\">user@localhost</from>"
 437 "   <subject>msxml3/tests: DTD validation (try 90)</subject>"
 438 "   <body>"
 439 "       XML_EMPTY_NOT_ALLOWED 0xC00CE011"
 440 "   </body>"
 441 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 442 "</email>";
 443
 444 static const CHAR szEmailXML_13[] =
 445 "<?xml version=\"1.0\"?>"
 446 SZ_EMAIL_DTD
 447 "<msg attachments=\"patch1\">"
 448 "   <recipients>"
 449 "       <to>wine-patches@winehq.org</to>"
 450 "   </recipients>"
 451 "   <from name=\"Anonymous\">user@localhost</from>"
 452 "   <subject>msxml3/tests: DTD validation (try 91)</subject>"
 453 "   <body>"
 454 "       XML_ROOT_NAME_MISMATCH 0xC00CE013"
 455 "   </body>"
 456 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 457 "</msg>";
 458
 459 static const CHAR szEmailXML_14[] =
 460 "<?xml version=\"1.0\"?>"
 461 SZ_EMAIL_DTD
 462 "<email attachments=\"patch1\">"
 463 "   <to>wine-patches@winehq.org</to>"
 464 "   <from name=\"Anonymous\">user@localhost</from>"
 465 "   <subject>msxml3/tests: DTD validation (try 92)</subject>"
 466 "   <body>"
 467 "       XML_INVALID_CONTENT 0xC00CE014"
 468 "   </body>"
 469 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 470 "</email>";
 471
 472 static const CHAR szEmailXML_15[] =
 473 "<?xml version=\"1.0\"?>"
 474 SZ_EMAIL_DTD
 475 "<email attachments=\"patch1\" ip=\"127.0.0.1\">"
 476 "   <recipients>"
 477 "       <to>wine-patches@winehq.org</to>"
 478 "   </recipients>"
 479 "   <from name=\"Anonymous\">user@localhost</from>"
 480 "   <subject>msxml3/tests: DTD validation (try 93)</subject>"
 481 "   <body>"
 482 "       XML_ATTRIBUTE_NOT_DEFINED 0xC00CE015"
 483 "   </body>"
 484 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 485 "</email>";
 486
 487 static const CHAR szEmailXML_16[] =
 488 "<?xml version=\"1.0\"?>"
 489 SZ_EMAIL_DTD
 490 "<email attachments=\"patch1\">"
 491 "   <recipients>"
 492 "       <to>wine-patches@winehq.org</to>"
 493 "   </recipients>"
 494 "   <from name=\"Anonymous\">user@localhost</from>"
 495 "   <subject>msxml3/tests: DTD validation (try 94)</subject>"
 496 "   <body enc=\"ASCII\">"
 497 "       XML_ATTRIBUTE_FIXED 0xC00CE016"
 498 "   </body>"
 499 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 500 "</email>";
 501
 502 static const CHAR szEmailXML_17[] =
 503 "<?xml version=\"1.0\"?>"
 504 SZ_EMAIL_DTD
 505 "<email attachments=\"patch1\" sent=\"true\">"
 506 "   <recipients>"
 507 "       <to>wine-patches@winehq.org</to>"
 508 "   </recipients>"
 509 "   <from name=\"Anonymous\">user@localhost</from>"
 510 "   <subject>msxml3/tests: DTD validation (try 95)</subject>"
 511 "   <body>"
 512 "       XML_ATTRIBUTE_VALUE 0xC00CE017"
 513 "   </body>"
 514 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 515 "</email>";
 516
 517 static const CHAR szEmailXML_18[] =
 518 "<?xml version=\"1.0\"?>"
 519 SZ_EMAIL_DTD
 520 "<email attachments=\"patch1\">"
 521 "   oops"
 522 "   <recipients>"
 523 "       <to>wine-patches@winehq.org</to>"
 524 "   </recipients>"
 525 "   <from name=\"Anonymous\">user@localhost</from>"
 526 "   <subject>msxml3/tests: DTD validation (try 96)</subject>"
 527 "   <body>"
 528 "       XML_ILLEGAL_TEXT 0xC00CE018"
 529 "   </body>"
 530 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 531 "</email>";
 532
 533 static const CHAR szEmailXML_20[] =
 534 "<?xml version=\"1.0\"?>"
 535 SZ_EMAIL_DTD
 536 "<email>"
 537 "   <recipients>"
 538 "       <to>wine-patches@winehq.org</to>"
 539 "   </recipients>"
 540 "   <from name=\"Anonymous\">user@localhost</from>"
 541 "   <subject>msxml3/tests: DTD validation (try 97)</subject>"
 542 "   <body>"
 543 "       XML_REQUIRED_ATTRIBUTE_MISSING 0xC00CE020"
 544 "   </body>"
 545 "   <attachment id=\"patch1\">0001-msxml3-tests-DTD-validation.patch</attachment>"
 546 "</email>";
 547
 548 static const CHAR szDatatypeXDR[] =
 549 "<Schema xmlns='urn:schemas-microsoft-com:xml-data'\n"
 550 "        xmlns:dt='urn:schemas-microsoft-com:datatypes'>\n"
 551 "   <ElementType name='base64Data' content='textOnly' dt:type='bin.base64'/>\n"
 552 "   <ElementType name='hexData' content='textOnly' dt:type='bin.hex'/>\n"
 553 "   <ElementType name='boolData' content='textOnly' dt:type='boolean'/>\n"
 554 "   <ElementType name='charData' content='textOnly' dt:type='char'/>\n"
 555 "   <ElementType name='dateData' content='textOnly' dt:type='date'/>\n"
 556 "   <ElementType name='dateTimeData' content='textOnly' dt:type='dateTime'/>\n"
 557 "   <ElementType name='dateTimeTzData' content='textOnly' dt:type='dateTime.tz'/>\n"
 558 "   <ElementType name='entityData' content='textOnly' dt:type='entity'/>\n"
 559 "   <ElementType name='entitiesData' content='textOnly' dt:type='entities'/>\n"
 560 "   <ElementType name='fixedData' content='textOnly' dt:type='fixed.14.4'/>\n"
 561 "   <ElementType name='floatData' content='textOnly' dt:type='float'/>\n"
 562 "   <ElementType name='i1Data' content='textOnly' dt:type='i1'/>\n"
 563 "   <ElementType name='i2Data' content='textOnly' dt:type='i2'/>\n"
 564 "   <ElementType name='i4Data' content='textOnly' dt:type='i4'/>\n"
 565 "   <ElementType name='i8Data' content='textOnly' dt:type='i8'/>\n"
 566 "   <ElementType name='intData' content='textOnly' dt:type='int'/>\n"
 567 "   <ElementType name='nmtokData' content='textOnly' dt:type='nmtoken'/>\n"
 568 "   <ElementType name='nmtoksData' content='textOnly' dt:type='nmtokens'/>\n"
 569 "   <ElementType name='numData' content='textOnly' dt:type='number'/>\n"
 570 "   <ElementType name='r4Data' content='textOnly' dt:type='r4'/>\n"
 571 "   <ElementType name='r8Data' content='textOnly' dt:type='r8'/>\n"
 572 "   <ElementType name='stringData' content='textOnly' dt:type='string'/>\n"
 573 "   <ElementType name='timeData' content='textOnly' dt:type='time'/>\n"
 574 "   <ElementType name='timeTzData' content='textOnly' dt:type='time.tz'/>\n"
 575 "   <ElementType name='u1Data' content='textOnly' dt:type='ui1'/>\n"
 576 "   <ElementType name='u2Data' content='textOnly' dt:type='ui2'/>\n"
 577 "   <ElementType name='u4Data' content='textOnly' dt:type='ui4'/>\n"
 578 "   <ElementType name='u8Data' content='textOnly' dt:type='ui8'/>\n"
 579 "   <ElementType name='uriData' content='textOnly' dt:type='uri'/>\n"
 580 "   <ElementType name='uuidData' content='textOnly' dt:type='uuid'/>\n"
 581 "\n"
 582 "   <ElementType name='Name' content='textOnly' dt:type='nmtoken'/>\n"
 583 "   <ElementType name='Value' content='eltOnly' order='many'>\n"
 584 "       <element type='base64Data'/>\n"
 585 "       <element type='hexData'/>\n"
 586 "       <element type='boolData'/>\n"
 587 "       <element type='charData'/>\n"
 588 "       <element type='dateData'/>\n"
 589 "       <element type='dateTimeData'/>\n"
 590 "       <element type='dateTimeTzData'/>\n"
 591 "       <element type='entityData'/>\n"
 592 "       <element type='entitiesData'/>\n"
 593 "       <element type='fixedData'/>\n"
 594 "       <element type='floatData'/>\n"
 595 "       <element type='i1Data'/>\n"
 596 "       <element type='i2Data'/>\n"
 597 "       <element type='i4Data'/>\n"
 598 "       <element type='i8Data'/>\n"
 599 "       <element type='intData'/>\n"
 600 "       <element type='nmtokData'/>\n"
 601 "       <element type='nmtoksData'/>\n"
 602 "       <element type='numData'/>\n"
 603 "       <element type='r4Data'/>\n"
 604 "       <element type='r8Data'/>\n"
 605 "       <element type='stringData'/>\n"
 606 "       <element type='timeData'/>\n"
 607 "       <element type='timeTzData'/>\n"
 608 "       <element type='u1Data'/>\n"
 609 "       <element type='u2Data'/>\n"
 610 "       <element type='u4Data'/>\n"
 611 "       <element type='u8Data'/>\n"
 612 "       <element type='uriData'/>\n"
 613 "       <element type='uuidData'/>\n"
 614 "   </ElementType>\n"
 615 "   <ElementType name='Property' content='eltOnly' order='seq'>\n"
 616 "       <element type='Name'/>\n"
 617 "       <element type='Value'/>\n"
 618 "   </ElementType>\n"
 619 "   <ElementType name='Properties' content='eltOnly'>\n"
 620 "       <element type='Property' minOccurs='0' maxOccurs='*'/>\n"
 621 "   </ElementType>\n"
 622 "</Schema>";
 623
 624 static const CHAR szDatatypeXML[] =
 625 "<?xml version='1.0'?>\n"
 626 "<Properties xmlns='urn:x-schema:datatype-test-xdr'>\n"
 627 "   <Property>\n"
 628 "       <Name>testBase64</Name>\n"
 629 "       <Value>\n"
 630 "           <base64Data>+HugeNumber+</base64Data>\n"
 631 "       </Value>\n"
 632 "   </Property>\n"
 633 "   <Property>\n"
 634 "       <Name>testHex</Name>\n"
 635 "       <Value>\n"
 636 "           <hexData>deadbeef</hexData>\n"
 637 "       </Value>\n"
 638 "   </Property>\n"
 639 "   <Property>\n"
 640 "       <Name>testBool</Name>\n"
 641 "       <Value>\n"
 642 "           <boolData>1</boolData>\n"
 643 "       </Value>\n"
 644 "   </Property>\n"
 645 "   <Property>\n"
 646 "       <Name>testChar</Name>\n"
 647 "       <Value>\n"
 648 "           <charData>u</charData>\n"
 649 "       </Value>\n"
 650 "   </Property>\n"
 651 "   <Property>\n"
 652 "       <Name>testDate</Name>\n"
 653 "       <Value>\n"
 654 "           <dateData>1998-02-01</dateData>\n"
 655 "       </Value>\n"
 656 "   </Property>\n"
 657 "   <Property>\n"
 658 "       <Name>testDateTime</Name>\n"
 659 "       <Value>\n"
 660 "           <dateTimeData>1998-02-01T12:34:56</dateTimeData>\n"
 661 "       </Value>\n"
 662 "   </Property>\n"
 663 "   <Property>\n"
 664 "       <Name>testDateTimeTz</Name>\n"
 665 "       <Value>\n"
 666 "           <dateTimeTzData>1998-02-01T12:34:56-06:00</dateTimeTzData>\n"
 667 "       </Value>\n"
 668 "   </Property>\n"
 669 "   <Property>\n"
 670 "       <Name>testFixed</Name>\n"
 671 "       <Value>\n"
 672 "           <fixedData>3.1416</fixedData>\n"
 673 "       </Value>\n"
 674 "   </Property>\n"
 675 "   <Property>\n"
 676 "       <Name>testFloat</Name>\n"
 677 "       <Value>\n"
 678 "           <floatData>3.14159</floatData>\n"
 679 "       </Value>\n"
 680 "   </Property>\n"
 681 "   <Property>\n"
 682 "       <Name>testI1</Name>\n"
 683 "       <Value>\n"
 684 "           <i1Data>42</i1Data>\n"
 685 "       </Value>\n"
 686 "   </Property>\n"
 687 "   <Property>\n"
 688 "       <Name>testI2</Name>\n"
 689 "       <Value>\n"
 690 "           <i2Data>420</i2Data>\n"
 691 "       </Value>\n"
 692 "   </Property>\n"
 693 "   <Property>\n"
 694 "       <Name>testI4</Name>\n"
 695 "       <Value>\n"
 696 "           <i4Data>-420000000</i4Data>\n"
 697 "       </Value>\n"
 698 "   </Property>\n"
 699 "   <Property>\n"
 700 "       <Name>testI8</Name>\n"
 701 "       <Value>\n"
 702 "           <i8Data>-4200000000</i8Data>\n"
 703 "       </Value>\n"
 704 "   </Property>\n"
 705 "   <Property>\n"
 706 "       <Name>testInt</Name>\n"
 707 "       <Value>\n"
 708 "           <intData>42</intData>\n"
 709 "       </Value>\n"
 710 "   </Property>\n"
 711 "   <Property>\n"
 712 "       <Name>testNmtoken</Name>\n"
 713 "       <Value>\n"
 714 "           <nmtokData>tok1</nmtokData>\n"
 715 "       </Value>\n"
 716 "   </Property>\n"
 717 "   <Property>\n"
 718 "       <Name>testNmtokens</Name>\n"
 719 "       <Value>\n"
 720 "           <nmtoksData>tok1 tok2 tok3</nmtoksData>\n"
 721 "       </Value>\n"
 722 "   </Property>\n"
 723 "   <Property>\n"
 724 "       <Name>testNumber</Name>\n"
 725 "       <Value>\n"
 726 "           <numData>3.14159</numData>\n"
 727 "       </Value>\n"
 728 "   </Property>\n"
 729 "   <Property>\n"
 730 "       <Name>testR4</Name>\n"
 731 "       <Value>\n"
 732 "           <r4Data>3.14159265</r4Data>\n"
 733 "       </Value>\n"
 734 "   </Property>\n"
 735 "   <Property>\n"
 736 "       <Name>testR8</Name>\n"
 737 "       <Value>\n"
 738 "           <r8Data>3.14159265358979323846</r8Data>\n"
 739 "       </Value>\n"
 740 "   </Property>\n"
 741 "   <Property>\n"
 742 "       <Name>testString</Name>\n"
 743 "       <Value>\n"
 744 "           <stringData>foo bar</stringData>\n"
 745 "       </Value>\n"
 746 "   </Property>\n"
 747 "   <Property>\n"
 748 "       <Name>testTime</Name>\n"
 749 "       <Value>\n"
 750 "           <timeData>12:34:56</timeData>\n"
 751 "       </Value>\n"
 752 "   </Property>\n"
 753 "   <Property>\n"
 754 "       <Name>testTimeTz</Name>\n"
 755 "       <Value>\n"
 756 "           <timeTzData>12:34:56-06:00</timeTzData>\n"
 757 "       </Value>\n"
 758 "   </Property>\n"
 759 "   <Property>\n"
 760 "       <Name>testU1</Name>\n"
 761 "       <Value>\n"
 762 "           <u1Data>255</u1Data>\n"
 763 "       </Value>\n"
 764 "   </Property>\n"
 765 "   <Property>\n"
 766 "       <Name>testU2</Name>\n"
 767 "       <Value>\n"
 768 "           <u2Data>65535</u2Data>\n"
 769 "       </Value>\n"
 770 "   </Property>\n"
 771 "   <Property>\n"
 772 "       <Name>testU4</Name>\n"
 773 "       <Value>\n"
 774 "           <u4Data>4294967295</u4Data>\n"
 775 "       </Value>\n"
 776 "   </Property>\n"
 777 "   <Property>\n"
 778 "       <Name>testU8</Name>\n"
 779 "       <Value>\n"
 780 "           <u8Data>18446744073709551615</u8Data>\n"
 781 "       </Value>\n"
 782 "   </Property>\n"
 783 "   <Property>\n"
 784 "       <Name>testURI</Name>\n"
 785 "       <Value>\n"
 786 "           <uriData>urn:schemas-microsoft-com:datatypes</uriData>\n"
 787 "       </Value>\n"
 788 "   </Property>\n"
 789 "   <Property>\n"
 790 "       <Name>testUUID</Name>\n"
 791 "       <Value>\n"
 792 "           <uuidData>2933BF81-7B36-11D2-B20E-00C04F983E60</uuidData>\n"
 793 "       </Value>\n"
 794 "   </Property>\n"
 795 "</Properties>";
 796
 797 static const CHAR szOpenSeqXDR[] =
 798 "<Schema xmlns='urn:schemas-microsoft-com:xml-data'>\n"
 799 "   <ElementType name='w' content='empty' model='closed'/>\n"
 800 "   <ElementType name='x' content='empty' model='closed'/>\n"
 801 "   <ElementType name='y' content='empty' model='closed'/>\n"
 802 "   <ElementType name='z' content='empty' model='closed'/>\n"
 803 "   <ElementType name='test' content='eltOnly' model='open' order='seq'>\n"
 804 "       <element type='x'/>\n"
 805 "       <group order='seq'>\n"
 806 "           <element type='x'/>\n"
 807 "           <element type='y'/>\n"
 808 "           <element type='z'/>\n"
 809 "       </group>\n"
 810 "       <element type='z'/>\n"
 811 "   </ElementType>\n"
 812 "</Schema>";
 813
 814 static const CHAR szOpenSeqXML1[] = "<test><x/><x/><y/><z/><z/></test>";
 815 static const CHAR szOpenSeqXML2[] = "<test><x/><x/><y/><z/><z/><w/></test>";
 816 static const CHAR szOpenSeqXML3[] = "<test><w/><x/><x/><y/><z/><z/></test>";
 817 static const CHAR szOpenSeqXML4[] = "<test><x/><x/><y/><z/><z/><v/></test>";
 818
 819 static const WCHAR szNonExistentFile[] = {
 820     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
 821 };
 822 static const WCHAR szNonExistentAttribute[] = {
 823     'n','o','n','E','x','i','s','i','t','i','n','g','A','t','t','r','i','b','u','t','e',0
 824 };
 825 static const WCHAR szDocument[] = {
 826     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
 827 };
 828
 829 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
 830 static WCHAR szdl[] = { 'd','l',0 };
 831 static const WCHAR szvr[] = { 'v','r',0 };
 832 static const WCHAR szlc[] = { 'l','c',0 };
 833 static WCHAR szbs[] = { 'b','s',0 };
 834 static const WCHAR szstr1[] = { 's','t','r','1',0 };
 835 static const WCHAR szstr2[] = { 's','t','r','2',0 };
 836 static const WCHAR szstar[] = { '*',0 };
 837 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
 838
 839 static WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
 840 static WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
 841 static WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
 842
 843 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
 844 static WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
 845 static WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
 846 static WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 847                                 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
 848 static WCHAR szElementXML4[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 849                                 '&','a','m','p',';','x',' ',0x2103,'<','/','E','l','e','T','e','s','t','>',0 };
 850
 851 static WCHAR szAttribute[] = {'A','t','t','r',0 };
 852 static WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
 853
 854 static WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
 855                           ' ','n','o','t',' ','r','i','g','h','t','!', 0};
 856 static WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
 857                              'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
 858                              '!',']',']','>',0};
 859 static WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
 860 static WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
 861
 862 static WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
 863 static WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
 864 static WCHAR szStrangeChars[] = {'&','x',' ',0x2103, 0};
 865
 866 #define expect_bstr_eq_and_free(bstr, expect) { \
 867     BSTR bstrExp = alloc_str_from_narrow(expect); \
 868     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
 869     SysFreeString(bstr); \
 870     SysFreeString(bstrExp); \
 871 }
 872
 873 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
 874
 875 #define ole_check(expr) { \
 876     HRESULT r = expr; \
 877     ok(r == S_OK, #expr " returned %x\n", r); \
 878 }
 879
 880 #define ole_expect(expr, expect) { \
 881     HRESULT r = expr; \
 882     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
 883 }
 884
 885 #define double_eq(x, y) ok((x)-(y)<=1e-14*(x) && (x)-(y)>=-1e-14*(x), "expected %.16g, got %.16g\n", x, y)
 886
 887 static void* _create_object(const GUID *clsid, const char *name, const IID *iid, int line)
 888 {
 889     void *obj = NULL;
 890     HRESULT hr;
 891
 892     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
 893     if (hr != S_OK)
 894         win_skip_(__FILE__,line)("failed to create %s instance: 0x%08x\n", name, hr);
 895
 896     return obj;
 897 }
 898
 899 #define _create(cls) cls, #cls
 900
 901 #define create_document(iid) _create_object(&_create(CLSID_DOMDocument), iid, __LINE__)
 902
 903 #define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
 904
 905 #define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
 906
 907 #define create_cache_version(v, iid) _create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)
 908
 909 static BSTR alloc_str_from_narrow(const char *str)
 910 {
 911     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 912     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
 913     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 914     return ret;
 915 }
 916
 917 static BSTR alloced_bstrs[256];
 918 static int alloced_bstrs_count;
 919
 920 static BSTR _bstr_(const char *str)
 921 {
 922     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
 923     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
 924     return alloced_bstrs[alloced_bstrs_count++];
 925 }
 926
 927 static void free_bstrs(void)
 928 {
 929     int i;
 930     for (i = 0; i < alloced_bstrs_count; i++)
 931         SysFreeString(alloced_bstrs[i]);
 932     alloced_bstrs_count = 0;
 933 }
 934
 935 static VARIANT _variantbstr_(const char *str)
 936 {
 937     VARIANT v;
 938     V_VT(&v) = VT_BSTR;
 939     V_BSTR(&v) = _bstr_(str);
 940     return v;
 941 }
 942
 943 static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
 944 {
 945     for (;;)
 946     {
 947         while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
 948         while (*sRight == '\r' || *sRight == '\n') sRight++;
 949         if (*sLeft != *sRight) return FALSE;
 950         if (!*sLeft) return TRUE;
 951         sLeft++;
 952         sRight++;
 953     }
 954 }
 955
 956 static void get_str_for_type(DOMNodeType type, char *buf)
 957 {
 958     switch (type)
 959     {
 960         case NODE_ATTRIBUTE:
 961             strcpy(buf, "A");
 962             break;
 963         case NODE_ELEMENT:
 964             strcpy(buf, "E");
 965             break;
 966         case NODE_DOCUMENT:
 967             strcpy(buf, "D");
 968             break;
 969         case NODE_TEXT:
 970             strcpy(buf, "T");
 971             break;
 972         case NODE_COMMENT:
 973             strcpy(buf, "C");
 974             break;
 975         case NODE_PROCESSING_INSTRUCTION:
 976             strcpy(buf, "P");
 977             break;
 978         default:
 979             wsprintfA(buf, "[%d]", type);
 980     }
 981 }
 982
 983 #define test_disp(u) _test_disp(__LINE__,u)
 984 static void _test_disp(unsigned line, IUnknown *unk)
 985 {
 986     DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
 987     IDispatchEx *dispex;
 988     DWORD dwProps = 0;
 989     BSTR sName;
 990     UINT ticnt;
 991     IUnknown *pUnk;
 992     HRESULT hres;
 993
 994     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
 995     ok_(__FILE__,line) (hres == S_OK, "Could not get IDispatch: %08x\n", hres);
 996     if(FAILED(hres))
 997         return;
 998
 999     ticnt = 0xdeadbeef;
1000     hres = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
1001     ok_(__FILE__,line) (hres == S_OK, "GetTypeInfoCount failed: %08x\n", hres);
1002     ok_(__FILE__,line) (ticnt == 1, "ticnt=%u\n", ticnt);
1003
1004     sName = SysAllocString( szstar );
1005     hres = IDispatchEx_DeleteMemberByName(dispex, sName, fdexNameCaseSensitive);
1006     ok(hres == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", hres);
1007     SysFreeString( sName );
1008
1009     hres = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
1010     ok(hres == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", hres);
1011
1012     hres = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &dwProps);
1013     ok(hres == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", hres);
1014     ok(dwProps == 0, "expected 0 got %d\n", dwProps);
1015
1016     hres = IDispatchEx_GetMemberName(dispex, dispid, &sName);
1017     ok(hres == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", hres);
1018     if(SUCCEEDED(hres))
1019         SysFreeString(sName);
1020
1021     hres = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
1022     ok(hres == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", hres);
1023
1024     hres = IDispatchEx_GetNameSpaceParent(dispex, &pUnk);
1025     ok(hres == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", hres);
1026     if(hres == S_OK && pUnk)
1027         IUnknown_Release(pUnk);
1028
1029     IDispatchEx_Release(dispex);
1030 }
1031
1032 static int get_node_position(IXMLDOMNode *node)
1033 {
1034     HRESULT r;
1035     int pos = 0;
1036
1037     IXMLDOMNode_AddRef(node);
1038     do
1039     {
1040         IXMLDOMNode *new_node;
1041
1042         pos++;
1043         r = IXMLDOMNode_get_previousSibling(node, &new_node);
1044         ok(SUCCEEDED(r), "get_previousSibling failed\n");
1045         IXMLDOMNode_Release(node);
1046         node = new_node;
1047     } while (r == S_OK);
1048     return pos;
1049 }
1050
1051 static void node_to_string(IXMLDOMNode *node, char *buf)
1052 {
1053     HRESULT r = S_OK;
1054     DOMNodeType type;
1055
1056     if (node == NULL)
1057     {
1058         lstrcpyA(buf, "(null)");
1059         return;
1060     }
1061
1062     IXMLDOMNode_AddRef(node);
1063     while (r == S_OK)
1064     {
1065         IXMLDOMNode *new_node;
1066
1067         ole_check(IXMLDOMNode_get_nodeType(node, &type));
1068         get_str_for_type(type, buf);
1069         buf+=strlen(buf);
1070
1071         if (type == NODE_ATTRIBUTE)
1072         {
1073             BSTR bstr;
1074             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
1075             *(buf++) = '\'';
1076             wsprintfA(buf, "%ws", bstr);
1077             buf += strlen(buf);
1078             *(buf++) = '\'';
1079             SysFreeString(bstr);
1080
1081             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
1082         }
1083         else
1084         {
1085             r = IXMLDOMNode_get_parentNode(node, &new_node);
1086             wsprintf(buf, "%d", get_node_position(node));
1087             buf += strlen(buf);
1088         }
1089
1090         ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
1091         IXMLDOMNode_Release(node);
1092         node = new_node;
1093         if (r == S_OK)
1094             *(buf++) = '.';
1095     }
1096
1097     *buf = 0;
1098 }
1099
1100 static char *list_to_string(IXMLDOMNodeList *list)
1101 {
1102     static char buf[4096];
1103     char *pos = buf;
1104     LONG len = 0;
1105     int i;
1106
1107     if (list == NULL)
1108     {
1109         lstrcpyA(buf, "(null)");
1110         return buf;
1111     }
1112     ole_check(IXMLDOMNodeList_get_length(list, &len));
1113     for (i = 0; i < len; i++)
1114     {
1115         IXMLDOMNode *node;
1116         if (i > 0)
1117             *(pos++) = ' ';
1118         ole_check(IXMLDOMNodeList_nextNode(list, &node));
1119         node_to_string(node, pos);
1120         pos += strlen(pos);
1121         IXMLDOMNode_Release(node);
1122     }
1123     *pos = 0;
1124     return buf;
1125 }
1126
1127 #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); }
1128 #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); }
1129
1130 static void test_domdoc( void )
1131 {
1132     HRESULT r;
1133     IXMLDOMDocument *doc;
1134     IXMLDOMParseError *error;
1135     IXMLDOMElement *element = NULL;
1136     IXMLDOMNode *node;
1137     IXMLDOMText *nodetext = NULL;
1138     IXMLDOMComment *node_comment = NULL;
1139     IXMLDOMAttribute *node_attr = NULL;
1140     IXMLDOMNode *nodeChild = NULL;
1141     IXMLDOMProcessingInstruction *nodePI = NULL;
1142     ISupportErrorInfo *support_error = NULL;
1143     VARIANT_BOOL b;
1144     VARIANT var;
1145     BSTR str;
1146     LONG code;
1147     LONG nLength = 0;
1148     WCHAR buff[100];
1149
1150     doc = create_document(&IID_IXMLDOMDocument);
1151     if (!doc) return;
1152
1153     test_disp((IUnknown*)doc);
1154
1155 if (0)
1156 {
1157     /* crashes on native */
1158     r = IXMLDOMDocument_loadXML( doc, (BSTR)0x1, NULL );
1159 }
1160
1161     /* try some stupid things */
1162     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1163     ok( r == S_FALSE, "loadXML succeeded\n");
1164
1165     b = VARIANT_TRUE;
1166     r = IXMLDOMDocument_loadXML( doc, NULL, &b );
1167     ok( r == S_FALSE, "loadXML succeeded\n");
1168     ok( b == VARIANT_FALSE, "failed to load XML string\n");
1169
1170     /* try to load a document from a nonexistent file */
1171     b = VARIANT_TRUE;
1172     str = SysAllocString( szNonExistentFile );
1173     VariantInit(&var);
1174     V_VT(&var) = VT_BSTR;
1175     V_BSTR(&var) = str;
1176
1177     r = IXMLDOMDocument_load( doc, var, &b);
1178     ok( r == S_FALSE, "loadXML succeeded\n");
1179     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1180     SysFreeString( str );
1181
1182     /* try load an empty document */
1183     b = VARIANT_TRUE;
1184     str = SysAllocString( szEmpty );
1185     r = IXMLDOMDocument_loadXML( doc, str, &b );
1186     ok( r == S_FALSE, "loadXML succeeded\n");
1187     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1188     SysFreeString( str );
1189
1190     r = IXMLDOMDocument_get_async( doc, &b );
1191     ok( r == S_OK, "get_async failed (%08x)\n", r);
1192     ok( b == VARIANT_TRUE, "Wrong default value\n");
1193
1194     /* check that there's no document element */
1195     element = NULL;
1196     r = IXMLDOMDocument_get_documentElement( doc, &element );
1197     ok( r == S_FALSE, "should be no document element\n");
1198
1199     /* try finding a node */
1200     node = NULL;
1201     str = SysAllocString( szstr1 );
1202     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
1203     ok( r == S_FALSE, "ret %08x\n", r );
1204     SysFreeString( str );
1205
1206     b = VARIANT_TRUE;
1207     str = SysAllocString( szIncomplete );
1208     r = IXMLDOMDocument_loadXML( doc, str, &b );
1209     ok( r == S_FALSE, "loadXML succeeded\n");
1210     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1211     SysFreeString( str );
1212
1213     /* check that there's no document element */
1214     element = (IXMLDOMElement*)1;
1215     r = IXMLDOMDocument_get_documentElement( doc, &element );
1216     ok( r == S_FALSE, "should be no document element\n");
1217     ok( element == NULL, "Element should be NULL\n");
1218
1219     /* test for BSTR handling, pass broken BSTR */
1220     memcpy(&buff[2], szComplete1, sizeof(szComplete1));
1221     /* just a big length */
1222     *(DWORD*)buff = 0xf0f0;
1223     b = VARIANT_FALSE;
1224     r = IXMLDOMDocument_loadXML( doc, &buff[2], &b );
1225     ok( r == S_OK, "loadXML failed\n");
1226     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1227
1228     /* loadXML ignores the encoding attribute and always expects Unicode */
1229     b = VARIANT_FALSE;
1230     str = SysAllocString( szComplete6 );
1231     r = IXMLDOMDocument_loadXML( doc, str, &b );
1232     ok( r == S_OK, "loadXML failed\n");
1233     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1234     SysFreeString( str );
1235
1236     /* try a BSTR containing a Windows-1252 document */
1237     b = VARIANT_TRUE;
1238     str = SysAllocStringByteLen( szNonUnicodeXML, sizeof(szNonUnicodeXML) - 1 );
1239     r = IXMLDOMDocument_loadXML( doc, str, &b );
1240     ok( r == S_FALSE, "loadXML succeeded\n");
1241     ok( b == VARIANT_FALSE, "succeeded in loading XML string\n");
1242     SysFreeString( str );
1243
1244     /* try to load something valid */
1245     b = VARIANT_FALSE;
1246     str = SysAllocString( szComplete1 );
1247     r = IXMLDOMDocument_loadXML( doc, str, &b );
1248     ok( r == S_OK, "loadXML failed\n");
1249     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1250     SysFreeString( str );
1251
1252     /* check if nodename is correct */
1253     r = IXMLDOMDocument_get_nodeName( doc, NULL );
1254     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1255
1256     str = (BSTR)0xdeadbeef;
1257     r = IXMLDOMDocument_get_baseName( doc, &str );
1258     ok ( r == S_FALSE, "got 0x%08x\n", r);
1259     ok (str == NULL, "got %p\n", str);
1260
1261     /* content doesn't matter here */
1262     str = NULL;
1263     r = IXMLDOMDocument_get_nodeName( doc, &str );
1264     ok ( r == S_OK, "get_nodeName wrong code\n");
1265     ok ( str != NULL, "str is null\n");
1266     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
1267     SysFreeString( str );
1268
1269     /* test put_text */
1270     r = IXMLDOMDocument_put_text( doc, _bstr_("Should Fail") );
1271     ok( r == E_FAIL, "ret %08x\n", r );
1272
1273     /* check that there's a document element */
1274     element = NULL;
1275     r = IXMLDOMDocument_get_documentElement( doc, &element );
1276     ok( r == S_OK, "should be a document element\n");
1277     if( element )
1278     {
1279         IObjectIdentity *ident;
1280         BSTR tag = NULL;
1281
1282         test_disp((IUnknown*)element);
1283
1284         r = IXMLDOMElement_QueryInterface( element, &IID_IObjectIdentity, (void**)&ident );
1285         ok( r == E_NOINTERFACE, "ret %08x\n", r);
1286
1287         r = IXMLDOMElement_get_tagName( element, NULL );
1288         ok( r == E_INVALIDARG, "ret %08x\n", r);
1289
1290         /* check if the tag is correct */
1291         r = IXMLDOMElement_get_tagName( element, &tag );
1292         ok( r == S_OK, "couldn't get tag name\n");
1293         ok( tag != NULL, "tag was null\n");
1294         ok( !lstrcmpW( tag, szOpen ), "incorrect tag name\n");
1295         SysFreeString( tag );
1296
1297         /* figure out what happens if we try to reload the document */
1298         str = SysAllocString( szComplete2 );
1299         r = IXMLDOMDocument_loadXML( doc, str, &b );
1300         ok( r == S_OK, "loadXML failed\n");
1301         ok( b == VARIANT_TRUE, "failed to load XML string\n");
1302         SysFreeString( str );
1303
1304         /* check if the tag is still correct */
1305         tag = NULL;
1306         r = IXMLDOMElement_get_tagName( element, &tag );
1307         ok( r == S_OK, "couldn't get tag name\n");
1308         ok( tag != NULL, "tag was null\n");
1309         ok( !lstrcmpW( tag, szOpen ), "incorrect tag name\n");
1310         SysFreeString( tag );
1311
1312         IXMLDOMElement_Release( element );
1313         element = NULL;
1314     }
1315
1316     /* as soon as we call loadXML again, the document element will disappear */
1317     b = 2;
1318     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
1319     ok( r == S_FALSE, "loadXML failed\n");
1320     ok( b == 2, "variant modified\n");
1321     r = IXMLDOMDocument_get_documentElement( doc, &element );
1322     ok( r == S_FALSE, "should be no document element\n");
1323
1324     /* try to load something else simple and valid */
1325     b = VARIANT_FALSE;
1326     str = SysAllocString( szComplete3 );
1327     r = IXMLDOMDocument_loadXML( doc, str, &b );
1328     ok( r == S_OK, "loadXML failed\n");
1329     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1330     SysFreeString( str );
1331
1332     /* try something a little more complicated */
1333     b = FALSE;
1334     str = SysAllocString( szComplete4 );
1335     r = IXMLDOMDocument_loadXML( doc, str, &b );
1336     ok( r == S_OK, "loadXML failed\n");
1337     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1338     SysFreeString( str );
1339
1340     r = IXMLDOMDocument_get_parseError( doc, &error );
1341     ok( r == S_OK, "returns %08x\n", r );
1342
1343     r = IXMLDOMParseError_get_errorCode( error, &code );
1344     ok( r == S_FALSE, "returns %08x\n", r );
1345     ok( code == 0, "code %d\n", code );
1346     IXMLDOMParseError_Release( error );
1347
1348     /* test createTextNode */
1349     r = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &nodetext);
1350     ok( r == S_OK, "returns %08x\n", r );
1351     IXMLDOMText_Release(nodetext);
1352
1353     str = SysAllocString( szOpen );
1354     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
1355     ok( r == E_INVALIDARG, "returns %08x\n", r );
1356     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
1357     ok( r == S_OK, "returns %08x\n", r );
1358     SysFreeString( str );
1359     if(nodetext)
1360     {
1361         IXMLDOMNamedNodeMap *pAttribs;
1362
1363         r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (void**)&element);
1364         ok(r == E_NOINTERFACE, "ret %08x\n", r );
1365
1366         /* Text Last Child Checks */
1367         r = IXMLDOMText_get_lastChild(nodetext, NULL);
1368         ok(r == E_INVALIDARG, "ret %08x\n", r );
1369
1370         nodeChild = (IXMLDOMNode*)0x1;
1371         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
1372         ok(r == S_FALSE, "ret %08x\n", r );
1373         ok(nodeChild == NULL, "nodeChild not NULL\n");
1374
1375         /* test get_attributes */
1376         r = IXMLDOMText_get_attributes( nodetext, NULL );
1377         ok( r == E_INVALIDARG, "get_attributes returned wrong code\n");
1378
1379         pAttribs = (IXMLDOMNamedNodeMap*)0x1;
1380         r = IXMLDOMText_get_attributes( nodetext, &pAttribs);
1381         ok(r == S_FALSE, "ret %08x\n", r );
1382         ok( pAttribs == NULL, "pAttribs not NULL\n");
1383
1384         /* test get_dataType */
1385         r = IXMLDOMText_get_dataType(nodetext, &var);
1386         ok(r == S_FALSE, "ret %08x\n", r );
1387         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
1388         VariantClear(&var);
1389
1390         /* test length property */
1391         r = IXMLDOMText_get_length(nodetext, NULL);
1392         ok(r == E_INVALIDARG, "ret %08x\n", r );
1393
1394         r = IXMLDOMText_get_length(nodetext, &nLength);
1395         ok(r == S_OK, "ret %08x\n", r );
1396         ok(nLength == 4, "expected 4 got %d\n", nLength);
1397
1398         /* test nodeTypeString */
1399         r = IXMLDOMText_get_nodeTypeString(nodetext, &str);
1400         ok(r == S_OK, "ret %08x\n", r );
1401         ok( !lstrcmpW( str, _bstr_("text") ), "incorrect nodeTypeString string\n");
1402         SysFreeString(str);
1403
1404         /* put data Tests */
1405         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
1406         ok(r == S_OK, "ret %08x\n", r );
1407
1408         /* get data Tests */
1409         r = IXMLDOMText_get_data(nodetext, &str);
1410         ok(r == S_OK, "ret %08x\n", r );
1411         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
1412         SysFreeString(str);
1413
1414         /* Confirm XML text is good */
1415         r = IXMLDOMText_get_xml(nodetext, &str);
1416         ok(r == S_OK, "ret %08x\n", r );
1417         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
1418         SysFreeString(str);
1419
1420         /* Confirm we get the put_data Text back */
1421         r = IXMLDOMText_get_text(nodetext, &str);
1422         ok(r == S_OK, "ret %08x\n", r );
1423         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
1424         SysFreeString(str);
1425
1426         /* test substringData */
1427         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
1428         ok(r == E_INVALIDARG, "ret %08x\n", r );
1429
1430         /* test substringData - Invalid offset */
1431         str = (BSTR)&szElement;
1432         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
1433         ok(r == E_INVALIDARG, "ret %08x\n", r );
1434         ok( str == NULL, "incorrect string\n");
1435
1436         /* test substringData - Invalid offset */
1437         str = (BSTR)&szElement;
1438         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
1439         ok(r == S_FALSE, "ret %08x\n", r );
1440         ok( str == NULL, "incorrect string\n");
1441
1442         /* test substringData - Invalid size */
1443         str = (BSTR)&szElement;
1444         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
1445         ok(r == E_INVALIDARG, "ret %08x\n", r );
1446         ok( str == NULL, "incorrect string\n");
1447
1448         /* test substringData - Invalid size */
1449         str = (BSTR)&szElement;
1450         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
1451         ok(r == S_FALSE, "ret %08x\n", r );
1452         ok( str == NULL, "incorrect string\n");
1453
1454         /* test substringData - Start of string */
1455         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
1456         ok(r == S_OK, "ret %08x\n", r );
1457         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
1458         SysFreeString(str);
1459
1460         /* test substringData - Middle of string */
1461         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
1462         ok(r == S_OK, "ret %08x\n", r );
1463         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
1464         SysFreeString(str);
1465
1466         /* test substringData - End of string */
1467         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
1468         ok(r == S_OK, "ret %08x\n", r );
1469         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
1470         SysFreeString(str);
1471
1472         /* test appendData */
1473         r = IXMLDOMText_appendData(nodetext, NULL);
1474         ok(r == S_OK, "ret %08x\n", r );
1475
1476         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
1477         ok(r == S_OK, "ret %08x\n", r );
1478
1479         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
1480         ok(r == S_OK, "ret %08x\n", r );
1481
1482         r = IXMLDOMText_get_text(nodetext, &str);
1483         ok(r == S_OK, "ret %08x\n", r );
1484         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1485         SysFreeString(str);
1486
1487         /* test insertData */
1488         str = SysAllocStringLen(NULL, 0);
1489         r = IXMLDOMText_insertData(nodetext, -1, str);
1490         ok(r == S_OK, "ret %08x\n", r );
1491
1492         r = IXMLDOMText_insertData(nodetext, -1, NULL);
1493         ok(r == S_OK, "ret %08x\n", r );
1494
1495         r = IXMLDOMText_insertData(nodetext, 1000, str);
1496         ok(r == S_OK, "ret %08x\n", r );
1497
1498         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
1499         ok(r == S_OK, "ret %08x\n", r );
1500
1501         r = IXMLDOMText_insertData(nodetext, 0, NULL);
1502         ok(r == S_OK, "ret %08x\n", r );
1503
1504         r = IXMLDOMText_insertData(nodetext, 0, str);
1505         ok(r == S_OK, "ret %08x\n", r );
1506         SysFreeString(str);
1507
1508         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
1509         ok(r == E_INVALIDARG, "ret %08x\n", r );
1510
1511         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
1512         ok(r == E_INVALIDARG, "ret %08x\n", r );
1513
1514         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
1515         ok(r == S_OK, "ret %08x\n", r );
1516
1517         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
1518         ok(r == S_OK, "ret %08x\n", r );
1519
1520         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
1521         ok(r == S_OK, "ret %08x\n", r );
1522
1523         r = IXMLDOMText_get_text(nodetext, &str);
1524         ok(r == S_OK, "ret %08x\n", r );
1525         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1526         SysFreeString(str);
1527
1528         /* delete data */
1529         /* invalid arguments */
1530         r = IXMLDOMText_deleteData(nodetext, -1, 1);
1531         ok(r == E_INVALIDARG, "ret %08x\n", r );
1532
1533         r = IXMLDOMText_deleteData(nodetext, 0, 0);
1534         ok(r == S_OK, "ret %08x\n", r );
1535
1536         r = IXMLDOMText_deleteData(nodetext, 0, -1);
1537         ok(r == E_INVALIDARG, "ret %08x\n", r );
1538
1539         r = IXMLDOMText_get_length(nodetext, &nLength);
1540         ok(r == S_OK, "ret %08x\n", r );
1541         ok(nLength == 43, "expected 43 got %d\n", nLength);
1542
1543         r = IXMLDOMText_deleteData(nodetext, nLength, 1);
1544         ok(r == S_OK, "ret %08x\n", r );
1545
1546         r = IXMLDOMText_deleteData(nodetext, nLength+1, 1);
1547         ok(r == E_INVALIDARG, "ret %08x\n", r );
1548
1549         /* delete from start */
1550         r = IXMLDOMText_deleteData(nodetext, 0, 5);
1551         ok(r == S_OK, "ret %08x\n", r );
1552
1553         r = IXMLDOMText_get_length(nodetext, &nLength);
1554         ok(r == S_OK, "ret %08x\n", r );
1555         ok(nLength == 38, "expected 38 got %d\n", nLength);
1556
1557         r = IXMLDOMText_get_text(nodetext, &str);
1558         ok(r == S_OK, "ret %08x\n", r );
1559         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1560         SysFreeString(str);
1561
1562         /* delete from end */
1563         r = IXMLDOMText_deleteData(nodetext, 35, 3);
1564         ok(r == S_OK, "ret %08x\n", r );
1565
1566         r = IXMLDOMText_get_length(nodetext, &nLength);
1567         ok(r == S_OK, "ret %08x\n", r );
1568         ok(nLength == 35, "expected 35 got %d\n", nLength);
1569
1570         r = IXMLDOMText_get_text(nodetext, &str);
1571         ok(r == S_OK, "ret %08x\n", r );
1572         ok( !lstrcmpW( str, _bstr_("This &is a Middle; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1573         SysFreeString(str);
1574
1575         /* delete from inside */
1576         r = IXMLDOMText_deleteData(nodetext, 1, 33);
1577         ok(r == S_OK, "ret %08x\n", r );
1578
1579         r = IXMLDOMText_get_length(nodetext, &nLength);
1580         ok(r == S_OK, "ret %08x\n", r );
1581         ok(nLength == 2, "expected 2 got %d\n", nLength);
1582
1583         r = IXMLDOMText_get_text(nodetext, &str);
1584         ok(r == S_OK, "ret %08x\n", r );
1585         ok( !lstrcmpW( str, _bstr_("") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1586         SysFreeString(str);
1587
1588         /* delete whole data ... */
1589         r = IXMLDOMText_get_length(nodetext, &nLength);
1590         ok(r == S_OK, "ret %08x\n", r );
1591
1592         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1593         ok(r == S_OK, "ret %08x\n", r );
1594         /* ... and try again with empty string */
1595         r = IXMLDOMText_deleteData(nodetext, 0, nLength);
1596         ok(r == S_OK, "ret %08x\n", r );
1597
1598         /* test put_data */
1599         V_VT(&var) = VT_BSTR;
1600         V_BSTR(&var) = SysAllocString(szstr1);
1601         r = IXMLDOMText_put_nodeValue(nodetext, var);
1602         ok(r == S_OK, "ret %08x\n", r );
1603         VariantClear(&var);
1604
1605         r = IXMLDOMText_get_text(nodetext, &str);
1606         ok(r == S_OK, "ret %08x\n", r );
1607         ok( !lstrcmpW( str, szstr1 ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1608         SysFreeString(str);
1609
1610         /* test put_data */
1611         V_VT(&var) = VT_I4;
1612         V_I4(&var) = 99;
1613         r = IXMLDOMText_put_nodeValue(nodetext, var);
1614         ok(r == S_OK, "ret %08x\n", r );
1615         VariantClear(&var);
1616
1617         r = IXMLDOMText_get_text(nodetext, &str);
1618         ok(r == S_OK, "ret %08x\n", r );
1619         ok( !lstrcmpW( str, _bstr_("99") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1620         SysFreeString(str);
1621
1622         /* ::replaceData() */
1623         V_VT(&var) = VT_BSTR;
1624         V_BSTR(&var) = SysAllocString(szstr1);
1625         r = IXMLDOMText_put_nodeValue(nodetext, var);
1626         ok(r == S_OK, "ret %08x\n", r );
1627         VariantClear(&var);
1628
1629         r = IXMLDOMText_replaceData(nodetext, 6, 0, NULL);
1630         ok(r == E_INVALIDARG, "ret %08x\n", r );
1631         r = IXMLDOMText_get_text(nodetext, &str);
1632         ok(r == S_OK, "ret %08x\n", r );
1633         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1634         SysFreeString(str);
1635
1636         r = IXMLDOMText_replaceData(nodetext, 0, 0, NULL);
1637         ok(r == S_OK, "ret %08x\n", r );
1638         r = IXMLDOMText_get_text(nodetext, &str);
1639         ok(r == S_OK, "ret %08x\n", r );
1640         ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1641         SysFreeString(str);
1642
1643         /* NULL pointer means delete */
1644         r = IXMLDOMText_replaceData(nodetext, 0, 1, NULL);
1645         ok(r == S_OK, "ret %08x\n", r );
1646         r = IXMLDOMText_get_text(nodetext, &str);
1647         ok(r == S_OK, "ret %08x\n", r );
1648         ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1649         SysFreeString(str);
1650
1651         /* empty string means delete */
1652         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_(""));
1653         ok(r == S_OK, "ret %08x\n", r );
1654         r = IXMLDOMText_get_text(nodetext, &str);
1655         ok(r == S_OK, "ret %08x\n", r );
1656         ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1657         SysFreeString(str);
1658
1659         /* zero count means insert */
1660         r = IXMLDOMText_replaceData(nodetext, 0, 0, _bstr_("a"));
1661         ok(r == S_OK, "ret %08x\n", r );
1662         r = IXMLDOMText_get_text(nodetext, &str);
1663         ok(r == S_OK, "ret %08x\n", r );
1664         ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1665         SysFreeString(str);
1666
1667         r = IXMLDOMText_replaceData(nodetext, 0, 2, NULL);
1668         ok(r == S_OK, "ret %08x\n", r );
1669
1670         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("m"));
1671         ok(r == S_OK, "ret %08x\n", r );
1672         r = IXMLDOMText_get_text(nodetext, &str);
1673         ok(r == S_OK, "ret %08x\n", r );
1674         ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1675         SysFreeString(str);
1676
1677         /* nonempty string, count greater than its length */
1678         r = IXMLDOMText_replaceData(nodetext, 0, 2, _bstr_("a1.2"));
1679         ok(r == S_OK, "ret %08x\n", r );
1680         r = IXMLDOMText_get_text(nodetext, &str);
1681         ok(r == S_OK, "ret %08x\n", r );
1682         ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1683         SysFreeString(str);
1684
1685         /* nonempty string, count less than its length */
1686         r = IXMLDOMText_replaceData(nodetext, 0, 1, _bstr_("wine"));
1687         ok(r == S_OK, "ret %08x\n", r );
1688         r = IXMLDOMText_get_text(nodetext, &str);
1689         ok(r == S_OK, "ret %08x\n", r );
1690         ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
1691         SysFreeString(str);
1692
1693         IXMLDOMText_Release( nodetext );
1694     }
1695
1696     /* test Create Comment */
1697     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
1698     ok( r == E_INVALIDARG, "returns %08x\n", r );
1699     node_comment = (IXMLDOMComment*)0x1;
1700
1701     /* empty comment */
1702     r = IXMLDOMDocument_createComment(doc, _bstr_(""), &node_comment);
1703     ok( r == S_OK, "returns %08x\n", r );
1704     str = (BSTR)0x1;
1705     r = IXMLDOMComment_get_data(node_comment, &str);
1706     ok( r == S_OK, "returns %08x\n", r );
1707     ok( str && SysStringLen(str) == 0, "expected empty string data\n");
1708     IXMLDOMComment_Release(node_comment);
1709     SysFreeString(str);
1710
1711     r = IXMLDOMDocument_createComment(doc, NULL, &node_comment);
1712     ok( r == S_OK, "returns %08x\n", r );
1713     str = (BSTR)0x1;
1714     r = IXMLDOMComment_get_data(node_comment, &str);
1715     ok( r == S_OK, "returns %08x\n", r );
1716     ok( str && (SysStringLen(str) == 0), "expected empty string data\n");
1717     IXMLDOMComment_Release(node_comment);
1718     SysFreeString(str);
1719
1720     str = SysAllocString(szComment);
1721     r = IXMLDOMDocument_createComment(doc, str, &node_comment);
1722     SysFreeString(str);
1723     ok( r == S_OK, "returns %08x\n", r );
1724     if(node_comment)
1725     {
1726         /* Last Child Checks */
1727         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
1728         ok(r == E_INVALIDARG, "ret %08x\n", r );
1729
1730         nodeChild = (IXMLDOMNode*)0x1;
1731         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
1732         ok(r == S_FALSE, "ret %08x\n", r );
1733         ok(nodeChild == NULL, "pLastChild not NULL\n");
1734
1735         /* baseName */
1736         str = (BSTR)0xdeadbeef;
1737         IXMLDOMComment_get_baseName(node_comment, &str);
1738         ok(r == S_FALSE, "ret %08x\n", r );
1739         ok(str == NULL, "Expected NULL\n");
1740
1741         IXMLDOMComment_Release( node_comment );
1742     }
1743
1744     /* test Create Attribute */
1745     str = SysAllocString(szAttribute);
1746     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
1747     ok( r == E_INVALIDARG, "returns %08x\n", r );
1748     r = IXMLDOMDocument_createAttribute(doc, str, &node_attr);
1749     ok( r == S_OK, "returns %08x\n", r );
1750     IXMLDOMText_Release( node_attr);
1751     SysFreeString(str);
1752
1753     /* test Processing Instruction */
1754     str = SysAllocStringLen(NULL, 0);
1755     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
1756     ok( r == E_INVALIDARG, "returns %08x\n", r );
1757     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
1758     ok( r == E_FAIL, "returns %08x\n", r );
1759     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
1760     ok( r == E_FAIL, "returns %08x\n", r );
1761     SysFreeString(str);
1762
1763     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
1764     ok( r == S_OK, "returns %08x\n", r );
1765     if(nodePI)
1766     {
1767         /* Last Child Checks */
1768         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
1769         ok(r == E_INVALIDARG, "ret %08x\n", r );
1770
1771         nodeChild = (IXMLDOMNode*)0x1;
1772         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
1773         ok(r == S_FALSE, "ret %08x\n", r );
1774         ok(nodeChild == NULL, "nodeChild not NULL\n");
1775
1776         r = IXMLDOMProcessingInstruction_get_dataType(nodePI, &var);
1777         ok(r == S_FALSE, "ret %08x\n", r );
1778         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
1779         VariantClear(&var);
1780
1781         /* test nodeName */
1782         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
1783         ok(r == S_OK, "ret %08x\n", r );
1784         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1785         SysFreeString(str);
1786
1787         /* test baseName */
1788         str = (BSTR)0x1;
1789         r = IXMLDOMProcessingInstruction_get_baseName(nodePI, &str);
1790         ok(r == S_OK, "ret %08x\n", r );
1791         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1792         SysFreeString(str);
1793
1794         /* test Target */
1795         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
1796         ok(r == S_OK, "ret %08x\n", r );
1797         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
1798         SysFreeString(str);
1799
1800         /* test nodeTypeString */
1801         r = IXMLDOMProcessingInstruction_get_nodeTypeString(nodePI, &str);
1802         ok(r == S_OK, "ret %08x\n", r );
1803         ok( !lstrcmpW( str, _bstr_("processinginstruction") ), "incorrect nodeTypeString string\n");
1804         SysFreeString(str);
1805
1806         /* test get_nodeValue */
1807         r = IXMLDOMProcessingInstruction_get_nodeValue(nodePI, &var);
1808         ok(r == S_OK, "ret %08x\n", r );
1809         ok( !lstrcmpW( V_BSTR(&var), _bstr_("version=\"1.0\"") ), "incorrect data string\n");
1810         VariantClear(&var);
1811
1812         /* test get_data */
1813         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
1814         ok(r == S_OK, "ret %08x\n", r );
1815         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
1816         SysFreeString(str);
1817
1818         /* test put_data */
1819         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
1820         ok(r == E_FAIL, "ret %08x\n", r );
1821
1822         /* test put_data */
1823         V_VT(&var) = VT_BSTR;
1824         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
1825         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
1826         ok(r == E_FAIL, "ret %08x\n", r );
1827         VariantClear(&var);
1828
1829         /* test get nodeName */
1830         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
1831         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
1832         ok(r == S_OK, "ret %08x\n", r );
1833         SysFreeString(str);
1834
1835         IXMLDOMProcessingInstruction_Release(nodePI);
1836     }
1837
1838     r = IXMLDOMDocument_QueryInterface( doc, &IID_ISupportErrorInfo, (void**)&support_error );
1839     ok( r == S_OK, "ret %08x\n", r );
1840     if(r == S_OK)
1841     {
1842         r = ISupportErrorInfo_InterfaceSupportsErrorInfo( support_error, &IID_IXMLDOMDocument );
1843         todo_wine ok( r == S_OK, "ret %08x\n", r );
1844         ISupportErrorInfo_Release( support_error );
1845     }
1846
1847     r = IXMLDOMDocument_Release( doc );
1848     ok( r == 0, "document ref count incorrect\n");
1849
1850     free_bstrs();
1851 }
1852
1853 static void test_persiststreaminit(void)
1854 {
1855     IXMLDOMDocument *doc;
1856     IPersistStreamInit *streaminit;
1857     HRESULT hr;
1858
1859     doc = create_document(&IID_IXMLDOMDocument);
1860     if (!doc) return;
1861
1862     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&streaminit);
1863     ok( hr == S_OK, "failed with 0x%08x\n", hr );
1864
1865     hr = IPersistStreamInit_InitNew(streaminit);
1866     ok( hr == S_OK, "failed with 0x%08x\n", hr );
1867
1868     IXMLDOMDocument_Release(doc);
1869 }
1870
1871 static void test_domnode( void )
1872 {
1873     HRESULT r;
1874     IXMLDOMDocument *doc, *owner = NULL;
1875     IXMLDOMElement *element = NULL;
1876     IXMLDOMNamedNodeMap *map = NULL;
1877     IXMLDOMNode *node = NULL, *next = NULL;
1878     IXMLDOMNodeList *list = NULL;
1879     IXMLDOMAttribute *attr = NULL;
1880     DOMNodeType type = NODE_INVALID;
1881     VARIANT_BOOL b;
1882     BSTR str;
1883     VARIANT var;
1884     LONG count;
1885
1886     doc = create_document(&IID_IXMLDOMDocument);
1887     if (!doc) return;
1888
1889     b = FALSE;
1890     str = SysAllocString( szComplete4 );
1891     r = IXMLDOMDocument_loadXML( doc, str, &b );
1892     ok( r == S_OK, "loadXML failed\n");
1893     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1894     SysFreeString( str );
1895
1896     b = 1;
1897     r = IXMLDOMNode_hasChildNodes( doc, &b );
1898     ok( r == S_OK, "hasChildNoes bad return\n");
1899     ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
1900
1901     r = IXMLDOMDocument_get_documentElement( doc, &element );
1902     ok( r == S_OK, "should be a document element\n");
1903     ok( element != NULL, "should be an element\n");
1904
1905     VariantInit(&var);
1906     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
1907
1908     r = IXMLDOMNode_get_nodeValue( doc, NULL );
1909     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
1910
1911     r = IXMLDOMNode_get_nodeValue( doc, &var );
1912     ok( r == S_FALSE, "nextNode returned wrong code\n");
1913     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
1914     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
1915
1916     if (element)
1917     {
1918         owner = NULL;
1919         r = IXMLDOMNode_get_ownerDocument( element, &owner );
1920         ok( r == S_OK, "get_ownerDocument return code\n");
1921         ok( owner != doc, "get_ownerDocument return\n");
1922         IXMLDOMDocument_Release(owner);
1923
1924         type = NODE_INVALID;
1925         r = IXMLDOMNode_get_nodeType( element, &type);
1926         ok( r == S_OK, "got %08x\n", r);
1927         ok( type == NODE_ELEMENT, "node not an element\n");
1928
1929         str = NULL;
1930         r = IXMLDOMNode_get_baseName( element, &str );
1931         ok( r == S_OK, "get_baseName returned wrong code\n");
1932         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
1933         SysFreeString(str);
1934
1935         /* check if nodename is correct */
1936         r = IXMLDOMElement_get_nodeName( element, NULL );
1937         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1938
1939         /* content doesn't matter here */
1940         str = NULL;
1941         r = IXMLDOMElement_get_nodeName( element, &str );
1942         ok ( r == S_OK, "get_nodeName wrong code\n");
1943         ok ( str != NULL, "str is null\n");
1944         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
1945         SysFreeString( str );
1946
1947         str = SysAllocString( szNonExistentFile );
1948         V_VT(&var) = VT_I4;
1949         V_I4(&var) = 0x1234;
1950         r = IXMLDOMElement_getAttribute( element, str, &var );
1951         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
1952         ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
1953         VariantClear(&var);
1954
1955         r = IXMLDOMElement_getAttributeNode( element, str, NULL);
1956         ok( r == E_FAIL, "getAttributeNode ret %08x\n", r );
1957
1958         attr = (IXMLDOMAttribute*)0xdeadbeef;
1959         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
1960         ok( r == E_FAIL, "getAttributeNode ret %08x\n", r );
1961         ok( attr == NULL, "getAttributeNode ret %p, expected NULL\n", attr );
1962         SysFreeString( str );
1963
1964         attr = (IXMLDOMAttribute*)0xdeadbeef;
1965         str = SysAllocString( szNonExistentAttribute );
1966         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
1967         ok( r == S_FALSE, "getAttributeNode ret %08x\n", r );
1968         ok( attr == NULL, "getAttributeNode ret %p, expected NULL\n", attr );
1969         SysFreeString( str );
1970
1971         str = SysAllocString( szdl );
1972         V_VT(&var) = VT_I4;
1973         V_I4(&var) = 0x1234;
1974         r = IXMLDOMElement_getAttribute( element, str, &var );
1975         ok( r == S_OK, "getAttribute ret %08x\n", r );
1976         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
1977         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
1978         VariantClear( &var );
1979
1980         r = IXMLDOMElement_getAttribute( element, NULL, &var );
1981         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
1982
1983         r = IXMLDOMElement_getAttribute( element, str, NULL );
1984         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
1985
1986         attr = NULL;
1987         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
1988         ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
1989         ok( attr != NULL, "getAttributeNode returned NULL\n" );
1990         if (attr)
1991         {
1992             r = IXMLDOMAttribute_get_parentNode( attr, NULL );
1993             ok( r == E_INVALIDARG, "Expected E_INVALIDARG, ret %08x\n", r );
1994
1995             /* attribute doesn't have a parent in msxml interpretation */
1996             node = (IXMLDOMNode*)0xdeadbeef;
1997             r = IXMLDOMAttribute_get_parentNode( attr, &node );
1998             ok( r == S_FALSE, "Expected S_FALSE, ret %08x\n", r );
1999             ok( node == NULL, "Expected NULL, got %p\n", node );
2000
2001             IXMLDOMAttribute_Release(attr);
2002         }
2003
2004         SysFreeString( str );
2005
2006         r = IXMLDOMElement_get_attributes( element, &map );
2007         ok( r == S_OK, "get_attributes returned wrong code\n");
2008         ok( map != NULL, "should be attributes\n");
2009
2010         b = 1;
2011         r = IXMLDOMNode_hasChildNodes( element, &b );
2012         ok( r == S_OK, "hasChildNoes bad return\n");
2013         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
2014     }
2015     else
2016         ok( FALSE, "no element\n");
2017
2018     if (map)
2019     {
2020         ISupportErrorInfo *support_error;
2021         r = IXMLDOMNamedNodeMap_QueryInterface( map, &IID_ISupportErrorInfo, (void**)&support_error );
2022         ok( r == S_OK, "ret %08x\n", r );
2023
2024         r = ISupportErrorInfo_InterfaceSupportsErrorInfo( support_error, &IID_IXMLDOMNamedNodeMap );
2025 todo_wine
2026 {
2027         ok( r == S_OK, "ret %08x\n", r );
2028 }
2029         ISupportErrorInfo_Release( support_error );
2030
2031         str = SysAllocString( szdl );
2032         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
2033         ok( r == S_OK, "getNamedItem returned wrong code\n");
2034         ok( node != NULL, "should be attributes\n");
2035         IXMLDOMNode_Release(node);
2036         SysFreeString( str );
2037
2038         str = SysAllocString( szdl );
2039         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
2040         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
2041         SysFreeString( str );
2042
2043         /* something that isn't in szComplete4 */
2044         str = SysAllocString( szOpen );
2045         node = (IXMLDOMNode *) 1;
2046         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
2047         ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
2048         ok( node == NULL, "getNamedItem should have returned NULL\n");
2049         SysFreeString( str );
2050
2051         /* test indexed access of attributes */
2052         r = IXMLDOMNamedNodeMap_get_length( map, NULL );
2053         ok ( r == E_INVALIDARG, "get_length should return E_INVALIDARG\n");
2054
2055         r = IXMLDOMNamedNodeMap_get_length( map, &count );
2056         ok ( r == S_OK, "get_length wrong code\n");
2057         ok ( count == 1, "get_length != 1\n");
2058
2059         node = NULL;
2060         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
2061         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
2062         ok ( node == NULL, "there is no node\n");
2063
2064         node = NULL;
2065         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
2066         ok ( r == S_FALSE, "get_item (1) wrong code\n");
2067         ok ( node == NULL, "there is no attribute\n");
2068
2069         node = NULL;
2070         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
2071         ok ( r == S_OK, "get_item (0) wrong code\n");
2072         ok ( node != NULL, "should be attribute\n");
2073
2074         r = IXMLDOMNode_get_nodeName( node, NULL );
2075         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
2076
2077         /* content doesn't matter here */
2078         str = NULL;
2079         r = IXMLDOMNode_get_nodeName( node, &str );
2080         ok ( r == S_OK, "get_nodeName wrong code\n");
2081         ok ( str != NULL, "str is null\n");
2082         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
2083         SysFreeString( str );
2084
2085         /* test sequential access of attributes */
2086         node = NULL;
2087         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2088         ok ( r == S_OK, "nextNode (first time) wrong code\n");
2089         ok ( node != NULL, "nextNode, should be attribute\n");
2090
2091         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2092         ok ( r != S_OK, "nextNode (second time) wrong code\n");
2093         ok ( node == NULL, "nextNode, there is no attribute\n");
2094
2095         r = IXMLDOMNamedNodeMap_reset( map );
2096         ok ( r == S_OK, "reset should return S_OK\n");
2097
2098         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
2099         ok ( r == S_OK, "nextNode (third time) wrong code\n");
2100         ok ( node != NULL, "nextNode, should be attribute\n");
2101     }
2102     else
2103         ok( FALSE, "no map\n");
2104
2105     if (node)
2106     {
2107         type = NODE_INVALID;
2108         r = IXMLDOMNode_get_nodeType( node, &type);
2109         ok( r == S_OK, "getNamedItem returned wrong code\n");
2110         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
2111
2112         str = NULL;
2113         r = IXMLDOMNode_get_baseName( node, NULL );
2114         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
2115
2116         str = NULL;
2117         r = IXMLDOMNode_get_baseName( node, &str );
2118         ok( r == S_OK, "get_baseName returned wrong code\n");
2119         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
2120         SysFreeString( str );
2121
2122         r = IXMLDOMNode_get_nodeValue( node, &var );
2123         ok( r == S_OK, "returns %08x\n", r );
2124         ok( V_VT(&var) == VT_BSTR, "vt %x\n", V_VT(&var));
2125         ok( !lstrcmpW(V_BSTR(&var), szstr1), "nodeValue incorrect\n");
2126         VariantClear(&var);
2127
2128         r = IXMLDOMNode_get_childNodes( node, NULL );
2129         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
2130
2131         r = IXMLDOMNode_get_childNodes( node, &list );
2132         ok( r == S_OK, "get_childNodes returned wrong code\n");
2133
2134         if (list)
2135         {
2136             r = IXMLDOMNodeList_nextNode( list, &next );
2137             ok( r == S_OK, "nextNode returned wrong code\n");
2138         }
2139         else
2140             ok( FALSE, "no childlist\n");
2141
2142         if (next)
2143         {
2144             b = 1;
2145             r = IXMLDOMNode_hasChildNodes( next, &b );
2146             ok( r == S_FALSE, "hasChildNoes bad return\n");
2147             ok( b == VARIANT_FALSE, "hasChildNoes wrong result\n");
2148
2149             type = NODE_INVALID;
2150             r = IXMLDOMNode_get_nodeType( next, &type);
2151             ok( r == S_OK, "getNamedItem returned wrong code\n");
2152             ok( type == NODE_TEXT, "node not text\n");
2153
2154             str = (BSTR) 1;
2155             r = IXMLDOMNode_get_baseName( next, &str );
2156             ok( r == S_FALSE, "get_baseName returned wrong code\n");
2157             ok( str == NULL, "basename was wrong\n");
2158             SysFreeString(str);
2159         }
2160         else
2161             ok( FALSE, "no next\n");
2162
2163         if (next)
2164             IXMLDOMNode_Release( next );
2165         next = NULL;
2166         if (list)
2167             IXMLDOMNodeList_Release( list );
2168         list = NULL;
2169         if (node)
2170             IXMLDOMNode_Release( node );
2171     }
2172     else
2173         ok( FALSE, "no node\n");
2174     node = NULL;
2175
2176     if (map)
2177         IXMLDOMNamedNodeMap_Release( map );
2178
2179     /* now traverse the tree from the root element */
2180     if (element)
2181     {
2182         r = IXMLDOMNode_get_childNodes( element, &list );
2183         ok( r == S_OK, "get_childNodes returned wrong code\n");
2184
2185         /* using get_item for child list doesn't advance the position */
2186         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
2187         expect_node(node, "E2.E2.D1");
2188         IXMLDOMNode_Release(node);
2189         ole_check(IXMLDOMNodeList_nextNode(list, &node));
2190         expect_node(node, "E1.E2.D1");
2191         IXMLDOMNode_Release(node);
2192         ole_check(IXMLDOMNodeList_reset(list));
2193
2194         IXMLDOMNodeList_AddRef(list);
2195         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
2196         ole_check(IXMLDOMNodeList_reset(list));
2197
2198         node = (void*)0xdeadbeef;
2199         str = SysAllocString(szdl);
2200         r = IXMLDOMNode_selectSingleNode( element, str, &node );
2201         SysFreeString(str);
2202         ok( r == S_FALSE, "ret %08x\n", r );
2203         ok( node == NULL, "node %p\n", node );
2204
2205         str = SysAllocString(szbs);
2206         r = IXMLDOMNode_selectSingleNode( element, str, &node );
2207         SysFreeString(str);
2208         ok( r == S_OK, "ret %08x\n", r );
2209         r = IXMLDOMNode_Release( node );
2210         ok( r == 0, "ret %08x\n", r );
2211     }
2212     else
2213         ok( FALSE, "no element\n");
2214
2215     if (list)
2216     {
2217         r = IXMLDOMNodeList_QueryInterface(list, &IID_IDispatch, NULL);
2218         ok( r == E_INVALIDARG || r == E_POINTER, "ret %08x\n", r );
2219
2220         r = IXMLDOMNodeList_get_item(list, 0, NULL);
2221         ok(r == E_INVALIDARG, "Exected E_INVALIDARG got %08x\n", r);
2222
2223         r = IXMLDOMNodeList_get_length(list, NULL);
2224         ok(r == E_INVALIDARG, "Exected E_INVALIDARG got %08x\n", r);
2225
2226         r = IXMLDOMNodeList_get_length( list, &count );
2227         ok( r == S_OK, "get_length returns %08x\n", r );
2228         ok( count == 4, "get_length got %d\n", count );
2229
2230         r = IXMLDOMNodeList_nextNode(list, NULL);
2231         ok(r == E_INVALIDARG, "Exected E_INVALIDARG got %08x\n", r);
2232
2233         r = IXMLDOMNodeList_nextNode( list, &node );
2234         ok( r == S_OK, "nextNode returned wrong code\n");
2235     }
2236     else
2237         ok( FALSE, "no list\n");
2238
2239     if (node)
2240     {
2241         type = NODE_INVALID;
2242         r = IXMLDOMNode_get_nodeType( node, &type);
2243         ok( r == S_OK, "getNamedItem returned wrong code\n");
2244         ok( type == NODE_ELEMENT, "node not text\n");
2245
2246         VariantInit(&var);
2247         ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
2248         r = IXMLDOMNode_get_nodeValue( node, &var );
2249         ok( r == S_FALSE, "nextNode returned wrong code\n");
2250         ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
2251         ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
2252
2253         r = IXMLDOMNode_hasChildNodes( node, NULL );
2254         ok( r == E_INVALIDARG, "hasChildNoes bad return\n");
2255
2256         b = 1;
2257         r = IXMLDOMNode_hasChildNodes( node, &b );
2258         ok( r == S_OK, "hasChildNoes bad return\n");
2259         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
2260
2261         str = NULL;
2262         r = IXMLDOMNode_get_baseName( node, &str );
2263         ok( r == S_OK, "get_baseName returned wrong code\n");
2264         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
2265         SysFreeString(str);
2266     }
2267     else
2268         ok( FALSE, "no node\n");
2269
2270     if (node)
2271         IXMLDOMNode_Release( node );
2272     if (list)
2273         IXMLDOMNodeList_Release( list );
2274     if (element)
2275         IXMLDOMElement_Release( element );
2276
2277     b = FALSE;
2278     str = SysAllocString( szComplete5 );
2279     r = IXMLDOMDocument_loadXML( doc, str, &b );
2280     ok( r == S_OK, "loadXML failed\n");
2281     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2282     SysFreeString( str );
2283
2284     b = 1;
2285     r = IXMLDOMNode_hasChildNodes( doc, &b );
2286     ok( r == S_OK, "hasChildNoes bad return\n");
2287     ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
2288
2289     r = IXMLDOMDocument_get_documentElement( doc, &element );
2290     ok( r == S_OK, "should be a document element\n");
2291     ok( element != NULL, "should be an element\n");
2292
2293     if (element)
2294     {
2295         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
2296         BSTR tag = NULL;
2297
2298         /* check if the tag is correct */
2299         r = IXMLDOMElement_get_tagName( element, &tag );
2300         ok( r == S_OK, "couldn't get tag name\n");
2301         ok( tag != NULL, "tag was null\n");
2302         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
2303         SysFreeString( tag );
2304     }
2305
2306     if (element)
2307         IXMLDOMElement_Release( element );
2308     ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
2309 }
2310
2311 static void test_refs(void)
2312 {
2313     HRESULT r;
2314     BSTR str;
2315     VARIANT_BOOL b;
2316     IXMLDOMDocument *doc;
2317     IXMLDOMElement *element = NULL;
2318     IXMLDOMNode *node = NULL, *node2;
2319     IXMLDOMNodeList *node_list = NULL;
2320     LONG ref;
2321     IUnknown *unk, *unk2;
2322
2323     doc = create_document(&IID_IXMLDOMDocument);
2324     if (!doc) return;
2325
2326     ref = IXMLDOMDocument_Release(doc);
2327     ok( ref == 0, "ref %d\n", ref);
2328
2329     doc = create_document(&IID_IXMLDOMDocument);
2330     if (!doc) return;
2331
2332     str = SysAllocString( szComplete4 );
2333     r = IXMLDOMDocument_loadXML( doc, str, &b );
2334     ok( r == S_OK, "loadXML failed\n");
2335     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2336     SysFreeString( str );
2337
2338     ref = IXMLDOMDocument_AddRef( doc );
2339     ok( ref == 2, "ref %d\n", ref );
2340     ref = IXMLDOMDocument_AddRef( doc );
2341     ok( ref == 3, "ref %d\n", ref );
2342     IXMLDOMDocument_Release( doc );
2343     IXMLDOMDocument_Release( doc );
2344
2345     r = IXMLDOMDocument_get_documentElement( doc, &element );
2346     ok( r == S_OK, "should be a document element\n");
2347     ok( element != NULL, "should be an element\n");
2348
2349     ref = IXMLDOMDocument_AddRef( doc );
2350     ok( ref == 2, "ref %d\n", ref );
2351     IXMLDOMDocument_Release( doc );
2352
2353     r = IXMLDOMElement_get_childNodes( element, &node_list );
2354     ok( r == S_OK, "rets %08x\n", r);
2355
2356     ref = IXMLDOMNodeList_AddRef( node_list );
2357     ok( ref == 2, "ref %d\n", ref );
2358     IXMLDOMNodeList_Release( node_list );
2359
2360     IXMLDOMNodeList_get_item( node_list, 0, &node );
2361     ok( r == S_OK, "rets %08x\n", r);
2362
2363     IXMLDOMNodeList_get_item( node_list, 0, &node2 );
2364     ok( r == S_OK, "rets %08x\n", r);
2365
2366     ref = IXMLDOMNode_AddRef( node );
2367     ok( ref == 2, "ref %d\n", ref );
2368     IXMLDOMNode_Release( node );
2369
2370     ref = IXMLDOMNode_Release( node );
2371     ok( ref == 0, "ref %d\n", ref );
2372     ref = IXMLDOMNode_Release( node2 );
2373     ok( ref == 0, "ref %d\n", ref );
2374
2375     ref = IXMLDOMNodeList_Release( node_list );
2376     ok( ref == 0, "ref %d\n", ref );
2377
2378     ok( node != node2, "node %p node2 %p\n", node, node2 );
2379
2380     ref = IXMLDOMDocument_Release( doc );
2381     ok( ref == 0, "ref %d\n", ref );
2382
2383     ref = IXMLDOMElement_AddRef( element );
2384     todo_wine {
2385     ok( ref == 3, "ref %d\n", ref );
2386     }
2387     IXMLDOMElement_Release( element );
2388
2389     /* IUnknown must be unique however we obtain it */
2390     r = IXMLDOMElement_QueryInterface( element, &IID_IUnknown, (void**)&unk );
2391     ok( r == S_OK, "rets %08x\n", r );
2392     r = IXMLDOMElement_QueryInterface( element, &IID_IXMLDOMNode, (void**)&node );
2393     ok( r == S_OK, "rets %08x\n", r );
2394     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk2 );
2395     ok( r == S_OK, "rets %08x\n", r );
2396     ok( unk == unk2, "unk %p unk2 %p\n", unk, unk2 );
2397
2398     IUnknown_Release( unk2 );
2399     IUnknown_Release( unk );
2400     IXMLDOMNode_Release( node );
2401
2402     IXMLDOMElement_Release( element );
2403
2404 }
2405
2406 static void test_create(void)
2407 {
2408     static const WCHAR szOne[] = {'1',0};
2409     static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
2410     HRESULT r;
2411     VARIANT var;
2412     BSTR str, name;
2413     IXMLDOMDocument *doc;
2414     IXMLDOMElement *element;
2415     IXMLDOMComment *comment;
2416     IXMLDOMText *text;
2417     IXMLDOMCDATASection *cdata;
2418     IXMLDOMNode *root, *node, *child;
2419     IXMLDOMNamedNodeMap *attr_map;
2420     IUnknown *unk;
2421     LONG ref;
2422     LONG num;
2423
2424     doc = create_document(&IID_IXMLDOMDocument);
2425     if (!doc) return;
2426
2427     /* types not supported for creation */
2428     V_VT(&var) = VT_I1;
2429     V_I1(&var) = NODE_DOCUMENT;
2430     node = (IXMLDOMNode*)0x1;
2431     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2432     ok( r == E_INVALIDARG, "returns %08x\n", r );
2433     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2434
2435     V_VT(&var) = VT_I1;
2436     V_I1(&var) = NODE_DOCUMENT_TYPE;
2437     node = (IXMLDOMNode*)0x1;
2438     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2439     ok( r == E_INVALIDARG, "returns %08x\n", r );
2440     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2441
2442     V_VT(&var) = VT_I1;
2443     V_I1(&var) = NODE_ENTITY;
2444     node = (IXMLDOMNode*)0x1;
2445     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2446     ok( r == E_INVALIDARG, "returns %08x\n", r );
2447     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2448
2449     V_VT(&var) = VT_I1;
2450     V_I1(&var) = NODE_NOTATION;
2451     node = (IXMLDOMNode*)0x1;
2452     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2453     ok( r == E_INVALIDARG, "returns %08x\n", r );
2454     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2455
2456     /* NODE_COMMENT */
2457     V_VT(&var) = VT_I1;
2458     V_I1(&var) = NODE_COMMENT;
2459     node = NULL;
2460     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2461     ok( r == S_OK, "returns %08x\n", r );
2462     ok( node != NULL, "\n");
2463
2464     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2465     ok( r == S_OK, "returns %08x\n", r );
2466     IXMLDOMNode_Release(node);
2467
2468     str = NULL;
2469     r = IXMLDOMComment_get_data(comment, &str);
2470     ok( r == S_OK, "returns %08x\n", r );
2471     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2472     IXMLDOMComment_Release(comment);
2473     SysFreeString(str);
2474
2475     node = (IXMLDOMNode*)0x1;
2476     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2477     ok( r == S_OK, "returns %08x\n", r );
2478
2479     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2480     ok( r == S_OK, "returns %08x\n", r );
2481     IXMLDOMNode_Release(node);
2482
2483     str = NULL;
2484     r = IXMLDOMComment_get_data(comment, &str);
2485     ok( r == S_OK, "returns %08x\n", r );
2486     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2487     IXMLDOMComment_Release(comment);
2488     SysFreeString(str);
2489
2490     node = (IXMLDOMNode*)0x1;
2491     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2492     ok( r == S_OK, "returns %08x\n", r );
2493
2494     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)&comment);
2495     ok( r == S_OK, "returns %08x\n", r );
2496     IXMLDOMNode_Release(node);
2497
2498     str = NULL;
2499     r = IXMLDOMComment_get_data(comment, &str);
2500     ok( r == S_OK, "returns %08x\n", r );
2501     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2502     IXMLDOMComment_Release(comment);
2503     SysFreeString(str);
2504
2505     /* NODE_TEXT */
2506     V_VT(&var) = VT_I1;
2507     V_I1(&var) = NODE_TEXT;
2508     node = NULL;
2509     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2510     ok( r == S_OK, "returns %08x\n", r );
2511     ok( node != NULL, "\n");
2512
2513     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2514     ok( r == S_OK, "returns %08x\n", r );
2515     IXMLDOMNode_Release(node);
2516
2517     str = NULL;
2518     r = IXMLDOMText_get_data(text, &str);
2519     ok( r == S_OK, "returns %08x\n", r );
2520     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2521     IXMLDOMText_Release(text);
2522     SysFreeString(str);
2523
2524     node = (IXMLDOMNode*)0x1;
2525     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2526     ok( r == S_OK, "returns %08x\n", r );
2527
2528     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2529     ok( r == S_OK, "returns %08x\n", r );
2530     IXMLDOMNode_Release(node);
2531
2532     str = NULL;
2533     r = IXMLDOMText_get_data(text, &str);
2534     ok( r == S_OK, "returns %08x\n", r );
2535     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2536     IXMLDOMText_Release(text);
2537     SysFreeString(str);
2538
2539     node = (IXMLDOMNode*)0x1;
2540     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2541     ok( r == S_OK, "returns %08x\n", r );
2542
2543     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)&text);
2544     ok( r == S_OK, "returns %08x\n", r );
2545     IXMLDOMNode_Release(node);
2546
2547     str = NULL;
2548     r = IXMLDOMText_get_data(text, &str);
2549     ok( r == S_OK, "returns %08x\n", r );
2550     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2551     IXMLDOMText_Release(text);
2552     SysFreeString(str);
2553
2554     /* NODE_CDATA_SECTION */
2555     V_VT(&var) = VT_I1;
2556     V_I1(&var) = NODE_CDATA_SECTION;
2557     node = NULL;
2558     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2559     ok( r == S_OK, "returns %08x\n", r );
2560     ok( node != NULL, "\n");
2561
2562     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2563     ok( r == S_OK, "returns %08x\n", r );
2564     IXMLDOMNode_Release(node);
2565
2566     str = NULL;
2567     r = IXMLDOMCDATASection_get_data(cdata, &str);
2568     ok( r == S_OK, "returns %08x\n", r );
2569     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2570     IXMLDOMCDATASection_Release(cdata);
2571     SysFreeString(str);
2572
2573     node = (IXMLDOMNode*)0x1;
2574     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2575     ok( r == S_OK, "returns %08x\n", r );
2576
2577     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2578     ok( r == S_OK, "returns %08x\n", r );
2579     IXMLDOMNode_Release(node);
2580
2581     str = NULL;
2582     r = IXMLDOMCDATASection_get_data(cdata, &str);
2583     ok( r == S_OK, "returns %08x\n", r );
2584     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2585     IXMLDOMCDATASection_Release(cdata);
2586     SysFreeString(str);
2587
2588     node = (IXMLDOMNode*)0x1;
2589     r = IXMLDOMDocument_createNode( doc, var, _bstr_("blah"), NULL, &node );
2590     ok( r == S_OK, "returns %08x\n", r );
2591
2592     r = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)&cdata);
2593     ok( r == S_OK, "returns %08x\n", r );
2594     IXMLDOMNode_Release(node);
2595
2596     str = NULL;
2597     r = IXMLDOMCDATASection_get_data(cdata, &str);
2598     ok( r == S_OK, "returns %08x\n", r );
2599     ok( str && SysStringLen(str) == 0, "expected empty comment, %p\n", str);
2600     IXMLDOMCDATASection_Release(cdata);
2601     SysFreeString(str);
2602
2603     /* NODE_ATTRIBUTE */
2604     V_VT(&var) = VT_I1;
2605     V_I1(&var) = NODE_ATTRIBUTE;
2606     node = (IXMLDOMNode*)0x1;
2607     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2608     ok( r == E_FAIL, "returns %08x\n", r );
2609     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2610
2611     V_VT(&var) = VT_I1;
2612     V_I1(&var) = NODE_ATTRIBUTE;
2613     node = (IXMLDOMNode*)0x1;
2614     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2615     ok( r == E_FAIL, "returns %08x\n", r );
2616     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2617
2618     V_VT(&var) = VT_I1;
2619     V_I1(&var) = NODE_ATTRIBUTE;
2620     str = SysAllocString( szlc );
2621     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2622     ok( r == S_OK, "returns %08x\n", r );
2623     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2624     SysFreeString(str);
2625
2626     /* a name is required for attribute, try a BSTR with first null wchar */
2627     V_VT(&var) = VT_I1;
2628     V_I1(&var) = NODE_ATTRIBUTE;
2629     str = SysAllocString( szstr1 );
2630     str[0] = 0;
2631     node = (IXMLDOMNode*)0x1;
2632     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2633     ok( r == E_FAIL, "returns %08x\n", r );
2634     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2635     SysFreeString(str);
2636
2637     /* NODE_PROCESSING_INSTRUCTION */
2638     V_VT(&var) = VT_I1;
2639     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2640     node = (IXMLDOMNode*)0x1;
2641     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2642     ok( r == E_FAIL, "returns %08x\n", r );
2643     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2644
2645     V_VT(&var) = VT_I1;
2646     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2647     node = (IXMLDOMNode*)0x1;
2648     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2649     ok( r == E_FAIL, "returns %08x\n", r );
2650     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2651
2652     V_VT(&var) = VT_I1;
2653     V_I1(&var) = NODE_PROCESSING_INSTRUCTION;
2654     r = IXMLDOMDocument_createNode( doc, var, _bstr_("pi"), NULL, NULL );
2655     ok( r == E_INVALIDARG, "returns %08x\n", r );
2656
2657     /* NODE_ENTITY_REFERENCE */
2658     V_VT(&var) = VT_I1;
2659     V_I1(&var) = NODE_ENTITY_REFERENCE;
2660     node = (IXMLDOMNode*)0x1;
2661     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2662     ok( r == E_FAIL, "returns %08x\n", r );
2663     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2664
2665     V_VT(&var) = VT_I1;
2666     V_I1(&var) = NODE_ENTITY_REFERENCE;
2667     node = (IXMLDOMNode*)0x1;
2668     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2669     ok( r == E_FAIL, "returns %08x\n", r );
2670     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2671
2672     /* NODE_ELEMENT */
2673     V_VT(&var) = VT_I1;
2674     V_I1(&var) = NODE_ELEMENT;
2675     node = (IXMLDOMNode*)0x1;
2676     r = IXMLDOMDocument_createNode( doc, var, NULL, NULL, &node );
2677     ok( r == E_FAIL, "returns %08x\n", r );
2678     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2679
2680     V_VT(&var) = VT_I1;
2681     V_I1(&var) = NODE_ELEMENT;
2682     node = (IXMLDOMNode*)0x1;
2683     r = IXMLDOMDocument_createNode( doc, var, _bstr_(""), NULL, &node );
2684     ok( r == E_FAIL, "returns %08x\n", r );
2685     ok( node == (void*)0x1, "expected same ptr, got %p\n", node);
2686
2687     V_VT(&var) = VT_I1;
2688     V_I1(&var) = NODE_ELEMENT;
2689     str = SysAllocString( szlc );
2690     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2691     ok( r == S_OK, "returns %08x\n", r );
2692     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2693
2694     V_VT(&var) = VT_I1;
2695     V_I1(&var) = NODE_ELEMENT;
2696     r = IXMLDOMDocument_createNode( doc, var, str, NULL, NULL );
2697     ok( r == E_INVALIDARG, "returns %08x\n", r );
2698
2699     V_VT(&var) = VT_R4;
2700     V_R4(&var) = NODE_ELEMENT;
2701     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2702     ok( r == S_OK, "returns %08x\n", r );
2703     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2704
2705     V_VT(&var) = VT_BSTR;
2706     V_BSTR(&var) = SysAllocString( szOne );
2707     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2708     ok( r == S_OK, "returns %08x\n", r );
2709     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2710     VariantClear(&var);
2711
2712     V_VT(&var) = VT_BSTR;
2713     V_BSTR(&var) = SysAllocString( szOneGarbage );
2714     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2715     ok( r == E_INVALIDARG, "returns %08x\n", r );
2716     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
2717     VariantClear(&var);
2718
2719     V_VT(&var) = VT_I4;
2720     V_I4(&var) = NODE_ELEMENT;
2721     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2722     ok( r == S_OK, "returns %08x\n", r );
2723     r = IXMLDOMDocument_appendChild( doc, node, &root );
2724     ok( r == S_OK, "returns %08x\n", r );
2725     ok( node == root, "%p %p\n", node, root );
2726
2727     ref = IXMLDOMNode_AddRef( node );
2728     ok(ref == 3, "ref %d\n", ref);
2729     IXMLDOMNode_Release( node );
2730
2731     ref = IXMLDOMNode_Release( node );
2732     ok(ref == 1, "ref %d\n", ref);
2733     SysFreeString( str );
2734
2735     V_VT(&var) = VT_I4;
2736     V_I4(&var) = NODE_ELEMENT;
2737     str = SysAllocString( szbs );
2738     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2739     ok( r == S_OK, "returns %08x\n", r );
2740     SysFreeString( str );
2741
2742     ref = IXMLDOMNode_AddRef( node );
2743     ok(ref == 2, "ref = %d\n", ref);
2744     IXMLDOMNode_Release( node );
2745
2746     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (void**)&unk );
2747     ok( r == S_OK, "returns %08x\n", r );
2748
2749     ref = IXMLDOMNode_AddRef( unk );
2750     ok(ref == 3, "ref = %d\n", ref);
2751     IXMLDOMNode_Release( unk );
2752
2753     V_VT(&var) = VT_EMPTY;
2754     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
2755     ok( r == S_OK, "returns %08x\n", r );
2756     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
2757     IXMLDOMNode_Release( child );
2758     IUnknown_Release( unk );
2759
2760
2761     V_VT(&var) = VT_NULL;
2762     V_DISPATCH(&var) = (IDispatch*)node;
2763     r = IXMLDOMNode_insertBefore( root, node, var, &child );
2764     ok( r == S_OK, "returns %08x\n", r );
2765     ok( node == child, "%p %p\n", node, child );
2766     IXMLDOMNode_Release( child );
2767
2768
2769     V_VT(&var) = VT_NULL;
2770     V_DISPATCH(&var) = (IDispatch*)node;
2771     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
2772     ok( r == S_OK, "returns %08x\n", r );
2773     IXMLDOMNode_Release( node );
2774
2775     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (void**)&element );
2776     ok( r == S_OK, "returns %08x\n", r );
2777
2778     r = IXMLDOMElement_get_attributes( element, &attr_map );
2779     ok( r == S_OK, "returns %08x\n", r );
2780     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2781     ok( r == S_OK, "returns %08x\n", r );
2782     ok( num == 0, "num %d\n", num );
2783     IXMLDOMNamedNodeMap_Release( attr_map );
2784
2785     V_VT(&var) = VT_BSTR;
2786     V_BSTR(&var) = SysAllocString( szstr1 );
2787     name = SysAllocString( szdl );
2788     r = IXMLDOMElement_setAttribute( element, name, var );
2789     ok( r == S_OK, "returns %08x\n", r );
2790     r = IXMLDOMElement_get_attributes( element, &attr_map );
2791     ok( r == S_OK, "returns %08x\n", r );
2792     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2793     ok( r == S_OK, "returns %08x\n", r );
2794     ok( num == 1, "num %d\n", num );
2795     IXMLDOMNamedNodeMap_Release( attr_map );
2796     VariantClear(&var);
2797
2798     V_VT(&var) = VT_BSTR;
2799     V_BSTR(&var) = SysAllocString( szstr2 );
2800     r = IXMLDOMElement_setAttribute( element, name, var );
2801     ok( r == S_OK, "returns %08x\n", r );
2802     r = IXMLDOMElement_get_attributes( element, &attr_map );
2803     ok( r == S_OK, "returns %08x\n", r );
2804     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2805     ok( r == S_OK, "returns %08x\n", r );
2806     ok( num == 1, "num %d\n", num );
2807     IXMLDOMNamedNodeMap_Release( attr_map );
2808     VariantClear(&var);
2809     r = IXMLDOMElement_getAttribute( element, name, &var );
2810     ok( r == S_OK, "returns %08x\n", r );
2811     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
2812     VariantClear(&var);
2813     SysFreeString(name);
2814
2815     V_VT(&var) = VT_BSTR;
2816     V_BSTR(&var) = SysAllocString( szstr1 );
2817     name = SysAllocString( szlc );
2818     r = IXMLDOMElement_setAttribute( element, name, var );
2819     ok( r == S_OK, "returns %08x\n", r );
2820     r = IXMLDOMElement_get_attributes( element, &attr_map );
2821     ok( r == S_OK, "returns %08x\n", r );
2822     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
2823     ok( r == S_OK, "returns %08x\n", r );
2824     ok( num == 2, "num %d\n", num );
2825     IXMLDOMNamedNodeMap_Release( attr_map );
2826     VariantClear(&var);
2827     SysFreeString(name);
2828
2829     V_VT(&var) = VT_I4;
2830     V_I4(&var) = 10;
2831     name = SysAllocString( szbs );
2832     r = IXMLDOMElement_setAttribute( element, name, var );
2833     ok( r == S_OK, "returns %08x\n", r );
2834     VariantClear(&var);
2835     r = IXMLDOMElement_getAttribute( element, name, &var );
2836     ok( r == S_OK, "returns %08x\n", r );
2837     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
2838     VariantClear(&var);
2839     SysFreeString(name);
2840
2841     /* Create an Attribute */
2842     V_VT(&var) = VT_I4;
2843     V_I4(&var) = NODE_ATTRIBUTE;
2844     str = SysAllocString( szAttribute );
2845     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
2846     ok( r == S_OK, "returns %08x\n", r );
2847     ok( node != NULL, "node was null\n");
2848     SysFreeString(str);
2849
2850     r = IXMLDOMNode_get_nodeTypeString(node, &str);
2851     ok( r == S_OK, "returns %08x\n", r );
2852     ok( !lstrcmpW( str, _bstr_("attribute") ), "incorrect nodeTypeString string\n");
2853     SysFreeString(str);
2854     IXMLDOMNode_Release( node );
2855
2856     IXMLDOMElement_Release( element );
2857     IXMLDOMNode_Release( root );
2858     IXMLDOMDocument_Release( doc );
2859 }
2860
2861 static void test_getElementsByTagName(void)
2862 {
2863     IXMLDOMNodeList *node_list;
2864     IXMLDOMDocument *doc;
2865     IXMLDOMElement *elem;
2866     WCHAR buff[100];
2867     VARIANT_BOOL b;
2868     HRESULT r;
2869     LONG len;
2870     BSTR str;
2871
2872     doc = create_document(&IID_IXMLDOMDocument);
2873     if (!doc) return;
2874
2875     str = SysAllocString( szComplete4 );
2876     r = IXMLDOMDocument_loadXML( doc, str, &b );
2877     ok( r == S_OK, "loadXML failed\n");
2878     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2879     SysFreeString( str );
2880
2881     str = SysAllocString( szstar );
2882
2883     /* null arguments cases */
2884     r = IXMLDOMDocument_getElementsByTagName(doc, NULL, &node_list);
2885     ok( r == E_INVALIDARG, "ret %08x\n", r );
2886     r = IXMLDOMDocument_getElementsByTagName(doc, str, NULL);
2887     ok( r == E_INVALIDARG, "ret %08x\n", r );
2888
2889     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
2890     ok( r == S_OK, "ret %08x\n", r );
2891     r = IXMLDOMNodeList_get_length( node_list, &len );
2892     ok( r == S_OK, "ret %08x\n", r );
2893     ok( len == 6, "len %d\n", len );
2894
2895     test_disp((IUnknown*)node_list);
2896
2897     IXMLDOMNodeList_Release( node_list );
2898     SysFreeString( str );
2899
2900     /* broken query BSTR */
2901     memcpy(&buff[2], szstar, sizeof(szstar));
2902     /* just a big length */
2903     *(DWORD*)buff = 0xf0f0;
2904     r = IXMLDOMDocument_getElementsByTagName(doc, &buff[2], &node_list);
2905     ok( r == S_OK, "ret %08x\n", r );
2906     r = IXMLDOMNodeList_get_length( node_list, &len );
2907     ok( r == S_OK, "ret %08x\n", r );
2908     ok( len == 6, "len %d\n", len );
2909     IXMLDOMNodeList_Release( node_list );
2910
2911     str = SysAllocString( szbs );
2912     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
2913     ok( r == S_OK, "ret %08x\n", r );
2914     r = IXMLDOMNodeList_get_length( node_list, &len );
2915     ok( r == S_OK, "ret %08x\n", r );
2916     ok( len == 1, "len %d\n", len );
2917     IXMLDOMNodeList_Release( node_list );
2918     SysFreeString( str );
2919
2920     str = SysAllocString( szdl );
2921     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
2922     ok( r == S_OK, "ret %08x\n", r );
2923     r = IXMLDOMNodeList_get_length( node_list, &len );
2924     ok( r == S_OK, "ret %08x\n", r );
2925     ok( len == 0, "len %d\n", len );
2926     IXMLDOMNodeList_Release( node_list );
2927     SysFreeString( str );
2928
2929     str = SysAllocString( szstr1 );
2930     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
2931     ok( r == S_OK, "ret %08x\n", r );
2932     r = IXMLDOMNodeList_get_length( node_list, &len );
2933     ok( r == S_OK, "ret %08x\n", r );
2934     ok( len == 0, "len %d\n", len );
2935     IXMLDOMNodeList_Release( node_list );
2936     SysFreeString( str );
2937
2938     /* test for element */
2939     r = IXMLDOMDocument_get_documentElement(doc, &elem);
2940     ok( r == S_OK, "ret %08x\n", r );
2941
2942     str = SysAllocString( szstar );
2943
2944     /* null arguments cases */
2945     r = IXMLDOMElement_getElementsByTagName(elem, NULL, &node_list);
2946     ok( r == E_INVALIDARG, "ret %08x\n", r );
2947     r = IXMLDOMElement_getElementsByTagName(elem, str, NULL);
2948     ok( r == E_INVALIDARG, "ret %08x\n", r );
2949
2950     r = IXMLDOMElement_getElementsByTagName(elem, str, &node_list);
2951     ok( r == S_OK, "ret %08x\n", r );
2952     r = IXMLDOMNodeList_get_length( node_list, &len );
2953     ok( r == S_OK, "ret %08x\n", r );
2954     todo_wine ok( len == 5, "len %d\n", len );
2955
2956     IXMLDOMNodeList_Release( node_list );
2957     SysFreeString( str );
2958
2959     /* broken query BSTR */
2960     memcpy(&buff[2], szstar, sizeof(szstar));
2961     /* just a big length */
2962     *(DWORD*)buff = 0xf0f0;
2963     r = IXMLDOMElement_getElementsByTagName(elem, &buff[2], &node_list);
2964     ok( r == S_OK, "ret %08x\n", r );
2965     r = IXMLDOMNodeList_get_length( node_list, &len );
2966     ok( r == S_OK, "ret %08x\n", r );
2967     todo_wine ok( len == 5, "len %d\n", len );
2968     IXMLDOMNodeList_Release( node_list );
2969
2970     IXMLDOMElement_Release(elem);
2971
2972     IXMLDOMDocument_Release( doc );
2973 }
2974
2975 static void test_get_text(void)
2976 {
2977     HRESULT r;
2978     BSTR str;
2979     VARIANT_BOOL b;
2980     IXMLDOMDocument *doc;
2981     IXMLDOMNode *node, *node2, *node3;
2982     IXMLDOMNode *nodeRoot;
2983     IXMLDOMNodeList *node_list;
2984     IXMLDOMNamedNodeMap *node_map;
2985     LONG len;
2986
2987     doc = create_document(&IID_IXMLDOMDocument);
2988     if (!doc) return;
2989
2990     str = SysAllocString( szComplete4 );
2991     r = IXMLDOMDocument_loadXML( doc, str, &b );
2992     ok( r == S_OK, "loadXML failed\n");
2993     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2994     SysFreeString( str );
2995
2996     str = SysAllocString( szbs );
2997     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
2998     ok( r == S_OK, "ret %08x\n", r );
2999     SysFreeString(str);
3000
3001     /* Test to get all child node text. */
3002     r = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&nodeRoot);
3003     ok( r == S_OK, "ret %08x\n", r );
3004     if(r == S_OK)
3005     {
3006         r = IXMLDOMNode_get_text( nodeRoot, &str );
3007         ok( r == S_OK, "ret %08x\n", r );
3008         ok( compareIgnoreReturns(str, _bstr_("fn1.txt\n\n fn2.txt \n\nf1\n")), "wrong get_text: %s\n", wine_dbgstr_w(str));
3009         SysFreeString(str);
3010
3011         IXMLDOMNode_Release(nodeRoot);
3012     }
3013
3014     if (0) {
3015     /* this test crashes on win9x */
3016     r = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatch, NULL);
3017     ok( r == E_INVALIDARG, "ret %08x\n", r );
3018     }
3019
3020     r = IXMLDOMNodeList_get_length( node_list, NULL );
3021     ok( r == E_INVALIDARG, "ret %08x\n", r );
3022
3023     r = IXMLDOMNodeList_get_length( node_list, &len );
3024     ok( r == S_OK, "ret %08x\n", r );
3025     ok( len == 1, "expect 1 got %d\n", len );
3026
3027     r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
3028     ok( r == E_INVALIDARG, "ret %08x\n", r );
3029
3030     r = IXMLDOMNodeList_nextNode( node_list, NULL );
3031     ok( r == E_INVALIDARG, "ret %08x\n", r );
3032
3033     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
3034     ok( r == S_OK, "ret %08x\n", r );
3035     IXMLDOMNodeList_Release( node_list );
3036
3037     /* Invalid output parameter*/
3038     r = IXMLDOMNode_get_text( node, NULL );
3039     ok( r == E_INVALIDARG, "ret %08x\n", r );
3040
3041     r = IXMLDOMNode_get_text( node, &str );
3042     ok( r == S_OK, "ret %08x\n", r );
3043     ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
3044     SysFreeString(str);
3045
3046     r = IXMLDOMNode_get_attributes( node, &node_map );
3047     ok( r == S_OK, "ret %08x\n", r );
3048
3049     str = SysAllocString( szvr );
3050     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
3051     ok( r == S_OK, "ret %08x\n", r );
3052     SysFreeString(str);
3053
3054     r = IXMLDOMNode_get_text( node2, &str );
3055     ok( r == S_OK, "ret %08x\n", r );
3056     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3057     SysFreeString(str);
3058
3059     r = IXMLDOMNode_get_firstChild( node2, &node3 );
3060     ok( r == S_OK, "ret %08x\n", r );
3061
3062     r = IXMLDOMNode_get_text( node3, &str );
3063     ok( r == S_OK, "ret %08x\n", r );
3064     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
3065     SysFreeString(str);
3066
3067
3068     IXMLDOMNode_Release( node3 );
3069     IXMLDOMNode_Release( node2 );
3070     IXMLDOMNamedNodeMap_Release( node_map );
3071     IXMLDOMNode_Release( node );
3072     IXMLDOMDocument_Release( doc );
3073 }
3074
3075 static void test_get_childNodes(void)
3076 {
3077     HRESULT r;
3078     BSTR str;
3079     VARIANT_BOOL b;
3080     IXMLDOMDocument *doc;
3081     IXMLDOMElement *element;
3082     IXMLDOMNode *node, *node2;
3083     IXMLDOMNodeList *node_list, *node_list2;
3084     LONG len;
3085
3086     doc = create_document(&IID_IXMLDOMDocument);
3087     if (!doc) return;
3088
3089     str = SysAllocString( szComplete4 );
3090     r = IXMLDOMDocument_loadXML( doc, str, &b );
3091     ok( r == S_OK, "loadXML failed\n");
3092     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3093     SysFreeString( str );
3094
3095     r = IXMLDOMDocument_get_documentElement( doc, &element );
3096     ok( r == S_OK, "ret %08x\n", r);
3097
3098     r = IXMLDOMElement_get_childNodes( element, &node_list );
3099     ok( r == S_OK, "ret %08x\n", r);
3100
3101     r = IXMLDOMNodeList_get_length( node_list, &len );
3102     ok( r == S_OK, "ret %08x\n", r);
3103     ok( len == 4, "len %d\n", len);
3104
3105     r = IXMLDOMNodeList_get_item( node_list, 2, &node );
3106     ok( r == S_OK, "ret %08x\n", r);
3107
3108     r = IXMLDOMNode_get_childNodes( node, &node_list2 );
3109     ok( r == S_OK, "ret %08x\n", r);
3110
3111     r = IXMLDOMNodeList_get_length( node_list2, &len );
3112     ok( r == S_OK, "ret %08x\n", r);
3113     ok( len == 0, "len %d\n", len);
3114
3115     r = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
3116     ok( r == S_FALSE, "ret %08x\n", r);
3117
3118     IXMLDOMNodeList_Release( node_list2 );
3119     IXMLDOMNode_Release( node );
3120     IXMLDOMNodeList_Release( node_list );
3121     IXMLDOMElement_Release( element );
3122     IXMLDOMDocument_Release( doc );
3123 }
3124
3125 static void test_get_firstChild(void)
3126 {
3127     static WCHAR xmlW[] = {'x','m','l',0};
3128     IXMLDOMDocument *doc;
3129     IXMLDOMNode *node;
3130     VARIANT_BOOL b;
3131     HRESULT r;
3132     BSTR str;
3133
3134     doc = create_document(&IID_IXMLDOMDocument);
3135     if (!doc) return;
3136
3137     str = SysAllocString( szComplete4 );
3138     r = IXMLDOMDocument_loadXML( doc, str, &b );
3139     ok( r == S_OK, "loadXML failed\n");
3140     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3141     SysFreeString( str );
3142
3143     r = IXMLDOMDocument_get_firstChild( doc, &node );
3144     ok( r == S_OK, "ret %08x\n", r);
3145
3146     r = IXMLDOMNode_get_nodeName( node, &str );
3147     ok( r == S_OK, "ret %08x\n", r);
3148
3149     ok(memcmp(str, xmlW, sizeof(xmlW)) == 0, "expected \"xml\" node name\n");
3150
3151     SysFreeString(str);
3152     IXMLDOMNode_Release( node );
3153     IXMLDOMDocument_Release( doc );
3154 }
3155
3156 static void test_get_lastChild(void)
3157 {
3158     static WCHAR lcW[] = {'l','c',0};
3159     static WCHAR foW[] = {'f','o',0};
3160     IXMLDOMDocument *doc;
3161     IXMLDOMNode *node, *child;
3162     VARIANT_BOOL b;
3163     HRESULT r;
3164     BSTR str;
3165
3166     doc = create_document(&IID_IXMLDOMDocument);
3167     if (!doc) return;
3168
3169     str = SysAllocString( szComplete4 );
3170     r = IXMLDOMDocument_loadXML( doc, str, &b );
3171     ok( r == S_OK, "loadXML failed\n");
3172     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3173     SysFreeString( str );
3174
3175     r = IXMLDOMDocument_get_lastChild( doc, &node );
3176     ok( r == S_OK, "ret %08x\n", r);
3177
3178     r = IXMLDOMNode_get_nodeName( node, &str );
3179     ok( r == S_OK, "ret %08x\n", r);
3180
3181     ok(memcmp(str, lcW, sizeof(lcW)) == 0, "expected \"lc\" node name\n");
3182     SysFreeString(str);
3183
3184     r = IXMLDOMNode_get_lastChild( node, &child );
3185     ok( r == S_OK, "ret %08x\n", r);
3186
3187     r = IXMLDOMNode_get_nodeName( child, &str );
3188     ok( r == S_OK, "ret %08x\n", r);
3189
3190     ok(memcmp(str, foW, sizeof(foW)) == 0, "expected \"fo\" node name\n");
3191     SysFreeString(str);
3192
3193     IXMLDOMNode_Release( child );
3194     IXMLDOMNode_Release( node );
3195     IXMLDOMDocument_Release( doc );
3196 }
3197
3198 static void test_removeChild(void)
3199 {
3200     HRESULT r;
3201     BSTR str;
3202     VARIANT_BOOL b;
3203     IXMLDOMDocument *doc;
3204     IXMLDOMElement *element, *lc_element;
3205     IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
3206     IXMLDOMNodeList *root_list, *fo_list;
3207
3208     doc = create_document(&IID_IXMLDOMDocument);
3209     if (!doc) return;
3210
3211     str = SysAllocString( szComplete4 );
3212     r = IXMLDOMDocument_loadXML( doc, str, &b );
3213     ok( r == S_OK, "loadXML failed\n");
3214     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3215     SysFreeString( str );
3216
3217     r = IXMLDOMDocument_get_documentElement( doc, &element );
3218     ok( r == S_OK, "ret %08x\n", r);
3219
3220     r = IXMLDOMElement_get_childNodes( element, &root_list );
3221     ok( r == S_OK, "ret %08x\n", r);
3222
3223     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3224     ok( r == S_OK, "ret %08x\n", r);
3225
3226     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3227     ok( r == S_OK, "ret %08x\n", r);
3228
3229     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3230     ok( r == S_OK, "ret %08x\n", r);
3231
3232     /* invalid parameter: NULL ptr */
3233     removed_node = (void*)0xdeadbeef;
3234     r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
3235     ok( r == E_INVALIDARG, "ret %08x\n", r );
3236     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3237
3238     /* ba_node is a descendant of element, but not a direct child. */
3239     removed_node = (void*)0xdeadbeef;
3240     r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
3241     ok( r == E_INVALIDARG, "ret %08x\n", r );
3242     ok( removed_node == NULL, "%p\n", removed_node );
3243
3244     r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
3245     ok( r == S_OK, "ret %08x\n", r);
3246     ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
3247
3248     /* try removing already removed child */
3249     temp_node = (void*)0xdeadbeef;
3250     r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
3251     ok( r == E_INVALIDARG, "ret %08x\n", r);
3252     ok( temp_node == NULL, "%p\n", temp_node );
3253
3254     /* the removed node has no parent anymore */
3255     r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
3256     ok( r == S_FALSE, "ret %08x\n", r);
3257     ok( temp_node == NULL, "%p\n", temp_node );
3258
3259     IXMLDOMNode_Release( removed_node );
3260     IXMLDOMNode_Release( ba_node );
3261     IXMLDOMNodeList_Release( fo_list );
3262
3263     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3264     ok( r == S_OK, "ret %08x\n", r);
3265
3266     r = IXMLDOMElement_QueryInterface( lc_node, &IID_IXMLDOMElement, (void**)&lc_element );
3267     ok( r == S_OK, "ret %08x\n", r);
3268
3269     /* MS quirk: passing wrong interface pointer works, too */
3270     r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
3271     ok( r == S_OK, "ret %08x\n", r);
3272
3273     r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
3274     ok( r == S_FALSE, "ret %08x\n", r);
3275     ok( temp_node == NULL, "%p\n", temp_node );
3276
3277     IXMLDOMNode_Release( lc_node );
3278     IXMLDOMNodeList_Release( root_list );
3279     IXMLDOMElement_Release( element );
3280     IXMLDOMDocument_Release( doc );
3281 }
3282
3283 static void test_replaceChild(void)
3284 {
3285     HRESULT r;
3286     BSTR str;
3287     VARIANT_BOOL b;
3288     IXMLDOMDocument *doc;
3289     IXMLDOMElement *element, *ba_element;
3290     IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
3291     IXMLDOMNodeList *root_list, *fo_list;
3292     IUnknown * unk1, *unk2;
3293     LONG len;
3294
3295     doc = create_document(&IID_IXMLDOMDocument);
3296     if (!doc) return;
3297
3298     str = SysAllocString( szComplete4 );
3299     r = IXMLDOMDocument_loadXML( doc, str, &b );
3300     ok( r == S_OK, "loadXML failed\n");
3301     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3302     SysFreeString( str );
3303
3304     r = IXMLDOMDocument_get_documentElement( doc, &element );
3305     ok( r == S_OK, "ret %08x\n", r);
3306
3307     r = IXMLDOMElement_get_childNodes( element, &root_list );
3308     ok( r == S_OK, "ret %08x\n", r);
3309
3310     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
3311     ok( r == S_OK, "ret %08x\n", r);
3312
3313     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
3314     ok( r == S_OK, "ret %08x\n", r);
3315
3316     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3317     ok( r == S_OK, "ret %08x\n", r);
3318
3319     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
3320     ok( r == S_OK, "ret %08x\n", r);
3321
3322     IXMLDOMNodeList_Release( fo_list );
3323
3324     /* invalid parameter: NULL ptr for element to remove */
3325     removed_node = (void*)0xdeadbeef;
3326     r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
3327     ok( r == E_INVALIDARG, "ret %08x\n", r );
3328     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3329
3330     /* invalid parameter: NULL for replacement element. (Sic!) */
3331     removed_node = (void*)0xdeadbeef;
3332     r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
3333     ok( r == E_INVALIDARG, "ret %08x\n", r );
3334     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
3335
3336     /* invalid parameter: OldNode is not a child */
3337     removed_node = (void*)0xdeadbeef;
3338     r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
3339     ok( r == E_INVALIDARG, "ret %08x\n", r );
3340     ok( removed_node == NULL, "%p\n", removed_node );
3341
3342     /* invalid parameter: would create loop */
3343     removed_node = (void*)0xdeadbeef;
3344     r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
3345     ok( r == E_FAIL, "ret %08x\n", r );
3346     ok( removed_node == NULL, "%p\n", removed_node );
3347
3348     r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
3349     ok( r == S_OK, "ret %08x\n", r );
3350
3351     r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
3352     ok( r == S_OK, "ret %08x\n", r );
3353
3354     /* ba_node and temp_node refer to the same node, yet they
3355        are different interface pointers */
3356     ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
3357     r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
3358     ok( r == S_OK, "ret %08x\n", r );
3359     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
3360     ok( r == S_OK, "ret %08x\n", r );
3361     todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
3362
3363     IUnknown_Release( unk1 );
3364     IUnknown_Release( unk2 );
3365
3366     /* ba_node should have been removed from below fo_node */
3367     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
3368     ok( r == S_OK, "ret %08x\n", r );
3369
3370     /* MS quirk: replaceChild also accepts elements instead of nodes */
3371     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
3372     ok( r == S_OK, "ret %08x\n", r );
3373
3374     r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
3375     ok( r == S_OK, "ret %08x\n", r );
3376
3377     r = IXMLDOMNodeList_get_length( fo_list, &len);
3378     ok( r == S_OK, "ret %08x\n", r );
3379     ok( len == 0, "len %d\n", len);
3380
3381     IXMLDOMNodeList_Release( fo_list );
3382
3383     IXMLDOMNode_Release(ba_node);
3384     IXMLDOMNode_Release(fo_node);
3385     IXMLDOMNode_Release(temp_node);
3386     IXMLDOMNodeList_Release( root_list );
3387     IXMLDOMElement_Release( element );
3388     IXMLDOMDocument_Release( doc );
3389 }
3390
3391 static void test_removeNamedItem(void)
3392 {
3393     IXMLDOMDocument *doc;
3394     IXMLDOMElement *element;
3395     IXMLDOMNode *pr_node, *removed_node, *removed_node2;
3396     IXMLDOMNodeList *root_list;
3397     IXMLDOMNamedNodeMap * pr_attrs;
3398     VARIANT_BOOL b;
3399     BSTR str;
3400     LONG len;
3401     HRESULT r;
3402
3403     doc = create_document(&IID_IXMLDOMDocument);
3404     if (!doc) return;
3405
3406     str = SysAllocString( szComplete4 );
3407     r = IXMLDOMDocument_loadXML( doc, str, &b );
3408     ok( r == S_OK, "loadXML failed\n");
3409     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3410     SysFreeString( str );
3411
3412     r = IXMLDOMDocument_get_documentElement( doc, &element );
3413     ok( r == S_OK, "ret %08x\n", r);
3414
3415     r = IXMLDOMElement_get_childNodes( element, &root_list );
3416     ok( r == S_OK, "ret %08x\n", r);
3417
3418     r = IXMLDOMNodeList_get_item( root_list, 1, &pr_node );
3419     ok( r == S_OK, "ret %08x\n", r);
3420
3421     r = IXMLDOMNode_get_attributes( pr_node, &pr_attrs );
3422     ok( r == S_OK, "ret %08x\n", r);
3423
3424     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3425     ok( r == S_OK, "ret %08x\n", r);
3426     ok( len == 3, "length %d\n", len);
3427
3428     removed_node = (void*)0xdeadbeef;
3429     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, NULL, &removed_node);
3430     ok ( r == E_INVALIDARG, "ret %08x\n", r);
3431     ok ( removed_node == (void*)0xdeadbeef, "got %p\n", removed_node);
3432
3433     removed_node = (void*)0xdeadbeef;
3434     str = SysAllocString(szvr);
3435     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node);
3436     ok ( r == S_OK, "ret %08x\n", r);
3437
3438     removed_node2 = (void*)0xdeadbeef;
3439     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node2);
3440     ok ( r == S_FALSE, "ret %08x\n", r);
3441     ok ( removed_node2 == NULL, "got %p\n", removed_node2 );
3442
3443     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3444     ok( r == S_OK, "ret %08x\n", r);
3445     ok( len == 2, "length %d\n", len);
3446
3447     r = IXMLDOMNamedNodeMap_setNamedItem( pr_attrs, removed_node, NULL);
3448     ok ( r == S_OK, "ret %08x\n", r);
3449     IXMLDOMNode_Release(removed_node);
3450
3451     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3452     ok( r == S_OK, "ret %08x\n", r);
3453     ok( len == 3, "length %d\n", len);
3454
3455     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
3456     ok ( r == S_OK, "ret %08x\n", r);
3457
3458     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
3459     ok( r == S_OK, "ret %08x\n", r);
3460     ok( len == 2, "length %d\n", len);
3461
3462     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
3463     ok ( r == S_FALSE, "ret %08x\n", r);
3464
3465     SysFreeString(str);
3466
3467     IXMLDOMNamedNodeMap_Release( pr_attrs );
3468     IXMLDOMNode_Release( pr_node );
3469     IXMLDOMNodeList_Release( root_list );
3470     IXMLDOMElement_Release( element );
3471     IXMLDOMDocument_Release( doc );
3472 }
3473
3474 static void test_XMLHTTP(void)
3475 {
3476     static const WCHAR wszBody[] = {'m','o','d','e','=','T','e','s','t',0};
3477     static const WCHAR wszPOST[] = {'P','O','S','T',0};
3478     static const WCHAR wszUrl[] = {'h','t','t','p',':','/','/',
3479         'c','r','o','s','s','o','v','e','r','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
3480         'p','o','s','t','t','e','s','t','.','p','h','p',0};
3481     static const WCHAR xmltestW[] = {'h','t','t','p',':','/','/',
3482         'c','r','o','s','s','o','v','e','r','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
3483         'x','m','l','t','e','s','t','.','x','m','l',0};
3484     static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
3485     static const CHAR xmltestbodyA[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<a>TEST</a>\n";
3486
3487     IXMLHttpRequest *pXMLHttpRequest;
3488     BSTR bstrResponse, method, url;
3489     VARIANT dummy;
3490     VARIANT async;
3491     VARIANT varbody;
3492     LONG state, status, ref, bound;
3493     void *ptr;
3494     IDispatch *event;
3495     HRESULT hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL,
3496                                   CLSCTX_INPROC_SERVER, &IID_IXMLHttpRequest,
3497                                   (void **)&pXMLHttpRequest);
3498     if (FAILED(hr))
3499     {
3500         win_skip("IXMLHTTPRequest is not available (0x%08x)\n", hr);
3501         return;
3502     }
3503
3504     VariantInit(&dummy);
3505     V_VT(&dummy) = VT_ERROR;
3506     V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
3507     VariantInit(&async);
3508     V_VT(&async) = VT_BOOL;
3509     V_BOOL(&async) = VARIANT_FALSE;
3510     V_VT(&varbody) = VT_BSTR;
3511     V_BSTR(&varbody) = SysAllocString(wszBody);
3512
3513     method = SysAllocString(wszPOST);
3514     url = SysAllocString(wszUrl);
3515
3516 if (0)
3517 {
3518     /* crashes on win98 */
3519     hr = IXMLHttpRequest_put_onreadystatechange(pXMLHttpRequest, NULL);
3520     ok(hr == S_OK, "got 0x%08x\n", hr);
3521 }
3522
3523     hr = IXMLHttpRequest_abort(pXMLHttpRequest);
3524     ok(hr == S_OK, "got 0x%08x\n", hr);
3525
3526     /* send before open */
3527     hr = IXMLHttpRequest_send(pXMLHttpRequest, dummy);
3528     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win9x, win2k */, "got 0x%08x\n", hr);
3529
3530     /* initial status code */
3531     hr = IXMLHttpRequest_get_status(pXMLHttpRequest, NULL);
3532     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3533
3534     status = 0xdeadbeef;
3535     hr = IXMLHttpRequest_get_status(pXMLHttpRequest, &status);
3536     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win9x, win2k */, "got 0x%08x\n", hr);
3537     ok(status == 0xdeadbeef, "got %d\n", status);
3538
3539     /* invalid parameters */
3540     hr = IXMLHttpRequest_open(pXMLHttpRequest, NULL, NULL, async, dummy, dummy);
3541     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3542
3543     hr = IXMLHttpRequest_open(pXMLHttpRequest, method, NULL, async, dummy, dummy);
3544     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3545
3546     hr = IXMLHttpRequest_open(pXMLHttpRequest, NULL, url, async, dummy, dummy);
3547     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3548
3549     hr = IXMLHttpRequest_setRequestHeader(pXMLHttpRequest, NULL, NULL);
3550     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3551
3552     hr = IXMLHttpRequest_setRequestHeader(pXMLHttpRequest, _bstr_("header1"), NULL);
3553     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win9x, win2k */, "got 0x%08x\n", hr);
3554
3555     hr = IXMLHttpRequest_setRequestHeader(pXMLHttpRequest, NULL, _bstr_("value1"));
3556     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3557
3558     hr = IXMLHttpRequest_setRequestHeader(pXMLHttpRequest, _bstr_("header1"), _bstr_("value1"));
3559     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win9x, win2k */, "got 0x%08x\n", hr);
3560
3561     hr = IXMLHttpRequest_get_readyState(pXMLHttpRequest, NULL);
3562     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3563
3564     state = -1;
3565     hr = IXMLHttpRequest_get_readyState(pXMLHttpRequest, &state);
3566     ok(hr == S_OK, "got 0x%08x\n", hr);
3567     ok(state == READYSTATE_UNINITIALIZED, "got %d, expected READYSTATE_UNINITIALIZED\n", state);
3568
3569     event = create_dispevent();
3570     ref = IDispatch_AddRef(event);
3571     ok(ref == 2, "got %d\n", ref);
3572     IDispatch_Release(event);
3573
3574     hr = IXMLHttpRequest_put_onreadystatechange(pXMLHttpRequest, event);
3575     ok(hr == S_OK, "got 0x%08x\n", hr);
3576
3577     ref = IDispatch_AddRef(event);
3578     ok(ref == 3, "got %d\n", ref);
3579     IDispatch_Release(event);
3580
3581     g_unexpectedcall = g_expectedcall = 0;
3582
3583     hr = IXMLHttpRequest_open(pXMLHttpRequest, method, url, async, dummy, dummy);
3584     ok(hr == S_OK, "got 0x%08x\n", hr);
3585
3586     ok(g_unexpectedcall == 0, "unexpected disp event call\n");
3587     ok(g_expectedcall == 1 || broken(g_expectedcall == 0) /* win2k */, "no expected disp event call\n");
3588
3589     /* status code after ::open() */
3590     status = 0xdeadbeef;
3591     hr = IXMLHttpRequest_get_status(pXMLHttpRequest, &status);
3592     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win9x, win2k */, "got 0x%08x\n", hr);
3593     ok(status == 0xdeadbeef, "got %d\n", status);
3594
3595     state = -1;
3596     hr = IXMLHttpRequest_get_readyState(pXMLHttpRequest, &state);
3597     ok(hr == S_OK, "got 0x%08x\n", hr);
3598     ok(state == READYSTATE_LOADING, "got %d, expected READYSTATE_LOADING\n", state);
3599
3600     hr = IXMLHttpRequest_abort(pXMLHttpRequest);
3601     ok(hr == S_OK, "got 0x%08x\n", hr);
3602
3603     state = -1;
3604     hr = IXMLHttpRequest_get_readyState(pXMLHttpRequest, &state);
3605     ok(hr == S_OK, "got 0x%08x\n", hr);
3606     ok(state == READYSTATE_UNINITIALIZED || broken(state == READYSTATE_LOADING) /* win98, win2k */,
3607         "got %d, expected READYSTATE_UNINITIALIZED\n", state);
3608
3609     hr = IXMLHttpRequest_open(pXMLHttpRequest, method, url, async, dummy, dummy);
3610     ok(hr == S_OK, "got 0x%08x\n", hr);
3611
3612     hr = IXMLHttpRequest_setRequestHeader(pXMLHttpRequest, _bstr_("header1"), _bstr_("value1"));
3613     ok(hr == S_OK, "got 0x%08x\n", hr);
3614
3615     hr = IXMLHttpRequest_setRequestHeader(pXMLHttpRequest, NULL, _bstr_("value1"));
3616     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3617
3618     hr = IXMLHttpRequest_setRequestHeader(pXMLHttpRequest, _bstr_(""), _bstr_("value1"));
3619     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3620
3621     SysFreeString(method);
3622     SysFreeString(url);
3623
3624     hr = IXMLHttpRequest_send(pXMLHttpRequest, varbody);
3625     if (hr == INET_E_RESOURCE_NOT_FOUND)
3626     {
3627         skip("No connection could be made with crossover.codeweavers.com\n");
3628         IXMLHttpRequest_Release(pXMLHttpRequest);
3629         return;
3630     }
3631     ok(hr == S_OK, "got 0x%08x\n", hr);
3632
3633     /* status code after ::send() */
3634     status = 0xdeadbeef;
3635     hr = IXMLHttpRequest_get_status(pXMLHttpRequest, &status);
3636     ok(hr == S_OK, "got 0x%08x\n", hr);
3637     ok(status == 200, "got %d\n", status);
3638
3639     /* another ::send() after completed request */
3640     hr = IXMLHttpRequest_send(pXMLHttpRequest, varbody);
3641     ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win9x, win2k */, "got 0x%08x\n", hr);
3642
3643     VariantClear(&varbody);
3644
3645     hr = IXMLHttpRequest_get_responseText(pXMLHttpRequest, &bstrResponse);
3646     ok(hr == S_OK, "got 0x%08x\n", hr);
3647     /* the server currently returns "FAILED" because the Content-Type header is
3648      * not what the server expects */
3649     if(hr == S_OK)
3650     {
3651         ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)),
3652             "expected %s, got %s\n", wine_dbgstr_w(wszExpectedResponse), wine_dbgstr_w(bstrResponse));
3653         SysFreeString(bstrResponse);
3654     }
3655
3656     /* GET request */
3657     url = SysAllocString(xmltestW);
3658
3659     hr = IXMLHttpRequest_open(pXMLHttpRequest, _bstr_("GET"), url, async, dummy, dummy);
3660     ok(hr == S_OK, "got 0x%08x\n", hr);
3661
3662     V_VT(&varbody) = VT_EMPTY;
3663
3664     hr = IXMLHttpRequest_send(pXMLHttpRequest, varbody);
3665     if (hr == INET_E_RESOURCE_NOT_FOUND)
3666     {
3667         skip("No connection could be made with crossover.codeweavers.com\n");
3668         IXMLHttpRequest_Release(pXMLHttpRequest);
3669         return;
3670     }
3671     ok(hr == S_OK, "got 0x%08x\n", hr);
3672
3673     hr = IXMLHttpRequest_get_responseText(pXMLHttpRequest, NULL);
3674     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3675
3676     hr = IXMLHttpRequest_get_responseText(pXMLHttpRequest, &bstrResponse);
3677     ok(hr == S_OK, "got 0x%08x\n", hr);
3678     if(hr == S_OK)
3679     {
3680         ok(!memcmp(bstrResponse, _bstr_(xmltestbodyA), sizeof(xmltestbodyA)*sizeof(WCHAR)),
3681             "expected %s, got %s\n", xmltestbodyA, wine_dbgstr_w(bstrResponse));
3682         SysFreeString(bstrResponse);
3683     }
3684
3685     hr = IXMLHttpRequest_get_responseBody(pXMLHttpRequest, NULL);
3686     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3687
3688     V_VT(&varbody) = VT_EMPTY;
3689     hr = IXMLHttpRequest_get_responseBody(pXMLHttpRequest, &varbody);
3690     ok(hr == S_OK, "got 0x%08x\n", hr);
3691     ok(V_VT(&varbody) == (VT_ARRAY|VT_UI1), "got type %d, expected %d\n", V_VT(&varbody), VT_ARRAY|VT_UI1);
3692     ok(SafeArrayGetDim(V_ARRAY(&varbody)) == 1, "got %d, expected one dimension\n", SafeArrayGetDim(V_ARRAY(&varbody)));
3693
3694     bound = -1;
3695     hr = SafeArrayGetLBound(V_ARRAY(&varbody), 1, &bound);
3696     ok(hr == S_OK, "got 0x%08x\n", hr);
3697     ok(bound == 0, "got %d, expected zero bound\n", bound);
3698
3699     hr = SafeArrayAccessData(V_ARRAY(&varbody), &ptr);
3700     ok(hr == S_OK, "got 0x%08x\n", hr);
3701     ok(memcmp(ptr, xmltestbodyA, sizeof(xmltestbodyA)-1) == 0, "got wrond body data\n");
3702     SafeArrayUnaccessData(V_ARRAY(&varbody));
3703
3704     VariantClear(&varbody);
3705
3706     SysFreeString(url);
3707
3708     IDispatch_Release(event);
3709     IXMLHttpRequest_Release(pXMLHttpRequest);
3710     free_bstrs();
3711 }
3712
3713 static void test_IXMLDOMDocument2(void)
3714 {
3715     static const WCHAR emptyW[] = {0};
3716     IXMLDOMDocument2 *doc2, *dtddoc2;
3717     IXMLDOMDocument *doc;
3718     IXMLDOMParseError* err;
3719     IDispatchEx *dispex;
3720     VARIANT_BOOL b;
3721     VARIANT var;
3722     HRESULT r;
3723     LONG ref, res;
3724     BSTR str;
3725
3726     doc = create_document(&IID_IXMLDOMDocument);
3727     if (!doc) return;
3728
3729     dtddoc2 = create_document(&IID_IXMLDOMDocument2);
3730     if (!dtddoc2)
3731     {
3732         IXMLDOMDocument_Release(doc);
3733         return;
3734     }
3735
3736     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
3737     ok( r == S_OK, "ret %08x\n", r );
3738     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
3739
3740     ole_expect(IXMLDOMDocument2_get_readyState(doc2, NULL), E_INVALIDARG);
3741     ole_check(IXMLDOMDocument2_get_readyState(doc2, &res));
3742     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
3743
3744     err = NULL;
3745     ole_expect(IXMLDOMDocument2_validate(doc2, NULL), S_FALSE);
3746     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
3747     ok(err != NULL, "expected a pointer\n");
3748     if (err)
3749     {
3750         res = 0;
3751         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3752         /* XML_E_NOTWF */
3753         ok(res == E_XML_NOTWF, "got %08x\n", res);
3754         IXMLDOMParseError_Release(err);
3755     }
3756
3757     str = SysAllocString( szComplete4 );
3758     r = IXMLDOMDocument_loadXML( doc2, str, &b );
3759     ok( r == S_OK, "loadXML failed\n");
3760     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3761     SysFreeString( str );
3762
3763     ole_check(IXMLDOMDocument2_get_readyState(doc, &res));
3764     ok(res == READYSTATE_COMPLETE, "expected READYSTATE_COMPLETE (4), got %i\n", res);
3765
3766     err = NULL;
3767     ole_expect(IXMLDOMDocument2_validate(doc2, &err), S_FALSE);
3768     ok(err != NULL, "expected a pointer\n");
3769     if (err)
3770     {
3771         res = 0;
3772         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3773         /* XML_E_NODTD */
3774         ok(res == E_XML_NODTD, "got %08x\n", res);
3775         IXMLDOMParseError_Release(err);
3776     }
3777
3778     r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
3779     ok( r == S_OK, "ret %08x\n", r );
3780     if(r == S_OK)
3781     {
3782         IDispatchEx_Release(dispex);
3783     }
3784
3785     /* we will check if the variant got cleared */
3786     ref = IXMLDOMDocument2_AddRef(doc2);
3787     expect_eq(ref, 3, int, "%d");  /* doc, doc2, AddRef*/
3788     V_VT(&var) = VT_UNKNOWN;
3789     V_UNKNOWN(&var) = (IUnknown *)doc2;
3790
3791     /* invalid calls */
3792     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
3793     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
3794     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
3795
3796     /* valid call */
3797     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
3798     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
3799     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
3800     V_VT(&var) = VT_R4;
3801
3802     /* the variant didn't get cleared*/
3803     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
3804
3805     /* setProperty tests */
3806     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
3807     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
3808     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
3809     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
3810     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
3811     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
3812
3813     V_VT(&var) = VT_BSTR;
3814     V_BSTR(&var) = SysAllocString(emptyW);
3815     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
3816     ok(r == S_OK, "got 0x%08x\n", r);
3817     VariantClear(&var);
3818
3819     V_VT(&var) = VT_I2;
3820     V_I2(&var) = 0;
3821     r = IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionNamespaces"), var);
3822     ok(r == E_FAIL, "got 0x%08x\n", r);
3823
3824     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
3825     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
3826     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
3827     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
3828
3829     IXMLDOMDocument2_Release( doc2 );
3830     IXMLDOMDocument_Release( doc );
3831
3832     /* DTD validation */
3833     ole_check(IXMLDOMDocument2_put_validateOnParse(dtddoc2, VARIANT_FALSE));
3834     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML), &b));
3835     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3836     err = NULL;
3837     ole_check(IXMLDOMDocument2_validate(dtddoc2, &err));
3838     ok(err != NULL, "expected pointer\n");
3839     if (err)
3840     {
3841         res = 0;
3842         ole_expect(IXMLDOMParseError_get_errorCode(err, &res), S_FALSE);
3843         ok(res == 0, "got %08x\n", res);
3844         IXMLDOMParseError_Release(err);
3845     }
3846
3847     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0D), &b));
3848     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3849     err = NULL;
3850     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3851     ok(err != NULL, "expected pointer\n");
3852     if (err)
3853     {
3854         res = 0;
3855         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3856         /* XML_ELEMENT_UNDECLARED */
3857         todo_wine ok(res == 0xC00CE00D, "got %08x\n", res);
3858         IXMLDOMParseError_Release(err);
3859     }
3860
3861     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_0E), &b));
3862     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3863     err = NULL;
3864     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3865     ok(err != NULL, "expected pointer\n");
3866     if (err)
3867     {
3868         res = 0;
3869         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3870         /* XML_ELEMENT_ID_NOT_FOUND */
3871         todo_wine ok(res == 0xC00CE00E, "got %08x\n", res);
3872         IXMLDOMParseError_Release(err);
3873     }
3874
3875     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_11), &b));
3876     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3877     err = NULL;
3878     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3879     ok(err != NULL, "expected pointer\n");
3880     if (err)
3881     {
3882         res = 0;
3883         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3884         /* XML_EMPTY_NOT_ALLOWED */
3885         todo_wine ok(res == 0xC00CE011, "got %08x\n", res);
3886         IXMLDOMParseError_Release(err);
3887     }
3888
3889     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_13), &b));
3890     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3891     err = NULL;
3892     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3893     ok(err != NULL, "expected pointer\n");
3894     if (err)
3895     {
3896         res = 0;
3897         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3898         /* XML_ROOT_NAME_MISMATCH */
3899         todo_wine ok(res == 0xC00CE013, "got %08x\n", res);
3900         IXMLDOMParseError_Release(err);
3901     }
3902
3903     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_14), &b));
3904     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3905     err = NULL;
3906     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3907     ok(err != NULL, "expected pointer\n");
3908     if (err)
3909     {
3910         res = 0;
3911         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3912         /* XML_INVALID_CONTENT */
3913         todo_wine ok(res == 0xC00CE014, "got %08x\n", res);
3914         IXMLDOMParseError_Release(err);
3915     }
3916
3917     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_15), &b));
3918     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3919     err = NULL;
3920     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3921     ok(err != NULL, "expected pointer\n");
3922     if (err)
3923     {
3924         res = 0;
3925         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3926         /* XML_ATTRIBUTE_NOT_DEFINED */
3927         todo_wine ok(res == 0xC00CE015, "got %08x\n", res);
3928         IXMLDOMParseError_Release(err);
3929     }
3930
3931     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_16), &b));
3932     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3933     err = NULL;
3934     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3935     ok(err != NULL, "expected pointer\n");
3936     if (err)
3937     {
3938         res = 0;
3939         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3940         /* XML_ATTRIBUTE_FIXED */
3941         todo_wine ok(res == 0xC00CE016, "got %08x\n", res);
3942         IXMLDOMParseError_Release(err);
3943     }
3944
3945     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_17), &b));
3946     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3947     err = NULL;
3948     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3949     ok(err != NULL, "expected pointer\n");
3950     if (err)
3951     {
3952         res = 0;
3953         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3954         /* XML_ATTRIBUTE_VALUE */
3955         todo_wine ok(res == 0xC00CE017, "got %08x\n", res);
3956         IXMLDOMParseError_Release(err);
3957     }
3958
3959     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_18), &b));
3960     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3961     err = NULL;
3962     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3963     ok(err != NULL, "expected pointer\n");
3964     if (err)
3965     {
3966         res = 0;
3967         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3968         /* XML_ILLEGAL_TEXT */
3969         todo_wine ok(res == 0xC00CE018, "got %08x\n", res);
3970         IXMLDOMParseError_Release(err);
3971     }
3972
3973     ole_check(IXMLDOMDocument2_loadXML(dtddoc2, _bstr_(szEmailXML_20), &b));
3974     ok( b == VARIANT_TRUE, "failed to load XML string\n");
3975     err = NULL;
3976     ole_expect(IXMLDOMDocument2_validate(dtddoc2, &err), S_FALSE);
3977     ok(err != NULL, "expected pointer\n");
3978     if (err)
3979     {
3980         res = 0;
3981         ole_check(IXMLDOMParseError_get_errorCode(err, &res));
3982         /* XML_REQUIRED_ATTRIBUTE_MISSING */
3983         todo_wine ok(res == 0xC00CE020, "got %08x\n", res);
3984         IXMLDOMParseError_Release(err);
3985     }
3986
3987     IXMLDOMDocument2_Release( dtddoc2 );
3988     free_bstrs();
3989 }
3990
3991 #define helper_ole_check(expr) { \
3992     HRESULT r = expr; \
3993     ok_(__FILE__, line)(r == S_OK, "=> %i: " #expr " returned %08x\n", __LINE__, r); \
3994 }
3995
3996 #define helper_expect_list_and_release(list, expstr) { \
3997     char *str = list_to_string(list); \
3998     ok_(__FILE__, line)(strcmp(str, expstr)==0, "=> %i: Invalid node list: %s, expected %s\n", __LINE__, str, expstr); \
3999     if (list) IXMLDOMNodeList_Release(list); \
4000 }
4001
4002 #define helper_expect_bstr_and_release(bstr, str) { \
4003     ok_(__FILE__, line)(lstrcmpW(bstr, _bstr_(str)) == 0, \
4004        "=> %i: got %s\n", __LINE__, wine_dbgstr_w(bstr)); \
4005     SysFreeString(bstr); \
4006 }
4007
4008 #define check_ws_ignored(doc, str) _check_ws_ignored(__LINE__, doc, str)
4009 static inline void _check_ws_ignored(int line, IXMLDOMDocument2* doc, char const* str)
4010 {
4011     IXMLDOMNode *node1, *node2;
4012     IXMLDOMNodeList *list;
4013     BSTR bstr;
4014
4015     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4016     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
4017     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
4018     helper_ole_check(IXMLDOMNodeList_reset(list));
4019     helper_expect_list_and_release(list, "E1.E4.E1.E2.D1 E2.E4.E1.E2.D1");
4020
4021     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
4022     helper_expect_list_and_release(list, "T1.E1.E4.E1.E2.D1 E2.E1.E4.E1.E2.D1 E3.E1.E4.E1.E2.D1 T4.E1.E4.E1.E2.D1 E5.E1.E4.E1.E2.D1");
4023     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
4024     if (str)
4025     {
4026         helper_expect_bstr_and_release(bstr, str);
4027     }
4028     else
4029     {
4030         helper_expect_bstr_and_release(bstr, "This is a description.");
4031     }
4032     IXMLDOMNode_Release(node1);
4033
4034     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
4035     helper_expect_list_and_release(list, "T1.E2.E4.E1.E2.D1 E2.E2.E4.E1.E2.D1 T3.E2.E4.E1.E2.D1 E4.E2.E4.E1.E2.D1 T5.E2.E4.E1.E2.D1 E6.E2.E4.E1.E2.D1 T7.E2.E4.E1.E2.D1");
4036     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
4037     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
4038     IXMLDOMNode_Release(node2);
4039 }
4040
4041 #define check_ws_preserved(doc, str) _check_ws_preserved(__LINE__, doc, str)
4042 static inline void _check_ws_preserved(int line, IXMLDOMDocument2* doc, char const* str)
4043 {
4044     IXMLDOMNode *node1, *node2;
4045     IXMLDOMNodeList *list;
4046     BSTR bstr;
4047
4048     helper_ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//*[local-name()='html']"), &list));
4049     helper_ole_check(IXMLDOMNodeList_get_item(list, 0, &node1));
4050     helper_ole_check(IXMLDOMNodeList_get_item(list, 1, &node2));
4051     helper_ole_check(IXMLDOMNodeList_reset(list));
4052     helper_expect_list_and_release(list, "E2.E8.E2.E2.D1 E4.E8.E2.E2.D1");
4053
4054     helper_ole_check(IXMLDOMNode_get_childNodes(node1, &list));
4055     helper_expect_list_and_release(list, "T1.E2.E8.E2.E2.D1 E2.E2.E8.E2.E2.D1 T3.E2.E8.E2.E2.D1 E4.E2.E8.E2.E2.D1 T5.E2.E8.E2.E2.D1 E6.E2.E8.E2.E2.D1 T7.E2.E8.E2.E2.D1");
4056     helper_ole_check(IXMLDOMNode_get_text(node1, &bstr));
4057     if (str)
4058     {
4059         helper_expect_bstr_and_release(bstr, str);
4060     }
4061     else
4062     {
4063         helper_expect_bstr_and_release(bstr, "\n                This is a description. \n            ");
4064     }
4065     IXMLDOMNode_Release(node1);
4066
4067     helper_ole_check(IXMLDOMNode_get_childNodes(node2, &list));
4068     helper_expect_list_and_release(list, "T1.E4.E8.E2.E2.D1 E2.E4.E8.E2.E2.D1 T3.E4.E8.E2.E2.D1 E4.E4.E8.E2.E2.D1 T5.E4.E8.E2.E2.D1 E6.E4.E8.E2.E2.D1 T7.E4.E8.E2.E2.D1");
4069     helper_ole_check(IXMLDOMNode_get_text(node2, &bstr));
4070     helper_expect_bstr_and_release(bstr, "\n                This is a description with preserved whitespace. \n            ");
4071     IXMLDOMNode_Release(node2);
4072 }
4073
4074 static void test_whitespace(void)
4075 {
4076     VARIANT_BOOL b;
4077     IXMLDOMDocument2 *doc1, *doc2, *doc3, *doc4;
4078
4079     doc1 = create_document(&IID_IXMLDOMDocument2);
4080     doc2 = create_document(&IID_IXMLDOMDocument2);
4081     if (!doc1 || !doc2) return;
4082
4083     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_TRUE));
4084     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4085     ok(b == VARIANT_FALSE, "expected false\n");
4086     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4087     ok(b == VARIANT_TRUE, "expected true\n");
4088
4089     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4090     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4091     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4092     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4093
4094     /* switch to XPath */
4095     ole_check(IXMLDOMDocument2_setProperty(doc1, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4096     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4097
4098     check_ws_ignored(doc1, NULL);
4099     check_ws_preserved(doc2, NULL);
4100
4101     /* new instances copy the property */
4102     ole_check(IXMLDOMDocument2_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**) &doc3));
4103     ole_check(IXMLDOMDocument2_QueryInterface(doc2, &IID_IXMLDOMDocument2, (void**) &doc4));
4104
4105     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4106     ok(b == VARIANT_FALSE, "expected false\n");
4107     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4108     ok(b == VARIANT_TRUE, "expected true\n");
4109
4110     check_ws_ignored(doc3, NULL);
4111     check_ws_preserved(doc4, NULL);
4112
4113     /* setting after loading xml affects trimming of leading/trailing ws only */
4114     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc1, VARIANT_TRUE));
4115     ole_check(IXMLDOMDocument2_put_preserveWhiteSpace(doc2, VARIANT_FALSE));
4116
4117     /* the trailing "\n            " isn't there, because it was ws-only node */
4118     check_ws_ignored(doc1, "\n                This is a description. ");
4119     check_ws_preserved(doc2, "This is a description.");
4120
4121     /* it takes effect on reload */
4122     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc1, &b));
4123     ok(b == VARIANT_TRUE, "expected true\n");
4124     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc2, &b));
4125     ok(b == VARIANT_FALSE, "expected false\n");
4126
4127     ole_check(IXMLDOMDocument2_loadXML(doc1, _bstr_(szExampleXML), &b));
4128     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4129     ole_check(IXMLDOMDocument2_loadXML(doc2, _bstr_(szExampleXML), &b));
4130     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4131
4132     check_ws_preserved(doc1, NULL);
4133     check_ws_ignored(doc2, NULL);
4134
4135     /* other instances follow suit */
4136     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc3, &b));
4137     ok(b == VARIANT_TRUE, "expected true\n");
4138     ole_check(IXMLDOMDocument2_get_preserveWhiteSpace(doc4, &b));
4139     ok(b == VARIANT_FALSE, "expected false\n");
4140
4141     check_ws_preserved(doc3, NULL);
4142     check_ws_ignored(doc4, NULL);
4143
4144     IXMLDOMDocument_Release(doc1);
4145     IXMLDOMDocument_Release(doc2);
4146     IXMLDOMDocument_Release(doc3);
4147     IXMLDOMDocument_Release(doc4);
4148     free_bstrs();
4149 }
4150
4151 static void test_XPath(void)
4152 {
4153     VARIANT var;
4154     VARIANT_BOOL b;
4155     IXMLDOMDocument2 *doc;
4156     IXMLDOMNode *rootNode;
4157     IXMLDOMNode *elem1Node;
4158     IXMLDOMNode *node;
4159     IXMLDOMNodeList *list;
4160
4161     doc = create_document(&IID_IXMLDOMDocument2);
4162     if (!doc) return;
4163
4164     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b));
4165     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4166
4167     /* switch to XPath */
4168     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
4169
4170     /* some simple queries*/
4171     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list));
4172     ole_check(IXMLDOMNodeList_get_item(list, 0, &rootNode));
4173     ole_check(IXMLDOMNodeList_reset(list));
4174     expect_list_and_release(list, "E2.D1");
4175     if (rootNode == NULL)
4176         return;
4177
4178     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//c"), &list));
4179     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
4180
4181     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//c[@type]"), &list));
4182     expect_list_and_release(list, "E3.E2.E2.D1");
4183
4184     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
4185     /* using get_item for query results advances the position */
4186     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
4187     expect_node(node, "E2.E2.D1");
4188     IXMLDOMNode_Release(node);
4189     ole_check(IXMLDOMNodeList_nextNode(list, &node));
4190     expect_node(node, "E4.E2.D1");
4191     IXMLDOMNode_Release(node);
4192     ole_check(IXMLDOMNodeList_reset(list));
4193     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
4194
4195     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
4196     expect_list_and_release(list, "E2.D1");
4197
4198     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
4199     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
4200     ole_check(IXMLDOMNodeList_reset(list));
4201     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
4202
4203     /* select an attribute */
4204     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
4205     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
4206
4207     /* would evaluate to a number */
4208     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
4209     /* would evaluate to a boolean */
4210     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
4211     /* would evaluate to a string */
4212     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
4213
4214     /* no results */
4215     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
4216     expect_list_and_release(list, "");
4217     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("elem//c"), &list));
4218     expect_list_and_release(list, "");
4219     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//elem[4]"), &list));
4220     expect_list_and_release(list, "");
4221     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//elem[0]"), &list));
4222     expect_list_and_release(list, "");
4223
4224     /* foo undeclared in document node */
4225     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4226     /* undeclared in <root> node */
4227     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
4228     /* undeclared in <elem> node */
4229     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
4230     /* but this trick can be used */
4231     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
4232     expect_list_and_release(list, "E3.E4.E2.D1");
4233
4234     /* it has to be declared in SelectionNamespaces */
4235     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4236         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
4237
4238     /* now the namespace can be used */
4239     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//test:c"), &list));
4240     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4241     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
4242     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4243     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
4244     expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
4245     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
4246     expect_list_and_release(list, "E5.E1.E4.E1.E2.D1 E6.E2.E4.E1.E2.D1");
4247
4248     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
4249     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4250         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
4251
4252     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4253
4254     VariantInit(&var);
4255     ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
4256     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
4257     if (V_VT(&var) == VT_BSTR)
4258         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
4259
4260     /* extra attributes - same thing*/
4261     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
4262         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
4263     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
4264
4265     IXMLDOMNode_Release(rootNode);
4266     IXMLDOMNode_Release(elem1Node);
4267     IXMLDOMDocument_Release(doc);
4268     free_bstrs();
4269 }
4270
4271 static void test_cloneNode(void )
4272 {
4273     IXMLDOMDocument *doc;
4274     VARIANT_BOOL b;
4275     IXMLDOMNodeList *pList;
4276     IXMLDOMNamedNodeMap *mapAttr;
4277     LONG nLength = 0, nLength1 = 0;
4278     LONG nAttrCnt = 0, nAttrCnt1 = 0;
4279     IXMLDOMNode *node;
4280     IXMLDOMNode *node_clone;
4281     IXMLDOMNode *node_first;
4282     HRESULT r;
4283     BSTR str;
4284     static const WCHAR szSearch[] = { 'l', 'c', '/', 'p', 'r', 0 };
4285
4286     doc = create_document(&IID_IXMLDOMDocument);
4287     if (!doc) return;
4288
4289     str = SysAllocString( szComplete4 );
4290     ole_check(IXMLDOMDocument_loadXML(doc, str, &b));
4291     ok(b == VARIANT_TRUE, "failed to load XML string\n");
4292     SysFreeString(str);
4293
4294     if(!b)
4295         return;
4296
4297     str = SysAllocString( szSearch);
4298     r = IXMLDOMNode_selectSingleNode(doc, str, &node);
4299     ok( r == S_OK, "ret %08x\n", r );
4300     ok( node != NULL, "node %p\n", node );
4301     SysFreeString(str);
4302
4303     if(!node)
4304     {
4305         IXMLDOMDocument_Release(doc);
4306         return;
4307     }
4308
4309     /* Check invalid parameter */
4310     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
4311     ok( r == E_INVALIDARG, "ret %08x\n", r );
4312
4313     /* All Children */
4314     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
4315     ok( r == S_OK, "ret %08x\n", r );
4316     ok( node_clone != NULL, "node %p\n", node );
4317
4318     if(!node_clone)
4319     {
4320         IXMLDOMDocument_Release(doc);
4321         IXMLDOMNode_Release(node);
4322         return;
4323     }
4324
4325     r = IXMLDOMNode_get_firstChild(node_clone, &node_first);
4326     ok( r == S_OK, "ret %08x\n", r );
4327     if(r == S_OK)
4328     {
4329         IXMLDOMDocument *doc2;
4330
4331         r = IXMLDOMNode_get_ownerDocument(node_clone, &doc2);
4332         ok( r == S_OK, "ret %08x\n", r );
4333         if(r == S_OK)
4334             IXMLDOMDocument_Release(doc2);
4335
4336         IXMLDOMNode_Release(node_first);
4337     }
4338
4339     r = IXMLDOMNode_get_childNodes(node, &pList);
4340     ok( r == S_OK, "ret %08x\n", r );
4341     if (pList)
4342         {
4343                 IXMLDOMNodeList_get_length(pList, &nLength);
4344                 IXMLDOMNodeList_Release(pList);
4345         }
4346
4347     r = IXMLDOMNode_get_attributes(node, &mapAttr);
4348     ok( r == S_OK, "ret %08x\n", r );
4349     if(mapAttr)
4350     {
4351         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt);
4352         IXMLDOMNamedNodeMap_Release(mapAttr);
4353     }
4354
4355     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
4356     ok( r == S_OK, "ret %08x\n", r );
4357     if (pList)
4358         {
4359                 IXMLDOMNodeList_get_length(pList, &nLength1);
4360                 IXMLDOMNodeList_Release(pList);
4361         }
4362
4363     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
4364     ok( r == S_OK, "ret %08x\n", r );
4365     if(mapAttr)
4366     {
4367         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
4368         IXMLDOMNamedNodeMap_Release(mapAttr);
4369     }
4370
4371     ok(nLength == nLength1, "wrong Child count (%d, %d)\n", nLength, nLength1);
4372     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%d, %d)\n", nAttrCnt, nAttrCnt1);
4373     IXMLDOMNode_Release(node_clone);
4374
4375     /* No Children */
4376     r = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
4377     ok( r == S_OK, "ret %08x\n", r );
4378     ok( node_clone != NULL, "node %p\n", node );
4379
4380     if(!node_clone)
4381     {
4382         IXMLDOMDocument_Release(doc);
4383         IXMLDOMNode_Release(node);
4384         return;
4385     }
4386
4387     r = IXMLDOMNode_get_firstChild(node_clone, &node_first);
4388     ok( r == S_FALSE, "ret %08x\n", r );
4389     if(r == S_OK)
4390     {
4391         IXMLDOMDocument *doc2;
4392
4393         r = IXMLDOMNode_get_ownerDocument(node_clone, &doc2);
4394         ok( r == S_OK, "ret %08x\n", r );
4395         if(r == S_OK)
4396             IXMLDOMDocument_Release(doc2);
4397
4398         IXMLDOMNode_Release(node_first);
4399     }
4400
4401     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
4402     ok( r == S_OK, "ret %08x\n", r );
4403     if (pList)
4404     {
4405         IXMLDOMNodeList_get_length(pList, &nLength1);
4406         ok( nLength1 == 0, "Length should be 0 (%d)\n", nLength1);
4407         IXMLDOMNodeList_Release(pList);
4408     }
4409
4410     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
4411     ok( r == S_OK, "ret %08x\n", r );
4412     if(mapAttr)
4413     {
4414         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
4415         ok( nAttrCnt1 == 3, "Attribute count should be 3 (%d)\n", nAttrCnt1);
4416         IXMLDOMNamedNodeMap_Release(mapAttr);
4417     }
4418
4419     ok(nLength != nLength1, "wrong Child count (%d, %d)\n", nLength, nLength1);
4420     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%d, %d)\n", nAttrCnt, nAttrCnt1);
4421     IXMLDOMNode_Release(node_clone);
4422
4423
4424     IXMLDOMNode_Release(node);
4425     IXMLDOMDocument_Release(doc);
4426 }
4427
4428 static void test_xmlTypes(void)
4429 {
4430     IXMLDOMDocument *doc;
4431     IXMLDOMElement *pRoot;
4432     HRESULT hr;
4433     IXMLDOMComment *pComment;
4434     IXMLDOMElement *pElement;
4435     IXMLDOMAttribute *pAttribute;
4436     IXMLDOMNamedNodeMap *pAttribs;
4437     IXMLDOMCDATASection *pCDataSec;
4438     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
4439     IXMLDOMDocumentFragment *pDocFrag = NULL;
4440     IXMLDOMEntityReference *pEntityRef = NULL;
4441     BSTR str;
4442     IXMLDOMNode *pNextChild;
4443     VARIANT v;
4444     LONG len = 0;
4445
4446     doc = create_document(&IID_IXMLDOMDocument);
4447     if (!doc) return;
4448
4449     pNextChild = (void*)0xdeadbeef;
4450     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
4451     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4452
4453     pNextChild = (void*)0xdeadbeef;
4454     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
4455     ok(hr == S_FALSE, "ret %08x\n", hr );
4456     ok(pNextChild == NULL, "pDocChild not NULL\n");
4457
4458     /* test previous Sibling */
4459     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
4460     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4461
4462     pNextChild = (void*)0xdeadbeef;
4463     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
4464     ok(hr == S_FALSE, "ret %08x\n", hr );
4465     ok(pNextChild == NULL, "pNextChild not NULL\n");
4466
4467     /* test get_attributes */
4468     hr = IXMLDOMDocument_get_attributes( doc, NULL );
4469     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
4470
4471     pAttribs = (void*)0xdeadbeef;
4472     hr = IXMLDOMDocument_get_attributes( doc, &pAttribs);
4473     ok(hr == S_FALSE, "ret %08x\n", hr );
4474     ok( pAttribs == NULL, "pAttribs not NULL\n");
4475
4476     /* test get_dataType */
4477     V_VT(&v) = VT_EMPTY;
4478     hr = IXMLDOMDocument_get_dataType(doc, &v);
4479     ok(hr == S_FALSE, "ret %08x\n", hr );
4480     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
4481     VariantClear(&v);
4482
4483     /* test nodeTypeString */
4484     str = NULL;
4485     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
4486     ok(hr == S_OK, "ret %08x\n", hr );
4487     ok( !lstrcmpW( str, _bstr_("document") ), "incorrect nodeTypeString string\n");
4488     SysFreeString(str);
4489
4490     /* test implementation */
4491     hr = IXMLDOMDocument_get_implementation(doc, NULL);
4492     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4493
4494     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
4495     ok(hr == S_OK, "ret %08x\n", hr );
4496     if(hr == S_OK)
4497     {
4498         VARIANT_BOOL hasFeature = VARIANT_TRUE;
4499         BSTR sEmpty = SysAllocStringLen(NULL, 0);
4500
4501         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
4502         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4503
4504         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
4505         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4506
4507         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
4508         ok(hr == S_OK, "ret %08x\n", hr );
4509         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4510
4511         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
4512         ok(hr == S_OK, "ret %08x\n", hr );
4513         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
4514
4515         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
4516         ok(hr == S_OK, "ret %08x\n", hr );
4517         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
4518
4519         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
4520         ok(hr == S_OK, "ret %08x\n", hr );
4521         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4522
4523         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
4524         ok(hr == S_OK, "ret %08x\n", hr );
4525         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4526
4527         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
4528         ok(hr == S_OK, "ret %08x\n", hr );
4529         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4530
4531         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
4532         ok(hr == S_OK, "ret %08x\n", hr );
4533         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
4534
4535         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
4536         ok(hr == S_OK, "ret %08x\n", hr );
4537         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
4538
4539         SysFreeString(sEmpty);
4540         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
4541     }
4542
4543     pRoot = (IXMLDOMElement*)0x1;
4544     hr = IXMLDOMDocument_createElement(doc, NULL, &pRoot);
4545     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4546     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
4547
4548     pRoot = (IXMLDOMElement*)0x1;
4549     hr = IXMLDOMDocument_createElement(doc, _bstr_(""), &pRoot);
4550     ok(hr == E_FAIL, "ret %08x\n", hr );
4551     ok(pRoot == (void*)0x1, "Expect same ptr, got %p\n", pRoot);
4552
4553     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
4554     ok(hr == S_OK, "ret %08x\n", hr );
4555     if(hr == S_OK)
4556     {
4557         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
4558         ok(hr == S_OK, "ret %08x\n", hr );
4559         if(hr == S_OK)
4560         {
4561             /* Comment */
4562             str = SysAllocString(szComment);
4563             hr = IXMLDOMDocument_createComment(doc, str, &pComment);
4564             SysFreeString(str);
4565             ok(hr == S_OK, "ret %08x\n", hr );
4566             if(hr == S_OK)
4567             {
4568                 /* test get_attributes */
4569                 hr = IXMLDOMComment_get_attributes( pComment, NULL );
4570                 ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
4571
4572                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
4573                 hr = IXMLDOMComment_get_attributes( pComment, &pAttribs);
4574                 ok(hr == S_FALSE, "ret %08x\n", hr );
4575                 ok( pAttribs == NULL, "pAttribs not NULL\n");
4576
4577                 /* test nodeTypeString */
4578                 hr = IXMLDOMComment_get_nodeTypeString(pComment, &str);
4579                 ok(hr == S_OK, "ret %08x\n", hr );
4580                 ok( !lstrcmpW( str, _bstr_("comment") ), "incorrect nodeTypeString string\n");
4581                 SysFreeString(str);
4582
4583                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
4584                 ok(hr == S_OK, "ret %08x\n", hr );
4585
4586                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
4587                 ok(hr == S_OK, "ret %08x\n", hr );
4588                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
4589                 SysFreeString(str);
4590
4591                 hr = IXMLDOMComment_get_xml(pComment, &str);
4592                 ok(hr == S_OK, "ret %08x\n", hr );
4593                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
4594                 SysFreeString(str);
4595
4596                 hr = IXMLDOMComment_get_dataType(pComment, &v);
4597                 ok(hr == S_FALSE, "ret %08x\n", hr );
4598                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
4599                 VariantClear(&v);
4600
4601                 /* put data Tests */
4602                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
4603                 ok(hr == S_OK, "ret %08x\n", hr );
4604
4605                 /* get data Tests */
4606                 hr = IXMLDOMComment_get_data(pComment, &str);
4607                 ok(hr == S_OK, "ret %08x\n", hr );
4608                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
4609                 SysFreeString(str);
4610
4611                 /* get data Tests */
4612                 hr = IXMLDOMComment_get_nodeValue(pComment, &v);
4613                 ok(hr == S_OK, "ret %08x\n", hr );
4614                 ok( V_VT(&v) == VT_BSTR, "incorrect dataType type\n");
4615                 ok( !lstrcmpW( V_BSTR(&v), _bstr_("This &is a ; test <>\\") ), "incorrect get_nodeValue string\n");
4616                 VariantClear(&v);
4617
4618                 /* Confirm XML text is good */
4619                 hr = IXMLDOMComment_get_xml(pComment, &str);
4620                 ok(hr == S_OK, "ret %08x\n", hr );
4621                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
4622                 SysFreeString(str);
4623
4624                 /* Confirm we get the put_data Text back */
4625                 hr = IXMLDOMComment_get_text(pComment, &str);
4626                 ok(hr == S_OK, "ret %08x\n", hr );
4627                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
4628                 SysFreeString(str);
4629
4630                 /* test length property */
4631                 hr = IXMLDOMComment_get_length(pComment, &len);
4632                 ok(hr == S_OK, "ret %08x\n", hr );
4633                 ok(len == 21, "expected 21 got %d\n", len);
4634
4635                 /* test substringData */
4636                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
4637                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4638
4639                 /* test substringData - Invalid offset */
4640                 str = (BSTR)&szElement;
4641                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
4642                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4643                 ok( str == NULL, "incorrect string\n");
4644
4645                 /* test substringData - Invalid offset */
4646                 str = (BSTR)&szElement;
4647                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
4648                 ok(hr == S_FALSE, "ret %08x\n", hr );
4649                 ok( str == NULL, "incorrect string\n");
4650
4651                 /* test substringData - Invalid size */
4652                 str = (BSTR)&szElement;
4653                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
4654                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4655                 ok( str == NULL, "incorrect string\n");
4656
4657                 /* test substringData - Invalid size */
4658                 str = (BSTR)&szElement;
4659                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
4660                 ok(hr == S_FALSE, "ret %08x\n", hr );
4661                 ok( str == NULL, "incorrect string\n");
4662
4663                 /* test substringData - Start of string */
4664                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
4665                 ok(hr == S_OK, "ret %08x\n", hr );
4666                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
4667                 SysFreeString(str);
4668
4669                 /* test substringData - Middle of string */
4670                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
4671                 ok(hr == S_OK, "ret %08x\n", hr );
4672                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
4673                 SysFreeString(str);
4674
4675                 /* test substringData - End of string */
4676                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
4677                 ok(hr == S_OK, "ret %08x\n", hr );
4678                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
4679                 SysFreeString(str);
4680
4681                 /* test appendData */
4682                 hr = IXMLDOMComment_appendData(pComment, NULL);
4683                 ok(hr == S_OK, "ret %08x\n", hr );
4684
4685                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
4686                 ok(hr == S_OK, "ret %08x\n", hr );
4687
4688                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
4689                 ok(hr == S_OK, "ret %08x\n", hr );
4690
4691                 hr = IXMLDOMComment_get_text(pComment, &str);
4692                 ok(hr == S_OK, "ret %08x\n", hr );
4693                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4694                 SysFreeString(str);
4695
4696                 /* test insertData */
4697                 str = SysAllocStringLen(NULL, 0);
4698                 hr = IXMLDOMComment_insertData(pComment, -1, str);
4699                 ok(hr == S_OK, "ret %08x\n", hr );
4700
4701                 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
4702                 ok(hr == S_OK, "ret %08x\n", hr );
4703
4704                 hr = IXMLDOMComment_insertData(pComment, 1000, str);
4705                 ok(hr == S_OK, "ret %08x\n", hr );
4706
4707                 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
4708                 ok(hr == S_OK, "ret %08x\n", hr );
4709
4710                 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
4711                 ok(hr == S_OK, "ret %08x\n", hr );
4712
4713                 hr = IXMLDOMComment_insertData(pComment, 0, str);
4714                 ok(hr == S_OK, "ret %08x\n", hr );
4715                 SysFreeString(str);
4716
4717                 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
4718                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4719
4720                 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
4721                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4722
4723                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
4724                 ok(hr == S_OK, "ret %08x\n", hr );
4725
4726                 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
4727                 ok(hr == S_OK, "ret %08x\n", hr );
4728
4729                 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
4730                 ok(hr == S_OK, "ret %08x\n", hr );
4731
4732                 hr = IXMLDOMComment_get_text(pComment, &str);
4733                 ok(hr == S_OK, "ret %08x\n", hr );
4734                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4735                 SysFreeString(str);
4736
4737                 /* delete data */
4738                 /* invalid arguments */
4739                 hr = IXMLDOMComment_deleteData(pComment, -1, 1);
4740                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4741
4742                 hr = IXMLDOMComment_deleteData(pComment, 0, 0);
4743                 ok(hr == S_OK, "ret %08x\n", hr );
4744
4745                 hr = IXMLDOMComment_deleteData(pComment, 0, -1);
4746                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4747
4748                 hr = IXMLDOMComment_get_length(pComment, &len);
4749                 ok(hr == S_OK, "ret %08x\n", hr );
4750                 ok(len == 43, "expected 43 got %d\n", len);
4751
4752                 hr = IXMLDOMComment_deleteData(pComment, len, 1);
4753                 ok(hr == S_OK, "ret %08x\n", hr );
4754
4755                 hr = IXMLDOMComment_deleteData(pComment, len+1, 1);
4756                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4757
4758                 /* delete from start */
4759                 hr = IXMLDOMComment_deleteData(pComment, 0, 5);
4760                 ok(hr == S_OK, "ret %08x\n", hr );
4761
4762                 hr = IXMLDOMComment_get_length(pComment, &len);
4763                 ok(hr == S_OK, "ret %08x\n", hr );
4764                 ok(len == 38, "expected 38 got %d\n", len);
4765
4766                 hr = IXMLDOMComment_get_text(pComment, &str);
4767                 ok(hr == S_OK, "ret %08x\n", hr );
4768                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4769                 SysFreeString(str);
4770
4771                 /* delete from end */
4772                 hr = IXMLDOMComment_deleteData(pComment, 35, 3);
4773                 ok(hr == S_OK, "ret %08x\n", hr );
4774
4775                 hr = IXMLDOMComment_get_length(pComment, &len);
4776                 ok(hr == S_OK, "ret %08x\n", hr );
4777                 ok(len == 35, "expected 35 got %d\n", len);
4778
4779                 hr = IXMLDOMComment_get_text(pComment, &str);
4780                 ok(hr == S_OK, "ret %08x\n", hr );
4781                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4782                 SysFreeString(str);
4783
4784                 /* delete from inside */
4785                 hr = IXMLDOMComment_deleteData(pComment, 1, 33);
4786                 ok(hr == S_OK, "ret %08x\n", hr );
4787
4788                 hr = IXMLDOMComment_get_length(pComment, &len);
4789                 ok(hr == S_OK, "ret %08x\n", hr );
4790                 ok(len == 2, "expected 2 got %d\n", len);
4791
4792                 hr = IXMLDOMComment_get_text(pComment, &str);
4793                 ok(hr == S_OK, "ret %08x\n", hr );
4794                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4795                 SysFreeString(str);
4796
4797                 /* delete whole data ... */
4798                 hr = IXMLDOMComment_get_length(pComment, &len);
4799                 ok(hr == S_OK, "ret %08x\n", hr );
4800
4801                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
4802                 ok(hr == S_OK, "ret %08x\n", hr );
4803                 /* ... and try again with empty string */
4804                 hr = IXMLDOMComment_deleteData(pComment, 0, len);
4805                 ok(hr == S_OK, "ret %08x\n", hr );
4806
4807                 /* ::replaceData() */
4808                 V_VT(&v) = VT_BSTR;
4809                 V_BSTR(&v) = SysAllocString(szstr1);
4810                 hr = IXMLDOMComment_put_nodeValue(pComment, v);
4811                 ok(hr == S_OK, "ret %08x\n", hr );
4812                 VariantClear(&v);
4813
4814                 hr = IXMLDOMComment_replaceData(pComment, 6, 0, NULL);
4815                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4816                 hr = IXMLDOMComment_get_text(pComment, &str);
4817                 ok(hr == S_OK, "ret %08x\n", hr );
4818                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4819                 SysFreeString(str);
4820
4821                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, NULL);
4822                 ok(hr == S_OK, "ret %08x\n", hr );
4823                 hr = IXMLDOMComment_get_text(pComment, &str);
4824                 ok(hr == S_OK, "ret %08x\n", hr );
4825                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4826                 SysFreeString(str);
4827
4828                 /* NULL pointer means delete */
4829                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, NULL);
4830                 ok(hr == S_OK, "ret %08x\n", hr );
4831                 hr = IXMLDOMComment_get_text(pComment, &str);
4832                 ok(hr == S_OK, "ret %08x\n", hr );
4833                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4834                 SysFreeString(str);
4835
4836                 /* empty string means delete */
4837                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_(""));
4838                 ok(hr == S_OK, "ret %08x\n", hr );
4839                 hr = IXMLDOMComment_get_text(pComment, &str);
4840                 ok(hr == S_OK, "ret %08x\n", hr );
4841                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4842                 SysFreeString(str);
4843
4844                 /* zero count means insert */
4845                 hr = IXMLDOMComment_replaceData(pComment, 0, 0, _bstr_("a"));
4846                 ok(hr == S_OK, "ret %08x\n", hr );
4847                 hr = IXMLDOMComment_get_text(pComment, &str);
4848                 ok(hr == S_OK, "ret %08x\n", hr );
4849                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4850                 SysFreeString(str);
4851
4852                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, NULL);
4853                 ok(hr == S_OK, "ret %08x\n", hr );
4854
4855                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("m"));
4856                 ok(hr == S_OK, "ret %08x\n", hr );
4857                 hr = IXMLDOMComment_get_text(pComment, &str);
4858                 ok(hr == S_OK, "ret %08x\n", hr );
4859                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4860                 SysFreeString(str);
4861
4862                 /* nonempty string, count greater than its length */
4863                 hr = IXMLDOMComment_replaceData(pComment, 0, 2, _bstr_("a1.2"));
4864                 ok(hr == S_OK, "ret %08x\n", hr );
4865                 hr = IXMLDOMComment_get_text(pComment, &str);
4866                 ok(hr == S_OK, "ret %08x\n", hr );
4867                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4868                 SysFreeString(str);
4869
4870                 /* nonempty string, count less than its length */
4871                 hr = IXMLDOMComment_replaceData(pComment, 0, 1, _bstr_("wine"));
4872                 ok(hr == S_OK, "ret %08x\n", hr );
4873                 hr = IXMLDOMComment_get_text(pComment, &str);
4874                 ok(hr == S_OK, "ret %08x\n", hr );
4875                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
4876                 SysFreeString(str);
4877
4878                 IXMLDOMComment_Release(pComment);
4879             }
4880
4881             /* Element */
4882             str = SysAllocString(szElement);
4883             hr = IXMLDOMDocument_createElement(doc, str, &pElement);
4884             SysFreeString(str);
4885             ok(hr == S_OK, "ret %08x\n", hr );
4886             if(hr == S_OK)
4887             {
4888                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
4889                 ok(hr == S_OK, "ret %08x\n", hr );
4890
4891                 /* test nodeTypeString */
4892                 hr = IXMLDOMDocument_get_nodeTypeString(pElement, &str);
4893                 ok(hr == S_OK, "ret %08x\n", hr );
4894                 ok( !lstrcmpW( str, _bstr_("element") ), "incorrect nodeTypeString string\n");
4895                 SysFreeString(str);
4896
4897                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
4898                 ok(hr == S_OK, "ret %08x\n", hr );
4899                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
4900                 SysFreeString(str);
4901
4902                 hr = IXMLDOMElement_get_xml(pElement, &str);
4903                 ok(hr == S_OK, "ret %08x\n", hr );
4904                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
4905                 SysFreeString(str);
4906
4907                 hr = IXMLDOMElement_get_dataType(pElement, &v);
4908                 ok(hr == S_FALSE, "ret %08x\n", hr );
4909                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
4910                 VariantClear(&v);
4911
4912                 /* Attribute */
4913                 pAttribute = (IXMLDOMAttribute*)0x1;
4914                 hr = IXMLDOMDocument_createAttribute(doc, NULL, &pAttribute);
4915                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4916                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
4917
4918                 pAttribute = (IXMLDOMAttribute*)0x1;
4919                 hr = IXMLDOMDocument_createAttribute(doc, _bstr_(""), &pAttribute);
4920                 ok(hr == E_FAIL, "ret %08x\n", hr );
4921                 ok(pAttribute == (void*)0x1, "Expect same ptr, got %p\n", pAttribute);
4922
4923                 str = SysAllocString(szAttribute);
4924                 hr = IXMLDOMDocument_createAttribute(doc, str, &pAttribute);
4925                 SysFreeString(str);
4926                 ok(hr == S_OK, "ret %08x\n", hr );
4927                 if(hr == S_OK)
4928                 {
4929                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
4930
4931                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, NULL);
4932                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4933
4934                     pNextChild = (IXMLDOMNode *)0x1;
4935                     hr = IXMLDOMAttribute_get_nextSibling(pAttribute, &pNextChild);
4936                     ok(hr == S_FALSE, "ret %08x\n", hr );
4937                     ok(pNextChild == NULL, "pNextChild not NULL\n");
4938
4939                     /* test Previous Sibling*/
4940                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, NULL);
4941                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
4942
4943                     pNextChild = (IXMLDOMNode *)0x1;
4944                     hr = IXMLDOMAttribute_get_previousSibling(pAttribute, &pNextChild);
4945                     ok(hr == S_FALSE, "ret %08x\n", hr );
4946                     ok(pNextChild == NULL, "pNextChild not NULL\n");
4947
4948                     /* test get_attributes */
4949                     hr = IXMLDOMAttribute_get_attributes( pAttribute, NULL );
4950                     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
4951
4952                     pAttribs = (IXMLDOMNamedNodeMap*)0x1;
4953                     hr = IXMLDOMAttribute_get_attributes( pAttribute, &pAttribs);
4954                     ok(hr == S_FALSE, "ret %08x\n", hr );
4955                     ok( pAttribs == NULL, "pAttribs not NULL\n");
4956
4957                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttribute, &pNewChild);
4958                     ok(hr == E_FAIL, "ret %08x\n", hr );
4959                     ok(pNewChild == NULL, "pNewChild not NULL\n");
4960
4961                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
4962                     ok(hr == S_OK, "ret %08x\n", hr );
4963                     if ( hr == S_OK )
4964                     {
4965                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttribute, NULL );
4966                         ok(hr == S_OK, "ret %08x\n", hr );
4967
4968                         IXMLDOMNamedNodeMap_Release(pAttribs);
4969                     }
4970
4971                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
4972                     ok(hr == S_OK, "ret %08x\n", hr );
4973                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
4974                     SysFreeString(str);
4975
4976                     /* test nodeTypeString */
4977                     hr = IXMLDOMAttribute_get_nodeTypeString(pAttribute, &str);
4978                     ok(hr == S_OK, "ret %08x\n", hr );
4979                     ok( !lstrcmpW( str, _bstr_("attribute") ), "incorrect nodeTypeString string\n");
4980                     SysFreeString(str);
4981
4982                     /* test nodeName */
4983                     hr = IXMLDOMAttribute_get_nodeName(pAttribute, &str);
4984                     ok(hr == S_OK, "ret %08x\n", hr );
4985                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
4986                     SysFreeString(str);
4987
4988                     /* test name property */
4989                     hr = IXMLDOMAttribute_get_name(pAttribute, &str);
4990                     ok(hr == S_OK, "ret %08x\n", hr );
4991                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
4992                     SysFreeString(str);
4993
4994                     hr = IXMLDOMAttribute_get_xml(pAttribute, &str);
4995                     ok(hr == S_OK, "ret %08x\n", hr );
4996                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
4997                     SysFreeString(str);
4998
4999                     hr = IXMLDOMAttribute_get_dataType(pAttribute, &v);
5000                     ok(hr == S_FALSE, "ret %08x\n", hr );
5001                     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
5002                     VariantClear(&v);
5003
5004                     IXMLDOMAttribute_Release(pAttribute);
5005
5006                     /* Check Element again with the Add Attribute*/
5007                     hr = IXMLDOMElement_get_xml(pElement, &str);
5008                     ok(hr == S_OK, "ret %08x\n", hr );
5009                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
5010                     SysFreeString(str);
5011                 }
5012
5013                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
5014                 ok(hr == S_OK, "ret %08x\n", hr );
5015
5016                 hr = IXMLDOMElement_get_xml(pElement, &str);
5017                 ok(hr == S_OK, "ret %08x\n", hr );
5018                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
5019                 SysFreeString(str);
5020
5021                 /* Test for reversible escaping */
5022                 str = SysAllocString( szStrangeChars );
5023                 hr = IXMLDOMElement_put_text(pElement, str);
5024                 ok(hr == S_OK, "ret %08x\n", hr );
5025                 SysFreeString( str );
5026
5027                 hr = IXMLDOMElement_get_xml(pElement, &str);
5028                 ok(hr == S_OK, "ret %08x\n", hr );
5029                 ok( !lstrcmpW( str, szElementXML4 ), "incorrect element xml\n");
5030                 SysFreeString(str);
5031
5032                 hr = IXMLDOMElement_get_text(pElement, &str);
5033                 ok(hr == S_OK, "ret %08x\n", hr );
5034                 ok( !lstrcmpW( str, szStrangeChars ), "incorrect element text\n");
5035                 SysFreeString(str);
5036
5037                 IXMLDOMElement_Release(pElement);
5038             }
5039
5040             /* CData Section */
5041             str = SysAllocString(szCData);
5042             hr = IXMLDOMDocument_createCDATASection(doc, str, NULL);
5043             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5044
5045             hr = IXMLDOMDocument_createCDATASection(doc, str, &pCDataSec);
5046             SysFreeString(str);
5047             ok(hr == S_OK, "ret %08x\n", hr );
5048             if(hr == S_OK)
5049             {
5050                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
5051                 VARIANT var;
5052
5053                 VariantInit(&var);
5054
5055                 hr = IXMLDOMCDATASection_QueryInterface(pCDataSec, &IID_IXMLDOMElement, (void**)&pElement);
5056                 ok(hr == E_NOINTERFACE, "ret %08x\n", hr);
5057
5058                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
5059                 ok(hr == S_OK, "ret %08x\n", hr );
5060
5061                 /* get Attribute Tests */
5062                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, NULL);
5063                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5064
5065                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
5066                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, &pAttribs);
5067                 ok(hr == S_FALSE, "ret %08x\n", hr );
5068                 ok(pAttribs == NULL, "pAttribs != NULL\n");
5069
5070                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
5071                 ok(hr == S_OK, "ret %08x\n", hr );
5072                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
5073                 SysFreeString(str);
5074
5075                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5076                 ok(hr == S_OK, "ret %08x\n", hr );
5077                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
5078                 SysFreeString(str);
5079
5080                 /* test lastChild */
5081                 pNextChild = (IXMLDOMNode*)0x1;
5082                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
5083                 ok(hr == S_FALSE, "ret %08x\n", hr );
5084                 ok(pNextChild == NULL, "pNextChild not NULL\n");
5085
5086                 /* test get_dataType */
5087                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, NULL);
5088                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5089
5090                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, &v);
5091                 ok(hr == S_FALSE, "ret %08x\n", hr );
5092                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
5093                 VariantClear(&v);
5094
5095                 /* test nodeTypeString */
5096                 hr = IXMLDOMCDATASection_get_nodeTypeString(pCDataSec, &str);
5097                 ok(hr == S_OK, "ret %08x\n", hr );
5098                 ok( !lstrcmpW( str, _bstr_("cdatasection") ), "incorrect nodeTypeString string\n");
5099                 SysFreeString(str);
5100
5101                 /* put data Tests */
5102                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
5103                 ok(hr == S_OK, "ret %08x\n", hr );
5104
5105                 /* Confirm XML text is good */
5106                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
5107                 ok(hr == S_OK, "ret %08x\n", hr );
5108                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
5109                 SysFreeString(str);
5110
5111                 /* Confirm we get the put_data Text back */
5112                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5113                 ok(hr == S_OK, "ret %08x\n", hr );
5114                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5115                 SysFreeString(str);
5116
5117                 /* test length property */
5118                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5119                 ok(hr == S_OK, "ret %08x\n", hr );
5120                 ok(len == 21, "expected 21 got %d\n", len);
5121
5122                 /* test get nodeValue */
5123                 hr = IXMLDOMCDATASection_get_nodeValue(pCDataSec, &var);
5124                 ok(hr == S_OK, "ret %08x\n", hr );
5125                 ok(V_VT(&var) == VT_BSTR, "got vt %04x\n", V_VT(&var));
5126                 ok( !lstrcmpW( V_BSTR(&var), _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5127                 VariantClear(&var);
5128
5129                 /* test get data */
5130                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
5131                 ok(hr == S_OK, "ret %08x\n", hr );
5132                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
5133                 SysFreeString(str);
5134
5135                 /* test substringData */
5136                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
5137                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5138
5139                 /* test substringData - Invalid offset */
5140                 str = (BSTR)&szElement;
5141                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
5142                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5143                 ok( str == NULL, "incorrect string\n");
5144
5145                 /* test substringData - Invalid offset */
5146                 str = (BSTR)&szElement;
5147                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
5148                 ok(hr == S_FALSE, "ret %08x\n", hr );
5149                 ok( str == NULL, "incorrect string\n");
5150
5151                 /* test substringData - Invalid size */
5152                 str = (BSTR)&szElement;
5153                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
5154                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5155                 ok( str == NULL, "incorrect string\n");
5156
5157                 /* test substringData - Invalid size */
5158                 str = (BSTR)&szElement;
5159                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
5160                 ok(hr == S_FALSE, "ret %08x\n", hr );
5161                 ok( str == NULL, "incorrect string\n");
5162
5163                 /* test substringData - Start of string */
5164                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
5165                 ok(hr == S_OK, "ret %08x\n", hr );
5166                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
5167                 SysFreeString(str);
5168
5169                 /* test substringData - Middle of string */
5170                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
5171                 ok(hr == S_OK, "ret %08x\n", hr );
5172                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
5173                 SysFreeString(str);
5174
5175                 /* test substringData - End of string */
5176                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
5177                 ok(hr == S_OK, "ret %08x\n", hr );
5178                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
5179                 SysFreeString(str);
5180
5181                 /* test appendData */
5182                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
5183                 ok(hr == S_OK, "ret %08x\n", hr );
5184
5185                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
5186                 ok(hr == S_OK, "ret %08x\n", hr );
5187
5188                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
5189                 ok(hr == S_OK, "ret %08x\n", hr );
5190
5191                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5192                 ok(hr == S_OK, "ret %08x\n", hr );
5193                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5194                 SysFreeString(str);
5195
5196                 /* test insertData */
5197                 str = SysAllocStringLen(NULL, 0);
5198                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
5199                 ok(hr == S_OK, "ret %08x\n", hr );
5200
5201                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
5202                 ok(hr == S_OK, "ret %08x\n", hr );
5203
5204                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
5205                 ok(hr == S_OK, "ret %08x\n", hr );
5206
5207                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
5208                 ok(hr == S_OK, "ret %08x\n", hr );
5209
5210                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
5211                 ok(hr == S_OK, "ret %08x\n", hr );
5212
5213                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
5214                 ok(hr == S_OK, "ret %08x\n", hr );
5215                 SysFreeString(str);
5216
5217                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
5218                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5219
5220                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
5221                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5222
5223                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
5224                 ok(hr == S_OK, "ret %08x\n", hr );
5225
5226                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
5227                 ok(hr == S_OK, "ret %08x\n", hr );
5228
5229                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
5230                 ok(hr == S_OK, "ret %08x\n", hr );
5231
5232                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5233                 ok(hr == S_OK, "ret %08x\n", hr );
5234                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5235                 SysFreeString(str);
5236
5237                 /* delete data */
5238                 /* invalid arguments */
5239                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, -1, 1);
5240                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5241
5242                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 0);
5243                 ok(hr == S_OK, "ret %08x\n", hr );
5244
5245                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, -1);
5246                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5247
5248                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5249                 ok(hr == S_OK, "ret %08x\n", hr );
5250                 ok(len == 43, "expected 43 got %d\n", len);
5251
5252                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len, 1);
5253                 ok(hr == S_OK, "ret %08x\n", hr );
5254
5255                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, len+1, 1);
5256                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5257
5258                 /* delete from start */
5259                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, 5);
5260                 ok(hr == S_OK, "ret %08x\n", hr );
5261
5262                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5263                 ok(hr == S_OK, "ret %08x\n", hr );
5264                 ok(len == 38, "expected 38 got %d\n", len);
5265
5266                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5267                 ok(hr == S_OK, "ret %08x\n", hr );
5268                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append End") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5269                 SysFreeString(str);
5270
5271                 /* delete from end */
5272                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 35, 3);
5273                 ok(hr == S_OK, "ret %08x\n", hr );
5274
5275                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5276                 ok(hr == S_OK, "ret %08x\n", hr );
5277                 ok(len == 35, "expected 35 got %d\n", len);
5278
5279                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5280                 ok(hr == S_OK, "ret %08x\n", hr );
5281                 ok( !lstrcmpW( str, _bstr_(" This &is a Middle; test <>\\Append ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5282                 SysFreeString(str);
5283
5284                 /* delete from inside */
5285                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 1, 33);
5286                 ok(hr == S_OK, "ret %08x\n", hr );
5287
5288                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5289                 ok(hr == S_OK, "ret %08x\n", hr );
5290                 ok(len == 2, "expected 2 got %d\n", len);
5291
5292                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5293                 ok(hr == S_OK, "ret %08x\n", hr );
5294                 ok( !lstrcmpW( str, _bstr_("  ") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5295                 SysFreeString(str);
5296
5297                 /* delete whole data ... */
5298                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
5299                 ok(hr == S_OK, "ret %08x\n", hr );
5300
5301                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
5302                 ok(hr == S_OK, "ret %08x\n", hr );
5303
5304                 /* ... and try again with empty string */
5305                 hr = IXMLDOMCDATASection_deleteData(pCDataSec, 0, len);
5306                 ok(hr == S_OK, "ret %08x\n", hr );
5307
5308                 /* ::replaceData() */
5309                 V_VT(&v) = VT_BSTR;
5310                 V_BSTR(&v) = SysAllocString(szstr1);
5311                 hr = IXMLDOMCDATASection_put_nodeValue(pCDataSec, v);
5312                 ok(hr == S_OK, "ret %08x\n", hr );
5313                 VariantClear(&v);
5314
5315                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 6, 0, NULL);
5316                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5317                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5318                 ok(hr == S_OK, "ret %08x\n", hr );
5319                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5320                 SysFreeString(str);
5321
5322                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, NULL);
5323                 ok(hr == S_OK, "ret %08x\n", hr );
5324                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5325                 ok(hr == S_OK, "ret %08x\n", hr );
5326                 ok( !lstrcmpW( str, _bstr_("str1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5327                 SysFreeString(str);
5328
5329                 /* NULL pointer means delete */
5330                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, NULL);
5331                 ok(hr == S_OK, "ret %08x\n", hr );
5332                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5333                 ok(hr == S_OK, "ret %08x\n", hr );
5334                 ok( !lstrcmpW( str, _bstr_("tr1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5335                 SysFreeString(str);
5336
5337                 /* empty string means delete */
5338                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_(""));
5339                 ok(hr == S_OK, "ret %08x\n", hr );
5340                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5341                 ok(hr == S_OK, "ret %08x\n", hr );
5342                 ok( !lstrcmpW( str, _bstr_("r1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5343                 SysFreeString(str);
5344
5345                 /* zero count means insert */
5346                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 0, _bstr_("a"));
5347                 ok(hr == S_OK, "ret %08x\n", hr );
5348                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5349                 ok(hr == S_OK, "ret %08x\n", hr );
5350                 ok( !lstrcmpW( str, _bstr_("ar1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5351                 SysFreeString(str);
5352
5353                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, NULL);
5354                 ok(hr == S_OK, "ret %08x\n", hr );
5355
5356                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("m"));
5357                 ok(hr == S_OK, "ret %08x\n", hr );
5358                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5359                 ok(hr == S_OK, "ret %08x\n", hr );
5360                 ok( !lstrcmpW( str, _bstr_("m1") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5361                 SysFreeString(str);
5362
5363                 /* nonempty string, count greater than its length */
5364                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 2, _bstr_("a1.2"));
5365                 ok(hr == S_OK, "ret %08x\n", hr );
5366                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5367                 ok(hr == S_OK, "ret %08x\n", hr );
5368                 ok( !lstrcmpW( str, _bstr_("a1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5369                 SysFreeString(str);
5370
5371                 /* nonempty string, count less than its length */
5372                 hr = IXMLDOMCDATASection_replaceData(pCDataSec, 0, 1, _bstr_("wine"));
5373                 ok(hr == S_OK, "ret %08x\n", hr );
5374                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
5375                 ok(hr == S_OK, "ret %08x\n", hr );
5376                 ok( !lstrcmpW( str, _bstr_("wine1.2") ), "incorrect get_text string, got '%s'\n", wine_dbgstr_w(str) );
5377                 SysFreeString(str);
5378
5379                 IXMLDOMCDATASection_Release(pCDataSec);
5380             }
5381
5382             /* Document Fragments */
5383             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
5384             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5385
5386             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
5387             ok(hr == S_OK, "ret %08x\n", hr );
5388             if(hr == S_OK)
5389             {
5390                 IXMLDOMNode *node;
5391
5392                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, NULL);
5393                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5394
5395                 node = (IXMLDOMNode *)0x1;
5396                 hr = IXMLDOMDocumentFragment_get_parentNode(pDocFrag, &node);
5397                 ok(hr == S_FALSE, "ret %08x\n", hr );
5398                 ok(node == NULL, "expected NULL, got %p\n", node);
5399
5400                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
5401                 ok(hr == S_OK, "ret %08x\n", hr );
5402
5403                 /* get Attribute Tests */
5404                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, NULL);
5405                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5406
5407                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
5408                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, &pAttribs);
5409                 ok(hr == S_FALSE, "ret %08x\n", hr );
5410                 ok(pAttribs == NULL, "pAttribs != NULL\n");
5411
5412                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
5413                 ok(hr == S_OK, "ret %08x\n", hr );
5414                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
5415                 SysFreeString(str);
5416
5417                 /* test next Sibling*/
5418                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
5419                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5420
5421                 node = (IXMLDOMNode *)0x1;
5422                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &node);
5423                 ok(hr == S_FALSE, "ret %08x\n", hr );
5424                 ok(node == NULL, "next sibling not NULL\n");
5425
5426                 /* test Previous Sibling*/
5427                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
5428                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5429
5430                 node = (IXMLDOMNode *)0x1;
5431                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &node);
5432                 ok(hr == S_FALSE, "ret %08x\n", hr );
5433                 ok(node == NULL, "previous sibling not NULL\n");
5434
5435                 /* test get_dataType */
5436                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, NULL);
5437                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5438
5439                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, &v);
5440                 ok(hr == S_FALSE, "ret %08x\n", hr );
5441                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
5442                 VariantClear(&v);
5443
5444                 /* test nodeTypeString */
5445                 hr = IXMLDOMDocumentFragment_get_nodeTypeString(pDocFrag, &str);
5446                 ok(hr == S_OK, "ret %08x\n", hr );
5447                 ok( !lstrcmpW( str, _bstr_("documentfragment") ), "incorrect nodeTypeString string\n");
5448                 SysFreeString(str);
5449
5450                 IXMLDOMDocumentFragment_Release(pDocFrag);
5451             }
5452
5453             /* Entity References */
5454             hr = IXMLDOMDocument_createEntityReference(doc, NULL, &pEntityRef);
5455             ok(hr == E_FAIL, "ret %08x\n", hr );
5456             hr = IXMLDOMDocument_createEntityReference(doc, _bstr_(""), &pEntityRef);
5457             ok(hr == E_FAIL, "ret %08x\n", hr );
5458
5459             str = SysAllocString(szEntityRef);
5460             hr = IXMLDOMDocument_createEntityReference(doc, str, NULL);
5461             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5462
5463             hr = IXMLDOMDocument_createEntityReference(doc, str, &pEntityRef);
5464             SysFreeString(str);
5465             ok(hr == S_OK, "ret %08x\n", hr );
5466             if(hr == S_OK)
5467             {
5468                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
5469                 ok(hr == S_OK, "ret %08x\n", hr );
5470
5471                 /* get Attribute Tests */
5472                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, NULL);
5473                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5474
5475                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
5476                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, &pAttribs);
5477                 ok(hr == S_FALSE, "ret %08x\n", hr );
5478                 ok(pAttribs == NULL, "pAttribs != NULL\n");
5479
5480                 /* test dataType */
5481                 hr = IXMLDOMEntityReference_get_dataType(pEntityRef, &v);
5482                 ok(hr == S_FALSE, "ret %08x\n", hr );
5483                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
5484                 VariantClear(&v);
5485
5486                 /* test nodeTypeString */
5487                 hr = IXMLDOMEntityReference_get_nodeTypeString(pEntityRef, &str);
5488                 ok(hr == S_OK, "ret %08x\n", hr );
5489                 ok( !lstrcmpW( str, _bstr_("entityreference") ), "incorrect nodeTypeString string\n");
5490                 SysFreeString(str);
5491
5492                 /* test get_xml*/
5493                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
5494                 ok(hr == S_OK, "ret %08x\n", hr );
5495                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
5496                 SysFreeString(str);
5497
5498                 IXMLDOMEntityReference_Release(pEntityRef);
5499             }
5500
5501             IXMLDOMElement_Release( pRoot );
5502         }
5503     }
5504
5505     IXMLDOMDocument_Release(doc);
5506
5507     free_bstrs();
5508 }
5509
5510 static void test_nodeTypeTests( void )
5511 {
5512     IXMLDOMDocument *doc = NULL;
5513     IXMLDOMElement *pRoot;
5514     IXMLDOMElement *pElement;
5515     HRESULT hr;
5516
5517     doc = create_document(&IID_IXMLDOMDocument);
5518     if (!doc) return;
5519
5520     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), NULL);
5521     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5522
5523     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
5524     ok(hr == S_OK, "ret %08x\n", hr );
5525     if(hr == S_OK)
5526     {
5527         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
5528         ok(hr == S_OK, "ret %08x\n", hr );
5529         if(hr == S_OK)
5530         {
5531             hr = IXMLDOMElement_put_dataType(pRoot, NULL);
5532             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
5533
5534             /* Invalid Value */
5535             hr = IXMLDOMElement_put_dataType(pRoot, _bstr_("abcdefg") );
5536             ok(hr == E_FAIL, "ret %08x\n", hr );
5537
5538             /* NOTE:
5539              *   The name passed into put_dataType is case-insensitive. So many of the names
5540              *     have been changed to reflect this.
5541              */
5542             /* Boolean */
5543             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Boolean"), &pElement);
5544             ok(hr == S_OK, "ret %08x\n", hr );
5545             if(hr == S_OK)
5546             {
5547                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5548
5549                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Boolean") );
5550                 ok(hr == S_OK, "ret %08x\n", hr );
5551
5552                 IXMLDOMElement_Release(pElement);
5553             }
5554
5555             /* String */
5556             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_String"), &pElement);
5557             ok(hr == S_OK, "ret %08x\n", hr );
5558             if(hr == S_OK)
5559             {
5560                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5561
5562                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("String") );
5563                 ok(hr == S_OK, "ret %08x\n", hr );
5564
5565                 IXMLDOMElement_Release(pElement);
5566             }
5567
5568             /* Number */
5569             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Number"), &pElement);
5570             ok(hr == S_OK, "ret %08x\n", hr );
5571             if(hr == S_OK)
5572             {
5573                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5574
5575                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("number") );
5576                 ok(hr == S_OK, "ret %08x\n", hr );
5577
5578                 IXMLDOMElement_Release(pElement);
5579             }
5580
5581             /* Int */
5582             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Int"), &pElement);
5583             ok(hr == S_OK, "ret %08x\n", hr );
5584             if(hr == S_OK)
5585             {
5586                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5587
5588                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("InT") );
5589                 ok(hr == S_OK, "ret %08x\n", hr );
5590
5591                 IXMLDOMElement_Release(pElement);
5592             }
5593
5594             /* Fixed */
5595             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Fixed"), &pElement);
5596             ok(hr == S_OK, "ret %08x\n", hr );
5597             if(hr == S_OK)
5598             {
5599                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5600
5601                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("fixed.14.4") );
5602                 ok(hr == S_OK, "ret %08x\n", hr );
5603
5604                 IXMLDOMElement_Release(pElement);
5605             }
5606
5607             /* DateTime */
5608             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime"), &pElement);
5609             ok(hr == S_OK, "ret %08x\n", hr );
5610             if(hr == S_OK)
5611             {
5612                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5613
5614                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime") );
5615                 ok(hr == S_OK, "ret %08x\n", hr );
5616
5617                 IXMLDOMElement_Release(pElement);
5618             }
5619
5620             /* DateTime TZ */
5621             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime_tz"), &pElement);
5622             ok(hr == S_OK, "ret %08x\n", hr );
5623             if(hr == S_OK)
5624             {
5625                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5626
5627                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
5628                 ok(hr == S_OK, "ret %08x\n", hr );
5629
5630                 IXMLDOMElement_Release(pElement);
5631             }
5632
5633             /* Date */
5634             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Date"), &pElement);
5635             ok(hr == S_OK, "ret %08x\n", hr );
5636             if(hr == S_OK)
5637             {
5638                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5639
5640                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Date") );
5641                 ok(hr == S_OK, "ret %08x\n", hr );
5642
5643                 IXMLDOMElement_Release(pElement);
5644             }
5645
5646             /* Time */
5647             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time"), &pElement);
5648             ok(hr == S_OK, "ret %08x\n", hr );
5649             if(hr == S_OK)
5650             {
5651                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5652
5653                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time") );
5654                 ok(hr == S_OK, "ret %08x\n", hr );
5655
5656                 IXMLDOMElement_Release(pElement);
5657             }
5658
5659             /* Time.tz */
5660             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time_TZ"), &pElement);
5661             ok(hr == S_OK, "ret %08x\n", hr );
5662             if(hr == S_OK)
5663             {
5664                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5665
5666                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time.tz") );
5667                 ok(hr == S_OK, "ret %08x\n", hr );
5668
5669                 IXMLDOMElement_Release(pElement);
5670             }
5671
5672             /* I1 */
5673             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I1"), &pElement);
5674             ok(hr == S_OK, "ret %08x\n", hr );
5675             if(hr == S_OK)
5676             {
5677                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5678
5679                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I1") );
5680                 ok(hr == S_OK, "ret %08x\n", hr );
5681
5682                 IXMLDOMElement_Release(pElement);
5683             }
5684
5685             /* I2 */
5686             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I2"), &pElement);
5687             ok(hr == S_OK, "ret %08x\n", hr );
5688             if(hr == S_OK)
5689             {
5690                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5691
5692                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I2") );
5693                 ok(hr == S_OK, "ret %08x\n", hr );
5694
5695                 IXMLDOMElement_Release(pElement);
5696             }
5697
5698             /* I4 */
5699             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I4"), &pElement);
5700             ok(hr == S_OK, "ret %08x\n", hr );
5701             if(hr == S_OK)
5702             {
5703                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5704
5705                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I4") );
5706                 ok(hr == S_OK, "ret %08x\n", hr );
5707
5708                 IXMLDOMElement_Release(pElement);
5709             }
5710
5711             /* UI1 */
5712             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI1"), &pElement);
5713             ok(hr == S_OK, "ret %08x\n", hr );
5714             if(hr == S_OK)
5715             {
5716                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5717
5718                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI1") );
5719                 ok(hr == S_OK, "ret %08x\n", hr );
5720
5721                 IXMLDOMElement_Release(pElement);
5722             }
5723
5724             /* UI2 */
5725             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI2"), &pElement);
5726             ok(hr == S_OK, "ret %08x\n", hr );
5727             if(hr == S_OK)
5728             {
5729                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5730
5731                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI2") );
5732                 ok(hr == S_OK, "ret %08x\n", hr );
5733
5734                 IXMLDOMElement_Release(pElement);
5735             }
5736
5737             /* UI4 */
5738             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI4"), &pElement);
5739             ok(hr == S_OK, "ret %08x\n", hr );
5740             if(hr == S_OK)
5741             {
5742                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5743
5744                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI4") );
5745                 ok(hr == S_OK, "ret %08x\n", hr );
5746
5747                 IXMLDOMElement_Release(pElement);
5748             }
5749
5750             /* r4 */
5751             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r4"), &pElement);
5752             ok(hr == S_OK, "ret %08x\n", hr );
5753             if(hr == S_OK)
5754             {
5755                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5756
5757                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r4") );
5758                 ok(hr == S_OK, "ret %08x\n", hr );
5759
5760                 IXMLDOMElement_Release(pElement);
5761             }
5762
5763             /* r8 */
5764             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r8"), &pElement);
5765             ok(hr == S_OK, "ret %08x\n", hr );
5766             if(hr == S_OK)
5767             {
5768                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5769
5770                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r8") );
5771                 ok(hr == S_OK, "ret %08x\n", hr );
5772
5773                 IXMLDOMElement_Release(pElement);
5774             }
5775
5776             /* float */
5777             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_float"), &pElement);
5778             ok(hr == S_OK, "ret %08x\n", hr );
5779             if(hr == S_OK)
5780             {
5781                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5782
5783                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("float") );
5784                 ok(hr == S_OK, "ret %08x\n", hr );
5785
5786                 IXMLDOMElement_Release(pElement);
5787             }
5788
5789             /* uuid */
5790             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_uuid"), &pElement);
5791             ok(hr == S_OK, "ret %08x\n", hr );
5792             if(hr == S_OK)
5793             {
5794                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5795
5796                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UuId") );
5797                 ok(hr == S_OK, "ret %08x\n", hr );
5798
5799                 IXMLDOMElement_Release(pElement);
5800             }
5801
5802             /* bin.hex */
5803             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_hex"), &pElement);
5804             ok(hr == S_OK, "ret %08x\n", hr );
5805             if(hr == S_OK)
5806             {
5807                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5808
5809                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.hex") );
5810                 ok(hr == S_OK, "ret %08x\n", hr );
5811
5812                 IXMLDOMElement_Release(pElement);
5813             }
5814
5815             /* bin.base64 */
5816             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_base64"), &pElement);
5817             ok(hr == S_OK, "ret %08x\n", hr );
5818             if(hr == S_OK)
5819             {
5820                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5821
5822                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.base64") );
5823                 ok(hr == S_OK, "ret %08x\n", hr );
5824
5825                 IXMLDOMElement_Release(pElement);
5826             }
5827
5828             /* Check changing types */
5829             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &pElement);
5830             ok(hr == S_OK, "ret %08x\n", hr );
5831             if(hr == S_OK)
5832             {
5833                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
5834
5835                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
5836                 ok(hr == S_OK, "ret %08x\n", hr );
5837
5838                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("string") );
5839                 ok(hr == S_OK, "ret %08x\n", hr );
5840
5841                 IXMLDOMElement_Release(pElement);
5842             }
5843
5844             IXMLDOMElement_Release(pRoot);
5845         }
5846     }
5847
5848     IXMLDOMDocument_Release(doc);
5849
5850     free_bstrs();
5851 }
5852
5853 static void test_DocumentSaveToDocument(void)
5854 {
5855     IXMLDOMDocument *doc, *doc2;
5856     IXMLDOMElement *pRoot;
5857     HRESULT hr;
5858
5859     doc = create_document(&IID_IXMLDOMDocument);
5860     if (!doc) return;
5861
5862     doc2 = create_document(&IID_IXMLDOMDocument);
5863     if (!doc2)
5864     {
5865         IXMLDOMDocument_Release(doc);
5866         return;
5867     }
5868
5869     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
5870     ok(hr == S_OK, "ret %08x\n", hr );
5871     if(hr == S_OK)
5872     {
5873         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
5874         ok(hr == S_OK, "ret %08x\n", hr );
5875         if(hr == S_OK)
5876         {
5877             VARIANT vDoc;
5878             BSTR sOrig;
5879             BSTR sNew;
5880
5881             V_VT(&vDoc) = VT_UNKNOWN;
5882             V_UNKNOWN(&vDoc) = (IUnknown*)doc2;
5883
5884             hr = IXMLDOMDocument_save(doc, vDoc);
5885             ok(hr == S_OK, "ret %08x\n", hr );
5886
5887             hr = IXMLDOMDocument_get_xml(doc, &sOrig);
5888             ok(hr == S_OK, "ret %08x\n", hr );
5889
5890             hr = IXMLDOMDocument_get_xml(doc2, &sNew);
5891             ok(hr == S_OK, "ret %08x\n", hr );
5892
5893             ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as origial\n");
5894
5895             SysFreeString(sOrig);
5896             SysFreeString(sNew);
5897         }
5898     }
5899
5900     IXMLDOMDocument_Release(doc2);
5901     IXMLDOMDocument_Release(doc);
5902 }
5903
5904 static void test_DocumentSaveToFile(void)
5905 {
5906     IXMLDOMDocument *doc;
5907     IXMLDOMElement *pRoot;
5908     HANDLE file;
5909     char buffer[100];
5910     DWORD read = 0;
5911     HRESULT hr;
5912
5913     doc = create_document(&IID_IXMLDOMDocument);
5914     if (!doc) return;
5915
5916     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
5917     ok(hr == S_OK, "ret %08x\n", hr );
5918     if(hr == S_OK)
5919     {
5920         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
5921         ok(hr == S_OK, "ret %08x\n", hr );
5922         if(hr == S_OK)
5923         {
5924             VARIANT vFile;
5925
5926             V_VT(&vFile) = VT_BSTR;
5927             V_BSTR(&vFile) = _bstr_("test.xml");
5928
5929             hr = IXMLDOMDocument_save(doc, vFile);
5930             ok(hr == S_OK, "ret %08x\n", hr );
5931         }
5932     }
5933
5934     IXMLDOMElement_Release(pRoot);
5935     IXMLDOMDocument_Release(doc);
5936
5937     file = CreateFile("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
5938     ok(file != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
5939     if(file == INVALID_HANDLE_VALUE)
5940         return;
5941
5942     ReadFile(file, buffer, sizeof(buffer), &read, NULL);
5943     ok(read != 0, "could not read file\n");
5944     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
5945
5946     CloseHandle(file);
5947     DeleteFile("test.xml");
5948 }
5949
5950 static void test_testTransforms(void)
5951 {
5952     IXMLDOMDocument *doc, *docSS;
5953     IXMLDOMNode *pNode;
5954     VARIANT_BOOL bSucc;
5955
5956     HRESULT hr;
5957
5958     doc = create_document(&IID_IXMLDOMDocument);
5959     if (!doc) return;
5960
5961     docSS = create_document(&IID_IXMLDOMDocument);
5962     if (!docSS)
5963     {
5964         IXMLDOMDocument_Release(doc);
5965         return;
5966     }
5967
5968     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
5969     ok(hr == S_OK, "ret %08x\n", hr );
5970
5971     hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
5972     ok(hr == S_OK, "ret %08x\n", hr );
5973
5974     hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (void**)&pNode );
5975     ok(hr == S_OK, "ret %08x\n", hr );
5976     if(hr == S_OK)
5977     {
5978         BSTR bOut;
5979
5980         hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
5981         ok(hr == S_OK, "ret %08x\n", hr );
5982         ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "Stylesheet output not correct\n");
5983         SysFreeString(bOut);
5984
5985         IXMLDOMNode_Release(pNode);
5986     }
5987
5988     IXMLDOMDocument_Release(docSS);
5989     IXMLDOMDocument_Release(doc);
5990
5991     free_bstrs();
5992 }
5993
5994 static void test_Namespaces(void)
5995 {
5996     IXMLDOMDocument *doc;
5997     IXMLDOMNode *pNode;
5998     IXMLDOMNode *pNode2 = NULL;
5999     VARIANT_BOOL bSucc;
6000     HRESULT hr;
6001     BSTR str;
6002     static  const CHAR szNamespacesXML[] =
6003 "<?xml version=\"1.0\"?>\n"
6004 "<root xmlns:WEB='http://www.winehq.org'>\n"
6005 "<WEB:Site version=\"1.0\" />\n"
6006 "</root>";
6007
6008     doc = create_document(&IID_IXMLDOMDocument);
6009     if (!doc) return;
6010
6011     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szNamespacesXML), &bSucc);
6012     ok(hr == S_OK, "ret %08x\n", hr );
6013     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6014
6015     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root"), &pNode );
6016     ok(hr == S_OK, "ret %08x\n", hr );
6017     if(hr == S_OK)
6018     {
6019         hr = IXMLDOMNode_get_firstChild( pNode, &pNode2 );
6020         ok( hr == S_OK, "ret %08x\n", hr );
6021         ok( pNode2 != NULL, "pNode2 == NULL\n");
6022
6023         /* Test get_prefix */
6024         hr = IXMLDOMNode_get_prefix(pNode2, NULL);
6025         ok( hr == E_INVALIDARG, "ret %08x\n", hr );
6026         /* NOTE: Need to test that arg2 gets cleared on Error. */
6027
6028         hr = IXMLDOMNode_get_prefix(pNode2, &str);
6029         ok( hr == S_OK, "ret %08x\n", hr );
6030         ok( !lstrcmpW( str, _bstr_("WEB")), "incorrect prefix string\n");
6031         SysFreeString(str);
6032
6033         /* Test get_namespaceURI */
6034         hr = IXMLDOMNode_get_namespaceURI(pNode2, NULL);
6035         ok( hr == E_INVALIDARG, "ret %08x\n", hr );
6036         /* NOTE: Need to test that arg2 gets cleared on Error. */
6037
6038         hr = IXMLDOMNode_get_namespaceURI(pNode2, &str);
6039         ok( hr == S_OK, "ret %08x\n", hr );
6040         ok( !lstrcmpW( str, _bstr_("http://www.winehq.org")), "incorrect namespaceURI string\n");
6041         SysFreeString(str);
6042
6043         IXMLDOMNode_Release(pNode2);
6044         IXMLDOMNode_Release(pNode);
6045     }
6046
6047     IXMLDOMDocument_Release(doc);
6048
6049     free_bstrs();
6050 }
6051
6052 static void test_FormattingXML(void)
6053 {
6054     IXMLDOMDocument *doc;
6055     IXMLDOMElement *pElement;
6056     VARIANT_BOOL bSucc;
6057     HRESULT hr;
6058     BSTR str;
6059     static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
6060     static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
6061
6062     doc = create_document(&IID_IXMLDOMDocument);
6063     if (!doc) return;
6064
6065     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
6066     ok(hr == S_OK, "ret %08x\n", hr );
6067     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6068
6069     if(bSucc == VARIANT_TRUE)
6070     {
6071         hr = IXMLDOMDocument_get_documentElement(doc, &pElement);
6072         ok(hr == S_OK, "ret %08x\n", hr );
6073         if(hr == S_OK)
6074         {
6075             hr = IXMLDOMElement_get_xml(pElement, &str);
6076             ok(hr == S_OK, "ret %08x\n", hr );
6077             ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
6078             SysFreeString(str);
6079
6080             IXMLDOMElement_Release(pElement);
6081         }
6082     }
6083
6084     IXMLDOMDocument_Release(doc);
6085
6086     free_bstrs();
6087 }
6088
6089 typedef struct _nodetypedvalue_t {
6090     const char *name;
6091     VARTYPE type;
6092     const char *value; /* value in string format */
6093 } nodetypedvalue_t;
6094
6095 static const nodetypedvalue_t get_nodetypedvalue[] = {
6096     { "root/string",    VT_BSTR, "Wine" },
6097     { "root/string2",   VT_BSTR, "String" },
6098     { "root/number",    VT_BSTR, "12.44" },
6099     { "root/number2",   VT_BSTR, "-3.71e3" },
6100     { "root/int",       VT_I4,   "-13" },
6101     { "root/fixed",     VT_CY,   "7322.9371" },
6102     { "root/bool",      VT_BOOL, "-1" },
6103     { "root/datetime",  VT_DATE, "40135.14" },
6104     { "root/datetimetz",VT_DATE, "37813.59" },
6105     { "root/date",      VT_DATE, "665413" },
6106     { "root/time",      VT_DATE, "0.5813889" },
6107     { "root/timetz",    VT_DATE, "1.112512" },
6108     { "root/i1",        VT_I1,   "-13" },
6109     { "root/i2",        VT_I2,   "31915" },
6110     { "root/i4",        VT_I4,   "-312232" },
6111     { "root/ui1",       VT_UI1,  "123" },
6112     { "root/ui2",       VT_UI2,  "48282" },
6113     { "root/ui4",       VT_UI4,  "949281" },
6114     { "root/r4",        VT_R4,   "213124" },
6115     { "root/r8",        VT_R8,   "0.412" },
6116     { "root/float",     VT_R8,   "41221.421" },
6117     { "root/uuid",      VT_BSTR, "333C7BC4-460F-11D0-BC04-0080C7055a83" },
6118     { 0 }
6119 };
6120
6121 static void test_nodeTypedValue(void)
6122 {
6123     const nodetypedvalue_t *entry = get_nodetypedvalue;
6124     IXMLDOMDocument *doc;
6125     IXMLDOMNode *node;
6126     VARIANT_BOOL b;
6127     VARIANT value;
6128     HRESULT hr;
6129
6130     doc = create_document(&IID_IXMLDOMDocument);
6131     if (!doc) return;
6132
6133     b = VARIANT_FALSE;
6134     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &b);
6135     ok(hr == S_OK, "ret %08x\n", hr );
6136     ok(b == VARIANT_TRUE, "got %d\n", b);
6137
6138     hr = IXMLDOMDocument_get_nodeValue(doc, NULL);
6139     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6140
6141     V_VT(&value) = VT_BSTR;
6142     V_BSTR(&value) = NULL;
6143     hr = IXMLDOMDocument_get_nodeValue(doc, &value);
6144     ok(hr == S_FALSE, "ret %08x\n", hr );
6145     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6146
6147     hr = IXMLDOMDocument_get_nodeTypedValue(doc, NULL);
6148     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6149
6150     hr = IXMLDOMDocument_get_nodeTypedValue(doc, &value);
6151     ok(hr == S_FALSE, "ret %08x\n", hr );
6152
6153     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/string"), &node);
6154     ok(hr == S_OK, "ret %08x\n", hr );
6155
6156     V_VT(&value) = VT_BSTR;
6157     V_BSTR(&value) = NULL;
6158     hr = IXMLDOMNode_get_nodeValue(node, &value);
6159     ok(hr == S_FALSE, "ret %08x\n", hr );
6160     ok(V_VT(&value) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&value));
6161
6162     hr = IXMLDOMNode_get_nodeTypedValue(node, NULL);
6163     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
6164
6165     IXMLDOMNode_Release(node);
6166
6167     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/binhex"), &node);
6168     ok(hr == S_OK, "ret %08x\n", hr );
6169     {
6170         BYTE bytes[] = {0xff,0xfc,0xa0,0x12,0x00,0x3c};
6171
6172         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6173         ok(hr == S_OK, "ret %08x\n", hr );
6174         ok(V_VT(&value) == (VT_ARRAY|VT_UI1), "incorrect type\n");
6175         ok(V_ARRAY(&value)->rgsabound[0].cElements == 6, "incorrect array size\n");
6176         if(V_ARRAY(&value)->rgsabound[0].cElements == 6)
6177             ok(!memcmp(bytes, V_ARRAY(&value)->pvData, sizeof(bytes)), "incorrect value\n");
6178         VariantClear(&value);
6179         IXMLDOMNode_Release(node);
6180     }
6181
6182     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root/binbase64"), &node);
6183     ok(hr == S_OK, "ret %08x\n", hr );
6184     {
6185         BYTE bytes[] = {0x62,0x61,0x73,0x65,0x36,0x34,0x20,0x74,0x65,0x73,0x74};
6186
6187         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6188         ok(hr == S_OK, "ret %08x\n", hr );
6189         ok(V_VT(&value) == (VT_ARRAY|VT_UI1), "incorrect type\n");
6190         ok(V_ARRAY(&value)->rgsabound[0].cElements == 11, "incorrect array size\n");
6191         if(V_ARRAY(&value)->rgsabound[0].cElements == 11)
6192             ok(!memcmp(bytes, V_ARRAY(&value)->pvData, sizeof(bytes)), "incorrect value\n");
6193         VariantClear(&value);
6194         IXMLDOMNode_Release(node);
6195     }
6196
6197     while (entry->name)
6198     {
6199         hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_(entry->name), &node);
6200         ok(hr == S_OK, "ret %08x\n", hr );
6201
6202         hr = IXMLDOMNode_get_nodeTypedValue(node, &value);
6203         ok(hr == S_OK, "ret %08x\n", hr );
6204         ok(V_VT(&value) == entry->type, "incorrect type, expected %d, got %d\n", entry->type, V_VT(&value));
6205
6206         if (entry->type != VT_BSTR)
6207         {
6208            if (entry->type == VT_DATE ||
6209                entry->type == VT_R8 ||
6210                entry->type == VT_CY)
6211            {
6212                if (entry->type == VT_DATE)
6213                {
6214                    hr = VariantChangeType(&value, &value, 0, VT_R4);
6215                    ok(hr == S_OK, "ret %08x\n", hr );
6216                }
6217                hr = VariantChangeTypeEx(&value, &value,
6218                                         MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT),
6219                                         VARIANT_NOUSEROVERRIDE, VT_BSTR);
6220                ok(hr == S_OK, "ret %08x\n", hr );
6221            }
6222            else
6223            {
6224                hr = VariantChangeType(&value, &value, 0, VT_BSTR);
6225                ok(hr == S_OK, "ret %08x\n", hr );
6226            }
6227
6228            ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
6229               "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
6230         }
6231         else
6232            ok(lstrcmpW( V_BSTR(&value), _bstr_(entry->value)) == 0,
6233                "expected %s, got %s\n", entry->value, wine_dbgstr_w(V_BSTR(&value)));
6234
6235         VariantClear( &value );
6236         IXMLDOMNode_Release(node);
6237
6238         entry++;
6239     }
6240
6241     IXMLDOMDocument_Release(doc);
6242     free_bstrs();
6243 }
6244
6245 static void test_TransformWithLoadingLocalFile(void)
6246 {
6247     IXMLDOMDocument *doc;
6248     IXMLDOMDocument *xsl;
6249     IXMLDOMNode *pNode;
6250     VARIANT_BOOL bSucc;
6251     HRESULT hr;
6252     HANDLE file;
6253     DWORD dwWritten;
6254     char lpPathBuffer[MAX_PATH];
6255     int i;
6256
6257     /* Create a Temp File. */
6258     GetTempPathA(MAX_PATH, lpPathBuffer);
6259     strcat(lpPathBuffer, "customers.xml" );
6260
6261     file = CreateFile(lpPathBuffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
6262     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
6263     if(file == INVALID_HANDLE_VALUE)
6264         return;
6265
6266     WriteFile(file, szBasicTransformXML, strlen(szBasicTransformXML), &dwWritten, NULL);
6267     CloseHandle(file);
6268
6269     /* Correct path to not include a escape character. */
6270     for(i=0; i < strlen(lpPathBuffer); i++)
6271     {
6272         if(lpPathBuffer[i] == '\\')
6273             lpPathBuffer[i] = '/';
6274     }
6275
6276     doc = create_document(&IID_IXMLDOMDocument);
6277     if (!doc) return;
6278
6279     xsl = create_document(&IID_IXMLDOMDocument);
6280     if (!xsl)
6281     {
6282         IXMLDOMDocument2_Release(doc);
6283         return;
6284     }
6285
6286     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
6287     ok(hr == S_OK, "ret %08x\n", hr );
6288     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6289     if(bSucc == VARIANT_TRUE)
6290     {
6291         BSTR sXSL;
6292         BSTR sPart1 = _bstr_(szBasicTransformSSXMLPart1);
6293         BSTR sPart2 = _bstr_(szBasicTransformSSXMLPart2);
6294         BSTR sFileName = _bstr_(lpPathBuffer);
6295         int nLegnth = lstrlenW(sPart1) + lstrlenW(sPart2) + lstrlenW(sFileName) + 1;
6296
6297         sXSL = SysAllocStringLen(NULL, nLegnth);
6298         lstrcpyW(sXSL, sPart1);
6299         lstrcatW(sXSL, sFileName);
6300         lstrcatW(sXSL, sPart2);
6301
6302         hr = IXMLDOMDocument_loadXML(xsl, sXSL, &bSucc);
6303         ok(hr == S_OK, "ret %08x\n", hr );
6304         ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
6305         if(bSucc == VARIANT_TRUE)
6306         {
6307             BSTR sResult;
6308
6309             hr = IXMLDOMDocument_QueryInterface(xsl, &IID_IXMLDOMNode, (void**)&pNode );
6310             ok(hr == S_OK, "ret %08x\n", hr );
6311             if(hr == S_OK)
6312             {
6313                 /* This will load the temp file via the XSL */
6314                 hr = IXMLDOMDocument_transformNode(doc, pNode, &sResult);
6315                 ok(hr == S_OK, "ret %08x\n", hr );
6316                 if(hr == S_OK)
6317                 {
6318                     ok( compareIgnoreReturns( sResult, _bstr_(szBasicTransformOutput)), "Stylesheet output not correct\n");
6319                     SysFreeString(sResult);
6320                 }
6321
6322                 IXMLDOMNode_Release(pNode);
6323             }
6324         }
6325
6326         SysFreeString(sXSL);
6327     }
6328
6329     IXMLDOMDocument_Release(doc);
6330     IXMLDOMDocument_Release(xsl);
6331
6332     DeleteFile(lpPathBuffer);
6333     free_bstrs();
6334 }
6335
6336 static void test_put_nodeValue(void)
6337 {
6338     static const WCHAR jeevesW[] = {'J','e','e','v','e','s',' ','&',' ','W','o','o','s','t','e','r',0};
6339     IXMLDOMDocument *doc;
6340     IXMLDOMText *text;
6341     IXMLDOMEntityReference *entityref;
6342     IXMLDOMAttribute *attr;
6343     IXMLDOMNode *node;
6344     HRESULT hr;
6345     VARIANT data, type;
6346
6347     doc = create_document(&IID_IXMLDOMDocument);
6348     if (!doc) return;
6349
6350     /* test for unsupported types */
6351     /* NODE_DOCUMENT */
6352     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&node);
6353     ok(hr == S_OK, "ret %08x\n", hr );
6354     V_VT(&data) = VT_BSTR;
6355     V_BSTR(&data) = _bstr_("one two three");
6356     hr = IXMLDOMNode_put_nodeValue(node, data);
6357     ok(hr == E_FAIL, "ret %08x\n", hr );
6358     IXMLDOMNode_Release(node);
6359
6360     /* NODE_DOCUMENT_FRAGMENT */
6361     V_VT(&type) = VT_I1;
6362     V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
6363     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
6364     ok(hr == S_OK, "ret %08x\n", hr );
6365     V_VT(&data) = VT_BSTR;
6366     V_BSTR(&data) = _bstr_("one two three");
6367     hr = IXMLDOMNode_put_nodeValue(node, data);
6368     ok(hr == E_FAIL, "ret %08x\n", hr );
6369     IXMLDOMNode_Release(node);
6370
6371     /* NODE_ELEMENT */
6372     V_VT(&type) = VT_I1;
6373     V_I1(&type) = NODE_ELEMENT;
6374     hr = IXMLDOMDocument_createNode(doc, type, _bstr_("test"), NULL, &node);
6375     ok(hr == S_OK, "ret %08x\n", hr );
6376     V_VT(&data) = VT_BSTR;
6377     V_BSTR(&data) = _bstr_("one two three");
6378     hr = IXMLDOMNode_put_nodeValue(node, data);
6379     ok(hr == E_FAIL, "ret %08x\n", hr );
6380     IXMLDOMNode_Release(node);
6381
6382     /* NODE_ENTITY_REFERENCE */
6383     hr = IXMLDOMDocument_createEntityReference(doc, _bstr_("ref"), &entityref);
6384     ok(hr == S_OK, "ret %08x\n", hr );
6385
6386     V_VT(&data) = VT_BSTR;
6387     V_BSTR(&data) = _bstr_("one two three");
6388     hr = IXMLDOMEntityReference_put_nodeValue(entityref, data);
6389     ok(hr == E_FAIL, "ret %08x\n", hr );
6390
6391     hr = IXMLDOMEntityReference_QueryInterface(entityref, &IID_IXMLDOMNode, (void**)&node);
6392     ok(hr == S_OK, "ret %08x\n", hr );
6393     V_VT(&data) = VT_BSTR;
6394     V_BSTR(&data) = _bstr_("one two three");
6395     hr = IXMLDOMNode_put_nodeValue(node, data);
6396     ok(hr == E_FAIL, "ret %08x\n", hr );
6397     IXMLDOMNode_Release(node);
6398     IXMLDOMEntityReference_Release(entityref);
6399
6400     /* supported types */
6401     hr = IXMLDOMDocument_createTextNode(doc, _bstr_(""), &text);
6402     ok(hr == S_OK, "ret %08x\n", hr );
6403     V_VT(&data) = VT_BSTR;
6404     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
6405     hr = IXMLDOMText_put_nodeValue(text, data);
6406     ok(hr == S_OK, "ret %08x\n", hr );
6407     IXMLDOMText_Release(text);
6408
6409     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
6410     ok(hr == S_OK, "ret %08x\n", hr );
6411     V_VT(&data) = VT_BSTR;
6412     V_BSTR(&data) = _bstr_("Jeeves & Wooster");
6413     hr = IXMLDOMAttribute_put_nodeValue(attr, data);
6414     ok(hr == S_OK, "ret %08x\n", hr );
6415     hr = IXMLDOMAttribute_get_nodeValue(attr, &data);
6416     ok(hr == S_OK, "ret %08x\n", hr );
6417     ok(memcmp(V_BSTR(&data), jeevesW, sizeof(jeevesW)) == 0, "got %s\n",
6418         wine_dbgstr_w(V_BSTR(&data)));
6419     VariantClear(&data);
6420     IXMLDOMAttribute_Release(attr);
6421
6422     free_bstrs();
6423
6424     IXMLDOMDocument_Release(doc);
6425 }
6426
6427 static void test_IObjectSafety_set(IObjectSafety *safety, HRESULT result, HRESULT result2, DWORD set, DWORD mask, DWORD expected, DWORD expected2)
6428 {
6429     DWORD enabled, supported;
6430     HRESULT hr;
6431
6432     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL, set, mask);
6433     if (result == result2)
6434         ok(hr == result, "SetInterfaceSafetyOptions: expected %08x, returned %08x\n", result, hr );
6435     else
6436         ok(broken(hr == result) || hr == result2,
6437            "SetInterfaceSafetyOptions: expected %08x, got %08x\n", result2, hr );
6438
6439     supported = enabled = 0xCAFECAFE;
6440     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
6441     ok(hr == S_OK, "ret %08x\n", hr );
6442     if (expected == expected2)
6443         ok(enabled == expected, "Expected %08x, got %08x\n", expected, enabled);
6444     else
6445         ok(broken(enabled == expected) || enabled == expected2,
6446            "Expected %08x, got %08x\n", expected2, enabled);
6447
6448     /* reset the safety options */
6449
6450     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
6451             INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER,
6452             0);
6453     ok(hr == S_OK, "ret %08x\n", hr );
6454
6455     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
6456     ok(hr == S_OK, "ret %08x\n", hr );
6457     ok(enabled == 0, "Expected 0, got %08x\n", enabled);
6458 }
6459
6460 static void test_document_IObjectSafety(void)
6461 {
6462     IXMLDOMDocument *doc;
6463     IObjectSafety *safety;
6464     DWORD enabled = 0, supported = 0;
6465     HRESULT hr;
6466
6467     doc = create_document(&IID_IXMLDOMDocument);
6468     if (!doc) return;
6469
6470     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IObjectSafety, (void**)&safety);
6471     ok(hr == S_OK, "ret %08x\n", hr );
6472
6473     /* get */
6474     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, NULL, &enabled);
6475     ok(hr == E_POINTER, "ret %08x\n", hr );
6476     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, NULL);
6477     ok(hr == E_POINTER, "ret %08x\n", hr );
6478
6479     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
6480     ok(hr == S_OK, "ret %08x\n", hr );
6481     ok(broken(supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA)) ||
6482        supported == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
6483         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER), "
6484              "got %08x\n", supported);
6485     ok(enabled == 0, "Expected 0, got %08x\n", enabled);
6486
6487     /* set -- individual flags */
6488
6489     test_IObjectSafety_set(safety, S_OK, S_OK,
6490         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER,
6491         INTERFACESAFE_FOR_UNTRUSTED_CALLER, INTERFACESAFE_FOR_UNTRUSTED_CALLER);
6492
6493     test_IObjectSafety_set(safety, S_OK, S_OK,
6494         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA,
6495         INTERFACESAFE_FOR_UNTRUSTED_DATA, INTERFACESAFE_FOR_UNTRUSTED_DATA);
6496
6497     test_IObjectSafety_set(safety, S_OK, S_OK,
6498         INTERFACE_USES_SECURITY_MANAGER, INTERFACE_USES_SECURITY_MANAGER,
6499         0, INTERFACE_USES_SECURITY_MANAGER /* msxml3 SP8+ */);
6500
6501     /* set INTERFACE_USES_DISPEX  */
6502
6503     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
6504         INTERFACE_USES_DISPEX, INTERFACE_USES_DISPEX,
6505         0, 0);
6506
6507     test_IObjectSafety_set(safety, S_OK, E_FAIL /* msxml3 SP8+ */,
6508         INTERFACE_USES_DISPEX, 0,
6509         0, 0);
6510
6511     test_IObjectSafety_set(safety, S_OK, S_OK /* msxml3 SP8+ */,
6512         0, INTERFACE_USES_DISPEX,
6513         0, 0);
6514
6515     /* set option masking */
6516
6517     test_IObjectSafety_set(safety, S_OK, S_OK,
6518         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
6519         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
6520         INTERFACESAFE_FOR_UNTRUSTED_CALLER,
6521         INTERFACESAFE_FOR_UNTRUSTED_CALLER);
6522
6523     test_IObjectSafety_set(safety, S_OK, S_OK,
6524         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
6525         INTERFACESAFE_FOR_UNTRUSTED_DATA,
6526         INTERFACESAFE_FOR_UNTRUSTED_DATA,
6527         INTERFACESAFE_FOR_UNTRUSTED_DATA);
6528
6529     test_IObjectSafety_set(safety, S_OK, S_OK,
6530         INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA,
6531         INTERFACE_USES_SECURITY_MANAGER,
6532         0,
6533         0);
6534
6535     /* set -- inheriting previous settings */
6536
6537     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
6538                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER,
6539                                                          INTERFACESAFE_FOR_UNTRUSTED_CALLER);
6540     ok(hr == S_OK, "ret %08x\n", hr );
6541     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
6542     ok(hr == S_OK, "ret %08x\n", hr );
6543     todo_wine
6544     ok(broken(enabled == INTERFACESAFE_FOR_UNTRUSTED_CALLER) ||
6545        enabled == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACE_USES_SECURITY_MANAGER) /* msxml3 SP8+ */,
6546          "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACE_USES_SECURITY_MANAGER), "
6547          "got %08x\n", enabled);
6548
6549     hr = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
6550                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA,
6551                                                          INTERFACESAFE_FOR_UNTRUSTED_DATA);
6552     ok(hr == S_OK, "ret %08x\n", hr );
6553     hr = IObjectSafety_GetInterfaceSafetyOptions(safety, NULL, &supported, &enabled);
6554     ok(hr == S_OK, "ret %08x\n", hr );
6555     todo_wine
6556     ok(broken(enabled == INTERFACESAFE_FOR_UNTRUSTED_DATA) ||
6557        enabled == (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA) /* msxml3 SP8+ */,
6558         "Expected (INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA), "
6559         "got %08x\n", enabled);
6560
6561     IObjectSafety_Release(safety);
6562
6563     IXMLDOMDocument_Release(doc);
6564 }
6565
6566 typedef struct _property_test_t {
6567     const GUID *guid;
6568     const char *clsid;
6569     const char *property;
6570     const char *value;
6571 } property_test_t;
6572
6573 static const property_test_t properties_test_data[] = {
6574     { &CLSID_DOMDocument,  "CLSID_DOMDocument" , "SelectionLanguage", "XSLPattern" },
6575     { &CLSID_DOMDocument2,  "CLSID_DOMDocument2" , "SelectionLanguage", "XSLPattern" },
6576     { &CLSID_DOMDocument30, "CLSID_DOMDocument30", "SelectionLanguage", "XSLPattern" },
6577     { &CLSID_DOMDocument40, "CLSID_DOMDocument40", "SelectionLanguage", "XPath" },
6578     { &CLSID_DOMDocument60, "CLSID_DOMDocument60", "SelectionLanguage", "XPath" },
6579     { 0 }
6580 };
6581
6582 static void test_default_properties(void)
6583 {
6584     const property_test_t *entry = properties_test_data;
6585     IXMLDOMDocument2 *doc;
6586     VARIANT var;
6587     HRESULT hr;
6588
6589     while (entry->guid)
6590     {
6591         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (void**)&doc);
6592         if (hr != S_OK)
6593         {
6594             win_skip("can't create %s instance\n", entry->clsid);
6595             entry++;
6596             continue;
6597         }
6598
6599         hr = IXMLDOMDocument2_getProperty(doc, _bstr_(entry->property), &var);
6600         ok(hr == S_OK, "got 0x%08x\n", hr);
6601         ok(lstrcmpW(V_BSTR(&var), _bstr_(entry->value)) == 0, "expected %s, for %s\n",
6602            entry->value, entry->clsid);
6603         VariantClear(&var);
6604
6605         IXMLDOMDocument2_Release(doc);
6606
6607         entry++;
6608     }
6609 }
6610
6611 static void test_XSLPattern(void)
6612 {
6613     IXMLDOMDocument2 *doc;
6614     IXMLDOMNodeList *list;
6615     VARIANT_BOOL b;
6616     LONG len;
6617
6618     doc = create_document(&IID_IXMLDOMDocument2);
6619     if (!doc) return;
6620
6621     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szExampleXML), &b));
6622     ok(b == VARIANT_TRUE, "failed to load XML string\n");
6623
6624     /* switch to XSLPattern */
6625     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
6626
6627     /* XPath doesn't select elements with non-null default namespace with unqualified selectors, XSLPattern does */
6628     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//elem/c"), &list));
6629     len = 0;
6630     ole_check(IXMLDOMNodeList_get_length(list, &len));
6631     /* should select <elem><c> and <elem xmlns='...'><c> but not <elem><foo:c> */
6632     ok(len == 3, "expected 3 entries in list, got %d\n", len);
6633     IXMLDOMNodeList_Release(list);
6634
6635     /* for XSLPattern start index is 0, for XPath it's 1 */
6636     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[0]"), &list));
6637     len = 0;
6638     ole_check(IXMLDOMNodeList_get_length(list, &len));
6639     ok(len != 0, "expected filled list\n");
6640     if (len)
6641         expect_list_and_release(list, "E1.E2.D1");
6642
6643     /* index() */
6644     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index()=1]"), &list));
6645     len = 0;
6646     ole_check(IXMLDOMNodeList_get_length(list, &len));
6647     ok(len != 0, "expected filled list\n");
6648     if (len)
6649         expect_list_and_release(list, "E2.E2.D1");
6650
6651     /* $eq$ */
6652     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() $eq$ 1]"), &list));
6653     len = 0;
6654     ole_check(IXMLDOMNodeList_get_length(list, &len));
6655     ok(len != 0, "expected filled list\n");
6656     if (len)
6657         expect_list_and_release(list, "E2.E2.D1");
6658
6659     /* end() */
6660     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[end()]"), &list));
6661     len = 0;
6662     ole_check(IXMLDOMNodeList_get_length(list, &len));
6663     ok(len != 0, "expected filled list\n");
6664     if (len)
6665         expect_list_and_release(list, "E4.E2.D1");
6666
6667     /* $not$ */
6668     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[$not$ end()]"), &list));
6669     len = 0;
6670     ole_check(IXMLDOMNodeList_get_length(list, &len));
6671     ok(len != 0, "expected filled list\n");
6672     if (len)
6673         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
6674
6675     /* !=/$ne$ */
6676     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() != 0]"), &list));
6677     len = 0;
6678     ole_check(IXMLDOMNodeList_get_length(list, &len));
6679     ok(len != 0, "expected filled list\n");
6680     if (len)
6681         expect_list_and_release(list, "E2.E2.D1 E3.E2.D1 E4.E2.D1");
6682     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() $ne$ 0]"), &list));
6683     len = 0;
6684     ole_check(IXMLDOMNodeList_get_length(list, &len));
6685     ok(len != 0, "expected filled list\n");
6686     if (len)
6687         expect_list_and_release(list, "E2.E2.D1 E3.E2.D1 E4.E2.D1");
6688
6689     /* </$lt$ */
6690     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() < 2]"), &list));
6691     len = 0;
6692     ole_check(IXMLDOMNodeList_get_length(list, &len));
6693     ok(len != 0, "expected filled list\n");
6694     if (len)
6695         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1");
6696     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() $lt$ 2]"), &list));
6697     len = 0;
6698     ole_check(IXMLDOMNodeList_get_length(list, &len));
6699     ok(len != 0, "expected filled list\n");
6700     if (len)
6701         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1");
6702
6703     /* <=/$le$ */
6704     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() <= 1]"), &list));
6705     len = 0;
6706     ole_check(IXMLDOMNodeList_get_length(list, &len));
6707     ok(len != 0, "expected filled list\n");
6708     if (len)
6709         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1");
6710     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() $le$ 1]"), &list));
6711     len = 0;
6712     ole_check(IXMLDOMNodeList_get_length(list, &len));
6713     ok(len != 0, "expected filled list\n");
6714     if (len)
6715         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1");
6716
6717     /* >/$gt$ */
6718     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() > 1]"), &list));
6719     len = 0;
6720     ole_check(IXMLDOMNodeList_get_length(list, &len));
6721     ok(len != 0, "expected filled list\n");
6722     if (len)
6723         expect_list_and_release(list, "E3.E2.D1 E4.E2.D1");
6724     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() $gt$ 1]"), &list));
6725     len = 0;
6726     ole_check(IXMLDOMNodeList_get_length(list, &len));
6727     ok(len != 0, "expected filled list\n");
6728     if (len)
6729         expect_list_and_release(list, "E3.E2.D1 E4.E2.D1");
6730
6731     /* >=/$ge$ */
6732     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() >= 2]"), &list));
6733     len = 0;
6734     ole_check(IXMLDOMNodeList_get_length(list, &len));
6735     ok(len != 0, "expected filled list\n");
6736     if (len)
6737         expect_list_and_release(list, "E3.E2.D1 E4.E2.D1");
6738     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index() $ge$ 2]"), &list));
6739     len = 0;
6740     ole_check(IXMLDOMNodeList_get_length(list, &len));
6741     ok(len != 0, "expected filled list\n");
6742     if (len)
6743         expect_list_and_release(list, "E3.E2.D1 E4.E2.D1");
6744
6745     /* $ieq$ */
6746     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[a $ieq$ 'a2 field']"), &list));
6747     len = 0;
6748     ole_check(IXMLDOMNodeList_get_length(list, &len));
6749     ok(len != 0, "expected filled list\n");
6750     if (len)
6751         expect_list_and_release(list, "E2.E2.D1");
6752
6753     /* $ine$ */
6754     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[a $ine$ 'a2 field']"), &list));
6755     len = 0;
6756     ole_check(IXMLDOMNodeList_get_length(list, &len));
6757     ok(len != 0, "expected filled list\n");
6758     if (len)
6759         expect_list_and_release(list, "E1.E2.D1 E3.E2.D1 E4.E2.D1");
6760
6761     /* $ilt$ */
6762     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[a $ilt$ 'a3 field']"), &list));
6763     len = 0;
6764     ole_check(IXMLDOMNodeList_get_length(list, &len));
6765     ok(len != 0, "expected filled list\n");
6766     if (len)
6767         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1");
6768
6769     /* $ile$ */
6770     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[a $ile$ 'a2 field']"), &list));
6771     len = 0;
6772     ole_check(IXMLDOMNodeList_get_length(list, &len));
6773     ok(len != 0, "expected filled list\n");
6774     if (len)
6775         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1");
6776
6777     /* $igt$ */
6778     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[a $igt$ 'a2 field']"), &list));
6779     len = 0;
6780     ole_check(IXMLDOMNodeList_get_length(list, &len));
6781     ok(len != 0, "expected filled list\n");
6782     if (len)
6783         expect_list_and_release(list, "E3.E2.D1 E4.E2.D1");
6784
6785     /* $ige$ */
6786     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[a $ige$ 'a3 field']"), &list));
6787     len = 0;
6788     ole_check(IXMLDOMNodeList_get_length(list, &len));
6789     ok(len != 0, "expected filled list\n");
6790     if (len)
6791         expect_list_and_release(list, "E3.E2.D1 E4.E2.D1");
6792
6793     /* $any$ */
6794     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[$any$ *='B2 field']"), &list));
6795     len = 0;
6796     ole_check(IXMLDOMNodeList_get_length(list, &len));
6797     ok(len != 0, "expected filled list\n");
6798     if (len)
6799         expect_list_and_release(list, "E2.E2.D1");
6800
6801     /* $all$ */
6802     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[$all$ *!='B2 field']"), &list));
6803     len = 0;
6804     ole_check(IXMLDOMNodeList_get_length(list, &len));
6805     ok(len != 0, "expected filled list\n");
6806     if (len)
6807         expect_list_and_release(list, "E1.E2.D1 E3.E2.D1 E4.E2.D1");
6808
6809     /* or/$or$/|| */
6810     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index()=0 or end()]"), &list));
6811     len = 0;
6812     ole_check(IXMLDOMNodeList_get_length(list, &len));
6813     ok(len != 0, "expected filled list\n");
6814     if (len)
6815         expect_list_and_release(list, "E1.E2.D1 E4.E2.D1");
6816     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index()=0 $or$ end()]"), &list));
6817     len = 0;
6818     ole_check(IXMLDOMNodeList_get_length(list, &len));
6819     ok(len != 0, "expected filled list\n");
6820     if (len)
6821         expect_list_and_release(list, "E1.E2.D1 E4.E2.D1");
6822     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index()=0 || end()]"), &list));
6823     len = 0;
6824     ole_check(IXMLDOMNodeList_get_length(list, &len));
6825     ok(len != 0, "expected filled list\n");
6826     if (len)
6827         expect_list_and_release(list, "E1.E2.D1 E4.E2.D1");
6828
6829     /* and/$and$/&& */
6830     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index()>0 and $not$ end()]"), &list));
6831     len = 0;
6832     ole_check(IXMLDOMNodeList_get_length(list, &len));
6833     ok(len != 0, "expected filled list\n");
6834     if (len)
6835         expect_list_and_release(list, "E2.E2.D1 E3.E2.D1");
6836     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index()>0 $and$ $not$ end()]"), &list));
6837     len = 0;
6838     ole_check(IXMLDOMNodeList_get_length(list, &len));
6839     ok(len != 0, "expected filled list\n");
6840     if (len)
6841         expect_list_and_release(list, "E2.E2.D1 E3.E2.D1");
6842     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root//elem[index()>0 && $not$ end()]"), &list));
6843     len = 0;
6844     ole_check(IXMLDOMNodeList_get_length(list, &len));
6845     ok(len != 0, "expected filled list\n");
6846     if (len)
6847         expect_list_and_release(list, "E2.E2.D1 E3.E2.D1");
6848
6849     /* namespace handling */
6850     /* no registered namespaces */
6851     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("")));
6852     list = NULL;
6853
6854     /* prefixes don't need to be registered, you may use them as they are in the doc */
6855     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//bar:x"), &list));
6856     len = 0;
6857     ole_check(IXMLDOMNodeList_get_length(list, &len));
6858     ok(len != 0, "expected filled list\n");
6859     if (len)
6860         expect_list_and_release(list, "E5.E1.E4.E1.E2.D1 E6.E2.E4.E1.E2.D1");
6861
6862     /* prefixes must be explicitly specified in the name */
6863     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:elem"), &list));
6864     len = 0;
6865     ole_check(IXMLDOMNodeList_get_length(list, &len));
6866     ok(len == 0, "expected empty list\n");
6867     if (len)
6868         IXMLDOMNodeList_Release(list);
6869
6870     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list));
6871     len = 0;
6872     ole_check(IXMLDOMNodeList_get_length(list, &len));
6873     ok(len != 0, "expected filled list\n");
6874     if (len)
6875         expect_list_and_release(list, "E3.E4.E2.D1");
6876
6877     /* explicitly register prefix foo */
6878     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
6879
6880     /* now we get the same behavior as XPath */
6881     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list));
6882     len = 0;
6883     ole_check(IXMLDOMNodeList_get_length(list, &len));
6884     ok(len != 0, "expected filled list\n");
6885     if (len)
6886         expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
6887
6888     /* set prefix foo to some nonexistent namespace */
6889     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:foo='urn:nonexistent-foo'")));
6890
6891     /* the registered prefix takes precedence */
6892     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//foo:c"), &list));
6893     len = 0;
6894     ole_check(IXMLDOMNodeList_get_length(list, &len));
6895     ok(len == 0, "expected empty list\n");
6896     if (len)
6897         IXMLDOMNodeList_Release(list);
6898
6899     IXMLDOMDocument2_Release(doc);
6900
6901     doc = create_document(&IID_IXMLDOMDocument2);
6902     if (!doc) return;
6903
6904     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szNodeTypesXML), &b));
6905     ok(b == VARIANT_TRUE, "failed to load XML string\n");
6906     list = NULL;
6907
6908     /* attribute() */
6909     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("attribute()"), &list));
6910     len = 0;
6911     ole_check(IXMLDOMNodeList_get_length(list, &len));
6912     ok(len == 0, "expected empty list\n");
6913     if (len)
6914         IXMLDOMNodeList_Release(list);
6915
6916     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("attribute('depth')"), &list));
6917     len = 0;
6918     ole_check(IXMLDOMNodeList_get_length(list, &len));
6919     ok(len == 0, "expected empty list\n");
6920     if (len)
6921         IXMLDOMNodeList_Release(list);
6922
6923     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root/attribute('depth')"), &list));
6924     len = 0;
6925     ole_check(IXMLDOMNodeList_get_length(list, &len));
6926     ok(len != 0, "expected filled list\n");
6927     if (len)
6928         expect_list_and_release(list, "A'depth'.E3.D1");
6929
6930     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//x/attribute()"), &list));
6931     len = 0;
6932     ole_check(IXMLDOMNodeList_get_length(list, &len));
6933     ok(len != 0, "expected filled list\n");
6934     if (len)
6935         expect_list_and_release(list, "A'id'.E3.E3.D1 A'depth'.E3.E3.D1");
6936
6937     list = NULL;
6938     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("//x//attribute(id)"), &list), E_FAIL);
6939     if (list)
6940         IXMLDOMNodeList_Release(list);
6941     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//x//attribute('id')"), &list));
6942     len = 0;
6943     ole_check(IXMLDOMNodeList_get_length(list, &len));
6944     ok(len != 0, "expected filled list\n");
6945     if (len)
6946         expect_list_and_release(list, "A'id'.E3.E3.D1 A'id'.E4.E3.E3.D1 A'id'.E5.E3.E3.D1 A'id'.E6.E3.E3.D1");
6947
6948     /* comment() */
6949     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("comment()"), &list));
6950     len = 0;
6951     ole_check(IXMLDOMNodeList_get_length(list, &len));
6952     ok(len != 0, "expected filled list\n");
6953     if (len)
6954         expect_list_and_release(list, "C2.D1");
6955
6956     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//comment()"), &list));
6957     len = 0;
6958     ole_check(IXMLDOMNodeList_get_length(list, &len));
6959     ok(len != 0, "expected filled list\n");
6960     if (len)
6961         expect_list_and_release(list, "C2.D1 C1.E3.D1 C2.E3.E3.D1 C2.E4.E3.D1");
6962
6963     /* element() */
6964     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("element()"), &list));
6965     len = 0;
6966     ole_check(IXMLDOMNodeList_get_length(list, &len));
6967     ok(len != 0, "expected filled list\n");
6968     if (len)
6969         expect_list_and_release(list, "E3.D1");
6970
6971     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root/y/element()"), &list));
6972     len = 0;
6973     ole_check(IXMLDOMNodeList_get_length(list, &len));
6974     ok(len != 0, "expected filled list\n");
6975     if (len)
6976         expect_list_and_release(list, "E4.E4.E3.D1 E5.E4.E3.D1 E6.E4.E3.D1");
6977
6978     list = NULL;
6979     ole_expect(IXMLDOMDocument2_selectNodes(doc, _bstr_("//element(a)"), &list), E_FAIL);
6980     if (list)
6981         IXMLDOMNodeList_Release(list);
6982     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//element('a')"), &list));
6983     len = 0;
6984     ole_check(IXMLDOMNodeList_get_length(list, &len));
6985     ok(len != 0, "expected filled list\n");
6986     if (len)
6987         expect_list_and_release(list, "E4.E3.E3.D1 E4.E4.E3.D1");
6988
6989     /* node() */
6990     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("node()"), &list));
6991     len = 0;
6992     ole_check(IXMLDOMNodeList_get_length(list, &len));
6993     ok(len != 0, "expected filled list\n");
6994     if (len)
6995         expect_list_and_release(list, "P1.D1 C2.D1 E3.D1");
6996
6997     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//x/node()"), &list));
6998     len = 0;
6999     ole_check(IXMLDOMNodeList_get_length(list, &len));
7000     ok(len != 0, "expected filled list\n");
7001     if (len)
7002         expect_list_and_release(list, "P1.E3.E3.D1 C2.E3.E3.D1 T3.E3.E3.D1 E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1");
7003
7004     /* nodeType() */
7005     /* XML_ELEMENT_NODE */
7006     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//x/node()[nodeType()=1]"), &list));
7007     len = 0;
7008     ole_check(IXMLDOMNodeList_get_length(list, &len));
7009     ok(len != 0, "expected filled list\n");
7010     if (len)
7011         expect_list_and_release(list, "E4.E3.E3.D1 E5.E3.E3.D1 E6.E3.E3.D1");
7012     /* XML_TEXT_NODE */
7013     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//x/node()[nodeType()=3]"), &list));
7014     len = 0;
7015     ole_check(IXMLDOMNodeList_get_length(list, &len));
7016     ok(len != 0, "expected filled list\n");
7017     if (len)
7018         expect_list_and_release(list, "T3.E3.E3.D1");
7019     /* XML_PI_NODE */
7020     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//x/node()[nodeType()=7]"), &list));
7021     len = 0;
7022     ole_check(IXMLDOMNodeList_get_length(list, &len));
7023     ok(len != 0, "expected filled list\n");
7024     if (len)
7025         expect_list_and_release(list, "P1.E3.E3.D1");
7026     /* XML_COMMENT_NODE */
7027     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//x/node()[nodeType()=8]"), &list));
7028     len = 0;
7029     ole_check(IXMLDOMNodeList_get_length(list, &len));
7030     ok(len != 0, "expected filled list\n");
7031     if (len)
7032         expect_list_and_release(list, "C2.E3.E3.D1");
7033
7034     /* pi() */
7035     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("pi()"), &list));
7036     if (list)
7037     {
7038         len = 0;
7039         ole_check(IXMLDOMNodeList_get_length(list, &len));
7040         ok(len != 0, "expected filled list\n");
7041         if (len)
7042             expect_list_and_release(list, "P1.D1");
7043     }
7044
7045     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("//y/pi()"), &list));
7046     len = 0;
7047     ole_check(IXMLDOMNodeList_get_length(list, &len));
7048     ok(len != 0, "expected filled list\n");
7049     if (len)
7050         expect_list_and_release(list, "P1.E4.E3.D1");
7051
7052     /* textnode() */
7053     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root/textnode()"), &list));
7054     len = 0;
7055     ole_check(IXMLDOMNodeList_get_length(list, &len));
7056     ok(len != 0, "expected filled list\n");
7057     if (len)
7058         expect_list_and_release(list, "T2.E3.D1");
7059
7060     ole_check(IXMLDOMDocument2_selectNodes(doc, _bstr_("root/element()/textnode()"), &list));
7061     len = 0;
7062     ole_check(IXMLDOMNodeList_get_length(list, &len));
7063     ok(len != 0, "expected filled list\n");
7064     if (len)
7065         expect_list_and_release(list, "T3.E3.E3.D1 T3.E4.E3.D1");
7066
7067     IXMLDOMDocument2_Release(doc);
7068     free_bstrs();
7069 }
7070
7071 static void test_splitText(void)
7072 {
7073     IXMLDOMCDATASection *cdata;
7074     IXMLDOMElement *root;
7075     IXMLDOMDocument *doc;
7076     IXMLDOMText *text, *text2;
7077     IXMLDOMNode *node;
7078     VARIANT var;
7079     VARIANT_BOOL success;
7080     LONG length;
7081     HRESULT hr;
7082
7083     doc = create_document(&IID_IXMLDOMDocument);
7084     if (!doc) return;
7085
7086     hr = IXMLDOMDocument_loadXML(doc, _bstr_("<root></root>"), &success);
7087     ok(hr == S_OK, "got 0x%08x\n", hr);
7088
7089     hr = IXMLDOMDocument_get_documentElement(doc, &root);
7090     ok(hr == S_OK, "got 0x%08x\n", hr);
7091
7092     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("beautiful plumage"), &cdata);
7093     ok(hr == S_OK, "got 0x%08x\n", hr);
7094
7095     V_VT(&var) = VT_EMPTY;
7096     hr = IXMLDOMElement_appendChild(root, (IXMLDOMNode*)cdata, NULL);
7097     ok(hr == S_OK, "got 0x%08x\n", hr);
7098
7099     length = 0;
7100     hr = IXMLDOMCDATASection_get_length(cdata, &length);
7101     ok(hr == S_OK, "got 0x%08x\n", hr);
7102     ok(length > 0, "got %d\n", length);
7103
7104     hr = IXMLDOMCDATASection_splitText(cdata, 0, NULL);
7105     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7106
7107     text = (void*)0xdeadbeef;
7108     /* negative offset */
7109     hr = IXMLDOMCDATASection_splitText(cdata, -1, &text);
7110     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7111     ok(text == (void*)0xdeadbeef, "got %p\n", text);
7112
7113     text = (void*)0xdeadbeef;
7114     /* offset outside data */
7115     hr = IXMLDOMCDATASection_splitText(cdata, length + 1, &text);
7116     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7117     ok(text == 0, "got %p\n", text);
7118
7119     text = (void*)0xdeadbeef;
7120     /* offset outside data */
7121     hr = IXMLDOMCDATASection_splitText(cdata, length, &text);
7122     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7123     ok(text == 0, "got %p\n", text);
7124
7125     /* no empty node created */
7126     node = (void*)0xdeadbeef;
7127     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7128     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7129     ok(node == 0, "got %p\n", text);
7130
7131     hr = IXMLDOMCDATASection_splitText(cdata, 10, &text);
7132     ok(hr == S_OK, "got 0x%08x\n", hr);
7133
7134     length = 0;
7135     hr = IXMLDOMText_get_length(text, &length);
7136     ok(hr == S_OK, "got 0x%08x\n", hr);
7137     ok(length == 7, "got %d\n", length);
7138
7139     hr = IXMLDOMCDATASection_get_nextSibling(cdata, &node);
7140     ok(hr == S_OK, "got 0x%08x\n", hr);
7141     IXMLDOMNode_Release(node);
7142
7143     /* split new text node */
7144     hr = IXMLDOMText_get_length(text, &length);
7145     ok(hr == S_OK, "got 0x%08x\n", hr);
7146
7147     node = (void*)0xdeadbeef;
7148     hr = IXMLDOMText_get_nextSibling(text, &node);
7149     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7150     ok(node == 0, "got %p\n", text);
7151
7152     hr = IXMLDOMText_splitText(text, 0, NULL);
7153     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7154
7155     text2 = (void*)0xdeadbeef;
7156     /* negative offset */
7157     hr = IXMLDOMText_splitText(text, -1, &text2);
7158     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7159     ok(text2 == (void*)0xdeadbeef, "got %p\n", text2);
7160
7161     text2 = (void*)0xdeadbeef;
7162     /* offset outside data */
7163     hr = IXMLDOMText_splitText(text, length + 1, &text2);
7164     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
7165     ok(text2 == 0, "got %p\n", text2);
7166
7167     text2 = (void*)0xdeadbeef;
7168     /* offset outside data */
7169     hr = IXMLDOMText_splitText(text, length, &text2);
7170     ok(hr == S_FALSE, "got 0x%08x\n", hr);
7171     ok(text2 == 0, "got %p\n", text);
7172
7173     text2 = 0;
7174     hr = IXMLDOMText_splitText(text, 4, &text2);
7175     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7176     if (text2) IXMLDOMText_Release(text2);
7177
7178     node = 0;
7179     hr = IXMLDOMText_get_nextSibling(text, &node);
7180     todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
7181     if (node) IXMLDOMNode_Release(node);
7182
7183     IXMLDOMText_Release(text);
7184     IXMLDOMElement_Release(root);
7185     IXMLDOMCDATASection_Release(cdata);
7186     free_bstrs();
7187 }
7188
7189 static void test_getQualifiedItem(void)
7190 {
7191     IXMLDOMDocument *doc;
7192     IXMLDOMElement *element;
7193     IXMLDOMNode *pr_node, *node;
7194     IXMLDOMNodeList *root_list;
7195     IXMLDOMNamedNodeMap *map;
7196     VARIANT_BOOL b;
7197     BSTR str;
7198     LONG len;
7199     HRESULT hr;
7200
7201     doc = create_document(&IID_IXMLDOMDocument);
7202     if (!doc) return;
7203
7204     str = SysAllocString( szComplete4 );
7205     hr = IXMLDOMDocument_loadXML( doc, str, &b );
7206     ok( hr == S_OK, "loadXML failed\n");
7207     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7208     SysFreeString( str );
7209
7210     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7211     ok( hr == S_OK, "ret %08x\n", hr);
7212
7213     hr = IXMLDOMElement_get_childNodes(element, &root_list);
7214     ok( hr == S_OK, "ret %08x\n", hr);
7215
7216     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7217     ok( hr == S_OK, "ret %08x\n", hr);
7218     IXMLDOMNodeList_Release(root_list);
7219
7220     hr = IXMLDOMNode_get_attributes(pr_node, &map);
7221     ok( hr == S_OK, "ret %08x\n", hr);
7222     IXMLDOMNode_Release(pr_node);
7223
7224     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7225     ok( hr == S_OK, "ret %08x\n", hr);
7226     ok( len == 3, "length %d\n", len);
7227
7228     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, NULL);
7229     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7230
7231     node = (void*)0xdeadbeef;
7232     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, NULL, NULL, &node);
7233     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7234     ok( node == (void*)0xdeadbeef, "got %p\n", node);
7235
7236     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, NULL);
7237     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7238
7239     hr = IXMLDOMNamedNodeMap_getQualifiedItem(map, _bstr_("id"), NULL, &node);
7240     ok( hr == S_OK, "ret %08x\n", hr);
7241     IXMLDOMNode_Release(node);
7242
7243     IXMLDOMNamedNodeMap_Release( map );
7244     IXMLDOMElement_Release( element );
7245     IXMLDOMDocument_Release( doc );
7246     free_bstrs();
7247 }
7248
7249 static void test_removeQualifiedItem(void)
7250 {
7251     IXMLDOMDocument *doc;
7252     IXMLDOMElement *element;
7253     IXMLDOMNode *pr_node, *node;
7254     IXMLDOMNodeList *root_list;
7255     IXMLDOMNamedNodeMap *map;
7256     VARIANT_BOOL b;
7257     BSTR str;
7258     LONG len;
7259     HRESULT hr;
7260
7261     doc = create_document(&IID_IXMLDOMDocument);
7262     if (!doc) return;
7263
7264     str = SysAllocString( szComplete4 );
7265     hr = IXMLDOMDocument_loadXML( doc, str, &b );
7266     ok( hr == S_OK, "loadXML failed\n");
7267     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7268     SysFreeString( str );
7269
7270     hr = IXMLDOMDocument_get_documentElement(doc, &element);
7271     ok( hr == S_OK, "ret %08x\n", hr);
7272
7273     hr = IXMLDOMElement_get_childNodes(element, &root_list);
7274     ok( hr == S_OK, "ret %08x\n", hr);
7275
7276     hr = IXMLDOMNodeList_get_item(root_list, 1, &pr_node);
7277     ok( hr == S_OK, "ret %08x\n", hr);
7278     IXMLDOMNodeList_Release(root_list);
7279
7280     hr = IXMLDOMNode_get_attributes(pr_node, &map);
7281     ok( hr == S_OK, "ret %08x\n", hr);
7282     IXMLDOMNode_Release(pr_node);
7283
7284     hr = IXMLDOMNamedNodeMap_get_length(map, &len);
7285     ok( hr == S_OK, "ret %08x\n", hr);
7286     ok( len == 3, "length %d\n", len);
7287
7288     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, NULL);
7289     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7290
7291     node = (void*)0xdeadbeef;
7292     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, NULL, NULL, &node);
7293     ok( hr == E_INVALIDARG, "ret %08x\n", hr);
7294     ok( node == (void*)0xdeadbeef, "got %p\n", node);
7295
7296     /* out pointer is optional */
7297     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7298     ok( hr == S_OK, "ret %08x\n", hr);
7299
7300     /* already removed */
7301     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("id"), NULL, NULL);
7302     ok( hr == S_FALSE, "ret %08x\n", hr);
7303
7304     hr = IXMLDOMNamedNodeMap_removeQualifiedItem(map, _bstr_("vr"), NULL, &node);
7305     ok( hr == S_OK, "ret %08x\n", hr);
7306     IXMLDOMNode_Release(node);
7307
7308     IXMLDOMNamedNodeMap_Release( map );
7309     IXMLDOMElement_Release( element );
7310     IXMLDOMDocument_Release( doc );
7311     free_bstrs();
7312 }
7313
7314 static void test_get_ownerDocument(void)
7315 {
7316     IXMLDOMDocument *doc1, *doc2, *doc3;
7317     IXMLDOMDocument2 *doc, *doc_owner;
7318     IXMLDOMNode *node;
7319     VARIANT_BOOL b;
7320     VARIANT var;
7321     HRESULT hr;
7322     BSTR str;
7323
7324     doc = create_document(&IID_IXMLDOMDocument2);
7325     if (!doc) return;
7326
7327     str = SysAllocString( szComplete4 );
7328     hr = IXMLDOMDocument_loadXML( doc, str, &b );
7329     ok( hr == S_OK, "loadXML failed\n");
7330     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7331     SysFreeString( str );
7332
7333     hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var);
7334     ok( hr == S_OK, "got 0x%08x\n", hr);
7335     ok( lstrcmpW(V_BSTR(&var), _bstr_("XSLPattern")) == 0, "expected XSLPattern\n");
7336     VariantClear(&var);
7337
7338     /* set to XPath and check that new instances use it */
7339     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath"));
7340     ok( hr == S_OK, "got 0x%08x\n", hr);
7341
7342     hr = IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"), _variantbstr_("xmlns:wi=\'www.winehq.org\'"));
7343     ok( hr == S_OK, "got 0x%08x\n", hr);
7344
7345     hr = IXMLDOMDocument2_get_firstChild(doc, &node);
7346     ok( hr == S_OK, "got 0x%08x\n", hr);
7347
7348     hr = IXMLDOMNode_get_ownerDocument(node, &doc1);
7349     ok( hr == S_OK, "got 0x%08x\n", hr);
7350
7351     hr = IXMLDOMDocument_QueryInterface(doc1, &IID_IXMLDOMDocument2, (void**)&doc_owner);
7352     ok( hr == S_OK, "got 0x%08x\n", hr);
7353     ok( doc_owner != doc, "got %p, doc %p\n", doc_owner, doc);
7354     hr = IXMLDOMDocument2_getProperty(doc_owner, _bstr_("SelectionNamespaces"), &var);
7355     ok( hr == S_OK, "got 0x%08x\n", hr);
7356     ok( lstrcmpW(V_BSTR(&var), _bstr_("xmlns:wi=\'www.winehq.org\'")) == 0, "expected previously set value\n");
7357     VariantClear(&var);
7358
7359     hr = IXMLDOMDocument2_getProperty(doc_owner, _bstr_("SelectionLanguage"), &var);
7360     ok( hr == S_OK, "got 0x%08x\n", hr);
7361     ok( lstrcmpW(V_BSTR(&var), _bstr_("XPath")) == 0, "expected XPath\n");
7362     VariantClear(&var);
7363     IXMLDOMDocument2_Release(doc_owner);
7364
7365     hr = IXMLDOMNode_get_ownerDocument(node, &doc2);
7366     ok( hr == S_OK, "got 0x%08x\n", hr);
7367     IXMLDOMNode_Release(node);
7368
7369     ok(doc1 != doc2, "got %p, expected %p. original %p\n", doc2, doc1, doc);
7370
7371     /* reload */
7372     str = SysAllocString( szComplete4 );
7373     hr = IXMLDOMDocument2_loadXML( doc, str, &b );
7374     ok( hr == S_OK, "got 0x%08x\n", hr);
7375     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7376     SysFreeString( str );
7377
7378     /* properties retained even after reload */
7379     hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var);
7380     ok( hr == S_OK, "got 0x%08x\n", hr);
7381     ok( lstrcmpW(V_BSTR(&var), _bstr_("xmlns:wi=\'www.winehq.org\'")) == 0, "expected previously set value\n");
7382     VariantClear(&var);
7383
7384     hr = IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionLanguage"), &var);
7385     ok( hr == S_OK, "got 0x%08x\n", hr);
7386     ok( lstrcmpW(V_BSTR(&var), _bstr_("XPath")) == 0, "expected XPath\n");
7387     VariantClear(&var);
7388
7389     hr = IXMLDOMDocument2_get_firstChild(doc, &node);
7390     ok( hr == S_OK, "got 0x%08x\n", hr);
7391
7392     hr = IXMLDOMNode_get_ownerDocument(node, &doc3);
7393     ok( hr == S_OK, "got 0x%08x\n", hr);
7394     IXMLDOMNode_Release(node);
7395
7396     hr = IXMLDOMDocument_QueryInterface(doc3, &IID_IXMLDOMDocument2, (void**)&doc_owner);
7397     ok( hr == S_OK, "got 0x%08x\n", hr);
7398     ok(doc3 != doc1 && doc3 != doc2 && doc_owner != doc, "got %p, (%p, %p, %p)\n", doc3, doc, doc1, doc2);
7399
7400     IXMLDOMDocument_Release(doc1);
7401     IXMLDOMDocument_Release(doc2);
7402     IXMLDOMDocument_Release(doc3);
7403     IXMLDOMDocument2_Release(doc);
7404     free_bstrs();
7405 }
7406
7407 static void test_setAttributeNode(void)
7408 {
7409     IXMLDOMDocument *doc, *doc2;
7410     IXMLDOMElement *elem;
7411     IXMLDOMAttribute *attr, *attr2, *ret_attr;
7412     VARIANT_BOOL b;
7413     HRESULT hr;
7414     BSTR str;
7415
7416     doc = create_document(&IID_IXMLDOMDocument);
7417     if (!doc) return;
7418
7419     str = SysAllocString( szComplete4 );
7420     hr = IXMLDOMDocument2_loadXML( doc, str, &b );
7421     ok( hr == S_OK, "loadXML failed\n");
7422     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7423     SysFreeString( str );
7424
7425     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7426     ok( hr == S_OK, "got 0x%08x\n", hr);
7427
7428     ret_attr = (void*)0xdeadbeef;
7429     hr = IXMLDOMElement_setAttributeNode(elem, NULL, &ret_attr);
7430     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
7431     ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7432
7433     hr = IXMLDOMDocument_createAttribute(doc, _bstr_("attr"), &attr);
7434     ok( hr == S_OK, "got 0x%08x\n", hr);
7435
7436     ret_attr = (void*)0xdeadbeef;
7437     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7438     ok( hr == S_OK, "got 0x%08x\n", hr);
7439     ok( ret_attr == NULL, "got %p\n", ret_attr);
7440
7441     attr2 = NULL;
7442     hr = IXMLDOMElement_getAttributeNode(elem, _bstr_("attr"), &attr2);
7443     ok( hr == S_OK, "got 0x%08x\n", hr);
7444     IXMLDOMAttribute_Release(attr2);
7445
7446     /* try to add it another time */
7447     ret_attr = (void*)0xdeadbeef;
7448     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7449     todo_wine ok( hr == E_FAIL, "got 0x%08x\n", hr);
7450     todo_wine ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7451
7452     IXMLDOMElement_Release(elem);
7453
7454     /* initialy used element is released, attribute still 'has' a container */
7455     hr = IXMLDOMDocument_get_documentElement(doc, &elem);
7456     ok( hr == S_OK, "got 0x%08x\n", hr);
7457     ret_attr = (void*)0xdeadbeef;
7458     hr = IXMLDOMElement_setAttributeNode(elem, attr, &ret_attr);
7459     todo_wine ok( hr == E_FAIL, "got 0x%08x\n", hr);
7460     todo_wine ok( ret_attr == (void*)0xdeadbeef, "got %p\n", ret_attr);
7461     IXMLDOMElement_Release(elem);
7462
7463     /* add attribute already attached to another document */
7464     doc2 = create_document(&IID_IXMLDOMDocument);
7465
7466     str = SysAllocString( szComplete4 );
7467     hr = IXMLDOMDocument_loadXML( doc2, str, &b );
7468     ok( hr == S_OK, "loadXML failed\n");
7469     ok( b == VARIANT_TRUE, "failed to load XML string\n");
7470     SysFreeString( str );
7471
7472     hr = IXMLDOMDocument_get_documentElement(doc2, &elem);
7473     ok( hr == S_OK, "got 0x%08x\n", hr);
7474     hr = IXMLDOMElement_setAttributeNode(elem, attr, NULL);
7475     todo_wine ok( hr == E_FAIL, "got 0x%08x\n", hr);
7476     IXMLDOMElement_Release(elem);
7477
7478     IXMLDOMDocument_Release(doc2);
7479
7480     IXMLDOMAttribute_Release(attr);
7481     IXMLDOMDocument_Release(doc);
7482     free_bstrs();
7483 }
7484
7485 static void test_XDR_schemas(void)
7486 {
7487     IXMLDOMDocument2 *doc, *schema;
7488     IXMLDOMSchemaCollection* cache;
7489     IXMLDOMParseError* err;
7490     VARIANT_BOOL b;
7491     VARIANT v;
7492     BSTR bstr;
7493
7494     doc = create_document(&IID_IXMLDOMDocument2);
7495     schema = create_document(&IID_IXMLDOMDocument2);
7496     cache = create_cache(&IID_IXMLDOMSchemaCollection);
7497
7498     if (!doc || !schema || !cache)
7499     {
7500         if (doc)    IXMLDOMDocument2_Release(doc);
7501         if (schema) IXMLDOMDocument2_Release(schema);
7502         if (cache)  IXMLDOMSchemaCollection_Release(cache);
7503
7504         return;
7505     }
7506
7507     VariantInit(&v);
7508
7509     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML1), &b));
7510     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7511
7512     ole_check(IXMLDOMDocument2_loadXML(schema, _bstr_(szOpenSeqXDR), &b));
7513     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7514
7515     /* load the schema */
7516     V_VT(&v) = VT_DISPATCH;
7517     V_DISPATCH(&v) = NULL;
7518     ole_check(IXMLDOMDocument2_QueryInterface(schema, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
7519     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
7520     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(""), v));
7521     VariantClear(&v);
7522
7523     /* associate the cache to the doc */
7524     V_VT(&v) = VT_DISPATCH;
7525     V_DISPATCH(&v) = NULL;
7526     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
7527     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
7528     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
7529     VariantClear(&v);
7530
7531     /* validate the doc
7532      * only declared elements in the declared order
7533      * this is fine */
7534     err = NULL;
7535     bstr = NULL;
7536     ole_check(IXMLDOMDocument2_validate(doc, &err));
7537     ok(err != NULL, "domdoc_validate() should always set err\n");
7538     ole_expect(IXMLDOMParseError_get_reason(err, &bstr), S_FALSE);
7539     ok(IXMLDOMParseError_get_reason(err, &bstr) == S_FALSE, "got error: %s\n", wine_dbgstr_w(bstr));
7540     if (bstr) SysFreeString(bstr);
7541     IXMLDOMParseError_Release(err);
7542
7543     /* load the next doc */
7544     IXMLDOMDocument2_Release(doc);
7545     doc = create_document(&IID_IXMLDOMDocument2);
7546     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML2), &b));
7547     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7548
7549     /* associate the cache to the doc */
7550     V_VT(&v) = VT_DISPATCH;
7551     V_DISPATCH(&v) = NULL;
7552     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
7553     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
7554     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
7555     VariantClear(&v);
7556
7557     /* validate the doc
7558      * declared elements in the declared order, with an extra declared element at the end
7559      * this is fine */
7560     err = NULL;
7561     bstr = NULL;
7562     ole_check(IXMLDOMDocument2_validate(doc, &err));
7563     ok(err != NULL, "domdoc_validate() should always set err\n");
7564     ole_expect(IXMLDOMParseError_get_reason(err, &bstr), S_FALSE);
7565     ok(IXMLDOMParseError_get_reason(err, &bstr) == S_FALSE, "got error: %s\n", wine_dbgstr_w(bstr));
7566     if (bstr) SysFreeString(bstr);
7567     IXMLDOMParseError_Release(err);
7568
7569     /* load the next doc */
7570     IXMLDOMDocument2_Release(doc);
7571     doc = create_document(&IID_IXMLDOMDocument2);
7572     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML3), &b));
7573     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7574
7575     /* associate the cache to the doc */
7576     V_VT(&v) = VT_DISPATCH;
7577     V_DISPATCH(&v) = NULL;
7578     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
7579     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
7580     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
7581     VariantClear(&v);
7582
7583     /* validate the doc
7584      * fails, extra elements are only allowed at the end */
7585     err = NULL;
7586     bstr = NULL;
7587     ole_expect(IXMLDOMDocument2_validate(doc, &err), S_FALSE);
7588     ok(err != NULL, "domdoc_validate() should always set err\n");
7589     todo_wine ok(IXMLDOMParseError_get_reason(err, &bstr) == S_OK, "got error: %s\n", wine_dbgstr_w(bstr));
7590     if (bstr) SysFreeString(bstr);
7591     IXMLDOMParseError_Release(err);
7592
7593     /* load the next doc */
7594     IXMLDOMDocument2_Release(doc);
7595     doc = create_document(&IID_IXMLDOMDocument2);
7596     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML4), &b));
7597     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7598
7599     /* associate the cache to the doc */
7600     V_VT(&v) = VT_DISPATCH;
7601     V_DISPATCH(&v) = NULL;
7602     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
7603     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
7604     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
7605     VariantClear(&v);
7606
7607     /* validate the doc
7608      * fails, undeclared elements are not allowed */
7609     err = NULL;
7610     bstr = NULL;
7611     ole_expect(IXMLDOMDocument2_validate(doc, &err), S_FALSE);
7612     ok(err != NULL, "domdoc_validate() should always set err\n");
7613     todo_wine ok(IXMLDOMParseError_get_reason(err, &bstr) == S_OK, "got error: %s\n", wine_dbgstr_w(bstr));
7614     if (bstr) SysFreeString(bstr);
7615     IXMLDOMParseError_Release(err);
7616
7617     IXMLDOMDocument2_Release(doc);
7618     IXMLDOMDocument2_Release(schema);
7619     IXMLDOMSchemaCollection_Release(cache);
7620
7621     free_bstrs();
7622 }
7623
7624 static void test_get_dataType(void)
7625 {
7626     IXMLDOMDocument2 *doc, *schema;
7627     IXMLDOMSchemaCollection* cache;
7628     IXMLDOMNode* node;
7629     IXMLDOMParseError* err;
7630     VARIANT_BOOL b;
7631     VARIANT v;
7632     LONG l;
7633     BSTR bstr;
7634
7635     VariantInit(&v);
7636
7637     doc = create_document(&IID_IXMLDOMDocument2);
7638     schema = create_document(&IID_IXMLDOMDocument2);
7639     cache = create_cache(&IID_IXMLDOMSchemaCollection);
7640
7641     if (!doc || !schema || !cache)
7642     {
7643         if (doc)    IXMLDOMDocument2_Release(doc);
7644         if (schema) IXMLDOMDocument2_Release(schema);
7645         if (cache)  IXMLDOMSchemaCollection_Release(cache);
7646
7647         return;
7648     }
7649
7650     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szDatatypeXML), &b));
7651     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7652
7653     ole_check(IXMLDOMDocument2_loadXML(schema, _bstr_(szDatatypeXDR), &b));
7654     ok(b == VARIANT_TRUE, "failed to load XML string\n");
7655
7656     err = NULL;
7657     ole_expect(IXMLDOMDocument2_validate(doc, &err), S_FALSE);
7658     ok(err != NULL, "domdoc_validate() should always set err\n");
7659     ole_check(IXMLDOMParseError_get_errorCode(err, &l));
7660     ok(l == E_XML_NODTD, "got %08x\n", l);
7661     IXMLDOMParseError_Release(err);
7662
7663     /* check data types without the schema */
7664     node = NULL;
7665     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBase64']/Value/base64Data"), &node));
7666     ok(node != NULL, "expected node\n");
7667     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7668     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7669     if (V_VT(&v) == VT_BSTR)
7670         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7671     VariantClear(&v);
7672     IXMLDOMNode_Release(node);
7673
7674     node = NULL;
7675     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testHex']/Value/hexData"), &node));
7676     ok(node != NULL, "expected node\n");
7677     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7678     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7679     if (V_VT(&v) == VT_BSTR)
7680         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7681     VariantClear(&v);
7682     IXMLDOMNode_Release(node);
7683
7684     node = NULL;
7685     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBool']/Value/boolData"), &node));
7686     ok(node != NULL, "expected node\n");
7687     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7688     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7689     if (V_VT(&v) == VT_BSTR)
7690         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7691     VariantClear(&v);
7692     IXMLDOMNode_Release(node);
7693
7694     node = NULL;
7695     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testChar']/Value/charData"), &node));
7696     ok(node != NULL, "expected node\n");
7697     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7698     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7699     if (V_VT(&v) == VT_BSTR)
7700         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7701     VariantClear(&v);
7702     IXMLDOMNode_Release(node);
7703
7704     node = NULL;
7705     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDate']/Value/dateData"), &node));
7706     ok(node != NULL, "expected node\n");
7707     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7708     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7709     if (V_VT(&v) == VT_BSTR)
7710         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7711     VariantClear(&v);
7712     IXMLDOMNode_Release(node);
7713
7714     node = NULL;
7715     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTime']/Value/dateTimeData"), &node));
7716     ok(node != NULL, "expected node\n");
7717     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7718     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7719     if (V_VT(&v) == VT_BSTR)
7720         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7721     VariantClear(&v);
7722     IXMLDOMNode_Release(node);
7723
7724     node = NULL;
7725     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTimeTz']/Value/dateTimeTzData"), &node));
7726     ok(node != NULL, "expected node\n");
7727     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7728     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7729     if (V_VT(&v) == VT_BSTR)
7730         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7731     VariantClear(&v);
7732     IXMLDOMNode_Release(node);
7733
7734     node = NULL;
7735     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFixed']/Value/fixedData"), &node));
7736     ok(node != NULL, "expected node\n");
7737     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7738     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7739     if (V_VT(&v) == VT_BSTR)
7740         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7741     VariantClear(&v);
7742     IXMLDOMNode_Release(node);
7743
7744     node = NULL;
7745     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFloat']/Value/floatData"), &node));
7746     ok(node != NULL, "expected node\n");
7747     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7748     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7749     if (V_VT(&v) == VT_BSTR)
7750         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7751     VariantClear(&v);
7752     IXMLDOMNode_Release(node);
7753
7754     node = NULL;
7755     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI1']/Value/i1Data"), &node));
7756     ok(node != NULL, "expected node\n");
7757     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7758     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7759     if (V_VT(&v) == VT_BSTR)
7760         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7761     VariantClear(&v);
7762     IXMLDOMNode_Release(node);
7763
7764     node = NULL;
7765     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI2']/Value/i2Data"), &node));
7766     ok(node != NULL, "expected node\n");
7767     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7768     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7769     if (V_VT(&v) == VT_BSTR)
7770         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7771     VariantClear(&v);
7772     IXMLDOMNode_Release(node);
7773
7774     node = NULL;
7775     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI4']/Value/i4Data"), &node));
7776     ok(node != NULL, "expected node\n");
7777     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7778     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7779     if (V_VT(&v) == VT_BSTR)
7780         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7781     VariantClear(&v);
7782     IXMLDOMNode_Release(node);
7783
7784     node = NULL;
7785     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI8']/Value/i8Data"), &node));
7786     ok(node != NULL, "expected node\n");
7787     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7788     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7789     if (V_VT(&v) == VT_BSTR)
7790         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7791     VariantClear(&v);
7792     IXMLDOMNode_Release(node);
7793
7794     node = NULL;
7795     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testInt']/Value/intData"), &node));
7796     ok(node != NULL, "expected node\n");
7797     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7798     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7799     if (V_VT(&v) == VT_BSTR)
7800         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7801     VariantClear(&v);
7802     IXMLDOMNode_Release(node);
7803
7804     node = NULL;
7805     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtoken']/Value/nmtokData"), &node));
7806     ok(node != NULL, "expected node\n");
7807     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7808     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7809     if (V_VT(&v) == VT_BSTR)
7810         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7811     VariantClear(&v);
7812     IXMLDOMNode_Release(node);
7813
7814     node = NULL;
7815     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtokens']/Value/nmtoksData"), &node));
7816     ok(node != NULL, "expected node\n");
7817     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7818     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7819     if (V_VT(&v) == VT_BSTR)
7820         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7821     VariantClear(&v);
7822     IXMLDOMNode_Release(node);
7823
7824     node = NULL;
7825     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNumber']/Value/numData"), &node));
7826     ok(node != NULL, "expected node\n");
7827     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7828     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7829     if (V_VT(&v) == VT_BSTR)
7830         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7831     VariantClear(&v);
7832     IXMLDOMNode_Release(node);
7833
7834     node = NULL;
7835     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR4']/Value/r4Data"), &node));
7836     ok(node != NULL, "expected node\n");
7837     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7838     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7839     if (V_VT(&v) == VT_BSTR)
7840         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7841     VariantClear(&v);
7842     IXMLDOMNode_Release(node);
7843
7844     node = NULL;
7845     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR8']/Value/r8Data"), &node));
7846     ok(node != NULL, "expected node\n");
7847     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7848     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7849     if (V_VT(&v) == VT_BSTR)
7850         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7851     VariantClear(&v);
7852     IXMLDOMNode_Release(node);
7853
7854     node = NULL;
7855     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testString']/Value/stringData"), &node));
7856     ok(node != NULL, "expected node\n");
7857     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7858     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7859     if (V_VT(&v) == VT_BSTR)
7860         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7861     VariantClear(&v);
7862     IXMLDOMNode_Release(node);
7863
7864     node = NULL;
7865     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTime']/Value/timeData"), &node));
7866     ok(node != NULL, "expected node\n");
7867     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7868     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7869     if (V_VT(&v) == VT_BSTR)
7870         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7871     VariantClear(&v);
7872     IXMLDOMNode_Release(node);
7873
7874     node = NULL;
7875     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTimeTz']/Value/timeTzData"), &node));
7876     ok(node != NULL, "expected node\n");
7877     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7878     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7879     if (V_VT(&v) == VT_BSTR)
7880         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7881     VariantClear(&v);
7882     IXMLDOMNode_Release(node);
7883
7884     node = NULL;
7885     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU1']/Value/u1Data"), &node));
7886     ok(node != NULL, "expected node\n");
7887     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7888     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7889     if (V_VT(&v) == VT_BSTR)
7890         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7891     VariantClear(&v);
7892     IXMLDOMNode_Release(node);
7893
7894     node = NULL;
7895     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU2']/Value/u2Data"), &node));
7896     ok(node != NULL, "expected node\n");
7897     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7898     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7899     if (V_VT(&v) == VT_BSTR)
7900         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7901     VariantClear(&v);
7902     IXMLDOMNode_Release(node);
7903
7904     node = NULL;
7905     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU4']/Value/u4Data"), &node));
7906     ok(node != NULL, "expected node\n");
7907     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7908     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7909     if (V_VT(&v) == VT_BSTR)
7910         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7911     VariantClear(&v);
7912     IXMLDOMNode_Release(node);
7913
7914     node = NULL;
7915     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU8']/Value/u8Data"), &node));
7916     ok(node != NULL, "expected node\n");
7917     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7918     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7919     if (V_VT(&v) == VT_BSTR)
7920         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7921     VariantClear(&v);
7922     IXMLDOMNode_Release(node);
7923
7924     node = NULL;
7925     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testURI']/Value/uriData"), &node));
7926     ok(node != NULL, "expected node\n");
7927     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7928     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7929     if (V_VT(&v) == VT_BSTR)
7930         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7931     VariantClear(&v);
7932     IXMLDOMNode_Release(node);
7933
7934     node = NULL;
7935     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testUUID']/Value/uuidData"), &node));
7936     ok(node != NULL, "expected node\n");
7937     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
7938     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
7939     if (V_VT(&v) == VT_BSTR)
7940         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7941     VariantClear(&v);
7942     IXMLDOMNode_Release(node);
7943
7944     /* now load the schema */
7945     V_VT(&v) = VT_DISPATCH;
7946     V_DISPATCH(&v) = NULL;
7947     ole_check(IXMLDOMDocument2_QueryInterface(schema, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
7948     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
7949     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_("urn:x-schema:datatype-test-xdr"), v));
7950     VariantClear(&v);
7951
7952     /* associate the cache to the doc */
7953     V_VT(&v) = VT_DISPATCH;
7954     V_DISPATCH(&v) = NULL;
7955     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
7956     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
7957     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
7958     VariantClear(&v);
7959
7960     /* validate the doc */
7961     err = NULL;
7962     l = 0;
7963     bstr = NULL;
7964     ole_check(IXMLDOMDocument2_validate(doc, &err));
7965     ok(err != NULL, "domdoc_validate() should always set err\n");
7966     ole_expect(IXMLDOMParseError_get_errorCode(err, &l), S_FALSE);
7967     ole_expect(IXMLDOMParseError_get_reason(err, &bstr), S_FALSE);
7968     ok(l == 0, "got %08x : %s\n", l, wine_dbgstr_w(bstr));
7969     if (bstr) SysFreeString(bstr);
7970     IXMLDOMParseError_Release(err);
7971
7972     /* check the data types again */
7973     node = NULL;
7974     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBase64']/Value/base64Data"), &node));
7975     ok(node != NULL, "expected node\n");
7976     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
7977     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
7978     if (V_VT(&v) == VT_BSTR)
7979         ok(lstrcmpW(V_BSTR(&v), _bstr_("bin.base64")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7980     VariantClear(&v);
7981     IXMLDOMNode_Release(node);
7982
7983     node = NULL;
7984     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testHex']/Value/hexData"), &node));
7985     ok(node != NULL, "expected node\n");
7986     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
7987     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
7988     if (V_VT(&v) == VT_BSTR)
7989         ok(lstrcmpW(V_BSTR(&v), _bstr_("bin.hex")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
7990     VariantClear(&v);
7991     IXMLDOMNode_Release(node);
7992
7993     node = NULL;
7994     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBool']/Value/boolData"), &node));
7995     ok(node != NULL, "expected node\n");
7996     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
7997     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
7998     if (V_VT(&v) == VT_BSTR)
7999         ok(lstrcmpW(V_BSTR(&v), _bstr_("boolean")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8000     VariantClear(&v);
8001     IXMLDOMNode_Release(node);
8002
8003     node = NULL;
8004     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testChar']/Value/charData"), &node));
8005     ok(node != NULL, "expected node\n");
8006     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8007     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8008     if (V_VT(&v) == VT_BSTR)
8009         ok(lstrcmpW(V_BSTR(&v), _bstr_("char")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8010     VariantClear(&v);
8011     IXMLDOMNode_Release(node);
8012
8013     node = NULL;
8014     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDate']/Value/dateData"), &node));
8015     ok(node != NULL, "expected node\n");
8016     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8017     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8018     if (V_VT(&v) == VT_BSTR)
8019         ok(lstrcmpW(V_BSTR(&v), _bstr_("date")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8020     VariantClear(&v);
8021     IXMLDOMNode_Release(node);
8022
8023     node = NULL;
8024     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTime']/Value/dateTimeData"), &node));
8025     ok(node != NULL, "expected node\n");
8026     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8027     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8028     if (V_VT(&v) == VT_BSTR)
8029         ok(lstrcmpW(V_BSTR(&v), _bstr_("dateTime")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8030     VariantClear(&v);
8031     IXMLDOMNode_Release(node);
8032
8033     node = NULL;
8034     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTimeTz']/Value/dateTimeTzData"), &node));
8035     ok(node != NULL, "expected node\n");
8036     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8037     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8038     if (V_VT(&v) == VT_BSTR)
8039         ok(lstrcmpW(V_BSTR(&v), _bstr_("dateTime.tz")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8040     VariantClear(&v);
8041     IXMLDOMNode_Release(node);
8042
8043     node = NULL;
8044     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFixed']/Value/fixedData"), &node));
8045     ok(node != NULL, "expected node\n");
8046     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8047     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8048     if (V_VT(&v) == VT_BSTR)
8049         ok(lstrcmpW(V_BSTR(&v), _bstr_("fixed.14.4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8050     VariantClear(&v);
8051     IXMLDOMNode_Release(node);
8052
8053     node = NULL;
8054     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFloat']/Value/floatData"), &node));
8055     ok(node != NULL, "expected node\n");
8056     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8057     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8058     if (V_VT(&v) == VT_BSTR)
8059         ok(lstrcmpW(V_BSTR(&v), _bstr_("float")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8060     VariantClear(&v);
8061     IXMLDOMNode_Release(node);
8062
8063     node = NULL;
8064     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI1']/Value/i1Data"), &node));
8065     ok(node != NULL, "expected node\n");
8066     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8067     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8068     if (V_VT(&v) == VT_BSTR)
8069         ok(lstrcmpW(V_BSTR(&v), _bstr_("i1")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8070     VariantClear(&v);
8071     IXMLDOMNode_Release(node);
8072
8073     node = NULL;
8074     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI2']/Value/i2Data"), &node));
8075     ok(node != NULL, "expected node\n");
8076     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8077     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8078     if (V_VT(&v) == VT_BSTR)
8079         ok(lstrcmpW(V_BSTR(&v), _bstr_("i2")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8080     VariantClear(&v);
8081     IXMLDOMNode_Release(node);
8082
8083     node = NULL;
8084     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI4']/Value/i4Data"), &node));
8085     ok(node != NULL, "expected node\n");
8086     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8087     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8088     if (V_VT(&v) == VT_BSTR)
8089         ok(lstrcmpW(V_BSTR(&v), _bstr_("i4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8090     VariantClear(&v);
8091     IXMLDOMNode_Release(node);
8092
8093     node = NULL;
8094     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI8']/Value/i8Data"), &node));
8095     ok(node != NULL, "expected node\n");
8096     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8097     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8098     if (V_VT(&v) == VT_BSTR)
8099         ok(lstrcmpW(V_BSTR(&v), _bstr_("i8")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8100     VariantClear(&v);
8101     IXMLDOMNode_Release(node);
8102
8103     node = NULL;
8104     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testInt']/Value/intData"), &node));
8105     ok(node != NULL, "expected node\n");
8106     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8107     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8108     if (V_VT(&v) == VT_BSTR)
8109         ok(lstrcmpW(V_BSTR(&v), _bstr_("int")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8110     VariantClear(&v);
8111     IXMLDOMNode_Release(node);
8112
8113     /* nmtoken does not return a bstr */
8114     node = NULL;
8115     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtoken']/Value/nmtokData"), &node));
8116     ok(node != NULL, "expected node\n");
8117     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
8118     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
8119     if (V_VT(&v) == VT_BSTR)
8120         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8121     VariantClear(&v);
8122     IXMLDOMNode_Release(node);
8123
8124     /* nmtokens does not return a bstr */
8125     node = NULL;
8126     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtokens']/Value/nmtoksData"), &node));
8127     ok(node != NULL, "expected node\n");
8128     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
8129     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
8130     if (V_VT(&v) == VT_BSTR)
8131         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8132     VariantClear(&v);
8133     IXMLDOMNode_Release(node);
8134
8135     node = NULL;
8136     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNumber']/Value/numData"), &node));
8137     ok(node != NULL, "expected node\n");
8138     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8139     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8140     if (V_VT(&v) == VT_BSTR)
8141         ok(lstrcmpW(V_BSTR(&v), _bstr_("number")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8142     VariantClear(&v);
8143     IXMLDOMNode_Release(node);
8144
8145     node = NULL;
8146     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR4']/Value/r4Data"), &node));
8147     ok(node != NULL, "expected node\n");
8148     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8149     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8150     if (V_VT(&v) == VT_BSTR)
8151         ok(lstrcmpW(V_BSTR(&v), _bstr_("r4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8152     VariantClear(&v);
8153     IXMLDOMNode_Release(node);
8154
8155     node = NULL;
8156     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR8']/Value/r8Data"), &node));
8157     ok(node != NULL, "expected node\n");
8158     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8159     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8160     if (V_VT(&v) == VT_BSTR)
8161         ok(lstrcmpW(V_BSTR(&v), _bstr_("r8")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8162     VariantClear(&v);
8163     IXMLDOMNode_Release(node);
8164
8165     /* dt:string is the default, does not return a bstr */
8166     node = NULL;
8167     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testString']/Value/stringData"), &node));
8168     ok(node != NULL, "expected node\n");
8169     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
8170     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
8171     if (V_VT(&v) == VT_BSTR)
8172         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8173     VariantClear(&v);
8174     IXMLDOMNode_Release(node);
8175
8176     node = NULL;
8177     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTime']/Value/timeData"), &node));
8178     ok(node != NULL, "expected node\n");
8179     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8180     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8181     if (V_VT(&v) == VT_BSTR)
8182         ok(lstrcmpW(V_BSTR(&v), _bstr_("time")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8183     VariantClear(&v);
8184     IXMLDOMNode_Release(node);
8185
8186     node = NULL;
8187     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTimeTz']/Value/timeTzData"), &node));
8188     ok(node != NULL, "expected node\n");
8189     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8190     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8191     if (V_VT(&v) == VT_BSTR)
8192         ok(lstrcmpW(V_BSTR(&v), _bstr_("time.tz")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8193     VariantClear(&v);
8194     IXMLDOMNode_Release(node);
8195
8196     node = NULL;
8197     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU1']/Value/u1Data"), &node));
8198     ok(node != NULL, "expected node\n");
8199     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8200     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8201     if (V_VT(&v) == VT_BSTR)
8202         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui1")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8203     VariantClear(&v);
8204     IXMLDOMNode_Release(node);
8205
8206     node = NULL;
8207     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU2']/Value/u2Data"), &node));
8208     ok(node != NULL, "expected node\n");
8209     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8210     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8211     if (V_VT(&v) == VT_BSTR)
8212         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui2")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8213     VariantClear(&v);
8214     IXMLDOMNode_Release(node);
8215
8216     node = NULL;
8217     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU4']/Value/u4Data"), &node));
8218     ok(node != NULL, "expected node\n");
8219     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8220     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8221     if (V_VT(&v) == VT_BSTR)
8222         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8223     VariantClear(&v);
8224     IXMLDOMNode_Release(node);
8225
8226     node = NULL;
8227     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU8']/Value/u8Data"), &node));
8228     ok(node != NULL, "expected node\n");
8229     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8230     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8231     if (V_VT(&v) == VT_BSTR)
8232         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui8")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8233     VariantClear(&v);
8234     IXMLDOMNode_Release(node);
8235
8236     node = NULL;
8237     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testURI']/Value/uriData"), &node));
8238     ok(node != NULL, "expected node\n");
8239     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8240     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8241     if (V_VT(&v) == VT_BSTR)
8242         ok(lstrcmpW(V_BSTR(&v), _bstr_("uri")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8243     VariantClear(&v);
8244     IXMLDOMNode_Release(node);
8245
8246     node = NULL;
8247     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testUUID']/Value/uuidData"), &node));
8248     ok(node != NULL, "expected node\n");
8249     todo_wine ole_check(IXMLDOMNode_get_dataType(node, &v));
8250     todo_wine ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
8251     if (V_VT(&v) == VT_BSTR)
8252         ok(lstrcmpW(V_BSTR(&v), _bstr_("uuid")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
8253     VariantClear(&v);
8254     IXMLDOMNode_Release(node);
8255
8256     ok(IXMLDOMDocument2_Release(schema) == 0, "schema not released\n");
8257     ok(IXMLDOMDocument2_Release(doc) == 0, "doc not released\n");
8258     ok(IXMLDOMSchemaCollection_Release(cache) == 0, "cache not released\n");
8259
8260     free_bstrs();
8261 }
8262
8263 static void test_put_dataType(void)
8264 {
8265     IXMLDOMCDATASection *cdata;
8266     IXMLDOMDocument *doc;
8267     VARIANT_BOOL b;
8268     HRESULT hr;
8269     BSTR str;
8270
8271     doc = create_document(&IID_IXMLDOMDocument);
8272     if (!doc) return;
8273
8274     str = SysAllocString( szComplete4 );
8275     hr = IXMLDOMDocument_loadXML( doc, str, &b );
8276     ok( hr == S_OK, "loadXML failed\n");
8277     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8278     SysFreeString( str );
8279
8280     hr = IXMLDOMDocument_createCDATASection(doc, _bstr_("test"), &cdata);
8281     ok( hr == S_OK, "got 0x%08x\n", hr);
8282     hr = IXMLDOMCDATASection_put_dataType(cdata, _bstr_("number"));
8283     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8284     hr = IXMLDOMCDATASection_put_dataType(cdata, _bstr_("string"));
8285     ok( hr == E_FAIL, "got 0x%08x\n", hr);
8286     IXMLDOMCDATASection_Release(cdata);
8287
8288     IXMLDOMDocument_Release(doc);
8289     free_bstrs();
8290 }
8291
8292 static void test_createNode(void)
8293 {
8294     IXMLDOMDocument *doc;
8295     IXMLDOMElement *elem;
8296     IXMLDOMNode *node;
8297     VARIANT v, var;
8298     BSTR prefix, str;
8299     HRESULT hr;
8300
8301     doc = create_document(&IID_IXMLDOMDocument);
8302     if (!doc) return;
8303
8304     /* NODE_ELEMENT nodes */
8305     /* 1. specified namespace */
8306     V_VT(&v) = VT_I4;
8307     V_I4(&v) = NODE_ELEMENT;
8308
8309     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("ns1:test"), _bstr_("http://winehq.org"), &node);
8310     ok( hr == S_OK, "got 0x%08x\n", hr);
8311     prefix = NULL;
8312     hr = IXMLDOMNode_get_prefix(node, &prefix);
8313     ok( hr == S_OK, "got 0x%08x\n", hr);
8314     ok(lstrcmpW(prefix, _bstr_("ns1")) == 0, "wrong prefix\n");
8315     SysFreeString(prefix);
8316     IXMLDOMNode_Release(node);
8317
8318     /* 2. default namespace */
8319     hr = IXMLDOMDocument_createNode(doc, v, _bstr_("test"), _bstr_("http://winehq.org/default"), &node);
8320     ok( hr == S_OK, "got 0x%08x\n", hr);
8321     prefix = (void*)0xdeadbeef;
8322     hr = IXMLDOMNode_get_prefix(node, &prefix);
8323     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8324     ok(prefix == 0, "expected empty prefix, got %p\n", prefix);
8325
8326     hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)&elem);
8327     ok( hr == S_OK, "got 0x%08x\n", hr);
8328
8329     V_VT(&var) = VT_BSTR;
8330     hr = IXMLDOMElement_getAttribute(elem, _bstr_("xmlns"), &var);
8331     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8332     ok( V_VT(&var) == VT_NULL, "got %d\n", V_VT(&var));
8333
8334     str = NULL;
8335     hr = IXMLDOMElement_get_namespaceURI(elem, &str);
8336     ok( hr == S_OK, "got 0x%08x\n", hr);
8337     ok( lstrcmpW(str, _bstr_("http://winehq.org/default")) == 0, "expected default namespace\n");
8338     SysFreeString(str);
8339
8340     IXMLDOMElement_Release(elem);
8341     IXMLDOMNode_Release(node);
8342
8343     IXMLDOMDocument_Release(doc);
8344     free_bstrs();
8345 }
8346
8347 static void test_get_prefix(void)
8348 {
8349     IXMLDOMDocumentFragment *fragment;
8350     IXMLDOMCDATASection *cdata;
8351     IXMLDOMElement *element;
8352     IXMLDOMComment *comment;
8353     IXMLDOMDocument *doc;
8354     HRESULT hr;
8355     BSTR str;
8356
8357     doc = create_document(&IID_IXMLDOMDocument);
8358     if (!doc) return;
8359
8360     /* nodes that can't support prefix */
8361     /* 1. document */
8362     str = (void*)0xdeadbeef;
8363     hr = IXMLDOMDocument_get_prefix(doc, &str);
8364     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8365     ok( str == 0, "got %p\n", str);
8366
8367     hr = IXMLDOMDocument_get_prefix(doc, NULL);
8368     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
8369
8370     /* 2. cdata */
8371     hr = IXMLDOMDocument_createCDATASection(doc, NULL, &cdata);
8372     ok(hr == S_OK, "got %08x\n", hr );
8373
8374     str = (void*)0xdeadbeef;
8375     hr = IXMLDOMCDATASection_get_prefix(cdata, &str);
8376     ok(hr == S_FALSE, "got %08x\n", hr);
8377     ok( str == 0, "got %p\n", str);
8378
8379     hr = IXMLDOMCDATASection_get_prefix(cdata, NULL);
8380     ok(hr == E_INVALIDARG, "got %08x\n", hr);
8381     IXMLDOMCDATASection_Release(cdata);
8382
8383     /* 3. comment */
8384     hr = IXMLDOMDocument_createComment(doc, NULL, &comment);
8385     ok(hr == S_OK, "got %08x\n", hr );
8386
8387     str = (void*)0xdeadbeef;
8388     hr = IXMLDOMComment_get_prefix(comment, &str);
8389     ok(hr == S_FALSE, "got %08x\n", hr);
8390     ok( str == 0, "got %p\n", str);
8391
8392     hr = IXMLDOMComment_get_prefix(comment, NULL);
8393     ok(hr == E_INVALIDARG, "got %08x\n", hr);
8394     IXMLDOMComment_Release(comment);
8395
8396     /* 4. fragment */
8397     hr = IXMLDOMDocument_createDocumentFragment(doc, &fragment);
8398     ok(hr == S_OK, "got %08x\n", hr );
8399
8400     str = (void*)0xdeadbeef;
8401     hr = IXMLDOMDocumentFragment_get_prefix(fragment, &str);
8402     ok(hr == S_FALSE, "got %08x\n", hr);
8403     ok( str == 0, "got %p\n", str);
8404
8405     hr = IXMLDOMDocumentFragment_get_prefix(fragment, NULL);
8406     ok(hr == E_INVALIDARG, "got %08x\n", hr);
8407     IXMLDOMDocumentFragment_Release(fragment);
8408
8409     /* no prefix */
8410     hr = IXMLDOMDocument_createElement(doc, _bstr_("elem"), &element);
8411     ok( hr == S_OK, "got 0x%08x\n", hr);
8412
8413     hr = IXMLDOMElement_get_prefix(element, NULL);
8414     ok( hr == E_INVALIDARG, "got 0x%08x\n", hr);
8415
8416     str = (void*)0xdeadbeef;
8417     hr = IXMLDOMElement_get_prefix(element, &str);
8418     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8419     ok( str == 0, "got %p\n", str);
8420
8421     IXMLDOMElement_Release(element);
8422
8423     /* with prefix */
8424     hr = IXMLDOMDocument_createElement(doc, _bstr_("a:elem"), &element);
8425     ok( hr == S_OK, "got 0x%08x\n", hr);
8426
8427     str = (void*)0xdeadbeef;
8428     hr = IXMLDOMElement_get_prefix(element, &str);
8429     ok( hr == S_OK, "got 0x%08x\n", hr);
8430     ok( lstrcmpW(str, _bstr_("a")) == 0, "expected prefix \"a\"\n");
8431     SysFreeString(str);
8432
8433     str = (void*)0xdeadbeef;
8434     hr = IXMLDOMElement_get_namespaceURI(element, &str);
8435     ok( hr == S_FALSE, "got 0x%08x\n", hr);
8436     ok( str == 0, "got %p\n", str);
8437
8438     IXMLDOMElement_Release(element);
8439
8440     IXMLDOMDocument_Release(doc);
8441     free_bstrs();
8442 }
8443
8444 static void test_selectSingleNode(void)
8445 {
8446     IXMLDOMDocument *doc;
8447     IXMLDOMNodeList *list;
8448     IXMLDOMNode *node;
8449     VARIANT_BOOL b;
8450     HRESULT hr;
8451     LONG len;
8452     BSTR str;
8453
8454     doc = create_document(&IID_IXMLDOMDocument);
8455     if (!doc) return;
8456
8457     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
8458     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8459
8460     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
8461     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8462
8463     str = SysAllocString( szComplete4 );
8464     hr = IXMLDOMDocument_loadXML( doc, str, &b );
8465     ok( hr == S_OK, "loadXML failed\n");
8466     ok( b == VARIANT_TRUE, "failed to load XML string\n");
8467     SysFreeString( str );
8468
8469     hr = IXMLDOMDocument_selectSingleNode(doc, NULL, NULL);
8470     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8471
8472     hr = IXMLDOMDocument_selectNodes(doc, NULL, NULL);
8473     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8474
8475     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), NULL);
8476     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8477
8478     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), NULL);
8479     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8480
8481     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("lc"), &node);
8482     ok(hr == S_OK, "got 0x%08x\n", hr);
8483     IXMLDOMNode_Release(node);
8484
8485     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("lc"), &list);
8486     ok(hr == S_OK, "got 0x%08x\n", hr);
8487     IXMLDOMNodeList_Release(list);
8488
8489     list = (void*)0xdeadbeef;
8490     hr = IXMLDOMDocument_selectNodes(doc, NULL, &list);
8491     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
8492     ok(list == (void*)0xdeadbeef, "got %p\n", list);
8493
8494     node = (void*)0xdeadbeef;
8495     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("nonexistent"), &node);
8496     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8497     ok(node == 0, "got %p\n", node);
8498
8499     list = (void*)0xdeadbeef;
8500     hr = IXMLDOMDocument_selectNodes(doc, _bstr_("nonexistent"), &list);
8501     ok(hr == S_OK, "got 0x%08x\n", hr);
8502     len = 1;
8503     hr = IXMLDOMNodeList_get_length(list, &len);
8504     ok(hr == S_OK, "got 0x%08x\n", hr);
8505     ok(len == 0, "got %d\n", len);
8506     IXMLDOMNodeList_Release(list);
8507
8508     IXMLDOMDocument_Release(doc);
8509     free_bstrs();
8510 }
8511
8512 static void test_events(void)
8513 {
8514     IConnectionPointContainer *conn;
8515     IConnectionPoint *point;
8516     IXMLDOMDocument *doc;
8517     HRESULT hr;
8518
8519     doc = create_document(&IID_IXMLDOMDocument);
8520     if (!doc) return;
8521
8522     hr = IXMLDOMDocument_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&conn);
8523     ok(hr == S_OK, "got 0x%08x\n", hr);
8524
8525     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IDispatch, &point);
8526     ok(hr == S_OK, "got 0x%08x\n", hr);
8527     IConnectionPoint_Release(point);
8528     hr = IConnectionPointContainer_FindConnectionPoint(conn, &IID_IPropertyNotifySink, &point);
8529     ok(hr == S_OK, "got 0x%08x\n", hr);
8530     IConnectionPoint_Release(point);
8531     hr = IConnectionPointContainer_FindConnectionPoint(conn, &DIID_XMLDOMDocumentEvents, &point);
8532     ok(hr == S_OK, "got 0x%08x\n", hr);
8533     IConnectionPoint_Release(point);
8534
8535     IConnectionPointContainer_Release(conn);
8536
8537     IXMLDOMDocument_Release(doc);
8538 }
8539
8540 static void test_createProcessingInstruction(void)
8541 {
8542     static const WCHAR bodyW[] = {'t','e','s','t',0};
8543     IXMLDOMProcessingInstruction *pi;
8544     IXMLDOMDocument *doc;
8545     WCHAR buff[10];
8546     HRESULT hr;
8547
8548     doc = create_document(&IID_IXMLDOMDocument);
8549     if (!doc) return;
8550
8551     /* test for BSTR handling, pass broken BSTR */
8552     memcpy(&buff[2], bodyW, sizeof(bodyW));
8553     /* just a big length */
8554     *(DWORD*)buff = 0xf0f0;
8555     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("test"), &buff[2], &pi);
8556     ok(hr == S_OK, "got 0x%08x\n", hr);
8557
8558     IXMLDOMProcessingInstruction_Release(pi);
8559     IXMLDOMDocument_Release(doc);
8560 }
8561
8562 static void test_put_nodeTypedValue(void)
8563 {
8564     IXMLDOMDocument *doc;
8565     IXMLDOMElement *elem;
8566     VARIANT type;
8567     HRESULT hr;
8568
8569     doc = create_document(&IID_IXMLDOMDocument);
8570     if (!doc) return;
8571
8572     hr = IXMLDOMDocument_createElement(doc, _bstr_("Element"), &elem);
8573     ok(hr == S_OK, "got 0x%08x\n", hr);
8574
8575     V_VT(&type) = VT_EMPTY;
8576     hr = IXMLDOMElement_get_dataType(elem, &type);
8577     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8578     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8579
8580     /* set typed value for untyped node */
8581     V_VT(&type) = VT_I1;
8582     V_I1(&type) = 1;
8583     hr = IXMLDOMElement_put_nodeTypedValue(elem, type);
8584     ok(hr == S_OK, "got 0x%08x\n", hr);
8585
8586     V_VT(&type) = VT_EMPTY;
8587     hr = IXMLDOMElement_get_dataType(elem, &type);
8588     ok(hr == S_FALSE, "got 0x%08x\n", hr);
8589     ok(V_VT(&type) == VT_NULL, "got %d, expected VT_NULL\n", V_VT(&type));
8590
8591     /* no type info stored */
8592     V_VT(&type) = VT_EMPTY;
8593     hr = IXMLDOMElement_get_nodeTypedValue(elem, &type);
8594     ok(hr == S_OK, "got 0x%08x\n", hr);
8595     ok(V_VT(&type) == VT_BSTR, "got %d, expected VT_BSTR\n", V_VT(&type));
8596     ok(memcmp(V_BSTR(&type), _bstr_("1"), 2*sizeof(WCHAR)) == 0,
8597        "got %s, expected \"1\"\n", wine_dbgstr_w(V_BSTR(&type)));
8598     VariantClear(&type);
8599
8600     IXMLDOMDocument_Release(doc);
8601     free_bstrs();
8602 }
8603
8604 static void test_get_xml(void)
8605 {
8606     static const char xmlA[] = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\r\n<a>test</a>\r\n";
8607     IXMLDOMProcessingInstruction *pi;
8608     IXMLDOMNode *first;
8609     IXMLDOMDocument *doc;
8610     VARIANT_BOOL b;
8611     VARIANT v;
8612     BSTR xml;
8613     HRESULT hr;
8614
8615     doc = create_document(&IID_IXMLDOMDocument);
8616     if (!doc) return;
8617
8618     b = VARIANT_TRUE;
8619     hr = IXMLDOMDocument_loadXML( doc, _bstr_("<a>test</a>"), &b );
8620     ok(hr == S_OK, "got 0x%08x\n", hr);
8621     ok( b == VARIANT_TRUE, "got %d\n", b);
8622
8623     hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"),
8624                              _bstr_("version=\"1.0\" encoding=\"UTF-16\""), &pi);
8625     ok(hr == S_OK, "got 0x%08x\n", hr);
8626
8627     hr = IXMLDOMDocument_get_firstChild(doc, &first);
8628     ok(hr == S_OK, "got 0x%08x\n", hr);
8629
8630     V_UNKNOWN(&v) = (IUnknown*)first;
8631     V_VT(&v) = VT_UNKNOWN;
8632
8633     hr = IXMLDOMDocument_insertBefore(doc, (IXMLDOMNode*)pi, v, NULL);
8634     ok(hr == S_OK, "got 0x%08x\n", hr);
8635
8636     IXMLDOMProcessingInstruction_Release(pi);
8637     IXMLDOMNode_Release(first);
8638
8639     hr = IXMLDOMDocument_get_xml(doc, &xml);
8640     ok(hr == S_OK, "got 0x%08x\n", hr);
8641
8642     ok(memcmp(xml, _bstr_(xmlA), sizeof(xmlA)*sizeof(WCHAR)) == 0,
8643         "got %s, expected %s\n", wine_dbgstr_w(xml), xmlA);
8644     SysFreeString(xml);
8645
8646     IXMLDOMDocument_Release(doc);
8647 }
8648
8649 START_TEST(domdoc)
8650 {
8651     IXMLDOMDocument *doc;
8652     HRESULT hr;
8653
8654     hr = CoInitialize( NULL );
8655     ok( hr == S_OK, "failed to init com\n");
8656     if (hr != S_OK)
8657         return;
8658
8659     test_XMLHTTP();
8660
8661     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&doc );
8662     if (hr != S_OK)
8663     {
8664         win_skip("IXMLDOMDocument is not available (0x%08x)\n", hr);
8665         return;
8666     }
8667
8668     IXMLDOMDocument_Release(doc);
8669
8670     test_domdoc();
8671     test_persiststreaminit();
8672     test_domnode();
8673     test_refs();
8674     test_create();
8675     test_getElementsByTagName();
8676     test_get_text();
8677     test_get_childNodes();
8678     test_get_firstChild();
8679     test_get_lastChild();
8680     test_removeChild();
8681     test_replaceChild();
8682     test_removeNamedItem();
8683     test_IXMLDOMDocument2();
8684     test_whitespace();
8685     test_XPath();
8686     test_XSLPattern();
8687     test_cloneNode();
8688     test_xmlTypes();
8689     test_nodeTypeTests();
8690     test_DocumentSaveToDocument();
8691     test_DocumentSaveToFile();
8692     test_testTransforms();
8693     test_Namespaces();
8694     test_FormattingXML();
8695     test_nodeTypedValue();
8696     test_TransformWithLoadingLocalFile();
8697     test_put_nodeValue();
8698     test_document_IObjectSafety();
8699     test_splitText();
8700     test_getQualifiedItem();
8701     test_removeQualifiedItem();
8702     test_get_ownerDocument();
8703     test_setAttributeNode();
8704     test_XDR_schemas();
8705     test_get_dataType();
8706     test_put_dataType();
8707     test_createNode();
8708     test_get_prefix();
8709     test_default_properties();
8710     test_selectSingleNode();
8711     test_events();
8712     test_createProcessingInstruction();
8713     test_put_nodeTypedValue();
8714     test_get_xml();
8715
8716     CoUninitialize();
8717 }