dlls/msxml3/tests/domdoc.c

   1 /*
   2  * XML test
   3  *
   4  * Copyright 2005 Mike McCormack for CodeWeavers
   5  * Copyright 2007 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 <stdio.h>
  30 #include <assert.h>
  31
  32 #include "wine/test.h"
  33
  34 const CLSID CLSID_DOMDocument2 = {0xf6d90f11, 0x9c73, 0x11d3, {0xb3, 0x2e, 0x00, 0xc0, 0x4f, 0x99, 0x0b, 0xb4}};
  35 const IID IID_IXMLDOMDocument2 = {0x2933bf95, 0x7b36, 0x11d2, {0xb2, 0x0e, 0x00, 0xc0, 0x4f, 0x98, 0x3e, 0x60}};
  36
  37 static const WCHAR szEmpty[] = { 0 };
  38 static const WCHAR szIncomplete[] = {
  39     '<','?','x','m','l',' ',
  40     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
  41 };
  42 static const WCHAR szComplete1[] = {
  43     '<','?','x','m','l',' ',
  44     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
  45     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
  46 };
  47 static const WCHAR szComplete2[] = {
  48     '<','?','x','m','l',' ',
  49     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
  50     '<','o','>','<','/','o','>','\n',0
  51 };
  52 static const WCHAR szComplete3[] = {
  53     '<','?','x','m','l',' ',
  54     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
  55     '<','a','>','<','/','a','>','\n',0
  56 };
  57 static const WCHAR szComplete4[] = {
  58     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
  59     '<','l','c',' ','d','l','=','\'','s','t','r','1','\'','>','\n',
  60         '<','b','s',' ','v','r','=','\'','s','t','r','2','\'',' ','s','z','=','\'','1','2','3','4','\'','>',
  61             'f','n','1','.','t','x','t','\n',
  62         '<','/','b','s','>','\n',
  63         '<','p','r',' ','i','d','=','\'','s','t','r','3','\'',' ','v','r','=','\'','1','.','2','.','3','\'',' ',
  64                     'p','n','=','\'','w','i','n','e',' ','2','0','0','5','0','8','0','4','\'','>','\n',
  65             'f','n','2','.','t','x','t','\n',
  66         '<','/','p','r','>','\n',
  67         '<','e','m','p','t','y','>','<','/','e','m','p','t','y','>','\n',
  68         '<','f','o','>','\n',
  69             '<','b','a','>','\n',
  70                 'f','1','\n',
  71             '<','/','b','a','>','\n',
  72         '<','/','f','o','>','\n',
  73     '<','/','l','c','>','\n',0
  74 };
  75 static const WCHAR szComplete5[] = {
  76     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
  77     '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','"',
  78     ' ','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','"','>',
  79         '<','S',':','s','c','o','p','e','>',
  80             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
  81         '<','/','S',':','s','c','o','p','e','>',
  82         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
  83             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
  84             'c','o','m','p','u','t','e','r',
  85         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
  86     '<','/','S',':','s','e','a','r','c','h','>',0
  87 };
  88
  89 static const CHAR szExampleXML[] =
  90 "<?xml version='1.0' encoding='utf-8'?>\n"
  91 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
  92 "    <elem>\n"
  93 "        <a>A1 field</a>\n"
  94 "        <b>B1 field</b>\n"
  95 "        <c>C1 field</c>\n"
  96 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
  97 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
  98 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
  99 "            </html>\n"
 100 "        </description>\n"
 101 "    </elem>\n"
 102 "\n"
 103 "    <elem>\n"
 104 "        <a>A2 field</a>\n"
 105 "        <b>B2 field</b>\n"
 106 "        <c type=\"old\">C2 field</c>\n"
 107 "    </elem>\n"
 108 "\n"
 109 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
 110 "        <a>A3 field</a>\n"
 111 "        <b>B3 field</b>\n"
 112 "        <c>C3 field</c>\n"
 113 "    </elem>\n"
 114 "\n"
 115 "    <elem>\n"
 116 "        <a>A4 field</a>\n"
 117 "        <b>B4 field</b>\n"
 118 "        <foo:c>C4 field</foo:c>\n"
 119 "    </elem>\n"
 120 "</root>\n";
 121
 122 static const WCHAR szNonExistentFile[] = {
 123     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
 124 };
 125 static const WCHAR szDocument[] = {
 126     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
 127 };
 128
 129 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
 130 static WCHAR szdl[] = { 'd','l',0 };
 131 static const WCHAR szvr[] = { 'v','r',0 };
 132 static const WCHAR szlc[] = { 'l','c',0 };
 133 static WCHAR szbs[] = { 'b','s',0 };
 134 static const WCHAR szstr1[] = { 's','t','r','1',0 };
 135 static const WCHAR szstr2[] = { 's','t','r','2',0 };
 136 static const WCHAR szstar[] = { '*',0 };
 137 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
 138
 139 static WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
 140 static WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
 141 static WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
 142
 143 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
 144 static WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
 145 static WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
 146 static WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
 147                                 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
 148
 149 static WCHAR szAttribute[] = {'A','t','t','r',0 };
 150 static WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
 151
 152 static WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
 153                           ' ','n','o','t',' ','r','i','g','h','t','!', 0};
 154 static WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
 155                              'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
 156                              '!',']',']','>',0};
 157 static WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
 158 static WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
 159
 160 static WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
 161 static WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
 162
 163 #define expect_bstr_eq_and_free(bstr, expect) { \
 164     BSTR bstrExp = alloc_str_from_narrow(expect); \
 165     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
 166     SysFreeString(bstr); \
 167     SysFreeString(bstrExp); \
 168 }
 169
 170 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
 171
 172 #define ole_check(expr) { \
 173     HRESULT r = expr; \
 174     ok(r == S_OK, #expr " returned %x\n", r); \
 175 }
 176
 177 #define ole_expect(expr, expect) { \
 178     HRESULT r = expr; \
 179     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
 180 }
 181
 182 static BSTR alloc_str_from_narrow(const char *str)
 183 {
 184     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 185     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
 186     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 187     return ret;
 188 }
 189
 190 BSTR alloced_bstrs[256];
 191 int alloced_bstrs_count = 0;
 192
 193 static BSTR _bstr_(const char *str)
 194 {
 195     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
 196     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
 197     return alloced_bstrs[alloced_bstrs_count++];
 198 }
 199
 200 static void free_bstrs(void)
 201 {
 202     int i;
 203     for (i = 0; i < alloced_bstrs_count; i++)
 204         SysFreeString(alloced_bstrs[i]);
 205     alloced_bstrs_count = 0;
 206 }
 207
 208 static VARIANT _variantbstr_(const char *str)
 209 {
 210     VARIANT v;
 211     V_VT(&v) = VT_BSTR;
 212     V_BSTR(&v) = _bstr_(str);
 213     return v;
 214 }
 215
 216 static void get_str_for_type(DOMNodeType type, char *buf)
 217 {
 218     switch (type)
 219     {
 220         case NODE_ATTRIBUTE:
 221             strcpy(buf, "A");
 222             break;
 223         case NODE_ELEMENT:
 224             strcpy(buf, "E");
 225             break;
 226         case NODE_DOCUMENT:
 227             strcpy(buf, "D");
 228             break;
 229         default:
 230             wsprintfA(buf, "[%d]", type);
 231     }
 232 }
 233
 234 static int get_node_position(IXMLDOMNode *node)
 235 {
 236     HRESULT r;
 237     int pos = 0;
 238
 239     IXMLDOMNode_AddRef(node);
 240     do
 241     {
 242         IXMLDOMNode *new_node;
 243
 244         pos++;
 245         r = IXMLDOMNode_get_previousSibling(node, &new_node);
 246         ok(!FAILED(r), "get_previousSibling failed\n");
 247         IXMLDOMNode_Release(node);
 248         node = new_node;
 249     } while (r == S_OK);
 250     return pos;
 251 }
 252
 253 static void node_to_string(IXMLDOMNode *node, char *buf)
 254 {
 255     HRESULT r = S_OK;
 256     DOMNodeType type;
 257
 258     if (node == NULL)
 259     {
 260         lstrcpyA(buf, "(null)");
 261         return;
 262     }
 263
 264     IXMLDOMNode_AddRef(node);
 265     while (r == S_OK)
 266     {
 267         IXMLDOMNode *new_node;
 268
 269         ole_check(IXMLDOMNode_get_nodeType(node, &type));
 270         get_str_for_type(type, buf);
 271         buf+=strlen(buf);
 272
 273         if (type == NODE_ATTRIBUTE)
 274         {
 275             BSTR bstr;
 276             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
 277             *(buf++) = '\'';
 278             wsprintfA(buf, "%ws", bstr);
 279             buf += strlen(buf);
 280             *(buf++) = '\'';
 281             SysFreeString(bstr);
 282
 283             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
 284         }
 285         else
 286         {
 287             int pos = get_node_position(node);
 288             DOMNodeType parent_type = NODE_INVALID;
 289             r = IXMLDOMNode_get_parentNode(node, &new_node);
 290
 291             /* currently wine doesn't create a node for the <?xml ... ?>. To be able to test query
 292              * results we "fix" it */
 293             if (r == S_OK)
 294                 ole_check(IXMLDOMNode_get_nodeType(node, &parent_type));
 295             /* we need also to workaround the no document node problem - see below */
 296             if (((r == S_FALSE && type != NODE_DOCUMENT) || parent_type == NODE_DOCUMENT) && type != NODE_PROCESSING_INSTRUCTION && pos==1)
 297             {
 298                 todo_wine ok(FALSE, "The first child of the document node in MSXML is the <?xml ... ?> processing instruction\n");
 299                 pos++;
 300             }
 301             wsprintf(buf, "%d", pos);
 302             buf += strlen(buf);
 303         }
 304
 305         ok(!FAILED(r), "get_parentNode failed (%08x)\n", r);
 306         IXMLDOMNode_Release(node);
 307         node = new_node;
 308         if (r == S_OK)
 309             *(buf++) = '.';
 310     }
 311
 312     /* currently we can't access document node in wine. All our examples this is the
 313      * root node so to be able to test query results we add it */
 314     if (type != NODE_DOCUMENT)
 315     {
 316         todo_wine ok(FALSE, "Document node is not the last returned node!\n");
 317         *(buf++) = '.';
 318         *(buf++) = 'D';
 319         *(buf++) = '1';
 320     }
 321     *buf = 0;
 322 }
 323
 324 static char *list_to_string(IXMLDOMNodeList *list)
 325 {
 326     static char buf[4096];
 327     char *pos = buf;
 328     long len = 0;
 329     int i;
 330
 331     if (list == NULL)
 332     {
 333         lstrcpyA(buf, "(null)");
 334         return buf;
 335     }
 336     ole_check(IXMLDOMNodeList_get_length(list, &len));
 337     for (i = 0; i < len; i++)
 338     {
 339         IXMLDOMNode *node;
 340         if (i > 0)
 341             *(pos++) = ' ';
 342         ole_check(IXMLDOMNodeList_nextNode(list, &node));
 343         node_to_string(node, pos);
 344         pos += strlen(pos);
 345         IXMLDOMNode_Release(node);
 346     }
 347     *pos = 0;
 348     return buf;
 349 }
 350
 351 #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); }
 352 #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); }
 353
 354 static void test_domdoc( void )
 355 {
 356     HRESULT r;
 357     IXMLDOMDocument *doc = NULL;
 358     IXMLDOMParseError *error;
 359     IXMLDOMElement *element = NULL;
 360     IXMLDOMNode *node;
 361     IXMLDOMText *nodetext = NULL;
 362     IXMLDOMComment *node_comment = NULL;
 363     IXMLDOMAttribute *node_attr = NULL;
 364     IXMLDOMNode *nodeChild = NULL;
 365     IXMLDOMProcessingInstruction *nodePI = NULL;
 366     VARIANT_BOOL b;
 367     VARIANT var;
 368     BSTR str;
 369     long code;
 370     long nLength = 0;
 371
 372     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
 373         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
 374     if( r != S_OK )
 375         return;
 376
 377     /* try some stupid things */
 378     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
 379     ok( r == S_FALSE, "loadXML failed\n");
 380
 381     b = VARIANT_TRUE;
 382     r = IXMLDOMDocument_loadXML( doc, NULL, &b );
 383     ok( r == S_FALSE, "loadXML failed\n");
 384     ok( b == VARIANT_FALSE, "failed to load XML string\n");
 385
 386     /* try to load a document from a nonexistent file */
 387     b = VARIANT_TRUE;
 388     str = SysAllocString( szNonExistentFile );
 389     VariantInit(&var);
 390     V_VT(&var) = VT_BSTR;
 391     V_BSTR(&var) = str;
 392
 393     r = IXMLDOMDocument_load( doc, var, &b);
 394     ok( r == S_FALSE, "load (from file) failed\n");
 395     ok( b == VARIANT_FALSE, "failed to load XML file\n");
 396     SysFreeString( str );
 397
 398     /* try load an empty document */
 399     b = VARIANT_TRUE;
 400     str = SysAllocString( szEmpty );
 401     r = IXMLDOMDocument_loadXML( doc, str, &b );
 402     ok( r == S_FALSE, "loadXML failed\n");
 403     ok( b == VARIANT_FALSE, "failed to load XML string\n");
 404     SysFreeString( str );
 405
 406     /* check that there's no document element */
 407     element = NULL;
 408     r = IXMLDOMDocument_get_documentElement( doc, &element );
 409     ok( r == S_FALSE, "should be no document element\n");
 410
 411     /* try finding a node */
 412     node = NULL;
 413     str = SysAllocString( szstr1 );
 414     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
 415     ok( r == S_FALSE, "ret %08x\n", r );
 416     SysFreeString( str );
 417
 418     b = VARIANT_TRUE;
 419     str = SysAllocString( szIncomplete );
 420     r = IXMLDOMDocument_loadXML( doc, str, &b );
 421     ok( r == S_FALSE, "loadXML failed\n");
 422     ok( b == VARIANT_FALSE, "failed to load XML string\n");
 423     SysFreeString( str );
 424
 425     /* check that there's no document element */
 426     element = (IXMLDOMElement*)1;
 427     r = IXMLDOMDocument_get_documentElement( doc, &element );
 428     ok( r == S_FALSE, "should be no document element\n");
 429     ok( element == NULL, "Element should be NULL\n");
 430
 431     /* try to load something valid */
 432     b = VARIANT_FALSE;
 433     str = SysAllocString( szComplete1 );
 434     r = IXMLDOMDocument_loadXML( doc, str, &b );
 435     ok( r == S_OK, "loadXML failed\n");
 436     ok( b == VARIANT_TRUE, "failed to load XML string\n");
 437     SysFreeString( str );
 438
 439     /* try with a null out pointer */
 440     r = IXMLDOMDocument_get_documentElement( doc, NULL );
 441     ok( r == E_INVALIDARG, "should be no document element\n");
 442
 443     /* check if nodename is correct */
 444     r = IXMLDOMDocument_get_nodeName( doc, NULL );
 445     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
 446
 447     /* content doesn't matter here */
 448     str = NULL;
 449     r = IXMLDOMDocument_get_nodeName( doc, &str );
 450     ok ( r == S_OK, "get_nodeName wrong code\n");
 451     ok ( str != NULL, "str is null\n");
 452     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
 453     SysFreeString( str );
 454
 455     /* test put_text */
 456     r = IXMLDOMDocument_put_text( doc, _bstr_("Should Fail") );
 457     ok( r == E_FAIL, "ret %08x\n", r );
 458
 459     /* check that there's a document element */
 460     element = NULL;
 461     r = IXMLDOMDocument_get_documentElement( doc, &element );
 462     ok( r == S_OK, "should be a document element\n");
 463     if( element )
 464     {
 465         BSTR tag = NULL;
 466
 467         /* check if the tag is correct */
 468         r = IXMLDOMElement_get_tagName( element, &tag );
 469         ok( r == S_OK, "couldn't get tag name\n");
 470         ok( tag != NULL, "tag was null\n");
 471         ok( !lstrcmpW( tag, szOpen ), "incorrect tag name\n");
 472         SysFreeString( tag );
 473
 474         /* figure out what happens if we try to reload the document */
 475         str = SysAllocString( szComplete2 );
 476         r = IXMLDOMDocument_loadXML( doc, str, &b );
 477         ok( r == S_OK, "loadXML failed\n");
 478         ok( b == VARIANT_TRUE, "failed to load XML string\n");
 479         SysFreeString( str );
 480
 481         /* check if the tag is still correct */
 482         tag = NULL;
 483         r = IXMLDOMElement_get_tagName( element, &tag );
 484         ok( r == S_OK, "couldn't get tag name\n");
 485         ok( tag != NULL, "tag was null\n");
 486         ok( !lstrcmpW( tag, szOpen ), "incorrect tag name\n");
 487         SysFreeString( tag );
 488
 489         IXMLDOMElement_Release( element );
 490         element = NULL;
 491     }
 492
 493     /* as soon as we call loadXML again, the document element will disappear */
 494     b = 2;
 495     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
 496     ok( r == S_FALSE, "loadXML failed\n");
 497     ok( b == 2, "variant modified\n");
 498     r = IXMLDOMDocument_get_documentElement( doc, &element );
 499     ok( r == S_FALSE, "should be no document element\n");
 500
 501     /* try to load something else simple and valid */
 502     b = VARIANT_FALSE;
 503     str = SysAllocString( szComplete3 );
 504     r = IXMLDOMDocument_loadXML( doc, str, &b );
 505     ok( r == S_OK, "loadXML failed\n");
 506     ok( b == VARIANT_TRUE, "failed to load XML string\n");
 507     SysFreeString( str );
 508
 509     /* try something a little more complicated */
 510     b = FALSE;
 511     str = SysAllocString( szComplete4 );
 512     r = IXMLDOMDocument_loadXML( doc, str, &b );
 513     ok( r == S_OK, "loadXML failed\n");
 514     ok( b == VARIANT_TRUE, "failed to load XML string\n");
 515     SysFreeString( str );
 516
 517     r = IXMLDOMDocument_get_parseError( doc, &error );
 518     ok( r == S_OK, "returns %08x\n", r );
 519
 520     r = IXMLDOMParseError_get_errorCode( error, &code );
 521     ok( r == S_FALSE, "returns %08x\n", r );
 522     ok( code == 0, "code %ld\n", code );
 523     IXMLDOMParseError_Release( error );
 524
 525      /* test createTextNode */
 526     str = SysAllocString( szOpen );
 527     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
 528     ok( r == E_INVALIDARG, "returns %08x\n", r );
 529     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
 530     ok( r == S_OK, "returns %08x\n", r );
 531     if(nodetext)
 532     {
 533         IXMLDOMNamedNodeMap *pAttribs;
 534
 535         /* Text Last Child Checks */
 536         r = IXMLDOMText_get_lastChild(nodetext, NULL);
 537         ok(r == E_INVALIDARG, "ret %08x\n", r );
 538
 539         nodeChild = (IXMLDOMNode*)0x1;
 540         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
 541         ok(r == S_FALSE, "ret %08x\n", r );
 542         ok(nodeChild == NULL, "nodeChild not NULL\n");
 543
 544         /* test get_attributes */
 545         r = IXMLDOMText_get_attributes( nodetext, NULL );
 546         ok( r == E_INVALIDARG, "get_attributes returned wrong code\n");
 547
 548         pAttribs = (IXMLDOMNamedNodeMap*)0x1;
 549         r = IXMLDOMText_get_attributes( nodetext, &pAttribs);
 550         ok(r == S_FALSE, "ret %08x\n", r );
 551         ok( pAttribs == NULL, "pAttribs not NULL\n");
 552
 553         /* test get_dataType */
 554         r = IXMLDOMText_get_dataType(nodetext, &var);
 555         ok(r == S_FALSE, "ret %08x\n", r );
 556         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
 557         VariantClear(&var);
 558
 559         /* test length property */
 560         r = IXMLDOMText_get_length(nodetext, NULL);
 561         ok(r == E_INVALIDARG, "ret %08x\n", r );
 562
 563         r = IXMLDOMText_get_length(nodetext, &nLength);
 564         ok(r == S_OK, "ret %08x\n", r );
 565         ok(nLength == 4, "expected 4 got %ld\n", nLength);
 566
 567         /* test nodeTypeString */
 568         r = IXMLDOMText_get_nodeTypeString(nodetext, &str);
 569         ok(r == S_OK, "ret %08x\n", r );
 570         ok( !lstrcmpW( str, _bstr_("text") ), "incorrect nodeTypeString string\n");
 571         SysFreeString(str);
 572
 573         /* put data Tests */
 574         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
 575         ok(r == S_OK, "ret %08x\n", r );
 576
 577         /* get data Tests */
 578         r = IXMLDOMText_get_data(nodetext, &str);
 579         ok(r == S_OK, "ret %08x\n", r );
 580         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
 581         SysFreeString(str);
 582
 583         /* Confirm XML text is good */
 584         r = IXMLDOMText_get_xml(nodetext, &str);
 585         ok(r == S_OK, "ret %08x\n", r );
 586         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
 587         SysFreeString(str);
 588
 589         /* Confirm we get the put_data Text back */
 590         r = IXMLDOMText_get_text(nodetext, &str);
 591         ok(r == S_OK, "ret %08x\n", r );
 592         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
 593         SysFreeString(str);
 594
 595         IXMLDOMText_Release( nodetext );
 596     }
 597     SysFreeString( str );
 598
 599     /* test Create Comment */
 600     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
 601     ok( r == E_INVALIDARG, "returns %08x\n", r );
 602     r = IXMLDOMDocument_createComment(doc, szComment, &node_comment);
 603     ok( r == S_OK, "returns %08x\n", r );
 604     if(node_comment)
 605     {
 606         /* Last Child Checks */
 607         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
 608         ok(r == E_INVALIDARG, "ret %08x\n", r );
 609
 610         nodeChild = (IXMLDOMNode*)0x1;
 611         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
 612         ok(r == S_FALSE, "ret %08x\n", r );
 613         ok(nodeChild == NULL, "pLastChild not NULL\n");
 614
 615         IXMLDOMComment_Release( node_comment );
 616     }
 617
 618     /* test Create Attribute */
 619     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
 620     ok( r == E_INVALIDARG, "returns %08x\n", r );
 621     r = IXMLDOMDocument_createAttribute(doc, szAttribute, &node_attr);
 622     ok( r == S_OK, "returns %08x\n", r );
 623     IXMLDOMText_Release( node_attr);
 624
 625     /* test Processing Instruction */
 626     str = SysAllocStringLen(NULL, 0);
 627     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
 628     ok( r == E_INVALIDARG, "returns %08x\n", r );
 629     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
 630     ok( r == E_FAIL, "returns %08x\n", r );
 631     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
 632     ok( r == E_FAIL, "returns %08x\n", r );
 633     SysFreeString(str);
 634
 635     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
 636     ok( r == S_OK, "returns %08x\n", r );
 637     if(nodePI)
 638     {
 639         /* Last Child Checks */
 640         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
 641         ok(r == E_INVALIDARG, "ret %08x\n", r );
 642
 643         nodeChild = (IXMLDOMNode*)0x1;
 644         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
 645         ok(r == S_FALSE, "ret %08x\n", r );
 646         ok(nodeChild == NULL, "nodeChild not NULL\n");
 647
 648         r = IXMLDOMProcessingInstruction_get_dataType(nodePI, &var);
 649         ok(r == S_FALSE, "ret %08x\n", r );
 650         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
 651         VariantClear(&var);
 652
 653         /* test nodeName */
 654         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
 655         ok(r == S_OK, "ret %08x\n", r );
 656         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
 657         SysFreeString(str);
 658
 659         /* test Target */
 660         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
 661         ok(r == S_OK, "ret %08x\n", r );
 662         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
 663         SysFreeString(str);
 664
 665         /* test nodeTypeString */
 666         r = IXMLDOMProcessingInstruction_get_nodeTypeString(nodePI, &str);
 667         ok(r == S_OK, "ret %08x\n", r );
 668         ok( !lstrcmpW( str, _bstr_("processinginstruction") ), "incorrect nodeTypeString string\n");
 669         SysFreeString(str);
 670
 671         /* test get_nodeValue */
 672         r = IXMLDOMProcessingInstruction_get_nodeValue(nodePI, &var);
 673         ok(r == S_OK, "ret %08x\n", r );
 674         ok( !lstrcmpW( V_BSTR(&var), _bstr_("version=\"1.0\"") ), "incorrect data string\n");
 675         VariantClear(&var);
 676
 677         /* test get_data */
 678         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
 679         ok(r == S_OK, "ret %08x\n", r );
 680         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
 681         SysFreeString(str);
 682
 683         /* test put_data */
 684         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
 685         ok(r == S_OK, "ret %08x\n", r );
 686         SysFreeString(str);
 687
 688         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
 689         ok(r == S_OK, "ret %08x\n", r );
 690         ok( !lstrcmpW( str, _bstr_("version=\"1.0\" encoding=\"UTF-8\"") ), "incorrect data string\n");
 691         SysFreeString(str);
 692
 693         /* Confirm XML text is good */
 694         r = IXMLDOMProcessingInstruction_get_xml(nodePI, &str);
 695         ok(r == S_OK, "ret %08x\n", r );
 696         ok( !lstrcmpW( str, _bstr_("<?xml version=\"1.0\" encoding=\"UTF-8\"?>") ), "incorrect xml string\n");
 697         SysFreeString(str);
 698
 699         IXMLDOMProcessingInstruction_Release(nodePI);
 700     }
 701
 702     r = IXMLDOMDocument_Release( doc );
 703     ok( r == 0, "document ref count incorrect\n");
 704
 705     free_bstrs();
 706 }
 707
 708 static void test_domnode( void )
 709 {
 710     HRESULT r;
 711     IXMLDOMDocument *doc = NULL, *owner = NULL;
 712     IXMLDOMElement *element = NULL;
 713     IXMLDOMNamedNodeMap *map = NULL;
 714     IXMLDOMNode *node = NULL, *next = NULL;
 715     IXMLDOMNodeList *list = NULL;
 716     DOMNodeType type = NODE_INVALID;
 717     VARIANT_BOOL b;
 718     BSTR str;
 719     VARIANT var;
 720     long count;
 721
 722     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
 723         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
 724     if( r != S_OK )
 725         return;
 726
 727     b = FALSE;
 728     str = SysAllocString( szComplete4 );
 729     r = IXMLDOMDocument_loadXML( doc, str, &b );
 730     ok( r == S_OK, "loadXML failed\n");
 731     ok( b == VARIANT_TRUE, "failed to load XML string\n");
 732     SysFreeString( str );
 733
 734     if (doc)
 735     {
 736         b = 1;
 737         r = IXMLDOMNode_hasChildNodes( doc, &b );
 738         ok( r == S_OK, "hasChildNoes bad return\n");
 739         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
 740
 741         r = IXMLDOMDocument_get_documentElement( doc, &element );
 742         ok( r == S_OK, "should be a document element\n");
 743         ok( element != NULL, "should be an element\n");
 744     }
 745     else
 746         ok( FALSE, "no document\n");
 747
 748     VariantInit(&var);
 749     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
 750
 751     r = IXMLDOMNode_get_nodeValue( doc, NULL );
 752     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
 753
 754     r = IXMLDOMNode_get_nodeValue( doc, &var );
 755     ok( r == S_FALSE, "nextNode returned wrong code\n");
 756     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
 757     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
 758
 759     if (element)
 760     {
 761         owner = NULL;
 762         r = IXMLDOMNode_get_ownerDocument( element, &owner );
 763         todo_wine {
 764         ok( r == S_OK, "get_ownerDocument return code\n");
 765         }
 766         ok( owner != doc, "get_ownerDocument return\n");
 767
 768         type = NODE_INVALID;
 769         r = IXMLDOMNode_get_nodeType( element, &type);
 770         ok( r == S_OK, "getNamedItem returned wrong code\n");
 771         ok( type == NODE_ELEMENT, "node not an element\n");
 772
 773         str = NULL;
 774         r = IXMLDOMNode_get_baseName( element, &str );
 775         ok( r == S_OK, "get_baseName returned wrong code\n");
 776         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
 777         SysFreeString(str);
 778
 779         /* check if nodename is correct */
 780         r = IXMLDOMElement_get_nodeName( element, NULL );
 781         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
 782
 783         /* content doesn't matter here */
 784         str = NULL;
 785         r = IXMLDOMElement_get_nodeName( element, &str );
 786         ok ( r == S_OK, "get_nodeName wrong code\n");
 787         ok ( str != NULL, "str is null\n");
 788         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
 789         SysFreeString( str );
 790
 791         str = SysAllocString( szNonExistentFile );
 792         V_VT(&var) = VT_I4;
 793         V_I4(&var) = 0x1234;
 794         r = IXMLDOMElement_getAttribute( element, str, &var );
 795         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
 796         ok( V_VT(&var) == VT_NULL, "vt = %x\n", V_VT(&var));
 797         VariantClear(&var);
 798         SysFreeString( str );
 799
 800         str = SysAllocString( szdl );
 801         V_VT(&var) = VT_I4;
 802         V_I4(&var) = 0x1234;
 803         r = IXMLDOMElement_getAttribute( element, str, &var );
 804         ok( r == S_OK, "getAttribute ret %08x\n", r );
 805         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
 806         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
 807         VariantClear( &var );
 808
 809         r = IXMLDOMElement_getAttribute( element, NULL, &var );
 810         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
 811
 812         r = IXMLDOMElement_getAttribute( element, str, NULL );
 813         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
 814
 815         SysFreeString( str );
 816
 817         r = IXMLDOMElement_get_attributes( element, &map );
 818         ok( r == S_OK, "get_attributes returned wrong code\n");
 819         ok( map != NULL, "should be attributes\n");
 820
 821         b = 1;
 822         r = IXMLDOMNode_hasChildNodes( element, &b );
 823         ok( r == S_OK, "hasChildNoes bad return\n");
 824         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
 825     }
 826     else
 827         ok( FALSE, "no element\n");
 828
 829     if (map)
 830     {
 831         ISupportErrorInfo *support_error;
 832         r = IXMLDOMNamedNodeMap_QueryInterface( map, &IID_ISupportErrorInfo, (LPVOID*)&support_error );
 833         ok( r == S_OK, "ret %08x\n", r );
 834
 835         r = ISupportErrorInfo_InterfaceSupportsErrorInfo( support_error, &IID_IXMLDOMNamedNodeMap );
 836 todo_wine
 837 {
 838         ok( r == S_OK, "ret %08x\n", r );
 839 }
 840         ISupportErrorInfo_Release( support_error );
 841
 842         str = SysAllocString( szdl );
 843         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
 844         ok( r == S_OK, "getNamedItem returned wrong code\n");
 845         ok( node != NULL, "should be attributes\n");
 846         IXMLDOMNode_Release(node);
 847         SysFreeString( str );
 848
 849         str = SysAllocString( szdl );
 850         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
 851         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
 852         SysFreeString( str );
 853
 854         /* something that isn't in szComplete4 */
 855         str = SysAllocString( szOpen );
 856         node = (IXMLDOMNode *) 1;
 857         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
 858         ok( r = S_FALSE, "getNamedItem found a node that wasn't there\n");
 859         ok( node == NULL, "getNamedItem should have returned NULL\n");
 860         SysFreeString( str );
 861
 862         /* test indexed access of attributes */
 863         r = IXMLDOMNamedNodeMap_get_length( map, &count );
 864         ok ( r == S_OK, "get_length wrong code\n");
 865         ok ( count == 1, "get_length != 1\n");
 866
 867         node = NULL;
 868         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
 869         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
 870         ok ( node == NULL, "there is no node\n");
 871
 872         node = NULL;
 873         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
 874         ok ( r == S_FALSE, "get_item (1) wrong code\n");
 875         ok ( node == NULL, "there is no attribute\n");
 876
 877         node = NULL;
 878         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
 879         ok ( r == S_OK, "get_item (0) wrong code\n");
 880         ok ( node != NULL, "should be attribute\n");
 881
 882         r = IXMLDOMNode_get_nodeName( node, NULL );
 883         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
 884
 885         /* content doesn't matter here */
 886         str = NULL;
 887         r = IXMLDOMNode_get_nodeName( node, &str );
 888         ok ( r == S_OK, "get_nodeName wrong code\n");
 889         ok ( str != NULL, "str is null\n");
 890         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
 891         SysFreeString( str );
 892
 893         /* test sequential access of attributes */
 894         node = NULL;
 895         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
 896         ok ( r == S_OK, "nextNode (first time) wrong code\n");
 897         ok ( node != NULL, "nextNode, should be attribute\n");
 898
 899         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
 900         ok ( r != S_OK, "nextNode (second time) wrong code\n");
 901         ok ( node == NULL, "nextNode, there is no attribute\n");
 902
 903         r = IXMLDOMNamedNodeMap_reset( map );
 904         ok ( r == S_OK, "reset should return S_OK\n");
 905
 906         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
 907         ok ( r == S_OK, "nextNode (third time) wrong code\n");
 908         ok ( node != NULL, "nextNode, should be attribute\n");
 909     }
 910     else
 911         ok( FALSE, "no map\n");
 912
 913     if (node)
 914     {
 915         type = NODE_INVALID;
 916         r = IXMLDOMNode_get_nodeType( node, &type);
 917         ok( r == S_OK, "getNamedItem returned wrong code\n");
 918         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
 919
 920         str = NULL;
 921         r = IXMLDOMNode_get_baseName( node, NULL );
 922         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
 923
 924         str = NULL;
 925         r = IXMLDOMNode_get_baseName( node, &str );
 926         ok( r == S_OK, "get_baseName returned wrong code\n");
 927         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
 928         SysFreeString( str );
 929
 930         r = IXMLDOMNode_get_nodeValue( node, &var );
 931         ok( r == S_OK, "returns %08x\n", r );
 932         ok( V_VT(&var) == VT_BSTR, "vt %x\n", V_VT(&var));
 933         ok( !lstrcmpW(V_BSTR(&var), szstr1), "nodeValue incorrect\n");
 934         VariantClear(&var);
 935
 936         r = IXMLDOMNode_get_childNodes( node, NULL );
 937         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
 938
 939         r = IXMLDOMNode_get_childNodes( node, &list );
 940         ok( r == S_OK, "get_childNodes returned wrong code\n");
 941
 942         if (list)
 943         {
 944             r = IXMLDOMNodeList_nextNode( list, &next );
 945             ok( r == S_OK, "nextNode returned wrong code\n");
 946         }
 947         else
 948             ok( FALSE, "no childlist\n");
 949
 950         if (next)
 951         {
 952             b = 1;
 953             r = IXMLDOMNode_hasChildNodes( next, &b );
 954             ok( r == S_FALSE, "hasChildNoes bad return\n");
 955             ok( b == VARIANT_FALSE, "hasChildNoes wrong result\n");
 956
 957             type = NODE_INVALID;
 958             r = IXMLDOMNode_get_nodeType( next, &type);
 959             ok( r == S_OK, "getNamedItem returned wrong code\n");
 960             ok( type == NODE_TEXT, "node not text\n");
 961
 962             str = (BSTR) 1;
 963             r = IXMLDOMNode_get_baseName( next, &str );
 964             ok( r == S_FALSE, "get_baseName returned wrong code\n");
 965             ok( str == NULL, "basename was wrong\n");
 966             SysFreeString(str);
 967         }
 968         else
 969             ok( FALSE, "no next\n");
 970
 971         if (next)
 972             IXMLDOMNode_Release( next );
 973         next = NULL;
 974         if (list)
 975             IXMLDOMNodeList_Release( list );
 976         list = NULL;
 977         if (node)
 978             IXMLDOMNode_Release( node );
 979     }
 980     else
 981         ok( FALSE, "no node\n");
 982     node = NULL;
 983
 984     if (map)
 985         IXMLDOMNamedNodeMap_Release( map );
 986
 987     /* now traverse the tree from the root element */
 988     if (element)
 989     {
 990         IXMLDOMNode *node;
 991         r = IXMLDOMNode_get_childNodes( element, &list );
 992         ok( r == S_OK, "get_childNodes returned wrong code\n");
 993
 994         /* using get_item for child list doesn't advance the position */
 995         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
 996         expect_node(node, "E2.E2.D1");
 997         IXMLDOMNode_Release(node);
 998         ole_check(IXMLDOMNodeList_nextNode(list, &node));
 999         expect_node(node, "E1.E2.D1");
1000         IXMLDOMNode_Release(node);
1001         ole_check(IXMLDOMNodeList_reset(list));
1002
1003         IXMLDOMNodeList_AddRef(list);
1004         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
1005         ole_check(IXMLDOMNodeList_reset(list));
1006     }
1007     else
1008         ok( FALSE, "no element\n");
1009
1010     node = (void*)0xdeadbeef;
1011     r = IXMLDOMNode_selectSingleNode( element, szdl, &node );
1012     ok( r == S_FALSE, "ret %08x\n", r );
1013     ok( node == NULL, "node %p\n", node );
1014     r = IXMLDOMNode_selectSingleNode( element, szbs, &node );
1015     ok( r == S_OK, "ret %08x\n", r );
1016     r = IXMLDOMNode_Release( node );
1017     ok( r == 0, "ret %08x\n", r );
1018
1019     if (list)
1020     {
1021         r = IXMLDOMNodeList_get_length( list, &count );
1022         ok( r == S_OK, "get_length returns %08x\n", r );
1023         ok( count == 4, "get_length got %ld\n", count );
1024
1025         r = IXMLDOMNodeList_nextNode( list, &node );
1026         ok( r == S_OK, "nextNode returned wrong code\n");
1027     }
1028     else
1029         ok( FALSE, "no list\n");
1030
1031     if (node)
1032     {
1033         type = NODE_INVALID;
1034         r = IXMLDOMNode_get_nodeType( node, &type);
1035         ok( r == S_OK, "getNamedItem returned wrong code\n");
1036         ok( type == NODE_ELEMENT, "node not text\n");
1037
1038         VariantInit(&var);
1039         ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
1040         r = IXMLDOMNode_get_nodeValue( node, &var );
1041         ok( r == S_FALSE, "nextNode returned wrong code\n");
1042         ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
1043         ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
1044
1045         r = IXMLDOMNode_hasChildNodes( node, NULL );
1046         ok( r == E_INVALIDARG, "hasChildNoes bad return\n");
1047
1048         b = 1;
1049         r = IXMLDOMNode_hasChildNodes( node, &b );
1050         ok( r == S_OK, "hasChildNoes bad return\n");
1051         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
1052
1053         str = NULL;
1054         r = IXMLDOMNode_get_baseName( node, &str );
1055         ok( r == S_OK, "get_baseName returned wrong code\n");
1056         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
1057         SysFreeString(str);
1058     }
1059     else
1060         ok( FALSE, "no node\n");
1061
1062     if (node)
1063         IXMLDOMNode_Release( node );
1064     if (list)
1065         IXMLDOMNodeList_Release( list );
1066     if (element)
1067         IXMLDOMElement_Release( element );
1068
1069     b = FALSE;
1070     str = SysAllocString( szComplete5 );
1071     r = IXMLDOMDocument_loadXML( doc, str, &b );
1072     ok( r == S_OK, "loadXML failed\n");
1073     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1074     SysFreeString( str );
1075
1076     b = 1;
1077     r = IXMLDOMNode_hasChildNodes( doc, &b );
1078     ok( r == S_OK, "hasChildNoes bad return\n");
1079     ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
1080
1081     r = IXMLDOMDocument_get_documentElement( doc, &element );
1082     ok( r == S_OK, "should be a document element\n");
1083     ok( element != NULL, "should be an element\n");
1084
1085     if (element)
1086     {
1087         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
1088         BSTR tag = NULL;
1089
1090         /* check if the tag is correct */
1091         r = IXMLDOMElement_get_tagName( element, &tag );
1092         ok( r == S_OK, "couldn't get tag name\n");
1093         ok( tag != NULL, "tag was null\n");
1094         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
1095         SysFreeString( tag );
1096     }
1097
1098     if (element)
1099         IXMLDOMElement_Release( element );
1100     if (doc)
1101         IXMLDOMDocument_Release( doc );
1102 }
1103
1104 static void test_refs(void)
1105 {
1106     HRESULT r;
1107     BSTR str;
1108     VARIANT_BOOL b;
1109     IXMLDOMDocument *doc = NULL;
1110     IXMLDOMElement *element = NULL;
1111     IXMLDOMNode *node = NULL, *node2;
1112     IXMLDOMNodeList *node_list = NULL;
1113     LONG ref;
1114     IUnknown *unk, *unk2;
1115
1116     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1117         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1118     if( r != S_OK )
1119         return;
1120     ref = IXMLDOMDocument_Release(doc);
1121     ok( ref == 0, "ref %d\n", ref);
1122
1123     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1124         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1125     if( r != S_OK )
1126         return;
1127
1128     str = SysAllocString( szComplete4 );
1129     r = IXMLDOMDocument_loadXML( doc, str, &b );
1130     ok( r == S_OK, "loadXML failed\n");
1131     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1132     SysFreeString( str );
1133
1134     ref = IXMLDOMDocument_AddRef( doc );
1135     ok( ref == 2, "ref %d\n", ref );
1136     ref = IXMLDOMDocument_AddRef( doc );
1137     ok( ref == 3, "ref %d\n", ref );
1138     IXMLDOMDocument_Release( doc );
1139     IXMLDOMDocument_Release( doc );
1140
1141     r = IXMLDOMDocument_get_documentElement( doc, &element );
1142     ok( r == S_OK, "should be a document element\n");
1143     ok( element != NULL, "should be an element\n");
1144
1145     ref = IXMLDOMDocument_AddRef( doc );
1146     ok( ref == 2, "ref %d\n", ref );
1147     IXMLDOMDocument_Release( doc );
1148
1149     r = IXMLDOMElement_get_childNodes( element, &node_list );
1150     ok( r == S_OK, "rets %08x\n", r);
1151     ref = IXMLDOMNodeList_AddRef( node_list );
1152     ok( ref == 2, "ref %d\n", ref );
1153     IXMLDOMNodeList_Release( node_list );
1154
1155     IXMLDOMNodeList_get_item( node_list, 0, &node );
1156     ok( r == S_OK, "rets %08x\n", r);
1157
1158     IXMLDOMNodeList_get_item( node_list, 0, &node2 );
1159     ok( r == S_OK, "rets %08x\n", r);
1160
1161     ref = IXMLDOMNode_AddRef( node );
1162     ok( ref == 2, "ref %d\n", ref );
1163     IXMLDOMNode_Release( node );
1164
1165     ref = IXMLDOMNode_Release( node );
1166     ok( ref == 0, "ref %d\n", ref );
1167     ref = IXMLDOMNode_Release( node2 );
1168     ok( ref == 0, "ref %d\n", ref );
1169
1170     ref = IXMLDOMNodeList_Release( node_list );
1171     ok( ref == 0, "ref %d\n", ref );
1172
1173     ok( node != node2, "node %p node2 %p\n", node, node2 );
1174
1175     ref = IXMLDOMDocument_Release( doc );
1176     ok( ref == 0, "ref %d\n", ref );
1177
1178     ref = IXMLDOMElement_AddRef( element );
1179     todo_wine {
1180     ok( ref == 3, "ref %d\n", ref );
1181     }
1182     IXMLDOMElement_Release( element );
1183
1184     /* IUnknown must be unique however we obtain it */
1185     r = IXMLDOMElement_QueryInterface( element, &IID_IUnknown, (LPVOID*)&unk );
1186     ok( r == S_OK, "rets %08x\n", r );
1187     r = IXMLDOMElement_QueryInterface( element, &IID_IXMLDOMNode, (LPVOID*)&node );
1188     ok( r == S_OK, "rets %08x\n", r );
1189     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (LPVOID*)&unk2 );
1190     ok( r == S_OK, "rets %08x\n", r );
1191     ok( unk == unk2, "unk %p unk2 %p\n", unk, unk2 );
1192
1193     IUnknown_Release( unk2 );
1194     IUnknown_Release( unk );
1195     IXMLDOMNode_Release( node );
1196
1197     IXMLDOMElement_Release( element );
1198
1199 }
1200
1201 static void test_create(void)
1202 {
1203     HRESULT r;
1204     VARIANT var;
1205     BSTR str, name;
1206     IXMLDOMDocument *doc;
1207     IXMLDOMElement *element;
1208     IXMLDOMNode *root, *node, *child;
1209     IXMLDOMNamedNodeMap *attr_map;
1210     IUnknown *unk;
1211     LONG ref;
1212     long num;
1213
1214     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1215         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1216     if( r != S_OK )
1217         return;
1218
1219     V_VT(&var) = VT_I4;
1220     V_I4(&var) = NODE_ELEMENT;
1221     str = SysAllocString( szlc );
1222     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1223     ok( r == S_OK, "returns %08x\n", r );
1224     r = IXMLDOMDocument_appendChild( doc, node, &root );
1225     ok( r == S_OK, "returns %08x\n", r );
1226     ok( node == root, "%p %p\n", node, root );
1227
1228     ref = IXMLDOMNode_AddRef( node );
1229     ok(ref == 3, "ref %d\n", ref);
1230     IXMLDOMNode_Release( node );
1231
1232     ref = IXMLDOMNode_Release( node );
1233     ok(ref == 1, "ref %d\n", ref);
1234     SysFreeString( str );
1235
1236     V_VT(&var) = VT_I4;
1237     V_I4(&var) = NODE_ELEMENT;
1238     str = SysAllocString( szbs );
1239     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1240     ok( r == S_OK, "returns %08x\n", r );
1241
1242     ref = IXMLDOMNode_AddRef( node );
1243     ok(ref == 2, "ref = %d\n", ref);
1244     IXMLDOMNode_Release( node );
1245
1246     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (LPVOID*)&unk );
1247     ok( r == S_OK, "returns %08x\n", r );
1248
1249     ref = IXMLDOMNode_AddRef( unk );
1250     ok(ref == 3, "ref = %d\n", ref);
1251     IXMLDOMNode_Release( unk );
1252
1253     V_VT(&var) = VT_EMPTY;
1254     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
1255     ok( r == S_OK, "returns %08x\n", r );
1256     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
1257     IXMLDOMNode_Release( child );
1258     IUnknown_Release( unk );
1259
1260
1261     V_VT(&var) = VT_NULL;
1262     V_DISPATCH(&var) = (IDispatch*)node;
1263     r = IXMLDOMNode_insertBefore( root, node, var, &child );
1264     ok( r == S_OK, "returns %08x\n", r );
1265     ok( node == child, "%p %p\n", node, child );
1266     IXMLDOMNode_Release( child );
1267
1268
1269     V_VT(&var) = VT_NULL;
1270     V_DISPATCH(&var) = (IDispatch*)node;
1271     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
1272     ok( r == S_OK, "returns %08x\n", r );
1273     IXMLDOMNode_Release( node );
1274
1275     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (LPVOID*)&element );
1276     ok( r == S_OK, "returns %08x\n", r );
1277
1278     r = IXMLDOMElement_get_attributes( element, &attr_map );
1279     ok( r == S_OK, "returns %08x\n", r );
1280     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1281     ok( r == S_OK, "returns %08x\n", r );
1282     ok( num == 0, "num %ld\n", num );
1283     IXMLDOMNamedNodeMap_Release( attr_map );
1284
1285     V_VT(&var) = VT_BSTR;
1286     V_BSTR(&var) = SysAllocString( szstr1 );
1287     name = SysAllocString( szdl );
1288     r = IXMLDOMElement_setAttribute( element, name, var );
1289     ok( r == S_OK, "returns %08x\n", r );
1290     r = IXMLDOMElement_get_attributes( element, &attr_map );
1291     ok( r == S_OK, "returns %08x\n", r );
1292     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1293     ok( r == S_OK, "returns %08x\n", r );
1294     ok( num == 1, "num %ld\n", num );
1295     IXMLDOMNamedNodeMap_Release( attr_map );
1296     VariantClear(&var);
1297
1298     V_VT(&var) = VT_BSTR;
1299     V_BSTR(&var) = SysAllocString( szstr2 );
1300     r = IXMLDOMElement_setAttribute( element, name, var );
1301     ok( r == S_OK, "returns %08x\n", r );
1302     r = IXMLDOMElement_get_attributes( element, &attr_map );
1303     ok( r == S_OK, "returns %08x\n", r );
1304     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1305     ok( r == S_OK, "returns %08x\n", r );
1306     ok( num == 1, "num %ld\n", num );
1307     IXMLDOMNamedNodeMap_Release( attr_map );
1308     VariantClear(&var);
1309     r = IXMLDOMElement_getAttribute( element, name, &var );
1310     ok( r == S_OK, "returns %08x\n", r );
1311     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
1312     VariantClear(&var);
1313     SysFreeString(name);
1314
1315     V_VT(&var) = VT_BSTR;
1316     V_BSTR(&var) = SysAllocString( szstr1 );
1317     name = SysAllocString( szlc );
1318     r = IXMLDOMElement_setAttribute( element, name, var );
1319     ok( r == S_OK, "returns %08x\n", r );
1320     r = IXMLDOMElement_get_attributes( element, &attr_map );
1321     ok( r == S_OK, "returns %08x\n", r );
1322     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1323     ok( r == S_OK, "returns %08x\n", r );
1324     ok( num == 2, "num %ld\n", num );
1325     IXMLDOMNamedNodeMap_Release( attr_map );
1326     VariantClear(&var);
1327     SysFreeString(name);
1328
1329     V_VT(&var) = VT_I4;
1330     V_I4(&var) = 10;
1331     name = SysAllocString( szbs );
1332     r = IXMLDOMElement_setAttribute( element, name, var );
1333     ok( r == S_OK, "returns %08x\n", r );
1334     VariantClear(&var);
1335     r = IXMLDOMElement_getAttribute( element, name, &var );
1336     ok( r == S_OK, "returns %08x\n", r );
1337     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
1338     VariantClear(&var);
1339     SysFreeString(name);
1340
1341     IXMLDOMElement_Release( element );
1342     IXMLDOMNode_Release( root );
1343     IXMLDOMDocument_Release( doc );
1344 }
1345
1346 static void test_getElementsByTagName(void)
1347 {
1348     HRESULT r;
1349     BSTR str;
1350     VARIANT_BOOL b;
1351     IXMLDOMDocument *doc;
1352     IXMLDOMNodeList *node_list;
1353     long len;
1354
1355     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1356         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1357     if( r != S_OK )
1358         return;
1359
1360     str = SysAllocString( szComplete4 );
1361     r = IXMLDOMDocument_loadXML( doc, str, &b );
1362     ok( r == S_OK, "loadXML failed\n");
1363     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1364     SysFreeString( str );
1365
1366     str = SysAllocString( szstar );
1367     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1368     ok( r == S_OK, "ret %08x\n", r );
1369     r = IXMLDOMNodeList_get_length( node_list, &len );
1370     ok( r == S_OK, "ret %08x\n", r );
1371     ok( len == 6, "len %ld\n", len );
1372     IXMLDOMNodeList_Release( node_list );
1373     SysFreeString( str );
1374
1375     str = SysAllocString( szbs );
1376     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1377     ok( r == S_OK, "ret %08x\n", r );
1378     r = IXMLDOMNodeList_get_length( node_list, &len );
1379     ok( r == S_OK, "ret %08x\n", r );
1380     ok( len == 1, "len %ld\n", len );
1381     IXMLDOMNodeList_Release( node_list );
1382     SysFreeString( str );
1383
1384     str = SysAllocString( szdl );
1385     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1386     ok( r == S_OK, "ret %08x\n", r );
1387     r = IXMLDOMNodeList_get_length( node_list, &len );
1388     ok( r == S_OK, "ret %08x\n", r );
1389     ok( len == 0, "len %ld\n", len );
1390     IXMLDOMNodeList_Release( node_list );
1391     SysFreeString( str );
1392
1393     str = SysAllocString( szstr1 );
1394     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1395     ok( r == S_OK, "ret %08x\n", r );
1396     r = IXMLDOMNodeList_get_length( node_list, &len );
1397     ok( r == S_OK, "ret %08x\n", r );
1398     ok( len == 0, "len %ld\n", len );
1399     IXMLDOMNodeList_Release( node_list );
1400     SysFreeString( str );
1401
1402     IXMLDOMDocument_Release( doc );
1403 }
1404
1405 static void test_get_text(void)
1406 {
1407     HRESULT r;
1408     BSTR str;
1409     VARIANT_BOOL b;
1410     IXMLDOMDocument *doc;
1411     IXMLDOMNode *node, *node2, *node3;
1412     IXMLDOMNodeList *node_list;
1413     IXMLDOMNamedNodeMap *node_map;
1414
1415     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1416         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1417     if( r != S_OK )
1418         return;
1419
1420     str = SysAllocString( szComplete4 );
1421     r = IXMLDOMDocument_loadXML( doc, str, &b );
1422     ok( r == S_OK, "loadXML failed\n");
1423     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1424     SysFreeString( str );
1425
1426     str = SysAllocString( szbs );
1427     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
1428     ok( r == S_OK, "ret %08x\n", r );
1429     SysFreeString(str);
1430
1431     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
1432     ok( r == S_OK, "ret %08x\n", r );
1433     IXMLDOMNodeList_Release( node_list );
1434
1435     /* Invalid output parameter*/
1436     r = IXMLDOMNode_get_text( node, NULL );
1437     ok( r == E_INVALIDARG, "ret %08x\n", r );
1438
1439     r = IXMLDOMNode_get_text( node, &str );
1440     ok( r == S_OK, "ret %08x\n", r );
1441 todo_wine {
1442     ok( !memcmp(str, szfn1_txt, sizeof(szfn1_txt)), "wrong string\n" );
1443  }
1444     ok( !memcmp(str, szfn1_txt, sizeof(szfn1_txt)-4), "wrong string\n" );
1445     SysFreeString(str);
1446
1447     r = IXMLDOMNode_get_attributes( node, &node_map );
1448     ok( r == S_OK, "ret %08x\n", r );
1449
1450     str = SysAllocString( szvr );
1451     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
1452     ok( r == S_OK, "ret %08x\n", r );
1453     SysFreeString(str);
1454
1455     r = IXMLDOMNode_get_text( node2, &str );
1456     ok( r == S_OK, "ret %08x\n", r );
1457     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
1458     SysFreeString(str);
1459
1460     r = IXMLDOMNode_get_firstChild( node2, &node3 );
1461     ok( r == S_OK, "ret %08x\n", r );
1462
1463     r = IXMLDOMNode_get_text( node3, &str );
1464     ok( r == S_OK, "ret %08x\n", r );
1465     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
1466     SysFreeString(str);
1467
1468
1469     IXMLDOMNode_Release( node3 );
1470     IXMLDOMNode_Release( node2 );
1471     IXMLDOMNamedNodeMap_Release( node_map );
1472     IXMLDOMNode_Release( node );
1473     IXMLDOMDocument_Release( doc );
1474 }
1475
1476 static void test_get_childNodes(void)
1477 {
1478     HRESULT r;
1479     BSTR str;
1480     VARIANT_BOOL b;
1481     IXMLDOMDocument *doc;
1482     IXMLDOMElement *element;
1483     IXMLDOMNode *node, *node2;
1484     IXMLDOMNodeList *node_list, *node_list2;
1485     long len;
1486
1487     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1488         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1489     if( r != S_OK )
1490         return;
1491
1492     str = SysAllocString( szComplete4 );
1493     r = IXMLDOMDocument_loadXML( doc, str, &b );
1494     ok( r == S_OK, "loadXML failed\n");
1495     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1496     SysFreeString( str );
1497
1498     r = IXMLDOMDocument_get_documentElement( doc, &element );
1499     ok( r == S_OK, "ret %08x\n", r);
1500
1501     r = IXMLDOMElement_get_childNodes( element, &node_list );
1502     ok( r == S_OK, "ret %08x\n", r);
1503
1504     r = IXMLDOMNodeList_get_length( node_list, &len );
1505     ok( r == S_OK, "ret %08x\n", r);
1506     ok( len == 4, "len %ld\n", len);
1507
1508     r = IXMLDOMNodeList_get_item( node_list, 2, &node );
1509     ok( r == S_OK, "ret %08x\n", r);
1510
1511     r = IXMLDOMNode_get_childNodes( node, &node_list2 );
1512     ok( r == S_OK, "ret %08x\n", r);
1513
1514     r = IXMLDOMNodeList_get_length( node_list2, &len );
1515     ok( r == S_OK, "ret %08x\n", r);
1516     ok( len == 0, "len %ld\n", len);
1517
1518     r = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
1519     ok( r == S_FALSE, "ret %08x\n", r);
1520
1521     IXMLDOMNodeList_Release( node_list2 );
1522     IXMLDOMNode_Release( node );
1523     IXMLDOMNodeList_Release( node_list );
1524     IXMLDOMElement_Release( element );
1525     IXMLDOMDocument_Release( doc );
1526 }
1527
1528 static void test_removeChild(void)
1529 {
1530     HRESULT r;
1531     BSTR str;
1532     VARIANT_BOOL b;
1533     IXMLDOMDocument *doc;
1534     IXMLDOMElement *element;
1535     IXMLDOMNode *node, *node2, *node3, *node4;
1536     IXMLDOMNodeList *node_list, *node_list2;
1537
1538     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1539         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1540     if( r != S_OK )
1541         return;
1542
1543     str = SysAllocString( szComplete4 );
1544     r = IXMLDOMDocument_loadXML( doc, str, &b );
1545     ok( r == S_OK, "loadXML failed\n");
1546     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1547     SysFreeString( str );
1548
1549     r = IXMLDOMDocument_get_documentElement( doc, &element );
1550     ok( r == S_OK, "ret %08x\n", r);
1551
1552     r = IXMLDOMElement_get_childNodes( element, &node_list );
1553     ok( r == S_OK, "ret %08x\n", r);
1554
1555     r = IXMLDOMNodeList_get_item( node_list, 3, &node );
1556     ok( r == S_OK, "ret %08x\n", r);
1557
1558     r = IXMLDOMNode_get_childNodes( node, &node_list2 );
1559     ok( r == S_OK, "ret %08x\n", r);
1560
1561     r = IXMLDOMNodeList_get_item( node_list, 0, &node4 );
1562     ok( r == S_OK, "ret %08x\n", r);
1563
1564     r = IXMLDOMElement_removeChild( element, NULL, &node2 );
1565     ok( r == E_INVALIDARG, "ret %08x\n", r );
1566
1567     r = IXMLDOMElement_removeChild( element, node4, &node2 );
1568     ok( r == S_OK, "ret %08x\n", r);
1569     ok( node4 == node2, "node %p node2 %p\n", node4, node2 );
1570
1571     r = IXMLDOMNode_get_parentNode( node4, &node3 );
1572     ok( r == S_FALSE, "ret %08x\n", r);
1573     ok( node3 == NULL, "%p\n", node3 );
1574
1575     IXMLDOMNode_Release( node2 );
1576     IXMLDOMNode_Release( node4 );
1577     IXMLDOMNodeList_Release( node_list2 );
1578     IXMLDOMNode_Release( node );
1579     IXMLDOMNodeList_Release( node_list );
1580     IXMLDOMElement_Release( element );
1581     IXMLDOMDocument_Release( doc );
1582 }
1583
1584 static void test_XMLHTTP(void)
1585 {
1586     static const WCHAR wszBody[] = {'m','o','d','e','=','T','e','s','t',0};
1587     static WCHAR wszPOST[] = {'P','O','S','T',0};
1588     static WCHAR wszUrl[] = {'h','t','t','p',':','/','/',
1589         'c','r','o','s','s','o','v','e','r','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
1590         'p','o','s','t','t','e','s','t','.','p','h','p',0};
1591     static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
1592     IXMLHttpRequest *pXMLHttpRequest;
1593     BSTR bstrResponse;
1594     VARIANT dummy;
1595     VARIANT varfalse;
1596     VARIANT varbody;
1597     HRESULT hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL,
1598                                   CLSCTX_INPROC_SERVER, &IID_IXMLHttpRequest,
1599                                   (void **)&pXMLHttpRequest);
1600     todo_wine {
1601     ok(hr == S_OK, "CoCreateInstance(CLSID_XMLHTTPRequest) should have succeeded instead of failing with 0x%08x\n", hr);
1602     }
1603     if (hr != S_OK)
1604         return;
1605
1606     VariantInit(&dummy);
1607     V_VT(&dummy) = VT_ERROR;
1608     V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
1609     VariantInit(&varfalse);
1610     V_VT(&varfalse) = VT_BOOL;
1611     V_BOOL(&varfalse) = VARIANT_FALSE;
1612     V_VT(&varbody) = VT_BSTR;
1613     V_BSTR(&varbody) = SysAllocString(wszBody);
1614
1615     hr = IXMLHttpRequest_open(pXMLHttpRequest, wszPOST, wszUrl, varfalse, dummy, dummy);
1616     ok(hr == S_OK, "IXMLHttpRequest_open should have succeeded instead of failing with 0x%08x\n", hr);
1617
1618     hr = IXMLHttpRequest_send(pXMLHttpRequest, varbody);
1619     ok(hr == S_OK, "IXMLHttpRequest_send should have succeeded instead of failing with 0x%08x\n", hr);
1620     VariantClear(&varbody);
1621
1622     hr = IXMLHttpRequest_get_responseText(pXMLHttpRequest, &bstrResponse);
1623     ok(hr == S_OK, "IXMLHttpRequest_get_responseText should have succeeded instead of failing with 0x%08x\n", hr);
1624     /* the server currently returns "FAILED" because the Content-Type header is
1625      * not what the server expects */
1626     ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)), "bstrResponse differs from what was expected\n");
1627     SysFreeString(bstrResponse);
1628 }
1629
1630 static void test_IXMLDOMDocument2(void)
1631 {
1632     HRESULT r;
1633     VARIANT_BOOL b;
1634     BSTR str;
1635     IXMLDOMDocument *doc;
1636     IXMLDOMDocument2 *doc2;
1637     VARIANT var;
1638     int ref;
1639
1640     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1641         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1642     if( r != S_OK )
1643         return;
1644
1645     str = SysAllocString( szComplete4 );
1646     r = IXMLDOMDocument_loadXML( doc, str, &b );
1647     ok( r == S_OK, "loadXML failed\n");
1648     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1649     SysFreeString( str );
1650
1651     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
1652     ok( r == S_OK, "ret %08x\n", r );
1653     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
1654
1655     /* we will check if the variant got cleared */
1656     ref = IXMLDOMDocument2_AddRef(doc2);
1657     expect_eq(ref, 3, int, "%d");  /* doc, doc2, AddRef*/
1658     V_VT(&var) = VT_UNKNOWN;
1659     V_UNKNOWN(&var) = (IUnknown *)doc2;
1660
1661     /* invalid calls */
1662     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
1663     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
1664     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
1665
1666     /* valid call */
1667     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
1668     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
1669     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
1670     V_VT(&var) = VT_R4;
1671
1672     /* the variant didn't get cleared*/
1673     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
1674
1675     /* setProperty tests */
1676     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
1677     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
1678     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
1679     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
1680     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
1681     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
1682
1683     /* contrary to what MSDN calims you can switch back from XPath to XSLPattern */
1684     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
1685     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
1686     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
1687
1688     IXMLDOMDocument2_Release( doc2 );
1689     IXMLDOMDocument_Release( doc );
1690     free_bstrs();
1691 }
1692
1693 static void test_XPath(void)
1694 {
1695     HRESULT r;
1696     VARIANT var;
1697     VARIANT_BOOL b;
1698     IXMLDOMDocument2 *doc;
1699     IXMLDOMNode *rootNode;
1700     IXMLDOMNode *elem1Node;
1701     IXMLDOMNode *node;
1702     IXMLDOMNodeList *list;
1703
1704     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1705         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
1706     if( r != S_OK )
1707         return;
1708
1709     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b));
1710     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1711
1712     /* switch to XPath */
1713     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
1714
1715     /* some simple queries*/
1716     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list));
1717     ole_check(IXMLDOMNodeList_get_item(list, 0, &rootNode));
1718     ole_check(IXMLDOMNodeList_reset(list));
1719     expect_list_and_release(list, "E2.D1");
1720     if (rootNode == NULL)
1721         return;
1722
1723     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//c"), &list));
1724     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
1725
1726     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//c[@type]"), &list));
1727     expect_list_and_release(list, "E3.E2.E2.D1");
1728
1729     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
1730     /* using get_item for query results advances the position */
1731     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
1732     expect_node(node, "E2.E2.D1");
1733     IXMLDOMNode_Release(node);
1734     ole_check(IXMLDOMNodeList_nextNode(list, &node));
1735     expect_node(node, "E4.E2.D1");
1736     IXMLDOMNode_Release(node);
1737     ole_check(IXMLDOMNodeList_reset(list));
1738     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
1739
1740     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
1741     expect_list_and_release(list, "E2.D1");
1742
1743     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
1744     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
1745     ole_check(IXMLDOMNodeList_reset(list));
1746     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
1747
1748     /* select an attribute */
1749     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
1750     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
1751
1752     /* would evaluate to a number */
1753     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
1754     /* would evaluate to a boolean */
1755     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
1756     /* would evaluate to a string */
1757     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
1758
1759     /* no results */
1760     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
1761     expect_list_and_release(list, "");
1762     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("elem//c"), &list));
1763     expect_list_and_release(list, "");
1764     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//elem[4]"), &list));
1765     expect_list_and_release(list, "");
1766
1767     /* foo undeclared in document node */
1768     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
1769     /* undeclared in <root> node */
1770     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
1771     /* undeclared in <elem> node */
1772     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
1773     /* but this trick can be used */
1774     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
1775     expect_list_and_release(list, "E3.E4.E2.D1");
1776
1777     /* it has to be declared in SelectionNamespaces */
1778     todo_wine ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
1779         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
1780
1781     /* now the namespace can be used */
1782     todo_wine ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//test:c"), &list));
1783     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
1784     todo_wine ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
1785     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
1786     todo_wine ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
1787     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
1788     todo_wine ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
1789     todo_wine expect_list_and_release(list, "E5.E1.E4.E1.E2.D1");
1790
1791     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
1792     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
1793         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
1794
1795     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
1796
1797     VariantClear(&var);
1798     todo_wine ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
1799     todo_wine expect_eq(V_VT(&var), VT_BSTR, int, "%x");
1800     if (V_VT(&var) == VT_BSTR)
1801         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
1802
1803     /* extra attributes - same thing*/
1804     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
1805         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
1806     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
1807
1808     IXMLDOMNode_Release(rootNode);
1809     IXMLDOMNode_Release(elem1Node);
1810     IXMLDOMDocument_Release(doc);
1811     free_bstrs();
1812 }
1813
1814 static void test_cloneNode(void )
1815 {
1816     IXMLDOMDocument *doc = NULL;
1817     VARIANT_BOOL b;
1818     IXMLDOMNodeList *pList;
1819     IXMLDOMNamedNodeMap *mapAttr;
1820     long nLength = 0, nLength1 = 0;
1821     long nAttrCnt = 0, nAttrCnt1 = 0;
1822     IXMLDOMNode *node;
1823     IXMLDOMNode *node_clone;
1824     HRESULT r;
1825     BSTR str;
1826     static const WCHAR szSearch[] = { 'l', 'c', '/', 'p', 'r', 0 };
1827
1828     r = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
1829     if( r != S_OK )
1830         return;
1831
1832     str = SysAllocString( szComplete4 );
1833     ole_check(IXMLDOMDocument_loadXML(doc, str, &b));
1834     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1835     SysFreeString(str);
1836
1837     if(!b)
1838         return;
1839
1840     str = SysAllocString( szSearch);
1841     r = IXMLDOMNode_selectSingleNode(doc, str, &node);
1842     ok( r == S_OK, "ret %08x\n", r );
1843     ok( node != NULL, "node %p\n", node );
1844     SysFreeString(str);
1845
1846     if(!node)
1847     {
1848         IXMLDOMDocument_Release(doc);
1849         return;
1850     }
1851
1852     /* Check invalid parameter */
1853     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
1854     ok( r == E_INVALIDARG, "ret %08x\n", r );
1855
1856     /* All Children */
1857     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
1858     ok( r == S_OK, "ret %08x\n", r );
1859     ok( node_clone != NULL, "node %p\n", node );
1860
1861     if(!node_clone)
1862     {
1863         IXMLDOMDocument_Release(doc);
1864         IXMLDOMNode_Release(node);
1865         return;
1866     }
1867
1868     r = IXMLDOMNode_get_childNodes(node, &pList);
1869     ok( r == S_OK, "ret %08x\n", r );
1870     if (pList)
1871         {
1872                 IXMLDOMNodeList_get_length(pList, &nLength);
1873                 IXMLDOMNodeList_Release(pList);
1874         }
1875
1876     r = IXMLDOMNode_get_attributes(node, &mapAttr);
1877     ok( r == S_OK, "ret %08x\n", r );
1878     if(mapAttr)
1879     {
1880         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt);
1881         IXMLDOMNamedNodeMap_Release(mapAttr);
1882     }
1883
1884     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
1885     ok( r == S_OK, "ret %08x\n", r );
1886     if (pList)
1887         {
1888                 IXMLDOMNodeList_get_length(pList, &nLength1);
1889                 IXMLDOMNodeList_Release(pList);
1890         }
1891
1892     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
1893     ok( r == S_OK, "ret %08x\n", r );
1894     if(mapAttr)
1895     {
1896         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
1897         IXMLDOMNamedNodeMap_Release(mapAttr);
1898     }
1899
1900     ok(nLength == nLength1, "wrong Child count (%ld, %ld)\n", nLength, nLength1);
1901     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%ld, %ld)\n", nAttrCnt, nAttrCnt1);
1902     IXMLDOMNode_Release(node_clone);
1903
1904     /* No Children */
1905     r = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
1906     ok( r == S_OK, "ret %08x\n", r );
1907     ok( node_clone != NULL, "node %p\n", node );
1908
1909     if(!node_clone)
1910     {
1911         IXMLDOMDocument_Release(doc);
1912         IXMLDOMNode_Release(node);
1913         return;
1914     }
1915
1916     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
1917     ok( r == S_OK, "ret %08x\n", r );
1918     if (pList)
1919         {
1920                 IXMLDOMNodeList_get_length(pList, &nLength1);
1921         ok( nLength1 == 0, "Length should be 0 (%ld)\n", nLength1);
1922                 IXMLDOMNodeList_Release(pList);
1923         }
1924
1925     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
1926     ok( r == S_OK, "ret %08x\n", r );
1927     if(mapAttr)
1928     {
1929         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
1930         ok( nAttrCnt1 == 3, "Attribute count should be 3 (%ld)\n", nAttrCnt1);
1931         IXMLDOMNamedNodeMap_Release(mapAttr);
1932     }
1933
1934     ok(nLength != nLength1, "wrong Child count (%ld, %ld)\n", nLength, nLength1);
1935     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%ld, %ld)\n", nAttrCnt, nAttrCnt1);
1936     IXMLDOMNode_Release(node_clone);
1937
1938
1939     IXMLDOMNode_Release(node);
1940     IXMLDOMDocument_Release(doc);
1941 }
1942
1943 static void test_xmlTypes(void)
1944 {
1945     IXMLDOMDocument *doc = NULL;
1946     IXMLDOMElement *pRoot;
1947     HRESULT hr;
1948     IXMLDOMComment *pComment;
1949     IXMLDOMElement *pElement;
1950     IXMLDOMAttribute *pAttrubute;
1951     IXMLDOMNamedNodeMap *pAttribs;
1952     IXMLDOMCDATASection *pCDataSec;
1953     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
1954     IXMLDOMDocumentFragment *pDocFrag = NULL;
1955     IXMLDOMEntityReference *pEntityRef = NULL;
1956     BSTR str;
1957     IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;   /* Used for testing Siblings */
1958     VARIANT v;
1959     long len = 0;
1960
1961     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
1962     if( hr != S_OK )
1963         return;
1964
1965     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
1966     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
1967
1968     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
1969     ok(hr == S_FALSE, "ret %08x\n", hr );
1970     ok(pNextChild == NULL, "pDocChild not NULL\n");
1971
1972     /* test previous Sibling */
1973     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
1974     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
1975
1976     pNextChild = (IXMLDOMNode *)0x1;
1977     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
1978     ok(hr == S_FALSE, "ret %08x\n", hr );
1979     ok(pNextChild == NULL, "pNextChild not NULL\n");
1980
1981     /* test get_attributes */
1982     hr = IXMLDOMDocument_get_attributes( doc, NULL );
1983     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
1984
1985     pAttribs = (IXMLDOMNamedNodeMap*)0x1;
1986     hr = IXMLDOMDocument_get_attributes( doc, &pAttribs);
1987     ok(hr == S_FALSE, "ret %08x\n", hr );
1988     ok( pAttribs == NULL, "pAttribs not NULL\n");
1989
1990     /* test get_dataType */
1991     hr = IXMLDOMDocument_get_dataType(doc, &v);
1992     ok(hr == S_FALSE, "ret %08x\n", hr );
1993     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
1994     VariantClear(&v);
1995
1996     /* test nodeTypeString */
1997     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
1998     ok(hr == S_OK, "ret %08x\n", hr );
1999     ok( !lstrcmpW( str, _bstr_("document") ), "incorrect nodeTypeString string\n");
2000     SysFreeString(str);
2001
2002     /* test implementation */
2003     hr = IXMLDOMDocument_get_implementation(doc, NULL);
2004     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2005
2006     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
2007     ok(hr == S_OK, "ret %08x\n", hr );
2008     if(hr == S_OK)
2009     {
2010         VARIANT_BOOL hasFeature = VARIANT_TRUE;
2011         BSTR sEmpty = SysAllocStringLen(NULL, 0);
2012
2013         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
2014         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2015
2016         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
2017         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2018
2019         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
2020         ok(hr == S_OK, "ret %08x\n", hr );
2021         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2022
2023         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
2024         ok(hr == S_OK, "ret %08x\n", hr );
2025         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
2026
2027         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
2028         ok(hr == S_OK, "ret %08x\n", hr );
2029         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
2030
2031         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
2032         ok(hr == S_OK, "ret %08x\n", hr );
2033         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2034
2035         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
2036         ok(hr == S_OK, "ret %08x\n", hr );
2037         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2038
2039         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
2040         ok(hr == S_OK, "ret %08x\n", hr );
2041         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2042
2043         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
2044         ok(hr == S_OK, "ret %08x\n", hr );
2045         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2046
2047         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
2048         ok(hr == S_OK, "ret %08x\n", hr );
2049         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2050
2051         SysFreeString(sEmpty);
2052         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
2053     }
2054
2055
2056
2057     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
2058     ok(hr == S_OK, "ret %08x\n", hr );
2059     if(hr == S_OK)
2060     {
2061         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
2062         ok(hr == S_OK, "ret %08x\n", hr );
2063         if(hr == S_OK)
2064         {
2065             /* Comment */
2066             hr = IXMLDOMDocument_createComment(doc, szComment, &pComment);
2067             ok(hr == S_OK, "ret %08x\n", hr );
2068             if(hr == S_OK)
2069             {
2070                 /* test get_attributes */
2071                 hr = IXMLDOMComment_get_attributes( pComment, NULL );
2072                 ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2073
2074                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2075                 hr = IXMLDOMComment_get_attributes( pComment, &pAttribs);
2076                 ok(hr == S_FALSE, "ret %08x\n", hr );
2077                 ok( pAttribs == NULL, "pAttribs not NULL\n");
2078
2079                 /* test nodeTypeString */
2080                 hr = IXMLDOMComment_get_nodeTypeString(pComment, &str);
2081                 ok(hr == S_OK, "ret %08x\n", hr );
2082                 ok( !lstrcmpW( str, _bstr_("comment") ), "incorrect nodeTypeString string\n");
2083                 SysFreeString(str);
2084
2085                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
2086                 ok(hr == S_OK, "ret %08x\n", hr );
2087
2088                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
2089                 ok(hr == S_OK, "ret %08x\n", hr );
2090                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
2091                 SysFreeString(str);
2092
2093                 hr = IXMLDOMComment_get_xml(pComment, &str);
2094                 ok(hr == S_OK, "ret %08x\n", hr );
2095                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
2096                 SysFreeString(str);
2097
2098                 hr = IXMLDOMComment_get_dataType(pComment, &v);
2099                 ok(hr == S_FALSE, "ret %08x\n", hr );
2100                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2101                 VariantClear(&v);
2102
2103                 /* put data Tests */
2104                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
2105                 ok(hr == S_OK, "ret %08x\n", hr );
2106
2107                 /* get data Tests */
2108                 hr = IXMLDOMComment_get_data(pComment, &str);
2109                 ok(hr == S_OK, "ret %08x\n", hr );
2110                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
2111                 SysFreeString(str);
2112
2113                 /* get data Tests */
2114                 hr = IXMLDOMComment_get_nodeValue(pComment, &v);
2115                 ok(hr == S_OK, "ret %08x\n", hr );
2116                 ok( V_VT(&v) == VT_BSTR, "incorrect dataType type\n");
2117                 ok( !lstrcmpW( V_BSTR(&v), _bstr_("This &is a ; test <>\\") ), "incorrect get_nodeValue string\n");
2118                 VariantClear(&v);
2119
2120                 /* Confirm XML text is good */
2121                 hr = IXMLDOMComment_get_xml(pComment, &str);
2122                 ok(hr == S_OK, "ret %08x\n", hr );
2123                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
2124                 SysFreeString(str);
2125
2126                 /* Confirm we get the put_data Text back */
2127                 hr = IXMLDOMComment_get_text(pComment, &str);
2128                 ok(hr == S_OK, "ret %08x\n", hr );
2129                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
2130                 SysFreeString(str);
2131
2132                 /* test length property */
2133                 hr = IXMLDOMComment_get_length(pComment, &len);
2134                 ok(hr == S_OK, "ret %08x\n", hr );
2135                 ok(len == 21, "expected 21 got %ld\n", len);
2136
2137                 IXMLDOMComment_Release(pComment);
2138             }
2139
2140             /* Element */
2141             hr = IXMLDOMDocument_createElement(doc, szElement, &pElement);
2142             ok(hr == S_OK, "ret %08x\n", hr );
2143             if(hr == S_OK)
2144             {
2145                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2146                 ok(hr == S_OK, "ret %08x\n", hr );
2147
2148                 /* test nodeTypeString */
2149                 hr = IXMLDOMDocument_get_nodeTypeString(pElement, &str);
2150                 ok(hr == S_OK, "ret %08x\n", hr );
2151                 ok( !lstrcmpW( str, _bstr_("element") ), "incorrect nodeTypeString string\n");
2152                 SysFreeString(str);
2153
2154                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
2155                 ok(hr == S_OK, "ret %08x\n", hr );
2156                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
2157                 SysFreeString(str);
2158
2159                 hr = IXMLDOMElement_get_xml(pElement, &str);
2160                 ok(hr == S_OK, "ret %08x\n", hr );
2161                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
2162                 SysFreeString(str);
2163
2164                 hr = IXMLDOMElement_get_dataType(pElement, &v);
2165                 ok(hr == S_FALSE, "ret %08x\n", hr );
2166                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2167                 VariantClear(&v);
2168
2169                  /* Attribute */
2170                 hr = IXMLDOMDocument_createAttribute(doc, szAttribute, &pAttrubute);
2171                 ok(hr == S_OK, "ret %08x\n", hr );
2172                 if(hr == S_OK)
2173                 {
2174                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
2175
2176                     hr = IXMLDOMAttribute_get_nextSibling(pAttrubute, NULL);
2177                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2178
2179                     pNextChild = (IXMLDOMNode *)0x1;
2180                     hr = IXMLDOMAttribute_get_nextSibling(pAttrubute, &pNextChild);
2181                     ok(hr == S_FALSE, "ret %08x\n", hr );
2182                     ok(pNextChild == NULL, "pNextChild not NULL\n");
2183
2184                     /* test Previous Sibling*/
2185                     hr = IXMLDOMAttribute_get_previousSibling(pAttrubute, NULL);
2186                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2187
2188                     pNextChild = (IXMLDOMNode *)0x1;
2189                     hr = IXMLDOMAttribute_get_previousSibling(pAttrubute, &pNextChild);
2190                     ok(hr == S_FALSE, "ret %08x\n", hr );
2191                     ok(pNextChild == NULL, "pNextChild not NULL\n");
2192
2193                     /* test get_attributes */
2194                     hr = IXMLDOMAttribute_get_attributes( pAttrubute, NULL );
2195                     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2196
2197                     pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2198                     hr = IXMLDOMAttribute_get_attributes( pAttrubute, &pAttribs);
2199                     ok(hr == S_FALSE, "ret %08x\n", hr );
2200                     ok( pAttribs == NULL, "pAttribs not NULL\n");
2201
2202                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttrubute, &pNewChild);
2203                     ok(hr == E_FAIL, "ret %08x\n", hr );
2204                     ok(pNewChild == NULL, "pNewChild not NULL\n");
2205
2206                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
2207                     ok(hr == S_OK, "ret %08x\n", hr );
2208                     if ( hr == S_OK )
2209                     {
2210                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttrubute, NULL );
2211                         ok(hr == S_OK, "ret %08x\n", hr );
2212
2213                         IXMLDOMNamedNodeMap_Release(pAttribs);
2214                     }
2215
2216                     hr = IXMLDOMAttribute_get_nodeName(pAttrubute, &str);
2217                     ok(hr == S_OK, "ret %08x\n", hr );
2218                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
2219                     SysFreeString(str);
2220
2221                     /* test nodeTypeString */
2222                     hr = IXMLDOMAttribute_get_nodeTypeString(pAttrubute, &str);
2223                     ok(hr == S_OK, "ret %08x\n", hr );
2224                     ok( !lstrcmpW( str, _bstr_("attribute") ), "incorrect nodeTypeString string\n");
2225                     SysFreeString(str);
2226
2227                     /* test nodeName */
2228                     hr = IXMLDOMAttribute_get_nodeName(pAttrubute, &str);
2229                     ok(hr == S_OK, "ret %08x\n", hr );
2230                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
2231                     SysFreeString(str);
2232
2233                     /* test name property */
2234                     hr = IXMLDOMAttribute_get_name(pAttrubute, &str);
2235                     ok(hr == S_OK, "ret %08x\n", hr );
2236                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
2237                     SysFreeString(str);
2238
2239                     hr = IXMLDOMAttribute_get_xml(pAttrubute, &str);
2240                     ok(hr == S_OK, "ret %08x\n", hr );
2241                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
2242                     SysFreeString(str);
2243
2244                     hr = IXMLDOMAttribute_get_dataType(pAttrubute, &v);
2245                     ok(hr == S_FALSE, "ret %08x\n", hr );
2246                     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2247                     VariantClear(&v);
2248
2249                     IXMLDOMAttribute_Release(pAttrubute);
2250
2251                     /* Check Element again with the Add Attribute*/
2252                     hr = IXMLDOMElement_get_xml(pElement, &str);
2253                     ok(hr == S_OK, "ret %08x\n", hr );
2254                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
2255                     SysFreeString(str);
2256                 }
2257
2258                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
2259                 ok(hr == S_OK, "ret %08x\n", hr );
2260
2261                 hr = IXMLDOMElement_get_xml(pElement, &str);
2262                 ok(hr == S_OK, "ret %08x\n", hr );
2263                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
2264
2265                 IXMLDOMElement_Release(pElement);
2266             }
2267
2268             /* CData Section */
2269             hr = IXMLDOMDocument_createCDATASection(doc, szCData, NULL);
2270             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2271
2272             hr = IXMLDOMDocument_createCDATASection(doc, szCData, &pCDataSec);
2273             ok(hr == S_OK, "ret %08x\n", hr );
2274             if(hr == S_OK)
2275             {
2276                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
2277
2278                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
2279                 ok(hr == S_OK, "ret %08x\n", hr );
2280
2281                 /* get Attribute Tests */
2282                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, NULL);
2283                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2284
2285                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2286                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, &pAttribs);
2287                 ok(hr == S_FALSE, "ret %08x\n", hr );
2288                 ok(pAttribs == NULL, "pAttribs != NULL\n");
2289
2290                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
2291                 ok(hr == S_OK, "ret %08x\n", hr );
2292                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
2293                 SysFreeString(str);
2294
2295                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
2296                 ok(hr == S_OK, "ret %08x\n", hr );
2297                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
2298                 SysFreeString(str);
2299
2300                 /* test lastChild */
2301                 pNextChild = (IXMLDOMNode*)0x1;
2302                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
2303                 ok(hr == S_FALSE, "ret %08x\n", hr );
2304                 ok(pNextChild == NULL, "pNextChild not NULL\n");
2305
2306                 /* test get_dataType */
2307                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, NULL);
2308                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2309
2310                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, &v);
2311                 ok(hr == S_FALSE, "ret %08x\n", hr );
2312                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2313                 VariantClear(&v);
2314
2315                 /* test nodeTypeString */
2316                 hr = IXMLDOMCDATASection_get_nodeTypeString(pCDataSec, &str);
2317                 ok(hr == S_OK, "ret %08x\n", hr );
2318                 ok( !lstrcmpW( str, _bstr_("cdatasection") ), "incorrect nodeTypeString string\n");
2319                 SysFreeString(str);
2320
2321                 /* put data Tests */
2322                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
2323                 ok(hr == S_OK, "ret %08x\n", hr );
2324
2325                 /* Confirm XML text is good */
2326                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
2327                 ok(hr == S_OK, "ret %08x\n", hr );
2328                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
2329                 SysFreeString(str);
2330
2331                 /* Confirm we get the put_data Text back */
2332                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
2333                 ok(hr == S_OK, "ret %08x\n", hr );
2334                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2335                 SysFreeString(str);
2336
2337                 /* test length property */
2338                 hr = IXMLDOMCDATASection_get_length(pComment, &len);
2339                 ok(hr == S_OK, "ret %08x\n", hr );
2340                 ok(len == 21, "expected 21 got %ld\n", len);
2341
2342                 IXMLDOMCDATASection_Release(pCDataSec);
2343             }
2344
2345             /* Document Fragments */
2346             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
2347             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2348
2349             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
2350             ok(hr == S_OK, "ret %08x\n", hr );
2351             if(hr == S_OK)
2352             {
2353                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
2354
2355                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
2356                 ok(hr == S_OK, "ret %08x\n", hr );
2357
2358                 /* get Attribute Tests */
2359                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, NULL);
2360                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2361
2362                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2363                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, &pAttribs);
2364                 ok(hr == S_FALSE, "ret %08x\n", hr );
2365                 ok(pAttribs == NULL, "pAttribs != NULL\n");
2366
2367                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
2368                 ok(hr == S_OK, "ret %08x\n", hr );
2369                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
2370                 SysFreeString(str);
2371
2372                 /* test next Sibling*/
2373                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
2374                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2375
2376                 pNextChild = (IXMLDOMNode *)0x1;
2377                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &pNextChild);
2378                 ok(hr == S_FALSE, "ret %08x\n", hr );
2379                 ok(pNextChild == NULL, "pNextChild not NULL\n");
2380
2381                 /* test Previous Sibling*/
2382                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
2383                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2384
2385                 pNextChild = (IXMLDOMNode *)0x1;
2386                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &pNextChild);
2387                 ok(hr == S_FALSE, "ret %08x\n", hr );
2388                 ok(pNextChild == NULL, "pNextChild not NULL\n");
2389
2390                 /* test get_dataType */
2391                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, NULL);
2392                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2393
2394                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, &v);
2395                 ok(hr == S_FALSE, "ret %08x\n", hr );
2396                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2397                 VariantClear(&v);
2398
2399                 /* test nodeTypeString */
2400                 hr = IXMLDOMDocumentFragment_get_nodeTypeString(pDocFrag, &str);
2401                 ok(hr == S_OK, "ret %08x\n", hr );
2402                 ok( !lstrcmpW( str, _bstr_("documentfragment") ), "incorrect nodeTypeString string\n");
2403                 SysFreeString(str);
2404
2405                 IXMLDOMDocumentFragment_Release(pCDataSec);
2406             }
2407
2408             /* Entity References */
2409             hr = IXMLDOMDocument_createEntityReference(doc, szEntityRef, NULL);
2410             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2411
2412             hr = IXMLDOMDocument_createEntityReference(doc, szEntityRef, &pEntityRef);
2413             ok(hr == S_OK, "ret %08x\n", hr );
2414             if(hr == S_OK)
2415             {
2416                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
2417                 ok(hr == S_OK, "ret %08x\n", hr );
2418
2419                 /* get Attribute Tests */
2420                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, NULL);
2421                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2422
2423                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2424                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, &pAttribs);
2425                 ok(hr == S_FALSE, "ret %08x\n", hr );
2426                 ok(pAttribs == NULL, "pAttribs != NULL\n");
2427
2428                 /* test dataType */
2429                 hr = IXMLDOMEntityReference_get_dataType(pEntityRef, &v);
2430                 ok(hr == S_FALSE, "ret %08x\n", hr );
2431                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2432                 VariantClear(&v);
2433
2434                 /* test nodeTypeString */
2435                 hr = IXMLDOMEntityReference_get_nodeTypeString(pEntityRef, &str);
2436                 ok(hr == S_OK, "ret %08x\n", hr );
2437                 ok( !lstrcmpW( str, _bstr_("entityreference") ), "incorrect nodeTypeString string\n");
2438                 SysFreeString(str);
2439
2440                 /* test get_xml*/
2441                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
2442                 ok(hr == S_OK, "ret %08x\n", hr );
2443                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
2444                 SysFreeString(str);
2445
2446                 IXMLDOMEntityReference_Release(pEntityRef);
2447             }
2448
2449             IXMLDOMElement_Release( pRoot );
2450         }
2451     }
2452
2453     IXMLDOMDocument_Release(doc);
2454
2455     free_bstrs();
2456 }
2457
2458 static void test_nodeTypeTests( void )
2459 {
2460     IXMLDOMDocument *doc = NULL;
2461     IXMLDOMElement *pRoot;
2462     IXMLDOMElement *pElement;
2463     HRESULT hr;
2464
2465     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
2466     if( hr != S_OK )
2467         return;
2468
2469     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
2470     ok(hr == S_OK, "ret %08x\n", hr );
2471     if(hr == S_OK)
2472     {
2473         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
2474         ok(hr == S_OK, "ret %08x\n", hr );
2475         if(hr == S_OK)
2476         {
2477             hr = IXMLDOMElement_put_dataType(pRoot, NULL);
2478             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2479
2480             /* Invalid Value */
2481             hr = IXMLDOMElement_put_dataType(pRoot, _bstr_("abcdefg") );
2482             ok(hr == E_FAIL, "ret %08x\n", hr );
2483
2484             /* NOTE:
2485              *   The name passed into put_dataType is case-insensitive. So many of the names
2486              *     have been changed to reflect this.
2487              */
2488             /* Boolean */
2489             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Boolean"), &pElement);
2490             ok(hr == S_OK, "ret %08x\n", hr );
2491             if(hr == S_OK)
2492             {
2493                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2494
2495                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Boolean") );
2496                 ok(hr == S_OK, "ret %08x\n", hr );
2497
2498                 IXMLDOMElement_Release(pElement);
2499             }
2500
2501             /* String */
2502             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_String"), &pElement);
2503             ok(hr == S_OK, "ret %08x\n", hr );
2504             if(hr == S_OK)
2505             {
2506                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2507
2508                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("String") );
2509                 ok(hr == S_OK, "ret %08x\n", hr );
2510
2511                 IXMLDOMElement_Release(pElement);
2512             }
2513
2514             /* Number */
2515             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Number"), &pElement);
2516             ok(hr == S_OK, "ret %08x\n", hr );
2517             if(hr == S_OK)
2518             {
2519                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2520
2521                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("number") );
2522                 ok(hr == S_OK, "ret %08x\n", hr );
2523
2524                 IXMLDOMElement_Release(pElement);
2525             }
2526
2527             /* Int */
2528             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Int"), &pElement);
2529             ok(hr == S_OK, "ret %08x\n", hr );
2530             if(hr == S_OK)
2531             {
2532                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2533
2534                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("InT") );
2535                 ok(hr == S_OK, "ret %08x\n", hr );
2536
2537                 IXMLDOMElement_Release(pElement);
2538             }
2539
2540             /* Fixed */
2541             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Fixed"), &pElement);
2542             ok(hr == S_OK, "ret %08x\n", hr );
2543             if(hr == S_OK)
2544             {
2545                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2546
2547                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("fixed.14.4") );
2548                 ok(hr == S_OK, "ret %08x\n", hr );
2549
2550                 IXMLDOMElement_Release(pElement);
2551             }
2552
2553             /* DateTime */
2554             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime"), &pElement);
2555             ok(hr == S_OK, "ret %08x\n", hr );
2556             if(hr == S_OK)
2557             {
2558                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2559
2560                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime") );
2561                 ok(hr == S_OK, "ret %08x\n", hr );
2562
2563                 IXMLDOMElement_Release(pElement);
2564             }
2565
2566             /* DateTime TZ */
2567             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime_tz"), &pElement);
2568             ok(hr == S_OK, "ret %08x\n", hr );
2569             if(hr == S_OK)
2570             {
2571                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2572
2573                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
2574                 ok(hr == S_OK, "ret %08x\n", hr );
2575
2576                 IXMLDOMElement_Release(pElement);
2577             }
2578
2579             /* Date */
2580             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Date"), &pElement);
2581             ok(hr == S_OK, "ret %08x\n", hr );
2582             if(hr == S_OK)
2583             {
2584                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2585
2586                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Date") );
2587                 ok(hr == S_OK, "ret %08x\n", hr );
2588
2589                 IXMLDOMElement_Release(pElement);
2590             }
2591
2592             /* Time */
2593             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time"), &pElement);
2594             ok(hr == S_OK, "ret %08x\n", hr );
2595             if(hr == S_OK)
2596             {
2597                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2598
2599                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time") );
2600                 ok(hr == S_OK, "ret %08x\n", hr );
2601
2602                 IXMLDOMElement_Release(pElement);
2603             }
2604
2605             /* Time.tz */
2606             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time_TZ"), &pElement);
2607             ok(hr == S_OK, "ret %08x\n", hr );
2608             if(hr == S_OK)
2609             {
2610                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2611
2612                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time.tz") );
2613                 ok(hr == S_OK, "ret %08x\n", hr );
2614
2615                 IXMLDOMElement_Release(pElement);
2616             }
2617
2618             /* I1 */
2619             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I1"), &pElement);
2620             ok(hr == S_OK, "ret %08x\n", hr );
2621             if(hr == S_OK)
2622             {
2623                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2624
2625                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I1") );
2626                 ok(hr == S_OK, "ret %08x\n", hr );
2627
2628                 IXMLDOMElement_Release(pElement);
2629             }
2630
2631             /* Byte */
2632             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_byte"), &pElement);
2633             ok(hr == S_OK, "ret %08x\n", hr );
2634             if(hr == S_OK)
2635             {
2636                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2637
2638                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("byte") );
2639                 ok(hr == S_OK, "ret %08x\n", hr );
2640
2641                 IXMLDOMElement_Release(pElement);
2642             }
2643
2644             /* I2 */
2645             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I2"), &pElement);
2646             ok(hr == S_OK, "ret %08x\n", hr );
2647             if(hr == S_OK)
2648             {
2649                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2650
2651                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I2") );
2652                 ok(hr == S_OK, "ret %08x\n", hr );
2653
2654                 IXMLDOMElement_Release(pElement);
2655             }
2656
2657             /* I4 */
2658             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I4"), &pElement);
2659             ok(hr == S_OK, "ret %08x\n", hr );
2660             if(hr == S_OK)
2661             {
2662                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2663
2664                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I4") );
2665                 ok(hr == S_OK, "ret %08x\n", hr );
2666
2667                 IXMLDOMElement_Release(pElement);
2668             }
2669
2670             /* UI1 */
2671             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI1"), &pElement);
2672             ok(hr == S_OK, "ret %08x\n", hr );
2673             if(hr == S_OK)
2674             {
2675                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2676
2677                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI1") );
2678                 ok(hr == S_OK, "ret %08x\n", hr );
2679
2680                 IXMLDOMElement_Release(pElement);
2681             }
2682
2683             /* UI2 */
2684             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI2"), &pElement);
2685             ok(hr == S_OK, "ret %08x\n", hr );
2686             if(hr == S_OK)
2687             {
2688                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2689
2690                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI2") );
2691                 ok(hr == S_OK, "ret %08x\n", hr );
2692
2693                 IXMLDOMElement_Release(pElement);
2694             }
2695
2696             /* UI4 */
2697             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI4"), &pElement);
2698             ok(hr == S_OK, "ret %08x\n", hr );
2699             if(hr == S_OK)
2700             {
2701                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2702
2703                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI4") );
2704                 ok(hr == S_OK, "ret %08x\n", hr );
2705
2706                 IXMLDOMElement_Release(pElement);
2707             }
2708
2709             /* r4 */
2710             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r4"), &pElement);
2711             ok(hr == S_OK, "ret %08x\n", hr );
2712             if(hr == S_OK)
2713             {
2714                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2715
2716                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r4") );
2717                 ok(hr == S_OK, "ret %08x\n", hr );
2718
2719                 IXMLDOMElement_Release(pElement);
2720             }
2721
2722             /* r8 */
2723             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r8"), &pElement);
2724             ok(hr == S_OK, "ret %08x\n", hr );
2725             if(hr == S_OK)
2726             {
2727                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2728
2729                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r8") );
2730                 ok(hr == S_OK, "ret %08x\n", hr );
2731
2732                 IXMLDOMElement_Release(pElement);
2733             }
2734
2735             /* float */
2736             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_float"), &pElement);
2737             ok(hr == S_OK, "ret %08x\n", hr );
2738             if(hr == S_OK)
2739             {
2740                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2741
2742                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("float") );
2743                 ok(hr == S_OK, "ret %08x\n", hr );
2744
2745                 IXMLDOMElement_Release(pElement);
2746             }
2747
2748             /* uuid */
2749             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_uuid"), &pElement);
2750             ok(hr == S_OK, "ret %08x\n", hr );
2751             if(hr == S_OK)
2752             {
2753                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2754
2755                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UuId") );
2756                 ok(hr == S_OK, "ret %08x\n", hr );
2757
2758                 IXMLDOMElement_Release(pElement);
2759             }
2760
2761             /* bin.hex */
2762             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_hex"), &pElement);
2763             ok(hr == S_OK, "ret %08x\n", hr );
2764             if(hr == S_OK)
2765             {
2766                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2767
2768                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.hex") );
2769                 ok(hr == S_OK, "ret %08x\n", hr );
2770
2771                 IXMLDOMElement_Release(pElement);
2772             }
2773
2774             /* bin.base64 */
2775             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_base64"), &pElement);
2776             ok(hr == S_OK, "ret %08x\n", hr );
2777             if(hr == S_OK)
2778             {
2779                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2780
2781                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.base64") );
2782                 ok(hr == S_OK, "ret %08x\n", hr );
2783
2784                 IXMLDOMElement_Release(pElement);
2785             }
2786
2787             /* Check changing types */
2788             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &pElement);
2789             ok(hr == S_OK, "ret %08x\n", hr );
2790             if(hr == S_OK)
2791             {
2792                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2793
2794                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
2795                 ok(hr == S_OK, "ret %08x\n", hr );
2796
2797                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("string") );
2798                 ok(hr == S_OK, "ret %08x\n", hr );
2799
2800                 IXMLDOMElement_Release(pElement);
2801             }
2802
2803             IXMLDOMElement_Release(pRoot);
2804         }
2805     }
2806
2807     IXMLDOMDocument_Release(doc);
2808
2809     free_bstrs();
2810 }
2811
2812 START_TEST(domdoc)
2813 {
2814     HRESULT r;
2815
2816     r = CoInitialize( NULL );
2817     ok( r == S_OK, "failed to init com\n");
2818
2819     test_domdoc();
2820     test_domnode();
2821     test_refs();
2822     test_create();
2823     test_getElementsByTagName();
2824     test_get_text();
2825     test_get_childNodes();
2826     test_removeChild();
2827     test_XMLHTTP();
2828     test_IXMLDOMDocument2();
2829     test_XPath();
2830     test_cloneNode();
2831     test_xmlTypes();
2832     test_nodeTypeTests();
2833
2834     CoUninitialize();
2835 }