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  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22
  23 #define COBJMACROS
  24
  25 #include "windows.h"
  26 #include "ole2.h"
  27 #include "xmldom.h"
  28 #include "msxml2.h"
  29 #include "msxml2did.h"
  30 #include "dispex.h"
  31 #include <stdio.h>
  32 #include <assert.h>
  33
  34 #include "wine/test.h"
  35
  36 static const WCHAR szEmpty[] = { 0 };
  37 static const WCHAR szIncomplete[] = {
  38     '<','?','x','m','l',' ',
  39     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
  40 };
  41 static const WCHAR szComplete1[] = {
  42     '<','?','x','m','l',' ',
  43     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
  44     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
  45 };
  46 static const WCHAR szComplete2[] = {
  47     '<','?','x','m','l',' ',
  48     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
  49     '<','o','>','<','/','o','>','\n',0
  50 };
  51 static const WCHAR szComplete3[] = {
  52     '<','?','x','m','l',' ',
  53     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
  54     '<','a','>','<','/','a','>','\n',0
  55 };
  56 static const WCHAR szComplete4[] = {
  57     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
  58     '<','l','c',' ','d','l','=','\'','s','t','r','1','\'','>','\n',
  59         '<','b','s',' ','v','r','=','\'','s','t','r','2','\'',' ','s','z','=','\'','1','2','3','4','\'','>',
  60             'f','n','1','.','t','x','t','\n',
  61         '<','/','b','s','>','\n',
  62         '<','p','r',' ','i','d','=','\'','s','t','r','3','\'',' ','v','r','=','\'','1','.','2','.','3','\'',' ',
  63                     'p','n','=','\'','w','i','n','e',' ','2','0','0','5','0','8','0','4','\'','>','\n',
  64             'f','n','2','.','t','x','t','\n',
  65         '<','/','p','r','>','\n',
  66         '<','e','m','p','t','y','>','<','/','e','m','p','t','y','>','\n',
  67         '<','f','o','>','\n',
  68             '<','b','a','>','\n',
  69                 'f','1','\n',
  70             '<','/','b','a','>','\n',
  71         '<','/','f','o','>','\n',
  72     '<','/','l','c','>','\n',0
  73 };
  74 static const WCHAR szComplete5[] = {
  75     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
  76     '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','"',
  77     ' ','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','"','>',
  78         '<','S',':','s','c','o','p','e','>',
  79             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
  80         '<','/','S',':','s','c','o','p','e','>',
  81         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
  82             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
  83             'c','o','m','p','u','t','e','r',
  84         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
  85     '<','/','S',':','s','e','a','r','c','h','>',0
  86 };
  87
  88 static const CHAR szExampleXML[] =
  89 "<?xml version='1.0' encoding='utf-8'?>\n"
  90 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
  91 "    <elem>\n"
  92 "        <a>A1 field</a>\n"
  93 "        <b>B1 field</b>\n"
  94 "        <c>C1 field</c>\n"
  95 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
  96 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
  97 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
  98 "            </html>\n"
  99 "        </description>\n"
 100 "    </elem>\n"
 101 "\n"
 102 "    <elem>\n"
 103 "        <a>A2 field</a>\n"
 104 "        <b>B2 field</b>\n"
 105 "        <c type=\"old\">C2 field</c>\n"
 106 "    </elem>\n"
 107 "\n"
 108 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 109 "        <a>A3 field</a>\n"
 110 "        <b>B3 field</b>\n"
 111 "        <c>C3 field</c>\n"
 112 "    </elem>\n"
 113 "\n"
 114 "    <elem>\n"
 115 "        <a>A4 field</a>\n"
 116 "        <b>B4 field</b>\n"
 117 "        <foo:c>C4 field</foo:c>\n"
 118 "    </elem>\n"
 119 "</root>\n";
 120
 121 static  const CHAR szTransformXML[] =
 122 "<?xml version=\"1.0\"?>\n"
 123 "<greeting>\n"
 124 "Hello World\n"
 125 "</greeting>";
 126
 127 static  const CHAR szTransformSSXML[] =
 128 "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
 129 "   <xsl:output method=\"html\"/>\n"
 130 "   <xsl:template match=\"/\">\n"
 131 "       <xsl:apply-templates select=\"greeting\"/>\n"
 132 "   </xsl:template>\n"
 133 "   <xsl:template match=\"greeting\">\n"
 134 "       <html>\n"
 135 "           <body>\n"
 136 "               <h1>\n"
 137 "                   <xsl:value-of select=\".\"/>\n"
 138 "               </h1>\n"
 139 "           </body>\n"
 140 "       </html>\n"
 141 "   </xsl:template>\n"
 142 "</xsl:stylesheet>";
 143
 144 static  const CHAR szTransformOutput[] =
 145 "<html><body><h1>"
 146 "Hello World"
 147 "</h1></body></html>";
 148
 149 static const WCHAR szNonExistentFile[] = {
 150     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
 151 };
 152 static const WCHAR szDocument[] = {
 153     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
 154 };
 155
 156 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
 157 static WCHAR szdl[] = { 'd','l',0 };
 158 static const WCHAR szvr[] = { 'v','r',0 };
 159 static const WCHAR szlc[] = { 'l','c',0 };
 160 static WCHAR szbs[] = { 'b','s',0 };
 161 static const WCHAR szstr1[] = { 's','t','r','1',0 };
 162 static const WCHAR szstr2[] = { 's','t','r','2',0 };
 163 static const WCHAR szstar[] = { '*',0 };
 164 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
 165
 166 static WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
 167 static WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
 168 static WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
 169
 170 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
 171 static WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
 172 static WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
 173 static WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 174                                 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
 175
 176 static WCHAR szAttribute[] = {'A','t','t','r',0 };
 177 static WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
 178
 179 static WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
 180                           ' ','n','o','t',' ','r','i','g','h','t','!', 0};
 181 static WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
 182                              'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
 183                              '!',']',']','>',0};
 184 static WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
 185 static WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
 186
 187 static WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
 188 static WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
 189
 190 #define expect_bstr_eq_and_free(bstr, expect) { \
 191     BSTR bstrExp = alloc_str_from_narrow(expect); \
 192     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
 193     SysFreeString(bstr); \
 194     SysFreeString(bstrExp); \
 195 }
 196
 197 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
 198
 199 #define ole_check(expr) { \
 200     HRESULT r = expr; \
 201     ok(r == S_OK, #expr " returned %x\n", r); \
 202 }
 203
 204 #define ole_expect(expr, expect) { \
 205     HRESULT r = expr; \
 206     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
 207 }
 208
 209 static BSTR alloc_str_from_narrow(const char *str)
 210 {
 211     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 212     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
 213     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 214     return ret;
 215 }
 216
 217 BSTR alloced_bstrs[256];
 218 int alloced_bstrs_count = 0;
 219
 220 static BSTR _bstr_(const char *str)
 221 {
 222     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
 223     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
 224     return alloced_bstrs[alloced_bstrs_count++];
 225 }
 226
 227 static void free_bstrs(void)
 228 {
 229     int i;
 230     for (i = 0; i < alloced_bstrs_count; i++)
 231         SysFreeString(alloced_bstrs[i]);
 232     alloced_bstrs_count = 0;
 233 }
 234
 235 static VARIANT _variantbstr_(const char *str)
 236 {
 237     VARIANT v;
 238     V_VT(&v) = VT_BSTR;
 239     V_BSTR(&v) = _bstr_(str);
 240     return v;
 241 }
 242
 243 static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
 244 {
 245     for (;;)
 246     {
 247         while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
 248         while (*sRight == '\r' || *sRight == '\n') sRight++;
 249         if (*sLeft != *sRight) return FALSE;
 250         if (!*sLeft) return TRUE;
 251         sLeft++;
 252         sRight++;
 253     }
 254 }
 255
 256 static void get_str_for_type(DOMNodeType type, char *buf)
 257 {
 258     switch (type)
 259     {
 260         case NODE_ATTRIBUTE:
 261             strcpy(buf, "A");
 262             break;
 263         case NODE_ELEMENT:
 264             strcpy(buf, "E");
 265             break;
 266         case NODE_DOCUMENT:
 267             strcpy(buf, "D");
 268             break;
 269         default:
 270             wsprintfA(buf, "[%d]", type);
 271     }
 272 }
 273
 274 static int get_node_position(IXMLDOMNode *node)
 275 {
 276     HRESULT r;
 277     int pos = 0;
 278
 279     IXMLDOMNode_AddRef(node);
 280     do
 281     {
 282         IXMLDOMNode *new_node;
 283
 284         pos++;
 285         r = IXMLDOMNode_get_previousSibling(node, &new_node);
 286         ok(SUCCEEDED(r), "get_previousSibling failed\n");
 287         IXMLDOMNode_Release(node);
 288         node = new_node;
 289     } while (r == S_OK);
 290     return pos;
 291 }
 292
 293 static void node_to_string(IXMLDOMNode *node, char *buf)
 294 {
 295     HRESULT r = S_OK;
 296     DOMNodeType type;
 297
 298     if (node == NULL)
 299     {
 300         lstrcpyA(buf, "(null)");
 301         return;
 302     }
 303
 304     IXMLDOMNode_AddRef(node);
 305     while (r == S_OK)
 306     {
 307         IXMLDOMNode *new_node;
 308
 309         ole_check(IXMLDOMNode_get_nodeType(node, &type));
 310         get_str_for_type(type, buf);
 311         buf+=strlen(buf);
 312
 313         if (type == NODE_ATTRIBUTE)
 314         {
 315             BSTR bstr;
 316             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
 317             *(buf++) = '\'';
 318             wsprintfA(buf, "%ws", bstr);
 319             buf += strlen(buf);
 320             *(buf++) = '\'';
 321             SysFreeString(bstr);
 322
 323             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
 324         }
 325         else
 326         {
 327             int pos = get_node_position(node);
 328             DOMNodeType parent_type = NODE_INVALID;
 329             r = IXMLDOMNode_get_parentNode(node, &new_node);
 330
 331             /* currently wine doesn't create a node for the <?xml ... ?>. To be able to test query
 332              * results we "fix" it */
 333             if (r == S_OK)
 334                 ole_check(IXMLDOMNode_get_nodeType(new_node, &parent_type));
 335             if ((parent_type == NODE_DOCUMENT) && type != NODE_PROCESSING_INSTRUCTION && pos==1)
 336             {
 337                 todo_wine ok(FALSE, "The first child of the document node in MSXML is the <?xml ... ?> processing instruction\n");
 338                 pos++;
 339             }
 340             wsprintf(buf, "%d", pos);
 341             buf += strlen(buf);
 342         }
 343
 344         ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
 345         IXMLDOMNode_Release(node);
 346         node = new_node;
 347         if (r == S_OK)
 348             *(buf++) = '.';
 349     }
 350
 351     *buf = 0;
 352 }
 353
 354 static char *list_to_string(IXMLDOMNodeList *list)
 355 {
 356     static char buf[4096];
 357     char *pos = buf;
 358     long len = 0;
 359     int i;
 360
 361     if (list == NULL)
 362     {
 363         lstrcpyA(buf, "(null)");
 364         return buf;
 365     }
 366     ole_check(IXMLDOMNodeList_get_length(list, &len));
 367     for (i = 0; i < len; i++)
 368     {
 369         IXMLDOMNode *node;
 370         if (i > 0)
 371             *(pos++) = ' ';
 372         ole_check(IXMLDOMNodeList_nextNode(list, &node));
 373         node_to_string(node, pos);
 374         pos += strlen(pos);
 375         IXMLDOMNode_Release(node);
 376     }
 377     *pos = 0;
 378     return buf;
 379 }
 380
 381 #define expect_node(node, expstr) { char str[4096]; node_to_string(node, str); ok(strcmp(str, expstr)==0, "Invalid node: %s, exptected %s\n", str, expstr); }
 382 #define expect_list_and_release(list, expstr) { char *str = list_to_string(list); ok(strcmp(str, expstr)==0, "Invalid node list: %s, exptected %s\n", str, expstr); if (list) IXMLDOMNodeList_Release(list); }
 383
 384 static void test_domdoc( void )
 385 {
 386     HRESULT r;
 387     IXMLDOMDocument *doc = NULL;
 388     IXMLDOMParseError *error;
 389     IXMLDOMElement *element = NULL;
 390     IXMLDOMNode *node;
 391     IXMLDOMText *nodetext = NULL;
 392     IXMLDOMComment *node_comment = NULL;
 393     IXMLDOMAttribute *node_attr = NULL;
 394     IXMLDOMNode *nodeChild = NULL;
 395     IXMLDOMProcessingInstruction *nodePI = NULL;
 396     VARIANT_BOOL b;
 397     VARIANT var;
 398     BSTR str;
 399     long code;
 400     long nLength = 0;
 401
 402     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
 403         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
 404     if( r != S_OK )
 405         return;
 406
 407     /* try some stupid things */
 408     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
 409     ok( r == S_FALSE, "loadXML failed\n");
 410
 411     b = VARIANT_TRUE;
 412     r = IXMLDOMDocument_loadXML( doc, NULL, &b );
 413     ok( r == S_FALSE, "loadXML failed\n");
 414     ok( b == VARIANT_FALSE, "failed to load XML string\n");
 415
 416     /* try to load a document from a nonexistent file */
 417     b = VARIANT_TRUE;
 418     str = SysAllocString( szNonExistentFile );
 419     VariantInit(&var);
 420     V_VT(&var) = VT_BSTR;
 421     V_BSTR(&var) = str;
 422
 423     r = IXMLDOMDocument_load( doc, var, &b);
 424     ok( r == S_FALSE, "load (from file) failed\n");
 425     ok( b == VARIANT_FALSE, "failed to load XML file\n");
 426     SysFreeString( str );
 427
 428     /* try load an empty document */
 429     b = VARIANT_TRUE;
 430     str = SysAllocString( szEmpty );
 431     r = IXMLDOMDocument_loadXML( doc, str, &b );
 432     ok( r == S_FALSE, "loadXML failed\n");
 433     ok( b == VARIANT_FALSE, "failed to load XML string\n");
 434     SysFreeString( str );
 435
 436     /* check that there's no document element */
 437     element = NULL;
 438     r = IXMLDOMDocument_get_documentElement( doc, &element );
 439     ok( r == S_FALSE, "should be no document element\n");
 440
 441     /* try finding a node */
 442     node = NULL;
 443     str = SysAllocString( szstr1 );
 444     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
 445     ok( r == S_FALSE, "ret %08x\n", r );
 446     SysFreeString( str );
 447
 448     b = VARIANT_TRUE;
 449     str = SysAllocString( szIncomplete );
 450     r = IXMLDOMDocument_loadXML( doc, str, &b );
 451     ok( r == S_FALSE, "loadXML failed\n");
 452     ok( b == VARIANT_FALSE, "failed to load XML string\n");
 453     SysFreeString( str );
 454
 455     /* check that there's no document element */
 456     element = (IXMLDOMElement*)1;
 457     r = IXMLDOMDocument_get_documentElement( doc, &element );
 458     ok( r == S_FALSE, "should be no document element\n");
 459     ok( element == NULL, "Element should be NULL\n");
 460
 461     /* try to load something valid */
 462     b = VARIANT_FALSE;
 463     str = SysAllocString( szComplete1 );
 464     r = IXMLDOMDocument_loadXML( doc, str, &b );
 465     ok( r == S_OK, "loadXML failed\n");
 466     ok( b == VARIANT_TRUE, "failed to load XML string\n");
 467     SysFreeString( str );
 468
 469     /* check if nodename is correct */
 470     r = IXMLDOMDocument_get_nodeName( doc, NULL );
 471     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
 472
 473     /* content doesn't matter here */
 474     str = NULL;
 475     r = IXMLDOMDocument_get_nodeName( doc, &str );
 476     ok ( r == S_OK, "get_nodeName wrong code\n");
 477     ok ( str != NULL, "str is null\n");
 478     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
 479     SysFreeString( str );
 480
 481     /* test put_text */
 482     r = IXMLDOMDocument_put_text( doc, _bstr_("Should Fail") );
 483     ok( r == E_FAIL, "ret %08x\n", r );
 484
 485     /* check that there's a document element */
 486     element = NULL;
 487     r = IXMLDOMDocument_get_documentElement( doc, &element );
 488     ok( r == S_OK, "should be a document element\n");
 489     if( element )
 490     {
 491         BSTR tag = NULL;
 492
 493         /* check if the tag is correct */
 494         r = IXMLDOMElement_get_tagName( element, &tag );
 495         ok( r == S_OK, "couldn't get tag name\n");
 496         ok( tag != NULL, "tag was null\n");
 497         ok( !lstrcmpW( tag, szOpen ), "incorrect tag name\n");
 498         SysFreeString( tag );
 499
 500         /* figure out what happens if we try to reload the document */
 501         str = SysAllocString( szComplete2 );
 502         r = IXMLDOMDocument_loadXML( doc, str, &b );
 503         ok( r == S_OK, "loadXML failed\n");
 504         ok( b == VARIANT_TRUE, "failed to load XML string\n");
 505         SysFreeString( str );
 506
 507         /* check if the tag is still correct */
 508         tag = NULL;
 509         r = IXMLDOMElement_get_tagName( element, &tag );
 510         ok( r == S_OK, "couldn't get tag name\n");
 511         ok( tag != NULL, "tag was null\n");
 512         ok( !lstrcmpW( tag, szOpen ), "incorrect tag name\n");
 513         SysFreeString( tag );
 514
 515         IXMLDOMElement_Release( element );
 516         element = NULL;
 517     }
 518
 519     /* as soon as we call loadXML again, the document element will disappear */
 520     b = 2;
 521     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
 522     ok( r == S_FALSE, "loadXML failed\n");
 523     ok( b == 2, "variant modified\n");
 524     r = IXMLDOMDocument_get_documentElement( doc, &element );
 525     ok( r == S_FALSE, "should be no document element\n");
 526
 527     /* try to load something else simple and valid */
 528     b = VARIANT_FALSE;
 529     str = SysAllocString( szComplete3 );
 530     r = IXMLDOMDocument_loadXML( doc, str, &b );
 531     ok( r == S_OK, "loadXML failed\n");
 532     ok( b == VARIANT_TRUE, "failed to load XML string\n");
 533     SysFreeString( str );
 534
 535     /* try something a little more complicated */
 536     b = FALSE;
 537     str = SysAllocString( szComplete4 );
 538     r = IXMLDOMDocument_loadXML( doc, str, &b );
 539     ok( r == S_OK, "loadXML failed\n");
 540     ok( b == VARIANT_TRUE, "failed to load XML string\n");
 541     SysFreeString( str );
 542
 543     r = IXMLDOMDocument_get_parseError( doc, &error );
 544     ok( r == S_OK, "returns %08x\n", r );
 545
 546     r = IXMLDOMParseError_get_errorCode( error, &code );
 547     ok( r == S_FALSE, "returns %08x\n", r );
 548     ok( code == 0, "code %ld\n", code );
 549     IXMLDOMParseError_Release( error );
 550
 551      /* test createTextNode */
 552     str = SysAllocString( szOpen );
 553     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
 554     ok( r == E_INVALIDARG, "returns %08x\n", r );
 555     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
 556     ok( r == S_OK, "returns %08x\n", r );
 557     SysFreeString( str );
 558     if(nodetext)
 559     {
 560         IXMLDOMNamedNodeMap *pAttribs;
 561
 562         r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (LPVOID*)&element);
 563         ok(r == E_NOINTERFACE, "ret %08x\n", r );
 564
 565         /* Text Last Child Checks */
 566         r = IXMLDOMText_get_lastChild(nodetext, NULL);
 567         ok(r == E_INVALIDARG, "ret %08x\n", r );
 568
 569         nodeChild = (IXMLDOMNode*)0x1;
 570         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
 571         ok(r == S_FALSE, "ret %08x\n", r );
 572         ok(nodeChild == NULL, "nodeChild not NULL\n");
 573
 574         /* test get_attributes */
 575         r = IXMLDOMText_get_attributes( nodetext, NULL );
 576         ok( r == E_INVALIDARG, "get_attributes returned wrong code\n");
 577
 578         pAttribs = (IXMLDOMNamedNodeMap*)0x1;
 579         r = IXMLDOMText_get_attributes( nodetext, &pAttribs);
 580         ok(r == S_FALSE, "ret %08x\n", r );
 581         ok( pAttribs == NULL, "pAttribs not NULL\n");
 582
 583         /* test get_dataType */
 584         r = IXMLDOMText_get_dataType(nodetext, &var);
 585         ok(r == S_FALSE, "ret %08x\n", r );
 586         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
 587         VariantClear(&var);
 588
 589         /* test length property */
 590         r = IXMLDOMText_get_length(nodetext, NULL);
 591         ok(r == E_INVALIDARG, "ret %08x\n", r );
 592
 593         r = IXMLDOMText_get_length(nodetext, &nLength);
 594         ok(r == S_OK, "ret %08x\n", r );
 595         ok(nLength == 4, "expected 4 got %ld\n", nLength);
 596
 597         /* test nodeTypeString */
 598         r = IXMLDOMText_get_nodeTypeString(nodetext, &str);
 599         ok(r == S_OK, "ret %08x\n", r );
 600         ok( !lstrcmpW( str, _bstr_("text") ), "incorrect nodeTypeString string\n");
 601         SysFreeString(str);
 602
 603         /* put data Tests */
 604         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
 605         ok(r == S_OK, "ret %08x\n", r );
 606
 607         /* get data Tests */
 608         r = IXMLDOMText_get_data(nodetext, &str);
 609         ok(r == S_OK, "ret %08x\n", r );
 610         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
 611         SysFreeString(str);
 612
 613         /* Confirm XML text is good */
 614         r = IXMLDOMText_get_xml(nodetext, &str);
 615         ok(r == S_OK, "ret %08x\n", r );
 616         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
 617         SysFreeString(str);
 618
 619         /* Confirm we get the put_data Text back */
 620         r = IXMLDOMText_get_text(nodetext, &str);
 621         ok(r == S_OK, "ret %08x\n", r );
 622         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
 623         SysFreeString(str);
 624
 625         /* test substringData */
 626         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
 627         ok(r == E_INVALIDARG, "ret %08x\n", r );
 628
 629         /* test substringData - Invalid offset */
 630         str = (BSTR)&szElement;
 631         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
 632         ok(r == E_INVALIDARG, "ret %08x\n", r );
 633         ok( str == NULL, "incorrect string\n");
 634
 635         /* test substringData - Invalid offset */
 636         str = (BSTR)&szElement;
 637         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
 638         ok(r == S_FALSE, "ret %08x\n", r );
 639         ok( str == NULL, "incorrect string\n");
 640
 641         /* test substringData - Invalid size */
 642         str = (BSTR)&szElement;
 643         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
 644         ok(r == E_INVALIDARG, "ret %08x\n", r );
 645         ok( str == NULL, "incorrect string\n");
 646
 647         /* test substringData - Invalid size */
 648         str = (BSTR)&szElement;
 649         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
 650         ok(r == S_FALSE, "ret %08x\n", r );
 651         ok( str == NULL, "incorrect string\n");
 652
 653         /* test substringData - Start of string */
 654         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
 655         ok(r == S_OK, "ret %08x\n", r );
 656         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
 657         SysFreeString(str);
 658
 659         /* test substringData - Middle of string */
 660         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
 661         ok(r == S_OK, "ret %08x\n", r );
 662         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
 663         SysFreeString(str);
 664
 665         /* test substringData - End of string */
 666         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
 667         ok(r == S_OK, "ret %08x\n", r );
 668         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
 669         SysFreeString(str);
 670
 671         /* test appendData */
 672         r = IXMLDOMText_appendData(nodetext, NULL);
 673         ok(r == S_OK, "ret %08x\n", r );
 674
 675         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
 676         ok(r == S_OK, "ret %08x\n", r );
 677
 678         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
 679         ok(r == S_OK, "ret %08x\n", r );
 680
 681         r = IXMLDOMText_get_text(nodetext, &str);
 682         ok(r == S_OK, "ret %08x\n", r );
 683         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string\n");
 684         SysFreeString(str);
 685
 686         /* test insertData */
 687         str = SysAllocStringLen(NULL, 0);
 688         r = IXMLDOMText_insertData(nodetext, -1, str);
 689         ok(r == S_OK, "ret %08x\n", r );
 690
 691         r = IXMLDOMText_insertData(nodetext, -1, NULL);
 692         ok(r == S_OK, "ret %08x\n", r );
 693
 694         r = IXMLDOMText_insertData(nodetext, 1000, str);
 695         ok(r == S_OK, "ret %08x\n", r );
 696
 697         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
 698         ok(r == S_OK, "ret %08x\n", r );
 699
 700         r = IXMLDOMText_insertData(nodetext, 0, NULL);
 701         ok(r == S_OK, "ret %08x\n", r );
 702
 703         r = IXMLDOMText_insertData(nodetext, 0, str);
 704         ok(r == S_OK, "ret %08x\n", r );
 705         SysFreeString(str);
 706
 707         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
 708         ok(r == E_INVALIDARG, "ret %08x\n", r );
 709
 710         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
 711         ok(r == E_INVALIDARG, "ret %08x\n", r );
 712
 713         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
 714         ok(r == S_OK, "ret %08x\n", r );
 715
 716         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
 717         ok(r == S_OK, "ret %08x\n", r );
 718
 719         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
 720         ok(r == S_OK, "ret %08x\n", r );
 721
 722         r = IXMLDOMText_get_text(nodetext, &str);
 723         ok(r == S_OK, "ret %08x\n", r );
 724         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string\n");
 725         SysFreeString(str);
 726
 727         IXMLDOMText_Release( nodetext );
 728     }
 729
 730     /* test Create Comment */
 731     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
 732     ok( r == E_INVALIDARG, "returns %08x\n", r );
 733     r = IXMLDOMDocument_createComment(doc, szComment, &node_comment);
 734     ok( r == S_OK, "returns %08x\n", r );
 735     if(node_comment)
 736     {
 737         /* Last Child Checks */
 738         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
 739         ok(r == E_INVALIDARG, "ret %08x\n", r );
 740
 741         nodeChild = (IXMLDOMNode*)0x1;
 742         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
 743         ok(r == S_FALSE, "ret %08x\n", r );
 744         ok(nodeChild == NULL, "pLastChild not NULL\n");
 745
 746         IXMLDOMComment_Release( node_comment );
 747     }
 748
 749     /* test Create Attribute */
 750     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
 751     ok( r == E_INVALIDARG, "returns %08x\n", r );
 752     r = IXMLDOMDocument_createAttribute(doc, szAttribute, &node_attr);
 753     ok( r == S_OK, "returns %08x\n", r );
 754     IXMLDOMText_Release( node_attr);
 755
 756     /* test Processing Instruction */
 757     str = SysAllocStringLen(NULL, 0);
 758     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
 759     ok( r == E_INVALIDARG, "returns %08x\n", r );
 760     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
 761     ok( r == E_FAIL, "returns %08x\n", r );
 762     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
 763     ok( r == E_FAIL, "returns %08x\n", r );
 764     SysFreeString(str);
 765
 766     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
 767     ok( r == S_OK, "returns %08x\n", r );
 768     if(nodePI)
 769     {
 770         /* Last Child Checks */
 771         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
 772         ok(r == E_INVALIDARG, "ret %08x\n", r );
 773
 774         nodeChild = (IXMLDOMNode*)0x1;
 775         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
 776         ok(r == S_FALSE, "ret %08x\n", r );
 777         ok(nodeChild == NULL, "nodeChild not NULL\n");
 778
 779         r = IXMLDOMProcessingInstruction_get_dataType(nodePI, &var);
 780         ok(r == S_FALSE, "ret %08x\n", r );
 781         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
 782         VariantClear(&var);
 783
 784         /* test nodeName */
 785         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
 786         ok(r == S_OK, "ret %08x\n", r );
 787         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
 788         SysFreeString(str);
 789
 790         /* test Target */
 791         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
 792         ok(r == S_OK, "ret %08x\n", r );
 793         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
 794         SysFreeString(str);
 795
 796         /* test nodeTypeString */
 797         r = IXMLDOMProcessingInstruction_get_nodeTypeString(nodePI, &str);
 798         ok(r == S_OK, "ret %08x\n", r );
 799         ok( !lstrcmpW( str, _bstr_("processinginstruction") ), "incorrect nodeTypeString string\n");
 800         SysFreeString(str);
 801
 802         /* test get_nodeValue */
 803         r = IXMLDOMProcessingInstruction_get_nodeValue(nodePI, &var);
 804         ok(r == S_OK, "ret %08x\n", r );
 805         ok( !lstrcmpW( V_BSTR(&var), _bstr_("version=\"1.0\"") ), "incorrect data string\n");
 806         VariantClear(&var);
 807
 808         /* test get_data */
 809         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
 810         ok(r == S_OK, "ret %08x\n", r );
 811         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
 812         SysFreeString(str);
 813
 814         /* test put_data */
 815         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
 816         ok(r == E_FAIL, "ret %08x\n", r );
 817
 818         /* test put_data */
 819         V_VT(&var) = VT_BSTR;
 820         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
 821         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
 822         ok(r == E_FAIL, "ret %08x\n", r );
 823         VariantClear(&var);
 824
 825         /* test get nodeName */
 826         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
 827         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
 828         ok(r == S_OK, "ret %08x\n", r );
 829         SysFreeString(str);
 830
 831         IXMLDOMProcessingInstruction_Release(nodePI);
 832     }
 833
 834     r = IXMLDOMDocument_Release( doc );
 835     ok( r == 0, "document ref count incorrect\n");
 836
 837     free_bstrs();
 838 }
 839
 840 static void test_domnode( void )
 841 {
 842     HRESULT r;
 843     IXMLDOMDocument *doc = NULL, *owner = NULL;
 844     IXMLDOMElement *element = NULL;
 845     IXMLDOMNamedNodeMap *map = NULL;
 846     IXMLDOMNode *node = NULL, *next = NULL;
 847     IXMLDOMNodeList *list = NULL;
 848     IXMLDOMAttribute *attr = NULL;
 849     DOMNodeType type = NODE_INVALID;
 850     VARIANT_BOOL b;
 851     BSTR str;
 852     VARIANT var;
 853     long count;
 854
 855     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
 856         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
 857     if( r != S_OK )
 858         return;
 859
 860     b = FALSE;
 861     str = SysAllocString( szComplete4 );
 862     r = IXMLDOMDocument_loadXML( doc, str, &b );
 863     ok( r == S_OK, "loadXML failed\n");
 864     ok( b == VARIANT_TRUE, "failed to load XML string\n");
 865     SysFreeString( str );
 866
 867     if (doc)
 868     {
 869         b = 1;
 870         r = IXMLDOMNode_hasChildNodes( doc, &b );
 871         ok( r == S_OK, "hasChildNoes bad return\n");
 872         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
 873
 874         r = IXMLDOMDocument_get_documentElement( doc, &element );
 875         ok( r == S_OK, "should be a document element\n");
 876         ok( element != NULL, "should be an element\n");
 877     }
 878     else
 879         ok( FALSE, "no document\n");
 880
 881     VariantInit(&var);
 882     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
 883
 884     r = IXMLDOMNode_get_nodeValue( doc, NULL );
 885     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
 886
 887     r = IXMLDOMNode_get_nodeValue( doc, &var );
 888     ok( r == S_FALSE, "nextNode returned wrong code\n");
 889     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
 890     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
 891
 892     if (element)
 893     {
 894         owner = NULL;
 895         r = IXMLDOMNode_get_ownerDocument( element, &owner );
 896         ok( r == S_OK, "get_ownerDocument return code\n");
 897         ok( owner != doc, "get_ownerDocument return\n");
 898
 899         type = NODE_INVALID;
 900         r = IXMLDOMNode_get_nodeType( element, &type);
 901         ok( r == S_OK, "getNamedItem returned wrong code\n");
 902         ok( type == NODE_ELEMENT, "node not an element\n");
 903
 904         str = NULL;
 905         r = IXMLDOMNode_get_baseName( element, &str );
 906         ok( r == S_OK, "get_baseName returned wrong code\n");
 907         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
 908         SysFreeString(str);
 909
 910         /* check if nodename is correct */
 911         r = IXMLDOMElement_get_nodeName( element, NULL );
 912         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
 913
 914         /* content doesn't matter here */
 915         str = NULL;
 916         r = IXMLDOMElement_get_nodeName( element, &str );
 917         ok ( r == S_OK, "get_nodeName wrong code\n");
 918         ok ( str != NULL, "str is null\n");
 919         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
 920         SysFreeString( str );
 921
 922         str = SysAllocString( szNonExistentFile );
 923         V_VT(&var) = VT_I4;
 924         V_I4(&var) = 0x1234;
 925         r = IXMLDOMElement_getAttribute( element, str, &var );
 926         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
 927         ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
 928         VariantClear(&var);
 929
 930         attr = (IXMLDOMAttribute*)0xdeadbeef;
 931         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
 932         ok( r == E_FAIL, "getAttributeNode ret %08x\n", r );
 933         ok( attr == NULL, "getAttributeNode ret %p, expected NULL\n", attr );
 934         SysFreeString( str );
 935
 936         str = SysAllocString( szdl );
 937         V_VT(&var) = VT_I4;
 938         V_I4(&var) = 0x1234;
 939         r = IXMLDOMElement_getAttribute( element, str, &var );
 940         ok( r == S_OK, "getAttribute ret %08x\n", r );
 941         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
 942         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
 943         VariantClear( &var );
 944
 945         r = IXMLDOMElement_getAttribute( element, NULL, &var );
 946         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
 947
 948         r = IXMLDOMElement_getAttribute( element, str, NULL );
 949         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
 950
 951         attr = NULL;
 952         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
 953         ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
 954         ok( attr != NULL, "getAttributeNode returned NULL\n" );
 955         if(attr)
 956             IXMLDOMAttribute_Release(attr);
 957
 958         SysFreeString( str );
 959
 960         r = IXMLDOMElement_get_attributes( element, &map );
 961         ok( r == S_OK, "get_attributes returned wrong code\n");
 962         ok( map != NULL, "should be attributes\n");
 963
 964         b = 1;
 965         r = IXMLDOMNode_hasChildNodes( element, &b );
 966         ok( r == S_OK, "hasChildNoes bad return\n");
 967         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
 968     }
 969     else
 970         ok( FALSE, "no element\n");
 971
 972     if (map)
 973     {
 974         ISupportErrorInfo *support_error;
 975         r = IXMLDOMNamedNodeMap_QueryInterface( map, &IID_ISupportErrorInfo, (LPVOID*)&support_error );
 976         ok( r == S_OK, "ret %08x\n", r );
 977
 978         r = ISupportErrorInfo_InterfaceSupportsErrorInfo( support_error, &IID_IXMLDOMNamedNodeMap );
 979 todo_wine
 980 {
 981         ok( r == S_OK, "ret %08x\n", r );
 982 }
 983         ISupportErrorInfo_Release( support_error );
 984
 985         str = SysAllocString( szdl );
 986         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
 987         ok( r == S_OK, "getNamedItem returned wrong code\n");
 988         ok( node != NULL, "should be attributes\n");
 989         IXMLDOMNode_Release(node);
 990         SysFreeString( str );
 991
 992         str = SysAllocString( szdl );
 993         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
 994         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
 995         SysFreeString( str );
 996
 997         /* something that isn't in szComplete4 */
 998         str = SysAllocString( szOpen );
 999         node = (IXMLDOMNode *) 1;
1000         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
1001         ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
1002         ok( node == NULL, "getNamedItem should have returned NULL\n");
1003         SysFreeString( str );
1004
1005         /* test indexed access of attributes */
1006         r = IXMLDOMNamedNodeMap_get_length( map, &count );
1007         ok ( r == S_OK, "get_length wrong code\n");
1008         ok ( count == 1, "get_length != 1\n");
1009
1010         node = NULL;
1011         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
1012         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
1013         ok ( node == NULL, "there is no node\n");
1014
1015         node = NULL;
1016         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
1017         ok ( r == S_FALSE, "get_item (1) wrong code\n");
1018         ok ( node == NULL, "there is no attribute\n");
1019
1020         node = NULL;
1021         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
1022         ok ( r == S_OK, "get_item (0) wrong code\n");
1023         ok ( node != NULL, "should be attribute\n");
1024
1025         r = IXMLDOMNode_get_nodeName( node, NULL );
1026         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1027
1028         /* content doesn't matter here */
1029         str = NULL;
1030         r = IXMLDOMNode_get_nodeName( node, &str );
1031         ok ( r == S_OK, "get_nodeName wrong code\n");
1032         ok ( str != NULL, "str is null\n");
1033         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
1034         SysFreeString( str );
1035
1036         /* test sequential access of attributes */
1037         node = NULL;
1038         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1039         ok ( r == S_OK, "nextNode (first time) wrong code\n");
1040         ok ( node != NULL, "nextNode, should be attribute\n");
1041
1042         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1043         ok ( r != S_OK, "nextNode (second time) wrong code\n");
1044         ok ( node == NULL, "nextNode, there is no attribute\n");
1045
1046         r = IXMLDOMNamedNodeMap_reset( map );
1047         ok ( r == S_OK, "reset should return S_OK\n");
1048
1049         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1050         ok ( r == S_OK, "nextNode (third time) wrong code\n");
1051         ok ( node != NULL, "nextNode, should be attribute\n");
1052     }
1053     else
1054         ok( FALSE, "no map\n");
1055
1056     if (node)
1057     {
1058         type = NODE_INVALID;
1059         r = IXMLDOMNode_get_nodeType( node, &type);
1060         ok( r == S_OK, "getNamedItem returned wrong code\n");
1061         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
1062
1063         str = NULL;
1064         r = IXMLDOMNode_get_baseName( node, NULL );
1065         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
1066
1067         str = NULL;
1068         r = IXMLDOMNode_get_baseName( node, &str );
1069         ok( r == S_OK, "get_baseName returned wrong code\n");
1070         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
1071         SysFreeString( str );
1072
1073         r = IXMLDOMNode_get_nodeValue( node, &var );
1074         ok( r == S_OK, "returns %08x\n", r );
1075         ok( V_VT(&var) == VT_BSTR, "vt %x\n", V_VT(&var));
1076         ok( !lstrcmpW(V_BSTR(&var), szstr1), "nodeValue incorrect\n");
1077         VariantClear(&var);
1078
1079         r = IXMLDOMNode_get_childNodes( node, NULL );
1080         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
1081
1082         r = IXMLDOMNode_get_childNodes( node, &list );
1083         ok( r == S_OK, "get_childNodes returned wrong code\n");
1084
1085         if (list)
1086         {
1087             r = IXMLDOMNodeList_nextNode( list, &next );
1088             ok( r == S_OK, "nextNode returned wrong code\n");
1089         }
1090         else
1091             ok( FALSE, "no childlist\n");
1092
1093         if (next)
1094         {
1095             b = 1;
1096             r = IXMLDOMNode_hasChildNodes( next, &b );
1097             ok( r == S_FALSE, "hasChildNoes bad return\n");
1098             ok( b == VARIANT_FALSE, "hasChildNoes wrong result\n");
1099
1100             type = NODE_INVALID;
1101             r = IXMLDOMNode_get_nodeType( next, &type);
1102             ok( r == S_OK, "getNamedItem returned wrong code\n");
1103             ok( type == NODE_TEXT, "node not text\n");
1104
1105             str = (BSTR) 1;
1106             r = IXMLDOMNode_get_baseName( next, &str );
1107             ok( r == S_FALSE, "get_baseName returned wrong code\n");
1108             ok( str == NULL, "basename was wrong\n");
1109             SysFreeString(str);
1110         }
1111         else
1112             ok( FALSE, "no next\n");
1113
1114         if (next)
1115             IXMLDOMNode_Release( next );
1116         next = NULL;
1117         if (list)
1118             IXMLDOMNodeList_Release( list );
1119         list = NULL;
1120         if (node)
1121             IXMLDOMNode_Release( node );
1122     }
1123     else
1124         ok( FALSE, "no node\n");
1125     node = NULL;
1126
1127     if (map)
1128         IXMLDOMNamedNodeMap_Release( map );
1129
1130     /* now traverse the tree from the root element */
1131     if (element)
1132     {
1133         IXMLDOMNode *node;
1134         r = IXMLDOMNode_get_childNodes( element, &list );
1135         ok( r == S_OK, "get_childNodes returned wrong code\n");
1136
1137         /* using get_item for child list doesn't advance the position */
1138         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
1139         expect_node(node, "E2.E2.D1");
1140         IXMLDOMNode_Release(node);
1141         ole_check(IXMLDOMNodeList_nextNode(list, &node));
1142         expect_node(node, "E1.E2.D1");
1143         IXMLDOMNode_Release(node);
1144         ole_check(IXMLDOMNodeList_reset(list));
1145
1146         IXMLDOMNodeList_AddRef(list);
1147         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
1148         ole_check(IXMLDOMNodeList_reset(list));
1149     }
1150     else
1151         ok( FALSE, "no element\n");
1152
1153     node = (void*)0xdeadbeef;
1154     r = IXMLDOMNode_selectSingleNode( element, szdl, &node );
1155     ok( r == S_FALSE, "ret %08x\n", r );
1156     ok( node == NULL, "node %p\n", node );
1157     r = IXMLDOMNode_selectSingleNode( element, szbs, &node );
1158     ok( r == S_OK, "ret %08x\n", r );
1159     r = IXMLDOMNode_Release( node );
1160     ok( r == 0, "ret %08x\n", r );
1161
1162     if (list)
1163     {
1164         r = IXMLDOMNodeList_QueryInterface(list, &IID_IDispatch, NULL);
1165         ok( r == E_INVALIDARG || r == E_POINTER, "ret %08x\n", r );
1166
1167         r = IXMLDOMNodeList_get_item(list, 0, NULL);
1168         ok(r == E_INVALIDARG, "Exected E_INVALIDARG got %08x\n", r);
1169
1170         r = IXMLDOMNodeList_get_length(list, NULL);
1171         ok(r == E_INVALIDARG, "Exected E_INVALIDARG got %08x\n", r);
1172
1173         r = IXMLDOMNodeList_get_length( list, &count );
1174         ok( r == S_OK, "get_length returns %08x\n", r );
1175         ok( count == 4, "get_length got %ld\n", count );
1176
1177         r = IXMLDOMNodeList_nextNode(list, NULL);
1178         ok(r == E_INVALIDARG, "Exected E_INVALIDARG got %08x\n", r);
1179
1180         r = IXMLDOMNodeList_nextNode( list, &node );
1181         ok( r == S_OK, "nextNode returned wrong code\n");
1182     }
1183     else
1184         ok( FALSE, "no list\n");
1185
1186     if (node)
1187     {
1188         type = NODE_INVALID;
1189         r = IXMLDOMNode_get_nodeType( node, &type);
1190         ok( r == S_OK, "getNamedItem returned wrong code\n");
1191         ok( type == NODE_ELEMENT, "node not text\n");
1192
1193         VariantInit(&var);
1194         ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
1195         r = IXMLDOMNode_get_nodeValue( node, &var );
1196         ok( r == S_FALSE, "nextNode returned wrong code\n");
1197         ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
1198         ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
1199
1200         r = IXMLDOMNode_hasChildNodes( node, NULL );
1201         ok( r == E_INVALIDARG, "hasChildNoes bad return\n");
1202
1203         b = 1;
1204         r = IXMLDOMNode_hasChildNodes( node, &b );
1205         ok( r == S_OK, "hasChildNoes bad return\n");
1206         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
1207
1208         str = NULL;
1209         r = IXMLDOMNode_get_baseName( node, &str );
1210         ok( r == S_OK, "get_baseName returned wrong code\n");
1211         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
1212         SysFreeString(str);
1213     }
1214     else
1215         ok( FALSE, "no node\n");
1216
1217     if (node)
1218         IXMLDOMNode_Release( node );
1219     if (list)
1220         IXMLDOMNodeList_Release( list );
1221     if (element)
1222         IXMLDOMElement_Release( element );
1223
1224     b = FALSE;
1225     str = SysAllocString( szComplete5 );
1226     r = IXMLDOMDocument_loadXML( doc, str, &b );
1227     ok( r == S_OK, "loadXML failed\n");
1228     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1229     SysFreeString( str );
1230
1231     b = 1;
1232     r = IXMLDOMNode_hasChildNodes( doc, &b );
1233     ok( r == S_OK, "hasChildNoes bad return\n");
1234     ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
1235
1236     r = IXMLDOMDocument_get_documentElement( doc, &element );
1237     ok( r == S_OK, "should be a document element\n");
1238     ok( element != NULL, "should be an element\n");
1239
1240     if (element)
1241     {
1242         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
1243         BSTR tag = NULL;
1244
1245         /* check if the tag is correct */
1246         r = IXMLDOMElement_get_tagName( element, &tag );
1247         ok( r == S_OK, "couldn't get tag name\n");
1248         ok( tag != NULL, "tag was null\n");
1249         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
1250         SysFreeString( tag );
1251     }
1252
1253     if (element)
1254         IXMLDOMElement_Release( element );
1255     if (doc)
1256         ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
1257 }
1258
1259 static void test_refs(void)
1260 {
1261     HRESULT r;
1262     BSTR str;
1263     VARIANT_BOOL b;
1264     IXMLDOMDocument *doc = NULL;
1265     IXMLDOMElement *element = NULL;
1266     IXMLDOMNode *node = NULL, *node2;
1267     IXMLDOMNodeList *node_list = NULL;
1268     LONG ref;
1269     IUnknown *unk, *unk2;
1270
1271     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1272         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1273     if( r != S_OK )
1274         return;
1275     ref = IXMLDOMDocument_Release(doc);
1276     ok( ref == 0, "ref %d\n", ref);
1277
1278     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1279         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1280     if( r != S_OK )
1281         return;
1282
1283     str = SysAllocString( szComplete4 );
1284     r = IXMLDOMDocument_loadXML( doc, str, &b );
1285     ok( r == S_OK, "loadXML failed\n");
1286     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1287     SysFreeString( str );
1288
1289     ref = IXMLDOMDocument_AddRef( doc );
1290     ok( ref == 2, "ref %d\n", ref );
1291     ref = IXMLDOMDocument_AddRef( doc );
1292     ok( ref == 3, "ref %d\n", ref );
1293     IXMLDOMDocument_Release( doc );
1294     IXMLDOMDocument_Release( doc );
1295
1296     r = IXMLDOMDocument_get_documentElement( doc, &element );
1297     ok( r == S_OK, "should be a document element\n");
1298     ok( element != NULL, "should be an element\n");
1299
1300     ref = IXMLDOMDocument_AddRef( doc );
1301     ok( ref == 2, "ref %d\n", ref );
1302     IXMLDOMDocument_Release( doc );
1303
1304     r = IXMLDOMElement_get_childNodes( element, &node_list );
1305     ok( r == S_OK, "rets %08x\n", r);
1306
1307     ref = IXMLDOMNodeList_AddRef( node_list );
1308     ok( ref == 2, "ref %d\n", ref );
1309     IXMLDOMNodeList_Release( node_list );
1310
1311     IXMLDOMNodeList_get_item( node_list, 0, &node );
1312     ok( r == S_OK, "rets %08x\n", r);
1313
1314     IXMLDOMNodeList_get_item( node_list, 0, &node2 );
1315     ok( r == S_OK, "rets %08x\n", r);
1316
1317     ref = IXMLDOMNode_AddRef( node );
1318     ok( ref == 2, "ref %d\n", ref );
1319     IXMLDOMNode_Release( node );
1320
1321     ref = IXMLDOMNode_Release( node );
1322     ok( ref == 0, "ref %d\n", ref );
1323     ref = IXMLDOMNode_Release( node2 );
1324     ok( ref == 0, "ref %d\n", ref );
1325
1326     ref = IXMLDOMNodeList_Release( node_list );
1327     ok( ref == 0, "ref %d\n", ref );
1328
1329     ok( node != node2, "node %p node2 %p\n", node, node2 );
1330
1331     ref = IXMLDOMDocument_Release( doc );
1332     ok( ref == 0, "ref %d\n", ref );
1333
1334     ref = IXMLDOMElement_AddRef( element );
1335     todo_wine {
1336     ok( ref == 3, "ref %d\n", ref );
1337     }
1338     IXMLDOMElement_Release( element );
1339
1340     /* IUnknown must be unique however we obtain it */
1341     r = IXMLDOMElement_QueryInterface( element, &IID_IUnknown, (LPVOID*)&unk );
1342     ok( r == S_OK, "rets %08x\n", r );
1343     r = IXMLDOMElement_QueryInterface( element, &IID_IXMLDOMNode, (LPVOID*)&node );
1344     ok( r == S_OK, "rets %08x\n", r );
1345     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (LPVOID*)&unk2 );
1346     ok( r == S_OK, "rets %08x\n", r );
1347     ok( unk == unk2, "unk %p unk2 %p\n", unk, unk2 );
1348
1349     IUnknown_Release( unk2 );
1350     IUnknown_Release( unk );
1351     IXMLDOMNode_Release( node );
1352
1353     IXMLDOMElement_Release( element );
1354
1355 }
1356
1357 static void test_create(void)
1358 {
1359     static const WCHAR szOne[] = {'1',0};
1360     static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
1361     HRESULT r;
1362     VARIANT var;
1363     BSTR str, name;
1364     IXMLDOMDocument *doc;
1365     IXMLDOMElement *element;
1366     IXMLDOMNode *root, *node, *child;
1367     IXMLDOMNamedNodeMap *attr_map;
1368     IUnknown *unk;
1369     LONG ref;
1370     long num;
1371
1372     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1373         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1374     if( r != S_OK )
1375         return;
1376
1377     V_VT(&var) = VT_I1;
1378     V_I1(&var) = NODE_ELEMENT;
1379     str = SysAllocString( szlc );
1380     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1381     ok( r == S_OK, "returns %08x\n", r );
1382     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
1383
1384     V_VT(&var) = VT_R4;
1385     V_R4(&var) = NODE_ELEMENT;
1386     str = SysAllocString( szlc );
1387     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1388     ok( r == S_OK, "returns %08x\n", r );
1389     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
1390
1391     V_VT(&var) = VT_BSTR;
1392     V_BSTR(&var) = SysAllocString( szOne );
1393     str = SysAllocString( szlc );
1394     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1395     ok( r == S_OK, "returns %08x\n", r );
1396     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
1397     VariantClear(&var);
1398
1399     V_VT(&var) = VT_BSTR;
1400     V_BSTR(&var) = SysAllocString( szOneGarbage );
1401     str = SysAllocString( szlc );
1402     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1403     ok( r == E_INVALIDARG, "returns %08x\n", r );
1404     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
1405     VariantClear(&var);
1406
1407     V_VT(&var) = VT_I4;
1408     V_I4(&var) = NODE_ELEMENT;
1409     str = SysAllocString( szlc );
1410     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1411     ok( r == S_OK, "returns %08x\n", r );
1412     r = IXMLDOMDocument_appendChild( doc, node, &root );
1413     ok( r == S_OK, "returns %08x\n", r );
1414     ok( node == root, "%p %p\n", node, root );
1415
1416     ref = IXMLDOMNode_AddRef( node );
1417     ok(ref == 3, "ref %d\n", ref);
1418     IXMLDOMNode_Release( node );
1419
1420     ref = IXMLDOMNode_Release( node );
1421     ok(ref == 1, "ref %d\n", ref);
1422     SysFreeString( str );
1423
1424     V_VT(&var) = VT_I4;
1425     V_I4(&var) = NODE_ELEMENT;
1426     str = SysAllocString( szbs );
1427     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1428     ok( r == S_OK, "returns %08x\n", r );
1429
1430     ref = IXMLDOMNode_AddRef( node );
1431     ok(ref == 2, "ref = %d\n", ref);
1432     IXMLDOMNode_Release( node );
1433
1434     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (LPVOID*)&unk );
1435     ok( r == S_OK, "returns %08x\n", r );
1436
1437     ref = IXMLDOMNode_AddRef( unk );
1438     ok(ref == 3, "ref = %d\n", ref);
1439     IXMLDOMNode_Release( unk );
1440
1441     V_VT(&var) = VT_EMPTY;
1442     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
1443     ok( r == S_OK, "returns %08x\n", r );
1444     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
1445     IXMLDOMNode_Release( child );
1446     IUnknown_Release( unk );
1447
1448
1449     V_VT(&var) = VT_NULL;
1450     V_DISPATCH(&var) = (IDispatch*)node;
1451     r = IXMLDOMNode_insertBefore( root, node, var, &child );
1452     ok( r == S_OK, "returns %08x\n", r );
1453     ok( node == child, "%p %p\n", node, child );
1454     IXMLDOMNode_Release( child );
1455
1456
1457     V_VT(&var) = VT_NULL;
1458     V_DISPATCH(&var) = (IDispatch*)node;
1459     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
1460     ok( r == S_OK, "returns %08x\n", r );
1461     IXMLDOMNode_Release( node );
1462
1463     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (LPVOID*)&element );
1464     ok( r == S_OK, "returns %08x\n", r );
1465
1466     r = IXMLDOMElement_get_attributes( element, &attr_map );
1467     ok( r == S_OK, "returns %08x\n", r );
1468     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1469     ok( r == S_OK, "returns %08x\n", r );
1470     ok( num == 0, "num %ld\n", num );
1471     IXMLDOMNamedNodeMap_Release( attr_map );
1472
1473     V_VT(&var) = VT_BSTR;
1474     V_BSTR(&var) = SysAllocString( szstr1 );
1475     name = SysAllocString( szdl );
1476     r = IXMLDOMElement_setAttribute( element, name, var );
1477     ok( r == S_OK, "returns %08x\n", r );
1478     r = IXMLDOMElement_get_attributes( element, &attr_map );
1479     ok( r == S_OK, "returns %08x\n", r );
1480     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1481     ok( r == S_OK, "returns %08x\n", r );
1482     ok( num == 1, "num %ld\n", num );
1483     IXMLDOMNamedNodeMap_Release( attr_map );
1484     VariantClear(&var);
1485
1486     V_VT(&var) = VT_BSTR;
1487     V_BSTR(&var) = SysAllocString( szstr2 );
1488     r = IXMLDOMElement_setAttribute( element, name, var );
1489     ok( r == S_OK, "returns %08x\n", r );
1490     r = IXMLDOMElement_get_attributes( element, &attr_map );
1491     ok( r == S_OK, "returns %08x\n", r );
1492     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1493     ok( r == S_OK, "returns %08x\n", r );
1494     ok( num == 1, "num %ld\n", num );
1495     IXMLDOMNamedNodeMap_Release( attr_map );
1496     VariantClear(&var);
1497     r = IXMLDOMElement_getAttribute( element, name, &var );
1498     ok( r == S_OK, "returns %08x\n", r );
1499     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
1500     VariantClear(&var);
1501     SysFreeString(name);
1502
1503     V_VT(&var) = VT_BSTR;
1504     V_BSTR(&var) = SysAllocString( szstr1 );
1505     name = SysAllocString( szlc );
1506     r = IXMLDOMElement_setAttribute( element, name, var );
1507     ok( r == S_OK, "returns %08x\n", r );
1508     r = IXMLDOMElement_get_attributes( element, &attr_map );
1509     ok( r == S_OK, "returns %08x\n", r );
1510     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1511     ok( r == S_OK, "returns %08x\n", r );
1512     ok( num == 2, "num %ld\n", num );
1513     IXMLDOMNamedNodeMap_Release( attr_map );
1514     VariantClear(&var);
1515     SysFreeString(name);
1516
1517     V_VT(&var) = VT_I4;
1518     V_I4(&var) = 10;
1519     name = SysAllocString( szbs );
1520     r = IXMLDOMElement_setAttribute( element, name, var );
1521     ok( r == S_OK, "returns %08x\n", r );
1522     VariantClear(&var);
1523     r = IXMLDOMElement_getAttribute( element, name, &var );
1524     ok( r == S_OK, "returns %08x\n", r );
1525     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
1526     VariantClear(&var);
1527     SysFreeString(name);
1528
1529     /* Create an Attribute */
1530     V_VT(&var) = VT_I4;
1531     V_I4(&var) = NODE_ATTRIBUTE;
1532     str = SysAllocString( szAttribute );
1533     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1534     ok( r == S_OK, "returns %08x\n", r );
1535     ok( node != NULL, "node was null\n");
1536     SysFreeString(str);
1537
1538     if(r == S_OK)
1539     {
1540         r = IXMLDOMNode_get_nodeTypeString(node, &str);
1541         ok( r == S_OK, "returns %08x\n", r );
1542         ok( !lstrcmpW( str, _bstr_("attribute") ), "incorrect nodeTypeString string\n");
1543         SysFreeString(str);
1544         IXMLDOMNode_Release( node );
1545     }
1546
1547     IXMLDOMElement_Release( element );
1548     IXMLDOMNode_Release( root );
1549     IXMLDOMDocument_Release( doc );
1550 }
1551
1552 static void test_getElementsByTagName(void)
1553 {
1554     HRESULT r;
1555     BSTR str;
1556     VARIANT_BOOL b;
1557     IXMLDOMDocument *doc;
1558     IXMLDOMNodeList *node_list;
1559     IDispatchEx *dispex;
1560     long len;
1561
1562     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1563         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1564     if( r != S_OK )
1565         return;
1566
1567     str = SysAllocString( szComplete4 );
1568     r = IXMLDOMDocument_loadXML( doc, str, &b );
1569     ok( r == S_OK, "loadXML failed\n");
1570     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1571     SysFreeString( str );
1572
1573     str = SysAllocString( szstar );
1574     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1575     ok( r == S_OK, "ret %08x\n", r );
1576     r = IXMLDOMNodeList_get_length( node_list, &len );
1577     ok( r == S_OK, "ret %08x\n", r );
1578     ok( len == 6, "len %ld\n", len );
1579
1580     r = IXMLDOMNodeList_QueryInterface( node_list, &IID_IDispatchEx, (void**)&dispex );
1581     ok( r == S_OK, "rets %08x\n", r);
1582     if( r == S_OK )
1583     {
1584         DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
1585         DWORD dwProps = 0;
1586         BSTR sName;
1587         IUnknown *pUnk;
1588
1589         sName = SysAllocString( szstar );
1590         r = IDispatchEx_DeleteMemberByName(dispex, sName, fdexNameCaseSensitive);
1591         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1592         SysFreeString( sName );
1593
1594         r = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
1595         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1596
1597         r = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &dwProps);
1598         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1599         ok(dwProps == 0, "expected 0 got %d\n", dwProps);
1600
1601         r = IDispatchEx_GetMemberName(dispex, dispid, &sName);
1602         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1603         if( SUCCEEDED(r) )
1604             SysFreeString(sName);
1605
1606         r = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
1607         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1608
1609         r = IDispatchEx_GetNameSpaceParent(dispex, &pUnk);
1610         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1611         if(r == S_OK)
1612             IUnknown_Release(pUnk);
1613
1614         IDispatchEx_Release( dispex );
1615     }
1616
1617
1618     IXMLDOMNodeList_Release( node_list );
1619     SysFreeString( str );
1620
1621     str = SysAllocString( szbs );
1622     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1623     ok( r == S_OK, "ret %08x\n", r );
1624     r = IXMLDOMNodeList_get_length( node_list, &len );
1625     ok( r == S_OK, "ret %08x\n", r );
1626     ok( len == 1, "len %ld\n", len );
1627     IXMLDOMNodeList_Release( node_list );
1628     SysFreeString( str );
1629
1630     str = SysAllocString( szdl );
1631     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1632     ok( r == S_OK, "ret %08x\n", r );
1633     r = IXMLDOMNodeList_get_length( node_list, &len );
1634     ok( r == S_OK, "ret %08x\n", r );
1635     ok( len == 0, "len %ld\n", len );
1636     IXMLDOMNodeList_Release( node_list );
1637     SysFreeString( str );
1638
1639     str = SysAllocString( szstr1 );
1640     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1641     ok( r == S_OK, "ret %08x\n", r );
1642     r = IXMLDOMNodeList_get_length( node_list, &len );
1643     ok( r == S_OK, "ret %08x\n", r );
1644     ok( len == 0, "len %ld\n", len );
1645     IXMLDOMNodeList_Release( node_list );
1646     SysFreeString( str );
1647
1648     IXMLDOMDocument_Release( doc );
1649 }
1650
1651 static void test_get_text(void)
1652 {
1653     HRESULT r;
1654     BSTR str;
1655     VARIANT_BOOL b;
1656     IXMLDOMDocument *doc;
1657     IXMLDOMNode *node, *node2, *node3;
1658     IXMLDOMNodeList *node_list;
1659     IXMLDOMNamedNodeMap *node_map;
1660     long len;
1661
1662     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1663         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1664     if( r != S_OK )
1665         return;
1666
1667     str = SysAllocString( szComplete4 );
1668     r = IXMLDOMDocument_loadXML( doc, str, &b );
1669     ok( r == S_OK, "loadXML failed\n");
1670     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1671     SysFreeString( str );
1672
1673     str = SysAllocString( szbs );
1674     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
1675     ok( r == S_OK, "ret %08x\n", r );
1676     SysFreeString(str);
1677
1678     if (0) {
1679     /* this test crashes on win9x */
1680     r = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatch, NULL);
1681     ok( r == E_INVALIDARG, "ret %08x\n", r );
1682     }
1683
1684     r = IXMLDOMNodeList_get_length( node_list, NULL );
1685     ok( r == E_INVALIDARG, "ret %08x\n", r );
1686
1687     r = IXMLDOMNodeList_get_length( node_list, &len );
1688     ok( r == S_OK, "ret %08x\n", r );
1689     ok( len == 1, "expect 1 got %ld\n", len );
1690
1691     r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
1692     ok( r == E_INVALIDARG, "ret %08x\n", r );
1693
1694     r = IXMLDOMNodeList_nextNode( node_list, NULL );
1695     ok( r == E_INVALIDARG, "ret %08x\n", r );
1696
1697     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
1698     ok( r == S_OK, "ret %08x\n", r );
1699     IXMLDOMNodeList_Release( node_list );
1700
1701     /* Invalid output parameter*/
1702     r = IXMLDOMNode_get_text( node, NULL );
1703     ok( r == E_INVALIDARG, "ret %08x\n", r );
1704
1705     r = IXMLDOMNode_get_text( node, &str );
1706     ok( r == S_OK, "ret %08x\n", r );
1707     ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
1708     SysFreeString(str);
1709
1710     r = IXMLDOMNode_get_attributes( node, &node_map );
1711     ok( r == S_OK, "ret %08x\n", r );
1712
1713     str = SysAllocString( szvr );
1714     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
1715     ok( r == S_OK, "ret %08x\n", r );
1716     SysFreeString(str);
1717
1718     r = IXMLDOMNode_get_text( node2, &str );
1719     ok( r == S_OK, "ret %08x\n", r );
1720     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
1721     SysFreeString(str);
1722
1723     r = IXMLDOMNode_get_firstChild( node2, &node3 );
1724     ok( r == S_OK, "ret %08x\n", r );
1725
1726     r = IXMLDOMNode_get_text( node3, &str );
1727     ok( r == S_OK, "ret %08x\n", r );
1728     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
1729     SysFreeString(str);
1730
1731
1732     IXMLDOMNode_Release( node3 );
1733     IXMLDOMNode_Release( node2 );
1734     IXMLDOMNamedNodeMap_Release( node_map );
1735     IXMLDOMNode_Release( node );
1736     IXMLDOMDocument_Release( doc );
1737 }
1738
1739 static void test_get_childNodes(void)
1740 {
1741     HRESULT r;
1742     BSTR str;
1743     VARIANT_BOOL b;
1744     IXMLDOMDocument *doc;
1745     IXMLDOMElement *element;
1746     IXMLDOMNode *node, *node2;
1747     IXMLDOMNodeList *node_list, *node_list2;
1748     long len;
1749
1750     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1751         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1752     if( r != S_OK )
1753         return;
1754
1755     str = SysAllocString( szComplete4 );
1756     r = IXMLDOMDocument_loadXML( doc, str, &b );
1757     ok( r == S_OK, "loadXML failed\n");
1758     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1759     SysFreeString( str );
1760
1761     r = IXMLDOMDocument_get_documentElement( doc, &element );
1762     ok( r == S_OK, "ret %08x\n", r);
1763
1764     r = IXMLDOMElement_get_childNodes( element, &node_list );
1765     ok( r == S_OK, "ret %08x\n", r);
1766
1767     r = IXMLDOMNodeList_get_length( node_list, &len );
1768     ok( r == S_OK, "ret %08x\n", r);
1769     ok( len == 4, "len %ld\n", len);
1770
1771     r = IXMLDOMNodeList_get_item( node_list, 2, &node );
1772     ok( r == S_OK, "ret %08x\n", r);
1773
1774     r = IXMLDOMNode_get_childNodes( node, &node_list2 );
1775     ok( r == S_OK, "ret %08x\n", r);
1776
1777     r = IXMLDOMNodeList_get_length( node_list2, &len );
1778     ok( r == S_OK, "ret %08x\n", r);
1779     ok( len == 0, "len %ld\n", len);
1780
1781     r = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
1782     ok( r == S_FALSE, "ret %08x\n", r);
1783
1784     IXMLDOMNodeList_Release( node_list2 );
1785     IXMLDOMNode_Release( node );
1786     IXMLDOMNodeList_Release( node_list );
1787     IXMLDOMElement_Release( element );
1788     IXMLDOMDocument_Release( doc );
1789 }
1790
1791 static void test_removeChild(void)
1792 {
1793     HRESULT r;
1794     BSTR str;
1795     VARIANT_BOOL b;
1796     IXMLDOMDocument *doc;
1797     IXMLDOMElement *element, *lc_element;
1798     IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
1799     IXMLDOMNodeList *root_list, *fo_list;
1800
1801     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1802         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1803     if( r != S_OK )
1804         return;
1805
1806     str = SysAllocString( szComplete4 );
1807     r = IXMLDOMDocument_loadXML( doc, str, &b );
1808     ok( r == S_OK, "loadXML failed\n");
1809     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1810     SysFreeString( str );
1811
1812     r = IXMLDOMDocument_get_documentElement( doc, &element );
1813     ok( r == S_OK, "ret %08x\n", r);
1814
1815     r = IXMLDOMElement_get_childNodes( element, &root_list );
1816     ok( r == S_OK, "ret %08x\n", r);
1817
1818     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
1819     ok( r == S_OK, "ret %08x\n", r);
1820
1821     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
1822     ok( r == S_OK, "ret %08x\n", r);
1823
1824     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
1825     ok( r == S_OK, "ret %08x\n", r);
1826
1827     /* invalid parameter: NULL ptr */
1828     removed_node = (void*)0xdeadbeef;
1829     r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
1830     ok( r == E_INVALIDARG, "ret %08x\n", r );
1831     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
1832
1833     /* ba_node is a descendant of element, but not a direct child. */
1834     removed_node = (void*)0xdeadbeef;
1835     r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
1836     ok( r == E_INVALIDARG, "ret %08x\n", r );
1837     ok( removed_node == NULL, "%p\n", removed_node );
1838
1839     r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
1840     ok( r == S_OK, "ret %08x\n", r);
1841     ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
1842
1843     /* try removing already removed child */
1844     temp_node = (void*)0xdeadbeef;
1845     r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
1846     ok( r == E_INVALIDARG, "ret %08x\n", r);
1847     ok( temp_node == NULL, "%p\n", temp_node );
1848
1849     /* the removed node has no parent anymore */
1850     r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
1851     ok( r == S_FALSE, "ret %08x\n", r);
1852     ok( temp_node == NULL, "%p\n", temp_node );
1853
1854     IXMLDOMNode_Release( removed_node );
1855     IXMLDOMNode_Release( ba_node );
1856     IXMLDOMNodeList_Release( fo_list );
1857
1858     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
1859     ok( r == S_OK, "ret %08x\n", r);
1860
1861     r = IXMLDOMElement_QueryInterface( lc_node, &IID_IXMLDOMElement, (LPVOID*)&lc_element );
1862     ok( r == S_OK, "ret %08x\n", r);
1863
1864     /* MS quirk: passing wrong interface pointer works, too */
1865     r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
1866     ok( r == S_OK, "ret %08x\n", r);
1867
1868     r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
1869     ok( r == S_FALSE, "ret %08x\n", r);
1870     ok( temp_node == NULL, "%p\n", temp_node );
1871
1872     IXMLDOMNode_Release( lc_node );
1873     IXMLDOMNodeList_Release( root_list );
1874     IXMLDOMElement_Release( element );
1875     IXMLDOMDocument_Release( doc );
1876 }
1877
1878 static void test_replaceChild(void)
1879 {
1880     HRESULT r;
1881     BSTR str;
1882     VARIANT_BOOL b;
1883     IXMLDOMDocument *doc;
1884     IXMLDOMElement *element, *ba_element;
1885     IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
1886     IXMLDOMNodeList *root_list, *fo_list;
1887     IUnknown * unk1, *unk2;
1888     long len;
1889
1890     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1891         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1892     if( r != S_OK )
1893         return;
1894
1895     str = SysAllocString( szComplete4 );
1896     r = IXMLDOMDocument_loadXML( doc, str, &b );
1897     ok( r == S_OK, "loadXML failed\n");
1898     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1899     SysFreeString( str );
1900
1901     r = IXMLDOMDocument_get_documentElement( doc, &element );
1902     ok( r == S_OK, "ret %08x\n", r);
1903
1904     r = IXMLDOMElement_get_childNodes( element, &root_list );
1905     ok( r == S_OK, "ret %08x\n", r);
1906
1907     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
1908     ok( r == S_OK, "ret %08x\n", r);
1909
1910     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
1911     ok( r == S_OK, "ret %08x\n", r);
1912
1913     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
1914     ok( r == S_OK, "ret %08x\n", r);
1915
1916     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
1917     ok( r == S_OK, "ret %08x\n", r);
1918
1919     IXMLDOMNodeList_Release( fo_list );
1920
1921     /* invalid parameter: NULL ptr for element to remove */
1922     removed_node = (void*)0xdeadbeef;
1923     r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
1924     ok( r == E_INVALIDARG, "ret %08x\n", r );
1925     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
1926
1927     /* invalid parameter: NULL for replacement element. (Sic!) */
1928     removed_node = (void*)0xdeadbeef;
1929     r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
1930     ok( r == E_INVALIDARG, "ret %08x\n", r );
1931     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
1932
1933     /* invalid parameter: OldNode is not a child */
1934     removed_node = (void*)0xdeadbeef;
1935     r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
1936     ok( r == E_INVALIDARG, "ret %08x\n", r );
1937     ok( removed_node == NULL, "%p\n", removed_node );
1938
1939     /* invalid parameter: would create loop */
1940     removed_node = (void*)0xdeadbeef;
1941     r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
1942     ok( r == E_FAIL, "ret %08x\n", r );
1943     ok( removed_node == NULL, "%p\n", removed_node );
1944
1945     r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
1946     ok( r == S_OK, "ret %08x\n", r );
1947
1948     r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
1949     ok( r == S_OK, "ret %08x\n", r );
1950
1951     /* ba_node and temp_node refer to the same node, yet they
1952        are different interface pointers */
1953     ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
1954     r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
1955     ok( r == S_OK, "ret %08x\n", r );
1956     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
1957     ok( r == S_OK, "ret %08x\n", r );
1958     todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
1959
1960     IUnknown_Release( unk1 );
1961     IUnknown_Release( unk2 );
1962
1963     /* ba_node should have been removed from below fo_node */
1964     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
1965     ok( r == S_OK, "ret %08x\n", r );
1966
1967     /* MS quirk: replaceChild also accepts elements instead of nodes */
1968     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
1969     ok( r == S_OK, "ret %08x\n", r );
1970
1971     r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
1972     ok( r == S_OK, "ret %08x\n", r );
1973
1974     r = IXMLDOMNodeList_get_length( fo_list, &len);
1975     ok( r == S_OK, "ret %08x\n", r );
1976     ok( len == 0, "len %ld\n", len);
1977
1978     IXMLDOMNodeList_Release( fo_list );
1979
1980     IXMLDOMNode_Release(ba_node);
1981     IXMLDOMNode_Release(fo_node);
1982     IXMLDOMNode_Release(temp_node);
1983     IXMLDOMNodeList_Release( root_list );
1984     IXMLDOMElement_Release( element );
1985     IXMLDOMDocument_Release( doc );
1986 }
1987
1988 static void test_XMLHTTP(void)
1989 {
1990     static const WCHAR wszBody[] = {'m','o','d','e','=','T','e','s','t',0};
1991     static WCHAR wszPOST[] = {'P','O','S','T',0};
1992     static WCHAR wszUrl[] = {'h','t','t','p',':','/','/',
1993         'c','r','o','s','s','o','v','e','r','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
1994         'p','o','s','t','t','e','s','t','.','p','h','p',0};
1995     static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
1996     IXMLHttpRequest *pXMLHttpRequest;
1997     BSTR bstrResponse;
1998     VARIANT dummy;
1999     VARIANT varfalse;
2000     VARIANT varbody;
2001     HRESULT hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL,
2002                                   CLSCTX_INPROC_SERVER, &IID_IXMLHttpRequest,
2003                                   (void **)&pXMLHttpRequest);
2004     ok(hr == S_OK, "CoCreateInstance(CLSID_XMLHTTPRequest) should have succeeded instead of failing with 0x%08x\n", hr);
2005     if (hr != S_OK)
2006         return;
2007
2008     VariantInit(&dummy);
2009     V_VT(&dummy) = VT_ERROR;
2010     V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
2011     VariantInit(&varfalse);
2012     V_VT(&varfalse) = VT_BOOL;
2013     V_BOOL(&varfalse) = VARIANT_FALSE;
2014     V_VT(&varbody) = VT_BSTR;
2015     V_BSTR(&varbody) = SysAllocString(wszBody);
2016
2017     hr = IXMLHttpRequest_open(pXMLHttpRequest, wszPOST, wszUrl, varfalse, dummy, dummy);
2018     todo_wine ok(hr == S_OK, "IXMLHttpRequest_open should have succeeded instead of failing with 0x%08x\n", hr);
2019
2020     hr = IXMLHttpRequest_send(pXMLHttpRequest, varbody);
2021     todo_wine ok(hr == S_OK, "IXMLHttpRequest_send should have succeeded instead of failing with 0x%08x\n", hr);
2022     VariantClear(&varbody);
2023
2024     hr = IXMLHttpRequest_get_responseText(pXMLHttpRequest, &bstrResponse);
2025     todo_wine ok(hr == S_OK, "IXMLHttpRequest_get_responseText should have succeeded instead of failing with 0x%08x\n", hr);
2026     /* the server currently returns "FAILED" because the Content-Type header is
2027      * not what the server expects */
2028     if(hr == S_OK)
2029     {
2030         ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)), "bstrResponse differs from what was expected\n");
2031         SysFreeString(bstrResponse);
2032     }
2033 }
2034
2035 static void test_IXMLDOMDocument2(void)
2036 {
2037     HRESULT r;
2038     VARIANT_BOOL b;
2039     BSTR str;
2040     IXMLDOMDocument *doc;
2041     IXMLDOMDocument2 *doc2;
2042     IDispatchEx *dispex;
2043     VARIANT var;
2044     int ref;
2045
2046     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
2047         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
2048     if( r != S_OK )
2049         return;
2050
2051     str = SysAllocString( szComplete4 );
2052     r = IXMLDOMDocument_loadXML( doc, str, &b );
2053     ok( r == S_OK, "loadXML failed\n");
2054     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2055     SysFreeString( str );
2056
2057     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
2058     ok( r == S_OK, "ret %08x\n", r );
2059     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
2060
2061     r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
2062     ok( r == S_OK, "ret %08x\n", r );
2063     if(r == S_OK)
2064     {
2065         IDispatchEx_Release(dispex);
2066     }
2067
2068     /* we will check if the variant got cleared */
2069     ref = IXMLDOMDocument2_AddRef(doc2);
2070     expect_eq(ref, 3, int, "%d");  /* doc, doc2, AddRef*/
2071     V_VT(&var) = VT_UNKNOWN;
2072     V_UNKNOWN(&var) = (IUnknown *)doc2;
2073
2074     /* invalid calls */
2075     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
2076     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
2077     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
2078
2079     /* valid call */
2080     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
2081     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
2082     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
2083     V_VT(&var) = VT_R4;
2084
2085     /* the variant didn't get cleared*/
2086     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
2087
2088     /* setProperty tests */
2089     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
2090     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
2091     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
2092     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
2093     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
2094     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
2095
2096     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
2097     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
2098     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
2099     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
2100
2101     IXMLDOMDocument2_Release( doc2 );
2102     IXMLDOMDocument_Release( doc );
2103     free_bstrs();
2104 }
2105
2106 static void test_XPath(void)
2107 {
2108     HRESULT r;
2109     VARIANT var;
2110     VARIANT_BOOL b;
2111     IXMLDOMDocument2 *doc;
2112     IXMLDOMNode *rootNode;
2113     IXMLDOMNode *elem1Node;
2114     IXMLDOMNode *node;
2115     IXMLDOMNodeList *list;
2116
2117     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
2118         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
2119     if( r != S_OK )
2120         return;
2121
2122     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b));
2123     ok(b == VARIANT_TRUE, "failed to load XML string\n");
2124
2125     /* switch to XPath */
2126     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
2127
2128     /* some simple queries*/
2129     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list));
2130     ole_check(IXMLDOMNodeList_get_item(list, 0, &rootNode));
2131     ole_check(IXMLDOMNodeList_reset(list));
2132     expect_list_and_release(list, "E2.D1");
2133     if (rootNode == NULL)
2134         return;
2135
2136     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//c"), &list));
2137     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
2138
2139     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//c[@type]"), &list));
2140     expect_list_and_release(list, "E3.E2.E2.D1");
2141
2142     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
2143     /* using get_item for query results advances the position */
2144     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
2145     expect_node(node, "E2.E2.D1");
2146     IXMLDOMNode_Release(node);
2147     ole_check(IXMLDOMNodeList_nextNode(list, &node));
2148     expect_node(node, "E4.E2.D1");
2149     IXMLDOMNode_Release(node);
2150     ole_check(IXMLDOMNodeList_reset(list));
2151     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
2152
2153     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
2154     expect_list_and_release(list, "E2.D1");
2155
2156     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
2157     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
2158     ole_check(IXMLDOMNodeList_reset(list));
2159     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
2160
2161     /* select an attribute */
2162     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
2163     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
2164
2165     /* would evaluate to a number */
2166     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
2167     /* would evaluate to a boolean */
2168     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
2169     /* would evaluate to a string */
2170     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
2171
2172     /* no results */
2173     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
2174     expect_list_and_release(list, "");
2175     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("elem//c"), &list));
2176     expect_list_and_release(list, "");
2177     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//elem[4]"), &list));
2178     expect_list_and_release(list, "");
2179
2180     /* foo undeclared in document node */
2181     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
2182     /* undeclared in <root> node */
2183     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
2184     /* undeclared in <elem> node */
2185     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
2186     /* but this trick can be used */
2187     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
2188     expect_list_and_release(list, "E3.E4.E2.D1");
2189
2190     /* it has to be declared in SelectionNamespaces */
2191     todo_wine ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
2192         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
2193
2194     /* now the namespace can be used */
2195     todo_wine ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//test:c"), &list));
2196     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
2197     todo_wine ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
2198     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
2199     todo_wine ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
2200     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
2201     todo_wine ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
2202     todo_wine expect_list_and_release(list, "E5.E1.E4.E1.E2.D1");
2203
2204     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
2205     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
2206         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
2207
2208     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
2209
2210     VariantInit(&var);
2211     todo_wine ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
2212     todo_wine expect_eq(V_VT(&var), VT_BSTR, int, "%x");
2213     if (V_VT(&var) == VT_BSTR)
2214         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
2215
2216     /* extra attributes - same thing*/
2217     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
2218         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
2219     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
2220
2221     IXMLDOMNode_Release(rootNode);
2222     IXMLDOMNode_Release(elem1Node);
2223     IXMLDOMDocument_Release(doc);
2224     free_bstrs();
2225 }
2226
2227 static void test_cloneNode(void )
2228 {
2229     IXMLDOMDocument *doc = NULL;
2230     VARIANT_BOOL b;
2231     IXMLDOMNodeList *pList;
2232     IXMLDOMNamedNodeMap *mapAttr;
2233     long nLength = 0, nLength1 = 0;
2234     long nAttrCnt = 0, nAttrCnt1 = 0;
2235     IXMLDOMNode *node;
2236     IXMLDOMNode *node_clone;
2237     HRESULT r;
2238     BSTR str;
2239     static const WCHAR szSearch[] = { 'l', 'c', '/', 'p', 'r', 0 };
2240
2241     r = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
2242     if( r != S_OK )
2243         return;
2244
2245     str = SysAllocString( szComplete4 );
2246     ole_check(IXMLDOMDocument_loadXML(doc, str, &b));
2247     ok(b == VARIANT_TRUE, "failed to load XML string\n");
2248     SysFreeString(str);
2249
2250     if(!b)
2251         return;
2252
2253     str = SysAllocString( szSearch);
2254     r = IXMLDOMNode_selectSingleNode(doc, str, &node);
2255     ok( r == S_OK, "ret %08x\n", r );
2256     ok( node != NULL, "node %p\n", node );
2257     SysFreeString(str);
2258
2259     if(!node)
2260     {
2261         IXMLDOMDocument_Release(doc);
2262         return;
2263     }
2264
2265     /* Check invalid parameter */
2266     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
2267     ok( r == E_INVALIDARG, "ret %08x\n", r );
2268
2269     /* All Children */
2270     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
2271     ok( r == S_OK, "ret %08x\n", r );
2272     ok( node_clone != NULL, "node %p\n", node );
2273
2274     if(!node_clone)
2275     {
2276         IXMLDOMDocument_Release(doc);
2277         IXMLDOMNode_Release(node);
2278         return;
2279     }
2280
2281     r = IXMLDOMNode_get_childNodes(node, &pList);
2282     ok( r == S_OK, "ret %08x\n", r );
2283     if (pList)
2284         {
2285                 IXMLDOMNodeList_get_length(pList, &nLength);
2286                 IXMLDOMNodeList_Release(pList);
2287         }
2288
2289     r = IXMLDOMNode_get_attributes(node, &mapAttr);
2290     ok( r == S_OK, "ret %08x\n", r );
2291     if(mapAttr)
2292     {
2293         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt);
2294         IXMLDOMNamedNodeMap_Release(mapAttr);
2295     }
2296
2297     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
2298     ok( r == S_OK, "ret %08x\n", r );
2299     if (pList)
2300         {
2301                 IXMLDOMNodeList_get_length(pList, &nLength1);
2302                 IXMLDOMNodeList_Release(pList);
2303         }
2304
2305     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
2306     ok( r == S_OK, "ret %08x\n", r );
2307     if(mapAttr)
2308     {
2309         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
2310         IXMLDOMNamedNodeMap_Release(mapAttr);
2311     }
2312
2313     ok(nLength == nLength1, "wrong Child count (%ld, %ld)\n", nLength, nLength1);
2314     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%ld, %ld)\n", nAttrCnt, nAttrCnt1);
2315     IXMLDOMNode_Release(node_clone);
2316
2317     /* No Children */
2318     r = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
2319     ok( r == S_OK, "ret %08x\n", r );
2320     ok( node_clone != NULL, "node %p\n", node );
2321
2322     if(!node_clone)
2323     {
2324         IXMLDOMDocument_Release(doc);
2325         IXMLDOMNode_Release(node);
2326         return;
2327     }
2328
2329     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
2330     ok( r == S_OK, "ret %08x\n", r );
2331     if (pList)
2332         {
2333                 IXMLDOMNodeList_get_length(pList, &nLength1);
2334         ok( nLength1 == 0, "Length should be 0 (%ld)\n", nLength1);
2335                 IXMLDOMNodeList_Release(pList);
2336         }
2337
2338     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
2339     ok( r == S_OK, "ret %08x\n", r );
2340     if(mapAttr)
2341     {
2342         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
2343         ok( nAttrCnt1 == 3, "Attribute count should be 3 (%ld)\n", nAttrCnt1);
2344         IXMLDOMNamedNodeMap_Release(mapAttr);
2345     }
2346
2347     ok(nLength != nLength1, "wrong Child count (%ld, %ld)\n", nLength, nLength1);
2348     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%ld, %ld)\n", nAttrCnt, nAttrCnt1);
2349     IXMLDOMNode_Release(node_clone);
2350
2351
2352     IXMLDOMNode_Release(node);
2353     IXMLDOMDocument_Release(doc);
2354 }
2355
2356 static void test_xmlTypes(void)
2357 {
2358     IXMLDOMDocument *doc = NULL;
2359     IXMLDOMElement *pRoot;
2360     HRESULT hr;
2361     IXMLDOMComment *pComment;
2362     IXMLDOMElement *pElement;
2363     IXMLDOMAttribute *pAttrubute;
2364     IXMLDOMNamedNodeMap *pAttribs;
2365     IXMLDOMCDATASection *pCDataSec;
2366     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
2367     IXMLDOMDocumentFragment *pDocFrag = NULL;
2368     IXMLDOMEntityReference *pEntityRef = NULL;
2369     BSTR str;
2370     IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;   /* Used for testing Siblings */
2371     VARIANT v;
2372     long len = 0;
2373
2374     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
2375     if( hr != S_OK )
2376         return;
2377
2378     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
2379     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2380
2381     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
2382     ok(hr == S_FALSE, "ret %08x\n", hr );
2383     ok(pNextChild == NULL, "pDocChild not NULL\n");
2384
2385     /* test previous Sibling */
2386     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
2387     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2388
2389     pNextChild = (IXMLDOMNode *)0x1;
2390     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
2391     ok(hr == S_FALSE, "ret %08x\n", hr );
2392     ok(pNextChild == NULL, "pNextChild not NULL\n");
2393
2394     /* test get_attributes */
2395     hr = IXMLDOMDocument_get_attributes( doc, NULL );
2396     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2397
2398     pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2399     hr = IXMLDOMDocument_get_attributes( doc, &pAttribs);
2400     ok(hr == S_FALSE, "ret %08x\n", hr );
2401     ok( pAttribs == NULL, "pAttribs not NULL\n");
2402
2403     /* test get_dataType */
2404     hr = IXMLDOMDocument_get_dataType(doc, &v);
2405     ok(hr == S_FALSE, "ret %08x\n", hr );
2406     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2407     VariantClear(&v);
2408
2409     /* test nodeTypeString */
2410     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
2411     ok(hr == S_OK, "ret %08x\n", hr );
2412     ok( !lstrcmpW( str, _bstr_("document") ), "incorrect nodeTypeString string\n");
2413     SysFreeString(str);
2414
2415     /* test implementation */
2416     hr = IXMLDOMDocument_get_implementation(doc, NULL);
2417     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2418
2419     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
2420     ok(hr == S_OK, "ret %08x\n", hr );
2421     if(hr == S_OK)
2422     {
2423         VARIANT_BOOL hasFeature = VARIANT_TRUE;
2424         BSTR sEmpty = SysAllocStringLen(NULL, 0);
2425
2426         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
2427         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2428
2429         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
2430         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2431
2432         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
2433         ok(hr == S_OK, "ret %08x\n", hr );
2434         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2435
2436         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
2437         ok(hr == S_OK, "ret %08x\n", hr );
2438         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
2439
2440         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
2441         ok(hr == S_OK, "ret %08x\n", hr );
2442         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
2443
2444         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
2445         ok(hr == S_OK, "ret %08x\n", hr );
2446         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2447
2448         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
2449         ok(hr == S_OK, "ret %08x\n", hr );
2450         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2451
2452         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
2453         ok(hr == S_OK, "ret %08x\n", hr );
2454         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2455
2456         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
2457         ok(hr == S_OK, "ret %08x\n", hr );
2458         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2459
2460         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
2461         ok(hr == S_OK, "ret %08x\n", hr );
2462         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2463
2464         SysFreeString(sEmpty);
2465         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
2466     }
2467
2468
2469
2470     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
2471     ok(hr == S_OK, "ret %08x\n", hr );
2472     if(hr == S_OK)
2473     {
2474         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
2475         ok(hr == S_OK, "ret %08x\n", hr );
2476         if(hr == S_OK)
2477         {
2478             /* Comment */
2479             hr = IXMLDOMDocument_createComment(doc, szComment, &pComment);
2480             ok(hr == S_OK, "ret %08x\n", hr );
2481             if(hr == S_OK)
2482             {
2483                 /* test get_attributes */
2484                 hr = IXMLDOMComment_get_attributes( pComment, NULL );
2485                 ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2486
2487                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2488                 hr = IXMLDOMComment_get_attributes( pComment, &pAttribs);
2489                 ok(hr == S_FALSE, "ret %08x\n", hr );
2490                 ok( pAttribs == NULL, "pAttribs not NULL\n");
2491
2492                 /* test nodeTypeString */
2493                 hr = IXMLDOMComment_get_nodeTypeString(pComment, &str);
2494                 ok(hr == S_OK, "ret %08x\n", hr );
2495                 ok( !lstrcmpW( str, _bstr_("comment") ), "incorrect nodeTypeString string\n");
2496                 SysFreeString(str);
2497
2498                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
2499                 ok(hr == S_OK, "ret %08x\n", hr );
2500
2501                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
2502                 ok(hr == S_OK, "ret %08x\n", hr );
2503                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
2504                 SysFreeString(str);
2505
2506                 hr = IXMLDOMComment_get_xml(pComment, &str);
2507                 ok(hr == S_OK, "ret %08x\n", hr );
2508                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
2509                 SysFreeString(str);
2510
2511                 hr = IXMLDOMComment_get_dataType(pComment, &v);
2512                 ok(hr == S_FALSE, "ret %08x\n", hr );
2513                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2514                 VariantClear(&v);
2515
2516                 /* put data Tests */
2517                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
2518                 ok(hr == S_OK, "ret %08x\n", hr );
2519
2520                 /* get data Tests */
2521                 hr = IXMLDOMComment_get_data(pComment, &str);
2522                 ok(hr == S_OK, "ret %08x\n", hr );
2523                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
2524                 SysFreeString(str);
2525
2526                 /* get data Tests */
2527                 hr = IXMLDOMComment_get_nodeValue(pComment, &v);
2528                 ok(hr == S_OK, "ret %08x\n", hr );
2529                 ok( V_VT(&v) == VT_BSTR, "incorrect dataType type\n");
2530                 ok( !lstrcmpW( V_BSTR(&v), _bstr_("This &is a ; test <>\\") ), "incorrect get_nodeValue string\n");
2531                 VariantClear(&v);
2532
2533                 /* Confirm XML text is good */
2534                 hr = IXMLDOMComment_get_xml(pComment, &str);
2535                 ok(hr == S_OK, "ret %08x\n", hr );
2536                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
2537                 SysFreeString(str);
2538
2539                 /* Confirm we get the put_data Text back */
2540                 hr = IXMLDOMComment_get_text(pComment, &str);
2541                 ok(hr == S_OK, "ret %08x\n", hr );
2542                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
2543                 SysFreeString(str);
2544
2545                 /* test length property */
2546                 hr = IXMLDOMComment_get_length(pComment, &len);
2547                 ok(hr == S_OK, "ret %08x\n", hr );
2548                 ok(len == 21, "expected 21 got %ld\n", len);
2549
2550                 /* test substringData */
2551                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
2552                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2553
2554                 /* test substringData - Invalid offset */
2555                 str = (BSTR)&szElement;
2556                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
2557                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2558                 ok( str == NULL, "incorrect string\n");
2559
2560                 /* test substringData - Invalid offset */
2561                 str = (BSTR)&szElement;
2562                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
2563                 ok(hr == S_FALSE, "ret %08x\n", hr );
2564                 ok( str == NULL, "incorrect string\n");
2565
2566                 /* test substringData - Invalid size */
2567                 str = (BSTR)&szElement;
2568                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
2569                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2570                 ok( str == NULL, "incorrect string\n");
2571
2572                 /* test substringData - Invalid size */
2573                 str = (BSTR)&szElement;
2574                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
2575                 ok(hr == S_FALSE, "ret %08x\n", hr );
2576                 ok( str == NULL, "incorrect string\n");
2577
2578                 /* test substringData - Start of string */
2579                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
2580                 ok(hr == S_OK, "ret %08x\n", hr );
2581                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
2582                 SysFreeString(str);
2583
2584                 /* test substringData - Middle of string */
2585                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
2586                 ok(hr == S_OK, "ret %08x\n", hr );
2587                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
2588                 SysFreeString(str);
2589
2590                 /* test substringData - End of string */
2591                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
2592                 ok(hr == S_OK, "ret %08x\n", hr );
2593                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
2594                 SysFreeString(str);
2595
2596                 /* test appendData */
2597                 hr = IXMLDOMComment_appendData(pComment, NULL);
2598                 ok(hr == S_OK, "ret %08x\n", hr );
2599
2600                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
2601                 ok(hr == S_OK, "ret %08x\n", hr );
2602
2603                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
2604                 ok(hr == S_OK, "ret %08x\n", hr );
2605
2606                 hr = IXMLDOMComment_get_text(pComment, &str);
2607                 ok(hr == S_OK, "ret %08x\n", hr );
2608                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string\n");
2609                 SysFreeString(str);
2610
2611                 /* test insertData */
2612                 str = SysAllocStringLen(NULL, 0);
2613                 hr = IXMLDOMComment_insertData(pComment, -1, str);
2614                 ok(hr == S_OK, "ret %08x\n", hr );
2615
2616                 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
2617                 ok(hr == S_OK, "ret %08x\n", hr );
2618
2619                 hr = IXMLDOMComment_insertData(pComment, 1000, str);
2620                 ok(hr == S_OK, "ret %08x\n", hr );
2621
2622                 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
2623                 ok(hr == S_OK, "ret %08x\n", hr );
2624
2625                 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
2626                 ok(hr == S_OK, "ret %08x\n", hr );
2627
2628                 hr = IXMLDOMComment_insertData(pComment, 0, str);
2629                 ok(hr == S_OK, "ret %08x\n", hr );
2630                 SysFreeString(str);
2631
2632                 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
2633                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2634
2635                 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
2636                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2637
2638                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
2639                 ok(hr == S_OK, "ret %08x\n", hr );
2640
2641                 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
2642                 ok(hr == S_OK, "ret %08x\n", hr );
2643
2644                 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
2645                 ok(hr == S_OK, "ret %08x\n", hr );
2646
2647                 hr = IXMLDOMComment_get_text(pComment, &str);
2648                 ok(hr == S_OK, "ret %08x\n", hr );
2649                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string\n");
2650                 SysFreeString(str);
2651
2652                 IXMLDOMComment_Release(pComment);
2653             }
2654
2655             /* Element */
2656             hr = IXMLDOMDocument_createElement(doc, szElement, &pElement);
2657             ok(hr == S_OK, "ret %08x\n", hr );
2658             if(hr == S_OK)
2659             {
2660                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2661                 ok(hr == S_OK, "ret %08x\n", hr );
2662
2663                 /* test nodeTypeString */
2664                 hr = IXMLDOMDocument_get_nodeTypeString(pElement, &str);
2665                 ok(hr == S_OK, "ret %08x\n", hr );
2666                 ok( !lstrcmpW( str, _bstr_("element") ), "incorrect nodeTypeString string\n");
2667                 SysFreeString(str);
2668
2669                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
2670                 ok(hr == S_OK, "ret %08x\n", hr );
2671                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
2672                 SysFreeString(str);
2673
2674                 hr = IXMLDOMElement_get_xml(pElement, &str);
2675                 ok(hr == S_OK, "ret %08x\n", hr );
2676                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
2677                 SysFreeString(str);
2678
2679                 hr = IXMLDOMElement_get_dataType(pElement, &v);
2680                 ok(hr == S_FALSE, "ret %08x\n", hr );
2681                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2682                 VariantClear(&v);
2683
2684                  /* Attribute */
2685                 hr = IXMLDOMDocument_createAttribute(doc, szAttribute, &pAttrubute);
2686                 ok(hr == S_OK, "ret %08x\n", hr );
2687                 if(hr == S_OK)
2688                 {
2689                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
2690
2691                     hr = IXMLDOMAttribute_get_nextSibling(pAttrubute, NULL);
2692                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2693
2694                     pNextChild = (IXMLDOMNode *)0x1;
2695                     hr = IXMLDOMAttribute_get_nextSibling(pAttrubute, &pNextChild);
2696                     ok(hr == S_FALSE, "ret %08x\n", hr );
2697                     ok(pNextChild == NULL, "pNextChild not NULL\n");
2698
2699                     /* test Previous Sibling*/
2700                     hr = IXMLDOMAttribute_get_previousSibling(pAttrubute, NULL);
2701                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2702
2703                     pNextChild = (IXMLDOMNode *)0x1;
2704                     hr = IXMLDOMAttribute_get_previousSibling(pAttrubute, &pNextChild);
2705                     ok(hr == S_FALSE, "ret %08x\n", hr );
2706                     ok(pNextChild == NULL, "pNextChild not NULL\n");
2707
2708                     /* test get_attributes */
2709                     hr = IXMLDOMAttribute_get_attributes( pAttrubute, NULL );
2710                     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2711
2712                     pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2713                     hr = IXMLDOMAttribute_get_attributes( pAttrubute, &pAttribs);
2714                     ok(hr == S_FALSE, "ret %08x\n", hr );
2715                     ok( pAttribs == NULL, "pAttribs not NULL\n");
2716
2717                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttrubute, &pNewChild);
2718                     ok(hr == E_FAIL, "ret %08x\n", hr );
2719                     ok(pNewChild == NULL, "pNewChild not NULL\n");
2720
2721                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
2722                     ok(hr == S_OK, "ret %08x\n", hr );
2723                     if ( hr == S_OK )
2724                     {
2725                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttrubute, NULL );
2726                         ok(hr == S_OK, "ret %08x\n", hr );
2727
2728                         IXMLDOMNamedNodeMap_Release(pAttribs);
2729                     }
2730
2731                     hr = IXMLDOMAttribute_get_nodeName(pAttrubute, &str);
2732                     ok(hr == S_OK, "ret %08x\n", hr );
2733                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
2734                     SysFreeString(str);
2735
2736                     /* test nodeTypeString */
2737                     hr = IXMLDOMAttribute_get_nodeTypeString(pAttrubute, &str);
2738                     ok(hr == S_OK, "ret %08x\n", hr );
2739                     ok( !lstrcmpW( str, _bstr_("attribute") ), "incorrect nodeTypeString string\n");
2740                     SysFreeString(str);
2741
2742                     /* test nodeName */
2743                     hr = IXMLDOMAttribute_get_nodeName(pAttrubute, &str);
2744                     ok(hr == S_OK, "ret %08x\n", hr );
2745                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
2746                     SysFreeString(str);
2747
2748                     /* test name property */
2749                     hr = IXMLDOMAttribute_get_name(pAttrubute, &str);
2750                     ok(hr == S_OK, "ret %08x\n", hr );
2751                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
2752                     SysFreeString(str);
2753
2754                     hr = IXMLDOMAttribute_get_xml(pAttrubute, &str);
2755                     ok(hr == S_OK, "ret %08x\n", hr );
2756                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
2757                     SysFreeString(str);
2758
2759                     hr = IXMLDOMAttribute_get_dataType(pAttrubute, &v);
2760                     ok(hr == S_FALSE, "ret %08x\n", hr );
2761                     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2762                     VariantClear(&v);
2763
2764                     IXMLDOMAttribute_Release(pAttrubute);
2765
2766                     /* Check Element again with the Add Attribute*/
2767                     hr = IXMLDOMElement_get_xml(pElement, &str);
2768                     ok(hr == S_OK, "ret %08x\n", hr );
2769                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
2770                     SysFreeString(str);
2771                 }
2772
2773                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
2774                 ok(hr == S_OK, "ret %08x\n", hr );
2775
2776                 hr = IXMLDOMElement_get_xml(pElement, &str);
2777                 ok(hr == S_OK, "ret %08x\n", hr );
2778                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
2779                 SysFreeString(str);
2780
2781                 IXMLDOMElement_Release(pElement);
2782             }
2783
2784             /* CData Section */
2785             hr = IXMLDOMDocument_createCDATASection(doc, szCData, NULL);
2786             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2787
2788             hr = IXMLDOMDocument_createCDATASection(doc, szCData, &pCDataSec);
2789             ok(hr == S_OK, "ret %08x\n", hr );
2790             if(hr == S_OK)
2791             {
2792                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
2793                 VARIANT var;
2794
2795                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
2796                 ok(hr == S_OK, "ret %08x\n", hr );
2797
2798                 /* get Attribute Tests */
2799                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, NULL);
2800                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2801
2802                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2803                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, &pAttribs);
2804                 ok(hr == S_FALSE, "ret %08x\n", hr );
2805                 ok(pAttribs == NULL, "pAttribs != NULL\n");
2806
2807                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
2808                 ok(hr == S_OK, "ret %08x\n", hr );
2809                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
2810                 SysFreeString(str);
2811
2812                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
2813                 ok(hr == S_OK, "ret %08x\n", hr );
2814                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
2815                 SysFreeString(str);
2816
2817                 /* test lastChild */
2818                 pNextChild = (IXMLDOMNode*)0x1;
2819                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
2820                 ok(hr == S_FALSE, "ret %08x\n", hr );
2821                 ok(pNextChild == NULL, "pNextChild not NULL\n");
2822
2823                 /* test get_dataType */
2824                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, NULL);
2825                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2826
2827                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, &v);
2828                 ok(hr == S_FALSE, "ret %08x\n", hr );
2829                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2830                 VariantClear(&v);
2831
2832                 /* test nodeTypeString */
2833                 hr = IXMLDOMCDATASection_get_nodeTypeString(pCDataSec, &str);
2834                 ok(hr == S_OK, "ret %08x\n", hr );
2835                 ok( !lstrcmpW( str, _bstr_("cdatasection") ), "incorrect nodeTypeString string\n");
2836                 SysFreeString(str);
2837
2838                 /* put data Tests */
2839                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
2840                 ok(hr == S_OK, "ret %08x\n", hr );
2841
2842                 /* Confirm XML text is good */
2843                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
2844                 ok(hr == S_OK, "ret %08x\n", hr );
2845                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
2846                 SysFreeString(str);
2847
2848                 /* Confirm we get the put_data Text back */
2849                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
2850                 ok(hr == S_OK, "ret %08x\n", hr );
2851                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2852                 SysFreeString(str);
2853
2854                 /* test length property */
2855                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
2856                 ok(hr == S_OK, "ret %08x\n", hr );
2857                 ok(len == 21, "expected 21 got %ld\n", len);
2858
2859                 /* test get nodeValue */
2860                 hr = IXMLDOMCDATASection_get_nodeValue(pCDataSec, &var);
2861                 ok(hr == S_OK, "ret %08x\n", hr );
2862                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2863                 VariantClear(&var);
2864
2865                 /* test get data */
2866                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
2867                 ok(hr == S_OK, "ret %08x\n", hr );
2868                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2869                 SysFreeString(str);
2870
2871                 /* test substringData */
2872                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
2873                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2874
2875                 /* test substringData - Invalid offset */
2876                 str = (BSTR)&szElement;
2877                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
2878                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2879                 ok( str == NULL, "incorrect string\n");
2880
2881                 /* test substringData - Invalid offset */
2882                 str = (BSTR)&szElement;
2883                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
2884                 ok(hr == S_FALSE, "ret %08x\n", hr );
2885                 ok( str == NULL, "incorrect string\n");
2886
2887                 /* test substringData - Invalid size */
2888                 str = (BSTR)&szElement;
2889                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
2890                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2891                 ok( str == NULL, "incorrect string\n");
2892
2893                 /* test substringData - Invalid size */
2894                 str = (BSTR)&szElement;
2895                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
2896                 ok(hr == S_FALSE, "ret %08x\n", hr );
2897                 ok( str == NULL, "incorrect string\n");
2898
2899                 /* test substringData - Start of string */
2900                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
2901                 ok(hr == S_OK, "ret %08x\n", hr );
2902                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
2903                 SysFreeString(str);
2904
2905                 /* test substringData - Middle of string */
2906                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
2907                 ok(hr == S_OK, "ret %08x\n", hr );
2908                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
2909                 SysFreeString(str);
2910
2911                 /* test substringData - End of string */
2912                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
2913                 ok(hr == S_OK, "ret %08x\n", hr );
2914                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
2915                 SysFreeString(str);
2916
2917                 /* test appendData */
2918                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
2919                 ok(hr == S_OK, "ret %08x\n", hr );
2920
2921                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
2922                 ok(hr == S_OK, "ret %08x\n", hr );
2923
2924                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
2925                 ok(hr == S_OK, "ret %08x\n", hr );
2926
2927                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
2928                 ok(hr == S_OK, "ret %08x\n", hr );
2929                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string\n");
2930                 SysFreeString(str);
2931
2932                 /* test insertData */
2933                 str = SysAllocStringLen(NULL, 0);
2934                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
2935                 ok(hr == S_OK, "ret %08x\n", hr );
2936
2937                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
2938                 ok(hr == S_OK, "ret %08x\n", hr );
2939
2940                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
2941                 ok(hr == S_OK, "ret %08x\n", hr );
2942
2943                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
2944                 ok(hr == S_OK, "ret %08x\n", hr );
2945
2946                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
2947                 ok(hr == S_OK, "ret %08x\n", hr );
2948
2949                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
2950                 ok(hr == S_OK, "ret %08x\n", hr );
2951                 SysFreeString(str);
2952
2953                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
2954                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2955
2956                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
2957                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2958
2959                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
2960                 ok(hr == S_OK, "ret %08x\n", hr );
2961
2962                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
2963                 ok(hr == S_OK, "ret %08x\n", hr );
2964
2965                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
2966                 ok(hr == S_OK, "ret %08x\n", hr );
2967
2968                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
2969                 ok(hr == S_OK, "ret %08x\n", hr );
2970                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string\n");
2971                 SysFreeString(str);
2972
2973                 IXMLDOMCDATASection_Release(pCDataSec);
2974             }
2975
2976             /* Document Fragments */
2977             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
2978             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2979
2980             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
2981             ok(hr == S_OK, "ret %08x\n", hr );
2982             if(hr == S_OK)
2983             {
2984                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
2985
2986                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
2987                 ok(hr == S_OK, "ret %08x\n", hr );
2988
2989                 /* get Attribute Tests */
2990                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, NULL);
2991                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2992
2993                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2994                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, &pAttribs);
2995                 ok(hr == S_FALSE, "ret %08x\n", hr );
2996                 ok(pAttribs == NULL, "pAttribs != NULL\n");
2997
2998                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
2999                 ok(hr == S_OK, "ret %08x\n", hr );
3000                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
3001                 SysFreeString(str);
3002
3003                 /* test next Sibling*/
3004                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
3005                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3006
3007                 pNextChild = (IXMLDOMNode *)0x1;
3008                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &pNextChild);
3009                 ok(hr == S_FALSE, "ret %08x\n", hr );
3010                 ok(pNextChild == NULL, "pNextChild not NULL\n");
3011
3012                 /* test Previous Sibling*/
3013                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
3014                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3015
3016                 pNextChild = (IXMLDOMNode *)0x1;
3017                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &pNextChild);
3018                 ok(hr == S_FALSE, "ret %08x\n", hr );
3019                 ok(pNextChild == NULL, "pNextChild not NULL\n");
3020
3021                 /* test get_dataType */
3022                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, NULL);
3023                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3024
3025                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, &v);
3026                 ok(hr == S_FALSE, "ret %08x\n", hr );
3027                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
3028                 VariantClear(&v);
3029
3030                 /* test nodeTypeString */
3031                 hr = IXMLDOMDocumentFragment_get_nodeTypeString(pDocFrag, &str);
3032                 ok(hr == S_OK, "ret %08x\n", hr );
3033                 ok( !lstrcmpW( str, _bstr_("documentfragment") ), "incorrect nodeTypeString string\n");
3034                 SysFreeString(str);
3035
3036                 IXMLDOMDocumentFragment_Release(pDocFrag);
3037             }
3038
3039             /* Entity References */
3040             hr = IXMLDOMDocument_createEntityReference(doc, szEntityRef, NULL);
3041             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3042
3043             hr = IXMLDOMDocument_createEntityReference(doc, szEntityRef, &pEntityRef);
3044             ok(hr == S_OK, "ret %08x\n", hr );
3045             if(hr == S_OK)
3046             {
3047                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
3048                 ok(hr == S_OK, "ret %08x\n", hr );
3049
3050                 /* get Attribute Tests */
3051                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, NULL);
3052                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3053
3054                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
3055                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, &pAttribs);
3056                 ok(hr == S_FALSE, "ret %08x\n", hr );
3057                 ok(pAttribs == NULL, "pAttribs != NULL\n");
3058
3059                 /* test dataType */
3060                 hr = IXMLDOMEntityReference_get_dataType(pEntityRef, &v);
3061                 ok(hr == S_FALSE, "ret %08x\n", hr );
3062                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
3063                 VariantClear(&v);
3064
3065                 /* test nodeTypeString */
3066                 hr = IXMLDOMEntityReference_get_nodeTypeString(pEntityRef, &str);
3067                 ok(hr == S_OK, "ret %08x\n", hr );
3068                 ok( !lstrcmpW( str, _bstr_("entityreference") ), "incorrect nodeTypeString string\n");
3069                 SysFreeString(str);
3070
3071                 /* test get_xml*/
3072                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
3073                 ok(hr == S_OK, "ret %08x\n", hr );
3074                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
3075                 SysFreeString(str);
3076
3077                 IXMLDOMEntityReference_Release(pEntityRef);
3078             }
3079
3080             IXMLDOMElement_Release( pRoot );
3081         }
3082     }
3083
3084     IXMLDOMDocument_Release(doc);
3085
3086     free_bstrs();
3087 }
3088
3089 static void test_nodeTypeTests( void )
3090 {
3091     IXMLDOMDocument *doc = NULL;
3092     IXMLDOMElement *pRoot;
3093     IXMLDOMElement *pElement;
3094     HRESULT hr;
3095
3096     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3097     if( hr != S_OK )
3098         return;
3099
3100     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
3101     ok(hr == S_OK, "ret %08x\n", hr );
3102     if(hr == S_OK)
3103     {
3104         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
3105         ok(hr == S_OK, "ret %08x\n", hr );
3106         if(hr == S_OK)
3107         {
3108             hr = IXMLDOMElement_put_dataType(pRoot, NULL);
3109             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3110
3111             /* Invalid Value */
3112             hr = IXMLDOMElement_put_dataType(pRoot, _bstr_("abcdefg") );
3113             ok(hr == E_FAIL, "ret %08x\n", hr );
3114
3115             /* NOTE:
3116              *   The name passed into put_dataType is case-insensitive. So many of the names
3117              *     have been changed to reflect this.
3118              */
3119             /* Boolean */
3120             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Boolean"), &pElement);
3121             ok(hr == S_OK, "ret %08x\n", hr );
3122             if(hr == S_OK)
3123             {
3124                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3125
3126                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Boolean") );
3127                 ok(hr == S_OK, "ret %08x\n", hr );
3128
3129                 IXMLDOMElement_Release(pElement);
3130             }
3131
3132             /* String */
3133             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_String"), &pElement);
3134             ok(hr == S_OK, "ret %08x\n", hr );
3135             if(hr == S_OK)
3136             {
3137                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3138
3139                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("String") );
3140                 ok(hr == S_OK, "ret %08x\n", hr );
3141
3142                 IXMLDOMElement_Release(pElement);
3143             }
3144
3145             /* Number */
3146             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Number"), &pElement);
3147             ok(hr == S_OK, "ret %08x\n", hr );
3148             if(hr == S_OK)
3149             {
3150                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3151
3152                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("number") );
3153                 ok(hr == S_OK, "ret %08x\n", hr );
3154
3155                 IXMLDOMElement_Release(pElement);
3156             }
3157
3158             /* Int */
3159             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Int"), &pElement);
3160             ok(hr == S_OK, "ret %08x\n", hr );
3161             if(hr == S_OK)
3162             {
3163                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3164
3165                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("InT") );
3166                 ok(hr == S_OK, "ret %08x\n", hr );
3167
3168                 IXMLDOMElement_Release(pElement);
3169             }
3170
3171             /* Fixed */
3172             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Fixed"), &pElement);
3173             ok(hr == S_OK, "ret %08x\n", hr );
3174             if(hr == S_OK)
3175             {
3176                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3177
3178                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("fixed.14.4") );
3179                 ok(hr == S_OK, "ret %08x\n", hr );
3180
3181                 IXMLDOMElement_Release(pElement);
3182             }
3183
3184             /* DateTime */
3185             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime"), &pElement);
3186             ok(hr == S_OK, "ret %08x\n", hr );
3187             if(hr == S_OK)
3188             {
3189                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3190
3191                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime") );
3192                 ok(hr == S_OK, "ret %08x\n", hr );
3193
3194                 IXMLDOMElement_Release(pElement);
3195             }
3196
3197             /* DateTime TZ */
3198             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime_tz"), &pElement);
3199             ok(hr == S_OK, "ret %08x\n", hr );
3200             if(hr == S_OK)
3201             {
3202                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3203
3204                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
3205                 ok(hr == S_OK, "ret %08x\n", hr );
3206
3207                 IXMLDOMElement_Release(pElement);
3208             }
3209
3210             /* Date */
3211             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Date"), &pElement);
3212             ok(hr == S_OK, "ret %08x\n", hr );
3213             if(hr == S_OK)
3214             {
3215                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3216
3217                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Date") );
3218                 ok(hr == S_OK, "ret %08x\n", hr );
3219
3220                 IXMLDOMElement_Release(pElement);
3221             }
3222
3223             /* Time */
3224             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time"), &pElement);
3225             ok(hr == S_OK, "ret %08x\n", hr );
3226             if(hr == S_OK)
3227             {
3228                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3229
3230                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time") );
3231                 ok(hr == S_OK, "ret %08x\n", hr );
3232
3233                 IXMLDOMElement_Release(pElement);
3234             }
3235
3236             /* Time.tz */
3237             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time_TZ"), &pElement);
3238             ok(hr == S_OK, "ret %08x\n", hr );
3239             if(hr == S_OK)
3240             {
3241                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3242
3243                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time.tz") );
3244                 ok(hr == S_OK, "ret %08x\n", hr );
3245
3246                 IXMLDOMElement_Release(pElement);
3247             }
3248
3249             /* I1 */
3250             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I1"), &pElement);
3251             ok(hr == S_OK, "ret %08x\n", hr );
3252             if(hr == S_OK)
3253             {
3254                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3255
3256                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I1") );
3257                 ok(hr == S_OK, "ret %08x\n", hr );
3258
3259                 IXMLDOMElement_Release(pElement);
3260             }
3261
3262             /* I2 */
3263             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I2"), &pElement);
3264             ok(hr == S_OK, "ret %08x\n", hr );
3265             if(hr == S_OK)
3266             {
3267                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3268
3269                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I2") );
3270                 ok(hr == S_OK, "ret %08x\n", hr );
3271
3272                 IXMLDOMElement_Release(pElement);
3273             }
3274
3275             /* I4 */
3276             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I4"), &pElement);
3277             ok(hr == S_OK, "ret %08x\n", hr );
3278             if(hr == S_OK)
3279             {
3280                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3281
3282                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I4") );
3283                 ok(hr == S_OK, "ret %08x\n", hr );
3284
3285                 IXMLDOMElement_Release(pElement);
3286             }
3287
3288             /* UI1 */
3289             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI1"), &pElement);
3290             ok(hr == S_OK, "ret %08x\n", hr );
3291             if(hr == S_OK)
3292             {
3293                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3294
3295                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI1") );
3296                 ok(hr == S_OK, "ret %08x\n", hr );
3297
3298                 IXMLDOMElement_Release(pElement);
3299             }
3300
3301             /* UI2 */
3302             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI2"), &pElement);
3303             ok(hr == S_OK, "ret %08x\n", hr );
3304             if(hr == S_OK)
3305             {
3306                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3307
3308                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI2") );
3309                 ok(hr == S_OK, "ret %08x\n", hr );
3310
3311                 IXMLDOMElement_Release(pElement);
3312             }
3313
3314             /* UI4 */
3315             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI4"), &pElement);
3316             ok(hr == S_OK, "ret %08x\n", hr );
3317             if(hr == S_OK)
3318             {
3319                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3320
3321                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI4") );
3322                 ok(hr == S_OK, "ret %08x\n", hr );
3323
3324                 IXMLDOMElement_Release(pElement);
3325             }
3326
3327             /* r4 */
3328             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r4"), &pElement);
3329             ok(hr == S_OK, "ret %08x\n", hr );
3330             if(hr == S_OK)
3331             {
3332                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3333
3334                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r4") );
3335                 ok(hr == S_OK, "ret %08x\n", hr );
3336
3337                 IXMLDOMElement_Release(pElement);
3338             }
3339
3340             /* r8 */
3341             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r8"), &pElement);
3342             ok(hr == S_OK, "ret %08x\n", hr );
3343             if(hr == S_OK)
3344             {
3345                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3346
3347                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r8") );
3348                 ok(hr == S_OK, "ret %08x\n", hr );
3349
3350                 IXMLDOMElement_Release(pElement);
3351             }
3352
3353             /* float */
3354             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_float"), &pElement);
3355             ok(hr == S_OK, "ret %08x\n", hr );
3356             if(hr == S_OK)
3357             {
3358                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3359
3360                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("float") );
3361                 ok(hr == S_OK, "ret %08x\n", hr );
3362
3363                 IXMLDOMElement_Release(pElement);
3364             }
3365
3366             /* uuid */
3367             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_uuid"), &pElement);
3368             ok(hr == S_OK, "ret %08x\n", hr );
3369             if(hr == S_OK)
3370             {
3371                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3372
3373                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UuId") );
3374                 ok(hr == S_OK, "ret %08x\n", hr );
3375
3376                 IXMLDOMElement_Release(pElement);
3377             }
3378
3379             /* bin.hex */
3380             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_hex"), &pElement);
3381             ok(hr == S_OK, "ret %08x\n", hr );
3382             if(hr == S_OK)
3383             {
3384                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3385
3386                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.hex") );
3387                 ok(hr == S_OK, "ret %08x\n", hr );
3388
3389                 IXMLDOMElement_Release(pElement);
3390             }
3391
3392             /* bin.base64 */
3393             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_base64"), &pElement);
3394             ok(hr == S_OK, "ret %08x\n", hr );
3395             if(hr == S_OK)
3396             {
3397                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3398
3399                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.base64") );
3400                 ok(hr == S_OK, "ret %08x\n", hr );
3401
3402                 IXMLDOMElement_Release(pElement);
3403             }
3404
3405             /* Check changing types */
3406             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &pElement);
3407             ok(hr == S_OK, "ret %08x\n", hr );
3408             if(hr == S_OK)
3409             {
3410                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3411
3412                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
3413                 ok(hr == S_OK, "ret %08x\n", hr );
3414
3415                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("string") );
3416                 ok(hr == S_OK, "ret %08x\n", hr );
3417
3418                 IXMLDOMElement_Release(pElement);
3419             }
3420
3421             IXMLDOMElement_Release(pRoot);
3422         }
3423     }
3424
3425     IXMLDOMDocument_Release(doc);
3426
3427     free_bstrs();
3428 }
3429
3430 static void test_DocumentSaveToDocument(void)
3431 {
3432     IXMLDOMDocument *doc = NULL;
3433     IXMLDOMDocument *doc2 = NULL;
3434     IXMLDOMElement *pRoot;
3435
3436     HRESULT hr;
3437
3438     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3439     if( hr != S_OK )
3440         return;
3441
3442     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc2 );
3443     if( hr != S_OK )
3444     {
3445         IXMLDOMDocument_Release(doc);
3446         return;
3447     }
3448
3449     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
3450     ok(hr == S_OK, "ret %08x\n", hr );
3451     if(hr == S_OK)
3452     {
3453         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
3454         ok(hr == S_OK, "ret %08x\n", hr );
3455         if(hr == S_OK)
3456         {
3457             VARIANT vDoc;
3458             BSTR sOrig;
3459             BSTR sNew;
3460
3461             V_VT(&vDoc) = VT_UNKNOWN;
3462             V_UNKNOWN(&vDoc) = (IUnknown*)doc2;
3463
3464             hr = IXMLDOMDocument_save(doc, vDoc);
3465             ok(hr == S_OK, "ret %08x\n", hr );
3466
3467             hr = IXMLDOMDocument_get_xml(doc, &sOrig);
3468             ok(hr == S_OK, "ret %08x\n", hr );
3469
3470             hr = IXMLDOMDocument_get_xml(doc2, &sNew);
3471             ok(hr == S_OK, "ret %08x\n", hr );
3472
3473             ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as origial\n");
3474
3475             SysFreeString(sOrig);
3476             SysFreeString(sNew);
3477         }
3478     }
3479
3480     IXMLDOMDocument_Release(doc2);
3481     IXMLDOMDocument_Release(doc);
3482 }
3483
3484 static void test_DocumentSaveToFile(void)
3485 {
3486     IXMLDOMDocument *doc = NULL;
3487     IXMLDOMElement *pRoot;
3488     HANDLE file;
3489     char buffer[100];
3490     DWORD read = 0;
3491     HRESULT hr;
3492
3493     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3494     if( hr != S_OK )
3495         return;
3496
3497     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
3498     ok(hr == S_OK, "ret %08x\n", hr );
3499     if(hr == S_OK)
3500     {
3501         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
3502         ok(hr == S_OK, "ret %08x\n", hr );
3503         if(hr == S_OK)
3504         {
3505             VARIANT vFile;
3506
3507             V_VT(&vFile) = VT_BSTR;
3508             V_BSTR(&vFile) = _bstr_("test.xml");
3509
3510             hr = IXMLDOMDocument_save(doc, vFile);
3511             ok(hr == S_OK, "ret %08x\n", hr );
3512         }
3513     }
3514
3515     IXMLDOMElement_Release(pRoot);
3516     IXMLDOMDocument_Release(doc);
3517
3518     file = CreateFile("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
3519     ok(file != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
3520     if(file == INVALID_HANDLE_VALUE)
3521         return;
3522
3523     ReadFile(file, buffer, sizeof(buffer), &read, NULL);
3524     ok(read != 0, "could not read file\n");
3525     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
3526
3527     CloseHandle(file);
3528     DeleteFile("test.xml");
3529 }
3530
3531 static void test_testTransforms(void)
3532 {
3533     IXMLDOMDocument *doc = NULL;
3534     IXMLDOMDocument *docSS = NULL;
3535     IXMLDOMNode *pNode;
3536     VARIANT_BOOL bSucc;
3537
3538     HRESULT hr;
3539
3540     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3541     if( hr != S_OK )
3542         return;
3543
3544     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&docSS );
3545     if( hr != S_OK )
3546     {
3547         IXMLDOMDocument_Release(doc);
3548         return;
3549     }
3550
3551     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
3552     ok(hr == S_OK, "ret %08x\n", hr );
3553
3554     hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
3555     ok(hr == S_OK, "ret %08x\n", hr );
3556
3557     hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (LPVOID*)&pNode );
3558     ok(hr == S_OK, "ret %08x\n", hr );
3559     if(hr == S_OK)
3560     {
3561         BSTR bOut;
3562
3563         hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
3564         ok(hr == S_OK, "ret %08x\n", hr );
3565         ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "Stylesheet output not correct\n");
3566
3567         IXMLDOMNode_Release(pNode);
3568     }
3569
3570     IXMLDOMDocument_Release(docSS);
3571     IXMLDOMDocument_Release(doc);
3572
3573     free_bstrs();
3574 }
3575
3576 static void test_Namespaces(void)
3577 {
3578     IXMLDOMDocument2 *doc = NULL;
3579     IXMLDOMNode *pNode;
3580     IXMLDOMNode *pNode2 = NULL;
3581     VARIANT_BOOL bSucc;
3582     HRESULT hr;
3583     BSTR str;
3584     static  const CHAR szNamespacesXML[] =
3585 "<?xml version=\"1.0\"?>\n"
3586 "<root xmlns:WEB='http://www.winehq.org'>\n"
3587 "<WEB:Site version=\"1.0\" />\n"
3588 "</root>";
3589
3590     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3591     if( hr != S_OK )
3592         return;
3593
3594     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNamespacesXML), &bSucc);
3595     ok(hr == S_OK, "ret %08x\n", hr );
3596     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
3597
3598     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root"), &pNode );
3599     ok(hr == S_OK, "ret %08x\n", hr );
3600     if(hr == S_OK)
3601     {
3602         hr = IXMLDOMNode_get_firstChild( pNode, &pNode2 );
3603         ok( hr == S_OK, "ret %08x\n", hr );
3604         ok( pNode2 != NULL, "pNode2 == NULL\n");
3605
3606         /* Test get_prefix */
3607         hr = IXMLDOMNode_get_prefix(pNode2, NULL);
3608         ok( hr == E_INVALIDARG, "ret %08x\n", hr );
3609         /* NOTE: Need to test that arg2 gets cleared on Error. */
3610
3611         hr = IXMLDOMNode_get_prefix(pNode2, &str);
3612         ok( hr == S_OK, "ret %08x\n", hr );
3613         ok( !lstrcmpW( str, _bstr_("WEB")), "incorrect prefix string\n");
3614         SysFreeString(str);
3615
3616         /* Test get_namespaceURI */
3617         hr = IXMLDOMNode_get_namespaceURI(pNode2, NULL);
3618         ok( hr == E_INVALIDARG, "ret %08x\n", hr );
3619         /* NOTE: Need to test that arg2 gets cleared on Error. */
3620
3621         hr = IXMLDOMNode_get_namespaceURI(pNode2, &str);
3622         ok( hr == S_OK, "ret %08x\n", hr );
3623         ok( !lstrcmpW( str, _bstr_("http://www.winehq.org")), "incorrect namespaceURI string\n");
3624         SysFreeString(str);
3625
3626         IXMLDOMNode_Release(pNode2);
3627         IXMLDOMNode_Release(pNode);
3628     }
3629
3630     IXMLDOMDocument2_Release(doc);
3631
3632     free_bstrs();
3633 }
3634
3635 static void test_FormattingXML(void)
3636 {
3637     IXMLDOMDocument2 *doc = NULL;
3638     IXMLDOMElement *pElement;
3639     VARIANT_BOOL bSucc;
3640     HRESULT hr;
3641     BSTR str;
3642     static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
3643     static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
3644
3645     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3646     if( hr != S_OK )
3647         return;
3648
3649     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
3650     ok(hr == S_OK, "ret %08x\n", hr );
3651     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
3652
3653     if(bSucc == VARIANT_TRUE)
3654     {
3655         hr = IXMLDOMDocument2_get_documentElement(doc, &pElement);
3656         ok(hr == S_OK, "ret %08x\n", hr );
3657         if(hr == S_OK)
3658         {
3659             hr = IXMLDOMElement_get_xml(pElement, &str);
3660             ok(hr == S_OK, "ret %08x\n", hr );
3661             ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
3662             SysFreeString(str);
3663
3664             IXMLDOMElement_Release(pElement);
3665         }
3666     }
3667
3668     IXMLDOMDocument2_Release(doc);
3669
3670     free_bstrs();
3671 }
3672
3673 START_TEST(domdoc)
3674 {
3675     HRESULT r;
3676
3677     r = CoInitialize( NULL );
3678     ok( r == S_OK, "failed to init com\n");
3679
3680     test_domdoc();
3681     test_domnode();
3682     test_refs();
3683     test_create();
3684     test_getElementsByTagName();
3685     test_get_text();
3686     test_get_childNodes();
3687     test_removeChild();
3688     test_replaceChild();
3689     test_XMLHTTP();
3690     test_IXMLDOMDocument2();
3691     test_XPath();
3692     test_cloneNode();
3693     test_xmlTypes();
3694     test_nodeTypeTests();
3695     test_DocumentSaveToDocument();
3696     test_DocumentSaveToFile();
3697     test_testTransforms();
3698     test_Namespaces();
3699     test_FormattingXML();
3700
3701     CoUninitialize();
3702 }