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

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